Het Simuleren van Quantum

Cryptografie met Centimeter

Golven en Python

M ATTHIJS G EERLINGS & N ICK S CHOT

Studentennummers: 16122348 17036801
Begeleider: Lodewijk Arntzen
Datum: January 15, 2021
Samenvatting
Uit een motivatie om de ontwikkeling van de Quantum Cryptografie en de be-
ginselen die hieraan ten grondslag liggen beter te begrijpen is dit project uitgevo-
erd. Er is onderzocht hoe de kern principes uit de Quantum Cryptografie ges-
imuleerd kunnen worden met zowel Python als met centimetergolven. Met name
is er gekeken naar de veiligheid van de zogenaamde ’key distributie’.

De hoofdonderzoeksvraag die leidend is voor dit project luidt:

Is het mogelijk om met een bundel centimetergolven het statische ver-

band tussen de keylengte en keyveiligheid van het BB84 protocol ex-
perimenteel aan te tonen?

Waarin het BB84 protocol het belangrijkste protocol is binnen de Quantum Cryp-
tografie. De grootste uitdaging is het simuleren van het Quantummechanische
meetprobleem, wat een fundamenteel concept is binnen de Quantum Cryptografie,
en minder zichtbaar een rol speelt bij een grote bundel fotonen. Zoals bij centime-
tergolven het geval is.

Het resultaat van dit project was een werkende, geautomatiseerde opstelling waarmee,
met behulp van Python, centimetergolven konden worden verzonden en ontvan-
gen. Met deze opstelling was het mogelijk het BB84 protocol te simuleren. Ook
is het BB84 protocol in Python gesimuleerd om nog meer data te verkrijgen en
te gebruiken als maatstaf waartegen de resultaten van de experimentele opstelling
konden worden getoetst.
Met de resultaten van deze simulaties was het mogelijk om de onderzoeksvraag te
beantwoorden.

De conclusie die werd getrokken is dat het inderdaad mogelijk is om het beschreven
statische verband tussen keylengte en keyveiligheid aan te tonen met centimeter-
golven. Ook is er geconcludeerd dat het BB84 protocol inderdaad veilig is en
voordelen heeft ten opzichte van klassieke cryptografie.

I
Contents
List of Figures III

1 Inleiding 1

2 Theorie 2
2.1 Theorie gerelateerd aan Quantum Cryptografie . . . . . . . . . . 2
2.1.1 Quantum key distributie en het gesimuleerde BB84 protocol 2
2.1.2 Het BB84 Protocol . . . . . . . . . . . . . . . . . . . . . 5
2.1.3 Implicaties Quantum Cryptografie . . . . . . . . . . . . . 6
2.1.4 Invloed eavesdroper op key distributie . . . . . . . . . . . 6
2.1.5 Statistiek achter key veiligheid . . . . . . . . . . . . . . . 7
2.2 Theorie gerelateerd aan praktijkwerk en onderzoek . . . . . . . . 10
2.2.1 Centimetergolven . . . . . . . . . . . . . . . . . . . . . . 10
2.2.2 Simulatie Quantum Cryptografie . . . . . . . . . . . . . . 10

3 Methode 11
3.1 Python simulatie . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Geautomatiseerde Centimetergolven Opstelling . . . . . . . . . . 14

4 Resultaten 17
4.1 Resultaten Python simulatie . . . . . . . . . . . . . . . . . . . . 17
4.2 Resultaten Simulatie met Centimetergolven . . . . . . . . . . . . 18

5 Conclusie 21

6 Aanbeveling 22

7 bibliography 23

A Code voor simulatie met centimetergolven (§3.2) 24

B Code Python simmulatie (§3.1) 32

II
List of Figures
1 Spin oriëntaties fotonen inclusief bijbehorende bit waarde [1] . . . 3
2 Base oriëntaties filters, links Z en rechts X [2] . . . . . . . . . . . 3
3 Kans op goede key van lengte L, na het versturen van 20 fotonen. . 9
4 Bepalen base met random number generator. . . . . . . . . . . . . 11
5 Flow chart van Pyton code die het BB84 protecol uitvoert terwijl
Eve aanwezig is. . . . . . . . . . . . . . . . . . . . . . . . . . . 12
6 Flow chart van Pyton code die de simulatie uitvoert. . . . . . . . . 13
7 Elektrisch schema om de Transmitters een oscillerend eletktrisch
signaal te geven met diode om de spanning te beperken beneden
de 1 V. De (+) en (-) in de figuur geven de terminals van de Trans-
mitter aan. De letter D geeft een arbitraire gekozen digitale poort
van de Arduino aan. . . . . . . . . . . . . . . . . . . . . . . . . . 15
8 Elektrisch schema om de Receivers uit te lezen. Waarin de (+) en
(-) in de figuur de terminals van de Receiver aangeven. De letter
A geeft een arbitraire gekozen analoge poort van de Arduino aan. . 15
9 Verwacht en verkregen aantal keys per lengte. . . . . . . . . . . . 17
10 Verwacht en verkregen aantal correcte keys per lengte. . . . . . . 18
11 Verwacht en verkregen aantal keys per lengte bij de meting met
centimetergolven. . . . . . . . . . . . . . . . . . . . . . . . . . . 19
12 Verwacht en verkregen aantal correcte keys per lengte bij de met-
ing met centimetergolven. . . . . . . . . . . . . . . . . . . . . . . 20

III
1 Inleiding
De Quantum Cryptografie is een tak van de cryptografie waarbij er gebruik wordt
gemaakt van Quantummechanische principes om informatie nog beter te ver-
sleutelen en versleutelde informatie veiliger te kunnen uitwisselen. In dit onder-
zoek wordt specifiek gekeken naar een quantummechanische oplossing voor het
key distributie probleem. Dat is een klassiek probleem in de cryptografie waar de
namen Alice, Bob, en Eve bekend voorkomen. In de theorie zal hier dieper op
in worden gegaan maar dit verslag zal zich beperken tot de quantummechanische
keydistibutie.

Naast onderzoek naar deze oplossing en de implicaties hiervan, is er ook on-

derzoek gedaan naar de veiligheid van deze oplossing met behulp van Python en
statistiek. Daarnaast is het principe van deze oplossing ook experimenteel getoetst
met behulp van Python en een opstelling met centimetergolven.

De grootste uitdaging in het gebruik van centimetergolven is het simuleren van

het Quantummechanische meetprobleem. Dit fenomeen, wat een direct gevolg
is van superpositie, is duidelijk waarneembaar met enkele fotonen. Als er wordt
gesproken over centimetergolven zijn dat nog steeds enkele fotonen, maar is dit
fenomeen niet meer duidelijk waarneembaar. Dat komt omdat het dan gaat om een
hele grote bundel enkele fotonen, die gezamelijk uitsluitend golfverdrag vertonen.

Het doel van het onderzoek is om de quantum cryptografie en de implicaties hi-

ervan te begrijpen, inzicht te krijgen in de veiligheid en statistiek van quantum
key-distributie, en de principes van quantum cryptografie experimenteel te toet-
sen met behulp van simulaties. De verwachting is dat de quantum cryptografie
veilig is en dat de principes ervan succesvol gesimuleerd kunnen worden.

Concreet levert dit de volgende specifieke onderzoeksvragen op:

• Is het mogelijk om met een bundel centimetergolven het statistische verband

tussen de keylengte en keyveiligheid van het BB84 protocol experimenteel
aan te tonen?

• Hoe kan de veiligheid van quantum key-distributie bepaald worden?

• Hoe kunnen de kern principes van de quantum cryptografie gesimuleerd

worden?

1
2 Theorie
Dit hoofdstuk is opgedeeld in twee delen. In het eerste deel: ’Theorie gerelateerd
aan Quantum Cryptografie’ wordt Quantum Cryptografie nauwkeurig uitgelegd.
Daarnaast wordt de invloed die een ’eavesdroper’ op het key distributie proces
heeft beschreven en wordt de statistiek die de veiligheid van het key distributie
proces beschrijft, toegelicht. In het tweede deel van het hoofdstuk ’Theorie gere-
lateerd aan praktijkwerk en onderzoek’, wordt de theorie toegelicht die relevant
is om het uitgevoerde onderzoek te begrijpen. Deze theorie sluit aan bij de in
hoofdstuk 3 beschreven methode.

2.1 Theorie gerelateerd aan Quantum Cryptografie

Cryptografie is het versleutelen/beveiligen van informatie bij het verzenden van
deze informatie. Wanneer je bijvoorbeeld een e-mail verzendt, dan zal deze on-
leesbaar zijn voor een persoon (voor wie de e-mail niet bedoeld is) die de e-mail
onderschept. Dit komt omdat de e-mail als het ware versleteld is. Alleen met
behulp van de zogenaamde ’key’ (sleutel) kan de versleutelde boodschap leesbaar
gemaakt worden. Wanneer een persoon die het bericht onderschept in bezit is van
een sleutel, dan zal deze persoon wel in staat zijn om het bericht te ontcijferen.
De cryptografie methode die vandaag de dag gebruikt wordt, maakt gebruik van
de factorisatie van priemgetallen. Berichten die op deze manier versleuteld zijn,
zijn vrijwel onmogelijk te kraken met een klassieke computer. De verwachting is
echter, dat op deze wijze versleutelde berichten zeer eenvoudig te kraken zullen
zijn door quantum computers. Er wordt namelijk verwacht, dat quantum com-
puters vele malen beter (sneller) zijn in het factoriseren van priemgetallen dan
klassieke computers.
Er bestaat echter een encryptie methode die zelfs voor quantum computers vrijwel
onmogelijk te kraken is. Deze encryptie methode, heet Quantum Cryptografie.
Quantum Cryptografie zal in deze paragraaf verder worden toegelicht.

