Affichage hiérarchique

InstinctHack · (Modification du message : 04-05-2013, 13h31 par InstinctHack.)

Salut,

(Ce thread s'est transformé de demande d'aide en nano mini tuto)

Je vous propose de programmer un très simple crackme.
Voilà la source :

Code C :



#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#define LONGUEUR 500 

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

{

    char Nom_du_tableau[LONGUEUR]="\0";//on définie un char

    char chaine1[] = "password";//un deuxième



    printf("Code?\n");//on demande à l'utilisateur de rentrer un code

    scanf("%s", Nom_du_tableau);//on récupère ce code

    printf("Chaine insérer : %s \n", Nom_du_tableau);//on l'affiche (useless mais bon...)



    if (strcmp(chaine1, Nom_du_tableau) != 0)//si les deux chaines sont différentes

        printf("FAIL\n");

    else

        printf("WIN\n");

    return 0;

}

compilez le ainsi :

Code :
gcc crackme.c

il nous faudras deux softs : objdump et hexedit, installez-les si nécessaire.
Comme le fichier en sortie (il se nomme généralement a.out) est en binaire, il n'est pas possible de l'ouvrir avec un éditeur de texte. Et comme c'est un éxécutable, on peux le déssambler pour afficher le code assembleur avec objdump.
Ce que l'on fait ainsi :

Code :
objdump -d a.out

(le paramètre -d signifiant "disassemble", d'ailleurs je vous invite à lire le man pour plus d'infos Wink

)
vous devriez obtenir une sortie similaire à celle-ci :

Code :
a.out:     file format elf64-x86-64

Disassembly of section .init:

00000000004004f0 <_init>:

  4004f0:       48 83 ec 08             sub    $0x8,%rsp

  4004f4:       e8 a3 00 00 00          callq  40059c <call_gmon_start>

  4004f9:       48 83 c4 08             add    $0x8,%rsp

  4004fd:       c3                      retq   

Disassembly of section .plt:

0000000000400500 <puts@plt-0x10>:

  400500:       ff 35 02 0b 20 00       pushq  0x200b02(%rip)        # 601008 <_GLOBAL_OFFSET_TABLE_+0x8>

  400506:       ff 25 04 0b 20 00       jmpq   *0x200b04(%rip)        # 601010 <_GLOBAL_OFFSET_TABLE_+0x10>

  40050c:       0f 1f 40 00             nopl   0x0(%rax)

0000000000400510 <puts@plt>:

  400510:       ff 25 02 0b 20 00       jmpq   *0x200b02(%rip)        # 601018 <_GLOBAL_OFFSET_TABLE_+0x18>

  400516:       68 00 00 00 00          pushq  $0x0

  40051b:       e9 e0 ff ff ff          jmpq   400500 <_init+0x10>

0000000000400520 <__stack_chk_fail@plt>:

  400520:       ff 25 fa 0a 20 00       jmpq   *0x200afa(%rip)        # 601020 <_GLOBAL_OFFSET_TABLE_+0x20>

  400526:       68 01 00 00 00          pushq  $0x1

  40052b:       e9 d0 ff ff ff          jmpq   400500 <_init+0x10>

0000000000400530 <printf@plt>:

  400530:       ff 25 f2 0a 20 00       jmpq   *0x200af2(%rip)        # 601028 <_GLOBAL_OFFSET_TABLE_+0x28>

  400536:       68 02 00 00 00          pushq  $0x2

  40053b:       e9 c0 ff ff ff          jmpq   400500 <_init+0x10>

0000000000400540 <__libc_start_main@plt>:

  400540:       ff 25 ea 0a 20 00       jmpq   *0x200aea(%rip)        # 601030 <_GLOBAL_OFFSET_TABLE_+0x30>

  400546:       68 03 00 00 00          pushq  $0x3

  40054b:       e9 b0 ff ff ff          jmpq   400500 <_init+0x10>

0000000000400550 <strcmp@plt>:

  400550:       ff 25 e2 0a 20 00       jmpq   *0x200ae2(%rip)        # 601038 <_GLOBAL_OFFSET_TABLE_+0x38>

  400556:       68 04 00 00 00          pushq  $0x4

  40055b:       e9 a0 ff ff ff          jmpq   400500 <_init+0x10>

