C++ on kenji.blog

"تشريح كامل" فهم أقوى خوارزمية لتحليل التشفير "GNFS" عن طريق تنفيذها بلغة C++

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

“تشريح كامل” فهم أقوى خوارزمية لتحليل التشفير “GNFS” عن طريق تنفيذها بلغة C++

يدعم “تشفير RSA” أسس الإنترنت الحديث. يعتمد أمانه على الاعتقاد الرياضي بأنه “من المستحيل عمليا على أجهزة الكمبيوتر الحالية تحليل عدد مركب عملاق إلى عوامله الأولية”.

ومع ذلك، لم تستسلم البشرية أبدا. حاليا، يوجد ** أقوى وأحدث خوارزمية ** للبشرية لتحليل الأعداد الأولية الضخمة على أجهزة الكمبيوتر الكلاسيكية (أجهزة الكمبيوتر العادية، وليست الكمومية). تسمى هذه الخوارزمية ** “غربال حقل الأعداد العام (GNFS: General Number Field Sieve)” **.

في هذه المقالة، سننشر الكود المصدري بالكامل بلغة C++ (باستخدام أعداد صحيحة متعددة الدقة boost::multiprecision من مكتبة Boost) والذي يجسد بشكل دقيق منطق الحوسبة المتقدم لهذه الخوارزمية، وسنشرح بعمق “نظرية الأعداد الجبرية” التي تقف وراءها.

يرجى الاستمتاع بأسرار الرياضيات وقوة علوم الكمبيوتر التي تقهرها مع الكود المصدري.

1. إطار عمل GNFS المتقدم (الكود المصدري الكامل)

أولا، سنقدم الصورة الكاملة لتنفيذ GNFS بلغة C++ الذي سنشرحه هنا. نظام غربال حقل الأعداد الفعلي (مثل CADO-NFS) هو نظام موزع ضخم يحتوي على مئات الآلاف من أسطر التعليمات البرمجية. ومع ذلك، يقوم هذا الكود باستخراج ** “5 مسارات (مراحل) أساسية” ** تشكل GNFS، وتصميمها كفئات، ونمذجتها في تكوين أدنى دون فقدان معناها الرياضي.

 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 إطار عمل منطقي متقدم
//
// يصمم هذا الكود بشكل دقيق المراحل الخمسة لـ GNFS الحديث
// المستخدم في CADO-NFS وغيرها، كفئات C++ (Boost).
// ============================================================================

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

// ============================================================================
// المرحلة 1: اختيار كثير الحدود (خوارزمية 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) {}

 // توليد كثير الحدود الأولي بناء على توسيع الأساس m (في الواقع يتم استخدام تقليص قاعدة الشبكة LLL الأكثر تقدما)
 void select(const cpp_int& N) {
 std::cout << "[المرحلة 1] اختيار كثير الحدود (الدرجة " << degree << ") يبدأ..." << std::endl;
 // توسيع أساس 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[المرحلة 1] اكتملت." << std::endl;
 }
};

// ============================================================================
// المرحلة 2: غربال الشبكة (Lattice Sieving)
// ============================================================================
// لا يستخدم GNFS الحديث Line Sieve، بل يستخدم
// Special-q Lattice Sieving الذي طوره Franke-Kleinjung كمعيار.
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 << "[المرحلة 2] توليد قواعد العوامل (الحد النسبي: " << rational_bound << "، الحد الجبري: " << algebraic_bound << ")" << std::endl;
 // (محذوف) في الواقع يتم توليد الأعداد الأولية والتصفية باستخدام رموز Legendre
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[المرحلة 2] Special-q Lattice Sieving نشط..." << std::endl;
 std::vector<Relation> relations;
 // تنفيذ وهمي: يقوم غربال الشبكة الفعلي بمسح مئات الجيجابايت من الذاكرة في كتل
 // يتم تعيين الأزواج (a, b) لشبكة (a = i*q + j*...) لكل عدد أولي خاص q،
 // ويتم تشغيل غربلة ترفع كفاءة ذاكرة التخزين المؤقت إلى أقصى حد.

 // إضافة علاقة وهمية واحدة للتوضيح
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[المرحلة 2] تم العثور على " << relations.size() << " علاقة." << std::endl;
 return relations;
 }
};

// ============================================================================
// المرحلة 3: التصفية (إزالة الفردية ودمج الزمرة)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[المرحلة 3] تصفية العلاقات..." << std::endl;
 // 1. إزالة الفردية (إزالة العلاقات التي تحتوي على أعداد أولية تظهر مرة واحدة فقط)
 // 2. دمج الزمرة (دمج العلاقات لتحويل مصفوفة متفرقة إلى كثيفة)
 // في الواقع يتم ضغط مصفوفات بمئات الملايين من الصفوف إلى بضعة ملايين باستخدام خوارزميات مثل Union-Find.
 std::cout << "[المرحلة 3] تم تقليل حجم المصفوفة بشكل مثالي." << std::endl;
 }
};

// ============================================================================
// المرحلة 4: الجبر الخطي فوق 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 << "[المرحلة 4] خوارزمية Block Wiedemann فوق GF(2) تبدأ..." << std::endl;
 // التكرار على حسابات ضرب المصفوفة المتفرقة في المتجه،
 // والعثور على متجهات الحلول (نواة) بحيث M * x = 0 mod 2.

 std::vector<std::vector<int>> dependencies; // قائمة التبعيات
 // بيانات وهمية
 dependencies.push_back({0});

 std::cout << "[المرحلة 4] تم العثور على " << dependencies.size() << " تبعيات خطية (مربعات كاملة)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// المرحلة 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 << "[المرحلة 5] حساب الجذر التربيعي الجبري..." << std::endl;

 // 1. حساب الجذر التربيعي النسبي V
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. حساب الجذر التربيعي الجبري gamma (باستخدام طريقة Montgomery، إلخ)
 // العثور على العنصر gamma في الحقل الجبري الضخم O_K وتحويله إلى العالم الحقيقي باستخدام التماثل phi
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // نفترض أنه تمت إضافة سلسلة من الرموز التربيعية (Quadratic Characters) في المرحلتين 2 و 4
 // لتجنب عقبات (Obstruction) مجموعة أصناف المثاليات ومجموعة الوحدات.

 std::cout << " -> تم تطبيق التماثل phi." << std::endl;
 std::cout << "[المرحلة 5] جار حساب القاسم المشترك الأكبر (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 << "[نجاح] تم العثور على عامل غير بديهي: " << factor << std::endl;
 std::cout << " العامل الآخر: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[فشل] حل بديهي. جاري تجربة التبعية التالية..." << std::endl;
 }
 }
};

