<!--
     The FreeBSD Documentation Project
     The FreeBSD French Documentation Project

     $FreeBSD$
     Original revision: n.nn
-->

    <chapter>
      <title>S&eacute;curit&eacute;</title>
      &trans.a.haby;
      
      <sect1 id="crypt">
	<title>DES, MD5, et Crypt</title>
	
	<para><emphasis>Contribution de &a.wollman;<!-- <br> -->24 Septembre
	    1995.</emphasis></para>
	
        <para>Pour &eacute;viter que les mots de passe ne soient facilement accessibles
          sur les syst&egrave;mes UN*X, ils ont traditionnellement &eacute;t&eacute; brouill&eacute;s
          d'une fa&ccedil;on ou d'une autre. Depuis la Septi&egrave;me Edition d'Unix de
          Bell Labs', les mots de passe ont &eacute;t&eacute; cod&eacute;s avec ce que les
          sp&eacute;cialistes de la s&eacute;curit&eacute; appellent 
          &ldquo;un hachage irr&eacute;versible&rdquo;. Ce qui signifie que le mot de
          passe est transform&eacute; de telle sorte qu'une fois encod&eacute;, il ne puisse
          &ecirc;tre d&eacute;cod&eacute;, sinon par la force, en parcourant l'&eacute;ventail de toutes
          les possibilit&eacute;s. Malheureusement, la seule m&eacute;thode accessible aux
          chercheurs d'AT&amp;T &eacute;tait bas&eacute;e sur DES, le &ldquo;Data Encryption
          Standard&rdquo; (standard de cryptage des donn&eacute;es). C'est un probl&egrave;me
          mineur pour les distributeurs de logiciels commerciaux, mais un
          obstacle s&eacute;rieux pour un syst&egrave;me d'exploitation comme FreeBSD, dont
          tout le code source est accessible librement, parce que, dans de
          nombreux pays, l'exportation de DES et d'autres logiciels de
          cryptage est restreinte.</para>
	
	<para>L'&eacute;quipe de d&eacute;veloppement de FreeBSD s'est donc retrouv&eacute;e face
          au dilemme suivant: comment rester compatible avec les autres
          syst&egrave;mes Unix sans enfreindre la l&eacute;gislation. Nous avons donc
          d&eacute;cid&eacute; d'une double approche: avoir une distribution qui ne
          comporte que du logiciel de hachage des mots de passe non restreint
          &agrave; l'exportation, et fournir une biblioth&egrave;que s&eacute;par&eacute;e pour le DES. 
          L'algorithme de codage a &eacute;t&eacute; extrait de la biblioth&egrave;que C et 
          d&eacute;plac&eacute; dans une biblioth&egrave;que s&eacute;par&eacute;e appel&eacute;e
	  <filename>libcrypt</filename>, du nom de la fonction C
	  <function>crypt</function> qui l'impl&eacute;mente. Dans FreeBSD 1.x 
          et quelques instantan&eacute;s de pr&eacute;-versions 2.0, l'algorithme librement
          exportable utilise une fonction non s&eacute;curis&eacute;e due &agrave; Nate Williams; 
          dans les versions ult&eacute;rieures, il a &eacute;t&eacute; remplac&eacute; par la fonction
          de hachage irr&eacute;versible MD5 de RSA Data Security, Inc. Comme aucune
          de ces fonctions n'utilise de technique de cryptage, elles sont
          suppos&eacute;es librement exportables des Etats-Unis et importables dans
          de nombreux autres pays.</para>
	
        <para>Dans le m&ecirc;me temps, nous avons aussi travaill&eacute; sur une fonction
          bas&eacute;e sur le cryptage DES. Tout d'abord, une version de la fonction
	  <function>crypt</function> &eacute;crite en dehors des Etats-Unis a &eacute;t&eacute;
          import&eacute;e, pour synchroniser le code am&eacute;ricain et celui du reste du
          monde. Puis la biblioth&egrave;que a &eacute;t&eacute; modifi&eacute;e et coup&eacute;e en deux; la
          biblioth&egrave;que <filename>libcrypt</filename> DES ne contient que le
          code de hachage irr&eacute;versible des mots de passe, et une deuxi&egrave;me 
          biblioth&egrave;que <filename>libcipher</filename> contient les points 
          d'entr&eacute;e vers le code  effectuant le cryptage. Le code a
          &eacute;t&eacute; d&eacute;coup&eacute; de cette fa&ccedil;on pour obtenir plus facilement la licence
          d'exportation pour la biblioth&egrave;que compil&eacute;e.</para>
	
	<sect2>
	  <title>Identifier votre m&eacute;canisme <command>crypt</command></title>
	  
	  <para>Il est assez facile de savoir si un mot de passe a &eacute;t&eacute; cod&eacute;
            avec un algorithme bas&eacute; sur DES ou sur MD5. Les mots de passe MD5
            commencent toujours par les caract&egrave;res 
            <literal>&#36;1&#36;</literal>.
            Les mots de passe DES n'ont pas de caract&eacute;ristique particuli&egrave;re,
            mais sont plus courts que les mots de passe MD5 et utilisent un
            alphabet de 64 caract&egrave;res qui ne contient pas le caract&egrave;re
	    <literal>&#36;</literal>, une cha&icirc;ne relativement courte qui ne
            commence pas par un &ldquo;<literal>&#36;</literal>&rdquo; a donc
            de tr&egrave;s fortes chances d'&ecirc;tre un mot de passe DES.</para>
	  
          <para>Savoir quelle biblioth&egrave;que est utilis&eacute;e sur votre syst&egrave;me est
            aussi facile pour la plupart des programmes, sauf pour ceux qui,
            comme <command>init</command> sont li&eacute;s statiquement. (Pour ces
            programmes, il n'y a qu'un moyen: les utiliser avec un mot de passe
            connu et voir si cela marche.) Les programmes qui utilisent la
            fonction <function>crypt</function> sont li&eacute;s avec la biblioth&egrave;que
            <filename>libcrypt</filename>, qui pour chaque type de codage,
            est un lien symbolique vers l'impl&eacute;mentation ad&eacute;quate. Par exemple,
            sur un syst&egrave;me utilisant la version DES:</para>
	  
	  
	    <informalexample>
	      <screen>&prompt.user;<userinput> cd /usr/lib</userinput>
&prompt.user; <userinput>ls -l /usr/lib/libcrypt*</userinput>
lrwxr-xr-x  1 bin  bin  13 Sep  5 12:50 libcrypt.a -&gt; libdescrypt.a
lrwxr-xr-x  1 bin  bin  18 Sep  5 12:50 libcrypt.so.2.0 -&gt; libdescrypt.so.2.0
lrwxr-xr-x  1 bin  bin  15 Sep  5 12:50 libcrypt_p.a -&gt; libdescrypt_p.a</screen>
	    </informalexample>
	  
	  
	  <para>Sur un syst&egrave;me utilisant les bibloth&egrave;ques bas&eacute;es sur le MD5,
            on trouvera les m&ecirc;mes liens, mais ils pointeront sur
	    <filename>libscrypt</filename> au lieu de
	    <filename>libdescrypt</filename>.</para>
	  
	</sect2>
      </sect1>
      
      <sect1 id="skey">
	<title>S/Key</title>
	
	<para><emphasis>Contribution de &a.wollman;<!-- <br> -->25 Septembre
	    1995.</emphasis></para>
	
	<para>S/Key est un syst&egrave;me de mots de passe non r&eacute;utilisables bas&eacute; sur 
          une fonction de hachage irr&eacute;versible (notre version est bas&eacute;e sur 
          MD4 pour des raisons de compatibilit&eacute;; d'autres versions utilisent
	  MD5 et DES-MAC). S/Key est inclus en standard dans toutes les 
	  distributions de FreeBSD depuis la version 1.1.5, et est aussi
          impl&eacute;ment&eacute; sur un nombre toujours plus important d'autres syst&egrave;mes.
	  S/Key est une marque d&eacute;pos&eacute;e de Bell Communications Research,
	  Inc.</para>
	
	<para>Il y a trois types de mots de passe diff&eacute;rents dont nous
          parlerons dans ce qui suit. Le premier est votre mot de passe
          Unix habituel ou un mot de passe Kerberos; nous l'appelerons
	  &ldquo;mot de passe Unix&rdquo;. Le second est le mot de passe
          non r&eacute;utilisable g&eacute;n&eacute;r&eacute; par le programme S/Key
	  <command>key</command> et reconnu par le programme
	  <command>keyinit</command> et l'invite de session; nous
	  l'appelerons &ldquo;mot de passe non r&eacute;utilisable&rdquo;. Le dernier
	  type de mot de passe est le mot de passe secret que vous donnez au
          programme <command>key</command> (et parfois au programme
          <command>keyinit</command>) qui l'utilise pour g&eacute;n&eacute;rer des mots de
	  passe non-r&eacute;utilisables; nous l'appelerons 
          &ldquo;mot de passe secret&rdquo; ou simplement
          &ldquo;mot de passe&rdquo;.</para>
	
	<para>Le mot de passe secret n'a rien &agrave; voir avec votre mot de passe
          Unix (ils peuvent &ecirc;tre identiques, mais c'est d&eacute;conseill&eacute;). Les
          mots de passe Unix sont limit&eacute;s &agrave; huit caract&egrave;res, alors que les
          mots de passe secrets S/Key ont la longueur que vous voulez; j'utilise
          des phrases de sept mots. En g&eacute;n&eacute;ral, le syst&egrave;me S/Key fonctionne
          sans liaison avec le syst&egrave;me de mots de passe Unix.</para>

<para>Il y a en outre deux autres types de donn&eacute;es utilis&eacute;s par le
  syst&egrave;me S/Key; l'un s'appelle &ldquo;grain de sel&rdquo;
  <footnote><para>N.d.T.: &ldquo;seed&rdquo; dans l'original en
  langue anglaise. &ldquo;salt&rdquo; est aussi parfois utilis&eacute;
  pour d&eacute;signer le pr&eacute;fixe utilis&eacute; pour perturber un
  algorithme de hachage. 
  Voir <citerefentry><refentrytitle>crypt</refentrytitle><manvolnum>3</manvolnum></citerefentry>.</para></footnote>
  ou (cela pr&ecirc;te &agrave;
  confusion) &ldquo;cl&eacute;&rdquo; et est un mot de deux lettres et cinq
  chiffres, et l'autre est le &ldquo;compteur d'it&eacute;rations&rdquo; 
  compris entre 100 et 1. S/Key g&eacute;n&egrave;re un mot de passe non r&eacute;utilisable
  en concat&eacute;nant le &ldquo;grain de sel&rdquo; et le mot de passe 
  secret, en lui appliquant
  la fonction de hachage irr&eacute;versible (la fonction s&eacute;curis&eacute;e MD4 de
  RSA Data Security, Inc.) autant de fois qu'indiqu&eacute; par le compteur
  d'it&eacute;rations, et en convertissant le r&eacute;sultat en six courts mots
  anglais. Les programmes <command>login</command> et 
  <command>su</command> enregistrent le dernier mot de passe non 
  r&eacute;utilisable employ&eacute;, et l'utilisateur est authentifi&eacute; si la valeur
  de hachage de son mot de passe est la m&ecirc;me que celle de celui 
  qu'il a utilis&eacute; auparavant. Comme le hachage utilis&eacute; est irr&eacute;versible,
  il n'est pas possible de g&eacute;n&eacute;rer de mot de passe non r&eacute;utilisable
  si l'on a surpris un de ceux qui a &eacute;t&eacute; utilis&eacute; avec 
  succ&egrave;s; le compteur
  est d&eacute;cr&eacute;ment&eacute; apr&egrave;s chaque ouverture de session r&eacute;ussie, de sorte que
  l'utilisateur et le programme d'initialisation de session restent en phase.
  (Quand ce compteur passe &agrave; 1, il est temps de r&eacute;initialiser 
  S/Key.)</para>

<para>Il y a quatre programmes du syst&egrave;me S/Key dont nous traiterons plus bas.
  Le programme <command>key</command> a comme param&egrave;tres un compteur
  d'it&eacute;rations, un &ldquo;grain de sel&rdquo; et un mot de passe 
  secret et g&eacute;n&egrave;re un mot
  de passe non r&eacute;utilisable. Le programme <command>keyinit</command> 
  initialise S/Key et sert &agrave; modifier les mots de passe, les compteurs
  d'it&eacute;rations et les &ldquo;grains de sel&rdquo;; Ses param&egrave;tres sont 
  soit un mot de passe
  secret, soit un compteur d'it&eacute;rations, soit un 
  &ldquo;grain de sel&rdquo;, et un mot de
  passe non r&eacute;utilisable. Le programme <command>keyinfo</command> 
  consulte le fichier <filename>/etc/skeykeys</filename> et imprime
  la valeur du compteur d'it&eacute;rations et le &ldquo;grain de sel&rdquo; 
  de l'utilisateur qui
  l'a invoqu&eacute;. Enfin, les programmes <command>login</command> et 
  <command>su</command> incorporent la logique n&eacute;cessaire pour
  reconna&icirc;tre les mots de passe non r&eacute;utilisables S/Key pour
  authentifier les utilisateurs. Le programme <command>login</command>
  est aussi capable d'interdire l'utilisation de mots de passe Unix
  en fonction de l'adresse d'origine de la connexion.</para>

<para>Nous d&eacute;crirons quatre sortes d'op&eacute;rations. La premi&egrave;re est 
  l'utilisation du programme <command>keyinit</command> sur une 
  connexion s&eacute;curis&eacute;e pour initialiser S/Key, ou pour modifier votre 
  mot de passe ou votre &ldquo;grain de sel&rdquo;. La seconde est 
  l'emploi du programme
  <command>keyinit</command> sur une connexion non s&eacute;curis&eacute;e, en m&ecirc;me
  temps que du programme <command>key</command> sur une connexion 
  s&eacute;curis&eacute;e, pour faire la m&ecirc;me chose. La troisi&egrave;me est l'utilisation 
  du programme <command>key</command> pour ouvrir une session sur une
  connexion non s&eacute;curis&eacute;e. La quatri&egrave;me est l'usage du programme
  <command>key</command> pour g&eacute;n&eacute;rer un certain nombre de cl&eacute;s qui
  peuvent &ecirc;tre not&eacute;es ou imprim&eacute;es et emport&eacute;es avec vous quand vous allez
  quelque part ou il n'y a aucune connexion s&eacute;curis&eacute;e (comme dans
  une conf&eacute;rence).</para>


