Foro de elhacker.net

Primeramente decir que este tutorial está encaminado principalmente a saber modificar los recursos  del programa que queremos analizar. Sin embargo, a veces modificar un recurso requiere tener conocimientos de ingeniería inversa... pero no siempre...
 
Hace ya bastante tiempo, en el foro de Uptodown que ya ni existe, hice un sencillo tutorial del manejo de un programa para editar recursos: Resource Hacker 3.4.0.79.
Nada más publicar aquel tutorial, recibí muchos mensajes de gente que me pedía ayuda para modificar los recursos de algunos programas, cosa que a veces era muy complicada y muchas veces imposible (desde un editor de recursos, sin usar debugger y dada mi poca experiencia de entonces).
Ese tutorial lo modifiqué con el tiempo guardándolo en mi ordenador, agregando información también de otros programas y de la experiencia que iba adquiriendo, y hoy después de todo este tiempo, y después de que varias personas hace poco me hayan pedido que les envíe el tutorial vuelvo a reeditarlo para colgarlo aquí.

Todos estos programas son muy parecidos en su manejo, así que con este tutorial lo que pretendo es:

1) Saber qué son los recursos de un programa.
2) Por qué es interesante poder modificarlos.
3) Explicaré con bastante detalle el manejo de un programa y posteriormente explicaré algunas características muy interesantes, de otros dos programas que también utilizo mucho.
4) Cuando un editor de recursos no puede modificar un recurso, ¿qué puedo hacer?


