Discussion :

[TWEESTY]

Bonjour à tous,


J'ai soucis avec un code assembleur sur une machine avec une architecture i386 et FreeBSD.

Je voudrais faire un syscall, ainsi je dois mettre le registre eax à une certaine valeur, par exemple 0x88 (pour mkdir). Cependant, j'ai un segmentation fault à chaque fois que je veux changer la valeur de eax.

Exemple :
mov %eax, 0x88000000 -> Segmentation fault

Par contre, si j'effectue cette opération, cela marche :
xor %eax,%eax


Je ne comprends donc pas comment mettre une valeur dans ce registre.

Merci d'avance pour votre aide!

[Obsidian]

Bonjour,

La notation AT&T (utilisée par défaut sous UNIX) utilise le format « MOV source,destination » et pas « MOV destination,source » comme c'est le cas sous l'assembleur natif Intel et sur la plupart des autres.

Encore un qui s'est trouvé brillant en remettant les arguments, selon lui, dans l'ordre normal sans réfléchir ni se demander pourquoi ils étaient dans l'autre ordre jusqu'ici. Quand on écrit « x=1 », la destination est à gauche et la source à droite…

Du coup, on est sans arrêt en train de se demander dans quel sens on est en train de faire circuler sa donnée. Essaie :

mov 0x88000000,%eax… et dis-nous si ça fonctionne.

[n5Rzn1D9dC]

Yep, puis les pourcentages, je sais pas si c'est obligatoire en AT&T, si ça sert à gcc ou rien du tout, mais sinon beurk quoi..
Dire qu'il y a des gens qui codent depuis des années sous cette syntaxe et qui trouvent la syntaxe intel horrible : /

TWEESTY> Je ne sais pas si c'est pareil sous Freebsd, mais sous Linux par exemple, ce serait 0x88 = 0x00000088 et non 0x8800000000
A moins que ce soit l'inverse sous FreeBSD.

[Kannagi]

Les pourcentages sont bien obligatoire comme le signe '$', et il est vrai que ça rend pas la syntaxe des plus belles.

Il y a la page wikipedia ici pour plus de précisions.

[TWEESTY]

Bonjour à tous,

Sujet fort intéressant! Merci de votre aide.

J’essaierai tout ce que vous venez de me dire lundi, cependant j'ai des doutes.

Car j'ai décompilé un programme, et pour le mov, c'était bien mov destination,source : en effet cette instruction était utilisée :
mov 0x3b,%al

D'ailleurs, on peut remarquer qu'il n'y a pas de $ devant 0x3b, donc je suis vraiment perdu...

Par contre, ce que je suis sûr pour 0x88, il faut bien mettre 0x88000000.
Je pourrai essayer tout çà lundi

[Kannagi]

C'est dommage qu'on lis pas mes lien =/

Les opérandes immédiats (constantes) sont préfixés d'un dollar '$'

Donc si c'est une valeur que tu veux mettre ça sera avec le préfixe '$'.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mov 0x3b,%al

Moi je le lis plutôt comme copier ce qui se trouve dans adresse mémoire 0x3b dans le registre al.
Alors que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

mov $0x3b,%al

Je le lirai plus comme mettre la valeur 0x3B (59) dans le registre al.

[n5Rzn1D9dC]

Je comprend mieux maintenant d'où vient cette manie de mettre des $ dans un code Fasm syntax intel que j'avais vu.
C'est simplement que le mec avait des restes de lorsqu'il codait en AT&T ^
C'était dans l'exemple "detour" il me semble.

Sinon pour les pourcentages, à part être obligatoire ça ne sert à rien du tout d'après ce que j'ai cru comprendre.

TWEESTY> Pour l'histoire du 0x88, c'est vraiment étrange ce que tu me dis..
Il me semble que ça pourrait être le cas si tu serais en gros boutisme, mais FreeBSD en x86 ne l'est pas.. En tout cas d'après ce qui est dit ici:
http://fr.wikipedia.org/wiki/Endianness

C'est très simple de le savoir..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
 
mov eax,0x1
 
push eax
push form
call [printf]
 
form db '%08x',13,10,0

[TWEESTY]

Merci à tous pour vos aides, en effet maintenant çà fonctionne

Enfin, il me reste un dernier problème, en effet mon objectif est de lancer le shell grâce à un buffer overflow et donc je voudrais exécuter la commande execve grâce à syscall.