// ============================================================================
// مسار التنفيذ الرئيسي
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] محرك General Number Field Sieve (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // عدد مركب ضخم N نريد تحليله، مثل RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // درجة كثير الحدود (عادة يتم اختيار درجة 5 إلى 6 للأرقام الأكبر من 130 رقما)
 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[النظام] اكتمل مسار SOTA GNFS في " << elapsed.count() << " ثانية." << std::endl;

 return 0;
}

إذن، كيف يقوم هذا الكود بتحطيم جدران التشفير؟ سنقوم بتقسيم وشرح الخوارزميات الدقيقة والرياضيات المتقدمة لكل من المراحل الخمس.

2. الهدف النهائي لـ GNFS: $X^2 \equiv Y^2 \pmod N$

ليس فقط GNFS، بل إن هدف معظم الخوارزميات الحديثة لتحليل الأعداد العملاقة هو العثور على زوج غير بديهي $(X, Y)$ يحقق المعادلة التطابقية التالية:

$$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$ (حل غير بديهي)، فهذا يعني أن هناك “قاسما مشتركا أكبر من 1 وأصغر من $N$” بين $(X-Y)$ و $N$. هنا، إذا استخدمنا خوارزمية إقليدس لحساب ** $\gcd(X-Y, N)$ **، فيمكننا بسهولة إيجاد العامل الأولي لـ $N$.

ومع ذلك، فإن العثور على $X$ و $Y$ يشبه البحث عن إبرة في الصحراء. لذلك، يتخذ GNFS نهجا عبقريا من خلال توزيع الحسابات عن طريق إنشاء ** عالمين **: “عالم الأعداد الصحيحة الحقيقية” و “عالم الحقول الجبرية لكثيرات الحدود”.

3. المرحلة 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) والتوسيع بأساس 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)$ بخصائص مهمة للغاية وهي ** “إذا عوضنا $m$ في المتغير $x$، فإن القيمة ستكون بالضبط $N$ ($f(m) = N$)” **. وبعبارة أخرى، $f(m) \equiv 0 \pmod N$. يتم تعريف كثير الحدود النسبي على أنه $g(x) = x - m$.

نتيجة لذلك، يتم ربط ** “عالم الحقل الجبري $\mathbb{Z}[\alpha]$” ** المحكوم بجذور $\alpha$ لـ $f(x)=0$ مع ** “عالم الأعداد النسبية (الصحيحة) $\mathbb{Z}$” ** المعتاد من خلال تماثل الحلقات $x \to m$.

في أنظمة مثل CADO-NFS، يتم استخدام خوارزمية KleinJung وخوارزمية تقليص قاعدة الشبكة LLL للبحث عن “أفضل كثير حدود $f(x)$” لا تكون معاملاته كبيرة جدا وتظهر فيه الأعداد الأولية بسهولة في الخطوات اللاحقة. يستغرق هذا البحث أشهرا.

4. المرحلة 2: غربلة الشبكة الخاصة (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،
 // وتشغيل غربال يحقق أقصى كفاءة لذاكرة التخزين المؤقت.
 // ...
 }
};

بعد إعداد العالمين، تتمثل الخطوة التالية في البحث عن “أعداد ملساء (أعداد تتكون فقط من عوامل أولية صغيرة)” في كلا العالمين. يتم توليد أزواج لا حصر لها من الأعداد الصحيحة $(a, b)$، ويتم حساب القيمتين التاليتين:

القيمة الجانبية النسبية : $a - bm$
المعيار الجانبي الجبري : $b^d f(a/b)$

يهدف GNFS إلى جمع عشرات إلى مئات الملايين من ** “الأزواج (العلاقات) التي يمكن تحليل قيمها الجانبية النسبية والجبرية بالكامل باستخدام عوامل أولية صغيرة فقط” **.

في السابق، تم استخدام “غربال الخط (Line Sieve)"، حيث يتم ترتيب أزواج $(a, b)$ على مستوى $xy$ وقسمتها على الأعداد الأولية. ومع ذلك، كان هذا بطيئا جدا لأنه يسبب فشلا كبيرا في ذاكرة التخزين المؤقت بسبب الوصول العشوائي للذاكرة.

لذلك، تستخدم الأكواد الحديثة طريقة تسمى ** “Special-q Lattice Sieve” **. يتم تثبيت عدد أولي كبير بما فيه الكفاية $q$، وتُحسب فقط أزواج $(a, b)$ حيث “القيمة الجبرية يجب أن تقبل القسمة على $q$”. تشكل الأزواج $(a, b)$ التي تلبي هذا الشرط “شبكة (Lattice)"، مما يجعل قفزة العنوان المحسوبة ثابتة وتتناسب تماما مع ذاكرة التخزين المؤقت L1/L2 لوحدة المعالجة المركزية. أدى هذا التحسين إلى زيادة سرعة حسابات GNFS بشكل هائل.

5. المرحلة 3: التصفية (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. إزالة الفردية (إزالة العلاقات التي تحتوي على أعداد أولية تظهر مرة واحدة فقط)
 // 2. دمج الزمرة (دمج العلاقات لجعل المصفوفة المتفرقة كثيفة)
 }
};

مئات الملايين من العلاقات التي جمعتها أجهزة الكمبيوتر حول العالم على مدار عدة أشهر في المرحلة الثانية. ومع ذلك، إذا قمنا بإدخالها مباشرة إلى “خطوة حل نظام المعادلات (حساب المصفوفة)” التالية، فإن ذاكرة الحاسوب العملاق ستمتلئ.

لذلك، يتم إجراء عملية ضغط قصوى للمصفوفة تسمى ** التصفية (Filtering) **.

