Mensajes

[EDIT]

EDIT:Link reparado

Adjunto un .doc

http://www.mediafire.com/?tlj5u42r5zys5zk

Saludos

[Tutorial Crackme edu]

Tutorial Crackme edu

Nombre:Crackme edu
Dificultad:1-2
Compilador:Visual Basic
Autor del crack:$Edu$

Cargamos el crackme desde OllyDBG, Notamos claramente que es un Visual Basic 6.0:


Veamos las API'S que utiliza el crackme (Ctrl+N):


Notaremos dos API'S muy interesantes coloquemos BP'S en ellas:




La primera se encarga de comparar string's y la segunda se encarga de obtener el número de caracteres de una string, las veremos más detalladamente a continuación mientras vayamos desarrollando el tutorial

Iniciamos el crackme (F9) e introducimos ID,SERIAL y luego verificar:


Vemos que se detiene en la API __vbaStrCmp:




Llegamos hasta la call __vbaStrComp, si nos fijamos en el stack podremos ver la comparación que se va a realizar (arg2 con arg3) notaremos que comprueba el serial falso con 0, por lo que lo más probable es que esté comprobando que si es que NO introdujimos algún valor.(para ver los datos que compara debemos hacer click derecho en alguno de los dos argumentos y seleccionar follow in dump):



Pasando la call __vbaStrComp y estando detenidos en RETN 8 veremos que EAX=1 por lo que deducimos que la API __vbaStrCmp retornará 1 si es que los string comparados no son iguales:



Luego mueve el valor de EAX a EDX y luego de algunas operaciones toma el EDX(1)y lo mueve dentro de [EBP-E4]  :


Ahora realizará los mismos pasos pero con la string ID:




Compara 0 con la ID que introdujimos esto devolverá 1 al retornar de la CALL:


una vez realizada las mismas operaciones mueve respectivamente ambos valores obtenidos de las llamadas a __vbaStrCmp (Ambos retornaron 1) a EAX y ECX:



realizando un TEST EAX,ECX:

Sabemos que la única forma de que no se active el flag Z (para que salte) es que EAX y ECX sean 1 con lo cual contamos de manera correcta

Si no se cumpliera nos mostrará un mensaje diciendo que debemos ingresar los datos


Si continuamos traceando el programa hará un llamado a la API __vbaLenBstr:


retornando la call EAX contiene el número de caracteres del serial que en este caso son 4 (serial falso:1234):


Continuando se llamará nuevamente a la API:

en esta nos retornará el valor 5 ya que UND3R contiene 5 caracteres

Luego se realiza una comparación entre EAX y ECX en donde EAX es el largo de la ID y ECX el largo del serial, notaremos que si no se realiza el salto obtendremos como resultado que el serial es incorrecto, para que pueda saltar el serial no puede ser mayor(más largo) que el ID en este caso cumplimos con el requisito:


Luego de esto no creo que se utilice nuevamente la API __vbaLenBstr debido a que ya se ha calculado el largo que hemos ingresado tanto del serial y del ID por lo que lo borraremos:


Ahora si damos nuevamente F9 se detiene en la API __vbaStrCmp:


si pusheamos hasta el call __vbaStrComp y miramos el stack notaremos que se está comparando 1 con Z, siendo 1 el primer digito que introdujimos en el serial falso:






Retornando de la API EAX toma el valor de FFFFFFFF y este es movido a ESI para luego pasar por un TEST SI,SI


:
en donde la única forma de que no salte es que ESI=0, por lo que podemos colocar un BP en el salto JNZ e introducir como serial Z234 o modificar el flag Z para que no salte ya que si salta notaremos se dirigirá a la string "Serial incorrecto"

Si seguimos traceando llegaremos a la siguiente address:

previamente vemos una comparación que es 1 con 3 en donde saltará si lo que está en DI sea mayor a 3, si vemos hacia donde salta notaremos que es hacia el cartel de que el serial es correcto, aquí veo un posible pequeño bug en la programación del crackme ya lo comentaré

[EBP-D0]:


Si seguimos traceando sin alterar el salto que nos dirige al cartel de serial correcto llegaremos hasta la siguiente address:


Si bajamos un poco notaremos un salto que anteriormente habíamos pasado por el, lo más probable es que tengamos a continuación la manera de como el crackme obtuvo la letra Z como respuesta correcta para el primer carácter del serial. obviamente en este caso obtendremos el valor del segundo carácter correcto:


Lleguemos hasta la siguiente address:


Aquí notamos algo muy interesante si miramos el registro y el OP-Code del address en donde estamos detenidos:


Sabemos que ECX apunta a nuestro ID, aquí moverá a DX el valor de ECX+2 por lo que moverá el segundo carácter a DX que en este caso es una N:




Quedando EDX con de la siguiente manera:


luego a EDX le suma 5, una vez sumado mueve a EAX el valor de DX y lo pushea para la API __vbaStrCmp:


luego llega nuevamente a una comprobación que es la misma en la que nos detuvimos cuando se comparó 1 con Z:


si vemos en el stack notaremos la comparación entre nuestro segundo caracter del serial con S:






Por lo que ya contamos con la fórmula y de alguna manera el entendimiento de como trabaja el crackme

Resumimos:
-verifica que ambas cajas de textos no estén vacías
-luego verifica que el SERIAL introducido no sea mayor a la ID
-luego toma el primer carácter del serial y le suma 5
-compara el resultado del primer carácter+5 con el primer carácter del serial
-luego continua sucesivamente con un contador que es hasta el tercer carácter
-Cumpliéndose los 3 primeros caracteres obtendremos el cartel de serial correcto

Aquí el problema de $Edu$, quizás es intencional pero la comprobación es solo hasta el tercer carácter por lo que podríamos colocar tan solo 3 caracteres este sería el pequeño bug del crackme

UND3R
U=55+5=Z
N=4e+5=S
D=44+5=I
3=3+5=8
R=52+5=W

Otra forma de crackearlo es nopear el salto que viene a continuación de la comparación del serial ya que si recordamos $Edu$ colocó un contador que si se pasa por el por tercera vez es considerado el serial como correcto:





Saludos a $Edu$

EDIT:
Adjunto el keygen hecho en OllyScript:

Código (asm) [Seleccionar] Expandir

VAR CONT
VAR VMEMORY
VAR SIZE
VAR AUX
VAR RESP
PREG:
ASK "Introduzca su ID"
MOV RESP,$RESULT
LEN RESP
MOV SIZE,$RESULT
ALLOC 100
MOV VMEMORY,$RESULT
MOV VMEMORY2,VMEMORY
CMP VMEMORY,0
JE ERROR1
MOV [VMEMORY],RESP
OPERACION:
CMP CONT,SIZE
JE EXIT
MOV AUX,[VMEMORY],1
ADD AUX,5
MOV [VMEMORY],AUX,1
INC VMEMORY
INC CONT
JMP OPERACION
ERROR:
MSG "Debe ingresar un serial"
JMP PREG
ERROR1:
MSG "Error inesperado"
RET
EXIT:
MOV AUX,[VMEMORY2], SIZE
BUF AUX
STR AUX
EVAL "ID:{RESP} SERIAL:{AUX}"
MSG $RESULT
FREE VMEMORY2
RET

[A B]

pues eso, como puedo ir adicionando valores me explico

tengo 3 valores

A B y C

como puedo hacer para que una variable vaya adicionando esos 3 valores

VAR AUX

que AUX sea A luego AB y luego ABC

No sé si se entienda bien mi duda jeje

Saludos y gracias

[GREFF]

Pues eso, algo así como GREFF existirá algún comando que tome valores de un txt o mejor todavía del log

Saludos

[ID:]

Estos scripts que haces, es ASM no? y necesitaria un compilador para ejecutar codigo en ASM no? o se guarda con alguna extension?esto lo pregunto para yo saber, porque pienso que en realidad este script se pondra en algun lugar del Olly para luego ser interpretado por el no?

No es ASM, se usa OllyScript que es un plugins encargado de leer script's

PD: tu crackme ID:UND3R PASS:ZSI8

luego el tute jeje

Saludos

Hola Flamer:
Los tutoriales por pequeños que sean siempre son bienvenidos.

Saludos tambien a .:UND3R:., te encontrabamos a faltar.

saludos

Estoy de vacaciones y en donde estoy no hay internet, pero de todas maneras sigo trabajando de manera interna ahora realizaré los tutoriales que prometí saludos

Está publicado Saludos

[Versión V1.2]

