Il existe plusieurs solutions plus ou moins efficace pour ce problème (comme par exemple la virtualisation), mais aujourd’hui je vais parler de Spoon (anciennement connu sous le nom de Xenocode).

Le principe de Spoon

Spoon est une sandbox permettant de lancer des applications directement à partir du web. Une fois le plugin installé, il suffit de cliquer sur une application à partir de leur site pour la lancer.

Navigateurs proposés

Actuellement, les navigateurs proposés sont les suivants  :

• Internet Explorer ( version 6, 7 et 8 )
• Firefox ( version 2, 3, 3.5 )
• Safari ( version 3 et 4 )
• Chrome
• Opera ( version 9 et 10 )

Exemple d’utilisation : Internet Explorer 6 sous Spoon

Voici un exemple d’utilisation d’Internet Explorer 6 sous Spoon à partir d’une machine ne l’ayant pas. Cela aura pris au total à peine une minute pour avoir le navigateur opérationnel.

A savoir que Spoon ne fait pas que dans les navigateurs, et propose un large choix d’application en sandbox, tel que ThunderBird, Notepad++, Office, ou même différent jeux.

Dans ce tutoriel, j’expliquerais comment générer un couple de clef publique/privée, sous linux et sous windows (à l’aide de putty), puis je montrerais comment déployer la clef sur un serveur distant pour permettre  l’accès à la machine sans avoir besoin de tapper son mot de passe à chaque connexion.

Sous Linux

Il faut tout d’abord installer le package openssh si celui-ci ne se trouverait pas encore sur la machine client :

apt-get install openssh-client

• Génération de la clef

La génération se fait ensuite facilement via la commande suivante :

ssh-keygen -t rsa -C <commentaire>

Le terminal demande ou générer la clef ( avec comme chemin par default ~/.ssh/id_rsa ), puis demande de rentrer une passphrase (il est évidemment très important de ne pas la laisser vide, sans quoi tout le monde pourrait se servir de votre clef).

Le commentaire est optionnel, mais il est judicieux d’en mettre un, afin de reconnaitre sa clef (surtout si l’on est amené à en utiliser plusieurs)

• Mémorisation de la clef

Une fois la clef générée, il faut indiquer à l’agent SSH de s’en servir lors des connexions. Cela se fait via la commande ssh-add :

ssh-add

Si vous avez laisser le chemin par default ( ~/ssh/ ), l’agent va chercher automatiquement dans ce dossier toutes les clefs disponibles et vous demande, pour chacune d’elles, sa passphrase. Si jamais vous avez enregistrer votre clef ailleurs, il suffit de specifier le chemin à la commande :

ssh-add /chemin/vers/ma/clef

Une fois vos clefs mémorisées par l’agent, celles-ci seront automatiquement utilisées lors de tentative d’identification SSH. Attention cependant, en cas de redémarrage, il est nécessaire de relancer la commande ssh-add.

Sous window (via Putty)

Sous windows, l’agent de connexion le plus fréquemment utilisé reste Putty. Il faut donc télécharger le logiciel ( par ici ). Attention, bien prendre l’installeur windows et non pas seulement l’exécutable putty.exe, sans quoi les outils de générations ne seront pas disponibles.

• Génération de la clef

La génération se fait via l’utilitaire PuttyGen :

Laissez la configuration par defaut ( SSH-2 RSA de taille 1024 ) et cliquez sur “Generate”. Bougez la souris comme un forcené pour générer la partie aléatoire de la clef, puis une fois la manipulation finie, rajoutez votre commentaire, entrez votre passphrase, puis enregistrez le couple ainsi généré ( save public key puis save private key ).

Putty n’utilisant pas exactement le même format de clef que sous linux, il est égalemment possible d’importer une clef généré sous cet OS pour permettre à Pageant de s’en servir (Conversion -> Import Key).

• Mémorisation de la clef

La mémorisation de la clef se fait via l’outil Pageant : lancez Pageant, puis cliquez sur “Add key”. Il vous est alors demandé la passphrase de la clef.

Une fois celle-ci validée, Pageant rajoute la clef à la liste de celles que pourra utiliser putty.

Dépot de la clef sur le serveur

Il faut ensuite déposer la clef publique (et bien la publique, la privée doit rester sur la machine à partir de laquelle l’ont veut se connecter) sur le ou les serveurs sur lesquels nous allons vouloir nous connecter, pour que le serveur nous reconnaisse.

Le dépot se fait vers le fichier ~/.ssh/authorized_keys de l’utilisateur à qui appartient la clef. Il suffit de rajouter le contenu du fichier de clef publique dans le fichier authorized_keys. Cela peut se faire à partir de l’importe quel éditeur de texte, ou, plus rapidement, comme ceci :

cat ~/chemin/vers/la/clef/id_dsa.pub >> ~/.ssh/authorized_keys

Dès que la clef est rajoutée, elle est immédiatement prise en compte pour les tentatives futures de connexion.

Vérification

Une fois la manipulation effectuée, il suffit de se déconnecter du serveur, de bien vérifier que l’agent du client à la clef SSH en mémoire, puis de relancer la connexion. On obtient le résultat suivant :

Et voila, plus besoin de tapper son mot de passe à chaque connexion, l’agent SSH se sert de la clef pour nous identifier automatiquement lors de connexion distantes.

MimeBodyPart mbp = new MimeBodyPart();
mbp.setContent(forwardedMsg, "message/rfc822");
mp.addPart(mbp);

Voila, on créé un BodyPart, et on lui injecte en tant que contenu l’object forwardedMsg, qui est un message de type MimeMessage, en spécifiant le mimetype : rfc822 (Internet Message Format), et le tour est joué.

Trouvé ici, avec plein d’autres exemples.

Dans ce tutorial j’expliquerais comment créer des redirections locales (local forwarding), distantes (remote forwarding), puis présenterais différentes solutions pour automatiser la création des tunnels.

Redirection locale “Local Forwarding”

La redirection locale reste la plus commune. Elle permet de rediriger un port de la machine locale vers une autre machine à travers le serveur SSH.

Par exemple sur le schéma ci-dessus, la machine Navicat (machine locale) se connecte au serveur mySQL à travers un serveur SSH. Sans l’utilisation du tunnel, le client ne pourrait pas se connecter à la base SQL, celle ci étant bloquée de l’exterieur.

Ce type de tunnel se créé de la manière suivant :

ssh -L <port_local>:<hote_distant>:<port_distant> <user>@<machine_distante>

Mettons donc, pour l’exemple, que l’on veuille accèder au serveur SQL ( machine “mysqlserv”, port “3306″, sur notre port local “3366″ en passant à travers l’hôte SSH “gateway” avec l’utilisateur “spark”. On obtient la commande suivante :

ssh -L 3366:mysqlserv:3306 spark@gateway

Redirection locale vers un port du poste distant

Il arrive également qu’on ai simplement besoin d’accèder à un port de la machine distante qui ne soit pas ouvert à l’exterieur ( service de messagerie stmp par exemple ). Dans ce cas la, c’est exactement la même opération. La seule astuce consiste a mêttre localhost en guise d’hote distant ( localhost étant ici du point de vue du serveur et non du client)

Si l’on voulait par exemple rediriger le port 25 de la machine distante vers notre propre port 25, il suffit de faire :

ssh -L 25:localhost:25 spark@gateway

Redirection distante “Remote Forwarding”

La redirection distante est tout simplement l’inverse de la redirection locale : on permet a l’ordinateur distant de passer à travers le poste local.

ssh -R <port_distant>:<hote_local>:<port_local> <user>@≤machine_distante>

Si l’on voulait par exemple permettre à la machine “myserver” d’accéder au serveur pop (port 110)  ‘popserver’ accessible depuis la machine locale sur son port 115 :

ssh -R 115:popserver:110 spark@myserver

Automatisation des tunnels

Aussi pratique soient ils, la création de tunnels à chaque fois que l’on en a besoin peut vite devenir une opération fastidieuse, surtout quand il s’agit d’ouvrir 5 ou 6 tunnels à chaque connexion. Heuresement, il existe différent moyens d’automatiser partie ou totalité des ouvertures.

• 1/ Via la configuration SSH

Il est possible d’automatiser la création de tunnels lors de l’ouverture d’une session SSH. Il est donc toujours necessaire d’ouvrir une session, cependant lors de l’ouverture, les tunnels configurés se lancent automatiquement.

Cela se passe dans le fichier de configuration ssh :

~/.ssh/config

Pour créer un forwarding local :

 Host myserver
     LocalForward 2525:localhost:25
     GatewayPorts no

Ici on forward le port 25 de myserver vers le port 2525 local.

Pour créer un forwarding distant :

  Host mytunnel
      RemoteForward 2323:localhost:23
      GatewayPorts no

Ici on forward le port 23 local vers le port 2323 de mytunnel

Si on prend donc le fichier de configuration ci-dessus, la connexion au server “myserver”

ssh spark@myserver

Créé automatiquement un tunnel du port local 2525 vers le port 25 du serveur.

• 2/ Via autoSSH

autoSSH est est paquet disponible sous la majorité des distributions linux, qui permet, comme son nom l’indique, d’automatiser la création de tunnels SSH.

L’installation est classique :

sudo apt-get install autossh

Ensuite, l’utilisation est la même que ssh. Par exemple :

autossh -M 5122 -N -R 25:localhost:22 spark@server

Quelques paramètres suplémentaire par rapport aux précédent exemples :

• -M 5122 : Paramètre propre à autossh : définie le port qui servira à surveiller l’état de la connexion SSH. Optionnel.

• -N : Paramètre de SSH : n’execute pas de commande à l’ouverture de la session SSH ( ne lance donc pas de shell vu que la connexion de sert ici que de tunnel )

A par ca, la syntaxe est la même que pour ssh : ici on ouvre un forwarding distant du port local 22 vers le port 25 de server.

• Via gSTM : Gnome SSH Tunnel Manager

gSTM est une interface graphique de gestion de tunnels SSH pour gnome. Il permet de configurer et de gerer très simplement des tunnels vers différentes machines.

l’installation est simple :

sudo apt-get install gstm

L’utilisation est ensuite très proche des solutions précédentes, mais présente le gros avantage de disposer d’une interface graphique.

Utilisation d’un tunnel pour se connecter à un mysql distant

Pour se connecter à un serveur mysql distant, l’opération est normalement très simple : on crée un tunnel vers le port 3306 du serveur distant vers un port local, puis on se connecte en local sur le port forwardé, comme par exemple :

ssh -L 3366:localhost:3306 spark@mysqlserver

Ensuite, il suffit de se connecter en local sur le port ouvert :

mysql -uroot -p -P3366

Cependant, à cause d’un bug dans mysql, lors d’une connexion sur localhost, mysql ignore le port spécifié pour se connecter en socket sur le mysql local.

Pour contrer ce bug, deux solutions :

1/ Spécifier l’hote comme 127.0.0.1 ( ce qui est différent de localhost pour mysql… )

2/ Modifier la configuration mysql :

Ouvrir le fichier de configuration de mysql

sudo vi /etc/mysql/my.cnf

Puis modifier la section [client] pour rajouter “protocol        = tcp”

Ce qui donne, sur une install clean de mysql :

[client]
protocol        = tcp
port            = 3316
socket          = /var/run/mysqld/mysqld.sock

Sans oublier de redemmarer le service mysql :

sudo /etc/init.d/mysql restart

ou encore

sudo restart mysql

Et voila, une fois la manipulation effectuée, plus de problème de connexion sur localhost.

AjaxLoad.info – http://www.ajaxload.info/

Chimply.com – http://www.chimply.com/

Loadinfo.net - http://www.loadinfo.net/

Preloaders.net – http://preloaders.net/

WebScriptLab – http://www.webscriptlab.com/

Étant en plein développement d’un petit pastebin-like en python ( enfin c’est un peu plus que ca, mais j’en reparlerais quand il sera fini ), le problème de la gestion de mes utilisateurs s’est posé assez vite.

Ne voulant pas avoir à gérer moi même l’authentification ( D’abord parce que je ne juge pas ça nécessaire, des choses comme OpenID le faisant très bien, et ensuite, ok, par flemme un peu, pas envie de gerer les mots de passes, les resets, d’être sur que tout est 100% secure…),  je me suis rappelé que mon compte StackOverflow s’identifie via mon google account. En creusant un peu, j’ai appris que leur authentification était gérer par un service se nommant RPX.

Mais RPX c’est quoi exactement ?

RPX est un service d’authenfication par OpenID assez jeune, et pourtant utilisé sur un certain nombre de sites de taille importante, comme UserVoice , Interscope, ou encore StackOverflow, dont je parlais dans un précédent billet.

Allez, comme un joli schéma vaut mieux qu’un long discours, RPX fournis un service qui ressemble à ca :

Traduction : RPX se positionne entre votre site web et les fournisseurs d’identification tierces (comme OpenID ou GoogleID par exemple ), et facilite l’utilisation de ces derniers.

En pratique, lorsque l’utilisateur va vouloir s’authentifier sur votre site, il va passer par une widget RPX (iframe embarquée ou popup), qui lui présente la liste des fournisseurs disponibles.

Par exemple, sur le site d’uservoice (la widget est a gauche, uservoice propose aussi une inscription directe au site) :

L’utilisateur choisir son système d’authentification et est alors dirigé vers la page de login du fournisseur tier. Par exemple pour facebook, il arrive ici :

Une fois l’authentification effectuée, l’utilisateur est redirigé vers votre site. (Pour certain fournisseurs comme google, lors de la première identification, l’utilisateur passe par une page lui demandant de confirmer qu’il autorise bien le site à accéder à ses informations)

Et c’est la que RPX fait la jointure retour avec votre site : une fois que l’utilisateur s’est authentifié, RPX vous indique (de façon sécurisée évidemment) si l’utilisateur s’est correctement authentifié ou non, et si oui, il vous transmet ses informations publiques ( email, nom d’utilisateur, nom d’usage et clef openId ).

A partir de la, vous avez votre utilisateur authentifié, vous savez qui il est, et vous êtes libre de faire ce que vous voulez (inscription en base, passage en session…)

Coté services

RPX propose 3 types de comptes :

• Basic ( Gratuit )
• Plus ( 100$ / an )
• Pro ( 500$ / an )

Je vous rassure tout de suite, le basic est largement suffisant pour tout ce qu’on pourrait vouloir sur un site de petite voir moyenne envergure :

Il est limité à 6 providers d’identifications (alors que les autres types de comptes n’ont pas de limite), cependant on peut quand même choisir ceux qu’on veut tous ceux disponibles,  c’est amplement suffisant ( personnellement j’ai pris OpenID, Google, Facebook, Twitter, Yahoo et AOL, ce qui couvre deja pas mal). A noter que pour facebook et twitter, il faut faire une petite manip pour créer une application tierse, mais tout est très bien expliqué sur le site de RPX, ca se passe donc sans problèmes.

Hormis le nombre de providers, les différences entre les types de comptes viennent surtout du support apporté à coté ( profiling, stats, customisation de la widget… ). plus d’information dans le comparatif sur le site officiel.

Les points négatifs

Même si le service proposé est vraiment intéressant, il faut quand même noter quelques points négatifs :

Tout d’abord, l’appel à la widget affichant le service d’identification est relativement lent (au moins pour les comptes gratuits, ca à l’air moins lent sur uservoice et stackoverflow). En effet l’affichage de l’iframe sur la page de login doit mettre une bonne seconde à s’afficher. C’est un détail, mais tout de même.

Ensuite, cela peut dérouter les utilisateurs ne connaissant pas le principe :l’utilisateur arrive sur un site, cherche à s’inscrire, et se retrouve diriger vers sa page google ou facebook. Cela peut dérouter quelques peu, voir même ressembler à du phishing. De plus, même si, quand on prend le temps de se renseigner, on sais que les informations fournis par les providers sont publiques (email, nom, clef openId … rien de très compromettant), on peut être effrayer au début en autorisant facebook à délivrer ses informations personnels à un site tier…

Enfin, pour finir, même si les risques sont très faibles, le jour ou le service RPX tombe en rade, on se retrouve avec un joli site sur lequel toute identification est impossible…

Un retour un peu plus complet sur les “dangers” de RPX est consultable ici , même si la plupart des choses ne sont pas spécifiquement objectives.

Sinon, pour ceux que ca intéresse, un autre billet devrait bientôt suivre sur comment brancher RPX sur un Pylons. En attendant, le tutoriel sur lequel je me suis principalement basé est disponible ici.

RPX -  RPXNow.com

Il faut quand même noter que le site est très jeune ( moins d’un an ) et compte déja 3.5 millions de visiteurs uniques par mois. Autant dire que ça va pas trop mal.

Alors, comment expliquer ce succès ? C’est assez simple : la ou la majorité des autres sites du genre sont souvent faits par des gens en 3 pièces pour tenter d’amasser des thunes, stackoverflow est fait par des gens qui ont compris ce qui attiraient les geeks. Remarque, quand on voit les photos du staff (scroller un peu en bas), on comprend assez vite pourquoi. Ca a l’air d’être une bien belle brochette

La réputation

La première chose est  l’utilisation d’une “monnaie” interne, la réputation, qui fonctionne de la manière suivante:

Lorsque vous posez ou que vous répondez à une question, les autres utilisateurs ont la possibilité de voter pour votre contribution, soit positivement, soit négativement. Ces votes augmentent ( ou diminuent ) ainsi votre réputation.

Cette réputation représente ainsi, pour reprendre les termes du site, “A quel point la communauté Stack Overflow vous fait confiance” (“how much the Stack Overflow community trusts you”).

Elle permet aussi d’accéder à certains privilèges. Par exemple, une fois les 200 réputations atteints, le nombre de pubs qui vous est affiché sur le site est diminué (j’aime bien l’idée),  et une fois les 2000 atteints, il possible d’éditer les posts des autres utilisateurs. (La liste complète est disponible ici).

Il est aussi possible de déposer une partie de sa réputation en “bounty” sur une de vos question. Si par exemple une question importante n’a pas encore eu de réponse, il vous est possible de déposer, disont 200pts de réputation dessus, qui seront ainsi une récompense pour la personne qui vous donnera la réponse attendu. Les questions disposant de bounty sont de plus visibles dans un onglet à part, permettant de rester plus longtemps dans la ou les premières pages.

Les badges

L’autre concept est le système des badges. En effet certaines actions vous attribuent des badges, qui sont de 3 types : bronze, argent et or.

Par exemple, lors du premier vote positif sur l’une de vos réponses, vous vous voyez attribué le badge de bronze  “Teacher” (oui, ils ont même pousser le vice en nommant chacun des badges)

Cette idée démoniaque, tout droit tirée des MMORPG  (concept d’achievement de WAR ou de WOW) est l’assurance que tout bon geek va passer plus de temps sur le site à essayer de monter sa réputation et débloquer des badges qu’à réellement bosser en semaine. Balaise. Vraiment balaise.

Dernier point interessant, il faut savoir que la base de donnée de stackoverflow est disponible en download libre, via torrent. Le post avec les mises à jour mensuelles est ici.

Serverfault.com

Stackoverflow dispose également d’un autre site, serverfault.com, qui lui est orienté vers les administrateurs système, et qui fonctionne sur le même principe.

Superuser.com

Et pour finir, un troisième site est prévu pour bientôt pour clôturer la trilogy stack overflow : Superuser.com , qui lui ciblera, litéralement : “computer enthusiasts and power users”

Feedback d’un mec qui n’a jamais codé une ligne de PHP :

- Trouver la doc sur leur site et la lire : 5 minutes

- Retrouver son login et son mdp unix : 7 minutes

- Trouver les identifiants sql dans la config : 30 secondes

- Installer MySql Administrator en local : 3 minutes

- Faire le back de la base : 25 secondes

- Faire le backup des fichiers : 2 minutes

- Mettre à jour les fichiers WP : 8 minutes

- Migrer la base : 3 secondes

Conclusion : y a des framework qui devraient en prendre de la graine…

Je sais plus trop comment je suis tombé sur le site, mais j’ai trouvé l’idée cool.

Positeo propose un service de vérification de son référencement google.

On choisi son mot clef, le site cible, et positeo nous indique la position du site sur une recherche du mot clef choisi.

Par exemple avec le mot clef ‘chaussures’ positeo nous indique que le site sarenza.com  est en première position (quelle surprise !) et eram.fr en 8ème.

Autant pour des sites se trouvant en première page de google, on ne gagne pas spécialement de temps par rapport à une recherche à la main, autant si le site recherché se trouve plus loin, cela evite de se tapper le défilement des pages jusqu’à trouver le résultat voulu.

Autre détail pratique, les mots clefs et sites déjà utilisés sont mémorisés, ce qui permet d’eviter de les retapper à chaque fois.

A noter également que le service va vérifier les résultats sur plusieurs datacenter google ( 15 aléatoires par requête ), même si je suis pas sur de l’interet de la chose.

Dans ce tutorial, j’expliquerai comment créer une méthode gérant un argument optionnel, puis une autre pouvant recevoir un nombre variable d’argument.

Arguments optionnels

Mettont que nous ayons besoin de trier une liste. Pour ce faire, nous créons une méthode qui s’occupe de trier la liste, puis de la retourner ( dans l’exemple, la fonction fait juste appel à la méthode sort de la liste, mais on imagine la déclaration d’une vrai méthode de tri puis de son exécution )

On obtientrait donc quelque chose de ce type :

mySort = function(l){
    l.sort();
    return l;
};
>>> mySort([4,2,3]);
[2,3,4]

Cependant, plus tard lors de notre développement, apparait un autre besoin : il faudrait pouvoir trier la liste, mais en sens inverse cette fois-ci.

Plusieurs solutions apparaissent alors :

La premiere serait de séparer les deux étapes, en effectuant d’abord l’appel à mySort(), puis ensuite à myReverse() par exemple ( qui, ferait d’ailleurs simplement return l.reverse() dans cet exemple très basique ). Mais cela allourdirait le code.

La seconde est de rajouter un second paramètre à mySort, pour spécifier l’ordre dans lequel on veut trier la liste.
On obtiendrait alors quelque chose de ce genre :

mySort = function(l, order){
    l.sort();
    if(order=="reverse") l.reverse();
    return l;
};
>>> mySort([2,4,3], "normal")
[2,3,4]
>>> mySort([2,4,3], "reverse")
[4,3,2]

On observe effectivemment qu’en fonction du second paramètre ( “normal” ou “reverse” ), le sens du tri est, ou non, inversé.

Seulement voila, cela oblige à passer un second parametre à chaque appel de sa méthode. Paramètre au final inutile si on veut trier la liste ‘simplement’, sans l’inverser.

Et bien en fait (oh surprise!) non.

En effet, une astuce trop peu connue des débutants est l’utilisation de paramètres optionnels. Un paramètre contenu dans la déclaration d’une méthode et non envoyé lors de l’appel de cette dernière ne pose,en fait, pas de problème. La variable est simplement considérée comme étant à la valeur null.

exemple :

f = function(a){
    return a
}
>>> f(2)
2
>>> f()
null

On constate qu’effectivemment, quand le paramètre ‘a’ n’est pas envoyé à la fonction ‘f’, ‘a’ est quand meme défini, et a la valeur null, dans le corps de la fonction. En exploitant cela, on peut modifier notre méthode de tri pour obtenir la suivante :

mySort = function(l, reverse){
    l.sort();
    if(reverse) l.reverse();
    return l;
};
>>> mySort([2,4,3])
[2,3,4]
>>> mySort([2,4,3], "reverse")
[4,3,2]

A noter qu’ici, la variable reverse est utilisé comme un flag : dans l’exemple on lui donne la valeur “reverse”, mais un simple “true” aurait suffit ( même si “reverse” aide à la lisibilitée du code )

Utilisation de la variable argument

Au passage, une autre astuce (un peu plus avancée celle la) concernant les arguments en javascript : dans une fonction, la variable ‘arguments’ contient la liste des arguments qui ont été passés.

Très simplement :

myTest2 = function(){
    return arguments;
};
>>> myTest2()
null
>>> myTest2(1,2,3)
[1,2,3]

Et cela marche quelque soient les arguments ‘normallement’ définis :

myTest2 = function(a,b){
    return arguments;
};
>>> myTest2()
null
>>> myTest2(1,2,3)
[1,2,3]

Arguments est une liste tout ce qu’il y a de plus classique : on peut connaitre sa taille avec arguments.length, et on recupère un élement avec arguments[position].

Concretement, cela permet d’envoyer un nombre variable de paramètres.

Par exemple, on peut envisager une fonction qui additionne un nombre quelconque de variables.

Additionner = function(){
    var sum = 0;
    for(var i=0; i < arguments.length; i++){
        sum += arguments[i];
    }
    return sum;
};
>>> Additionner()
0
>>> Additionner(1,2)
3
>>> Additionner(1,2,3)
6
>>> Additionner(1,2,3,6,12,48)
72

On constate bien qu’on peut passer un nombre variable de paramètres, et que le résultat de la méthode est la somme de tous.