API tools faq
paste
Advertisement
Guest User

DrAg0n Protection (2012 ) Source code ( Clear )

a guest
Jun 16th, 2014
823
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 17.91 KB | None | 0 0
raw download clone embed print report
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <fcntl.h>
  4. #include <io.h>
  5. #include <iostream>
  6. #include <fstream>
  7. #include <vector>
  8. #include "detours.h"
  9. #include <string>
  10. #include <Wincrypt.h>
  11. int hConHandle;
  12. long lStdHandle;
  13.  
  14. #define dll extern "C" __declspec(dllexport)
  15.  
  16. using namespace std;
  17.  
  18. static const WORD MAX_CONSOLE_LINES = 1000;
  19.  
  20. // Aedes Protection
  21.  
  22.  
  23.     string name = "Metin2Deluxe",
  24.     version = "1.1.0.0",
  25.     date = "18/03/2012";
  26.  
  27.  
  28.  
  29. #pragma region Prototipi Funzioni
  30.  
  31. dll void showInfo();
  32. dll void get_pack(void);
  33. dll void sub_get(void);
  34. dll BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved);
  35. dll void RedirectIOToConsole();
  36. dll void FixExtractor();
  37. dll void RedirectIOToConsole( void );
  38. dll void get_name();
  39. dll void lzo_func_1();
  40. dll void lzo_func_2();
  41. dll void lzo_func_3();
  42. dll void lzo_func_4();
  43. dll int xtea(int,int,LPBYTE,int);
  44. dll void block_get();
  45. dll int check(int,int,char*);
  46. dll void xxtea();
  47. dll void pong_func();
  48. dll void block_ref();
  49. dll void block_switch();
  50.  
  51. #pragma endregion Prototipi Funzioni
  52. #pragma region Dichiarazioni
  53.  
  54. DWORD fileName_add;
  55.  
  56. // GetPack
  57. DWORD push_0070F89B = 0x0070F89B;
  58. DWORD call_005769F0 = 0x005769F0;
  59. DWORD call_00576B90 = 0x00576B90;
  60. DWORD call_00640230 = 0x00640230;
  61. DWORD push_0073E6B4 = 0x0073E6B4;
  62. DWORD call_0065932E = 0x0065932E;
  63. DWORD push_0073E6AC = 0x0073E6AC;
  64. DWORD push_0073E6A4 = 0x0073E6A4;
  65. DWORD call_00571070 = 0x00571070;
  66. DWORD call_005D6BA0 = 0x005D6BA0;
  67. DWORD call_00571290 = 0x00571290;
  68. DWORD call_0073E6A0 = 0x0073E6A0;
  69. DWORD call_00571460 = 0x00571460;
  70. DWORD call_0063F020 = 0x0063F020;
  71.  
  72. DWORD call_005DF7D0 = 0x005DF7D0;
  73.  
  74. int count = 0;
  75.  
  76. // end - GetPack Ref;
  77.  
  78. // SubGet - Ref
  79.     DWORD call_005D3FC0 = 0x005D3FC0;
  80.     DWORD call_005D63F0 = 0x005D63F0;
  81. // End SubGet - Ref
  82.  
  83. char* control_1 = ".pyc";
  84. char* control_2 = ".txt";
  85. char* info,*info2,  *info3, *info4, *info5, *info6;
  86.  
  87. // Start Lzo_func_1 Ref;
  88. DWORD call_005D7F80 = 0x005D7F80;
  89. DWORD call_00407800 = 0x00407800;
  90. DWORD call_0063F640 = 0x0063F640;
  91. DWORD push_0074C518 = 0x0074C518;
  92. DWORD call_004069F0 = 0x004069F0;
  93. DWORD call_005D8120 = 0x005D8120;
  94. DWORD call_005DA2D0 = 0x005DA2D0;
  95. DWORD call_005714D0 = 0x005714D0;
  96. DWORD push_0073E6A0 = 0x0073E6A0;
  97. DWORD call_0074C518 = 0x0074c518;
  98. DWORD addy_74C520 = 0x74C520;
  99. BYTE addy_74C524 = 0x74C524;
  100. // End Lzo_func_1 ref;
  101. DWORD call_0063EFDD = 0x0063EFDD;
  102. DWORD call_00428900 = 0x00428900;
  103. DWORD call_005767B0 = 0x005767B0;
  104. #pragma endregion Dichiarazioni
  105. #pragma region Archivi
  106.  
  107. /* Standart */
  108. char *magic = "MCOZ";
  109.  
  110. char *pong = "83da635ds12312ss";
  111.  
  112. char* est_1 = ".eue";
  113. char* est_2 = ".dlx";
  114.  
  115.  
  116. DWORD index_est = *(int *)(est_2);
  117. byte key_1[] = {0xff , 0x37 , 0x3f , 0x3f , 0xf3 , 0x4E , 0xf1 , 0x25 , 0x4D , 0x2D , 0x5f , 0x30 , 0x52 , 0x37 , 0xf1 , 0xf5};
  118. byte key_2[] = {0x22 , 0xB8 , 0xB4 , 0x04 , 0x64 , 0xB2 , 0x6E , 0x1F , 0xAE , 0xEA , 0x18 , 0x00 , 0xA6 , 0xF6 , 0xFB , 0x1C};
  119.  
  120. char* packName;
  121.  
  122.  
  123. /* MIllenium Word
  124. char *magic = "THIA";
  125. char *pong = "abdi@lswkdsg33.1";
  126.  
  127. char* est_1 = ".mln";
  128. char* est_2 = ".wrl";
  129.  
  130. DWORD index_est = *(int *)(est_2);
  131.  
  132. byte key_1[] = {0x4D , 0x31 , 0x37 , 0x37 , 0x33 , 0x4E , 0x31 , 0x55 , 0x4D , 0x2D , 0x57 , 0x30 , 0x52 , 0x37 , 0x44 , 0x35};
  133. byte key_2[] = {0x22 , 0xB8 , 0xB4 , 0x04 , 0x64 , 0xB2 , 0x6E , 0x1F , 0xAE , 0xEA , 0x18 , 0x00 , 0xA6 , 0xF6 , 0xFB , 0x1C};
  134.  
  135. */
  136.  
  137. /*
  138. ArisOnline
  139. byte key_1[] = {0x32, 0x47, 0xDF, 0x98, 0x79, 0x87, 0x7D, 0xA7, 0x93, 0x21, 0x28, 0x79, 0x8D, 0xA3, 0x23, 0x20};
  140. byte key_2[] = {0x22 , 0xB8 , 0xB4 , 0x04 , 0x64 , 0xB2 , 0x6E , 0x1F , 0xAE , 0xEA , 0x18 , 0x00 , 0xA6 , 0xF6 , 0xFB , 0x1C};
  141.  
  142.  
  143. /*
  144.  
  145. Metin2Deluxe ( .Net )
  146.  
  147.  
  148. char *pong = "1234abcd5678efgh";
  149.  
  150. char* est_1 = ".dlx";
  151. char* est_2 = ".eue";
  152.  
  153. byte key_1[] = {0xff , 0x37 , 0x3f , 0x3f , 0xf3 , 0x4E , 0xf1 , 0x25 , 0x4D , 0x2D , 0x5f , 0x30 , 0x52 , 0x37 , 0xf1 , 0xf5};
  154. byte key_2[] = {0x22 , 0xB8 , 0xB4 , 0x04 , 0x64 , 0xB2 , 0x6E , 0x1F , 0xAE , 0xEA , 0x18 , 0x00 , 0xA6 , 0xF6 , 0xFB , 0x1C};
  155.  
  156.  
  157.  
  158.  
  159.  
  160.  
  161.  
  162. */
  163.  
  164. DWORD call_005728A0 = 0x005728A0;
  165. DWORD jmp_005DF8E7 = 0x005DF8E7;
  166. DWORD call_005700B0 = 0x005700B0;
  167. DWORD jmp_572057 = 0x572057;
  168. DWORD call_005D4090 = 0x005D4090;
  169. #pragma endregion Archivi
  170.  
  171. dll void start_crypto(){
  172.  
  173.         DetourFunction((BYTE*) 0x729C80, (BYTE*)pong_func);
  174.         DetourFunction((BYTE*) 0x5E06C8, (BYTE*)get_name);
  175.         DetourFunction((BYTE*) 0x005E06C0, (BYTE*)lzo_func_1);
  176.         DetourFunction((BYTE*) 0x005DF8BE, (BYTE*)lzo_func_2);
  177.         DetourFunction((BYTE*) 0x00572040, (BYTE*)lzo_func_3);
  178.         DetourFunction((BYTE*) 0x005700B0, (BYTE*)lzo_func_4);
  179.         DetourFunction((BYTE*) 0x48f7e0,( BYTE* )get_pack);
  180.         DetourFunction((BYTE*) 0x1E05D240, (BYTE*)block_get);
  181.         DetourFunction((BYTE*) 0x1E05D4E0, (BYTE*)block_ref);
  182.         DetourFunction((BYTE*) 0x0041D9D3, (BYTE*)block_switch);
  183.            
  184.         ifstream ReadFile;
  185.         ReadFile.open("info.txt");
  186.         string out;
  187.  
  188.         if (ReadFile.is_open()) {
  189.             ReadFile >> out;
  190.             if (out == "Show" || out == "show"){
  191.                 RedirectIOToConsole();
  192.                 showInfo();
  193.  
  194.             }
  195.         }
  196.        
  197.         ReadFile.close();
  198.  
  199. }
  200. dll void showInfo(){
  201.  
  202.     cout << "\t\t\tDrAg0n Protection v" << version << endl<< endl<< endl;
  203.     cout << "Version compiled for - " << name << endl;
  204.     cout << "Protection Compiled in date " << date << endl;
  205.  
  206.     cout << "Coded by DrAg0n" << endl;
  207.     cout << "Skype = dragon_9330" << endl;
  208.  
  209. }
  210. dll BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
  211. {
  212.     switch (fdwReason)
  213.     {
  214.     case DLL_PROCESS_ATTACH:
  215.         start_crypto();
  216.         break;
  217.  
  218.     case DLL_PROCESS_DETACH:
  219.  
  220.     ExitProcess(0);
  221.         break;
  222.  
  223.     case DLL_THREAD_ATTACH:
  224.  
  225.         break;
  226.  
  227.     case DLL_THREAD_DETACH:
  228.  
  229.         break;
  230.     }
  231.     return TRUE; // succesful
  232. }
  233. dll __declspec (naked) void get_pack(){
  234.  __asm{
  235.   PUSH -1
  236.   PUSH push_0070F89B
  237.   MOV EAX,DWORD PTR FS:[0]
  238.   PUSH EAX
  239.   MOV DWORD PTR FS:[0],ESP
  240.   SUB ESP,0x148
  241.   MOV EAX,DWORD PTR DS:[0x7C2DE8]
  242.   XOR EAX,ESP
  243.   LEA ECX,[ESP+4]
  244.   PUSH ECX
  245.   MOV DWORD PTR SS:[ESP+0x148],EAX
  246.   MOV EAX,DWORD PTR SS:[ESP+0x160]
  247.   PUSH 0
  248.   PUSH EAX
  249.   CALL call_005769F0
  250.   ADD ESP,0x0C
  251.   TEST AL,AL
  252.   JNE L0022
  253.   PUSH 0
  254.   CALL call_00576B90
  255.   ADD ESP,0x4
  256.   JMP L0083
  257. L0022:
  258.   MOV EDX,DWORD PTR SS:[ESP+0x4]
  259.   MOV info2, EDX
  260.   PUSH ESI
  261.   PUSH 0x2E
  262.   PUSH EDX
  263.   ritorno:
  264.   CALL call_00640230
  265.   MOV ESI,EAX
  266.   ADD ESP,0x8
  267.   TEST ESI,ESI
  268.   JE L0079
  269.   PUSH push_0073E6B4
  270.   PUSH ESI
  271.   CALL call_0065932E
  272.   ADD ESP,0x8
  273.   TEST EAX,EAX
  274.   JE L0049
  275.   inizio:
  276.   PUSH control_1
  277.   PUSH ESI
  278.   CALL call_0065932E
  279.   ADD ESP,0x8
  280.   TEST EAX,EAX
  281.   JE L0049
  282.   PUSH control_2
  283.   PUSH ESI
  284.   CALL  call_0065932E
  285.   ADD ESP,0x8
  286.   TEST EAX,EAX
  287.   JNE L0079
  288.   L0049:
  289.   LEA ECX,[ESP+0x0C]
  290.   CALL call_00571070
  291.   MOV ECX,DWORD PTR SS:[ESP+0x8]
  292.   LEA EAX,[ESP+04]
  293.   PUSH EAX
  294.   PUSH ECX
  295.   MOV ECX,DWORD PTR DS:[0x7D0710]
  296.   LEA EDX,[ESP+0x14]
  297.   PUSH EDX
  298.   MOV DWORD PTR SS:[ESP+0x160],0
  299.   MOV DWORD PTR SS:[ESP+0x10],0
  300.   CALL sub_get
  301.   CALL check
  302.   TEST AL,AL
  303.   LEA ECX,[ESP+0x0C]
  304.   JE L0077
  305.   CALL call_00571290
  306.   PUSH EAX
  307.   MOV EAX,DWORD PTR SS:[ESP+0x08]
  308.   PUSH EAX
  309.   PUSH push_0073E6A0
  310.   CALL DWORD PTR DS:[0x7317B0]
  311.   ADD ESP,0x0C
  312.   LEA ECX,[ESP+0x0C]
  313.   MOV ESI,EAX
  314.   MOV DWORD PTR SS:[ESP+0x154],-1
  315.   CALL call_00571460
  316.   MOV EAX,ESI
  317.   JMP L0082
  318. L0077:
  319.   MOV DWORD PTR SS:[ESP+0x154],-1
  320.   CALL call_00571460
  321. L0079:
  322.   PUSH 0
  323.   CALL call_00576B90
  324.   ADD ESP,0x4
  325. L0082:
  326.   POP ESI
  327. L0083:
  328.   MOV ECX,DWORD PTR SS:[ESP+0x148]
  329.   MOV DWORD PTR FS:[0],ECX
  330.   MOV ECX,DWORD PTR SS:[ESP+0x144]
  331.   XOR ECX,ESP
  332.   CALL call_0063F020
  333.   ADD ESP,0x154
  334.   RETN
  335.  }
  336.  
  337. fine:
  338.  __asm MOV info,ESI
  339. cout << info << endl;
  340. __asm JMP inizio
  341.  
  342. log2:
  343. cout << info2 << endl;
  344. __asm JMP ritorno
  345.  
  346. }
  347. dll __declspec (naked) void sub_get(){
  348.  
  349.    
  350.  
  351. __asm{
  352.  
  353.   PUSH EBX
  354.   MOV EBX,DWORD PTR SS:[ESP+0x0C]
  355.   PUSH EBP
  356.   MOV EBP,DWORD PTR SS:[ESP+0x0C]
  357.   PUSH ESI
  358.   PUSH EDI
  359.   MOV EDI,DWORD PTR SS:[ESP+0x1C]
  360.   MOV ESI,ECX
  361.   MOV EAX,DWORD PTR DS:[ESI+0x8]
  362.   TEST EAX,EAX
  363.   PUSH EDI
  364.   PUSH EBX
  365.   PUSH EBP
  366.   JNE L0027
  367.   CALL call_005D3FC0
  368.   TEST AL,AL
  369.   JNE L0030
  370.   PUSH EDI
  371.   PUSH EBX
  372.   PUSH EBP
  373.   MOV ECX,ESI
  374.   CALL call_005D63F0
  375.   POP EDI
  376.   POP ESI
  377.   POP EBP
  378.   POP EBX
  379.   RETN 0x0C
  380. L0027:
  381.   CALL call_005D63F0
  382.   TEST AL,AL
  383.   JE L0036
  384. L0030:
  385.   POP EDI
  386.   POP ESI
  387.   POP EBP
  388.   MOV AL,1
  389.   POP EBX
  390.   RETN 0x0C
  391. L0036:
  392.   PUSH EDI
  393.   PUSH EBX
  394.   PUSH EBP
  395.   MOV ECX,ESI
  396.   CALL call_005D3FC0
  397.   POP EDI
  398.   POP ESI
  399.   POP EBP
  400.   POP EBX
  401.   RETN 0x0C
  402.     }
  403. }
  404.  
  405. DWORD jmp_005E06C9 = 0x005E06C9;
  406.  
  407.  
  408.  
  409. dll __declspec (naked) void get_name(){
  410.  
  411. cout << packName;
  412.  
  413.  
  414. }
  415.  
  416. dll __declspec (naked) void lzo_func_1(){
  417.  
  418. __asm{
  419.  
  420.   PUSH EBP
  421.   MOV EBP,DWORD PTR SS:[ESP+0x18]
  422.   TEST EBP,EBP
  423.   PUSH ESI
  424.   PUSH EDI
  425.   MOV packName,EDI
  426.   MOV ESI,ECX
  427.   JE L0012
  428.   PUSH 0x20
  429.   PUSH EBP
  430.   LEA ECX,[ESI+0x1BEC]
  431.   CALL call_00407800
  432.   MOV BYTE PTR DS:[ESI+0x35D],0
  433. L0012:
  434.   MOV EDX,DWORD PTR SS:[ESP+0x18]
  435.   MOV EAX,EDX
  436.   LEA EDI,[EAX+0x1]
  437.   JMP L0017
  438.   LEA ECX,[ECX]
  439. L0017:
  440.   MOV CL,BYTE PTR DS:[EAX]
  441.   INC EAX
  442.   TEST CL,CL
  443.   JNE L0017
  444.   PUSH EBX
  445.   SUB EAX,EDI
  446.   PUSH EAX
  447.   PUSH EDX
  448.   LEA ECX,[ESI+0x1BC8]
  449.   CALL call_00407800
  450.   MOV EBX,DWORD PTR SS:[ESP+0x18]
  451.   PUSH 0x0FF
  452.   LEA EAX,[ESI+0x14D]
  453.   PUSH EBX
  454.   PUSH EAX
  455.   CALL call_0063F640
  456.   PUSH 104
  457.   LEA EDI,[ESI+0x24D]
  458.   PUSH EBX
  459.   PUSH EDI
  460.   CALL call_0063F640
  461.   ADD ESP,0x18
  462.   DEC EDI
  463. L0040:
  464.   MOV AL,BYTE PTR DS:[EDI+0x1]
  465.   INC EDI
  466.   TEST AL,AL
  467.   JNE L0040
  468.   MOV ECX,DWORD PTR DS:[index_est]
  469.   MOV DWORD PTR DS:[EDI],ECX
  470.   MOV DL,BYTE PTR DS:[0x74C524]
  471.   MOV EAX,EBX
  472.   MOV BYTE PTR DS:[EDI+0x4],DL
  473.   LEA EDX,[EAX+0x1]
  474. L0050:
  475.   MOV CL,BYTE PTR DS:[EAX]
  476.   INC EAX
  477.   TEST CL,CL
  478.   JNE L0050
  479.   SUB EAX,EDX
  480.   PUSH EAX
  481.   LEA EDI,[ESI+0x1BAC]
  482.   PUSH EBX
  483.   MOV ECX,EDI
  484.   CALL call_00407800
  485.   PUSH 0x4
  486.   PUSH est_1
  487.   MOV ECX,EDI
  488.   CALL call_004069F0
  489.   MOV AL,BYTE PTR SS:[ESP+0x20]
  490.   MOV ECX,ESI
  491.   MOV BYTE PTR DS:[ESI+0x35C],AL
  492.   CALL call_005D8120
  493.   TEST AL,AL
  494.   POP EBX
  495.   JE L0099
  496.   MOV ECX,ESI
  497.   CALL call_005DA2D0
  498.   TEST AL,AL
  499.   JE L0099
  500.   MOV EDX,DWORD PTR SS:[ESP+0x10]
  501.   TEST EBP,EBP
  502.   SETNE CL
  503.   PUSH ECX
  504.   PUSH EDX
  505.   MOV ECX,ESI
  506.   CALL call_005DF7D0
  507.   MOV AL,BYTE PTR DS:[ESI+0x35C]
  508.   TEST AL,AL
  509.   JE L0104
  510.   CMP DWORD PTR DS:[EDI+0x18],0x10
  511.   JB L0089
  512.   MOV EDI,DWORD PTR DS:[EDI+0x4]
  513.   JMP L0090
  514. L0089:
  515.   ADD EDI,0x4
  516. L0090:
  517.   PUSH 0
  518.   PUSH 0
  519.   LEA EAX,[ESI+0x140]
  520.   PUSH EAX
  521.   PUSH EDI
  522.   LEA ECX,[ESI+0x4]
  523.   CALL call_005714D0
  524.   TEST EAX,EAX
  525.   JNE L0106
  526. L0099:
  527.   POP EDI
  528.   POP ESI
  529.   XOR AL,AL
  530.   POP EBP
  531.   RETN 0x14
  532. L0104:
  533.   MOV ECX,ESI
  534.   CALL call_005D7F80
  535. L0106:
  536.   POP EDI
  537.   POP ESI
  538.   MOV AL,0x1
  539.   POP EBP
  540.   RETN 0x14
  541.  
  542. }
  543.  
  544. }
  545. dll __declspec (naked) void lzo_func_2(){
  546.  
  547. __asm{
  548.  
  549.   CMP EAX,magic
  550.   JNE 0x005DFAC3
  551.   PUSH OFFSET key_1
  552.   PUSH ESI
  553.   LEA EAX,[ESP+0x14]
  554.   MOV BYTE PTR SS:[EBP+0x14C],0x1
  555.   MOV ECX,DWORD PTR DS:[0x7D0C1C]
  556.   PUSH EAX
  557.   CALL call_005728A0
  558.   JMP jmp_005DF8E7
  559.  
  560. }  
  561. }
  562. dll __declspec (naked) void lzo_func_3(){
  563.  
  564. __asm{
  565.        
  566.   PUSH EDX
  567.   PUSH EBX
  568.   SUB EAX,4
  569.   PUSH EAX
  570.   PUSH EDI
  571.   MOV DWORD PTR SS:[ESP+0x2030],0
  572.   CALL call_005700B0
  573.   JMP jmp_572057
  574.    
  575.   }
  576.  
  577.  
  578.  
  579. }
  580. dll __declspec (naked) void  lzo_func_4(){
  581.  
  582. __asm{
  583.  
  584.   MOV EAX,DWORD PTR SS:[ESP+0x10]
  585.   MOV ECX,EAX
  586.   AND ECX,0x80000007
  587.   JNS L0007
  588.   DEC ECX
  589.   OR ECX,0xFFFFFFF8
  590.   INC ECX
  591. L0007:
  592.   JE L0012
  593.   SUB EAX,ECX
  594.   ADD EAX,0x8
  595.   MOV DWORD PTR SS:[ESP+0x10],EAX
  596.   JMP L0013
  597. L0012:
  598.   MOV DWORD PTR SS:[ESP+0x10],EAX
  599. L0013:
  600.   PUSH EBX
  601.   MOV EBX,EAX
  602.   SAR EBX,0x3
  603.   TEST EBX,EBX
  604.   JLE L0041
  605.   PUSH EBP
  606.   MOV EBP,DWORD PTR SS:[ESP+0x14]
  607.   PUSH ESI
  608.   MOV ESI,DWORD PTR SS:[ESP+0x14]
  609.   PUSH EDI
  610.   MOV EDI,DWORD PTR SS:[ESP+0x14]
  611.   LEA ECX,[ECX]
  612. L0025:
  613.   MOV EAX,DWORD PTR DS:[ESI]
  614.   MOV ECX,DWORD PTR DS:[ESI+0x4]
  615.   PUSH EDI // DwSize
  616.   PUSH EBP // lzoData
  617.   PUSH EAX // Pointer to [InData]
  618.   PUSH ECX // OutBuffer
  619.   CALL xtea
  620.   ADD ESP,0x10
  621.   ADD EDI,0x8
  622.   ADD ESI,0x8
  623.   DEC EBX
  624.   JNE L0025
  625.   MOV EAX,DWORD PTR SS:[ESP+0x20]
  626.   POP EDI
  627.   POP ESI
  628.   POP EBP
  629. L0041:
  630.   POP EBX
  631.   RETN
  632.  
  633. }
  634.  
  635.  
  636. }
  637.  
  638. bool first = false;
  639.  
  640. dll int xtea(int a1, int a2, LPBYTE key, int a4){
  641.  
  642.  int result;
  643.  
  644.  
  645.    
  646.    
  647.  
  648.  
  649. unsigned int sum = -957401312;
  650.   unsigned int delta = 0x61C88647;
  651.   unsigned int v5;
  652.   unsigned int v6;
  653.   signed int v7;
  654.  
  655.  
  656.  
  657.   v5 = a2;
  658.   v6 = a1;
  659.  
  660.   v7 = 32;
  661.  
  662.   for(int i = 0; i < v7; i++){
  663.     v6 -= (sum + *(DWORD*)(key + 4 * ((sum >> 11) & 3))) ^ (v5 + (16 * v5 ^ (v5 >> 5)));
  664.     sum += delta;
  665.     v5 -= (sum + *(DWORD*)(key + 4 * (sum & 3))) ^ (v6 + (16 * v6 ^ (v6 >> 5)));
  666.   }
  667.  
  668.  
  669.  
  670.   result = a4;
  671.   *(DWORD*)a4 = v5;
  672.   *(DWORD*)(a4 + 4) = v6;
  673.  
  674. return result;
  675.  
  676. }
  677. __declspec (naked) void xxtea(){
  678.    
  679.     __asm{
  680.   MOV EDX,DWORD PTR SS:[ESP+0x8]
  681.   MOV ECX,DWORD PTR SS:[ESP+0x4]
  682.   PUSH EBX
  683.   PUSH EBP
  684.   PUSH ESI
  685.   MOV ESI,DWORD PTR SS:[ESP+0x18]
  686.   PUSH EDI
  687.   MOV EAX,0xC6EF3720
  688.   MOV EDI,0x20
  689.   LEA EBX,[EBX]
  690. L0010:
  691.   MOV EBX,EDX
  692.   SHR EBX,0x5
  693.   MOV EBP,EDX
  694.   SHL EBP,0x4
  695.   XOR EBX,EBP
  696.   MOV EBP,EAX
  697.   SHR EBP,0x0B
  698.   AND EBP,0x00000003
  699.   MOV EBP,DWORD PTR DS:[EBP*0x4+ESI]
  700.   ADD EBP,EAX
  701.   ADD EBX,EDX
  702.   XOR EBX,EBP
  703.   SUB ECX,EBX
  704.   MOV EBX,ECX
  705.   SHR EBX,0x5
  706.   MOV EBP,ECX
  707.   SHL EBP,0x4
  708.   XOR EBX,EBP
  709.   ADD EAX,0x61C88647
  710.   MOV EBP,EAX
  711.   AND EBP,0x00000003
  712.   MOV EBP,DWORD PTR DS:[EBP*0x4+ESI]
  713.   ADD EBX,ECX
  714.   ADD EBP,EAX
  715.   XOR EBX,EBP
  716.   SUB EDX,EBX
  717.   DEC EDI
  718.   JNE L0010
  719.   MOV EAX,DWORD PTR SS:[ESP+0x20]
  720.   POP EDI
  721.   POP ESI
  722.   POP EBP
  723.   MOV DWORD PTR DS:[EAX],EDX
  724.   MOV DWORD PTR DS:[EAX+0x4],ECX
  725.   POP EBX
  726.   RETN
  727.   }
  728.  
  729.    
  730.  
  731. }
  732. __declspec (naked) void xxea_2(){
  733.  
  734.     __asm{
  735.  
  736.   MOV EDX,DWORD PTR SS:[ESP+0x8]
  737.   MOV ECX,DWORD PTR SS:[ESP+0x4]
  738.   PUSH EBX
  739.   PUSH EBP
  740.   PUSH ESI
  741.   MOV ESI,DWORD PTR SS:[ESP+0x18]
  742.   PUSH EDI
  743.   MOV EAX,0xC6EF3720
  744.   MOV EDI,0x20
  745.   LEA EBX,[EBX]
  746. L0010:
  747.   MOV EBX,EDX
  748.   SHR EBX,0x5
  749.   MOV EBP,EDX
  750.   SHL EBP,0x4
  751.   XOR EBX,EBP
  752.   MOV EBP,EAX
  753.   SHR EBP,0x0B
  754.   AND EBP,0x00000003
  755.   MOV EBP,DWORD PTR DS:[EBP*0x4+ESI]
  756.   ADD EBP,EAX
  757.   ADD EBX,EDX
  758.   XOR EBX,EBP
  759.   SUB ECX,EBX
  760.   MOV EBX,ECX
  761.   SHR EBX,0x5
  762.   MOV EBP,ECX
  763.   SHL EBP,0x4
  764.   XOR EBX,EBP
  765.   ADD EAX,0x61C88647
  766.   MOV EBP,EAX
  767.   AND EBP,0x00000003
  768.   MOV EBP,DWORD PTR DS:[EBP*0x4+ESI]
  769.   ADD EBX,ECX
  770.   ADD EBP,EAX
  771.   XOR EBX,EBP
  772.   SUB EDX,EBX
  773.   DEC EDI
  774.   JNE L0010
  775.   MOV EAX,DWORD PTR SS:[ESP+0x20]
  776.   POP EDI
  777.   POP ESI
  778.   POP EBP
  779.   MOV DWORD PTR DS:[EAX],EDX
  780.   MOV DWORD PTR DS:[EAX+0x4],ECX
  781.   POP EBX
  782.   RETN
  783.  
  784.     }
  785. }
  786. __declspec (naked) void xtea_lzo(){
  787.  
  788.     __asm{
  789.  
  790.   MOV EDX,DWORD PTR SS:[ESP+0x8]
  791.   MOV ECX,DWORD PTR SS:[ESP+0x4]
  792.   PUSH EBX
  793.   PUSH EBP
  794.   PUSH ESI
  795.   MOV ESI,DWORD PTR SS:[ESP+0x18]
  796.   PUSH EDI
  797.   MOV EAX,0xC6EF3720
  798.   MOV EDI,0x20
  799.   LEA EBX,[EBX]
  800. L0010:
  801.   MOV EBX,EDX
  802.   SHR EBX,0x5
  803.   MOV EBP,EDX
  804.   SHL EBP,0x4
  805.   XOR EBX,EBP
  806.   MOV EBP,EAX
  807.   SHR EBP,0x0B
  808.   AND EBP,0x00000003
  809.   MOV EBP,DWORD PTR DS:[EBP*0x4+ESI]
  810.   ADD EBP,EAX
  811.   ADD EBX,EDX
  812.   XOR EBX,EBP
  813.   SUB ECX,EBX
  814.   MOV EBX,ECX
  815.   SHR EBX,0x5
  816.   MOV EBP,ECX
  817.   SHL EBP,0x4
  818.   XOR EBX,EBP
  819.   ADD EAX,0x61C88647
  820.   MOV EBP,EAX
  821.   AND EBP,0x00000003
  822.   MOV EBP,DWORD PTR DS:[EBP*0x4+ESI]
  823.   ADD EBX,ECX
  824.   ADD EBP,EAX
  825.   XOR EBX,EBP
  826.   SUB EDX,EBX
  827.   DEC EDI
  828.   JNE L0010
  829.   MOV EAX,DWORD PTR SS:[ESP+0x20]
  830.   POP EDI
  831.   POP ESI
  832.   POP EBP
  833.   MOV DWORD PTR DS:[EAX],EDX
  834.   MOV DWORD PTR DS:[EAX+0x4],ECX
  835.   POP EBX
  836.   RETN
  837.  
  838.     }
  839. }
  840. dll int check(int, int,char *f_name)
  841. {
  842.    
  843.     string fName = f_name;
  844.     int pos = fName.rfind(".");
  845.     if (pos == 0){
  846.         ::MessageBoxA(0,"Universal Extractor Founded!","DrAg0N Protection",MB_OK);
  847.         ExitProcess(0);
  848.     }
  849.     else{
  850.     string Est = fName.substr(pos);
  851.     if (Est != ".py" && Est != ".txt" && Est != ".pyc"){
  852.         ::MessageBoxA(0,"Universal Extractor Founded!","DrAg0N Protection",MB_OK);
  853.         ExitProcess(0);
  854.     }}
  855.    
  856.     return 1;
  857.  
  858. }
  859. dll __declspec (naked) void pong_func(){
  860.  
  861.     __asm {
  862.  
  863.   PUSH 0x10
  864.   PUSH pong
  865.   MOV ECX,0x7A6188
  866.   CALL call_00407800
  867.   PUSH 0x0072E7F0
  868.   CALL call_0063EFDD
  869.   POP ECX
  870.   RETN
  871.  
  872. }
  873. }
  874. dll __declspec (naked )void block_get(){
  875.     ::MessageBoxA(0,"Py Injection Founded!","DrAg0N Protection",MB_OK);
  876.     ExitProcess(0);
  877. }
  878. dll __declspec (naked )void block_str(){
  879.     ::MessageBoxA(0,"Py Injection Founded!","DrAg0N Protection",MB_OK);
  880.     ExitProcess(0);
  881. }
  882. dll __declspec (naked) void block_ref(){
  883.     ::MessageBoxA(0,"Py Injection Founded!","DrAg0N Protection",MB_OK);
  884.     ExitProcess(0);
  885. }
  886. dll __declspec (naked) void block_switch(){
  887.  
  888.     __asm{
  889.  
  890.   MOV DWORD PTR SS:[ESP+0x4],0
  891.   MOV EAX,DWORD PTR SS:[ESP+0x8]
  892.   MOV ECX,DWORD PTR SS:[ESP+0x0C]
  893.   PUSH ECX
  894.   PUSH EAX
  895.   MOV ECX,DWORD PTR DS:[0x7D070C]
  896.   CALL call_00428900
  897.   CALL call_005767B0
  898.   POP ESI
  899.   ADD ESP,0x0C
  900.   RETN
  901.     }
  902. }
  903.  
  904. void RedirectIOToConsole( void )
  905. {
  906.    
  907.     CONSOLE_SCREEN_BUFFER_INFO coninfo;
  908.     FILE *fp;
  909.  
  910.     // allocate a console for this app
  911.     AllocConsole();
  912.  
  913.     // set the screen buffer to be big enough to let us scroll text
  914.     GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),    &coninfo);
  915.     coninfo.dwSize.Y = MAX_CONSOLE_LINES;
  916.     SetConsoleScreenBufferSize(GetStdHandle(STD_OUTPUT_HANDLE),    coninfo.dwSize);
  917.  
  918.     // redirect unbuffered STDOUT to the console
  919.     lStdHandle = (long)GetStdHandle(STD_OUTPUT_HANDLE);
  920.     hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
  921.  
  922.     fp = _fdopen( hConHandle, "w" );
  923.  
  924.     *stdout = *fp;
  925.     setvbuf( stdout, NULL, _IONBF, 0 );
  926.  
  927.     // redirect unbuffered STDIN to the console
  928.     lStdHandle = (long)GetStdHandle(STD_INPUT_HANDLE);
  929.     hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
  930.  
  931.     fp = _fdopen( hConHandle, "r" );
  932.  
  933.     *stdin = *fp;
  934.     setvbuf( stdin, NULL, _IONBF, 0 );
  935.  
  936.     // redirect unbuffered STDERR to the console
  937.     lStdHandle = (long)GetStdHandle(STD_ERROR_HANDLE);
  938.     hConHandle = _open_osfhandle(lStdHandle, _O_TEXT);
  939.  
  940.     fp = _fdopen( hConHandle, "w" );
  941.  
  942.     *stderr = *fp;
  943.     setvbuf( stderr, NULL, _IONBF, 0 );
  944.  
  945.     // make cout, wcout, cin, wcin, wcerr, cerr, wclog and clog
  946.     // point to console as well
  947.     ios::sync_with_stdio();
  948. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!