WinHTTP on kenji.blog

Wie man eine Nachricht in Slack mit Slack App + OAuth2 postet

Wed, 16 Jul 2025 23:36:27 +0900

✅ Methode zum Posten mit einem Access Token (Slack Web API)

Das “OAuth Token” (wie xoxb-…) von Slack ist ein Schlüssel, um Nachrichten über die Web API von Slack zu posten. In diesem Fall senden Sie im Gegensatz zu einem Webhook eine POST-Anfrage an den Slack API-Endpunkt mit einem Authorization: Bearer-Header.

🔑 Notwendige Voraussetzungen

Sie müssen chat:write in den OAuth-Scopes der Slack-App aufnehmen:

Einrichtungsprozess

Gehen Sie zu https://api.slack.com/apps
Erstellen Sie eine App oder wählen Sie eine bestehende aus
Unter “OAuth & Permissions” > Scopes → Fügen Sie chat:write hinzu
Klicken Sie auf “Install to Workspace” oder “Reinstall” und holen Sie sich das Access Token (z.B. xoxb-xxxxxxxxxx)

💻 C++ Code (Posten in der Slack API mit WinHTTP)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostSlackMessage(const std::wstring& accessToken, const std::string& channel, const std::string& text) {
 const wchar_t* host = L"slack.com";
 const wchar_t* path = L"/api/chat.postMessage";

 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 if (!hSession) return false;

 HINTERNET hConnect = WinHttpConnect(hSession, host, INTERNET_DEFAULT_HTTPS_PORT, 0);
 if (!hConnect) return false;

 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", path,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 // Authorization-Header und Content-Type
 std::wstring headers = L"Content-Type: application/json\r\n";
 headers += L"Authorization: Bearer " + accessToken + L"\r\n";

 // JSON-Body
 std::string body = R"({"channel":")" + channel + R"(","text":")" + text + R"("})";

 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 (DWORD)-1,
 (LPVOID)body.c_str(),
 body.length(),
 body.length(),
 0);

 if (!result || !WinHttpReceiveResponse(hRequest, NULL)) {
 std::cerr << "Sende-Fehler\n";
 return false;
 }

 // Überprüfung des Statuscodes
 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring token = L"xoxb-dein_access_token"; // Access Token
 std::string channel = "KANAL_ID_oder_#general"; // Z.B.: "#general" oder "C0123456789"
 std::string message = "Test zum Posten in Slack mit C++!";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "Erfolgreich gepostet!\n";
 } else {
 std::cerr << "Posten fehlgeschlagen.\n";
 }

 return 0;
}

📌 Wie man die Kanal-ID erhält

