Quelques photos du rallye WRC de France en Alsace

Très en retard, voici quelques une des photos que j’ai prises sur l’étape « Pays d’Ormont » du rallye WRC de France, le samedi 2 octobre 2010, dans l’épingle de Grandrupt.

Par manque de temps elles sont vraiment « brutes », telles que je les ai prises, pas même recadrées. Sorry ! =)

Elles sont bien sûr réduites, histoire de pas abuser sur les temps de chargement pour ceux qui habitent dans des contrées lointaines, mais si vous voulez les originales, faites le moi savoir dans les commentaires, je vous les enverrai.

La DS3, voiture 0 cette année et future voiture de Sebastien Loeb :
La voiture 0, une DS3

Sébastien Loeb et son copilote Daniel Elena, sur Citroën C4 WRC bien sûr :
Sebastien Loeb et Daniel Elena

Les suivants de l’équipe Citroën : Sordo et Vallejo :
Sordo et Vallejo

Encore une de Sordo et Vallejo :
Sordo et Vallejo

Et les troisième (par ordre de passage) de chez Citroën : Sébastien Ogier et Julien Ingrassia :
Ogier et Ingrassia

Latvala et Anttila, sur Ford Focus WRC :
Latvala et Anttila

Et quelques autres photos assez réussies (du moins selon mes critères :D ). Remarquez la Twingo WRC, la grande classe.






L’outil cage est dans la branche principale !

Gimp Cage Tool Splash

Ça y est ! Depuis 48h maintenant, le code de l’outil de déformation par cage est dans la branche principale de Gimp ! Il sera donc, sauf surprise, inclus dans la prochaine release, la 2.8 !

Un grand merci à mon mentor, Alexia Death et à Michael Natterer (Mitch) de s’occuper de cette fusion et du nettoyage qui l’accompagne.

Vidéo de l’outil de déformation par cage

Hello,

Un internaute à fait une petite revue de mon outil de déformation par cage et l’a publié sur le site d’une communauté d’utilisateur de Gimp. C’est sur le site GimpUser.com !

L’article contient notamment une vidéo de l’outil en action !

En tout cas, ça fait vraiment plaisir de voir que la chose plait, et que c’est utile =)

Il faut vraiment que je trouve du temps pour fignoler tout ça (interface et optimisation surtout) …

Mise en place d’un serveur musical avec MPD

J’ai mis en place chez moi un serveur de musique qui devait répondre a des besoins un peu particuliers :
– fonctionnement client-serveur, le serveur devant lire la musique (il est branché sur ma chaine hifi) et les clients permettant de contrôler la lecture de la musique à distance (pas d’écran sur le serveur)
– la musique est stockée non pas sur le serveur, mais sur mon PC fixe, dans ma chambre, qui n’est pas allumé tout le temps (bon il faudra l’allumer pour lire la musique évidement :D )
– tout ça sur du Linux bien entendu, le serveur étant sous Ubuntu server 10.10 et le PC fixe sous Ubuntu 10.04

Je me suis penché vers MPD (Music Player Deamon), qui a l’avantage de répondre parfaitement à tous ces besoins :)

Pour la suite : IP du serveur : 192.168.1.8 et IP du PC fixe : 192.168.1.4, les deux sont en DHCP mais le routeur est configuré pour leur attribuer toujours la même IP.

Voilà, le contexte étant posé, on y va :)
Première étape : rendre la musique présente sur le PC fixe accessible au serveur. J’ai choisi de faire ça avec NFS, à priori une autre méthode (comme avec Samba) aurait fonctionné tout aussi bien. Le partage NFS, donc :
0) Installation des paquets « nfs-common » (nécessaire sur le client et le serveur) et « nfs-kernel-server » (nécessaire uniquement sur le serveur). Attention, ici (et uniquement ici) c’est le PC fixe qui joue le rôle de serveur puisque c’est lui qui partage la musique
1) Création du point de montage sur le serveur (donc le « vrai » serveur cette fois ci) : mkdir /mnt/jidey_musique
2) Paramétrage de NFS sur le PC fixe (donc le serveur NFS) :
– ajouter une ligne dans le fichier /etc/exports :

/home/jidey/Musique/ *(ro,fsid=0,insecure,no_subtree_check)

– ajouter ces trois lignes dans le fichier /etc/hosts.deny :

portmap:ALL
nfsd:ALL
mountd:ALL

– ajouter ces 6 lignes dans le fichier /etc/hosts.allow (adapter les IP, il faut mettre l’IP du client nfs) :

