Modificando cabeceras "for Fun and Profit"

Bueno, hace unas semanas conseguir añadir una sección a un archivo y en ella poder inyectar mi codigo.

Bueno, lo dividire por capitulos, para que nadie se pierda si no sabe absolutamente nada sobre el formato PE (Portable Executable).

Índice:

1.- ¿Que es el formato PE?
2.- 1ª Práctica: Cambiando el Entry Point
3.- 2ª Práctica: Agregando una sección
4.- 3ª Práctica: Inyectando codigo y reparando direcciones
5.- Últimos apuntes

Este seran los distintos capítulos que escribire.

Un Saudo

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

¿Que es el formato PE?

Si echamos un vistazo a la Wikipedia nos dice lo siguiente:

Citar

The Portable Executable (PE) format is a file format for executables, object code, and DLLs, used in 32-bit and 64-bit versions of Windows operating systems. The term "portable" refers to the format's portability across all 32-bit (and by extension 64-bit) Windows operating systems. The PE format is basically a data structure that encapsulates the information necessary for the Windows OS loader to manage the wrapped executable code. This includes dynamic library references for linking, API export and import tables, resource management data and thread-local storage (TLS) data. On NT operating systems, the PE format is used for EXE, DLL, OBJ, SYS (device driver), and other file types.

Como casi todo lo bueno que hay por internet esta en ingles, "in spanish" hay poca cosa...

http://www.perantivirus.com/sosvirus/pregunta/portable.htm

El archivo "por excelencia" es el siguiente:

http://www.microsoft.com/whdc/system/platform/firmware/PECOFF.mspx

Echenle una buena ojeada y luego continuen con este texto

Bien, antes de empezar a explicar las partes mas importantes que vamos a tocar les dire las herramientas necesarias para hacer las practicas. Son 4:

- OllyDbg: Para mi el mejor debugger que hay a ring 3, lo vamos a necesitar bastante
- Hex Workshop: o cualquier otro editor hexadecimal
- PEiD: para ver unas cuantas cosas.
- Dumpbin: Esta en la carpeta del VC++, se lo subire por si alguien no lo tiene.

Bien, abrimos un exe cualquiera y las 2 priemras "letras" que encontramos es MZ, que significa eso?? pues es una marca que indica que es un archivo DOS. Esas marcas vienen de Mark Zbikowski, uno de los creadores del MS-DOS.

Despues, no nos interesa nada mas, hasta llegar aqui:

Citar

PE..L

Bien, ese PE es la marca del formato PE, es donde se inicia la lectura.

Los primeros bytes que le siguien son 4C01 si lo leen desde el editor hexadecimal, pero recuerden que estamos en un Endian (para mas info sobre eso busquen en la Wiki), asi que el numero real es 14C, que es para indicar que este archivo correra sobre un i386. Justo después de ese numero hay otro numero, en mi caso, en un archivo de VB habrá el numero 3, que indica el numero de secciones que contiene el archivo.

Siguiendo este numero le toca el turno de otro numero de 4 bytes, que indica la fecha en que fue creado, ese numero es simplemente una anecdota, ya que no nos sirve.

En el offset nº CC tenemos otro numero que nos interesa, que en mi caso es E0, que es el tamaño del Optional Header (o cabecera opcional).

Bueno, ahora ya no nos interesa nada mas de aqui, vamonos al Optional Header.

Esta situado en D0, y lo primero que nos encontramos es lo siguiente: 0B01 en Endian, lo que equivale a 10B en Hexa. Este es el Magic Number, es una mera anecdota, ya que tampoco lo vamos a tocar.

A partir de ahora no voy a explicarlo tanto, les dire lo que es, en que dirección y cuanto ocupa

