TurboLaunch 5.1.3 सुरक्षा अध्ययन

साधारण सुरक्षा या तीन तरीकों (पैच, स्निफर, कीजेन) में टर्बोलांच 5.1.3 तोड़ दें।

लक्ष्य : TurboLaunch 5.1.3
उपकरण : OllyDbg 1.10, Dup2 (एक पैच बनाने के लिए), OllyDbg, डेल्फी 7 के लिए कोडरिपर प्लगइन (keygen लिखने के लिए)

यह एक उबाऊ शाम थी, मैं एक ऐसे कार्यक्रम की तलाश में था जिसे मैं "खोदना" चाहूंगा। सबसे पहले, एक बाइट को संपादित करके मैंने AWBackuper 4.0 से परीक्षण को हटा दिया, यह बहुत ही निर्बाध लग रहा था, फिर मुझे उस प्रोग्राम को याद आया जो लंबे समय से (लगभग 4 साल) मेरे कंप्यूटर पर रहा था - यह Savo Software से TurboLaunch है। इसके लिए कीजेन्स मौजूद हैं (शायद लगभग 10), लेकिन मैंने उनमें से किसी में भी एक छोटी सी बारीकियों को नहीं देखा है (हालांकि इसके द्वारा और बड़ी यह महत्वपूर्ण भूमिका नहीं निभाती है), लेकिन इसके बारे में थोड़ी देर बाद।

और इसलिए, शुरू करते हैं ...

पैचिंग

पहला तरीका मैंने पैच चुना, क्योंकि शुरुआती लोगों के लिए यह सबसे आसान है।
हम पीड़ित को ओलीडबग (फिर सिर्फ ओलिया, ऑली) में लोड करते हैं। हम शुरू करते हैं और नाग-खिड़की देखते हैं, "मेरा पंजीकरण कोड दर्ज करें" पर क्लिक करें


अपना नाम (DimitarSerg) और "ईमानदारी से खरीदा गया" कोड 1234567890 दर्ज करें
बहुत अजीब है, लेकिन हम इस संदेश को देखते हैं:


पाठ स्ट्रिंग्स में संदेश टेक्स्ट देखें। RMB-> के लिए खोजें -> सभी संदर्भित पाठ स्ट्रिंग।

हम पाते हैं:


थोड़ा अधिक हम 00529CD3 से जंप देखते हैं, यानी हम वहां से आए थे।
महान, आइए देखें कि हमारे पास क्या है:

"क्लासिक":
CALL TurboLau.0053AEB0
TEST AL,AL
JE @TurboLau_00529D99

तो, एक जांच है और, परीक्षण के परिणाम के अनुसार, कूद।
यहाँ नीचे लाइनें हैं:

00529D1A |. BA F49D5200 MOV EDX,TurboLau.00529DF4 ; ASCII "REGISTERED TO: "
और ऐसे:
00529D3B |. 68 0C9E5200 PUSH TurboLau.00529E0C ; ASCII "Thank you for registering! Be sure to check out our web site for updated versions of TurboLaunch and other programs written by "

तो ठीक है, 00529CCC पर एक नज़र डालें। E8 DF110100 CALL TurboLau.0053AEB0
एक और कॉल है, और पंजीकरण प्रक्रिया के समान कुछ अंदर है। ठीक है, हमें सत्यापन प्रक्रिया की आवश्यकता क्यों है, अगर हम इसके बिना कर सकते हैं!

और इसलिए, 540628 पर पंजीकरण प्रक्रिया की शुरुआत में, हम एक "क्लासिक" पैच बनाते हैं
xor eax,eax // EAX
inc eax // EAX = EAX +1
Retn // return

परिवर्तन सहेजें। RMB-> निष्पादन योग्य कॉपी -> सभी संशोधनों -> फ़ाइल को सहेजें ।

एक नए नाम के तहत इसे सहेजें, उदाहरण के लिए, TurboLaunch1.exe
हम आनन्दित होना चाहते हैं, लेकिन बदले में हमें यह मिलता है:


एय-ay-ay। ईमानदारी की जाँच। खैर, भगवान उसके साथ रहें:
हम डिबगर में प्रोग्राम को फिर से लोड करते हैं, फिर संदेश बॉक्स फ़ंक्शन को कॉल करने के लिए ब्रेकपॉइंट सेट करते हैं
bp MessageBoxA

"मुख्य धागे की कॉल स्टैक" विंडो में, यह देखो कि यह कहाँ से आया है:


हम RMB-> शो कॉल करते हैं और पते पर खुद को पाते हैं
00450CA4 |. E8 8F75FBFF CALL <JMP.&user32.MessageBoxA> ; \MessageBoxA