2.1.1 Quantum key distributie en het gesimuleerde BB84 protocol

Bij het versturen van een boodschap is er een verzender en een ontvanger. In
de rest van deze paragraaf zal de verzender Alice, en de ontvanger Bob worden
genoemd. Voordat Alice haar boodschap (bijvoorbeeld een e-mail) naar Bob zal
sturen, zullen Alice en Bob eerst een gezamelijke Quantum key genereren. Zij
doen dit via het BB84 protocol. Het genereren van de Quantum key in het ges-
imuleerde protocol gaat als volgt in zijn werk. Alice stuurt één voor één, een n
aantal fotonen naar Bob. Elk van deze fotonen gaat door een polarisatie filter. De

2
oriëntatie van het filter bepaalt welke bit-waarde aan het foton wordt meegegeven.
Er zijn vier mogelijke oriëntaties, zoals te zien is in figuur 1.

Figure 1: Spin oriëntaties fotonen inclusief bijbehorende bit waarde [1]

Zoals te zien is in het figuur, zijn er twee spin oriëntaties met een bitwaarde van 1,
en twee oriëntaties met een bitwaarde van 0. De oriëntaties met een hoek van 0° en
45° ten opzichte van de verticale as hebben een bitwaarde van 1, en de oriëntaties
met een hoek van 90° en -45° hebben een bitwaarde van 0.
Naast een polarisatie hoek en bitwaarde, hebben de fotonen ook een ’base’. Foto-
nen met een polarisatie hoek van 0° of 90° hebben de base Z en fotonen met een
polarisatie hoek van -45° of 45° hebben een base van X. In figuur 2 zijn twee
polarisatie filters met base Z en X te zien (dit zijn een ander type filters, dan de
filters die Alice gebruikt bij het verzenden van de fotonen).

Figure 2: Base oriëntaties filters, links Z en rechts X [2]

Wanneer een foton met een bepaalde base door een filter gaat met dezelfde base,
dan zal dit foton het filter verlaten met dezelfde spin oriëntatie als waarmee het
binnenkwam. Wanneer het foton echter door een filter gaat met een andere base
dan het foton zelf, dan zal de base van het foton veranderen naar de base van het
filter. Wanneer er bijvoorbeeld een foton met een spin oriëntatie van 45° (base X)

3
door een filter met base Z gaat, dan zal het foton het filter verlaten met base Z.
Er is hier een kans van 50% dat het foton een spin oriëntatie van 0° krijgt, en een
kans van 50% dat het foton een spin oriëntatie van 90° krijgt. Er is dus ook een
50% kans, dat de bit waarde van een foton verandert wanneer het door een filter
gaat van een andere base.
De eigenschappen van de vier verschillende fotonen die Alice kan verzenden staan
samengevat in tabel 1.
Table 1: Eigenschappen vier mogelijk verstuurde fotonen

Base Spin oriëntatie Bit waarde

Z 0° 1
Z 90° 0
X 45° 1
X -45° 0

De spin oriëntaties van de door Alice verstuurde fotonen, moeten door Bob bepaald
worden, zodat hij de bitwaardes kan achterhalen. Bob bepaald de bitwaardes met
behulp van een Base filter. Voor elk foton dat hij ontvangt, kiest hij random een
base filter (X of Z) om de spin richting te achterhalen. Wanneer hij echter een
filter met de verkeerde base kiest, zal hij de spin oriëntatie en dus mogelijk de bit
waarde beı̈nvloeden.
Ter voorbeeld: wanneer Alice 10 fotonen naar Bob verstuurt, is een mogelijke
base sequentie: Z, Z, Z, X, Z, Z, X, X, X en Z. Een bitwaarde sequentie die hier
bij kan horen is: 0, 0, 1, 0, 0, 1, 0, 1, 0 en 1. Omdat Alice 10 fotonen verstuurt, zal
ook Bob 10 keer een random base moeten kiezen. Een mogelijke base sequentie
voor Bob is: Z, Z, X, Z, X, Z, Z, X, X en Z. In deze sequentie zijn de eerste,
tweede, zesde, achtste, negende en tiende base gelijk aan die in de sequentie van
Alice. De fotonen gemeten bij deze oriëntatie zullen dan ook de juiste bitwaarde
weergeven. Voor de andere gemeten fotonen, geldt echter dat er een 50% kans
is dat de verkeerde bitwaarde wordt gemeten. Een voorbeeld van een bitwaarde
sequentie die Bob dus zou kunnen krijgen is: 0, 0, 1, 1, 1, 1, 1, 1, 0 en 1. Deze
bitwaarde sequentie komt duidelijk niet overeen met de sequentie van Alice. De
nu verkregen sequentie kan dus ook niet als key worden gebruikt. Om tot een key
te komen, moet er achterhaald worden bij welke fotonen de verkeerde base (een
andere base dan door Alice gebruikt) door Bob is gebruikt. Alice en Bob doen
dit door beide publiek (bijvoorbeeld via twitter) hun base sequentie te delen. Zij
zullen beiden de bitwaardes waarbij niet de zelfde base is gebruikt uit hun key ver-
wijderen. Zij blijven vervolgens beiden over met een bit waarde sequentie van: 0,
0, 1, 1, 0 en 1, en hebben dus de zelfde key. Dat de base sequentie openbaar wordt
gedeeld is geen enkel prboleem, aangezien er voor elke base twee bitwaardes mo-

4
gelijk zijn (0 en 1). Uit de base sequentie is dus nooit de key te achterhalen.

2.1.2 Het BB84 Protocol

Zoals in paragraaf 2.1.1 is toegelicht, werkt het gesimuleerde BB84 protocol door
gebruik te maken van polarisatietoestanden. Het is belangrijk te vermelden hoe
het echte protocol wordt toegepast in de Quantum Cryptografie.

Het BB84 Protocol berust zich alleen op de key distributie. Het protcol is ver-
noemd naar Charles Benett en Gilles Brassard die het ontwikkelde in 1984 [3].
Het is ook het eerste encryptieprotocol in de Quantum Cryptografie. Het protocol
is veilig en gebasseerd op de zogenaamde No-cloning theorem. De No-cloning
theorem zegt eigenlijk dat het onmogelijk is om een identieke kopie te maken
van een onbekende quantum toestand (zoals de spintoestand van een foton). Dit
principe komt voort uit het meetprobleem in de Quantummechanica: de meting
van een quantumtoestand heeft een kans om de toestand te veranderen. Het gevolg
in de Quantum Cryprografie is dat als de key-generatie plaatsvindt door informatie
te coderen in de spintoestanden van fotonen, dat de aanwezigheid van Eve de key-
distributie zo zal beinvloeden (zoals in paragraaf 2.1.1 is toegelicht) dat er geen
key tot stand kan komen en de aanwezigheid van een Eavesdropper dus kan wor-
den aangetoond.

Het is ook belangrijk te vermelden dat er in Quantum Computing wordt gew-

erkt met Qubits en dus niet met ’normale’, klassieke bits. Qubits nemen niet een
specifieke waarde aan (zoals bitwaarde 1 of 0) maar een superpositie van deze
bitwaarden:
|ψi = α|0i + β |1i (1)
De qubit-toestand van een foton is dus een lineare combinatie van de basis bit-
toestanden. In dit geval is de fysische betekenis van de coëfficiënten α en β dat
dit waarschijnlijksheidsamplitudes zijn (een concept uit de quantummechanica).

Zoals in paragraaf 2.1.1 is toegelicht, leidt dit protocol uiteindelijk tot vier ver-
schillende qubit-toestanden. In de simulatie wordt dit gedaan met polarisatiehoeken
en basen. De formele wijze waarop dit in de echte Quantum Cryprografie wordt
gedaan is als volgt: Alice wilt een private key versturen naar Bob en gebruikt
hiervoor twee reeksen aan bits, a en b, beide met een lengte van n bits.

5
 Formeel wordt de manier waarop deze twee reeksen worden gecodeerd weergegeven
als een tensor-product van n qubits:
n
|ψi = ⊗ |ψai ,bi i (2)
i=1

De bits a en b met de verschillende indices √ geven √ dan de vier qubit-toestanden

√
|ψ00 i = |0i, |ψ10 i = |1i, |ψ01 i = |+i = 21 2|0i+ 12 2|1i, |ψ11 i = |−i = 12 2|0i−
1
√
2 2|1i

2.1.3 Implicaties Quantum Cryptografie

Zoals uit de vorige paragrafen duidelijk is geworden levert het BB84 protocol
een quantummechanische oplossing voor het key-distributie probleem op dat the-
oretisch veilig is. Met de uitzondering dat er een hele kleine kans bestaat dat Eve
de juiste key weet te bemachtigen. Hoe groot deze kans is en hoe dit samenhangt
met de veiligheid van de key-distributie is verder toegelicht in paragraven 2.1.4 en
2.1.5.

Een van de voordelen van de quantum cryptografie is dat het encryptie voor lan-
gere perioden mogelijk maakt. Met klassieke cryptografie is het maximum voor
ge-encrypte data ongeveer 30 jaar terwijl quantum cryptografie informatie zou
kunnen beveiligen voor ongeveer 100 jaar [4]. Dit is gunstig voor bijvoorbeeld
de gezondheidszorg omdat zij tegenwoordig veel werken met elektronische sys-
temen om medische informatie van patienten op te slaan(in 2017 was het 85.9%
van doktoren die zo informatie opslaat [5]).

2.1.4 Invloed eavesdroper op key distributie

