Etiqueta: import reconstructor

Solución al CrackMe DAE 430

20 febrero, 2015 por deurus·2 comentarios

Introducción
Herramientas utilizadas
Desempacado con Ollydbg 2 (Videotutorial)
Desempacado con Ollydbg 1 (Videotutorial)
Análisis de la rutina del número de serie
Links

Table of Contents

Introducción

Este Crackme está basado en la protección de DVD Audio Extractor 4.3. Afrontaremos dos partes, una primera donde desempacaremos PECompact 2.x y otra donde analizaremos la rutina de comprobación del número de serie. Os adelante que la única dificultad reside en desempacar ya que la rutina del serial es bastante floja.

El motivo que me ha llevado a realizar un apartado para Ollydbg 1 y otro para Ollydbg 2 es principalmente por que con Ollydbg 2 lo haremos desde Windows 7 x64 y con Ollydbg 1 desde Windos 7 x32.

Herramientas utilizadas

Ollydbg2 con los plugins OllyDumEX y CmdBar.
Ollydbg1 con plugin OllyDump.
Import Reconstructor 1.6.

Desempacado con Ollydbg 2

Videotutorial disponible: http://youtu.be/-63yEUTqP-c.

Resumen de pasos:

Cargar Crackme en Ollydbg.
Pulsar F9.
Poner breakpoint «bp VirtualFree»
Pulsamos F9 dos veces.
Pulsamos Ctrl+F9.
Pulsamos F8 hasta salir del RETN.
Ponemos breakpoint a JMP EAX.
Dumpeamos.
Reconstruimos las importaciones.

1. Cargamos el Crackme en Olly y aparecemos aquí.

2. Pulsamos una vez F9 y veremos esto:

3. Ponemos un breakpoint de la siguiente manera «bp VirtualFree» con la ayuda del plugin CmdBar.

4. Pulsamos F9 dos veces y aparecemos aquí.

5. A continuación pulsamos Ctrl+F9 y veremos esto.

6. Pulsamos F8 hasta salir del RETN anterior y veremos esto.

7. Al final vemos lo que estábamos buscando. El JMP EAX es el salto que nos lleva al punto de entrada original (OEP). Ponemos un breakpoint en JMP EAX y pulsamos F9, cuando se detenga Ollydbg, pulsamos F8 y aparecemos aquí.

8. Ya tenemos a PECompact contra las cuerdas, ahora mismo tenemos el Crackme desempacado en memoria.

Hacemos click en Plugins > OllyDumpEx > Dump process y veremos esto.

Pulsamos en Dump y esto nos generará un archivo que se llama DAE430_CrackMe_dump.

9. A continuación con Import Reconstructor seleccionamos el crackme y pulsamos IAT AutoSearch y Get Imports.

Veremos unas importaciones NO válidas, pulsamos en Show Invalid y las clickamos con el botón derecho > Delete thunks.

Finalmente pulsamos Fix Dump y elegimos el crackme dumpeado anteriormente. Con esto ya hemos finalizado el desempacado.

Desempacado con Ollydbg 1

Videotutorial disponible: http://youtu.be/mm42HRlPXOE

Resumen de pasos:

Cargamos el crackme en Ollydbg.
Pulsamos F8 hasta el segundo Call y en éste entramos con F7.
Seguimos con F8.
Buscamos JMP EAX, le ponemos un breakpoint y ejecutamos hast que pare en el.
Situados en JMP EAX, pulsamos F8 y llegamos al OEP.
Dumpeamos.
Reconstruimos las importaciones.

1. Cargamos el crackme en Ollydbg y vemos esto.

2. Pulsamos F8 hasta que veamos dos Calls. Pulsamos F8 hasta el segundo Call y cuando estemos situados encima de él pulsamos F7 para entrar en el.

Dentro del segundo call veremos esto.

3. Seguimos con F8 y llegamos aquí.

4. Sin tracear, nos desplazamos por el código hasta encontrar un poco más abajo JMP EAX. Le ponemos un breakpoint y pulsamos F9.

5. Cuando estemos situados en JMP EAX pulsamos F8 y llegamos al punto de entrada original (OEP).

6. Ahora con el plugin OllyDump vamos a dumpear el ejecutable que tenemos desempacado en memoria.

Dumpeamos.

7. Finalmente con Import reconstructor arreglamos las importaciones.

Análisis de la rutina del número de serie

Cargamos en Ollydbg el crackme desempacado y en las referencias de texto encontramos el mensaje «Gracias por registrarte». Pulsamos en él y llegamos a la rutina de comprobación del serial que desgranamos a continuación.

00401B89    .  83F9 03             CMP ECX,3                                 ;  Len(nombre) >=3
00401B8C    .  0F8E 46010000       JLE DAE430_C.00401CD8
00401B92    .  B2 44               MOV DL,44                                 ;  Dl=44(Letra D)
00401B94    .  31C0                XOR EAX,EAX
00401B96    .  31FF                XOR EDI,EDI
00401B98    .  381403              CMP BYTE PTR DS:[EBX+EAX],DL              ;  Compara 1er digito con la letra D
00401B9B    .  74 05               JE SHORT DAE430_C.00401BA2
00401B9D    >  BF 01000000         MOV EDI,1
00401BA2    >  40                  INC EAX
00401BA3    .  83F8 04             CMP EAX,4
00401BA6    .  74 0C               JE SHORT DAE430_C.00401BB4
00401BA8    .  8A5404 45           MOV DL,BYTE PTR SS:[ESP+EAX+45]           ;  Memoria 22FAF5 a 22FAF | Lee los digitos A1X
00401BAC    .  381403              CMP BYTE PTR DS:[EBX+EAX],DL              ;  Los compara
00401BAF    .^ 75 EC               JNZ SHORT DAE430_C.00401B9D
00401BB1    .^ EB EF               JMP SHORT DAE430_C.00401BA2
00401BB3       90                  NOP
00401BB4    >  66:0FBE4424 53      MOVSX AX,BYTE PTR SS:[ESP+53]             ; EAX = 5ºdígito
00401BBA    .  8D1480              LEA EDX,DWORD PTR DS:[EAX+EAX*4]          ; EAX*4+EAX = A
00401BBD    .  8D04D0              LEA EAX,DWORD PTR DS:[EAX+EDX*8]          ; A*8 + 5ºdigito=B
00401BC0    .  66:C1E8 08          SHR AX,8                                  ; B/100=C
00401BC4    .  C0F8 02             SAR AL,2                                  ; C/4=D
00401BC7    .  8A5424 53           MOV DL,BYTE PTR SS:[ESP+53]               ; DL = 5ºdígito
00401BCB    .  C0FA 07             SAR DL,7                                  ; 5ºdígito/80=E
00401BCE    .  29D0                SUB EAX,EDX                               ; E-D=F    
00401BD0    .  8D0480              LEA EAX,DWORD PTR DS:[EAX+EAX*4]          ; F*4*F=G
00401BD3    .  8D0480              LEA EAX,DWORD PTR DS:[EAX+EAX*4]          ; G*4+G=H
00401BD6    .  8A5424 53           MOV DL,BYTE PTR SS:[ESP+53]               ; DL = 5ºdígito
00401BDA    .  29C2                SUB EDX,EAX                               ; 5ºdigito - H = I
00401BDC    .  83C2 41             ADD EDX,41                                ; I+41 = J
00401BDF    .  885424 4A           MOV BYTE PTR SS:[ESP+4A],DL               ; GUARDA J EN LA MEMORIA 22FAFA
00401BE3    .  66:0FBE4424 54      MOVSX AX,BYTE PTR SS:[ESP+54]
00401BE9    .  8D3480              LEA ESI,DWORD PTR DS:[EAX+EAX*4]
00401BEC    .  8D04F0              LEA EAX,DWORD PTR DS:[EAX+ESI*8]
00401BEF    .  66:C1E8 08          SHR AX,8
00401BF3    .  C0F8 02             SAR AL,2
00401BF6    .  8A4C24 54           MOV CL,BYTE PTR SS:[ESP+54]
00401BFA    .  C0F9 07             SAR CL,7
00401BFD    .  29C8                SUB EAX,ECX
00401BFF    .  89C6                MOV ESI,EAX
00401C01    .  8D34B6              LEA ESI,DWORD PTR DS:[ESI+ESI*4]
00401C04    .  8D34B6              LEA ESI,DWORD PTR DS:[ESI+ESI*4]
00401C07    .  8A4424 54           MOV AL,BYTE PTR SS:[ESP+54]               
00401C0B    .  89F1                MOV ECX,ESI
00401C0D    .  29C8                SUB EAX,ECX                               
00401C0F    .  89C6                MOV ESI,EAX
00401C11    .  8D46 41             LEA EAX,DWORD PTR DS:[ESI+41]             
00401C14    .  884424 4B           MOV BYTE PTR SS:[ESP+4B],AL               ;  GUARDA J2 EN LA MEMORIA 22FAFB para el 6ºdígito
00401C18    .  66:0FBE4424 55      MOVSX AX,BYTE PTR SS:[ESP+55]
00401C1E    .  8D3480              LEA ESI,DWORD PTR DS:[EAX+EAX*4]
00401C21    .  8D04F0              LEA EAX,DWORD PTR DS:[EAX+ESI*8]
00401C24    .  66:C1E8 08          SHR AX,8
00401C28    .  C0F8 02             SAR AL,2
00401C2B    .  8A4C24 55           MOV CL,BYTE PTR SS:[ESP+55]
00401C2F    .  C0F9 07             SAR CL,7
00401C32    .  29C8                SUB EAX,ECX
00401C34    .  89C6                MOV ESI,EAX
00401C36    .  8D34B6              LEA ESI,DWORD PTR DS:[ESI+ESI*4]
00401C39    .  8D34B6              LEA ESI,DWORD PTR DS:[ESI+ESI*4]
00401C3C    .  8A4424 55           MOV AL,BYTE PTR SS:[ESP+55]               
00401C40    .  89F1                MOV ECX,ESI
00401C42    .  29C8                SUB EAX,ECX                               
00401C44    .  89C6                MOV ESI,EAX
00401C46    .  8D46 41             LEA EAX,DWORD PTR DS:[ESI+41]             
00401C49    .  884424 4C           MOV BYTE PTR SS:[ESP+4C],AL               ;  GUARDA J3 EN LA MEMORIA 22FAFC para el 7ºdígito
00401C4D    .  66:0FBE4424 56      MOVSX AX,BYTE PTR SS:[ESP+56]
00401C53    .  8D3480              LEA ESI,DWORD PTR DS:[EAX+EAX*4]
00401C56    .  8D04F0              LEA EAX,DWORD PTR DS:[EAX+ESI*8]
00401C59    .  66:C1E8 08          SHR AX,8
00401C5D    .  C0F8 02             SAR AL,2
00401C60    .  8A4C24 56           MOV CL,BYTE PTR SS:[ESP+56]
00401C64    .  C0F9 07             SAR CL,7
00401C67    .  29C8                SUB EAX,ECX
00401C69    .  89C6                MOV ESI,EAX
00401C6B    .  8D34B6              LEA ESI,DWORD PTR DS:[ESI+ESI*4]
00401C6E    .  8D34B6              LEA ESI,DWORD PTR DS:[ESI+ESI*4]
00401C71    .  8A4424 56           MOV AL,BYTE PTR SS:[ESP+56]               
00401C75    .  89F1                MOV ECX,ESI
00401C77    .  29C8                SUB EAX,ECX                              
00401C79    .  89C6                MOV ESI,EAX
00401C7B    .  8D46 41             LEA EAX,DWORD PTR DS:[ESI+41]             
00401C7E    .  884424 4D           MOV BYTE PTR SS:[ESP+4D],AL               ;  GUARDA J4 EN LA MEMORIA 22FAFD para el 8ºdígito
00401C82    .  B8 08000000         MOV EAX,8
00401C87    .  381403              CMP BYTE PTR DS:[EBX+EAX],DL
00401C8A    .  74 05               JE SHORT DAE430_C.00401C91
00401C8C    >  BF 01000000         MOV EDI,1
00401C91    >  40                  INC EAX
00401C92    .  83F8 0C             CMP EAX,0C
00401C95    .  74 0D               JE SHORT DAE430_C.00401CA4
00401C97    .  8A5404 42           MOV DL,BYTE PTR SS:[ESP+EAX+42]
00401C9B    .  381403              CMP BYTE PTR DS:[EBX+EAX],DL              ;  Compara 22FAFA y siguientes con 9, 10, 11 y 12avo digito
00401C9E    .^ 75 EC               JNZ SHORT DAE430_C.00401C8C
00401CA0    .^ EB EF               JMP SHORT DAE430_C.00401C91
00401CA2    .  66:90               NOP
00401CA4    >  89F8                MOV EAX,EDI                               ; |
00401CA6    .  FEC8                DEC AL                                    ; |
00401CA8    .  74 5C               JE SHORT DAE430_C.00401D06                ; |
00401CAA    .  C74424 0C 40000000  MOV DWORD PTR SS:[ESP+C],40               ; |
00401CB2    .  C74424 08 4C004100  MOV DWORD PTR SS:[ESP+8],DAE430_C.0041004>; |ASCII "Info"
00401CBA    .  C74424 04 51004100  MOV DWORD PTR SS:[ESP+4],DAE430_C.0041005>; |ASCII "Gracias por registrarte."
00401CC2    .  C70424 00000000     MOV DWORD PTR SS:[ESP],0                  ; |
00401CC9    .  E8 EE000000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401CCE    .  83EC 10             SUB ESP,10
00401CD1    .  31C0                XOR EAX,EAX
00401CD3    .^ E9 F2FBFFFF         JMP DAE430_C.004018CA
00401CD8    >  C74424 0C 40000000  MOV DWORD PTR SS:[ESP+C],40               ; |
00401CE0    .  C74424 08 4C004100  MOV DWORD PTR SS:[ESP+8],DAE430_C.0041004>; |ASCII "Info"
00401CE8    .  C74424 04 6A004100  MOV DWORD PTR SS:[ESP+4],DAE430_C.0041006>; |ASCII "Nombre mínimo 4 caracteres."
00401CF0    .  C70424 00000000     MOV DWORD PTR SS:[ESP],0                  ; |
00401CF7    .  E8 C0000000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401CFC    .  83EC 10             SUB ESP,10
00401CFF    .  31C0                XOR EAX,EAX
00401D01    .^ E9 C4FBFFFF         JMP DAE430_C.004018CA
00401D06    >  C74424 0C 10000000  MOV DWORD PTR SS:[ESP+C],10               ; |
00401D0E    .  C74424 08 34004100  MOV DWORD PTR SS:[ESP+8],DAE430_C.0041003>; |ASCII "Error"
00401D16    .  C74424 04 3A004100  MOV DWORD PTR SS:[ESP+4],DAE430_C.0041003>; |ASCII "Registro fallido."
00401D1E    .  C70424 00000000     MOV DWORD PTR SS:[ESP],0                  ; |
00401D25    .  E8 92000000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA

Resumen