Versión V1.2
¿Para que sirve?
-Si tenemos un programa trial podremos lanzar el script, luego caducarlo (cambiar la fecha) e ejecutar el script nuevamente, luego de eso comparamos y obtendremos el salto que nos bloquea el acceso al programa.
-Si dumpeamos un programa y tiene detección CRC podemos realizar los pasos comentados anteriormente y obtendremos el salto CRC.
-Si tenemos un serial verdadero podemos obtener el salto que nos considera el serial como válido.

Mejoras:
-Reparado error con 2 opciones activadas al mismo tiempo (filtro bucle con  detenerse en address específico, generaban un error que ya está solucionado)
-Log tipo de salto(idea de tinkipinki)
-Anterior versión solo logeaba saltos SHORT, ahora logea JMP NEAR
-Optimizado el código: V1.0=367 lineas V1.2=309 lineas (incluyendo las opciones adicionales)
-Filtrar los saltos SHORT
EDIT:tenía un pequeño error el código cuando lo subí, ahora está editado y funciona correctamente.

Imágenes:










Código de la versión 1.2:

Código (asm) [Seleccionar] Expandir

/*
   -=================================================================-

       Script realizado por :UND3R                                      
       Script para : Logear saltos condicionales                                              
       Configuracion: Saltar todas las excepciones y no tener ningún BP                                              
       Fecha : 12/10/2011                                          

                   -=[ Comentario del Script ]=-                    
    Ideal para logear todo tipo de saltos condicionales para posteriormente                                                              
    compararlo con otro log con el fin de localizar saltos mágicos                                                                

   -=================================================================-
*/
VAR AUX_EXIT
VAR T_F_N_LOG
VAR CONT_LOG_N
VAR FILTRO
VAR VEIP
VAR RESP
VAR N_LOGTXT
VAR LOG_SALTO
VAR VMEMORY
VAR VMEMORY2
VAR VMEMORY3
VAR AUX_TS
VAR TIPO_SALTO
VAR AUX_TS2
VAR LOG_BUCLE1
VAR LOG_BUCLE2
VAR COMP
VAR VEIP2
VAR MAX
VAR MIN
VAR CONT_LOG_N2
VAR CANTI_LOG_SAVE
VAR COMPROBAR_SALTO
VAR SI_NO
VAR VAR_EIP
VAR CONT_JUMP
VAR LOG_TIPO_SALTO
VAR ANTIBUCLE2
VAR ANTIBUCLE1
VAR N_BUCLE1
VAR CONT
VAR INF_BUCLE2
VAR INF_BUCLE1
VAR INF_BUCLE
VAR VEIP_2
VAR FILTRAR_JMP_SHORT
ASK "Introduzca el nombre del archivo a crear EJ: LOG1.TXT"
MOV N_LOGTXT,$RESULT
EVAL "{N_LOGTXT}"
WRT $RESULT, "|N:   |ADDRESS:|EIP:    |SALTA: |BUCLE: |TIPO SALTO:|"
WRTA $RESULT, "|---------------------------------------------------|"  
PREG_FILTRO:
MSGYN "¿Opciones avanzadas?"
CMP 1,$RESULT
JE AVANZADO
TRACE:
TICND "byte [EIP] > 6F && byte [EIP] < 80 || byte [EIP+1] > 7F && byte [EIP+1] < 90 && byte [EIP]==0F"
CMP RESP,eip
JE EXIT1
OPCODE eip
MOV LOG_SALTO,$RESULT_1
ALLOC 50
MOV VMEMORY,$RESULT
MOV [VMEMORY],LOG_SALTO
MOV VMEMORY2,VMEMORY
ADD VMEMORY2,2
BUCLE_TS:
CMP [VMEMORY2],20,1
JNE INC_VMEMORY2
MOV VMEMORY3,VMEMORY2
COMP_SHORT:
INC VMEMORY3
MOV AUX_TS,[VMEMORY3],5
CMP AUX_TS,"SHORT"
JE SALTO_TIPO1
SALTO_TIPO2:
SUB VMEMORY2,VMEMORY
MOV TIPO_SALTO,[VMEMORY],VMEMORY2
STR TIPO_SALTO
FREE VMEMORY
JMP TRACE0
SALTO_TIPO1:
ADD VMEMORY3,5
MOV AUX_TS2,[VMEMORY3],1
CMP AUX_TS2,2E
JE SALTO_TIPO2
SUB VMEMORY3,VMEMORY
MOV TIPO_SALTO,[VMEMORY],VMEMORY3
LOG TIPO_SALTO
FREE VMEMORY
CMP FILTRAR_JMP_SHORT,1
JE TRACE
JMP TRACE0
INC_VMEMORY2:
INC VMEMORY2
JMP BUCLE_TS
TRACE0:
CMP eip,VEIP
JE CONT_BUCLE
MOV LOG_BUCLE1,0
MOV LOG_BUCLE2,0
TRACE1:
OPCODE eip
MOV VEIP,eip
MOV VEIP2,VEIP
ADD VEIP2,$RESULT_2
STI
CMP FILTRO,1
JNZ TRACE2
CMP eip,MAX
JA TRACE2
CMP eip,MIN
JAE TRACE
TRACE2:
CMP LOG_BUCLE1,1
JNE TRACE3
MOV LOG_BUCLE2,"!"
TRACE3:
INC CONT_LOG_N
ITOA CONT_LOG_N, 10.
MOV CONT_LOG_N2,$RESULT
CMP T_F_N_LOG,1
JNE TRACE4
CMP CONT_LOG_N2,CANTI_LOG_SAVE
JE EXIT2
TRACE4:
CMP VEIP2,eip
JE NO
SI:
MOV COMPROBAR_SALTO,1
MOV SI_NO,"SI"
JMP LOG_COMPR_TXT
NO:
MOV COMPROBAR_SALTO,0
MOV SI_NO,"NO"
LOG_COMPR_TXT:
EVAL "|{CONT_LOG_N2}"
MOV CONT_LOG_N2,$RESULT
LOG_COMPR_TXT_:
LEN CONT_LOG_N2
CMP $RESULT,6
JNE INC_LOG_COMPR_TXT
ADD CONT_LOG_N2,"|"
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_LOG_N2
LOG_CMPR_TXT2:
EVAL "{VEIP}"
MOV VEIP_2,$RESULT
LOG_CMPR_TXT2_:
LEN VEIP_2
CMP $RESULT,8
JNE INC_LOG_CMPR_TXT2
ADD VEIP_2,"|"
EVAL "{N_LOGTXT}"
WRTA $RESULT,VEIP_2,""
LOG_CMPR_TXT3:
EVAL "{eip}"
MOV VAR_EIP,$RESULT
LOG_CMPR_TXT3_:
LEN VAR_EIP
CMP $RESULT,8
JNE INC_LOG_CMPR_TXT3
ADD VAR_EIP,"|"
EVAL "{N_LOGTXT}"
WRTA $RESULT,VAR_EIP,""
LOG_CMPR_TXT4:
EVAL "{SI_NO}     |{LOG_BUCLE2}      |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
CMPR_LEN_TS:
LEN TIPO_SALTO
CMP $RESULT,B
JNE INC_LEN_TS
EVAL "{TIPO_SALTO}|"
MOV LOG_TIPO_SALTO,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,LOG_TIPO_SALTO,""
CMP AUX_EXIT,1
JE LOG_COMPR_TXT2
JMP TRACE
LOG_COMPR_TXT2:
JMP EXIT
STOP:
BPHWS RESP, "x"
JMP FILTRO
EXIT1:
BPHWC RESP
EXIT:
EVAL "{N_LOGTXT}"
WRTA $RESULT,"`---------------------------------------------------´"
ret
EXIT2:
MOV AUX_EXIT,1
JMP TRACE4
AVANZADO:
MSGYN "¿Detener en Nº cantidad de datos logeados?"
CMP 0,$RESULT
JE AVANZADO2
N_LOG_SAVE:
ASK "Introduzca número de datos a logear:"
MOV CANTI_LOG_SAVE,$RESULT
ITOA CANTI_LOG_SAVE
MOV CANTI_LOG_SAVE,$RESULT
MOV T_F_N_LOG,1
JMP FILTRO
AVANZADO2:
MSGYN "¿Detener log en address determinado?"
CMP 0,$RESULT
JE FILTRO
BP_ADDRESS:
ASK "Introduzca la dirección en donde desea detener el log"
MOV RESP,$RESULT
CMP RESP,0
JNE STOP
FILTRO:
MSGYN "¿Excluir en el log rango de address?"
CMP 0,$RESULT
JE FILTRO_JMP
FILTRO2:
MOV FILTRO,1
ASK "Introduzca el rango a excluir,desde:"
MOV MIN,$RESULT
ASK "hasta:"
MOV MAX,$RESULT
FILTRO_JMP:
MSGYN "¿Excluir saltos SHORT?"
CMP 0,$RESULT
JE ANTIBUCLE
MOV FILTRAR_JMP_SHORT,1
ANTIBUCLE:
MSGYN "¿Log inteligente (evita bucle's)?"
CMP 0,$RESULT
JE OLLYH
ANTIBUCLE2:
MOV ANTIBUCLE1,1
ASK "Nº de veces que debe repetirse un salto para ser considerado bucle"
MOV N_BUCLE1,$RESULT
OLLYH:
MSGYN "¿Ocultar OllyDBG mientras se ejecuta el script?"
CMP $RESULT,0
JE GOTRACE
DBH
GOTRACE:
JMP TRACE
CONT_BUCLE:
INC CONT
MOV LOG_BUCLE1,1
CMP CONT,N_BUCLE1
JE SALTAR_BUCLE
JMP TRACE1
SALTAR_BUCLE:
CMP COMPROBAR_SALTO,0
JE NO_SALTA_BUCLE
SI_SALTA_BUCLE:
MOV INF_BUCLE2,VEIP2
JMP BUCLE2
NO_SALTA_BUCLE:
MOV INF_BUCLE,VEIP
ADD INF_BUCLE,1
MOV INF_BUCLE,[INF_BUCLE],1
MOV INF_BUCLE2,eip
ADD INF_BUCLE2,INF_BUCLE
ADD INF_BUCLE2,2
CMP INF_BUCLE,7F
JBE BUCLE2
SUB INF_BUCLE2,100
BUCLE2:
EVAL "|----[{VEIP}]-¡BUCLE ENCONTRADO!------------------"
MOV CONT_JUMP,$RESULT
BUCLE2_:
LEN CONT_JUMP
CMP $RESULT,34
JNE INC_BUCLE2
ADD CONT_JUMP,"|"
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
BUCLE_CONT_:
BP INF_BUCLE2
RUN
CMP INF_BUCLE2,eip
JNE ERROR1
BC INF_BUCLE2
MOV CONT,0
MOV LOG_BUCLE1,0
MOV LOG_BUCLE2,0
JMP TRACE
INC_LEN_TS:
ADD TIPO_SALTO," "
JMP CMPR_LEN_TS
INC_BUCLE2:
ADD CONT_JUMP,"-"
JMP BUCLE2_
INC_LOG_CMPR_TXT3:
ADD VAR_EIP," "
JMP LOG_CMPR_TXT3_
INC_LOG_CMPR_TXT2:
ADD VEIP_2," "
JMP LOG_CMPR_TXT2_
INC_LOG_COMPR_TXT:
ADD CONT_LOG_N2," "
JMP LOG_COMPR_TXT_
ERROR1:
MSG "Error inesperado #1"
RET




