ShellNoob

Escribir shellcodes siempre ha sido muy divertido, pero algunas partes son extremadamente aburridas y propensas a errores. ¡Concéntrate solo en la parte divertida y usa ShellNoob!

Para una visión rápida, consulta las diapositivas de la charla en Black Hat Arsenal: link

¿Quieres contribuir? ¿Solicitud de funcionalidad? ¿Reporte de error? ¿Insultos? Todo comentario es bienvenido! (Pero algunos tipos de comentarios son más bienvenidos que otros :-)).

No dudes en contactarme en twitter @reyammer o enviarme un correo a yanick[AT]cs.ucsb.edu si tienes alguna pregunta!

Colaboradores y Reconocimientos

• Levente Polyak (@anthraxx42)
  • Añadió soporte para Python 3
  • Correcciones de errores
• @ToolsWatch y el equipo de Black Hat
  • Me dieron la oportunidad de mostrar mi herramienta :D

Novedades

• 21/01/2014 - ¡ShellNoob 2.1 está disponible! Incluye soporte completo para Python 3 y muchas correcciones de errores. ¡Todo el crédito es para Levente Polyak!

• 29/07/2013 - ¡ShellNoob 2.0 está disponible!

• 08/06/2013 - ¡ShellNoob fue aceptado en Black Hat Arsenal! Ver anuncio aquí: link.

Características

• convertir shellcode entre diferentes formatos y fuentes. Formatos actualmente soportados: asm, bin, hex, obj, exe, C, python, ruby, pretty, safeasm, completec, shellstorm. (Todos los detalles en la sección "Descripción de formatos")
• modo interactivo de conversión asm a opcode (y viceversa). Esto es útil cuando no puedes usar bytes específicos en el shellcode y quieres determinar si una instrucción de ensamblador específica causará problemas.
• soporte tanto para sintaxis ATT como Intel. Ver el modificador --intel.
• soporte para 32 y 64 bits (cuando se trabaja en una máquina x86_64). Ver el modificador --64.
• resuelve números de syscall, constantes y números de error (¡ahora implementado de verdad! :-)).
• portable y fácil de desplegar (solo depende de gcc/as/objdump y python). ¡Es solo un script de Python autocontenido, y soporta tanto Python2.7+ como Python3+.
• desarrollo in situ: ¡ejecutas ShellNoob directamente en la arquitectura objetivo!
• soporte incorporado para Linux/x86, Linux/x86_64, Linux/ARM, FreeBSD/x86, FreeBSD/x86_64.
• opción "prepend breakpoint". Ver el modificador -c.
• soporte para leer desde stdin / escribir en stdout (usar "-" como nombre de archivo)
• depuración super barata: ¡ver las opciones --to-strace y --to-gdb!
• ¡Usa ShellNoob como módulo de Python en tus scripts! Ver la sección "ShellNoob como biblioteca".
• El modo verbose muestra los pasos de bajo nivel de la conversión: útil para depurar / entender / aprender!
• Plugins extra: parcheo binario facilitado con las opciones --file-patch, --vm-patch, --fork-nopper! (todos los detalles abajo)

Casos de Uso

Ayuda incorporada

