🌵 🗑️ 👨🏿‍🤝‍👨🏼 क्विक पासवर्ड रिकवरी प्रो 1.7 के लिए सुरक्षा अध्ययन 🙉 🚋 🍣

सभी को नमस्कार। आज मैं क्विक पासवर्ड रिकवरी प्रो 1.7.1 के उदाहरण का उपयोग करना चाहता हूं ताकि एक सुरक्षा अध्ययन दिखाया जा सके जो कुछ दिलचस्प ट्रिक्स और एक हैश फ़ंक्शन का उपयोग करता है।

उद्देश्य: क्विक पासवर्ड रिकवरी प्रो 1.7.1 (www.passdecrypt.ru)
संरक्षण: HWID + MD5
टूल्स: डाई 0.65 + KANAL 2.92 प्लगइन, OllyDbg 1.10 (बाद में इसे Olly कहा जाता है) + mapimp प्लगइन (tport.org पर पाया जा सकता है), IDR (इंटरएक्टिव डेल्फी रिकंस्ट्रक्टर), कीजेनर असिस्टेंट 1.7, बोरलैंड डेल्फी 7 (लेखन कीजन के लिए)।
"रोगी परीक्षा" शुरू करते हैं:

कार्यक्रम बोरलैंड डेल्फी [क्रिया: 2006] में लिखा गया है ऑब्जेक्ट पास्कल, इसलिए ओली के लिए एक मानचित्र फ़ाइल का विश्लेषण करने और बनाने के लिए इसे तुरंत आईडीआर में लोड करें।
कनाल प्लगइन को कई क्रिप्टो हस्ताक्षर मिलते हैं:

हम कार्यक्रम शुरू करते हैं, हम एक संदेश के साथ एक खिड़की से बधाई देते हैं कि यह एक अपंजीकृत संस्करण है और कुछ फ़ंक्शन उपलब्ध नहीं हैं। हम इसे स्वयं सत्यापित कर सकते हैं:

"रजिस्टर" बटन पर क्लिक करें:

पंजीकरण के लिए, हमें एक नाम और क्रम संख्या की आवश्यकता है, जो संभवतः सिस्टम पहचानकर्ता (इसके बाद HWID) पर निर्भर करता है।

उदाहरण के लिए, कोई भी पंजीकरण डेटा दर्ज करें:
नाम: ds@mail.ru
धारावाहिक: abcdefghigklmnop

हम आईडीआर कोड को देखते हैं जिसे "रजिस्टर" बटन पर क्लिक करके निष्पादित किया जाता है, लेकिन हम देखते हैं कि रजिस्ट्री में प्रविष्टियों की एक जोड़ी बनाने के अलावा, कुछ और नहीं होता है:

कार्यक्रम हमें इसे फिर से शुरू करने की पेशकश करता है, जिसका अर्थ है कि कार्यक्रम की शुरुआत में कहीं न कहीं चेक किया जाता है। मान लीजिए कि सत्यापन तब किया जाता है जब मुख्य फॉर्म बनाया जाता है (ऑनक्रिएट इवेंट)। हम IDR में कॉल लोकेशन की तलाश करते हैं और Olly में फ़ंक्शन की शुरुआत में ब्रेकपॉइंट लगाते हैं:

हम डिबगर से कार्यक्रम शुरू करते हैं और यहां रुकते हैं:

Copy Source | Copy HTML 0046EC94 > . 55 PUSH EBP ; Unit1.TForm1.FormCreate 

हमें पहली दिलचस्प कॉल मिलती है:

यहां पहुंचने तक F7 और ट्रेस दर्ज करें:

मैं थोड़ा आगे चला जाऊंगा और कहूंगा कि यह यहां है कि एचडब्ल्यूआईडी पीढ़ी और धारावाहिक के पहले भाग का अलगाव छुपा हुआ है।
फिर से, F7 पर जाएं और निर्धारित करें कि पता 46537F पर एक HWID उत्पन्न होता है, जो डीबगर के तहत फ़ंक्शन के माध्यम से जाकर अनुमान लगाना आसान है:

Copy Source | Copy HTML 0046537F |. E8 3CFCFFFF CALL <QuickPas._Unit32.sub_00464FC0> ; << Get Hwid 

लेकिन फिर हम 00464FC0 पर फ़ंक्शन की सावधानीपूर्वक जांच करते हैं और वहां कोड पाते हैं:

Copy Source | Copy HTML 00465072 | > /8B45 FC /MOV EAX,DWORD PTR SS:[EBP-4] 00465075 |. |0FB64418 FF |MOVZX EAX,BYTE PTR DS:[EAX+EBX-1] 0046507A |. |8BD3 |MOV EDX,EBX 0046507C |. |03D2 |ADD EDX,EDX 0046507E |. |03C2 |ADD EAX,EDX 00465080 |. |8D55 DC |LEA EDX,DWORD PTR SS:[EBP-24] 00465083 |. |E8 3441FAFF |CALL < QuickPas.SysUtils.IntToStr > 00465088 |. |8B55 DC |MOV EDX,DWORD PTR SS:[EBP-24] 0046508B |. |8D45 F4 |LEA EAX,DWORD PTR SS:[EBP-C] 0046508E |. |E8 6D01FAFF |CALL < QuickPas.system. @LStrCat > 00465093 |. |43 |INC EBX 00465094 |. |83FB 04 |CMP EBX,4 00465097 |.^\75 D9 \JNZ SHORT QuickPas.00465072 00465099 |. 8D45 F8 LEA EAX,DWORD PTR SS:[EBP-8] 0046509C |. E8 93FEF9FF CALL < QuickPas.system. @LStrClr > 004650A1 |. BB 01000000 MOV EBX,1 004650A6 | > 8D45 D8 /LEA EAX,DWORD PTR SS:[EBP-28] 004650A9 |. 8B55 F4 |MOV EDX,DWORD PTR SS:[EBP-C] 004650AC |. 0FB6541A FF |MOVZX EDX,BYTE PTR DS:[EDX+EBX-1] 004650B1 |. E8 6600FAFF |CALL < QuickPas.system. @LStrFromChar > 004650B6 |. 8B55 D8 |MOV EDX,DWORD PTR SS:[EBP-28] 004650B9 |. 8D45 F8 |LEA EAX,DWORD PTR SS:[EBP-8] 004650BC |. E8 3F01FAFF |CALL < QuickPas.system. @LStrCat > 004650C1 |. 43 |INC EBX 004650C2 |. 83FB 06 |CMP EBX,6 004650C5 |.^ 75 DF \JNZ SHORT QuickPas.004650A6

यहां, पहले 3 वर्णों के कोड लिए गए हैं, + 2 से लूप काउंटर के मूल्य को गुणा करके एक स्ट्रिंग में विभाजित किया गया है, और उसके बाद केवल पहले 5 को लिया गया है (SystemBiosDate पैरामीटर, जिसमें से हैश माना जाता है, रजिस्ट्री में पाया जा सकता है, और अधिक विशेष रूप से यहां: HKEY_LOCAL_MACHINE \ HARDWARE \ DESCRIPT) \ प्रणाली)

पास्कल में, इसे इस तरह लिखा जा सकता है:

Copy Source | Copy HTML md5_sbd:=md5( SystemBiosDate) for i:=1 to 3 do begin result := result + IntToStr(ord(md5_sbd[i]) + i*2;); end ; 

HWID पुनर्प्राप्ति फ़ंक्शन से बाहर निकलने के बाद, आगे कदम:

Copy Source | Copy HTML 00465389 |> /8D45 F8 /LEA EAX,DWORD PTR SS:[EBP-8] 0046538C |. |E8 BF00FAFF | CALL <QuickPas.system.@UniqueStringA> 00465391 |. |BA 06000000 |MOV EDX,6 00465396 |. |2BD3 |SUB EDX,EBX 00465398 |. |8B4D FC |MOV ECX,DWORD PTR SS:[EBP-4] 0046539B |. |0FB64C19 FF |MOVZX ECX,BYTE PTR DS:[ECX+EBX-1] 004653A0 |. |884C10 FF |MOV BYTE PTR DS:[EAX+EDX-1],CL 004653A4 |. |43 |INC EBX 004653A5 |. |83FB 06 |CMP EBX,6 004653A8 |.^\75 DF \JNZ SHORT QuickPas.00465389 004653AA |. BB 01000000 MOV EBX,1 004653AF |> 8D45 F0 /LEA EAX,DWORD PTR SS:[EBP-10] 004653B2 |. 8B55 F8 |MOV EDX,DWORD PTR SS:[EBP-8] 004653B5 |. 0FB6541A FF |MOVZX EDX,BYTE PTR DS:[EDX+EBX-1] 004653BA |. E8 5DFDF9FF | CALL <QuickPas.system.@LStrFromChar> 004653BF |. 8B45 F0 |MOV EAX,DWORD PTR SS:[EBP-10] 004653C2 |. E8 313FFAFF | CALL <QuickPas.SysUtils.StrToInt> 004653C7 |. 8BF0 |MOV ESI,EAX 004653C9 |. 33F3 |XOR ESI,EBX 004653CB |. 8D55 F4 |LEA EDX,DWORD PTR SS:[EBP-C] 004653CE |. 8BC6 |MOV EAX,ESI 004653D0 |. E8 E73DFAFF | CALL <QuickPas.SysUtils.IntToStr> 004653D5 |. 8D45 F8 |LEA EAX,DWORD PTR SS:[EBP-8] 004653D8 |. E8 7300FAFF | CALL <QuickPas.system.@UniqueStringA> 004653DD |. 8B55 F4 |MOV EDX,DWORD PTR SS:[EBP-C] 004653E0 |. 0FB612 |MOVZX EDX,BYTE PTR DS:[EDX] 004653E3 |. 885418 FF |MOV BYTE PTR DS:[EAX+EBX-1],DL 004653E7 |. 43 |INC EBX 004653E8 |. 83FB 06 |CMP EBX,6 004653EB |.^ 75 C2 \JNZ SHORT QuickPas.004653AF

यहाँ कुछ रूपांतरण हैं, आदि। फिर, मैं इस कोड का प्रतिनिधित्व करता हूं जिसका मैंने केवल पास्कल में अनुवाद किया है:

Copy Source | Copy HTML part_of_serial:=ReverseString(hwid); tmp:= '' ; for i:= 1 to 5 do begin tmp:=tmp + copy(IntToStr(StrToInt(part_of_serial[i]) xor i),1,1); end ; part_of_serial:=copy(tmp,1,5); 

मेरे मामले में, परिणाम 41413 है
आगे बढ़ें, देखें ...

यह जानते हुए कि कार्यक्रम हैश फ़ंक्शन md5 का उपयोग करता है, हम अपनी धारणा की जांच करते हैं:
md5 (41413) = FFA54840A3C240E0725C16C7FA48281C

यह स्टैक विंडो में स्पष्ट रूप से दिखाई देता है:

हम फ़ंक्शन से बाहर निकलते हैं, ट्रेस करना जारी रखते हैं और देखते हैं कि तब हम प्रवेश किए गए धारावाहिक के पहले 5 पात्रों से md5 हैश लेते हैं और इसकी तुलना पहले प्राप्त एक (आदिम, लेकिन कम से कम किसी तरह) से करते हैं।
md5 (abcde) = AB56B4D92B40713ACC5AF89985D4B786

अब हम जानते हैं कि सही धारावाहिक के पहले अक्षर (मेरे मामले में) 41413 होना चाहिए।
हम एक नए धारावाहिक के साथ एक कार्यक्रम को पंजीकृत करने की कोशिश कर रहे हैं, जो उपरोक्त बातों को ध्यान में रखते हुए:
41413abcdefghijklmnop, और ईमेल पहले जैसा ही है (ds@mail.ru)।
अब हम पहले से ही सत्यापन से गुजर रहे हैं:

Copy Source | Copy HTML 00465563 |. E8 DCFDF9FF CALL <QuickPas.system.@LStrCmp> 