Zoals in paragraaf 2.1.1 aangetoond, is het onmogelijk om de key te achterhalen
uit de verzonden base sequentie. Wanneer je dus de key wilt achterhalen van
een boodschap die niet voor jou bedoeld is, dan zal je de key moeten afluisteren
(eavesdropping). De persoon die de key afluistert, zal in het vervolg van deze
paragraaf Eve worden genoemd.
Om de key te achterhalen, zal Eve de door Alice verstuurde fotonen moeten on-
derscheppen. Vervolgens moet zij met behulp van een base filter (figuur 2) de
spin oriëntatie achterhalen, om aan de bitwaarde te komen. Omdat zij niet weet
welke base de fotonen hebben die Alice verstuurt, zal ook Eve moeten gokken
(random kiezen) welke base zij moet gebruiken. Nadat Eve van een foton de po-
larisatiehoek gemeten heeft, zal zij een foton met de zelfde polarisatiehoek doors-
turen naar Bob. De reden dat zij dit doet, is omdat zij niet betrapt wilt worden en
wanneer Bob geen fotonen ontvangt, terwijl Alice ze wel verstuurt, dan weet Bob

6
dat er iets aan de hand is.
Omdat Eve haar Base random kiest, zal zij statistisch gezien in de helft van de
gevallen de verkeerde base kiezen. Wanneer zij de verkeerde base kiest is de kans
50% dat ze de verkeerde bit waarde afleest. Voor elk bit in de uiteindelijke key
van Eve is er dus een 25% kans dat deze de verkeerde bitwaarde heeft en een 75%
kans dat deze de goede bitwaarde heeft.
Omdat Eve de door haar gemeten fotonen doorstuurt naar Bob, zal ook Bob in de
helft van de gevallen een foton ontvangen met een andere base dan door Alice ver-
zonden. Ook voor elk bit in de key van Bob geldt dus, dat er een 25% kans is dat
deze de verkeerde bitwaarde heeft en een 75% kans dat deze de goede bitwaarde
heeft.
Om een goede key te verkrijgen, moeten alle bitwaardes in de verkregen bitwaarde
sequentie goed zijn. Omdat er bij aanwezigheid van Eve slechts een 75% kans is
voor elk bit om goed te zijn, geldt er:
3
Kans goede key = ( )L (3)
4
Hier is L de lengte van de verkregen key, na het verwijderen van de bitwaardes
waarbij Bob en Alice een andere base hebben gebruikt. Wanneer Alice bijvoor-
beeld 10 fotonen naar Bob verstuurt, terwijl Eve aanwezig is en er blijven uitein-
delijk 6 bits over in de uiteidenlijke key, dan is de kans voor zowel Eve als Bob
6
gelijk aan 34 = 0, 178 dat de door hen verkregen key juist is. Wanneer Bob na het
uitvoeren van het BB84 protocol niet op de juiste key komt, dan weet hij dat er
iets aan de hand is en dat er dus mogelijk een eavesdroper aanwezig is.

In de volgende paragraaf (2.1.5) zal dieper worden ingegaan op key veiligheid.

Er zal hier een formule worden afgeleid die het verband aangeeft tussen de vei-
ligheid van een key en het aantal verzonden fotonen [6].

2.1.5 Statistiek achter key veiligheid

Zoals in paragraaf 2.1.4 aangetoond, geldt er voor de kans dat Eve de key van
lengte L achterhaald:
3
Kans goede key = ( )L (4)
4
Echter valt er niet op voorhand te voorspellen wat de lengte van de uiteindelijke
key zal zijn. Om deze reden is er een vergelijking nodig die het verband geeft
tussen het aantal door Alice verzonden fotonen en de kans dat Eve de key goed
heeft.
Om een dergelijke vergelijking te verkrijgen, moet er eerst een vergelijking verkre-
gen worden, die het verband geeft tussen de kans op een key lengte L en het aantal

7
verzonden fotonen n. Om bijvoorbeeld de kans te bepalen op een lengte van L = 2,
na het versturen van 20 fotonen (n = 20), moet er eerst bepaald worden op hoeveel
manieren er een key van lengte 2 verkregen kan worden uit een sequentie van 20
bits. Voor het eerste bit in de key, geldt er, dat alle 20 bits in de sequentie mee
kunnen worden genomen in de key (er zijn dus 20 mogelijkheden). Het bit dat
nu is meegenomen kan niet meer worden gebruikt voor het tweede bit. Er zijn nu
dus nog 19 bits beschikbaar (er zijn dus 19 mogelijkheden). Je zou dus kunnen
denken dat er 20 · 19 = 380 manieren zijn om een key van lengte 2 te verkrijgen
na het versturen van 20 fotonen. Dit is echter niet het geval, want eerst bit 4 en
dan bit 13 pakken (uit de sequentie), is het zelfde als bit 13 en dan bit 4 pakken,
aangezien bit 4 altijd voor bit 13 komt in de key. Elke mogelijkheid is dus dubbel
geteld (L! keer geteld).
Daadwerkelijk zijn er dus 20 · 19/2 = 190 mogelijkheden.
Wanneer deze vergelijking in de algemene vorm (voor variable L en n) wordt
opgeschreven, dan geldt er:
n!
Aantal manieren(n, L) = (5)
(n − L)! · L!

Hier compenseert de L! in de noemer voor de dubbel tellingen, terwijl de term

n! 20!
(n−L)! equivalent is aan de 20 · 19 uit het voorbeeld, aangezien er geldt (20−2)! =
20!
18! = 20 · 19.
Nu er een formule verkregen is, die het aantal manieren geeft waarop een key
van lengte L kan worden verkregen, kan er eenvoudig een vergelijking worden
afgeleid die de kans op een key van lengte L als functie van het aantal verzonden
fotonen n geeft. Er geldt namelijk: kans L = totaal manieren L
aantal manieren . Dus er geldt:
n!
(n−L)!·L!
p(L, n) = n!
(6)
∑i=n
i=0 (n−i)!·i!

Hier is p(L, n) de kans op een key van lengte L, bij een verzonden aantal fotonen
van n. In paragraaf 2 is al aangetoond dat de kans op een goede key van lengte L
wordt gegeven door de vergelijking: Kans goede key = ( 34 )L
De vergelijking voor de kans op een goede key van lengte L bij een verzonden
aantal fotonen van n is dus:
3
g(L, n) = p(L, n) · ( )L (7)
4
In figuur 3 wordt het verband weergegeven, tussen de kans op een goede key
en de key lengte, na het versturen van 20 fotonen.

8
 Figure 3: Kans op goede key van lengte L, na het versturen van 20 fotonen.

De kans dat Eve de key goed heeft, is dus de som van de waardes van g(L, n)
van 0 tot en met n. De vergelijking die geldt is dus:
L=n
gkE(L, n) = ∑ g(L, n) (8)
L=0

Hier staat gkE voor goede key Eve.

In tabel 2 staat voor een aantal waardes van n weergegeven hoe groot de kans is
dat Eve de key correct achterhaald.

Table 2: Kans goede key Eve als functie van verzonden aantal Fotonen

Verzonden aantal fotonen n kans goede key Eve

1 0,875
5 0,513
10 0,263
50 1,26·10− 3
100 1,59·10− 6
500 1,01 ·10−29

Zoals in de tabel te zien is, is wanneer Alice 500 fotonen verstuurt, de kans dat
Eve de key goed heeft gelijk aan 1, 01 · 10−29 . Dit betekent statistisch gezien, dat
Eve 1029 pogingen nodig zou hebben, om één keer een key goed te hebben, bij een
n waarde van 500. Dit maakt de key practisch niet te achterhalen (onbreekbaar).
Zelfs niet met behulp van een quantum computer.

9
2.2 Theorie gerelateerd aan praktijkwerk en onderzoek
Het deeltjeskarakter van het foton en andere quantummechanische eigenschappen
zoals spin maken de quantumcrytografie mogelijk, zoals in het eerste theorie deel
uitgebreid is behandeld. Echter is het doel van het onderzoek om te achterhalen
of dezelfde principes ook kunnen worden aangetoond met centimergolven. In
deze paragraaf zullen de theorie achter centimetergolven en de theorie achter de
simulatie van de quantum cryptografie met centimetergolven worden behandelt.

2.2.1 Centimetergolven
Centimetergolven worden ook wel Super-high frequency (SHF) golven genoemd.
Het zijn electromagnetische golven met een golflengte van 10 tot 100 mm. Als
er wordt gesproken over een centimetergolf, wordt er gesproken over een grote
bundel fotonen. De quantummechanische principes gelden nog steeds. De reden
dat er gesproken wordt over een simulatie is omdat er geen gebruik wordt gemaakt
van ’single foton’ detectoren. Maar in principe zou echte quantumcryptografie
mogelijk moeten zijn met centimetergolven.

2.2.2 Simulatie Quantum Cryptografie

Het principe van het BB84 protocol is als volgt samen te vatten:
Meting spintoestand door Eve → Probleem Keygeneratie
Dit principe geldt dankzij het meetprobleem in de Quantummechanica (zoals
eerder in de theorie toegelicht). Het probleem in de keygeneratie tussen Alice
en Bob maakt het mogelijk om te achterhalen dat er een Eavesdropper aanwezig
is. Dit is het principe dat gesimuleerd moet worden.

Er zijn verschillende manieren om dit principe te simuleren. De manier waarop