Para que no se pierda ninguna descarga con los hosting gratuitos y temporales, os pongo este enlace a mi Web de un archivo zip bien ordenado con todas las descargas de este tutorial:
Enlace (http://www.karmany.net/index.php/ingenieria-inversa/21-como-modificar-programas/8-como-modificar-programas-i)

En los ejemplos 1 y 2, he usado un antiguo packer denominado Embryo Patcher. Dicho software es actualmente considerado por los antivirus como malware, aunque de forma errónea (falsos positivos). Pero como son necesarios para seguir el tutorial y como alguno me lo ha solicitado, os dejo un enlace con un archivo rar cifrado en descarga:
Descarga ejemplo 1 y 2 (https://mega.co.nz/#!fgwwwTKZ!bCfn-1WZmSdxJOij_fG7yQ2F--YPh7XkISRO4r7OA3I)
Contraseña del archivo rar: elhacker.net

karmany

Los recursos son elementos de la interfaz que proporcionan información al usuario. Los mapas de bits, los iconos, las barras de herramientas, los cursores son ejemplos de recursos.
Con estos programas pues, lo que podemos hacer es ver, modificar, renombrar, añadir, borrar y extraer recursos de ejecutables EXE (algunos a 32 bits otros a 16), (DLL y OCX). Se pueden ver los cursores, iconos, bitmaps, imágenes GIF, AVI y JPG. También se pueden escuchar los recursos de audio WAV y MIDI y ver o modificar los Menús, Diálogos, Mensajes, Strings, etc.
A veces estos programas no encuentran todos los recursos, y por lo tanto estas veces será imposible modificarlo. Otras veces un programa reconoce un recurso que otro programa no encuentra.

Seguro que habrá alguno que todavía no entiende qué es un recurso, voy a poner el primer ej.:
Imaginemos un programa que tiene un menú y al pulsar en File vemos lo siguiente:


Vemos que el menú File consta solamente de Open…
Podemos hacer una cosa sencilla por ej. que es modificar el idioma a nuestro gusto y queda por ejemplo así:


Ahora ya se entiende mejor, ¿verdad?

¿Dónde se guardan normalmente los recursos?
Normalmente se guardan en la sección de recursos. Si analizas un ejecutable o un archivo PE con un visor de encabezado (visor PE) verás que en la mayoría de ellos aparece una sección con el nombre .rsrc. En esa sección es donde los programas editores de recursos buscan los mismos.

Para los programas hecho en NET es un tanto diferente. Existen editores de recursos capaces de modificar ciertos recursos para estos programas, pero no es tan sencillo como en los de código nativo. Pondremos algún ejemplo.

La finalidad que más he oído repetida es para modificar el idioma a un programa. Es una idea interesante. Mi experiencia y la de otras personas que se lo han llegado a tomar también en serio es que es un trabajo muy pero que muy costoso..
El que haya traducido un programa entero y luego haya visto recién sacada una versión posterior a la traducida, sabe de lo que hablo.

Pero hay muchísimas otras finalidades:
-Imaginemos un programa gratuito y sin licencia (que es mío y me acabo de inventar) que cada vez que lo abrimos nos aparece una ventana que dice:


Bastará que podamos encontrar dicha ventana y la suprimamos (y que se pueda claro..).

-Podemos dar a nuestros programas nuestro toque personal.. podemos insertarle alguna imagen que nos guste, nuestro nombre etc…

-Hay mucha gente también que se dedica a modificar la interfaz de un programa y luego hacen suyo el trabajo de los demás..
Voy a explicar esto último con un ej. muy sencillo:
Por ej. tengo este programa:


Muy sencillo que pone que introduzca una password..
Voy a modificarlo rápidamente y queda esto otro:


Impresionante y es el mismo programa de arriba..
-En fin, podéis hacer las cosas que vuestra imaginación proponga y la limitación de estos programas tengan.

¡Vamos a empezar con el primer programa!.

Toda la información de este tutorial es personal y de mi experiencia con los programas, también he añadido algunas cosas de los archivos de ayuda. Todo este link se va modificando y corrigiendo errores enlaces e imágenes.
   
Antes de comenzar:
 “Como todos sabemos, los programas son propiedad de sus desarrolladores y éstos conceden autorización para el uso de sus aplicaciones bajo unas condiciones o términos que, normalmente, vienen reflejados en la Licencia del programa. Si en la citada licencia viene expresamente prohibido la traducción del programa, debemos de abstenernos de confeccionarla, salvo que solicitemos (y obtengamos) la pertinente autorización de aquellos que legalmente estén capacitados para concederla.”

En definitiva, no hagáis cosas ilegales. karmany

Resource Hacker versión 3.4.0.79 y Resource Hacker (beta) versión 3.5.2

Bueno, antes de todo decir que este editor de recursos ya tiene varios bugs que el autor no quiere solucionar, pero que para explicar el funcionamiento de los editores de recursos, pues es una herramienta muy fácil de utilizar.

Su página oficial es:
http://www.angusj.com/resourcehacker/ (http://www.angusj.com/resourcehacker/)
Realmente la versión con la que he hecho este tutorial es la versión 3.4.0.79, pero el autor hizo una excepción y saco una nueva versión el 19 de diciembre de 2009 (v.3.5.2) para analizar recursos a 64bits.
Resource Hacker v.3.5.2:
http://www.angusj.com/resourcehacker/reshack_setup.exe (http://www.angusj.com/resourcehacker/reshack_setup.exe)

Resource Hacker v.3.4.0.79 (original en inglés):
http://delphi.icm.edu.pl/ftp/tools/ResHack.zip (http://delphi.icm.edu.pl/ftp/tools/ResHack.zip)

Resource Hacker v.3.4.0.79 en español:
http://www.karmany.net/index.php/ingenieria-inversa/32-herramientas/23-resource-hacker-34079-spanish (http://www.karmany.net/index.php/ingenieria-inversa/32-herramientas/23-resource-hacker-34079-spanish)
Un programa que seguro que va a quitar muchas horas de sueño a muchos.

Para este tutorial he usado la v.3.4.0.79 traducida a español, que te he puesto en descarga.

Para que todo el mundo pueda seguir este tutorial, se me ha ocurrido la idea de trabajar con el mismo ejecutable de este programa. Así pues, lo primero que haremos y es lo que hay que hacer siempre es copiar el archivo a modificar, en este caso “ResHacker.exe” y lo pegamos por ejemplo en el escritorio. Yo le he cambiado el nombre para no equivocarme: “copia.exe”.

PD. Quisiera comentar que le mandé al autor de Resource Hacker varios emails pidiendo que siguiera con el proyecto y corrigiera los bugs. Como vi que Angus ha seguido programando, a mediados de marzo de 2007 se lo volví a pedir por última vez y me respondió lo siguiente:
-"No, I have no plans to update Resource Hacker. Sorry.
Angus"
Una lástima, no quiere ni dejar el código fuente para que otros puedan seguir el proyecto. Bueno, respeto su opinión aunque no la comparto y ya no se lo volveré a pedir más.

Ejecutamos el programa “ResHacker.exe”.
Vamos a echar un vistazo general a su ventana de inicio:


Observamos primeramente que la pantalla está dividida en dos:
Izquierda en blanco, derecha en un color crema.

Vemos también una sencilla barra de herramientas:
Archivo, Editar, Ver, Acción, Ayuda.
Esto no merece más explicación, no voy a adentrarme en todos sus submenús, ya se irán viendo.

El programa puede abrir archivos .exe .dll .ocx .cpl .scr y .res. Archivos ejecutables win32. Las limitaciones vienen bien explicadas en su página oficial.

Vamos a darle a abrir y seleccionamos el programa “copia.exe”:


Nos han salido a la izquierda 9 carpetas. Esas carpetas dependen del archivo y del programa con que ha sido compilado el archivo: Visual Basic, C++ , Delphi, etc., aunque normalmente algunas suelen ser similares.

Estas carpetas contienen lo que el programa llama recursos. (Resource).

Podemos encontrar algunas de las siguientes carpetas con los siguientes recursos:

GIF o AVI: Aquí encontraremos como su nombre indica los archivos .gif o .avi que encontraremos en el programa. Como ejemplo, en el programa que hemos abierto, vamos a ayuda --> acerca de… y encontraremos un .gif (Un martillo golpeando las letras Resource Hacker).

Cursor y Cursor Group: Son los cursores que hay en el programa. Como ejemplo, pon el puntero del ratón entre la línea que separa la parte de color blanca y la parte de color crema.

Icon e Icon Group: Son los iconos del programa. Como ejemplo, el icono del ejecutable y el icono que vemos en la esquina superior izquierda de la ventana.

Bitmap: Como su nombre indica son los archivos en mapa de bits. Son las imágenes que el programa utiliza. Como ejemplo abrimos la carpeta Bitmap y vamos a SMALLICONS y pulsamos en 0. Ahí encontramos las imágenes de carpeta cerrada, abierta y la imagen de color amarilla o blanca de si estamos viendo un recurso o no.

String Table: Son las frases que aparecen cuando el programa identifica algún error, problema o indica algún aviso. Como ejemplo vamos a String Table y a 4077. A la derecha veremos en 65219: "Los recursos han sido modificados, ¿desea guardar los cambios?". Ésta es la frase que aparecerá cuando modifiquemos un recurso y por ejemplo cerremos el programa sin haberlo guardado.

RCData: Aquí están los cuadros de diálogo. Este apartado es característico de los programas realizados con Delphi (como el Resource Hacker). Como ejemplo vamos a RCData y a TABOUTFORM. Ahí encontraremos en la 6º línea Caption = 'Acerca de'. Este “acerca de” es el título de la ventana que hay en ayuda --> acerca de…

Versión Info: Seguro que se os habrá escapado algún detalle… Cuando pulsáis en el icono del ejecutable con el botón derecho y seleccionáis propiedades o cuando dejáis el icono del ratón sobre el icono del ejecutable, veis que muchas veces se indica nombre del programador versión… etc…pues aquí las tenéis para modificarlas a gusto.

Hasta aquí se ha descrito el contenido de las 9 carpetas, pero como he señalado en el “Resource Hacker” pueden aparecer otras carpetas:

Dialog: En esta carpeta encontraremos los cuadros del diálogo del programa. Pero lo bueno que tiene esto es que en nuestro programa “Resource Hacker” aparecerá al lado del botón “Compilar Script” otro que dice “Mostrar (u ocultar) Diálogo”. De esta forma para modificar el tamaño de las ventanas, botones etc… podremos hacerlo gráficamente.

Hay algunas carpetas más que aparecen, algunas con valores hexadecimales que no contienen información aparente. Otras carpetas contienen también información importante, pero explicando las ya descritas yo creo que es más que suficiente para adentrarnos en el programa

Lo primero ejecutamos de nuevo el programa “ResHacker.exe”.
Vamos a archivo --> abrir y abrimos el “copia.exe”  que teníamos en el escritorio.


La primera carpeta que vemos a la izquierda es GIF (o AVI). Aquí aparecen los archivos .gif y .avi como he señalado más arriba.
La abrimos al máximo: GIF, 128 y pulsamos en el 0, veremos que el recurso es un .gif de Resource Hacker en el que un martillo golpea a las letras.
Este gif aparece en ayuda --> acerca de… (Comprobarlo).
 
-Podemos guardar el .gif en nuestro disco duro para, por ejemplo, editarlo:
Pulsamos con el botón derecho en el recurso (0) y en el menú que sale, la tercera opción es: Guardar [GIF : 128 : 0], pulsamos y la guardamos donde queramos.

[GIF : 128 : 0] (esto nos indica el nombre “128”, el tipo “GIF” y el lenguaje “0” del recurso).

-Una vez retocada o cuando tengamos otro .gif que queramos usar, volvemos a pulsar con el botón derecho y damos a “reemplazar recurso”, en la siguiente ventana señalamos “abrir archivo con nuevo recurso”, elegimos el archivo .gif que queremos insertar y después debemos rellenar los dos primeros campos tal y como lo tenemos nombrado a la izquierda, es decir, en tipo de recurso escribiremos GIF y en nombre de recurso escribiremos 128. Le damos a reemplazar y ya lo tenemos. Para comprobarlo podemos “guardar como” ejemplo.exe (acordarse de poner la extensión .exe) y ejecutamos el nuevo ejemplo.exe.
Vamos a Ayuda --> acerca de… y veremos cómo ha cambiado el dibujo... ¿curioso verdad?


Problemas que he encontrado: dará fallos en la ejecución si se cambia el tipo, nombre o lenguaje del recurso.

En este ejemplo que he puesto, el archivo que tiene que reemplazarse tiene que ser .gif y da igual el número de píxeles y el tamaño. Pero es aconsejable que sean similares para poder verlos correctamente. Yo lo que he hecho ha sido crear una imagen con un programa editor gráfico (podéis si no retocar la imagen del programa o utilizar una vuestra) y después grabarla como .gif.



En los iconos y cursores la información del recurso está dividida en dos tipos:
“Cursor” y “Cursor group” por un lado e “Icon” e “Icon group” por otro lado.
Se puede observar perfectamente esto en la parte de la izquierda.

Cada icono o cursor puede contener varias imágenes relacionadas. Ej.
16 píxeles x 16 píxeles (16 colores)
32 píxeles x 32 píxeles (256 colores) dependiendo del tamaño y resolución del color se utilizará un icono u otro. Por ejemplo, el icono para ejecutar el programa no tiene el mismo tamaño ni resolución que el que hay en la esquina superior izquierda de la ventana.

-El “Icon group” contiene la información de un icono: nombre de la imagen, tamaño de la imagen y resolución del color.
-El “Icon” contiene la imagen real.

Para cambiar un icono: Vamos p.ej. a Icon Group --> MAINICON--> 3081 pulsamos con el botón derecho y seleccionamos reemplazar recurso. No tiene más complicación. Elegimos el que queremos (veis que se pueden seleccionar .exe etc…). Ahora podemos ver cómo se ha modificado “Icon” e “Icon Group”.
Para ver los resultados “guardar como” y veréis ya primeramente cómo ha cambiado el icono para ejecutar la aplicación.

Para cambiar el“Cursor” hacemos lo mismo. Lo que pasa es que aquí he encontrado algún que otro problema. Alguna vez he intentado cambiar algún cursor por otro que contenía algún programa .exe, y al ejecutarlo, me ha dado error en la aplicación. Así que si cambiáis algún cursor ¡probar que os funcione!.

Tenéis bastantes cursores en Windows --> cursores y cursor. Hay también muchas utilidades para crear vuestros propios .cur y utilizarlos.
Para crear iconos hay muchos programas gratuitos. Ejemplos:
http://greenfish.xtreemhost.com/downloads.php (http://greenfish.xtreemhost.com/downloads.php)
http://icofx.ro/ (http://icofx.ro/)
http://www.conware.org/products/ia/about.php (http://www.conware.org/products/ia/about.php)

Puedes igualmente reemplazar las imágenes. El mejor consejo aquí es que pruebes por ejemplo en Bitmap --> SMALLICONS y cambies la bmp por otra (botón derecho, reemplazar recurso). Estos iconos son de 16 x 16 pixels. En total el dibujo es de 64 x 16 pixels. Así que aunque sea complicado, para hacerlo bien hay que hacerlo en ese tamaño.
Puedes sino editar esa .bmp. Para esto tienes que guardarla en el disco duro. Botón derecho y guardar. A mi no me ha dado ningún problema incluso insertándole imágenes de mucho mayor tamaño y resolución.
En mi ejemplo he “jugado” con unas palabras, tú puedes intentar cualquier otra cosa que se te ocurra. Este es el resultado:


Para modificar imágenes o gráficos tenemos el archiconocido programa GIMP:
http://www.gimp.org.es/ (http://www.gimp.org.es/)

Para modificar la información vamos a hacer un ejemplo:
Abrimos String Table --> 4077 y pulsamos en 0. Vemos que a la derecha en 65218 sale “¿Está seguro que quiere borrar recursos?”, todo lo que hay entre comillas se puede cambiar y variar el tamaño.
Poner lo que queráis. Yo he puesto: “Soy karmany”. Ahora le damos al botón de arriba “Compilar Script”.
Si no da ningún error ya lo tenemos. Para comprobarlo vamos a “guardar como”, ponemos por ej. ejemplo.exe y lo guardamos. Lo abrimos desde su icono ejemplo.exe y vamos a archivo abrir y abrimos “copia.exe”. Abrimos GIF --> 128 -->0, pulsamos con el botón derecho y decimos borrar recurso. Veréis lo que sale…


Esto sólo lo hace la primera vez que intentamos borrar un recurso, si aceptamos después ya no sale.

Hay que saber que:
-No cambiar nada que no haya entre comillas.
-Los símbolos % no hay que borrarlos ni cambiarlos de sitio ni borrar la coma que hay detrás ni las letras que van detrás pegadas.(%A0)
-El símbolo & significa que la letra que va detrás de este símbolo es el acceso rápido para el programa. En un mismo menú no puede ir la misma letra. La letra va subrayada.
-Como habréis podido observar hay mucha información que no deja cambiarla al pulsar en Compilar Script, y abajo sale error, ya explicaré más adelante cómo se puede intentar cambiar. También hay muchísima información que probablemente no veamos nunca, así que si queréis traducir un programa mi consejo es que traduzcáis lo imprescindible solamente.
-Para buscar recursos tenemos en el menú ver --> buscar texto. La verdad que a mi me resulta muy útil.



Aquí aparte de cambiar el texto, puedes cambiar el color, subrayado etc…este es el apartado que más me gusta.

Vamos a por el primer ejemplo:
Vamos a RCData --> TABOUTFORM y pulsamos sobre el 0. Ya os he explicado en el apartado anterior cómo cambiar el texto, así que podéis cambiar el “acerca de“ que hay en la sexta línea y que es el título de la ventana de ayuda --> acerca de. Pulsáis después Compilar Script, (siempre que cambiéis algo hay que pulsar Compilar Script) guardar cómo, no olvidar la extensión .exe y probar la aplicación.

Para variar otras características hay que entender un poco más:
Cada ventana, recurso etc… en este ejemplo empieza por object y termina por end. Si os fijáis arriba del todo (en RCData --> TABOUTFORM y pulsamos sobre el 0) pone: “object AboutForm: TAboutForm” que significa que va a empezar a definir la ventana de ayuda. El end lo tiene abajo del todo (es el último), es decir, que todo lo que hay entre “object AboutForm: TAboutForm” y end corresponde a los datos que hay en la ventana de ayuda “acerca de”.

Desde arriba todos los datos que veis hasta “TextHeight = 14” definen las características de la ventana, algunas de ellas como:
Left = 209, Top = 251, ClientHeight = 205, ClientWidth = 296 que indican respectivamente la posición en la horizontal, posición en la vertical, anchura y longitud de la ventana.
A veces es posible cambiar estos valores, pero mi experiencia dice que suelen dar bastantes errores. Para evitar estos errores yo lo que hago es compilar “programando” los textos yo mismo (esto está explicado un poco más abajo). Un valor de ejemplo que podéis compilar es ClientHeight=2 y veréis cómo cambia la ventana. Si ponéis otros valores y compiláis, el error os lo dará al intentar ejecutar la aplicación:
Error… no es una aplicación win32 válida…

Vamos a por otro objeto, el siguiente:

object Label3: TLabel
Left = 27
Top = 128
Width = 241
Height = 15
Cursor = crHandPoint
Caption = 'http://rpi.net.au/~ajohnson/resourcehacker'
Font.Charset = DEFAULT_CHARSET
Font.Color = clBlue
Font.Height = -12
Font.Name = 'Arial'
Font.Style = [fsBold, fsUnderline]
ParentFont = False
OnClick = Label3Click
End

-El “object Label3: TLabel” nos dice que va a definir un control Label (es un texto que no puede ser modificado por el usuario, cuando se ejecuta el programa).
-Las 4 siguientes líneas indican la posición como he explicado antes. (Aquí no me deja cambiarlas).
- Cursor = crHandPoint indica el cursor que va a tener cuando pasas el icono del ratón sobre el texto.(En este caso es una mano, indicando que es interactivo).
-Caption = es el mensaje.
-Font.Color = clBlue indica el color del texto. Color azul.
-Font.Height = -12 indica el tamaño. Mayor número mayor tamaño.
-Font.Name = ‘Arial’ es el tipo de letra.
-Font.Style = [fsBold, fsUnderline], indica las características del texto: Bold es negrita y underline es subrayado.
-OnClick = Label3Click activa para que cuando pulsemos (hagamos clic) sobre el texto haga una determinada función.

Bueno pues viendo lo que tenemos aquí, vamos a hacer nuestra pequeña programación en texto!! Así podremos poner el texto que queramos y donde queramos sin que nos dé ese error tan molesto de "no es una aplicación win32 válida..!!" (nota: esto de no es una aplicación válida suele aparecer al modificar ciertos recursos y guarda con el editor de recursos. Normalmente suele ser que no se ha modificado el encabezado correctamente. Esto que se explica seguidamente es para evitar este comportamiento del editor de recursos de una forma sencilla):

Lo primero es definir un texto:
“object Label9: TLabel” y ahora le pongo las características que yo quiero y en total me queda así:

object Label9: TLabel
Left = 0
Top = 0
Width = 241
Height = 15
Cursor = crDrag
Caption = 'Esto es una prueba'
Font.Charset = DEFAULT_CHARSET
Font.Color = clred
Font.Height = -20
Font.Name = 'Verdana'
Font.Style = [fsItalic]
ParentFont = False
End
Ahora lo que tenéis que hacer es insertar todo esto. Yo lo he insertado detrás de “TextHeight = 14”. Como si trabajarais con el bloc de notas. Luego lo compiláis y probáis la aplicación.
¡Impresionante verdad!.


En este punto yo sé que más de uno se va a animar haciendo muchísimas cosas más, pero lo dejo en vuestra imaginación.




Es muy curioso cómo actúa el programa Resource Hacker con los recursos de Dialog.
Como ejemplo voy a intentarlo con un archivo que espero tenga todo el mundo.
Primeramente haremos una copia de seguridad. Vamos a:
-Disco duro --> archivos de programa --> Windows Media Player --> y hacemos una copia del archivo ejecutable: “setup_wm.exe”.

Abrimos la copia con el Resource Hacker.
-Vamos a Dialog --> 51 y pulsamos en 3082. ¿Veis el botón que os he dicho antes?: “mostrar u ocultar diálogo”. En este caso ocultar diálogo:


Pulsadlo para que veáis lo que hace. Pues esa ventana que pone Iniciando descarga, la podéis modificar a vuestro gusto. Podéis pinchar sobre las dos barras de descarga y sobre las letras iniciando descarga y ponerlas donde vosotros queráis.
Aquí porque no salen botones (botones de aceptar, cancelar etc…), pero podéis pinchar igualmente sobre ellos y modificar la posición como queráis.

Esta es una de las maneras para modificar los recursos, pero podemos hacerlo de otras formas.
Otra forma es variar el código que en este caso es:

51 DIALOGEX 0, 0, 399, 134
STYLE DS_NOFAILCREATE | WS_CHILD
EXSTYLE WS_EX_RTLREADING | WS_EX_CONTROLPARENT
CAPTION ""
LANGUAGE LANG_SPANISH, 0x3
FONT 8, "Tahoma"
{
   CONTROL "Progress1", 8000, "msctls_progress32", PBS_SMOOTH | WS_CHILD | WS_VISIBLE | WS_BORDER, 64, 40, 286, 9
   CONTROL "Progress1", 8001, "msctls_progress32", PBS_SMOOTH | WS_CHILD | WS_VISIBLE | WS_BORDER, 64, 88, 286, 9
   CONTROL "", 1028, STATIC, SS_LEFT | WS_CHILD | WS_VISIBLE | WS_GROUP, 311, 25, 36, 8 , 0x00001020
   CONTROL "", 1021, STATIC, SS_LEFT | WS_CHILD | WS_VISIBLE | WS_GROUP, 311, 74, 36, 8 , 0x00001020
   CONTROL "Iniciando descarga...", 1022, STATIC, SS_LEFT | WS_CHILD | WS_VISIBLE | WS_GROUP, 64, 66, 222, 16 , 0x00000020
   CONTROL "", 1023, STATIC, SS_LEFT | WS_CHILD | WS_VISIBLE | WS_GROUP, 64, 17, 222, 16 , 0x00000020
   CONTROL "", -1, "NativeFontCtl", 0x50000010, 0, 0, 0, 0
}
 Así a primera vista parece complicado, pero se entenderá todo este código en el siguiente párrafo.

Una manera más de variar aquí los recursos es pulsando con el botón derecho (Cuando está mostrado el diálogo). Sale un menú y podéis insertar control, editar control, borrar control, editar diálogo y ocultar diálogo. Es una forma muy fácil de editar.

Voy a poner un ejemplo sencillo para entender también cómo se modifica el código.


Nos encontramos aquí de nuevo:


Pulsamos sobre la ventana que pone Dialog – 51 con el botón derecho y seleccionamos insertar control. Como en los ejemplos que hemos puesto arriba, vamos aquí también a insertar un texto label que diga por ejemplo: Espere.
Para ello en el menú desplegable seleccionamos STATIC:


O bien pulsamos sobre la palabra label. Si dejamos el puntero del ratón sobre cada icono nos dice a qué control corresponde.

En leyenda poner: Espere.

Por lo demás, he cambiado lo que se ve(podéis ver cómo se modifica el valor Style): 54020101


Y queda así:


Hay que darse cuenta que al modificar esto de esta forma, hemos cambiado el código que parecía tan complicado al principio. Acabamos de insertar en la ventana un control label. Vamos a ver cómo se ha puesto en el código:
CONTROL "Espere", 0, STATIC, SS_CENTER | SS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_GROUP, 134, 112, 74, 14 , 0x00020201

Ahora ya se entiendo todo... ¿verdad?

Ya se ve que no es nada complicado todo esto, simplemente es experimentar un poco.

Llegados a este punto he de decir una de las muchas utilidades del Resource Hacker. ;o)
Algunas veces al abrir un programa, nos podemos encontrar con alguna “pesada” e incomoda ventana de información, como la que he puesto al inicio, que nos puede avisar o comunicar cualquier cosa: desde la versión del programa hasta.... los días que nos quedan para utilizar el programa. ¿Qué se hace para evitar esta desagradable ventana de información?, pues, ya veréis pero no siempre, que borrando la carpeta con todos sus recursos ya no vuelve a salir. En el ejemplo anterior sería borrar por completo la carpeta 51.



Por último antes de acabar voy a poner un ejemplo que vi en el archivo ayuda de cómo insertar una imagen o un icono en programas que tengan la carpeta Dialog. Lo primero es buscar un programa que contenga la carpeta Dialog, así que buscando he encontrado uno muy conocido el emule 0,47a (compilado en C/C++ si no me equivoco).
Vamos a ir a Disco duro --> archivos de programa --> emule y copiamos el archivo “eMule.exe” y lo pegamos en el escritorio, lo utilizaremos como copia de seguridad.

Abrimos la copia del emule 0,47a con el Resource Hacker.
 
Ahora lo que vamos a hacer es insertar el icono que queremos que aparezca en la ventana. Para esto seleccionamos en Acción --> Añadir un nuevo recurso. Abrir archivo con nuevo recurso y vamos a buscar el icono.ico. Elegir el que queráis, yo he elegido uno de color verde. Seleccionarlo.
En tipo de recurso ya se tendrá que haber puesto ICONGROUP y en nombre de recurso ponéis el que queráis: NUEVOICONO he puesto yo. Le dais a añadir recurso. Para ver si está bien insertado nos vamos a Icon Group y tiene que aparecer nuestro NUEVOICONO (por orden alfabético).
Ahora nos vamos a ir a la ventana donde queremos insertarlo que en este caso está en: Dialog --> 315 por ej.
Pulsáis sobre el 0 y en la parte de la derecha arriba en ocultar diálogo (o cerrar la ventana). Y ahora vamos a insertar la orden oportuna, insertándola donde queráis, yo la he puesto la última:

CONTROL "NUEVO ICONO", -1, STATIC, SS_ICON | WS_CHILD | WS_VISIBLE, 171, 173, 21, 20


 Sobre todo tened cuidado de no borrar el {. Si la copiáis directamente tal vez os de error de sintaxis las comillas. Deberéis cambiarlas vosotros escribiéndolas de nuevo.
Tras todo esto pulsamos en Compilar Script y ya tenemos el icono. Lo ponemos donde queramos, volvemos a compilar y guardamos.
Para ver el resultado, abrimos el emule y vamos a preferencias, ahí estará la ventana con nuestro nuevo icono:


Bueno hasta aquí dejo ya el Resource Hacker.
Existen muchísimos programas para editar recursos. En el siguiente apartado veremos algunos.

Existen actualmente muchísimos editores de recursos. Versiones a fecha de hoy (13 de marzo de 2011):
Resource Hacker:
- Gratuito
- Versión 3.5.2 (beta) - 19 de diciembre de 2009
- Desactualizado y el autor no tienes planes para actualizarlo. Lo actualizó por uso propio para usarlo en Windows 64bits.
- Enlace: http://angusj.com/resourcehacker/ (http://angusj.com/resourcehacker/)

Exescope:
- De pago
- Versión: 6.50 - 23 de mayo de 2004
- Lleva mucho tiempo desactualizado pero lo pongo porque fue muy conocido y puede analizar ejecutables de 16 bits.
- Enlace: http://hp.vector.co.jp/authors/VA003525/emysoft.htm#6 (http://hp.vector.co.jp/authors/VA003525/emysoft.htm#6)

Resource Tuner
- De pago
- Versión 1.99 R6 - 20 de octubre de 2009
- Es un excelente editor de recursos, de los mejores. Tiene plugins adicionales como la descompresión de UPX que hacen este trabajo facilísimo. Es el editor de recursos que viene junto con PE Explorer, te lo comento porque si vas a comprarlo tal vez deberías pensar en éste último.
- Enlace Resource Tuner: http://www.restuner.com/ (http://www.restuner.com/)
- Enlace General: http://www.heaventools.com/ (http://www.heaventools.com/)

XN Resource Editor
- Gratuito
- Versión 3.0.0.1 -  17 de diciembre de 2005
- Buen editor de recursos gratuito y que tiene a disposición el código fuente.
- Enlace: http://www.wilsonc.demon.co.uk/d10resourceeditor.htm (http://www.wilsonc.demon.co.uk/d10resourceeditor.htm)

Restorator 2007
- De pago
- Versión 2007 - julio 2007
- Lleva años sin ninguna actualización, aunque es bastante completo.
- Enlace: http://www.bome.com/Restorator/help/version_history.html (http://www.bome.com/Restorator/help/version_history.html)

Resource Builder
- De pago
- Versión 3.0.3.25 - 18 de septiembre de 2009
- Enlace: http://www.resource-builder.com/download.html (http://www.resource-builder.com/download.html)

ResEdit
- Gratuito
- Versión 1.5.4
- Es muy buen editor de recursos para programadores. Por ejemplo, para usuarios de Visual C++ que programan en código nativo.
- Enlace: http://www.resedit.net/ (http://www.resedit.net/)

Explorer Suite
- Gratuito
- Versión: III - 03 de diciembre de 2010
- Muy buen editor de recursos. Tiene dos cosas por las que destaca y es que puede trabajar perfectamente con UNICODE y la segunda es que puede analizar recursos en NET.
- Enlace: http://www.ntcore.com/exsuite.php (http://www.ntcore.com/exsuite.php)


Y muchísimos más...

Voy a analizar dos de ellos:


Su página oficial es:
http://hp.vector.co.jp/authors/VA003525/emysoft.htm#6 (http://hp.vector.co.jp/authors/VA003525/emysoft.htm#6)

No es gratuito y como he dicho antes lleva mucho tiempo sin actualizarse. Hace años fue muy conocido y tiene una característica muy interesante y es que puede analizar los recursos en aplicaciones a 16 bits.



Programa gratuito que se puede descargar de su página oficial:
http://www.wilsonc.demon.co.uk/d10resourceeditor.htm (http://www.wilsonc.demon.co.uk/d10resourceeditor.htm)

Es similar a los otros dos pero tiene algunas opciones muy interesantes:
-Tiene el código fuente completo disponible para descargar.
-Tiene una interfaz más agradable.
-Permite modificar iconos y mapas de bits.
Como ejemplo voy a abrir el Resource Hacker con el XN Resource Editor, voy a ir a Icon Group --> MAINICON y selecciono el icono 32 x 32. Como se observa se puede modificar el icono:


Y en según qué programas, en Dialog, te permite modificar los recursos gráficamente ya que añade los controles a la derecha, he de decir que me llamó mucho la atención:


-Y por último otra utilidad muy interesante que tiene este programa es que puedes añadir como recurso el XP Theme Manifest. Yo lo he utilizado para aplicaciones creadas en Visual Basic 6 por ej. y darles apariencia XP.


Y para finalizar, una pregunta. Hemos visto que podemos cambiar muchos recursos en nuestros programas y estos programas y muchos otros están muy bien porque podemos variar el número de letras y se puede compilar.
 Pero..  en el caso del programa Resource Hacker, ¿Cómo podemos cambiar por ejemplo el título de la ventana principal, aparte de otras cosas?..
Si lo intentáis buscar, veréis que no sale en recursos, así que no lo podemos modificar con estos programas
Para poder modificarlo deberemos utilizar otros programas editores como el Ultraedit 32 que es el que utilizo yo. Son editores en hexadecimal.
No me voy a adentrar en el manejo de este programa, pero voy a explicar cómo cambiar en la ventana principal las palabras: Resource Hacker:

Al abrir el archivo “copia.exe” con el Ultraedit vemos un montón de líneas y a la izquierda el número de “línea”: 00000000h, 00000010h etc… Debemos buscar en este caso sobre la línea 000aaf70h y veréis a la derecha las palabras: Resource Hacker. Éstas son las palabras que podemos modificar para cambiar el título de la ventana principal del programa.

Espero que os haya servido de ayuda todo este extenso tutorial.
La verdad que hoy día traducir un programa o hacerlo a gusto de cada uno es estar sentado delante del ordenador muchas horas, y cuando crees que lo tienes acabado encuentras alguna frase sin traducir, o cuando lo has traducido acaban de sacar al mercado una versión posterior.
Existen muchos programas para modificar los recursos. Yo utilizo estos 3 que acabo de mencionar. A veces uno abre lo que el otro no puede.
Muchas veces veréis que no son capaces de abrir muchos recursos y tendréis que utilizar programas editores hexadecimales. Hay que tener cuidado con estos últimos programas porque no se pueden insertar ni borrar bytes ya que sino la aplicación es muy probable que dé error. Por ej. puedes tener una aplicación en la que quieres traducir la palabra: Help que tiene 4 bytes: 48 65 6C 70 por ayuda en español que son 5 bytes: 41 79 75 64 61. Dará casi seguro error.
Por eso siempre antes de modificar cualquier archivo hay que hacer una copia de seguridad.
Otras veces veréis que algunas aplicaciones han sido comprimidas o encriptadas y no se pueden ni siquiera ver los recursos.
En este caso para ver los recursos hay que descomprimirlas o ‘desprotegerlas’... el ejemplo 2 es un caso concreto por ej.



Cualquier duda, error, cosa que queráis añadir…

Un saludo de karmany.

En este apartado iré añadiendo algunos ejemplos de cómo hago yo para modificar algunos recursos..

Ejemplo01:

Ya que nos encontramos en el subforo de Ingeniería Inversa, voy a aprovechar este tutorial para modificar un programa que tiene alguna curiosidad. (Nota: El programa del que voy a hablar podría ser útil hace años pero actualmente no recomiendo su uso, al final del ejemplo2 explico alternativas y pongo el porqué. Sólo descargarlo para seguir este tutorial.)
El programa se llama: Embryo Patcher versión 1.2:


Este programa permite comparar dos archivos, original y parcheado y tras analizarlos genera un ejecutable para convertir el archivo original. En definitiva un programa para generar parches.

Descargar el archivo Embryo Patcher 1.2 del archivo zip. El enlace está en el primer mensaje de este hilo.

Si se ejecuta este programa, observamos primeramente que ni el botón de About (acerca de), funciona. Si intentamos abrir el Embryo Patcher con nuestro Resource Hacker veremos que no nos deja.. ¡empezamos bien! – (resolveremos todo esto)

Lo primero que siempre suelo hacer es ver de dónde viene el programa, su autor etc… ¡Nada! su página web ha desaparecido.
Analicé el programa para averiguar con qué ha sido compilado y todos los programas que utilicé (RDG Packer Detector, File Inspector, Peid…) me indicaron que el compresor era:


Desempacar UPX es muy sencillo, es lo más básico para cualquier novato en ingeniería inversa. Se puede desempacar de muchas formas:
- Usando el mismo UPX: http://upx.sourceforge.net/ (http://upx.sourceforge.net/)
- Desempacándolo manualmente para Re-Newbies: Desempacar UPX para novatos por Shaddy (http://ricardonarvaja.info/WEB/CURSO%20NUEVO/TEORIAS%20NUMERADAS/801-900/874-Desempaquetando%20un%20UPX%20para%20RE-Newbies%20por%20Shaddy.zip)
 - Usar herramientas como vamos a hacer aquí. En este caso vamos a usar un excelente programa para editar recursos que tiene un plugin para desempacar perfectamente UPX, el programa es:

Resource Tuner: Es un programa para editar recursos como los que he comentado en este tutorial. No es gratuito y la versión de prueba es para 30 días. Si alguien decide comprarlo tal vez estaría más interesado en PE Explorer que del mismo autor y engloba a Resource Tuner. La ventaja que tiene como ya he comentado es que tiene un plugin para UPX.
Página Web:
http://www.restuner.com/ (http://www.restuner.com/)

Lo único que hice con este programa es abrir el Embryo Patcher y volverlo a guardar. Ya desapareció UPX. ¡Ahora ya se puede empezar a editar los recursos!.

Lo primero que quise hacer es intentar averiguar por qué no funciona el botón “Acerca de”. Así que abrí el programa con el conocido Resource Hacker y me fui a dialog y a la ventana Acerca de. (AB_DIALOG). Algo extraño hay ahí. Hay cuatro LINKS y sólo se ven los recuadros, no hay nada de texto. Tal vez el problema sea este. Voy a intentar solucionarlo.
Así que se me ocurrió modificar en el texto esos “LINK” por STATIC a ver qué ocurría.
Por ej. en:
CONTROL "devon@wizard.ae.krakow.pl", 3400, "LINK", 0x50000100, 78, 61, 100, 8

Sustituí el “LINK” y quedó así:
CONTROL "devon@wizard.ae.krakow.pl", 3400, STATIC, 0x50000100, 78, 61, 100, 8

Pulsé en Compilar Script y se modificó a:
CONTROL "devon@wizard.ae.krakow.pl", 3400, STATIC, SS_LEFT | SS_NOTIFY | WS_CHILD | WS_VISIBLE, 78, 61, 100, 8

¡Y apareció el texto! Sólo quedaba saber si funcionaría el link, si se abriría “Acerca de” y si el cursor sería la mano..
Cambié los 4 LINKS compilé y guardé el ejecutable. Lo abrí y perfecto:


A partir de aquí con el Resource Hacker no hay más misterio. Traduje el programa, que no tiene mucho que traducir. Después para traducir los Tool Tips y demás diálogos que no aparecen en el Resource Hacker, utilicé el UltraEdit 32. Me quedó así:


En este momento parece que ya hemos acabado ¿no?. Pues no, ya que estamos “arreglando” el programa vamos a dejarlo bien acabado…
Sólo nos queda darle la apariencia de Windows XP si nos deja y ya está.

Voy a utilizar un programa que ya he explicado más arriba: XN Resource Editor.
Como comenté, este programa tiene una opción muy interesante que es la de añadir el recurso del archivo MANIFEST. Eso es lo que voy a hacer añadir este recurso.
Así que abro el XN Resource Editor -> File -> Open y selecciono el Embryo Patcher que ya tenemos traducido.
Voy a Resource -> Add Resource y selecciono de la lista el XP Theme Manifest. Guardo el archivo y ya tenemos todo arreglado:


En realidad tienen que salir los botones como si estuvieran sobre otro botón. Para arreglar esto, desde el resource hacker hay que señalar el botón, editar control y quitar porque estará en amarillo: WS_EX_STATICEDGE.

Ahora sí que podemos decir que hemos "arreglado" el programa y dado apariencia XP.

Dentro de poco pondré el segundo ejemplo que también tiene que ver con este programa.

Un saludo.

PD. ¿Habéis probado a utilizar el Resource Hacker con un archivo MANIFEST? :-).

Ejemplo 02:

Descargar el archivo parche.rar del archivo zip. El enlace está en el primer mensaje de este hilo.

Utilizando el programa anterior podemos crear nuestros propios parches (repito y como pongo al final de este ejemplo, hay otras alternativas), pero si observáis la interfaz de estos parches no es muy agradable. Así que este ejemplo trata de eso:
Modificar los recursos de un parche generado con Embryo Patcher 1.2.

Programas para desempacarlo: OllyDBG con plugin OllyDump, Import REconstructor 1.6 final, LordPE.

Yo quería hacer un ej. sencillo, desempacando UPX de forma tradicional pero, sin quererlo he encontrado un programa que tiene alguna sorpresa...
Mi parche generado lo he llamado: parche.exe:


Si examinamos el archivo con el Peid nos dice que está empacado con UPX. Probé:
-Desempacarlo con UPX
-Utilizar el plugin del ej. anterior
Y nada de nada, daba error en todos, así que toca desempacarlo a mano:

Existen muchísimos tutes de cómo desempacar UPX. En el ejemplo anterior pongo un enlace para gente sin conocimientos. He hecho un tute paso a paso de cómo desempacar mi parche.exe. Si no lo tienes claro, descarga el archivo Explicación.doc. Lo que explico aquí a fin de evitar un mensaje muy largo es general.

Descargar el archivo Explicación.doc del archivo zip. El enlace está en el primer mensaje de este hilo.



1) Abro parche.exe con el Olly, veo que lo primero que aparece es un PUSHAD, así que utilizo una forma para obtener el OEP (Punto de entrada, Entry Point), que explico en el archivo anterior.
El OEP que obtengo es 401000.

2) Ahora lo que voy a hacer es dumpearlo con el plugin OllyDump. Lo único que destildo es “Rebuild Import” porque voy a buscar los datos de la IAT manualmente. El archivo dumpeado lo llamo: dumpeado.exe

