ShellNoob

Escrever shellcodes sempre foi super divertido, mas algumas partes são extremamente chatas e propensas a erros. Foque apenas na parte divertida e use ShellNoob!

Para uma visão geral rápida, confira os slides da palestra do Black Hat Arsenal: link

Quer contribuir? Pedido de recurso? Relatório de bug? Palavrões? Todo feedback é bem-vindo!! (Mas alguns tipos de feedback são mais bem-vindos do que outros :-)).

Sinta-se à vontade para me chamar no twitter @reyammer ou para me enviar um e-mail para yanick[AT]cs.ucsb.edu com qualquer dúvida!

Contribuidores e Agradecimentos

• Levente Polyak (@anthraxx42)
  • adicionou suporte ao Python 3
  • correções de bugs
• @ToolsWatch & equipes do Black Hat
  • Eles me deram a chance de exibir minha ferramenta :D

Novidades

• 01/21/2014 - ShellNoob 2.1 foi lançado! Ele vem com suporte total para Python 3 e toneladas de correções de bugs. Todos os créditos vão para Levente Polyak!

• 07/29/2013 - ShellNoob 2.0 foi lançado!

• 06/08/2013 - ShellNoob foi aceito no Black Hat Arsenal! Veja o anúncio aqui: link.

Recursos

• converta shellcode entre diferentes formatos e fontes. Formatos atualmente suportados: asm, bin, hex, obj, exe, C, python, ruby, pretty, safeasm, completec, shellstorm. (Todos os detalhes na seção "Descrição dos formatos".)
• modo interativo de conversão asm-para-opcode (e vice-versa). Isso é útil quando você não pode usar bytes específicos no shellcode e quer descobrir se uma instrução de assembly específica causará problemas.
• suporte para sintaxe ATT e Intel. Verifique a opção --intel.
• suporte para 32 e 64 bits (quando estiver em uma máquina x86_64). Verifique a opção --64.
• resolva números de syscall, constantes e números de erro (agora implementado de verdade! :-)).
• portátil e facilmente implantável (depende apenas de gcc/as/objdump e python). É apenas um script python autocontido e suporta tanto Python2.7+ quanto Python3+.
• desenvolvimento no local: você executa o ShellNoob diretamente na arquitetura alvo!
• suporte nativo para Linux/x86, Linux/x86_64, Linux/ARM, FreeBSD/x86, FreeBSD/x86_64.
• opção "prepend breakpoint". Verifique a opção -c.
• suporte para ler da stdin / escrever na stdout (use "-" como nome de arquivo)
• depuração super barata: verifique as opções --to-strace e --to-gdb!
• Use o ShellNoob como um módulo Python em seus scripts! Consulte a seção "ShellNoob como biblioteca".
• O modo verboso mostra as etapas de baixo nível da conversão: útil para depurar / entender / aprender!
• Plugins extras: correção de binários facilitada com as opções --file-patch, --vm-patch, ! (todos os detalhes abaixo)

Casos de Uso

Ajuda embutida

