Affiche des informations sur les fichiers dans différents formats de fichiers et trouve des gadgets pour construire des chaînes ROP pour différentes architectures (x86/x86_64, ARM/ARM64, MIPS, PowerPC, SPARC64). Pour le désassemblage, ropper utilise l'excellent framework Capstone.
Vous pouvez utiliser ropper pour afficher des informations sur des fichiers binaires dans différents formats de fichiers et vous pouvez rechercher des gadgets pour construire des chaînes rop pour différentes architectures (x86/X86_64, ARM/ARM64, MIPS/MIPS64, PowerPC/PowerPC64, SPARC64). Pour le désassemblage, ropper utilise l'impressionnant Capstone Framework.
Installer Capstone avec PyPi :
$ sudo pip install capstone
Installer filebytes avec PyPi :
$ sudo pip install filebytes
Optionnel (pas nécessaire pour exécuter ropper, seulement pour rechercher des gadgets) :
Installer Keystone :
$ sudo pip install keystone-engine
Installer et exécuter Ropper
$ python setup.py install
$ ropper
Vous pouvez aussi installer Ropper avec pip
$ pip install ropper
Si vous le souhaitez, vous pouvez utiliser Ropper sans installation
$ ./Ropper.py
Si vous ne voulez pas installer filebytes, filebytes est un sous-module du dépôt ropper. Cela signifie que vous n'avez pas besoin d'installer filebytes et ropper.
$ git clone https://github.com/sashs/ropper.git
$ cd ropper
$ git submodule init
$ git submodule update
$ ./Ropper.py
CETTE FONCTIONNALITÉ EST ENCORE EN DÉVELOPPEMENT ! Ropper dispose d'une commande de recherche sémantique, qui offre la possibilité de rechercher des gadgets.
$ ropper --file <afile> --semantic "<any constraint>"
Les dépendances optionnelles suivantes sont nécessaires pour utiliser la recherche sémantique :
Installer pyvex
$ sudo pip install pyvex
Installer z3py
$ python scripts/mk_make.py
$ cd build
$ make
$ sudo make install
reg == reg - affecter un registre à un autre
reg == number - affecter un nombre à un registre
reg == [reg] - affecter la mémoire à un registre
reg += number/reg/[reg]
reg -= number/reg/[reg]
reg *= number/reg/[reg]
reg /= number/reg/[reg]
eax==1 !ebx - définir eax à 1 et rechercher des gadgets qui ne modifient pas ebx
usage: Ropper.py [-h] [--help-examples] [-v] [--console]
[-f <file> [<file> ...]] [-r] [-a <arch>]
[--section <section>] [--string [<string>]] [--hex]
[--asm [<asm> [H|S|R] ...]] [--disasm <opcode>]
[--disassemble-address <address:length>] [-i] [-e]
[--imagebase] [-c] [-s] [-S] [--imports] [--symbols]
[--set <option>] [--unset <option>] [-I <imagebase>] [-p]
[-j <reg>] [--stack-pivot] [--inst-count <n bytes>]
[--search <regex>] [--quality <quality>] [--opcode <opcode>]
[--instructions <instructions>] [--type <type>] [--detailed]
[--all] [--cfg-only] [--chain <generator>] [-b <badbytes>]
[--nocolor] [--clear-cache] [--no-load] [--analyse <quality>]
[--semantic constraint]
[--count-of-findings <count of gadgets>] [--single]
Vous pouvez utiliser ropper pour afficher des informations sur des fichiers binaires dans différents formats de fichiers
et vous pouvez rechercher des gadgets pour construire des chaînes rop pour différentes architectures
types de fichiers supportés :
ELF
PE
Mach-O
Raw
architectures supportées :
x86 [x86]
x86_64 [x86_64]
MIPS [MIPS, MIPS64]
ARM/Thumb [ARM, ARMTHUMB]
ARM64 [ARM64]
PowerPC [PPC, PPC64]
SPARC [SPARC64]
générateurs de chaînes rop disponibles :
execve (execve[=<cmd>], par défaut /bin/sh) [Linux x86, x86_64]
mprotect (mprotect=<address>:<size>) [Linux x86, x86_64]
virtualprotect (virtualprotect=<address iat vp>:<size>) [Windows x86]
options :
-h, --help afficher ce message d'aide et quitter
--help-examples Afficher des exemples
-v, --version Afficher la version
--console Démarrer la ligne de commande interactive
-f <file> [<file> ...], --file <file> [<file> ...]
Le fichier à charger
-r, --raw Charger le fichier comme fichier brut
-a <arch>, --arch <arch>
L'architecture du fichier chargé
--section <section> Les données de cette section doivent être affichées
--string [<string>] Cherche la chaîne <string> dans toutes les sections de données
--hex Affiche les sections sélectionnées au format hexadécimal
--asm [<asm> [H|S|R] ...]
Une chaîne à assembler et un format de sortie
(H=HEX, S=STRING, R=RAW, par défaut : H)
--disasm <opcode> Opcode à désassembler (par ex. ffe4, 89c8c3, ...)
--disassemble-address <address:length>
Désassemble l'instruction à l'adresse <address>
(0x12345678:L3). Le nombre d'instructions à
désassembler peut être spécifié (0x....:L...)
-i, --info Affiche l'en-tête du fichier [ELF/PE/Mach-O]
-e Affiche le point d'entrée
--imagebase Affiche l'ImageBase [ELF/PE/Mach-O]
-c, --dllcharacteristics
Affiche les caractéristiques DLL [PE]
-s, --sections Affiche les sections du fichier [ELF/PE/Mach-O]
-S, --segments Affiche les segments du fichier [ELF/Mach-O]
--imports Affiche les imports [ELF/PE]
--symbols Affiche les symboles [ELF]
--set <option> Définit les options. Options disponibles : aslr nx
--unset <option> Annule les options. Options disponibles : aslr nx
-I <imagebase> Utiliser cette imagebase pour les gadgets
-p, --ppr Recherche les instructions 'pop reg; pop reg; ret'
[uniquement x86/x86_64]
-j <reg>, --jmp <reg>
Recherche les instructions 'jmp reg' (-j reg[,reg...])
[uniquement x86/x86_64]
--stack-pivot Affiche tous les gadgets de stack pivot
--inst-count <n bytes>
Spécifie le nombre maximum d'instructions dans un gadget
(par défaut : 6)
--search <regex> Recherche des gadgets
--quality <quality> La qualité des gadgets trouvés par la recherche (1 =
meilleur)
--opcode <opcode> Recherche des opcodes (par ex. ffe4 ou ffe? ou ff??)
--instructions <instructions>
Recherche des instructions (par ex. "jmp esp", "pop eax;
ret")
--type <type> Définit le type de gadgets [rop, jop, sys, all]
(par défaut : all)
--detailed Affiche les gadgets de manière plus détaillée
--all Ne supprime pas les gadgets en double
--cfg-only Filtre les gadgets qui échouent au test CFG de Microsoft.
Uniquement pour les fichiers PE compilés avec le test CFG
activé (vérifier DllCharachteristics) [PE]
--chain <generator> Génère une ropchain [générateur paramètre=valeur[
paramètre=valeur]]
-b <badbytes>, --badbytes <badbytes>
Définit les octets qui ne doivent pas être contenus dans les gadgets
--nocolor Désactive la sortie colorée
--clear-cache Vide le cache
--no-load Ne charge pas les gadgets automatiquement au démarrage de la console
(--console)
--analyse <quality> utilisé uniquement pour l'implémentation de la recherche sémantique
--semantic constraint
recherche sémantique de gadgets
--count-of-findings <count of gadgets>
Nombre maximum de gadgets qui seront affichés avec la
recherche sémantique (0 = indéfini, par défaut : 5)
--single Aucun processus multiple n'est utilisé pour l'analyse des gadgets
exemples d'utilisation :
[Generic]
./Ropper.py
./Ropper.py --file /bin/ls --console
[Informations]
./Ropper.py --file /bin/ls --info
./Ropper.py --file /bin/ls --imports
./Ropper.py --file /bin/ls --sections
./Ropper.py --file /bin/ls --segments
./Ropper.py --file /bin/ls --set nx
./Ropper.py --file /bin/ls --unset nx
./Ropper.py --file /bin/ls --inst-count 5
./Ropper.py --file /bin/ls --search "sub eax" --badbytes 000a0d
./Ropper.py --file /bin/ls --search "sub eax" --detail
./Ropper.py --file /bin/ls --filter "sub eax"
./Ropper.py --file /bin/ls --inst-count 5 --filter "sub eax"
./Ropper.py --file /bin/ls --opcode ffe4
./Ropper.py --file /bin/ls --opcode ffe?
./Ropper.py --file /bin/ls --opcode ??e4
./Ropper.py --file /bin/ls --detailed
./Ropper.py --file /bin/ls --ppr --nocolor
./Ropper.py --file /bin/ls --jmp esp,eax
./Ropper.py --file /bin/ls --type jop
./Ropper.py --file /bin/ls --chain execve
./Ropper.py --file /bin/ls --chain "execve cmd=/bin/sh" --badbytes 000a0d
./Ropper.py --file /bin/ls --chain "mprotect address=0xbfdff000 size=0x21000"
./Ropper.py --file /bin/ls /lib/libc.so.6 --console
[Assembler/Désassembler]
./Ropper.py --asm "jmp esp"
./Ropper.py --asm "mov eax, ecx; ret"
./Ropper.py --disasm ffe4
[Recherche]
./Ropper.py --file /bin/ls --search <searchstring>
? n'importe quel caractère
% n'importe quelle chaîne
Exemple :
./Ropper.py --file /bin/ls --search "mov e?x"
0x000067f1: mov edx, dword ptr [ebp + 0x14]; mov dword ptr [esp], edx; call eax
0x00006d03: mov eax, esi; pop ebx; pop esi; pop edi; pop ebp; ret ;
0x00006d6f: mov ebx, esi; mov esi, dword ptr [esp + 0x18]; add esp, 0x1c; ret ;
0x000076f8: mov eax, dword ptr [eax]; mov byte ptr [eax + edx], 0; add esp, 0x18; pop ebx; ret ;
./Ropper.py --file /bin/ls --search "mov [%], edx"
0x000067ed: mov dword ptr [esp + 4], edx; mov edx, dword ptr [ebp + 0x14]; mov dword ptr [esp], edx; call eax;
0x00006f4e: mov dword ptr [ecx + 0x14], edx; add esp, 0x2c; pop ebx; pop esi; pop edi; pop ebp; ret ;
0x000084b8: mov dword ptr [eax], edx; ret ;
0x00008d9b: mov dword ptr [eax], edx; add esp, 0x18; pop ebx; ret ;
./Ropper.py --file /bin/ls --search "mov [%], edx" --quality 1
0x000084b8: mov dword ptr [eax], edx; ret ;; ret ;
#!/usr/bin/env python
from ropper import RopperService
# not all options need to be given
options = {'color' : False, # if gadgets are printed, use colored output: default: False
'badbytes': '00', # bad bytes which should not be in addresses or ropchains; default: ''
'all' : False, # Show all gadgets, this means to not remove double gadgets; default: False
'inst_count' : 6, # Number of instructions in a gadget; default: 6
'type' : 'all', # rop, jop, sys, all; default: all
'detailed' : False} # if gadgets are printed, use detailed output; default: False
rs = RopperService(options)
##### change options ######
rs.options.color = True
rs.options.badbytes = '00'
rs.options.badbytes = ''
rs.options.all = True
##### open binaries ######
# it is possible to open multiple files
rs.addFile('test-binaries/ls-x86')
rs.addFile('ls', bytes=open('test-binaries/ls-x86','rb').read()) # other possiblity
rs.addFile('ls_raw', bytes=open('test-binaries/ls-x86','rb').read(), raw=True, arch='x86')
##### close binaries ######
rs.removeFile('ls')
rs.removeFile('ls_raw')
# Set architecture of a binary, so it is possible to look for gadgets for a different architecture
# It is useful for ARM if you want to look for ARM gadgets or Thumb gadgets
# Or if you opened a raw file
ls = 'test-binaries/ls-x86'
rs.setArchitectureFor(name=ls, arch='x86')
rs.setArchitectureFor(name=ls, arch='x86_64')
rs.setArchitectureFor(name=ls, arch='ARM')
rs.setArchitectureFor(name=ls, arch='ARMTHUMB')
rs.setArchitectureFor(name=ls, arch='ARM64')
rs.setArchitectureFor(name=ls, arch='MIPS')
rs.setArchitectureFor(name=ls, arch='MIPS64')
rs.setArchitectureFor(name=ls, arch='PPC')
rs.setArchitectureFor(name=ls, arch='PPC64')
rs.setArchitectureFor(name=ls, arch='SPARC64')
rs.setArchitectureFor(name=ls, arch='x86')
##### load gadgets ######
# load gadgets for all opened files
rs.loadGadgetsFor()
# load gadgets for only one opened file
ls = 'test-binaries/ls-x86'
rs.loadGadgetsFor(name=ls)
# change gadget type
rs.options.type = 'jop'
rs.loadGadgetsFor()
rs.options.type = 'rop'
rs.loadGadgetsFor()
# change instruction count
rs.options.inst_count = 10
rs.loadGadgetsFor()
##### print gadgets #######
rs.printGadgetsFor() # print all gadgets
rs.printGadgetsFor(name=ls)
##### Get gadgets ######
gadgets = rs.getFileFor(name=ls).gadgets
##### search pop pop ret ######
pprs = rs.searchPopPopRet(name=ls) # looks for ppr only in 'test-binaries/ls-x86'
pprs = rs.searchPopPopRet() # looks for ppr in all opened files
for file, ppr in pprs.items():
for p in ppr:
print p
##### load jmp reg ######
jmp_regs = rs.searchJmpReg(name=ls, regs=['esp', 'eax']) # looks for jmp reg only in 'test-binaries/ls-x86'
jmp_regs = rs.searchJmpReg(regs=['esp', 'eax'])
jmp_regs = rs.searchJmpReg() # looks for jmp esp in all opened files
for file, jmp_reg in jmp_regs.items():
for j in jmp_reg:
print j
##### search opcode ######
ls = 'test-binaries/ls-x86'
gadgets_dict = rs.searchOpcode(opcode='ffe4', name=ls)
gadgets_dict = rs.searchOpcode(opcode='ffe?')
gadgets_dict = rs.searchOpcode(opcode='??e4')
for file, gadgets in gadgets_dict.items():
for g in gadgets:
print g
##### search instructions ######
ls = 'test-binaries/ls-x86'
for file, gadget in rs.search(search='mov e?x', name=ls):
print file, gadget
for file, gadget in rs.search(search='mov [e?x%]'):
print file, gadget
result_dict = rs.searchdict(search='mov eax')
for file, gadgets in result_dict.items():
print file
for gadget in gadgets:
print gadget
##### assemble instructions ######
hex_string = rs.asm('jmp esp')
print '"jmp esp" assembled to hex string =', hex_string
raw_bytes = rs.asm('jmp esp', format='raw')
print '"jmp esp" assembled to raw bytes =', raw_bytes
string = rs.asm('jmp esp', format='string')
print '"jmp esp" assembled to string =',string
arm_bytes = rs.asm('bx sp', arch='ARM')
print '"bx sp" assembled to hex string =', arm_bytes
##### disassemble bytes #######
arm_instructions = rs.disasm(arm_bytes, arch='ARM')
print arm_bytes, 'disassembled to "%s"' % arm_instructions
# Change the imagebase, this also change the imagebase for all loaded gadgets of this binary
rs.setImageBaseFor(name=ls, imagebase=0x0)
# reset image base
rs.setImageBaseFor(name=ls, imagebase=None)
gadgets = rs.getFileFor(name=ls).gadgets
# gadget address
print hex(gadgets[0].address)
# get instruction bytes of gadget
print bytes(gadgets[0].bytes).encode('hex')
# remove all gadgets containing bad bytes in address
rs.options.badbytes = '000a0d' # gadgets are filtered automatically
