ESTUDIO COLECTIVO DE DESPROTECCIONES
Última Actualizacion: 25/10/2001
Programa Tag Rename v1.6 W95 / W98 / NT
Descripción Programa para añadir tags a los mp3
Tipo Trial de 30 dias
Tipo de Tutorial [X] Original  [ ] Adaptación  [ ] Aplicación  [ ] Traducción
Url no la recuerdo ;)
Protección Nag Screen. Time Limit 30 Dias,Comprimido con Aspack+Asprotect
Dificultad [1] Principiante  [2] Amateur  [3] Aficionado  [4] Profesional  [5] Especialista
Herramientas SoftIce v3.25, IDA v.4.0, Hex Workshop
Objetivo Simular estar registrados.Insertando codigo en el cuerpo de Aspack
Cracker Mr.Snow
Grupo Whiskey Kon Tekila
Fecha 8 de Septiembre de 2000
INTRODUCCION

El Objetivo de este tutorial es mostrar lo duro ke lo pueden poner algunos PACKERS, o por lo menos intentarlo ya ke aparentemente alterar el ejecutable para ke reaccione como un producto registrado no tiene mas dificultad ke la de conseguir fijar el parche en el mismo ejecutable . El eskema de proteccion de este programa parece basarse mas ke nada en el packer utilizado ya ke el autor no parece haber puesto mucho empeño en el algoritmo de validacion , el cual solo depende de alterar un simple salto condicional . Bueno sin mas nos dirijieremos a explorar la victima.....

Aproximacion Facilona

Ejecutamos el programa y nos aparece la pantallita de bienvenida , la cual nos recuerda los dias ke nos kedan de evaluacion .
Pulsamos sobre el boton de registro y  rellenamos el campo de nombre y numero, entramos en Soft Ice y ponemos un BPX HmemCpy y pulsamos OK.
Apareceremos de nuevo en la pantalla del soft ice ahora pulsamos unas cuantas veces F12 hasta llegar al codigo del Tag Rename , una vez en su codigo pulsamos unas cuantas veces F10 hasta situarnos en el offset 40870e un poco mas abajo vemos un salto condicional con lo ke suponemos ke esta sera la rutina validadora , pulsamos F8 y entramos en la rutina , si seguimos trazando el programa llegaremos a la conclusion ke todo el tic de la cuestion esta en la linea 460aac la cual contiene un jz xxxx y si este salto se cumple se determina ke el programa no esta validado , colo lo cual podemos cambiarlo por jnz o nop nop .
Ahora ke sabemos donde esta el offset a cambiar podriamos pensar ke con solo usar un Proccess Patcher sobraria , bueno pos probemoslo y nos daremos cuenta de ke tras cargar el loader nos aparece un bonito ERROR 15 y se cierra el programa.
Buff Ke mal royo parece ser ke el programa detecta las modificaciones en memoria , tendremos ke usar otro metodo .

 

 

Se Complica El Asunto ...

Bueno inspeccionemos el ejecutable , usando un editor hexadecimal veremos ke en la cabezera PE del archivo hay una seccion llamada XXXXX ke seguro ke es donde se aloja el codigo del desenpaketador. Bueno para ver donde devuelve el packer el control al programa deveremos ejecutar el programa desde el principio e ir trazando hasta ver donde llegamos (o usar IDA para ahorrarnos tiempo) .
Primero usaremos Soft Ice para ojear la zona de batalla . Como el programa esta comprimido sera muy tipico ke no podamos parar en el principio del programa usando el Symbol Loader del Soft Ice , asi ke vamos a usar un pekeño trukillo:

Usa ProcDump o algun programa parecido para obtener los datos de la cabecera PE y saber cual es el punto de entrada del ejecutable , en nuestro caso el Punto de entrada es 57b001.

Ahora ejecuta el Tag & Rename y parate en cualkier punto de su codigo ( usa los bpx de antes para detenerte en el codigo)  , una vez aki ponemos un BPM en 57b001 x , salimos del programa y kitamos todos los BPX menos el ke acabamos de poner . Ahora ejecutamos de nuevo y apareceremos en el punto de entrada.