$ ./shellnoob.py -h
shellnoob.py [--from-INPUT] (input_file_path | - ) [--to-OUTPUT] [output_file_path | - ]
shellnoob.py -c (añadir un breakpoint (Advertencia: solo pocas plataformas/OS están soportadas!)
shellnoob.py --64 (modo de 64 bits, por defecto: 32 bits)
shellnoob.py --intel (modo sintaxis Intel, por defecto: att)
shellnoob.py -q (modo silencioso)
shellnoob.py -v (o -vv, -vvv)
shellnoob.py --to-strace (lo compila y ejecuta strace)
shellnoob.py --to-gdb (lo compila y ejecuta gdb y establece breakpoint en el punto de entrada)

Plugins "independientes"
shellnoob.py -i [--to-asm | --to-opcode ] (para modo interactivo)
shellnoob.py --get-const <const>
shellnoob.py --get-sysnum <sysnum>
shellnoob.py --get-errno <errno>
shellnoob.py --file-patch <exe_fp> <file_offset> <data> (en hex). (Advertencia: probado solo en x86/x86_64)
shellnoob.py --vm-patch <exe_fp> <vm_address> <data> (en hex). (Advertencia: probado solo en x86/x86_64)
shellnoob.py --fork-nopper <exe_fp> (esto nopea las llamadas a fork(). Advertencia: probado solo en x86/x86_64)

"Instalación"
shellnoob.py --install [--force] (esto solo copia el script en una ubicación conveniente)
shellnoob.py --uninstall [--force]

Formato INPUT soportado: asm, obj, bin, hex, c, shellstorm
Formato OUTPUT soportado: asm, obj, exe, bin, hex, c, completec, python, bash, ruby, pretty, safeasm
¡Todas las combinaciones de INPUT a OUTPUT están soportadas!

Instalación (solo si quieres)

$ ./shellnoob.py --install

Esto solo copiará el script a /usr/local/bin/snoob. Eso es todo. (Ejecuta ./shellnoob.py --uninstall para deshacerlo).

Convertir shellcode de/a diferentes formatos con una CLI súper flexible.

$ snoob --from-asm shell.asm --to-bin shell.bin

Algunas alternativas equivalentes (la herramienta intentará adivinar lo que quieres dada la extensión del archivo..)

$ snoob --from-asm shell.asm --to-bin
$ snoob shell.asm --to-bin
$ snoob shell.asm --to-bin - > shell.bin
$ cat shell.asm | snoob --from-asm - --to-bin - > shell.bin

Descripción de formatos

• "asm" - ensamblador estándar. Sintaxis ATT por defecto, usa --intel para usar sintaxis Intel. (ver sección "asm como formato de salida" para más detalles)
• "bin" - binario crudo ('\x41\x42\x43\x44')
• "hex" - binario crudo codificado en hex ('41424344')
• "obj" - un ELF
• "exe" - un ELF ejecutable
• "c" - algo listo para incrustar en un programa C.
• "python", "bash", "ruby" - igual que aquí.
• "completec" - C compilable que establece la memoria como RWX correctamente (para soportar shellcodes auto-modificables)
• "safeasm" - ensamblador que es 100% ensamblable: a veces la salida de objdump, de la cual se toma "asm", no es ensamblable. Esto sacará los bytes "crudos" (en notación .byte) para que sea ensamblable por "as".
• "shellstorm" - El modificador --from-shellstorm toma como argumento un <shellcode_id>. ShellNoob obtendrá el shellcode seleccionado de la base de datos de shellcodes de shell-storm, y lo convertirá al formato seleccionado.

Depuración fácil

$ snoob -c shell.asm --to-exe shell
$ gdb -q shell
$ run
Reading symbols from ./shell...(no debugging symbols found)...done.
(gdb) run
Starting program: ./shell

Program received signal SIGTRAP, Trace/breakpoint trap.
0x08048055 in ?? ()
(gdb) 

O puedes usar los nuevos modificadores --to-strace y --to-gdb!

$ snoob open-read-write.asm --to-strace
Convirtiendo open-read-write.asm (asm) a /tmp/tmpBaQbzP (exe)
execve("/tmp/tmpBaQbzP", ["/tmp/tmpBaQbzP"], [/* 97 vars */]) = 0
[ Process PID=12237 runs in 32 bit mode. ]
open("/tmp/secret", O_RDONLY)           = 3
read(3, "thesecretisthedolphin\n", 255) = 22
write(1, "thesecretisthedolphin\n", 22thesecretisthedolphin
) = 22
_exit(0)  

$ snoob open-read-write.asm --to-gdb
Convirtiendo open-read-write.asm (asm) a /tmp/tmpZdImWw (exe)
Reading symbols from /tmp/tmpZdImWw...(no debugging symbols found)...done.
(gdb) Breakpoint 1 at 0x8048054
(gdb)

¡Observa cómo ShellNoob establece automáticamente un breakpoint en el punto de entrada!

Obtener números de syscall, constantes y errno

$ snoob --get-sysnum read
i386 ~> 3
x86_64 ~> 0
$ snoob --get-sysnum fork
i386 ~> 2
x86_64 ~> 57

$ snoob --get-const O_RDONLY
O_RDONLY ~> 0
$ snoob --get-const O_CREAT
O_CREAT ~> 64
$ snoob --get-const EINVAL
EINVAL ~> 22

$ snoob --get-errno EINVAL
EINVAL ~> Invalid argument
$ snoob --get-errno 22
22 ~> Invalid argument
$ snoob --get-errno EACCES
EACCES ~> Permission denied
$ snoob --get-errno 13
13 ~> Permission denied

Modo interactivo

$ ./shellnoob.py -i --to-opcode
asm_to_opcode selected
>> mov %eax, %ebx
mov %eax, %ebx ~> 89c3
>> 

./shellnoob.py -i --to-asm
opcode_to_asm selected
>> 89c3
89c3 ~> mov %eax,%ebx
>>