> ## Content Index
> Fetch the complete content index at: https://informatic-ar.com/llms.txt
> Use this file to discover other available public pages before exploring further.

# الكود الأكثر صعوبه Obfuscated Code
- URL: https://informatic-ar.com/obfuscated_code_cpp/
- Published: 2013-09-29T08:04:24.000Z
- Updated: 2026-10-03T22:32:11.000Z
- Author: وجدي عصام
- Tags: سي/سي++, سي++, obfuscated, code, #wordpress-archive, #Import 2026-10-03 20:48

مقالنا اليوم يتكلم حول طرق سيئه "للغايه" لكتابه الكود بحيث لن يفهم هذا الكود الا القليل ، وهناك بعض الأسباب لعمل مثل هذه البرامج منها مثلا التسليه Fun ، التحدي ، حمايه كود البرنامج ، الفوز بمسابقه ما (هناك مسابقه عالميه تقام كل سنه حول هذا النوع من البرامج International Obfuscated C Code Contest ) .

[![Obfuscated Code](https://informatic-ar.com/wp-content/uploads/2013/09/Obfuscated-Code-279x300.jpg)](https://informatic-ar.com/wp-content/uploads/2013/09/Obfuscated-Code.jpg)

أغلب هذه البرامج تكون مكتوبه بسي ، أو بيرل ، ونادرا ما نجد سي++ ، وذلك لأن سي تحتوي بعضا من الأمور قد تم تلافيها في سي++ ، منها مثلا استدعاء الداله main من داخل البرنامج .

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

ولنأخذ مثال "فاتح للشهيه" قبل أن نبدأ بالطرق ، قم بقرائه المثال ، وفي حال فهمت المثال كاملا وعرفت المخرجات ، فسوف أجزم أنك أحد هؤلاء المجانين .

```c
#include <stdio.h>
main(t, _, a) char *a;
{
    return !0 < t ? t < 3 ? main(-79, -13, a + main(-87, 1 - _, main(-86, 0, a + 1) + a)) : 1,
           t < _ ? main(t + 1, _, a) : 3,
           main(-94, -27 + t, a) && t == 2 ? _ < 13 ? main(2, _ + 1, "%s %d %d\n") : 9 : 16
       : t < 0
           ? t < -72
                 ? main(
                       _, t,
                       "@n'+,#'/*{}w+/w#cdnr/+,{}r/*de}+,/*{*+,/w{%+,/w#q#n+,/#{l,+,/n{n+,/+#n+,/#\
;#q#n+,/+k#;*+,/'r :'d*'3,}{w+K w'K:'+}e#';dq#'l \
q#'+d'K#!/+k#;q#'r}eKK#}w'r}eKK{nl]'/#;#q#n'){)#}w'){){nl]'/+#n';d}rw' i;# \
){nl]!/n{n#'; r{#w'r nc{nl]'/#{l,+'K {rw' iK{;[{nl]'/w#q#n'wk nw' \
iwk{KK{nl]!/w{%'l##w#' i; :{nl]'/*{q#'ld;r'}{nlwb!/*de}'c \
;;{nl'-{}rw]'/+,}##'*}#nc,',#nw]'/+kd'+e}+;#'rdq#w! nr'/ ') }+}{rl#'{n' ')# \
}'+}##(!!/")
             : t < -50 ? _ == *a ? putchar(31 [a]) : main(-65, _, a + 1)
                       : main((*a == '/') + t, _, a + 1)
       : 0 < t ? main(2, 2, "%s")
               : *a == '/' ||
                     main(0,
                          main(-61, *a,
                               "!ek;dc i@bK'(q)-[w]*%n+r3#l,{}:\nuwloca-O;m .vpbks,fxntdCeghiry"),
                          a + 1);
}
```

حاول أن تتخيل ما هي المخرجات قبل أن تقوم بتشغيله ، تخيل فقط !!

**كيف تكتب برنامج مشوش ؟**  
هنا علينا أن نرجع الى بدايه تعلمنا للغه ونتذكر ما هي أصعب الأشياء التي واجهتنا في التعلم ، أذكر أنني جلست كم يوم حتى فهمت ما هو المؤشر Pointer ، مممم أيضا الأستدعاء الذاتي مربك أيضا ، أيضا المصفوفات وخاصه عندما نستخدم Pointer Arithmetic ، معامل الفاصله Comma مربك ايضا لان تنفيذه غريب بعض الشيء ، جميع المواضيع السابقه التي كنت تعتبرها صعبه ، هنا ستكون هي سلاحك الأول

أيضا المتغيرات ذات الشكل المتشابه مثلا الحرف O و الحرف o ( الأول كبير والثاني صغير ) و الرقم 0 ، أيضا الحرف i والحرف l والحرف L الرقم 1 ، هذه المتغيرات تسبب لي التشاؤم من البرنامج ، خاصه عندما كنت أقرأ برنامج أحد الطلاب ، وهذه أحد سطور أحد الطلاب :

```c
char clear, ch, c, bag[100], bag1[10][10], bag2[100];
int n = 0, m, x, w = 0, aa = 0, z, l = 0, nn[50], mm[50], qw, az, i, j;

// other code

for (int fg = 1; fg <= az; fg += 2)
{
    if (nn[fg - 1] == nn[fg])
    {
        bag2[fg - 1] = bag1[nn[fg - 1]][(mm[fg - 1] + 1) % 5];
        bag2[fg] = bag1[nn[fg - 1]][(mm[fg] + 1) % 5];
    }
    else if (mm[fg - 1] == mm[fg])
    {
        bag2[fg - 1] = bag1[(nn[fg - 1] + 1) % 5][mm[fg - 1]];
        bag2[fg] = bag1[(nn[fg] + 1) % 5][mm[fg]];
    }
    else
    {
        bag2[fg - 1] = bag1[nn[fg - 1]][mm[fg]];
        bag2[fg] = bag1[nn[fg]][mm[fg - 1]];
    }
}
```

يبدوا لي أن هذا الطالب يكتب برنامج Obfuscated بالفطره ، وأعتقد أنه سيفوز بمثل هذه المسابقات بكل سهوله :) .

نبدأ الأن بقطع من الكود ، ونحاول أن نغيرها من كود عادي الى مشوش ، وبعدها نأخذ مثال Hello World ومن ثم نحوله الى Hello Devil .

**التلاعب بأسماء المتغيرات :**

نأخذ مثال لبرنامج يطبع الحروف من A الى Z ، ونقوم ببعض التغيرات عليه في اسامي المتغيرات :

```cpp
#include <stdio.h>

int main()
{
    for (int i = 'A'; i <= 'Z'; i++)
        printf("%c", i);

    return 0;
}
```

الان قمنا بوضع جمله الطباعه في داله ، ومررنا لها الحرف الأول والأخير ، ومن ثم طبعنا الحروف :

```c
#include <stdio.h>

void _(int O, int _O)
{
    for (; O <= _O; O++)
        printf("%c", O);
}

int main()
{
    // you can change A with 65  in decimal  OR with 0x41 in hex
    // olse you can change Z to 90 in decimal or 0x5A in hex
    _(0x41, 90);

    return 0;
}
```

لاحظ استخدام الحروف المشابه O و \_O ، أيضا ارسال الحرف A بقيمته في النظام Hex ، ويمكن أستخدام أي نظام أخر .  
(طبعا عليك بازاله التعليق من البرنامج ، وهو أصلا موضوع لك أنت ، حيث البرنامج المفترض يشوش القارئ وليس يشرح للقارئ).

**التلاعب بالمؤشرات والمصفوفات :**

مراجعه سريعه للأمر ، تجدها في هذه السطور :

```c
printf("\n\n%d\n", arr[1]); // print 20
printf("%d\n", *(arr + 1)); // print 20
printf("%d\n", *(1 + arr)); // print 20

printf("Address = %x\n", &arr[1]); // print Address for element 1
printf("Address = %x\n", arr + 1); // print Address for element 1
```

الأن كيف يمكن أن نتلاعب هنا ، كلنا نعرف أذا أردنا أن نرسل مصفوفه لداله نقوم بارسال عنوانها ، حسنا ، ممكن أن نضع هذا العنوان في متغير int أولا ، ونقوم بارسال هذا العدد (العنوان) ، الان من داخل المصفوفه نقوم بتحويل هذا العدد int الى مؤشر عن طرق الCast .

أنظر الى المثال القادم ، وهو لطباعه الأعداد من 1 الى 10 ، والذي يليه هو بعد التلاعب فيه قليلا :

```c
#include <stdio.h>

void functionOne(int *array, int size)
{
    for (int i = 0; i < size; i++)
        printf("%d ", array[i]); // or *array++     or   *(array+i)
}

int main()
{
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    functionOne(array, 10);

    return 0;
}
```

الان النسخه المعدله ، ولاحظ أننا في الداله main قمنا بأخذ عنوان المصفوفه ، وارساله الى الداله functionOne ، وهناك قمنا بعمل cast لهذا الرقم وحولناه الى مؤشر ، بعدها باستخدام pointer arithmetic قمنا بالوصول الى عناصر المصفوفه .

```c
#include <stdio.h>

void functionOne(int address, int size)
{
    int i = 0;
    for (; i < size; i++)
        printf("%d ", *((int *)address + i));
}

int main()
{
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    int address = (int)array; //  (int) &array[0]
    functionOne(address, 10);

    return 0;
}
```

**المعامل الشرطي الثلاثي Conditional Operator ومعامل الفاصله Comma Operator :**

معامل الفاصله يعمل من اليسار الى اليمين ، ومن ثم يسند قيمه المتغير الموجود في الجهه اليمني الى المتغير اذا كان هناك. نأخذ مثال :

```c
int a = 0;
int b = 3;
a = (b += 3, b - 1);
```

الان عند تنفيذ السطر الثالث ، نقوم بزياده b بمقدار 3 وتصبح 6 ، بعدها نطرح من b واحد وتصبح 5 ، وأخيرا نسند b الى a (اي تصبح قيمه a هي 5 ).

المعامل الشرطي هو بديل لجمله If :

```c
if (<test_condition>)
{
    <variable_name> = <value_if_true>;
}
else
{
    <variable_name> = <value_if_false>;
}
```

وباستخدام Conditional Operator :

```c
<variable_name> = (<test_condition>) ? (<value_if_true>) : (<value_if_false>);
```

في حال كان test\_condition صحيح سوف ينفذ value\_if\_true والا value\_if\_false .

هذا المعامل له دور كبير جدا في هذه النوعيه من البرامج ، حيث يتم استبدال أي جمله شرطيه بهذا المعامل .

وفي حاله كانت هناك nested if ، يمكن استخدام المعامل الشرطي مع معامل الفاصله لكي يؤدي الغرض :

```c
<variable_name> = (<test_condition>) ? (<expression_a1>, ..., <value_if_true>) : (<expression_b1>, ..., <value_if_false>);
```

مثال :

```c
int a = 1;
int b = 2;
int c = 3;

if (a < 0)
{
    b += 3;
    a = b - 1;
}
else
{
    c += b;
    a = c + 2;
}
```

الان نحوله الى conditional operator و comma operator :

```c
int a = 1;
int b, c;
a = (b = 2, c = 3, a < 0) ? (b += 3, b - 1) : (c += b, c + 2);
```

وهنا أولا سوف يسند 2 الى b ، بعدها 3 الى c ، بعدها يقارن هل a أصغر من 0 ، في حال كان ذلك ، يزيد على b ثلاثه ، ومن ثم يطرح واحد ، ويرجع القيمه ويسندها الى a . اما اذا كان a أكبر من 0 ، سوف يزيد على c مقدار b وهي 2 ، بعدها يزيد على c 2 ويسند الناتج الى a .

**الأستدعاء الذاتي :**

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

نأخذ مثال لطباعه الأعداد من 1 - 10 ، وبعدها نحوله الى النداء الذاتي :

```c
#include "stdio.h"

int main()
{
    int array[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

    int i;
    for (i = 0; i < 10; ++i)
    {
        printf("%d ", array[i]);
    }

    return 0;
}
```

وها هو البرنامج بعد التعديل :

```c
#include "stdio.h"

void recursiveFunction(int array, int i, int stop)
{
    printf("%d ", *((int *)array + i));
    i++;
    if (i < stop)
    {
        recursiveFunction(array, i, stop);
    }
}

int main()
{
    int array[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    recursiveFunction((int)array, 0, 10);
    return 0;
}
```

الأن نأخذ مثال شامل لـ Hello World ، المثال هو :

```c
#include "stdio.h"

int main()
{
    printf("Hello World!");
    return 0;
}
```

وبعدها سندخل هذا المثال غرفه العمليات ، للقيام بعمليه تجميل ، ليخرج بالشكل :

```c
#include "stdio.h"
_(__, _0, O_, ___)
{
    (O_ < _0)              ? printf("%c", (O_ == 2) || (O_ == 3) || (O_ == 9) ? ___++, O_++,
                                    108 : *((int *)__ + O_++ - ___)),
        _(__, _0, O_, ___) : 0;
}
main()
{
    int array[] = {72, 'e', 111, 040, 0127, 0x6F, 'r', 0x64, 041};
    _(array, 12, 0, 0);
}
```

جميل أليس كذلك !

نبدا الأن .

**الخطوه الأولى :**  
نعمل داله للطباعه ، نرسل اليها المصفوفه ، القيم التي في المصفوفه كتبناها بالنظام العشري .

```c
void myFunction(int array[], int arraySize)
{
    int i;
    for (i = 0; i < arraySize; ++i)
    {
        printf("%c", array[i]);
    }
}

int main()
{
    int array[] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33};
    myFunction(array, 12);
    return 0;
}
```

**الخطوه الثانيه :**  
استخدمنا فكره ارسال متغير يحمل العنوان (التي شرحناها في الأعلى) وبعدها نقوم بعمل cast للمتغير ونحوله الى مؤشر :

```c
#include "stdio.h"

void myFunction(int integer, int arraySize)
{
    int i;
    for (i = 0; i < arraySize; ++i)
    {
        printf("%c", *((int *)integer + i));
    }
}

int main()
{

    int array[] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33}, integer = (int)array;
    myFunction(integer, 12);
    return 0;
}
```

**الخطوه الثالثه :**  
غيرنا الداله وقمنا بعمل استدعاء ذاتي ، وغيرنا if الى Conditional Operator :

```c
void myFunction(int integer, int arraySize, int i)
{
    (i < arraySize) ? printf("%c", *((int *)integer + i++)), myFunction(integer, arraySize, i) : 0;
}

int main()
{

    int array[] = {72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33};
    myFunction((int)array, 12, 0);
    return 0;
}
```

**الخطوه الرابعه :**  
نتخلص من بعض الحروف المكرره في المصفوفه (وهو الحرف L) يتكرر ثلاث مرات 108 ، في الموقع 2 و 3 و 9 :

```c
#include "stdio.h"

void myFunction(int integer, int arraySize, int i, int k)
{
    (i < arraySize) ? (i == 2) || (i == 3) || (i == 9) ? k++, i++,
        printf("%c", 108)                              : printf("%c", *((int *)integer + i++ - k)),
        myFunction(integer, arraySize, i, k)           : 0;
}

int main()
{

    int array[] = {72, 101, 111, 32, 87, 111, 114, 100, 33};
    myFunction((int)array, 12, 0, 0);
    return 0;
}
```

**الخطوه الخامسه :**   
نغير من ترتيب معامل الشرط في الداله :

```c
void myFunction(int integer, int arraySize, int i, int k)
{
    (i < arraySize) ? printf("%c", (i == 2) || (i == 3) || (i == 9) ? k++, i++,
                             108 : *((int *)integer + i++ - k)),
        myFunction(integer, arraySize, i, k) : 0;
}

int main()
{

    int array[] = {72, 101, 111, 32, 87, 111, 114, 100, 33};
    myFunction((int)array, 12, 0, 0);
    return 0;
}
```

**الخطوه السادسه :**  
نغير من أسماء المتغيرات في الداله ، ودائما تغير اسماء المتغيرات يأتي في أخر مرحله حتى لا تضيع أنت وتشوش على نفسك اثناء كتابة البرنامج ، أيضا تغيير القيم في المصفوفه وجعلها بعده أنظمه Hex و octal وdecimal :

```c
#include "stdio.h"

void myFunction(int __, int _0, int O_, int ___)
{
    (O_ < _0) ? printf("%c", (O_ == 2) || (O_ == 3) || (O_ == 9) ? ___++, O_++,
                       108 : *((int *)__ + O_++ - ___)),
        myFunction(__, _0, O_, ___) : 0;
}

int main()
{

    int array[] = {72, 'e', 111, 040, 0127, 0x6F, 'r', 0x64, 041};
    myFunction((int)array, 12, 0, 0);
    return 0;
}
```

**الخطوه السابعه :**  
تغير اسم الداله ، حذف القيمه الراجعه ، وسوف يعتبرها المترجم هي int ، أيضا حذف نوع المتغير المرسل في الداله وأيضا سيتعبرها int :

```c
_(__, _0, O_, ___)
{
    (O_ < _0)              ? printf("%c", (O_ == 2) || (O_ == 3) || (O_ == 9) ? ___++, O_++,
                                    108 : *((int *)__ + O_++ - ___)),
        _(__, _0, O_, ___) : 0;
}

main()
{
    int array[] = {72, 'e', 111, 040, 0127, 0x6F, 'r', 0x64, 041};
    _(array, 12, 0, 0);
}
```

**الخطوه الأخير :**  
نقوم بحذف المسافات بين الجمل ، وضغطها :

```c
#include "stdio.h"
_(__, _0, O_, ___)
{
    (O_ < _0)              ? printf("%c", (O_ == 2) || (O_ == 3) || (O_ == 9) ? ___++, O_++,
                                    108 : *((int *)__ + O_++ - ___)),
        _(__, _0, O_, ___) : 0;
}
main()
{
    int array[] = {72, 'e', 111, 040, 0127, 0x6F, 'r', 0x64, 041};
    _(array, 12, 0, 0);
}
```

واوووو ...... من كان يصدق أن هذا البرنامج Hello World !

**نقطه أخيره**  
البرنامج السابق هو أسهل برنامج مشوش ، نعم !! هناك بعض البرامج معقده جدا وخاصه عندما يتم استخدام جمل الهاش # أو Preprocessor Directive

هناك بعض البرامج ، يمكن أن تقوم بكشفها بسرعه مثل :

```c
_(__, ___, ____)
{
    ___ / __ <= 1                         ? _(__, ___ + 1, ____)
    : !(___ % __)                         ? _(__, ___ + 1, 0)
    : ___ % __ == ___ / __ && !____       ? (printf("%d\t", ___ / __), _(__, ___ + 1, 0))
    : ___ % __ > 1 && ___ % __ < ___ / __ ? _(__, 1 + ___, ____ + !(___ / __ % (___ % __)))
    : ___ < __ * __                       ? _(__, ___ + 1, ____)
                                          : 0;
}
main()
{
    _(100, 0, 0);
}
```

وهو يطبع الأعداد الأوليه من 1 الى 100 ، وهنا أولا أستعن بخاصيه Find & Replace الموجوده في الDE أو في أي محرر نصوص ، وغير كل : \_ بمثلا Function ، وبعدها سوف تصبح النتيجه :

```c
Function(__, ___, ____)
{
    ___ / __ <= 1                         ? Function(__, ___ + 1, ____)
    : !(___ % __)                         ? Function(__, ___ + 1, 0)
    : ___ % __ == ___ / __ && !____       ? (printf("%d\t", ___ / __), Function(__, ___ + 1, 0))
    : ___ % __ > 1 && ___ % __ < ___ / __ ? Function(__, 1 + ___, ____ + !(___ / __ % (___ % __)))
    : ___ < __ * __                       ? Function(__, ___ + 1, ____)
                                          : 0;
}
main()
{
    Function(100, 0, 0);
}
```

الان غير كل : \_\_ بمثلا varOne وقم بعمل replace All :

```c
Function(varOne, ___, ____)
{
    ___ / varOne <= 1 ? Function(varOne, ___ + 1, ____)
    : !(___ % varOne) ? Function(varOne, ___ + 1, 0)
    : ___ % varOne == ___ / varOne && !____
        ? (printf("%d\t", ___ / varOne), Function(varOne, ___ + 1, 0))
    : ___ % varOne > 1 && ___ % varOne < ___ / varOne
        ? Function(varOne, 1 + ___, ____ + !(___ / varOne % (___ % varOne)))
    : ___ < varOne * varOne ? Function(varOne, ___ + 1, ____)
                            : 0;
}
main()
{
    Function(100, 0, 0);
}
```

واستمر هكذا الى أن تنتهي من جميع أسماء المتغيرات العجيبه ، وبعدها قم بتنظيم البرنامج ، وهنا ستجد نفسك أمام الكود مباشره !

أخيرا ، لما لا يطرح كل منا كوده الـ Obfuscated ونشاهد من هو صاحب الكود الأكثر تشويشا ؟