|
|
| Zeile 1: |
Zeile 1: |
| '''RSA''' ('''Rivest–Shamir–Adleman''') ist ein [[Asymmetrisches Kryptosystem|asymmetrisches kryptographisches Verfahren]], das sowohl zum [[Verschlüsselung|Verschlüsseln]] als auch zum [[Digitale Signatur|digitalen Signieren]] verwendet werden kann. Es verwendet ein Schlüsselpaar, bestehend aus einem privaten [[Schlüssel (Kryptologie)|Schlüssel]], der zum [[Entschlüsselung#Entschlüsselung in der Kryptologie|Entschlüsseln]] oder Signieren von Daten verwendet wird, und einem öffentlichen Schlüssel, mit dem man verschlüsselt oder Signaturen prüft. Der private Schlüssel wird geheim gehalten und kann nicht mit realistischem Aufwand aus dem öffentlichen Schlüssel berechnet werden. | | '''RSA''' ('''Rivest–Shamir–Adleman''') ist ein [[Asymmetrisches Kryptosystem|asymmetrisches kryptographisches Verfahren]], das sowohl zum [[Verschlüsselung|Verschlüsseln]] als auch zum [[Digitale Signatur|digitalen Signieren]] verwendet werden kann. Es verwendet ein Schlüsselpaar, bestehend aus einem privaten [[Schlüssel (Kryptologie)|Schlüssel]], der zum [[Entschlüsselung#Entschlüsselung in der Kryptologie|Entschlüsseln]] oder Signieren von Daten verwendet wird, und einem öffentlichen Schlüssel, mit dem man verschlüsselt oder Signaturen prüft. Der private Schlüssel wird geheim gehalten und kann nicht mit realistischem Aufwand aus dem öffentlichen Schlüssel berechnet werden. |
|
| |
| == Geschichte ==
| |
| Nachdem [[Whitfield Diffie]] und [[Martin Hellman]] im Jahr 1976 eine Theorie zur Public-Key-Kryptografie veröffentlicht hatten,
| |
| versuchten die drei Mathematiker [[Ronald L. Rivest|Rivest]], [[Adi Shamir|Shamir]] und [[Leonard Adleman|Adleman]] am [[Massachusetts Institute of Technology|MIT]], die Annahmen von Diffie und Hellman zu widerlegen. Nachdem sie den Beweis bei verschiedenen Verfahren durchführen konnten, stießen sie schließlich auf eines, bei dem sie keinerlei Angriffspunkte fanden. Hieraus entstand 1977 ''RSA'', das erste veröffentlichte asymmetrische Verschlüsselungsverfahren. Der Name RSA steht für die Anfangsbuchstaben ihrer Familiennamen. Da [[Leonard Adleman|Adleman]] seinen Anteil als gering einschätzte und anfangs gar nicht als Autor genannt werden wollte, kam es zur nicht-alphabetischen Reihenfolge der Autoren und damit zur Abkürzung RSA.
| |
|
| |
| Bereits Anfang der [[1970er]] Jahre war im britischen [[Government Communications Headquarters|GCHQ]] von [[James H. Ellis|Ellis]], [[Clifford Cocks|Cocks]] und [[Malcolm Williamson (Kryptologe)|Williamson]] ein ähnliches [[asymmetrisch]]es Verfahren entwickelt worden, welches aber keine große praktische Bedeutung erlangte und aus Geheimhaltungsgründen nicht wissenschaftlich publiziert wurde.
| |
| RSA konnte daher 1983 zum [[Patent]] angemeldet werden, obgleich es nicht das erste Verfahren dieser Art war. Das Patent erlosch am 21. September 2000.
| |
|
| |
| == Verfahren ==
| |
| Das Verfahren ist mit dem [[Rabin-Verschlüsselungsverfahren]] verwandt. Da es deterministisch arbeitet, ist es unter Umständen für bestimmte Angriffe anfällig. In der Praxis wird RSA daher mit dem [[Optimal Asymmetric Encryption Padding]] kombiniert.
| |
|
| |
| === Einwegfunktionen ===
| |
| [[Einwegfunktion]]
| |
| [[Funktion (Mathematik)|Funktionen]], bei denen eine Richtung leicht, die andere (Umkehrfunktion) schwierig zu berechnen ist, bezeichnet man als ''[[Einwegfunktion]]en'' ([[Englische Sprache|engl.]] ''one-way function''). Beispielsweise ist nach aktuellem Wissensstand die [[Faktorisierungsverfahren|Faktorisierung]] einer großen Zahl, also ihre Zerlegung in ihre Primfaktoren, sehr aufwändig, während das Erzeugen einer Zahl durch [[Multiplikation]] von Primzahlen recht einfach und schnell möglich ist. Spezielle Einwegfunktionen sind [[Einwegfunktion#Einwegfunktionen mit Falltür (Trapdoor-Einwegfunktionen)|Falltürfunktionen]] (engl. ''trapdoor one-way function''), die mit Hilfe einer Zusatzinformation auch rückwärts leicht zu berechnen sind.
| |
|
| |
| Die Verschlüsselung und die Signatur mit RSA basieren auf einer Einwegpermutation mit Falltür (engl. ''trapdoor one-way permutation'', kurz ''TOWP''), einer Falltürfunktion, die gleichzeitig [[Bijektive Funktion|bijektiv]], also eine [[Permutation]], ist. Die Einwegeigenschaft begründet, warum die Entschlüsselung (bzw. das Signieren) ohne den geheimen Schlüssel (die Falltür) schwierig ist.
| |
|
| |
| === Erzeugung des öffentlichen und privaten Schlüssels ===
| |
| Die Schlüssel bestehen aus den drei Zahlen <math>e, d</math> und <math>N</math>. Man nennt <math>N</math> den ''RSA-[[Division mit Rest#Modulo|Modul]]'', <math>e</math> den ''Verschlüsselungsexponenten'' und <math>d</math> den ''Entschlüsselungsexponenten''. Das [[Tupel|Zahlenpaar]] <math>(e,N)</math> bildet den [[Öffentlicher Schlüssel|öffentlichen Schlüssel]] (public key) und das Paar <math>(d,N)</math> den [[Geheimer Schlüssel|privaten Schlüssel]] (private key). Diese Zahlen werden durch das folgende Verfahren erzeugt:
| |
| # Wähle zufällig und [[Stochastisch unabhängige Ereignisse|stochastisch unabhängig]] zwei [[Primzahl]]en <math>p \neq q</math>. Diese sollen die gleiche Größenordnung haben, aber nicht zu dicht beieinander liegen, sodass der folgende Rahmen ungefähr eingehalten wird: <math>0{,}1<|\log_2 p -\log_2 q|<30</math>. (In der Praxis erzeugt man dazu solange Zahlen der gewünschten Länge und führt mit diesen anschließend einen [[Primzahltest]] durch, bis man zwei Primzahlen gefunden hat.)
| |
| # Berechne den RSA-[[Division mit Rest#Modulo|Modul]]
| |
| #: <math>N = p \cdot q</math>
| |
| # Berechne die [[Eulersche φ-Funktion#Berechnung|Eulersche φ-Funktion]] von <math>N</math>
| |
| #:<math>\varphi(N) = (p-1) \cdot (q-1)</math>
| |
| # Wähle eine zu <math>\varphi(N)</math> [[Teilerfremdheit|teilerfremde]] Zahl <math>e</math>, für die gilt <math>1 < e < \varphi(N)-1</math>.
| |
| # Berechne den Entschlüsselungsexponenten <math>d</math> als [[Inverses Element#Multiplikativ Inverses|multiplikativ Inverses]] von <math>e</math> bezüglich des [[Division mit Rest|Moduls]] <math>\varphi(N)</math>, was mit dem [[Erweiterter euklidischer Algorithmus|erweiterten euklidischen Algorithmus]] erfolgen kann. Es soll also die [[Kongruenz (Zahlentheorie)|Kongruenz]] gelten:
| |
| #: <math>e \cdot d \equiv 1\pmod{\varphi(N)}</math>
| |
|
| |
| Die Zahlen <math>p</math>, <math>q</math> und <math>\varphi(N)</math> werden nicht mehr benötigt und können nach der Schlüsselerstellung gelöscht werden. Es ist jedoch relativ einfach, diese Werte aus <math>e</math>, <math>d</math> und <math>N</math> zu rekonstruieren. <math>p, q, \varphi(N)</math> und <math>d</math> müssen geheim gehalten werden.
| |
|
| |
| Da die [[Primzahltest]]s inzwischen ausreichend schnell sind, wählt man heutzutage zuerst einen kleinen Exponenten <math>e</math> mit <math>2^{16} < e < 2^{64}</math> und verwirft bei der Erzeugung die Primzahlen <math>p, q</math>, für die <math>p-1, q-1</math> nicht teilerfremd zu <math>e</math> sind. Die Wahl eines <math>e</math> kleiner als die [[Fermat-Zahl]] <math>F_4 = 2^{16}+1 = 65537</math> kann zu Angriffsmöglichkeiten führen, etwa in Form des von [[Johan Håstad]] publizierten „Broadcast“-Angriffs, bei dem der Versand einer Nachricht an mehrere Empfänger zu einer Dechiffrierung über den [[Chinesischer Restsatz|chinesischen Restsatz]] führen kann.
| |
|
| |
| Wenn <math>d</math> weniger als ein Viertel der Bits des RSA-Moduls hat, kann <math>d</math> – sofern nicht bestimmte Zusatzbedingungen erfüllt sind – mit einem auf [[Kettenbruch|Kettenbrüchen]] aufbauenden Verfahren effizient ermittelt werden. Bei der Wahl eines Exponenten <math>e</math> kleiner als <math>2^{64}</math> ist diese Möglichkeit jedoch ausgeschlossen.
| |
|
| |
| ==== Beispiel ====
| |
| # Wir wählen den Exponenten <math>e = 23</math>.
| |
| # Wir wählen <math>p = 11</math> und <math>q = 13</math> für die beiden Primzahlen. Die Zahlen <math>p-1 = 10</math> und <math>q-1 = 12</math> sind teilerfremd zum Exponenten <math>e = 23</math>.
| |
| # Der RSA-Modul ist <math>N = p \cdot q = 143</math>. Damit bilden <math>e = 23</math> und <math>N = 143</math> den öffentlichen Schlüssel.
| |
| # Die eulersche [[Phi|φ]]-Funktion hat den Wert <math>\varphi(N) = \varphi(143) = (p-1)(q-1) = 120</math>.
| |
| # [[Prime Restklassengruppe|Berechnung der Inversen]] zu <math>e</math> modulo <math>\varphi(N)</math>:<br />Es gilt: <math> e \cdot d + k \cdot \varphi(N) = 1 = \operatorname{ggT}(e,\varphi(N))</math>,<br />im konkreten Beispiel: <math>23 \cdot d + k \cdot 120 = 1 = \operatorname{ggT}(23,120)</math>.<br />Mit dem erweiterten euklidischen Algorithmus berechnet man nun die Faktoren <math>d=47</math> und <math>k=-9</math>, und somit ist <math>d = 47</math> der private Schlüssel, während <math>k</math> nicht weiter benötigt wird.
| |
|
| |
| === Verschlüsseln von Nachrichten ===
| |
| [[Datei:Verschlüsselung (asymmetrisches Kryptosystem) Schema.svg|mini|Verschlüsselung]]
| |
| Um eine Nachricht <math>m</math> zu verschlüsseln, verwendet der Absender die Formel
| |
| :<math>c \equiv m^e\pmod N</math>
| |
| und erhält so aus der [[Klartext (Kryptographie)|Nachricht]] <math>m</math> den [[Geheimtext]] <math>c</math>. Die Zahl <math>m</math> muss dabei kleiner sein als der RSA-Modul <math>N</math>.
| |
|
| |
| ==== Beispiel ====
| |
| Es soll die Zahl 7 verschlüsselt werden. Der Sender benutzt den veröffentlichten Schlüssel des Empfängers <math>N = 143</math>, <math>e = 23</math> und rechnet
| |
| :<math>2 \equiv 7^{23}\pmod{143}</math>
| |
| Das [[Geheimtext|Chiffrat]] ist also <math>c = 2</math>.
| |
|
| |
| === Entschlüsseln von Nachrichten ===
| |
| [[Datei:Entschlüsselung (symmetrisches und asymmetrisches Kryptosystem) Schema.svg|mini|Entschlüsselung]]
| |
| Der Geheimtext <math>c</math> kann durch [[modulare Exponentiation]] wieder zum Klartext <math>m</math> entschlüsselt werden. Der Empfänger benutzt die Formel
| |
| :<math>m \equiv c^d\pmod N</math>
| |
| mit dem nur ihm bekannten Wert <math>d</math> sowie <math>N</math>.
| |
|
| |
| ==== Beispiel ====
| |
| Für gegebenes <math>c = 2</math> wird berechnet
| |
| :<math>7 \equiv 2^{47}\pmod{143}</math>
| |
| Der Klartext ist also <math>m = 7</math>.
| |
|
| |
| === Signieren von Nachrichten ===
| |
| Um eine Nachricht <math>m</math> zu signieren, wird vom Sender auf die Nachricht die RSA-Funktion mit dem eigenen privaten Schlüssel <math>d</math> angewandt. Zum Prüfen wendet der Empfänger auf die Signatur <math>m^d \bmod\ N</math> mit Hilfe des öffentlichen Schlüssels des Senders <math>e</math> die Umkehrfunktion an und vergleicht diese mit der zusätzlich übermittelten unverschlüsselten Nachricht <math>m</math>. Wenn beide übereinstimmen, ist die Signatur gültig und der Empfänger kann sicher sein, dass derjenige, der das Dokument signiert hat, auch den privaten Schlüssel besitzt und dass niemand seit der Signierung das Dokument geändert hat. Es wird also die [[Integrität (Informationssicherheit)|Integrität]] und [[Authentizität]] garantiert, vorausgesetzt, der private Schlüssel ist wirklich geheim geblieben.
| |
| Aufgrund der [[Homomorphismus|Homomorphieeigenschaft]] von RSA ist dieses Signaturverfahren jedoch ungeeignet. Liegen zwei Signaturen <math>m_1^d</math>, <math>m_2^d</math> vor, so kann ein Angreifer daraus durch Multiplizieren die Signatur der Nachricht <math>m_1m_2</math> berechnen. Sogar aus nur einer Signatur <math>m^d</math> kann ein Angreifer beliebig viele Nachrichten-Signatur-Paare erzeugen: <math>(m\cdot c^e,m^d\cdot c)</math> ist ein solches Paar für beliebige <math>c</math>.
| |
|
| |
| Dieses Problem kann umgangen werden, indem nicht die Nachricht selbst signiert wird. Stattdessen wird mit einer zusätzlich zum Signaturverfahren spezifizierten kollisionsresistenten [[Hashfunktion]] <math>H</math> der Hash-Wert <math>H(m)</math> der Nachricht <math>m</math> berechnet. Dieser wird mit dem privaten Schlüssel signiert, um die eigentliche Signatur zu erhalten. Der Empfänger kann die so erhaltene Signatur mit dem öffentlichen Schlüssel verifizieren und erhält dabei einen Wert <math>h'</math>. Diesen vergleicht er mit dem von ihm selbst gebildeten Hashwert <math>H(m)</math> der ihm vorliegenden Nachricht <math>m</math>. Wenn beide Werte <math>H(m)=h'</math> übereinstimmen, kann mit hoher Wahrscheinlichkeit davon ausgegangen werden, dass die Nachricht fehlerfrei übertragen wurde und nicht gefälscht ist. Auch diese Modifikation erfüllt allerdings nicht die modernen Sicherheitsanforderungen, daher werden Verfahren wie RSA-[[Probabilistic Signature Scheme|PSS]] verwendet, um mit RSA zu signieren.
| |
|
| |
| {{Siehe auch|Elektronische Unterschrift|Full-Domain-Hash}}
| |
|
| |
| === RSA mit dem Chinesischen Restsatz ===
| |
| Mit Hilfe des [[Chinesischer Restsatz|Chinesischen Restsatzes]] können Nachrichten effizienter entschlüsselt oder signiert werden.
| |
| Weil der Modul <math>N</math> sehr groß ist, sind auch die im Rechner verwendeten Bitdarstellungen der Zahlen sehr lang.
| |
| Der Chinesische Restsatz erlaubt es, die Berechnungen statt in einer [[Gruppe (Mathematik)|Gruppe]] der Größe <math>N</math> gleichzeitig in den zwei kleineren Gruppen der Größe <math>p</math> und <math>q</math> auszuführen und das Ergebnis danach wieder zusammenzusetzen.
| |
| Da hier die Zahlen wesentlich kleiner sind, ist diese Berechnung insgesamt schneller.
| |
| Diese Variante wird nach der englischen Bezeichnung des Chinesischen Restsatzes CRT (Chinese remainder theorem) auch CRT-RSA genannt.
| |
|
| |
| Der private Schlüssel besteht dann im Gegensatz zu dem, was im Rest dieses Artikels angenommen wird, aus folgenden Komponenten:
| |
| * <math>N</math>, der ''RSA-Modul'',
| |
| * <math>d</math>, der ''Entschlüsselungsexponent'',
| |
| * <math>p</math>, die ''erste Primzahl,''
| |
| * <math>q</math>, die ''zweite Primzahl'' (ungleich p),
| |
| * <math>d_p = d \bmod (p-1)</math>, häufig ''dmp1'' genannt,
| |
| * <math>d_q = d \bmod (q-1)</math>, häufig ''dmq1'' genannt und
| |
| * <math>q_{Inv} = q^{-1} \bmod p</math>, häufig ''iqmp'' genannt.
| |
|
| |
| Eine Nachricht <math>m</math> wird dann wie folgt signiert:
| |
| * <math>m_1 = m^{d_p} \bmod p</math>
| |
| * <math>m_2 = m^{d_q} \bmod q</math>
| |
| * <math>s = (q_{Inv}(m_1-m_2) \bmod p)q + m_2</math>
| |
|
| |
| Aus der letzten Gleichung sieht man sofort, dass <math>s \bmod q = m_2</math> und <math>s \bmod p = q_{Inv}q(m_1-m_2) + m_2 \bmod p = m_1</math>.
| |
| Die Signatur <math>s</math> stimmt also sowohl <math>\bmod p</math> als auch <math>\bmod q</math> mit <math>m^d</math> überein, daher ist nach dem Chinesischen Restsatz <math>s = m^d \bmod N</math>. (Bemerkung: Die Identität <math>s = m^d \bmod p</math> sieht man so: Modulo p gilt <math>s = m^{d_p}=m^{d+k(p-1)}=m^d (m^{p-1})^k=m^d</math>. Die letzte Identität folgt aus dem [[Kleiner fermatscher Satz|kleinen fermatschen Satz]]. Analog erhält man <math>s = m^d \bmod q</math>.)
| |
|
| |
| === RSA ist kein Primzahltest ===
| |
| Wenn <math>p \neq q</math> [[Primzahl]]en sind, funktioniert das RSA-Verfahren. Umgekehrt kann aber aus dem funktionierenden RSA-Verfahren nicht geschlossen werden, dass der Modul <math>N</math> das Produkt zweier Primzahlen <math>p</math> und <math>q</math> ist, denn mit [[Carmichael-Zahl]]en funktioniert das Verfahren auch.
| |
|
| |
| == Sicherheit ==
| |
| Public-Key-Verschlüsselungs-Verfahren wie RSA werden in der Praxis immer als hybride Verfahren in Verbindung mit symmetrischen Verfahren verwendet. Bei der Analyse der Sicherheit im praktischen Einsatz müssen die Sicherheit des Public-Key-Verfahrens und die praktische Sicherheit des Gesamtsystems betrachtet werden. Angriffe auf das RSA-Verfahren erfolgen oft über [[Seitenkanalattacke|Seitenkanäle]]. Das Gesamtsystem kann unsicher sein, wenn nur eine Komponente, beispielsweise ein Computer, kompromittiert wurde.
| |
|
| |
| === Beziehung zwischen RSA und dem Faktorisierungsproblem ===
| |
| Bei der [[Kryptoanalyse]] des RSA-Verfahrens unterscheidet man zwischen zwei Problemen:
| |
| * RSA-Problem (<math>\mathrm{RSAP}</math>): Gegeben sind der öffentliche Schlüssel <math>(N, e)</math> sowie der Geheimtext <math>c</math>. Gesucht wird der Klartext <math>m</math>, wobei gilt: <math>m^e\equiv c\pmod{N}</math>
| |
| : Das Problem liegt hier in der Schwierigkeit, <math>e</math>-te Wurzeln [[Division mit Rest|modulo]] <math>N</math> zu ziehen, was zur Bestimmung der Nachricht <math>m</math> notwendig ist.
| |
| * RSA-Schlüsselproblem (<math>\mathrm{RSAP^*}</math>): Gegeben ist der öffentliche Schlüssel <math>(N, e)</math>. Gesucht wird der geheime Schlüssel <math>d</math>, wobei gilt: <math>ed\equiv 1\pmod{\varphi(N)}</math>
| |
| : Das Problem liegt hier in der Schwierigkeit, die [[Eulersche φ-Funktion]] von <math>N</math> ''ohne'' Kenntnis der Faktoren ''p'' und ''q'' zu berechnen.
| |
|
| |
| Folgende Beziehungen zwischen den RSA-Problemen und <math>\mathrm{FACTORING}</math>, dem [[Faktorisierungsverfahren|Faktorisierungsproblem]], sind bekannt:
| |
| :<math>\mathrm{RSAP} \leq_p \mathrm{RSAP^*} =_p \mathrm{FACTORING}</math>
| |
|
| |
| Die Beziehung <math>\mathrm{RSAP} \leq_p \mathrm{RSAP^*}</math> ist trivial, denn wenn man den privaten Schlüssel hat, kann man damit wie oben jeden beliebigen Geheimtext entschlüsseln. Ob die Umkehrung gilt, ist zurzeit unbekannt.
| |
|
| |
| Auch die Beziehung <math>\mathrm{RSAP^*} \leq_p \mathrm{FACTORING}</math> ist trivial, denn wenn man <math>N=pq</math> faktorisiert hat, kann man damit leicht <math>\varphi(N)=(p-1)(q-1)</math> berechnen, und dann mit dem euklidischen Algorithmus zu gegebenem öffentlichen Schlüssel den zugehörigen privaten Schlüssel effizient berechnen, wie in der Schlüsselerzeugung.
| |
|
| |
| Für die Beziehung <math>\mathrm{FACTORING} \leq_p \mathrm{RSAP^*}</math> ist schon lange ein ''probabilistischer'' Polynomialzeitalgorithmus bekannt. Vor kurzem wurde gezeigt, dass sich diese Reduktion im balancierten RSA (d. h. <math>p</math> und <math>q</math> haben gleiche Bitlänge) auch ''deterministisch'' durchführen lässt. Der Beweis verwendet das Coppersmith-Verfahren zur Bestimmung von Nullstellen eines irreduziblen bivariaten Polynoms mit ganzzahligen Koeffizienten, welches sich auf eine [[Gitter (Mathematik)#Gitterreduktion|Gitterbasenreduktion]] zurückführen lässt.
| |
|
| |
| Da alle gängigen Implementierungen balanciertes RSA verwenden, ist in der Praxis das Brechen des geheimen Schlüssels nur mit der Kenntnis des öffentlichen Schlüssels genau so schwer wie das Faktorisieren von <math>N</math>. Wegen <math>\mathrm{RSAP} \leq_p \mathrm{FACTORING}</math> ist im Fall der zusätzlichen Kenntnis eines Geheimtexts die Schwierigkeit des Faktorisierungsproblems von zentralem Interesse.
| |
|
| |
| === Schwierigkeit des Faktorisierungsproblems ===
| |
| Man möchte <math>N=pq</math> für sehr große Primzahlen <math>p</math> und <math>q</math> faktorisieren. Diese [[Primfaktorzerlegung]] ist für große Zahlen mit den heute bekannten Verfahren praktisch nicht durchführbar. Es ist aber nicht bewiesen, dass es sich bei der Primfaktorzerlegung um ein prinzipiell schwieriges Problem handelt.
| |
|
| |
| Mit dem [[Quadratisches Sieb|Quadratischen Sieb]] wurde 1994 die Zahl [[RSA-129]] mit 129 Dezimalstellen in 8 Monaten von ca. 600 Freiwilligen faktorisiert. Mit der Methode des [[Zahlkörpersieb]]s wurde im Jahr 2005 von Wissenschaftlern der [[Rheinische Friedrich-Wilhelms-Universität Bonn|Friedrich-Wilhelms-Universität Bonn]] die im Rahmen der [[RSA Factoring Challenge]] von RSA Laboratories vorgegebene 200-stellige Dezimalzahl RSA-200 in ihre zwei großen Primfaktoren zerlegt.
| |
| Die ersten RSA-Zahlen bis RSA-500 wurden entsprechend der Anzahl der Dezimalstellen benannt, weitere RSA-Zahlen nach der Anzahl der Binärstellen. Die Faktorisierung begann Ende 2003 und dauerte bis Mai 2005. Unter anderem kam ein [[Rechnerverbund]] von 80 handelsüblichen Rechnern an der Universität Bonn zum Einsatz. Im November 2005 zahlten RSA Laboratories für die Faktorisierung von RSA-640, einer Zahl mit 640 Bits bzw. 193 Dezimalstellen, eine Prämie von 20.000 US-Dollar.
| |
| Obwohl mittlerweile für das Faktorisieren der RSA-Challenge-Zahlen keine Prämien mehr gezahlt werden, wurde im Dezember 2009 die Zahl RSA-768 faktorisiert.
| |
|
| |
| Für die Faktorisierung von RSA-1024 (309 Dezimalstellen) oder gar RSA-2048 (617 Dezimalstellen) waren 100.000 $ bzw. 200.000 $ ausgelobt; die RSA Laboratories haben im Mai 2007 die RSA Factoring Challenge beendet, nachdem die o. g. Wissenschaftler der Universität Bonn im selben Monat eine 1039-Bit [[Mersenne-Primzahl|Mersennezahl]] (312 Dezimalstellen) faktorisiert hatten. Aufgrund der ungleichen Stellenzahl der Faktoren war das aber wesentlich leichter, als eine RSA-Zahl gleicher Länge zu faktorisieren. Die wachsende Rechenleistung moderner Computer stellt für die kurzfristige Sicherheit von RSA im Wesentlichen kein Problem dar, zumal diese Entwicklung vorhersehbar ist: Der Nutzer kann bei der Erzeugung seines Schlüssels darauf achten, dass der während der Dauer der beabsichtigten Verwendung nicht faktorisiert werden kann. Nicht vorhersehbare Entwicklungen wie die Entdeckung deutlich schnellerer Algorithmen oder gar Schaffung eines leistungsfähigen [[Quantencomputer]]s, der die Faktorisierung von Zahlen durch Verwendung des [[Shor-Algorithmus]] effizient durchführen könnte, bergen zumindest für die mittel- und langfristige Sicherheit der verschlüsselten Daten gewisse Risiken.
| |
|
| |
| Zum konkreten Sicherheitsniveau bestimmter Schlüssellängen gibt es unterschiedliche Aussagen. Laut [[Bundesnetzagentur]] sind für RSA-basierte Signaturen bis Ende 2020 Schlüssel mit einer Mindestlänge von 1976 Bit geeignet (Empfehlung 2048 Bit). Für Signaturverfahren nach den Anforderungen aus {{§|17|sigg_2001|buzer}} Abs. 1 bis 3 SigG, „für die die besten bekannten Angriffe auf dem Problem der Faktorisierung großer Zahlen oder auf dem Problem der Berechnung diskreter Logarithmen in endlichen Körpern beruhen (RSA und [[Digital Signature Algorithm|DSA]]), werden Schlüssellängen von mindestens 3 000 Bit verpflichtend werden“, um perspektivisch mindestens ein Sicherheitsniveau von 120 Bit zu etablieren.
| |
|
| |
| === Schwierigkeit des RSA-Problems ===
| |
| In einigen Spezialfällen kann man das RSA-Verfahren brechen, ohne das Faktorisierungsproblem gelöst zu haben. Der Angriff von Wiener bei balanciertem RSA löst das RSA-Schlüsselproblem effizient unter der Annahme, dass der private Schlüssel nur eine geringe Bitlänge aufweist, genauer <math>d<\tfrac13\sqrt[4]{N}</math>. Wiener verwendete dabei die Tatsache, dass unter der Abschätzung für <math>d</math> der Bruch <math>\tfrac{k}{d}</math> (für eine ganze Zahl <math>k</math>) in der Kettenbruchentwicklung von <math>\tfrac{e}{N}</math> auftaucht. Die Schranke wurde mit Mitteln der Gitterbasenreduktion auf <math>d<N^{0{,}292}</math> verbessert.
| |
|
| |
| Auch das RSA-Problem kann unter einigen Annahmen effizient ohne Faktorisieren gelöst werden. Der Angriff von Håstad ermittelt einen Klartext, der mit kleinem Verschlüsselungsexponenten (etwa <math>e=3</math>) für mehrere Empfänger vor dem Verschlüsseln speziell aufbereitet wurde, etwa wenn die Nummer des Empfängers in den Klartext codiert wurde. Dieser Angriff verwendet die Coppersmith-Methode, um kleine Nullstellen eines Polynoms in einer Unbestimmten zu berechnen, welche wiederum auf Gitterbasenreduktion beruht.
| |
|
| |
| === Angriffe gegen das unmodifizierte RSA-Verfahren („Textbook-RSA“) ===
| |
| RSA ist in der oben beschriebenen Version, die auch als „Textbook-RSA“ bekannt ist, weder als Verschlüsselungs- noch als Signaturverfahren geeignet, da es in beiden Fällen auf gravierende Weise unsicher ist und als Signaturverfahren auch keine langen Nachrichten signieren kann.
| |
|
| |
| Die RSA-Verschlüsselung ist deterministisch. Das erlaubt es einem Angreifer, einen Klartext zu raten, ihn mit dem öffentlichen Schlüssel zu verschlüsseln und dann mit einem Chiffrat zu vergleichen. Dies kann insbesondere bei sehr kurzen Nachrichten wie “Ja” und „Nein“ sehr praktikabel und verheerend sein. Hieraus folgt, dass unmodifiziertes RSA nicht [[IND-CPA]]-sicher ist, heute eine absolute Minimalanforderung an Verschlüsselungsverfahren.
| |
|
| |
| Wenn der Klartext <math>m</math> und der Verschlüsselungsexponent <math>e</math> so klein sind, dass sogar <math>c = m^e < N</math> ist, dann kann ein Angreifer die <math>e</math>-te Wurzel aus <math>c</math> ziehen und das Chiffrat auf diese Weise entschlüsseln. Wurzelziehen ist nur modulo einer großen Zahl schwierig, aber in diesem Fall kann <math>c</math> als ganze Zahl betrachtet werden.
| |
|
| |
| Wenn dieselbe Nachricht <math>m</math> zu mehreren Empfängern geschickt wird, die zwar alle unterschiedliche (und teilerfremde) Moduli <math>N_i</math> benutzen, aber als öffentlichen Schlüssel den gleichen Exponenten <math>e</math>, dann kann aus <math>e</math> Nachrichten <math>m^e \bmod N_1, \ldots, m^e \bmod N_l</math> mit dem Chinesischen Restsatz <math>m^e \bmod \prod N_i</math> berechnet werden. Weil <math>m^e < \prod N_i</math> (nach Voraussetzung ist <math>m < N_i</math> für alle <math>i</math>), kann diese Zahl wieder als in den ganzen Zahlen liegend aufgefasst werden und Wurzelziehen ist dort einfach. Dieser Angriff wird nach seinem Entdecker Johan Håstad als „Håstads Angriff“ bezeichnet.
| |
|
| |
| Da die RSA-Funktion <math>x \mapsto x^d \bmod N</math> [[Homomorphismus|multiplikativ]] ist (d. h. <math>(xy)^d =x^dy^d \bmod N</math> gilt), kann man aus jedem Chiffrat <math>m^e</math> ein weiteres gültiges Chiffrat <math>m^er^e = (mr)^e</math> erzeugen. Wenn man den Besitzer des zugehörigen geheimen Schlüssels davon überzeugen kann, diese Zahl zu entschlüsseln oder zu signieren, kann man aus dem Ergebnis <math>mr</math> leicht <math>m</math> gewinnen.
| |
|
| |
| Dieselbe Eigenschaft erlaubt auch einen Angriff auf das Signaturverfahren. Aus bekannten Klartext-Signaturpaaren <math> s_1 = m_1^d, \ldots, s_k = m_k^d</math> lassen sich weitere gültige Signaturen
| |
| :<math>s=\prod s_i\bmod N</math> zu Nachrichten <math>m=\prod m_i\bmod N</math>
| |
| berechnen.
| |
|
| |
| === Padding ===
| |
| Um solche Angriffe zu verhindern, werden bei RSA-Verschlüsselung und RSA-Signatur sogenannte [[Padding (Informatik)|Padding]]-Verfahren eingesetzt. Standards für Padding-Verfahren für RSA werden z. B. in [[PKCS|PKCS#1]] oder [[Internationale Organisation für Normung|ISO]] 9796 definiert. Diese nutzen aus, dass die Länge des Klartextes bzw. Hash-Wertes deutlich kleiner als die Länge von <math>N</math> ist, und fügen dem Klartext bzw. dem Hash-Wert vor der Verschlüsselung oder Signatur eine Zeichenfolge R mit vorgegebener Struktur an, die unter mehreren möglichen zufällig gewählt wird und dadurch das Chiffrat randomisiert. Es wird also die RSA-Funktion nicht auf die Nachricht <math>M</math> oder auf den Hash-Wert <math>h(M)</math> angewandt, sondern auf den Klartext (bzw. seinem Hashwert) mit angehängtem <math>R</math>. In der Regel enthält <math>R</math> eine Angabe über die Länge der Nachricht oder des Hash-Wertes oder eine eindeutige Zeichenfolge, die den Beginn von <math>R</math> kennzeichnet. Dies erleichtert nicht nur die Dekodierung, sondern erschwert auch Angriffe. Padding-Verfahren können für die Berechnung von <math>R</math> auch Zufallszahlen und Hashfunktionen verwenden.
| |
| Einige moderne Paddingverfahren – beispielsweise das [[Optimal Asymmetric Encryption Padding]] (OAEP) oder das [[Probabilistic Signature Scheme]] (PSS) – verwenden kryptographische Hashfunktionen, um den Klartext vor der Verschlüsselung weiter zu randomisieren, und sind unter idealisierenden Annahmen an die verwendete Hashfunktion beweisbar sicher unter der RSA-Annahme.
| |
|
| |
| === Chosen-Ciphertext-Angriff ===
| |
| [[Daniel Bleichenbacher]] stellte 1998 einen Angriff auf die in [[PKCS|PKCS#1 v1]] spezifizierte RSA-Verschlüsselung vor. Dabei nutzte er aus, dass PKCS#1 v1 ein Nachrichtenformat vorgibt und einige Implementierungen nach dem Entschlüsseln Fehlermeldungen ausgeben, falls dieses Format nicht eingehalten wurde. Um den Angriff gegen ein Chiffrat <math>c</math> durchzuführen, wählt man eine Zahl <math>s</math> und berechnet daraus ein neues Chiffrat <math>s^e c</math>. Bei dem Nachrichtenformat sind die ersten zwei Bytes 00 und 02, wenn also keine Fehlermeldung kommt, weiß man, dass sowohl bei der ursprünglichen Nachricht <math>m</math> als auch bei der neuen Nachricht <math>sm</math> die ersten beiden Bytes 00 02 sind. Mehrfache Wiederholung mit geschickt gewählten <math>s</math> erlauben es, nach und nach den gesamten Klartext aufzudecken.
| |
| RSA nach [[PKCS|PKCS#1 ab Version 2]] ist immun gegen diesen Angriff.
| |
|
| |
| === Sicherheit hybrider Verfahren ===
| |
| RSA wird aus Effizienzgründen in der Regel in Hybridverfahren mit symmetrischen Verfahren kombiniert. Zur hybriden Verschlüsselung wird zufällig ein Sitzungsschlüssel für ein symmetrisches Verschlüsselungsverfahren generiert, der dann per RSA verschlüsselt und zusammen mit der Nachricht übertragen wird. Zum Signieren wird nicht die gesamte Nachricht, sondern nur ein Hash-Wert signiert.
| |
|
| |
| Für die Sicherheit von RSA sind Primzahlen mit mehreren hundert Dezimalstellen (mindestens 2048 Bit) erforderlich. Damit können symmetrische Schlüssel jeder üblichen Länge verschlüsselt werden. Gängige Verfahren zur symmetrischen Verschlüsselung basieren beispielsweise auf der Blockchiffre [[Advanced Encryption Standard|AES]] mit einer Schlüssellänge von 128, 192 oder maximal 256 Bit.
| |
|
| |
| Eine sichere Hashfunktion wie [[SHA-2]] erzeugt Hashwerte mit einer Länge von 224 bis 512 Bit. Damit lassen sich Signaturverfahren mittels RSA realisieren, die nur einen Signaturschritt benötigen.
| |
|
| |
| Die Sicherheit des Gesamtsystems hängt sowohl im Fall der Verschlüsselung als auch der Signatur von der Sicherheit beider verwendeter Verfahren ab. Da bei RSA für ein ähnliches Sicherheitsniveau wie beim symmetrischen Verfahren deutlich längere Schlüssel nötig sind, wird die Sicherheit des Hybridverfahrens meistens von der Sicherheit des Public-Key-Verfahrens bestimmt.
| |
|
| |
| == Vollständiges Beispiel ==
| |
| === Anmerkung ===
| |
| * RSA direkt auf Texte anzuwenden, birgt erhebliche Risiken. RSA wird deshalb, anders als im Beispiel, in der Praxis praktisch nur in Kombination mit anderen Verfahren verwendet. (Siehe: [[Hybride Verschlüsselung]] und Abschnitt [[#Angriffe gegen das unmodifizierte RSA-Verfahren („Textbook-RSA“)|Angriffe gegen das unmodifizierte RSA-Verfahren]].)
| |
| * Um das Beispiel übersichtlich zu halten, wurden relativ kleine Primzahlen verwendet. Zur sicheren Verschlüsselung werden typischerweise mindestens 600-[[Dezimalsystem|stellige]] <math>N</math> empfohlen.
| |
|
| |
| === Vorarbeiten ===
| |
| Die oben genannten Schritte sollen nun an einem vollständigen Beispiel erläutert werden. Um einen Text zu verschlüsseln, müssen zunächst Buchstaben in Zahlen umgewandelt werden. Dazu verwendet man in der Praxis zum Beispiel den [[ASCII]]-Code. Hier sei willkürlich die folgende Zuordnung gewählt:
| |
| A=01 B=02 C=03 usw. (00 = Leerzeichen)
| |
| Darüber hinaus sei angenommen, dass jeweils drei Zeichen zu einer Zahl zusammengefasst werden. Die Buchstabenfolge AXT wird also zu 012420. Die kleinste zu verschlüsselnde Zahl ist dann 000000 (drei Leerzeichen), die größte 262626 (ZZZ). Der Modul <math>N = p \cdot q</math> muss also größer als 262626 sein.
| |
|
| |
| Klartext: W I K I P E D I A
| |
| Kodierung: 23 09 11 09 16 05 04 09 01
| |
|
| |
| === Schlüsselerzeugung ===
| |
| Zunächst werden geheim zwei Primzahlen gewählt, beispielsweise <math>p=307</math> und <math>q=859</math>. Damit ergibt sich:
| |
|
| |
| :<math>N = p \cdot q = 263713</math>
| |
|
| |
| :<math>\varphi(N) = (p-1) \cdot (q-1) = 262548</math>
| |
|
| |
| :<math>e = 1721</math> (zufällig, teilerfremd zu <math>\varphi(N)</math>)
| |
|
| |
| :<math>d = 1373</math> (das [[Inverses Element|multiplikative Inverse]] zu <math>e \pmod{\varphi(N)}</math> mit Hilfe des [[Erweiterter euklidischer Algorithmus|erweiterten euklidischen Algorithmus]])
| |
|
| |
| Öffentlicher Schlüssel:
| |
| :<math>e = 1721</math> und <math>N = 263713</math>
| |
|
| |
| Privater Schlüssel:
| |
| :<math>d = 1373</math> und <math>N = 263713</math>
| |
|
| |
| === Verschlüsselung ===
| |
| C<sub>n</sub> = K<sub>n</sub><sup>e</sup> mod N für n=1,2,3(,...)
| |
| C<sub>1</sub> = 230911<sup>1721</sup> mod 263713 = 001715
| |
| C<sub>2</sub> = 091605<sup>1721</sup> mod 263713 = 184304
| |
| C<sub>3</sub> = 040901<sup>1721</sup> mod 263713 = 219983
| |
|
| |
| === Entschlüsselung ===
| |
| K<sub>n</sub> = C<sub>n</sub><sup>d</sup> mod N für n=1,2,3(,...)
| |
| K<sub>1</sub> = 001715<sup>1373</sup> mod 263713 = 230911
| |
| K<sub>2</sub> = 184304<sup>1373</sup> mod 263713 = 091605
| |
| K<sub>3</sub> = 219983<sup>1373</sup> mod 263713 = 040901
| |
|
| |
| === Signatur ===
| |
| C<sub>n</sub> = K<sub>n</sub><sup>d</sup> mod N
| |
| C<sub>1</sub> = 230911<sup>1373</sup> mod 263713 = 219611
| |
| C<sub>2</sub> = 091605<sup>1373</sup> mod 263713 = 121243
| |
| C<sub>3</sub> = 040901<sup>1373</sup> mod 263713 = 138570
| |
|
| |
| === Verifikation ===
| |
| K<sub>n</sub> = C<sub>n</sub><sup>e</sup> mod N
| |
| K<sub>1</sub> = 219611<sup>1721</sup> mod 263713 = 230911
| |
| K<sub>2</sub> = 121243<sup>1721</sup> mod 263713 = 091605
| |
| K<sub>3</sub> = 138570<sup>1721</sup> mod 263713 = 040901
| |
|
| |
| Die Berechnung der modularen Exponentiation kann durch [[binäre Exponentiation]] (Square-and-multiply) beschleunigt werden.
| |
| :<math>7^{23} \ \bmod \ 143 \ = \ \left(\left(\left( 7^2 \right)^2\cdot 7\right)^2\cdot 7\right)^2\cdot 7 \ \bmod \ 143 = 2</math>
| |
|
| |
| Dabei wendet man nach jedem Rechenschritt auf die zu handhabenden Zahlen die [[Modulo]]-Operation „mod“ an, um die Zwischenergebnisse möglichst klein zu halten. Aus dem Klartext „7“ erhalten wir somit den Geheimtext „2“.
| |
|
| |
| === Programmierung ===
| |
| Das folgende [[Programmiersprache|Programm]] in der [[Programmiersprache]] [[C++]] zeigt die Implementierung des RSA-Verfahrens mit <math>p=223</math>, <math>q=127</math> und <math>e = 121</math>, was den [[Privater Schlüssel|privaten Schlüssel]] ''<math>d = 5317</math>'' ergibt. Das Programm gibt den verschlüsselten und den entschlüsselten Text (in diesem Beispiel ''Werde Mitglied bei Wikipedia!'') auf der Konsole aus.
| |
|
| |
| <syntaxhighlight lang="c++">
| |
| #include <iostream>
| |
| using namespace std;
| |
|
| |
| // berechnet aus dem öffentlichen Schlüssel e den privaten Schlüssel (das multiplikative Inverse von e modulo phi)
| |
| unsigned getPrivateKey(unsigned e, unsigned phi)
| |
| {
| |
| unsigned a = phi, b = e;
| |
| unsigned d = 0, u = 1;
| |
| while (b != 0)
| |
| {
| |
| unsigned q = a / b;
| |
| unsigned x = b; // Variable zum Zwischenspeichern
| |
| b = a - q * b;
| |
| a = x;
| |
| x = u;
| |
| u = d - q * u;
| |
| d = x;
| |
| }
| |
| if (a > 1) {
| |
| cout << "Fehler: e und phi nicht teilerfremd" << endl;
| |
| exit(1);
| |
| }
| |
| return d;
| |
| }
| |
|
| |
| // Diese Funktion berechnet die Potenz a ^ b modulo n
| |
| unsigned modularPower(unsigned a, unsigned b, unsigned n)
| |
| {
| |
| unsigned res = (b & 1) ? a : 1;
| |
| b >>= 1;
| |
| while (b)
| |
| {
| |
| a = a * a % n;
| |
| if (b & 1) res = res * a % n;
| |
| b >>= 1;
| |
| }
| |
| return res;
| |
| }
| |
|
| |
| // Diese Funktion ver- oder entschlüsselt den Klartext 'text' elementweise mit dem Schlüssel 'key'
| |
| void RSA(unsigned *text, int len, unsigned n, unsigned key)
| |
| {
| |
| for (int i = 0; i < len; i++) // for-Schleife, die die Zeichen des Textes durchläuft
| |
| {
| |
| unsigned c = modularPower(text[i], key, n); // ver- bzw. entschlüsselt text[i]
| |
| text[i] = c;
| |
| }
| |
| }
| |
|
| |
| int main()
| |
| {
| |
| unsigned p = 223; // die Primzahlen p und q
| |
| unsigned q = 127;
| |
| unsigned n = p * q;
| |
| unsigned e = 121; // Der öffentlichen Schlüssel
| |
| unsigned phi = (p - 1) * (q - 1);
| |
| unsigned d = getPrivateKey(e, phi); // Erzeugt den privaten Schlüssel
| |
|
| |
| const char *klartext = "Werde Mitglied bei Wikipedia!";
| |
| unsigned text[100];
| |
| int len = 0;
| |
| while (klartext[len])
| |
| text[len] = klartext[len], ++len;
| |
|
| |
| RSA(text, len, n, e); // Verschlüsseln
| |
| // Ausgabe des verschlüsselten Texts auf der Konsole:
| |
| for (int i=0 ; i < len ; ++i)
| |
| cout << ' ' << text[i];
| |
| cout << '\n';
| |
|
| |
| RSA(text, len, n, d); // Entschlüsseln
| |
| // Ausgabe des Dechiffrats:
| |
| for (int i=0 ; i < len ; ++i)
| |
| cout << (char)text[i];
| |
| cout << '\n';
| |
| }
| |
| </syntaxhighlight>
| |
|
| |
| == Anwendung ==
| |
| === Hybride Verfahren ===
| |
| [[Hybride Verschlüsselung]]
| |
|
| |
| RSA ist im Vergleich zu Verfahren wie [[3DES]] und [[Advanced Encryption Standard|AES]] mindestens um den Faktor 100 langsamer. In der Praxis wird RSA daher meist nur zum Austausch eines Schlüssels für die [[Symmetrisches Kryptosystem|symmetrische Verschlüsselung]] benutzt. Für die Verschlüsselung der Daten werden dann symmetrische Verfahren eingesetzt. Damit sind die Vorteile beider Systeme vereint: einfacher Schlüsselaustausch und effiziente Verschlüsselung.
| |
|
| |
| === Anwendungsgebiete ===
| |
| * Internet- und Telefonie-Infrastruktur: [[X.509|X.509-Zertifikate]]
| |
| * Übertragungs-Protokolle: [[IPsec]], [[Transport Layer Security|TLS]], [[Secure Shell|SSH]], [[WASTE]]
| |
| * E-Mail-Verschlüsselung: [[OpenPGP]], [[S/MIME]]
| |
| * Authentifizierung französischer [[Telefonkarte]]n
| |
| * Kartenzahlung: [[Contact EMV|EMV]]
| |
| * RFID-Chip auf dem [[Deutscher Reisepass|deutschen Reisepass]]
| |
| * Electronic Banking: [[HBCI#Sicherheitsverfahren|HBCI]]
| |
|
| |
| == Weblinks ==
| |
| {{Wikibooks|Beweisarchiv: Kryptografie: Kryptosysteme: Korrektheit des RSAs|Beweisarchiv: Korrektheit des RSAs}}
| |
| * [http://www.matheprisma.uni-wuppertal.de/Module/RSA/index.htm Erklärung von RSA vom Fachbereich Mathematik der Universität Wuppertal]
| |
| * [http://www.nord-com.net/h-g.mekelburg/krypto/mod-asym.htm#rsa Einfache Erklärung von RSA mit Online-Beispielen von Hans-G. Mekelburg]
| |
| * {{Internetquelle |url=http://www.basement-softworks.de/dokumente/realisierung_und_anwendung_des_rsa-algorithmus_in_der_informatik.html |titel=Arbeit über RSA mit Schwerpunkt in der Informatik |offline=1 |archiv-url=https://web.archive.org/web/20120818180314/http://www.basement-softworks.de/dokumente/realisierung_und_anwendung_des_rsa-algorithmus_in_der_informatik.html |archiv-datum=2012-08-18 |abruf=2012-08-18}}
| |
| * [http://mitpress.mit.edu/sicp/psets/ps3/readme.html RSA-Codebeispiel] in [[Scheme]] vom [[Massachusetts Institute of Technology]]
| |
| * [http://kilchb.de/bsp_rsa.php Beispiel zur RSA-Verschlüsselung vorgerechnet von Joachim Mohr]
| |
| * [https://www.cryptool.org/assets/ct1/presentations/RSA/RSA-de.pptx Interaktive Präsentation des RSA-Verfahrens von CrypTool]
| |
| * [https://www-ee.stanford.edu/~hellman/publications/24.pdf Whitfield Diffie and Martin E. Hellman: New Directions in Cryptography], IEEE Transactions on Information Theory, Vol. IT-22, No. 6, November 1976
| |
| * {{TIBAV |19815 |Linktext=RSA: Einführung |Herausgeber=Spannagel |Jahr=2012 |DOI=10.5446/19815 }}
| |
| * {{TIBAV |19816 |Linktext=RSA: Konstruktion der Schlüssel |Herausgeber=Spannagel |Jahr=2012 |DOI=10.5446/19816 }}
| |
| * {{TIBAV |19817 |Linktext=RSA: Ver- und Entschlüsselung |Herausgeber=Spannagel |Jahr=2012 |DOI=10.5446/19817 }}
| |
| * {{TIBAV |19813 |Linktext=RSA: Beispiel Teil 1 |Herausgeber=Spannagel |Jahr=2012 |DOI=10.5446/19813 }}
| |
| * {{TIBAV |19814 |Linktext=RSA: Beispiel Teil 2 |Herausgeber=Spannagel |Jahr=2012 |DOI=10.5446/19814 }}
| |
|
| |
| # https://de.wikipedia.org/wiki/RSA
| |
|
| |
| [[Kategorie:X.509]]
| |
| [[Kategorie:RSA]]
| |