jeudi, décembre 24 2009

Joyeuses Fêtes !

Mini billet pour souhaiter de bonnes fêtes à tout le monde et, puisque c'est de circonstance, je vous résume[1] la description faite sur VX Heaven du premier virus répandue à grande échelle sur un réseau informatique et en ayant notablement perturbé le fonctionnement : CHRISTMAS EXEC

Santa Claus - Creative Common by "kevindooley" on Flickr

CHRISTMAS EXEC a été écrit en 1987 (22 ans déjà...) par un étudiant de l'université de Clausthal-Zellerfield (Allemagne) dans le but de souhaiter un joyeux Noël à ses amis de l'université. A l'époque Internet tel qu'on le connait aujourd'hui n'existait pas, et le programme s'est donc répandu d'abord sur le réseau de l'université de Clausthal-Zellerfield (à mes souhaits), puis il a fuit sur le réseau de recherche européen EARNet, il a poursuivi sa folle épopée sur BitNet aux USA et a terminé sa course en paralysant VNet, un réseau privé utilisé par IBM pour communiquer avec ses fournisseurs et clients.

Rien de bien sorcier dans ce programme pourtant puisqu'il se contentait d'afficher un ascii-art de Noël ...et de s'envoyer par mail à tout les contacts qu'il trouvait sur l'ordinateur "infecté". Les guillemets autour de "infecté" sont d'ailleurs importants puisque pour s'exécuter le programme avait besoin d'être volontairement lancé par l'utilisateur (bah ouais, de la bonne vieille ingénierie sociale :) ).

Comme quoi on n'a rien inventé...et 22 ans après on trouve encore des gens capable d'exécuter n'importe quoi quand on leur demande (je pense en particulier aux codecs "indispensables" pour visionner des films interdit aux moins de 18 ans, ou encore aux super antivirus-de-la-mort-qui-tue et qui doivent absolument être installés parce qu'ils viennent d'identifier 35[2] infections différentes sur votre poste mais qu'ils peuvent vous aider à le nettoyer...)

Allez, pour conclure ce billet (et certainement l'année vu que je pars loin du net pour la fin du mois) je vous retranscrit l'ascii-art de CHRISTMAS EXEC, ça n'a pas vieillit d'un poil :) !

                    *
                    *
                   ***
                  *****
                 *******
                *********
              *************                A
                 *******
               ***********                VERY
             ***************
           *******************            HAPPY
               ***********
             ***************            CHRISTMAS
           *******************
         ***********************         AND MY
             ***************
           *******************         BEST WISHES
         ***********************
       ***************************     FOR THE NEXT
                 ******
                 ******                    YEAR
                 ******

Notes

[1] et je traduit également, si ça c'est pas trop gentil de ma part ?!

[2] Remplacez vous même pas 10D6 pour le résultat correspondant à votre ordinateur

jeudi, décembre 10 2009

Du café dans l'petit robot

Avec tous ces androids qui fleurissent un peu partout dans mon entourage ces derniers temps il fallait bien que je craque un jour ou l'autre... Première étape du craquage : je me replonge (légèrement) dans le Java[1] pour jouer un petit peu avec le SDK et les émulateurs android fournis par Google. Et comme je sens que les étapes d'initialisations d'un projets ou d'une VM sont du genre à disparaitre de ma mémoire en moins de temps qu'il n'en faut à Windows ME pour planter je me suis dit que j'allais en faire un petit billet pour ce blog, à moitié sous forme de mémo donc, histoire de conserver une trace de toutes les étapes à mener pour jeter les premières fondations d'une appli android[2]

Creative Commion - Based on the pictures by "Joi" and "DeaPeaJay" on Flickr

Téléchargement de l'environnement

Première étape : récupérer le SDK chez Google. Jusque là : facile ;) Ensuite on décompresse l'archive tar xvzf android-sdk_r3-linux.tgz. Toujours rien de compliqué jusqu'à présent. Pas d'improvisation, soyons discipliné cd android-sdk-linux && cat "SDK Readme.txt", la ligne suivante nous est donnée directement par le petit texte du Readme, ./tools/android update sdk. Ca ouvre un GUI...bon, c'est l'heure d'improviser. Visiblement le GUI permet de télécharger des composants essentiels qui ne sont pas inclus dans l'archive, par exemple ce qu'il faut pour créer des android virtuels (je me disait bien que 15M pour le tout ça faisait léger...). Je choisis un SDK pour Android 2.0 (la version la plus récente), et j'espère que ça suffira pour commencer (le bébé pèse tout de même plus de 40M et je suis en train de faire un gros emerge world à coté donc ma bande passante est assez limitée ;) )

Préparation de l'environnement

