C++ on kenji.blog

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम "GNFS" को समझना

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

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम “GNFS” को समझना

आधुनिक इंटरनेट का आधार “RSA क्रिप्टोग्राफी” है। इसकी मजबूती इस गणितीय विश्वास पर निर्भर करती है कि “वर्तमान कंप्यूटरों के लिए एक विशाल भाज्य संख्या (composite number) का अभाज्य गुणनखंडन (prime factorization) करना लगभग असंभव है”।

हालाँकि, मानवता ने कभी हार नहीं मानी है। वर्तमान में, क्लासिकल कंप्यूटरों (सामान्य कंप्यूटर, न कि क्वांटम कंप्यूटर) पर विशाल अभाज्य गुणनखंडन करने के लिए ** मानवता का सबसे शक्तिशाली और उन्नत एल्गोरिदम ** मौजूद है। वह है ** “सामान्य संख्या क्षेत्र चलनी (GNFS: General Number Field Sieve)” ** ।

इस लेख में, हम इस GNFS के अत्याधुनिक संगणना लॉजिक को C++ (Boost लाइब्रेरी के मल्टीपल-प्रिसीजन इंटीजर boost::multiprecision का उपयोग करके) में सख्ती से मॉडल किए गए कार्यान्वयन कोड को पूरी तरह से प्रकाशित करेंगे, और इसके पीछे “बीजीय संख्या सिद्धांत (Algebraic Number Theory)” की गहराइयों को विस्तार से समझाएंगे।

कृपया स्रोत कोड के साथ गणित के रहस्य और कंप्यूटर विज्ञान की उस शक्ति का आनंद लें जो इसे मात देती है।

1. GNFS अत्याधुनिक लॉजिक फ्रेमवर्क (संपूर्ण स्रोत कोड)

सबसे पहले, हम इस बार समझाए जाने वाले GNFS के C++ कार्यान्वयन का पूरा दृश्य प्रस्तुत करेंगे। वास्तविक संख्या क्षेत्र चलनी (जैसे CADO-NFS) लाखों पंक्तियों वाला एक विशाल वितरित सिस्टम है, लेकिन यह कोड GNFS को बनाने वाले ** “5 आवश्यक पाइपलाइनों (चरणों)” ** को निकालता है, उन्हें क्लास के रूप में डिज़ाइन करता है, और गणितीय अर्थ खोए बिना न्यूनतम कॉन्फ़िगरेशन के साथ मॉडल करता है।

 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>

// Boost.Multiprecision के मल्टीपल-प्रिसीजन इंटीजर का उपयोग
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (सामान्य संख्या क्षेत्र चलनी) अत्याधुनिक लॉजिक फ्रेमवर्क
//
// यह कोड CADO-NFS आदि में उपयोग किए जाने वाले अत्याधुनिक GNFS के 5 पाइपलाइनों को
// C++ (Boost) क्लास डिज़ाइन के रूप में सख्ती से मॉडल करता है।
// ============================================================================

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 का एल्गोरिदम)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // बीजीय पक्ष बहुपद f(x)
 std::vector<cpp_int> g; // परिमेय पक्ष बहुपद g(x) = x - m
 cpp_int m;

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

 // base-m विस्तार के आधार पर प्रारंभिक बहुपद का निर्माण (वास्तव में अधिक उन्नत जालक आधार न्यूनीकरण LLL का उपयोग किया जाता है)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // सरल base-m विस्तार (d घात)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // सरल m का अनुमान (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[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (जालक चलनी)
// ============================================================================
// हाल के वर्षों में GNFS में Line Sieve (सरल रेखा चलनी) के बजाय Franke-Kleinjung आदि द्वारा
// Special-q Lattice Sieving (विशेष-q जालक चलनी) का उपयोग करना डिफ़ॉल्ट मानक है।
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;
 // (छोड़ा गया) वास्तव में अभाज्य संख्या निर्माण और लेजेंड्रे प्रतीक आदि से फ़िल्टरिंग की जाती है
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // मॉक कार्यान्वयन: वास्तविक जालक चलनी सैकड़ों GB मेमोरी स्पेस को ब्लॉक द्वारा स्कैन करती है
 // (a, b) युग्मों को विशेष अभाज्य q के जालक (a = i*q + j*...) में मैप करती है,
 // और कैश दक्षता को अधिकतम करने वाली चलनी (sieve) चलाती है।

 // डेमो के लिए एक डमी रिलेशन जोड़ा गया
 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 (सिंगलटन रिमूवल और क्लीक मर्जिंग)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (केवल 1 बार आने वाले अभाज्य संख्या वाले रिलेशन को हटाना)
 // 2. Clique merging (विरल मैट्रिक्स को सघन बनाने के लिए रिलेशन को मिलाना)
 // वास्तव में यूनियन-फाइंड एल्गोरिदम आदि द्वारा करोड़ों पंक्तियों वाले मैट्रिक्स को लाखों पंक्तियों में संकुचित किया जाता है।
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann विधि)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // हाल के सुपरकंप्यूटर वातावरण में Block Lanczos विधि की तुलना में, वितरित कंप्यूटिंग के लिए
 // अधिक उपयुक्त Block Wiedemann विधि (Coppersmith कार्यान्वयन) को अत्याधुनिक माना जाता है।
 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;
 // विरल मैट्रिक्स (sparse matrix) और वेक्टर के गुणन की पुनरावृत्ति करके,
 // M * x = 0 mod 2 को संतुष्ट करने वाले कई हल वेक्टर (कर्नेल) खोजना।

 std::vector<std::vector<int>> dependencies; // निर्भरता की सूची
 // डमी डेटा
 dependencies.push_back({0});

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

// ============================================================================
// Phase 5: 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 << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. परिमेय पक्ष का वर्गमूल V की गणना (सरल पूर्णांक गणना)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. बीजीय पक्ष का वर्गमूल gamma की गणना (Montgomery's method आदि)
 // विशाल बीजीय क्षेत्र O_K का तत्व gamma ज्ञात करना, और समरूपता (homomorphism) phi द्वारा वास्तविक दुनिया में मैप करना
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // आदर्श वर्ग समूह (Ideal Class Group) और इकाई समूह (Unit Group) की बाधाओं (Obstruction) से बचने के लिए,
 // यह मानकर चलते हैं कि Phase 2 और 4 में द्विघाती वर्णों (Quadratic Characters) की पंक्तियाँ जोड़ी गई हैं।

 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;

 // RSA-270 आदि, विशाल भाज्य संख्या N जिसका गुणनखंडन करना है
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // बहुपद की घात (130 अंकों से अधिक होने पर आमतौर पर 5 या 6 चुनी जाती है)
 int degree = 6;

 // पाइपलाइन इनिशियलाइज़ेशन
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // वास्तविक सीमाएँ करोड़ों में होती हैं
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. बहुपद चयन
 poly_select.select(N);

 // 2. चलनी (sieve) प्रसंस्करण
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. फ़िल्टरिंग (मैट्रिक्स संपीड़न)
 filter.reduce_matrix(relations);

 // 4. रेखीय बीजगणित (GF(2) पर शून्यस्थान खोज)
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. बीजीय वर्गमूल की गणना और 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;
}

तो यह कोड क्रिप्टोग्राफी की दीवारों को कैसे तोड़ता है? आइए इन 5 चरणों में से प्रत्येक के पीछे के सटीक एल्गोरिदम और उन्नत गणित को विस्तार से समझें।

2. GNFS का अंतिम लक्ष्य: $X^2 \equiv Y^2 \pmod N$

GNFS ही नहीं, बल्कि लगभग सभी आधुनिक विशाल अभाज्य गुणनखंडन एल्गोरिदम का लक्ष्य एक ऐसा गैर-तुच्छ (non-trivial) युग्म $(X, Y)$ खोजना है जो निम्नलिखित सर्वांगसमता (congruence) को संतुष्ट करता हो:

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

इस समीकरण का अर्थ है कि “$X^2$ और $Y^2$ को $N$ से विभाजित करने पर शेषफल समान होता है”। यदि हम इसे रूपांतरित करें, तो: $X^2 - Y^2 \equiv 0 \pmod N$ अर्थात, $(X-Y)(X+Y)$, $N$ का गुणज है।

यदि $X \not\equiv \pm Y \pmod N$ (गैर-तुच्छ हल) है, तो $(X-Y)$ और $N$ के बीच “1 से बड़ा और $N$ से छोटा एक सार्व भाजक (common divisor)” मौजूद होगा। यहाँ, यदि हम यूक्लिड के एल्गोरिदम का उपयोग करके ** $\gcd(X-Y, N)$ ** की गणना करते हैं, तो $N$ का अभाज्य गुणनखंड आसानी से मिल जाएगा।

