elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Estamos en la red social de Mastodon


+  Foro de elhacker.net
|-+  Programación
| |-+  Ingeniería Inversa (Moderadores: karmany, .:UND3R:., MCKSys Argentina)
| | |-+  [Tutorial] Russian Dolls crackme
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: [Tutorial] Russian Dolls crackme  (Leído 9,372 veces)
.:UND3R:.
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.118


Ingeniería inversa / MASM


Ver Perfil WWW
[Tutorial] Russian Dolls crackme
« en: 5 Enero 2012, 08:50 am »

Tutorial Russian Dolls crackme
Autor: Andrewl
información del crackme:http://crackmes.de
Autor del tutorial:UND3R
Objetivos: Realizar Keygen

Abrimos el crackme directamente, observaremos que nos informa el número de dígitos del serial:


Si introducimos un serial falso nos mostrará el siguiente mensaje:


Abrimos el crackme desde OllyDbg y veremos el siguiente Entry Point:


Buscamos referencias de texto dentro del crackme:


Notaremos la cadena de texto "Congratulations!", hacemos doble clic para dirigirnos hacia la dirección en donde es utilizada:


Vemos una instrucción PUSH, encargada de meter el puntero de la cadena de texto en el stack y luego una instrucción JMP SHORT que permite la utilización de la misma call hacia la API MessageBoxA permitiendo el ahorro de instrucciones:


Si subimos un poco veremos que para que el crackme nos muestre el mensaje de "Congratulations!" se deben cumplir ocho comparaciones. Si alguna de las ocho nos da como resultado cero (Activación de la bandera ZF) nos mostrará el mensaje equivalente al introducir un serial falso. Para obtener el mensaje de un serial correcto se debería cumplir las siguientes afirmaciones:

Citar
00402D78   .  807C24 11 00  CMP BYTE PTR SS:[ESP+11],0
Stack SS:[0012FAC5]=01

00402D7F   .  807C24 14 00  CMP BYTE PTR SS:[ESP+14],0
Stack SS:[0012FAC8]=01

00402D86   .  807C24 13 00  CMP BYTE PTR SS:[ESP+13],0
Stack SS:[0012FAC7]=01

00402D8D   .  807C24 17 00  CMP BYTE PTR SS:[ESP+17],0
Stack SS:[0012FACB]=01

00402D94   .  807C24 16 00  CMP BYTE PTR SS:[ESP+16],0
Stack SS:[0012FACA]=01

00402D9B   .  807C24 15 00  CMP BYTE PTR SS:[ESP+15],0
Stack SS:[0012FAC9]=01

00402DA2   .  807C24 10 00  CMP BYTE PTR SS:[ESP+10],0
Stack SS:[0012FAC4]=01

00402DA9   .  807C24 12 00  CMP BYTE PTR SS:[ESP+12],0
Stack SS:[0012FAC6]=01

* (Otra manera sería invertir los nemónicos de instrucciones JE SHORT por JNE SHORT)

También vemos un CALL ESI llamativo ya que este podría ser el encargado de comprobar si el serial introducido corresponde a un serial válido, coloquemos un BP en él:


Iniciamos el crackme (F9) e introducimos un serial falso:


Notaremos que se ha detenido en nuestro BP:


Entramos al CALL ESI y veremos lo siguiente:


Traceamos algunas instrucciones hasta llegar a la instrucción XOR:


Si pasamos la instrucción XOR (F7), notaremos que han cambiado algunas instrucciones posteriores a JNZ SHORT. Esto se debe a una función de descifrado en donde el contenido de ESI es alterado producto de la operación booleana XOR entre [ESI] y 76, guardando el resultado en el operando de destino (dentro de ESI). Luego de eso es incrementado ESI para apuntar a las siguientes instrucciones y disminuido ECX, este segundo registro es utilizado como contador de bucle ya que luego de SUB ECX,1 hay un nemónico de instrucción de tipo salto condicional en donde salta a la instrucción XOR si el resultado de la instrucción SUB ECX,1 es distinto de cero:


Colocamos un BP a continuación de JNZ SHORT e iniciamos el crackme (F9):


Veremos una serie de instrucciones descifradas:


Quitamos el BP y traceamos (F7), notaremos las siguientes instrucciones encargadas de la validación del serial:
Código:
0FB648 03       MOVZX ECX,BYTE PTR DS:[EAX+3] ; mueve el cuarto valor del serial a ECX
83F9 6D         CMP ECX,6D                    ; lo compara con 6D (m)

En caso de que la comparación de como resultado la activación de la bandera Cero (ZF), se moverá dentro de EDX el byte 1:
Código:
MOV BYTE PTR DS:[EDX],1



Si miramos el valor de EDX en los registros de propósito general de 32 bits veremos que EDX apunta a una de las ocho direcciones que debe contener 1 byte para que el serial sea considerado como válido:


Si seguimos traceando (F7) notaremos una función encargada de cifrar las instrucciones previamente descifradas:


Seguimos traceando (F7), veremos nuevamente el procedimiento de descifrado:


Colocamos un BP a continuación de la instrucción JNZ SHORT:


Iniciamos nuevamente el crackme (F9) y notaremos que se repiten nuevamente los procedimientos:


 podríamos resumirlo de la siguiente manera:
-descifra las instrucciones a ejecutar
-ejecuta las instrucciones descifradas encargadas de verificar el serial
-cifra las instrucciones previamente ejecutadas


(Lo más probable es que el programa cifre las instrucciones ejecutadas para evitar que al retornar del CALL ESI queden descubiertas todas las instrucciones de comprobación del serial, al igual que luego de introducir un serial si es dumpeado el ejecutable, quedarían expuestas las comprobaciones.)

Si seguimos traceando notaremos que siempre se repiten las mismas funciones:
Código:
0015E028    0FB648 03       MOVZX ECX,BYTE PTR DS:[EAX+3] ; mueve el cuarto valor del serial a ECX
0015E02F    83F9 6D         CMP ECX,6D                    ; lo compara con 6D (m)

0015E069    0FB648 02       MOVZX ECX,BYTE PTR DS:[EAX+2] ; mueve el tercer valor del serial a ECX
0015E070    83F9 37         CMP ECX,37                    ; lo compara con 37 (7)

0015E0AA    0FB648 03       MOVZX ECX,BYTE PTR DS:[EAX+3] ; mueve el cuarto valor del serial a ECX
0015E0B1    83F9 65         CMP ECX,65                    ; lo compara con 65 (e)

0015E0EB    0FB648 07       MOVZX ECX,BYTE PTR DS:[EAX+7] ; mueve el octavo valor del serial a ECX
0015E0F2    83F9 48         CMP ECX,48                    ; lo compara con 48 (H)

0015E12C    0FB648 03       MOVZX ECX,BYTE PTR DS:[EAX+3] ; mueve el cuarto valor del serial a ECX
0015E133    83F9 37         CMP ECX,37                    ; lo compara con 37 (7)

0015E16D    0FB648 00       MOVZX ECX,BYTE PTR DS:[EAX]   ; mueve el primer valor del serial a ECX
0015E174    83F9 37         CMP ECX,37                    ; lo compara con 37 (7)

0015E1AE    0FB648 01       MOVZX ECX,BYTE PTR DS:[EAX+1] ; mueve el segundo valor del serial a ECX
0015E1B5    83F9 55         CMP ECX,55                    ; lo compara con 55 (U)

0015E1EF    0FB648 01       MOVZX ECX,BYTE PTR DS:[EAX+1] ; mueve el segundo valor del serial a ECX
0015E1F6    83F9 64         CMP ECX,64                    ; lo compara con 64 (d)

0015E230    0FB648 04       MOVZX ECX,BYTE PTR DS:[EAX+4] ; mueve el quinto valor del serial a ECX
0015E237    83F9 47         CMP ECX,47                    ; lo compara con 47 (G)

0015E271    0FB648 02       MOVZX ECX,BYTE PTR DS:[EAX+2] ; mueve el tercer valor del serial a ECX
0015E278    83F9 37         CMP ECX,37                    ; lo compara con 37 (7)

0015E2B2    0FB648 01       MOVZX ECX,BYTE PTR DS:[EAX+1] ; mueve el segundo valor del serial a ECX
0015E2B9    83F9 55         CMP ECX,55                    ; lo compara con 55 (U)

0015E2F3    0FB648 07       MOVZX ECX,BYTE PTR DS:[EAX+7] ; mueve el octavo valor del serial a ECX
0015E2FA    83F9 6F         CMP ECX,6F                    ; lo compara con 6F (o)

0015E334    0FB648 05       MOVZX ECX,BYTE PTR DS:[EAX+5] ; mueve el sexto valor del serial a ECX
0015E33B    83F9 37         CMP ECX,37                    ; lo compara con 37 (7)

0015E375    0FB648 03       MOVZX ECX,BYTE PTR DS:[EAX+3] ; mueve el cuarto valor del serial a ECX
0015E37C    83F9 36         CMP ECX,36                    ; lo compara con 36 (6)

0015E3B6    0FB648 01       MOVZX ECX,BYTE PTR DS:[EAX+1] ; mueve el segundo valor del serial a ECX
0015E3BD    83F9 33         CMP ECX,33                    ; lo compara con 33 (3)

0015E3F7    0FB648 04       MOVZX ECX,BYTE PTR DS:[EAX+4] ; mueve el quinto valor del serial a ECX
0015E3FE    83F9 45         CMP ECX,45                    ; lo compara con 45 (E)

0015E438    0FB648 02       MOVZX ECX,BYTE PTR DS:[EAX+2] ; mueve el tercer valor del serial a ECX
0015E43F    83F9 50         CMP ECX,50                    ; lo compara con 50 (P)

0015E479    0FB648 02       MOVZX ECX,BYTE PTR DS:[EAX+2] ; mueve el tercer valor del serial a ECX
0015E480    83F9 36         CMP ECX,36                    ; lo compara con 36 (6)

0015E4BA    0FB648 05       MOVZX ECX,BYTE PTR DS:[EAX+5] ; mueve el sexto valor del serial a ECX
0015E4C1    83F9 39         CMP ECX,39                    ; lo compara con 39 (9)

0015E4FB    0FB648 05       MOVZX ECX,BYTE PTR DS:[EAX+5] ; mueve el sexto valor del serial a ECX
0015E502    83F9 49         CMP ECX,49                    ; lo compara con 49 (I)

0015E53C    0FB648 00       MOVZX ECX,BYTE PTR DS:[EAX]   ; mueve el primer valor del serial a ECX
0015E543    83F9 35         CMP ECX,35                    ; lo compara con 35 (5)

0015E57D    0FB648 02       MOVZX ECX,BYTE PTR DS:[EAX+2] ; mueve el tercer valor del serial a ECX
0015E584    83F9 7A         CMP ECX,7A                    ; lo compara con 7A (z)

0015E5BE    0FB648 01       MOVZX ECX,BYTE PTR DS:[EAX+1] ; mueve el segundo valor del serial a ECX
0015E5C5    83F9 6E         CMP ECX,6E                    ; lo compara con 6E (n)

0015E5FF    0FB648 03       MOVZX ECX,BYTE PTR DS:[EAX+3] ; mueve el cuarto valor del serial a ECX
0015E606    83F9 6A         CMP ECX,6A                    ; lo compara con 6A (j)

0015E640    0FB648 01       MOVZX ECX,BYTE PTR DS:[EAX+1] ; mueve el segundo valor del serial a ECX
0015E647    83F9 7A         CMP ECX,7A                    ; lo compara con 7A (z)

0015E681    0FB648 06       MOVZX ECX,BYTE PTR DS:[EAX+6] ; mueve el séptimo valor del serial a ECX
0015E688    83F9 57         CMP ECX,57                    ; lo compara con 57 (W)

0015E6C2    0FB648 05       MOVZX ECX,BYTE PTR DS:[EAX+5] ; mueve el sexto valor del serial a ECX
0015E6C9    83F9 4F         CMP ECX,4F                    ; lo compara con 47 (O)

Por lo que podríamos crear un script de ODbg encargado de almacenar todas las comparaciones que realiza. Al realizar comprobaciones de los datos obtenidos por el script, los serial ingresados eran considerados como incorrectos por lo que por lógica deberían haber más comparaciones que si se cumplen se introduce un byte 0, por lo que encontré funciones muy similares pero con la gran diferencia que si estas se cumplían en vez de poseer la instrucción MOV BYTE PTR DS:[EDX],1 a continuación de JNZ SHORT, contenían la instrucción MOV BYTE PTR DS:[EDX],0, a consecuencia de esto cree un script que en un documento de texto me mostrara la comparación junto con un SI o un NO en donde SI es introducido cuando la instrucción siguiente a JNZ SHORT es MOV BYTE PTR DS:[EDX],1 y un NO cuando la instrucción siguiente a JNZ SHORT es MOV BYTE PTR DS:[EDX],0

Script:
Código
  1. VAR AUX
  2. VAR FSERIAL
  3. VAR SERIAL
  4. WRT "log.txt","Log:"                                                  
  5. INICIO:
  6. TICND  "byte [eip]==75 && byte [eip+1]==0F7"  
  7. BP eip+2
  8. RUN
  9. BC eip
  10. TICND  "byte [eip]==8B && byte [eip+1]==55"
  11. STI
  12. CMP edx,0012FAC5
  13. JE ENCONTRADO
  14. CMP edx,0012FAC8
  15. JE ENCONTRADO
  16. CMP edx,0012FAC7
  17. JE ENCONTRADO
  18. CMP edx,0012FACB
  19. JE ENCONTRADO
  20. CMP edx,0012FACA
  21. JE ENCONTRADO
  22. CMP edx,0012FAC9
  23. JE ENCONTRADO
  24. CMP edx,0012FAC4
  25. JE ENCONTRADO
  26. CMP edx,0012FAC6
  27. JE ENCONTRADO
  28. JMP INICIO
  29. ENCONTRADO:  
  30. MOV FSERIAL,ecx
  31. BUF FSERIAL
  32. STR FSERIAL  
  33. MOV SERIAL,[eip+2],1
  34. BUF SERIAL
  35. STR SERIAL
  36. STI
  37. ADD eip,2
  38. CMP [eip],C6,1
  39. JNE INICIO
  40. CMP [eip+1],02,1
  41. JNE INICIO
  42. CMP [eip+2],01,1
  43. JE SI
  44. NO:
  45. MOV AUX,"NO"
  46. JMP CONTINUAR
  47. SI:
  48. MOV AUX,"SI"
  49. CONTINUAR:
  50. WRTA "log.txt",FSERIAL
  51. WRTA "log.txt","=",""
  52. WRTA "log.txt",SERIAL,""
  53. WRTA "log.txt"," ",""
  54. WRTA "log.txt",AUX,""  
  55. jmp INICIO

El script debe ser ejecutado de la siguiente forma:
1)colocar BP en CALL ESI
2)iniciar el crackme (F9)
3)introducir el serial: 12345678 (ya que nos dará la referencia de la posición del dígito que se está comparando)
4)Se detendrá en el BP se debe quitar y entrar dentro del CALL (001CFFE8    55              PUSH EBP)

El script debe ser detenido una vez que hemos presionado aceptar a la alerta generada por la API MessageBoxA del serial incorrecto.

Una vez terminado el script si abrimos log.txt (documento de texto creado por el script) veremos lo siguiente:

En la primera linea:
el cuarto carácter es comparado con m y si este se cumple mueve dentro de EDX el byte 1.

Ya que el script logea las comparaciones de manera secuencial, la lógica sería buscar desde abajo hacia arriba una comparación con SI y luego buscar hacia abajo la misma comparación con un NO, si se encuentra la comparación el dígito es inválido en caso contrario el dígito es válido, para optimizar la búsqueda utilizaremos Excel, seleccionamos todo el contenido de log.txt y lo pegamos dentro de una nueva hoja de Excel:


Nos dirigimos a Datos->Filtro:


En la ubicación A1 ("Log:") contendrá un botón:


Seleccionamos el botón y nos vamos a Filtros de texto-> Comienza por...:


He introducimos 1:


De esta forma Excel filtrará de manera secuencial todos los datos que comienza con 1, en otras palabras nos mostrará todas las comparaciones realizadas con el primer dígito:


Copiamos el contenido filtrado en un nuevo documento de texto, nos dirigimos hasta el final y comenzamos a buscar "SI" de la siguiente manera:

De manera lógica estamos buscando la última comparación válida del dígito 1

Ya encontrado el "SI" buscamos hacia abajo la igualdad válida para saber si es anulada por un "NO" (En este caso está a la vista, pero en los demás dígitos no son tan visibles las igualdades válidas que más abajo se ven afectadas por un "NO"):


Si no se encuentra la comparación hemos encontrado un dígito válido:

en caso contrario debemos volver al "SI" encontrado y buscar nuevamente "SI" hacia arriba ya encontrado el primer dígito se debe filtrar nuevamente en Excel pero esta vez por los que comienzan en 2 y repetir el procedimiento de búsqueda hasta encontrar los ocho dígitos.

Una vez encontrado los ocho dígitos al introducir el serial, el crackme nos mostrará el siguiente mensaje:


Ya con un serial válido podemos obtener un Keygen:
1)debemos introducir el serial válido.
2)EJ: CAaC5EEs.
3)Si queremos saber todas las posibilidades del primer dígito vamos introduciendo números desde el "0" al "9", luego letras mayúsculas desde la "A" a la "Z" y letras minúsculas desde la "a" a la "z".

Pero el mensaje del serial incorrecto nos es un poco molesto, por lo que podríamos borrarlo, nos dirigimos a la string: "sorry, try harder!":


y llenamos con instrucciones NOP (Not operand) y agregamos un JMP tal como lo muestra la imagen:


Guardamos los cambios y ya podremos obtener los dígitos válidos para cada posición del serial con mayor comodidad.

La lista completa de posibles combinaciones es la siguiente:
Código:
   1ºD   2ºD   3ºD   4ºD   5Dº   6Dº   7ºD   8ºD
VA 1     4     2     8     4     7     1     4
   C     A     a     C     5     E     E     s
         B                 D     F
         C                 J     H
         E                 Ñ     K
         J                 P     L
         K                 U     M
         M                 ñ     N
         Ñ                       Ñ
         O                       Q
         Q                       R
         R                       S
         V                       U
         Z                       V
         a                       W
         g                       X
         i                       Y
         k                       g
         m                       h
         q                       i
         s                       j
         y                       ñ
                                 o
                                 q
                                 t
                                 z

Keygen:
Para el Keygen he tenido que suprimir las letras Ñ y ñ en cuanto a la generación del serial debido a que estoy iniciándome en el lenguaje ASM y estoy utilizando procedimientos pre-diseñados por lo que desconozco como solucionarlo y como trabajar directamente con APIS por lo que el Keygen es muy simple, pero cumple con su finalidad, aquí el código de fuente:

Código
  1. TITLE Keygen Russian Dolls (Keygen-Russian-Dolls.asm)
  2. ; Genera combinaciones de dígitos válidos para el crackme Russian Dolls
  3. ; Autor: UND3R
  4. ; Fecha: Miércoles 4 de enero de 2012
  5. INCLUDE c:\masm32\include\Irvine32.inc
  6. INCLUDELIB c:\masm32\lib\kernel32.lib
  7. INCLUDELIB c:\masm32\lib\Irvine32.lib
  8. INCLUDELIB c:\masm32\lib\User32.lib
  9. .data
  10. ; en el arreglo SegundoDigito se ha omitido la letra Ñ
  11. ; en el arreglo QuintoDigito se ha omitido la letra Ñ y ñ
  12. ; en el arreglo SextoDigito se ha omitido la letra Ñ y ñ
  13. PrimerDigito  BYTE 31h,"C"
  14. SegundoDigito BYTE 34h,"A","B","C","E","J","K","M","O","Q","R","V","Z","a","g","i","k","m","q","s","y"
  15. TercerDigito  BYTE 32h,"a"
  16. CuartoDigito  BYTE 38h,"C"
  17. QuintoDigito  BYTE 34h,35h,"D","J","P","U"
  18. SextoDigito   BYTE 37h,"E","F","H","K","L","M","N","Q","R","S","U","V","W","X","Y","g","h","i","j","o","q","t","z"
  19. SeptimoDigito BYTE 31h,"E"
  20. OctavoDigito  BYTE 34h,"s"
  21. Serial        BYTE 8 DUP(?)
  22. Color         BYTE ?
  23.  
  24. .code
  25. main PROC
  26.    call GetTextColor              ; obtiene el color de texto y fondo de la consola
  27. mov Color,al                   ; mue AL dentro del arreglo Color
  28.    call Randomize                 ; inicializa el valor de la semilla para el procedimiento RandomRange
  29.    call GenerarSerial
  30.    call MostrarSerial
  31. jmp main
  32. main ENDP
  33. GenerarSerial PROC
  34. ; Genera seriales válidos de manera aleatoria
  35. ; RECIBE:   NADA
  36. ; DEVUELVE: Serial válido en el arreglo sin inicializar "Serial"
  37. ;--------------------------------------------------------------------
  38. mov eax,sizeof PrimerDigito    ; mueve a EAX el número de valores del arreglo
  39. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  40. mov dl,[PrimerDigito+eax]      ; mueve a DL un valor aleatorio del arreglo "PrimerDigito"
  41. mov [Serial],dl                ; mueve DL dentro del arreglo "Serial"
  42.  
  43. mov eax,sizeof SegundoDigito   ; mueve a EAX el número de valores del arreglo
  44. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  45. mov dl,[SegundoDigito+eax]     ; mueve a DL un valor aleatorio del arreglo "SegundoDigito"
  46. mov [Serial+1],dl              ; mueve DL dentro del arreglo "Serial"
  47.  
  48.    mov eax,sizeof TercerDigito    ; mueve a EAX el número de valores del arreglo
  49. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  50. mov dl,[TercerDigito+eax]      ; mueve a DL un valor aleatorio del arreglo "TercerDigito"
  51. mov [Serial+2],dl              ; mueve DL dentro del arreglo "Serial"
  52.  
  53. mov eax,sizeof CuartoDigito    ; mueve a EAX el número de valores del arreglo
  54. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  55. mov dl,[CuartoDigito+eax]      ; mueve a DL un valor aleatorio del arreglo "CuartoDigito"
  56. mov [Serial+3],dl              ; mueve DL dentro del arreglo "Serial"
  57.  
  58. mov eax,sizeof QuintoDigito    ; mueve a EAX el número de valores del arreglo
  59. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  60. mov dl,[QuintoDigito+eax]      ; mueve a DL un valor aleatorio del arreglo "QuintoDigito"
  61. mov [Serial+4],dl              ; mueve DL dentro del arreglo "Serial"
  62.  
  63. mov eax,sizeof SextoDigito     ; mueve a EAX el número de valores del arreglo
  64. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  65. mov dl,[SextoDigito+eax]       ; mueve a DL un valor aleatorio del arreglo "SextoDigito"
  66. mov [Serial+5],dl              ; mueve DL dentro del arreglo "Serial"
  67.  
  68. mov eax,sizeof SeptimoDigito   ; mueve a EAX el número de valores del arreglo
  69. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  70. mov dl,[SeptimoDigito+eax]     ; mueve a DL un valor aleatorio del arreglo "SeptimoDigito"
  71. mov [Serial+6],dl              ; mueve DL dentro del arreglo "Serial"
  72.  
  73. mov eax,sizeof OctavoDigito    ; mueve a EAX el número de valores del arreglo
  74. call RandomRange               ; genera números aleatorios desde 0 hasta EAX - 1
  75. mov dl,[OctavoDigito+eax]      ; mueve a DL un valor aleatorio del arreglo "OctavoDigito"
  76. mov [Serial+7],dl              ; mueve DL dentro del arreglo "Serial"
  77. ret
  78.  
  79. GenerarSerial ENDP
  80. MostrarSerial PROC
  81.    mov ecx,8                      ; establece ECX = 8
  82.    mov esi,0                      ; establece ESI = 0
  83.    L2:
  84.    mov eax,16                     ; establece EAX = 16
  85.    call RandomRange               ; Genera un número aleatorio entre 0 y EAX - 15
  86. cmp eax,0                      ; compara EAX con 0
  87. je L2                          ; si EAX = 0 se dirige a la etiqueta L2 (Evita un texto negro junto con un fondo de igual color)
  88. call SetTextColor              ; Cambia el color de texto y de fondo de la consola, de acuerdo al valor de AL
  89.    L1:
  90. mov al,[Serial+esi]            ; mueve los dígitos del arreglo "Serial" a AL
  91. call WriteChar                 ; escribe un dígito del arreglo "Serial" en la consola
  92. inc esi                        ; aumenta en uno esi
  93. loopd L1                       ; decrementa ECX y si ECX no es cero se dirige a la etiqueta L1
  94. call Crlf                      ; desplaza el cursor abajo, hacia la derecha
  95. mov al,[Color]                 ; mueve el contenido del arreglo Color a AL
  96. call SetTextColor              ; Cambia el color de texto y de fondo de la consola, de acuerdo al valor de AL
  97. call WaitMsg                   ; se espera que el usuario presiona alguna tecla para continuar
  98. call Clrscr                    ; limpia el contenido de la consola
  99. ret
  100.  
  101. MostrarSerial ENDP
  102. END main

En el cada vez que presionemos una tecla nos mostrará seriales distintos:


IMPORTANTE:
Si el serial es copiado directamente y no es introducido de manera manual o ni si quiera un dígito, el crackme lo considera como inválido pudiendo ser este verdadero.

UND3R



Pack de descarga:
-Crackme modificado sin el mensaje de serial incorrecto
-Código de fuente Keygen .asm
-Seriales correctos.txt
-Crackme
-Keygen
-Script
-log.txt

LINK: http://www.mediafire.com/?nxlnml8nx4i8dvb
En línea


Solicitudes de crack, keygen, serial solo a través de mensajes privados (PM)
.:UND3R:.
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.118


Ingeniería inversa / MASM


Ver Perfil WWW
Re: [Tutorial] Russian Dolls crackme
« Respuesta #1 en: 5 Enero 2012, 09:13 am »

Adjunto el .doc http://www.mediafire.com/?tfwab3pm1r1g9ir
En línea


Solicitudes de crack, keygen, serial solo a través de mensajes privados (PM)
Tinkipinki

Desconectado Desconectado

Mensajes: 242



Ver Perfil
Re: [Tutorial] Russian Dolls crackme
« Respuesta #2 en: 5 Enero 2012, 13:50 pm »

Hola .:UND3R:.
Excelente trabajo y documentacion..... ;-)

Saludos cordiales
En línea

Иōҳ


Desconectado Desconectado

Mensajes: 563


Ver Perfil
Re: [Tutorial] Russian Dolls crackme
« Respuesta #3 en: 5 Enero 2012, 14:13 pm »

En realidad son 2 caracteres para cada posición.

y este crackme es el del concurso de cls, y aún no termina  :silbar:
En línea

Eres adicto a la Ing. Inversa? -> www.noxsoft.net
.:UND3R:.
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.118


Ingeniería inversa / MASM


Ver Perfil WWW
Re: [Tutorial] Russian Dolls crackme
« Respuesta #4 en: 5 Enero 2012, 15:46 pm »

