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

Saludos

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:

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

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

Eso, he encontrado listas de los tipos de saltos, pero sin su valor hexadecimal, si alguien me ayudará estaría muy agradecido, saludos

Introducción al cracking en P-Code parte 2

En esta segunda parte le daremos énfasis al programa WKTVBDE, realizaremos una serie de crackmes de manera sencilla y aprenderemos a nopear en P-Code

I-Clave2.exe

Abrimos WKTVBDE y vemos lo siguiente:


Seleccionamos File->Open y elegimos clave2.exe si cargó sin ningún problema nos debería aparecer lo siguiente:


Seleccionamos Action->Run y Nos aparecerán dos alertas, estas deben ser aceptadas rapidamente ya que el debugger crashea:




Si todo ha salido bien, Nos aparecerá clave2 y debajo de el podremos ver el debugger sin ningún P-Code:


Intentemos colocar un nombre y un serial:


Ahora presionemos registrar y veremos a WKTVBDE cargado con los P-Code:


En la parte superior a la derecha, contamos con el stack:


Debajo del stack contamos con un menú muy util:


Memory dump->ALT+M


En esta parte del programa podremos localizar P-codes y modificarlos de manera muy cómoda,Por ejemplo veamos en el dessembler algunos P-codes:


Si nos fijamos en el address 00401CE0 encontraremos un BranchF que es equivalente a 1C
si nos dirigimos a Memory dump y buscamos 00401CE0:


En el costado izquierdo podemos ver los valores hexadecimales que se encuentran a partir de 00401CE0, si hacemos doble click en 1C podremos modificarlo en tiempo de ejecución presionando Patch Now!:


Otra forma un poco más rápida es hacer click derecho en un P-Code ubicado en el dessembler y seleccionar "Modify current opcode". esto nos llevará a Memory dump pero ya apuntando al address del P-Code.

String Refs: Nos muestras las referencias de textos que hay en el programa debuggeado:


API->Ctrl+B:Nos muestra una lista de API'S de Visual Basic, dándonos la posibilidad de colocar BP haciendo doble click:


*Para quitarlo debemos hacer 4 click's

Opcodes->Ctrl+O:Nos muestra una lista de P-Codes al igual que API

OnExecution->Ctrl+E:Nos muestra la lista de BP que ya están puestos y nos dá la posibilidad de Colocarlos también:


Para agregar algún BP se debe insertar el address en la parte inferior y luego presionar ADD

Trace Commands:


Como su nombre lo dice nos muestra los comandos que tenemos para tracear
Step Trace cumple el rol de F7 en OllyDBG
Trace Ret cumple el rol de Execute till return
Trace Over cumple el rol de F8 en OllyDBG
Go! cumple el rol de F9 en OllyDBG
Trace X nos da la posibilidad de tracear un número de P-Codes determinados

en la parte inferior podemos encontrar "Analize BranchX" este nos mostrará la lista de BranchT y BranchF que posee el programa a debuggear:


Ya familiarizados con WKTVBDE continuamos reverseando, vamos avanzando con F8 hasta encontrarnos en el siguiente P-Code:


Este Opcode se encarga obtener el serial introducido, a continuación encontramos 6C:
6C    5620 0B33 2          Push#4 [arg]

Encargado de pushear el serial, podemos corroborarlo si nos dirijimos en el dump al address a pushar:


Si continuamos traceando hasta 401D01:

Notaremos una comprobación entre 5 y 6, si miramos en el stack veremos de donde provienen:


Si continuamos traceando hasta 401D08 nos encontraremos con un BranchF=1C, WKTVBDE nos muestra al lado de él si saltará o no, en este caso NO:


Si nos fijamos al no saltar nos mostrará un mensaje que podemos ver en el address 00401D21

Por lo que deducimos que la anterior comparación fue el número de caracteres del nombre introducido con el mínimo permitido UND3R=5 con 6

Por lo que intentaremos modificar el salto para evitar la alerta, hacemos click derecho->Modify current opcode y cambiamos 1C por 1D que es el salto opuesto:


Presionamos F8 y veremos que saltará 00401D3F


*Si quisieramos saltar a otro lugar, podemos utilizar una excelente herramienta que trae P32Dasm llamada Jump calculator


Desgraciadamente P32Dasm trabaja con Offset Raw por lo que podría confundir de alguna forma. Para utilizarla debemos escribir el address en donde se encuentra el salto (Raw) y a continuación hacia que address saltará, en el costado izquierdo podremos seleccionar el tipo de salto.

Seguimos traceando, aquí toma nuestro nombre y lo pone en minúsculas:


Si seguimos traceando una gran serie de P-Code's nos detendremos en el siguiente salto:


Notaremos que si no salta nos llevará a un mensaje de que el serial es incorrecto, intentemos modificar el salto:


Ahora presionemos Go!->F5


II-CrackMe Chronos

Cargamos el crackme desde WKTVBDE


También lo cargamos desde exdec y buscamos referencias, una vez encontrada buscamos el primer Branch desde abajo hacia arriba:


Ahora introducimos un serial cualquiera y traceamos hasta llegar a 402B08, luego lo cambiamos por 1D y presionamos F5 o Go!:



III-nags1

Para eliminar una nag en algunos casos al igual que los serial debemos modificar los Branch, o en otros casos se debemos Nopear un P-Code, en el segundo caso no se pueden eliminar dejando un vacio por lo que siempre se debe reemplazar por otro P-Code, siempre y cuando, el otro ocupe el mismo espacio (número de parámetros)

Veamos un ejemplo a continuación:

Iniciamos nags1 para visualizar el nag a eliminar:



Cargamos nags1 con exedec:


Notaremos que es un rtcMsgBox ubicado en 401A2D. Vamos desde OllyDBG al address:
Veremos un P-Code con 4 bytes de parámetro, cambiemoslo por un push 0=05 00 00 00 00




Si damos RUN F9, notaremos que la nags ha desaparecido

Introducción al cracking de P-Code

Referencia:Capitulo 29 "Introducción al cracking desde 0" por Ricardo Narvaja

Siempre cuando realizamos un previo análisis del ejecutable que nos vamos a enfrentar, cuando sabemos que es un Visual Basic compilado en P-Code intentamos aludirlo
ya que toman su tiempo crackearlo, por eso el motivo de esta introducción, en esta primera parte nos enfocaremos en el capítulo 29 de Ricardo Narvaja, en la segunda entrega nos enfocaremos con más crackmes y empezaremos a utilizar el fomoso WKTVBDE.

Herramientas:
-WKTVBDE
-OllyDbg
-P32Dasm
-exdec

I-¿Qué es P-Code?
Cuando compilados un programa con VB, este nos da la posibilidad de elegir el tipo de compilado diferenciando entre código NATIVO y P-CODE:
el código nativo tiene la gran ventaja que ejecutan el código en la sección code del programa permitiendo esto que sea más "fácil" lograr saltar la seguridad, por otro lado el
P-CODE no posee código de ejecución dentro de la sección code. solo posee una serie de códigos llamados P-Code que son interpretados y ejecutados por la dll de Visual Basic, haciéndonos una tarea más difícil.

II-¿Como saber si es un P-Code?
Los P-Code tienen una grán característica y es el uso de la API: MethCallEngine

Cargamos Clave1 con OllyDBG:


Si subimos un poco veremos que se utiliza la API:


Otra forma de saber que es un P-Code, es el mal análisis de código que realiza OllyDBG a diferencia de un native, si bajamos un poco lo podremos notar:


III-Analizando P-Code con OllyDBG
Para analizar un P-Code bajo OllyDBG debemos usar paralelamente exdec o P32Dasm, estos programas se encargan de encontrar la lista de P-Codes de forma automática. La idea es entender como trabajan estos tipos de programas:

Como sabemos los programas compilados en P-Code no ejecutan su código en la sección code solo executan comandos P-Code's que son interpretados por la dll de Visual Basic por lo que nosotros nos basaremos de eso,encontrar los P-Code de manera manual.

Cargamos clave1.exe en OllyDBG y colocamos un BP en la API MethCallEngine:


Iniciamos el programa con F9 y veremos lo siguiente:


Introducimos un serial cualquiera:


Vemos que se detiene en el BP:


Presionamos Alt+M y colocamos un Memory breakpoint on access en la sección code


Presionamos F9 hasta que se detenga en la siguiente instrucción:

MOV AL,BYTE PTR DS:[ESI]


En este lugar es donde la dll lee el primer P-Code, si miramos arriba del dump veremos de donde proviene:



Comienzan en: 00401BD0, si nos dirigimos ahí desde el dump veremos los P-Code's y sus parámetros:



Presionemos F7,y EAX tomará el valor del primer P-Code:



luego si presionamos F7 nuevamente aumenta ESI, esto lo hace para que ESI apunte a los parámetros del P-Code 04:


Desgraciadamente no existe una lista de P-Code's oficiales pero de todas formas adjunto una.

Para hacernos una idea de que va hacer el programa buscamos el P-Code 04 en la lista:

04    567B 0B8E 2 1 2      Push arg

Osea lo que hará será pushear su argumento,veamos si esto es correcto, luego de INC ESI realiza un JMP:


Presionamos F7 y llegamos aca:


veremos el siguiente comando:MOVSX EAX,WORD PTR DS:[ESI]

