Categoría: Crackmes.de

Solución al Crackme 7 de Scarebyte

17 febrero, 2016 por deurus·Sin comentarios

Introducción
Desempacado
Eliminar la NAG
Password
Nº serie asociado a un nombre
Checkbox
Trackbar
Links

Introducción

Aquí tenemos un Crackme clásico creado por Scarebyte hallá por el año 2000 y que cuenta con varias fases siendo un crackme muy interesante para iniciarse o simplemente para divertirse. Al estar realizado en Delphi, los apartados de las checkboxes y de las trackbars se simplifican y mucho, pero aún así hay que currarselo un poco para dejar todo bien atado. Si os fijáis en las soluciones que aparecen en crackmes.de, en aquellos años se usaba DEDE y aunque yo usaré otra herramienta, DEDE sigue siendo igual de útil.

Desempacado

PEiD nos dice que nos enfrentamos a ASPack 1.08.03 -> Alexey Solodovnikov, así que vamos al lío.

Eliminar la NAG

Tan sencillo como poner un Breakpoint a User32.MessageBoxA. La llamada a NOPear está en la dirección 441CF2.

Password

Desde las string references localizamos los mensajes de chico bueno y chico malo que nos llevan al código a analizar.

0044C3CD   |.  E8 5294FDFF     CALL CrackMe_.00425824
0044C3D2   |.  8B45 FC         MOV EAX,[LOCAL.1]
0044C3D5   |.  E8 9A76FBFF     CALL CrackMe_.00403A74
0044C3DA   |.  83F8 0C         CMP EAX,0C                             ; Lengh C = 12
0044C3DD   |.  0F85 53010000   JNZ CrackMe_.0044C536		      ; Salto a chico malo
0044C3E3   |.  8D55 FC         LEA EDX,[LOCAL.1]
0044C3E6   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C3EC   |.  E8 3394FDFF     CALL CrackMe_.00425824
0044C3F1   |.  8B45 FC         MOV EAX,[LOCAL.1]
0044C3F4   |.  8038 43         CMP BYTE PTR DS:[EAX],43               ; 1º dígito serial = C
0044C3F7   |.  0F85 27010000   JNZ CrackMe_.0044C524		      ; Salto a chico malo
0044C3FD   |.  8D55 F8         LEA EDX,[LOCAL.2]
0044C400   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C406   |.  E8 1994FDFF     CALL CrackMe_.00425824
0044C40B   |.  8B45 F8         MOV EAX,[LOCAL.2]
0044C40E   |.  8078 03 6F      CMP BYTE PTR DS:[EAX+3],6F             ; 4º dígito serial = o
0044C412   |.  0F85 0C010000   JNZ CrackMe_.0044C524			; Salto a chico malo
0044C418   |.  8D55 F4         LEA EDX,[LOCAL.3]
0044C41B   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C421   |.  E8 FE93FDFF     CALL CrackMe_.00425824
0044C426   |.  8B45 F4         MOV EAX,[LOCAL.3]
0044C429   |.  8078 08 6F      CMP BYTE PTR DS:[EAX+8],6F             ; 9º dígito serial = o
0044C42D   |.  0F85 F1000000   JNZ CrackMe_.0044C524			; Salto a chico malo
0044C433   |.  8D55 F0         LEA EDX,[LOCAL.4]
0044C436   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C43C   |.  E8 E393FDFF     CALL CrackMe_.00425824
0044C441   |.  8B45 F0         MOV EAX,[LOCAL.4]
0044C444   |.  8078 01 6C      CMP BYTE PTR DS:[EAX+1],6C             ; 2º dígito serial = l
0044C448   |.  0F85 D6000000   JNZ CrackMe_.0044C524			; Salto a chico malo
0044C44E   |.  8D55 EC         LEA EDX,[LOCAL.5]
0044C451   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C457   |.  E8 C893FDFF     CALL CrackMe_.00425824
0044C45C   |.  8B45 EC         MOV EAX,[LOCAL.5]
0044C45F   |.  8078 04 20      CMP BYTE PTR DS:[EAX+4],20             ; 5º dígito serial = espacio
0044C463   |.  0F85 BB000000   JNZ CrackMe_.0044C524			; Salto a chico malo
0044C469   |.  8D55 E8         LEA EDX,[LOCAL.6]
0044C46C   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C472   |.  E8 AD93FDFF     CALL CrackMe_.00425824
0044C477   |.  8B45 E8         MOV EAX,[LOCAL.6]
0044C47A   |.  8078 0A 52      CMP BYTE PTR DS:[EAX+A],52             ; 11º dígito serial = R
0044C47E   |.  0F85 A0000000   JNZ CrackMe_.0044C524									; Salto a chico malo
0044C484   |.  8D55 E4         LEA EDX,[LOCAL.7]
0044C487   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C48D   |.  E8 9293FDFF     CALL CrackMe_.00425824
0044C492   |.  8B45 E4         MOV EAX,[LOCAL.7]
0044C495   |.  8078 07 75      CMP BYTE PTR DS:[EAX+7],75             ; 8º dígito serial = u
0044C499   |.  0F85 85000000   JNZ CrackMe_.0044C524									; Salto a chico malo
0044C49F   |.  8D55 E0         LEA EDX,[LOCAL.8]
0044C4A2   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C4A8   |.  E8 7793FDFF     CALL CrackMe_.00425824
0044C4AD   |.  8B45 E0         MOV EAX,[LOCAL.8]
0044C4B0   |.  8078 09 6E      CMP BYTE PTR DS:[EAX+9],6E             ; 10º dígito serial = n
0044C4B4   |.  75 6E           JNZ SHORT CrackMe_.0044C524		; Salto a chico malo
0044C4B6   |.  8D55 DC         LEA EDX,[LOCAL.9]
0044C4B9   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C4BF   |.  E8 6093FDFF     CALL CrackMe_.00425824
0044C4C4   |.  8B45 DC         MOV EAX,[LOCAL.9]
0044C4C7   |.  8078 02 6E      CMP BYTE PTR DS:[EAX+2],6E             ; 3º dígito serial = n
0044C4CB   |.  75 57           JNZ SHORT CrackMe_.0044C524		; Salto a chico malo
0044C4CD   |.  8D55 D8         LEA EDX,[LOCAL.10]
0044C4D0   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C4D6   |.  E8 4993FDFF     CALL CrackMe_.00425824
0044C4DB   |.  8B45 D8         MOV EAX,[LOCAL.10]
0044C4DE   |.  8078 05 69      CMP BYTE PTR DS:[EAX+5],69             ; 6º dígito serial = i
0044C4E2   |.  75 40           JNZ SHORT CrackMe_.0044C524	      ; Salto a chico malo
0044C4E4   |.  8D55 D4         LEA EDX,[LOCAL.11]
0044C4E7   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C4ED   |.  E8 3293FDFF     CALL CrackMe_.00425824
0044C4F2   |.  8B45 D4         MOV EAX,[LOCAL.11]
0044C4F5   |.  8078 0B 6E      CMP BYTE PTR DS:[EAX+B],6E             ; 12º dígito serial = n
0044C4F9   |.  75 29           JNZ SHORT CrackMe_.0044C524	      ; Salto a chico malo
0044C4FB   |.  8D55 D0         LEA EDX,[LOCAL.12]
0044C4FE   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C504   |.  E8 1B93FDFF     CALL CrackMe_.00425824
0044C509   |.  8B45 D0         MOV EAX,[LOCAL.12]
0044C50C   |.  8078 06 67      CMP BYTE PTR DS:[EAX+6],67             ; 7º dígito serial = g
0044C510   |.  75 12           JNZ SHORT CrackMe_.0044C524	      ; Salto a chico malo
0044C512   |.  BA 78C54400     MOV EDX,CrackMe_.0044C578              ;  ASCII "Right Password"
0044C517   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C51D   |.  E8 3293FDFF     CALL CrackMe_.00425854
0044C522   |.  EB 22           JMP SHORT CrackMe_.0044C546
0044C524   |>  BA 90C54400     MOV EDX,CrackMe_.0044C590              ;  ASCII "Wrong Password"
0044C529   |.  8B83 E8020000   MOV EAX,DWORD PTR DS:[EBX+2E8]
0044C52F   |.  E8 2093FDFF     CALL CrackMe_.00425854
0044C534   |.  EB 10           JMP SHORT CrackMe_.0044C546
0044C536   |>  BA 90C54400     MOV EDX,CrackMe_.0044C590              ;  ASCII "Wrong Password"
	
Chequeo rápido
ABCD EFGHIJK
Clno iguonRn
	
; 1º  dígito serial = C
; 4º  dígito serial = o
; 9º  dígito serial = o
; 2º  dígito serial = l
; 5º  dígito serial = espacio
; 11º dígito serial = R
; 8º  dígito serial = u
; 10º dígito serial = n
; 3º  dígito serial = n
; 6º  dígito serial = i
; 12º dígito serial = n
; 7º  dígito serial = g

Básicamente chequea la frase «Cool Running» de forma desordenada como se ve justo encima, siendo el password correcto «Clno iguonRn«. Os dejo el código para que lo analicéis.

Nº serie asociado a un nombre

De nuevo con las string references localizamos el código.

