Criptografia quàntica (i II)

by marti

Ve de “Criptografia quàntica (I)”.

Aquesta segona part de l’article explica el BB84, el primer protocol de criptografia quàntica i també el més senzill. Aquest protocol el van proposar el 1984 Charles H. Bennet, d’IBM New York, i Gilles Brassard, de la Universitat de Montréal.

Estats i bases

En aquest protocol s’utilitza un sistem quàntic de dos nivells, és a dir, que qualsevol estat posible d’aquest sistema es pot representar mitjançant una combinació lineal de dos estats que formen una base. D’aquest sistema s’utilitzen dues bases, cada una formada per dos estats, de manera que en total estarem utilitzant quatre estats diferents.

Normalment s’utilitza la polartització de la llum: els fotons, que es poden entendre com paquets indivisibles de llum. Cada fotó pot estar polaritzat verticalment |\uparrow\,\rangle, horitzontalment |\to\,\rangle, +45 graus |\nearrow\,\rangle o -45 graus |\searrow\,\rangle. Els dos primers formen la base horitzontal-vertical +, i els dos últims la base diagonal \times.

Així, si mesurem l’estat |\uparrow\,\rangle amb la base + obtenim el mateix estat amb probabilitat 1, ja que estem mesurant un estat que és “propi” de la base utilitzada. Si en canvi mesurem l’estat |\nearrow\,\rangle amb la base +, podem obtenir o bé |\uparrow\,\rangle amb probabilitat 0.5 o bé |\to\,\rangle amb probabilitat 0.5, ja que l’estat no és propi de la base utilitzada. Per conveni, s’assigna el valor binari 0 als estats |\uparrow\,\rangle|\nearrow\,\rangle i el valor 1 als altres dos. A aquests estats se’ls anomena qubits, de quantum bits.

El protocol

Vist això, el protocol segueix uns passos molt senzills. Suposem que l’Alice i en Bob volen crear una clau, i que l’Eve els espia per intentar conèixer quina clau faran servir.

Primer, l’Alice genera aleatòriament una cadena de fotons, cada un amb una polarització a l’atzar, i els envia a en Bob. La cadena pot ser realment aleatòria, i no simplement pseudoaleatòria, perquè pot utilitzar la mecànica quàntica.

En Bob mesura els estats que li van arribant de l’Alice, cada vegada amb una de les dues bases + o \times a l’atzar. D’aquesta manera, si l’estat que li arriba és propi de la base amb què mesura, obté el mateix estat que li ha arribat, mentre que si li arriba un estat que no és propi, obté la meitat de resultats bons i la meitat de dolents. Com que aproximadament en la meitat dels casos haurà utilitzat la base bona i en l’altra meitat la dolenta, en resum en Bob obté l’anomenada raw key o clau en brut, que té aproximadament un 25% d’errors.

Evidentment, no pot fer servir aquesta clau perquè hi ha massa errors. El que fa en Bob ara és anunciar públicament quina base ha utilitzat cada vegada, i l’Alice respon públicament si la base que en Bob ha utilitzat cada vegada és bona o no, és a dir, si l’estat que enviava era propi d’aquesta base o no. Això no revela cap mena d’informació, perquè l’únic que s’ha fet públic és la base utilitzada, i no el bit transmès cada vegada.

Així doncs, tant l’Alice com en Bob es queden amb els estats mesurats amb bases bones i descarten els dolents, de manera que es queden amb la shifted key, aproximadament la meitat de llarga que la raw key però sense cap error.

Posant un exemple, l’Alice podria enviar, a l’atzar, els estats

| \nearrow \, \rangle | \to \, \rangle | \uparrow \, \rangle | \uparrow \, \rangle | \searrow \, \rangle | \searrow \, \rangle | \to \, \rangle | \nearrow \, \rangle

En Bob els mesuraria utilitzant les bases, també escollides a l’atzar,

+ + \times + \times + \times \times

Quan en Bob mesura l’estat mesura amb la base compatible, obté el mateix qubit que li havia enviat l’Alice. Quan mesura amb la base incompatible, pot obtenir amb igual probabilitat un resultat o un altre. Per exemple, quan mesuri | \nearrow \, \rangle amb la base + pot obtenir o bé | \uparrow \, \rangle o bé | \to \, \rangle, que són els dos estats propis de la base amb què ha mesurat.

Després d’haver mesurat, en Bob anunciaria les bases que ha utilitzat i l’Alice li diria que només s’ha de quedar amb els resultats 2, 4, 5 i 8. Resumint, i fent servir el conveni de 0 i 1 d’abans,

\begin{array}{lcccccccc}  \textrm{Enviat per l'Alice:} & | \nearrow \, \rangle & | \to \, \rangle & | \uparrow \, \rangle & | \uparrow \, \rangle & | \searrow \, \rangle & | \searrow \, \rangle & | \to \, \rangle & | \nearrow \, \rangle \\  \textrm{Base d'en Bob:} & + & + & \times & + & \times & + & \times & \times \\  \textrm{Rebut per en Bob:} & | \uparrow \, \rangle & | \to \, \rangle & | \searrow \, \rangle & | \uparrow \, \rangle & | \searrow \, \rangle & | \to \, \rangle & | \nearrow \, \rangle & | \nearrow \, \rangle \\  \textrm{Acceptat:} & & | \to \, \rangle & & | \uparrow \, \rangle & | \searrow \, \rangle & & & | \nearrow \, \rangle \\  \textrm{Shifted key:} & & 1 & & 0 & 1 & & & 0  \end{array}

