unix4fun

VIM et 0x0a, grmlbmlbm $#!@$#@!

eau — Sun, 18 Jul 2010 00:53:00 +0200

Si vous aussi vous vous retrouvez a éditer des fichier binaires un peu a la loyale et que vim vous casse les burnes a rajouter ce satane 0x0a a la fin sans rien dire, voici les deux lignes magiques:

:set noeol
:set binary

Il y a évidement d'autres alternatives genre HTE ou BEYE (anciennement BIEW) ou d'autres, mais pas top top, mais je crois que d'autres alternatives arrivent tranquillement, j'updaterai ou je posterais une news en plus au moment venu, wait and see..

bref voila...

Le crochetage SSL avec ton serpent

frl — Wed, 09 Jun 2010 11:43:00 +0200

Pour un premier post, désolé, c'est sur du win32 :). Je lisais dernièrement "GrayHat Python" et je découvre Pydbg (un debugger écrit en python) que je ne connaissais pas (bon je ne connais pas grand chose non plus, du coup c'est plus facile d'être émerveillé) et dans le chapitre sur le hooking je tombe sur un exemple de "soft-hooking" (le hooking avec un breakpoint soft (INT3) sur la fonction qui t'intéresse) pour "sniffer" les connections SSL dans firefox (hook sur une fontion specifique de firefox).

Ca me rappelle des discussions avec eau qui avait déjà commence a bosser dessus, en voyant comment le truc est tout con ca m'a donne envie de voir si hooker les "CryptoAPI"s de MS que IE utilise est tout aussi simple.

Donc une fois recup Pydbg, un petit "import pydbg" et on peut instancier un object debugger mydbg=pybdg.pydbg().
Et voila! maintenant qu'on a notre debugger instancié, on peut s'attacher a des process, mettre des breakpoints, lire l'etats des registres etc.. Un peu comme scripter a l'interieur d'IDA ou ImmunityDebugger.

Du coup c'est vrai que le soft hooking comme ca c'est tout bidon. Un petit breakpoint dans la fonction qui nous intéresse, une callback fonction pour effectuer des opérations sur cette fonction et on release le breakpoint pour que le process continue normalement.

Bon, c'est pas efficace du tout côté perf, c'est clair...
Mais pour un ptit hooking rapido histoire de tester/fuzzer un truc ca peut etre sympa et utile.

Alors voila j'ai matte les CryptoAPI de MS et j'ai pense d'abord hooker "CryptEncrypt()" et "CryptDecrypt()" exportées par "Advapi32.dll".

Ok finalement en cherchant un peu, il y a eut pleins de présentations sur le hooking de ces 2 fonctions (par exemple celle-ci) et en effet c'est tout bon mais pour sniffer uniquement.

Si on veut modifier les requêtes envoyées par exemple, alors la on voit qu'on tombe sur un os, en tracant les appels un certain "CryptHashData()" est appelé avant "CryptEncrypt()" et donc dommage.. Difficile de modifier un truc hashe préalablement sans que ca se voit! Et la ce cher eau me dit qu'il avait regarde "EncryptMessage()" et "DecryptMessage()" et il avait raison le bougre!

En effet "EncryptMessage()" prend la requête, appele "CryptHashData()" puis "CryptEncrypt()" et balance tout ca hashé/chiffré ensuite au fonctions résal(réseaux). Du coup hooker "EncryptMessage()" est bien plus intéressant puisqu'avant le hash donc possible de modifier la requête.

Je n'ai pas encore réussi a faire tout ce que je voulais sur "EncryptMessage()", modifier la requête...ok, mais uniquement si sa nouvelle taille est <= a l'originale. Pour en générer une de taille > a la requête originale, je coince.

J'ai essaye de mettre a jour la taille a plusieurs endroits, re-ecrire la requête en allouant assez de place ailleurs et updater les pointeurs/références sur ma nouvelle requête mais niet... je dois merder, quelque chose m'échappe.

Voyant que des fonctions appelées avant "EncryptMessage()" manipulaient aussi la requête HTTP et utilisaient la taille pour différents trucs que je n'ai pas exploré je me suis résigné a hooker la dedans et c'est passé. Enfin, j'ai finalement hooke une fonction qui se trouve dans "Wininet.dll" mais elle semble tres specifique a IE donc pas super fonctionnel pour autre chose qu'IE... (i.e. Thick Client)...

Pour ceux que ca intéresse, voila un petit bout de code tout bidon (et pas beau je sais :)..) mais c'est juste pour tester et voir comment jouer avec pydbg et le soft-hooking:

hook_ssl_pydbg.py

J'ai teste ca sur XP SP2 en anglais avec IE7.

Un petit print screen aussi pour voir ce que ca donne:

Pydbg fait parti du framework Paimei (du coup ca m'a donne envi de revoir kill bill2..):
Paimei

svn checkout http://paimei.googlecode.com/svn/trunk/pydbg paimei-read-only

CryptEncrypt(), CryptDecrypt(), EncryptMessage(), DecryptMessage()

Ca passe ok avec python 2.6 sur ma VM XP mais quelques posts disent que pydasm ne passe bien qu'avec python 2.5.

vers l'infini et au delà! java!

eau — Sun, 30 May 2010 16:56:00 +0200

Un gentil et soyeux descriptif d'une vulnerabilite dans le code de parsing midi de Java, marrant et une bonne lecture.

C'est a lire par ici:

http://vreugdenhilresearch.nl/2010/05/java-midi-parse-vulnerabilities/

ASM reference

eau — Mon, 26 Apr 2010 23:31:00 +0200

En ce moment je bricole des trucs en assembleur x86/x86-64 et MIPS (wouhouu j'ai un loongson 2f!), alors du coup j'ai qqes liens:

Et j'en profite pour dire que pour tester il y a:

GXEMUL
QEMU

Et il y a aussi qqes petits liens classiques:

C'est dans les vieux pots...

poz — Mon, 12 Apr 2010 10:34:00 +0200

Suite à la mise à disponibilité de RE2, je suis tombé sur un article de Russ Cox qui explique en quoi l'algorithme de matching de Ken Thompson (Thompson NFA, pour Non Deterministic Algorithm) poutrait grave sa mère pour la reconnaissance de certaines grammaires (face à PCRE ou Perl), avec moins de 500 lignes de C. C'est intéressant. On a même droit à une implémentation (assez basique) en C. Yummy.

o l'article

OpenBench ! l'autre analyseur logique "ouvert"

eau — Mon, 01 Mar 2010 13:37:00 +0100

La classe, il y a vraiment des gens poilus sur cette petite planete! Un nouveau projet de logic analyzer opensource (on avait deja poste une petite news sur un autre projet de logic analyzer opensource) qui affiche des fonctionnalites sympathiques, en tout cas ca fait un bel exemple d'une architecture materielle a base de FPGA "from scratch" et la possibilite d'etudier comment on "enchaine" du signal digital proprement!

Et hop un nouveau projet pour sniffer du bus!

J'y connais rien mais ca me fait tripper de lire leur sources meme si je pige que 1%
Enjoy!

Graphique sur le recencement des impacts de foudre survenus depuis 1963 sur la cordillère des Andes

mgu — Sat, 13 Feb 2010 13:15:00 +0100

Dans un registre bien différent de celui du précedent billet, je suis ammené de temps en temps a produire des statistiques sous forme graphique. Jusqu'a présent, j'utilisais gnuplot qui fait bien son boulot, mais il faut le reconnaitre, nous pond des graphiques un peu oldschool qui pourraient choquer quelques flans et par la meme occasion décrédibiliser tout le travail realisé en amont (dans un contexte professionnel).

Généralement je fais fi de ce genre de considérations, mais en tombant sur un comparatif rezal qui utilise ggplot2, jme suis dit que cela valait le coup de creuser l'affaire (certainement plus par curiosité que pour la raison énoncée ci-dessus).

Et en effet, ggplot2 utilise le langage R qui est trés utilisé, semble-t'il, pour générer des statistiques avancées / mathematiques.

Pour moi c'est un peu tout nouveau, et donc je découvre les immenses possibilités offertes par ce langage.

Et voila, il existe sur le net, quelques ressources interéssantes que je souhaitais vous faire partager (et qui vous permettrons peut-etre de mieux comprendre le titre).

Je suis pas docteur en crypto, mais ca m'empeche pas de chier droit!

eau — Fri, 05 Feb 2010 04:05:00 +0100

Il y a quelques semaines, une connaissance postait ce truc la en discutant, après avoir jeté un oeil, je ne trouve pas de solution triviale et je me dis bon... c'est juste je suis une quiche en crypto y a un truc incroyable a faire, j'y comprendrais rien... j'apprends ensuite qu'un pote qui mattait aussi l'a pété en 30 minutes... alors bon ok c'est une grosse brute poilue qui a une sorte de "don" pour voir la matrice, mais voilà, ca me fait chier de me sentir comme une merde et pourquoi pas ? je suis peut-être moins mediocre que je pense.

Je me suis dit bon faudra que j'essaye, le temps passe, je tourne autour un peu comme un puceau autour de sa premiere meuf, je flippe et quand je commence a m'approcher, oula trop dur beaucoup trop dur et je rebrousse chemin !

Après quelque temps a tergiverser, à me fouetter et a me sentir comme un clochard, je m'y suis mis hier soir et comme je suis un gros newbie en crypto, je me suis dit que j'allais ecrire comment j'avais attaqué la chose, sans la paperasse de "docteur en crypto" (ou chiffrement, j'en sais rien, j'm'en fous).

Etape 1 - Le probleme

#include <iostream>
#include <cstdlib>

using namespace std;

char *key = "????????";
//char secret[] = "ZJ]]_Y2ec%_hXH]P\\%k_eS2OSW4n\\]f+RJincNUS.QU_eLW].Ngn7F^^.IY17XUSZZYmjJ^!";
//char out[100];

void decrypt(char *secret, char *key){
char c;
char *k = key;
while ((c = *secret) != 0){
*secret++ = (c-32) - ((*k)-64) + 32;
k = *(k+1) ? k+1 : key;
}
}

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

strcpy(secret, "ZJ]]_Y2ec%_hXH]P\\%k_eS2OSW4n\\]f+RJincNUS.QU_eLW].Ngn7F^^.IY17XUSZZYmjJ^!");
decrypt(secret,key);
cout << "SECRET MESSAGE: " << secret << endl;

return EXIT_SUCCESS;
}