0044C648  /.  55            PUSH EBP
0044C649  |.  8BEC          MOV EBP,ESP
0044C64B  |.  83C4 F8       ADD ESP,-8
0044C64E  |.  53            PUSH EBX
0044C64F  |.  56            PUSH ESI
0044C650  |.  33C9          XOR ECX,ECX
0044C652  |.  894D F8       MOV [LOCAL.2],ECX
0044C655  |.  8BF0          MOV ESI,EAX
0044C657  |.  33C0          XOR EAX,EAX
0044C659  |.  55            PUSH EBP
0044C65A  |.  68 83C74400   PUSH CrackMe_.0044C783
0044C65F  |.  64:FF30       PUSH DWORD PTR FS:[EAX]
0044C662  |.  64:8920       MOV DWORD PTR FS:[EAX],ESP
0044C665  |.  33C0          XOR EAX,EAX
0044C667  |.  8945 FC       MOV [LOCAL.1],EAX
0044C66A  |.  A1 80F84400   MOV EAX,DWORD PTR DS:[44F880]        ;  Eax = Nombre
0044C66F  |.  E8 0074FBFF   CALL CrackMe_.00403A74
0044C674  |.  83F8 06       CMP EAX,6                            ;  Cmp lengh nombre con 6
0044C677  |.  0F8E F0000000 JLE CrackMe_.0044C76D                ;  Salta si <= 6
0044C67D  |.  A1 80F84400   MOV EAX,DWORD PTR DS:[44F880]        ;  Eax = Nombre
0044C682  |.  E8 ED73FBFF   CALL CrackMe_.00403A74
0044C687  |.  83F8 14       CMP EAX,14                           ;  Cmp lengh nombre con 20 (14h)
0044C68A  |.  0F8D DD000000 JGE CrackMe_.0044C76D                ;  salta si >= 20
0044C690  |.  A1 80F84400   MOV EAX,DWORD PTR DS:[44F880]
0044C695  |.  E8 DA73FBFF   CALL CrackMe_.00403A74
0044C69A  |.  85C0          TEST EAX,EAX
0044C69C  |.  7E 17         JLE SHORT CrackMe_.0044C6B5
0044C69E  |.  BA 01000000   MOV EDX,1
0044C6A3  |>  8B0D 80F84400 /MOV ECX,DWORD PTR DS:[44F880]       ;  Bucle in
0044C6A9  |.  0FB64C11 FF   |MOVZX ECX,BYTE PTR DS:[ECX+EDX-1]
0044C6AE  |.  014D FC       |ADD [LOCAL.1],ECX                   ;  Suma dig nombre y guarda en 12FBC4
0044C6B1  |.  42            |INC EDX
0044C6B2  |.  48            |DEC EAX
0044C6B3  |.^ 75 EE         \JNZ SHORT CrackMe_.0044C6A3         ;  Bucle out
0044C6B5  |>  A1 84F84400   MOV EAX,DWORD PTR DS:[44F884]        ;  Eax = Compañia
0044C6BA  |.  E8 B573FBFF   CALL CrackMe_.00403A74
0044C6BF  |.  83F8 02       CMP EAX,2                            ;  Cmp lengh compañia con 2
0044C6C2  |.  7E 18         JLE SHORT CrackMe_.0044C6DC          ;  Salta si <= 2
0044C6C4  |.  A1 84F84400   MOV EAX,DWORD PTR DS:[44F884]        ;  Eax = Compañia
0044C6C9  |.  E8 A673FBFF   CALL CrackMe_.00403A74
0044C6CE  |.  83F8 08       CMP EAX,8                            ;  Cmp lengh compañia con 8
0044C6D1  |.  7D 09         JGE SHORT CrackMe_.0044C6DC          ;  Salta si >= 8
0044C6D3  |.  8B45 FC       MOV EAX,[LOCAL.1]                    ;  Eax = sum nombre
0044C6D6  |.  6BC0 02       IMUL EAX,EAX,2                       ;  Sum nombre * 2
0044C6D9  |.  8945 FC       MOV [LOCAL.1],EAX
0044C6DC  |>  68 98C74400   PUSH CrackMe_.0044C798               ;  ASCII "I Love Cracking and "
0044C6E1  |.  8D55 F8       LEA EDX,[LOCAL.2]
0044C6E4  |.  8B45 FC       MOV EAX,[LOCAL.1]
0044C6E7  |.  E8 68B0FBFF   CALL CrackMe_.00407754
0044C6EC  |.  FF75 F8       PUSH [LOCAL.2]                       ;  sum del nombre
0044C6EF  |.  68 B8C74400   PUSH CrackMe_.0044C7B8               ;  ASCII " Girls ;)"
0044C6F4  |.  B8 8CF84400   MOV EAX,CrackMe_.0044F88C
0044C6F9  |.  BA 03000000   MOV EDX,3
0044C6FE  |.  E8 3174FBFF   CALL CrackMe_.00403B34               ;  Concatena 1º frase + sum nombre + 2ºfrase
0044C703  |.  33C0          XOR EAX,EAX
0044C705  |.  8945 FC       MOV [LOCAL.1],EAX
0044C708  |.  A1 88F84400   MOV EAX,DWORD PTR DS:[44F888]        ;  Eax = Serial
0044C70D  |.  E8 6273FBFF   CALL CrackMe_.00403A74
0044C712  |.  8BD8          MOV EBX,EAX
0044C714  |.  A1 8CF84400   MOV EAX,DWORD PTR DS:[44F88C]
0044C719  |.  E8 5673FBFF   CALL CrackMe_.00403A74
0044C71E  |.  3BD8          CMP EBX,EAX                          ;  Compara tamaño frase con tamaño serial
0044C720  |.  75 4B         JNZ SHORT CrackMe_.0044C76D
0044C722  |.  A1 88F84400   MOV EAX,DWORD PTR DS:[44F888]
0044C727  |.  E8 4873FBFF   CALL CrackMe_.00403A74
0044C72C  |.  85C0          TEST EAX,EAX
0044C72E  |.  7E 27         JLE SHORT CrackMe_.0044C757
0044C730  |.  BA 01000000   MOV EDX,1
0044C735  |>  8B0D 88F84400 /MOV ECX,DWORD PTR DS:[44F888]	; Bucle in -->
0044C73B  |.  0FB64C11 FF   |MOVZX ECX,BYTE PTR DS:[ECX+EDX-1]
0044C740  |.  034D FC       |ADD ECX,[LOCAL.1]
0044C743  |.  8B1D 8CF84400 |MOV EBX,DWORD PTR DS:[44F88C]
0044C749  |.  0FB65C13 FF   |MOVZX EBX,BYTE PTR DS:[EBX+EDX-1]	; Compara dígito a dígito nuestro serial
0044C74E  |.  2BCB          |SUB ECX,EBX			; con la concatenación anterior
0044C750  |.  894D FC       |MOV [LOCAL.1],ECX
0044C753  |.  42            |INC EDX
0044C754  |.  48            |DEC EAX
0044C755  |.^ 75 DE         \JNZ SHORT CrackMe_.0044C735	; <-- Bucle out
0044C757  |>  837D FC 00    CMP [LOCAL.1],0
0044C75B  |.  75 10         JNZ SHORT CrackMe_.0044C76D		; Salta si algo ha ido mal
0044C75D  |.  8B86 14030000 MOV EAX,DWORD PTR DS:[ESI+314]
0044C763  |.  BA CCC74400   MOV EDX,CrackMe_.0044C7CC           ; "You have found the correct Serial :)"

En resumen

Tamaño del nombre entre 7 y 19.
Tamaño de la compañía entre 3 y 7 aunque no interviene en el serial.
Suma los valores ascii de los dígitos del nombre y lo multiplica por 2.
Concatena «I Love Cracking and » + «sum del nombre» + » Girls ;)».

Checkbox

Para afrontar esta parte del reto vamos a usar una herramienta llamada Interactive Delphi Reconstructor o IDR. En su día la mejor herramienta era DEDE, pero IDR a mi parecer es algo más potente.

Básicamente IDR nos permite sin quebraderos de cabeza localizar el código del botón que comprueba la secuencia de checkboxes correcta. Cargamos el crackme en IDR y dentro de la pestaña «Units (F2)«, abajo del todo hacemos doble click sobre «F Crack» y vemos que nos muestra todos los controles del formulario. El botón que nos interesa se llama «SpeedButton3«.

Si hacemos doble click sobre el nos muestra el código que se muestra a continuación.

crack::TForm1.SpeedButton3Click
 0044C7F4    push       ebp
 0044C7F5    mov        ebp,esp
 0044C7F7    push       0
 0044C7F9    push       ebx
 0044C7FA    mov        ebx,eax
 0044C7FC    xor        eax,eax
 0044C7FE    push       ebp
 0044C7FF    push       44C920
 0044C804    push       dword ptr fs:[eax]
 0044C807    mov        dword ptr fs:[eax],esp
 0044C80A    mov        eax,dword ptr [ebx+324]; TForm1.cb3:TCheckBox
 0044C810    mov        edx,dword ptr [eax]
 0044C812    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C818    test       al,al
>0044C81A    je         0044C8ED
 0044C820    mov        eax,dword ptr [ebx+328]; TForm1.cb5:TCheckBox
 0044C826    mov        edx,dword ptr [eax]
 0044C828    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C82E    test       al,al
>0044C830    je         0044C8ED
 0044C836    mov        eax,dword ptr [ebx+32C]; TForm1.cb6:TCheckBox
 0044C83C    mov        edx,dword ptr [eax]
 0044C83E    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C844    test       al,al
>0044C846    je         0044C8ED
 0044C84C    mov        eax,dword ptr [ebx+358]; TForm1.cb12:TCheckBox
 0044C852    mov        edx,dword ptr [eax]
 0044C854    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C85A    test       al,al
>0044C85C    je         0044C8ED
 0044C862    mov        eax,dword ptr [ebx+364]; TForm1.cb15:TCheckBox
 0044C868    mov        edx,dword ptr [eax]
 0044C86A    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C870    test       al,al
>0044C872    je         0044C8ED
 0044C874    mov        eax,dword ptr [ebx+330]; TForm1.cb20:TCheckBox
 0044C87A    mov        edx,dword ptr [eax]
 0044C87C    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C882    test       al,al
>0044C884    je         0044C8ED
 0044C886    mov        eax,dword ptr [ebx+34C]; TForm1.cb9:TCheckBox
 0044C88C    mov        edx,dword ptr [eax]
 0044C88E    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C894    test       al,al
>0044C896    je         0044C8ED
 0044C898    mov        eax,dword ptr [ebx+354]; TForm1.cb11:TCheckBox
 0044C89E    mov        edx,dword ptr [eax]
 0044C8A0    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C8A6    test       al,al
>0044C8A8    je         0044C8ED
 0044C8AA    mov        eax,dword ptr [ebx+35C]; TForm1.cb13:TCheckBox
 0044C8B0    mov        edx,dword ptr [eax]
 0044C8B2    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C8B8    test       al,al
>0044C8BA    je         0044C8ED
 0044C8BC    mov        eax,dword ptr [ebx+33C]; TForm1.cb19:TCheckBox
 0044C8C2    mov        edx,dword ptr [eax]
 0044C8C4    call       dword ptr [edx+0B8]; TCustomCheckBox.GetChecked
 0044C8CA    test       al,al
>0044C8CC    je         0044C8ED
 0044C8CE    lea        eax,[ebp-4]
 0044C8D1    mov        edx,44C934; 'Ìõô¸ö÷ê¥ó¤ÉÚÀÆ²Äæââîàä¶¶'
 0044C8D6    call       @LStrLAsg
 0044C8DB    lea        eax,[ebp-4]
 0044C8DE    call       0044BF00
 0044C8E3    mov        eax,dword ptr [ebp-4]
 0044C8E6    call       ShowMessage
>0044C8EB    jmp        0044C90A
 0044C8ED    lea        eax,[ebp-4]
 0044C8F0    mov        edx,44C958; 'Åÿæòè¡¦óàù¨ïêçð®øé¤íüàîè¯¹'
 0044C8F5    call       @LStrLAsg
 0044C8FA    lea        eax,[ebp-4]
 0044C8FD    call       0044BF00
 0044C902    mov        eax,dword ptr [ebp-4]
 0044C905    call       ShowMessage
 0044C90A    xor        eax,eax
 0044C90C    pop        edx
 0044C90D    pop        ecx
 0044C90E    pop        ecx
 0044C90F    mov        dword ptr fs:[eax],edx
 0044C912    push       44C927
 0044C917    lea        eax,[ebp-4]
 0044C91A    call       @LStrClr
 0044C91F    ret
<0044C920    jmp        @HandleFinally
<0044C925    jmp        0044C917
 0044C927    pop        ebx
 0044C928    pop        ecx
 0044C929    pop        ebp
 0044C92A    ret

Como podéis apreciar, las checkboxes involucradas son la 3, 5, 6, 9, 11, 12, 13, 15, 19 y 20. Solo nos falta saber cuales se corresponden con esa numeración y aquí ya depende de cada uno, yo en su día saqué los números a mano mediante el orden de tabulación, pero ya que tenemos IDR, el nos va a dar la solución de una forma sencilla y rápida.

Vamos a la pestaña «Forms (F5)«, seleccionamos la opción Form y hacemos doble click sobre el formulario.

Veréis que aparece el formulario con todos los recursos, incluso los puedes modificar. Localizar los checkboxes ahora es un juego de niños.

Os dejo un vídeo.

Trackbar

De nuevo, con la ayuda de IDR, localizamos la parte del código y analizamos su funcionamiento. Esta parte es la más divertida ya que requiere de un keygen pero en vez de coger el número de serie de una caja de texto lo obtiene de 5 trackbars como muestra la siguiente imagen.

El código de comprobación es el siguiente.