portmap: 192.168.1.8
lockd: 192.168.1.8
nfsd: 192.168.1.8
mountd: 192.168.1.8
rquotad: 192.168.1.8
statd: 192.168.1.8

3) Monter le partage nfs sur le client nfs (le serveur MPD) :

sudo mount -t nfs4 192.168.1.4:/ /mnt/jidey_musique/

NB : j’ai été au plus rapide pour la partie NFS. C’est un peu crado, et surtout automatisable (avec fstab). Je ne veux pas m’étendre sur le sujet ici, tout ce qui importe c’est d’avoir un dossier avec de la musique sur le serveur MPD.

Deuxième étape : installation et configuration de MPD sur le serveur.
L’installation est, comme souvent sur Ubuntu, simplissime : sudo apt-get install mpd
Pour la configuration, c’est à peu près du même niveau. La configuration se fait dans /etc/mpd.conf pour une configuration valable pour tous les utilisateurs (c’est notre cas) ou dans ~/.mpdconf pour une configuration personnalisée à chaque utilisateur. Voici le contenu de mon /etc/mpd.conf :

port                    "6600"
music_directory         "/mnt/musique_jidey"
playlist_directory      "/var/lib/mpd/playlists"
db_file                 "/var/lib/mpd/tag_cache"
log_file                "/var/log/mpd/mpd.log"
pid_file                "/var/run/mpd/pid"
state_file              "/var/lib/mpd/state"

user                    "mpd"
bind_to_address         "localhost"

audio_output {
        type            "alsa"
        name            "My ALSA Device"
        device          "hw:0,0"        # optional
        format          "44100:16:2"    # optional
        mixer_device    "default"       # optional
        mixer_control   "PCM"           # optional
        mixer_index     "0"             # optional
}

Notez qu’il faut créer les dossiers ci-dessus (.mpd et .mpd/playlists) s’ils n’existent pas.
Beaucoup d’autres options sont possibles, toutes sont très bien expliquées dans le fichier de configuration créé avec l’installation.
Si vous avez des problèmes de connexion avec les clients, essayez de commenter la ligne « bind_to_address « localhost »  »
Un petit restart du démon MPD et ça devrait être bon :

sudo /etc/init.d/mpd restart

Troisième étape : installation et configuration des clients. Il existe une multitude de clients compatibles avec MPD. La liste (à priori à peu près exhaustive) est disponible sur le site de MPD. Comme vous le constaterez, des clients existent pour à peu près toutes les plateforme imaginable, d’Androïd à Gnome (assez classique) en passant par la Wii…

Utiliser vi comme éditeur hexadécimal

Un petit post rapide, qui est plus un post-it pour moi qu’autre chose, mais ça peut servir à d’autres…

Vous pouvez utiliser vi (ou vim) comme éditeur hexadécimal. Pour cela, il suffit d’appuyer sur la touche Echap et d’entrer la commande suivante :

:%!xxd

Le texte est alors traduit en hexadécimal. Attention : si vous sauvegardez le texte, c’est la forme hexadécimale qui sera sauvegardée (pas très grave cela dit, il suffit de retraduire dans l’autre sens). En fait, vi traduit votre texte en caractères hexadécimaux, mais après il les gère comme un texte « normal ».

Pour traduire un texte hexadécimal en un texte « normal », c’est la commande suivante :

:%!xxd -r

Trop facile! =)

Petite étude du hack mondial

Cela fait maintenant presque 2 ans que j’ai un serveur qui tourne en (presque) continu, avec SSH sur le port par défault et fail2ban pour refouler les prétendants non désirables.

Comme fail2ban offre la possibilité d’envoyer un mail à chaque attaque, ainsi qu’un WHOIS sur l’ip de l’attaquant, il est possible de faire quelques statistiques. Voici d’abord les résultats, puis la méthode.

Résultats

Pays d’origine de l’attaque

Voici le top 10 des pays:

Pays Nombre d’attaque
Chine 974
Corée du sud 123
Inde 117
USA 100
France 44
Taiwan 42
Pérou 42
Russie 41
Allemagne 32
Hong-kong 28

Un total de 2018 informations de pays ont été extraites des 1044 mails.  Cette différence s’explique par le fait qu’une partie des WHOIS mentionnent plusieurs fois le pays (organisation, FAI, contact technique, ..). Cependant, ces informations en trop ne sont pas spécifiques à des pays en particulier, et n’impactent pas les statistiques.