het in dit onderzoek is gedaan is door de spintoestanden van de enkele fotonen
te simuleren met de polarisatietoestand van de golf. De manier waarop deze po-
larisatiehoeken corresponderen met bitwaarden is in de vorige theorieparagraaf
toegelicht. De centimetergolven waarmee de simulatie wordt uitgevoerd worden
geproduceerd met zogenaamde Transmitters en kunnen worden gedetecteerd met
zogenaamde Receivers. De golven die uit de transmitters komen zijn intern gepo-
lariseerd en de receivers zullen de golf alleen detecteren als deze in de juiste ori-
entatie staan ingesteld. Ofewel, de polarisatietoestand kan worden aangepast door
de orientatie van de transmitters en receivers te veranderen.

In plaats van het veranderen van de orientatie van de transmitters en receivers zijn
er twee transmitters en receivers gebruikt die elk in een andere orientatie staan.

10
3 Methode
Er zijn twee manieren gebruikt om de in paragraaf 2.1.5 beschreven statistiek te
toetsen. De eerste manier waarop dit getoetst is, is met behulp van een Python
simulatie. Deze methode wordt toegelicht in paragraaf 3.1 Python simulatie.
De tweede manier waarop de theorie getoetst is, is met behulp van een geau-
tomatiseerde centimeter-golven opstelling. Deze methode wordt beschreven in
paragraaf 3,2 Geautomatiseerde centimeter golven opstelling.

3.1 Python simulatie

Om de in paragraaf 2.1.5 beschreven statistiek te toetsen, is er met behulp van
Python een simulatie gedaan van het ’Alice, Bob en Eve’ experiment. Het belan-
grijkste doel van deze simulatie was, het valideren van vergelijkingen 6, 7 en 8.
Hoe de geschreven Python code werkt, wordt in deze paragraaf uitgelegd aan de
hand van block diagrams. De gehele Python code is terug te vinden in bijlage B .

Om deze simulatie te doen, is er als eerst, binnen Python een functie gedefinieerd
die het BB84 protocol simuleert met Eve aanwezig. Een flow chart van de geschreven
Pyton code is te zien in figuur 5. Deze functie heeft de gewenste n waarde (het
aantal fotonen dat Alice verstuurt) als input (blok 1). Vervolgens wordt voor Alice
bepaald welke base zij zal gebruiken. Ook worden de spin richtingen en de, bi-
jbehorende, bit waarde van de door haar verzonden fotonen bepaald. Voor Eve en
Bob wordt ook bepaald welke base zij zullen gebruiken (blok 2). De base en spin
richtingen worden bepaald met een random number generator. Hoe een dergelijke
bepaling van (bijvoorbeeld) de base gedaan is met Python, is te zien in figuur 4.

Figure 4: Bepalen base met random number generator.

Als eerste is er een lege lijst aangemaakt, genaamd Bases Alice. Zo lang het aantal
elementen in deze lijst kleiner is dan het totaal aantal fotonen dat zij zal versturen,
wordt het deel code dat binnen de while loop staat, herhaaldelijk uitgevoerd. In
de eerste regel code in de while loop, wordt er een numerieke waarde aan de vari-
abele genaamd ’Value’ gehangen. Deze numerieke waarde wordt bepaald met een
random number generator. De functie random.random() levert namelijk een ran-
dom getal tussen de 0 en de 1. In de tweede regel code binnen de while loop,
worden voor waardes van ’Value’ groter dan 0, 5, een waarde van 0,5 aan de lijst

11
Bases Alice toegevoegd, en voor waardes van ’Value’ kleiner dan 0,5, wordt een
waarde van 0 aan de lijst Bases Alice toegevoegd. Een 0 correspondeert hier met
een bases Z en een 0,5 correspondeert met een bases X.

Figure 5: Flow chart van Pyton code die het BB84 protecol uitvoert terwijl Eve aanwezig is.

Nadat voor zowel Alice, Bob als Eve de bases sequentie bekend zijn, worden de
base sequenties van Alice en Eve met elkaar vergeleken (blok 3). Wanneer zij
voor een foton dezelfde base gebruiken, dan zal Eve de spin richting (en dus de
bit waarde) van het foton overnemen. Wanneer zij verschillende base gebruiken,
dan wordt, voor Eve, de spin oriëntatie (en dus de bit waarde) bepaald met een

12
random number generator.
In blok 4, wordt hetzelfde gedaan als in blok 3, alleen dan met Eve en Bob in
plaats van Alice en Eve.
Op het moment dat, voor Alice, Bob en Eve, de base, spin en bit-waarde se-
quenties compleet zijn. Worden de base sequenties van Alice en Bob met elkaar
vergeleken (blok 5). Wanneer de base niet overeenkomen, worden voor Alice,
Bob en Eve, de bit waarde horende bij dit foton verwijderd uit de bit waarde se-
quentie.
Na het verwijderen van deze bit waardes, print de functie de keys van Alice, Bob
en Eve (blok 6). En kan er dus gekeken worden of deze overeenkomen.

Om de in paragraaf 2.1.5 beschreven statistiek te toetsen, moet het hier boven

beschreven protocol vele malen worden uitgevoerd voor een vaste waarde van n.
Om dit te doen is er nog een fucntie gedefinieerd, waar de hier beschreven func-
tie is ingestopt. Hoe deze code werkt, wordt uitgelegd aan de hand van een flow
chart, te zien in figuur 6.

Figure 6: Flow chart van Pyton code die de simulatie uitvoert.

Zoals te zien in blok 1, heeft deze code twee inputs. Dit zijn de waarde van n, en
de tijd die de simulatie maximaal mag duren. Aan de hand van deze n waarde en
deze maximale tijd, wordt er in blok 2 bepaald, hoe vaak het in het begin van deze
paragraaf beschreven protocol uitgevoerd dient te worden (x keer).

13
In blok 3 wordt het protocol x keer uitgevoerd.
Na het uitvoeren van de simulatie, geeft de code de belangrijkste resultaten (gegevens)
van de simulatie als output. Deze resultaten bevatten onder andere: het aantal keer
dat de simulatie is uitgevoerd, het aantal verkregen keys per lengte L voor zowel
Eve als Bob en het aantal correct verkregen keys per lengte L voor zowel Eve als
Bob.

Om de in paragraaf 2.1.5 beschreven statistiek te toetsen, is de hierboven beschreven

simulatie uitgevoerd. Deze simulatie had een maximum tijd van vijf uur, voor een
n waarde van 20. De resultaten van deze simulatie zijn terug te vinden in paragraaf
4.1 van het resultaten hoofdstuk.

3.2 Geautomatiseerde Centimetergolven Opstelling

Om het principe van het BB84 protocol in de Quantum Crytografie (zoals in para-
graaf 2.2 beschreven) te kunnen simuleren, is er gebruik gemaakt van een Arduino
microcontroller, de Arduino IDE die draait op een aangepaste vorm van C-code,
en Python. Hoe de elektrische netwerken in elkaar zitten, hoe de code werkt en
hoe het totale systeem werkt wordt in deze paragraaf besproken. De gebruikte
codes staan in bijlage A.

Om de verschillende polarisatie- of spintoestanden te simuleren is gebruikt gemaakt

van twee Transmitters die elk corresponderen met een base (van Alice en dan van
Eve). En er is gebruik gemaakt van twee Receivers die ook elk corresponderen
met een base (eerst van Eve en dan van Bob).

Het is ook belangrijk om te vermelden hoe de Transmitters en Receivers geau-

tomatiseerd zijn. De Transmitters krijgen een oscillerend elektrisch signaal gedurende
een specifieke hoeveelheid tijd. Een korte ’pulse’ geeft bitwaarde 0 aan en een
lange ’pulse’ geeft bitwaarde 1 aan. Dit signaal wordt gegenereerd met behulp
van een Arduino, een weerstand, en een diode om de grootte van de spanning te
beperken (zie figuur 7).

14
Figure 7: Elektrisch schema om de Transmitters een oscillerend eletktrisch signaal te geven met
diode om de spanning te beperken beneden de 1 V. De (+) en (-) in de figuur geven de terminals
van de Transmitter aan. De letter D geeft een arbitraire gekozen digitale poort van de Arduino aan.

Tijdens het uitvoeren van de simulatie was het ook belangrijk te weten wat er
werd gemeten door de Receivers. Daarom werden deze automatisch uitgelezen.
Dit werd eenvoudig gedaan met behulp van een weerstand en de analoge poorten
van de Arduino (zie figuur 8).

Figure 8: Elektrisch schema om de Receivers uit te lezen. Waarin de (+) en (-) in de figuur de
terminals van de Receiver aangeven. De letter A geeft een arbitraire gekozen analoge poort van de
Arduino aan.

Het is belangrijk om te vermelden dat het elektisch schema van figuur 8 inclusief
de code van de Arduino geen spanningsmeter vormen. Een Arduino is op zichzelf
niet zeer geschikt voor het nauwkeurig meten van spanningen. Het meten van
spanningen was echter ook onnodig in dit geval. Aangezien er alleen onderscheid
gemaakt moest worden tussen wel of geen signaal gemeten en de lengte van het
signaal. Het gemeten signaal is dimensieloos, is een geheel getal tussen de 0 en

15
1023, en wordt gedefinieerd door de analogRead functie van de Arduino [7].

Het eerste gedeelte van de simulatie vindt plaats in Python en is identiek aan
het protocol dat is toegelicht in paragraaf 3.1. Nadat de basen voor Alice, Bob,
en Eve zijn bepaald, zowel als de bits van Alice, wordt er een pulse verstuurd
naar de Transmitter met de corresponderende base van Alice. Het resultaat is dat
deze Transmitter een signaal verstuurt. De base van Eve bepaald in dit geval bij
welke Receiver er wordt gemeten. Komt haar base overeen met die van Alice, dan
meet zij een signaal en de bitwaarde die Alice verstuurd bepaalt de langte van het
signaal. Heeft zij een andere base dan Alice, dan ontvangt zij geen signaal. Zoals
in paragraag 3.1 is toegelicht: Als zij een signaal meet, neemt zij de gemeten bit-
waarde over. Meet zij geen signaal, dan bepaalt ze haar bitwaarde met een random
number generator. Nu Eve haar bitwaarden heeft wordt hetzelfde proces herhaalt
tussen Eve en Bob.