Die alleinige Verwendung des Kanalnamens (z.B. #general) kann zu einem Fehler führen. Die zuverlässige Methode besteht darin, die ID zu verwenden, die in der URL der Slack-Kanalseite steht.

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑Dieser Teil ist die Kanal-ID

✅ Über Token-Arten (Ergänzung)

Token-Format	Verwendung	Beispiel
`xoxb-...`	Bot Token (Empfohlen)	Posten, Bearbeiten, Löschen
`xoxp-...`	User Token (Nicht empfohlen)	Nicht-Bot-bezogene Vorgänge
Refresh Token	Für langfristige Token-Erneuerung	Wird normalerweise nicht verwendet

📝 Zusammenfassung

Um von C++ aus auf Slack zu posten, ist die Methode Slack Web API + Bearer Token zuverlässig
Verwenden Sie den chat.postMessage-Endpunkt mit HTTPS POST
Das Token muss im Bearer-Header gesendet werden
Die Angabe der Kanal-ID ist zuverlässig

Wie man Nachrichten in Slack mit C++ (Win32 API + WinHTTP) postet 【Webhook-Unterstützung】

Wed, 16 Jul 2025 19:42:56 +0900

Wie man Nachrichten in Slack mit C++ (Win32 API + WinHTTP) postet 【Webhook-Unterstützung】

Ich möchte eine Nachricht von C++ an Slack senden. Das ist bei Node.js oder Python sehr üblich, aber Fälle mit „C++ × Win32 API × WinHTTP“ sind eher selten.

In diesem Artikel erkläre ich Schritt für Schritt und leicht verständlich, wie man mithilfe einer Webhook-URL Nachrichten von C++ an Slack sendet .

✅ Gesamtablauf

Um in Slack zu posten, befolgen Sie diese Schritte:

Holen Sie sich die Slack Webhook-URL (API-Schlüssel)
Senden Sie eine POST-Anfrage mit WinHTTP
Erstellen Sie den Nachrichtentext im JSON-Format
Überprüfen Sie das Ergebnis und fertig!

🔑 Schritt 1: So erhalten Sie die Slack Webhook-URL

Mit einer Funktion namens Incoming Webhooks in Slack können Sie ganz einfach Nachrichten von externen Diensten posten.

Schritte zur Beschaffung

Besuchen Sie https://api.slack.com/apps
Klicken Sie auf Create New App
Wählen Sie From scratch, legen Sie den App-Namen fest und wählen Sie den Ziel-Workspace
Wählen Sie im linken Menü “Incoming Webhooks” und aktivieren Sie es
Klicken Sie auf “Add New Webhook to Workspace” und wählen Sie einen Kanal
Kopieren Sie die generierte URL (z. B. https://hooks.slack.com/services/xxx/yyy/zzz)

Diese URL fungiert wie ein API-Schlüssel.

💻 Schritt 2: Nachricht an Slack senden mit C++ Code

Verwendete Technologien

Win32 API
WinHTTP (Standardbibliothek)
Nachricht im JSON-Format

Beispielcode (Slack Post)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82


#include <windows.h>
#include <winhttp.h>
#include <iostream>

#pragma comment(lib, "winhttp.lib")

bool PostToSlack(const std::wstring& webhookUrl, const std::string& messageJson) {
 // URL aufteilen
 URL_COMPONENTS urlComp{};
 wchar_t hostName[256];
 wchar_t urlPath[1024];

 urlComp.dwStructSize = sizeof(urlComp);
 urlComp.lpszHostName = hostName;
 urlComp.dwHostNameLength = _countof(hostName);
 urlComp.lpszUrlPath = urlPath;
 urlComp.dwUrlPathLength = _countof(urlPath);

 if (!WinHttpCrackUrl(webhookUrl.c_str(), 0, 0, &urlComp)) {
 std::wcerr << L"URL konnte nicht aufgeteilt werden\n";
 return false;
 }

 // HTTP-Sitzung und Verbindung
 HINTERNET hSession = WinHttpOpen(L"SlackPoster/1.0",
 WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME,
 WINHTTP_NO_PROXY_BYPASS, 0);
 HINTERNET hConnect = WinHttpConnect(hSession, hostName, urlComp.nPort, 0);
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", urlPath,
 NULL, WINHTTP_NO_REFERER,
 WINHTTP_DEFAULT_ACCEPT_TYPES,
 WINHTTP_FLAG_SECURE);

 std::wstring headers = L"Content-Type: application/json\r\n";
 BOOL result = WinHttpSendRequest(hRequest,
 headers.c_str(),
 -1,
 (LPVOID)messageJson.c_str(),
 messageJson.length(),
 messageJson.length(),
 0);

 if (!result) {
 std::cerr << "Sendeanfrage fehlgeschlagen\n";
 return false;
 }

 WinHttpReceiveResponse(hRequest, NULL);

 DWORD statusCode = 0;
 DWORD size = sizeof(statusCode);
 WinHttpQueryHeaders(hRequest,
 WINHTTP_QUERY_STATUS_CODE | WINHTTP_QUERY_FLAG_NUMBER,
 WINHTTP_HEADER_NAME_BY_INDEX,
 &statusCode, &size, WINHTTP_NO_HEADER_INDEX);

 // Ressourcen freigeben
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring webhookUrl = L"https://hooks.slack.com/services/xxx/yyy/zzz"; // Durch Ihren eigenen Webhook ersetzen

 std::string message = R"({
 "text": "Hello from C++ :rocket:",
 "username": "C++ Bot",
 "icon_emoji": ":robot_face:"
 })";

 if (PostToSlack(webhookUrl, message)) {
 std::cout << "Erfolgreich gepostet!\n";
 } else {
 std::cerr << "Posten fehlgeschlagen.\n";
 }

 return 0;
}

🧪 JSON-Nachricht anpassen

Bei Slack-Webhooks können Sie folgende Parameter einbeziehen:

1
2
3
4
5
6


{
 "text": "Benachrichtigungsinhalt",
 "username": "Bot-Name",
 "icon_emoji": ":rocket:",
 "channel": "#BeliebigerKanalname"
}

