Bueno traigo acá un crackme del compañero yo mismo sencillito que me pareció bueno para traerlo acá a ver quien puede resolverlo. Si hay algún problema con que lo publique acá que el autor me diga y se remueve. Me parece que fue posteado originalmente en CPH y otras comunidades como h-sec.
Acerca:
Misión: Keygen válido y tutorial
Código fuente: Petición
Empaquetado: No
Dificultad: 1/10, Novatos
Lenguaje: C / NASM

Reglas:
-No SelfKeygen
-No parchear
-Desempaquetar
-Keygen válido
-Pasar el rato...

Próximamente versión para Linux.

Saludos
Descarga [Enlace externo eliminado para invitados]

Las reglas son claras, no parchear, en este crackme no tiene caso, la mision es programar un keygen, en caso de que no pueda que haga un tutorial de como sacar el serial correcto a ver quien lo resuelve cabe decir que para los que empezamos es un buen crackme tiene varias rutinas interesantes

Dejo el tutorial abajo, si aun quieres resolverlo pues no bajes mas la barra de desplazamiento D:
//mHmm..
Bueno... debido a el extenso número de comentarios interesados en resolver el crackme XDD dejo el keygen OJO como dije lo limite a usuarios de 6 caracteres xD igual basta cambiar unas lineas para hacerlo mas "genérico", y un tutorial de cómo resolverlo hecho por mí.
Imagen


keygen
[Enlace externo eliminado para invitados]


Tutorial
Bien, pues de una vez a hacer el tutorial, primero abrimos el archivo con peid, nada que lo empaquete, lo abrimos con olly, vemos moviendo un poco la barra de desplazamiento luego luego, dos llamadas a scanf (para recoger nuestro user y pass)

Imagen


Si nos fijamos bien hay un par de call's entre un scanf y otro, vamos poniendo un breakpoint justo despues del primer call a scanf, en mi caso lo puse en 0x401535, corremos el programa y ponemos cualquier user, caemos en el breakpoint y traceamos hasta el primer call despues de scanf en mi caso está en 0x4053E, vemos que es una simple rutina que cuenta la longitud del usuario (un strlen), al salir del call vemos que compara el tamaño con 6, y luego hace un salto si es menor a 6 o mayor a 10 me parece

Código: Seleccionar todo

0040153E  |. E8 4DFDFFFF    CALL CrackMe_.00401290
00401543  |. A3 88404000    MOV DWORD PTR DS:[404088],EAX
00401548  |. 3D 06000000    CMP EAX,6
0040154D  |. 0F82 AA010000  JB CrackMe_.004016FD
00401553  |. 3D 0A000000    CMP EAX,0A
00401558  |. 0F87 9F010000  JA CrackMe_.004016FD
Podemos deducir que nuestro user tiene que tener entre 6-10 caracteres, seguimos traceando y mas abajito encontramos otro call en mi caso 0x401563, si entramos en la rutina vemos que toma cada caracter y hace una comparación...

Código: Seleccionar todo

00401338  |. 8038 40        |CMP BYTE PTR DS:[EAX],40
0040133B  |. 7E 0D          |JLE SHORT CrackMe_.0040134A
0040133D  |. 8B45 08        |MOV EAX,DWORD PTR SS:[EBP+8]
00401340  |. 0345 FC        |ADD EAX,DWORD PTR SS:[EBP-4]
00401343  |. 8038 4B        |CMP BYTE PTR DS:[EAX],4B
00401346  |. 7F 02          |JG SHORT CrackMe_.0040134A

Salta si el caracter es menor a 0x40 o mayor a 0x4B deducimos que solo podemos ingresar caracteres de @ hasta K (que cagado no puedo escribir linkgl)... Proseguimos, volvemos a correr el programa si la cagamos al introducir un usuario que no cumpla con las condiciones que vamos diciendo, pasamos ya al scanf del password en 0X40158E, traceamos y nos topamos con una rutina...

Código: Seleccionar todo

0040159E  |> 8A81 10404000  /MOV AL,BYTE PTR DS:[ECX+404010]
004015A4  |. 50             |PUSH EAX
004015A5  |. E8 0AFDFFFF    |CALL CrackMe_.004012B4
004015AA  |. 35 4D000000    |XOR EAX,4D
004015AF  |. 8981 C8404000  |MOV DWORD PTR DS:[ECX+4040C8],EAX
004015B5  |. 41             |INC ECX
004015B6  |. 3B0D 88404000  |CMP ECX,DWORD PTR DS:[404088]
004015BC  |.^75 E0          \JNZ SHORT CrackMe_.0040159E