हालाँकि, इस $X$ और $Y$ को खोजना रेगिस्तान में सुई खोजने जैसा है। इसलिए, GNFS “वास्तविक पूर्णांकों की दुनिया” और “बहुपदों की बीजीय दुनिया” नामक ** 2 दुनियाएँ ** बनाने और संगणना को वितरित करने का एक प्रतिभाशाली दृष्टिकोण अपनाता है।

3. Phase 1: बहुपद चयन (Polynomial Selection)

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // m = N^(1/d) की गणना और base-m विस्तार
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

GNFS का पहला कदम दोनों दुनियाओं को जोड़ने के लिए एक “जादुई बहुपद” बनाना है। एक विशाल संख्या $N$ के लिए, हम एक पूर्णांक $m$ चुनते हैं। आमतौर पर, हम इसे इस तरह चुनते हैं कि $m \approx N^{1/d}$ हो (कोड में $d=6$ घात के बहुपद की कल्पना की गई है)।

फिर, हम $N$ का $m$-आधार विस्तार करते हैं, और इसके गुणांकों का उपयोग करके बहुपद $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$$

इस बहुपद $f(x)$ में एक अत्यंत महत्वपूर्ण गुण है कि ** “चर $x$ में $m$ रखने पर, यह ठीक $N$ बन जाता है ($f(m) = N$)” ** । दूसरे शब्दों में, $f(m) \equiv 0 \pmod N$। परिमेय पक्ष के बहुपद को $g(x) = x - m$ के रूप में परिभाषित किया जाता है।

इसके कारण, $f(x)=0$ के मूल $\alpha$ द्वारा शासित ** “बीजीय क्षेत्र की दुनिया $\mathbb{Z}[\alpha]$” ** और सामान्य ** “परिमेय (पूर्णांक) संख्याओं की दुनिया $\mathbb{Z}$” ** को $x \to m$ नामक “रिंग होमोमोर्फिज्म (Ring Homomorphism)” द्वारा दृढ़ता से जोड़ा जाता है।

अत्याधुनिक CADO-NFS आदि में, KleinJung एल्गोरिदम या LLL जालक आधार न्यूनीकरण एल्गोरिदम का उपयोग महीनों तक ऐसे “सबसे सुविधाजनक बहुपद $f(x)$” की खोज के लिए किया जाता है जिसके गुणांक बहुत बड़े नहीं होते हैं और बाद के चरणों में अभाज्य संख्याएँ उत्पन्न होने की अधिक संभावना होती है (अर्थात स्मूथ होने की संभावना अधिक होती है)।

4. Phase 2: विशेष $q$ जालक चलनी (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // (a, b) युग्मों को विशेष अभाज्य q के जालक में मैप करता है,
 // और कैश दक्षता को अधिकतम करने वाली चलनी (sieve) चलाता है।
 // ...
 }
};

एक बार जब दोनों दुनियाएँ तैयार हो जाती हैं, तो अगला कदम उन दोनों दुनियाओं में “स्मूथ संख्याएँ (केवल छोटी अभाज्य संख्याओं से बनी संख्याएँ)” खोजना है। पूर्णांक युग्मों $(a, b)$ की अनगिनत संख्या उत्पन्न की जाती है, और निम्नलिखित दो मानों की गणना की जाती है:

** परिमेय पक्ष का मान ** : $a - bm$
** बीजीय पक्ष का नॉर्म ** : $b^d f(a/b)$

GNFS का लक्ष्य ऐसे ** “युग्मों (Relation: संबंध) को करोड़ों की संख्या में इकट्ठा करना है जहाँ परिमेय और बीजीय दोनों मानों को पूरी तरह से केवल छोटे अभाज्य कारकों में विभाजित किया जा सकता है” ** ।

शुरुआती GNFS में, एक “सरल रेखा चलनी (Line Sieve)” का उपयोग किया जाता था जो $(a, b)$ को $xy$-तल पर रखता था और उन्हें एक सिरे से अभाज्य संख्याओं द्वारा क्रमिक रूप से विभाजित करता था। हालाँकि, इसमें मेमोरी के कई स्थानों तक पहुँचने के कारण लगातार कैश मिस होने और बहुत धीमा होने की कमजोरी थी।

इसलिए, वर्तमान अत्याधुनिक कोड में ** “विशेष $q$ जालक चलनी (Special-q Lattice Sieve)” ** नामक तकनीक का उपयोग किया जाता है। एक उपयुक्त रूप से बड़ी अभाज्य संख्या $q$ तय की जाती है, और केवल उन $(a, b)$ युग्मों की गणना की जाती है जहाँ “बीजीय पक्ष का मान निश्चित रूप से $q$ द्वारा विभाज्य है”। इस शर्त को पूरा करने वाले $(a, b)$ तल पर एक “जालक (Lattice)” बनाते हैं, इसलिए गणना करने के लिए पतों की जंप की चौड़ाई स्थिर हो जाती है, जो CPU के L1/L2 कैश में पूरी तरह से फिट बैठती है। इस जालक चलनी की शुरुआत के साथ, GNFS की गणना गति में नाटकीय रूप से सुधार हुआ।

5. Phase 3: फ़िल्टरिंग (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (केवल 1 बार आने वाले अभाज्य संख्या वाले रिलेशन को हटाना)
 // 2. Clique merging (विरल मैट्रिक्स को सघन बनाने के लिए रिलेशन को मिलाना)
 }
};

Phase 2 में दुनिया भर के कंप्यूटरों द्वारा महीनों तक एकत्र किए गए करोड़ों रिलेशन। हालाँकि, अगर हम इसे ऐसे ही अगले “युगपत समीकरणों को हल करने वाले चरण (मैट्रिक्स गणना)” में डाल देते हैं, तो सुपरकंप्यूटर की मेमोरी भर जाएगी।

इसलिए, ** फ़िल्टरिंग (Filtering) ** नामक एक अति-संपीड़न प्रक्रिया की जाती है।

** Singleton removal (सिंगलटन रिमूवल) ** मान लें कि करोड़ों रिलेशन में कोई विशाल अभाज्य संख्या $p$ “केवल 1 बार” आती है। हमारा लक्ष्य “सभी अभाज्य संख्याओं के घातांकों को सम (2 का गुणज) बनाना” है, इसलिए जो अभाज्य संख्या केवल 1 बार आती है उसे कभी सम नहीं किया जा सकता। इसलिए, उस अभाज्य संख्या वाले रिलेशन को तुरंत “कचरा” मानकर हटा (पर्ज) दिया जाता है। चूँकि यह एक श्रृंखला प्रतिक्रिया में होता है, करोड़ों पंक्तियों वाला डेटा तेज़ी से कम हो जाता है।
** Clique merging (क्लीक मर्जिंग) ** इसके अलावा, एक विशिष्ट अभाज्य संख्या साझा करने वाले रिलेशन को एक साथ गुणा करके (जोड़कर), पंक्तियों की संख्या कम हो जाती है, जबकि एक विरल (sparse) मैट्रिक्स को सघन स्थिति में संकुचित किया जाता है (ग्राफ सिद्धांत में क्लीक सर्च के समान एक विधि का उपयोग किया जाता है)।

इस अनुकूलन के साथ, विशाल विरल मैट्रिक्स को गणना योग्य आकार में नाटकीय रूप से संकुचित किया जाता है।

6. Phase 4: GF(2) पर रेखीय बीजगणित (Block Wiedemann विधि)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // विरल मैट्रिक्स (sparse matrix) और वेक्टर के गुणन की पुनरावृत्ति करके,
 // M * x = 0 mod 2 को संतुष्ट करने वाले कई हल वेक्टर (कर्नेल) खोजना।
 }
};

यह पहेली का मूल है। हम एकत्र किए गए रिलेशन को गुणा करते हैं ताकि ** “ऐसे संयोजन को खोज सकें जहाँ सभी अभाज्य कारकों के घातांक सम हो जाते हैं” ** ।

गणितीय रूप से, यह एक विशाल मैट्रिक्स $M$ जिसमें प्रत्येक अभाज्य संख्या के घातांक की “सम/विषम (यानी 0 या 1)” स्थिति होती है, और यह दर्शाने वाला एक वेक्टर $x$ कि किन रिलेशन का उपयोग किया जाए, का उपयोग करके: ** $M \cdot x \equiv 0 \pmod 2$ ** संतुष्ट करने वाले हल वेक्टर $x$ (शून्यस्थान / कर्नेल) को खोजने के अलावा और कुछ नहीं है।

