Etiqueta: aspack

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.

Solución al PGC Official KeygenMe

14 agosto, 2020 por deurus·2 comentarios

Table of Contents

Introducción

Siguiendo con los crackmes que contienen RSA, esta vez tenemos un Keygenme del grupo PGC (Pirates Gone Crazy) que incluso servía para ser admitido en el grupo si mandabas la solución. Como veremos usa RSA32 + MD5 y en la parte de RSA ni siquiera usa el descifrado por lo que es de los sencillitos.

Resumen RSA

Parámetros

p = Primer número primo
q = Segundo número primo
e = Exponente público que cumpla MCD(e,(p-1)*(q-1))==1
n = Módulo público siendo n=p*q
d = Exponente privado que cumpla d=e^(-1) mod ((p-1)*(q-1))

De este modo e y n son la parte pública de la clave y d y n la parte privada. Los número primos p y q se utilizan solo para generar los parámetros y de ahí en adelante se pueden desechar.

Funciones de Cifrado/Descifrado

cifrado = descifrado ^ e mod n
descifrado = cifrado ^ d mod n

Debug

En las referencias de texto se ven a simple vista el exponente público e (10001) y el módulo n (8e701a4c793eb8b739166bb23b49e421)

Text strings referenced in RSA32+MD:.text
Address    Disassembly                                                     Text string
00401848   PUSH    RSA32+MD.00404104                                       ASCII "%.8x%.8x%.8x%.8x"
00401A72   PUSH    RSA32+MD.0040429C                                       ASCII "[PGCTRiAL/2oo2]"
00401AEE   PUSH    RSA32+MD.00404275                                       ASCII "10001"
00401AFE   PUSH    RSA32+MD.0040427B                                       ASCII "8e701a4c793eb8b739166bb23b49e421"
00401B43   PUSH    RSA32+MD.00404404                                       ASCII "Name Must Be >= 1 Character."
00401B57   PUSH    RSA32+MD.00404421                                       ASCII "Key Must Be >= 1 Character."
00401B6D   PUSH    RSA32+MD.0040443D                                       ASCII "Congratulations!"
00401B72   PUSH    RSA32+MD.0040444E                                       ASCII "                 You've done it!
Please send your keygen along with
source code to pgc@dangerous-minds.com
if you would like to be considered as
         a new member of PGC."
00401BE7   PUSH    0                                                       (Initial CPU selection)
00401C47   MOV     [DWORD SS:EBP-24],RSA32+MD.00404119                     ASCII "PGCWinClass"
00401C7C   MOV     [DWORD SS:EBP-24],RSA32+MD.0040424E                     ASCII "STATIC"
00401CDB   PUSH    RSA32+MD.00404115                                       ASCII "PGC"
00401CE0   PUSH    RSA32+MD.00404119                                       ASCII "PGCWinClass"
00401D13   PUSH    RSA32+MD.00404125                                       ASCII "EDIT"
00401D46   PUSH    RSA32+MD.00404125                                       ASCII "EDIT"
00401DFB   PUSH    RSA32+MD.00404115                                       ASCII "PGC"
00401E00   PUSH    RSA32+MD.0040424E                                       ASCII "STATIC"

Rutina de comprobación

00401A0E  /$  53            PUSH    EBX
00401A0F  |.  57            PUSH    EDI
00401A10  |.  56            PUSH    ESI
00401A11  |.  6A 11         PUSH    11                             ; /Count = 11 (17.)
00401A13  |.  68 AC424000   PUSH    RSA32+MD.004042AC              ; |Buffer = RSA32+MD.004042AC
00401A18  |.  FF35 94454000 PUSH    [DWORD DS:404594]              ; |hWnd = NULL
00401A1E  |.  E8 49080000   CALL    <JMP.&USER32.GetWindowTextA>   ; \GetWindowTextA
00401A23  |.  83F8 01       CMP     EAX,1
00401A26  |.  0F8C 17010000 JL      RSA32+MD.00401B43
00401A2C  |.  A3 6D424000   MOV     [DWORD DS:40426D],EAX
00401A31  |.  6A 22         PUSH    22                             ; /Count = 22 (34.)
00401A33  |.  68 BD424000   PUSH    RSA32+MD.004042BD              ; |Buffer = RSA32+MD.004042BD
00401A38  |.  FF35 98454000 PUSH    [DWORD DS:404598]              ; |hWnd = NULL
00401A3E  |.  E8 29080000   CALL    <JMP.&USER32.GetWindowTextA>   ; \GetWindowTextA
00401A43  |.  83F8 01       CMP     EAX,1
00401A46  |.  0F8C 0B010000 JL      RSA32+MD.00401B57
00401A4C  |.  A3 71424000   MOV     [DWORD DS:404271],EAX
00401A51  |.  6A 00         PUSH    0
00401A53  |.  E8 C8080000   CALL    RSA32+MD.00402320
00401A58  |.  A3 69424000   MOV     [DWORD DS:404269],EAX
00401A5D  |.  A1 71424000   MOV     EAX,[DWORD DS:404271]
00401A62  |.  FF35 69424000 PUSH    [DWORD DS:404269]              ; /Arg2 = 00000000
00401A68  |.  68 BD424000   PUSH    RSA32+MD.004042BD              ; |Arg1 = 004042BD
00401A6D  |.  E8 510A0000   CALL    RSA32+MD.004024C3              ; \RSA32+MD.004024C3
00401A72  |.  68 9C424000   PUSH    RSA32+MD.0040429C              ; /StringToAdd = "[PGCTRiAL/2oo2]"
00401A77  |.  68 AC424000   PUSH    RSA32+MD.004042AC              ; |ConcatString = ""
00401A7C  |.  E8 51080000   CALL    <JMP.&KERNEL32.lstrcatA>       ; \lstrcatA
00401A81  |.  68 AC424000   PUSH    RSA32+MD.004042AC              ; /String = ""
00401A86  |.  E8 4D080000   CALL    <JMP.&KERNEL32.lstrlenA>       ; \lstrlenA
00401A8B  |.  68 DF424000   PUSH    RSA32+MD.004042DF              ; /Arg4 = 004042DF
00401A90  |.  68 10454000   PUSH    RSA32+MD.00404510              ; |Arg3 = 00404510
00401A95  |.  50            PUSH    EAX                            ; |Arg2
00401A96  |.  68 AC424000   PUSH    RSA32+MD.004042AC              ; |Arg1 = 004042AC
00401A9B  |.  E8 60F5FFFF   CALL    RSA32+MD.00401000              ; \RSA32+MD.00401000
00401AA0  |.  6A 00         PUSH    0
00401AA2  |.  E8 79080000   CALL    RSA32+MD.00402320
00401AA7  |.  A3 5D424000   MOV     [DWORD DS:40425D],EAX
00401AAC  |.  6A 00         PUSH    0
00401AAE  |.  E8 6D080000   CALL    RSA32+MD.00402320
00401AB3  |.  A3 59424000   MOV     [DWORD DS:404259],EAX
00401AB8  |.  6A 00         PUSH    0
00401ABA  |.  E8 61080000   CALL    RSA32+MD.00402320
00401ABF  |.  A3 61424000   MOV     [DWORD DS:404261],EAX
00401AC4  |.  6A 00         PUSH    0
00401AC6  |.  E8 55080000   CALL    RSA32+MD.00402320
00401ACB  |.  A3 65424000   MOV     [DWORD DS:404265],EAX
00401AD0  |.  B8 02000000   MOV     EAX,2
00401AD5  |.  C1E0 04       SHL     EAX,4
00401AD8  |.  FF35 5D424000 PUSH    [DWORD DS:40425D]              ; /Arg2 = 00000000
00401ADE  |.  68 DF424000   PUSH    RSA32+MD.004042DF              ; |Arg1 = 004042DF
00401AE3  |.  E8 DB090000   CALL    RSA32+MD.004024C3              ; \RSA32+MD.004024C3
00401AE8  |.  FF35 65424000 PUSH    [DWORD DS:404265]              ; /Arg2 = 00000000
00401AEE  |.  68 75424000   PUSH    RSA32+MD.00404275              ; |Arg1 = 00404275 ASCII "10001"
00401AF3  |.  E8 CB090000   CALL    RSA32+MD.004024C3              ; \RSA32+MD.004024C3
00401AF8  |.  FF35 61424000 PUSH    [DWORD DS:404261]              ; /Arg2 = 00000000
00401AFE  |.  68 7B424000   PUSH    RSA32+MD.0040427B              ; |Arg1 = 0040427B ASCII "8e701a4c793eb8b739166bb23b49e421"
00401B03  |.  E8 BB090000   CALL    RSA32+MD.004024C3              ; \RSA32+MD.004024C3
00401B08  |.  FF35 59424000 PUSH    [DWORD DS:404259]
00401B0E  |.  FF35 61424000 PUSH    [DWORD DS:404261]
00401B14  |.  FF35 65424000 PUSH    [DWORD DS:404265]
00401B1A  |.  FF35 5D424000 PUSH    [DWORD DS:40425D]
00401B20  |.  E8 87120000   CALL    RSA32+MD.00402DAC
00401B25  |.  FF35 69424000 PUSH    [DWORD DS:404269]
00401B2B  |.  FF35 59424000 PUSH    [DWORD DS:404259]
00401B31  |.  E8 61080000   CALL    RSA32+MD.00402397
00401B36  |.  85C0          TEST    EAX,EAX
00401B38  |.  74 31         JE      SHORT RSA32+MD.00401B6B
00401B3A  |.  E8 85000000   CALL    RSA32+MD.00401BC4
00401B3F  |.  5E            POP     ESI
00401B40  |.  5F            POP     EDI
00401B41  |.  5B            POP     EBX
00401B42  |.  C3            RET
00401B43  |>  68 04444000   PUSH    RSA32+MD.00404404              ; /Text = "Name Must Be >= 1 Character."
00401B48  |.  FF35 98454000 PUSH    [DWORD DS:404598]              ; |hWnd = NULL
00401B4E  |.  E8 5B070000   CALL    <JMP.&USER32.SetWindowTextA>   ; \SetWindowTextA
00401B53  |.  5E            POP     ESI
00401B54  |.  5F            POP     EDI
00401B55  |.  5B            POP     EBX
00401B56  |.  C3            RET
00401B57  |>  68 21444000   PUSH    RSA32+MD.00404421              ; /Text = "Key Must Be >= 1 Character."
00401B5C  |.  FF35 98454000 PUSH    [DWORD DS:404598]              ; |hWnd = NULL
00401B62  |.  E8 47070000   CALL    <JMP.&USER32.SetWindowTextA>   ; \SetWindowTextA
00401B67  |.  5E            POP     ESI
00401B68  |.  5F            POP     EDI
00401B69  |.  5B            POP     EBX
00401B6A  |.  C3            RET
00401B6B  |>  6A 00         PUSH    0                              ; /Style = MB_OK|MB_APPLMODAL
00401B6D  |.  68 3D444000   PUSH    RSA32+MD.0040443D              ; |Title = "Congratulations!"
00401B72  |.  68 4E444000   PUSH    RSA32+MD.0040444E              ; |Text = "                 You've done it!
Please send your keygen along with
source code to pgc@dangerous-minds.com
if you would like to be considered as
         a new member of PGC."
00401B77  |.  FF35 8C454000 PUSH    [DWORD DS:40458C]              ; |hOwner = NULL
00401B7D  |.  E8 02070000   CALL    <JMP.&USER32.MessageBoxA>      ; \MessageBoxA
00401B82  |.  EB 00         JMP     SHORT RSA32+MD.00401B84
00401B84  |>  FF35 5D424000 PUSH    [DWORD DS:40425D]
00401B8A  |.  E8 BE070000   CALL    RSA32+MD.0040234D
00401B8F  |.  FF35 59424000 PUSH    [DWORD DS:404259]
00401B95  |.  E8 B3070000   CALL    RSA32+MD.0040234D
00401B9A  |.  FF35 61424000 PUSH    [DWORD DS:404261]
00401BA0  |.  E8 A8070000   CALL    RSA32+MD.0040234D
00401BA5  |.  FF35 65424000 PUSH    [DWORD DS:404265]
00401BAB  |.  E8 9D070000   CALL    RSA32+MD.0040234D
00401BB0  |.  FF35 69424000 PUSH    [DWORD DS:404269]
00401BB6  |.  E8 92070000   CALL    RSA32+MD.0040234D
00401BBB  |.  E8 04000000   CALL    RSA32+MD.00401BC4
00401BC0  |.  5E            POP     ESI
00401BC1  |.  5F            POP     EDI
00401BC2  |.  5B            POP     EBX
00401BC3  \.  C3            RET