"Copies the value of the source operand to the destination register
with the sign extended."

lo que hará será colocar el parámetro de ESI en EAX considerando el signo negativo:



Luego suma EAX con EBP pero EAX por causa del MOVSX quedó en negativo será una resta: FFFFFF74h equivale a -140 decimal(para corroborar se debe hacer doble click en EAX), si 140 lo pasamos a hexadecimal,nos da: 8C por lo que en resumen realizará lo siguiente -8C+0012F4E0:



luego de eso realiza un PUSH EAX:



con eso concluye el P-Code 04 luego de eso realiza un XOR EAX,EAX para limpiar EAX y vuelve a mover el siguiente P-Code a EAX que en este caso es 21:



Luego suma 3 a ESI para apuntar al parámetro del segundo P-Code:



Aquí mueve a EAX el contenido de 0012F4E8 y lo mueve a EAX, luego el contenido de 0012F4E8 que ahora se encuentra en EAX es movido a [EBP-4C] luego de esto realiza un XOR EAX,EAX nuevamente para limpiar EAX y tomar nuevamente el siguiente P-CODE

En resumen la dll realiza lo siguiente:
-Toma el valor de P-Code y lo mueve a EAX: MOV AL,BYTE PTR DS:[ESI]
-Incrementa ESI para apuntar al parámetro del P-Code
-Se dirige al parámetro y ejecuta la operación correspondiente
-Terminada la operación realiza un XOR EAX,EAX para limpiar el registro
-Vuelve nuevamente al primer paso

Todo este análisis manual se puede evitar como comenté anteriormente con programas como exdec o P32Dasm, abrimos exdec y nos aparecerá lo siguiente:



Nos vamos a File->disassemble Prog y elegimos clave1.exe y nos mostrará lo siguiente:



en donde el primer valor es el address(VA) del P-code,el segundo valor es el P-Code mismo, el tercer valor es el nombre del P-Code y el cuarto el parámetro.

Si recordamos el primer P-Code fue 4 y estaba ubicado en el address 401BD0 y lo que realizo fue pushear el valor de EBP-8C, por lo que el programa nos facilita considerablemente la localización de los P-Code junto con sus parámetros

*exdec solo está disponible en fase beta, imposibilitando guardar la lista de P-Code pero de todas formas sigue siendo una herramienta fundamental.

Si abrimos P32Dasm veremos lo parecido que son:


este programa está más avanzado y nos muestra los P-Code de una manera más visible ideal cuando son muchos, También nos facilita la búsqueda de referencias de strings o números:



IV-Crackeando con OllyDBG y exdec

Para crackear de manera básica debemos tener conocimientos de dos P-Codes

1)BranchF=1C
este P-Code es similar a un salto condicional, este salto se realiza si la comprobación anterior es falsa.

2)BranchT=1D
este P-Code es el opuesto a BranchF es decir, este salta cuando la comprobación es verdadera T=True F=false


Una vez entendido como trabajan los programas compilados en P-Code podemos empezar a trabajar, lo primero que haremos será cargar clave1.exe con exdec, bajamos hasta encontrar alguna referencia de texto que sea llamativa:



una vez encontrada la referencia, en este caso:
"Número incorrecto"

debemos subir hasta encontrar algún BranchT o un BranchF. los Branch=1E no los debemos considerar ya que son equivalentes a JMP, es decir saltos incondicionales:



Encontramos un BranchF en 401C2C que si no se cumple la comprobación anterior este saltará a 401C63 vayamos a esa address para ver hacia donde se ubiese dirigido:



Vemos que se dirige a "Número Correcto"

Cargamos clave1.exe desde OllyDBG y nos dirijimos desde el dump a 401C2C (Address del BranchF)



Notaremos que hay un 1C que es equivalente a BranchF, intentemos cambiarlo por BranchT que es 1D y guardamos los cambios:



Iniciamos clave1 modificado, introduzcamos un serial cualquiera y presionamos Registrar:



Nuestro serial es tomado como válido

En esta ocación trabajamos enfocados en OllyDBG, luego trataremos teorias con WKTVBDE,Hasta la Parte II




UND3R

eso :B

Saludos

Descarga:http://download.aivosto.net/vbw2.zip

Raul100 me pidió que "crackeara"(reverseara) este programa, hace tiempo le hice un crack y hoy lo vengo a compartir con ustedes

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


Saludos

esa es mi sugerencia

hola tengo una duda, como puedo mover 66 C7 05 5B F0 45 00 EB 12  (9bytes con mov), solo conozco word y dword


Saludos

Hola tengo la siguiente duda

si en memoria virtual tengo 150000 con size 3000 si quisiera dejarlo el address 150000 con size 4000 que parámetros debería pushear para llamar a realloc?

Gracias