Discussion :

[chuko]

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

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
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

[firemax]

Moi j'aurais plutot fais les choses comme ca :

Code :

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

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;
}

[orfix]

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 :

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
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 ....

[nicolas.sitbon]

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
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.

[Emmanuel Delahaye]

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.

[Emmanuel Delahaye]

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 :

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

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...

[firemax]

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()).

[Emmanuel Delahaye]

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é...

[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é.

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
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 ...

[chuko]

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

[chuko]

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

[firemax]

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)

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
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 :

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

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

Est t'il possible que quelqu'un explique ?

[nicolas.sitbon]

Sinon (desoler chuko je me sert un peu de ton thread) je comprend pas bien cette partie de code :

Code :

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

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 :

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

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 :

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

*ret = (size_t)shellcode;

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

Code :

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

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          |
|======================================|

[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

[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 .

[Emmanuel Delahaye]

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 : {...}

[orfix]

Ce code sera plus parlant :

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
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 :

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

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 ) .

[nicolas.sitbon]

Ce code sera plus parlant :

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
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 :

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

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.

[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.

[bulki]

Peut-être:

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
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 :

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
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

Code :

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

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