Victor STINNER a écrit 1639 commentaires

En comparaison de WinDev, Python Card est affreusement moche. Mais je ne connais ni l'un, ni l'autre, donc difficile de bien les comparer.

Pendant très longtemps j'ai entendu parler de WinDev sans savoir ce que c'était. Alors je me suis renseigné et j'ai rédigé cet article :
http://www.haypocalc.com/blog/index.php/2007/11/07/83-pc-sof(...)

Je pense que tu y trouveras quelques infos intéressantes.

Pour avoir des retours d'utilisateurs, je te conseille le newsgroup officiel :
http://groups.google.com/group/fr.comp.developpement.agl.win(...)

Je ne sais pas pour quelle société tu travailles. Pour quels raisons vous vous prenez des procès ? En France, le dernier procès (au sujet de la sécurité informatique) dont j'ai entendu parlé c'était un chercheur en sécurité qui a publié une faille dans un anti-virus. Il a perdu parce qu'il n'avait pas de licence de l'anti-virus (rah le con !).

censure par LCA

C'est qui / quoi LCA ?

MS c'est un peu l'elephant dans le couloir, une cible ideale

Je ne vois pas ce que tu veux dire par cette phrase. Microsoft est la cible des pirates car Microsoft c'est +90% des ordinateurs sur Terre... La moindre faille affecte direct 90% de la Terre (enfin, très grossièrement).

Je crois que cette discussion est un peu la discussion que bien d'autres ont eu sur « pour ou contre la sécurité par l'obscurité ».
http://fr.wikipedia.org/wiki/Sécurité_par_l'obscurité

Perso j'ai fait mon choix. Dans un de mes articles récents je parle de bugs trouvés dans le générateur de nombres pseudo-aléatoires de Netscape Navigator qui était à l'époque un logiciel propriétaire. Des chercheurs ont fait pareil pour Linux et Windows (et ont trouvés des bugs, dans les deux OS). La sécurité par l'obscurité est un leurre : on pense être à l'abris alors qu'en fait ça change rien...
http://www.haypocalc.com/blog/index.php/2007/12/02/96-bugs-g(...)

Bah pour un compilateur, le mieux est (comme GCC le fait, sauf si --ffast-math est utilisé) de ne pas chercher à « optimiser ». C'est au programmeur d'ordonner ses opérations.

nicO se demandait pourquoi faut il de la précision et quel est l'impact de la précision. Hé bien durant mes études j'avais écrit un algorithme pour trouver les zéros de polynômes de n'importe quel degré. Le but étant d'intégrer des fractions rationelles (j'étais jeune et fou).
http://www.haypocalc.com/wiki/Projet_AC20

Et bien à partir de polynômes du 10e degré, je commençais à bien sentir les erreurs d'arrondi, l'algorithme ne fonctionnait plus. À force d'enchaîner les opérations, on perd petit à petit en précision pour finalement être totalement imprécis. À partir du 20e degré (je me souviens plus bien), l'algo marchait plus du tout.

Dans la publication suivante, les auteurs de MPFI expliquent que si l'intervalle grossit trop, ils refont le calcul avec une précision supérieure (précision pour l'intervalle du résultat). Genre on calcule a + b avec une précision de 10 chiffres, si lle résultat est trop gros, on calcule avec 20 chiffres.
http://www.cs.utep.edu/interval-comp/interval.02/revo.pdf

Ceci n'est possible qu'en utilisant une bibliothèque (MPFR) offrant une précision variable. Les flottants IEEE ont une précision fixe (32, 64, 80 bits).

Le papier explique également que MPFI marche parce que MPFR réalise un arrondi exact : calculer 1 - 9e-10 avec une précision de 4 chiffres donne 0,999 et non pas 1,000 comme le fait Mapple IntPack (c'est un exemple simplifié pour illustrer le problème d'arrondi)... Si j'ai bien compris IntPack utilise les nombres IEEE et pas une bibliothèque du type MPFR à précision variable justement.

Extrait du papier : « It can be noticed that the rule of thumb “to get more digits, one has to increase the computing precision by roughly the same number of digits” can fail, for instance when computing a square root or more generally a 1/n-th power close to 0. However, the rule of thumb becomes in such cases “to get α more digits, one has to increase the computing precision by roughly nα digits”. In other words, in most cases an increase in the computing precision yields an improved accuracy on the results. »

poursuivi devant un tribunal par un gars qui se serait fait piquer ses donnees ou autre grace a une faille trouvee par un de nos softs.

Je ne connais pas la législation, mais ça me semble tiré par les cheveux que ça soit l'auteur du logiciel qui est mis en cause plutôt que la personne qui l'a utilisé à des fins malicieuse. On peut faire le parallèle avec les hébergeurs de contenu Internet qui sont mis hors de cause par la LEN : c'est les personnes qui publient le contenu qui sont à juger. Corrigez moi si je dis une bétise.

D'autres que toi publient déjà des fuzzers. Tu en trouves à foison sur Internet. Moi même je viens de publier Fusil :-) Google a publié plusieurs fuzzers récemment (avec le nom de leurs auteurs !!!). Je ne vois pas ce qu'on pourrait reprocher à Google. Je prend l'exemple de Google car c'est une société qui engage sa responsabilité en offrant au public des armes de destruction massives :-)

Quand un bug est trouvé, il y a plusieurs manières de réagir. Beaucoup de personnes (morales ou physiques) contactent l'éditeur et attendent que le bug soit corrigé avant de publier la faille.

Je pense plutôt qu'en offrant au public des outils de Q&A (car c'est avant tout de l'assurance qualité), les développeurs seront plus tentés eux-même d'utiliser ces outils. Si aucun outil n'est disponible, comment font les développeurs pour trouver des bugs ? Ils attendent que les pirates publient anonymement des exploits ?

Il existe le type Decimal en Python qui calcule en base décimale, ce qui évite les erreurs de conversion base 2^n <=> 10^n plutôt désagréables. La précision est paramétrable :
http://docs.python.org/lib/module-decimal.html

Voir les publications d'IBM pour les calculs en décimal :
http://www2.hursley.ibm.com/decimal/decarith.html

Salut,

Comment s'écrit un code ? Par essais erreurs ? On doit évaluer "à la main" les fuites de précision et écrire l'algorithme en conséquence ?

Il existe quelques règles que je ne saurai énoncer exhaustivement. Exemple : ne pas utiliser d'opérande sur un petit et un grand nombre (1 + 10^100 est crétin). Il faut réordonner une fonction en conséquence. Exemple pratique : résolution d'une équation du 2e degré :
http://fr.wikipedia.org/wiki/%C3%89quation_du_second_degr%C3(...)

J'imagine que c'est la démarche des codes scientifiques pour éviter d'utiliser des nombres étendus plus lent.

Euh, les éviter je sais pas, c'est très pénible de calculer en virgule fixe (avec des nombres entiers). Il existe un décodeur Ogg/Vorbis en virgule fixe, mais je vois pas le rapport, on s'aggare :-)

changer l'ordre des opération pour la vitesse

Je ne vois pas en quoi l'ordre change la vitesse. Utilise des SIMD ou non, ça change les perfs oui. Mais on ne change pas l'ordre du calcul. On reformule pour permettre la vectorisation. Au passage, les derniers gcc vectorisent tout seul !

Sachez que GCC ne modifient pas les calculs sur les flottants car justement l'ordre des opérandes joue énormément sur la précision du résultat. Il ne pas simplifier x*2.0/2.0 par exemple.

D'ailleurs comment choisi-t-on d'utiliser un type d'arrondi plutôt qu'un autre ?

Selon le résultat attendu ?

Quel est l'intérêt de gérer les NaN ou les infinis qui ralentissent tellement un code c ?

Les gérer ? Comment ça ? Il suffit de vérifier à la fin qu'on n'a pas de NaN, -INF ou INF je pense. Si on sait ce qu'on fait, on ne trimballe pas de NaN.

--

Pour aller un peu plus loin, il existe la bibliothèque MPFR :
http://www.mpfr.org/

Enfin, un bilbliothèque qui calcule sur des intervalles : MPFI stands for Multiple Precision Floating-point Interval library.
http://perso.ens-lyon.fr/nathalie.revol/software.html

Une machine de 252 noeuds donne combien d'images par seconde à Quake ?

Plus sérieusement : quels applications tournent là-dessus ? Vous avez des benchmarks comparatifs avec des gros calculateurs ? Est-ce prévu pour pouvoir faire tourner Apache et MySQL par exemple (faut-il des processus ou des threads) ?

D'autres l'ont déjà fait et ça marche effectivement très bien :-) Un exemple parmis d'autres (date de 2005) :
http://seclists.org/vuln-dev/2006/May/0004.html

Mais c'est plus drôle quand ça touche le serveur quand même (hop, je balance un collègue) :
http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2007-5300

J'en profite pour demander si il existe de bon outils pour faire du fuzzing sur du XML.

Je connais le projet untidy, mais juste de nom, je ne l'ai pas testé (le logo est plutôt parlant) :
http://untidy.sourceforge.net/

À priori, cet outil teste la conformité des parseurs XML (comme libxml2 et Firefox) et non pas du contenu.

Effectivement, un générateur de XML valide pourrait être rigolo.

cykl : si tu connais un projet libre qui mange du XML en entrée et qui est simple à scripter en ligne de commande, je peux voir ce que je peux faire.

Pour éviter que ces pourris de BSD et de capitalistes propriétaires puissent profiter de ces logiciels.

Ca m'intéresserait d'avoir des sources à ce sujet (articles, emails, benchmarks, etc.). En même temps, glibc 2.7 c'est pas pour tout de suite :-)

Un truc que je me demandes, pourquoi est-ce que tu as ecris ton propre framework plutot qu'utiliser/etendre un des framework connus, genre Peach qui est en python aussi ?

Hum hum, bonne question. Réponse officielle :

« Contrairement à ce que laisse penser le mot « framework », chaque outil est spécialisé dans un domaine. PROTOS est dédié au fuzzing réseau, zzuf vise l'attaque des parseurs de fichier, sysfuzz vise uniquement les appels systèmes noyaux (mais multi-OS, déjà pas mal), etc. » (hum, il me semble que zzuf peut aussi injecter des erreurs dans une socket)

Réponse honnête :

« J'aime programmer et je redéveloppe mon propre outil pour comprendre comment ça marche. À la limite, je passe plus de temps à peaufiner l'outil lui-même qu'à l'utiliser. Je suis un passionné de la technique. »

La bonne réponse est un mélange des deux. Fusil est un ensemble d'outils pour fabriquer vite fait un projet de fuzzing quel qu'il soit, bien qu'aujourd'hui les projets d'exemples sont peu variés. Je vise des scénarios complexes impliquant beaucoup d'agents avec beaucoup d'interactions. Et j'ai écrit un framework comme ça l'ajout d'une fonctionnalité dans Fusil va bénéficier à tous les projets utilisant Fusil. Genre là j'ai fait en sorte qu'en cas de succès, tous les fichiers impliqués dans la session soient sauvés. Et bien, tous les projets bénéficient de ce plus.

Je ne veux pas te decourager, mais developper un framework complet

Hé bien, tout dépend de ce que tu veux dire par « complet ». Je trouve qu'avec le version actuelle (dans un moment de folie aujourd'hui, j'ai tagué une version 0.5, allez hop) on peut déjà faire beaucoup de choses.

Pour la suite, je vais voir comment contrôler des programmes graphiques et aussi des programmes sur une autre machine.

Pour les personnes intéressées par la gestion de la mémoire, je vous conseille la lecture de mon billet où je parle des évolutions de malloc() adaptés aux processeurs multi-coeurs :
http://www.haypocalc.com/blog/index.php/2007/11/08/87-gestio(...)

Je pense que plus de 70% des failles de sécurité sont trouvées avec la technique du fuzzing. Il suffit de voir quels outils ont été utilisés pour les Month of Kernel/PHP/Browser bugs. Voir aussi :
http://secunia.com/historic_advisories/

J'ai lancé une campagne de fuzzing et j'ai trouvé divers bugs plus ou moins graves. J'ai écrit un patch, mais les auteurs de la bibliothèque Tremor ne s'en soucient pas.
https://trac.xiph.org/ticket/1254

Il reste d'autres bugs non corrigés.

Pourquoi ne pas lui demander tout simplement plutôt que de supposer des choses et faire planer le doute ?

« [Salaire] De 3000 à 3400 euros par mois, primes comprises. (...) Le salaire maximum, primes comprises, est de 40 800 euros par an. » Je suppose qu'on parle en net. Et bien, pour 12 × 3400 ma calto donne 40800... Quel hasard.... Mais alors, il n'a aucune prime le mec ? Pourtant, les primes ne sont pas comptées dans le salaire normalement, ou bien ? Le document officiel SNCF confirme que les primes existent, donc où est passée sa prime de fin d'année par exemple ?

Le document est rempli de « comme dans de nombreuses autres entreprises ». Je suppose qu'il faut lire « entreprises publiques », car je suis dans le privé et je n'ai qu'une très faible proportion des avantages qu'ils ont, alors qu'à la SNCF ils cumulent tous les avantages.

« [ Retraite à ] 50 ans pour les conducteurs uniquement et 55 ans pour tous les autres cheminots » Je trouve ça inégalitaire avec d'autres boulots bien plus pénibles (BTP, travail à la chaîne, etc.). C'était pour dire que je suis opposé à cette nouvelle grêve de la SCNF.

Je ne sais pas si c'est lié, mais Leo Dorrendorf a publié un papier sur les faiblesses de l'algorithme de génération de nombre aléatoire de Windows 2000 :
http://www.heise-security.co.uk/news/98934

Auteur de l'outil, je vous conseille de l'essayer : « apt-get install python-hachoir-urwid » puis « hachoir-urwid image.raw ». Exemple avec « sudo hachoir-urwid /dev/sda » (hachoir-urwid ne permettant pas l'édition, aucun risque de perdre des données) :

0) file:/dev/sda: MS-DOS hard drive with Master Boot Record (MBR) (55.9 GB)
+ 0) mbr (512 bytes)
512) padding[0] (31.0 KB)
32256) partition[0]: Linux (ext2/ext3) (243.1 MB)
- 254983680) partition[1]: Extended (55.7 GB)
+ 0) mbr (512 bytes)
512) padding[0] (31.0 KB)
32256) partition[0]: Linux (ext2/ext3) (55.7 GB)

(touche 'a' pour afficher les offests abolus et non pas relatif et 'v' pour cacher les valeurs pour que ça soit plus lisible)

Ah ouais super, à quand le ducktyping en brainfuck?

Haypo (qui retourne à son code Python en rigolant tout seul)

Sinon, c'est très marrant :D

J'adôôôôôôôôre les Geekscottes ! À quand les T-Shirts, tasses, tapis de souris et autres produits dérivés ?

( Pour information, Ubuntu Gutsy préinstalle Gimp 2.4.0rc3. J'espère que la version finale sera rapidement disponible pour Ubuntu. )

Vivement que la série de développement 2.5 démarre.

Vivement que Gimp se rapproche de GEGL, ce qui ne semble pas encore être le cas :-(
http://www.gegl.org/

GEGL est un moteur de rendu d'image qui gère tous les formats de pixel possibles et imaginables : RVB, CMJN, CIE Lab, (...) ; précision de 8 / 16 bits, entier ou flottant, par composante de couleur. GEGL gère de manière transparence (via babl) la conversion d'un format à l'autre. Il intègre déjà bon nombre de fonctionnalités de Gimp.

GEGL est surtout impressionant dans sa capacité de traiter des images énormes (200.000 x 200.000 pixels ou plus), images plus grosses que la RAM ! GEGL permet de réaliser un rendu d'une partie de l'image finale.

GEGL est déjà et fonctionnel, il existe des bindings pour C, C#, Ruby et Python. C'est une bibliothèque qui n'attend qu'à être utilisée. Des petites programmes l'utilisant existent déjà.