إزالة الفردية (Singleton removal) لنفترض أن عددا أوليا ضخما $p$ ظهر “مرة واحدة فقط” من بين مئات الملايين من العلاقات. هدفنا هو “جعل جميع أسس الأعداد الأولية زوجية (مضاعفات 2)"، لذلك فإن العدد الأولي الذي يظهر مرة واحدة لا يمكن أبدا أن يصبح زوجيا. وبالتالي، يتم حذف العلاقة التي تحتوي على هذا العدد الأولي على الفور كـ “قمامة غير مجدية”. وبسبب سلسلة الأحداث هذه، يتم تقليص مئات الملايين من صفوف البيانات.
دمج الزمرة (Clique merging) بعد ذلك، من خلال ضرب (جمع) العلاقات التي تشترك في أعداد أولية معينة، يتم ضغط (تكثيف) المصفوفة المتفرقة وتقليل عدد الصفوف (باستخدام تقنية مشابهة للبحث عن الزمرة في نظرية المخططات).

من خلال هذا التحسين، يتم ضغط المصفوفة المتفرقة الضخمة بشكل كبير إلى حجم يمكن حسابه.

6. المرحلة 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) {
 // حسابات ضرب المصفوفة المتفرقة في المتجه،
 // وإيجاد متجهات حلول بحيث M * x = 0 mod 2.
 }
};

الآن نصل إلى جوهر اللغز. نقوم بضرب العلاقات المجمعة للعثور على ** “التركيبة التي تصبح فيها كل قوى العوامل الأولية زوجية” **.

من الناحية الرياضية، باستخدام مصفوفة ضخمة $M$ تمثل عناصرها “الزوجي والفردي (أي 0 أو 1)” لقوى كل عدد أولي، والمتجه $x$ الذي يمثل العلاقة المستخدمة، فإننا نحل (البحث في الفضاء الفارغ): $M \cdot x \equiv 0 \pmod 2$

علينا حل نظام معادلات مصفوفة بملايين الصفوف وملايين الأعمدة. في الحذف الغاوسي العادي، سيكون التعقيد $O(N^3)$، مما يعني أن الحساب لن يكتمل حتى نهاية الكون.

لذلك، تعتمد التطبيقات الحديثة ** “طريقة Block Wiedemann” **. هذه طريقة فضاء جزئي لـ Krylov تعثر على الحل عبر تكرار عمليات ضرب المصفوفات والمتجهات، مستغلة حقيقة أن المصفوفة $M$ “متفرقة جدا (معظمها 0)”. على عكس طريقة Block Lanczos القديمة، تقوم Block Wiedemann بتقسيم عملية الحساب تماما على مجموعات منفصلة، وتظهر قوة هائلة في الحوسبة السحابية الموزعة الحديثة والحواسيب العملاقة.

7. المرحلة 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)
 }
};

من خلال حسابات المصفوفة في المرحلة 4، حصلنا على مجموعة من العلاقات $S$ والتي “إذا تم ضربها معا، ستصبح كل أسس العوامل الأولية زوجية”. يتيح لنا ذلك بناء “مربعات” في كل من العوالم النسبية والجبرية.

نظرا لأن الجانب النسبي هو مجرد ضرب لأعداد صحيحة، فمن السهل حساب الجذر التربيعي $V$.

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

لكن الجحيم الحقيقي يكمن في “الجانب الجبري”. في عالم الحقل الجبري $\mathbb{Z}[\alpha]$، لا يتم الحفاظ على تفرد التحليل إلى العوامل الأولية، لذلك أجرينا الحسابات باستخدام المثاليات. تضمن حسابات المصفوفة فقط أن النتيجة ** “مربع مثالي”، لكنها لا “تضمن أنها مربع لعنصر ($\gamma^2$)” **.

هنا يظهر عائق هائل في نظرية الأعداد الجبرية، والذي يسمى “عائق مجموعة أصناف المثاليات” و “عائق مجموعة الوحدات”. يخترق GNFS هذا الجدار باستخدام سحر يسمى ** “الرموز التربيعية (Quadratic Characters)” **. في مصفوفة المرحلة 4، تتم إضافة عدد قليل من أعمدة البقايا التربيعية (رمز Legendre) سراً لمثاليات أولية خاصة. بفضل ذلك، تتجاوز المجموعة المكتشفة $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 ليست مجرد تقنية برمجة. إنها تحفة من ذكاء البشرية تغلبت على “أعماق الرياضيات البحتة” مثل الجبر المجرد، ونظرية الحلقات، ومجموعة أصناف المثاليات، وذلك باستخدام “هندسة متطرفة” مثل البنية الموزعة للحواسيب العملاقة وتحسين ذاكرة التخزين المؤقت.

يتم حماية معلومات الدردشات والبطاقات الائتمانية التي نرسلها كل يوم بواسطة هذه المعارك الرياضية الهائلة.

نأمل من خلال إطار عمل C++ هذا، أن تتمكن من الشعور بـ “رومانسية الرياضيات والكمبيوتر” الكامنة وراء خوارزميات كسر التشفير المتطورة.

كيفية استدعاء Microsoft.Windows.AI من C++

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

🎯 كيفية استدعاء `Microsoft.Windows.AI` من C++ [مع نموذج كود]

بدءًا من نظام التشغيل Windows 10، يأتي Windows مزودًا بـ وقت تشغيل يمكنه تنفيذ نماذج الذكاء الاصطناعي بتنسيق ONNX بشكل قياسي. هذا هو Windows ML (Windows.AI.MachineLearning).

في هذه المقالة، سنشرح بالتفصيل كيفية استدعاء Microsoft.Windows.AI.MachineLearning من C++ (تطبيق Win32 الأساسي) مع نموذج كود.

✅ التحضير

◾ المتطلبات

Windows 10 (1809+) أو Windows 11
Visual Studio 2019 أو أحدث (إصدار Community مناسب)
دعم C++/WinRT (Microsoft.Windows.CppWinRT)
Windows SDK 10.0.17763.0 أو أحدث

✅ هيكل المشروع

قم بإنشاء مشروع بالهيكل التالي في Visual Studio.

النوع: تطبيق سطح مكتب Windows C++ (مشروع فارغ)
النظام الفرعي: Windows (WinMain)
أضف الحزم التالية عبر NuGet
1

Microsoft.Windows.CppWinRT

✅ نموذج الكود

فيما يلي حد أدنى لنموذج يجمع بين Win32 API و Windows.AI.MachineLearning باستخدام WinMain.

