C++ on kenji.blog

[Análisis completo] Implementando y entendiendo el algoritmo de descifrado más fuerte 'GNFS' en C++

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

【Análisis Completo】Entendiendo el algoritmo de descifrado más fuerte “GNFS” implementándolo en C++

El cifrado “RSA” es la base que sostiene la Internet moderna. Su robustez depende de la creencia matemática de que “factorizar un número compuesto gigante en números primos es virtualmente imposible con las computadoras actuales”.

Sin embargo, la humanidad nunca se rinde. Actualmente, existe el **algoritmo más fuerte y avanzado de la humanidad ** para realizar factorizaciones gigantescas en computadoras clásicas (computadoras normales, no cuánticas). Este es el “General Number Field Sieve (GNFS) o Criba General del Cuerpo de Números”.

En este artículo, publicaremos todo el código de implementación que modela estrictamente la lógica computacional más avanzada de GNFS en C++ (usando enteros de precisión múltiple boost::multiprecision de la biblioteca Boost), y explicaremos a fondo los abismos de la “teoría algebraica de números” detrás de él.

Por favor, disfruten del misterio de las matemáticas y del poder de la ciencia computacional que lo domina, junto con el código fuente.

1. GNFS Framework Lógico de Vanguardia (Código fuente completo)

Primero, aquí está la visión general de la implementación de GNFS en C++ que explicaremos. La criba de cuerpo de números real (como CADO-NFS) es un sistema distribuido masivo de cientos de miles de líneas de código, pero este código diseña y modela las “5 tuberías (fases) esenciales” que componen GNFS en clases, manteniéndolo en una configuración mínima sin perder su significado matemático.

 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>

// Usando enteros de precisión múltiple de Boost.Multiprecision
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (Criba General del Cuerpo de Números) Framework Lógico de Vanguardia
//
// Este código modela estrictamente las 5 tuberías del GNFS más avanzado utilizado en CADO-NFS, etc.,
// como diseño de clases en C++ (Boost).
// ============================================================================

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

// ============================================================================
// Fase 1: Selección Polinomial (Algoritmo de KleinJung)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polinomio lado algebraico f(x)
 std::vector<cpp_int> g; // Polinomio lado racional g(x) = x - m
 cpp_int m;

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

 // Generación del polinomio inicial basado en expansión en base m (En realidad se usa reducción de bases de retículos LLL más avanzada)
 void select(const cpp_int& N) {
 std::cout << "[Fase 1] Polynomial Selection (Grado " << degree << ") iniciando..." << std::endl;
 // Expansión simple en base m (grado d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Aproximación simple de m (sin usar funciones de Boost)
 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[Fase 1] Completo." << std::endl;
 }
};

// ============================================================================
// Fase 2: Lattice Sieving (Criba de Retículos)
// ============================================================================
// En el GNFS moderno, el estándar de facto no es Line Sieve (Criba Lineal), sino
// la Criba de Retículos q-Especial (Special-q Lattice Sieving) de Franke-Kleinjung y otros.
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 << "[Fase 2] Generando Factor Bases (Límite Racional: " << rational_bound << ", Límite Algebraico: " << algebraic_bound << ")" << std::endl;
 // (Omitido) En realidad realiza generación de primos y filtrado con el símbolo de Legendre, etc.
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Fase 2] Special-q Lattice Sieving activo..." << std::endl;
 std::vector<Relation> relations;
 // Implementación Mock: La criba de retículos real escanea cientos de GB de espacio de memoria en bloques,
 // mapea pares (a, b) a retículos para cada primo especial q (a = i*q + j*...),
 // y ejecuta un sieving (criba) maximizando la eficiencia de la caché al extremo.

 // Añadiendo una relación dummy para la demo
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Fase 2] Encontradas " << relations.size() << " relaciones." << std::endl;
 return relations;
 }
};

// ============================================================================
// Fase 3: Filtering (Purga de singletons y mezcla de cliques)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Fase 3] Filtrando Relaciones..." << std::endl;
 // 1. Eliminación de Singletons (eliminación de relaciones con primos que aparecen solo 1 vez)
 // 2. Fusión de Cliques (combinación de relaciones para hacer densa una matriz dispersa)
 // En realidad, comprime una matriz de cientos de millones de filas a unos pocos millones usando algoritmos como Union-Find.
 std::cout << "[Fase 3] Tamaño de la matriz reducido óptimamente." << std::endl;
 }
};

// ============================================================================
// Fase 4: Álgebra Lineal sobre GF(2) (Método Block Wiedemann)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // En los entornos de supercomputadoras recientes, se utiliza como vanguardia el método Block Wiedemann
 // (implementación de Coppersmith) que es más adecuado para computación distribuida que el método Block Lanczos.
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Fase 4] Algoritmo Block Wiedemann sobre GF(2) iniciando..." << std::endl;
 // Repite la operación de producto de matrices dispersas y vectores,
 // y encuentra múltiples vectores solución (kernels) donde M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // Lista de dependencias
 // Datos dummy
 dependencies.push_back({0});

 std::cout << "[Fase 4] Encontradas " << dependencies.size() << " dependencias lineales (cuadrados perfectos)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Fase 5] Computación de Raíz Cuadrada Algebraica..." << std::endl;

 // 1. Cálculo de la raíz cuadrada racional V (operación de enteros simple)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Cálculo de la raíz cuadrada algebraica gamma (Método de Montgomery, etc.)
 // Encuentra el elemento gamma del cuerpo algebraico gigante O_K, y lo mapea al mundo real con el homomorfismo phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Asumiendo que se añadieron columnas de Caracteres Cuadráticos (Quadratic Characters) en la Fase 2 y 4
 // para evitar la obstrucción del grupo de clases de ideales y el grupo de unidades.

 std::cout << " -> Mapa de homomorfismo phi aplicado." << std::endl;
 std::cout << "[Fase 5] Calculando 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 << "[ÉXITO] Factor no trivial encontrado: " << factor << std::endl;
 std::cout << " Otro factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FALLO] Solución trivial. Probando la siguiente dependencia..." << std::endl;
 }
 }
};