Versión V1.0
Este script como el título lo dice se encarga de logear todos los diferentes tipos de saltos condicionales hasta un cierto punto especificado por el usuario y los guarda en un documento de texto (archivo log) indicando el address en donde estaba el salto,si se realizó el salto o no y si se realizó indica hacia donde salto, esto puede ser útil para encontrar comprobaciones CRC, antidump de tamaño o detección de si el programa está siendo ejecutado bajo una máquina virtual, la idea es generar dos log
EJ: archivo desempaqueta=Log1 archivo empaquetado=Log2, ambos detenidos en el OEP, de esta forma con algún comparador de textos podremos ver que salto tienen de diferencia siendo este el posible causante de las detecciones mencionadas anteriormente.

Imágen de logs:



Nº=el número de log, este es el que se debe especificar dentro de las opciones si se quiere detener en N cantidad de log especificado.

ADDRESS=Indica en donde está el salto encontrado

EIP=Indica la ubicación luego de que se ejecutó el salto

BUCLE=!: indica que se está repitiendo un salto
          0:Indica que NO se está repitiendo el salto

SALTA: SI/NO este es la acción más importante del script



*En esta imagen muestra la detección de un bucle, para evitar que se repita en el log, con la opción de log inteligente en vez de ver los address repetidos, veremos una alerta