3) Ahora sólo queda arreglar la IAT:
Botón derecho -> Search For -> Binary String y busco el famoso “FF 25”
Lo primero que me ha encontrado ha sido un salto en 401826.
Pulso: botón derecho -> Follow In Dump -> Memory Address
y obtengo Inicio, Fin y tamaño de la IAT:
INICIO de la IAT: 00402000
FINAL de la IAT:  00402080
Tamaño: 80

Si esto no se entiende descargar el archivo que he comentado antes que viene bien explicado.  :)

Con estos valores ya puedo abrir el Import REconstructor y attachear "parche.exe". E introduzco abajo a la izquierda los siguientes valores que he obtenido:

OEP:   00001000
RVA:   00002000
Size:    00000080

Pulso en Get Imports y observo que todas las entradas son válidas. Parece todo correcto, así que pulso en Fix Dump, elijo el archivo dumpeado.exe, que había creado con el plugin OllyDump y se crea satisfactoriamente el archivo: dumpeado_.exe.


Bueno mi intención era llegar hasta aquí, pero si ejecuto dumpeado_.exe observo con sorpresa que el texto es ilegible y el programa NO funciona correctamente... :o


En este punto me equivoqué en mis razonamientos (hace años de esto jeje, todos hemos sido novatos) y no saqué nada claro, así que le mandé mi desconcierto y sorpresa a Ricardo Narvaja para que me enseñara algún camino. Gracias a él pude continuar y no es difícil... Gracias Ricardo..



