Quantenschlüsselverteilung

Für dieses Modul "Qiskit im Klassenzimmer" müssen die Schüler eine funktionierende Python Umgebung mit den folgenden Paketen installiert haben:

• qiskit v2.1.0 oder neuer
• qiskit-ibm-runtime v0.40.1 oder neuer
• qiskit-aer v0.17.0 oder neuer
• qiskit.visualization
• numpy
• pylatexenc

Um die oben genannten Pakete einzurichten und zu installieren, lesen Sie die Anleitung Qiskit installieren. Um Aufträge auf echten Quantencomputern ausführen zu können, müssen die Schüler ein Konto bei IBM Quantum® einrichten, indem sie die Schritte in der Anleitung zur Einrichtung Ihres IBM Cloud Kontos befolgen.

Dieses Modul wurde getestet und verbrauchte 5 Sekunden QPU-Zeit. Dies ist nur eine Schätzung. Ihre tatsächliche Nutzung kann davon abweichen.

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

Schauen Sie sich den Modul-Walkthrough von Dr. Katie McCormick unten an, oder klicken Sie hier, um ihn auf YouTube zu sehen.

Einführung und Motivation

Es gibt unendlich viele Möglichkeiten, Informationen zu verschlüsseln und zu entschlüsseln, und buchstäblich Tausende von Möglichkeiten sind gut erforscht worden. Wir beschränken uns hier auf eine sehr frühe und sehr einfache Verschlüsselungsmethode, die so genannte "einfache Ersetzung", um uns auf den Quantenanteil dieses Protokolls zu konzentrieren. Der Quantenteil könnte mit relativ wenigen Änderungen an viele andere Protokolle angepasst werden.

Einfacher Austausch

Bei einer einfachen Ersatzverschlüsselung wird ein Buchstabe oder eine Zahl durch einen anderen ersetzt, so dass eine 1:1-Zuordnung zwischen den Buchstaben und Zahlen in einer Nachricht und den in einer verschlüsselten Sequenz verwendeten Buchstaben und Zahlen besteht. Ein Beispiel aus der Popkultur ist das Kryptoquote- oder Kryptogramm-Rätsel, bei dem ein Zitat oder ein Satz durch einfache Ersetzung verschlüsselt wird und der Spieler die Aufgabe hat, es zu entschlüsseln. Diese sind leicht zu lösen, wenn sie lang genug sind. Nehmen wir ein Beispiel:

R WVXRWVW GSZG R'W YVGGVI NZPV GSRH KIVGGB OLMT. GSZG DZB, KVLKOV DROO SZEV ZM VZHRVI GRNV HLOERMT RG. R SLKV R NZWV RG HRNKOV VMLFTS.

Diejenigen, die diese Aufgaben von Hand lösen, wenden meist Tricks an, die eine Vertrautheit mit der Struktur der Sprache der ursprünglichen Nachricht voraussetzen. Im Englischen beispielsweise sind die einzigen Wörter mit einem Buchstaben, die dem verschlüsselten "R" gleichen, "a" und "I". Die Doppelbuchstaben, die z. B. in "KIVGGB" verschlüsselt sind, können nur bestimmte Werte annehmen. Es gibt auch subtilere Hinweise, wie z. B. das häufigste Wort, das in das "GSZG"-Muster passt, ist "das". Diejenigen, die einen Code verwenden, um dieses Problem zu lösen, haben viel mehr Möglichkeiten, z. B. das Durchsuchen von Möglichkeiten, bis ein englisches Wort gefunden wird, und das Aktualisieren unter Beibehaltung dieses Wortes. Eine einfache, aber wirkungsvolle Methode ist die Verwendung der Buchstabenhäufigkeit, insbesondere wenn die Nachricht lang genug ist, um eine repräsentative Stichprobe der englischen Sprache darzustellen.

Check-in-Frage

Versuchen Sie doch einmal, dies zu entschlüsseln, wenn Sie möchten, auch wenn es für den Rest des Moduls nicht erforderlich ist. Klicken Sie unten auf „Antwort“, um die Nachricht anzuzeigen.

• Antwort

  Ich habe beschlossen, dass es besser ist, wenn ich es ziemlich lang mache. Auf diese Weise wird es den Leuten leichter fallen, das Problem zu lösen. Ich hoffe, ich habe es einfach genug gemacht.

Das obige Beispiel ist mit einem "Schlüssel" verbunden, einer Zuordnung zwischen den verschlüsselten und den entschlüsselten Buchstaben. In diesem Fall lautet der Schlüssel:

• A (nicht verwendet, nennen wir es Z)
• B->Y
• C (nicht verwendet, nennen wir es X)
• D->W
• E->V
• F->U
• ...

Und so weiter. Das ist, gelinde gesagt, kein guter Schlüssel. Schlüssel, bei denen die verschlüsselten und entschlüsselten Buchstaben einfach eine verschobene Version des Alphabets sind (z. B. A->B und B->C), werden "Caesar-Shift"-Chiffren genannt.

Beachten Sie, dass diese sehr schwierig sind, wenn sie kurz sind. Wenn sie sehr kurz sind, sind sie sogar unbestimmt. Ziehen Sie Folgendes in Betracht:

URYYP

Es gibt viele mögliche Entschlüsselungen, die verschiedene Schlüssel verwenden: HALLO, KLEINLICH, FRÖHLICH, WACKELIG, HOCKER. Fallen Ihnen noch andere ein?

Aber wenn Sie viele solcher Nachrichten versenden, wird die Verschlüsselung irgendwann geknackt. Sie sollten also nicht zu oft denselben "Schlüssel" verwenden. Am besten ist es sogar, wenn Sie eine bestimmte Ersetzung nur einmal verwenden. Nicht in nur einer Nachricht, sondern nur für ein einziges Zeichen! Damit meinen wir, dass Sie für jedes in der Nachricht verwendete Zeichen der Reihe nach ein Verschlüsselungsschema oder einen Schlüssel haben werden. Wenn Sie einem Freund eine Nachricht mit dieser Botschaft schicken wollen, brauchen Sie und Ihr Freund einen Block Papier (in alten Zeiten), auf dem dieser sich ständig ändernde Schlüssel geschrieben steht. Sie werden dies nur einmal verwenden. Dies wird als "One-Time-Pad" bezeichnet.

Das Einmal-Pad

Lassen Sie uns dies anhand eines Beispiels erläutern. Man könnte dies ausschließlich mit Buchstaben tun, aber es ist üblich, von Buchstaben in Zahlen umzuwandeln, z. B. durch Zuweisung von A=0, B=1, C=2…. Angenommen, wir sind Freunde, die in geheime Aktivitäten verwickelt sind, und wir haben uns eine Bude geteilt. Idealerweise würden wir viele Pads teilen, aber das heutige ist es:

EDGRPOJNCUWQZVMK.

Oder die Umwandlung in Zahlen nach der Stellung im Alphabet:

4,3,6,17,15, 14, 9, 13, 2, 20, 22, 16, 25, 21, 12, 10.

Nehmen wir an, ich möchte die Botschaft mit Ihnen teilen:

"Ich liebe Quanten!"

Oder anders ausgedrückt:

8, 11, 14, 21, 4, 16, 20, 0, 13, 19, 20, 12

Wir wollen den obigen Code nicht senden; das ist eine einfache Ersetzung, die überhaupt nicht sicher ist. Wir wollen dies in irgendeiner Weise mit unserem Schlüssel kombinieren. Eine gängige Methode ist die Addition modulo 26. Wir addieren den Wert der Nachricht zum Wert des Schlüssels, mod 26, bis wir das Ende der Nachricht erreichen. Wir würden also senden

8+4 (mod 26) = 12, 11+3 (mod 26) = 14, 14+6 (mod 26) = 20, 21+17 (mod 26) = 12.

= 12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

Beachten Sie, dass es völlig aussichtslos ist, die Nachricht zu entschlüsseln, wenn jemand sie abfängt und den Schlüssel NICHT hat! Nicht einmal die beiden "u "s in "quantum" sind mit der gleichen Zahl kodiert! Die erste ist eine 3 und die zweite ist eine 16... im selben Wort!

Ich schicke Ihnen das also, und Sie haben denselben Schlüssel wie ich. Sie machen die Addition modulo 26 rückgängig, von der Sie wissen, dass ich sie durchgeführt habe:

12, 14, 20, 12, 19, 4, 3, 13, 15, 13, 16, 2

=( 4+x1 ) (mod 26), ( 3+x2 ) (mod 26), ( 6+x3 ) (mod 26), ( 17+x4 ) (mod 26),.

So muss die Nachricht x1, x2, x3, x4… sein

8, 11, 14, 21.

Wenn wir dies in Text umwandeln, ergibt sich schließlich

"Ich liebe Quanten".

Dies ist ein einmaliges Pad.

Wenn der Schlüssel kürzer ist als die Nachricht, müssen wir die Verschlüsselung wiederholen. Das wäre immer noch ein schwer zu lösendes Entschlüsselungsproblem, aber nicht unmöglich, wenn es oft genug wiederholt wird. Sie benötigen also eine lange Taste (oder "Pad").

Die obige Aktivität macht hoffentlich deutlich, dass ein One-Time-Pad eine unknackbare Form der Verschlüsselung ist, wenn man ein paar Annahmen trifft, wie z. B.:

• Der Schlüssel ist so lang wie die zu sendende Nachricht oder länger
• Der Schlüssel ist wirklich zufällig
• Der Schlüssel wird nur einmal verwendet und dann verworfen

Das ist also großartig. Wir haben eine unknackbare Verschlüsselung... es sei denn, jemand bekommt unseren Schlüssel. Wenn jemand unseren Schlüssel bekommt, wird alles entschlüsselt. Dieser Unterschied zwischen einer unknackbaren Verschlüsselung und der Preisgabe aller unserer Geheimnisse macht die gemeinsame Nutzung eines sicheren Schlüssels äußerst wichtig. Das Ziel der Quantenschlüsselverteilung besteht darin, die Beschränkungen, die die Natur der Quanteninformation auferlegt hat, zu nutzen, um einen gemeinsamen Schlüssel bzw. ein One-Time-Pad zu sichern.

Quanten-Zustände als Schlüssel nutzen

Gehen wir davon aus, dass wir mit Qubits arbeiten (wobei wir betonen, dass Qubits zwei Eigenzustände haben). Man könnte Quantensysteme mit einer höheren Anzahl von Quantenzuständen verwenden, aber die modernen Quantencomputer unter IBM® verwenden Qubits. Es ist kein Problem, unser A, B, C, in Sequenzen von 0’s und 1’s zu kodieren. Es reicht also aus, wenn wir einen Schlüssel von 0’s und 1’s gemeinsam nutzen und jedes Bit, das einen Buchstaben speichert, modulo 2 addieren.

Überprüfen Sie Ihr Verständnis

Wenn wir uns wirklich nur für englische Buchstaben interessieren, wie viele Bits brauchen wir dann?

• Antwort
  $$2^4=16\\ 2^5 = 32 \rightarrow 5 \text{ bits}$$

Unsere Freunde Alice und Bob möchten einen Quantenschlüssel so austauschen, dass niemand ihn abfangen kann (zumindest nicht ohne ihr Wissen). Sie müssen eine Möglichkeit haben, sich gegenseitig Quantenzustände zu senden. Dies mit hoher Wiedergabetreue und ohne Rauschen/Fehler zu tun, ist NICHT trivial. Es gibt jedoch zwei Ansätze, die wir an dieser Stelle nachvollziehen können sollten:

1. Mit einem Glasfaserkabel kann man Licht senden... was sehr quantenmechanisch ist. Einzelne Photonen können mit hoher Zuverlässigkeit über viele Kilometer Glasfaserkabel nachgewiesen werden. Dies ist kein perfekter, fehlerfreier Quantenkanal, aber er könnte sehr gut sein.
2. Wir könnten die Quantenteleportation nutzen, wie in einem früheren Modul beschrieben. Das heißt, Alice und Bob könnten sich verschränkte Qubits teilen, und ein Zustand könnte mit Hilfe des Teleportationsprotokolls von Alice an Bob gesendet werden.

Für dieses Modul wollen wir nicht verlangen, dass Sie über hochgradig zuverlässige optische Einrichtungen für die gemeinsame Nutzung von Photonen verfügen, daher werden wir die zweite Methode für die gemeinsame Nutzung von Quantenzuständen verwenden. Das heißt aber nicht, dass dies die realistischste Lösung für die gemeinsame Nutzung von Quantenschlüsseln über große Entfernungen ist.

Wir werden nun ein Protokoll untersuchen, das erstmals 1984 von Charles Bennett und Gilles Brassard entwickelt wurde, um Zustände, die in verschiedenen Basen gemessen wurden, von Alice bis Bob zu teilen. Wir werden ein ausgeklügeltes Messschema verwenden, um einen Schlüssel für die spätere Verschlüsselung zu erstellen. Mit anderen Worten: Wir verteilen einen Quantenschlüssel zwischen zwei Parteien, die miteinander kommunizieren wollen, daher "Quantenschlüsselverteilung" (QKD).

QKD Schritt 1: Alices Zufallsbits und Zufallsbasen

Alice wird zunächst eine zufällige Folge von 0 und 1 erzeugen. Sie wählt dann nach dem Zufallsprinzip eine Basis aus, um einen Quantenzustand auf der Grundlage jedes zufälligen Bits zu erzeugen, wobei sie die nachstehende Tabelle verwendet (eine Tabelle, die auch Bob hat):

Nehmen wir zum Beispiel an, dass Alice nach dem Zufallsprinzip eine 0 erzeugt und nach dem Zufallsprinzip die Basis X ausgewählt hat. Dann würde sie einen Quantenzustand $|\psi\rangle = |+\rangle_x = \frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ vorbereiten. Man kann die Quantenzufälligkeit sicherlich nutzen, um einen zufälligen Satz von 0 und 1 und eine zufällige Basiswahl zu erzeugen. Nehmen wir zunächst einfach an, dass eine Zufallsmenge wie folgt generiert worden ist:

Diese Reihe von Zufallsbits, Basen und daraus resultierenden Zuständen würde sich in einer langen Sequenz fortsetzen, um einen Schlüssel von ausreichender Länge zu erhalten.

QKD Schritt 2: Bobs zufällige Basen

Bob wählt auch eine zufällige Auswahl von Basen. Während Alice jedoch die Wahl der Basis zur Vorbereitung ihres Zustands nutzte, wird Bob tatsächlich Messungen in diesen Basen vornehmen. Wenn Bob eine Messung auf der gleichen Grundlage vornimmt, auf der Alice den Zustand vorbereitet hat, können wir das Ergebnis von Bobs Messung vorhersagen. Wenn Bob zufällig eine andere Basis wählt als die, die Alice bei der Vorbereitung verwendet hat, können wir das Ergebnis von Bobs Messung nicht kennen.

Betrachten Sie in der folgenden Tabelle die erste Spalte. Alice hat den Zustands $\vert +\rangle$ vorbereitet, der ein Eigenzustand von X ist. Da Bob sich ebenfalls zufällig für eine Messung in der X-Basis entschieden hat, gibt es nur ein mögliches Ergebnis für Bobs gemessenen Zustand: $\vert +\rangle$. In der zweiten Spalte haben sie jedoch unterschiedliche Basen gewählt. Der von Alice gesendete Zustand lautet „ $\vert -\rangle = \frac{1}{\sqrt{2}}(\vert 0\rangle-\vert 1 \rangle)$ “. Dieser wird mit einer Wahrscheinlichkeit von 50 % von Bob im Zustand „ $\vert 0\rangle$ “ gemessen und mit einer Wahrscheinlichkeit von 50 % im Zustand „ $\vert 1\rangle$ “. Daher kann die Zeile, die unsere a priori-Kenntnisse über Bobs Messungen wiedergibt, in Spalte 2 nicht ausgefüllt werden. Aber Bob wird eine Messung durchführen und einen Eigenzustand von (in dieser Spalte) Z erhalten. In der untersten Zeile tragen wir ein, welche Werte bei diesen Messungen ermittelt wurden.

QKD Schritt 3: Öffentliche Diskussion der Grundlagen

Alice und Bob können sich nun gegenseitig mitteilen, welche Grundlage sie in jedem Fall gewählt haben. Für alle Spalten, in denen sie zufällig die gleiche Basis gewählt haben, wissen sie mit Sicherheit, welchen Status der andere hatte. Bob kann den Zustand und die Basis in eine 0 oder 1 umwandeln, entsprechend der von beiden Parteien geteilten Konvention. Wir können die obige Tabelle so umschreiben, dass sie nur die Fälle anzeigt, in denen die Basen von Alice und Bob übereinstimmen:

Alice hat die Bitfolge 00100... erfolgreich übertragen. an Bob. Hätten sich die Freunde im Voraus darauf geeinigt, 5-Bit-Zeichenfolgen als Zahlen in ihrem Einmal-Pad zu verwenden, würden diese ersten fünf Bits ihnen die Zahl $4 = 0\times2^4+0\times2^3+1\times2^2+0\times2^1+0\times2^0$ liefern.

QKD Schritt 4: Geheimnis überprüfen und senden

Bevor Alice und Bob weitermachen, sollten sie eine Teilmenge ihrer klassischen Bits zum Vergleich auswählen. Da sie nur Messungen von Qubits aufbewahrt haben, die auf der gleichen Basis vorbereitet und gemessen wurden, sollten alle Messwerte übereinstimmen. Wenn ein sehr kleiner Prozentsatz nicht übereinstimmte, könnte dies auf Quantenrauschen oder Fehler zurückzuführen sein. Aber wenn viele nicht einverstanden sind, ist etwas schief gelaufen!

Wir werden hier nicht darauf eingehen, welcher Teil des Schlüssels für die Überprüfung verwendet werden sollte. Für den Moment gehen wir davon aus, dass diese Prüfung gut verläuft; wir werden im folgenden Abschnitt über das Abhören darauf zurückkommen.

Die Freunde würden sich dann gegenseitig über klassische Kanäle eine verschlüsselte Nachricht schicken. Sie würden dann die Zahlen in ihrem Einmal-Pad verwenden, um geheime Nachrichten zu ver- und entschlüsseln, ohne das Einmal-Pad jemals von einem Ort zum anderen zu übertragen. Für den nächsten Abschnitt über das Abhören ist zu bedenken, dass die Weitergabe des Schlüssels vor der Offenlegung des verschlüsselten Geheimnisses über klassische Kanäle erfolgt.

Alice und Bob haben ihre Wahlgrundlage über klassische Kanäle mitgeteilt, könnte das nicht abgefangen werden? Ja! Aber wenn man weiß, auf welcher Grundlage sie gemessen haben, kann man nicht sagen, welches Bit sie gesendet oder erhalten haben. Das ist nur möglich, wenn man auch Alices Startbits kennt. Aber dann befänden Sie sich in Alices Computer, wo die Geheimnisse gespeichert sind, und die geheime Kommunikation der Geheimnisse würde hinfällig. Das Abhören der klassischen Kommunikation bricht also nicht die Verschlüsselung. Aber was ist mit dem Abfangen von Informationen über den Quantenkanal?

Widerstandsfähigkeit von QKD gegen Abhören

Alice und Bob haben eine Freundin Eve, die für ihre Lauschangriffe berüchtigt ist. Eve möchte den Quantenschlüssel von Alice und Bob abfangen, um ihn zur Entschlüsselung von Nachrichten zwischen den beiden zu verwenden. Dies würde zwangsläufig zwischen der Vorbereitung der Zustände durch Alice und der Messung der Zustände durch Bob geschehen, da die Messung den Quantenzustand kollabieren lässt. Dies bedeutet insbesondere, dass das Abhören erfolgen muss , bevor eine gemeinsame Nutzung oder ein Abgleich von Datenbanken stattgefunden hat.

Eve muss erraten, welche Basis bei der Kodierung jedes Bits verwendet wurde. Auch hier gilt: Wenn sie keinen Zugang zu Alices Computer hat, hat sie keine Grundlage für ihre Vermutung, und sie wird zufällig sein. Nehmen wir an, dass Alices Start die gleiche ist wie zuvor, und nehmen wir weiter an, dass Bobs zufällige Wahl der Messbasis die gleiche ist wie zuvor. Füllen wir aus, was Eva erhält, wenn sie Messungen im Quantenkanal vornimmt. Wenn Eva zufällig die gleiche Basis wie Alice wählt, wissen wir, was sie bekommen wird. Andernfalls könnte sie eines von zwei Ergebnissen erzielen, die jeweils eine Wahrscheinlichkeit von 50 % haben.

Da Eve nun aber keine Ahnung hat, ob sie mit Alices Basis übereinstimmt oder nicht, weiß sie nicht, was sie an Bob senden soll, um Alices ursprüngliche Zustände nachzubilden. Wenn Eve beispielsweise $|0\rangle$ misst, weiß sie mit Sicherheit nur, dass Alice den Zustand $|1\rangle$ für dieses Qubit nicht vorbereitet hat. Alice hätte jedoch auch $|0\rangle$, $|+\rangle$ oder $|-\rangle$ vorbereiten können. Alle diese Ergebnisse wären mit Eves Messung vereinbar. Also muss Eva eine Entscheidung treffen. Entweder übermittelt sie genau den von ihr gemessenen Zustand weiter, oder sie versucht zu erraten, in welchen Fällen ihre Messung nicht dem von Alice gesendeten Eigenzustand entsprach. Wir werden eine Mischung in unsere Tabelle aufnehmen:

An dieser Stelle kann man sich fragen: "Warum macht Eva nicht einfach eine Kopie von Alices Quantenzustand, behält eine zum Messen und gibt die andere an Bob weiter?" Die Antwort ist das "No-Cloning"-Theorem. Inoffiziell heißt das, dass es keine einheitliche (quantenmechanische) Operation gibt, die eine zweite Kopie eines beliebigen Quantenzustands erstellen kann, während die erste Kopie erhalten bleibt. Der Beweis ist relativ einfach und soll als Übung dienen. Verstehen Sie aber zunächst, dass die Herstellung von Kopien des Quantenzustands durch Eve durch fundamentale Naturgesetze verboten ist, und dies ist eine prinzipielle Stärke von QKD.

Wie zuvor würden Alice und Bob sich gegenseitig anrufen und die Basen vergleichen. Sie werden diese Tabelle auf die Fälle reduzieren, in denen die beiden Freunde die gleichen Basen ausgewählt haben:

Alice und Bob haben wieder einmal eine Bitfolge übermittelt... aber die Zeichenfolgen stimmen nicht überein. Die Bits ganz links und in der Mitte sind gespiegelt. Ein Blick auf die vorherige Tabelle zeigt, dass diese Diskrepanz auf die Störung durch Eva zurückzuführen ist. Wichtig ist, dass wir jetzt, während wir den Schlüssel erstellen, Statistiken über die Übereinstimmung unserer Bitstrings erstellen können, lange bevor wir unser verschlüsseltes Geheimnis weitergeben. Alice und Bob können beliebig viele ihrer One-Time-Pad-Bits verwenden, um die Sicherheit ihres Kanals zu überprüfen. Wenn ein einzelnes Bit oder ein sehr kleiner Prozentsatz von Bits nicht übereinstimmt, kann dies auf Rauschen oder Fehler zurückzuführen sein. Ein erheblicher Teil der Abweichungen deutet jedoch auf Abhörmaßnahmen hin. Die Bedeutung von "substanziell" hängt hier ein wenig vom Rauschen im verwendeten Aufbau ab; was das für IBM® Quantencomputer bedeutet, wird weiter unten diskutiert, wenn wir dieses Protokoll implementieren. Wenn zu viele Fehler entdeckt werden, teilen Alice und Bob das Geheimnis nicht und können mit der Jagd auf den Abhörenden beginnen.

Vorbehalte

Der Nachweis der Sicherheit ist äußerst schwierig. Das hier grob beschriebene Protokoll wurde 1984 vorgeschlagen und konnte erst 16 Jahre später als sicher eingestuft werden (Shor & Preskill, 2000 ). Es gibt viele Feinheiten, die den Rahmen dieser Einführung sprengen würden. Wir werden jedoch kurz einige davon aufzählen, um zu zeigen, dass das Thema komplexer ist als hier dargestellt.

• Sichere Kanäle: Wenn Alice ihre Qubits durch eine Quantenanordnung (einen Kanal) sendet und insbesondere, wenn sie klassische Antworten von jemandem zurückbekommt, haben wir angenommen, dass dieser jemand tatsächlich Bob ist. Wenn Eve dieses System so infiltriert hat, dass die gesamte Kommunikation von Alice mit Eve und die gesamte Kommunikation von Bob mit Eve stattfand, dann hat Eve tatsächlich einen Schlüssel erhalten und kann Geheimnisse erfahren. Zunächst muss man für "sichere Kanäle" sorgen, ein Prozess mit einer anderen Reihe von Protokollen, auf die wir hier nicht eingegangen sind.
• Annahmen über Eve: Um die Sicherheit wirklich zu beweisen, können wir keine Annahmen über Evas Verhalten machen; sie könnte immer unsere Erwartungen enttäuschen. Um konkrete Beispiele zu nennen, gehen wir hier von Annahmen aus. Wir könnten zum Beispiel annehmen, dass die Zustände, die Eve an Bob weitergibt, immer genau die sind, die sie bei der Messung erhalten hat. Oder wir könnten annehmen, dass sie zufällig einen Zustand wählt, der experimentell mit ihrer Messung übereinstimmt. Grundsätzlich wird hier davon ausgegangen, dass Eva tatsächlich eine Messung vornimmt, anstatt den Zustand in einem anderen Quantensystem zu speichern und ein zufälliges Qubit an Bob zu senden. Diese Annahmen sind gut, um das Protokoll zu verstehen, aber sie bedeuten, dass wir nicht alles in voller Allgemeinheit beweisen können.
• Verstärkung der Privatsphäre: Alice und Bob sind nicht verpflichtet, den Quantenschlüssel genau so zu verwenden, wie er übermittelt wurde. Sie können z. B. eine Hash-Funktion auf den gemeinsamen Schlüssel anwenden. Dabei wird die Tatsache ausgenutzt, dass der Abhörende den Schlüssel nur unvollständig kennt, um einen kürzeren, aber sicheren gemeinsamen Schlüssel zu erzeugen.

Experiment 1: QKD ohne Lauscher

Wir wollen das obige Protokoll in Abwesenheit eines Abhörers implementieren. Wir werden dies zunächst mit einem Simulator tun, einfach um den Arbeitsablauf zu verstehen.

Zunächst eine Anmerkung zu Quantensimulatoren: Die meisten Quantenprobleme, die mehr als ~30 Qubits umfassen, können von den meisten Computern nicht simuliert werden. Kein klassischer Computer, Supercomputer oder Grafikprozessor kann die gesamte Bandbreite des Verhaltens eines Quantencomputers mit 127 Qubits simulieren. Die Motivation für den Einsatz von echten Quantencomputern ist normalerweise, dass die vielen verschränkten Qubits nicht simuliert werden können. In diesem Fall gibt es keine Verschränkung von Qubits, es sei denn, wir verwenden das Teleportationsverfahren, um Informationen zu übertragen. In diesem Fall ist die Motivation für den Einsatz echter Quantencomputer eine andere: es ist das No-Cloning-Theorem. Ein klassischer Computer, der ein Qubit simuliert, könnte Informationen über einen Quantenzustand von Alice an Bob senden, aber wenn diese klassischen Informationen abgefangen würden, könnten sie leicht dupliziert werden, und Eve könnte eine perfekte Kopie behalten, während sie eine andere an Bob sendet. Dies ist bei echten Quantenzuständen nicht möglich.

IBM Quantum empfiehlt, Probleme der Quanteninformatik mit Hilfe eines Rahmens zu lösen, den wir "Qiskit-Muster" nennen. Sie besteht aus den folgenden Schritten.

• Schritt 1: Übertragen Sie Ihr Problem auf einen Quantenkreis
• Schritt 2: Optimieren Sie Ihre Schaltung für den Betrieb auf echter Quantenhardware
• Schritt 3: Führen Sie Ihren Auftrag auf IBM Quantencomputern mit Laufzeitprimitiven aus
• Schritt 4: Nachbearbeitung der Ergebnisse

Qiskit-Muster Schritt 1: Ordnen Sie Ihr Problem einem Quantenschaltkreis zu

In diesem Fall reduziert sich die Abbildung unseres Problems auf Quantenschaltungen auf die einfache Vorbereitung von Alices Zuständen und die Einbeziehung von Bobs Messungen. Wir beginnen mit der Auswahl von Zufallsbits und Zufallsbasen.

# Qiskit patterns step 1: Map your problem to quantum circuit
# Import some generic packages

import numpy as np
from qiskit import QuantumCircuit

# Set up a random number generator and a quantum circuit. We choose to start with 20 bits, though
# any number <30 should be fine.

rng = np.random.default_rng()
bit_num = 20
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Random bits and bases for Alice
# generate Alice's random bits

abits = np.round(rng.random(bit_num))

# generate Alice's random measurement bases. Here we will associate a "0" with the Z basis, and a
# "1" with the X basis.

abase = np.round(rng.random(bit_num))

# Alice's state preparation. Check that this creates states according to table 1

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob
# generate Bob's random measurement bases.

bbase = np.round(rng.random(bit_num))

# Note that if Bob measures in Z no gates are necessary, since IBM Quantum computers
# measure in Z by default.
# If Bob measures in the X basis, we implement a hadamard gate qc.h to facilitate the measurement.

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)

Stellen wir uns die Bits, Basen und den Schaltkreis vor. Beachten Sie, dass die Basen manchmal übereinstimmen, manchmal aber auch nicht.

print("Alice's bits are ", abits)
print("Alice's bases are ", abase)
print("Bob's bases are ", bbase)
qc.draw("mpl")

Output:

Alice's bits are  [1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 0. 0. 1. 0. 0. 0. 1. 0. 0. 0.]
Alice's bases are  [0. 0. 0. 1. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 0. 1. 1. 0. 1. 0.]
Bob's bases are  [0. 1. 1. 0. 1. 0. 1. 1. 0. 0. 1. 1. 0. 0. 1. 0. 1. 1. 0. 0.]

Qiskit-Muster Schritt 2: Optimieren Sie das Problem für die Quantenausführung

In diesem Schritt werden die Operationen, die wir durchführen wollen, in Bezug auf die Funktionalität eines bestimmten Quantencomputers ausgedrückt. Außerdem wird unser Problem auf den Aufbau des Quantencomputers übertragen.

Wir beginnen mit dem Laden mehrerer Pakete, die für die Kommunikation mit IBM Quantencomputern erforderlich sind. Wir müssen auch ein Backend auswählen, auf dem die Anwendung laufen soll. Wir können entweder das am wenigsten ausgelastete Backend wählen oder ein bestimmtes Backend auswählen, dessen Eigenschaften wir kennen. Obwohl wir momentan einen Simulator verwenden werden, ist es wichtig, ein vernünftiges Rauschmodell in der Simulation zu verwenden, und es ist gut, den Arbeitsablauf so nah wie möglich an dem zu halten, was wir später für echte Quantencomputer verwenden werden.

Unten finden Sie einen Code, mit dem Sie Ihre Anmeldedaten bei der ersten Verwendung speichern können. Achten Sie darauf, diese Informationen aus dem Notebook zu löschen, nachdem Sie es in Ihrer Umgebung gespeichert haben, damit Ihre Anmeldedaten nicht versehentlich weitergegeben werden, wenn Sie das Notebook freigeben. Weitere Anleitungen finden Sie unter Einrichten Ihres IBM Cloud Kontos und Initialisieren des Dienstes in einer nicht vertrauenswürdigen Umgebung.

# Load IBM Quantum Compute Service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load IBM Quantum Compute Service

# Syntax for first saving your token.  Delete these lines after saving your credentials.
# QiskitRuntimeService.save_account(channel='ibm_quantum_platform',
# instance = '<YOUR_IBM_INSTANCE_CRN>', token='<YOUR-API_KEY>', overwrite=True, set_as_default=True)
# service = QiskitRuntimeService(channel='ibm_quantum_platform')

# Load saved credentials
service = QiskitRuntimeService()


# Use the least busy backend, or uncomment the loading of a specific backend like "ibm_brisbane".
# backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)
backend = service.backend("ibm_brisbane")
print(backend.name)

Output:

ibm_brisbane

Im Folgenden wählen wir einen Simulator und ein Rauschmodell aus.

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

# Load the qiskit runtime sampler
from qiskit_ibm_runtime import SamplerV2 as Sampler


noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Qiskit patterns step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

Qiskit-Muster Schritt 3: Ausführen

Verwenden Sie den Sampler, um Ihren Auftrag auszuführen, mit dem Stromkreis als Argument.

# This required 5 s to run on a Heron r2 processor on 10-28-24
sampler = Sampler(mode=backend)
job = sampler.run([qc_isa], shots=1)
# job = sampler_sim.run([qc], shots = 1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Qiskit-Muster Schritt 4: Nachbearbeitung

Hier interpretieren wir unsere Ergebnisse und gewinnen nützliche Informationen. Wir könnten versuchen, die Ausgabe unseres Samplers zu visualisieren, aber wir haben Sampler auf eine unkonventionelle Art und Weise verwendet. Anstatt viele Messungen an unserer Schaltung vorzunehmen und Statistiken über die Zustände zu erstellen, haben wir nur eine Messung vorgenommen (die von Bob). Jedes Qubit mit einem Zustand, der auf der gleichen Basis vorbereitet und gemessen wurde, sollte ein deterministisches Ergebnis haben, so dass nur eine Messung erforderlich ist. Diese Qubits mit Zuständen, die in verschiedenen Basen vorbereitet und gemessen wurden (die probabilistische Ergebnisse haben und viele Messungen zur Interpretation erfordern würden), werden nicht verwendet, um unseren einmaligen Block/Schlüssel zu erstellen.

Extrahieren wir eine Liste von Messergebnissen aus diesem Bitstring. Achte darauf, dass du die Reihenfolge umkehrst, wenn du sie mit Alices Bitfeld vergleichst, das wir zum Erstellen der Schaltung verwendet haben.

# Get an array of bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))

# Reverse the order to match our input. See "little endian" notation.

bbits = bmeas_ints[::-1]

print(bbits)

Output:

[1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0]

Vergleichen wir die von Alice und Bob zufällig gewählten Messbasen. Dies war Schritt 3 in unserem QKD-Protokoll (öffentliche Diskussion der Grundlagen). Jedes Mal, wenn sie dieselbe Basis für ein Qubit wählen, fügen wir die mit diesem Qubit verbundenen Bits zu einer Liste von Bits für die Generierung von Zahlen in einem One-Time-Pad hinzu. Wenn die Basen nicht übereinstimmen, werden die Ergebnisse verworfen. Überprüfen wir auch, ob die beiden Listen der Bits übereinstimmen oder ob es Verluste aufgrund von Rauschen oder anderen Faktoren gab.

# QKD step 3: Public discussion of bases

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    # Check whether bases matched.
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        # If bits match when bases matched, increase count of matching bits
        if int(abits[n]) == bbits[n]:
            match_count += 1

print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 0, 1, 0, 0, 0, 1, 0]
[1, 0, 1, 0, 0, 0, 1, 0]
fidelity =  1.0
loss =  0.0

Alice und Bob haben jeweils eine Liste von Bits, die mit 100%iger Sicherheit übereinstimmen. Sie können diese verwenden, um Zahlen in einem einmaligen Block zu generieren. Diese können sie dann in QKD-Schritt 4 verwenden: Senden und Entschlüsseln eines Geheimnisses. Die derzeitige Anordnung der Bits ist zu kurz, um viel zu entschlüsseln. Wir werden darauf zurückkommen, nachdem wir das Abhören einbezogen haben.

Überprüfen Sie Ihr Verständnis

Gehen Sie davon aus, dass Sie Ziffern benötigen, die groß genug sind, um das Verschieben von Buchstaben im englischen Alphabet um die volle Länge des Alphabets oder mehr zu ermöglichen, obwohl es sicherlich auch andere Kodierungsschemata gibt. (a) Wie viele Buchstaben könnte eine Nachricht lang sein, damit sie mit den Bits im obigen Schlüssel entschlüsselt werden kann? (b) Muss Ihre Antwort mit der Ihrer Klassenkameraden übereinstimmen? Gründe?

• Antwort

  (a) Die Antwort hängt davon ab, wie viele zufällig ausgewählte Basen bei Alice und Bob übereinstimmen. Da die Wahrscheinlichkeit, dass die Basen bei einem beliebigen Qubit übereinstimmen, bei etwa 50:50 liegt, gehen wir davon aus, dass fast 10 unserer Bits brauchbar sind. 9 oder 11 werden völlig normal sein. Selbst 4 oder 15 sind nicht ausgeschlossen. Für eine Verschiebung um eine Zahl, die größer oder gleich der Länge des englischen Alphabets ist, sind 5 Bits erforderlich, was bedeutet, dass man die Verschiebung auf einen Buchstaben pro 5 Bits anwenden kann. Wenn Alice und Bob mindestens 5 gemeinsame Bits haben, kannst du einen einzelnen Buchstaben verschlüsseln. Wenn du mindestens 10 hast, kannst du 2 Buchstaben darstellen, und so weiter.

  (b) Dies muss aus den unter (a) genannten Gründen nicht der Fall sein.

Experiment 2: QKD mit einem Lauscher

Wir werden genau das gleiche Protokoll wie bisher verwenden. Dieses Mal werden wir einen weiteren Satz von Messungen durch Eve zwischen Alice und Bob einfügen.

from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister

# Qiskit patterns step 1: Mapping your problem to a quantum circuit
# QKD step 1: Random bits and bases for Alice

bit_num = 20
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Alice's random bits and bases, as before

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation, as before

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute
job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

Qiskit-Muster Schritt 4 (Nachbearbeitung) ist in diesem Fall einfach. Es besteht keine Notwendigkeit, die Verteilung der Messungen zu visualisieren, da wir nur eine Messung durchgeführt haben. Eve hat die folgenden Bits:

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

print(ebits)

Output:

[0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1]

Nun muss Eva die Zustände rekonstruieren, um sie an Bob weiterzuleiten. Wie in der Einleitung beschrieben, kann sie nicht wissen, ob sie die Kodierungsgrundlagen richtig erraten hat, so dass sie nicht in der Lage ist, genau die gleichen Zustände vorzubereiten, die gesendet wurden. Sie könnte davon ausgehen, dass jede Basiswahl richtig war und genau das kodieren, was sie gemessen hat, oder sie könnte annehmen, dass sie die Basis falsch gewählt hat und einen der Eigenzustände der entgegengesetzten Basis wählen. Der Einfachheit halber gehen wir hier vom ersten Fall aus. Wir erreichen dies, indem wir einen völlig neuen Quantenschaltkreis konstruieren und die Schritte der Qiskit-Muster wie zuvor wiederholen.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit patterns step 1: Mapping your problem onto a quantum circuit
# QKD step 1: Eve uses her measurements to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

qc.barrier()

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)


# Qiskit patterns step 3: Execute

job = sampler_sim.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

print(bbits)

Output:

[0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1]

Wir wollen nun die Bits von Alice und Bob vergleichen:

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1
print(agoodbits)
print(bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

[1, 1, 0, 0, 0, 1, 1]
[1, 1, 0, 0, 0, 0, 1]
fidelity =  0.8571428571428571
loss =  0.1428571428571429

Zuvor gab es eine perfekte Übereinstimmung zwischen den Bits in Alices und Bobs Schlüssel. Anhand von Evas Störung sehen wir, dass die Bits von Alice und Bob in 14 % der Fälle, in denen sie übereinstimmen sollten, unterschiedlich sind, weil Alice und Bob die gleichen Basen ausgewählt haben. Dies sollte für Alice und Bob leicht zu erkennen sein. Wenn man sich jedoch auf einen derartigen Prozentsatz von Fehlern verlässt, bedeutet dies, dass es eine Grenze gibt, wie viel Rauschen wir im Quantenkanal tolerieren können.

Experiment 3: Vergleich von QKD mit und ohne Abhören auf einem realen Quantencomputer

Lassen wir dies auf einem echten Quantencomputer laufen. Auf diese Weise können wir das Klonverbotstheorem nutzen. Gleichzeitig haben echte Quantencomputer Rauschen und eine höhere Fehlerquote als klassische Computer. Vergleichen wir also den Vertrauensverlust unserer Schlüsselbits mit und ohne Abhören, um sicherzustellen, dass der Unterschied bei Verwendung eines echten Quantencomputers erkennbar ist. Wir beginnen mit der Abwesenheit von Lauschangriffen:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 3 sec to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qc = QuantumCircuit(bit_num, bit_num)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(m, m)


# Qiskit patterns step 2: Transpilation

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Load the Runtime primitive and session
sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's measurement bases and collect usable bits

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
Bob's bits =  [0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1]
fidelity =  0.9682539682539683
loss =  0.031746031746031744

Ohne Abhören erreichten wir eine 100-prozentige Treue bei diesem Satz von 127 Versuchsbits, was zu 55 übereinstimmenden Basen und verwendbaren Schlüsselbits führte. Wiederholen wir dieses Experiment nun mit Eva, die mitlauscht:

from qiskit_ibm_runtime import SamplerV2 as Sampler

# This calculation was run on an Eagle r3 processor on 11-7-24 and
# required 2 s to run, with 127 qubits.
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

bit_num = 127
qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)

# QKD step 1: Generate Alice's random bits and bases

abits = np.round(rng.random(bit_num))
abase = np.round(rng.random(bit_num))

# Alice's state preparation

for n in range(bit_num):
    if abits[n] == 0:
        if abase[n] == 1:
            qc.h(n)
    if abits[n] == 1:
        if abase[n] == 0:
            qc.x(n)
        if abase[n] == 1:
            qc.x(n)
            qc.h(n)


# Eavesdropping happens here!
# Generate Eve's random measurement bases

ebase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if ebase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

sampler = Sampler(mode=backend)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit patterns step 4: Post-processing
# Extract Eve's bits

keys = counts.keys()
key = list(keys)[0]
emeas = list(key)
emeas_ints = []
for n in range(bit_num):
    emeas_ints.append(int(emeas[n]))
ebits = emeas_ints[::-1]

# print(ebits)

# Restart process
# Qiskit patterns step 1: Mapping your problem to a quantum circuit

# QKD step 1: Eve uses her measurements above to prepare best guess states to send on to Bob

qr = QuantumRegister(bit_num, "q")
cr = ClassicalRegister(bit_num, "c")
qc = QuantumCircuit(qr, cr)


# Eve's state preparation

for n in range(bit_num):
    if ebits[n] == 0:
        if ebase[n] == 1:
            qc.h(n)
    if ebits[n] == 1:
        if ebase[n] == 0:
            qc.x(n)
        if ebase[n] == 1:
            qc.x(n)
            qc.h(n)

# QKD step 2: Random bases for Bob

bbase = np.round(rng.random(bit_num))

for m in range(bit_num):
    if bbase[m] == 1:
        qc.h(m)
    qc.measure(qr[m], cr[m])

# Qiskit patterns step 2: Transpile

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)
qc_isa = pm.run(qc)

# Qiskit patterns step 3: Execute

job = sampler.run([qc_isa], shots=1)
counts = job.result()[0].data.c.get_counts()
countsint = job.result()[0].data.c.get_int_counts()

# Qiskit Patterns step 4: Post-processing
# Extract Bob's bits

keys = counts.keys()
key = list(keys)[0]
bmeas = list(key)
bmeas_ints = []
for n in range(bit_num):
    bmeas_ints.append(int(bmeas[n]))
bbits = bmeas_ints[::-1]

# Compare Alice's and Bob's bases, when they are the same, keep the bits.

agoodbits = []
bgoodbits = []
match_count = 0
for n in range(bit_num):
    if abase[n] == bbase[n]:
        agoodbits.append(int(abits[n]))
        bgoodbits.append(bbits[n])
        if int(abits[n]) == bbits[n]:
            match_count += 1

# Print some results

print("Alice's bits = ", agoodbits)
print("Bob's bits = ", bgoodbits)
print("fidelity = ", match_count / len(agoodbits))
print("loss = ", 1 - match_count / len(agoodbits))

Output:

Alice's bits =  [1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1]
Bob's bits =  [1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]
fidelity =  0.7619047619047619
loss =  0.23809523809523814

Hier haben wir einen Verlust von fast 23% an Wiedergabetreue bei gemeinsam genutzten Bits aufgrund von Abhören festgestellt! Das ist sehr gut nachweisbar! Es ist zu beachten, dass die Übertragung von Quanteninformationen über große Entfernungen immer noch zusätzliches Rauschen und Fehler verursachen kann. Es ist ein komplexes Gebiet, das über diese Einführung hinausgeht, wenn man sicherstellt, dass Lauschangriffe auch in Anwesenheit von Geräuschen entdeckt werden können, selbst wenn Eve alle ihr zur Verfügung stehenden Tricks anwendet.

Fragen

Lehrkräfte können Versionen dieser Hefte mit Antwortschlüsseln und Hinweisen zur Einordnung in gängige Lehrpläne anfordern, indem sie diese kurze Umfrage zur Verwendung der Hefte ausfüllen.

Kritische Konzepte

• Quanteninformation kann nicht kopiert oder "geklont" werden.
• Man kann den gleichen Präparationsprozess wiederholen, um ein Ensemble von Quantenzuständen zu erzeugen, die alle gleich oder fast gleich sind.
• Ein Verschlüsselungs-/Entschlüsselungsschlüssel (ein One-Time-Pad) kann unter Verwendung von Quantenzuständen zwischen zwei Freunden ausgetauscht werden.
• Wenn zwei Freunde nach dem Zufallsprinzip eine Messbasis wählen, bedeutet dies, dass sie in der Hälfte der Fälle eine andere Wahl treffen und die Informationen über diese Qubits verwerfen müssen.
• Die zufällige Wahl der Messbasis stellt auch sicher, dass ein Abhörer den vorbereiteten Ausgangszustand nicht kennen und somit den gesendeten Zustand nicht wiederherstellen kann. Dadurch wird sichergestellt, dass das Abhören entdeckt wird.

Richtig/Falsch-Fragen

1. T/F Bei der Quantenschlüsselverteilung messen die beiden Kommunikationspartner jedes Qubit auf der gleichen Basis.
2. T/F Ein Abhörer, der Quanteninformationen bei QKD abfängt, wird durch die Naturgesetze daran gehindert, den abgefangenen Quantenzustand zu kopieren.
3. T/F Ein One-Time-Pad ist ein Schlüssel zur Ver-/Entschlüsselung sicherer Nachrichten, bei dem ein bestimmtes Kodierungsschema nur einmal für eine einzige Information (z. B. einen Buchstaben des Alphabets) verwendet wird.

MC-Fragen

1. Wählen Sie die Option, die die Aussage am besten vervollständigt. Wie in diesem Modul beschrieben, ist ein One-Time-Pad ein Satz von Verschlüsselungs-/Entschlüsselungsschlüsseln, der verwendet wird...

• a. Nur einmal für eine einzelne Information, z. B. einen einzelnen Buchstaben.
• b. Nur einmal für eine einzige Nachricht.
• c. Nur einmal für einen bestimmten Zeitraum, etwa einen Tag.
• d. Solange es keine Beweise für Abhörmaßnahmen gibt.

2. Angenommen, Alice und Bob wählen ihre Messbasen zufällig. Sie messen. Dann tauschen sie ihre Messgrundlagen aus und behalten nur die Informationen aus den Fällen, in denen sie dieselbe Grundlage verwendet haben. Wie viel Prozent ihrer Qubits sollten bis zu einer gewissen zufälligen Fluktuation verwertbare Informationsbits liefern?

• a. 100 %
• b. 50°%
• c. 25ₒ%
• d. 12.5%
• e. 0 %

3. Nachdem Alice und Bob Fälle ausgewählt haben, in denen sie die gleichen Messgrundlagen verwendet haben, wie viel Prozent dieser Informationsbits sollten übereinstimmen, wenn Quantenrauschen und Fehler vernachlässigbar wären?

• a. 100 %
• b. 50°%
• c. 25ₒ%
• d. 12.5%
• e. 0 %

4. Angenommen, Alice hat ihre Messbasen zufällig ausgewählt. Eva wählt ihre Basen ebenfalls nach dem Zufallsprinzip aus, und sie hört zu (Maßnahmen). Sie sendet an Bob Zustände, die mit ihren Messungen übereinstimmen. Alice und Bob vergleichen die Wahl der Basen und behalten nur die von ihnen gemessenen/vorbereiteten Qubits in denselben Basen. Bis zu einer gewissen zufälligen Fluktuation wird ungefähr der Prozentsatz dieser gehaltenen Qubit-Messungen übereinstimmen, wie Alice und Bob meinen?

• a. 100 %
• b. 75 % 




• c. 50°%
• d. 25ₒ%
• e. 12.5%
• F. 0 %

DISKUSSIONSFRAGEN

1. Nehmen wir an, dass alle Basisentscheidungen für alle Teilnehmer, Alice, Bob und Eve, zufällig sind. Nehmen wir an, dass Eva nach dem Abhören einen Zustand an Bob sendet, der auf der gleichen Basis vorbereitet wird, auf der sie gemessen hat, und der mit dieser Messung übereinstimmt. Überzeugen Sie Ihre Partner davon, dass 12.5 % aller Qubits, die von Alice initialisiert werden, zu Messabweichungen zwischen Alice und Bob führen, was auf Abhören hindeutet (Quantenfehler und Rauschen werden nicht berücksichtigt). Hinweis 1: Da es keine bevorzugte Basis gibt, sollte, wenn man nur eine einzige Wahl für Alice in Betracht zieht, das Verhältnis für diese eine Wahl dasselbe sein wie das Verhältnis für die Summe aller Wahlmöglichkeiten. Hinweis 2: Es reicht möglicherweise nicht aus, die Anzahl der Möglichkeiten zu zählen, auf die etwas passieren könnte, da einige Ergebnisse mit unterschiedlichen Wahrscheinlichkeiten auftreten können.

2. Nehmen wir wieder an, dass alle Basisentscheidungen für alle Teilnehmer, Alice, Bob und Eve, zufällig sind. Aber nun bedenken Sie, dass es Eva freisteht, nach ihrer Messung jeden beliebigen Staat mitzuschicken. Sie könnte sogar versuchen, Staaten zu senden, die nicht mit ihren eigenen Messungen übereinstimmen. Diskutieren Sie mit Ihren Partnern/Nachbarn, ob es Ihrer Meinung nach irgendeine Wahl von Basen gibt, die den durchschnittlichen Prozentsatz von Qubits, die Alice und Bob das Abhören anzeigen, verringern könnte.