C++ on kenji.blog

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

Sat, 05 Sep 2026 13:04:59 +0900

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

Die “RSA-Verschlüsselung”, die das heutige Internet grundlegend stützt. Ihre Robustheit beruht auf der mathematischen Überzeugung, dass “es für heutige Computer praktisch unmöglich ist, gigantische zusammengesetzte Zahlen in Primfaktoren zu zerlegen”.

Aber die Menschheit hat nie aufgegeben. Gegenwärtig gibt es für klassische Computer (normale Computer, keine Quantencomputer) den ** stärksten und fortschrittlichsten Algorithmus der Menschheit ** zur Durchführung riesiger Primfaktorzerlegungen. Das ist das ** “General Number Field Sieve (GNFS, Allgemeines Zahlkörpersieb)” **.

In diesem Artikel werden wir den gesamten Quellcode einer streng modellierten Implementierung der hochmodernen Berechnungslogik von GNFS in C++ (unter Verwendung von boost::multiprecision für Multipräzisions-Ganzzahlen aus der Boost-Bibliothek) veröffentlichen und die Tiefen der “algebraischen Zahlentheorie”, die dahinter steckt, gründlich erklären.

Bitte genießen Sie das Mysterium der Mathematik und die rohe Kraft der Informatik, die es bezwingt, zusammen mit dem Quellcode.

1. GNFS State-of-the-Art Logik-Framework (Gesamter Quellcode)

Zunächst zeigen wir das vollständige Bild der GNFS-C++-Implementierung, die wir diesmal erläutern. Das eigentliche Zahlkörpersieb (wie CADO-NFS) ist ein riesiges verteiltes System, das in die Hunderttausende von Zeilen geht, aber dieser Code extrahiert die ** “5 wesentlichen Pipelines (Phasen)” ** , die GNFS ausmachen, entwirft sie als Klassen und modelliert sie in einer Minimalkonfiguration, ohne die mathematische Bedeutung zu verlieren.

 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
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// Multipräzisions-Ganzzahlen von Boost.Multiprecision verwenden
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (Allgemeines Zahlkörpersieb) State-of-the-Art Logik-Framework
//
// Dieser Code ist eine strikte Modellierung der 5 Pipelines des hochmodernen GNFS,
// wie es in CADO-NFS usw. verwendet wird, als C++ (Boost) Klassendesign.
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung Algorithmus)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polynom der algebraischen Seite f(x)
 std::vector<cpp_int> g; // Polynom der rationalen Seite g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // Generierung des Initialpolynoms basierend auf der base-m Entwicklung (tatsächlich wird eine fortgeschrittenere Gitterbasisreduktion LLL verwendet)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // Einfache base-m Entwicklung (Grad d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Einfache Näherung für m (Näherung ohne Verwendung von Boost-Funktionen)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (Gittersieb)