Une fois le téléchargement et l'installation (automatique) terminés on a toutes les briques de bases. Préparons tout ça pour que ça soit en état de fonctionner. Dans la fenêtre de GUI que je n'ai pas encore fermée (mais qu'on peut retrouver aisément en lançant juste ./tools/android sans arguments) je choisis le menu "Virtual Devices" et hop je clique sur "New", rien de super compliqué là, je prend les valeurs par défaut puis je clique sur "Create AVD" (Android Virtual Device). Ca a l'air d'avoir marché puisque ma VM (pardon, "mon AVD" ) apparait maintenant dans une liste de choix qui était auparavant vide. Je la sélectionne, je clique sur "Start" et là la magie s'opère : l'android virtuel démarre bien.

  • Première constatation : je n'aurai peut-être pas du laisser le skin par défaut, il est vraiment laid (mais au moins il a l'air fonctionnel, je vais sans doute m'y habituer, et rien ne dit que les autres sont mieux lol).
  • Seconde constatation : le démarrage est lent, mais alors vraiment lent ! Je pensais que sur émulateur ça irait plus vite que sur les vrais téléphones mais non (ceci dit mon pc n'est pas une machine de guerre...mais quand même). Je suppose que c'est la faute de Java, de toute façon quand quelque chose rame c'est forcément la faute de Java ;) !


Android AVD started

Hello World

Démarrer le projet

Bien, maintenant qu'on arrive à faire tourner des android virtuels, il est temps de sacrifier à l'éternelle tradition du "Hello World". Seulement voilà : je n'aime pas le Java[3], et je n'aime pas Eclipse non plus, donc je ne vais pas pouvoir suivre à la virgule près le tutoriel officiel...qu'à celà ne tienne, je vais essayer d'y coller au mieux et au moins je comprendrai sans doute un peu mieux comment ça se passe que ceux qui se contentent de cliquer sur des gros boutons Eclipse "Auto Write Code And Compile And Debug And Deploy And Become Rich" ;)
Première étape : démarrer un nouveau projet android. Pour ce faire j'aurai besoin de :

  • Connaitre ma plateforme cible (i.e. la version d'android pour laquelle je veux écrire un programme). Comme je n'en ai téléchargé qu'une (pour android 2.0, souvenez vous) je suis prêt à parier que ma cible porte le numéro "1", mais bon, vérifions tout de même : ./tools/android list targets Gagné : l'indice 1 (le seul présent) correspond bien à l'API level 5, android 2.0 :)
  • Un nom pour mon application. Je vais faire original : Hello
  • Un répertoire pour stocker mon projet (s'il n'existe pas il sera créé en même temps que le projet). Encore une fois soyons original : ~/android_hello
  • Le nom de la classe d'Activité par défaut de mon projet. Alors là ça demande une petite explication de texte : d'après ce que j'ai compris en survolant les site parlant d'android une "Activity" serait, en gros, l'équivalent d'un thread. Donc là il me demande plus ou moins le nom de la classe à lancer au démarrage de mon appli. Continuons dans l'originalité : HelloActivity
  • Le namespace du package de mon projet, comme en Java. Hop : fr.ozwald.android.hello

Une fois ces éléments décidés, plus qu'à taper la commande magique :

./tools/android create project --target 1 --name Hello --path ~/android_hello --activity HelloActivity --package fr.ozwald.android.hello

Voilà, ça semble avoir marché. En tout cas il m'a créé tout pleins de fichiers dans ~/android_hello (qu'il a créé pour l'occasion) et ne m'a sorti aucun message d'erreur. J'aime quand un plan se déroule sans accroc !

Modifier le squelette de projet

Petit coup d'oeil dans le répertoire ~/android_hello/src/fr/ozwald/android/hello/, on y trouve un fichier Java qui correspond à priori au squelette de ma toute nouvelle application (et qui est le même que celui trouvé dans le tuto officiel avec Eclipse, elle est pas belle la vie ;) ?). Plus qu'à suivre les modifications proposées par le tuto officiel afin d'obtenir le code suivant :

package fr.ozwald.android.hello;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class HelloActivity extends Activity {
   /** Called when the activity is first created. */
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       TextView tv = new TextView(this);
       tv.setText("Hello, Android");
       setContentView(tv);
   }
}

Normalement ça devrait suffire pour le Hello World.

Compiler le projet

Compilons donc la chose, en mode debug (ce qui simplifie un peu le déploiement en zappant l'étape de signature du jar mais en interdit l'exécution hors des environnement virtuels) cd ~/android_hello && ant debug. Bon...bug. M'étonnes pas venant de Java -_- Il s'emmèle les pinceaux entre les JRE et les JDK que j'ai sur mon poste. Après 5mn à trifouiller je m'en sort avec un petit emerge -uv --oneshot java-config. suivi d'un java-config -S 2 afin de redéfinir ma JAVA_HOME actuelle pour pointer sur l'un des JDK que j'ai, plutôt que sur un JRE. Reprenons : ant debug. Le script semble content puisqu'il me parle de façon polie (i.e. pas de gros "FAIL" et autres "ERRORS") et effectivement dans le répertoire ~/android_hello/bin je trouve bien un "Hello-debug.apk"[4]. Youpi :) !