※ نموذج ONNX المستخدم هو model.onnx، يرجى وضعه في نفس المجلد مع الملف القابل للتنفيذ.

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

 // إنشاء جلسة
 LearningModelSession session(model);
 LearningModelBinding binding(session);

 // إدخال/إخراج النموذج (إدخال فارغ مؤقتًا هنا)
 // في الواقع، مطلوب الربط باستخدام TensorFloat وما إلى ذلك.

 // تنفيذ الاستدلال
 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 الإدخال/الإخراج

اعتمادًا على النموذج، قد تحتاج إلى إنشاء وربط Tensor قبل الاستدلال.

مثال:

1
2
3
4
5
6
7
8


// تحويل مصفوفة 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.
يمكن التحقق من مواصفات الإدخال/الإخراج الدقيقة للنموذج باستخدام أدوات مثل Netron.

✅ الخلاصة

العنصر	المحتوى
واجهة برمجة التطبيقات المستخدمة	Windows.AI.MachineLearning (WinRT)
اللغة	C++ (Win32)
الطريقة الموصى بها	عبر ترويسة C++/WinRT
المزايا	يعمل نموذج ONNX بشكل أصلي، ويدعم وحدة معالجة الرسومات أيضًا
تنبيه	انتبه لاسم إدخال النموذج وشكل Tensor

✅ بديل: لأولئك الذين لا يرغبون في استخدام WinRT

باستخدام ONNX Runtime من Microsoft، يمكنك التعامل مع نماذج ONNX من C++ تمامًا بدون WinRT.
يدعم الأنظمة الأساسية المتعددة، مما يسمح برمز مشترك لـ Windows/Linux.

📌 الخاتمة

Windows ML (Microsoft.Windows.AI) هو محرك استدلال ذكاء اصطناعي قوي يمكن استخدامه بشكل جيد حتى من C++. إذا كنت بحاجة إلى الاستدلال الأصلي على Windows، يرجى تجربته.

سيتم شرح أمثلة محددة لإنشاء نماذج ONNX وربط Tensor في مقال تكميلي!

خطوات استدعاء TinyLLaMA من C++ (باستخدام llama.cpp)

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

✅ خطوات إعداد TinyLLaMA × C++ (باستخدام `llama.cpp`)

🔧 الخطوة 1: تجهيز llama.cpp

1-1. البيئة المطلوبة (الحد الأدنى)

نظام التشغيل: 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.

📦 الخطوة 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 هو تكميم 4 بت. سيتم تقليل حجم النموذج إلى حوالي ** 350 ميجابايت ** تقريباً.

🧪 الخطوة 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;
}

🧱 الخطوة 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 # نموذج مكمم (~350 ميجابايت)
├── main.cpp # كود C++ أعلاه
├── llama.cpp/ # نواة llama.cpp
└── build/
 └── libllama.a # المكتبة المترجمة

🧠 ملاحظات للتطبيق على حالات الاستخدام

وجود كود في C++ لـ مطابقة وتحديد قوالب العقدة بناءً على المخرجات
مثال: إذا كان يحتوي على “Excel” ، “تصفية” ، “حفظ” -> إنشاء مجموعة العقدة المقابلة
هذا الجزء مقبول بتكوين بسيط مثل عبارة if + تحميل قالب JSON

📌 الخلاصة

العنصر	المحتوى
النموذج الموصى به	TinyLLaMA-1.1B-Chat v1.0 (GGUF + تكميم)
الحجم	~350-450 ميجابايت (تكميم 4 بت)
تكامل C++	ممكن باستخدام `llama.cpp` ، لا توجد تبعيات خارجية تقريبًا
قوة المعالجة	كافية لفهم النوايا البسيطة وإنشاء النص (نص طبيعي -> تكوين)
قابلية التوسع	يمكن تحويله إلى ذكاء اصطناعي لإنشاء العقدة عن طريق الدمج مع ملء الفتحات واستدعاء القالب

كيفية نشر رسالة على Slack باستخدام Slack App + OAuth2

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

✅ طريقة النشر باستخدام رمز الوصول (Slack Web API)

يعد “OAuth Token (مثل xoxb- وما إلى ذلك)” من Slack هو المفتاح للنشر باستخدام Web API الخاص بـ Slack. في هذه الحالة، وعلى عكس Webhook، ستقوم بإجراء POST إلى نقطة نهاية API في Slack مع رأس Authorization: Bearer.

🔑 المتطلبات الأساسية

يجب عليك تضمين chat:write في نطاق OAuth في تطبيق Slack الخاص بك:

خطوات الإعداد

قم بزيارة https://api.slack.com/apps
قم بإنشاء تطبيق أو حدد تطبيقًا موجودًا
في “OAuth & Permissions” > Scopes ← أضف chat:write
قم بإجراء “Install to Workspace” أو “Reinstall” للحصول على Access Token (مثال: xoxb-xxxxxxxxxx)

💻 كود C++ (النشر في Slack API باستخدام 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);

 // ترويسة التفويض ونوع المحتوى
 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 = "معرف-القناة-أو-#general"; // مثال: "#general" أو "C0123456789"
 std::string message = "محاولة النشر في Slack من C++!";

 if (PostSlackMessage(token, channel, message)) {
 std::cout << "تم النشر بنجاح!\n";
 } else {
 std::cerr << "فشل في النشر.\n";
 }

 return 0;
}

📌 كيفية الحصول على معرف القناة