📌 Ergänzende Hinweise

Stellen Sie sicher, dass Sie als Content-Type "application/json" angeben
Die Webhook-URL wird direkt als wstring übergeben (URL-Codierung nicht erforderlich)
Da es sich um HTTPS-Kommunikation handelt, vergessen Sie nicht WINHTTP_FLAG_SECURE

🎉 Bonus: Beispiel für eine gepostete Nachricht in Slack

In Slack wird es so angezeigt:

1
2


[C++ Bot]
Hello from C++ :rocket:

✍️ Zusammenfassung

Element	Inhalt
Post-Methode	Webhook (Incoming Webhooks)
Kommunikationsbibliothek	WinHTTP
Datenformat	JSON
Verwendbare Parameter	text, username, icon_emoji, channel usw.

Selbst wenn Sie dachten „Slack-Integration mit C++…?“, können Sie ab heute einen Benachrichtigungs-Bot einbauen!

🚀 Vorschau auf das nächste Mal?

Wenn Sie interessiert sind, zeige ich das nächste Mal:

Datei anhängen
UI mit Buttons
Flexible API-Bedienung mit Slack App + OAuth2

und wir können Ihnen einen weiteren Schritt der Slack-Integration vorstellen!

Wie man Nachrichten von C++ an Microsoft Teams sendet (WinHTTP + Graph API)

Mon, 14 Jul 2025 23:40:15 +0900

Wie man Nachrichten von C++ an Microsoft Teams sendet (WinHTTP + Graph API)

Sie möchten automatisch in einen Microsoft Teams-Chat posten —
In solchen Fällen können Sie die Microsoft Graph API verwenden.
In diesem Artikel stellen wir Schritt für Schritt ein C++-Codebeispiel mit WinHTTP sowie die erforderlichen API-Authentifizierungsschritte vor.

🔧 Notwendige Vorbereitungen (Authentifizierungseinstellungen für die Microsoft Graph API)

1. App im Azure Portal registrieren

Um die Microsoft Graph API nutzen zu können, müssen Sie zunächst eine App in Azure registrieren.

Besuchen Sie das Azure Portal
“Microsoft Entra ID” > "＋ Hinzufügen" > “App-Registrierungen” > “Neue Registrierung”
Geben Sie einen beliebigen App-Namen ein und klicken Sie auf “Registrieren”

2. API-Berechtigungen hinzufügen

Gehen Sie im linken Menü zu “API-Berechtigungen”
Suchen Sie unter “Microsoft Graph” > “Berechtigungen auswählen” nach den folgenden Geltungsbereichen und klicken Sie auf “Berechtigungen aktualisieren”

Chat.ReadWrite
User.Read

※ Wenn Sie in einem Kanal posten möchten, ist auch ChannelMessage.Send erforderlich

3. Client-ID und Mandanten-ID notieren

Notieren Sie sich die folgenden zwei Werte, die auf der Registerkarte “Übersicht” angezeigt werden:

Anwendungs-ID (Client-ID)
Verzeichnis-ID (Mandanten-ID)

4. Einen geheimen Clientschlüssel erstellen

Gehen Sie zur Registerkarte “Zertifikate & Geheimnisse”
“Neuer geheimer Clientschlüssel” > Legen Sie ein Ablaufdatum fest und klicken Sie auf “Hinzufügen”
Notieren Sie sich unbedingt sofort den angezeigten Wert (Geheimnis)

🔐 Zugriffstoken abrufen (OAuth2)

Für den Abruf verwenden wir den Ablauf client_credentials.
Führen Sie den folgenden Befehl mit curl aus, um ein Zugriffstoken zu erhalten.

1
2
3
4
5
6
7


curl -X POST ^
 https://login.microsoftonline.com/{Mandanten-ID}/oauth2/v2.0/token ^
 -H "Content-Type: application/x-www-form-urlencoded" ^
 -d "client_id={Client-ID}" ^
 -d "scope=https%3A%2F%2Fgraph.microsoft.com%2F.default" ^
 -d "client_secret={Geheimer-Clientschlüssel}" ^
 -d "grant_type=client_credentials"

Antwortbeispiel

1
2
3
4
5
6