Vemos que toma de nuevo caracter por caracter del usuario (ojo que nuestro usuario esta guardado en 0x404010), luego hace un call, si entramos con F7 vemos que le resta 0x30 a su valor ascii y al salir del call le hace un xor 4D y guarda toda la cadena nueva en la direccion 4040C8, anotamos lo que hace, y la direccion y seguimos, justo abajito de esa rutina en las siguientes dos instrucciones nos encontramos con otra rutina mas... Bueno entramos en ella...

Código: Seleccionar todo

004015C4  |> 8A82 C8404000  /MOV AL,BYTE PTR DS:[EDX+4040C8]
004015CA  |. 50             |PUSH EAX
004015CB  |. E8 F8FCFFFF    |CALL CrackMe_.004012C8
004015D0  |. 4A             |DEC EDX
004015D1  |. 8882 48414000  |MOV BYTE PTR DS:[EDX+404148],AL
004015D7  |. 81FA 00000000  |CMP EDX,0
004015DD  |.^75 E5          \JNZ SHORT CrackMe_.004015C4


Vemos que toma de nuevo caracter por caracter esta vez de la cadena que acaba de "encriptar" restando 0x30 y haciendo xor 4D de el algoritmo anterior, y entrando en el call vemos como le hace un xor 4A, ojo que esta vez donde guarda la cadena 0x404148, la está metiendo de atrás hacia adelante, es decir 404149=caracter, luego pasa a 404148=caracter, es decir va decrementando y no incrementando, y por una razón que desconozco sera por que el xor lo hace al caracter nulo al principio en la primera vuelta del bucle del algoritmo ¿? coloca el caracter 4A (el mismo con el que hace el xor) al último, bueno hasta ahora no sabemos si es una encriptación yo por eso mejor anoto las direcciones xD y seguimos...

Más abajo en 4015DF, vemos que hace otro call pasando como parámetro esta vez la cadena que acaba de generar en el algoritmo anterior, entramos a ver que hace la rutina...

Código: Seleccionar todo

004012F0  |> 8B45 08        /MOV EAX,DWORD PTR SS:[EBP+8]
004012F3  |. 0345 FC        |ADD EAX,DWORD PTR SS:[EBP-4]
004012F6  |. 8038 00        |CMP BYTE PTR DS:[EAX],0
004012F9  |. 74 15          |JE SHORT CrackMe_.00401310
004012FB  |. 8B45 08        |MOV EAX,DWORD PTR SS:[EBP+8]
004012FE  |. 0345 FC        |ADD EAX,DWORD PTR SS:[EBP-4]
00401301  |. 0FBE10         |MOVSX EDX,BYTE PTR DS:[EAX]
00401304  |. 8D45 F8        |LEA EAX,DWORD PTR SS:[EBP-8]
00401307  |. 0110           |ADD DWORD PTR DS:[EAX],EDX
00401309  |. 8D45 FC        |LEA EAX,DWORD PTR SS:[EBP-4]
0040130C  |. FF00           |INC DWORD PTR DS:[EAX]
0040130E  |.^EB E0          \JMP SHORT CrackMe_.004012F0
00401310  |> 8B45 F8        MOV EAX,DWORD PTR SS:[EBP-8]
00401313  |. C9             LEAVE

Vale vamos viendo de aquí al parecer podemos deducir que va sumando todos los caracteres de la cadena en uno por ejemplo si yo introduje de usuario ABCDEF, se modifico en la primer rutina quedando 5C,5F,5E,59,58,5B, en la segunda se volvió a modificar quedando, 15,14,13,12,11,4A, en esta rutina suma los últimos caracteres en uno, es decir 15+14+13+12+11+4A=A9, guarden este numero, al parecer será importante... y bueno luego salimos del call... vemos que guarda todo en la misma dirección del último algoritmo...

Bien pues en la siguientes dos instrucciones despues de salir del call nos encontramos con...

Código: Seleccionar todo