- El nombre debe tener más de 3 dígitos aunque no lo usa para el número de serie.
- El serial tiene 12 dígitos dividiendose en tres partes, 111122223333.
- La primera parte 1111 es comparada directamente con DA1X.
- Segunda parte (2222), para los dígitos 5º, 6º, 7º y 8º hace lo siguiente:
dígito *4 + dígito = A
A*8 + dígito=B
B/100 = C
C/4 = D
dígito/80 = E
E-D = F    
F*4*F = G
G*4+G = H
digito - H = I
I+41 = J
GUARDA J EN LA MEMORIA 22FAFA
**Todo esto se puede resumir en dígito mod 19 + 41
- Tercera parte (3333). Finalmente compara el resultado del 5º, 6º, 7º y 8º dígitos con el 9º, 10º, 11º y 12º dígitos.

Ejemplo:

Serial = DA1X12345678
1 - (31h mod 19h) + 41h = 48h(Y)
2 - (32h mod 19h) + 41h = 41h(A)
3 - (33h mod 19h) + 41h = 42h(B)
4 - (34h mod 19h) + 41h = 43h(C)
Compara Y con 5
Compara A con 6
Compara B con 7
Compara C con 8
Luego el serial correcto sería DA1X1234YABC

Tron – Reto IA de yoire.com

29 agosto, 2015 por deurus·1 comentario

Introducción
Objetivo del juego y normas
Código inicial
Primeras modificaciones
Terminando la faena
Código ganador
Curiosidades
Enlaces

Table of Contents

Introducción

Hace tiempo que me aficioné a los retos de Hacking y Cracking, y si bien la mayoría de ellos consisten en desencriptar una clave o realizar ingeniería inversa sobre un ejecutable, también los hay sobre programación pura y dura.

En esta ocasión se nos proporciona un código «muestra» parecido a PHP o C++ y tenemos que ingeniarnoslas para mejorarlo y ganar a la máquina.

Objetivo del juego y normas

El objetivo de esta misión es ganar a Tr0n en su propio juego: las carreras de motos. Se te proporcionará un programa (código) funcional para que veas como se controla el vehiculo. Usando tu inteligencia, tendrás que entender su uso y mejorarlo, ya que no es lo suficientemente bueno como para ganar a Tr0n. Tr0n lleva ya bastante tiempo en la parrilla de juegos y es bastante habilidoso 🙂

Cuando venzas a Tr0n un mínimo de 5 veces consecutivas, se te dará por superada esta prueba.

Buena suerte!!!

[ Available functions / Funciones disponibles ]
direction() returns current direction, change to a new one with direction([newdir])
getX(), getY() returns X and Y coordinates
collisionDistance() | collisionDistance([anydir]) returns the distance until collision
Note: parameters [*dir] can be empty or one of this values: UP DOWN LEFT or RIGHT

[ Constants / Constantes ]
UP DOWN LEFT RIGHT MAX_X MAX_Y

[ Rules / Reglas ]
Try to survive driving your bike and … / Intenta sobrevivir conduciendo tu moto y…
Don’t cross any line / No cruces ninguna línea
or crash with the corners! / o choques con las esquinas!

[ Mission / Mision ]
Use well this controller and beat Tr0n 5 consecutive times to score in this game
Usa bien este controlador y vence a Tr0n 5 veces consecutivas para puntuar en este juego

Código inicial

Nada más comenzar vemos que hemos perdido nuestra primera partida con el siguiente código:

	function controller(playerController $c){
		if($c->direction()==UP && $c->getY()<10){
			if(rand(0,1)==0) $c->direction(LEFT);
				else $c->direction(RIGHT);
			goto done;
		}
		if($c->direction()==DOWN && MAX_Y-$c->getY()<10){
			if(rand(0,1)==0) $c->direction(LEFT);
				else $c->direction(RIGHT);
			goto done;
		}
		if($c->direction()==LEFT && $c->getX()<10){
			if(rand(0,1)==0) $c->direction(UP);
				else $c->direction(DOWN);
			goto done;
		}
		if($c->direction()==RIGHT && MAX_X-$c->getX()<10){
			if(rand(0,1)==0) $c->direction(UP);
				else $c->direction(DOWN);
		}
		done:
	}

Nosotros somos el AZUL y la máquina es el VERDE.

Primeras modificaciones

Lo primero que tenemos que modificar son las distancias de las coordenadas que estan puestas en «<10» al mínimo, que sería «<2«. También sustituir la aleatoriedad «rand(0,1)==0» por algo más útil y comenzar a usar la función «collisionDistance()«.

Como podéis observar en el código inferior, usamos la función «collisionDistance()» para detectar cuando estamos a punto de chocar «collisionDistance() ==1» y para detectar a que lado nos conviene más girar en función de donde podamos recorrer más distancia «if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT); else $c->direction(RIGHT);«.

if($c->direction()==UP && $c->getY()==1 && $c->collisionDistance() ==1){
			if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
				else $c->direction(RIGHT);
		}
if($c->direction()==DOWN && MAX_Y-$c->getY()<2 || $c->collisionDistance() ==1){
			if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
				else $c->direction(RIGHT);
		}
if($c->direction()==LEFT && $c->getX()==1 && $c->collisionDistance() ==1){
			if($c->collisionDistance([UP]) >2) 
                                $c->direction(UP);
				else 
                                $c->direction(DOWN);
		}
if($c->direction()==RIGHT && MAX_X-$c->getX()<2 || $c->collisionDistance() ==1){
			if($c->collisionDistance([UP]) >2) $c->direction(UP);
				else $c->direction(DOWN);
				
		}

Terminando la faena

El código anterior de por sí no nos resuelve mucho si no afinamos un poco más, comprobando todos las posibles colisiones y tomando la dirección correcta en función de la mayor distancia a recorrer.

    if($c->collisionDistance([UP])==1 || $c->collisionDistance() ==1){
             if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
               $c->direction(LEFT);
             else 
               $c->direction(RIGHT);
     }
     if($c->collisionDistance([DOWN])==1 || $c->collisionDistance() ==1){
            if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
               $c->direction(LEFT);
             else 
               $c->direction(RIGHT);
     }
     if($c->collisionDistance([RIGHT])==1 || $c->collisionDistance() ==1){
             if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
               $c->direction(UP);
             else 
               $c->direction(DOWN);
     }
     if($c->collisionDistance([LEFT])==1 || $c->collisionDistance() ==1){
          if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
               $c->direction(UP);
             else 
               $c->direction(DOWN);
     }

Código ganador

El código que utilicé yo para ganar a Tron es el siguiente:

function controller(playerController $c){
uno:
if($c->direction()==UP && $c->getY()==1 && $c->collisionDistance() ==1){
			if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
				else $c->direction(RIGHT);
				
		}
if($c->direction()==DOWN && MAX_Y-$c->getY()<2 || $c->collisionDistance() ==1){
			if($c->collisionDistance([LEFT]) >2) $c->direction(LEFT);
				else $c->direction(RIGHT);
				
		}
if($c->direction()==LEFT && $c->getX()==1 && $c->collisionDistance() ==1){
			if($c->collisionDistance([UP]) >2) 
                                $c->direction(UP);
				else 
                                $c->direction(DOWN);
				
		}
if($c->direction()==RIGHT && MAX_X-$c->getX()<2 || $c->collisionDistance() ==1){
			if($c->collisionDistance([UP]) >2) $c->direction(UP);
				else $c->direction(DOWN);
				
		}
dos:
    if($c->collisionDistance([UP])==1 || $c->collisionDistance() ==1){
             if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
               $c->direction(LEFT);
             else 
               $c->direction(RIGHT);
     }
     if($c->collisionDistance([DOWN])==1 || $c->collisionDistance() ==1){
            if($c->collisionDistance([LEFT]) > $c->collisionDistance([RIGHT]))
               $c->direction(LEFT);
             else 
               $c->direction(RIGHT);
     }
     if($c->collisionDistance([RIGHT])==1 || $c->collisionDistance() ==1){
             if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
               $c->direction(UP);
             else 
               $c->direction(DOWN);
     }
     if($c->collisionDistance([LEFT])==1 || $c->collisionDistance() ==1){
          if($c->collisionDistance([UP]) > $c->collisionDistance([DOWN]))
               $c->direction(UP);
             else 
               $c->direction(DOWN);
     }
		done:
	}

Mis jugadas ganadoras:

El código no es infalible ya que como comprabaréis vosotros mismos, no se puede ganar siempre por el mero hecho de la aleatoriedad y de la suerte. Cuando dispongais de un código decente, ejecutarlo varias veces para estar seguros antes de desecharlo.

Curiosidades

Como se suele decir, la banca siempre gana, y en este caso no iba a ser menos y es que en caso de empate ¡la banca gana!

Por último deciros que podéis utilizar el código ya que la web detecta los códigos ganadores para que no se repitan.

Enlaces

Web del reto

VideoTutorial – Keygen y desempacado UPX para el Crackme#1 de ECloZion

22 septiembre, 2014 por deurus·2 comentarios

Versión de texto

Lista de reproducción

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

Solución al Time Trial de Detten

21 octubre, 2014 por deurus·Sin comentarios

Intro

Hoy tenemos aquí otro crackme sacado del baúl de los recuerdos. En este caso se trata de una protección por tiempo límite a través de un keyfile llamado «data.det«. Disponemos de tres días o nueve sesiones antes de que el crackme expire.

El algoritmo

La primera vez que ejecutamos el crackme, crea el fichero «data.det» y realiza lo siguiente:

Lee el fichero data.det que inicialmente tiene 10 bytes a cero y el último byte un 60(`).
Comprueba que tenga 11 bytes (B) y continúa.
Al detectar el fichero vacío le mete valores codificandolos con XOR 6969. Los almacena en memoria 4030AB y siguientes.

00401000 t>/$  6A 00               PUSH 0                                    ; /pModule = NULL
00401002   |.  E8 0B020000         CALL <JMP.&KERNEL32.GetModuleHandleA>     ; \GetModuleHandleA
00401007   |.  A3 F4304000         MOV DWORD PTR DS:[4030F4],EAX             ;  kernel32.BaseThreadInitThunk
0040100C   |.  6A 00               PUSH 0                                    ; /hTemplateFile = NULL
0040100E   |.  68 80000000         PUSH 80                                   ; |Attributes = NORMAL
00401013   |.  6A 03               PUSH 3                                    ; |Mode = OPEN_EXISTING
00401015   |.  6A 00               PUSH 0                                    ; |pSecurity = NULL
00401017   |.  6A 00               PUSH 0                                    ; |ShareMode = 0
00401019   |.  68 000000C0         PUSH C0000000                             ; |Access = GENERIC_READ|GENERIC_WRITE
0040101E   |.  68 A2304000         PUSH timetria.004030A2                    ; |FileName = "DATA.DET"
00401023   |.  E8 DE010000         CALL <JMP.&KERNEL32.CreateFileA>          ; \CreateFileA
00401028   |.  83F8 FF             CMP EAX,-1
0040102B   |.  74 07               JE SHORT timetria.00401034
0040102D   |.  A3 14314000         MOV DWORD PTR DS:[403114],EAX             ;  kernel32.BaseThreadInitThunk
00401032   |.  EB 18               JMP SHORT timetria.0040104C
00401034   |>  6A 30               PUSH 30                                   ; /Style = MB_OK|MB_ICONEXCLAMATION|MB_APPLMODAL
00401036   |.  68 38304000         PUSH timetria.00403038                    ; |Title = "I don't like this !"
0040103B   |.  68 02304000         PUSH timetria.00403002                    ; |Text = "Where is my DATA.DET file?\r\nI can't run without it..."
00401040   |.  6A 00               PUSH 0                                    ; |hOwner = NULL
00401042   |.  E8 B3010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401047   |.  E9 22010000         JMP timetria.0040116E
0040104C   |>  6A 00               PUSH 0                                    ; /pOverlapped = NULL
0040104E   |.  68 E0304000         PUSH timetria.004030E0                    ; |pBytesRead = timetria.004030E0
00401053   |.  6A 32               PUSH 32                                   ; |BytesToRead = 32 (50.)
00401055   |.  68 AB304000         PUSH timetria.004030AB                    ; |Buffer = timetria.004030AB
0040105A   |.  FF35 14314000       PUSH DWORD PTR DS:[403114]                ; |hFile = NULL
00401060   |.  E8 B9010000         CALL <JMP.&KERNEL32.ReadFile>             ; \ReadFile
00401065   |.  833D E0304000 0B    CMP DWORD PTR DS:[4030E0],0B
0040106C   |.  0F85 E9000000       JNZ timetria.0040115B
00401072   |.  BB AB304000         MOV EBX,timetria.004030AB
00401077   |.  68 E4304000         PUSH timetria.004030E4                    ; /pSystemTime = timetria.004030E4
0040107C   |.  E8 97010000         CALL <JMP.&KERNEL32.GetSystemTime>        ; \GetSystemTime
00401081   |.  803B 00             CMP BYTE PTR DS:[EBX],0
00401084   |.  75 22               JNZ SHORT timetria.004010A8               ;  Si existe el fichero salta a las comprobaciones
00401086   |.  51                  PUSH ECX
00401087   |.  33C9                XOR ECX,ECX
00401089   |.  EB 15               JMP SHORT timetria.004010A0
0040108B   |>  66:8B81 E4304000    /MOV AX,WORD PTR DS:[ECX+4030E4]          ;  |
00401092   |.  66:35 6969          |XOR AX,6969                              ;  |
00401096   |.  66:8981 AB304000    |MOV WORD PTR DS:[ECX+4030AB],AX          ;  |
0040109D   |.  83C1 02             |ADD ECX,2                                ;  | Bucle de codificacion de data.det por primera vez
004010A0   |>  83F9 08              CMP ECX,8                                ;  |
004010A3   |.^ 76 E6               \JBE SHORT timetria.0040108B              ;  |
004010A5   |.  59                  POP ECX                                   ;  kernel32.7580EE1C
004010A6   |.  EB 3A               JMP SHORT timetria.004010E2

Vigilando el proceso de creación del archivo podemos llegar a la conclusión de como se genera.

Los dos primeros bytes son el año = 2014 = 0x7DE. 7DE XOR 6969 = 6EB7.
Los dos siguientes son el mes = 10 = 0xA. A XOR 6969 = 6963.
Los dos siguientes usa un 4 (día de la semana???) = 0x4. 4 XOR 6969 = 696D.
Los dos siguientes son el día del mes = 2 = 0x2. 2 XOR 6969 = 696B
Los dos siguientes usa un 1 = 0x1. 1 XOR 6969 = 6968.
El número de sesiones lo deja como está, 60.

Estado de la memoria:

004030AB  B7 6E 63 69 6D 69 6B 69 68 69 60                 ·ncimikihi`

Finalmente le resta 1 al número de sesiones y guarda el fichero.

004010E2   |> \A0 B5304000         MOV AL,BYTE PTR DS:[4030B5]
004010E7   |.  34 69               XOR AL,69
004010E9   |.  3C 00               CMP AL,0
004010EB   |. /74 59               JE SHORT timetria.00401146
004010ED   |. |FEC8                DEC AL
004010EF   |. |A2 01304000         MOV BYTE PTR DS:[403001],AL
004010F4   |. |34 69               XOR AL,69
004010F6   |. |A2 B5304000         MOV BYTE PTR DS:[4030B5],AL
004010FB   |. |6A 00               PUSH 0                                    ; /Origin = FILE_BEGIN
004010FD   |. |6A 00               PUSH 0                                    ; |pOffsetHi = NULL
004010FF   |. |6A 00               PUSH 0                                    ; |OffsetLo = 0
00401101   |. |FF35 14314000       PUSH DWORD PTR DS:[403114]                ; |hFile = 00000034 (window)
00401107   |. |E8 18010000         CALL <JMP.&KERNEL32.SetFilePointer>       ; \SetFilePointer
0040110C   |. |6A 00               PUSH 0                                    ; /pOverlapped = NULL
0040110E   |. |68 E0304000         PUSH timetria.004030E0                    ; |pBytesWritten = timetria.004030E0
00401113   |. |6A 0B               PUSH 0B                                   ; |nBytesToWrite = B (11.)
00401115   |. |68 AB304000         PUSH timetria.004030AB                    ; |Buffer = timetria.004030AB
0040111A   |. |FF35 14314000       PUSH DWORD PTR DS:[403114]                ; |hFile = 00000034 (window)
00401120   |. |E8 05010000         CALL <JMP.&KERNEL32.WriteFile>            ; \WriteFile

En cada ejecución realiza tres comprobaciones.
Recordemos el contenido del fichero:

B7 6E 63 69 6D 69 6B 69 68 69 60                 ·ncimikihi`

1) Mes y año (4 primeros bytes)

004010A8   |> \8B0D AB304000       MOV ECX,DWORD PTR DS:[4030AB] ; ECX=69636EB7
004010AE   |.  81F1 69696969       XOR ECX,69696969              ; 69636EB7 xor 69696969 = A07DE (A = mes y 7DE = año)
004010B4   |.  A1 E4304000         MOV EAX,DWORD PTR DS:[4030E4]
004010B9   |.  3BC1                CMP EAX,ECX                   ; Compara con mes y año actuales
004010BB   |.  0F85 85000000       JNZ timetria.00401146         ; Bad boy

2) Día (7º y 8º byte)

004010C1   |.  66:8B0D B1304000    MOV CX,WORD PTR DS:[4030B1]   ; CX = 696B
004010C8   |.  66:81F1 6969        XOR CX,6969                   ; 696B xor 6969 = 2
004010CD   |.  66:A1 EA304000      MOV AX,WORD PTR DS:[4030EA]   ; AX = día actual obtenido con GetSystemTime
004010D3   |.  66:2BC1             SUB AX,CX                     ; Los resta
004010D6   |.  66:83F8 03          CMP AX,3                      ; Compara con 3
004010DA   |.  77 6A               JA SHORT timetria.00401146    ; Si el resultado >=3 Bad Boy

3) Sesiones (11º byte)

004010DC   |.  2805 00304000       SUB BYTE PTR DS:[403000],AL   ;
004010E2   |>  A0 B5304000         MOV AL,BYTE PTR DS:[4030B5]   ; AL = numero de sesiones actual
004010E7   |.  34 69               XOR AL,69                     ; 61 Xor 69 = 8
004010E9   |.  3C 00               CMP AL,0                      ; Compara con 0
004010EB   |.  74 59               JE SHORT timetria.00401146    ; Salta si hemos superado las 9 sesiones. Bad boy
004010ED   |.  FEC8                DEC AL                        ; Si no le resta 1
004010EF   |.  A2 01304000         MOV BYTE PTR DS:[403001],AL
004010F4   |.  34 69               XOR AL,69                     ; y le hace xor 69 para codificar el nuevo valor de sesión
004010F6   |.  A2 B5304000         MOV BYTE PTR DS:[4030B5],AL

Con esto ya podemos alterar el archivo a nuestro antojo sin necesidad de parchear.

Keygen

Try
            ano = ano Xor 26985
            mes = mes Xor 26985
            dia = dia Xor 26985
            anos = Hex(ano).ToString
            mess = Hex(mes).ToString
            dias = Hex(dia).ToString
            If txtsesiones.Text <= 255 Then
                sesioness = Hex(sesiones)
            Else
                sesiones = 255
            End If
            sesioness = Hex(sesiones)
            'key = 00 00 00 00 00 00 00 00 00 00 00
            'key = año+año+mes+mes+X+X+dia+dia+X+sesiones
            key = Chr(Convert.ToInt32(anos.Substring(2, 2), 16)) & Chr(Convert.ToInt32(anos.Substring(0, 2), 16)) _
            & Chr(Convert.ToInt32(mess.Substring(2, 2), 16)) & Chr(Convert.ToInt32(mess.Substring(0, 2), 16)) _
            & Chr(106) & Chr(105) _
            & Chr(Convert.ToInt32(dias.Substring(2, 2), 16)) & Chr(Convert.ToInt32(dias.Substring(0, 2), 16)) _
            & Chr(103) & Chr(105) _
            & Chr(Convert.ToInt32(sesioness.Substring(0, 2), 16))
            'Creo el archivo llave
            Dim ruta As String = Application.StartupPath & "\DATA.DET"
            If File.Exists(ruta) Then
                File.Delete(ruta)
            End If
            Using sw As StreamWriter = New StreamWriter(ruta, True, System.Text.Encoding.Default)
                sw.Write(key)
                sw.Close()
            End Using
            MsgBox("DATA.DET generado correctamente", MsgBoxStyle.Information + MsgBoxStyle.OkOnly, "Info")
        Catch ex As Exception
            MsgBox("Ocurrió algún error" & vbCrLf & ex.Message)
        End Try

Links

Blooper Tech Movie VIII – Black Mirror 4x05 (MetalHead)

Hoy tenemos aquí un capitulo del gran David Slade, productor de Series como American Gods o Hannibal y director de

Keygen para el CrackMe Pythagoras de Spider

Introducción Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por

Blooper Tech Movie I - The Ring (La Señal)

Con The Ring inauguro una nueva sección llamada Blooper Tech Movie (BTM), algo así como pifias o tomas falsas tecnológicas

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

1 2 3 … 30 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

: Captura del episodio

: Software del vehículo

: Captura del episodio

Keygen para el CrackMe Pythagoras de Spider

24 abril, 2017 por deurus·Sin comentarios

Table of Contents

Introducción

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

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

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

Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890

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

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

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

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

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

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

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

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

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

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

Primera condición

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

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

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

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

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

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

Introducimos Nombre: deurus y Serial: 9834567890

Segunda condición

Analicemos el siguiente código.

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

En resumen:

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

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

Serial = aabbbbcccc

Tercera condición

Finalmente comprueba lo siguiente:

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

En resumen:

7890 – 3456 – 8 = 0

Creación del Keygen

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

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

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

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

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

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

Enlaces

Blooper Tech Movie I – The Ring (La Señal)

22 noviembre, 2015 por deurus·Sin comentarios

Con The Ring inauguro una nueva sección llamada Blooper Tech Movie (BTM), algo así como pifias o tomas falsas tecnológicas en películas. Aunque no os lo creáis, los creadores del séptimo arte y sus asesores son humanos, y como tal se rigen por la ley del mínimo esfuerzo. En este BTM vamos a ver como una simple escena nos puede arruinar la excelente atmósfera de intriga que hasta ese momento se respiraba.

BTM

Transcurridos 70 minutos de película vemos que la protagonista está en una redacción buscando información sobre la maldita cinta de vídeo en un PC.

Hasta aquí todo correcto, pero instantes después vemos que realiza una búsqueda sobre «Moesko Islands» y cuando se abre el plano y podemos ver la barra de direcciones, en realidad vemos un archivo local situado en «C:\WIN98\Desktop\search.com\2_moesko_island_pt2.html«. A continuación la secuencia, se pueden ver los enlaces «locales» en el segundo 13 y 17.

Imagen 1 – «C:\WIN98\Desktop\search.com\2_moesko_island_pt2.html»

Imagen 2 – «C:\WIN98\Desktop\search.com\restoration.html»

Teniendo en cuenta que la película data del año 2002, me parece increíble que los productores no se lo curraran un poco más y registraran un dominio como «jdoesearch.com» y simularan que se realizan las búsquedas ONline y no OFFline como se están haciendo en realidad.

Quizá no tenían pensado mostrar la parte superior del navegador o simplemente pensaron que nadie se fijaría pero el caso es que para cualquiera que haya navegado por Internet más de 2 veces, si se fija en la barra de direcciones su expresión facial cambia a WTF!.

Enlaces

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 1.0 Keygen [1/3]

Introducción Esta es la primera entrega de tres en las que vamos a ver tres crackmes que todo reverser debería

Stego d33p

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

Keygen para el Crackme#1 de DiS

Intro Hoy tenemos un crackme realizado en ensamblador y sin empacar. Consiste en el típico serial asociado a un nombre

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 1.0 Keygen [1/3]

8 septiembre, 2014 por deurus·4 comentarios

Introducción

Esta es la primera entrega de tres en las que vamos a ver tres crackmes que todo reverser debería hacer. Son la serie del autor Cruehead. Aunque los hice hace ya muchos años, he decidido documentarlos para que el lector que empieza pueda deleitarse. En este caso se trata del típico Nombre / Serial.

El algoritmo

El algoritmo de este crackme es lo más sencillo que nos podemos encontrar.

Abrimos el crackme con Olly y buscamos en las «string references» el mensaje de error. Pinchamos sobre el y en la parte superior enseguida vemos 2 calls muy interesantes.

Veamos que hace con el nombre.

Para «deurus» pondría todo en mayúsculas, sumaría su valor ascii y le haría XOR 0x5678.

Ejemplo:

deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0

Veamos que hace con el serial introducido.

Convierte nuestro serial a hexadecimal y le hace XOR 0x1234.

Ejemplo:

Serial = 12345 –> 0x3039 XOR 0x1234 = 0x220D

Una vez que tenemos el SUMNombre y el SUMSerial los compara. Lo vemos en CMP EAX, EBX.

En resumen, si a nuestro SUMNombre le hacemos XOR 0x5678 y XOR 0x1234 ya tenemos el serial bueno.

Ejemplo:

deurus –> DEURUS –> 0x44+0x45+0x55+0x52+0x55+0x53 = 0x1D8 XOR 0x5678 = 0x57A0 XOR 0x1234 = 0x4594

0x4594 = 17812

El Keygen

char Nombre[20];
GetWindowText(hwndEdit1, Nombre, 20);
char Serial[20];
int len = strlen(Nombre);
int suma = 0;
boolean error = false;
   for(int i = 0; i <= len; i = i + 1)
   {
      suma += toupper(Nombre[i]);
   }
suma = suma^0x444C; //444C == 5678 xor 1234
wsprintf(Serial,"%d",suma);
SetWindowText(hwndEdit2, TEXT(Serial));

Links

Reto Stego 1 de Hacker Games

Cambio de extensión Imagen oculta Descifrando el mensaje Enlaces Cambio de extensión (paso opcional) Al descargar la imagen de la

Keygen para el Crackme Sweeet Dream 1.0 de 2Sweeet

Intro Hoy tenemos aquí un crackme del año 2000 empacado y con un algoritmo aunque no muy complicado largo de

Solución al Crackme 7 de Scarebyte

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

Del Hacking a la IA: Cómo Expediente X Abordó la Tecnología de Vanguardia

La serie "Expediente X" (The X-Files) ha capturado la imaginación de los espectadores desde su debut en 1993, con sus

1 2 3 … 30 Next »

Reto Stego 1 de Hacker Games

2 diciembre, 2015 por deurus·Sin comentarios

Cambio de extensión
Imagen oculta
Descifrando el mensaje
Enlaces

Table of Contents

Cambio de extensión (paso opcional)

Al descargar la imagen de la web del reto vemos que tiene la extensión php y lo más probable es que no nos abra correctamente.

...
<br/>
<img src="steg1img.php"/>
<br/>
...

Abrimos la imagen con nuestro editor hexadecimal favorito y nos fijamos en la cabecera.

00000000h: 89 50 4E 47 0D 0A 1A 0A 00 00 00 0D 49 48 44 52 ; ‰PNG........IHDR

Renombramos entonces la extensión a png y continuamos.

Imagen oculta

Esta parte la afrontaremos con Steganabara, una herramienta muy útil que siempre uso cuando me enfrento a un reto «stego». En esta ocasión utilizaremos el análisis de color. Para ello pulsamos sobre «Analyse > Color table«.

En la tabla de colores tenemos la descomposición de colores RGBA y su frecuencia de aparición. Ordenamos por frecuencia descendiente y hacemos doble clic sobre la fila para abrir la imagen resultante.

A continuación un resumen de las imágenes obtenidas.

Como podéis observar, la imagen oculta es un código QR. Lo escaneamos con nuestra app preferida y obtenemos un texto encriptado.

dtsfwqutisvqtesymkuvabbujwhfecuvlshwopcyeghguywjvlaibflcacyahckyqvypjntfhihgtvyxeqakjwouldltuiuhbhjumgkxuugqahvwhotduqtahcknheypjetxpvlhxtlrpjagyjzcgijgfjmcupsslkzpuxegaillytlfbygeptzjtuzlvlwkzdznxqwpabbe

Descifrando el mensaje

A partir de aquí el reto pasa a ser de encriptación. Con el tiempo diferenciareis fácilmente el tipo de cifrado con sólo ver el texto. En este caso lo primero que se nos ocurre es comprobar dos cifrados clásicos como son el cifrado César y el Vigenere.

Tras desestimar el cifrado César realizamos un ataque de «fuerza bruta» al cifrado Vigenere mediante análisis estadístico. En la imagen que muestro a continuación se puede ver que la clave está cerca de ser «HPHQTC» pero todavía no se lee correctamente.

Ya que la fuerza bruta de por sí no termina de darnos la respuesta correcta, pasamos a probar algo muy útil, esto es, descifrar por fuerza bruta pero dándole una palabra para comparar. En este caso en concreto vemos que una posible palabra que pudiera estar en el texto encriptado es «PASSWORD», probamos y reto terminado.

Enlaces

Keygen para el Crackme Sweeet Dream 1.0 de 2Sweeet

27 septiembre, 2014 por deurus·Sin comentarios

Intro

Hoy tenemos aquí un crackme del año 2000 empacado y con un algoritmo aunque no muy complicado largo de tracear. Está empacado varias veces, algo poco habitual pero recordemos que es un crackme antiguo. Tras el empacado se encuentra Delphi.

Herramientas

PEiD o similar.
OllyDbg con plugin OllyDumpEX.
Import REConstructor.
LordPE (Opcional).

Desempacado multicapa

VideoTutorial del desempacado disponible

Si lo pasamos por PEiD nos dice que Aspack 2.1, Exeinfo no está muy seguro y RDG packer detector en el escaneo avanzado nos encuentra Aspack, UPX y PE-Pack.

En principio nos enfrentamos a Aspack 2.1, abrimos el crackme con OllyDbg y vemos el típico PUSHAD.

Pulsamos F8 (Step Over) y a continuación click derecho sobre el registro ESP y Follow in DUMP.

Seleccionamos los primeros cuatro bytes útiles del dump y les ponemos un Breakpoint de Hardware, Access y Dword.

Pulsamos F9 y nos para aquí:

Ya tenemos a Aspack contra las cuerdas, pulsamos F8 hasta después del RETN para llegar al OEP (Original Entry Point).

Pero en el supuesto OEP vemos otro PUSHAD por lo que esto no ha terminado. Investigando un poco más vemos que la segunda capa se corresponde con PE-PACK 1.0. La estrategia a seguir es la misma, como ya tenemos el breakpoint puesto pulsamos F9 y nos para aquí:

Pulsamos F8 y nos llega a otro PUSHAD. Esta vez es UPX.

Pulsamos de nuevo F9 y paramos aquí:

Pulsamos F8 y esta vez si llegamos al OEP (4576EC).

A continuación vamos a dumpear el archivo en memoria. Vamos a plugins > OllyDumpEX, pulsamos sobre «Get EIP as OEP» y finalmente sobre «Dump«.

Minimizamos Olly (no cerrar), abrimos el programa ImportREC y seleccionamos el ejecutable «Sweeet1.exe».

Pegamos el OEP original (576EC), le damos a AutoSearch y a continuación a Get Imports.

Finalmente pulsamos Fix Dump y elegimos el ejecutable dumpeado anteriormente. Esto nos genera un ejecutable dumpeado que es el ejecutable válido.

Ahora PEiD nos dice que estamos tratando con un crackme hecho en Delphi.

Hemos pasado por tres capas de compresión casi idénticas, vamos a analizarlas.

El algoritmo

Cuando abrimos el crackme nos fijamos en que genera una key. Esta key se genera en función del disco duro desde el que se ejecuta.

Como la secuencia de generación del serial válido es larga os pongo lo más importante muy resumido y con ejemplos como siempre.

El serial es del siguiente tipo:

Serial = 1ªParte-2ªParte-3ªParte
Serial = 0000XXXXX-SerialCalculado-xxxx000Z8

Comprobación del tamaño del nombre
----------------------------------
........
00456EAA    E8 01CCFAFF     CALL sweeet1_Fix_dump_rebuilded.00403AB0
00456EAF    83F8 04         CMP EAX,4    ------------------------------------------------; Nombre >=4                    
00456EB2    7D 13           JGE SHORT sweeet1_Fix_dump_rebuilded.00456EC7
00456EB4    A1 08954500     MOV EAX,DWORD PTR DS:[sweeet1_Fix_dump_rebuilded.459508]
00456EB9    8B00            MOV EAX,DWORD PTR DS:[EAX]
00456EBB    E8 0869FEFF     CALL sweeet1_Fix_dump_rebuilded.0043D7C8
00456EC0    BB 01000000     MOV EBX,1
00456EC5    EB 15           JMP SHORT sweeet1_Fix_dump_rebuilded.00456EDC
00456EC7    83FB 25         CMP EBX,25                                                                                                
00456ECA    7D 0E           JGE SHORT sweeet1_Fix_dump_rebuilded.00456EDA
00456ECC    83C3 32         ADD EBX,32
00456ECF    83C3 1E         ADD EBX,1E
00456ED2    83EB 4F         SUB EBX,4F
00456ED5    83FB 25         CMP EBX,25 -----------------------------------------------; Nombre <=25
00456ED8  ^ 7C F2           JL SHORT sweeet1_Fix_dump_rebuilded.00456ECC
00456EDA    33DB            XOR EBX,EBX
00456EDC    33C0            XOR EAX,EAX
........

1ºBucle - Nuestro nombre (A)
----------------------------
........
00456F55    BE 1B000000     MOV ESI,1B -------------------------------; ESI = 1B
00456F5A    EB 21           JMP SHORT sweeet1_dump_.00456F7D
00456F5C    8D55 D4         LEA EDX,[EBP-2C]
00456F5F    A1 34A84500     MOV EAX,DWORD PTR DS:[sweeet1_dump_.45A8
00456F64    8B80 C4020000   MOV EAX,DWORD PTR DS:[EAX+2C4]
00456F6A    E8 B5DAFCFF     CALL sweeet1_dump_.00424A24
00456F6F    8B45 D4         MOV EAX,DWORD PTR SS:[EBP-2C]
00456F72    0FB64418 FF     MOVZX EAX,BYTE PTR DS:[EBX+EAX-1]---------; Coje digito
00456F77    03F0            ADD ESI,EAX ------------------------------; digito + ESI
00456F79    43              INC EBX
00456F7A    0FAFF3          IMUL ESI,EBX  ----------------------------; multiplica por i (bucle)
00456F7D    8D55 D4         LEA EDX,[EBP-2C]
........

2ºBucle - La key (B)
--------------------
........
00456F9C         |.  BF 1A000000            MOV EDI,1A -------------------------;EDI = 1A
00456FA1         |.  BB 01000000            MOV EBX,1
00456FA6         |.  EB 1E                  JMP SHORT sweeet1_.00456FC6
00456FA8         |>  8D55 D4                /LEA EDX,[LOCAL.11]
00456FAB         |.  A1 34A84500            |MOV EAX,DWORD PTR DS:[45A834]
00456FB0         |.  8B80 D0020000          |MOV EAX,DWORD PTR DS:[EAX+2D0]
00456FB6         |.  E8 69DAFCFF            |CALL sweeet1_.00424A24
00456FBB         |.  8B45 D4                |MOV EAX,[LOCAL.11]
00456FBE         |.  0FB64418 FF            |MOVZX EAX,BYTE PTR DS:[EAX+EBX-1]--;Coje dígito
00456FC3         |.  03F8                   |ADD EDI,EAX -----------------------;Suma dígito a dígito
00456FC5         |.  43                     |INC EBX
00456FC6         |>  8D55 D4                 LEA EDX,[LOCAL.11]
00456FC9         |.  A1 34A84500            |MOV EAX,DWORD PTR DS:[45A834]
00456FCE         |.  8B80 D0020000          |MOV EAX,DWORD PTR DS:[EAX+2D0]
00456FD4         |.  E8 4BDAFCFF            |CALL sweeet1_.00424A24
00456FD9         |.  8B45 D4                |MOV EAX,[LOCAL.11]
00456FDC         |.  E8 CFCAFAFF            |CALL sweeet1_.00403AB0
00456FE1         |.  3BD8                   |CMP EBX,EAX
00456FE3         |.^ 7C C3                  \JL SHORT sweeet1_.00456FA8
........

Generación del serial central
-----------------------------
........
00456FE5         |.  B9 01000000            MOV ECX,1
00456FEA         |.  BB 01000000            MOV EBX,1
00456FEF         |.  8BC7                   MOV EAX,EDI
00456FF1         |.  F7EE                   IMUL ESI ----------; C = A * B
00456FF3         |.  99                     CDQ
........
00456FFD         |.  2345 E8                AND EAX,[LOCAL.6]--; D = A and C
00457000         |.  2355 EC                AND EDX,[LOCAL.5]
00457003         |.  8945 E8                MOV [LOCAL.6],EAX
00457006         |.  8955 EC                MOV [LOCAL.5],EDX
........
00457032         |.  8BC7                   MOV EAX,EDI
00457034         |.  99                     CDQ
00457035         |.  0345 E8                ADD EAX,[LOCAL.6]--; E = D + B
00457038         |.  1355 EC                ADC EDX,[LOCAL.5]
0045703B         |.  8945 E0                MOV [LOCAL.8],EAX
0045703E         |.  8955 E4                MOV [LOCAL.7],EDX
........
00405732           8B4424 10                MOV EAX,DWORD PTR SS:[ESP+10]
00405736           F72424                   MUL DWORD PTR SS:[ESP]
00405739           8BC8                     MOV ECX,EAX
0040573B           8B4424 04                MOV EAX,DWORD PTR SS:[ESP+4]
0040573F           F76424 0C                MUL DWORD PTR SS:[ESP+C]------; F = B * D
00405743           03C8                     ADD ECX,EAX
00405745           8B0424                   MOV EAX,DWORD PTR SS:[ESP]
00405748           F76424 0C                MUL DWORD PTR SS:[ESP+C]------; G = A * F
........
0045705E         |.  0B0424                 OR EAX,DWORD PTR SS:[ESP]-----; Serial central = G or A
........
00457077         |.  E8 FC07FBFF            CALL sweeet1_.00407878
0045707C         |.  8B45 F8                MOV EAX,[LOCAL.2]-------------; EAX = Serial central
........
004570D1         |.  E8 A207FBFF            CALL sweeet1_.00407878
004570D6         |.  8B45 D0                MOV EAX,[LOCAL.12]
004570D9         |.  E8 D2C9FAFF            CALL sweeet1_.00403AB0--------; Obtiene longitud del serial central en hexa
004570DE         |.  8BD8                   MOV EBX,EAX
........
004570D1         |.  E8 A207FBFF            CALL sweeet1_.00407878--------;*Nota

*Nota:
A partir de aquí genera la primera y tercera parte del serial de la siguiente manera:

Serial = 1ªParte-2ªParte-3ªParte
Serial = 0000XXXXX-SerialCalculado-xxxx000Z8

1ºParte = 3ºdigSerial+1ºdigSerial+2ºdigSerial+3ºdigSerial+4ºdigNombreMayu+2ºdigNombreMayu+5ºdigNombreMayu+1ºdigNombreMayu+3ºdigNombreMayu
3ºParte = 3ºdigNombreMin+1ºdigNombreMin+4ºdigNombreMin+2ºdigNombreMin+Tamaño Serial_2ªParte en Hex y de tres dígitos+Z8

Ejemplo:

Nombre: deurus
Key:    C0C0A000
Serial: 6906REUDU-906297047918-udre00CZ8

1) A = 23A2A (Con nuestro nombre empezando por 1B se lo suma a ESI y se lo multiplica por i (la que toque cada vez))
2) B = 1A1 (Con nuestra Key empezando por 1A va sumando los digitos)
3) C = B * A = 3A0BE6A
4) D = A and C = 3A2A
5) E = D + B = 3BCB (Offset 457035)
6) F = B * D = 5EBE6A (Offset 48704A)
7) G = A * F = D303834164
8) Serial = G or A (Serial = D303834164 or 23A2A = D303837B6E (906297047918))

A tener en cuenta:

1ªParte del serial siempre mayúsculas.
2ªParte siempre numérico. Usa el registro de 64 bits (Qword) con signo.**Nota
3ªParte siempre minúsculas.

**Nota:

Nombre: deurus.info
Key:    E09FF000
Serial: 9169REUDU-16918236-udre008Z8

Fíjate que: -16918236 = FFFFFFFFFEFDD924

Nombre: deurus
Key:    C0C0A000
Serial: 6906REUDU-906297047918-udre00CZ8

906297047918 = 000000D303837B6E

Links

Solución a los retos criptográficos de Rogerfm.net

Introducción Cripto 1 Cripto 2 Cripto 3 Cripto 4 Cripto 5 Cripto 6 Cripto 7 Cripto 8 Cripto 9 Cripto 10

Keygen para el CrackMe Pythagoras de Spider

Introducción Hoy tenemos aquí un bonito crackme matemático realizado por Spider. El crackme está realizado en ensamblador y precisamente por

This little bunny CrackMe

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

AfKayAs's CrackMe#2 KeyGen

Intro Hoy vamos a desmitificar un poco a Visual Basic. El Crackme reza que acabemos con la nag y hagamos

1 2 3 … 30 Next »

Solución a los retos criptográficos de Rogerfm.net

8 septiembre, 2018 por deurus·Sin comentarios

Introducción
Cripto 1
Cripto 2
Cripto 3
Cripto 4
Cripto 5
Cripto 6
Cripto 7
Cripto 8
Cripto 9
Cripto 10
Enlaces

Table of Contents

Introducción

Los retos de encriptación son muy variados como hemos comentado anteriormente. Aquí tenemos unos buenos ejemplos de ello.

Cripto 1

En este primer nivel nos encontramos con un método de encriptación muy antíguo. Sólo diré como pista, que es de los más antiguos que se conocen.

ozhlofxrlmvhxzorulimrz

Lo primero que suelo hacer en este tipo de retos cuando son solamente letras, es comprobar las dos opciones más típicas, que son el cifrado César y Vigenere. En este caso necesitamos ahondar un poco más, aunque enseguida llegamos a la conclusión de que el cifrado usado es el afín. Un ataque por fuerza bruta nos devuelve la solución y los coeficientes utilizados.

Solución: A=25,B=25 – LASOLUCIONESCALIFORNIA

Fuente: http://www.dcode.fr/chiffre-affine

Cripto 2

En este segundo nivel recordaremos a un general romano muy conocido. Lo complicaremos un poco, sólo lo justo para que cueste algo más de cinco minutos encontrar la clave 🙂

oehoeahhjoexhkzqhfsvzhffhwrhotqk

Lo primero que nos viene a la cabeza es el cifrado César pero no va. Probando varios cifrados por sustitución al final damos con el correcto. De nuevo un ataque por fuerza bruta nos da frutos.

Solución: (3,4,5)/1 – LACLAVEDELASEGUNDAPRUEBAESMEKONG

Fuente: https://www.dcode.fr/chiffre-decalages

Cripto 3

Este nivel también va a ser sencillo. Estos caracteres, pertenecientes a un sistema bastante conocido de encriptado, esconden una palabra que, al introducirla (en minúsculas), nos permitirá superar el nivel.

Investigando un poco llegamos a la conclusión de que se trata del cifrado Francmasón o Pig Pen.

Solución: primates

Fuente: https://www.dcode.fr/chiffre-pig-pen-francs-macons

Cripto 4

Esta prueba es tan simple que la he dividido en dos partes que, aunque de apariencia similar, se resuelven de distinta manera. La clave es la unión de las dos palabras resultantes de descifrar las dos líneas de números y que, juntas, forman una tercera palabra.

0111001101110101011100000110010101110010
0001001110011000111110100100110010010001

La primera parte se puede convertir en bloque:

0111001101110101011100000110010101110010 = super

Fuente: https://www.rapidtables.com/convert/number/binary-to-ascii.html

Para la segunda debemos separar en grupos de 5 dígitos y listo:

00010 01110 01100 01111 10100 10011 00100 10001

C O M P U T E R

Fuente: www.lindau-nobel.org

Cripto 5

Para descubrir la palabra clave sólo se necesita una mínima capacidad de observación.

31 04 40 23 20 34 33 13 23 22

Se trata del cuadrado de Polibio.

Cripto 6

Aquí hay que hacer un poco de trabajo de investigación: Hay que descubrir la clave que empleó un escritor francés (Una pista: «Lagardère») en una de sus novelas, que es la empleada aquí para formar la palabra clave (en minúsculas) que, por cierto, es alemana.

RI³I²MIL²I²A³

POR RESOLVER

Cripto 7

Seguimos con cosas fáciles. Se trata de descifrar este texto escrito en inglés.

kgw qkoev ol 617 qthpreoz iwjpz sdkg kgw pdeyeplk rwqdjzwe ipezwq spbbdq sgo sgwz goqkdbdkdwq iwjpz spq rwkwecdzwr ko cpmw gdq uweqozpb yozkedihkdoz ko kgw spe wlloek

Una vez descifrado, nos será fácil descubrir la clave:

pzpyozrp

Se trata de un cifrado de sustitución mono alfabético.

ABCDEFGHIJKLMNOPQRSTUVWXYZ
ZLMIRVHUBGTFJKOASDWQPYEXCN

THE STORY OF 617 SQUADRON BEGAN WITH THE AIRCRAFT DESIGNER BARNES WALLIS WHO WHEN HOSTILITIES BEGAN WAS DETERMINED TO MAJE HIS PERSONAL CONTRIBUTION TO THE WAR EFFORT

Una vez descifrado el alfabeto la solución queda:

pzpyozrp = anaconda

Cripto 8

A veces, las cosas no son lo que parecen. Donde aparecen unos números, en realidad hay otros números distintos.

273664524572348321143738
853442616537643005319627

POR RESOLVER

Cripto 9

Para resolver algunos problemas, hay que tener una buena base. Este es un buen ejemplo de ello:

ZW50ZXJwcmlzZQ0K

¿Os suena base 64?

Solución: enterprise

Fuente: https://www.base64decode.org/

Cripto 10

Esto es más complicado. Para descifrar este texto que contiene la clave para superar el nivel, se necesita otra clave. Para que no sea demasiado difícil, he utilizado una palabra muy sencilla de sólo cuatro letras 🙂

myiemyuvbaeewcxweghkflxw

Mediante fuerza bruta matamos dos pájaros de un tiro.

lapalabraclaveesdiogenes

Fuente: https://www.guballa.de/vigenere-solver

Enlaces

- Web del reto

Keygen para el CrackMe Pythagoras de Spider

24 abril, 2017 por deurus·Sin comentarios

Table of Contents

Introducción

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

Sabiendo esto introducimos Nombre: deurus y Serial: 1234567890

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

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

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

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

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

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

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

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

Primera condición

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

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

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

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

Introducimos Nombre: deurus y Serial: 9834567890

Segunda condición

Analicemos el siguiente código.

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

En resumen:

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

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

Serial = aabbbbcccc

Tercera condición

Finalmente comprueba lo siguiente:

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

En resumen:

7890 – 3456 – 8 = 0

Creación del Keygen

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

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

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

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

Enlaces

This little bunny CrackMe

10 septiembre, 2018 por deurus·Sin comentarios

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

En este pequeño CrackMe se nos pide investigar como se genera la clave que resuelve el reto. No tiene formulario donde introducir usuario y clave, cuando lo ejecutamos simplemente aparece una NAG dándonos a entender que no lo conseguimos.

Lo primero que vemos es esto:

004010B8 | 53                       | push ebx                                |
004010B9 | 56                       | push esi                                |
004010BA | 57                       | push edi                                |
004010BB | 83 C4 F4                 | add esp,FFFFFFF4                        |
004010BE | C6 05 84 20 40 00 00     | mov byte ptr ds:[402084],0              | Dirección 402084 = 0
004010C5 | C7 44 24 08 28 00 00 00  | mov dword ptr ds:[esp+8],28             | 
004010CD | 54                       | push esp                                |
004010CE | 6A 01                    | push 1                                  |
004010D0 | 6A 00                    | push 0                                  |
004010D2 | 68 0C 20 40 00           | push exepuzz1.40200C                    | ;0040200C:"Software\\Caesum\\rev1"
004010D7 | 68 02 00 00 80           | push 80000002                           |
004010DC | E8 F4 00 00 00           | call <exepuzz1.RegOpenKeyExA>           | Distracción
004010E1 | 85 C0                    | test eax,eax                            |
004010E3 | 0F 85 C6 00 00 00        | jne exepuzz1.4011AF                     | Parchear este salto
004010E9 | 8D 44 24 08              | lea eax,dword ptr ds:[esp+8]            |
004010ED | 50                       | push eax                                |
004010EE | 68 84 20 40 00           | push exepuzz1.402084                    | Coge lo que haya en la dirección 402084
........

Lo primero que nos llama la atención es que en 4010BE pone el DUMP 402084 a cero. Lo corroboramos:

00402000: 04 20 40 00 63 6D 62 69 70 6F 66 00 53 6F 66 74 ; . @.cmbipof.Soft
00402010: 77 61 72 65 5C 43 61 65 73 75 6D 5C 72 65 76 31 ; ware\Caesum\rev1
00402020: 00 6B 65 79 00 74 65 6C 6C 20 6D 65 20 74 68 65 ; .key.tell me the
00402030: 20 61 6E 73 77 65 72 00 59 6F 75 72 20 70 61 73 ;  answer.Your pas
00402040: 73 20 69 73 20 00 42 6C 61 68 00 54 68 69 73 20 ; s is .Blah.This 
00402050: 6C 69 74 74 6C 65 20 62 75 6E 6E 79 20 77 65 6E ; little bunny wen
00402060: 74 20 68 6F 70 00 42 6C 61 68 00 42 6C 61 68 2C ; t hop.Blah.Blah,
00402070: 20 73 65 65 20 69 66 20 49 20 63 61 72 65 00 42 ;  see if I care.B
00402080: 6C 61 68 00 00 00 00 00 00 00 00 00 00 00 00 00 ; lah.............
                       ^
                       |
                       ----402084 (Ahora no hay nada)

Además para poder continuar la ejecución debemos parchear el salto JNE de la dirección 4010E3. Seguimos:

........
004010F3 | 8D 54 24 0C              | lea edx,dword ptr ds:[esp+C]            |
004010F7 | 52                       | push edx                                |
004010F8 | 6A 00                    | push 0                                  |
004010FA | 68 21 20 40 00           | push exepuzz1.402021                    | ;00402021:"key"
004010FF | 8B 4C 24 14              | mov ecx,dword ptr ds:[esp+14]           |
00401103 | 51                       | push ecx                                |
00401104 | E8 C6 00 00 00           | call <exepuzz1.RegQueryValueExA>        | Distracción
00401109 | 8B 04 24                 | mov eax,dword ptr ds:[esp]              |
0040110C | 50                       | push eax                                |
0040110D | E8 B7 00 00 00           | call <exepuzz1.RegCloseKey>             |
00401112 | 68 25 20 40 00           | push exepuzz1.402025                    | ;00402025:"tell me the answer"
00401117 | 68 84 20 40 00           | push exepuzz1.402084                    | Coge lo que haya en la dirección 402084
0040111C | E8 17 FF FF FF           | call exepuzz1.401038                    |
00401121 | 83 C4 08                 | add esp,8                               |
00401124 | 85 C0                    | test eax,eax                            |
00401126 | 74 72                    | je exepuzz1.40119A                      |
00401128 | 68 84 20 40 00           | push exepuzz1.402084                    |
0040112D | E8 CE FE FF FF           | call exepuzz1.401000                    |
00401132 | 59                       | pop ecx                                 |
00401133 | 8B F0                    | mov esi,eax                             |
00401135 | 33 DB                    | xor ebx,ebx                             |
00401137 | B9 84 20 40 00           | mov ecx,exepuzz1.402084                 |
0040113C | 3B F3                    | cmp esi,ebx                             |
0040113E | 7E 21                    | jle exepuzz1.401161                     |
00401140 | 0F BE 01                 | movsx eax,byte ptr ds:[ecx]             |>----BUCLE------
00401143 | 8B D0                    | mov edx,eax                             | EAX y EDX contienen el valor HEX del dígito que toque
00401145 | BF 1A 00 00 00           | mov edi,1A                              | EDI = 1A
0040114A | 43                       | inc ebx                                 | incremento el contador
0040114B | 8D 04 C2                 | lea eax,dword ptr ds:[edx+eax*8]        | EAX = Dígito+Dígito*8
0040114E | 8D 04 C2                 | lea eax,dword ptr ds:[edx+eax*8]        | EAX = Dígito+EAX*8
00401151 | 83 C0 3B                 | add eax,3B                              | EAX = EAX+3B
00401154 | 99                       | cdq                                     |
00401155 | F7 FF                    | idiv edi                                | EAX / EDI
00401157 | 80 C2 61                 | add dl,61                               | DL + 61
0040115A | 88 11                    | mov byte ptr ds:[ecx],dl                |
0040115C | 41                       | inc ecx                                 |
0040115D | 3B F3                    | cmp esi,ebx                             | ¿He terminado de recorrer la string?
0040115F | 7F DF                    | jg exepuzz1.401140                      |^-----BUCLE------
........

En 401117 vemos que intenta leer del DUMP en la dirección 402084 y a partir de ahí según lo que haya en el DUMP realiza una serie de operaciones con los datos y nos devuelve el resultado en forma de NAG.

Probamos varias cosas y nuestra teoría funciona pero, ¿cúal es la cadena de texto que debemos introducir?. A partir de aquí ya es un poco la intuición de cada uno, aunque la más lógica es «tell me the answer» que aparece justo antes del bucle.

El BUCLE

En resumen:

t 74  74*8+74 = 414*8+74 = 2114+3B = 214F MOD 1A = 19 + 61 = 72 (z)
e 65  65*8+65 = 38D*8+65 = 1CCD+3B = 1D08 MOD 1A = 16 + 61 = 77 (w)
l 6C  6C*8+6C = 3CC*8+6C = 1ECC+3B = 1F07 MOD 1A =  D + 61 = 6E (n)
l 6C  6C*8+6C = 3CC*8+6C = 1ECC+3B = 1F07 MOD 1A =  D + 61 = 6E (n)
  20  20*8+20 = 120*8+20 = 0920+3B = 095B MOD 1A =  3 + 61 = 64 (d)
m 6D  6D*8+6D = 3D5*8+6D = 1F15+3B = 1F50 MOD 1A =  8 + 61 = 69 (i)
e 65  65*8+65 = 38D*8+65 = 1CCD+3B = 1D08 MOD 1A = 16 + 61 = 77 (w)
  20  20*8+20 = 120*8+20 = 0920+3B = 095B MOD 1A =  3 + 61 = 64 (d)
t 74  74*8+74 = 414*8+74 = 2114+3B = 214F MOD 1A = 19 + 61 = 72 (z)
h 68  68*8+68 = 3A8*8+68 = 1DA8+3B = 1DE3 MOD 1A =  7 + 61 = 68 (h)
e 65  65*8+65 = 38D*8+65 = 1CCD+3B = 1D08 MOD 1A = 16 + 61 = 77 (w)
  20  20*8+20 = 120*8+20 = 0920+3B = 095B MOD 1A =  3 + 61 = 64 (d)
a 61  61*8+61 = 369*8+61 = 1BA9+3B = 1BE4 MOD 1A = 10 + 61 = 71 (q)
n 6E  6E*8+6E = 3DE*8+6E = 1F5E+3B = 1F9C MOD 1A =  6 + 61 = 67 (g)
s 73  73*8+73 = 40B*8+73 = 20CB+3B = 2106 MOD 1A =  4 + 61 = 65 (e)
w 77  77*8+77 = 42F*8+77 = 21EF+3B = 222A MOD 1A =  A + 61 = 6B (k)
e 65  65*8+65 = 38D*8+65 = 1CCD+3B = 1D08 MOD 1A = 16 + 61 = 77 (w) 
r 72  72*8+72 = 402*8+72 = 2082+3B = 20BD MOD 1A =  9 + 61 = 6A (j)

zwnndiwdzhwdqdekwj

La cadena de texto resultante ¿sera la correcta?

AfKayAs’s CrackMe#2 KeyGen

13 septiembre, 2014 por deurus·Sin comentarios

Intro

Hoy vamos a desmitificar un poco a Visual Basic. El Crackme reza que acabemos con la nag y hagamos un keygen.

La NAG

Lo primero que debemos establecer es a que tipo de Nag nos estamos enfrentando, si es una MessageBox, se localiza y se parchea, si es un formulario la cosa ya cambia un poco, ya que encontrar esa parte del código puede resultar tedioso.

Yo voy a utilizar el camino fácil. En VB contamos con una estupenda herramienta como es VBReformer, que nos muestra las entrañas del crackme y nos posibilita cambiar ciertos parametros.

Abrimos el crackme con VBReformer y vemos su contenido. Localizamos rápidamente el formulario que aparece inicialmente (CMSplash) y el temporizador que contiene (Timer1). Inicialmente el timer tiene un interval de 7000, es decir, la nag se muestra durante 7 segundos. Es tan sencillo como cambiarlo por 1 y guardar el ejecutable (File > Save binary as).

Si no disponemos de esta estupenda herramienta, siempre podemos localizar el timer con un editor hexadecimal. Localizamos en Olly el nombre del timer (en las string references lo veréis), y lo buscamos en el editor hexadecimal. La duración de la nag la debemos estimar nosotros y a continuación buscar ese valor hexadecimal. Imaginemos que estimamos que son 7 segundos, lo pasamos a milisegundos y a hexadecimal. 7000 = 0x1B58. Buscamos en el editor hexadecimal «Timer1» y a continuación localizamos el valor 1B58 invertido, es decir, 581B. En las imágenes inferiores se ve claro.

Cambiando el valor ya lo tendriámos.

El algoritmo

El algoritmo de este crackme es muy sencillo pero he elegido este en concreto para que veáis las vueltas que da VB para hacer 6 operaciones matemáticas. A continuación tenéis el código íntegro comentado y debajo el resumen.

004081F5      .  FF15 F8B04000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]    ;  MSVBVM50.__vbaLenBstr
004081FB      .  8BF8                     MOV EDI,EAX
004081FD      .  8B4D E8                  MOV ECX,DWORD PTR SS:[EBP-18]
00408200      .  69FF 385B0100            IMUL EDI,EDI,15B38                              ;  TEMP = Len(nombre) *15B38
00408206      .  51                       PUSH ECX
00408207      .  0F80 B7050000            JO CrackmeV.004087C4
0040820D      .  FF15 0CB14000            CALL DWORD PTR DS:[<&MSVBVM50.#516>]            ;  MSVBVM50.rtcAnsiValueBstr
00408213      .  0FBFD0                   MOVSX EDX,AX                                    ;  digito a ax
00408216      .  03FA                     ADD EDI,EDX                                     ;  TEMP +=1digito
00408218      .  0F80 A6050000            JO CrackmeV.004087C4
0040821E      .  57                       PUSH EDI                                        ;  MSVBVM50.__vbaObjSet
0040821F      .  FF15 F4B04000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrI4>]      ;  MSVBVM50.__vbaStrI4
00408225      .  8BD0                     MOV EDX,EAX
00408227      .  8D4D E0                  LEA ECX,DWORD PTR SS:[EBP-20]
0040822A      .  FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408230      .  8BBD 50FFFFFF            MOV EDI,DWORD PTR SS:[EBP-B0]
00408236      .  50                       PUSH EAX
00408237      .  57                       PUSH EDI                                        ;  MSVBVM50.__vbaObjSet
00408238      .  FF93 A4000000            CALL DWORD PTR DS:[EBX+A4]                      ;  MSVBVM50.0F050D32
0040823E      .  85C0                     TEST EAX,EAX
00408240      .  7D 12                    JGE SHORT CrackmeV.00408254
00408242      .  68 A4000000              PUSH 0A4
00408247      .  68 AC6F4000              PUSH CrackmeV.00406FAC
0040824C      .  57                       PUSH EDI                                        ;  MSVBVM50.__vbaObjSet
0040824D      .  50                       PUSH EAX
0040824E      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
00408254      >  8D45 E0                  LEA EAX,DWORD PTR SS:[EBP-20]
00408257      .  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
0040825A      .  50                       PUSH EAX
0040825B      .  8D55 E8                  LEA EDX,DWORD PTR SS:[EBP-18]
0040825E      .  51                       PUSH ECX
0040825F      .  52                       PUSH EDX
00408260      .  6A 03                    PUSH 3
00408262      .  FF15 80B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>;  MSVBVM50.__vbaFreeStrList
00408268      .  83C4 10                  ADD ESP,10
0040826B      .  8D45 D4                  LEA EAX,DWORD PTR SS:[EBP-2C]
0040826E      .  8D4D D8                  LEA ECX,DWORD PTR SS:[EBP-28]
00408271      .  8D55 DC                  LEA EDX,DWORD PTR SS:[EBP-24]
00408274      .  50                       PUSH EAX
00408275      .  51                       PUSH ECX
00408276      .  52                       PUSH EDX
00408277      .  6A 03                    PUSH 3
00408279      .  FF15 08B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>;  MSVBVM50.__vbaFreeObjList
0040827F      .  8B9D 40FFFFFF            MOV EBX,DWORD PTR SS:[EBP-C0]                   ;  CrackmeV.00409A68
00408285      .  83C4 10                  ADD ESP,10
00408288      .  8B83 FC020000            MOV EAX,DWORD PTR DS:[EBX+2FC]
0040828E      .  56                       PUSH ESI
0040828F      .  8985 38FFFFFF            MOV DWORD PTR SS:[EBP-C8],EAX
00408295      .  FFD0                     CALL EAX
00408297      .  8B3D 20B14000            MOV EDI,DWORD PTR DS:[<&MSVBVM50.__vbaObjSet>]  ;  MSVBVM50.__vbaObjSet
0040829D      .  50                       PUSH EAX
0040829E      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
004082A1      .  50                       PUSH EAX
004082A2      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet; <&MSVBVM50.__vbaObjSet>
004082A4      .  56                       PUSH ESI
004082A5      .  8985 58FFFFFF            MOV DWORD PTR SS:[EBP-A8],EAX
004082AB      .  FF93 08030000            CALL DWORD PTR DS:[EBX+308]
004082B1      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
004082B4      .  50                       PUSH EAX
004082B5      .  51                       PUSH ECX
004082B6      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004082B8      .  8BD8                     MOV EBX,EAX
004082BA      .  8D45 E8                  LEA EAX,DWORD PTR SS:[EBP-18]
004082BD      .  50                       PUSH EAX
004082BE      .  53                       PUSH EBX
004082BF      .  8B13                     MOV EDX,DWORD PTR DS:[EBX]                      ;  MSVBVM50.0F025A95
004082C1      .  FF92 A0000000            CALL DWORD PTR DS:[EDX+A0]
004082C7      .  85C0                     TEST EAX,EAX
004082C9      .  7D 12                    JGE SHORT CrackmeV.004082DD
004082CB      .  68 A0000000              PUSH 0A0
004082D0      .  68 AC6F4000              PUSH CrackmeV.00406FAC
004082D5      .  53                       PUSH EBX
004082D6      .  50                       PUSH EAX
004082D7      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
004082DD      >  8B8D 58FFFFFF            MOV ECX,DWORD PTR SS:[EBP-A8]
004082E3      .  8B55 E8                  MOV EDX,DWORD PTR SS:[EBP-18]
004082E6      .  52                       PUSH EDX
004082E7      .  8B19                     MOV EBX,DWORD PTR DS:[ECX]
004082E9      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004082EF      .  D905 08104000            FLD DWORD PTR DS:[401008]
004082F5      .  833D 00904000 00         CMP DWORD PTR DS:[409000],0
004082FC      .  75 08                    JNZ SHORT CrackmeV.00408306
004082FE      .  D835 0C104000            FDIV DWORD PTR DS:[40100C]                      ;  10 / 5 = 2
00408304      .  EB 0B                    JMP SHORT CrackmeV.00408311
00408306      >  FF35 0C104000            PUSH DWORD PTR DS:[40100C]
0040830C      .  E8 578DFFFF              CALL <JMP.&MSVBVM50._adj_fdiv_m32>
00408311      >  83EC 08                  SUB ESP,8
00408314      .  DFE0                     FSTSW AX
00408316      .  A8 0D                    TEST AL,0D
00408318      .  0F85 A1040000            JNZ CrackmeV.004087BF
0040831E      .  DEC1                     FADDP ST(1),ST                                  ;  TEMP +=2
00408320      .  DFE0                     FSTSW AX
00408322      .  A8 0D                    TEST AL,0D
00408324      .  0F85 95040000            JNZ CrackmeV.004087BF
0040832A      .  DD1C24                   FSTP QWORD PTR SS:[ESP]
0040832D      .  FF15 48B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>]      ;  MSVBVM50.__vbaStrR8
00408333      .  8BD0                     MOV EDX,EAX
00408335      .  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
00408338      .  FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
0040833E      .  899D 34FFFFFF            MOV DWORD PTR SS:[EBP-CC],EBX
00408344      .  8B9D 58FFFFFF            MOV EBX,DWORD PTR SS:[EBP-A8]
0040834A      .  50                       PUSH EAX
0040834B      .  8B85 34FFFFFF            MOV EAX,DWORD PTR SS:[EBP-CC]
00408351      .  53                       PUSH EBX
00408352      .  FF90 A4000000            CALL DWORD PTR DS:[EAX+A4]
00408358      .  85C0                     TEST EAX,EAX
0040835A      .  7D 12                    JGE SHORT CrackmeV.0040836E
0040835C      .  68 A4000000              PUSH 0A4
00408361      .  68 AC6F4000              PUSH CrackmeV.00406FAC
00408366      .  53                       PUSH EBX
00408367      .  50                       PUSH EAX
00408368      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
0040836E      >  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
00408371      .  8D55 E8                  LEA EDX,DWORD PTR SS:[EBP-18]
00408374      .  51                       PUSH ECX
00408375      .  52                       PUSH EDX
00408376      .  6A 02                    PUSH 2
00408378      .  FF15 80B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>;  MSVBVM50.__vbaFreeStrList
0040837E      .  83C4 0C                  ADD ESP,0C
00408381      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
00408384      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
00408387      .  50                       PUSH EAX
00408388      .  51                       PUSH ECX
00408389      .  6A 02                    PUSH 2
0040838B      .  FF15 08B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>;  MSVBVM50.__vbaFreeObjList
00408391      .  8B95 40FFFFFF            MOV EDX,DWORD PTR SS:[EBP-C0]                   ;  CrackmeV.00409A68
00408397      .  83C4 0C                  ADD ESP,0C
0040839A      .  8B82 00030000            MOV EAX,DWORD PTR DS:[EDX+300]
004083A0      .  56                       PUSH ESI
004083A1      .  8985 30FFFFFF            MOV DWORD PTR SS:[EBP-D0],EAX
004083A7      .  FFD0                     CALL EAX
004083A9      .  50                       PUSH EAX
004083AA      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
004083AD      .  50                       PUSH EAX
004083AE      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004083B0      .  56                       PUSH ESI
004083B1      .  8985 58FFFFFF            MOV DWORD PTR SS:[EBP-A8],EAX
004083B7      .  FF95 38FFFFFF            CALL DWORD PTR SS:[EBP-C8]                      ;  MSVBVM50.0F10C340
004083BD      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
004083C0      .  50                       PUSH EAX
004083C1      .  51                       PUSH ECX
004083C2      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004083C4      .  8BD8                     MOV EBX,EAX
004083C6      .  8D45 E8                  LEA EAX,DWORD PTR SS:[EBP-18]
004083C9      .  50                       PUSH EAX
004083CA      .  53                       PUSH EBX
004083CB      .  8B13                     MOV EDX,DWORD PTR DS:[EBX]                      ;  MSVBVM50.0F025A95
004083CD      .  FF92 A0000000            CALL DWORD PTR DS:[EDX+A0]
004083D3      .  85C0                     TEST EAX,EAX
004083D5      .  7D 12                    JGE SHORT CrackmeV.004083E9
004083D7      .  68 A0000000              PUSH 0A0
004083DC      .  68 AC6F4000              PUSH CrackmeV.00406FAC
004083E1      .  53                       PUSH EBX
004083E2      .  50                       PUSH EAX
004083E3      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
004083E9      >  8B8D 58FFFFFF            MOV ECX,DWORD PTR SS:[EBP-A8]
004083EF      .  8B55 E8                  MOV EDX,DWORD PTR SS:[EBP-18]
004083F2      .  52                       PUSH EDX
004083F3      .  8B19                     MOV EBX,DWORD PTR DS:[ECX]
004083F5      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004083FB      .  DC0D 10104000            FMUL QWORD PTR DS:[401010]                      ;  *3
00408401      .  83EC 08                  SUB ESP,8                                       ;  -2
00408404      .  DC25 18104000            FSUB QWORD PTR DS:[401018]
0040840A      .  DFE0                     FSTSW AX
0040840C      .  A8 0D                    TEST AL,0D
0040840E      .  0F85 AB030000            JNZ CrackmeV.004087BF
00408414      .  DD1C24                   FSTP QWORD PTR SS:[ESP]
00408417      .  FF15 48B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrR8>]      ;  MSVBVM50.__vbaStrR8
0040841D      .  8BD0                     MOV EDX,EAX
0040841F      .  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
00408422      .  FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408428      .  899D 2CFFFFFF            MOV DWORD PTR SS:[EBP-D4],EBX
0040842E      .  8B9D 58FFFFFF            MOV EBX,DWORD PTR SS:[EBP-A8]
00408434      .  50                       PUSH EAX
00408435      .  8B85 2CFFFFFF            MOV EAX,DWORD PTR SS:[EBP-D4]
0040843B      .  53                       PUSH EBX
0040843C      .  FF90 A4000000            CALL DWORD PTR DS:[EAX+A4]
00408442      .  85C0                     TEST EAX,EAX
00408444      .  7D 12                    JGE SHORT CrackmeV.00408458
00408446      .  68 A4000000              PUSH 0A4
0040844B      .  68 AC6F4000              PUSH CrackmeV.00406FAC
00408450      .  53                       PUSH EBX
00408451      .  50                       PUSH EAX
00408452      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
00408458      >  8D4D E4                  LEA ECX,DWORD PTR SS:[EBP-1C]
0040845B      .  8D55 E8                  LEA EDX,DWORD PTR SS:[EBP-18]
0040845E      .  51                       PUSH ECX
0040845F      .  52                       PUSH EDX
00408460      .  6A 02                    PUSH 2
00408462      .  FF15 80B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeStrList>>;  MSVBVM50.__vbaFreeStrList
00408468      .  83C4 0C                  ADD ESP,0C
0040846B      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
0040846E      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
00408471      .  50                       PUSH EAX
00408472      .  51                       PUSH ECX
00408473      .  6A 02                    PUSH 2
00408475      .  FF15 08B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaFreeObjList>>;  MSVBVM50.__vbaFreeObjList
0040847B      .  8B95 40FFFFFF            MOV EDX,DWORD PTR SS:[EBP-C0]                   ;  CrackmeV.00409A68
00408481      .  83C4 0C                  ADD ESP,0C
00408484      .  8B82 04030000            MOV EAX,DWORD PTR DS:[EDX+304]
0040848A      .  56                       PUSH ESI
0040848B      .  8985 28FFFFFF            MOV DWORD PTR SS:[EBP-D8],EAX
00408491      .  FFD0                     CALL EAX
00408493      .  50                       PUSH EAX
00408494      .  8D45 D8                  LEA EAX,DWORD PTR SS:[EBP-28]
00408497      .  50                       PUSH EAX
00408498      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
0040849A      .  56                       PUSH ESI
0040849B      .  8985 58FFFFFF            MOV DWORD PTR SS:[EBP-A8],EAX
004084A1      .  FF95 30FFFFFF            CALL DWORD PTR SS:[EBP-D0]                      ;  MSVBVM50.0F10C348
004084A7      .  8D4D DC                  LEA ECX,DWORD PTR SS:[EBP-24]
004084AA      .  50                       PUSH EAX
004084AB      .  51                       PUSH ECX
004084AC      .  FFD7                     CALL EDI                                        ;  MSVBVM50.__vbaObjSet
004084AE      .  8BD8                     MOV EBX,EAX
004084B0      .  8D45 E8                  LEA EAX,DWORD PTR SS:[EBP-18]
004084B3      .  50                       PUSH EAX
004084B4      .  53                       PUSH EBX
004084B5      .  8B13                     MOV EDX,DWORD PTR DS:[EBX]                      ;  MSVBVM50.0F025A95
004084B7      .  FF92 A0000000            CALL DWORD PTR DS:[EDX+A0]
004084BD      .  85C0                     TEST EAX,EAX
004084BF      .  7D 12                    JGE SHORT CrackmeV.004084D3
004084C1      .  68 A0000000              PUSH 0A0
004084C6      .  68 AC6F4000              PUSH CrackmeV.00406FAC
004084CB      .  53                       PUSH EBX
004084CC      .  50                       PUSH EAX
004084CD      .  FF15 18B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaHresultCheck>;  MSVBVM50.__vbaHresultCheckObj
004084D3      >  8B8D 58FFFFFF            MOV ECX,DWORD PTR SS:[EBP-A8]
004084D9      .  8B55 E8                  MOV EDX,DWORD PTR SS:[EBP-18]
004084DC      .  52                       PUSH EDX
004084DD      .  8B19                     MOV EBX,DWORD PTR DS:[ECX]
004084DF      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004084E5      .  DC25 20104000            FSUB QWORD PTR DS:[401020]                      ;  TEMP -= -15
004084EB      .  83EC 08                  SUB ESP,8
004084EE      .  DFE0                     FSTSW AX
004084F0      .  A8 0D                    TEST AL,0D
004084F2      .  0F85 C7020000            JNZ CrackmeV.004087BF
........
00408677      . /74 62                    JE SHORT CrackmeV.004086DB
00408679      . |8B35 14B14000            MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>]  ;  MSVBVM50.__vbaStrCat
0040867F      . |68 C06F4000              PUSH CrackmeV.00406FC0                          ;  UNICODE "You Get It"
00408684      . |68 DC6F4000              PUSH CrackmeV.00406FDC                          ;  UNICODE "\r\n"
00408689      . |FFD6                     CALL ESI                                        ;  <&MSVBVM50.__vbaStrCat>
0040868B      . |8BD0                     MOV EDX,EAX
0040868D      . |8D4D E8                  LEA ECX,DWORD PTR SS:[EBP-18]
00408690      . |FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408696      . |50                       PUSH EAX
00408697      . |68 E86F4000              PUSH CrackmeV.00406FE8                          ;  UNICODE "KeyGen It Now"

Que se puede resumir en esto.

004081F5      .  FF15 F8B04000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaLenBstr>]    ;  MSVBVM50.__vbaLenBstr
004081FB      .  8BF8                     MOV EDI,EAX
004081FD      .  8B4D E8                  MOV ECX,DWORD PTR SS:[EBP-18]
00408200      .  69FF 385B0100            IMUL EDI,EDI,15B38                              ;  TEMP = Len(nombre) *15B38
00408206      .  51                       PUSH ECX
00408207      .  0F80 B7050000            JO CrackmeV.004087C4
0040820D      .  FF15 0CB14000            CALL DWORD PTR DS:[<&MSVBVM50.#516>]            ;  MSVBVM50.rtcAnsiValueBstr
00408213      .  0FBFD0                   MOVSX EDX,AX                                    ;  digito a ax
00408216      .  03FA                     ADD EDI,EDX                                     ;  TEMP +=1digito
00408218      .  0F80 A6050000            JO CrackmeV.004087C4
........
004082E9      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004082EF      .  D905 08104000            FLD DWORD PTR DS:[401008]
004082F5      .  833D 00904000 00         CMP DWORD PTR DS:[409000],0
004082FC      .  75 08                    JNZ SHORT CrackmeV.00408306
004082FE      .  D835 0C104000            FDIV DWORD PTR DS:[40100C]                      ;  10 / 5 = 2
00408304      .  EB 0B                    JMP SHORT CrackmeV.00408311
00408306      >  FF35 0C104000            PUSH DWORD PTR DS:[40100C]
0040830C      .  E8 578DFFFF              CALL <JMP.&MSVBVM50._adj_fdiv_m32>
00408311      >  83EC 08                  SUB ESP,8
00408314      .  DFE0                     FSTSW AX
00408316      .  A8 0D                    TEST AL,0D
00408318      .  0F85 A1040000            JNZ CrackmeV.004087BF
0040831E      .  DEC1                     FADDP ST(1),ST                                  ;  TEMP +=2
00408320      .  DFE0                     FSTSW AX
00408322      .  A8 0D                    TEST AL,0D
........
004083F5      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004083FB      .  DC0D 10104000            FMUL QWORD PTR DS:[401010]                      ;  TEMP *=3
00408401      .  83EC 08                  SUB ESP,8                                       ;  TEMP -=2
00408404      .  DC25 18104000            FSUB QWORD PTR DS:[401018]
0040840A      .  DFE0                     FSTSW AX
0040840C      .  A8 0D                    TEST AL,0D
........
004084DF      .  FF15 74B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaR8Str>]      ;  MSVBVM50.__vbaR8Str
004084E5      .  DC25 20104000            FSUB QWORD PTR DS:[401020]                      ;  TEMP -= -15
004084EB      .  83EC 08                  SUB ESP,8
004084EE      .  DFE0                     FSTSW AX
004084F0      .  A8 0D                    TEST AL,0D
004084F2      .  0F85 C7020000            JNZ CrackmeV.004087BF
........
00408677      . /74 62                    JE SHORT CrackmeV.004086DB
00408679      . |8B35 14B14000            MOV ESI,DWORD PTR DS:[<&MSVBVM50.__vbaStrCat>]  ;  MSVBVM50.__vbaStrCat
0040867F      . |68 C06F4000              PUSH CrackmeV.00406FC0                          ;  UNICODE "You Get It"
00408684      . |68 DC6F4000              PUSH CrackmeV.00406FDC                          ;  UNICODE "\r\n"
00408689      . |FFD6                     CALL ESI                                        ;  <&MSVBVM50.__vbaStrCat>
0040868B      . |8BD0                     MOV EDX,EAX
0040868D      . |8D4D E8                  LEA ECX,DWORD PTR SS:[EBP-18]
00408690      . |FF15 94B14000            CALL DWORD PTR DS:[<&MSVBVM50.__vbaStrMove>]    ;  MSVBVM50.__vbaStrMove
00408696      . |50                       PUSH EAX
00408697      . |68 E86F4000              PUSH CrackmeV.00406FE8                          ;  UNICODE "KeyGen It Now"

Y en esto:

TEMP = Len(nombre) *15B38
TEMP += 1ºdigitoascii
TEMP +=2
TEMP *=3
TEMP -=2
TEMP +=15

Y el KeyGen nos ocupa una sola línea

txtserial.Text = (((((Len(txtnombre.Text) * 88888) + Asc(Mid(txtn.Text, 1, 1))) + 2) * 3) - 2) + 15

Huevo de pascua (Easter egg)

Si nos fijamos en el VBReformer, en el formulario principal vemos muchas cajas de texto.

Las hacemos visibles, guardamos y ejecutamos haber que pasa.

Lo que pasa es que va guardando el resultado de las operaciones en ellas y en la de arriba concretamente está nuestro serial bueno, lo que nos hace poseedores de un KeyGen encubierto.

Links

Reto forense "Find the cat" de Root-Me.org

Intro President’s cat was kidnapped by separatists. A suspect carrying a USB key has been arrested. Berthier, once again, up

Solución al Crackme Zebra 1.1 de aLoNg3x

Introducción Hoy tenemos aquí un crackme de los que te hacen temblar las conexiones neuronales. Estamos acostumbrados al típico serial

Yoire PE Reversing Challenge (Crackme Very Hard)

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

Retos stego 1-4 de Challengeland.co

Introducción Hoy vamos a enfrentarnos a cuatro retos de esteganografía relativamente sencillos, y digo relativamente, debido a que hay tantas

1 2 3 … 30 Next »

Protegido: Reto forense «Find the cat» de Root-Me.org

20 diciembre, 2015 por deurus·Escribe tu contraseña para ver los comentarios.

Solución al Crackme Zebra 1.1 de aLoNg3x

12 octubre, 2014 por deurus·1 comentario

Introducción

Hoy tenemos aquí un crackme de los que te hacen temblar las conexiones neuronales. Estamos acostumbrados al típico serial asociado a un nombre y a veces nos sorprenden.

El crackme data del año 2000, está realizado por aLoNg3x y lo tenéis colgado en crackmes.de. En crackmes.de también disponéis de una solución muy elegante realizada por cronos, pero que no acaba de saciar nuestro afán de descubrir todas las soluciones posibles.

El algoritmo

Abrimos el crackme con Olly y enseguida encontramos la rutina de comprobación junto con los mensajes de éxito y error. Os dejo la rutina comentada como siempre.

004012D7   |.  83C4 08             ADD ESP,8                                 ;  
004012DA   |.  09C0                OR EAX,EAX                                ;  
004012DC   |. /74 16               JE SHORT Zebrone.004012F4                 ;  Salta a Bad boy
004012DE   |. |6A 00               PUSH 0                                    ; /Style = MB_OK|MB_APPLMODAL
004012E0   |. |68 26324000         PUSH Zebrone.00403226                     ; |Title = "Great !!!"
004012E5   |. |68 30324000         PUSH Zebrone.00403230                     ; |Text = "Congratulations, you have cracked the Zebra Crackme ver 1.1"
004012EA   |. |FF75 08             PUSH [ARG.1]                              ; |hOwner = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
004012ED   |. |E8 C6010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
004012F2   |. |EB 14               JMP SHORT Zebrone.00401308
004012F4   |> \6A 00               PUSH 0                                    ; /Style = MB_OK|MB_APPLMODAL
004012F6   |.  68 F8314000         PUSH Zebrone.004031F8                     ; |Title = "Hmmmm :P"
004012FB   |.  68 01324000         PUSH Zebrone.00403201                     ; |Text = "Sorry... The Serial isn't correct :Þ"
00401300   |.  FF75 08             PUSH [ARG.1]                              ; |hOwner = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
00401303   |.  E8 B0010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401308   |>  31C0                XOR EAX,EAX
0040130A   |.  40                  INC EAX
0040130B   |.  EB 39               JMP SHORT Zebrone.00401346
0040130D   |>  6A 00               PUSH 0                                    ; /Result = 0
0040130F   |.  FF75 08             PUSH [ARG.1]                              ; |hWnd = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
00401312   |.  E8 89010000         CALL <JMP.&USER32.EndDialog>              ; \EndDialog
00401317   |.  31C0                XOR EAX,EAX
00401319   |.  40                  INC EAX
0040131A   |.  EB 2A               JMP SHORT Zebrone.00401346
0040131C   |>  6A 00               PUSH 0                                    ; /Style = MB_OK|MB_APPLMODAL
0040131E   |.  68 40304000         PUSH Zebrone.00403040                     ; |Title = "Zebra ver. 1.1"
00401323   |.  68 4F304000         PUSH Zebrone.0040304F                     ; |Text = "This is the 1.1 Zebra Crackme, Thanks to Quequero and Koma, to have said me a bug of the previous version. (It was due to an orrible cpu appoximation). As usually you cannot patch this .EXE, you've to find one of the many correct solut"...
00401328   |.  FF75 08             PUSH [ARG.1]                              ; |hOwner = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
0040132B   |.  E8 88010000         CALL <JMP.&USER32.MessageBoxA>            ; \MessageBoxA
00401330   |.  31C0                XOR EAX,EAX
00401332   |.  40                  INC EAX
00401333   |.  EB 11               JMP SHORT Zebrone.00401346
00401335   |>  6A 00               PUSH 0                                    ; /Result = 0
00401337   |.  FF75 08             PUSH [ARG.1]                              ; |hWnd = 0011067C ('Zebra - aLoNg3x - 1.1 Version',class='#32770')
0040133A   |.  E8 61010000         CALL <JMP.&USER32.EndDialog>              ; \EndDialog
0040133F   |.  31C0                XOR EAX,EAX
00401341   |.  40                  INC EAX
00401342   |.  EB 02               JMP SHORT Zebrone.00401346
00401344   |>  31C0                XOR EAX,EAX
00401346   |>  C9                  LEAVE
00401347   \.  C2 1000             RETN 10
================================================================
0040134A   /$  55                  PUSH EBP
0040134B   |.  89E5                MOV EBP,ESP
0040134D   |.  83EC 68             SUB ESP,68
00401350   |.  FF75 08             PUSH [ARG.1]                              ; /x1
00401353   |.  E8 78010000         CALL <JMP.&CRTDLL.atof>                   ; \atof
00401358   |.  DD55 E8             FST QWORD PTR SS:[EBP-18]
0040135B   |.  83EC 08             SUB ESP,8
0040135E   |.  DD1C24              FSTP QWORD PTR SS:[ESP]
00401361   |.  E8 82010000         CALL <JMP.&CRTDLL.floor>
00401366   |.  DD5D F8             FSTP QWORD PTR SS:[EBP-8]
00401369   |.  FF75 0C             PUSH [ARG.2]                              ; /x2
0040136C   |.  E8 5F010000         CALL <JMP.&CRTDLL.atof>                   ; \atof
00401371   |.  DD55 D8             FST QWORD PTR SS:[EBP-28]
00401374   |.  83EC 08             SUB ESP,8
00401377   |.  DD1C24              FSTP QWORD PTR SS:[ESP]
0040137A   |.  E8 69010000         CALL <JMP.&CRTDLL.floor>
0040137F   |.  83C4 18             ADD ESP,18
00401382   |.  DD55 F0             FST QWORD PTR SS:[EBP-10]
00401385   |.  DC4D F8             FMUL QWORD PTR SS:[EBP-8]
00401388   |.  D9EE                FLDZ
0040138A   |.  DED9                FCOMPP                                    ;  floor(x1)*floor(x2)=0 ???
0040138C   |.  DFE0                FSTSW AX                                  ;  <<Store status word
0040138E   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
0040138F   |.  75 07               JNZ SHORT Zebrone.00401398                ;  Si salta todo OK
00401391   |.  31C0                XOR EAX,EAX
00401393   |.  E9 96000000         JMP Zebrone.0040142E                      ;  Bad boy
00401398   |>  DD45 F8             FLD QWORD PTR SS:[EBP-8]                  ;  <<Floating point load
0040139B   |.  DC5D F0             FCOMP QWORD PTR SS:[EBP-10]               ;  x1 = x2 ???
0040139E   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013A0   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013A1   |.  75 07               JNZ SHORT Zebrone.004013AA                ;  Si salta todo OK
004013A3   |.  31C0                XOR EAX,EAX
004013A5   |.  E9 84000000         JMP Zebrone.0040142E                      ;  Bad boy
004013AA   |>  DD45 F8             FLD QWORD PTR SS:[EBP-8]                  ;  <<Floating point load
004013AD   |.  DD5D C8             FSTP QWORD PTR SS:[EBP-38]
004013B0   |.  D9E8                FLD1                                      ;  Carga 1 en el stack
004013B2   |.  DD55 C0             FST QWORD PTR SS:[EBP-40]                 ;  <<Floating point store
004013B5   |.  DC5D C8             FCOMP QWORD PTR SS:[EBP-38]               ;  x1 > 1 ???
004013B8   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013BA   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013BB   |.  77 2D               JA SHORT Zebrone.004013EA                 ;  Si salta bad boy
004013BD   |.  DF2D 38304000       FILD QWORD PTR DS:[403038]                ;  <<Load integer>> 2540BE400 = 10^10
004013C3   |.  DD55 B8             FST QWORD PTR SS:[EBP-48]                 ;  <<Floating point store
004013C6   |.  DC5D C8             FCOMP QWORD PTR SS:[EBP-38]               ;  x1 < 10^10 ???
004013C9   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013CB   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013CC   |.  72 1C               JB SHORT Zebrone.004013EA                 ;  Si salta bad boy
004013CE   |.  DD45 F0             FLD QWORD PTR SS:[EBP-10]                 ;  <<Floating point load
004013D1   |.  DD5D B0             FSTP QWORD PTR SS:[EBP-50]                ;  <<Store and pop
004013D4   |.  DD45 C0             FLD QWORD PTR SS:[EBP-40]                 ;  <<Floating point load
004013D7   |.  DC5D B0             FCOMP QWORD PTR SS:[EBP-50]               ;  x2 > 1 ???
004013DA   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013DC   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013DD   |.  77 0B               JA SHORT Zebrone.004013EA                 ;  Si salta bad boy
004013DF   |.  DD45 B8             FLD QWORD PTR SS:[EBP-48]                 ;  <<Floating point load>> carga 10^10
004013E2   |.  DC5D B0             FCOMP QWORD PTR SS:[EBP-50]               ;  x2 < 10^10 ???
004013E5   |.  DFE0                FSTSW AX                                  ;  <<Store status word
004013E7   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
004013E8   |.  73 04               JNB SHORT Zebrone.004013EE                ;  Salta si menor
004013EA   |>  31C0                XOR EAX,EAX
004013EC   |.  EB 40               JMP SHORT Zebrone.0040142E                ;  Bad boy
004013EE   |>  DD45 F8             FLD QWORD PTR SS:[EBP-8]                  ;  <<Floating point load>> carga x1
004013F1   |.  D9FE                FSIN                                      ;  Sin(x1)
004013F3   |.  DD5D A8             FSTP QWORD PTR SS:[EBP-58]                ;  <<Store and pop
004013F6   |.  DD45 F0             FLD QWORD PTR SS:[EBP-10]                 ;  <<Floating point load>> carga x2
004013F9   |.  D9FE                FSIN                                      ;  Sin(x2)
004013FB   |.  DD5D A0             FSTP QWORD PTR SS:[EBP-60]                ;  <<Store and pop
004013FE   |.  DD45 A8             FLD QWORD PTR SS:[EBP-58]                 ;  <<Floating point load
00401401   |.  DC4D A0             FMUL QWORD PTR SS:[EBP-60]                ;  Sin(x1) * Sin(x2)
00401404   |.  DF2D 30304000       FILD QWORD PTR DS:[403030]                ;  <<Load integer>> 2386F26FC10000 = 10^16
0040140A   |.  DEC9                FMULP ST(1),ST                            ;  10^16 * (Sin(x1) * Sin(x2))
0040140C   |.  83EC 08             SUB ESP,8
0040140F   |.  DD1C24              FSTP QWORD PTR SS:[ESP]                   ;  <<Store and pop
00401412   |.  E8 D1000000         CALL <JMP.&CRTDLL.floor>
00401417   |.  83C4 08             ADD ESP,8
0040141A   |.  DD5D 98             FSTP QWORD PTR SS:[EBP-68]
0040141D   |.  D9EE                FLDZ                                      ;  <<Load 0.0 onto stack
0040141F   |.  DC5D 98             FCOMP QWORD PTR SS:[EBP-68]               ;  10^16 * (Sin(x1) * Sin(x2)) = 0 ???
00401422   |.  DFE0                FSTSW AX
00401424   |.  9E                  SAHF                                      ;  <<Store AH into FLAGS
00401425   |.  75 05               JNZ SHORT Zebrone.0040142C                ;  Si NO salta todo OK
00401427   |.  31C0                XOR EAX,EAX
00401429   |.  40                  INC EAX
0040142A   |.  EB 02               JMP SHORT Zebrone.0040142E
0040142C   |>  31C0                XOR EAX,EAX
0040142E   |>  C9                  LEAVE
0040142F   \.  C3                  RETN

La primera dificultad que podemos encontrar es que utiliza instrucciones FPU y coma flotante, ya que si no tenemos la vista entrenada nos puede resultar un engorro. Superado esto, la rutina de comprobación se puede resumir así:

x1 * x2 != 0
x1 != x2
x1 > 1 y < 10^10
x2 > 1 y < 10^10
Floor[10^16 * sin(x1) * sin(x2)] = 0

A priori no parece que tenga mucha dificultad, pero vamos a analizarlo más concienzudamente. Necesitamos que la parte entera del resultado de la multiplicación sea 0, algo que parece sencillo, pero fíjate que la constante 10^16 nos obliga a su vez, a que el resultado del seno sea muy pequeño, cosa que como comprobaréis limita mucho los resultados satisfactorios.

Repasando trigonometría

Cuando nos enseñó nuestro profesor la función del seno nos hizo el siguiente dibujo:

Partiendo de la circunferencia unitaria, podemos concluir que el seno de alpha es igual a la altura x. Como lo que nos interesa a nosotros es que el seno sea muy pequeño, en realidad estamos buscando que la x sea lo más pequeña posible. Llegamos entonces a la conclusión de que las soluciones para enteros entre 1 y 10^10 van a ser muy reducidas. Además nos percatamos que el ángulo alpha va a tener que estar muy proximo a 0º – 360 (0 – 2π) y a 180º (π). En el siguiente gráfico queda claro el estrecho margen en el que nos movemos.

Si habéis leído la solución de cronos ahora le encontraréis algo más de sentido a por que él utilizó fracciones continuas de π y cogió como resultado los numeradores más cercanos a 10^10, en su caso 245850922 y 411557987.

Análisis operacional

Vamos a analizar un ejemplo operacional.

sin( x rad)
sin(245850922) = 6,1180653830011163142712109862972e-9
sin(411557987) = 2,536716051963676479648989773448e-9

sin(245850922)*sin(411557987) = 1,5519794664022230015882605365808e-17

10^16 * 1,5519794664022230015882605365808e-17 = 0,15519794664022230015882605365808

Floor(0,15519794664022230015882605365808) = 0

Como veis, el exponente negativo (^-17) debe ser mayor que el positivo (^16) para tener éxito.

Fuerza bruta

Lo que vamos a hacer a continuación es buscar todos los senos con exponente negativo ^-8 ó ^-9 de enteros entre 1 y 10^10, y vamos a cruzar los resultados para determinar todos los resultados válidos.

Preparamos el programa y le dejamos trabajar. En principio vamos a filtrar todos los resultados que tengan exponente negativo y luego ya aislaremos los que nos interesan. Esto lo hago por curiosidad.

La fuerza bruta nos arroja 63663 resultados con exponente negativo entre ^-5 y ^-9, de los cuales solamente nos quedamos con 65, que son los comprendidos a exponentes de entre ^-8 y ^-9. Los números mágicos son los siguientes:

Los rojos son exponentes ^-9, el resto ^-8.

La mayoría de estos números solo valen con ciertas combinaciones, de hecho, ninguno vale para todos. Esto se debe, a parte del propio exponente, a que hay senos positivos y negativos y para hacer válido a un seno negativo hay que combinarlo con otro negativo. Esto último se debe únicamente a la interpretación que hace el crackme.

Finalmente cruzamos los resultados y obtenemos 44 combinaciones de seriales válidos que si obviamos repeticiones se reducen a la mitad.

Combinaciones válidas:

Conclusiones

Podemos concluir que para cada 10^10 enteros hay 22 soluciones posibles. Finalmente comentar que si aLoNg3x no hubiera puesto el límite en 10^10, habría soluciones infinitas.

Links

ThisIsLegal.com - Realistic Challenge 4

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

Afinador

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

Crypto - Vodka

Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos

¿El crackme de android más famoso del mundo?

Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar

1 2 3 … 30 Next »

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.

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)

Crypto – Vodka

3 agosto, 2024 por deurus·Sin comentarios

Hemos interceptado un mensaje secreto, pero ninguno de nuestros traductores lo sabe interpretar, ¿sabrías interpretarlo tú? Lo único que hemos encontrado es esto en un foro: шжзклмнпфъ = 1234567890

Mensaje secreto: нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл

Solución

Parece que el mensaje secreto está encriptado utilizando un alfabeto cifrado que corresponde a números. Según la clave proporcionada (шжзклмнпфъ = 1234567890), cada letra del alfabeto cirílico se sustituye por un número.

Primero, descompondremos la clave dada:
ш = 1
ж = 2
з = 3
к = 4
л = 5
м = 6
н = 7
п = 8
ф = 9
ъ = 0

Ahora, aplicamos esta clave al mensaje secreto:

нж, фн, фф, шън, нф, шшъ, шжз, мф, шъп, фл, пк, шъш, шшм, шшк, шъл, шшл, фл, шъш, шшл, фл, шшн, шшъ, фл, шъм, шшн, шъш, шъз, шшш, фл, пж, шшн, шшл, шшш, шжл

Sustituyendo cada letra según la clave:

нж = 72
фн = 97
фф = 99
шън = 107
нф = 79
шшъ = 110
шжз = 123
мф = 69
шъп = 108
фл = 95
пк = 84
шъш = 101
шшм = 116
шшк = 114
шъл = 105
шшл = 115
фл = 95
шъш = 101
шшл = 115
фл = 95
шшн = 117
шшъ = 110
фл = 95
шъм = 106
шшн = 117
шъш = 101
шъз = 130
шшш = 111
фл = 95
пж = 82
шшн = 117
шшл = 115
шшш = 111
шжл = 125

El mensaje traducido a números es:

72, 97, 99, 107, 79, 110, 123, 69, 108, 95, 84, 101, 116, 114, 105, 115, 95, 101, 115, 95, 117, 110, 95, 106, 117, 101, 130, 111, 95, 82, 117, 115, 111, 125

Este parece ser un mensaje cifrado en números. La secuencia de números se puede interpretar de varias maneras (como ASCII, coordenadas, etc.). Si asumimos que es un texto codificado en ASCII:

Convertimos cada número a su correspondiente carácter ASCII:

72 = H
97 = a
99 = c
107 = k
79 = O
110 = n
123 = {
69 = E
108 = l
95 = _
84 = T
101 = e
116 = t
114 = r
105 = i
115 = s
95 = _
101 = e
115 = s
95 = _
117 = u
110 = n
95 = _
106 = j
117 = u
101 = e
130 = ?
111 = o
95 = _
82 = R
117 = u
115 = s
111 = o
125 = }

Juntando todo:

HackOn{El_Tetris_e_s_u_n_j_u_e?o_Ruso}

La parte «{El_Tetris_e_s_u_n_j_u_e?o_Ruso}» parece un mensaje en español. Probablemente deba ser leído como: HackOn{El_Tetris_es_un_juego_Ruso}

Así, el mensaje secreto es: HackOn{El_Tetris_es_un_juego_Ruso}.

La imagen de portada de la entrada ha sido generada con ChatGPT.

¿El crackme de android más famoso del mundo?

24 mayo, 2015 por deurus·1 comentario

Hace unos años cuando empecé a trastear con Android y animado por mi afición a la Ingeniería Inversa, decidí realizar una serie de crackmes. Los dos primeros pasaron algo desapercibidos, pero el Crackme nº3 tuvo una gran repercusión en el mundillo y, aunque no fue el primer crackme para Android ni mucho menos, si que fue uno de los más estudiados. Todos ellos fueron publicados a través de crackmes.de y el nº3 en cuestión el 6 de Noviembre de 2010. Os dejo una lista de unas cuantas webs donde aparece analizado para que veáis la repercusión que a mi parecer tuvo.

Soluciones al crackme

Referencias al crackme

Android High Performance Programming (Libro)

Links

Mirror Crackmes.de

While Crackmes.de returns, I leave a couple of files for practice. Mientras vuelve Crackmes.de, os dejo un par de archivos para practicar.

Solución a los retos javascript de rogerfm.net

Introducción Javascript 1 (Serial a la vista) Javascript 2 (La función charAt()) Javascript 3 (Input) Javascript 4 (Fuerza bruta manual) Javascript

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

AperiSolve en tu Raspi

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he

1 2 3 … 30 Next »

ThisIsLegal.com – Realistic Challenge 3

27 agosto, 2014 por deurus·Sin comentarios

Table of Contents

Introducción

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

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

Mirror Crackmes.de

29 marzo, 2017 por deurus·Sin comentarios

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

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

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

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

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

 password of files = deurus.info

AperiSolve en tu Raspi

Acabo de montar AperiSolve en una Raspi que tenía por casa pensando que sería coser y cantar, pero me he

VideoTutorial - Desempacando Aspack 2.1, Pe-Pack 1.0 y UPX del Crackme Sweeet Dream 1.0 de 2Sweeet

http://youtu.be/ZO_GucNNtIQ Lista de reproducción

5 revistas sobre Hacking imprescindibles

Si te interesa el mundo del hacking, ya sea como aficionado o como profesional, seguramente querrás estar al día de

ThisIsLegal.com - Realistic Challenge 2

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

1 2 3 … 30 Next »

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/*

VideoTutorial – Desempacando Aspack 2.1, Pe-Pack 1.0 y UPX del Crackme Sweeet Dream 1.0 de 2Sweeet

25 septiembre, 2014 por deurus·1 comentario

Lista de reproducción

5 revistas sobre Hacking imprescindibles

25 abril, 2023 por deurus·Sin comentarios

Si te interesa el mundo del hacking, ya sea como aficionado o como profesional, seguramente querrás estar al día de las últimas novedades, técnicas y herramientas que se utilizan en este campo. Para ello, una buena opción es suscribirte a alguna de las revistas sobre hacking que existen en el mercado. Estas publicaciones te ofrecen información de calidad, actualizada y veraz sobre todo lo relacionado con la seguridad informática, el pentesting, el hacking ético y otros temas de interés. En este artículo te presentamos cinco revistas sobre hacking que deberías leer si quieres ampliar tus conocimientos y habilidades en este ámbito.

Es una de las revistas más populares y reconocidas sobre hacking. Se publica desde el año 2005 y cuenta con una amplia comunidad de lectores y colaboradores. Su contenido abarca desde los aspectos más básicos hasta los más avanzados del hacking, con artículos, tutoriales, entrevistas, casos de estudio y reseñas de herramientas. Además, tiene ediciones especiales dedicadas a temas específicos como el hacking web, el hacking móvil, el malware o el IoT. Puedes acceder a su versión digital o impresa desde su página web.

hakin9.org

Es una revista electrónica sobre hacking que se publica desde el año 1985. Tiene una periodicidad irregular y se distribuye de forma gratuita a través de Internet. Sus contenidos son principalmente artículos técnicos sobre hacking, seguridad informática, programación, etc. También incluye algunos textos de ficción y humor relacionados con el hacking. Es una revista muy apreciada por la comunidad hacker por su calidad y originalidad.

phrack.org

2600: The Hacker Quarterly es una revista legendaria entre los hackers, ya que se publica desde 1984 y ha sido testigo de la evolución de este movimiento a lo largo de las décadas. Su nombre hace referencia a la frecuencia de 2600 Hz que se usaba para hackear las líneas telefónicas en los años 60 y 70. En sus páginas encontrarás artículos sobre hacking, seguridad informática, cultura hacker, activismo digital y mucho más.

2600.com

Revista especializada en pentesting o pruebas de penetración, una de las ramas más importantes del hacking ético. Su contenido está dirigido tanto a principiantes como a expertos en esta materia, con artículos prácticos, teóricos y metodológicos sobre cómo realizar pentests eficaces y profesionales. También incluye entrevistas a destacados pentesters, reseñas de herramientas y reportajes sobre proyectos y eventos relevantes. Puedes descargar su versión digital desde su página web o comprar su versión impresa.

pentestmag.com

Es una revista para los entusiastas del hacking creativo, es decir, aquellos que usan la tecnología para crear proyectos innovadores y divertidos. En sus páginas encontrarás ideas, tutoriales, consejos y reseñas sobre temas como la electrónica, la robótica, el hardware libre, el software libre, el internet de las cosas, la impresión 3D y mucho más..

hackspace.raspberrypi.com

ThisIsLegal.com – Realistic Challenge 2

27 agosto, 2014 por deurus·Sin comentarios

Table of Contents

Introducción

Realistic Challenge 2: You have heard about people being targeted by a new religion called Egitology. Another hacker infiltrated the group and discovered that the list of people they target is stored on the site but he doesn’t know where.

Break into the site, find the file and remove it. Also leave no evidence that you was ever there so they wont realise until its too late!

El enunciado del reto nos dice que tenemos que localizar la lista de objetivos y eliminarla sin dejar evidencias.

Analizando la seguridad de la víctima

Echamos un vistazo y vemos que tienen un Login para usuarios registrados, este será nuestro primer testeo.

Lo primero que se no viene a la cabeza con un formulario de este tipo es Inyección SQL, probamos varios métodos y tenemos suerte.

User: admin
Pass: ‘ or 1=1–‘;

Vemos que hemos entrado como admin y enseguida nos llama la atención «Back up Database«. Pulsamos a ver que pasa.

Obtenemos el hash de las claves de los usuarios Admin y SuperAdmin. Por suerte son hashes MD5. Obtenemos la clave de SuperAdmin y nos loguemos.

Solo nos queda borrar la lista de objetivos y nuestras huellas. Para ello borramos los siguientes archivos y reto superado.

Lista de objetivos: root/misc/targets
Logs: root/images/logs