مبهم سازی یا پیچیده کردن کُدهای باینری

سلام خدمت دوستان عزیز. میخوام اندک اطلاعاتی که در مورد مبهم سازی یا پیچیده کردن کُدهای دارم رو توی این تاپیک به اشتراک بذارم. امیدوارم مورد استفاده دوستان قرار بگیره.

قبل از شروع مطلب این رو بگم که برنامه های NET. بحثشون جداست و صد البته مبهم سازی براشون اهمیت بیشتری داره ولی من در ادامه فقط درباره مبهم سازی کُدهای باینری صحبت میکنم.

مبهم سازی کُد چیه؟ و فایدش چیه؟

اگه شما برید چند تا از این فیلم های آموزشی کرک رو ببینید متوجه میشد که وقتی یه کرکر میخواد یه برنامه رو کرک کنه اول دنبال جایی میگرده که باید کرک رو از اونجا شروع کنه (منظور این که یه کرکر نمیاد از اولین خط برنامه شروع بکنه و خط به خط بره جلو تا به نقطه کرک کردن برسه). بنابراین یه کرکر سرنخ ها رو مثل یه کارگاه دنبال میکنه تا به نقاط مورد نظر خودش برسه (حالا چقدر کارگاه خوبیه دیگه به تجربه و اطلاعات خودش برمیگرده). خب حالا اگه شما رد پاها رو پاک یا مدارک رو مخدوش کنید شاید بتونید از دستش دربرید!

بذارید به جای حرف زدن یه مقدار کُد بذارم:

فرض کنید شما یه تابع دارید که شماره سریال رو از رجیستری براتون میخونه و اسمش هست ReadSnFromReg که آدرس حقیقی اون توی برنامه های دیباگر میشه 005B15F0.
حالا شما از این تابع سه چهار بار درجاهای مختلف استفاده میکنید که شماره سریال رو باهاش چک بکنید.
کرکر در یکی از توابع چک کردن شما، داستان خوندن و چک کردن شماره سریال رو پیدا و اون رو کرک میکنه.
حالا وقتی برنامه رو امتحان میکنه بطور کامل موفق نمیشه چون دو سه جای دیگه هم وجود داره که باید کرک کنه.
بنابراین میاد تا جاهای دیگه رو پیدا کنه و میره توی برنامه دیباگر روی آدرس حقیقی تابع شما راست کلیک کرده و (برای مثال) گزینه Find Same Addresses رو میزنه و برنامه دیباگر جاهای دیگه ای که تابع ReadSnFromReg استفاده شده رو بهش نشون میده، حالا به راحتی جاهای دیگه رو هم کرک کرده و برنامه رو کامل کرک شده تحویل میده.
خب در اینجا کُدهای یه ترفند ساده رو مینویسم که میتونه از جستجوی یه آدرس (به روش فوق) جلوگیری کنه.
با فرض اینکه کُد اصلی به این صورت باشه:

S := ReadSnFromReg;

کُد اسمبلیش رو از توی محیطی که توش برنامه مینویسن در بیارید و کپی پیستش کنید.

http://s2.picofile.com/file/7790200321/Code1.png

یه نگاه با دیباگر هم بهش بندازید بد نیست.

http://s2.picofile.com/file/7790211177/Debug1.png

وقتی توی دیباگر بهش نگاه میکنید میبینید که آدرس واقعی (005B15F0) نشون داده میشه بنابراین همونطور که قبلا گفتیم برنامه دیباگر میتونه این آدرس واقعی رو در جاهای دیگه هم پیدا کنه.

خب حالا اگه ما کُد اصلی رو که اسمبلیش به این صورت هست:

  asm

    lea eax, [ebp-$08]

    call ReadSnFromReg

  end;

کمی بپیچونیم:

  asm

    lea eax, [ebp-$08]

    mov ecx, offset ReadSnFromReg + 500

    sub ecx, 500

    call ecx

  end;

به نظرتون توی دیباگر چی میبینیم:

http://s2.picofile.com/file/7790234080/Debug2.png

خب همونطور که ملاحظه میکنید دیباگر آدرس واقعی تابع ReadSnFromReg رو نشون نمیده و اگه هم از جای دیگه ای آدرس واقعی جستجو بشه در این قسمت چیزی پیدا نمیشه.