قد يؤدي استخدام اسم القناة فقط (مثال: #general) أحيانًا إلى حدوث خطأ. الطريقة الأكثر موثوقية هي استخدام المعرف من عنوان URL لصفحة قناة Slack.

1
2


https://app.slack.com/client/Txxxxx/C0123456789
 ↑ هذا الجزء هو معرف القناة

✅ حول أنواع الرموز (إضافي)

تنسيق الرمز	الغرض	مثال
`xoxb-...`	Bot Token (موصى به)	نشر، تعديل، حذف
`xoxp-...`	User Token (غير موصى به)	عمليات غير خاصة بالبوت
Refresh Token	لتحديث الرمز طويل الأمد	لا يُستخدم عادةً

📝 الخلاصة

للنشر في Slack من C++، تعتبر طريقة Slack Web API + Bearer Token هي الأكثر موثوقية
استخدم نقطة النهاية chat.postMessage مع HTTPS POST
يجب إرسال الرمز في ترويسة Bearer
من الأفضل تحديد القناة باستخدام المعرف

كيفية نشر رسائل إلى Slack باستخدام C++ (Win32 API + WinHTTP) [دعم Webhook]

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

كيفية نشر رسائل إلى Slack باستخدام C++ (Win32 API + WinHTTP) [دعم Webhook]

أرغب في نشر رسائل إلى Slack من C++. هذا شائع جدًا في Node.js و Python، لكن هناك حالات قليلة لاستخدام “C++ × Win32 API × WinHTTP”.

في هذا المقال، سأشرح خطوة بخطوة كيفية إرسال رسائل من C++ إلى Slack باستخدام رابط Webhook بطريقة سهلة الفهم.

✅ التدفق العام

للنشر في Slack، اتبع الخطوات التالية:

احصل على رابط Slack Webhook (مفتاح API)
أرسل طلب POST باستخدام WinHTTP
قم بتكوين نص الرسالة بصيغة JSON
تحقق من النتيجة واكتمل!

🔑 الخطوة 1: كيفية الحصول على رابط Slack Webhook

في Slack، يمكنك بسهولة نشر رسائل من خدمات خارجية باستخدام ميزة تسمى Incoming Webhooks.

خطوات الحصول

انتقل إلى https://api.slack.com/apps
انقر على Create New App
اختر From scratch، وحدد اسم التطبيق ومساحة العمل الوجهة
من القائمة اليسرى، حدد “Incoming Webhooks” وقم بتفعيله
انقر على “Add New Webhook to Workspace” وحدد قناة
انسخ الرابط الصادر (مثال: https://hooks.slack.com/services/xxx/yyy/zzz)

يعمل هذا الرابط مثل مفتاح API.

💻 الخطوة 2: إرسال رسالة إلى Slack بكود C++

التقنيات المستخدمة

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 Webhooks، يمكنك تضمين معلمات مثل هذه:

1
2
3
4
5
6


{
 "text": "محتوى الإشعار",
 "username": "اسم البوت",
 "icon_emoji": ":rocket:",
 "channel": "#اسم_قناة_اختياري"
}

📌 ملاحظات إضافية

يجب تحديد Content-Type كـ "application/json"
يتم تمرير رابط Webhook كـ 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، إلخ.

حتى إذا كنت تعتقد أن التكامل مع Slack باستخدام C++ صعب… يمكنك إضافة بوت إشعارات بدءًا من اليوم!

🚀 ما التالي؟

إذا كنت مهتمًا، ففي المرة القادمة:

إرفاق الملفات
واجهة مستخدم بأزرار
عمليات API مرنة عبر Slack App + OAuth2

يمكننا أيضًا تقديم تكامل متقدم مع Slack بخطوة أبعد مثل هذه!

كيفية نشر رسائل إلى Microsoft Teams من C++ (WinHTTP + Graph API)

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

كيفية نشر رسائل إلى Microsoft Teams من C++ (WinHTTP + Graph API)

هل ترغب في النشر التلقائي في دردشة Microsoft Teams؟ يمكنك استخدام ** Microsoft Graph API ** لذلك. في هذه المقالة، سنقدم ** أمثلة كود C++ باستخدام WinHTTP ** و ** خطوات مصادقة API المطلوبة ** خطوة بخطوة.

🔧 التحضيرات المطلوبة (إعدادات مصادقة Microsoft Graph API)

1. تسجيل التطبيق في بوابة Azure

أولاً، لاستخدام Microsoft Graph API، يجب عليك تسجيل تطبيقك في Azure.

انتقل إلى Azure Portal
** “Microsoft Entra ID” ** > ** “＋إضافة” ** > ** “تسجيل التطبيق” ** > ** “تسجيل جديد” **
أدخل اسم التطبيق الذي تريده وانقر على “تسجيل”

2. إضافة أذونات API

انتقل إلى “أذونات API” في القائمة اليسرى
في ** “Microsoft Graph” ** > ** “تحديد الأذونات” **، ابحث عن النطاقات التالية وانقر على ** “تحديث الأذونات” **

Chat.ReadWrite
User.Read

※ إذا كنت ترغب في النشر في قناة، فستحتاج أيضًا إلى ChannelMessage.Send

3. تدوين معرف العميل ومعرف المستأجر

احتفظ بالقيمتين التاليتين المعروضتين في علامة التبويب “نظرة عامة”:

معرف التطبيق (العميل)
معرف الدليل (المستأجر)

4. إنشاء سر العميل

انتقل إلى علامة التبويب “الشهادات والأسرار”
“سر عميل جديد” > قم بتعيين تاريخ انتهاء الصلاحية وانقر على “إضافة”
** تأكد من تدوين القيمة المعروضة (السر) على الفور **

🔐 الحصول على رمز الوصول (OAuth2)

سنستخدم تدفق client_credentials للحصول على الرمز. قم بتشغيل الأمر التالي باستخدام curl للحصول على رمز الوصول.

1
2
3
4
5
6
7


curl -X POST ^
 https://login.microsoftonline.com/{معرف المستأجر}/oauth2/v2.0/token ^
 -H "Content-Type: application/x-www-form-urlencoded" ^
 -d "client_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.

💬 نموذج C++ للنشر في دردشة Teams

فيما يلي مثال بلغة C++ للنشر في دردشة باستخدام 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


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

🔍 كيفية الحصول على معرف الدردشة

يمكنك التحقق من معرف الدردشة باستخدام 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"
 }
 ]
}

📌 ملاحظات

هذا النموذج هو تنفيذ بالحد الأدنى. في بيئة الإنتاج:
- معالجة انتهاء صلاحية الرمز
- التحقق من شهادة HTTPS
- تعزيز معالجة الأخطاء
للنشر في القنوات، استخدم teams/{team-id}/channels/{channel-id}/messages.
لإرسال المرفقات، ستحتاج إلى معالجة متعددة الأجزاء أو Graph Drive API.

📎 الخلاصة

الميزة	الوصف
Graph API	واجهة برمجة التطبيقات الرسمية للتفاعل مع Teams
تسجيل التطبيق	إجراءات المصادقة المطلوبة على Azure
رمز الوصول	تم الحصول عليه عبر OAuth2 واستخدامه في الطلبات
تنفيذ C++	استدعاء Graph API باستخدام WinHTTP