// ============================================================================
// Aktuelle GNFS verwenden anstelle des Line Sieve (Liniensieb) das Special-q Lattice Sieving
// (Spezielles q-Gittersieb) von Franke, Kleinjung et al. als De-facto-Standard.
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (Ausgelassen) In Wirklichkeit werden Primzahlen generiert und mit Legendre-Symbolen etc. gefiltert
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // Mock-Implementierung: Das tatsächliche Gittersieb scannt blockweise Hunderte von GB an Speicherraum,
 // ordnet (a, b) Paare Gittern pro spezieller Primzahl q (a = i*q + j*...) zu
 // und führt ein Sieben mit maximaler Cache-Effizienz aus.

 // Füge zu Demonstrationszwecken eine Dummy-Relation hinzu
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (Singularitäten bereinigen und Cliquen zusammenführen)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (Löschen von Relationen mit Primzahlen, die nur einmal vorkommen)
 // 2. Clique merging (Zusammenführen von Relationen, um spärliche Matrizen dicht zu machen)
 // In der Praxis werden hunderte Millionen von Zeilen mit Union-Find-Algorithmen usw. auf einige Millionen komprimiert.
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann Methode)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // In neueren Supercomputer-Umgebungen wird die für verteiltes Rechnen besser geeignete
 // Block Wiedemann Methode (Coppersmith-Implementierung) anstelle der Block Lanczos Methode als State-of-the-Art eingesetzt.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // Iteriert das Produkt von spärlichen Matrizen (Sparse Matrix) und Vektoren,
 // und findet mehrere Lösungsvektoren (Kerne), für die M * x = 0 mod 2 gilt.

 std::vector<std::vector<int>> dependencies; // Liste der Abhängigkeiten
 // Dummy-Daten
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root (Algebraische Quadratwurzel)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. Berechnung der Quadratwurzel V der rationalen Seite (einfache Ganzzahlarithmetik)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Berechnung der Quadratwurzel gamma der algebraischen Seite (Montgomery's Methode etc.)
 // Findet das Element gamma des riesigen algebraischen Körpers O_K und bildet es mit dem Homomorphismus phi auf die reale Welt ab
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Es wird vorausgesetzt, dass in Phase 2 und 4 Folgen von quadratischen Resten (Quadratic Characters) hinzugefügt wurden,
 // um die Hindernisse (Obstructions) der Idealklassengruppe und der Einheitengruppe zu umgehen.

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Die gigantische zusammengesetzte Zahl N, die wir in Primfaktoren zerlegen wollen, z. B. RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Der Grad des Polynoms (bei mehr als 130 Stellen wird normalerweise Grad 5 bis 6 gewählt)
 int degree = 6;

 // Initialisierung der Pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Tatsächliche Schranken (Bounds) liegen bei Dutzenden bis Hunderten von Millionen
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. Polynom-Selektion
 poly_select.select(N);

 // 2. Sieb-Verarbeitung (Sieving)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filterung (Matrixkompression)
 filter.reduce_matrix(relations);

 // 4. Lineare Algebra (Nullraum-Suche über GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Berechnung der algebraischen Quadratwurzel und GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

Nun, wie durchbricht dieser Code die kryptographischen Mauern? Wir werden für jede der 5 Phasen die detaillierten Algorithmen und die fortgeschrittene Mathematik verdaulich erklären.

2. Das ultimative Ziel von GNFS: $X^2 \equiv Y^2 \pmod N$

Das Ziel von GNFS, wie auch den meisten modernen Algorithmen zur gigantischen Primfaktorzerlegung, ist es, ein nicht-triviales Paar $(X, Y)$ zu finden, das die folgende Kongruenz erfüllt:

$$X^2 \equiv Y^2 \pmod N$$

Diese Gleichung bedeutet, dass “die Reste von $X^2$ und $Y^2$, wenn man sie durch $N$ teilt, gleich sind”. Umgeformt ergibt das: $X^2 - Y^2 \equiv 0 \pmod N$ Das heißt, $(X-Y)(X+Y)$ ist ein Vielfaches von $N$.

Wenn $X \not\equiv \pm Y \pmod N$ (eine nicht-triviale Lösung) gilt, gibt es zwischen $(X-Y)$ und $N$ einen “gemeinsamen Teiler größer als 1 und kleiner als $N$”. Wenn wir hier den Euklidischen Algorithmus anwenden, um ** $\gcd(X-Y, N)$ ** zu berechnen, finden wir die Primfaktoren von $N$ sehr leicht.

Jedoch ist die Suche nach diesen $X$ und $Y$ wie die Suche nach der Nadel im Heuhaufen. Daher wählt GNFS den genialen Ansatz, ** “zwei Welten” ** zu erschaffen – die “Welt der realen ganzen Zahlen” und die “Welt der algebraischen Zahlkörper von Polynomen” – und die Berechnungen aufzuteilen.

3. Phase 1: Polynom-Selektion (Polynomial Selection)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Berechnung von m = N^(1/d) und base-m Entwicklung
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

Der erste Schritt von GNFS ist die Schaffung eines “magischen Polynoms”, um die beiden Welten zu überbrücken. Für eine riesige Zahl $N$ wählen wir eine ganze Zahl $m$. Normalerweise wählt man $m \approx N^{1/d}$ (im Code wird ein Polynom $d=6$. Grades angenommen).

Dann entwickeln wir $N$ im $m$-adischen System (Basis $m$) und verwenden die Koeffizienten, um das Polynom $f(x)$ zu konstruieren.

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

Dieses Polynom $f(x)$ hat eine äußerst wichtige Eigenschaft: ** “Wenn man $m$ für die Variable $x$ einsetzt, ergibt es genau $N$ ($f(m) = N$)” **. Mit anderen Worten, $f(m) \equiv 0 \pmod N$. Das Polynom der rationalen Seite ist definiert als $g(x) = x - m$.

Dadurch werden die ** “Welt des algebraischen Zahlkörpers $\mathbb{Z}[\alpha]$” **, die durch die Wurzel $\alpha$ von $f(x)=0$ beherrscht wird, und die gewöhnliche ** “Welt der rationalen Zahlen (ganzen Zahlen) $\mathbb{Z}$” ** durch einen Ringhomomorphismus $x \to m$ fest miteinander verbunden.

In hochmodernen Implementierungen wie CADO-NFS werden Algorithmen wie der KleinJung-Algorithmus oder die LLL-Gitterbasisreduktion verwendet, um monatelang nach dem “absolut besten Polynom $f(x)$” zu suchen, bei dem die Koeffizienten nicht extrem groß werden und in nachfolgenden Schritten leicht Primzahlen auftreten (Smoothness/Glattigkeit begünstigt wird).

4. Phase 2: Spezielles $q$-Gittersieb (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Ordnet (a, b) Paare Gittern pro spezieller Primzahl q zu
 // und führt ein Sieben mit maximaler Cache-Effizienz aus.
 // ...
 }
};

Nachdem die beiden Welten vorbereitet sind, betreten wir den nächsten Schritt: die Suche nach “glatten Zahlen” (Zahlen, die nur aus kleinen Primfaktoren bestehen) in beiden Welten. Wir generieren unzählige ganzzahlige Paare $(a, b)$ und berechnen die folgenden zwei Werte:

** Wert auf der rationalen Seite ** : $a - bm$
** Norm auf der algebraischen Seite ** : $b^d f(a/b)$

Das Ziel von GNFS ist es, zig bis hunderte Millionen ** “Paare (Relationen), bei denen die Werte sowohl der rationalen als auch der algebraischen Seite vollständig in kleine Primfaktoren zerlegt werden können” **, zu sammeln.

In frühen GNFS-Versionen wurde das “Liniensieb (Line Sieve)” verwendet, bei dem die $(a, b)$ auf der $xy$-Ebene aufgereiht und der Reihe nach durch Primzahlen geteilt wurden. Da dies jedoch auf den Speicher überall verstreut zugriff, traten häufig Cache-Misses auf, was es sehr langsam machte.

Deshalb verwenden moderne High-End-Codes die Methode des ** “Speziellen $q$-Gittersiebs (Special-q Lattice Sieve)” **. Man fixiert eine relativ große Primzahl $q$ und berücksichtigt nur Paare $(a, b)$, für die “der algebraische Wert definitiv durch $q$ teilbar ist”. Da die Paare $(a, b)$, die diese Bedingung erfüllen, ein “Gitter (Lattice)” auf der Ebene bilden, ist die Sprungweite der Speicheradressen bei der Berechnung konstant, was perfekt in die L1/L2-Caches der CPUs passt. Die Einführung dieses Gittersiebs hat die Rechengeschwindigkeit von GNFS dramatisch erhöht.

5. Phase 3: Filterung (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (Löschen von Relationen mit Primzahlen, die nur einmal vorkommen)
 // 2. Clique merging (Zusammenführen von Relationen, um spärliche Matrizen dicht zu machen)
 }
};

Computer weltweit haben in Phase 2 über Monate hinweg Hunderte Millionen von Relationen gesammelt. Wenn wir diese jedoch direkt in den nächsten “Schritt zum Lösen von Gleichungssystemen (Matrixberechnung)” werfen, würde selbst der Speicher eines Supercomputers überlaufen.

Daher wird ein extrem starker Matrixkompressionsprozess namens ** Filtering (Filterung) ** durchgeführt.