Et là faut retrouver le plaintext.

Etape 2 - C'est quoi ce bordel..?!

On se dit : première hypothèse, si c'est un "challenge" la taille de la clef dans le code source doit bien etre de 8 chars et le "plaintext" doit etre un texte standard en anglais. Ensuite on matte la routine de decryption, on voit que ca "rotate" sur la taille de la key, donc des blocs encrypted de 8 chars à chaque fois, chaque bloc est chiffré avec la même clef.

c'est un "challenge" donc le plaintext est certainement une phrase, donc des caractères imprimables.
c'est un "challenge" donc la clef est probablement un mot anglais un truc du genre (vu le language du forum).
c'est un "challenge" donc le \?\?\?\?\?\?\?\? veut aussi probablement dire que la clef fait 8 bytes"

Etape 3 - Par où je commence !?

Première idée... bon-je-sais-pas-quoi-faire, "when in doubt, use brute force", alors hop on bricole un bruteforcer en carton avec un trombonne, un chewing gum et de l'ammoniac et on se dit que "youpi youpi" dans 10 minutes on a la reponse et pfiou je suis pas trop une grosse tanche comme je pensais, après tout, mon bruteforcer, il est recursif, il verifie que pour chaque byte de clef teste, le "plaintext" sur tous les blocs reste un caractere "possible" (comprendre printable à l'ecran soit entre 0x20 et 0x7D ou 0x7E} et la récursivité arrive pour aller bruteforcer le bytes de clef suivant, si j ai verifié cette condition.

Naif que j'étais je me suis dit... "wai tranquille, devrait pas trop y en avoir", mes fesses wai.. lancant le bruteforce et en loggant dans un fichier, je me suis retrouve avec un file de plus de 18 Go de candidats possibles (./bruteforcer^C^C^C^C^C) qui matchaient mes conditions, pleins de garbage et wai... il fallait tester rien que :

$ bc
bc 1.06.94
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'. 
255^8
17878103347812890625

hmm merde...je pensais pas autant...hmm et pis ma machine est sur les genoux avec tout ça et mon disque en prends plein la gueule... bruteforce..meme apres triturage pas une bonne idée...

Etape 4 - Le plaign et le-pote-qui-connaît-la-crypto (tm)

Un vague optimisation apres exposition du problème a votre "local guru crypto", equation bla, limiter le range des bytes a tester, verifier correlations binaire bla, ne pas bruteforcer tout les chars, effectivement, j'enlève un TAS de candidats, je sais plus je crois que j'etais descendu aux alentours des 12 Go pour le file et la aussi ./bruteforcer-DrCrypto^C^C^C^C, bon j'ai aucun bagage en math, ni aucune technique pour trouver des super algo de pétage de crypto, donc hopla retour case depart, ma bite et mon couteau.

Entre temps j'ai dû passer deja 8 heures effectives sur cette connerie...c'etait il y a 1 ou 2 semaines.