🚀 الخطوات التالية

كأمثلة أكثر تقدمًا، يمكنك أيضًا:

النشر في قنوات الفريق (/teams/{team-id}/channels/...)
النشر مع المرفقات
التبديل بين حسابات الروبوت وحسابات المستخدمين
تنفيذ C++ كامل يشمل الحصول على الرمز

إذا كان لديك أي طلبات، فلا تتردد في ترك تعليق!

مزايا وعيوب إنشاء برامج باستخدام Win32API + C++

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

جاذبية وتحديات التطوير باستخدام Win32API + C++

بالنسبة لأولئك الذين يرغبون في إتقان تطوير تطبيقات Windows، لا يزال Win32API + C++ خيارا قويا. تجمع هذه المجموعة، التي تتيح لك التفاعل مع نظام التشغيل بأقرب مسافة، بين السرعة العالية والمرونة.

من ناحية أخرى، نظرا لأنها تختلف اختلافا كبيرا عن أساليب التطوير الحديثة، فإن إتقانها يتطلب أيضا تصميما.

في هذه الصفحة، سنشرح المزايا والعيوب بطريقة سهلة الفهم من منظور مطور تطبيقات Windows نشط .

المزايا

تنفيذ أصلي فائق السرعة

نظرا لأن C++ و Win32API يعملان في الطبقة الأقرب لنظام التشغيل، فلا يوجد تقريبا أي عبء إضافي. كفاءة استخدام وحدة المعالجة المركزية والذاكرة عالية جدا، وتتميز بـ سرعة تنفيذ ساحقة .

مرونة وحرية عالية

يمكنك التحكم الدقيق بنفسك في كل سلوك للتطبيق، مثل التحكم في النوافذ، والمعالجة غير المتزامنة، وتكامل COM، وإدارة العمليات. من الممكن أيضا بناء أدوات متخصصة لغرض معين، أو إطارات عمل مخصصة خاصة بك.

سهل التوزيع بدون الحاجة إلى وقت تشغيل

نظرا لعدم الحاجة إلى أوقات تشغيل خارجية مثل .NET أو Java، يمكن توزيعه كملف تنفيذي واحد فقط . من الصعب حدوث مشاكل عند إعادة التوزيع، ومن الجذاب أنه من السهل تشغيله حتى بدون مثبت.

يمكن إنشاء تطبيقات خفيفة الوزن

نظرا لأنه يتطلب فقط الحد الأدنى من التكوين، فإن الميزة هي أن بصمة الذاكرة صغيرة جدا . يعمل بشكل مريح حتى على أجهزة الكمبيوتر ذات المواصفات المنخفضة وبيئات الأجهزة الافتراضية.

تحكم متقدم على مستوى نظام التشغيل ممكن

يمكن أيضا تحقيق تحكم يصعب باستخدام اللغات والمكتبات العادية ، مثل الخطافات العالمية للماوس ولوحة المفاتيح، والضبط الدقيق لأنماط النوافذ، وعمليات قائمة النظام.

العيوب

كفاءة تطوير منخفضة

يجب أن يتم بناء واجهة المستخدم الرسومية بالكامل من خلال الكود، و قد يتطلب إنشاء زر واحد عشرات الأسطر من التعليمات البرمجية . تعديل التصميم عند التغيير مرهق أيضا، والإنتاجية منخفضة مقارنة بالتطوير باستخدام أطر عمل واجهة المستخدم.

الصيانة تميل إلى الانخفاض

يحتوي على الكثير من التعليمات البرمجية ذات البنية الخاصة ، مثل حلقات الرسائل وإجراءات النوافذ، مما يجعل من الصعب قراءتها وإعادة استخدامها. هناك أيضا جوانب تجعلها غير مناسبة لتطوير الفريق أو الصيانة طويلة الأجل.

التكيف مع واجهة المستخدم الحديثة مرهق

من الصعب التكيف مع تجربة المستخدم المطلوبة في السنوات الأخيرة ، مثل دعم DPI العالي، وواجهة اللمس، وإمكانية الوصول، والوضع المظلم. يجب معالجة كل منها يدويا، الأمر الذي يتطلب الكثير من الجهد.

غير مدعوم عبر المنصات

نظرا لأنها واجهة برمجة تطبيقات مخصصة بالكامل لـ Windows، لا يمكن نقلها إلى macOS أو Linux . إذا كنت تتوقع النشر عبر منصات متعددة، فستحتاج إلى اختيار تقنية أخرى.

تكلفة تعلم عالية جدا

يجب أن تفهم المفاهيم والآليات التي نادرا ما تستخدم اليوم ، مثل المقابض، و GDI، و COM، و OLE. العديد من المستندات قديمة أيضا، ويتطلب التعلم وقتا وصبرا.

الاستخدامات المناسبة

أدوات خفيفة الوزن مثل مشغلات الملفات ومساعدات مفاتيح الاختصار
أدوات النظام المساعدة مثل معالجة الحافظة والتحكم في IME
تطبيقات نظام التحكم الأصلي مثل الخطافات العالمية والتقاط النوافذ
أدوات مساعدة السائق التي ترتبط ارتباطا وثيقا بالأجهزة

الاستخدامات غير المناسبة

التطبيقات الموجهة للمستهلكين العاديين حيث يتم التركيز على واجهة المستخدم / تجربة المستخدم الحديثة
النماذج الأولية وتطوير MVP حيث يتم تحديد الأولويات للسرعة
مشاريع واسعة النطاق تعتمد على التشغيل طويل الأجل وتطوير الفريق
المنتجات عبر المنصات التي تحتاج إلى دعم أنظمة تشغيل متعددة

ملخص التقييم

الجانب	التقييم
سرعة التنفيذ	◎ سريع جدا
كفاءة الذاكرة	◎ ممتاز
سرعة التطوير	× بطيء
الصيانة	× منخفض
دعم عبر المنصات	× غير مدعوم
دعم واجهة المستخدم الحديثة	× ضعيف
حرية تحكم نظام التشغيل	◎ عالية جدا

الخاتمة

