مقالنا اليوم يتكلم حول طرق سيئه "للغايه" لكتابه الكود بحيث لن يفهم هذا الكود الا القليل ، وهناك بعض الأسباب لعمل مثل هذه البرامج منها مثلا التسليه Fun ، التحدي ، حمايه كود البرنامج ، الفوز بمسابقه ما (هناك مسابقه عالميه تقام كل سنه حول هذا النوع من البرامج International Obfuscated C Code Contest ) .
أغلب هذه البرامج تكون مكتوبه بسي ، أو بيرل ، ونادرا ما نجد سي++ ، وذلك لأن سي تحتوي بعضا من الأمور قد تم تلافيها في سي++ ، منها مثلا استدعاء الداله main من داخل البرنامج .
أحب أن أذكر أن الطرق الموجوده هنا ، لا ينصح باستخدامها أبدا ، فهي طرق سيئه جدا ، وكما ذكرت فقط الغرض منها هو التشويش ...
ولنأخذ مثال "فاتح للشهيه" قبل أن نبدأ بالطرق ، قم بقرائه المثال ، وفي حال فهمت المثال كاملا وعرفت المخرجات ، فسوف أجزم أنك أحد هؤلاء المجانين .
#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 ، هذه المتغيرات تسبب لي التشاؤم من البرنامج ، خاصه عندما كنت أقرأ برنامج أحد الطلاب ، وهذه أحد سطور أحد الطلاب :
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 ، ونقوم ببعض التغيرات عليه في اسامي المتغيرات :
#include <stdio.h>
int main()
{
for (int i = 'A'; i <= 'Z'; i++)
printf("%c", i);
return 0;
}الان قمنا بوضع جمله الطباعه في داله ، ومررنا لها الحرف الأول والأخير ، ومن ثم طبعنا الحروف :
#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 ، ويمكن أستخدام أي نظام أخر .
(طبعا عليك بازاله التعليق من البرنامج ، وهو أصلا موضوع لك أنت ، حيث البرنامج المفترض يشوش القارئ وليس يشرح للقارئ).
التلاعب بالمؤشرات والمصفوفات :
مراجعه سريعه للأمر ، تجدها في هذه السطور :
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 ، والذي يليه هو بعد التلاعب فيه قليلا :
#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 قمنا بالوصول الى عناصر المصفوفه .
#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 :
معامل الفاصله يعمل من اليسار الى اليمين ، ومن ثم يسند قيمه المتغير الموجود في الجهه اليمني الى المتغير اذا كان هناك. نأخذ مثال :
int a = 0;
int b = 3;
a = (b += 3, b - 1);الان عند تنفيذ السطر الثالث ، نقوم بزياده b بمقدار 3 وتصبح 6 ، بعدها نطرح من b واحد وتصبح 5 ، وأخيرا نسند b الى a (اي تصبح قيمه a هي 5 ).
المعامل الشرطي هو بديل لجمله If :
if (<test_condition>)
{
<variable_name> = <value_if_true>;
}
else
{
<variable_name> = <value_if_false>;
}وباستخدام Conditional Operator :
<variable_name> = (<test_condition>) ? (<value_if_true>) : (<value_if_false>);في حال كان test_condition صحيح سوف ينفذ value_if_true والا value_if_false .
هذا المعامل له دور كبير جدا في هذه النوعيه من البرامج ، حيث يتم استبدال أي جمله شرطيه بهذا المعامل .
وفي حاله كانت هناك nested if ، يمكن استخدام المعامل الشرطي مع معامل الفاصله لكي يؤدي الغرض :
<variable_name> = (<test_condition>) ? (<expression_a1>, ..., <value_if_true>) : (<expression_b1>, ..., <value_if_false>);مثال :
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 :
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 ، وبعدها نحوله الى النداء الذاتي :
#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;
}وها هو البرنامج بعد التعديل :
#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 ، المثال هو :
#include "stdio.h"
int main()
{
printf("Hello World!");
return 0;
}وبعدها سندخل هذا المثال غرفه العمليات ، للقيام بعمليه تجميل ، ليخرج بالشكل :
#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);
}جميل أليس كذلك !
نبدا الأن .
الخطوه الأولى :
نعمل داله للطباعه ، نرسل اليها المصفوفه ، القيم التي في المصفوفه كتبناها بالنظام العشري .
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 للمتغير ونحوله الى مؤشر :
#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 :
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 :
#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;
}الخطوه الخامسه :
نغير من ترتيب معامل الشرط في الداله :
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 :
#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 :
_(__, _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);
}الخطوه الأخير :
نقوم بحذف المسافات بين الجمل ، وضغطها :
#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
هناك بعض البرامج ، يمكن أن تقوم بكشفها بسرعه مثل :
_(__, ___, ____)
{
___ / __ <= 1 ? _(__, ___ + 1, ____)
: !(___ % __) ? _(__, ___ + 1, 0)
: ___ % __ == ___ / __ && !____ ? (printf("%d\t", ___ / __), _(__, ___ + 1, 0))
: ___ % __ > 1 && ___ % __ < ___ / __ ? _(__, 1 + ___, ____ + !(___ / __ % (___ % __)))
: ___ < __ * __ ? _(__, ___ + 1, ____)
: 0;
}
main()
{
_(100, 0, 0);
}وهو يطبع الأعداد الأوليه من 1 الى 100 ، وهنا أولا أستعن بخاصيه Find & Replace الموجوده في الDE أو في أي محرر نصوص ، وغير كل : _ بمثلا Function ، وبعدها سوف تصبح النتيجه :
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 :
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 ونشاهد من هو صاحب الكود الأكثر تشويشا ؟
