Title:	  How to create a shellcode on Linux x86 ?
	Author:   Jonathan Salwan <submit ! shell-storm.org>
	Web:	  http://www.shell-storm.org/ | http://twitter.com/shell_storm
	Date:	  2010-05-30
	Language: French 

	Original version: http://howto.shell-storm.org/files/howto-1.php




	I - Présentation des shellcodes
	===============================

	Un shellcode est une chaîne de caractères qui représente un code binaire exécutable capable de lancer
	n'importe quelle application sur la machine. La plupart  du temps un  shellcode ouvre un  shell pour
	avoir un accès complet sur la machine. Généralement, les shellcodes sont  injectés dans la mémoire de 
	la machine via l'exploitation d'une faille type dépassement de tampon (buffer overflow).


	II - Comprendre les bases
	=========================

	1 - Les appels systèmes
	
	Un appel système (en anglais, system call, abrégé en syscall)  est une fonction  fournie par le noyau 
	d'un système d'exploitation. Suivant les Os nos syscall seront appelés différemment.
	
	Exemple d'appel système fréquemment utilisé: 
	open, write, read, close, chmod, chown ...

	Sur la  majorité  des  systèmes  d'exploitations,  les  appels système peuvent être utilisés comme de 
	simples fonctions écrites en C. Par exemple pour l'appel système chown:

	extern int chown (__const char *__file, __uid_t __owner, __gid_t __group)

	Chaque appel  système  à une adresse, qui est attribuée par le système d'exploitation et qui lui  est
	propre.  Par  exemple  sous   linux  avec  le kernel 2.6.31 l'adresse  du  syscall  chown  est  0xb6.  
	Comment  connaître  cette  adresse ?  Une  simple  commande comme ci-dessous permet d'avoir l'adresse 
	du syscall. Les adresses dans unistd_x.h sont en decimales. 


	Pour un système 32 bits

	jonathan@archlinux [ shellcode ]# cat /usr/include/asm/unistd_32.h | grep chown
	#define __NR_lchown		 16
	#define __NR_fchown		 95
	#define __NR_chown		182
	#define __NR_lchown32		198
	#define __NR_fchown32		207
	#define __NR_chown32		212
	#define __NR_fchownat		298

	 
	Pour un système 64 bits

	jonathan@archlinux [ shellcode ]# cat /usr/include/asm/unistd_64.h | grep chown
	#define __NR_chown				92
	__SYSCALL(__NR_chown, sys_chown)
	#define __NR_fchown				93
	__SYSCALL(__NR_fchown, sys_fchown)
	#define __NR_lchown				94
	__SYSCALL(__NR_lchown, sys_lchown)
	#define __NR_fchownat				260
	__SYSCALL(__NR_fchownat, sys_fchownat)


	Comme vous pouvez le constater, si l'os est sous 32 ou 64 bits, l'adresse des syscalls change.



	III - Ecrire son premier shellcode
	==================================

	En premier lieu nous allons créer un shellcode simple, qui va nous  permettre d'effectuer une pause.
	Pour ça nous allons appeler la fonction _pause dont l'adresse est 29 ce qui donne 0x1d en hexadecimal
	(sous 32 bits).


	jonathan@archlinux [ ~ ]$ cat /usr/include/asm/unistd_32.h | grep pause
	#define __NR_pause		 29


	Une fois qu'on connait l'adresse du syscall, il nous reste plus qu'à connaître, ce qu'on doit mettre
	dans les registres.
	Pour cela référez vous à cette page => http://www.shell-storm.org/shellcode/files/syscalls.html

	Nous pouvons  constater  que pour _pause nous n'avons pas besoin de remplir les registres, juste un 
	appel suffit, ce qui va donc est très court à programmer.


	jonathan@archlinux [ shellcode ]$ cat pause.s
	xor %eax,%eax
	mov $29,%al	
	int $0x80	
	jonathan@archlinux [ shellcode ]$ as -o pause.o pause.s
	jonathan@archlinux [ shellcode ]$ ld -o pause pause.o
	ld: warning: cannot find entry symbol _start; defaulting to 08048054
	jonathan@archlinux [ shellcode ]$ ./pause 
	^C
	jonathan@archlinux [ shellcode ]$
 
	
	Expliquation
	============
	
	xor %eax,%eax	<= On met le registre eax à 0 pour éviter les segments faults
	mov $29,%al 	<= On place 29 (l'adresse du syscall) dans le registre al	
	int $0x80	<= On exécute


	Maintenant nous allons l'écrire C. Pour cela nous devons connaître l'équivalence des fonctions asm en 
	hexadecimales ce qui va par la suite être notre shellcode.

	Comment avoir les équivalences en hexadecimal ?
	C'est simple, nous utilisons tout simplement l'outil objdump, ce qui donne:


	jonathan@archlinux [ shellcode ]$ objdump -d ./pause

	pause:     file format elf32-i386


	Disassembly of section .text:

	08048054 <.text>:
	 8048054:	31 c0                	xor    %eax,%eax
	 8048056:	b0 1d                	mov    $0x1d,%al
	 8048058:	cd 80                	int    $0x80
	jonathan@archlinux [ shellcode ]$


	Et voilà, donc en C le code sera:


	jonathan@archlinux [ shellcode ]$ cat pause_c.c 
	#include<stdio.h>

	void main(void)
	{
	char shellcode[] = "\x31\xc0\xb0\x1d\xcd\x80";

	(*(void(*)()) shellcode)();

	}
	jonathan@archlinux [ shellcode ]$ gcc -o pause_c pause_c.c 
	jonathan@archlinux [ shellcode ]$ ./pause_c 
	^C
	jonathan@archlinux [ shellcode ]$

	Votre premier shellcode fonctionne correctement.

	Maintenant nous allons étudier la fonction _write. Référons nous encore au site que j'ai soumis
	plus haut.

	Info registre:
	==============
	%eax	   = 4 
	%ebx       = unsigned int 
	%ecx       = const char * 
	%edx       = size

	
	Nous allons tous simplement écrire jonathan, regardons ce que donne les sources:

	jonathan@ArchLinux [shellcode]$ cat write.s
	;_write	
	xor   %eax,%eax   <= Pour éviter les segmentfaults
	xor   %ebx,%ebx   <= 	//		//
	xor   %ecx,%ecx   <= 	//		//
	xor   %edx,%edx   <= 	//		//

	movb  $0x9,%dl    <= on place la taille de notre mot dans dl(edx) donc jonathan + \n |  8+1=9   
	pushl $0x0a       <= on commence à empiler notre line feed (\n) = 0x0a
	push  $0x6e616874 <= naht
	push  $0x616e6f6a <= onaj
	movl  %esp,%ecx   <= on envoie %esp dans %ecx le registre qui contient la constante char de _write
	movb  $0x1,%bl    <= ici 1 pour %ebx,
	movb  $0x4,%al    <= et ici le syscall de _write donc 4
	int   $0x80       <= on exécute

	;_exit
	xor   %ebx,%ebx    <= %ebx = 0
	movb  $0x1,%al     <= %eax = 1 (syscall de _exit)
	int   $0x80        <= on exécute

	
	Compilons et exécutons notre programme:
	
	jonathan@ArchLinux [shellcode]$ as -o write.o write.s
	jonathan@ArchLinux [shellcode]$ ld -o write write.o 
	ld: warning: cannot find entry symbol _start; defaulting to 08048054
	jonathan@ArchLinux [shellcode]$ ./write 
	jonathan
	jonathan@ArchLinux [shellcode]$

	Ecrivons notre shellcode en C pour cela, un petit objdump sera utile.

	jonathan@ArchLinux [shellcode]$ objdump -d write

	write:     file format elf32-i386


	Disassembly of section .text:

	08048054 <.text>:
	 8048054:	31 c0                	xor    %eax,%eax
	 8048056:	31 db                	xor    %ebx,%ebx
	 8048058:	31 c9                	xor    %ecx,%ecx
	 804805a:	31 d2                	xor    %edx,%edx
	 804805c:	b2 09                	mov    $0x9,%dl
	 804805e:	6a 0a                	push   $0xa
	 8048060:	68 74 68 61 6e       	push   $0x6e616874
	 8048065:	68 6a 6f 6e 61       	push   $0x616e6f6a
	 804806a:	89 e1                	mov    %esp,%ecx
	 804806c:	b3 01                	mov    $0x1,%bl
	 804806e:	b0 04                	mov    $0x4,%al
	 8048070:	cd 80                	int    $0x80
	 8048072:	31 db                	xor    %ebx,%ebx
	 8048074:	b0 01                	mov    $0x1,%al
	 8048076:	cd 80                	int    $0x80
	jonathan@ArchLinux [shellcode]$
	
	On retrouve bien à droite les sources de notre code en asm puis l'équivalence des instructions en 
	hexadecimal.

	jonathan@ArchLinux [shellcode]$ cat write_c.c 
	#include <stdio.h>

	void main(void)
	{
	char shellcode[] = 	"\x31\xc0\x31\xdb\x31\xc9"
				"\x31\xd2\xb2\x09\x6a\x0a"
				"\x68\x74\x68\x61\x6e\x68"
				"\x6a\x6f\x6e\x61\x89\xe1"
				"\xb3\x01\xb0\x04\xcd\x80"
				"\x31\xdb\xb0\x01\xcd\x80";

	fprintf(stdout,"Lenght: %d\n",strlen(shellcode));
	(*(void(*)()) shellcode)();
	}

	Compilons et exécutons notre shellcode.

	jonathan@ArchLinux [shellcode]$ gcc -o write_c write_c.c 
	jonathan@ArchLinux [shellcode]$ ./write_c 
	Lenght: 36
	jonathan
	jonathan@ArchLinux [shellcode]$

	Et voila cela fonctionne parfaitement. Shellcode _write(1,"jonathan\n",9) + _exit(0) pour une taille de 36 bytes.


	
	IV - Références
	===============
	
	[x] - http://www.shell-storm.org

	[1] - http://fr.wikipedia.org/wiki/Shellcode

	[2] - /usr/include/asm/unistd_32.h