Una vez aki pulsamos F8 y vamos trazando el programa con F10 , enseguida veremos ke el programa realiza unos call y se ejecuta entero , si entramos en estos call pordremos ver como el programa empieza a dar saltos de arriba para abajo (estos saltos son solo para despistar) , en vista de lo visto vamos a usar IDA o podemos acabar dando saltos al ritmo del soft ice....

Cargamos el Ida Pro y elegimos el Tagrename.exe le damos a ok y nos informara de ke el segmento de importaciones esta destruido . Ahora aparecemos en la entrada del programa si vamos mirando el codigo hacia abajo vemos ke hay mas de 50 docenas de saltos , A causa de tantos saltos el propio ida puede ser ke no reconozca ciertas zonas como codigo , con lo ke tendremos ke decirle ke lo combierta a codigo para hacer esto solo debemos posicionar el cursor sobre las ordenes ke no se han desensamblado  y pulsar la tecla C la cual combierte a codigo , si eke es posible , si ves ke pulsas la C y no cambia prueba a bajar una linea mas .
Bueno pues pulsemos la C hasta llegar a la linea 57bc28 , en esta linea es la ke se supone ke se devuelve el control al programa principal . Volvemos al soft ice y ejecutamos el programa (recuerda tener el bpm activado) ahora ponemos un BPX en la linea 57bc28 , y dejamos ke se ejecute el programa , sin mas retardos apareceremos en esta linea.Pulsamos F10 para ver donde paramos y aparecemos en una funcion del sistema (localFree) pulsamos F11 para retornar y ............

Arrggggggg ¡¡¡¡ ke es esto , parece ser ke estamos en una zona de memoria , ke pasa aki .

Pues sin duda esto se pone muy feo , ahora estamos en una zona de la memoria sin nombre , y para colmo resulta ser parte del codigo del desenpaketador , ya ke aun no esta visible la parte del codigo del programa.
Cerremos y volvemos a ejecutar el programa paramos en la llamada a localFree y si pulsamos f11 aparece de nuevo el mismo codigo de antes, pero si te fijas el offset es distinto , lo ke nos complicara mas la cosa a la hora de parchear el programa.
Bueno como hemos comprobado antes si usamos un procces patcher se produce un error 15 , para comprobar donde ocurre esto vamos a poner un BPM en la zona la cual debemos parchear , BPM 460AAC (pon este bpx cuando te encuentres al principio del codigo ke se carga en memoria) , dejamos ke se ejecute el programa y vemos como se detiene , si ahora visualizamos esa zona de memoria (d 460AAC) veremos como hemos parado en la zona ke se encarga de descomprimir el verdadero codigo del programa , si dejamos ke se siga ejecutando veremos como volvemos a regresar a SI . Hagamos una prueba
vuelve a ajecutar el programa cuando te detengas en el primer BPM 460aac visualiza esa zona de memoria y cambia el 74=jz por un 75=jnz y deja ejecutar el programa , pararas de nuevo en el soft ice ignora esta parada y deja ke se siga ejecutando el programa , veras como aparece el ERROR 15 .

Recuerda ke seguramente cada vez ke vuelvas a ejecutar el programa , aunke tengas puestos los BPX o BPM pude ser ke pase de para para evitar esto usa el comando BPE (Break Point Edit) y el numero de breackpoint y dale a intro te aparecera el bpx o bpm ke pusiste vuelve a pulsar intro y el BreackPoint sera reactivado.

Conclusion , la primera vez ke paramos es cuando se descomprime el ejecutable , y la segunda vez es cuando se realiza el checksum ke determina si hemos alterado el programa o no.