$ ./shellnoob.py -h
shellnoob.py [--from-INPUT] (input_file_path | - ) [--to-OUTPUT] [output_file_path | - ]
shellnoob.py -c (prepend a breakpoint (Warning: only few platforms/OS are supported!)
shellnoob.py --64 (64 bits mode, default: 32 bits)
shellnoob.py --intel (intel syntax mode, default: att)
shellnoob.py -q (quite mode)
shellnoob.py -v (or -vv, -vvv)
shellnoob.py --to-strace (compiles it & run strace)
shellnoob.py --to-gdb (compiles it & run gdb & set breakpoint on entrypoint)

Standalone "plugins"
shellnoob.py -i [--to-asm | --to-opcode ] (for interactive mode)
shellnoob.py --get-const <const>
shellnoob.py --get-sysnum <sysnum>
shellnoob.py --get-errno <errno>
shellnoob.py --file-patch <exe_fp> <file_offset> <data> (in hex). (Warning: tested only on x86/x86_64)
shellnoob.py --vm-patch <exe_fp> <vm_address> <data> (in hex). (Warning: tested only on x86/x86_64)
shellnoob.py --fork-nopper <exe_fp> (this nops out the calls to fork(). Warning: tested only on x86/x86_64)

"Installation"
shellnoob.py --install [--force] (this just copies the script in a convinient position)
shellnoob.py --uninstall [--force]

Supported INPUT format: asm, obj, bin, hex, c, shellstorm
Supported OUTPUT format: asm, obj, exe, bin, hex, c, completec, python, bash, ruby, pretty, safeasm
All combinations from INPUT to OUTPUT are supported!

Instalação (somente se você quiser)

$ ./shellnoob.py --install

Isso simplesmente copia o script para /usr/local/bin/snoob. Só isso. (Execute ./shellnoob.py --uninstall para desfazer).

Converta shellcode de/para diferentes formatos com uma CLI super flexível.

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

Algumas alternativas equivalentes (a ferramenta tentará adivinhar o que você quer com base na extensão do arquivo..)

$ 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

Descrição dos formatos

• "asm" - assembly padrão. Sintaxe ATT por padrão, use --intel para usar a sintaxe Intel. (veja a seção "asm como saída" para mais detalhes)
• "bin" - binário bruto ('\x41\x42\x43\x44')
• "hex" - binário bruto codificado em hexadecimal ('41424344')
• "obj" - um ELF
• "exe" - um ELF executável
• "c" - algo pronto para embutir em um programa C.
• "python", "bash", "ruby" - o mesmo aqui.
• "completec" - C compilável que define corretamente a memória como RWX (para suportar shellcodes automodificáveis)
• "safeasm" - assembly que é 100% montável: às vezes, a saída do objdump, da qual o "asm" é extraído, não é montável. Isso gerará os bytes "brutos" (em notação .byte) para que seja montável pelo "as".
• "shellstorm" - A opção --from-shellstorm recebe como argumento um <shellcode_id>. O ShellNoob buscará o shellcode selecionado no banco de dados de shellcodes do shell-storm e o converterá para o formato selecionado.

Depuração 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) 

Ou você pode usar as novas opções --to-strace e --to-gdb!

$ snoob open-read-write.asm --to-strace
Converting open-read-write.asm (asm) into /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
Converting open-read-write.asm (asm) into /tmp/tmpZdImWw (exe)
Reading symbols from /tmp/tmpZdImWw...(no debugging symbols found)...done.
(gdb) Breakpoint 1 at 0x8048054
(gdb)

Observe como o ShellNoob define automaticamente um breakpoint no ponto de entrada!

Obtenha números de syscall, constantes e 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 interativo

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

ShellNoob como biblioteca

$ python
>>> from shellnoob import ShellNoob
>>> sn = ShellNoob(flag_intel=True)

>>> sn.asm_to_hex('nop; mov ebx,eax; xor edx,edx')
'9089c331d2'
>>> sn.hex_to_inss('9089c331d2')
['nop', 'mov ebx,eax', 'xor edx,edx']

>>> sn.do_resolve_syscall('fork')
i386 ~> 2
x86_64 ~> 57

Asm como formato de saída

Quando "asm" é o formato de saída, o ShellNoob fará o seu melhor. O objdump é usado como desmontador, mas sua saída não é à prova de balas. O ShellNoob tenta enriquecer a desmontagem adicionando os bytes (notação .byte) e, quando apropriado, exibirá o equivalente em ASCII (notação .ascii). Isso é útil quando você quer modificar/montar a saída do objdump, mas precisa de uma correção rápida.

Exemplo com a notação .byte:

jmp 0x37              # .byte 0xeb,0x35      
pop %ebx              # .byte 0x5b          
mov %ebx,%eax         # .byte 0x89,0xd8      
add $0xb,%eax         # .byte 0x83,0xc0,0x0b 
xor %ecx,%ecx         # .byte 0x31,0xc9      

Exemplo com a notação .ascii:

das                   # .ascii "/"
je 0xac               # .ascii "tm"
jo 0x70               # .ascii "p/"
jae 0xa8              # .ascii "se"
arpl %si,0x65(%edx)   # .ascii "cre"
je 0xa0               # .ascii "tX

Licença

ShellNoob é distribuído sob a licença MIT. Consulte o arquivo COPYRIGHT.