Upload 17 files

README.md

@@ -1,14 +1,105 @@
----
-title: QuantumCrypt
-emoji: 🏢
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.17.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Applied quantum cryptography
----
+# QuantumCrypt
+
+## BB84
+
+## Introduction
+The BB84 protocol is a Quantum Key Distribution (QKD) scheme developed by Charles Bennett and Gilles Brassard in 1984. It enables two parties, traditionally called Alice and Bob, to securely share a secret key, ensuring resistance against eavesdropping attempts by an adversary (Eve).
+
+## Working Principle
+BB84 leverages quantum mechanics to ensure secure communication. It relies on the properties of photon polarization and Heisenberg's uncertainty principle, making it impossible for an eavesdropper to measure photon states without disturbing the transmission.
+
+The protocol operates as follows:
+1. **Photon Transmission:** Alice sends a sequence of randomly polarized photons in one of two possible bases (rectilinear `+` or diagonal `×`).
+2. **Random Measurement:** Bob measures each received photon using a randomly chosen basis.
+3. **Basis Comparison:** Alice and Bob publicly compare the bases used for each photon and discard cases where Bob used the incorrect basis.
+4. **Key Extraction:** The remaining bits form a shared secret key.
+5. **Error Checking:** Alice and Bob verify key integrity by publicly comparing a subset of the bits. If errors exceed a threshold, they abort the protocol.
+6. **Privacy Amplification:** If necessary, they apply classical error correction and privacy amplification techniques to refine the final secret key.
+
+## Security
+The security of BB84 is based on the no-cloning theorem, which prevents an adversary from perfectly copying an unknown quantum state. Any attempt by Eve to measure photons introduces detectable errors, allowing Alice and Bob to discard compromised keys.
+
+## Applications
+- Secure communication
+- Quantum cryptography
+- Future-proof encryption against quantum computing attacks
+
+
+
+# E91
+
+## Overview
+
+This project demonstrates how Alice and Bob can securely exchange a cryptographic key using the **E91 Quantum Key Distribution (QKD) Protocol**. The protocol, developed by **Artur Ekert in 1991**, leverages quantum entanglement and **Bell's theorem** to ensure that an eavesdropper, Eve, cannot gain any information about the key without detection.
+
+## Encryption and the One-Time Pad
+
+To ensure message confidentiality, Alice encrypts her message using the **one-time pad** technique. This method relies on the **exclusive OR (XOR) operation** to combine the plaintext and a randomly generated key:
+
+$$ c_i = m_i \oplus k_i $$
+
+where:
+- \( m \) is the plaintext message,
+- \( k \) is the secret key,
+- \( c \) is the ciphertext.
+
+Decryption is performed using the same XOR operation:
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+$$ m_i = c_i \oplus k_i $$
+
+Since the security of the **one-time pad** depends on the secrecy of the key, the main challenge is securely distributing this key between Alice and Bob. This is where quantum mechanics comes into play.
+
+## The E91 Quantum Key Distribution Protocol
+
+The **E91 protocol** ensures secure key exchange using **quantum entanglement**. The steps are as follows:
+
+### 1. Entangled Qubits Distribution
+Charlie (a trusted third party) generates **N pairs of entangled qubits** in the singlet state:
+
+$$ \lvert\psi_s\rangle = \frac{1}{\sqrt{2}}(\lvert01\rangle - \lvert10\rangle) $$
+
+Charlie then sends **one qubit** from each entangled pair to Alice and the other to Bob over a **quantum channel**.
+
+### 2. Measurement by Alice and Bob
+- Alice and Bob independently choose random measurement bases and measure their received qubits.
+- If they measure along the same basis, their results will be perfectly **anti-correlated** (i.e., opposite values).
+
+### 3. Classical Communication
+- Alice and Bob share their measurement choices over a **public classical channel**.
+- They discard measurements where bases do not match.
+- The remaining bits form the **raw key**.
+
+### 4. Security Verification (Bell Test)
+- Alice and Bob compute the **CHSH correlation value** to check for **Bell inequality violation**:
+
+$$ C = \langle X \otimes W \rangle - \langle X \otimes V \rangle + \langle Z \otimes W \rangle + \langle Z \otimes V \rangle $$
+
+- If the result exceeds the classical bound of **2** (e.g., \( C = -2\sqrt{2} \)), the key is confirmed to be **secure**.
+- If Eve interfered, the Bell test would fail, alerting Alice and Bob to discard the key.
+
+### 5. Key Extraction
+After removing potentially compromised bits, Alice and Bob apply **error correction** and **privacy amplification** techniques to finalize the **secret key**.
+
+## Why the E91 Protocol is Secure
+- **Quantum Mechanics Guarantees Security**: Any attempt by Eve to measure the qubits **collapses their state**, altering results and revealing her presence.
+- **Bell's Theorem and CHSH Inequality**: These ensure that no **local hidden variable theory** can explain the observed correlations, confirming true quantum entanglement.
+
+## Applications
+- **Quantum-Safe Encryption**: Protects against attacks from quantum computers.
+- **Secure Communications**: Used in diplomatic and military communication systems.
+- **Quantum Networks**: Forms the foundation for future **quantum internet** applications.
+
+## Requirements
+- Python (latest version recommended)
+- Qiskit for quantum simulations
+- Matplotlib for visualizing results
+- NumPy for numerical computations
+
+## References
+- [One-Time Pad](https://en.wikipedia.org/wiki/One-time_pad)
+- [E91 Quantum Key Distribution](https://en.wikipedia.org/wiki/E91_protocol)
+- [Bell's Theorem](https://en.wikipedia.org/wiki/Bell's_theorem)
+- [Qiskit Quantum Information](https://qiskit.org/documentation/tutorials/circuits/3_summary_of_quantum_operations.html)
+
+---
+This project demonstrates a secure method of quantum key distribution using entanglement and Bell's theorem, ensuring the highest level of encryption security.

app.py

@@ -0,0 +1,135 @@
+import gradio as gr
+from src.bb84 import BB84Protocol
+from src.e91 import E91Protocol
+from src.circuit_viz import CircuitVisualizer
+import numpy as np
+import uuid
+
+class QuantumCryptApp:
+    """Interface gráfica para o QuantumCrypt usando Gradio."""
+    
+    def __init__(self):
+        self.bb84 = BB84Protocol()
+        self.e91 = E91Protocol()
+        
+    def create_interface(self):
+        """Cria a interface Gradio."""
+        
+        with gr.Blocks(title="QuantumCrypt", css="footer{display:none !important}") as interface:
+            gr.Markdown("# QuantumCrypt")
+            
+            with gr.Tabs():
+                with gr.Tab("BB84"):
+                    with gr.Row():
+                        with gr.Column():
+                            key_length = gr.Slider(
+                                minimum=8, maximum=256, value=64,
+                                label="Tamanho da Chave"
+                            )
+                            error_correction = gr.Checkbox(
+                                label="Usar Correção de Erros",
+                                visible=False
+                            )
+                            generate_btn = gr.Button("Gerar Chave BB84")
+
+                        with gr.Column():
+                            
+                            output_text = gr.TextArea(label="Resultado")
+                            circuit_viz = gr.Image(label="Visualização do Circuito", 
+                                                   show_download_button=False, 
+                                                   show_fullscreen_button=False,
+                                                   show_share_button=False)
+                
+                    
+                with gr.Tab("E91"):
+                    with gr.Row():
+                        with gr.Column():
+                            key_length_e91 = gr.Slider(
+                                minimum=8, maximum=256, value=64,
+                                label="Tamanho da Chave"
+                            )
+                            error_correction_e91 = gr.Checkbox(
+                                label="Usar Correção de Erros",
+                                visible=False
+                            )
+                            generate_btn_e91 = gr.Button("Gerar Chave BB84")
+
+                        with gr.Column():
+                            
+                            output_text_e91 = gr.TextArea(label="Resultado")
+                            circuit_viz_e91 = gr.Image(label="Visualização do Circuito", 
+                                                   show_download_button=False, 
+                                                   show_fullscreen_button=False,
+                                                   show_share_button=False)
+                
+                with gr.Accordion(label="About", open=False):
+                        with open("README.md", "r") as readme_file:
+                            gr.Markdown(
+                            readme_file.read()
+                            )
+            
+            def generate_bb84(length, use_correction):
+                filename = f"data/{uuid.uuid4()}.png"
+                protocol = BB84Protocol(
+                    key_length=length,
+                    error_correction=use_correction
+                )
+                result = protocol.generate_key()
+                
+                # Gerar visualização
+                circuit_img = CircuitVisualizer.draw_circuit(
+                    protocol.current_circuit,
+                    filename=filename
+                )
+                
+                # Formatar resultado
+                output = (
+                    f"Chave Alice: {''.join(map(str, result['alice']))}\n"
+                    f"Chave Bob: {''.join(map(str, result['bob']))}\n"
+                    f"Tamanho: {len(result['alice'])} bits\n"
+                    f"Correção de Erros: {'Ativada' if use_correction else 'Desativada'}"
+                )
+                
+                return output, filename
+            
+            def generate_e91(length):
+                filename = f"data/{uuid.uuid4()}.png"
+                protocol = E91Protocol(
+                    key_length=length
+                )
+                result = protocol.generate_key()
+                
+                # Gerar visualização
+                circuit_img = CircuitVisualizer.draw_circuit(
+                    protocol.current_circuit,
+                    filename=filename
+                )
+                
+                # Formatar resultado
+                output = (
+                    f"Chave Alice: {''.join(map(str, result['alice']))}\n"
+                    f"Chave Bob: {''.join(map(str, result['bob']))}\n"
+                    f"Tamanho: {len(result['alice'])} bits\n"
+                )
+                
+                return output, filename
+            
+            generate_btn_e91.click(
+                generate_e91,
+                inputs=[key_length_e91],
+                outputs=[output_text_e91, circuit_viz_e91]
+            )
+
+            generate_btn.click(
+                generate_bb84,
+                inputs=[key_length, error_correction],
+                outputs=[output_text, circuit_viz]
+            )
+            
+        return interface
+
+# Exemplo de uso
+if __name__ == "__main__":
+    app = QuantumCryptApp()
+    interface = app.create_interface()
+    interface.launch()

requirements.txt

@@ -0,0 +1,70 @@
+aiofiles==23.2.1
+annotated-types==0.7.0
+anyio==4.8.0
+certifi==2025.1.31
+charset-normalizer==3.4.1
+click==8.1.8
+contourpy==1.3.1
+cycler==0.12.1
+dill==0.3.9
+exceptiongroup==1.2.2
+fastapi==0.115.8
+ffmpy==0.5.0
+filelock==3.17.0
+fonttools==4.56.0
+fsspec==2025.2.0
+gradio==5.17.1
+gradio_client==1.7.1
+h11==0.14.0
+httpcore==1.0.7
+httpx==0.28.1
+huggingface-hub==0.29.1
+idna==3.10
+Jinja2==3.1.5
+kiwisolver==1.4.8
+markdown-it-py==3.0.0
+MarkupSafe==2.1.5
+matplotlib==3.10.0
+mdurl==0.1.2
+mpmath==1.3.0
+numpy==2.2.3
+orjson==3.10.15
+packaging==24.2
+pandas==2.2.3
+pbr==6.1.1
+pillow==11.1.0
+psutil==7.0.0
+pydantic==2.10.6
+pydantic_core==2.27.2
+pydub==0.25.1
+Pygments==2.19.1
+pylatexenc==2.10
+pyparsing==3.2.1
+python-dateutil==2.9.0.post0
+python-multipart==0.0.20
+pytz==2025.1
+PyYAML==6.0.2
+qiskit==1.4.0
+qiskit-aer==0.16.1
+requests==2.32.3
+rich==13.9.4
+ruff==0.9.7
+rustworkx==0.16.0
+safehttpx==0.1.6
+scipy==1.15.2
+semantic-version==2.10.0
+shellingham==1.5.4
+six==1.17.0
+sniffio==1.3.1
+starlette==0.45.3
+stevedore==5.4.1
+symengine==0.13.0
+sympy==1.13.3
+tomlkit==0.13.2
+tqdm==4.67.1
+typer==0.15.1
+typing_extensions==4.12.2
+tzdata==2025.1
+urllib3==2.3.0
+uvicorn==0.34.0
+websockets==14.2

src/base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Tuple, Optional
+import logging
+
+class QuantumProtocol(ABC):
+    """Classe base abstrata para protocolos de criptografia quântica."""
+    
+    def __init__(self, key_length: int = 128):
+        self.key_length = key_length
+        self.logger = logging.getLogger(self.__class__.__name__)
+    
+    @abstractmethod
+    def generate_key(self) -> Dict[str, List[int]]:
+        """Gera uma chave usando o protocolo específico."""
+        pass
+    
+    @abstractmethod
+    def get_circuit_visualization(self) -> str:
+        """Retorna a visualização do circuito quântico."""
+        pass

src/bb84.py

@@ -0,0 +1,341 @@
+from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit.visualization import circuit_drawer
+from qiskit_aer import Aer
+import numpy as np
+import random
+from typing import Dict, List, Tuple, Optional
+import logging
+from .base import QuantumProtocol
+
+class BB84Protocol(QuantumProtocol):
+    """
+    Implementação do protocolo BB84 para distribuição quântica de chaves.
+    Herda da classe base QuantumProtocol e implementa correção de erros quânticos.
+    """
+
+    def __init__(self, key_length: int = 128, error_correction: bool = True):
+        """
+        Inicializa o protocolo BB84.
+
+        Args:
+            key_length (int): Tamanho desejado da chave final em bits
+            error_correction (bool): Se True, utiliza correção de erros quânticos
+        """
+        super().__init__(key_length)  # Chama o construtor da classe base
+        self.error_correction = error_correction
+        self.simulator = Aer.get_backend('qasm_simulator')
+        self.current_circuit = None
+
+    def _prepare_qubit(self, bit: int, basis: str) -> QuantumCircuit:
+        """
+        Prepara um único qubit no estado e base especificados.
+
+        Args:
+            bit (int): Bit a ser codificado (0 ou 1)
+            basis (str): Base de medição ('Z' para rectilinear ou 'X' para diagonal)
+
+        Returns:
+            QuantumCircuit: Circuito quântico preparado
+        """
+        if self.error_correction:
+            # Circuito com correção de erros (código de repetição de 3 qubits)
+            qr = QuantumRegister(3, 'q')
+            cr = ClassicalRegister(1, 'c')
+            qc = QuantumCircuit(qr, cr)
+            
+            # Prepara o estado base
+            if bit == 1:
+                qc.x(qr[0])
+            
+            # Aplica o código de repetição
+            qc.cx(qr[0], qr[1])  # CNOT para copiar o estado
+            qc.cx(qr[0], qr[2])
+            
+            # Aplica a transformação de base se necessário
+            if basis == 'X':
+                qc.h(qr)  # Aplica H em todos os qubits
+        else:
+            # Circuito simples sem correção
+            qr = QuantumRegister(1, 'q')
+            cr = ClassicalRegister(1, 'c')
+            qc = QuantumCircuit(qr, cr)
+            
+            # Prepara o estado
+            if bit == 1:
+                qc.x(qr[0])
+            if basis == 'X':
+                qc.h(qr[0])
+
+        self.current_circuit = qc
+        return qc
+
+    def _measure_qubit(self, circuit: QuantumCircuit, basis: str) -> QuantumCircuit:
+        """
+        Adiciona medição em uma base específica ao circuito.
+
+        Args:
+            circuit (QuantumCircuit): Circuito a ser medido
+            basis (str): Base de medição ('Z' ou 'X')
+
+        Returns:
+            QuantumCircuit: Circuito com medição adicionada
+        """
+        if self.error_correction:
+            # Medição com correção de erros
+            if basis == 'X':
+                circuit.h(range(3))  # Aplica H em todos os qubits para base X
+            
+            # Medição em todos os qubits
+            circuit.measure_all()
+            
+        else:
+            # Medição simples
+            if basis == 'X':
+                circuit.h(0)
+            circuit.measure([0], [0])
+            
+        return circuit
+
+    def _error_correction_decode(self, measurements: List[int]) -> int:
+        """
+        Decodifica medições usando voto majoritário para correção de erros.
+
+        Args:
+            measurements (List[int]): Lista de medições dos qubits
+
+        Returns:
+            int: Bit decodificado
+        """
+        return 1 if sum(measurements) > len(measurements)/2 else 0
+
+    def generate_random_bits(self, n: int) -> List[int]:
+        """
+        Gera uma lista de bits aleatórios.
+
+        Args:
+            n (int): Número de bits a serem gerados
+
+        Returns:
+            List[int]: Lista de bits aleatórios
+        """
+        return [random.randint(0, 1) for _ in range(n)]
+
+    def generate_random_bases(self, n: int) -> List[str]:
+        """
+        Gera uma lista de bases aleatórias.
+
+        Args:
+            n (int): Número de bases a serem geradas
+
+        Returns:
+            List[str]: Lista de bases aleatórias ('Z' ou 'X')
+        """
+        return [random.choice(['Z', 'X']) for _ in range(n)]
+
+    def simulate_transmission(self, bits: List[int], bases: List[str]) -> Tuple[List[int], List[str]]:
+        """
+        Simula a transmissão dos qubits de Alice para Bob.
+
+        Args:
+            bits (List[int]): Bits a serem transmitidos
+            bases (List[str]): Bases usadas para codificação
+
+        Returns:
+            Tuple[List[int], List[str]]: Medições de Bob e bases escolhidas
+        """
+        bob_bases = self.generate_random_bases(len(bits))
+        bob_measurements = []
+        
+        for i in range(len(bits)):
+            # Alice prepara o qubit
+            circuit = self._prepare_qubit(bits[i], bases[i])
+            
+            # Bob mede o qubit
+            circuit = self._measure_qubit(circuit, bob_bases[i])
+            
+            # Executa a simulação
+            job = self.simulator.run(circuit, shots=1)
+            result = job.result()
+            counts = list(result.get_counts().keys())[0]
+            
+            if self.error_correction:
+                # Decodifica as medições com correção de erros
+                measurements = [int(bit) for bit in counts]
+                measured_bit = self._error_correction_decode(measurements)
+            else:
+                measured_bit = int(counts)
+                
+            bob_measurements.append(measured_bit)
+            
+        return bob_measurements, bob_bases
+
+    def sift_key(self, alice_bits: List[int], alice_bases: List[str], 
+                 bob_measurements: List[int], bob_bases: List[str]) -> Tuple[List[int], List[int]]:
+        """
+        Realiza o processo de peneiramento da chave.
+
+        Args:
+            alice_bits (List[int]): Bits originais de Alice
+            alice_bases (List[str]): Bases usadas por Alice
+            bob_measurements (List[int]): Medições de Bob
+            bob_bases (List[str]): Bases usadas por Bob
+
+        Returns:
+            Tuple[List[int], List[int]]: Chaves peneiradas de Alice e Bob
+        """
+        alice_key = []
+        bob_key = []
+        
+        for i in range(len(alice_bits)):
+            if alice_bases[i] == bob_bases[i]:
+                alice_key.append(alice_bits[i])
+                bob_key.append(bob_measurements[i])
+                
+        return alice_key, bob_key
+
+    def check_eavesdropping(self, alice_key: List[int], bob_key: List[int], 
+                           sample_size: float = 0.25) -> bool:
+        """
+        Verifica a presença de um espião comparando uma amostra das chaves.
+
+        Args:
+            alice_key (List[int]): Chave de Alice
+            bob_key (List[int]): Chave de Bob
+            sample_size (float): Proporção da chave a ser verificada
+
+        Returns:
+            bool: True se não houver evidência de espionagem, False caso contrário
+        """
+        if len(alice_key) != len(bob_key):
+            return False
+            
+        sample_length = int(len(alice_key) * sample_size)
+        indices = random.sample(range(len(alice_key)), sample_length)
+        
+        differences = 0
+        for i in indices:
+            if alice_key[i] != bob_key[i]:
+                differences += 1
+                
+        error_rate = differences / sample_length
+        self.logger.info(f"Taxa de erro na amostra: {error_rate:.2%}")
+        
+        # Define um limite aceitável de erro (5%)
+        return error_rate < 0.05
+
+    def get_circuit_visualization(self) -> str:
+        """
+        Implementação do método abstrato da classe base.
+        Retorna a visualização do circuito atual em ASCII.
+
+        Returns:
+            str: Representação ASCII do circuito
+        """
+        if self.current_circuit:
+            return circuit_drawer(self.current_circuit, output='text')
+        return "Nenhum circuito disponível"
+
+    def generate_key(self) -> Dict[str, List[int]]:
+        """
+        Implementação do método abstrato da classe base.
+        Executa o protocolo BB84 completo para gerar uma chave compartilhada.
+
+        Returns:
+            Dict[str, List[int]]: Dicionário contendo as chaves finais de Alice e Bob
+        """
+        # Fase 1: Preparação
+        raw_bits = self.generate_random_bits(self.key_length * 4)
+        alice_bases = self.generate_random_bases(len(raw_bits))
+        
+        self.logger.info(f"Iniciando protocolo BB84 para gerar chave de {self.key_length} bits")
+        self.logger.info(f"Correção de erros: {'Ativada' if self.error_correction else 'Desativada'}")
+        
+        # Fase 2: Transmissão
+        bob_measurements, bob_bases = self.simulate_transmission(raw_bits, alice_bases)
+        
+        # Fase 3: Peneiramento
+        alice_key, bob_key = self.sift_key(raw_bits, alice_bases, bob_measurements, bob_bases)
+        
+        self.logger.info(f"Chave peneirada gerada com {len(alice_key)} bits")
+        
+        # Fase 4: Detecção de espionagem
+        if not self.check_eavesdropping(alice_key, bob_key):
+            self.logger.error("Possível tentativa de espionagem detectada!")
+            return {"alice": [], "bob": []}
+        
+        # Fase 5: Finalização
+        final_key_length = min(self.key_length, len(alice_key))
+        alice_final_key = alice_key[:final_key_length]
+        bob_final_key = bob_key[:final_key_length]
+        
+        self.logger.info(f"Protocolo BB84 concluído com sucesso. "
+                        f"Chave final de {final_key_length} bits gerada.")
+        
+        return {
+            "alice": alice_final_key,
+            "bob": bob_final_key
+        }
+
+    def get_key_statistics(self, alice_key: List[int], bob_key: List[int]) -> Dict:
+        """
+        Calcula estatísticas sobre as chaves geradas.
+
+        Args:
+            alice_key (List[int]): Chave de Alice
+            bob_key (List[int]): Chave de Bob
+
+        Returns:
+            Dict: Dicionário com estatísticas das chaves
+        """
+        if not alice_key or not bob_key:
+            return {
+                "key_length": 0,
+                "error_rate": 1.0,
+                "matching_rate": 0.0,
+                "entropy": 0.0
+            }
+
+        differences = sum(a != b for a, b in zip(alice_key, bob_key))
+        error_rate = differences / len(alice_key)
+        
+        # Calcula a entropia da chave
+        ones = sum(alice_key) / len(alice_key)
+        zeros = 1 - ones
+        if zeros == 0 or ones == 0:
+            entropy = 0
+        else:
+            entropy = -(ones * np.log2(ones) + zeros * np.log2(zeros))
+
+        return {
+            "key_length": len(alice_key),
+            "error_rate": error_rate,
+            "matching_rate": 1 - error_rate,
+            "entropy": entropy
+        }
+
+def main():
+    """Função principal para demonstração do protocolo."""
+    # Criar uma instância do protocolo
+    bb84 = BB84Protocol(key_length=64, error_correction=True)
+    
+    # Gerar uma chave compartilhada
+    result = bb84.generate_key()
+    
+    # Verificar se as chaves são idênticas
+    if result["alice"] and result["bob"]:
+        print("\nChave de Alice:", "".join(map(str, result["alice"])))
+        print("Chave de Bob:  ", "".join(map(str, result["bob"])))
+        
+        # Obter e mostrar estatísticas
+        stats = bb84.get_key_statistics(result["alice"], result["bob"])
+        print("\nEstatísticas da chave:")
+        print(f"Tamanho: {stats['key_length']} bits")
+        print(f"Taxa de erro: {stats['error_rate']:.2%}")
+        print(f"Taxa de correspondência: {stats['matching_rate']:.2%}")
+        print(f"Entropia: {stats['entropy']:.2f} bits")
+        
+        # Mostrar visualização do último circuito
+        print("\nÚltimo circuito gerado:")
+        print(bb84.get_circuit_visualization())
+    else:
+        print("Falha na geração da chave - possível tentativa de espionagem detectada.")

src/circuit_viz.py

@@ -0,0 +1,15 @@
+from qiskit.visualization import circuit_drawer
+from typing import Optional
+import matplotlib.pyplot as plt
+
+class CircuitVisualizer:
+    """Classe para visualização de circuitos quânticos."""
+    
+    @staticmethod
+    def draw_circuit(circuit, filename: Optional[str] = None):
+        """Desenha e opcionalmente salva o circuito."""
+        fig = plt.figure(figsize=(12, 8))
+        circuit_drawer(circuit, output='mpl')
+        if filename:
+            plt.savefig(filename)
+        plt.close()

src/e91.py

@@ -0,0 +1,167 @@
+from .base import QuantumProtocol
+from qiskit_aer import Aer
+from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
+import numpy as np
+import random
+from typing import Dict, List, Tuple
+from qiskit.visualization import circuit_drawer
+
+
+
+class E91Protocol(QuantumProtocol):
+    """
+    Implementação do protocolo E91 (Ekert91) baseado em emaranhamento.
+    
+    O protocolo E91 usa pares de qubits emaranhados e medições em diferentes ângulos
+    para estabelecer uma chave segura e verificar a presença de espionagem através
+    da violação das desigualdades de Bell.
+    """
+    
+    def __init__(self, key_length: int = 128):
+        super().__init__(key_length)
+        self.simulator = Aer.get_backend('qasm_simulator')
+        self.current_circuit = None
+        
+        # Ângulos de medição para Alice e Bob
+        self.alice_angles = [0, np.pi/4, np.pi/2]
+        self.bob_angles = [np.pi/4, np.pi/2, 3*np.pi/4]
+    
+    def _prepare_entangled_pair(self) -> QuantumCircuit:
+        """
+        Prepara um par de qubits emaranhados no estado de Bell Φ+.
+        
+        Returns:
+            QuantumCircuit: Circuito com o par emaranhado
+        """
+        qr = QuantumRegister(2, 'q')
+        cr = ClassicalRegister(2, 'c')
+        qc = QuantumCircuit(qr, cr)
+        
+        # Criar estado de Bell Φ+ = (|00⟩ + |11⟩)/√2
+        qc.h(qr[0])
+        qc.cx(qr[0], qr[1])
+        
+        self.current_circuit = qc
+        return qc
+    
+    def _measure_qubit(self, circuit: QuantumCircuit, angle: float, qubit: int) -> QuantumCircuit:
+        """
+        Adiciona medição em um ângulo específico para um qubit.
+        
+        Args:
+            circuit (QuantumCircuit): Circuito a ser medido
+            angle (float): Ângulo de medição
+            qubit (int): Índice do qubit a ser medido
+            
+        Returns:
+            QuantumCircuit: Circuito com medição adicionada
+        """
+        # Rotação para o ângulo de medição
+        circuit.ry(2*angle, qubit)
+        circuit.measure([qubit], [qubit])
+        return circuit
+
+    def _check_bell_inequality(self, correlations: List[float]) -> bool:
+        """
+        Verifica a violação da desigualdade de CHSH.
+        
+        Args:
+            correlations (List[float]): Lista de correlações medidas
+            
+        Returns:
+            bool: True se a desigualdade for violada (indicando ausência de espião)
+        """
+        # Cálculo do parâmetro S da desigualdade CHSH
+        S = abs(sum(correlations))
+        # O valor teórico máximo é 2√2 ≈ 2.82
+        # Um valor > 2 indica violação da desigualdade
+        return S > 2
+    
+    def _calculate_correlation(self, alice_results: List[int], 
+                             bob_results: List[int]) -> float:
+        """
+        Calcula a correlação entre as medições de Alice e Bob.
+        
+        Args:
+            alice_results (List[int]): Resultados das medições de Alice
+            bob_results (List[int]): Resultados das medições de Bob
+            
+        Returns:
+            float: Valor da correlação (-1 a 1)
+        """
+        if not alice_results or not bob_results:
+            return 0
+        
+        return np.mean([a == b for a, b in zip(alice_results, bob_results)])
+
+    def generate_key(self) -> Dict[str, List[int]]:
+        """
+        Executa o protocolo E91 completo para gerar uma chave compartilhada.
+        
+        Returns:
+            Dict[str, List[int]]: Dicionário contendo as chaves finais de Alice e Bob
+        """
+        self.logger.info(f"Iniciando protocolo E91 para gerar chave de {self.key_length} bits")
+        
+        alice_key = []
+        bob_key = []
+        correlations = []
+        
+        # Precisamos de mais pares para compensar descartes
+        num_pairs = self.key_length * 4
+        
+        for _ in range(num_pairs):
+            # Preparar par emaranhado
+            circuit = self._prepare_entangled_pair()
+            
+            # Alice e Bob escolhem ângulos aleatoriamente
+            alice_angle = random.choice(self.alice_angles)
+            bob_angle = random.choice(self.bob_angles)
+            
+            # Adicionar medições
+            circuit = self._measure_qubit(circuit, alice_angle, 0)  # Alice
+            circuit = self._measure_qubit(circuit, bob_angle, 1)    # Bob
+            
+            # Executar circuito
+            job = self.simulator.run(circuit, shots=1)
+            result = job.result()
+            counts = list(result.get_counts().keys())[0]
+            alice_result = int(counts[0])
+            bob_result = int(counts[1])
+            
+            # Verificar se os ângulos são compatíveis para a chave
+            if alice_angle == bob_angle:
+                alice_key.append(alice_result)
+                bob_key.append(bob_result)
+            else:
+                # Usar para teste de Bell
+                correlation = self._calculate_correlation([alice_result], [bob_result])
+                correlations.append(correlation)
+        
+        # Verificar violação da desigualdade de Bell
+        if not self._check_bell_inequality(correlations):
+            self.logger.error("Possível espionagem detectada - violação de Bell não observada!")
+            return {"alice": [], "bob": []}
+        
+        # Cortar para o tamanho desejado
+        alice_key = alice_key[:self.key_length]
+        bob_key = bob_key[:self.key_length]
+        
+        self.logger.info(f"Protocolo E91 concluído com sucesso. "
+                        f"Chave final de {len(alice_key)} bits gerada.")
+        
+        return {
+            "alice": alice_key,
+            "bob": bob_key
+        }
+
+    def get_circuit_visualization(self) -> str:
+        """
+        Retorna a visualização do circuito atual em ASCII.
+        
+        Returns:
+            str: Representação ASCII do circuito
+        """
+        if self.current_circuit:
+            return circuit_drawer(self.current_circuit, output='text')
+        return "Nenhum circuito disponível"

src/generate.py

@@ -0,0 +1,226 @@
+from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
+from qiskit_aer import Aer
+from qiskit.visualization import plot_histogram
+import numpy as np
+import random
+from typing import List, Tuple, Dict
+import logging
+
+class BB84Protocol:
+    def __init__(self, key_length: int = 128):
+        """
+        Inicializa o protocolo BB84 com o tamanho desejado da chave.
+        
+        Args:
+            key_length (int): Tamanho desejado da chave final em bits
+        """
+        self.key_length = key_length
+        self.simulator = Aer.get_backend('qasm_simulator')
+        
+        # Configuração do logging
+        logging.basicConfig(level=logging.INFO)
+        self.logger = logging.getLogger(__name__)
+
+    def _prepare_qubit(self, bit: int, basis: str) -> QuantumCircuit:
+        """
+        Prepara um único qubit no estado e base especificados.
+        
+        Args:
+            bit (int): Bit a ser codificado (0 ou 1)
+            basis (str): Base de medição ('Z' para rectilinear ou 'X' para diagonal)
+            
+        Returns:
+            QuantumCircuit: Circuito quântico preparado
+        """
+        qr = QuantumRegister(1)
+        cr = ClassicalRegister(1)
+        qc = QuantumCircuit(qr, cr)
+        
+        # Prepara o estado do qubit
+        if bit == 1:
+            qc.x(qr[0])
+            
+        # Aplica a transformação de base se necessário
+        if basis == 'X':
+            qc.h(qr[0])
+            
+        return qc
+
+    def _measure_qubit(self, circuit: QuantumCircuit, basis: str) -> QuantumCircuit:
+        """
+        Adiciona a medição em uma base específica ao circuito.
+        
+        Args:
+            circuit (QuantumCircuit): Circuito a ser medido
+            basis (str): Base de medição ('Z' ou 'X')
+            
+        Returns:
+            QuantumCircuit: Circuito com medição adicionada
+        """
+        if basis == 'X':
+            circuit.h(0)
+        circuit.measure([0], [0])
+        return circuit
+
+    def generate_random_bits(self, n: int) -> List[int]:
+        """
+        Gera uma lista de bits aleatórios.
+        
+        Args:
+            n (int): Número de bits a serem gerados
+            
+        Returns:
+            List[int]: Lista de bits aleatórios
+        """
+        return [random.randint(0, 1) for _ in range(n)]
+
+    def generate_random_bases(self, n: int) -> List[str]:
+        """
+        Gera uma lista de bases aleatórias.
+        
+        Args:
+            n (int): Número de bases a serem geradas
+            
+        Returns:
+            List[str]: Lista de bases aleatórias ('Z' ou 'X')
+        """
+        return [random.choice(['Z', 'X']) for _ in range(n)]
+
+    def simulate_transmission(self, bits: List[int], bases: List[str]) -> Tuple[List[int], List[str]]:
+        """
+        Simula a transmissão dos qubits de Alice para Bob.
+        
+        Args:
+            bits (List[int]): Bits a serem transmitidos
+            bases (List[str]): Bases usadas para codificação
+            
+        Returns:
+            Tuple[List[int], List[str]]: Medições de Bob e bases escolhidas
+        """
+        bob_bases = self.generate_random_bases(len(bits))
+        bob_measurements = []
+        
+        for i in range(len(bits)):
+            # Alice prepara o qubit
+            circuit = self._prepare_qubit(bits[i], bases[i])
+            
+            # Bob mede o qubit
+            circuit = self._measure_qubit(circuit, bob_bases[i])
+            
+            # Executa a simulação usando a nova API do Qiskit
+            job = self.simulator.run(circuit, shots=1)
+            result = job.result()
+            counts = result.get_counts()
+            measured_bit = int(list(counts.keys())[0])
+            bob_measurements.append(measured_bit)
+            
+        return bob_measurements, bob_bases
+
+    def sift_key(self, alice_bits: List[int], alice_bases: List[str], 
+                 bob_measurements: List[int], bob_bases: List[str]) -> Tuple[List[int], List[int]]:
+        """
+        Realiza o processo de peneiramento da chave.
+        
+        Args:
+            alice_bits (List[int]): Bits originais de Alice
+            alice_bases (List[str]): Bases usadas por Alice
+            bob_measurements (List[int]): Medições de Bob
+            bob_bases (List[str]): Bases usadas por Bob
+            
+        Returns:
+            Tuple[List[int], List[int]]: Chaves peneiradas de Alice e Bob
+        """
+        alice_key = []
+        bob_key = []
+        
+        for i in range(len(alice_bits)):
+            if alice_bases[i] == bob_bases[i]:
+                alice_key.append(alice_bits[i])
+                bob_key.append(bob_measurements[i])
+                
+        return alice_key, bob_key
+
+    def check_eavesdropping(self, alice_key: List[int], bob_key: List[int], 
+                           sample_size: float = 0.25) -> bool:
+        """
+        Verifica a presença de um espião comparando uma amostra das chaves.
+        
+        Args:
+            alice_key (List[int]): Chave de Alice
+            bob_key (List[int]): Chave de Bob
+            sample_size (float): Proporção da chave a ser verificada
+            
+        Returns:
+            bool: True se não houver evidência de espionagem, False caso contrário
+        """
+        if len(alice_key) != len(bob_key):
+            return False
+            
+        sample_length = int(len(alice_key) * sample_size)
+        indices = random.sample(range(len(alice_key)), sample_length)
+        
+        differences = 0
+        for i in indices:
+            if alice_key[i] != bob_key[i]:
+                differences += 1
+                
+        error_rate = differences / sample_length
+        self.logger.info(f"Taxa de erro na amostra: {error_rate:.2%}")
+        
+        # Define um limite aceitável de erro (por exemplo, 5%)
+        return error_rate < 0.05
+
+    def generate_key(self) -> Dict[str, List[int]]:
+        """
+        Executa o protocolo BB84 completo para gerar uma chave compartilhada.
+        
+        Returns:
+            Dict[str, List[int]]: Dicionário contendo as chaves finais de Alice e Bob
+        """
+        # Fase 1: Preparação
+        raw_bits = self.generate_random_bits(self.key_length * 4)  # Geramos mais bits para compensar o peneiramento
+        alice_bases = self.generate_random_bases(len(raw_bits))
+        
+        self.logger.info(f"Iniciando protocolo BB84 para gerar chave de {self.key_length} bits")
+        
+        # Fase 2: Transmissão
+        bob_measurements, bob_bases = self.simulate_transmission(raw_bits, alice_bases)
+        
+        # Fase 3: Peneiramento
+        alice_key, bob_key = self.sift_key(raw_bits, alice_bases, bob_measurements, bob_bases)
+        
+        self.logger.info(f"Chave peneirada gerada com {len(alice_key)} bits")
+        
+        # Fase 4: Detecção de espionagem
+        if not self.check_eavesdropping(alice_key, bob_key):
+            self.logger.error("Possível tentativa de espionagem detectada!")
+            return {"alice": [], "bob": []}
+        
+        # Fase 5: Finalização
+        final_key_length = min(self.key_length, len(alice_key))
+        alice_final_key = alice_key[:final_key_length]
+        bob_final_key = bob_key[:final_key_length]
+        
+        self.logger.info(f"Protocolo BB84 concluído com sucesso. Chave final de {final_key_length} bits gerada.")
+        
+        return {
+            "alice": alice_final_key,
+            "bob": bob_final_key
+        }
+
+# Exemplo de uso
+if __name__ == "__main__":
+    # Criar uma instância do protocolo
+    bb84 = BB84Protocol(key_length=64)
+    
+    # Gerar uma chave compartilhada
+    result = bb84.generate_key()
+    
+    # Verificar se as chaves são idênticas
+    if result["alice"] and result["bob"]:
+        print("\nChave de Alice:", "".join(map(str, result["alice"])))
+        print("Chave de Bob:  ", "".join(map(str, result["bob"])))
+        print("\nAs chaves são idênticas?", result["alice"] == result["bob"])
+        print("Tamanho da chave:", len(result["alice"]), "bits")
+    else:
+        print("Falha na geração da chave - possível tentativa de espionagem detectada.")

src/qec.py

@@ -0,0 +1,24 @@
+from typing import List
+
+class QuantumErrorCorrection:
+    """Implementação de correção de erros quânticos."""
+    
+    @staticmethod
+    def encode_message(bits: List[int]) -> List[int]:
+        """Codifica uma mensagem usando código de repetição."""
+        encoded = []
+        for bit in bits:
+            # Implementa código de repetição de 3 qubits
+            encoded.extend([bit] * 3)
+        return encoded
+    
+    @staticmethod
+    def decode_message(encoded_bits: List[int]) -> List[int]:
+        """Decodifica uma mensagem usando voto majoritário."""
+        decoded = []
+        for i in range(0, len(encoded_bits), 3):
+            chunk = encoded_bits[i:i+3]
+            # Voto majoritário
+            bit = 1 if sum(chunk) > len(chunk)/2 else 0
+            decoded.append(bit)
+        return decoded