probleme de pointeur

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour a tous un petit souci sur un pointeur fonction je poste le code

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 
 
int fonct()
{
char scode[]=
"\x31\xc9\x83\xe9\xdd\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xfb"
"\xe2\x8d\x15\x83\xeb\xfc\xe2\xf4\x07\x0a\xc9\x15\xfb\xe2\x06\x50"
"\xc7\x69\xf1\x10\x83\xe3\x62\x9e\xb4\xfa\x06\x4a\xdb\xe3\x66\x5c"
"\x70\xd6\x06\x14\x15\xd3\x4d\x8c\x57\x66\x4d\x61\xfc\x23\x47\x18"
"\xfa\x20\x66\xe1\xc0\xb6\xa9\x11\x8e\x07\x06\x4a\xdf\xe3\x66\x73"
"\x70\xee\xc6\x9e\xa4\xfe\x8c\xfe\x70\xfe\x06\x14\x10\x6b\xd1\x31"
"\xff\x21\xbc\xd5\x9f\x69\xcd\x25\x7e\x22\xf5\x19\x70\xa2\x81\x9e"
"\x8b\xfe\x20\x9e\x93\xea\x66\x1c\x70\x62\x3d\x15\xfb\xe2\x06\x7d"
"\xc7\xbd\xbc\xe3\x9b\xb4\x04\xed\x78\x22\xf6\x45\x93\x12\x07\x11"
"\xa4\x8a\x15\xeb\x71\xec\xda\xea\x1c\x81\xec\x79\x98\xcc\xe8\x6d"
"\x9e\xe2\x8d\x15";
}
 
int main(int argc, char *argv[])
{
 
  int(*p)();
  p=&fonct;
  (*p)();
 
 
 
 
  system("PAUSE");	
  return 0;
}

Normalement le pointeur devrai sauter sur l'adresse de ma fonction et exécuter les opcodes un a un mais ça ne marche pas,j' ai du faire une erreur si quelqu'un pouvait m'éclairer ce serai sympa merci d'avance

Moi j'aurais plutot fais les choses comme ca :

Code:

1
2
3
4
5
6
7
8
9
10
 
int main(int argc, char *argv[])
{
 
  int (*p)();
  p=fonct;
  p();
  system("PAUSE");	
  return 0;
}

Citation:

Envoyé par chuko

Normalement le pointeur devrai sauter sur l'adresse de ma fonction et exécuter les opcodes un a un mais ça ne marche pas,j' ai du faire une erreur si quelqu'un pouvait m'éclairer ce serai sympa merci d'avance

il faut pointer non pas sur la fonction ( qui ne fait rien du tout ) mais sur ton shellCode directement grâce à un cast explicite comme ceci :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 char scode[]= "\x31\xc9\x83\xe9\xdd\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xfb" "\xe2\x8d\x15\x83\xeb\xfc\xe2\xf4\x07\x0a\xc9\x15\xfb\xe2\x06\x50" "\xc7\x69\xf1\x10\x83\xe3\x62\x9e\xb4\xfa\x06\x4a\xdb\xe3\x66\x5c" "\x70\xd6\x06\x14\x15\xd3\x4d\x8c\x57\x66\x4d\x61\xfc\x23\x47\x18" "\xfa\x20\x66\xe1\xc0\xb6\xa9\x11\x8e\x07\x06\x4a\xdf\xe3\x66\x73" "\x70\xee\xc6\x9e\xa4\xfe\x8c\xfe\x70\xfe\x06\x14\x10\x6b\xd1\x31" "\xff\x21\xbc\xd5\x9f\x69\xcd\x25\x7e\x22\xf5\x19\x70\xa2\x81\x9e" "\x8b\xfe\x20\x9e\x93\xea\x66\x1c\x70\x62\x3d\x15\xfb\xe2\x06\x7d" "\xc7\xbd\xbc\xe3\x9b\xb4\x04\xed\x78\x22\xf6\x45\x93\x12\x07\x11" "\xa4\x8a\x15\xeb\x71\xec\xda\xea\x1c\x81\xec\x79\x98\xcc\xe8\x6d" "\x9e\xe2\x8d\x15"; int main(int argc, char *argv[]) { int(*p)(); p = (int(*)())scode; (*p)(); system("PAUSE"); return 0; }
ton shellcode est erroné ... en désassemblant ton code je n'ai pas trouvé de RET ....

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdlib.h>
 