कार्यक्रम बिना किसी चेतावनी के शुरू होता है और अबाउट विंडो में लिखता है कि सब कुछ ठीक है, लेकिन जब हम प्रोग्राम के फंक्शन बटन पर क्लिक करते हैं, तो हमें अनरजिस्टर्ड संस्करण दिखाई देता है।

ठीक है, जारी रखें जहां से हमने परीक्षा उत्तीर्ण की है। हमने ब्रेकपॉइंट को 00465563 पर सेट किया और आगे ट्रेस किया।
हम कोड के दो बहुत सरल टुकड़े देखते हैं:

Copy Source | Copy HTML 00465595 |. BB 01000000 MOV EBX,1 0046559A | > /8B45 EC /MOV EAX,DWORD PTR SS:[EBP-14] 0046559D |. |0FB64418 FF |MOVZX EAX,BYTE PTR DS:[EAX+EBX-1] 004655A2 |. |0145 E4 |ADD DWORD PTR SS:[EBP-1C],EAX 004655A5 |. |43 |INC EBX 004655A6 |. |83FB 06 |CMP EBX,6 004655A9 |.^\75 EF \JNZ SHORT QuickPas.0046559A 

Copy Source | Copy HTML 004655BC |. BB 01000000 MOV EBX,1 004655C1 | > 8B55 FC /MOV EDX,DWORD PTR SS:[EBP-4] 004655C4 |. 0FB6541A FF |MOVZX EDX,BYTE PTR DS:[EDX+EBX-1] 004655C9 |. 0155 E8 |ADD DWORD PTR SS:[EBP-18],EDX 004655CC |. 43 |INC EBX 004655CD |. 48 |DEC EAX 004655CE |.^ 75 F1 \JNZ SHORT QuickPas.004655C1 

उनमें कुछ गणनाएं शामिल हैं (पहले दर्ज किए गए धारावाहिक से 6 से 10 वें अक्षर के लिए), और फिर दर्ज किए गए ई-मेल से।

इस सब के परिणामस्वरूप, संख्या 1353 और fghijklmnop की तुलना की जाती है, यह तर्कसंगत है कि यह सीरियल नंबर का तीसरा भाग हो सकता है।
एक नया सीरियल नंबर आज़माना: 41413abcde1353
सब कुछ ठीक लग रहा है, लेकिन वहाँ एक है "लेकिन"!
जब हम फ़ंक्शन कुंजियों को पुनर्स्थापित करने के लिए क्लिक करते हैं, तो हमें अजीब अक्षर मिलते हैं, जैसे:

यह पता चलता है कि परिणामों को आउटपुट करने से पहले कुछ गलत हो जाता है। आइए क्लिक करके IDR में घटना को देखें, उदाहरण के लिए, द बैट पासवर्ड रीसेट करने के लिए और प्रक्रिया की शुरुआत में ब्रेकपॉइंट सेट करें।

फिर हम 465250 पते पर फ़ंक्शन में जाते हैं और स्टैक विंडो को ध्यान से देखते हैं, और साथ ही साथ F8 दबाते हैं
यह नोटिस करना मुश्किल नहीं है कि धारावाहिक के पहले 5 अक्षर और एचडब्ल्यूआईडी एक साथ चिपके हुए हैं, और फिर प्राप्त स्ट्रिंग से md5 हैश माना जाता है।

md5 (4141369735) = 3354B017EB74FB4DC20A1B484911431

और फिर प्राप्त हैश से एक निश्चित राशि पर विचार किया जाता है:

Copy Source | Copy HTML for i:=4 to 7 do begin tmp := tmp + IntToStr(ord(part2[i])); end ; 

और पहले 5 अक्षर कॉपी किए गए हैं:

Copy Source | Copy HTML some := copy(tmp,1,5); 

गणनाओं के परिणामस्वरूप, हमें 52664 मिलते हैं (हम इस मूल्य पर लौट आएंगे)।