** Singleton removal (Singularitäten bereinigen) ** Angenommen, eine riesige Primzahl $p$ tritt in Hunderten Millionen Relationen “nur ein einziges Mal” auf. Da es unser Ziel ist, “die Exponenten aller Primzahlen gerade (ein Vielfaches von 2) zu machen”, kann eine Primzahl, die nur einmal auftritt, niemals einen geraden Exponenten erreichen. Daher werden Relationen, die diese Primzahl enthalten, sofort als “nutzloser Müll” gelöscht (bereinigt). Da dies kettenreaktionsartig passiert, werden die Hunderte Millionen Datenzeilen rasant reduziert.
** Clique merging (Cliquen zusammenführen) ** Darüber hinaus werden durch die Kombination (Addition) von Relationen, die bestimmte Primzahlen teilen, die Anzahl der Zeilen reduziert und die spärliche (luftige) Matrix dichter gemacht (es wird ein Ansatz ähnlich der Cliquensuche in der Graphentheorie verwendet).

Durch diese Optimierung wird die gigantische dünnbesetzte Matrix auf eine rechenbare Größe dramatisch komprimiert.

6. Phase 4: Lineare Algebra über GF(2) (Block Wiedemann Methode)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Iteriert das Produkt von spärlichen Matrizen (Sparse Matrix) und Vektoren,
 // und findet mehrere Lösungsvektoren (Kerne), für die M * x = 0 mod 2 gilt.
 }
};

Endlich der Kern des Puzzles. Wir multiplizieren die gesammelten Relationen miteinander, um nach einer ** “Kombination zu suchen, bei der die Exponenten aller Primfaktoren gerade Zahlen werden” **.

Mathematisch gesehen geht es darum, eine riesige Matrix $M$, deren Elemente die Exponenten der Primzahlen (“gerade oder ungerade”, also 0 oder 1) sind, und einen Vektor $x$, der angibt, welche Relationen verwendet werden, zu verwenden, um Lösungsvektoren $x$ (Nullraum / Kern) zu finden, für die gilt: ** $M \cdot x \equiv 0 \pmod 2$ **

Wir müssen ein Gleichungssystem mit einer Matrix von enormer Größe, Millionen von Zeilen × Millionen von Spalten, lösen. Mit der üblichen Gaußschen Elimination wäre die Komplexität $O(N^3)$ und die Berechnung würde nicht enden, bevor das Universum sein Ende findet.

Daher wird in hochmodernen Implementierungen die ** “Block Wiedemann Methode” ** verwendet. Dies ist eine Art Krylov-Unterraum-Methode, die die Tatsache nutzt, dass die Matrix $M$ “sehr spärlich (meistens 0)” ist, und durch wiederholte Multiplikationen von Matrix und Vektoren eine Lösung ableitet. Im Gegensatz zur älteren Block-Lanczos-Methode kann die Block-Wiedemann-Methode den Berechnungsprozess vollständig auf mehrere Cluster aufteilen, wodurch sie bei parallelen Berechnungen im modernen verteilten Cloud-Computing oder auf Supercomputern eine überwältigende Leistung erbringt.

7. Phase 5: Algebraische Quadratwurzel (Algebraic Square Root) und der Zusammenbruch der Kryptographie

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Berechnung der Quadratwurzel V der rationalen Seite
 cpp_int V = 1;

 // 2. Berechnung der Quadratwurzel gamma der algebraischen Seite
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

Durch die Matrixberechnung in Phase 4 haben wir “eine Menge von Relationen $S$, die, miteinander multipliziert, für alle Primfaktoren gerade Exponenten ergeben”, erhalten. Damit können wir in beiden Welten, der rationalen und der algebraischen, ein “Quadrat” konstruieren.

Auf der rationalen Seite ist es nur eine Multiplikation von ganzen Zahlen, daher ist die Berechnung der Quadratwurzel $V$ einfach.

$$V^2 = \prod_{S} (a - bm)$$

** Aber die wahre Hölle liegt auf der “algebraischen Seite”. ** In der Welt des algebraischen Zahlkörpers $\mathbb{Z}[\alpha]$ gilt die Eindeutigkeit der Primfaktorzerlegung nicht, weshalb wir Ideale für die Berechnung verwendet haben. Die Matrixberechnung hat nur garantiert, dass es ** “das Quadrat eines Ideals” ** wird, aber ** nicht, dass es “das Quadrat eines Elements ($\gamma^2$)” wird **.

Hier stellen sich uns immense Hürden aus der algebraischen Zahlentheorie in den Weg: das “Hindernis der Idealklassengruppe” und das “Hindernis der Einheitengruppe”. Um diese Hürden zu überwinden, nutzt GNFS die Magie der ** “Quadratischen Reste (Quadratic Characters)” **. Man fügt der Matrix aus Phase 4 vorab heimlich Spalten mit quadratischen Resten (Legendre-Symbolen) für einige Dutzend spezielle Primideale hinzu. Dadurch überspringt die gefundene Menge $S$ mit überwältigender Wahrscheinlichkeit die Hindernisse und bildet erfolgreich das “Quadrat eines echten Elements $\gamma^2$”.

Der Prozess zur Ermittlung von $\gamma$ (die algebraische Quadratwurzel) verwendet hochkomplexe Algorithmen wie die Montgomery-Methode.

Und schließlich wird die algebraische Quadratwurzel $\gamma$ durch den Ringhomomorphismus $\phi$ in die reale Welt teleportiert ($m$ für $x$ einsetzen), um $Y$ zu erhalten. Wenn wir das rationale $V$ einfach $X$ nennen, ist die ultimative Gleichung endlich komplett.

$$X^2 \equiv Y^2 \pmod N$$

Jetzt müssen wir nur noch $\gcd(X-Y, N)$ berechnen. Sobald dieser 0,001-Sekunden-Prozess durchläuft und die nicht-trivialen Faktoren auf dem Bildschirm gedruckt werden, bricht die so unbezwingbar scheinende RSA-Verschlüsselung vollständig zusammen.

Fazit

GNFS ist nicht nur eine Programmiertechnik. Es ist die Kristallisation der menschlichen Intelligenz, die den “Abgrund der reinen Mathematik” wie abstrakte Algebra, Ringtheorie und Idealklassengruppen mit der “extremen Ingenieurskunst” wie der verteilten Architektur von Supercomputern und der Cache-Optimierung bezwungen hat.