Ahora llega el momento de hacer algunas pruebas mas , sabemos ke el codigo del programa ke tenemos ke alterar no aparece en el ejecutable , y por otro lado el codigo del packer es cargado en memoria (offsets arbitrarios) , la solucion mas facil es la propuesta por MR.Crimson en su tutorial sobre el AZPR. Crear un THREAD paralelo ke se encargue de modificar el codigo en el momento oportuno, par ello lo primero ke necesitamos es espacio en el ejecutable para codificar nuestro thread. Cargamo a nuestro amigo TOPO seleccionamos unos 300 bytes y lo pasamos al tag rename , y ..... maldicion dice ke no puede liberarnos espacio.

Ueno pos nos tocara hacerlo a lo bestia , o añadimos una nueva seccion ( e incrementamos el tamaño del ejecutable) , o buscamos rutinas inutiles ke podamos limpiar , RUTINAS INUTILES eso me suena a JMP aki JMP alla JMP aki_otravez JMP aka CALL mil_jmp_mas ....
Ya tenemos una zona donde taladrar , en los JMP y encima despues de todos estos saltos tenemos el retorno al codigo del packer en memoria por lo ke nos viene ke ni pintao. Vayamos al IDA y veamos cuantos saltos nos podemos limpiar y cuantas instrucciones restaurar.

Para limpiar la zona solo tenemos ke limitarnos a llenarla de 90=NOP y respetar la instrucciones validas como POP EBX , y supongamos ke necesitamos 500 (1f4h) bytes para nuestra aplicacion entonces 57bc28-1f4=57ba34 aki sera a partir de donde debemos rellenar ... usamos ida para ver ke instruccione restaurar y con nuestro hex editor favorito lo rellenamos de 90.
Para ahorrarme tiempo he creado un programita en VB ke se encarga de analizar un fichero de texto y si encuentra una "j","l",";" o "d" elimina esa linea con lo cual
con coger y copiar en un fichero la zonas ke keremos sacar las intrucciones y pasarla por el prog te devuelve solo las instrucciones utiles saltandose los JMP ,DB y LOC_xxxxx.
Una vez limpio estas son las intrucciones ke debemos restaurar desde 57ba33 a 57bc28:

push    eax
call    sub_57BA4B
pop     eax
pop     eax
push    edi
push    ebx
call    sub_57BA7B
pop     ebx
pop     ebx
push    dword ptr [esi+8]
pop     dword ptr ss:unk_45BA52[ebp]
push    dword ptr ss:unk_45BA52[ebp]
pop     ebx
add     ebx,edi
push    eax
call    sub_57BAC2
pop     eax
pop     eax
push    ebx
push    ebx
call    sub_57BAF2
pop     ebx
pop     ebx
push    eax
call    sub_57BB21
pop     eax
pop     eax
push    esi
push    ebx
call    sub_57BB51
pop     ebx
pop     ebx
push    eax
call    sub_57BB80
pop     eax
pop     eax
push    eax
push    ebx
call    sub_57BBB0
pop     ebx
pop     ebx
push    eax
call    sub_57BBDF
pop     eax
pop     eax
push    dword ptr ss:unk_45C39D[ebp]
push    ebx
call    sub_57BC14
pop     ebx
pop     ebx
retn
Como sabras siempre ke se llama a un CALL xxxxx el propio procesador se encarga de empujar a la pila la direccion de retorno , es decir ke lo mismo nos da call XXXX ke push ebx , si te fijas despues de cada call se restaurar 2 veces los mismos registros y eso es devido a ke ha de eliminar el dato ke no necesita ke es el punto de retorno despues del call , ya ke el programa nunca regresa y como hemos visto el ultimo ret ke tiene nos devuelve a una api , por lo ke la direccion a esa api es pusheada en la untima dword (linea en rojo).

Pues todo este chorro es igual a este:

push    edi
push    dword ptr [esi+8]
pop     ebx
add     ebx,edi
push    ebx
push    esi
push    eax
push    dword ptr ss:unk_45C39D[ebp]  = push dword ptr [ebp+45c39d]
retn
Pos nada ya tienes las instrucciones ke has de respetar y el resto de JMP los puedes limpiar asinke , coge el hexeditor , situate en la zona a limpiar , rellenala con 90 , y copia los valores de push u pop correctos.
Ahora ya tenemos nuestro programa con una gran zona toa pa nosotros . Probemoslo a ver ke tal ..... y ¡arrggg¡ (grito de espanto) . Pos parece ke algo pasa porke el programa nisikiera se ha ejecutado , ¿tendra algun checksum? pos fijo , para encontrar el checksum solo tendremos ke poner un bpm en la zona ke hemos modificado y esperar a ke pare y localizar la rutina .... bpm 57ba33 rw ...y... pasa de to el mu kpullo no se ha parado , entonces ¿como demonios detecta ke lo hemos cambiado , si aparentemente no ha leido la memoria para comprobarlo? , pos alomejor en vez de leer la memoria esta leyendo el disco ....
Pues nada un bpx a CreatefileA y esperemos a ver ke pasa .... Bingooo , parece ke si ke lo hacia de esta manera con lo ke solo hemos de falsear la comprobacion
pero para eso tendremos ke cazarla porke si te das cuenta esta comprobacion se realiza desde una zona de memoria ke como ya dije antes cambia de offset arbitrariamente , ya ke estas zonas las asigna el sitema para las aplicaciones ke lo soliciten .
(para insertar el codigo te recomiendo ke trazes el ultimo salto , en mi caso y si has seguido los pasos anteriores , el codigo lo inserto en el offset 57ba36)

Cauando paremos en el BPX CreateFileA pulsamos F11 y aparecera este codigo:
    pop esi  <--------- Nosotros pararemos aki
    pop ebx
    ret