आगे दिलचस्प कॉल:
CALL 00467A44
यहां हमारे लिए कुछ भी दिलचस्प नहीं है (यह प्रोग्राम का मुख्य कार्य है जो पासवर्ड को पुनर्प्राप्त करने की कोशिश करता है)।
हम आगे बढ़ते हैं और यहां देखते हैं:
00470919 |. E8 FA4DFFFF CALL <QuickPas._Unit32.sub_00465718>

बहुत दिलचस्प ब्लॉक:

Copy Source | Copy HTML 0046577F |. BB 01000000 MOV EBX,1 00465784 | > 8D45 FC /LEA EAX,DWORD PTR SS:[EBP-4] 00465787 |. E8 C4FCF9FF |CALL < QuickPas.system. @UniqueStringA > 0046578C |. 8D4418 FF |LEA EAX,DWORD PTR DS:[EAX+EBX-1] 00465790 |. 50 |PUSH EAX 00465791 |. 8BC3 |MOV EAX,EBX 00465793 |. 99 |CDQ 00465794 |. F7FF |IDIV EDI 00465796 |. 8B45 F8 |MOV EAX,DWORD PTR SS:[EBP-8] 00465799 |. 0FB60410 |MOVZX EAX,BYTE PTR DS:[EAX+EDX] 0046579D |. 0FBE55 F3 |MOVSX EDX,BYTE PTR SS:[EBP-D] 004657A1 |. F7EA |IMUL EDX 004657A3 |. 8B55 FC |MOV EDX,DWORD PTR SS:[EBP-4] 004657A6 |. 0FB6541A FF |MOVZX EDX,BYTE PTR DS:[EDX+EBX-1] 004657AB |. 03C2 |ADD EAX,EDX 004657AD |. 5A |POP EDX 004657AE |. 8802 |MOV BYTE PTR DS:[EDX],AL 004657B0 |. 43 |INC EBX 004657B1 |. 4E |DEC ESI 004657B2 |.^ 75 D0 \JNZ SHORT QuickPas.00465784

डंप विंडो को देखते हुए, हम समझते हैं कि आदिम एन्क्रिप्शन आउटपुट के सामने है (हालांकि यह बहुत जोर से है और पूर्ण एन्क्रिप्शन तक नहीं पहुंचता है, लेकिन आम में कुछ है - यह एक संदेश है और जिस एन्क्रिप्शन के साथ कुंजी चल रही है, इसलिए मैं इसे कॉल करना जारी रखूंगा) ब्लॉक एन्क्रिप्शन)।

आप इस कोड को और अधिक विस्तार से जांच सकते हैं, लेकिन अंतिम लक्ष्य (केजेन लिखने) के लिए हमें इसकी आवश्यकता नहीं है।

आगे बढ़ो और देखो:

Copy Source | Copy HTML 0047093B |. E8 144DFFFF CALL < QuickPas._Unit32.sub_00465654 > 

इस फ़ंक्शन के लिए जो पैरामीटर पारित किया गया है, वह हमारे लिए बहुत परिचित है - ये 6 वीं से 10 वीं तक के सीरियल के पात्र हैं।
अंतर्ज्ञान मुझे असफल नहीं हुआ, हम इस तरह का एक कोड देखते हैं:

Copy Source | Copy HTML 004656AC |. BB 01000000 MOV EBX,1 004656B1 | > 8D45 FC /LEA EAX,DWORD PTR SS:[EBP-4] 004656B4 |. E8 97FDF9FF |CALL < QuickPas.system. @UniqueStringA > 004656B9 |. 8D4418 FF |LEA EAX,DWORD PTR DS:[EAX+EBX-1] 004656BD |. 50 |PUSH EAX 004656BE |. 8BC3 |MOV EAX,EBX 004656C0 |. 99 |CDQ 004656C1 |. F7FF |IDIV EDI 004656C3 |. 8B45 F8 |MOV EAX,DWORD PTR SS:[EBP-8] 004656C6 |. 0FB60410 |MOVZX EAX,BYTE PTR DS:[EAX+EDX] 004656CA |. 0FBE55 F3 |MOVSX EDX,BYTE PTR SS:[EBP-D] 004656CE |. F7EA |IMUL EDX 004656D0 |. 8B55 FC |MOV EDX,DWORD PTR SS:[EBP-4] 004656D3 |. 0FB6541A FF |MOVZX EDX,BYTE PTR DS:[EDX+EBX-1] 004656D8 |. 03C2 |ADD EAX,EDX 004656DA |. 5A |POP EDX 004656DB |. 8802 |MOV BYTE PTR DS:[EDX],AL 004656DD |. 43 |INC EBX 004656DE |. 4E |DEC ESI 004656DF |.^ 75 D0 \JNZ SHORT QuickPas.004656B1

