View source for SIKE: Los, Stop, Schade

== SIKE und NIST ==

SIKE steht für "Supersinguläre Isogeny Key Exchange". Es handelt sich um ein asymmetrisches Kryptosystem, das auf isogenen elliptischen Kurven basiert. SIKE ist ein Verschlüsselungsverfahren, das die Sicherheit von Datenübertragungen gewährleistet.
Es verwendet isogene elliptische Kurven und die Berechnung von Isogenien, um Schlüssel auszutauschen und Daten zu verschlüsseln. SIKE basiert auf supersingulären isogenen elliptischen Kurven und Isogenien, wodurch es eine post-quantum Kryptografie bietet, die vor Angriffen von Quantencomputern sicher ist.
Isogenien sind mathematische Transformationen zwischen elliptischen Kurven, die SIKE zur Schlüsselaustausch und Datenverschlüsselung verwendet.
NIST (National Institute of Standards and Technology):
Das National Institute of Standards and Technology (NIST) ist eine Amerikanische Behörde, die Standards und Richtlinien für verschiedene Bereiche, einschließlich Kryptografie, entwickelt und pflegt.
NIST spielt eine wichtige Rolle bei der Festlegung von Standards für kryptografische Algorithmen und Protokolle, um die Sicherheit von Informationen und Kommunikation zu gewährleisten.
NIST hat einen Wettbewerb zur Identifizierung von post-quantum-kryptografischen Algorithmen ins Leben gerufen, bei dem SIKE eine bedeutende Rolle spielt.
NIST wird voraussichtlich Standards für post-quantum-Kryptografie festlegen, die von Organisationen und Regierungen weltweit übernommen werden.

Sike würde es bis in die 4. Runde des NIST-Wettbewerbs für quantensichere Verschlüsselungsprotokolle schaffen. Leider wurde zu der Zeit, als SIKE an Popularität gewann, ein neues Papier veröffentlicht, das sicherstellte, dass SIKE nicht sicher ist und mit einem Single-core Laptop entschlüsselt werden kann. Der Angriff erforderte weder zu viel Rechenleistung noch dauerte er zu lange, um die vom NIST-Wettbewerb vorgegebenen Parameter zu entschlüsseln.

==SIKE Schlüsselaustausch ==

Im Folgenden geben wir einen zugegeben sehr groben Überblick, wie ein
Diffie-Hellman Schlüsselaustausch im SIKE Protokoll funktioniert und
anschließend, warum der private Schlüssel von Bob effizient berechnet
werden kann.

Wie bei einem klassischen Diffie-Hellman Verfahren stehen auch bei SIKE
öffentliche Systemparameter fest. Dazu gehören zwei natürliche Zahlen e
und f, eine Primzahl <math>p = 2^e\cdot3^f-1</math> und eine Elliptische Kurve E auf
<math>\mathbb{F}_{p^2}</math> der Form <math>y^2 = x^3+6x^2+x</math>, d.h. allen Punkten <math>(x,y)</math> in <math>\mathbb{F}_{p^2}</math>, die
die Gleichung erfüllen. Der zugrundeliegende Körper <math>\mathbb{F}_{p^2}</math> hat als
Grundmenge genau die komplexen Zahlen, deren Real- als auch
Imaginärteil in der Restklasse <math>\mathbb{F}_p \mbox{ }(={0,1,2,\dots,p-1})</math> enthalten sind.
Desweiteren gibt es noch vier sogenannte Hilfspunkte <math>\mathrm{P}_A,\mathrm{Q}_A,\mathrm{P}_B,\mathrm{Q}_B</math> auf
E, dessen Bedeutung wir gleich beleuchten werden.
Wichtig für uns ist, dass die Punkte auf einer Elliptischen Kurve
zusammen mit der Punktaddition eine Gruppe bilden. Können mit
Homomorphismen, also strukturerhaltenden Abbildungen, auf Untergruppen
abgebildet werden. Einen nicht-konstanten Gruppen Homomorphismus von
einer elliptischen Kurve auf sich selbst nennen wir hier auch Isogenie.
Der Kern einer Isogenie ist die Menge aller Punkte, die auf das neutrale
Element abgebildet werden. Der Grad einer Isogenie ist die Größe ihres
Kerns.
Der Gedanke des SIKE Schlüsselaustauschs ist, dass sich Alice und Bob
jeweils geheime Isogenien ausdenken, die sich zu einer dritten Isogenie verknüpfen lassen.
Allerdings können sie nicht einfach die Isogenien bzw. ihre Kerne über den ungesicherten Kanal verschicken. Darum legen sie zwei (öffentliche) jeweils öffentliche Hilfspunktpaare fest, die Punkte <math>\mathrm{P}_A,\mathrm{Q}_A</math> der Ordnung <math>2^e</math> für Alice und die Punkte <math>\mathrm{P}_B,\mathrm{Q}_B</math> der Ordnung <math>3^f</math> für Bob. Alice denkt sich nun eine geheime ganze Zahl <math>a</math> aus, und erhält mit <math>A=\langle\mathrm{P}_A+a\cdot\mathrm{Q}_A\rangle</math> den Kern ihrer Isogenie <math>\varphi_A</math> der Ordnung <math>2^e</math>. Bob erhält analog eine Isogenie <math>\varphi_B</math> der Ordnung <math>3^b</math>. Nun tauschen sie über den unsicheren Kanal die Bildwerte der Hilfspunkte des jeweils anderen unter der eigenen Isogenie aus, also <math>\varphi_A(\mathrm{P}_B)</math>, <math>\varphi_A(\mathrm{Q}_B)</math> und <math>\varphi_B(\mathrm{P}_A)</math>, <math>\varphi_B(\mathrm{Q}_A)</math> aus. Somit kann der jeweils können sie mit dem eigenen Geheimnis und den Bildwerten der Isogenie des anderen auf einen gemeinsamen Kern und somit auch eine gemeinsame Isogenie kommen, die ein Angreifer ohne eines der privaten Geheimnisse <math>a</math> oder <math>b</math> nicht effizient ermitteln kann.

== Mathematischer Angriff ==

Der Angriff von Castryck und Decru zeigt, wie eine bösartige Alice Bobs geheime Isogenie rekonstruieren kann. Der Grundgedanke dabei ist, dass die gemeinsame Isogenie von Alice und Bob eine besondere Isogenie ist, die wir hier, um mathematische Definitionen und Genauigkeiten zu ersparen, einfach nur reduzierbar nennen. Man kann sich das so vorstellen, dass ihr Bild das Produkt zweier elliptischer Kurven ist.
Das Ereignis, dass man von einer belibigen elliptischen Kurve durch eine (2,2)-Isogenie auf einem Produkt
zweier Kurven landet, beträgt ungefähr <math>10/p</math>, also unfassbar klein.
Castryck und Decru ziehen sich Kanis Theorem zur Hilfe, was grob besagt, dass wenn wir eine Isogenie haben und zwei Kerne, die bis (bis auf das neutrale Element) disjunkt den Kern der Isogenie aufspannen, die Isogenie reduzierbar ist bzw. wir auf einem Produkt zweier Kurven landen.
Die in SIKE von Alice und Bob errechnete Isogenie zusammen mit den Kernen A und B entspricht genau den Bedingungen von Kanis Theorem und bildet somit auf eine Produktkurve ab. Im Angriff betrachten wir Bobs <math>3^f</math>-Isogenie als Verkettung von f vielen 3-Isogenien, die von Alice Bildkurve auf eine Produktkurve abbilden.
Für die erste 3-Isogenie haben wir drei Möglichkeiten zu raten. Wir probieren eine und wissen nun, dass wenn wir richtig liegen, wir von der entstehenden Kurve mit einer <math>3^{f-1}</math>-Isogenie auf unsere Produktkurve gelangen. Wir konstruieren nun eine <math>2^e-3^{f-1}</math>-Isogenie, deren Pseudoinverse zusammen mit Bobs übriger <math>3^{f-1}</math>-Isogenie eine <math>2^e</math>-Isogenie ergibt, die laut Kanis Theorem wieder reduzierbar ist. Wir erinnern uns, dass es extrem unwahrscheinlich ist, mit solch einer Isogenie, die auch nur die e-fache Verknüpfung von 2-Isogenien ist, auf einer Produktkurve zu landen. Ob wir dies tun lässt sich sehr effizient überprüfen. Wenn die nicht der Fall ist, haben wir die 3-Isogenie auf jeden Fall falsch geraten, wenn doch können wir jedoch mit hoher Sicherheit ausschließen, dass wir falsch geraten haben, da es so unwahrscheinlich ist aus Zufall auf einer Produktkurve gelandet zu sein.
So erraten wir schritt für Schritt Bobs 3^f Isogenie, indem wir immer wieder eine <math>2^e-3^{f-j}</math>-Isogenie (<math>j \in \{1,\dots,e-1\}</math>) bauen und überprüfen, ob wir mit der entstehenden <math>2^f</math> Isogenie auf einer Produktkurve landen. Kanis Theorem liefert uns hier sozusagen ein Entscheidungskriterium.

== Angewandter Angriff ==

Der Angriff wurde ursprünglich von dem Duo Wouter Castryck und Thomas Decru durchgeführt. In ihrem Beitrag erklärten sie, dass der Angriff mithilfe des Computer-Algebra-Software-Systems namens Magma möglich war. Da Magma nicht quelloffen ist, stand es nicht vielen Menschen zur Verfügung, so dass nicht viele den Angriff selbst testen konnten. Um die Implementierung für die Öffentlichkeit zugänglicher zu machen, implementierten Giacomo Pope und Rémy Oudompheng den ursprünglichen Angriff erneut in einem Softwaresystem namens SageMath. SageMath ist quelloffen, und jeder kann den Angriff herunterladen und auf seinen eigenen Geräten neu implementieren, solange SageMath auf dem jeweiligen Gerät installiert ist.

SageMath kann hier installiert werden: https://www.sagemath.org/

Die Parameter für den Angriff werden bereits im Vorfeld vom NIST-Wettbewerb vorgegeben. Die Parameter stellen sicher, dass der Schlüssel lang genug ist, damit der Angriff in einer realen Anwendung sinnvoll ist, und auch um sicherzustellen, dass die Verschlüsselung robust genug ist und ein gewisses Maß an Sicherheit bietet. Das bedeutet, dass die Parameter eine Richtlinie für die Entwickler darstellen und ihnen helfen, die richtigen Entscheidungen zu treffen, wenn SIKE implementiert wird.

<syntaxhighlight lang="python">
SIKE_parameters = {
    "SIKEp434" : (216, 137),
    "SIKEp503" : (250, 159),
    "SIKEp610" : (305, 192),
    "SIKEp751" : (372, 239)
}
</syntaxhighlight>
Code Beispiel 1: SIKE Parametern in den Code

Wie es auf Beispiel 1 zu sehen ist, sind die SIKE Parametern für die Werten <math>a</math> und <math>b</math> gegeben. Mithilfe dieser Parameter kann die Primzahl <math>p</math> definiert werden. <math>p = 2^a \cdot 3^b -1</math>. <math>p</math> ist wichtig, um die Elliptische Kurven und Isogenien zu generieren. 
Die elliptische Kurve E<math>_\mathrm{start}</math> über einem endlichen Feld <math>\mathbb{F}_{p^2}</math> wird als Startpunkt für die Challenge definiert.
Eine zufällige ganze Zahl Bobskey wird generiert und auf ternäre Ziffern eingestellt.
Zum Abschluss der Challenge wird eine neue elliptische Kurve E<math>_B</math> erstellt und von E<math>_B</math> zu E<math>_{B_\mathrm{start}}</math> eine Isogeniekette erzeugt. Die Isogeniekette wird auf der Grundlage der Punkte <syntaxhighlight inline lang="python">P3 + Bobskey *Q3</syntaxhighlight> erstellt, wobei <syntaxhighlight inline lang="python">P3</syntaxhighlight> und <syntaxhighlight inline lang="python">Q3</syntaxhighlight> Torsionspunkte auf E<math>_\mathrm{start}</math> sind. Die Länge der Isogeniekette ist gleich dem Parameter b.
Der Aufbau der Challenge besteht im Wesentlichen aus der Wahl der Parameter, der Generierung des privaten Schlüssels <syntaxhighlight inline lang="python">Bobskey</syntaxhighlight> und der Erstellung der Isogenese von der elliptischen Kurve E<math>_\textrm{start}</math> zur elliptischen Kurve E<math>_B</math> auf der Basis von <syntaxhighlight inline lang="python">Bobskey</syntaxhighlight> und den angegebenen Parametern.

Die Codezeile <syntaxhighlight inline lang="python">EB, chain = Pushing3Chain(E_start, P3 + Bobskey * Q3, b)</syntaxhighlight> beinhaltet elliptische Kurvenoperationen und ist Teil des Challenge-Setups im Code.
	<syntaxhighlight inline lang="python">P3</syntaxhighlight> und <syntaxhighlight inline lang="python">Q3</syntaxhighlight> sind Punkte auf einer elliptischen Kurve E<math>_\mathrm{start}</math>. Diese Punkte sind Teil des 			Challenge-Setups.
	<syntaxhighlight inline lang="python">Bobskey</syntaxhighlight> ist eine zufällige ganze Zahl aus dem Bereich <math>[0, 3^b)</math>. Diese ganze Zahl ist Bobs privater Schlüssel in ternärer Darstellung.
	<syntaxhighlight inline lang="python">Bobskey * Q3</syntaxhighlight> bedeutet eine skalare Multiplikation des Punktes <syntaxhighlight inline lang="python">Q3</syntaxhighlight> mit der ganzen Zahl <syntaxhighlight inline lang="python">Bobskey</syntaxhighlight>. Diese Operation berechnet <syntaxhighlight inline lang="python">Bobskey</syntaxhighlight> mal den Punkt <syntaxhighlight inline lang="python">Q3</syntaxhighlight> auf der elliptischen Kurve.
	<syntaxhighlight inline lang="python">P3 + Bobskey * Q3</syntaxhighlight> addiert das Ergebnis der skalaren Multiplikation <syntaxhighlight inline lang="python">(Bobskey * Q3)</syntaxhighlight> zu dem Punkt <syntaxhighlight inline lang="python">P3</syntaxhighlight>. Dies ist eine Punktaddition auf der elliptischen Kurve. Das Ergebnis ist ein neuer 	Punkt auf der Kurve.
	<syntaxhighlight inline lang="python">Pushing3Chain(E_start, P3 + Bobskey * Q3, b)</syntaxhighlight> erzeugt eine Isogeniekette (Kette) von der elliptischen Kurve E<math>_\mathrm{start}</math> zu einer neuen elliptischen Kurve E<math>_B</math>, die auf den Punkten <syntaxhighlight inline lang="python">P3 + 		Bobskey * Q3</syntaxhighlight> basiert. Der Parameter <math>b</math> gibt die Länge der Kette an.
	
Zusammenfassend lässt sich sagen, dass die Codezeile im Wesentlichen eine Herausforderung für den Angreifer darstellt, indem sie ein Problem der Isogenie elliptischer Kurven aufstellt. Das Ziel des Angreifers ist es, Bobs privaten Schlüssel (<syntaxhighlight inline lang="python">Bobskey</syntaxhighlight>) auf der Grundlage dieser Herausforderung wiederherzustellen, was die Arbeit mit den Operationen der elliptischen Kurve und den Isogenieberechnungen beinhaltet.

<syntaxhighlight lang="python">
# generate challenge key
Bobskey = randint(0,3^b)

EB, chain = Pushing3Chain(E_start, P3 + Bobskey*Q3, b)
# Speeds things up in Sage
EB.set_order((p+1)^2)
PB = P2
for c in chain:
    PB = c(PB)
QB = Q2 
for c in chain:
    QB = c(QB)

print(f"If all goes well then the following digits should be found: {Integer(Bobskey).digits(base=3)}")
</syntaxhighlight>
Code Beispiel 2: Pushing3Chain Funktion

== Attack ==
skB ist als leere Liste definiert, in die die Werte von Bobs geheimem Schlüssel während des Angriffs nacheinander eingefügt werden. 

Der Code durchläuft eine Schleife über <syntaxhighlight inline lang="python">i</syntaxhighlight> von <syntaxhighlight inline lang="python">1</syntaxhighlight> bis <syntaxhighlight inline lang="python">(b-2)</syntaxhighlight>. Für jedes <syntaxhighlight inline lang="python">i</syntaxhighlight> wird geprüft, ob <syntaxhighlight inline lang="python">b-i</syntaxhighlight> ungerade ist, indem die Bedingung <syntaxhighlight inline lang="python">(b-i) % 2 == 1</syntaxhighlight> verwendet wird. Ist dies der Fall, wird ein Index berechnet und Daten aus der uvtable auf der Grundlage dieses Index gesammelt.
index wird berechnet als <syntaxhighlight inline lang="python">(b - i + 1) / 2</syntaxhighlight>.
<syntaxhighlight inline lang="python">exp</syntaxhighlight> wird aus <syntaxhighlight inline lang="python">uvtable[index-1][1]</syntaxhighlight> extrahiert.
Wenn <syntaxhighlight inline lang="python">exp</syntaxhighlight> kleiner oder gleich <syntaxhighlight inline lang="python">a</syntaxhighlight> ist, werden auch <syntaxhighlight inline lang="python">u</syntaxhighlight> und <syntaxhighlight inline lang="python">v</syntaxhighlight> aus <syntaxhighlight inline lang="python">uvtable[index-1][2]</syntaxhighlight> bzw. <syntaxhighlight inline lang="python">uvtable[index-1][3]</syntaxhighlight> abgerufen.
Diese Daten werden in der Liste expdata an der <syntaxhighlight inline lang="python">i-1</syntaxhighlight>-ten Position als <syntaxhighlight inline lang="python">[exp, u, v]</syntaxhighlight> gespeichert.

Nehmen wir die Parameter <syntaxhighlight inline lang="python">a=216</syntaxhighlight> und <syntaxhighlight inline lang="python">b=137</syntaxhighlight>

Da <syntaxhighlight inline lang="python">b</syntaxhighlight> <syntaxhighlight inline lang="python">137</syntaxhighlight> ist, wird <syntaxhighlight inline lang="python">expdata</syntaxhighlight> eine Liste mit <syntaxhighlight inline lang="python">134</syntaxhighlight> Unterlisten sein, die jeweils drei Nullen enthalten. Schleife von <syntaxhighlight inline lang="python">i</syntaxhighlight> im Bereich von <syntaxhighlight inline lang="python">1</syntaxhighlight> bis <syntaxhighlight inline lang="python">b-2</syntaxhighlight>, der von <syntaxhighlight inline lang="python">1</syntaxhighlight> bis <syntaxhighlight inline lang="python">135</syntaxhighlight> reicht. Prüfe, ob <syntaxhighlight inline lang="python">(b - i) % 2 == 1 </syntaxhighlight> für jedes <syntaxhighlight inline lang="python">i</syntaxhighlight>. Diese Bedingung prüft, ob <syntaxhighlight inline lang="python">b-i</syntaxhighlight> eine ungerade Zahl ist. Wenn <syntaxhighlight inline lang="python">b-i</syntaxhighlight> ungerade ist, wird der <syntaxhighlight inline lang="python">Index</syntaxhighlight> als <syntaxhighlight inline lang="python"> b-i/2 </syntaxhighlight> berechnet. Dieser Index wird für den Zugriff auf Elemente der <syntaxhighlight inline lang="python">uvtable</syntaxhighlight> verwendet.

<syntaxhighlight inline lang="python">b=137</syntaxhighlight>, also ist <syntaxhighlight inline lang="python">expdata</syntaxhighlight> eine Liste mit <syntaxhighlight inline lang="python"> 134 </syntaxhighlight> Unterlisten, gefüllt mit <syntaxhighlight inline lang="python">[0, 0, 0]</syntaxhighlight>.
Die Schleife läuft von <syntaxhighlight inline lang="python">i = 1</syntaxhighlight> bis <syntaxhighlight inline lang="python">i = 135</syntaxhighlight>.
Wenn <syntaxhighlight inline lang="python"> i = 1 </syntaxhighlight> ist, ist <syntaxhighlight inline lang="python">(b - i) % 2 == 0</syntaxhighlight>, also passiert nichts.
Wenn <syntaxhighlight inline lang="python"> i = 2 </syntaxhighlight> ist, ist <syntaxhighlight inline lang="python">(b - i) % 2 == 1</syntaxhighlight>, so dass der Index als <syntaxhighlight inline lang="python">(137 - 2 + 1) / 2 = 68 </syntaxhighlight>berechnet wird. Dann holt es <syntaxhighlight inline lang="python">exp = 135, u = 68402650496677101758628224525965</syntaxhighlight>  und <syntaxhighlight inline lang="python">v = 491073477706829402358064079515557</syntaxhighlight>  aus <syntaxhighlight inline lang="python">uvtable[68]</syntaxhighlight> und aktualisiert <syntaxhighlight inline lang="python">expdata[1]</syntaxhighlight> mit <syntaxhighlight inline lang="python">[135, 68402650496677101758628224525965, 491073477706829402358064079515557]</syntaxhighlight>.
Dieser Vorgang wird für alle Werte von <syntaxhighlight inline lang="python">i</syntaxhighlight> fortgesetzt, bis die Schleife beendet ist.
Nach der Schleife wird bet1 inkrementiert, bis es den Wert <syntaxhighlight inline lang="python">2</syntaxhighlight> erreicht (da <syntaxhighlight inline lang="python">expdata[2][0]</syntaxhighlight> der erste Nicht-Null-Wert ist).

Für <syntaxhighlight inline lang="python">a = 216</syntaxhighlight> und <syntaxhighlight inline lang="python">b=137 </syntaxhighlight>ergeben sich mit der <syntaxhighlight inline lang="python">uv</syntaxhighlight>-Tabelle also folgende Ergebnisse:

<syntaxhighlight inline lang="python">ai = expdata[2-1][0] = 135  </syntaxhighlight>,
<syntaxhighlight inline lang="python">u = expdata[2-1][1] = 68402650496677101758628224525965</syntaxhighlight>,
<syntaxhighlight inline lang="python">v = expdata[2-1][2] = 491073477706829402358064079515557</syntaxhighlight>.

Diese Ergebnisse sind wichtig für die spätere Verwendung dieser Werte beim Orakel für die Split- und Glue-Operationen der Isogenien im Attack.

Die ersten <syntaxhighlight inline lang="python">bet1</syntaxhighlight>-Ziffern werden für den Angriff berechnet, indem geprüft wird, ob einer der Werte korrekt ist und die Bedingung für das Glue- und Split-Orakel erfüllt. Dies geschieht, um einen bekannten Ausgangspunkt für den Angriff festzulegen und zu beweisen, dass der Angriff Schritte in die richtige Richtung unternimmt.

Das Klebe- und Teilungsorakel wird verwendet, um zu prüfen, ob ein Schritt in die richtige Richtung gemacht wird, indem die gegebenen Kurven geklebt und geteilt werden: die erste Kurve C und die zweite Kurve E<math>_B</math>. Die Kurve C wird durch eine Reihe von Transformationen erzeugt, die auf die Ausgangskurve E<math>_\mathrm{start}</math> angewandt werden, geleitet von tauhatkernel_distort, und die Funktion Pushing3Chain spielt eine entscheidende Rolle bei diesem Kurvenerzeugungsprozess. Während E<math>_B</math> am Anfang des Codes initialisiert wird. Indem man auch die Punkte der Kurven der Ordnung <math>2^a</math> und <math>3^b</math> verwendet, kann die Funktion genutzt werden. Die Funktion nutzt die Eigenschaften von Richelot-Isogenien (kein Hinweis), wobei geprüft wird, ob die aus C und der Richelot-Isogenie abgeleitete Kurve in ein Produkt aus sipersingulären elliptischen Kurven zerlegt werden kann. 
Durch Kleben wird eine neue Isogenie erzeugt, und von dieser Klebekarte werden eine Kurve und ein Paar neuer Punkte durch eine Kette von Isogenien abgebildet.

Der Angriff besteht darin, eine Kette von Isogenien zu konstruieren, ausgehend von einer bekannten Ausgangskurve und einem Punkt. Diese Kette stellt eine Folge von Transformationen dar, die auf die Kurve und den Punkt angewendet werden. Der Angriff besteht darin, eine Kette von Isogenien zu konstruieren, ausgehend von einer bekannten Ausgangskurve und einem Punkt. Diese Kette stellt eine Folge von Transformationen dar, die auf die Kurve und den Punkt angewendet werden.
An einem bestimmten Punkt der Kette wird die Funktion <syntaxhighlight inline lang="python">Does22ChainSplit</syntaxhighlight> mit bestimmten Parametern aufgerufen. Diese Funktion prüft, ob der aktuelle Zustand der Isogenesekette in zwei separate Ketten aufgeteilt werden kann. Wenn sie <syntaxhighlight inline lang="python">True</syntaxhighlight> zurückgibt, deutet dies darauf hin, dass die aktuellen Berechnungen zu einer Situation geführt haben, in der die elliptische Kurve in zwei getrennte Kurven zerlegt werden kann.

Wenn eine Kettenaufspaltung auftritt, zeichnet der Angreifer die Ziffern oder Parameter auf, die zum Erreichen dieser Aufspaltung verwendet wurden. Diese Ziffern sind potenzielle Kandidaten für Teile von Bobs geheimem Schlüssel, da sie mit der Transformation verbunden sind, die zur Aufspaltung der Kurve geführt hat. Das erste Teil des Angriffs kann in Abbildung 3 gesehen werden.

<syntaxhighlight lang="python">
# for j in CartesianPower([0,1,2], bet1) do
for j in product([0,1,2], repeat=int(bet1)):
    print(f"Testing digits: {[j[k] for k in range(bet1)]}")

    # tauhatkernel = 3^bi*P3 + sum([3^(k-1)*j[k-1] for k in range(1,beta+1)])*3^bi*Q3
    tauhatkernel = 3^bi*P3 
    for k in range(1, bet1+1):
        tauhatkernel += (3^(k-1)*j[k-1])*3^bi*Q3

    tauhatkernel_distort = u*tauhatkernel + v*two_i(tauhatkernel)

    C, tau_tilde = Pushing3Chain(E_start, tauhatkernel_distort, bet1)

    P_c = u*P2 + v*two_i(P2) 
    for taut in tau_tilde:
        P_c = taut(P_c)
    Q_c = u*Q2 + v*two_i(Q2)
    for taut in tau_tilde:
        Q_c = taut(Q_c)

    # if j eq <2 : k in [1..bet1]> or Does22ChainSplit(C, EB, 2^alp*P_c, 2^alp*Q_c, 2^alp*PB, 2^alp*QB, ai) then
    if j == (2,)*bet1 or Does22ChainSplit(C, EB, 2^alp*P_c, 2^alp*Q_c, 2^alp*PB, 2^alp*QB, ai):
        print("Glue-and-split! These are most likely the secret digits.")
        for k in j:
            skB.append(k)
        break

print(skB)
</syntaxhighlight>

Code Beispiel 3: Angriff mit den Glue and Split Oracle.

Der Angriff wird fortgesetzt, in der Hoffnung, weitere Aufspaltungen zu finden und weitere Ziffern aufzuzeichnen. Mit der Zeit, wenn mehr Ziffern aufgezeichnet werden, kann der Angreifer genügend Informationen zusammensetzen, um Bobs gesamten geheimen Schlüssel wiederherzustellen. Das liegt daran, dass jede aufgezeichnete Ziffer einen Schritt in der Kette der Isogenese darstellt und dazu beiträgt, eine Folge von Transformationen zu bilden, die schließlich zum geheimen Schlüssel führt.

Ein einziger Kettensplit verrät zwar nicht sofort Bobs geheimen Schlüssel, ist aber ein entscheidender Schritt im Angriffsprozess. Er bedeutet einen Fortschritt in der Fähigkeit des Angreifers, die Kurve in einfachere Komponenten zu zerlegen und potenzielle Kandidaten für Teile des geheimen Schlüssels aufzuzeichnen

Der letzte Teil des Codes beinhaltet die Angriffsphase, um die letzten Ziffern von Bobs geheimem Schlüssel zu erzwingen. Es gibt eine Schleife, die die potenziellen Werte durchläuft und eine elliptische Kurve mit denselben Parametern und derselben Kette wie im Setup erzeugt. Die Schleife prüft, ob die j-Invariante der generierten elliptischen Kurve, mit der Bobs Schlüssel gefunden werden soll, mit der j-Invariante der zuvor generierten Kurve übereinstimmt. Wenn sie übereinstimmen, bedeutet dies, dass die richtigen Werte für die letzten Ziffern gefunden wurden. 

Am Ende wird Bobs Schlüssel ausgedruckt, der mit dem privaten Schlüssel übereinstimmt, der während des Einrichtungsteils des Codes erzeugt wurde.


== Quellen ==

* https://sike.org/files/SIDH-spec.pdf
* https://eprint.iacr.org/2022/975.pdf
* https://www.youtube.com/watch?v=rwri6Ai4H1I (sehr empfehlenswert!)
* https://research.nccgroup.com/2022/08/08/implementing-the-castryck-decru-sidh-key-recovery-attack-in-sagemath/
* https://doc.sagemath.org/html/en/tutorial/programming.html
* https://eprint.iacr.org/2022/975.pdf#page=13
* https://www.normalesup.org/~oudomphe/textes/202208-castryck-decru-shortcut.pdf