ऊपर स्क्रॉल करें और देखें:
00450C7B |> \84DB TEST BL,BL
00450C7D |. 74 60 JE SHORT TurboLau.00450CDF

फिर से जाँच करें।
हम बिना शर्त (जेई -> जेएमपी) के लिए सशर्त संक्रमण को बदलते हैं, परिवर्तनों को बचाते हैं और शुरू करते हैं। हुर्रे, कार्यक्रम शुरू होता है।

अब हम विंडो खरीदने के लिए नहीं कह रहे हैं, के बारे में विंडो में हम "पंजीकृत" देखते हैं।
सामान्य तौर पर, किसी के लिए पंजीकृत, यह अच्छा है।

Dup2 या uPPP में एक पैच बनाना कोई समस्या नहीं है।

क्रम संख्या के लिए खोजें।

जैसा कि आपने ऊपर उल्लेख किया है, सही / गलत सीरियल नंबर के बारे में संदेश परिणाम के आधार पर बनता है

00529CD1 |. 84C0 TEST AL,AL

और ऊपर की लाइन हम देखते हैं:
00529CCC |. E8 DF110100 CALL TurboLau.0053AEB0
यह तर्कसंगत है कि पूरी पीढ़ी की प्रक्रिया यहां होती है ...

हम देखते हैं:
0053AEB0 /$ 8B90 68010000 MOV EDX,DWORD PTR DS:[EAX+168]
0053AEB6 |. 8B80 64010000 MOV EAX,DWORD PTR DS:[EAX+164]
0053AEBC |. E8 67570000 CALL TurboLau.00540628
0053AEC1 \. C3 RETN

हमने 0053AEB0 पर एक ब्रेकपॉइंट लगाया और नाम / पंजीकरण संख्या दर्ज करते समय हम यहां रुकते हैं और देखते हैं कि दर्ज किया गया डेटा पढ़ा जा रहा है, जिसका अर्थ है कि सबसे दिलचस्प CALL TurboLau.00540628 में है।

हम एफ 7 के साथ ट्रेस करते हैं, हम पढ़ना, कुछ परिवर्तन, अन्य संचालन आदि देखते हैं। आदि, परिणामस्वरूप, यदि आप इस प्रक्रिया को कुछ मिनटों का ध्यान और धैर्य देते हैं, तो निर्देश के निष्पादन के दौरान

00540758 |. 8B45 F4 MOV EAX,DWORD PTR SS:[EBP-C]

हम देखेंगे:
स्टैक एसएस: [0012F1AC] = 00C66E8C, (ASCII "D1F74F-5L3GRT-3WDULJ")
हम्म, सही सीरियल नंबर है?! हम कोशिश करते हैं: नाम DimitarSerg और सीरियल नंबर D1F74F-5L3GRT-3WDULJ, कार्यक्रम हमें अधिग्रहण पर बधाई देता है।

चूंकि सीरियल नंबर स्पष्ट दिखाई दे रहा है, स्निफर श्रृंखला को एक धमाके के साथ लिखा गया है, आपको बस उस पते पर EAX रजिस्टर देखने की जरूरत है जो 00540758 के तुरंत बाद, यानी 0054075B पर जाता है।

मैं एक स्निफ़र श्रृंखला लिखने के लिए कार्यप्रणाली का वर्णन नहीं करूंगा, लेकिन मैं कहूंगा कि AT4RE टीम में सीरियल स्निफ़र निर्माता जैसे उपकरण हैं, आप इसका उपयोग कर सकते हैं, इसे कुछ इस तरह देखना चाहिए:


लेकिन मैं इसकी सिफारिश नहीं करता हूं, क्योंकि यह यूनिकोड में सीरियल नंबर को सूँघता नहीं है और इसमें इंटरफ़ेस के साथ लगातार गड़बड़ियाँ हैं।
सार्वजनिक तौर पर स्निफ़र्स बनाने के लिए कई उदाहरण (टेम्प्लेट) होते हैं, इसलिए असेंबलर या डेल्फी हाथों में और आगे "खत्म" होते हैं।

keygen

खैर, सबसे दिलचस्प बात है, ज़ाहिर है, लेखन केजेन।
जैसा कि मैंने ऊपर वर्णित किया है, पूरी पीढ़ी की प्रक्रिया 00540628 से शुरू होती है
कोई भी पंजीकरण डेटा, ट्रेस दर्ज करें। इस जगह पर ध्यान दें:


इस कॉल पर एक नज़र डालें। हम नाम, गणना पर किए गए कुछ ऑपरेशन देखते हैं। मैं पहले से कहूंगा कि गणनाओं का पहला भाग होता है, जिसके परिणाम का थोड़ी देर बाद उपयोग किया जाता है। मैं असेंबलर में एक "महान कल्पना" नहीं हूं, इसलिए मैं कोडरिनर प्लगइन का उपयोग करता हूं।

मैं दो केजेन विधि दिखाऊंगा: डेल्फी में इनलाइन असेंबलर कोड और पास्कल में पूरी तरह से अनुवादित कोड:

Copy Source | Copy HTML

1. प्रक्रिया GenClick ( डमी : सूचक; प्रेषक: PControl);
2. var NameBuffer, SerNum: स्ट्रिंग;
3. len, sn_tmp: पूर्णांक ;
4. शुरू करना
5. अगर Nm.Text <> '' शुरू हो तो
6. NameBuffer: = Nm.Text;
7. len: = लंबाई (Nm.Text);
8. एएसएम
9. PUSHAD
10. Mov ECX, NameBuffer
11. Mov EBX, लेन
12. @ TurboLau_0053F42E:
13. XOR EAX, EAX
14. MOV AL, BYTE PTR DS: [ECX]
15. SHL EAX, 8
16. XOR EDX, EAX
17. MOV EAX, 8
18. @ TurboLau_0053F43C:
19. टेस्ट डीएच, 080h
20. JE @ TurboLau_0053F44B
21. ADD EDX, EDX
22. XOR EDX, 01021h
23. JMP @ TurboLau_0053F44D
24. @ TurboLau_0053F44B:
25. ADD EDX, EDX
26. @ TurboLau_0053F44D:
27. दिसंबर अहंकार
28. JNZ @ TurboLau_0053F43C
29. INC ECX
30. दिसंबर की बात
31. JNZ @ TurboLau_0053F42E
32. MOV EAX, EDX
33. और EAX, 0FFFFh
34. mov sn_tmp, EAX
35. POPAD
36. अंत;
37. Edit.text: = Int2Hex ((sn_tmp), 4);
38. अंत
39. अन्यथा
40. Edit.Text: = 'अपना नाम दर्ज करें' ;
41. अंत ;

मैं अलग से प्रक्रिया क्यों लाया? यह मेरे लिए आसान था, मैं तुरंत रिप्ड कोड का सही संचालन देख सकता हूं। उदाहरण के लिए, नाम DimitarSerg sn_tmp = E330 के लिए

खैर, फिर, फिर से एक तकनीकी मामला: हम कोडरिपर प्लगइन का उपयोग करते हैं, पते से शुरू होता है 5406BC से 540752 (हम देखते हैं कि यह एक बड़ी पीढ़ी चक्र है)। मैं कुछ कॉल पर ध्यान देना चाहता हूं। कोडराइपर लिखते हैं "<? जम्प / कॉल एड्रेस नॉट रिज़ॉल्व्ड", उनमें से अधिकांश अनावश्यक हैं और इन्हें हटाया जा सकता है, लेकिन यहाँ
005406EE | E8 F52DECFF || CALL TurboLau.004034E8
इस कॉल को कभी भी हटाया नहीं जा सकता है, क्योंकि अंदर से:

Copy Source | Copy HTML

1. @ TurboLau_004034E8:
2. PUSH EBX
3. XOR EBX, EBX
4. IMUL EDX, DWORD PTR DS: [EBX + 0542008h], 08088405h
5. INC EDX
6. MOV DWORD PTR DS: [EBX + 0542008h], EDX
7. MUL EDX
8. MOV EAX, EDX
9. पॉप ईबीएक्स
10. RETN

यह, जैसा कि मुझे बताया गया था (उस समय पता नहीं था), कि यह मानक रैंडम है, और DWORD PTR DS: [EBX + 0542008h] (मेरे पास sn_tmp भी है) - यह रैंडमसेड है।

और रिप्ड कोड में, अब इसे एक अलग प्रक्रिया के रूप में नहीं कहते हैं, लेकिन बस इसे अपने कॉल के स्थान पर कॉपी करें, यहाँ एक खंड है:

Copy Source | Copy HTML