004015F0  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
004015F7  |. E8 E0FCFFFF    CALL CrackMe_.004012DC
004015FC  |. A3 C8414000    MOV DWORD PTR DS:[4041C8],EAX


De nuevo es una llamada a la MISMA FUNCIÓN por lo que no volveré a entrar vemos desde aquí que toma el user como parametro y hace la llamda por lo que deducimos, que sumará de nuevo el user y en la siguiente instrucción se guardará en 4041c8, vamos comprobando, si sumamos 41+42+43+44+45+46=195 (todo en hex), pasamos la instruccion con F8 y vemos que en eax aparece nuestro número mágico 195, entonces bien guardamos lo vital como la direccion donde se guardó esto y seguimos...

Traceando abajito vemos que toma ambas sumas A9 y 0x195, las multiplica luego a ese resultado le hace un xor 1E240 y después le suma a eso de nuevo A9... aca lo vemos:

Código: Seleccionar todo

00401601  |. 8B15 48414000  MOV EDX,DWORD PTR DS:[404148]
00401607  |. A1 C8414000    MOV EAX,DWORD PTR DS:[4041C8]
0040160C  |. 0FAFD0         IMUL EDX,EAX
0040160F  |. 81F2 40E20100  XOR EDX,1E240
00401615  |. 01C2           ADD EDX,EAX

Si seguimos mas abajo vemos otra rutina...

Código: Seleccionar todo

0040161B  |> 3B1D 88404000  /CMP EBX,DWORD PTR DS:[404088]
00401621  |. 74 1A          |JE SHORT CrackMe_.0040163D
00401623  |. 8A83 4C404000  |MOV AL,BYTE PTR DS:[EBX+40404C]
00401629  |. 880424         |MOV BYTE PTR SS:[ESP],AL
0040162C  |. E8 83FCFFFF    |CALL CrackMe_.004012B4
00401631  |. 8883 C8424000  |MOV BYTE PTR DS:[EBX+4042C8],AL
00401637  |. 43             |INC EBX
00401638  |.^E9 DEFFFFFF    \JMP CrackMe_.0040161B

Bueno toma por caracteres el password, y compara a ebx que es 0 en ese momento, con la longitud del user si no me equivoco, eso no lo vi muy bien, despues hace un call, entramos al call y vemos que al caracter le resta 0x30 e incrementa despues EBX, por lo que deducimos de ahi que el password va a ser limite de 7 caracteres 0-6... O eso creemos hasta ahorita... Seguimos traceando al salir de la rutina...

Y después vemos como yo-mismo usa sus dotes de programador para desanimarnos porque COÑO como 12 call's seguidos...!

Código: Seleccionar todo

0040163D  |> C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
00401644  |. C74424 04 8840>MOV DWORD PTR SS:[ESP+4],CrackMe_.00404088
0040164C  |. E8 15FDFFFF    CALL CrackMe_.00401366
00401651  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
00401658  |. C74424 04 C842>MOV DWORD PTR SS:[ESP+4],CrackMe_.004042C8
00401660  |. E8 01FDFFFF    CALL CrackMe_.00401366
00401665  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
0040166C  |. C74424 04 4841>MOV DWORD PTR SS:[ESP+4],CrackMe_.00404148
00401674  |. E8 EDFCFFFF    CALL CrackMe_.00401366
00401679  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
00401680  |. C74424 04 C841>MOV DWORD PTR SS:[ESP+4],CrackMe_.004041C8
00401688  |. E8 D9FCFFFF    CALL CrackMe_.00401366
0040168D  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
00401694  |. C74424 04 4842>MOV DWORD PTR SS:[ESP+4],CrackMe_.00404248
0040169C  |. E8 C5FCFFFF    CALL CrackMe_.00401366
004016A1  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
004016A8  |. E8 66FDFFFF    CALL CrackMe_.00401413
004016AD  |. 50             PUSH EAX
004016AE  |. 68 60434000    PUSH CrackMe_.00404360
004016B3  |. E8 AEFCFFFF    CALL CrackMe_.00401366
004016B8  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
004016BF  |. E8 C1FDFFFF    CALL CrackMe_.00401485
004016C4  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
004016CB  |. C74424 04 6043>MOV DWORD PTR SS:[ESP+4],CrackMe_.00404360
004016D3  |. E8 8EFCFFFF    CALL CrackMe_.00401366
004016D8  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010    ;  ASCII "ABCDEF"
004016DF  |. E8 ACFBFFFF    CALL CrackMe_.00401290
004016E4  |. A3 48434000    MOV DWORD PTR DS:[404348],EAX
004016E9  |. C70424 4C40400>MOV DWORD PTR SS:[ESP],CrackMe_.0040404C    ;  ASCII "asdf123"
004016F0  |. E8 9BFBFFFF    CALL CrackMe_.00401290
004016F5  |. 3905 48434000  CMP DWORD PTR DS:[404348],EAX
004016FB  |. 74 13          JE SHORT CrackMe_.00401710
004016FD  |> C9             LEAVE
004016FE  |. C3             RETN