CPU Disasm
Address   Hex dump          Command                                  Comments
0044C1FF  |.  E8 ECF6FCFF   CALL 0041B8F0                            ; b^3
0044C204  |.  D805 50C34400 FADD DWORD PTR DS:[44C350]               ; b^3+5
0044C20A  |.  D9FA          FSQRT                                    ; sqrt(b^3+5)
0044C20C  |.  E8 F365FBFF   CALL 00402804                            ; Cos(sqrt(b^3+5)) = U
0044C211  |.  DB7D B8       FSTP TBYTE PTR SS:[EBP-48]
0044C214  |.  9B            WAIT
0044C215  |.  D905 54C34400 FLD DWORD PTR DS:[44C354]                ; Coje a
0044C21B  |.  DC45 E8       FADD QWORD PTR SS:[EBP-18]               ; a+1
0044C21E  |.  D9FA          FSQRT                                    ; sqrt(a+1)
0044C220  |.  D9E0          FCHS                                     ; -sqrt(a+1) = V
0044C222  |.  DB6D B8       FLD TBYTE PTR SS:[EBP-48]
0044C225  |.  DEC1          FADDP ST(1),ST
0044C227  |.  DB7D AC       FSTP TBYTE PTR SS:[EBP-54]
0044C22A  |.  9B            WAIT
0044C22B  |.  D905 58C34400 FLD DWORD PTR DS:[44C358]                ; coje c
0044C231  |.  DC4D D8       FMUL QWORD PTR SS:[EBP-28]               ; c*3
0044C234  |.  D805 54C34400 FADD DWORD PTR DS:[44C354]               ; c*3+1
0044C23A  |.  D9ED          FLDLN2                                   ; Ln(c*3+1) = X
0044C23C  |.  D9C9          FXCH ST(1)
0044C23E  |.  D9F1          FYL2X
0044C240  |.  DB6D AC       FLD TBYTE PTR SS:[EBP-54]
0044C243  |.  DEC1          FADDP ST(1),ST                           ; U+V+X
0044C245  |.  DB7D A0       FSTP TBYTE PTR SS:[EBP-60]
0044C248  |.  9B            WAIT
0044C249  |.  D905 5CC34400 FLD DWORD PTR DS:[44C35C]                ; coje d
0044C24F  |.  DC45 D0       FADD QWORD PTR SS:[EBP-30]               ; d+2
0044C252  |.  D9FA          FSQRT                                    ; sqrt(d+2) = Y
0044C254  |.  DB6D A0       FLD TBYTE PTR SS:[EBP-60]
0044C257  |.  DEE1          FSUBRP ST(1),ST                          ; U+V+X+(-Y)
0044C259  |.  D905 58C34400 FLD DWORD PTR DS:[44C358]                ; coje e
0044C25F  |.  DC4D C8       FMUL QWORD PTR SS:[EBP-38]               ; e*3
0044C262  |.  D835 5CC34400 FDIV DWORD PTR DS:[44C35C]               ; (e*3)/2 = Z
0044C268  |.  DEC1          FADDP ST(1),ST                           ; U+V+X+Y+Z
0044C26A  |.  DB2D 60C34400 FLD TBYTE PTR DS:[44C360]
0044C270  |.  DEC1          FADDP ST(1),ST                           ; U+V+X+Y+Z+0.37
0044C272  |.  D80D 6CC34400 FMUL DWORD PTR DS:[44C36C]               ; (U+V+X+Y+Z+0.37)*1000
0044C278  |.  DD5D F0       FSTP QWORD PTR SS:[EBP-10]
0044C27B  |.  9B            WAIT
0044C27C  |.  DD45 F0       FLD QWORD PTR SS:[EBP-10]
0044C27F  |.  E8 9065FBFF   CALL 00402814                            ; Redondea((U+V+X+Y+Z+0,37)*1000)
0044C284  |.  8945 98       MOV DWORD PTR SS:[EBP-68],EAX
0044C287  |.  8955 9C       MOV DWORD PTR SS:[EBP-64],EDX
0044C28A  |.  DF6D 98       FILD QWORD PTR SS:[EBP-68]
0044C28D  |.  83C4 F4       ADD ESP,-0C
0044C290  |.  DB3C24        FSTP TBYTE PTR SS:[LOCAL.33]             
0044C293  |.  9B            WAIT                                     
0044C294  |.  8D45 FC       LEA EAX,[EBP-4]                          
0044C297  |.  E8 68BFFBFF   CALL 00408204                            
0044C29C  |.  8D45 FC       LEA EAX,[EBP-4]
0044C29F  |.  E8 5CFCFFFF   CALL 0044BF00                            ; Llamada de generación de hash
........
0044BF04  |.  8BF0          MOV ESI,EAX
0044BF06  |.  8B06          MOV EAX,DWORD PTR DS:[ESI]               ; EAX = 5415
0044BF08  |.  E8 677BFBFF   CALL 00403A74
0044BF0D  |.  8B15 98EE4400 MOV EDX,DWORD PTR DS:[44EE98]
0044BF13  |.  8902          MOV DWORD PTR DS:[EDX],EAX
0044BF15  |.  8B06          MOV EAX,DWORD PTR DS:[ESI]
0044BF17  |.  E8 587BFBFF   CALL 00403A74
0044BF1C  |.  84C0          TEST AL,AL
0044BF1E  |.  76 38         JBE SHORT 0044BF58
0044BF20  |.  880424        MOV BYTE PTR SS:[LOCAL.3],AL
0044BF23  |.  B3 01         MOV BL,1
0044BF25  |>  B8 1C000000   /MOV EAX,1C
0044BF2A  |.  E8 516AFBFF   |CALL 00402980
0044BF2F  |.  0D 80000000   |OR EAX,00000080
0044BF34  |.  8BFB          |MOV EDI,EBX
0044BF36  |.  81E7 FF000000 |AND EDI,000000FF
0044BF3C  |.  8B16          |MOV EDX,DWORD PTR DS:[ESI]
0044BF3E  |.  0FB6543A FF   |MOVZX EDX,BYTE PTR DS:[EDI+EDX-1]       ; Coje dig a dig el hash, en este caso 5415
0044BF43  |.  33C2          |XOR EAX,EDX                             ; 1 dig XOR 83; 2 dig XOR 89; 3 dig XOR 86; 4 dig XOR 8D
0044BF45  |.  50            |PUSH EAX
0044BF46  |.  8BC6          |MOV EAX,ESI
0044BF48  |.  E8 F77CFBFF   |CALL 00403C44                           
0044BF4D  |.  5A            |POP EDX
0044BF4E  |.  885438 FF     |MOV BYTE PTR DS:[EDI+EAX-1],DL
0044BF52  |.  43            |INC EBX
0044BF53  |.  FE0C24        |DEC BYTE PTR SS:[LOCAL.3]
0044BF56  |.^ 75 CD         \JNZ SHORT 0044BF25
........
0044C2AC  |.  E8 D378FBFF   CALL 00403B84                            ; Llamada a comparación
........
00403BAD  |> /8B0E          /MOV ECX,DWORD PTR DS:[ESI]              ; ECX = nuestro Serial XOReado
00403BAF  |. |8B1F          |MOV EBX,DWORD PTR DS:[EDI]              ; EBX = Serial bueno
00403BB1  |. |39D9          |CMP ECX,EBX                             ; Compara
00403BB3  |. |75 58         |JNE SHORT 00403C0D                      ; Chico malo
00403BB5  |. |4A            |DEC EDX
00403BB6  |. |74 15         |JZ SHORT 00403BCD
00403BB8  |. |8B4E 04       |MOV ECX,DWORD PTR DS:[ESI+4]
00403BBB  |. |8B5F 04       |MOV EBX,DWORD PTR DS:[EDI+4]
00403BBE  |. |39D9          |CMP ECX,EBX
00403BC0  |. |75 4B         |JNE SHORT 00403C0D
00403BC2  |. |83C6 08       |ADD ESI,8
00403BC5  |. |83C7 08       |ADD EDI,8
00403BC8  |. |4A            |DEC EDX
00403BC9  |.^\75 E2         \JNZ SHORT 00403BAD

En resumen

1) Siendo nuestro serial : 1 2 3 4 5
                           a b c d e
 
2) Realiza las operaciones matemáticas:
   Round(((Cos(sqrt(b^3+5)) + (-sqrt(a+1)) + Ln(c*3+1) + (-sqrt(d+2)) + ((e*3)/2))+0.37)*1000))
 
3) Obtenemos un hash resultante de 5415

4) XORea los dígitos de la siguiente manera:
   (5)35 xor 86 = B6
   (4)34 xor 83 = BD
   (1)31 xor 86 = B7
   (5)35 xor 8D = B8
 
 De modo que tenemos B6BDB7B8
 
5) Compara B6BDB7B8 con B5BAB2BA

6) Revertimos el XOR para obtener el hash bueno
   B5 xor 86 = 36(6)
   BA xor 83 = 33(3)
   B2 xor 86 = 34(4)
   BA xor 8D = 37(7)
 
 Luego el hash bueno es 6347
 
7) Debemos hacer fuerza bruta buscando: 
   Round(((Cos(sqrt(b^3+5)) + (-sqrt(a+1)) + Ln(c*3+1) + (-sqrt(d+2)) + ((e*3)/2))+0.37)*1000)) = 6347

Para obtener los seriales válidos podemos hacer bucles recursivos hasta recorrer las 10^5 opciones posibles. Una forma de hacerlo en VBNet es la siguiente.

Dim tmp As Double
Dim an, bn, cn, dn, en As Integer
        For an = 0 To 9
            For bn = 0 To 9
                For cn = 0 To 9
                    For dn = 0 To 9
                        For en = 0 To 9
                            tmp = Round(((Cos(Sqrt((Pow(bn, 3)) + 5)) + (-Sqrt(an + 1)) + Log(cn * 3 + 1) + (-Sqrt(dn + 2)) + ((en * 3) / 2) + 0.37) * 1000))
                            txtdebug.Text = "a-b-c-d-e = Hash || " & an & "-" & bn & "-" & cn & "-" & dn & "-" & en & " = " & tmp
                            If tmp = 6347 Then
                                ListBox1.Items.Add("Serial: " & an & bn & cn & dn & en)
                            End If
                            Application.DoEvents()
                        Next
                    Next
                Next
            Next
        Next

Os dejo como siempre el crackme y el keygen en los enlaces.

Mirror Crackmes.de

29 marzo, 2017 por deurus·Sin comentarios

~~While Crackmes.de returns, I leave a couple of files for practice.~~

~~Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.~~

~~In the folder crackmes.de_mirror you have two files:~~

~~En la carpeta crackmes.de_mirror tienes dos archivos:~~

~~Crackmes.de (2011 – 2015).rar [491 MB] [password: tuts4you]~~
~~crackmes.de-2016-12.7z [639 MB]~~

 password of files = deurus.info

lost_in_bin

Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la

Keygen para el Crackme#8 de Kwazy Webbit - Comparación no lineal

Primeras impresiones El crackme es el típico de usuario y número de serie. Si no introduces un nombre te salta

CanYouHack.it Mobile2 Challenge - Follow The Web (English)

Warning: This challenge is still active and therefore should not be resolved using this information. Aviso: Este reto sigue en

This little bunny CrackMe

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece. En este pequeño CrackMe se nos

« Previous 1 2 3 4 … 30 Next »

lost_in_bin

8 agosto, 2024 por deurus·Sin comentarios

Estamos ante un ELF un poco más interesante que los vistos anteriormente. Básicamente porque es divertido y fácil encontrar la solución en el decompilado y quizá por evocar recuerdos de tiempos pretéritos.

Table of Contents

ELF Decompilado

/* This file was generated by the Hex-Rays decompiler version 8.4.0.240320.
   Copyright (c) 2007-2021 Hex-Rays <info@hex-rays.com>

   Detected compiler: GNU C++
*/

#include <defs.h>


//-------------------------------------------------------------------------
// Function declarations