1. @ TurboLau_005406E9:
2. MOV EAX, 021h
3. // -> कॉल @ TurboLau_004034E8; <= कूदो / कॉल पता हल नहीं
4. // कॉल सामग्री
5. PUSH EBX
6. XOR EBX, EBX
7. IMUL EDX, sn_tmp, 08088405h
8. INC EDX
9. मूव sn_tmp, edx
10. MUL EDX
11. MOV EAX, EDX
12. पॉप ईबीएक्स
13. MOV EBX, EAX
14. INC EBX
15. MOV AL, BYTE PTR SS: [EBP-0Dh]
16. XOR AL, 0FFh
17. और EAX, 0FFh
18. जोड़ें EBX, EAX
19. Dec esi
20. JNZ @ TurboLau_005406E9

मैं लाइन पर भी ध्यान देना चाहता हूं
00540715 | BA 1C085400 | MOV EDX, TurboLau.0054081C; ASCII "GF2DSA38HJKL7M4NZXCV5BY9UPT6R1EWQ40I1CP7Z7GOEPQLZ"

इसे "कुंजी" कहा जा सकता है, क्योंकि पंजीकरण कोड सीधे इस पर निर्भर करता है। पता 0054081C पर एक स्ट्रिंग के लिए एक सूचक edx रजिस्टर को लिखा गया है।
Asmov आवेषण और शुद्ध पास्कल के साथ डेल्फी कीजेन के लिए पूर्ण स्रोत कोड संलग्न हैं, वहाँ कुछ भी जटिल नहीं है।

खैर, और मैंने क्या कहानी शुरू की: इन सभी पीढ़ियों के बाद, हम रोकते नहीं हैं, लेकिन कुछ नामों / उपनामों को देखते हैं, इत्यादि पर जोर देते हैं।

स्वाभाविक रूप से, यह एक आदिम ब्लैक लिस्ट है:

Copy Source | Copy HTML

1. @ TurboLau_005407C4:
2. MOV EAX, DWORD PTR SS: [EBP-4]; ब्लैकलिस्ट सत्यापन साइकिल
3. MOV EDX, DWORD PTR DS: [ESI]
4. CALL @ TurboLau_00405030
5. JNZ @ TurboLau_005407D4
6. XOR EBX, EBX
7. JMP @ TurboLau_005407DA
8. @ TurboLau_005407D4:
9. एडीडी ईएसआई, 4
10. दिसंबर edi
11. JNZ @ TurboLau_005407C4

दिलचस्प उपनाम जैसे नाइट्रोजन / TSRh TeaM, REVENGE Crew, FGHTiNG FOR FUN, TEAM VIRILITY ... आदि। मुझे लगता है कि आपको संकेत मिलता है।
कुल 44 नाम। कोई समस्या नहीं कॉपी-पेस्ट मैन्युअल रूप से, प्रकार की स्ट्रिंग सरणी में हथौड़ा
ब्लैक लिस्ट: स्ट्रिंग = (...) की सरणी [0..43], और जनरेट करते समय, देखें कि क्या आप जो नाम चाहते हैं वह ब्लैकलिस्ट में है। (मैं भी फ़ाइल BlackList.txt संलग्न)।

"पूर्ण प्रसन्नता" के लिए हम कोड को asm आवेषण के साथ पास्कल में अनुवाद करते हैं:

Copy Source | Copy HTML