Tester l'appli

Plus qu'à installer notre appli sur notre android virtuel, et le tour sera joué. Pour ce faire je redémarre mon AVD et, depuis le répertoire "tools" du SDK android, je lance l'incantation magique qui devrait installer l'appli dessus pendant qu'il fonctionne ./adb install ~/android_hello/bin/Hello-debug.apk. Je regarde à présent dans l'AVD et, miracle, une nouvelle application est là : HelloActivity (bon, pas très joli tout ça, mais on s'en fout pour l'instant). Je la lance...Ca marche :) !

Android HelloWorld
Voilà, finalement ça a presque été facile et ce post ne me servira peut être jamais tellement avoir un trou de mémoire là dessus semble peu probable, mais "sait-on jamais"... Et d'ailleurs pour conclure voici une mini astuce : à la place de compiler (ant debug) puis d'installer (adb install ~/android_hello/bin/Hello-debug.apk), vous pouvez (à condition qu'il n'y ai qu'un AVD en route) remplacer ces deux commandes par un unique ant install qui fera la compilation en debug puis l'installation à la volée. Vachement pratique ^_^ !

Notes

[1] Le Python est supporté depuis peu via le "Android Scripting Environment" mais, hélas, il ne permet pas (encore ?) de réaliser des applications complètes déployables via le market :(

[2] Oui, je ne suis pas le premier, et certainement pas le meilleur auteur, mais comme prévenu : ce billet a pour premier but de me servir d'aide mémoire pour une fois ^_^

[3] Oui je sais : ça ne se voit pas trop ;)

[4] apk c'est l'extension des applications pour android...à priori c'est des JAR ;)

mercredi, décembre 2 2009

Du python à l'oignon

Parmi les jeunes langages de scripts à la mode de nos jours on distingue assez clairement deux leaders : le python et le ruby. Le nombre de trolls velus entre ces deux langages est d'ailleurs assez impressionnant ! Personnellement j'utilise le python puisqu'il répond à tout ce que j'attend de la part d'un langage de script (je ne prétend donc pas qu'il soit mieux ou moins bien que le ruby que je n'ai juste pas testé), et quand par hasard une fonctions que j'aurai aimée n'est pas présente de base il est souvent enfantin de la rajouter comme je me propose de vous en donner un exemple dans ce billet !

Oignons - Creative Common from "ILoveButter" on Flickr

L'une des bibliothèques standards du python que j'ai apprécié le plus vite c'est la bibliothèque "urllib"[1] qui permet, entre autres choses, de récupérer une page web en une toute petite ligne de code :

urllib.urlopen("http://www.ozwald.fr").read().

Quand on compare aux dizaines de lignes nécessaires en C pour obtenir la même chose, ça donne des frissons de bonheur ! Avec cette librairie tout ce que l'on peut vouloir faire se fait très simplement : ajout de headers HTTP, lecture des headers HTTP de la réponse, passage par un proxy HTTP, etc. Seulement voilà : une fonction manque à l'appel (à mon gout), c'est la possibilité d'utiliser un proxy SOCKS :( !

Pourquoi vouloir utiliser un proxy SOCKS me direz vous ? Après tout "C'est relativement rare comme besoin et donc certainement contournable". Et bien non, là ça n'est pas contournable puisque le but du jeu c'est de faire passer notre script python par TOR, or TOR vient par défaut en tant que proxy SOCKS :)

Comment faire pour que notre script python passe par TOR du coup ? C'est enfantin : Vous télécharger socksipy, vous enregistrez le fichier que vous venez de télécharger dans le même répertoire que le script que vous voulez TORifier, et dans ce script que vous voulez TORifier vous ajoutez les 4 lignes suivantes :

import socks
import socket
socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS4,"127.0.0.1",9050,True)
socket.socket = socks.socksocket

Voilà c'est fait :) Vous avez remplacé l'ouverture de socket standard de python par celle de socksipy (qui utilise le proxy TOR que vous avez configuré), donc suite à ces 4 lignes toutes les fonctions de python qui reposent sur des socket sont TORifiées, en particulier les fonctions d'urllib qui vont lire des pages web. Alors, c'était enfantin ou pas ?

Notes