Die Chats oder Kreditkarteninformationen, die wir jeden Tag beiläufig senden, werden durch einen solchen astronomischen mathematischen Schlagabtausch geschützt.

Ich hoffe, Sie konnten durch dieses C++-Framework die “Romantik von Mathematik und Computern”, die hinter modernsten kryptoanalytischen Algorithmen steckt, spüren.

So rufen Sie Microsoft.Windows.AI aus C++ auf

Sat, 19 Jul 2025 10:03:51 +0900

🎯 Aufruf von `Microsoft.Windows.AI` aus C++ [Mit Beispielcode]

Seit Windows 10 verfügt Windows standardmäßig über eine Laufzeitumgebung, die KI-Modelle im ONNX-Format ausführen kann. Das ist Windows ML (Windows.AI.MachineLearning).

In diesem Artikel wird konkret mit Beispielcode erklärt, wie Sie Microsoft.Windows.AI.MachineLearning aus C++ (Win32-App-Basis) aufrufen können.

✅ Vorbereitung

◾ Systemanforderungen

Windows 10 (1809+) oder Windows 11
Visual Studio 2019 oder neuer (Community-Edition ist in Ordnung)
C++/WinRT-Unterstützung (Microsoft.Windows.CppWinRT)
Windows SDK 10.0.17763.0 oder höher

✅ Projektstruktur

Erstellen Sie in Visual Studio ein Projekt mit der folgenden Struktur:

Typ: C++ Windows Desktop-Anwendung (Leeres Projekt)
Subsystem: Windows (WinMain)
Fügen Sie das folgende Paket über NuGet hinzu:
1

Microsoft.Windows.CppWinRT

✅ Beispielcode

Das Folgende ist ein Minimalbeispiel, das WinMain verwendet und die Win32-API mit Windows.AI.MachineLearning kombiniert.

※ Gehen Sie davon aus, dass das verwendete ONNX-Modell model.onnx ist, und legen Sie es im selben Ordner wie die ausführbare Datei ab.

`main.cpp`

 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


#include <windows.h>
#include <winrt/Windows.AI.MachineLearning.h>
#include <winrt/Windows.Storage.h>

#pragma comment(lib, "windowsapp") // Für WinRT-Verknüpfung

using namespace winrt;
using namespace Windows::AI::MachineLearning;
using namespace Windows::Storage;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
 // WinRT-Initialisierung (MTA oder STA ist in Ordnung)
 winrt::init_apartment();

 try {
 // Modelldatei laden
 auto modelFile = StorageFile::GetFileFromPathAsync(L"model.onnx").get();
 LearningModel model = LearningModel::LoadFromStorageFileAsync(modelFile).get();

 // Sitzung erstellen
 LearningModelSession session(model);
 LearningModelBinding binding(session);

 // Modellein- und -ausgabe (hier vorübergehend leere Eingabe)
 // In der Praxis ist eine Bindung z.B. mit TensorFloat erforderlich

 // Inferenz ausführen
 auto result = session.EvaluateAsync(binding, L"").get();

 MessageBox(nullptr, L"Inferenz abgeschlossen", L"Windows ML (C++)", MB_OK);
 }
 catch (winrt::hresult_error const& ex) {
 MessageBox(nullptr, ex.message().c_str(), L"Fehler", MB_ICONERROR);
 }

 return 0;
}

✅ Ergänzung: Wie man Eingabe- und Ausgabe-Tensoren angibt

Je nach Modell ist es erforderlich, vor der Inferenz Tensoren zu erstellen und zu binden.

Beispiel:

1
2
3
4
5
6
7
8


// 1D-Float-Array in Tensor umwandeln
std::vector<float> inputData = {0.5f, 0.3f, 0.2f};
std::vector<int64_t> shape = {1, 3}; // Form: [1, 3]

auto tensor = TensorFloat::CreateFromArray(shape, inputData);

// Eingabebindung (muss mit dem Eingabenamen des Modells übereinstimmen)
binding.Bind(L"input_0", tensor);

Die Ausgabe kann auf ähnliche Weise mit result.Outputs().Lookup(L"output_0") abgerufen werden.

✅ Hinweise zum Debuggen

Wenn die Modelldatei nicht im Ausführungsordner vorhanden ist, wird eine FileNotFoundException ausgelöst.
Wenn die Eingabe-/Ausgabenamen nicht übereinstimmen, tritt ein invalid_argument-Fehler auf.
Die genauen IO-Spezifikationen des Modells können mit Tools wie Netron überprüft werden.

✅ Zusammenfassung

Element	Inhalt
Verwendete API	Windows.AI.MachineLearning (WinRT)
Sprache	C++ (Win32-Basis)
Empfohlene Methode	Über C++/WinRT-Header
Vorteile	ONNX-Modelle laufen nativ, GPU-Unterstützung ist ebenfalls möglich
Vorsicht	Achten Sie auf die Eingabenamen des Modells und die Tensorformen

✅ Alternative: Für diejenigen, die WinRT nicht verwenden möchten

Durch die Verwendung der ONNX Runtime von Microsoft können Sie ONNX-Modelle vollständig ohne WinRT aus C++ heraus behandeln.
Es ist plattformübergreifend, was gemeinsamen Code auf Windows/Linux ermöglicht.

📌 Fazit

Windows ML (Microsoft.Windows.AI) ist eine leistungsstarke KI-Inferenz-Engine, die robust von C++ aus verwendet werden kann. Wenn Sie native Inferenzen auf Windows benötigen, probieren Sie es aus.

Wenn Sie konkrete Beispiele für die Erstellung von ONNX-Modellen und das Tensor-Binding wünschen, wird dies in einem kommenden Artikel behandelt!

Schritte, um TinyLLaMA aus C++ aufzurufen (unter Verwendung von llama.cpp)

Sat, 19 Jul 2025 09:40:53 +0900

✅ Einrichtung von TinyLLaMA × C++ (mit `llama.cpp`)

🔧 Schritt 1: llama.cpp vorbereiten

1-1. Erforderliche Umgebung (Minimum)

OS: Windows / Linux / macOS
Entwicklungsumgebung: g++ / clang / MSVC
Git / CMake

1-2. llama.cpp abrufen und kompilieren

1
2
3
4
5
6