<sect2>
  <title>Initialisation depuis une connexion s&eacute;curis&eacute;e</title>
  
  <para>Pour initialiser S/Key, changer votre mot de passe ou changer
    votre &ldquo;grain de sel&rdquo; quand vous &ecirc;tes en session, sous 
    votre compte, sur une 
    connexion s&eacute;curis&eacute;e (e.g., sur la console d'une machine), utilisez
    la commande <command>keyinit</command> sans param&egrave;tres:</para>
  
  
    <informalexample>
      <screen>&prompt.user; keyinit
Updating wollman:			) ceci n'appara&icirc;t pas si vous
Old key: ha73895  		        ) n'avez pas d&eacute;j&agrave; utilis&eacute; S/Key 
Reminder - Only use this method if you are directly connected.
If you are using telnet or rlogin exit with no password and use keyinit -s.
(Rappel - N'employez cette m&eacute;thode que si vous &ecirc;tes directement connect&eacute;.
Si vous utilisez telnet ou rlogin, quittez sans donner de mot de passe 
et utilisez keyinit -s)
<prompt>Enter secret password:</prompt>			) j'ai tap&eacute; ma phrase cl&eacute; ici
<prompt>Again secret password:</prompt>			) je l'ai retap&eacute;e

ID wollman s/key is 99 ha73896		) voir ci-dessous 
SAG HAS FONT GOUT FATE BOOM		)</screen>
    </informalexample>
  
  
  <para>Il y a beaucoup de choses l&agrave;-dedans. A l'invite
    <prompt>Enter secret password:</prompt>, vous devez entrer un
    mot de passe ou une phrase (j'utilise des phrases d'au moins
    sept mots) qui servira &agrave; g&eacute;n&eacute;rer les mots de passe pour vos
    sessions. La ligne qui commence par &ldquo;ID&rdquo; vous
    liste vos param&egrave;tres S/Key: votre nom d'utilisateur, la valeur
    de votre compteur d'it&eacute;rations et votre 
    &ldquo;grain de sel&rdquo;. Quand vous ouvrirez
    une session avec S/Key, le syst&egrave;me aura m&eacute;moris&eacute; ces valeurs et
    vous les redonnera, vous n'avez donc pas besoin de les retenir.
    La derni&egrave;re ligne vous donne le mot de passe non r&eacute;utilisable
    correspondant &agrave; ces param&egrave;tres et &agrave; votre mot de passe secret;
    si vous deviez vous reconnectez imm&eacute;diatement, c'est ce mot de
    passe que vous utiliseriez.</para>
  
</sect2>

<sect2>
  <title>Initialisation depuis une connexion non s&eacute;curis&eacute;e</title>
  
  <para>Pour initialiser S/Key, changer votre mot de passe ou changer
    votre &ldquo;grain de sel&rdquo; quand vous &ecirc;tes en session 
    sur une connexion non
    s&eacute;curis&eacute;e, il vous faudra d&eacute;j&agrave; avoir une connexion s&eacute;curis&eacute;e
    sur une machine o&ugrave; vous pouvez utiliser le programme
    <command>key</command>; ce peut &ecirc;tre depuis un accessoire de
    bureau sur un Macintosh ou depuis la ligne de commande d'une
    machine s&ucirc;re (notre exemple illustre ce dernier 
    cas). Il vous
    faudra donner une valeur au compteur d'it&eacute;rations et indiquer
    un &ldquo;grain de sel&rdquo; ou utiliser la valeur al&eacute;atoire 
    g&eacute;n&eacute;r&eacute;e par le programme.
    Sur la connexion non s&eacute;curis&eacute;e (&agrave; la machine que vous initialisez),
    employez la commande <command>keyinit -s</command>:</para>
  
  
    <informalexample>
      <screen>&prompt.user; <userinput>keyinit -s</userinput>
Updating wollman: Old key: kh94741
Reminder you need the 6 English words from the skey command.
(Rappel - Il vous faut les 6 mots Anglais fournis par la commande skey.)
<prompt>Enter sequence count from 1 to 9999:</prompt> <userinput>100</userinput>	) j'ai tap&eacute; cela
<prompt>Enter new key [default kh94742]:</prompt>
s/key 100 kh94742</screen>
    </informalexample>
  
  
  <para>Pour utiliser le &ldquo;grain de sel&rdquo; par d&eacute;faut,
    (que le programme <command>keyinit</command> appelle une
    &ldquo;cl&eacute;&rdquo;&nbsp;-&nbsp;<literal>key</literal>, ce qui pr&ecirc;te
    &agrave; confusion), appuyez sur Entr&eacute;e. Passez ensuite sur votre connexion
    s&eacute;curis&eacute;e ou sur l'accessoire de bureau S/Key et donnez lui les
    m&ecirc;mes param&egrave;tres:</para>
  
    <informalexample>
      <screen>&prompt.user; <userinput>key 100 kh94742</userinput>
Reminder - Do not use this program while logged in via telnet or rlogin.
(Rappel - N'utilisez pas ce programme avec une session telnet ou rlogin.)
<prompt>Enter secret password:</prompt>             ) j'ai tap&eacute; mon mot de passe
secret
HULL NAY YANG TREE TOUT VETO</screen>
    </informalexample>
  
  
  <para>Retournez alors sur votre connexion non s&eacute;curis&eacute;e, et donnez le
    mot de passe non r&eacute;utilisable g&eacute;n&eacute;r&eacute; par la programme
    <command>key</command> au programme 
    <command>keyinit</command>:</para>
  
  
    <informalexample>
      <screen><prompt>s/key access password:</prompt> <userinput>HULL NAY YANG TREE TOUT VETO</userinput>
ID wollman s/key is 100 kh94742
HULL NAY YANG TREE TOUT VETO</screen>
    </informalexample>
  
  
  <para>Le reste de la description du paragraphe pr&eacute;c&eacute;dent s'applique
    aussi ici.</para>
  
</sect2>

<sect2>
  <title>Diversion: une invite de session</title>
  
  <para>Avant d'expliquer comment g&eacute;n&eacute;rer les mots de passe non
     r&eacute;utilisables, nous allons examiner une invite de session
     S/Key:</para>
  
    <informalexample>
      <screen>&prompt.user; <userinput>telnet himalia</userinput>
Trying 18.26.0.186...
Connected to himalia.lcs.mit.edu.
Escape character is '^]'.
s/key 92 hi52030
<prompt>Password:</prompt></screen>
    </informalexample>
  
  
  <para>Remarquez qu'avant de nous demander un mot de passe, le
    programme d'initialisation de la session nous affiche le nombre
    d'it&eacute;rations et le grain de sel dont nous aurons besoin pour
    g&eacute;n&eacute;rer la cl&eacute; appropri&eacute;e. Vous d&eacute;couvrirez aussi une possibilit&eacute;
    int&eacute;ressante (qui n'est pas illustr&eacute;e ici); si vous tapez Entr&eacute;e
    quand on vous demande votre mot de passe, le programme active
    l'&eacute;cho au terminal, de sorte que vous voyez ce que vous tapez.
    C'est tr&egrave;s utile si vous essayez de taper une S/Key &agrave; la main, 
    &agrave; partir d'un r&eacute;sultat imprim&eacute;, par exemple.</para>
  
  <para>Si cette machine avait &eacute;t&eacute; configur&eacute;e pour interdire l'emploi
    de mots de passe Unix depuis ma machine, l'annotation
    <literal>(s/key required)</literal>&nbsp;-&nbsp;&ldquo;(s/key obligatoire)&rdquo;
   aurait aussi figur&eacute;, pr&eacute;cisant que seul un mot de passe S/Key non
   r&eacute;utilisable serait accept&eacute;.</para>
  
</sect2>

<sect2>
  <title>G&eacute;n&eacute;rer un unique mot de passe non r&eacute;utilisable</title>
  
  <para>Pour g&eacute;n&eacute;rer le mot de passe non r&eacute;utilisable dont nous
     avons besoin pour ouvrir la session, nous utilisons une
     machine s&ucirc;re et le programme <command>key</command>.
     (Il y a des versions du programme <command>key</command> pour DOS 
     et Windows, et il y a aussi un accessoire de bureau pour
     Macintosh.) La version en ligne de commande du programme 
     <command>key</command> a pour param&egrave;tres le compteur d'it&eacute;rations
     et le &ldquo;grain de sel&rdquo;; vous pouvez les couper-coller
     de l'invite de session, en commen&ccedil;ant &agrave; 
    <literal>key</literal> jusqu'&agrave; la fin de la ligne. Donc:</para>
  
  
    <informalexample>
      <screen>&prompt.user; <userinput>key 92 hi52030</userinput>		) coll&eacute; du programme pr&eacute;c&eacute;dent
Reminder - Do not use this program while logged in via telnet or rlogin.
(Rappel - N'utilisez pas ce programme avec une session telnet ou rlogin.)
<prompt>Enter secret password:</prompt>		) j'ai tap&eacute; mon mot de passe secret
ADEN BED WOLF HAW HOT STUN</screen>
    </informalexample>
  
  
  <para>et dans l'autre fen&ecirc;tre:</para>
  
  
    <informalexample>
      <screen>s/key 92 hi52030				) de la section pr&eacute;c&eacute;dente
<prompt>Password:</prompt>
(turning echo on)
<prompt>Password:</prompt>ADEN BED WOLF HAW HOT STUN
Last login: Wed Jun 28 15:31:00 from halloran-eldar.l
[etc.]</screen>
    </informalexample>
  
  
  <para>C'est la m&eacute;thode la plus simple <emphasis>si</emphasis> vous
    avez une machine s&ucirc;re . Il y a une appliquette Java
    <ulink url="http://www.cs.umd.edu/~harry/jotp/src.html">The Java OTP
    Calculator</ulink>, que vous pouvez t&eacute;l&eacute;charger et ex&eacute;cuter sous
    n'importe quel navigateur supportant Java.</para>
  
</sect2>

<sect2>
  <title>G&eacute;n&eacute;rer de multiples mots de passe non r&eacute;utilisables</title>
  
  <para>Il vous faut parfois aller en des endroits o&ugrave; vous n'avez pas
    de connexion s&eacute;curis&eacute;e disponible. Dans ce cas, vous pouvez 
    utiliser la commande <command>key</command> pour g&eacute;n&eacute;rer en une
    seule fois plusieurs mots de passe non r&eacute;utilisables; vous pouvez
    imprimer ces derniers. Par exemple:</para>
  
    <informalexample>
      <screen>&prompt.user; <userinput>key -n 25 57 zz99999</userinput>
Reminder - Do not use this program while logged in via telnet or rlogin.
(Rappel - N'utilisez pas ce programme avec une session telnet ou rlogin.)
<prompt>Enter secret password:</prompt>
33: WALT THY MALI DARN NIT HEAD
34: ASK RICE BEAU GINA DOUR STAG
...
56: AMOS BOWL LUG FAT CAIN INCH
57: GROW HAYS TUN DISH CAR BALM</screen>
    </informalexample>
  
  
  <para>L'option <option>-n 25</option> demande vingt-cinq cl&eacute;s en
    s&eacute;quence; l'option <option>57</option> indique le rang de la
    <emphasis>derni&egrave;re</emphasis> it&eacute;ration; le reste a &eacute;t&eacute; d&eacute;crit
    plus haut. Notez que les cl&eacute;s sont imprim&eacute;es dans l'ordre inverse
    de celui o&ugrave; elles seront &eacute;ventuellement utilis&eacute;es. Si vous &ecirc;tes
    vraiment parano&iuml;de, vous pouvez les recopier &agrave; la main, sinon
    vous pouvez les couper-coller vers la commande 
    <command>lpr</command>. Remarquez que chaque ligne liste et le 
    nombre d'it&eacute;rations et le mot de passe non r&eacute;utilisable; vous
    trouverez cependant probablement pratique de rayer les mots de
    passe au fur et &agrave; mesure de leur utilisation.</para>
  
</sect2>

<sect2>
  <title>Restreindre l'utilisation des mots de passe Unix</title>
  
  <para>Le fichier de configuration 
    <filename>/etc/skey.access</filename> peut servir &agrave; d&eacute;finir des
    restrictions d'utilisation des mots de passe Unix en fonction des
    noms de machine et d'utilisateur, de la ligne utilis&eacute;e par le
    terminal ou de l'adresse IP de la machine connect&eacute;e &agrave; distance. Le
    format d&eacute;taill&eacute; de ce fichier est d&eacute;crit dans la page de manuel de
    <citerefentry><refentrytitle>skey.access</refentrytitle><manvolnum>5</manvolnum></citerefentry>; 
    elle inclut aussi des avertissements relatifs &agrave; la s&eacute;curit&eacute; qu'il
    faut lire avant de se fier &agrave; ce fichier pour sa s&eacute;curit&eacute;.</para>
  
  <para>S'il n'y a pas de fichier <filename>/etc/skey.access</filename> 
    (ce qui est le cas par d&eacute;faut avec la distribution de FreeBSD),
    tous les utilisateurs pourront se servir de mots de passe Unix.
    Si le fichier existe, alors tous les utilisateurs devront passer
    par S/Key, &agrave; moins qu'ils ne soient explicitement autoris&eacute;s &agrave; ne
    pas le faire par des instructions du fichier
    <filename>skey.access</filename>. Dans tous les cas, l'usage
    de mots de passe Unix est autoris&eacute; sur la console syst&egrave;me.</para>
  
  <para>Voici un exemple de fichier de configuration qui illustre
    les trois types d'instructions les plus courants:</para>
  
  <programlisting>
permit internet 18.26.0.0 255.255.0.0
permit user jrl
permit port ttyd0
  </programlisting>
  
  <para>La premi&egrave;re ligne (<literal>permit
    internet</literal>) autorise les utilisateurs dont les adresses
    IP (ce qui rend vuln&eacute;rable en cas d'usurpation) appartiennent
    au sous-r&eacute;seau sp&eacute;cifi&eacute; &agrave; employer des mots de passe Unix. Il ne
    faut pas consid&eacute;rer cela comme une mesure de s&eacute;curit&eacute;, mais plut&ocirc;t
    comme un moyen de rappeler aux utilisateurs qu'ils sont sur un
    r&eacute;seau non s&eacute;curis&eacute; et qu'ils doivent utiliser S/Key pour
    s'authentifier.</para>  
  
  <para>La seconde ligne (<literal>permit user</literal>)
    autorise l'utilisateur d&eacute;sign&eacute; &agrave; employer n'importe quand des
    mots de passe Unix. En g&eacute;n&eacute;ral, il faut se servir de cette
    possibilit&eacute; si les gens soit n'ont pas moyen d'utiliser
    le programme <command>key</command>, s'ils ont par exemple des
    terminaux passifs, soit s'ils sont d&eacute;finitivement r&eacute;fractaires.</para>
  
  <para>La troisi&egrave;me ligne (<literal>permit port</literal>)
    autorise tous les utilisateurs d'un terminal sur une liaison particuli&egrave;re
    &agrave; utiliser des mots de passe Unix. On emploie cela pour les connexions
    t&eacute;l&eacute;phoniques.</para>
	  
	</sect2>
      </sect1>
      
      <sect1 id="kerberos">
	<title>Kerberos</title>
	
	<para><emphasis>Contribution de &a.markm; (sur la base d'une 
            contribution de Mark Dapoz).</emphasis></para>
	
	<para>Kerberos est un protocole r&eacute;seau suppl&eacute;mentaire qui permet
          aux utilisateurs de s'authentifier en passant par l'interm&eacute;diaire
          d'un serveur s&eacute;curis&eacute;. Des services comme l'ouverture de session
          et la copie &agrave; distance, la copie s&eacute;curis&eacute;e de fichiers entre syst&egrave;mes
          et autres fonctionnalit&eacute;s &agrave; haut risque deviennent ainsi 
          consid&eacute;rablement plus s&ucirc;rs et contr&ocirc;lables.</para>
	
	<para>Les instructions qui suivent peuvent &ecirc;tre utilis&eacute;es comme
          guide d'installation de Kerberos dans la version distribu&eacute;e
          pour FreeBSD. Vous devriez cependant vous r&eacute;f&eacute;rer aux pages
          de manuel correspondantes pour avoir une description compl&egrave;te.</para>
	
        <para>La distribution Kerberos de FreeBSD n'est pas la distribution
	  originale de 4.4BSD-Lite, mais eBones, qui avait &eacute;t&eacute;
          auparavant port&eacute;e sous FreeBSD 1.1.5.1, et dont les sources ne
          proviennent pas des Etats-Unis/Canada, ce qui la rend disponible aux 
          utilisateurs d'autres pays.</para>
	
	<para>Pour ces derniers, qui ont besoin d'une distribution l&eacute;gale
          de ce logiciel, s'il vous plait, <emphasis>ne vous la procurez
          pas</emphasis> depuis un site aux Etats-Unis ou au Canada. Vous
          lui causeriez de <emphasis>graves</emphasis> probl&egrave;mes. Il y a
          une copie l&eacute;gale sur 
          <hostid role="fqdn">skeleton.mikom.csir.co.za</hostid>, qui se
          situe en Afrique du Sud.</para>
	
	
	<sect2>
	  <title>Cr&eacute;er la base de donn&eacute;es initiale</title>
	  
	  <para>Il faut faire cela uniquement sur le serveur Kerberos. V&eacute;rifiez
            d'abord qu'il ne tra&icirc;ne pas d'anciennes bases Kerberos. Allez
            dans le r&eacute;pertoire <filename>/etc/kerberosIV</filename> et
            assurez-vous qu'il ne contient que les fichiers suivants:</para>
	  
	  
	    <informalexample>
	      <screen>&prompt.root; <userinput>cd /etc/kerberosIV</userinput>
&prompt.root; <userinput>ls</userinput>
README		krb.conf        krb.realms</screen>
	    </informalexample>
	  
	  
	  <para>S'il y a d'autres fichiers (comme
	    <filename>principal.*</filename> ou <symbol>master_key</symbol>),
	    utilisez la commande <symbol>kdb_destroy</symbol> pour supprimer
            l'ancienne base de donn&eacute;es Kerberos, ou si Kerberos ne tourne pas,
	    effacez simplement les fichiers exc&eacute;dentaires avec
            <command>rm</command>.</para>
	  
	  <para>Vous devez maintenant &eacute;diter les fichiers
            <filename>krb.conf</filename> et
	    <filename>krb.realms</filename> pour d&eacute;finir votre domaine 
            (&ldquo;realm&rdquo;)
            Kerberos. Pour notre exemple, le domaine sera
	    <filename>GRONDAR.ZA</filename> et le serveur
	    <filename>grunt.grondar.za</filename>. Nous &eacute;ditons ou cr&eacute;ons alors
	    le fichier <filename>krb.conf</filename>:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>cat krb.conf</userinput>
GRONDAR.ZA
GRONDAR.ZA grunt.grondar.za admin server
CS.BERKELEY.EDU okeeffe.berkeley.edu
ATHENA.MIT.EDU kerberos.mit.edu
ATHENA.MIT.EDU kerberos-1.mit.edu
ATHENA.MIT.EDU kerberos-2.mit.edu
ATHENA.MIT.EDU kerberos-3.mit.edu
LCS.MIT.EDU kerberos.lcs.mit.edu
TELECOM.MIT.EDU bitsy.mit.edu
ARC.NASA.GOV trident.arc.nasa.gov</screen>
	  </informalexample>
	  
	  <para>Les autres domaines n'ont pas besoin d'&ecirc;tre mentionn&eacute;s. Ils
            ne sont l&agrave; que pour montrer comment une machine peut avoir
            connaissance de plusieurs domaines. Pour plus de simplicit&eacute;,
            vous pouvez ne pas les inclure.</para>
	  
	  <para>La premi&egrave;re ligne indique pour quel domaine cette machine 
            agit. Les autres lignes d&eacute;finissent les autres 
            domaines/machines. Chaque ligne comporte d'abord le nom du
            domaine, puis le nom de la machine qui est le &ldquo;centre
            de distribution&rdquo; de ce domaine. Les mots
            <literal>admin server</literal> qui suivent signifient que
            cette machine est aussi serveur d'administration de la
            base de donn&eacute;es. Pour plus d'explication sur cette 
            terminologie, consultez les pages de manuel de Kerberos.</para>
	  
	  <para>Il faut maintenant ajouter
            <hostid role="fqdn">grunt.grondar.za</hostid> 
	    au domaine <filename>GRONDAR.ZA</filename> et ajouter une entr&eacute;e
	    pour mettre toutes les machines du domaine DNS
            <hostid role="domainname">.grondar.za</hostid> dans
	    le domaine Kerberos <filename>GRONDAR.ZA</filename>. Le fichier
	    <filename>krb.realms</filename> aura alors l'allure 
            suivante:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>cat krb.realms</userinput>
grunt.grondar.za GRONDAR.ZA
.grondar.za GRONDAR.ZA
.berkeley.edu CS.BERKELEY.EDU
.MIT.EDU ATHENA.MIT.EDU
.mit.edu ATHENA.MIT.EDU</screen>
	  </informalexample>
	  
	  <para>Encore une fois, les autres domaines n'ont pas besoin 
            d'&ecirc;tre mentionn&eacute;s. Ils ne sont l&agrave; que pour montrer comment
            une machine peut avoir connaissance de plusieurs 
            domaines. Pour plus de simplicit&eacute;, vous pouvez ne pas les 
            inclure.</para>
	  
	  <para>La premi&egrave;re ligne assigne un syst&egrave;me 
            <emphasis>particulier</emphasis> au domaine d&eacute;sign&eacute;.
            Les autres lignes montrent comment affecter par d&eacute;faut
            les syst&egrave;mes d'un sous-domaine DNS &agrave; un domaine Kerberos
            donn&eacute;.</para>
	  
	  <para>Nous pouvons maintenant cr&eacute;er le base de donn&eacute;es. Il n'y a &agrave;
            le faire que sur le serveur Kerberos (ou Centre de Distribution
            de Cl&eacute;s). Cela se fait avec la command
	    <command>kdb_init</command>:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>kdb_init</userinput>
<prompt>Realm name [default  ATHENA.MIT.EDU ]:</prompt> <userinput>GRONDAR.ZA</userinput>
You will be prompted for the database Master Password.
It is important that you NOT FORGET this password.
(On vous demandera le Mot de Passe Ma&icirc;tre de la base de donn&eacute;es.)
(Il est important de NE PAS PERDRE ce mot de passe.)
		
<prompt>Enter Kerberos master key:</prompt> </screen>
	  </informalexample>
	  
	  <para>Nous devons maintenant sauvegarder la cl&eacute; pour que les serveurs
            sur la machine locale puisse la lire, avec la commande
	    <command>kstash</command>:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>kstash</userinput>
	      
<prompt>Enter Kerberos master key:</prompt>

Current Kerberos master key version is 1.

Master key entered. BEWARE!
(Cl&eacute; ma&icirc;tre saisie. ATTENTION!)</screen>
	  </informalexample>
	  
	  <para>Le mot de passe ma&icirc;tre encrypt&eacute; est enregistr&eacute; dans
	    le fichier <filename>/etc/kerberosIV/master_key</filename>.</para>
	  
	</sect2>
	
	<sect2>
	  <title>Installer les services</title>
	  
	  <para>Il faut ajouter deux entr&eacute;es (&ldquo;principals&rdquo;
            <footnote><para>N.d.T.: L'&ldquo;Introduction &agrave; Kerberos 5&rdquo;
            du NCSA&nbsp;-&nbsp;<ulink url="http://www.ncsa.uuic.edu/General/CC/ACES/kerberos/introduction.html">http://www.ncsa.uuic.edu/General/CC/ACES/kerberos/introduction.html</ulink>
            explicite cette notion: &ldquo;Toute entit&eacute; &agrave; laquelle il faut
            s'authentifier ou qui doit s'authentifier est un
            <foreignphrase>principal</foreignphrase> Kerberos ...
            chaque principal a un mot de passe secret qui n'est connu
            que de lui-m&ecirc;me et du Centre de Distribution de Cl&eacute;s. Chaque
            <foreignphrase>principal</foreignphrase> a un nom ... de la
            forme 
            <emphasis>primaire/instance@domaine</emphasis>.&rdquo;</para></footnote>)

            &agrave; la base de donn&eacute;es pour <emphasis>chaque</emphasis> syst&egrave;me 
            qui sera s&eacute;curis&eacute; par Kerberos.  Ce sont <literal>kpasswd</literal>
	    et <literal>rcmd</literal>. Ces deux entr&eacute;es sont d&eacute;finies pour
            chaque syst&egrave;me. A chacune de leurs instances est attribu&eacute;e le nom 
            du syst&egrave;me.</para>
	  
	  <para>Ces &ldquo;d&eacute;mons&rdquo;, <command>kpasswd</command> et
	    <command>rcmd</command> permettent aux syst&egrave;mes de changer
            les mots de passe Kerberos et d'ex&eacute;cuter des commandes comme
	    <command>rcp</command>, <command>rlogin</command>
	    et <command>rsh</command>.</para>
	  
	  <para>Ajoutons donc maintenant ces entr&eacute;es:</para>
	  
	  
	    <informalexample>
	      <screen>&prompt.root; <userinput>kdb_edit</userinput>
Opening database...

<prompt>Enter Kerberos master key:</prompt>

Current Kerberos master key version is 1.

Master key entered.  BEWARE!
Previous or default values are in [brackets] ,
enter return to leave the same, or new value.

<prompt>Principal name:</prompt> <userinput>passwd</userinput>
<prompt>Instance:</prompt> <userinput>grunt</userinput>

&lt;Not found&gt;, <prompt>Create [y] ?</prompt> <userinput>y</userinput>

Principal: passwd, Instance: grunt, kdc_key_ver: 1
<prompt>New Password:</prompt>                    &lt;---- entrez RANDOM ici
Verifying password

<prompt>New Password:</prompt>                    &lt;---- entrez RANDOM ici

<prompt>Random password [y] ?</prompt> <userinput>y</userinput>

Principal's new key version = 1
<prompt>Expiration date (enter yyyy-mm-dd) [ 2000-01-01 ] ?</prompt>
<prompt>Max ticket lifetime (*5 minutes) [ 255 ] ?</prompt>
<prompt>Attributes [ 0 ] ?</prompt>
Edit O.K.
<prompt>Principal name:</prompt> <userinput>rcmd</userinput>
<prompt>Instance:</prompt> <userinput>grunt</userinput>

&lt;Not found&gt;, <prompt>Create [y] ?</prompt>

Principal: rcmd, Instance: grunt, kdc_key_ver: 1
<prompt>New Password:</prompt>		          &lt;---- entrez RANDOM ici
Verifying password

<prompt>New Password:</prompt>                    &lt;---- entrez RANDOM ici

<prompt>Random password [y] ?</prompt>

Principal's new key version = 1
<prompt>Expiration date (enter yyyy-mm-dd) [ 2000-01-01 ] ?</prompt>
<prompt>Max ticket lifetime (*5 minutes) [ 255 ] ?</prompt>
<prompt>Attributes [ 0 ] ?</prompt>
Edit O.K.
<prompt>Principal name:</prompt>                  &lt;---- ne rien entrez ici 
                                                  permet de quitter le programme</screen>
	    </informalexample>
	  
	  
	</sect2>
	
	<sect2>
	  <title>Cr&eacute;er le fichier des services</title>
	  
	  <para>Il faut maintenant extraire toutes les instances qui d&eacute;finissent
            les services sur chaque machine. Cela se fait avec la commande
	    <command>ext_srvtab</command>. Elle cr&eacute;e un fichier qui doit &ecirc;tre
	    copi&eacute; ou report&eacute; <emphasis>par un moyen s&ucirc;r</emphasis> dans le
            r&eacute;pertoire <filename>/etc/kerberosIV</filename> de chaque client
            Kerberos. Ce fichier doit exister sur tous les serveurs et tous
            les clients et est crucial au  bon fonctionnement de 
	    Kerberos.</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>ext_srvtab grunt</userinput>
<prompt>Enter Kerberos master key:</prompt>
		
Current Kerberos master key version is 1.

Master key entered. BEWARE!
Generating 'grunt-new-srvtab'....</screen>
	  </informalexample>
	  
	  <para>Cette commande ne g&eacute;n&egrave;re qu'un fichier temporaire qui doit &ecirc;tre
            renomm&eacute; en <filename>srvtab</filename> pour que tous les serveurs
            puissent y acc&eacute;der. Utilisez la commande <command>mv</command>
            pour l'installer sur le syst&egrave;me d'origine:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>mv grunt-new-srvtab srvtab</userinput></screen>
	  </informalexample>
	  
	  <para>Si le fichier est destin&eacute; &agrave; un client, et que le r&eacute;seau n'est
            pas consid&eacute;r&eacute; comme s&ucirc;r, copiez le fichier 
            <filename>&lt;client&gt;-new-srvtab</filename> sur un support 
            amovible et transportez-le par un moyen physiquement s&ucirc;r. N'oubliez
            pas de le renommer <filename>srvtab</filename> dans le r&eacute;pertoire
	    <filename>/etc/kerberosIV</filename> du client, et mettez-le bien
	    en mode 600:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>mv grumble-new-srvtab srvtab</userinput>
&prompt.root; <userinput>chmod 600 srvtab</userinput></screen>
	  </informalexample>
	</sect2>
	
	<sect2>
	  <title>Renseigner la base de donn&eacute;es</title>
	  
	  <para>Il faut maintenant cr&eacute;er des entr&eacute;es utilisateurs dans la base
            de donn&eacute;es. Ajoutons une entr&eacute;e pour l'utilisateur
	    <username>jeanne</username>. Utilisez la commande
	    <command>kdb_edit</command> pour cela:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>kdb_edit</userinput>
Opening database...

<prompt>Enter Kerberos master key:</prompt>

Current Kerberos master key version is 1.

Master key entered.  BEWARE!
Previous or default values are in [brackets] ,
enter return to leave the same, or new value.

<prompt>Principal name:</prompt> <userinput>jeanne</userinput>
<prompt>Instance:</prompt>

&lt;Not found&gt;, <prompt>Create [y] ?</prompt> <userinput>y</userinput>

Principal: jeanne, Instance: , kdc_key_ver: 1
<prompt>New Password:</prompt>                &lt;---- entrez un mot de passe s&ucirc;r ici
Verifying password

<prompt>New Password:</prompt>                &lt;---- r&eacute;entrez le mot de passe s&ucirc;r l&agrave;
Principal's new key version = 1
<prompt>Expiration date (enter yyyy-mm-dd) [ 2000-01-01 ] ?</prompt>
<prompt>Max ticket lifetime (*5 minutes) [ 255 ] ?</prompt>
<prompt>Attributes [ 0 ] ?</prompt>
Edit O.K.
<prompt>Principal name:</prompt>             &lt;---- ne rien entrer ici permet 
                                                      de quitter le programme</screen>
	  </informalexample>
	</sect2>
	
	<sect2>
	  <title>Tester l'ensemble</title>
	  
	  <para>Il faut d'abord d&eacute;marrer les &ldquo;d&eacute;mons&rdquo; Kerberos.
            NOTEZ que si vous avez correctement modifi&eacute; votre fichier
	    <filename>/etc/rc.conf</filename>, cela se fera automatiquement
            au red&eacute;marrage du syst&egrave;me. Ce n'est n&eacute;cessaire que sur le serveur
            Kerberos. Les clients Kerberos r&eacute;cup&eacute;reront automagiquement les
            informations dont ils ont besoin via leur r&eacute;pertoire
	    <filename>/etc/kerberosIV</filename>.</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>kerberos &amp;</userinput>
Kerberos server starting
Sleep forever on error
Log file is /var/log/kerberos.log
Current Kerberos master key version is 1.

Master key entered. BEWARE!

Current Kerberos master key version is 1
Local realm: GRONDAR.ZA
&prompt.root; <userinput>kadmind -n &amp;</userinput>
KADM Server KADM0.0A initializing
Please do not use 'kill -9' to kill this job, use a
regular kill instead
(S'il vous plait, n'utilisez pas kill -9 pour arr&ecirc;ter 
 le programme, utilisez kill &agrave; la place)

Current Kerberos master key version is 1.

Master key entered.  BEWARE!</screen>
	  </informalexample>
	  
	  <para>Vous pouvez maintenant utiliser la commande 
            <command>kinit</command> pour obtenir un 
            &ldquo;ticket d'entr&eacute;e&rdquo;
            pour l'utilisateur <username>jeanne</username> que nous avons cr&eacute;&eacute;
            plus haut :</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <userinput>kinit jeanne</userinput>
MIT Project Athena (grunt.grondar.za)
Kerberos Initialization for "jeanne"
<prompt>Password:</prompt> </screen>
	  </informalexample>
	  
	  <para>Essayons de lister les informations associ&eacute;es avec la commande
             <command>klist</command> pour voir si nous avons vraiment tout
             ce qu'il nous faut:</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <userinput>klist</userinput>
Ticket file:    /tmp/tkt245
Principal:      jeanne@GRONDAR.ZA

  Issued           Expires          Principal
Apr 30 11:23:22  Apr 30 19:23:22  krbtgt.GRONDAR.ZA@GRONDAR.ZA</screen>
	  </informalexample>
	  
	  <para>Essayons maintenant de changer de mot de passe avec la commande
             <command>passwd</command> pour voir si le &ldquo;d&eacute;mon&rdquo; 
             <command>kpasswd</command> est autoris&eacute; &agrave; acc&eacute;der &agrave; la base de 
             donn&eacute;es Kerberos:</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <userinput>passwd</userinput>
realm GRONDAR.ZA
<prompt>Old password for jeanne:</prompt>
<prompt>New Password for jeanne:</prompt>
Verifying password
<prompt>New Password for jeanne:</prompt>
Password changed.</screen>
	  </informalexample>
	</sect2>
	
	<sect2>
	  <title>Autoriser l'utilisation de la commande <command>su</command></title>
	  
	  <para>Kerberos permet d'attribuer &agrave; <emphasis>chaque</emphasis>
	    utilisateur qui a besoin des droits du super-utilisateur son
            <emphasis>propre</emphasis> mot de passe <command>su</command>. Nous
            pouvons cr&eacute;er un identifiant qui soit autoris&eacute; &agrave; utiliser
	    <command>su</command> pour devenir <username>root</username>. Cela
	    se fait en associant une instance <username>root</username> &agrave;
            l'identificateur de base. Avec la commande 
            <command>kdb_edit</command> nous cr&eacute;ons l'entr&eacute;e
	    <literal>jeanne.root</literal> dans la base de donn&eacute;es 
            Kerberos:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>kdb_edit</userinput>
Opening database...

<prompt>Enter Kerberos master key:</prompt>

Current Kerberos master key version is 1.

Master key entered.  BEWARE!
Previous or default values are in [brackets] ,
enter return to leave the same, or new value.

<prompt>Principal name:</prompt> <userinput>jeanne</userinput>
<prompt>Instance:</prompt> <userinput>root</userinput>

&lt;Not found&gt;, Create [y] ? y

Principal: jeanne, Instance: root, kdc_key_ver: 1
<prompt>New Password:</prompt>                    &lt;---- entrez un mot de passe SUR ici
Verifying password

<prompt>New Password:</prompt>    	 	 &lt;---- r&eacute;entrez le mot de passe l&agrave;

Principal's new key version = 1
<prompt>Expiration date (enter yyyy-mm-dd) [ 2000-01-01 ] ?</prompt>
<prompt>Max ticket lifetime (*5 minutes) [ 255 ] ?</prompt> <userinput>12</userinput> &lt;--- Laissez une valeur faible!
<prompt>Attributes [ 0 ] ?</prompt>
Edit O.K.
<prompt>Principal name:</prompt>                 &lt;---- ne rien entrer ici
                                                  permet de quitter le programme</screen>
	  </informalexample>
	  
	  <para>V&eacute;rifions maintenant les caract&eacute;ristiques associ&eacute;es pour voir si cela marche:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>kinit jeanne.root</userinput>
MIT Project Athena (grunt.grondar.za)
Kerberos Initialization for "jeanne.root"
<prompt>Password:</prompt></screen>
	  </informalexample>
	  
	  <para>Il faut maintenant ajouter l'utilisateur au fichier
	    <filename>.klogin</filename> de root:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>cat /root/.klogin</userinput>
jeanne.root@GRONDAR.ZA</screen>
	  </informalexample>
	  	  
	  <para>Essayons maintenant la commande <command>su</command>:</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <prompt>su</prompt>
<prompt>Password:</prompt></screen>
	  </informalexample>
	  
	  <para>et voyons quelles sont nos caract&eacute;ristiques:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; klist
Ticket file:	/tmp/tkt_root_245
Principal:      jeanne.root@GRONDAR.ZA

  Issued           Expires          Principal
May  2 20:43:12  May  3 04:43:12  krbtgt.GRONDAR.ZA@GRONDAR.ZA</screen>
	  </informalexample>
	</sect2>
	
	<sect2>
	  <title>Utiliser d'autres commandes</title>
	  
	  <para>Dans l'exemple pr&eacute;c&eacute;dent, nous avons cr&eacute;&eacute; une entr&eacute;e principale
	    <literal>jeanne</literal> avec une instance <literal>root</literal>.
            Elle reposait sur un utilisateur ayant le m&ecirc;me nom que l'entr&eacute;e
            principale. C'est ce que fait Kerberos par d&eacute;faut;
	    une <literal>&lt;entr&eacute;e_principale&gt;.&lt;instance&gt;</literal>
            de la forme 
	    <literal>&lt;nom_d_utilisateur&gt;.</literal><literal>root</literal>
            autorisera
	    <literal>&lt;nom_d_utilisateur&gt;</literal> &agrave; utiliser
            <command>su</command> pour devenir root si le fichier
	    <filename>.klogin</filename> du r&eacute;pertoire utilisateur de 
            <username>root</username> est correctement renseign&eacute;:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>cat /root/.klogin</userinput>
jeanne.root@GRONDAR.ZA</screen>
	  </informalexample>
	  
	  <para>De m&ecirc;me, s'il y a dans un r&eacute;pertoire utilisateur
	    des lignes de la forme:</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <userinput>cat ~/.klogin</userinput>
jeanne@GRONDAR.ZA
jacques@GRONDAR.ZA</screen>
	  </informalexample>
	  
	  <para>Cela permet &agrave; quiconque dans le domaine
            <filename>GRONDAR.ZA</filename>
	    s'est authentifi&eacute; en tant que
	    <username>jeanne</username> ou <username>jacques</username> (avec
	    <command>kinit</command>, voir plus haut) d'acc&eacute;der avec
	    <command>rlogin</command> au compte de
	    <username>jeanne</username> ou &agrave; ses fichiers sur ce syst&egrave;me
	    (<hostid>grunt</hostid>) avec <command>rlogin</command>, <command>rsh</command> ou
	    <command>rcp</command>.</para>
	  
	  <para>Par exemple, jeanne ouvre maintenant une session sur un autre 
            syst&egrave;me, avec Kerberos:</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <userinput>kinit</userinput>
MIT Project Athena (grunt.grondar.za)
<prompt>Password:</prompt>
%prompt.user; <userinput>rlogin grunt</userinput>
Last login: Mon May  1 21:14:47 from grumble
Copyright (c) 1980, 1983, 1986, 1988, 1990, 1991, 1993, 1994
        The Regents of the University of California.   All rights reserved.

FreeBSD BUILT-19950429 (GR386) #0: Sat Apr 29 17:50:09 SAT 1995</screen>
	  </informalexample>
	  
	  <para>ou bien jacques ouvre une session sur le compte de jeanne
            sur la m&ecirc;me machine (jeanne ayant modifi&eacute; son fichier
	    <filename>.klogin</filename> comme d&eacute;crit plus haut, et
	    l'administrateur de Kerberos ayant d&eacute;fini une entr&eacute;e principale
	    <emphasis>jacques</emphasis>, sans instance:</para>
	  
	  <informalexample>
	    <screen>&prompt.user; <userinput>kinit</userinput>
&prompt.user; <userinput>rlogin grunt -l jeanne</userinput>
MIT Project Athena (grunt.grondar.za)
<prompt>Password:</prompt>
Last login: Mon May  1 21:16:55 from grumble
Copyright (c) 1980, 1983, 1986, 1988, 1990, 1991, 1993, 1994
        The Regents of the University of California.   All rights reserved.
FreeBSD BUILT-19950429 (GR386) #0: Sat Apr 29 17:50:09 SAT 1995</screen>
	  </informalexample>
	</sect2>
      </sect1>
      
      <sect1 id="firewalls">
	<title>Coupe-Feux</title>
	
	<para><emphasis>Contribution de &a.gpalmer; et
	    &a.alex;.</emphasis></para>
	
	<para>Les coupe-feux suscitent un int&eacute;r&ecirc;t croissant de la part de gens
          qui se connectent &agrave; l'Internet, et sont m&ecirc;me install&eacute;s sur des
          r&eacute;seaux priv&eacute;s pour accro&icirc;tre leur s&eacute;curit&eacute;. Cette section vise &agrave;
          vous expliquer ce que sont les coupe-feux, comment les utiliser
          et comment mettre en oeuvre les possibilit&eacute;s offertes par le noyau
          de FreeBSD pour les impl&eacute;menter.</para>
	
	<note>
	  <para>Les gens pensent souvent qu'avoir un coupe-feu entre le
            r&eacute;seau interne de leur entreprise et le
	    &ldquo;Grand M&eacute;chant Internet&rdquo;
            r&eacute;soud tous leurs probl&egrave;mes de s&eacute;curit&eacute;.</para>
	    
	  <para>Cela peut y concourir, mais une syst&egrave;me de coupe-feu mal
            configur&eacute; pr&eacute;sente pour la s&eacute;curit&eacute; un risque plus grand que
            de ne pas en avoir du tout. Un coupe-feu ajoute une couche 
            protectrice
            suppl&eacute;mentaire &agrave; votre syst&egrave;me, mais ne sera pas capable 
            d'emp&ecirc;cher un pirate r&eacute;ellement d&eacute;termin&eacute; de p&eacute;n&eacute;trer votre
            r&eacute;seau interne. Si vous &ecirc;tes laxiste quant &agrave; votre
            s&eacute;curit&eacute; interne parce que vous croyez votre coupe-feu
            imp&eacute;n&eacute;trable, vous avez tout bonnement simplifi&eacute; la t&acirc;che
            des pirates.</para>
	</note>
	
	
	<sect2>
	  <title>Qu'est-ce qu'un coupe-feu?</title>
	  
	  <para>Il y a aujourd'hui deux types de coupe-feux diff&eacute;rents
            d'utilisation courante sur l'Internet. Le premier est appel&eacute;
            plus justement <emphasis>routeur filtrant</emphasis>, quand
            le noyau d'une machine interconnect&eacute;e &agrave; plusieurs r&eacute;seaux
            s&eacute;lectionne, en appliquant un ensemble de r&egrave;gles, les paquets
            qu'il transmet ou rejette. Le second, d&eacute;sign&eacute; par le terme
            de <emphasis>serveurs mandataires</emphasis>, s'appuie sur
            des &ldquo;d&eacute;mons&rdquo; pour assurer l'authentification
            et transmettre les paquets, &eacute;ventuellement sur une machine
            interconnect&eacute;e dont la transmission de paquets au niveau
            du noyau est d&eacute;sactiv&eacute;e.</para>
	  
	  <para>Les sites combinent parfois ces deux approches, de telle
            sorte qu'une machine seulement (appel&eacute;e 
            <emphasis>bastion</emphasis>) soit autoris&eacute;e &agrave; envoyer des
            paquets, via un routeur filtrant, sur le r&eacute;seau interne. Les
            services mandat&eacute;s, qui sont g&eacute;n&eacute;ralement plus s&ucirc;rs que les
            m&eacute;canismes habituels d'authentification, 
            sont fournis par le bastion.</para>
	  
	  <para>Le noyau de FreeBSD inclut une fonctionnalit&eacute; de filtrage
            de paquets (appel&eacute;e <application>IPFW</application>), dont traite
            essentiellement la suite de cette section. Des serveurs mandataires
            sous FreeBSD peuvent &ecirc;tre mis en oeuvre avec des logiciels
            ext&eacute;rieurs, mais il y a une telle vari&eacute;t&eacute; de serveurs mandataires
            qu'il est impossible de les d&eacute;crire dans ce document.</para>
	  
	  <sect3
	    id="firewalls-packet-filters">
	    <title>Routeurs filtrants</title>
	    
	    <para>Un routeur est une machine qui transmet des paquets entre
               plusieurs r&eacute;seaux. Le noyau d'un routeur filtrant comporte
               en plus du code qui applique &agrave; chaque paquet un jeu de
               r&egrave;gles pour d&eacute;cider de le transmettre ou non. La plupart
               des logiciels r&eacute;cents de routage IP comportent du code de
               filtrage de paquets. Pour l'utiliser, vous devez fournir
               au filtre un ensemble de r&egrave;gles sur la base desquelles il
               peut d&eacute;cider d'autoriser ou non la transmission des
               paquets.</para>
	    
	    <para>Pour d&eacute;cider si le paquet peut passer ou non, le code
               parcourt les r&egrave;gles jusqu'&agrave; ce qu'il en trouve une qui
               corresponde aux en-t&ecirc;tes du paquet. Il effectue alors
               l'op&eacute;ration associ&eacute;e &agrave; la r&egrave;gle. Ce peut &ecirc;tre rejeter
               le paquet, le transmettre, ou m&ecirc;me r&eacute;pondre par un
               message ICMP &agrave; l'&eacute;metteur. La premi&egrave;re r&egrave;gle trouv&eacute;e, en
               s&eacute;quence, est seule prise en consid&eacute;ration. On peut donc
               parler d'une &ldquo;cha&icirc;ne de r&egrave;gles&rdquo;.</para>

	    <para>Les crit&egrave;res de s&eacute;lection des paquets varient selon
              les logiciels, mais vous pouvez typiquement d&eacute;finir des
              r&egrave;gles bas&eacute;es sur les adresses IP de l'&eacute;metteur et du
              destinataire, les ports source et destination (pour les
              protocoles qui supportent les ports), voir le type de paquet
	      (UDP, TCP, ICMP, etc...).</para>
	    
	  </sect3>
	  
	  <sect3
	    id="firewalls-proxy-servers">
	    <title>Serveurs mandataires</title>
    
	    <Para>Les serveurs mandataires sont des machines sur lesquelles
              les &ldquo;d&eacute;mons&rdquo; du syst&egrave;me standard 
	      (telnetd, ftpd, etc) sont remplac&eacute;s par des serveurs sp&eacute;ciaux.
	      Ce sont ces serveurs que l'on appelle <emphasis>serveurs
  	      mandataires</emphasis>, car ils n'autorisent normalement que
              les connexions entrantes. Cela permet (par exemple),
              avec un serveur mandataire telnet sur votre bastion, aux gens
              de se connecter de l'ext&eacute;rieur et d'acc&eacute;der &agrave; votre r&eacute;seau
              interne, apr&egrave;s avoir satisfait &agrave; un m&eacute;canisme d'authentification
              (inversement, des serveurs mandataires peuvent &ecirc;tre utilis&eacute;s
              pour les connexions du r&eacute;seau interne vers l'ext&eacute;rieur).</para>
	    
	    <para>Les serveurs mandataires sont g&eacute;n&eacute;ralement plus s&ucirc;rs que les
              serveurs ordinaires et disposent d'une plus grande vari&eacute;t&eacute; de 
              m&eacute;canismes d'authentification, dont les mots de passe &ldquo;&agrave; 
              usage unique&rdquo;, de fa&ccedil;on &agrave; ce que, 
              m&ecirc;me si quelqu'un arrive &agrave;
              surprendre votre mot de passe, il ne puisse l'utiliser pour
              acc&eacute;der &agrave; vos syst&egrave;mes, puisqu'il expire aussit&ocirc;t. Comme ils
              ne donnent pas aux utilisateurs l'acc&egrave;s &agrave; la machine qui les
              h&eacute;berge, il en est d'autant plus difficile d'installer une
              entr&eacute;e d&eacute;rob&eacute;e dans votre syst&egrave;me de s&eacute;curit&eacute;.</para> 
	    
	    <para>Les serveurs mandataires ont aussi souvent la possibilit&eacute;
              de restreindre encore l'acc&egrave;s, de telle fa&ccedil;on que seules
              certaines machines y soient autoris&eacute;es, et peuvent aussi
              la plupart du temps &ecirc;tre configur&eacute;s 
              pour d&eacute;finir quels utilisateurs
              peuvent acc&eacute;der aux machines cibles. L&agrave; encore, les 
              fonctionnalit&eacute;s disponibles d&eacute;pendent des logiciels que
              vous choisissez.</para>
	    
	  </sect3>
	</sect2>
	
	<sect2>
	  <title>Que me permet de faire IPFW?</title>
	  
	  <para><application>IPFW</application>, le logiciel fourni avec
            FreeBSD, est un syst&egrave;me de filtrage de paquets et de comptabilit&eacute;
            qui est int&eacute;gr&eacute; au noyau, et comporte un outil de configuration
            accessible &agrave; l'utilisateur,
	    <citerefentry><refentrytitle>ipfw</refentrytitle><manvolnum>8</manvolnum></citerefentry>. Ensemble, ils vous permettent de d&eacute;finir et de consulter
            les r&egrave;gles appliqu&eacute;es par le noyau pour prendre ses d&eacute;cisions de
            routage.</para>
	  
	  <para><application>IPFW</application> comporte deux parties. Le
            coupe-feu s'occupe du filtrage de paquets. Il y a aussi une 
            partie comptabilit&eacute; IP, qui vous permet de tracer l'utilisation
            de votre routeur, sur la base de r&egrave;gles similaires &agrave; celle
            utilis&eacute;e par le coupe-feu. Vous pouvez (par exemple) savoir
            quel trafic votre routeur re&ccedil;oit d'une machine donn&eacute;e, ou quel
            volume de requ&ecirc;tes WWW (&ldquo;World Wide Web&rdquo;) il 
            transmet.</para>
	  
	  <para>De par la conception d'<application>IPFW</application>,
	    vous pouvez l'utiliser sur une machine qui ne fait pas de
            routage, pour filtrer les connexions entrantes et sortantes.
	    C'est un cas plus particulier d'application 
            d'<application>IPFW</application> que l'usage g&eacute;n&eacute;ral, qui
            se g&egrave;re avec les m&ecirc;mes commandes et les m&ecirc;mes techniques.</para>
	  
	</sect2>
	
	<sect2>
	  <title>Activer IPFW sur FreeBSD</title>
	  
	  <para>Comme la majeure partie du syst&egrave;me 
             <application>IPFW</application> est int&eacute;gr&eacute;e au noyau,
             vous devrez ajouter une ou plusieurs options &agrave; votre
             fichier de configuration du noyau, selon les possibilit&eacute;s
             que vous voulez utiliser, et recompiler votre noyau.
	     Reportez-vous au chapitre
	     <link linkend="kernelconfig">Configurer le noyau de FreeBSD</link>
             pour plus de d&eacute;tails sur la recompilation
             du noyau.</para>
	  
	  <para>Il y a trois options de configuration du noyau qui concernent
	    <application>IPFW</application>:</para>
	  
	  
	    <variablelist>
	      <varlistentry><term>options IPFIREWALL</term>
		<listitem>
		  <para>Int&egrave;gre au noyau le code de filtrage de 
                    paquets.</para>
		</listitem>
	      </varlistentry>
	      
	      <varlistentry><term>options IPFIREWALL_VERBOSE</term>
		
		<listitem>
		  <para>Donne au code la possibilit&eacute; de tracer les paquets via
		    <citerefentry><refentrytitle>syslogd</refentrytitle><manvolnum>8</manvolnum></citerefentry>. 
                    Sans cette option et m&ecirc;me si vous pr&eacute;cisez dans vos r&egrave;gles
                    que les paquets doivent &ecirc;tre trac&eacute;s, rien ne se 
		    passera.</para>
		</listitem>
	      </varlistentry>
	      
	      <varlistentry><term>options IPFIREWALL_VERBOSE_LIMIT=10</term>
		
		<listitem>
		  <para>Limite le nombre de paquets similaires trac&eacute;s. Cette
                    option peut &ecirc;tre utile dans un environnement hostile, si
                    vous voulez surveiller l'activit&eacute; de votre coupe-feu, tout
                    en &eacute;vitant les attaques par refus de service qui
                    submergeraient <command>syslog</command>.</para>

		  <para>Quand une r&egrave;gle atteint le nombre limite de paquets
                    identiques, la trace est d&eacute;sactiv&eacute;e pour cette r&egrave;gle.
                    Pour la remettre en service, vous devrez r&eacute;initialiser 
		    le compteur associ&eacute; avec l'utilitaire 
                    <citerefentry><refentrytitle>ipfw</refentrytitle><manvolnum>8</manvolnum></citerefentry>:</para>
		  
		  <informalexample>
		    <screen>&prompt.root; <userinput>ipfw zero 4500</userinput></screen>
		  </informalexample>
		  
		  <para>o&ugrave; 4500 est le num&eacute;ro de la r&egrave;gle que vous voulez de
		    nouveau tracer.</para>
		</listitem>
	      </varlistentry>
	    </variablelist>
	  
	  
	  <para>Il y avait, dans les versions ant&eacute;rieures de FreeBSD, une
	    option <literal>IPFIREWALL_ACCT</literal>. Elle est maintenant
            obsol&egrave;te. Le code du coupe-feu int&egrave;gre d&eacute;sormais automatiquement
            les fonctions comptables.</para>
	  
	</sect2>
	
	<sect2>
	  <title>Configurer IPFW</title>
	  
	  <para>La configuration du logiciel <application>IPFW</application> 
	    se fait avec l'utilitaire <citerefentry><refentrytitle>ipfw</refentrytitle><manvolnum>8</manvolnum></citerefentry>. La syntaxe de cette commande
            para&icirc;t assez compliqu&eacute;e, mais elle est relativement simple, une
            fois que vous en avez compris la structure.</para>
	  
          <para>L'utilitaire comporte quatre cat&eacute;gories de commandes:
            ajout/suppression, liste, vidage, r&eacute;initialisation. On ajoute
            et l'on supprime des r&egrave;gles de filtrage. On liste les r&egrave;gles.
            On vide la s&eacute;quence de r&egrave;gles, pour supprimer toutes les r&egrave;gles.
            On r&eacute;initialise les informations comptables.</para>
	  
	  
	  <sect3>
	    <title>Modifier les r&egrave;gles IPFW</title>
	    
	    <para>La syntaxe pour ce type de commande est:
	      <cmdsynopsis>
		<command>ipfw</command>
		<arg>-N</arg>
		<arg choice="plain">commande</arg>
		<arg>index</arg>
		<arg choice="plain">action</arg>
		<arg>log</arg>
		<arg choice="plain">protocole</arg>
		<arg choice="plain">adresses</arg>
		<arg>options</arg>
	      </cmdsynopsis></para>
	    
	    <para>Il n'y a qu'un seul indicateur avec ce type de
	      commande:</para>
	    
	    
	      <variablelist>
		<varlistentry><term>-N</term>
		  <listitem>
		    <para>R&eacute;soudre les adresses et les noms de services
		      dans les sorties.</para>
		    
		  </listitem>
		</varlistentry>
	      </variablelist>
	    
	    
	    <para>La <emphasis>commande</emphasis> peut &ecirc;tre raccourcie
	      &agrave; son abbr&eacute;viation univoque la plus courte. Les 
	      <emphasis>commandes</emphasis> valides sont:</para>
	    
	    
	      <variablelist>
		<varlistentry><term>add</term>
		  <listitem>
		    <para>Ajoute une entr&eacute;e &agrave; la liste des r&egrave;gles de 
		      filtrage/comptabilit&eacute;.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>delete</term>
		  
		  <listitem>
		    <para>Supprime une entr&eacute;e de la liste des r&egrave;gles de 
		      filtrage/comptabilit&eacute;.</para>
		  </listitem>
		</varlistentry>
	      </variablelist>
	    
	    
	    <para>Des versions ant&eacute;rieures d'<application>IPFW</application>
              s&eacute;paraient les r&egrave;gles de filtrage et celles de comptabilit&eacute;.
              La version actuelle autorise la comptabilisation de chaque
	      r&egrave;gle de filtrage.</para>
	    
	    <para>L'<emphasis>index</emphasis>, s'il est renseign&eacute;, permet
              d'ins&eacute;rer la r&egrave;gle &agrave; un point pr&eacute;cis de la s&eacute;quence. Sinon,
              la r&egrave;gle est ajout&eacute;e en fin de s&eacute;quence avec un index de 100
	      sup&eacute;rieur &agrave; la derni&egrave;re r&egrave;gle existante (&agrave; 
              l'exception de la r&egrave;gle par d&eacute;faut, 65535, 
              &ldquo;deny&rdquo;).</para>
	    
	    <para>L'option <literal>log</literal> active la trace de la
	      r&egrave;gle &agrave; la console syst&egrave;me, si le noyau a &eacute;t&eacute; compil&eacute; avec
              l'option <literal>IPFIREWALL_VERBOSE</literal>.</para>
	    
	    <para>Les <emphasis>actions</emphasis> valides sont:</para>
	    
	    
	      <variablelist>
		<varlistentry><term>reject</term>
		  <listitem>
		    <para>Refuse le paquet, et envoie un message ICMP 
                      h&ocirc;te ou port non joignable (selon le cas) &agrave;
		      l'&eacute;metteur.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>allow</term>
		  
		  <listitem>
		    <para>Transmet normalement le paquet (alias:
		    <literal>pass</literal> et 
                    <literal>accept</literal>). </para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>deny</term>
		  
		  <listitem>
		    <para>Rejette le paquet. N'envoie pas de message
		      ICMP &agrave; l'&eacute;metteur (tout ce passe comme si le paquet
		      n'&eacute;tait jamais arriv&eacute; &agrave; destination).</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>count</term>
		  
		  <listitem>
		    <para>Met &agrave; jour les informations comptables, mais le paquet
                      n'est pas accept&eacute;/rejet&eacute; sur la base de cette r&egrave;gle. Le
		      filtrage se poursuit avec la r&egrave;gle suivante de la
		      s&eacute;quence.</para>
		  </listitem>
		</varlistentry>
	      </variablelist>
	    
	    
	    <para>Chaque <emphasis>action</emphasis> est identifiable
	      par son abbr&eacute;viation univoque la plus courte.</para>
	    
	    <para>Les <emphasis>protocoles</emphasis> qui peuvent &ecirc;tre
	      pr&eacute;cis&eacute;s sont:</para>
	    
	    
	      <variablelist>
		<varlistentry><term>all</term>
		  <listitem>
		    <para>N'importe quel paquet IP.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>icmp</term>
		  
		  <listitem>
		    <para>Les paquets ICMP.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>tcp</term>
		  
		  <listitem>
		    <para>Les paquets TCP.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>udp</term>
		  
		  <listitem>
		    <para>Les paquets UDP.</para>
		  </listitem>
		</varlistentry>
	      </variablelist>
	    
	    
	    <para>Les <emphasis>adresses</emphasis> sont repr&eacute;sent&eacute;es comme
               suit:</para>

	    <cmdsynopsis>
	      <arg choice="plain">from</arg>
	      <arg choice="plain"><replaceable>adresse/masque</replaceable></arg><arg><replaceable>port</replaceable></arg>
	      <arg choice="plain">to</arg>
	      <arg choice="plain"><replaceable>adresse/masque</replaceable></arg><arg><replaceable>port</replaceable></arg>
	      <arg>via <replaceable>interface</replaceable></arg>
	    </cmdsynopsis>
	    
	    <para>Vous ne pouvez sp&eacute;cifier le <replaceable>port</replaceable> 
              qu'avec les <emphasis>protocoles</emphasis> qui les supportent
	      (UDP et TCP).</para>
	    
	    <para>Le param&egrave;tre <option>via</option> est optionnel et d&eacute;finit
              soit l'adresse IP, soit le nom de domaine d'une interface IP
              locale, soit le nom d'une interface 
              (e.g. <devicename>ed0</devicename>) pour que la r&egrave;gle ne 
              s'applique qu'aux paquets passant par cette interface. Le
              num&eacute;ro d'unit&eacute; de l'interface peut &ecirc;tre remplac&eacute; par un
              caract&egrave;re de substitution. Par exemple, <literal>ppp*</literal> 
              d&eacute;signe toutes les interfaces associ&eacute;es au module PPP int&eacute;gr&eacute; au 
              noyau.</para>
	    
	    <para>La syntaxe utilis&eacute;e pour
	      <replaceable>adresse/masque</replaceable> est:</para>
	      
	      <informalexample>
		<screen><replaceable>adresse</replaceable></screen>
	      </informalexample>

	      <para>ou:</para>
	      
	      <informalexample>
		<screen><replaceable>adresse</replaceable>/<replaceable>longueur_du_masque</replaceable></screen>
	      </informalexample>
	      
	      <para>ou:</para>

	      <informalexample>
		<screen><replaceable>adresse</replaceable>:<replaceable>masque_logique</replaceable></screen>
	      </informalexample>
	    
	    <para>Un nom de machine valide peut remplacer l'adresse IP.
	      <option><replaceable>longueur_du_masque</replaceable></option> est
              une valeur d&eacute;cimale indiquant combien de digits de l'adresse 
              doivent correspondre. e.g. <literal>192.216.222.1/24</literal>
              g&eacute;n&egrave;re un masque tel que toutes les adresses d'un sous-r&eacute;seau de 
              classe C (dans ce cas, 192.216.222) soient s&eacute;lectionn&eacute;es.
              <option><replaceable>masque_logique</replaceable></option> est
              une adresse IP telle que le masque soit obtenu par intersection 
              logique (&ldquo;ET&rdquo;) avec l'adresse associ&eacute;e. Le mot-cl&eacute;
	      <literal>any</literal> peut &ecirc;tre utilis&eacute; pour indiquer
	      &ldquo;n'importe quelle adresse IP&rdquo;.</para>
	    
	    <para>Les num&eacute;ros des ports &agrave; bloquer sont indiqu&eacute;s par:

	      <cmdsynopsis>
		<arg choice="plain"><replaceable>port</replaceable><arg>,<replaceable>port</replaceable><arg>,<replaceable>port</replaceable><arg>...</arg></arg></arg></arg>
	      </cmdsynopsis>pour donner un seul port ou une liste de ports, ou:

	      <cmdsynopsis>
		<arg choice="plain"><replaceable>port</replaceable>-<replaceable>port</replaceable></arg>
	      </cmdsynopsis>pour donner une plage de valeurs. On peut aussi
              combiner une seule plage et une liste, mais la plage doit toujours
              &ecirc;tre indiqu&eacute;e en premier.</para>
	    
	    <para>Les <emphasis>options</emphasis> disponibles sont:</para>
	    
	    
	      <variablelist>
		<varlistentry><term>frag</term>
		  <listitem>
		    <para>Le paquet correspond si ce n'est pas le premier
	            fragment d'un datagramme.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>in</term>
		  
		  <listitem>
		    <para>Le paquet correspond si c'est un paquet 
                    entrant.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>out</term>
		  
		  <listitem>
		    <para>Le paquet correspond si c'est un paquet 
                    sortant.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>ipoptions <replaceable>options</replaceable></term>
		  
		  <listitem>
		    <para>Le paquet correspond si son en-t&ecirc;te IP contient les
                      options&nbsp;-&nbsp;s&eacute;par&eacute;es par des virgules&nbsp;-&nbsp;de la liste
                      d'<replaceable>options</replaceable>. Les options IP
		      reconnues sont: <literal>ssrr</literal> 
                      (&ldquo;strict source route&rdquo;&nbsp;-&nbsp;routage strict
                      par la source)
		      <literal>lsrr</literal> 
                      (&ldquo;loose source route&rdquo;&nbsp;-&nbsp;routage souple
                      par la source),
                      <literal>rr</literal> (&ldquo;record packet 
                      route&rdquo;&nbsp;-&nbsp;enregistrer la route du paquet),
		      et <literal>ts</literal>
		      (&ldquo;timestamp&rdquo;&nbsp;-&nbsp;date). L'absence d'une 
                      option est indiqu&eacute;e en la faisant pr&eacute;c&eacute;der d'un
	              <literal>!</literal>.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>established</term>
		  
		  <listitem>
		    <para>Le paquet correspond s'il fait partie
                      d'une connexion TCP d&eacute;j&agrave; &eacute;tablie,
		      (i.e. si le bit RST ou ACK
		      est positionn&eacute;). Vous pouver optimiser les performances
		      du coupe-feu en introduisant une r&egrave;gle
                      <emphasis>established</emphasis>
		      assez t&ocirc;t dans la s&eacute;quence.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>setup</term>
		  
		  <listitem>
		    <para>Le paquet correspond si c'est un paquet qui initialise
	              une connexion TCP (Le bit SYN est positionn&eacute; mais pas le
                      bit ACK).</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>tcpflags <replaceable>indicateurs</replaceable></term>
		  
		  <listitem>
		    <para>Le paquet correspond si son en-t&ecirc;te contient les 
                      indicateurs&nbsp;-&nbsp;s&eacute;par&eacute;s par des virgules&nbsp;-&nbsp;de la
	              liste d'<replaceable>indicateurs</replaceable>. Les
		      indicateurs reconnus sont <literal>fin</literal>,
		      <literal>syn</literal>, <literal>rst</literal>,
		    <literal>psh</literal>, <literal>ack</literal>, et
		    <literal>urg</literal>. L'absence d'un indicateur donn&eacute;
		    est indiqu&eacute;e en le faisant pr&eacute;c&eacute;der d'un
                    <literal>!</literal>.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>icmptypes <replaceable>types</replaceable></term>
		  
		  <listitem>
		    <para>Le paquet correspond si son type ICMP appartient &agrave; la
		      liste <replaceable>types</replaceable>. La liste est 
                      donn&eacute;e sous forme d'une combinaison de plages et/ou de
                      types s&eacute;par&eacute;s par des virgules. Les types ICMP 
                      habituellement utilis&eacute;s sont:
		      <literal>0</literal> &ldquo;echo reply&rdquo; (r&eacute;ponse &agrave; 
                      un <command>ping</command>),
		      <literal>5</literal> &ldquo;redirect&rdquo; 
                      (modification de la route), <literal>8</literal> 
                      &ldquo;echo request&rdquo; (&eacute;mis par 
                      <command>ping</command>), et
		      <literal>11</literal> &ldquo;time exceeded&rdquo;
                      (utilis&eacute; pour indiquer que le TTL&nbsp;-&nbsp;&ldquo;Time To
                      Live&rdquo;&nbsp;-&nbsp;dur&eacute;e de vie&nbsp;-&nbsp;,a &eacute;t&eacute; atteint, avec
		      <citerefentry><refentrytitle>traceroute</refentrytitle><manvolnum>8</manvolnum></citerefentry>, par exemple).</para>
		  </listitem>
		</varlistentry>
	      </variablelist>
	    
	    
	  </sect3>
	  
	  <sect3>
	    <title>Lister les r&egrave;gles IPFW</title>
	    
	    <para>La syntaxe de cette forme de la commande est:
               <cmdsynopsis>
		<command>ipfw</command>
		<arg>-a</arg>
		<arg>-t</arg>
		<arg>-N</arg>
		<arg choice="plain">l</arg>
	      </cmdsynopsis></para>
	    
	    <para>Il y a trois indicateurs valides avec ce type  de
	      commande:</para>
	    
	    
	      <variablelist>
		<varlistentry><term>-a</term>
		  <listitem>
		    <para>Affiche avec la liste, les valeurs des compteurs.
                      Cette option est le seul moyen de consulter les
		      informations comptables.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>-t</term>
		  
		  <listitem>
		    <para>Affiche la date de derni&egrave;re concordance pour chaque
                      r&egrave;gle de la s&eacute;quence. Le format d'affichage n'est
                      pas compatible avec la syntaxe d'entr&eacute;e de l'utilitaire
		      <citerefentry><refentrytitle>ipfw</refentrytitle><manvolnum>8</manvolnum></citerefentry>.</para>
		  </listitem>
		</varlistentry>
		
		<varlistentry><term>-N</term>
		  
		  <listitem>
		    <para>Essaye de r&eacute;soudre les adresses et le noms des
		      services.</para>
		  </listitem>
		</varlistentry>
	      </variablelist>
	    
	    
	  </sect3>
	  
	  <sect3>
	    <title>Vider les r&egrave;gles IPFW</title>
	    
	    <para>La commande pour vider les r&egrave;gles est:
	      <cmdsynopsis>
		<command>ipfw</command>
		<arg choice="plain">flush</arg>
	      </cmdsynopsis></para>
	    
	    <para>Toutes les r&egrave;gles de la s&eacute;quence sont supprim&eacute;es, sauf
              la r&egrave;gle par d&eacute;faut d&eacute;finie par le noyau (index 65535). Faites
              attention quand vous utilisez cette commande, la r&egrave;gle par
              d&eacute;faut &ldquo;deny&rdquo; isolera votre coupe-feu du r&eacute;seau
              jusqu'&agrave; ce qu'une nouvelle r&egrave;gle &ldquo;allow&rdquo; soit 
	      ajout&eacute;e &agrave; la s&eacute;quence.</para>
	    
	  </sect3>
	  
	  <sect3>
	    <title>R&eacute;initialiser les compteurs IPFW</title>
	    
	    <para>La syntaxe pour r&eacute;initialiser un ou plusieurs compteurs de 
              paquets est:
	      <cmdsynopsis>
		<command>ipfw</command>
		<arg choice="plain">zero</arg>
		<arg choice="opt"><replaceable>index</replaceable></arg>
	      </cmdsynopsis></para>
	    
	    <para>Employ&eacute;e sans l'argument 
               <replaceable>index</replaceable>, tous les compteurs sont
               r&eacute;initialis&eacute;s. Si un <replaceable>index</replaceable> est
               pr&eacute;cis&eacute;, l'op&eacute;ration ne s'applique qu'&agrave; la r&egrave;gle 
	       correspondante.</para>
	    
	  </sect3>
	</sect2>
	
	<sect2>
	  <title>Exemples de commandes IPFW</title>
	  
	  <para>Cette commande emp&ecirc;chera le routeur de transmettre tous les 
            paquets venant de la machine
	    <hostid role="fqdn">sales.pirates.org</hostid> vers le port 
            &ldquo;telnet&rdquo; de la machine
	    <hostid role="fqdn">chics.types.org</hostid>:</para>
	  
	  <informalexample>
	    <screen>&prompt.root <userinput>ipfw add deny tcp from sales.pirates.org to chics.types.org 23</userinput></screen>
	  </informalexample>
	  
	  <para>L'exemple suivant rejette tout trafic TCP venant du r&eacute;seau
	    <hostid role="domainname">pirates.org</hostid> (un r&eacute;seau de classe
            C) vers la machine
	    <hostid role="fqdn">chics.types.org</hostid> machine (quel que
            soit le port).</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>ipfw add deny log tcp from sales.pirates.org/24 to chics.types.org</userinput></screen>
	  </informalexample>
	  
	  <para>Si vous ne voulez pas que l'on puisse ouvrir de sessions X 
            sur votre r&eacute;seau interne (un sous-r&eacute;seau d'un r&eacute;seau de classe C),
            la commande suivante applique le filtrage ad&eacute;quat:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>ipfw add deny tcp from any to mon.reseau.org/28 6000 setup</userinput></screen>
	  </informalexample>
	  
	  <para>Pour lister les informations comptables:
	    
	    <informalexample>
	      <screen>&prompt.root; <userinput>ipfw -a list</userinput></screen>
	    </informalexample> ou en abr&eacute;g&eacute;:
	    
	    <informalexample>
	      <screen>&prompt.root; <userinput>ipfw -a l</userinput></screen>
	    </informalexample> Vous pouvez aussi voir la derni&egrave;re date 
              d'application d'une r&egrave;gle avec:
	    
	    <informalexample>
	      <screen>&prompt.root; <userinput>ipfw -at l</userinput></screen>
	    </informalexample></para>
	  
	</sect2>
	
	<sect2>
	  <title>Mettre en oeuvre un coupe-feu filtrant</title>
	  
	  <note>
	    <para>Les suggestions ci-dessous ne sont rien que des suggestions.
              Les contraintes varient d'un coupe-feu &agrave; l'autre et je ne peux
              pas vous dire comment mettre en place le coupe-feu qui r&eacute;ponde
              &agrave; votre besoin particulier.</para>
	  </note>
	  
          <para>Lorsque vous commencez &agrave; configurer votre coupe-feu, &agrave; moins
            que vous n'ayez un banc d'essai pour faire vos tests dans un 
            environnement que vous contr&ocirc;lez, je vous conseille
            vivement d'utiliser les options de trace des commandes apr&egrave;s avoir
            compil&eacute; un noyau supportant les traces du coupe-feu. Vous pourrez
            ainsi identifier rapidement les probl&egrave;mes et y rem&eacute;dier sans
            provoquer trop de g&ecirc;ne. M&ecirc;me par la suite, je vous conseille de
            conserver l'option pour les commandes <command>deny</command>, 
            ce qui vous permettra de tracer les attaques &eacute;ventuelles et aussi de
            modifier vos r&egrave;gles si vos besoins &eacute;voluent.</para>
	  
	  <note>
	    <para>Tracer les commandes <command>accept</command> aboutit
              &agrave; de gros volumes de fichiers de trace, puisqu'il y a une 
              ligne pour chaque paquet qui transite par le coupe-feu. Les
              transferts ftp/http importants ralentissent alors s&eacute;rieusement
              le syst&egrave;me. Cela augmente aussi le temps de latence pour ces
              paquets, parce que cela demande au noyau plus de traitement
              avant de les passer. <command>syslogd</command> utilisera aussi
              plus de temps CPU pour &eacute;crire toutes ces informations sur disque
              et peut m&ecirc;me assez rapidement saturer la partition sur laquelle
	      r&eacute;side le r&eacute;pertoire <filename>/var/log</filename>.</para>
	  </note>
	  
          <para>Tel qu'il est livr&eacute;, FreeBSD ne sait pas charger les r&egrave;gles
            du coupe-feu au d&eacute;marrage du syst&egrave;me. Je vous sugg&egrave;re d'appeler
            une proc&eacute;dure ad-hoc depuis la proc&eacute;dure
	    <filename>/etc/netstart</filename>. Mettez cette proc&eacute;dure assez t&ocirc;t
            dans le fichier <filename>netstart</filename>, de sorte que le 
            coupe-feu soit configur&eacute; avant les interfaces IP. Il n'y a ainsi
            pas de possibilit&eacute; d'acc&egrave;s tant que votre r&eacute;seau est encore
            ouvert.</para>
	  
	  <para>Employez la m&eacute;thode que vous voulez pour charger les r&egrave;gles.
            La commande <command>ipfw</command> ne peut pas charger toutes
            les r&egrave;gles en une seule fois. Je proc&egrave;de de la fa&ccedil;on 
            suivante:</para>
	  
	  <informalexample>
	    <screen>&prompt.root; <userinput>ipfw list</userinput></screen>
	  </informalexample>
	  
	  <para>pour &eacute;crire dans un fichier les r&egrave;gles que j'ai d&eacute;finies. Puis
            j'&eacute;dite ce fichier pour ajouter <literal>ipfw</literal> au d&eacute;but
            de chaque ligne. La proc&eacute;dure peut alors &ecirc;tre ex&eacute;cut&eacute;e pour
            recharger les r&egrave;gles. C'est n'est peut-&ecirc;tre pas la fa&ccedil;on la
            plus efficace de proc&eacute;der, mais cela marche.</para> 
	  
	  <para>La question suivante est de savoir ce que votre coupe-feu
	    doit r&eacute;ellement <emphasis>faire</emphasis>! Cela d&eacute;pend dans une 
            large mesure des acc&egrave;s que vous voulez autoriser de l'ext&eacute;rieur
            &agrave; votre r&eacute;seau et vice-versa. Voici quelques r&egrave;gles 
            g&eacute;n&eacute;rales:</para>
	  
	    <itemizedlist>
	      
	      <listitem>
		<para>Bloquez tous les acc&egrave;s entrants sur des ports TCP
                  en dessous de 1024. C'est l&agrave; que les services les plus
                  probl&eacute;matiques pour la s&eacute;curit&eacute; se trouvent, comme
		  finger, SMTP (courrier &eacute;lectronique) et telnet.</para>
	      </listitem>
	      
	      <listitem>
		<para>Bloquez <emphasis>tout</emphasis> traffic UDP entrant.
                  Il y a tr&egrave;s peu de services utiles qui fonctionnent sur UDP,
                  et les services qui sont utiles menacent g&eacute;n&eacute;ralement la
		  s&eacute;curit&eacute; (e.g. Les protocoles RPC et NFS de Sun). Cela 
                  pr&eacute;sente l'inconv&eacute;nient que, comme le protocole UDP est
                  sans &eacute;tat, les r&eacute;ponses aux requ&ecirc;tes UDP sortantes sont
                  aussi bloqu&eacute;es. Cela peut poser probl&egrave;me &agrave; des utilisateurs
                  internes qui veulent interroger des serveurs archie (prospero)
                  externes. Si vous voulez autoriser l'acc&egrave;s &agrave; archie, vous
                  devez accepter les paquets UDP venant des ports 191 et 1525
                  sur n'importe quel port UDP interne. ntp est un autre service
                  que vous pouver envisager d'autoriser; il utilise le port
		  123.</para>
	      </listitem>
	      
	      <listitem>
		<para>Bloquez le trafic entrant vers le port 6000. Le port
                  6000 est utilis&eacute; pour acc&egrave;der aux serveurs X11, et peut
                  pr&eacute;senter des risques pour la s&eacute;curit&eacute; (en particulier
                  si les gens ont l'habitude d'utiliser 
                  <command>xhost +</command> sur leur station de travail).
                  X11 peut en fait utiliser une plage de ports commen&ccedil;ant
                  au port 6000, la limite sup&eacute;rieure d&eacute;pendant du nombre
                  de sessions d'affichage qu'accepte la machine. La limite
                  d&eacute;finie par la RFC 1700 est 6063.</para>
	      </listitem>
	      
	      <listitem>
		<para>R&eacute;pertoriez les ports utilis&eacute;s par les serveurs
                  internes (e.g. serveurs SQL, ...). C'est probablement
                  une bonne id&eacute;e de les bloquer aussi, car ils sont
                  normalement hors de la plage 1-1024 d&eacute;crite plus haut.</para> 
	      </listitem>
	      
	    </itemizedlist>
	  
	  
	  <para>Le CERT propose d'autres recommendations pour la configuration
            d'un coupe-feu &agrave; l'adresse
	    <ulink url="ftp://ftp.cert.org/pub/tech_tips/packet_filtering">ftp://ftp.cert.org/pub/tech_tips/packet_filtering</ulink>.</para>
	  
	  <para>Comme je l'ai dit plus haut, ce ne sont que des
	    <emphasis>propositions</emphasis>.  Vous devrez d&eacute;finir vous-m&ecirc;me
            les r&egrave;gles &agrave; appliquer &agrave; votre coupe-feu. Je ne peux endosser
            AUCUNE responsabilit&eacute; si quelqu'un s'infiltre sur votre r&eacute;seau,
            m&ecirc;me si vous suivez les conseils donn&eacute;s ci-dessus.</para>
	  
	</sect2>
      </sect1>
    </chapter>
<!--    
     Local Variables:
     mode: sgml
     sgml-declaration: "../chapter.decl"
     sgml-indent-data: t
     sgml-omittag: nil
     sgml-shorttag: nil
     sgml-always-quote-attributes: t 
     sgml-minimize-attributes: max
     sgml-parent-document: ("../handbook.sgml" "part" "chapter")
     End: 
-->       
