<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>C-P01NTs on P01NT</title><link>https://outofsrvc.github.io/ar/cworkshop/</link><description>Recent content in C-P01NTs on P01NT</description><generator>Hugo</generator><language>ar</language><lastBuildDate>Thu, 13 Aug 2026 10:00:00 +0300</lastBuildDate><atom:link href="https://outofsrvc.github.io/ar/cworkshop/index.xml" rel="self" type="application/rss+xml"/><item><title>المراحل التي يمر بها الكود</title><link>https://outofsrvc.github.io/ar/cworkshop/compilation-stages/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/compilation-stages/</guid><description>&lt;p>السلام عليكم ورحمة الله وبركاته.&lt;/p>
&lt;p>هذه السلسلة ستغطي أساسيات لغة C المهمة لمجال &lt;strong>الهندسة العكسية (Reverse Engineering)&lt;/strong>. لن نتوسع في كل تفاصيل اللغة، بل في ما يهم من قراءة الـ disassembly وتحليل الـ binaries.&lt;/p>
&lt;h2 id="المراحل-التي-يمر-بها-كود-لغة-c">المراحل التي يمر بها كود لغة C&lt;/h2>
&lt;p>أولاً يكون لدينا الكود المصدر (&lt;strong>Source Code&lt;/strong>) وهو الملف بامتداد &lt;code>.c&lt;/code> وفيه الكود الذي كتبناه. هذا الكود يمر بأربع مراحل قبل أن ينفذ، ومن المهم جداً فهمها:&lt;/p>
&lt;h3 id="1-المعالجة-المسبقة-preprocessor">1. المعالجة المسبقة (Preprocessor)&lt;/h3>
&lt;p>في هذه المرحلة تتم عدة خطوات من أهمها:&lt;/p></description></item><item><title>هيكلية البرنامج</title><link>https://outofsrvc.github.io/ar/cworkshop/program-structure/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/program-structure/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على هيكلية تركيب البرنامج الأساسي في لغة C. تتكون الهيكلية من أجزاء أساسية يلتزم بها كل برنامج C:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-c" data-lang="c">&lt;span class="line">&lt;span class="cl">&lt;span class="cp">#include&lt;/span> &lt;span class="cpf">&amp;lt;stdio.h&amp;gt; // تضمين مكتبات النظام&lt;/span>&lt;span class="cp">
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="cp">&lt;/span>&lt;span class="c1">// تعريف الثوابت (Constants) أو المتغيرات العامة (Global Variables)
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">// دوال أخرى
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="kt">int&lt;/span> &lt;span class="nf">main&lt;/span>&lt;span class="p">(){&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl"> &lt;span class="c1">// الكود الأساسي هنا
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span> &lt;span class="c1">// المتغيرات، الدوال، الحلقات، الشروط
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span> &lt;span class="k">return&lt;/span> &lt;span class="mi">0&lt;/span>&lt;span class="p">;&lt;/span> &lt;span class="c1">// إرجاع القيمة للمشغل
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span>&lt;span class="p">}&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">// دوال أخرى
&lt;/span>&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;h2 id="1-التضمين-include">1. التضمين (include)&lt;/h2>
&lt;p>مثال: &lt;code>#include &amp;lt;stdio.h&amp;gt;&lt;/code> — حيث يستخدم لاستيراد المكتبات المدمجة. هذه المكتبة تحديداً مسؤولة عن الإدخال والإخراج، واختصارها &lt;code>stdio&lt;/code> يعني:&lt;/p></description></item><item><title>المتغيرات والثوابت</title><link>https://outofsrvc.github.io/ar/cworkshop/variables-and-constants/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/variables-and-constants/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على تعريف المتغيرات وخطوات تعريفها وقواعد تسميتها، بالإضافة إلى تعريف الثوابت وأنواعها وطرق تعريفها، وفي النهاية سنوضح الفرق بين المتغيرات والثوابت.&lt;/p>
&lt;h2 id="أولا-المتغيرات-variables">أولاً: المتغيرات (Variables)&lt;/h2>
&lt;p>&lt;strong>تعريفها&lt;/strong>: هي مكان يُحجز في الذاكرة (RAM) لتخزين قيمة معينة أثناء تشغيل البرنامج.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>ملاحظة دقيقة&lt;/strong>: قيمة المتغير المحلي تُحرَّر مساحتها من الـ stack عند انتهاء الدالة، لكن القيمة نفسها قد &lt;strong>تبقى في الذاكرة الفعلية&lt;/strong> حتى تُستبدل بقيم أخرى. وهذا المفهوم مهم جداً في الهندسة العكسية — فالمحلل يبحث أحياناً عن قيم قديمة لم تُمسح عمداً.&lt;/p></description></item><item><title>أنواع البيانات ومحددات التنسيق</title><link>https://outofsrvc.github.io/ar/cworkshop/data-types-and-format-specifiers/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/data-types-and-format-specifiers/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على أنواع البيانات (Data Types) ومحددات التنسيق (Format Specifiers) الخاصة بها.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>ملاحظة&lt;/strong>: أحياناً يجب حفظ المصطلحات الإنجليزية، لأن أغلب تعاملك مع لغات البرمجة سيكون باللغة الإنجليزية، والترجمة العربية تختلف من شخص لآخر.&lt;/p>&lt;/blockquote>
&lt;h2 id="ما-هي-أنواع-البيانات">ما هي أنواع البيانات؟&lt;/h2>
&lt;p>هي الشكل الذي تُحفظ به البيانات (كالمتغيرات) التي يمكن تخزينها ومعالجتها. أهم أنواعها:&lt;/p>
&lt;h3 id="1-الأعداد-الصحيحة-integers">1. الأعداد الصحيحة (Integers)&lt;/h3>
&lt;ul>
&lt;li>تستخدم لتخزين الأعداد الصحيحة (1، 55، -72 — أي بدون فواصل عشرية).&lt;/li>
&lt;li>الكلمة المفتاحية: &lt;code>int&lt;/code>.&lt;/li>
&lt;li>الحجم: &lt;strong>4 بايت في كل من x86 و x64&lt;/strong> (انظر ملاحظة الأخطاء الشائعة أدناه).&lt;/li>
&lt;li>يمكن جعل الأعداد موجبة فقط باستخدام &lt;code>unsigned&lt;/code>.&lt;/li>
&lt;/ul>
&lt;h3 id="2-الأعداد-العشرية-floating-point">2. الأعداد العشرية (Floating-point)&lt;/h3>
&lt;ul>
&lt;li>تستخدم لتخزين الأعداد ذات الفواصل العشرية (1.2، 3.7).&lt;/li>
&lt;li>&lt;code>float&lt;/code>: 4 بايت.&lt;/li>
&lt;li>&lt;code>double&lt;/code>: 8 بايت.&lt;/li>
&lt;/ul>
&lt;h3 id="3-الحروف-characters">3. الحروف (Characters)&lt;/h3>
&lt;ul>
&lt;li>تخزن محرفاً واحداً (حرف، رقم، أو أي رمز).&lt;/li>
&lt;li>الكلمة المفتاحية: &lt;code>char&lt;/code>.&lt;/li>
&lt;li>الحجم: 1 بايت.&lt;/li>
&lt;/ul>
&lt;h3 id="4-void-بدون-قيمة">4. Void (بدون قيمة)&lt;/h3>
&lt;ul>
&lt;li>يستخدم مع الدوال أو المؤشرات التي لا ترجع قيمة.&lt;/li>
&lt;li>الكلمة المفتاحية: &lt;code>void&lt;/code>.&lt;/li>
&lt;li>&lt;strong>مهم لمجال RE&lt;/strong>: &lt;code>void*&lt;/code> هو مؤشر عام (غير محدد النوع) — سنعود إليه في آخر مقالات الأساسيات لأنه من أهم الأمور في الهندسة العكسية.&lt;/li>
&lt;/ul>
&lt;h2 id="جدول-أحجام-البيانات-على-windows-x64">جدول أحجام البيانات (على Windows x64)&lt;/h2>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>النوع&lt;/th>
 &lt;th>الحجم (بايت)&lt;/th>
 &lt;th>المدى التقريبي&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>&lt;code>char&lt;/code>&lt;/td>
 &lt;td>1&lt;/td>
 &lt;td>-128 إلى 127&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>unsigned char&lt;/code>&lt;/td>
 &lt;td>1&lt;/td>
 &lt;td>0 إلى 255&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>short&lt;/code>&lt;/td>
 &lt;td>2&lt;/td>
 &lt;td>-32,768 إلى 32,767&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>int&lt;/code>&lt;/td>
 &lt;td>4&lt;/td>
 &lt;td>-2.1 مليار إلى 2.1 مليار&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>unsigned int&lt;/code>&lt;/td>
 &lt;td>4&lt;/td>
 &lt;td>0 إلى 4.3 مليار&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>long&lt;/code>&lt;/td>
 &lt;td>4 (Windows) / 8 (Linux x64)&lt;/td>
 &lt;td>يعتمد على النظام&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>long long&lt;/code>&lt;/td>
 &lt;td>8&lt;/td>
 &lt;td>أعداد ضخمة&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>float&lt;/code>&lt;/td>
 &lt;td>4&lt;/td>
 &lt;td>فاصلة عشرية&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>double&lt;/code>&lt;/td>
 &lt;td>8&lt;/td>
 &lt;td>فاصلة عشرية بدقة أعلى&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;code>pointer&lt;/code>&lt;/td>
 &lt;td>4 (x86) / 8 (x64)&lt;/td>
 &lt;td>عنوان في الذاكرة&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h3 id="خطأ-شائع-يجب-تجنبه">خطأ شائع يجب تجنبه&lt;/h3>