// ============================================================================
// Pipeline de Ejecución Principal
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] Motor General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // Número compuesto gigante N que queremos factorizar, ej. RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Grado del polinomio (para más de 130 dígitos usualmente se selecciona grado 5 a 6)
 int degree = 6;

 // Inicialización del pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Los límites reales son decenas a cientos de millones
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. Selección Polinomial
 poly_select.select(N);

 // 2. Proceso de Criba (Sieving)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filtrado (Compresión de matriz)
 filter.reduce_matrix(relations);

 // 4. Álgebra Lineal (Búsqueda del espacio nulo sobre GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Cálculo de Raíz Cuadrada Algebraica y 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[Sistema] Pipeline SOTA GNFS completado en " << elapsed.count() << " segundos." << std::endl;

 return 0;
}

Entonces, ¿cómo es que este código destruye los muros de la criptografía? Explicaremos los minuciosos algoritmos y las matemáticas avanzadas para cada una de las 5 fases.

2. El objetivo final de GNFS: $X^2 \equiv Y^2 \pmod N$

El objetivo de la mayoría de los algoritmos de factorización gigante moderna, no solo de GNFS, es encontrar un par no trivial $(X, Y)$ que satisfaga la siguiente congruencia:

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

Esta fórmula significa que “los restos al dividir $X^2$ y $Y^2$ por $N$ son iguales”. Reorganizando esto: $X^2 - Y^2 \equiv 0 \pmod N$ En otras palabras, $(X-Y)(X+Y)$ es un múltiplo de $N$.

Si $X \not\equiv \pm Y \pmod N$ (solución no trivial), existirá un “divisor común mayor que 1 y menor que $N$” entre $(X-Y)$ y $N$. Aquí, si usamos el algoritmo de Euclides para calcular $\gcd(X-Y, N)$, podemos encontrar los factores primos de $N$ con mucha facilidad.

Sin embargo, encontrar estos $X$ e $Y$ es como buscar una aguja en un desierto. Por lo tanto, GNFS adopta el ingenioso enfoque de crear dos mundos, el “mundo de los enteros reales” y el “mundo de los cuerpos algebraicos de los polinomios”, y distribuye los cálculos.

3. Fase 1: Selección Polinomial (Polynomial Selection)

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Cálculo de m = N^(1/d) y expansión en base m
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

El primer paso de GNFS es crear un “polinomio mágico” que sirva de puente entre los dos mundos. Para un número gigante $N$, elegimos un entero $m$. Usualmente se elige de tal manera que $m \approx N^{1/d}$ (el código asume un polinomio de grado $d=6$).

Luego, expandimos $N$ en base $m$ y usamos esos coeficientes para construir el polinomio $f(x)$.

$$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$$

Este polinomio $f(x)$ tiene una propiedad extremadamente importante: “al sustituir la variable $x$ con $m$, resulta ser exactamente $N$ ($f(m) = N$)”. En otras palabras, $f(m) \equiv 0 \pmod N$. El polinomio en el lado racional se define como $g(x) = x - m$.

Con esto, el “mundo del cuerpo algebraico $\mathbb{Z}[\alpha]$” dominado por la raíz $\alpha$ de $f(x)=0$ y el “mundo normal de los racionales (enteros) $\mathbb{Z}$” quedan firmemente conectados por un “homomorfismo de anillos” (Homomorphism) de $x \to m$.

En herramientas de vanguardia como CADO-NFS, el polinomio “más conveniente $f(x)$” donde los coeficientes no se vuelven extremadamente grandes y es probable que aparezcan primos en pasos posteriores (más fácil que sea liso), se busca durante meses utilizando el algoritmo de KleinJung y el algoritmo de reducción de bases de retículos LLL.

4. Fase 2: Criba de Retículos q-Especial (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // mapea pares (a, b) a retículos para cada primo especial q,
 // y ejecuta un sieving (criba) maximizando la eficiencia de la caché al extremo.
 // ...
 }
};

Una vez preparados ambos mundos, el siguiente paso es buscar “números lisos” (números formados solo por factores primos pequeños) en ambos mundos. Generamos infinitos pares de enteros $(a, b)$ y calculamos los siguientes dos valores:

Valor racional: $a - bm$
Norma algebraica: $b^d f(a/b)$

El propósito de GNFS es recolectar de decenas a cientos de millones de estos “pares donde tanto el valor racional como el algebraico pueden descomponerse completamente en factores primos pequeños (Relation: relaciones)”.

En los primeros GNFS, se utilizaba una “Criba Lineal (Line Sieve)” que alineaba $(a, b)$ en el plano $xy$ y dividía por primos desde un extremo. Sin embargo, esto causaba muchas fallas de caché al acceder a la memoria en todas partes, y tenía la debilidad de ser muy lento.

Por lo tanto, el código de vanguardia actual utiliza un método llamado “Criba de Retículos q-Especial (Special-q Lattice Sieve)”. Se fija un número primo $q$ moderadamente grande y solo se consideran “los pares $(a, b)$ donde el valor algebraico siempre es divisible por $q$”. Dado que estos $(a, b)$ forman un “retículo (Lattice)” en el plano, el tamaño del salto de la dirección calculada es constante y se ajusta perfectamente a las memorias caché L1/L2 de la CPU. Gracias a la introducción de esta criba de retículos, la velocidad de cálculo de GNFS ha mejorado drásticamente.

5. Fase 3: Filtrado (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Eliminación de Singletons (eliminación de relaciones con primos que aparecen solo 1 vez)
 // 2. Fusión de Cliques (combinación de relaciones para hacer densa una matriz dispersa)
 }
};

Cientos de millones de relaciones recolectadas durante meses por computadoras de todo el mundo en la Fase 2. Sin embargo, si metemos esto directamente en el siguiente “paso de resolución de ecuaciones simultáneas (cálculo matricial)”, la memoria de la supercomputadora estallará.

Por eso, se realiza un proceso de supercompresión de la matriz llamado Filtering (Filtrado).

Eliminación de Singletons (Singleton removal / Purga de singularidades) Suponga que un primo gigante $p$ aparece “solo 1 vez” entre cientos de millones de relaciones. Dado que nuestro objetivo es “hacer que los exponentes de todos los primos sean pares (múltiplos de 2)”, un primo que aparece solo 1 vez nunca podrá hacerse par. Por lo tanto, las relaciones que contienen ese primo se eliminan instantáneamente (se purgan) por considerarse “basura inútil”. A medida que esto ocurre en cadena, los datos de cientos de millones de filas se reducen rápidamente.
Fusión de Cliques (Clique merging) Además, multiplicar (sumar) relaciones que comparten un número primo específico reduce el número de filas al tiempo que comprime una matriz dispersa en un estado más denso (se utiliza una técnica similar a la búsqueda de cliques en la teoría de grafos).