pero alto, vemos que la mayoría de estos apuntan a la misma dirección por lo que una vez sabiendo que hace esa rara función 401366, podríamos deducir lo demás, asi que procedemos con las primeras lineas, mueve 404010 y 404088 que son el user y la longitud del user, y hace la llamada, entramos en la rutina y vemos lo siguiente...

Código: Seleccionar todo

0040136C  |. 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]
0040136F  |. 8945 F8        MOV DWORD PTR SS:[EBP-8],EAX
00401372  |> 8B45 F8        /MOV EAX,DWORD PTR SS:[EBP-8]              
00401375  |. 8038 00        |CMP BYTE PTR DS:[EAX],0
00401378  |. 74 07          |JE SHORT CrackMe_.00401381
0040137A  |. 8D45 F8        |LEA EAX,DWORD PTR SS:[EBP-8]
0040137D  |. FF00           |INC DWORD PTR DS:[EAX]
0040137F  |.^EB F1          \JMP SHORT CrackMe_.00401372
00401381  |> C745 FC 000000>MOV DWORD PTR SS:[EBP-4],0
00401388  |> 8B45 0C        /MOV EAX,DWORD PTR SS:[EBP+C]
0040138B  |. 0345 FC        |ADD EAX,DWORD PTR SS:[EBP-4]
0040138E  |. 8038 00        |CMP BYTE PTR DS:[EAX],0
00401391  |. 74 1C          |JE SHORT CrackMe_.004013AF
00401393  |. 8B45 F8        |MOV EAX,DWORD PTR SS:[EBP-8]
00401396  |. 8B4D FC        |MOV ECX,DWORD PTR SS:[EBP-4]
00401399  |. 01C1           |ADD ECX,EAX
0040139B  |. 8B45 FC        |MOV EAX,DWORD PTR SS:[EBP-4]
0040139E  |. 89C2           |MOV EDX,EAX
004013A0  |. 0355 0C        |ADD EDX,DWORD PTR SS:[EBP+C]
004013A3  |. 8D45 FC        |LEA EAX,DWORD PTR SS:[EBP-4]
004013A6  |. FF00           |INC DWORD PTR DS:[EAX]
004013A8  |. 0FB602         |MOVZX EAX,BYTE PTR DS:[EDX]
004013AB  |. 8801           |MOV BYTE PTR DS:[ECX],AL
004013AD  |.^EB D9          \JMP SHORT CrackMe_.00401388
004013AF  |> 8B45 F8        MOV EAX,DWORD PTR SS:[EBP-8]
004013B2  |. 0345 FC        ADD EAX,DWORD PTR SS:[EBP-4]
004013B5  |. C600 00        MOV BYTE PTR DS:[EAX],0
004013B8  |. 8B45 08        MOV EAX,DWORD PTR SS:[EBP+8]
004013BB  |. C9             LEAVE

Bueno... hasta este punto yo ya estaba medio arto, sin embargo al seguir traceando y entrar en el primer bucle podemos deducir que está buscando la dirección siguiente al user (404010), que esté vacía hasta encontrar un espacio vacío, vamos como que va a concactenar algo despues de nuestro user :S, y efectivamente entramos en el segundo bucle vemos como en la posicion 404016 ingresa un caracter más, cual? pues la longitud de nuestro user (6), por lo que quedaría en la memoria algo como esto:

404010=41 (A)
404011=42 (B)
404012=43 (C)
404013=44 (D)
404014=45 (E)
404015=46 (F)
404016=06