git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
mkdir build
cd build
cmake ..
cmake --build . --config Release

Unter Windows ist es am einfachsten, die Visual Studio Developer Command Prompt mit cmake --build . --config Release zu verwenden.

📦 Schritt 2: TinyLLaMA-Modell herunterladen und konvertieren

2-1. Originalmodell von HuggingFace beziehen

Beispiel: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# Falls erforderlich, transformers zum Herunterladen verwenden
pip install transformers huggingface_hub

python3 -m transformers.models.llama.convert_llama_weights_to_hf \
 --input_dir ./TinyLlama-1.1B-Chat \
 --model_size 1B \
 --output_dir ./hf_model

Dies ist der Schritt zur Konvertierung in das Hugging Face-Format.

2-2. In das GGUF-Format konvertieren (für `llama.cpp`)

1
2


cd llama.cpp
python3 convert.py ./hf_model --outfile tinyllama.gguf

2-3. Modellquantisierung (Größenreduzierung)

1

./quantize ./tinyllama.gguf ./tinyllama-q4.gguf q4_0

q4_0 steht für 4-Bit-Quantisierung. Die Modellgröße schrumpft auf etwa ** 350MB ** .

🧪 Schritt 3: Das Modell aus C++ aufrufen (Codebeispiel)

3-1. Einfacher C++-Code (Inferenz)

 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


#include "llama.h"
#include <iostream>

int main() {
 llama_model_params model_params = llama_model_default_params();
 llama_context_params ctx_params = llama_context_default_params();

 llama_model *model = llama_load_model_from_file("tinyllama-q4.gguf", model_params);
 llama_context *ctx = llama_new_context_with_model(model, ctx_params);

 std::string prompt = "Der Benutzer sagt, dass er Excel-Daten laden, filtern und speichern möchte. Wie sieht die Knotenkonfiguration aus?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // Tokenisierung
 std::vector<llama_token> tokens(prompt.size() + 8);
 int n = llama_tokenize(model, prompt.c_str(), tokens.data(), tokens.size(), true);
 tokens.resize(n);

 for (size_t i = 0; i < tokens.size(); ++i) {
 batch.token[i + 1] = tokens[i];
 }

 batch.n_tokens = tokens.size() + 1;
 llama_decode(ctx, batch);

 // Inferenz-Ergebnis abrufen
 for (int i = 0; i < 50; ++i) {
 llama_token next = llama_sample_token(ctx, nullptr);
 std::cout << llama_token_to_str(model, next);
 llama_batch next_batch = llama_batch_init(1, 0, 1);
 next_batch.token[0] = next;
 next_batch.n_tokens = 1;
 llama_decode(ctx, next_batch);
 }

 llama_free(ctx);
 llama_free_model(model);
 return 0;
}

🧱 Schritt 4: Kompilierungsmethode (Beispiel)

1

g++ -I./llama.cpp main.cpp ./llama.cpp/build/libllama.a -o tiny_infer -pthread -std=c++11

libllama.a wird nach der Erstellung im Verzeichnis build/ generiert.

✅ Beispiel für die Struktur der Artefakte (Organisation)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # Quantisiertes Modell (~350MB)
├── main.cpp # Obiger C++-Code
├── llama.cpp/ # llama.cpp-Quellcode
└── build/
 └── libllama.a # Kompilierte Bibliothek

🧠 Zusätzliche Hinweise zur Anwendung auf Anwendungsfälle

Code in C++ einbauen, um die Ausgabe entgegenzunehmen und Knoten-Templates abzugleichen/auszuwählen.
Beispiel: Wenn “Excel”, “Filter”, “Speichern” enthalten sind → entsprechende Knotengruppen generieren.
Dieser Teil kann mit einer einfachen Struktur wie if-Anweisungen + Laden von JSON-Vorlagen umgesetzt werden.

📌 Zusammenfassung

Element	Beschreibung
Empfohlenes Modell	TinyLLaMA-1.1B-Chat v1.0 (GGUF + Quantisierung)
Größe	~350 bis 450MB (4-Bit-Quantisierung)
C++-Integration	Möglich durch `llama.cpp`, fast keine externen Abhängigkeiten
Verarbeitungsleistung	Ausreichend für einfache Intentionserkennung und Satzgenerierung (Natürliche Sprache → Struktur)
Erweiterbarkeit	Kann durch Kombination mit Slot-Filling und Template-Aufrufen zu einer KI für Knotengenerierung werden

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!

Vor- und Nachteile der Programmerstellung mit Win32API + C++

Sat, 12 Jul 2025 12:30:35 +0900

Der Reiz und die Herausforderungen der Entwicklung mit Win32API + C++

Für diejenigen, die die Windows-App-Entwicklung meistern möchten, ist Win32API + C++ nach wie vor eine leistungsstarke Option. Diese Kombination, die die engstmögliche Interaktion mit dem Betriebssystem ermöglicht, bietet sowohl Geschwindigkeit als auch Flexibilität.

Andererseits erfordert die Beherrschung Entschlossenheit, da sie sich erheblich von modernen Entwicklungsstilen unterscheidet.

Auf dieser Seite werden wir die Vor- und Nachteile aus der Perspektive eines aktiven Windows-App-Entwicklers klar erläutern.

Vorteile

Ultraschnelle Native Ausführung

Da C++ und Win32API auf der Schicht operieren, die dem Betriebssystem am nächsten ist, gibt es fast keinen unnötigen Overhead. Die CPU- und Speichernutzung ist äußerst effizient und bietet eine überwältigende Ausführungsgeschwindigkeit .

Hohe Flexibilität und Freiheit

Sie können das gesamte App-Verhalten selbst fein steuern , wie z. B. Fenstersteuerung, asynchrone Verarbeitung, COM-Integration und Prozessverwaltung. Es ist auch möglich, spezialisierte Tools und eigene originelle Frameworks zu erstellen.

Einfach zu Verteilen Ohne Laufzeitbedarf

Da keine externen Laufzeitumgebungen wie .NET oder Java erforderlich sind, kann es als einzelne ausführbare Datei verteilt werden . Es ist weniger anfällig für Probleme bei der Neuverteilung und lässt sich ohne Installationsprogramm leicht ausführen.

Kann Leichtgewichtige Apps Erstellen