Comme la Chine écrase les autres pays, ces données sont affichés de manière logarithmique sur les graphiques suivants:

On peut donc voir qu’on se fait allègrement pourrir par la Chine. Les pays les plus attaquants sont en règle générale des pays émergents et/ou très peuplés. Je pense qu’on peut attribuer la cinquième place de la France au fait que le serveur se situe sur un réseau francais (ou alors j’ai des voisins taquins).

Vous pouvez également regarder la liste complète des pays.

Nom d’utilisateur

Voici le top 10 des noms d’utilisateurs essayé par les attaquants:

Utilisateur Nombre d’attaque
test 607
admin 440
oracle 405
root 364
guest 210
user 135
sales 133
alias 131
samba 130
office 129

Un total de 9849 noms d’utilisateurs ont été extraits des mails (2581 différents).

On peut voir que les hackers visent logiquement au plus rentable. L’user root n’est cependant qu’en 4ème position, probablement car la première chose à faire sur un serveur est de désactiver l’accès root par SSH.

Vous pouvez également regarder la liste complète des noms d’utilisateurs.

Méthode

La première étape est de récupérer les mails au format texte. Comme Gmail n’offre pas de fonction d’exports, je me suis connecté à ma boite mail avec thunderbird en IMAP. Ensuite on fait une recherche avec les termes « fail2ban banned » et on exporte la selection au format eml.

La deuxième étape est d’extraire les informations. Pour ça, la ligne de commande est toute indiquée. Voici les commandes magiques:

# extraction des utilisateurs
grep -h -i ": Invalid user" *.eml | awk '{print $8}' > user &&
grep -h "Authentication failure" *.eml | awk '{print $11}' >> user &&
cat user | sort -f | uniq -ci | tr -s ' ' ';' | sed "s/^;//" | sort -nr -t ";" > user-count
#extraction des pays
grep -h -i "^country" *.eml | awk '{print $2}' > country &&
cat country | sort -f | uniq -ci | tr -s ' ' ';' | sed "s/^;//" | sort -nr -t ";" > country-count

Ici, grep pour sélectionner les bonnes lignes, awk pour récupérer le bon mot, sort et uniq pour trier et compter, et un coup de sed pour remplacer des espaces par des points-virgule pour contourner un comportement un peu étrange de sort qui considère que « 23 46″ est le nombre 2346.

La récupération des noms d’utilisateurs se fait en deux fois, car le message est différent si l’utilisateur existe réellement sur la machine.

Conclusion

Voilà, je vous laisse vous faire votre propre avis sur la chose. Personnellement, j’ai pu constater grâce à ce serveur et un autre, que changer le port par défaut de SSH, d’avoir des mots de passe complexes et d’utiliser fail2ban pour éviter les brutes forces amène à une relative tranquillité face à ces attaques. A moins bien sur de s’être fait des ennemis ou d’héberger la banque de France =)

Trick list

Voici une liste d’astuces, de techniques que j’ai apprise durant mon Summer of Code. Elle est livré un peu en vrac, et peu, ou non, vous intéresser.

Allocation mémoire avec la Glib:

allocation mémoire pour des objets:

– g_new (struct_type, nombre)
– g_renew (struct_type, ancienne_allocation, nombre)
– g_unref_object (objet)

allocation simple:

– g_malloc (nombre_d’octet)
– g_realloc (ancienne_allocation, nombre_d’octet)
– g_free (mémoire)
Les allocations avec g_malloc sont couteuse, donc si la mémoire a une taille fixe, preferez g_slice.

Coder pour Gimp

debug des gobject et erreurs glib

Lancez Gimp avec l’argument –g-fatal-warnings

debug des evenements GTK

Lorsque GTK envois un évenement (appuie d’une touche, clic souris ..), Gimp prend la main sur le gestionnaire d’entrée/sortie. Si vous mettez un breackpoint dans la gestion d’un evenement, ce gestionnaire d’evenement n’est pas rendu à GTK quand le débuggeur bloque Gimp. Résultat vous ne pouvez plus utiliser ni clavier, ni souris. Pas pratique. La solution est de compiler votre propre GTK avec l’option –enable-debug=yes, compiler Gimp avec ce GTK, et lancer Gimp avec l’option –gtk-no-grabs.

autogen.sh

Les options de compilation sont visible avec ./configure –help

compiler sans optimisation

CFLAGS=-O0 ./autogen.sh –prefix=….

installation rapide des binaires uniquement

cd app/ && sudo make install-binPROGRAMS

Gobject