تنها کاری که ما انجام دادیم این بود که آدرس واقعی (005B15F0 = offset ReadSnFromReg) رو به اضافه 500 کردیم و وقتی برنامه کامپایل شد عدد محاسبه شده (005B17E4) در دیباگر نشون داده شد به همین خاطر دیگه جستجوی آدرس واقعی (005B15F0) در این قسمت بی نتیجه میشه چون توی کُدهای حقیقی، این آدرس نوشته نشده که در صورت جستجو بشه پیداش کرد!

خب ما با روش بالا سرنخ پیدا کردن یک تابع رو مخدوش کردیم.

ادامه میدم... فعلا...

سلام مجدد.

خب اول مطالب پست اولم رو يه جمع بندي بکنم:

همونطور که در بالا گفتم اولين فايده مبهم سازي کُد، پاک کردن رد پاها و مخدوش کردن مدارک و شواهده تا کرکر نتونه به سادگي نقاط کليدي کُدهامون رو پيدا کنه. در اين راستا يه مثالي از مبهم سازي براي فراخواني تابع (که در اسمبلي با فرمان call اجرا ميشه) آوردم که با يه جمع و تفريق ساده ي آدرس امکانپذير شد.
در مورد روشهاي مبهم سازيه اين چنيني يه PDF مرجع هست که ضميمه کردم. اين PDF در مورد پيچوندن مهم ترين فرمان هاي اسمبلي بهتون کمک ميکنه.

در اين پست با يک مثال، مقداري از مطالب اوليه PDF مذکور رو به زبان فارسي براتون توضیح میدم:

تبدیل یک Call به یک JMP:
خب همونظور که میدونید معمولا برای صدا زدن یک تابع از فرمان call استفاده میشه ولی در حقیقت خود call هم نوعی jmp هست با این تفاوت که وقتی فرمان call انجام میشه آدرس فعلی در استک قرار میگیره تا پس از Ret بتونیم به این آدرس برگردیم ولی jmp آدرس جاری رو جایی ذخیره نمیکنه...
کُدهای اسمبلی مثال قبلی (که توی پست اول گفتم) رو توی دیباگر نگاه کنید (عکس زیر):

  asm

    lea eax, [ebp-$08]

    call ReadSnFromReg

  end;

http://s4.picofile.com/file/7792309779/Dbg1.png

فرمان call در آدرس 005B164A قرار داره زمانیکه call انجام بشه به خط بعد از آن یعنی به آدرس 005B164F باز خواهیم گشت بنابراین زمانیکه فرمان call میخواد اجرا بشه آدرس 005B164F رو در استک قرار میده تا بتونه بهش برگرده؛ خودتون میدونید که قرار دادن یک مقدار در استک همون push کردن اون مقدار هست با این حساب اگه ما آدرس خط بعدی رو push بکنیم میتونیم از jmp به جای call استفاده بکنیم. بصورت تئوری اینطوری باید کُد نوشت.

  asm

    lea eax, [ebp-$08]

    push CurrentLineOffset + 10

    jmp ReadSnFromReg

  end;

اما مشکل اینجاست که ما آدرس خط جاری (CurrentLineOffset) رو نداریم.
با دو تا ترفند میتونیم آدرس خط جاری رو بدست بیاریم:
- یکی call درجا، یعنی call 0 که توی inline assembler دلفی من میتونم به این صورت بنویسمش.

  asm

    lea eax, [ebp-$08]

    DB $E8, 0,0,0,0

    add [esp], 4+5

    jmp ReadSnFromReg

  end;

به خط دوم توجه کنید یک call درجا، میتونه یک push از آدرس خط جاری براتون بسازه. حواستون باشه که میخواهید به خط بعد از jmp برید پس آدرسی که توی استک ذخیره شده رو به اضافه مقدار مورد نیاز بکنید؛ توی خط سوم این کار انجام شده.

- دومی ساختن تابع ای که قبل از Ret، آدرس بازگشت رو توی یک رجیستر ذخیره کنه. توی دلفی من به این صورت مینویسمش:

  function Get_EIP: DWORD;

  asm

    pop eax

    push eax

  end;



procedure TForm3.Button1Click(Sender: TObject);

var

  S: string;

begin

  asm

    call Get_EIP

    add eax, 3+1+3+5

    push eax

    lea eax, [ebp-$08]

    jmp ReadSnFromReg

  end;