समान कोड, लेकिन इस स्थिति में यह संदेश को "आउटपुट" से ठीक पहले "डिक्रिप्ट" करता है।
यह स्पष्ट है कि सामान्य आउटपुट डेटा प्राप्त करने के लिए, आपको एन्क्रिप्टेड के समान कुंजी के साथ डिक्रिप्ट करना होगा।

true_key = 52664
our_key = abcde

संदेश = डिक्रिप्ट (क्रिप्ट (संदेश, true_key), our_key)
यह अनुमान लगाना आसान है कि संदेश = संदेश के लिए, true_key को हमारे_ समान के बराबर होना चाहिए।

सामान्य तौर पर, हमारे पास keygen के लिए सभी डेटा होते हैं, यह एक सामान्य प्रक्रिया में सब कुछ कम करने के लिए रहता है।
अलग-अलग कार्यों में कुछ गणनाओं के टूटने की सुविधा के लिए:

1. रजिस्ट्री से मान प्राप्त करने का कार्य:

Copy Source | Copy HTML function RegQueryStr(RootKey: HKEY; Key, Name: string ; Success: PBoolean = nil): string ; var Handle: HKEY; Res: LongInt; DataType, DataSize: DWORD; begin if Assigned(Success) then Success^ := False; Res := RegOpenKeyEx(RootKey, PChar(Key), 0 , KEY_QUERY_VALUE, Handle); if Res <> ERROR_SUCCESS then Exit; Res := RegQueryValueEx(Handle, PChar(Name), nil, @DataType, nil, @DataSize); if (Res <> ERROR_SUCCESS) or (DataType <> REG_SZ) then begin RegCloseKey(Handle); Exit; end; SetString(Result, nil, DataSize - 1 ); Res := RegQueryValueEx(Handle, PChar(Name), nil, @DataType, PByte(@Result[ 1 ]), @DataSize); if Assigned(Success) then Success^ := Res = ERROR_SUCCESS; RegCloseKey(Handle); end;

2. HWID गणना समारोह:

Copy Source | Copy HTML function GetHWID: string; var SystemBiosDate,md5_sbd:String; i: integer ; digest:pointer; dwSize:Cardinal; begin SystemBiosDate := RegQueryStr(HKEY_LOCAL_MACHINE, 'HARDWARE\DESCRIPTION\System' , 'SystemBiosDate' ); md5_sbd:=SystemBiosDate; dwSize:=length(md5_sbd); digest:= GetHash(@md5_sbd[1],dwSize,ALG_MD5); if digest <> nil then try md5_sbd:=BinToHexStr(digest,dwSize); finally FreeMem(digest); end ; md5_sbd:=Uppercase(md5_sbd); result := '' ; for i:=1 to 3 do begin result := result + IntToStr(ord(md5_sbd[i]) + i*2); end ; result :=copy( Result ,1,5); End ;

3. रिवर्स (रिवर्स लाइन) प्राप्त करने का कार्य:

Copy Source | Copy HTML function ReverseString( const s: string ): string ; var i, len: Integer; begin len := Length(s); SetLength(Result, len); for i := len downto 1 do begin Result[len - i + 1 ] := s[i]; end; end; 

4. यह जाँचने के लिए कि क्या स्ट्रिंग एक संख्या है (उपयोगकर्ता इनपुट की शुद्धता के लिए):

Copy Source | Copy HTML function IsStrANumber( const S: string ): Boolean; var P: PChar; begin P := PChar(S); Result := False; while P^ <> # 0 do begin if not (P^ in [ '0' .. '9' ]) then Exit; Inc(P); end; Result := True; end; 

