Retos Septiembre 2012 Mes De Crackers
Hola amigos asi como dise el hilo mes de reversear un poco, a un que yo queria empesarlo el dia primero de cada mes pero mientras seme ocurria y le pedia permiso al moderador, haremos una excepción bueno.
Cada mes pondre crackmes asi que el que quiera participar que partisipe abra del nivel 1, 2 y 3 para empezar y si quieren aumentar la dificultad la aumentamos o pedirme packers
Reglas:
1-No es obligado hacer tutoriales pero si lo quieren hacer aganlos para que aprendan los nuevos
2-Describir brevemente como logro crackearlo y mostrar la clave si es crackme o la clave para su nick si es keygenme
Para el primer mes que es este hay crackmes del nivel 1 y 2
cyclone
http://www.mediafire.com/?6ucbk6rbz6aeep1 (http://www.mediafire.com/?6ucbk6rbz6aeep1)
FuelVM-Keygenme
http://www.mediafire.com/?ozpbmlp8g3o2z1m (http://www.mediafire.com/?ozpbmlp8g3o2z1m)
MusicalCrackme
http://www.mediafire.com/?pl9mngk2co5rr8v (http://www.mediafire.com/?pl9mngk2co5rr8v)
SerialMe
http://www.mediafire.com/?1b778y7i81inp6b (http://www.mediafire.com/?1b778y7i81inp6b)
Simple_KGM_2
http://www.mediafire.com/?7po55bp57zfltop (http://www.mediafire.com/?7po55bp57zfltop)
los resultados como claves y seriales que se muestren aqui en este hilo como tambien las dudas y preguntas.
Bueno hay estan y que se diviertan
Saludos Flamer
Flamer cyclone vencido, gracias por la colecta de los crackmes , el método antidebug de este no sé ni cual es, porque el olly no se me cierra , he usado el 2.01 , en cuanto a un tute pues pequeño tute:
1.Abrimos el crackme con el Olly , pulsamos F9 y caemos en el entry point del programa.
Estudio del crackme.
-Luego de pedir el serial , saca a este mismo de la memoria y lo rota 11 veces a la derecha.
MOV EAX,DWORD PTR DS:[4030BC]
ROR EAX,11
MOV EBX,554F0000
CMP EAX,EBX
-Después lo compara con 554F0000.
Por lo que deducimos que si:
ROR x,11 = 554F0000
Donde x es el serial que metemos ,despejamos, la inversa de ror , es rol por lo que queda esto:
x = ROL 554F0000,11
x = 0000AA9E que es igual a 43678 en decimal.
¡Un saludo!
hola avesudra te dire cual es el otro fasil para que no te desanimes si no puedes con los demas
es el MusicalCrackme
se le tiene que hacer keygen el cual es fasil
saludos flamer
Hola Flamer.
SerialMe vencido.
Muy facil si se parchea y un poco lioso si vas a buscar el keygen ya que hace un sinfin de operaciones que al final siempre se acaban comparando con
8x@rtr25 en la direccion 401209
Saludos y felicitaciones por esta magnifica idea
hola tinki si parchando en la direccion
0040120F . /75 1E JNZ SHORT SerialMe.0040122F
por
0040120F . /75 1E Je SHORT SerialMe.00401219
y queda listo
poniendo asi un serial de 8 digitos ya que el crackme pide 8 sino te manda al cartel incorrecto
saludos
Hola Flamer , ya estaba con ese crame >:D , bueno ya está vencido, un pequeño tute.
1.Abrimos el programa con el Olly , buscamos las APIS a ver que hay de interesante... ummm GetDlgItemInt ... para que será? jeje , ponemos el breakpoint en las dos.
2.Bien , ejecutamos el programa dando F9 , ponemos nuestro ID , y el serial , y presionamos registrar.
3. Aleluya! , caemos en donde coge los seriales... Seguimos mirando , y coge mi ID , y lo mete en ebx, despues coge mi serial y lo mete en ECX...
4. Entramos al call , ese que hay ahí abajo , está muy claro , al serial , le suma 4C , lo incrementa en uno , le añade 38B , se añade a sí mismo , se multiplica por trés y se le resta uno.
5. Salimos del call y vemos una comparación de ebx con eax , ¿con eax? , si.. yo también me extrañé , pero es que al coger el serial en el ultimo GetDlgItemInt, devolvió su valor en eax , lo movió a ecx , pero no borró eax, por lo tanto está comparando nuestro serial original , con las operaciones que le ha hecho a nuestro ID.
Pues listo! Armemos nuestro keygen en ASM que estoy practicando jeje:
TITLE keygen (keygen.asm)
.386 ; Hace el código compatible con el procesador 386
.MODEL flat,stdcall
INCLUDE user32.inc
INCLUDE kernel32.inc
INCLUDE msvcrt.inc
INCLUDELIB user32.lib
INCLUDELIB kernel32.lib
INCLUDELIB msvcrt.lib
;PARA TENER LOS BUFFERS
__p__iob PROTO C
_iobuf STRUCT
_ptr DWORD ?
_cnt DWORD ?
_base DWORD ?
_flag DWORD ?
_file DWORD ?
_charbuf DWORD ?
_bufsiz DWORD ?
_tmpfname DWORD ?
_iobuf ENDS
FILE TYPEDEF _iobuf
;PROTOTIPOS DE FUNCIONES EN C
EXTRN fgets:NEAR
EXTRN sscanf:NEAR
EXTRN getchar:NEAR
EXTRN printf:NEAR
EXTRN strlen:NEAR
;PROTOTIPOS DE FUNCIONES EN ASM
.data ;Datos del programa
MSG_ID BYTE "Ingrese su ID(maximo 4 digitos):",0
MSG_KEY BYTE "Su serial es: %d",0Ah,0Dh,0
PULSE_TECLA BYTE "Pulse intro para salir . . .",0
;ESPECIFICADORES DE FORMATO
ESPI BYTE "%d",0
ESPS BYTE "%s",0
.data?
ID DWORD ?
SERIAL DWORD ?
BUFFER_FGETS DWORD ?
stdin DWORD ?
stdout DWORD ?
stderr DWORD ?
.code ;Código del programa
main PROC
;Buffers
call __p__iob
mov stdin,eax ; #define stdin (&__iob_func()[0])
add eax,SIZEOF(FILE)
mov stdout,eax ; #define stdout (&__iob_func()[1])
add eax,SIZEOF(FILE)
mov stderr,eax ; #define stderr (&__iob_func()[2])
;Inicio código.
push OFFSET MSG_ID
push OFFSET ESPS
call printf
;COGEMOS DEL BUFFER DIEZ CARÁCTERES POR SI LAS MOSCAS.
push stdin
push 10
push OFFSET BUFFER_FGETS
call fgets
;COGEMOS EL ID DEL BUFFER DE FGETS CON SSCANF
push OFFSET ID
push OFFSET ESPI
push OFFSET BUFFER_FGETS
call sscanf
;;;;;;;;;;;;;;;;;;;;;;;;
;CREACIÓN DEL SERIAL ;
;;;;;;;;;;;;;;;;;;;;;;;;
mov ebx ,ID ;
add ebx,4Ch ;
inc ebx ;
add ebx,38Bh ;
add ebx,ebx ;
imul ebx,3 ;
dec ebx ;
;;;;;;;;;;;;;;;;;;;;;;;;
;IMPRIMIMOS SERIAL
push ebx
push OFFSET MSG_KEY
call printf
;IMPRIMIMOS PARA AVISAR
push OFFSET PULSE_TECLA
push OFFSET ESPS
call printf
;CUANDO PULSE INTRO CERRAMOS
call getchar
invoke ExitProcess,0
ret
main endp
END main
Y no podía abandonar a mi querido C , uff , que liviano se me hace al ASM:
#include <stdio.h>
#include <stdlib.h>
int main()
{
char * buffer_fgets = malloc(10);
int ID;
int serial;
printf("Ingresa el ID (4 caracteres maximo):");
fgets(buffer_fgets,6,stdin);
sscanf(buffer_fgets,"%d",&ID);
serial=ID;
//Rutina de creación.
serial+=76;//4c en hex
++serial;
serial+=907;//38b en hex
serial+=serial;
serial*=3;
--serial;
printf("Tu serial es: %d \n",serial);
printf("Presione intro para terminar . . .");
getchar();
return 0;
}
Felisidades avesudra me sorprendiastes hasta en masm lo hisistes
yo tambien estoy practicando masm a ratos cuando puedo pero seme hizo mas fasil hacerlo en vb6
saludos flamer y felisitaciones los demas si estan un poco complicados
Cita de: Flamer en 14 Septiembre 2012, 03:38 AM
Felisidades avesudra me sorprendiastes hasta en masm lo hisistes
yo tambien estoy practicando masm a ratos cuando puedo pero seme hizo mas fasil hacerlo en vb6
saludos flamer y felisitaciones los demas si estan un poco complicados
Si bueno no estoy acostumbrado a hacer crackmes pero los fáciles me mata la curiosidad jajaja , ya que estoy aprendiendo no viene mal , aunque también lo he puesto en C , es normal que para hacer estas cosas recurramos a lenguajes de más alto nivel. Voy a intentar mirar el SerialMe.
¡Un saludo!
Si pones unpacking me puedo animar :P
Cita de: Иōҳ en 14 Septiembre 2012, 04:48 AM
Si pones unpacking me puedo animar :P
ya esta nox para el mes que sigue que es octubre subo 2
para los demas usuarios pidanme el nivel que quieran y los subo, solo puse estos fasiles para empezar y tambien por que estamos a 14 de Septiembre
el siguiente sera el 1 de octubre
saludos Flamer
Hola estoy intentado el simple_KGM , pero es muy complicado , tengo la primera parte ya pasada , es así:
1. Abrimos el simple_KGM y buscamos las apis en el olly , umm GetDlgItemInt y dos GetDlgItemText , bueno pongamos los breakpoints.
2. Coge nuestro ID, y mira si eax es 0 (eax en ese momento es el largo del nombre) , si es 0 va al chico malo,si nó, le resta 0D4h y lo guarda en la memoria [404674]
3. Coge nuestro serial y mira si eax es 0(eax en ese momento es el largo del serial),si es 0 va al chico malo, si nó, lo guarda en [404678]
4. Coge nuestro nombre y mira si eax es 4, si es mas bajo , chico malo, si nó, mira si eax es 20, si es más grande chico malo... De aquí deducimos que nuestro nombre debe tener entre 4 y 20 carácteres , ni más ni menos.Una vez hecho esto va cogiendo cada byte de nuestro nombre y le hace estas operaciones:
MOV EDI,EAX
XOR EDX,EDX
XOR ESI,ESI
MOV ECX,1
LOOP:
INC EDX
MOVZX EAX,BYTE PTR DS:[EDX+4042D3]
CMP EDX,EDI
XOR EDX,EDX
ADD EAX,ESI
SHL EAX,4
ADD EAX,10001
PUSH EAX ; /Arg1
CALL 00401283 ; \Simple_KGM_2.00401283
ADD ESI,EAX
INC ECX
CMP ECX,20
JNE LOOP
El call que hay ahí en medio:
PUSH EBP ; Simple_KGM_2.00401283(guessed Arg1)
MOV EBP,ESP
PUSH ECX
MOV EAX,DWORD PTR SS:[ARG.1]
MOV ECX,666
CICLO:
ADD EAX,68656865
ROR EAX,8
SUB EAX,65686568
ROL EAX,16
MOV EBX,EAX
NOT EAX
SUB EBX,EAX
ADC EAX,EBX
ROR EAX,6
LOOP CICLO
ADD EAX,61733376
XOR EAX,76337361
NOP
NOP
NOP
NOP
NOP
NOP
NOP
AND EAX,0000FFFF
SHL EAX,10
MOV AX,0DEAD
SUB EAX,D00EA00D
POP ECX
LEAVE
RETN 4
Después del loop , compara el resultado de todas las operaciones con [404674] , adivinad quien había en la posición de memoria, el valor de nuestro ID -04Dh ,con lo que si hacemos un keygen para eso tendriamos que pedir el nombre , hacer las rutinas de calculo para el ID , y sumarle 04Dh , ya que cuando lo metemos en el programa se lo resta.
Hasta ahí bien , he hecho mitad del keygen para eso, nos pide el nombre y el te calcula el ID:
.386 ; Hace el código compatible con el procesador 386
.MODEL flat,stdcall
INCLUDE user32.inc
INCLUDE kernel32.inc
INCLUDE msvcrt.inc
INCLUDELIB user32.lib
INCLUDELIB kernel32.lib
INCLUDELIB msvcrt.lib
;PARA TENER LOS BUFFERS
__p__iob PROTO C
_iobuf STRUCT
_ptr DWORD ?
_cnt DWORD ?
_base DWORD ?
_flag DWORD ?
_file DWORD ?
_charbuf DWORD ?
_bufsiz DWORD ?
_tmpfname DWORD ?
_iobuf ENDS
FILE TYPEDEF _iobuf
;PROTOTIPOS DE FUNCIONES EN C
EXTRN printf:NEAR
EXTRN fgets:NEAR
EXTRN sscanf:NEAR
EXTRN getchar:NEAR
EXTRN strlen:NEAR
;PROTOTIPOS DE FUNCIONES EN ASM
.data ;Datos del programa
INGRESA_NOMBRE BYTE "Ingresa tu nombre: ",0
TU_ID_ES BYTE "Tu ID es: %u",0Ah,0Dh,0
PULSE_TECLA BYTE "Pulse intro para terminar . . .",0
;ESPECIFICADORES DE FORMATO
ESPI BYTE "%d",0
ESPS BYTE "%s",0
ESPIU BYTE "%u",0
.data?
NOMBRE BYTE 20 DUP (0)
ID DWORD ?
BUFFER_FGETS BYTE 20 DUP(0)
stdin DWORD ?
stdout DWORD ?
stderr DWORD ?
.code
rutinaSerial PROC
PUSH EBP
MOV EBP,ESP
PUSH ECX
MOV EAX,[EBP+8]
MOV ECX,666h
CICLO:
ADD EAX,68656865h
ROR EAX,8h
SUB EAX,65686568h
ROL EAX,16h
MOV EBX,EAX
NOT EAX
SUB EBX,EAX
ADC EAX,EBX
ROR EAX,6h
LOOP CICLO
ADD EAX,61733376h
XOR EAX,76337361h
AND EAX,0000FFFFh
SHL EAX,10h
MOV AX,0DEADh
SUB EAX,0D00EA00Dh
POP ECX
leave
ret
rutinaSerial endp
.code ;Código del programa
main PROC
;Buffers
call __p__iob
mov stdin,eax ; #define stdin (&__iob_func()[0])
add eax,SIZEOF(FILE)
mov stdout,eax ; #define stdout (&__iob_func()[1])
add eax,SIZEOF(FILE)
mov stderr,eax ; #define stderr (&__iob_func()[2])
;Inicio código.
push OFFSET INGRESA_NOMBRE
push OFFSET ESPS
call printf
push stdin
push 20
push OFFSET BUFFER_FGETS
call fgets
push OFFSET NOMBRE
push OFFSET ESPS
push OFFSET BUFFER_FGETS
call sscanf
push OFFSET NOMBRE
call strlen
MOV EDI,EAX
XOR EDX,EDX
XOR ESI,ESI
MOV ECX,1
L1:
INC EDX
MOVZX EAX,NOMBRE[EDX-1]
CMP EDX,EDI
JNE L2
XOR EDX,EDX
L2:
ADD EAX,ESI
SHL EAX,4h
ADD EAX,10001h
PUSH EAX
CALL rutinaSerial
ADD ESI,EAX
INC ECX
CMP ECX,20h
JNE L1
add eax,0D4h
mov ID,EAX
push ID
push OFFSET TU_ID_ES
call printf
push OFFSET PULSE_TECLA
push OFFSET ESPS
call printf
call getchar
invoke ExitProcess,0
ret
main endp
END main
Despues , lo que hace es con wsprintf , pasa lo que hay en eax , o sea nuestro ID , a una cadena en notación hexadecimal, y seguidamente , hay una rutina en la que hacen operaciones con un valor que no es constante :(!!! , cambia , y ese valor lo cogen con lo que retorna la api , VirtualAlloc pasandole estos parámetros, pero es que siempre da un valor diferente , y para hacer un keygen como sé cual es ese valor?
Pongo las rutinas que decía:
CPU Disasm
Address Hex dump Command Comments
004011AA |. 50 PUSH EAX ; /<%08X>
004011AB |. 68 16404000 PUSH OFFSET 00404016 ; |Format = "%08X"
004011B0 |. 68 F4454000 PUSH OFFSET 004045F4 ; |Buf
004011B5 |. E8 1A010000 CALL <JMP.&user32.wsprintfA> ; \USER32.wsprintfA
004011BA |. 83C4 0C ADD ESP,0C
004011BD |. FF35 3E404000 PUSH DWORD PTR DS:[40403E] ; /Arg3 = 290000
004011C3 |. 6A 10 PUSH 10 ; |Arg2 = 10
004011C5 |. 68 F4424000 PUSH OFFSET 004042F4 ; |Arg1 = ASCII "12345"
004011CA |. E8 F4020000 CALL 004014C3 ; \Simple_KGM_2.004014C3
Y los parametros que se le pasan a la api:
Address Hex dump Command Comments
00401326 |. 6A 04 PUSH 4 ; /Protect = PAGE_READWRITE
00401328 |. 68 00100000 PUSH 1000 ; |AllocType = MEM_COMMIT
0040132D |. 6A 54 PUSH 54 ; |Size = 84.
0040132F |. 6A 00 PUSH 0 ; |Address = NULL
00401331 |. E8 30110000 CALL <JMP.&kernel32.VirtualAlloc> ; \KERNEL32.VirtualAlloc
Bueno no hay problema , la cogeré con virtualprotect o algo de eso.
fuelVM keygenme nivel extremadamente analítico
,tutorial de asolot lo cito:
http://ricardonarvaja.info/WEB/CONCURSOS%202011/CONCURSO%2012/CLS_12_11_FuelVM%20v0.1%20crackme%20by%20asOlOt.rar
datos
Name:apuromafo
serial:aFVPVLO@F@
El tutorial de asOlOt es impresionante, más la tool que programó en asm, joder yo me quedé weon cuando lo leí en su momento... Un verdadero maestro, si señor!
Saludos,
Nox.
Pues yo me he lanzado a por el MusicalCrackme....
Tengo el Keygen hecho en ASM32, y es un poco bestia ponerlo entero si alguien está interesado lo posteo , pero básicamente el resumen sería este
00401125 . 68 EC030000 PUSH 3EC
0040112A . FF75 08 PUSH DWORD PTR SS:[EBP+8]
0040112D . E8 D8000000 CALL 0040120A ; Aquí calcula nuestro Personal ID
00401132 . 8BD8 MOV EBX,EAX
00401134 . 33C0 XOR EAX,EAX
00401136 . 6A 01 PUSH 1
00401138 . 6A 00 PUSH 0
0040113A . 68 ED030000 PUSH 3ED
0040113F . FF75 08 PUSH DWORD PTR SS:[EBP+8]
00401142 . E8 C3000000 CALL 0040120A ; Aquí calcula nuestro serial
00401147 . 8BC8 MOV ECX,EAX
00401149 . E8 4DFFFFFF CALL 0040109B ; Aquí opera con nuestroi personal ID para ver si coincide con el serial
0040114E 3BC3 CMP EAX,EBX ; Los compara
00401150 . 74 0C JE SHORT 0040115E ; Si somos buenos salta
Es decir coge nuestro Personal ID opera con él... coge nuestro serial opera con él..
Esta llamada calcula el serial correcto a partir de nuestro ID personal
00401149 . E8 4DFFFFFF CALL 0040109B
0040114E 3BC3 CMP EAX,EBX
00401150 . 74 0C JE SHORT 0040115E
Rutina que calcula el serial correcto
0040109B /$ 83C3 4C ADD EBX,4C ; Le suma 4C a nuestro ID PERSONAL modificado
0040109E |. 83C2 03 ADD EDX,3
004010A1 |. 43 INC EBX ; Incrementa en uno el cálculo
004010A2 |. 81C3 8B030000 ADD EBX,38B ; Le suma 38B
004010A8 |. 03DB ADD EBX,EBX ; Se suma a si mismo
004010AA |. 0FAFDA IMUL EBX,EDX ; Multiplica el resultado por EDX (3)
004010AD |. 4B DEC EBX ; Resta 1
004010AE \. C3 RETN ; El resultado queda en EBX
Mi ID PErosnal 1234 el serial es 13307 ... y a escuchar música ;-)
PD. muy buenos los crackmes....
Cita de: apuromafo en 14 Septiembre 2012, 15:38 PM
fuelVM keygenme nivel extremadamente analítico
,tutorial de asolot lo cito:
http://ricardonarvaja.info/WEB/CONCURSOS%202011/CONCURSO%2012/CLS_12_11_FuelVM%20v0.1%20crackme%20by%20asOlOt.rar
datos
Name:apuromafo
serial:aFVPVLO@F@
uff creo que seme paso la mano con ese y no sabia que ricardo lo habia puesto como reto me disculpo por ese error
Hola Nop+ eres bueno para ser nuevo te digo por que es tu primer mensage Felisidades y sigue asi
espero seguirte viendo por aca
saludos Flamer
Lo siento no sé hacer el keygen del simple_KGM 2 , consigo hacer que genere mi ID a partir de mi nombre (el programa que dejé en masm arriba), pero de ahí , coge y hace operaciones raras cogiendo los Valores que devuelve VirtualAlloc , bueno ahí tienen mi registro:
nombre : avesudra
ID : 396312436
Serial : 76989F4C3CFD8061
PD : He mirado en crackmes.de ahora para ver que era , y el serial es un cifrado RSA de 64 bits, ahí lo dejo
¡Un saludo!
pero el intento le hisistes es lo que cuenta para aprender
saludos sigue asi
Cyclone CrackMe :
Tutorial :
Ya sabes, solo explicare como obtener el Hardcode :
Bueno primero analizemos Iniciemos, ingresemos cualquier numero : 787878
Obviamente nos dice "ERROR : Wrong code" pues vamos ya tenemos varios datos.
Nuestro serial (:
Chico Malo
Iniciemos el ollydbg y lo cargamos :
COMENZEMOS
------------------
Por eso el codigo es muy pequeño ...
Bueno a simple vista vemos un "CMP EAX, EBX"
Dependiendo de esto nos mostrara el mensaje Chico bueno o Malo.
Ademas, se activaran varios Flags..
Ok vamos a la direccion 401026 : CALL scanf
Ese call lo que hace es guardar en una variable determinada "En este caso 4030BC"
o podria ser asi :
#include <stdio.h>
int EAX, EBX;
printf("El serial : ");
scanf("%d", &EAX); //Guarda en EAX lo ingresado..
Seguidamente el programa añade 8 a ESP despues mueve "a EAX " nuestro serial : 787878
Recuerda que tiene que ser un valor entero (int).
Despues hace un ROR EAX, 11 ; Rota 11 veces EAX.
// seguimos el code
int i = 0;
for (i = 0; i < 11; i++) ;
Despues hace un mov EBX, 554F0000 ;
EBX = 554F0000
DESPUES la comparacion para encontrar el serial hacemos lo siguiente :
Clic derecho en CMP EAX, EBX y le damos assemble :
y escribimos
ROL ; Como dijo avesudra la inversa de ROR
ROL EBX, 11 ;
Ejecutamos la linea con F8 y miramos el registro EBX.
Nos como resultado : 0000AA9E , pasado a decimal : 43678 -> nuestro querido hardcode.
Espero que me entiendan un poco, no soy de tutoriales :P
Saludos !!!
:silbar:
Keygen para keygen musical
es el crackme mas fácil, el tute ya lo hizo Nop+
Dim Serie, ID As Long
ID = Int(9999 * Rnd + 1)
TexTID.Text = ID
Serie = ID + 984
Serie = Serie * 2
Serie = Serie * 3
Serie = Serie - 1
TexTSerie.Text = Serie
hola FaQuiVer bienvenido En hora buena Felisidades por el logro asi como alos demas que an partisipado
Nota: como la ven si les pongo los fasiles con el algoritmo mas larguito bueno
Cita de: avesudra en 15 Septiembre 2012, 03:09 AM
Lo siento no sé hacer el keygen del simple_KGM 2 , consigo hacer que genere mi ID a partir de mi nombre (el programa que dejé en masm arriba), pero de ahí , coge y hace operaciones raras cogiendo los Valores que devuelve VirtualAlloc , bueno ahí tienen mi registro:
nombre : avesudra
ID : 396312436
Serial : 76989F4C3CFD8061
PD : He mirado en crackmes.de ahora para ver que era , y el serial es un cifrado RSA de 64 bits, ahí lo dejo
¡Un saludo!
Hola avesudra lee estado hechando un ojo sabes como escribir en el campo ID ala primera o si alguno sabe
Si flamer por ahí en el tercer post mio detras de este , hay un keygen para el id , basicamente lo que hace es que tu metes el nombre hace unas operaciones y compara con el id que metes menos 4Dh que se lo resta al guardarlo en memoria.Por lo tanto:
Metemos el nombre -> hacemos todas las operaciones que hay antes de comparar y cuando tengos ese valor le sumamos 4Dh para que cuando lo metamos otra vez quede igual ,lo que no entiendo es el algoritmo de cifrado para el serial...
Olbida la pregunta anterior es un error mio queria escribir letras en el campo ID y solo acepta numeros jajajaja ;D ;D
Bueno con respecto a la creacion del keygen seven claramente las operaciones del algoritmo boy acalalo aver si logro hacerlo
saludos Flamer
Vale vale jajajaja ,hace unas cosas muy raras después de comprobar el ID hay 4 calls y al final acaba sacando una cadena cifrada con RSA en 64 bits.
para Flamer el ID=4092673908
el keygenme esta difisil para mi ya que el ID debe de ser igual al valor generado con el nombre y igual al valor generado con el serial
a lo que boy es que hay dos zonas de comparacion la primera donde compara el ID (el mio 4092673908 por ejemplo) por el valor generado con el nombre hay esta bien
004011A2 |. 3905 74464000 CMP DWORD PTR DS:[404674],EAX
004011A8 |. 75 67 JNZ SHORT Simple_K.00401211
luego ase unas operaciones con el serial que ingreso y lo compara con el valor del ID
004011FE |. 68 F4434000 PUSH Simple_K.004043F4 ; /String2 = "0"
00401203 |. 68 F4454000 PUSH Simple_K.004045F4 ; |String1 = "F3F13EA0"
00401208 |. E8 03010000 CALL <JMP.&kernel32.lstrcmpA> ; \lstrcmpA
esta difisil
busque aver si tenia un bug poniendo 0 en el campo serial y poniendo 212 en el campo ID con esto la segunda comparacion se cumple pero la primera no
osea que el autor del crackme tapo el bug ya que no hay ningun nombre que me diera 0 ya que solo podemos ingresar nombres con 4 digitos en adelante
saludos Flamer