domingo, 18 de noviembre de 2012

[TOOL] VSD v2.1 x86 update

Hola!,

esta entrada es solo para avisarles que hay una nueva versión de VSD x86 disponible en la web del proyecto, acá.

Algunas de las novedades son:

v2.1 x86 - 18/11/2012
--

- Added "Ignore unnamed objects" in the window handles.
- Added "Set Priority" feature in order to set the priority of a given process.
- Added "Suspend process" and "Resume process" features.
- Added "Suspend all threads before dumping". Using this option you can suspend the execution of a given process before to dump it.
- Added updatevsd.exe.
Cualquier comentario es bienvenido.

Saludos.

lunes, 5 de noviembre de 2012

[RETO] TRVCrackme v1.0

Hola!,

aquí les dejo un reto que envié a la lista de CracksLatinoS! hace ya unas semanas.

Es un crackme muy simple hecho en C para MIPS.

Los detalles están en el README.txt.

Anímense que es muy sencillo!.

Hasta pronto!.

Mas vale tarde que nunca ...

Hola!,

esta entrada debería de haberla hecho hace muuuuuucho tiempo pero entre una cosa y otra no encontraba el momento justo de sentarme a escribir estas líneas.

El 17 y 18 de Septiembre de este año 2012 estuve nuevamente, y como hace tres años ya, junto a Ricardo Narvaja y Ariel Coronel en una nueva edición del training "Defeating Software Protections" en la Ekoparty.

Tal y como vengo haciendo estos años, quería agradecer a los muchachos y muchachas (que este año no hubo) por haber asistido y habernos soportado todas esas horas!!!. A todos ellos, GRACIAS!.

Y como es costumbre también, aquí les dejo una postal:

Hasta pronto!.

miércoles, 12 de septiembre de 2012

[Tips&Tricks] Examinando la IAT con Windbg

Hola!,

el otro día un compañero de trabajo me preguntó si sabía como listar las funciones importadas por un programa utilizando Windbg. En ese momento no tenía idea de como hacerlo pero gracias a un par de búsquedas en google pude encontrar una solución aquí que paso a describirles:

1. Primero que nada, cargamos el ejecutable con el cual queremos trabajar en Windbg (CTRL+E).

2. Primero, utilizaremos el comando "!lmi". Este comando muestra información detallada acerca de un módulo. En nuestro caso, como parámetro, indicaremos el nombre de un ejecutable, en este caso notepad.exe, para obtener algo de información acerca del mismo:

0:001> !lmi notepad.exe
Loaded Module Info: [notepad.exe]
Module: notepad
Base Address: 01000000
Image Name: notepad.exe
Machine Type: 332 (I386)
Time Stamp: 48025287 Sun Apr 13 15:35:51 2008
Size: 14000
CheckSum: 18700
Characteristics: 10f
Debug Data Dirs: Type Size VA Pointer
CODEVIEW 24, 18f0, cf0 RSDS - GUID: {506F162C-C6A5-453B-8F9E-DB55AF72CD9B}
Age: 1, Pdb: notepad.pdb
Symbol Type: DEFERRED - No error - symbol load deferred
Load Report: no symbols loaded
De todos ellos, nos interesa "Base Address".

3. El comando "!dh" sirve para mostrar los headers de un módulo. Tiene algunos parámetros como "-a" para mostrar toda la información de los headers, "-s" para mostrar los sections headers y "-f" para mostrar solo file headers. En nuestro caso, lo que queremos obtener es el address y el size de la IT (ImportTable) listado en los DataDirectories, con lo cual, utilizaremos el parámetro "-f" ya que solo queremos los file headers.

La sintaxis es la siguiente: !dh -f address:

0:000> !dh -f 01000000

File Type: EXECUTABLE IMAGE
FILE HEADER VALUES
14C machine (i386)
3 number of sections
48025287 time date stamp Sun Apr 13 15:35:51 2008

0 file pointer to symbol table
0 number of symbols
E0 size of optional header
10F characteristics
Relocations stripped
Executable
Line numbers stripped
Symbols stripped
32 bit word machine

OPTIONAL HEADER VALUES
10B magic #
7.10 linker version
7800 size of code
A600 size of initialized data
0 size of uninitialized data
739D address of entry point
1000 base of code
----- new -----
01000000 image base
1000 section alignment
200 file alignment
2 subsystem (Windows GUI)
5.01 operating system version
5.01 image version
4.00 subsystem version
14000 size of image
400 size of headers
18700 checksum
00040000 size of stack reserve
00011000 size of stack commit
00100000 size of heap reserve
00001000 size of heap commit
8000 DLL characteristics
Terminal server aware
0 [ 0] address [size] of Export Directory
7604 [ C8] address [size] of Import Directory
B000 [ 8948] address [size] of Resource Directory
0 [ 0] address [size] of Exception Directory
0 [ 0] address [size] of Security Directory
0 [ 0] address [size] of Base Relocation Directory
1350 [ 1C] address [size] of Debug Directory
0 [ 0] address [size] of Description Directory
0 [ 0] address [size] of Special Directory
0 [ 0] address [size] of Thread Storage Directory
18A8 [ 40] address [size] of Load Configuration Directory
250 [ D0] address [size] of Bound Import Directory
1000 [ 348] address [size] of Import Address Table Directory
0 [ 0] address [size] of Delay Import Directory
0 [ 0] address [size] of COR20 Header Directory
0 [ 0] address [size] of Reserved Directory
Como podemos observar, el RVA donde comienza la IAT es 0x1000 y su tamaño es 0x348.

Estos datos los vamos a necesitar en el próximo paso.

4. Por último, vamos a utilizar el comando "dps". Este comando se utiliza para mostrar el contenido de la memoria de un proceso en un rango dado. La sintaxis es "dps [Options] range". En nuestro caso, sería algo así: "dps 01000000+1000 L348/4", donde:

- 01000000: ImageBase de nuestro programa.
- 1000: RVA del inicio de la IAT.
- 348: Size de la IAT.

Con la letra "L" le indicamos el tamaño del ranto que en este caso es el Size de la IAT dividido 4 porque cada entrada en la IAT ocupa 4 bytes (DWORD).

Este es el resultado:

0:001> dps 0x01000000+0x1000 L348/4
01001000 77dd6fef ADVAPI32!RegQueryValueExW
01001004 77dd6c17 ADVAPI32!RegCloseKey
01001008 77dfba25 ADVAPI32!RegCreateKeyW
0100100c 77dfbd05 ADVAPI32!IsTextUnicode
01001010 77dd7aab ADVAPI32!RegQueryValueExA
01001014 77dd7842 ADVAPI32!RegOpenKeyExA
01001018 77ddd757 ADVAPI32!RegSetValueExW
0100101c 00000000
01001020 773dd270 COMCTL32!CreateStatusWindowW
01001024 00000000
01001028 77f2dc19 GDI32!EndPage
0100102c 77f44a05 GDI32!AbortDoc
01001030 77f2dea9 GDI32!EndDoc
01001034 77f16e5f GDI32!DeleteDC
01001038 77f2f456 GDI32!StartPage
0100103c 77f17f9d GDI32!GetTextExtentPoint32W
01001040 77f1be28 GDI32!CreateDCW
[...]
Hay muchas más entradas pero solo coloque unas pocas.

Espero que les sea útil.

Hasta la próxima!.

viernes, 24 de agosto de 2012

Ekoparty Training: Defeating software protections

Hola!,

este post es para hacerles saber que este año 2012 estaremos nuevamente con Ricardo Narvaja, Ariel Coronel y quien escribe, dictando el training de "Defeating Software Protections" en la Ekoparty 2012.

Les dejo un poco de información al respecto:

CONTENIDO:
Cuando una empresa o un programador necesita distribuir su Software, Shareware, Trial o Demo, debe optar por algún mecanismo para proteger la propiedad intelectual de los ojos curiosos de los crackers.

Entonces...¿Qué mejor que un curso de cracking para estar al tanto de las técnicas mas utilizadas a la hora de romper protecciones de software? El conocimiento de las técnicas más comunes de que desprotegen el software, brinda la posibilidad de desarrollar nuevos mecanismos para protegerlo.

El training comenzará con una introducción de assembler(x86) y las herramientas generalmente empleadas, para luego continuar con la descripción del formato ejecutable utilizado en Windows. Se mostrarán diversas técnicas para obtener un serial en memoria, o métodos para patchear instrucciones que permiten desviar la ejecución del programa, con el fin de evitar que se ejecuten funciones no deseadas. La primera jornada finalizará con la creación de un patcher el cual facilita, por ejemplo, la distribución de los cambios hechos en un ejecutable. Durante el transcurso del segundo día se intensificará lo aprendido, aplicándolo a diferentes lenguajes de programación. Se expondrán las técnicas para atacar aplicaciones .NET y Java entre otros.

Se explicará el funcionamiento de las protecciones comerciales ( packers ) y las diferentes formas de atacarlas. También se demostrará como modificar los programas protegidos sin necesidad de desempacar los binarios ( inline patching ).

Los participantes aplicarán los conceptos aprendidos en la resolución de ejercicios creados especialmente para el Training versión EKOparty. Se entregará un manual que contiene más de 300 páginas ilustrativas + un CD con el contenido completo de todo el curso, incluyendo sus ejercicios, herramientas y la foto de Ricardo Narvaja.

Día 1:
* Conceptos básicos y herramientas
* PE structure
* String references
* Serial fishing
* API cracking
* Patchers
* Loaders

Día 2:
* .NET cracking
* Java Cracking
* Unpacking
* OEP finding
* Stolen bytes recovering
* IAT rebuilding
* Ollyscripting
* Inline patching
* Antidumping
* Antidebugging
Es un training de 2 días (16 hs), 17 y 18 de Septiembre, y tiene un costo de ARS $4.000 (IVA incluido).

Los esperamos!.

defeating software protections from ekoparty on Vimeo.


martes, 31 de julio de 2012

ECI 2012

Hola!,

esta pequeñisima entrada es solo para contarles que el Viernes 27 del mes de Agosto estuvimos con Fracisco Falcón brindando nuestra reciente charla, presentada el mes pasado en RECon, en las instalaciones de la Facultad de Ciencias Exactas y Naturales de la Universidad de Buenos Aires, Argentina en el contexto de la ECI, Escuela de Ciencias Informáticas. A continuación les dejo un quote de lo expuesto en la web de la misma:

La Escuela de Ciencias Informáticas (ECI) se lleva a cabo anualmente desde el año 1987 en el Departamento de Computación, Facultad de Ciencias Exactas y Naturales, Universidad de Buenos Aires.

La ECI tiene como objetivo ofrecer a alumnos de la UBA, a alumnos de otras instituciones, a graduados y a profesionales del medio, cursos intensivos de alto nivel de especialización y actualización, sobre temas que habitualmente no se dan en las carreras de grado. Los cursos son dictados por prestigiosos profesores de diversas instituciones, extranjeras y nacionales, lo cual permite brindar a los participantes enfoques variados de los temas tratados y la oportunidad de establecer vínculos de cooperación académica, así como incentivar las actividades de investigación y desarrollo.

Coincidiendo con un esfuerzo nacional para crear una capacidad científica y tecnológica propia en el área de informática, la ECI intenta promover la formación de nuevas generaciones de investigadores y profesionales. A las distintas ediciones de la ECI han concurrido entre 350 y 800 personas que tomaron 2 ó 3 cursos cada una, incluyendo estudiantes de universidades de toda la Argentina y de países limítrofes.

La realización de la escuela es posible gracias a la colaboración de prestigiosos profesores e investigadores de universidades y centros de investigación y desarrollo extranjeros y nacionales, al aporte de la Facultad de Ciencias Exactas y Naturales de la UBA, y al apoyo financiero brindado por diversas empresas privadas e instituciones. Se han realizado también en ediciones anteriores exposiciones de software, equipamiento y libros, tendientes a mejorar el intercambio tecnológico y profesional entre industria y universidad.

A diferencia de RECon, el ambiente en la ECI es académico. La charla fue un poco más distendida que la que dimos en RECon, pudiendo hacerse preguntas durante el desarrollo de la misma, interactuando un poco más con el público y con muchas más preguntas, tal vez a raíz del ambiente académico.

El link a la presentación de la charla la pueden encontrar aquí.

Sin dudas, otra experiencia y muy buena!.

jueves, 21 de junio de 2012

La vuelta de RECon 2012 ...

Hace unos días ya desde que Francisco y yo volvimos de dar nuestra charla en RECon y me pareció que se merecía un post por varias razones:

1- Primero, decir que Montreal es una ciudad increíble. La comida maravillosa, la cerveza espectacular, la gente muy amable y para culminar, el festival al cual asistimos esos días, Les FrancoFolies, fue gigantesco!.

2- RECon estuvo de 10!. La calidad de las charlas fue espectacular, sin dudas es LA conferencia sobre RE.

3- Nuestra charla, gracias a Dios, se desarrolló como lo habíamos planeado. En mi humilde opinión, estuvimos bien, el material fue de calidad y la presentación salió sin nervios y muy clara. Cuando suban los videos ya van a poder apreciar si fue así como les cuento o todo lo contrario.

Además, quería decirles que acá pueden encontrar los slides de la charla y acá pueden encontrar eXait, la herramienta que hicimos para testear todas las técnicas anti-DBI que presentamos.

Por cierto, junto con Francisco, hicimos un post en el blog de Core Security detallando un poquito más como fue la presentación. El post lo pueden leer aquí.

No tengo mucho más para contarles.

Hasta pronto!.

lunes, 4 de junio de 2012

El camino hacia RECon 2012 ...

RECon 2012 está a poco más de una semana!.

REcon es una conferencia sobre temas relacionados con la seguridad informática y reverse engineering organizada en Canada desde 2005. No cuenta con el presupuesto de otras conferencias de este estilo como BlackHat/Defcon, tampoco tiene la cantidad de público de estas otras e inclusive podríamos decir que apunta más a un público local que internacional pero, bajo mi punto de vista, todas estas cosas se compensan con la calidad de las charlas y trainings presentados que, en mi opinión, tienen mayor contenido técnico que las charlas presentadas en BH/Defcon, por ejemplo.

Personas muy reconocidas en el ambiente del RCE como Gerardo Richarte, Alex Ionescu, Rolf Rolles, Tomislav Pericin (ap0x), Nicolas Brulez (Armadillo Copymen), entre otros, presentan charlas y trainigs año a año que le dan a RECon ese título de ser una, sino la, conferencia con el mayor nivel técnico.

Este año, junto con Francisco Falcón, vamos a dar nuestra primer charla en una conferencia de seguridad informática y da la casualidad de que será RECon el lugar para hacerlo.

En nuestra charla titulada "Dynamic Binary Instrumentation Frameworks: I know you're there spying on me" vamos a presentar más de una docena de técnicas para determinar si nuestro programa está siendo o no instrumentado por un framework DBI, haciendo especial foco en Pin. Además, vamos a presentar una herramienta open-source llamada eXait para testear todas la técnicas presentadas durante la charla.

No quiero adelantar nada más de la charla, asi que si quieren saber más los invito a que vayan a RECon o en su defecto que se bajen el material de la charla una vez que termine la conferencia.

Acá les dejo el abstract de nuestra charla.

Hasta pronto!.

"""
Debuggers have been -and still are- the de-facto tool for dynamic analysis of programs. In the last decade a myriad of techniques to detect the presence of these kind of tools have been developed as a defensive measure to avoid the analysis of code during runtime.

Over the past few years, an alternative for dynamic code analysis appeared: Dynamic Binary Instrumentation (DBI) frameworks. These have gained popularity in the information security field, and their usage for reverse engineering tasks is increasing. Nowadays we have DBI-based tools that allow us to perform different kinds of jobs, such as covert debugging, shellcode detection, taint analysis, instruction tracing, automatic unpacking, and self-modifying code analysis, among others.

We believe that as DBI framework-based reverse engineering tools gain popularity, defensive techniques to avoid dynamic code analysis through instrumentation will arise. Our research pretends to be the starting point in the task of documenting and presenting different techniques to detect the presence of DBI framework-based tools.

During our talk we will show over a dozen techniques that can be used to determine if our code is being instrumented focusing on Pin, Intel's DBI framework. We will also release a benchmark-like open source tool, which allows to automatically test every technique discussed in the talk. We call this tool eXait, the eXtensible Anti-Instrumentation Tester.
"""

domingo, 1 de abril de 2012

VSD v2.0 x86

Hola!,

esta entrada es para comentarles que este fin de semana salió un nuevo release de VSD (Virtual Section Dumper).

Esta nueva versión tiene un par de cosas nuevas con respecto a la versión anterior:

* Podemos ver todos los handles abiertos que tiene la aplicación.
* Podemos ver todos los módulos cargados por el programa.
* Dumpear cada uno de los módulos cargados en dos sabores: Full y Parcial.
* Podemos ver los threads del proceso e interactuar con ellos (Terminar, Suspender y Resumir su ejecución).
* Parchear la memoria de un proceso: Al mejor estilo PUPE2002, podemos buscar bytes en la memoria de un proceso indicando una dirección perteneciente al mismo e indicar nuevos bytes para escribir.

Para los puristas, les aviso que el código está igual o peor de horrible que en la versión anterior. Como para la próxima versión quiero agregar varias cosas no me va a quedar otra que organizarlo muy bien y hacer un refactoring enorme porque sino se va a convertir en un bodoque inmantenible :) así que a no desesperar!.

Durante el desarrollo de algunas de las cosas "nuevas" en VSD me crucé con un par de problemas que les voy a ir comentando en próximos posts.

Además de estar trabajando en estas cosas "nuevas", estuve arreglando varios bugs, la mayoría reportados por marciano (Gracias panchote!), y haciendo un poco de refactoring en algunas funciones (solo en un par de ellas).

El que quiera probar esta nueva versión puede visitar la web del proyecto http://code.google.com/p/virtualsectiondumper

Para la próxima versión voy a incluir muchas cosas más, algunas de ellas las pueden encontrar listadas aquí: http://code.google.com/p/virtualsectiondumper/issues/list y otras aquí: http://code.google.com/p/virtualsectiondumper/source/browse/trunk/x86/vsd_win32/vsd_win32/TODO.txt

Tal vez en breve saque una versión 2.1 agregando alguna funcionalidad más pero el grueso vendrá incluido en otra versión mayor pues quiero dedicarle tiempo a otros proyectos que tengo un poco abandonados desde el 2010 como FUU y aadp.

En fin ...

Les dejo un par de screenshots:






martes, 21 de febrero de 2012

VSD v1.0 x64

Hola!,

este post es para comentarles que acabo de subir a la web del proyecto la versión de 64 bits de VSD. Básicamente, es lo mismo que en x86 con la salvedad de que agregué una nueva columna en la ventana principal (ImageType) para saber que tipo de proceso es, 64 bits vs 32 bits.

Pueden encontrar el .zip con el binario y el source code en la web del proyecto: http://code.google.com/p/virtualsectiondumper

Les dejo un screenshot:


Hasta pronto!.

domingo, 19 de febrero de 2012

aadp4immdbg para ImmunityDebugger >= 1.80

Hola!,

este pequeño post es para comentarles que acabo de subir a la web del proyecto aadp una versión del plugin aadp4immdbg para ImmunityDebugger >= 1.80. La versión que se encontraba en la web hasta el día de hoy era para la versión 1.73.

Debo advertirles que no tuve demasiado tiempo para probar esta "nueva" versión así que si encuentran algún bug, por favor, envienme un mail así puedo corregirlo a la brevedad.

Esta versión no incorpora ningún cambio significativo con respecto a la anterior, de hecho, la he versionado igual que la anterior porque la única diferencia radica en el nombre de las funciones exportadas.

Pueden bajarse esta versión desde la web del proyecto http://code.google.com/p/aadp

Hasta pronto!.

sábado, 18 de febrero de 2012

aadlib liberada bajo LGPL v3

Hola!,

este post es para contarles que he subido el código de aadlib, el core de aadp4olly, a googlecode bajo licencia LGPL v3.

Pueden bajarse el código de la web del proyecto: http://code.google.com/p/aadp

Hasta pronto!.

jueves, 16 de febrero de 2012

Virtual Section Dumper v1.0 x86 (VSD)

Hola!,

pasó mucho rato desde mi último post pero no importa porque ahora estoy de vuelta.

En esta ocasión, es para hacerles saber de una nueva herramienta que estuve desarrollando durante este último tiempo, VSD.

Virtual Section Dumper es, básicamente, una herramiente para Windows que les permitirá dumpear las secciones virtuales de un proceso (solo 32 bits por el momento).

Para el que quiera mayor información, puede visitar la web del proyecto: http://code.google.com/p/virtualsectiondumper

Quiero agradecer a marciano, MCKSys, Guan de Dio, Nacho_dj y Shub-Nigurrath porque, como es costumbre ya, son ellos quienes prueban mis herramientas y leen mis tutoriales antes de que se publiquen, me dan ideas para mejorar las cosas que hago y me soportan día a día!.

Les dejo un screenshot:


Hasta la próxima!.