Como vemos comprueba que tanto el nombre como el número de serie tengan al menos un dígito y a continuación comienza el chequeo del serial. El chequeo es muy sencillo ya que ni siquiera tenemos que buscar los números primos p y q y a continuación n, simplemente podemos obtener el número de serie con la parte pública de la clave (par de número e y n). Lo resumimos a continuación:

Concatena nuestro nombre con la cadena «[PGCTRiAL/2oo2]»
Crea el hash MD5 de la cadena concatenada.
Cifra el hash usando el par de números e y n obtenidos en las referencias de texto.

1. deurus[PGCTRiAL/2oo2]
2. md5(deurus[PGCTRiAL/2oo2]) = dc8a39282da8539d11b8a6aec000c45a
3. dc8a39282da8539d11b8a6aec000c45a^10001 mod 8e701a4c793eb8b739166bb23b49e421 = 1FF83ECC5A65334DA2BC93C675A9BA15

Nombre: deurus
Serial: 1FF83ECC5A65334DA2BC93C675A9BA15

Keygen

//
// md5(deurus[PGCTRiAL/2oo2]) = dc8a39282da8539d11b8a6aec000c45a
//
var c = BigInt("0xdc8a39282da8539d11b8a6aec000c45a");
var e = BigInt("0x10001");
var n = BigInt("0x8e701a4c793eb8b739166bb23b49e421");
//
var serial = BigInt(0);
serial = powmod(c, e, n);
document.write(serial.toString(16));
//
//POWMOD
//
function powmod(base, exp, modulus) {
  var accum = BigInt("1");
  var i = BigInt("0");
  var basepow2 = BigInt(base);
  while ((BigInt(exp) >> BigInt(i) > BigInt(0))) {
    if (((BigInt(exp) >> BigInt(i)) & BigInt(1)) == BigInt(1)) {
      accum = (BigInt(accum) * BigInt(basepow2)) % BigInt(modulus);
    }
    basepow2 = (BigInt(basepow2) * BigInt(basepow2)) % BigInt(modulus);
    i++;
  }
  return BigInt(accum);
}

Enlaces

Blooper Tech Movie VI – Dexter 1×08 (S01E08)

14 noviembre, 2017 por deurus·1 comentario

Hace poco me puse a leer El oscuro pasajero de Jeff Lindsay, novela que inspiró la serie Dexter. La nostalgia me invadió y al final decidí volver a ver la primera temporada que tanto me gustó hace unos años. Para mi sorpresa, muchos de los detalles que recordaba de la serie eran incorrectos o incompletos. Bueno, el caso es que en esta ocasión me he fijado más en los detalles y he descubierto una pequeña perla en el capítulo 8 de la primera temporada.

ALERTA DE SPOILER: Aunque la serie tiene unos añitos no quisiera fastidiarsela a nadie. Si continuas leyendo puede que te enteres de algo que no quieras.

Table of Contents

Missed connection

En un momento dado, a Dexter se le ocurre la feliz idea de contactar con el asesino en serie que le está dejando regalitos y no se le ocurre mejor idea que hacerlo en una web de contactos cualquiera. La web en cuestión es www.miamilist12.com/miami/main y Dexter decide escribir un mensaje en el hilo missed connections. A continuación la secuencia de imágenes.

mailto:frozenbarbie@hotmail.???

La simple idea de escribir en un tablón, foro, lista, etc y esperar que el asesino en serie lo lea ya es una locura. Pero señor@s, esto es ficción, y por supuesto el asesino no solo ve el mensaje si no que responde a Dexter creando un pequeño error con las direcciones de email. Y es que cuando el asesino ve el mensaje se puede apreciar que la dirección de email de Dexter es frozenbarbie@hotmail.web y cuando el asesino le responde, se ve claramente que lo hace a la dirección frozenbarbie@hotmail.com. A continuación las imágenes.

Además me ha llamado la atención que aunque es evidente que el asesino usa Windows XP, se puede apreciar que han retocado en post-producción el botón de inicio para que quede oculto.

Nos vemos en el siguiente BTM.

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

Table of Contents

Introducción

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

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

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

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.

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

Stego X – Chunk

7 noviembre, 2022 por deurus·Sin comentarios

Table of Contents

Intro

Se suele decir que para cada problema hay una solución. Si esto lo llevamos al terreno stego podemos decir que para cada reto hay una herramienta que nos da la solución. En la entrada anterior os comenté que mi fondo de armario son steganabara y stegsolve aunque cuando la imagen es PNG, una herramienta de uso obligatorio es TweakPNG.

La víctima

Nos enfrentamos a una imagen PNG de 112KB (115477 bytes) con una resolución de 300×225 píxeles. A priori llama la atención el elevado tamaño VS la baja resolución, lo que aviva nuestras sospechas de que esos KB extras se deban a que haya insertado otro archivo en su interior.

Chunk

Los archivos PNG tienen la peculiaridad de que están divididos en secciones (chunks) en la que algunas son críticas como IHDR (cabecera), IDAT (la imagen) e IEND (final) y otras muchas secundarias como por ejemplo tEXt (para insertar texto). Al explorar el archivo con TweakPNG vemos la cabecera, varios chunks de texto, muchos IDAT que he combinado en uno para mejorar el análisis y la sección final. Si os fijáis, al combinar los IDAT ha cambiado el tamaño del PNG de 115447 a 110893 bytes aunque en este caso sigue siendo un tamaño elevado.

aspecto de los chunks tras combinar todos los IDAT en uno

Llama la atención el chunk cHRm de 12595 bytes del que TweakPNG ya nos avisa que no reconoce su contenido. Cargamos la imagen en un editor hexadecimal y buscamos la palabra «Great» que es el texto que hay justo antes del chunk cHRm que nos interesa.

detalle del chunk cHRm en editor hexadecimal

La búsqueda da sus frutos ya que el chunk parece que está formado por un archivo mp4. A partir de aquí tenemos varias opciones, para mí la más limpia es con un editor hexadecimal apuntar los offsets de inicio y fin del chunk y crear un archivo nuevo con el contenido. Otra opción es exportar el chunk desde TweakPNG con extensión mp4 y borrar los bytes del nombre del chunk con un editor hexadecimal, de lo contrario no podréis reproducir el mp4.

nombre del chunk a borrar para que funcione el mp4

Hecho esto, al escuchar el mp4 obtenemos la solución del reto.

Enlaces

Nota: si algo os pide clave es deurus.info

TweakPNG by jsummers [Oficial] [GitHub] [mirror]
PNG – Portable Network Graphics [Wikipedia]
MP4 – Moving Picture Experts Group (4) [Wikipedia]

Solución al KeyGenMe1 (RSA127) de C00lw0lf

16 febrero, 2015 por deurus·Sin comentarios

Introducción
Funcionamiento de RSA
OllyDbg
Calculando la clave privada (d)
Ejemplo operacional
Keygen
Links

Introducción

Segunda crackme con RSA que afrontamos. Esta vez se trata de un crackme realizado en VC++ 7.0 y en sus entrañas utiliza RSA-127. Una cosa que no comenté en la entrega anterior (RSA-200), es que conviene utilizar el plugin Kanal de PEiD para localizar cuando se utilizan números grandes o determinados hashes como MD5 o SHA1.

Otra cosa es que os quería comentar es la coletilla 127. Esta lo determina el módulo n e indica el número de bits de éste.

Funcionamiento de RSA

Inicialmente es necesario generar aleatoriamente dos números primos grandes, a los que llamaremos p y q.
A continuación calcularemos n como producto de p y q:
```
n = p * q
```
Se calcula fi:
```
fi(n)=(p-1)(q-1)
```
Se calcula un número natural e de manera que MCD(e, fi(n))=1 , es decir e debe ser primo relativo de fi(n). Es lo mismo que buscar un numero impar por el que dividir fi(n) que de cero como resto.
Mediante el algoritmo extendido de Euclides se calcula d que es el inverso modular de e.
```
Puede calcularse d=((Y*fi(n))+1)/e para Y=1,2,3,... hasta encontrar un d entero.
```
El par de números (e,n) son la clave pública.
El par de números (d,n) son la clave privada.
Cifrado: La función de cifrado es.
```
c = m^e mod n
```
Descifrado: La función de descifrado es.
```
m = c^d mod n
```

OllyDbg

Con OllyDbg analizamos la parte del código que nos interesa.

0040109B    .  68 00010000         PUSH 100                                  ; /Count = 100 (256.)
004010A0    .  52                  PUSH EDX                                  ; |Buffer = RSA127.<ModuleEntryPoint>
004010A1    .  68 EA030000         PUSH 3EA                                  ; |ControlID = 3EA (1002.)
004010A6    .  8B8C24 28020000     MOV ECX,DWORD PTR SS:[ESP+228]            ; |
004010AD    .  51                  PUSH ECX                                  ; |hWnd = NULL
004010AE    .  FF15 F0B04000       CALL DWORD PTR DS:[<&USER32.GetDlgItemTex>; \GetDlgItemTextA
004010B4    .  8D5424 04           LEA EDX,DWORD PTR SS:[ESP+4]
004010B8    .  57                  PUSH EDI
004010B9    .  52                  PUSH EDX                                  ;  RSA127.<ModuleEntryPoint>
004010BA    .  50                  PUSH EAX                                  ;  kernel32.BaseThreadInitThunk
004010BB    .  E8 201E0000         CALL RSA127.00402EE0
004010C0    .  83C4 0C             ADD ESP,0C
004010C3    .  8D9424 04010000     LEA EDX,DWORD PTR SS:[ESP+104]
004010CA    .  68 00010000         PUSH 100                                  ; /Count = 100 (256.)
004010CF    .  52                  PUSH EDX                                  ; |Buffer = RSA127.<ModuleEntryPoint>
004010D0    .  68 EB030000         PUSH 3EB                                  ; |ControlID = 3EB (1003.)
004010D5    .  8B8C24 28020000     MOV ECX,DWORD PTR SS:[ESP+228]            ; |
004010DC    .  51                  PUSH ECX                                  ; |hWnd = NULL
004010DD    .  FF15 F0B04000       CALL DWORD PTR DS:[<&USER32.GetDlgItemTex>; \GetDlgItemTextA
004010E3    .  8D9424 04010000     LEA EDX,DWORD PTR SS:[ESP+104]
004010EA    .  52                  PUSH EDX                                  ;  RSA127.<ModuleEntryPoint>
004010EB    .  8B4C24 04           MOV ECX,DWORD PTR SS:[ESP+4]
004010EF    .  51                  PUSH ECX
004010F0    .  E8 5B1F0000         CALL RSA127.00403050
004010F5    .  68 08B14000         PUSH RSA127.0040B108                      ;  ASCII "666AAA422FDF79E1D4E41EDDC4D42C51"
004010FA    .  55                  PUSH EBP
004010FB    .  E8 501F0000         CALL RSA127.00403050
00401100    .  68 2CB14000         PUSH RSA127.0040B12C                      ;  ASCII "29F8EEDBC262484C2E3F60952B73D067"
00401105    .  56                  PUSH ESI
00401106    .  E8 451F0000         CALL RSA127.00403050
0040110B    .  53                  PUSH EBX
0040110C    .  55                  PUSH EBP
0040110D    .  56                  PUSH ESI
0040110E    .  8B5424 24           MOV EDX,DWORD PTR SS:[ESP+24]
00401112    .  52                  PUSH EDX                                  ;  RSA127.<ModuleEntryPoint>
00401113    .  E8 38250000         CALL RSA127.00403650
00401118    .  53                  PUSH EBX
00401119    .  57                  PUSH EDI
0040111A    .  E8 31130000         CALL RSA127.00402450
0040111F    .  83C4 30             ADD ESP,30
00401122    .  85C0                TEST EAX,EAX                              ;  kernel32.BaseThreadInitThunk
00401124    .  74 12               JE SHORT RSA127.00401138
00401126    .  B8 01000000         MOV EAX,1
0040112B    .  81C4 08020000       ADD ESP,208
00401131    .  5B                  POP EBX                                   ;  kernel32.7590EE1C
00401132    .  5D                  POP EBP                                   ;  kernel32.7590EE1C
00401133    .  5E                  POP ESI                                   ;  kernel32.7590EE1C
00401134    .  5F                  POP EDI                                   ;  kernel32.7590EE1C
00401135    .  C2 1000             RETN 10
00401138    >  6A 40               PUSH 40                                   ; /Style = MB_OK|MB_ICONASTERISK|MB_APPLMODAL
0040113A    .  68 5CB14000         PUSH RSA127.0040B15C                      ; |Title = "Yeah!"
0040113F    .  68 50B14000         PUSH RSA127.0040B150                      ; |Text = "Nice job!!!"
00401144    .  6A 00               PUSH 0                                    ; |hOwner = NULL
00401146    .  FF15 F4B04000       CALL DWORD PTR DS:[<&USER32.MessageBoxA>] ; \MessageBoxA

El código nos proporciona el exponente público (e) y el módulo (n).

e = 29F8EEDBC262484C2E3F60952B73D067
n = 666AAA422FDF79E1D4E41EDDC4D42C51

Finalmente realiza un PowMod con el número de serie del disco C y el par de claves (e,n).

Calculando la clave privada (d)

Una vez localizados los datos anteriores lo siguiente es factorizar para obtener los primos p y q y finalmente d.

d = 65537

Ejemplo operacional

Nº serie disco C = -1295811883
Serial = hdd.getBytes()^d mod n
Serial = 2d31323935383131383833^65537 mod 666AAA422FDF79E1D4E41EDDC4D42C51
Serial = 1698B6CE6BE0D388C31E8E7895AF445A

Keygen

El keygen está hecho en Java ya que permite trabajar con números grandes de forma sencilla.

JButton btnNewButton = new JButton("Generar");
        btnNewButton.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent arg0) {
                BigInteger serial = new BigInteger("0");
                BigInteger n = new BigInteger("136135092290573418981810449482425576529");
                BigInteger d = new BigInteger("415031");
                String hdd = t1.getText();
                BigInteger tmp = new BigInteger(hdd.getBytes());
                serial = tmp.modPow(d, n);
                t2.setText(serial.toString(16).toUpperCase());
            }
        });