les gobject, c’est mal.

si vous avec un warning relatif au gobject, essayer un make install

quelque chose cloche ? essayez un make install

Babl

Babl est une librairie qui sert à l’abstraction des différents format de pixel (RVB, CMJN, ..)

déclarer un format

babl_type (« float »)
babl_type (« u8″)
babl_format_n (babl_type (« float »), nombre_element)
Voir la doc http://www.gegl.org/babl/#Vocabulary pour voir les formats disponible. Une petite précision:
– R': gamma ajusté
– Ra: alpha pré-multiplié
<http://www.gimp.org/docs/plugin_in/appendix-alpha.html>

convertir des formats avec un Babl fish

babl_process (babl_fish, buffer_source, buffer_destination, nombre_d’element)

Gegl

creer un buffer

GeglBuffer *bfr = gegl_buffer_new (gegl_rectangle, babl_format)

buffer leak

Dans le fichier gegl/buffer/gegl_buffer.c, décommentez #define GEGL_BUFFER_DEBUG_ALLOCATION. A la sortie de Gimp, une trace d’allocation va être affiché. Vous pouvez convertir les adresses du binaire en position dans le code source avec addr2line -e app/.libs/gimp-2.7 adresse

Git

push dans une branche distante

git push origin soc-2010-cage

garder la branche à jour

git fetch origin && git rebase origin

Fin officielle

Et voilà, le summer of code est terminé, du moins officiellement.
J’ai finalement moins mis à jour le blog que je voulais. Il faut avouer qu’au bout de 2 mois à se taper la tête contre le code, la motivation faiblit un peu. Enfin, voilà les news:
Comme annoncé dans le dernier billet, j’ai travaillé sur une méthode pour inverser le calcul de la transformation (c’est à dire savoir d’où viennent les pixels, plutôt que où ils vont), ce qui permet d’avoir une bonne qualité d’image, en évitant surtout l’aliasing. Le principe est le suivant:
  • on positionne sur l’image une grille de la surface de la cage avant déformation.
  • on applique la déformation aux points de cette grille.
  • on divise chaque case de cette grille en deux triangles
  • on parcourt chacun de ces triangles, on trouve les pixels à l’intérieur, et on en déduit les coordonnées du pixel source, par interpolation.
  • on obtient donc, pour chaque pixel de l’image, à quelle coordonnée de l’image il faut piocher des pixels pour trouver l’image transformée (sampling).
Ma première approche pour le problème de l’interpolation dans les triangles a été de retrouver un sens (trouver le point le plus haut, les points droite et gauche), puis de le parcourir avec des équations de droites. Et bien c’est pas une grande idée. Il y a un tas de cas particulier, c’est compliqué et inefficace. Finalement, un ami m’a suggéré de procéder de manière récursive, c’est à dire de découper les triangles en 4, jusqu’à qu’il ne contienne plus qu’un pixel. Ensuite on interpole ses coordonnées source grâce à un système de barycentre. Et là, ça marche tout le temps, et c’est même efficace ! Merci Théophile (oui, tu as donc contribué au logiciel libre avec plus qu’un patch pour la libcaca =) ).
En fait c’est tellement efficace que ça va probablement remplacer la méthode « directe » qui sert pour l’instant de prévisualisation interactive (qui en plus est assez moche).
Voici donc à quoi ressemble le coeur de l’outil. Chaque cercle est une opération Gegl.
  • Cage_coef_calc sert à calculer, pour chaque pixel à transformer, la série de coefficient qui sert à la transformation.
  • Cage_transform calcule et inverse la transformation.
  • Render_mapping recompose l’image finale.
L’intérêt de cette architecture et de Gegl en général, c’est qu’on peux facilement réutiliser les éléments. Typiquement, le code de mon outil pourra être réutilisé assez facilement pour créer un outil dans le style du plugin iWarp.
Pour en revenir à l’essentiel, voici l’état des lieux. L’outil est globalement terminé. Par globalement, je veux dire que le coeur fonctionne correctement, et qu’il est utilisable dans une utilisation « classique ». Il reste quelque défaut de jeunesse à corriger (par exemple, il ne marche pas sur les masques de calques), peaufiner l’interface, et il sera près pour une relecture de code et l’inclusion dans la branche principale de Gimp.
Voici quelques exemples de déformation;

Ubuntu/Debian : faire le ménage dans les noyaux

Après quelques mois d’utilisation, mon grub ressemble inévitablement à ça :

grub

Oui, je fais une collection de kernels, et alors? :D
Bref, tout ça pour dire que je fini par me retrouver avec 4 ou 5 noyaux, ce qui est, d’une part, inutile, et d’autre part gênant quand il faut commencer à scroller pour attendre la ligne « Windows » tout en bas de la liste (ok, je n’ai qu’à pas utiliser Windows, mais c’est pas la question :p ). Il y a bien la méthode crade d’adapter simplement grub, mais c’est quand même plus propre de supprimer tous ces noyaux inutiles. Voici comment faire.

Lister tous les noyaux installés

dpkg -l | grep linux-image
ii  linux-image-2.6.31-19-generic        2.6.31-19.56                               Linux kernel image for version 2.6.31 on x86
ii  linux-image-2.6.31-20-generic        2.6.31-20.58                               Linux kernel image for version 2.6.31 on x86
ii  linux-image-2.6.31-21-generic        2.6.31-21.59                               Linux kernel image for version 2.6.31 on x86
ii  linux-image-2.6.31-22-generic        2.6.31-22.60                               Linux kernel image for version 2.6.31 on x86
ii  linux-image-generic                  2.6.31.22.35                               Generic Linux kernel image

On voit à la fin le paquet générique du kernel. Il ne faut pas le supprimer.

En théorie, à chaque paquet « linux-image » est associé 2 paquets « linux-headers ».

dpkg -l | grep linux-headers
ii  linux-headers-2.6.31-19              2.6.31-19.56                               Header files related to Linux kernel version
ii  linux-headers-2.6.31-19-generic      2.6.31-19.56                               Linux kernel headers for version 2.6.31 on x
ii  linux-headers-2.6.31-20              2.6.31-20.58                               Header files related to Linux kernel version
ii  linux-headers-2.6.31-20-generic      2.6.31-20.58                               Linux kernel headers for version 2.6.31 on x
ii  linux-headers-2.6.31-21              2.6.31-21.59                               Header files related to Linux kernel version
ii  linux-headers-2.6.31-21-generic      2.6.31-21.59                               Linux kernel headers for version 2.6.31 on x
ii  linux-headers-2.6.31-22              2.6.31-22.60                               Header files related to Linux kernel version
ii  linux-headers-2.6.31-22-generic      2.6.31-22.60                               Linux kernel headers for version 2.6.31 on x
ii  linux-headers-generic                2.6.31.22.35                               Generic Linux kernel headers

Suppression des noyaux inutiles

Il est recommandé de conserver les 2 noyaux les plus récents (le plus récent pour une utilisation courante, l’autre en cas de problème sur le dernier noyau). Dans mon cas, je veux donc supprimer les versions 2.6.31-19.56 et 2.6.31-20.58 du noyau.
Ensuite, tout se fait classiquement avec apt-get et son option –purge :

sudo apt-get remove linux-image-2.6.31-19-generic linux-headers-2.6.31-19 linux-headers-2.6.31-19-generic linux-image-2.6.31-20-generic linux-headers-2.6.31-20 linux-headers-2.6.31-20-generic --purge

Grub sera (normalement) mis à jour automatiquement.

Sortir du prototype

Hello,

Un peu de nouvelle par ici. Depuis quelques jours, j’ai pas mal discuté avec mon mentor et les développeurs de Gimp. Je suis arrivé à une étape de mon projet où une bonne partie des choses marche. L’idée est maintenant de passer du prototype à une version plus propre et efficace. Dans mon cas, comme j’ai beaucoup bricolé, ça veut dire quasiment une réécriture. Le fond est bon, mais la forme beaucoup moins. Cependant, ce travail est assez rapide et a déjà bien avancé.

Parallèlement à ça, j’ai commencé un algorithme qui permettra de calculer la transformation inverse. Je m’explique. Dans la majorité des opérations de transformation, c’est la transformation inverse qui est utilisée (on parcourt l’image cible, et on va chercher les pixels qui doivent être à cet endroit). Ça permet d’obtenir une bonne qualité d’image, en évitant notamment l’aliasing. Le problème dans mon cas, est que les coordonnées de Green, qui servent de base à ma transformation, ne décrivent qu’une transformation dans le sens direct. On obtient donc des images comme celle de mon dernier post. Il est possible de tricher, mais ça reste pas l’idéal. L’idée ici, c’est de calculer la transformation directe, de voir où ça va, et d’interpoler pour chaque pixel cible la position dans la source. Ça peut paraitre simple, mais en fait, pas vraiment. Mais ça progresse !