تابع GET_EIP عمل مورد نظر ما رو انجام میده (محض اطلاع بگم که مقدار موجود در رجیستر EIP آدرس خط جاری رو همیشه نگاه داری میکنه ولی توی برنامه نویسی ما مستقیما بهش دسترسی نداریم). آدرس خط جاری در eax قرار گرفته به اضافه مقدار مورد نظر شده و push داده میشه.

امیدوارم این مبحث براتون مفید و الهام بخش مبهم سازی های خلاقانه باشه.

اگر علاقه مند به این گونه مبهم سازی ها هستید مطالب PDF ضمیمه شده رو پی بگیرید.
----------------------------

اگر مجالی باشه در ادامه روشهاي ديگه اي از مبهم سازي که براي خسته کردن يا گيج کردن کرکر به کار ميره رو توضیح میدم.

موفق باشید.

دانلود فایل Applied Binary Code Obfuscation.PDF

در مورد خسته کردن، گیج کردن یا اتلاف وقت کرکرها بهتره از آسون ترین راه که همون استفاده از JUNK Code (یا Rubbish Code به معنی کُدهای هرز) شروع کنیم....

فایده کُدهای هرز چیه؟

خب کرکر باید براشون به نحوی وقت بذاره (حتی اگه از پلاگین های آماده JUNK CODE Remover هم استفاده کنه - البته میشه JUNK CODE ها رو به نحوی استفاده کرد که پلاگین های آماده نتونن از پسش بر بیان) و بفهمه که کدوم کُدها هرز هستن که همین خودش باعث گیج کردن و خسته کردن کرکر میشه که به نوعی فرسایش انرژی یه کرکر رو باعث میشه.

----------------

شما میتونید خودتون کُدهای هرز داخل کُدهاتون به کار ببرید؛ هدف کُدهایی هستن که هدفی ندارن، برای مثال حلقه هایی بنویسید که در عمل هیچ کارایی ندارن یا یکسری مقدار دهی متغییر انجام بدید و بدون اینکه ازش استفاده کنید جلوتر یه مقدار دیگه بهش بدید و از این جور کارها.
در این راه شما میتونید از برنامه های آماده هم استفاده کنید برای NET. برنامه های زیادی بدین منظور هست که میتونید دانلود کنید ولی بحث ما در مورد کُدهای باینری هست.
یه مثال از سایت http://www.sourceformat.com/code-obfuscator-delphi.htm :