__int64 (**init_proc())(void);
__int64 sub_400650(); // weak
// int printf(const char *format, ...);
// int puts(const char *s);
// void __noreturn exit(int status);
// size_t strlen(const char *s);
// __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD); weak
// int sprintf(char *s, const char *format, ...);
// __int64 ptrace(enum __ptrace_request request, ...);
// __int64 strtol(const char *nptr, char **endptr, int base);
// __int64 __isoc99_scanf(const char *, ...); weak
// int memcmp(const void *s1, const void *s2, size_t n);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void *sub_400730();
__int64 sub_400760();
void *sub_4007A0();
__int64 sub_4007D0();
void fini(void); // idb
void term_proc();
// int __fastcall _libc_start_main(int (__fastcall *main)(int, char **, char **), int argc, char **ubp_av, void (*init)(void), void (*fini)(void), void (*rtld_fini)(void), void *stack_end);
// __int64 _gmon_start__(void); weak

//-------------------------------------------------------------------------
// Data declarations

_UNKNOWN main;
_UNKNOWN init;
__int64 (__fastcall *funcs_400E29)() = &sub_4007D0; // weak
__int64 (__fastcall *off_601DF8)() = &sub_4007A0; // weak
__int64 (*qword_602010)(void) = NULL; // weak
char *off_602080 = "FLAG-%s\n"; // idb
char a7yq2hryrn5yJga[16] = "7Yq2hrYRn5Y`jga"; // weak
const char aO6uH[] = "(O6U,H\""; // idb
_UNKNOWN unk_6020B8; // weak
_UNKNOWN unk_6020C8; // weak
char byte_6020E0; // weak
char s1; // idb
char byte_602110[]; // weak
char byte_602120[33]; // weak
char byte_602141[7]; // idb
__int64 qword_602148; // weak
__int64 qword_602150; // weak
__int64 qword_602158; // weak
__int64 qword_602160; // weak
__int64 qword_602178; // weak


//----- (0000000000400630) ----------------------------------------------------
__int64 (**init_proc())(void)
{
  __int64 (**result)(void); // rax

  result = &_gmon_start__;
  if ( &_gmon_start__ )
    return (__int64 (**)(void))_gmon_start__();
  return result;
}
// 6021D8: using guessed type __int64 _gmon_start__(void);

//----- (0000000000400650) ----------------------------------------------------
__int64 sub_400650()
{
  return qword_602010();
}
// 400650: using guessed type __int64 sub_400650();
// 602010: using guessed type __int64 (*qword_602010)(void);

//----- (0000000000400700) ----------------------------------------------------
// positive sp value has been detected, the output may be wrong!
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void))
{
  __int64 v3; // rax
  int v4; // esi
  __int64 v5; // [rsp-8h] [rbp-8h] BYREF
  char *retaddr; // [rsp+0h] [rbp+0h] BYREF

  v4 = v5;
  v5 = v3;
  _libc_start_main((int (__fastcall *)(int, char **, char **))main, v4, &retaddr, (void (*)(void))init, fini, a3, &v5);
  __halt();
}
// 400706: positive sp value 8 has been found
// 40070D: variable 'v3' is possibly undefined

//----- (0000000000400730) ----------------------------------------------------
void *sub_400730()
{
  return &unk_6020C8;
}

//----- (0000000000400760) ----------------------------------------------------
__int64 sub_400760()
{
  return 0LL;
}

//----- (00000000004007A0) ----------------------------------------------------
void *sub_4007A0()
{
  void *result; // rax

  if ( !byte_6020E0 )
  {
    result = sub_400730();
    byte_6020E0 = 1;
  }
  return result;
}
// 6020E0: using guessed type char byte_6020E0;

//----- (00000000004007D0) ----------------------------------------------------
__int64 sub_4007D0()
{
  return sub_400760();
}

//----- (00000000004007D7) ----------------------------------------------------
__int64 __fastcall main(int a1, char **a2, char **a3)
{
  size_t v3; // rax
  size_t v4; // rax
  int i; // [rsp+1Ch] [rbp-24h]
  int n; // [rsp+20h] [rbp-20h]
  int m; // [rsp+24h] [rbp-1Ch]
  int k; // [rsp+28h] [rbp-18h]
  int j; // [rsp+2Ch] [rbp-14h]

  if ( ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1 )
    goto LABEL_2;
  if ( a1 > 4 )
  {
    qword_602148 = strtol(a2[1], 0LL, 10);
    if ( qword_602148 )
    {
      qword_602150 = strtol(a2[2], 0LL, 10);
      if ( qword_602150 )
      {
        qword_602158 = strtol(a2[3], 0LL, 10);
        if ( qword_602158 )
        {
          qword_602160 = strtol(a2[4], 0LL, 10);
          if ( qword_602160 )
          {
            if ( -24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
              && 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
              && 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
              && -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613 )
            {
              qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;
              sprintf(byte_602141, "%06x", qword_602178);
              v4 = strlen(byte_602141);
              MD5(byte_602141, v4, byte_602110);
              for ( i = 0; i <= 15; ++i )
                sprintf(&byte_602120[2 * i], "%02x", (unsigned __int8)byte_602110[i]);
              printf(off_602080, byte_602120);
              exit(0);
            }
          }
        }
      }
    }
LABEL_2:
    printf("password : ");
    __isoc99_scanf("%s", &s1);
    if ( strlen(&s1) > 0x10 )
    {
      puts("the password must be less than 16 character");
      exit(1);
    }
    for ( j = 0; j < strlen(&s1); ++j )
      *(&s1 + j) ^= 6u;
    if ( !strcmp(&s1, a7yq2hryrn5yJga) )
    {
      v3 = strlen(&s1);
      MD5(&s1, v3, byte_602110);
      for ( k = 0; k <= 15; ++k )
        sprintf(&byte_602120[2 * k], "%02x", (unsigned __int8)byte_602110[k]);
      printf(off_602080, byte_602120);
      exit(0);
    }
    puts("bad password!");
    exit(0);
  }
  printf("password : ");
  __isoc99_scanf("%s", &s1);
  if ( strlen(&s1) > 0x10 )
  {
    puts("the password must be less than 16 character");
    exit(1);
  }
  for ( m = 0; m < strlen(&s1); ++m )
  {
    *(&s1 + m) ^= 2u;
    ++*(&s1 + m);
    *(&s1 + m) = ~*(&s1 + m);
  }
  if ( !memcmp(&s1, &unk_6020B8, 9uLL) )
  {
    for ( n = 0; n < strlen(aO6uH); n += 2 )
    {
      aO6uH[n] ^= 0x45u;
      aO6uH[n + 1] ^= 0x26u;
    }
    puts(aO6uH);
  }
  else
  {
    puts("bad password!");
  }
  return 0LL;
}
// 4006A0: using guessed type __int64 __fastcall MD5(_QWORD, _QWORD, _QWORD);
// 4006E0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 602148: using guessed type __int64 qword_602148;
// 602150: using guessed type __int64 qword_602150;
// 602158: using guessed type __int64 qword_602158;
// 602160: using guessed type __int64 qword_602160;
// 602178: using guessed type __int64 qword_602178;

//----- (0000000000400DE0) ----------------------------------------------------
void __fastcall init(unsigned int a1, __int64 a2, __int64 a3)
{
  signed __int64 v3; // rbp
  __int64 i; // rbx

  v3 = &off_601DF8 - &funcs_400E29;
  init_proc();
  if ( v3 )
  {
    for ( i = 0LL; i != v3; ++i )
      (*(&funcs_400E29 + i))();
  }
}
// 601DF0: using guessed type __int64 (__fastcall *funcs_400E29)();
// 601DF8: using guessed type __int64 (__fastcall *off_601DF8)();

//----- (0000000000400E54) ----------------------------------------------------
void term_proc()
{
  ;
}

// nfuncs=33 queued=10 decompiled=10 lumina nreq=0 worse=0 better=0
// ALL OK, 10 function(s) have been successfully decompiled

Análisis estático

Anti-debug

Si la función ptrace retorna -1, significa que el programa está siendo depurado y redirige a LABEL_2.

if (ptrace(PTRACE_TRACEME, 0LL, 0LL, 0LL) == -1) {
    goto LABEL_2;
}

Cálculos y validaciones

El programa espera al menos 5 argumentos (nombre del programa y cuatro números enteros). Si se proporcionan los cuatro números enteros, se realizan los siguientes cálculos:

if (-24 * qword_602148 - 18 * qword_602150 - 15 * qword_602158 - 12 * qword_602160 == -18393
    && 9 * qword_602158 + 18 * (qword_602150 + qword_602148) - 9 * qword_602160 == 4419
    && 4 * qword_602158 + 16 * qword_602148 + 12 * qword_602150 + 2 * qword_602160 == 7300
    && -6 * (qword_602150 + qword_602148) - 3 * qword_602158 - 11 * qword_602160 == -8613)

Esto es un sistema de ecuaciones lineales mondo y lirondo que debe ser resuelto para encontrar los valores correctos de qword_602148, qword_602150, qword_602158 y qword_602160. Una vez resuelto el sistema de ecuaciones se realiza la operación:

 qword_602178 = qword_602158 + qword_602150 * qword_602148 - qword_602160;

A continuación se pasa el resultado de la variable qword_602178 a hexadecimal y se genera su hash MD5.

Solución en Python

Lo más rápido en esta ocasión es usar Python, pero esto se puede resolver hasta con lápiz y papel 😉

from sympy import symbols, Eq, solve
import hashlib

# Definir las variables
A, B, C, D = symbols('A B C D')

# Definir las ecuaciones
eq1 = Eq(-24*A - 18*B - 15*C - 12*D, -18393)
eq2 = Eq(9*C + 18*(A + B) - 9*D, 4419)
eq3 = Eq(4*C + 16*A + 12*B + 2*D, 7300)
eq4 = Eq(-6*(A + B) - 3*C - 11*D, -8613)

# Resolver el sistema de ecuaciones
solution = solve((eq1, eq2, eq3, eq4), (A, B, C, D))

# Verificar si se encontró una solución
if solution:
    print("Solución encontrada:")
    print(solution)

    # Obtener los valores de A, B, C y D
    A_val = solution[A]
    B_val = solution[B]
    C_val = solution[C]
    D_val = solution[D]

    # Mostrar los valores encontrados
    print(f"A = {A_val}")
    print(f"B = {B_val}")
    print(f"C = {C_val}")
    print(f"D = {D_val}")

    # Calcular qword_602178
    qword_602178 = C_val + B_val * A_val - D_val
    qword_602178 = int(qword_602178)  # Convertir a entero de Python
    print(f"qword_602178 = {qword_602178}")

    # Convertir qword_602178 a una cadena en formato hexadecimal
    byte_602141 = f"{qword_602178:06x}"
    print(f"byte_602141 (hex) = {byte_602141}")

    # Calcular el MD5 de la cadena
    md5_hash = hashlib.md5(byte_602141.encode()).hexdigest()
    print(f"MD5 hash = {md5_hash}")

    # Generar la flag
    flag = f"FLAG-{md5_hash}"
    print(f"Flag = {flag}")

else:
    print("No se encontró una solución.")

Al ejecutar el script veremos algo como esto:

Solución encontrada:
{A: 227, B: 115, C: 317, D: 510}
A = 227
B = 115
C = 317
D = 510
qword_602178 = 25912
byte_602141 (hex) = 006538
MD5 hash = 21a84f2c7c7fd432edf1686215db....
Flag = FLAG-21a84f2c7c7fd432edf1686215db....

Keygen para el Crackme#8 de Kwazy Webbit – Comparación no lineal

26 agosto, 2014 por deurus·Sin comentarios

Primeras impresiones

El crackme es el típico de usuario y número de serie. Si no introduces un nombre te salta un messagebox indicándotelo y si introduces cualquier información sale un mensaje de error.