Het is ook van belang om te vermelden hoe er in de opstelling onderscheid werd

gemaakt tussen de verschillende toestanden van het gemeten signaal. In de Python
code wordt een aantal keer een pulse verstuurd naar de verschillende Transmit-
ters, vervolgens worden de Receivers met de Arduino uitgelezen en wordt deze
data verstuurd naar Python. Uiteindelijk zijn dan de ’boundaries’ of grenzen
van de lange en korte signalen bekend. Er wordt ook gecontroleerd of er geen
overlap bestaat tussen de lange en korte signalen om goed onderscheid te kunnen
maken. Als er vervolgens in het experiment een signaal wordt ontvangen, wordt
met Python gecontroleerd binnen welke range het signaal zich bevind. Voorbeeld:
[10, 100] stellen een kort signaal voor en [500, 1000] een lang signaal. Als een
detector (Receiver) niets hoort te meten (door verschillende basen) dan wordt er
in de code een waarde van -1 geconstateerd en is er dus geen bitwaarde gemeten.
Oftewel: De detector gaat niet af.

De opstelling met de Transmitters en Receivers was zo opgezet dat het bijna on-
mogelijk zou moeten zijn dat perongeluk beide Receivers een signaal ontvangen
van dezelfde Transmitter. Het moet namelijk niet zo zijn dat de verkeerde dectec-
tor ’af gaat’. Zelfs met de opbouw van de opstelling waren er nog enkele proble-
men die verholpen waren door de ’thresholds’ van de Receivers goed in te stellen.
Dit bleek een moeilijk proces dat constant opnieuw gedaan moest worden omdat
de thresholds niet te hoog konden zijn omdat je dan geen onderscheid kon maken
tussen ruis en het signaal. En niet te laag waardoor de verkeerde Receiver een sig-
naal kan ontvangen. Ook de afstand tussen de componenten in de opstelling had
invloed op de ideale waarden van deze thresholds. Dit werd dus voor elke met-
ing opnieuw ingesteld. De thresholds corresponderen met een minimale spanning
waarbij de Arduino een signaal als meting registreert.

16
4 Resultaten
4.1 Resultaten Python simulatie
In deze paragraaf worden de resultaten van de, in paragraaf 3.1 beschreven simu-
latie getoond. De maximum tijd van de simulatie bedroeg 5 uur, bij een n-waarde
van 20.
Tijdens deze simulatie, is het in figuur 5 beschreven protocol, 88 677 619 keer
uitgevoerd. Op basis van de in paragraaf 2.1.5 beschreven statistiek, mogen er
6 137 268 correcte keys voor zowel Eve als Bob worden verwacht. Eve kwam
uiteindelijk op 6 137 533 correcte keys, en Bob kwam op 6 135 318 correcte keys
uit. Zowel Eve als Bob, zitten wat aantal correcte keys betreft, binnen 0,05% van
de verwachte waarde. Dit duidt op een sterke overeenstemming tussen de sim-
ulatie en de in paragraaf 2.1.5 beschreven statistiek, wat aantoont dat formule 8
geldig is.
Naast het valideren van formule 8, was een belangrijk doel van de simulatie, het
valideren van formules 6 en 7. Om formule 6 te valideren, is er een lijn geplot van
het aantal verwachte keys per lengte (op basis van formule 6). In dit figuur is ook
het daadwerkelijk aantal keys per lengte geplot. De resultaten van deze plot zijn
te zien in figuur 9.

Figure 9: Verwacht en verkregen aantal keys per lengte.

Zoals te zien, in het figuur, is er een sterke overeenkomst tussen de meetpunten

(rode bolletjes) en de theoretische lijn (groen). Dit toont aan dat formule 6 geldig
is.

17
Een zelfde soort plot, is gemaakt om formule 7 te valideren. In dit figuur is het
aantal correcte keys, per lengte, dat op basis van formule 7 mag worden verwacht,
geplot. Ook zijn het aantal verkregen correcte keys per lengte, voor zowel, Eve
als Bob geplot.

Figure 10: Verwacht en verkregen aantal correcte keys per lengte.

Zoals te zien in het figuur, is er een sterke overeenkomst tussen het aantal correcte
keys dat mag worden verwacht (uit de theorie) en het aantal correcte keys dat door
zowel Eve als Bob is verkregen. Hier mee is aangetoond, dat ook formule 7 geldig
is.

Er kan dus geconcludeerd worden, dat de in paragraaf 2.1.5 beschreven statistiek,

de statistiek achter key veiligheid correct beschrijft.

4.2 Resultaten Simulatie met Centimetergolven

In deze paragraaf worden de resultaten van de in paragraaf 3.2 beschreven simu-
latie en experiment getoond. De analyse is analoog aan dat in paragraaf 4.1.
De maximumtijd voor deze simulatie bedroeg 30 minuten, bij een n-waarde van
3. Het protocol is bij deze simulatie/meting 109 keer uitgevoerd. Het verwachtte
aantal correcte keys voor zowel Eve als Bob is 73. Eve kwam uit op 70 correct
keys (4% verschil) en Bob op op 68 correct keys (7% verschil).
Om formule 6 te valideren is het aantal keys per lengte uitgezet tegen de keylengte

18
en vergeleken met de verwachte waardes uit de theorie. Het resultaat is te zien in
figuur 11.

Figure 11: Verwacht en verkregen aantal keys per lengte bij de meting met centimetergolven.

Zoals in de figuur is te zien, overlappen de blauwe en oranje stippen (het verwachtte

aantal keys en het daadwerkelijke aantal) of liggen ze dicht bij elkaar. De grootste
uitwijking van de verwachting bevindt zich bij keylengte 0. De uitwijking is daar
3,625 keys. Dat is een uitwijking van 26,6% van de verwachte waarde. Dit kan
verklaard worden door een korte meettijd. De conclusie is dat het verband van
formule 6 zeker zichtbaar is maar nog beter bevestigt zou kunnen worden bij een
langere meettijd.
Om formule 7 te valideren is het aantal correcte keys uitgezet tegen de keylengte
en vergeleken met de verwachte waardes uit de theorie. Zie figuur 12.

19
Figure 12: Verwacht en verkregen aantal correcte keys per lengte bij de meting met centimeter-
golven.

Er is er een sterke overeenkomst tussen het aantal verwachte correcte keys en het
aantal correcte keys dat door zowel Eve als Bob is verkregen. Zoals besproken is
de afwijking van de verwachte waarde voor Eve gelijk aan 4% en voor Bob gelijk
aan 7%. Ook hier geldt weer dat een langere meetperiode waarschijnlijk zal bij-
dragen bij een betere besvestiging.

Er kan dus geconcludeerd worden dat de statistiek, die in het theorie hoofdstuk
staat beschreven, klopt. En dat dit dus ook kan worden aangetoond met centime-
tergolven. Met de kanttekening dat langere meetperioden waarschijnlijk tot een
sterkere bevestiging zullen leiden.

20
5 Conclusie
Doel van dit onderzoek was, om de statistiek die de Quantum Cryptografie beschri-
jft, te valideren met zowel een Python simulatie als met een geautomatiseerde
centimeter-golven opstelling.
Wat betreft de Python simulatie, kan er geconcludeerd worden dat deze zeer sterk
in overeenstemming is met de statistiek die de quantum cryptografie beschrijft.
Zo is er een simulatie uitgevoerd, waarbij 88 677 619 keer, een 20 fotonen lange
key werd verzonden. Op basis van deze gegevens mochten er voor zowel Bob
als Eve 6 137 268 correcte keys worden verwacht. Zowel Bob als Eve kwamen
binnen de 0,05% van deze verwachte waarde. Hieruit kan geconcludeerd worden,
dat de statistiek die het BB84 protocol beschrijft correct is, en dus dat formules 6,
7 en 8 geldig zijn.
Ook in de data verkregen met de geautomatiseerde centimeter opstelling, is er
overeenstemming tussen de statistiek en de resultaten. Zo is het protocol met de
geautomatiseerde opstelling 109 keer uitgevoerd, bij een key lengte van 3. Op ba-
sis van deze informatie, mochten er 73 correcte keys verwacht worden. Eve kwam
uit op 70 (4% afwijking) en Bob op 68 (7% afwijking) correcte keys. Het is zeer
aannemelijk dat de afwijkingen kleiner zouden zijn, wanneer er meer keys zouden
zijn verstuurd. In de grafieken, die de verkregen data vergelijken met de verwachte
waardes (op basis van de statistiek) is sterke overeenstemming te zien. Op basis
van de data verkregen met de geautomatiseerde centimeter golven opstelling, kan
er dus geconcludeerd worden dat de formules 6, 7 en 8 geldig zijn.

21
6 Aanbeveling
Voor verder laboratorium werk met centimeter golven bij de Haagse Hogeschool,
wordt er aangeraden om extra elektrische componenten bij te bestellen. Het bi-
jbestellen van extra componenten, leidt tot een grotere flexibiliteit wat betreft de
mogelijkheden van wat er gedaan kan worden met centimetergolven. Met name
wordt er aangeraden, om elektrische oscilatoren te bestellen. Om centimetergol-
ven te kunnen genereren is er een hoog frequent AC signaal nodig. Met behulp
van deze oscilatoren, kan er een hoog frequente AC stroom gegenereerd worden.
Een website, waar deze oscilatoren eventueel besteld zouden kunnen worden is te
vinden bij kopje [8] in de bibliografie. Er wordt aangeraden, om van deze website
een oscilator te bestellen met een zo hoog mogelijke frequentie. Een hoge fre-
quentie leidt tot een korte golflengte, wat het lab werk vereenvoudigt.
Deze AC stroom, moet uiteraard wel worden omgezet in EM golven. Om dit te
doen, moet de stroom door een stuk metaal (een geleider) worden gestuurd. Wat
de beste manier is om dit te doen en hoe (eventueel) een ontvanger (van EM gol-
ven) gemaakt kan worden, dient nader te worden onderzocht.

22
 7 bibliography
References
[1] “Polarisatie richtingen,” [Video] ,https://www.youtube.com/watch?v=uiiaAJ3c6dMt=1s,
Accessed 10-1-2021.

[2] “Base oriëntaties,” [Afbeelding] ,http://reports.ias.ac.in/report/18088/study-

of-bb84-qkd-protocol-modifications-and-attacks, Accessed 10-1-2021.

[3] “Security quantum cryptography,” [Artikel], C. Branciard, N. Gisin, B. Kraus

and V. Scarani, ”Security of two quantum cryptography protocols using the
same four qubit states,” Physical Review A., no. 72, 2005.

[4] “The case for quantum key distribution,” [Online],

https://link.springer.com/chapter/10.1007%2F978-3-642-11731-
23 5, Accessed12 − 1 − 2021.

[5] “Statistiek van de cdc over medische gegevens,” [Online], www.cdc.gov, Ac-
cessed 12-1-2021.

[6] “Kans goede key eve,” [PowerPoint presentatie]

,https://pt.slideshare.net/converse2006/bb84-0718/5?smtNoRedir=1, Accessed
10-1-2021.

[7] “analogread,” [Online], https://www.arduino.cc/reference/en/language/functions/analog-

io/analogread/, Accessed 12-1-2021.

[8] “Mini circuits,” [Online] ,https://www.minicircuits.com/WebStore/dashboard

.html?model=ZX95-2705-S%2B, Accessed 10-1-2021.

23
 A Code voor simulatie met centimetergolven (§3.2)
Code voor de simulatie (Python):

1 import serial
2 from serial import Serial
3 import matplotlib.pyplot as plt
4 import atexit
5 import threading
6 import time
7 import random
8 import numpy as np
9 import sys
10

11

12 plt.ion()
13 cnt=0
14

15 simulation_results = []
16 serialArduino = serial.Serial('com6', 9600)
17

18 # In deze functie worden de grenzen bepaald waarmee onderscheid gemaakt kan

19 # worden tussen lange (bitwaarde 1) en korte (bitwaarde 0) pulsen.
20 def determine_boundaries():
21 short = []
22 long = []
23 short1 = []
24 long1 = []
25 for i in range(0, 5):
26 short.append(pulse(0, 0, 0))
27 short.append(pulse(1, 1, 0))
28 long.append(pulse(0, 0, 1))
29 long.append(pulse(1, 1, 1))
30

31 if(max(short) < min(long)):

32 return [[min(short) / 2, max(short) + (min(long) - max(short)) / 2],
33 [max(short) + (min(long) - max(short)) / 2, max(long) * 2]]
34 elif(min(short) > max(short) or min(long) > max(long)):
35 print('Error: Boundaries reversed!')
36 sys.exit()

24
37 else:
38 print('Error: Boundaries overlap!')
39 sys.exit()
40

41 # Met deze functie worden via de Arduino 'pulses' verstuurd naar de

42 # transmitters. Ook worden de receivers uitgelezen.
43 def pulse(basis1, basis2, bitwaarde):
44

45 if(basis1 != basis2):
46 if(basis1 == 0):
47 if(bitwaarde == 0):
48 serialArduino.write(b'pulse1short')
49 readArduino()
50 return -1 # Buiten grenzen
51 elif(bitwaarde == 1):
52 serialArduino.write(b'pulse1long')
53 readArduino()
54 return -1 # Buiten grenzen
55 elif(basis1 == 1):
56 if(bitwaarde == 0):
57 serialArduino.write(b'pulse2short')
58 readArduino()
59 return -1 # Buiten grenzen
60 elif(bitwaarde == 1):
61 serialArduino.write(b'pulse2long')
62 readArduino()
63 return -1 # Buiten grenzen
64

65 elif(basis1 == basis2):
66 if(basis1 == 0):
67 if(bitwaarde == 0):
68 serialArduino.write(b'pulse1short')
69 return readArduino()
70 elif(bitwaarde == 1):
71 serialArduino.write(b'pulse1long')
72 return readArduino()
73 elif(basis1 == 1):
74 if(bitwaarde == 0):
75 serialArduino.write(b'pulse2short')
76 return readArduino()

25
 77 elif(bitwaarde == 1):
78 serialArduino.write(b'pulse2long')
79 return readArduino()
80

81 def doAtExit():
82 serialArduino.close()
83 print("Close serial")
84 print("serialArduino.isOpen() = " + str(serialArduino.isOpen()))
85

86 atexit.register(doAtExit)
87

88 print("serialArduino.isOpen() = " + str(serialArduino.isOpen()))

89

90 def readArduino():
91 valueRead = serialArduino.readline(500)
92 valueInInt = int(valueRead)
93 return(valueInInt)
94

95 'Turns a list into an integer'

96 def list_to_int(List):
97 a = 0
98 b = len(List)
99 for i in List:
100 a = a+i*10**(b-1)
101 b = b-1
102 return(a)
103

104 # Met deze functie wordt het BB84 protocol eenmaal uitgevoerd.
105 def run_simulation(number_of_photons, boundaries):
106 bases_alice = []
107 bases_bob = []
108 new_bases_alice = []
109 new_bases_bob = []
110 new_bases_eve = []
111 bits_alice = []
112 bits_eve = []
113 bits_bob = []
114

115 key_length = 0
116 correctness_eve = 0
117 correctness_bob = 0

26
118

119 key_alice = 0
120 key_bob = 0
121 key_eve = 0
122

123

124

125 while len(bases_alice)<number_of_photons:

126 bases_alice.append(int(0.5+random.random()))
127 bases_bob.append(int(0.5+random.random()))
128

129

130 for i in range(0,len(bases_alice)):

131 if bases_alice[i] == bases_bob[i]:
132 new_bases_alice.append(bases_alice[i])
133 new_bases_bob.append(bases_bob[i])
134

135 while len(new_bases_eve)<len(new_bases_alice):

136 new_bases_eve.append(int(0.5+random.random()))
137

138 print('new_bases_alice: {}'.format(new_bases_alice))

139 print('new_bases_bob: {}'.format(new_bases_bob))
140 print('new_bases_eve: {}'.format(new_bases_eve))
141

142

143 while len(bits_alice)<len(new_bases_alice):

144 bits_alice.append(int(0.5+random.random()))
145

146 print('bits_alice: {}'.format(bits_alice))

147

148 for i in range(0, len(new_bases_alice)):

149 print('test')
150

151 measured_value_eve = pulse(int(new_bases_alice[i]),

152 int(new_bases_eve[i]), int(bits_alice[i]))
153 print('measured_value_eve: {}'.format(measured_value_eve))
154

155 if(int(measured_value_eve) > int(boundaries[0][0]) and

156 int(measured_value_eve) < int(boundaries[0][1])):
157 print('alice naar eve: ontvangen Receiver 1')

27
158 bits_eve.append(0)
159 elif(int(measured_value_eve) > int(boundaries[1][0]) and
160 int(measured_value_eve) < int(boundaries[1][1])):
161 print('alice naar eve: ontvangen Receiver 2')
162 bits_eve.append(1)
163 else:
164 print('alice naar eve: random')
165 bits_eve.append(int(0.5+random.random()))
166 time.sleep(2)
167 print('bits_eve: {}'.format(bits_eve))
168

169 for i in range(0, len(new_bases_eve)):

170