Da es nur die absolut notwendige Konfiguration erfordert, ist seine Eigenschaft ein sehr geringer Speicherbedarf . Es läuft auch auf leistungsschwachen PCs oder in virtuellen Maschinenumgebungen komfortabel.

Fortgeschrittene Steuerung auf Betriebssystemebene Möglich

Sie können auch Steuerungen realisieren, die mit normalen Sprachen und Bibliotheken schwierig sind , wie z. B. globale Maus- und Tastatur-Hooks, Feinabstimmung von Fensterstilen und Systemmenüoperationen.

Nachteile

Geringe Entwicklungseffizienz

Selbst der Aufbau der GUI muss vollständig in Code erfolgen, und manchmal sind Dutzende Zeilen Code erforderlich, nur um eine einzige Schaltfläche zu erstellen . Das Ändern des Designs ist ebenfalls kompliziert, und die Produktivität ist im Vergleich zur Entwicklung mit UI-Frameworks geringer.

Leicht Verringerte Wartbarkeit

Es gibt viele Codes mit speziellen Strukturen , wie z. B. Nachrichtenschleifen und Fensterprozeduren, was die Lesbarkeit und Wiederverwendbarkeit beeinträchtigt. Es hat auch Aspekte, die für die Teamentwicklung und die langfristige Wartung ungeeignet sind.

Schwierige Unterstützung Moderner UI

Es ist schwierig, die in den letzten Jahren geforderte UX zu unterstützen , wie z. B. High-DPI-Unterstützung, Touch-Interfaces, Barrierefreiheit und Dark Mode. Sie müssen jede manuell behandeln, was viel Mühe erfordert.

Keine Plattformübergreifende Unterstützung

Da es sich um eine vollständig Windows-exklusive API handelt, kann es nicht auf macOS oder Linux portiert werden . Wenn Sie eine plattformübergreifende Bereitstellung planen, müssen Sie andere Technologien auswählen.

Extrem Hohe Lernkosten

Sie müssen Konzepte und Mechanismen verstehen, die heute selten verwendet werden , wie z. B. Handles, GDI, COM und OLE. Viele Dokumente sind alt und erfordern Zeit und Geduld zum Lernen.

Geeignete Anwendungen

Leichtgewichtige Tools wie Datei-Launcher und Hotkey-Unterstützer
Systemdienstprogramme wie Zwischenablagenmanipulation und IME-Steuerung
Native steuerungsbasierte Apps wie globale Hooks und Fenstererfassung
Treiber-Support-Tools , die eng mit der Hardware verbunden sind

Ungeeignete Anwendungen

Allgemeine Verbraucher-Apps , bei denen moderne UI / UX wichtig sind
Prototyping und MVP-Entwicklung , die mit Blick auf Geschwindigkeit erstellt wurden
Großprojekte , die auf langfristigem Betrieb und Teamentwicklung basieren
Plattformübergreifende Produkte , die mehrere Betriebssysteme unterstützen müssen

Bewertungszusammenfassung

Standpunkt	Bewertung
Ausführungsgeschwindigkeit	◎ Sehr Schnell
Speichereffizienz	◎ Hervorragend
Entwicklungsgeschwindigkeit	× Langsam
Wartbarkeit	× Gering
Plattformübergreifende Unterstützung	× Nicht Unterstützt
Moderne UI-Unterstützung	× Schwach
Freiheit der OS-Steuerung	◎ Überwältigend Hoch

Fazit

Win32API + C++ ist ein Werkzeug für Entwickler, die “alles im Betriebssystem selbst handhaben wollen”. Während seine Leistung immens ist, erfordern Lernen und Betrieb eine entsprechende Entschlossenheit.

Ob es sich lohnt, “mutig zu wählen”, hängt von der Art der App ab, die Sie anstreben.

In die Welt von #include <windows.h> einzutauchen, ohne sich auf GUI-Frameworks oder moderne Sprachen zu verlassen ―― Diese Entscheidung ist auch heute noch sinnvoll.

【Für Anfänger】Schritte zur Installation von libcurl (mit OpenSSL-Unterstützung) in Visual Studio mit vcpkg

Mon, 07 Jul 2025 21:46:08 +0900

Wenn Sie libcurl (mit OpenSSL-Unterstützung) in Visual Studio verwenden möchten, ist die Installation von vcpkg einfach und empfehlenswert

Wenn es darum geht, HTTP-Kommunikation in C++ zu behandeln, wird oft libcurl verwendet. Aber das Kompilieren und Anpassen von Abhängigkeiten ist überraschend mühsam, nicht wahr?

In solchen Fällen ist das C++-Bibliotheksverwaltungstool von Microsoft, ** “vcpkg” ** , sehr nützlich. Dieses Mal stellen wir die Schritte von der Einführung von libcurl (OpenSSL-kompatibel) mit cpkg bis hin zur reibungslosen Nutzung in Visual Studio vor.

Installation von vcpkg (nur für diejenigen, die es noch nicht installiert haben)

Lassen Sie uns zuerst cpkg installieren. Bitte führen Sie die folgenden Schritte in PowerShell aus.

powershell git clone https://github.com/microsoft/vcpkg cd vcpkg .ootstrap-vcpkg.bat

※Wenn Git noch nicht installiert ist, installieren Sie es bitte von der Offiziellen Git-Website.

Installation von libcurl (OpenSSL-kompatibel)

Als Nächstes verwenden wir vcpkg, um libcurl zu installieren. Um die 64-Bit-Version mit OpenSSL-Unterstützung anzugeben, führen Sie den folgenden Befehl aus.

powershell vcpkg install curl[ssl] --triplet x64-windows

Wenn Sie diesen Befehl ausführen, werden notwendige Abhängigkeiten (wie OpenSSL) automatisch mit eingerichtet.

Integrationseinstellungen für Visual Studio

Um die mit vcpkg eingeführten Bibliotheken einfach in Ihrem Visual Studio-Projekt verwenden zu können, konfigurieren Sie die Integrationseinstellungen mit dem folgenden Befehl.

powershell vcpkg integrate install

Sobald dies eingerichtet ist, steht #include <curl/curl.h> in Visual Studio-Projekten automatisch zur Verfügung, und Sie müssen Bibliothekspfade oder Linker-Einstellungen nicht mehr manuell vornehmen.