Con esta optimización, la enorme matriz dispersa se comprime drásticamente a un tamaño computable.

6. Fase 4: Álgebra Lineal sobre GF(2) (Método Block Wiedemann)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Repite la operación de producto de matrices dispersas y vectores,
 // y encuentra múltiples vectores solución (kernels) donde M * x = 0 mod 2.
 }
};

Por fin, el núcleo del rompecabezas. Multiplicamos las relaciones recolectadas para buscar “combinaciones donde los exponentes de los factores primos sean todos números pares”.

Matemáticamente, esto no es más que encontrar un vector solución $x$ (espacio nulo/kernel) usando una matriz gigante $M$ cuyos elementos son “par/impar (es decir, 0 o 1)” de los exponentes de cada primo y un vector $x$ que indica qué relaciones utilizar: $M \cdot x \equiv 0 \pmod 2$

Tenemos que resolver un sistema de ecuaciones de una matriz de tamaño absurdo de millones de filas × millones de columnas. Con el método normal de eliminación de Gauss, la complejidad sería $O(N^3)$, y el cálculo no terminaría hasta el final del universo.

Por lo tanto, la implementación más avanzada utiliza el “Método Block Wiedemann (Bloque Wiedemann)”. Este es un tipo de método del subespacio de Krylov que aprovecha el hecho de que la matriz $M$ es “extremadamente dispersa (casi toda ceros)” y deriva la solución iterando la multiplicación de matriz y vector. A diferencia del antiguo método Block Lanczos, el método Block Wiedemann puede dividir completamente el proceso de cálculo en múltiples grupos, por lo que ejerce un poder abrumador en la computación en nube distribuida moderna y en la computación paralela en supercomputadoras.

7. Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root) y el Colapso de la Criptografía

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Cálculo de la raíz cuadrada racional V
 cpp_int V = 1;

 // 2. Cálculo de la raíz cuadrada algebraica gamma
 cpp_int Y = 1;

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

A través de los cálculos matriciales de la Fase 4, hemos obtenido un “conjunto de relaciones $S$ que al multiplicarse hacen que todos los factores primos tengan potencias pares”. Con esto, podemos construir el “cuadrado” en ambos mundos, el racional y el algebraico.

Para el lado racional, es simplemente una multiplicación de enteros, por lo que calcular la raíz cuadrada $V$ es fácil.

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

Sin embargo, el verdadero infierno reside en el “lado algebraico”. En el mundo del cuerpo algebraico $\mathbb{Z}[\alpha]$, dado que la factorización única de factores primos no es válida, hemos estado calculando usando ideales. Lo único que garantiza el cálculo matricial es que “es el cuadrado de un ideal”, y no se garantiza que sea “el cuadrado de un elemento ($\gamma^2$)”.

Aquí se levantan poderosos muros en la teoría algebraica de números llamados “obstrucción del grupo de clases de ideales” y “obstrucción del grupo de unidades”. Para romper este muro, GNFS utiliza la magia llamada “Caracteres Cuadráticos (Quadratic Characters)”. A la matriz de la Fase 4, se añaden secretamente de antemano columnas de residuos cuadráticos (Símbolo de Legendre) para decenas de ideales primos especiales. Con esto, hay una probabilidad abrumadora de que el conjunto $S$ encontrado evite la obstrucción y forme con éxito el “cuadrado del elemento verdadero $\gamma^2$”.

El proceso de encontrar $\gamma$ (raíz cuadrada algebraica) se calcula utilizando algoritmos muy complejos como el método de Montgomery.

Y por fin, la raíz cuadrada algebraica $\gamma$ es teletransportada al mundo real (sustituyendo $m$ por $x$) mediante el homomorfismo de anillos $\phi$, y obtenemos $Y$. Si ponemos el $V$ del lado racional directamente como $X$, la ecuación absoluta que hemos estado buscando finalmente se completa.

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

Solo queda calcular $\gcd(X-Y, N)$. En el momento en que se ejecuta el proceso de 0.001 segundos y el factor no trivial se imprime en la pantalla, el cifrado RSA, que se jactaba de ser inexpugnable, colapsa por completo.

Conclusión

GNFS no es simplemente una técnica de programación. Es el cristal del intelecto humano que ha dominado el “abismo de las matemáticas puras” como el álgebra abstracta, la teoría de anillos y los grupos de clases de ideales, con la “ingeniería extrema” como la arquitectura distribuida de supercomputadoras y la optimización de cachés.

La información de chat y de tarjetas de crédito que enviamos de manera informal está protegida sobre una defensa matemática tan astronómica.

Esperamos que, a través de este framework de C++, hayan sentido el “romanticismo de las matemáticas y la informática” detrás del algoritmo de descifrado más avanzado.

Cómo llamar a Microsoft.Windows.AI desde C++

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

🎯 Cómo llamar a `Microsoft.Windows.AI` desde C++ 【Con código de ejemplo】

A partir de Windows 10, Windows incluye de forma estándar un **runtime capaz de ejecutar modelos de IA en formato ONNX . Este es ** Windows ML (Windows.AI.MachineLearning).

En este artículo, explicaremos detalladamente con código de ejemplo ** cómo llamar a Microsoft.Windows.AI.MachineLearning desde ** C++ (basado en aplicaciones Win32).

✅ Preparación

◾ Entorno necesario

Windows 10 (1809+) o Windows 11
Visual Studio 2019 o posterior (la versión Community está bien)
Soporte para C++/WinRT (Microsoft.Windows.CppWinRT)
Windows SDK 10.0.17763.0 o superior

✅ Configuración del proyecto

Cree un proyecto con la siguiente configuración en Visual Studio.

Tipo: Aplicación de escritorio de Windows en C++ (Proyecto vacío)
Subsistema: Windows (WinMain)
Agregue el siguiente paquete desde NuGet
1

Microsoft.Windows.CppWinRT

✅ Código de ejemplo

A continuación se muestra un ejemplo de configuración mínima que combina la API de Win32 y Windows.AI.MachineLearning utilizando WinMain.

※ Nota: El modelo ONNX a utilizar será model.onnx y debe colocarse en la misma carpeta que el archivo ejecutable.