Bueno es básicamente lo que hace ahi, entonces salimos del call y vamos a ver las siguientes llamadas a la misma funcion aver si podemos deducir que sucede, como sabemos el primer parametro fue 404010 por lo que el primer parametro debe ser la direccion en donde se partira para concactenar mas caracteres, y el segundo parametro seran esos caracteres a pegar ahi xD entonces checamos los call's que nos faltan que son iguales:

Código: Seleccionar todo

00401651  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010
00401658  |. C74424 04 C842>MOV DWORD PTR SS:[ESP+4],CrackMe_.004042C8
00401660  |. E8 01FDFFFF    CALL CrackMe_.00401366
00401665  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010
0040166C  |. C74424 04 4841>MOV DWORD PTR SS:[ESP+4],CrackMe_.00404148
00401674  |. E8 EDFCFFFF    CALL CrackMe_.00401366
00401679  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010
00401680  |. C74424 04 C841>MOV DWORD PTR SS:[ESP+4],CrackMe_.004041C8
00401688  |. E8 D9FCFFFF    CALL CrackMe_.00401366
0040168D  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010
00401694  |. C74424 04 4842>MOV DWORD PTR SS:[ESP+4],CrackMe_.00404248
0040169C  |. E8 C5FCFFFF    CALL CrackMe_.00401366

En el primero si guardamos bien las direcciones que sacamos anteriormente 404010 sabemos que es donde se van a "pegar" los caracteres, y vemos que en 40402C8 está nuestro password cuando le restaron 30x al parecer, entonces deducimos
ABCDEF6PASSWORD (ojo cada letra del password le aplicaron sub 0x30)

En la siguiente llamada mete como segundo parametro no se si les suena pero esa direccion es donde se guardo la suma que resultaba A9 y la siguiente es la suma que daba 0x195, y la ultima de esa no tenia la direccion ¿?, al entrar en el call de nuevo veo que no concactena nada, quizá para añadir un caracter nulo ¿? la verdad no lo sé y a este punto no quiero saberlo, en fin... Entonces todo nos queda así:
ABCDEF6PASSA9951 (pongo 951 y no 195 porque se introduce byte por byte es decir 0x0195 se mete 95 luego 01) o así está en este crackme...

Bueno... salimos del ultimo call identico para entrar en uno diferente que esta abajito:

Código: Seleccionar todo

004016A1  |. C70424 1040400>MOV DWORD PTR SS:[ESP],CrackMe_.00404010
004016A8  |. E8 66FDFFFF    CALL CrackMe_.00401413

Vemos que mete la dirección de la cadena que se concateno, es como funcionan los punteros si estas familiarizado con C, acá se ve claramente el uso de los punteros xD... Bueno entramos en el call y al parecer es donde ya alfin se genera despues de tantos algoritmos el password...

Código: Seleccionar todo

00401420  |. C785 F4EFFFFF >MOV DWORD PTR SS:[EBP-100C],0
0040142A  |> 8B45 08        /MOV EAX,DWORD PTR SS:[EBP+8]               ; ||
0040142D  |. 0385 F4EFFFFF  |ADD EAX,DWORD PTR SS:[EBP-100C]            ; ||
00401433  |. 8038 00        |CMP BYTE PTR DS:[EAX],0                    ; ||
00401436  |. 74 46          |JE SHORT CrackMe_.0040147E                 ; ||
00401438  |. 8B45 08        |MOV EAX,DWORD PTR SS:[EBP+8]               ; ||
0040143B  |. 0385 F4EFFFFF  |ADD EAX,DWORD PTR SS:[EBP-100C]            ; ||
00401441  |. 0FBE00         |MOVSX EAX,BYTE PTR DS:[EAX]                ; ||
00401444  |. 894424 08      |MOV DWORD PTR SS:[ESP+8],EAX               ; ||
00401448  |. C74424 04 0330>|MOV DWORD PTR SS:[ESP+4],CrackMe_.00403003 ; ||ASCII "%d"
00401450  |. 8D85 F8EFFFFF  |LEA EAX,DWORD PTR SS:[EBP-1008]            ; ||
00401456  |. 890424         |MOV DWORD PTR SS:[ESP],EAX                 ; ||
00401459  |. E8 22070000    |CALL <JMP.&msvcrt.sprintf>                 ; |\sprintf
0040145E  |. 8D85 F8EFFFFF  |LEA EAX,DWORD PTR SS:[EBP-1008]            ; |
00401464  |. 894424 04      |MOV DWORD PTR SS:[ESP+4],EAX               ; |
00401468  |. C70424 A044400>|MOV DWORD PTR SS:[ESP],CrackMe_.004044A0   ; |
0040146F  |. E8 FC060000    |CALL <JMP.&msvcrt.strcat>                  ; \strcat
00401474  |. 8D85 F4EFFFFF  |LEA EAX,DWORD PTR SS:[EBP-100C]
0040147A  |. FF00           |INC DWORD PTR DS:[EAX]
0040147C  |.^EB AC          \JMP SHORT CrackMe_.0040142A
0040147E  |> B8 A0444000    MOV EAX,CrackMe_.004044A0
00401483  |. C9             LEAVE
00401484  \. C3             RETN