- En el offset D2 tenemos la version del Linker (2 bytes = 0600)
- En D4 tenemos el Tamaño del codigo de 2 bytes
- En E0 tenemos el RVA o lo que es lo mismo, el Entry Point, de 2b
- En EE tenemos la Imagen Base que suele ser 40000, es la posición de memoria donse se empeiza a cargar (Como curiosidad les dire que si cambian ese dato a 5000 por ejemplo algunos antivirus no detectaran lagunos archivos que sean sospechosos xDDD)
- En F0 tenemos la alineación de la sección (Esto es importante, ya lo verenos)
- En F4 tenemos la alineación del archivo
- En 108 tenemos el tamaño de la imagen, tambien es immportante si tenemos que inyectar codigo
- En 10C tenemos el tamaño de las cabeceras

Bueno, hasta aqui lo mas "importante", quedan otras cosas como donde esta la IAT y cosas de esas que lo explicare con un log del dumpbin delante

Ahora explicare las partes de las que se compone una sección en la cabecera (ya que se declara hay).

Nos vamos en donde dice .text (sección de codigo ejecutable, todo el codigo de los programas suele estar en esta sección, mucha gente cree que todo el codigo que hay por debajo de la cabecera es ejecutable, y no es así.). En el editor nos vamos hay y empezare a explicar.

Vemos lo siguiente en la parte del texto:

Citar