-Nombre del .txt:
El script en primera instancia nos preguntará con que nombre queremos guardar el log

-Opciones avanzadas:
Si no optamos por esta opción el script comenzará a logear todos

-Detener en Nº cantidad de datos logeados:
Esta opción nos da la posibilidad de que el script se detenga en una cierta cantidad de números de registro.

-Detener en un determinado address:
Si queremos detener el script en un cierto address

-Excluir en el log rango de address:
Nos da la posibilidad de poder excluir un rango de address, estas no serán mostradas en el log, ideal para excluir los saltos de las API'S si elegimos esta opción nos preguntara desde donde queremos que excluya y hasta que address

-Log inteligente:
esta opción evita bucles ideal para evitar tener repetidos datos en el log que pueden estorbar la comparación, si elegimos esta opción nos preguntará cuantas veces debe pasar el programa por un mismo salto para que sea considerado bucle
*Recomendación:4
*Actualmente no considera como bucle en donde un salto salta a otro salto
-Ocultar OllyDBG mientras se ejecuta el script:
esta opción habilita el comando DBGH

SCRIPT:

Código (asm) [Seleccionar] Expandir

/*
   -=================================================================-
                                               
       Script realizado por :UND3R                                      
       Script para : Logear saltos condicionales                                              
       Configuracion: Saltar todas las excepciones y no tener ningún BP                                              
       Fecha : 12/10/2011                                          
                                                                   
                   -=[ Comentario del Script ]=-                    
    Ideal para logear todo tipo de saltos condicionales para posteriormente                                                              
    compararlo con otro log con el fin de localizar saltos mágicos                                                                
                                                                   
   -=================================================================-
*/
VAR INFO_N4
VAR STR_4
VAR STR_2
VAR STR_1
VAR INFO_N3
VAR INFO_N2
VAR INFO_N
VAR CONT_LOG_N2
VAR AUX_EXIT
VAR T_F_N_LOG
VAR CANTI_LOG_SAVE
VAR CONT_LOG_N
VAR SI_NO
VAR CONT_JUMP
VAR N_LOGTXT
VAR LOG_BUCLE2
VAR LOG_BUCLE1
VAR COMPROBAR_SALTO
VAR INF_BUCLE2
VAR INF_BUCLE
VAR N_BUCLE1
VAR CONT
VAR ANTIBUCLE1
VAR FILTRO
VAR MIN
VAR MAX
VAR COMP
VAR RESP
VAR VEIP2
VAR VEIP
ASK "Introduzca el nombre del archivo a crear EJ: LOG1.TXT"
MOV N_LOGTXT,$RESULT
EVAL "{N_LOGTXT}"
WRT $RESULT, "|N:   |ADDRESS:|EIP:    |BUCLE: |SALTA: |"
WRTA $RESULT, "|---------------------------------------|"  
PREG_FILTRO:
MSGYN "¿Opciones avanzadas?"
CMP 1,$RESULT
JE AVANZADO
TRACE:
TICND "byte [EIP] > 6F && byte [EIP] < 80"
CMP RESP,eip
JE EXIT1
CMP eip,VEIP
JE CONT_BUCLE
MOV LOG_BUCLE1,0
MOV LOG_BUCLE2,0
TRACE1:
MOV COMP,[eip],1
CMP COMP,70
JB TRACE
CMP COMP,7F
JA TRACE
OPCODE eip
MOV VEIP,eip
MOV VEIP2,VEIP
ADD VEIP2,$RESULT_2
STI
CMP FILTRO,1
JNZ TRACE2
CMP eip,MAX
JA TRACE2
CMP eip,MIN
JAE TRACE
TRACE2:
CMP LOG_BUCLE1,1
JNE TRACE3
MOV LOG_BUCLE2,"!"
TRACE3:
INC CONT_LOG_N
ITOA CONT_LOG_N, 10.
MOV CONT_LOG_N2,$RESULT
CMP T_F_N_LOG,1
JNE TRACE4
CMP CONT_LOG_N2,CANTI_LOG_SAVE
JE EXIT2
TRACE4:
CMP VEIP2,eip
JE NO
SI:
MOV COMPROBAR_SALTO,1
MOV SI_NO,"SI"
JMP LOG_COMPR_TXT
NO:
MOV COMPROBAR_SALTO,0
MOV SI_NO,"NO"
LOG_COMPR_TXT:
LEN CONT_LOG_N2
MOV INFO_N,$RESULT
CMP INFO_N,1
JE LOG_CMPR_TXT_1
CMP INFO_N,2
JE LOG_CMPR_TXT_2
CMP INFO_N,3
JE LOG_CMPR_TXT_3
CMP INFO_N,4
JE LOG_CMPR_TXT_4
CMP INFO_N,5
JE LOG_CMPR_TXT__5
JMP ERROR2
LOG_CMPR_TXT_1:
EVAL "|{CONT_LOG_N2}    |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
JMP LOG_CMPR_TXT2
LOG_CMPR_TXT_2:
EVAL "|{CONT_LOG_N2}   |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
JMP LOG_CMPR_TXT2
LOG_CMPR_TXT_3:
EVAL "|{CONT_LOG_N2}  |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
JMP LOG_CMPR_TXT2
LOG_CMPR_TXT_4:
EVAL "|{CONT_LOG_N2} |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
JMP LOG_CMPR_TXT2
LOG_CMPR_TXT__5:
EVAL "|{CONT_LOG_N2}|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
LOG_CMPR_TXT2:
ITOA VEIP
MOV STR_1,$RESULT
LEN STR_1
MOV INFO_N2,$RESULT
CMP INFO_N2,5
JE LOG_CMPR_TXT_5
CMP INFO_N2,6
JE LOG_CMPR_TXT_6
CMP INFO_N2,7
JE LOG_CMPR_TXT_7
CMP INFO_N2,8
JE LOG_CMPR_TXT_8
JMP ERROR3
LOG_CMPR_TXT_5:
EVAL "{VEIP}   |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
JMP LOG_CMPR_TXT3
LOG_CMPR_TXT_6:
EVAL "{VEIP}  |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
JMP LOG_CMPR_TXT3
LOG_CMPR_TXT_7:
EVAL "{VEIP} |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
JMP LOG_CMPR_TXT3
LOG_CMPR_TXT_8:
EVAL "{VEIP}|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
LOG_CMPR_TXT3:
ITOA eip
MOV STR_2,$RESULT
LEN STR_2
MOV INFO_N3,$RESULT
CMP INFO_N3,5
JE LOG_CMPR_TXT2_5
CMP INFO_N3,6
JE LOG_CMPR_TXT2_6
CMP INFO_N3,7
JE LOG_CMPR_TXT2_7
CMP INFO_N3,8
JE LOG_CMPR_TXT2_8
JMP ERROR4
LOG_CMPR_TXT2_5:
EVAL "{eip}   |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
JMP LOG_CMPR_TXT4
LOG_CMPR_TXT2_6:
EVAL "{eip}  |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
JMP LOG_CMPR_TXT4
LOG_CMPR_TXT2_7:
EVAL "{eip} |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
JMP LOG_CMPR_TXT4
LOG_CMPR_TXT2_8:
EVAL "{eip}|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
LOG_CMPR_TXT4:
EVAL "{LOG_BUCLE2}      |{SI_NO}     |"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP,""
CMP AUX_EXIT,1
JE LOG_COMPR_TXT2
JMP TRACE
LOG_COMPR_TXT2:
JMP EXIT
STOP:
BPHWS RESP, "x"
JMP FILTRO
EXIT1:
BPHWC RESP
EXIT:
EVAL "{N_LOGTXT}"
WRTA $RESULT,"`---------------------------------------´"
ret
EXIT2:
MOV AUX_EXIT,1
JMP TRACE4
AVANZADO:
MSGYN "¿Detener en Nº cantidad de datos logeados?"
CMP 0,$RESULT
JE AVANZADO2
N_LOG_SAVE:
ASK "Introduzca número de datos a logear:"
MOV CANTI_LOG_SAVE,$RESULT
ITOA CANTI_LOG_SAVE
MOV CANTI_LOG_SAVE,$RESULT
MOV T_F_N_LOG,1
JMP FILTRO
AVANZADO2:
MSGYN "¿Detener log en address determinado?"
CMP 0,$RESULT
JE FILTRO
BP_ADDRESS:
ASK "Introduzca la dirección en donde desea detener el log"
MOV RESP,$RESULT
CMP RESP,0
JNE STOP
FILTRO:
MSGYN "¿Excluir en el log rango de address?"
CMP 0,$RESULT
JE ANTIBUCLE
FILTRO2:
MOV FILTRO,1
ASK "Introduzca el rango a excluir,desde:"
MOV MIN,$RESULT
ASK "hasta:"
MOV MAX,$RESULT
ANTIBUCLE:
MSGYN "¿Log inteligente (evita bucle's)?"
CMP 0,$RESULT
JE OLLYH
ANTIBUCLE2:
MOV ANTIBUCLE1,1
ASK "Nº de veces que debe repetirse un salto para ser considerado bucle"
MOV N_BUCLE1,$RESULT
OLLYH:
MSGYN "¿Ocultar OllyDBG mientras se ejecuta el script?"
CMP $RESULT,0
JE GOTRACE
DBH
GOTRACE:
JMP TRACE
CONT_BUCLE:
INC CONT
MOV LOG_BUCLE1,1
CMP CONT,N_BUCLE1
JE SALTAR_BUCLE
JMP TRACE1
SALTAR_BUCLE:
CMP COMPROBAR_SALTO,0
JE NO_SALTA_BUCLE
SI_SALTA_BUCLE:
MOV INF_BUCLE2,VEIP2
JMP BUCLE2
NO_SALTA_BUCLE:
MOV INF_BUCLE,VEIP
ADD INF_BUCLE,1
MOV INF_BUCLE,[INF_BUCLE],1
MOV INF_BUCLE2,eip
ADD INF_BUCLE2,INF_BUCLE
ADD INF_BUCLE2,2
CMP INF_BUCLE,7F
JBE BUCLE2
SUB INF_BUCLE2,100
BUCLE2:
ITOA VEIP
MOV STR_4,$RESULT
LEN STR_4
MOV INFO_N4,$RESULT
CMP INFO_N4,5
JE BUCLE_5
CMP INFO_N4,6
JE BUCLE_6
CMP INFO_N4,7
JE BUCLE_7
CMP INFO_N4,8
JE BUCLE_8
BUCLE_5:
EVAL "|----[{VEIP}]-¡BUCLE ENCONTRADO!---------|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
JMP BUCLE_CONT_
BUCLE_6:
EVAL "|----[{VEIP}]-¡BUCLE ENCONTRADO!--------|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
BP INF_BUCLE2
JMP BUCLE_CONT_
BUCLE_7:
EVAL "|----[{VEIP}]-¡BUCLE ENCONTRADO!-------|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
JMP BUCLE_CONT_
BUCLE_8:
EVAL "|----[{VEIP}]-¡BUCLE ENCONTRADO!------|"
MOV CONT_JUMP,$RESULT
EVAL "{N_LOGTXT}"
WRTA $RESULT,CONT_JUMP
BUCLE_CONT_:
BP INF_BUCLE2
EOB COMPROBAR
RUN
COMPROBAR:
CMP INF_BUCLE2,eip
JNE ERROR1
BC INF_BUCLE2
MOV CONT,0
MOV LOG_BUCLE1,0
MOV LOG_BUCLE2,0
JMP TRACE
ERROR1:
MSG "Error inesperado #1"
RET
ERROR2:
MSG "Los datos registrados exceden la cantidad máxima permitida"
RET
ERROR3:
MSG "Error inesperado #2"
RET
ERROR4:
MSG "Error inesperado #3"
RET

Si no lo entendieron bien, les pido que lo utilicen y notarán que no es nada complicado de entender.

Saludos UND3R

PD: otra funcionalidad puede ser encontrar el salto decisivo de un programa teniendo un serial correcto.

Para eso debes debuggear y entender el lenguaje "chino" que comentabas, es decir verificar si se intenta conectar a algún servidor externo ya que debe hacerlo de alguna manera para que otra persona pueda recoger los datos de tu cuenta, con un firewall podrías filtrar la conexión que genera el ejectuable o también utilizar wireshark entre otros

Saludos

comparte el archivo y quizas t pueda dar una mano! Saludos

+1 sabiendo que el código está completo lo más probable es que se deba nopear algún salto, esperamos el ejecutable, saludos