हमें लाखों पंक्तियों × लाखों स्तंभों वाले मैट्रिक्स के युगपत समीकरणों को हल करना होगा। सामान्य गाऊसी उन्मूलन (Gaussian elimination) से गणना की जटिलता $O(N^3)$ हो जाएगी, और गणना ब्रह्मांड के अंत तक भी समाप्त नहीं होगी।

इसलिए, अत्याधुनिक कार्यान्वयन ** “Block Wiedemann (ब्लॉक विडमैन) विधि” ** को अपनाता है। यह क्रिलोव सबस्पेस विधि का एक प्रकार है जो इस तथ्य का लाभ उठाता है कि मैट्रिक्स $M$ “अत्यंत विरल (लगभग सभी 0)” है, और मैट्रिक्स और वेक्टर के गुणन को बार-बार करके हल निकालता है। पुरानी Block Lanczos विधि के विपरीत, Block Wiedemann विधि गणना प्रक्रिया को पूरी तरह से कई क्लस्टरों में विभाजित कर सकती है, इसलिए यह आधुनिक वितरित क्लाउड कंप्यूटिंग और सुपरकंप्यूटर पर समानांतर गणना में अत्यधिक शक्तिशाली है।

7. Phase 5: बीजीय वर्गमूल (Algebraic Square Root) और क्रिप्टोग्राफी का पतन

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. परिमेय पक्ष का वर्गमूल V की गणना
 cpp_int V = 1;

 // 2. बीजीय पक्ष का वर्गमूल gamma की गणना
 cpp_int Y = 1;

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

Phase 4 में मैट्रिक्स गणनाओं के माध्यम से, हमने “रिलेशन का एक सेट $S$ प्राप्त किया है जो, जब गुणा किया जाता है, तो सभी अभाज्य कारकों की सम घात में परिणत होता है”। यह हमें परिमेय और बीजीय दोनों दुनियाओं में “वर्ग (Squares)” बनाने की अनुमति देता है।

चूँकि परिमेय पक्ष केवल पूर्णांक गुणन है, इसलिए वर्गमूल $V$ की गणना करना आसान है।

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

** लेकिन असली चुनौती “बीजीय पक्ष” पर है। ** बीजीय क्षेत्र $\mathbb{Z}[\alpha]$ की दुनिया में, अभाज्य गुणनखंडन की विशिष्टता (unique factorization) लागू नहीं होती है, इसलिए हमने आदर्शों (ideals) का उपयोग करके गणना की है। मैट्रिक्स गणना केवल यह गारंटी देती है कि यह “आदर्श का वर्ग” है, और ** यह गारंटी नहीं देता है कि यह “तत्व का वर्ग ($\gamma^2$)” बन जाता है ** ।

यहाँ बीजीय संख्या सिद्धांत में एक दुर्जेय दीवार है, जिसे “आदर्श वर्ग समूह (Ideal Class Group) की बाधा” और “इकाई समूह (Unit Group) की बाधा” कहा जाता है। GNFS में, इस दीवार को तोड़ने के लिए ** “द्विघाती वर्णों (Quadratic Characters)” ** नामक जादू का उपयोग किया जाता है। Phase 4 के मैट्रिक्स में, दर्जनों विशेष अभाज्य आदर्शों के लिए द्विघाती अवशेषों (लेजेंड्रे प्रतीक) की पंक्तियों को चुपके से पहले से जोड़ दिया जाता है। इस वजह से, पाया गया सेट $S$ भारी संभावना के साथ बाधाओं को बायपास करेगा, और सुरक्षित रूप से “सच्चे तत्व का वर्ग $\gamma^2$” बनाएगा।

$\gamma$ (बीजीय वर्गमूल) ज्ञात करने का कार्य Montgomery विधि जैसे अत्यंत जटिल एल्गोरिदम का उपयोग करके किया जाता है।

और अंततः, बीजीय पक्ष के वर्गमूल $\gamma$ को रिंग होमोमोर्फिज्म $\phi$ द्वारा वास्तविक दुनिया में ले जाया जाता है ($x$ के लिए $m$ प्रतिस्थापित करके), जिससे हमें $Y$ मिलता है। यदि हम परिमेय पक्ष के $V$ को वैसे ही $X$ के रूप में रखते हैं, तो वह पूर्ण समीकरण जो हम खोज रहे थे, अंततः पूरा हो जाता है।

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

अब बस $\gcd(X-Y, N)$ की गणना करनी है। 0.001 सेकंड का प्रसंस्करण चलता है, और जैसे ही गैर-तुच्छ कारक स्क्रीन पर प्रिंट होते हैं, अभेद्य मानी जाने वाली RSA क्रिप्टोग्राफी पूरी तरह से ढह जाती है।

निष्कर्ष

GNFS सिर्फ एक प्रोग्रामिंग तकनीक नहीं है। यह मानव बुद्धि का क्रिस्टलीकरण है जिसने “शुद्ध गणित की गहराइयों” जैसे अमूर्त बीजगणित (abstract algebra), रिंग थ्योरी (ring theory), और आदर्श वर्ग समूहों (ideal class groups) को “चरम इंजीनियरिंग” जैसे सुपरकंप्यूटर वितरित आर्किटेक्चर और कैश अनुकूलन के साथ जीत लिया है।

हम जिन चैट और क्रेडिट कार्ड की जानकारी को लापरवाही से भेजते हैं, वे ऐसे खगोलीय गणितीय बचावों द्वारा संरक्षित हैं।

हमें उम्मीद है कि इस C++ फ्रेमवर्क के माध्यम से, आप अत्याधुनिक क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम के पीछे “गणित और कंप्यूटर के रोमांस” को महसूस करेंगे।

C++ से Microsoft.Windows.AI को कॉल करने का तरीका

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

🎯 C++ से `Microsoft.Windows.AI` को कॉल करने का तरीका【उदाहरण कोड के साथ】

Windows 10 और उसके बाद के संस्करणों में, Windows मानक रूप से एक रनटाइम के साथ आता है जो ONNX प्रारूप के AI मॉडल को निष्पादित कर सकता है । वह Windows ML (Windows.AI.MachineLearning) है।

इस लेख में, हम C++ (Win32 ऐप आधारित) से Microsoft.Windows.AI.MachineLearning को कॉल करने का तरीका, उदाहरण कोड के साथ विस्तार से समझाएंगे।

✅ तैयारी

◾ आवश्यक परिवेश

Windows 10 (1809+) या Windows 11
Visual Studio 2019 या नया (Community संस्करण भी ठीक है)
C++/WinRT समर्थन (Microsoft.Windows.CppWinRT)
Windows SDK 10.0.17763.0 या उच्चतर

✅ प्रोजेक्ट संरचना

Visual Studio में निम्नलिखित संरचना के साथ एक प्रोजेक्ट बनाएं।

प्रकार: C++ Windows डेस्कटॉप एप्लिकेशन (खाली प्रोजेक्ट)
सबसिस्टम: Windows (WinMain)
NuGet के माध्यम से निम्नलिखित पैकेज जोड़ें
1

Microsoft.Windows.CppWinRT

✅ उदाहरण कोड

नीचे WinMain का उपयोग करके Win32 API और Windows.AI.MachineLearning को संयोजित करने वाला एक न्यूनतम उदाहरण दिया गया है।

※ उपयोग किया जाने वाला ONNX मॉडल model.onnx है, और इसे निष्पादन योग्य फ़ाइल (executable file) के समान फ़ोल्डर में रखा जाना चाहिए।