{
 "token_type":"Bearer",
 "expires_in":3599,
 "ext_expires_in":3599,
 "access_token": "eyJ0eXAiOiJKV1QiLCJub... (Ausgelassen)"
}

Verwenden Sie dieses access_token, um die Microsoft Graph API aufzurufen.

💬 C++-Beispiel zum Posten im Teams-Chat

Hier zeigen wir ein C++-Beispiel, das WinHTTP verwendet, um in einem Chat zu posten.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


#include <windows.h>
#include <winhttp.h>
#include <iostream>
#include <string>

#pragma comment(lib, "winhttp.lib")

void PostToTeamsChat(const std::wstring& accessToken, const std::wstring& chatId, const std::wstring& message) {
 HINTERNET hSession = WinHttpOpen(L"TeamsPoster/1.0", WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
 WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0);

 HINTERNET hConnect = WinHttpConnect(hSession, L"graph.microsoft.com", INTERNET_DEFAULT_HTTPS_PORT, 0);

 std::wstring endpoint = L"/v1.0/chats/" + chatId + L"/messages";
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"POST", endpoint.c_str(), NULL,
 WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_SECURE);

 std::wstring jsonBody = L"{\"body\": {\"content\": \"" + message + L"\"}}";
 std::wstring headers = L"Authorization: Bearer " + accessToken + L"\r\nContent-Type: application/json\r\n";

 BOOL bResult = WinHttpSendRequest(hRequest,
 headers.c_str(), (DWORD)-1L,
 (LPVOID)jsonBody.c_str(), (DWORD)(jsonBody.length() * sizeof(wchar_t)),
 (DWORD)(jsonBody.length() * sizeof(wchar_t)), 0);

 if (bResult)
 WinHttpReceiveResponse(hRequest, NULL);

 DWORD dwSize = 0;
 WinHttpQueryDataAvailable(hRequest, &dwSize);

 if (dwSize > 0) {
 std::wstring response(dwSize / sizeof(wchar_t), 0);
 DWORD dwDownloaded = 0;
 WinHttpReadData(hRequest, &response[0], dwSize, &dwDownloaded);
 std::wcout << L"Response: " << response << std::endl;
 }

 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);
}

int main() {
 std::wstring access;
 std::wstring chatId = L"19:";
 std::wstring message = L"Hello from C++!";
 std::wcout << L"Enter your access token: ";
 std::getline(std::wcin, access);
 std::wcout << L"Enter chat ID: ";
 std::getline(std::wcin, chatId);
 PostToTeamsChat(access, chatId, message);
 return 0;
}

🔍 So erhalten Sie die Chat-ID

Die Chat-ID kann mit GET /v1.0/me/chats überprüft werden.

1
2
3
4


curl -X GET ^
 https://graph.microsoft.com/v1.0/me/chats ^
 -H "Authorization: Bearer {access_token}" ^
 -H "Content-Type: application/json"

Antwortbeispiel

1
2
3
4
5
6
7
8
9


{
 "value": [
 {
 "id": "19:abc123xyz@thread.v2",
 "topic": null,
 "chatType": "oneOnOne"
 }
 ]
}

📌 Wichtige Hinweise

Dieses Beispiel ist eine Minimalimplementierung. Im produktiven Betrieb:
- Behandlung des Token-Ablaufs
- Überprüfung des HTTPS-Zertifikats
- Verbesserte Fehlerbehandlung
Für Kanalbeiträge verwenden Sie teams/{team-id}/channels/{channel-id}/messages.
Das Senden von Anhängen erfordert eine Multipart-Verarbeitung oder die Graph Drive API.

Zusammenfassung

📎 Zusammenfassung

Funktion	Übersicht
Graph API	Offizielle API zur Interaktion mit Teams
App-Registrierung	Notwendiges Authentifizierungsverfahren auf Azure
Zugriffstoken	Wird über OAuth2 abgerufen und für Anfragen verwendet
C++-Implementierung	Ruft die Graph API mithilfe von WinHTTP auf

🚀 Nächste Schritte

Als fortgeschrittenere Beispiele sind auch folgende möglich:

In einen Teamkanal posten (/teams/{team-id}/channels/...)
Beiträge mit Anhängen
Zwischen Bot-Konten und Benutzerkonten wechseln
Vollständige C++-Implementierung einschließlich Token-Abruf

Bitte zögern Sie nicht, einen Kommentar zu hinterlassen, wenn Sie Wünsche haben!