Abrí el programa desempacado (dumpeado_.exe) con el Olly, y me sale un aviso:

"module 'dumpeado' has entry point outside the code (as specified in the PE header). Maybe this file is self-extracting or self-modifyint. Please keep it in mind wen setting breakpoints!!"

Vaya... tiene el OEP fuera del código!?

Después de darle vueltas a la cabeza pulsé Alt + M y observé lo que el OllyDBG me decía:
 Address           Size           Section      Contains
00400000     00001000                        PE header
00401000     00005000        EMB0
OEP = 401000

El Olly tiene razón. Pues voy a modificar para que el OEP esté dentro del código. Cierro el OllyDBG.
Para esto utilizo el programa LordPE:
-Lo abro, pulso en PE EDITOR y selecciono el programa dumpeado_.exe. Se abre una ventana con toda la información.
-Veo que en BaseofCode pone 00006000. Lo voy a modificar por 00001000. Pulso en Save y Ok.                                                
Ahora ya podemos abrir el dumpeado_.exe con el OllyDBG sin ningún problema. Además aparece más información importante.. ;)



Después de observar el código hay unos saltos importantes que hay que conocer: CreateFileMapping, MapViewofFile.. como yo tampoco lo tenía muy claro busqué información:
http://www.formauri.es/arrobamasmas/Articulos/indexArticulo.php?art=1 (http://www.formauri.es/arrobamasmas/Articulos/indexArticulo.php?art=1)

