Registrarse

[karmany]

Ejemplo 03

Aunque he puesto ejemplo 03 (por continuar de la misma forma), en realidad son ideas que pueden solucionar alguna dificultad.

Modificar tamaño de una cadena de texto:

Como se ha observado, si podemos abrir el programa con un editor de recursos y modificamos cualquier texto, dándole un tamaño diferente, el editor de recursos hace las modificaciones pertinentes para ajustar el nuevo texto al programa..
El problema viene, generalmente, cuando no podemos abrir con el editor de recursos ese texto que queremos modificar y tenemos que editarlo desde un editor hexadecimal.
Por ej. es posible encontrar "Help" que queremos traducir por "Ayuda" que tiene un byte más.

¿Qué podemos hacer?
Lo primero es conocer cómo se guardan esos datos. Si se abre un programa con un editor hexadecimal y se buscan esas cadenas ya comentadas podemos encontrar por ej. esto:

. .G.I.F...v.e.r.s.i.ó.n...i.m.a.g.e.n.

Esos "." no corresponden al punto. Voy a coger por ej. esto:
"..v.e.r.s.i.ó.n." y su hex: "0E 00 76 00 65 00 72 00 73 00 69 00 F3 00 6E 00".
Es fácil observar que el 0E corresponte al número de bytes (de 76 al último 00) y los demás números (excepto 00) corresponden a las letras de "versión".
También he encontrado programas que en vez de 0E verás un 07 y es el resultado de la longitud de la cadena "versión".


Pueden haber otras combinaciones, pero es fácil razonarlo..
Sabiendo esto podemos encontrarnos con un programa así:

..o.r...h.e.l.p.  -> 04 00 6F 00 72 00 08 00 68 00 65 00 6C 00 70 00
Sencillamente se puede modificar y dejarlo así:

..o...a.y.u.d.a. -> 02 00 6F 00 0A 00 61 00 79 00 75 00 64 00 61 00

El número total de bytes en los dos es: 10 (hex) -> 16 (dec) esto es lo importante.

Otras formas:

-También es posible encontrar tras los datos muchos bytes a 00. A veces, es posible utilizarlos ya que y según qué casos el programa no los va a modificar. Otras veces en cambio, y por experiencia, el programa utiliza esas direcciones para guardar datos temporalmente y estropea nuestro trabajo.

-En algún caso he tenido algún programa en el que sí es posible modificar un texto con el Resource Hacker pero no otro texto que no lo puede abrir..
Abriendo el programa con un Editor Hexadecimal vi que los 2 textos se encontraban próximos..
¿Qué hice?
Pues con el Resource Hacker modifiqué ese texto que me dejaba editar y le puse bastantes caracteres, con lo que conseguí bytes libres para cambiar el otro texto..

[karmany]

Ejemplo 04

Este siguiente ejemplo es una buena forma de crackear un programa con una limitación de tiempo con Resource Hacker.
Se puede apreciar cómo, se intenta eliminar una ventana que nos informa de la limitación de tiempo de 15 días, y se obtiene un error. Para saber lo que sigue hay que leerlo.

Este fantástico tute ha sido realizado por APOKLIPTIKO (CrackSLatinoS), y lo he encontrado en la página de Ricardo Narvaja en formato pdf. Si falla este enlace se puede descargar en la página ya mencionada en Curso Nuevo y número 781-. Volviéndonos invisibles.
Descarga directa:
TUTE

[karmany]

Ejemplo 05

Insertar imágenes en Delphi

Bueno hace bastante tiempo que sigo detrás de este ej.
Si habéis leído el tute, antes de acabar pongo un ejemplo que encontré en el archivo ayuda del Resource Hacker de cómo insertar una imagen después de haberla insertado como recurso en un programa que hubiese sido compilado en C:

Si habéis probado con otros programas la cosa es bastante diferente.
Por ej. si se abre con el Resource Hacker un programa compilado con Delphi, el código que mencioné arriba no vale. Entonces, ¿cómo es posible insertar una imagen en un programa creado en Delphi?
Para verlo, lo primero descargar este programa que he hecho en Delphi:
Descargar el archivo ejemplo.rar del archivo zip. El enlace está en el primer mensaje de este hilo.

Si se ejecuta el programa se observa lo siguiente:

_Imagen29

Aparece una imagen, con unas bandas de colores. El tamaño de la imagen es 32 x 32.
Vamos a abrir el programa con el Resource Hacker a ver dónde está esa imagen.
La imagen la encontramos en RCData --> TForm1
y se encuentra en el código como:

Código:

object Image1: TImage
    Left = 136
    Top = 64
    Width = 32
    Height = 32
    AutoSize = True
    Picture.Data = {

Es decir en Picture.Data está el valor que corresponde a la imagen.

He de decir en este punto, que he intentado desde hace ya bastante tiempo de todo: He insertado como recurso una imagen, pero desde el código soy incapaz de llamarla, porque al compilar con el Resource Hacker tiene bastantes limitaciones.
Realmente existen Editores de recursos que leen perfectamente estas imágenes y en algunos se pueden modificar sin variar el formato. Lo hacen todo de una forma visual muy cómoda pero por contra tienen otras limitaciones como son la dificultad de modificar una imagen variando el formato o simplemente insertar una imagen cualquiera donde nosotros queramos.
Por este motivo me decidí crear una aplicación, que está actualmente en desarrollo, que fuera capaz de descifrar esos códigos y viceversa: que a partir de una imagen fuera capaz de crear el código correspondiente.

He creado una aplicación que genera automáticamente el código Picture.Data, para poder insertar la imagen que nosotros queramos.

El programa que he creado y con el que voy a seguir este tute se puede descargar de aquí: (Gracias a Ricardo Narvaja)
Rescode Imagen v2.0.4


*Características:
-Compilado con MASM32.
-Completo archivo de ayuda con más opciones de las explicadas aquí.
-No necesita instalación.
-Reconoce código: Picture.Data(.bmp, .ico), propiedad Glyph, TImageList (generando dos bitmaps),  Ico.Data y MetaFiles (.emf, .wmf)

Si alguien tiene alguna sugerencia que no dude en consultarmela y la añadiré al programa.


Lo que voy a hacer ahora es en el programa modificar la imagen: object Image1 por la siguiente imagen:

_Imagen30

Descarga del archivo .bmp original:
Descargar el archivo cubo.bmp del archivo zip. El enlace está en el primer mensaje de este hilo.

Así que voy a generar el código con mi programa. Guardo la imagen anterior en mi disco duro, ejecuto ResCode Imagen 2.0.4 y pulso en el botón de los 3 puntos, selecciono la imagen.

Tras esto automáticamente ya aparecerá el código. Si se quiere ver la vista previa podemos pulsar en el botón "Crear archivo imagen". Veremos lo siguiente:

_Imagen31

La imagen es de la versión 2.0.3

Ya tengo el código generado, sólo queda pulsar botón derecho del ratón y: "Seleccionar todo--> copiar".

Vamos al Resource Hacker y sustituimos el código anterior.
*Observación: para seleccionar gran cantidad de código simplemente hay que dejar el cursor al inicio, nos situamos al final del código y pulsamos Shift+click (botón izq. ratón).

Compilo Script y guardo el nuevo .exe creado y el resultado es:

_Imagen32

Habilitar controles en Delphi

Hace un tiempo, hice un tute bastante interesante de cómo habilitar botones en Delphi 6. Viene todo muy bien explicado y analizado. Se trata de dos botones, uno desactivado en sus propiedades y otro desactivado en un evento.
Explico cómo habilitarlos utilizando en los dos casos un editor de recursos y después mediante un debugger. El segundo ejemplo pienso que es muy interesante:

Activando botones en Delphi 6 por karmany

[karmany]

Ejemplo 06

Sobre Visual Basic 6 (I)

Muchísima gente sigue utilizando todavía el querido (queridísimo) Visual Basic 6. Por este motivo existen en la actualidad cientos de programas compilados en este lenguaje.

¿Quién no ha tenido alguna vez la curiosidad de abrir un programa compilado en Visual Basic (VB) con un editor de recursos?¿Qué observaremos?.
-Pues normalmente sólo veremos dos carpetas: Icon Group y Version.

¿Por qué?
-Pues porque como comenté al principio de todo, los editores de recursos analizan la sección de recursos (.rsrc) pero en los programas compilados con VB6, los recursos NO se encuentran en esa sección.

Un programa compilado con VB6 normalmente tiene 3 secciones:
-text (aquí el Entry Point)
-data
-rsrc (y es la que los editores de recursos leen)

Entonces, ¿dónde se guardan los recursos?
-Se guardan en la sección .text.

Buscar determinados recursos a mano por la sección .text, es una locura así que voy a utilizar un programa muy bueno que nos va a indicar dónde está cada cosa:
VB Decompiler Lite

Lo primero es configurarlo, así que en el menú Tools-Options en los apartados Form y Disasembler señalamos todas las tildes.

Ahora ya podemos abrir cualquier programa compilado en Visual Basic. Yo voy a abrir uno de ejemplo que acabo de hacer. Es éste:

_Imagen33

Como se observa el botón no está centrado.
Veo en VB Decompiler lo siguiente:

Código:

Begin VB.CommandButton Command1 'Offset: 00001230
    Caption = "Caption"
    Left = 480
    Top = 240
    Width = 1335
    Height = 495
    TabIndex = 0
  End

Me está diciendo que:
-Se trata de un botón: CommandButton
-Su "caption": Caption
-Su posición en el formulario: Left y Top
-Sus dimensiones: Width y Height
-El índice del Tab: TabIndex = 0
-Y lo más importante de todo: Que se encuentra en el offset 00001230. (¡Qué buena información!. Esta información nos va a ayudar en nuestro cometido y pocos programas la dan).

Lo que voy a hacer es modificar por ejemplo:
-La posición del botón para centrarlo.(Solamente horizontal)
-Y voy a modificar también el texto mostrado ("Caption") por "Aceptar". En este último caso no tendré problemas ya que los dos textos constan de 7 bytes.

Voy a abrir el ejecutable en VB con cualquier editor hexadecimal. A la izquierda los editor hexadecimales nos indican el offset así que nos dirigimos a 00001230 y tendremos que ver lo siguiente:

Código:

1230   0000 0001 0800 436F 6D6D 616E 6431 0004   ......Command1..
1240   0107 0043 6170 7469 6F6E 0004 E001 F000   ...Caption..à....
1250   3705 EF01 1100 00FF 0204 0000 5000 0000   7.......ÿ....P.....

Lo primero que voy a hacer es cambiar lo más fácil en este caso :el texto. Así que modificamos "Caption" y escribimos encima "Aceptar".
Ahora voy a mover el botón a la derecha para centrarlo. Sé por el VB Decompiler que el Left = 480. Utilizo la calculadora de Windows y convierto 480 decimal en hexadecimal: 480d == 01E0h.
Como sé que los datos se guardan al revés, sé que tengo que buscar por E001, así que en el código que he puesto arriba lo localizo rápidamente en la segunda linea (los dos penúltimos bytes).

Ahora hago unos cálculos matemáticos sencillos para centrar el botón:
Ancho formulario = 4185; 4185/2 = 2093
Ancho botón = 1335; 1335/2 = 668
Posición resultante para centrar: 2093 - 668 = 1425

1425 decimal = 0591 hex por lo tanto tengo que modificar los bytes E001 por 9105.
El final del código es el siguiente:

Código:

1240   0107 0041 6365 7074 6172 0004 9105 F000 ...Aceptar..`...

Lo guardo como ejemplo.exe, lo ejecuto y...

_Imagen34

Esto es similar en todos los controles...

Ahora para finalizar viene de nuevo mi pasión por las imágenes, es un poco diferente.

Cómo modificar una imagen:

Voy a ir directamente al ejemplo. He creado una aplicación que sólo consta de una imagen. El acerca de, puede ser el siguiente:

_Imagen35

Consta de una imagen. Vamos a ver cómo la podemos modificar.
Para extraer las imágenes voy a utilizar otro programa excelente, se trata de VBreformer su página web es la siguiente:
http://www.decompiler-vb.net/

Voy a abrir el programa en VB con este VB reformer. En mi caso, yo he utilizado el programa Trial Edition v.4.2. Y tras analizar la aplicación aparecen a la izquierda las siguientes carpetas:

*Informations-headers (para este tutorial nos olvidamos de ella)
*Forms-objetcs:
         -Form1 - VB.form:
                    -Mi_imagen - VB.Image
*Visual Basic resources:
         -Form1.frx:
                    -Form1.frx: 00000000

Ahora miro a la derecha y veo el siguiente código:

Código:

'address 00001178
Begin VB.Form   Form1
...
...
    Begin VB.Image   Mi_imagen
            'Object ID: 0x0001
            Picture="Form1.frx":00000000
            Left..
            Top..
            ....
    End
End

Yo me fijo en estos detalles:
1º El nombre de la imagen: Mi_imagen
2º El offset que me indica el formulario. Ya que la imagen estará  más abajo de ahí: 'address 00001178
3º La imagen en cuestion. A la derecha me indica que la imagen es esta: Picture="Form1.frx":00000000. Así que voy a la izquierda (donde las carpetas) y selecciono la imagen correspondiente: -Form1.frx: 00000000

Ya tengo la imagen que quiero modificar. VBreformer tiene una opción valiosísima que nos permite extraer la imagen tal cual aparece en el código, así que lo voy a hacer: "File --> enregistrer l'image sous"


Yo la he llamado: imagen.bmp.
Ahora voy a buscar un dato importantísimo:
-El tamaño: 102734 bytes

Con toda esta información ya puedo modificar la imagen o crear otra a mi gusto. La única condición es que la imagen nueva NO DEBE sobrepasar de 102734 bytes. No he probado a modificar el formato pero supongo que dará error así que lo dejo igual: .bmp. La imagen que he creado la he llamado imagen_modificada.bmp

Yo he hecho esta imagen de igualmente 102734 bytes:

_Imagen36

Ahora viene la parte más difícil de todo. Insertar esa imagen.

Voy a abrir el programa con un editor hexadecimal cualquiera y me voy a ir al offset antes marcado: 00001178.
Ahora bien, yo sé que una imagen en formato mapa de bits comienza por BM, así que un poco más abajo de ese offset voy a buscar esto comentado:

Código:

Offset           ASCII
1220        ..........Mi_ima
1230        gen.............
1240        ..BMN..........

Ahí está el nombre de mi imagen, y después aparece lo comentado:BM. Ya tengo el inicio.

Ahora abro en otra pestaña del editor hexadecimal la imagen_modificada.bmp y copio todos sus bytes.

Ahora tengo que pegarlo pero sin que se agrege ningún byte de más, así que hay que hacer cálculos matemáticos:

Offset de inicio: 00001242 hex
Tamaño de la imagen: 102734 dec = 1914E hex
Offset final imagen: 00001242 + 0001914E = 0001A390 hex
Pero como el offset 00001242 ya contiene un byte pues hay que restarle 1. ¡IMPORTANTE!

Por lo tanto:
offset inicial: 00001242
offset final:   0001A38F

Ahora solamente y con mucho cuidado hay que seleccionar los bytes que hay entre esos offsets y pegar los que habíamos copiado. Sé por experiencia que seleccionarlos para un bitmap puede ser complicado, así que algunos editores hexadecimales permiten seleccionar pulsando la tecla Shift o simplemente lo que hago yo: visualizo 128 bytes por columna y en un momento lo selecciono todo.

Bueno, tras pegar lo que acabo de comentar ya tiene que aparecer lo siguiente:

_Imagen37

Ciertamente si no se tiene experiencia, puede ser complicado realizar este último ejemplo que acabo de hacer.

[karmany]

Ejemplo 07

Sobre Visual Basic 6 (II)

Viendo que hay mucha gente interesada en VB, voy a seguir con algún ejemplo más examinando un par de programas más para VB y a explicar un programa gratuito, con código fuente incluído (en VB) y realmente muy interesante que nos permitirá descubrir el offset exacto de cualquier control y nos enseñará sus propiedades...

El programa que voy a utilizar para todo este ejemplo se puede descargar (incluído su código fuente) desde el siguiente enlace, el programa se llama VB Editor 3.0 y su autor Hexman:
VB Editor v3.0

La interfaz del programa que he compilado en VB6 para este ejemplo es la siguiente:

_Imagen38

El programa lo he llamado: "ejemplo7.exe"
Como se puede observar, hay dos botones deshabilitados y un timer con un intervalo de 2553. El primer botón (Command1) está deshabilitado en las propiedades, mientras que el segundo botón (Command2) está deshabilitado en el evento Form_Load.

Importante: VB Editor v.3.0 es un programa que si se modifica en él cualquier propiedad, se modificará automáticamente en el ejecutable que hayamos abierto. Lo que quiero decir es que se haga una copia de seguridad, ya que a veces al modificar una determinada propiedad VB Editor no lo hace correctamente y NO se podrá volver al ejecutable original. Por este motivo, yo utilizo VB Editor solamente para leer los datos, pero desde él no modifico nada.

Lo que voy a hacer es habilitar los dos botones y ver también cómo se puede modificar el interval del timer modificando su valor o simplemente poniéndolo a cero, ya que de este modo lo desactivaremos permanentemente.

Bueno, pues voy a abrir ejemplo7.exe desde el programa VB Editor v3.0. Nada más abrirlo nos aparecerá la ruta de en mi caso "ejemplo7.exe".
Hay que clickear dos veces sobre ella y ya aparecerá el/los formularios con los controles que hay y con un dato muy bueno: El offset donde se encuentra dicho control. ¡Muy interesante programa y gratuito!

Habilitar "Command1"

En mi caso, voy clickar sobre el primer botón: "Command1" y veré lo siguiente:

_Imagen39

Con ese enabled = Falso ya nos está indicando que el botón está desactivado en sus propiedades. Cuando se compila un programa en VB este dato se guarda como un 0 -> deshabilitado o como un 1 --> habilitado.
También sabemos que el offset de dicho botón es: 4803 (12C3) así que ya podemos ir en un editor hexadecimal a esa zona:

_Imagen40

Ahí está efectivamente toda la información importante. Voy a analizar los bytes..
Primeramente vemos el "name" del control: "Command1", seguidamente se observa el "caption" del botón: "Deshabilitado en propiedades: Enabled == False". Y a partir de aquí voy a analizar los bytes que siguen:

0004 6801 6801 0F0F 7701 0800 1100

0004
6801 -> Left
6801 -> Top
0F0F -> Width
7701 -> Height
08
00 -> Este es nuestro byte. (00 = Desactivado.)

Ya hemos visto la forma de localizarlo así que ahora voy a modificarlo y lo voy a poner 01. Lo guardo como "ejemplo72.exe" lo ejecuto y...

_Imagen41

Hay veces que el byte 00 no coincide exactamente en ese lugar, pero sabiendo que es un 00 pues se puede probar a modificar uno a uno hasta encontrarlo.. es fácil.

Habilitar "Command2"

Este botón es diferente ya que está habilitado en sus propiedades pero se deshabilita al cargar el formulario, así que hay que "echar mano" de otro programa que nos ayude a encontrar en qué parte del código lo deshabilita... "SmartCheck"
Para este ejemplo hay que entender primeramente una cosa. Cuando se deshabilita un control, realmente podemos observar que si ponemos un BP en EnableWindow en un debugger, pues veremos cómo se detiene.
En VB, y en los programas que he analizado normalmente se hace de la siguiente forma:
Se ponen dos valores en la pila y seguidamente se llama a una subrutina (CALL) que es la que desactiva el control. El primer dato que se introduce es un cero que recordemos que es desactivado. Si lo ponemos <> cero, observaremos que se habilita, con lo cual no sólo el 1 habilita el control.
El segundo dato que se pone en la pila pienso que es la ID o un identificador que utiliza VB para identificar al control, ya que he comprobado que el handle no es. Por lo tanto con esta información podemos hacer dos cosas:
-intentar modificar el primer valor que se pone en la pila y ponerlo <> 0
-nopear la call que es la que deshabilita el control.

Sabiendo ya esto, voy a ejecutar "ejemplo72.exe" en el SmartCheck. Observo lo siguiente:

_Imagen42

SmartCheck es un programa impresionantemente impresionante para analizar programas en VB.
Nos da toda la información necesaria. Nos da el evento, nos dice que desactiva un botón, nos dice qué botón es y nos indica la subrutina donde se encuentra(offset). En definitiva: Nos dice todo.

Ahora ya es sólo cuestión de analizarlo en el OllyDBG o en vuestro debugger preferido. Y voy a ir a esa dirección (sumo 400000 al offset):

_Imagen43

El programa aprovecha que el valor de EDI es cero. Es el primer valor que pone en la pila y como ya he explicado es cero.
El segundo valor: ESI es un valor que identifica al control y que si se modifica nos dará error.
Si se modifica en ejecución ese valor de EDI y se pone distinto de cero se comprueba efectivamente que el botón se habilita. Por lo tanto de eso se trata.

Como expliqué, se puede nopear la CALL en la que (en la imagen anterior) está parado o simplemente voy a sustituir el primer PUSH EDI por por ejemplo PUSH ESI ya que ESI no será igual a cero. Para el que siga sin entender esto último se trata de modificar solamente ese byte 57 (PUSH EDI) por 56 (PUSH ESI).
Supongo que se entiende, es sencillo.

De este modo ya tengo los dos botones habilitados. :-)

Modificar el Interval del timer

Como he hecho en la parte (I) y en esta parte (II), podemos utilizar varios de los programas explicados para localizar el offset del timer y ya sabiendo el valor del interval modificarlo a nuestro gusto.
En este caso he utilizado el VB Editor v3.0 y rápidamente me ha dado el offset y el valor del intervalo = 2553 que en hex = 9F9. Por el método seguido anteriormente se localiza de forma rápida y podemos modificar ese valor a nuestro gusto.
Lo más interesante de todo es que si modificamos ese 09F9 a 0000 lo que conseguimos es desactivar el timer permanentemente (a no ser que se modifique posteriormente en el código).

[karmany]

Ejemplo 08

Modificar el título de una ventana por uno más largo en VB6.
Sobre Visual Basic (III)

Antes de nada quiero hacer una pequeña introducción que el que quiera puede saltarse:
Debido a la buena acogida que ha tenido el tutorial, y la cantidad de mensajes que recibo solicitando ayuda, sigo ampliándolo con nuevas ideas. Recibo preguntas que cada vez son más complicadas, pero intentaremos hacer todo lo más sencillo posible.

Antes de comenzar, hay que tener claras bastantes cosas y releer varias veces el tute porque puede ser difícil de entender.
Ya que hay mucha gente que pregunta por este tema, voy a modificar el título de un programa compilado con Visual Basic 6 por otro título mucho más largo.



1ª FORMA:

Esta primera manera de hacerlo es la más complicada haciendo uso de una API.

Descargar el programa sol.exe (está como sol.zip) que está en el archivo .zip. El enlace está en el primer mensaje de este hilo.

El título del programa original es "Sol":

_Imagen44

y voy a modificarlo por "Título mucho más largo - karmany".

Para hacer esto, se podría intentar modificar el puntero de "Sol" pero en VB6 no es sencillo hacerlo. También se podría intentar modificar el título utilizando la misma función de VB pero también es una ardua tarea, así que, en principio se me ocurre que la forma más sencilla es hacerlo utilizando la API "SetWindowText".
SetWindowText requiere 2 datos: el puntero a la cadena "Título mucho más largo - karmany" y el handle de la ventana. Éste ultimo dato es el más complejo de encontrar pero VB6 en determinados momentos lo deja bien visible en la pila.

Bueno, sabiendo ya cómo lo voy a hacer, queda lo más importante: Y... ¿cómo se puede obtener la dirección de "SetWindowText" para poder utilizar dicha API?. Este es el dato más complicado de encontrar para todo Newbie y por este hecho se debe entender perfectamente:
Voy a insertar en la IAT (que en el programa original será toda de funciones de la librería de VB6) nuestra dirección de "SetWindowText". Por lo tanto, lo que voy a hacer es modificar la IMAGE IMPORT DESCRIPTOR la cual nos dará la dirección correcta de "SetWindowText". Como sé que habrá gente que no tiene ni idea de qué es la IMAGE IMPORT DESCRIPTOR pues me remito a los fantásticos tutoriales de Ricardo Narvaja en los que explica paso a paso qué es y para qué sirve.(Titulados: Import Tables lento y a mano). Puede ser difícil de entender si no se tiene práctica, pero voy a intentar explicarlo lo más sencillo que pueda...
Lo que voy a hacer para este ultimo caso es crear una nueva sección y ahí pondré la IID y la IAT. Para hacer esto de forma muy requetesencilla, voy a utilizar el programa ImportRE que hace siempre una labor importantísima.
De este modo, como en un programa compilado con Visual Basic 6, la IAT está normalmente en la dirección 401000 pues al cambiarla de sitio, tendré ahí espacio suficiente para hacer un injerto.

Bien con todo lo que acabo de explicar, ya estamos en condiciones de empezar:
El programa que he creado se llama "Sol.exe". No lo voy a poner de momento en descarga, pero si alguien realmente lo necesita que me lo pida.

Abro "Sol.exe" en el OllyDBG. Parado en el OEP. Voy a 401000 y veo la IAT:

Código:

00401000 DD MSVBVM60._CIcos        ; 1º dato de la IAT
00401004 DD MSVBVM60._adj_fptan    ; 2º dato de la IAT
00401008 DD MSVBVM60._adj_fdiv_m64 ; 3º dato de la IAT
....
....
00401070 DD MSVBVM60._CIexp        ;29º dato de la IAT
00401074 00000000                  ;Indica final
00401078 01000800
0040107C FA194000
00401080 FF25 20104000    JMP NEAR DWORD PTR DS:[401020] ;1º Salto a la IAT
....

Bien, para que después ImportRE nos diga que hay una función pero que no sabe cuál es voy a modificar los datos de 401078 y 40107C de este modo:

Código:

00401070 DD MSVBVM60._CIexp        ;29º dato de la IAT
00401074 00000000                  ;Indica final
00401078 77777777                  ;pongo un número cualquiera
0040107C 00000000                  ;0 para "decirle que es el final"
00401080 FF25 20104000    JMP NEAR DWORD PTR DS:[401020] ;1º Salto a la IAT

Pues ya podemos ejecutar ImportRE, seleccionamos "Sol.exe" y abajo a la izquierda ponemos los 3 datos siguientes:
OEP: 00001130 (Ya que el OEP es 00401130 y la Image Base 400000)
RVA: 00001000 (Ya la IAT comienza en 00401000)
Size:0000007C (Ya que como se ve antes, en 401078 hemos puesto 77777777)
Pulsamos en "Get Imports" y aparece lo siguiente:

Código:

+ msvbvm60.dll FThunk:00001000 NbFunc:1D (decimal:29) valid:YES
- ?FThunk:00001078 NbFunc:1 (decimal:1) valid:NO
     rva:00001078 ptr:77777777

Perfecto. Como se observa ha reconocido nuestras 29 funciones de la librería de VB y nos dice que hay una función de otra librería que no reconoce y que la dirección es 77777777 que ya habíamos preparado para tal fin. Como ya sabemos qué API necesitamos: "SetWindowTextA", pues clickeamos 2 veces  y seleccionamos dicha API. Y ya nos aparecerá lo siguiente:

Código:

+ msvbvm60.dll FThunk:00001000 NbFunc:1D (decimal:29) valid:YES
- user32.dll Fthunk:00001078 NbFunc:1 (decimal:1) valid:YES
     rva:00001078 mod:user32.dll ord:0287 name: SetWindowTextA

Perfecto. Ahora pulsamos en "Fix Dump" seleccionamos "Sol.exe" y nos crea satisfactoriamente "Sol_.exe". El trabajo que hace ImportRE es fantástico.

TRUCO PARA HACERLO FUNCIONAR

.
De este modo hemos creado ya una nueva sección, y ahí hemos puesto la IID y la IAT.
Si se ejecuta da error, así que después de analizarlo detenidamente descubrí que el problema es culpa de un dato: "Bound Import". Para solucionarlo, hay que abrir "Sol_.exe" en un editor de PE y modificar tanto el dato "Bound Import RVA" como Bound Import Size" y poner los 2 a CERO. Ya funciona "Sol_.exe".

Ahora ya se observa que en 401000 ya no está la IAT y podemos utilizar este espacio para poner el código que nosotros queramos.

Lo primero que hago es ver qué eventos hay. Yo utilizo esta vez VB Decompiler Lite y obtengo que en 4019B0 comienza Form.Load.
Ahora lo que me interesa es buscar el handle de la ventana a la que quiero modificar el título.
Me pongo al final de esta subrutina(Form.Load):

Código:

...
00401A09 POP EDI
00401A0A POP ESI
00401A0B MOV DWORD PTR FS:[0],ECX
00401A12 POP EBX
00401A13 MOV ESP,EBP
00401A15 POP EBP
00401A16 RETN 4

Pongo un Breakpoint(BP) por ejemplo en 401A09. Pongo también un BP en la API "CreateWindowExA" y voy pulsando F9 hasta que para en "CreateWindowExA" y es por nuestra ventana: (Windows name: "Sol"). Traceo hasta el RET de "CreateWindowExA" para observar el handle y veo que en mi caso el handle (registro eax) es: 001105F2
Pulso F9 y para en 00401A09 y observo la pila encontrándome lo siguiente:

Código:

ESP    0013FB20
ESP+4  0013FBF0
ESP+8  00000001
ESP+C  00CF49C8
ESP+10 001105F2

¡Umm! parece ser que si paro en 401A09, tengo en ESP+10 el ¡handle de mi ventana!. Interesante. Pues con este dato ya podemos hacer el injerto.
Así que modifico el original código de 00401A09 por lo siguiente:

Código:

00401A09   JMP 00401000
00401A0E   NOP
00401A0F   NOP
00401A10   NOP
00401A11   NOP
00401A12   POP EBX
00401A13   MOV ESP,EBP
00401A15   POP EBP
00401A16   RETN 4

Me he comido 3 instrucciones.

Y en 00401000 hago el siguiente injerto:

Código:

00401000   PUSHAD                          ;Guardo todos los registros
00401001   PUSH 401020                     ;1º dato "SetWindowTextA" Texto = "Título mucho más largo - karmany"
00401006   PUSH DWORD PTR SS:[ESP+34]      ;2º dato "SetWindowTextA" handle ventana
0040100A   CALL NEAR DWORD PTR DS:[404078] ;Call "SetWindowTextA"
00401010   POPAD                           ;restauro todos los registros
00401011   POP EDI                         ;1ª instrucción que me comí
00401012   POP ESI                         ;2ª instrucción que me comí
00401013   MOV DWORD PTR FS:[0],ECX        ;3ª instrucción que me comí
0040101A   JMP 00401A12                    ;vuelve al código

Se observa que tras hacer los push el dato del handle que era [esp+10] se ha convertido en [esp+34].
También hay que observar que la dirección [404078] es de SetWindowTextA que es donde está la IAT.
Finalmente sólo queda insertar nuestro texto en 401020, terminado en cero:

Código:

00401020  54 ED 74 75 6C 6F 20 6D 75 63 68 6F 20 6D E1 73  Título mucho más
00401030  20 6C 61 72 67 6F 20 2D 20 6B 61 72 6D 61 6E 79   largo - karmany
00401040  00               

                                .

Y asunto terminado.

El ejemplo final es el siguiente:

_Imagen45

Si quieres analizar el resultado puedes descargar cómo me ha quedado a mí:
Descargar el programa sol_2.exe (está como sol_2.zip) que está en el archivo .zip. El enlace está en el primer mensaje de este hilo.


Ya sé de antemano, que esto que acabo de explicar no es nada sencillo, pero es la forma que se me ha ocurrido de hacerlo.



2ª FORMA:

Tras haber publicado la 1ª FORMA recibí varios mensajes en los que me comentabais que era posible hacerlo de una manera más sencilla, usando determinados programas que ya hemos analizado en ej. anteriores.

Realmente existen programas como VBReformer, del que ya hablé en el ejemplo 6, que nos permiten modificar directamente el título de la ventana que tenemos por defecto. Es decir, podemos abrir el programa en VBReformer, observar todo lo que ha analizado y tras seleccionar en el panel izquierdo el formulario que deseamos, nos aparecerá en el panel derecho los controles y propiedades de dicho formulario y podremos modificarlos. Después simplemente guardamos.

Realmente para una persona que no se quiere complicar o no tiene suficientes conocimientos para entender el ejemplo que propuse, pues es una muy buena opción y podría ser la primera opción que deberíamos usar.

Por contra, VBReformer no siempre compila adecuadamente o no siempre puede abrir todos los programas. Además si el título se modificara en algún evento, tampoco nos valdría... Bueno, todo es cuestión de probar, de gustos y de lo que nuestra imaginación proponga- Las dos formas explicadas son válidas.


Para cualquier duda...

[karmany]

Ejemplo 09

Sustituir recursos

Muchos programas tienen los recursos en otra sección donde los editores de recursos no pueden acceder (estos suelen estar normalmente en la sección .rsrc), por ejemplo como expliqué al sustituir una imagen en un programa hecho en Visual Basic (ejemplo 6). Realmente es un trabajo costoso, no por no saber hacerlo, sino porque hay que ser muy preciso: no podemos añadir ni un sólo byte de más y no podemos equivocarnos...

Como hemos visto, para programas compilados por ej. en Visual Basic podemos valernos de determinadas herramientas, pero si tenemos un programa hecho en un lenguaje indeterminado y queremos por ejemplo modificar una imagen o la música...¿cómo lo podemos hacer?

Yo hace tiempo lo hacía todo a mano, pero conocí una gran herramienta que nos va a facilitar enormemente el trabajo. Se trata del programa:
MultiExtractor. Su página web es la siguiente:
http://www.multiextractor.com/

¿Qué podemos hacer con este programa?
MultiExtractor es capaz de "extraer" de determinados archivos los siguientes recursos:
JPG, BMP, GIF, PNG, PCX, TGA, ICO, CUR, TIFF, EMF, WMF, XM, MOD, WAV, OGG, MP3, MID, S3M, AVI, MPG, DAT, ASF, MOV, SWF, BIK, SMK y nos permite asimismo poder sustituirlos. De este modo ya no hay que preocuparse de si el editor de recursos no puede modificar determinado recurso y nos permite sustituir cualquiera con un par de clicks de ratón.
Un programa muy útil y recomendable. El principal inconveniente es que es de pago.

Antes de poner un simple ejemplo, debemos saber que no podemos sobrepasar el tamaño del recurso a modificar. Esto es lógico y MultiExtractor nos avisará.

Voy a hacer un simple ejemplo con un programa cualquiera... para ello me he fabricado un ejecutable con VB6 al que le he añadido solamente en la interfaz una imagen en formato jpg. El que quiera que lo descargue para practicar:

Descargar el programa ejemplo9.exe que está en el archivo .zip. El enlace está en el primer mensaje de este hilo.

Este es el programa (ejemplo9.exe):

_Imagen46

Como he comentado antes, si lo abris desde un editor de recursos será imposible modificar la imagen... ya he dicho muchas veces el porqué de esto.
Para sustituir la imagen por otra habría que hacerlo a mano como expliqué en el ejemplo 6, pero es un trabajo muy preciso... así que vamos a hacerlo rápidamente con Multiextractor.
Lo primero es trabajar con una copia de seguridad, ya que se modificará el archivo original.
Abro ejemplo9.exe con Multiextractor y encuentra de forma eficaz nuestra imagen jpg:

_Imagen47

Ahora simplemente pulsamos en la imagen jpg con el botón derecho del ratón y seleccionamos: "Import from..."
Seguidamente seleccionamos la imagen que queramos y ya está... si ejecutamos otra vez ejemplo9.exe veremos la imagen nueva que nosotros hayamos puesto:

_Imagen48

He querido hacer este ejemplo de forma general, sin pensar en el compilador. Por supuesto, para un programa compilado con Visual Basic 6 podemos hacer uso de VReformer para sustituir una imagen... pero la idea es tener una visión generalizada para otros compiladores...

[karmany]

Ejemplo 10

Redimensionar matrices en VB6.
Sobre Visual Basic (IV)
Muchas veces en determinados programas, sobre todo en programas obsoletos o que ya no se desarrollan es necesario aumentar el rango de la matriz.
Esto puede resultar muy útil, ya que las matrices normalmente no están redimensionadas en ningún evento, están (normalmente) declaradas en las declaraciones de cualquier formulario o módulo y ningún programa te indica dónde están: ni VBReformer, ni VB decompiler ni ningún otro.

En este ejemplo que he hecho, he declarado una matriz: Private variable(1) As String que se compone de variable(0) y variable(1).
Está declarada dentro de las declaraciones del formulario principal.

Os voy a mostrar cómo se puede redimensionar hasta FF ==> 255... cómo encontrar ese byte escondido.

Lo primero es descargar el programa que he hecho:
Descargar el programa ReDimMatriz.exe (está como ReDimMatriz.zip) que está en el archivo .zip. El enlace está en el primer mensaje de este hilo.

Ejecutarlo, examinarlo con Ingeniería Inversa. Es muy sencillo. Si pulsáis el primer botón nos mostrará la dimensión de la variable empezando por 0.
Si se pulsa el botón segundo mostrará variable por variable.

_Imagen49

¿Cómo se rellena una matriz de string desde VB6?
Pues es muy sencillo, porque para matrices de cadenas(strings) hace uso de la función __vbaStrCopy, que como su nombre indica copia una cadena de texto. Y este ejemplo es así.

Vamos a analizarlo. Poner un BP en 403477, ejecutar el programa en un depurador(OllyDBG por ej.), pulsar el segundo botón y se detendrá ahí.

Código:

00403477   .  FF15 74104000          call near dword ptr ds:[401074]                  ; MSVBVM60.__vbaStrCopy

Si vemos el registro ecx, en mi caso es 0015ef08. Si dumpeamos ese valor veremos el primer dword que se reserva para la matriz. Ese valor dword lo rellena VB con una dirección donde irá la cadena de texto.

Antes de pasar por la función  __vbaStrCopy:

Código:

0015EF08  00 00 00 00 00 00 00 00  ........

Después de pasar por la función __vbaStrCopy:

Código:

0015EF08  54 A3 16 00 00 00 00 00  T£.....

Y si dumpeo ese valor: 0016A354 vemos esto:

Código:

0016A354  76 00 61 00 72 00 69 00  v.a.r.i.
0016A35C  61 00 62 00 6C 00 65 00  a.b.l.e.
0016A364  28 00 30 00 29 00 00     (.0.)..

que es la cadena de texto que se cargará en en variable(0).

Bien, ¿qué ocurre?
Pues variable(1) está definida en las declaraciones del formulario y no se puede redimensionar así como así. Como variable(1) son dos: variable(0) y variable(1) pues en el código del programa existe un byte 02 que es el que hay que buscar...
Sólamente modificando ese byte 02 a cualquier otro valor redimensionamos la matriz. De esto se trata: de encontrar ese byte 02.

Para encontrarlo, voy a poner un Hardware Breakpoint en el dword de la variable(1) que es la segunda string. Se entiendo ¿no?, es decir, voy a poner un HBP on write dword en 0015ef0c. Reinicio OllyDBG y veo cuándo el dword de 0015ef0c se pone a 0.

Ejecuto el depurador, veo que se detiene por HBP pero el valor no es cero. Sigo ejecutando y veo que se detiene y que el valor de 0015ef0c se pone a cero!!! Aquí está.
A veces mirando los registros se puede observar de dónde se está leyendo, pero en este caso no se puede saber, así que se me ocurre ver la pila y observo lo siguiente:

Código:

0012F728   0015F0C0
0012F72C   0015F0A8
0012F730   004030B8  Proyecto.004030B8

004030B8?! podría ser éste la dirección que buscamos???
Voy a dumpear a ver:

Código:

004030B0  02 00 00 00 00 00 00 00  .......
004030B8  08 00 00 00 26 00 00 00  ...&...
004030C0  55 00 42 00 6F 00 75 00  U.B.o.u.

Como se puede observar, el byte que buscamos es el que está en 004030B0.

Así que vamos a modificar ese bytes y ponemos el valor que queramos y veréis los resultados:

_Imagen50

_Imagen51

Aprovechando una herramienta mía, voy a mostrar cómo modificar el byte rápidamente desde el ejecutable original que he puesto en descarga. Haré uso de File Location Calculator v0.3.2, que se puede descargar gratuitamente desde aquí:
http://tuts4you.com/download.php?view.2790

Arrastramos el programa sobre File Location Calculator, señalamos virtual address y pegamos ahí la dirección 004030B0. Simplemente pulsamos Enter o pulsamos el botón calcular. Ya se verá en los bytes el byte 02. Ahora sencillamente pulsamos el botón Editor hex, modificamos el byte y guardamos. Imagen:

_Imagen52

Gracias a la colaboración (lo ha hecho el todo) de kcr_4u, es posible descargar el tutorial en pdf, hasta el 5º ejemplo (aunque está desactualizado y no se corresponde con el original):

Tutorial en pdf

GRACIAS krc_4u POR TU AYUDA.

Texto y enlaces revisados: Todos los textos y enlaces fueron corregidos y actualizados el día 13 de marzo de 2011. Asimismo todas las imágenes tienen están numeradas y todo tiene copia de seguridad.


Si alguien observa alguna cosa que debiera modificar o añadir, comentario o algún enlace roto, mandarme un mp..
Un saludo a todos.