Etape 5 - La bonne vieille haine des familles ou l'envie profonde de soumission !

Alors ma bite et mon couteau, hmm j'ai un cerveau, regardons ça de plus pres a nouveau...je me ré-ouvre tout ca (Featuring la grosse haine) hier soir... je regarde curieusement le ciphertext et je commence par le séparer en bloc comme au debut..

ZJ]]_Y2e  c%_hXH]P  \%k_eS2O  SW4n\]f+  RJincNUS  .QU_eLW]  .Ngn7F^^  .IY17XUS  ZZYmjJ^!

Hmm pas top lisible.. comme ca so..ouais beaucoup mieux..

0 1 2 3 4 5 6 7

Z J ] ] _ Y 2 e    
c % _ h X H ] P 
\ % k _ e S 2 O 
S W 4 n \ ] f + 
R J i n c N U S 
. Q U _ e L W ] 
. N g n 7 F ^ ^ 
. I Y 1 7 X U S 
Z Z Y m j J ^ !

Je reviens a mes hypotheses.. je me dis bon, si c'est une phrase, il y aura des espaces et peut etre des virgules, mais pour un challenge mettre de la ponctuation ca me parait chiant.. alors je me dis ok, espaces seulements... ensuite mon oeil est attiré par les 3 . . . sur la colonne du byte 0 de la clef.. en mattant la ligne plus haut je me dis que ca passe pas mal si c'est un espace ca separe bien des mots.., je me bricole vite fait 2 ptits tools a la con... pour bruteforcer la valeur de la clef pour obtenir le plaintext et un autre juste pour encoder 1 byte en lui filant le byte de la clef.

alors, si '.' est un espace quelle est la clef necessaire pour l'obtenir:

$ ./findk . " "
cipher: . -> plain:  
key: 0x4e (N)

Ok "N" bon ca serait eventuellement le premier byte de la clef, c'est possible c'est "printable", on va verifier avec les autres bytes de la meme colonne:

$ ./usek Z N
cipher: Z - N -> plain: 4c(L)
$ ./usek c N
cipher: c - N -> plain: 55(U)
$ ./usek \\ N
cipher: \ - N -> plain: 4e(N)
$ ./usek S N
cipher: S - N -> plain: 45(E)
$ ./usek R N
cipher: R - N -> plain: 44(D)
$ ./usek . N
cipher: . - N -> plain: 20( )
$ ./usek Z N
cipher: Z - N -> plain: 4c(L)

Hmm là je me dis, intéressant, il n'y a pas un seul caractère relou, genre virgule, caractères de contrôles a la noix, #, @ etc... que des chars et étrangement ils sont tous en majuscule. Je me refais une petite ligne :

//char dasecret[] = "ZJ]]_Y2ec%_hXH]P\%k_eS2OSW4n\]f+RJincNUS.QU_eLW].Ngn7F^^.IY17XUSZZYmjJ^!";
//                   =       =       =       =       =       =       =       =       =            
//                   L       U       N       E       D       .       .       .       L          KEY: N???????

Je représente les "espaces" par des "." histoire de rendre ça un peu plus lisible pour mon cerveau de mollusque ! Je reviens sur ma petite matrice de caractères, je matte la colonne #2 et je me dis, tiens les "%" ca pourrait être les espaces du début de la phrase, vu que j'ai trouvé les espaces de la fin de la phrase (enfin je crois), alors j'essaye..

$ ./findk % " "
cipher: % -> plain:  
key: 0x45 (E)
$ ./usek J E
cipher: J - E -> plain: 45(E)
$ ./usek % E
cipher: % - E -> plain: 20( )
$ ./usek W E
cipher: W - E -> plain: 52(R)
$ ./usek Q E
cipher: Q - E -> plain: 4c(L)
$ ./usek N E
cipher: N - E -> plain: 49(I)
$ ./usek I E
cipher: I - E -> plain: 44(D)
$ ./usek Z E
cipher: Z - E -> plain: 55(U)

Et là je me dis, ca sent le mouflon ! J'ai de nouveau que des lettres capitales et le second byte de ma clef est aussi en lettre capitale, ca ne me semble plus etre une coincidence... Yes j'ai 2 bytes de la clef ! NE.. hmm

//char dasecret[] = "ZJ]]_Y2ec%_hXH]P\%k_eS2OSW4n\]f+RJincNUS.QU_eLW].Ngn7F^^.IY17XUSZZYmjJ^!";
//                   =       =       =       =       =       =       =       =       =            
//                   LE      U.      N.      ER      DE      .L      .I      .D      LU         KEY: NE??????