.text............................... ..`

Lo que equivale en hexa a esto:

Citar

2E74657874000000FC0E000000100000001000000010000000000000000000000000000020000060

Paso a explicar eso

- Lo que esta en Rojo: Es el nombre de .text en hexa
- Lo que esta en Azul: Es el tamaño virtual
- Lo que esta en Rosa: Es la dirección virtual
- Lo que esta en Verde: Es el tamaño de los datos
- Lo que esta en Naranja: Es el "file pointer to raw data"
- Lo que esta en Púrpura: Que en Hexa es 60000020 son los flags, que indican que es una sección de codigo, que es ejecutable y que se puede leer.

Si lo metemos en el Olly, esta sección empeiza en 00401000 (el 004 es del 400000 que dije antes que si lo cambiabas los AV's no lo pillaban, y el 1000 de la dirección Virtual) y termina en 00401EF0 (este EFO es el del tamaño virtual).

Hay que andar con ojo con eso, no vayamos a meter dos secciones en el mismo espacio (evidentemente nos daria error antes de iniciar

).

Creo que hasta aqui ya vale, no me quiero adelantar, asi que solo les dire que al final de esta sección se encuentra la IAT.

En en próximo capítulo vamos a cmabiar el entry point y a meter algunos opcodes para hacer pequeños experimentos como un loop infinito o algunas cosas de estas

Como tarea (si la quieren hacer) es que carguen elgun programa con el olly y miren que efectivamente, el entry point nos dice que esta en 117C y el olly carga en 0040117C (recuerden que se carga en la memoria virtual, y por eso deben de agregarle el 0040 delante o lo que haya en la dirección EE del archivo.

Me despido, Un Saludo

Edit:

Se me olvidó subir el Dumpbin.

jueguen un rato con este archivo, es bastante interesate.

Si quieren sacar un log completo hagan lo siguiente:

Citar

dumpbin /all archivo.exe > log.txt

Si quieren ver solamente las cabeceras:

Citar

dumpbin /headers archivo.exe

Hay muchas otras opciones.

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

1ª Práctica: Cambiando el Entry Point

Ahoar empieza ya lo bueno, dejamos la teoria de lado (aunque eso nunca se peude, ya que la vamos a necesitar) y empezaremos a toquetear el archivo.

En esta practica cambiaremos el entry point de nuestro archivo victima y lo redierccionaremos a un loop en ASM, para practicar con los opcodes.

Yo ire escribiendo a medida que lo haga en mi PC, luego subire todos los archivos (el victima y los resultados del dumpibn) al servidor, vosotros os descargais ese archivo y vais siguiendolo, haber si os sale como a mi

Bueno, hacemos un dumpeado con el dumpbin y nos dice que el entry point es 114C, nos vamos a la posición E0 y hay encontramos ese numero escito para endian (es decir, 4C11). Si lo cambiamos haremos que el archivo se empiece a ejecutar donde nosotros queramos. Si nos vamos a la dirección donde apunta el EP en el editor hexa vemos lo siguiente:

Lo que e señalado es la primera linea (en opcodes) que sale en el olly, si no me creeis, id al olly y cargad el archivo

Ahora vamos a hacer que cargue en la posición 120 por ejemplo, asi que nos vamos a la posición donde hay el EP (E0) y escribimos esto: 2001.

Si lo pasamos al Olly nos sale un cartelito avisando de que el entry point esta fuera de la sección codigo, y evidentemente es asi, ya que la sección de codigo empieza en 1000 y nosotros le hemos dicho que cargue en 120.

Ahora, vamos a crear un pequeño loop. Al loop lo situaremos en una region de "muchos 0's" o sea, que no substituiremos ningun opcode, yaque nos cargariamos el programa.

Si nos fijamos, desde 1670 a 1860 hay 0's, y como los opcodes de nuestro loop no son demasiado extensos podremos meter hay el loop.

Ahora se preguntaran, como sacar los opcodes?? pues muy facil, desde el mismo Olly se pueden sacar, nos vamos a una linea cualquiera y pulsamos la barra espaciadora, luego hay ponemos lo que nosotros queramos.

Bien, pondremos los opcodes en la posición 1680, asi que nos vamos a esa posición dentro del olly (00401680). Nuestro loop lo que hara sera saltar a una posición mas arriba, para asi provocar un loop. asi que en la posición 00401680 escribimos: jmp short 0040167F. Ahora, en la dirección de arriba (0040167F) le tendremos que poner un nop, para que no haga nada. El opcode del nop es un 90.

Al pulsar intro se añadira hay mismo y justo al lado tenemos los opcodes, que son: EB FD

Nos vamos al archivo y le agregamos esos opcodes a partir de la dirección 1680.

Una vez agregado tenemos que colocar el EP (entry Point) hacia esa dirección.

Una vez cambiamos, nos vamos al olly para verlo. Y ya tenemos un loop que nos sirve de bien poco, pero almenos hemos aprendido algo

Si lo ejecutan con un doble click lo tendran que finalizar con el administrador de tareas

y les subira el PC al 95%-100%, asi que la mejor opción es con el Olly

Bien, ahora que podriamos hacer con esto?? pues varias cosas, pero siempre estaremos limitados al espacio que nos de el archivo, por eso lo de añadir una sección, ya que le podemos dar el tamaño que nosotros queramos

Ahora les podria pasar un ejemplo de como llamar a una api, por ejemplo la del messageboxA pero creo que es pronto todavia para saber como reparar la IAT, ya que queria hacer un injerto de otro programa, pero se tiene que reparar y mejor hacerlo en la última practica

Lo dicho, ahora les subire el archivo y el log y echadle un vistazo.

Un Saludo

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

2ª Práctica: Agregando una sección

Este apartado fue el que mas quebraderos de cabeza me llevo, agregar la sección es facil, lo que no me cuadraba era la IAT, al final consegui repararla gracias a Karmany.

Bueno, abramos el archivo de pruebas (1.exe) con el editor hexa y vamos a intentar "imitar" la sección .text por ejemplo, asi quenos vamos al editor hex y miramos la longitud de la sección .text y agregamos la nuestra al final de las otras.

Fijense, en la parte hexadecimal, lo seleccionado va justo despues de los flags de la última sección, que son 4000040, tenemos que tener cuidado con eso

Al nombre de la sección le pueden poner el nombre que quieran, yo le e puesto hend

Ahora, pasemos a analizar las cosas y repararlas, ya que asi no cargaria.

Citar

.hend............................... ..`

Citar

2E68656E640000008C0C000000100000001000000010000000000000000000000000000020000060

En rojo: el nombre, que es .hend
En rosa: El tamaño virtual de la sección (Lo podemos dejar asi)
En verde: La dirección virtual, la tendremos que reparar para que no cargue sobre la .text xDDD
En Naranja: size of raw data, lo dejamos como esta
En Purpura: file pointer to raw data, evidentemente, tambien lo tenemos que reparar

En Azul: Son los flags, lo dejamos como esta, ya que queremos codigo ejecutable.

Para repararlo, lo tenemos que dejar asi:

Citar

2E68656E640000008C0C000000400000001000000040000000000000000000000000000020000060

Ya que queremos que cargue despues de la sección .rsrc (de recursos).

Si lo guardasemos asi el archivo estaria desalineado, hay 2 opciones, cambiar el alineamiento (que es un rollo) o borrar tantos bytes como hemos añadido cuando hemos colocado la ultima sección, asi que borramos 40 0's y listo, ya pueden guardar el archivo y veran como el explorer cargara el icono, eso quiere decir que el archivo esta alineado.

Ahora nos falta una cosa, cambiar el numero de secciones en el header, que si repasamos el primer capítulo, esta en el offset nº BE.

Lo cambiamos por 4 y ahoar lo que tenemos que hacer es agregar esos 1000 bytes que ocupa nuestra nueva sección.

Asi que le asignamos los 1000 bytes con el editor hexadecimal al final del todo.

Una vez echo esto tenemos que cambiar otro dato, el del size of image (o tamaño de la imagen), ya que sino solo cargara hasta 4000.

Una vez cambiado eso lo guardamos (en otro archivo, por ejemplo 2.exe) y lo analizamos con el dumpbin.

Ahora, los log's del dumpbin no nos dan ningun error y ya nos muestra nuestra nueva sección totalmente vacia!!!

Pero, al ejecutarlo nos da un error, eso es porque no emos reparado la Bound Import Directory, asi que vamos a repararla.

Si nos fijamos, la Bound Import Directory en el archivo 1.exe apuntaba a la posición 228, y nos mostraba:

..:@............MSVBVM60.DLL

Eso lo sobreescribimos nosotros al añadir la sección, asi que lo tendremos que modificar para que pueda cargar la Dll del VB.

Ahora les mostrare una imagen de como me a quedado a mi.

El opcode a cambiar esta en el offset 188. Y tiene que apuntar a 250, ya que es donde empieza la Bound Import Directory.

Ahora lo guardamos y si todo a salido bien veremos la agradable imagen de conseguido!!

Ahora tenemos una sección donde escribir los opcodes que queramos!!!

Hasta el próximo capítulo!!! birra

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

3ª Práctica: Inyectando codigo y reparando direcciones

Ya tenemos el archivo preparado, con nuestra sección marca de la casa, ahora solo queda aprovechar esa sección.

En el ejemplo que les mostrare haremos un injerto de un codigo echo con el Fasm, es un simple hola mundo, pero bueno, va a servir

Manos a la obra.

Cogemos el archivo del Fasm y le cogemos todo lo que necesitemos, que en este caso sera la sección .text y la IAT.

Copiamos "a pelo" el codigo del Fasm que es el siguiente:

Citar

j......Win32 Assembly......Hi! I'm the example program!.j...| @.j...^ @...V ..........< ..^ ..t ..........J ..| ......................KERNEL32.DLL..USER32.DLL..f ......f ........ExitProcess.. ....... ........MessageBoxA

Y lo pegamos (la pare hexadecimal) en nuestra nueva sección.

Bien, ahora ya hemos realizado el injerto, ahora toca la parte mas "complicada", que es reparar los saltos, en esta opcasión repararemos los saltos hacia la IAT, para poder llamar a las Dll's.

Si lo metemos en el olly veremos que no apuntan hacia ningun lado las llamadas a las apis, asi que toca reparar.

Para repararlo mos ira de maravillas hacerlo dentro del olly.

Antes de meterlo al olly, podriamos cambiar el entry point para que se ejecute nuestro codigo inyectado.

Una vez cambiado el EP lo metemos al olly (recomiendo esactivar el AV', ya que a mi por lo menos el Kav me a saltado).

Perfecto, nos ha saltado donde queriamos, si nos fijamos en esos 2 últimos calls, no contienen el nombre de las apis en los comentarios. Para repararlo podemos dumpear esa dirección al dump y vemos que no hay nada.

Para repararlo nos ayudamos del archivo original, asi que cargamos el programa hello en otro olly y vemos que hace exactamente.

Vemos que los call's si contienen el nombre de las apis. Si dumpeamos la dirección primera, vemos que llama a 7E3D058A, asi que lo ponemos en nuestro codigo (2.exe) haber si se escribe el nombre de la api.

Escribimos esto en esa linea: Call 7E3D058A y volià!! se nos escribió el nombre

NOTA: Poniendo el salto "a mano" implica que solo se ejecute en nuestro PC, ya que en otro PC esa dirección no sera usada por esa API, puede que por ninguna, asi que hay que tener cuidado con eso.

La otra api (la de exitproces) no nos interesa, ya que finalizaria el programa, asi que lo podemos substituir por un salto al EP original, para que continue normalmente el programa.

Antes de hacer ese jump, escribamos los opcodes del call parcheado en el archivo.

Una vez cambiados los opcodes, cambiamos tambien los opcodes de la última api por lo del Jmp hacia el OEP (original Entry Point).

Ahora, guardamos el archivo y vamos a ver que pasa al ejecutarlo con doble click.

Y ya nos funciona perfectamente!!!

NOTA: Corrección de la Ptractica nº 2. En el Bound Import directori en lugar de cambiarlo del 228 a 250 lo tienen que dejar a 0, y el 20 que hay a continuación tambien.

Esto es todo amigos

PD: Es mucho mejor usar este tipo de inyecciones con un codigo que no dependa de API's ni nada de eso, y si quereis usar apis, es mejor que saqueys las direcciones de las apis mediante el codigo asm, para no tener que meterle mano mas...

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

Últimos apuntes

Bueno, pongo este apunte que me pidió E0N:

http://inexinferis.in.funpic.org/index.php?name=articles&req=listarticles&artid=1

Y yo les dejo este que me paso Mek de elhacker.net, esta en ingles:

http://www.woodmann.com/fravia/covert1.htm

Otro

http://win32assembly.online.fr/pe-tut1.html

Bueno, a partir de ahora el post queda abierto para dudas/sugerencias/criticas/felicitaciones.

PD: Si rectifico algo del tutorial lo notificaré.
PD2: Para los moderadores, si este manual va en programación muevanlo hay, me parecio adecuado publicarlo aqui ya que se podria agregar estos pasos a un virus o algo...

Un Saludo

Originalmente publicado en: http://www.antifahack.net/index.php/topic,247.0.html

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

muy Buen Papper

salu2

Cita de: c3r0x en 21 Septiembre 2007, 01:10

muy Buen Papper

salu2

Merci

Muchas veces las cosas no se le dan al que las merece más, sino al que sabe pedirlas con insistencia. - Arthur Schopenhauer

excelente me gusto por la facilidad que explicas las cosas sin tener que entrar en tantos tecnicismos.

bueno men aca hay mas informacion publicada en espavirus referente a lo que es
el formato PE tambien incluye codigo y ejecutable para que se entienda aun mas.

http://www.espavirus.com/articulos/indice_pe.htm

esta dividido en tres partes.

y esta otra parte esta echa por zeropad en un curso de programacion de virus en asm. en donde tambien explica en parte lo que es el formato PE.

http://www.espavirus.com/cursos_virus/curso_ZeroPad/04-Introduccion_a_la_programacion_de_virus_en_ASM.doc

Saludos.

Muy bien Hendrix, muy buen tutorial al final despues de leerlo mas de diez veces, he logrado empezar a entender algo, te animo a que pongas mas ejemplos para resolver alguna de las dudas... muchas gracias por tu tiempo

hard-h2o modding Foros de ayuda Yashira.org Videojuegos indetectables.net

Noticias Informatica Seguridad Informática ADSL Foros en español eNYe Sec

Todas las webs afiliadas están libres de publicidad engañosa.