path: root/fr_FR.ISO8859-1/articles/ipsec-must/article.xml

<?xml version="1.0" encoding="iso-8859-1" standalone="no"?>
<!DOCTYPE article PUBLIC "-//FreeBSD//DTD DocBook XML V4.2-Based Extension//EN"
	"../../../share/xml/freebsd42.dtd" [
<!ENTITY % entities PUBLIC "-//FreeBSD//ENTITIES DocBook FreeBSD Entity Set//FR" "../../share/xml/entities.ent">
%entities;
<!ENTITY % not.published "IGNORE">
]>

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

    $FreeBSD$
    $Id: article.xml,v 1.7 2007-01-20 13:34:48 blackend Exp $
    Original revision: 1.12
-->

<article lang="fr">
  <articleinfo>
    <title>Vérification indépendante du fonctionnement d'IPSec sous
      FreeBSD</title>

    <author>
      <firstname>David</firstname>
      <surname>Honig</surname>

      <affiliation>
        <address><email>honig@sprynet.com</email></address>
      </affiliation>
    </author>

    <pubdate>3 Mai 1999</pubdate>
	<legalnotice id="trademarks" role="trademarks">
	&tm-attrib.freebsd;
	&tm-attrib.opengroup;
	&tm-attrib.general;
	</legalnotice>

    <releaseinfo>$FreeBSD$</releaseinfo>

    <abstract>
      <para>Vous avez installé IPSec et cela semble fonctionner.
	Comment pouvez-vous en être sûr?  Je décris
	une méthode pour vérifier expérimentalement
	le fonctionnement d'IPSec.</para>

	&trans.a.fonvieille;
    </abstract>
  </articleinfo>

  <sect1>
    <title>Le problème</title>

    <para>Tout d'abord, supposons que vous avez <link
      linkend="ipsec-install">installé
      <emphasis>IPSec</emphasis></link>.
      Comment savez-vous si cela <link linkend="caveat">fonctionne</link>?
      Bien sûr, votre connexion ne fonctionnera pas si elle est mal
      configurée, et fonctionnera quand vous l'aurez enfin
      correctement configurée.  &man.netstat.1; le fera
      apparaître.  Mais pouvez-vous le confirmer
      de façon indépendante?</para>
  </sect1>

  <sect1>
    <title>La solution</title>

    <para>Tout d'abord, quelques informations théoriques relatives
      &agrave; la cryptographie:</para>

    <orderedlist>
      <listitem>
	<para>Les données chiffrées sont
	  uniformément distribuées, i.e., ont une entropie
	  maximale par symbole;</para>
      </listitem>

      <listitem>
	<para>Les données brutes, non compressées sont en
	  générale redondantes, i.e., n'ont pas une
	  entropie maximale.</para>
      </listitem>
    </orderedlist>

    <para>Supposez que vous pourriez mesurer l'entropie des
      données &agrave; destination et en provenance de votre
      interface réseau.  Alors vous pourriez voir la
      différence entre données non-chiffées et
      données chiffrées.  Cela serait vrai même si
      certaines des données en &ldquo;mode chiffré&rdquo;
      n'étaient pas chiffrées --- comme l'en-tête IP
      externe, si le paquet doit être routable.</para>

    <sect2 id="MUST">
      <title>MUST</title>

      <para>L'&ldquo;Universal Statistical Test for Random
	Bit Generators&rdquo;(<ulink
	url="http://www.geocities.com/SiliconValley/Code/4704/universal.pdf">
	<acronym>MUST</acronym></ulink>) d'Ueli Maurer, ou encore le
	&ldquo;test statistique universel pour les générateurs
	aléatoires de bits&rdquo;, mesure rapidement l'entropie d'un
	échantillon.  Il utilise une sorte d'algorithme de compression.
	<link linkend="code">Le code est donné ci-dessous</link> pour
	une variante qui mesure les morceaux (environ un quart de
	mégaoctet) successifs d'un fichier.</para>
    </sect2>

    <sect2 id="tcpdump">
      <title>Tcpdump</title>

      <para>Nous avons également besoin d'une manière de
	capturer les données réseau brutes.  Un programme
	appelé &man.tcpdump.1; vous permet de faire cela, si vous
	avez activé l'interface
	<emphasis>Berkeley Packet Filter</emphasis> (Filtre de Paquet de
	Berkeley) dans votre <link linkend="kernel">fichier de
	configuration du noyau</link>.</para>

      <para>La commande</para>

      <screen><userinput><command>tcpdump</command> -c 4000 -s 10000 -w <replaceable>dumpfile.bin</replaceable></userinput></screen>

      <para>capturera 4000 paquets bruts dans le fichier
	<replaceable>dumpfile.bin</replaceable>.  Dans cet exemple
	jusqu'&agrave; 10000 octets par paquets seront
	capturés.</para>
    </sect2>
  </sect1>

  <sect1>
    <title>L'expérience</title>

    <para>Voici l'expérience:</para>

    <procedure>
      <step>
	<para>Ouvrez une fenêtre sur un hôte IPSec et une
	  autre sur un hôte non sécurisé.</para>
      </step>

      <step>
	<para>Maintenant commencez &agrave; <link linkend="tcpdump">capturer
	  les paquets</link>.</para>
      </step>

      <step>
	<para>Dans la fenêtre &ldquo;sécurisée&rdquo;,
	  lancez la commande &unix; &man.yes.1;, qui fera défiler
	  le caractère <literal>y</literal>.  Au bout d'un moment,
	  arrêtez cela.  Passez &agrave; la fenêtre non
	  sécurisée, et faites de même.  Au bout
	  d'un moment, arrêtez.</para>
      </step>

      <step>
	<para>Maintenant lancez <link linkend="code">MUST</link> sur les
	  paquets capturés.  Vous devriez voir quelque chose de
	  semblable &agrave; ce qui suit.  Ce qui est important de noter est
	  que la connexion non sécurisée a 93% (6,7) de valeurs
	  attendues (7,18), et la connexion &ldquo;normale&rdquo; a 29%
	  (2,1) de valeurs attendues.</para>

    <screen>&prompt.user; <userinput>tcpdump -c 4000 -s 10000 -w <replaceable>ipsecdemo.bin</replaceable></userinput>
&prompt.user; <userinput>uliscan <replaceable>ipsecdemo.bin</replaceable></userinput>

Uliscan 21 Dec 98
L=8 256 258560
Measuring file ipsecdemo.bin
Init done
Expected value for L=8 is 7.1836656
6.9396 --------------------------------------------------------
6.6177 -----------------------------------------------------
6.4100 ---------------------------------------------------
2.1101 -----------------
2.0838 -----------------
2.0983 -----------------</screen>
      </step>
    </procedure>
  </sect1>

    <sect1 id="caveat">
      <title>Mise en garde</title>

    <para>Cette expérience montre qu'IPSec <emphasis>semble</emphasis>
      distribuer les données utiles
      <emphasis>uniformément</emphasis> comme un chiffrement
      le devrait.  Cependant, l'expérience décrite
      ici <emphasis>ne peut pas</emphasis> détecter les
      problèmes possibles dans un système.  Ceux-ci
      peuvent être la génération ou l'échange
      d'une clé faible, des données ou clés visibles
      par d'autres, l'utilisation d'algorithmes faibles, code du noyau
      modifié, etc...
      Etudiez les sources, maîtrisez le code.</para>
  </sect1>

  <sect1 id="IPsec">
    <title>IPSec - Définition</title>

    <para>Extensions de sécurité au protocole internet
      IPv4, requises pour l'IPv6.  Un protocole pour le chiffrement et
      l'authentification au niveau IP (hôte &agrave; hôte).
      SSL sécurise uniquement une socket d'application;
      <application>SSH</application> sécurise seulement une session;
      <application>PGP</application> sécurise uniquement un fichier
      spécifique ou un message.  IPSec chiffre tout entre deux
      hôtes.</para>
  </sect1>

  <sect1 id="ipsec-install">
    <title>Installation d'IPSec</title>

    <para>La plupart des versions récentes de FreeBSD ont le support
      IPSec dans leurs sources de base.  Aussi vous devrez probablement
      ajouter l'option <option>IPSEC</option> dans votre configuration de noyau
      et, après la compilation et l'installation du noyau, configurer
      les connexions IPSec en utilisant la commande
      &man.setkey.8;.</para>

    <para>Un guide complet sur l'utilisation d'IPSec sous FreeBSD est
      fourni dans le <ulink url="../../books/handbook/ipsec.html">Manuel
      de Freebsd</ulink>.</para>
  </sect1>

  <sect1 id="kernel">
    <title>src/sys/i386/conf/KERNELNAME</title>

    <para>Ce qui suit doit être présent dans le fichier de
      configuration du noyau afin de pouvoir capturer les données
      réseau avec &man.tcpdump.1;.  Soyez-sûr de lancer
      &man.config.8; après avoir rajouté la ligne
      ci-dessous, et de recompiler et réinstaller.</para>

    <programlisting>device	bpf</programlisting>
  </sect1>

    <sect1 id="code">
      <title>Test statistique universel de Maurer (pour une longueur de
	bloc=8 bits)</title>

        <para>Vous pouvez trouver le même code source <ulink
          url="http://www.geocities.com/SiliconValley/Code/4704/uliscanc.txt">
          ici</ulink>.</para>

<programlisting>/*
  ULISCAN.c   ---blocksize of 8

  1 Oct 98
  1 Dec 98
  21 Dec 98       uliscan.c derived from ueli8.c

  This version has // comments removed for Sun cc

  This implements Ueli M Maurer's "Universal Statistical Test for Random
  Bit Generators" using L=8

  Accepts a filename on the command line; writes its results, with other
  info, to stdout.

  Handles input file exhaustion gracefully.

  Ref: J. Cryptology v 5 no 2, 1992 pp 89-105
  also on the web somewhere, which is where I found it.

  -David Honig
  honig@sprynet.com

  Usage:
  ULISCAN filename
  outputs to stdout
*/

#define L 8
#define V (1&lt;&lt;L)
#define Q (10*V)
#define K (100   *Q)
#define MAXSAMP (Q + K)

#include &lt;stdio.h&gt;
#include &lt;math.h&gt;

int main(argc, argv)
int argc;
char **argv;
{
  FILE *fptr;
  int i,j;
  int b, c;
  int table[V];
  double sum = 0.0;
  int iproduct = 1;
  int run;

  extern double   log(/* double x */);

  printf("Uliscan 21 Dec 98 \nL=%d %d %d \n", L, V, MAXSAMP);

  if (argc &lt; 2) {
    printf("Usage: Uliscan filename\n");
    exit(-1);
  } else {
    printf("Measuring file %s\n", argv[1]);
  }

  fptr = fopen(argv[1],"rb");

  if (fptr == NULL) {
    printf("Can't find %s\n", argv[1]);
    exit(-1);
  }

  for (i = 0; i &lt; V; i++) {
    table[i] = 0;
  }

  for (i = 0; i &lt; Q; i++) {
    b = fgetc(fptr);
    table[b] = i;
  }

  printf("Init done\n");

  printf("Expected value for L=8 is 7.1836656\n");

  run = 1;

  while (run) {
    sum = 0.0;
    iproduct = 1;

    if (run)
      for (i = Q; run &amp;&amp; i &lt; Q + K; i++) {
        j = i;
        b = fgetc(fptr);

        if (b &lt; 0)
          run = 0;

        if (run) {
          if (table[b] &gt; j)
            j += K;

          sum += log((double)(j-table[b]));

          table[b] = i;
        }
      }

    if (!run)
      printf("Premature end of file; read %d blocks.\n", i - Q);

    sum = (sum/((double)(i - Q))) /  log(2.0);
    printf("%4.4f ", sum);

    for (i = 0; i &lt; (int)(sum*8.0 + 0.50); i++)
      printf("-");

    printf("\n");

    /* refill initial table */
    if (0) {
      for (i = 0; i &lt; Q; i++) {
        b = fgetc(fptr);
        if (b &lt; 0) {
          run = 0;
        } else {
          table[b] = i;
        }
      }
    }
  }
}</programlisting>
  </sect1>
</article>