बुनियादी पीढ़ी की प्रक्रिया:

Copy Source | Copy HTML procedure generate; var Serial,NameBuf: String ; len,len1: integer ; Textname,HWID: PChar ; hw: String ; i ,sum_name,sum_part2: integer ; part1,tmp,part2,part3: string ; digest: pointer ; dw Size : Cardinal ; begin len := GetWindowTextLengthA( TxtNameHwnd ); len1 := GetWindowTextLengthA( txtHWID ); if len > 1 then begin { Get text from name input } GetMem( Textname, len ); GetWindowTextA( TxtNameHwnd,PAnsiChar(Textname ),len + 1 ); GetMem( HWID, len1 ); GetWindowTextA( TxtHWID,PAnsiChar(HWID ),len1 + 1 ); HW:=String( HWID ); if ( IsStrANumber(hw )) and ( length(hw )= 5 ) then begin { Generate Serial } NameBuf:=String( Textname ); hw:=string( HWID ); hw:=copy( hw,1,5 ); part1:=ReverseString( hw ); tmp:= '' ; for i := 1 to 5 do begin tmp:=tmp + copy( IntToStr(StrToInt(part1[i] ) xor i ), 1 , 1 ); end; part1:=copy( tmp,1,5 ); //--------------------- tmp:= '' ; part2 :=part1+hw; dw Size :=length( part2 ); digest:= GetHash( @part2[1],dwSize,ALG_MD5 ); if digest <> nil then try part2:=BinToHexStr( digest,dwSize ); finally FreeMem( digest ); end; part2 := UpperCase ( part2 ); for i := 4 to 7 do begin tmp := tmp + IntToStr( ord(part2[i] )); end; part2 := copy( tmp,1,5 );; //--------------------- sum_name:= 0 ; sum_part2:= 0 ; for i := 1 to length( NameBuf )- 1 do begin sum_name:=sum_name + ord( NameBuf[i] ); end; for i := 1 to length( part2 ) do begin sum_part2:=sum_part2 + ord( part2[i] ); end; part3:=IntToStr( sum_name+sum_part2 ); Serial:=part1 + part2 + part3; end else // if hwid not numeric or <> 5 Serial:= 'Invalid HWID' ; { Display The Results } SetWindowTextA( TxtSerialHwnd,PChar(Serial )); FreeMem ( HWID, len1 + 1 ); FreeMem ( Textname, len+1 ); end Else { Display Error } SetWindowText( TxtSerialHwnd,'Not Enough Characters..' ); end;

मुझे लगता है कि यहां सब कुछ बहुत स्पष्ट है, क्योंकि पहले सभी मुख्य बिंदुओं का विश्लेषण किया गया है।
कोड के इन वर्गों के कारण प्रश्न हो सकते हैं:

Copy Source | Copy HTML dwSize:=length(part2); digest:= GetHash(@part2[1],dwSize,ALG_MD5); if digest <> nil then try part2:=BinToHexStr(digest,dwSize); finally FreeMem(digest); end ; 

संक्षेप में, यह HashCryptoAPILib का उपयोग करके एक md5 हैश गणना है, जो बदले में मानक विंडोज टूल (CryptoApi) का उपयोग करता है। आप खुद केजेन को संकलित कर सकते हैं या इसे "डाउनलोड" अनुभाग में tport.org के लिए तैयार कर सकते हैं।

हम किसी भी नाम के लिए एक सीरियल बनाते हैं और उसका परीक्षण करते हैं। कार्यक्रम पंजीकृत है, यह सही ढंग से काम करता है, यह अपने कार्यों को करने की कोशिश करता है और संदेशों को सामान्य रूप में प्रदर्शित करता है। वह सब है।

मुझे उम्मीद है कि उपरोक्त सामग्री दिलचस्प थी और किसी को अपने लिए कुछ उपयोगी मिलेगा।

क्विक पासवर्ड रिकवरी प्रो 1.7 के लिए सुरक्षा अध्ययन

More articles: