% ************************************************************
% *****                   Studienarbeit                  *****
% *****                                                  *****
% *****      Vergleichende Analyse und VHDL-basierte     *****
% *****    Implementation von Zufallszahlengeneratoren   *****
% *****            auf Chipkarten (SmartCards)           *****
% *****                                                  *****
% *****        von Peter Hartmann und Stefan Witt        *****
% ************************************************************

% Anmerkungen: - übersetzen in Arbeit.dvi mit:
%                latex Arbeit.tex
%                --> ACHTUNG: Erst bei zweimaligen Übersetzen werden Änderungen in der
%                             Seitennummerierung und im Inhaltsverzeichnis übernommen!
%              - DVI-Datei ansehen:
%                xdvi Arbeit.dvi
%              - von DVI nach PS konvertieren:
%                dvips Arbeit.dvi
%                (unter Solaris jedoch: dvips -o Arbeit.ps Arbeit.dvi)
%              - von PS nach PDF konvertieren:
%                ps2pdf Arbeit.ps
%              - Eine Übersicht zu den LaTeX-Befehlen ist zu finden unter (SuSE-Linux 7.0):
%                /usr/share/doc/packages/te_latex/texmf/latex/latex2e-html/ltx-2.html
%              - Eine Übersicht über teTeX ist zu finden unter (SuSE-Linux 7.0):
%                /usr/share/doc/packages/te_latex/texmf/index.html


% ************************************************************
% *****                 LaTeX2e-Präambel                 *****
% ************************************************************

% Dokomentenklasse : Artikel
% gewählte Optionen: - 11pt     : 11 Punkt-Schrift
%                    - a4paper  : DIN A4-Papier
%                    - twoside  : doppelseitig (d.h. linke und rechte Seite unterschiedlich)
%                    - titlepage: Titelseite, Abstract und Inhaltsverzeichnis auf mehreren Seiten
\documentclass[11pt,a4paper,twoside,titlepage]{article}


% ***** notwendige Packages *****

% *** algorithmic ***
% Paket: algorithmic
% Zweck: Float-Formatierung für Algorithmen
% Doku : Dokumentation zu finden unter (SuSE-Linux 7.0):
%        /usr/share/doc/packages/te_latex/texmf/latex/styles/algorithms.dvi
\usepackage{algorithmic}

% *** amsfonts ***
% Paket  : amsfonts
% Zweck  : für spezielle Mathematik-Schriftarten (z.B. geschwungenes NP)
% Hinweis: Die Symbole erhält man mit \mathcal{NP}
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/fonts/amsfonts/amsfndoc.dvi
\usepackage{amsfonts}
% ausgefülltes Quadrat definieren; die Doku zu folgendem Kommando und die Symboltabellen sind in (SuSE 7.0):
% /usr/share/doc/packages/te_latex/texmf/fonts/amsfonts/amsfndoc.dvi   (Seite 18 und 19)
\newsymbol\blacksquare 1004

% *** amsmath ***
% Paket  : amsmath
% Zweck  : für spezielle Mathematik-Symbole (z.B. natürliche und reelle Zahlen)
% Hinweis: Die Symbole erhält man mit \mathbb{N}
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/latex/amsmath/amsldoc.dvi
\usepackage{amsmath}

% *** fancyhdr ***
% Paket  : fancyhdr
% Zweck  : für Seitenlayout
% Hinweis: siehe "Seitenlayout" unten
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/latex/fancyhdr/fancyhdr.dvi
\usepackage{fancyhdr}

% *** fancyvrb ***
% Paket  : fancyvrb
% Zweck  : für das Einfügen von Quellcode
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/latex/fancyvrb/fancyvrb.ps
\usepackage{fancyvrb}

% *** floatflt ***
% Paket  : floatflt
% Zweck  : für Textfluss um Abbildungen und Tabellen
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/latex/floatflt/floatflt.dvi
\usepackage{floatflt}

% *** geometry ***
% Paket   : geometry
% Zweck   : Anpassungen an DIN A4-Papiergröße
% Optionen: a4paper -- DIN A4-Papier
%           twoside -- doppelseitiger Druck (linke und rechte Seite verschieden)
% Doku    : Dokumentation zu finden unter (SuSE-Linux 7.0):
%           /usr/share/doc/packages/te_latex/texmf/latex/geometry/geometry.dvi
\usepackage[a4paper,twoside]{geometry}

% *** graphics ***
% Paket  : graphics
% Zweck  : zum Einbinden von EPS-Graphiken
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/latex/graphics/grfguide.ps
\usepackage{graphics}

% *** ngerman ***
% Paket  : ngerman
% Zweck  : für Umlaute, deutsche Silbentrennung usw.
% Hinweis: ngerman benutzt im Gegensatz zu german die neue Rechtschreibung
%          (wichtig für die Silbentrennung)
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/generic/styles/gerdoc.dvi
\usepackage{ngerman}
\selectlanguage{german} % Dokumentensprache auf deutsch stellen

% *** pifont ***
% Paket  : pifont
% Zweck  : Font mit dem Symbol für Spiegelstriche
% Doku   : Dokumentation zu finden unter (SuSE-Linux 7.0):
%          /usr/share/doc/packages/te_latex/texmf/fonts/fontname/fontname.dvi (Seite 5)
\usepackage{pifont}
\renewcommand\labelitemi[0]{\ding{235}} % 3D-Rechtspfeil für Spiegelstriche

% *** times ***
% Paket: Times
% Zweck: Schrift Times benutzen (sieht wesentlich besser als die Standardschrift aus)
\usepackage{times}

% *** tocbibind ***
% Paket   : tocbibind
% Zweck   : Literaturverzeichnis u.a. sollen ins Inhaltsverzeichnis
% Optionen: nottoc -- Seitennr. des Inhaltsverzeichnisses nicht ins Inhaltsverzeichnis
% Doku    : Dokumentation zu finden unter (SuSE-Linux 7.0):
%           /usr/share/doc/packages/te_latex/texmf/latex/tocbibind/tocbibind.dvi
\usepackage[nottoc]{tocbibind}


% ***** Seitenformat *****

% Hier wird das globale Seitenlayout eingestellt. Dazu wird das Paket fancyhdr benutzt (s.o.).
\fancyhead[LE,RO]{\slshape \thepage} % Seitennummer auf geraden Seiten links, auf ungeraden rechts
\fancyhead[LO]{\slshape \rightmark}  % auf ungeraden Seiten links die Bezeichnung des Unterabschnitts
\fancyhead[RE]{\slshape \leftmark}   % auf geraden Seiten rechts den Abschnittsnamen
\fancyfoot{}                         % Fußzeile leer
\pagestyle{fancy}                    % Fancy-Layout für das Dokument benutzen
\setlength{\parindent}{7pt}          % kleinen Absatzeinzug benutzen
\begin{document}                     % und los!



% ************************************************************
% *****                    Titelseite                    *****
% ************************************************************

\author{~\vspace{-2cm} \\~Universit"at Hamburg \\~\\ Fachbereich Informatik \\
       ~\vspace{2cm} \\
       Autoren:\\~\\Peter~Hartmann~(mail@mathematic.de), Stefan~Witt~(post@stefan-witt.de)}
\title{Studienarbeit\\ \vspace{1cm} Vergleichende Analyse und VHDL-basierte Implementation von
       Zufallszahlengeneratoren auf Chipkarten (SmartCards)\vspace{3cm}}
\date{\vspace{5cm}\today}
\maketitle


% ************************************************************
% *****                     Abstract                     *****
% ************************************************************

% ***** deutsche Zusammenfassung *****
\renewcommand{\abstractname}{} % Überschrift der Zusammenfassung ändern (bauen wir selber)
\begin{abstract}
\setcounter{page}{2}

\paragraph{\hspace{7cm} Zusammenfassung} \quad \newline

Zufallszahlen haben die unterschiedlichsten Anwendungsgebiete. Ein immer wichtiger werdendes Einsatzgebiet sind
Chipkarten. Die Zufallszahlen werden dort vor allem zur Produktsicherung benutzt. Erzeugt werden sie von
Zufallsgeneratoren, die mit mathematischen Verfahren Zahlen liefern. In der vorliegenden Studienarbeit haben wir vier 
Zufallszahlengeneratoren auf ihre Eignung f"ur eine Chipkartenimplementation untersucht. Die Generatoren erzeugen 
die Zufallszahlen auf unterschiedliche Weise, mit einem linear r"uckgekoppelten Schieberegister, mit quadratischen 
Resten, mit Permutationen und mit Punktverdopplung "uber einer elliptischen Kurve. Die Ergebnisse werden hier vergleichend 
dargestellt. Die einzelnen Zufallszahlengeneratoren sind f"ur die statistische Untersuchung in der Programmiersprache C
implementiert und f"ur die praktische Untersuchung in der Hardwarebeschreibungssprache VHDL.

% ***** englische Zusammenfassung *****
\vspace{2cm}
\paragraph{\hspace{8cm}Abstract} \quad \newline

Random numbers are used in many different domains. An increasingly important domain is smart cards, in which random
numbers are mainly used for protection of products. They are generated by random number generators, which provide
numbers by mathematical methods. In this study we have examined four different random
number generators with respect to their suitability of implementing them on smart cards. The generators produce
random numbers in different ways: With a linear feedback shift register, with quadratic residui, with permutations,
and with doubling of points over an elliptic curve. The results are presented and compared. All these random number
generators have been implemented for the statistic analysis in the programming language C and for the practical
analysis in the hardware description language VHDL.

\end{abstract}



% ************************************************************
% *****                Inhaltsverzeichnis                *****
% ************************************************************

% ACHTUNG: Wenn das Paket titlesec benutzt wird, wird das
%          Inhaltsverzeichnis falsch dargestellt.
%          Offenbar vertragen sich die Pakete titlesec
%          und tocbibind nicht.

%\thispagestyle{empty} % Leerseite, damit das Inhaltsverzeichnis auf der rechten Seite erscheint
%~
%\newpage
\setcounter{page}{3} % Seitennummer richtig setzen (ist sonst falsch!)
\enlargethispage{1cm}
\tableofcontents
\newpage


% ************************************************************
% *****              Kapitel 1 (Einleitung)              *****
% ************************************************************

\thispagestyle{empty} % Leerseite, damit die Einleitung auf der rechten Seite beginnt
~
\newpage
\section{Einleitung} \label{einleitung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.3cm}(von Stefan Witt)}}

Chipkarten geh"oren mittlerweile zum allt"aglichen Leben und werden mit Selbstverst"andlichkeit benutzt --
beispielsweise Telefonkarten, Geldkarten,
oder Krankenversicherungskarten, um nur einige zu nennen.
,,Ende 2000 waren in Deutschland knapp 18 Mio.
Kreditkarten im Umlauf, zusammen mit den EC-Karten befanden sich rund
100 Mio. Zahlungskarten in deutschen Portemonnaies`` (aus: \cite[S.12]{barnick}).
 Immer dann, wenn es im Zusammenhang mit Chipkarten um
Sicherheit geht, so zum Beispiel um Schutz vor dem unerlaubten Kopieren der Karten oder um Authentifikation, spielen
Zufallszahlen eine wichtige Rolle. Wegen des gro"sen Bedarfs an Sicherheit ist es daher von Bedeutung, sich mit
Zufallszahlengeneratoren auseinanderzusetzen.

In dieser Studienarbeit werden aus diesem Grund vier verschiedene Algorithmen untersucht, die Zufallszahlen erzeugen.
Aus dem Anwendungsgebiet der Chipkarten ergeben sich drei fundamentale Anforderungen, die die Zufallsgeneratoren
erf"ullen m"ussen:

Erstens m"ussen sie dazu geeignet sein, auf Chipkarten implementiert zu werden. Durch die
Implementation {\em auf} der Chipkarte ist gew"ahrleistet, dass der Zustand des Zufallsgenerators nicht von au"sen
angesehen werden kann, weil er in der Karte gekapselt ist und die Karte sehr gut gegen unerlaubtes Auslesen gesch"utzt ist.
Alle vier in dieser Arbeit untersuchten Zufallsgeneratoren erf"ullen diese Eigenschaft, und sie werden exemplarisch
in der Hardwarebeschreibungssprache VHDL umgesetzt.

Zweitens m"ussen die Zufallsgeneratoren deterministisch sein, das hei"st mehrere identische Zufallsgeneratoren
erzeugen unabh"angig voneinander dieselben Zufallszahlen in derselben Reihenfolge. Obwohl diese Eigenschaft in
der Literatur im Allgemeinen als nachteilig angesehen wird, ist sie f"ur viele Anwendungen notwendig. Beispielsweise
wird der Determinismus ben"otigt, um Duplikate von Chipkarten aufzudecken, indem die erzeugte Zufallszahlenfolge des
Generators auf der Chipkarte mit der Zahlenfolge eines identischen Zufallsgenerators verglichen wird. Alle in
dieser Studienarbeit analysierten Generatoren erf"ullen die Eigenschaft des Determinismus'.

Die dritte Anforderung ist, dass die Zufallsgeneratoren skalierbar sein sollen. Das bedeutet, dass die Anzahl der Bits,
aus denen die Zufallszahlen bestehen, beliebig eingestellt werden kann. Dadurch wird eine skalierbare
Sicherheit gew"ahrleistet, an der es gro"sen Bedarf gibt. Sie bietet die M"oglichkeit, zwischen verschiedenen
Sicherheitsanforderungen beliebig zu w"ahlen. Diese Studienarbeit zielt explizit auf den Low-Security-Bereich ab und
setzt deshalb als obere Grenze f"ur die Bitbreite der Zufallsgeneratoren 20 Bit. Im Low-Security-Bereich sind
im Allgemeinen 10 Bit bereits ausreichend. Der Ausschluss der Anwendungsgebiete mit sehr hohen Sicherheitsanforderungen
ist allerdings kein Nachteil: Der Low-Security-Bereich gewinnt zunehmend an Bedeutung, beispielsweise wird
zur Sicherung von Produkten, die nach einem Verfallsdatum wertlos werden, lediglich Low-Security-Schutz ben"otigt.

\paragraph{"Uberblick "uber die folgenden Kapitel} \quad \newline

Kapitel~\ref{motivation} stellt verschiedene Anwendungsbereiche vor, in denen Zufallszahlen ben"otigt werden. Dazu
z"ahlen auch Anwendungen, die noch nicht realisiert sind, sondern erst in der n"aheren Zukunft umgesetzt werden.

In Kapitel~\ref{grundlagen} werden die Grundlagen vorgestellt, auf die in den darauf folgenden Kapiteln aufgebaut
wird. Das sind Zufallszahlen und Zufallsgeneratoren, Gruppentheorie, elliptische Kurven und statistische Verfahren
als mathematische Grundlagen sowie eine Einf"uhrung in die Technik von Chipkarten.

Kapitel~\ref{analyseverfahren} beschreibt Eigenschaften, die Zufallsgeneratoren erf"ullen sollen, und Bewertungsverfahren,
um diese Eigenschaften zu pr"ufen.

In Kapitel~\ref{zzg} werden vier ausgew"ahlte Zufallsgeneratoren vorgestellt und die von ihnen erzeugten Zufallszahlen
analysiert.

In Kapitel~\ref{impl} werden die Implementationen in C und VHDL der zuvor vorgestellten Zufallsgeneratoren
dargestellt und untersucht.

Kapitel~\ref{schluss} gibt schlie"slich einen zusammenfassenden "Uberblick und zeigt weitere Perspektiven auf.


% ************************************************************
% *****          Kapitel 2 (Wozu Zufallszahlen?)         *****
% ************************************************************

\newpage
\addtocontents{toc}{}
\section{Motivation -- Wozu Zufallszahlen?} \label{motivation}

In diesem Kapitel sollen verschiedene Anwendungsbereiche f"ur Zufallszahlengeneratoren vorgestellt werden. Dabei
liegt das Hauptaugenmerk auf solchen Anwendungsgebieten, in denen Chipkarten eingesetzt werden oder werden k"onnten.
Einige der vorgestellten Anwendungen sind noch nicht realisiert, werden aber in der n"aheren Zukunft fraglos Einzug in das
allt"agliche Leben erlangen und immens an Bedeutung gewinnen.

% ************************** Schutz vor unerlaubtem Kopieren von Chipkarten **************************

\subsection{Schutz vor unerlaubtem Kopieren von Chipkarten \hspace{2.7cm}} \label{low-security} % Platz für Namen lassen
% Zeile zurück und Autor neben den Eintrag schreiben. Dieser Umstand ist nötig, weil der Name nicht in den
% lebendigen Überschriften erscheinen soll und das ifthen-Package nicht im Inhaltsevrzeichnis funktioniert. 
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{9.1cm}(von Stefan Witt)}}

Der wichtigste Anwendungsbereich f"ur Zufallsgeneratoren auf Chipkarten ist der Schutz vor dem unberechtigten Kopieren.
Es gibt grunds"atzlich zwei M"oglichkeiten, wer versuchen k"onnte, so eine Kopie anzufertigen: Entweder ist es der
Besitzer der Karte selbst oder eine Person, die kurzzeitig im Besitz der Karte war, beispielsweise ein Dieb.
Wer Interesse haben kann, eine Chipkarte zu duplizieren, h"angt ganz von der Art der Chipkarte ab. F"ur beide F"alle
sollen Beispiele angegeben werden.


\paragraph{Kopieren einer Telefonkarte} \quad \newline

Der Besitzer einer handels"ublichen Telefonkarte f"ur "offentliche Telefonzellen k"onnte versuchen, eine illegale
Kopie seiner Telefonkarte anzufertigen. Welchen Vorteil er dadurch erh"alt, ist klar -- er verdoppelt oder vervielfacht
das Guthaben der Karte. Gesch"adigt wird durch die kopierte Karte die Telefongesellschaft, die die Telefonkarten verkauft. Sie muss also ihre Telefonkarten vor dem Duplizieren sch"utzen.

Dazu ben"otigt jede Karte eine eindeutige Kennung, die auf der Karte abgespeichert und der Telefongesellschaft
bekannt ist. Jedes Mal, wenn die Karte in einer Telefonzelle benutzt wird, wird diese Kennung an den Rechner der
Telefongesellschaft "ubermittelt, und alle Benutzungszeitpunkte der Telefonkarte werden nachvollzogen. Als Schutz vor
dem unerlaubten Kopieren reicht das allein aber nicht aus, weil der Besitzer der Karte die kopierte Karte mit derselben
Kennung versehen kann.

Als L"osung werden zus"atzlich zwei identische Zufallszahlengeneratoren verwendet: Einer befindet sich auf der
Telefonkarte und der andere auf dem Rechner der Telefongesellschaft. Beide Generatoren m"ussen mit demselben Startwert
initialisiert werden (siehe Kapitel \ref{zufallszahlen}), so dass sie bei jeder erneuten Ausf"uhrung beide jeweils
dieselbe Zufallszahl erzeugen. Dann ist es m"oglich, dass die Telefonkarte bei der Benutzung eine Zufallszahl erzeugt,
diese an den Rechner der Telefongesellschaft sendet und dieser durch den Aufruf seines Zufallszahlengenerators pr"uft,
ob es sich um dieselbe Zufallszahl handelt. Eine Telefonkarte muss also die richtige Kennung und die jeweils g"ultige
Zufallszahl senden.

Auf diese Weise ist es m"oglich, festzustellen, ob eine Kopie der Telefonkarte angefertigt wurde: Das Original und die
Kopie benutzen denselben Zufallszahlengenerator, und daher liefern beide bei der ersten Benutzung nach dem Duplizieren
dieselbe Zufallszahl.
Wenn die Originalkarte nach dem Duplizieren erstmalig benutzt wird, berechnet sie eine Zufallszahl, die der Rechner der
Telefongesellschaft als g"ultig anerkennt. Wenn daraufhin die Kopie benutzt wird, liefert sie genau die Zufallszahl,
die die Originalkarte zuvor erzeugt hat. Der Recher der Telefongesellschaft weist diese Zahl als ung"ultig zur"uck,
weil er bereits die n"achste Zufallszahl in der Sequenz der vom benutzten Generator erzeugten Zufallszahlen erwartet.
Somit wird die Kopie zur"uckgewiesen und kann nicht zum Telefonieren benutzt werden.

Es k"onnte jedoch auch der umgekehrte Fall eintreten, dass zuerst die Kopie benutzt wird. Dann wird das Original
zur"uckgewiesen. Es ist also nicht m"oglich, festzustellen, welche Karte das Original und welche die Kopie ist,
sondern nur, dass eine unerlaubte Kopie angefertigt wurde. Bei dieser Anwendung ist das auch nicht von Bedeutung,
weil die Telefongesellschaft trotzdem die Benutzung zweier identischer Telefonkarten verhindern kann.


\paragraph{Kopieren einer Geldkarte} \quad \newline

Auch bei Geldkarten, beispielsweise EC-Karten (,,Electronic Cash``), ist es notwendig, das unerlaubte Kopieren der
Karten zu erkennen. Es kann zwar passieren, dass eine Geldkarte entwendet wird, allerdings wird ein Dieb nicht
versuchen, die gestohlene Karte zu kopieren, weil er ja mithilfe der Karte direkt auf das Konto des Karteneigent"umers
zugreifen kann.

Es kann stattdessen der Fall eintreten, dass ein Verk"aufer, der ein Kartenleseger"at an der Kasse
benutzt, dieses f"alscht. Das gef"alschte Ger"at liest aus der Karte des ahnungslosen Kunden die Kartenkennung aus und
speichert die vom Kunden eingegebene Geheimzahl, verh"alt sich aber ansonsten wie ein echtes Leseger"at, das hei"st es
"ubermittelt die Kennung und die Geheimzahl an die Bank. Der Kunde bemerkt den gef"alschten Kartenleser nicht, weil
die Buchung sich f"ur ihn nicht von einer an einem echten Leseger"at unterscheidet. Durch die Speicherung der
Kartenkennung und der Geheimzahl hat der Verk"aufer nun aber die M"oglichkeit, eine illegale Kopie der Geldkarte
anzufertigen, die er dazu benutzen kann, um Geld vom Konto des Kartenbesitzers abzubuchen.

Auch dieser Versuch des unerlaubten Kopierens kann mithilfe von Zufallszahlen verhindert werden. Dazu wird die
gleiche Methode benutzt wie bei der Verhinderung des Duplizierens von Telefonkarten (siehe oben, Abschnitt ,,Kopieren
einer Telefonkarte``): Auf der Geldkarte
und auf dem Rechner der Bank werden identische Zufallszahlengeneratoren verwendet. Bei jeder Transaktion erzeugt die
Geldkarte eine neue Zufallszahl und "ubermittelt sie an die Bank. Der Rechner der Bank erzeugt ebenfalls die n"achste
Zufallszahl der Sequenz und pr"uft, ob sie mit der Zahl "ubereinstimmt, die die Geldkarte gesendet hat. Wenn das nicht
der Fall ist, wird die Geldkarte gesperrt, weil sie als gef"alscht erkannt wurde.

Es k"onnen hierbei wiederum zwei F"alle eintreten: Entweder f"uhrt der Verk"aufer mit der gef"alschten Karte oder
der rechtm"a"sige Kartenbesitzer mit der Originalkarte die n"achste Transaktion oder die n"achsten Transaktionen durch.
Im ersten Fall wird die Karte des Kunden gesperrt, weil die gef"alschte Karte bereits die folgende Zufallszahl an die
Bank "ubermittelt hat und die Originalkarte die bereits ung"ultig gewordene Zufallszahl an die Bank sendet. Im zweiten
Fall wird die Karte des Verk"aufers gesperrt, weil sie eine bereits ung"ultige Zufallszahl "ubermittelt. Das hat zur
Folge, dass auch die Originalkarte gesperrt wird, weil sie dieselbe Kartenkennung besitzt.

In beiden F"allen bemerkt also der rechtm"a"sige Kartenbesitzer, dass seine Geldkarte gesperrt ist. Au"serdem kann die
Bank genau nachvollziehen, welcher Verk"aufer die Geldkarte gef"alscht hat, indem sie die an sie "ubermittelten
Zufallszahlen vergleicht. Die Bank muss nur pr"ufen, welche Zufallszahl doppelt an sie gesendet wurde. Die Transaktion
{\it vor} dem ersten Auftreten der doppelten Zufallszahl\footnote{In der Sequenz der Zufallszahlen kann eine Zahl
selbstverst"andlich doppelt auftreten, obwohl keine F"alschung vorliegt. Dann hat die Bank keine M"oglichkeit,
festzustellen, wann die Karte gef"alscht wurde.} gibt die Transaktion an, bei der der Verk"aufer die Karte
ausgelesen und gef"alscht hat.


% ****************************************** Produktsicherung ****************************************

\subsection{Produktsicherung \hspace{2.7cm}} \label{verschluesselung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{4.1cm}(von Stefan Witt)}}

Zufallszahlen lassen sich dazu benutzen, unautorisierten Zugriff auf Informationen zu verhindern. Dieses geschieht in
engem Zusammenhang mit der Verschl"usselung der betreffenden Informationen.

Die Verschl"usselung der zu sch"utzenden Informationen besitzt einen entscheidenden Nachteil: Sie bietet nicht die
M"oglichkeit von zeitlich begrenzter G"ultigkeit. Mithilfe eines Zufallszahlengenerators hingegen ist es m"oglich, an
definierten Zeitpunkten eine neue Zufallszahl zu generieren. Diese Zeitpunkte werden {\it Transaktionen} genannt.
Im Folgenden werden Anwendungen vorgestellt.


\paragraph{Wechsel von Zust"andigkeiten} \quad \newline

Mittels der Zufallszahlen ist es m"oglich, ein Produkt in einer Wertsch"opfungskette vor Manipulation zu sch"utzen. In
einer solchen Kette sind nacheinander verschiedene Personen f"ur das Produkt zust"andig, wobei jede der Personen mit
einem Ger"at f"ur den Zugriff auf den Gegenstand ausgestattet sein muss. W"unschenswert ist es, jeder der an der
Wertsch"opfung beteiligten Personen nur so lange Zugriff auf das Produkt zu gew"ahren, wie es n"otig ist.

Eine L"osung hierf"ur ist die Verwendung eines Zufallszahlengenerators. Jeder produzierte Gegenstand wird mit einem
Mikrochip ausgestattet, der einen Zufallsgenerator enth"alt, und jeder Bearbeiter erh"alt ein Ger"at, das mit genau
einer Zufallszahl der Sequenz der vom Generator erzeugten Zufallszahlen ausgestattet ist. Das Ger"at wird zum Zugriff
auf die Produktdaten benutzt.

Dabei kennt das Ger"at des ersten Bearbeiters in der Wertsch"opfungskette die erste Zufallszahl der Sequenz, das Ger"at
des zweiten Bearbeiters
die zweite Zufallszahl und so weiter. Sobald eine "Ubergabe des produzierten Gegenstandes an den folgenden Bearbeiter
erfolgt, wird er von der Person abgezeichnet, die ihn weitergibt. Diese Abzeichnung erfolgt mithilfe des Ger"ates des
Bearbeiters. Dabei sendet das Abzeichnungsger"at die Zahl an den Mikrochip, und dieser vergleicht sie mit der zuletzt
mit seinem Generator erzeugten Zufallszahl. Wenn die Zahlen "ubereinstimmen, ist das Ger"at zum Abzeichnen berechtigt,
und der Zufallsgenerator erzeugt die n"achste Zufallszahl. Damit ist ausschlie"slich das Ger"at des folgenden
Bearbeiters zum Zugriff auf die Daten im Chip und zum n"achsten Abzeichnen berechtigt.


\paragraph{Ausleseschutz} \quad \newline

Unabh"angig von Transaktionen sind Zufallszahlen dazu geeignet, mit Chipkarten ausgestattete Produkte vor dem
unautorisierten Auslesen zu sch"utzen, beispielsweise durch die Konkurrenz oder Spione.

 Dazu wird die gleiche Methode wie im obigen Abschnitt ,,Wechsel von Zust"andigkeiten`` benutzt, so dass nur ein
Leseger"at den Chip auslesen kann, das "uber die jeweils g"ultige Zufallszahl verf"ugt.


\paragraph{Diebstahlsicherung} \quad \newline

Zufallszahlen k"onnen auch f"ur die Diebstahlsicherung verwendet werden. Das soll anhand zweier Beispiele erl"autert
werden.

Die elektronischen Komponenten in einem Auto sind "uber einen gemeinsamen Systembus verbunden und
kommunizieren miteinander. Nun kann mithilfe von Zufallsgeneratoren das nachtr"agliche Einbauen einer gestohlenen
Komponente verhindert werden. Dazu muss jede der elektronischen Komponenten mit dem gleichen Zufallsgenerator ausgestattet
werden. Jedes Mal, wenn der Fahrer das Auto startet, wird in allen Komponenten die n"achste Zufallszahl erzeugt.
Wenn alle Komponenten Originale sind, m"ussen alle Zufallszahlen "ubereinstimmen.

In dem Fall, dass eine der Komponenten ausf"allt, muss eine zentrale Komponente mitz"ahlen, wie oft sich eine
Komponente nicht authentifiziert hat und bei jedem Start des Autos eine um eins erh"ohte Anzahl an Zufallszahlen
verlangen. Die ausgefallene Komponente muss nach ihrer Reparatur mehr als eine Zufallszahl senden, und wenn die
letzte dieser Zufallszahlen mit der aktuell g"ultigen Zahl "ubereinstimmt, wird die Komponente akzeptiert.

Wenn ein Betr"uger eine gestohlene Komponente in das Auto einbauen will, beispielsweise einen Airbag
(die Airbag-Sicherung ist momentan aktuell), muss er den Zufallsgenerator kennen, damit die neue Komponente mit der
schon im Auto vorhandenen Elektronik zusammenarbeitet. Wenn das nicht der Fall ist, wird das falsche Teil vom Auto
erkannt, und das Auto kann den Dienst verweigern oder nur in abgeschw"achter Form erbringen.

Momentan in der Entwicklung sind Systeme, die im Falle falscher Komponenten nach und nach das Auto unbrauchbar werden
lassen, beispielsweise durch langfristig abnehmende Leistung des Motors. Das Auto verliert dadurch an Wert, so dass
sich das Einbauen gestohlener Komponenten nicht lohnt.
Momentan aktuell ist die Sicherung von Airbags mithilfe der beschriebenen Methode, so dass gestohlene Airbags
nicht in anderen Autos verwendet werden k"onnen. Ein Airbag, der eingebaut wird und nicht mit dem Bordsystem
zusammenarbeitet, l"ost sofort aus. Eine Dienstverweigerung des Airbags bei einem Unfall kommt nicht in Frage, weil
sie gesetzlich nicht zul"assig ist.

Eine weitere Anwendung zur Diebstahlsicherung sind ferngesteuerte Autoschl"osser, die mit einem Funksender anstatt
eines Autoschl"ussels bedient werden. Beim Senden des Funksignals wird ein Code "ubermittelt, den der Empf"anger
im Auto auf G"ultigkeit pr"uft. Wenn er korrekt ist, "offnet oder schlie"st er die T"urverriegelung, ansonsten nicht.
Ein Angreifer k"onnte einen Empf"anger in der N"ahe des Autos platzieren und das "ubermittelte Funksignal mitlesen, so
dass er den korrekten Code zum "Offnen der T"ur mithilfe eines entsprechend angepassten Senders an den Empf"anger des
Autos senden kann. Der Empf"anger w"urde den Code als korrekt anerkennen und die T"uren "offnen. Dieser Angriff ist als
{\it Replay-Attacke} bekannt.

Um diesen Angriff zu verhindern, m"ussen Sender und Empf"anger mit identischen Zufallsgeneratoren ausgestattet werden.
Der Sender sendet also den Schloss-Code und die n"achste Zufallszahl in der Sequenz. Nur wenn der Code korrekt ist und
die Zufallszahl mit der des Empf"angers "ubereinstimmt, wird das Schloss ge"offnet. Da aber jedes Auto "uber einen
legalen Zweitschl"ussel verf"ugt, muss das Verfahren etwas erweitert werden: Wenn der Zweitschl"ussel verwendet wird,
muss er alle vom Erstschl"ussel bereits gesendeten Zufallszahlen senden und zus"atzlich die n"achste in der Sequenz,
weil diese einem Angreifer nicht bekannt sein kann. Eine Alternative zu diesem Verfahren ist die Verwendung verschiedener
Zufallszahlengeneratoren f"ur jeden legalen Schl"ussel.


% ***************************************** Authentifikation *****************************************

\subsection{Authentifikation \hspace{2.7cm}} \label{authentifikation}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{4cm}(von Stefan Witt)}}

Zufallsgeneratoren k"onnen f"ur die Authentifikation von zwei Kommunikationspartnern, zum Beispiel Nutzer oder Gespr"achspartner, verwendet werden. Unter Authentifikation versteht man den
Nachweis, dass eine Person oder ein Objekt tats"achlich die Identit"at besitzt, die sie bzw. es vorgibt zu sein.
Beispielsweise ist eine Passwortabfrage bei der Anmeldung an einem Rechner ein Authentifikationsvorgang.


\paragraph{Zufallszahlen statt Transaktionsnummern} \quad \newline

Im Bereich der T"atigung von Bankgesch"aften vom heimischen Rechner aus (,,Home-Banking``) werden zurzeit sehr oft
so genannte Transaktionsnummern (TANs) verwendet. Bei jeder Transaktion, die der Kunde durchf"uhren m"ochte, muss er
eine solche Transaktionsnummer angeben, mit der er sich authentifiziert. Er erh"alt von der Bank eine Liste, die
f"ur sein Konto g"ultige Transaktionsnummern enth"alt, und kann bei jeder Transaktion eine Nummer aus dieser Liste
angeben. Dabei ist jede Nummer genau einmal g"ultig, das hei"st der Kunde ben"otigt erneut eine Liste, sobald er alle
Transaktionsnummern einmal benutzt hat.

Die Authentifikation mittels Transaktionsnummern ist in mehrfacher Hinsicht mit Nachteilen behaftet. Zum einen
ist es f"ur den Kunden recht umst"andlich, bei jeder Transaktion eine Nummer aus der Liste herauszusuchen, und zum
anderen hat die Liste den gravierenden Nachteil, dass der Kunde sie verlieren kann. Jeder, der die Liste der
Transaktionsnummern und die Kontonummer besitzt, ist dazu imstande, Buchungen auf dem entsprechenden Konto
durchzuf"uhren.

Das Verfahren kann unter der Verwendung von Zufallszahlengeneratoren wesentlich vereinfacht werden: Sowohl der
Rechner der Bank als auch der des Kunden benutzen denselben Zufallsgenerator. Das bedeutet, dass die jeweils n"achste
g"ultige Transaktionsnummer vom Zufallsgenerator des Kunden erzeugt wird. Sie wird, genauso wie die Transaktionsnummern
des Listenverfahrens, an den Rechner der Bank "ubermittelt, und dieser kann mithilfe seines identischen
Zufallsgenerators die "ubermittelte Zahl pr"ufen. Auf diese Weise muss der Kunde nicht mehr die Liste seiner
g"ultigen Transaktionsnummern verwalten und geht auch nicht das Risiko ein, dass er die Liste verliert.


\paragraph{Schl"usselaustausch} \quad \newline

Wenn zwei Kommunikationspartner "uber einen sicheren Kanal kommunizieren m"ochten, m"ussen sie dazu die auszutauschenden
Daten verschl"usseln. F"ur eine schnelle Verschl"usselung ist ein symmetrisches Verfahren, beispielsweise Triple-DES
(,,Data Encryption Standard``) notwendig. Das Problem, das dabei auftritt, ist das Vereinbaren eines gemeinsamen
Schl"ussels, weil zur Vereinbarung die Kommunikation nur "uber den unsicheren Kanal m"oglich ist.

Zur Vereinbarung eines Schl"ussels gibt es Verfahren, die so genannten {\it Zero-Knowledge-Protokolle}. Ihnen ist
gemeinsam, dass sie einen Zufallszahlengenerator ben"otigen.

Im Folgenden soll eines der Zero-Know\-legde-Pro\-to\-kolle vorgestellt werden, und zwar der Schl"usselaustausch nach dem
Verfahren von Diffie und Hellman, der so genannte {\it Diffie-Hellman-Key-Ex\-change} (nach \cite[S.~624f.]{tanenbaum}).
Das Verfahren ist in Abb.~\ref{diffie} graphisch veranschaulicht.

Angenommen, Alice m"ochte mit Bob\footnote{Alice und Bob sind die in der Kryptologie "ublichen Beispielnamen.} einen
gemeinsamen Schl"ussel vereinbaren.
Dazu w"ahlen Alice und Bob mithilfe eines Zufallszahlengenerators jeweils eine gro"se Zufallszahl: Alice w"ahlt $x$,
und Bob w"ahlt $y$.

\begin{floatingfigure}[r]{8cm}
\includegraphics{abbildungen/diffie.eps}
{\it \caption[Schl"usseltausch nach Diffie und Hellman]{\label{diffie}Ort-Zeit-Diagramm des Schl"usseltauschs nach der
Methode von Diffie und Hellman. Horizontal sind die Kommunikationspartner dargestellt, und die Zeitachse verl"auft
vertikal nach unten (nach \cite[S.~625]{tanenbaum}).\\~}}
\end{floatingfigure}

Dann w"ahlt Alice zwei gro"se Primzahlen $n$ und $g$, wobei $\frac{n-1}{2}$ auch eine Primzahl
sein muss.

Alice sendet dann $n$, $g$ und $g^{x} \bmod n$ an Bob. Das Senden kann "uber einen unsicheren, das hei"st abh"orbaren
Kommunikationskanal erfolgen. Als Antwort sendet Bob die Zahl $g^{y} \bmod n$ an Alice.

Sodann stehen Alice und Bob alle Informationen zur Verf"ugung, um den Schl"ussel zu berechnen: Alice berechnet
\begin{displaymath}
(g^{y} \bmod n)^x = g^{xy} \bmod n,
\end{displaymath}
und Bob berechnet
\begin {displaymath}
(g^{x} \bmod n)^{y} = g^{xy} \bmod n.
\end{displaymath}

Ein Angreifer, der die ausgetauschten Nachrichten mith"ort, verf"ugt zwar "uber alle Informationen, um den Schl"ussel
$g^{xy} \bmod n$ zu berechnen, jedoch ist die Berechnung in der Praxis wegen des sehr hohen Aufwandes nicht machbar.
Der Angreifer m"usste aus $g^{x} \bmod n$ und $g^{y} \bmod n$ die Werte $x$ bzw. $y$ (so genannte diskrete Logarithmen)
berechnen, aber f"ur die Berechnung diskreter Logarithmen ist kein Algorithmus bekannt, der deterministisch in
Polynomzeit arbeitet.



% ******************************** Stromchiffrierung mit Zufallszahlen *******************************

\subsection{Stromchiffrierung mit Zufallszahlen \hspace{3.3cm}} \label{stromchiffrierung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{7cm}(von Peter Hartmann)}}

Ein weiteres wichtiges Einsatzgebiet f"ur Sequenzen von Zufallszahlen ist der Einsatz in der Stromchiffrierung. Die 
Stromchiffrierung verschl"usselt im Gegensatz zur Blockchiffrierung den Klartext bitweise und nicht in Bitgruppen 
(siehe \cite[S.~4]{schneier}). Der Algorithmus wird als {\it One-Time-Pad} bezeichnet und wurde 1917 von Joseph Mauborgne und Gilbert 
Vernam bei AT\&T erfunden (siehe \cite[S.~403]{kahn}).

\begin{floatingfigure}[l]{15cm}
\includegraphics{abbildungen/stromchiffre.eps}
{\it \caption[Stromchiffrierung]{\label{stromchiffre}Prinzip der Stromchiffrierung. Dargestellt sind die Fl"usse
der Bitstr"ome. Die beiden Zufallszahlengeneratoren sind identisch, das hei"st sie generieren beide denselben Bitstrom.
Die eingezeichneten Nullen und Einsen sind willk"urlich gew"ahlt und dienen lediglich der Illustration.}}
\end{floatingfigure}
~\vspace{8cm}

Wurden vor Erfindung des Computers noch Lochstreifen benutzt und die 
Rechenoperationen auf Buchstaben angewandt, so wird heute f"ur die Verschl"usselung des Klartextes der Bitstrom, der 
den Klartext darstellt, mit dem Bitstrom der Zufallszahlensequenz addiert, also eine einfache Exklusiv-Oder-Verkn"upfung 
(XOR-Verkn"upfung) durchgef"uhrt. F"ur die Entschl"usselung wird der verschl"usselte Bitstrom nochmals mit dem Bitstrom
der Zufallszahlensequenz addiert, weil: $a \oplus b \oplus b = a$ gilt (siehe Abb.~\ref{stromchiffre}).

Der Stromchiffierurungs-Algorithmus hat zwei entscheidende Vorteile gegen"uber anderen Verschl"usselungsalgorithmen.
Er ist sehr schnell und ben"otigt kaum Hardware- oder Rechenaufwand, da f"ur das Ver- bzw. Entschl"usseln nur die
XOR-Verkn"upfung ausgef"uhrt werden muss. Der zweite entscheidende Vorteil ist die absolute Sicherheit. Ist die 
Zufallszahlensequenz wirklich zuf"allig, also nicht vorhersagbar, dann bleibt der verschl"usselte Klartext f"ur immer 
unbekannt. Da jeder Klartext gleich wahrscheinlich ist, gibt es f"ur einen unbefugten Dritten keine M"oglichkeit, zu 
ermitteln, welcher davon der richtige ist. Eine echte Zufallszahlensequenz, die zu einem nicht zuf"alligen Klartext 
addiert wird, erzeugt einen v"ollig willk"urlichen Chiffretext. Keine noch so "uberragende Verarbeitungsleistung kann 
daran irgendetwas "andern. Der Beweis f"ur die Sicherheit ist in \cite{shannon} zu finden.

Nachteilig ist das Problem der Synchronisation. Sender und Empf"anger m"ussen perfekt synchronisiert sein. Geht bei 
der "Ubertragung ein Bit verloren, dann wird beim Entschl"usseln nur noch Klartext ohne jeden Sinn erzeugt (\cite{rueppel}).
Die Sicherheit von diesem Algorithmus h"angt von der Qualit"at der Zufallszahlen ab, erforderlich sind hier 
Zufallszahlen, die nicht vorhersagbar sind. Besitzt die Zufallszahlensequenz beispielsweise eine Periode und wird der 
Klartext auch nur zweimal mit den sich wiederholenden Zufallszahlen verschl"usselt, dann ist das One-Time-Pad nicht 
mehr sicher (\cite[S.~149]{bauer}).



% *********************** Weitere Anwendungen von Zufallszahlen in der Informatik ********************

\subsection{Weitere Anwendungen von Zufallszahlen in der Informatik \hspace{3.3cm}} \label{simulation}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{10.5cm}(von Peter Hartmann)}}

Ein weiteres Einsatzgebiet von Zufallszahlen ist die Verwendung bei Problemstellungen, die mittels einer zuf"alligen 
Komponente gel"ost werden. Das sind beispielsweise die Simulation, das Testen von Programmen oder der Einsatz 
von randomisierten Algorithmen.


\paragraph{Simulation} \quad \newline

Die so genannte {\it Monte-Carlo-Methode}, auch als Simulationsmethode bezeichnet, dient der approximativen 
Berechnung von Wahrscheinlichkeiten. Diese Methode macht Gebrauch von dem schwachen Gesetz der gro"sen Zahlen, 
das besagt, dass das Stichprobenmittel $(X_{1} + ... + X_{n}) / n$ von $n$ Zufallsvariablen eine Approximation f"ur 
den Erwartungswert $EX_{1}$ ist. Benutzt man also f"ur die $X_{1}, ...,X_{n}$ die Zufallszahlen $x_{1}, ...,x_{n}$, 
dann kann man das arithmetische Mittel $(x_{1} + ... + x_{n}) / n$ als Approximation f"ur den Erwartungswert 
$EX_{1}$ w"ahlen. Genauere Erkl"arungen und Beispiele findet man in \cite[S.~294ff.]{neuhaus}.


\paragraph{Testen von Programmen} \quad \newline

F"ur die Qualit"atssicherung ist das Testen von Programmen (siehe \cite[S.~663]{informatikhandbuch}) und von integrierten 
Schaltungen (siehe \cite[S.~269ff.]{schiffmann}) ein wichtiger Punkt. Allerdings kann meist wegen der Komplexit"at kein 
vollst"andiger Test durchgef"uhrt werden. Eine Schaltwerk mit $n$ Eing"angen und $m$ Speichergliedern erfordert 
f"ur einen vollst"andigen Test $2^{m+n}$ Testmuster. Angenommen, der Test eines Testmusters w"urde eine 
Mikrosekunde ben"otigen, dann w"urde die Testzeit eines Schaltwerkes mit $m+n=45$ Eing"angen bereits "uber ein Jahr
betragen. Aus diesem Grund wird unter anderem mittels zuf"alliger Testmuster getestet. Diese lassen sich mit Zufallszahlen
realisieren.


\paragraph{Randomisierte Algorithmen} \quad \newline

\enlargethispage{1cm}

Bei vielen deterministischen Berechnungen ist der Zeitaufwand f"ur die L"osung des Problems zu hoch. Es gibt aber 
randomisierte Algorithmen, die einige dieser Probleme effizient l"osen. F"ur diese Algorithmen ben"otigt man 
Zufallszahlen. Als Beispiel sei hier der Algorithmus von Rabin (siehe \cite[S.~27ff.]{rabin76}) erw"ahnt. Dieser testet, ob eine 
gegebene Zahl eine Primzahl ist oder nicht. F"ur diesen sehr schnellen Algorithmus werden zuf"allige nat"urliche 
Zahlen ben"otigt. Wenn f"ur eine zuf"allige Zahl der Algorithmus die zu untersuchende Zahl als Primzahl ausweist, 
dann ist das mit Sicherheit wahr. Ist das Ergebnis negativ, so betr"agt die Irrtumswahrscheinlichkeit weniger als 
$0,5$. Testet man eine Zahl einhundert Mal mit Zufallszahlen und ist das Ergebnis immer positiv, dann sinkt die 
Irrtumswahrscheinlichkeit, dass doch eine zusammengesetzte Zahl vorliegt, auf unter $2^{-100}$.



% ************************************************************
% *****              Kapitel 3 (Grundlagen)              *****
% ************************************************************

\newpage
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Kapitel falsch im Inhaltsverzeichnis erscheint.
\section{Grundlagen} \label{grundlagen}

In diesem Kapitel werden die Grundlagen dargestellt, auf die die folgenden Kapitel aufbauen. Dazu z"ahlen
Zufallszahlen und deren Erzeugung, mathematische Gruppentheorie, elliptische Kurven, statistische Verfahren und
Chipkartentechnik.

% ******************************************* Zufallszahlen ******************************************

\subsection{Zufallszahlen \hspace{3,3cm}} \label{zufallszahlen}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{3.5cm}(von Peter Hartmann)}}

% ***** Was sind Zufallszahlen? *****

\subsubsection{Was sind Zufallszahlen?} \label{zufallszahlendefinition}

Es gibt je nach Standpunkt und Anwendungsbereich unterschiedliche Definitionen von Zufallszahlen. Vom 
philosophischen Standpunkt aus ist es beispielsweise eine offene Frage, ob Zufall "uberhaupt existiert. Da hier der 
praktische Einsatz von Zufallszahlengeneratoren auf Chipkarten im Vordergrund steht, soll diese Frage aber nicht 
weiter interessieren.

Bei einer gegebenen Zahl, beispielsweise der 42, ist es nicht nachvollziehbar, ob diese Zahl eine Zufallszahl ist oder 
nicht, da nicht gezeigt werden kann, ob diese Zahl zuf"allig ermittelt wurde oder das Ergebnis deterministischer 
Berechnungen ist.

In \cite[S.~1ff.]{knuth} wird stattdessen die Definition von Zufallszahlen "uber Sequenzen von Zufallszahlen 
angegeben. Diese Folgen von Zahlen werden als zuf"allig angesehen, wenn die einzelnen generierten Zahlen 
unabh"angig von den vorhergegangenen Zahlen zuf"allig erzeugt werden. Hier wird es dann problematisch,
"uberhaupt von Zufallszahlen zu sprechen, wenn diese von deterministischen Maschinen erzeugt werden. Diese Zahlen 
werden eindeutig vorhersagbar nach einem Algorithmus erzeugt. Eine einmal erzeugte Zufallszahlensequenz k"onnte 
immer wieder erzeugt werden und ist damit "uberhaupt nicht mehr zuf"allig. Abgesehen von theoretischen Modellen, 
welche in der Lage sind, nichtdeterministisch zu arbeiten, gibt es keine mit Maschinen erzeugten Zufallszahlen.
Eine Ausnahme ist die Benutzung des physikalischen Zufalls aus der Realit"at. Diese allerdings auf Chipkarten nicht 
praktikable Methode wird unter dem nachfolgenden Punkt besprochen.

Das Ziel ist es also, Sequenzen von 
Zufallszahlen zu erzeugen, die zuf"allig aussehen. In diesem Zusammenhang spricht man von {\it Pseudo-} oder 
{\it Quasizufallszahlen}. Die Erzeugung von Pseudozufallszahlen ist gegen"uber der Erzeugung von echten Zufallszahlen
nicht mit Nachteilen behaftet, im Gegenteil -- teilweise sind in den Anwendungen Pseudozufallszahlen erw"unscht,
siehe dazu Kapitel \ref{motivation}.
Der Einfachheit halber wird zuk"unftig von Zufallszahlen gesprochen, obwohl Pseudozufallszahlen 
gemeint sind.
In enger Anlehnung an \cite[S.~54f.]{schneier} wird hier eine weniger formale Definition von Zufallszahlen angegeben.

\paragraph{Definition:}

Ein Generator erzeugt {\it Pseudozufallszahlen}, wenn er die folgende Eigenschaft besitzt:

\begin{enumerate}
\item \label{zuf1} Der Generator scheint zuf"allig zu sein. Das bedeutet, dass die erzeugten Zahlen s"amtliche bekannten 
statistischen Zufallstests bestehen.
\end{enumerate}
Ist zus"atzlich die folgende Eigenschaft erf"ullt, dann spricht man von einem {\it kryptographisch sicheren}\\ 
{\it Pseudo\-zufalls\-zahlengenerator}:
\begin{enumerate}
\setcounter{enumi}{1} % Aufzählung mit Punkt 2 beginnen
\item \label{zuf2} Die erzeugten Zahlen sind nicht voraussagbar. Es ist unm"oglich, zu berechnen, welche Zufallszahl als
n"achstes kommt, selbst wenn der Algorithmus oder die Hardware, die die Zahlen erzeugen, sowie alle vorhergehenden 
Zahlen bekannt sind.
\end{enumerate}


Diese zwei Eigenschaften sind f"ur die Beurteilung der hier vorgestellten Zufallszahlengeneratoren ma"sgebend, wobei 
die Sicherheit bzw. die Qualit"at der erzeugten Zufallszahlen entweder von der Komplexit"at eines mathematischen 
Problems oder von der Geheimhaltung einer zur Erzeugung der Zufallszahlen erforderlichen Information abh"angt. 
Dabei ist auch abzuw"agen, mit welchem Aufwand welche Werte gesch"utzt werden sollen, so dass die Eigenschaft \ref{zuf2} 
nicht und Eigenschaft \ref{zuf1} nicht besonders gut erf"ullt werden m"ussen, wenn die gesch"utzten Werte gering und 
demzufolge der Aufwand zur Berechnung der Zufallszahlen in keinem vern"unftigen Verh"altnis mehr zum erreichten 
Vorteil steht, der mit der Kenntnis der Zufallszahlen erreichbar ist.

\paragraph{Definition:}

Von {\it echten Zufallszahlen} spricht man, wenn zus"atzlich zu den schon genannten Eigenschaften noch die folgende 
erf"ullt ist:

\begin{enumerate}
\setcounter{enumi}{2} % Aufzählung mit Punkt 3 beginnen
\item Der Generator ist nicht zuverl"assig reproduzierbar.
 Wenn man den Generator zweimal mit exakt derselben Eingabe, 
soweit dies m"oglich ist, laufen l"asst, erh"alt man zwei Zufallsfolgen, die keinerlei "Ahnlichkeiten aufweisen.
\end{enumerate}


% ***** Überblick über Zufallsgeneratoren *****

\subsubsection{"Uberblick "uber Zufallsgeneratoren} \label{zufallsgeneratoren}

In diesem Abschnitt soll ein kurzer "Uberblick "uber Zufallszahlengeneratoren gegeben werden, dabei ist das Ziel 
nicht der vollst"andige "Uberblick, da dies den Rahmen dieser Arbeit sprengen w"urde. Es gibt von den hier vorgestellten 
Generatoren jeweils modifizierte oder kombinierte Versionen, so dass ein umfassender "Uberblick auch gar nicht 
m"oglich ist. Umfangreiche und ausf"uhrliche "Ubersichten zu Zufallszahlengeneratoren findet man in
\cite[S.~425ff.]{schneier}, \cite[S.~1ff.]{knuth} und \cite[S.~39ff.]{dissertation}.

\paragraph{Gl"ucksspiele} \quad \newline

Eine der "altesten Methoden, um Zufallszahlen zu erzeugen, sind die Gl"ucksspiele (\cite[S.~250ff.]{hogben}).
Zumindest sollten die benutzten Ergebnisse unabh"angig davon, ob nun ein Gl"ucksrad, W"urfel, Karten oder anderes 
benutzt wird, zuf"allig sein. Die Methode, um heutzutage beispielsweise die Lottozahlen zu erzeugen, ist allgemein 
bekannt: Eine drehbare gro"se durchsichtige Kugel, in der sich weitere nummerierte Kugeln befinden, wird gedreht, so 
dass sich die Kugeln, die mit den Lottozahlen bezeichnet sind, vermischen. Bei Stillstand der gro"sen Kugel f"allt dann 
eine von den kleinen Kugeln heraus, und diese bestimmt eine Gewinnzahl. Im Interesse der Lottogesellschaften ist 
dies abgesehen von der Einschr"ankung, dass eine bereits gezogene Zahl nicht wieder gezogen werden kann, eine wirklich
zuf"allige Auswahl von Gewinnzahlen. Allerdings ist diese Methode zu langsam und schon gar 
nicht auf Chipkarten implementierbar. Dieser letztere Nachteil trifft auf alle Methoden zur Erzeugung von echten 
Zufallszahlen zu.

\paragraph{Echter Zufall} \quad \newline

F"ur die Erzeugung von Zufallszahlen l"asst sich selbstverst"andlich der Zufall aus dem realen Leben benutzen. Daf"ur 
existieren die unterschiedlichsten M"oglichkeiten.

Bereits 1955 wurde von der RAND Corporation ein Buch \cite{rand} mit einer Million Zufallsziffern herausgegeben. 
Die Zahlen f"ur das Buch wurden mit einer elektronischen Roulettescheibe erzeugt, welche von einer zuf"alligen 
Frequenzquelle angesteuert wurde. Auch die Benutzung des Buches sollte nach den Verfassern zuf"allig geschehen. Man 
sollte das Buch, welches im Hauptteil die Zufallsziffern in tabellarischer Form enth"alt, zuf"allig aufschlagen, eine 
Zahl blind w"ahlen. Von dieser Zahl soll dann die erste Stelle modulo 2 reduziert werden, damit man die Startzeile 
erh"alt, und die beiden letzten Stellen der Zahl sollen modulo 50 reduziert werden, um die Startspalte zu erhalten. 
Weiterhin sollen die bereits f"ur die Berechnung von Startspalte und -zeile benutzten Zahlen markiert werden, damit
sie nicht ein zweites Mal als solche verwendet werden.

Wenn man einen Computer benutzt, dann bieten sich auch hier zuf"allige Ereignisse an, die leicht zu ermitteln sind. 
Man kann beispielsweise die Tastaturverz"ogerung beim Bedienen der Tastatur messen, die Bewegung der Maus, die 
Zugriffszeiten der Festplatte oder die CPU-Auslastung. Diese Messdaten lassen sich dann mit einer Hashfunktion zu 
einer Zufallszahlensequenz verarbeiten. Weitere Einzelheiten zu dieser Methode sind in \cite[S.~485ff.]{schneier} zu 
finden.

Die beste M"oglichkeit, eine gro"se Anzahl von Zufallsbits zu erzeugen, bietet der nat"urliche Zufall der realen Welt. Hier
nutzt man Ereignisse, die regelm"a"sig, aber zuf"allig stattfinden, beispielsweise atmosph"arisches Rauschen, welches 
einen bestimmten Schwellenwert "uberschreitet. Mittels Geigerz"ahler l"asst sich auch der radioaktive Zerfall als 
Zufallsquelle nutzen. Die Zeit zwischen den Ereignissen dient dann der Erzeugung der Zufallsbits: Ist das nachfolgende 
Intervall gr"o"ser als das vorhergehende, dann schreibt man eine $1$ in die Zufallszahlensequenz, ansonsten eine $0$
(siehe \cite[S.~484ff.]{schneier}).

Von dieser Sorte Zufallszahlengeneratoren existiert eine breitere Auswahl. In \cite{richter} wird ein Generator 
beschrieben, welcher das thermische Rauschen einer Halbleiterdiode nutzt. Auch Spannungsdifferenzen zwischen 
elektronischen Bauteilen (siehe \cite[S.~77ff.]{agnew}) oder die Frequenzschwankungen eines frei schwingenden Oszillators 
(siehe \cite[S.~203ff.]{fairfield}) lassen sich nutzen. Es existieren auch frei k"aufliche hardwarebasierte 
Zufallszahlengeneratoren\footnote{\texttt{http://valley.interact.nl/av/com/orion/home.html},\\
\texttt{http://www.protego.se/sg100\_en.htm}}.

Allen diesen Methoden zur Erzeugung von Zufallszahlen ist gemein, dass sie sich gar nicht oder nur mit erheblichem
Aufwand auf Chipkarten implementieren lassen. Eine weitere Eigenschaft dieser Generatoren macht sie f"ur die in
Kapitel \ref{low-security} beschriebene Anwendung unbrauchbar. Diese Generatoren sind nicht reproduzierbar, das
hei"st es ist nicht m"oglich, gleiche Zufallszahlen an zwei verschiedenen Orten oder Zeiten zu erzeugen. Ein Abgleich
zwischen einer Geldkarte und der dazugeh"origen Bank ist damit nicht m"oglich. Sind diese Generatoren, die nach der
Definition in Kapitel \ref{zufallszahlendefinition} zwar echte Zufallszahlen erzeugen, f"ur kryptographische
Anwendungen erw"unscht, so sind sie f"ur die Sicherung von Chipkarten unbrauchbar.

\paragraph{Kongruenzen} \quad \newline

Die am h"aufigsten eingesetzte Methode zur Zufallszahlengenerierung bzw. die am h"aufigsten in 
Programmiersprachen eingesetzte Methode (siehe \cite[S.~39]{dissertation}) ist die lineare Kongruenz. Vorgestellt wurde diese 
Methode in \cite{lehmer} und ist aktuell ausf"uhrlich beschrieben in \cite[S.~10ff.]{knuth}.
F"ur einen Zufallszahlengenerator w"ahlt man daf"ur vier Zahlen:

\begin{tabbing}
\quad $x_{0}$ \quad \= den Inkrementen \quad \= \kill\\
\quad $x_{0},$ \> $\mathrm{den~Startwert},$\>$  x_{0} > 0.$ \\
\quad $a,$\>  $\mathrm{den~Multiplikator}$,\>  $a > 0.$ \\
\quad $c,$\>$  \mathrm{den~Inkrementen},$\>$  c \geq 0.$ \\
\quad $m,$\>$  \mathrm{den~Modulus},$\>$  m > x_{0}, m > a, m > c.$
\end{tabbing}

Die Folge der Zufallszahlen, die aus der Folge der $x_{n}$ besteht, erh"alt man dann mit der wiederholten L"osung 
der Rekurrenzgleichung:

\begin{displaymath}
\quad x_{n+1} = (ax_{n}+c) \bmod m.
\end{displaymath}

Die maximal erreichbare Periode ist offensichtlich m. Ein Generator, der lineare Kongruenzen zur Erzeugung der 
Zufallszahlen benutzt, ist vorhersagbar und damit nicht gut geeignet f"ur den sicheren Einsatz. Diese 
Aussage gilt auch f"ur abgeschnittene lineare Kongruenzgeneratoren, das hei"st lineare Kongruenzgeneratoren, bei denen
nur einige Ziffern von $x_{n+1}$ ausgegeben werden, und ebenso f"ur solche mit unbekannten Parametern (siehe \cite[S.~425]{schneier}).

Ein weiterer linearer Kongruenzgenerator ist der additive oder auch verz"ogerte Fibonacci-Generator (siehe
\cite[S.~449]{schneier}). Die Rekurrenzgleichung f"ur diesen Generator lautet:

\begin{displaymath}
\quad x_{i+1} = (x_{i-a} + x_{i-b} + ... + x_{i-m}) \bmod 2^{n}
\end{displaymath}

Der Vorteil, den man damit erreicht, dass man die $m$ Vorg"anger speichert, ist die maximal erreichbare Periode von 
$2^{n} - 1$.

Es ist nahe liegend, den linearen Ausdruck in der Rekurrenzgleichung durch einen nichtlinearen zu ersetzen. Damit 
kommt man dann zu den nichtlinearen Kongruenzgeneratoren. Ein Vertreter dieser Sorte ist der
{\it Blum-Blum-Shub-Generator}. Dieser wird in Kapitel \ref{bbsvorstellung} vorgestellt.

\paragraph{R"uckgekoppelte Schieberegister} \quad \newline

Die neben den Kongruenzgeneratoren am h"aufigsten eingesetzte Methode zur Erzeugung von Zufallszahlen ist das 
r"uckgekoppelte Schieberegister. Die ersten theoretischen Betrachtungen finden sich in \cite{selmer}. Man 
unterscheidet je nach der R"uckkopplungsfunktion zwischen linear r"uckgekoppelten und nicht linear 
r"uckgekoppelten Schieberegistern. Das linear r"uckgekoppelte Schieberegister (,,Linear Feedback Shift Register``),
hier als LFSR abgek"urzt, wird in Kapitel \ref{lfsrvorstellung} ausf"uhrlich vorgestellt.

\paragraph{Nutzung von Verschl"usselungsalgorithmen} \quad \newline

Generell lassen sich alle Algorithmen, die der Verschl"usselung dienen, zur Erzeugung von Zufallszahlen nutzen. 
Prim"ares Ziel eines Verschl"usselungsalgorithmus' ist es, die Redundanzen, die ein Text enth"alt, vollkommen 
zu beseitigen, so dass ein Text mit zuf"alligem Inhalt entsteht. Von diesem so erzeugten Chiffretext ist es dann nicht 
mehr m"oglich, auf den Klartext zu schlie"sen. Die Stromchiffren sind am einfachsten f"ur die Erzeugung von 
Zufallszahlen zu benutzen, da diese Algorithmen bereits eine Zufallszahlensequenz erzeugen (siehe Kapitel 
\ref{stromchiffrierung}). Diese Methode der Erzeugung von Zufallszahlen wird in den Kapiteln \ref{rc4vorstellung} 
und \ref{rc4} am Beispiel von RC4 untersucht. Andere Verschl"usselungsalgorithmen kann man ebenso 
benutzen, indem man einfach f"ur den Klartext einen beliebigen unbekannten Text benutzt. Die Auslagerungsdatei des 
Betriebssystems oder tempor"are Programmdateien bieten sich zum Verschl"usseln an. Der damit erzeugte Chiffretext 
l"asst sich dann als Quelle f"ur die Zufallszahlen benutzen. Es besteht auch die M"oglichkeit, ein Startwort zu 
verschl"usseln und das verschl"usselte Wort erneut zu verschl"usseln und dies immer wieder zu tun. Die damit 
rekursiv erzeugten verschl"usselten W"orter lassen sich als Zufallszahlensequenz benutzen.

\paragraph{Mathematische Probleme} \quad \newline

Es besteht eine allgemeine M"oglichkeit, aus mathematischen Problemen einen Zufallszahlengenerator zu erzeugen. 
Unter einem mathematischen Problem wird hier die Existenz einer Einwegfunktion (,,One-Way-Function``) verstanden,
das hei"st es existiert 
eine effizient berechenbare Funktion $f(x)$, f"ur die die Umkehrfunktion einen sehr hohen Rechenaufwand erfordert. 

Prominentestes Beispiel hierf"ur ist das Problem der Faktorisierung von ganzen Zahlen, welches in dem RSA-Algorithmus
(,,Rivest, Shamir, Adleman``, \cite[S.~120ff.]{rsa}) eingesetzt wird. Es ist einfach, zwei gro"se Primzahlen
zu multiplizieren, aber 
erheblich aufw"andiger, das Produkt der Primzahlen bei deren Unkenntnis zu faktorisieren. Solche Einwegfunktionen 
erm"oglichen es, Verschl"usselungsalgorithmen und damit auch Zufallszahlengeneratoren zu entwickeln, deren 
Sicherheit vom Berechnungsaufwand der Umkehrfunktion abh"angt. Weitere Beispiele sind die Berechnung des 
diskreten Logarithmus (\cite[S.~224ff.]{odlyzko}; siehe auch Kap.~\ref{authentifikation}) in der mutiplikativen
Gruppe der Primk"orper $\mathcal{GF}(p)$, 
in der multiplikativen Gruppe der Charakteristik $2$, also $\mathcal{GF}(2^{n})$ oder in der Gruppe der 
elliptischen Kurven "uber endlichen K"orpern $\mathcal{EC}(F)$. Der diskrete Logarithmus ist in allen F"allen die 
Berechnung der Umkehrung der modularen Potenzierung (siehe \ref{authentifikation}, Abschnitt Schl"usselaustausch).

\vspace{1cm}

% ************************************* Mathematische Grundlagen *************************************
\subsection{Mathematische Grundlagen \hspace{3.3cm}} \label{mathe}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{5.7cm}(von Peter Hartmann)}}

% ***** Gruppentheorie *****
\subsubsection{Gruppentheorie} \label{gruppentheorie}

Im nachfolgenden Abschnitt sollen die gruppentheoretischen Grundlagen kurz vorgestellt werden. Auf Beweise wird 
dabei verzichtet, diese finden sich in \cite[S. 271ff.]{biggs}.

Eine {\it Gruppe} ist eine algebraische Struktur, die "uber eine Menge $G$ definiert wird. Weiterhin wird eine 
bin"are Operation $\circ$ ben"otigt, die zwei Elemente aus $G$ verkn"upft.

\paragraph{Definition:}

Das Paar $(G, \circ)$ hei"st genau dann {\it Gruppe}, wenn folgende Axiome erf"ullt werden:
\vspace{-7mm}
\begin{tabbing}
\quad $G1$ \quad \= Abgeschlossenheit \quad \= $\forall x, y, z \in G$: \quad \= $\exists x' \in G$: \quad \= \kill\\
\quad $G1$ \> Abgeschlossenheit \> $ \forall x, y \in G$: \> \> $ x \circ y \in G$ \\
\quad $G2$ \> Assoziativit"at \> $\forall x, y, z \in G$: \> \> ($x \circ y$) $\circ z = x \circ$ ($y \circ z$) \\
\quad $G3$ \> Neutrales Element \> $\exists e \in G$: \> $\forall x \in G$: \> $e \circ x$ = $x \circ e$ = $x$ \\
\quad $G4$ \> Inverses Element \> $\forall x \in G$: \> $\exists x' \in G$: \> $x \circ x'$ = $x' \circ x$ = $e$
\end{tabbing}

F"ur die in dieser Arbeit vorgestellten Zufallszahlengeneratoren LFSR (siehe Kapitel~\ref{lfsrvorstellung}) und EC
(siehe Kapitel~\ref{eccvorstellung}) ist die Gruppe das zugrunde liegende mathematische 
Modell. F"ur die elliptischen Kurven $\mathcal{EC}(F)$ "uber $\mathcal{GF}(p)$ wird das im n"achsten Abschnitt 
erl"autert werden.

\paragraph{Definition:}

Die Anzahl der Elemente einer Gruppe $(G, \circ)$ wird als {\it Ordnung} der Gruppe $(G, \circ)$ bezeichnet und mit
$\mid G \mid$ notiert. Ist $\mid G \mid$ endlich, dann liegt eine {\it endliche} Gruppe vor.

\paragraph{Definition:}
Sei $x \in G$, dann ist die Potenz $x^{n}$ wie folgt rekursiv definiert:

\begin{displaymath}
\quad x^{0} = e, \qquad x^{1} = x, \qquad x^{n} = x \circ x^{n-1} \qquad \mathrm{(mit \hspace{3mm}} n \geq 2 \mathrm{)}
\end{displaymath}

F"ur negative Exponenten $n$ lautet die Definition analog, dabei wird f"ur das in Axiom $G4$ eingef"uhrte inverse 
Element $x'$ auch $x^{-1}$ geschrieben.

\paragraph{Definition:}

Sei $x \in G$ und $\mid G \mid$ endlich, dann ist die kleinste positive ganze Zahl $m$ mit $x^{m} = e$ die {\it 
Ordnung} von $x$ in $(G, \circ)$.

\paragraph{Definition:}

Eine Gruppe $(G, \circ)$ wird als {\it zyklische Gruppe} bezeichnet, wenn es ein $x \in G$ gibt, so dass jedes Element 
von $G$ eine Potenz von $x$ ist, also $G = \lbrace x^{n} \mid n \in \mathbb{Z} \rbrace$. Das Element $x$ wird als 
{\it erzeugendes Element} bezeichnet, und man schreibt $G = \langle x \rangle$.

\paragraph{Definition:}

Eine Teilmenge $H$ der Elemente der Gruppe $(G, \circ)$ bildet eine Untergruppe von $(G, \circ)$, wenn f"ur $H$ die 
Gruppenaxiome bez"uglich der in $G$ definierten Verkn"upfung $\circ$ gelten.

\paragraph{Theorem:}

Wenn $(G, \circ)$ eine endliche Gruppe der Ordnung $m$ ist und $(H, \circ)$ ist eine Untergruppe von $(G, \circ)$ mit der Ordnung $n$, 
dann ist $n$ ein Teiler von $m$.

Dieser Satz ist als Theorem von Lagrange bekannt, und er ist hier sehr wichtig f"ur die 
Beurteilung der Periode der von den Generatoren erzeugten Zufallszahlensequenzen. Weiterhin gilt, wenn $(G, \circ)$ eine 
zyklische Gruppe ist, dann gibt es f"ur jeden Teiler $d$ von $\mid G \mid$ genau eine Untergruppe.

\paragraph{Definition:}

Sei in einer Sequenz $x_{i}$ das $i$-te Zeichen, dann besitzt die Sequenz genau dann eine {\it Periode} der 
L"ange $m$, wenn ab einem Wert $x_{i}$ f"ur alle $x_{j}$, mit $j \geq i$, $x_{j} = x_{j+m-1}$ ist, 
dabei sind $m$ und $i$ die kleinsten positiven ganzen Zahlen, die diese Bedingung erf"ullen. 
Die Sequenz $x_{1}x_{2}$ \ldots $x_{i-1}$ wird dann als {\it Vorperiode} bezeichnet.

Da die hier vorgestellten Zufallszahlengeneratoren deterministisch arbeiten und nur endlich viele Werte verarbeiten, 
erzeugt jeder der Generatoren Sequenzen mit Perioden. Diese sollten am besten so gro"s wie m"oglich sein, um die 
Vorhersagbarkeit der nachfolgenden Bits zu erschweren. Wenn nun f"ur die Generierung der Zufallszahlen endliche 
Gruppen zugrunde liegen, dann muss man, um eine gro"se Periode zu erreichen, auf die Ordnung der Gruppe 
achten. Ist die Gruppe primer Ordnung, dann gelangt man erst dann in einen schon durchlaufenen Zustand und damit 
an die Stelle, ab der sich die Bits wiederholen, wenn so viele Verkn"upfungsschritte ausgef"uhrt worden sind, wie die 
Ordnung der Gruppe ist. Ist die Gruppe nicht primer Ordnung, so kann es passieren, dass man in einer Untergruppe 
rechnet und diese dann eine sehr kleine Ordnung, das hei"st eine kurze Periode, besitzt. Wegen der Abgeschlossenheit
bleibt man, einmal dorthin gelangt, bei den Verkn"upfungsschritten in der entsprechenden Untergruppe.



% ***** Elliptische Kurven *****
\subsubsection{Elliptische Kurven} \label{elliptischekurven}

In diesem Kapitel werden die wichtigsten Grundlagen f"ur elliptische Kurven $\mathcal{EC}$ "uber endlichen
K"orpern $F$, also $\mathcal{EC}(F)$, und hier in dem speziellen Fall des K"orpers $\mathcal{GF}(p)$ 
vorgestellt. Diese Einschr"ankungen beziehen sich auf den in Kapitel \ref{eccvorstellung} vorgestellten 
Zufallszahlengenerator. Ausf"uhrliche und weitergehende Darstellungen zu allen in diesem Kapitel 
angesprochenen Bereichen finden sich in \cite{ieee}.

Bevor die elliptischen Kurven definiert werden, sind noch einige Definitionen zum Verst"andnis notwendig.

\paragraph{K"orper} \quad \newline

\vspace{-0.5cm}

\paragraph{Definition:}

Eine Gruppe $(G, \circ)$ hei"st {\it abelsche} oder {\it kommutative} Gruppe, wenn zus"atzlich zu den vier 
Gruppenaxiomen Folgendes erf"ullt ist:

\begin{displaymath}
\quad G5 \quad \mathrm{Kommutativit"at} \quad \forall x, y \in G: \quad x \circ y = y \circ x
\end{displaymath}

\paragraph{Definition:}

Es seien zwei kommutative Gruppen $(G_{1}, \circ)$ und $( G_{2}, \oplus)$ gegeben und die neutralen Elemente
dieser Gruppen mit $e_{1}$ bzw. $e_{2}$ bezeichnet. Wenn $ G_{1} = G_{2}$ ist, 
die Verkn"upfungen $\circ$ und $\oplus$ sich unterscheiden und f"ur die Gruppe $(G_{1}, \circ)$
bei Axiom $G4$ f"ur $x \circ x' = e_{1}$ einschr"ankend $x \not= e_{2}$ vorausgesetzt wird,
dann ist das Tripel $(K, \circ, \oplus)$ ein {\it K"orper}, wenn $G_{1} = K$ ist
und zus"atzlich folgendes Axiom erf"ullt ist:

\begin{displaymath}
\quad K1 \quad \mathrm{Distributivit"at} \quad \forall x, y, z \in K: \quad (x \oplus y) \circ z = (x \circ z) 
\oplus (y \circ z)
\end{displaymath}

Ist $\mid K \mid$ ein endlicher Wert, dann bezeichnet man $(K, \circ, \oplus)$ als {\it endlichen} K"orper.

\paragraph{Der K"orper $\mathcal{GF}(p)$} \quad \newline

Die elliptischen Kurven, die f"ur den vorgestellten Zufallszahlengenerator benutzt werden, sind "uber dem
endlichen K"orper $\mathcal{GF}(p)$ definiert. Das $\mathcal{GF}$ steht f"ur Galois-Feld und das $p$ f"ur 
eine Primzahl $p > 2$. Die Elemente des K"orpers sind dann die Menge $\mathbb{Z}_{p} = \lbrace 0, 1, 2,
\ldots, p-1 \rbrace$. Die Verkn"upfungen $\circ$ und $\oplus$ entsprechen dann der Multiplikation
$\cdot$ bzw. der Addition $+$ modulo $p$. Das bedeutet, dass jedes Ergebnis aus $x \cdot y = z$ bzw.
$x + y = z$ mit $z > p-1$ wegen des Abgeschlossenheitsaxioms $G1$ durch Reduktion mit dem Modulus $p$ in ein Element aus 
$\mathbb{Z}_{p}$ umgewandelt werden muss.

\paragraph{Definition:}

Zwei Zahlen $x$ und $y$ sind kongruent modulo $p$, geschrieben $x \equiv y \bmod p$, wenn $p$ die Differenz 
$x - y$ teilt. \quad \newline

Addiert man beispielsweise im K"orper $\mathcal{GF}(5)$ die Zahlen $3$ und $4$, dann liegt bei der 
gew"ohnlichen Addition das Ergebnis $7$ nicht in der Menge $\mathbb{Z}_{5} = \lbrace 0, 1, 2, 3, 4 \rbrace$, 
also wird das Ergebnis $7$ mit dem Modulus $5$ zu $2$ reduziert, da $7 \equiv 2 \bmod 5$ ist. \quad 
\newline

Die Division im K"orper $\mathcal{GF}(p)$ l"asst sich auf die Multiplikation mit dem Inversen des Divisors 
zur"uckf"uhren, da der Quotient $\frac{x}{y}$ sich als $x \cdot y'$ schreiben und dann als Produkt ausrechnen l"asst.
Das hei"st die Division l"asst sich auf die Multiplikation zur"uckf"uhren, wenn das Inverse des Divisors 
bekannt ist.

Ist beispielsweise der Quotient $\frac{4}{3}$ in $\mathcal{GF}(5)$ gesucht, so muss die $4$ mit dem inversen Element
multipliziert werden, das hei"st $\frac{4}{3}=4 \cdot 3^{-1}$. Das inverse Element der $3$ ist $2$, da
$3 \cdot 2 \equiv 1 \bmod 5$ ist. F"ur den Quotienten ergibt sich also $\frac{4}{3}=4 \cdot 3^{-1}=4 \cdot 2 = 3$,
denn $4 \cdot 2 \equiv 3 \bmod 5$. Das Finden des inversen Elementes in einem endlichen 
K"orper ist im Allgemeinen keine einfache Aufgabe und sollte nach M"oglichkeit vermieden werden.

\paragraph{Elliptische Kurven "uber $\mathcal{GF}(p)$} \quad \newline


Elliptische Kurven sind keine, wie der Name vermuten l"asst, Kurven, die Ellipsen beschreiben, sondern 
Gleichungen, die bei der Berechnung von Ellipsenumf"angen im Integranden auftreten.

\paragraph{Definition:}

~

\begin{floatingfigure}[r]{9cm}
\includegraphics{abbildungen/elliptischekurve.eps}
{\it \caption[Beispiel einer elliptischen Kurve]{\label{elliptischekurve} Die elliptische Kurve
$y^2 = x^3 + 2x + 4$. Der Punkt $\mathcal{O}$ rechts oben ist die Darstellung des Unendlichkeitspunktes.}}
\end{floatingfigure}


\vspace{-5mm} \hspace{2cm}
Eine elliptische Kurve $\mathcal{EC}$ "uber $\mathcal{GF}(p)$ ist eine Menge von Punkten $(x, y)$, die die 
Gleichung $y^2 = x^3 + ax + b$ erf"ullen. Weiterhin gilt $4a^3 + 27b^2 \not= 0$ und $a, b, x, y, \in 
\mathbb{Z}_{p}$. Zus"atzlich wird noch der so genannte Unendlichkeitspunkt $\mathcal{O}$ hinzugenommen. 
\quad \newline

Als Beispiel f"ur eine elliptische Kurve (siehe Abb.~\ref{elliptischekurve}) hat $y^2 = x^3 + 2x + 4$ "uber 
$\mathcal{GF}(5)$ die folgenden Punkte $\lbrace (0, 2),$ $(0, 3),$ $(2, 1),$ $(2, 4),$ $(4, 1),$ $(4, 4), \mathcal{O}
\rbrace$.
\vspace{4cm}

\paragraph{Elliptische Kurven als Gruppe} \quad \newline

Das Besondere an den elliptischen Kurven ist, dass sie bez"uglich der Addition von Punkten eine Gruppe bilden. Die 
Addition zweier Punkte $P_{1}(x_{1}, y_{1})$ und $P_{2}(x_{2}, y_{2})$ einer elliptischen Kurve ergibt einen
dritten Punkt $P_{3}(x_{3}, y_{3})$ und ist wie folgt definiert:


\begin{eqnarray*}
-P_{1}            & = & (x_{1}, -y_{1}) \\
P_{3}=P_{1}+P_{2} & = & \left\{
                        \begin{tabular}{ccl}
                        $\mathcal{O},$  & $\mathrm{falls}$ & $P_{1} =-P_{2}$       \\
                        $P_{2},$        & $\mathrm{falls}$ & $P_{1} = \mathcal{O}$ \\
                        $P_{1},$        & $\mathrm{falls}$ & $P_{2} = \mathcal{O}$.
                        \end{tabular}
                        \right.
\end{eqnarray*}

Ansonsten ist $P_{3}(x_{3}, y_{3}) = P_{1} + P_{2}$ mit

\begin{eqnarray*}
\lambda & = & \left\{
              \begin{tabular}{ccl}
              $\frac{y_{1}-y_{2}}{x_{1}-x_{2}},$ & $\mathrm{falls}$ & $P_{1} \not= P_{2}$ \\
              ~ \\
              $\frac{3x_{1}^2+a}{2y_{1}},$       & $\mathrm{falls}$ & $P_{1} = P_{2}$
              \end{tabular}
              \right. \\
x_{3}   & = & -x_{1} - x_{2} + \lambda^2 \\
y_{3}   & = & -y_{1} + \lambda(x_{1} - x_{3}).
\end{eqnarray*}

Wenn zwei Punkte $P_{1}$ und $P_{2}$ auf der Kurve liegen, dann liegt nach dem Abgeschlossenheitsaxiom 
$G1$ auch die Summe der Punkte, also der Punkt $P_{3}$, auf der Kurve.

F"ur die F"alle $P_{1} = -P_{2},$ $P_{1} = \mathcal{O}$ und $P_{2} = \mathcal{O}$ ist das 
offensichtlich. Die weiteren F"alle mit $P_{1} \not= P_{2}$ und $P_{1} = P_{2}$ erfordern etwas l"angere 
Rechnungen, auf die hier verzichtet wird.

Als Beispiel wird hier der Punkt $P_{1}(2, 1)$ aus unserer Beispielkurve $y^2 = x^3 + 2x + 4$ verdoppelt, das hei"st
der Punkt wird zu sich selbst addiert, also der Fall $P_{1} = P_{2}$. Nach der Additionsdefinition ergeben sich 
f"ur $P_{1} + P_{1} = P_{2}$ folgende Werte \footnote{Beachte, dass in $\mathcal{GF}(5)$ gerechnet wird.}:

\begin{displaymath}
\quad x_{2} = -2 - 2 + \left(\frac{3 \cdot 2^2 + 2}{2 \cdot 1}\right)^2 = -4 + \left(\frac{14}{2}\right)^2
= -4 + (14 \cdot 3)^2 
= 1760 = 0
\end{displaymath}
\begin{displaymath}
\quad y_{2} = -1 + \left(\frac{3 \cdot 2^2 + 2}{2 \cdot 1}\right)(2 - x_{2}) = -1 + (14 \cdot 3) \cdot 2 = 43 = 3
\end{displaymath}

\begin{floatingfigure}[r]{9cm}
\includegraphics{abbildungen/elliptischekurveaddition.eps}
{\it \caption[Beispiel einer elliptischen Kurve]{\label{elliptischekurveaddition} Die elliptische Kurve
$y^2 = x^3 + 2x + 4$ wie in Abb.~\ref{elliptischekurve}. 
Die Pfeile zeigen den Zyklus des Punktes (0,~3), das hei"st wenn der Punkt vervielfacht wird,
ergeben sich die Punkte in der Reihenfolge, wie sie mit den Pfeilen verbunden sind.}}
\end{floatingfigure}

Die fortlaufende Addition, also die Vervielfachung, ist in Abb.~\ref{elliptischekurveaddition} dargestellt.

Der Punkt $P_{2}(0, 3)$ liegt auch auf unserer Beispielkurve (siehe Abb.~\ref{elliptischekurve} und
Abb~\ref{elliptischekurveaddition}).

Die Addition von Kurvenpunkten folgt auch dem 
Assoziativit"atsaxiom $G2$. Das neutrale Element nach Axiom $G3$ ist der Unendlichkeitspunkt $\mathcal{O}$, da 
die Addition von einem Punkt $P_{1}$ mit $\mathcal{O}$ per Definition wieder den Punkt $P_{1}$ ergibt. \\ Das 
inverse Element zu einem Punkt $P_{1}( x_{1}, y_{1})$ ist $P_{2}( x_{1}, -y_{1})$, da die Addition von den 
Punkten $P_{1}$ und $-P_{1}$ den Unendlichkeitspunkt $\mathcal{O}$ ergibt. Zu zeigen, dass die Gruppe kommutativ ist,
erfordert l"angere Rechnungen, auf die hier verzichtet wird.

\vspace{2cm}

\paragraph{Projektive Koordinatendarstellung} \quad \newline

Bisher wurden die Punkte der elliptischen Kurven mit 2 Koordinaten in der so 
genannten affinen Form angegeben, ein Punkt hatte also die Form $(x, y)$ und 
konnte grafisch in einem zweidimensionalen Koordinatensystem veranschaulicht 
werden. Bei der Addition von Punkten einer elliptischen Kurve ist es in dieser 
Darstellung notwendig, im zugrunde liegenden K"orper, hier $\mathcal{GF}(p)$, zu 
dividieren, und damit ist es erforderlich, das Inverse eines Elementes aus 
$\mathcal{GF}(p)$ zu berechnen. Dies l"asst sich vermeiden, wenn man zur 
projektiven Koordinatendarstellung "ubergeht.

Im Folgenden werden zur Unterscheidung der Darstellungen f"ur die affine kleine 
und f"ur die projektive Koordinatendarstellung gro"se Buchstaben benutzt. Bei 
der projektiven Koordinatendarstellung ist eine dritte Variable $Z$ notwendig. 
Der Punkt $(x, y)$ bezeichnet einen Punkt in der affinen und der Punkt $(X, Y, 
Z)$ einen in der projektiven Darstellung. Die projektive Darstellung ist nicht 
eindeutig, so bezeichnet jeder Punkt der Form $(\lambda^{2}X,~\lambda^{3}Y,~\lambda Z)$
mit $\lambda \not= 0,~\lambda \in \mathcal{GF}(p)$ ein und denselben 
Punkt. Damit l"asst sich in der projektiven Darstellung nichts mehr einfach 
grafisch veranschaulichen.

Die Umrechnung von der affinen zur projektiven Darstellung erfolgt mit:

\begin{displaymath}
\quad X = x, \qquad Y = y, \qquad Z = 1.
\end{displaymath}

Die Umrechnung von der projektiven zur affinen Darstellung ist schwieriger und 
erfolgt mit:

\begin{displaymath}
\quad x = \frac{X}{Z^{2}}, \qquad y = \frac{Y}{Z^{3}}.
\end{displaymath}

Der Unendlichkeitspunkt $\mathcal{O}$ hat die Form $(\lambda^{2}, \lambda^{3}, 
0)$ mit $\lambda \not= 0, \lambda \in \mathcal{GF}(p)$. Es existieren weitere 
projektive Koordinatendarstellungen, die allerdings mit einem h"oheren 
Rechenaufwand verbunden sind. Der entscheidende Vorteil der projektiven 
Darstellung ist das Vermeiden der Division in $\mathcal{GF}(p)$.

Im Folgenden wird die Punktaddition von einem Punkt mit sich selbst dargestellt, 
da diese Operation bei dem in dieser Arbeit vorgestellten EC-Zufallszahlengenerator
(siehe Kapitel~\ref{eccvorstellung}) benutzt wird. Die anderen F"alle finden sich
in \cite[S. 126ff.]{ieee}.

Gegeben ist ein Punkt $P (X_{1}, Y_{1}, Z_{1})$, und gesucht ist der Punkt $Q 
(X_{2}, Y_{2}, Z_{2})$ mit $Q = 2P$. Zu berechnen ist in diesem Fall:

\begin{eqnarray*}
X_{2} & = & M^{2} - 2S, \\
Y_{2} & = & M(S - X_{2}) - T, \\
Z_{2} & = & 2Y_{1}Z_{1}.
\end{eqnarray*}

Die drei Hilfsvariablen $M, S$ und $T$ erh"alt man wie folgt:

\begin{eqnarray*}
M & = & 3X_{1}^{2 } + aZ_{1}^{4},\\
S & = & 4X_{1}Y_{1}^{2}, \\
T & = & 8Y_{1}^{4}.
\end{eqnarray*}

Das $a$ wird der gegebenen elliptischen Kurve der Form $y^{2} = x^{3} + ax + b$ 
entnommen, und alle Berechnungen werden im K"orper $\mathcal{GF}(p)$ durchgef"uhrt, "uber 
dem die Kurve definiert ist.

\vspace{1cm}

% ********************************************** Statistik *******************************************
\subsection{Statistik \hspace{2.7cm}} \label{statistikgrundlagen}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.7cm}(von Stefan Witt)}}

F"ur die Bewertung der Qualit"at von Zufallszahlen (siehe Kapitel \ref{analyseverfahren}) werden Verfahren aus der
Statistik verwendet. Das sind zum einen der Chi-Quadrat-Anpassungstest und zum anderen die Intervallsch"atzung einer
Normalverteilung. Beide Verfahren werden in diesem Abschnitt kurz vorgestellt, allerdings ohne auf die
statistischen Herleitungen n"aher einzugehen. F"ur detaillierte Darstellungen muss auf \cite[S.~175ff.]{huebner}
und \cite[S.~12ff.]{dissertation} verwiesen werden.

\paragraph{Chi-Quadrat-Anpassungstest} \quad \newline

Mit einem Anpassungstest wird eine unbekannte Wahrscheinlichkeitsverteilung dahingehend "uberpr"uft, ob sie gleich
einer vermuteten, also hypothetischen Verteilung ist. Ein solcher Anpassungstest ist der {\it Chi-Quadrat-Anpassungstest}
($\chi^{2}$-Anpassungstest), der nun in einer vereinfachten Weise vorgestellt werden soll (angelehnt an
\cite[S.16.]{dissertation}).

Aus der Grundgesamtheit der Gr"o"se $N$ werde eine Stichprobe $x_{1}, x_{2},\dots, x_{n}$ vom Umfang $n$ gezogen. Die
unbekannte Wahrscheinlichkeitsverteilung der Stichprobe sei $F$, und die hypothetische Verteilung sei $F_{0}$.
Die zu pr"ufende Hypothese lautet dann $\mathcal{H}_{0}:\hspace{2mm}F=F_{0}$.

Der Test wird in folgenden Schritten durchgef"uhrt:
\begin{enumerate}
\item Zun"achst wird das Signifikanzniveau $\alpha$ festgelegt\footnote{In der Literatur ist die Bezeichnung des
Signifikanzniveaus unterschiedlich; so bezeichnet es beispielsweise \cite{huebner} mit $\alpha$, aber
\cite{dissertation} bezeichnet es mit $1-\alpha$. Hier wird also die Benennung nach \cite{huebner} verwendet.},
also die Wahrscheinlichkeit, mit der die Hypothese $\mathcal{H}_{0}$ gelten soll, beispielsweise $\alpha=0,95=95\%$. 
Weiterhin muss die Anzahl $k$ der Werte festgelegt
sein, die die Werte der Stichprobe annehmen kann. $k$ hei"st auch {\it Anzahl der Freiheitsgrade}.
Es muss gelten: $k \geq 1$ und $k$ ist endlich, denn der Chi-Quadrat-Test ist nur zum Testen diskreter Verteilungen
geeignet. Mit $z_{1}, z_{2}, \dots, z_{k}$ seien die $k$ Werte bezeichnet, die die Stichprobe annehmen kann.\\
Falls die Stichprobe $x_{1}, x_{2}, \dots, x_{n}$ beispielsweise nur die Werte $0$ und $1$ annehmen kann, so folgen
$k=2$, weil nur 2 Werte m"oglich sind, $z_{1}=0$ und $z_{2}=1$.
\item F"ur jeden Wert $z_{i}$, $1 \leq i \leq k$, wird gez"ahlt, wie oft ein Stichprobenwert
$x_{1}, x_{2},\dots, x_{n}$ den Wert $z_{i}$ annimmt. Die Anzahl wird als H"aufigkeit $H_{i}$ bezeichnet.
\item F"ur jeden Wert $z_{i}$ ($1 \leq i \leq k$) wird die Wahrscheinlichkeit $p_{i}=P(X = z_{i}|F_{0})$ berechnet,
also die Wahrscheinlichkeit, mit der ein Stichprobenwert nach der hypothetischen Verteilung $F_{0}$ den Wert $z_{i}$
annimmt.
\item Es muss die Testgr"o"se $\chi^{2}$ berechnet werden mit der Formel
\begin{equation}
\chi^{2} = \sum _{i=1}^{k}{\frac{1}{n \cdot p_{i}}(H_{i} - n \cdot p_{i})^{2}}.
\label{formelchiquadrat}
\end{equation}
Dabei ist $(H_{i} - n \cdot p_{i})^{2}$ die quadratische Abweichung der Anzahl an Stichprobenwerten, die $z_{i}$ annehmen,
von der mit der hypothetischen Verteilung $F_{0}$ berechneten Anzahl $n \cdot p_{i}$. Die Division durch $n \cdot p_{i}$
bewirkt, dass die quadratische Abweichung normiert wird, also unabh"angig von der hypothetischen Verteilung wird.
F"ur die Begr"undung der Wahl der Testgr"o"se siehe \cite[S.~188]{huebner}.
\item Aus einer Tabelle f"ur die $\chi^{2}$-Verteilung muss das $\alpha$-Quantil $c_{\alpha}$ der
$\chi^{2}$-Verteilung abgelesen werden. Solch eine Tabelle ist beispielsweise in \cite[S.~197]{huebner} zu finden.
Die Tabellenspalten geben die $\alpha$-Quantile an, also das Signifikanzniveau, und in den Zeilen steht der Freiheitsgrad.

Der Ablehnungsbereich der Hypothese $\mathcal{H}_{0}$ ist das Intervall $K_{\alpha}=(c_{\alpha},\infty)$,
denn es gilt folgender
Satz:
\begin{displaymath}
\mathrm{Die~Hypothese~} \mathcal{H}_{0} \mathrm{~wird~genau~dann~abgelehnt,~wenn~} \chi^{2} \in K_{\alpha} \mathrm{.}
\end{displaymath}

Das $\alpha$-Quantil muss also mit dem oben berechneten $\chi^{2}$ verglichen werden, und wenn es gr"o"ser
als $\chi^{2}$ ist, weicht die Stichprobe von der vermuteten Verteilung $F_{0}$ ab.
\end{enumerate}

\begin{floatingtable}[r]{
{\centering
\begin{tabular}[b]{|c|c|c|c|}
\hline
\hspace{3mm} $i$ \hspace{3mm} & \hspace{3mm} $z_{i}$ \hspace{3mm} & \hspace{3mm} $H_{i}$ \hspace{3mm} & \hspace{3mm} $p_{i}$ \\
\hline
$1$ & $1$     & $7$     & $\frac{1}{6}$ \\
$2$ & $2$     & $7$     & $\frac{1}{6}$ \\
$3$ & $3$     & $7$     & $\frac{1}{6}$ \\
$4$ & $4$     & $7$     & $\frac{1}{6}$ \\
$5$ & $5$     & $6$     & $\frac{1}{6}$ \\
$6$ & $6$     & $6$     & $\frac{1}{6}$ \\
\hline
\end{tabular}
}}
{\it \caption{\label{chiquadratbeispiel} Beispiel eines Zufallsexperiments: H"aufigkeiten der aufgetretenen Augenzahlen
bei $40$ W"urfen mit einem W"urfel.\vspace{10mm}}}
\end{floatingtable}

Zur Verdeutlichung des Verfahrens folgt ein Beispiel: Ein W"urfel soll dahin gehend gepr"uft werden, ob alle
Augenzahlen mit gleicher Wahrscheinlichkeit auftreten. Der W"urfel wird $n=40$ Mal geworfen (das ist vielleicht nicht
sinnvoll, aber die auftretenden Zahlen sollen "uberschaubar klein bleiben), und die H"aufigkeiten $H_{i}$
der erzielten Augenzahlen werden gez"ahlt. Dabei soll das Ergebnis wie in Tabelle~\ref{chiquadratbeispiel} aufgetreten
sein.

Die zu pr"ufende Hypothese ist
\begin{displaymath}
\mathcal{H}_{0}: \hspace{2mm} P(X = k) = \frac{1}{6},
\end{displaymath}
also die Hypothese der Gleichverteilung. Die Wahrscheinlichkeiten, dass die gew"urfelte Augenzahl $X$ gleich $k$ wird,
sind ebenfalls in Tabelle~\ref{chiquadratbeispiel} eingetragen. Das Signifikanzniveau sei $\alpha=0,95$, das hei"st das Ergebnis
des Tests soll mit einer Wahrscheinlichkeit von $95\%$ zutreffen.

Es ist $k=6$, weil es 6 verschiedene Versuchsausg"ange gibt, und die Werte, die gew"urfelt werden k"onnen, sind
$z_{1}=1$, $z_{2}=2$, $z_{3}=3$, $z_{4}=4$, $z_{5}=5$ und $z_{6}=6$.

Nun kann $\chi^{2}$ nach Formel~\ref{formelchiquadrat} berechnet werden:
\begin{displaymath}
\chi^{2}=\sum _{i=1}^{6}{\frac{1}{40 \cdot \frac{1}{6}} \left(H_{i}-40 \cdot \frac{1}{6}\right)^{2}}
= \frac{6}{40} \cdot \left(4 \cdot \left(7-\frac{40}{6}\right)^{2} + 2 \cdot \left(6-\frac{40}{6}\right)^{2}\right)
= \frac{6}{40} \cdot \left(\frac{4}{9} + \frac{8}{9}\right)
= \frac{1}{5}.
\end{displaymath}
Aus einer Tabelle f"ur die Quantile der $\chi^{2}$-Verteilung, beispielsweise aus \cite[S.~188]{huebner}, entnimmt
man f"ur $k=6$ Freiheitsgrade das Quantil $c_{\alpha}=c_{0,95}=12,60$. Da $\frac{1}{5} < 12,60$, wird die
Hypothese $\mathcal{H}_{0}$ angenommen, das hei"st die Verteilung ist ann"ahernd eine Gleichverteilung.


\paragraph{Intervallsch"atzung f"ur die Normalverteilung} \quad \newline

In diesem Abschnitt wird eine Stichprobe $x_{1}, x_{2}, \dots, x_{n}$, die in der Theorie normalverteilt sein m"usste,
durch eine Normalverteilung angen"ahert. Dazu werden der Erwartungswert $\mu$ und die Streuung $\sigma$ der
zu bestimmenden Normalverteilung durch das Stichprobenmittel bzw. die empirische Stichprobenstandardabweichung
der Stichprobe approximiert. F"ur den Erwartungswert $\mu$ wird ein Vertrauensintervall, auch
Kon\-fi\-denz\-in\-ter\-vall genannt, gesch"atzt, in dem der Wert mit einer vorgegebenen Wahrscheinlichkeit liegen soll.
Die Sch"atzung wird in folgenden Schritten durchgef"uhrt (angelehnt an \cite[S.~182]{huebner}):
\begin{enumerate}
\item Festlegen der Signifikanzniveaus $\alpha$, also der Wahrscheinlichkeit, mit der der Erwartungswert $\mu$ im
Vertrauensintervall liegen soll.
\item Berechnen des Stichprobenmittels $\overline{X}$ der Stichprobe $x_{1}, x_{2}, \dots, x_{n}$ mit der Formel
\begin{equation}
\overline{X} = \frac{1}{n} \cdot \sum _{i=1}^{n}{X_{i}}.
\label{formelstichprobenmittel}
\end{equation}
Das Stichprobenmittel $\overline{X}$ ist eine Sch"atzung f"ur den unbekannten Erwartungswert $\mu$ der Grundgesamtheit,
und es ist zudem sogar die beste aller m"oglichen Sch"atzungen.
\item Berechnen der empirischen Stichprobenstandardabweichung $\sigma$ mit der Formel
\begin{equation}
\sigma_{S} = \sqrt{\frac{1}{n-1} \cdot \sum_{i=1}^{n}{(x_{i}-\overline{X})^{2}}}.
\label{formelstichprobenstandardabweichung}
\end{equation}
Die empirische Stichprobenstandardabweichung $\sigma_{S}$ ist die beste Sch"atzung f"ur die Standardabweichung
$\sigma$ der Grundgesamtheit. Sie gibt an, um welchen Betrag die Werte der Grundgesamtheit durchschnittlich vom
Stichprobenmittel abweichen.
\item Nun kann das reellwertige, geschlossene Konfidenzintervall $K$ des Stichprobenmittels $\overline{X}$ berechnet
werden. Es ergibt sich zu
\begin{displaymath}
K=\left[
\overline{X}-t_{n-1,~1+\frac{\alpha}{2}} \cdot \frac{\sigma}{\sqrt{n}} \hspace{3mm} ; \hspace{3mm}
\overline{X}+t_{n-1,~1+\frac{\alpha}{2}} \cdot \frac{\sigma}{\sqrt{n}}
\right] .
\end{displaymath}
Dabei bedeutet $n$ wiederum der Umfang der Stichprobe, und $t_{n-1,~1+\frac{\alpha}{2}}$ ist das
$1+\frac{\alpha}{2}$-Quantil der Student-Verteilung mit $n-1$ Freiheitsgraden. F"ur die Definition der Student-Verteilung
wird auf \cite[S.~181f.]{huebner} verwiesen. Da bei der Auswertung von
Zufallszahlen umfangreiche Stichproben auftreten, kann n"aherungsweise $n-1 \rightarrow \infty$ angenommen
und mit $t_{\infty,~1+\frac{\alpha}{2}}$ gerechnet werden. Die Quantile der Student-Verteilung sind tabelliert und
beispielsweise in \cite[S.~196]{huebner} zu finden.
\end{enumerate}
Die Dichtefunktion der resultierenden Normalverteilung mit den eben berechneten Parametern $\mu = \overline{X}$
und $\sigma = \sigma_{S}$ ist
\begin{displaymath}
P(X=x_{i}) = \frac{1}{\sqrt{2 \pi} \cdot \sigma} \cdot e^{-\frac{1}{2} \cdot (\frac{x_{i}-\mu}{\sigma})^{2}},
\end{displaymath}
wobei $\overline{X}$ mit der Wahrscheinlichkeit $\alpha$ im oben berechneten Vertrauensintervall liegt.


% ********************************************* Chipkarten *******************************************
\newpage
\subsection{Chipkarten \hspace{2.7cm}} \label{chipkarten}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{3.2cm}(von Stefan Witt)}}

Da in den sp"ateren Kapiteln Zufallszahlengeneratoren f"ur Chipkarten vorgestellt und implementiert werden, soll
im Folgenden auf die Technik von Chipkarten eingegangen werden.

Im allt"aglichen Gebrauch werden verschiedene Arten von Identifikationskarten benutzt, die sich im Aussehen, im Aufbau
und im Verwendungszweck unterscheiden. Allen gemeinsam ist jedoch, dass sie der ISO-Norm 7810 (,,Identification Cards --
Physical Characteristics``) entsprechen, die die physikalischen Eigenschaften wie Abmessungen oder Werkstoffe festlegt.

Eine Art der Identifikationskarten ist die {\it hochgepr"agte Karte}, die sich dadurch auszeichnet, dass die Informationen,
die sie bereitstellt, als in Plastik gegossene Zeichen auf der Kartenoberfl"ache fest angebracht sind. Mit einem
Leseger"at k"onnen ein Abdruck dieser Zeichen erstellt und die Informationen der Karte kopiert werden. Ein Beispiel f"ur
eine hochgepr"agte Karte ist die verbreitete EuroCard, auf der die Kartennummer aufgepr"agt ist.

Neben den hochgepr"agten Karten gibt es auch {\it Magnetstreifenkarten}, auf denen die Information in digitaler Form
auf einem Magnetstreifen, der sich auf der Kartenr"uckseite befindet, gespeichert sind (Details siehe
\cite[S.44ff.]{chipbuch}). Zum Beispiel sind Eurocheque-Karten Magnetstreifenkarten.

Die neueste Art der Identifikationskarte ist die {\it Chipkarte} (Smart Card), in die ein Mikrochip eingebaut ist. Solche Karten
sollen in den folgenden Abschnitten beschrieben werden (angelehnt an \cite{chipbuch}).


% ***** Überblick über Chipkarten-Typen *****

\subsubsection{"Uberblick "uber Chipkarten-Typen} \label{chipkartentypen}
Chipkarten sind dadurch charakterisiert, dass in ihnen ein Mikrochip, der einen integrierten Schaltkreis enth"alt,
untergebracht ist. Der Chip verf"ugt "uber Funktionseinheiten zum Speichern, Verarbeiten und "Ubertragen von Daten,
ist also ein eigenst"andiges Rechensystem.

Es gibt mehrere Gr"unde daf"ur, Chipkarten zu benutzen:
\begin{itemize}
\item Chipkarten bieten viel Platz zum Speichern von Informationen. W"ahrend auf einer hochgepr"agten Karte nur einige
Byte, das hei"st einige Zeichen, und auf einer Magnetstreifenkarte etwa 1000 Bit (Quelle: \cite[S.~44f.]{chipbuch}) gespeichert
werden k"onnen, sind auf einer Chipkarte mehrere Kilobyte "ublich. Es gibt bereits Karten mit mehr als 32 KByte Speicher.
Nicht f"ur jede Anwendung wird so viel Speicher ben"otigt, aber f"ur sicherheitsrelevante F"alle, z.B. die Speicherung
eines Datenschl"ussels, sind einige KByte n"otig.
\item Die auf der Chipkarte gespeicherten Daten sind gesch"utzt. Dieser Schutz gilt sowohl gegen das Auslesen der Daten
als auch gegen ihre Manipulation. Es ist m"oglich, geheime Daten in den Mikrochip zu laden, die von au"sen nicht mehr
gelesen werden k"onnen, sondern nur noch im Rechenwerk des Chips verarbeitet werden k"onnen. Erm"oglicht wird dieser
Schutz durch eine Vielzahl von Sicherheitsma"snahmen (Details siehe \cite[S.~469ff.]{chipbuch}).
\item Chipkarten k"onnen Berechnungen durchf"uhren. W"ahrend hochgepr"agte Karten und Magnetstreifenkarten lediglich
zum Speichern von Informationen dienen, kann eine Chipkarte Rechenoperationen durchf"uhren. Die Berechnungen
k"onnen von gespeicherten Daten auf der Chipkarte und von "au"seren Eingaben abh"angen. Die Ergebisse k"onnen
gespeichert oder nach au"sen abgegeben werden.

Dadurch er"offnet sich eine Vielzahl von Anwendungsgebieten, beispielsweise die Verwendung von Authentifikationsalgorithmen
(siehe Kapitel \ref{authentifikation}) mithilfe einer Chipkarte.
\item Chipkarten sind g"unstig in der Herstellung. Als Werkstoff f"ur den Kartenk"orper wird meist Polyvinylchlorid (PVC)
benutzt, das sehr preiswert ist (siehe \cite[S.70]{chipbuch}). In der Massenproduktion ist der Mikrochip ebenfalls g"unstig
herzustellen, und die Montage ist einfach und kosteng"unstig durchf"uhrbar.
Teuer ist allerdings der Eigenentwurf einer Chipkarte.
\end{itemize}


\paragraph{Speicherkarten} \quad \newline

Speicherkarten dienen dem Abspeichern von Informationen, die vor Manipulation und L"oschung gesch"utzt sein
sollen. In Abb.~\ref{speicherkarte} ist schematisch der Aufbau einer Speicherkarte skizziert.

\begin{floatingfigure}[r]{8cm}
\includegraphics{abbildungen/speicherkarte.eps}
{\it \caption[Schema einer Speicherkarte]{\label{speicherkarte}Schema einer Speicherkarte. Die "au"seren Anschl"usse
der Karte sind angedeutet (nach \cite[S.49]{chipbuch}).}}
\end{floatingfigure}

Die Anwendungsdaten sind in einem EEPROM
(,,Electrically Erasable Read Only Memory``) abgelegt, das hei"st sie sind in einem wiederbeschreibbaren, nichtfl"uchtigen
Speicher abgelegt und k"onnen demnach ge"andert werden. Die Karte besitzt weiterhin einen Nur-Lese-Speicher
(,,Read-Only Memory``), in dem die Identifizierungsdaten der Karte abgelegt sind, die nicht ge\-"an\-dert werden k"onnen.
Der Zugriff auf den Speicher wird hardwarem"a"sig durch die Sicherheitslogik kontrolliert.

Speicherkarten sind synchrone Karten, das hei"st die Kommandos werden von au"sen durch elektrische Signale an die Karte
gesendet.

Ein Beispiel f"ur eine Speicherkarte ist die Krankenversicherungskarte, auf der Informationen "uber Krankenversicherte
abgespeichert sind.

\vspace{5mm} % wegen Grafik


\paragraph{Mikroprozessorkarten} \quad \newline

Eine Weiterf"uhrung des Konzeptes, integrierte Schaltungen auf einer Chipkarte unterzubringen, ist die Mikroprozessorkarte,
die in Abb.~\ref{mikroprozkarte} schematisch dargestellt ist.

Auf ihr ist ein vollst"andiger Mikrorechner untergebracht, der {\it Mikrocontroller} genannt wird. Seine Hauptkomponente
ist ein Mikroprozessor (CPU).

\begin{floatingfigure}[r]{8cm}
\includegraphics{abbildungen/mikroprozkarte.eps}
{\it \caption[Schema einer Mikroprozessorkarte]{\label{mikroprozkarte}Schema einer Mikroprozessorkarte.
Die "au"seren Anschl"usse der Karte sind angedeutet (nach \cite[S.50]{chipbuch}).}}
\end{floatingfigure}

 Zus"atzlich verf"ugt der Mikrocontroller "uber drei Arten von Speicher:
ein ROM, auf dem das Be\-triebs\-sys\-tem der Karte fest verankert ist, ein EEPROM, das hei"st ein nichtfl"uchtiger Speicher,
f"ur Teile des Be\-triebs\-sys\-tems und zur Speicherung von Daten (entsprechend dem EEPROM einer Speicherkarte, s.o.)
und RAM als fl"uchtigen Arbeitsspeicher.

Als weitere Komponente kann in einem Mikrocontroller ein Coprozessor (NPU), auch {\it Akzelerator} genannt, vorhanden
sein. Dabei handelt es sich um eine Funktionseinheit, die f"ur eine bestimmte Rechenoperation sehr hoch optimiert
ist und diese Operation wesentlich schneller ausf"uhren kann als der Zentralprozessor. Angesto"sen wird die
Berechnung durch den Zentralprozessor, der ein Signal an den Coprozessor sendet und danach auf das Fertig-Signal
des Coprozessors wartet.
Die Rechenoperation ist zumeist eine Berechnung im Kontext von kryptographischen Algorithmen, ist aber je nach
Anforderung in verschiedenen Anwendungsgebieten unterschiedlich.

Als Schnittstelle nach au"sen besitzt der Mikrocontroller eine Datenleitung (siehe Abb.~\ref{mikroprozkarte}). Eine
Steuerleitung wie die von Speicherkarten gibt es nicht, weil die Steuerung nach festgelegten Kommandos erfolgt, die
im Betriebssystem des Mikrocontrollers festgelegt sind. Mikroprozessorkarten sind also asynchrone Karten.


% ***** Aufbau einer Chipkarte *****

\subsubsection{Aufbau einer Chipkarte} \label{chipkartenaufbau}

Der physikalische Aufbau einer Chipkarte soll im Folgenden beschrieben werden. Dabei werden nur Mikroprozessorkarten
betrachtet, weil nur sie f"ur die Anwendung, n"amlich die Implementierung von Zufallszahlengeneratoren, geeignet
sind. Speicherkarten sind zwar vom "au"seren Aufbau identisch mit Mikroprozessorkarten, sind aber nicht
programmierbar, weil kein Prozessor auf ihnen vorhanden ist (siehe \ref{chipkartentypen}).

Es wird in den folgenden Abschnitten analog zu \cite[S.~56ff.]{chipbuch} vorgegangen.


\paragraph{"Au"serer Aufbau} \quad \newline

\begin{floatingfigure}[r]{11cm}
\includegraphics{abbildungen/kartenmasse.eps}
{\it \caption[Ma"se einer ID-1-Karte]{\label{kartenmasse}Ma"se einer Chipkarte im ID-1-Format. Die Anschl"usse des
Chips sind angedeutet. Die Toleranzen sind nicht eingezeichnet (nach \cite[S.57, S.110]{chipbuch}).}}
\end{floatingfigure}

Die Formate der Karten sind durch die ISO-Norm 7810 festgelegt. In Abb.~\ref{kartenmasse} sind die Abmessungen einer
Karte im ID-1-Format dargestellt. Neben der ID-1-Karte, die am verbreitetsten ist, gibt es das kleinere ID-00-Format,
das bisher kaum verwendet wird, und das ID-000-For\-mat, das speziell f"ur Karten in Mobiltelefonen definiert wurde.
Neben dem Kartenformat sind in der ISO-Norm auch die physikalischen Eigenschaften von Chipkarten festgelegt. Dazu
z"ahlen nicht nur die Werkstoffe, sondern auch die physikalische Belastbarkeit der Karte, beispielsweise die
mechanische Belastbarkeit und die Temperatur\-be\-st"an\-dig\-keit. Details sind in \cite[S.~521ff.]{chipbuch} zu finden.


\paragraph{Anschluss des Mikrochips} \quad \newline

Die heutzutage am weitesten verbreitete Technik, den Mikrochip in der Karte unterzubringen, ist die
Chip-on-Flex-Technik.

\begin{floatingfigure}[r]{8cm}
\includegraphics{abbildungen/chiponflex.eps}
{\it \caption[Querschnitt durch eine Chipkarte]{\label{chiponflex}Querschnitt durch eine Chipkarte in der
Chip-on-Flex-Technik (nach \cite[S.76]{chipbuch}).}}
\end{floatingfigure}

Dabei wird zun"achst ein Geh"ause f"ur den Chip, das Chip-on-Flex-Modul, hergestellt. Das Modul umfasst erst einmal nur
die nach au"sen sichtbaren metallischen Anschl"usse der Chipkarte. Der Chip wird auf das Modul aufgesetzt, und
die Kontakte des Chips werden mit d"unnen Dr"ahten mit den Metallkontakten des Moduls verbunden (Draht-Bond-Verfahren,
Wire-Bonding).
Es wird ein Loch in den Kartenk"orper gefr"ast und das Modul in dieses Loch geklebt. Das Ergebnis des Einbaus ist
in Abb.~\ref{chiponflex} skizziert.

Das Chipmodul verf"ugt "uber 8 Anschl"usse. Die Nummerierung dieser Kontakte und deren Belegung sind in Abb.
\ref{pinbelegung} dargestellt. Die Signale sind wie folgt definiert:
\begin{itemize}
\item \texttt{\textbf{CLK}}: Takt-Signal f"ur die Hardware. Auf der Chipkarte ist kein Taktgenerator vorhanden, daher
muss der Takt vom Terminal erzeugt und an die Karte angelegt werden.
\item \texttt{\textbf{I/O}}: Datenleitung. Da es nur {\it eine} Datenleitung gibt, ist die Kommunikation nur im
Halbduplex-Modus m"oglich. Also sendet entweder das Terminal Daten oder die Chipkarte, aber nie beide gleichzeitig.
\item \texttt{\textbf{GND}}: Masse
\item \texttt{\textbf{RST}}: Reset-Signal
\item \texttt{\textbf{Vcc}}: Versorgungsspannung
\item \texttt{\textbf{Vpp}}: Programmierspannung (wird nicht mehr benutzt)
\end{itemize}

~ %einige Verrenkungen, damit die Grafiken richtig erscheinen

~


\begin{floatingfigure}[r]{15cm}
\includegraphics{abbildungen/pinbelegung.eps}
{\it \caption[Anschl"usse einer Chipkarte]{\label{pinbelegung}Nummerierung und Belegung der Anschl"usse einer
Chipkarte. Die Anschl"usse C4 und C8 sind unbenutzt (,,Not Connected``) (nach \cite[S.76]{chipbuch}).}}
\end{floatingfigure}
~

\vspace{2cm}

~

\vspace{1cm}

% ***** Datenübertragung von/zu einer Chipkarte *****

\subsubsection{Daten"ubertragung von/zu einer Chipkarte} \label{chipkartendue}


\paragraph{Ablauf einer Chipkartensitzung} \quad \newline

Wenn eine Chipkarte in ein Kartenterminal hineingef"uhrt wird, soll eine Verbindung zwischen Karte und Terminal
etabliert werden. Der erste Schritt zur Herstellung der Verbindung ist die Initialisierung auf elektrischer
Ebene. Weil keine undefinierten Zust"ande der Signale auftreten sollen, ist die Reihenfolge der Signalwechsel
bei der Beschaltung von gro"ser Bedeutung. Zuerst wird die Masse angelegt, dann die Versorgungsspannung und
erst dann das Taktsignal f"ur den Mikroprozessor (siehe Abb.~\ref{anaussequenz}). Der Mikrocontroller ist nach
dem Anlegen des Taktes in Betrieb und wird durch das Reset-Signal in einen definierten Anfangszustand gebracht.
Sobald von der Chipkarte an die Datenleitung ein definierter Wert angelegt wird, wird das Reset-Signal vom
Terminal zur"uckgesetzt (wegen negativer Logik auf ,,high``).

\begin{floatingfigure}[l]{15cm}
\includegraphics{abbildungen/anaussequenz.eps}
{\it \caption[Ein-/Ausschaltsequenz einer Chipkarte]{\label{anaussequenz}Ein-/Ausschaltsequenz einer Chipkarte.
Die Abfolge der Signalwechsel an den Anschl"ussen der Karte ist qualitativ skizziert (nach \cite[S.87]{chipbuch}).}}
\end{floatingfigure}
~\vspace{9cm}

Nach dem Initialisieren der Chipkarte auf elektrischer Ebene erfolgt die Initialisierung der Kommunikation.
Sie ist zusammen mit dem Kommandoaustausch zwischen Terminal und Karte als Ort-Zeit-Diagramm in Abb.~\ref{sitzung}
dargestellt.

\begin{floatingfigure}[r]{8cm}
\includegraphics{abbildungen/sitzung.eps}
{\it \caption[Datenaustausch zwischen Terminal und Karte]{\label{sitzung}Ort-Zeit-Diagramm des Datenaustauschs zwischen
Kartenterminal und Chipkarte. Horizontal sind die beiden Orte aufgetragen, und die Zeitachse verl"auft nach unten
(nach \cite[S.324]{chipbuch}).}}
\end{floatingfigure}

Die Chipkarte reagiert auf den Reset mit einem ATR-Datenpaket (,,Answer to Reset``). Der ATR ist ein Datenstring, der
"Ubertragungsparameter f"ur die Kommunikation festlegt; ausf"uhrliche Details sind in \cite[S.~330ff.]{chipbuch} zu finden.

Wenn das Kartenterminal einige von der Chipkarte festgelegten "Ubertragungsparameter "andern m"ochte, so kann es das
direkt im Anschluss an das empfangene ATR tun. Dazu kann es eine Protocol Type Selection (PTS) durchf"uhren, indem
es eine PTS-Anfrage an die Karte sendet. Die Karte antwortet auf die Anfrage und kann bestimmte "Anderungen zulassen
oder nicht (Details in \cite[S.~342ff.]{chipbuch}).

Nach der Verhandlungsphase "uber die Kommunikationsparameter erfolgt die eigentliche Kommunikation. Dabei sendet das
Chipkartenterminal Kommandos an die Chipkarte, und die Chipkarte sendet jeweils Antworten, wie in Abb.~\ref{sitzung}
skizziert.  Das hei"st, dass die Chipkarte keine Kommandos an das Terminal
senden darf. Diese Art der Kommandoabarbeitung hei"st {\it Chal\-lenge-Response-Verfahren}. Die Kommandos werden
weiter unten in diesem Abschnitt vorgestellt.

\vspace{3cm}

\paragraph{Kommunikationsprotokolle} \quad \newline

F"ur den Entwurf und die Beschreibung der Daten"ubertragung zwischen dem Kartenterminal und der Chipkarte wird
das OSI-Modell (,,Open Systems Interconnection``) benutzt, das ebenfalls zur Darstellung der Kommunikation in
Rechnernetzwerken verwendet wird.

Im Falle von Chipkarten besteht das Modell allerdings nicht aus 7, sondern aus 3 Schichten (siehe Abb.~\ref{osimodell}).

\begin{floatingfigure}[r]{15cm}
\includegraphics{abbildungen/osimodell.eps}
{\it \caption[OSI-Modell der Kommunikation]{\label{osimodell} Das OSI-Modell der Kommunikation zwischen Kartenterminal und
Chipkarte. Dargestellt sind die 3 Schichten und das "Ubertragungsmedium mit den Datenfl"ussen zwischen den Schichten.
Zu den Schichten sind einige Protokolle angegeben (nach \cite[S.325]{chipbuch}).}}
\end{floatingfigure}
~\vspace{8cm}

\newpage
Die unterste Schicht, die physikalische Schicht, ist f"ur den Austausch von Bitstr"omen zust"andig. Es gibt zwei
unterschiedliche Protokolle, die genormt sind: Kontaktbehaftete Karten (ISO/IEC 7816-3) und kontaktlose Karten
(ISO/IEC 10 536-3).

Schicht 2 ist die Leitungsschicht. Ihre Aufgaben sind die "Ubermittlung von Dateneinheiten (byte- oder blockweise), die
Bereitstellung einer fehlerfreien Verbindung (Fehlerkorrektur) sowie die Zugriffssteuerung (halb- oder vollduplex).
Die am meisten verwendeten Protokolle der Leitungsschicht sind das einfache T=0 (sprich ,,Transport Protocol 0``) nach
ISO-Norm 7816-3, T=1 und T=14, das ein Standard der Telekom AG ist und nur in Deutschland Verwendung findet. F"ur Details
wird auf \cite[S.~354ff.]{chipbuch} verwiesen.

Die oberste Schicht ist die Anwendungsschicht, in der Protokolle der Anwendungsdom"ane verwendet werden. Das ist
beispielsweise das GSM-Protokoll (,,Global System for Mobile Communications``), das im Bereich des Mobilfunks
benutzt wird.


\paragraph{Chipkarten-Kommandos} \quad \newline

Es gibt eine Vielzahl m"oglicher Kommandos, die ein Chipkartenterminal an eine Chipkarte senden kann. Die Anzahl der
Kommandos ist sogar derart umfangreich, dass es keine Chipkarte gibt, die alle Kommandos verarbeiten kann; das ist
vom daf"ur n"otigen Speicheraufwand schon nicht m"oglich. Stattdessen sind die Kommandos, die eine Chipkarte versteht,
vom Anwendungsgebiet abh"angig. So gibt es f"ur den Zahlungsverkehr oder f"ur die Telekommunikation unterschiedliche
Kommandos, die nur die entsprechenden Chipkarten verarbeiten k"onnen.

\quad ~

\quad ~

\begin{floatingfigure}[l]{15cm}
\includegraphics{abbildungen/chipkommandos.eps}
{\it \caption[Klassifizierung von Chipkartenkommandos]{\label{chipkommandos} Klassifizierungsbaum der Kommandos an
Chipkarten (nach \cite[S.396]{chipbuch}).}}
\end{floatingfigure}

\quad ~

\vspace{12cm}
F"ur Chipkarten-Kommandos gibt es diverse Normen und Standards, beispielsweise EMV (,,Europay, Mastercard, VISA`` -- die
Marktf"uhrer) im Zahlungsverkehr oder GSM im Bereich der Telekommunikation.

Einen "Uberblick "uber die Chipkartenkommandos liefert der Klassifizierungbaum der Kommandos in Abb.~\ref{chipkommandos}.
F"ur diese Studienarbeit sind die Kommandos zur Erzeugung von Zufallszahlen und zur Authentifikation von gr"o"stem Interesse.
Sie sollen daher nun vorgestellt werden (nach \cite[S.~415ff.]{chipbuch}.

\begin{itemize}
\item \textbf{GET CHALLENGE}: Fordert die Karte auf, eine Zufallszahl an das Terminal zu senden.
\item \textbf{INTERNAL~AUTHENTICATE}: Authentifikation der Chipkarte, das hei"st die Chipkarte muss sich dem Terminal
gegen"uber authentifizieren. Das Terminal gibt eine Zahl als Parameter an und fordert die Karte auf, diese Zahl mit
einem zuvor vereinbarten Schl"ussel zu verschl"usseln. Diese verschl"usselten Daten sendet die Karte an das Terminal,
das sie mit den von ihm selbst verschl"usselten Daten vergleicht. Wenn die beiden verschl"usselten Daten gleich sind,
hat sich die Karte authentifiziert.
\item \textbf{EXTERNAL~AUTHENTICATE}: Authentifikation des Terminals gegen"uber der Chipkarte. Man beachte, dass dieses
Kommando vom Terminal aus gesendet wird, weil eben alle Kommandos vom Terminal gesendet werden m"ussen (vgl. Abb.
\ref{sitzung}). Die Chipkarte muss also so programmiert sein, dass sie erst dann Zugriff auf die Daten gew"ahrt,
wenn das Terminal sich gegen"uber der Chipkarte authentifiziert, das hei"st EXTERNAL~AUTHENTICATE aufgerufen hat.

Das Terminal sendet als Parameter eine mit einem zuvor vereinbarten Schl"ussel verschl"usselte Zufallszahl, die es
mit GET~CHALLENGE von der Chipkarte angefordert hat. Die Chipkarte f"uhrt dieselbe Verschl"usselung durch und
vergleicht die beiden verschl"usselten Informationen. Wenn sie gleich sind, hat sich das Terminal authentifiziert,
und die Karte gibt die Benutzung der Datenkommandos frei.
\end{itemize}



% ******************************************************************
% ***** Kapitel 4 (Bewertungskriterien für Zufallsgeneratoren) *****
% ******************************************************************

\newpage
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Kapitel falsch im Inhaltsverzeichnis erscheint.
\section{Bewertungskriterien f"ur Zufallsgeneratoren} \label{analyseverfahren}


% ***** Überblick über Anforderungen an Zufallsgeneratoren *****

\subsection{"Uberblick "uber Anforderungen an Zufallsgeneratoren \hspace{2.7cm}} \label{zufallszahlenanforderungen}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{9.6cm}(von Stefan Witt)}}

In diesem Abschnitt wird vorgestellt, welche Eigenschaften ein Generator f"ur Pseudozufallszahlen besitzen soll.
Diese Eigenschaften spiegeln die Qualit"at des Generators wider.
Dabei werden zun"achst allgemeine Kriterien dargelegt, und dann folgen einige Kriterien, die sich dadurch ergeben, dass
die Zufallsgeneratoren auf Chipkarten implementiert werden sollen.

\paragraph{Allgemeine Anforderungen an einen Zufallszahlengenerator} \quad \newline

Ein guter Zufallszahlengenerator muss die folgenden Eigenschaften erf"ullen (nach \cite[S.~27f.]{dissertation}):
\begin{itemize}
\item Die erzeugten Zufallszahlen sind {\it gleichverteilt}, das hei"st sie treten alle mit derselben Wahrscheinlichkeit
auf, z.B. $0$ und $1$ beide jeweils mit einer Wahrscheinlichkeit von $50\%$.
\item Die erzeugten Zufallszahlen sind {\it unkorreliert}. Das bedeutet, sie sind alle voneinander stochastisch
unabh"angig. Es ist jedoch so, dass die Zufallszahlengeneratoren die n"achsten Zahlen auf zuvor erzeugte Zahlen
beziehen, also dass der aktuelle interne Zustand des Generators von den zuvor erzeugten Zahlen abh"angt. Dadurch sind
die Ergebniswerte in {\it jedem} Zufallsgenerator korreliert. Die Forderung muss demnach genauer lauten: Die Korrelation
der erzeugten Zufallszahlen ist sehr klein, so dass sie mit statistischen Untersuchungen nicht gefunden wird.
\item Der Generator ist {\it effizient}. Er muss einen geringen Platz- und Zeitbedarf besitzen, so dass er m"oglichst
mit minimalem Speicheraufwand sehr viele Zufallszahlen in kurzer Zeit erzeugt.
\item Der Generator besitzt eine {\it gro"se Periode}. Es ist unm"oglich, einen Zufallsgenerator zu entwerfen, dessen
Folge der erzeugten Zufallszahlen sich nicht wiederholt, der also eine unendliche Periode besitzt. Daher wird zumindest
eine gro"se Periode gefordert.

Die Periode ist ausreichend gro"s, wenn sie gr"o"ser ist als die Anzahl der Zahlen, die mit dem Zufallsgenerator erzeugt
werden sollen.
\item Der Generator ist {\it einfach implementierbar}. Das bezieht sich sowohl auf Hardware- als auch
Software-Implementierungen. Je nach Generator kann es allerdings aufw"andiger sein, ihn entweder in Hardware oder in
Software umzusetzen.
\item Das Verfahren darf {\it "offentlich bekannt} sein. Das ist keine Einschr"ankung an den Zufallszahlengenerator,
weil er trotzdem Zufallszahlen erzeugen kann: Geheim gehalten werden, soweit es erforderlich ist, der Startwert
des Generators und damit sein interner Zustand.
\end{itemize}

\paragraph{Anforderungen an Zufallsgeneratoren auf Chipkarten} \quad \newline

F"ur die Implementierung von Zufallszahlengeneratoren auf Chipkarten, die eines der Hauptthemen dieser Studienarbeit ist,
gelten besondere Anforderungen. Sie sollen nun vorgestellt werden.
\begin{itemize}
\item Der Generator muss {\it besonders schnell} sein. Der Grund daf"ur ist, dass die Antwortzeit der Chipkarte
m"oglichst gering sein soll, um Realzeitanforderungen zu gen"ugen. Inklusive der Kartenansteuerung, der
Authentifikation und dem Kommunikationsoverhead (siehe Abschnitt \ref{chipkartendue}) soll die Antwortzeit nicht
mehr als 0,3 Sekunden betragen, damit der gesamte Vorgang vom Menschen als augenblicklich angesehen wird.

Die notwendige Antwortzeit eines Zufallsgenerators ist allerdings sehr stark von der Implementierung abh"angig. Deshalb
kann der Zeitaufwand lediglich von der Gr"o"senordnung her zwischen verschiedenen Generatoren verglichen werden.
\item Der Generator muss eine {\it geringe elektrische Leistungsaufnahme} haben. Sie ist abh"angig vom
Hard\-ware\-auf\-wand, weil jeder Transistor elektrische Leistung aufnimmt und in W"armeleistung umsetzt.

Die Leistungsaufnahme kann auch dadurch minimiert werden, dass sich in zwei aufeinander folgenden erzeugten Zufallszahlen
m"oglichst wenige Bits "andern, das hei"st von 0 auf 1 bzw. umgekehrt wechseln. Der Grund daf"ur ist die inh"arente
Eigenschaft von CMOS-Schaltkreisen (,,Complementary Metal Oxide Semiconductor`` -- eine Schaltkreisfamilie),
dass die Leistungsaufnahme beim Wechsel von Low- und High-Spannungspegel sehr gro"s ist, w"ahrend sie im Fall des
konstant bleibenden Pegels minimal ist.
\item Der Zufallsgenerator muss mit {\it geringem Hardwareaufwand} umsetzbar sein. Die Gr"unde daf"ur sind die schon
genannte Verlustleistung und die begrenzte zur Verf"ugung stehende Chipfl"ache.
\end{itemize}


% ***** Komplexit"at *****
\subsection{Komplexit"at \hspace{3.3cm}} \label{komplexitaet}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{3.3cm}(von Peter Hartmann)}}

\paragraph{Zeitkomplexit"at und Antwortzeit} \quad \newline

Ein wichtiges Kriterium zur Beurteilung der Qualit"at eines Zufallszahlengenerators ist die Zeitkomplexit"at bei der 
Erzeugung der Zufallszahlen. Wie bereits erw"ahnt, sind hier 0,3 Sekunden die obere Grenze f"ur die Antwortzeit der 
Chipkarte auf eine Anfrage nach einer Zufallszahl. Die Antwortzeit setzt sich aus der Zeitdauer f"ur die 
Kommunikation mit dem Terminal und der Zeitdauer f"ur die Erzeugung der Zufallszahl zusammen.

Nach Abb.~\ref{sitzung} (Seite~\pageref{sitzung}) ist vor dem Anfragekommando, welches die Chipkarte zur Erzeugung einer
Zufallszahl auffordert, noch der Reset auszuf"uhren. Dies geschieht immer, wenn die Chipkarte in das Terminal
eingesteckt wird und damit die Versorgungsspannung, der Takt und das Resetsignal angelegt werden 
(siehe Kapitel~\ref{chipkartendue}). Die Karte antwortet innerhalb von 400 bis 40 000 Taktzyklen mit einem ATR 
(siehe \cite[S. 330]{chipbuch} oder Kapitel~\ref{chipkartendue}). Die PTS-Anfrage (siehe Kapitel~\ref{chipkartendue})
wird hier zeitlich nicht in Betracht gezogen, da bei den in dieser Arbeit 
vorgestellten Anforderungen davon ausgegangen werden kann, dass die Chipkarten auf die Terminalanforderungen 
abgestimmt sind, so dass eine "Anderung des Protokolls nicht erforderlich ist. F"ur die "Ubertragungsraten 
gebr"auchlicher Kommandos werden in~\cite[S.~359ff.]{chipbuch} f"ur das Protokoll T=0 etwa 70 000 bis 134 000 
Taktzyklen angegeben. Das bedeutet, dass allein f"ur die Kommunikation zwischen Terminal und Chipkarte bereits 
308 000 Taktzyklen ben"otigt werden k"onnten. Unter Benutzung der Standardfrequenz von 3,5712 MHz sind so 
bereits 0,086 Sekunden verstrichen, und f"ur die Generierung der Zufallszahl stehen nur noch 0,218 Sekunden zur 
Verf"ugung, um die obere Grenze von 0,3 Sekunden einzuhalten.

F"ur die einzelnen Generatoren wird in Abh"angigkeit vom Takt die Anzahl der erzeugten Zufallsbits angegeben. Um 
daraus einen besser zu interpretierenden und vergleichbareren Wert zwischen den verschiedenen Generatoren zu 
erhalten, wird der Wert unter der Annahme, dass die Karte mit 3,5712 MHz getaktet wird, in einen Wert 
umgerechnet, der die Zeitkomplexit"at in Bits pro Sekunde angibt. So lassen sich die Generatoren einfach vergleichen, 
und es wird offensichtlich, ob die Generatoren unterhalb der Zeitschranke von 0,218 Sekunden bleiben. Es l"asst sich 
dann sogar leicht angeben, welche Anzahl von Bits innerhalb der Zeitgrenze erzeugt werden k"onnten.

Liefert als Beispiel ein Generator in 640 Takten genau 2 Zufallsbits, dann erzeugt er bei 3,5712 Millionen 
Verarbeitungsschritten 11 160 Zufallsbits. Die Leistung dieses Generators liegt also bei 11 160 Bit/s. Innerhalb von 0,2 
Sekunden k"onnte der Generator also 2 232 Bit erzeugen.

\paragraph{Speicherbedarf} \quad \newline

Ein weiteres wichtiges und restriktives Kriterium ist der Speicherbedarf, den der Generator auf der Chipkarte erfordert, 
da die Chipfl"ache begrenzt ist. Hierbei werden zwei Kriterien unterschieden. Einmal der Speicherplatz, angegeben 
in Anzahl der Flipflops, die die Operanden in Abh"angigkeit ihrer Gr"o"se ben"otigen. Hierbei wird einmal der 
ben"otigte Registerplatz f"ur die Operanden im statischen Zustand angeben, da die M"oglichkeit eines Akzelerators auf 
der Chipkarte besteht, der dann f"ur den ben"otigten dynamischen Speicher zust"andig w"are. Die ben"otigten Register 
w"ahrend der Berechnung der Zufallszahlen durch Hilfsvariablen werden zus"atzlich angeben, sind aber bei 
Vorhandensein eines Akzelerators unerheblich; ist dieser nicht vorhanden, so gilt diese Aussage nicht.

Als zweites Kriterium wird durch das Programm {\tt AMS~SYNOPSYS} der Speicherzellenbedarf in verschiedenen 
Abh"angigkeiten ermittelt. Die benutzten Einstellungen, die auch die Speicherzellenangabe beeinflussen, sind:

\vspace{-7mm}
\begin{tabbing}
\quad AMS Process\quad \= \kill\\
\quad Input \> \hspace{-3mm}: CSX, \\
\quad AMS Process\> \hspace{-3mm}: CSA/CSD \quad CMOS, \\
\quad Strukturgr"o"se\> \hspace{-3mm}: 0,35 $\mu m$. \\
\end{tabbing}


% ***** Hardware-Kriterien *****
\subsection{Hardware-Kriterien \hspace{3.3cm}} \label{hardwarekriterien}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{4.4cm}(von Peter Hartmann)}}

\paragraph{Akzeleratoren} \quad \newline

Ein Akzelerator ist eine Funktionseinheit, die bestimmte komplexere Berechnungen optimiert ausf"uhren kann (siehe 
Kapitel~\ref{chipkartentypen}, Abschnitt ,,Mikroprozessorkarten``). Ist auf einer Chipkarte ein Akzelerator vorhanden, 
der einen Verarbeitungsschritt optimiert ausf"uhrt, der auch von dem Zufallszahlengenerator benutzt wird, dann ist es 
nahe liegend, den Akzelerator auch f"ur den Generator zu benutzen. Bei den vorgestellten Generatoren betrifft das den 
BBS-Generator (siehe Kapitel~\ref{bbsvorstellung}), der die Quadrierung von Zahlen benutzt und den EC-Generator, 
der die Punktaddition einer elliptischen Kurve benutzt. Geht man vom Vorhandensein eines passenden Akzelerators 
aus, dann schneiden die beiden Generatoren nicht mehr so schlecht im Vergleich zu RC4 und LFSR bez"uglich des 
Speicherzellenbedarfs ab, da die aufw"andige Funktionseinheit zur  Quadrierung bzw. der Punktaddition schon auf 
der Karte vorhanden ist. Die Zufallsgeneratoren werden detailliert in Kapitel~\ref{zzg} verglichen.

\paragraph{Leistungsaufnahme} \quad \newline

Die Leistungsaufnahme sollte aus den technischen Gr"unden der Umsetzung in W"armeleistung und der 
Dimensionierung der einzelnen dotierten Gebiete auf der Chipfl"ache so gering wie m"oglich sein. Auch im Hinblick 
auf kontaktlose Chipkarten, die ihre Stromversorgung nicht durch das Kartenleseger"at, sondern durch induktive 
Kopplung erhalten, ist eine minimale Leistungsaufnahme ein entscheidendes Qualit"atsmerkmal. Das hier benutze 
Ma"s wird keine konkrete Leistungsangabe, sondern die Angabe der kippenden Bits sein, da diese in erster Linie f"ur 
die Leistungsaufnahme verantwortlich sind. Dazu werden in Abh"angigkeit von der Erzeugung einer Zufallszahl die 
Anzahl der Wechsel der Flipflopinhalte von 0 auf 1 und umgekehrt angegeben werden.


% ***** Test auf Gleichverteilung *****
\subsection{Test auf Gleichverteilung \hspace{2.7cm}} \label{testgleichverteilung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{5.3cm}(von Stefan Witt)}}

Die von einem Zufallsgenerator erzeugten Zahlen sollen, wie bereits in Abschnitt~\ref{zufallszahlenanforderungen} gesagt,
gleichverteilt sein, das hei"st die erzeugten Zahlen sollen alle mit gleicher Wahrscheinlichkeit auftreten. Da die
Zufallsgeneratoren in dieser Arbeit auf einer Chipkarte implementiert werden sollen, wird angenommen, dass die
erzeugten Zufallszahlen als Bin"arzahlen vorliegen, also mit den Ziffern $0$ und $1$ dargestellt werden.

Die Anzahl der Bin"arziffern der Zufallszahl werde im Folgenden mit $k$ bezeichnet, und $n$ sei die Anzahl der vorliegenden
Zufallszahlen. Es wird davon ausgegangen, dass eine Stichprobe $x_{1}, x_{2},\dots, x_{n}$  von Zufallszahlen von
einem Zufallsgenerator erzeugt wurde.

Es gibt grunds"atzlich zwei unterschiedliche Ans"atze zum Testen auf Gleichverteilung: Entweder wird
getestet, ob in jeder Zufallszahl durchschnittlich gleich viele Einsen und Nullen auftreten, oder es wird getestet,
ob jede m"ogliche Zufallszahl mit der gleichen Wahrscheinlichkeit auftritt. Beide Testalternativen werden in den beiden
folgenden Abschnitten vorgestellt\footnote{Bei idealen Zufallsgeneratoren w"urde es ausreichen, nur einen der beiden
Tests durchzuf"uhren. In Kapitel~\ref{zzg} werden aber Unterschiede zwischen beiden Tests festgestellt werden, und
deshalb werden hier beide Verfahren vorgestellt.}.


\paragraph{Pr"ufen der bitweisen Wahrscheinlichkeit} \quad \newline

Es sollen nun zwei Methoden dargestellt werden, um zu pr"ufen, ob Einsen und Nullen jeweils mit der Wahrscheinlichkeit
$\frac{1}{2}$ auftreten, also die bitweise Wahrscheinlichkeit $\frac{1}{2}$ ist. Ein erster Ansatz dazu k"onnte sein,
die erzeugten Zufallsbits als Sequenz anzusehen und zu pr"ufen, ob gleich viele Einsen und Nullen auftreten. Dieses
Verfahren entspr"ache dem Verfahren im folgenden Abschnitt ,,Pr"ufen der blockweisen Wahrscheinlichkeit`` mit der
Blockl"ange 1. Die von den Zufallsgeneratoren erzeugten Zahlen sind allerdings immer $k$ Bit lang, das hei"st es
werden immer Bl"ocke der L"ange $k$ ausgegeben.

Um zu testen, ob in jedem $k$ Bit langen Bitblock Einsen und Nullen jeweils mit der Wahrscheinlichkeit $\frac{1}{2}$
auftreten, m"ussen die Einsen in jedem Block gez"ahlt werden. Die Nullen brauchen nicht gez"ahlt zu werden, weil
sie sich ergeben, indem $k$ minus Anzahl der Einsen gerechnet wird. Es k"onnen $0$ bis $k$ Einsen in jeder
Zufallszahl auftreten, weil die L"ange einer jeden Zufallszahl $k$ Stellen ist. Es ist
allerdings {\it nicht} so, dass jede Anzahl von Einsen mit gleicher Wahrscheinlichkeit auftritt. Vielmehr ergibt sich
eine Binomialverteilung, weil das Erzeugen von aufeinander folgenden Zufallsbits als Bernoulli-Experiment aufgefasst
werden muss. Die Wahrscheinlichkeit f"ur das Auftreten von $i$ Einsen $(1~\leq~i~\leq~k)$ ist
\begin{equation}
P(X=i) = \left( _{i}^{k} \right) p^{i} (1-p)^{k-i}.
\label{formelbino}
\end{equation}
Ob diese theoretische Verteilung zutrifft, wird im Folgenden mit zwei Verfahren "uberpr"uft: mit dem Chi-Quadrat-Test
und der Anpassung an eine Normalverteilung.

\quad \newline

Mithilfe des Chi-Quadrat-Tests, der in Kapitel~\ref{statistikgrundlagen} vorgestellt wurde, kann getestet werden, ob
die Anzahlen der Einsen, die in den Zufallszahlen gez"ahlt werden, binomialverteilt sind.

Die zu untersuchende Stichprobe seien die vorliegenden $n$ Zufallszahlen $x_{1}, x_{2}, \dots, x_{n}$, und $k$ sei die
Anzahl der Bits dieser Zufallszahlen. $k$ ist gleichsam die Anzahl der Freiheitsgrade, also die m"oglichen Anzahlen
an Einsen in den Zufallszahlen. Das Signifikanzniveau, das hei"st das Sicherheitsniveau, wird auf $\alpha=0,95$ festgelegt.
Die Einsen der Zufallszahlen werden gez"ahlt, und die H"aufigkeiten werden mit $H_{i}$ bezeichnet.

Mit diesen Angaben kann die Testgr"o"se $\chi^{2}$ mithilfe von Formel~\ref{formelchiquadrat} aus
Kapitel~\ref{statistikgrundlagen} berechnet werden:
\begin{displaymath}
\chi^{2} = \sum _{i=1}^{k}{\frac{1}{n \cdot p_{i}}(H_{i} - n \cdot p_{i})^{2}},
\end{displaymath}
mit der Wahrscheinlichkeit aus Gleichung~\ref{formelbino} (mit $p_{1}$ sei die Wahrscheinlichkeit f"ur das
Auftreten einer $1$ bezeichnet; es soll $p_{1}=0,5$ sein)
\begin{displaymath}
p_{i} = \left( _{i}^{k} \right) p_{1}^{i} (1-p_{1})^{k-i}
=\left( _{i}^{k} \right) 0,5^{i} (1-0,5)^{k-i}
=\left( _{i}^{k} \right) 0,5^{k}
\end{displaymath}
und ineinander eingesetzt also
\begin{displaymath}
\chi^{2} = \sum _{i=1}^{k}{\frac{1}{n \cdot \left( _{i}^{k} \right) 0,5^{k}  }\left(H_{i} - n \cdot
\left( _{i}^{k} \right) 0,5^{k}\right)^{2}}.
\end{displaymath}

Der Wert $\chi^{2}$ wird wie in Kapitel~\ref{statistikgrundlagen} dargestellt ausgewertet. F"ur den Fall, dass der
Chi-Quadrat-Test ergibt, dass die Verteilung der Einsen nicht einer Binomialverteilung gen"ugt, ist ein weiteres
Pr"ufverfahren zum Testen der theoretischen Verteilung notwendig, das nun vorgestellt wird.

\quad \newline

Ein weiterer Test, ob die Einsen der Zufallszahlen binomialverteilt sind, ist die Ann"aherung einer Normalverteilung
an die Verteilung der Einsen. Das Verfahren, das dabei angewendet wird, ist in Kapitel~\ref{statistikgrundlagen}
(Abschnitt ,,Intervallsch"atzung f"ur die Normalverteilung``) beschrieben. Bei der Anpassung werden das Stichprobenmittel
(siehe Formel~\ref{formelstichprobenmittel}, S.~\pageref{formelstichprobenmittel}) und die Stichprobenstandardabweichung
(siehe Formel~\ref{formelstichprobenstandardabweichung}, S.~\pageref{formelstichprobenstandardabweichung}) berechnet.

Zum Vergleich mit der theoretisch vermuteten Binomialverteilung m"ussen ihr Erwartungswert $EN$ und ihre
Standardabweichung $\sigma_{N}$ berechnet werden. Das geschieht mit den Formeln
\begin{equation}
EN = \sum _{i=1}^{k}{k \cdot \left( _{i}^{k} \right) 0,5^{k}}
\label{formelerw}
\end{equation}
und
\begin{equation}
\sigma_{N} = \sqrt{\frac{1}{n} \cdot \sum_{i=1}^{n}{(p_{i} - EN})^{2}}
= \sqrt{\frac{1}{n} \cdot \sum_{i=1}^{n}{(\left( _{i}^{k} \right) 0,5^{k} - EN})^{2}}.
\label{formelstdabw}
\end{equation}
Wichtig ist, dass in der Formel zur Berechnung von $\sigma_{N}$ der Bruch $\frac{1}{n}$ auftritt und nicht $\frac{1}{n-1}$
wie in Formel~\ref{formelstichprobenstandardabweichung}. Der Grund daf"ur ist, dass $\sigma_{N}$ nicht gesch"atzt
werden muss, sondern die exakte Standardabweichung ist.

Es k"onnen nun die theoretische und die angen"aherte Verteilung verglichen werden. Wenn der Erwartungswert $EN$ der
theoretischen Verteilung im Konfidenzintervall um $\mu$ der angen"aherten Verteilung liegt und wenn die
Standardabweichungen $\sigma_{N}$ und $\sigma$ "ubereinstimmen, hat der Zufallsgenerator den Test bestanden.

\paragraph{Pr"ufen der blockweisen Wahrscheinlichkeit} \quad \newline

Mit dem folgenden Verfahren soll getestet werden, ob alle $n$ Zufallszahlen der L"ange $k$ mit der gleichen
Wahrscheinlichkeit auftreten. Es gibt $2^{k}$ m"ogliche Bitkombinationen der L"ange $k$ , die der Zufallsgenerator
ausgeben kann.

\begin{floatingtable}[r]{
{\centering
\begin{tabular}[b]{|c|c|}
\hline
\hspace{5mm} lfd. Nr. \hspace{5mm} & \hspace{5mm} Zufallszahl \hspace{5mm} \\
\hline
$1$ & 0111 \\
$2$ & 0111 \\
$3$ & 0100 \\
$4$ & 0011 \\
$5$ & 0101 \\
$6$ & 1000 \\
$7$ & 1100 \\
$8$ & 1011 \\
$9$ & 0101 \\
$10$ & 0011 \\
\hline
\end{tabular}
}}
{\it \caption{\label{statistikbeispiel} Beispiel der Ausgabe von 10 4-Bit-Zufallszahlen eines Zufallsgenerators}}
\end{floatingtable}

Es muss die H"aufigkeit $H_{i}$ ($1 \leq i \leq n$) jeder ausgegebenen Zahl gez"ahlt und mit der theoretischen
Gleichverteilung verglichen werden. Die Wahrscheinlichkeit jeder Zahl ist bei einer Gleichverteilung
\begin{displaymath}
p_{i}=\frac{n}{2^{k}}.
\end{displaymath}
Der Vergleich zwischen der H"aufigkeit und der Gleichverteilung geschieht wiederum mit dem Chi-Quadrat-Test. Durch
Einsetzen der Gleichverteilung in Formel~\ref{formelchiquadrat} aus Kapitel~\ref{statistikgrundlagen} ergibt sich:
\begin{displaymath}
\chi^{2} = \sum _{i=1}^{n}{\frac{2^{k}}{n^{2}}\left(H_{i} - \frac{n^{2}}{2^{k}}\right)^{2}}.
\end{displaymath}

Der Wert $\chi^{2}$ wird wiederum ausgewertet wie in Kapitel~\ref{statistikgrundlagen} dargestellt.


\paragraph{Durchf"uhrung der Tests mit Rechnerunterst"utzung} \quad \newline \label{rechner}


Um von einem Zufallsgenerator erzeugte Zufallszahlen auf die Gleichverteilung hin zu pr"ufen, wurde im Rahmen dieser
Arbeit ein Programm entwickelt, das Unterst"utzung bei der Durchf"uhrung der in diesem Abschnitt vorgestellten Tests
bietet. Es ist auf der beiliegenden CD zu finden (siehe Anh"ange~\ref{anhangcd} und~\ref{anhangsitzung}.2).
An dieser Stelle soll aber nicht auf die
technischen Details eingegangen werden, sondern das Programm soll anhand eines Beispiels vorgestellt werden.

In Tabelle ~\ref{statistikbeispiel} sind 10 Zahlen angegeben, die von einem Zufallsgenerator erzeugt wurden, der
4-Bit-Zahlen ausgibt\footnote{Die Zahlen wurden mit dem RC4-Generator (vgl. Kap.~\ref{rc4vorstellung})
unter Benutzung des Standardschl"ussels erzeugt.}.

Das Testprogramm untersucht zun"achst die bitweise Wahrscheinlichkeit. Es liefert folgende Ausgabe, wenn es auf
die Beispielzahlen aus Tabelle~\ref{statistikbeispiel} angewandt wird:

\begin{Verbatim}[commandchars=\\\{\}, fontsize=\small]

Anzahl | theoretische | H\"aufigkeit | Differenz |   approx.  |    Abweichung
Einsen |  H\"aufigkeit  |            |           | Normalvert.| H\"auf.-Normalvert.
-------|--------------|------------|-----------|------------|------------------
   0   |        0.625 |        0   |     0.625 |      0.094 |   -0.094
   1   |        2.500 |        2   |     0.500 |      1.780 |    0.220
   2   |        3.750 |        5   |    -1.250 |      5.357 |   -0.357
   3   |        2.500 |        3   |    -0.500 |      2.570 |    0.430
   4   |        0.625 |        0   |     0.625 |      0.196 |   -0.196
-------|--------------|------------|-----------|------------|------------------
 SUMME |       10.000 |       10   |     0.000 |      9.997 |    0.003

Chi-Quadrat-Test:
Chi^2 =   1.867 mit n=5 Freiheitsgraden

Theoretische Verteilung:
Erwartungswert     = 2.0000
Standardabweichung = 1.0000

Approximierte Normalverteilung (d.h. tats\"achliche Verteilung):
Stichprobenmittel              = 2.1000 +/- 0.7679 Einsen
Stichproben-Standardabweichung = 0.7379 Einsen
\end{Verbatim}

Diese Ausgabe ist wie folgt zu interpretieren: Die Zeilen der Tabelle spiegeln die Anzahlen der Einsen wider, die 
in den Zufallszahlen auftreten k"onnen. In diesem Fall gibt es 5 Zeilen, weil in jeder 4 Bit langen Zufallszahlen
0 bis 4 Einsen  vorhanden sein k"onnen.

In der ersten Spalte ist die Anzahl der Einsen angegeben, auf die sich die jeweilige Zeile bezieht. Die Spalte~2
gibt die theoretischen H"aufigkeiten an. Sie sind, wie oben dargelegt, binomialverteilt (siehe Formel~\ref{formelbino}).
In der folgenden 3.~Spalte sind die Einsen pro Zufallszahl gez"ahlt. Die Anzahlen k"onnen mithilfe der
Tabelle~\ref{statistikbeispiel} nachvollzogen werden. Spalte 4 zeigt die Differenzen zwischen der vorliegenden und der
hypothetischen Verteilung.

Mit den Daten aus den Spalten 2 bis 4 wird der Wert von $\chi^{2}$ nach Formel~\ref{formelchiquadrat} berechnet. Aus
einer Tabelle f"ur die Chi-Quadrat-Quantile (beispielsweise~\cite[S.~197]{huebner}) muss der Vergleichswert $c_{\alpha}$
ausgelesen werden (vgl. Kapitel~\ref{statistikgrundlagen}); beispielsweise $c_{0,95}=15,09$ f"ur $n=5$ Freiheitsgrade.

Aus den gez"ahlten Anzahlen wird, wie oben beschrieben, eine Normalverteilung an die vorliegende Verteilung gelegt.
Das Stichprobenmittel nach Formel~\ref{formelstichprobenmittel} und die Stichprobenstandardabweichung nach
Formel~\ref{formelstichprobenstandardabweichung} werden ausgegeben, und in der Tabellenspalte 5 werden die aus der
gesch"atzten Normalverteilung resultierenden Anzahlen angegeben. Spalte 6 zeigt zus"atzlich die Differenz zwischen
der tats"achlichen Verteilung und der berechneten Normalverteilung. Zum Vergleich der theoretischen und der
Normalverteilung werden die Standardabweichung und der Erwartungswert der theoretischen Verteilung berechnet (nach den
Formeln~\ref{formelerw} und~\ref{formelstdabw}).

\vspace{5mm}

Das Testprogramm pr"uft auch die blockweisen Wahrscheinlichkeiten, das hei"st es testet, wie oft welche Zufallszahl
erzeugt wird. Die Ausgabe sieht wie folgt aus (falls die Tabelle zu lang wird, gibt das Programm sie nicht aus, sondern
nur das Ergebnis des Chi-Quadrat-Tests):
\begin{Verbatim}[commandchars=\\\{\}, fontsize=\small]
       Bitkombination | theoret. H\"auf. |   H\"aufigkeit  |   Differenz
      ----------------|----------------|---------------|---------------
                 0000 |          0.625 |             0 |          0.625
                 0001 |          0.625 |             0 |          0.625
                 0010 |          0.625 |             0 |          0.625
                 0011 |          0.625 |             2 |         -1.375
                 0100 |          0.625 |             1 |         -0.375
                 0101 |          0.625 |             2 |         -1.375
                 0110 |          0.625 |             0 |          0.625
       Bitkombination | theoret. H\"auf. |   H\"aufigkeit  |   Differenz
      ----------------|----------------|---------------|---------------
                 0111 |          0.625 |             2 |         -1.375
                 1000 |          0.625 |             1 |         -0.375
                 1001 |          0.625 |             0 |          0.625
                 1010 |          0.625 |             0 |          0.625
                 1011 |          0.625 |             1 |         -0.375
                 1100 |          0.625 |             1 |         -0.375
                 1101 |          0.625 |             0 |          0.625
                 1110 |          0.625 |             0 |          0.625
                 1111 |          0.625 |             0 |          0.625
      ----------------|----------------|---------------|---------------
            SUMME     |         10     |            10 |          0
       
      Chi-Quadrat-Test:
      Chi^2 =  15.600 mit n=16 Freiheitsgraden 
\end{Verbatim}
In der ersten Tabellenspalte sind alle theoretisch m"oglichen Zufallszahlen angegeben, die $4$ Bit lang sind. In der
folgenden Spalte sind die H"aufigkeiten der Gleichverteilung angegeben, denen die erzeugten Zufallszahlen im Idealfall
gen"ugen. Die dritte Spalte zeigt das Ergebnis des Ausz"ahlens der Zahlen. Das Ergebnis kann einfach mithilfe von
Tabelle~\ref{statistikbeispiel} verifiziert werden. Die letzte Tabellenspalte gibt die Abweichungen zwischen theoretischer
und vorliegender H"aufigkeit an.

Das Ergebnis des Chi-Quadrat-Tests (siehe obiger Abschnitt ,,Pr"ufen der blockweisen Wahrscheinlichkeit``) ist unter
der Tabelle angegeben.


% ***** Test auf Unabhängigkeit *****
\subsection{Test auf Unabh"angigkeit \hspace{2.7cm}} \label{testunabhaengigkeit}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{5.2cm}(von Stefan Witt)}}

Die vom Zufallsgenerator erzeugten Zahlen m"ussen auf Unabh"angigkeit gepr"uft werden. Das bedeutet, dass getestet werden
muss, ob sie hinreichend zuf"allig sind. Leider gibt es kein eindeutiges, quantifizierbares Merkmal einer zuf"alligen
Zahlenfolge (nach \cite[S.~29]{dissertation}), so dass mehrere Tests notwendig sind, um die Unabh"angigkeitseigenschaft
zu pr"ufen.

Die zu testende Hypothese ist beim Test auf Unabh"angigkeit:
\begin{displaymath}
\mathcal{H}_{0}: \quad U_{i} \textrm{ unabh"angig von } U_{j} \quad \forall i \geq j,
\end{displaymath}
das hei"st aufeinander folgende Zahlen sind voneinander unabh"angig.

Zum Testen auf Unabh"angigkeit gibt es eine Vielzahl von Testverfahren, beispielsweise den Iterationstest, den
L"uckentest oder den Pokertest, um nur einige zu nennen. Eine detaillierte Vorstellung der Verfahren ist in
\cite[S.~32ff.]{dissertation} zu finden. Es gibt ein fertiges Programmpaket namens {\tt DIE HARD}
\footnote{zu finden unter {\tt http://stat.fsu.edu/\~{}geo/diehard.html}}, das 15 Testverfahren auf eine Datei mit
erzeugten Zufallszahlen anwendet.

Statt viele Verfahren anzuwenden, ist es auch m"oglich, den universellen statistischen Test aus \cite{maurer} zu
verwenden. Dieser Test misst die Entropie der erzeugten Zufallsbits und vergleicht sie mit einem Referenzwert.
Universal ist er deshalb, weil sich laut \cite{maurer} alle Tests auf den Universaltest zur"uckf"uhren lassen.
Schneier stellt in \cite[S.~483]{schneier} fest, dass sich aus dem universellen Test ergibt, dass eine Zufallsfolge, die
komprimierbar ist, nicht wirklich zuf"allig ist.

Der universelle Test kann also durch eine Kompression ersetzt werden: Wenn die erzeugten Zufallszahlen
sich nicht durch die Verwendung redundanzreduzierender Codes, beispielsweise dem Huffman-Code, komprimieren lassen,
dann sind sie unabh"angig.

Zum Testen der Zufallszahlen kann also ein g"angiges Kompressionsprogramm, zum Beispiel \texttt{gzip} oder
\texttt{zip} verwendet werden. Dieses Testverfahren ist allerdings nur zum groben Einsch"atzen der Unabh"angigkeit
der Zufallszahlen geeignet, weil die Packprogramme keine Abh"angigkeiten pr"ufen, die sich ergeben, wenn die Reihenfolge
der zuf"alligen Bitfolge ge"andert wird.



% ************************************************************************
% *****  Kapitel 5 (Vorstellung und Analyse der Zufallsgeneratoren)  *****
% ************************************************************************

\newpage
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Kapitel falsch im Inhaltsverzeichnis erscheint.
\section{Vorstellung und Analyse ausgew"ahlter Zufallsgeneratoren} \label{zzg}


% ************************************************ LFSR **********************************************

\subsection{LFSR \hspace{3.3cm}} \label{lfsrvorstellung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.4cm}(von Peter Hartmann)}}

Ein {\it r"uckgekoppeltes Schieberegister} (siehe \cite[S.~429ff.]{schneier}) setzt sich aus zwei Teilen zusammen, einem 
Schieberegister und einer R"uckkopplungsfunktion. Das Schieberegister besteht aus linear geordeneten Flipflops.
Die {\it L"ange} eines Schieberegisters wird in Bit angegeben und bezeichnet die Anzahl der Register, bei 
einer L"ange von $n$ Bit spricht man von einem $n$-Bit-Schieberegister.

Wenn ein Bit in der Zufallszahlensequenz ben"otigt wird, dann werden die in den Flipflops gespeicherten Bits 
nach links in das benachbarte Flipflop geschoben, das hei"st der Inhalt des Flipflops $b_{i}$ wird durch den 
Wert des Flipflops $b_{i-1}$ ersetzt. Das Bit $b_{1}$ wird in Abh"angigkeit der anderen Bits in den 
Flipflops durch die R"uckkopplungsfunktion berechnet. Als Ausgabe wird meist das niederwertigste Bit benutzt. 
Die einfachste Version eines Schieberegisters ist das linear r"uckgekoppelte Schieberegister, kurz LFSR (,,Linear 
Feedback Shift Register``, siehe Abb.~\ref{schieberegister}).

\begin{floatingfigure}[l]{15cm}
\hspace{3cm}
\includegraphics{abbildungen/schieberegister.eps}
\hspace{3cm}
{\it \caption[lfsrvorstellung]{\label{schieberegister}Schieberegister mit linearer R"uckkopplung}}
\end{floatingfigure}
~\vspace{7.5cm}

Hier ist die R"uckkopplungsfunktion durch eine XOR-Verkn"upfung bestimmter Bits des Registers gegeben. Die 
Liste dieser Bits hei"st {\it Tap Sequence} oder {\it Fibonacci-Konfiguration}. Ein $4$-Bit-Schieberegister mit der 
Tap Sequence $1001$, das hei"st es werden die Bits $b_{4}$ und $b_{1}$ f"ur die R"uckkopplungsfunktion 
XOR-verkn"upft, mit der Initialisierung $1111$ durchl"auft dann folgende Zust"ande:
$1111$, $1110$, $1101$, $1010$, $0101$, $1011$, $0110$, $1100$, $1001$, $0010$, $0100$, $1000$, $0001$, 
$0011$ und $0111$.
Danach wiederholen sich die Zust"ande, weil der n"achste Zustand wieder den Anfangszustand ergibt. Die 
Zufallszahlensequenz, bestehend aus den niederwertigsten Bits, lautet f"ur dieses Beispiel:
$1 0 1 0 1 1 0 0 1 0 0 0 1 1 1 \dots$ .

Ein LFSR mit $n$ Bits kann $2^{n}$ Zust"ande annehmen. Der Zustand, der aus lauter Nullen besteht, ist hier 
nicht brauchbar, da ein LFSR mit Nullen in den Flipflops als einzigen Wert die Null in der Ausgabesequenz 
liefert. Die maximal erreichbare Periode ist also $2^{n}-1$. Um diese zu erreichen, muss das Polynom, welches 
die Tap Sequence plus der Konstanten $1$ beschreibt, ein primitives und irreduzibles Polynom modulo $2$ sein.

Primitiv ist in multiplikativen Gruppen endlicher K"orper eine andere Bezeichnung f"ur ein erzeugendes Element. 
Das hei"st ein solches Polynom erzeugt in seinen Potenzen s"amtliche Elemente der Gruppe. Zus"atzlich ist jede 
multiplikative Gruppe eines endlichen K"orpers zyklisch (siehe \cite[S.~350ff.]{biggs}).

Irreduzibel bedeutet, das Polynom l"asst sich nicht faktorisieren. Faktorisieren bedeutet, dass das Polynom eine 
Nullstelle $ x_{1}$ besitzt und das Polynom sich nach einer Folgerung aus dem Fundamentalsatz der Algebra 
(siehe \cite[S.~107]{bartsch}) von $a_{n}x^{n} + a_{n-1}x^{n-1} + a_{n-2}x^{n-2} + a_{n-3}x^{n-3} + \dots + 
a_{1}x +$ $a_{0}$ in $(x - x_{1})\cdot(a_{n}x^{n-1} + (a_{n}x_{1}+a_{n-1})x^{n-2} + (a_{n}x_{1}^{2}+$ 
$a_{n-1}x_{1}+a_{n-2})x^{n-3} + \dots + (a_{n}x_{1}^{n-2}+a_{n-1}x_{1}^{n-
3}+\dots+a_{3}x_{1}+a_{2})x +$ $(a_{n}x_{1}^{n-1}+a_{n-1}x_{1}^{n-2}+\dots+a_{2}x_{1}+a_{1}))$ 
umformen l"asst.

Der Grad des Polynoms entspricht der L"ange des Schieberegisters. Das Beispiel mit der Tap Sequence $1001$ 
steht f"ur das Polynom $x^{4}+x+1$. F"ur die Bestimmung primitiver Polynome gibt es keine allgemeine 
einfache M"oglichkeit. Weitere Einzelheiten dazu finden sich in \cite{rabin68}. Schwach besetzte Polynome 
stellen nach \cite[S.~433]{schneier} einen Nachteil dar, weil sie m"oglicherweise kryptographischen 
Anforderungen nicht gen"ugen.

Der Vorteil von LFSRs ist die einfache Implementation in Hard- und Software. Der Nachteil ist, dass ein LFSR 
mit unbekannter R"uckkopplung der L"ange $n$ mit dem effizienten {\it Berlekamp-Massey-Algorithmus} 
\cite{massey1} aus nur $2n$ Ausgabebits ermittelt werden kann. Nicht ins Gewicht f"allt dieser Nachteil, wenn
die Anzahl der Zufallszahlen, die der Zufallsgenerator jemals erzeugen soll, kleiner als $2n$ ist,
weil dann der Berlekamp-Massey-Algorithmus nicht anwendbar ist.

In diesem Zusammenhang wird f"ur Generatoren von Zufallssequenzen auf Basis von LFSRs ein wichtiges 
Komplexit"atsma"s angegeben. Die {\it lineare Komplexit"at} eines Generators ist definiert als die L"ange des 
k"urzesten LFSRs, das die Ausgabe des Generators simuliert. Jede von einem {\it endlichen Automaten} "uber 
einem {\it endlichen K"orper} erzeugte Folge hat nach \cite{massey2} endliche lineare Komplexit"at.

\paragraph{Untersuchung der erzeugten Zufallszahlen auf Gleichverteilung} \quad \newline

Im Folgenden werden die Zufallszahlen, die vom LFSR generiert werden, auf Gleichverteilung untersucht, dabei 
wird wie in Kapitel~\ref{testgleichverteilung} beschrieben vorgegangen. Zum Erzeugen der Zufallszahlen wird 
die in Kapitel~\ref{lfsr} vorgestelle Implementation des LFSR in der Programmiersprache C benutzt. Das 
Ergebnis der Untersuchungen ist in Tabelle~\ref{lfsrstatistik} zusammengefasst.

\begin{floatingtable}[l]{
\hspace{1.3cm}
{\scriptsize
\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r||r|r|}
\hline
Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok? & $\chi^{2}$ (Block) &
Ok?\\
\hline
 4 &        100 &  3,587 & $\surd$  &  2 & 1,000 &  2,070 $\pm$ 0,311 & 0,946 & $\surd$  &       18,720 & $\surd$\\
 4 &     10 000 &  9,011 & $\surd$  &  2 & 1,000 &  2,017 $\pm$ 0,033 & 0,957 & $\surd$  &       17,370 & $\surd$\\
 4 &  1 000 000 &  3,603 & $\surd$  &  2 & 1,000 &  2,000 $\pm$ 0,003 & 1,001 & $\surd$  &        9,134 & $\surd$\\
 4 & 10 000 000 &  3,931 & $\surd$  &  2 & 1,000 &  2,000 $\pm$ 0,001 & 0,995 & $\surd$  &        9,498 & $\surd$\\
 4 & 50 000 000 &  0,284 & $\surd$  &  2 & 1,000 &  2,000 $\pm$ 0,001 & 1,000 & $\surd$  &       10,539 & $\surd$\\
\hline
 8 &        100 & 12,649 & $\surd$  &  4 & 1,414 &  4,010 $\pm$ 0,471 & 1,432 & $\surd$  &      243,040 & $\surd$\\
 8 &     10 000 &  4,502 & $\surd$  &  4 & 1,414 &  4,010 $\pm$ 0,046 & 1,410 & $\surd$  &      234,880 & $\surd$\\
 8 &  1 000 000 &  9,513 & $\surd$  &  4 & 1,414 &  4,002 $\pm$ 0,005 & 1,416 & $\surd$  &      271,349 & $\surd$\\
 8 & 10 000 000 &  6,603 & $\surd$  &  4 & 1,414 &  4,001 $\pm$ 0,002 & 1,414 & $\surd$  &      206,951 & $\surd$\\
 8 & 50 000 000 &  7,550 & $\surd$  &  4 & 1,414 &  4,000 $\pm$ 0,001 & 1,414 & $\surd$  &      247,467 & $\surd$\\
\hline
12 &        100 &  5,571 & $\surd$  &  6 & 1,732 &  5,950 $\pm$ 0,570 & 1,731 & $\surd$  &    4 077,920 & $\surd$\\
12 &     10 000 & 16,652 & $\surd$  &  6 & 1,732 &  5,994 $\pm$ 0,057 & 1,732 & $\surd$  &    4 147,584 & $\surd$\\
12 &  1 000 000 &  9,509 & $\surd$  &  6 & 1,732 &  6,002 $\pm$ 0,006 & 1,732 & $\surd$  &    4 159,705 & $\surd$\\
12 & 10 000 000 &  6,504 & $\surd$  &  6 & 1,732 &  6,001 $\pm$ 0,002 & 1,732 & $\surd$  &    4 187,401 & $\surd$\\
12 & 50 000 000 &  6,730 & $\surd$  &  6 & 1,732 &  6,000 $\pm$ 0,001 & 1,732 & $\surd$  &    3 992,683 & $\surd$\\
\hline
16 &        100 &  9,627 & $\surd$  &  8 & 2,000 &  7,920 $\pm$ 0,634 & 1,926 & $\surd$  &   65 436,000 & $\surd$\\
16 &     10 000 & 13,173 & $\surd$  &  8 & 2,000 &  8,008 $\pm$ 0,066 & 2,012 & $\surd$  &   66 192,154 & $\surd$\\
16 &  1 000 000 & 14,033 & $\surd$  &  8 & 2,000 &  8,002 $\pm$ 0,007 & 2,001 & $\surd$  &   65 253,863 & $\surd$\\
16 & 10 000 000 & 10,671 & $\surd$  &  8 & 2,000 &  8,001 $\pm$ 0,002 & 2,000 & $\surd$  &   64 850,466 & $\surd$\\
16 & 50 000 000 & 14,716 & $\surd$  &  8 & 2,000 &  8,000 $\pm$ 0,001 & 2,000 & $\surd$  &   62 427,195 & $\surd$\\
\hline
20 &        100 &  5,403 & $\surd$  & 10 & 2,236 & 10,040 $\pm$ 0,706 & 2,146 & $\surd$  &1 048 576,000 & $\surd$\\
20 &     10 000 & 17,503 & $\surd$  & 10 & 2,236 & 10,003 $\pm$ 0,073 & 2,228 & $\surd$  &1 050 110,336 & $\surd$\\
20 &  1 000 000 & 19,623 & $\surd$  & 10 & 2,236 & 10,003 $\pm$ 0,007 & 2,235 & $\surd$  &1 046 281,384 & $\surd$\\
20 & 10 000 000 & 10,523 & $\surd$  & 10 & 2,236 & 10,000 $\pm$ 0,002 & 2,236 & $\surd$  &1 038 999,393 & $\surd$\\
20 & 50 000 000 &  7,972 & $\surd$  & 10 & 2,236 & 10,000 $\pm$ 0,001 & 2,236 & $\surd$  &  998 053,322 & $\surd$\\
\hline
\end{tabular}
}}
{\it \caption{\label{lfsrstatistik} Untersuchung von Zufallszahlen, die mit dem LFSR-Generator mit einem Schieberegister
der Bitbreite 30 erzeugt wurden. Als Polynom wurde $x^{30}+x^{6}+x^{4}+x^{1}+x^{0}$ benutzt, und der Startwert des
Registers war $(2AAA~AAAA)_{16}$. In den Tests wurden 4, 8, 12, 16 und 20 Bits aus dem Register ausgegeben. Es wurden
immer die h"ochstwertigsten Bits genommen, bei 4 Ausgabebits also die Bits 30, 29, 28 und 27. Das Schieberegister
wurde immer so oft geschoben wie Bits ausgegeben wurden, zum Beispiel wurde vor jedem Ausgeben von 20 Bit 20 mal
geschoben. Das Signifikanzniveau
der $\chi^{2}$-Quadrat-Verteilung wurde auf $\alpha = 0,95$ festgelegt; die Quantile der $\chi^{2}$-Verteilung
wurden \cite[S.~197]{huebner} entnommen.\\~}}
\end{floatingtable}

~
\vspace{13.8cm}

Vom Schieberegister wurden je 
nach Bitzahl entsprechend viele Flipflops genommen und jeweils vor der Ausgabe einer Zufallszahl ebenso oft 
geschoben. F"ur alle Ausgabel"angen 4, 8, 12, 16 und 20 Bit wurden jeweils 100, 10~000, 1~000~000, 
10~000~000 und 50~000~000 Zufallszahlen erzeugt (Tabellenspalten 1 und 2). Die erzeugten Zufallszahlen 
wurden den Statistiktests unterzogen, deren Ergebnisse in den Spalten der Tabelle~\ref{lfsrstatistik} angegeben 
sind. Der Chi-Quadrat-Test zur Untersuchung auf Gleichverteilung der bitweisen Wahrscheinlichkeit ist in den 
Spalten 3 und 4 gezeigt; dabei gibt Spalte 3 den Wert von $\chi^{2}$ an und Spalte 4, ob der Test mit dem 
berechneten Wert $\chi^{2}$ bestanden wurde ($\surd$ bedeutet ,,bestanden``).
Der Anpassungstest der bitweisen Wahrscheinlichkeit an eine Normalverteilung ist in den Spalten 5 
bis 9 zu finden. Angegeben sind dort der Erwartungswert $EN$ und die Standardabweichung $\sigma_{N}$ der 
theoretischen Binomialverteilung, das empirische Stichprobenmittel $\overline{X}$ und die empirische 
Stichprobenstandardabweichung $\sigma_{S}$ der Verteilung der Zufallszahlen sowie wieder eine Angabe, ob der 
Test bestanden worden ist. Das Ergebnis des Chi-Quadrat-Tests der blockweisen Wahrscheinlichkeiten auf 
Gleichverteilung ist in den Spalten 10 und 11 abgedruckt; Spalte 10 zeigt den Wert von $\chi^{2}$, und in Spalte~11
ist wiederum angegeben, ob der Test bestanden wurde.

S"amtliche vom LFSR f"ur den Test erzeugten Zufallszahlen bestehen die Statistiktests. Damit eignen sich diese 
Zufallszahlen mit Sicherheit f"ur Low-Security-Anwendungen, insbesondere auch f"ur einen Einsatz zur Erzeugung 
von Zufallszahlen innerhalb geschlossener Systeme ohne direkte Au"senwirkung des LFSRs, beispielsweise f"ur 
Initialisierungen anderer Generatoren oder zur Steuerung von Zufallsprozessen. F"ur einen Einsatz in Bereichen, 
in denen es um nichttriviale Werte geht, etwa der Absicherung von Geld- und Kreditkarten, ist von einem Einsatz eines 
LFSR abzusehen, da mit dem {\it Berlekamp-Massey-Algorithmus} \cite{massey1} aus nur $2n$ Ausgabebits ($n$ 
ist der Polynomgrad) der Generator vorhersagbar ist und damit ein etwaiger Kopierschutz von Geld- und 
Kreditkarten kein Hindernis mehr darstellt. Vor einem Einsatz von einem LFSR ist also genau zu "uberlegen, wie 
die sicherheitstechnischen Randbedingungen aussehen.

\paragraph{Untersuchung der erzeugten Zufallszahlen auf Unabh"angigkeit} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[b]{|r|r||r|r|r|c|}
\hline
Bitzahl & Anzahl & unkompr. [Byte] & \texttt{zip} [Byte] & \texttt{gzip} [Byte] & Ok?\\
\hline
 4 &        100 &          50 &          50 &          81 & $\surd$\\
 4 &     10 000 &       5 000 &       5 000 &       5 031 & $\surd$\\
 4 &  1 000 000 &     500 000 &     500 080 &     500 106 & $\surd$\\
 4 & 10 000 000 &   5 000 000 &   5 000 765 &   5 000 791 & $\surd$\\
 4 & 50 000 000 &  25 000 000 &  25 003 815 &  25 003 841 & $\surd$\\
\hline
 8 &        100 &         100 &         100 &         131 & $\surd$\\
 8 &     10 000 &      10 000 &      10 000 &      10 031 & $\surd$\\
 8 &  1 000 000 &   1 000 000 &   1 000 155 &   1 000 181 & $\surd$\\
 8 & 10 000 000 &  10 000 000 &  10 001 530 &  10 001 556 & $\surd$\\
 8 & 50 000 000 &  50 000 000 &  50 007 630 &  50 007 656 & $\surd$\\
\hline
12 &        100 &         150 &         150 &         181 & $\surd$\\
12 &     10 000 &      15 000 &      15 000 &      15 031 & $\surd$\\
12 &  1 000 000 &   1 500 000 &   1 500 230 &   1 500 256 & $\surd$\\
12 & 10 000 000 &  15 000 000 &  15 002 290 &  15 002 316 & $\surd$\\
12 & 50 000 000 &  75 000 000 &  75 012 070 &  75 012 096 & $\surd$ \\
\hline
16 &        100 &         200 &         200 &         231 & $\surd$ \\
16 &     10 000 &      20 000 &      20 000 &      20 031 & $\surd$ \\
16 &  1 000 000 &   2 000 000 &   2 000 310 &   2 000 336 & $\surd$ \\
16 & 10 000 000 &  20 000 000 &  20 003 055 &  20 003 081 & $\surd$ \\
16 & 50 000 000 & 100 000 000 & 100 015 917 & 100 015 943 & $\surd$ \\
\hline
20 &        100 &         250 &         250 &         281 & $\surd$ \\
20 &     10 000 &      25 000 &      25 000 &      25 031 & $\surd$ \\
20 &  1 000 000 &   2 500 000 &   2 500 385 &   2 500 411 & $\surd$ \\
20 & 10 000 000 &  25 000 000 &  25 003 815 &  25 003 841 & $\surd$ \\
20 & 50 000 000 & 125 000 000 & 125 019 695 & 125 019 721 & $\surd$ \\
\hline
\end{tabular}
}}}
{\it \caption{\label{lfsrpacken} Untersuchung der Kompressionsraten.}}
\end{floatingtable}

Die vom LFSR erzeugten Zufallszahlen werden nun auf ihre Unabh"angigkeit "uber\-pr"uft. Dazu wird versucht, wie 
in Kapitel~\ref{testunabhaengigkeit} beschrieben, sie mit den Packprogrammen \texttt{gzip} und \texttt{zip} zu 
komprimieren.

Es wurden dieselben Parameter des LFSR-Generators gew"ahlt wie zuvor bei der Untersuchung auf 
Gleichverteilung (siehe voriger Abschnitt), und es wurden wiederum jeweils 100, 10~000, 1~000~000, 
10~000~000 und 50~000~000 Zahlen der L"angen 4, 8, 12, 16 und 20 Bit erzeugt. Das Ergebnis der 
Untersuchung dieser Zahlen ist in Tabelle~\ref{lfsrpacken} dargestellt. Die Spalten 1 und 2 geben die eben 
genannte Bitl"ange der Zahlen sowie die Anzahl der Zufallszahlen an. In Spalte 3 ist die unkomprimierte Gr"o"se 
der Zufallszahlen angegeben, die in einer Datei abgespeichert wurden. Die\-se Gr"o"se berechnet aus 
$\frac{\mathrm{Bitzahl} \cdot \mathrm{Anzahl}}{8}$. In den Spalten 4 und 5 ist die Gr"o"se der mit \texttt{zip} 
bzw. \texttt{gzip} komprimierten Daten angegeben, das hei"st nicht die Gr"o"se der komprimierten Datei, sondern 
nur die der komprimierten Daten (ohne Overhead, der sich aus den Dateiformaten ergibt).

Bei der Betrachtung von Tabelle~\ref{lfsrpacken} f"allt auf, dass die Informationsmenge der komprimierten 
Zufallszahlen nie kleiner als die der unkomprimierten Zahlen ist. Das bedeutet, dass sich die vom LFSR 
erzeugten Zufallszahlen nicht komprimieren lassen. Also haben die Zufallszahlen den Test auf Unabh"angigkeit 
bestanden.

%\begin{floatingtable}[r]{
%{\centering
%{\scriptsize
%\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r|}
%\hline
%Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok?\\
%\hline
% 4 &        100 & 15,653 & $\times$ &  2 & 1,000 &  1,909 $\pm$ 0,363 & 1,098 & $\surd$ \\
% 4 &     10 000 &  9,624 & $\surd$  &  2 & 1,000 &  2,002 $\pm$ 0,032 & 0,983 & $\surd$ \\
% 4 &  1 000 000 &  0,620 & $\surd$  &  2 & 1,000 &  1,999 $\pm$ 0,003 & 1,000 & $\surd$ \\
% 4 & 10 000 000 &  2,954 & $\surd$  &  2 & 1,000 &  2,000 $\pm$ 0,001 & 1,000 & $\surd$ \\
% 4 & 50 000 000 &  5,021 & $\surd$  &  2 & 1,000 &  2,000 $\pm$ 0,001 & 1,000 & $\surd$ \\
%\hline
% 8 &        100 & 13,799 & $\surd$  &  4 & 1,414 &  4,020 $\pm$ 0,500 & 1,512 & $\surd$ \\
% 8 &     10 000 & 11,331 & $\surd$  &  4 & 1,414 &  4,022 $\pm$ 0,046 & 1,392 & $\surd$ \\
% 8 &  1 000 000 &  6,713 & $\surd$  &  4 & 1,414 &  3,999 $\pm$ 0,005 & 1,413 & $\surd$ \\
% 8 & 10 000 000 & 11,251 & $\surd$  &  4 & 1,414 &  4,000 $\pm$ 0,002 & 1,415 & $\surd$ \\
% 8 & 50 000 000 &  5,061 & $\surd$  &  4 & 1,414 &  4,000 $\pm$ 0,001 & 1,414 & $\surd$\\
%\hline
%12 &        100 &  6,663 & $\surd$  &  6 & 1,732 &  5,970 $\pm$ 0,542 & 1,638 & $\surd$ \\
%12 &     10 000 &  8,304 & $\surd$  &  6 & 1,732 &  6,004 $\pm$ 0,057 & 1,735 & $\surd$ \\
%12 &  1 000 000 & 10,643 & $\surd$  &  6 & 1,732 &  6,003 $\pm$ 0,006 & 1,733 & $\surd$ \\
%12 & 10 000 000 & 14,886 & $\surd$  &  6 & 1,732 &  6,000 $\pm$ 0,002 & 1,732 & $\surd$ \\
%12 & 50 000 000 &  4,421 & $\surd$  &  6 & 1,732 &  6,000 $\pm$ 0,001 & 1,732 & $\surd$ \\
%\hline
%16 &        100 &  7,653 & $\surd$  &  8 & 2,000 &  8,152 $\pm$ 0,692 & 2,092 & $\surd$ \\
%16 &     10 000 &  9,401 & $\surd$  &  8 & 2,000 &  8,020 $\pm$ 0,066 & 1,999 & $\surd$ \\
%16 &  1 000 000 & 21,513 & $\surd$  &  8 & 2,000 &  8,002 $\pm$ 0,007 & 1,999 & $\surd$ \\
%16 & 10 000 000 & 14,007 & $\surd$  &  8 & 2,000 &  8,000 $\pm$ 0,002 & 2,000 & $\surd$ \\
%16 & 50 000 000 & 15,805 & $\surd$  &  8 & 2,000 &  8,000 $\pm$ 0,001 & 2,000 & $\surd$ \\
%\hline
%20 &        100 & 14,615 & $\surd$  & 10 & 2,236 & 10,121 $\pm$ 0,740 & 2,237 & $\surd$ \\
%20 &     10 000 & 12,659 & $\surd$  & 10 & 2,236 &  9,983 $\pm$ 0,074 & 2,235 & $\surd$ \\
%20 &  1 000 000 & 21,259 & $\surd$  & 10 & 2,236 &  9,996 $\pm$ 0,007 & 2,236 & $\surd$ \\
%20 & 10 000 000 & 18,056 & $\surd$  & 10 & 2,236 &  9,999 $\pm$ 0,002 & 2,236 & $\surd$ \\
%20 & 50 000 000 &  6,351 & $\surd$  & 10 & 2,236 & 10,000 $\pm$ 0,001 & 2,236 & $\surd$ \\
%\hline
%\end{tabular}
%}}}
%{\it \caption{\label{lfsrkippbits} Untersuchung der kippenden Bits der erzeugten Zufallszahlen des LFSR-Generators.
%Die Parameter sind dieselben wie in Tabelle~\ref{lfsrstatistik}}}
%\end{floatingtable}
%
%~
%
%\vspace{1mm}

\newpage

% ********************************************* BBS ******************************************

\subsection{BBS \hspace{3.3cm}} \label{bbsvorstellung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.3cm}(von Peter Hartmann)}}

Einer der einfachsten und sichersten Zufallszahlengeneratoren ist der Blum-Blum-Shub-Generator, hier ab\-k"ur\-zend 
als {\it BBS-Generator} bezeichnet. Er wurde 1982 auf der Crypto 82 vorgestellt und 1986 in \cite{blum} 
ver"offentlicht und nach seinen Erfindern benannt, eine andere gebr"auchliche Bezeichnung ist {\it quadratischer 
Restegenerator}.

F"ur den Generator ben"otigt man zwei spezielle und verschiedene Primzahlen $p$ und $q$. Eine Primzahl $p$ ist 
dann von der gew"unschten Form, wenn $p = 2p_{1}+1$ und $p_{1} = p_{2}+1$ ungerade Primzahlen sind und $p_{2}$ prim ist
(insbesondere ergibt sich aus diesen Forderungen, dass $p$ und $q$ kongruent $3 \bmod 4$ sind).
Diese Bedingung erm"oglicht das Erreichen der maximalen Periode von $2p_{2}q_{2}$. F"ur den Modulus $n$ bei 
der Berechnung der Zufallszahlen wird dann das Produkt der beiden Zahlen $p$ und $q$ benutzt.
Weiterhin w"ahlt man eine Zahl $x$, bei der sich f"ur $x \bmod p$ bzw. $x \bmod q$ weder $0$, $1$ noch $p-1$ bzw. $q-
1$ ergibt. Diese Einschr"ankungen\footnote{http://www.contestcen.com/crypto001.htm} dienen ebenfalls einer 
langen Periode. Weitere Einzelheiten dazu sind in \cite[S. 376ff.]{blum} zu finden.

Der Startwert des Generators berechnet sich mit

\begin{displaymath}
x_{0} = x^{2} \bmod n.
\end{displaymath}

Jetzt kann man mit der fortgesetzten Berechnung der Rekurrenzgleichung

\begin{displaymath}
x_{i+1} = x^{2}_{i} \bmod n
\end{displaymath}

die Bits der Zufallszahlensequenz erzeugen, indem man das niederwertigste Bit der erzeugten $ x_{i} $ benutzt.

W"ahlen wir beispielsweise die Zahlen $23$ und $47$ f"ur $p$ und $q$ und f"ur $x$ die Zahl $42$, dann 
ergeben sich folgende Berechnungsschritte:

\begin{tabbing}
\quad $x_{0} = 42^{2} \bmod 1081 = 683$ \\
\quad $x_{1} = 683^{2} \bmod 1081 = 578$ \\
\quad $x_{2} = 578^{2} \bmod 1081 = 55$ \\
\quad $x_{3} = 55^{2} \bmod 1081 = 863$ \\

\hspace{0.9cm} \vdots

~\\

\hspace{-0.1cm}

\quad $x_{109} = 347^{2} \bmod 1081 = 418$ \\
\quad $x_{110} = 418^{2} \bmod 1081 = 683$ \\
\end{tabbing}

In diesem Beispiel wurde die maximale Periode von $2p_{2}q_{2} = 2\cdot5\cdot11 = 110$ erreicht. Die 
Zahlen $p = 23= 2\cdot11 + 1$, $p_{1} = 11 = 2\cdot5 + 1$, $p_{2} = 5$, $q = 47= 2\cdot23 + 1$, 
$q_{1} = 23 = 2\cdot11 + 1$, $q_{2} = 11$ sind hier alle ungerade Primzahlen, und $x = 42$ ist kongruent 
$19 \bmod 23$ bzw. $42 \bmod 47$. Die Zufallszahlensequenz, aus den niederwertigsten Bits bestehend, beginnt 
f"ur dieses Beispiel mit 1011 \dots .

In dieser Version hat der Generator die Eigenschaft, dass die Bits der Sequenz weder nach links noch nach rechts 
vorhersagbar sind. Diese Eigenschaft verliert man, wenn man mehr als ein Bit der $x_{i}$ f"ur die 
Zufallszahlensequenz benutzen m"ochte. Um die Eigenschaft der Nichtvorhersagbarkeit der zu generierenden Bits 
zu behalten, gilt nach \cite{vazirani} als Grenze der m"oglichen zu benutzenden Bits $\log_{2}m$, dabei ist $m$ 
die Bitl"ange der $ x_{i}$.

Eine weitere vorteilhafte Eigenschaft des Generators ist, dass man das $i$-te Bit berechnen kann, ohne die 
vorherigen $i - 1$ Bits berechnen zu m"ussen. Das bedeutet, dass man wahlfreien Zugriff auf die einzelnen Bits 
der Zufallszahlensequenz hat. Daf"ur m"ussen aber die Werte f"ur $p$ und $q$ bekannt sein. Die Berechnung 
erfolgt dann mit

\begin{displaymath}
x_{i} = x^{2^{i}\bmod ((p-1)(q-1))}_{0}.
\end{displaymath}

Die Sicherheit des Verfahrens liegt in der Schwierigkeit der Faktorisierung von $n$. Ist das Primzahlprodukt gro"s 
genug, so ist die Zufallszahlensequenz nicht vorhersagbar, auch wenn $n$ ver"offentlicht wird. So kann jeder, der 
$n$ kennt, mit dem Generator Zufallszahlen erzeugen und muss nur den Startwert $x$ geheimhalten. Nachteilig an 
dem Verfahren ist die Ineffizienz des BBS-Generators, denn das Quadrieren der gro"sen Zahlen bei der Erzeugung
des n"achsten Zufallsbits ist aufw"andig.



\paragraph{Untersuchung der erzeugten Zufallszahlen auf Gleichverteilung} \quad \newline

In der Tabelle~\ref{bbsstatistik} sind die Ergebnisse der Untersuchung der vom BBS-Generator erzeugten Zufallszahlen 
auf Gleichverteilung dargestellt.  Bei der Untersuchung wurde wie in Kapitel~\ref{testgleichverteilung} beschrieben 
vorgegangen. Zum Erzeugen der Zufallszahlen wird die in Kapitel~\ref{bbs} vorgestelle Implementation von BBS in der 
Programmiersprache C benutzt. Der Generator erzeugt jeweils pro Quadrierung eine neue Zahl, von dieser wurden die 
niederwertigsten Bits entsprechend der Bitzahl entnommen, also wie in Spalte 1 angegeben 1, 2, 4, 8, 12, 16 und 20 Bit.
F"ur alle Ausgabel"angen wurden jeweils 100, 10~000 und 1~000~000 Zufallszahlen erzeugt 
(Tabellenspalten 1 und 2). Die erzeugten Zufallszahlen wurden den Statistiktests unterzogen, deren Ergebnisse in den 
Spalten der Tabelle~\ref{bbsstatistik} angegeben sind. Der Chi-Quadrat-Test zur Untersuchung auf Gleichverteilung der
bitweisen Wahrscheinlichkeit ist in den Spalten 3 und 4 gezeigt; dabei gibt Spalte 3 den Wert von $\chi^{2}$ an und
Spalte 4, ob der Test mit dem berechneten Wert $\chi^{2}$ bestanden wurde ($\surd$ bedeutet ,,bestanden``, $\times$
bedeutet ,,nicht bestanden``). Der Anpassungstest der bitweisen Wahrscheinlichkeit an eine Normalverteilung
ist in den Spalten 5 bis 9 zu finden. Angegeben sind dort der Erwartungswert $EN$ und die Standardabweichung $\sigma_{N}$
der theoretischen Binomialverteilung, das empirische Stichprobenmittel $\overline{X}$ und die empirische
Stichprobenstandardabweichung $\sigma_{S}$ der Verteilung der Zufallszahlen sowie wieder eine Angabe, ob der Test
bestanden worden ist. Das Ergebnis des Chi-Quadrat-Tests der blockweisen Wahrscheinlichkeiten auf Gleichverteilung
ist in den Spalten 10 und 11 abgedruckt; Spalte 10 zeigt den Wert von $\chi^{2}$, und in Spalte 11 ist wiederum angegeben,
ob der Test bestanden wurde.

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r||r|r|}
\hline
Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok? & $\chi^{2}$ (Block) &
Ok?\\
\hline
 1 &        100 &     3,115 & $\surd$  &  0,5 & 0,500 & 0,414 $\pm$ 0,495 & 0,495 & $\surd$  &        3,115 & $\surd$\\
 1 &     10 000 &     2,822 & $\surd$  &  0,5 & 0,500 & 0,492 $\pm$ 0,500 & 0,500 & $\surd$  &        2,822 & $\surd$\\
 1 &  1 000 000 &     0,264 & $\surd$  &  0,5 & 0,500 & 0,500 $\pm$ 0,500 & 0,500 & $\surd$  &        0,264 & $\surd$\\
\hline
 2 &        100 &     1,440 & $\surd$  &  1,0 & 0,707 & 0,920 $\pm$ 0,720 & 0,720 & $\surd$  &        2,160 & $\surd$\\
 2 &     10 000 &     1,109 & $\surd$  &  1,0 & 0,707 & 0,995 $\pm$ 0,710 & 0,710 & $\surd$  &        3,754 & $\surd$\\
 2 &  1 000 000 &     1,040 & $\surd$  &  1,0 & 0,707 & 0,999 $\pm$ 0,707 & 0,707 & $\surd$  &        1,087 & $\surd$\\
\hline
 4 &        100 &     5,000 & $\surd$  &  2,0 & 1,000 & 1,870 $\pm$ 0,981 & 0,981 & $\surd$  &       14,240 & $\surd$\\
 4 &     10 000 &     4,926 & $\surd$  &  2,0 & 1,000 & 1,983 $\pm$ 0,999 & 0,999 & $\surd$  &       17,245 & $\surd$\\
 4 &  1 000 000 &     2,017 & $\surd$  &  2,0 & 1,000 & 1,999 $\pm$ 1,000 & 1,000 & $\surd$  &        5,032 & $\surd$\\
\hline
 8 &        100 &    28,695 & $\times$ &  4,0 & 1,141 & 3,800 $\pm$ 1,706 & 1,706 & $\surd$  &      273,760 & $\surd$\\
 8 &     10 000 &     7,120 & $\surd$  &  4,0 & 1,141 & 3,991 $\pm$ 1,428 & 1,428 & $\surd$  &      298,061 & $\surd$\\
 8 &  1 000 000 &     3,109 & $\surd$  &  4,0 & 1,141 & 3,998 $\pm$ 1,414 & 1,414 & $\surd$  &      173,423 & $\surd$\\
\hline
12 &        100 &   196,466 & $\times$ &  6,0 & 1,732 & 5,600 $\pm$ 2,123 & 2,123 & $\surd$  &    4 077,920 & $\surd$\\
12 &     10 000 &     8,355 & $\surd$  &  6,0 & 1,732 & 5,981 $\pm$ 1,747 & 1,747 & $\surd$  &    4 059,738 & $\surd$\\
12 &  1 000 000 &     4,504 & $\surd$  &  6,0 & 1,732 & 5,999 $\pm$ 1,733 & 1,733 & $\surd$  &    2 401,530 & $\surd$\\
\hline
16 &        100 &   828,881 & $\times$ &  8,0 & 2,000 & 7,680 $\pm$ 2,449 & 2,449 & $\surd$  &   65 436,000 & $\surd$\\
16 &     10 000 &    14,047 & $\surd$  &  8,0 & 2,000 & 7,987 $\pm$ 2,014 & 2,014 & $\surd$  &   65 720,294 & $\surd$\\
16 &  1 000 000 &    38,504 & $\times$ &  8,0 & 2,000 & 7,998 $\pm$ 2,000 & 2,000 & $\surd$  &   65 213,493 & $\surd$\\
\hline
20 &        100 & 4 741,185 & $\times$ & 10,0 & 2,236 & 9,630 $\pm$ 2,834 & 2,834 & $\surd$  &1 048 476,000 & $\surd$\\
20 &     10 000 &    49,923 & $\times$ & 10,0 & 2,236 & 9,992 $\pm$ 2,249 & 2,249 & $\surd$  &1 047 803,469 & $\surd$\\
20 &  1 000 000 &    64,489 & $\times$ & 10,0 & 2,236 & 9,991 $\pm$ 2,259 & 2,259 & $\surd$  &  996 180,423 & $\surd$\\
\hline
\end{tabular}
}}}
{\it \caption{\label{bbsstatistik} Untersuchung von Zufallszahlen, die mit dem BBS-Generator erzeugt wurden.
Als Parameter wurden $n=4 079 \cdot 4 127 = 16~834~033$ und $x=2$ gew"ahlt; daraus ergibt sich eine Periode von
$2~101~178$. Ausgegeben wurden jeweils die niedrigsten 1, 2, 4, 8, 12, 16 bzw. 20 Bits. Das Signifikanzniveau
der $\chi^{2}$-Quadrat-Verteilung wurde auf $\alpha = 0,95$ festgelegt; die Quantile der $\chi^{2}$-Verteilung
wurden \cite[S.~197]{huebner} entnommen.}}
\end{floatingtable}

~

\vspace{12cm}

~\\In Tabelle~\ref{bbsstatistik} f"allt auf, dass der BBS-Generator den Test auf die blockweise Gleichverteilung und den
Anpassungstest der bitweisen Wahrscheinlichkeiten an die Normalverteilung besteht, aber den Chi-Quadrat-Test der bitweisen 
Gleichverteilung bei den Bitzahlen gr"o"ser als 4 nicht.  Das hat zwei Gr"unde: Es werden pro erzeugtem quadratischen
Rest zu viele Bits ausgegeben, und bei der Erzeugung von nur 100 Zufallszahlen tritt nicht jedes m"ogliche Versuchsergebnis 5 mal 
auf. Erst wenn alle Ergebnisse 5 mal vorkommen, ist der Chi-Quadrat-Test anwendbar und liefert brauchbare Ergebnisse. Der Modulus 
betr"agt in diesem Beispiel 16~834~033, der gr"o"ste quadratische Rest, der auftreten kann, ist also kleiner als 16~834~033. In 
dualer Darstellung sind h"ochstens $\lceil \log_{2}(16~834~032) \rceil = 25$ Bit erforderlich. Um die Sicherheit des Generators 
nicht zu gef"ahrden, d"urfen von den quadratischen Resten nicht mehr als $\log_{2}m$ ausgegeben werden, in diesem Beispiel also 
nicht mehr als $\lfloor \log_{2}25 \rfloor = 4$ Bit ausgegeben werden. Weiterhin sind die quadratischen Reste "uber das gesamte 
Intervall von 2 bis 16~834~033 verteilt, und somit sind die 4 Bit auch nicht in allen F"allen nutzbar, tats"achlich liegt die 
durchschnittliche nutzbare Anzahl der Bits unter diesem Wert. Insofern sind die Ergebnisse vom Chi-Quadrat-Test f"ur gr"o"sere 
Bitzahlen kein unerwartetes Ergebnis. Es zeigt deutlich die Grenzen der nutzbaren Bits, und es ist offensichtlich, dass man f"ur 
gr"o"sere Bitzahlen, entweder die Bits von aufeinanderfolgenden Zufallszahlen zusammensetzen oder eben einen deutlich gr"o"seren 
Modulus w"ahlen muss. Eine weitere Schwierigkeit ist die jeweilige Ermittlung der Anzahl der nutzbaren Bits, die ja von der Gr"o"se
der verschiedenen quadratischen Reste abh"angt. Da hier die Implementierung auf Chipkarten im Vordergrund steht, werden diese Aspekte, 
die mit weiteren Aufwand verbunden sind, nicht weiter verfolgt. 

%~
%
%\vspace{12cm}
%
%
%\begin{floatingtable}[r]{
%{\centering
%{\scriptsize
%\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r|}
%\hline
%Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok?\\
%\hline
% 1 &        100 &   1,175 & $\surd$  &  0,5 & 0,500 &  0,447 $\pm$ 0,162 & 0,500 & $\surd$\\
% 1 &     10 000 &   0,221 & $\surd$  &  0,5 & 0,500 &  0,502 $\pm$ 0,017 & 0,500 & $\surd$\\
% 1 &  1 000 000 &   0,129 & $\surd$  &  0,5 & 0,500 &  0,500 $\pm$ 0,002 & 0,500 & $\surd$\\
%\hline
% 2 &        100 &   2,434 & $\surd$  &  1,0 & 0,707 &  0,939 $\pm$ 0,249 & 0,754 & $\surd$\\
% 2 &     10 000 &   0,591 & $\surd$  &  1,0 & 0,707 &  1,004 $\pm$ 0,023 & 0,705 & $\surd$\\
% 2 &  1 000 000 &   2,532 & $\surd$  &  1,0 & 0,707 &  0,999 $\pm$ 0,002 & 0,708 & $\surd$\\
%\hline
% 4 &        100 &   5,108 & $\surd$  &  2,0 & 1,000 &  1,879 $\pm$ 0,358 & 1,081 & $\surd$\\
% 4 &     10 000 &   6,176 & $\surd$  &  2,0 & 1,000 &  2,004 $\pm$ 0,033 & 0,990 & $\surd$\\
% 4 &  1 000 000 &   0,830 & $\surd$  &  2,0 & 1,000 &  2,000 $\pm$ 0,003 & 1,000 & $\surd$\\
%\hline
% 8 &        100 &  31,207 & $\times$ &  4,0 & 1,141 &  3,788 $\pm$ 0,568 & 1,716 & $\surd$\\
% 8 &     10 000 &  11,953 & $\surd$  &  4,0 & 1,141 &  4,008 $\pm$ 0,047 & 1,425 & $\surd$\\
% 8 &  1 000 000 &   7,993 & $\surd$  &  4,0 & 1,141 &  4,000 $\pm$ 0,005 & 1,415 & $\surd$\\
%\hline
%12 &        100 &  26,126 & $\times$ &  6,0 & 1,732 &  5,859 $\pm$ 0,690 & 2,085 & $\surd$\\
%12 &     10 000 &  11,176 & $\surd$  &  6,0 & 1,732 &  6,010 $\pm$ 0,057 & 1,726 & $\surd$\\
%12 &  1 000 000 &   2,836 & $\surd$  &  6,0 & 1,732 &  6,001 $\pm$ 0,006 & 1,733 & $\surd$\\
%\hline
%16 &        100 &  57,537 & $\times$ &  8,0 & 2,000 &  7,970 $\pm$ 0,831 & 2,513 & $\surd$\\
%16 &     10 000 &  10,322 & $\surd$  &  8,0 & 2,000 &  8,004 $\pm$ 0,066 & 2,005 & $\surd$\\
%16 &  1 000 000 &  12,991 & $\times$ &  8,0 & 2,000 &  8,000 $\pm$ 0,007 & 2,000 & $\surd$\\
%\hline
%20 &        100 & 238,260 & $\times$ & 10,0 & 2,236 &  9,950 $\pm$ 0,892 & 2,697 & $\surd$\\
%20 &     10 000 &  16,473 & $\times$ & 10,0 & 2,236 & 10,018 $\pm$ 0,074 & 2,240 & $\surd$\\
%20 &  1 000 000 &  19,015 & $\times$ & 10,0 & 2,236 &  9,999 $\pm$ 0,007 & 2,237 & $\surd$\\
%\hline
%\end{tabular}
%}}}
%{\it \caption{\label{bbskippbits} Untersuchung der kippenden Bits der erzeugten Zufallszahlen.}}
%\end{floatingtable}
%
%~
%
%\vspace{1mm}
%
%~
%
%\newpage
\paragraph{Untersuchung der erzeugten Zufallszahlen auf Unabh"angigkeit} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[b]{|r|r||r|r|r|c|}
\hline
Bitzahl & Anzahl & unkompr. [Byte] & \texttt{zip} [Byte] & \texttt{gzip} [Byte] & Ok?\\
\hline
 1 &        100 &          13 &          13 &          40 & $\surd$\\
 1 &     10 000 &       1 250 &       1 250 &       1 280 & $\surd$\\
 1 &  1 000 000 &     125 000 &     125 020 &     125 045 & $\surd$\\
\hline
 2 &        100 &          25 &          25 &          53 & $\surd$\\
 2 &     10 000 &       2 500 &       2 500 &       2 530 & $\surd$\\
 2 &  1 000 000 &     250 000 &     250 040 &     250 065 & $\surd$\\
\hline
 4 &        100 &          50 &          50 &          80 & $\surd$\\
 4 &     10 000 &       5 000 &       5 000 &       5 030 & $\surd$\\
 4 &  1 000 000 &     500 000 &     500 080 &     500 105 & $\surd$\\
\hline
 8 &        100 &         100 &         100 &         130 & $\surd$\\
 8 &     10 000 &      10 000 &      10 000 &      10 030 & $\surd$\\
 8 &  1 000 000 &   1 000 000 &   1 000 155 &   1 000 180 & $\surd$\\
\hline
12 &        100 &         150 &         150 &         180 & $\surd$\\
12 &     10 000 &      15 000 &      15 000 &      15 030 & $\surd$\\
12 &  1 000 000 &   1 500 000 &   1 500 230 &   1 500 255 & $\surd$\\
\hline
16 &        100 &         200 &         200 &         230 & $\surd$\\
16 &     10 000 &      20 000 &      20 000 &      20 030 & $\surd$\\
16 &  1 000 000 &   2 000 000 &   2 000 310 &   2 000 335 & $\surd$\\
\hline
20 &        100 &         250 &         250 &         280 & $\surd$\\
20 &     10 000 &      25 000 &      25 000 &      25 030 & $\surd$\\
20 &  1 000 000 &   2 500 000 &   2 500 385 &   2 500 410 & $\surd$\\
\hline
\end{tabular}
}}}
{\it \caption{\label{bbspacken} Untersuchung der Kompressionsraten der von BBS erzeugten Zufallszahlen.}}
\end{floatingtable}

Die vom BBS-Generator erzeugten Zufallszahlen werden nun auf ihre Unabh"an\-gig\-keit gepr"uft. Dazu wird versucht, wie in
Kapitel~\ref{testunabhaengigkeit} beschrieben, sie mit den Packprogrammen \texttt{gzip} und \texttt{zip} zu
komprimieren.

Es wurden dieselben Parameter wie bei der Untersuchung des BBS-Generators auf Gleichverteilung ge\-w"ahlt (siehe
voriger Abschnitt), und es wurden wiederum jeweils 100, 10~000 und 1~000~000 Zahlen der
L"an\-gen 1, 2, 4, 8, 12, 16 und 20 Bit erzeugt. Das Ergebnis der Untersuchung dieser Zahlen ist in Tabelle~\ref{bbspacken}
dargestellt. Die Spalten 1 und 2 geben die eben genannte Bitl"ange der Zahlen sowie die Anzahl der Zufallszahlen an.
In Spalte 3 ist die unkomprimierte Gr"o"se der Zufallszahlen angegeben, die in einer Datei abgespeichert wurden. Die\-se
Gr"o"se berechnet aus $\frac{\mathrm{Bitzahl} \cdot \mathrm{Anzahl}}{8}$. In den Spalten 4 und 5 ist die Gr"o"se der
mit \texttt{zip} bzw. \texttt{gzip} komprimierten Daten angegeben, das hei"st nicht die Gr"o"se der komprimierten
Datei, sondern nur die der komprimierten Daten (ohne Overhead, der sich aus den Dateiformaten ergibt).

Bei der Betrachtung von Tabelle~\ref{bbspacken} f"allt auf, dass die Informationsmenge der komprimierten
Zufallszahlen nie kleiner als die der unkomprimierten Zahlen ist. Das bedeutet, dass sich die von BBS
erzeugten Zufallszahlen nicht komprimieren lassen. Also haben die Zufallszahlen den Test auf Unabh"angigkeit
bestanden.

\newpage

% ************************************************* RC4 **********************************************

\subsection{RC4 \hspace{2.7cm}} \label{rc4vorstellung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.3cm}(von Stefan Witt)}}

RC4 ist ein Zufallszahlengenerator, der von Ron Rivest\footnote{Ron Rivest ist neben Adi Shamir und Leonard Adleman
einer der Entwickler des RSA-Verschl"usselungsverfahrens.} entwickelt wurde\footnote{RC4 ist von RSA Data Security Inc.
patentiert, und die Benutzung in eigenen Programmen bedarf der Lizenzierung.}. Die Erzeugung von Zufallszahlen mit RC4
ist sehr effizient, und deshalb ist dieser Generator zur Stromchiffrierung (vgl. Abschnitt \ref{stromchiffrierung})
geeignet. RC4 steht f"ur ,,Ron's Code 4`` oder ,,Rivest's Cipher 4``, wobei die 4 andeutet, dass es noch weitere
Stromchiffrierungen von Ron Rivest gibt.

Im Folgenden wird die Darstellung aus \cite[S.~455f.]{schneier} auf eine variable
Ausgabel"ange verallgemeinert. Diese variable Ausgabel"ange $n$, mit der der Zufallsgenerator arbeitet, kann
beliebig gro"s sein. Sie gibt die Anzahl der Bits an, die der Zufallsgenerator bei der Ausf"uhrung parallel
ausgibt. "Ublich sind 8 oder 16 Bit, allerdings sind f"ur die Implementierung auf Chipkarten 4 Bit besser
geeignet, wie sp"ater gezeigt werden wird.

Alle Werte, die zur Berechnung einer Zufallszahl ben"otigt werden, sind aus der Gruppe $\mathcal{GF}(2^{n})$. Als
Rechenoperation der Gruppe wird die Addition benutzt.


\paragraph{Beschreibung des Verfahrens} \quad \newline

F"ur die Initialisierung von RC4 wird ein Schl"ussel ben"otigt. Dieser Schl"ussel besteht aus
$2^{n}$ Werten $K_{0}$, $K_{1}, \dots$, $K_{2^{n}-1}$, die Werte aus $\mathcal{GF}(2^{n})$ annehmen d"urfen.
Der Algorithmus benutzt zur Erzeugung eine Substitutions-Box (S-Box), die die $2^{n}$ Werte
$S_{0}, S_{1}, \dots, S_{2^{n}-1}$ enth"alt, die ebenfalls aus $\mathcal{GF}(2^{n})$ sind.
 Sie sei anfangs mit den Werten $S_{0}=0, S_{1}=1, \dots, S_{2^{n}-1}=2^{n}-1$ gef"ullt.
Zus"atzlich gebe es die Indizes $i$ und $j$.

Dann werden folgende Instruktionen ausgef"uhrt:

\vspace{0.5cm}

\begin{algorithmic}
\STATE $j \leftarrow 0$
\FOR{$i=0$ \textbf{to} $2^{n}-1$}
\STATE $j \leftarrow (j + S_{i} + K_{i}) \bmod 2^{n}$
\STATE \textbf{vertausche} $S_{i}$ und $S_{j}$
\ENDFOR
\STATE $i \leftarrow 0$
\STATE $j \leftarrow 0$
\end{algorithmic}

\vspace{0.5cm}

Durch diese Schleife werden die Elemente der S-Box $2^{n}$-mal permutiert. Jedes Element der S-Box ist
mindestens einmal an einer Permutation beteiligt, weil in der Vertauschoperation der Schleifenz"ahler $i$
als Index $S_{i}$ benutzt wird.

F"ur die Erzeugung der ersten Zufallszahl m"ussen die Indizes $i$ und $j$ mit $0$ initialisiert werden,
was in den letzten beiden Programmzeilen geschieht.

Um eine Zufallszahl der L"ange $n$ zu erzeugen, werden folgende Rechenoperationen durchgef"uhrt:

\vspace{0.5cm}

\begin{algorithmic}
\STATE $i \leftarrow (i + 1) \bmod 2^{n}$
\STATE $j \leftarrow (j + S_{i}) \bmod 2^{n}$
\STATE \textbf{vertausche} $S_{i}$ und $S_{j}$
\STATE $t \leftarrow (S_{i} + S_{j}) \bmod 2^{n}$
\STATE \textbf{gib aus} $S_{t}$
\end{algorithmic}

\vspace{0.5cm}

Die ersten 3 Operationen entsprechen der Permutation bei der Initialisierung, allerdings mit zwei Unterschieden:
Erstens wird der Schleifenz"ahler $i$ beim Erreichen von $2^{n}$ wieder auf $0$ gesetzt (Inkrement in
$\mathcal{GF}(2^{n})$). Zweitens wird der Schl"ussel $K_{i}$ nicht mehr ber"ucksichtigt.

Die letzten beiden Operationen w"ahlen mithilfe der Variablen $t$ einen Wert aus der S-Box aus und
geben diesen als Zufallszahl aus. Der ausgegebene Wert ist also $n$ Bit lang. Da die S-Box alle Werte $0$ bis
$2^{n-1}$ genau einmal enth"alt, sind alle $2^{n}$ Kombinationen aus $n$ Bit als Ausgabe m"oglich.


\paragraph{Parametrisierung des Verfahrens f"ur Chipkarten} \quad \newline

F"ur die Implementierung von RC4 auf Chipkarten muss die Ausgabel"ange $n$ sinnvoll festgelegt werden. Es muss
ein Kompromiss zwischen notwendigem Speicherbedarf und Sicherheit des Zufallsgenerators gefunden werden.

\begin{floatingtable}[r]{
{\centering
\begin{tabular}[b]{|c|r|r|}
\hline
\hspace{2mm} $n$ \hspace{2mm} & Speicherbedarf [Bit]& Anzahl Zust"ande\\
\hline
1 &  5 & 2 \\
2 & 14 & 384 \\
3 & 33 & 3 265 920 \\
4 & 76 & 5 356 234 211 328 000 \\
5 & 175 & $\approx 3 \cdot 10^{38}$ \\
6 & 402 & $\approx 5 \cdot 10^{92}$ \\
7 & 917 & $\approx 4 \cdot 10^{215}$ \\
8 & 2 072 & $\approx 1 \cdot 10^{512}$ \\
\hline
\end{tabular}
}}
{\it \caption{\label{rc4bedarf} Speicherbedarf und Anzahl der Zust"ande des RC4-Generators in Abh"angigkeit der
Ausgabebreite $n$ \vspace{3mm}}}
\end{floatingtable}

Der Speicherbedarf h"angt von der Gr"o"se der S-Box ab. Er ist $P = n \cdot (2^{n} + 3) \textrm{~Bit}$, denn es werden
$2^{n}$ Werte in der S-Box gespeichert, es wird Platz f"ur die Variablen $i$, $j$ und $t$ ben"otigt, und jeder
dieser Werte ist $n$ Bit lang. Die Sicherheit, also die Periode des Zufallsgenerators, h"angt nicht von der Wahl des
Schl"ussels ab, denn RC4 besitzt nach \cite[S.~456]{schneier} un\-ab\-h"an\-gig von der Wahl des Schl"us\-sels keine
kleinen Zyklen. Aus demselben Grund ist die Periode in der Gr"ossen\-ordnung der Anzahl der Zust"ande
des Zufallsgenerators. Der Generator kann genau $Z = 2^{n}! \cdot (n^{2})^{2}$ verschiedene Zust"ande annehmen, denn es
gibt $2^{n}!$ viele Permutationen der S-Box und jeweils $n^{2}$ Werte, die die Variablen $i$ und $j$ annehmen k"onnen.

In Tabelle~\ref{rc4bedarf} sind f"ur die Ausgabebreiten 1 bis 8 Bit Speicherbedarf und Anzahl der Zust"ande
angegeben. Zur Implementation auf Chipkarten ist eine Ausgabebreite von 4 Bit am sinnvollsten, weil nur 76 Bit
(9,5 Bytes) Speicherplatz ben"otigt werden, aber trotzdem eine sehr gro"se Periode gew"ahrleistet ist. Ein Test der
Periode ergab, dass sie mindestens 3 500 000 000 000 betr"agt\footnote{Um das festzustellen, rechnete ein 500~MHz-Rechner
50~Stunden lang; um alle Zust"ande des Generators zu durchlaufen, h"atte er etwa 88~000~Stunden rechnen m"ussen.}.

In der Praxis ist allerdings gefordert, dass die Zufallszahlen l"anger als 4 Bit sind. Um das zu erreichen, wird
der RC4-Generator mehrfach gestartet, und die 4-Bit-Zahlen, die er erzeugt, werden zu einer l"angeren Zufallszahl
zusammengesetzt. Am einfachsten ist es, Vielfache von 4 als Breite der zusammengesetzten Zufallszahl zu w"ahlen,
weil dann die Ausgabe sehr einfach umgesetzt werden kann.


\paragraph{Untersuchung der erzeugten Zufallszahlen auf Gleichverteilung} \quad \newline

Es sollen nun die Zufallszahlen, die vom RC4-Generator erzeugt werden, wie in Kapitel~\ref{testgleichverteilung}
beschrieben auf Gleichverteilung untersucht werden. Zum Erzeugen der Zufallszahlen wird die in
Kapitel~\ref{rc4} vorgestelle Implementation von RC4 in der Programmiersprache C benutzt.
Das Ergebnis der Untersuchungen ist in Tabelle~\ref{rc4statistik} (Seite~\pageref{rc4statistik}) zusammengefasst.
Der Generator erzeugt jeweils 4~Bit lange Zufallszahlen; l"angere Zufallszahlen (8, 12, 16 und 20 Bit) wurden durch
Aneinanderreihen mehrerer 4-Bit-Zahlen erzeugt. F"ur alle Ausgabel"angen 4, 8, 12, 16
und 20 Bit wurden jeweils 100, 10~000, 1~000~000, 10~000~000 und 50~000~000 Zufallszahlen erzeugt (Tabellenspalten 1
und 2).
Die erzeugten Zufallszahlen wurden den Statistiktests unterzogen, deren Ergebnisse in den Spalten der
Tabelle~\ref{rc4statistik} angegeben sind. Der Chi-Quadrat-Test zur Untersuchung auf Gleichverteilung der
bitweisen Wahrscheinlichkeit ist in den Spalten 3 und 4 gezeigt; dabei gibt Spalte 3 den Wert von $\chi^{2}$ an und
Spalte 4, ob der Test mit dem berechneten Wert $\chi^{2}$ bestanden wurde ($\surd$ bedeutet ,,bestanden``, $\times$
bedeutet ,,nicht bestanden``). Der Anpassungstest der bitweisen Wahrscheinlichkeit an eine Normalverteilung
ist in den Spalten 5 bis 9 zu finden. Angegeben sind dort der Erwartungswert $EN$ und die Standardabweichung $\sigma_{N}$
der theoretischen Binomialverteilung, das empirische Stichprobenmittel $\overline{X}$ und die empirische
Stichprobenstandardabweichung $\sigma_{S}$ der Verteilung der Zufallszahlen sowie wieder eine Angabe, ob der Test
bestanden worden ist. Das Ergebnis des Chi-Quadrat-Tests der blockweisen Wahrscheinlichkeiten auf Gleichverteilung
ist in den Spalten 10 und 11 abgedruckt; Spalte 10 zeigt den Wert von $\chi^{2}$, und in Spalte 11 ist wiederum angegeben,
ob der Test bestanden wurde.


\begin{floatingtable}[r]{
\hspace{0.5cm}
{\scriptsize
\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r||r|r|}
\hline
Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok? & $\chi^{2}$ (Block) & Ok?\\
\hline
 4 &        100 &    3,867 & $\surd$  &  2 & 1,000 &  1,920 $\pm$ 0,326 & 0,992 & $\surd$  &        7,520 & $\surd$\\
 4 &     10 000 &    2,079 & $\surd$  &  2 & 1,000 &  2,007 $\pm$ 0,033 & 0,999 & $\surd$  &       18,362 & $\surd$\\
 4 &  1 000 000 &    3,017 & $\surd$  &  2 & 1,000 &  2,001 $\pm$ 0,003 & 1,000 & $\surd$  &       15,678 & $\surd$\\
 4 & 10 000 000 &    3,272 & $\surd$  &  2 & 1,000 &  2,001 $\pm$ 0,001 & 1,000 & $\surd$  &       10,809 & $\surd$\\
 4 & 50 000 000 &    1,208 & $\surd$  &  2 & 1,000 &  2,000 $\pm$ 0,001 & 1,000 & $\surd$  &       15,950 & $\surd$\\
\hline
 8 &        100 &    1,723 & $\surd$  &  4 & 1,414 &  4,060 $\pm$ 0,477 & 1,448 & $\surd$  &      263,520 & $\surd$\\
 8 &     10 000 &    8,743 & $\surd$  &  4 & 1,414 &  4,010 $\pm$ 0,046 & 1,388 & $\surd$  &      276,608 & $\surd$\\
 8 &  1 000 000 &   30,047 & $\times$ &  4 & 1,414 &  4,003 $\pm$ 0,005 & 1,414 & $\surd$  &      267,371 & $\surd$\\
 8 & 10 000 000 &  239,157 & $\times$ &  4 & 1,414 &  4,001 $\pm$ 0,002 & 1,415 & $\surd$  &      698,327 & $\surd$\\
 8 & 50 000 000 & 1258,277 & $\times$ &  4 & 1,414 &  4,000 $\pm$ 0,001 & 1,415 & $\surd$  &    2 820,727 & $\surd$\\
\hline
12 &        100 &   15,077 & $\surd$  &  6 & 1,732 &  6,130 $\pm$ 0,602 & 1,829 & $\surd$  &    4 405,600 & $\surd$\\
12 &     10 000 &   24,129 & $\times$ &  6 & 1,732 &  6,019 $\pm$ 0,057 & 1,727 & $\surd$  &    4 009,139 & $\surd$\\
12 &  1 000 000 &   37,232 & $\times$ &  6 & 1,732 &  6,005 $\pm$ 0,006 & 1,733 & $\surd$  &    4 190,958 & $\surd$\\
12 & 10 000 000 &  211,857 & $\times$ &  6 & 1,732 &  6,001 $\pm$ 0,002 & 1,733 & $\surd$  &    5 196,444 & $\surd$\\
12 & 50 000 000 &  930,820 & $\times$ &  6 & 1,732 &  6,000 $\pm$ 0,001 & 1,733 & $\surd$  &    9 369,948 & $\surd$\\
\hline
16 &        100 &    9,423 & $\surd$  &  8 & 2,000 &  8,200 $\pm$ 0,678 & 2,060 & $\surd$  &   65 436,000 & $\surd$\\
16 &     10 000 &    9,524 & $\surd$  &  8 & 2,000 &  8,022 $\pm$ 0,065 & 1,975 & $\surd$  &   65 548,150 & $\surd$\\
16 &  1 000 000 &   29,103 & $\times$ &  8 & 2,000 &  8,004 $\pm$ 0,007 & 2,002 & $\surd$  &   66 068,345 & $\surd$\\
16 & 10 000 000 &  123,543 & $\times$ &  8 & 2,000 &  8,001 $\pm$ 0,002 & 2,000 & $\surd$  &   67 909,306 & $\surd$\\
16 & 50 000 000 &  572,012 & $\times$ &  8 & 2,000 &  8,000 $\pm$ 0,001 & 2,000 & $\surd$  &   77 487,208 & $\surd$\\
\hline
20 &        100 &    6,516 & $\surd$  & 10 & 2,236 & 10,220 $\pm$ 0,676 & 2,053 & $\surd$  &1 048 576,000 & $\surd$\\
20 &     10 000 &   10,904 & $\surd$  & 10 & 2,236 & 10,028 $\pm$ 0,073 & 2,230 & $\surd$  &1 046 545,178 & $\surd$\\
20 &  1 000 000 &   45,481 & $\times$ & 10 & 2,236 & 10,006 $\pm$ 0,007 & 2,238 & $\surd$  &1 046 807,769 & $\surd$\\
20 & 10 000 000 &  140,678 & $\times$ & 10 & 2,236 & 10,001 $\pm$ 0,002 & 2,237 & $\surd$  &1 050 521,985 & $\surd$\\
20 & 50 000 000 &  553,078 & $\times$ & 10 & 2,236 & 10,000 $\pm$ 0,001 & 2,237 & $\surd$  &1 060 015,985 & $\surd$\\
\hline
\end{tabular}
} \hspace{0.7cm} }
{\it \caption{\label{rc4statistik} Untersuchung von Zufallszahlen, die mit dem RC4-Generator mit der Ausgabebreite 4 Bit
erzeugt wurden. Zum Erzeugen l"angerer Zufallszahlen wurde der Generator mehrfach nacheinander ausgef"uhrt.  Es
wurde immer der Standardschl"ussel $K_{0}=0$, $K_{1}=1, \dots$, $K_{15}=15$ verwendet. Das Signifikanzniveau
der $\chi^{2}$-Quadrat-Verteilung wurde auf $\alpha = 0,95$ festgelegt; die Quantile der $\chi^{2}$-Verteilung
wurden \cite[S.~197]{huebner} entnommen.}}
\end{floatingtable}

~

\vspace{1mm}

~

\vspace{12cm}

In Tabelle~\ref{rc4statistik} f"allt auf, dass der RC4-Generator den Test auf die blockweise Gleichverteilung und den
Anpassungstest der
bitweisen Wahrscheinlichkeiten an die Normalverteilung besteht, aber den Chi-Quadrat-Test der bitweisen Gleichverteilung
nicht. Wenn die Ausgabel"ange gr"o"ser als 4 ist und mehr als 10 000 Zufallszahlen erzeugt werden, wird der
Wert von $\chi^{2}$ gr"o"ser als das entsprechende Quantil der Chi-Quadrat-Verteilung. Da in dieser Arbeit nur
Untersuchungen im Low-Security-Bereich betrachtet werden, das hei"st Anwendungen, bei denen nur wenige Zufallszahlen
erzeugt werden, f"allt das Nichtbestehen des Tests ab 10 000 Zufallszahlen nicht ins Gewicht.

Um diesen Mangel am RC4-Generator dennoch zu beheben, ist eine Modifikation notwendig, die kurz erl"autert werden soll. Der
Test ergibt, dass die ausgegebenen Zufallszahlen nicht voneinander unabh"angig sind, sobald mehrere nacheinander
erzeugte 4-Bit-Zufallszahlen zu einer l"angeren Zufallszahl zusammengesetzt werden. Weiterhin ist aus
Tabelle~\ref{rc4statistik} zu entnehmen, da"s der Test f"ur die Ausgabel"ange 4 immer bestanden wird. Also ist es
ung"unstig, mehrere 4-Bit-Zahlen, die nacheinander erzeugt wurden, zu einer neuen zusammenzusetzen. Die L"osung ist,
mehrere RC4-Generatoren, die mit verschiedenen Schl"usseln initialisiert sind, parallel mehrere 4-Bit-Zufallszahlen
erzeugen zu lassen und diese Zahlen zu einer langen Zufallszahl zusammenzusetzen. Dadurch ist gew"ahrleistet, dass
die Zahlen unabh"angig voneinander sind. Der Nachteil ist, dass der Speicherbedarf auf ein Vielfaches ansteigt.
Das Verfahren paralleler RC4-Generatoren wird in dieser Arbeit nicht weiter verfolgt, weil sie sich auf
Low-Security-Anwendungen beschr"ankt.
\vspace{10mm}

\newpage

%~
%
%\begin{floatingtable}[r]{
%{\centering
%{\scriptsize
%\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r|}
%\hline
%Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok?\\
%\hline
% 4 &        100 &   0,946 & $\surd$  &  2 & 1,000 & 1,950 $\pm$ 0,325 & 0,983 & $\surd$ \\
% 4 &     10 000 &  13,869 & $\times$ &  2 & 1,000 & 2,003 $\pm$ 0,033 & 0,999 & $\surd$ \\
% 4 &  1 000 000 &   7,409 & $\surd$  &  2 & 1,000 & 2,001 $\pm$ 0,033 & 1,001 & $\surd$ \\
% 4 & 10 000 000 &  14,109 & $\times$ &  2 & 1,000 & 1,999 $\pm$ 0,001 & 1,001 & $\surd$ \\
% 4 & 50 000 000 &  51,848 & $\times$ &  2 & 1,000 & 1,999 $\pm$ 0,001 & 1,000 & $\surd$ \\
%\hline
% 8 &        100 &   7,907 & $\surd$  &  4 & 1,414 & 4,182 $\pm$ 0,464 & 1,402 & $\surd$ \\
% 8 &     10 000 &  13,600 & $\surd$  &  4 & 1,414 & 3,989 $\pm$ 0,047 & 1,424 & $\surd$ \\
% 8 &  1 000 000 &  21,325 & $\times$ &  4 & 1,414 & 4,004 $\pm$ 0,005 & 1,415 & $\surd$ \\
% 8 & 10 000 000 &  62,055 & $\times$ &  4 & 1,414 & 4,002 $\pm$ 0,002 & 1,414 & $\surd$ \\
% 8 & 50 000 000 & 277,359 & $\times$ &  4 & 1,414 & 4,002 $\pm$ 0,001 & 1,414 & $\times$\\
%\hline
%12 &        100 &  16,242 & $\surd$  &  6 & 1,732 & 6,061 $\pm$ 0,590 & 1,783 & $\surd$ \\
%12 &     10 000 &  10,911 & $\surd$  &  6 & 1,732 & 5,984 $\pm$ 0,057 & 1,744 & $\surd$ \\
%12 &  1 000 000 &  11,683 & $\surd$  &  6 & 1,732 & 5,998 $\pm$ 0,006 & 1,734 & $\surd$ \\
%12 & 10 000 000 &  18,509 & $\surd$  &  6 & 1,732 & 5,999 $\pm$ 0,002 & 1,732 & $\surd$ \\
%12 & 50 000 000 &  50,216 & $\times$ &  6 & 1,732 & 6,000 $\pm$ 0,001 & 1,733 & $\surd$ \\
%\hline
%16 &        100 &   6,219 & $\surd$  &  8 & 2,000 & 7,970 $\pm$ 0,606 & 1,832 & $\surd$ \\
%16 &     10 000 &  25,968 & $\surd$  &  8 & 2,000 & 7,970 $\pm$ 0,066 & 2,002 & $\surd$ \\
%16 &  1 000 000 &  10,204 & $\surd$  &  8 & 2,000 & 8,000 $\pm$ 0,007 & 1,998 & $\surd$ \\
%16 & 10 000 000 &  14,831 & $\surd$  &  8 & 2,000 & 7,999 $\pm$ 0,002 & 2,001 & $\surd$ \\
%16 & 50 000 000 &  17,551 & $\surd$  &  8 & 2,000 & 8,000 $\pm$ 0,001 & 2,000 & $\surd$ \\
%\hline
%20 &        100 &  14,919 & $\surd$  & 10 & 2,236 & 9,768 $\pm$ 0,713 & 2,156 & $\surd$ \\
%20 &     10 000 &  13,601 & $\surd$  & 10 & 2,236 & 9,980 $\pm$ 0,074 & 2,238 & $\surd$ \\
%20 &  1 000 000 &  26,106 & $\surd$  & 10 & 2,236 & 9,995 $\pm$ 0,007 & 2,235 & $\surd$ \\
%20 & 10 000 000 &  40,250 & $\times$ & 10 & 2,236 & 9,999 $\pm$ 0,002 & 2,237 & $\surd$ \\
%20 & 50 000 000 &  51,206 & $\times$ & 10 & 2,236 & 9,998 $\pm$ 0,001 & 2,237 & $\surd$ \\
%\hline
%\end{tabular}
%}}}
%{\it \caption{\label{rc4kippbits} Untersuchung der kippenden Bits der erzeugten Zufallszahlen.
%Die Parameter bei der Erzeugung und Untersuchung der Zufallszahlen sind dieselben wie in Tabelle~\ref{rc4statistik}.}}
%\end{floatingtable}
%
%Das Ergebnis der Untersuchung, ob in zwei aufeinanderfolgenden Zufallszahlen, die mit dem RC4-Generator erzeugt wurden,
%die H"alfte der Bits kippen, ist in Tabelle~\ref{rc4kippbits} dargestellt.
%
%\vspace{5.6cm}

\paragraph{Untersuchung der erzeugten Zufallszahlen auf Unabh"angigkeit} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[b]{|r|r||r|r|r|c|}
\hline
Bitzahl & Anzahl & unkompr. [Byte] & \texttt{zip} [Byte] & \texttt{gzip} [Byte] & Ok?\\
\hline
 4 &        100 &          50 &          50 &          80 & $\surd$\\
 4 &     10 000 &       5 000 &       5 000 &       5 030 & $\surd$\\
 4 &  1 000 000 &     500 000 &     500 080 &     500 105 & $\surd$\\
 4 & 10 000 000 &   5 000 000 &   5 000 765 &   5 000 790 & $\surd$\\
 4 & 50 000 000 &  25 000 000 &  25 003 815 &  25 003 840 & $\surd$\\
\hline
 8 &        100 &         100 &         100 &         130 & $\surd$\\
 8 &     10 000 &      10 000 &      10 000 &      10 030 & $\surd$\\
 8 &  1 000 000 &   1 000 000 &   1 000 155 &   1 000 180 & $\surd$\\
 8 & 10 000 000 &  10 000 000 &  10 001 530 &  10 001 555 & $\surd$\\
 8 & 50 000 000 &  50 000 000 &  50 007 630 &  50 007 655 & $\surd$\\
\hline
12 &        100 &         150 &         150 &         180 & $\surd$\\
12 &     10 000 &      15 000 &      15 000 &      15 030 & $\surd$\\
12 &  1 000 000 &   1 500 000 &   1 500 230 &   1 500 255 & $\surd$\\
12 & 10 000 000 &  15 000 000 &  15 002 290 &  15 002 315 & $\surd$\\
12 & 50 000 000 &  75 000 000 &  75 012 046 &  75 012 071 & $\surd$ \\
\hline
16 &        100 &         200 &         200 &         230 & $\surd$ \\
16 &     10 000 &      20 000 &      20 000 &      20 030 & $\surd$ \\
16 &  1 000 000 &   2 000 000 &   2 000 310 &   2 000 335 & $\surd$ \\
16 & 10 000 000 &  20 000 000 &  20 003 055 &  20 003 080 & $\surd$ \\
16 & 50 000 000 & 100 000 000 & 100 015 861 & 100 015 886 & $\surd$ \\
\hline
20 &        100 &         250 &         250 &         280 & $\surd$ \\
20 &     10 000 &      25 000 &      25 000 &      25 030 & $\surd$ \\
20 &  1 000 000 &   2 500 000 &   2 500 385 &   2 500 410 & $\surd$ \\
20 & 10 000 000 &  25 000 000 &  25 003 815 &  25 003 840 & $\surd$ \\
20 & 50 000 000 & 125 000 000 & 125 019 671 & 125 019 696 & $\surd$ \\
\hline
\end{tabular}
}}}
{\it \caption{\label{rc4packen} Untersuchung der Kompressionsraten beim Komprimieren von Zufallszahlen, die mit dem
RC4-Generator der Ausgabebreite 4 Bit erzeugt wurden. Zum Erzeugen l"angerer Zufallszahlen wurde der Generator
mehrfach nacheinander ausgef"uhrt.  Es wurde immer der Standardschl"ussel $K_{0}=0$, $K_{1}=1, \dots$, $K_{15}=15$
verwendet.\vspace{3mm}}}
\end{floatingtable}


Die von RC4 erzeugten Zufallszahlen werden nun auf ihre Unabh"angigkeit ge\-pr"uft. Dazu wird versucht, wie in
Kapitel~\ref{testunabhaengigkeit} beschrieben, sie mit den Packprogrammen \texttt{gzip} und \texttt{zip} zu
komprimieren.

Es wurden dieselben Parameter des RC4-Generators gew"ahlt wie zuvor bei der Untersuchung auf Gleichverteilung (siehe
voriger Abschnitt), und es wurden wiederum jeweils 100, 10~000, 1~000~000, 10~000~000 und 50~000~000 Zahlen der
L"angen 4, 8, 12, 16 und 20 Bit erzeugt. Das Ergebnis der Untersuchung dieser Zahlen ist in Tabelle~\ref{rc4packen}
dargestellt. Die Spalten 1 und 2 geben die eben genannte Bitl"ange der Zahlen sowie die Anzahl der Zufallszahlen an.
In Spalte 3 ist die unkomprimierte Gr"o"se der Zufallszahlen angegeben, die in einer Datei abgespeichert wurden. Die\-se
Gr"o"se berechnet aus $\frac{\mathrm{Bitzahl} \cdot \mathrm{Anzahl}}{8}$. In den Spalten 4 und 5 ist die Gr"o"se der
mit \texttt{zip} bzw. \texttt{gzip} komprimierten Daten angegeben, das hei"st nicht die Gr"o"se der komprimierten
Datei, sondern nur die der komprimierten Daten (ohne Overhead, der sich aus den Dateiformaten ergibt).

Bei der Betrachtung von Tabelle~\ref{rc4packen} f"allt auf, dass die Informationsmenge der komprimierten
Zufallszahlen nie kleiner als die der unkomprimierten Zahlen ist. Das bedeutet, dass sich die von RC4
erzeugten Zufallszahlen nicht komprimieren lassen. Also haben die Zufallszahlen den Test auf Unabh"angigkeit
bestanden.

\vspace{1cm}


% ************************************************* EC **********************************************

\subsection{Elliptische Kurven \hspace{3.5cm}} \label{eccvorstellung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{4.3cm}(von Peter Hartmann)}}

Dieser Zufallszahlengenerator, abgek"urzt als EC-Generator bezeichnet, nutzt die in Kapitel 
\ref{elliptischekurven} beschriebenen elliptischen Kurven der Form $y^{2} = x^{3} + ax + b$ "uber 
$\mathcal{GF}(p)$. Die Berechnungen werden in der projektiven Koordinatendarstellung durchgef"uhrt, um die 
Division zu vermeiden. Als Startwert wird ein Punkt $P_{0} (x_{0}, y_{0}, z_{0})$ der elliptischen Kurve 
gew"ahlt. Dabei ist $z_{0} = 1$, weil mit einem Punkt in affiner Darstellung initialisiert wird.

Die rekursive Definition der fortgesetzten Punktverdopplung bzw. der Addition eines Punktes zu sich selbst lautet 
dann:
\begin{eqnarray*}
(x_{1}, y_{1}, z_{1}) & = & 2 \cdot (x_{0}, y_{0}, z_{0}) \\
(x_{n}, y_{n}, z_{n}) & = & 2 \cdot (x_{n-1}, y_{n-1}, z_{n-1}) \quad \mathrm{~mit~} n > 0
\end{eqnarray*}

Die Zufallszahlensequenz besteht dann aus der Folge der $x_{n}$ oder der Folge von Bitbl"ocken einer festen 
Breite $w$, die aus den $x_{n}$ erzeugt werden. Sei Beispielsweise $x_{n} = 10111011$ und die Breite des 
Bitblocks mit $w = 5$ definiert, dann werden die $5$ niederwertigsten Bits benutzt.

Problematisch ist bei diesem Verfahren die Beurteilung der Periode, die hier auftritt. Da statt der fortgesetzten 
Punktaddition die Punktverdopplung benutzt wird, gilt der Satz von Langrange (siehe Kapitel~\ref{gruppentheorie}) 
nicht mehr, und es ist in Abh"angigkeit von der Kurvenordnung keine einfache Aussage mehr zu treffen, welche 
Gr"o"se die Periode besitzt. Auch wird diese Untersuchung erschwert, da hier mit einer uneindeutigen Darstellung 
gearbeitet wird. Das bedeutet, selbst wenn der Ausgangspunkt erneut erreicht wird, ist damit noch keine Periode 
erkennbar, da die ausgegebenen Werte sich unterscheiden, auch wenn sie den gleichen Punkt beschreiben. Da hier von 
den drei Werten jeweils nur einer zur Ausgabe benutzt wird und die anderen unbekannt sind und zus"atzlich eine 
nichteindeutige Darstellung benutzt wird, ist es im Low-Security-Bereich eine hinnehmbare Einschr"ankung, dass 
hier die theoretischen Grundlagen nicht vorliegen. Insofern w"are auch eine numerische Untersuchung durch ein 
Trustcenter denkbar, welches dann f"ur gestiegene Anforderungen die Qualit"at der Zufallszahlen garantiert.

\paragraph{Untersuchung der erzeugten Zufallszahlen auf Gleichverteilung} \quad \newline

Es sollen nun die Zufallszahlen, die vom EC-Generator erzeugt werden, wie in Kapitel~\ref{testgleichverteilung}
beschrieben auf Gleichverteilung untersucht werden. Zum Erzeugen der Zufallszahlen wird die in
Kapitel~\ref{ecc} vorgestelle Implementation von EC in der Programmiersprache C benutzt.


\begin{floatingtable}[r]{
\hspace{0.5cm}
{\small
\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r||r|r|}
\hline
Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok? & $\chi^{2}$ (Block) & Ok?\\
\hline
 1 &   100 &     0,154 & $\surd$  &  0,5 & 0,500 & 0,481 $\pm$ 0,162 & 0,502 & $\surd$  &        0,154 & $\surd$\\
 1 & 1 000 &     0,144 & $\surd$  &  0,5 & 0,500 & 0,494 $\pm$ 0,052 & 0,500 & $\surd$  &        0,144 & $\surd$\\
 1 & 1 847 &     0,009 & $\surd$  &  0,5 & 0,500 & 0,499 $\pm$ 0,038 & 0,500 & $\surd$  &        0,009 & $\surd$\\
\hline
 2 &   100 &     0,380 & $\surd$  &  1,0 & 0,707 & 0,990 $\pm$ 0,227 & 0,689 & $\surd$  &        0,400 & $\surd$\\
 2 & 1 000 &     2,136 & $\surd$  &  1,0 & 0,707 & 0,974 $\pm$ 0,073 & 0,697 & $\surd$  &        2,528 & $\surd$\\
 2 & 1 847 &     1,216 & $\surd$  &  1,0 & 0,707 & 0,990 $\pm$ 0,054 & 0,700 & $\surd$  &        1,429 & $\surd$\\
\hline
 4 &   100 &     5,360 & $\surd$  &  2,0 & 1,000 & 2,140 $\pm$ 0,307 & 0,932 & $\surd$  &       18,080 & $\surd$\\
 4 & 1 000 &     3,848 & $\surd$  &  2,0 & 1,000 & 2,043 $\pm$ 0,102 & 0,978 & $\surd$  &       13,440 & $\surd$\\
 4 & 1 847 &     1,833 & $\surd$  &  2,0 & 1,000 & 1,971 $\pm$ 0,077 & 1,007 & $\surd$  &       12,970 & $\surd$\\
\hline
 8 &   100 &     6,478 & $\surd$  &  4,0 & 1,141 & 4,180 $\pm$ 0,457 & 1,388 & $\surd$  &      222,560 & $\surd$\\
 8 & 1 000 &     8,557 & $\surd$  &  4,0 & 1,141 & 3,955 $\pm$ 0,143 & 1,377 & $\surd$  &      263,616 & $\surd$\\
 8 & 1 847 &     3,703 & $\surd$  &  4,0 & 1,141 & 3,959 $\pm$ 0,108 & 1,416 & $\surd$  &      235,235 & $\surd$\\
\hline
12 &   100 &     8,912 & $\surd$  &  6,0 & 1,732 & 6,100 $\pm$ 0,574 & 1,744 & $\surd$  &    3 996,000 & $\surd$\\
12 & 1 000 &    17,444 & $\surd$  &  6,0 & 1,732 & 5,933 $\pm$ 0,182 & 1,745 & $\surd$  &    4 144,576 & $\surd$\\
12 & 1 847 &    19,176 & $\surd$  &  6,0 & 1,732 & 5,935 $\pm$ 0,135 & 1,765 & $\surd$  &    4 102,332 & $\surd$\\
\hline
\end{tabular}
} \hspace{0.4cm} }
{\it \caption{\label{ecstatistik-x} Untersuchung von Zufallszahlen, die mit dem EC-Generator {\em durch Ausgabe der
x-Koordinate} erzeugt wurden.
Als Kurve wurde $y^{2}=x^{3} + 2155 \cdot x + 16008$ "uber $\mathcal{GF}(33~013)$ mit dem Startpunkt $P_{0}(x_{0}; y_{0})=(3; 150)$ gew"ahlt.
Die Kurve besitzt die prime Ordnung 33247, und mit dem Startpunkt wird eine Periode von 1847 erreicht.
Das Signifikanzniveau der $\chi^{2}$-Quadrat-Verteilung wurde auf $\alpha = 0,95$ festgelegt; die Quantile der
$\chi^{2}$-Verteilung wurden \cite[S.~197]{huebner} entnommen.}}
\end{floatingtable}

~

\vspace{11cm}

Das Ergebnis der Untersuchungen ist in den Tabellen~\ref{ecstatistik-x} und~\ref{ecstatistik-y} zusammengefasst.
Der Generator erzeugt Zufallszahlen der L"ange 1, 2, 4, 8 und 12 Bit. F"ur alle Ausgabel"angen 1, 2, 4, 8 und 
12 Bit wurden jeweils 100, 1~000 und 1~847 Zufallszahlen erzeugt (Tabellenspalten 1 und 2). Es wurde als obere 
Grenze 1~847 Zahlen f"ur den Statistiktest gew"ahlt, da dann wieder der Ausgangspunkt erreicht wird. Dazu wurden f"ur die 
Tabelle~\ref{ecstatistik-x} die x-Koordinaten und f"ur die Tabelle~\ref{ecstatistik-y} die y-Koordinaten benutzt.
Die erzeugten Zufallszahlen wurden den Statistiktests unterzogen, deren Ergebnisse in den Spalten der
Tabellen~\ref{ecstatistik-x} und~\ref{ecstatistik-y} angegeben sind. Der Chi-Quadrat-Test zur Untersuchung auf 
Gleichverteilung der bitweisen Wahrscheinlichkeit ist in den Spalten 3 und 4 gezeigt; dabei gibt Spalte 3 den Wert 
von $\chi^{2}$ an und Spalte 4, ob der Test mit dem berechneten Wert $\chi^{2}$ bestanden wurde ($\surd$ bedeutet 
,,bestanden``, $\times$ bedeutet ,,nicht bestanden``). Der Anpassungstest der bitweisen Wahrscheinlichkeit an 
eine Normalverteilung ist in den Spalten 5 bis 9 zu finden. Angegeben sind dort der Erwartungswert $EN$ und die 
Standardabweichung $\sigma_{N}$ der theoretischen Binomialverteilung, das empirische Stichprobenmittel $\overline{X}$ 
und die empirische Stichprobenstandardabweichung $\sigma_{S}$ der Verteilung der Zufallszahlen sowie wieder eine Angabe, 
ob der Test bestanden worden ist. Das Ergebnis des Chi-Quadrat-Tests der blockweisen Wahrscheinlichkeiten auf Gleichverteilung
ist in den Spalten 10 und 11 abgedruckt; Spalte 10 zeigt den Wert von $\chi^{2}$, und in Spalte 11 ist wiederum angegeben,
ob der Test bestanden wurde.

Die erzeugten Zufallszahlen, die mit den x-Koordinaten erzeugt wurden, bestehen in allen benutzten Ausgabebreiten den 
Statistiktest. Bei den Zufallszahlen, die mittels der y-Koordinate generiert wurden, f"allt auf, dass die Zahlen bei der 
1-Bit-Ausgabe bei einer Anzahl von 1~000 erzeugten Zufallszahlen durchfallen.



\begin{floatingtable}[r]{
\hspace{0.5cm}
{\small
\begin{tabular}[b]{|r|r||r|c||r|r|r|r|r||r|r|}
\hline
Bitzahl & Anzahl & $\chi^{2}$ (Bit) & Ok? & $EN$ & $\sigma_{N}$ & $\overline{X} \hspace{5mm} $ & $\sigma_{S}$ & Ok? & $\chi^{2}$ (Block) & Ok?\\
\hline
 1 &   100 &     0,154 & $\surd$  &  0,5 & 0,500 & 0,519 $\pm$ 0,162 & 0,502 & $\surd$  &        0,154 & $\surd$ \\
 1 & 1 000 &     7,744 & $\times$ &  0,5 & 0,500 & 0,544 $\pm$ 0,052 & 0,498 & $\surd$  &        7,744 & $\times$\\
 1 & 1 847 &     4,987 & $\surd$  &  0,5 & 0,500 & 0,526 $\pm$ 0,038 & 0,500 & $\surd$  &        4,987 & $\surd$ \\
\hline
 2 &   100 &     2,720 & $\surd$  &  1,0 & 0,707 & 0,920 $\pm$ 0,246 & 0,748 & $\surd$  &        7,840 & $\surd$ \\
 2 & 1 000 &     3,776 & $\surd$  &  1,0 & 0,707 & 1,040 $\pm$ 0,073 & 0,698 & $\surd$  &        8,384 & $\surd$ \\
 2 & 1 847 &     2,566 & $\surd$  &  1,0 & 0,707 & 1,025 $\pm$ 0,054 & 0,703 & $\surd$  &        5,165 & $\surd$ \\
\hline
 4 &   100 &     4,947 & $\surd$  &  2,0 & 1,000 & 1,970 $\pm$ 0,308 & 0,937 & $\surd$  &       25,440 & $\surd$ \\
 4 & 1 000 &     3,743 & $\surd$  &  2,0 & 1,000 & 1,958 $\pm$ 0,102 & 0,975 & $\surd$  &       11,104 & $\surd$ \\
 4 & 1 847 &     4,994 & $\surd$  &  2,0 & 1,000 & 2,012 $\pm$ 0,075 & 0,973 & $\surd$  &       17,489 & $\surd$ \\
\hline
 8 &   100 &    12,146 & $\surd$  &  4,0 & 1,141 & 4,180 $\pm$ 0,457 & 1,389 & $\surd$  &      278,880 & $\surd$ \\
 8 & 1 000 &     5,843 & $\surd$  &  4,0 & 1,141 & 3,993 $\pm$ 0,148 & 1,421 & $\surd$  &      234,432 & $\surd$ \\
 8 & 1 847 &     3,473 & $\surd$  &  4,0 & 1,141 & 3,989 $\pm$ 0,108 & 1,411 & $\surd$  &      253,531 & $\surd$ \\
\hline
12 &   100 &    17,410 & $\surd$  &  6,0 & 1,732 & 6,270 $\pm$ 0,569 & 1,728 & $\surd$  &    4 159,840 & $\surd$ \\
12 & 1 000 &    14,650 & $\surd$  &  6,0 & 1,732 & 6,002 $\pm$ 0,182 & 1,749 & $\surd$  &    3 997,120 & $\surd$ \\
12 & 1 847 &     7,473 & $\surd$  &  6,0 & 1,732 & 6,002 $\pm$ 0,133 & 1,734 & $\surd$  &    3 974,332 & $\surd$ \\
\hline
\end{tabular}
} \hspace{0.4cm} }
{\it \caption{\label{ecstatistik-y} Untersuchung von Zufallszahlen, die mit dem EC-Generator {\em durch Ausgabe der
y-Koordinate} erzeugt wurden.
Als Kurve wurde $y^{2}=x^{3} + 2155 \cdot x + 16008$ "uber $\mathcal{GF}(33~013)$ mit dem Startpunkt 
$P_{0}(x_{0}; y_{0})=(3; 150)$ gew"ahlt. Die Kurve besitzt die prime Ordnung 33~247, und mit dem Startpunkt 
wird eine Periode von 1847 erreicht. Das Signifikanzniveau der $\chi^{2}$-Quadrat-Verteilung wurde auf 
$\alpha = 0,95$ festgelegt; die Quantile der $\chi^{2}$-Verteilung wurden \cite[S.~197]{huebner} entnommen.}}
\end{floatingtable}

~

\vspace{11cm}

\begin{floatingtable}[l]{
\hspace{3.5cm}
{\scriptsize
\begin{tabular}[b]{|r|r||r|r|r|c|}
\hline
Bitzahl & Anzahl & unkompr. [Byte] & \texttt{zip} [Byte] & \texttt{gzip} [Byte] & Ok?\\
\hline
 1 &   100 &    13 &    13 &    41 & $\surd$ \\
 1 & 1 000 &   125 &   125 &   155 & $\surd$ \\
 1 & 1 847 &   231 &   231 &   261 & $\surd$ \\
\hline
 2 &   100 &    25 &    25 &    41 & $\surd$ \\
 2 & 1 000 &   250 &   250 &   280 & $\surd$ \\
 2 & 1 847 &   462 &   462 &   492 & $\surd$ \\
\hline
 4 &   100 &    50 &    50 &    80 & $\surd$ \\
 4 & 1 000 &   500 &   500 &   530 & $\surd$ \\
 4 & 1 847 &   924 &   924 &   954 & $\surd$ \\
\hline
 8 &   100 &   100 &   100 &   130 & $\surd$ \\
 8 & 1 000 & 1 000 & 1 000 & 1 030 & $\surd$ \\
 8 & 1 847 & 1 847 & 1 847 & 1 877 & $\surd$ \\
\hline
12 &   100 &   150 &   150 &   180 & $\surd$ \\
12 & 1 000 & 1 500 & 1 500 & 1 530 & $\surd$ \\
12 & 1 847 & 2 771 & 2 771 & 2 801 & $\surd$ \\
\hline
\end{tabular}
} \hspace{3.5cm} }
{\it \caption{\label{ecpacken} Untersuchung der Kompressionsraten beim EC-Generator. Da sich die Kompressionsraten
bei der Ausgabe von x- und y-Koordinate an keiner Stelle unterscheiden, sind sie in einer einzigen Tabelle
zusammengefasst.}}
\end{floatingtable}

~

\newpage

\paragraph{Untersuchung der erzeugten Zufallszahlen auf Unabh"angigkeit} \quad \newline

Die vom EC-Generator erzeugten Zufallszahlen werden nun auf ihre Unabh"angigkeit gepr"uft. Dazu wird versucht, wie in
Kapitel~\ref{testunabhaengigkeit} beschrieben, sie mit den Packprogrammen \texttt{gzip} und \texttt{zip} zu
komprimieren.

Es wurden dieselben Parameter des EC-Generators gew"ahlt wie zuvor bei der Untersuchung auf Gleichverteilung (siehe
voriger Abschnitt), und es wurden wiederum jeweils 100, 1~000 und 1~847 Zahlen der L"angen 1, 2, 4, 8 und 12 Bit 
erzeugt. Das Ergebnis der Untersuchung dieser Zahlen ist in Tabelle~\ref{ecpacken} dargestellt. Da sich die Werte 
f"ur die Zahlen, die durch Ausgabe der x- bzw. der y-Koordinate erzeugt wurden, nicht unterscheiden, sind sie in einer 
Tabelle zusammengefasst. Die Spalten 1 und 2 geben die eben genannte Bitl"ange der Zahlen sowie die Anzahl der 
Zufallszahlen an. In Spalte 3 ist die unkomprimierte Gr"o"se der Zufallszahlen angegeben, die in einer Datei 
abgespeichert wurden. Die\-se Gr"o"se berechnet aus $\frac{\mathrm{Bitzahl} \cdot \mathrm{Anzahl}}{8}$. In den 
Spalten 4 und 5 ist die Gr"o"se der mit \texttt{zip} bzw. \texttt{gzip} komprimierten Daten angegeben, das hei"st 
nicht die Gr"o"se der komprimierten Datei, sondern nur die der komprimierten Daten (ohne Overhead, der sich aus 
den Dateiformaten ergibt).

Bei der Betrachtung von Tabelle~\ref{ecpacken} f"allt auf, dass die Informationsmenge der komprimierten
Zufallszahlen nie kleiner als die der unkomprimierten Zahlen ist. Das bedeutet, dass sich die vom EC-Generator 
erzeugten Zufallszahlen nicht komprimieren lassen. Also haben die Zufallszahlen den Test auf Unabh"angigkeit
bestanden.

\newpage


% ****************************************************************
% *****  Kapitel 6 (Implementierung der Zufallsgeneratoren)  *****
% ****************************************************************

\newpage
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Kapitel falsch im Inhaltsverzeichnis erscheint.
\section{Implementierung der Zufallsgeneratoren auf Chipkarten} \label{impl}

In diesem Kapitel werden die Implementierungen der Zufallsgeneratoren aus Kapitel~\ref{zzg} vorgestellt.
Jeder der Generatoren wurde in den Programmiersprachen C und VHDL programmiert. In Kapitel~\ref{implgemein} werden die
Eigenschaften vorgestellt, die die Implementationen der Zufallsgeneratoren gemeinsam vorweisen. In den darauf folgenden
Kapiteln~\ref{lfsr} bis~\ref{ecc} werden die verschiedenen Implementationen im einzelnen vorgestellt. Zus"atzlich werden
die Eigenschaften der Zufallsgeneratoren untersucht, die sich aus der Implementation ergeben. Das sind die Antwortzeit,
der Speicherbedarf und die Leistungsaufnahme.


% ******************************** Gemeinsamkeiten der Implementierungen******************************

\subsection{Gemeinsamkeiten der Implementierungen \hspace{2.8cm}} \label{implgemein}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{7.9cm}(von Stefan Witt)}}

Alle in Kapitel~\ref{zzg} vorgestellten Zufallsgeneratoren wurden zweimal implementiert: Einmal in der
Programmiersprache C und einmal in VHDL\footnote{VHDL steht f"ur ,,Very High Speed Integrated Circuit Hardware
Description Language`` und ist eine Beschreibungssprache f"ur Hardwarestrukturen.}. Diese doppelte Implementierung
wurde aus folgendem Grund durchgef"uhrt: Zum ausf"uhrlichen Analysieren der Zufallsgeneratoren und zum
Erstellen von Statistiken ist es g"unstig, die Generatoren auf einem Rechner in einer Hochsprache vorliegen zu haben.
Andererseits sollen sie in Hardware umgesetzt werden, und deshalb ist die Implementierung in einer
Hardwarebeschreibungssprache dringend notwendig. Erst dadurch ist es m"oglich, den Hardware- und Zeitaufwand
der Zufallsgeneratoren abzusch"atzen.

\paragraph{Die Implementierungen in C} \quad \newline

Zum Analysieren der Zufallsgeneratoren wurde die Programmiersprache C gew"ahlt, weil sie zum einen die
notwendigen Bitoperationen unterst"utzt und zum anderen portabel ist.

Als C-Compiler wurde \texttt{gcc}, der GNU-C-Compiler, benutzt, und die Programme wurden unter den Betriebssystemen Linux, Solaris
und AmigaOS erfolgreich kompiliert. Da auf graphische Benutzungsoberfl"achen verzichtet wurde und nur die Bibliotheken
aus dem ANSI-C-Sprachstandard benutzt wurden, ist die Portierung zwischen verschiedenen Betriebssystemen problemlos
m"oglich.

Bei der Programmierung wurde darauf geachtet, dass die Zufallsgeneratoren frei parametrisierbar sind. Das bedeutet,
dass alle Eigenschaften -- auch die Anzahl der Ausgabebits -- einfach "anderbar sind. Diese M"oglichkeit zum Einstellen
der Parameter ist zum Analysieren der Zufallszahlen sehr bedeutsam. Die Einstellungen werden jeweils direkt im Quellcode
im Definitionsabschnitt des Zufallsgenerators vorgenommen. Dieses Vorgehen hat im Gegensatz zu eigenen
Konfigurationsdateien den Vorteil, dass die "Anderungen schneller und einfacher durchgef"uhrt werden k"onnen.

Im Folgenden sollen die Parameter vorgestellt werden, die bei allen Zufallsgeneratoren eingestellt werden k"onnen.

\begin{itemize}
\item \texttt{\#define ANZAHL 10} --- Legt die Anzahl der Zufallszahlen fest, die erzeugt werden sollen.
\item \texttt{\#define TESTE\_PERIODE true} --- Boolescher Wert, der besagt, ob der Zufallsgenerator auf eine Periode
                                           untersucht werden soll. Wenn \texttt{true} eingestellt ist, wird
                                           nach jedem Erzeugen einer Zufallszahl getestet, ob der Zustand des
                                           Zufallsgenerators gleich dem Anfangszustand ist, und der Benutzer wird
                                           informiert, wenn eine Periode gefunden wird.
\item \texttt{\#define DATEIAUSGABE true} --- Festlegung, ob die Zufallszahlen in einer Datei abgespeichert werden sollen.
                                          Die erzeugte Zufallszahlendatei kann mit dem in
                                          Kapitel~\ref{testgleichverteilung} vorgestellten Statistikprogramm getestet
                                          werden, oder es kann versucht werden, sie wie in
                                          Kapitel~\ref{testunabhaengigkeit} beschrieben mit einem Packprogramm zu
                                          komprimieren.
\item \texttt{\#define DATEINAME \dq datei.zz\dq} --- Hier kann der Dateiname der zu erzeugenden Datei eingestellt werden.
\item \texttt{\#define KONSOLE false} --- Einstellung, ob die Zufallszahlen auf der Konsole ausgegeben werden sollen.
                                      Das ist nur dann m"oglich, wenn auch die Ausgabe in eine Datei (siehe oben)
                                      eingestellt ist.
\item \texttt{\#define ZUSTANDLOG true} --- Mit diesem Parameter wird eingestellt, ob nach jedem Rechenschritt der
                                        Zustand des Generators in eine Datei geschrieben werden soll. Das ist notwendig,
                                        um die kippenden Bits beim Erzeugen einer Zufallszahl zu analysieren. Das
                                        Dateiformat sieht f"ur jeden Zufallsgenerator anders aus; es ist in den
                                        C-Programmen jeweils dokumentiert. Die Rechenschritte werden in C genauso
                                        durchgef"uhrt wie in den Hardwarebeschreibungen, um die Aussagekraft der
                                        Tests kippender Bits zu gew"ahrleisten.
\item \texttt{\#define LOGDATEINAME \dq zustand.log\dq} --- Hier wird die Datei angegeben, in die die Zust"ande
                                                        gespeichert werden sollen.
\end{itemize}


\paragraph{Die Implementierungen in VHDL} \quad \newline

Die Implementierung in VHDL ist erforderlich, um die Zufallsgeneratoren in Hardware zu beschreiben. Diese
Hardwarebeschreibung kann dazu benutzt werden, um die Generatoren auf Chipkarten zu verwenden. Im Rahmen dieser
Studienarbeit wurden die in VHDL beschriebenen Zufallsgeneratoren erfolgreich auf ein FPGA (,,Field Programmable
Gate Array``) abgebildet. Als Compiler und Simulator kam \texttt{SYNOPSYS} zum Einsatz, und die Untersuchung der
Schaltung wurde mit \texttt{CADENCE} durchgef"uhrt.

\begin{floatingfigure}[r]{8cm}
\includegraphics{abbildungen/anschluesse.eps}
{\it \caption[Anschl"usse der VHDL-Modelle]{\label{anschluesse} Anschl"usse, die die Implementationen der
Zufallsgeneratoren in VHDL aufweisen. Links sind die Eing"ange dargestellt und rechts die Ausg"ange.}}
\end{floatingfigure}

Die Zufallsgeneratoren wurden so implementiert, dass sie von der Ansteuerung alle das gleiche Verhalten aufweisen.
Wie in Abb.~\ref{anschluesse} dargestellt, verf"ugen die Zufallsgeneratoren alle "uber den Eingang ,,nreset`` zum
Initialisieren des Zufallsgenerators, den Takteingang ,,clk`` und das Eingangssignal ,,start``, um eine neue
Zufallszahl anzufordern. Wenn eine Zufallszahl fertig berechnet ist, ist der Ausgang ,,zufallszahl\_fertig`` f"ur
einen Takt auf High, und gleichzeitig liegt am Ausgang ,,zufallszahl`` die Zufallszahl. Zu allen anderen Zeitpunkten
sind die Ausg"ange auf Low, das hei"st es nicht m"oglich, aus den Signalen an den Ausg"angen R"uckschl"usse "uber
den Zustand des Zufallsgenerators zu ziehen.

Die Realisierung der Zufallsgeneratoren ist so, wie in Abb.~\ref{anschluesse} dargestellt und wie im Rahmen dieser
Studienarbeit in VHDL programmiert wurde, noch nicht direkt auf Chipkarten zu "ubernehmen. Der Grund daf"ur ist,
dass alle Generatoren von einer dauerhaften externen Spannungsquelle abh"angig sind. Wenn diese nicht gegeben ist,
geht der im Generator gespeicherte Zustand verloren, und er l"asst sich nur noch "uber das Reset-Signal in einen
definierten Zustand "uberf"uhren. Dadurch wird allerdings der Zufallsgenerator wieder auf den Anfangswert zur"uckgesetzt
und liefert demzufolge dieselben Zufallszahlen wie bei der ersten Initialisierung. Abhilfe f"ur diese Problematik ist,
dass der Zustand des Zufallsgenerators in einem nichtfl"uchtigen Speicher, beispielsweise einem EEPROM (siehe
Kapitel~\ref{chipkartentypen}, Abschnitt ,,Mikroprozessorkarten``), gespeichert wird. Da der Aufbau einer Chipkarte
je nach Chipkartentyp und Hersteller variiert, wurde in dieser Studienarbeit die allgemeine Variante nach dem oben
beschriebenen Verfahren implementiert, die sich an verschiedene Chipkarten anpassen l"asst.

Bei der Implementierung wurden f"ur jeden Zufallsgenerator drei Dateien erstellt: \texttt{generator\_pkg.vhd},
\texttt{generator.vhd} und \texttt{tb\_generator.vhd}. Die erste Datei, \texttt{generator\_pkg.vhd}, enth"alt
die Parameter des entsprechenden Zufallsgenerators. Als einziger Parameter, der f"ur alle Generatoren gleichsam
einstellbar ist, ist ,,\texttt{constant TIMEBASE: time := 100 ns;}``, der die Zeitaufl"osung angibt, die bei der 
Simulation verwendet werden soll. Die Datei \texttt{generator.vhd} enth"alt die eigentliche Implementierung des
Zufallsgenerators, und \texttt{tb\_generator.vhd} ist die Testumgebung des Generators, die zur Validierung
benutzt wird.


% ************************************************ LFSR **********************************************

\subsection{LFSR \hspace{3.3cm}} \label{lfsr}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.4cm}(von Peter Hartmann)}}

In diesem Kapitel werden die LFSR-Implementierungen beschrieben, die Zeit- und Speicherkomplexit"at des 
LFSR-Generators untersucht sowie Aussagen zur Leistungsaufnahme getroffen.

\paragraph{Implementierung von LFSR in C} \quad \newline

Die Implementierung des LFSR-Generators in C bereitet keine Probleme, da die notwendigen Operationen und Datentypen 
zur Verf"ugung stehen (das Schieberegister und das Polynom werden jeweils als ,,unsigned long`` realisiert). Auch 
hinsichtlich der Wertebereiche gibt es keine Probleme. Es sind LFSRs mit einem Polynomgrad von bis zu $n = 32$ 
m"oglich (auf 32-Bit-Rechnern).

Neben den Standard-Parametern, die jeder Zufallsgenerator bietet (siehe Kapitel~\ref{implgemein}, Abschnitt
,,Die Implementierungen in C``), sind folgende Einstellungen f"ur den LFSR-Generator zus"atzlich w"ahlbar:

\begin{itemize}
\item \texttt{\#define BITBREITE} --- Angabe der Breite, die das Schieberegister in Bits haben soll.
\item \texttt{\#define ANFANGSZUSTAND} --- Angabe, mit welchem Schieberegisterinhalt initialisiert wird.
\item \texttt{\#define POLYNOM} --- Angabe des Polynoms, welches das R"uckkopplungsschema beschreibt.
\item \texttt{\#define AUSGABEHOCH, -NIEDRIG} --- Hier wird das Intervall der nebeneinanderliegenden Bits
                        angegeben, aus denen die auszugebenden Zufallsbits genommen werden.
\item \texttt{\#define EINMAL\_SCHIEBEN false} --- Auswahl, ob zum Erzeugen einer Zufallszahl ein einziges Mal
                        geschoben werden soll oder so oft wie die Zufallszahl breit ist.
\end{itemize}

\begin{floatingfigure}[l]{15cm}
\hspace{1.5cm}
\includegraphics{abbildungen/lfsr-zustand.eps}
{\it \caption[Zustandsdiagramm des LFSR-Generators]{\label{lfsr-zustand} Zustandsdiagramm des Automaten, der
in der VHDL-Implementation von LFSR beschrieben wird. Jede Transition ist mit der Bedingung f"ur den "Ubergang
($\lambda$ bei spontanem "Ubergang) und den Ausgabe-Wertzuweisungen, die beim Zustandswechsel durchgef"uhrt werden,
beschriftet.}}
\end{floatingfigure}

~

\vspace{9cm}

\paragraph{Implementierung von LFSR in VHDL} \quad \newline

Der LFSR-Generator ist auch in der VHDL-Implementation frei konfigurierbar. Die Einstellungen, die vorgenommen 
werden k"onnen, entsprechen denen der C-Implementierung, nur die Einstellm"oglichkeit \texttt{EINMAL\_SCHIEBEN}
wurde weggelassen, weil die Tests ergaben, dass die Qualit"at der Zufallszahlen bei nur einmaligem Schieben zum Erzeugen
einer Zufallszahl unbrauchbar ist. Zum Erzeugen einer $n$ Bit langen Zufallszahl wird daher immer $n$-mal das Register
geschoben.


Bei der Implemetation in VHDL wurden f"ur das LFSR folgende Register definiert:
{\small \begin{verbatim}
  signal schieberegister:       std_logic_vector(BITBREITE-1 downto 0);
  signal zaehler:               std_logic_vector(AUSGABEBREITELOG-1 downto 0);
  signal fertig:                std_logic_vector(AUSGABEBREITE-1 downto 0);
\end{verbatim}}

Dabei ist das Schieberegister neben dem durch das Polynom beschriebene R"uckkopplungsschema das zentrale Element 
zur Erzeugung der Zufallszahlen. Der Z"ahler dient zur Bestimmung, wie oft geschoben werden muss, bevor die Zufallszahl 
ausgegeben werden kann. Die Zufallszahl wird dabei direkt dem Schieberegister entnommen, so dass kein 
weiteres Ausgaberegister notwendig ist. Mit ,,fertig`` wird signalisiert, ob die Zufallszahl ausgegeben werden kann.

Der LFSR-Generator wurde -- wie die anderen Zufallsgeneratoren auch -- als Mealy-Automat realisiert. Das Zustandsdiagramm 
dieses endlichen Automaten ist in Abb.~\ref{lfsr-zustand} dargestellt. Nach dem Reset geht der Generator in den ,,frei``-Zustand 
"uber, initialisiert das Schieberegister mit dem Startwert und wartet auf das ,,start``-Signal. Sobald das ,,start``-Signal 
anliegt, wechselt der Generator in den Zustand ,,generierung`` und setzt den ,,zaehler`` auf die ,,ausgabebreite``. Dann werden,
solange der ,,zaehler`` ungleich Null ist, das neue Bit ,,einschub`` berechnet, die Bits im Schieberegister um eine Stelle 
verschoben und das neue Bit in das LFSR geschrieben. Sind der ,,zaehler`` und ,,start`` gleich Null, dann wird
,,fertig`` auf Eins gesetzt, und der Generator geht wieder in den Zustand ,,frei`` zur"uck. Liegt aber schon wieder ein 
,,start``-Signal an, dann bleibt der Generator im Zustand ,,generierung``, der ,,zaehler`` wird auf die ,,ausgabebreite`` 
gesetzt, und es wird wiederum eine Zufallszahl erzeugt, ohne erst in den ,,frei``-Zustand zur"uckzuwechseln.

In Abb.~\ref{lfsr-waves} sind die Signale des LFSR-Generators bei der Initialisierung und dem Erzeugen einer Zufallszahl 
dargestellt.

\vspace{1cm}

\begin{floatingfigure}[r]{17cm}
\includegraphics{abbildungen/lfsr-waves.eps}
{\it \caption[Signaldiagramm des LFSR-Generators]{\label{lfsr-waves} Signale des LFSR-Generators. Gezeigt sind
die Initialisierung und das Erzeugen einer Zufallszahl.}}
\end{floatingfigure}

~
\vspace{8cm}

\paragraph{Leistungsaufnahme} \quad \newline

Zur Analyse der Leistungsaufnahme der VHDL-Implementation des LFSR-Generators wurden, wie in
Kapitel~\ref{hardwarekriterien} beschrieben, die kippenden Bits bei der Erzeugung einer neuen Zufallszahl untersucht.


Untersucht wurden dazu die Bits, die durch das Schieberegister geschoben werden. Da hierzu das Polynom 
$x^{30}+x^{6}+x^{4}+x^{1}+x^{0}$ zur Beschreibung des LFSRs benutzt wurde, sind genau $30$ wechselnde Bits 
als H"ochstgrenze m"oglich. Als Startwert wurde $(2AAA~AAAA)_{16}$ gew"ahlt. Nach jeweils einem Takt, also 
nach dem Verschieben der Bits um eine Stelle, wurde die Anzahl der gewechselten Bits protokolliert. Insgesamt 
wurde dieser Vorgang 10~000~000 mal durchgef"uhrt. Das Ergebnis der Untersuchung ist in Tabelle~\ref{lfsrzustandswechsel} 
dargestellt.

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[b]{|c||r|r|}
\hline
Anzahl Wechsel & H"aufigkeit & approx. Normalvert.\\
\hline
        0     &             0 &            0.448 \\
        1     &             0 &            3.095 \\
        2     &             1 &           18.711 \\
        3     &            30 &           99.017 \\
        4     &           231 &          458.593 \\
        5     &          1279 &         1858.881 \\
        6     &          5421 &         6594.493 \\
        7     &         18861 &        20474.706 \\
        8     &         54862 &        55636.548 \\
        9     &        132946 &       132314.964 \\
       10     &        279483 &       275400.062 \\
       11     &        509491 &       501678.379 \\
       12     &        805648 &       799821.395 \\
       13     &       1118259 &      1116007.031 \\
       14     &       1356400 &      1362847.073 \\
       15     &       1444098 &      1456577.517 \\
       16     &       1351139 &      1362468.153 \\
       17     &       1113028 &      1115386.537 \\
       18     &        805378 &       799154.443 \\
       19     &        508876 &       501120.673 \\
       20     &        280336 &       275017.419 \\
       21     &        133528 &       132094.388 \\
       22     &         54527 &        55528.355 \\
       23     &         19023 &        20429.208 \\
       24     &          5536 &         6578.010 \\
       25     &          1324 &         1853.719 \\
       26     &           259 &          457.193 \\
       27     &            33 &           98.687 \\
       28     &             3 &           18.644 \\
       29     &             0 &            3.083 \\
       30     &             0 &            0.446 \\   
\hline
\end{tabular}
}}}
{\it \caption{\label{lfsrzustandswechsel} Untersuchung der kippenden Bits beim Erzeugen einer Zufallszahl.
Erzeugt wurden 10~000~000 Zufallszahlen mit dem Polynom $x^{30}+x^{6}+x^{4}+x^{1}+x^{0}$ und dem Startwert
$(2AAA~AAAA)_{16}$ Das Stichprobenmittel ist $\overline{X}=14.9990 \pm 0.0029$
Einsen, die empirische Stichprobenstandardabweichung ist $\sigma_{S}=2.7389$ Einsen.}}
\end{floatingtable}


Die Anzahl der Bitwechsel befindet sich in der ersten Spalte, in der zweiten steht die gez"ahlte 
H"aufigkeit, und in der dritten Spalte stehen die Werte einer Normalverteilung, die an die Verteilung der 
gez"ahlten H"au\-fig\-kei\-ten angepasst ist.

Das Ergebnis der Untersuchung zeigt, dass die Anzahl der kippenden Bits zwischen $2$ und $28$ liegt. Im Mittelwert 
kippen $\overline{X}=14.9990$ Bit (die Sch"atzgenauigkeit von $\overline{X}$ ist $0,0029$ Bit), und die 
empirische Standardabweichung ist $\sigma_{S}=2.7389$ kippende Bits.

F"ur die Leistungsaufnahme der Hardware ist das Ergebnis, dass pro erzeugtem Bit im Mittel 14,999 Bits kippen, 
ein recht gutes Ergebnis. F"ur das Generieren von 20-Bit-Zufallszahlen ist unter Annahme der Unabh"angigkeit 
die Anzahl der kippenden Bits also $20 \cdot 14,999 = 299,98$ Bits. Das LFSR eignet sich damit unter dem Aspekt 
der Leistungsaufnahme ohne weiteres f"ur eine Implementierung auf einer Chipkarte.

Um diesen Wert noch zu verbessern, "uberlegt man, was passiert, wenn man ein k"urzeres Schieberegister 
w"ahlt. Der Mittelwert der kippenden Bits $\overline{X}$ ist offensichtlich direkt vom Polynomgrad $n$ ab\-h"an\-gig. 
Es gilt $\overline{X} \approx \frac{n}{2}$. Insofern ist es eine "Uberlegung wert, von welchem Grad das eingesetzte 
Polynom sein soll. Wenn der Polynomgrad $n$ kleiner gew"ahlt wird, dann sinkt auch die Leistungsaufnahme. Bei der 
Erzeugung einer 20-Bit-Zufallszahl mit einem LFSR, welches auf Grundlage eines Polynoms vom Grad $n = 20$ konstruiert 
wurde, sind im Mittel $200$ kippende Bits zu erwarten.

\vspace{2.2cm}

\paragraph{Komplexit"at} \quad \newline

Die ben"otigten Flipflops entsprechen genau dem Grad des benutzten Polynoms und sind damit direkt von der 
gew"unschten Periode abh"angig. Weitere Register f"ur tempor"are Variablen sind nicht n"otig. Auch Register 
zum Speichern der Zufallsbits sind nicht erforderlich, da die Zufallsbits direkt den Schieberegistern entnommen 
werden k"onnen. Damit hat das LFSR hinsichtlich des Speicherbedarfs den besten Wert unter den 
vorgestellten Generatoren.

Ein Akzelerator ist bei dem einfachen Aufbau des LFSRs nicht erforderlich.

Soll die vom Generator erzeugte Zufallszahlensequenz einen Wert $m$ als Periode nicht unterschreiten, so hat das 
optimal gew"ahlte Schieberegister eine L"ange von $n=\lceil \log_{2}(m + 1) \rceil$ Bits, das hei"st das Polynom ist 
von diesem Grad, und auch die Anzahl der Flipflops im Register entspricht diesem Wert.

~

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[t]{|c|c|}
\hline
Polynomgrad $n$ & Speicherzellen\\
\hline
      8       &       70 \\
     16       &       86 \\
     24       &      102 \\
     32       &      118 \\
     40       &      134 \\
     48       &      150 \\
     56       &      176 \\
     64       &      192 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{lfsr-polynomgrad-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs vom 
Polynomgrad $n$ bei konstanten Werten $k = 1$ (Besetzungszahl) und $b = 4$ (Ausgabebitbreite).\vspace{5mm}\\~}}
\end{floatingtable}

Das LFSR erzeugt halb so schnell wie der RC4-Generator (der schnellste der hier vorgestellten Generatoren) 
die Zufallsbits, da bei jedem Takt ein  Bit erzeugt wird. Unter Annahme der Standardfrequenz von 3,5712 MHz 
produziert das LFSR also 3,5712 Millionen Zufallsbits und in 0,2 Sekunden genau 714 240 Zufallsbits und ist 
somit sehr schnell und unproblematisch bez"uglich der Zeitschranke.

Um eine allgemeine Formel f"ur den Speicherzellenbedarf zu erhalten, wurde mit dem Programm {\tt AMS 
SYNOPSYS} \footnote{Die Programmeinstellungen sind wie in Kapitel \ref{komplexitaet} beschrieben.} der 
Speicherzellenbedarf in Abh"angigkeit des Grades des benutzten Polynoms, der Besetzung des Polynoms und der 
Ausgabebreite der Zufallszahlen ermittelt. Mit einem h"oheren Polynomgrad $n$ steigt der Zellenbedarf, da 
die Anzahl der Register genau dem Polynomgrad entspricht. Ist die Besetzung $k$ des Polynoms dichter, so steigt 
auch der Speicherzellenbedarf, da entsprechend mehr XOR-Verkn"upfungen ausgef"uhrt werden m"ussen. Eine 
gr"o"sere Ausgabebitbreite $b$ erfordert mehr Speicherzellen, da f"ur den Z"ahler zus"atzliche Register 
erforderlich sind. In den Tabellen~\ref{lfsr-polynomgrad-speicherzellen}, \ref{lfsr-besetzung-speicherzellen}
und \ref{lfsr-ausgabebitbreite-speicherzellen} sind die abh"angigen Werte dargestellt.

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[t]{|c|c|}
\hline
Besetzung $k$ & Speicherzellen\\
\hline
     1      &      118 \\
     2      &      119 \\
     3      &      120 \\
     \dots  &      \dots \\
    31      &      148 \\
    32      &      149 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{lfsr-besetzung-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs von der Besetzung 
$k$ des Polynoms bei konstanten Werten $n = 32$ (Polynomgrad) und $b = 4$ (Ausgabebitbreite).}}
\end{floatingtable}

Bei Betrachtung der Werte f"ur den Polynomgrad $n$ und dem Speicherzellenbedarf in
Tabelle~\ref{lfsr-polynomgrad-speicherzellen} ergibt sich eine lineare 
Abh"angigkeit der Form $f(n) = 2n + x$. Die Konstante $x$ wird hier durch die Werte von $k$ und $b$ 
bestimmt und hat hier den Wert $x = 54$ (das ergibt sich z.B. aus der ersten Zeile von
Tabelle~\ref{lfsr-polynomgrad-speicherzellen}: $70=2\cdot 8+x$).

Bei Betrachtung der Werte f"ur die Besetzung $k$ des Polynoms und dem Speicherzellenbedarf
(Tabelle~\ref{lfsr-besetzung-speicherzellen}) ergibt sich eine 
lineare Abh"angigkeit der Form $f(k) = k + y$. Die Konstante $y$ wird hier durch die Werte von $n$ und $b$ 
bestimmt und hat hier den Wert $y = 117$.

Bei Betrachtung der Werte f"ur die Ausgabebitbreite $b$ und den Speicherzellenbedarf
(Tabelle~\ref{lfsr-ausgabebitbreite-speicherzellen}) ergibt sich eine 
linearlogarithmische Abh"angigkeit der Form $f(b) = 2 \cdot \lfloor \log_{2}(b) \rfloor + b + z$. Die Konstante 
$z$ wird hier durch die Werte von $n$ und $k$ bestimmt und hat hier den Wert $z = 110$.
\quad \newline
Bei Betrachtung der drei Abh"angigkeiten ergibt sich nach einfacher Rechnung die folgende Formel f"ur den 
Speicherzellenbedarf:

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[t]{|c|c|}
\hline
Ausgabebitbreite $b$ & Speicherzellen\\
\hline
        1          &      111 \\
        2          &      114 \\
        3          &      115 \\
        4          &      118 \\
        5          &      119 \\
        6          &      120 \\
        7          &      121 \\
        8          &      124 \\
        9          &      125 \\
       10          &      126 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{lfsr-ausgabebitbreite-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs von der 
Ausgabebitbreite $b$ bei konstanten Werten $n = 32$ (Polynomgrad) und $k = 1$ (Besetzungszahl des Polynoms).
}}
\end{floatingtable}

\begin{displaymath}
\quad f(n, k, b) = 2n + k + 2 \cdot \lfloor \log_{2}(b) \rfloor + b + 45
\end{displaymath}

Ist nun beispielsweise der Speicherzellenbedarf f"ur ein LFSR gefragt, welches durch das Polynom $x^{54} + x^{8} 
+ x^{6} + x^{3} + 1$ beschrieben wird und nach vier Takten eine Zufallszahl der Breite vier ausgeben soll, dann sind 
die drei Werte $n = 54$, $k = 4$ und $b = 4$. Beim Einsetzten in die Formel ergibt sich:
\begin{displaymath}
\quad f(54; 4; 4) = 2 \cdot 54 + 4 + 2 \cdot \lfloor \log_{2}(4) \rfloor + 4 + 45 = 165
\end{displaymath}
Dieser Wert wird durch {\tt AMS SYNOPSYS} best"atigt.

\newpage

% ************************************************* BBS **********************************************

\subsection{BBS \hspace{3.3cm}} \label{bbs}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.2cm}(von Peter Hartmann)}}

In diesem Kapitel werden die Implementationen des BBS-Generators vorgestellt, die Komplexit"at des Zeit- und 
Speicheraufwandes zur Berechnung von $x_{i+1}=x_{i}^{2}\bmod n$ sowie die Leistungsaufnahme untersucht.

\paragraph{Implementierung von BBS in C} \quad \newline

Die Implementierung des BBS-Generators in C liegt in zwei Versionen vor. Einmal die ,,int``-Version, die mit 
Integer-Werten arbeitet. Diese Implementierung ist wegen der Verarbeitung ganzzahliger Werten besser f"ur 
eine Chipkartenimplementierung geeignet. Allerdings f"uhrt die Begrenzung der Wortbreite auf 32 Bit auf den 
meisten Rechnern dazu, dass bei einem "Uberlauf der Generator nur noch Nullen erzeugt. Dieser Fall tritt auf, 
wenn beim Quadrieren ein Wert gr"o"ser als $2^{32}$ erzeugt wird. Die zweite Version der BBS-Implementierung 
ist die ,,double``-Version, die intern mit Gleitkommazahlen rechnet und daher einen gr"o"seren Wertebereich 
bietet. Eine Implementation, die Gleitkommazahlen verwendet, ist wegen des h"oheren Aufwands nicht f"ur 
Chipkarten geeignet.

Neben den Standard-Parametern, die jeder Zufallsgenerator bietet (siehe Kapitel~\ref{implgemein}, Abschnitt
,,Die Implementierungen in C``), sind in der Implementation vom BBS-Generator folgende Einstellungen zus"atzlich 
w"ahlbar:


\begin{itemize}
\item \texttt{\#define PRODUKT} --- Angabe des Modulus, der f"ur den Generator verwendet werden soll.
\item \texttt{\#define START} --- Angabe des Startwertes, mit dem der Generator initialisiert werden soll.
\item \texttt{\#define BITBREITE} --- Angabe der Anzahl der Bits, die pro Quadrierung des quadratischen Restes 
                                      ausgegeben werden sollen. Problemlos ist die Ausgabe von bis zu zwei 
                                      Bit. Bei der Ausgabe von mehr als zwei Bit sind gewisse Einschr"ankungen 
                                      bez"uglich der Qualit"at der Zufallszahlen zu erwarten (siehe
Kapitel~\ref{bbsvorstellung}).
\end{itemize}


\paragraph{Implementierung von BBS in VHDL} \quad \newline

Der BBS-Generator ist auch in der VHDL-Implementation frei konfigurierbar. Die Parameter entsprechen der C-Implementation.
Zus"atzlich muss in der VHDL-Implementation in der Datei \texttt{bbs\_pkg.vhd} die Konstante \texttt{PRODUKTLOG} angegeben 
werden, das ist der auf eine ganze Zahl aufgerundete Logarithmus des verwendeten Modulus'.

Folgende Register wurden f"ur den BBS-Generator in der VHDL-Implementation definiert:
{\small \begin{verbatim}
  signal wert:                  std_logic_vector(PRODUKTLOG-1 downto 0);
  signal rechenregister:        std_logic_vector(PRODUKTLOG*2-1 downto 0);
  signal multregister:          std_logic_vector(PRODUKTLOG-1 downto 0);
  signal ergebnisregister:      std_logic_vector(PRODUKTLOG*2+1-1 downto 0);
  signal fertig:                std_logic_vector(BITBREITE-1 downto 0);
\end{verbatim}}

Dabei sind alle Register vom Typ ,,std\_logic\_vector``. Im ,,wert``-Register steht der aktuelle quadratische Rest des 
Generators. Das ,,rechenregister`` dient zur Berechnung des Produktes bei der Quadrierung, das ,,multregister`` dient 
dabei als Hilfsregister f"ur die Multiplikation. Im ,,ergebnisregister`` steht dann das Ergebnis der Multiplikation 
bzw. der Moduloreduktion. Das Register ,,fertig`` dient zum Signalisieren, ob die Berechnung der Zufallsbits fertig ist.

BBS wurde -- wie die anderen Zufallsgeneratoren auch -- als Mealy-Automat realisiert. Das Zustandsdiagramm dieses
endlichen Automaten ist in Abb.~\ref{bbs-zustand} dargestellt. Der Automat soll hier nicht in allen Einzelheiten 
beschrieben werden, Details lassen sich der Abb.~\ref{bbs-zustand} und dem VHDL-Code (auf der beiliegenden CD,
siehe Anhang~\ref{anhangcd}) entnehmen. Nach dem Reset geht der Generator 
in den ,,frei``-Zustand "uber und setzt das ,,wert``-Register auf den Startwert des Generators und alle anderen Register auf Null
und wartet auf das ,,start``-Signal. Beim Anliegen 
des ,,start``-Signals wechselt der Generator in den ,,quad``-Zustand, in diesem wird der aktuelle ,,wert`` 
quadriert. Ist die Quadrierung beendet, geht der Generator in den ,,redux``-Zustand "uber, in dem dann aus dem 
Quadrat mittels Reduktion durch den Modulus der neue quadratische Rest gebildet wird. Ist die Reduktion beendet, 
steht im ,,ergebnisregister`` der neue quadratische Rest, der auch in das ,,wert``-Register geschrieben wird. Beim 
"Ubergang in den ,,frei``-Zustand wird dann das Signal ,,fertig`` gesetzt.

\begin{floatingfigure}[r]{16cm}
\includegraphics{abbildungen/bbs-zustand.eps}
{\it \caption[Zustandsdiagramm des BBS-Generators]{\label{bbs-zustand} Zustandsdiagramm des Automaten, der
in der VHDL-Implementation des BBS-Zufallsgenerators beschrieben wird. Jede Transition ist mit der Bedingung
f"ur den "Ubergang ($\lambda$ bei spontanem "Ubergang) und den Wertzuweisungen, die beim Zustandswechsel
durchgef"uhrt werden, beschriftet. Wenn ein Wert beim Zustands"ubergang nicht explizit zugewiesen wird, bedeutet
das, dass er den Wert beibeh"alt. Zur "Ubersichtlichkeit ist das Setzen von ,,fertig=0`` nicht immer explizit
angegeben.}}
\end{floatingfigure}

~

\vspace{11.5cm}


\paragraph{Komplexit"at} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[b]{|c|c|}
\hline
Modulus $m$ & Speicherzellen\\
\hline
      3       &       92 \\
      4       &      104 \\
      5       &      104 \\
      6       &      104 \\
      7       &      104 \\
      8       &      116 \\
      \dots   &      \dots \\
     15       &      116 \\
     16       &      128 \\
      \dots   &      \dots \\
     31       &      128 \\
     32       &      140 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{bbs-modulus-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs vom 
Modulus $m$ bei der Ausgabebreite $b = 1$.
}}
\end{floatingtable}


Der BBS-Generator ist erheblich aufw"andiger und langsamer als das LFSR. Bei den Ergebnissen, die hier dargestellt 
werden, ist aber nicht zu vergessen, dass die M"oglichkeit eines Akzelerators besteht. Ist ein solcher vorhanden, der 
die Quadrierung "ubernimmt, dann sind die Ergebnisse im Vergleich zu LFSR und RC4 nicht mehr ganz so schlecht. 

Im Folgenden soll nun untersucht werden, welche Zeit- und Speicherplatzkomplexit"at der BBS-Generator in Abh"angigkeit 
vom gew"ahlten Modulus besitzt.

Um eine allgemeine Formel f"ur den Speicherzellenbedarf zu erhalten, wur\-de mit dem Programm {\tt AMS 
SYNOPSYS} \footnote{Die Programmeinstellungen sind wie in Kapitel \ref{komplexitaet} beschrieben.} der 
Speicherzellenbedarf in Ab\-h"an\-gig\-keit von der Gr"o"se des Modulus' und der Ausgabebitbreite untersucht. F"ur 
ver"anderlichen Modulus $m$ und konstante Ausgabebitbreite $b = 1$ ergeben sich die in
Tabelle~\ref{bbs-modulus-speicherzellen} dargestellten Werte.

Der logarithmische Anstieg der Speicherzellen in Abh"angigkeit des Modulus' $m$ ergibt sich aus der bin"aren Speicherung
der Operanden. 
Bei Betrachtung der Werte der Tabelle~\ref{bbs-modulus-speicherzellen} ergibt sich eine Abh"angigkeit der Form 
$f(m) = 12 \cdot \left( \lfloor \log_{2}(m) \rfloor + 1 \right) + 68$.
\enlargethispage{3mm}

Bei einer "Anderung der Ausgabebreite $b$ und konstantem Modulus $m = 128$ ergeben sich die Werte, die in
Tabelle~\ref{bbs-ausgabebreite-speicherzellen} 
zu finden sind. Nat"urlich sind die gew"ahlten Werte zu klein f"ur einen praktischen Einsatz, da die Ausgabebreite viel zu
hoch gew"ahlt und der 
Modulus viel zu klein gew"ahlt wurde, diese Wahlen zur Ermittlung der Abh"angigkeiten aber n"utzlich sind.

Mit diesen Werten ergibt sich f"ur den Speicherzellenbedarf eine  Abh"an\-gig\-keit von der Ausgabebreite in der Form 
$f(b) = 3b + 161$. Setzt man nun diese beiden ermittelten Abh"angigkeiten zusammen, dann ergibt sich f"ur den
BBS-Generator 
folgende Gleichung:

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[b]{|c|c|}
\hline
Ausgabebreite $b$ & Speicherzellen\\
\hline
      1       &      164 \\
      2       &      167 \\
      3       &      170 \\
      4       &      173 \\
      5       &      176 \\
      6       &      179 \\
      7       &      182 \\
      8       &      185 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{bbs-ausgabebreite-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs von 
der Ausgabebreite $b$ und konstantem Modulus $m = 128$.\vspace{5mm}}}
\end{floatingtable}

\begin{displaymath}
\quad f(m, b) = 12 \cdot \left( \lfloor \log_{2}(m) \rfloor + 1 \right) + 3b + 65
\end{displaymath}
Ist nun beispielsweise der Speicherzellenbedarf eines BBS-Ge\-ne\-ra\-tors mit dem Modulus 1~081 und einer 2~Bit-Ausgabe
gefragt, dann 
ergibt sich damit:
\begin{displaymath}
\quad f(1~081; 2) = 12 \cdot \left( \lfloor \log_{2}(1~081) \rfloor + 1 \right) + 3 \cdot 2 + 65 = 203
\end{displaymath}
Dieser Wert wird durch {\tt AMS SYNOPSYS} best"atigt.
\vspace{5mm}

Gefragt ist nun nach einer Abh"angigkeit zwischen Periode und Speicherzellenbedarf. Hier wird dabei die Einschr"ankung
vorgenommen, 
dass die beiden Primzahlen $p$ und $q$, aus denen sich der Modulus mit $m = p \cdot q$ errechnet, in etwa gleich gro"s
sind, da sich ansonsten 
bei gro"sen unterschiedlichen Werten von $p$ und $q$ keine einfachen Aussagen mehr treffen lassen. F"ur optimal
gew"ahlte Werte von
$p$ 
und $q$ ergibt sich eine Periode von $2p_{2}q_{2}$, dabei sind $p_{2} = \frac{p - 3}{4}$ und $q_{2} = \frac{q - 3}{4}$.
Werden 2 Bits 
pro Quadrierung ausgegeben, so erh"alt man eine Periode von $4p_{2}q_{2}$. Unter der Annahme, dass $p_{2} \approx q_{2}$
gilt, ergibt sich nach einfacher Rechnung f"ur die Periode die N"aherung
$\frac{1}{16}\left(m^{2} - \frac{3}{4} + \frac{9}{4}\right)$. Soll nun ein Wert $k$ als Periode 
nicht unterschritten werden, dann ergibt sich nach L"osung der quadratischen Gleichung, dass $m$ gr"o"ser als
$\frac{1}{8}(3 + 32\sqrt{k -
135})$ 
zu w"ahlen ist. Eingesetzt in die Gleichung f"ur die Abh"angigkeit der Speicherzellen von dem Modulus ergibt sich somit
ein Zusammenhang von Periode und Speicherbedarf von
\begin{displaymath}
\quad f(k, 2) = 12 \cdot \left\lfloor \log_{2}(\frac{1}{8}(3 + 32\sqrt{k - 135}) + 1) \right\rfloor + 71.
\end{displaymath}
Eine weitere wichtige Frage ist, wie schnell der BBS-Generator die Zufallsbits erzeugen kann. Hier wird wiederum in
Abh"angigkeit des variablen 
Modulus' und fester Ausgabebreite $b = 2$ ausgegangen und wegen etwas komplizierterer durchschnittlicher logarithmischer
Gr"o"sen der
quadratischen 
Reste die Absch"atzung f"ur den schlechtesten Fall vorgenommen. Das Quadrieren der Zahlen nimmt so viele Takte in Anspruch
wie diese in
ihrer bin"aren 
Darstellung an Bits ben"otigen. Die gr"o"ste Zahl, die bei einem festen Modulus $m$ quadriert werden kann, ist $m - 1$,
also sind daf"ur im
schlechtesten Fall 
$\lceil \log_{2}(m - 1) \rceil$ Takte notwendig. Weiterer Zeitaufwand ergibt sich beim Reduzieren der quadrierten Zahlen
mit dem Modulus.
Der Modulus $m$ 
ben"otigt $\lceil \log_{2}m \rceil$ Stellen. Die gr"o"stm"ogliche Quadratzahl kann $(m - 1)^{2}$ ergeben und ben"otigt
damit $\lceil
\log_{2}(m - 1)^{2} \rceil$ bzw. 
$2 \cdot \lceil \log_{2}(m - 1) \rceil$ Stellen. Der gr"o"ste zeitliche Aufwand ergibt sich, wenn an einer einzigen Stelle
der quadrierten
Zahlen ein Bit gesetzt ist, 
welches h"oherwertiger als das h"ochstwertigste Bit des Modulus ist. Dann werden f"ur alle Stellen der Quadratzahl, die
h"oherwertiger als
das h"ochstwertigste Bit 
des Modulus und nicht gesetzt sind, 2 Takte f"ur Subtraktion und Korrekturaddition ben"otigt, und f"ur das eine gesetzte
Bit ist ein Takt
erforderlich.
Damit ergeben sich im schlechtesten Fall weitere $\lceil \log_{2}(m-1)^{2} \rceil - \lceil \log_{2}m \rceil$ Takte.
Zusammengefasst sind
das f"ur zwei Zufallsbits genau 
$\lceil \log_{2}(m - 1) \rceil + \lceil \log_{2}(m - 1)^{2} \rceil - \lceil \log_{2}m \rceil$ Takte. Vereinfacht ergibt
sich f"ur die
Anzahl der Takte f"ur 
zwei Bit in Abh"angigkeit des Modulus' folgende Gleichung:
\begin{displaymath}
\quad t(m) = \left\lceil \log_{2}\frac{(m - 1)^3}{\sqrt{m}} \right\rceil .
\end{displaymath}
Sei nun $m = 16~000~000$, dann sind f"ur 2 Bit h"ochstens $\left\lceil \log_{2}\frac{(16~000~000 - 1)^3}{\sqrt{16~000~000}}
\right\rceil = 60$ Takte
notwendig. 
Unter Annahme der Standardfrequenz von 3,5712 MHz erzeugt der BBS-Generator in diesem Beispiel also mindestens 119~040
Zufallsbits pro
Sekunde. Innerhalb von 
0,2 Sekunden sind das 23~808 Zufallsbits. Der BBS-Generator ist damit zwar erheblich langsamer als LFSR und RC4, liefert aber die
Zufallsbits schnell
genug. Auch hier stellt 
also die Zeitschranke kein Problem dar.

\newpage

\paragraph{Leistungsaufnahme} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[b]{|c||r|r|}
\hline
\hspace{0.5cm} Anzahl Wechsel \hspace{0.5cm} & \hspace{0.5cm} H"aufigkeit \hspace{0.5cm} & \hspace{0.5cm} approx.
Normalvert.\hspace{0.5cm}\\
\hline
        0     &             0 &          748.832 \\
        1     &             2 &         1007.251 \\
        2     &           466 &         1325.306 \\
        3     &          3435 &         1705.767 \\
        4     &          4714 &         2147.576 \\
        5     &          4383 &         2644.859 \\
        6     &          4507 &         3186.264 \\
        7     &          4124 &         3754.793 \\
        8     &          5140 &         4328.281 \\
        9     &          3532 &         4880.564 \\
       10     &          6333 &         5383.314 \\
       11     &          4037 &         5808.374 \\
       12     &          7016 &         6130.341 \\
       13     &          4369 &         6329.068 \\
       14     &          6803 &         6391.755 \\
       15     &          4882 &         6314.305 \\
       16     &          6614 &         6101.775 \\
       17     &          5110 &         5767.823 \\
       18     &          5516 &         5333.261 \\
       19     &          4323 &         4823.907 \\
       20     &          4312 &         4268.056 \\
       21     &          3868 &         3693.912 \\
       22     &          3297 &         3127.289 \\
       23     &          2507 &         2589.851 \\
       24     &          2023 &         2098.005 \\
       25     &          1524 &         1662.507 \\
       26     &          1109 &         1288.681 \\
       27     &           801 &          977.131 \\
       28     &           547 &          724.745 \\
       29     &           478 &          525.827 \\
       30     &           514 &          373.186 \\
       31     &           442 &          259.080 \\
       32     &           365 &          175.941 \\
       33     &           306 &          116.876 \\
       34     &           199 &           75.947 \\
       35     &           127 &           48.274 \\
       36     &            82 &           30.016 \\
       37     &            45 &           18.256 \\
       38     &            23 &           10.862 \\
       39     &            17 &            6.321 \\
       40     &             6 &            3.599 \\
       41     &             3 &            2.004 \\
       42     &             3 &            1.092 \\
       43     &             2 &            0.582 \\
       44     &             1 &            0.303 \\
       45     &             0 &            0.155 \\
       46     &             0 &            0.077 \\
       47     &             0 &            0.038 \\
       48     &             0 &            0.018 \\
       49     &             0 &            0.008 \\
       50     &             0 &            0.004 \\
       51     &             0 &            0.002 \\
       52     &             0 &            0.001 \\
       53     &             0 &            0.000 \\
       \dots  &         \dots &            \dots \\
      120     &             0 &            0.000 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{bbszustandswechsel} Untersuchung der kippenden Bits beim Erzeugen von Zufallszahlen.
Es wurden der Modulus $n=47 \cdot 719 = 33793$ und die Zahl zum Erzeugen des Startwertes $x=2$ (vgl.
Kap~\ref{bbsvorstellung}) gew"ahlt.}}
\end{floatingtable}

Zur Analyse der Leistungsaufnahme der VHDL-Implementation des BBS-Ge\-ne\-ra\-tors wurden, wie in Kapitel~\ref{hardwarekriterien}
beschrieben, die kippenden Bits der Zustandswechsel bei der Erzeugung der Zufallsbits untersucht.

Das Ergebnis der statistischen Analyse ist in Tabelle~\ref{bbszustandswechsel} gezeigt.
Betrachtet wurden dabei die Register ,,wert`` und ,,mult\-re\-gis\-ter``, die hier bei diesem Beispiel eine Gr"o"se von 
15 Bits ben"otigen sowie die Register ,,rechenregister`` und ,,ergebnisregister``, die bei diesem Beispiel 
eine Gr"o"se von 30 Bits be\-n"o\-ti\-gen. Das sind insgesamt 90 m"ogliche Bits, die wechseln k"onnen.\footnote{Bei der
Implementation des Statistiktests wurden zur einfacheren Implementation auch ,,rechenregister`` und ,,ergebnisregister``
als 30 Bit breite Zahlen angenommen, deren obere 15 Bit immer 0 sind, die also nicht kippen. Bei der Statistikausgabe
werden daher maximal 120 Bitwechsel angegeben, von denen aber nur maximal 90 tats"achlich auftreten k"onnen.} F"ur jede m"ogliche 
Anzahl von Bits, die sich "andern k"onnen, gibt es eine Tabellenzeile. Die Anzahlen der wechselnden Bits sind in der 
ersten Spalte zu finden, die gez"ahlten H"aufigkeiten in der zweiten, und in der letzten Spal\-te stehen die Werte 
einer Normalverteilung, die an die Verteilung der gez"ahlten kippenden Bits angepasst ist.

Das Ergebnis der Untersuchung zeigt, dass die Anzahl der kippenden Bits zwischen 1 und 44 liegt. Untersucht wurden 
dabei die kippenden Bits nach jedem Zustandswechsel, das hei"st bei jedem Durchlaufen einer Kante im 
Zustandsdiagramm des Automaten (siehe Abb.~\ref{bbs-zustand}). Im Mittelwert kippen $\overline{X}=13,9470$ Bit
(die Sch"atzgenauigkeit von $\overline{X}$ ist $0.0675$ Bit), und die empirische Standardabweichung ist 
$\sigma_{S}=6,7348$ kippende Bits.

Erzeugt wurden 1~969 Zufallszahlen mit 107~907 Zustandswechseln. Bei einer sicheren Ausgabe von 2 Bits pro erzeugtem 
quadratischen Rest ergeben sich somit $10 \cdot 13,947 \cdot \frac{107~907}{1~969} = 7~643,367$ kippende Bits bei der 
Erzeugung von 20 Zufallsbits. Dieses Ergebnis ist unter dem Aspekt der Leistungsaufnahme schlecht und l"asst den 
BBS-Generator f"ur einen Einsatz bei kontaktlosen Chipkarten als nicht geeignet erscheinen.


\newpage



% ************************************************* RC4 **********************************************

\subsection{RC4 \hspace{2.8cm}} \label{rc4}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{2.2cm}(von Stefan Witt)}}

Im Folgenden werden die Implementationen des RC4-Zufallsgenerators vorgestellt und die Analysen der Hardware-Kriterien
(Leistungsaufnahme und Aufwand) zusammengefasst.


\paragraph{Implementierung von RC4 in C} \quad \newline

Die Implementierung des RC4-Zufallsgenerators ist in C problemlos m"oglich, weil die erforderlichen Datentypen
in C zur Verf"ugung stehen (die S-Box, $i$ und $j$ sind als ,,unsigned integer`` realisiert) und der Wertebereich
der Typen hinreichend gro"s ist. F"ur 4-Bit-RC4 sind die maximalen Werte f"ur $i$,$j$ und die S-Box-Werte $2^{4}-1=15$,
w"ahrend der Datentyp ,,unsigned integer`` bis zu $2^{32}-1$ zul"asst.

Neben den Standard-Parametern, die jeder Zufallsgenerator bietet (siehe Kapitel~\ref{implgemein}, Abschnitt
,,Die Implementierungen in C``), sind in der Implementation von RC4 folgende Einstellungen zus"atzlich w"ahlbar:
\begin{itemize}
\item \texttt{\#define BITBREITE 4} --- Anzahl der Bits, die jede Zufallszahl breit sein soll. Dieser Wert beeinflusst
                                    die Gr"o"se der S-Box und den Wertebereich der Variablen $i$ und $j$ (siehe
                                    Kapitel~\ref{rc4vorstellung}). Wenn mehrere Zufallszahlen zu einer l"angeren
                                    zusammengesetzt werden sollen, wie es bei der Analyse in Kapitel~\ref{rc4vorstellung}
                                    getan wurde, so muss die Bitbreite beibehalten und die Anzahl der Zufallszahlen
                                    entsprechend erh"oht werden. Wenn beispielsweise die mit 4-Bit-RC4 erzeugten
                                    4-Bit-Zufallszahlen zu 20-Bit-Zufallszahlen zusammengesetzt werden sollen, ist
                                    keine "Anderung der Bitbreite n"otig, weil die 4-Bit-Zufallszahlen aufeinanderfolgend
                                    in die Ausgabedatei geschrieben werden und 5 4-Bit-Zahlen vom Statistikprogramm
                                    als 20-Bit-Zahlen eingelesen werden k"onnen. Um die Verminderung der Anzahl an
                                    Zufallszahlen durch das Zusammenfassen auszugleichen, muss die Anzahl der
                                    4-Bit-Zufallszahlen im RC4-Generator erh"oht werden.
\item \texttt{\#define STANDARDSCHLUESSEL true} --- Auswahl, ob der Standardschl"ussel $K_{0}=0$, $K_{1}=1$,~\dots,
                                    $K_{2^{\textrm{BITBREITE}}-1}=2^{\textrm{BITBREITE}}-1$ verwendet werden soll.
\item \texttt{unsigned int Schluessel $\left[\right.$\hspace{-2mm} SBOX\_GROESSE \hspace{-2mm}$\left.\right]$=\dots} ---
                                    Hier kann der Schl"ussel angegeben werden, wenn der
                                    Standardschl"ussel nicht verwendet werden soll.
\end{itemize}


\paragraph{Implementierung von RC4 in VHDL} \quad \newline

Der RC4-Zufallsgenerator ist auch in der VHDL-Implementation frei konfigurierbar. Die Parameter entsprechen denen des
C-Programms, es gibt aber einige Unterschiede. Aus diesem Grund werden die in der Datei \texttt{rc4\_pkg.vhd}
einstellbaren Parameter kurz erl"autert:
\begin{itemize}
\item \texttt{constant BITBREITE: integer := 4;} --- Diese Einstellung entspricht der des C-Programms.
\item \texttt{constant SBOX\_GROESSE:  integer := 16;} --- Dieser Wert muss auf $2^{\textrm{BITBREITE}}$ gesetzt werden.
\item \texttt{constant AUSGABEBREITE: integer := 20;} --- Im Gegensatz zum C-Programm kann hier explizit angegeben
                                                      werden, wie viele Bits der Zufallsgenerator ausgeben soll. Die
                                                      Ausgabebreite muss ein Vielfaches der Bitbreite sein. Wenn
                                                      beispielsweise die Bitbreite 4 und die Ausgabebreite 20 ist, dann
                                                      erzeugt die Hardware 5 4-Bit-Zufallszahlen, setzt sie zu 20 Bit
                                                      zusammen und gibt diese 20 Bit aus.
\item \texttt{constant RUNDENZAHLLOG: integer := 3;} --- Die Rundenzahl ist die Anzahl der Zufallszahlen, die zu einer
                                                      auszugebenden Zahl zusammengesetzt werden, im obigen Beispiel also 5.
                                                      Hier muss der aufgerundete duale Logarithmus der Rundenzahl angegeben
                                                      werden, also wiederum im Beispiel
                                                      $\left\lceil log_{2}(5) \right\rceil = 3$.
\item \texttt{constant Schluessel:    BOX := \dots} --- Hier wird der Schl"ussel angegeben. Einen Standardschl"ussel
                                                      gibt es nicht.
\end{itemize}


Bei der Implementation in VHDL werden f"ur RC4 folgende Register definiert:
{\scriptsize \begin{verbatim}
  signal SBox:    array (0 to SBOX_GROESSE-1) of integer range 0 to SBOX_GROESSE-1;
  signal i:       integer range 0 to SBOX_GROESSE-1;
  signal j:       integer range 0 to SBOX_GROESSE-1;
  signal zaehler: std_logic_vector(RUNDENZAHLLOG-1 downto 0);
  signal ausgabe: std_logic_vector(AUSGABEBREITE-1 downto 0);
  signal fertig:  std_logic_vector(AUSGABEBREITE-1 downto 0);
\end{verbatim}}
Dabei sind die S-Box, $i$ und $j$, wie in Kapitel~\ref{rc4vorstellung} angegeben, die Variablen, die f"ur die
Erzeugung einer Zufallszahl ben"otigt werden. Sie sind in VHDL als ,,integer`` und nicht als ,,std\_logic\_vector``
realisiert, weil die Indizes zum Zugriff auf ein Arrayelement nur vom Typ ,,integer`` sein d"urfen.
Der Z"ahler wird zum R"uckw"artsz"ahlen der Rundenzahl ben"otigt, ,,ausgabe`` dient zum Speichern der zusammengesetzten
Zufallszahlen, bevor sie ausgegeben werden, und ,,fertig`` dient zum Signalisieren, ob die Berechnung fertig ist.


\begin{floatingfigure}[r]{15cm}
\includegraphics{abbildungen/rc4-zustand.eps}
{\it \caption[Zustandsdiagramm des RC4-Generators]{\label{rc4-zustand} Zustandsdiagramm des Automaten, der
in der VHDL-Implementation von RC4 beschrieben wird. Jede Transition ist mit der Bedingung f"ur den "Ubergang
($\lambda$ bei spontanem "Ubergang) und den Wertzuweisungen, die beim Zustandswechsel durchgef"uhrt werden,
beschriftet. Wenn ein Wert beim Zustands"ubergang nicht explizit zugewiesen wird, bedeutet das, dass er den
Wert beibeh"alt.}}
\end{floatingfigure}

~

\vspace{14cm}

RC4 wurde -- wie die anderen Zufallsgeneratoren auch -- als Mealy-Automat realisiert. Das Zustandsdiagramm dieses
endlichen Automaten ist in Abb.~\ref{rc4-zustand} dargestellt. Nach dem Reset geht der RC4-Zufallsgenerator in den
,,init``-Zustand "uber, in dem die S-Box mithilfe des Schl"ussels initialisiert wird. Danach wartet der Generator
auf das ,,start``-Signal. Sobald es anliegt, wird der Z"ahler mit der Rundenzahl, also mit
$\frac{\mathrm{Ausgabebreite}}{\mathrm{Bitbreite}}-1$ initalisiert (weil bis 0 zur"uckgez"ahlt wird, wird 1 subtrahiert).
Die Zust"ande ,,gen1`` und ,,gen2`` werden so oft durchlaufen wie der Z"ahler angibt. Dabei wird beim "Ubergang in
,,gen1`` die S-Box permutiert, und beim "Ubergang zu ,,gen2`` wird mithilfe des Registers $t$ ein Wert aus der S-Box
gew"ahlt und in das Ausgaberegister geschoben. Wenn der Z"ahler im Zustand ,,gen2`` gleich 0 ist, wird das Ausgaberegister
ausgegeben, das ,,fertig``-Signal gesetzt und abh"angig vom ,,Start``-Signal in den Zustand ,,frei`` oder ,,gen1``
gewechselt.


\paragraph{Leistungsaufnahme} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[b]{|c||r|r|}
\hline
Anzahl Wechsel & H"aufigkeit & approx. Normalvert.\\
\hline
        0     &             0 &         1026.066 \\
        1     &          1941 &         3414.680 \\
        2     &          8823 &         9654.621 \\
        3     &         23915 &        23191.599 \\
        4     &         51497 &        47329.994 \\
        5     &         87155 &        82063.966 \\
        6     &        123695 &       120886.791 \\
        7     &        148855 &       151291.837 \\
        8     &        155327 &       160865.325 \\
        9     &        140063 &       145318.090 \\
       10     &        110263 &       111528.848 \\
       11     &         74219 &        72721.872 \\
       12     &         42640 &        40285.910 \\
       13     &         20721 &        18960.580 \\
       14     &          7883 &         7581.591 \\
       15     &          2511 &         2575.606 \\
       16     &           492 &          743.376 \\
       17     &             0 &          182.284 \\
       18     &             0 &           37.975 \\
       19     &             0 &            6.721 \\
       20     &             0 &            1.011 \\
       21     &             0 &            0.129 \\
       22     &             0 &            0.014 \\
       23     &             0 &            0.001 \\
       24     &             0 &            0.000 \\
       25     &             0 &            0.000 \\
       \dots  &         \dots &            \dots \\
       71     &             0 &            0.000 \\
       72     &             0 &            0.000 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{rc4zustandswechsel} Untersuchung der kippenden Bits beim Erzeugen einer Zufallszahl.
Erzeugt wurden 1 000 000 Zufallszahlen. Das Stichprobenmittel ist $\overline{X}=7,8764 \pm 0.0082$ kippende Bits,
die empirische Stichprobenstandardabweichung ist $\sigma_{S}=2.4769$ kippende Bits.}}
\end{floatingtable}

Zur Analyse der Leistungsaufnahme der VHDL-Im\-ple\-men\-ta\-tion von RC4 wurden, wie in Kapitel~\ref{hardwarekriterien}
beschrieben, die kippenden Bits bei der Erzeugung einer neuen Zufallszahl untersucht.

In die Betrachtung einbezogen
wurden dabei die Variablen $i$ und $j$ sowie die Werte S-Box. Das Ergebnis der Untersuchung von 1~000~000 Zufallszahlen
der L"ange 4 Bit ist in Tabelle~\ref{rc4zustandswechsel} angegeben. Es sind bei der Bitbreite 4 maximal
$2^{4} \cdot 4 + 2 \cdot 4 = 72$ (f"ur die S-Box $2^{4} \cdot 4$ Bit und f"ur $i$ und $j$ je $4$ Bit)
kippende Bits m"oglich. F"ur jede m"ogliche Anzahl an Wechseln gibt es eine Tabellenzeile.
Die Anzahl ist in der ersten Spalte eingetragen; in der zweiten Spalte ist die gez"ahlte H"aufigkeit zu finden, und in
der letzten Spalte stehen die Werte einer Normalverteilung, die an die Verteilung der gez"ahlten H"aufigkeiten
angepasst ist.

Das Ergebnis der Untersuchung zeigt, dass die Anzahl der kippenden Bits zwischen 1 und 16 liegt. Im Mittelwert kippen
$\overline{X}=7,8764$ Bit (die Sch"atzgenauigkeit von $\overline{X}$ ist $0.0082$ Bit), und die empirische
Standardabweichung ist $\sigma_{S}=2.4769$ kippende Bits.

F"ur die Leistungsaufnahme der Hardware ist das Ergebnis, dass pro 4-Bit-Zufallszahl im Mittel $7,8764$ Bit kippen,
sehr gut. F"ur 20-Bit-Zufallszahlen ist die Anzahl der kippenden Bits also (unter der Annahme der Unabh"angigkeit)
$5 \cdot 7,8764 = 39,382$ Bit. Zur Verwendung auf Chipkarten ist diese Eigenschaft des RC4-Zufallsgenerators
hervorragend, weil die Leistungsaufnahme minimal ist.

\vspace{1cm}

\paragraph{Komplexit"at} \quad \newline

Der Zeitbedarf zur Erzeugung einer Zufallszahl mit dem RC4-Zufallsgenerator ist 2 Takte zum Generieren einer
4-Bit-Zahl (bei Verwendung des 4-Bit-RC4). Diese Zahl ergibt sich aus dem Zustandsdiagramm (Abb.~\ref{rc4-zustand}),
weil zum Erzeugen einer 4-Bit-Zufallszahl die beiden Zust"ande ,,gen1`` und ,,gen2`` durchlaufen werden.

Allgemein ist der Zeitbedarf $t(m)$ zum Erzeugen einer $n$ Bit breiten Zufallszahl mit 4-Bit-RC4
\begin{displaymath}
\quad t(m) = 2 \cdot \frac{m}{4}.
\end{displaymath}
Dabei muss $m$ durch 4 teilbar sein, das hei"st es sind nur Vielfache von 4 als Ausgabebreite zul"assig. Der Zufallsgenerator
geht beim Erzeugen einer Zufallszahl vor wie in Kapitel~\ref{rc4vorstellung} beschrieben: Wenn mehr als 4 Bit angefordert
werden, erzeugt er mehrere 4-Bit-Zahlen und setzt sie zu einer langen Zufallszahl zusammen.

Wenn der Takt die Standardfrequenz von Chipkarten ist (3,5712 MHz ), dann erzeugt RC4 innerhalb von 0,2 Sekunden
7~142~400 Zufallsbits (je 4 Bit in 2 Takten). Die Anforderung nach kurzer Antwortzeit ist damit sehr gut erf"ullt.

\begin{floatingtable}[r]{
{\centering
{\small
\begin{tabular}[t]{|c|c|}
\hline
Ausgabebreite $b$ & Speicherzellen\\
\hline
 8 & 605 \\
12 & 627 \\
16 & 649 \\
20 & 671 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{rc4-breite-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs von der Ausgabebreite
$b$.\\~}}
\end{floatingtable}

Zur Untersuchung des Hardwareaufwands, den die VHDL-Im\-ple\-men\-ta\-tion von RC4 ben"otigt, wurde f"ur verschiedene
Ausgabebreiten $b$ der Bedarf an Speicherzellen ermittelt. Das Ergebnis ist in Tabelle~\ref{rc4-breite-speicherzellen}
dargestellt. Zwischen den beiden Gr"o"sen ergibt sich induktiv die Beziehung
\begin{displaymath}
\quad f(b) = 22 \cdot \frac{b}{4} + 561.
\end{displaymath}
Die Anzahl der notwendigen Speicherzellen steigt also linear mit der Ausgabebreite an. Im Vergleich mit den zuvor
untersuchten Zufallsgeneratoren LFSR und BBS werden mehr Zellen ben"otigt. Das liegt daran, dass f"ur RC4 ein
aufw"andiges Permutationsnetzwerk zur Realisierung der Vertauschungen der S-Box gebraucht wird.

Die Periode ist beim 4-Bit-RC4-Generator unabh"angig vom Speicherbedarf, weil die Periode eine Konstante ist,
wie in Kapitel~\ref{rc4vorstellung} (Abschnitt ,,Parametrisierung des Verfahrens f"ur Chipkarten``) beschrieben wurde.
Da die Periode aber konstant in der Gr"o"senordnung $10^{15}$ liegt und damit die Sicherheit des RC4-Generators im
Low-Security-Bereich in jedem Fall gew"ahrleistet ist, ist das kein Nachteil.

\vspace{1cm}


% ************************************************* EC **********************************************

\subsection{Elliptische Kurven \hspace{3.5cm}} \label{ecc}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{4.3cm}(von Peter Hartmann)}}

Im Folgenden werden die Implementierungen des EC-Generators vorgestellt, die Komplexit"at in Hinblick auf den Speicher- 
und den Zeitaufwand untersucht sowie Angaben zur Leistungsaufnahme gemacht.

\paragraph{Implementierung von EC in C} \quad \newline

Die Implementierung des EC-Zufallsgenerators ist in C nicht ganz einfach, da die 32-Bit-Beschr"ankung auf den meisten 
Rechnern dazu f"uhrt, dass die eingesetzte Beispielkurve nicht korrekt benutzt werden kann, weil durch die auftretenden 
Multiplikationen die 32-Bit-Darstellung nicht ausreicht. Mit einigen Anpassungen ist die Einschr"ankung allerdings
umgehbar. Die Einzelheiten sind ausf"uhrlich in der Datei~\texttt{EC.c} (siehe Anhang~\ref{anhangcd}) dokumentiert.
S"amtliche Variablen, sowohl die Punktkoordinaten als auch die Hilfsvariablen (siehe Kapitel~\ref{elliptischekurven}),
sind als ,,integer`` realisiert.

Neben den Standard-Parametern, die jeder Zufallsgenerator bietet (siehe Kapitel~\ref{implgemein}, Abschnitt
,,Die Implementierungen in C``), sind in der Implementation von EC folgende Einstellungen zus"atzlich w"ahlbar:
\begin{itemize}
\item \texttt{\#define KURVE\_A} --- Angabe des Kurvenparameters $a$.
\item \texttt{\#define KURVE\_B} --- Angabe des Kurvenparameters $b$, dieser hat nur einen informativen Wert, da er nicht zur 
                                    Berechnung benutzt wird. Der Wert ergibt sich implizit aus dem angegeben Startwert.
\item \texttt{\#define KURVE\_X} --- Angabe der x-Koordinate des Startpunktes $P_{0}$.
\item \texttt{\#define KURVE\_Y} --- Angabe der y-Koordinate des Startpunktes $P_{0}$.
\item \texttt{\#define KURVE\_MODULUS} --- Angabe des Modulus $p$ der Gruppe $\mathcal{GF}(p)$.
\item \texttt{\#define KURVE\_MODULUSLOG} --- Angabe der Anzahl Bits zur Darstellung von \texttt{KURVE\_MO\-DU\-LUS}.
\item \texttt{\#define AUSGABE\_KOORDINATE} --- Angabe, welche Koordinate zur Ausgabe benutzt werden soll, m"oglich sind 
                                               $x$, $y$ oder $z$.
\item \texttt{\#define BITBREITE} --- Angabe der Anzahl der Bits, die der Ausgabekoordinate entnommen werden sollen.
\end{itemize}

\paragraph{Implementierung von EC in VHDL} \quad \newline

Der EC-Zufallsgenerator ist auch in der VHDL-Implementation frei konfigurierbar. Die Parameter entsprechen denen des
C-Programms.

Bei der Implementation in VHDL werden f"ur den EC-Generator folgende Register definiert:
{\scriptsize \begin{verbatim}
  signal x:                     std_logic_vector(KURVE_MODULUSLOG-1 downto 0);
  signal y:                     std_logic_vector(KURVE_MODULUSLOG-1 downto 0);
  signal z:                     std_logic_vector(KURVE_MODULUSLOG-1 downto 0);
  signal m:                     std_logic_vector(KURVE_MODULUSLOG-1 downto 0);
  signal s:                     std_logic_vector(KURVE_MODULUSLOG-1 downto 0);
  signal t:                     std_logic_vector(KURVE_MODULUSLOG-1 downto 0);
  signal rechenregister:        std_logic_vector(KURVE_MODULUSLOG*2-1 downto 0);
  signal fak1register:          std_logic_vector(KURVE_MODULUSLOG*2-1 downto 0);
  signal fak2register:          std_logic_vector(KURVE_MODULUSLOG*2-1 downto 0);
  signal ergebnisregister:      std_logic_vector(KURVE_MODULUSLOG*2+1-1 downto 0);
  signal fertig:                std_logic_vector(BITBREITE-1 downto 0);
\end{verbatim}}

F"ur die Punktkoordinaten werden $x$, $y$ und $z$ benutzt, und $m$, $s$ und $t$ sind die Hilfsvariablen zur
Berechnung der neuen 
Punktkoordinaten bei der Punktverdopplung (siehe Kapitel~\ref{elliptischekurven}). Das ,,rechenregister`` dient zur 
Produktberechnung, die Register ,,fak1register`` und ,,fak2register`` zur Multiplikation (die beiden Faktoren), das 
,,ergebnisregister`` f"ur das Multiplikations- und das Endergebnis, und das Register ,,fertig`` signalisiert das Ende der
Berechnung.

EC wurde -- wie die anderen Zufallsgeneratoren auch -- als Mealy-Automat realisiert. Auf das Zustandsdiagramm dieses
endlichen Automaten wird verzichtet, da der Automat 30 Zust"ande besitzt und eine grafische Darstellung bei der 
Gr"o"senordnung nichts mehr veranschaulicht. Auch auf eine detaillierte Beschreibung der Arbeitsweise des Generators 
in der VHDL-Implementation soll verzichtet werden, da diese zu umfangreich und auch recht redundant ausfallen w"urde. 
Die benutzten Grundoperationen wie die Multiplikation oder die Addition sind insoweit nicht erkl"arungsbed"urftig,
und der Punktverdopplungsalgorithmus findet sich in Kapitel~\ref{elliptischekurven}.

Es ist aber ohne n"ahere Betrachtungen ersichtlich, dass der EC-Generator den gr"o"sten Berechnungsaufwand verursacht.


\paragraph{Komplexit"at} \quad \newline

\begin{floatingtable}[r]{
{\centering
{\scriptsize
\begin{tabular}[t]{|c|c|c|}
\hline
Logarithmus des Modulus $m$ & Bitbreite $b$ & Speicherzellen\\
\hline
            2            &     1      &      306 \\
            2            &     2      &      309 \\
            3            &     1      &      334 \\
            3            &     2      &      337 \\
            3            &     3      &      340 \\
            4            &     1      &      362 \\
            4            &     2      &      365 \\
            4            &     3      &      368 \\
            4            &     4      &      371 \\
            5            &     1      &      390 \\
            5            &     2      &      393 \\
            5            &     3      &      396 \\
            5            &     4      &      399 \\
            5            &     5      &      402 \\
            6            &     1      &      418 \\
\hline
\end{tabular}
}}}
{\it \caption{\label{ec-modulus-speicherzellen} Abh"angigkeit des Speicherzellenbedarfs vom Logarithmus des 
Modulus $m$ bei der Ausgabebreite $b$.}}
\end{floatingtable}

Der EC-Generator ist hinsichtlich der Zeitkomplexit"at der schlechteste unter den hier vorgestellten Generatoren. 
Vom Speicherzellenbedarf liegt er zwischen dem BBS- und dem RC4-Generator. 

Die Speicherkomplexit"at wurde wie bei den anderen Generatoren ermittelt. 
Aus Tabelle~\ref{ec-modulus-speicherzellen} ergibt sich offensichtlich in Abh"angigkeit vom Kurvenmodulus $m$ und der 
Ausgabebreite $b$ folgende Formel f"ur die Speicherzellen:

\begin{displaymath}
\quad f(m, b) = 28 \cdot \lceil \log_{2}m) \rceil + 3b + 247.
\end{displaymath}

F"ur unsere Beispielkurve $y^{2}=x^{3} + 2155 \cdot x + 16008$ "uber $\mathcal{GF}(33~013)$ mit einer 4-Bit-Ausgabe 
ergibt sich somit:

\begin{displaymath}
\quad f(33~013; 4) = 28 \cdot \lceil \log_{2}33~013 \rceil + 3 \cdot 4 + 247 = 707.
\end{displaymath}

Dieser Wert wird durch {\tt AMS SYNOPSYS} best"atigt.
\vspace{5mm}

Zur Zeitkomplexit"at wird in analoger Weise wie f"ur den BBS-Generator vorgegangen. Es wird vom schlechtesten Fall 
ausgegangen, und es werden die beim BBS-Generator vorgestellten Ergebnisse benutzt (siehe Kapitel~\ref{bbs}).
Bei der Punktverdopplung sind f"unf Multiplikationen mit den Konstanten 2, 3, 4 und 8 erforderlich (siehe
Kapitel~\ref{elliptischekurven}). Das ist vergleichsweise vernachl"assigbarer Rechenaufwand. Auch die drei
Subtraktionen und die eine Addition lassen sich, wenn 
auch schon etwas aufw"andiger, noch vergleichsweise vernachl"assigen. Es sind weiterhin 13 Multiplikationen notwendig, bei denen 
die Faktoren bis zu $m-1$ gro"s werden k"onnen. Nach den beim BBS-Generator durchgef"uhrten Betrachtungen ergibt das in etwa 
folgende Absch"atzung in Abh"angigkeit des Modulus' $m$ folgenden Zeitaufwand pro Punktverdopplung:

\begin{displaymath}
\quad t(m) = 13 \cdot \left\lceil \log_{2}\frac{(m - 1)^3}{\sqrt{m}} \right\rceil
\end{displaymath}

Sei nun $m = 16~000~000$, dann sind f"ur 4 Bits in etwa h"ochstens $13 \cdot \left\lceil \log_{2}\frac{(16~000~000 -
1)^3}{\sqrt{16~000~000}}
\right\rceil = 778$ Takte notwendig. Unter Annahme der Standardfrequenz von 3,5712 MHz erzeugt der EC-Generator in diesem Beispiel 
also mindestens 18~360 Zufallsbits pro Sekunde. Innerhalb von 0,2 Sekunden sind das 3~672 Zufallsbits. Der EC-Generator ist damit zwar 
der langsamste unter den hier vorgestellten Zufallszahlengeneratoren, liefert aber die Zufallsbits schnell genug. Auch hier stellt also die Zeitschranke 
kein Problem dar. Der Modulus von 16~000~000 ist deshalb gew"ahlt worden, da dies dem verwendeten BBS-Modulus entspricht. Praktischerweise wird wohl kaum eine 
solche gro"se elliptische Kurve im Low-Security-Bereich eingesetzt werden. F"ur ein $m = 30~000$ liefert der Generator in 0,2 Sekunden 
immerhin schon 5~910 Bits.

~

\begin{floatingtable}[r]{
\hspace{1.5cm}
{\scriptsize
\begin{tabular}[b]{|c||r|r|||c||r|r|}
\hline
Anzahl Wechsel & H"aufigkeit & approx. Normalvert. & Anzahl Wechsel & H"aufigkeit & approx. Normalvert.\\
\hline
        0     &          2742 &         5343.719 &        35     &          2418 &         6883.772 \\
        1     &             1 &         7095.765 &        36     &          2602 &         5174.829 \\
        2     &             7 &         9270.330 &        37     &          1971 &         3827.419 \\
        3     &            30 &        11916.029 &        38     &          2221 &         2785.200 \\
        4     &          4208 &        15069.829 &        39     &          1962 &         1994.101 \\
        5     &         39471 &        18751.046 &        40     &          2072 &         1404.683 \\
        6     &         57416 &        22955.306 &        41     &          1861 &          973.531 \\
        7     &         55137 &        27649.104 &        42     &          1731 &          663.837 \\
        8     &         49744 &        32765.699 &        43     &          1443 &          445.363 \\
        9     &         37771 &        38203.065 &        44     &          1511 &          293.973 \\
       10     &         52416 &        43824.541 &        45     &          1366 &          190.915 \\
       11     &         43493 &        49462.601 &        46     &          1230 &          121.987 \\
       12     &         43667 &        54925.867 &        47     &           991 &           76.688 \\
       13     &         46928 &        60009.125 &        48     &           841 &           47.433 \\
       14     &         52922 &        64505.696 &        49     &           721 &           28.865 \\
       15     &         57912 &        68221.181 &        50     &           618 &           17.283 \\
       16     &         62340 &        70987.324 &        51     &           509 &           10.181 \\
       17     &         75804 &        72674.620 &        52     &           372 &            5.901 \\
       18     &         75708 &        73202.369 &        53     &           265 &            3.365 \\
       19     &         73570 &        72545.070 &        54     &           223 &            1.888 \\
       20     &         75857 &        70734.464 &        55     &           140 &            1.042 \\
       21     &         68379 &        67856.997 &        56     &            89 &            0.566 \\
       22     &         62832 &        64046.971 &        57     &            74 &            0.302 \\
       23     &         55524 &        59476.166 &        58     &            52 &            0.159 \\
       24     &         52201 &        54341.012 &        59     &            29 &            0.082 \\
       25     &         47673 &        48848.686 &        60     &            17 &            0.042 \\
       26     &         46172 &        43203.452 &        61     &             8 &            0.021 \\
       27     &         47961 &        37594.508 &        62     &            18 &            0.010 \\
       28     &         43631 &        32186.279 &        63     &             6 &            0.005 \\
       29     &         30339 &        27111.749 &        64     &             3 &            0.002 \\
       30     &         21793 &        22469.049 &        65     &             0 &            0.001 \\
       31     &         11552 &        18321.129 &        66     &             0 &            0.001 \\
       32     &          8198 &        14698.066 &        67     &             0 &            0.000 \\
       33     &          4412 &        11601.351 &        \dots  &         \dots &            \dots \\
       34     &          4047 &         9009.430 &       310     &             0 &            0.000 \\
\hline
\end{tabular}
} \hspace{1.5cm} }
{\it \caption{\label{eczustandswechsel} Untersuchung der kippenden Bits beim Erzeugen einer Zufallszahl.
Erzeugt wurden 1~847 Zufallszahlen. Das Stichprobenmittel ist $\overline{X}=17.9451 \pm 0.0215$ kippende Bits,
die empirische Stichprobenstandardabweichung ist $\sigma_{S}=7.8434$ kippende Bits. Die Spalten 4, 5 und 6 sind
die Fortsetzungen der Spalten 1, 2 und~3.}}
\end{floatingtable}

~

\newpage

\paragraph{Leistungsaufnahme} \quad \newline


Zur Analyse der Leistungsaufnahme der VHDL-Implementation des EC-Ge\-ne\-ra\-tors wurden, wie in Kapitel~\ref{hardwarekriterien}
beschrieben, die kippenden Bits der Zustandswechsel bei der Erzeugung der Zufallsbits untersucht.

Das Ergebnis der statistischen Analyse ist in Tabelle~\ref{eczustandswechsel} gezeigt.
Betrachtet wurden dabei die Register der Variablen $x$, $y$, $z$, $m$, $s$ und $t$ sowie die Register ,,rechenregister``, 
,,fak1register``, ,,fak2register`` und ,,ergebnisregister``. Jedes dieser zehn Register ben"otigt 31 Bits, da  
die Kurve $y^{2}=x^{3} + 2155 \cdot x + 16008$ "uber $\mathcal{GF}(33~013)$ mit dem Startpunkt $P_{0}(x_{0}; y_{0})=(3; 150)$ benutzt
wurde. 
Insgesamt sind also 310 m"ogliche Bits vorhanden, die ihren Wert ver"andern k"onnen. F"ur jede m"ogliche 
Anzahl von Bits, die sich "andern k"onnen, gibt es eine Tabellenzeile. Die Anzahlen der wechselnden Bits sind in der 
ersten Spalte zu finden, die gez"ahlten H"aufigkeiten in der zweiten, und in der letzten Spalte stehen die Werte 
einer Normalverteilung, die an die Verteilung der gez"ahlten kippenden Bits angepasst ist.

Das Ergebnis der Untersuchung zeigt, dass die Anzahl der kippenden Bits zwischen 0 und 66 liegt. Untersucht wurden 
dabei die kippenden Bits nach jedem Zustandswechsel. Im Mittelwert kippen $\overline{X}=17.9451$ Bit
(die Sch"atzgenauigkeit von $\overline{X}$ ist $0.0215$ Bit), und die empirische Standardabweichung ist 
$\sigma_{S}=7.8434$ kippende Bits.

Erzeugt wurden 1~847 Zufallszahlen mit 1~439~222 Zustandswechseln. Bei einer Ausgabe von 4 Bit\footnote{4 Bit wurden 
deshalb gew"ahlt, weil der BBS-Generator 2 Bits problemlos sicher ausgeben kann, aber im Gegensatz zum EC-Generator nur 
mit einer Koordinate arbeitet, der EC-Generator in der affinen Darstellung aber mit zwei.} pro erzeugtem 
verdoppelten Punkt ergeben sich somit $5 \cdot 17.9451 \cdot \frac{1~439~222}{1~847} = 69~916,034$ kippende Bits bei der 
Ereugung von 20 Zufallsbits. Dieses Ergebnis ist unter dem Aspekt der Leistungsaufnahme sehr schlecht und l"asst den 
EC-Generator f"ur einen Einsatz bei Chipkarten nicht als geeignet erscheinen.



% ************************************************************
% *****                Kapitel 7 (Schluss)               *****
% ************************************************************

\newpage
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Kapitel falsch im Inhaltsverzeichnis erscheint.
\section{Schluss} \label{schluss}


% ******************************************* Zusammenfassung ****************************************

\subsection{Zusammenfassung \hspace{3.5cm}} \label{zusammenfassung}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{4.3cm}(von Peter Hartmann)}}


In diesem Kapitel werden die in der Studienarbeit f"ur die vier untersuchten Zufallszahlengeneratoren 
erzielten Ergebnisse vergleichend vorgestellt. Dabei wird f"ur die einzelnen Anforderungspunkte (siehe 
Kapitel~\ref{analyseverfahren}), soweit m"oglich, eine Reihenfolge der Zufallszahlengeneratoren bez"uglich 
ihrer Eigenschaften angegeben werden. Untersucht wurden die Generatoren LFSR, BBS, RC4 und EC. Die genauen 
Einzelheiten finden sich in den Unterpunkten der Kapitel~\ref{zzg} und~\ref{impl}. Zu beachten ist bei 
diesen Aufstellungen aber, dass die Ergebnisse implementationsabh"angig und teilweise gar nicht absolut
vergleichbar sind, weil mehrdimensionale Einstellm"oglichkeiten eine einfache Reihenfolge gar nicht zulassen. 
Dies ist aber bei den einzelnen Punkten vermerkt. Insofern dient dieses Kapitel als "Uberblick.

\paragraph{Zeitkomplexit"at} \quad \newline

Die zeitlichen Anforderungen an einen Zufallszahlengenerator sind gerade beim Chipkarteneinsatz sehr wichtig, 
da ein Warten auf die Chipkarte bzw. das Warten auf die so genannte Technik im Allgemeinen von den Benutzern 
als unangenehm empfunden wird. Nach M"oglichkeit sollen diese Vorg"ange vom Empfinden her als zeitlos angesehen 
werden. Nach den in Kapitel~\ref{komplexitaet} beschriebenen Einzelheiten bestehen alle Generatoren die 
Anforderungen. Es ergibt sich hierbei die Reihenfolge:

\begin{tabbing}
\hspace{6cm} 3. \= {\bf LFSR} \= = \= \kill \\
\hspace{6cm} {\bf 1.} \> {\bf RC4}  \> {\bf =} \>  \boldmath{$7,1424 \cdot 10^{6}~\frac{\mathrm{Bit}}{\mathrm{s}}$} \\
\hspace{6cm} {\bf 2.} \> {\bf LFSR} \> {\bf =} \>  \boldmath{$3,5712 \cdot 10^{6}~\frac{\mathrm{Bit}}{\mathrm{s}}$} \\
\hspace{6cm} {\bf 3.} \> {\bf BBS}  \> {\bf =} \>  \boldmath{$119~040~\frac{\mathrm{Bit}}{\mathrm{s}}$} \\
\hspace{6cm} {\bf 4.} \> {\bf EC}   \> {\bf =} \>  \boldmath{$5~910~\frac{\mathrm{Bit}}{\mathrm{s}}$} \\
\end{tabbing}

Der RC4-Generator liefert in der 4-Bit-Version 4 Bit pro Takt, bei Nutzung einer Version, die mehr Bits ausgibt, 
entsprechend mehr, allerdings mit stark steigendem Speicherbedarf. Es l"asst sich aber ohne weiteres die Geschwindigkeit 
beschleunigen. Der LFSR-Generator liefert pro Takt ein Bit unabh"angig von der Gr"o"se des benutzten Polynoms. Es 
besteht aber die M"oglichkeit der Parallelisierung (siehe \cite[S.434]{schneier}), die jedoch mit h"oherem Speicher- 
und Rechenaufwand verbunden ist. Bei dem BBS- bzw. EC-Generator entstammt der Wert einer Absch"atzung nach oben und der 
Annahme eines Modulus von 16~000~000 f"ur BBS und von 30~000 f"ur EC. Die allgemeinen Formeln finden sich in den 
Kapiteln~\ref{bbs} und~\ref{ecc}. Hier sei auf die M"oglichkeit von Akzeleratoren hingewiesen, die aber nichts an der 
Reihenfolge der Generatoren "andern w"urden, aber die Generierung beschleunigen w"urden.

\paragraph{Speicherbedarf} \quad \newline

Der Speicherbedarf, den ein Zufallszahlengenerator erfordert, ist ein Ausschlu"skriterium f"ur den Einsatz auf einer 
Chipkarte, da gerade hier die Chipfl"ache begrenzt ist. Ein Generator, dessen Speicherzellenanforderungen zu hoch sind, 
ist f"ur eine Chipkartenimplementation nicht tragbar. Die Ermittlung des Speicherzellenbedarfs ist in Kapitel~\ref{komplexitaet} 
beschrieben, und die Einzelheiten zu den unterschiedlichen Generatoren findet sich im Kapitel~\ref{impl}. Allerdings 
h"angt der Speicherzellenbedarf von mehreren Faktoren ab, das sind sowohl das benutzte Programm, die Implementation und 
insbesondere die verschiedenen Parameter, die die einzelnen Generatoren beeinflussen. Die genauen Abh"angigkeiten von der 
Periode, der Ausgabebreite, dem eingesetzten Modulus oder der Besetzungszahl finden sich in den Kapiteln~\ref{lfsr} bis~\ref{ecc}.
F"ur die Reihenfolge wurden die Einstellungen benutzt, die auch f"ur die Statistiktests benutzt wurden. Damit ergibt sich:

\newpage

\begin{tabbing}
\hspace{4cm} 3. \= {\bf LFSR} \= = \= \boldmath{$ f(16~834~033; 2)$} \= \kill \\
\hspace{4cm} {\bf 1.} \> {\bf LFSR} \> {\bf =} \>  \boldmath{$f(30; 4; 20)$}      \> \boldmath{$= 117~\mathrm{Speicherzellen~} ;(2^{30}-1)$} \\
\hspace{4cm} {\bf 2.} \> {\bf BBS}  \> {\bf =} \>  \boldmath{$f(16~834~033; 2)$}  \> \boldmath{$= 359~\mathrm{Speicherzellen~} ;(2~101~178)$} \\
\hspace{4cm} {\bf 3.} \> {\bf RC4}  \> {\bf =} \>  \boldmath{$f(20)$}             \> \boldmath{$= 671~\mathrm{Speicherzellen~} ;(10^{15})$} \\
\hspace{4cm} {\bf 4.} \> {\bf EC}   \> {\bf =} \>  \boldmath{$f(33~013; 4)$}      \> \boldmath{$= 707~\mathrm{Speicherzellen~} ;(7~388)$} \\
\end{tabbing}

In den Klammern hinter dem Speicherzellenbedarf ist die Periode angegeben, die die Bitsequenzen der Generatoren mit den
entsprechenden Einstellungen haben. Die genauen Zusammenh"ange zwischen Periode\footnote{Die Periode beim BBS-Generator ist
hier ein Fall der halben Periode, also $p_{2}q_{2}$ statt $2p_{2}q_{2}$.} und Speicherbedarf finden sich in den 
Kapiteln~\ref{lfsr} bis~\ref{rc4}. F"ur den EC-Generator liegen diesbez"uglich keine Zusammenh"ange vor. Die Einzelheiten zu 
den allgemeinen Formeln zum Ermitteln des Speicherbedarfs sind auch in den Kapiteln~\ref{lfsr} bis~\ref{ecc} zu finden. 
Der Speicherbedarf beim LFSR h"angt haupts"achlich linear vom  Polynomgrad ab, bei BBS und EC logarithmisch vom Modulus. 
Bei RC4 h"angt der Speicherbedarf haupts"achlich von der Gr"o"se des Permutationsnetzwerkes ab, die 5-Bit-Version ist erheblich 
aufw"andiger als die hier benutzte 4-Bit-Version, ansonsten ist der Speicherbedarf hier linear abh"angig von der Ausgabebreite.
Bei den vielf"altigen Einstellm"oglichkeiten sollten die Angaben des Speicherzellenbedarfs nicht absolut betrachtet 
werden, aber sie zeigen die oben angegebene Reihenfolge auf.

\paragraph{Leistungsaufnahme} \quad \newline

Ein weiteres wichtiges Kriterium f"ur einen Einsatz auf Chipkarten ist die Leistungsaufnahme, die hier in Form von kippenden 
Bits dargestellt wird. Die Einzelheiten finden sich wiederum in den Kapiteln~\ref{komplexitaet} und~\ref{lfsr} bis ~\ref{ecc}. 
F"ur die Erzeugung von 20-Bit-Zufallszahlen ergeben sich f"ur die Generatoren mit den Einstellungen, die auch in den Statistiktests 
benutzt wurden, folgende Ergebnisse:

\begin{tabbing}
\hspace{4cm} 3. \= {\bf LFSR} \= = \= \kill \\
\hspace{4cm} {\bf 1.} \> {\bf RC4}  \> {\bf =} \>  \boldmath{$\mathrm{~im~Mittel~} 39\mathrm{~kippende~Bits}$} \\
\hspace{4cm} {\bf 2.} \> {\bf LFSR} \> {\bf =} \>  \boldmath{$\mathrm{~im~Mittel~} 300\mathrm{~kippende~Bits}$} \\
\hspace{4cm} {\bf 3.} \> {\bf BBS}  \> {\bf =} \>  \boldmath{$\mathrm{~im~Mittel~} 7~643\mathrm{~kippende~Bits}$} \\
\hspace{4cm} {\bf 4.} \> {\bf EC}   \> {\bf =} \>  \boldmath{$\mathrm{~im~Mittel~} 69~916 \mathrm{~kippende~Bits}$} \\
\end{tabbing}

RC4 und LFSR gen"ugen hier ohne Probleme den Anforderungen, BBS sieht schon nach einer recht hohen Leistungsaufnahme aus, ob 
aber EC "uberhaupt bei der zu erwartenden hohen Anzahl an kippenden Bits noch f"ur den Chipkarteneinsatz taugt, m"usste von 
den entsprechenden Chipherstellern "uberpr"uft werden.

\paragraph{Qualit"at der erzeugten Zufallszahlen} \quad \newline

F"ur den Sicherheitsaspekt ist nat"urlich wichtig, wie zuf"allig die erzeugten Zahlen aussehen. Bedenklich ist der LFSR-Generator
wegen des effizienten {\it Berlekamp-Massey-Algorithmus'} (siehe Kapitel~\ref{lfsrvorstellung}). Der theoretisch beste Generator ist BBS 
(siehe Kapitel~\ref{lfsrvorstellung}). Zu EC existieren in der hier vorgestelleten Form keine theoretischen Grundlagen. RC4 wurde 
von Ron Rivest bei RSA Data Security Inc. entwickelt, die Namen sprechen f"ur sich, aber es ist nicht zu vergessen, dass es keine 
"offentlichen Texte zur Kryptoanalyse gibt (siehe~\cite[S.~455f.]{schneier}).

Allen Generatoren gemeinsam ist aber, dass sie die in Kapitel~\ref{statistikgrundlagen} beschriebenen Tests bestehen. Einzelheiten 
zu kritischen Werten sind in den Kapiteln~\ref{lfsrvorstellung} bis ~\ref{eccvorstellung} zu finden.


\paragraph{Fazit} \quad \newline

Abschlie"send l"asst sich sagen, dass RC4 der f"ur eine Chipkartenimplementation am besten geeignete Zufallszahlengenerator ist, auch 
wenn der Speicherbedarf das Gesamtbild etwas tr"ubt und auch das Patent auf diesem Verfahren mit Kosten verbunden ist. {\em Am schlechtesten 
schneidet der EC-Generator ab.} Welcher Generator nun am besten f"ur eine Implementation taugt, h"angt aber trotzdem von den 
einzelnen Anforderungen ab, die ja sehr verschieden sein k"onnen. Nicht zu vergessen trotz der gerade mal durchschnittlichen Werte des 
BBS-Generators sind die Eigenschaften des wahlfreien Zugriffs auf die Zufallszahlensequenz und die hohe Sicherheit. Das LFSR ist 
f"ur eine Kombination mit einem andern Generator oder innerhalb eines geschlossenen Systems eine Alternative.



% *************************************** Ausblick, Perspektiven**************************************

\subsection{Ausblick, Perspektiven \hspace{2.8cm}} \label{ausblickperspektiven}
\addtocontents{toc}{\vspace{-0.5cm} {\it \hspace{5cm}(von Stefan Witt)}}

In diesem abschlie"sendem Kapitel werden weiterf"uhrende Fragestellungen vorgestellt, die sich aus dieser
Studienarbeit ergeben. Der Grund, weshalb diese Fragen nicht an dieser Stelle gekl"art werden, ist, dass
sie den Umfang der Studienarbeit sprengen w"urden und sich f"ur weitere wissenschaftliche Arbeiten eignen.

\paragraph{Optimierung der Implementation} \quad \newline

Diese Studienarbeit ist auf die Bewertung verschiedener Zufallsgeneratoren und die Realisierbarkeit dieser
Generatoren auf Chipkarten fokussiert. Es wurde eine exemplarische Implementation durchgef"uhrt, um die
grunds"atzliche Umsetzung zu untersuchen.

Bei der Implementierung wurde aber nicht untersucht, inwieweit sich die Algorithmen zur Erzeugung von Zufallszahlen
bez"uglich des Zeit- und Platzbedarfs optimieren lassen. Zeitoptimierungen sind vor allem durch
Parallelisierung einzelner Berechnungsschritte m"oglich. Insbesondere trifft das bei dem Generator zu, der
elliptische Kurven benutzt, weil dort viele voneinander unabh"angige Rechnungen durchgef"uhrt werden, die
durch Nebenl"aufigkeit deutlich schneller als in der sequentiellen Implementation dieser Studienarbeit
sind. Interessant ist in diesem Zusammenhang auch die Fragestellung, welcher Grad an paralleler Verarbeitung
welchen Hardware- und Zeitaufwand verursacht.

Weiterhin w"are es w"unschenswert, die Implementationen in der Programmiersprache C so zu verbessern, dass sie -- wie
die VHDL-Implementation -- beliebige Wortl"angen zulassen und nicht durch die Maschinenwortbreite (meist 32 Bit)
beschr"ankt sind. Dazu k"onnte beispielsweise die GNU-MP-Library \texttt{gmp}\footnote{zu finden unter
\texttt{http://www.swox.com/gmp}} verwendet werden, die das Rechnen mit beliebig gro"sen Zahlen gestattet.


\paragraph{Parametrisierbare Chipkarten} \quad \newline

Es ist ebenfalls w"unschenswert, die Zufallsgeneratoren so zu implementieren, dass sie sich f"ur so genannte parametrisierbare Chipkarten eignen.
Parametrisierbare Chipkarten sind Chipkarten, auf denen der Endanwender Einstellungen vornehmen kann, beispielsweise
die "Anderung des Startwerts oder das "Uberspringen einer beliebigen Anzahl an Zufallszahlen.


\paragraph{Weitere Zufallsgeneratoren mit Elliptischen Kurven} \quad \newline

Es gibt verschiedene M"oglichkeiten, mit elliptischen Kurven Zufallszahlen zu erzeugen. In dieser Studienarbeit wurde
ein Zufallsgenerator vorgestellt, der einen Punkt auf der Kurve fortlaufend verdoppelt. Eine Untersuchung anderer
Verfahren zur Erzeugung von Zufallszahlen mit elliptischen Kurven w"are interessant, ist aber an dieser Stelle zu
umfangreich. Ein Algorithmus ist beispielsweise zu finden in~\cite{gong}.



% ************************************************************
% *****              Anhang A: Inhalt der CD             *****
% ************************************************************

\newpage
\appendix % Umschalten auf Anhang-Modus
\setcounter{section}{0}
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Literaturverzeichnis falsch im Inhaltsverzeichnis erscheint.
\addtocontents{toc}{\vspace{0.5cm} \hspace{-3mm} {\bf Anhang} \hspace{1mm} {\it (von Stefan Witt)}} % "Anhang" ins Inhaltsverzeichnis schreiben
\addtocontents{toc}{}         % ohne diese Leerzeile gibt's eine Fehlermeldung
\section{Inhalt der CD} \label{anhangcd}

Zu dieser Studienarbeit wurde eine CD-ROM erstellt, auf der die verschiedenen Implementationen, die zitierten
Internetseiten und weitere Daten zu finden sind. Die CD-ROM ist so gestaltet, dass mit einem beliebigen
Internetbrowser durch die CD navigiert werden kann. Dazu muss lediglich die Datei \texttt{index.html}
mit einem Browser ge"offnet werden (unter dem Betriebssystem ,,Windows`` geschieht das automatisch).

Zur "Ubersicht werden nun die Verzeichnisse mit den enthaltenen Dateien vorgestellt; die HTML-Dateien, die zur
Navigation enthalten sind, werden der Einfachheit halber weggelassen:

\begin{itemize}
\item Verzeichnis \texttt{Beispiel} (siehe Anhang~\ref{anhangsitzung}.1)
\vspace{-7mm}
\begin{tabbing}
\quad \texttt{Statistik-Kippbit\_Ausgabe.txt} \quad \= \kill\\
\quad \texttt{RC4.EXE}                        \> \parbox{8.3cm}{Ausf"uhrbarer RC4-Zufallsgenerator (f"ur ,,Windows``).} \\
\quad \> \quad \\
\quad \texttt{RC4\_Ausgabe.txt}               \> \parbox{8.3cm}{Bildschirmausgabe des RC4-Zufallsgenerators.} \\
\quad \> \quad \\
\quad \texttt{STATISTIK.EXE}                  \> \parbox{8.3cm}{Ausf"uhrbarer Statistik-Test des RC4-Zufalls\-ge\-ne\-ra\-tors.} \\
\quad \> \quad \\
\quad \texttt{Statistik\_Ausgabe.txt}         \> \parbox{8.3cm}{Bildschirmausgabe der RC4-Statistik-Untersuchung.}\\
\quad \> \quad \\
\quad \texttt{STATISTIK-KIPPBIT.EXE}          \> \parbox{8.3cm}{Ausf"uhrbarer Test der kippenden Bits des RC4-Zu\-fallsgenerators.} \\
\quad \> \quad \\
\quad \texttt{Statistik-Kippbit\_Ausgabe.txt} \> \parbox{8.3cm}{Bildschirmausgabe der Untersuchung der kippenden Bits des RC4-Zufallsgenerators.} \\
\end{tabbing}
\vspace{-7mm}
\item Verzeichnis \texttt{C-Implementation}
\vspace{-7mm}
\begin{tabbing}
\quad \texttt{lfsr\_waves (quer).pdf} \quad \= \kill\\
\quad \texttt{bbs-double.c}        \> \parbox{10cm}{Double-Variante des BBS-Generators.} \\
\quad \> \quad \\
\quad \texttt{bbs-int.c}           \> \parbox{10cm}{Integer-Variante des BBS-Generators.} \\
\quad \> \quad \\
\quad \texttt{BBS-Periode.txt}     \> \parbox{10cm}{Ergebnisse der Untersuchung der Periodengr"o"se des BBS-Generators.} \\
\quad \> \quad \\
\quad \texttt{BBS-Test.txt}        \> \parbox{10cm}{Exemplarischer Test der Periode des BBS-Generators.}\\
\quad \> \quad \\
\quad \texttt{Bitblock.h}          \> \parbox{10cm}{Prozeduren zum Laden und Speichern einzelner Bits in Bin"ardateien.} \\
\quad \> \quad \\
\quad \texttt{Blumzahlen.c}        \> \parbox{10cm}{Programm zur Erzeugung von Blumschen Zahlen. Diese werden  f"ur den BBS-Generator ben"otigt.} \\
\quad \> \quad \\
\quad \texttt{blumzahlen.txt}      \> \parbox{10cm}{Liste aller Blumschen Zahlen bis zu 1~000~000.}  \\
\quad \> \quad \\
\quad \texttt{EC.c}                \> \parbox{10cm}{Der Zufallsgenerator mit elliptischen Kurven.}  \\
\quad \> \quad \\
\quad \texttt{LFSR.c}              \> \parbox{10cm}{Linear r"uckgekoppeltes Schieberegister als Zufallsgenerator.}  \\
\quad \> \quad \\
\quad \texttt{Makefile}            \> \parbox{10cm}{Datei mit den "Ubersetzungsregeln f"ur den C-Compiler; wird vom \texttt{make}-Befehl benutzt.} \\
\quad \> \quad \\
\quad \texttt{RC4.c}               \> \parbox{10cm}{RC4-Zufallsgenerator.} \\
\quad \> \quad \\
\quad \texttt{RC4-periode.c}       \> \parbox{10cm}{Modifizierter RC4-Zufallsgenerator, der nach der Periode sucht.} \\
\quad \> \quad \\
\quad \texttt{Statistik.c}         \> \parbox{10cm}{Programm zur statistischen Untersuchung von Zufallszahlen.} \\
\quad \> \quad \\
\quad \texttt{Statistik-Kippbit.c} \> \parbox{10cm}{Programm zur Untersuchung der kippenden Bits zwischen aufeinanderfolgenden Zust"anden eines Zufallsgenerators.} \\
\end{tabbing}
\vspace{-7mm}
\item Verzeichnis \texttt{Text}
\vspace{-7mm}
\begin{tabbing}
\quad \texttt{lfsr\_waves (quer).pdf} \quad \= \kill\\
\quad \texttt{Arbeit.pdf}          \> \parbox{10cm}{Studienarbeit im PDF-Format (Achtung: Einige Formatierungen sind dabei nicht korrekt!).} \\
\quad \> \quad \\
\quad \texttt{Arbeit.ps}           \> \parbox{10cm}{Studienarbeit im Postscript-Format.} \\
\quad \> \quad \\
\quad \texttt{LaTeX} (Verzeichnis) \> \parbox{10cm}{\LaTeX-Quelldatei und Abbildungen. Die Bilder wurden mit \texttt{xfig}
erstellt; die \texttt{.fig}-Dateien sind hier neben den \texttt{.eps}-Dateien ebenfalls zu finden.} \\
\end{tabbing}
\vspace{-7mm}
\item Verzeichnis \texttt{VHDL-Implementation}
\vspace{-7mm}
\begin{tabbing}
\quad \texttt{lfsr\_waves (quer).pdf} \quad \= \kill\\
\quad \texttt{bbs\_pkg.vhd}        \> \parbox{10cm}{Konfigurationsdatei des BBS-Generators} \\
\quad \> \quad \\
\quad \texttt{bbs.vhd}             \> \parbox{10cm}{Implementation des BBS-Generators} \\
\quad \> \quad \\
\quad \texttt{tb\_bbs.vhd}         \> \parbox{10cm}{Testumgebung zur Simulation des BBS-Generators} \\
\quad \> \quad \\
\quad \texttt{ec\_pkg.vhd}         \> \parbox{10cm}{Konfigurationsdatei des EC-Generators} \\
\quad \> \quad \\
\quad \texttt{ec.vhd}              \> \parbox{10cm}{Implementation des EC-Generators} \\
\quad \> \quad \\
\quad \texttt{tb\_ec.vhd}          \> \parbox{10cm}{Testumgebung zur Simulation des EC-Generators} \\
\quad \> \quad \\
\quad \texttt{lfsr\_pkg.vhd}       \> \parbox{10cm}{Konfigurationsdatei des LFSR-Generators} \\
\quad \> \quad \\
\quad \texttt{lfsr.vhd}            \> \parbox{10cm}{Implementation des LFSR-Generators} \\
\quad \> \quad \\
\quad \texttt{tb\_lfsr.vhd}        \> \parbox{10cm}{Testumgebung zur Simulation des LFSR-Generators} \\
\quad \> \quad \\
\quad \texttt{rc4\_pkg.vhd}        \> \parbox{10cm}{Konfigurationsdatei des RC4-Generators} \\
\quad \> \quad \\
\quad \texttt{rc4.vhd}             \> \parbox{10cm}{Implementation des RC4-Generators} \\
\quad \> \quad \\
\quad \texttt{tb\_rc4.vhd}         \> \parbox{10cm}{Testumgebung zur Simulation des RC4-Generators} \\
\end{tabbing}
\vspace{-7mm}
\item Verzeichnis \texttt{VHDL-Simulation}
\vspace{-7mm}
\begin{tabbing}
\quad \texttt{lfsr\_waves (quer).pdf} \quad \= \kill\\
\quad \> \quad \\
\quad \texttt{bbs\_waves.pdf}        \> \parbox{10cm}{Blum-Blum-Shub-Generator mit den Parametern $n=1081$ (Modulus) und $x=42$ (Startwert) im PDF-Format.} \\
\quad \> \quad \\
\quad \texttt{bbs\_waves (quer).pdf} \> \parbox{10cm}{Dasselbe im Querformat.} \\
\quad \> \quad \\
\quad \texttt{bbs\_waves.ps}         \> \parbox{10cm}{Dasselbe als Postscriptdatei.} \\
\quad \> \quad \\
\quad \texttt{ec\_waves.pdf}         \> \parbox{10cm}{Zufallsgenerator mit elliptischen Kurven. Die Parameter sind $p=33013$ (Modulus), $a=2155$, $b=16008$ (Kurvenparameter) und der Startpunkt $x=3$, $y=150$ (PDF-Format).} \\
\quad \> \quad \\
\quad \texttt{ec\_waves (quer).pdf}  \>  \parbox{10cm}{Dasselbe im Querformat.} \\
\quad \> \quad \\
\quad \texttt{ec\_waves.ps}          \>  \parbox{10cm}{Dasselbe als Postscriptdatei.} \\
\quad \> \quad \\
\quad \texttt{lfsr\_waves.pdf}       \> \parbox{10cm}{Linear r"uckgekoppeltes Schieberegister mit dem Polynom $P(x) = x^{32} + x^{7} + x^{6} + x^{2} + x^{0}$ (=0x80000062) und dem Startwert 0xAAAAAAAA (PDF-Format).} \\
\quad \> \quad \\
\quad \texttt{lfsr\_waves (quer).pdf}\>  \parbox{10cm}{Dasselbe im Querformat.} \\
\quad \> \quad \\
\quad \texttt{lfsr\_waves.ps}        \> \parbox{10cm}{Dasselbe als Postscriptdatei.}  \\
\quad \> \quad \\
\quad \texttt{rc4\_waves.pdf}        \> \parbox{10cm}{RC4-Zufallsgenerator mit dem Standardschl"ussel (PDF-Format).} \\
\quad \> \quad \\
\quad \texttt{rc4\_waves (quer).pdf} \>  \parbox{10cm}{Dasselbe im Querformat.} \\
\quad \> \quad \\
\quad \texttt{rc4\_waves.ps}         \>  \parbox{10cm}{Dasselbe als Postscriptdatei.} \\
\end{tabbing}
\vspace{-7mm}
\item Verzeichnis \texttt{Internetseiten}
\vspace{-7mm}
\begin{tabbing}
\quad \texttt{xxxxxxxxxxxxxxxxxxxx} \quad \= \kill\\
\quad \> \quad \\
\texttt{citeseer.nj.nec.com} \> \parbox{10cm}{Die Quelle, die auf den Artikel von Guang Gong, Thomas A. Berson, Douglas R. Stinson (\dq Elliptic Curve Pseudorandom Sequence Generators\dq, 1998) verweist. Im Literaturverzeichnis der Studienarbeit ist der Artikel als~\cite{gong} bezeichnet.} \\
\quad \> \quad \\
\texttt{stat.fsu.edu} \> \parbox{10cm}{Programm zur Untersuchung der Unabh"angigkeit von Zufallszahlen.} \\
\quad \> \quad \\
\texttt{valley.interact.nl} \> \parbox{10cm}{Frei k"auflicher hardwarem"a"siger Zufallszahlengenerator.} \\
\quad \> \quad \\
\texttt{www.protego.se} \> \parbox{10cm}{Ein weiterer frei k"auflicher hardwarem"a"siger Zufallszahlengenerator.} \\
\quad \> \quad \\
\texttt{www.swox.com} \> \parbox{10cm}{Die GNU-MP-Library \texttt{gmp} f"ur Berechnungen mit beliebig gro"sen Zahlen.} \\
\quad \> \quad \\
\texttt{www.contestcen.com} \> \parbox{10cm}{Text zur Untersuchung des BBS-Generators.} \\
\end{tabbing}
\end{itemize}




% ************************************************************
% *****            Anhang B: Beispielsitzungen           *****
% ************************************************************

\newpage
\section{Beispielsitzungen} \label{anhangsitzung}

\subsection*{B.1\hspace{2mm}Schnelles Ausprobieren}

Zum bequemen Nachvollziehen der Arbeitsweise der Zufallsgeneratoren wird nun das Beispiel aus
Kapitel~\ref{testgleichverteilung} (Abschnitt ,,Durchf"uhrung der Tests mit Rechnerunterst"utzung``, S.~\pageref{rechner})
mithilfe der CD-ROM nachvollzogen. Dort wurde der 4-Bit-RC4-Zufallsgenerator unter Benutzung des Standardschl"ussels
untersucht.

Die einzelnen Schritte zur Erzeugung und Untersuchung der Zufallszahlen werden im Folgenden dargestellt. S"amtliche
notwendigen Dateien befinden sich im Verzeichnis \texttt{Beispiel} der beiliegenden CD (vgl. Anhang~\ref{anhangcd}).
Die vorkompilierten Programme laufen nur unter dem Betriebssystem ,,Windows``; f"ur andere Betriebssysteme m"ussen
die Quelltexte einfach "ubersetzt werden.


\begin{enumerate}
\item Kopieren Sie die Dateien aus dem Verzeichnis \texttt{Beispiel} der beiliegenden CD auf die lokale Festplatte,
und wechseln Sie in das lokale Verzeichnis, in das Sie die Dateien kopiert haben.
\item Starten Sie das Programm \texttt{RC4.EXE}, um die Zufallszahlen mit dem RC4-Generator zu erzeugen. Die Zahlen
aus Tabelle~\ref{statistikbeispiel} (Seite~\pageref{statistikbeispiel}) werden ausgegeben und in die Datei
\texttt{rc4.zz} geschrieben. Die durchlaufenen Zust"ande werden in der Datei \texttt{rc4-zustand.log} gespeichert.
\item Starten Sie das Programm \texttt{STATISTIK.EXE}. Es erscheint das Ergebnis der Statistiktests, bei denen
die bit- und blockweisen Wahrscheinlichkeiten gepr"uft werden. Die Ausgabe entspricht derjenigen aus
Kapitel~\ref{testgleichverteilung}  (Abschnitt ,,Durchf"uhrung der Tests mit Rechnerunterst"utzung``,
S.~\pageref{rechner}ff.).
\item Starten Sie das Programm \texttt{STATISTIK-KIPPBIT.EXE}. Es untersucht, wie viele Bits bei der Erzeugung einer
neuen Zufallszahl kippen, wie in Kapitel~\ref{hardwarekriterien} beschrieben.
\end{enumerate}


\vspace{5mm}
\subsection*{B.2\hspace{2mm}Beispiel: Entwurf eines Schieberegisters}

Um mit den Implementationen tiefer gehend vertraut zu werden, wird nun exemplarisch ein lineares Schieberegister
entworfen, mit C simuliert und anschlie"send mit VHDL umgesetzt. Dazu sind ein C-Compiler und ein VHDL-Compiler
notwendig (hier werden \texttt{gcc} bzw. \texttt{vhdlan} benutzt).

Das Schieberegister soll 20 Bit breit sein und 1 Bit breite Zufallszahlen erzeugen; der Startwert des Registers soll
0101~0101~0101~0101~0101 sein. Dazu wird das primitive Polynom $P(x)=x^{20}+x^{3}+x^{0}$ gew"ahlt.


\paragraph{Umsetzung in C} \quad \newline

Zuallererst muss der C-Quelltext von der CD-ROM auf Festplatte kopiert werden, weil sonst die Dateien nicht
zur"uckgeschrieben werden k"onnen. Notwendig sind die Dateien \texttt{Bitblock.h}, \texttt{LFSR.c},
\texttt{Makefile}, \texttt{Statistik.c} und \texttt{Statistik-Kippbit.c} aus dem Verzeichnis \texttt{C-Implementation}.

Der C-Quellcode \texttt{LFSR.c} muss nach den gestellten Anforderungen angepasst werden. Dazu m"ussen folgende
Einstellungen vorgenommen werden (die Einstellungen sind im Detail in Kapitel~\ref{impl} und im C-Quelltext
beschrieben):

\begin{verbatim}
#define BITBREITE 20
#define ANFANGSZUSTAND 0xaaaaa           // hexadezimaler Anfangszustand
#define POLYNOM 0x80004                  // Polynom
#define AUSGABEHOCH 1                    // Ausgabebits
#define AUSGABENIEDRIG 1
#define EINMAL_SCHIEBEN false
#define ANZAHL ((double) 1048576)
#define TESTE_PERIODE true
#define DATEIAUSGABE true                // Zahlen in Datei schreiben
#define DATEINAME "lfsr.zz"
#define KONSOLE false
#define ZUSTANDLOG true                  // kippende Bits untersuchen
#define LOGDATEINAME "lfsr-zustand.log"
\end{verbatim}

Nach dem Speichern wird das Programm mit dem Befehl \texttt{make LFSR} kompiliert und kann mit dem Aufruf
\texttt{LFSR} gestartet werden. Das Programm gibt folgendes aus:
\begin{Verbatim}[commandchars=\\\{\}, fontsize=\small]
Periode gefunden bei 1048575.
Warnung: Letztes Byte mit 4 Nullen aufgef\"ullt.
\end{Verbatim}
Da die Ausgabe auf der Konsole abgeschaltet wurde, werden die Zufallszahlen nicht
ausgegeben; sie werden aber in der Datei \texttt{lfsr.zz} gespeichert. Der Zufallsgenerator gibt die erwartete
Periode von $2^{n}-1=1048575$ aus (Achtung: Wenn die Ausgabebitbreite erh"oht wird und \texttt{EINMAL\_SCHIEBEN}
auf \texttt{true} gesetzt ist, sinkt die Periode, weil hier nicht die Zahl der Bits, sondern die Anzahl
der erzeugten Zufallszahlen (also Bl"ocke) angegeben wird). Zus"atzlich weist das LFSR-Programm darauf hin, dass
die Ausgabedatei mit Nullen aufgef"ullt werden musste, weil die Zufallszahlen nicht exakt in die Datei gepasst haben,
da die Anzahl der erzeugten Bits nicht durch 8 teilbar war.


\paragraph{Statistische Untersuchung} \quad \newline

Um die zuvor erzeugten Zufallszahlen zu untersuchen, muss der C-Quelltext \texttt{Statistik.c} konfiguriert
werden, und zwar so:

\begin{verbatim}
#define DATEINAME "lfsr.zz"
#define BITBREITE 1
#define KONSOLE false
\end{verbatim}

Durch die Eingabe von \texttt{make Statistik} wird der Quellcode kompiliert, und mit dem Befehl \texttt{Statistik}
wird das Programm aufgerufen. Die Ausgabe sieht folgenderma"sen aus:
\begin{Verbatim}[commandchars=\\\{\}, fontsize=\scriptsize]
Warnung: Die letzten 8 Eintr\"age k\"onnten aufgef\"ullte Nullen sein.
1048576 Zufallszahlen aus der Datei lfsr.zz geladen (Bitbreite=1 Bit).
 
 
*********** TEST: Anzahl der Einsen, aus denen die Zufallszahl bestehen ***********
 
Anz. Einsen|theoret. H\"auf.|  H\"aufigkeit |th.H\"auf.-H\"auf. |approx. Normalvert. |Abw. H\"auf.-Normalvert.
-----------|--------------|-------------|---------------|--------------------|----------------------
      0    |    524288.000|       524287|         1.000 |         507448.421 |     16838.579
      1    |    524288.000|       524289|        -1.000 |         507450.357 |     16838.643
-----------|--------------|-------------|---------------|--------------------|----------------------
   SUMME   |   1048576.000|      1048576|         0.000 |        1014898.778 |     33677.222
 
Chi-Quadrat-Test:
Chi^2 =   0.000 mit n=2 Freiheitsgraden
 
Theoretische Verteilung:
Erwartungswert     = 0.5000
Standardabweichung = 0.5000
 
Approximierte Normalverteilung (d.h. tats\"achliche Verteilung):
Stichprobenmittel              = 0.5000 +/- 0.0016 Einsen
Stichproben-Standardabweichung = 0.5000 Einsen
 
 
*********** TEST: H\"aufigkeit der Zufallszahlen ***********
 
 Bitkombination | theoret. H\"auf. |   H\"aufigkeit  |    Differenz
----------------|----------------|---------------|---------------
              0 |     524288.000 |        524287 |          1.000
              1 |     524288.000 |        524289 |         -1.000
----------------|----------------|---------------|---------------
      SUMME     |    1048576     |       1048576 |          0
 
Chi-Quadrat-Test:
Chi^2 =   0.000 mit n=2 Freiheitsgraden
\end{Verbatim}

Um die kippenden Bits des LFSR-Generators zu untersuchen, muss das Programm \texttt{Statistik-Kippbit.c} angepasst
werden:
{\small
\begin{verbatim}
#define BITBREITE 20
#define ANZAHL_VAR 1
#define LOGDATEINAME "lfsr-zustand.log"
\end{verbatim}
}
Das Programm wird mit \texttt{make Statistik-Kippbit} kompiliert und mit \texttt{Statistik-Kippbit} aufgerufen.
Es liefert diese Ausgabe:
\begin{Verbatim}[commandchars=\\\{\}, fontsize=\scriptsize]
Warnung: Ignoriere 4 Bits am Dateiende.
1048577 Zust\"ande zu je 1 Variablen aus der Datei lfsr-zustand.log geladen (Bitbreite=20 Bit).
 
 
*********** TEST: Anzahl der kippenden Bits bei Zustandswechsel ***********
 
 Anz. Wechsel |   H\"aufigkeit  | approx. Normalvert.
--------------|---------------|--------------------
        0     |             0 |            8.493
        1     |            20 |           56.784
        2     |           190 |          310.835
        3     |          1140 |         1393.068
        4     |          4845 |         5111.592
        5     |         15504 |        15356.114
        6     |         38760 |        37770.057
        7     |         77520 |        76059.793
        8     |        125970 |       125401.817
        9     |        167960 |       169275.345
       10     |        184756 |       187078.884
       11     |        167960 |       169276.636
       12     |        125970 |       125403.731
       13     |         77520 |        76061.534
       14     |         38760 |        37771.209
       15     |         15504 |        15356.699
       16     |          4845 |         5111.826
       17     |          1140 |         1393.142
       18     |           190 |          310.854
       19     |            20 |           56.788
       20     |             2 |            8.494
--------------|---------------|---------------------
     SUMME    |   1048576.000 |      1048573.693
 
Approximierte Normalverteilung (d.h. tats\"achliche Verteilung):
Stichprobenmittel              = 10.0000 +/- 0.0072 Einsen
Stichproben-Standardabweichung = 2.2361 Einsen
\end{Verbatim}


\paragraph{Umsetzung in VHDL} \quad \newline

Um das Schieberegister in VHDL umzusetzen, m"ussen die Quelltexte \texttt{lfsr\_pkg.vhd}, \texttt{lfsr.vhd} \\
und \texttt{tb\_lfsr.vhd} von der CD-ROM auf Festplatte kopiert werden, weil die Dateien ge"andert werden.

Zur Einstellung des Schieberegisters muss die Datei \texttt{lfsr\_pkg.vhd} wie folgt parametrisiert werden:
{\scriptsize
\begin{verbatim}
constant BITBREITE:        integer := 20;
constant STARTWERT:        std_logic_vector((BITBREITE-1) downto 0) := "10101010101010101010";
constant POLYNOM:          std_logic_vector((BITBREITE-1) downto 0) := "10000000000000000100";
constant AUSGABEHOCH:      integer := 1;
constant AUSGABENIEDRIG:   integer := 1;
constant AUSGABEBREITELOG: integer := 1;
\end{verbatim}
}

\enlargethispage{1cm}
Vor dem Kompilieren muss unter Unix das Verzeichnis \texttt{WORK} angelegt werden. Dann werden die VHDL-Programme
mit \texttt{vhdlan lfsr\_pkg.vhd} und \texttt{vhdlan lfsr.vhd} "ubersetzt. Die Testumgebung f"ur die Simulation
wird mit \texttt{vhdlan tb\_lfsr.vhd} kompiliert. Der \texttt{SYNOPSYS}-Simulator wird mit \texttt{vhdldbx} gestartet.


% ************************************************************
% *****               Literaturverzeichnis               *****
% ************************************************************

\newpage
\addtocontents{toc}{}         % Zum Inhaltsverzeichnis muss eine Leerzeile zugefügt werden, weil
                              % sonst das Literaturverzeichnis falsch im Inhaltsverzeichnis erscheint.
\begin{thebibliography}{99}   % maximale Breite auf 99 Zeichen

\bibitem[Agnew 87]{agnew}
        G. B. Agnew: {\it Random Sources for Cryptographic Systems},
        Advances in Cryptology - EUROCRYPT 87 Proceedings, Springer 1988

\bibitem[Bauer 97]{bauer}
        Friedrich L. Bauer: {\it Entzifferte Geheimnisse},
        Springer-Verlag, 2. Auflage 1997

\bibitem[Bartsch 97]{bartsch}
        Hans-Jochen Bartsch: {\it Taschenbuch mathematischer Formeln},
        Fachbuchverlag Leipzig, 17. Auflage 1997

\bibitem[Barnick]{barnick}
        Katrin Barnick: {\it Chip statt Magnetstreifen},
        Entertainment Markt, Nr. 12, 15. Juni 2001

\bibitem[Biggs 89]{biggs}
        Norman L. Biggs: {\it Discrete Mathematics},
        Oxford University Press, Revised Edition 1989

\bibitem[Blum 86]{blum}
        L. Blum, M. Blum, M. Shub, {\it A Simple Unpredictable Pseudo-Random Number Generator},
        Siam Journal on Computing, V. 15, N. 2, 1986, S.~364-383

\bibitem[Fairfield 84]{fairfield}
        R. C. Fairfield, A. Matusevich, J. Plany: {\it An LSI Digital Encryption Processor (DEP)},
        Advances in Cryptology: Proceedings of CRYPTO 84, Springer 1985

\bibitem[Gong 98]{gong}
        Guang Gong, Thomas A. Berson, Douglas R. Stinson:
        {\it Elliptic Curve Pseudorandom Sequence Generators}, 1998,
        \texttt{http://citeseer.nj.nec.com/65929.html}

\bibitem[H"artel 94]{dissertation}
        Frank H"artel: {\it Zufallszahlen f"ur Simulationsmodelle},
        Difo-Druck GmbH, Bamberg 1994

\bibitem[Hogben 63]{hogben}
        Lancelot Hogben: {\it Die Entdeckung der Mathematik - Zahlen formen ein Weltbild},
        Chr. Belser Verlag Stuttgart 1963

\bibitem[H"ubner 96]{huebner}
        Gerhard H"ubner: {\it Stochastik},
        Viewig \& Sohn Verlagsgesellschaft, Braunschweig/Wiesbaden 1996

\bibitem[IEEE P1363 / D13]{ieee}
        IEEE P1363 / D13: {\it Standard Specifications for Public Key Cryptography},
        Anhang A, Number-Theoretic Background, 1999

\bibitem[Kahn 96]{kahn}
        David Kahn, THE Codebreakers: {\it The Story Of Secret Writing},
        SCRIBNER 1996

\bibitem[Knuth 98]{knuth}
        Donald Erwin Knuth: {\it The Art Of Computer Programming - Third Edition, Volume 2
        -- Seminumerical Algorithms}, Addison Wesley Longman, 3. Auflage 1998

\bibitem[Lehmer 51]{lehmer}
        D. H. Lehmer: {\it Proc. 2nd Symposium on Large-Scale Digital Computing Machinery},
        Cambridge: Harvard University Press 1951

\bibitem[Massey 69]{massey1}
        James L. Massey: {\it Shift-Register Synthesis and BCH Decoding},
        IEEE Transactions on Information Theory, V. it-15, N. 1, 1969, S.~122-127

\bibitem[Massey 69]{massey2}
        James L. Massey: {\it Cryptography and System Theory},
        Proceedings of the 24th Allerton Conference on Communicaton, Control and Computers, 1986, S.~1-8

\bibitem[Maurer 90]{maurer}
        Ueli M. Maurer: {\it A Universal Statistical Test for Random Bit Generators},
        A.J. Menezes, S.A.Vanstone (Hrsg.): Advances in Cryptology - CRYPTO '90 Proceedings,
        Springer-Verlag Heidelberg 1991, S.~409 - 420 

\bibitem[Neuhaus 95]{neuhaus}
        Klaus Behnen, Georg Neuhaus: {\it Grundkurs Stochastik -
        Eine integrierte Einf"uhrung in Wahrscheinlichkeitstheorie und mathematische Statistik},
        Teubner, 3. Auflage 1995

\bibitem[Odlyzko 84]{odlyzko}
        A. Odlyzko: {\it Discrete Logarithms in Finite Fields and Their Cryptographic Significance},
        Advances in Cryptology: Proceedings of EUROCRYPT 84, Springer 1985

\bibitem[Rabin 68]{rabin68}
        M. O. Rabin: {\it Probabilistic Algorithms in Finite Fields},
        SIAM Journal on Computing, V. 9, N. 2, 1980, S.~273-280

\bibitem[Rabin 76]{rabin76}
        M. O. Rabin: {\it Probabilisic algorithms},
        New directions and recent results in algorithms and complexity, 1976

\bibitem[RAND 55]{rand}
        RAND Corporation: {\it A Million Random Digits with 100.000 Normal Deviates},
        Glencoe, IL: Free Press Publishers, 1955

\bibitem[Rankl 99]{chipbuch}
        Wolfgang Rankl, Wolfgang Effing: {\it Handbuch der Chipkarten}, Hanser Verlag, 3. Auflage 1999

\bibitem[Rechenberg 97]{informatikhandbuch}
        Gustav Pomberger, Peter Rechenberg: {\it Informatik-Handbuch},
        Hanser 1997

\bibitem[Richter 92]{richter}
        Manfred Richter: {\it Ein Rauschgenerator zur Gewinnung von quasi-idealen Zufallszahlen f"ur die stochastische 
        Simulation}, TU Aachen 1992, Dissertation

\bibitem[RSA 78]{rsa}
        Ron Rivest, Adi Shamir, Leonard Adleman: {\it A Method for Obtaining Digital Signatures and Public-Key 
        Cryptosystems}, Communications of the ACM, V. 21, N. 2, 1978

\bibitem[Rueppel 86]{rueppel}
        Rainer A. Rueppel: {\it Analysis and Design of Stream Ciphers},
        Springer Verlag 1986

\bibitem[Schiffmann 96]{schiffmann}
        Wolfram Schiffmann, Robert Schmitz: {\it Technische Informatik 1 - Grundlagen der digitalen Elektronik},
        Springer, 3. Auflage 1996

\bibitem[Schneier 96]{schneier}
        Bruce Schneier: {\it Angewandte Kryptographie}, Addison-Wesley 1996

\bibitem[Selmer 66]{selmer}
        E. S.~Selmer: {\it Linear Recurrence over Finite Field},
        University of Bergen, Norwegen, 1966

\bibitem[Shannon 49]{shannon}
        Claude E. Shannon, {\it The Communication Theory of Secrecy Systems},
        Bell System Technical Journal, 1949

\bibitem[Tanenbaum 96]{tanenbaum}
        Andrew S.~Tanenbaum: {\it Computernetzwerke},
        Prentice Hall, 3. Auflage 1996

\bibitem[Vazirani 84]{vazirani}
        U.V. Vazirani, V.V. Vazirani, {\it Efficient and Secure Pseudo-Random Number Generation},
        Proceedings of the 25th Symposium on the Foundations of Computer Science, 1984, S.~458-463

\end{thebibliography}


% ************************************************************
% *****      Erklärung, dass die Arbeit von uns ist      *****
% ************************************************************
\newpage
\thispagestyle{empty}

\vspace{3cm}

\paragraph{\hspace{7.5cm} Erkl"arung} \quad \newline

\vspace{3cm}

Hiermit erkl"aren wir, dass wir die vorliegende Studienarbeit selbstst"andig erstellt und keine
anderen Hilfsmittel als die angegebenen verwendet haben.

\vspace{3cm}

\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}
\hspace{4.9cm}
\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}\_\hspace{-1mm}

Peter Hartmann \hspace{6.8cm} Stefan Witt



% ***** 2 Leerseiten, so dass die Erklärung nicht auf der Rückseite der Studienarbeit ist
\newpage
\thispagestyle{empty} % Leerseite, damit die Einleitung auf der rechten Seite beginnt
~
\newpage

\thispagestyle{empty} % Leerseite, damit die Einleitung auf der rechten Seite beginnt
~


% ************************************************************
% *****                      Ende                        *****
% ************************************************************

\end{document}