Trazamos el programa con F10 hasta pasar un par de Ret`s mas y aparecera algo como esto:
    mov eax,[ebp-14]    <------- carga en EAX el checksum calculado
    cmp eax,[ebp-10]    <------- y lo compara con el correcto
    jz xxxxx                  <---- este es el salto condicional a falsear con un simple jnz

Ahora es cuando surgen algunas complicaciones menores ....

Para poder cambiar este salto primero debemos saber como localizarlo , y la mejor manera es la siguiente , como hemos visto antes el ultimo lugar ke podemos establecer el control es en la zona ke hemos limpiado , y si te fijas en los datos de la pila (ESP)  justo antes del RET vereas ke [esp+4] y EAX tienen la direccion de memoria en la ke seguira ejecutandose el programa con lo ke lo unico ke debemos hacer es guardar este valor y ver a ke relacion se encuentra del salto condicional del checksum :

 Entrada al codigo generado en memoria: 5F53DD
     -(restamos)
lugar donde se comprueba el checksum:  5E6C28
-----------------------------------------------------
                                                                  E7B5
con lo ke tenemos ke si antes de retornar guardamos el valos de [esp+4] o EAX y aplicamos luego la resta de E7B5 tendremos sin lugar a fallos el offset donde se hara la comprobacion , con lo ke en nuestra zona limpia de codigo debemos generar la primera parte de nuesto THREAD

Comienza El Baile

Siguiendo el tutorial de  MR.Crimson podemos ver como llamar a apis ke no son cargadas por defecto por el cargador PE , pero en el caso de este empaketador las llamadas GetProcAdress y GetModuleHandle si ke son cargadas , para comprobarlo usa un hex editor y busca estas cadenas , veras como aparecen , con lo ke se las podemos robar al programa ;)
Pon el Bpm al principio del programa ejecutalo ahora kita todos los bpx y pon BPX GetModuleHandleA , deja ke se ejecute el programa y cuado pares pulsa F11 para ver donde aparecemos , veras algo como esto

0057B02F                 lea     eax, unk_45C294[ebp]
0057B035                 push    eax
0057B036                 call    dword ptr ss:unk_45C3D0[ebp] ; llamada a GetModuleHandleA
0057B03C                 mov     dword ptr ss:unk_45C290[ebp], eax  ; EAX tiene el valor del handle al Kernel32.dll
0057B042                 mov     edi, eax
0057B044                 lea     ebx, unk_45C2A1[ebp]
En este codigo onbtenemos 2 valores muy interesantes :
 en la line 57b036 se llama a la funcion GetModuleHandleA con lo ke sabemos ke la entrada a esta rutina la podemos encontrar en [ebp+45c3d0]
 y si usas el soft ice , paras en la linea 57b03c y preguntas ke valor tiene EAX (what eax) veras ke es el Handle a Kernel32.dll , con lo ke sabemos ke en [ebp+45c290] tenemos el manejador.
Realizamos la misma operacion pero con un Bpx GetProcAdress y:
0057B04C                 call    dword ptr ss:unk_45C3CC[ebp] ; ;llamada a GetProcAddress
0057B052                 mov     dword ptr ss:unk_45C399[ebp], eax
0057B058                 lea     ebx, unk_45C2AC[ebp]
0057B05E                 push    ebx
Vemos como GetProcAddress se encuantra en [ebp+45c3cc] .
Ahora tenemos todo lo necesario para codificar nuestro Thread ...
Tenemos :
    [ebp+45c290] = Handle de Kernel32.dll
    [ebp+45c3cc]= GetProcAddress
    [ebp+45c3d0]= GetModuleHandleA
solo nos falta obtener la entrada para IsBadCodePtr , CreateThread y CloseHandle (ver tutorial sobre el AZPR).
 
 
0057BA36 loc_57BA36:                             ; CODE XREF: sub_57BA1C+14.j
0057BA36                 nop
0057BA37                 push    edi
0057BA38                 push    dword ptr [esi+8]
0057BA3B                 nop
0057BA3C                 nop
0057BA3D                 nop
0057BA3E                 nop        ; estos nops realmente no tendrian ke estar aki , pero para respetar los offsets he de dejarlos , con unas pekeñas
0057BA3F                 nop        ; modificaciones pueden ser eliminados.
0057BA40                 nop
0057BA41                 nop
0057BA42                 nop
0057BA43                 nop
0057BA44                 nop
0057BA45                 nop
0057BA46                 nop
0057BA47                 pop     ebx
0057BA48                 add     ebx, edi
0057BA4A                push    ebx
0057BA4B                 push    esi
0057BA4C                 push    eax
0057BA4D                 push    dword ptr ss:unk_45C39D[ebp]
0057BA53                 mov     ds:dword_57BA8C, eax
0057BA58                 jmp     short loc_57BA95
0057BA58 ; ---------------------------------------------------------------------------
0057BA5A aIsbadcodeptr   db 'IsBadCodePtr',0
0057BA67 aCreatethread   db 'CreateThread',0
0057BA74 aClosehandle    db 'CloseHandle',0
0057BA80 dword_57BA80    dd  00000000h
0057BA84 dword_57BA84    dd  00000000h
0057BA88 dword_57BA88    dd  00000000h
0057BA8C dword_57BA8C   dd  00000000h
0057BA90 dword_57BA90    dd  00000000h
0057BA94                 db  90h ; É
0057BA95 ; ---------------------------------------------------------------------------
0057BA95
0057BA95 loc_57BA95:
0057BA95                 push    offset aIsbadcodeptr ; "IsBadCodePtr"
0057BA9A                push    dword ptr ss:unk_45C290[ebp]
0057BAA0              call       dword ptr ss:unk_45C3CC[ebp]
0057BAA6                mov     ds:dword_57BA80, eax
0057BAAB                push   offset aCreatethread ; "CreateThread"
0057BAB0               push    dword ptr ss:unk_45C290[ebp]
0057BAB6                 call       dword ptr ss:unk_45C3CC[ebp]
0057BABC                 mov     ds:dword_57BA84, eax
0057BAC1                 push    offset aClosehandle ; "CloseHandle"
0057BAC6                 push    dword ptr ss:unk_45C290[ebp]
0057BACC               call      dword ptr ss:unk_45C3CC[ebp]
0057BAD2                 mov     ds:dword_57BA88, eax
0057BAD7                 push    offset dword_57BA90
0057BADC                 push    20h
0057BADE                 push     0
0057BAE0                 push     offset loc_57BAF7
0057BAE5                 push     0
0057BAE7                 push     0
0057BAE9                 call       ds:dword_57BA84
0057BAEF                 push    eax
0057BAF0                 call       ds:dword_57BA88
0057BAF6                 retn
0057BAF6 sub_57BA1C      endp ; sp = -40h
0057BAF6
0057BAF7 ; ---------------------------------------------------------------------------
0057BAF7
0057BAF7 loc_57BAF7:                        Elimina el checksum ke se encarga de comprobar la integridad del fichero
0057BAF7                 mov     edi, ds:dword_57BA8C
0057BAFD                 sub     edi, 0E7B5h
0057BB03                 push    edi
0057BB04                 call    ds:dword_57BA80
0057BB0A                 test    eax, eax
0057BB0C                 jnz     short loc_57BAF7
0057BB0E                 cmp     byte ptr [edi], 74h
0057BB11                 jnz     short loc_57BAF7
0057BB13                 mov     byte ptr [edi], 75h
0057BB16                 jmp     short loc_57BB1C
0057BB16 ; ---------------------------------------------------------------------------
Con este codigo conseguimos anular el checksum ke no nos dejaba continuar ahora solo debemos centrarnos en parchear el codigo ke nos da registro en el programa.
Para eso primero deberemos saber en ke momento se realiza el checksum del codigo ke keremos parchear , y una vez lo sepamos podremos modificar los bytes necesarios despues de ke el checksum sea realizado.(ahora me estoy refiriendo al checksum ke nos saca el bonito mensaje de ERROR 15) .
Ejecuta el programa pon un bpx antes de devolver el control a la rutina de memoria (bpx 57bbf6) , ahora pon un bpm en la zona ke debemos parchear (bpm 460aac) , espera a ke pare 2 veces (una descomprime , y la segunda realiza el checksum)  y traza el programa hasta ke veas como compara el numero del checksum , despues de esa comparacion , podemos alterar el codigo de donde keramos  . en mi caso la zona donde insertar mi nuevo codigo la calculo de la manera ke hicimos antes para calcular la zona del salto condifcional despues de la llamada a createfilea , y obtengo E2CF .
Mi estrategia es muy simple: pretendo insertar en parte del codigo ke se ejecutara despues del checksum una llamada a una rutina la cual parchee la zona necesaria para el registro , sin peligro de checksums porke ya han sido realizados y restaure las instrucciones ke he kitado para insertar ese call , luego simplemente retorna y se sigue ejecutando el programa.
0057BB18                 dd 57BB39h      ; dword ke apunta al codigo ke parcheara el  registro del programa y restaurara los datos eliminados para insertar el call
0057BB1C ; ---------------------------------------------------------------------------
0057BB1C
0057BB1C loc_57BB1C:  Parchea el codigo del packer en memoria para ke ejecute nuestro parche despues de haber realizado el checksum.
0057BB1C                 mov     edi, ds:dword_57BA8C
0057BB22                 sub     edi, 0E2CFh
0057BB28                 mov     dword ptr [edi], 0BB1815FFh  ;aki se mueven los bytes de la instruccion call dword ptr[57bb18]
0057BB2E                 mov     word ptr [edi+4], 57h                ; al codigo del packer en memoria
0057BB34                 retn
0057BB34 ; ---------------------------------------------------------------------------
0057BB35                 db  90h ; É
0057BB36                 db  90h ; É
0057BB37                 db  90h ; É
0057BB38                 db  90h ; É
0057BB39 ; ---------------------------------------------------------------------------
0057BB39                 mov     ds:byte_460AAC, 75h        ; parcheamos el programa descomprimido
0057BB40                 mov     ecx, [eax+10h]                        ; restautamos las instrucciones ke machakemos con el call
0057BB43                 mov     eax, [ebp+8]
0057BB46                 retn
Bufff casi na to lo ke he escrito , Pos ueno esto es todo amigoosss o casi todo ......

 

IDA Pro v4.0 colton ke buen amigo....

Jeje como aun no me he cansado de escribir ahora os voy a explicar como podemos usar IDA 4.0 Pro para ensamblar nuestro programita.
Pero primero veamos unos comandos:

Teclas De Ida:
            C            - Combierte los bytes en codigo
            D            - Combierte los bytes en datos (1 vez byte,2 veces word, 3 veces dword)
            A            - Combierte los bytes en cadenas Ascii (db "hola")
            U            - Combierte codigo , datos o ascii en bytes idefinidos
            G            - Salta a una zona del programa
            E            - Establece el final de una rutina
            N           - Cambiar nombres a rutinas , variables ...
            ;             - Añadir comentarios
 

asi es como Ida nos puede mostrar unas zonas de codigo , fijate ke la linea 57ba30 tenemos un salto hacia 57ba36 , lo ke nos indica ke en esa zona continua el codigo ,si nos situamos en esa  linea (57ba36) y pulsamos  la "C" aparecera esto:

Si ahora nos ponemos en la linea donde pone loc_57ba37 y pulsamos la "N" podremos elegir un nombre para ese offset.

Sigamos viendo ke sale :

Si nos situamos en 57ba67 y pulsamos la "A" combertiremos estos datos en cadens Ascii , y haremos lo mismo en la linea 57ba74 y el resultado sera:

Si ahora intentamos lo mismo en la linea 57ba80 no pasara nada , probemos con "D" ya ke hay 4 bytes pulsaremos la "D" 3 veces (dword) y repetimos la operacion con el resto :

Como veras Ida es muy potente ya ke si nos acostumbramos a desensamblar con el y a renombrar rutinas es mucho mas facil el entendimiento del programa.
Tambien puede ser muy util para insertar codigo sin necesisda de recurrir al soft ice .
Si nos vamos al menu Edit ---> Patch Program  -----> Asemble . podremos insertar codigo donde keramos eso si recordar siempre poner la h de hexadecimal despues de una expresion numerica : mov dword ptr[eax],123456h si no nos dara error , una vez ke tengamos ensambladas las instrucciones podemos usar el Comando "U" para ver los bytes por los ke se componen las instrucciones para asi copiarlos con un Hex Editor en el fichero Victima.

En las opciones de Ida Tenemos la forma en la ke puede reconocer cadenas ascii y muchas cosas mas pero eso son palabras mayores , lo ke se de ida es a base de probar con el , y os recomiendo ke practikeis con el , ya ke aunke pueda parecer complejo llega a ser extremadamente util.

JEJE Pos ahora si ke creo ke he explicado todo lo ke tenia ke explicar , sin mas un saludo a todos , y espero ke este tutorial os sea util , el tutorial es largo pero creo ke lo he explicado detalladamente , si teneis alguna duda , pos ya sabeis Experimentar y PREGUNTAR  ....

 Mr.Snow - WkT 2000

 

Saludos y tal ...
Salu2 a todos los miembros de WKT ,al ZaIote (bzz),Karpoff , Ni2,Gadix,Xasx,A todos los del canal #crackers del hispano , a Digital Justice , y todos los ke me han ayudado y apoyado en el mundo de la II y recordar Punk Not Dead y Whiskey Kon Tekila menos. jeje
[ Entrada | Documentos Genéricos | WkT! Web Site ]
[ Todo el ECD | x Tipo de Protección | x Fecha de Publicación | x Orden Alfabético ]
(c) Whiskey Kon Tekila [WkT!] - The Original Spanish Reversers.
Si necesitas contactar con nosotros , lee esto antes e infórmate de cómo puedes ayudarnos