ShellNoob

Écrire des shellcodes a toujours été super amusant, mais certaines parties sont extrêmement ennuyeuses et sujettes à erreurs. Concentrez-vous uniquement sur la partie amusante et utilisez ShellNoob !

Pour un aperçu rapide, consultez les diapositives de la présentation Black Hat Arsenal : lien

Vous voulez contribuer ? Demande de fonctionnalité ? Rapport de bug ? Insultes ? Tous les retours sont les bienvenus !! (Mais certains types de retours sont plus les bienvenus que d'autres :-)).

N'hésitez pas à me mentionner sur Twitter @reyammer ou à m'envoyer un email à yanick[AT]cs.ucsb.edu pour toute question !

Contributeurs et Remerciements

• Levente Polyak (@anthraxx42)
  • ajouté le support de Python 3
  • corrections de bugs
• @ToolsWatch et les équipes de Black Hat
  • Ils m'ont donné l'occasion de montrer mon outil :D

Actualités

• 21/01/2014 - ShellNoob 2.1 est sorti ! Il est livré avec le support complet de Python 3 et des tonnes de corrections de bugs. Tout le crédit revient à Levente Polyak !

• 29/07/2013 - ShellNoob 2.0 est sorti !

• 08/06/2013 - ShellNoob a été accepté à Black Hat Arsenal ! Voir l'annonce ici : lien.

Fonctionnalités

• convertir du shellcode entre différents formats et sources. Formats actuellement supportés : asm, bin, hex, obj, exe, C, python, ruby, pretty, safeasm, completec, shellstorm. (Tous les détails dans la section « Description des formats ».)
• mode interactif de conversion asm en opcode (et vice versa). Utile lorsque vous ne pouvez pas utiliser certains octets dans le shellcode et que vous voulez déterminer si une instruction assembleur spécifique posera problème.
• support des syntaxes ATT et Intel. Consultez l'option --intel.
• support 32 et 64 bits (lorsque vous travaillez sur une machine x86_64). Consultez l'option --64.
• résolution des numéros d'appels système, des constantes et des codes d'erreur (maintenant réellement implémenté ! :-)).
• portable et facile à déployer (dépend uniquement de gcc/as/objdump et python). C'est juste un seul script python autonome, et il supporte à la fois Python2.7+ et Python3+.
• développement sur place : vous exécutez ShellNoob directement sur l'architecture cible !
• support intégré pour Linux/x86, Linux/x86_64, Linux/ARM, FreeBSD/x86, FreeBSD/x86_64.
• option « prepend breakpoint ». Consultez l'option -c.
• support de la lecture depuis stdin / écriture vers stdout (utilisez « - » comme nom de fichier)
• débogage super économique : consultez les options --to-strace et --to-gdb !
• Utilisez ShellNoob comme module Python dans vos scripts ! Consultez la section « ShellNoob en tant que bibliothèque ».
• Le mode verbeux affiche les étapes bas niveau de la conversion : utile pour déboguer / comprendre / apprendre !
• Plugins supplémentaires : le patching binaire rendu facile avec les options --file-patch, --vm-patch, ! (tous les détails ci-dessous)

Cas d'utilisation

Aide intégrée

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

Installation (seulement si vous le souhaitez)

$ ./shellnoob.py --install

Cela va simplement copier le script dans /usr/local/bin/snoob. C'est tout. (Exécutez ./shellnoob.py --uninstall pour annuler).

Convertir du shellcode d'un format à un autre avec une CLI ultra flexible.

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

Quelques alternatives équivalentes (l'outil essaiera de deviner ce que vous voulez en fonction de l'extension du fichier..)

$ 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

Description des formats

• "asm" - assembleur standard. Syntaxe ATT par défaut, utilisez --intel pour utiliser la syntaxe Intel. (voir la section « asm en sortie » pour plus de détails)
• "bin" - binaire brut ('\x41\x42\x43\x44')
• "hex" - binaire brut encodé en hexadécimal ('41424344')
• "obj" - un ELF
• "exe" - un ELF exécutable
• "c" - quelque chose de prêt à être intégré dans un programme C.
• "python", "bash", "ruby" - pareil ici.
• "completec" - C compilable qui définit correctement la mémoire en RWX (pour supporter les shellcodes auto-modifiants)
• "safeasm" - assembleur 100 % assemblable : parfois la sortie de objdump, dont est extrait l'« asm », n'est pas assemblable. Cela affiche les octets bruts (en notation .byte) afin qu'ils soient assemblables par « as ».
• "shellstorm" - L'option --from-shellstorm prend en argument un <shellcode_id>. ShellNoob récupérera le shellcode sélectionné depuis la base de shellcodes de shell-storm et le convertira au format choisi.

Débogage facile

$ 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 vous pouvez utiliser les nouvelles options --to-strace et --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)

Remarquez comment ShellNoob définit automatiquement un point d'arrêt sur le point d'entrée !

Obtenir les numéros d'appels système, constantes et 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

Mode interactif

$ ./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 en tant que bibliothèque

$ 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 en tant que format de sortie

Lorsque le format de sortie est « asm », ShellNoob fait de son mieux. Objdump est utilisé comme désassembleur, mais sa sortie n'est pas infaillible. ShellNoob essaie d'enrichir le désassemblage en ajoutant les octets (notation .byte), et, le cas échéant, affiche l'équivalent en ASCII (notation .ascii). Cela est utile lorsque vous voulez modifier/assembler la sortie de objdump mais que vous avez besoin d'une correction rapide.

Exemple avec la notation .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      

Exemple avec la notation .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

Licence

ShellNoob est distribué sous la licence MIT. Consultez le fichier COPYRIGHT.