0000000000400560 <__isoc99_scanf@plt>:

  400560:       ff 25 da 0a 20 00       jmpq   *0x200ada(%rip)        # 601040 <_GLOBAL_OFFSET_TABLE_+0x40>

  400566:       68 05 00 00 00          pushq  $0x5

  40056b:       e9 90 ff ff ff          jmpq   400500 <_init+0x10>

Disassembly of section .text:

0000000000400570 <_start>:

  400570:       31 ed                   xor    %ebp,%ebp

  400572:       49 89 d1                mov    %rdx,%r9

  400575:       5e                      pop    %rsi

  400576:       48 89 e2                mov    %rsp,%rdx

  400579:       48 83 e4 f0             and    $0xfffffffffffffff0,%rsp

  40057d:       50                      push   %rax

  40057e:       54                      push   %rsp

  40057f:       49 c7 c0 20 08 40 00    mov    $0x400820,%r8

  400586:       48 c7 c1 90 07 40 00    mov    $0x400790,%rcx

  40058d:       48 c7 c7 7c 06 40 00    mov    $0x40067c,%rdi

  400594:       e8 a7 ff ff ff          callq  400540 <__libc_start_main@plt>

  400599:       f4                      hlt    

  40059a:       66 90                   xchg   %ax,%ax

000000000040059c <call_gmon_start>:

  40059c:       48 83 ec 08             sub    $0x8,%rsp

  4005a0:       48 8b 05 51 0a 20 00    mov    0x200a51(%rip),%rax        # 600ff8 <_DYNAMIC+0x1d0>

  4005a7:       48 85 c0                test   %rax,%rax

  4005aa:       74 02                   je     4005ae <call_gmon_start+0x12>

  4005ac:       ff d0                   callq  *%rax

  4005ae:       48 83 c4 08             add    $0x8,%rsp

  4005b2:       c3                      retq   

  4005b3:       66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)

  4005ba:       00 00 00 

  4005bd:       0f 1f 00                nopl   (%rax)

00000000004005c0 <deregister_tm_clones>:

  4005c0:       b8 5f 10 60 00          mov    $0x60105f,%eax

  4005c5:       55                      push   %rbp

  4005c6:       48 2d 58 10 60 00       sub    $0x601058,%rax

  4005cc:       48 83 f8 0e             cmp    $0xe,%rax

  4005d0:       48 89 e5                mov    %rsp,%rbp

  4005d3:       77 02                   ja     4005d7 <deregister_tm_clones+0x17>

  4005d5:       5d                      pop    %rbp

  4005d6:       c3                      retq   

  4005d7:       b8 00 00 00 00          mov    $0x0,%eax

  4005dc:       48 85 c0                test   %rax,%rax

  4005df:       74 f4                   je     4005d5 <deregister_tm_clones+0x15>

  4005e1:       5d                      pop    %rbp

  4005e2:       bf 58 10 60 00          mov    $0x601058,%edi

  4005e7:       ff e0                   jmpq   *%rax

  4005e9:       0f 1f 80 00 00 00 00    nopl   0x0(%rax)

00000000004005f0 <register_tm_clones>:

  4005f0:       b8 58 10 60 00          mov    $0x601058,%eax

  4005f5:       55                      push   %rbp

  4005f6:       48 2d 58 10 60 00       sub    $0x601058,%rax

  4005fc:       48 c1 f8 03             sar    $0x3,%rax

  400600:       48 89 e5                mov    %rsp,%rbp

  400603:       48 89 c2                mov    %rax,%rdx

  400606:       48 c1 ea 3f             shr    $0x3f,%rdx

  40060a:       48 01 d0                add    %rdx,%rax

  40060d:       48 89 c6                mov    %rax,%rsi

  400610:       48 d1 fe                sar    %rsi

  400613:       75 02                   jne    400617 <register_tm_clones+0x27>

  400615:       5d                      pop    %rbp

  400616:       c3                      retq   

  400617:       ba 00 00 00 00          mov    $0x0,%edx

  40061c:       48 85 d2                test   %rdx,%rdx

  40061f:       74 f4                   je     400615 <register_tm_clones+0x25>

  400621:       5d                      pop    %rbp

  400622:       bf 58 10 60 00          mov    $0x601058,%edi

  400627:       ff e2                   jmpq   *%rdx

  400629:       0f 1f 80 00 00 00 00    nopl   0x0(%rax)

0000000000400630 <__do_global_dtors_aux>:

  400630:       80 3d 21 0a 20 00 00    cmpb   $0x0,0x200a21(%rip)        # 601058 <__TMC_END__>

  400637:       75 11                   jne    40064a <__do_global_dtors_aux+0x1a>

  400639:       55                      push   %rbp

  40063a:       48 89 e5                mov    %rsp,%rbp

  40063d:       e8 7e ff ff ff          callq  4005c0 <deregister_tm_clones>

  400642:       5d                      pop    %rbp

  400643:       c6 05 0e 0a 20 00 01    movb   $0x1,0x200a0e(%rip)        # 601058 <__TMC_END__>

  40064a:       f3 c3                   repz retq 

  40064c:       0f 1f 40 00             nopl   0x0(%rax)

0000000000400650 <frame_dummy>:

  400650:       48 83 3d c8 07 20 00    cmpq   $0x0,0x2007c8(%rip)        # 600e20 <__JCR_END__>

  400657:       00 

  400658:       74 1b                   je     400675 <frame_dummy+0x25>

  40065a:       b8 00 00 00 00          mov    $0x0,%eax

  40065f:       48 85 c0                test   %rax,%rax

  400662:       74 11                   je     400675 <frame_dummy+0x25>

  400664:       55                      push   %rbp

  400665:       bf 20 0e 60 00          mov    $0x600e20,%edi

  40066a:       48 89 e5                mov    %rsp,%rbp

  40066d:       ff d0                   callq  *%rax

  40066f:       5d                      pop    %rbp

  400670:       e9 7b ff ff ff          jmpq   4005f0 <register_tm_clones>

  400675:       e9 76 ff ff ff          jmpq   4005f0 <register_tm_clones>

  40067a:       66 90                   xchg   %ax,%ax

000000000040067c <main>:

  40067c:       55                      push   %rbp

  40067d:       48 89 e5                mov    %rsp,%rbp

  400680:       48 81 ec 20 02 00 00    sub    $0x220,%rsp

  400687:       89 bd ec fd ff ff       mov    %edi,-0x214(%rbp)

  40068d:       48 89 b5 e0 fd ff ff    mov    %rsi,-0x220(%rbp)

  400694:       64 48 8b 04 25 28 00    mov    %fs:0x28,%rax

  40069b:       00 00 

  40069d:       48 89 45 f8             mov    %rax,-0x8(%rbp)

  4006a1:       31 c0                   xor    %eax,%eax

  4006a3:       0f b7 05 b3 01 00 00    movzwl 0x1b3(%rip),%eax        # 40085d <_IO_stdin_used+0x2d>

  4006aa:       66 89 85 00 fe ff ff    mov    %ax,-0x200(%rbp)

  4006b1:       48 8d 95 02 fe ff ff    lea    -0x1fe(%rbp),%rdx

  4006b8:       b8 00 00 00 00          mov    $0x0,%eax

  4006bd:       66 89 02                mov    %ax,(%rdx)

  4006c0:       48 83 c2 02             add    $0x2,%rdx

  4006c4:       89 02                   mov    %eax,(%rdx)

  4006c6:       48 83 c2 04             add    $0x4,%rdx

  4006ca:       b9 3d 00 00 00          mov    $0x3d,%ecx

  4006cf:       48 89 d7                mov    %rdx,%rdi

  4006d2:       f3 48 ab                rep stos %rax,%es:(%rdi)

  4006d5:       48 89 fa                mov    %rdi,%rdx

  4006d8:       89 02                   mov    %eax,(%rdx)

  4006da:       48 83 c2 04             add    $0x4,%rdx

  4006de:       c7 85 f0 fd ff ff 70    movl   $0x73736170,-0x210(%rbp)

  4006e5:       61 73 73 

  4006e8:       c7 85 f4 fd ff ff 77    movl   $0x64726f77,-0x20c(%rbp)

  4006ef:       6f 72 64 

  4006f2:       c6 85 f8 fd ff ff 00    movb   $0x0,-0x208(%rbp)

  4006f9:       bf 34 08 40 00          mov    $0x400834,%edi

  4006fe:       e8 0d fe ff ff          callq  400510 <puts@plt>

  400703:       48 8d 85 00 fe ff ff    lea    -0x200(%rbp),%rax

  40070a:       48 89 c6                mov    %rax,%rsi

  40070d:       bf 3a 08 40 00          mov    $0x40083a,%edi

  400712:       b8 00 00 00 00          mov    $0x0,%eax

  400717:       e8 44 fe ff ff          callq  400560 <__isoc99_scanf@plt>

  40071c:       48 8d 85 00 fe ff ff    lea    -0x200(%rbp),%rax

  400723:       48 89 c6                mov    %rax,%rsi

  400726:       bf 3d 08 40 00          mov    $0x40083d,%edi

  40072b:       b8 00 00 00 00          mov    $0x0,%eax

  400730:       e8 fb fd ff ff          callq  400530 <printf@plt>

  400735:       48 8d 95 00 fe ff ff    lea    -0x200(%rbp),%rdx

  40073c:       48 8d 85 f0 fd ff ff    lea    -0x210(%rbp),%rax

  400743:       48 89 d6                mov    %rdx,%rsi

  400746:       48 89 c7                mov    %rax,%rdi

  400749:       e8 02 fe ff ff          callq  400550 <strcmp@plt>

  40074e:       85 c0                   test   %eax,%eax

  400750:       74 0c                   je     40075e <main+0xe2>

  400752:       bf 54 08 40 00          mov    $0x400854,%edi

  400757:       e8 b4 fd ff ff          callq  400510 <puts@plt>

  40075c:       eb 0a                   jmp    400768 <main+0xec>

  40075e:       bf 59 08 40 00          mov    $0x400859,%edi

  400763:       e8 a8 fd ff ff          callq  400510 <puts@plt>

  400768:       b8 00 00 00 00          mov    $0x0,%eax

  40076d:       48 8b 55 f8             mov    -0x8(%rbp),%rdx

  400771:       64 48 33 14 25 28 00    xor    %fs:0x28,%rdx

  400778:       00 00 

  40077a:       74 05                   je     400781 <main+0x105>

  40077c:       e8 9f fd ff ff          callq  400520 <__stack_chk_fail@plt>

  400781:       c9                      leaveq 

  400782:       c3                      retq   

  400783:       66 2e 0f 1f 84 00 00    nopw   %cs:0x0(%rax,%rax,1)

  40078a:       00 00 00 

  40078d:       0f 1f 00                nopl   (%rax)

0000000000400790 <__libc_csu_init>:

  400790:       48 89 6c 24 d8          mov    %rbp,-0x28(%rsp)

  400795:       4c 89 64 24 e0          mov    %r12,-0x20(%rsp)

  40079a:       48 8d 2d 77 06 20 00    lea    0x200677(%rip),%rbp        # 600e18 <__init_array_end>

  4007a1:       4c 8d 25 68 06 20 00    lea    0x200668(%rip),%r12        # 600e10 <__frame_dummy_init_array_entry>

  4007a8:       4c 89 6c 24 e8          mov    %r13,-0x18(%rsp)

  4007ad:       4c 89 74 24 f0          mov    %r14,-0x10(%rsp)

  4007b2:       4c 89 7c 24 f8          mov    %r15,-0x8(%rsp)

  4007b7:       48 89 5c 24 d0          mov    %rbx,-0x30(%rsp)

  4007bc:       48 83 ec 38             sub    $0x38,%rsp

  4007c0:       4c 29 e5                sub    %r12,%rbp

  4007c3:       41 89 fd                mov    %edi,%r13d

  4007c6:       49 89 f6                mov    %rsi,%r14

  4007c9:       48 c1 fd 03             sar    $0x3,%rbp

  4007cd:       49 89 d7                mov    %rdx,%r15

  4007d0:       e8 1b fd ff ff          callq  4004f0 <_init>

  4007d5:       48 85 ed                test   %rbp,%rbp

  4007d8:       74 1c                   je     4007f6 <__libc_csu_init+0x66>

  4007da:       31 db                   xor    %ebx,%ebx

  4007dc:       0f 1f 40 00             nopl   0x0(%rax)

  4007e0:       4c 89 fa                mov    %r15,%rdx

  4007e3:       4c 89 f6                mov    %r14,%rsi

  4007e6:       44 89 ef                mov    %r13d,%edi

  4007e9:       41 ff 14 dc             callq  *(%r12,%rbx,8)

  4007ed:       48 83 c3 01             add    $0x1,%rbx

  4007f1:       48 39 eb                cmp    %rbp,%rbx

  4007f4:       75 ea                   jne    4007e0 <__libc_csu_init+0x50>

  4007f6:       48 8b 5c 24 08          mov    0x8(%rsp),%rbx

  4007fb:       48 8b 6c 24 10          mov    0x10(%rsp),%rbp

  400800:       4c 8b 64 24 18          mov    0x18(%rsp),%r12

  400805:       4c 8b 6c 24 20          mov    0x20(%rsp),%r13

  40080a:       4c 8b 74 24 28          mov    0x28(%rsp),%r14

  40080f:       4c 8b 7c 24 30          mov    0x30(%rsp),%r15

  400814:       48 83 c4 38             add    $0x38,%rsp

  400818:       c3                      retq   

  400819:       0f 1f 80 00 00 00 00    nopl   0x0(%rax)

0000000000400820 <__libc_csu_fini>:

  400820:       f3 c3                   repz retq 

  400822:       66 90                   xchg   %ax,%ax

Disassembly of section .fini:

0000000000400824 <_fini>:

  400824:       48 83 ec 08             sub    $0x8,%rsp

  400828:       48 83 c4 08             add    $0x8,%rsp

  40082c:       c3                      retq

Moche nan ? Smile

Bon là, il faut connaitre un peu les bases en assembleur pour y comprendre quelque chose...
mais si vous faites attention, vous verrez quelques lignes intéressantes :

Code :
...

  4006fe:       e8 0d fe ff ff          callq  400510 <puts@plt>

...

  400717:       e8 44 fe ff ff          callq  400560 <__isoc99_scanf@plt>

....

  400749:       e8 02 fe ff ff          callq  400550 <strcmp@plt>

  40074e:       85 c0                   test   %eax,%eax

  400750:       74 0c                   je     40075e <main+0xe2>

Alors pourquoi sont-t-elles intéressantes ?
et bien pour :
la première vous reconnaitrez surement votre affichage de message,
la deuxième étant la récupération du code envoyé par l'utilisateur,
la troisième c'est l'opération de comparaison
la quatrième est la "fonction assembleur" qui se charge de faire "vraiment" l'opération (@gourous, insulter moi au besoin Big Grin

)
la cinquième est un saut qui se produise si la condition n'est pas respecté (la condition étant que les passes soient différents, si le saut se produit c'est qu'on as le bon password)

et on vas venir "patcher" (cad modifier) notre crackme pour qu'il valide n'importe quel password, et pour ça on vas jouer sur la dernière instruction : le jump.

il faut savoir qu'il existe (au moins ) trois sauts : (c'est ceux que je connait :p )

Code :
JE adr    74    2    Saut à l'adresse indiquée si égalité

JG adr    7F    2    Saut à l'adresse indiquée si supérieur

JLE adr    7E    2    Saut à l'adresse indiquée si inférieur

JNE adr    75    2    Saut à l'adresse indiquée si non-égalité

-le jmp qui se produit toujours ( \xEB )

Donc pour edit le binaire, on use hexedit ainsi :

Code :
hexedit --color a.out

(c'est plus """lisible""" avec la couleur)
Mais maintenant faut savoir quoi modifier...
Et bien reprenons les lignes intéressantes 3 et 5 :

Code :
400749:       e8 02 fe ff ff          callq  400550 <strcmp@plt>

...

  400750:       74 0c                   je     40075e <main+0xe2>

La deuxième colonne est la représentation en héxadécimale des instructions, vous pouvez donc les rechercher en faisant Ctrl+S et en insérant la chaine "E802FEFFFF" l'éditeur vous metteras à l'endroit approprié, puis avancez jusqu'a trouver "740C" et remplacer par un saut qui se produiras à tous les coups : "EB0C".
Enregistrer votre crackme avec Ctrl+W et appuyez sur [S].
Lancer le

Code :
./a.out

Et rentrer ce que vous voulez, après tout, maintenant on s'en fout, le crackme est patcher \o/
J'espère que ce tuto fait par un loob en aideras d'autre à commencer dans le RE. Big Grin

notfound · (Modification du message : 04-05-2013, 09h35 par notfound.)

Sympa ce mini tuto, but :

InstinctHack a écrit :Bon là, il faut connaitre un peu les bases en assembleur pour y comprendre quelque chose...
mais si vous faites attention, vous verrez quelques lignes intéressantes :

Code :
... 4006fe: e8 0d fe ff ff callq 400510 <puts@plt> ... 400717: e8 44 fe ff ff callq 400560 <__isoc99_scanf@plt> .... 400749: e8 02 fe ff ff callq 400550 <strcmp@plt> 40074e: 85 c0 test %eax,%eax 400750: 74 0c je 40075e <main+0xe2>

Même sans trop comprendre l'assembleur, et c'est comme ça que j'ai réussi mes premiers crackme (les plus faciles aussi ...) mais on peut voir :

Code :
<puts@plt>    // Affichage à l'écran (printf?)

<__isoc99_scanf@plt> //Scanf ...

<strcmp@plt>   //Fonction strcmp() en C

je     40075e <main+0xe2>   // JE = Jump Egal

Recherche Google si on est pas sûr :

Code :
JE adr    74    2    Saut à l'adresse indiquée si égalité

JG adr    7F    2    Saut à l'adresse indiquée si supérieur

JLE adr    7E    2    Saut à l'adresse indiquée si inférieur

JNE adr    75    2    Saut à l'adresse indiquée si non-égalité

Maintenant qu'on est sûr, on sait que la partie qui nous intéresse est celle qui va comparer les 2 strings (strcmp), on a donc (l'adresse en ROUGE) :

400749: e8 02 fe ff ff callq 400550 <strcmp@plt>

Ceci étant dit, c'est évidement mieux de connaître l'assembleur pour ce genre d'exercice, j'en conviens !

Kiwazaru · 04-05-2013, 13h28

"-le je (celui de base) qui se produit quand la condition est FALSE ( \x74 )
-le jne qui se produit quand la condition est TRUE ( \x75 )
-le jmp qui se produit toujours ( \xEB )"

Dire que c'est celui de base est maladroit j'pense , sinon pareil, ce n'est pas tout le temps FALSE ou TRUE, le post de NotFound l'explique bien: "
JE adr 74 2 Saut à l'adresse indiquée si égalité
JG adr 7F 2 Saut à l'adresse indiquée si supérieur
JLE adr 7E 2 Saut à l'adresse indiquée si inférieur
JNE adr 75 2 Saut à l'adresse indiquée si non-égalité"
et il y en a encore , du genre JNZ (Jump if not zero) , JZ (Jump if Zero), JA, JB (+ || -) etc...
Et si je dis pas de connerie, les JMP sont des jump inconditionnel & les J?? sont des jumps conditionnels, et les jumps conditionnels utilisent des indicateurs (FLAG) genre CF, ZF, SF et OF, et c'est pour ça qu'avec un logiciel de disass type OllyDBG on peu modifier en live les indicateurs afin de patcher les jumps.

gruik · 04-05-2013, 14h58

Kiwazaru · 04-05-2013, 19h25

gruik: Thx, je travaille pas sous linux pour gdb mais c'est toujours bon à savoir Smile

***supersnail*** · 05-05-2013, 09h50

Sinon pour les réfractaires à gdb, y'a edb sous linux qu'est un ollydbg-like (pas mal instable par contre, même si j'ai pas testé la version sur googlecode).

fr0g · 05-05-2013, 16h47

(05-05-2013, 09h50)supersnail a écrit : Sinon pour les réfractaires à gdb, y'a edb sous linux qu'est un ollydbg-like (pas mal instable par contre, même si j'ai pas testé la version sur googlecode).

Je confirme, perso je reste à GDB & IDA sous Linux , le principe de edb est pas mal, mais bon à part une interface graphique il y a rien d'exceptionnel, et la stabilité laisse effectivement à désirer .

Sujets apparemment similaires…
Sujet		Auteur	Réponses	Affichages	Dernier message
	[Ebook-PDF]Programmation Avancée C linux	thxer	3	254	29-05-2013, 07h37 Dernier message: thxer
	[ring0 linux]espionnez ce que fait un utilisateur sur votre pc [à ne pas faire]	Creepy_p0ney	5	394	07-04-2013, 20h24 Dernier message: Kiwazaru
	[C] The advanced linux programming	Junky	2	257	26-03-2013, 18h29 Dernier message: sakiir
	[NASM] Création d'un thread sous Linux uniquement avec les syscalls	supersnail	2	232	04-03-2013, 23h36 Dernier message: Dobry
	[C-Question] Memory Editing Sous linux ?	sakiir	4	245	24-02-2013, 00h58 Dernier message: sakiir
	[C++] Spammeur linux	Dobry	0	133	24-02-2012, 19h48 Dernier message: Dobry

Identifiant Mot de passe
S’enregistrer \| Mot de passe oublié ? Se rappeler