Cependant, je n'arrive pas à faire fonctionner mon syscall si j'ai des pointeurs de chaines de caractères comme paramètres. J'ai essayé d'exécuter exit avec syscall et tout fonctionne mais par exemple j'essaye de printer "aaaa", et celà ne fonctionne pas, j'ai un segementation fault.

Voici le code assembleur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 mov $4, %eax
       mov $1, %ebx
       mov $0x80000000, %ecx
       mov $4, %edx
       int 0x80

Biensûr, j'ai mis à l'adresse
0x$0x80000000 -> \x61
0x$0x80000001 -> \x61
0x$0x80000002 -> \x61
0x$0x80000003 -> \x61


Mais j'ai donc un segmentation fault mais après la dernière ligne du programme, j'ai l'impression qu'il essaie de lire la chaîne de caractères mais qu'il n'arrive pas à savoir quand est-ce qu'elle se termine. Cependant, sur le web, je n'ai trouvé de renseignements sur comment terminer une chaîne de caractères.

Si vous le savez, je serai très reconnaissant.


PS: Je précise que c'est pour un projet pour un cours de Software Security en Suède :=)

[Kannagi]

Mais j'ai donc un segmentation fault mais après la dernière ligne du programme, j'ai l'impression qu'il essaie de lire la chaîne de caractères mais qu'il n'arrive pas à savoir quand est-ce qu'elle se termine. Cependant, sur le web, je n'ai trouvé de renseignements sur comment terminer une chaîne de caractères.

Euh tu n'as jamais fait du C ?
Parce que la fin de caractère doit se terminé par '\0' soit 0x00 ou 0 ,chose qu'on sait si on a fait du C.

[TWEESTY]

Si si, j'en ai fait D'ailleurs, c'est pour cela que je parlais de caractère de terminaison. C'est donc bizarre car j'ai essayé d'ajouter un \x00, par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
0x$0x80000000 -> \x61
0x$0x80000001 -> \x61
0x$0x80000002 -> \x61
0x$0x80000003 -> \x00

Je viens peut-être d'avoir une idée, vu que l'architecture est du little-endian, peut-être que je dois inverser et mettre plutôt :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
0x$0x80000000 -> \x00
0x$0x80000001 -> \x61
0x$0x80000002 -> \x61
0x$0x80000003 -> \x61

Mais dans ce cas là, mon code assembleur doit-il changé et devenir :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 mov $4, %eax
       mov $1, %ebx
       mov $0x80000003, %ecx
       mov $4, %edx
       int 0x80

Mmmmm,je suis perplexe mais c'est tellement intéressant. Je pense que le problème venait de là.

[n5Rzn1D9dC]

Bah c'est quasiment la même chose que le printf que je t'avais mis ci-dessus..
Tu as l'air de te compliquer la vie pour rien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
push string
push form
call [printf]
 
string db 'aaaa',0
form db '%s',13,10,0

Ou shellcode reversed-addr oriented:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
	jmp	a1
     b1:
	jmp	a2
 
     b2:
	call	[printf]
 
	ret
 
     a1:
	call	b1
	db 'aaaa',0
     a2:
	call	b2
	db '%s',13,10,0

[TWEESTY]

Bah c'est quasiment la même chose que le printf que je t'avais mis ci-dessus..
Tu as l'air de te compliquer la vie pour rien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
push string
push form
call [printf]
 
string db 'aaaa',0
form db '%s',13,10,0

Ou shellcode reversed-addr oriented:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
	jmp	a1
     b1:
	jmp	a2
 
     b2:
	call	[printf]
 
	ret
 
     a1:
	call	b1
	db 'aaaa',0
     a2:
	call	b2
	db '%s',13,10,0

J'ai regardé ton code, cependant je peux juste écrire directement dans la mémoire grâce à un buffer overflow donc je ne peux pas écrire des choses comme :

string db 'aaaa',0

C'est donc pour celà que j'ai des difficultés, car j'ai déjà fait de l'assembleur mais pas en écrivant directement dans la mémoire.

[n5Rzn1D9dC]

J'ai regardé ton code, cependant je peux juste écrire directement dans la mémoire grâce à un buffer overflow donc je ne peux pas écrire des choses comme :

string db 'aaaa',0

C'est donc pour celà que j'ai des difficultés, car j'ai déjà fait de l'assembleur mais pas en écrivant directement dans la mémoire.

Meuh ?
A mon avis tu manques de pratique pour te lancer dans la conception de shellcode. Attend encore un peu.
Le premier code de mon post, c'est un code banal, ce n'est pas un exemple fait pour un inclus dans un shellcode, le deuxième par contre EST un shellcode (hors-loading des library, mais je ne vais pas te donner la méthode complète sinon ça sert à rien).

Il y a aussi le push-oriented shellcoding, mais je n'aime pas cette méthode:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
	push	0
	push	'aaaa'
	mov	eax,esp
 
	push	10
	push	'%s'
	mov	ecx,esp
 
	push	eax
	push	ecx
 
	call	[printf]

[Kannagi]

Qu'est qui te fait penser que c'est un probleme de fin de caractère ?
Sinon je me souviens que en faisant des .com sur windows la fin de caractère était avec le caractère '$'.

[n5Rzn1D9dC]

Moi perso il y a toujours son histoire de 0x1 = 0x10000000 que je trouve extrêmement étrange.

Normalement, freebsd x86 = linux x68 = windows x86 = little endian = byte arrivant à droite.

[n5Rzn1D9dC]

Le principe d'un shellcode est qu'il puisse s'executer dans une page mémoire autre que celle d'origine, et donc ne pas dépendre des VA ou RVA de ton programme.
Ca tu l'as compris.

Donc concernant l'exemple du shellcode orienté adresses-inversées:
Inverser les adresses sert à ce que leur calcul commence à 0xFFFFFFFF
De cette façon, elle seront identique dans la page mémoire de destination.. Ce qui rend le code indépendant de la page dans laquelle il a été créé.
Ah j'oubliais.. un call push automatiquement l'adresse de retour, ce qui push automatiquement ta chaine, et donc c'est encore une fois indépendant de la page mémoire.

Comme je te disais, c'est un shellcode, près à l'emploi. Tu récupères les bytes, tu les mets où ça t'arrange, puis fait un call, et tu verras que ça fonctionne.

Pour la méthode push, bah tu push simplement sur la pile, donc il n'y a aucune adresse (en dehors de la pile), ce qui rend également le code indépendant de la page.

[TWEESTY]

Merci bien, j'essaierai de nouveau demain.

Mais la première solution, de pusher la chaîne, je l'avais faite mais hélas ca n'avait pas marché.

[n5Rzn1D9dC]

Ca doit fonctionner. Quand ça ne fonctionne pas c'est souvent une erreur d'ordre des arguments.

Et pour la méthode push-oriented, c'est également des adresses que tu dois pusher, il ne faut pas oublier ça, si tu push des valeurs immédiates, ça ne peux pas fonctionner, le printf attend des adresses.

edit: D'ailleurs j'ai fait une erreur dans la méthode push, tu vois ça va vite. Je n'ai pas pusher les adresses en dernier, je corrige.
J'ai testé, maintenant il fonctionne.
C'est aussi pour ça que je n'aime pas cette méthode, ça va vite de faire une erreur.

[TWEESTY]

Ce que ne comprends, c'est que je dois mettre l'adresse de ma chaîne de caractères dans le registre ecx, or je sais que ma chaîne commence à l'adresse 0x80000000, donc pour mettre cette adresse dans le registre ecx, je dois utiliser une valeur immédiate :=)

[n5Rzn1D9dC]

Ce que ne comprends, c'est que je dois mettre l'adresse de ma chaîne de caractères dans le registre ecx, or je sais que ma chaîne commence à l'adresse 0x80000000, donc pour mettre cette adresse dans le registre ecx, je dois utiliser une valeur immédiate :=)

Mais non, regarde l'exemple que je t'ai donné.
Les valeurs de la 1ère chaîne 'aaaa',0 sont pushés sur la pile, ensuite c'est esp qui est mise dans eax.
L'adresse de la chaîne est dans contenue dans esp.

Idem pour la 2ème chaîne. L'adresse de '%s',10 se trouve dans esp, que tu copies dans ecx.

Au final tu push tes 2 adresses de chaînes qui sont dans eax et ecx et tu appels printf.

printf lui trouvera donc l'adresse de '%s',10 à esp, et l'adresse de 'aaaa',0 à esp+4


Voilà ce que ça donne au debugger (ça peut t'aider d'ailleurs d'en utiliser un...)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
0006FFAC   0006FFB4  ´ÿ.  ASCII "%s"     < adresse du formatage
0006FFB0   0006FFBC  ¼ÿ.  ASCII "aaaa"   < adresse de 'aaaa'
0006FFB4   00007325  %s..
0006FFB8   0000000A  ....
0006FFBC   61616161  aaaa
0006FFC0   00000000  ....