&lt;blockquote>
&lt;p>&lt;strong>حجم &lt;code>int&lt;/code> لا يعتمد على المعمارية (x86/x64)&lt;/strong> — بل على المترجم/الـ ABI. &lt;code>int&lt;/code> هي 4 بايت في كل من x86 و x64 على ويندوز ولينكس. أما الفارق الحقيقي بين المعماريات فيظهر في حجم المؤشرات (4 بايت في x86، 8 بايت في x64) وفي &lt;code>long&lt;/code> على بعض الأنظمة.&lt;/p></description></item><item><title>سلاسل الهروب</title><link>https://outofsrvc.github.io/ar/cworkshop/escape-sequences/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/escape-sequences/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على سلاسل الهروب (Escape Sequences) وأهميتها واستخداماتها.&lt;/p>
&lt;h2 id="ما-هي-سلاسل-الهروب">ما هي سلاسل الهروب؟&lt;/h2>
&lt;p>تُستخدم داخل النصوص للتعبير عن رموز خاصة أو للتحكم في تنسيق المخرجات. يتم تمثيلها بالشرطة المائلة العكسية (&lt;code>\&lt;/code>) متبوعة بحرف أو أكثر. الغرض منها تسهيل تمثيل المحارف الخاصة التي يصعب كتابتها داخل سلسلة نصية حرفية (String Literal) — كالـ Tab أو السطر الجديد.&lt;/p>
&lt;h2 id="1-التحكم-في-التنسيق-والمخرجات">1. التحكم في التنسيق والمخرجات&lt;/h2>
&lt;h3 id="n--سطر-جديد-newline">&lt;code>\n&lt;/code> — سطر جديد (Newline)&lt;/h3>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-c" data-lang="c">&lt;span class="line">&lt;span class="cl">&lt;span class="nf">printf&lt;/span>&lt;span class="p">(&lt;/span>&lt;span class="s">&amp;#34;Hello&lt;/span>&lt;span class="se">\n&lt;/span>&lt;span class="s">World&amp;#34;&lt;/span>&lt;span class="p">);&lt;/span>
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;p>الناتج:&lt;/p></description></item><item><title>الجمل الشرطية</title><link>https://outofsrvc.github.io/ar/cworkshop/conditionals/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/conditionals/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على if / else-if / else، الجمل المتداخلة (Nested if)، جملة switch، والعامل الثلاثي (Ternary Operator).&lt;/p>
&lt;p>&lt;strong>الجمل الشرطية&lt;/strong>: تُستخدم لاتخاذ القرارات بناءً على شروط معينة — تُنفَّذ تعليمات مختلفة بناءً على نتيجة الشرط (true أو false).&lt;/p>
&lt;h2 id="1-جملة-if">1. جملة if&lt;/h2>
&lt;p>تُستخدم للتحقق من شرط معين وتنفيذ الكود إذا كان الشرط صحيحاً (true). وهي أبسط الجمل.&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-c" data-lang="c">&lt;span class="line">&lt;span class="cl">&lt;span class="k">if&lt;/span> &lt;span class="p">(&lt;/span>&lt;span class="n">condition&lt;/span>&lt;span class="p">)&lt;/span> &lt;span class="p">{&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl"> &lt;span class="c1">// كود يُنفذ إذا كان الشرط صحيحًا
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span>&lt;span class="p">}&lt;/span>
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;h2 id="2-جملة-if-else">2. جملة if-else&lt;/h2>
&lt;p>تُنفذ كوداً معيناً إذا كان الشرط صحيحاً، وكوداً مختلفاً إذا كان خاطئاً.&lt;/p></description></item><item><title>الحلقات التكرارية</title><link>https://outofsrvc.github.io/ar/cworkshop/loops/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/loops/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على الحلقات التكرارية: &lt;code>while loop&lt;/code>, &lt;code>do-while loop&lt;/code>, &lt;code>for loop&lt;/code> والحلقات المتداخلة (Nested Loops)، وسنتعلم كيفية التحكم فيها والفرق بين استخداماتها.&lt;/p>
&lt;p>&lt;strong>الحلقات التكرارية&lt;/strong>: تُستخدم لتنفيذ كتلة من التعليمات بشكل متكرر بناءً على شرط معين. هناك أنواع متعددة، وكل واحد يناسب حالة استخدام مختلفة.&lt;/p>
&lt;h2 id="1-حلقة-while">1. حلقة while&lt;/h2>
&lt;p>تُستخدم عندما يكون التكرار معتمداً على شرط معين — وقد لا تُنفذ الحلقة على الإطلاق إذا لم يتحقق الشرط.&lt;/p></description></item><item><title>المصفوفات والسلاسل النصية</title><link>https://outofsrvc.github.io/ar/cworkshop/arrays-and-strings/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/arrays-and-strings/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على المصفوفات والسلاسل النصية واستخداماتها وأهميتها في الهندسة العكسية.&lt;/p>
&lt;blockquote>
&lt;p>من هذا المقال سنتوسع بالشرح — لأن المقالات المتبقية هي من أهم ما يفيدنا في الهندسة العكسية، ويجب إتقان التعامل معها.&lt;/p>&lt;/blockquote>
&lt;p>المصفوفات والسلاسل النصية من أهم أنواع البيانات المستخدمة لتخزين البيانات ومعالجتها، وهما يختلفان في الاستخدام والهيكلية. &lt;strong>فهم كيفية عملهما في الذاكرة هو أساس تحليل البرامج التنفيذية، خصوصاً فيما يتعلق بالكشف عن الثغرات.&lt;/strong>&lt;/p></description></item><item><title>الدوال</title><link>https://outofsrvc.github.io/ar/cworkshop/functions/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/functions/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على الدوال وأنواعها وأشكالها، وأهم الدوال التي تفيدنا في الهندسة العكسية.&lt;/p>
&lt;p>&lt;strong>الدوال تلعب دوراً محورياً في البرمجة، وخصوصاً في الهندسة العكسية&lt;/strong> — لأنها وحدة التحليل الأساسية: عندما نفتح أي برنامج في IDA أو Ghidra، فإن أول ما نراه هو قائمة الدوال، ومن تحليلها نفهم كيف يعمل البرنامج.&lt;/p>
&lt;h2 id="ما-هي-الدوال">ما هي الدوال؟&lt;/h2>
&lt;p>وحدات أساسية لإعادة استخدام الكود وتنظيمه — &amp;ldquo;كتل&amp;rdquo; من التعليمات مصممة لتنفيذ مهام معينة. كل دالة يمكن أن تقبل معاملات (Arguments) وتُرجع قيمة (Return Value).&lt;/p></description></item><item><title>المؤشرات وإدارة الذاكرة</title><link>https://outofsrvc.github.io/ar/cworkshop/pointers-and-memory/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/pointers-and-memory/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتعرف على المؤشرات (Pointers) وأنواعها، ونأخذ مقدمة عن إدارة وتخصيص الذاكرة (Memory Management and Allocation). وهو &lt;strong>آخر مقال في سلسلة الأساسيات&lt;/strong> إن شاء الله.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>ملاحظة&lt;/strong>: لن نتوسع في memory management بالقدر المطلوب — سنشرح المفاهيم الأساسية التي تساعدنا على فهم المؤشرات، لأن الموضوع يستحق مقالاً خاصاً.&lt;/p>&lt;/blockquote>
&lt;p>المؤشرات أداة قوية تتيح التحكم المباشر في الذاكرة، مما يجعلها ذات أهمية قصوى عند تحليل البرامج وفهم التعليمات الثنائية.&lt;/p></description></item><item><title>العوامل البتية</title><link>https://outofsrvc.github.io/ar/cworkshop/bitwise-operators/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/bitwise-operators/</guid><description>&lt;p>السلام عليكم ورحمة الله وبركاته.&lt;/p>
&lt;p>من هذا المقال سنتعامل مع لغة C بالأمور الـ &lt;strong>low level&lt;/strong>.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>قبل البدء&lt;/strong>: يجب أن تكون على معرفة بأساسيات لغة C — يمكنك مراجعة سلسلة الأساسيات المنشورة سابقاً.&lt;/p>&lt;/blockquote>
&lt;p>في هذا المقال سنشرح العوامل البتية (Bitwise Operators) وعوامل الزيادة والنقصان (Increment/Decrement) والعامل الثلاثي (Ternary Operator). لن نركز على العمليات الحسابية البسيطة (جمع، طرح&amp;hellip;) لأنها بديهية — هذه السلسلة تركز على الأمور الأقوى التي ستخدمنا في الهندسة العكسية.&lt;/p></description></item><item><title>الذاكرة الظاهرية: Stack مقابل Heap</title><link>https://outofsrvc.github.io/ar/cworkshop/virtual-memory-stack-vs-heap/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/virtual-memory-stack-vs-heap/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتحدث عن تصميم الذاكرة الخاص بالـ Stack والـ Heap، ونوضح نقاط الاختلاف بينهما.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>ملاحظة&lt;/strong>: هذا المقال لا يغطي كل شيء حرفياً، لكنه سيوصلنا لفهم كامل عن الأمور التي سنتحدث فيها.&lt;/p>&lt;/blockquote>
&lt;h2 id="تخطيط-الذاكرة-memory-layout">تخطيط الذاكرة (Memory Layout)&lt;/h2>
&lt;p>كما ذكرنا في مقال المؤشرات، ذاكرة البرامج في الأنظمة الحديثة x86/x64 تنقسم إلى 5 أقسام رئيسية (والبعض يقول 4 بدمج Data مع BSS):&lt;/p>
&lt;ol>
&lt;li>&lt;strong>Text Segment&lt;/strong> — التعليمات التنفيذية (للقراءة فقط).&lt;/li>
&lt;li>&lt;strong>Data Segment&lt;/strong> — المتغيرات العامة المهيأة.&lt;/li>
&lt;li>&lt;strong>BSS Segment&lt;/strong> — المتغيرات العامة غير المهيأة.&lt;/li>
&lt;li>&lt;strong>Heap&lt;/strong> — التخصيص الديناميكي.&lt;/li>
&lt;li>&lt;strong>Stack&lt;/strong> — المتغيرات المحلية وإطارات الدوال.&lt;/li>
&lt;/ol>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-text" data-lang="text">&lt;span class="line">&lt;span class="cl">+-----------------+ عناوين عالية
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| Stack | ينمو للأسفل
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| | |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| v |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">+-----------------+
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| (فجوة) |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">+-----------------+
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| ^ |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| | |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| Heap | ينمو للأعلى
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">+-----------------+
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| BSS |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| Data |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| Text |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">+-----------------+ عناوين منخفضة
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;blockquote>
&lt;p>نتعامل هنا مع الـ &lt;strong>User Space&lt;/strong> فقط — الـ Kernel Space موضوع آخر.&lt;/p></description></item><item><title>التخصيص الديناميكي</title><link>https://outofsrvc.github.io/ar/cworkshop/dynamic-allocation/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/dynamic-allocation/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>بعد أن تحدثنا عن الـ Heap والـ Stack وفهمنا البنية الداخلية لكل منهما وآلية عملهما، سنتطرق اليوم لشرح موضوع &lt;strong>تخصيص الذاكرة الديناميكية&lt;/strong> بطريقة موسعة — إدارة الذواكر الحرة وأشهر الثغرات المتكررة في هذا الموضوع.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>Dynamic Memory Allocation&lt;/strong>: فهمه مهم جداً لتحليل البرمجيات واستغلال الثغرات وفهم آلية عمل البرنامج من الداخل.&lt;/p>&lt;/blockquote>
&lt;h2 id="دوال-التخصيص-الأساسية">دوال التخصيص الأساسية&lt;/h2>
&lt;h3 id="1-malloc-و-free">1. malloc() و free()&lt;/h3>
&lt;p>&lt;strong>malloc&lt;/strong> تخصص كتلة ذاكرة في الـ Heap بحجم محدد (بالبايت) &lt;strong>دون تهيئة&lt;/strong> — محتواها قيم عشوائية (garbage):&lt;/p></description></item><item><title>التمرير بالمرجع والقيمة</title><link>https://outofsrvc.github.io/ar/cworkshop/pass-by-value-vs-reference/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/pass-by-value-vs-reference/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>من هذا المقال نبدأ الدخول إلى &lt;strong>Assembly x86-64&lt;/strong> لنكتسب فهماً Low-Level. الشرح سيكون بسيطاً وواضحاً.&lt;/p>
&lt;blockquote>
&lt;p>&lt;strong>بيئة الأمثلة&lt;/strong>: المخرجات هنا من gcc على لينكس (اتفاقية SysV حيث يُمرر المعامل الأول في RDI). على ويندوز x64 تختلف مسجلات المعاملات (RCX/RDX/R8/R9) كما شرحنا في مقال الذاكرة الظاهرية.&lt;/p>&lt;/blockquote>
&lt;blockquote>
&lt;p>&lt;strong>يُنصح&lt;/strong> قبل إكمال هذه السلسلة بدراسة سلسلة الـ Computer Architecture and Organization، ومعرفة أساسية بالـ Memory والـ Registers (شرحناها في مقالي المؤشرات و Stack vs Heap).&lt;/p></description></item><item><title>الدوال — الجزء الثاني</title><link>https://outofsrvc.github.io/ar/cworkshop/functions-part-two/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/functions-part-two/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>بعد أن بنينا حجر الأساس في لغة C وتقسيم الذاكرة والمؤشرات ومقدمة الـ Assembly — نكمل الطريق نحو بنية معرفية كاملة. في هذا المقال نتحدث عن الدوال بطريقة &lt;strong>متقدمة&lt;/strong>، بمرجع أساسي من كتاب K&amp;amp;R، مع تتبع السجلات في الـ Assembly لنرى كيف يمشي الكود في الـ Low-Level.&lt;/p>
&lt;p>&lt;strong>فهرس المقال:&lt;/strong>&lt;/p>
&lt;ul>
&lt;li>1.1 نطاق المتغيرات (Variables Scope)&lt;/li>
&lt;li>1.2 ملفات الرأس (Header Files)&lt;/li>
&lt;li>1.3 المتغيرات والدوال الثابتة (Static)&lt;/li>
&lt;li>1.4 العودية (Recursion)&lt;/li>
&lt;/ul>
&lt;h2 id="المكونات-الأساسية-للدوال">المكونات الأساسية للدوال&lt;/h2>
&lt;table>
 &lt;thead>
 &lt;tr>
 &lt;th>المكوّن&lt;/th>
 &lt;th>الوصف&lt;/th>
 &lt;/tr>
 &lt;/thead>
 &lt;tbody>
 &lt;tr>
 &lt;td>&lt;strong>التوقيع (Signature)&lt;/strong>&lt;/td>
 &lt;td>تعريف الدالة: &lt;code>returnType funcName(Parameters) {}&lt;/code>&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;strong>الجسم (Body)&lt;/strong>&lt;/td>
 &lt;td>الوظيفة التي تقوم بها الدالة&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;strong>الباراميترات&lt;/strong>&lt;/td>
 &lt;td>قيم الإدخال&lt;/td>
 &lt;/tr>
 &lt;tr>
 &lt;td>&lt;strong>قيمة الإرجاع&lt;/strong>&lt;/td>
 &lt;td>الناتج الرئيسي&lt;/td>
 &lt;/tr>
 &lt;/tbody>