Antes de esto abre un archivo y calcula el tamaño.
Ricardo me comentó que si en vez de abrir el archivo dumpeado_.exe pongo en la misma carpeta el original empacado "parche.exe" y le modifico el nombre a "dumpeado_.exe" el programa funciona perfecto..
Así que con todos estos datos me puse manos a la obra:



Cerré todo programa. Abrí el "parche.exe" con el Olly, me puse en el OEP(ya explicado) y observé dónde "coge" los datos:
Analizándo el código lo vi claro:
1º Abre el archivo "parche.exe"
2º Busca en la dirección B11400, 3A bytes. Mirar:

4010F2    MOV EDI,DWORD PTR DS:[4033F4] -> EDI = B10000
4010F8    ADD EDI,DWORD PTR DS:[4033B5] -> EDI = EDI + 1400 = B11400
4010FE    MOV ESI,EDI
401100    MOV ECX,DWORD PTR DS:[4033A7] -> ECX = 3A
401106    MOV EDI,DWORD PTR DS:[4033F8] -> EDI = 146A00

Y un poco más abajo:
40110D    REP MOVS BYTE PTR ES:[EDI],BYTE PTR DS:[ESI]

Es decir, coge 3A bytes de la dirección B11400 y los pone en 146A00.
Solamente hay que saber cómo se ponen en B11400 los bytes, , para resolver el misterio...porque los datos, más abajo los toma de 146A00.



