diff --git a/main.tex b/main.tex
index 954d43f0fff700b6ec0ae21af73723a7c0809f51..00befffa3fa4201a25c5f0bb25c026b90362466f 100644
--- a/main.tex
+++ b/main.tex
@@ -947,7 +947,7 @@ in Abhängigkeit von \(d\) und \(p_\Gamma\) berechnen.
 
 %TODO ref Kap. 13
 Der Erfolg unserer Angriffe ist abhängig von den Linearitäten bzw.\@ den
-Differenztabellen -- diese werden wir uns später in Kapitel%~\ref{}
+Differenztabellen -- diese werden wir uns später in Kapitel 13%~\ref{}
 angucken.  Auch verringern mehrere aktive parallele S-Boxen die
 Erfolgswahrscheinlichkeit (s.\@ Sätze~\ref{thm:piling-up-lemma}
 und~\ref{thm:piling-up-lemma-diff}) -- wir möchten also die Permutation
@@ -1389,11 +1389,11 @@ wiefolgt aus:
 
 \section{Stromchiffren}
 
-Stromchiffren basieren auf der Idee eine pseudozufllige Folge aus einem Schlüssel
+Stromchiffren basieren auf der Idee eine pseudozufällige Folge aus einem Schlüssel
 abzuleiten -- diese wird dann mit dem zu chiffrierenden Text verknüpft.  Eine
 übliche Art Stromchiffren zu bauen sind Linear Feedback Shift Registers (LFSRs).
 Sie können sehr einfach in Hardware über eben Shift Register realisiert werden
-und bieten einen kontinuierliechen Schlüsselstrom.  Wir beschäftigen uns nun
+und bieten einen kontinuierlichen Schlüsselstrom.  Wir beschäftigen uns nun
 zuerst mit dem Aufbau und der mathematischen Modellierung.
 
 \subsection{Linear Feedback Shift Register}
@@ -1405,6 +1405,57 @@ Vektor aus (öffentlich bekannten) sogenannten Rückkopplungskoeffizienten
 \]
 Der Schlüsselstrom wird berechnet, indem das Shiftregister mit dem Schlüssel
 \(k_0,\dotsc,k_{10}\) initialisiert wird.  In jedem Takt wird an den Stellen mit
-\(a_i=1\)
+\(a_i=1\) der aktuelle Wert des Registers abgenommen und diese Werte miteinander
+addiert.  Dieses Ergebnis wird wiederum links ins Register zurück eingespielt.
+%TODO grafik
+
+Formal besteht ein LFSR also aus einem Initialzustand \((k_0,\dotsc,k_{10})\in\GF_2^n\)
+aus dem eingesetzten Repo bei einer Registerlänge von \(n\), einem ebensolangen
+Rückkopplungskoeffizienten \((a_0,\dotsc,a_{10})\).  Dann erfüllt der Schlüsselstrom
+aus \(k_t\) mit \(t\geq n-1\) nach folgender Gleichung:
+\[
+	k_t := a_0 k_{t-n} \xor \dotsb \xor a_{n-1} k_{t-1}
+\]
+
+Erste Beobachtungen ergeben, dass für einen Initialzustand von \((0,\dotsc,0)\)
+eine Nullfolge generiert wird.  Ist der Initialzustand jedoch nicht der
+NUllvektor und ist der \enquote{letzte} Rückkopplungskoeffizient \(a_0\neq 0\),
+dann wird der erzeugte Schlüsselstrom nie \(n\) viele Nullen hintereinander
+ausgeben, also
+\[
+	(k_{t-n},\dotsc,k_{t-1} \neq (0,\dotsc,0), \qquad \forall t\geq n
+\]
+Weiterhin ist der Schlüsselstrom periodisch mit einer maximalen Periode von
+\(2^n -1\).  Dadurch, dass es auch maximal \(2^n -1\) verschiedene \(n\)-Tupel
+ungleich des Nullvektors gibt, muss spätestens nach so vielen Takten der erste
+Zustand wieder im LFSR\@.
+
+Zudem können wir bei einer gegebenen Bitfolge mit Periode \(N\) ein LFSR mit
+Registerlänge \(N\) und der Rückkopplung \(a_0=1\) und \(a_1=\dotsb=a_{N-1}=0\)
+bauen, welches diese Bitfolge generiert.  Wir werden später den besseren
+Berlekamp-Massey-Algorithmus kennenlernen.
+
+Wichtig ist: LFSRs sind alleine nicht sicher, da wir eine einfache known-plaintext
+Attacke durchführen können, indem wir \(n\) Plaintexte \(m_t,\dotsc,m_{t+n}\)
+mit den zugehörigen Ciphertexten \(c_i=m_i\xor k_i\) sammeln.  Wir können nun
+direkt einen \(n\) langen Teil des Schlüsselstroms errechnen:
+\[
+	(k_t,\dotsc,k_{t+n}) = (m_t,\dotsc,m_{t+n}) \xor (c_t,\dotsc,c_{t+n})
+\]
+Mit diesem lassen sich dann auch die Nachfolger (und Vorgänger) berechnen.
+Wir nutzen also LFSRs nur als Bausteine für eine komplette Chiffre, indem wir
+mehrere kombinieren und eine Auswahlfunktion \(f\) auf die Ausgaben der einzelnen
+LFSRs anwenden, die für jedes Output-Bit der Gesamtchiffre spezifiziert, welches
+LFSR konkret verwendet wird.
+
+Wir betrachten nun jedoch erstmal einzelne LFSRs und möchten wissen, welche
+eine maximale Periode haben um eine möglichst \enquote{gute} Chiffre zu erhalten.
+Als Angreifer wollen wir dann untersuchen, wie wir bei einem gegebenen Bitstrom
+den Rückkopplungskoeffizienten bestimmen können.  Abschließend werden wir uns dann
+mit der Auswahlfunktion beschäftigen, und welche Angriffe es darauf gibt.
+
+\paragraph{Algebraische Beschreibung des Schlüsselstroms}
+
+
 
 \end{document}