char shellcode[] = /* appelons un chat, un chat!! */
   "\x31\xc9\x83\xe9\xdd\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xfb"
   "\xe2\x8d\x15\x83\xeb\xfc\xe2\xf4\x07\x0a\xc9\x15\xfb\xe2\x06\x50"
   "\xc7\x69\xf1\x10\x83\xe3\x62\x9e\xb4\xfa\x06\x4a\xdb\xe3\x66\x5c"
   "\x70\xd6\x06\x14\x15\xd3\x4d\x8c\x57\x66\x4d\x61\xfc\x23\x47\x18"
   "\xfa\x20\x66\xe1\xc0\xb6\xa9\x11\x8e\x07\x06\x4a\xdf\xe3\x66\x73"
   "\x70\xee\xc6\x9e\xa4\xfe\x8c\xfe\x70\xfe\x06\x14\x10\x6b\xd1\x31"
   "\xff\x21\xbc\xd5\x9f\x69\xcd\x25\x7e\x22\xf5\x19\x70\xa2\x81\x9e"
   "\x8b\xfe\x20\x9e\x93\xea\x66\x1c\x70\x62\x3d\x15\xfb\xe2\x06\x7d"
   "\xc7\xbd\xbc\xe3\x9b\xb4\x04\xed\x78\x22\xf6\x45\x93\x12\x07\x11"
   "\xa4\x8a\x15\xeb\x71\xec\xda\xea\x1c\x81\xec\x79\x98\xcc\xe8\x6d"
   "\x9e\xe2\x8d\x15";
 
 
int main (void)
{
   size_t *ret = (size_t *)(&ret + 2);
   *ret = (size_t)shellcode;
   return 0;
}

Apparamment ça n'est pas un shellcode pour Linux ou BSD.

03/08/2008, 02h17
Emmanuel Delahaye

Citation:

Envoyé par chuko

Bonjour a tous un petit souci sur un pointeur fonction je poste le code
<...>
Normalement le pointeur devrai sauter sur l'adresse de ma fonction et exécuter les opcodes un a un mais ça ne marche pas,j' ai du faire une erreur si quelqu'un pouvait m'éclairer ce serai sympa merci d'avance

C'est louche. C'est quoi ces opcodes ? Ils ont du sens pour ta machine ? Ca fait quoi ?

De toutes façons, ce sont des données, donc ils ne sont pas exécutés. Il n'y a pas de moyen portable de faire ce que tu veux faire.
03/08/2008, 02h19
Emmanuel Delahaye
Citation:
Envoyé par ssmario2

il faut pointer non pas sur la fonction ( qui ne fait rien du tout ) mais sur ton shellCode directement grâce à un cast explicite comme ceci :

Code:

1 2 3 4 5 6 7 8 9 10 int main(int argc, char *argv[]) { int(*p)(); p = (int(*)())scode; (*p)(); system("PAUSE"); return 0; }
Le comportement est indéfini, car tu mets l'adresse d'une variable dans un pointeur de fonction... Ca peut fonctionner ... ou pas, selon les phases de la lune, l'age du capitaine...
03/08/2008, 04h03
firemax

Citation:

Envoyé par Emmanuel Delahaye

Le comportement est indéfini, car tu mets l'adresse d'une variable dans un pointeur de fonction... Ca peut fonctionner ... ou pas, selon les phases de la lune, l'age du capitaine...

Je comprend pas bien ce que tu veux m'expliquer, fonct n'est pas une variable (dans mon exemple c'etais int fonct()).
03/08/2008, 08h22
Emmanuel Delahaye

Citation:

Envoyé par firemax

Je comprend pas bien ce que tu veux m'expliquer, fonct n'est pas une variable (dans mon exemple c'etais int fonct()).

Désolé, je me suis embrouillé avec les différents répondeurs... J'ai corrigé.

Ton code est techniquement correct, mais évidemment, le shellcode étant en mémoire de données, il n'est pas exécuté...
03/08/2008, 09h33
Melem
@chucko : ce n'est pas toi-même qui as déjà créé cette discussion : ASM dans programme C ? Je ne vois pas pourquoi on devrait retaper tout ce qui a déjà été posté.
Citation:
Envoyé par chucko

Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 int fonct() { char scode [] = "..."; return 0; } int main() { int (*p)(); p = &fonct; (*p)(); return 0; }

Normalement le pointeur devrait sauter sur l'adresse de ma fonction et exécuter les opcodes un a un ...
Non p pointe sur fonct donc (*p)() appelle fonct, qui crée un tableau initialisé puis retourne. Si tu veux faire exécuter du code machine que tu as composé tu pointes sur ces instructions, pas sur autre chose. C'est un moyen de faire, mais pas le seul (voir code de nicolas.sitbon). Mais le plus important, on ne met pas n'importe quoi dans le code. En particulier, une fonction doit toujours se terminer par ret ...
03/08/2008, 10h17
chuko

re

Merci pour vos réponse oui ne effet j'avais déjà poster un truc du même genre mais pour être franc au moment de l'ancien poste je ne comprenais absolument rien au pointeur de fonction, bref merci pour votre aide ça fonctionne maintenant
03/08/2008, 10h19
chuko

re

Pour info les opcodes ne font rien de spécial si ce n'est lancer calc.exe de windows

Citation:

Envoyé par Emmanuel Delahaye

Désolé, je me suis embrouillé avec les différents répondeurs... J'ai corrigé.

Ton code est techniquement correct, mais évidemment, le shellcode étant en mémoire de données, il n'est pas exécuté...

Ok, me posais la question, je cherchais désespérément l'erreur ^^

(et nan le shellcode ne sera pas exécuter mais je pensais que la question se limitait au pointeur sur fonction)
Citation:
Envoyé par nicolas.sitbon
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 #include <stdlib.h> char shellcode[] = /* appelons un chat, un chat!! */ "\x31\xc9\x83\xe9\xdd\xd9\xee\xd9\x74\x24\xf4\x5b\x81\x73\x13\xfb" "\xe2\x8d\x15\x83\xeb\xfc\xe2\xf4\x07\x0a\xc9\x15\xfb\xe2\x06\x50" "\xc7\x69\xf1\x10\x83\xe3\x62\x9e\xb4\xfa\x06\x4a\xdb\xe3\x66\x5c" "\x70\xd6\x06\x14\x15\xd3\x4d\x8c\x57\x66\x4d\x61\xfc\x23\x47\x18" "\xfa\x20\x66\xe1\xc0\xb6\xa9\x11\x8e\x07\x06\x4a\xdf\xe3\x66\x73" "\x70\xee\xc6\x9e\xa4\xfe\x8c\xfe\x70\xfe\x06\x14\x10\x6b\xd1\x31" "\xff\x21\xbc\xd5\x9f\x69\xcd\x25\x7e\x22\xf5\x19\x70\xa2\x81\x9e" "\x8b\xfe\x20\x9e\x93\xea\x66\x1c\x70\x62\x3d\x15\xfb\xe2\x06\x7d" "\xc7\xbd\xbc\xe3\x9b\xb4\x04\xed\x78\x22\xf6\x45\x93\x12\x07\x11" "\xa4\x8a\x15\xeb\x71\xec\xda\xea\x1c\x81\xec\x79\x98\xcc\xe8\x6d" "\x9e\xe2\x8d\x15"; int main (void) { size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)shellcode; return 0; }
Apparamment ça n'est pas un shellcode pour Linux ou BSD.
Sinon (desoler chuko je me sert un peu de ton thread) je comprend pas bien cette partie de code :
Code:

1 2 size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)shellcode;
Est t'il possible que quelqu'un explique ?

Citation:
Envoyé par firemax
Sinon (desoler chuko je me sert un peu de ton thread) je comprend pas bien cette partie de code :
Code:

1 2 size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)shellcode;
Est t'il possible que quelqu'un explique ?
Quand tu appelles une fonction, l'adresse de retour (l'instruction suivant le call) est pushé sur la pile,
suivi de la sauvegarde de pointeur de frame, ça fait donc 2 adresses sur la pile. Le but ici est d'écrasé l'adresse de retour. Pour ce faire, il faut déjà avoir un pointeur dessus, et ensuite l'écraser.

Code:

size_t *ret = (size_t *)(&ret + 2);

ici on fait pointer ret sur l'adresse de retour stocker sur la pile (2 adresses plus haut d'où le + 2).

Code:

*ret = (size_t)shellcode;

enfin on écrase la valeur de retour par l'adresse de notre shellcode.
Code:

1 2 3 4 5 6 7 8 9 avant : après : =======================================| |adresse de retour|adresse du shellcode| |=================|====================| |pointeur de frame|pointeur de frame | |=================|====================| | ret | ret | |======================================|

03/08/2008, 20h44
firemax

Merci, je vois le principe (meme si je ne maitrise pas assez le sujet pour penser a ce genre de pratique xd)

Je retiens c'est toujours utile a savoir :)
03/08/2008, 22h47
orfix

@nicolas.sitbon : Cette méthode fonctionne très bien avec de simple fonctions, mais pas pour le main ( comme dans votre exemple ) en tous cas chez moi ! en exécutant mes programmes directement depuis la console sans IDE.

J'en conclue que le Pointeur d'Instruction IP ne va pas aller chercher l'adresse de retour dans la pile après l'exécution de main puisque main est le point d'entrée personne ne l'a appelé ? Dites moi si je me trompe j'aimerais comprendre un peu mieux ce genre de mécanisme, Merci .
03/08/2008, 23h22
Emmanuel Delahaye

Citation:

Envoyé par ssmario2

J'en conclue que le Pointeur d'Instruction IP ne va pas aller chercher l'adresse de retour dans la pile après l'exécution de main puisque main est le point d'entrée personne ne l'a appelé ? Dites moi si je me trompe j'aimerais comprendre un peu mieux ce genre de mécanisme, Merci .

Si tu connais un peu l'assembleur 386, exécute le code pas à pas en mode assembleur...

Code::Blocks : debugger : {...}

Ce code sera plus parlant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #include <stdlib.h> /* -MO- shellCode spécifique à linux * sous Windows sa serais : * * MOV AX,0x4C00 * INT 0x21 */ char sysCall_exit[]= "\xB8\x01\x00\x00\x00" /* mov eax,1 ; sys_exit de kernel/exit.c */ "\xBB\x05\x00\x00\x00" /* mov ebx,5 ; code d'erreur 5 choisis arbitrairement */ "\xCD\x80"; /* int 80h ; appel systéme */ void foo( void ) { size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)sysCall_exit; } int main (void) { #if DEPUIS_MAIN size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)sysCall_exit; #else foo(); #endif return 0; }
Code:

1 2 3 4 5 6 $> gcc -Wall shell.c && ./a.out le shell a retourné 5 $> gcc -Wall -D DEPUIS_MAIN shell.c && ./a.out && echo $? 0
Avec GDB même constations depuis le main le shellCode n'est pas exécuté, en passant par une fonction le résultat est celui attendu.

le choix des instructions pour le shellCode s'explique par le fait que j'avais droit à une erreur de segmentation normale l'adresse de retour sur la pile est erronée ( je me suis amusé avec la pile en essayons plusieurs trucs :p ça marche parfaitement ) ces instructions mettent fin à l'exécution plus ou moins propre du programme en retournant un code d'erreur '5' ainsi si le shellCode a été exécuté le programme renverra 5 au shell autrement 0 ( venant du main : return 0 ) .

Citation:
Envoyé par ssmario2
Ce code sera plus parlant :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 #include <stdlib.h> /* -MO- shellCode spécifique à linux * sous Windows sa serais : * * MOV AX,0x4C00 * INT 0x21 */ char sysCall_exit[]= "\xB8\x01\x00\x00\x00" /* mov eax,1 ; sys_exit de kernel/exit.c */ "\xBB\x05\x00\x00\x00" /* mov ebx,5 ; code d'erreur 5 choisis arbitrairement */ "\xCD\x80"; /* int 80h ; appel systéme */ void foo( void ) { size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)sysCall_exit; } int main (void) { #if DEPUIS_MAIN size_t *ret = (size_t *)(&ret + 2); *ret = (size_t)sysCall_exit; #else foo(); #endif return 0; }
Code:

1 2 3 4 5 6 $> gcc -Wall shell.c && ./a.out le shell a retourné 5 $> gcc -Wall -D DEPUIS_MAIN shell.c && ./a.out && echo $? 0
Avec GDB même constations depuis le main le shellCode n'est pas exécuté, en passant par une fonction le résultat est celui attendu.

le choix des instructions pour le shellCode s'explique par le fait que j'avais droit à une erreur de segmentation normale l'adresse de retour sur la pile est erronée ( je me suis amusé avec la pile en essayons plusieurs trucs :p ça marche parfaitement ) ces instructions mettent fin à l'exécution plus ou moins propre du programme en retournant un code d'erreur '5' ainsi si le shellCode a été exécuté le programme renverra 5 au shell autrement 0 ( venant du main : return 0 ) .
En fait c'est plus compliqué que ça, la fonction main() est bien appelé, par une certaine fonction mainCRTStartup() si je ne dis pas de bêtise qui se trouve dans crt0.c. Le problème avec Microsoft, est qu'ils ont tendance à rajouter certaine information sur la pile, de mémoire, j'avais trouvé leur système de gestion des exceptions, ce qui fait que dans ce cas là, le décalage doit être plus grand. Les shellcodes ne sont malheureusement pas une science exacte, je n'y connais pas grand chose sous Windows, je suis plus UNIX, mais Melem ou Médinoc pourront te répondre je suppose.

04/08/2008, 09h03
Melem

Il n'y a pas grand-chose à rajouter, main quelle que soit la plateforme est en effet appelée par une fonction qui varie selon l'environnement. C'est cette fonction qui fournit les paramètres de la ligne de commande et tout le reste (flux standards, etc.). Quant à l'emplacement de l'adresse de retour sur la pile, on ne peut pas généraliser.

Peut-être:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
#include <stdlib.h>
#include <stdint.h>
 
char sysCall_exit[]=
  "\xB8\x01\x00\x00\x00"
  "\xBB\x05\x00\x00\x00"
  "\xCD\x80";
 
int
main (void)
{
  uintptr_t *ret;
 
  ret = (uintptr_t *)(&ret + 7);
  *ret = (uintptr_t)sysCall_exit;       
  return 0;
}

qui donne ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
08048384 <main>:
 8048384:       8d 4c 24 04             lea    0x4(%esp),%ecx
 8048388:       83 e4 f0                and    $0xfffffff0,%esp
 804838b:       ff 71 fc                pushl  -0x4(%ecx)
 804838e:       55                      push   %ebp
 804838f:       89 e5                   mov    %esp,%ebp
 8048391:       51                      push   %ecx
 8048392:       83 ec 10                sub    $0x10,%esp
 8048395:       8d 45 f8                lea    -0x8(%ebp),%eax
 8048398:       83 c0 1c                add    $0x1c,%eax
 804839b:       89 45 f8                mov    %eax,-0x8(%ebp)
 804839e:       8b 55 f8                mov    -0x8(%ebp),%edx
 80483a1:       b8 14 a0 04 08          mov    $0x804a014,%eax
 80483a6:       89 02                   mov    %eax,(%edx)
 80483a8:       b8 00 00 00 00          mov    $0x0,%eax
 80483ad:       83 c4 10                add    $0x10,%esp
 80483b0:       59                      pop    %ecx
 80483b1:       5d                      pop    %ebp
 80483b2:       8d 61 fc                lea    -0x4(%ecx),%esp
 80483b5:       c3                      ret
 80483b6:       90                      nop

Mais c'est beaucoup trop fragile. D'ailleurs tu peux voir qu'à l'entrée de la fonction main, y'a un prologue différent par rapport aux autres fonctions.

Btw je profite de ton thread pour demander pourquoi sur un 64b le code si dessous ne s'exécute pas (= segfault) ? On dirait que la heap n'est pas executable :S (sur 32b c'est ok). Louche :roll:

Code:

1
2
3
4
5
6
7
8
 
char rupt = 0xcc;
 
int main(void)
{
  __asm__ __volatile__("jmp *%[dest]":: [dest] "r" (&rupt));
  return 0;
}

Voir 40 message(s) de cette discussion en une page