1. // ...
2. वर
3. काली सूची: स्ट्रिंग [ 0 .. 43 ] स्ट्रिंग का = ( 'जिक्रोन / पीसी 97', 'फ्रीवेयर', 'पंजीकृत उपयोगकर्ता', <br/> 'NuZ''c97', 'पंजीकृत', 'kOUGER! [CB4]] ',' कॉस्मो क्रैमर 1997 ',' कॉस्मो क्रैमर MJ13 ', <br/> ' MJ13 फॉरएवर ',' cH / फ़रोज़ेन क्रू ',' एवरीबॉडी ',' iCEMAN [uFF] ',' पेन ',' हेनरी पैन ' <br/> 'iTR [CORE]', 'mpbaer', 'CORE / JES', 'चेन बोरचांग', 'n03l', 'ODIN 97', 'lgb / cORE''97', <br/> 'MCC ',' ब्लास्टसॉफ्ट ',' कोर / ड्रिहुई ',' विज़ियन / कोर ',' टीएएमआई वीरिल्ली ',' नम्बुलु ',' नुज़पेक 97 ', <br/> ' वार्मज़ेल ',' फ़रोज़न क्रू ',' टीएएम विजिलिटी ',' x3u ',' Reg Name ',' FiGHTiNG FOR FUN ',' RaSCaL [TMG] ', <br/> ' Nitros ^ 21 ',' TEAM TSRH ',' ttdown.com ',' Nitrogen / TSRh TeaM ',' फ्री प्रोग्राम ',' रिवेंज क्रू ', <br/> ' व्लादिमीर काशो ',' एलेक्सेज मेलनिकोव ',' सेठ डब्ल्यू। हिंसशॉ ' );
4. // ...
5. प्रक्रिया उत्पन्न;
6. वार
7. NameBuffer, SerNum: स्ट्रिंग ;
8. EDX, EAX, len, i , a , b , tmp1: पूर्णांक ;
9. पाठ का नाम: PChar ;
10. शुरू करना
11. len: = GetWindowTextLengthA ( TxtNameHwnd );
12. अगर लेन> 1 तो
13. शुरू करना
14. {नाम इनपुट से पाठ प्राप्त करें}
15. गेटमेम ( टेक्स्टनाम, लेन + 1 );
16. GetWindowTextA ( TxtNameHwnd, PAnsiChar (Textname ), len + 1 );
17. {सीरियल बनाएं}
18. KeyStr: = 'GF2DSA38HJL7M4NZXCV5BY9UPT6R1EWQ40I1CP' ;
19. NameBuffer: = स्ट्रिंग ( टेक्स्टनाम );
20. सर्नम्: = '' ;
21. अनियमित करें;
22. EDX: = 0 ;
23. मैं के लिए : = 1 लेन करने के लिए
24. शुरू करना
25. EDX: = EDX xor ( ord (NameBuffer [i] ) श्ल 8 );
26. EAX: = 8 ;
27. जबकि EAX <> 0 करते हैं
28. शुरू;
29. if ( EDX shr 8 और $ 0FF )> = $ 80
30. तो
31. EDX: = EDX shl 1 xor $ 1021
32. अन्यथा
33. EDX: = EDX shl 1 ;
34. dec ( EAX );
35. अंत;
36. अंत;
37. RandSeed: = EDX और $ 0FFFF;
38. i : = 1 ;
39. जबकि मैं <> $ 13 करते हैं
40. शुरू करना
41. a : = 0 ;
42. बी : = $ 13 - मैं ;
43. अगर बी > 0 तो
44. शुरू करना
45. जबकि b > 0 करते हैं
46. शुरू करना
47. a : = random ( 33 );
48. inc ( ए );
49. अगर मैं > तो
50. tmp1: = ord ( NameBuffer [i mod len] )
51. अन्यथा
52. tmp1: = ord ( NameBuffer [i] );
53. tmp1: = tmp1 xor $ 0FF और $ 0FF;
54. a : = a + tmp1;
55. dec ( b );
56. अंत;
57. अंत;
58. जबकि $ 21 करते हैं
59. शुरू करना
60. a : = a - $ 21 ;
61. अंत;
62. SerNum: = SerNum + KeyStr [ a ];
63. inc ( i );
64. अंत;
65. सम्मिलित करें ( '-', SerNum, 7 );
66. सम्मिलित करें ( '-', SerNum, 14 );
67. I के लिए : = 0 से 43 करते हैं
68. शुरू करना
69. अगर NameBuffer = ब्लैक लिस्ट [ i ] तब
70. शुरू करना
71. सर्नम: = L BLACKLISTED NAME ’ ;
72. तोड़;
73. अंत में और;
74. अंत;
75. {परिणाम प्रदर्शित करें }
76. SetWindowTextA ( TxtSerialHwnd, PChar (SerNum ));
77. फ्रीम ( टेक्स्टनाम, लेन + 1 );
78. अंत
79. अन्यथा
80. { प्रदर्शन त्रुटि}
81. SetWindowText ( TxtSerialHwnd, 'नॉट इनफ कैरेक्टर्स ..' );
82. अंत;

नतीजतन, मुझे इस तरह के कीजन मिले:


आकार 36.5 Kb (अनपैक्ड)। KOL (मुख्य ऑब्जेक्ट्स लाइब्रेरी) - डेल्फी के लिए एक पुस्तकालय का उपयोग करके इस तरह के एक छोटे कीजेन आकार को प्राप्त किया जाता है। आप इसे WinApi का उपयोग करके भी कर सकते हैं, अपने लोगो को चिपकाएँ, एक xm / v22 ट्रैक जोड़ें (यह मैं जनता के लिए है। keygen और किया है), लेकिन मेरी सलाह है - यदि आप डेल्फी में 400g या अधिक लिखेंगे तो VCL का उपयोग न करें ... यह keygen के लिए आकार नहीं है!
कौन शुद्ध असेम्बलर को अधिक पसंद करता है - हाथ में मास्सम (फेस, तस्मा)।

यहीं से मेरी कहानी समाप्त होती है, मुझे उम्मीद है कि किसी को इस लेख से कुछ मिलेगा।