Que hace ahi?, vemos que separa caracter por caracter toda la cadena que generó anteriormente y le aplica formato con sprintf, vemos que usa el parámetro %d, por lo que todo al parecer quedará hecho números xD, pasa todos los caracteres, quedando masomenos asi
ABCDEF6PASSA9951->656667686970numeros_dependiendo_elpaass-87-1071

ahora porque -87 y -1071 porque el A9 (si te salio igual que ami porque pusiste igual ABCDEF como usuario) lo pasa a FFFFFFA9 en el movsx, y el 95 igual FFFFFF95 y el 1 lo pasa igual y esos numeros en hex son negativos xD, y así sería la forma en que genera el serial apartir del user y pass, puedes comprobarlo modificando en el olly el pwd que pusiste por ese antes de que haga la comparación que esta despuecito y te dará el goodboy, entonces ya no es necesario ver los demás call's

La programación del keygen una vez sabiendo esto se vuelve sencilla, yo me atoré en dos partes...
1.- Cómo pasar de 95 a FFFFFF95 en un lenguaje que no sea ASM xD
2.- Cómo evitar que cambie el serial dependiendo el pass...

Yo lo hice de la siguiente manera (lo hice de 6 caracteres únicamente para no liarme y publicar más rápido esto que lo tengo pendiente desde hace días) entonces para la programacion del key solo pides el user lo conviertes a ascii
ABCDEF
656667686970 le haces un strlen al user y lo concactenas
6566676869706, aca para no liarte calculando que pwd podría dar lo resolví concactenando el usuario de nuevo hasta el caracter 7, y se van los problemas quedando
6566676869706656667
después tienes que hacer los algoritmos
1.- valor_letra_user xor 4D
letra_del_xor xor 4A
sumas todos los valores
2.- sumas el valor de todos los caracteres del user

ambos los pasas a hex y les restas 0x100 para que te de el negativo y voilá, me olvidaba ANTES hice una función para dividir un entero en grupos de dos para el 195 y no liarme a bajo nivel, entonces haciendo modulo (%) 100 y dividiendo después entre 100 sacas los grupos, una vez que tieness el 95 entonces si le aplicas la resta, y despues agregas el ultimo grupo de pares (el 1)
6566676869706656667-87-1071

Saludos
//mHmm..
Bello te quedo bien, xD y mas con tu forma e compartir el tuto, m egusto el estilo que usaste!

Edito:

Código: Seleccionar todo

770DF64B      BF FCF60D77     MOV EDI,OFFSET ntdll.770DF6FC            ; ASCII "TppTimerpStopCallbackGeneration"

770DF650      BE B8270377     MOV ESI,OFFSET ntdll.770327B8            ; ASCII "d:\win7sp1_gdr\minkernel\threadpool\ntdll\timer.c"
WTF, °_° alguien me puede explicar para que funciona...
1337 & culture!
Pues ahí estas trabajando con la ntdll tal vez, si observas la dirección en memoria en la que estas, NO es la del programa que estas debuggeando en sí, debiste caer ahí gracias a un call quizá, tal vez, porque el 99% de los programas se cargan en 400000 (imagebase), si estas resolviendo un crackme dudo que sea relevante esa parte, son procedimientos que quizá necesite una api, o algo así no puedo decirlo con seguridad si no veo más instrucciones, ahí nomas mueve las strings que vienen ahí a EDI y ESI, igual que alguien más experto nos ilumiine
//mHmm..
Responder

Volver a “Manuales”