Win32API + C++ أداة مناسبة للمطورين الذين “يريدون التعامل مع كل شيء في نظام التشغيل بأنفسهم”. في حين أن قوتها كبيرة جدا، إلا أن التعلم والتشغيل يتطلبان استعدادا مقابلا.

ما إذا كان الأمر يستحق “الخيار المتعمد” يعتمد على طبيعة التطبيق الذي تهدف إليه.

القفز إلى عالم #include <windows.h> دون الاعتماد على أطر عمل واجهة المستخدم الرسومية أو اللغات الحديثة ―― هذا الاختيار لا يزال مهما كما كان دائما.

【للمبتدئين】خطوات تثبيت libcurl (مع دعم OpenSSL) في Visual Studio باستخدام vcpkg

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

إذا كنت تريد استخدام libcurl (مع دعم OpenSSL) في Visual Studio، فإن استخدام vcpkg سهل وموصى به

غالبًا ما يتم استخدام libcurl عندما تريد التعامل مع اتصالات HTTP في C++. لكن ضبط إعدادات البناء والتبعيات يمكن أن يكون مزعجًا بشكل غير متوقع.

في مثل هذه الأوقات، تكون أداة إدارة مكتبات C++ من Microsoft ** “vcpkg” ** مفيدة. هذه المرة، سأقدم خطوات استخدام vcpkg لتثبيت libcurl (مع دعم OpenSSL) واستخدامه بسلاسة في Visual Studio.

تثبيت vcpkg (فقط لمن لم يقم بتثبيته بعد)

أولاً، دعنا نثبت vcpkg. يرجى تنفيذ الخطوات التالية في PowerShell.

1
2
3


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

※ إذا لم يكن لديك Git مثبتًا بعد، يرجى تثبيته من الموقع الرسمي لـ Git.

تثبيت libcurl (مع دعم OpenSSL)

بعد ذلك، سنستخدم vcpkg لتثبيت libcurl. لتحديد إصدار 64 بت المتوافق مع OpenSSL، قم بتشغيل الأمر التالي.

1

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

عند تشغيل هذا الأمر، سيتم أيضًا إعداد التبعيات الضرورية (مثل OpenSSL) تلقائيًا.

إعداد التكامل مع Visual Studio

لتسهيل استخدام المكتبات المثبتة بواسطة vcpkg من مشاريع Visual Studio الخاصة بك، قم بإعداد التكامل باستخدام الأمر التالي.

1

vcpkg integrate install

بمجرد إعداد ذلك، ستتمكن تلقائيًا من استخدام #include <curl/curl.h> في مشاريع Visual Studio الخاصة بك، ولن تحتاج إلى إعداد مسارات المكتبة أو إعدادات الرابط يدويًا.

خاتمة

الآن أصبحت جاهزًا لاستخدام libcurl (مع دعم OpenSSL) في Visual Studio.

باستخدام vcpkg، يمكنك إدارة التبعيات المزعجة كلها مرة واحدة
تثبيت libcurl بسهولة باستخدام vcpkg install curl[ssl] --triplet x64-windows
تكامل تلقائي مع Visual Studio باستخدام vcpkg integrate install

بعد ذلك، قم بتضمين ملفات الرأس في مشروعك وابدأ التطوير باستخدام واجهة برمجة تطبيقات libcurl. استفد من vcpkg المريح لزيادة كفاءة تطويرك بشكل كبير.

خطوات تشغيل PowerShell من C++ عبر C++/CLI DLL

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

🎯 خطوات تشغيل PowerShell من C++ عبر C++/CLI DLL (Visual Studio 2022 / C++)

✅ الهيكل العام

🔹 ① غلاف CLI DLL (C++/CLI)

يوفر وظيفة لتشغيل نصوص PowerShell.

🔹 ② الجانب المتصل بـ Native C++

يستدعي CLI DLL لتشغيل نصوص PowerShell.

🔧 الخطوة 1: إنشاء مشروع غلاف CLI DLL

1. إنشاء المشروع

[إنشاء جديد] → [C++] → CLR Class Library (.NET Framework)
الاسم: PowerShellWrapper

💡 إذا لم يظهر هذا القالب، قم بتثبيت بيئة عمل “.NET desktop development”.

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: الاستدعاء من جانب Native 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)

نظراً لأن هذا التكوين يشير مباشرة إلى .NET DLL بدلاً من COM، فإنه لا حاجة إلى IDL أو TLB أو تسجيل COM .

✅ التكوين النهائي

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → استدعاء DLL

خطوات تشغيل PowerShell من C++ عبر C++/CLI DLL

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

🎯 خطوات تشغيل PowerShell من C++ عبر C++/CLI DLL (Visual Studio 2022 / C++)

✅ الهيكل العام

🔹 ① غلاف CLI DLL (C++/CLI)

يوفر وظيفة لتشغيل نصوص PowerShell.

🔹 ② الجانب المتصل بـ Native C++

يستدعي CLI DLL لتشغيل نصوص PowerShell.

🔧 الخطوة 1: إنشاء مشروع غلاف CLI DLL

1. إنشاء المشروع

[إنشاء جديد] → [C++] → CLR Class Library (.NET Framework)
الاسم: PowerShellWrapper

💡 إذا لم يظهر هذا القالب، قم بتثبيت بيئة عمل “.NET desktop development”.

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: الاستدعاء من جانب Native 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)

نظراً لأن هذا التكوين يشير مباشرة إلى .NET DLL بدلاً من COM، فإنه لا حاجة إلى IDL أو TLB أو تسجيل COM .

✅ التكوين النهائي

1
2
3
4
5


Solution
├── PowerShellWrapper (C++/CLI DLL)
│ └── PowerShellExecutor
├── NativeApp (C++ EXE)
 └── main.cpp → استدعاء DLL

كيفية إخراج الوقت الحالي بتنسيق ISO8601 في C++

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

هذه كانت طريقة إخراج الوقت الحالي بتنسيق ISO8601 في C++.

مراجع

std::format

كيفية بناء OpenSSL على Windows

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

ما هو OpenSSL

إنه مكتبة مفتوحة المصدر توفر المعالجة اللازمة لإجراء اتصالات مشفرة.

لاستخدامه من برنامج، يتم نشر كود مصدر لغة C، لذلك تحتاج إلى بناء وإنشاء مكتبة.

أدناه، سوف نقدم إجراء البناء.