`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") // WinRT लिंकिंग के लिए

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

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE, LPSTR, int nCmdShow)
{
 // WinRT आरंभीकरण (MTA या STA ठीक है)
 winrt::init_apartment();

 try {
 // मॉडल फ़ाइल लोड करें
 auto modelFile = StorageFile::GetFileFromPathAsync(L"model.onnx").get();
 LearningModel model = LearningModel::LoadFromStorageFileAsync(modelFile).get();

 // सत्र (Session) बनाएं
 LearningModelSession session(model);
 LearningModelBinding binding(session);

 // मॉडल इनपुट/आउटपुट (यहाँ एक डमी खाली इनपुट है)
 // वास्तव में TensorFloat आदि के साथ बाइंड करना आवश्यक है

 // अनुमान (Inference) निष्पादित करें
 auto result = session.EvaluateAsync(binding, L"").get();

 MessageBox(nullptr, L"अनुमान पूरा हुआ", L"Windows ML (C++)", MB_OK);
 }
 catch (winrt::hresult_error const& ex) {
 MessageBox(nullptr, ex.message().c_str(), L"त्रुटि", MB_ICONERROR);
 }

 return 0;
}

✅ अतिरिक्त जानकारी: इनपुट और आउटपुट Tensor निर्दिष्ट करने का तरीका

कुछ मॉडलों के लिए, अनुमान (inference) से पहले Tensor का निर्माण और बाइंडिंग आवश्यक है।

उदाहरण:

1
2
3
4
5
6
7
8


// 1-आयामी float सरणी को Tensor में बदलें
std::vector<float> inputData = {0.5f, 0.3f, 0.2f};
std::vector<int64_t> shape = {1, 3}; // आकार: [1, 3]

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

// इनपुट बाइंडिंग (मॉडल के इनपुट नाम से मेल खाना चाहिए)
binding.Bind(L"input_0", tensor);

आउटपुट को भी इसी तरह result.Outputs().Lookup(L"output_0") का उपयोग करके प्राप्त किया जा सकता है।

✅ डिबगिंग के लिए ध्यान रखने योग्य बातें

यदि मॉडल फ़ाइल निष्पादन फ़ोल्डर में मौजूद नहीं है, तो FileNotFoundException फेंका जाएगा।
यदि इनपुट/आउटपुट नाम मेल नहीं खाते हैं, तो invalid_argument त्रुटि होगी।
मॉडल के सटीक IO विनिर्देशों की जांच Netron जैसे उपकरणों से की जा सकती है।

✅ निष्कर्ष

आइटम	विवरण
उपयोग किया गया API	Windows.AI.MachineLearning (WinRT)
भाषा	C++ (Win32 आधारित)
अनुशंसित विधि	C++/WinRT हेडर के माध्यम से
लाभ	ONNX मॉडल मूल रूप से (natively) चलते हैं, GPU समर्थन भी उपलब्ध है
ध्यान दें	मॉडल इनपुट नाम और Tensor आकार पर ध्यान दें

✅ विकल्प: उन लोगों के लिए जो WinRT का उपयोग नहीं करना चाहते हैं

Microsoft के ONNX Runtime का उपयोग करके, आप पूरी तरह से WinRT के बिना C++ से ONNX मॉडल को संभाल सकते हैं ।
यह क्रॉस-प्लेटफ़ॉर्म समर्थित है, और Windows/Linux के लिए सामान्य कोड संभव है।

📌 निष्कर्ष

Windows ML (Microsoft.Windows.AI) एक शक्तिशाली AI अनुमान इंजन (inference engine) है जिसे C++ से मज़बूती से उपयोग किया जा सकता है। यदि आपको Windows पर नेटिव अनुमान की आवश्यकता है, तो कृपया इसे आज़माएँ।

जिन लोगों को ONNX मॉडल बनाने और Tensor बाइंडिंग के विशिष्ट उदाहरण चाहिए, हम भविष्य के लेख में उन्हें समझाने की योजना बना रहे हैं!

TinyLLaMA को C++ से कॉल करने की प्रक्रिया (llama.cpp का उपयोग करके)

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

✅ TinyLLaMA × C++ सेटअप प्रक्रिया (`llama.cpp` का उपयोग करके)

🔧 Step 1: llama.cpp तैयार करें

1-1. आवश्यक वातावरण (न्यूनतम)

OS: Windows / Linux / macOS
विकास वातावरण: g++ / clang / MSVC
Git / CMake

1-2. 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

Windows पर, Visual Studio Developer Command Prompt में cmake --build . --config Release का उपयोग करना आसान है।

📦 Step 2: TinyLLaMA मॉडल डाउनलोड और कनवर्ट करें

2-1. HuggingFace से मूल मॉडल प्राप्त करें

उदाहरण: TinyLLaMA-1.1B

1
2
3
4
5
6
7


# आवश्यकतानुसार transformers का उपयोग करके डाउनलोड करें
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

यह Hugging Face प्रारूप में कनवर्ट करने का चरण है।

2-2. GGUF प्रारूप में कनवर्ट करें (`llama.cpp` के लिए)

1
2


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

2-3. मॉडल क्वांटाइजेशन (आकार कम करना)

1

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

q4_0 4bit क्वांटाइजेशन है। मॉडल का आकार लगभग ** 350MB ** तक कम हो जाता है।

🧪 Step 3: C++ से मॉडल को कॉल करें (कोड उदाहरण)

3-1. सरल C++ कोड (अनुमान)

 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 = "उपयोगकर्ता कहता है कि वह Excel डेटा पढ़ना, फ़िल्टर करना और सहेजना चाहता है। नोड कॉन्फ़िगरेशन क्या है?";
 llama_batch batch = llama_batch_init(512, 0, 1);
 llama_token BOS = llama_token_bos(model);
 batch.token[0] = BOS;

 // टोकनाइज़ेशन
 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);

 // अनुमान परिणाम प्राप्त करें
 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;
}

🧱 Step 4: संकलन विधि (उदाहरण)

1

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

libllama.a बिल्ड के बाद build/ निर्देशिका में बनाया जाता है।

✅ आउटपुट संरचना उदाहरण (व्यवस्थित)

1
2
3
4
5
6


my_app/
├── tinyllama-q4.gguf # क्वांटाइज्ड मॉडल (~350MB)
├── main.cpp # उपरोक्त C++ कोड
├── llama.cpp/ # llama.cpp स्रोत
└── build/
 └── libllama.a # संकलित लाइब्रेरी

🧠 उपयोग के मामले में लागू करने के लिए पूरक

आउटपुट प्राप्त करने और नोड टेम्पलेट से मिलान / चयन करने के लिए C++ में कोड रखें
उदाहरण: यदि “Excel”, “फ़िल्टर”, “सहेजें” शामिल हैं → संबंधित नोड समूह उत्पन्न करें
यह भाग if स्टेटमेंट + JSON टेम्पलेट लोडिंग जैसी सरल संरचना के साथ ठीक है

📌 सारांश

आइटम	विवरण
अनुशंसित मॉडल	TinyLLaMA-1.1B-Chat v1.0 (GGUF + क्वांटाइजेशन)
आकार	~350 से 450MB (4bit क्वांटाइजेशन)
C++ एकीकरण	`llama.cpp` का उपयोग करके संभव है, लगभग कोई बाहरी निर्भरता नहीं
प्रसंस्करण क्षमता	सरल इरादे को समझने और आउटपुट वाक्य उत्पन्न करने के लिए पर्याप्त (प्राकृतिक वाक्य → संरचना)
विस्तारशीलता	स्लॉट-फिलिंग और टेम्पलेट कॉलिंग के साथ मिलकर, इसे एक नोड जेनरेशन AI बनाया जा सकता है

Slack App + OAuth2 का उपयोग करके Slack पर संदेश कैसे पोस्ट करें

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

✅ एक्सेस टोकन का उपयोग करके पोस्ट करने की विधि (Slack Web API)

Slack का “OAuth Token (जैसे xoxb-…)” Slack के Web API का उपयोग करके पोस्ट करने के लिए एक कुंजी है। इस मामले में, Webhook के विपरीत, आप Authorization: Bearer हेडर के साथ Slack API एंडपॉइंट पर POST करते हैं।

🔑 आवश्यक शर्तें

आपको Slack ऐप के OAuth स्कोप में chat:write शामिल करना होगा:

सेटअप प्रक्रिया

https://api.slack.com/apps पर जाएं
एक ऐप बनाएं या मौजूदा ऐप चुनें
“OAuth & Permissions” > Scopes में → chat:write जोड़ें
“Install to Workspace” या “Reinstall” पर जाएं और Access Token प्राप्त करें (उदा: xoxb-xxxxxxxxxx)

💻 C++ कोड (WinHTTP के साथ Slack API पर पोस्ट करना)

 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 हेडर और Content-Type
 std::wstring headers = L"Content-Type: application/json\r\n";
 headers += L"Authorization: Bearer " + accessToken + L"\r\n";

 // 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 << "भेजने में त्रुटि\n";
 return false;
 }

 // स्थिति कोड की जाँच
 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-आपका_एक्सेस_टोकन"; // एक्सेस टोकन
 std::string channel = "चैनल_ID_या_#general"; // उदा: "#general" या "C0123456789"
 std::string message = "C++ से Slack पर पोस्ट करने का प्रयास!";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "पोस्ट सफल!\n";
 } else {
 std::cerr << "पोस्ट विफल।\n";
 }

 return 0;
}

📌 चैनल ID कैसे प्राप्त करें

केवल चैनल नाम (उदा: #general) का उपयोग करने से त्रुटि हो सकती है। सबसे विश्वसनीय तरीका Slack चैनल पृष्ठ URL में ID का उपयोग करना है।

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑यह हिस्सा चैनल ID है

✅ टोकन के प्रकार (पूरक)

टोकन प्रारूप	उपयोग	उदाहरण
`xoxb-...`	Bot Token (अनुशंसित)	पोस्ट, संपादित करें, हटाएं
`xoxp-...`	User Token (अनुशंसित नहीं)	गैर-बॉट संचालन
Refresh Token	दीर्घकालिक टोकन अपडेट के लिए	आमतौर पर उपयोग नहीं किया जाता है

📝 सारांश

C++ से Slack पर पोस्ट करने के लिए, Slack Web API + Bearer Token विधि विश्वसनीय है
HTTPS POST के साथ chat.postMessage एंडपॉइंट का उपयोग करें
टोकन को Bearer हेडर में भेजा जाना चाहिए
चैनल ID निर्दिष्ट करना विश्वसनीय है

C++ (Win32 API + WinHTTP) के साथ Slack पर संदेश कैसे भेजें [Webhook समर्थित]

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

C++ (Win32 API + WinHTTP) के साथ Slack पर संदेश कैसे भेजें [Webhook समर्थित]

मैं C++ से Slack पर एक संदेश पोस्ट करना चाहता हूँ। यह Node.js और Python में आम है, लेकिन “C++ × Win32 API × WinHTTP” का उपयोग करने के मामले दुर्लभ हैं, है ना?

इस लेख में, हम Webhook URL का उपयोग करके C++ से Slack पर संदेश भेजने का तरीका चरण-दर-चरण समझाएंगे।

✅ पूरी प्रक्रिया

Slack पर पोस्ट करने के लिए, इन चरणों का पालन करें।

Slack Webhook URL (API कुंजी) प्राप्त करें
WinHTTP का उपयोग करके POST अनुरोध भेजें
संदेश के मुख्य भाग को JSON प्रारूप में बनाएँ
परिणाम की जाँच करें और पूरा करें!

🔑 Step1: Slack Webhook URL कैसे प्राप्त करें

Slack में, आप Incoming Webhooks नामक सुविधा का उपयोग करके बाहरी सेवाओं से आसानी से संदेश पोस्ट कर सकते हैं।

प्राप्ति के चरण

https://api.slack.com/apps पर जाएँ
Create New App पर क्लिक करें
From scratch चुनें, ऐप का नाम और पोस्ट करने के लिए कार्यक्षेत्र (workspace) चुनें
बाएँ मेनू से “Incoming Webhooks” चुनें, और इसे सक्षम करें
“Add New Webhook to Workspace” पर क्लिक करें, और एक चैनल चुनें
जारी किए गए URL को कॉपी करें (उदाहरण: https://hooks.slack.com/services/xxx/yyy/zzz)

यह URL एक API कुंजी की तरह काम करता है।

💻 Step2: C++ कोड के साथ Slack पर संदेश भेजें

प्रयुक्त तकनीकें

Win32 API
WinHTTP (मानक पुस्तकालय)
JSON प्रारूप में संदेश

नमूना कोड (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) {
 // 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"URL विश्लेषण विफल रहा\n";
 return false;
 }

 // HTTP सत्र और कनेक्शन
 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 << "भेजने का अनुरोध विफल रहा\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);

 // संसाधन मुक्त करें
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);

 return (statusCode == 200);
}

int main() {
 std::wstring webhookUrl = L"https://hooks.slack.com/services/xxx/yyy/zzz"; // इसे अपने Webhook से बदलें

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

 if (PostToSlack(webhookUrl, message)) {
 std::cout << "पोस्ट सफल रहा!\n";
 } else {
 std::cerr << "पोस्ट विफल रहा।\n";
 }

 return 0;
}

🧪 JSON संदेश को अनुकूलित करना

Slack के Webhook में, आप निम्नलिखित पैरामीटर शामिल कर सकते हैं:

1
2
3
4
5
6


{
 "text": "अधिसूचना सामग्री",
 "username": "बॉट का नाम",
 "icon_emoji": ":rocket:",
 "channel": "#कोई भी चैनल नाम"
}

📌 अतिरिक्त जानकारी

Content-Type को "application/json" के रूप में निर्दिष्ट करना सुनिश्चित करें
Webhook URL को वैसे ही wstring के रूप में पास किया जाता है (URL एन्कोडिंग की आवश्यकता नहीं है)
क्योंकि यह HTTPS संचार है, इसलिए WINHTTP_FLAG_SECURE को न भूलें

🎉 बोनस: Slack में पोस्ट की पुष्टि का उदाहरण

यह Slack में कुछ इस तरह दिखाई देगा:

1
2


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

✍️ निष्कर्ष

आइटम	विवरण
पोस्टिंग विधि	Webhook (Incoming Webhooks)
संचार पुस्तकालय	WinHTTP
डेटा प्रारूप	JSON
उपलब्ध पैरामीटर	text, username, icon_emoji, channel आदि

यदि आपने कभी सोचा था कि C++ को Slack के साथ एकीकृत करना मुश्किल है… तो आप आज से ही एक सूचना बॉट (notification bot) शामिल कर सकते हैं!

🚀 अगला भाग?

अगर आपकी रुचि है, तो अगली बार हम:

फ़ाइल संलग्न करना
बटन के साथ UI
Slack App + OAuth2 के माध्यम से लचीला API संचालन

जैसे कुछ और उन्नत Slack एकीकरण भी प्रस्तुत कर सकते हैं!

C++ से Microsoft Teams में संदेश कैसे भेजें (WinHTTP + Graph API)

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

C++ से Microsoft Teams में संदेश कैसे भेजें (WinHTTP + Graph API)

Microsoft Teams के चैट में स्वचालित रूप से पोस्ट करना चाहते हैं――
ऐसी स्थिति में आप Microsoft Graph API का उपयोग कर सकते हैं।
इस लेख में, हम WinHTTP का उपयोग करते हुए C++ कोड उदाहरण और आवश्यक API प्रमाणीकरण प्रक्रिया को चरण-दर-चरण (step-by-step) प्रस्तुत करेंगे।

🔧 आवश्यक तैयारी (Microsoft Graph API प्रमाणीकरण सेटिंग)

1. Azure पोर्टल में ऐप पंजीकरण

सबसे पहले, Microsoft Graph API का उपयोग करने के लिए, आपको Azure में एक ऐप पंजीकृत करना होगा।

Azure Portal पर जाएं
“Microsoft Entra ID” > "＋ जोड़ें (Add)" > “ऐप पंजीकरण (App registrations)” > “नया पंजीकरण (New registration)”
कोई भी ऐप नाम दर्ज करें और “पंजीकरण (Register)” पर क्लिक करें

2. API अनुमतियां जोड़ें

बाएं मेनू में “API अनुमतियां (API permissions)” पर जाएं
“Microsoft Graph” > “अनुमतियां चुनें (Select permissions)” में निम्नलिखित स्कोप खोजें और “अनुमतियां अपडेट करें (Update permissions)” पर क्लिक करें:

Chat.ReadWrite
User.Read

※ यदि आप किसी चैनल पर पोस्ट करना चाहते हैं तो ChannelMessage.Send भी आवश्यक है

3. क्लाइंट ID और टेनेंट ID नोट करें

“अवलोकन (Overview)” टैब में प्रदर्शित होने वाली इन 2 चीजों को नोट कर लें:

एप्लीकेशन (क्लाइंट) ID
निर्देशिका (टेनेंट) ID

4. क्लाइंट सीक्रेट बनाएं

“प्रमाणपत्र और सीक्रेट (Certificates & secrets)” टैब पर जाएं
“नया क्लाइंट सीक्रेट (New client secret)” > समाप्ति तिथि निर्धारित करें और “जोड़ें (Add)” पर क्लिक करें
प्रदर्शित मूल्य (सीक्रेट) को उसी समय अनिवार्य रूप से नोट कर लें

🔐 एक्सेस टोकन प्राप्त करना (OAuth2)

प्राप्त करने के लिए client_credentials फ्लो का उपयोग किया जाता है।
एक्सेस टोकन प्राप्त करने के लिए curl का उपयोग करके निम्नलिखित कमांड चलाएं।

1
2
3
4
5
6
7


curl -X POST ^
 https://login.microsoftonline.com/{टेनेंट ID}/oauth2/v2.0/token ^
 -H "Content-Type: application/x-www-form-urlencoded" ^
 -d "client_id={क्लाइंट ID}" ^
 -d "scope=https%3A%2F%2Fgraph.microsoft.com%2F.default" ^
 -d "client_secret={क्लाइंट सीक्रेट}" ^
 -d "grant_type=client_credentials"

प्रतिक्रिया उदाहरण

1
2
3
4
5
6


{
 "token_type":"Bearer",
 "expires_in":3599,
 "ext_expires_in":3599,
 "access_token": "eyJ0eXAiOiJKV1QiLCJub...（छोड़ा गया）"
}

इस access_token का उपयोग करके Microsoft Graph API को कॉल किया जाता है।

💬 Teams चैट में पोस्ट करने के लिए C++ उदाहरण

यहाँ WinHTTP का उपयोग करके चैट में पोस्ट करने का एक C++ उदाहरण दिया गया है।

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

🔍 चैट ID प्राप्त करने का तरीका

चैट ID को 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"

प्रतिक्रिया उदाहरण

1
2
3
4
5
6
7
8
9


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

📌 ध्यान देने योग्य बातें

यह उदाहरण एक न्यूनतम कार्यान्वयन है। वास्तविक उपयोग में:
- टोकन की समाप्ति (expiration) को संभालना
- HTTPS प्रमाणपत्र का सत्यापन
- त्रुटि हैंडलिंग में सुधार
चैनल में पोस्ट करने के लिए teams/{team-id}/channels/{channel-id}/messages का उपयोग किया जाता है।
अटैचमेंट भेजने के लिए मल्टीपार्ट प्रोसेसिंग या Graph ड्राइव API की आवश्यकता होती है।

निष्कर्ष

📎 निष्कर्ष

फ़ीचर	विवरण
Graph API	Teams के साथ संवाद करने के लिए आधिकारिक API
ऐप पंजीकरण	Azure पर आवश्यक प्रमाणीकरण प्रक्रिया
एक्सेस टोकन	OAuth2 के माध्यम से प्राप्त किया जाता है, और अनुरोधों के लिए उपयोग किया जाता है
C++ कार्यान्वयन	Graph API को कॉल करने के लिए WinHTTP का उपयोग करता है

🚀 अगले कदम

अधिक उन्नत उदाहरण के रूप में, निम्नलिखित भी संभव हैं:

टीम चैनल में पोस्ट करना (/teams/{team-id}/channels/...)
अटैचमेंट के साथ पोस्ट करना
बॉट अकाउंट और यूज़र अकाउंट के बीच स्विच करना
टोकन प्राप्त करने सहित पूर्ण C++ कार्यान्वयन

यदि आपके कोई प्रश्न या अनुरोध हैं, तो बेझिझक टिप्पणी करें!

Win32API + C++ के साथ प्रोग्राम बनाने के फायदे और नुकसान

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

Win32API + C++ के साथ विकास का आकर्षण और चुनौतियाँ

उन लोगों के लिए जो विंडोज ऐप डेवलपमेंट में महारत हासिल करना चाहते हैं, Win32API + C++ अभी भी एक शक्तिशाली विकल्प है। यह संयोजन, जो ऑपरेटिंग सिस्टम के साथ सबसे करीबी संभव बातचीत की अनुमति देता है, गति और लचीलापन दोनों प्रदान करता है।

दूसरी ओर, इसे मास्टर करने के लिए दृढ़ संकल्प की आवश्यकता होती है, क्योंकि यह आधुनिक विकास शैलियों से काफी भिन्न है।

इस पृष्ठ पर, हम एक सक्रिय विंडोज ऐप डेवलपर के दृष्टिकोण से फायदे और नुकसान को स्पष्ट रूप से समझाएंगे।

फायदे

अल्ट्रा-फास्ट नेटिव निष्पादन

चूंकि C++ और Win32API ऑपरेटिंग सिस्टम के सबसे करीब की परत पर काम करते हैं, इसलिए लगभग कोई अनावश्यक ओवरहेड नहीं है। CPU और मेमोरी का उपयोग अत्यंत कुशल है, जो एक भारी निष्पादन गति का दावा करता है।

उच्च लचीलापन और स्वतंत्रता

आप ऐप के सभी व्यवहारों को स्वयं बारीकी से नियंत्रित कर सकते हैं, जैसे विंडो नियंत्रण, एसिंक्रोनस प्रोसेसिंग, COM एकीकरण और प्रक्रिया प्रबंधन। विशिष्ट उपकरण और अपने स्वयं के मूल ढांचे बनाना भी संभव है।

रनटाइम की आवश्यकता के बिना वितरित करने में आसान

चूंकि .NET या Java जैसे किसी बाहरी रनटाइम की आवश्यकता नहीं है, इसे एकल निष्पादन योग्य फ़ाइल के रूप में वितरित किया जा सकता है । पुनर्वितरण के दौरान समस्याओं का खतरा कम होता है और इंस्टॉलर के बिना इसे चलाना आसान होता है।

हल्के ऐप्स बना सकते हैं

चूंकि इसके लिए केवल न्यूनतम आवश्यक कॉन्फ़िगरेशन की आवश्यकता होती है, इसकी विशेषता यह है कि इसका मेमोरी फ़ुटप्रिंट बहुत छोटा होता है। यह कम विशिष्टताओं वाले पीसी या वर्चुअल मशीन वातावरण पर भी आराम से चलता है।

उन्नत ओएस-स्तरीय नियंत्रण संभव

आप ऐसे नियंत्रणों को भी महसूस कर सकते हैं जो सामान्य भाषाओं और पुस्तकालयों के साथ कठिन हैं , जैसे वैश्विक माउस और कीबोर्ड हुक, विंडो शैलियों की फाइन-ट्यूनिंग, और सिस्टम मेनू संचालन।

नुकसान

कम विकास दक्षता

यहां तक कि GUI का निर्माण भी पूरी तरह से कोड में किया जाना चाहिए, और कभी-कभी सिर्फ एक बटन बनाने के लिए कोड की दर्जनों पंक्तियों की आवश्यकता होती है । डिज़ाइन को संशोधित करना भी जटिल है, और UI फ्रेमवर्क का उपयोग करके विकास की तुलना में उत्पादकता कम है।

रखरखाव को कम करने में आसान

संदेश लूप और विंडो प्रक्रियाओं जैसे विशेष संरचनाओं वाले कई कोड हैं, जो पठनीयता और पुन: प्रयोज्यता में बाधा डालते हैं। इसके ऐसे पहलू भी हैं जो टीम के विकास और दीर्घकालिक रखरखाव के लिए अनुपयुक्त हैं।

आधुनिक यूआई का समर्थन करना मुश्किल

हाल के वर्षों में आवश्यक UX का समर्थन करना मुश्किल है , जैसे कि उच्च DPI समर्थन, टच इंटरफेस, एक्सेसिबिलिटी और डार्क मोड। आपको प्रत्येक को मैन्युअल रूप से संभालना होगा, जिसमें बहुत प्रयास की आवश्यकता होती है।

क्रॉस-प्लेटफॉर्म का समर्थन नहीं करता

चूंकि यह पूरी तरह से विंडोज-अनन्य एपीआई है, इसलिए इसे macOS या Linux पर पोर्ट नहीं किया जा सकता है। यदि आप क्रॉस-प्लेटफॉर्म परिनियोजन की योजना बनाते हैं, तो आपको अन्य तकनीकों का चयन करना होगा।

अत्यधिक उच्च सीखने की लागत

आपको उन अवधारणाओं और तंत्रों को समझना चाहिए जिनका आज शायद ही कभी उपयोग किया जाता है , जैसे कि हैंडल, GDI, COM और OLE। कई दस्तावेज़ पुराने हैं, जिन्हें सीखने के लिए समय और धैर्य की आवश्यकता होती है।

उपयुक्त उपयोग

फ़ाइल लॉन्चर और हॉटकी समर्थकों जैसे हल्के उपकरण
क्लिपबोर्ड हेरफेर और IME नियंत्रण जैसे सिस्टम उपयोगिताओं
वैश्विक हुक और विंडो कैप्चर जैसे देशी नियंत्रण-आधारित ऐप्स
ड्राइवर समर्थन उपकरण जो हार्डवेयर से निकटता से जुड़े हुए हैं

अनुपयुक्त उपयोग

सामान्य उपभोक्ता-सामना करने वाले ऐप्स जहां आधुनिक यूआई / यूएक्स महत्वपूर्ण हैं
प्रोटोटाइपिंग और एमवीपी विकास गति को ध्यान में रखकर बनाए गए हैं
दीर्घकालिक संचालन और टीम के विकास के आधार पर बड़े पैमाने की परियोजनाएं
क्रॉस-प्लेटफॉर्म उत्पाद जिन्हें कई ऑपरेटिंग सिस्टम का समर्थन करने की आवश्यकता होती है

मूल्यांकन सारांश

दृष्टिकोण	मूल्यांकन
निष्पादन की गति	◎ बहुत तेज
मेमोरी दक्षता	◎ उत्कृष्ट
विकास की गति	× धीमी
रखरखाव	× कम
क्रॉस-प्लेटफॉर्म समर्थन	× समर्थित नहीं
आधुनिक यूआई समर्थन	× कमजोर
ओएस नियंत्रण की स्वतंत्रता	◎ बहुत अधिक

निष्कर्ष

Win32API + C++ उन डेवलपर्स के लिए एक उपकरण है जो “ऑपरेटिंग सिस्टम में सब कुछ खुद संभालना चाहते हैं”। हालाँकि इसकी शक्ति अपार है, इसके सीखने और संचालन के लिए तदनुसार दृढ़ संकल्प की आवश्यकता होती है।

क्या “साहसपूर्वक चुनना” उचित है, यह आपके द्वारा लक्षित ऐप की प्रकृति पर निर्भर करता है।

जीयूआई फ्रेमवर्क या आधुनिक भाषाओं पर भरोसा किए बिना #include <windows.h> की दुनिया में गोता लगाना ―― वह विकल्प आज भी सार्थक है।

【शुरुआती लोगों के लिए】vcpkg का उपयोग करके Visual Studio में libcurl (OpenSSL समर्थित) स्थापित करने की प्रक्रिया

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

अगर आप Visual Studio में libcurl (OpenSSL समर्थित) का उपयोग करना चाहते हैं, तो vcpkg स्थापित करना आसान है और अनुशंसित है

C++ में HTTP संचार को संभालते समय अक्सर libcurl का उपयोग किया जाता है। लेकिन, निर्माण और निर्भरता को समायोजित करना आश्चर्यजनक रूप से परेशानी भरा हो सकता है।

ऐसे समय में Microsoft का C++ लाइब्रेरी प्रबंधन उपकरण ** “vcpkg” ** बहुत काम आता है। इस बार, हम cpkg का उपयोग करके libcurl (OpenSSL समर्थित) स्थापित करने और इसे Visual Studio में सुचारू रूप से उपयोग करने योग्य बनाने की प्रक्रिया का परिचय देंगे।

vcpkg की स्थापना (केवल उनके लिए जिन्होंने इसे स्थापित नहीं किया है)

सबसे पहले cpkg स्थापित करते हैं। कृपया PowerShell में निम्न चरणों का पालन करें।

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

※यदि आपने अभी तक Git स्थापित नहीं किया है, तो कृपया इसे Git की आधिकारिक वेबसाइट से स्थापित करें।

libcurl (OpenSSL समर्थित) की स्थापना

इसके बाद, vcpkg का उपयोग करके libcurl स्थापित करें। OpenSSL का समर्थन करने वाले 64-बिट संस्करण को निर्दिष्ट करने के लिए, निम्न कमांड चलाएँ।

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

इस कमांड को चलाने पर, आवश्यक निर्भरताएँ (जैसे OpenSSL) भी स्वचालित रूप से सेट हो जाती हैं।

Visual Studio के साथ एकीकरण सेटिंग

vcpkg द्वारा स्थापित लाइब्रेरीज़ को अपने Visual Studio प्रोजेक्ट से आसानी से उपयोग करने के लिए, निम्नलिखित कमांड के साथ एकीकरण सेटिंग्स कॉन्फ़िगर करें।

powershell vcpkg integrate install

एक बार यह सेट हो जाने पर, #include <curl/curl.h> स्वचालित रूप से Visual Studio प्रोजेक्ट्स में उपलब्ध हो जाएगा, और आपको मैन्युअल रूप से लाइब्रेरी पथ या लिंकर सेटिंग्स को कॉन्फ़िगर करने की आवश्यकता नहीं होगी।

निष्कर्ष

इसके साथ, Visual Studio में libcurl (OpenSSL समर्थित) स्थापित करने की तैयारी पूरी हो गई है।

vcpkg का उपयोग करके, आप एक साथ परेशानी वाली निर्भरताओं को प्रबंधित कर सकते हैं
cpkg install curl[ssl] –triplet x64-windows के साथ आसानी से libcurl स्थापित करें
cpkg integrate install के साथ Visual Studio के साथ स्वचालित एकीकरण संभव है

अब, बस अपने प्रोजेक्ट में हेडर को शामिल करें और विकास शुरू करने के लिए libcurl के API का उपयोग करें। कृपया सुविधाजनक vcpkg का लाभ उठाएं और अपने विकास की दक्षता को बढ़ाएं।

C++ से C++/CLI DLL के माध्यम से PowerShell को निष्पादित करने के चरण

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

🎯 C++ से C++/CLI DLL के माध्यम से PowerShell को निष्पादित करने के चरण (Visual Studio 2022 / C++)

✅ समग्र वास्तुकला

🔹 ① CLI रैपर DLL (C++/CLI)

PowerShell स्क्रिप्ट को निष्पादित करने की कार्यक्षमता प्रदान करता है।

🔹 ② नेटिव C++ कॉलर

PowerShell स्क्रिप्ट चलाने के लिए CLI DLL को कॉल करता है।

🔧 चरण 1: CLI रैपर DLL प्रोजेक्ट बनाना

1. प्रोजेक्ट बनाना

[नया प्रोजेक्ट बनाएँ] → [C++] → CLR क्लास लाइब्रेरी (.NET Framework)
नाम: PowerShellWrapper

💡 यदि यह टेम्प्लेट प्रदर्शित नहीं होता है, तो “.NET डेस्कटॉप विकास” वर्कलोड स्थापित करें।

2. NuGet पैकेज जोड़ें

प्रोजेक्ट पर राइट-क्लिक करें → [NuGet पैकेज प्रबंधित करें]
System.Management.Automation खोजें और स्थापित करें
(संस्करण 5.x या 7.x)

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

🔧 चरण 2: नेटिव C++ से कॉल करना

1. C++ कंसोल ऐप प्रोजेक्ट बनाना

नाम: NativeApp

2. संदर्भ सेटिंग

प्रोजेक्ट पर राइट-क्लिक करें → [जोड़ें] → [संदर्भ] → प्रोजेक्ट → PowerShellWrapper जोड़ें
[गुण] → [C/C++] → [कॉमन लैंग्वेज रनटाइम सपोर्ट] → /clr में बदलें

3. निष्पादन कोड (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;
}

💡 अतिरिक्त जानकारी (IDL / TLB / COM पंजीकरण)

यह कॉन्फ़िगरेशन COM के बजाय सीधे .NET DLL को संदर्भित करता है, इसलिए IDL, TLB, या COM पंजीकरण की आवश्यकता नहीं है ।

✅ अंतिम वास्तुकला

1
2
3
4
5


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

C++ से C++/CLI DLL के माध्यम से PowerShell को निष्पादित करने के चरण

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

🎯 C++ से C++/CLI DLL के माध्यम से PowerShell को निष्पादित करने के चरण (Visual Studio 2022 / C++)

✅ समग्र वास्तुकला

🔹 ① CLI रैपर DLL (C++/CLI)

PowerShell स्क्रिप्ट को निष्पादित करने की कार्यक्षमता प्रदान करता है।

🔹 ② नेटिव C++ कॉलर

PowerShell स्क्रिप्ट चलाने के लिए CLI DLL को कॉल करता है।

🔧 चरण 1: CLI रैपर DLL प्रोजेक्ट बनाना

1. प्रोजेक्ट बनाना

[नया प्रोजेक्ट बनाएँ] → [C++] → CLR क्लास लाइब्रेरी (.NET Framework)
नाम: PowerShellWrapper

💡 यदि यह टेम्प्लेट प्रदर्शित नहीं होता है, तो “.NET डेस्कटॉप विकास” वर्कलोड स्थापित करें।

2. NuGet पैकेज जोड़ें

प्रोजेक्ट पर राइट-क्लिक करें → [NuGet पैकेज प्रबंधित करें]
System.Management.Automation खोजें और स्थापित करें
(संस्करण 5.x या 7.x)

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

🔧 चरण 2: नेटिव C++ से कॉल करना

1. C++ कंसोल ऐप प्रोजेक्ट बनाना

नाम: NativeApp

2. संदर्भ सेटिंग

प्रोजेक्ट पर राइट-क्लिक करें → [जोड़ें] → [संदर्भ] → प्रोजेक्ट → PowerShellWrapper जोड़ें
[गुण] → [C/C++] → [कॉमन लैंग्वेज रनटाइम सपोर्ट] → /clr में बदलें

3. निष्पादन कोड (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;
}

💡 अतिरिक्त जानकारी (IDL / TLB / COM पंजीकरण)

यह कॉन्फ़िगरेशन COM के बजाय सीधे .NET DLL को संदर्भित करता है, इसलिए IDL, TLB, या COM पंजीकरण की आवश्यकता नहीं है ।

✅ अंतिम वास्तुकला

1
2
3
4
5


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

C++ में वर्तमान समय को ISO 8601 प्रारूप में कैसे प्रिंट करें

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

पूर्व शर्तें

ISO C++ 20 मानक (/std:c++20)

कोड

1
2
3
4


#include <chrono>
#include <format>

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

इस प्रकार आप C++ में वर्तमान समय को ISO 8601 प्रारूप में प्रिंट कर सकते हैं।

संदर्भ

std::format

Windows पर OpenSSL को कैसे बिल्ड करें

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

OpenSSL क्या है?

यह एक ओपन-सोर्स लाइब्रेरी है जो एन्क्रिप्टेड संचार करने के लिए आवश्यक प्रोसेसिंग प्रदान करती है।

इसे किसी प्रोग्राम से उपयोग करने के लिए, चूंकि C स्रोत कोड प्रकाशित है, आपको लाइब्रेरी बनाने के लिए इसे बिल्ड करना होगा।

नीचे, हम बिल्ड प्रक्रिया का परिचय दे रहे हैं।

बिल्ड वातावरण की तैयारी

Perl

https://strawberryperl.com/ से strawberry-perl-5.32.1.1-64bit.msi डाउनलोड करें। नवीनतम संस्करण ठीक रहेगा।
NASM

https://www.nasm.us/ के Download से 2.16.01/nasm-2.16.01-win64.zip डाउनलोड करें। नवीनतम गैर-RC संस्करण ठीक रहेगा। स्थापना के बाद, आपको उस फ़ोल्डर को पर्यावरण चर PATH में पंजीकृत करना होगा जहाँ NASM स्थापित है।
Visual Studio 2022 या Build Tools for Visual Studio 2022

https://visualstudio.microsoft.com/ja/downloads/ से Visual Studio 2022 Community या Build Tools for Visual Studio 2022 इंस्टॉल करें।

Windows पर OpenSSL बिल्ड प्रक्रिया

https://www.openssl.org/source/ से openssl-3.1.0.tar.gz डाउनलोड करें और इसे एक्सट्रेक्ट करें। यदि आप इसे एक्सट्रेक्ट नहीं कर सकते हैं, तो कमांड प्रॉम्प्ट में tar -xzf openssl-3.1.0.tar.gz चलाएँ।
प्रशासक विशेषाधिकारों के साथ कमांड प्रॉम्प्ट प्रारंभ करें।
एक्सट्रेक्ट किए गए फ़ोल्डर को खोलें।
निम्नलिखित कमांड चलाएँ। *अपने स्थापित Visual Studio संस्करण से मेल खाने के लिए Community भाग बदलें।

1

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

निम्नलिखित कमांड चलाएँ:

1

perl Configure VC-WIN64A

निम्नलिखित कमांड चलाएँ (इसमें काफी समय लगता है):

1

nmake

निम्नलिखित कमांड चलाएँ (इसमें काफी समय लगता है):

1

nmake test

निम्नलिखित कमांड चलाएँ:

1

nmake install

यदि सफल होता है, तो OpenSSL C:\Program Files\OpenSSL में स्थापित हो जाएगा।

बस इतना ही।

संदर्भ

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

C++ on kenji.blog

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम "GNFS" को समझना

【संपूर्ण विश्लेषण】C++ में लागू करके सबसे शक्तिशाली क्रिप्टोग्राफी क्रैकिंग एल्गोरिदम “GNFS” को समझना

1. GNFS अत्याधुनिक लॉजिक फ्रेमवर्क (संपूर्ण स्रोत कोड)

2. GNFS का अंतिम लक्ष्य: $X^2 \equiv Y^2 \pmod N$

3. Phase 1: बहुपद चयन (Polynomial Selection)

4. Phase 2: विशेष $q$ जालक चलनी (Special-q Lattice Sieving)

5. Phase 3: फ़िल्टरिंग (Filtering)

6. Phase 4: GF(2) पर रेखीय बीजगणित (Block Wiedemann विधि)

7. Phase 5: बीजीय वर्गमूल (Algebraic Square Root) और क्रिप्टोग्राफी का पतन

निष्कर्ष

C++ से Microsoft.Windows.AI को कॉल करने का तरीका

🎯 C++ से Microsoft.Windows.AI को कॉल करने का तरीका【उदाहरण कोड के साथ】

✅ तैयारी

◾ आवश्यक परिवेश

✅ प्रोजेक्ट संरचना

✅ उदाहरण कोड

main.cpp

✅ अतिरिक्त जानकारी: इनपुट और आउटपुट Tensor निर्दिष्ट करने का तरीका

✅ डिबगिंग के लिए ध्यान रखने योग्य बातें

✅ निष्कर्ष

✅ विकल्प: उन लोगों के लिए जो WinRT का उपयोग नहीं करना चाहते हैं

📌 निष्कर्ष

TinyLLaMA को C++ से कॉल करने की प्रक्रिया (llama.cpp का उपयोग करके)

✅ TinyLLaMA × C++ सेटअप प्रक्रिया (llama.cpp का उपयोग करके)

🔧 Step 1: llama.cpp तैयार करें

1-1. आवश्यक वातावरण (न्यूनतम)

1-2. llama.cpp प्राप्त करें और बिल्ड करें

📦 Step 2: TinyLLaMA मॉडल डाउनलोड और कनवर्ट करें

2-1. HuggingFace से मूल मॉडल प्राप्त करें

2-2. GGUF प्रारूप में कनवर्ट करें (llama.cpp के लिए)

2-3. मॉडल क्वांटाइजेशन (आकार कम करना)

🧪 Step 3: C++ से मॉडल को कॉल करें (कोड उदाहरण)

3-1. सरल C++ कोड (अनुमान)

🧱 Step 4: संकलन विधि (उदाहरण)

✅ आउटपुट संरचना उदाहरण (व्यवस्थित)

🧠 उपयोग के मामले में लागू करने के लिए पूरक

📌 सारांश

Slack App + OAuth2 का उपयोग करके Slack पर संदेश कैसे पोस्ट करें

✅ एक्सेस टोकन का उपयोग करके पोस्ट करने की विधि (Slack Web API)

🔑 आवश्यक शर्तें

सेटअप प्रक्रिया

💻 C++ कोड (WinHTTP के साथ Slack API पर पोस्ट करना)

📌 चैनल ID कैसे प्राप्त करें

✅ टोकन के प्रकार (पूरक)

📝 सारांश

C++ (Win32 API + WinHTTP) के साथ Slack पर संदेश कैसे भेजें [Webhook समर्थित]

C++ (Win32 API + WinHTTP) के साथ Slack पर संदेश कैसे भेजें [Webhook समर्थित]

✅ पूरी प्रक्रिया

🔑 Step1: Slack Webhook URL कैसे प्राप्त करें

प्राप्ति के चरण

💻 Step2: C++ कोड के साथ Slack पर संदेश भेजें

प्रयुक्त तकनीकें

नमूना कोड (Slack पोस्ट)

🧪 JSON संदेश को अनुकूलित करना

📌 अतिरिक्त जानकारी

🎉 बोनस: Slack में पोस्ट की पुष्टि का उदाहरण

✍️ निष्कर्ष

🚀 अगला भाग?

C++ से Microsoft Teams में संदेश कैसे भेजें (WinHTTP + Graph API)

C++ से Microsoft Teams में संदेश कैसे भेजें (WinHTTP + Graph API)

🔧 आवश्यक तैयारी (Microsoft Graph API प्रमाणीकरण सेटिंग)

1. Azure पोर्टल में ऐप पंजीकरण

2. API अनुमतियां जोड़ें

3. क्लाइंट ID और टेनेंट ID नोट करें

4. क्लाइंट सीक्रेट बनाएं

🔐 एक्सेस टोकन प्राप्त करना (OAuth2)

प्रतिक्रिया उदाहरण

💬 Teams चैट में पोस्ट करने के लिए C++ उदाहरण

🔍 चैट ID प्राप्त करने का तरीका

प्रतिक्रिया उदाहरण

📌 ध्यान देने योग्य बातें

निष्कर्ष

📎 निष्कर्ष

🚀 अगले कदम

Win32API + C++ के साथ प्रोग्राम बनाने के फायदे और नुकसान

Win32API + C++ के साथ विकास का आकर्षण और चुनौतियाँ

फायदे

अल्ट्रा-फास्ट नेटिव निष्पादन

उच्च लचीलापन और स्वतंत्रता

🎯 C++ से `Microsoft.Windows.AI` को कॉल करने का तरीका【उदाहरण कोड के साथ】

`main.cpp`

✅ TinyLLaMA × C++ सेटअप प्रक्रिया (`llama.cpp` का उपयोग करके)

2-2. GGUF प्रारूप में कनवर्ट करें (`llama.cpp` के लिए)