Marco Mattiucci
Email me
2026-10-30 09:51:07 sentence:
Guardati attorno prima di sentirti solo.
INFORMATICA - QUANTUM COMPUTING
QKD BB84 - Eavesdropping QKD
Giugno 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 e i grafici sono stati disegnati da Gemini 3.1 Pro e Perplexity Pro su mie indicazioni.
1. Eavesdropping Quantum Key Distribution
Nella pagina precedente ho introdotto un piccolo studio sul key agreement tra due nodi tramite QKD (Quantum Key Distribution) e in particolare sul protocollo BB84 che ne è preso normalmente come base di studio.
In questa pagina affronteremo alcuni metodi per intercettare parzialmente la chiave condivisa segreta anche in considerazione del fatto che la QKD è un metodo che, per i principi su cui si basa, non è intercettabile nemmeno teoricamente.
E' interessante però osservare che la non intercettabilità teorica della QKD si basa sull'uso di un canale quantistico di comunicazione praticamente ideale e sebbene in determinate condizioni molti canali quantistici esistenti (es. quelli su fibre ottiche) si comportano in maniera prossima al caso ideale è certo che nessun canale reale si può considerare privo di difetti ed errori al 100%.
Proprio in conseguenza di questo si sono sviluppate diverse teorie di eavesdropping per la QKD che, a dire il vero, non operano perfettamente ma sono comunque importantissime per rafforzare questa tipologia di protocollo nelle sue applicazioni reali (lo studio della cybersecurity si basa fondamentalmente sull'analisi e più spesso sull'impiego delle tecniche di attacco e penetrazione dei sistemi).
1.1. Eve con un clonatore quantistico
Lo schema di Eve che si pone fra Alice e Bob visto nella pagina precedente è il seguente:
Nella stessa pagina abbiamo visto che, anche considerando un canale quantistico ideale, il QBER di Bob in fase di valutazione sale da 0 a valori di molto superiori alla soglia di accettabilità 0.11 quando Eve fa la sua comparsa sul canale. In definitiva Alice e Bob, sempre in fase di valutazione della "bontà" del canale quantistico, si accorgono facilmente della presenza di Eve. Il problema sostanziale è che Bob, in presenza di Eve, non riceve il canale vero |ψ2⟩ ma uno ricostruito da Eve, ossia |ψ2*⟩. Sarebbe sicuramente più funzionale all'intercettazione di Eve se potesse essere costruito un clonatore quantistico che dirami |ψ2⟩ in due stati equivalenti:
|ψ2**⟩ da inviare unicamente ai circuiti interni di Eve;
|ψ2*⟩ da inviare unicamente a Bob.
Tale clonatore non si può costruire in senso assoluto in quanto, come visto nella pagina Quantum No Cloning una linea quantistica non ammette fan-out, ossia non si può diramare su più linee d'uscita conservando lo stesso stato quantistico.
Al momento comunque ipotizziamo che una sorta di clonatore esista; lo potremmo inserire come segue:
Richiamiamo che in letteratura si riconoscono tre tipologie di attacchi fondamentali alla QKD: individual, collective e general-coherent. In questo lavoro stiamo ovviamente considerando solo l'attacco individual dove Eve opera Intercept-Resend per ogni qbit trasmesso ponendosi nel mezzo tra Alice e Bob.
A titolo solo di indicazione negli attacchi collective Eve non misura subito i vari qbit della trasmissione ma, impiegando memorie quantistiche, li conserva per operare la misura in blocco nella fase di sifting quando Alice e Bob si confrontano sulle basi per filtrare la chiave condivisa (il problema si sposta a come passare in memoria gli stati quantistici senza che Bob ne risenta). Infine, gli attacchi general-coherent, individuati solo in teoria, richiedono un Computer Quantistico Universale Fault-Tolerant con un numero di qbit sufficiente a conservare tutti gli N qbit della comunicazione tra Alice e Bob considerandolo come un unico stato quantistico globale (molto grande) mediante il quale realizzare un entanglement (correlazione forte) tra tutti i qubit emessi da Alice e quelli di Eve (al momento è quasi fantascienza :-) ).
Nel paragrafo successivo passiamo quindi a considerare il problematico discorso del quantum cloner per far funzionare meglio possibile il nostro attacco individuale di Eve.
1.2. Aggirare il no-cloning theorem
Ci sono svariati lavori scientifici che cercano, in qualche modo, di aggirare il vincolo del no-cloning con dei "trucchi" tecnici più o meno validi.
Per questo piccolo studio considereremo due articoli recenti (alla data di scrittura di questa pagina web):
(1) Yamaguchi, K., & Kempf, A. (2026). "Encrypted qubits can be cloned." Physical Review Letters, 136, 010801. download here;
(2) Pigott, Brian, et al. "Eavesdropping on the BB84 Protocol using Phase-Covariant Cloning: Experimental Results." International Journal of Quantum Information, vol. 23, no. 07, 2025, download here.
Nell'articolo (1) si dimostra la realizzazione di un clonatore perfetto di stati quantistici purchè risulti criptato ossia, nel pieno rispetto del teorema del no-cloning, si dice che uno stato quantistico criptato può essere clonato senza problemi n volte nella sua interezza ma, al momento dell'impiego del clone: (a) solo 1 clone tra gli n disponibili potrà essere impiegato (tutti gli altri cloni e lo stesso stato originale si perdono); (b) la chiave di cifratura dello stato si perde anch'essa. In definitiva si tratta di un clonatore perfetto che però all'atto del suo impiego determina forti limitazioni. Di fatto sembra comportarsi come una sorta di switcher piuttosto che essere un replicatore di stati quantistici (informazioni). Di seguito riporto lo schema di uno di questi crypto-cloner da me realizzato in Google CirQ per una linea ad 1 solo qbit con chiave di cifratura ad 1 solo qbit:
Per la precisione questo schema riunisce: cifratura, clonazione e decifratura (da adesso in avanti in questa pagina lo chiameremo crypto-cloner) Lo stato |A> è quello (originale) da clonare, lo stato |S1> è il clone e lo stato |N1> è la chiave di cifratura. Come si può vedere la parte di circuito che decritta (decodifica) usa la stessa chiave di cifratura |N1> usata per cifrare. Cosa si ottiene appena prima della misura? La risposta è molto semplice e potete fare delle prove implementando il circuito come lo vedete: |A> ed |N1> vengono persi (ad esempio se misurati appaiono casuali), mentre |S1> acquisisce tutte le proprietà che |A> aveva all'origine (rivedendo i contenuti della mia pagina sui PQRNG, dove cito la porta SWAP, non è difficile capire che abbiamo fatto lo SWAP tra |A> e |S1> "consumando" |N1>).
Per completezza su alcune delle "nuove" porte impiegate nel circuito appena descritto mi limito a illustrare brevemente quanto segue. Partiamo dalla porta Z di Pauli:
La porta Z di Pauli esegue la cosiddetta inversione di fase, ossia lascia lo |0> inalterato ma |1> diviene -|1>. Eseguendo il prodotto tensoriale tra 2 porte Z si ottiene la porta ZZ (che opera quindi su 2 qbit), la cui matrice è la seguente:
La porta ZZ svolge inversione di fase solo su |01>, |10> e |11> mentre lascia inalterato |00>. La sua radice quadrata (elevazione a 0.5) determina la porta riportata nel circuito, la ZZ0.5:
Essa lascia invariati |00> e |11> ma inverte di 90° le fasi di |01> e |10>. Passiamo ora alla porta S, anch'essa presente nel circuito considerato:
La porta S è esattamente la radice quadrata della porta Z e quindi applica una rotazione di 90° attorno all'asse Z della sfera di Bloch (la Z ne applica 180°).
Passiamo ora all'articolo (2) che impiega, proprio per attaccare la QKD, un clonatore phase-covariant il quale, in generale, fa parte della classe dei clonatori approssimati di stati quantistici (la citata approssimazione lo rende compatibile con il teorema del no-cloning). La clonazione, in questo caso, non è perfetta come per il circuito precedente (articolo (1)) ma il vantaggio è che gli stati clonati sono impiegabili separatamente tra loro senza problemi. Di seguito lo schema circuitale del Clonatore quantistico fase-covariante che ho realizzato in Google CirQ seguendo le indicazioni della pubblicazione (da adesso in avanti in questa pagina lo chiameremo approximate-cloner):
Esso è indicato quale clonatore fase-covariante in quanto opera con la stessa affidabilità indipendentemente dall'angolo di fase del qbit che clona. Nel caso della QKD consideriamo angoli di fase molto particolari e non generici, come si può vedere nella sfera di Bloch che segue (per completezza ricordiamo che un qualsiasi stato quantistico si può rappresentare come segue evidenziando le fasi θ e φ:
|ψ⟩ = cos(θ/2)|0⟩ + eiφsin(θ/2)|1⟩
) per cui possiamo spingere al massimo l'affidabilità del clonatore:
in particolare, l'articolo (2) evidenzia che per tali angoli di fase dei 4 stati del QKD i valori ottimali di θ1, θ2 e θ3, per assegnare le 3 porte quantistiche Ry() sono:
θ1 = π/4 e θ2 = θ3 con π/8 < θ2 < π/4
Anche in questo caso, per completezza, mi limito a introdurre la "nuova" porta Ry(θ) usata nel circuito in ben tre posizioni:
La Ry(θ) si calcola come particolare esponenziale della matrice di Pauli Y e dato che ha coefficienti tutti reali dipendenti da θ può modificare le probabilità di misura di |0> e |1> in funzione dello stesso θ generando comunque una sovrapposizione di stati (può ricordare il funzionamento della porta H pur essendone diversa).
2. Sperimentazione su circuito quantistico
Riprendendo quanto visto nella pagina precedente sulla QKD BB84 proviamo ora ad applicare i due clonatori analizzati nel paragrafo precedente per verificare cosa accade in presenza dell'intruso Eve.
2.1 Uso del crypto-cloner (1)
Su github.com/mmattiucci2024/qkd ho inserito il software in python che implementa nello schema del QKD anche il crypto-cloner dell'articolo (1). In assenza di Eve e di errori/rumore sulla linea quantistica (caso ideale) lo schema circuitale globale è quello che segue:
QUANTUM CIRCUIT:
┌────┐
N__channel: ───────────X───────────────────────────────X───────X───S───X───────X──────────────────────────
│ │ │ │ │
QRNGalice1: ────H────M─┼───────────────────────────────┼───────┼───────┼───────┼──────────────────────────
║ │ │ │ │ │
QRNGalice2: ────H────╫M┼───────────────────────────────┼───────┼───────┼───────┼──────────────────────────
║║│ │ │ │ │
QRNGbob__1: ────H────╫╫┼M──────────────────────────────┼───────┼───────┼───────┼──────────────────────────
║║│║ │ │ │ │
Q__channel: ─────────╫╫┼╫────X───H───ZZ───────XX───────┼───────┼───────┼───────┼──────────────────────────
║║│║ ║ ║ │ │ │ │ │ │
S__channel: ────H────╫╫@╫────╫───╫───ZZ^0.5───XX^0.5───@───H───@───────@───H───@───H───M('bob_measure')───
║║ ║ ║ ║ ║
QRNGalice1m: ════════@╬═╬════^═══╬═════════════════════════════════════════════════╬══════════════════════
║ ║ ║ ║
QRNGalice2m: ═════════@═╬════════^═════════════════════════════════════════════════╬══════════════════════
║ ║
QRNGbob__1m: ═══════════@══════════════════════════════════════════════════════════^══════════════════════
└────┘
Come si può vedere il canale principale Q__channel viene clonato in S__channel per poi passare a Bob, inoltre esiste un canale quantistico ulteriore N__channel che occorre per la cifratura. In pratica il canale principale finisce la sua strada ed S__channel prende le sue informazioni. Il risultato della simulazione CirQ che segue è che il tutto per la QKD è perfettamente trasparente, il circuito si comporta per il protocollo QKD come se il clonatore non ci fosse:
Alice sent 200 random bit(s) over the quantum channel.
The quantum channel is free of depolarizing noise.
The quantum channel is free of amplitude damping noise.
Alice and Bob sifting:
Bob sends to Alice the sequence of the random bases it used:
11011100111001000001011101110101010000111000101011110001101000001000100101000001010101010000111100111011101100101100100111110010100111100001011010111001101010101101111001011110100011011101001110011101
Alice sends back to Bob the positions of the bits where the bases match:
1 4 5 8 10 14 15 17 18 20 21 22 23 28 29 32 33 34 35 36 37 39 41 43 44 45 46 47 48 49 50 51 57 59 60 62 64 67 72 74 76 77 78 80 81 84 86 89 93 95 97 100 102 104 105 107 109 110 111 112 115 117 121 124 125 126 128 129 131 132 133 134 136 138 139 140 148 150 152 153 154 155 157 158 162 163 164 166 167 169 170 172 174 175 176 177 178 179 181 182 183 186 187 190 191 193 194 195 196 199
Alice (A) and Bob (B) sifted keys (bit errors in red):
A: 00011111001011110110010110101101000010100111001101011100110110011001101010100111100100000111001010110111000111
B: 00011111001011110110010110101101000010100111001101011100110110011001101010100111100100000111001010110111000111
Alice shared 110 bit(s) out of 200 bit(s) with Bob via the QKD sifting process.
Bob ERRORS= 0 bit(s) - QBER_BOB= 0.0
Alice and Bob retain the 110 shared bits.
La QBER di Bob è nulla e la chiave filtrata corrisponde perfettamente tra Alice e Bob. Il clonatore non introduce rumore o errori. Vediamo quindi cosa accade se introduciamo la presenza dell'intruso Eve che avrebbe, al suo interno proprio il citato clonatore. Lo schema circuitale diviene il seguente:
QUANTUM CIRCUIT:
┌────┐ ┌─────────────────┐
N__channel: ───────────X────────────────────────────────X────────────────────────X───S───X───────X──────────────────────────
│ │ │ │ │
QRNGalice1: ────H────M─┼────────────────────────────────┼────────────────────────┼───────┼───────┼──────────────────────────
║ │ │ │ │ │
QRNGalice2: ────H────╫M┼────────────────────────────────┼────────────────────────┼───────┼───────┼──────────────────────────
║║│ │ │ │ │
QRNGbob__1: ────H────╫╫┼M───────────────────────────────┼────────────────────────┼───────┼───────┼──────────────────────────
║║│║ │ │ │ │
Q__channel: ─────────╫╫┼╫────X───H───ZZ───────XX────────┼M('eve_measure')────────┼───────┼───────┼──────────────────────────
║║│║ ║ ║ │ │ │ │ │ │
S__channel: ────H────╫╫@╫────╫───╫───ZZ^0.5───XX^0.5────@────────────────────H───@───────@───H───@───H───M('bob_measure')───
║║ ║ ║ ║ ║
QRNGalice1m: ════════@╬═╬════^═══╬═══════════════════════════════════════════════════════════════════╬══════════════════════
║ ║ ║ ║
QRNGalice2m: ═════════@═╬════════^═══════════════════════════════════════════════════════════════════╬══════════════════════
║ ║
QRNGbob__1m: ═══════════@════════════════════════════════════════════════════════════════════════════^══════════════════════
└────┘ └─────────────────┘
e il risultato della simulazione CirQ è quello che segue:
Alice sent 200 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: 00101101000010101110111100001101110000101000110110101101100001101011000000110010001100111110110100011100100110000101101111010011100111001100111110101101001010101011100100011001111110100001001100011011 Alice sends back to Bob the positions of the bits where the bases match: 1 5 6 8 9 10 13 15 16 18 19 20 21 22 23 24 26 27 29 30 34 38 40 44 46 50 53 54 55 59 60 63 68 72 74 77 79 87 88 89 90 92 97 100 101 107 113 114 116 120 121 122 123 126 127 130 132 135 137 139 140 141 144 146 154 155 158 159 162 163 167 169 174 176 178 180 181 182 183 185 188 189 191 192 193 194 Alice (A), Bob (B), and Eve (E) sifted keys (bit errors in red): A: 11100101100010100111110001011101001010111000100100100110010110011001100010110111110010 B: 11100101100010100111110001011101001010111000100100100110010110011001100010110111110010 E: _1__1_111__1_10_0_10_0_1101__01_1__01_______0___0_1_10000_00__0______01__101__001__000 Alice shared 86 bit(s) out of 200 bit(s) with Bob via the QKD sifting process. Eve intercepted 43 bit(s) of the shared key with 25 wrong bit(s). Bob ERRORS= 0 bit(s) - QBER_BOB= 0.0 Alice and Bob retain the 86 shared bits.
Alice e Bob comunque ritengono i bit della chiave filtrata perchè non possono accorgersi dell'intruso dato che il QBER è ancora nullo. Eve però intercetta dopo il sifting solo la metà dei bit e di questi un'altra metà (più o meno) è errata. In pratica Eve svolge un'azione di intrusione trasparente al sistema ma non riesce a rilevare una congrua quantità di bit della chiave finale ed inoltre non ha neanche un criterio per capire o compensare i suoi errori di intercettazione.
In definitiva si può dimostrare che l'uso di un crypto-cloner non introduce, per Eve, valore aggiunto rispetto ad indovinare a caso il valore dei bit della chiave conoscendo le basi di Alice e Bob. Il metodo di intrusione provato, quindi, è davvero poco efficace.
2.2 Uso del approximate-cloner (2)
Proviamo ora a inserire nel circuito ideale della QKD il Clonatore quantistico fase-covariante dell'articolo (2) che è a tutti gli effetti un clonatore (che non impiega il cripto) ma opera con una certa approssimazione (non è perfetto). Sempre su github.com/mmattiucci2024/qkd ho inserito il software in python per questa situazione, il circuito CirQ è il seguente:
QUANTUM CIRCUIT:
┌───┐
A__channel: ────────────────X──────Ry(0.38π)───@───────────────────X───────@──────────────────────────
│ │ │ │
CQ_channel: ────Ry(0.5π)────@──────────────────X───Ry(0.38π)───X───┼───@───┼──────────────────────────
│ │ │ │
QRNGalice1: ────H───────────M──────────────────────────────────┼───┼───┼───┼──────────────────────────
║ │ │ │ │
QRNGalice2: ────H───────────╫M─────────────────────────────────┼───┼───┼───┼──────────────────────────
║║ │ │ │ │
QRNGbob__1: ────H───────────╫╫M────────────────────────────────┼───┼───┼───┼──────────────────────────
║║║ │ │ │ │
Q__channel: ────────────────╫╫╫────X───────────H───────────────@───@───X───X───H───M('bob_measure')───
║║║ ║ ║ ║
QRNGalice1m: ═══════════════@╬╬════^═══════════╬═══════════════════════════════╬══════════════════════
║║ ║ ║
QRNGalice2m: ════════════════@╬════════════════^═══════════════════════════════╬══════════════════════
║ ║
QRNGbob__1m: ═════════════════@════════════════════════════════════════════════^══════════════════════
└───┘
che simulato in CirQ produce il seguente output:
Alice sent 200 random bit(s) over the quantum channel. The quantum channel is free of depolarizing noise. The quantum channel is free of amplitude damping noise. Alice and Bob sifting: Bob sends to Alice the sequence of the random bases it used: 00100011111010110111101010001001000010001110100100101111000010110101001000111010010101001101100011110010010110010100101101111100000110101111010000110010101010111101010000010000011010110100011111110000 Alice sends back to Bob the positions of the bits where the bases match: 0 2 9 16 19 24 26 31 33 36 37 38 41 42 45 46 48 53 54 56 60 62 63 64 67 73 74 77 80 81 83 84 85 86 90 93 95 97 98 99 102 103 104 105 106 107 111 112 114 115 117 120 121 126 132 133 134 135 137 140 141 142 143 144 145 149 151 153 155 156 158 159 162 163 164 165 166 168 175 177 181 182 183 186 189 192 195 199 Alice (A) and Bob (B) sifted keys (bit errors in red): A: 11011011000 0 110100110 1 01 0 010100111 1 110110101001 0 111001011111010111 1 1110111010100 0 0011111 B: 11011011000 1 110100110 0 01 1 010100111 0 110110101001 1 111001011111010111 0 1110111010100 1 0011111 Alice shared 88 bit(s) out of 200 bit(s) with Bob via the QKD sifting process. Bob ERRORS= 7 bit(s) - QBER_BOB= 0.07954545454545454 Alice and Bob retain the 88 shared bits, but Bob needs to correct 7 bit(s).
La più importante conclusione di questa simulazione e di altre simili che si possono lanciare è che lo schema QKD risente della presenza del clonatore fase-covariante dell'articolo (2) introducendo un QBER diverso da zero. Si tratta di un QBER di molto inferiore alla soglia 0.11 che normalmente si considera di accettabilità per cui Alice e Bob comunque aderiscono sulla chiave filtrata e iniziano poi una fase di correzione errori. In definitiva, però, nel circuito QKD ideale la semplice introduzione del clonatore approssimato considerato viene facilmente rilevata in quanto il QBER non è più nullo. Similmente, si può dire che il clonatore in questione è egli stesso considerato come un intruso dal circuito QKD, una sorta di Eve, anche se non rileva/misura nessun dato.
Proviamo quindi a inserire un intruso Eve che impieghi questo clonatore approssimato al suo interno:
QUANTUM CIRCUIT:
┌───┐ ┌──┐
A__channel: ────────────────X──────Ry(0.3π)───@──────────────────X────────@───────────────────────────────────────────
│ │ │ │
CQ_channel: ────Ry(0.5π)────@─────────────────X───Ry(0.3π)───X───┼───@────┼H────M('eve_measure')──────────────────────
│ │ │ │
QRNGalice1: ────H───────────M────────────────────────────────┼───┼───┼────┼───────────────────────────────────────────
║ │ │ │ │
QRNGalice2: ────H───────────╫M───────────────────────────────┼───┼───┼────┼───────────────────────────────────────────
║║ │ │ │ │
QRNGbob__1: ────H───────────╫╫M──────────────────────────────┼───┼───┼────┼───────────────────────────────────────────
║║║ │ │ │ │
Q__channel: ────────────────╫╫╫────X──────────H──────────────@───@───X────X─────H──────────────────M('bob_measure')───
║║║ ║ ║ ║
QRNGalice1m: ═══════════════@╬╬════^══════════╬═════════════════════════════════╬═════════════════════════════════════
║║ ║ ║
QRNGalice2m: ════════════════@╬═══════════════^═════════════════════════════════╬═════════════════════════════════════
║ ║
QRNGbob__1m: ═════════════════@═════════════════════════════════════════════════^═════════════════════════════════════
└───┘ └──┘
Il CQ_channel è il clone approssimato che si determina dentro Eve e quello che lo stesso Eve misura, mentre il Q__channel originale passa come sempre a Bob. Quindi Eve non opera sullo stesso canale di Bob ma solo sul suo clone. Andando a simulare in CirQ questo circuito si vede quanto segue:
Alice sent 200 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: 11001010010010000010011001010010100100110010100010111100100100101011011001000000111110111100011101000010111000001000011001101101100110100010000010011101100000110101001000001000001000111111011000100111 Alice sends back to Bob the positions of the bits where the bases match: 0 1 2 4 5 7 8 10 11 12 13 14 16 20 21 22 24 25 28 36 37 39 41 42 44 46 49 53 58 61 63 65 66 69 71 77 78 81 84 92 93 94 95 96 97 98 100 102 103 105 106 110 111 114 115 117 123 124 128 130 131 137 138 139 140 142 146 148 150 151 152 153 158 160 161 162 165 166 167 168 169 171 172 175 177 178 179 180 182 186 188 189 191 192 196 199 Alice (A), Bob (B), and Eve (E) sifted keys (bit errors in red): A: 11110011 1 001111110 0 011110 0 110000011010100001 0 011 1 0010 1 0001001 1 0111100100 1 010 1 00 1 0100001101000011 B: 11110011 0 001111110 1 011110 1 110000011010100001 1 011 0 0010 0 0001001 0 0111100100 0 010 0 00 0 0100001101000011 E: _0111_10 1 00___11__ 0 00__00 0 1_00______11__00__ _ 0__ _ 0_10 _ __0_001 _ 0_0____0__ _ 0_1 _ 00 1 01__10_0_1__1_1_ Alice shared 96 bit(s) out of 200 bit(s) with Bob via the QKD sifting process. Eve intercepted 48 bit(s) of the shared key with 12 wrong bit(s). Bob ERRORS= 10 bit(s) - QBER_BOB= 0.10416666666666667 Alice and Bob retain the 96 shared bits, but Bob needs to correct 10 bit(s).
Il QBER di Bob si è alzato molto rispetto a prima e se si considera la QKD ideale è evidente ad Alice e Bob la presenza dell'intruso. Si noti però che si è ancora entro la soglia di accettabilità del QBER (0.11) e che Eve ha meno errori sui bit "intercettati" rispetto a quelli che aveva con il cripto-clone. In questo contesto diviene rilevante introdurre il rumore e gli errori sulla linea quantistica perchè in tale situazione il QBER nullo per Bob è praticamente impossibile anche senza intruso e l'introduzione del clonatore approssimato potrebbe non elevare a sufficienza il QBER stesso rendendo l'intruso praticamente trasparente.
Di seguito circuito e risultato di simulazione in presenza di rumore sulla linea quantistica principale:
QUANTUM CIRCUIT:
┌───┐ ┌──┐
A__channel: ────────────────X──────Ry(0.38π)───@───────────────────X────────@──────────────────────────────────────────────────────────
│ │ │ │
CQ_channel: ────Ry(0.5π)────@──────────────────X───Ry(0.38π)───X───┼───@────┼H────M('eve_measure')─────────────────────────────────────
│ │ │ │
QRNGalice1: ────H───────────M──────────────────────────────────┼───┼───┼────┼──────────────────────────────────────────────────────────
║ │ │ │ │
QRNGalice2: ────H───────────╫M─────────────────────────────────┼───┼───┼────┼──────────────────────────────────────────────────────────
║║ │ │ │ │
QRNGbob__1: ────H───────────╫╫M────────────────────────────────┼───┼───┼────┼──────────────────────────────────────────────────────────
║║║ │ │ │ │
Q__channel: ────────────────╫╫╫────X───────────H───────────────@───@───X────X─────D(0.04)────────────AD(0.09)───H───M('bob_measure')───
║║║ ║ ║ ║
QRNGalice1m: ═══════════════@╬╬════^═══════════╬════════════════════════════════════════════════════════════════╬══════════════════════
║║ ║ ║
QRNGalice2m: ════════════════@╬════════════════^════════════════════════════════════════════════════════════════╬══════════════════════
║ ║
QRNGbob__1m: ═════════════════@═════════════════════════════════════════════════════════════════════════════════^══════════════════════
└───┘ └──┘
Alice sent 200 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 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: 11111011001110100101011000010000111101100001011010101110100100000001011010011001000000010010010011100111001111010111111101110000100101100110111001001110000011001111011010011101000100001001011110100100 Alice sends back to Bob the positions of the bits where the bases match: 2 3 4 7 9 10 13 14 15 17 20 22 23 26 29 30 31 32 33 34 38 39 40 42 44 45 48 49 51 54 56 57 58 61 63 66 67 68 69 74 78 79 80 81 82 83 84 86 87 88 90 91 93 94 97 98 99 102 103 104 105 109 111 112 113 114 118 119 120 125 128 129 130 132 135 136 137 138 139 141 142 143 145 147 148 150 151 154 155 156 157 159 160 162 164 166 167 169 171 173 175 177 182 183 185 191 192 193 194 195 197 198 Alice (A), Bob (B), and Eve (E) sifted keys (bit errors in red): A: 11110001101001101100100 1 0 01001011110110011100001101 0 0 1 11001 0 000001000100 0 10 0 11 1 001010 1 0100001010001000 1 101001110 B: 11110001101001101100100 0 1 01001011110110011100001101 1 0 0 11001 1 000001000100 1 10 1 11 0 001010 0 0100001010001000 0 101001110 E: 0____111_1_0_10__11_1__ _ 1 10_0______0_000__1_011100_ 0 _ 1 110__ _ _1_101011___ 0 10 0 1_ 1 __10__ 1 1_0__1___0100__0 1 00____1_0 Alice shared 112 bit(s) out of 200 bit(s) with Bob via the QKD sifting process. Eve intercepted 60 bit(s) of the shared key with 22 wrong bit(s). Bob ERRORS= 10 bit(s) - QBER_BOB= 0.08928571428571429 Alice and Bob retain the 112 shared bits, but Bob needs to correct 10 bit(s).
Si può facilmente notare che in presenza di rumore la situazione migliora, nel senso che è più difficile per Alice e Bob capire che c'è un intruso. In realtà, come vedremo nel prossimo paragrafo, le simulazioni di cui sopra sono state svolte basandosi su parametri adattati ai diversi contesti considerati mediante un ottimizzatore statistico. Quindi, facendo opportuno tuning, è possibile migliorare l'invisibilità dell'intruso Eve e tenerne contenuti i bit errati da questi intercettati. Una rapida occhiata all'output precedente permette di vedere che gli errori commessi da Eve sono percentualmente inferiori a quelli nei casi precedenti. Si tratta purtroppo (o fortunatamente per la QKD) sempre di intercettazioni molto limitate quantitativamente delle chiavi filtrate ma questo studio occorre per capire che più si opera in un contesto reale e più l'inattaccabilità della QKD può essere messa in discussione.
2.3 Ottimizzazione del approximate-cloner (2)
Dalle sperimentazioni CirQ dei paragrafi precedenti appare evidente che il clonatore approssimato fase-covariante dell'articolo (2) è sicuramente migliore per l'intrusione di quello cripto (1).
Proprio il clonatore approssimato dipende, come visto nel par. 1.2, dalla scelta di alcuni parametri θ per i quali l'articolo dimostra le condizioni:
θ1 = π/4 e θ2 = θ3 con π/8 < θ2 < π/4mentre quindi il θ1 è praticamente definito, su θ2 e conseguentemente θ3 c'è spazio di manovra per un'azione di ottimizzazione statistica.
In particolare, sempre in un software python CirQ che ho inserito in github.com/mmattiucci2024/qkd ho realizzato un sistema di valutazione delle prestazioni dell'intrusione al variare di θ2 tra i due limiti imposti. Il citato intervallo di valori è stato diviso in 1000 parti e su un grafico che ha sulle ascisse i numeri da 0 a 1000 sono stati riportati i tre grafici di:
a. QBER medio di Bob;
b. QBER medio di Eve;
c. Percentuale media di bit della sifted key che Eve è in grado di intercettare.
In pratica ogni punto i delle ascisse da 0 a 1000 rappresenta un'assegnazione di:
θ2 = π/8 + (π/4 - π/8) * i/1000e per ogni assegnazione i di θ2 vengono svolte N = 100 simulazioni quantistiche con CirQ andando a rilevare e memorizzare ogni volta QBER di Bob, QBER di Eve e Percentuale di bit intercettati da Eve per poi farne la media aritmetica alla fine (valori riportati nel grafico che segue).
Passiamo subito a considerare i risultati di questo processo di valutazione nel caso ideale di canale quantistico senza rumore:
La linea verde si riferisce alla percentuale media di bit della sifted key che Eve riesce a intercettare dato un certo valore di θ2 e come si può facilmente vedere si attesta praticamente sul 50% e rimane ivi costante. Questo significa che tale percentuale media non è sostanzialmente influenzata dal variare di θ2.
La linea blu si riferisce al QBER medio di Bob e si può facilmente vedere che tende a 0 all'aumentare di θ2 verso π/4, inoltre è il caso di osservare che anche la sua variabilità si affievolisce sempre al crescere di θ2.
La linea rossa si riferisce al QBER medio di Eve (sui bit intercettati) che tende a crescere all'aumentare di θ2 verso π/4, e anche la sua variabilità aumenta sempre al crescere di θ2.
Ricordando che la soglia 0.11 per il QBER di Bob è molto importante, consentendo ad Alice e Bob di stabilire in specifiche sessioni di test delle comunicazione se la linea è da considerare affidabile, si può impostare il seguente criterio di ottimalità:
si traccia la linea tratteggiata gialla parallela alle ascisse e si trova facilmente l'intersezione con il grafico del QBER medio di Bob (blu), considerando che tale funzione risulta monotona decrescente in senso stretto, il corrispondente valore della ascisse indica proprio quale θ2 scegliere.
Dal grafico, il θ2 risulta da una i = 280 e quindi, dalla formula di cui sopra:
θ2 = θ* ≈ 0.325 πDa questo valore di θ2 a crescere, Alice e Bob considerano la linea affidabile (quindi non vedono l'intruso Eve), non conviene però andare oltre θ* in quanto, corrispondentemente, il QBER di Eve aumenta rendendo l'intercettazione meno affidabile.
Sempre dal grafico, il θ*, la nostra scelta statisticamente ottimale del parametro per il clonatore approssimato di Eve, permette anche di stimare (con una linea verticale) il QBER medio ottimale di Eve che risulta circa 0.2998.
Quindi Eve riesce a "carpire" circa il 50% dei bit della chiave filtrata da Alice e Bob senza che questi lo "vedano" ma di tali bit mediamente il 30% è errato.
Ripetendo l'esperimento di ottimizzazione numerica per il caso in cui il canale quantistico di comunicazione è affetto da rumore si ha il grafico:
Dal grafico, il θ* questa volta risulta da una i = 490, che, secondo la solita formula porta a:
θ2 = θ* ≈ 0.375 π e valore medio QBER(Eve) ≈ 0.38da cui Eve riesce a "carpire" circa il 50% dei bit della chiave filtrata da Alice e Bob senza che questi lo "vedano" ma di tali bit mediamente il 38% è errato.
3. Conclusioni
Il software realizzato permette delle simulazioni e delle ottimizzazioni inerenti alla possibilità di intercettare la chiave segreta della QKD almeno parzialmente.
Sebbene si tratti di una simulazione numerica (con e senza rumore sulla linea) i risultati fanno vedere come il settore dei clonatori approssimati prometta bene garantendo almeno la non visibilità dell'intruso ai due nodi che condividono la chiave segreta.
In ogni caso la QKD è ben lungi dall'essere "sconfitta" dato che i risultati statistici, per quanto ottimizzati, forniscono a Eve errori di cattura dei bit della chiave mediamente superiori a quelli che si potrebbero avere tentando di indovinare la chiave a caso (questo non è dimostrato in questa pagina ma si può calcolare).
Il settore degli attacchi alla QKD deve ancora fare molti passi avanti per potersi ritenere efficace e impiegabile (anche solo in teoria e nei casi migliori) e quindi la QKD è sicuramente una tecnologia che mantiene, a mio avviso e attualmente, un'alta affidabilità se ben impiantata su linee quantistiche adeguatamente prive di errori e rumore.
In questo lavoro ho solo voluto portare in evidenza interessanti studi molto recenti (2026) sui clonatori quantistici e li ho applicati a dei casi di attacchi individuali al key agreement, anche per evidenziare l'importanza di queste analisi nella cybersecurity attuale.
Cookie(s) & Privacy
Questo sito web, per quanto da me programmato e realizzato in php, non emette cookie, non effettua il profiling dell'utente e non raccoglie vostri dati personali. Alcuni cookie possono essere emessi dal cloud che lo supporta, strumento al di fuori della possibilità di controllo dello scrivente. Per qualsiasi dubbio in proposito smettete immediatamente la navigazione.marcomattiucci.it
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)