//////////////////////////////////////////////////////////////////////////////////////////

  //                                                                                      //

  //      Before Junk Code Obfuscating - Object Pascal (Delphi) Example Source Code       //

  //                                                                                      //

  //////////////////////////////////////////////////////////////////////////////////////////



  function QuickPos(const Substr, S: WideString; MatchesIndex: Integer = 1): Integer;

  var

    LenOfS, LenOfSubstr: Integer;

  begin

    Result := Pos(Substr, S);



    if (MatchesIndex = 1) or (Result = 0) then

      Exit;



    LenOfS := Length(S);

    LenOfSubstr := Length(Substr);



    while (MatchesIndex > 1) and (Result > 0) do

    begin

      Result := _PosForward(Substr, S, Result + 1, LenOfSubstr, LenOfS);



      if Result = 0 then

        Exit;



      Dec(MatchesIndex);

    end;

  end;

  

  //////////////////////////////////////////////////////////////////////////////////////////

  //                                                                                      //

  //      After Junk Code Obfuscating - Object Pascal (Delphi) Example Source Code        //

  //                                                                                      //

  //////////////////////////////////////////////////////////////////////////////////////////



  function QuickPos(const Substr, S: WideString; MatchesIndex: Integer = 1): Integer;

  var

    LenOfS, LenOfSubstr: Integer;

  begin

    // junk instruction begin

    asm

      jz   @1

      jnz  @1

      db   $e9

      @1:

    end;

    // junk instruction end



    Result := Pos(Substr, S);



    // junk instruction begin

    asm

          pushf

          push  $0A

      @1: jnb   @3

          jmp   @2

      @2: call  @4

      @3: jnb   @2

      @4: add   esp,4

          jmp   @5

      @5: dec   dword ptr [esp]

          jno   @6

      @6: jns   @1

          jp    @7

      @7: add   esp,4

          popf

          jmp   @8

      @8:

    end;

    // junk instruction end



    if (MatchesIndex = 1) or (Result = 0) then

    begin

      // junk instruction begin

      asm

            pushf

            jb    @3

        @1: jmp   @2

        @2: call  @4

        @3: jb    @1

        @4: add   esp,4

            popf

            jmp   @5

        @5:

      end;

      // junk instruction end



      Exit;

    end;



    LenOfS := Length(S);

  

    // junk instruction begin

    asm

          jz   @1

          jnz  @1

          db   $e8

      @1:

    end;

    // junk instruction end



    LenOfSubstr := Length(Substr);



    // junk instruction begin

    asm

      db 0E9h,0A2h,001h,000h,000h,049h,00Fh,0F6h,03Ch,0CFh,  075h,0EEh,0C0h,00Fh,031h,08Bh

      db 0C8h,00Fh,031h,02Bh,0C8h,0F7h,0D1h,081h,0F9h,000h,  050h,000h,000h,07Fh,0FEh,00Fh

      db 031h,08Bh,0C8h,00Fh,031h,02Bh,0C8h,0F7h,0D1h,081h,  0F9h,000h,050h,000h,000h,07Fh

      db 0FEh,0D6h,00Fh,088h,0DDh,001h,000h,000h,00Fh,089h,  0D7h,001h,000h,000h,03Eh,0C1h

      db 0C3h,005h,0C1h,0CBh,005h,036h,00Fh,08Ah,001h,002h,  000h,000h,00Fh,08Bh,0FBh,001h

      db 000h,000h,05Bh,0E8h,00Bh,000h,000h,000h,072h,065h,  067h,069h,073h,074h,065h,072h

      db 065h,064h,000h,058h,0EBh,002h,012h,028h,0E8h,03Eh,  000h,000h,000h,099h,04Fh,0F6h

      db 03Ch,0FFh,090h,05Fh,050h,00Fh,031h,08Bh,0C8h,00Fh,  031h,02Bh,0C8h,0F7h,0D1h,081h

      db 0F9h,000h,050h,000h,000h,07Ch,005h,0E9h,0D7h,06Ch,  030h,0F0h,0E8h,00Bh,000h,000h

      db 000h,072h,065h,067h,069h,073h,074h,065h,072h,065h,  064h,000h,058h,0F8h,00Fh,084h

      db 0A1h,000h,000h,000h,00Fh,085h,09Bh,000h,000h,000h,  03Bh,068h,01Dh,024h,000h,000h

      db 083h,0C4h,004h,083h,0C4h,004h,00Fh,084h,007h,000h,  000h,000h,00Fh,085h,001h,000h

      db 000h,000h,048h,0E8h,00Bh,000h,000h,000h,072h,065h,  067h,069h,073h,074h,065h,072h

      db 065h,064h,000h,058h,0EBh,00Bh,072h,065h,067h,069h,  073h,074h,065h,072h,065h,064h

      db 000h,065h,0F8h,00Fh,083h,056h,0FFh,0FFh,0FFh,000h,  0A4h,0BCh,0E6h,0D6h,0B7h,0E8h

      db 00Bh,000h,000h,000h,072h,065h,067h,069h,073h,074h,  065h,072h,065h,064h,000h,058h

      db 0F9h,00Fh,031h,08Bh,0C8h,00Fh,031h,02Bh,0C8h,0F7h,  0D1h,081h,0F9h,000h,050h,000h

      db 000h,07Fh,0FEh,068h,019h,054h,000h,000h,083h,0C4h,  004h,0D6h,00Fh,08Ah,0CFh,000h

      db 000h,000h,00Fh,08Bh,0C9h,000h,000h,000h,058h,0EBh,  00Dh,077h,072h,06Fh,06Eh,067h

      db 020h,073h,065h,072h,069h,061h,06Ch,000h,0E9h,038h,  0FFh,0FFh,0FFh,043h,03Eh,0F6h

      db 03Ch,0C5h,094h,053h,011h,0E8h,001h,000h,000h,000h,  086h,0E8h,001h,000h,000h,000h

      db 0B8h,083h,044h,024h,004h,012h,083h,004h,024h,00Ah,  0C3h,0F8h,050h,052h,00Fh,031h

      db 033h,0C8h,05Ah,033h,0C8h,058h,051h,059h,0F9h,00Fh,  082h,006h,000h,000h,000h,000h

      db 06Bh,05Dh,082h,06Bh,0EBh,00Fh,0CFh,00Fh,0CFh,036h,  00Fh,080h,0D3h,0FEh,0FFh,0FFh

      db 00Fh,081h,0CDh,0FEh,0FFh,0FFh,0DCh,050h,052h,00Fh,  031h,033h,0C8h,05Ah,033h,0C8h

      db 058h,068h,0EFh,04Ch,000h,000h,083h,0C4h,004h,036h,  00Fh,084h,06Dh,0FEh,0FFh,0FFh

      db 00Fh,085h,067h,0FEh,0FFh,0FFh,00Ah,00Fh,031h,08Bh,  0C8h,00Fh,031h,02Bh,0C8h,0F7h

      db 0D1h,081h,0F9h,000h,050h,000h,000h,07Fh,0FEh,0EBh,  00Bh,072h,065h,067h,069h,073h

      db 074h,065h,072h,065h,064h,000h,068h,027h,0ACh,000h,  000h,083h,0C4h,004h,00Fh,08Ch

      db 0B3h,0FFh,0FFh,0FFh,00Fh,08Dh,0ADh,0FFh,0FFh,0FFh,  094h,068h,075h,004h,000h,000h

      db 083h,0C4h,004h,0F3h,0F8h,00Fh,083h,004h,0FFh,0FFh,  0FFh,000h,0BBh,08Dh,090h,07Ch

      db 097h,0E8h,001h,000h,000h,000h,0EAh,0E8h,001h,000h,  000h,000h,008h,083h,044h,024h

      db 004h,012h,083h,004h,024h,00Ah,0C3h,010h,0F9h,00Fh,  082h,01Ah,0FFh,0FFh,0FFh,000h

      db 02Bh,09Dh,0CDh,020h,0DBh,00Fh,031h,08Bh,0C8h,00Fh,  031h,02Bh,0C8h,0F7h,0D1h,081h

      db 0F9h,000h,050h,000h,000h,07Fh,0FEh,0E8h,00Bh,000h,  000h,000h,072h,065h,067h,069h

      db 073h,074h,065h,072h,065h,064h,000h,058h,068h,09Fh,  00Ch,000h,000h,083h,0C4h,004h

      db 00Fh,088h,095h,0FFh,0FFh,0FFh,00Fh,089h,08Fh,0FFh,  0FFh,0FFh,073h,0EBh,00Bh,072h

      db 065h,067h,069h,073h,074h,065h,072h,065h,064h,000h,  00Fh,088h,007h,000h,000h,000h

      db 00Fh,089h,001h,000h,000h,000h,0A1h

    end;

    // junk instruction end



    while (MatchesIndex > 1) and (Result > 0) do

    begin

      Result := _PosForward(Substr, S, Result + 1, LenOfSubstr, LenOfS);



      // junk instruction begin

      asm

            jz   @1

            jnz  @1

            db   $9a

            db   $e8

        @1:

      end;

      // junk instruction end



      if Result = 0 then

        Exit;



      // junk instruction begin

      asm

        db   0EBh, 1,    0Fh,  31h

        db   0F0h, 0EBh, 0Ch,  33h

        db   0C8h, 0EBh, 3,    0EBh

        db   9,    0Fh,  59h,  74h

        db   5,    75h,  0F8h, 51h

        db   0EBh, 0F1h

      end;

      // junk instruction end



      Dec(MatchesIndex);



      // junk instruction begin

      asm

            jz   @1

            jnz  @1

            db   $e8

        @1:

      end;

      // junk instruction end

    end;

  end;