إعداد بيئة البناء

Perl

قم بتنزيل strawberry-perl-5.32.1.1-64bit.msi من https://strawberryperl.com/. أعتقد أن أحدث إصدار جيد.
NASM

قم بتنزيل 2.16.01/nasm-2.16.01-win64.zip من Download في https://www.nasm.us/. أعتقد أن أحدث إصدار بخلاف rc جيد. بعد التثبيت، يجب عليك تسجيل المجلد الذي تم تثبيت NASM فيه في متغير البيئة PATH.
Visual Studio 2022 أو Build Tools for Visual Studio 2022

قم بتثبيت Visual Studio 2022 Community أو Build Tools for Visual Studio 2022 من https://visualstudio.microsoft.com/ja/downloads/.

إجراء بناء OpenSSL على Windows

قم بتنزيل وفك ضغط openssl-3.1.0.tar.gz من https://www.openssl.org/source/. إذا لم تتمكن من فك ضغطه، فقم بتشغيل tar -xzf openssl-3.1.0.tar.gz في موجه الأوامر.
ابدأ موجه الأوامر بصلاحيات المسؤول
افتح المجلد الذي تم فك ضغطه
قم بتشغيل الأمر التالي ※قم بتغيير جزء Community وفقًا لإصدار Visual Studio الذي قمت بتثبيته

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

"تشريح كامل" فهم أقوى خوارزمية لتحليل التشفير "GNFS" عن طريق تنفيذها بلغة C++

“تشريح كامل” فهم أقوى خوارزمية لتحليل التشفير “GNFS” عن طريق تنفيذها بلغة C++

1. إطار عمل GNFS المتقدم (الكود المصدري الكامل)

2. الهدف النهائي لـ GNFS: $X^2 \equiv Y^2 \pmod N$

3. المرحلة 1: اختيار كثير الحدود (Polynomial Selection)

4. المرحلة 2: غربلة الشبكة الخاصة (Special-q Lattice Sieving)

5. المرحلة 3: التصفية (Filtering)

6. المرحلة 4: الجبر الخطي فوق GF(2) (طريقة Block Wiedemann)

7. المرحلة 5: الجذر التربيعي الجبري (Algebraic Square Root) وانهيار التشفير

خاتمة

كيفية استدعاء Microsoft.Windows.AI من C++

🎯 كيفية استدعاء Microsoft.Windows.AI من C++ [مع نموذج كود]

✅ التحضير

◾ المتطلبات

✅ هيكل المشروع

✅ نموذج الكود

main.cpp

✅ ملحق: كيفية تحديد Tensor الإدخال/الإخراج

✅ ملاحظات التصحيح

✅ الخلاصة

✅ بديل: لأولئك الذين لا يرغبون في استخدام WinRT

📌 الخاتمة

خطوات استدعاء TinyLLaMA من C++ (باستخدام llama.cpp)

✅ خطوات إعداد TinyLLaMA × C++ (باستخدام llama.cpp)

🔧 الخطوة 1: تجهيز llama.cpp

1-1. البيئة المطلوبة (الحد الأدنى)

1-2. الحصول على llama.cpp وبناؤه

📦 الخطوة 2: تنزيل نموذج TinyLLaMA وتحويله

2-1. الحصول على النموذج الأصلي من HuggingFace

2-2. التحويل إلى تنسيق GGUF (من أجل llama.cpp)

2-3. تكميم النموذج (تقليل الحجم)

🧪 الخطوة 3: استدعاء النموذج من C++ (مثال على الكود)

3-1. كود C++ بسيط (استدلال)

🧱 الخطوة 4: طريقة الترجمة (مثال)

✅ مثال على بنية المخرجات (منظمة)

🧠 ملاحظات للتطبيق على حالات الاستخدام

📌 الخلاصة

كيفية نشر رسالة على Slack باستخدام Slack App + OAuth2

✅ طريقة النشر باستخدام رمز الوصول (Slack Web API)

🔑 المتطلبات الأساسية

خطوات الإعداد

💻 كود C++ (النشر في Slack API باستخدام WinHTTP)

📌 كيفية الحصول على معرف القناة

✅ حول أنواع الرموز (إضافي)

📝 الخلاصة

كيفية نشر رسائل إلى Slack باستخدام C++ (Win32 API + WinHTTP) [دعم Webhook]

كيفية نشر رسائل إلى Slack باستخدام C++ (Win32 API + WinHTTP) [دعم Webhook]

✅ التدفق العام

🔑 الخطوة 1: كيفية الحصول على رابط Slack Webhook

خطوات الحصول

💻 الخطوة 2: إرسال رسالة إلى Slack بكود C++

التقنيات المستخدمة

كود عينة (نشر في Slack)

🧪 تخصيص رسائل JSON

📌 ملاحظات إضافية

🎉 إضافة: مثال على التحقق من النشر في Slack

✍️ الملخص

🚀 ما التالي؟

كيفية نشر رسائل إلى Microsoft Teams من C++ (WinHTTP + Graph API)

كيفية نشر رسائل إلى Microsoft Teams من C++ (WinHTTP + Graph API)

🔧 التحضيرات المطلوبة (إعدادات مصادقة Microsoft Graph API)

1. تسجيل التطبيق في بوابة Azure

2. إضافة أذونات API

3. تدوين معرف العميل ومعرف المستأجر

4. إنشاء سر العميل

🔐 الحصول على رمز الوصول (OAuth2)

مثال على الاستجابة

💬 نموذج C++ للنشر في دردشة Teams

🔍 كيفية الحصول على معرف الدردشة

مثال على الاستجابة

📌 ملاحظات

📎 الخلاصة

🚀 الخطوات التالية

مزايا وعيوب إنشاء برامج باستخدام Win32API + C++

جاذبية وتحديات التطوير باستخدام Win32API + C++

المزايا

تنفيذ أصلي فائق السرعة

مرونة وحرية عالية

سهل التوزيع بدون الحاجة إلى وقت تشغيل

🎯 كيفية استدعاء `Microsoft.Windows.AI` من C++ [مع نموذج كود]

`main.cpp`

✅ خطوات إعداد TinyLLaMA × C++ (باستخدام `llama.cpp`)

2-2. التحويل إلى تنسيق GGUF (من أجل `llama.cpp`)