Fazit

Damit ist die Vorbereitung zur Einführung von libcurl (OpenSSL-kompatibel) in Visual Studio abgeschlossen.

Mit vcpkg können Sie mühsame Abhängigkeiten auf einmal verwalten
Installieren Sie libcurl ganz einfach mit cpkg install curl[ssl] –triplet x64-windows
Eine automatische Integration mit Visual Studio ist mit cpkg integrate install möglich

Jetzt müssen Sie nur noch den Header in Ihr Projekt einbinden und die libcurl-API verwenden, um mit der Entwicklung zu beginnen. Nutzen Sie das praktische vcpkg, um Ihre Entwicklungseffizienz auf einen Schlag zu steigern.

Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL

Wed, 16 Apr 2025 01:58:03 +0900

🎯 Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL (Visual Studio 2022 / C++)

✅ Gesamtarchitektur

🔹 ① CLI-Wrapper-DLL (C++/CLI)

Stellt die Funktionalität zum Ausführen von PowerShell-Skripten bereit.

🔹 ② Nativer C++-Aufrufer

Ruft die CLI-DLL auf, um das PowerShell-Skript auszuführen.

🔧 Schritt 1: Erstellen des CLI-Wrapper-DLL-Projekts

1. Projekt erstellen

[Neues Projekt erstellen] → [C++] → CLR-Klassenbibliothek (.NET Framework)
Name: PowerShellWrapper

💡 Wenn diese Vorlage nicht angezeigt wird, installieren Sie die Workload “.NET-Desktopentwicklung”.

2. NuGet-Paket hinzufügen

Rechtsklick auf das Projekt → [NuGet-Pakete verwalten]
Suchen und installieren Sie System.Management.Automation
(Version 5.x oder 7.x)

3. Implementierung des CLI-Codes

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 Schritt 2: Aufruf aus nativem C++

1. Erstellen des C++-Konsolen-App-Projekts

Name: NativeApp

2. Referenzeinstellungen

Rechtsklick auf das Projekt → [Hinzufügen] → [Referenz] → Projekte → PowerShellWrapper hinzufügen
[Konfigurationseigenschaften] → [C/C++] → [Common Language Runtime-Unterstützung] → Ändern in /clr