این مثال بیشتر (یا کاملاً) روی اسمبلی معطوف هست و من در این پست یک برنامه آماده برای تولید کُدهای هرز اسمبلی معرفی میکنم و در پست بعدی یک سری منطق های بی هدف یا هدفمند کُد نویسی برای گیج کردن و خسته کردن کرکر رو نشون میدم.

خب شما برای تولید خودکار کُدهای هرز میتونید از این برنامه:
Rubbish Code Generator - IMPosTOR - UnREaL RCE
استفاده کنید. فایلش رو ضمیمه کردم.
استفاده از این برنامه با یک bat فایل که در کنارش هست خیلی آسونه، داخل فایل bat تعداد و اندازه JUNK CODE هایی که میخواهید تولید بشن رو وارد کنید.

@_rcg_0_1.exe 64 5

;@Pause

تعداد 5 تا و اندازه 64 بایت
حالا وقتی فایل bat رو ذخیره و اجرا کنید خواهید دید که به تعداد مورد نظر فایل .inc و فایل .asm تولید میکنه:

http://s4.picofile.com/file/7792800642/Junk1.png

استفاده از فایل .inc در داخل محیط برنامه نویسی هم که خودتون میدونید:

  {$INCLUDE JUNK\obf_64_1.inc}

  inherited Create(True);

  {$INCLUDE JUNK\obf_64_2.inc}

