20:56 < BahaBulle> Au début, y'a un 26 00 00 ... qui pourrait être un numéro de secteur mais j'en ai pas vu d'autre ensuite
20:57 < |Pixel|> comment ça, pas vu d'autres ?
20:58 < BahaBulle> Bah après, ils se ressemblent tous à part qu'il y a un 80 de temps en temps qui me dit qu'il y a quelque chose avec ce truc mais je ne vois pas quoi
20:58 < |Pixel|> à quoi correspond ce "26" /
20:58 < |Pixel|> ?
20:59 < BahaBulle> Ca pourrait être un numéro de secteur mais j'en ai pas la certitude
20:59 < |Pixel|> qui vaudrait quoi ?
21:00 < BahaBulle> Euh...a pas compris la question :/
21:00 < BahaBulle> Si c'est un numéro de secteur, ça vaut le secteur 26...
21:48 < |Pixel|> BahaBulle: 26, c'est de l'hexa
21:50 < BahaBulle> ah oui, je l'oublie souvent celle-là :D
21:50 < |Pixel|> donc ?
21:51 < BahaBulle> Donc 38
21:51 < |Pixel|> refait-moi un printdir "/" ?
21:51 < BahaBulle> Et 38, c'est le secteur où se trouve le binaire
21:51 < |Pixel|> quelle belle coïncidence
21:51 < BahaBulle> Sector   Size        Date       Time       Flags  Name           XA flags
21:51 < BahaBulle>     22      2048 18/04/2000 12:35:00+0.0 -D------ .              d---f
21:51 < BahaBulle>     22      2048 18/04/2000 12:35:00+0.0 -D------ ..             d---f
21:51 < BahaBulle>     38    606208 18/04/2000 12:35:00+0.0 -------- SLUS_010.41;1  ----f
21:51 < BahaBulle>    334        69 18/04/2000 12:35:00+0.0 -------- SYSTEM.CNF;1   ----f
21:51 < |Pixel|> 334 vaut combien en hexa ?
21:52 < BahaBulle> 14e
21:52 < |Pixel|> bien; et donc... ?
21:52 < BahaBulle> OUIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIN
21:52  * BahaBulle veut un nouveau cerveau
21:52 < |Pixel|> oui oui oui
21:53 < |Pixel|> "donc" ? :P
21:54 < BahaBulle> Donc ça m'explique le début du secteur 24
21:54 < BahaBulle> 26 00 00 00 4e 01 00 f7 4f 01 80 00 4f 01 80 00
21:54 < |Pixel|> ça t'explique quoi ?
21:55 < BahaBulle> Ca donne les secteurs des fichiers
21:55 < |Pixel|> explicite
22:03 < BahaBulle> En revanche, on a pas l'indication de la taille du fichier
22:03 < |Pixel|> peut-être, peut-être pas
22:04 < BahaBulle> Déjà, le secteur ne semble pas sur 4 octets sinon ça colle pas
22:05 < |Pixel|> bieng
22:07 < BahaBulle> Donc il doit être sur 2 ou 3 mais y'a ce 80 qui m'embête
22:09 < |Pixel|> quelle est le numéro de secteur maximum d'un CD ?
22:09 < BahaBulle> Aucune idée
22:10 < |Pixel|> réfléchis un peu
22:11 < |Pixel|> c'est juste des math simples
22:11 < |Pixel|> certain que GreatSkaori pourra répondre à cette question
22:11 -!- GreatSkaori [seb@Wnet-50675.w90-27.abo.wanadoo.fr] has quit [Ping timeout]
22:11 < |Pixel|> le lache!
22:12 < cvoila> ou pas :p
22:12 < |Pixel|> je suis en train de m'étrangler de rire devant mon PC
22:12  * S-O-R étrangle |Pixel| pour l'aider
22:12  * |Pixel| donne des coups de pieds
22:13 < BahaBulle> Ca dépend de la taille du CD :p
22:13  * BahaBulle saute sur S-O-R et le frappe à coup d'enceinte
22:14 < |Pixel|> et quelle est la taille typique d'un CD ?
22:14 < cvoila> Baha : combien d'octets y'a-t-il dans un secteur déjà ?
22:14 < |Pixel|> ça c'est la question suivante :P
22:14 < cvoila> désolé
22:14 < |Pixel|> hu hu
22:14 < BahaBulle> 650 Mo
22:14 < |Pixel|> répond à la question de cvoila maintenant
22:15 < BahaBulle> 2352 (j'ai lu ça quelque part :p)
22:15 < BahaBulle> octets
22:15 < |Pixel|> ça c'est en "raw"
22:15 < |Pixel|> c'est 2048 en mode "data" (ou MODE2_FORM1)
22:15 < BahaBulle> C'était ma 2ème réponse
22:15 < |Pixel|> :)
22:15 < |Pixel|> bref; donc combien de secteurs ?
22:17 -!- GreatSkaori [~seb@Wnet-11992.w86-194.abo.wanadoo.fr] has joined #bleargh
22:17 < BahaBulle> euh...650 Mo en octets, ça fait.............tout ça / 2048......dans les 300 000 :D
22:18 < |Pixel|> dans les 300000, oui
22:18 < |Pixel|> ce qui fait combien en hexa ?
22:18 < BahaBulle> 0493E0 (pour 300 000)
22:19 < |Pixel|> bien; qu'est-ce qui te "gêne" exactement avec le 80 ?
22:22 < BahaBulle> Bah, a quoi il sert ? Si le secteur est sur 3 octets, il reste 1 octet
22:22 < |Pixel|> qu'est-ce que tu connais du "binaire" exactement ?
22:23 < BahaBulle> C'est des 0 et des 1 :D
22:23 < |Pixel|> mvui voilà
22:23 < |Pixel|> bon
22:23 < |Pixel|> si on regarde ton numéro de secteur là
22:23 < |Pixel|> pour arondir, disons 050000
22:24 < |Pixel|> si on affiche ça en binaire, ça donne:
22:24 < BahaBulle> 0101 0000 0000 0000 0000
22:24 < |Pixel|> 000001010000000000000000
22:24 < |Pixel|> avec 4 zéros devant, oui
22:25 < BahaBulle> ah oui, j'ai oublié le 0 devant
22:25 < |Pixel|> et ton "80" en 3ième position, c'est 800000
22:25 < |Pixel|> donc en binaire:
22:25 < |Pixel|> 100000000000000000000000
22:25 < |Pixel|> en clair, 800000 fait en binaire:
22:25 < |Pixel|> 100000000000000000000000
22:26 < |Pixel|> alors que n'importe quel numéro de secteur en binaire s'écrit avec des chiffres binaires qui sont là:
22:26 < |Pixel|> 00000xxxxxxxxxxxxxxxxxxx
22:26 < BahaBulle> Ca ok
22:26 < |Pixel|> en clair, ton "80" ne peut pas rentrer en collision avec le numéro de secteur
22:26 < |Pixel|> pour être plus précis, ce genre de technique est classique
22:27 < |Pixel|> rajouter un bit en haut d'un "petit" chiffre pour le marquer; on appelle ça un 'flag'
22:27 < |Pixel|> vu que c'est *vraiment* le bit le plus haut possible, on peut vraiment se douter que ce 80 qui traine est une indication de flag
22:28 < BahaBulle> Oui
22:28 < |Pixel|> donc tu peux considérer que le numéro de secteur est sur 3 octets en effet, avec un flag éventuel en 800000
22:28 < |Pixel|> et j'oserais même rajouter:
22:28 < |Pixel|> ce flag à vue de nez indique si le fichier est en MODE2; à savoir, une vidéo en STR
22:29 < |Pixel|> à l'instar des autres fichiers normaux du CD qui sont en MODE2_FORM1
22:29 < BahaBulle> Si tu le dis :D
22:30 < |Pixel|> c'est ce que l'on appelle de l'inspiration, mais bon
22:30 < |Pixel|> bref
22:30 < |Pixel|> continuons sur notre lancée
22:30 < |Pixel|> 22:03 < BahaBulle> En revanche, on a pas l'indication de la taille du fichier
22:30 < |Pixel|> 21:54 < BahaBulle> 26 00 00 00 4e 01 00 f7 4f 01 80 00 4f 01 80 00
22:30 < |Pixel|> 21:51 < BahaBulle>    334        69 18/04/2000 12:35:00+0.0 -------- SYSTEM.CNF;1   ----f
22:30 < |Pixel|> faisons encore un peu de math
22:31 < |Pixel|> notre fichier system.cnf, qui est situé en 14e, fait 69 octets
22:31 < |Pixel|> en lisant l'entrée suivante, (14f), on sait donc qu'il occupe au maximum un secteur
22:32 < BahaBulle> oui
22:32 < |Pixel|> il y a un truc entre les deux entrées, un "f7", qui n'ést pas présent dans l'entrée précédente
22:32 < |Pixel|> 21:51 < BahaBulle>     38    606208 18/04/2000 12:35:00+0.0 -------- SLUS_010.41;1  ----f
22:32 < |Pixel|> l'entrée précédente fait 606208 octets
22:32 < |Pixel|> "implicitement" on sait qu'elle est là de 0x26 à 0x14e
22:33 < |Pixel|> donc 296 secteurs (en décimal)
22:33 < |Pixel|> 296*2048 = 606208
22:33 < |Pixel|> ho la belle coïncidence
22:33 < BahaBulle> AAAAHH, je suis partit de 20352 octets pour faire mon calcul tout à l'heure, du coup, ça tombait pas bien :(
22:33 < BahaBulle> 2352
22:33 < |Pixel|> donc il n'y a pas de "résidus" sur le fichier
22:34 < |Pixel|> par contre, pour system.cnf, qui ne fait que 69 octets
22:34 < |Pixel|> on a un résidu de 1979 octets
22:34 < |Pixel|> F7 en hexa fait 247
22:34 < |Pixel|> un nombre "byte" ne peut aller que de 0 à 255
22:35 < |Pixel|> un secteur, on le sait, va de 0 à 2047
22:35 < |Pixel|> donc si on applique une échelle de valeur
22:35 < |Pixel|> il suffit de multiplier par 8
22:35 < |Pixel|> 247 * 8 = 1976
22:35 < |Pixel|> ce qui correspond à quelques octets près au résidu laissé par system.cnf
22:35 < |Pixel|> cqfd
22:36 < |Pixel|> donc en juste 3 entrées de 4 octets
22:36 < |Pixel|> on peut deduire avec une certitude de 95% je dirais l'utilité de chaque bit de chaque entrée
22:37  * |Pixel| cherche la pulsation de BahaBulle 
22:37  * S-O-R pense que |Pixel| a encore fait une victime
22:37  * BahaBulle est partit surveillé sa nourriture
22:38 < cvoila> ...
22:38 < BahaBulle> -é +er
22:38 < cvoila> -t aussi
22:38  * S-O-R en était sûr :P
22:38  * cvoila est l'hopital qui se fout de la charité
22:39  * BahaBulle est nul en conjugaison
22:40 < cvoila> finis ta popote et reviens-nous vite
22:40 < |Pixel|> *soupir*
22:40 < BahaBulle> ok ok, donc 3 octets pour le secteur (avec un flag pour dire le type de fichier) et 1 octet pour le "résidu"
22:41 < BahaBulle> En fait, il me manque pas mal de déclic pour comprendre ces truc-là
22:41 < BahaBulle> Bien que j'aurais pu trouver un peu plus si je ne m'étais pas trompé de taille pour un secteur :p
22:42 < |Pixel|> de toute façon
22:42 < |Pixel|> faut bien se mettre dans la tête ce que c'est qu'un CD, et comment il marche
22:42 < |Pixel|> est-ce que tu as lu la partie  STRUCTURE OF A CD-ROM de ma doc ?
22:43 < BahaBulle> Avec la doc du cd-tool ?
22:43 < |Pixel|> oui
22:43 < BahaBulle> Oui, plusieurs fois :D
22:44 < |Pixel|> heh
22:44 < BahaBulle> Mais mon cerveau n'assimile pas comme il faut les informations :D
22:44 < BahaBulle> D'ailleurs, faut que je la retrouve, je vais peut être mieux comprendre :D
22:45 < |Pixel|> http://www.nobis-crew.org/cd-tool/
22:47 < BahaBulle> Je vais manger
23:34 < BahaBulle> En fait, les structures de xeno et chrono sont "assez simples"
23:36 < BahaBulle> Enfin, y'a pas de cryptage à la con
23:36 < BahaBulle> Bref, suite au prochain épisode. Bonne nuit à tous
23:36 -!- BahaBulle [bahabulle@Wnet-2072.fbx.proxad.net] has quit [Quit: ]
23:36 < cvoila> roh
23:38 < Jes> :)
23:40 < Jes> au fait cvoila, tu fais souvent du reverse engineering "offline" il me semble, non?
23:40 < cvoila> oui
23:40 < Jes> VP tu l'as fait sans debugger?
23:40 < Jes> (la version PSX)
23:40 < cvoila> oui, sans débugger
23:40 < Jes> ah
23:41 < |Pixel|> je l'ai fait sans debugger non plus, hm
23:41 < Jes> respect :)
23:41 < cvoila> je ne connais meme pas le jeu
23:41 < cvoila> je l'ai vu tourner une fois chez pix
23:41 < Jes> :D
23:42 < cvoila> le debuggeur, c'est vraiment une nouveauté pour moi, ces dernières années (meme pour les binaires windows)
23:42 < cvoila> j'ai trop l'habitude d'analyser du code que je ne peux de toute façon pas executer
23:43 < |Pixel|> tsé Jes
23:43 < |Pixel|> il n'y a que PE que j'ai fait en mode "je démonte le binaire dans un débugger"
23:43 < |Pixel|> tout le reste c'est de l'offline
23:46 < Jes> et en offline tu t'y prends comment en dehors d'ouvrir l'iso (ou tel ou tel fichier) dans un éditeur hexa et te creuser les méninges?
23:46 < Jes> ida et FLIRT?
23:47 < |Pixel|> j'ai fait VP et Xeno sans meme lancer IDA
23:47 < cvoila> l'editeur hexa est vraiment mon ami
23:47 < Jes> c'est beau :)
23:47 < |Pixel|> tsé, quand tu regardes
23:48 < |Pixel|> la façon dont j'ai redémonté la structure de Chrono à la volée là au dessus
23:48 < cvoila> moi, j'ai lancé IDA pour VP, pour trouver l'implémentation officielle du cryptage
23:48 < |Pixel|> en utilisant 12 bytes et 3 copiers/collers de commandes cd-tool
23:48 < Jes> oui oui, mais là c'est relativement "clair"
23:48 < |Pixel|> oui mais
23:49 < |Pixel|> Baha bloquait dessus pendant 3h
23:49 < Jes> baha fait beaucoup d'effort et progressera encore ;)
23:49 < |Pixel|> j'ai vu les 12 octets, et il m'a fallu environ 8s pour deviner, sans calculatrice
23:49 < Jes> ^^
23:49 < cvoila> c'est aussi une question d'expérience
23:50 < cvoila> on a tous un passé en bricolage informatique
23:50 < |Pixel|> je crois que c'est surtout un soucis avec les 95% des programmeurs
23:50 < |Pixel|> j'ai remarqué que les programmeurs en général ne s'intéressent pas de savoir comment le code qu'ils tapent en C se retraduit au final
23:50 < |Pixel|> et du coup, n'ont pas tant de notion que ça de "structure sans information"
23:51 < cvoila> souvent, on se pose la question : "si je devais coder ce truc, comment je m'y prendrais..." et bien souvent, c'est la méthode que les développeurs utilisent dans le jeu à hacker
23:51 < |Pixel|> voilà
23:51 < |Pixel|> la plupart des hackers que je vois sont en mode *poke* *poke* *poke* pour comprendre comment ça marche
23:52 < Jes> certes, de là à démonter un chiffrement à l'oeil nu ;)
23:52 < |Pixel|> des gens comme cvoila et moi sommes des *programmeurs* qui ont toujours essayé de comprendre comment ça se retraduit au final
23:52 < |Pixel|> mais
23:52 < |Pixel|> regarde l'index crypté de VP
23:52 < |Pixel|> je l'ai littéralement claqué à l'oeil nu
23:53 < cvoila> moi, j'ai une technique proche de celle de |Pixel| pour repérer les cryptages XOR à la con
23:53 < |Pixel|> cvoila a été assez borné pour désassembler et comprendre le vrai algo derrière le cryptage
23:53 < |Pixel|> mais au final, il m'a juste suffit de regarder le dump hexa de ce bloc en mode "je lis la matrice"
23:53 < |Pixel|> et j'ai vu les structure cryptées apparaître
23:53 < Jes> hé beh
23:54 < Jes> chapeau
23:54 < |Pixel|> de là a en déduire comment bruteforcer le truc, c'est simple
23:54 < cvoila> j'ouvre les fichiers "cryptés" dans mon visualiseur d'image
23:54 < |Pixel|> oui, c'est aussi un bon truc
23:54 < |Pixel|> en fait, il a raison
23:54 < Jes> tu regarde la distribution des bytes? o_O
23:54 < cvoila> ca aussi
23:54 < |Pixel|> non
23:54 < Jes> +s
23:54 < |Pixel|> c'est pas tant la distribution
23:55 < |Pixel|> quand on regarde l'image je veux dire
23:55 < cvoila> à l'oeil, on peut déterminer le type de données rien qu'en voyant la représentation graphique
23:55 < |Pixel|> le coup de regarder par image consiste à visualiser des patterns, des sortes de "vagues" dans le flux d'octets
23:55 < |Pixel|> moi c'est ce que je fais quand je regarde un dump hexa
23:55 < |Pixel|> je ne lis pas les chiffres
23:55 < |Pixel|> je regarde le dessin qu'ils forment
23:55 < cvoila> voila
23:56 < |Pixel|> un exemple simple:
23:56 < |Pixel|> je vais tenter de le montrer ici
23:56 < Jes> oui, mais c'est relativement évident quand c'est des pointeurs, ou ce genre de conneries
23:56 < Jes> mais quand c'est "crypté"
23:56 < Jes> en théorie un bon chiffrement est sensé caché tout pattern
23:56 < Jes> -é +ert
23:56 < Jes> -t
23:56 < Jes> grumbl
23:56 < cvoila> "bon chiffrement"
23:56 < |Pixel|> oui
23:56 < Jes> tu peux plus rien reconnaître, le flux est comme un truc tiré au hasard
23:56 < cvoila> justement là, c'est un MAUVAIS
23:56 < |Pixel|> le chiffrement de VP est une blague
23:57 < |Pixel|> le mec qui a designé cet algo peut se tirer une balle
23:57 < Jes> ah
23:57 < Jes> bein n'empêche
23:57 < Jes> respect :)
23:57 < |Pixel|> regarde
23:57 < |Pixel|> je vais te montrer
23:57 < |Pixel|> (tenter)
23:58 < cvoila> c'est un peu ce que je disais l'autre jour sur les nouvelles consoles... maintenant, c'est tellement simple de crypter en RSA que les cryptages simples type "XOR" sont vraiment en voie de disparition
23:58 < |Pixel|> au fond, RSA est du XOR à la fin, hm
23:59 < Jes> et pourquoi rsa?
23:59 < Jes> pourquoi un cryptage asymétrique?
23:59 < cvoila> oh, je disais RSA car j'avais la PSP en tete
23:59 < |Pixel|> la PSP est un cryptage asymétrique
23:59 < |Pixel|> et la PS3
23:59 < |Pixel|> c'est pas du RSA
23:59 < |Pixel|> c'est "MagicGate"
23:59 < |Pixel|> truc sony
23:59 < Jes> oui mais tu parles de la signature digitale?
23:59 < |Pixel|> non
23:59 < |Pixel|> le cryptage est asymétrique
00:00 < |Pixel|> et la raison est totalement évidente
00:00 < |Pixel|> je te laisse réfléchir sur la question 2 minutes
00:01 < |Pixel|> http://static.grumpycoder.net/pixel/index.bin pour l'index de VP crypté
00:02 < Jes> mmmh
00:02 < |Pixel|> 00000000  05 01 7e 7d bd 89 bc 37  19 54 56 c3 f5 36 be de  |..~}...7.TV..6..|
00:02 < |Pixel|> 00000010  c1 99 67 f8 9d 65 d0 93  79 62 a8 2f 55 68 c2 eb  |..g..e..yb./Uh..|
00:02 < |Pixel|> 00000020  21 70 c2 8a bf 1b d4 73  1b 62 83 0f f7 e8 4b 8b  |!p.....s.b....K.|
00:02 < |Pixel|> 00000030  c3 77 48 06 9f d6 4f 91  7b 35 4f 28 57 11 46 e3  |.wH...O.{5O(W.F.|
00:03 < Jes> j'avoue que je ne distingue rien là-dedans
00:04 < |Pixel|> voyons en 32 bytes par ligne
00:04 < Jes> enfin
00:04 < Jes> mouais
00:04 < |Pixel|> 05 01 7e 7d bd 89 bc 37 19 54 56 c3 f5 36 be de c1 99 67 f8 9d 65 d0 93 79 62 a8 2f 55 68 c2 eb
00:04 < |Pixel|> 21 70 c2 8a bf 1b d4 73 1b 62 83 0f f7 e8 4b 8b c3 77 48 06 9f d6 4f 91 7b 35 4f 28 57 11 46 e3
00:05 < |Pixel|> 23 7d 57 be bf c9 4e 59 1b 14 69 70 f7 72 64 0b c3 d9 f9 86 9f 24 5d 10 7b 23 b3 ab 57 2b 8b 67 
00:05 < |Pixel|> 23 33 e9 33 bf 1b 4b cf 1b 62 82 ca f7 e8 92 c4 c3 77 a3 d6 9f d6 f0 e07b 35 0a ba 57 10 54 55
00:05 < |Pixel|> on voit des patterns apparaître
00:05 < Jes> ah oui tiens
00:05 < Jes> indeed
00:06 < |Pixel|> les patterns disent:
00:06 < |Pixel|> bd -> bf -> bf -. bf
00:06 < |Pixel|> ou
00:06 < |Pixel|> 19 -> 1b -> 1b -> 1b
00:06 < |Pixel|> ou encore
00:06 < |Pixel|> f8 -> 06 -> 86 -> d6
00:06 < |Pixel|> ce qui fait fortement penser à des bits qui flippent
00:06 < |Pixel|> donc "xor"
00:06 < |Pixel|> avec une clef qui fait dans les 32 octets
00:06 < |Pixel|> voyons à la fin du fichier:
00:07 < Jes> y a beaucoup de 555555 qui se répète à la fin
00:07 < Jes> +nt
00:07 < |Pixel|> 21 77 bc 33 bd 5f 13 cf 19 26 e2 ca f5 ac f1 c4 c1 33 c5 d6 9d 92 98 e0 79 71 7e ba 55 55 55 55
00:07 < |Pixel|> hypothèse: c'est du XOR
00:07 < |Pixel|> hypothèse: c'est un fichier "simple" crypté avec une clef "xor" de longueur 32
00:07 < |Pixel|> hypothèse: le fichier est paddé avec des 0
00:07 < |Pixel|> conclusion: les derniers 32 octets sont 0 XOR key
00:08 < |Pixel|> donc la "clef" est 21 77 bc 33 bd 5f 13 cf 19 26 e2 ca f5 ac f1 c4 c1 33 c5 d6 9d 92 98 e0 79 71 7e ba 55 55 55 55
00:08 < Jes> wow :)
00:08 < |Pixel|> test: appliquer bytes xor (ce bloc de bytes sur tout le fichier)
00:08 < |Pixel|> et voila comment j'avais claqué l'index de VP à l'époque
00:09 < |Pixel|> en fait, je dis une connerie
00:09 < |Pixel|> quand tu regardes la fin du fichier
00:09 < |Pixel|> tu as des altérations différentes
00:09 -!- Irssi: Pasting 5 lines to #bleargh. Press Ctrl-K if you wish to do this or Ctrl-C to cancel.
00:09 < |Pixel|> 00004f80  21 39 28 64 bd 8d af 37  19 50 27 c3 f5 36 be de  |!9(d...7.P'..6..|
00:09 < |Pixel|> 00004f90  c1 9d 15 f8 9d 60 e9 93  79 67 ec 2f 55 6f e3 eb  |.....`..yg./Uo..|
00:09 < |Pixel|> 00004fa0  21 77 f2 a7 bd 5f c1 73  19 26 94 0f f5 ac 6b 8b  |!w..._.s.&....k.|
00:09 < |Pixel|> 00004fb0  c1 33 6b 06 9d 92 6a 91  79 71 68 28 55 55 6f e3  |.3k...j.yqh(UUo.|
00:09 < |Pixel|> 00004fc0  21 39 66 be bd 8d 7d 59  19 50 51 70 f5 36 24 0b  |!9f...}Y.PQp.6$.|
00:09 < |Pixel|> 00004fd0  c1 9d bb 86 9d 60 1b 10  79 67 fa ab 55 6f d9 67  |.....`..yg..Uo.g|
00:09 < |Pixel|> 00004fe0  21 77 bc 33 bd 5f 13 cf  19 26 e2 ca f5 ac f1 c4  |!w.3._...&......|
00:09 < |Pixel|> 00004ff0  c1 33 c5 d6 9d 92 98 e0  79 71 7e ba 55 55 55 55  |.3......yq~.UUUU|
00:09 < |Pixel|> la "clef" est tout ça en fait
00:09 < Jes> oui la clé fait 0x80 non?
00:10 < Jes> oui voilà
00:10 < |Pixel|> 256 octets en fait
00:10 < |Pixel|> hmmm
00:10 < |Pixel|> pourquoi j'avais calculé 256 ? je sais plus
00:10 < |Pixel|> ça semble 128 là vu de loin
00:10 < |Pixel|> mais bref
00:10 < |Pixel|> voilà
00:10 < |Pixel|> comme dit cvoila 
00:11 < |Pixel|> tu dois fonctionner en mode "comment ils ont fait ?"
00:11 < |Pixel|> enfin non
00:11 < Jes> oui 128
00:11 < |Pixel|> "comment je ferais ?"
00:11 < Jes> enfin c'est beau ça :)
00:11 < |Pixel|> perso, "comment je ferais" ==> utiliser un algo intelligent, mais bon
00:11 < |Pixel|> après, on peut se demander "comment je pourrais foirer mon coup ?" ou encore "comment je ferais si j'avais que des notions rudimentaires de crypto ? 
00:12 < |Pixel|> d'où mes quelques hypothèses
00:12 < |Pixel|> qui étaient presque vraies
00:12 < Jes> en effet
00:12 < |Pixel|> mais qui collait quand même
00:12 < Jes> fallait y penser
00:12 < |Pixel|> en fait, la vraie explication est plus "simple"
00:12 < |Pixel|> et d'ailleurs, en voyant le bloc, je m'en doutais
00:12 < |Pixel|> quand on regarde la fin
00:12 < |Pixel|> il y a plein de 5
00:13 < |Pixel|> 55555555 signifie simplement 0101010101010101...
00:13 < |Pixel|> or, quand on regarde plus haut
00:13 < |Pixel|> on a f5xxxxxx
00:13 < |Pixel|> 55xxxxxx
00:13 < |Pixel|> 5555xxxx
00:13 < |Pixel|> 55555555
00:14 < cvoila> graphiquement, la TOC ressemble à ca (zoomé 4x) :
00:14 < cvoila> http://cvoila.free.fr/vp_toc.png
00:14 < |Pixel|> donc on peut se dire que leur algo de génération de nombre pseudo randoms fait juste des xors avec les mêmes chiffres encore et encore, juste slidés d'un bit
00:14 < |Pixel|> ce qui est vrai, vu que l'algo que cvoila a reversé via IDA est le suivant:
00:14 < cvoila> chaque ligne faisant 128 pixel (ou octets)
00:15 < |Pixel|> http://pixel.pastey.net/114498
00:15 < Jes> cvoila: pas mal ça aussi
00:16 < Jes> ah vi
00:16 < Jes> et donc leur générateur pseudo aléatoire boucle
00:16 < Jes> rigolo
00:16 < |Pixel|> voilà
00:16 < |Pixel|> le pire
00:16 < |Pixel|> c'est que s'ils avaient fait * au lieu de ^
00:16 < |Pixel|> ça aurait été correct
00:17 < |Pixel|> (sauf que leur machin dump la clef lors du premier GetNext(), mais ça c'est un détail :P)
00:17 < Jes> aussi oui :)
00:17 < Jes> enfin
00:17 < Jes> c'est beau :)
00:17 < |Pixel|> 'fin voilà
00:17 < cvoila> ensuite, quand on sait qu'il y a du "xor" dans le cryptage
00:18 < |Pixel|> la cryptanalyse via images ala cvoila est un bon moyen, en effet
00:18 < cvoila> c'était pas compliqué d'ouvrir IDA, charger le binaire, et faire une recherche texte "eor"
00:18 < |Pixel|> voilà :D
00:18 < |Pixel|> surtout que bon
00:18 < cvoila> y'en a pas des miliers :p
00:18 < |Pixel|> c'est pas véritablement un opcode classique