Listado de la etiqueta: Radare2

Introducción a Frida

¿Qué es Frida?

Frida es un framework de instrumentación de binarios multiplataforma: en el momento de escribir este artículo, Frida puede ser usado en Windows, Mac, Linux, iOS y Android.

Frida funciona inyectando el motor de JavaScript V8 en aplicaciones nativas. De esta manera, Frida puede ejecutar código JavaScript en el contexto de la aplicación en la que está inyectado, pudiendo así acceder a la memoria, hookear funciones, llamarlas, etc.

Frida no es sólo una librería. Frida trae consigo un conjunto de herramientas que te pueden ayudar a la hora de realizar una análisis de un aplicación.

En este post os mostraré algunas de las capacidades de Frida mediante la realización de una serie de ejercicios prácticos en los que analizaremos un binario compilado para OSx (Mach-O 64-bit executable x86_64).

Nota: el código del programa utilizado en estos ejercicios es el que aparece a continuación de estas lineas. Pero para intentar darle un poco de realismo, se va a tratar el binario como si fuera una caja negra

Analizando el binario

Analizando el binario con radare2 (o haciendo trampa y mirando el código) se puede ver que el programa pide una contraseña y luego comprueba si esta es buena
o no.
Si la contraseña es correcta devuelve el mensaje «Yey!», y si no es buena «Nice try, but nope».

$ r2 poc
 -- Experts agree, security holes suck, and we fixed some of them!