Si dejamos solamente el serial en blanco nos sale un mensaje de error muy interesante diciéndonos que introduzcamos un número entre 1 y 2^32. Por lo tanto ya sabemos que nuestro serial está entre 1 y 4294967296.

PEiD no arroja resultados pero una primera impresión con Ollydbg hace creer que está programado en ensamblador y que no está comprimido.

Al ataque con Ollydbg

Cargamos el crackme en Ollydbg y hacemos click derecho Search for > Names

Vemos dos referencias interesantes como son:

&USER32.GetDlgItemInt

&USER32.GetDlgItemTextA

Ponemos sendos breakpoints y damos al play.

Vemos que para en USER32.GetDlgItemTextAy que retorna al offset 4010E7

Vamos a 4010E7 y vemos que pasa.

Hace un Test eax,eax por si hemos introducido algún nombre y si no es así nos muestra la nag.

Continuamos con la ejecución y para en el siguiente breakpoint, esta vez el referente a USER32.GetDlgItemInt, vamos al offset 401108 a ver que nos espera.

Se puede ver claramente que carga en EAX nuestro número de serie en hexa, lo compara con ESI que vale 0 y si son iguales nag de error y si no continua a 401120 donde guarda en la pila nuestro nombre y serial y llama al offset 401000.

Veamos que hay en el offset 401000.

Aquí vemos una primera parte con un bucle en el que interviene nuestro nombre y donde obtendremos el “HashName” y posteriormente una operaciones aritméticas en las que finalmente modifica el valor de EAX. Tengamos en cuenta que la comprobación final es un Test eax,eax o lo que es lo mismo, comprueba si EAX = 0 y si es 0 salta al mensaje de error como vemos en la imagen siguiente.

En resumen:

Obtenemos el HashName.

Realizamos unas operaciones a ese HashName (LOCAL.1) y al serial introducido (ARG.2).

Si EAX <> 0 entonces serial correcto.

Sacando el “HashName”

Veamos un ejemplo de obtención del hashname para el usuario “abc”. El bucle se repetirá tantas veces como letras tenga el nombre.

Entendiendo la comprobación del serial

En resumen:

Necesitamos que EAX <> 0.

Necesitamos que (HashName XOR Serial) = 0 ya que:

a. La negación de 0 es 0 –>NEG(0) = 0

b. La resta con acarreo de 0 – 0 = 0 –>SBB 0,0 = 0

Hay que tener en cuenta que la resta con acarreo (SBB) de cualquier número, dará como resultado en EAX = FFFFFFFF, que al incrementar en 1 quedará en 0.

Por lo tanto si cumplimos las condiciones anteriormente expuestas, al incrementar EAX con INC EAX, este quedará en 1 haciendo nuestro serial válido.

Generando el serial válido

Las operaciones que se realizan sobre nuestro serial son NOT, SUB y XOR. Por suerte para nosotros son reversibles quedando nuestro serial así:

Serial válido = [NOT(HashName) + 0xBADC0DE5] XOR 0x1337C0DE

Para el nombre “abc” sería:

[(NOT(734111798) + 3134983653)] XOR 322420958 = 2620237168

Keygen en ensamblador

Como no es propósito de este manual enseñar a hacer un keygen desde 0, muestro el código importante y adjunto los links del código fuente. Si quieres ver como se hace un keygen básico en ASM desde cero mira el tutorial del Keygen para el KeygenMe#01 de eBuC.

Enlaces

Crackme + Keygen en ASM + WinASM studio 5.1.5 [31MB]

Yoire PE Stage 3 Reversing Challenge (Benten) - Fuerza Bruta

Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si

Migas de pan

Se nos entrega el siguiente ELF: Extracción de la Flag Si nos fijamos en las líneas 41 a la 45

Blooper Tech Movie X - Misión Imposible

Intro La primera entrega de Misión Imposible es ya un clásico y poco o nada tiene que envidiar a sus

Video Tutorial - Crackme#3 by spoke3FFF - Registros

Aquí os dejo un video tutorial. El crackme lo podeis encontrar en crackmes.de.

« Previous 1 2 3 4 … 30 Next »

Keygen para el Crackme 1 de VisionZ

26 julio, 2020 por deurus·Sin comentarios

Table of Contents

Intro

Aquí tenemos un crackme clásico realizado en Visual C++. La única particularidad que tiene es que no muestra MessageBox al introducir bien o mal el serial, simplemente cambia una imagen de un emoticono. Si observamos el comportamiento del crackme notaremos que inicialmente el emoticono está neutral y al fallar se pone triste y por lo tanto es de suponer que al acertar se pondrá contento.

El BreakPoint

Al mirar en las Intermodular Calls de OllyDbg vemos que LoadIconA es un buen candidato para ubicar la comprobación del serial. Si nos fijamos hay tres llamadas, ponemos un breakpoint en las tres y enseguida llegamos a la zona de comprobación del serial.

La comprobación

00401180   . 6A FF          PUSH -1
00401182   . 68 68194000    PUSH CrackMe_.00401968
00401187   . 64:A1 00000000 MOV EAX,DWORD PTR FS:[0]
0040118D   . 50             PUSH EAX
0040118E   . 64:8925 000000>MOV DWORD PTR FS:[0],ESP
00401195   . 83EC 0C        SUB ESP,0C
00401198   . 53             PUSH EBX
00401199   . 55             PUSH EBP
0040119A   . 8BE9           MOV EBP,ECX
0040119C   . 56             PUSH ESI
0040119D   . 57             PUSH EDI
0040119E   . 8D4C24 10      LEA ECX,DWORD PTR SS:[ESP+10]
004011A2   . E8 2F050000    CALL <JMP.&MFC42.#540>
004011A7   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
004011AB   . C74424 24 0000>MOV DWORD PTR SS:[ESP+24],0
004011B3   . E8 1E050000    CALL <JMP.&MFC42.#540>
004011B8   . 8D4424 10      LEA EAX,DWORD PTR SS:[ESP+10]
004011BC   . 8BCD           MOV ECX,EBP
004011BE   . 50             PUSH EAX
004011BF   . 68 E9030000    PUSH 3E9
004011C4   . C64424 2C 01   MOV BYTE PTR SS:[ESP+2C],1
004011C9   . E8 02050000    CALL <JMP.&MFC42.#3097>                  ;  Lee el tamano del nombre
004011CE   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
004011D2   . 51             PUSH ECX
004011D3   . 68 EA030000    PUSH 3EA
004011D8   . 8BCD           MOV ECX,EBP
004011DA   . E8 F1040000    CALL <JMP.&MFC42.#3097>                  ;  Lee el tamano del serial
004011DF   . 51             PUSH ECX
004011E0   . 8D5424 14      LEA EDX,DWORD PTR SS:[ESP+14]
004011E4   . 8BCC           MOV ECX,ESP
004011E6   . 896424 1C      MOV DWORD PTR SS:[ESP+1C],ESP
004011EA   . 52             PUSH EDX
004011EB   . E8 DA040000    CALL <JMP.&MFC42.#535>
004011F0   . 8D4424 1C      LEA EAX,DWORD PTR SS:[ESP+1C]   
004011F4   . 8BCD           MOV ECX,EBP       
004011F6   . 50             PUSH EAX                 
004011F7   . E8 D4010000    CALL CrackMe_.004013D0 
004011FC   . 50             PUSH EAX
004011FD   . 8D4C24 14      LEA ECX,DWORD PTR SS:[ESP+14]
00401201   . C64424 28 02   MOV BYTE PTR SS:[ESP+28],2
00401206   . E8 B9040000    CALL <JMP.&MFC42.#858>
0040120B   . 8D4C24 18      LEA ECX,DWORD PTR SS:[ESP+18]
0040120F   . C64424 24 01   MOV BYTE PTR SS:[ESP+24],1
00401214   . E8 A5040000    CALL <JMP.&MFC42.#800>
00401219   . 8B4C24 10      MOV ECX,DWORD PTR SS:[ESP+10]
0040121D   . 8B5424 14      MOV EDX,DWORD PTR SS:[ESP+14]
00401221   . 8B41 F8        MOV EAX,DWORD PTR DS:[ECX-8]
00401224   . 8B4A F8        MOV ECX,DWORD PTR DS:[EDX-8]
00401227   . 3BC1           CMP EAX,ECX                              ;  CMP len nombre y len serial
00401229   . 0F85 2C010000  JNZ CrackMe_.0040135B
0040122F   . 83F8 03        CMP EAX,3                                ;  len nombre >=3
00401232   . 0F8C 23010000  JL CrackMe_.0040135B
00401238   . 50             PUSH EAX
00401239   . E8 7A040000    CALL <JMP.&MFC42.#823>
0040123E   . 8BF0           MOV ESI,EAX
00401240   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
00401244   . 83C4 04        ADD ESP,4
00401247   . 33C9           XOR ECX,ECX
00401249   . 8B50 F8        MOV EDX,DWORD PTR DS:[EAX-8]
0040124C   . 4A             DEC EDX
0040124D   . 85D2           TEST EDX,EDX
0040124F   . 7E 37          JLE SHORT CrackMe_.00401288
.......
1ºBUCLE
.......
00401251   > 8A1401         MOV DL,BYTE PTR DS:[ECX+EAX]
00401254   . 8A5C01 01      MOV BL,BYTE PTR DS:[ECX+EAX+1]
00401258   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
0040125C   . 0FBED2         MOVSX EDX,DL
0040125F   . 0FBE0401       MOVSX EAX,BYTE PTR DS:[ECX+EAX]
00401263   . 8D4410 FE      LEA EAX,DWORD PTR DS:[EAX+EDX-2]
00401267   . 99             CDQ
00401268   . 2BC2           SUB EAX,EDX
0040126A   . 0FBED3         MOVSX EDX,BL
0040126D   . D1F8           SAR EAX,1
0040126F   . 40             INC EAX
00401270   . 83EA 02        SUB EDX,2
00401273   . 3BC2           CMP EAX,EDX
00401275   . 0F94C0         SETE AL
00401278   . 880431         MOV BYTE PTR DS:[ECX+ESI],AL
0040127B   . 8B4424 10      MOV EAX,DWORD PTR SS:[ESP+10]
0040127F   . 41             INC ECX
00401280   . 8B50 F8        MOV EDX,DWORD PTR DS:[EAX-8]
00401283   . 4A             DEC EDX
00401284   . 3BCA           CMP ECX,EDX
00401286   .^7C C9          JL SHORT CrackMe_.00401251
........
Última comprobación
........
00401288   > 0FBE1401       MOVSX EDX,BYTE PTR DS:[ECX+EAX]
0040128C   . 0FBE78 01      MOVSX EDI,BYTE PTR DS:[EAX+1]
00401290   . 8B4424 14      MOV EAX,DWORD PTR SS:[ESP+14]
00401294   . 83C7 FE        ADD EDI,-2
00401297   . 0FBE0401       MOVSX EAX,BYTE PTR DS:[ECX+EAX]
0040129B   . 8D4410 FE      LEA EAX,DWORD PTR DS:[EAX+EDX-2]
0040129F   . 99             CDQ
004012A0   . 2BC2           SUB EAX,EDX
004012A2   . D1F8           SAR EAX,1
004012A4   . 40             INC EAX
004012A5   . 3BC7           CMP EAX,EDI
004012A7   . 0F94C2         SETE DL
004012AA   . 881431         MOV BYTE PTR DS:[ECX+ESI],DL

La comprobación es muy sencilla, en resumen hace esto con todas las letras del nombre excepto la última:

1º Caracter
(1ºname + 1ºserial - 2 = X)
(X / 2)
(X + 1)
(2ºname - 2 = Y)
¿Y = X?
2º Caracter
(2ºname + 2ºserial - 2 = X)
(X / 2)
(X + 1)
(3ºname - 2 = Y)
¿Y = X?
...
Con el último caracter del nombre hace lo siguiente:
(6ºname + 6ºserial - 2 = X)
(X / 2)
(X + 1)
(2ºname - 2 = Y)
¿Y = X?
---------
Para revertir la primera parte de la comprobación para el nombre deurus quedaría:
X1 = (((2ºname-2-1)*2)+2)-1ºname
X2 = (((3ºname-2-1)*2)+2)-2ºname
X3 = (((4ºname-2-1)*2)+2)-3ºname
X4 = (((5ºname-2-1)*2)+2)-4ºname
X5 = (((6ºname-2-1)*2)+2)-5ºname
X6 = (((2ºname-2-1)*2)+2)-6ºname

Keygen

var nombre = "deurus";
nombre = nombre.toUpperCase();
var serial = "";
var tmp = "";

var i;
for (i = 0; i < nombre.length-1 ; i++) {
  tmp = ((nombre.charCodeAt(i+1)-2-1)*2+2)-nombre.charCodeAt(i);
  serial += String.fromCharCode(tmp);
}

tmp = ((nombre.charCodeAt(1)-2-1)*2+2)-nombre.charCodeAt(nombre.length-1);
serial += String.fromCharCode(tmp);

document.write(serial);

Enlaces

Y eso es todo, ¡a disfrutar!

Keygen para el CrackMe Pythagoras de Spider

24 abril, 2017 por deurus·Sin comentarios

Table of Contents

Introducción

Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por eso, vamos a tener que lidiar con ciertas peculiaridades al realizar el keygen con un lenguaje de bajo nivel.

Al inicio comprueba la longitud del nombre y de el número de serie. El nombre debe tener al menos 6 caracteres y el número de serie debe tener 10. Os adelanto ya que la asignación de memoria del nombre es de 9 caracteres, es decir, da igual la longitud del nombre que solo va a usar 9.

004014AD | E8 1A 02 00 00           | call <pythagoras.GetWindowTextA>        | ;Lee el nombre
004014B2 | 83 F8 06                 | cmp eax,6                               | ;Nombre >=6 caracteres
004014B5 | 0F 82 03 01 00 00        | jb pythagoras.4015BE                    |
004014BB | 6A 14                    | push 14                                 |
004014BD | 68 D9 31 40 00           | push pythagoras.4031D9                  | ;004031D9:"1234567890"
004014C2 | FF 35 10 32 40 00        | push dword ptr ds:[403210]              |
004014C8 | E8 FF 01 00 00           | call <pythagoras.GetWindowTextA>        | ;Lee el serial
004014CD | 83 F8 0A                 | cmp eax,A                               | ;Serial debe tener 10 (A) caracteres
004014D0 | 0F 85 E8 00 00 00        | jne pythagoras.4015BE                   |

Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890

A continuación chequea que nuestro serial tenga caracteres hexadecimales.

004014DA | 8A 81 D9 31 40 00        | mov al,byte ptr ds:[ecx+4031D9]         | ; ecx+004031D9:"1234567890"
004014E0 | 3C 00                    | cmp al,0                                | ; contador del bucle
004014E2 | 74 1F                    | je pythagoras.401503                    | ; fin del bucle
004014E4 | 3C 30                    | cmp al,30                               | ; 0x30 = número 1
004014E6 | 0F 82 D2 00 00 00        | jb pythagoras.4015BE                    | ; < 30 bad boy
004014EC | 3C 46                    | cmp al,46                               | ; 0x46 = letra F
004014EE | 0F 87 CA 00 00 00        | ja pythagoras.4015BE                    | ; > 46 bad boy
004014F4 | 3C 39                    | cmp al,39                               | ; 0x39 = número 9
004014F6 | 76 08                    | jbe pythagoras.401500                   | ; <=39 ok continua el bucle
004014F8 | 3C 41                    | cmp al,41                               | ; 0x41 = letra A
004014FA | 0F 82 BE 00 00 00        | jb pythagoras.4015BE                    | ; <41 bad boy
00401500 | 41                       | inc ecx                                 | ; contador += 1
00401501 | EB D7                    | jmp pythagoras.4014DA                   | ; bucle

Continua realizando un sumatorio con nuestro nombre, pero tenemos que tener especial cuidado al tratamiento de los datos, ya que el crackme al estar hecho en ensamblador puede jugar con los registros como quiere y eso nos puede inducir a error.

0040150B | 3C 00                    | cmp al,0                                | ; ¿Fin bucle?
0040150D | 74 05                    | je pythagoras.401514                    | ; Salta fuera del bucle si procede
0040150F | 02 D8                    | add bl,al                               | ; bl = bl + al
00401511 | 41                       | inc ecx                                 | ; contador +=1
00401512 | EB F1                    | jmp pythagoras.401505                   | ; bucle

Si os fijáis utiliza registros de 8 bits como son AL y BL. Debajo os dejo una explicación de EAX pero para EBX es lo mismo.

               EAX
-----------------------------------
                         AX
                  -----------------
                     AH       AL
                  -------- --------
00000000 00000000 00000000 00000000
 (8bit)   (8bit)   (8bit)   (8bit)
 

  EAX     (32 bit)
--------
     AX   (16 bit)
    ----
    AHAL  (AH y AL 8 bit)
--------
00000000

El uso de registros de 8 bits nos implica tomar precauciones al realizar el Keygen debido a que por ejemplo, en .Net no tenemos la capacidad de decirle que haga una suma y que nos devuelva solamente 8 bits del resultado. Veamos como ejemplo para el nombre «deurus». La suma de los caracteres hexadecimales quedaría:

64+65+75+72+75+73 = 298, es decir, EAX = 00000298

Pero recordad que el crackme solo cogerá el 98 que es lo correspondiente al registro AL. De momento nos quedamos con nuestro SUMNOMBRE = 98.

Primera condición

A continuación coge los dos primeros caracteres del serial y les resta nuestro SUMNOMBRE y comprueba que el resultado esté entre 4 (0x4) y -4 (0xFC).

0040154B | 0F B6 05 F3 31 40 00     | movzx eax,byte ptr ds:[4031F3]          |
00401552 | 8A C8                    | mov cl,al                               |
00401554 | 2A CB                    | sub cl,bl                               | ; CL = CL - BL | CL = 12 - 98 = 7A
00401556 | 80 F9 04                 | cmp cl,4                                | ; Compara CL con 4
00401559 | 7F 63                    | jg pythagoras.4015BE                    | ; Salta si es mayor
0040155B | 80 F9 FC                 | cmp cl,FC                               | ; Compara CL con FC (-4)
0040155E | 7C 5E                    | jl pythagoras.4015BE                    | ; Salta si es menor

Como veis, el resultado de la resta da 7A (122) que al ser mayor que 4 nos echa vilmente. Aquí de nuevo utiliza registros de 8 bits por lo que debemos tener cuidado con las operaciones matemáticas para no cometer errores, veamos un ejemplo para clarificar de aquí en adelante.

Utilizando 8 bits
-----------------
12 - 98 = 7A que en decimal es 122

Utilizando 16 bits
------------------
0012 - 0098 = FF7A que en decimal es -134

Ahora ya veis la diferencia entre FC (252) y FFFC (-4). Estrictamente, el crackme comprueba el rango entre 4 (4) y FC (122) al trabajar con registros de 8 bits pero nosotros, como veremos más adelante tomaremos el rango entre 4 y -4. De momento, para poder continuar depurando cambiamos los dos primeros caracteres del serial de 12 a 98, ya que 98 – 98 = 0 y cumple la condición anterior.

Introducimos Nombre: deurus y Serial: 9834567890

Segunda condición

Analicemos el siguiente código.

00401560 | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
00401562 | 8B D8                    | mov ebx,eax                             | ; EBX = EAX
00401564 | 0F B7 05 F4 31 40 00     | movzx eax,word ptr ds:[4031F4]          | ; EAX = 3456 (4 dígitos siguientes del serial)
0040156B | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
0040156D | 03 D8                    | add ebx,eax                             | ; EBX = EBX + EAX
0040156F | 0F B7 05 F6 31 40 00     | movzx eax,word ptr ds:[4031F6]          | ; EAX = 7890 (4 últimos dígitos del serial)
00401576 | F7 E0                    | mul eax                                 | ; EAX = EAX * EAX
00401578 | 33 C3                    | xor eax,ebx                             | ; EAX
0040157A | 75 42                    | jne pythagoras.4015BE                   | ; Salta si el flag ZF no se activa

En resumen:

98 * 98 = 5A40 (98²)
3456 * 3456 = 0AB30CE4 (3456²)
0AB36724 + 5A40 = 0AB36724
7890 * 7890 = 38C75100 (7890²)
38C75100 XOR 0AB36724 = 32743624
Si el resultado del XOR no es cero nuestro serial no pasa la comprobación.

Es decir, Pitágoras entra en escena -> 7890² = 98² + 3456²

Serial = aabbbbcccc

Tercera condición

Finalmente comprueba lo siguiente:

0040157C | 66 A1 F6 31 40 00        | mov ax,word ptr ds:[4031F6]             | ; AX = 7890
00401582 | 66 2B 05 F4 31 40 00     | sub ax,word ptr ds:[4031F4]             | ; AX = 7890 - 3456 = 443A
00401589 | 2C 08                    | sub al,8                                | ; AL = 3A - 8 = 32
0040158B | 75 31                    | jne pythagoras.4015BE                   | ; Si el resultado de la resta no ha sido cero, serial no válido
0040158D | 6A 30                    | push 30                                 |
0040158F | 68 B0 31 40 00           | push pythagoras.4031B0                  | ;004031B0:":-) Well done!!!"
00401594 | 68 7F 31 40 00           | push pythagoras.40317F                  | ;0040317F:"Bravo, hai trovato il seriale di questo CrackMe!"
00401599 | FF 75 08                 | push dword ptr ds:[ebp+8]               |

En resumen:

7890 – 3456 – 8 = 0

Creación del Keygen

Nuestro serial tiene que cumplir tres condiciones para ser válido.

a – SUMNOMBRE debe estar entre 4 y -4
c² = a² + b²
c – b – 8 = 0

Como hemos dicho anteriormente, tomaremos el SUMNOMBRE y le sumaremos y restaremos valores siempre y cuando el resultado esté entre 4 y -4. Para deurus hemos dicho que el SUMNOMBRE es 98 por lo que los posibles valores de «a» se pueden ver debajo. Además debemos tener en cuenta que el crackme solo lee los 9 primeros dígitos del nombre.

Es evidente que para encontrar el valor de «c» vamos a tener que utilizar fuerza bruta chequeando todos los valores de «b» comprendidos entre 0 y FFFF (65535). Además, como trabajaremos en un lenguaje de alto nivel, debemos descartar los resultados decimales. Esto nos limitará los seriales válidos asociados a un determinado nombre. Si realizáramos el keygen en ensamblador obtendríamos bastantes más seriales válidos.

