Marco Mattiucci

INFORMATICA - QUANTUM COMPUTING
QKD BB84

Maggio 2026

Nota

In considerazione del corrente estensivo impiego degli LLM per produrre testi evidenzio che il testo di questa pagina è stato prodotto da me direttamente e personalmente ed è frutto dei miei studi personali, gli schemi a blocchi sono stati disegnati da Gemini 3.1 Pro su mie indicazioni. Per il software di simulazione della QKD BB84 in python proposto sul mio github.com/mmattiucci2024/qkd esso è stato scritto direttamente da me eccezion fatta per le prime 3 piccole procedure, realizzate da Gemini 3.1 Pro + Perplexity Pro su mie indicazioni.

1. Quantum Key Distribution (QKD)

La QKD è un protocollo per la distribuzione sicura di chiavi tra sole due parti, fondato sui principi della meccanica quantistica. In particolare, questo lavoro prende in considerazione il protocollo di QKD indicato come BB84, acronimo dalle iniziali dei suoi inventori, Charles H. Bennett e Gilles Brassard, e dall'anno di definizione, il 1984 (tale protocollo di distribuzione quantistica delle chiavi è stato presentato all'International Conference on Computers, Systems and Signal Processing di Bangalore, India, nel dicembre 1984 con l'articolo scientifico intitolato "Quantum cryptography: Public key distribution and coin tossing")

Ovviamente il mio approccio al QKD BB84 è sempre ristretto all'ambito informatico per cui ho realizzato un simulatore in python CirQ che tramite porte quantistiche standard analizza il funzionamento del protocollo, verificando cosa accade in presenza di rumore (simulato) sulla linea di comunicazione o di un intruso (anch'esso simulato) che vuole intercettare le comunicazioni tra i due nodi, infine si considera anche una tecnica molto elementare di correzione errori delle chiavi.

L'obiettivo è illustrare in maniera pratica, diretta e semplificata il funzionamento del QKD BB84 con un software che permetta anche di variare le condizioni di funzionamento.

2. Premessa sulla porta di Hadamard H

Nella pagina Quantum Program 1 abbiamo visto che la misurazione in uscita di un circuito elementare come il seguente:

porta a valori random binari 0 o 1 con probabilità perfettamente bilanciate. Questo non è difficile da dimostrare matematicamente dato che la matrice di H è:

da cui il risultato dell'applicare H a |0> è:

ricordando che per la misura del generico stato quantistico
|Ψ>, la probabilità di avere 0 o 1 (valori classici perchè frutto di misura) è calcolabile come segue:

si può facilmente desumere che la misura nel circuito sopra descritto, all'uscita di H, ha una P(0)=P(1)=1/2, ossia il bilanciamento randomico tra 0 ed 1. Allo stesso modo, se si applica H ad |1> si ha:

e quindi anche in questo caso la misura avrà probabilità P(0)=P(1)=1/2, confermando il bilanciamento randomico tra 0 ed 1. Che sia quindi |0> o |1> in ingresso alla H la misura alla sua uscita è sempre quella di un quantum random number generator binario.

I due particolari stati quantistici che si ottengono in uscita dalla H avendo come ingresso |0> ed |1> vengono indicati rispettivamente con |+> e |->:

Facciamo quindi l'ultimo passo necessario per analizzare poi la QKD: andiamo a considerare il circuito che segue in cui ci sono due porte H in sequenza. Come già visto in Quantum Program 1 si ottiene lo stato in ingresso alla prima H, qualunque esso sia. La dimostrazione è semplice:

ossia applicando la porta di Hadamard due volte di seguito si ottiene una porta I (matrice identità) che equivale al semplice canale quantistico considerato (è come se le due H non ci fossero).

3. Circuito multifunzione

Avendo la premessa di cui al paragrafo precedente possiamo ora passare a considerare il seguente circuito quantistico in cui ogni porta risulta controllata da una misura classica (non quantistica) binaria:

ricordando che le porte controllate si riconducono a porte Identità (sostanzialmente inesistenti) quando il controllo classico vale 0, mentre svolgono la loro piena funzione quando il controllo vale 1, possiamo stilare la tabella che segue tenendo conto di tutte le otto possibili configurazioni binarie di C1, C2 e C3 e di quanto visto sulla porta H nel paragrafo precedente:

Come si può facilmente evincere dalla tabella, le righe evidenziate con colore diverso mostrano che lo stato quantistico d'uscita |ψ₃⟩ coincide con |ψ₁⟩ solo quando C2 e C3 (i controlli delle due H) sono uguali tra loro. Negli altri casi l'uscita è uno stato sovrapposto |+> o |->.

Quindi, andando a misurare |ψ₃⟩ e tenendo presente quanto visto nel paragrafo precedente sulle probabilità di misurare 0 o 1 nei diversi stati quantistici, si ha che:

M(|ψ₃⟩) = C1 se C2 = C3

altrimenti M(|ψ₃⟩) è un valore binario perfettamente random.

Questo risultato è molto importante nel capire come opera la QKD BB84, il circuito quantistico multifunzione studiato è proprio alla base del citato protocollo.

4. QKD parte 1 - sharing

Ripartiamo dal circuito multifunzione di cui al paragrafo precedente e consideriamo due nodi di trasmissione: nel primo nodo (nodo 1) inseriamo la CNOT e la prima H, nel secondo (nodo 2) la seconda H.

Inoltre, i comandi classici C1, C2 e C3 imponiamo che siano gestiti da tre diversi QRNG (Quantum Random Number Generator), i primi due nel nodo 1 e il terzo nel nodo 2. Lo schema diventa quello che segue:

Lo stato quantistico |ψ₂⟩ viene condiviso dai due nodi (linea tratteggiata) mediante un canale quantistico (fibra ottica o onde elettromagnetiche) e quindi nodo 1 e 2 possono essere ad una certa distanza tra loro, non necessariamente nello stesso luogo.

Ipotizzando un comportamento sincrono del sistema nel suo complesso (ignorando al momento problemi inerenti a tempi di trasmissione, stabilità degli stati quantistici, attenuazioni sulla linea, depolarizzazione, ecc.), i tre QRNG generano tre valori binari simultaneamente attivando o meno le tre porte quantistiche. Secondo quanto visto nel paragrafo precedente, nel caso in cui i rispettivi QRNG di C2 e C3, presenti su nodi differenti, generino lo stesso valore binario si ha con certezza:

M(|ψ₃⟩) = C1

ossia il nodo 1 e il nodo 2, in tal caso, condividono un bit classico pur non avendolo esplicitamente trasmesso sulla linea di trasmissione. In tutti gli altri casi il risultato di M(|ψ₃⟩) è casuale.

Il punto centrale di estrema importanza è che si può valutare se un valore binario casuale (C1) sia stato condiviso o meno osservando se due altri valori casuali C2 e C3, non correlati al primo, siano uguali tra loro.

Questa è la "magia" della QKD in generale, ossia la possibilità di condividere valori casuali di QRNG (quindi ottime possibili chiavi di crittazione simmetrica) tra due nodi differenti svolgendo valutazioni su altri valori casuali perfettamente scorrelati dai primi per ragioni quantistiche.

5. QKD parte 2 - buffering & sifting

Il passaggio successivo lo possiamo facilmente considerare analizzando il seguente schema circuitale:

come si può vedere sono stati inclusi dei buffer di memoria che registrano C1 e C2 all'interno del nodo 1, mentre C3 e M(|ψ₃⟩) all'interno del nodo 2.

Si ipotizza che il sistema circuitale operi N volte e per ognuna delle volte i 4 buffer di memoria raccolgono i valori binari classici delle citate variabili. In definitiva, al completamento del processo, in ognuno dei buffer ci sono N righe.

Passo successivo per i 2 nodi è pubblicare e confrontare, su una linea classica pre-autenticata e non criptata (garanzia di mittente e destinatario) i soli buffer di C2 e C3. Precisamente il nodo 2, che si può considerare come ricevente, invia al nodo 1 tutto il buffer di C3; il nodo 1 analizza i vari bit che riceve e invia indietro al nodo 2 le posizioni in cui rispecchiano i valori di C2.

Va sottolineato che questa comunicazione pubblica indietro e avanti scambia sulla linea classica solo valori random.

Il nodo 1, comunemente indicato in letteratura come "Alice" (nodo trasmittente), dopo aver ricevuto il contenuto del buffer di C3 dal nodo 2, detto "Bob" (nodo ricevente), è in grado di selezionare i bit del buffer C1 che sono da considerare come condivisi tra i nodi.

Dall'altra parte, ottenuta la risposta di Alice, anche Bob può individuare i bit in comune del buffer di M(|ψ₃⟩).

Questa operazione di individuazione dei bit condivisi, svolta da entrambi i nodi in connubio tra loro, è detta in letteratura sifting. La sequenza di tali bit condivisi rappresenta proprio la chiave frutto del key distribution tra Alice e Bob.

6. QKD emulazione software (caso ideale)

Il software realizzato, liberamente disponibile su github.com/mmattiucci2024/qkd, emula in python quanto descritto nel paragrafo precedente realizzando un meccanismo di QKD BB84 mediante la libreria CirQ di Google.

Per questa prima parte si considerano le condizioni ideali e quindi nessun rumore o problema sulla linea di trasmissione e nessun intruso tra Alice e Bob. Di seguito una parte dell'output del software per N = 100. Come si può vedere, dopo il sifting, il numero di bit condivisi è 55 e quindi i restanti bit (su 100) sono stati scartati. Inoltre le due sequenze ricavate da Alice e Bob sono coincidenti senza errori nemmeno su un bit.

Alice and Bob communicate on the quantum channel:
Nr  Alice  Alice Bob   Bob  
    C1     C2    C3    M(|ψ3⟩) 
0   1      1     0     1    
1   0      1     0     0    
2   0      0     0     0     - Alice and Bob matching bases.
3   1      1     1     1     - Alice and Bob matching bases.
4   1      1     1     1     - Alice and Bob matching bases.
5   0      0     1     0    
6   0      0     0     0     - Alice and Bob matching bases.
7   0      0     0     0     - Alice and Bob matching bases.
...
...
95  1      0     1     1    
96  0      0     0     0     - Alice and Bob matching bases.
97  0      0     1     1    
98  0      1     1     0     - Alice and Bob matching bases.
99  1      1     0     0    
Alice sent 100 random bit(s) over the quantum channel.
The quantum channel is free of depolarizing noise.
The quantum channel is free of amplitude damping noise.
No eavesdropper is present on the quantum communication channel.

Alice and Bob sifting:
Bob sends to Alice the sequence of the random bases it used:
0001110000111010101110110010001111001001100101111000101101001010010011101011001100001010001111110110
Alice sends back to Bob the positions of the bits where the bases match:
2 3 4 6 7 11 15 19 21 23 26 29 30 32 33 34 36 41 42 43 45 46 47 49 50 51 54 56 57 60 61 63 64 65 70 73 74 75 76 78 80 81 82 85 86 87 88 89 90 91 92 93 94 96 98 
Alice (A) and Bob (B) sifted keys (bit errors in red):
A: 0110001110011111101000100001000111111100101110100110000
B: 0110001110011111101000100001000111111100101110100110000
Alice shared 55 bit(s) out of 100 bit(s) with Bob via the QKD sifting process.
Bob ERRORS= 0 bit(s) - QBER_BOB= 0.0
Alice and Bob retain the 55 shared bits.

QUANTUM CIRCUIT:
                    ┌───┐
QRNGalice1: ────H────M─────────────────────────────────────
                     ║
QRNGalice2: ────H────╫M────────────────────────────────────
                     ║║
QRNGbob__1: ────H────╫╫M───────────────────────────────────
                     ║║║
Q__channel: ─────────╫╫╫────X───H───H───M('bob_measure')───
                     ║║║    ║   ║   ║
QRNGalice1m: ════════@╬╬════^═══╬═══╬══════════════════════
                      ║║        ║   ║
QRNGalice2m: ═════════@╬════════^═══╬══════════════════════
                       ║            ║
QRNGbob__1m: ══════════@════════════^══════════════════════
                    └───┘

Se si analizza il circuito quantistico qui sopra disegnato in CirQ ed usato per l'emulazione, si può facilmente vedere che i tre QRNG necessari al funzionamento sono costruiti impiegando delle porte di Hadamard. Ogni QRNG, infatti, è il risultato della misura di uno stato sovrapposto |+> ottenuto applicando |0> (in CirQ ogni linea è inizializzata per default a |0>) ad una porta H: si tratta delle linee classiche QRNGalice1m, QRNGalice2m e QRNGbob__1m. Quindi per i QRNG non si fa ricorso ai PRNG (Pseudo Random Number Generator) del python ma si usa ancora l'emulazione quantistica del CirQ (nella realtà i QRNG contenuti nei dispositivi QKD sono anch'essi uno specifico hardware quantistico).

7. QKD parte 3 - problemi reali

Nella realtà e quindi fuori da condizioni protette di laboratorio o ideali di simulazione matematica, i problemi che possono affliggere la QKD sono diversi e a seconda della loro intensità si può passare dall'avere alcuni errori nei bit nella chiave condivisa da Alice e Bob fino ad avere un completo fallimento del processo di key distribution.

Il primo problema riguarda i QRNG, se non sono di qualità elevata possono introdurre errori e talvolta rendere parti della chiave condivisa prevedibili, inoltre devono essere sufficientemente veloci per garantire la velocità globale della key distribution.

Una delle questioni più comuni è sicuramente quella del rumore sulla linea di trasmissione quantistica (la linea tratteggiata con lo stato |ψ₂⟩ per meglio intederci), i due ricorrenti rumori di depolarizzazione e di attenuazione sono spesso legati alle distanze ed alle curve (per le fibre ottiche) per cui è risaputo che i sistemi di QKD reali smettono di operare correttamente ed efficacemente per lunghezze superiori ad una certa soglia (ad esempio oggi si parla di 100km su fibra ottica ma ci sono varie sperimentazioni e ricerche in atto per incrementare tale limite) oppure in condizioni meccaniche poco curate delle linee.

Infine, un altro problema assolutamente da considerare è come reagisce il sistema di QKD allorquando un intruso guadagni l'accesso alla linea |ψ₂⟩, ma questo lo vedremo specificamente in uno dei prossimi paragrafi.

Nel presente paragrafo andremo a trattare il concetto di rumore sul canale di trasmissione quantistico |ψ₂⟩, di come il meccanismo di QKD reagisca a tale condizione e delle possibili contromisure che si devono introdurre per ottenere comunque una valida key distribution tra Alice e Bob.

Fortunatamente la libreria CirQ prevede la simulazione del rumore e nel software realizzato sono stati inseriti due rumori di media intensità, uno di attenuazione e uno di depolarizzazione, che sebbene influenzino la QKD non ne impediscono completamente il funzionamento. Di seguito l'output del software in una di tali circostanze, sempre per N = 100:

Alice and Bob communicate on the quantum channel:
Nr  Alice  Alice Bob   Bob  
    C1     C2    C3    M(|ψ3⟩) 
0   1      1     0     1    
1   1      1     1     1     - Alice and Bob matching bases.
2   1      0     0     1     - Alice and Bob matching bases.
3   0      1     0     0    
4   1      1     1     1     - Alice and Bob matching bases.
5   0      0     1     0    
6   0      0     1     1    
7   0      0     0     0     - Alice and Bob matching bases.
...
...
95  0      1     1     0     - Alice and Bob matching bases.
96  0      0     1     1    
97  1      1     0     0    
98  1      0     1     1    
99  1      1     0     1    
Alice sent 100 random bit(s) over the quantum channel.
The quantum channel is affected by quantum depolarizing noise - probability= 0.04
The quantum channel is affected by quantum amplitude damping noise - probability= 0.09
No eavesdropper is present on the quantum communication channel.

Alice and Bob sifting:
Bob sends to Alice the sequence of the random bases it used:
0100111001010101000100001011001000010010111011000011110011001100011100010010101011001010101111111010
Alice sends back to Bob the positions of the bits where the bases match:
1 2 4 7 8 9 14 15 17 19 20 21 22 24 25 29 30 34 35 36 41 42 49 52 53 54 56 57 60 63 64 68 69 75 77 82 83 84 89 90 93 95 
Alice (A) and Bob (B) sifted keys (bit errors in red):
A: 1110000100 1 1101 1 10010000001011110001000010
B: 1110000100 0 1101 0 10010000001011110001000010
Alice shared 42 bit(s) out of 100 bit(s) with Bob via the QKD sifting process.
Bob ERRORS= 2 bit(s) - QBER_BOB= 0.047619047619047616
Alice and Bob retain the 42 shared bits, but Bob needs to correct 2 bit(s) in the following positions:
20 29 
Beginning error correction on the sifted key:
Bob sends to Alice the hash value: 017e0c5165a376b13a20b71d62cfa74d64d12ae6d46d744cddea60941343a4aa of the subkey: 0 - Alice responds by rejecting the subkey!
Bob sends to Alice the hash value: 299889fdc7ecc38c1e6c31187f97c830b2de2d763e55b32758bd8586e8e495ca of the subkey: 1 - Alice responds by rejecting the subkey!
Bob sends to Alice the hash value: 44496266412a99adce553e73b593b4511280ff5769a11d5dfef14b75dee25ad4 of the subkey: 2 - Alice responds by rejecting the subkey!
Bob sends to Alice the hash value: 3f555ae0fb87a67460e44768dca1b1d5407505967726f463cfcb5bf5246defa9 of the subkey: 3 - Alice responds by rejecting the subkey!
...
...
Bob sends to Alice the hash value: 02384a486a94637b213ce73f48dfecf0f38c724abdd6e9308bfe922e6609acec of the subkey: 150 - Alice responds by rejecting the subkey!
Bob sends to Alice the hash value: a51083a7ad008351db6d5f39aaca346611929db766c179850c3a6184c7189025 of the subkey: 151 - Alice responds by rejecting the subkey!
Bob sends to Alice the hash value: acab61345345f31c3510212d84e3efc3313d4df9b173d13493252ab24ef3dd70 of the subkey: 152 - Alice reports a perfect subkey match; no error detected.
Final key distribution on subkey no. 152 :10010000001011110001000010

QUANTUM CIRCUIT:
                    ┌───┐
QRNGalice1: ────H────M──────────────────────────────────────────────────────────
                     ║
QRNGalice2: ────H────╫M─────────────────────────────────────────────────────────
                     ║║
QRNGbob__1: ────H────╫╫M────────────────────────────────────────────────────────
                     ║║║
Q__channel: ─────────╫╫╫────X───H───D(0.04)───AD(0.09)───H───M('bob_measure')───
                     ║║║    ║   ║                        ║
QRNGalice1m: ════════@╬╬════^═══╬════════════════════════╬══════════════════════
                      ║║        ║                        ║
QRNGalice2m: ═════════@╬════════^════════════════════════╬══════════════════════
                       ║                                 ║
QRNGbob__1m: ══════════@═════════════════════════════════^══════════════════════
                    └───┘

Come si può vedere dal disegno del circuito CirQ qui sopra riportato, i due rumori sulla linea: (a) cirq.depolarize(prob) (nel disegno D()) corrisponde al rumore di depolarizzazione (depolarizing noise), mentre (b) cirq.amplitude_damp(prob) (nel disegno AD()) corrisponde al rumore di attenuazione di ampiezza (amplitude damping).

Il rumore di depolarizzazione simula errori casuali attraverso i quali lo stato quantistico ha una fase (tridimensionale sulla sfera di bloch) che tende a modificarsi in maniera random (per fenomeni di rumore ambientale non strutturato, scattering, disturbi non correlati, errori complessivi di canale che non privilegiano una fase particolare, ecc.).

Il rumore di attenuazione simula la perdita di energia del qbit durante la propagazione o durante l’attesa. In pratica il qbit tende spontaneamente a "rilassarsi" da ∣1⟩ a ∣0⟩ (per fenomeni di assorbimento, perdita di fotoni, rilassamento energetico, decadimento del segnale utile, ecc., collegati soprattutto a tempo di propagazione o di permanenza nel canale, lunghezza della linea, pieghe nella fibra ottica, perdite del mezzo e interazioni con l’ambiente).

Impostando i valori per le probabilità dei due rumori a 0.04 e 0.09 (valori equivalenti al funzionamento del sistema QKD in buone condizioni), il software porta a termine il sifting nella simulazione ma rileva che Bob commette errori su 2 bit determinando un QBER (Quantum Bit Error Rate) non nullo (QBER_BOB = 0.04761...). In definitiva il citato rumore, dal punto di vista informatico, determina la probabilità che QBER risulti generalmente maggiore di zero.

Problema sostanziale è che Bob non può rilevare il QBER da solo senza confrontare la sua sifted key con quella di Alice. Il software di simulazione può calcolare il QBER caso per caso perchè, appunto, la simulazione avviene tutta in un'unica memoria e non su linee di trasmissione vere su nodi fisicamente separati. In letteratura si identificano allora due momenti:

(a) una comunicazione di valutazione della linea, dove la sifted key di Bob viene mandata pubblicamente ad Alice sul canale autenticato affinchè si possa calcolare il QBER;

(b) la fase di key distribution vera e propria (con sifted key condivise solo tra Alice e Bob) che viene ritenuta fattibile solo se il QBER (già calcolato nella fase precedente) risulta minore di circa 0.11.

La soglia 0.11 è giustificabole dal punto di vista statistico, ma dato che il QBER è sostanzialmente campionato attraverso una o più prove si tratta comunque di una valutazione empirica. Talvolta tale soglia di accettazione viene rivista in vista di situazioni particolari dal punto di vista pratico.

Ad ogni modo, un QBER campionato medio tale che:
0.11 > QBER > 0
indica che in fase di reale key distribution ci saranno quasi sicuramente dei bit da correggere nella sequenza di bit di Bob e quindi si deve impiegare un metodo di correzione degli errori. Vi sono diversi algoritmi di correzione errori particolarmente funzionali per la QKD (ad es. LDPC (Low-Density Parity-Check) e Cascade classico di BB84), in questo software, a titolo di esempio, ne è stato implementato uno basato sullo scambio di hash di sottochiavi tra Alice e Bob secondo uno schema di numeri triangolari. Nulla di particolarmente efficiente per il contesto in studio, ma, quale esempio, è semplice da implementare e funziona in maniera semplice e deterministica.

Al termine della correzioni errori si ha finalmente la chiave condivisa tra Alice e Bob. Si noti che si parte da N = 100 bit scambiati, per avere il sifting su 42 bit e infine ottenere la chiave condivisa finale, dopo la correzione errori, di soli 26 bit.

8. QKD parte 4 - intruso sulla linea

In questo paragrafo tratteremo dell'eventuale presenza di un intruso sulla linea quantistica e dell'effetto che avrebbe sul meccanismo di QKD BB84. In particolare l'intruso potrebbe tentare di effettuare l'intercettazione soprattutto sulla parte di canale di trasmissione caratterizzato dallo stato quantistico |ψ₂⟩. Questo in quanto tale parte è esterna ad entrambi i nodi.

Grazie al teorema di "no cloning", già analizzato nella pagina Quantum No Cloning sappiamo che una linea quantistica non ammette fan-out, ossia non si può diramare su più linee d'uscita conservando lo stesso stato quantistico. Si può anche dire, nel caso che stiamo trattando, che lo stato quantistico sul canale di comunicazione esterno a Alice e Bob |ψ₂⟩ non può essere conosciuto o clonato da un eventuale intruso (che chiameremo da adesso in avanti Eve come da letteratura) nella sua interezza.

Nell'ipotesi che Eve abbia pieno accesso al canale di trasmissione quantistico (al suo hardware) e sebbene non possa clonare lo stato quantistico ivi presente, rimane l'unica possibilità di "tagliare" tale canale inserirendovi un qualcosa che si possa confondere con Bob.

Come si evince dallo schema, allo stesso modo di Bob, l'intruso Eve si collega a |ψ₂⟩ con una porta H controllata da un generico PRNG (Pseudo Random Number Generator) dotato di sua memoria, successivamente l'uscita di tale H passa ad un blocco di misura. Come noto la misura fa collassare lo stato quantistico in uscita dalla H controllata verso un valore classico binario 0 o 1 e quindi Eve può memorizzare tale valore (intercettate) in un suo buffer in maniera simile a quanto fa Bob. La questione, a questo punto, si sposta nel come ricollegare la linea permettendo al meccanismo QKD di funzionare il più possibile in maniera trasparente tra Alice e Bob. Eve, quindi, introduce il valore classico appena memorizzato in una porta H che determina in uscita uno stato quantistico |ψ₂*⟩ che può essere favorevolmente accolto da Bob e che, sebbene poco abbia a che fare con il vero |ψ₂⟩, permette comunque al meccanismo QKD di procedere.

Eve ascolta anche sul canale classico pubblico che collega i buffer di Alice e Bob per cui costruisce un suo processo di sifting parallelo a quello degli ignari Alice e Bob. La memoria del PRNG permette ad Eve di selezionare i bit della sequenza quando la base di Eve (scelta dal PRNG) coincide sia con quella di Alice che con quella di Bob (scelta dai loro rispettivi QRNG). Eve potrà così terminare il suo sifting intercettando almeno una parte della sifted key condivisa tra Alice e Bob.

Per semplicità la simulazione del software che segue introduce la presenza di Eve in un meccanismo di QKD ideale, senza rumore di linea, ed è interessante vedere cosa accade:

Alice, Bob and Eve (eavesdropper) communicate on the quantum channel:
Nr  Alice  Alice Bob   Bob  
    C1     C2    C3    M(|ψ3⟩) 
1   1      1     1     0     1     - Alice and Bob matching bases.
2   0      0     0     0     0     - Alice and Bob matching bases.
3   0      0     1     1     0    
...
...
96  0      0     0     0     0     - Alice and Bob matching bases.
97  0      1     1     0     0     - Alice and Bob matching bases.
98  1      0     0     1     1     - Alice and Bob matching bases.
99  0      0     1     1     1    
Alice sent 100 random bit(s) over the quantum channel.
The quantum channel is free of depolarizing noise.
The quantum channel is free of amplitude damping noise.
There is an eavesdropper on the quantum communication channel.

Alice and Bob sifting:
Bob sends to Alice the sequence of the random bases it used:
1101101010100011100001011001101010001001111110100101110101111010011100001010001010110000001111110101
Alice sends back to Bob the positions of the bits where the bases match:
1 2 5 8 11 13 16 17 20 23 27 30 32 33 34 35 42 45 47 48 49 50 51 52 54 57 58 59 61 63 64 65 69 70 72 74 76 77 80 84 85 88 92 93 95 96 97 98 
Alice (A) and Bob (B) sifted keys (bit errors in red):
A:  1 01 1 010011101 0 1111 1 0 1 1100 1 0 0 01 1 00 1 1001000 0 100001
B:  0 01 0 010011101 1 1111 0 0 0 1100 0 0 1 01 0 00 0 1001000 1 100001
E:  _ 0_ _ 01__111__ _ 1111 _ _ _ 11__ _ 0 _ 0_ _ 0_ _ _001__0 _ 1_0001
Alice shared 48 bit(s) out of 100 bit(s) with Bob via the QKD sifting process.
Eve intercepted 24 bit(s) of the shared key.
Bob ERRORS= 10 bit(s) - QBER_BOB= 0.20833333333333334
Alice and Bob discard the 48 shared bits because the QBER is higher than 0.1

QUANTUM CIRCUIT:
                    ┌───┐
QRNGalice1: ────H────M────────────────────────────────────────────────────────────────
                     ║
QRNGalice2: ────H────╫M───────────────────────────────────────────────────────────────
                     ║║
QRNGbob__1: ────H────╫╫M──────────────────────────────────────────────────────────────
                     ║║║
Q__channel: ─────────╫╫╫────X───H───H───M('eve_measure')───H───H───M('bob_measure')───
                     ║║║    ║   ║                              ║
QRNGalice1m: ════════@╬╬════^═══╬══════════════════════════════╬══════════════════════
                      ║║        ║                              ║
QRNGalice2m: ═════════@╬════════^══════════════════════════════╬══════════════════════
                       ║                                       ║
QRNGbob__1m: ══════════@═══════════════════════════════════════^══════════════════════
                    └───┘

Come si può vedere dall'output della simulazione Alice e Bob determinano una sifted key di 48 bit sui 100 bit trasmessi, nel contempo Eve intercetta correttamente 24 bit. Quello che si mette in chiara evidenza, però, è che il QBER si alza notevolmente, era previsto nullo perchè il sistema è ideale, senza rumore su linea o apparati, eppure il QBER = 0.2083..., ben oltre la soglia del 0.11 prevista per l'accettazione del funzionamento del meccanismo.

In definitiva, si può dimostrare statisticamente che la soglia 0.11 del QBER di cui avevamo parlato nel paragrafo precedente viene sempre abbondantemente superata quando c'è un intruso sulla linea che cerca di intercettare la key distribution. La fase di valutazione del QBER (quella in cui dopo il sifting si comparano le chiavi su canale autenticato) quindi, non è solo utile per determinare se il protocollo può funzionare dal punto di vista pratico sull'hardware previsto, ma anche per prevenire la presenza di intrusi che tentano l'intercettazione.

9. Conclusioni

Il software realizzato permette di simulare anche l'intervento di un intruso sul canale in presenza di rumore di linea. Ovviamente il QBER andrà ulteriormente a peggiorare escludendo l'accettazione del meccanismo da parte di Alice e Bob.

Il BB84 è solo uno dei protocolli QKD possibili, oggi ne sono stati realizzati diversi e gran parte di loro sono già integrati in prodotti commerciali. Inoltre ce ne sono diversi di natura sperimentale e anche altri algoritmi di correzione errore post-sifting sono in corso di valutazione. Lo scopo è aumentare la performance della key distribution, rendere il protocollo talmente robusto da accettare anche hardware con maggiore presenza di rumore, e target principale è rendere le distanze utili tra Alice e Bob sempre maggiori.

I vantaggi della QKD sono diversi tra cui segnalo in primo luogo la resilienza agli attacchi ma anche il fatto che su fibra ottica diviene un meccanismo estremamente integrabile con i sistemi di crittazione simmetrici già esistenti e sempre più spesso sovrapponibile alle comunicazioni ottiche classiche.

Inserirlo quindi nelle infrastrutture di comunicazioni ottica costituisce una spesa limitata, non intacca l'esistente e aumenta la resilienza globale dei canali alle intercettazioni.

Bisogna però ricordare che è un protocollo punto-punto e non ne esiste una versione per una rete di n nodi collegati a maglia. In questo senso stanno avanzando prodotti che integrano la QKD con la PQC (Post-Quantum Cryptography) in maniera tale che risulti possibile gestire delle maglie di nodi o anche distanze superiori a quelle che la QKD attuale può supportare garantendo comunque una resilienza notevole.

marcomattiucci.it

• Home

Informatica:

• Home(Informatica)

Quantum Computing:

• Home(Quantum)
• QC models
• Q HyperC
• Program 1
• Annealing 1
• Registers (Prog2)
• Operators & No clone
• Annealing 2
• QRNG & PRNG
• Memorie e tempo
• Annealing 3
• PQRNG
• QKD BB84
• Eavesdropping QKD
• (working-on)