Introduction:
Dans ce tutoriel nous allons voir du keygenning avec du MD5, on a déjà vu ça avec mon tutoriel sur le keygenning de MBAM, Cette application et un peu moins compliquée dans son algorithme
Les outils:
OllyDbg v2.01 (http://Ollydbg.de/)
Detect It Easy (https://github.com/horsicq/DIE-engine/releases)
MD5 C*h*e*c*k*s*u*m V*e*r*i*f*i*e*r v6.1 (http://www.flashplayerpro.com/MD5ChecksumVerifier.exe)
I: Démarrage
La musique habituelle: installez l'application, scanné la avec DiE, ça ne semble pas compressé, super.
Ouvrez l'application et essayons d'entrer dans un faux numéro de série pour voir sont comportement.
Et rien!
Pas de MessageBox, aucun changement de texte pour indiquer un mauvais serial, NADA.
D'accord... Chargeons le fichier dans olly.
II: Trouver la procédure d'enregistrement
Nous allons essayer de chercher une chaîne intéressante et voir avec un peu de bon sens si nous pouvons trouver quelque chose digne d'intérêt pour nous.
Dans la fenêtre du désassembleur: clic droit>Search for>All referenced strings
Ensuite, on défile et on regarde..
Nous rencontrons près de la fin quelques chaines de textes comme: "Username" "Info" "code"
Nous cliquons dessus pour voir à quoi ressemble la procédure courante.
Nous remontons la procédure à son début pour y mettre un point d'arrêt, en espérant que quelque chose se passe.
Maintenant, nous exécutons le programme avec F9 et nous allons entrer un serial bidon.
Et là... Le débogueur break après avoir appuyer sur le bouton de vérification, génial! Il n'y a plus qu'à tracer et voir ce qu'il se passe.
III: Comprendre la routine d'enregistrement
Au début, nous rencontrons une vérification pour voir si le nom d'utilisateur n'est pas vide.
S'il y a zéro caractère, alors nous prenons le saut pour quitter le segment.
Après cela, notre serial est récupéré, puis hacher en MD5.
Pour mon sérial bidon: 1337 = E48E13207341B6BFFB7FB1622282247B
Le pointeur pour le hash est ensuite transmis à EAX.
Une ligne après, un pointeur (en hard cette fois-ci) contenant un autre hachage est transmis à EDX. "DFF760119804534A899F55D494DF0ECF"
Nous entrons ensuite dans un CALL et après être sorti, nous avons une condition de saut.
À l'intérieur du CALL, notre serial hashé dans EAX est comparé à l'autre hachage contenu dans EDX.
Notre hash ne correspond pas, nous sommes donc éjectés.
Après avoir quitté l'appel de comparaison, nous prenons le saut conditionnel qui nous envoie à l'offset 004A5311.
Nous arrivons sur un code similaire, nous constatons un autre CALL qui appelle la même procédure de comparaison précédente.
Avec cette fois une petite différence, le serial n'est pas complètement haché: il prend juste les 7 premières lettres de notre serial bidon, hash ça en md5, puis compare le hash avec CAF5C8456865585C73C24EDFB7402802.
Si le résultat n'est pas bon, nous sommes éjectés du segment.
Nous avons donc deux choix:
Cracké DFF760119804534A899F55D494DF0ECF, qui semblerais être un «serial maitre» mais qui peut être n'importe quoi.
Cracké CAF5C8456865585C73C24EDFB7402802, qui fait parti de la routine, donc si on veut le keygenner on n’a pas vraiment le choix enfaite.
On sait par contre que c'est un mot de 7 caractères pour CAF5C8456865585C73C24EDFB7402802.
Eh bien, cela est considéré comme "dur", le cassage du hash pourrait prendre du temps, beaucoup de temps.
Vous pouvez toujours essayer de casser le hash si vous avez une plate-forme dédiée pour calculer des choses, personnellement j'utilise Hashcat qui peut faire du multithread sur mes GPU.
Habituellement, lorsque les crackers font face à ce genre de problème avec la crypto, nous remplaçons simplement les valeurs inconnues avec nos propres valeurs. (keygen+patch du coup)
Mais dans le cas présent, je n'aurais pas eu à utiliser mon rig, ni a faire cela.
J'ai cherché dans Google des exemples de serial pour des versions précédentes, et j'ai remarqué que la première partie du serial commençait toujours par "LdfMCV-"
Qui fait exactement 7 caractères avec le tiret, et le résultat du hachage MD5 pour ce mot est... Oui: CAF5C8456865585C73C24EDFB7402802
Parfait!
Nous pouvons maintenant aller de l'avant, reprendre l'exécution avec F9 et entrer un nouveau numéro de série bidon, mais cette fois avec les 7 premières bonnes lettres: LdfMCV-123456789
Ensuite, nous nous retrouvons ou nous étions, la comparaison est faite, nous prenons le saut conditionnel qui nous a fait éviter de quitter le segment, c'est bien!.
Nous continuons à tracer avec F8 et nous voyons que le code prend notre nom et le hache en MD5 à l'intérieur de l'appel 004A2BF0
Ensuite, il prend notre numéro de série bidon, et nous passons sur les instructions MOV ECX, 2 et MOV EDX, 8 Ceux ci seront ensuite utilisé pour l'appel ci-dessous.
L'appel prendra 2 caractères et commencera à saisir à la position 8 (juste après la partie du serial en hard) une fois terminée, le pointeur est écrit dans la pile.
Ensuite, le pointeur sur notre nom haché réapparaît (dans mon cas: Xylitol = 9F01C4DEFB31F597423AC2E0CAB0FA54)
Ensuite, le hachage est tronqué: vous pouvez voir MOV ECX, 2 et MOV EDX, 0D cette fois-ci.
Nous avons maintenant: F597423AC2E0CAB0FA54, et les 2 premiers caractères du hach "F5" sont saisis.
Une ligne après, nous avons POP EAX, qui restaure le pointeur sur "12", qui est mes deux premiers caractères de mon serial bidon qui ont été attrapés plus tôt.
Et nous nous retrouvons à nouveau dans un CALL de comparaison, la même procédure qu’avant.
"12" de mon serial bidon est comparé à "F5"
Ce n'est pas bon, alors après avoir quitté l'appel de comparaison, il quitte le segment.
Je sais maintenant que mon serial commence par "LdfMCV-F5"
Il n'y a plus qu'à reprendre l'exécution avec F9 et remettre à jour notre serial bidon avec les nouveaux éléments que l'on a appris.
Pour moi, ce sera quelque chose comme: LdfMCV-F5AAAAAAAAA
Nous passons correctement le saut et nous sommes maintenant proches de la fin, et comme vous pouvez le constater, le code est un peu similaire à ce que nous venons de voir avant.
Le hash de mon nom est pris et puis tronqué pour obtenir les 11 premiers caractères à partir de la position 16, le résultat est: 423AC2E0CAB
Après, nous rencontrons à nouveau la procédure d'appel de hachage MD5 qui va hashé en MD5: "423AC2E0CAB"
Le résultat est: FF514146D567BF8C0988AF0118E612AE
Le sérial bidon est ensuite tronqué pour obtenir les 3 premiers caractères à partir de la position 10 (après "LdfMCV-F5") et pousse le résultat dans la pile.
Une fois cela fait, il prend le nouveau hachage obtenu: FF514146D567BF8C0988AF0118E612AE
Et le tronque à nouveau pour obtenir 3 caractères à partir de la position 20 du hache, le résultat est "8AF"
"AAA" de mon serial bidon est alors comparé à "8AF"
Si ce n'est pas bon, nous quittons le segment, si c'est bon, nous sommes enfin enregistrés.
Donc, pour Xylitol, mon numéro de série valide est: LdfMCV-F58AF
Nous avons atteint la fin de l'algo, nous pouvons maintenant écrire un keygen.
IV: Faire un keygen
Tout ce que nous avons à faire est de construire des hashs MD5 et de faire un peu de troncatures.
Pour cela je vais utiliser le même "md5.asm" que j'avais utilisé pour mon keygen mbam, ce fichier s'utilise comme la cryptolib de drizz.
Cela évite juste d'importé toute la lib pour juste une fonction de md5.
kg.asm:
.486
.model flat, stdcall
option casemap :none ; case sensitive
include \masm32\include\windows.inc
include \masm32\include\kernel32.inc
include \masm32\include\user32.inc
include \masm32\macros\macros.asm
includelib \masm32\lib\kernel32.lib
includelib \masm32\lib\user32.lib
include md5.asm
comment /*
kg for MD5 Checksum Verifier v6.1
MD5ChecksumVerifier.exe - 98ee714c93300c70b54c71c6d32be29e
By Xyl, as usual
/
DlgProc PROTO :DWORD,:DWORD,:DWORD,:DWORD
.const
IDC_NAME equ 1001
IDC_SERIAL equ 1002
IDB_QUIT equ 1003
IDC_GROUPBOX equ 1004
IDC_DATE_STATIC equ 1005
MAXSiZE equ 256
.data
; Keygen details
szNameMD5 dd MAXSiZE dup (0)
szSerialTempMD5 dd MAXSiZE dup (0)
szHardPart db "LdfMCV-",0
; Dialog details
szTitle db "MD5 checksum verifier v6.1 *keygen*",0
szGroupBox db "nAME ^ sERIAL",0
szIDBExit db "eXiT",0
szEnterName db "Enter a name buddy!",0
szTooLong db "Name is too long",0
szDateStatic db "20/06/2021",0
.data?
hInstance dd ? ;dd can be written as dword
szBufName db 265 dup (?)
szName_len dd ?
szSerial_len dd ?
szSerialTemp1 db 100h dup(?)
szSerialTemp2 db 100h dup(?)
szSerial db 100h dup(?)
.code
start:
invoke GetModuleHandle,NULL
mov hInstance,eax
invoke DialogBoxParam,hInstance,101,0,ADDR DlgProc,0
invoke ExitProcess,eax
HexToChar Proc HexValue :DWORD,
CharValue :DWORD,
HexLength :DWORD
mov esi,[ebp+8]
mov edi,[ebp+0Ch]
mov ecx,[ebp+10h]
@HexToChar:
lodsb
mov ah, al
and ah, 0fh
shr al, 4
add al, '0'
add ah, '0'
.if al > '9'
add al, 'A'-'9'-1
.endif
.if ah > '9'
add ah, 'A'-'9'-1
.endif
stosw
loopd @HexToChar
Ret
HexToChar endp
DlgProc proc hWin :DWORD,
uMsg :DWORD,
wParam :DWORD,
lParam :DWORD
.if uMsg == WM_INITDIALOG
; Set the dialog controls texts. Done here in the code instead of resource
; file to reduce the required bytes (strings in the rc file are UNICODE not ANSI)
invoke SetWindowText,hWin,ADDR szTitle ; Set the window title text
invoke SetDlgItemText,hWin,IDC_GROUPBOX,ADDR szGroupBox
invoke SetDlgItemText,hWin,IDB_QUIT,ADDR szIDBExit
invoke SetDlgItemText,hWin,IDC_DATE_STATIC,ADDR szDateStatic
.elseif uMsg == WM_COMMAND
mov eax,wParam
mov edx,eax
shr edx,16
and eax,0FFFFh
.if edx == EN_CHANGE
.if eax == IDC_NAME
invoke GetDlgItemText,hWin,IDC_NAME,Addr szBufName,MAXSiZE
.if eax == 0
invoke SetDlgItemText,hWin,IDC_SERIAL,addr szEnterName
.elseif eax > 60
invoke SetDlgItemText,hWin,IDC_SERIAL,addr szTooLong
.elseif
invoke lstrlen,addr szBufName
mov szName_len,eax
;Compute the MD5 hash for the entered name
invoke MD5Init
invoke MD5Update,addr szBufName,szName_len
invoke MD5Final
;hex to chars the MD5
invoke HexToChar,addr MD5Digest,addr szNameMD5,16
;Get 2 chars from the MD5 starting at position 12
invoke lstrcpyn,addr szSerialTemp1,addr szNameMD5+12,3
;Add the hard part to the serial + the 2 chars grabbed.
invoke lstrcat,addr szSerial,addr szHardPart
invoke lstrcat,addr szSerial,addr szSerialTemp1
;Get 11 chars from the MD5 starting at position 16
invoke lstrcpyn,addr szSerialTemp2,addr szNameMD5+16,12
invoke lstrlen,addr szSerialTemp2
mov szSerial_len,eax
;Compute the MD5 hash for the 11 chars grabbed
invoke MD5Init
invoke MD5Update,addr szSerialTemp2,szSerial_len
invoke MD5Final
invoke HexToChar,addr MD5Digest,addr szSerialTempMD5,16
;Take 3 chars from the md5 starting at position 19
invoke lstrcpyn,addr szSerialTemp2,addr szSerialTempMD5+19,4
;Build the final serial
invoke lstrcat,addr szSerial,addr szSerialTemp2
invoke SetDlgItemText,hWin,IDC_SERIAL,addr szSerial
call clean
.endif
.endif
.endif
.if wParam == IDB_QUIT
invoke EndDialog,hWin,0
.endif
.elseif uMsg == WM_CLOSE
invoke EndDialog,hWin,0
.endif
xor eax,eax
ret
DlgProc endp
clean proc
invoke RtlZeroMemory,addr szBufName,sizeof szBufName
invoke RtlZeroMemory,addr szNameMD5,sizeof szNameMD5
invoke RtlZeroMemory,addr szSerialTempMD5,sizeof szSerialTempMD5
invoke RtlZeroMemory,addr szSerialTemp1,sizeof szSerialTemp1
invoke RtlZeroMemory,addr szSerialTemp2,sizeof szSerialTemp2
invoke RtlZeroMemory,addr szSerial,sizeof szSerial
ret
clean endp
end start
md5.asm:
.data? MD5HashBuf db 64 dup(?) MD5Digest dd 4 dup(?) MD5Len dd ? MD5Index dd ? .code MD5FF macro dwA, dwB, dwC, dwD, locX, rolS, constAC mov edi,dwC xor edi,dwD and edi,dwB xor edi,dwD add dwA,[locX] lea dwA,[edi+dwA+constAC] rol dwA,rolS add dwA,dwB endm MD5GG macro dwA, dwB, dwC, dwD, locX, rolS, constAC mov edi,dwC xor edi,dwB and edi,dwD xor edi,dwC add dwA,[locX] lea dwA,[edi+dwA+constAC] rol dwA,rolS add dwA,dwB endm MD5HH macro dwA, dwB, dwC, dwD, locX, rolS, constAC mov edi,dwC xor edi,dwD xor edi,dwB add dwA,[locX] lea dwA,[dwA+edi+constAC] rol dwA,rolS add dwA,dwB endm MD5II macro dwA, dwB, dwC, dwD, locX, rolS, constAC mov edi,dwD xor edi,-1 or edi,dwB xor edi,dwC add dwA,[locX] lea dwA,[edi+dwA+constAC] rol dwA,rolS add dwA,dwB endm align dword MD5Transform proc pushad mov esi,offset MD5Digest mov edi,offset MD5HashBuf mov eax,[esi+0*4] mov ebx,[esi+1*4] mov ecx,[esi+2*4] mov ebp,edi mov edx,[esi+3*4] ;============================================================== MD5FF eax, ebx, ecx, edx, dword ptr [ebp+ 0*4], 7, 0D76AA478H MD5FF edx, eax, ebx, ecx, dword ptr [ebp+ 1*4], 12, 0E8C7B756H MD5FF ecx, edx, eax, ebx, dword ptr [ebp+ 2*4], 17, 0242070DBH MD5FF ebx, ecx, edx, eax, dword ptr [ebp+ 3*4], 22, 0C1BDCEEEH MD5FF eax, ebx, ecx, edx, dword ptr [ebp+ 4*4], 7, 0F57C0FAFH MD5FF edx, eax, ebx, ecx, dword ptr [ebp+ 5*4], 12, 04787C62AH MD5FF ecx, edx, eax, ebx, dword ptr [ebp+ 6*4], 17, 0A8304613H MD5FF ebx, ecx, edx, eax, dword ptr [ebp+ 7*4], 22, 0FD469501H MD5FF eax, ebx, ecx, edx, dword ptr [ebp+ 8*4], 7, 0698098D8H MD5FF edx, eax, ebx, ecx, dword ptr [ebp+ 9*4], 12, 08B44F7AFH MD5FF ecx, edx, eax, ebx, dword ptr [ebp+10*4], 17, 0FFFF5BB1H MD5FF ebx, ecx, edx, eax, dword ptr [ebp+11*4], 22, 0895CD7BEH MD5FF eax, ebx, ecx, edx, dword ptr [ebp+12*4], 7, 06B901122H MD5FF edx, eax, ebx, ecx, dword ptr [ebp+13*4], 12, 0FD987193H MD5FF ecx, edx, eax, ebx, dword ptr [ebp+14*4], 17, 0A679438EH MD5FF ebx, ecx, edx, eax, dword ptr [ebp+15*4], 22, 049B40821H ;============================================================== MD5GG eax, ebx, ecx, edx, dword ptr [ebp+ 1*4], 5, 0F61E2562H MD5GG edx, eax, ebx, ecx, dword ptr [ebp+ 6*4], 9, 0C040B340H MD5GG ecx, edx, eax, ebx, dword ptr [ebp+11*4], 14, 0265E5A51H MD5GG ebx, ecx, edx, eax, dword ptr [ebp+ 0*4], 20, 0E9B6C7AAH MD5GG eax, ebx, ecx, edx, dword ptr [ebp+ 5*4], 5, 0D62F105DH MD5GG edx, eax, ebx, ecx, dword ptr [ebp+10*4], 9, 002441453H MD5GG ecx, edx, eax, ebx, dword ptr [ebp+15*4], 14, 0D8A1E681H MD5GG ebx, ecx, edx, eax, dword ptr [ebp+ 4*4], 20, 0E7D3FBC8H MD5GG eax, ebx, ecx, edx, dword ptr [ebp+ 9*4], 5, 021E1CDE6H MD5GG edx, eax, ebx, ecx, dword ptr [ebp+14*4], 9, 0C33707D6H MD5GG ecx, edx, eax, ebx, dword ptr [ebp+ 3*4], 14, 0F4D50D87H MD5GG ebx, ecx, edx, eax, dword ptr [ebp+ 8*4], 20, 0455A14EDH MD5GG eax, ebx, ecx, edx, dword ptr [ebp+13*4], 5, 0A9E3E905H MD5GG edx, eax, ebx, ecx, dword ptr [ebp+ 2*4], 9, 0FCEFA3F8H MD5GG ecx, edx, eax, ebx, dword ptr [ebp+ 7*4], 14, 0676F02D9H MD5GG ebx, ecx, edx, eax, dword ptr [ebp+12*4], 20, 08D2A4C8AH ;============================================================== MD5HH eax, ebx, ecx, edx, dword ptr [ebp+ 5*4], 4, 0FFFA3942H MD5HH edx, eax, ebx, ecx, dword ptr [ebp+ 8*4], 11, 08771F681H MD5HH ecx, edx, eax, ebx, dword ptr [ebp+11*4], 16, 06D9D6122H MD5HH ebx, ecx, edx, eax, dword ptr [ebp+14*4], 23, 0FDE5380CH MD5HH eax, ebx, ecx, edx, dword ptr [ebp+ 1*4], 4, 0A4BEEA44H MD5HH edx, eax, ebx, ecx, dword ptr [ebp+ 4*4], 11, 04BDECFA9H MD5HH ecx, edx, eax, ebx, dword ptr [ebp+ 7*4], 16, 0F6BB4B60H MD5HH ebx, ecx, edx, eax, dword ptr [ebp+10*4], 23, 0BEBFBC70H MD5HH eax, ebx, ecx, edx, dword ptr [ebp+13*4], 4, 0289B7EC6H MD5HH edx, eax, ebx, ecx, dword ptr [ebp+ 0*4], 11, 0EAA127FAH MD5HH ecx, edx, eax, ebx, dword ptr [ebp+ 3*4], 16, 0D4EF3085H MD5HH ebx, ecx, edx, eax, dword ptr [ebp+ 6*4], 23, 004881D05H MD5HH eax, ebx, ecx, edx, dword ptr [ebp+ 9*4], 4, 0D9D4D039H MD5HH edx, eax, ebx, ecx, dword ptr [ebp+12*4], 11, 0E6DB99E5H MD5HH ecx, edx, eax, ebx, dword ptr [ebp+15*4], 16, 01FA27CF8H MD5HH ebx, ecx, edx, eax, dword ptr [ebp+ 2*4], 23, 0C4AC5665H ;============================================================== MD5II eax, ebx, ecx, edx, dword ptr [ebp+ 0*4], 6, 0F4292244H MD5II edx, eax, ebx, ecx, dword ptr [ebp+ 7*4], 10, 0432AFF97H MD5II ecx, edx, eax, ebx, dword ptr [ebp+14*4], 15, 0AB9423A7H MD5II ebx, ecx, edx, eax, dword ptr [ebp+ 5*4], 21, 0FC93A039H MD5II eax, ebx, ecx, edx, dword ptr [ebp+12*4], 6, 0655B59C3H MD5II edx, eax, ebx, ecx, dword ptr [ebp+ 3*4], 10, 08F0CCC92H MD5II ecx, edx, eax, ebx, dword ptr [ebp+10*4], 15, 0FFEFF47DH MD5II ebx, ecx, edx, eax, dword ptr [ebp+ 1*4], 21, 085845DD1H MD5II eax, ebx, ecx, edx, dword ptr [ebp+ 8*4], 6, 06FA87E4FH MD5II edx, eax, ebx, ecx, dword ptr [ebp+15*4], 10, 0FE2CE6E0H MD5II ecx, edx, eax, ebx, dword ptr [ebp+ 6*4], 15, 0A3014314H MD5II ebx, ecx, edx, eax, dword ptr [ebp+13*4], 21, 04E0811A1H MD5II eax, ebx, ecx, edx, dword ptr [ebp+ 4*4], 6, 0F7537E82H MD5II edx, eax, ebx, ecx, dword ptr [ebp+11*4], 10, 0BD3AF235H MD5II ecx, edx, eax, ebx, dword ptr [ebp+ 2*4], 15, 02AD7D2BBH MD5II ebx, ecx, edx, eax, dword ptr [ebp+ 9*4], 21, 0EB86D391H ;============================================================== add [esi+0*4],eax ; update digest add [esi+1*4],ebx add [esi+2*4],ecx add [esi+3*4],edx popad retn MD5Transform endp MD5BURN macro xor eax,eax mov MD5Index,eax mov edi,Offset MD5HashBuf mov ecx,(sizeof MD5HashBuf)/4 rep stosd endm align dword MD5Init proc uses edi xor eax, eax mov MD5Len,eax MD5BURN mov eax,offset MD5Digest mov dword ptr [eax+0*4],067452301h mov dword ptr [eax+1*4],0EFCDAB89h mov dword ptr [eax+2*4],098BADCFEh mov dword ptr [eax+3*4],010325476h ret MD5Init endp align dword MD5Update proc uses esi edi ebx lpBuffer:dword, dwBufLen:dword mov ebx,dwBufLen mov esi,lpBuffer add MD5Len,ebx .while ebx mov eax,MD5Index mov ecx,64 sub ecx,eax lea edi,[MD5HashBuf+eax] .if ecx <= ebx sub ebx,ecx rep movsb call MD5Transform MD5BURN .else mov ecx,ebx rep movsb add MD5Index,ebx .break .endif .endw ret MD5Update endp align dword MD5Final proc uses esi edi mov ecx, MD5Index mov byte ptr [MD5HashBuf+ecx],80h .if ecx >= 56 call MD5Transform MD5BURN .endif mov eax,MD5Len xor edx,edx shld edx,eax,3 shl eax,3 mov dword ptr [MD5HashBuf+56],eax mov dword ptr [MD5HashBuf+60],edx call MD5Transform mov eax,offset MD5Digest ret MD5Final endp
base.rc:
;This Resource Script was generated by WinAsm Studio. #define IDC_NAME 1001 #define IDC_SERIAL 1002 #define IDB_QUIT 1003 #define IDC_GROUPBOX 1004 #define IDC_DATE_STATIC 1005 101 DIALOGEX 0,0,151,68 CAPTION "Base" FONT 8,"Tahoma" STYLE 0x80c80880 EXSTYLE 0x00000000 BEGIN CONTROL "",IDC_GROUPBOX,"Button",0x50008007,3,3,144,47,0x00000000 CONTROL "",IDB_QUIT,"Button",0x10000000,97,52,50,14,0x00000000 CONTROL "",IDC_NAME,"Edit",0x10000080,10,12,131,12,0x00000200 CONTROL "",IDC_SERIAL,"Edit",0x10000080,10,31,131,12,0x00000200 CONTROL "",IDC_DATE_STATIC,"Static",0x58000000,3,58,44,9,0x00000000 END
make.bat:
@echo off \masm32\bin\rc /v base.rc \masm32\bin\ml.exe /c /coff /Cp /nologo kg.asm \masm32\bin\link.exe /SUBSYSTEM:WINDOWS /RELEASE /VERSION:4.0 /OUT:Keygen.exe kg.obj base.res del base.res del base.obj del kg.obj pause
Une fois compilé, ça ressemble à ça:
V: Conclusion
Nous avons vu ici un peu de crypto, également rencontré un problème avec la partie en hard déjà hachée.
Le serial maitre "DFF760119804534A899F55D494DF0ECF" est toujours un inconnu pour nous, mais heureusement, nous avons récupéré l'équivalent en texte de CAF5C8456865585C73C24EDFB7402802, ce qui nous a permis de coder un keygen.
C'était une autre application facile, bien pour se familiariser avec la crypto et comment faire un peu de manipulation de chaîne.
Nous aurions également pu ajouter quelques nombres aléatoires à notre keygen comme anti-ripping/watermark, car le reste du numéro de série n'est pas vérifié après la position 12.
Cela nous permettrait de reconnaître une release plagiarisée si une personne décide de "ressource-hack" le keygen ou de posté en ligne des numéros de série générer a parti de notre Keygen.
Une pratique assez courante sur la scène pour trouver les lamers.
Xylitol, 20/06/2021
Copyright (C)- xtx Team (2021)