[1] Et son évolution : urllib2

jeudi, octobre 29 2009

Capilarité faciale

Hop étant très occupé ces temps-ci je vais me contenter de billets nettement plus court qu'à l'accoutumée, mais au moins ça vous laisse tout le loisir de creuser par vous même si le sujet abordé par l'un d'eux vous interpelle.

Logo lagrottedubarbu.com - Creative Common par lagrottedubarbu.com

Pour ce premier "mini-billet-parce-que-je-suis-occupé" je vais simplement parler un petit peu d’un site web que j’ai découvert récemment (je ne sais même plus où) et qui porte l’alléchant nom de "La grotte du barbu". Pour résumer c’est un geek (barbu) qui fait des vidéos sur ses bricolages et je trouve que ses vidéos font merveilleusement écho à la définition du hack que je donnais il y a quelques semaines ! Typiquement regardez la vidéo "hacker sa cuisine", c’est dans la pure lignée de l’état d’esprit de mon billet précédant.

Le site souffre néanmoins de quelques travers comme typiquement le ratio "technicité sur durée de la vidéo" que je trouve bien trop faible. Par exemple la vidéo expliquant comment monter un mini robot dure presque 25mn alors qu’il s’agit juste de coller deux piles à deux moteurs via deux boutons inverseurs…

Bref c’est un site distrayant avec un état d’esprit que j’aime bien mais qui requiert hélas beaucoup de temps pour être apprécié et dont le niveau de technicité est très faible. C’est donc plus à voir comme une petite série donnant des idées de bricolage que comme de véritables tutoriels vidéo mais moi j'aime bien. Maintenant que vous êtes prévenus entrez donc à vos risques et périls dans la grotte du barbu !

lundi, septembre 14 2009

Osez dire OUI !

Si un jour vous vous ennuyez je vous conseille de partir à la découverte d'un monde merveilleux : ls /bin/[1] Vous regardez le listing et ouvrez le man des commandes que vous ne connaissez pas, ça passe le temps et perso ça m'a pas mal distrait quand j'était à l'école. En plus les connaissances ainsi acquises se sont toujours montré payante pour moi à plus ou moins long terme....Toutes, même celle de la commande "yes" ;)

YES - Creative Common by "domib34" on Flickr

Pour ceux qui ignorent ce que fait la commande "yes" je vous offre gracieusement la description issue du man : "yes - output a string repeatedly until killed". Voilà :) ....Vous tapez "yes" et hop, le programme va cracher "y"[2] indéfiniment sur la sortie standard. Super hein :) ? C'est typiquement le genre de commande que l'on peut découvrir en listant les répertoires de son PATH et qui me laissent perplexes. Je veux dire : je comprend bien l'utilité de la chose (certainement pour répondre "oui" en boucle lors de procédures un peu chiante ou de "rm -i" incontrolable) mais de là à en faire un outil standard [3]...

Toujours est il que quand je suis tombé sur cette commande je me souviens m'être dit "bon, il FAUT que je lui trouve une utilité", et j'y suis parvenu. Je vous l'accorde elle est un peu capilotractée et on pourrait remplacer "yes" par beaucoup d'autres choses mais je la trouve tout de même pratique dans certaines situations et puis ça m'a permis de tirer profit de commandes (ou options) que j'avais découvert par des "ls /bin". Voici donc la commande, je vous laisse la lire et essayer de deviner ce qu'elle fait, je donnerai l'explication après :

yes | cat -n | head -n 6 | shuf | cut -f 1 | head -n 1 | tr -d "\t "

Pour réaliser cette ligne j'ai du découvrir l'option "-n" de la commande "cat" (que j'utilise pourtant plusieurs dizaines de fois par jour), la commande "shuf", et la commande "tr" :) Pour information toutes sont dans "/bin" (sauf "shuf") et ont donc de très vives chances d'être présentes sur presque tous les unixoïdes du monde, vous pouvez donc tester la ligne chez vous si vous n'avez pas déjà compris à quoi elle sert ;) ...Attention c'est votre dernière chance avant que je donne la solution....Plus qu'une demi ligne...Voilà : elle sert à simuler le lancer d'un dés à six faces, pratique quand on est rôliste ;) ![4]

Notes

[1] Les gourous peuvent passer à la force 2 avec /usr/bin/

[2] "y" suivi d'un retour charriot pour être précis. On peut remplacer "y" par la chaine de son choix.

[3] en tout cas il était présent sur toutes les distribs où j'ai regardé

[4] Et pour les plus taquins d'entre vous il est également possible de faire des yes "bonjour :p" | wall, ou encore des yes "salut" >> /dev/ttyX quand on est root sur une machine avec des amis dessus

- page 2 de 3 -