AperiSolve en tu Raspi

8 diciembre, 2025 por deurus·Sin comentarios

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he encontrado con que el repositorio no estaba preparado para todas las distros Linux de forma estándar. El resultado lo he colgado en Github, de modo que para montarlo en vuestra propia Raspi solo tenéis que seguir estos pasos:

1. Clonar el repositorio
git clone https://github.com/deurus/AperiSolve-Raspi3.git
cd AperiSolve-Raspi3/AperiSolve

2. Construir los contenedores
docker compose build
docker compose up -d

3. Abrir la web
http://<IP_RASPI>:5000

Si tenéis curiosidad de la adaptación que he tenido que hacer aquí están los pasos que he seguido:

1. Preparar el sistema
sudo apt update
sudo apt install -y git docker.io docker-compose
sudo usermod -aG docker $USER
newgrp docker

2. Clonar AperiSolve
git clone https://github.com/Zeecka/AperiSolve.git
cd AperiSolve

3. Crear la estructura de build para la imagen ARM/x86
nano docker-compose.yml

y pega este contenido:

FROM python:3.11-slim

RUN apt-get update && apt-get install -y \
    zip \
    p7zip-full \
    binwalk \
    foremost \
    exiftool \
    steghide \
    ruby \
    binutils \
    pngcheck \
    && rm -rf /var/lib/apt/lists/*

COPY aperisolve/ /aperisolve/

RUN pip install --no-cache-dir -r /aperisolve/requirements.txt

WORKDIR /aperisolve

CMD ["gunicorn", "-w", "4", "-b", "0.0.0.0:5000", "wsgi:app"]

4. Arreglar docker-compose.yml para ser válido y compatible

services:
  web:
    image: aperisolve-local
    build: .
    container_name: aperisolve-web
    ports:
      - "5000:5000"
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  worker:
    image: aperisolve-local
    container_name: aperisolve-worker
    depends_on:
      - redis
      - postgres
    environment:
      DB_URI: "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"

  redis:
    image: redis:7
    container_name: aperisolve-redis

  postgres:
    image: postgres:16
    container_name: aperisolve-postgres
    environment:
      POSTGRES_USER: aperiuser
      POSTGRES_PASSWORD: aperipass
      POSTGRES_DB: aperisolve
    volumes:
      - postgres_data:/var/lib/postgresql/data

volumes:
  postgres_data:

5. Modificar aperisolve/config.py
nano config.py

y pega este contenido:

from pathlib import Path

IMAGE_EXTENSIONS = [".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp", ".tiff"]

WORKER_FILES = ["binwalk", "foremost", "steghide", "zsteg"]

RESULT_FOLDER = Path(__file__).parent.resolve() / "results"
RESULT_FOLDER.mkdir(parents=True, exist_ok=True)

6. Modificación de aperisolve/app.py

Sustituir la línea: app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI")
por:
default_db = "postgresql://aperiuser:aperipass@postgres:5432/aperisolve"
app.config["SQLALCHEMY_DATABASE_URI"] = os.environ.get("DB_URI", default_db)

7. Construir la imagen
docker build -t aperisolve-local .

8. Levantar los contenedores
docker compose down
docker compose up -d

9. Comprobar logs
docker logs aperisolve-web --tail=50
docker logs aperisolve-worker --tail=50

10. Acceder a la web
 - Desde cualquier máquina de la red local: http://IP-DE-LA-MAQUINA:5000
 - Desde la Raspi: http://localhost:5000

11. Limpieza (cuando necesites)
 - Reiniciar contenedores:
docker compose restart
 - Borrar resultados antiguos:
sudo rm -r aperisolve/results/*

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]

Afinador

Se nos entrega un ELF que decompilado presenta este aspecto: Para resolver el juego y obtener una licencia válida, nos

Guía rápida para tener una red Gigabit en casa

Introducción A quien va dirigido Comprobaciones previas Lo que necesitamos Presupuesto Ejemplo de instalación Preguntas frecuentes Glosario Notas finales Introducción

ThisIsLegal.com - User Challenge 1 (Javascript)

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

Dark_Prince's crackme in Java Keygen

Introducción Aquí tenemos un crackme hecho en Java, lo que como comprobareis a continuación no es muy buena idea ya

1 2 3 … 30 Next »

Afinador

3 agosto, 2024 por deurus·Sin comentarios

Se nos entrega un ELF que decompilado presenta este aspecto:

/* 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_401020();
__int64 sub_401030(); // weak
__int64 sub_401040(); // weak
__int64 sub_401050(); // weak
__int64 sub_401060(); // weak
__int64 sub_401070(); // weak
// int puts(const char *s);
// int printf(const char *format, ...);
// __int64 __isoc99_scanf(const char *, ...); weak
// void __noreturn exit(int status);
void __fastcall __noreturn start(__int64 a1, __int64 a2, void (*a3)(void));
void dl_relocate_static_pie();
char *deregister_tm_clones();
__int64 register_tm_clones();
char *_do_global_dtors_aux();
__int64 frame_dummy();
int __fastcall main(int argc, const char **argv, const char **envp);
_BYTE *__fastcall encode(__int64 a1);
__int64 __fastcall validar(const char *a1);
int banner();
int comprar();
void _libc_csu_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 _libc_csu_init;
const char a31mparaSeguirU[43] = "\x1B[31mPara seguir usando este producto deber"; // idb
const char a32myaPuedesSeg[61] = "\x1B[32mYa puedes seguir afinando tus instrumentos (y tus flags "; // idb
const char aDirigaseANuest[21] = "\nDirigase a nuestra p"; // idb
__int64 (__fastcall *_frame_dummy_init_array_entry)() = &frame_dummy; // weak
__int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)() = &_do_global_dtors_aux; // weak
__int64 (*qword_404010)(void) = NULL; // weak
char _bss_start; // weak


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

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

//----- (0000000000401020) ----------------------------------------------------
__int64 sub_401020()
{
  return qword_404010();
}
// 404010: using guessed type __int64 (*qword_404010)(void);

//----- (0000000000401030) ----------------------------------------------------
__int64 sub_401030()
{
  return sub_401020();
}
// 401030: using guessed type __int64 sub_401030();

//----- (0000000000401040) ----------------------------------------------------
__int64 sub_401040()
{
  return sub_401020();
}
// 401040: using guessed type __int64 sub_401040();

//----- (0000000000401050) ----------------------------------------------------
__int64 sub_401050()
{
  return sub_401020();
}
// 401050: using guessed type __int64 sub_401050();

//----- (0000000000401060) ----------------------------------------------------
__int64 sub_401060()
{
  return sub_401020();
}
// 401060: using guessed type __int64 sub_401060();

//----- (0000000000401070) ----------------------------------------------------
__int64 sub_401070()
{
  return sub_401020();
}
// 401070: using guessed type __int64 sub_401070();

//----- (00000000004010D0) ----------------------------------------------------
// 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))_libc_csu_init,
    _libc_csu_fini,
    a3,
    &v5);
  __halt();
}
// 4010DA: positive sp value 8 has been found
// 4010E1: variable 'v3' is possibly undefined

//----- (0000000000401100) ----------------------------------------------------
void dl_relocate_static_pie()
{
  ;
}

//----- (0000000000401110) ----------------------------------------------------
char *deregister_tm_clones()
{
  return &_bss_start;
}
// 404050: using guessed type char _bss_start;

//----- (0000000000401140) ----------------------------------------------------
__int64 register_tm_clones()
{
  return 0LL;
}

//----- (0000000000401180) ----------------------------------------------------
char *_do_global_dtors_aux()
{
  char *result; // rax

  if ( !_bss_start )
  {
    result = deregister_tm_clones();
    _bss_start = 1;
  }
  return result;
}
// 404050: using guessed type char _bss_start;

//----- (00000000004011B0) ----------------------------------------------------
__int64 frame_dummy()
{
  return register_tm_clones();
}

//----- (00000000004011B6) ----------------------------------------------------
int __fastcall main(int argc, const char **argv, const char **envp)
{
  int v4; // [rsp+10h] [rbp-10h] BYREF
  int v5; // [rsp+14h] [rbp-Ch]
  unsigned __int64 v6; // [rsp+18h] [rbp-8h]

  v6 = __readfsqword(0x28u);
  v5 = 0;
  puts("\n\x1B[31m    -----------Se le ha acabado el periodo de prueba gratuito-----------\n");
  puts(a31mparaSeguirU);
  do
  {
    banner();
    __isoc99_scanf("%d", &v4);
    if ( v4 == 3 )
      exit(0);
    if ( v4 > 3 )
      goto LABEL_10;
    if ( v4 == 1 )
    {
      comprar();
      continue;
    }
    if ( v4 == 2 )
      v5 = validar("%d");
    else
LABEL_10:
      puts("Opcion invalida, pruebe otra vez");
  }
  while ( !v5 );
  puts(a32myaPuedesSeg);
  return 0;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);

//----- (0000000000401291) ----------------------------------------------------
_BYTE *__fastcall encode(__int64 a1)
{
  _BYTE *result; // rax
  int i; // [rsp+14h] [rbp-4h]

  for ( i = 0; i <= 33; ++i )
  {
    if ( *(char *)(i + a1) <= 96 || *(char *)(i + a1) > 122 )
    {
      if ( *(char *)(i + a1) <= 64 || *(char *)(i + a1) > 90 )
      {
        result = (_BYTE *)*(unsigned __int8 *)(i + a1);
        *(_BYTE *)(i + a1) = (_BYTE)result;
      }
      else
      {
        result = (_BYTE *)(i + a1);
        *result = (5 * ((char)*result - 65) + 8) % 26 + 65;
      }
    }
    else
    {
      result = (_BYTE *)(i + a1);
      *result = (5 * ((char)*result - 97) + 8) % 26 + 97;
    }
  }
  return result;
}

//----- (00000000004013DB) ----------------------------------------------------
__int64 __fastcall validar(const char *a1)
{
  int i; // [rsp+Ch] [rbp-64h]
  char v3[48]; // [rsp+10h] [rbp-60h] BYREF
  __int64 v4[6]; // [rsp+40h] [rbp-30h] BYREF

  v4[5] = __readfsqword(0x28u);
  qmemcpy(v4, "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", 34);
  printf("\nIntroduce tu licencia: ");
  __isoc99_scanf("%s", v3);
  encode((__int64)v3);
  for ( i = 0; i <= 33; ++i )
  {
    if ( v3[i] != *((_BYTE *)v4 + i) )
    {
      puts("\n\x1B[31mTu licencia es incorrecta\x1B[37m\n");
      return 0LL;
    }
  }
  puts("\n\x1B[32mEres un crack, lo conseguiste\x1B[37m");
  return 1LL;
}
// 4010B0: using guessed type __int64 __isoc99_scanf(const char *, ...);
// 4013DB: using guessed type char var_60[48];

//----- (00000000004014CE) ----------------------------------------------------
int banner()
{
  puts("                     ___________OPCIONES___________");
  puts("                    | 1: Comprar licencia premium  |");
  puts("                    | 2: Validar clave de licencia |");
  puts("                    | 3: Salir                     |");
  puts("                     ------------------------------");
  return printf("> ");
}

//----- (0000000000401526) ----------------------------------------------------
int comprar()
{
  return puts(aDirigaseANuest);
}

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

  init_proc();
  v3 = &_do_global_dtors_aux_fini_array_entry - &_frame_dummy_init_array_entry;
  if ( v3 )
  {
    for ( i = 0LL; i != v3; ++i )
      (*(&_frame_dummy_init_array_entry + i))();
  }
}
// 403E10: using guessed type __int64 (__fastcall *_frame_dummy_init_array_entry)();
// 403E18: using guessed type __int64 (__fastcall *_do_global_dtors_aux_fini_array_entry)();

//----- (00000000004015B0) ----------------------------------------------------
void _libc_csu_fini(void)
{
  ;
}

//----- (00000000004015B8) ----------------------------------------------------
void term_proc()
{
  ;
}

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

Para resolver el juego y obtener una licencia válida, nos fijamos en el proceso de validación que se encuentra en la función validar (líneas 237 a 258). Esta función compara una entrada de licencia codificada con una licencia codificada almacenada en el programa.

La licencia almacenada es "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}", y se utiliza la función encode (líneas 207 a 234) para codificar la entrada del usuario antes de compararla. La función encode aplica un cifrado simple a la entrada, alterando los caracteres alfabéticos según una fórmula específica.

La función de cifrado encode realiza lo siguiente:

Si el carácter es una letra minúscula (a-z), se convierte según la fórmula (5 * (char - 97) + 8) % 26 + 97.
Si el carácter es una letra mayúscula (A-Z), se convierte según la fórmula (5 * (char - 65) + 8) % 26 + 65.

Nos construimos una función en Python para decodificar la Flag y reto superado.

def decode(encoded_char):
    if 'a' <= encoded_char <= 'z':
        original_char = chr(((ord(encoded_char) - 97 - 8) * 21) % 26 + 97)
    elif 'A' <= encoded_char <= 'Z':
        original_char = chr(((ord(encoded_char) - 65 - 8) * 21) % 26 + 65)
    else:
        original_char = encoded_char
    return original_char

encoded_license = "RisgAv{rIU_ihHwvIxA_sAppCsziq3vzC}"
decoded_license = "".join(decode(char) for char in encoded_license)

print("Licencia descifrada:", decoded_license)

Guía rápida para tener una red Gigabit en casa

2 noviembre, 2014 por deurus·1 comentario

Introducción
A quien va dirigido
Comprobaciones previas
Lo que necesitamos
Presupuesto
Ejemplo de instalación
Preguntas frecuentes
Glosario
Notas finales

Table of Contents

Introducción

Un día cualquiera se te ocurre comprarte un disco duro de red NAS para centralizar todo tu contenido multimedia. Lo conectas y todo va genial, pero de repente vas a copiar unos cuantos gigas de fotos y te encuentras con que la operación va a tardar días. En ese mismo instante te planteas sacar el máximo provecho a tu red doméstica y la solución se llama gigabit.

A quién va dirigido

Esta guía va dirigida a todo el mundo que esté pensando en hacer o mejorar la red LAN doméstica. Si eres un amante del WIFI, olvídate de esto, ya que para conseguir altas velocidades se necesita cablear la casa. Además, de lo que trata esta guía es de que se conecte un ordenador portátil o sobremesa de la forma más rápida posible al disco duro de red.

Comprobaciones previas

Probablemente dispongas de un Modem / Router proporcionado por tu compañia y que seguramente no sea gigabit (10/100/1000), esto es lo primero que debes comprobar. Busca tu modelo en internet y cerciorate.

También necesitas que la tarjeta de red del portátil o sobremesa sean gigabit, en este caso lo más probable es que lo sean pero asegúrate.

Lo que necesitamos

Tras hacer las comprobaciones previas ya podemos hacer una lista de los materiales que necesitamos.

Router gigabit (en caso del que tu compañia no lo sea).

Si el nuestro no es gigabit existen soluciones económicas como el TP-Link TL-WR1043ND que lo tenemos por 44€ en pccomponentes. Os recomiendo esta tienda por rapidez, seriedad y no abusan con los gastos de envío.

Switch gigabit (para ampliar puertos)

En caso de que los cuatro puertos que vienen con el router se nos queden cortos, la solución más economica y acertada es un Switch ethernet gigabit como el TP-LINK TL-SG1005D que lo tenemos por 16€. Este dispositivo es una maravilla ya que nos brinda 4 puertos más y no requiere configuración alguna.

Tarjeta de red gigabit (para pc sobremesa en caso de no ser o no disponer)

Son muy económicas, las puedes encontrar por 10€-15€ en cualquier tienda especializada. Ejemplo PCI. Ejemplo PCI-e. Video instalación de una tarjeta de red.

Bobina de cable de red Categoría 6.

100m de cable UTP categoría 6 viene a costar sobre unos 42€.

Cables Cat6 interconexionado router / switch / pc.

Para interconexionado de equipos recomiento estos de 50cm por 1,5€. Para conexión del pc tienes otras larguras más apropiadas. También podéis haceros vosotros los cables con lo sobrante de la bobina, para ello necesitaréis una crimpadora y terminales rj45.

Tomas RJ45 categoría 6.

Esto depende de tu instalación y la gama que elijas. En mi caso utilizo tomas Niessen que solo el conector vale 16€, pero tienes tomas más económicas. De superficie por 2,75€ y empotrable por 8,25€.

Insertadora (punch down) para las tomas RJ45.

Indispensable para conectar internamente los cables de las tomas. La tenéis por 11€ en ebay. Video de la insertadora en acción.

Disco duro de red NAS

Esto es una recomendación personal ya que la elección puede variar en función de las necesidades de almacenamiento y conexiones. Una solución barata y con espacio suficiente para uso doméstico es el disco WD My Cloud 3TB que lo podeis adquirir por 159€.

Presupuesto (Precios Octubre 2014)

Router = 44€
Switch = 16€
Tarjeta de red = 15€
Bobina de cable = 42€
Cables interconexionado 50cm x4 = 6€
Cable conexión pc / switch o router 1,8m = 2,95€
Tomas RJ45 x 2 = 16,5€
Disco duro de red NAS = 159€
TOTAL = 345,45€ + gastos de envío.

Esto puede variar en función de los componentes que elijas comprar pero el coste oscilará entre 250 y 350€, algo bastante asequible para centralizar contenido multimedia. Digo asequible por que la mitad del presupuesto se lo lleva el disco de red, los componentes son más bien baratos.

Ejemplo de instalación

Esquema inicial

En mi esquema disponemos del router proporcionado por el proveedor de internet que en mi caso sí es gigabit pero que solo lo utilizo para dar internet al router neutro.El router neutro junto con el switch me proporcionan 8 puertos gigabit. El router neutro además gestiona el wifi de la casa, pero en el mejor de los casos (Wifi n) estos dispositivos solo podrán mover datos a 300mbps. Utilizo como media center mis amadas Raspberry Pi que en este caso no se benefician de la velocidad ya que disponen de conexión 10/100.

Configurar router neutro

Lo primero a conectar es el router neutro y en este caso, TP-Link te lo pone fácil si no te defiendes muy bien con las redes, ya que proporciona un CD que se encarga de guiarte paso a paso. Lo más importante es la asignación de la IP privada, por defecto es 192.168.2.1 y a no ser que el router de la compañia tenga esa misma IP lo podéis dejar como está.

Disco duro de red NAS

Para configurar el disco de red normalmente viene un CD para ayudar al usuario novel. Lo único que tenéis que tener en cuenta es que la IP debe estar en consonancia con la del router neutro, si el router neutro es 192.168.2.1 al disco NAS podéis asignarle 192.168.2.150. Para más información aquí tenéis la guía de instalación.

Preguntas frecuentes. FAQ

¿El cable normal o cruzado?

Podéis usar cable normal, también llamado conexión Pin a Pin ó 1:1, para toda la instalación ya que los dispositivos de hoy en día aceptan cualquier cable y resuelven internamente en función del cable conectado. Pero si nos ponemos quisquillosos, para conectar elementos pasivos entre sí (router a switch, etc) se utiliza cable normal 1:1. Para conectar elementos activos (PC a router/switch) cable cruzado.

¿Qué norma de colores uso?

Mi consejo es que uses el standard EIA/TIA 568B tanto en la conexión de las cajas como en la creación de los cables.

Cada roseta o toma en su interior tiene definido el orden que debes seguir para conectar los cables según el standard A o B, esto es una aproximación y puede no coincidir con tu toma.

Tengo todo instalado y es categoría 6 pero mi pc me marca que me conecta a 100mbps ¿qué pasa?

Si estás seguro de que las rosetas están bien conectadas, que has usado los cables correctos, que todos los dispositivos son gigabit y tu pc hace de las suyas, quizás debas de forzar a tu tarjeta de red a trabajar en modo gigabit ó 100 full duplex ó 100FD. Esto es debido a que el driver de la tarjeta de red por defecto viene con la opción de «autonegociación» activada y a veces necesita que le «obligues» a trabajar en gigabit.

En cada tarjeta de red puede venir diferente, yo os muestro mi caso desde windows 7:

Diríjete a Inicio > Panel de control > Ver el estado y las tareas de red > conexión de area local

En mi caso marca 1 Gbps pero si estais teniendo problemas os marcará 100 mbps. A continuación pulsa Propiedades.

Pulsa Configurar.

En la pestaña Opciones avanzadas busca la opción de la velocidad, en mi caso «Speed/duplex settings» y selecciona 100 mb Full Duplex. De este modo le forzais a la tarjeta de red a trabajar en modo gigabit. Si no lo consiguiera trabajará en el modo que pueda pero no os dejará sin conexión.

Glosario

NAS – del inglés Network Attached Storage, es el nombre dado a una tecnología de almacenamiento dedicada a compartir la capacidad de almacenamiento a través de una red. Estos discos vienen equipados como mínimo con una conexión RJ45 para integrarlo en una red de forma rápida y sencilla.
Full Duplex – Que transmite y recibe en ambas direcciones al mismo tiempo por cables independientes.
Switch – Un conmutador o switch es un dispositivo digital lógico de interconexión de equipos que opera en la capa de enlace de datos del modelo OSI. Su función es interconectar dos o más segmentos de red, de manera similar a los puentes de red, pasando datos de un segmento a otro de acuerdo con la dirección MAC de destino de las tramas en la red.
Gigabit Ethernet – también conocida como GigaE, es una ampliación del estándar Ethernet (concretamente la versión 802.3ab y 802.3z del IEEE) que consigue una capacidad de transmisión de 1 gigabit por segundo, correspondientes a unos 1000 megabits por segundo de rendimiento contra unos 100 de Fast Ethernet (También llamado 100BASE-TX).

Notas finales

Soy consciente de que me he dejado muchas cosas en el tintero pero mi pretensión es que el lector de un vistazo rápido tenga una idea clara de lo que necesita para lograr una red decente en casa.

ThisIsLegal.com – User Challenge 1 (Javascript)

29 agosto, 2014 por deurus·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Table of Contents

Introducción

Este es el típico reto de Javascript, no tiene mucha complicación pero he decidido dedicarle una entrada por que me llamó la atención lo que utiliza de usuario y clave.

El Script

function getStyle(el,styleProp)
{
    var x = document.getElementById(el);
    if (x.currentStyle)
        var y = x.currentStyle[styleProp];
    else if (window.getComputedStyle)
        var y = document.defaultView.getComputedStyle(x,null).getPropertyValue(styleProp);

if (y.substr(0, 1) == "#"){ return y; } else {
    
var value = y.split(',');

var R = value[0].substr(4);
var G = value[1];
var B = value[2].substr(0, value[2].length-1);

var RGB =  "#" + toHex(R)+ toHex(G)+toHex(B);

return RGB;

 }
}

function toHex(N) {
 if (N==null) return "00";
 N=parseInt(N); if (N==0 || isNaN(N)) return "00";
 N=Math.max(0,N); N=Math.min(N,255); N=Math.round(N);
 return "0123456789ABCDEF".charAt((N-N%16)/16)
      + "0123456789ABCDEF".charAt(N%16);
}

function pw (form)
{

   var d1, d2, d3;

if (navigator.appName == "Netscape"){
   d1= getStyle('content', 'background-color');
} else {
   d1= getStyle('content', 'backgroundColor');
}

     d2=form.Name.value;
     d3=form.Password.value;

  if (d2==d1.length) {
    if (d3==d1) {
      window.open ("../" + d1.substr(1, 10), "_self")
    } else {
      alert("Muhaha! Wrong!")
    }
  } else {
    alert("Muhaha! Wrong!")
  }
}

El Formulario

<div class="chal_box" style="padding:10px;">
<form name="form" action="" method="post">
        Username<br />
        <input id="inputd2" type="text" name="Name" value="" size="30" maxlength="30"><br />
        Password<br />
        <input id="inputd1" type="text" name="Password" value="" size="30" maxlength="30"><br /><br />

         <input type="button" name="Only a button" value="Enter Site" id="Only a button" class="btn" onclick="pw(this.form)">
</form>
</div>

Interpretando el Script

En el formulario vemos que llama a la función «pw» y ésta a su vez llama a la función «getStyle«, bueno, pués es tan simple como poner un «alert();» dentro de la función «pw» para cazar la clave. Con éste método podemos cazar la clave del 90% de este tipo de pruebas.

Con esto ya tenemos la clave. El usuario responde a la siguiente sentencia «d2==d1.length«, es decir, es el número de dígitos de la clave.

¿Fácil no?

Dark_Prince’s crackme in Java Keygen

27 agosto, 2014 por deurus·Sin comentarios

Introducción

Aquí tenemos un crackme hecho en Java, lo que como comprobareis a continuación no es muy buena idea ya que conseguir el código fuente e incluso modificarlo no es muy dificil.

Decompilado

Abrimos la víctima con nuestro decompilador favorito y nos fijamos en su contenido.

Lo interesante está en la clase Main > doneActionPerformed(ActionEvent), ya que contiene el código al ejecutar el botón que chequea el serial.

Llegados a este punto podríamos hacer cualquier cosa, parchear, que el serial válido nos lo mostrara una MessageBox etc. Pero vamos a hacer algo mejor, vamos a modificar la victima para crear nuestro keygen personalizado.

Creando un Keygen a partir de la víctima

Solamente tendremos que modificar un poco la apariencia y modificar la rutina de comprobación del serial para que lo muestre en la caja de texto del serial. Finalmente abrá que recompilar.

Aquí resalto el texto a modificar para el aspecto.

Así queda la modificación para mostrar el serial correcto en la caja de texto.

El aspecto del keygen finalmente es así.

Y como podeis apreciar funciona correctamente.

Links

Keygen para el KeygenMe#01 de eBuC - Comparación lineal

Primeras impresiones Analizamos el programa con PEiD y nos muestra que está hecho en ensamblador. Unas pruebas introduciendo datos nos

Descargar contenido multimedia de ciertas webs

Hoy en día, la descarga de contenido multimedia de ciertas webs es imposible o muy difícil. En ciertos casos lo

Stego d33p

En este reto se nos entrega un archivo WAV de 9,92 MB. Tras escucharlo y analizarlo por encima con Audacity

Solución al PGC Official KeygenMe

Introducción Siguiendo con los crackmes que contienen RSA, esta vez tenemos un Keygenme del grupo PGC (Pirates Gone Crazy) que

1 2 3 … 30 Next »

Keygen para el KeygenMe#01 de eBuC – Comparación lineal

25 agosto, 2014 por deurus·2 comentarios

Primeras impresiones

Analizamos el programa con PEiD y nos muestra que está hecho en ensamblador.

Unas pruebas introduciendo datos nos muestran que el nombre debe tener entre 3 y 10 dígitos.

Determinando la rutina de creación del serial con Ollydbg

Llegados a este punto tenemos dos opciones que funcionan en el 90% de los casos. La primera es mediante las referenced strings o mediante los names.

Para el primer caso, con el keygenme cargado en olly, click derecho y Search > All referenced text strings. Haciendo doble click en “You got it” o en “Bad boy” vamos directamente a la rutina de comprobación del serial o muy cerca de ella en la mayoría de los casos.

Para el segundo caso, haremos click derecho y Search > Name (label) in current módule, o Ctrl+N. Vemos dos llamadas interesantes como son user32.GetDlgItemInt y user32.GetDlgItemTextA. Lo más seguro es que user32.GetDlgItemInt coja del textbox nuestro serial y user32.GetDlgItemTextA coja nuestro nombre. Para este caso colocaríamos breakpoints en las dos llamadas.

En mi caso elijo la primera opción. Nada más pulsar en “You got it” nos fijamos un poco más arriba y vemos las funciones donde coge el nombre y el serial y a simple vista se ven las operaciones que hace con ellos.

Generando un serial válido

Como se muestra en la imagen siguiente, la creación del serial es muy sencilla y al final la comparación es lineal ya que se compara nuestro serial con el serial válido. Veamos el serial válido para el usuario “abc” cuyos dígitos en hexadecimal son 0x61, 0x62 y 0x63.

Letra a	Letra b	Letra c
Suma + 0x61 Suma * 0x20 Suma xor 0xBEFF Suma / 4 Suma = 0x2CB7	Suma + 0x62 Suma * 0x20 Suma xor 0xBEFF Suma / 4 Suma = 0x14777	Suma + 0x63 Suma * 0x20 Suma xor 0xBEFF Suma / 4 Suma = 0xA116F
Suma xor 0xBEA4 = 0xAAFCB
Serial válido = 700363

Generando un keygen con WinASM studio desde cero

Abrimos WinASM studio y pulsamos en File > New Project y en la pestaña dialog elegimos base.

Vemos que se nos generan tres archivos, uno con extensión asm, otro con extensión inc y otro con extensión rc. El archivo asm es el que contendrá nuestro código. El archivo inc no lo vamos a usar para simplificar las cosas y el archivo rc es nuestro formulario al que pondremos a nuestro gusto.

Empecemos con el aspecto del formulario. Por defecto viene como se muestra en la siguiente imagen. Que por cierto, es todo lo que necesitamos para un keygen básico.

Y el aspecto final:

Ahora veamos cómo viene nuestro archivo asm inicialmente y que haremos con él. En la siguiente imagen lo indico.

Encima de la sección .code hemos creado dos secciones como son .data y .data? y hemos declarado las variables necesarias.

szFormat está declarada en formato integer (%i). Más tarde la utilizaremos junto a la función wsprintf para dar formato a un número.

szSizeMin: habla por sí misma.

szSizeMax: habla por sí misma.

szCap: habla por sí misma.

szName: contendrá el nombre introducido.

szCode: contendrá el serial válido.

Nuestro código queda de la siguiente manera:

A partir de aquí ya simplemente es escribir el código necesario para generar el serial válido. Una de las ventajas que tiene el ensamblador para hacer keygens sin muchas complicaciones, es que prácticamente es copiar el código que nos muestra Ollydbg. Si os fijáis a continuación, en el botón llamado “IDC_OK” (no le he cambiado el nombre) he puesto todo el código necesario para generar la simple rutina del serial.

Como veis el bucle del nombre es una copia de lo que nos mostró Ollydbg. Una vez que tenemos en EAX nuestro serial válido, mediante la función wsprintf guardamos en la variable szCode el serial válido con formato integer. Finalmente mediante la función SetDlgItemText, mostramos el serial válido en la caja de texto 1002, que es la del serial.

Enlaces

Blooper Tech Movie VII – Absentia 1×06 (S01E06)

En el BTM anterior nos remontábamos al año 2006 para ver un pequeño gazapo ocurrido en la serie Dexter. En

LaFarge's Crackme 2 - Keygen por Injerto

Intro Hoy vamos a hacer algo diferente, vamos a hacer un keygen con la propia víctima. El término anglosajón para

Stego XVI - Bytes

Intro Os comparto un reto stego que me gustó cuando lo hice hace unos años. En realidad se tarda pocos

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

1 2 3 … 30 Next »

Blooper Tech Movie VII – Absentia 1×06 (S01E06)

14 noviembre, 2017 por deurus·Sin comentarios

En el BTM anterior nos remontábamos al año 2006 para ver un pequeño gazapo ocurrido en la serie Dexter. En esta ocasión vamos a hablar sobre un pequeño detalle de una serie actual, Absentia. No es un gazapo, pero es algo bastante poco creíble hoy día.

Table of Contents

Hide me

La escena la protagoniza Emily Byrne (Stana Katic) y en ella se ve a Emily buscar algo sospechoso en un portátil.

Primer detalle

En la primera imagen y antes de que Emily haga clic en Documents, se puede apreciar un acceso directo que reza Browser con un icono de la bola del mundo y una lupa. Muy chulo pero para darle más credibilidad a la escena se podía mostrar un acceso directo de Chrome, Firefox o Internet Explorer que son los navegadores más usados.

Where is my Browser?

Para rematar…

A lo que vamos. Emily decide mirar en la carpeta Documents > Videos y para su sorpresa está vacía. Pero como Emily es una mujer de recursos decide comprobar si hay archivos ocultos y para ello retoca las opciones de carpeta.

¡Tachán!, como por arte de magia aparecen todas las carpetas del supuesto asesino con todo tipo de vídeos incriminatorios. Como he comentado anteriormente, parece poco creíble pensar que algo que te puede llevar a la cárcel de por vida sea protegido de forma tan pobre.

Enlaces

Ficha en IMDB.

LaFarge’s Crackme 2 – Keygen por Injerto

10 septiembre, 2014 por deurus·Sin comentarios

Intro

Hoy vamos a hacer algo diferente, vamos a hacer un keygen con la propia víctima. El término anglosajón para esto es «selfkeygening» y no es que esté muy bien visto por los reversers pero a veces nos puede sacar de apuros.

La víctima elegida es el Crackme 2 de LaFarge. Está hecho en ensamblador.

Injerto Light

Primeramente vamos a realizar un injerto light, con esto quiero decir que vamos a mostrar el serial bueno en la MessageBox de error.

Abrimos Olly y localizamos el código de comprobación del serial, tenemos suerte ya que el serial se muestra completamente y no se comprueba byte a byte ni cosas raras. En la imagen inferior os muestro el serial bueno para el nombre deurus y el mensaje de error. Como podeis observar el serial bueno se saca de memoria con la instrucción PUSH 406749 y el mensaje de error con PUSH 406306.

Si cambiamos el PUSH del serial por el de el mensaje de error ya lo tendriámos. Nos situamos encima del PUSH 406306 y pulsamos espacio, nos saldrá un diálogo con el push, lo modificamos y le damos a Assemble.

Ahora el crackme cada vez que le demos a Check it! nos mostrará:

Keygen a partir de la víctima

Pero no nos vamos a quedar ahí. Lo interesante sería que el serial bueno lo mostrara en la caja de texto del serial. Esto lo vamos a hacer con la función user32.SetDlgItemTextA.

Según dice la función necesitamos el handle de la ventana, el ID de la caja de texto y el string a mostrar. La primera y segunda la obtenemos fijándonos en la función GetDlgItemTextA que recoje el serial introducido por nosotros. La string es el PUSH 406749.

Con esto ya tenemos todo lo que necesitamos excepto el espacio dentro del código, en este caso lo lógico es parchear las MessageBox de error y acierto. Las seleccionamos, click derecho y Edit > Fill with NOPs.

Ahora escribimos el injerto.

Finalmente con Resource Hack cambiamos el aspecto del programa para que quede más profesional y listo. Tenemos pendiente hacer el keygen puro y duro, venga agur.

Links

Wechall Training LSB Challenge (Esteganografía)

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

Tras las Pantallas de 'Contact': Un Viaje a Través del Hardware y del Software

Introducción La película "Contact", estrenada en 1997 y dirigida por Robert Zemeckis, es una adaptación de la novela homónima de

ThisIsLegal.com - Realistic Challenge 3

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

Cruehead’s Crackme 2.0 Serial [2/3]

Introducción Continuamos con la segunda entrega de Cruehead. En este caso nos encontramos con un único campo de contraseña para

1 2 3 … 30 Next »

Wechall Training LSB Challenge (Esteganografía)

29 agosto, 2014 por deurus·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Table of Contents

Introducción

Resumidamente, esta técnica consiste en ocultar información en el bit menos significativo de cada uno de los píxeles de una imagen, consiguiendo así que el cambio realizado sea invisible al ojo humano. El problema de esta técnica, es que la información oculta puede obtenerse fácilmente si esta no se ha codificado previamente o si no se sigue un patrón concreto a la hora de ocultarla.

Desde la web del reto nos avisan de que esto es un simple truco pero espectacular. Nos animan a descargar una imágen y a encontrar la solución oculta.

Aprovecho este reto para presentaros una herramienta vital al enfrentaros a ciertos retos sobre esteganografía, steganabara.

Steganabara tiene dos apartados muy interesantes, uno es «color table» y otro «bit mask«, hoy veremos en acción a «bit mask».

No os preocupéis por la solución ya que cambia para cada usuario y sesión.

Buscando la solución oculta

Abrimos steganabara y empezamos a trastear con bit mask.

Al poco tiempo ya vemos que vamos bien encaminados.

Finalmente no nos cuesta dar con la solución.

Tras las Pantallas de ‘Contact’: Un Viaje a Través del Hardware y del Software

1 diciembre, 2024 por deurus·Sin comentarios

Table of Contents

Introducción

La película «Contact«, estrenada en 1997 y dirigida por Robert Zemeckis, es una adaptación de la novela homónima de Carl Sagan. Más allá de su profunda exploración sobre la existencia de vida extraterrestre y el debate entre ciencia y fe, la película ofrece un interesante vistazo a la tecnología de la época. En este análisis, nos enfocaremos en los aspectos tecnológicos presentes en la película, detallando los sistemas operativos, software y hardware utilizados por los protagonistas.

Sinopsis

La Dra. Eleanor «Ellie» Arroway, interpretada por Jodie Foster, es una científica dedicada al proyecto SETI (Búsqueda de Inteligencia Extraterrestre). Tras años de búsqueda, capta una señal proveniente del espacio profundo que contiene instrucciones para construir una máquina enigmática. A medida que se desarrolla la trama, Ellie enfrenta desafíos políticos, religiosos y personales mientras lucha por interpretar el mensaje y lo que podría significar para la humanidad.

Análisis Tecnológico

Sistemas Operativos y Software

Uno de los aspectos más destacados en Contact es la presencia del sistema operativo UNIX. A lo largo de la película, se observan pistas que indican su uso, como pegatinas en las pantallas con mensajes del estilo: «Join the UNIX PARTY (The open system platform)». UNIX, desarrollado en la década de 1970, es conocido por su estabilidad y eficiencia, características esenciales en entornos científicos y de investigación.

La utilización de Netscape Navigator es recurrente. El logo de Netscape aparece en varias ocasiones, especialmente durante las videoconferencias que se muestran sin retrasos apreciables. Netscape fue uno de los primeros navegadores web ampliamente utilizados y jugó un papel crucial en la expansión de Internet durante los años 90.

Es importante destacar que, aunque la película promueve la idea de sistemas abiertos a través del uso de UNIX, Netscape Navigator no era software libre en el momento en que se rodó la película. Durante esa época, antes de 1997, Netscape era un navegador propietario. Sin embargo, en sistemas UNIX, Netscape tenía poca competencia y era el navegador predominante, soportando estándares abiertos como HTTP y HTML. Curiosamente, en 1998, poco después del estreno de la película, Netscape liberó el código fuente de su navegador, iniciando el proyecto Mozilla y contribuyendo significativamente al movimiento del software libre.

El software o plataforma denominada ~~MADDEN~~ HADDEN es utilizado por los protagonistas en diversas localizaciones, sugiriendo que es un estándar en su campo. Aunque en la realidad no existe un software conocido con ese nombre en el ámbito científico, en la película parece ser una herramienta integral para el análisis de datos y comunicación.

Videoconferencias y Comunicaciones

Las videoconferencias sin «lags» (retrasos) que se muestran en la película son notables, especialmente considerando las limitaciones tecnológicas de la época. La presencia del logo de Netscape durante estas comunicaciones resalta el optimismo sobre las capacidades de Internet en 1997. En ese entonces, las conexiones de alta velocidad no eran comunes, y las videollamadas de calidad eran más una aspiración que una realidad.

Estándares y Sistemas Abiertos

La promoción de sistemas abiertos es evidente en la película. El uso de UNIX, basado en estándares abiertos, refleja una filosofía de colaboración y accesibilidad en el ámbito científico. Aunque Netscape Navigator no era software libre durante la producción de la película, su soporte para estándares abiertos de Internet lo convirtió en una herramienta esencial para la comunicación y el intercambio de información entre científicos y profesionales.

Hardware

En términos de hardware, la película presenta una variedad de equipos representativos de la tecnología de los años 90:

Monitor NEC MultiSync XE21: Un monitor CRT de 21 pulgadas conocido por su alta resolución y calidad de imagen, ideal para aplicaciones que requieren detalles precisos.

Monitores con marcas ocultas: Es interesante notar que en varios monitores se utilizan post-its o adhesivos para cubrir la marca y el modelo. Esto podría deberse a decisiones de producción para evitar publicidad no deseada o cuestiones legales relacionadas con derechos de marca.

Monitor CTX: Aunque no se especifica el modelo, los monitores CTX eran populares por su fiabilidad y rendimiento a un costo razonable.

Monitor Hansol Mazellan 17px: Los monitores Hansol eran reconocidos por su calidad en la reproducción de gráficos, siendo utilizados en diseño y aplicaciones multimedia.

Monitor IBM: IBM fue pionera en tecnología informática, y sus monitores eran sinónimo de calidad y durabilidad. Aunque no se especifica el modelo exacto, es probable que se trate de uno de sus populares monitores CRT utilizados en entornos profesionales.

Evolución de UNIX y Windows

Para entender el contexto tecnológico de la época, es útil comparar la evolución de UNIX y Windows, así como de los navegadores Netscape Navigator e Internet Explorer.

Detalles Adicionales

Cobertura de marcas: La práctica de cubrir las marcas y modelos en los monitores podría indicar un intento de la producción por crear un entorno más universal y atemporal, evitando asociar la tecnología presentada con productos específicos que podrían quedar obsoletos rápidamente. En bastantes fotogramas se nota que esto es completamente intencionado.

Representación de la tecnología: La película equilibra la precisión técnica con las necesidades narrativas. Si bien algunas representaciones, como las videoconferencias fluidas, eran tecnológicamente avanzadas para la época, sirven para enfatizar la conectividad y colaboración global entre los científicos.

SETI y la Búsqueda de Vida Extraterrestre: En Contact, la Dra. Ellie Arroway dedica su vida al proyecto SETI (Search for Extraterrestrial Intelligence), reflejando el esfuerzo real de la comunidad científica por encontrar señales de inteligencia extraterrestre. SETI es una iniciativa internacional que utiliza radiotelescopios para detectar posibles comunicaciones de civilizaciones fuera de la Tierra. La película captura la pasión y los desafíos asociados con este tipo de investigación, destacando la dedicación de los científicos que trabajan en el límite de lo conocido.

El Mensaje de Arecibo: El radiotelescopio de Arecibo en Puerto Rico juega un papel significativo tanto en la realidad como en la película. En 1974, desde este observatorio, se envió el famoso Mensaje de Arecibo, una transmisión de radio dirigida al cúmulo estelar M13, diseñada para demostrar los avances tecnológicos humanos y nuestra existencia a posibles civilizaciones extraterrestres. El mensaje contenía información codificada sobre la composición humana, nuestro sistema numérico, la estructura del ADN y nuestra posición en el sistema solar. En «Contact», aunque la señal recibida por Ellie proviene de Vega y no está directamente relacionada con el Mensaje de Arecibo, la película establece paralelismos con este acontecimiento histórico. La utilización de Arecibo como escenario subraya la conexión entre los esfuerzos reales y ficticios en la búsqueda de inteligencia extraterrestre. La película explora la posibilidad de que, así como enviamos mensajes al espacio, podríamos recibir respuestas o comunicaciones de otras civilizaciones.

Matthew McConaughey: Es interesante notar cómo este actor ha participado en dos de las películas más destacadas de la ciencia ficción: Contact e Interstellar. En Contact, McConaughey interpreta un papel secundario como Palmer Joss, un escritor y asesor espiritual que cuestiona las implicaciones éticas y filosóficas del descubrimiento científico. Diecisiete años después, en Interstellar, asume el rol protagonista de Cooper, un ex piloto de la NASA que emprende una misión interestelar para salvar a la humanidad.

Números primos: El inicio de la investigación seria de la señal extraterrestre en la película se desencadena cuando, al analizar la señal recibida, los científicos descubren que esta codifica una secuencia de números primos. Este hallazgo resulta crucial, ya que los números primos, al ser divisibles únicamente por 1 y por sí mismos, no surgen de forma aleatoria en procesos naturales conocidos. Su presencia en la señal sugiere intencionalidad e inteligencia detrás de su emisión, lo que confirma que no se trata de ruido cósmico sino de una posible comunicación deliberada desde una civilización avanzada. Este descubrimiento impulsa a los científicos a profundizar en la decodificación, marcando el verdadero inicio de la búsqueda de vida extraterrestre.

Conclusión

Contact no solo es una obra que invita a reflexionar sobre nuestro lugar en el universo y la posibilidad de vida más allá de la Tierra, sino que también es un retrato de la tecnología de su tiempo. La inclusión de sistemas operativos como UNIX, navegadores como Netscape y hardware específico refleja una atención al detalle que enriquece la narrativa. A pesar de que Netscape Navigator no era software libre durante la producción de la película, su presencia destaca la importancia de los estándares abiertos y la colaboración en el avance científico.

También destaca por su compromiso con la precisión científica, en gran parte debido a la influencia de Carl Sagan, autor de la novela original y asesor en la producción. La representación de los procedimientos del SETI, el análisis de señales y las discusiones éticas y filosóficas reflejan debates reales en la comunidad científica. La inclusión de elementos como el Mensaje de Arecibo y las operaciones del radiotelescopio añaden autenticidad a la narrativa y acercan al público a la realidad de la exploración espacial.

Bibliografía y Enlaces

Galería

ThisIsLegal.com – Realistic Challenge 3

27 agosto, 2014 por deurus·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Table of Contents

Introducción

Realistic Challenge 3: Your school is employing a web designer who is charging far too much for site design and doesn’t know anything about protecting the site. However, he’s sure that there’s no way anyone can hack into any site he’s designed, prove him wrong!

En tu escuela están haciendo una web nueva muy rápido. El creador asegura que no le pueden hackear, demuéstrale que está equivocado.

Analizando a la víctima

Echamos un vistazo y vemos en el menú cosas interesantes. La primera de ellas es un Login que pronto descartamos ya que no parece llevar a ninguna parte. La segunda sirve para mandar enlaces al administrador y que este los publique posteriormente en la web.

Vamos a trastear un poco con la opción de mandar enlaces. En el código fuente ya vemos algo interesante y es que hay un campo oculto con el valor a 1 al mandar el enlace. Probamos a mandar un enlace sin tocar nada y nos dice que lo manda pero que lo tienen que aprobar. Vamos a probar ahora cambiando el valor del parámetro oculto a 0 con Firebug.

¡Funcionó!, el enlace ha pasado el filtro.

¿Cómo podemos aprovechar esto?, pués la forma más común es «XSS cross site scripting«. Veamos una prueba. Con el parámetro oculto otra vez en 0 mandamos el siguiente enlace y reto superado.

Cruehead’s Crackme 2.0 Serial [2/3]

8 septiembre, 2014 por deurus·2 comentarios

Introducción

Continuamos con la segunda entrega de Cruehead. En este caso nos encontramos con un único campo de contraseña para introducir.

El algoritmo

Abrimos con Olly y vemos dos saltos. El primer Call realiza una serie de operaciones con el serial introducido y el segundo comprueba si el serial es correcto.

A continuación llegamos aquí:

00401365     /$  C605 18214000 00         MOV BYTE PTR DS:[402118],0
0040136C     |.  8B7424 04                MOV ESI,DWORD PTR SS:[ESP+4]
00401370     |.  56                       PUSH ESI
00401371     |>  8A06                     /MOV AL,BYTE PTR DS:[ESI]      ; <---
00401373     |.  84C0                     |TEST AL,AL
00401375     |.  74 19                    |JE SHORT CRACKME2.00401390
00401377     |.  FE05 18214000            |INC BYTE PTR DS:[402118]
0040137D     |.  3C 41                    |CMP AL,41                     ; 41 = A
0040137F     |.  72 04                    |JB SHORT CRACKME2.00401385    ; ya es mayúscula
00401381     |.  3C 5A                    |CMP AL,5A                     ; 5A = Z
00401383     |.  73 03                    |JNB SHORT CRACKME2.00401388   ; Convertir a mayúscula
00401385     |>  46                       |INC ESI
00401386     |.^ EB E9                    |JMP SHORT CRACKME2.00401371   ; Bucle -->
00401388     |>  E8 25000000              |CALL CRACKME2.004013B2
0040138D     |.  46                       |INC ESI
0040138E     |.^ EB E1                    \JMP SHORT CRACKME2.00401371
00401390     |>  5E                       POP ESI
00401391     |.  E8 03000000              CALL CRACKME2.00401399         ;Convertido a mayúsculas continuamos
00401396     |.  EB 00                    JMP SHORT CRACKME2.00401398
00401398     \>  C3                       RETN

Si nuestro serial contiene solo letras, las convierte a mayúsculas y seguimos aquí. En resumen hace XOR byte a byte entre nuestro serial y la frase «Messing_in_bytes»

00401399     /$  33DB                     XOR EBX,EBX
0040139B     |.  33FF                     XOR EDI,EDI
0040139D     |>  8A8F A3214000            /MOV CL,BYTE PTR DS:[EDI+4021A3]  ; Carga el primer byte de 4021A3
004013A3     |.  8A1E                     |MOV BL,BYTE PTR DS:[ESI]         ;
004013A5     |.  84DB                     |TEST BL,BL
004013A7     |.  74 08                    |JE SHORT CRACKME2.004013B1
004013A9     |.  32D9                     |XOR BL,CL                        ; byteSerial XOR Byte"Messing_in..."
004013AB     |.  881E                     |MOV BYTE PTR DS:[ESI],BL
004013AD     |.  46                       |INC ESI                          ;Siguiente byte de "Messing_in_bytes"
004013AE     |.  47                       |INC EDI                          ;Siguiente byte del serial
004013AF     |.^ EB EC                    \JMP SHORT CRACKME2.0040139D
004013B1     \>  C3                       RETN                              ;XOR finalizado volvemos

Estado del DUMP (memoria) antes del XOR y con nuestro serial (12345678) cargado.

00402118  00 47 6F 6F 64 20 77 6F 72 6B 21 00 47 72 65 61  .Good work!.Grea
00402128  74 20 77 6F 72 6B 2C 20 6D 61 74 65 21 0D 4E 6F  t work, mate!.No
00402138  77 20 74 72 79 20 74 68 65 20 6E 65 78 74 20 43  w try the next C
00402148  72 61 63 6B 4D 65 21 00 1F 2C 37 36 3B 3D 28 19  rackMe!.,76;=(
00402158  3D 26 1A 31 2D 3B 37 3E 4E 6F 20 6C 75 63 6B 21  =&1-;7>No luck!
00402168  00 4E 6F 20 6C 75 63 6B 20 74 68 65 72 65 2C 20  .No luck there,
00402178  6D 61 74 65 21 00 31 32 33 34 35 36 37 38 39 00  mate!.123456789.
00402188  00 00 00 00 00 00 00 00 00 00 54 72 79 20 74 6F  ..........Try to
00402198  20 63 72 61 63 6B 20 6D 65 21 00 4D 65 73 73 69   crack me!.Messi
004021A8  6E 67 5F 69 6E 5F 62 79 74 65 73 00 00 00 00 00  ng_in_bytes.....

Estado del DUMP después del XOR.

00402118  0A 47 6F 6F 64 20 77 6F 72 6B 21 00 47 72 65 61  .Good work!.Grea
00402128  74 20 77 6F 72 6B 2C 20 6D 61 74 65 21 0D 4E 6F  t work, mate!.No
00402138  77 20 74 72 79 20 74 68 65 20 6E 65 78 74 20 43  w try the next C
00402148  72 61 63 6B 4D 65 21 00 1F 2C 37 36 3B 3D 28 19  rackMe!.,76;=(
00402158  3D 26 1A 31 2D 3B 37 3E 4E 6F 20 6C 75 63 6B 21  =&1-;7>No luck!
00402168  00 4E 6F 20 6C 75 63 6B 20 74 68 65 72 65 2C 20  .No luck there,
00402178  6D 61 74 65 21 00 7C 57 40 47 5C 58 50 67 50 5E  mate!.|W@G\XPgP^
00402188  00 00 00 00 00 00 00 00 00 00 54 72 79 20 74 6F  ..........Try to
00402198  20 63 72 61 63 6B 20 6D 65 21 00 4D 65 73 73 69   crack me!.Messi
004021A8  6E 67 5F 69 6E 5F 62 79 74 65 73                 ng_in_bytes

A continuación comprueba nuestro serial XOReado con los bytes en memoria.

004013B8     /$  33FF                     XOR EDI,EDI
004013BA     |.  33C9                     XOR ECX,ECX
004013BC     |.  8A0D 18214000            MOV CL,BYTE PTR DS:[402118]                                
004013C2     |.  8B7424 04                MOV ESI,DWORD PTR SS:[ESP+4]                    ; APUNTA AL DUMP 40217E
004013C6     |.  BF 50214000              MOV EDI,CRACKME2.00402150                       ; APUNTA AL DUMP 402150
004013CB     |.  F3:A6                    REPE CMPS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]   ; VER NOTA**
004013CD     \.  C3                       RETN

Nota**

Si buscamos el comando REPE encontramos que si el flag Z = 1 el bucle se corta y que trabaja con bytes. El problema es que en Olly la instrucción REPE nosotros la vemos con un solo paso y nos puede pasar desapercibida.
En resumen, está comprobando los bytes de las direcciones 402150 (1F 2C 37 36 3B 3D 28 19 3D 26 1A 31 2D 3B 37 3E) con nuestro serial XOReado, 40217E en adelante, por lo que si hacemos XOR entre los bytes de 402150 y la frase «Messing_in_bytes» obtendremos la clave correcta.

M  e  s  s  i  n  g  _  i  n  _  b  y  t  e  s
4D 65 73 73 69 6E 67 5F 69 6E 5F 62 79 74 65 73
                                                XOR
1F 2C 37 36 3B 3D 28 19 3D 26 1A 31 2D 3B 37 3E
-----------------------------------------------
52 49 44 45 52 53 4F 46 54 48 45 53 54 4F 52 4D
R  I  D  E  R  S  O  F  T  H  E  S  T  O  R  M

Serial: RIDERSOFTHESTORM

Links

Canyouhack.it – Crack Challenge 4 (Brain Fuck Me)

Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de

CanYouHack.it Crack6 Challenge - Lights Out (English)

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

Blooper Tech Movie IX – The Sinner 2×06

Este BTM va otra vez sobre IPs. Si amigos del séptimo arte, viendo un capítulo de mi querida "The Sinner"

WinFan's NETCrackMe#1 Keygen

Introducción Tal y como nos adelanta el creador está programado en .NET. Lo abrimos para ver su comportamiento y a

1 2 3 … 30 Next »

Canyouhack.it – Crack Challenge 4 (Brain Fuck Me)

13 abril, 2017 por deurus·Sin comentarios

Aquí tenemos un crackme fuera de lo común, más que nada por que está programado en Brainfuck, un lenguaje de programación esotérico bastante complejo.

[-]>[-]<>++++++++[<++++++++++>-]<.+++++++++++++++++.>+++[<++++++>-]<..++++.-
-------.+++.--------------.>++++++[<------>-]<-.>+++++[<------>-]<-.,>,>,>,>
>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++
+++++++++++>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++>>>>++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<
<<<<<<<<<<<<<<<<[>>>>>>>-<<<<<<<-]>>>>>>><<+>>[[-]++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++.<]<[>]<<<<<[>>>>>>>>>>-<<<<<<<<
<<-]>>>>>>>>>><<+>>[[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++.<]<[>]<<<<<<<<[>>>>>>>>>>>>>-<<<<<<<<<<<<<-]>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.<]<[>]<<<<<<<<<<<[>>>>>>>>>>>>>>>>-<<<<<<<<<<<<<<<<-]>>>>>>>>>>>>>>>><<+>>[
[-]+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++.<]<[>]>>>[-]>[-]<+++++++++++++.---.>+++++++[<++++++++++++>-]<.>+++++++[<
--------->-]<+.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------
->-]<.>++++++++[<+++++++++>-]<+.+++++++++++.>+++++++[<----------->-]<.>+++++
++[<+++++++++++>-]<-.>+++++++[<------------>-]<+.>++++++++[<+++++++++++>-]<-
.-----.---------.+++++++++++..---------------.+++++++++.>++++++[<-----------
-->-]<.+++++++.>+++++[<++++++>-]<+.-----.++++++++.+++.>++++++[<------>-]<-.-
------.>++++++++[<++++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>++
+++[<++++++>-]<+.-----.+++++++++++.>++++++[<------>-]<-.-------.>++++++++[<+
+++++++++>-]<-.+++.>+++++++++[<--------->-]<-.+++++++.>+++++[<+++++>-]<+.+++
+++++.+++.>++++++[<------>-]<-.+++++++...--------------.>++++++++[<+++++++++
++>-]<+.----------.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-
]<.-------.>+++[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++
+++++[<++++++++++>-]<.-----.++++++++.+++.-------.-.>++++++[<--------->-]<.--
------------.>+++++[<++++++++>-]<+.>++++[<+++++++>-]<+.>+++++++[<---------->
-]<.>+++++++[<++++++++++++>-]<.------------.---.+++++++++++++.-------------.
>+++++++[<---------->-]<+.>++++++++[<+++++++++>-]<+.++++++++++.>+++++++[<---
--------->-]<+.>++++++[<+++++++++++++>-]<.+.+++++.------------.+.+++++.-----
--.>++++++[<---------->-]<+.------------.>++++++++[<+++++++++++>-]<+.-------
---.++++++.>+++++++[<------------>-]<-.>++++++++[<+++++++++>-]<.-------.>+++
[<+++++++>-]<.-----------------.>+++++++[<---------->-]<+.>++++++++[<+++++++
++++>-]<-.--------------.+++++.>++++++[<------------->-]<.+.

La solución que he encontrado yo, es convertir el código brainfuck a algo más amigable y depurarlo hasta encontrar la solución. La conversión la he realizado con VBBrainFNET y luego la depuración con Visual Studio. El crackme te pide una clave de cuatro cifras para darte la solución, pero si no quieres volverte loco puedes amañar los bucles para encontrar la solución.

¡SUERTE!

Enlaces

CanYouHack.it Crack6 Challenge – Lights Out (English)

26 agosto, 2014 por deurus·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Intro

This crackme is for the crack challenge 6 of canyouhack.it.

In this crackme the goal is to turn on all the lights. Note that a light off to the next, so if we interrupt this, we win.

Tools

Exeinfo (For crackme info)

Delphi Decompiler (For decompile)

OllyDbg (For debug)

Decompiling

With Delphi Decompiler we can found easy the buttons and his offsets.

Go to the offset 401A64 in OllyDbg and analyze the code.

We view two jumps, one turn ON the light and the other Turn OFF the next light. Patching the call from offset 401A8B we get the serial.

Canyouhack.it – Cryptography Challenge 13

13 abril, 2017 por deurus·Sin comentarios

Los retos criptográficos son muy variados y muchas veces la dificultad está en saber a que te enfrentas. En este caso pasa eso, te dan un código y si no has visto algo parecido en la vida, no sabes por donde empezar. El título del autor da una pequeña pista pero para los desconocedores no es suficiente. La pista es el título y dice «WTF?!?» y el código a descifrar es el siguiente:

[-]>[-]<
>+++++++++++[<+++++++++++>-]<.
>+++[<--->-]<-.
>++[<++>-]<++.
+.
>++++[<---->-]<-.
---.
+++.
.
>+++[<+++>-]<.
>+++[<--->-]<+.
>++++[<++++>-]<-.
>++++[<---->-]<--.
>+++[<+++>-]<-.
>++[<-->-]<--.
-.

Si eres una persona con recursos, realizaras varias búsquedas por la red y al final llegarás a la conclusión de que te enfrentas a BRAINFUCK, un lenguaje de programación esotérico como ya vimos en el reto de Root-Me.

Enlaces

ThisIsLegal.com – Realistic Challenge 5

28 agosto, 2014 por deurus·Sin comentarios

Warning: This challenge is still active and therefore should not be resolved using this information.
Aviso: Este reto sigue en activo y por lo tanto no se debería resolver utilizando esta información.

Table of Contents

Introducción

Realistic Challenge 5: There is a new company out called NullCo. Have a look around the site and see what you can do.

Hay una nueva compañia llamada NullCo. Echa un vistazo a la web haber que puedes hacer.

Analizando a la víctima

Echamos un vistazo a la web y lo único interesante que vemos es un buscador.

Miramos el código fuente y vemos una ruta interesante.

Si exploramos la ruta «http://www.thisislegal.com/nc/adm/» nos aparece un login. Metemos cualquier cosa y el mensaje de error da demasiada información.

Ahora fijémonos en el menú productos. Pinchamos sobre cualquier producto y a continuación en la imagen para ampliarla, veremos el siguiente enlace.

http://www.thisislegal.com/nc/i.php?img=images/serve

Explotando la víctima

Vamos a ver si podemos explotar «i.php«. Probamos a obtener información sensible del servidor.

Probamos «http://www.thisislegal.com/nc/i.php?img=adm/login.pwd» y nos da error, seguramente por que está anexionando la extensión de la imagen, es decir, el script está interpretando esto:

http://www.thisislegal.com/nc/i.php?img=adm/login.pwd.png

Vamos a anularlo con un caracter nulo. Probamos y ahora si.

El password está en base64. Lo decodificamos online, nos logueamos y reto superado.

ThisIsLegal.com – Realistic Challenge 4

27 agosto, 2014 por deurus·Sin comentarios

Table of Contents

Introducción

Realistic Challenge 4: There is a site offering protection against hackers to website owners, the service is far too overpriced and the people running the service don’t know anything about security. Look around their site, and see how protected it is.

Hay un sitio que ofrece protección contra los hackers. El servicio tiene un precio abusivo, echa un vistazo a la web y evalúa su pretección.

Analizando a la víctima

Vemos un escueto menú pero con cosas interesantes.

Pinchamos sobre «Testimonials» y a continuación en «Customer 1»

Vemos que hay solo 3 «customers», vamos a introducir manualmente un 5 haber que pasa.

Ok, nos genera el siguiente error.

Probamos ahora con un enlace interno que nos genera el siguiente error.

http://www.thisislegal.com/newr/src/read.php?customer=../orders.php

Nos llama la atención «../beqref.cuc«. Parece una encriptación simple, probemos a poner eso mismo en el navegador.

http://www.thisislegal.com/newr/src/read.php?customer=../beqref.cuc

Nuestras sospechas son acertadas, ahora el error muestra esto.

Explotando a la víctima

Probamos varias cosas y al final conseguimos algo relevante con «order2.php«.

http://www.thisislegal.com/newr/src/read.php?customer=../beqre2.cuc

Tenemos un directorio interesante «secure«, si entramos en el nos salta un Login típico protegido con «.htaccess«. Lo lógico a continuación es hacernos con el archivo «.htpasswd«

http://www.thisislegal.com/newr/src/read.php?customer=../frpher/.ugcnffjq

Una vez obtenido el contenido del archivo «.htpasswd» lo siguiente es crackear el password con John the Ripper. Nos logueamos en la carpeta secure y reto superado.

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

28 agosto, 2014 por deurus·3 comentarios

Aviso: Este crackme forma parte de una serie de pruebas de Yoire.com que todavía está en activo. Lo ético si continuas leyendo este manual es que no utilices la respuesta para completar la prueba sin esfuerzo. 😉

Analizando

Abrimos el crackme con Ollydbg y vamos a las referenced strings.

Pinchamos sobre cualquiera.

Vemos un «Call» donde seguramente se generará un SUM en función del serial metido ya que después del Call vemos una comprobación contra «B79E763E» lo que nos da una pista de que vamos a tener que utilizar fuerza bruta para llegar a ese valor. Vamos a explorar el Call.

Lo que resalto con la flecha son una par de Calls que podemos NOPear ya que lo único que hacen es ralentizar la generación del SUM.

A continuación vamos a analizar el algoritmo de generación del SUM.

MOV EDI,5EED                   - EDI = 5EED
JMP SHORT 01_crack.004010D7
/MOV EAX,EDI                   <----Bucle
|SHL EAX,5                     - 5EED * 32 = BDDA0
|MOVZX EDX,BYTE PTR DS:[EBX]   - Coge el dígito
|XOR EAX,EDX                   - BDDA0 XOR digito
|MOV EDI,EAX
|XOR EDI,1D0B1EED              - XOR 1D0B1EED
|INC EBX
|..
|MOV ESI,EAX
CMP BYTE PTR DS:[EBX],0
JNZ SHORT 01_crack.004010B4   - Bucle ---->

Para un serial de tres dígitos la secuencia sería esta (valores en hexadecimal):

1º Digit —> BDDA0 XOR 1D0B1EED XOR 1ºDigit XOR 1D0B1EED = Temp
2º Digit —> Temp = Temp * 20 Xor 1D0B1EED XOR 2ºDigit
3º Digit —> Temp = Temp * 20 Xor 1D0B1EED XOR 3ºDigit
…
CMP Temp, B79E763E

Aplicando Fuerza Bruta

La creación del «BruteForcer» os la dejo a vosotros. Aquí teneis un fragmento hecho en VB.Net.

Dim temp As Long
Dim temp2 As String
Dim letter As Integer
Dim brute As String
brute = TextBox4.Text
temp = 0
temp = Asc(Mid(brute, 1, 1)) Xor 487268077 Xor 777632
temp2 = Hex(temp)
temp2 = Microsoft.VisualBasic.Right(temp2, 8)
temp = Convert.ToUInt64(temp2, 16)
For i = 2 To Len(brute)
letter = Asc(Mid(brute, i, 1))
temp = temp * 32
temp2 = Hex(temp)
temp2 = Microsoft.VisualBasic.Right(temp2, 8)
temp = Convert.ToUInt64(temp2, 16)
temp = temp Xor 487268077
temp2 = Hex(temp)
temp2 = Microsoft.VisualBasic.Right(temp2, 8)
temp = Convert.ToUInt64(temp2, 16)
temp = temp Xor letter
'
temp2 = Hex(temp)
Next

Blooper Tech Movie VIII – Black Mirror 4×05 (MetalHead)

5 enero, 2018 por deurus·1 comentario

Hoy tenemos aquí un capitulo del gran David Slade, productor de Series como American Gods o Hannibal y director de películas como Hard Candy o 30 días de oscuridad.

Table of Contents

El guiño

Lo que más me ha gustado del capítulo es el guiño que han hecho a la RaspBerry PI. La escena transcurre al inicio del capítulo cuando uno de los protagonistas se conecta a un vehículo para hackearlo con una Raspi 3 Model B con varios pines del GPIO doblados. Os dejo unas capturas a continuación donde se aprecia el logo.

: Captura del episodio

: Captura del episodio

: Captura del episodio

: Captura del episodio

La conexión

Ya puestos, la conexión parece micro usb tipo B. Al fondo se ve lo que parece un puerto HDMI.

: Captura del episodio

: Captura del episodio

: Captura del episodio

: Cable comercial

La pifia

Lo que no me ha gustado es que al fijarme en el software que corre en el vehículo aparece un flamante OMNIBOOT.EXE con un aspecto parecido al símbolo de sistema, es decir, nos intentan vender que en un futuro el software que gestiona el vehículo es alguna variación de Windows, algo poco probable a día de hoy al menos. Con este tipo de predicciones no se puede escupir hacia arriba pero actualmente es más probable un nucleo tipo Linux u otro propietario al estilo Tesla.

Software del vehículo

Os dejo todas las capturas relevantes a continuación.

: Captura del episodio

: Captura del episodio

: Captura del episodio

: Captura del episodio

: Captura del episodio

: Software del vehículo

: Captura del episodio

: Captura del episodio

Solución al CrackMe Matrix de ZemoZ

19 agosto, 2020 por deurus·Sin comentarios

Table of Contents

Introducción

Aquí tenemos un CrackMe diferente a lo que estamos acostumbrados, ya que en vez del típico número de serie asociado a un nombre la comprobación se realiza mediante checkboxes con una matriz de 7×3. El CrackMe está realizado en Visual C++ lo que facilita en parte encontrar rápidamente la rutina de comprobación.

Comprobación

004013C5   > /8B7424 10     MOV     ESI,[DWORD SS:ESP+10]						;
004013C9   . |33FF          XOR     EDI,EDI
004013CB   > |8B86 74304000 MOV     EAX,[DWORD DS:ESI+403074]                   ;
004013D1   . |8BCB          MOV     ECX,EBX
004013D3   . |50            PUSH    EAX
004013D4   . |E8 6F020000   CALL    <JMP.&MFC42.#3092_CWnd::GetDlgItem>			; Lee el estado del checkbox
004013D9   . |8B48 20       MOV     ECX,[DWORD DS:EAX+20]
004013DC   . |6A 00         PUSH    0
004013DE   . |6A 00         PUSH    0
004013E0   . |68 F0000000   PUSH    0F0
004013E5   . |51            PUSH    ECX                                         ; 
004013E6   . |FFD5          CALL    NEAR EBP
004013E8   . |3B86 20304000 CMP     EAX,[DWORD DS:ESI+403020]					; Comprueba el estado del checkbox (1 activado 0 desactivado)
004013EE   . |75 20         JNZ     SHORT Matrix_C.00401410						; Salto a chico malo
004013F0   . |47            INC     EDI											; Incrementa contador
004013F1   . |83C6 04       ADD     ESI,4
004013F4   . |83FF 07       CMP     EDI,7										; ¿Hemos terminado de leer las columnas? ¿contador = 7?
004013F7   .^|7C D2         JL      SHORT Matrix_C.004013CB                     ; si terminan las columnas deja pasar
004013F9   . |8B4424 10     MOV     EAX,[DWORD SS:ESP+10]
004013FD   . |83C0 1C       ADD     EAX,1C										; contador de filas
00401400   . |83F8 54       CMP     EAX,54										; 3 filas = 1C+1C+1C=54
00401403   . |894424 10     MOV     [DWORD SS:ESP+10],EAX
00401407   .^\7C BC         JL      SHORT Matrix_C.004013C5						; ¿Hemos terminado de leer la fila? ¿contador = 54?
00401409   .  68 D8304000   PUSH    Matrix_C.004030D8                           ;  ASCII "Registration successful!"
0040140E   .  EB 05         JMP     SHORT Matrix_C.00401415
00401410   >  68 C8304000   PUSH    Matrix_C.004030C8                           ;  ASCII "Not registered!"

En la rutina de comprobación se ve fácil un CMP EDI,7 por lo que podemos deducir que si el creador no se ha molestado mucho la comprobación se realiza de izquierda a derecha y de arriba hacia abajo.

Tal es así que si ponemos un breakpoint en 4013E8, podemos ir sacando el estado correcto de los checkboxes sin mucha molestia.

Enlaces

CrackMe

Blooper Tech Movie VII – Absentia 1×06 (S01E06)

14 noviembre, 2017 por deurus·Sin comentarios

Table of Contents

Hide me

La escena la protagoniza Emily Byrne (Stana Katic) y en ella se ve a Emily buscar algo sospechoso en un portátil.

Primer detalle

Where is my Browser?

Para rematar…

Enlaces

Ficha en IMDB.

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....