`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") // Para enlazar con WinRT

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

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
 // Inicialización de WinRT (MTA o STA están bien)
 winrt::init_apartment();

 try {
 // Cargar el archivo del modelo
 auto modelFile = StorageFile::GetFileFromPathAsync(L"model.onnx").get();
 LearningModel model = LearningModel::LoadFromStorageFileAsync(modelFile).get();

 // Crear una sesión
 LearningModelSession session(model);
 LearningModelBinding binding(session);

 // Entrada/salida del modelo (aquí se asume una entrada vacía)
 // En la práctica, es necesario vincular con TensorFloat, etc.

 // Ejecutar inferencia
 auto result = session.EvaluateAsync(binding, L"").get();

 MessageBox(nullptr, L"La inferencia se ha completado", L"Windows ML (C++)", MB_OK);
 }
 catch (winrt::hresult_error const& ex) {
 MessageBox(nullptr, ex.message().c_str(), L"Error", MB_ICONERROR);
 }

 return 0;
}

✅ Complemento: Cómo especificar los Tensores de entrada y salida

Dependiendo del modelo, es necesario crear y vincular un Tensor antes de la inferencia.

Ejemplo:

1
2
3
4
5
6
7
8


// Convertir un arreglo de float unidimensional a Tensor
std::vector<float> inputData = {0.5f, 0.3f, 0.2f};
std::vector<int64_t> shape = {1, 3}; // Forma: [1, 3]

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

// Vinculación de entrada (coincidir con el nombre de entrada del modelo)
binding.Bind(L"input_0", tensor);

La salida se puede obtener de manera similar con result.Outputs().Lookup(L"output_0").

✅ Puntos a tener en cuenta al depurar

Si el archivo del modelo no existe en la carpeta de ejecución, se producirá un FileNotFoundException.
Si los nombres de entrada y salida no coinciden, se producirá un error invalid_argument.
Las especificaciones exactas de E/S del modelo se pueden verificar con herramientas como Netron.

✅ Resumen

Elemento	Detalle
API utilizada	Windows.AI.MachineLearning (WinRT)
Lenguaje	C++ (basado en Win32)
Método recomendado	A través de las cabeceras C++/WinRT
Ventajas	Los modelos ONNX funcionan de forma nativa, también soportan GPU
Precaución	Prestar atención a los nombres de entrada del modelo y la forma del Tensor

✅ Alternativa: Para los que no quieren usar WinRT

Si utiliza ONNX Runtime de Microsoft, puede manejar modelos ONNX desde C++ completamente sin WinRT.
Es multiplataforma, lo que permite un código común incluso en Windows/Linux.

📌 Conclusión

Windows ML (Microsoft.Windows.AI) es un motor de inferencia de IA potente que se puede utilizar perfectamente incluso desde C++. Si necesita realizar inferencias de forma nativa en Windows, no dude en probarlo.

Si desea ejemplos específicos sobre cómo crear modelos ONNX o vincular tensores, ¡planeamos explicarlos en un artículo de seguimiento!

Pasos para llamar a TinyLLaMA desde C++ (usando llama.cpp)

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

✅ Configuración de TinyLLaMA × C++ (usando `llama.cpp`)

🔧 Paso 1: Preparar llama.cpp

1-1. Entorno necesario (mínimo)

SO: Windows / Linux / macOS
Entorno de desarrollo: g++ / clang / MSVC
Git / CMake

1-2. Obtener y compilar llama.cpp

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

En Windows, es más fácil usar Visual Studio Developer Command Prompt y ejecutar cmake --build . --config Release.

📦 Paso 2: Descargar y convertir el modelo TinyLLaMA

2-1. Obtener el modelo original de HuggingFace

Ejemplo: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# Instalar transformers para descargar si es necesario
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

Este paso es para convertir al formato de Hugging Face.

2-2. Convertir al formato GGUF (para `llama.cpp`)

1
2


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

2-3. Cuantización del modelo (reducción de tamaño)

1

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

q4_0 es cuantización de 4 bits. El tamaño del modelo se reducirá a aproximadamente 350 MB.

🧪 Paso 3: Llamar al modelo desde C++ (Ejemplo de código)

3-1. Código C++ simple (Inferencia)

 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 = "El usuario dice que quiere leer datos de Excel, filtrarlos y guardarlos. ¿Cuál es la configuración de los nodos?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // Tokenización
 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);

 // Obtener resultados de inferencia
 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;
}

🧱 Paso 4: Método de compilación (Ejemplo)

1

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

libllama.a se crea en el directorio build/ después de compilar.

✅ Ejemplo de estructura del producto final (Organizado)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # Modelo cuantizado (~350MB)
├── main.cpp # Código C++ anterior
├── llama.cpp/ # Código fuente de llama.cpp
└── build/
 └── libllama.a # Biblioteca compilada

🧠 Notas adicionales para aplicar a tu caso de uso

Tener código en C++ que reciba la salida y compare y seleccione plantillas de nodos.
Ejemplo: Si contiene “Excel”, “filtro” y “guardar” → Generar los nodos correspondientes.
Esta parte puede ser tan simple como sentencias if + lectura de plantilla JSON.

📌 Resumen

Elemento	Descripción
Modelo recomendado	TinyLLaMA-1.1B-Chat v1.0 (GGUF + Cuantización)
Tamaño	~350-450MB (Cuantización 4bit)
Integración C++	Posible usando `llama.cpp`, casi sin dependencias externas
Capacidad de procesamiento	Suficiente para comprensión de intención simple y generación de salida (texto natural → configuración)
Extensibilidad	Se puede combinar con el llenado de ranuras (slots) y llamadas a plantillas para crear una IA de generación de nodos

Cómo publicar mensajes en Slack usando Slack App + OAuth2

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

✅ Método de publicación usando un token de acceso (Slack Web API)

El “Token OAuth (como xoxb-〜)” de Slack es la clave para publicar usando la Web API de Slack. En este caso, a diferencia del Webhook, haces un POST al endpoint de la API de Slack con el encabezado Authorization: Bearer.

🔑 Requisitos necesarios

Es necesario incluir chat:write en los permisos OAuth de la aplicación de Slack:

Pasos de configuración

Accede a https://api.slack.com/apps
Crea una aplicación o selecciona una existente
En “OAuth & Permissions” > Scopes → Añade chat:write
Haz clic en “Install to Workspace” o “Reinstall” para obtener el Access Token (Ejemplo: xoxb-xxxxxxxxxx)

💻 Código C++ (Publicar en la API de Slack con 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);

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

 // Cuerpo JSON
 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 << "Error de envío\n";
 return false;
 }

 // Comprobar código de estado
 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-tu-token-de-acceso"; // Token de acceso
 std::string channel = "ID-del-canal-o-#general"; // Ej: "#general" o "C0123456789"
 std::string message = "¡He publicado en Slack desde C++!";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "¡Publicación exitosa!\n";
 } else {
 std::cerr << "Error en la publicación.\n";
 }

 return 0;
}

📌 Cómo obtener el ID del canal

A veces se producen errores si solo usas el nombre del canal (Ejemplo: #general). El método más seguro es usar el ID que se encuentra en la URL de la página del canal en Slack.

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑ Esta parte es el ID del canal

✅ Sobre los tipos de tokens (Información adicional)

Formato del Token	Uso	Ejemplo
`xoxb-...`	Bot Token (Recomendado)	Publicar, editar, eliminar
`xoxp-...`	User Token (No recomendado)	Operaciones no relacionadas con bots
Refresh Token	Para renovar tokens a largo plazo	Normalmente no se usa

📝 Resumen

Para publicar en Slack desde C++, el método de Slack Web API + Bearer Token es el más seguro
Usa el endpoint chat.postMessage con HTTPS POST
El token debe enviarse en el encabezado Bearer
Para los canales, especificar por ID es lo más seguro

Cómo enviar un mensaje a Slack en C++ (Win32 API + WinHTTP) [Soporte de Webhook]

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

Cómo enviar un mensaje a Slack en C++ (Win32 API + WinHTTP) [Soporte de Webhook]

Quiero enviar un mensaje a Slack desde C++. Es muy común en Node.js o Python, pero es poco frecuente hacerlo con “C++ × Win32 API × WinHTTP”.

En este artículo, explicaremos paso a paso cómo enviar un mensaje a Slack desde C++ usando una URL de Webhook.

✅ Flujo general

Para publicar en Slack, se deben seguir los siguientes pasos:

Obtener la URL del Webhook de Slack (Clave de API)
Enviar una solicitud POST usando WinHTTP
Ensamblar el cuerpo del mensaje en formato JSON
¡Verificar el resultado y listo!

🔑 Paso 1: Cómo obtener la URL de Webhook de Slack

En Slack, usando una función llamada Incoming Webhooks, puedes publicar mensajes fácilmente desde servicios externos.

Pasos para obtenerla

Accede a https://api.slack.com/apps
Haz clic en Create New App
Elige From scratch, selecciona un nombre para la aplicación y el espacio de trabajo de destino
En el menú de la izquierda, selecciona “Incoming Webhooks” y actívalo
Haz clic en “Add New Webhook to Workspace” y selecciona un canal
Copia la URL generada (Ejemplo: https://hooks.slack.com/services/xxx/yyy/zzz)

Esta URL funciona como una clave de API.

💻 Paso 2: Enviar un mensaje a Slack con código C++

Tecnologías utilizadas

Win32 API
WinHTTP (Biblioteca estándar)
Mensaje en formato JSON

Código de muestra (Publicación en Slack)

 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) {
 // Descomposición de la URL
 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"Falló la descomposición de la URL\n";
 return false;
 }

 // Sesión HTTP y conexión
 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 << "Falló la solicitud de envío\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);

 // Liberar recursos
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring webhookUrl = L"https://hooks.slack.com/services/xxx/yyy/zzz"; // Reemplázalo con tu Webhook

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

 if (PostToSlack(webhookUrl, message)) {
 std::cout << "¡Publicación exitosa!\n";
 } else {
 std::cerr << "Falló la publicación.\n";
 }

 return 0;
}

🧪 Personalización del mensaje JSON

En el Webhook de Slack, puedes incluir los siguientes parámetros:

1
2
3
4
5
6


{
 "text": "Contenido de la notificación",
 "username": "Nombre del Bot",
 "icon_emoji": ":rocket:",
 "channel": "#nombre_del_canal_opcional"
}

📌 Notas adicionales

Debes especificar "application/json" en Content-Type
La URL del Webhook se pasa como un wstring tal cual (no requiere codificación URL)
Como es una comunicación HTTPS, no olvides agregar WINHTTP_FLAG_SECURE

🎉 Extra: Ejemplo de confirmación de publicación en Slack

Se mostrará así en Slack:

1
2


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

✍️ Resumen

Elemento	Descripción
Método de publicación	Webhook (Incoming Webhooks)
Biblioteca de comunicación	WinHTTP
Formato de datos	JSON
Parámetros disponibles	text, username, icon_emoji, channel, etc.

¡Incluso si pensabas que integrar C++ con Slack era complicado, puedes incorporar un Bot de notificaciones desde hoy mismo!

🚀 ¿Próximamente?

Si te interesa, la próxima vez podríamos cubrir:

Adjuntar archivos
Interfaz de usuario con botones
Operaciones API flexibles con Slack App + OAuth2

¡Podemos presentar una integración con Slack un paso más allá!

Cómo publicar mensajes en Microsoft Teams desde C++ (WinHTTP + Graph API)

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

Cómo publicar mensajes en Microsoft Teams desde C++ (WinHTTP + Graph API)

¿Quieres publicar mensajes automáticamente en el chat de Microsoft Teams?
Para eso puedes usar la Microsoft Graph API.
En este artículo, presentaremos un ejemplo de código en C++ usando WinHTTP ** y los ** pasos de autenticación de la API necesarios, paso a paso.

🔧 Preparación necesaria (Configuración de autenticación de Microsoft Graph API)

1. Registrar la aplicación en el portal de Azure

Primero, para usar la Microsoft Graph API, debes registrar una aplicación en Azure.

Accede al Azure Portal
Ve a “Microsoft Entra ID ” > “+ Agregar ” > “ Registros de aplicaciones ” > “ Nuevo registro”
Ingresa un nombre para la aplicación y haz clic en “Registrar”

2. Agregar permisos de API

Ve al menú izquierdo “Permisos de API”
En “Microsoft Graph ” > “ Permisos delegados ” (o seleccionar permisos), busca los siguientes ámbitos (scopes) y haz clic en “ Actualizar permisos” (o agregar permisos)

Chat.ReadWrite
User.Read

※ Si deseas publicar en un canal, también necesitarás ChannelMessage.Send

3. Anotar el ID del cliente y el ID del inquilino (tenant)

Anota los siguientes dos valores que se muestran en la pestaña “Información general”:

ID de la aplicación (cliente)
ID del directorio (inquilino)

4. Crear un secreto de cliente

Ve a la pestaña “Certificados y secretos”
Selecciona “Nuevo secreto de cliente” > Establece una fecha de expiración y haz clic en “Agregar”
Asegúrate de copiar el valor mostrado (secreto) en este momento, ya que no podrás verlo después

🔐 Obtener el token de acceso (OAuth2)

Para obtenerlo, usaremos el flujo client_credentials.
Ejecuta el siguiente comando con curl para obtener el token de acceso.

1
2
3
4
5
6
7


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

Ejemplo de respuesta

1
2
3
4
5
6


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

Usaremos este access_token para llamar a la Microsoft Graph API.

💬 Ejemplo en C++ para publicar en el chat de Teams

Aquí mostramos un ejemplo en C++ que usa WinHTTP para publicar en el chat.

 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;
}

🔍 Cómo obtener el ID del chat

El ID del chat se puede verificar con GET /v1.0/me/chats.

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"

Ejemplo de respuesta

1
2
3
4
5
6
7
8
9


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

📌 Puntos a tener en cuenta

Este ejemplo es una implementación mínima. En un entorno de producción:
- Manejo de expiración de tokens
- Verificación del certificado HTTPS
- Mejora en el manejo de errores
Para publicaciones en canales se usa teams/{team-id}/channels/{channel-id}/messages.
Para enviar archivos adjuntos, se requiere procesamiento multiparte o la API de Graph Drive.

Resumen

📎 Resumen

Característica	Descripción
Graph API	API oficial para interactuar con Teams
Registro de aplicación	Procedimientos de autenticación necesarios en Azure
Token de acceso	Obtenido a través de OAuth2 y usado para peticiones
Implementación en C++	Llama a la Graph API utilizando WinHTTP

🚀 Próximos pasos

Para ejemplos más avanzados, también es posible lo siguiente:

Publicación en canales de equipos (/teams/{team-id}/channels/...)
Publicación con archivos adjuntos
Cambio entre cuentas de bot o cuentas de usuario
Implementación completa en C++ incluyendo la obtención del token

¡Si tienes alguna pregunta o sugerencia, no dudes en comentar!

Ventajas y desventajas de crear programas con Win32API + C++

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

Atractivo y desafíos de desarrollar con Win32API + C++

Para aquellos que quieren profundizar en el desarrollo de aplicaciones para Windows, Win32API + C++ sigue siendo una opción poderosa. Esta combinación, que permite interactuar con el sistema operativo desde la distancia más corta, combina alta velocidad y flexibilidad.

Por otro lado, difiere enormemente de los estilos de desarrollo modernos, por lo que su aprendizaje requiere determinación.

En esta página, explicaremos las ventajas y desventajas de forma sencilla desde la perspectiva de un desarrollador activo de aplicaciones para Windows.

Ventajas

Ejecución nativa ultrarrápida

Dado que C++ y Win32API funcionan en la capa más cercana al sistema operativo, casi no hay sobrecarga innecesaria. La eficiencia en el uso de CPU y memoria es muy alta, presumiendo de una velocidad de ejecución abrumadora.

Alta flexibilidad y libertad

Puede controlar de forma precisa y por sí mismo todos los comportamientos de la aplicación, como el control de ventanas, el procesamiento asíncrono, la integración COM y la gestión de procesos. También es posible crear herramientas especializadas para un propósito o su propio marco de trabajo personalizado.

Fácil de distribuir sin necesidad de tiempo de ejecución

Dado que no se requieren tiempos de ejecución externos como .NET o Java, se puede distribuir solo con un archivo ejecutable. Es menos propenso a problemas durante la redistribución y es atractivo porque es fácil de ejecutar incluso sin un instalador.

Se pueden crear aplicaciones ligeras

Dado que solo requiere la configuración mínima necesaria, se caracteriza por una huella de memoria muy pequeña. Funciona de manera fluida incluso en PC con bajas especificaciones o entornos de máquinas virtuales.

Control avanzado a nivel de sistema operativo posible

Puede realizar controles que son difíciles con lenguajes y bibliotecas normales, como el hook global del ratón/teclado, el ajuste fino del estilo de la ventana y la manipulación del menú del sistema.

Desventajas

Baja eficiencia de desarrollo

La construcción de la GUI también debe hacerse completamente mediante código, y a veces se necesitan decenas de líneas de código solo para crear un botón. Las modificaciones por cambios de diseño también son engorrosas, y la productividad es más baja en comparación con el desarrollo utilizando un marco de trabajo de UI.

La mantenibilidad tiende a disminuir

Hay mucho código de estructura especial, como bucles de mensajes y procedimientos de ventana, lo que dificulta la legibilidad y la reutilización. También tiene aspectos que lo hacen inadecuado para el desarrollo en equipo y el mantenimiento a largo plazo.

El soporte para UI moderna es tedioso

Es difícil soportar la UX requerida en los últimos años, como soporte de alto DPI, interfaz táctil, accesibilidad y modo oscuro. Se necesita tiempo y esfuerzo porque requiere hacerlo manualmente uno por uno.

No soporta multiplataforma

Como es una API completamente exclusiva de Windows, no se puede portar a macOS o Linux. Si asume la implementación en múltiples plataformas, necesitará seleccionar otras tecnologías.

El costo de aprendizaje es extremadamente alto

Debe comprender conceptos y mecanismos que rara vez se usan en la actualidad, como manejadores (handles), GDI, COM y OLE. Mucha de la documentación es antigua, y el aprendizaje requiere tiempo y perseverancia.

Usos adecuados

Herramientas ligeras como lanzadores de archivos y asistencia de teclas de acceso rápido
Utilidades del sistema como operaciones del portapapeles y control IME
Aplicaciones de tipo control nativo como hooks globales y captura de ventanas
Herramientas de asistencia de controladores que están estrechamente vinculadas al hardware

Usos no adecuados

Aplicaciones dirigidas a consumidores generales donde se enfatiza la UI/UX moderna
Prototipado y desarrollo MVP que prioriza la velocidad
Proyectos a gran escala que asumen operaciones a largo plazo y desarrollo en equipo
Productos multiplataforma que necesitan soportar múltiples sistemas operativos

Resumen de evaluación

Punto de vista	Evaluación
Velocidad de ejecución	◎ Muy rápida
Eficiencia de memoria	◎ Excelente
Velocidad de desarrollo	× Lenta
Mantenibilidad	× Baja
Soporte multiplataforma	× No soportado
Soporte UI moderna	× Débil
Grado de libertad de control del SO	◎ Abrumadoramente alto

Conclusión

Win32API + C++ es una herramienta adecuada para desarrolladores que “quieren manejar todo el sistema operativo por sí mismos”. Si bien su poder es muy grande, el aprendizaje y la operación requieren la correspondiente determinación.

Si vale la pena “elegirlo a propósito” depende de la naturaleza de la aplicación a la que apunte.

Sumergirse en el mundo de #include <windows.h> sin depender de marcos de trabajo GUI o lenguajes modernos… Esa elección sigue siendo significativa hoy en día.

[Para principiantes] Pasos para introducir libcurl (compatible con OpenSSL) en Visual Studio usando vcpkg

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

Si desea usar libcurl (compatible con OpenSSL) en Visual Studio, la introducción de vcpkg es fácil y recomendada

Cuando se quiere manejar comunicación HTTP en C++, libcurl se usa a menudo. Pero, construir y ajustar dependencias es sorprendentemente molesto, ¿verdad?

Ahí es donde “vcpkg”, una herramienta de gestión de bibliotecas de C++ de Microsoft, resulta útil. En esta ocasión, introduciremos los pasos para usar vcpkg para instalar libcurl (compatible con OpenSSL) y poder usarlo fluidamente en Visual Studio.

Instalación de vcpkg (sólo para quienes no lo tengan)

Primero, instalemos vcpkg. Por favor, ejecute los siguientes pasos en PowerShell.

1
2
3


git clone https://github.com/microsoft/vcpkg
cd vcpkg
.\bootstrap-vcpkg.bat

※ Si Git aún no está instalado, por favor, instálelo desde el sitio web oficial de Git.

Instalación de libcurl (compatible con OpenSSL)

A continuación, usaremos vcpkg para instalar libcurl. Para especificar la versión de 64 bits compatible con OpenSSL, ejecute el siguiente comando:

1

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

Cuando se ejecuta este comando, las dependencias necesarias (como OpenSSL) también se configurarán automáticamente.

Configuración de la integración con Visual Studio

Para que las bibliotecas introducidas con vcpkg se puedan usar fácilmente desde proyectos de Visual Studio, configure la integración con el siguiente comando.

1

vcpkg integrate install

Al hacer esta configuración, #include <curl/curl.h> se podrá usar automáticamente en el proyecto de Visual Studio, y ya no será necesario configurar manualmente la ruta de la biblioteca o la configuración del enlazador.

Conclusión

Con esto, la preparación para introducir libcurl (compatible con OpenSSL) en Visual Studio está completa.

Usando vcpkg, las dependencias molestas se pueden gestionar todas a la vez
Instale fácilmente libcurl con vcpkg install curl[ssl] --triplet x64-windows
La integración automática con Visual Studio es posible con vcpkg integrate install

Después de esto, incluya los encabezados en el proyecto y comience a desarrollar usando la API de libcurl. Aproveche el conveniente vcpkg para aumentar enormemente la eficiencia de su desarrollo.

Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI

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

🎯 Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI (Visual Studio 2022 / C++)

✅ Arquitectura general

🔹 ① DLL envoltura CLI (C++/CLI)

Proporciona la funcionalidad para ejecutar scripts de PowerShell.

🔹 ② Lado de llamada C++ nativo

Llama a la DLL CLI para ejecutar el script de PowerShell.

🔧 Paso 1: Creación del proyecto de la DLL envoltura CLI

1. Creación del proyecto

[Crear un proyecto nuevo] → [C++] → Biblioteca de clases CLR (.NET Framework)
Nombre: PowerShellWrapper

💡 Si no ves esta plantilla, instala la carga de trabajo “Desarrollo de escritorio de .NET”.

2. Añadir paquete NuGet

Haz clic derecho en el proyecto → [Administrar paquetes NuGet]
Busca e instala System.Management.Automation
(Versión 5.x o 7.x)

3. Implementación del código en el lado CLI

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();
}

🔧 Paso 2: Llamada desde el lado de C++ nativo

1. Crear proyecto de aplicación de consola C++

Nombre: NativeApp

2. Configurar referencias

Haz clic derecho en el proyecto → [Agregar] → [Referencia] → [Proyectos] → Agrega PowerShellWrapper
[Propiedades de configuración] → [C/C++] → [Soporte de Common Language Runtime] → Cambiar a /clr

3. Código de ejecución (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;
}

💡 Nota adicional (IDL / TLB / Registro COM)

Esta configuración hace referencia directa a una DLL de .NET en lugar de COM, por lo tanto, no se requiere IDL, TLB ni registro COM.

✅ Estructura final

1
2
3
4
5


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

Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI

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

🎯 Pasos para ejecutar PowerShell desde C++ a través de una DLL de C++/CLI (Visual Studio 2022 / C++)

✅ Arquitectura general

🔹 ① DLL envoltura CLI (C++/CLI)

Proporciona la funcionalidad para ejecutar scripts de PowerShell.

🔹 ② Lado de llamada C++ nativo

Llama a la DLL CLI para ejecutar el script de PowerShell.

🔧 Paso 1: Creación del proyecto de la DLL envoltura CLI

1. Creación del proyecto

[Crear un proyecto nuevo] → [C++] → Biblioteca de clases CLR (.NET Framework)
Nombre: PowerShellWrapper

💡 Si no ves esta plantilla, instala la carga de trabajo “Desarrollo de escritorio de .NET”.

2. Añadir paquete NuGet

Haz clic derecho en el proyecto → [Administrar paquetes NuGet]
Busca e instala System.Management.Automation
(Versión 5.x o 7.x)

3. Implementación del código en el lado CLI

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();
}

🔧 Paso 2: Llamada desde el lado de C++ nativo

1. Crear proyecto de aplicación de consola C++

Nombre: NativeApp

2. Configurar referencias

Haz clic derecho en el proyecto → [Agregar] → [Referencia] → [Proyectos] → Agrega PowerShellWrapper
[Propiedades de configuración] → [C/C++] → [Soporte de Common Language Runtime] → Cambiar a /clr

3. Código de ejecución (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;
}

💡 Nota adicional (IDL / TLB / Registro COM)

Esta configuración hace referencia directa a una DLL de .NET en lugar de COM, por lo tanto, no se requiere IDL, TLB ni registro COM.

✅ Estructura final

1
2
3
4
5


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

'Cómo generar la hora actual en formato ISO8601 en C++'

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

Requisitos

Estándar ISO C++ 20 (/std:c++20)

Código

1
2
3
4


#include <chrono>
#include <format>

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

Esta fue la forma de generar la hora actual en formato ISO8601 en C++.

Referencias

std::format

Cómo compilar OpenSSL en Windows

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

¿Qué es OpenSSL?

Es una biblioteca de código abierto que proporciona el procesamiento necesario para realizar comunicaciones cifradas.

Para utilizarlo desde un programa, dado que el código fuente en lenguaje C es público, es necesario compilarlo para crear la biblioteca.

A continuación se presentan los pasos para su compilación.

Preparación del entorno de compilación

Perl

Descargue strawberry-perl-5.32.1.1-64bit.msi desde https://strawberryperl.com/. Creo que está bien usar la última versión.
NASM

Descargue 2.16.01/nasm-2.16.01-win64.zip desde la sección de Download en https://www.nasm.us/. Creo que está bien usar la última versión (que no sea rc). Después de la instalación, es necesario registrar la carpeta donde se instaló NASM en la variable de entorno PATH.
Visual Studio 2022 ** o ** Build Tools for Visual Studio 2022

Instale Visual Studio 2022 Community o Build Tools for Visual Studio 2022 desde https://visualstudio.microsoft.com/ja/downloads/.

Pasos para compilar OpenSSL en Windows

Descargue y extraiga openssl-3.1.0.tar.gz desde https://www.openssl.org/source/. Si no puede extraerlo, ejecute tar -xzf openssl-3.1.0.tar.gz en el símbolo del sistema.
Inicie el símbolo del sistema con privilegios de administrador.
Abra la carpeta extraída.
Ejecute el siguiente comando. * Cambie la parte de Community según la versión de Visual Studio que haya instalado:

1

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

Ejecute el siguiente comando:

1

perl Configure VC-WIN64A

Ejecute el siguiente comando (toma bastante tiempo):

1

nmake

Ejecute el siguiente comando (toma bastante tiempo):

1

nmake test

Ejecute el siguiente comando:

1

nmake install

Si todo sale bien, OpenSSL se instalará en C:\Program Files\OpenSSL.

Eso es todo.

Referencias

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

C++ on kenji.blog

[Análisis completo] Implementando y entendiendo el algoritmo de descifrado más fuerte 'GNFS' en C++

【Análisis Completo】Entendiendo el algoritmo de descifrado más fuerte “GNFS” implementándolo en C++

1. GNFS Framework Lógico de Vanguardia (Código fuente completo)

2. El objetivo final de GNFS: $X^2 \equiv Y^2 \pmod N$

3. Fase 1: Selección Polinomial (Polynomial Selection)

4. Fase 2: Criba de Retículos q-Especial (Special-q Lattice Sieving)

5. Fase 3: Filtrado (Filtering)

6. Fase 4: Álgebra Lineal sobre GF(2) (Método Block Wiedemann)

7. Fase 5: Raíz Cuadrada Algebraica (Algebraic Square Root) y el Colapso de la Criptografía

Conclusión

Cómo llamar a Microsoft.Windows.AI desde C++

🎯 Cómo llamar a Microsoft.Windows.AI desde C++ 【Con código de ejemplo】

✅ Preparación

◾ Entorno necesario

✅ Configuración del proyecto

✅ Código de ejemplo

main.cpp

✅ Complemento: Cómo especificar los Tensores de entrada y salida

✅ Puntos a tener en cuenta al depurar

✅ Resumen

✅ Alternativa: Para los que no quieren usar WinRT

📌 Conclusión

Pasos para llamar a TinyLLaMA desde C++ (usando llama.cpp)

✅ Configuración de TinyLLaMA × C++ (usando llama.cpp)

🔧 Paso 1: Preparar llama.cpp

1-1. Entorno necesario (mínimo)

1-2. Obtener y compilar llama.cpp

📦 Paso 2: Descargar y convertir el modelo TinyLLaMA

2-1. Obtener el modelo original de HuggingFace

2-2. Convertir al formato GGUF (para llama.cpp)

2-3. Cuantización del modelo (reducción de tamaño)

🧪 Paso 3: Llamar al modelo desde C++ (Ejemplo de código)

3-1. Código C++ simple (Inferencia)

🧱 Paso 4: Método de compilación (Ejemplo)

✅ Ejemplo de estructura del producto final (Organizado)

🧠 Notas adicionales para aplicar a tu caso de uso

📌 Resumen

Cómo publicar mensajes en Slack usando Slack App + OAuth2

✅ Método de publicación usando un token de acceso (Slack Web API)

🔑 Requisitos necesarios

Pasos de configuración

💻 Código C++ (Publicar en la API de Slack con WinHTTP)

📌 Cómo obtener el ID del canal

✅ Sobre los tipos de tokens (Información adicional)

📝 Resumen

Cómo enviar un mensaje a Slack en C++ (Win32 API + WinHTTP) [Soporte de Webhook]

Cómo enviar un mensaje a Slack en C++ (Win32 API + WinHTTP) [Soporte de Webhook]

✅ Flujo general

🔑 Paso 1: Cómo obtener la URL de Webhook de Slack

Pasos para obtenerla

💻 Paso 2: Enviar un mensaje a Slack con código C++

Tecnologías utilizadas

Código de muestra (Publicación en Slack)

🧪 Personalización del mensaje JSON

📌 Notas adicionales

🎉 Extra: Ejemplo de confirmación de publicación en Slack

✍️ Resumen

🚀 ¿Próximamente?

Cómo publicar mensajes en Microsoft Teams desde C++ (WinHTTP + Graph API)

Cómo publicar mensajes en Microsoft Teams desde C++ (WinHTTP + Graph API)

🔧 Preparación necesaria (Configuración de autenticación de Microsoft Graph API)

1. Registrar la aplicación en el portal de Azure

2. Agregar permisos de API

3. Anotar el ID del cliente y el ID del inquilino (tenant)

4. Crear un secreto de cliente

🔐 Obtener el token de acceso (OAuth2)

Ejemplo de respuesta

💬 Ejemplo en C++ para publicar en el chat de Teams

🔍 Cómo obtener el ID del chat

Ejemplo de respuesta

📌 Puntos a tener en cuenta

Resumen

📎 Resumen

🚀 Próximos pasos

Ventajas y desventajas de crear programas con Win32API + C++

Atractivo y desafíos de desarrollar con Win32API + C++

Ventajas

Ejecución nativa ultrarrápida

Alta flexibilidad y libertad

🎯 Cómo llamar a `Microsoft.Windows.AI` desde C++ 【Con código de ejemplo】

`main.cpp`

✅ Configuración de TinyLLaMA × C++ (usando `llama.cpp`)

2-2. Convertir al formato GGUF (para `llama.cpp`)