[0x100000e60]> pd 60 @ main
    ;-- main:
    ;-- entry0:
    ;-- _main:
    ;-- func.100000e60:
            0x100000e60      55             push rbp
            0x100000e61      4889e5         mov rbp, rsp
            0x100000e64      4883ec50       sub rsp, 0x50
            0x100000e68      c745fc000000.  mov dword [rbp - 4], 0
            0x100000e6f      897df8         mov dword [rbp - 8], edi
            0x100000e72      488975f0       mov qword [rbp - 0x10], rsi
            0x100000e76      c745ec000000.  mov dword [rbp - 0x14], 0
        .-> 0x100000e7d      488d3d080100.  lea rdi, [rip + 0x108]     ; 0x100000f8c ; section.3.__cstring ; "Password: " @ 0x100000f8c
        |   0x100000e84      b000           mov al, 0
        |   0x100000e86      e88f000000     call sym.imp.printf
        |   0x100000e8b      488d3d050100.  lea rdi, [rip + 0x105]     ; 0x100000f97 ; str._10s ; "%10s" @ 0x100000f97
        |   0x100000e92      488d75cc       lea rsi, [rbp - 0x34]
        |   0x100000e96      8945c8         mov dword [rbp - 0x38], eax
        |   0x100000e99      b000           mov al, 0
        |   0x100000e9b      e880000000     call sym.imp.scanf
        |   0x100000ea0      488d7dcc       lea rdi, [rbp - 0x34]
        |   0x100000ea4      c645dd64       mov byte [rbp - 0x23], 0x64 ; [0x64:1]=0 ; 'd'
        |   0x100000ea8      c645d949       mov byte [rbp - 0x27], 0x49 ; [0x49:1]=0 ; 'I'
        |   0x100000eac      c645de65       mov byte [rbp - 0x22], 0x65 ; [0x65:1]=0 ; 'e'
        |   0x100000eb0      c645d653       mov byte [rbp - 0x2a], 0x53 ; [0x53:1]=0 ; 'S'
        |   0x100000eb4      c645df00       mov byte [rbp - 0x21], 0
        |   0x100000eb8      c645d765       mov byte [rbp - 0x29], 0x65 ; [0x65:1]=0 ; 'e'
        |   0x100000ebc      c645da6e       mov byte [rbp - 0x26], 0x6e ; [0x6e:1]=0 ; 'n'
        |   0x100000ec0      c645dc69       mov byte [rbp - 0x24], 0x69 ; [0x69:1]=0 ; 'i'
        |   0x100000ec4      c645d863       mov byte [rbp - 0x28], 0x63 ; [0x63:1]=0 ; 'c'
        |   0x100000ec8      c645db73       mov byte [rbp - 0x25], 0x73 ; [0x73:1]=69 ; 's' ; "EXT" @ 0x73
        |   0x100000ecc      8945c4         mov dword [rbp - 0x3c], eax
        |   0x100000ecf      e8fcfeffff     call sym._encrypt_arg
        |   0x100000ed4      488d75d6       lea rsi, [rbp - 0x2a]
        |   0x100000ed8      488945e0       mov qword [rbp - 0x20], rax
        |   0x100000edc      488b7de0       mov rdi, qword [rbp - 0x20]
        |   0x100000ee0      e847000000     call sym.imp.strcmp
        |   0x100000ee5      83f800         cmp eax, 0
       ,==< 0x100000ee8      0f8416000000   je 0x100000f04
       ||   0x100000eee      488d3da70000.  lea rdi, [rip + 0xa7]      ; 0x100000f9c ; str.Nice_try__but_nope_n ; "Nice try, but nope." @ 0x100000f9c
       ||   0x100000ef5      b000           mov al, 0
       ||   0x100000ef7      e81e000000     call sym.imp.printf
       ||   0x100000efc      8945c0         mov dword [rbp - 0x40], eax
      ,===< 0x100000eff e911000000 jmp 0x100000f15 |`--> 0x100000f04      488d3da50000.  lea rdi, [rip + 0xa5]      ; 0x100000fb0 ; str.Yey__n ; "Yey!." @ 0x100000fb0
      | |   0x100000f0b      b000           mov al, 0
      | |   0x100000f0d      e808000000     call sym.imp.printf
      | |   0x100000f12      8945bc         mov dword [rbp - 0x44], eax
      `-`=< 0x100000f15      e963ffffff     jmp 0x100000e7d

El mensaje «Yey!» se puede ver en la linea 46 y «Nice try, buy nope.»en la linea 42.
Analizando cómo llegar a «Yey!», vemos la siguiente parte del código, dónde se llama a strcmp y si las dos cadenas son iguales, salta a la parte del código que hará que se escriba «Yey!»:

        |   0x100000ee0      e847000000     call sym.imp.strcmp
        |   0x100000ee5      83f800         cmp eax, 0
       ,==< 0x100000ee8      0f8416000000   je 0x100000f04

Analicemos el resto de llamadas que ocurren en el main del programa:
r2VV
Primero hay una llamada a printf y luego una a scanf. Sin saber nada de ingeniería inversa, sólo ejecutando el binario podemos imaginar que se trata de la petición de contraseña que aparece al ejecutar el programa:

Después de eso se llama a la función encrypt_arg y por ultimo el resultado de esa función se pasa a strcmp, que lo compara con la cadena que se forma con la ejecución de las siguientes instrucciones:

        |   0x100000ea4      c645dd64       mov byte [rbp - 0x23], 0x64 ; [0x64:1]=0 ; 'd'
        |   0x100000ea8      c645d949       mov byte [rbp - 0x27], 0x49 ; [0x49:1]=0 ; 'I'
        |   0x100000eac      c645de65       mov byte [rbp - 0x22], 0x65 ; [0x65:1]=0 ; 'e'
        |   0x100000eb0      c645d653       mov byte [rbp - 0x2a], 0x53 ; [0x53:1]=0 ; 'S'
        |   0x100000eb4      c645df00       mov byte [rbp - 0x21], 0
        |   0x100000eb8      c645d765       mov byte [rbp - 0x29], 0x65 ; [0x65:1]=0 ; 'e'
        |   0x100000ebc      c645da6e       mov byte [rbp - 0x26], 0x6e ; [0x6e:1]=0 ; 'n'
        |   0x100000ec0      c645dc69       mov byte [rbp - 0x24], 0x69 ; [0x69:1]=0 ; 'i'
        |   0x100000ec4      c645d863       mov byte [rbp - 0x28], 0x63 ; [0x63:1]=0 ; 'c'
        |   0x100000ec8      c645db73       mov byte [rbp - 0x25], 0x73 ; [0x73:1]=69 ; 's' ; "EXT" @ 0x73

Dependiendo del resultado de esa comparación, podremos saltaremos a «Yey!», o no.

Para resolver este ejercicio, necesitamos primero saber cual es la cadena contra la compara strcmp y luego saber que es lo que hace la función encrypt_arg con la password que introducimos antes de pasársela a strcmp. En ese momento podremos generar una cadena que tras ser procesada por encrypt_arg sea igual que el segundo argumento de strcmp.

Solucionando nuestros problemas usando Frida

Normalmente este tipo de cosas se pueden solucionar leyendo ensamblador y reformando la cadena, este es el caso de nuestro binario. Pero otras veces, esta cadena se forma dinámicamente en tiempo de ejecución hay que ir paso a paso con el debugger mirando la cadena que se forma.
O, si lo que queremos es sólo llegar a «Yey!» podríamos parchear la instrucción je 0x100000f04 para convertirla en un salto incondicional. Pero esto se trata de utilizar Frida, así que veamos que podemos hacer con Frida.
Frida nos permite interceptar la función y mandarnos un mensaje con el contenido de los argumentos de la función.
Para ello basta con escribir un modulo en python de este estilo:

import frida
import sys

session = frida.attach(int(sys.argv[2]))
script = session.create_script("""
Interceptor.attach(ptr("%s"), {
    onEnter: function (args) {
        send("arg[0]: " + Memory.readCString(args[0]));
        send("arg[1]: " + Memory.readCString(args[1]));
    }
});
""" % int(sys.argv[1], 16))

def on_message(message, data):
    print message['payload']

script.on('message', on_message)
script.load()
sys.stdin.read()

Este script va a interceptar la llamada en la dirección que le pasemos como primer parámetro, del proceso cuyo PID pasemos como segundo parámetro.
La dirección de la llamada función se puede sacar de muchas maneras, pero en el video de demostración que podéis ver a continuación, he usado radare2 para depurar el proceso y encontrar la dirección.

Ya sabemos entonces que la cadena que introducimos se procesa de alguna manera y se compara con SecInside. Ahora podríamos analizar la función que «cifra» la cadena (que en este caso es muy fácil, o usar Frida para hacer que strcmp siempre se cumpla.

Para eso tenemos dos opciones: hookear la llamada y modificar los argumentos, o modificar el valor de retorno. Para ambos casos la API de Frida nos lo pone fácil con sus «onEnter» y «onLeave».
En el primer caso querremos que al entrar el primer argumento sea igual que el segundo. Este se consigue muy fácil modificando un poco el script anterior:

import frida
import sys

session = frida.attach(int(sys.argv[2]))
script = session.create_script("""
Interceptor.attach(ptr("%s"), {
    onEnter: function (args) {
	args[0] = args[1]
        send("arg[0]: " + Memory.readCString(args[0]));
        send("arg[1]: " + Memory.readCString(args[1]));
    }
});
""" % int(sys.argv[1], 16))

def on_message(message, data):
    print message['payload']

script.on('message', on_message)

script.load()
sys.stdin.read()

En este caso la parte de los mensajes no es necesaria, pero la he dejado para que se vea claramente lo que está pasando. La clave está en la linea 8, dónde le decimos que al entrar en la función args[0] = args[1].
En el segundo caso, lo que haremos será aprovechar onLeave para modificar el valor de salida de strcmp que lo modificaremos para que siempre diga que las cadenas son iguales. Es decir, que siempre devuelva 0:

import frida
import sys

session = frida.attach(int(sys.argv[2]))
script = session.create_script("""
Interceptor.attach(ptr("%s"), {
    onEnter: function (args) {
        send("arg[0]: " + Memory.readCString(args[0]));
        send("arg[1]: " + Memory.readCString(args[1]));
    },
    onLeave: function (retval) {
	retval.replace(0);
    }
});
""" % int(sys.argv[1], 16))

def on_message(message, data):
    print message['payload']

script.on('message', on_message)

script.load()
sys.stdin.read()

Como podéis ver, he utilizado también onEnter, pero la única razón por la que aparece es para registrar la actividad y que se vea un poco mejor lo que está pasando.
A continuación un video con estos dos scripts en acción:

Esto son sólo unos ejemplos simples de las cosas que se pueden hacer con Frida, pero vale que para lo que no lo conocíais, tengáis una idea general de las cosas que permite automatizar con unas pocas lines de JavaScript. Si te ha llamado la atención, pruébalo y cuéntanos que tal te fue en los comentarios. ¡Hasta la próxima!

open source security

5 Proyectos de seguridad Open Source que me han salvado la vida

… y uno que me mola muchísimo.
En la entrada de esta semana quería dejaros un listado de herramientas de seguridad open source que en algún momento me han sacado de algún problema, han hecho mi trabajo más fácil, me han resultado interesantes o me han servido para sacar adelante un reto en un CTF.

Radare2

r2logo3La primera herramienta de la os quiero hablar es Radare2. Seguramente la más conocida dentro de la comunidad hispanohablante ya que su desarrollador es .cat y es un habitual dando charlas en los diversos congresos de seguridad que tienen lugar en España.
Para los que no conozcan Radare2, se podría resumir en que es un framework para realizar ingeniería inversa. Una de las cosas que más me gusta de Radare es el soporte a arquitecturas y formatos de ficheros marcianos que otros programas de ingeniería inversa no soportan nativamente. Según su documentación:


Architectures:
6502, 8051, CRIS, H8/300, LH5801, T8200, arc, arm, avr, bf, blackfin, csr, dalvik, dcpu16, gameboy, i386, i4004, i8080, m68k, malbolge, mips, msil, msp430, nios II, powerpc, rar, sh, snes, sparc, tms320 (c54x c55x c55+), V810, x86-64, zimg, risc-v.
File Formats:
bios, CGC, dex, elf, elf64, filesystem, java, fatmach0, mach0, mach0-64, MZ, PE, PE+, TE, COFF, plan9, dyldcache, Commodore VICE emulator, Game Boy (Advance), Nintendo DS ROMs and Nintendo 3DS FIRMs.

Una de las peculiaridades de Radare2 es que está en constante desarrollo. Si te has descargado Radare2 al empezar a leer este artículo, será mejor que vayas haciendo checkout otra vez porque seguramente a estas alturas estés desactualizado. Para estar, más o menos, al día de lo que pasa en Radare2 puedes seguir el proyecto en Twitter o echar un ojo al blog de vez en cuando.

Osquery

logo-bigEsta herramienta me llamo la atención desde el momento en que la vi en acción en un taller en BruCON. Se trata de un programa desarrollado por el equipo de respuesta ante incidentes de Facebook para poder realizar actividades de live response en sistemas OS X y Linux.
Osquery nos permite realizar consultas al sistema utilizando la sintaxis de SQLite. Estas consultas son muchas veces independientes del sistema operativo, lo que permite el acceso a la información de distintos sistemas utilizando la misma consulta.
Además de la consola interactiva desde la que lanzar consultas, Osquery te permite ejecutar un servicio que va a realizar consultas periódicamente y escribir los cambios en un log que luego pueden ser procesados por un correlador en busca de comportamientos anómalos.

Loki

lokiiconLoki es un escáner simple de indicadores de compromiso (IOC). En el momento de escribir este artículo, Loki sólo soporta los siguientes tipos de IOC:

  • Nombre de fichero (expresión regular)
  • Hash de un fichero
  • Conexiones contra direcciones IP/dominios
  • Reglas YARA

Loki llama la atención principalmente por ser el hermano pequeño de Thor. Thor es un escáner de IOCs, pero esta vez no es simple y su funcionalidad es mucho mayor… pero no es open source. Aun así Thor está haciendo ruido en la comunidad DFIR por su velocidad a la hora de escanear el sistema de ficheros, característica que comparte con Loki y que hace a este más interesante.
Además, con un poquito que te manejes con python, ampliar las capacidades de Loki es realmente sencillo.

Snort/Suricata

suri-400x400Estos dos proyectos vienen de la mano ya que cumplen una misma función: Sistema de Detección de Intrusiones (IDS).
Mi experiencia usando estos dos sistemas es como IDS y como herramienta para analizar el alcance de un incidente en una red. Los dos proyectos pueden hacer los dos trabajos perfectamente, pero en el segundo caso yo prefiero usar Suricata antes que Snort.
La razón por la que prefiero usar Suricata es que permite una mayor granularidad a la hora de escribir reglas. Mientras que Snort te obliga a definir una regla sobre tráfico http como TCP, Suricata te permite definirla como http. Esto permite escribir reglas más estrictas y reducir el número de falsos positivos, lo que a la hora de encontrar comportamientos específicos en la red viene muy bien.
Snortpig_professor2(NOTA: La versión 3 de Snort ha salido hace poco y no sé si han cambiado algo en la sintaxis de las reglas, por lo que es posible que las reglas de Snort 3 permitan la misma granularidad que Suricata.)
Es importante saber que este tipo de productos requieren un mantenimiento en forma de actualización de reglas y, sobre todo al principio, invertir tiempo en la personalización de las reglas para que se adapten a tu entorno y no estén llenado la consola de los analistas de falsos positivos.

Volatility

vVolatility desde hace unos años se ha convertido en el estándar de facto en lo que a análisis forense de memoria se refiere.
Soporta múltiples tipos de imágenes de memoria, incluido soporte inicial para imágenes de Windows 10.
Tiene por detrás un gran soporte de la comunidad, lo que hace que cada cierto tiempo aparezcan plugins que extienden la funcionalidad de este proyecto. Además, escribir este tipo de plugins es relativamente sencillo si necesitas adaptar ciertas cosas para el análisis en el que estás trabajando.

DVRF

Este último proyecto no lo he probado aún, pero que estoy esperando tener un poco de tiempo libre para poder hincarle el diente: Damn Vulnerable Router Firmware (DVRF).
Es un proyecto diseñado para introducir a la gente en el mundo de la ingeniería inversa de firmware. Esta preparado para ser instalado en un Linksys E1550, pero si no tienes uno en casa puedes trabajar en ello usando Qemu.
Hasta han publicado también una pequeña guía con los primeros pasos que hay que dar para tener DVRF en Qemu.

Como veis hay muchos proyectos open source que nos pueden ayudar a realizar nuestro trabajo en seguridad sin invertir dinero en licencias. Estos son solo algunos de los múltiples proyectos que se usan día a día en seguridad, muchos se han quedado fuera (Metasploit, Bro, Cuckoo, Rekall…).
Por último, me gustaría que vosotros, lectores, compartierais los proyectos open source de seguridad que más os gusten o que os han salvado el día, ya sea ayudándoos a explotar una vulnerabilidad marciana, detectando un bicho que el antivirus no cazaba, o bastionando un sistema que tenía que estar en producción para ayer.
Además, si tienes un proyecto personal que te gustaría compartir y dar visibilidad, déjalo en los comentarios. Quién sabe, a lo mejor en una futura entrada sobre proyectos de seguridad open source puede aparecer en la lista, ¡o puede salir una colaboración con el blog!