&lt;/table>
&lt;h2 id="نموذج-تنفيذ-دالة">نموذج تنفيذ دالة&lt;/h2>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-c" data-lang="c">&lt;span class="line">&lt;span class="cl">&lt;span class="kt">int&lt;/span> &lt;span class="nf">add&lt;/span>&lt;span class="p">(&lt;/span>&lt;span class="kt">int&lt;/span> &lt;span class="n">a&lt;/span>&lt;span class="p">,&lt;/span> &lt;span class="kt">int&lt;/span> &lt;span class="n">b&lt;/span>&lt;span class="p">)&lt;/span> &lt;span class="p">{&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl"> &lt;span class="kt">int&lt;/span> &lt;span class="n">result&lt;/span> &lt;span class="o">=&lt;/span> &lt;span class="n">a&lt;/span> &lt;span class="o">+&lt;/span> &lt;span class="n">b&lt;/span>&lt;span class="p">;&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl"> &lt;span class="k">return&lt;/span> &lt;span class="n">result&lt;/span>&lt;span class="p">;&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="p">}&lt;/span>
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;h3 id="الـ-assembly-32-bit">الـ Assembly (32-bit)&lt;/h3>
&lt;p>نستخدم &lt;code>-m32&lt;/code> لتبسيط الشرح (نمط EBP الكلاسيكي الذي تراه في ملايين البرامج القديمة):&lt;/p></description></item><item><title>المعدلات</title><link>https://outofsrvc.github.io/ar/cworkshop/data-modifiers/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/data-modifiers/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتحدث عن &lt;strong>المعدلات (Data Modifiers)&lt;/strong> — وهي التي تغيّر خصائص وشكل الـ Data Types:&lt;/p>
&lt;ul>
&lt;li>&lt;strong>Sign&lt;/strong>: &lt;code>signed&lt;/code>, &lt;code>unsigned&lt;/code>.&lt;/li>
&lt;li>&lt;strong>Size&lt;/strong>: &lt;code>short&lt;/code>, &lt;code>long&lt;/code>.&lt;/li>
&lt;li>&lt;strong>Storage&lt;/strong>: &lt;code>auto&lt;/code>, &lt;code>register&lt;/code>, &lt;code>extern&lt;/code>, &lt;code>static&lt;/code>.&lt;/li>
&lt;/ul>
&lt;h3 id="ملاحظات-عامة">ملاحظات عامة&lt;/h3>
&lt;ul>
&lt;li>لا يمكن استخدام أكثر من معدّل من نفس النوع معاً (لا يمكن &lt;code>long short&lt;/code> مع بعض).&lt;/li>
&lt;li>بعض المعدلات لا تصح في مواضع معينة — مثل &lt;code>unsigned float&lt;/code>، لأن الـ float &lt;strong>دائماً signed&lt;/strong>.&lt;/li>
&lt;/ul>
&lt;h2 id="1-معدلات-الإشارة-sign-modifiers">1. معدلات الإشارة (Sign Modifiers)&lt;/h2>
&lt;p>كيف نمثل متغير signed داخل الـ Data Type؟ تطورت ثلاث طرق عبر الزمن:&lt;/p></description></item><item><title>الهياكل Struct</title><link>https://outofsrvc.github.io/ar/cworkshop/structures/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/structures/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتحدث عن الـ &lt;strong>Structure&lt;/strong> — أول أنواع البيانات المعرّفة من المستخدم.&lt;/p>
&lt;h2 id="أساسيات-الـ-structure">أساسيات الـ Structure&lt;/h2>
&lt;p>عرفنا أن لغة C فيها أنواع بيانات أساسية (Standard Data Types): &lt;code>int&lt;/code>, &lt;code>char&lt;/code>, &lt;code>float&lt;/code>, &lt;code>double&lt;/code>&amp;hellip;&lt;/p>
&lt;p>ماذا لو أردنا التعبير عن &lt;strong>كائن (Object)&lt;/strong> من الواقع — مثل الإنسان الذي يحمل &lt;strong>اسماً&lt;/strong> و &lt;strong>عمراً&lt;/strong>؟ نحتاج مزج &lt;strong>String&lt;/strong> (مصفوفة أحرف) مع &lt;strong>int&lt;/strong> في كائن واحد.&lt;/p>
&lt;p>هنا يأتي الـ &lt;strong>Structure&lt;/strong>: تشبه المصفوفة، لكنها &lt;strong>تجمع متغيرات من أنماط متعددة&lt;/strong> (بينما المصفوفة من نمط واحد). وبما أن المطور من صنعها، تُصنف ضمن &lt;strong>User Defined Data Types&lt;/strong>.&lt;/p></description></item><item><title>الحقول البتية والاتحادات والتعداد</title><link>https://outofsrvc.github.io/ar/cworkshop/bit-fields-unions-enums/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/bit-fields-unions-enums/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>في هذا المقال سنتحدث عن: &lt;strong>Bit Fields&lt;/strong> (الحقول البتية)، &lt;strong>Unions&lt;/strong> (الاتحادات)، و &lt;strong>Enums&lt;/strong> (التعدادات).&lt;/p>
&lt;h2 id="1-الحقول-البتية-bit-fields">1. الحقول البتية (Bit Fields)&lt;/h2>
&lt;p>تعريفنا في المقال السابق أن الـ struct يوزع &lt;strong>بايتات&lt;/strong> — لكن ماذا لو أردنا تقسيم &lt;strong>بايت واحد إلى بتات&lt;/strong>؟ هنا يأتي الـ Bit Field: نحدد عدد البتات لكل عضو.&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-c" data-lang="c">&lt;span class="line">&lt;span class="cl">&lt;span class="k">typedef&lt;/span> &lt;span class="k">struct&lt;/span> &lt;span class="p">{&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl"> &lt;span class="n">u8&lt;/span> &lt;span class="nl">a&lt;/span> &lt;span class="p">:&lt;/span> &lt;span class="mi">4&lt;/span>&lt;span class="p">;&lt;/span> &lt;span class="c1">// 4 بتات
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span> &lt;span class="n">u8&lt;/span> &lt;span class="nl">b&lt;/span> &lt;span class="p">:&lt;/span> &lt;span class="mi">2&lt;/span>&lt;span class="p">;&lt;/span> &lt;span class="c1">// 2 بتات
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span> &lt;span class="n">u8&lt;/span> &lt;span class="nl">c&lt;/span> &lt;span class="p">:&lt;/span> &lt;span class="mi">1&lt;/span>&lt;span class="p">;&lt;/span> &lt;span class="c1">// 1 بت
&lt;/span>&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">&lt;span class="c1">&lt;/span>&lt;span class="p">}&lt;/span> &lt;span class="n">student&lt;/span>&lt;span class="p">;&lt;/span> &lt;span class="c1">// المجموع 7 بتات ← داخل بايت واحد
&lt;/span>&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-text" data-lang="text">&lt;span class="line">&lt;span class="cl">+---+---+---+---+---+---+---+---+
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">| a (4 بت) | b (2) | c | (فارغ) |
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">+---+---+---+---+---+---+---+---+
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;blockquote>
&lt;p>&lt;strong>ملاحظة&lt;/strong>: المترجم يحزم الـ bit fields داخل البايت، لكن لا يضمن سلوكاً واحداً عبر جميع المترجمات (implementation-defined). عند التحليل، قراءة الـ bit fields في الـ assembly تتضمن عمليات &lt;code>and&lt;/code>/&lt;code>shift&lt;/code>.&lt;/p></description></item><item><title>المعالج المسبق</title><link>https://outofsrvc.github.io/ar/cworkshop/preprocessor/</link><pubDate>Thu, 13 Aug 2026 10:00:00 +0300</pubDate><guid>https://outofsrvc.github.io/ar/cworkshop/preprocessor/</guid><description>&lt;p>بسم الله الرحمن الرحيم.&lt;/p>
&lt;p>بعد سلسلة من المقالات نكون قد انتهينا من أساسيات لغة C — ونتابع بإذن الله بسلسلة الـ Malware Development.&lt;/p>
&lt;p>في هذا المقال سنتعرف على &lt;strong>التوجيهات (Directives) الخاصة بالمعالج المسبق (Preprocessor)&lt;/strong> — وهي الحرف &lt;code>#&lt;/code> المتبوع بكلمات محجوزة يفهمها الـ Preprocessor ويقوم باستبدالها قبل الترجمة.&lt;/p>
&lt;blockquote>
&lt;p>نظرة على مراحل الـ Compilation (التي شرحناها في المقال الأول) — بالشكل المنفصل:&lt;/p>
&lt;div class="highlight">&lt;pre tabindex="0" class="chroma">&lt;code class="language-bash" data-lang="bash">&lt;span class="line">&lt;span class="cl">gcc -E file.c -o file.i &lt;span class="c1"># 1. المعالج المسبق Preprocessor&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">gcc -S file.i -o file.s &lt;span class="c1"># 2. المترجم Compiler&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">gcc -c file.s -o file.o &lt;span class="c1"># 3. المجمع Assembler&lt;/span>
&lt;/span>&lt;/span>&lt;span class="line">&lt;span class="cl">gcc file.o -o file &lt;span class="c1"># 4. الرابط Linker&lt;/span>
&lt;/span>&lt;/span>&lt;/code>&lt;/pre>&lt;/div>&lt;/blockquote>
&lt;h2 id="1-توجيهات-التضمين-inclusion-directives">1. توجيهات التضمين (Inclusion Directives)&lt;/h2>
&lt;h3 id="include">&lt;code>#include&lt;/code>&lt;/h3>
&lt;p>يسمح بإعادة هيكلة البرنامج (Restructuring): تقسيم البرنامج الكبير إلى ملفات متعددة، كل ملف مسؤول عن وظيفة معينة:&lt;/p></description></item></channel></rss>