Bon première idée qui me vient en tête, NE, NET ?! 'vais essayer donc "T" pour la 3ème lettre...

//                   LEI     U.K     N.W     ER.     DEU     .LA     .IS     .DE     LUE        KEY: NET????? NET could be a word but..

Alors je cherche des mots anglais commencant par NET (comme NETWORK) pour la clef, mais je ne trouve rien dont la 4ème lettre passe..hmm Ensuite en mattant de le plaintext avec 3 lettres, LEI, DEU, LUE, je trouve pas ou peu de mots en anglais.. j'ai pas ou peu d'idées de comment passer à la prochaine étape, hmm mais j'ai dit que j'allais te soumettre alors tu m'echapperas pas $#@!$#@!$!@$!

Etape 6 - Le breakthrough

Grmlgrmlgrm, quelques verres dans le nez avec une copine, une bonne discussion, du vibe... je rentre chez moi vers 0h00, je mange rapidos, je rouvre mon petit fichier.. et hmm Je commence à douter de ma 3ème lettre... je fais marche arrière pour la 3ème lettre et je réfléchis...

0 1 2 3 4 5 6 7

N E ? ? ? ? ? ?

Z J ] ] _ Y 2 e    
c % _ h X H ] P 
\ % k _ e S 2 O 
S W 4 n \ ] f + 
R J i n c N U S 
. Q U _ e L W ] 
. N g n 7 F ^ ^ 
. I Y 1 7 X U S 
Z Z Y m j J ^ !

4ème colonne 3 x n, hmm le coup des espaces peut-être, je retente, groumpf je tombe sur des caractères relous en decodant la colonne.. pas la bonne partie de la clef, je refais la même chose pour le reste... 2x7, 2x_, etc... ca passe pas.. grmlbmlbmb..

Je me dis bon... qu'est-ce que j'ai là.. et je me rends compte que j'ai de nouvelles hypothèses de base sur mes trouvailles précédentes..

phrase entièrement en majuscules.
clef entièrement en majuscules.
1 byte de clef valide devrait vérifier une colonne entière en majuscule ou avec un espace

Chassez le naturel, il revient au galop : when in doubt, use brute force! Cette fois je bruteforce uniquement 2 blocs de ciphertext, je prends entre 0x41 et 0x5A pour les bytes de la clef, je ne teste que isupper(), isblank() et isdigit() on sait jamais si il y a du "leet speak"..

$ ./bf2 > bf2results
$ ls -la bf2results 
-rw------- 1 eau users 41570100 2010-02-05 01:33 bf2results

Hmm 41 Mo de results, ca va, c'est très très loin des 12 Go, je dois pas être loin! Je matte le contenu :

key: NEITVARW, index: 8 buffer: LETIIX NU VTBGK9N
key: NEITVARX, index: 8 buffer: LETIIX MU VTBGK8N
key: NEITVARY, index: 8 buffer: LETIIX LU VTBGK7N
key: NEITVARZ, index: 8 buffer: LETIIX KU VTBGK6N
key: NEITVBRK, index: 8 buffer: LETIIW ZU VTBFKEN
key: NEITVBRL, index: 8 buffer: LETIIW YU VTBFKDN
key: NEITVBRM, index: 8 buffer: LETIIW XU VTBFKCN
key: NEITVBRN, index: 8 buffer: LETIIW WU VTBFKBN

Bon signe, les candidats font à peu pres tous la meme taille, et y a ces 2 chars partout, ensuite je commence par virer les trucs improbables à coup de grep

$ cat bf2results | grep -v QQ | grep -v GKD | grep -v VXM | grep -v KDN \
   | grep -v K9N | grep -v K8N | grep -v K[0-9]N | grep -v YSN | grep -v EZX \
   | grep -v XTF | grep -v KBN | grep -v NTT | grep -v KCN | grep -v YRF \
   | grep -v SQL
[...]
key: NETYPSRO, index: 8 buffer: LEIDOF VU KOH5KAN
key: NETYPTRK, index: 8 buffer: LEIDOE ZU KOH4KEN
key: NETYPTRO, index: 8 buffer: LEIDOE VU KOH4KAN
key: NETYPURK, index: 8 buffer: LEIDOD ZU KOH3KEN
key: NETYPURO, index: 8 buffer: LEIDOD VU KOH3KAN
key: NETYPVRK, index: 8 buffer: LEIDOC ZU KOH2KEN
[...]

Etape 7 - Finish HIM!!