3. Ausführungscode (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 Zusätzliche Informationen (IDL / TLB / COM-Registrierung)

Diese Konfiguration verweist direkt auf die .NET-DLL anstelle von COM, daher ist keine IDL-, TLB- oder COM-Registrierung erforderlich .

✅ Endgültige Architektur

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → DLL-Aufruf

Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL

Wed, 16 Apr 2025 01:58:03 +0900

🎯 Schritte zum Ausführen von PowerShell aus C++ über eine C++/CLI-DLL (Visual Studio 2022 / C++)

✅ Gesamtarchitektur

🔹 ① CLI-Wrapper-DLL (C++/CLI)

Stellt die Funktionalität zum Ausführen von PowerShell-Skripten bereit.

🔹 ② Nativer C++-Aufrufer

Ruft die CLI-DLL auf, um das PowerShell-Skript auszuführen.

🔧 Schritt 1: Erstellen des CLI-Wrapper-DLL-Projekts

1. Projekt erstellen

[Neues Projekt erstellen] → [C++] → CLR-Klassenbibliothek (.NET Framework)
Name: PowerShellWrapper

💡 Wenn diese Vorlage nicht angezeigt wird, installieren Sie die Workload “.NET-Desktopentwicklung”.

2. NuGet-Paket hinzufügen

Rechtsklick auf das Projekt → [NuGet-Pakete verwalten]
Suchen und installieren Sie System.Management.Automation
(Version 5.x oder 7.x)

3. Implementierung des CLI-Codes

PowerShellWrapper.h

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


#pragma once

using namespace System;

namespace PowerShellWrapper {
 public ref class PowerShellExecutor {
 public:
 String^ Execute(String^ script);
 };
}

PowerShellWrapper.cpp

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


#include "PowerShellWrapper.h"
using namespace System;
using namespace System::Management::Automation;
using namespace System::Collections::ObjectModel;

String^ PowerShellWrapper::PowerShellExecutor::Execute(String^ script)
{
 PowerShell^ ps = PowerShell::Create();
 ps->AddScript(script);
 Collection<PSObject^>^ results = ps->Invoke();

 System::Text::StringBuilder^ sb = gcnew System::Text::StringBuilder();
 for each (PSObject^ result in results)
 {
 sb->AppendLine(result->ToString());
 }

 return sb->ToString();
}

🔧 Schritt 2: Aufruf aus nativem C++

1. Erstellen des C++-Konsolen-App-Projekts

Name: NativeApp

2. Referenzeinstellungen

Rechtsklick auf das Projekt → [Hinzufügen] → [Referenz] → Projekte → PowerShellWrapper hinzufügen
[Konfigurationseigenschaften] → [C/C++] → [Common Language Runtime-Unterstützung] → Ändern in /clr

3. Ausführungscode (main.cpp)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


#using <System.dll>
#using "..\\PowerShellWrapper\\Debug\\PowerShellWrapper.dll"

using namespace System;
using namespace PowerShellWrapper;

int main()
{
 PowerShellExecutor^ executor = gcnew PowerShellExecutor();
 String^ result = executor->Execute("Get-Process | Select-Object -First 1");
 Console::WriteLine(result);
 return 0;
}

💡 Zusätzliche Informationen (IDL / TLB / COM-Registrierung)

Diese Konfiguration verweist direkt auf die .NET-DLL anstelle von COM, daher ist keine IDL-, TLB- oder COM-Registrierung erforderlich .

✅ Endgültige Architektur

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → DLL-Aufruf

Wie man die aktuelle Zeit im ISO 8601 Format in C++ ausgibt

Sat, 15 Apr 2023 19:35:27 +0900

Voraussetzungen

ISO C++ 20 Standard (/std:c++20)

Code

1
2
3
4


#include <chrono>
#include <format>

std::string datetime = std::format("{:%FT%TZ}", system_clock::now());

So können Sie die aktuelle Zeit im ISO 8601 Format in C++ ausgeben.

Referenzen

std::format

Wie man OpenSSL unter Windows kompiliert

Fri, 07 Apr 2023 21:06:32 +0900

Was ist OpenSSL?

Es ist eine Open-Source-Bibliothek, die die notwendige Verarbeitung für verschlüsselte Kommunikation bereitstellt.

Um es in einem Programm verwenden zu können, müssen Sie es kompilieren, um eine Bibliothek zu erstellen, da der C-Quellcode veröffentlicht wird.

Nachfolgend stellen wir den Kompilierungsvorgang vor.

Vorbereitung der Build-Umgebung

Perl

Laden Sie strawberry-perl-5.32.1.1-64bit.msi von https://strawberryperl.com/ herunter. Die neueste Version sollte in Ordnung sein.
NASM

Laden Sie 2.16.01/nasm-2.16.01-win64.zip unter Download von https://www.nasm.us/ herunter. Die neueste Non-RC-Version sollte in Ordnung sein. Nach der Installation müssen Sie den Ordner, in dem NASM installiert ist, in der Umgebungsvariablen PATH registrieren.
Visual Studio 2022 oder Build Tools for Visual Studio 2022

Installieren Sie Visual Studio 2022 Community oder Build Tools for Visual Studio 2022 von https://visualstudio.microsoft.com/ja/downloads/.

OpenSSL-Build-Prozedur unter Windows

Laden Sie openssl-3.1.0.tar.gz von https://www.openssl.org/source/ herunter und entpacken Sie es. Wenn Sie es nicht entpacken können, führen Sie tar -xzf openssl-3.1.0.tar.gz in der Eingabeaufforderung aus.
Starten Sie die Eingabeaufforderung mit Administratorrechten.
Öffnen Sie den entpackten Ordner.
Führen Sie den folgenden Befehl aus. *Ändern Sie den Teil Community, damit er Ihrer installierten Version von Visual Studio entspricht.

1

"C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvarsall.bat" x64

Führen Sie den folgenden Befehl aus:

1

perl Configure VC-WIN64A

Führen Sie den folgenden Befehl aus (dauert ziemlich lange):

1

nmake

Führen Sie den folgenden Befehl aus (dauert ziemlich lange):

1

nmake test

Führen Sie den folgenden Befehl aus:

1

nmake install

Wenn es erfolgreich war, wird OpenSSL in C:\Program Files\OpenSSL installiert.

Das ist alles.

Referenzen

https://ja.wikipedia.org/wiki/OpenSSL

C++ on kenji.blog

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

1. GNFS State-of-the-Art Logik-Framework (Gesamter Quellcode)

2. Das ultimative Ziel von GNFS: $X^2 \equiv Y^2 \pmod N$

3. Phase 1: Polynom-Selektion (Polynomial Selection)

4. Phase 2: Spezielles $q$-Gittersieb (Special-q Lattice Sieving)

5. Phase 3: Filterung (Filtering)

6. Phase 4: Lineare Algebra über GF(2) (Block Wiedemann Methode)

7. Phase 5: Algebraische Quadratwurzel (Algebraic Square Root) und der Zusammenbruch der Kryptographie

Fazit

So rufen Sie Microsoft.Windows.AI aus C++ auf

🎯 Aufruf von Microsoft.Windows.AI aus C++ [Mit Beispielcode]

✅ Vorbereitung

◾ Systemanforderungen

✅ Projektstruktur

✅ Beispielcode

main.cpp

✅ Ergänzung: Wie man Eingabe- und Ausgabe-Tensoren angibt

✅ Hinweise zum Debuggen

✅ Zusammenfassung

✅ Alternative: Für diejenigen, die WinRT nicht verwenden möchten

📌 Fazit

Schritte, um TinyLLaMA aus C++ aufzurufen (unter Verwendung von llama.cpp)

✅ Einrichtung von TinyLLaMA × C++ (mit llama.cpp)

🔧 Schritt 1: llama.cpp vorbereiten

1-1. Erforderliche Umgebung (Minimum)

1-2. llama.cpp abrufen und kompilieren

📦 Schritt 2: TinyLLaMA-Modell herunterladen und konvertieren

2-1. Originalmodell von HuggingFace beziehen

2-2. In das GGUF-Format konvertieren (für llama.cpp)

2-3. Modellquantisierung (Größenreduzierung)

🧪 Schritt 3: Das Modell aus C++ aufrufen (Codebeispiel)

3-1. Einfacher C++-Code (Inferenz)

🧱 Schritt 4: Kompilierungsmethode (Beispiel)

✅ Beispiel für die Struktur der Artefakte (Organisation)

🧠 Zusätzliche Hinweise zur Anwendung auf Anwendungsfälle

📌 Zusammenfassung

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

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

🔑 Notwendige Voraussetzungen

Einrichtungsprozess

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

📌 Wie man die Kanal-ID erhält

✅ Über Token-Arten (Ergänzung)

📝 Zusammenfassung

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

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

✅ Gesamtablauf

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

Schritte zur Beschaffung

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

Verwendete Technologien

Beispielcode (Slack Post)

🧪 JSON-Nachricht anpassen

📌 Ergänzende Hinweise

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

✍️ Zusammenfassung

🚀 Vorschau auf das nächste Mal?

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

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

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

1. App im Azure Portal registrieren

2. API-Berechtigungen hinzufügen

3. Client-ID und Mandanten-ID notieren

4. Einen geheimen Clientschlüssel erstellen

🔐 Zugriffstoken abrufen (OAuth2)

Antwortbeispiel

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

🔍 So erhalten Sie die Chat-ID

Antwortbeispiel

📌 Wichtige Hinweise

Zusammenfassung

📎 Zusammenfassung

🚀 Nächste Schritte

Vor- und Nachteile der Programmerstellung mit Win32API + C++

Der Reiz und die Herausforderungen der Entwicklung mit Win32API + C++

Vorteile

Ultraschnelle Native Ausführung

Hohe Flexibilität und Freiheit

🎯 Aufruf von `Microsoft.Windows.AI` aus C++ [Mit Beispielcode]

`main.cpp`

✅ Einrichtung von TinyLLaMA × C++ (mit `llama.cpp`)

2-2. In das GGUF-Format konvertieren (für `llama.cpp`)