El canal que utilitzen l’Alice i en Bob no cal que sigui confidencial. Això és així perquè Eve no pot interceptar qubits i reenviar-los en el seu estat original mantenint-ne una còpia. És l’anomenat teorema de no clonació (No cloning theorem), demostrat per Wootters i Zurek el 1982. L’Eve simplement es podria quedar el qubit, i no reenviar-ne cap a en Bob, però llavors en Bob podria avisar l’Alice que descartés el qubit que no ha rebut.

Estratègia d’interceptar-reenviar

Tanmateix, l’Eve pot dur a terme un senzill atac consistent en mesurar a l’atzar amb una de les dues bases possibles cada qubit que l’Alice envia a en Bob, i una vegada mesurat enviar a en Bob el qubit corresponent al resultat obtingut. Així, en un 50% dels casos l’Eve mesurarà amb la base correcta, sense modificar l’estat, obtenint la informació i sense que l’Alice o en Bob ho puguin detectar. En l’altre 50% dels casos, utilitzarà la base incorrecta. Llavors, el qubit enviat tindrà un 50% de probabilitat de ser mesurat per en Bob com si fos el correcte, i un 50% com si fos l’incorrecte.

Resumint, mesurant tots els estats enviats l’Eve obté un 50% de la informació, mentre que l’Alice i en Bob acaben amb una shifted key que té un 25% d’errors. Aquest nivell d’errors és detectable, però si Eve només interceptés el 10% dels qubits enviats, obtindria un 5% de la informació mentre que l’error final de la shifted key seria tan sols d’un 2.5%, que és comparable a l’error obtingut per causes tècniques.

Utilitzant el mateix exemple, l’Alice envia els mateixos estats i en Bob utilitza les mateixes bases, abans que els qubits arribin a en Bob l’Eve els mesura amb les seves bases, també escollides a l’atzar. Així,

\begin{array}{lcccccccc}  \textrm{Enviat per l'Alice:} & | \nearrow \, \rangle & | \to \, \rangle & | \uparrow \, \rangle & | \uparrow \, \rangle & | \searrow \, \rangle & | \searrow \, \rangle & | \to \, \rangle & | \nearrow \, \rangle \\  \textrm{Base de l'Eve:} & \times & + & \times & \times & \times & + & \times & + \\  \textrm{Rebut i enviat per l'Eve:} & | \nearrow \, \rangle & | \to \, \rangle & | \nearrow \, \rangle & | \searrow \, \rangle & | \searrow \, \rangle & | \to \, \rangle & | \searrow \, \rangle & | \to \, \rangle \\  \textrm{Base d'en Bob:} & + & + & \times & + & \times & + & \times & \times \\  \textrm{Rebut per en Bob:} & | \uparrow \, \rangle & | \to \, \rangle & | \nearrow \, \rangle & | \uparrow \, \rangle & | \searrow \, \rangle & | \to \, \rangle & | \searrow \, \rangle & | \searrow \, \rangle \\  \textrm{Acceptat:} & & | \to \, \rangle & & | \uparrow \, \rangle & | \searrow \, \rangle & & & | \searrow \, \rangle \\  \textrm{Shifted key de l'Alice:} & & 1 & & 0 & 1 & & & 0 \\  \textrm{Shifted key de l'Eve:} & & 1 & & - & 1 & & & - \\  \textrm{Shifted key d'en Bob} & & 1 & & 0 & 1 & & & 1  \end{array}

Com es veu, les claus de l’Alice i en Bob tenen errors (en aquest cas, en l’últim bit). Per la seva banda, l’Eve ha aconseguit informació parcial sobre la clau. Sap que el primer i el tercer bit de la shifted key són un 1, i s’ha adonat que els qubits mesurats en segon i quart lloc són probablement incorrectes perquè la seva base no coincideix amb la d’en Bob (que s’ha fet pública).

Per saber si l’Eve ha espiat la seva comunicació, l’Alice i en Bob poden comparar una part aleatòria de la shifted key i estimar-ne l’error. Si el nivell d’errors és acceptable dins els marges tècnics, accepten la clau, descartant evidentment la part comparada; sinó, tornen a començar el protocol.

Correcció d’errors i ampliació de privacitat

Els dos últims passos en un protocol de criptografia quàntica utilitzen algoritmes clàssics: d’una banda, per corregir els errors de la clau, i de l’altra, per reduir la informació que té l’Eve de la clau final. Aquests algortimes van ser proposats inicialment per Bennett, Brassard i Robert (1988).

En primer lloc, cal corregir els errors en la clau, que poden ser deguts tant a causes tècniques com a l’Eve. En el cas més simple d’algoritme de correcció d’errors, l’Alice escull una parella aleatòria de bits i els suma XOR, és a dir, 0\oplus0=00\oplus1=11\oplus0=1 i 1\oplus1=0. Si la suma corresponent d’en Bob coincideix, l’Alice i en Bob mantenen el primer bit i rebutgen el segon. Si la suma no coincideix, rebutgen els dos. A la pràctica, s’utilitzen algoritmes més sofisticats i eficients.

Després de la correcció d’errors, l’Alice i en Bob tenen claus idèntiques, però l’Eve encara pot tenir informació. Per reduir-la, l’Alice suma XOR altra vegada dos bits aleatoris, i en Bob fa el mateix amb els seus corresponents. Llavors, l’Alice i en Bob es queden només amb el resultat de la suma. Així, si l’Eve no té informació d’algun dels dos bits, no té cap mena d’informació de la seva suma XOR.

En resum, la criptografia quàntica només s’aplica en la creació i distribució d’una clau simètrica. A més, el canal necessita autentificació: l’Alice i en Bob poden utilitzar un canal no confidencial però han de saber que efectivament l’altra persona és qui diu ser. Per a fer-ho, poden utilitzar una clau més curta, i llavors amb la criptografia quàntica n’obtenen una de més llarga, de la qual en poden guardar una part per a la següent sessió.

About these ads