قبل یا بعد هر خط کُد (و یا حتی بعد یا قبل هر خط اسمبلی هم) میتونین ازش استفاده کنید.

اگه شما هم مطلبی دارین در این زمینه از ما دریغ نکنید.
فعلا...

اما در مورد مبهم سازي هاي خسته کننده و گيج کننده:
من يه نمونه کاربردي براي روشن شدن مطلب مثال ميزنم شما ميتونيد با خلاقيت خودتون هر جور کُدي بنويسيد که کرکر رو خسته يا گيج بکنيد.

مثال: کُد اسپاگتي (Spaghetti Code)
منبع: R4ndom’s Tutorial #21 Anti-Debugging Techniques « The Legend Of Random

فرايند بسيار ساده چک کردن يه شماره سريال رو در نظر بگيريد:
- اول بايد شماره سريالي که کاربر وارد ميکنه رو بگيريد.

S1 := GetSerialNumber

- بعد بايد يه شماره سريال صحيح رو بارگذاري کنيد.

S2 := RetriveACorrectSerial

- حالا بايد شماره سريال گرفته شده رو با شماره سريال بارگذاري شده تطابق بديد.

if S1 = S2 then

- اگر صحيح بود پيام صحيح بودن رو نشون بدين و برنامه رو بطور کامل بياريد بالا.

goto CorrectSerialFunction

- اگر اشتباه بود که پيام اشتباه بودن رو نشون بدين و برنامه رو ببنديد.

goto InCorrectSerialFunction

خب همين چند خط کُد ساده رو در نظر بگيريد

S1 := GetSerialNumber

S2 := RetriveACorrectSerial

if S1 = S2 then

goto CorrectSerialFunction

else

goto InCorrectSerialFunction

کرکر هم به همين سادگي که اين رو مينويسيد کُد رو ميفهمه و کرکش ميکنه.

حالا اگه شما کُد رو بصورت زير تغيير بديد:

Jump to Spaghetti1



Spaghetti6:



InCorrectSerialFunction



Jump to End



Spaghetti3:



if S = S2 then



jump to Spaghetti5



else



Jump to Spaghetti6



Spaghetti1:



S1 := GetSerialNumber



Jump to Spaghetti2



End:



Exit;



Spaghetti2:



S2 := RetriveACorrectSerial



Jump to Spaghetti3



Spaghetti5:



CorrectSerialFunction



Jump to End

به نظرتون کار کرکر براي فهميدنش سخت تر نميشه!
مطمئناً همينطوره چون حتي برنامه هاي ديباگر هم ممکنه گيج بشن و نتونن کُد رو بدرستي آناليز کنن.

اگه فکر ميکنيد ارزشش رو نداره که چنين حرکت هايي توي کُدهاتون بزنين، بايد بگم که براي آناليز کُدهاي پيچيده يه کرکر بايد قلم و کاغذ برداره و با يه فکر باز و دقت تمام کُدهاي شما رو آناليز کنه؛ اگه خسته باشه کم حوصله باشه يا حواسش پرت بشه و چند بار توي کُدهاي شما گيج بشه، کلافه ميشه و انرژيش تحليل ميره و ممکنه توي آناليز کُدها اشتباه کنه شک نکنيد!

مثال بالا نمونه اي بود از روش هاي خسته يا گيج کردن کرکر، شما ميتونيد از خلاقيت خودتون براي پيچوندن کُدهاتون استفاده کنيد و دمار از روزگار آدم هاي کم حوصله در بياريد.


موفق باشيد.

این وب سایت هم در نوع خودش جالبه کد Assembly بهش میدی و خودش عملیات Obfuscation رو روی کد ها انجام میده و نتیجه رو برمی گردونه .

نقل قول:

---

نوشته شده توسط بهروز عباسی

این وب سایت هم در نوع خودش جالبه کد Assembly بهش میدی و خودش عملیات Obfuscation رو روی کد ها انجام میده و نتیجه رو برمی گردونه .

---

تکنیکی که تحت عنوان کد اسپاگتی معرفی شد رو در کد اعمال میکنه ؛ یا همون Control Flow Obfuscation ؛ اگر نسخه کاملش رو داشته باشید خیلی بهتر عمل میکنه