En realidad son 2 caracteres para cada posición.

y este crackme es el del concurso de cls, y aún no termina  :silbar:

Lo encontré en otra página:

http://crackmes.us/read.py?id=161

En cuanto a esos concursos de CLS como se mandan las soluciones? :S xd

Hola .:UND3R:.
Excelente trabajo y documentacion..... ;-)

Saludos cordiales

Muchas gracias Tinkipinki, hace tiempo que no sabía de ti, espero que estés muy bien Saludos

Saludos
« Última modificación: 5 Enero 2012, 15:50 pm por .:UND3R:. » En línea


Solicitudes de crack, keygen, serial solo a través de mensajes privados (PM)
Иōҳ


Desconectado Desconectado

Mensajes: 563


Ver Perfil
Re: [Tutorial] Russian Dolls crackme
« Respuesta #5 en: 5 Enero 2012, 16:01 pm »

Corrige el tute, tienes errores u.u
En línea

Eres adicto a la Ing. Inversa? -> www.noxsoft.net
.:UND3R:.
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.118


Ingeniería inversa / MASM


Ver Perfil WWW
Re: [Tutorial] Russian Dolls crackme
« Respuesta #6 en: 5 Enero 2012, 16:17 pm »

Cual es el error? si me dan siempre seriales válidos  :huh:
En línea


Solicitudes de crack, keygen, serial solo a través de mensajes privados (PM)
Иōҳ


Desconectado Desconectado

Mensajes: 563


Ver Perfil
Re: [Tutorial] Russian Dolls crackme
« Respuesta #7 en: 5 Enero 2012, 18:16 pm »

na error mío xD
En línea

Eres adicto a la Ing. Inversa? -> www.noxsoft.net
.:UND3R:.
Moderador Global
***
Desconectado Desconectado

Mensajes: 3.118


Ingeniería inversa / MASM


Ver Perfil WWW
Re: [Tutorial] Russian Dolls crackme
« Respuesta #8 en: 5 Enero 2012, 18:20 pm »

 >:( jeje, Saludos
En línea


Solicitudes de crack, keygen, serial solo a través de mensajes privados (PM)
karmany
Moderador
***
Desconectado Desconectado

Mensajes: 1.614


Sueñas que sueñas


Ver Perfil WWW
Re: [Tutorial] Russian Dolls crackme
« Respuesta #9 en: 5 Enero 2012, 18:24 pm »

Feliz año!! y qué magnifico trabajo UND3R !!!

Sé lo que cuesta escribir un pedazo tutorial como ese. Seguro que muchos te lo agradecerán. Y la cantidad de imágenes.

He guardado una copia en formato .png de todo el hilo. Si quieres pon el enlace en Crackmes/tutoriales para que no se pierda, que lo dejé abierto.

PD. Recuerdo que hace poco eras tú el que pedía consejo, ahora vas a ser tú el profesor :-P
« Última modificación: 5 Enero 2012, 18:27 pm por karmany » En línea

Páginas: [1] 2 Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Tutorial Crackme MadCrack v1 por karmany
Ingeniería Inversa
karmany 0 6,698 Último mensaje 30 Diciembre 2008, 01:53 am
por karmany
[Tutorial]CrackMe 1 by kaiser1313
Ingeniería Inversa
.:UND3R:. 7 6,154 Último mensaje 2 Septiembre 2011, 07:35 am
por apuromafo CLS
[TUTORIAL]Crackme edu « 1 2 »
Ingeniería Inversa
.:UND3R:. 11 8,333 Último mensaje 21 Octubre 2011, 19:07 pm
por .:UND3R:.
[Tutorial] SelfKeygen Crackme 58DD2D69 C.L.S.
Ingeniería Inversa
cibergolen 3 3,714 Último mensaje 25 Diciembre 2011, 05:17 am
por Иōҳ
tutorial crackme.exe
Ingeniería Inversa
mario86 4 13,265 Último mensaje 28 Diciembre 2016, 13:01 pm
por apuromafo CLS
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines