code-linux

Détournement du flux d' execution d' un programme

2008-11-22T10:15:00.012+01:00

Ici je vais m' interreser au détournement du flux d' execution d' un programme en C, on s' apercois que c' est assez simple de faire sauter le programme a une adresse choisi et de lui faire executer le code, a condition biensur d' avoir une faille de type "buffer overflow" dans le programme.Voici le code qui va me permettre de le faire:

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

void copier(char *chaine){
        char buffer[50];
        strcpy(buffer, chaine);
}
void detourne(){
         printf("-== OPERATION REUSSI ==-\n");
}
int main(int argc, char **argv){
        if(argc < 2){
        fprintf(stderr, "hey donne un argument !!\n");
        exit(EXIT_FAILURE);
} else {
        copier(argv[1]);
}
return EXIT_SUCCESS;
}

j' ai volontairement écris la fonction copier() qui apel la fonction strcpy() et biensur strcpy() ne controle pas le nombre de caractères qui va être écris dans la variable buffer qui elle ne peut en contenir que 50.
Voila le résultat que j' obtient en envoyant 54 'A' + l' adresse de la fonction detourne dans argv[1] :

$ ./bof $(perl -e 'print "A" x 54 . "\x4e\x84\x04\x08"')
-== OPERATION REUSSI ==-
Erreur de segmentation

Tout marche bien comme prévu le programme en écrasant les 8 octets suivant le buffer en mémoire a bien sauté a l' adresse de la fonction détourne.
Je pourrais m' arreter la mais il reste quand même beaucoup de questions sans réponse, qu' est ce que j' ai éraser exactement ?

En ce penchant sur l' assembleur on voit que le processeur a plusieur registres, celui qui nous intéresse ici est le registre EIP, ce registre contient toujour l' adresse de la prochaine instruction a executer, juste avec cette info on peut deja imaginer ce qu' il c' est passé.
A l' apel de la fonction copier(), il va ce créer un bloc d' activation pour cette fonction, c' est à dire un espace mémoire (stack ou pile) ou sera stocké le contexte de la fonction, les variables locales (buffer), l' ancien debut du bloc d' activation de la fonction appelante (EBP), puis l' adresse de retour de la fonction (EIP) dans l' ordre. On peut representer simplement la mémoire de cette facon:
[ buffer | EBP | EIP ]
Comme je l' ai dit au dessus EIP contient l' adresse de la prochaine instruction à executer, donc maintenant on peut comprendre pourquoi j' ai du envoyer 54 'A' + l' adresse de la fonction detourne().
Mes 50 premier 'A' on rempli le buffer, j' en est rajouté 4 pour écraser EBP et j' ai rajouté l' adresse de la fonction detourne() qui est sur 4 octets aussi.Donc après avoir copié tout ca dans le buffer la mémoire peut être representez comme ca:
[ AAAAAAAAAA | AAAA | adresse de la fonction detourne ]

Pour trouver l' adresse de la fonction detourne je ne me suis pas embeter :

$ nm ./bof
080495dc d _DYNAMIC
080496b0 d _GLOBAL_OFFSET_TABLE_
0804858c R _IO_stdin_used
w _Jv_RegisterClasses
080495cc d __CTOR_END__
080495c8 d __CTOR_LIST__
080495d4 d __DTOR_END__
080495d0 d __DTOR_LIST__
080485c4 r __FRAME_END__
080495d8 d __JCR_END__
080495d8 d __JCR_LIST__
080496e0 A __bss_start
080496d4 D __data_start
08048540 t __do_global_ctors_aux
080483e0 t __do_global_dtors_aux
080496d8 D __dso_handle
w __gmon_start__
0804853a T __i686.get_pc_thunk.bx
080495c8 d __init_array_end
080495c8 d __init_array_start
080484d0 T __libc_csu_fini
080484e0 T __libc_csu_init
U __libc_start_main@@GLIBC_2.0
080496e0 A _edata
080496e8 A _end
0804856c T _fini
08048588 R _fp_hw
0804830c T _init
080483b0 T _start
080496e4 b completed.5843
08048434 T copier
080496d4 W data_start
0804844e T detourne <--- l' adresse ici
U exit@@GLIBC_2.0
08048410 t frame_dummy
U fwrite@@GLIBC_2.0
08048462 T main
080496dc d p.5841
U puts@@GLIBC_2.0
080496e0 B stderr@@GLIBC_2.0
U strcpy@@GLIBC_2.0

La commande nm permet d' obtenir la liste des symbols.

Les sections .ctors / .dtors

2008-11-22T10:00:00.006+01:00

Quand on lance par exemple la commande :

$ size -A -x /bin/ls
/bin/ls :
section size addr
.interp 0x13 0x8048134
.note.ABI-tag 0x20 0x8048148
.hash 0x32c 0x8048168 <-- table de hash
.gnu.hash 0x5c 0x8048494 <-- table de hash
.dynsym 0x680 0x80484f0 <-- table des symboles
.dynstr 0x477 0x8048b70 <-- table des noms
.gnu.version 0xd0 0x8048fe8
.gnu.version_r 0xc0 0x80490b8
.rel.dyn 0x28 0x8049178 <-- table de relocation
.rel.plt 0x2e0 0x80491a0 <-- table de relocation
.init 0x30 0x8049480
.plt 0x5d0 0x80494b0
.text 0x104bc 0x8049a80 <-- intruction du programme (r)
.fini 0x1c 0x8059f3c
.rodata 0x3e4c 0x8059f60 <-- variables globales et statiques constante (r)
.eh_frame_hdr 0x2c 0x805ddac
.eh_frame 0xcc 0x805ddd8
.ctors 0x8 0x805e000 <-- constructeur
.dtors 0x8 0x805e008 <-- destructeur
.jcr 0x4 0x805e010
.dynamic 0xe8 0x805e014
.got 0x8 0x805e0fc
.got.plt 0x17c 0x805e104
.data 0x110 0x805e280 <-- variables globales et statiques initialisés (r+w)
.bss 0x46c 0x805e3a0 <-- variables globales et statiques non initialisés (r+w)
.gnu_debuglink 0x8 0x0
Total 0x1656a

Bon il y a les sections connue , .text, .data, .rodata etc ... mais pour ceu qui ne ce sont jamais demander ce que sont les sections .ctors et .dtors voici une petite explication .
En C un peu comme dans une class en PHP il y a un constructeur (.ctors) et un destructeur (.dtors).
Donc le constructeur et est appeler automatiquement au début du programme et le destructeur automatiquement à la fin . Voila un bout de code qui présente le fonctionnement :

#include
#include

static void constructeur(void)__attribute__((constructor));
static void destructeur(void)__attribute__((destructor));

int main(int argc, char** argv)
{
        printf("Dans la fonction main()\n");

    return EXIT_SUCCESS;
}
void destructeur(void)
{
        printf("Dans le destructeur\n");
}
void constructeur(void)
{
        printf("Dans le constructeur\n");
}

La génèse

2008-11-21T22:18:00.002+01:00

Au commencement Dieu créa le digit. Il prit ensuite huit digits pour créer un octet.
Or, la mémoire était vide ; seuls les crayons et les gommes couvraient la surface du bureau.
Dieu sépara alors le zéro et le un, et il vit que cela était bon.
Dieu dit : "Que les données soient !" Et il en fut ainsi.

Et Dieu dit : "Plaçons les données dans leurs lieux respectifs."
Et il créa les disquettes, les disques durs et les CD-ROM.
Mais le logiciel n'existait pas encore.
Alors Dieu créa les programmes ; grands et petits.
Dieu leur dit : "Allez et multipliez-vous, remplissez toute la mémoire."

Dieu dit alors : "Je créerai le programmeur. Et le programmeur créera de nouveaux programmes et gouvernera les ordinateurs, les programmes et les données."
Dieu créa le programmeur, et il le mit dans le centre de données.

Et Dieu montra au programmeur le répertoire et lui dit :
"Tu peux utiliser tous les volumes et sous-répertoires, mais n'utilise pas Windows."

Alors Dieu dit : "Il n'est pas bon que le programmeur soit seul."
Il prit un OS du corps du programmeur et il créa une créature qui regardait le programmeur, qui admirait le programmeur, qui aimait les choses faites par le programmeur. Dieu nomma la créature "Utilisateur".
Il laissa le programmeur et l'Utilisateur nus dans le DOS, et il vit que cela était bon.

Mais Bill était plus malin que toutes les créatures de Dieu.
Bill dit à l'utilisateur : "Dieu t'a-t-il vraiment dit de ne pas utiliser tous les programmes ?"

L'utilisateur répondit : "Dieu a dit que nous pouvions utiliser n'importe quel programme et n'importe quel bloc de données, mais il nous a dit de ne pas utiliser Windows parce que nous pourrions mourir."

Et Bill dit à l'utilisateur : "Comment peux-tu parler de quelque chose que tu n'as même pas essayé ? Dès que tu utiliseras Windows tu seras l'égal de Dieu. Tu seras capable de créer tout ce que tu voudras, rien qu'en touchant la souris."

Et l'utilisateur vit que les fruits de Windows étaient meilleurs et plus faciles à utiliser.
Il vit aussi que toute connaissance était inutile, puisque Windows pouvait la remplacer.

Alors l'utilisateur installa Windows dans son ordinateur ; et il dit au programmeur que cela était bon.

Le programmeur commença à chercher de nouveaux pilotes.

Alors Dieu lui dit : "Que cherches-tu ?"
Le programmeur répondit : "Je cherche de nouveaux pilotes, parce que je ne peux pas les trouver dans le DOS."

Dieu lui répondit : "Qui t'a dit que tu avais besoin de nouveaux pilotes, n'aurais-tu pas utilisé Windows par exemple ?"

Le programmeur lui répondit : "C'est Bill qui nous l'a dit."

Alors Dieu dit à Bill :
"Pour ce que tu as fait, tu seras haï par toutes les créatures et l'utilisateur sera toujours mécontent de toi. Pire encore, tu seras condamné à ne jamais vendre que Windows."

Dieu dit encore à l'utilisateur :
"Pour ce que tu as fait, Windows te trompera et consommera toutes tes ressources et tu ne pourras acheter que de mauvais programmes que tu utiliseras dans la douleur et tu seras toujours sous la tutelle du programmeur."

Dieu dit enfin au programmeur :
"Pour n'avoir pas écouté l'utilisateur, tu ne seras jamais heureux. Tous tes programmes seront farcis d'erreurs, tu crouleras sous les fiches de bugs et tu seras condamné à les corriger et à les recorriger jusqu'à la fin des temps."

Dieu les expulsa tous du centre de données et il en bloqua la porte avec un mot de passe.

Puis Dieu se ravisa et se dit qu'il n'était pas juste que tous soient punis par la faute d'un seul.

Alors il créa la pomme pour narguer Bill, et le pingouin pour libérer les hommes.

PS :
La pomme est le logo d’Apple Computer Inc.
Le pingouin est le logo de Linux (logiciel libre)

Les arguments de ligne de commande

2008-11-15T14:22:00.006+01:00

Je me sert très souvent des arguments de la ligne de commande pour ne pas dire toujour ...
Regardons le bout de code ci dessous:

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
printf("adresse de argc: %p\n"
"valeur de argc: %d\n"
"[ valeur gauche de argv: %p | "
"valeur droite de argv : %p ]\n", &argc, argc, &argv, argv);

return EXIT_SUCCESS;

}

Ou argc est égal au nombre d' arguments de la ligne de commande -1 car argv[0] contient le nom du programme donc argc vaut toujour 1, et argv est pointeur sur un tableau de pointeur qui pointe sur l' adresse en mémoire du premier caractère de chaque argument.
Le shema ci-dessous résume la situtation très simplement:

Si je lance le programme au dessus en le compilant avec l' option -g pour pouvoir ensuite le debugger j' obtient ceci :

$ ./a.out arg1 arg2
adresse de argc: 0xbfcd42e0
valeur de argc: 3
[ valeur gauche de argv: 0xbfcd42e4 | valeur droite de argv : 0xbfcd4364 ]

Ici il y a plusieur chose interressante:
1) on remarque que argc et argv ce suivent en mémoire, argc est un entier codé sur 4 octects et argv est un pointeur qui lui aussi est codé sur 4 octets.
Donc 0xbfcd42e4 - 0xbfcd42e0 = 0x4.
0xbfcd42e4 n' est pas l' adresse du premier argument mais bien l' adresse du pointeur qui pointe sur l' adresse 0xbfcd4364 qui est l' adresse du tableau de pointeur.

Attention: Les adresses qu' on voit ici ne sont pas les adresses exact comme elle sont dans la mémoire physique de la machine, ce sont des adresses virtuelles, un mécanisme de translation de ces adresses virtuelles en adresse physique est mis en place par le système et d' autre par, par ce que l' on apel la MMU (Memory Management Unit) j' èspère pouvoir faire un article la dessus.
Sans rentrer dans les détails quand un programme tourne il dispose d' un espace d' adressage a lui tout seul, avec son code, ses données, et plein d' autre informations, en théorie il est donc impossible qu' un autre programme puisse écrire quoi que ce soit dans l' espace d' adressage d' un autre.

Revenons en à nos moutons et allons chercher dans cette espace d' adressage les données ou elles ce trouvent avec gdb :

$ gdb -q ./a.out
1 . (gdb) b main
2 . Breakpoint 1 at 0x8048385: file test.c, line 7.
3 . (gdb) r arg1 arg2
4 . Starting program: /home/napoleon/a.out arg1 arg2
5 .
6 . Breakpoint 1, main (argc=3, argv=0xbfd9abe4) at test.c:7
7 . 7 printf("adresse de argc: %p\n"
8 . (gdb) p &argc
9 . $1 = (int *) 0xbfd9ab60
10 . (gdb) p &argv
11 . $2 = (char ***) 0xbfd9ab64
12 . (gdb) p argv
13 . $3 = (char **) 0xbfd9abe4
14 . (gdb) x/4wx $3
15 . 0xbfd9abe4: 0xbfd9c790 0xbfd9c7a5 0xbfd9c7aa 0x00000000
16 . (gdb) x/s 0xbfd9c790
17 . 0xbfd9c790: "/home/napoleon/a.out"
18 . (gdb) x/s 0xbfd9c7a5
19 . 0xbfd9c7a5: "arg1"
20 . (gdb) x/s 0xbfd9c7aa
21 . 0xbfd9c7aa: "arg2"

On voit que les adresses on changer ce qui est normal, mais le principe est le même.

A la ligne 8 j' affiche l' adresse de argc, puis a la ligne 10 j' affiche l' adresse du pointeur argv, encore une fois on voit bien qu' il ce suivent.
a la ligne 12 j' affiche l' adresse pointé par argv avec la commande 'p' qui est le raccourci de 'print' ce qui a pour effet de placer le résultat de la commande dans la variable $3 (ligne 13).
Juste après a la ligne 14 j' affiche un morceau de la mémoire avec la commande 'x'. ici je fait suivre x/ par 4wx ce qui veut dire affiche moi 4 mots mémoire en hexadécimal de l' adresse contenu dans la variable $3.
Et la a la ligne 15 j' obtient l' adresse du premier octet de chacun de mes 3 arguments + le NULL qui doit obligatoirement terminer le tableau, la aussi on remarque facilement que les trois arguments ce suivent, les lignes suivante j' ai plus qu' a afficher la chaine contenu a partir de chaque adresse, avec la commande x/s ou le 's' veut dire string.

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

int main(int argc, char **argv)
{
int i = 1;
while(i < argc)
{
printf("argv[%d] = [ %s ] a l' adresse %p\n", i, argv[i], argv[i]);
i++;
}
return EXIT_SUCCESS;
}

$ ./a.out arg1 arg2 arg3
argv[1] = [ arg1 ] a l' adresse 0xbfb7e76b
argv[2] = [ arg2 ] a l' adresse 0xbfb7e770
argv[3] = [ arg3 ] a l' adresse 0xbfb7e775

En réalité on ne va pas analyser les options de la ligne de commande de cette façon qui est lourde et chiante a codé (imaginer le nombre de comparaison a faire etc ...) , pour cela il y a la fonction getopt() défini dans /usr/include/unistd.h et getopt.h pour les options long.

Sans commentaire

2008-11-07T12:24:00.005+01:00

Défois on tombe la dessus ...

installer VLC 0.9.3 sur ubuntu hardy 8.04

2008-11-01T08:50:00.003+01:00

Pour ceux qui n' on pas voulu passer à intrepid voici la solution pour avoir un jolie vlc:
Avant tout supprimer la version déja installer sur votre machine.
Dans votre sources.lst rajouter cette ligne:

deb http://ppa.launchpad.net/c-korn/ubuntu hardy main

Puis on recharge:

sudo apt-get update

et on installe:

sudo apt-get install vlc

Deux petit programmes utiles

2008-10-24T17:44:00.006+02:00

Hello,
Bon voila deux petit programmes pour encore une fois simplifié la vie du programmeur.
le premier est ascii mais un screenshot vaut meiux que mille mots :

C' est tout simplement la table ascii mais avec des options comme -x pour hexadecimal -o octale -d decimal c' est très pratique.
Et un deuxieme qui ma vraiment supris c' est meld, enfaite meld compare des fichiers ou des répertoires, la aussi un screenshot sera plus parlant :

J' ai deux fichiers avec quelque différences et meld les trouvent et les indiques. C' est vraiment un exemple basique ...
Les deux sont dans les dépots pour les installer:

sudo apt-get install meld ascii

chiffrer et dechiffrer facilement avec ccrypt

2008-10-23T09:37:00.004+02:00

Défois on a pas envie de ce prendre la courgette avec GPG ou ce genre de logiciel, admettons que j' ai un fichier que je veux chiffrer alors la solution s' apel ccrypt.
Pour l' installer:

sudo apt-get install ccrypt

voila maintenant il y a deux commande à retenir.
pour chiffrer le fichier:

ccrypt -e votreFichier

un mot de passe va vous être demander.
et voila votre fichier est chiffrer on le reconnais car il portera l' extension .cpt
maintenant pour le déchiffrer:

ccrypt -d votreFichier.cpt

on vous demande votre mot de passe et hop ! le fichier est déchiffrer !

La synthaxe intel dans GDB gnu debugger

2008-10-19T12:42:00.006+02:00

Enfaite je ne m' etais jamais interresser au option de configuration de GDB, donc en cherchant un peu j' ai trouver comment obtenir des output en synthaxe INTEL.

pour simplement placer l' output assembleur (intel) dans un fichier on peut faire comme ça:

~$ gcc -S -masm=intel essai.c

napol3on@s4t4n:~$ cat essai.s
.file "essai.c"
.intel_syntax noprefix
.section .rodata
.LC0:
.string "hello world"
.text
.globl main
.type main, @function
main:
lea ecx, [esp+4]
and esp, -16
push DWORD PTR [ecx-4]
push ebp
mov ebp, esp
push ecx
sub esp, 4
mov DWORD PTR [esp], OFFSET FLAT:.LC0
call printf
mov eax, 0
add esp, 4
pop ecx
pop ebp
lea esp, [ecx-4]
ret
.size main, .-main
.ident "GCC: (Ubuntu 4.3.2-1ubuntu10) 4.3.2"
.section .note.GNU-stack,"",@progbits

Mais le mieux est que cette option soit constante.
Donc pour configurer GDB il faut créer un fichier .gdbinit dans le /home et c' est ici que l' on place les commandes qu' il va lire au démarrage.
donc la commande a placer dans ce fichier est :
set disassembly-flavor intel
Vous pouvez en apprendre plus ici :
http://www.ibm.com/developerworks/aix/library/au-gdb.html

Edit: puisque l' on est dans la synthaxe intel il serais bien de mettre objdump aussi avec cette synthaxe donc pour avoir une output en synthaxe intel sur objdump il faut rajouter:

objdump -M intel ./executable

sur la ligne de commande.

Migration vers ubuntu 8.10 Intrepid

2008-10-18T21:46:00.015+02:00

Hello,

Et oui je cette apres midi je me suis lancer dans mise a jour vers ubuntu 8.10 Intrepid, apres quelque renseignement sur les bog connus je n' ai rien trouver de vraiment chiant, seul probleme dès le debut de la mise a jour, il m' informe que le pilote nvidia n' est plus disponible pour ma carte graphique (gforce4 un peu de retard je sais mais bon c' est deja un point faible ..) apres quelque recherche il ce trouve que deux des pilotes nvidia ne seront plus dispo, et un de chez ati. (a suivre)

Sinon quelque petit changement à noter comme:
le passage a the gimp 2.6

navigation avec onglets dans nautilus. (screenshot ci-dessous)

Et enfin la possibilité de faire un OS bootable a partir d' une clé USB (screenshot ci-dessous)

le nouveau VLC directement inclus ( ouf depuis le temp )

Et un petit truc que je viens de remarquer c' est system cleaner (faire le menage quoi)

Quelque theme en plus.

Edit: j' avais appris que l' on disposais d' un repertoire crypter et invisible au yeux des autres $USER donc j' ai trouver comment l' activer.

il faut installer ce paquet:

ecryptfs-utils

et pour l' activer taper:

ecryptfs-setup-private

Voila voila ! dès que j' aurais fais le tour je completerais.

Installer code::blocks en 2 minutes sur ubuntu

2008-09-25T05:13:00.004+02:00

Me revoila ! oula j' arrête pas en ce moment ... bon je vais vous présenter la façon la plus simple d' installer code::blocks sur votre ubuntu, simple mais elle ne ce mettra pas a jour automatiquement mais pour y remèdier j' écrirais un petit script bash de mise a jour que je posterais plus tard.

Donc on commence par télécharger les paquets :
Pour linux-32bit:
http://download.berlios.de/codeblocks/codeblocks_8.02-0ubuntu1.deb.tar.gz
Pour linux-64bit:
http://prdownload.berlios.de/codeblocks/codeblocks-8.02-amd64.tar.gz

placer le tar.gz dans votre home par exemple, puis on ouvre une console et on décompresse :

tar xvfz code-blocks-xxxxxx.tar.gz

après vous allez vous retrouvez avec plusieurs paquets .deb

pour tout installer facilement on tape :

dpkg -i *.deb

et voila vous avez installer code::blocks en moins de 2 minutes !

structure utsname,obtenir des informations sur votre machine.

2008-09-23T16:23:00.006+02:00

Hello,
je voulais mettre ce bout de code, car souvent sur les forums la question est poser, donc voila le code:

#include <stdio.h>
#include <stdlib.h>
#include <sys/utsname.h>

int main()
{
struct utsname info;

if(uname(&info) == -1)
{
        perror("uname ");
        exit(EXIT_FAILURE);
}
else
{
        printf("%s\n", info.nodename);
        printf("%s\n", info.sysname);
        printf("%s\n", info.machine);
        printf("%s\n", info.release);
        printf("%s\n", info.version);
}

return EXIT_SUCCESS;
}

équivalent a un [ uname --all ].

Sortie de la version VLC 0.9.2

2008-09-23T16:10:00.002+02:00

Le très célèbre lecteur multimédia VLC est maintenant disponible en version 0.9.2,
au menu des nouvelles fonctionnalités :
- Une nouvelle interface sous Linux et Windows
- Amélioration de la gestion de la playlist et des librairies multimédias
- La prise en charge de nouveaux codecs et de filtres vidéo et audio.

Site officiel : http://www.videolan.org/vlc/

Voici une présentation vidéo de VLC 0.9.2, ou l'on peut voir la nouvelle interface de VLC sous Windows Vista et sous Linux (GNOME et KDE 4) : http://www.youtube.com/watch?v=zVhk7Kq1rEU

Pour plus d'informations sur cette nouvelle version majeur de vlc : http://wiki.videolan.org/What_is_cool_in_0.9

CodeWeavers propose Google Chrome pour Mac et Linux

2008-09-20T18:00:00.000+02:00

Quinze jours après la sortie pour les seuls PC sous Windows (XP et Vista) du navigateur web open-source de Google, Chrome, l'éditeur CodeWeavers se propose de le rendre officieusement disponible sur deux autres plateformes : Mac et Linux. A terme, c'est Google qui va en faire de même, prévoyant effectivement de proposer Chrome en version Mac et Linux en plus de Windows.

Connu principalement pour son logiciel "CrossOver" permettant aux utilisateurs de Mac et Linux d'exécuter certains programmes sous Windows (dont Microsoft Office ou Internet Explorer), cet éditeur américain s'est donc attaqué au navigateur web de Google pour le rendre compatible avec de nouvelles plateformes.

Mais plutôt que d'exploiter la dernière version de Chrome disponible, CodeWeavers a préféré utiliser une version légèrement différente basée sur le moteur d'affichage open-source du navigateur baptisé "Chromium" qui possède à cette heure un rendu légèrement différent de son équivalent pour PC, encore en version bêta. Il ne faudra donc pas s'attendre à des miracles avec cette version Mac et Linux officieuse de Chrome, dépourvue de quelques fonctionnalités dont la mise à jour automatique du programme.

D'ailleurs Jeremy White, le patron de CodeWeavers, précise qu'il s'agit d'un défi technique montrant la viabilité de sa solution exploitant entre autres le logiciel Wine (Wine Is Not an Emulator) plutôt qu'une réelle solution permettant d'utiliser pleinement Chrome. Ceci explique sans doute pourquoi "CrossOver Chromium" est relativement lent et n'exploite pas encore le Flash. Le logiciel est téléchargeable gratuitement à cette adresse et compatible avec Mac OS X 10.4 (ou ultérieur) et différentes distributions GNU/Linux dont Debian, Red Hat, Mandriva, Suse ou Ubuntu.

Lancé le 2 septembre dernier, Google Chrome représente actuellement selon Net Applications moins de 1% du marché mondial des navigateurs web. Selon Nielsen cette fois, Chrome aurait été téléchargé aux Etats-Unis la première semaine suivant son lancement pas moins de 2 millions de fois. Pas de quoi rivaliser avec les 8 millions de téléchargements de Firefox 3 en seule journée (le jour de son lancement le 18 juin dernier) mais cela confirme l'engouement suscité autour de la première version bêta de Chrome.

Les pointeurs en C

2008-09-09T16:17:00.014+02:00

Les pointeurs !! c' est quelque chose qui fait fuire beaucoup de débutant en langage C et pourtant c' est simple comme bonjour... quand on a compris le principe.
C' est ce que je vais essayer de faire avec des exemples pratique, donc pas de théorie ou très peu.
Alors un pointeur est une variable qui peut contenir l' adresse d' une autre variable (du même type).

en faisant *pointeur j' obtiens la valeur de l' adresse pointer par pointeur.
en faisant &pointeur j' obtient l' adresse de pointeur.
c' est comme pour une variable normal.

Mais vérifions tout de suite ce que j' avance :

char *p;
printf("[ adresse de p: %p adresse pointer par p: %p ]\n", &p, p);

L' execution de ce bout de code me donne :

[ adresse de p: 0xbffb5d28 adresse pointer par p: 0xbffb5d48 ]

La vous allez me dire mais le pointeur ne pointe sur rien du tout et pourtant il contient une adresse c' est normal ?
Oui en effet, je n' ai pas initialiser le pointeur a NULL, donc il pointe n' importe ou en mémoire, donc voila l' importance d' initialiser ses pointeur a NULL.

On recommence de la bonne façon cette fois :

char *p = NULL;
printf("[ adresse de p: %p adresse pointer par p: %p ]\n", &p, p);

L' execution de ce bout de code me donne :

[ adresse de p: 0xbffa9d28 adresse pointer par p: (nil) ]

La ok il pointe nul part et est bien initialiser a NULL.

Maintenant on sais initialiser comme il faut un pointeur mais on sais autre chose, on sais que si on veut que notre pointeur pointe sur l' adresse d' une variable on va devoir remplacer (nil) qui est rien d autre qu une case pour stocker une adresse, par l' adresse de la variable sur laquelle on veut pointer non ?

donc c' est simple :

char caractere = 'B';
char *p = NULL;

printf("[ adresse de caractere : %p | contenu de caractere: %c ]\n\n", &caractere, caractere);

printf("[ adresse de p : %p -> adresse pointer par p: %p ]\n\n", &p, p);

puts("Maintenant on remplace (nil) par l adresse de caractere\n");

p = &caractere;

printf("[ adresse de p : %p -> adresse pointer par p: %p ]\n", &p, p);

printf("[ adresse de p: %p | contenu de l' adresse pointer par p: %c ]\n", &p, *p);

L' execution donne:

[ adresse de caractere : 0xbfcd4253 | contenu de caractere: B ]

[ adresse de p : 0xbfcd424c -> adresse pointer par p: (nil) ]

Maintenant on remplace (nil) par l adresse de caractere

[ adresse de p : 0xbfcd424c -> adresse pointer par p: 0xbfcd4253 ]

[ adresse de p: 0xbfcd424c | contenu de l' adresse pointer par p: B ]

Vous voyez que les adresses en rouge sont les mêmes, donc on bien réussi a faire pointer q sur l adresse de caractere.J' aurais pu faire l impasse sur l adresse du pointeur (qui est toujour la meme elle ne change pas) mais c' est justement pour bien comprendre qu' un pointeur est exactement comme une variable sauf que a la place de contenir une valeur, elle contient l adresse d' une valeur.

On va appronfondir cette histoire de signe afin de bien comprendre avec un exemple simple:

rapel :
en faisant *pointeur j' obtiens la valeur de l' adresse pointer par pointeur.
en faisant &pointeur j' obtient l' adresse de pointeur.
donc voici un bout de code tout a fait valide et qui va permettre de comprendre encore mieux cette histoire de signe.

char caractere = 'B';

printf("caractere: %c\n", caractere);

*(&caractere) = 'C';

printf("caractere: %c\n", *(&caractere) );

et oui *(&caractere) est bien equivalent a caractere.

met moi la lettre C dans le contenu *() de l' adresse de &caractere.

Pour finir voila un bout de code que vous ne devriez plus avoir aucun mal a comprendre, j' ai mis des couleurs pour aider:

char caractere = 'B';
char *p = NULL;
char **p_p = NULL;
p = &caractere;
p_p = &p;

printf("[ adresse de caractere: %p | valeur: %c ]\n\n", &caractere, caractere);
printf("[ adresse de p: %p | adresse pointer par p: %p ]\n\n", &p, p);
printf("[ adresse de p_p: %p | adresse pointer par p_p: %p ]\n\n", &p_p, p_p);

printf("valeur de caractere : %c\n", caractere);
printf("valeur de p : %c\n", *p);
printf("valeur de p_p : %c\n", **p_p);

L' execution de ce code donne:

[ adresse de caractere: 0xbf94aed3 | valeur: B ]

[ adresse de p: 0xbf94aecc | adresse pointer par p: 0xbf94aed3 ]

[ adresse de p_p: 0xbf94aec8 | adresse pointer par p_p: 0xbf94aecc ]

valeur de caractere : B
valeur de p : B
valeur de p_p : B

Plusieur consoles dans la meme fenêtre avec Terminator

2008-09-02T15:33:00.005+02:00

Yop, ces derniers temp je me suis mis a tester un peu les petits logiciels pas trop connu sous ubuntu et j' ai découvert Terminator, Terminator est enfaite une simple console, mais qui offre quelque avantages par rapport celle de gnome par défaut.
On peut par exemple diviser la fenêtre en plusieur, ou enlever les bordures, voila un petit screen:

ou avec l' option -b enlever les bordures :

voila pour le reste c est exactement pareil alors pourquoi s' en privé !!!

john the ripper pour déchiffrer les MD5

2008-08-15T21:20:00.009+02:00

Voila les commande pour installer john avec le patch sous linux:

> mkdir john
> cd john
> wget http://www.openwall.com/john/f/john-1.7.2.tar.bz2
> bunzip2 john-1.7.2.tar.bz2 > tar -xvf john-1.7.2.tar

> cd john-1.7.2
> wget ftp://ftp.openwall.com/pub/projects/john/contrib/john-1.7-rawmd5-ipb2-4.diff.gz

> gzip -d john-1.7-rawmd5-ipb2-4.diff.gz
> patch -p1 < john-1.7-rawmd5-ipb2-4.diff

> cd src
> make
> make clean linux-x86-sse2
> cd ../run/

A partir de la faite le test:

./john -test

et pour la lancer sur un hash:

./john --format=raw-MD5 t_hash

ou t_hash est le fichier avec le hash sous cette forme:

toto:6f3e68a2a11cb9bf3ef40994a59e6b58

Ps: veillez a avoir bien installer patch avant.

Morsegen fallait y penser

2008-08-15T19:53:00.010+02:00

En scrutant les bas fond d' internet je viens de tomber sur un petit Tool assez original coder par luigi Auriemma, il prend simplement un fichier texte en argument et vous donne la conversion en morse vous savez le langage pour envoyer des SOS c' est très amusant.
Par exemple je crée un fichier exemple.txt et j' écrit "hello world" à l' interieur:

napoleon@s4t4n:~/Bureau/morsegen$ echo "hello world" > exemple.txt

je lance le petit tool:

napoleon@s4t4n:~/Bureau/morsegen$ ./morsegen exemple.txt
Morse generator 0.2
by Luigi Auriemma
e-mail: aluigi@autistici.org
web: aluigi.org

.... . ._.. ._.. ___ .__ ___ ._. ._.. _..

En cadeaux je vous met l' alphabet morse pour comparer :

Vous le trouverez les sources ici a morsgen dans le zip ya le .exe pour window(pas essayer) et le morsegen.c a compiler.
gcc -c morsegen.c
gcc -o morsegen morsgen.o
Merci monsieur luigi très amusant !!

Au coeur des fonctions C, dissection d' une fonction

2008-08-15T16:37:00.011+02:00

Qu' est-ce qui ce passe avant, pendant, et après l' apel d' une fonction C ? C' est ce que je vais décrire pas à pas.Pour pouvoir suivre cette article il est indispensable de connaitre, le fonctionnement d' une stack (pile), et avoir les bases du language assembleur, syntaxe intel, et AT&T pour les sortie avec GDB, une connaissance aussi du debugger GDB ne sera pas de trop, et biensur une bonne maitrise du langage C, bien que ce soit juste les fonctions qui nous intéressent ici.

Avant de commencer je vais quand même rappeler brièvement quelques points fondamentaux.

La mémoire d' un ordinateur est adressée par mot (word) de 4 octets (32bit) et débute à 0x0000000 et fini à 0xfffffff.
Cette espace de mémoire est divisé en deux zones :

1) L 'espace user de 0x00000000 à 0xbfffffff
2) L 'espace kernel de 0xc0000000 à 0xffffffff

Quand un processus est lancer , il est mappé en mémoire et dispose d' un espace de mémoire indépendant de tout les autres processus.(En gros je passe les détails)
Une fois charger en mémoire le processus est divisé en plusieur section:
.text la ou est placer le code du programme
.data la ou sont placer les données initialisées ou non.
.bss la ou sont placer les données globales non initialisées

En plus il y a la stack (pile) qui sert de stockage pour y placer des données temporaire, les variables local d' une fonction seront par exemple placer sur la pile.Maintenant essayons de comprendre le fonctionnement de cette stack.
La stack peut être vue comme une jeux de carte, elle grandit vers les adresses basses, pour revenir au jeux de carte c 'est comme si on ajoutais des cartes par dessous, on appelera %ebp la base de la pile donc le sommet de notre jeux de carte, et on appelera toujour %esp le pointeur vers la dernière valeur(carte) qu' on a ajouter.


adresse haute  ------  %ebp  ( haut du jeux de carte )
          ------
          ------
adresse basse  ------   <-- %esp  ( dernière carte ajouter )

l' opcode push ajoute une carte, et pop retire une carte, ce qu' il faut bien retenir surtout, c' est que cette pile marche selon le modele LIFO "last in first out" c' est à dire que la dernière donnée(carte) ajouter sera toujour le première à sortir.
Enfaite on ne verra pas ces 2 instructions ici,car gdb utilise la syntax AT&T qui est je l' avoue franchement plus chiante a lire que celle d' intel, mais bon, on a rien sans rien donc on apprend les deux et on s' écrase...

Voila c' étais bref mais le but n' est pas de faire un cour sur l' assembleur et la mémoire d' un ordinateur.

Bon pour tout le reste de cette article je me baserais uniquement sur cette exemple de programme C:

#include <stdio.h>

int addition(int parametre1, int parametre2)
{
int res = 0;
res = parametre1 + parametre2;
printf("%d", res);
}

int main()
{
addition(5, 6);
return 0;
}

Donc maintenant on compile et lance avec celui qui va nous permettre d' analyser le programme [ GDB ]:

Afin d' avoir des valeurs qui tombe juste j' ai compiler avec l' option -mpreferred-stack-boundary=2 et -g bien évidement pour le debug.

napoleon@s4t4n:~$ gdb ./exemple
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...
(gdb) disass main
Dump of assembler code for function main:
0x0804839f <main+0>: push %ebp
0x080483a0 <main+1>: mov %esp,%ebp
0x080483a2 <main+3>: sub $0x8,%esp
0x080483a5 <main+6>: movl $0x6,0x4(%esp)
0x080483ad <main+14>: movl $0x5,(%esp)
0x080483b4 <main+21>: call 0x8048374 <addition>
0x080483b9 <main+26>: mov $0x0,%eax
0x080483be <main+31>: leave
0x080483bf <main+32>: ret
End of assembler dump.
(gdb) disass addition
Dump of assembler code for function addition:
0x08048374 <addition+0>: push %ebp
0x08048375 <addition+1>: mov %esp,%ebp
0x08048377 <addition+3>: sub $0xc,%esp
0x0804837a <addition+6>: movl $0x0,-0x4(%ebp)
0x08048381 <addition+13>: mov 0xc(%ebp),%eax
0x08048384 <addition+16>: add 0x8(%ebp),%eax
0x08048387 <addition+19>: mov %eax,-0x4(%ebp)
0x0804838a <addition+22>: mov -0x4(%ebp),%eax
0x0804838d <addition+25>: mov %eax,0x4(%esp)
0x08048391 <addition+29>: movl $0x8048480,(%esp)
0x08048398 <addition+36>: call 0x80482d8 <printf@plt>
0x0804839d <addition+41>: leave
0x0804839e <addition+42>: ret
End of assembler dump.
(gdb)

Commencons par regarder ce qui ce passe en main+6 car c' est ici que débute notre fonction.Enfaite c' est pas le début mais la préparation de la fonction, a ce moment elle n' a pas encore été appelé.
movl $0x6,0x4(%esp)
Cette instruction peut être traduite par : Ajoute la valeur 0x6 (6 en décimal) a +4 de l' adresse pointé par %esp.En syntaxe Intel on pourrais faire push dword 0x6
Et oui ! %esp contient une adresse.
Et cette valeur 6 est bien le deuxième argument de notre fonction addition, enfaite il empile les valeurs en sens inverse ce qui ce vérifie encore en main+14 movl $0x5,(%esp) ou il empile le premier argument.

En main+21 on retrouve un call:
call 0x8048374 <addition>
call est un saut inconditionnel c' est à dire que lorsque qu' il arrive ici il saute sans aucune condition a l' adresse 0x8048374 qui est bien l' adresse de notre fonction addition:
0x08048374 <addition+0>: push %ebp
Pendant cette apel il va ce passer une opération implicite, il va sauvegarder l' adresse de retour de la fonction, donc %eip, puisque je rapel que %eip pointe toujour sur l' adresse de la prochaine instruction à executer.

Une fois nos argument, et l' adresse de retour sauvegarder il va ce passer ce qu' on apel le prologue de la fonction:
0x08048374 <addition+0>: push %ebp
0x08048375 <addition+1>: mov %esp,%ebp

En addition+0 il prepare le nouvel environnement pour la fonction addition,il sauvegarde %ebp sur la pile, puis en addition+1 il met %esp dans %ebp donc a ce moment la %ebp = %esp

Après il va reserver de la place pour les variables locales de la fonction.Il décremente %esp de 12(0xc), en gros il soustrait 12 a %esp:
sub $0xc,%esp
Pourquoi 12 ? Un peu de calcul, nous avons 3 variables de type (int) qui sont des entiers, un entier en général prend 4 octets, donc 3 x 4 = 12 (0xc), par contre si on aurais un char, donc 1 octets il aurais quand même reserver 0x4 puisque il réserve que des multiples de 4, si on on aurais un chaine de 6 octets il aurais réserver 0x8 (a ne pas oublier).

Ensuite passons en addition+13 et addition+14
mov 0xc(%ebp),%eax
add 0x8(%ebp),%eax
Il place la valeur qui est en %ebp+12 dans %eax, puis en addition+16 il additione la valeur qui est placer en %ebp+8 avec la valeur de %eax.

Regardond de plus près ce que contient %ebp+12, %ebp+8 à ce moment la:

(gdb) b addition
Breakpoint 1 at 0x804837a: file exemple.c, line 5.
(gdb) r
Starting program: /home/napoleon/exemple

Breakpoint 1, addition (parametre1=5, parametre2=6) at exemple.c:5
5 int res = 0;
(gdb) x/bc $ebp+12
0xbf8535d4: 6 '\006'
(gdb) x/bc $ebp+8
0xbf8535d0: 5 '\005'
(gdb)

La tout devient plus clair !!
mov 0xc(%ebp),%eax place moi la valeur 0x6(6 en déacimal) dans %eax.
add 0x8(%ebp),%eax Additionne moi la valeur placer dans %ebp+8 qui est donc 0x5 (5 en décimal) avec %eax.
ce qui donne bien l' addition qu' on lui a demander de faire 5+6 dans la fonction.

Vérifions maintenant ce que contient %eax à la ligne 7:

Breakpoint 2 at 0x804838a: file exemple.c, line 7.
(gdb) c
Continuing.

Breakpoint 2, addition (parametre1=5, parametre2=6) at exemple.c:7
7 printf("%d", res);
(gdb) p $eax
$1 = 11
(gdb)

Il est donc clair que %eax sers a manipuler des données, beaucoup d' opération passe par lui, entre autre ici il contient le résultat de notre opération soit (11).

En dernier il faut remmettre l' état de la pile comme elle était avant l' apel de la fonction, ce qui ce fait avec ces deux instructions:
leave
ret
Enfaite leave est équivalent à:
mov ebp,esp
pop ebp

Donc %ebp et %esp reviennent ou ils étaient avant l' apel de la fonction.
Puis viens le
ret
Qui a pour effet de dépiler %eip qui contient l' adresse de retour. ainsi le programme reprendra son execution la ou il l' avait interrompu.
On verra dans un autre article qu' il est possible de modifier cette adresse de retour afin que le programme saute ou on lui dit de sauter, c' est le principe des buffer overflow et d' ailleur cette article est je pense une bonne mise en jambe pour ça.
Voilà on a vue en détail avant, pendant, et après l' apel d' une fonction.

comprendre les injections SQL

2008-08-13T20:04:00.023+02:00

$connexion = mysql_connect('localhost','user','motDePasse');

mysql_select_db('injection');

if(isset($pseudo) AND isset($pass))
{
$req = "SELECT pseudo,password FROM `essai` WHERE pseudo='$pseudo' AND password='$pass'";

$res = mysql_query($req);

while($x = mysql_fetch_array($res))
{
echo $x['pseudo']. ' ' .$x['password'].'
'; } }

Donc le script PHP attend un pseudo et un mot de passe, transmis par le formulaire via la method POST, une fois qu' il a le pseudo et le mot de passe il envoie la requête a la base de donné qui elle cherche si dans la table essai si il ce trouve un pseudo et un mot de passe qui correspond a ce que l' utilisateur à rentrer. si elle trouve une correspondance elle l' affiche sinon elle ne renvoi rien du tout.
Donc si l utilisateur est (alain) et a pour mot de passe (pofigljfh) la requête deviendra (en vert c' est ce que rentre l' utilisateur).

SELECT pseudo,password FROM `essai` WHERE pseudo='alain' AND password='pofigljfh'

Et l utilisateur sera authentifié car il y a bien une correspondance dans la table.
Maintenant en sachant que le script ne filtre pas les caractère spéciaux il est facile de déformer la requête.
Regardons cette exemple (en vert c' est ce que rentre l' utilisateur):

SELECT pseudo,password FROM `essai` WHERE pseudo='alain' OR '1'='1' AND password='chaineAuHazard' OR '1'='1'

Le truc c' est que la condition sera toujour vrai puisque , on demande d afficher les champs ou (1 est égal à 1) donc bête et discipliner le programme renverra tout les enregistrements de la base, avec le pseudo et mot de passe de l' administrateur.Voici quelque autre exemple ou l' egalité est toujours vrai:

WHERE pseudo='alain' OR 'a'='a' AND password='chaineAuHazard' OR 'a'='a'
WHERE pseudo='alain' OR 'a'='a' AND password='bloup' OR 'b' between 'a' AND 'c'

Le dernier exemple est aussi valide et oui car on demande les champs ou b est entre a et c.
Aller pour la forme un dernier, on sais que les commentaires en SQL commencent par un # c' est a dire que tout ce qui ce trouve après sera ignorer.Ici on va imaginer que l on connais juste le pseudo de l administrateur du site.
Mise en pratique:

SELECT pseudo,password FROM `essai` WHERE pseudo='admin'#' AND password='bloup'
Donc ici pas besoin du mot de passe puisque le password est mis en commentaire.Donc voila quelque exemple parmis tant d' autre, mais comment sécurisé tous ca?
Avec la fonction mysql_escape_string() ou mysql_real_escape_string() par exemple.
Donc notre script securisé devient:
SELECT pseudo,password FROM `essai` WHERE pseudo='mysql_escape_string($pseudo)' AND password='mysql_escape_string($pass)'
Je ne vais pas passer en revue tout les types d' injection car chaque cas est différent mais les base sont là.

::: conseil

Je ne peut que vous conseiller de mettre séverement à l' épreuve votre site avant de le publier, il ne faut pas oublier que le but premier d' un hacker est de faire planter votre script afin qu' il génère une erreur, vous allez me dire pourquoi ?
C' est tout simplement pour obtenir des informations sur vos bases,vos tables, les noms des champs, la version de mysql etc ...
Protèger chaque variable quand vous le pouvez avec une fonction adapté, vous avez le choix, mysql et PHP disposent de beaucoup de fonctions pour vérifier les types des donnés, échappé les caractère spéciaux etc ...
Rentrer des caractères dans l' url comme %22 %23 %27 %25 %24 %5E %3B %2C %3A %21 %3C %3E et analyser le comportement du script, il ne doit y avoir aucun message d' erreur qui s' affiche, n' oublier pas qu' il est possible de cacher les messages d' erreur avec un @ placer devant le nom d' une fonction ou d' une instruction.D' autre par ne laisser pas trainer des fichiers inutile.
Faite tout ce qui est possible et imaginable pour faire planter votre script !! et corriger les erreurs.

Le padding de GCC qui énerve ..

2008-08-10T07:52:00.000+02:00

Je suis assez enerver de voir que gcc n' en fait qu' a sa tête,a partir de la version 3.x il rajoute un padding a chaque fois, un exemple :

napoleon@s4t4n:~$cat exemple.c
int adi()
{
int a = 5;
}
int main()
{
return 0;
}

napoleon@s4t4n:~$ gcc -c -g exemple.c
napoleon@s4t4n:~$ gcc -o exemple exemple.o
napoleon@s4t4n:~$ gcc -S exemple.c
napoleon@s4t4n:~$ gdb ./exemple
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...
(gdb) disass adi
Dump of assembler code for function adi:
0x08048344 : push %ebp
0x08048345 : mov %esp,%ebp
0x08048347 : sub $0x10,%esp
0x0804834a : movl $0x5,-0x4(%ebp)
0x08048351 : leave
0x08048352 : ret
End of assembler dump.
(gdb)

Comme on le voit a l' adresse 0x08048347 il soustrait 0x10 (16 en decimal) octets a esp, alors qu' il ne devrait en soustraire que 0x4 (4 en decimal) puisque chez moi un int prend 4 octets en mémoire.

Donc après une petite recherche sur google j' ai trouver comment éviter cela, la solution est de compiler avec -mpreferred-stack-boundary=2

napoleon@s4t4n:~$ gcc -c -g -mpreferred-stack-boundary=2 exemple.c
napoleon@s4t4n:~$ gcc -o exemple exemple.o
napoleon@s4t4n:~$ gcc -S exemple.c
napoleon@s4t4n:~$ gdb ./exemple
GNU gdb 6.8-debian
Copyright (C) 2008 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law. Type "show copying"
and "show warranty" for details.
This GDB was configured as "i486-linux-gnu"...
(gdb) disass adi
Dump of assembler code for function adi:
0x08048344 : push %ebp
0x08048345 : mov %esp,%ebp
0x08048347 : sub $0x4,%esp
0x0804834a : movl $0x5,-0x4(%ebp)
0x08048351 : leave
0x08048352 : ret
End of assembler dump.

Et la miracle il nous a bien reservé les 4 octets normalement ! Que demande le peuple ? hien ??

Obfuscation de code en javascript

2008-08-08T17:43:00.012+02:00

Pour la petite hisoire :

Napol3on ce balladait dans le rayon presse du centre commercial Auchan près de chez lui, soudain il tombe sur le dernier numéro du mag haking, un chapitre parle justement de l' obfuscation de code en javascript, après avoir rapidement jetter un coup d' oeil dessus, je me suis dit,tiens je vais me coder un petit truc équivalent en rentrant !....Et voila le resultat :

Technique de chiffrement simple :

Ce script est très simple, on lui donne le script malicieux dans src_enc avec a chaque fois la prochaine lettre dans l alphabet, ce qui donne simplement : alert(''); pour l ' exemple, après on parcourt la chaine avec charCodeAt() qui renvoi le code ascii de chaque caractere de la chaine - 1 et le stock dans 'as', il reste simplement a faire l' inverse avec String.fromCharCode() qui renvoie la valeur du code ascii de chaque caractère, et en dernier avec la fonction eval() on fait executer le code.

Rats : Rough Auditing Tool Sécurity

2008-08-08T09:25:00.015+02:00

RATS est un logiciel d' audit de code, a tester :

Explication des options :
# -d : spécifier une base de donnée de vulnérabilité alternative
# -h : affiche l'aide d'utilisation
# -i : rapporte les fonctions qui autorise des entrées externes
# -l : force le langage à auditer
# -r : inclus les références qui ne sont pas des appels de fonctions
# -w <1,2,3> : niveau d'alerte (par défault 2)
# -x : ne charge pas la base de donnée des vulnérabilités par défaul
# -R : n'autorise pas l'analyse récursive des fichiers audités
# --xml : rapport d'audit au format XML
# --html : rapport d'audit au format HTML
# --follow-symlinks : suit les liens symboliques
# --columns : Affiche la colonne dans laquelle RATS a trouver un problème de sécurité
# --context : Affiche la ligne dans laquelle RATS a trouver un problème de sécurité

Exemple:

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

void copier(char *chaine)
{
char buffer[100];
strcpy(buffer, chaine);
}

int main(int argc,char *argv[])
{
if(argc < 2)
{
fprintf(stderr,"oups! et la chaine de caractere elle est ou ?\n\n");
exit(EXIT_FAILURE);
}
copier(argv[1]);
return 0;
}

Au dessus le programme C vulnérable, dans ce programme j' ai volontairement laisser trainer un buffer de taille fixe de 100 octets, le programme prend en argument une chaine de caractere qui sera transmis a la fonction copier() et placer dans le buffer .ça sens le BOF a 3km ! Bon si il affiche pas d 'alerte c' est qu' il est a mettre dans la corbeille :-)

n4pol3on@debian:~/prog_C$ rats -l c --columns --context --html vuln.c

RATS results.

Issue: fixed size global buffer

Extra care should be taken to ensure that character arrays that are
allocated on the stack are used safely. They are prime targets for
buffer overflow attacks. <------ Bien vue l amis rats !
File: vuln.c Line:7 char buffer[100]; <------- Le buffer que je parlais

Issue: strcpy <-------- La fonction strcpy()
Severity: High
Check to be sure that argument 2 passed to this function call will no copy more data than can be handled, resulting in a buffer overflow. <--------- Bien vue l' araignée
File: vuln.c Line:8 strcpy(buffer, chaine); <--------- aie aie aie !!!

Inputs detected at the following points
Total lines analyzed: 38
Total time 0.032423 seconds
1172 lines per second

Voila un exemple affreusement exagerer mais c ' est simplement histoire de montrer son utilisation, qui est extremement simple, ceci dit il vaut mieu jetter quand même un coup d' oeil soit même au code ..