doc/documentation/content/da/articles/ipsec-must/_index.adoc

---
title: Uafhængig Verifikation af IPsec Funktionalitet i FreeBSD
authors:
  - author: David Honig
    email: honig@sprynet.com
releaseinfo: "$FreeBSD$" 
trademarks: ["freebsd", "opengroup", "general"]
---

= Uafhængig Verifikation af IPsec Funktionalitet i FreeBSD
:doctype: article
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:source-highlighter: rouge
:experimental:
:toc-title: Indholdsfortegnelse
:table-caption: Tabel
:figure-caption: Figur
:example-caption: Eksempel

[.abstract-title]
Resumé

Dansk version af Laust S. Jespersen Laust@doc.freebsd.dk.

Du installerede IPsec og det ser ud til at virke. Men hvordan ved du det? Jeg beskriver en metode til eksperimentalt at verificere at IPsec virker.

'''

toc::[]

[[problem]]
== Problemet

Lad os antage, at du har <<ipsec-install>>. Hvordan ved du at det <<caveat>>? Selvfølgelig virker din forbindelse ikke hvis den er miskonfigureret, og den vil virke når du endelig laver det rigtigt. man:netstat[1] lister den. Men kan du verificere det uafhængigt?

[[solution]]
== Løsningen

Først, noget krypto-relevant teoretisk information:

. krypterede data er uniformt distribueret, som f.eks. har maksimal entropi pr. symbol;
. rå, ukomprimerede data er typisk redundant, f.eks., har sub-maksimal entropi.

Hvis du kunne måle entropien af dataene til og fra dit netværks interface. Så kunne du se forskellen mellem ukrypterede og krypterede data. Det ville være tilfældet selvom nogle af dataene i "krypteret mode" ikke var krypterede, som f.eks. den yderste IP header skal være, hvis pakken skal kunne routes.

[[MUST]]
=== MUST

Ueli Maurers "Universal Statistical Test for Random Bit Generators" (http://www.geocities.com/SiliconValley/Code/4704/universal.pdf[MUST]) måler hurtigt entropien af en stikprøve. Den bruger en kompressionsagtig algoritme. <<code>> til en variant der måler successive (~kvart megabyte) store bidder af en fil.

[[tcpdump]]
=== Tcpdump

Vi har også brug for en måde at opsamle de rå netværksdata. Et program kaldet man:tcpdump[1] lader dig gøre dette, hvis du har slået _Berkeley Packet Filter_ interfacet til i din <<kernel>>.

Kommandoen

[source,bash]
....
tcpdump -c 4000 -s 10000 -w dumpfile.bin
....

vil opfange 4000 rå pakker til _dumpfile.bin_. Op til 10.000 bytes per pakke bliver opfanget i dette eksempel.

[[experiment]]
== Eksperimentet

Her er eksperimentet:

[.procedure]
====
. Åbn et vindue til en IPsec vært og et andet vindue til en usikker vært.
. Start nu med at <<tcpdump>>.
. I det "sikre" vindue, køres UNIX(R) kommandoen man:yes[1], hvilket vil streame `y` karakteren. Stop dette efter et stykke tid. Skift til det usikre vindue, og gentag. Stop igen efter et stykke tid.
. Kør nu <<code>> på de opfangede pakker. Du skulle se noget lignende det følgende. Det vigtige at notere sig er, at den sikre forbindelse har 93% (6,7) af den ventede værdi (7.18), og den "normale" forbindelse har 29% (2.1) af den ventede værdi.
+
[source,bash]
....
% tcpdump -c 4000 -s 10000 -w ipsecdemo.bin
% uliscan ipsecdemo.bin
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 -----------------
....
====

[[caveat]]
== Undtagelse

Dette eksperiment viser at, IPsec _kan_ se ud til at distribuere payload data __uniformt__, som kryptering skal. Men det eksperiment der er beskrevet her _kan ikke_ detektere mange mulige fejl i et system (ingen af hvilke jeg har nogle beviser for). Disse inkluderer dårlig nøgle generering eller udveksling, data eller nøgler der kan ses af andre, brug af svage algoritmer, kernel undergravning, osv. Studér kildekoden; kend kildekoden.

[[IPsec]]
== IPsec---Definition

Internet Protokol sikkerheds udvidelser til IPv4; krævet for IPv6. En protokol til at forhandle kryptering og autentifikation på IP (vært-til-vært) niveau. SSL sikrer kun en applikationssocket; SSH sikrer kun et login; PGP sikrer kun en specifik fil eller besked. IPsec krypterer alting mellem to værter.

[[ipsec-install]]
== Installering af IPsec

De fleste af de moderne versioner af FreeBSD har IPsec support i deres base kildekode. Så du er sikkert nødt til at inkludere `IPSEC` optionen i din kernel konfig og, efter genbygning og reinstallation af kernel, konfigurere IPsec forbindelser ved hjælp af man:setkey[8] kommandoen.

En udførlig guide om at køre IPsec på FreeBSD er tilrådighed i link:{handbook}#ipsec[FreeBSD Håndbogen].

[[kernel]]
== src/sys/i386/conf/KERNELNAME

Dette skal være til stede i kernel konfig filen for at være i stand til at opfange netværksdata med man:tcpdump[1]. Vær sikker på at køre man:config[8] efter at tilføje dette, og genbygge og reinstallere.

[.programlisting]
....
device	bpf
....

[[code]]
== Maurers universelle statistiske test (for blok størrelse=8 bits)

Du kan finde samme kode på http://www.geocities.com/SiliconValley/Code/4704/uliscanc.txt[dette link].

[.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<<L)
#define Q (10*V)
#define K (100   *Q)
#define MAXSAMP (Q + K)

#include <stdio.h>
#include <math.h>

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 < 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 < V; i++) {
    table[i] = 0;
  }

  for (i = 0; i < 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 && i < Q + K; i++) {
        j = i;
        b = fgetc(fptr);

        if (b < 0)
          run = 0;

        if (run) {
          if (table[b] > 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 < (int)(sum*8.0 + 0.50); i++)
      printf("-");

    printf("\n");

    /* refill initial table */
    if (0) {
      for (i = 0; i < Q; i++) {
        b = fgetc(fptr);
        if (b < 0) {
          run = 0;
        } else {
          table[b] = i;
        }
      }
    }
  }
}
....