Una vez encontrados los valores enteros de la operación «c² = a² + b²», se debe cumplir que «c – b – 8 = 0», lo que nos limitará bastante los resultados.

    Private Sub btn_generar_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btn_generar.Click
        Try
            If txt_nombre.TextLength > 5 Then
                lst_serials.Items.Clear()
                Dim tmp, c, cx As String
                Dim sumanombre, tmp2 As Integer
                If txt_nombre.TextLength > 9 Then tmp2 = 8 Else tmp2 = txt_nombre.TextLength - 1
                'Calculo el SUMNOMBRE
                For i = 0 To tmp2
                    sumanombre += Asc(Mid(txt_nombre.Text, i + 1, 1)) 'Acumulo suma
                    tmp = Strings.Right(Hex(sumanombre).ToString, 2)  'Solo 8 bits (Registro AL)
                    sumanombre = Val("&H" & tmp) 'Paso a decimal
                Next
                tmp = Strings.Right(Hex(sumanombre).ToString, 2)
                sumanombre = CInt("&H" & tmp)
                txtdebug.Text = "- SumNombre = " & Hex(sumanombre) & vbCrLf
                txtdebug.Text &= "----------------------------------------------" & vbCrLf
                Dim a(8) As Integer
                '
                'a - sumanombre >=4 y <=4
                '
                a(0) = sumanombre - 4
                a(1) = sumanombre - 3
                a(2) = sumanombre - 2
                a(3) = sumanombre - 1
                a(4) = sumanombre
                a(5) = sumanombre + 1
                a(6) = sumanombre + 2
                a(7) = sumanombre + 3
                a(8) = sumanombre + 4
                txtdebug.Text &= "- Posibles valores de 'a'" & vbCrLf
                For i = 0 To a.Length - 1
                    txtdebug.Text &= Hex(a(i)) & " "
                Next
                txtdebug.Text &= "----------------------------------------------" & vbCrLf
                txtdebug.Text &= "- Buscando valores de b y c" & vbCrLf
                txtdebug.Text &= "Serial = aabbbbcccc" & vbCrLf
                '
                'c = sqr(a^2 + b^2)
                '
                txtdebug.Text &= "(1) c = raiz(a^2 + b^2)" & vbCrLf
                txtdebug.Text &= "(2) c - b - 8 = 0" & vbCrLf
                For i = 0 To a.Length - 1 ' todas las posibilidades de a
                    For b = 0 To 65535 'b -> 0000 - FFFF
                        c = Math.Sqrt(a(i) ^ 2 + b ^ 2)
                        If c.Contains(".") Then 'busco enteros
                        Else
                            cx = c - b - 8
                            cx = Hex(cx).PadLeft(4, "0"c)
                            lbl_info.Text = cx
                            If cx = "0000" Then
                                txtdebug.Text &= " (1) " & Hex(c).PadLeft(4, "0"c) & " = raiz(" & Hex(a(i)).PadLeft(2, "0"c) & "^2 + " & Hex(b).PadLeft(4, "0"c) & "^2)" & vbCrLf
                                lst_serials.Items.Add(Hex(a(i)).PadLeft(2, "0"c) & Hex(b).PadLeft(4, "0"c) & Hex(c).PadLeft(4, "0"c))
                                txtdebug.Text &= " (2) " & Hex(c).PadLeft(4, "0"c) & " - " & Hex(b).PadLeft(4, "0"c) & " - 8 = 0" & vbCrLf
                            End If
                        End If
                        Application.DoEvents()
                    Next
                Next
                lbl_info.Text = "Búsqueda finalizada"
            End If
        Catch ex As Exception
            MsgBox(ex.ToString)
        End Try

Enlaces

Solución a los CrackMes de CrkViZ 1-5

12 marzo, 2015 por deurus·1 comentario

Introducción
Herramientas disponibles
CrkViz-1 (Serial a la vista)
CrkViz-2 (Parcheando rutina aleatoria)
CrkViz-3 (Nag+Keygen)
CrkViz-4 (Límite de ejecuciones+Keygen)
CrkViz-5 (Serial a la vista)
Notas finales
Enlaces

Table of Contents

Introducción

Esta vez vamos a analizar los CrackMes de un antiguo colaborador de Karpoff Spanish Tutor, CrkViZ. En estas cinco soluciones vamos a pelearnos con Visual Basic 5/6 nativo y Pcode, con el registro de Windows y tendremos que parchear algúna rutina antidebug. Los CrackMes son del año 2000 y aunque algunos estaban ya solucionados, los analizaremos igualmente para ver la diferencia que existe con los análisis realizados en aquellos años, sí, estamos hablando del Softice.

Herramientas disponibles

Cuando hablamos de Visual Basic 5/6, podemos destacar 3 herramientas que nos facilitan mucho la vida, VB Decompiler, VB Reformer y ExDec. Las dos primeras se defienden bien tanto con código nativo como pcode y ExDec solamente nos sirve para pcode. Aún así, si todo lo demás falla, Ollydbg nos sacará de apuros.

CrkViz-1

Este primer crackme está compilado en Pcode y hoy día, con las herramientas de que disponemos no supone ninguna dificultad. Tan solo debemos abrirlo con VB Decompiler y ya nos encontramos con el serial válido.

Los opcodes obtenidos con ExDec se ven de la siguiente manera.

......
402F14: 04 FLdRfVar                local_008C
402F17: 21 FLdPrThis              
402F18: 0f VCallAd                 7b3fc340
402F1B: 19 FStAdFunc               local_0088
402F1E: 08 FLdPr                   local_0088
402F21: 0d VCallHresult            7b3fbe88
402F26: 6c ILdRf                   local_008C
402F29: 1b LitStr:                 57230198        <--------------
402F2C: Lead0/30 EqStr            
402F2E: 2f FFree1Str               local_008C
402F31: 1a FFree1Ad                local_0088
402F34: 1c BranchF:                403012
402F37: 21 FLdPrThis              
402F38: 0d VCallHresult            7b3fc2b0
402F3D: 3a LitVarStr:              ( local_00AC )  Gracias por Registrar!!      
402F42: Lead2/00 FStVarCopy       
402F46: 27 LitVar_Missing         
402F49: 27 LitVar_Missing         
402F4C: 3a LitVarStr:              ( local_00AC ) CrkViz
402F51: 4e FStVarCopyObj           local_00BC
402F54: 04 FLdRfVar                local_00BC
402F57: f5 LitI4:                  0x40  64  (...@)
402F5C: 04 FLdRfVar                local_009C
402F5F: 0a ImpAdCallFPR4:          _rtcMsgBox
402F64: 36 FFreeVar
402F6D: 27 LitVar_Missing         
402F70: 25 PopAdLdVar             
402F71: 27 LitVar_Missing
......

CrkViz-2

Este segundo crackme también está compilado en pcode. La rutina del serial es muy sencilla pero al introducir un número aleatorio nos obliga a parchear. Cargamos el crackme en VB Decompiler y nos muestra esto:

Básicamente vemos que genera un número aleatorio entre 1 y 999999999 y luego le suma 1. La forma de afrontar esto es parcheando. Nos fijamos en el offset aproximado (4037F2) y abrimos el crackme en un editor hexadecimal. La forma de convertir el offset que nos muestra VB Decompiler a lo que nos muestra un editor hexadecimal es la siguiente.

VBdec_offset - Image Base - VirtualOffset + RawOffset = Offset_Editor.H

4037F2 - 400000 - 1000 + 400 = 2BF2

Una vez localizados los bytes, los cambiamos por ceros y guardamos.

Una vez parcheado, el serial correcto es 1.

CrkViz-3

En esta tercera entrega, CrkViz aumentó la dificultad. El crackme está compilado en código nativo y nos enfrentamos a un serial asociado a un nombre y a una rutina antidebug que en realidad es una Nag, ya que se muestra siempre.

Afrontar la nag es muy sencillo, basta con localizarla y parchear la llamada.