Et la je me dit tiens c'est bizarre... VU ca veut rien dire en anglais, mais ZU en ALLEMAND.. c'est TO... et la je commence a me dire merde, c'etait pas en anglais, on va verifier... je filtre que les " ZU ", du coup je vois que les 2 derniers bytes de la clef sont toujours "RK" :

key: NEZZWRRK, index: 8 buffer: LECCHG ZU ENA6KEN
key: NEZZWSRK, index: 8 buffer: LECCHF ZU ENA5KEN

Et là ca devient de plus en plus des mots, alors je m'excite, mais peut-être que mon "T" pour le 3ème char était bon !!!!!! Hop hop hop!

$ cat bf2results | grep -v QQ | grep -v GKD | grep -v VXM \
  | grep -v KDN | grep -v K9N | grep -v K8N | grep -v K[0-9]N \
  | grep -v YSN | grep -v EZX | grep -v XTF | grep -v KBN \
  | grep -v NTT | grep -v KCN | grep -v YRF | grep -v SQL \
  | grep " ZU " | grep "key: NET" | wc -l
4146

Je matte vite fait les results :

key: NETZWDRK, index: 8 buffer: LEICHU ZU KNADKEN
__key: NETZWERK, index: 8 buffer: LEICHT ZU KNACKEN__
key: NETZWFRK, index: 8 buffer: LEICHS ZU KNABKEN
key: NETZWGRK, index: 8 buffer: LEICHR ZU KNAAKEN
key: NETZWORK, index: 8 buffer: LEICHJ ZU KNA9KEN

Et là je me dis BORDEL C'EST DE L'ALLEMAND DE MERDE $#@! $#@!$#@!$!#@$#@! Je vérifie sur translate bidule.... "Easy to crack" RAH $#@ $ #@!$ #@! $#@! $ #@!$ #@! Hop je passe le tout avec la super clef que je viens de recover, NETZWERK :

Et voilà le plaintext :

"LEICHT ZU KNACKEN WENN DER TEXT DEUTLICH LAENGER IST ALS DE SCHLUESSEL"

Et sa traduction :

"Easy to crack WHEN THE TEXT IS SIGNIFICANTLY LONGER THAN DE KEY"

Juste pour les relous, il y a certainement 10000321432 moyens de faire mieux et plus simple, les commentaires sont les bienvenus pour les critiques constructives ! N'hesitez pas, c'etait certainement pas la methode la plus élégante, mais c'est passé et le temps effectif passé dessus est de bien une 15 aines d'heures, pas vraiment les quelques jours que je pensais... mais je suis toujours très loin des 30 minutes :)

Enjoy !

mechante deadlock! vilaine! booouuu mechante! a la niche!

eau — Fri, 29 Jan 2010 22:57:00 +0100

Un projet marrant et que je trouve super drole, j'ai a peine commence a lire et j ai pas poste depuis des lustres, allez hop c'est la fete :)

Un projet pour "eviter" les deadlock sans avoir a recompiler quoique ce soit, vais tester ca gentillement ce soir!

Le project:

http://dslab.epfl.ch/proj/dimmunix

Le paper:

http://dslab.epfl.ch/pubs/dimmunix

Le code:

http://code.google.com/p/dimmunix/

Vas-y, montre moi tes doigts ?!

jr — Thu, 31 Dec 2009 10:55:00 +0000

Tu aimes Netfilter mais voilà, tu voudrais bien aussi faire... de l'OS fingerprinting ? C'est possible depuis la version 2.6.31, grâce au module xt_osf qui a été inclu officiellement. Donc voilà comment ça marche, un petit exemple :

insmod ./xt_osf.ko
./nfnl_osf -f ./pf.os
iptables -I INPUT -j ACCEPT -p tcp -m osf ~~log 0~~ ttl 2

Tout d'abord un commentaire sur pf.os, c'est le fichier utilisé par packet filter, donc le fichier de définition de p0f, le tool de mister Zalewski. Ensuite on fait un test de connexion, et on voit dans les logs :

Windows 2000:SP4 : 192.168.028.131:2007 -> 192.168.028.124:22 hops=0

L'archive pour le programme userland (nfnl_osf) et les infos sont sur le bleurg de l'auteur du patch initial : http://ioremap.net/projects/osf

he HARP project: Have you ever wanted to build a CPU?

eau — Thu, 17 Dec 2009 23:26:00 +0100