171 measured_value_bob = pulse(new_bases_eve[i], new_bases_bob[i], bits_eve[i

172

173 if(int(measured_value_bob) >= int(boundaries[0][0]) and

174 int(measured_value_bob) <= int(boundaries[0][1])):
175 print('eve naar bob: ontvangen Receiver 1')
176 bits_bob.append(0)
177 elif(int(measured_value_bob) >= int(boundaries[1][0]) and
178 int(measured_value_bob) <= int(boundaries[1][1])):
179 print('eve naar bob: ontvangen Receiver 2')
180 bits_bob.append(1)
181 else:
182 print('eve naar bob: random')
183 bits_bob.append(int(0.5+random.random()))
184 time.sleep(2)
185 print('bits_bob: {}'.format(bits_bob))
186

187

188

189 '+1 voor alle waardes in bit lijsten'

190 bits_alice = [i + 1 for i in bits_alice]
191 bits_eve = [i + 1 for i in bits_eve]
192 bits_bob = [i + 1 for i in bits_bob]
193

194 key_alice = list_to_int(bits_alice)

195 print('key_alice: {}'.format(key_alice))
196

197 key_eve = list_to_int(bits_eve)

198 print('key_eve: {}'.format(key_eve))

28
199

200 key_bob = list_to_int(bits_bob)

201 print('key_bob: {}'.format(key_bob))
202

203 key_length = len(bits_alice)

204 if int(key_alice) == int(key_eve):
205 correctness_eve = 1
206 else:
207 correctness_eve = 0
208

209 if int(key_alice) == int(key_bob):

210 correctness_bob = 1
211 else:
212 correctness_bob = 0
213

214 print('correctness_eve: {}'.format(correctness_eve))

215 print('correctness_bob: {}'.format(correctness_bob))
216

217 return [key_length, correctness_eve, correctness_bob]

218

219 # Met deze functie wordt een simulatie gestart. Het aantal fotonen,
220 # de zogenaamde n-waarde, en de maximale runtime van de simulatie worden
221 # ingevoerd. De functie geeft de resultaten van de simulatie terug.
222 def simulation(number_of_photons, run_time):
223 global simulation_results
224 boundaries = determine_boundaries()
225 print(boundaries)
226 start_time = time.time()
227 while((time.time() - start_time) < run_time):
228 simulation_results.append(run_simulation(number_of_photons,
229 boundaries))
230 return simulation_results

Code voor de simulatie (Arduino-C):

1 #include "Wire.h" // imports the wire library for talking over I2C
2

4 String command;

29
 5 unsigned int transmitters[] = {2, 3, 5};
6 int numberOfMeasurements = 0;
7 int SensorValueSum = 0;
8

9 unsigned int t1 = 0;
10 unsigned int t2 = 0;
11 unsigned int a = 0;
12

13

14 // Hiermee wordt een 'pulse' verstuurd naar de Transmitters. Deze 'pulse'

15 // wordt ook aangemaakt hier met een oscillerend elekrisch signaal.
16 void sendPulse(unsigned int transmitterId, unsigned long durationPulse) {
17

18 unsigned long startTime = millis();

19 unsigned long endTime = millis();
20 int sensor;
21

22 while((endTime - startTime) < durationPulse * 1000) {

23 digitalWrite(transmitters[transmitterId], HIGH);
24 readSignal();
25 endTime = millis();
26 delay(1);
27 digitalWrite(transmitters[transmitterId], LOW);
28 readSignal();
29 delay(1);
30 }
31

32 Serial.println(SensorValueSum);
33 SensorValueSum = 0;
34 endTime = millis();
35 }
36

37 // Hiermee worden de Receivers uitgelezen.

38 void readSignal() {
39 float voltage;
40 unsigned long startTime = millis();
41 unsigned long measuredPulse = 0;
42

43 // De getallen 700 en 200 hier zijn bijna altijd anders.

44 // Dit zijn de thresholds die afhangen van afstand,
45 // ruis, en nog meer factoren.

30
46 if(analogRead(A0) > 700) SensorValueSum += 1;
47 if(analogRead(A5) > 200) SensorValueSum += 1;
48 //Serial.println(sensorValue);
49 //voltage = sensorValue * (5.0 / 1023.0);
50 //Serial.println(voltage);
51 startTime = millis();
52 }
53

54 void setup() {
55 Serial.begin(9600); //turn on serial monitor
56 pinMode(2, OUTPUT);
57 pinMode(3, OUTPUT);
58 pinMode(A0, INPUT);
59 pinMode(A5, INPUT);
60 }
61

62 void loop() {
63 while(Serial.available()==0);
64 while(Serial.available()){
65 delay(10);
66 char c=Serial.read();
67 if(c=='#' ){break;}
68 command+=c;
69 }
70

71 if(command=="pulse1short") {
72 sendPulse(0, 1);
73 } else if(command=="pulse1long") {
74 sendPulse(0, 5);
75 }
76

77 if(command=="pulse2short") {
78 sendPulse(1, 1);
79 } else if(command=="pulse2long") {
80 sendPulse(1, 5);
81 }
82

83 command="";
84 }

31
 B Code Python simmulatie (§3.1)

1 'Simmulatie ALice Bob en Eve met variabele key lengte. Deze simulatie wordt\
2 gedaan om de onderliggende statistiek te bevestigen danwel onderuit te halen..'
3

4 'Input simulatei'
5 Te_versturen_bits = 2
6 Max_tijd = 30
7 import time
8

10 def SimulatieVariabeleKeyLengte(Verzonden_aantal_fotonen\
11 ,aantal_goede_verlangt):
12 lengtes = range(0,Verzonden_aantal_fotonen + 1)
13 'Hieronder wordt de functie factorial gedefinieerd'
14 def factorial(number):
15 if int(number) != number:
16 return('This function does not yet work for non integers')
17 if number<0:
18 return('Dit is wiskundig onmogelijk')
19 if number == 0:
20 return(1)
21 a = range(1,number+1)
22 b = 1
23 for i in a:
24 b = b*i
25 return(b)
26

27 'Hier wordt de noemer gecreerd van de functie kans op lengte p(x)\

28 (zie schrift)'
29 noemer = 0
30 for i in range(0,Verzonden_aantal_fotonen + 1):
31 noemer = noemer + (factorial(Verzonden_aantal_fotonen))\
32 /(factorial(Verzonden_aantal_fotonen-i)*factorial(i))
33

34 'Hier wordt per key lengte bepaald hoe groot de kans op deze lengte is'
35 Kans_op_lengte_X = [] #Lijst met per positie de kans op de bijbehorende
36 #key lengte
37 for i in range(0,Verzonden_aantal_fotonen + 1):

32
38 Kans_op_lengte_X.append(((factorial(Verzonden_aantal_fotonen))\
39 /(factorial(Verzonden_aantal_fotonen-i)*factorial(i)))/noemer)
40

41 Kans_op_goede_key_van_lengte = []
42 for i in range(0,len(Kans_op_lengte_X)):
43 Kans_op_goede_key_van_lengte.append(Kans_op_lengte_X[i]*((3/4)**i))
44 kans_goede_key_Eve = sum(Kans_op_goede_key_van_lengte)
45

46 'Hier wordt bepaald hoe vaak het protecol uitgevoerd moet worden om op het\
47 verlangde aantal goede simulaties te komen'
48 Aantal_keer_protecol_uitvoeren = int(aantal_goede_verlangt\
49 /kans_goede_key_Eve)
50

51

52 Verwacht_aantal_keys_per_lengte = []
53 for i in range(0,len(Kans_op_lengte_X)):
54 Verwacht_aantal_keys_per_lengte.append(Kans_op_lengte_X[i]*\
55 Aantal_keer_protecol_uitvoeren)
56 'Functie Alice Bob en Eve variabele key lengte'
57 def Alice_Bob_en_Eve(Verzonden_fotonen):
58 import random
59

60 'Benodigde functies'
61 def ListToInt(List):
62 if len(List) == 0:
63 return([])
64 a = 0
65 b = len(List)
66 for i in List:
67 a = a+i*10**(b-1)
68 b = b-1
69 return(a)
70

71

72 N_photons = Verzonden_fotonen
73

74 Bases_Alice = [] #Een rechte bases krijgt de waarde 0 en een schuine 0.

75 Spin_Alice = []
76 Bit_Value_Alice = []
77

33
 78 'Hieronder in while loop worden de basesen, spin waardes en bit waardes van
79 'Alice bepaald.'
80

81 while len(Bases_Alice)<N_photons:
82 Value = random.random()
83 Bases_Alice.append(int(0.5+Value)/2)
84

85 if Bases_Alice[-1] < 0.25:

86 if random.random() < 0.5:
87 Spin_Alice.append(0)
88 Bit_Value_Alice.append(0)
89 else:
90 Spin_Alice.append(90)
91 Bit_Value_Alice.append(1)
92

93 if Bases_Alice[-1] > 0.25:

94 if random.random() < 0.5:
95 Spin_Alice.append(-45)
96 Bit_Value_Alice.append(0)
97 else:
98 Spin_Alice.append(45)
99 Bit_Value_Alice.append(1)
100

101 'Hieronder worden de basesen van Bob bepaald'

102 Bases_Bob = []
103 while len(Bases_Bob)<N_photons:
104 Value = random.random()
105 Bases_Bob.append(int(0.5+Value)/2)
106

107 'Hieronder worden de basesen van Eve bepaald'

108 Bases_Eve = []
109 while len(Bases_Eve) < N_photons:
110 Value = random.random()
111 Bases_Eve.append(int(0.5+Value)/2)
112

113 'Bepalen spin- en bit waardes Eve'

114 Posities = range(N_photons)
115 Spin_Eve = []
116 Bit_Value_Eve = []
117 for i in Posities:

34
118 if Bases_Alice[i] == Bases_Eve[i]:
119 Spin_Eve.append(Spin_Alice[i])
120 Bit_Value_Eve.append(Bit_Value_Alice[i])
121

122 if Bases_Alice[i] != Bases_Eve[i] and Bases_Eve[i] < 0.25:

123 Random_getal = random.random()
124 if Random_getal<0.5:
125 Spin_Eve.append(0)
126 Bit_Value_Eve.append(0)
127 else:
128 Spin_Eve.append(90)
129 Bit_Value_Eve.append(1)
130

131

132 if Bases_Alice[i] != Bases_Eve[i] and Bases_Eve[i] > 0.25:

133 Random_getal = random.random()
134 if Random_getal<0.5:
135 Spin_Eve.append(-45)
136 Bit_Value_Eve.append(0)
137 else:
138 Spin_Eve.append(45)
139 Bit_Value_Eve.append(1)
140

141 'Bepalen spin- en bit waardes Eve'

142 Posities = range(N_photons)
143 Spin_Bob = []
144 Bit_Value_Bob = []
145 for i in Posities:
146 if Bases_Eve[i] == Bases_Bob[i]:
147 Spin_Bob.append(Spin_Eve[i])
148 Bit_Value_Bob.append(Bit_Value_Eve[i])
149

150 if Bases_Eve[i] != Bases_Bob[i] and Bases_Bob[i] < 0.25:

151 Random_getal = random.random()
152 if Random_getal<0.5:
153 Spin_Bob.append(0)
154 Bit_Value_Bob.append(0)
155 else:
156 Spin_Bob.append(90)
157 Bit_Value_Bob.append(1)
158

35
159

160 if Bases_Eve[i] != Bases_Bob[i] and Bases_Bob[i] > 0.25:

161 Random_getal = random.random()
162 if Random_getal<0.5:
163 Spin_Bob.append(-45)
164 Bit_Value_Bob.append(0)
165 else:
166 Spin_Bob.append(45)
167 Bit_Value_Bob.append(1)
168

169 for i in range(N_photons):

170 Bit_Value_Alice[i] = Bit_Value_Alice[i]+1
171 Bit_Value_Eve[i] = Bit_Value_Eve[i]+1
172 Bit_Value_Bob[i] = Bit_Value_Bob[i]+1
173

174 good_Bit_Value_Alice = []
175 good_Bit_Value_Eve = []
176 good_Bit_Value_Bob = []
177

178 for i in range(0,len(Spin_Alice)):

179 if Bases_Alice[i] == Bases_Bob[i]:
180 good_Bit_Value_Alice.append(Bit_Value_Alice[i])
181 good_Bit_Value_Eve.append(Bit_Value_Eve[i])
182 good_Bit_Value_Bob.append(Bit_Value_Bob[i])
183

184 KeyAlice = ListToInt(good_Bit_Value_Alice)

185 KeyEve = ListToInt(good_Bit_Value_Eve)
186 KeyBob = ListToInt(good_Bit_Value_Bob)
187 return(KeyAlice,KeyEve,KeyBob)
188

189 Aantal_keys_per_lengte = []
190 Correcte_keys_Eve_per_lengte = []
191 Correcte_keys_Bob_per_lengte = []
192 for i in range(0,Verzonden_aantal_fotonen+1):
193 Aantal_keys_per_lengte.append(0)
194 Correcte_keys_Eve_per_lengte.append(0)
195 Correcte_keys_Bob_per_lengte.append(0)
196

197

198 def intsplitter(number = []):

199 if number == []:

36
200 return([])
201 return([int(d) for d in str(number)])
202

203 counter = 0
204 while counter< Aantal_keer_protecol_uitvoeren:
205 KeyAlice, KeyEve, KeyBob = Alice_Bob_en_Eve(Verzonden_aantal_fotonen)
206 Aantal_keys_per_lengte[len(intsplitter(KeyAlice))] = \
207 Aantal_keys_per_lengte[len(intsplitter(KeyAlice))] + 1
208

209 if KeyAlice == KeyEve:

210 Correcte_keys_Eve_per_lengte[len(intsplitter(KeyAlice))] =\
211 Correcte_keys_Eve_per_lengte[len(intsplitter(KeyAlice))] + 1
212

213 if KeyAlice == KeyBob:

214 Correcte_keys_Bob_per_lengte[len(intsplitter(KeyAlice))] =\
215 Correcte_keys_Bob_per_lengte[len(intsplitter(KeyAlice))] + 1
216 counter = counter + 1
217

218 'Hieronder wordt per key lengte bepaald hoe vaak deze key lengte zal\
219 voorkomen'
220 Verwacht_voorkomen_keylengte = []
221 for i in Kans_op_lengte_X:
222 Verwacht_voorkomen_keylengte.append(i*Aantal_keer_protecol_uitvoeren)
223 #return(Kans_op_lengte_X,Verwacht_voorkomen_keylengte)
224 'Hieronder wordt per keylengte bepaald hoe vaak er een correcte key wordt\
225 verwacht'
226 Verwacht_voorkomen_correcte_key_van_lengte = []
227 for i in Kans_op_goede_key_van_lengte:
228 Verwacht_voorkomen_correcte_key_van_lengte.append\
229 (i*Aantal_keer_protecol_uitvoeren)
230 return(lengtes,Verwacht_aantal_keys_per_lengte,\
231 Verwacht_voorkomen_correcte_key_van_lengte,Aantal_keys_per_lengte,\
232 Correcte_keys_Eve_per_lengte,Correcte_keys_Bob_per_lengte,\
233 Aantal_keer_protecol_uitvoeren,Kans_op_lengte_X,\
234 Kans_op_goede_key_van_lengte)
235

236 t1 = time.time()
237 Aantal_uitvoeren = 100
238 SimulatieVariabeleKeyLengte(Te_versturen_bits,Aantal_uitvoeren)
239 t2 = time.time()

37
240 'Bepalen waarde Aantal_goed_Verlangd'
241 Aantal_goed_Verlangd = int(0.9*Aantal_uitvoeren*Max_tijd/(t2-t1))
242

243 start_time = time.time()

244

245 lengtes,Verwacht_aantal_keys_per_lengte,\
246 Verwacht_voorkomen_correcte_key_van_lengte,Aantal_keys_per_lengte,\
247 Correcte_keys_Eve_per_lengte,Correcte_keys_Bob_per_lengte,\
248 Aantal_keer_protecol_uitvoeren,Kans_op_lengte_X,Kans_op_goede_key_van_lengte \
249 = SimulatieVariabeleKeyLengte(Te_versturen_bits,Aantal_goed_Verlangd)
250

251

252 print('Het protecol is:',Aantal_keer_protecol_uitvoeren,'keer uitgevoerd.')

253 print('De key lengtes zijn',lengtes)
254 print('Per lengte wordt her volgend aantal keys verwacht:',\
255 [int(i) for i in Verwacht_aantal_keys_per_lengte])
256 print('Daadwerkelijk komen er',Aantal_keys_per_lengte,'keys per lengte voor')
257 print('Per lengte worden er per key lengte'\
258 , [int(i) for i in Verwacht_voorkomen_correcte_key_van_lengte]\
259 ,'correcte keys verwacht')
260 print('Correcte keys Eve per lengte',Correcte_keys_Eve_per_lengte)
261 print('Correcte keys Bob per lengte',Correcte_keys_Bob_per_lengte)
262 #print('De kans per lengte is:',Kans_op_lengte_X)
263 #print('De kans op een goede key per lengte:',Kans_op_goede_key_van_lengte)
264

265 'Changing the size of numbers on the axis of the figures (10 is standard)'
266 import matplotlib
267 matplotlib.rc('xtick', labelsize=14)
268 matplotlib.rc('ytick', labelsize=14)
269

270 import matplotlib.pyplot as plt

271 'Figuur 1: verwachte aantal keys per lengte vs aantal keys per lengte'
272 plt.figure(1)
273 plt.plot(lengtes,Verwacht_aantal_keys_per_lengte,color = 'green',label = \
274 'Verwacht aantal keys per key lengte')
275 plt.scatter(lengtes,Aantal_keys_per_lengte,color = 'red',label = \
276 'Aantal keys')
277 plt.ylim(-0.1*max(max(Verwacht_aantal_keys_per_lengte),\
278 max(Aantal_keys_per_lengte)),\

38
279 1.4*max(max(Verwacht_aantal_keys_per_lengte),\
280 max(Aantal_keys_per_lengte)))
281 plt.legend(loc = 'upper right',fontsize=12)
282 plt.xlabel('Key lengte',size = 14)
283 plt.ylabel('Aantal keys met lengte',size = 14)
284 plt.grid()
285 plt.show()
286

287 'Figuur 2: Verwacht aantal correcte keys per lengte vs aantal correcte keys\
288 per lengte'
289 plt.figure(2)
290 plt.plot(lengtes,Verwacht_voorkomen_correcte_key_van_lengte,color = 'green'\
291 ,label = 'Verwacht aantal correcte keys per lengte')
292 plt.scatter(lengtes,Correcte_keys_Eve_per_lengte,color = 'red',label =\
293 'Correcte keys per lengte Eve',marker = '^')
294 plt.scatter(lengtes,Correcte_keys_Bob_per_lengte,color = 'blue',label =\
295 'Correcte keys per lengte Bob',marker = 'v')
296 plt.ylim(-0.1*max(max(Verwacht_voorkomen_correcte_key_van_lengte)\
297 ,max(Correcte_keys_Eve_per_lengte)\
298 ,max(Correcte_keys_Bob_per_lengte))\
299 ,1.6*max(max(Verwacht_voorkomen_correcte_key_van_lengte)\
300 ,max(Correcte_keys_Eve_per_lengte)\
301 ,max(Correcte_keys_Bob_per_lengte)))
302 plt.legend(loc = 'upper right',fontsize=12)
303 plt.xlabel('Key lengte',size = 14)
304 plt.ylabel('Aantal correcte keys',size = 14)
305 plt.grid()
306 plt.show()
307

308

309 'Figuur 3: kans op bepaalde keylengte'

310 plt.figure(3)
311 plt.grid()
312 plt.scatter(lengtes,Kans_op_lengte_X)
313 plt.xlabel('Key lengte',size = 15)
314 plt.ylabel('Kans op lengte',size = 15)
315 plt.show()
316

317 'Figuur 4: kans op goede key met keylengte'

39
318 plt.figure(4)
319 plt.grid()
320 plt.ylim(-0.1*max(Kans_op_goede_key_van_lengte),\
321 1.1*max(Kans_op_goede_key_van_lengte))
322 plt.scatter(lengtes,Kans_op_goede_key_van_lengte)
323 plt.xlabel('Key lengte',size = 15)
324 plt.ylabel('Kans op goede key',size = 15)
325 plt.show()
326

327 end_time = time.time()

328

329 print('Het runnen van deze code duurt:',abs(int((start_time - end_time)*100)/100

40