CPU Disasm
Address   Hex dump          Command                                            Comments
004058E2    8D4D DC         LEA ECX,[EBP-24]
004058E5    C785 BCFDFFFF B MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.004033B8     ; UNICODE "  Debugger detectado!!!   "
004058EF    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8
004058F9    FFD7            CALL EDI
004058FB    B9 04000280     MOV ECX,80020004
00405900    B8 0A000000     MOV EAX,0A
00405905    898D FCFDFFFF   MOV DWORD PTR SS:[EBP-204],ECX
0040590B    898D 0CFEFFFF   MOV DWORD PTR SS:[EBP-1F4],ECX
00405911    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00405917    8D8D 14FEFFFF   LEA ECX,[EBP-1EC]
0040591D    8985 F4FDFFFF   MOV DWORD PTR SS:[EBP-20C],EAX
00405923    8985 04FEFFFF   MOV DWORD PTR SS:[EBP-1FC],EAX
00405929    C785 BCFDFFFF 8 MOV DWORD PTR SS:[EBP-244],CrkMeViz-3.00403188     ; UNICODE "Error"
00405933    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],8
0040593D    FF15 C8914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDup>]
00405943    8D85 F4FDFFFF   LEA EAX,[EBP-20C]
00405949    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
0040594F    50              PUSH EAX
00405950    8D95 14FEFFFF   LEA EDX,[EBP-1EC]
00405956    51              PUSH ECX
00405957    52              PUSH EDX
00405958    8D45 DC         LEA EAX,[EBP-24]
0040595B    6A 10           PUSH 10
0040595D    50              PUSH EAX
0040595E    FF15 50914000   CALL DWORD PTR DS:[<&MSVBVM50.#595>]               ; rtcMsgBox - NOPear para evitar la NAG
00405964    8D8D F4FDFFFF   LEA ECX,[EBP-20C]

Antes de llegar al keygen vemos que realiza unas llamadas al registro de Windows, ponemos un breakpoint «bp RegOpenKeyW» y ejecutamos.

CPU Disasm
Address   Hex dump            Command                                  Comments
00405677  |.  8B8D B8FDFFFF   MOV ECX,DWORD PTR SS:[EBP-248]
0040567D  |.  B8 54334000     MOV EAX,CrkMeViz-3.00403354              ; UNICODE "<Unregister>"
00405682  |.  68 B4304000     PUSH CrkMeViz-3.004030B4                 ; UNICODE "Serial number"
00405687  |.  894A 04         MOV DWORD PTR DS:[EDX+4],ECX
0040568A  |.  8985 BCFDFFFF   MOV DWORD PTR SS:[EBP-244],EAX
00405690  |.  68 84304000     PUSH CrkMeViz-3.00403084                 ; UNICODE "Register"
00405695  |.  68 58304000     PUSH CrkMeViz-3.00403058                 ; UNICODE "CrkMeViz3"
0040569A  |.  8942 08         MOV DWORD PTR DS:[EDX+8],EAX
0040569D  |.  8B85 C0FDFFFF   MOV EAX,DWORD PTR SS:[EBP-240]
004056A3  |.  8942 0C         MOV DWORD PTR DS:[EDX+0C],EAX
004056A6  |.  FF15 C0914000   CALL DWORD PTR DS:[<&MSVBVM50.#689>] 	; rtcGetSetting - Lee el numero de serie del registro
........
0040574F  |.  68 9C304000     PUSH CrkMeViz-3.0040309C                  ; UNICODE "User Name"
00405754  |.  68 84304000     PUSH CrkMeViz-3.00403084                  ; UNICODE "Register"
00405759  |.  68 58304000     PUSH CrkMeViz-3.00403058                  ; UNICODE "CrkMeViz3"
0040575E  |.  8948 08         MOV DWORD PTR DS:[EAX+8],ECX
00405761  |.  8B8D C0FDFFFF   MOV ECX,DWORD PTR SS:[EBP-240]
00405767  |.  8948 0C         MOV DWORD PTR DS:[EAX+0C],ECX
0040576A  |.  FF15 C0914000   CALL DWORD PTR DS:[<&MSVBVM50.#689>]	; rtcGetSetting - Lee el Usuario del registro

Reconstruyendo la llamada al registro vemos que lee de esta ruta: HKEY_CURRENT_USER\Software\VB and VBA Program Settings\CrkMeViz3\Register el contenido de User Name y del Serial number.

Quizá uno de los fallos de éste crackme, es que no comprueba la autenticidad de estos parámetros y si los modificas parece que estás registrado. Un ejemplo:

La rutina de comprobación del serial no es para nada complicada pero recordemos que estamos tratando con VB y éste delega el trabajo duro en otras librerias de modo que tenemos que «meternos» a tracear las llamadas para ver los valores que multiplica y divide.

CPU Disasm
Address     Hex dump          Command                                            Comments
00405A86      FF15 3C914000   CALL DWORD PTR DS:[<&MSVBVM50.#518>]    ;MSVBVM50.rtcLowerCaseVar
00405A8C      8D95 14FEFFFF   LEA EDX,[EBP-1EC]
00405A92      8D8D ACFEFFFF   LEA ECX,[EBP-154]
00405A98      FFD6            CALL ESI
00405A9A      8D95 ACFEFFFF   LEA EDX,[EBP-154]
00405AA0      8D8D 4CFEFFFF   LEA ECX,[EBP-1B4]
00405AA6      FFD7            CALL EDI
00405AA8      8D95 4CFEFFFF   LEA EDX,[EBP-1B4]
00405AAE      8D8D 7CFFFFFF   LEA ECX,[EBP-84]
00405AB4      FFD7            CALL EDI
00405AB6      8D85 14FEFFFF   LEA EAX,[EBP-1EC]
00405ABC      8D8D 7CFFFFFF   LEA ECX,[EBP-84]
00405AC2      50              PUSH EAX
00405AC3      6A 01           PUSH 1
00405AC5      8D95 04FEFFFF   LEA EDX,[EBP-1FC]
00405ACB      51              PUSH ECX
00405ACC      52              PUSH EDX
00405ACD      C785 1CFEFFFF 0 MOV DWORD PTR SS:[EBP-1E4],1
00405AD7      C785 14FEFFFF 0 MOV DWORD PTR SS:[EBP-1EC],2
00405AE1      FF15 68914000   CALL DWORD PTR DS:[<&MSVBVM50.#632>]   ;MSVBVM50.rtcMidCharVar (Esto lo hace 6 veces, lo omito para abreviar.)
........
00405CE1      FF15 34914000   CALL DWORD PTR DS:[<&MSVBVM50.#516>]   ;MSVBVM50.rtcAnsiValueBstr (Lo mismo, otras 6)
........
00405E7C    C785 BCFDFFFF 2 MOV DWORD PTR SS:[EBP-244],52E
00405E86    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00405E90    50              PUSH EAX
00405E91    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
		|
		->MSVBVM50.__vbaVarMul
			........
			741C19D3      0FB745 FE       MOVZX EAX,WORD PTR SS:[EBP-2]       ;Valor1
			741C19D7      0FB74D F2       MOVZX ECX,WORD PTR SS:[EBP-0E]      ;Valor2
			741C19DB      6BC0 12         IMUL EAX,EAX,12                     ;Valor1*Valor2
			........
00405E97    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
00405E9D    50              PUSH EAX
00405E9E    51              PUSH ECX
00405E9F    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EA5    8D95 F4FDFFFF   LEA EDX,[EBP-20C]
00405EAB    50              PUSH EAX
00405EAC    52              PUSH EDX
00405EAD    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EB3    50              PUSH EAX
00405EB4    8D85 E4FDFFFF   LEA EAX,[EBP-21C]
00405EBA    50              PUSH EAX
00405EBB    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405EC1    8D8D D4FDFFFF   LEA ECX,[EBP-22C]
00405EC7    50              PUSH EAX
00405EC8    51              PUSH ECX
00405EC9    FF15 84914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00405ECF    50              PUSH EAX
00405ED0    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00405ED6    8D85 C4FDFFFF   LEA EAX,[EBP-23C]
00405EDC    52              PUSH EDX
00405EDD    50              PUSH EAX
00405EDE    FF15 94914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
		|
		->MSVBVM50.__vbaVarDiv
			........
			741C8094      DD43 08         FLD QWORD PTR DS:[EBX+8]      ;Recupera el resultado de las multiplicaciones anteriores
			741C8097      0FBF47 08       MOVSX EAX,WORD PTR DS:[EDI+8] ;EAX = 1326 (52E)
			741C809B      8945 F8         MOV DWORD PTR SS:[EBP-8],EAX
			741C809E      DA75 F8         FIDIV DWORD PTR SS:[EBP-8]    ;Divide los dos resultados
			741C80A1      DD5E 08         FSTP QWORD PTR DS:[ESI+8]
			........
00405F44      FF15 24914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]          ;Len(nombre)
........
00405F85      FF15 94914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]           ;Resultado anterior / Len(nombre)
........

En resumen:

Pasa nuestro nombre a minúsculas.
Obtiene el valor ascii de los 6 primeros dígitos del nombre.
Los multiplica entre sí y divide el resultado acumulado entre 1326 (52E).
Divide el resultado anterior entre el tamaño del nombre.

Ejemplo para deurus

64*65*75*72*75*73 = 1A605D70EB8
1A605D70EB8 / 52E = 5179FBF4
5179FBF4 / 6 = D9454A9

Al estar correctamente registrados desaparece el botón de registrar.

CrkViz-4

El cuarto crackme es prácticamente igual que el tercero salvo que en vez de nag ahora contamos con limitación de ejecuciones. Del mismo modo utiliza el registro de Windows para guardar los datos de registro y las ejecuciones que llevamos.

Ponemos un breakpoint «bp RegOpenKeyW» y llegamos a la conclusión de que la ruta es HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register y los valores se guardan en Counter, User Name y Serial number respectivamente. Este crackme hereda el fallo del anterior y si alteramos los valores el crackme nos muestra como usuarios autorizados, aunque sabemos que no estamos registrados ya que seguimos limitados por ejecuciones. Ni que decir tiene que lo mismo que modificamos el nombre y número de serie, podemos modificar el contador a nuestro favor. Crear un archivo «Reiniciar_contador.reg» con el siguiente contenido sería suficiente.

Windows Registry Editor Version 5.00

[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC]

[HKEY_CURRENT_USER\Software\VB and VBA Program Settings\ODBC\Register]
"Counter"="0"
"User Name"="deurus"
"Serial number"="12345"

El keygen es prácticamente igual que en el crackme anterior, solo cambia el divisor.

CPU Disasm
Address   Hex dump          Command                                                   Comments
........
00404BD2    C785 BCFDFFFF C MOV DWORD PTR SS:[EBP-244],6C1
00404BDC    C785 B4FDFFFF 0 MOV DWORD PTR SS:[EBP-24C],2
00404BE6    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
   |
    ->MSVBVM50.__vbaVarMul
	741C19F9    0FBF4F 08       MOVSX ECX,WORD PTR DS:[EDI+8]      ;Valor1
	741C19FD    0FBF43 08       MOVSX EAX,WORD PTR DS:[EBX+8]      ;Valor2
	741C1A01    0FAFC8          IMUL ECX,EAX                       ;Valor1*Valor2
........
00404BEC    8D8D 04FEFFFF   LEA ECX,[EBP-1FC]
00404BF2    50              PUSH EAX
00404BF3    51              PUSH ECX
00404BF4    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404BFA    8D95 F4FDFFFF   LEA EDX,[EBP-20C]
00404C00    50              PUSH EAX
00404C01    52              PUSH EDX
00404C02    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C08    50              PUSH EAX
00404C09    8D85 E4FDFFFF   LEA EAX,[EBP-21C]
00404C0F    50              PUSH EAX
00404C10    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C16    8D8D D4FDFFFF   LEA ECX,[EBP-22C]
00404C1C    50              PUSH EAX
00404C1D    51              PUSH ECX
00404C1E    FF15 A0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarMul>]
00404C24    50              PUSH EAX
00404C25    8D95 B4FDFFFF   LEA EDX,[EBP-24C]
00404C2B    8D85 C4FDFFFF   LEA EAX,[EBP-23C]
00404C31    52              PUSH EDX
00404C32    50              PUSH EAX
00404C33    FF15 B0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]
   |
    ->MSVBVM50.__vbaVarDiv
	741C8094    DD43 08         FLD QWORD PTR DS:[EBX+8]              ; Recupera el resultado de las multiplicaciones anteriores
	741C8097    0FBF47 08       MOVSX EAX,WORD PTR DS:[EDI+8]         ; EAX = 1729 (6C1)
	741C809B    8945 F8         MOV DWORD PTR SS:[EBP-8],EAX
	741C809E    DA75 F8         FIDIV DWORD PTR SS:[EBP-8]

00404C39    8BD0            MOV EDX,EAX
........
00404CA0    FF15 3C914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]  ;Len(nombre)
........
00404CF1    FF15 B0914000   CALL DWORD PTR DS:[<&MSVBVM50.__vbaVarDiv>]   ;Resultado anterior / Len(nombre)

En resumen:

Pasa nuestro nombre a minúsculas.
Obtiene el valor ascii de los 6 primeros dígitos del nombre.
Los multiplica entre sí y divide el resultado acumulado entre 1729 (6C1).
Divide el resultado anterior entre el tamaño del nombre.

Ejemplo para deurus

64*65*75*72*75*73 = 1A605D70EB8
1A605D70EB8 / 6C1 = 3E7C594A
3E7C594A / 6 = A6A0EE2

CrkViz-5

Este último crackme está compilado en código nativo y simplemente se trata de una comparación lineal. La única diferencia reside en que no hay botón de registro, la comprobación la gestiona un evento «On Change«, de modo que está comprobando el tamaño del serial que introducimos y cuando éste tiene 8 dígitos llegamos aquí.

........
0040A64F         .  C745 9C CDD4DD02    MOV DWORD PTR SS:[EBP-64],2DDD4CD      ;2DDD4CD = 48092365
0040A656         .  C745 94 03800000    MOV DWORD PTR SS:[EBP-6C],8003
0040A65D         .  FF15 08C14000       CALL DWORD PTR DS:[<&MSVBVM50.__vbaVa> ;MSVBVM50.__vbaVarTstEq
0040A663         .  66:85C0             TEST AX,AX
0040A666         .  0F84 BA000000       JE CrkMeViZ.0040A726                   ;Si salta BAD  BOY
........

Luego el serial correcto es 48092365.

Notas finales

¿Ha sido indoloro no?, claro que sí, Visual Basic es un coñazo de tracear pero hay que reconocer que con el tiempo las herramientas han mejorado mucho y nuestra vida es mucho más sencilla. Bueno, pués esto ha sido todo, como siempre os dejo todo el material utilizado y un Keygen.

Enlaces

QR Stego Challenge

15 septiembre, 2018 por deurus·Sin comentarios

AVISO: Debido a que este reto está en activo no publicaré a donde pertenece.

Ya sabéis que los retos stego son muy variopintos. El otro día me encontré con uno que parecía que iba a ser complejo pero en realidad era bastante sencillo.

Tras varias pruebas complejas infructuosas, se me ocurrió descomponer por canales y efectivamente ese era el camino. Para ello yo utilicé la herramienta StegSolve de mi querido Caesum, pero podéis resolverlo incluso online con Pinetools.

Categoría: Crackmes.de

Introducción

Desempacado

Eliminar la NAG

Password

Nº serie asociado a un nombre

Checkbox

Trackbar

Links

ELF Decompilado

Análisis estático

Anti-debug

Cálculos y validaciones

Solución en Python

Primeras impresiones

Al ataque con Ollydbg

Sacando el “HashName”

Entendiendo la comprobación del serial

Generando el serial válido

Keygen en ensamblador

Enlaces

Intro

El BreakPoint

La comprobación

Keygen

Enlaces

Introducción

Primera condición

Segunda condición

Tercera condición

Creación del Keygen

Enlaces

Introducción

Herramientas disponibles

CrkViz-1

CrkViz-2

CrkViz-3

CrkViz-4

CrkViz-5

Notas finales

Enlaces