Un projet super poilu, qui a pour but de construire une machine entiere "au travers d'"/"via" un FPGA, alors que je commence a peine a comprendre les debut de bases de VHDL et a faire mes premiers debuts d'embryons de tests, de trucs tout moisis, on me souffle ce lien, je vois ca et la pouf, je bande....mais j'y comprends encore rien, je vous rassure..

Le lien erectile:

harp project

c'est une tendance tres claire! les epidemies progressent...

eau — Sat, 05 Dec 2009 12:25:00 +0100

Alors ca n'est pas vraiment un truc "technique", mais c'est drole alors autant en faire une nouvelle. En ces periodes d'epidemies et de panique, de contagion massive, mr poz nous a trouve un paper sur une autre epidemie tres repandue et bien decrite, une analyse empirique du syndrome de "la grosse tete" (ca c'est moi qui appele ca comme ca...) ou des "grosses chevilles", bon je raconte n'importe quoi... lisez, c'est bien de lire:

das paper!

l'electronique digitale et son MUST HAVE pour debugger/sniffer des bus/chips etc...

eau — Tue, 10 Nov 2009 23:44:00 +0100

Je decouvre pleins de trucs (pas difficile je connais rien), je me suis achete un analyseur logique ou logic analyzer pour matter les signaux qui passent pour un petit projet a la con et surtout comprendre l'arsenal des outils pour designer et comprendre l'electronique de base.

Au fil des liens je suis tombe sur ce projet opensource qui semble plutot pas mal, a tester et a suivre...

Alors je vais essayer de commencer a lire (j'ai tellement de trucs a lire...$#@$#@! et si peu de temps.. $#@!$#@ :() bref au moins je sais que j'aurais mis le lien qqes part :) et j'essayerais d'updater ou de poster si j'ai quelque chose d'interessant a dire :)

meme vieux on continue d'apprendre

eau — Fri, 06 Nov 2009 16:02:00 +0100

Je rentre dans ma 65 eme annee et je continue encore d'apprendre de nouvelles choses.. Au cours d'une discussion avec un pote sur "l'intrawebz" (tm) j'ai appris l'existence des register_printf_functions.. comme decrit dans les liens suivants:

Et au passage qqqes docs sur les attributes GCC et des ptits examples:

Edit de poz:

on note au passage que dans le premier lien, l'auteur ne sait pas comment virer un warning gênant à la compilation (dû à -Wformat, lui-même inclu dans -Wall) ; pour s'en débarrasser, il suffit de passer l'option -Wno-format à gcc. Ceci dit, il faut faire attention, parce qu'il ne râlera plus quand vous utiliserez le mauvais /specifier/ (genre %s au lieu de %zu), donc méfiance...
bon alors bien sûr c'est quand on migre son code que la merde arrive par tombereaux entiers :). Alors, register_printf_function() est deprecated à partir de glibc 2.10, il faut donc utiliser register_printf_specifier() à la place. Un coup de #if __GLIBC_PREREQ(2,10) sous linux devrait faire l'affaire... je mets au conditionnel parce que chez moi le printf() segfault :)

IMDb le retour de la mOOooOOort

poz — Tue, 27 Oct 2009 15:31:00 +0100

Bon alors, il y a presque deux ans j'avais écrit un script tout pourri, cf cette news. Je disais "ouiiiii, après j'vais ajouter des graphes et tout tu vas voir c'est trop de la boulette kikoolol", et... ben rien. Parce que je suis une grosse bouse j'ai arrêté d'y toucher. Ben à ma pause de midi là, j'ai écrit un script tout moche qui utilise l'output de imdb.sh pour générer des graphes d'évolution des notes d'un acteurs en fonction du temps, etc. On peut même en afficher plusieurs en même temps ! Trop puissant ! Bon en fait c'est tout naze hein, mais c'est juste que ça fait marrer de comparer bruce lee et chuck norris, exemple :

Bon... si vous voulez *vraiment* le script, c'est ici :

imdb-graph.sh

Il suffit de l'appeler comme ceci :

$ imdb-graph.sh "brad pitt"

Ou pour avoir plusieurs courbes superposées

$ imdb-graph.sh "brad pitt" "edward norton"

Il produira alors le fichier 'brad pitt edward norton.png'

Real High level languages are Un!X

sbz — Thu, 08 Oct 2009 01:22:00 +0200

Nous aimons tous le C, l'asm, Unix et Linux, c'est un fait. Mais voilà pourquoi on aime aussi le Python et le Perl qui sont aussi des *vrais* langages.

Vous en doutez encore ? Allez jeter un oeil ici et là.

TCP/IP for dummies

poz — Wed, 30 Sep 2009 08:38:00 +0200

Je ne sais pas pour vous, mais le réseau, je trouve ça assez intéressant. Comment fonctionnent les protocoles, leurs implémentations, etc. Alors voici un petit lien, présentant une implémentation de TCP/IP très légère, mais assez intéressante d'un point de vue didactique. Il s'agit de lwIP (light-weight IP), une stack TCP/IP ne faisant pas de copie de buffer afin de ne pas perdre trop en performances (mais avec une abstraction manquante, car chaque layer peut taper dans la couche sous-jacente), et où les principaux comportements attendus sont implémentés : silly window avoidance, demultiplexage, contrôle de checksum, retransmission rapide, calcul de RTT, contrôle de congestion, etc. La pile propose même une API BSD compliant :) Bon, il s'agit d'un PoC d'universitaire, hein, c'est pas ça qui va remplacer les piles des OS, mais encore une fois, ça se comprend vite et bien.

Ah, oui, le code (C, oeuf corse) tient en moins de 2600 lignes, et le code objet produit pèse 13.5 KiB.

c'est ici

PS : Dernière chose, il n'y a pas de support IPv6. Haaan, la grosse honte.

GDB et sa belle super conviviale nouveaute!

eau — Sun, 27 Sep 2009 00:12:00 +0200

Eh ouiii, on m'a averti cette semaine GDB a une nouvelle super fonctionnalite conviviale qui permet de faire (grossierement) "marche-arriere" et donc et revenir a l'etat d'execution precedent et puis le precedent et puis le precedent en gros de runner le code a l'envers... voila c'est fait GDB fonctionne comme un magnetoscope VHS et ca se passe par ici.

Piccolo-SAN!!!

eau — Wed, 02 Sep 2009 11:12:00 +0200

On m'a pose une question ce matin et je me suis rappele que j'avais ecris un tools a la noix pour l'iSCSI, mais du coup j ai vite cherche 2-3 trucs divers sur "l'intarwebs" ( (c) unpote ) a propos des autres trucs sur les SANs, et j'ai trouve qqes autres trucs marrant a lire:

bref c'est pas nouveau, mais ca fait du bien a relire et ca me donne presque envie de bidouiller 2,3 ameliorations a mon bidule, si je le retrouve grbmlmblmb..

enjoy!

Oh oui, montre-moi ton gros paquet !

poz — Thu, 27 Aug 2009 14:40:00 +0200

Je vais probablement enfoncer des portes ouvertes mais c'est pas grave. Récemment j'ai écouté le trafic d'une machine qui streamait du son via le protocole DAAP (le truc de iTunes) sous un linux (donc une approximation de DAAP en fait, car les specs ne sont pas releasées). Bref, le linux envoie de la musique sur un LAN via le soft rhythmbox. Ça passe par un LAN, et arrive au client. En faisant un coup de tcpdump sur le serveur, je m'aperçois que les datagrammes IP font régulièrement plus de 1500 bytes. Souvent 5 ou 7 KB. Curieux... Je me demande d'où ça vient. Qui plus est, le checksum TCP est incorrect. Vraiment chelou, ça.

$ ip link ls eth0
3: eth0: <BROADCAST,MULTICAST,PROMISC,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP qlen 1000
    link/ether 00:12:3f:71:57:a1 brd ff:ff:ff:ff:ff:ff

La MTU est bien à 1500. Si j'écoute sur le client, je vois bien des paquets fragmentés. Bizarre bizarre. Le switch ferait ça ? Je mirror les ports et j'écoute : paquets fragmentés. Boooon, après avoir cherché à droite à gauche, je tombe sur ces liens :

L'explication est que la fragmentation est réalisée par la carte réseau, hypothèse que j'avais exclue d'emblée, parce que ça me semblait overkill. Et pourtant ! Un patch avec des benches envoyés sur la ml netdev du noyau linux montre que ça améliore significativement les performances (dans le cas où le firmware permet de le faire, bien sûr), et ça semble intégré depuis le 2.6.18.

C'est tout. Je voulais juste poster ça pour éviter aux ignares comme moi de chercher pendant des plombes le pourquoi du comment. Enfin... encore faut-il qu'ils connaissent ce site. :-)

PS : pour le checksum erroné, c'est visiblement parce que la stack TCP/IP sait que le device va regragmenter, et donc invalider le checksum calculé (et en mettre un autre à la place). Donc pas la peine de se fatiguer à le calculer. C'est mon hypothèse, il faudrait que je regarde les sources.