From 4894a2a01fb072dc0ebf5133993832fbcfe5244c Mon Sep 17 00:00:00 2001 From: Reto Fritsche Date: Sun, 29 Aug 2021 23:57:01 +0200 Subject: created example, made some succested correction/improvements --- buch/papers/mceliece/aufbau.tex | 103 +--------- buch/papers/mceliece/einleitung.tex | 6 +- buch/papers/mceliece/fazit.tex | 20 +- buch/papers/mceliece/funktionsweise.tex | 337 ++++++++++++++++++++++++++++++-- 4 files changed, 337 insertions(+), 129 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/aufbau.tex b/buch/papers/mceliece/aufbau.tex index 200cb7b..0849fc1 100644 --- a/buch/papers/mceliece/aufbau.tex +++ b/buch/papers/mceliece/aufbau.tex @@ -11,16 +11,6 @@ Das McEliece-Kryptosystem besteht aus folgenden Elementen: \label{mceliece:subsection:d_k}} In diesem Vektor der Länge $k$ sind die zu verschlüsselnden Daten enthalten. -Beispiel: -\[d_4= -\begin{pmatrix} - 1\\ - 1\\ - 1\\ - 0 -\end{pmatrix} -\] - \subsection{Binäre Zufallsmatrix $S_k$ \label{mceliece:subsection:s_k}} $S_k$ ist eine Binäre Zufallsmatrix der Grösse $k \times k$. @@ -30,26 +20,6 @@ wobei danach mithilfe des Gauss-Algorithmus deren Inverse bestimmt werden kann. Da eine solche Matrix möglicherweise singulär ist, muss in diesem Fall eine neue Zufallsmatrix erzeugt werden. Für grössere Matrizen existieren bessere Methoden, auf welche hier nicht weiter eingegangen wird \cite{mceliece:GenerationRandMatrix}. -Beispiel: -\[S_4= - \begin{pmatrix} - 0 & 0 & 1 & 1\\ - 0 & 0 & 0 & 1\\ - 0 & 1 & 0 & 1\\ - 1 & 0 & 0 & 1 - \end{pmatrix} -\] - -\[ - S_4^{-1}= - \begin{pmatrix} - 0 & 1 & 0 & 1\\ - 0 & 1 & 1 & 0\\ - 1 & 1 & 0 & 0\\ - 0 & 1 & 0 & 0\\ - \end{pmatrix} -\] - \subsection{Linear-Code-Generatormatrix $G_{n,k}$ \label{mceliece:subsection:g_nk}} Das wichtigste Element des McEliece-Systems ist ein fehlerkorrigierender Code, @@ -63,52 +33,11 @@ wird das Codewort länger als das Datenwort, es wird also Redundanz hinzugefügt, um die Fehlerkorrektur möglich zu machen. -Beispiel -\[ - G_{7,4}= - \begin{pmatrix} - 1 & 0 & 0 & 0\\ - 1 & 1 & 0 & 0\\ - 0 & 1 & 1 & 0\\ - 1 & 0 & 1 & 1\\ - 0 & 1 & 0 & 1\\ - 0 & 0 & 1 & 0\\ - 0 & 0 & 0 & 1 - \end{pmatrix} -\] - \subsection{Permutations-Matrix $P_n$ \label{mceliece:subsection:p_n}} Mit der zufällig generierten Permutationsmatrix $P_n$ wird die Reihenfolge der Bits geändert. Mit der Inversen $P_n^{-1}$ kann die Bitvertauschung rückgängig gemacht werden. -Beispiel -\[ - P_7= - \begin{pmatrix} - 0 & 1 & 0 & 0 & 0 & 0 & 0\\ - 0 & 0 & 0 & 0 & 0 & 0 & 1\\ - 0 & 0 & 0 & 0 & 0 & 1 & 0\\ - 0 & 0 & 1 & 0 & 0 & 0 & 0\\ - 0 & 0 & 0 & 1 & 0 & 0 & 0\\ - 1 & 0 & 0 & 0 & 0 & 0 & 0\\ - 0 & 0 & 0 & 0 & 1 & 0 & 0 - \end{pmatrix} -\] -, -\[ - P_7^{-1}=P_7^t= - \begin{pmatrix} - 0 & 0 & 0 & 0 & 0 & 1 & 0\\ - 1 & 0 & 0 & 0 & 0 & 0 & 0\\ - 0 & 0 & 0 & 1 & 0 & 0 & 0\\ - 0 & 0 & 0 & 0 & 1 & 0 & 0\\ - 0 & 0 & 0 & 0 & 0 & 0 & 1\\ - 0 & 0 & 1 & 0 & 0 & 0 & 0\\ - 0 & 1 & 0 & 0 & 0 & 0 & 0 - \end{pmatrix} -\] - \subsection{Public-Key $K_{n,k}$ \label{mceliece:subsection:k_nk}} Der öffentliche Schlüssel, welcher zum Verschlüsseln verwendet wird, @@ -117,20 +46,6 @@ berechnet sich aus den bereits bekannten Matrizen wiefolgt: K_{n,k}=P_{n}\cdot G_{n,k}\cdot S_{k}\,. \] -Beispiel -\[ - K_{7,4}= - \begin{pmatrix} - 0 & 0 & 1 & 0\\ - 1 & 0 & 0 & 1\\ - 0 & 0 & 1 & 1\\ - 1 & 1 & 1 & 1\\ - 0 & 1 & 0 & 1\\ - 0 & 1 & 0 & 0\\ - 1 & 0 & 0 & 0 - \end{pmatrix} -\] - \subsection{Fehler-Vektor $e_n$ \label{mceliece:subsection:e_n}} Dieser Vektor der Länge $n$ besteht aus $t$ Einsen, welche zufällig innerhalb des Vektors angeordnet sind, @@ -138,24 +53,10 @@ alle anderen Einträge sind Null. Dieser Fehlervektor besitzt also gleich viele Einer, wie die Anzahl Fehler, die der Linearcode der Generatormatrix $G_{n,k}$ zu korrigieren vermag. -Beispiel -\[ - E_7= - \begin{pmatrix} - 0\\ - 0\\ - 1\\ - 0\\ - 0\\ - 0\\ - 0 - \end{pmatrix} -\] - \subsection{Daten-Vektor $d_k$ \label{mceliece:subsection:d_k}} -In diesem Vektor der länge $k$ ist die Nachricht (oder einen Teil davon) enthalten. +In diesem Vektor der Länge $k$ ist die Nachricht (oder einen Teil davon) enthalten. \subsection{Code-Vektor $c_n$ \label{mceliece:subsection:c_n}} -In diesem Vektor der länge $n$ ist die verschlüsselte Nachricht (oder einen Teil davon) enthalten. \ No newline at end of file +In diesem Vektor der Länge $n$ ist die verschlüsselte Nachricht (oder einen Teil davon) enthalten. \ No newline at end of file diff --git a/buch/papers/mceliece/einleitung.tex b/buch/papers/mceliece/einleitung.tex index cebb8ed..e900837 100644 --- a/buch/papers/mceliece/einleitung.tex +++ b/buch/papers/mceliece/einleitung.tex @@ -6,11 +6,11 @@ \section{Einleitung \label{mceliece:section:einleitung}} \rhead{Einleitung} -Beim McEliece-Kryptosystem handelt es sich um ein asymetrisches Verschlüsselungsverfahren, welches erlaubt, +Beim McEliece-Kryptosystem handelt es sich um ein asymmetrisches Verschlüsselungsverfahren, welches erlaubt, Daten verschlüsselt über ein Netzwerk zu übermitteln, ohne dass vorab ein gemeinsamer, geheimer Schlüssel unter den Teilnehmern ausgetauscht werden müsste. -Eine andere, bereits erläuterte Variante einer asymetrischen Verschlüsselung ist das Diffie-Hellman-Verfahren \ref{buch:subsection:diffie-hellman}. -Im Gegensatz zu Diffie-Hellman gilt das McEliece-System als Quantencomputerresistent +Eine andere, bereits erläuterte Variante einer asymmetrischen Verschlüsselung ist das Diffie-Hellman-Verfahren \ref{buch:subsection:diffie-hellman}. +Im Gegensatz zu Diffie-Hellman gilt das McEliece-System als quantencomputerresistent und das Verschlüsseln/Entschlüsseln von Nachrichten wird hauptsächlich mit Matrizenoperationen durchgeführt. diff --git a/buch/papers/mceliece/fazit.tex b/buch/papers/mceliece/fazit.tex index 186708b..eb96288 100644 --- a/buch/papers/mceliece/fazit.tex +++ b/buch/papers/mceliece/fazit.tex @@ -10,20 +10,20 @@ Ein kurzer Vergleich des McEliece-Systems mit dem oft verwendeten RSA-System soll zeigen, wo dessen Vor- und Nachteile liegen. \subsection{Resourcen} -Eine Eigenheit des McEliece-Systems ist das hinzufügen von Rauschen (mit Fehlervektor $e_n$). -Damit diese mit dem Lienarcode-Decoder wieder entfernt werden können, +Eine Eigenheit des McEliece-Systems ist das Hinzufügen von Rauschen (mit Fehlervektor $e_n$). +Damit diese mit dem Linearcode-Decoder wieder entfernt werden können, wird Redundanz benötigt, weshalb dessen Kanalefizienz (Nutzbits/Übertragungsbits) sinkt. Die Schlüsselgrösse des McEliece-Systems ist deshalb so riesig, weil es sich um eine zweidimensionale Matrix handelt, währenddem RSA mit nur zwei Skalaren auskommt. Das McEliece-System benötigt dafür weniger Rechenaufwand beim Verschlüsseln/Entschlüsseln, da die meisten Operationen mit Matrixmultiplikationen ausgeführt werden können (Aufwand ist in binären Operationen pro Informationsbit)\cite{mceliece:CodeBasedCrypto}. Beim Rechenaufwand sei noch erwähnt, -dass asymetrische Verschlüsselungen meist nur dazu verwendet werden, -um einen Schlüssel für eine symetrische Verschlüsselung auszutauschen. +dass asymmetrische Verschlüsselungen meist nur dazu verwendet werden, +um einen Schlüssel für eine symmetrische Verschlüsselung auszutauschen. \begin{center} -\begin{tabular}{c|c|c} - &McEliece (n=2048, k=1718, t = 30) &RSA (2048, e = 216 + 1)\\ +\begin{tabular}{l|c|c} + &McEliece ($n=2048$, $k=1718$, $t = 30$) &RSA ($2048$, $e = 216 + 1$)\\ \hline - Schlüssegrösse: (Public) &429.5 KByte &0.5 KByte \\ + Schlüssegrösse (Public): &429.5 KByte &0.5 KByte \\ Kanaleffizienz: &83.9 \% &100 \% \\ Verschlüsselungsaufwand: &1025 &40555 \\ Entschlüsselungsaufwand: &2311 &6557176, 5 @@ -31,7 +31,7 @@ um einen Schlüssel für eine symetrische Verschlüsselung auszutauschen. \end{center} \subsection{Sicherheit} -Grosse unterschiede zwischen den beiden Kryptosystemen gibt es jedoch bei der Sicherheit. +Grosse Unterschiede zwischen den beiden Kryptosystemen gibt es jedoch bei der Sicherheit. Der Kern der RSA-Verschlüsselung beruht auf dem Problem, eine grosse Zahl in ihre beiden Primfaktoren zu zerlegen. Bei genügend grossen Zahlen ist diese Zerlegung auch mit den heute besten verfügbaren Computern kaum innerhalb vernünftiger Zeit zu lösen. Weiter ist aber bekannt, @@ -43,7 +43,7 @@ Für das ``Syndrome decoding'' sind bis heute keine Methoden bekannt, welche nennenswerte Vorteile gegenüber dem Durchprobieren (brute-force) bringen, auch nicht mithilfe eines Quantencomputers. \begin{center} -\begin{tabular}{c|c|c} +\begin{tabular}{l|c|c} &McEliece &RSA \\ \hline Grundlage Verschlüsselung &Syndrome decoding &Integer factoring\\ @@ -54,4 +54,4 @@ auch nicht mithilfe eines Quantencomputers. Die Verbreitung des McEliece-Kryptosystems ist zurzeit äusserst gering. Das liegt einerseits an der immensen Grösse des öffentlichen Schlüssels, andererseits wird aber auch in naher Zukunft nicht mit einem genügend starken Quantencomputer gerechnet, -welcher andere asymetrische Verschlüsselungen gefährden würde. +welcher andere asymmetrische Verschlüsselungen gefährden würde. diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index 7c69b13..b4f00f0 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -25,7 +25,7 @@ und wird anschliessend Bob zugestellt. \label{mceliece:section:verschl}} Bob berechnet nun die verschlüsselte Nachricht $c_n$, indem er seine Daten $d_k$ mit dem öffentlichen Schlüssel $K_{n,k}$ von Alice multipliziert -und anschliessend durch eine Addition mit einem Fehlervektor $e_n$ einige Bitfehler hinzufügt. +und anschliessend durch eine Addition mit einem Fehlervektor $e_n$ einige Bitfehler hinzufügt: \[ c_n\,=\,K_{n,k}\cdot d_k + e_n\,. \] @@ -36,25 +36,25 @@ Die verschlüsselte Nachricht $c_n$ wird anschliessend Alice zugestellt. \subsection{Entschlüsselung \label{mceliece:section:entschl}} Alice entschlüsselt die erhaltene Nachricht in mehreren einzelnen Schritten. -Um etwas Transparenz in diese Prozedur zu bringen, wird der öffentliche Schlüssel $K_{n,k}$ mit seinen Ursprungsmatrizen dargestellt. +Um etwas Transparenz in diese Prozedur zu bringen, wird der öffentliche Schlüssel $K_{n,k}$ mit seinen Ursprungsmatrizen dargestellt: \begin{align*} c_n\,&=\,K_{n,k}\cdot d_k + e_n \\ - &= P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + e_n + &= P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + e_n\,. \end{align*} Zuerst wird der Effekt der Permutationsmatrix rückgängig gemacht, -indem das Codewort mit dessen Inversen $P_n^{-1}$ multipliziert wird. +indem das Codewort mit dessen Inversen $P_n^{-1}$ multipliziert wird: \begin{align*} c_{n}''\,=\,P_n^{-1}\cdot c_n\,&= P_n^{-1}\cdot P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ - &= G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ + &= G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n\,. \\ \end{align*} Eine weitere Vereinfachung ist nun möglich, weil $P_n^{-1}$ einerseits auch eine gewöhnliche Permutationsmatrix ist und andererseits ein zufälliger Fehlervektor $e_n$ multipliziert mit einer Permutationsmatrix -wiederum einen gleichwertigen, zufälligen Fehlervektor $e_n'$ ergibt. +wiederum einen zufälligen Fehlervektor gleicher Länge und mit der gleichen Anzahl Fehlern $e_n'$ ergibt: \begin{align*} c_{n}''\,&=\,G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ - &=\,G_{n,k}\cdot S_{k}\cdot d_k + e'_n\quad \quad \quad | \, - e'_n\,=\,P_n^{-1}\cdot e_n + &=\,G_{n,k}\cdot S_{k}\cdot d_k + e'_n \quad \text{mit} \quad + e'_n\,=\,P_n^{-1}\cdot e_n\,. \end{align*} Dank des fehlerkorrigierenden Codes, der durch die implizite Multiplikation mittels $G_{n,k}$ auf die Daten angewendet wurde, können nun die Bitfehler, verursacht durch den Fehlervektor $e'_n$, @@ -62,22 +62,329 @@ entfernt werden. Da es sich bei diesem Schritt nicht um eine einfache Matrixmultiplikation handelt, wird die Operation durch eine Funktion dargestellt. Wie dieser Decoder genau aufgebaut ist, -hängt vom verwendeten Linearcode ab. +hängt vom verwendeten Linearcode ab: \begin{align*} c_{k}'\,&=\text{Linear-Code-Decoder($c''_n$)}\\ &=\text{Linear-Code-Decoder($G_{n,k}\cdot S_{k}\cdot d_k + e'_n$)}\\ - &=S_{k}\cdot d_k + &=S_{k}\cdot d_k\,. \end{align*} Zum Schluss wird das inzwischen fast entschlüsselte Codewort $c'_k$ mit der inversen der zufälligen Binärmatrix $S^{-1}$ multipliziert, -womit der Inhalt der ursprünglichen Nachricht nun wiederhergestellt wurde. +womit der Inhalt der ursprünglichen Nachricht nun wiederhergestellt wurde: \begin{align*} c_{k}'\,&=S_{k}\cdot d_k \quad | \cdot S_k^{-1}\\ d'_{k}\,=\,S_{k}^{-1} \cdot c'_k&=S_{k}^{-1} \cdot S_{k}\cdot d_k\\ - &=d_k + &=d_k\,. \end{align*} \subsection{Beispiel} +Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden. +\begin{itemize} + \item Daten- und Fehlervektor + \begin{itemize} + \item[] + \[d_4= + \begin{pmatrix} + 1\\ + 1\\ + 1\\ + 0 + \end{pmatrix} + ,\, + e_7= + \begin{pmatrix} + 0\\ + 0\\ + 1\\ + 0\\ + 0\\ + 0\\ + 0 + \end{pmatrix} + \] + \end{itemize} + \item Private Matrizen: + \begin{itemize} + \item[] + \[S_4= + \begin{pmatrix} + 0 & 0 & 1 & 1\\ + 0 & 0 & 0 & 1\\ + 0 & 1 & 0 & 1\\ + 1 & 0 & 0 & 1 + \end{pmatrix},\, + S_4^{-1}= + \begin{pmatrix} + 0 & 1 & 0 & 1\\ + 0 & 1 & 1 & 0\\ + 1 & 1 & 0 & 0\\ + 0 & 1 & 0 & 0\\ + \end{pmatrix}, + \] + \item[] + \[ + G_{7,4}= + \begin{pmatrix} + 1 & 0 & 0 & 0\\ + 1 & 1 & 0 & 0\\ + 0 & 1 & 1 & 0\\ + 1 & 0 & 1 & 1\\ + 0 & 1 & 0 & 1\\ + 0 & 0 & 1 & 0\\ + 0 & 0 & 0 & 1 + \end{pmatrix},\, + \] + \item[] + \[ + P_7= + \begin{pmatrix} + 0 & 1 & 0 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 0 & 1\\ + 1 & 0 & 0 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 1 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 1 & 0\\ + 0 & 0 & 1 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 1 & 0 & 0 + \end{pmatrix} + ,\, + P_7^{-1}=P_7^t= + \begin{pmatrix} + 0 & 0 & 0 & 0 & 0 & 1 & 0\\ + 1 & 0 & 0 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 1 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 1 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 0 & 1\\ + 0 & 0 & 1 & 0 & 0 & 0 & 0\\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 + \end{pmatrix} + \] + \end{itemize} + \item Öffentlicher Schlüssel: + \begin{itemize} + \item[] + \begin{align*} + K_{7,4}&=P_{7}\cdot G_{7,4}\cdot S_{4}=\\ + \begin{pmatrix} %k + 0 & 0 & 1 & 0\\ + 1 & 0 & 0 & 1\\ + 0 & 0 & 1 & 1\\ + 1 & 1 & 1 & 1\\ + 0 & 1 & 0 & 1\\ + 0 & 1 & 0 & 0\\ + 1 & 0 & 0 & 0 + \end{pmatrix} + &= + \begin{pmatrix} %p + 0 & 1 & 0 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 0 & 1\\ + 1 & 0 & 0 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 1 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 1 & 0\\ + 0 & 0 & 1 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 1 & 0 & 0 + \end{pmatrix} + \cdot + \begin{pmatrix} %g + 1 & 0 & 0 & 0\\ + 1 & 1 & 0 & 0\\ + 0 & 1 & 1 & 0\\ + 1 & 0 & 1 & 1\\ + 0 & 1 & 0 & 1\\ + 0 & 0 & 1 & 0\\ + 0 & 0 & 0 & 1 + \end{pmatrix} + \cdot + \begin{pmatrix} %s + 0 & 0 & 1 & 1\\ + 0 & 0 & 0 & 1\\ + 0 & 1 & 0 & 1\\ + 1 & 0 & 0 & 1 + \end{pmatrix} + \end{align*} + \end{itemize} + \item Verschlüsselung: + \begin{itemize} + \item[] + \begin{align*} + c_7&=K_{7,4}\cdot d_4 + e_7=\\ + \begin{pmatrix} %c + 1\\ + 1\\ + 0\\ + 1\\ + 1\\ + 1\\ + 1 + \end{pmatrix} + &= + \begin{pmatrix} %k + 0 & 0 & 1 & 0\\ + 1 & 0 & 0 & 1\\ + 0 & 0 & 1 & 1\\ + 1 & 1 & 1 & 1\\ + 0 & 1 & 0 & 1\\ + 0 & 1 & 0 & 0\\ + 1 & 0 & 0 & 0 + \end{pmatrix} + \cdot + \begin{pmatrix} %d + 1\\ + 1\\ + 1\\ + 0 + \end{pmatrix} + + + \begin{pmatrix} %e + 0\\ + 0\\ + 1\\ + 0\\ + 0\\ + 0\\ + 0 + \end{pmatrix} + \end{align*} + \end{itemize} + \item Entschlüsselung (Permutation rückgängig machen): + \begin{itemize} + \item[] + \begin{align*} + c_{7}''&=P_7^{-1}\cdot c_7=\\ + \begin{pmatrix} %c'' + 0\\ + 1\\ + 1\\ + 1\\ + 1\\ + 1\\ + 1 + \end{pmatrix} + &= + \begin{pmatrix} %p^-1 + 0 & 0 & 1 & 0 & 0 & 0 & 0\\ + 1 & 0 & 0 & 0 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 1 & 0\\ + 0 & 0 & 0 & 1 & 0 & 0 & 0\\ + 0 & 0 & 0 & 0 & 0 & 0 & 1\\ + 0 & 0 & 0 & 0 & 1 & 0 & 0\\ + 0 & 1 & 0 & 0 & 0 & 0 & 0 + \end{pmatrix} + \cdot + \begin{pmatrix} %c + 1\\ + 1\\ + 0\\ + 1\\ + 1\\ + 1\\ + 1 + \end{pmatrix} + \end{align*} + \end{itemize} + \item Entschlüsselung (Bitfehlerkorrektur mit Linearcode): + \begin{itemize} + \item[] + \begin{align*} + c_{7}'\,&=\text{Linear-Code-Decoder($c''_7$)}=\\ + \begin{pmatrix} %c' + 1\\ + 0\\ + 1\\ + 1 + \end{pmatrix} + &=\text{Linear-Code-Decoder} + \begin{pmatrix} + 0\\ + 1\\ + 1\\ + 1\\ + 1\\ + 1\\ + 1 + \end{pmatrix} + \end{align*} + \end{itemize} + \item Entschlüsselung (Umkehrung des $S_k$-Matrix-Effekts): + \begin{itemize} + \item[] + \begin{align*} + d'_{4}&=S_{4}^{-1} \cdot c'_4 \,(= d_4)\\ + \begin{pmatrix} + 1\\ + 1\\ + 1\\ + 0 + \end{pmatrix} + &= + \begin{pmatrix} %s^-1 + 0 & 1 & 0 & 1\\ + 0 & 1 & 1 & 0\\ + 1 & 1 & 0 & 0\\ + 0 & 1 & 0 & 0\\ + \end{pmatrix} + \cdot + \begin{pmatrix} %c' + 1\\ + 0\\ + 1\\ + 1 + \end{pmatrix} + \end{align*} + \end{itemize} +\end{itemize} -TODO: --alle Beispielmatrizen- und Vektoren hierhin zügeln, numerisches Beispiel kreieren\\ --erläutern des 7/4-codes (ja/nein)? \ No newline at end of file + +\subsubsection{7/4-Code} +Bem 7/4-Code handelt es sich um einen linearen Code, +der ein Bitfehler korrigieren kann. +Es gibt unterschiedliche Varianten zum Erzeugen eines 7/4-Codes, +wobei der hier verwendete Code mithilfe des irreduziblen Generator-Polynoms $P_g = x^3 +x + 1$ generiert wird. +Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d$ mit dem Generatorpolynom $P_g$ multipliziert wird: +\[ + P_c=P_g \cdot P_d\,. +\] +Damit diese Multiplikation mit Matrizen ausgeführt weredn kann, werden die Polynome in Vektoren abgefüllt: +\[ + P_g = \textcolor{red}{1}\cdot x^0 + \textcolor{blue}{1}\cdot x^1 + \textcolor{green}{0}\cdot x^2 + \textcolor{orange}{1}\cdot x^3 \implies + [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{green}{0}, \textcolor{orange}{1}] = g_4\,. +\] +Auch das Datenpolynom wird mit einem Vektor dargestellt: $P_d = d_0 \cdot x^0 + d_1 \cdot x^1 + d_2 \cdot x^2 + d_3 \cdot x^3 \implies [d_0, d_1, d_2, d_3] = d_4$\,. +Der Vektor $g_4$ wird nun in die sogenannte Generatormatrix $G_{7,4}$ gepakt, +sodass die Polynommultiplikation mit $d_4$ mittels Matrixmultiplikation realisiert werden kann: + +\[ + c_7=G_{7,4} \cdot d_4= + \begin{pmatrix} + \textcolor{red}{1} & 0 & 0 & 0 \\ + \textcolor{blue}{1} & \textcolor{red}{1} & 0 & 0 \\ + \textcolor{green}{0} & \textcolor{blue}{1} & \textcolor{red}{1} & 0 \\ + \textcolor{orange}{1} & \textcolor{green}{0} & \textcolor{blue}{1} & \textcolor{red}{1} \\ + 0 & \textcolor{orange}{1} & \textcolor{green}{0} & \textcolor{blue}{1} \\ + 0 & 0 & \textcolor{orange}{1} & \textcolor{green}{0} \\ + 0 & 0 & 0 & \textcolor{orange}{1} + \end{pmatrix} + \begin{pmatrix} + d_0\\ + d_1\\ + d_2\\ + d_3 + \end{pmatrix} + = + \begin{pmatrix} + c_0\\ + c_1\\ + c_2\\ + c_3\\ + c_4\\ + c_5\\ + c_6\\ + \end{pmatrix}\,. +\] +Beim nun entstandenen Code-Vektor $c_7=[c_0, ..., c_6]$ entsprechen die Koeffizienten dem dazugehörigen Code-Polynom $P_c=c_0\cdot x^0+...+c_6\cdot x^6$ +Aufgrund der Multiplikation mit dem Generatorpolynom $P_g$ lässt sich das Codewort auch wieder restlos durch $P_g$ dividieren. +Wird dem Codewort nun einen Bitfehler hinzugefügt, entsteht bei der Division durch $P_g$ einen Rest. +Beim gewählten Polynom beträgt die sogenannte Hamming-Distanz drei, das bedeutet, +dass vom einen gültigen Codewort zu einem anderen gültigen Codewort drei Bitfehler vorkommen müssen. +Somit ist es möglich, auf das ursprüngliche Bitmuster zu schliessen, solange maximal ein Bitfehler vorhanden ist. +Jeder der möglichen acht Bitfehler führt bei der Divison zu einem anderen Rest, +womit das Dazugehörige Bit identifiziert und korrigiert werden kann, +indem beispielsweise die Bitfehler mit dem Dazugehörigen Rest in der sogenannten Syndrom-Tabelle hinterlegt werden. -- cgit v1.2.1 From 9ef53904ccf44f3c04bda08610cccb30fee47e50 Mon Sep 17 00:00:00 2001 From: Reto Fritsche Date: Tue, 31 Aug 2021 22:49:58 +0200 Subject: some corrections --- buch/papers/mceliece/example_code/mceliece_simple.py | 14 +++++--------- buch/papers/mceliece/funktionsweise.tex | 6 ++++-- 2 files changed, 9 insertions(+), 11 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/example_code/mceliece_simple.py b/buch/papers/mceliece/example_code/mceliece_simple.py index bac3b42..c8d5e9d 100644 --- a/buch/papers/mceliece/example_code/mceliece_simple.py +++ b/buch/papers/mceliece/example_code/mceliece_simple.py @@ -187,14 +187,10 @@ def decode_linear_code(c, g, syndrome_table): q, r=divmod(Poly(c), g) q=np.r_[q.coef%2, np.zeros(len(c)-len(q)-len(g)+1)] r=np.r_[r.coef%2, np.zeros(len(g)-len(r))] - syndrome_index=np.sum([int(a*2**i) for i, a in enumerate(r)]) - while syndrome_index > 0: - c=c ^ syndrome_table[syndrome_index] - q, r=divmod(Poly(c), g) - q=np.r_[q.coef%2, np.zeros(len(c)-len(q)-len(g)+1)] - r=np.r_[r.coef%2, np.zeros(len(g)-len(r))] - syndrome_index=np.sum([int(a*2**i) for i, a in enumerate(r)]) - return np.array(q, dtype=int) + syndrome_index=np.sum([int(a*2**i) for i, a in enumerate(r)]) #binary to decimal + q_corr, r_corr=divmod(Poly(syndrome_table[syndrome_index]), g) + q_corr=np.r_[q_corr.coef%2, np.zeros(len(c)-len(q_corr)-len(g)+1)] + return q.astype(int) ^ q_corr.astype(int) def encode_linear_code(d, G): ''' @@ -324,4 +320,4 @@ if __name__ == '__main__': print(f'msg_rx: {msg_rx}') - \ No newline at end of file + diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index b4f00f0..5aceb24 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -71,10 +71,12 @@ hängt vom verwendeten Linearcode ab: Zum Schluss wird das inzwischen fast entschlüsselte Codewort $c'_k$ mit der inversen der zufälligen Binärmatrix $S^{-1}$ multipliziert, womit der Inhalt der ursprünglichen Nachricht nun wiederhergestellt wurde: \begin{align*} - c_{k}'\,&=S_{k}\cdot d_k \quad | \cdot S_k^{-1}\\ d'_{k}\,=\,S_{k}^{-1} \cdot c'_k&=S_{k}^{-1} \cdot S_{k}\cdot d_k\\ &=d_k\,. \end{align*} +Möchte ein Angreifer die verschlüsselte Nachricht knacken, muss dieser die drei privaten Matrizen $S_k$, $G_{n,k}$ und $P_n$ kennen. +Aus dem Öffentlichen Schlüssel lassen sich diese nicht rekonstruieren +und eine systematische Analyse der Codeworte wird durch das Hinzufügen von zufälligen Bitfehlern zusätzlich erschwert. \subsection{Beispiel} Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden. @@ -303,7 +305,7 @@ Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden \end{pmatrix} \end{align*} \end{itemize} - \item Entschlüsselung (Umkehrung des $S_k$-Matrix-Effekts): + \item Entschlüsselung (Umkehrung des $S_4$-Matrix-Effekts): \begin{itemize} \item[] \begin{align*} -- cgit v1.2.1 From 0d5fb702bb57294fbd9dda7aab4b76efebed6c22 Mon Sep 17 00:00:00 2001 From: Reto Date: Tue, 31 Aug 2021 23:41:43 +0200 Subject: added syndrome table --- buch/papers/mceliece/funktionsweise.tex | 41 ++++++++++++++++++++++++--------- 1 file changed, 30 insertions(+), 11 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index 5aceb24..58337c8 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -75,7 +75,7 @@ womit der Inhalt der ursprünglichen Nachricht nun wiederhergestellt wurde: &=d_k\,. \end{align*} Möchte ein Angreifer die verschlüsselte Nachricht knacken, muss dieser die drei privaten Matrizen $S_k$, $G_{n,k}$ und $P_n$ kennen. -Aus dem Öffentlichen Schlüssel lassen sich diese nicht rekonstruieren +Aus dem öffentlichen Schlüssel lassen sich diese nicht rekonstruieren und eine systematische Analyse der Codeworte wird durch das Hinzufügen von zufälligen Bitfehlern zusätzlich erschwert. \subsection{Beispiel} @@ -336,21 +336,21 @@ Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden \subsubsection{7/4-Code} -Bem 7/4-Code handelt es sich um einen linearen Code, +Beim 7/4-Code handelt es sich um einen linearen Code, der ein Bitfehler korrigieren kann. Es gibt unterschiedliche Varianten zum Erzeugen eines 7/4-Codes, wobei der hier verwendete Code mithilfe des irreduziblen Generator-Polynoms $P_g = x^3 +x + 1$ generiert wird. -Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d$ mit dem Generatorpolynom $P_g$ multipliziert wird: +Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d$ mit dem Generatorpolynom $P_g$ multipliziert wird (Codiervorgang): \[ P_c=P_g \cdot P_d\,. \] -Damit diese Multiplikation mit Matrizen ausgeführt weredn kann, werden die Polynome in Vektoren abgefüllt: +Damit diese Multiplikation mit Matrizen ausgeführt werden kann, werden die Polynome in mit Vektoren dargestellt: \[ P_g = \textcolor{red}{1}\cdot x^0 + \textcolor{blue}{1}\cdot x^1 + \textcolor{green}{0}\cdot x^2 + \textcolor{orange}{1}\cdot x^3 \implies [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{green}{0}, \textcolor{orange}{1}] = g_4\,. \] -Auch das Datenpolynom wird mit einem Vektor dargestellt: $P_d = d_0 \cdot x^0 + d_1 \cdot x^1 + d_2 \cdot x^2 + d_3 \cdot x^3 \implies [d_0, d_1, d_2, d_3] = d_4$\,. -Der Vektor $g_4$ wird nun in die sogenannte Generatormatrix $G_{7,4}$ gepakt, +Auch das Daten-Polynom wird mit einem Vektor dargestellt: $P_d = d_0 \cdot x^0 + d_1 \cdot x^1 + d_2 \cdot x^2 + d_3 \cdot x^3 \implies [d_0, d_1, d_2, d_3] = d_4$\,. +Der Vektor $g_4$ wird nun in die sogenannte Generatormatrix $G_{7,4}$ gepackt, sodass die Polynommultiplikation mit $d_4$ mittels Matrixmultiplikation realisiert werden kann: \[ @@ -381,12 +381,31 @@ sodass die Polynommultiplikation mit $d_4$ mittels Matrixmultiplikation realisie c_6\\ \end{pmatrix}\,. \] -Beim nun entstandenen Code-Vektor $c_7=[c_0, ..., c_6]$ entsprechen die Koeffizienten dem dazugehörigen Code-Polynom $P_c=c_0\cdot x^0+...+c_6\cdot x^6$ +Beim nun entstandenen Code-Vektor $c_7=[c_0, ..., c_6]$ entsprechen die Koeffizienten dem dazugehörigen Code-Polynom $P_c=c_0\cdot x^0+...+c_6\cdot x^6$. Aufgrund der Multiplikation mit dem Generatorpolynom $P_g$ lässt sich das Codewort auch wieder restlos durch $P_g$ dividieren. Wird dem Codewort nun einen Bitfehler hinzugefügt, entsteht bei der Division durch $P_g$ einen Rest. Beim gewählten Polynom beträgt die sogenannte Hamming-Distanz drei, das bedeutet, -dass vom einen gültigen Codewort zu einem anderen gültigen Codewort drei Bitfehler vorkommen müssen. +dass vom einen gültigen Codewort zu einem anderen gültigen Codewort drei Bitfehler auftreten müssen. Somit ist es möglich, auf das ursprüngliche Bitmuster zu schliessen, solange maximal ein Bitfehler vorhanden ist. -Jeder der möglichen acht Bitfehler führt bei der Divison zu einem anderen Rest, -womit das Dazugehörige Bit identifiziert und korrigiert werden kann, -indem beispielsweise die Bitfehler mit dem Dazugehörigen Rest in der sogenannten Syndrom-Tabelle hinterlegt werden. +Jeder der möglichen acht Bitfehler führt bei der Division zu einem anderen Rest, +womit das dazugehörige Bit identifiziert und korrigiert werden kann, +indem beispielsweise die Bitfehler mit dem dazugehörigen Rest in der sogenannten Syndrom-Tabelle (Tabelle \ref{mceliece:tab:syndrome}) hinterlegt werden. +\begin{table} + \begin{center} + \begin{tabular}{l|c} + \hline + Syndrom (Divisionsrest) &korrespondierender Bitfehler\\ + \hline + 1 ($[1,0,0]$) &$[1,0,0,0,0,0,0]$\\ + 2 ($[0,1,0]$) &$[0,1,0,0,0,0,0]$\\ + 3 ($[1,1,0]$) &$[0,0,0,1,0,0,0]$\\ + 4 ($[0,0,1]$) &$[0,0,1,0,0,0,0]$\\ + 5 ($[1,0,1]$) &$[0,0,0,0,0,0,1]$\\ + 6 ($[0,1,1]$) &$[0,0,0,0,1,0,0]$\\ + 7 ($[1,1,1]$) &$[0,0,0,0,0,1,0]$\\ + \hline + + \end{tabular} + \end{center} + \caption{\label{mceliece:tab:syndrome}Syndrom-Tabelle 7/4-Code} +\end{table} -- cgit v1.2.1 From 283986431bbf1e343666e6ea243afff3dc28ccfb Mon Sep 17 00:00:00 2001 From: Reto Date: Wed, 1 Sep 2021 00:02:03 +0200 Subject: typos & co --- buch/papers/mceliece/funktionsweise.tex | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index 58337c8..03601b3 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -293,7 +293,7 @@ Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden 1\\ 1 \end{pmatrix} - &=\text{Linear-Code-Decoder} + &=\text{Linear-Code-Decoder(} \begin{pmatrix} 0\\ 1\\ @@ -303,6 +303,7 @@ Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden 1\\ 1 \end{pmatrix} + \text{)} \end{align*} \end{itemize} \item Entschlüsselung (Umkehrung des $S_4$-Matrix-Effekts): @@ -344,7 +345,7 @@ Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d \[ P_c=P_g \cdot P_d\,. \] -Damit diese Multiplikation mit Matrizen ausgeführt werden kann, werden die Polynome in mit Vektoren dargestellt: +Damit diese Multiplikation mit Matrizen ausgeführt werden kann, werden die Polynome in mit Vektoren dargestellt (Kapitel \ref{buch:section:polynome:vektoren}): \[ P_g = \textcolor{red}{1}\cdot x^0 + \textcolor{blue}{1}\cdot x^1 + \textcolor{green}{0}\cdot x^2 + \textcolor{orange}{1}\cdot x^3 \implies [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{green}{0}, \textcolor{orange}{1}] = g_4\,. @@ -392,7 +393,7 @@ womit das dazugehörige Bit identifiziert und korrigiert werden kann, indem beispielsweise die Bitfehler mit dem dazugehörigen Rest in der sogenannten Syndrom-Tabelle (Tabelle \ref{mceliece:tab:syndrome}) hinterlegt werden. \begin{table} \begin{center} - \begin{tabular}{l|c} + \begin{tabular}{|l|l|} \hline Syndrom (Divisionsrest) &korrespondierender Bitfehler\\ \hline -- cgit v1.2.1 From 362e2db0b3272a304adc9523788b9e0cdc81536f Mon Sep 17 00:00:00 2001 From: Reto Date: Wed, 1 Sep 2021 09:18:29 +0200 Subject: typos & co --- buch/papers/mceliece/funktionsweise.tex | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index 03601b3..8288e7f 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -12,8 +12,11 @@ bei dem Bob an Alice eine verschlüsselte Nachticht über ein öffentliches Netz \subsection{Vorbereitung \label{mceliece:section:vorbereitung}} -Damit der Nachrichtenaustausch stattfinden kann, muss Alice (Empfängerin) -zuerst ein Schlüsselpaar definieren. +Bevor einen Datenaustausch zwischen Sender und Empfänger stattfinden kann, +muss abgemacht werden, welche Länge $n$ das Code-Wort und welche Länge $k$ das Datenwort hat +und wie viele Bitfehler $t$ (angewendet mit Fehlervektor $e_n$) +für das Rauschen des Code-Wortes $c_n$ verwendet werden. +Danach generiert Alice (Empfängerin) ein Schlüsselpaar. Dazu erstellt sie die einzelnen Matrizen $S_k$, $G_{n,k}$ und $P_n$. Diese drei einzelnen Matrizen bilden den privaten Schlüssel von Alice und sollen geheim bleiben. @@ -29,7 +32,7 @@ und anschliessend durch eine Addition mit einem Fehlervektor $e_n$ einige Bitfeh \[ c_n\,=\,K_{n,k}\cdot d_k + e_n\,. \] -Dabei wird für jede Nachricht (oder für jedes Nachrichtenfragment) +Dabei wird für jede Nachricht (oder für jedes Nachrichtenfragment) $d_k$ einen neuen, zufälligen Fehlervektor generiert. Die verschlüsselte Nachricht $c_n$ wird anschliessend Alice zugestellt. @@ -79,7 +82,8 @@ Aus dem öffentlichen Schlüssel lassen sich diese nicht rekonstruieren und eine systematische Analyse der Codeworte wird durch das Hinzufügen von zufälligen Bitfehlern zusätzlich erschwert. \subsection{Beispiel} -Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden. +Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden. +Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four} beschrieben. \begin{itemize} \item Daten- und Fehlervektor \begin{itemize} @@ -336,7 +340,8 @@ Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden \end{itemize} -\subsubsection{7/4-Code} +\subsubsection{7/4-Code +\label{mceliece:subsection:seven_four}} Beim 7/4-Code handelt es sich um einen linearen Code, der ein Bitfehler korrigieren kann. Es gibt unterschiedliche Varianten zum Erzeugen eines 7/4-Codes, -- cgit v1.2.1 From 321637683b7b08817021f7b9d7ca4f25b194deb8 Mon Sep 17 00:00:00 2001 From: Reto Date: Fri, 3 Sep 2021 21:07:18 +0200 Subject: realized improvements succestions --- buch/papers/mceliece/aufbau.tex | 9 ++++-- buch/papers/mceliece/fazit.tex | 52 ++++++++++++++++++++------------- buch/papers/mceliece/funktionsweise.tex | 41 ++++++++++++++------------ 3 files changed, 61 insertions(+), 41 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/aufbau.tex b/buch/papers/mceliece/aufbau.tex index 0849fc1..ef45bc1 100644 --- a/buch/papers/mceliece/aufbau.tex +++ b/buch/papers/mceliece/aufbau.tex @@ -6,6 +6,9 @@ \section{Aufbau\label{mceliece:section:Aufbau}} \rhead{Aufbau} Das McEliece-Kryptosystem besteht aus folgenden Elementen: +Nachfolgend sind alle Bestandteile für das McEliece-Kryptosystem aufgelistet, +wobei alle Vektoren und Matrizen, sowie die Rechenoperationen damit, +im binären Raum $\mathbb{F}_2$ stattfinden. \subsection{Datenvektor $d_k$ \label{mceliece:subsection:d_k}} @@ -27,7 +30,7 @@ der in der Lage ist, $t$ Fehler zu korrigieren. Im Zusammenhang mit McEliece werden dabei meist binäre Goppa-Codes \cite{mceliece:goppa} verwendet, es können prinzipiell auch andere Codes wie beispielsweise Reed-Solomon verwendet werden, jedoch besitzen einige (unter anderem auch Reed-Solomon) Codes Schwachstellen \cite{mceliece:lorenz}. -Das Codieren mit diesem linearen Code kann mithilfe dessen Generatormatrix $G_{n,k}$ erfolgen. +Das Codieren mit diesem linearen Code kann mithilfe seiner Generatormatrix $G_{n,k}$ erfolgen. Da es sich um einen fehlerkorrigierenden Code handelt, wird das Codewort länger als das Datenwort, es wird also Redundanz hinzugefügt, @@ -41,7 +44,7 @@ Mit der Inversen $P_n^{-1}$ kann die Bitvertauschung rückgängig gemacht werden \subsection{Public-Key $K_{n,k}$ \label{mceliece:subsection:k_nk}} Der öffentliche Schlüssel, welcher zum Verschlüsseln verwendet wird, -berechnet sich aus den bereits bekannten Matrizen wiefolgt: +berechnet sich aus den bereits bekannten Matrizen wie folgt: \[ K_{n,k}=P_{n}\cdot G_{n,k}\cdot S_{k}\,. \] @@ -50,7 +53,7 @@ berechnet sich aus den bereits bekannten Matrizen wiefolgt: \label{mceliece:subsection:e_n}} Dieser Vektor der Länge $n$ besteht aus $t$ Einsen, welche zufällig innerhalb des Vektors angeordnet sind, alle anderen Einträge sind Null. -Dieser Fehlervektor besitzt also gleich viele Einer, +Dieser Fehlervektor besitzt also gleich viele Einsen wie die Anzahl Fehler, die der Linearcode der Generatormatrix $G_{n,k}$ zu korrigieren vermag. \subsection{Daten-Vektor $d_k$ diff --git a/buch/papers/mceliece/fazit.tex b/buch/papers/mceliece/fazit.tex index eb96288..aab1f54 100644 --- a/buch/papers/mceliece/fazit.tex +++ b/buch/papers/mceliece/fazit.tex @@ -15,20 +15,26 @@ Damit diese mit dem Linearcode-Decoder wieder entfernt werden können, wird Redundanz benötigt, weshalb dessen Kanalefizienz (Nutzbits/Übertragungsbits) sinkt. Die Schlüsselgrösse des McEliece-Systems ist deshalb so riesig, weil es sich um eine zweidimensionale Matrix handelt, währenddem RSA mit nur zwei Skalaren auskommt. -Das McEliece-System benötigt dafür weniger Rechenaufwand beim Verschlüsseln/Entschlüsseln, da die meisten Operationen mit Matrixmultiplikationen ausgeführt werden können (Aufwand ist in binären Operationen pro Informationsbit)\cite{mceliece:CodeBasedCrypto}. +Das McEliece-System benötigt dafür weniger Rechenaufwand beim Verschlüsseln/Entschlüsseln, +da die meisten Operationen mit Matrixmultiplikationen ausgeführt werden können. +Eine Übersicht zu diesem Thema bietet Tabelle \ref{mceliece:tab:comparison_effort}. + Beim Rechenaufwand sei noch erwähnt, dass asymmetrische Verschlüsselungen meist nur dazu verwendet werden, um einen Schlüssel für eine symmetrische Verschlüsselung auszutauschen. -\begin{center} -\begin{tabular}{l|c|c} - &McEliece ($n=2048$, $k=1718$, $t = 30$) &RSA ($2048$, $e = 216 + 1$)\\ - \hline - Schlüssegrösse (Public): &429.5 KByte &0.5 KByte \\ - Kanaleffizienz: &83.9 \% &100 \% \\ - Verschlüsselungsaufwand: &1025 &40555 \\ - Entschlüsselungsaufwand: &2311 &6557176, 5 -\end{tabular} -\end{center} +\begin{table} + \begin{center} + \begin{tabular}{l|c|c} + &McEliece ($n=2048$, $k=1718$, $t = 30$) &RSA ($2048$, $e = 216 + 1$)\\ + \hline + Schlüssegrösse (Public): &429.5 KByte &0.5 KByte \\ + Kanaleffizienz: &83.9 \% &100 \% \\ + Verschlüsselungsaufwand: &1025* &40555* \\ + Entschlüsselungsaufwand: &2311* &6557176,5* \\ + \end{tabular} + \end{center} + \caption{\label{mceliece:tab:comparison_effort}Vergleich zwischen RSA und McEliece bezüglich Effizienz. (*Aufwand in binären Operationen pro Informationsbit\cite{mceliece:CodeBasedCrypto})} +\end{table} \subsection{Sicherheit} Grosse Unterschiede zwischen den beiden Kryptosystemen gibt es jedoch bei der Sicherheit. @@ -38,19 +44,25 @@ Weiter ist aber bekannt, dass mithilfe des sogenannten Shor-Algorithmus \cite{mceliece:shor} und einem Quantencomputer auch diese Zerlegung zügig realisiert werden könnte, was zur Folge hätte, dass die Verschlüsselung von RSA unwirksam würde. Zurzeit sind die Quantencomputer jedoch noch bei weitem nicht in der Lage, grosse Zahlen mithilfe dieses Algorithmuses zu zerlegen. + Das McEliece-System hingegen beruht auf dem Problem des ``Syndrome decoding'' (Korrektur von Bitfehlern eines Codewortes, das mit einem entsprechenden Linearcode codiert wurde). Für das ``Syndrome decoding'' sind bis heute keine Methoden bekannt, welche nennenswerte Vorteile gegenüber dem Durchprobieren (brute-force) bringen, auch nicht mithilfe eines Quantencomputers. -\begin{center} -\begin{tabular}{l|c|c} - &McEliece &RSA \\ -\hline - Grundlage Verschlüsselung &Syndrome decoding &Integer factoring\\ - Aufwand (gewöhnliche CPU) &exponential &< exponential \\ - Aufwand (Quantencomputer) &> polynomial &$\mathcal{O}(\log(N)^3)$ -\end{tabular} -\end{center} +Eine Übersicht betreffend des Rechenaufwandes zum Knacken der Verschlüsselung ist in Tabelle \ref{mceliece:tab:comparison_security} gegeben und bezieht sich auf die Schlüsselgrösse $N$. +\begin{table} + \begin{center} + \begin{tabular}{l|c|c} + &McEliece &RSA \\ + \hline + Grundlage Verschlüsselung &Syndrome decoding &Integer factoring\\ + Aufwand (gewöhnliche CPU) &exponentiell &< exponentiell \\ + Aufwand (Quantencomputer) &> polynominell &$\mathcal{O}(\log(N)^3)$ + \end{tabular} + \end{center} + \caption{\label{mceliece:tab:comparison_security}Vergleich zwischen RSA und McEliece bezüglich Sicherheit} +\end{table} + Die Verbreitung des McEliece-Kryptosystems ist zurzeit äusserst gering. Das liegt einerseits an der immensen Grösse des öffentlichen Schlüssels, andererseits wird aber auch in naher Zukunft nicht mit einem genügend starken Quantencomputer gerechnet, diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index 8288e7f..76b4b70 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -8,7 +8,7 @@ \rhead{Funktionsweise} Um den Ablauf des Datenaustausches mittels McEliece-Verschlüsselung zu erläutern, wird ein Szenario verwendet, -bei dem Bob an Alice eine verschlüsselte Nachticht über ein öffentliches Netzwerk zukommen lässt. +bei dem Bob an Alice eine verschlüsselte Nachricht über ein öffentliches Netzwerk zukommen lässt. \subsection{Vorbereitung \label{mceliece:section:vorbereitung}} @@ -33,7 +33,7 @@ und anschliessend durch eine Addition mit einem Fehlervektor $e_n$ einige Bitfeh c_n\,=\,K_{n,k}\cdot d_k + e_n\,. \] Dabei wird für jede Nachricht (oder für jedes Nachrichtenfragment) $d_k$ -einen neuen, zufälligen Fehlervektor generiert. +ein neuer, zufälliger Fehlervektor generiert. Die verschlüsselte Nachricht $c_n$ wird anschliessend Alice zugestellt. \subsection{Entschlüsselung @@ -45,7 +45,7 @@ Um etwas Transparenz in diese Prozedur zu bringen, wird der öffentliche Schlüs &= P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + e_n\,. \end{align*} Zuerst wird der Effekt der Permutationsmatrix rückgängig gemacht, -indem das Codewort mit dessen Inversen $P_n^{-1}$ multipliziert wird: +indem das Codewort mit der Inversen $P_n^{-1}$ multipliziert wird: \begin{align*} c_{n}''\,=\,P_n^{-1}\cdot c_n\,&= P_n^{-1}\cdot P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ &= G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n\,. \\ @@ -71,18 +71,18 @@ hängt vom verwendeten Linearcode ab: &=\text{Linear-Code-Decoder($G_{n,k}\cdot S_{k}\cdot d_k + e'_n$)}\\ &=S_{k}\cdot d_k\,. \end{align*} -Zum Schluss wird das inzwischen fast entschlüsselte Codewort $c'_k$ mit der inversen der zufälligen Binärmatrix $S^{-1}$ multipliziert, +Zum Schluss wird das inzwischen fast entschlüsselte Codewort $c'_k$ mit der Inversen der zufälligen Binärmatrix $S^{-1}$ multipliziert, womit der Inhalt der ursprünglichen Nachricht nun wiederhergestellt wurde: \begin{align*} d'_{k}\,=\,S_{k}^{-1} \cdot c'_k&=S_{k}^{-1} \cdot S_{k}\cdot d_k\\ &=d_k\,. \end{align*} -Möchte ein Angreifer die verschlüsselte Nachricht knacken, muss dieser die drei privaten Matrizen $S_k$, $G_{n,k}$ und $P_n$ kennen. +Möchte ein Angreifer die verschlüsselte Nachricht knacken, muss er die drei privaten Matrizen $S_k$, $G_{n,k}$ und $P_n$ kennen. Aus dem öffentlichen Schlüssel lassen sich diese nicht rekonstruieren und eine systematische Analyse der Codeworte wird durch das Hinzufügen von zufälligen Bitfehlern zusätzlich erschwert. \subsection{Beispiel} -Die Verschlüsselung soll mittels einem numerischen Beispiel demonstriert werden. +Die Verschlüsselung soll mittels eines numerischen Beispiels demonstriert werden. Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four} beschrieben. \begin{itemize} \item Daten- und Fehlervektor @@ -162,6 +162,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 0 & 1 & 0 & 0 & 0 & 0\\ 0 & 1 & 0 & 0 & 0 & 0 & 0 \end{pmatrix} + \,. \] \end{itemize} \item Öffentlicher Schlüssel: @@ -205,6 +206,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 1 & 0 & 1\\ 1 & 0 & 0 & 1 \end{pmatrix} + \,. \end{align*} \end{itemize} \item Verschlüsselung: @@ -248,6 +250,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0\\ 0 \end{pmatrix} + \,. \end{align*} \end{itemize} \item Entschlüsselung (Permutation rückgängig machen): @@ -284,6 +287,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1\\ 1 \end{pmatrix} + \,. \end{align*} \end{itemize} \item Entschlüsselung (Bitfehlerkorrektur mit Linearcode): @@ -308,6 +312,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1 \end{pmatrix} \text{)} + \,. \end{align*} \end{itemize} \item Entschlüsselung (Umkehrung des $S_4$-Matrix-Effekts): @@ -335,15 +340,15 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1\\ 1 \end{pmatrix} + \,. \end{align*} \end{itemize} \end{itemize} - -\subsubsection{7/4-Code +\subsection{7/4-Code \label{mceliece:subsection:seven_four}} Beim 7/4-Code handelt es sich um einen linearen Code, -der ein Bitfehler korrigieren kann. +der einen Bitfehler korrigieren kann. Es gibt unterschiedliche Varianten zum Erzeugen eines 7/4-Codes, wobei der hier verwendete Code mithilfe des irreduziblen Generator-Polynoms $P_g = x^3 +x + 1$ generiert wird. Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d$ mit dem Generatorpolynom $P_g$ multipliziert wird (Codiervorgang): @@ -352,8 +357,8 @@ Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d \] Damit diese Multiplikation mit Matrizen ausgeführt werden kann, werden die Polynome in mit Vektoren dargestellt (Kapitel \ref{buch:section:polynome:vektoren}): \[ - P_g = \textcolor{red}{1}\cdot x^0 + \textcolor{blue}{1}\cdot x^1 + \textcolor{green}{0}\cdot x^2 + \textcolor{orange}{1}\cdot x^3 \implies - [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{green}{0}, \textcolor{orange}{1}] = g_4\,. + P_g = \textcolor{red}{1}\cdot x^0 + \textcolor{blue}{1}\cdot x^1 + \textcolor{darkgreen}{0}\cdot x^2 + \textcolor{orange}{1}\cdot x^3 \implies + [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{darkgreen}{0}, \textcolor{orange}{1}] = g_4\,. \] Auch das Daten-Polynom wird mit einem Vektor dargestellt: $P_d = d_0 \cdot x^0 + d_1 \cdot x^1 + d_2 \cdot x^2 + d_3 \cdot x^3 \implies [d_0, d_1, d_2, d_3] = d_4$\,. Der Vektor $g_4$ wird nun in die sogenannte Generatormatrix $G_{7,4}$ gepackt, @@ -362,13 +367,13 @@ sodass die Polynommultiplikation mit $d_4$ mittels Matrixmultiplikation realisie \[ c_7=G_{7,4} \cdot d_4= \begin{pmatrix} - \textcolor{red}{1} & 0 & 0 & 0 \\ - \textcolor{blue}{1} & \textcolor{red}{1} & 0 & 0 \\ - \textcolor{green}{0} & \textcolor{blue}{1} & \textcolor{red}{1} & 0 \\ - \textcolor{orange}{1} & \textcolor{green}{0} & \textcolor{blue}{1} & \textcolor{red}{1} \\ - 0 & \textcolor{orange}{1} & \textcolor{green}{0} & \textcolor{blue}{1} \\ - 0 & 0 & \textcolor{orange}{1} & \textcolor{green}{0} \\ - 0 & 0 & 0 & \textcolor{orange}{1} + \textcolor{red}{1} & 0 & 0 & 0 \\ + \textcolor{blue}{1} & \textcolor{red}{1} & 0 & 0 \\ + \textcolor{darkgreen}{0} & \textcolor{blue}{1} & \textcolor{red}{1} & 0 \\ + \textcolor{orange}{1} & \textcolor{darkgreen}{0} & \textcolor{blue}{1} & \textcolor{red}{1} \\ + 0 & \textcolor{orange}{1} & \textcolor{darkgreen}{0} & \textcolor{blue}{1} \\ + 0 & 0 & \textcolor{orange}{1} & \textcolor{darkgreen}{0} \\ + 0 & 0 & 0 & \textcolor{orange}{1} \end{pmatrix} \begin{pmatrix} d_0\\ -- cgit v1.2.1 From 87b92ddaef7dc6bd4322202343f39d6845acb2b0 Mon Sep 17 00:00:00 2001 From: Reto Date: Fri, 3 Sep 2021 21:19:23 +0200 Subject: small changes --- buch/papers/mceliece/fazit.tex | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/fazit.tex b/buch/papers/mceliece/fazit.tex index aab1f54..883f838 100644 --- a/buch/papers/mceliece/fazit.tex +++ b/buch/papers/mceliece/fazit.tex @@ -33,7 +33,7 @@ um einen Schlüssel für eine symmetrische Verschlüsselung auszutauschen. Entschlüsselungsaufwand: &2311* &6557176,5* \\ \end{tabular} \end{center} - \caption{\label{mceliece:tab:comparison_effort}Vergleich zwischen RSA und McEliece bezüglich Effizienz. (*Aufwand in binären Operationen pro Informationsbit\cite{mceliece:CodeBasedCrypto})} + \caption{\label{mceliece:tab:comparison_effort}Vergleich zwischen RSA und McEliece bezüglich Resourcen\cite{mceliece:CodeBasedCrypto}. (*Aufwand in binären Operationen pro Informationsbit)} \end{table} \subsection{Sicherheit} -- cgit v1.2.1 From c57d78ab001196e31558f0676928ccd4319e6fdd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andreas=20M=C3=BCller?= Date: Mon, 6 Sep 2021 09:59:16 +0200 Subject: editorial edits mceliece --- buch/papers/mceliece/aufbau.tex | 25 +++++++--- buch/papers/mceliece/einleitung.tex | 7 ++- buch/papers/mceliece/fazit.tex | 32 +++++++----- buch/papers/mceliece/funktionsweise.tex | 88 ++++++++++++++++++--------------- 4 files changed, 93 insertions(+), 59 deletions(-) (limited to 'buch/papers/mceliece') diff --git a/buch/papers/mceliece/aufbau.tex b/buch/papers/mceliece/aufbau.tex index ef45bc1..64c0cb3 100644 --- a/buch/papers/mceliece/aufbau.tex +++ b/buch/papers/mceliece/aufbau.tex @@ -7,8 +7,9 @@ \rhead{Aufbau} Das McEliece-Kryptosystem besteht aus folgenden Elementen: Nachfolgend sind alle Bestandteile für das McEliece-Kryptosystem aufgelistet, -wobei alle Vektoren und Matrizen, sowie die Rechenoperationen damit, +wobei alle Vektoren und Matrizen sowie die Rechenoperationen damit im binären Raum $\mathbb{F}_2$ stattfinden. +\index{F2@$\mathbb{F}_2$}% \subsection{Datenvektor $d_k$ \label{mceliece:subsection:d_k}} @@ -16,29 +17,39 @@ In diesem Vektor der Länge $k$ sind die zu verschlüsselnden Daten enthalten. \subsection{Binäre Zufallsmatrix $S_k$ \label{mceliece:subsection:s_k}} -$S_k$ ist eine Binäre Zufallsmatrix der Grösse $k \times k$. +$S_k$ ist eine binäre Zufallsmatrix der Grösse $k \times k$. Auch muss diese Matrix in $\mathbb{F}_2$ invertierbar sein. Für kleine Matrizen kann durchaus jedes Matrizenelement zufällig generiert werden, wobei danach mithilfe des Gauss-Algorithmus deren Inverse bestimmt werden kann. +\index{Gauss-Algorithmus}% +\index{inverse Matrix}% Da eine solche Matrix möglicherweise singulär ist, muss in diesem Fall eine neue Zufallsmatrix erzeugt werden. +\index{Zufallsmatrix}% Für grössere Matrizen existieren bessere Methoden, auf welche hier nicht weiter eingegangen wird \cite{mceliece:GenerationRandMatrix}. \subsection{Linear-Code-Generatormatrix $G_{n,k}$ \label{mceliece:subsection:g_nk}} +\index{Generator-Matrix}% +\index{Linear-Code}% Das wichtigste Element des McEliece-Systems ist ein fehlerkorrigierender Code, der in der Lage ist, $t$ Fehler zu korrigieren. +\index{fehlerkorrigierender Code}% Im Zusammenhang mit McEliece werden dabei meist binäre Goppa-Codes \cite{mceliece:goppa} verwendet, -es können prinzipiell auch andere Codes wie beispielsweise Reed-Solomon verwendet werden, +\index{Goppa-Code}% +es können prinzipiell auch andere Codes wie beispielsweise Reed-Solomon (Kapitel~\ref{chapter:reedsolomon}) verwendet werden, +\index{Reed-Solomon-Code}% jedoch besitzen einige (unter anderem auch Reed-Solomon) Codes Schwachstellen \cite{mceliece:lorenz}. Das Codieren mit diesem linearen Code kann mithilfe seiner Generatormatrix $G_{n,k}$ erfolgen. Da es sich um einen fehlerkorrigierenden Code handelt, wird das Codewort länger als das Datenwort, es wird also Redundanz hinzugefügt, +\index{Redundanz}% um die Fehlerkorrektur möglich zu machen. \subsection{Permutations-Matrix $P_n$ \label{mceliece:subsection:p_n}} -Mit der zufällig generierten Permutationsmatrix $P_n$ wird die Reihenfolge der Bits geändert. +Mit der zufällig generierten Permutationsmatrix $P_n$ (Abschnitt~\ref{buch:section:permutationsmatrizen}) wird die Reihenfolge der Bits geändert. +\index{Permutationsmatrix} Mit der Inversen $P_n^{-1}$ kann die Bitvertauschung rückgängig gemacht werden. \subsection{Public-Key $K_{n,k}$ @@ -46,7 +57,7 @@ Mit der Inversen $P_n^{-1}$ kann die Bitvertauschung rückgängig gemacht werden Der öffentliche Schlüssel, welcher zum Verschlüsseln verwendet wird, berechnet sich aus den bereits bekannten Matrizen wie folgt: \[ - K_{n,k}=P_{n}\cdot G_{n,k}\cdot S_{k}\,. + K_{n,k}=P_{n}\cdot G_{n,k}\cdot S_{k}. \] \subsection{Fehler-Vektor $e_n$ @@ -58,8 +69,8 @@ wie die Anzahl Fehler, die der Linearcode der Generatormatrix $G_{n,k}$ zu korri \subsection{Daten-Vektor $d_k$ \label{mceliece:subsection:d_k}} -In diesem Vektor der Länge $k$ ist die Nachricht (oder einen Teil davon) enthalten. +In diesem Vektor der Länge $k$ ist die Nachricht oder ein Teil davon enthalten. \subsection{Code-Vektor $c_n$ \label{mceliece:subsection:c_n}} -In diesem Vektor der Länge $n$ ist die verschlüsselte Nachricht (oder einen Teil davon) enthalten. \ No newline at end of file +In diesem Vektor der Länge $n$ ist die verschlüsselte Nachricht oder ein Teil davon enthalten. diff --git a/buch/papers/mceliece/einleitung.tex b/buch/papers/mceliece/einleitung.tex index e900837..f289512 100644 --- a/buch/papers/mceliece/einleitung.tex +++ b/buch/papers/mceliece/einleitung.tex @@ -7,10 +7,15 @@ \label{mceliece:section:einleitung}} \rhead{Einleitung} Beim McEliece-Kryptosystem handelt es sich um ein asymmetrisches Verschlüsselungsverfahren, welches erlaubt, +\index{McEliece-Kryptosystem}% +\index{Kryptosystem}% +\index{Verschlüsselungsverfahren, asymmetrisch}% +\index{asymmetrische Verschlüsselung}% Daten verschlüsselt über ein Netzwerk zu übermitteln, ohne dass vorab ein gemeinsamer, geheimer Schlüssel unter den Teilnehmern ausgetauscht werden müsste. -Eine andere, bereits erläuterte Variante einer asymmetrischen Verschlüsselung ist das Diffie-Hellman-Verfahren \ref{buch:subsection:diffie-hellman}. +Eine andere, bereits erläuterte Variante einer asymmetrischen Verschlüsselung ist das Diffie-Hellman-Verfahren (Abschnitt~\ref{buch:subsection:diffie-hellman}). Im Gegensatz zu Diffie-Hellman gilt das McEliece-System als quantencomputerresistent +\index{quantencomputerresistent}% und das Verschlüsseln/Entschlüsseln von Nachrichten wird hauptsächlich mit Matrizenoperationen durchgeführt. diff --git a/buch/papers/mceliece/fazit.tex b/buch/papers/mceliece/fazit.tex index 883f838..b53328f 100644 --- a/buch/papers/mceliece/fazit.tex +++ b/buch/papers/mceliece/fazit.tex @@ -10,16 +10,20 @@ Ein kurzer Vergleich des McEliece-Systems mit dem oft verwendeten RSA-System soll zeigen, wo dessen Vor- und Nachteile liegen. \subsection{Resourcen} -Eine Eigenheit des McEliece-Systems ist das Hinzufügen von Rauschen (mit Fehlervektor $e_n$). -Damit diese mit dem Linearcode-Decoder wieder entfernt werden können, +Eine Eigenheit des McEliece-Systems ist das Hinzufügen von Rauschen in Form des Fehlervektors $e_n$. +Damit dieses mit dem Linearcode-Decoder wieder entfernt werden können, wird Redundanz benötigt, weshalb dessen Kanalefizienz (Nutzbits/Übertragungsbits) sinkt. +\index{Kanaleffizienz}% + Die Schlüsselgrösse des McEliece-Systems ist deshalb so riesig, weil es sich um eine zweidimensionale Matrix handelt, währenddem RSA mit nur zwei Skalaren auskommt. +\index{Schlüsselgrösse}% Das McEliece-System benötigt dafür weniger Rechenaufwand beim Verschlüsseln/Entschlüsseln, da die meisten Operationen mit Matrixmultiplikationen ausgeführt werden können. +\index{Matrixmultiplikation}% Eine Übersicht zu diesem Thema bietet Tabelle \ref{mceliece:tab:comparison_effort}. - Beim Rechenaufwand sei noch erwähnt, +\index{Rechenaufwand}% dass asymmetrische Verschlüsselungen meist nur dazu verwendet werden, um einen Schlüssel für eine symmetrische Verschlüsselung auszutauschen. \begin{table} @@ -27,26 +31,32 @@ um einen Schlüssel für eine symmetrische Verschlüsselung auszutauschen. \begin{tabular}{l|c|c} &McEliece ($n=2048$, $k=1718$, $t = 30$) &RSA ($2048$, $e = 216 + 1$)\\ \hline - Schlüssegrösse (Public): &429.5 KByte &0.5 KByte \\ - Kanaleffizienz: &83.9 \% &100 \% \\ - Verschlüsselungsaufwand: &1025* &40555* \\ - Entschlüsselungsaufwand: &2311* &6557176,5* \\ + Schlüssegrösse (Public) &429.5 KByte &0.5 KByte \\ + Kanaleffizienz &83.9 \% &100 \% \\ + Verschlüsselungsaufwand\textsuperscript{$\dagger$} &1025 bitop &40555 bitop \\ + Entschlüsselungsaufwand\textsuperscript{$\dagger$} &2311 bitop &6557176.5 bitop \\ \end{tabular} \end{center} - \caption{\label{mceliece:tab:comparison_effort}Vergleich zwischen RSA und McEliece bezüglich Resourcen\cite{mceliece:CodeBasedCrypto}. (*Aufwand in binären Operationen pro Informationsbit)} + \caption{\label{mceliece:tab:comparison_effort}Vergleich zwischen RSA und McEliece bezüglich Resourcen \cite{mceliece:CodeBasedCrypto}.% (*Aufwand in binären Operationen pro Informationsbit)} + \quad\small\textsuperscript{$\dagger$}Aufwand in binären Operationen pro Informationsbit.} \end{table} \subsection{Sicherheit} Grosse Unterschiede zwischen den beiden Kryptosystemen gibt es jedoch bei der Sicherheit. +\index{Sicherheit}% Der Kern der RSA-Verschlüsselung beruht auf dem Problem, eine grosse Zahl in ihre beiden Primfaktoren zu zerlegen. +\index{Primfaktoren}% Bei genügend grossen Zahlen ist diese Zerlegung auch mit den heute besten verfügbaren Computern kaum innerhalb vernünftiger Zeit zu lösen. Weiter ist aber bekannt, dass mithilfe des sogenannten Shor-Algorithmus \cite{mceliece:shor} und einem Quantencomputer auch diese Zerlegung zügig realisiert werden könnte, +\index{Shor-Algorithmus}% +\index{Algorithmus von Shor}% +\index{Quantencomputer}% was zur Folge hätte, dass die Verschlüsselung von RSA unwirksam würde. -Zurzeit sind die Quantencomputer jedoch noch bei weitem nicht in der Lage, grosse Zahlen mithilfe dieses Algorithmuses zu zerlegen. +Zurzeit sind die Quantencomputer jedoch noch bei weitem nicht in der Lage, grosse Zahlen mithilfe dieses Algorithmus zu zerlegen. -Das McEliece-System hingegen beruht auf dem Problem des ``Syndrome decoding'' (Korrektur von Bitfehlern eines Codewortes, das mit einem entsprechenden Linearcode codiert wurde). -Für das ``Syndrome decoding'' sind bis heute keine Methoden bekannt, +Das McEliece-System hingegen beruht auf dem Problem des {\em Syndrome decoding}, also der Korrektur von Bitfehlern eines Codewortes, das mit einem entsprechenden Linearcode codiert wurde. +Für das {\em Syndrome decoding} sind bis heute keine Methoden bekannt, welche nennenswerte Vorteile gegenüber dem Durchprobieren (brute-force) bringen, auch nicht mithilfe eines Quantencomputers. Eine Übersicht betreffend des Rechenaufwandes zum Knacken der Verschlüsselung ist in Tabelle \ref{mceliece:tab:comparison_security} gegeben und bezieht sich auf die Schlüsselgrösse $N$. diff --git a/buch/papers/mceliece/funktionsweise.tex b/buch/papers/mceliece/funktionsweise.tex index 76b4b70..4d6c18d 100644 --- a/buch/papers/mceliece/funktionsweise.tex +++ b/buch/papers/mceliece/funktionsweise.tex @@ -18,7 +18,7 @@ und wie viele Bitfehler $t$ (angewendet mit Fehlervektor $e_n$) für das Rauschen des Code-Wortes $c_n$ verwendet werden. Danach generiert Alice (Empfängerin) ein Schlüsselpaar. Dazu erstellt sie die einzelnen Matrizen $S_k$, $G_{n,k}$ und $P_n$. -Diese drei einzelnen Matrizen bilden den privaten Schlüssel von Alice +Diese drei Matrizen bilden den privaten Schlüssel von Alice und sollen geheim bleiben. Der öffentliche Schlüssel $K_{n,k}$ hingegen berechnet sich aus der Multiplikation der privaten Matrizen (Abschnitt \ref{mceliece:subsection:k_nk}) @@ -30,7 +30,7 @@ Bob berechnet nun die verschlüsselte Nachricht $c_n$, indem er seine Daten $d_k mit dem öffentlichen Schlüssel $K_{n,k}$ von Alice multipliziert und anschliessend durch eine Addition mit einem Fehlervektor $e_n$ einige Bitfehler hinzufügt: \[ - c_n\,=\,K_{n,k}\cdot d_k + e_n\,. + c_n=K_{n,k}\cdot d_k + e_n. \] Dabei wird für jede Nachricht (oder für jedes Nachrichtenfragment) $d_k$ ein neuer, zufälliger Fehlervektor generiert. @@ -41,23 +41,23 @@ Die verschlüsselte Nachricht $c_n$ wird anschliessend Alice zugestellt. Alice entschlüsselt die erhaltene Nachricht in mehreren einzelnen Schritten. Um etwas Transparenz in diese Prozedur zu bringen, wird der öffentliche Schlüssel $K_{n,k}$ mit seinen Ursprungsmatrizen dargestellt: \begin{align*} - c_n\,&=\,K_{n,k}\cdot d_k + e_n \\ - &= P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + e_n\,. + c_n&=K_{n,k}\cdot d_k + e_n \\ + &= P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + e_n. \end{align*} Zuerst wird der Effekt der Permutationsmatrix rückgängig gemacht, indem das Codewort mit der Inversen $P_n^{-1}$ multipliziert wird: \begin{align*} - c_{n}''\,=\,P_n^{-1}\cdot c_n\,&= P_n^{-1}\cdot P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ - &= G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n\,. \\ + c_{n}''=P_n^{-1}\cdot c_n&= P_n^{-1}\cdot P_{n}\cdot G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ + &= G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n. \end{align*} Eine weitere Vereinfachung ist nun möglich, weil $P_n^{-1}$ einerseits auch eine gewöhnliche Permutationsmatrix ist und andererseits ein zufälliger Fehlervektor $e_n$ multipliziert mit einer Permutationsmatrix wiederum einen zufälligen Fehlervektor gleicher Länge und mit der gleichen Anzahl Fehlern $e_n'$ ergibt: \begin{align*} - c_{n}''\,&=\,G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ - &=\,G_{n,k}\cdot S_{k}\cdot d_k + e'_n \quad \text{mit} \quad - e'_n\,=\,P_n^{-1}\cdot e_n\,. + c_{n}''&=G_{n,k}\cdot S_{k}\cdot d_k + P_n^{-1}\cdot e_n \\ + &=G_{n,k}\cdot S_{k}\cdot d_k + e'_n \quad \text{mit} \quad + e'_n=P_n^{-1}\cdot e_n. \end{align*} Dank des fehlerkorrigierenden Codes, der durch die implizite Multiplikation mittels $G_{n,k}$ auf die Daten angewendet wurde, können nun die Bitfehler, verursacht durch den Fehlervektor $e'_n$, @@ -67,16 +67,16 @@ wird die Operation durch eine Funktion dargestellt. Wie dieser Decoder genau aufgebaut ist, hängt vom verwendeten Linearcode ab: \begin{align*} - c_{k}'\,&=\text{Linear-Code-Decoder($c''_n$)}\\ - &=\text{Linear-Code-Decoder($G_{n,k}\cdot S_{k}\cdot d_k + e'_n$)}\\ - &=S_{k}\cdot d_k\,. + c_{k}'&=\text{Linear-Code-Decoder}(c''_n)\\ + &=\text{Linear-Code-Decoder}(G_{n,k}\cdot S_{k}\cdot d_k + e'_n)\\ + &=S_{k}\cdot d_k. \end{align*} Zum Schluss wird das inzwischen fast entschlüsselte Codewort $c'_k$ mit der Inversen der zufälligen Binärmatrix $S^{-1}$ multipliziert, womit der Inhalt der ursprünglichen Nachricht nun wiederhergestellt wurde: -\begin{align*} - d'_{k}\,=\,S_{k}^{-1} \cdot c'_k&=S_{k}^{-1} \cdot S_{k}\cdot d_k\\ - &=d_k\,. -\end{align*} +\begin{equation*} + d'_{k}=S_{k}^{-1} \cdot c'_k=S_{k}^{-1} \cdot S_{k}\cdot d_k + =d_k. +\end{equation*} Möchte ein Angreifer die verschlüsselte Nachricht knacken, muss er die drei privaten Matrizen $S_k$, $G_{n,k}$ und $P_n$ kennen. Aus dem öffentlichen Schlüssel lassen sich diese nicht rekonstruieren und eine systematische Analyse der Codeworte wird durch das Hinzufügen von zufälligen Bitfehlern zusätzlich erschwert. @@ -95,7 +95,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1\\ 0 \end{pmatrix} - ,\, + ,\quad e_7= \begin{pmatrix} 0\\ @@ -105,7 +105,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0\\ 0\\ 0 - \end{pmatrix} + \end{pmatrix}. \] \end{itemize} \item Private Matrizen: @@ -117,7 +117,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 0 & 0 & 1\\ 0 & 1 & 0 & 1\\ 1 & 0 & 0 & 1 - \end{pmatrix},\, + \end{pmatrix},\quad S_4^{-1}= \begin{pmatrix} 0 & 1 & 0 & 1\\ @@ -137,7 +137,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 1 & 0 & 1\\ 0 & 0 & 1 & 0\\ 0 & 0 & 0 & 1 - \end{pmatrix},\, + \end{pmatrix}, \] \item[] \[ @@ -150,8 +150,8 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 0 & 0 & 0 & 0 & 1 & 0\\ 0 & 0 & 1 & 0 & 0 & 0 & 0\\ 0 & 0 & 0 & 0 & 1 & 0 & 0 - \end{pmatrix} - ,\, + \end{pmatrix}, + \quad P_7^{-1}=P_7^t= \begin{pmatrix} 0 & 0 & 0 & 0 & 0 & 1 & 0\\ @@ -161,11 +161,12 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 0 & 0 & 0 & 0 & 0 & 1\\ 0 & 0 & 1 & 0 & 0 & 0 & 0\\ 0 & 1 & 0 & 0 & 0 & 0 & 0 - \end{pmatrix} - \,. + \end{pmatrix}. \] \end{itemize} \item Öffentlicher Schlüssel: +\index{Schlüssel, öffentlicher}% +\index{öffentlicher Schlüssel}% \begin{itemize} \item[] \begin{align*} @@ -206,7 +207,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0 & 1 & 0 & 1\\ 1 & 0 & 0 & 1 \end{pmatrix} - \,. + . \end{align*} \end{itemize} \item Verschlüsselung: @@ -250,7 +251,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 0\\ 0 \end{pmatrix} - \,. + . \end{align*} \end{itemize} \item Entschlüsselung (Permutation rückgängig machen): @@ -287,14 +288,14 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1\\ 1 \end{pmatrix} - \,. + . \end{align*} \end{itemize} \item Entschlüsselung (Bitfehlerkorrektur mit Linearcode): \begin{itemize} \item[] \begin{align*} - c_{7}'\,&=\text{Linear-Code-Decoder($c''_7$)}=\\ + c_{7}'&=\text{Linear-Code-Decoder($c''_7$)}=\\ \begin{pmatrix} %c' 1\\ 0\\ @@ -312,7 +313,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1 \end{pmatrix} \text{)} - \,. + . \end{align*} \end{itemize} \item Entschlüsselung (Umkehrung des $S_4$-Matrix-Effekts): @@ -340,7 +341,7 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four 1\\ 1 \end{pmatrix} - \,. + . \end{align*} \end{itemize} \end{itemize} @@ -349,18 +350,22 @@ Der verwendete Linear-Code wird im Abschnitt \ref{mceliece:subsection:seven_four \label{mceliece:subsection:seven_four}} Beim 7/4-Code handelt es sich um einen linearen Code, der einen Bitfehler korrigieren kann. +\index{7/4-Code}% +\index{linearer Code}% +\index{Code, linear}% Es gibt unterschiedliche Varianten zum Erzeugen eines 7/4-Codes, -wobei der hier verwendete Code mithilfe des irreduziblen Generator-Polynoms $P_g = x^3 +x + 1$ generiert wird. -Somit lässt sich das Code-Polynom $P_c$ berechnen, indem das Daten-Polynom $P_d$ mit dem Generatorpolynom $P_g$ multipliziert wird (Codiervorgang): +wobei der hier verwendete Code mithilfe des irreduziblen Generatorpolynoms $P_g = x^3 +x + 1$ generiert wird. +\index{Generatorpolynom}% +Somit lässt sich das Codepolynom $P_c$ berechnen, indem das Datenpolynom $P_d$ mit dem Generatorpolynom $P_g$ multipliziert wird (Codiervorgang): \[ - P_c=P_g \cdot P_d\,. + P_c=P_g \cdot P_d. \] -Damit diese Multiplikation mit Matrizen ausgeführt werden kann, werden die Polynome in mit Vektoren dargestellt (Kapitel \ref{buch:section:polynome:vektoren}): +Damit diese Multiplikation mit Matrizen ausgeführt werden kann, werden die Polynome als Vektoren dargestellt (Kapitel \ref{buch:section:polynome:vektoren}): \[ P_g = \textcolor{red}{1}\cdot x^0 + \textcolor{blue}{1}\cdot x^1 + \textcolor{darkgreen}{0}\cdot x^2 + \textcolor{orange}{1}\cdot x^3 \implies - [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{darkgreen}{0}, \textcolor{orange}{1}] = g_4\,. + [\textcolor{red}{1}, \textcolor{blue}{1} ,\textcolor{darkgreen}{0}, \textcolor{orange}{1}] = g_4. \] -Auch das Daten-Polynom wird mit einem Vektor dargestellt: $P_d = d_0 \cdot x^0 + d_1 \cdot x^1 + d_2 \cdot x^2 + d_3 \cdot x^3 \implies [d_0, d_1, d_2, d_3] = d_4$\,. +Auch das Datenpolynom wird mit einem Vektor dargestellt: $P_d = d_0 \cdot x^0 + d_1 \cdot x^1 + d_2 \cdot x^2 + d_3 \cdot x^3 \implies [d_0, d_1, d_2, d_3] = d_4$. Der Vektor $g_4$ wird nun in die sogenannte Generatormatrix $G_{7,4}$ gepackt, sodass die Polynommultiplikation mit $d_4$ mittels Matrixmultiplikation realisiert werden kann: @@ -390,17 +395,19 @@ sodass die Polynommultiplikation mit $d_4$ mittels Matrixmultiplikation realisie c_4\\ c_5\\ c_6\\ - \end{pmatrix}\,. + \end{pmatrix}. \] -Beim nun entstandenen Code-Vektor $c_7=[c_0, ..., c_6]$ entsprechen die Koeffizienten dem dazugehörigen Code-Polynom $P_c=c_0\cdot x^0+...+c_6\cdot x^6$. +Beim nun entstandenen Codevektor $c_7=[c_0, ..., c_6]$ entsprechen die Koeffizienten dem dazugehörigen Codepolynom $P_c=c_0\cdot x^0+...+c_6\cdot x^6$. Aufgrund der Multiplikation mit dem Generatorpolynom $P_g$ lässt sich das Codewort auch wieder restlos durch $P_g$ dividieren. Wird dem Codewort nun einen Bitfehler hinzugefügt, entsteht bei der Division durch $P_g$ einen Rest. Beim gewählten Polynom beträgt die sogenannte Hamming-Distanz drei, das bedeutet, +\index{Hamming-Distanz}% dass vom einen gültigen Codewort zu einem anderen gültigen Codewort drei Bitfehler auftreten müssen. Somit ist es möglich, auf das ursprüngliche Bitmuster zu schliessen, solange maximal ein Bitfehler vorhanden ist. Jeder der möglichen acht Bitfehler führt bei der Division zu einem anderen Rest, womit das dazugehörige Bit identifiziert und korrigiert werden kann, -indem beispielsweise die Bitfehler mit dem dazugehörigen Rest in der sogenannten Syndrom-Tabelle (Tabelle \ref{mceliece:tab:syndrome}) hinterlegt werden. +indem beispielsweise die Bitfehler mit dem dazugehörigen Rest in der sogenannten Syndromtabelle (Tabelle \ref{mceliece:tab:syndrome}) hinterlegt werden. +\index{Syndromtabelle}% \begin{table} \begin{center} \begin{tabular}{|l|l|} @@ -418,5 +425,6 @@ indem beispielsweise die Bitfehler mit dem dazugehörigen Rest in der sogenannte \end{tabular} \end{center} - \caption{\label{mceliece:tab:syndrome}Syndrom-Tabelle 7/4-Code} + \caption{\label{mceliece:tab:syndrome}Syndromtabelle 7/4-Code} \end{table} +\index{Syndrom}% -- cgit v1.2.1