<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <title>Artisan Numérique</title>
  <link rel="alternate" type="text/html" href="http://artisan.karma-lab.net/node/82"/>
  <link rel="self" type="application/atom+xml" href="http://artisan.karma-lab.net/node/82/atom/feed"/>
  <id>http://artisan.karma-lab.net/node/82/atom/feed</id>
  <updated>2008-05-22T15:32:35+02:00</updated>
  <entry>
    <title>Les différents visages de SSH</title>
    <link rel="alternate" type="text/html" href="http://artisan.karma-lab.net/node/82" />
    <id>http://artisan.karma-lab.net/node/82</id>
    <published>2008-04-09T20:44:28+02:00</published>
    <updated>2008-05-22T15:32:35+02:00</updated>
    <author>
      <name>Ulhume</name>
    </author>
    <category term="Serveurs" />
    <category term="OK" />
    <category term="Planet Libre" />
    <category term="Tutoriel" />
    <summary type="html"><![CDATA[<p>
  SSH est un utilitaire absolument vitale pour Unix, mais aussi pour Windows. Dans une première approche il permet juste d'ouvrir un terminal à distance et n'est alors pas sans rappeler le vénérable Telnet. Mais à y regarder de plus prés il se révèle sous le jour d'un véritable couteau suisse sécurisé, permettant en vrac de lancer à distance des applications graphiques, de créer des proxy sécurisés, de router tout un trafic IP sur un canal crypté, de lancer des commandes à distances,etc. En somme, outil fondamental qu'il est indispensable de maîtriser. 
</p>
    ]]></summary>
    <content type="html"><![CDATA[<p>
  SSH est un utilitaire absolument vitale pour Unix, mais aussi pour Windows. Dans une première approche il permet juste d'ouvrir un terminal à distance et n'est alors pas sans rappeler le vénérable Telnet. Mais à y regarder de plus prés il se révèle sous le jour d'un véritable couteau suisse sécurisé, permettant en vrac de lancer à distance des applications graphiques, de créer des proxy sécurisés, de router tout un trafic IP sur un canal crypté, de lancer des commandes à distances,etc. En somme, outil fondamental qu'il est indispensable de maîtriser. 
</p>
<!--break-->

	<a name='chapter_13'></a>
	<h2>Du shell distant au flux sécurisé</h2>
	
<p>
  Contrairement à ce que laisse présager son nom, le Secured Shell est un outil permettant de lancer une commande sur une machine disante, de lui fournir des données et d’en recueillir les résultats. Et tout cela au travers d'un tube crypté. Alors pourquoi donc appeler cela un Shell me direz-vous ? Tout simplement parce que la commande que lance par défaut ssh est un shell. Ainsi lorsque je tape la commande suivante, SSH m'ouvre dans mon terminal, après saisi des accréditations, un shell distant sur la machine <kbd>titine</kbd> en utilisant le login <kbd>gaston</kbd>. 
  <div class='code-container-area'><div class='code-container'><div class='traces'><ul><li><span class='prompt'>gaston$</span><span class="kw2">ssh</span> gaston<span class="sy0">@</span>titine</li><li class='result'>gaston@titine $</li></ul></div></div></div>
</p>

<div class='inline-box note'>
  Il ne faut pas confondre terminal et shell. Le terminal est l'outil qui gère les entrées clavier et les affichages sous la forme d'un vénérable écran texte. De manière caricaturale, un terminal est l'émulateur des anciens écrans d'ordinateur à l'époque où la souris n'existait pas encore. Un shell quant à lui est une application texte, que l'on lance pour pouvoir saisir des commandes. Le shell utilise donc le terminal pour lire les données et écrire les résultats. 
</div>
<p>
  Par rapport au vénérable Telnet, SSH utilisé en tant que shell présente deux interêts majeurs. Tout d'abord la sécurité car les flux sont cryptés. Ensuite la compression permettant de passer plus facilement sur des liaisons plus faibles. Mais pour se convaincre que le shell n'est en réalité qu'une commande lancée par ssh, vous pouvez essayer de la faire de manière explicite en lançant le shell bash (sh) sur la machine distante :
  <div class='code-container-area'><div class='code-container'><div class='traces'><ul><li class='result'># ici je lance la commande sh à travers ssh sur la machine titine</li><li><span class='prompt'>gaston$</span><span class="kw2">ssh</span> gaston<span class="sy0">@</span>titine <span class="st0">&quot;sh&quot;</span></li><li class='result'>echo $HOSTNAME</li><li class='result'>titine</li><li class='result'>exit</li></ul></div></div></div>
</p>

<p>
  Comme vous l'avez vue, SSH lance une commande distante et établie un tunnel crypté entre la machine locale et la machine distante par lequel transite les données envoyées à la commandes et les résultats qu'elle renvoie. Sortons donc définitivement du cadre du simple shell pour étudier cette possibilité de tube sécurisé. 
</p>
<p>
  Par exemple, imaginons que nous voulions créer à distance le fichier <kbd>helloWorld.txt</kbd> contenant la chaîne <kbd>bonjour</kbd>. En utilisant SSH, la syntaxe serait la suivante :
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw3">echo</span> <span class="st0">&quot;Bonjour&quot;</span> <span class="sy0">|</span> <span class="kw2">ssh</span> utilisateur<span class="sy0">@</span>machine <span class="st0">&quot;cat &gt; helloWorld.txt&quot;</span></div></div></div>
</p>
<p>
  Pour ceux qui ne sont pas à l’aise avec les tubes et les redirection, vous pouvez faire un petit tour <a class='external' target='_blank' href='/node/1517' >ici</a>. 
  <ul>
  <li>Tout d'abord la commande <kbD>echo</kbd> va écrire dans la sortie standard la chaîne de caractères "Bonjour"</li>
  <li>Le tube (<kbd>|</kbd>) redirige cette sortie vers l'entrée de la commande <kbd>ssh</kbd>, comme si nous avions saisi cette chaîne à la main.</li>
  <li>SSH va établir une connection sur la machine <kbd>titine</kbd> et sur le compte de l'utilisateur <kbd>gaston</kbd>. </li>
  <li>Une fois la connection établie, SSH lance la commande en paramètre <kbd>cat &gt; helloWorld.txt</kbd>. Cette commande attend les données venant de son entrée standard et envoit ce qu'elle y trouve dans le fichier <kbd>helloWorld.txt</kbd></li>
  <li>SSH va activer le tunnel et envoyer les données provenant de son entrée standard vers la commande qu'il a lancé sur la machine distante.</li>
  </ul>
<p>
<p>
  Pratique non ? Et nous pouvons faire la même chose dans les deux sens. Pour rendre la commande précédente un peu plus polie, faisons la remercier la machine locale. 
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw3">echo</span> <span class="st0">&quot;Bonjour&quot;</span> <span class="sy0">|</span> <span class="kw2">ssh</span> utilisateur<span class="sy0">@</span>machine <span class="st0">&quot;cat &gt; helloWorld.txt ; echo merci&quot;</span></div></div></div>
</p>
<p>
  Ici la seule différence c'est que l'on a groupé l'exécution de deux commandes en une seule (grâce au <kbd>;</kbd>) la seconde ayant pour rôle d'écrire <kbD>merci</kbd> dans la sortie standard, ce que SSH relaye immédiatement dans son tunnel, vers la machine locale. Et comme il n'y a pas de redirection en plus, le remerciement s'affiche simplement à l'écran. 
</p>
<p>
  Ces deux exemples très simples vous permettent de voir que SSH est loin d'être le simple shell qui parait être. Il est possible d'effectuer grâce à lui des tâches complexes comme des backups de machines distantes vers une machine locale. Après c'est une question de besoin, d'imagination et de goût pour les legos <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/wink2.gif" title="Wink" alt="Wink" class="smiley-content"/> 
</p>


	<a name='chapter_14'></a>
	<h2>Paramétrage du serveur</h2>
	
<h3>Le démon SSH</h3>
<p>
  SSH se compose d'un client (commande ssh) et d'un serveur (démon sshd). Le couple est installé en standard par l'immense majorité des distributions (désolé pour les Ubunteros mais ce n’est pas une exclusivité <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/wink2.gif" title="Wink" alt="Wink" class="smiley-content"/> ). Les commandes que j'ai donné plus haut marchent donc, clef en main, sur la plupart des installations. Mais ceci n'empêche pas de changer les comportements standard pour faire coller tout cela à vos besoins.
</p>
<div class='inline-box note'>Pour les Windowsiens, un serveur SSH est disponible dans le projet <a class='external' target='_blank' href='http://www.cygwin.com/' >cygwin</a>. Il marche exactement comme la version unix. Il a en plus le bon goût de s'installer en tant que service et offrir aux expatriés du monde Unix une VRAIE console <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/smile.gif" title="Smiling" alt="Smiling" class="smiley-content"/>
</div>
<p>
<p>
  Dans la majorité des cas, la configuration de l'ensemble de la chaîne SSH se trouve dans le dossier <kbd>/etc/ssh</kbd>. Et plus spécifiquement celle du serveur sshd se trouve dans le fichier <kbd>/etc/ssh/sshd_config</kbd>. Un classique <kbd>man sshd_config</kbd> vous en détaillera les nombreuses options.
</p>
<p>
  La plupart du temps, le serveur se lance simplement comme un service linux par un <kbd>/etc/init.d/sshd start</kbd>.
  </p>
  <div class='inline-box attention'>
    Ne connectez JAMAIS un serveur SSH sur un réseau public en oubliant de désactiver les accès de l'utilisateur root. En effet si une faille est trouvée un jour sur ssh, et qu'elle est utilisée avec cet utilisateur, c'est toute votre machine qui est du coup compromise. Veillez donc à ce que le paramètre <kbd>PermitRootLogin No</kbd> soit bien présent dans votre fichier de configuration. Si vous tenez à pouvoir vous connecter en root à partir d'internet, allez à la technique <kbd>SSH sans mot de passe</kbd> dans le chapitre <kbd>Améliorer la sécurité de l'accès root</kbd>, il s'y trouve une bonne solution alternative. 
  </div>
  
<h3>Ne pas utiliser le port par défaut</h3>  
  <p>Le serveur se met alors par défaut en écoute du port 22. Il est malin si l'on envisage de connecter se service au réseau publique de changer se port et opter pour quelque chose de moins standard, par exemple <kbd>12401</kbd> (paramètre <kbd>Port 12401</kbd> dans sshd_config). L'avantage est que vous vous mettez à l’abri des attaques automatisées. L'inconvénient est que vous devrez du coup spécifier à chaque fois ce port dans une commande ssh, par un <kbd>ssh -p 12401 titine</kbd>. Pour éviter cela si vous êtes amené à vous connecter souvent de la même machine, je vous conseille d'ajouter l'entrée suivante au fichier <kbd>ssh_config</kbd>
  <div class='code-container-area'><div class='code-container'><div class="code"><ol><li class="li1"><div class="de1">Host titine</div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; Port <span class="nu0">12401</span></div></li></ol></div></div></div>
</p>
<p>
  Cette technique vous permet d'avoir des paramètres de connections par défaut différent pour chaque serveur cible. L'entrée <kbd>host *</kbd> définissant le paramétrage par défaut commun à tous. 
</p>

<h3>Utiliser XInetd</h3>
<p>
  Normalement, lorsque l'on lance un service réseau (OpenSSH, ftp, etc...) il se met en écoute d'un port (22 pour SSH, 32 pour Ftp, etc...) et attends patiemment qu'un utilisateur veuille bien s'y connecter. Pendant ce temps, lorsque personne n'y fait appel, le service reste en mémoire et dés fois occupe aussi un peu de CPU. Xinetd est un outil qui va écouter un port à la place d'un service. Lorsqu'un utilisateur se connecte, xinetd charge le service en mémoire et le colle sur le port. Lorsque le client se déconnecte, xinetd décharge le service et libère ainsi la mémoire. 
</p>
<p>
  Son utilisation est qui plus est conseillée en façade à un réseau publique car finalement c'est lui qui sera du coup en première ligne, pas le serveur réel. Et vu qu'il est très simple de conception, il est aussi très sûr. 
</p>
<p>
  xinetd est installé en standard dans la majorité des cas. Si vous n'avez pas de <kbd>/etc/init.d/xinetd</kbd> vous pouvez l'installer par un simple <kbd>urpmi xinetd</kbd>.
</p>
 <p> Pour utiliser sshd avec xinetd, il faut simplement créer ou modifier le fichier <kbd>/etc/xinetd.d/sshd-xinetd</kbd> comme suit :
  <div class='code-container-area'><div class='code-container'><div class="code"><ol><li class="li1"><div class="de1">service <span class="kw2">ssh</span></div></li>
<li class="li1"><div class="de1"><span class="br0">&#123;</span></div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; disable = no</div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; socket_type &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; = stream</div></li>
<li class="li2"><div class="de2">&nbsp; &nbsp; &nbsp; &nbsp; <span class="kw3">wait</span> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= no</div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; user &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= root</div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; server &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= <span class="sy0">/</span>usr<span class="sy0">/</span>sbin<span class="sy0">/</span>sshd</div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; server_args &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; = -i</div></li>
<li class="li1"><div class="de1">&nbsp; &nbsp; &nbsp; &nbsp; <span class="kw2">nice</span> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;= <span class="nu0">10</span></div></li>
<li class="li2"><div class="de2"><span class="br0">&#125;</span></div></li></ol></div></div></div>
</p>
<p>
  C'est le <kbd>disable=no</kbd> qui indique que le fichier est actif. Maintenant il va nous falloir arrêter le service sshd  par un <kbd>/etc/init.d/sshd stop</kbd> et un <kbd>chkconfig --del sshd</kbd> pour éviter qu'il ne se relance au démarrage de la machine. Ensuite opération inverse pour xinetd : <kbd>/etc/init.d/xinetd start</kbd> et <kbd>chkcnfig --add xinetd</kbd>. ET voilà c'est tout. Et pour vérifier que c'est bien xinetd et non plus sshd qui est en écoute du port 22 :
  <div class='code-container-area'><div class='code-container'><div class="code"><ol><li class="li1"><div class="de1"><span class="kw2">netstat</span> -anlp <span class="sy0">|</span> <span class="kw2">grep</span> <span class="nu0">22</span></div></li>
<li class="li1"><div class="de1">&nbsp;</div></li>
<li class="li1"><div class="de1">tcp &nbsp; &nbsp; &nbsp; &nbsp;<span class="nu0">0</span> &nbsp; &nbsp; &nbsp;<span class="nu0">0</span> <span class="nu0">0.0</span><span class="nu0">.0</span><span class="nu0">.0</span>:<span class="nu0">22</span> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;<span class="nu0">0.0</span><span class="nu0">.0</span><span class="nu0">.0</span>:<span class="sy0">*</span> &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; LISTEN &nbsp; &nbsp; &nbsp;<span class="nu0">926</span><span class="sy0">/</span>xinetd</div></li></ol></div></div></div>
</p>


	<a name='chapter_15'></a>
	<h2>SSH Sans mot de passe</h2>
	
<h3>Avertissement</h3>
<P>
  A la longue c'est un peu fatiguant de rentrer un mot de passe à chaque connexion. Pour automatiser cela, OpenSSH peut remplacer l'authentification classique par un jeu clef publique/clef privée. 
</p>
<div class='inline-box attention'>
Cette technique est très pratique mais est aussi à manier avec <strong>beaucoup</strong> de précautions. Ne jamais permettre un login sans mot de passe d'un compte utilisateur vers un compte root car si le premier est compromis (ce qui peut arriver facilement), le second l'est aussi, et là, ce peut être beaucoup plus grave !!
</div>


<h3>Préparer son compte</h3>
<p>
  SSH est un outil pointilleux et encore plus lorsqu'il s'agit de se connecter sans mot de passe. La premier chose à valider est que le dossier <kbd>home</kbd> de l’utilisateur sur lequel on va chercher à se connecter lui appartienne vraiment. Cela peut sembler idiot mais souvent ssh manque sa connexion simplement pour cette raison. Nous allons donc tout d'abord vérifier que l'utilisateur <kbd>gaston</kbd> possède bien un compte et un groupe propre. Pour cela, nous utilisons la commande suivante :
  <div class='code-container-area'><div class='code-container'><div class="code"><ol><li class="li1"><div class="de1"><span class="kw2">id</span> gaston</div></li>
<li class="li1"><div class="de1"><span class="co0"># uid=500(gaston) gid=500(gaston)</span></div></li></ol></div></div></div>
</p>
<p>
  Nous avons donc bien un utilisateur <kbd> gaston </kbd> et son groupe <kbd> gaston </kbd>. Nous pouvons donc vérifier que ce dossier lui appartient bien en tapant sur la machine distante :
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">chown</span> gaston:gaston <span class="sy0">/</span>home<span class="sy0">/</span>gaston -Rc</div></div></div>
</p>
<p>
  Si la commande vous affiche des changements, c'est que l'on a bien fait de l'exécuter <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/wink2.gif" title="Wink" alt="Wink" class="smiley-content"/>
</p>
<p>
  Dans le même ordre d'idée, SSH n'aime pas trop que le dossier d'un utilisateur soit lisible par le reste du monde, nous allons donc vérifier que les droits sont les bons par un :
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">chmod</span> <span class="nu0">700</span> <span class="sy0">/</span>home<span class="sy0">/</span>gaston -c</div></div></div>
</p>
<p>
  Ceci fait, nous allons nous intéresser au dossier <kbd>/home/gaston /.ssh</kbd>. Normalement il existe déjà, sinon, créez le. Lui aussi doit avoir des droits bien stricts que nous allons vérifier ainsi :
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">chmod</span> <span class="nu0">700</span> <span class="sy0">/</span>home<span class="sy0">/</span>gaston<span class="sy0">/</span>.<span class="kw2">ssh</span></div></div></div>
</p>
  
<p> Pour l'instant, nous allons nous arrêter là et tenter une connexion distante par un 
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">ssh</span> gaston<span class="sy0">@</span>titine_distante</div></div></div>
</p>
<p>
Si tout est bien configuré, ssh devrait vous demander le mot de passe et vous donner l'accès. 
</p>




<h3>Générer un couple de clefs</h3>
<p>Avertissement étant donné, passons à la mise en pratique. Nous voulons que <kbd>gaston</kbd> puisse se connecter de sa machine à la machine <kbd>titine</kbd> sans mot de passe. Pour cela, il faut que <kbd>gaston</kbd> génère sur son compte une paire de clefs et que sur son compte distant, il autorise cette clef.
   </p>
<p>  
La marche à suivre est donc la suivante. Tout d'abord, sur la machine locale, il faut générer un couple de clef :
  <div class='code-container-area'><div class='code-container'><div class="code"><ol><li class="li1"><div class="de1"><span class="kw2">ssh-keygen</span> -t dsa</div></li>
<li class="li1"><div class="de1"><span class="co0"># Appuyez sur [Entrée] à chaque question...</span></div></li></ol></div></div></div>
</p>  
<p>
Une fois terminée, vous devez avoir dans le dossier <kbd>/home/gaston/.ssh</kbd> deux clefs : id_dsa et id_dsa.pub. Pour que ssh les accepte, nous devons en modifier les droits :
<div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">chmod</span> <span class="nu0">600</span> <span class="sy0">/</span>home<span class="sy0">/</span>gaston<span class="sy0">/</span>.<span class="kw2">ssh</span><span class="sy0">/*</span> -c</div></div></div>
</p>
<p>
  Ceci fait, nous allons recopier la clef <kbd>PUBLIQUE</kbd>, c'est-à-dire <kbd>id_dsa.pub</kbd> dans le fichier <kbd>/home/gaston/.ssh/authorized_keys </kbd> de la machine distante. Ce fichier peut contenir plusieurs clefs, les unes dernières les autres, une ligne à chaque fois. 
</p>
<p>
  Pour copier cette clef, soit vous utilisez le bon vieux presse-papiers, soit vous utilisez ce que nous avons vu sur ssh au chapitre précédent :
  <div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">cat</span> ~<span class="sy0">/</span>.<span class="kw2">ssh</span><span class="sy0">/</span>id_dsa.pub <span class="sy0">|</span> <span class="kw2">ssh</span> gaston<span class="sy0">@</span>titine <span class="st0">&quot;cat &gt;&gt; ~/.ssh/authorized_keys&quot;</span></div></div></div>
</p>
<p>
  Cette ligne magique va vous demander (une dernière fois) le mot de passe sur la machine distante et y expédier ensuite, via ssh, le contenu de la clef publique. Le <kbd>&gt; &gt;</kbd> permet de ne pas écraser les clefs déjà stockées dans le fichier. 
</p>
<p>
 Voilà, c'est terminé, il ne suffit plus qu'à tester votre nouvelle connexion sans mot de passe. En ajoutant un paramètre à ssh, il est aussi possible de mettre de prendre les clefs ailleurs sur sur <kbd>~/.ssh/</kbd>, par exemple sur une clefs usb, et ainsi de les garder avec vous en permanence. 
</p>

<h3>Améliorer la sécurité de l'accès root</h3>
<p>
  Cette technique de la connexion sans mot de passe peut être très utile pour améliorer la sécurité d'un serveur SSH connecté au réseau publique. En effet, comme nous l'avons vu plus haut, il est irresponsable de laisser à root le droit de se connecter sur un serveur ssh à partir d'internet. Il n'y a pas de failles connues à ce jour sur ce point mais nul ne sait ce qu'il peut arriver. Mais si vous tenez à pouvoir vous connecter en root sur un serveur SSH publique, la bonne solution consiste à utiliser justement un couple de clefs et à paramétrer le serveur distant pour qu'il refuse la connexion par mot de passe et donc n'accepte QUE la connexion par clef.
  </p>
<p>Il va sans dire que la règle énoncée plus haut tient toujours, ne faite ce genre de chose qu'entre deux comptes root, pas entre celui d'un utilisateur standard et le root. Je me répète, je sais, mais bon. 
</p>
<p>
  Pour indiquer au serveur SSH de refuser toute méthode d'authentification autre que celle de la clef, il suffit simplement de modifier le fichier <kbd>/etc/ssh/sshd_config</kbd> et de modifier le paramètre <kbD>PermitRootLogin "without-password"</kbd>. Bien évidemment, il faut relancer le serveur après cette modification.
</p>


	<a name='chapter_16'></a>
	<h2>Redirections de ports</h2>
	
<h3>Redirection d'un port distant sur un port local</h3>
<p>
  Nous avons vu que SSH fonctionnait comme un tunnel sécurisé permettant de faire passer de manière des données d'une commande à une autre, l'une locale, l'autre distante. Mais ce ne serait pas rendre hommage à cet outil que de le limiter à ce simple usage.
</p>
<p>
 En effet, ssh est parfaitement capable de faire la même chose mais directement sur un port TCP/IP cette fois. Imaginons un cas classique. J'ai un réseau local utilisant 
		  <a target='_blank' href='http://fr.wikipedia.org/wiki/webmin'>
		  webmin
		  </a>. Ce dernier est un serveur WEB utilisant le port 10000. Or je n'ai pas très envie de publier ce port sur un réseau publique, et pourtant pouvoir accéder à cette interface d'administration à distance peut-être très utile. La solution ? Passer par un routage de port avec ssh :
<div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">ssh</span> titine -R <span class="nu0">8080</span>:localhost:<span class="nu0">10000</span></div></div></div>
</p>
<p>
  Une fois la commande exécutée et la connexion établie, si vous prenez votre navigateur WEB et allez à l'adresse <kbd>localhost:8080</kbd> (le port 8080 de VOTRE machine locale), la requête va transiter par ssh et être effectuée sur le serveur distant au port localhost:10000. Le résultat de la requête va revenir par le même chemin et s'afficher sur votre navigateur. Et voilà <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/smile.gif" title="Smiling" alt="Smiling" class="smiley-content"/>
</p>
<p>
  Alors nous avons utilisé <kbd>localhost</kbd> indiquant la machine l'adresse local de la machine distante (faut suivre <img src="http://artisan.karma-lab.net/sites/all/modules/contrib/smileys/packs/crystal/wink2.gif" title="Wink" alt="Wink" class="smiley-content"/> ). Mais cette commande permet d'atteindre <strong>toutes les machines</strong> du réseau local qui contient ma machine distante. A méditer très sérieusement lorsque vous ouvrez benoîtement un accès ssh à un tiers... A noter cependant qu'il est possible d'interdire au niveau du serveur la redirection de port par le paramètre <kbd>AllowTcpForwarding</kbd>. Ceci dit, comme l'indique la documentation de ssh, ce n'est que reculer pour mieux sauter car quelqu'un qui dispose d'un accès ssh peut installer son propre système de redirection, à bon entendeur...
</p>

<h3>Redirection d'un port local sur un port distant</h3>
<p>
Il est aussi possible par ssh d'effectuer l'opération inverse et ainsi autoriser la machine distance à se connecter sur un serveur de votre lan
<div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">ssh</span> titine -R <span class="nu0">8080</span>:localhost:<span class="nu0">80</span></div></div></div>
</p>
<p>
 Cette commande n'a l'air de rien, mais imaginez dans un contexte d'entreprise. Un simple employé peut lancer une série de client ssh qui vont ainsi rendre ses machines disponibles, à l'extérieur du réseau. Imaginez le gag que peut être une commande du genre :
<div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">ssh</span> mon_serveur -R <span class="nu0">21</span>:serveur_de_donnees:<span class="nu0">21</span></div></div></div>
</p>
<p>
Avec cela, n'importe qui peut se connecter sur le serveur FTP privé de l'entreprise comme s'il était dans le LAN. Pensez-y avant d'ouvrir l'accès SSH dans votre firewall…
</p>


	<a name='chapter_17'></a>
	<h2>Redirection globale via SOCKS</h2>
	
<p>
SSH complète la panoplie du tunnel crypté multi usage par un outil de poids : un proxy SOCKS.
</p>
<p>
Un proxy SOCKS est petit serveur utilisant un protocole conçu pour à une application qui sait l'utiliser (un navigateur WEB, un messenger, un client FTP, etc..) de se connecter sur le net sans avoir directement de connexion à internet. Toutes les demandes de l'application vont donc passer par le proxy SOCKS.
</p>
<p>
 Un proxy SOCKS se distingue d'un Proxy HTTP en le fait qu'il n'est pas spécialisé à un seul protocole (contrairement au cas précédents) mais va router globalement le trafic qu'il soit FTP, HTTP, POP, etc...
</p>
<p>
Pour utiliser une machine distante comme passerelle internet et la machine locale comme proxy socks, il me suffit donc de lancer la commande suivante :
<div class='code-container-area'><div class='code-container'><div class="code"><span class="kw2">ssh</span> titine -D <span class="nu0">3128</span></div></div></div>
</p>
<p>
Et si je configure par exemple FireFox pour utiliser le serveur SOCKS <kbd>localhost:3128</kbd>, je vais pouvoir, à travers la connexion SSH, utiliser la connexion Internet de la machine distante sans aucune limite. Je peux aller sur n'importe quelle machine du réseau distant, je peux aussi utiliser la connexion Internet du réseau distant. Bref, faire à peu près ce que je veux. La aussi, c'est le genre de chose à méditer avant de donner sans réfléchir un accès ssh sur une machine. 
</p>

	<a name='chapter_18'></a>
	<h2>Conclusion</h2>
	
<p>
Ce rapide tour d'horizon nous a permis de voir à quel point SSH est un outil versatile et souple. Et dangereux aussi. A manier donc avec d'infinies précautions dès qu'il s'agit d'ouvrir un accès ssh sur votre machine, ou de laisser passer ssh sur un firewall. 
</p>    ]]></content>
  </entry>
</feed>