Bueno.. el programa abre un archivo (él mismo) y luego hace:
CreateFileMapping, MapViewOfFile...
Aquí está el quid de la cuestión... ¡A ver qué hace esto!

Voy a poner un Breakpoint justo después de MapViewOfFile.
Observo que retorna EAX con un valor = B10000 y si pulso Alt + M veo que se ha creado una nueva sección en la dirección: B10000 y pone "parche.exe".. interesante...

Voy a ver qué hay en esa sección.. Así que voy a la ventana de dumpeado pulso botón derecho -> goto -> expresion y pongo 00B10000.
Observo todo el código detenidamente, abro con un editor hexadecimal el "parche.exe" y veo que es exactamente igual.
Cuando vi esto, ya tuve las cosas bien claras..
Si la dirección de los 3A bytes es B11400 no cuesta nada apreciar que el Offset es 1400.



Resumen de todo esto: el programa copia 3A bytes que tiene en la dirección (Offset) 1400 y los pone en 146A00. Después coge los datos de aquí..
¿¿Qué pasa en el desempacado?? pues que los datos no están en esa dirección. No existen. Esto es posible si el programador ha primero empaquetado su aplicación y luego ha modificado el archivo insertando los datos..
¿Qué voy a hacer para hacer funcionar el archivo desempacado?
Voy a copiar los 3A bytes que están en el Offset 1400 del archivo original empacado (parche.exe) y los voy a pegar por ej. en Offset 8300 del archivo desempacado. Esto lo hago todo y fácilmente con el Ultraedit32.
Observación importante:Esto que estoy haciendo de pegar 3A bytes en el Offset 8300 que he visto vacío y no se modifica, quiero dejar claro que no está bien hecho. Hacerlo bien sería crear bytes nuevos (por ej. con el programa Topo), que con seguridad no se van a modificar y ahí pegar los 3A bytes.

Ahora solamente queda decirle al programa que lea los datos en 8300 y no en 1400.
Recordando de arriba:
4010F8    ADD EDI,DWORD PTR DS:[4033B5] -> EDI = EDI + 1400 = B11400
Vemos que el 1400 está en 4033B5. Así que sólo queda sustituir el 14 de 4033B6 por 83. Por supuesto con el editor hexadecimal.
Con todo esto resuelto voy a ejecutar mi programa:


Y compruebo que funciona bien..

Ahora se puede ya modificar todo con un editor de recursos. Extraño es que el Resource Hacker no me deja pero el Exescope y el XN Resource sí.

Una cosa curiosa que podéis hacer es que si queréis cambiar la dirección Web o el correo electrónico, solamente hay que modificar con un editor hexadecimal esto comentado y listo.


No quería extenderme tanto, pero ya he comentado en este amplio tutorial que modificar un programa puede ser muy trabajoso, y con este último ejemplo ha quedado demostrado..

Consideraciones finales sobre Embryo Patcher v.1.2:
Después de utilizarlo unas cuantas veces observé que el programa tiene algún bug y se cierra no sé por qué. (Con el archivo original.)
También al traducirlo observé que el límite de cambios de 2 archivos es 255.
Pienso que hay muchos y mejores programas que este, lo comento por si alguien aprovechando este tutorial quiere utilizar el Embryo Patcher.
Por ej. el programa diablo2oo2's Universal Patcher tiene muchísimas más opciones y es un programa en desarrollo y muy bueno... Además Shaddy nos hizo un excelente tutorial del manejo de este gran programa. Descarga:
dUP2.Diablo Universal Patcher v2.17 by ShaDDy (http://ricardonarvaja.info/WEB/CURSO%20NUEVO/TEORIAS%20NUMERADAS/1001-1100/1009-dUP2.Diablo%27s.Universal.Patcher.v2.17.By.ShaDDy.rar)
Su página web es la siguiente:
http://diablo2oo2.di.funpic.de/dup.htm (http://diablo2oo2.di.funpic.de/dup.htm)

Ejemplo 03

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

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.


-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..

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 (http://ricardonarvaja.info/WEB/CURSO%20NUEVO/TEORIAS%20NUMERADAS/701-800/781-.Volviendonos%20invisibles.rar)

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:


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:

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 (http://ricardonarvaja.info/WEB/OTROS/HERRAMIENTAS/Q-R-S-T-U/rescode%20imagen%20204.rar)

---

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


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:

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:




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 (http://ricardonarvaja.info/WEB/CURSO%20NUEVO/TEORIAS%20NUMERADAS/801-900/821-Activando%20botones%20en%20Delphi%206%20por%20karmany.rar)

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 (http://www.vb-decompiler.org/)

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:


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


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:


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:
Lo guardo como ejemplo.exe, lo ejecuto y...

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:


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/ (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:

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:


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:


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:


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

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 (http://hexman.free.fr/fr/exe/vbeditor_III_opensource.php)

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


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!



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


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:


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 -> 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...


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.



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:


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):


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. :-)



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).

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":


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:


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:


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:


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:


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

.
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):


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:


¡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:


Me he comido 3 instrucciones.

Y en 00401000 hago el siguiente injerto:


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:

                                .

Y asunto terminado.

El ejemplo final es el siguiente:


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...

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):

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:


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:


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...

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.


¿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í.

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:

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

Y si dumpeo ese valor: 0016A354 vemos esto:
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:


004030B8?! podría ser éste la dirección que buscamos???
Voy a dumpear a ver:
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:


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 (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:

---

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 (http://www.telefonica.net/web2/telamarinera/docus/Tutorial_para_editar_recursos.rar)

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.