import numpy as np
import random
from typing import List, Tuple

class BB84Protocol:
    def __init__(self):
        # 定义基态：+ (水平/垂直) 和 × (±45度)
        self.bases = ['+', '×']
        self.bit_to_polarization = {
            (0, '+'): '↑',  # 垂直
            (1, '+'): '→',  # 水平
            (0, '×'): '↗',  # +45度
            (1, '×'): '↖'   # -45度
        }
    
    def alice_prepare_qubits(self, key_length: int) -> Tuple[List[int], List[str], List[str]]:
        """Alice准备量子比特"""
        # 生成随机比特序列
        bits = [random.randint(0, 1) for _ in range(key_length)]
        # 随机选择测量基
        bases = [random.choice(self.bases) for _ in range(key_length)]
        # 根据比特和基态确定偏振态
        polarizations = [self.bit_to_polarization[(bit, base)] 
                        for bit, base in zip(bits, bases)]
        
        return bits, bases, polarizations
    
    def bob_measure_qubits(self, polarizations: List[str], key_length: int) -> Tuple[List[str], List[int]]:
        """Bob测量量子比特"""
        # Bob随机选择测量基
        bob_bases = [random.choice(self.bases) for _ in range(key_length)]
        bob_bits = []
        
        for pol, base in zip(polarizations, bob_bases):
            # 模拟量子测量过程
            measured_bit = self.quantum_measurement(pol, base)
            bob_bits.append(measured_bit)
        
        return bob_bases, bob_bits
    
    def quantum_measurement(self, polarization: str, measurement_base: str) -> int:
        """模拟量子测量过程"""
        # 定义偏振态与测量基的关系
        measurement_results = {
            ('↑', '+'): 0,  ('→', '+'): 1,
            ('↗', '×'): 0,  ('↖', '×'): 1,
            # 错误基态测量返回随机结果
            ('↑', '×'): random.randint(0, 1),
            ('→', '×'): random.randint(0, 1),
            ('↗', '+'): random.randint(0, 1),
            ('↖', '+'): random.randint(0, 1)
        }
        return measurement_results[(polarization, measurement_base)]
    
    def sift_keys(self, alice_bases: List[str], bob_bases: List[str], 
                  alice_bits: List[int], bob_bits: List[int]) -> Tuple[List[int], List[int]]:
        """筛选匹配基态的比特"""
        alice_sifted = []
        bob_sifted = []
        
        for i, (a_base, b_base) in enumerate(zip(alice_bases, bob_bases)):
            if a_base == b_base:  # 基态匹配
                alice_sifted.append(alice_bits[i])
                bob_sifted.append(bob_bits[i])
        
        return alice_sifted, bob_sifted
    
    def error_detection(self, alice_key: List[int], bob_key: List[int], 
                       sample_size: int = None) -> float:
        """错误检测和估算"""
        if sample_size is None:
            sample_size = min(len(alice_key) // 10, 100)  # 使用10%或最多100比特
        
        # 随机选择样本进行公开比较
        sample_indices = random.sample(range(len(alice_key)), sample_size)
        errors = 0
        
        for i in sample_indices:
            if alice_key[i] != bob_key[i]:
                errors += 1
        
        error_rate = errors / sample_size
        
        # 从密钥中移除用于测试的比特
        alice_final = [bit for i, bit in enumerate(alice_key) if i not in sample_indices]
        bob_final = [bit for i, bit in enumerate(bob_key) if i not in sample_indices]
        
        return alice_final, bob_final, error_rate
    
    def privacy_amplification(self, key: List[int], error_rate: float) -> List[int]:
        """隐私放大减少窃听者信息"""
        # 计算安全密钥长度（简化版本）
        shannon_limit = 1 - 2 * error_rate  # Shannon限制
        safe_length = int(len(key) * shannon_limit * 0.8)  # 保守估计
        
        # 使用简单的奇偶校验进行隐私放大
        amplified_key = []
        for i in range(0, safe_length * 2, 2):
            if i + 1 < len(key):
                parity_bit = key[i] ^ key[i + 1]
                amplified_key.append(parity_bit)
        
        return amplified_key[:safe_length]

# 完整的QKD会话示例
def run_qkd_session(key_length: int = 1000):
    protocol = BB84Protocol()
    
    print(f"开始QKD会话，目标密钥长度：{key_length}比特")
    
    # Alice准备量子比特
    alice_bits, alice_bases, polarizations = protocol.alice_prepare_qubits(key_length)
    print(f"Alice发送了{len(polarizations)}个量子比特")
    
    # Bob测量量子比特
    bob_bases, bob_bits = protocol.bob_measure_qubits(polarizations, key_length)
    print(f"Bob完成测量")
    
    # 基态筛选
    alice_sifted, bob_sifted = protocol.sift_keys(alice_bases, bob_bases, alice_bits, bob_bits)
    print(f"基态匹配后剩余{len(alice_sifted)}比特")
    
    # 错误检测
    alice_key, bob_key, error_rate = protocol.error_detection(alice_sifted, bob_sifted)
    print(f"错误率：{error_rate:.3f}，剩余{len(alice_key)}比特")
    
    if error_rate > 0.11:  # BB84协议的安全阈值
        print("警告：错误率过高，可能存在窃听！")
        return None, None
    
    # 隐私放大
    alice_final = protocol.privacy_amplification(alice_key, error_rate)
    bob_final = protocol.privacy_amplification(bob_key, error_rate)
    
    print(f"最终安全密钥长度：{len(alice_final)}比特")
    return alice_final, bob_final

class E91Protocol:
    def __init__(self):
        self.bell_angles = [0, 22.5, 45, 67.5, 90, 112.5, 135, 157.5]  # 度
    
    def generate_entangled_pairs(self, num_pairs: int) -> List[Tuple]:
        """生成纠缠光子对"""
        entangled_pairs = []
        for _ in range(num_pairs):
            # 贝尔态 |Φ+⟩ = (|00⟩ + |11⟩)/√2
            # 测量结果总是相关的
            correlation = random.choice([1, -1])  # 完美反关联或关联
            entangled_pairs.append(correlation)
        return entangled_pairs
    
    def alice_measurements(self, pairs: List, angles: List[float]) -> List[int]:
        """Alice的测量选择"""
        alice_results = []
        for pair, angle in zip(pairs, angles):
            # 根据测量角度和纠缠关联性确定结果
            prob = abs(np.cos(np.radians(angle))) ** 2
            result = 1 if random.random() < prob else 0
            if pair == -1:  # 反关联情况
                result = 1 - result
            alice_results.append(result)
        return alice_results
    
    def test_bell_inequality(self, alice_results: List, bob_results: List, 
                           alice_angles: List, bob_angles: List) -> float:
        """测试贝尔不等式验证量子纠缠"""
        # CHSH不等式测试
        # S = E(a,b) - E(a,b') + E(a',b) + E(a',b') ≤ 2 (经典)
        # 量子力学预测最大值为2√2 ≈ 2.83
        
        correlations = []
        angle_pairs = [(0, 45), (0, 135), (90, 45), (90, 135)]
        
        for a_angle, b_angle in angle_pairs:
            correlation = self.calculate_correlation(alice_results, bob_results,
                                                   alice_angles, bob_angles,
                                                   a_angle, b_angle)
            correlations.append(correlation)
        
        S = correlations[0] - correlations[1] + correlations[2] + correlations[3]
        return S
    
    def calculate_correlation(self, alice_results, bob_results, 
                            alice_angles, bob_angles, target_a, target_b):
        """计算特定角度组合的关联度"""
        matches = []
        for i, (a_angle, b_angle) in enumerate(zip(alice_angles, bob_angles)):
            if abs(a_angle - target_a) < 1 and abs(b_angle - target_b) < 1:
                correlation = 1 if alice_results[i] == bob_results[i] else -1
                matches.append(correlation)
        return np.mean(matches) if matches else 0

import hashlib
from typing import Dict, Any

class QuantumDigitalSignature:
    def __init__(self):
        self.quantum_states = {}  # 存储量子态信息
        self.classical_keys = {}  # 经典验证密钥
    
    def generate_quantum_signature(self, message: str, sender_id: str) -> Dict[str, Any]:
        """生成量子数字签名"""
        # 生成消息的量子编码
        message_hash = hashlib.sha256(message.encode()).hexdigest()
        
        # 为每个比特生成量子态
        quantum_signature = []
        for bit in message_hash:
            # 每个十六进制字符对应4个量子比特
            hex_value = int(bit, 16)
            for i in range(4):
                qubit_value = (hex_value >> i) & 1
                # 随机选择基态进行编码
                basis = random.choice(['+', '×'])
                quantum_state = self.encode_qubit(qubit_value, basis)
                quantum_signature.append({
                    'state': quantum_state,
                    'basis': basis,
                    'position': len(quantum_signature)
                })
        
        # 生成经典验证信息
        classical_verification = {
            'sender_id': sender_id,
            'timestamp': time.time(),
            'message_length': len(message),
            'signature_length': len(quantum_signature)
        }
        
        return {
            'quantum_signature': quantum_signature,
            'classical_verification': classical_verification,
            'message_hash': message_hash
        }
    
    def verify_quantum_signature(self, message: str, signature: Dict[str, Any], 
                               sender_public_key: str) -> bool:
        """验证量子数字签名"""
        # 重新计算消息哈希
        message_hash = hashlib.sha256(message.encode()).hexdigest()
        
        if message_hash != signature['message_hash']:
            return False
        
        # 验证量子签名
        quantum_sig = signature['quantum_signature']
        verification_success = 0
        total_checks = 0
        
        for i, bit in enumerate(message_hash):
            hex_value = int(bit, 16)
            for j in range(4):
                expected_bit = (hex_value >> j) & 1
                qubit_index = i * 4 + j
                
                if qubit_index < len(quantum_sig):
                    quantum_state = quantum_sig[qubit_index]
                    measured_bit = self.measure_qubit(quantum_state['state'], 
                                                    quantum_state['basis'])
                    
                    if measured_bit == expected_bit:
                        verification_success += 1
                    total_checks += 1
        
        # 计算验证成功率
        success_rate = verification_success / total_checks
        return success_rate > 0.9  # 90%以上成功率认为签名有效
    
    def encode_qubit(self, bit_value: int, basis: str) -> str:
        """将比特编码为量子态"""
        if basis == '+':
            return '↑' if bit_value == 0 else '→'
        else:  # basis == '×'
            return '↗' if bit_value == 0 else '↖'
    
    def measure_qubit(self, quantum_state: str, measurement_basis: str) -> int:
        """测量量子比特"""
        # 模拟量子测量过程
        if (quantum_state in ['↑', '→'] and measurement_basis == '+') or            (quantum_state in ['↗', '↖'] and measurement_basis == '×'):
            # 正确基态，确定结果
            return 0 if quantum_state in ['↑', '↗'] else 1
        else:
            # 错误基态，随机结果
            return random.randint(0, 1)

class QuantumCryptographyHardware:
    def __init__(self):
        self.laser_wavelength = 1550  # nm, 电信波段
        self.detector_efficiency = 0.1  # 10%探测效率
        self.dark_count_rate = 100  # Hz
        self.gate_time = 1e-9  # 1ns
    
    def single_photon_source(self, intensity: float = 0.1) -> Dict[str, Any]:
        """单光子源配置"""
        # 弱相干态近似单光子
        photon_number_dist = np.random.poisson(intensity)
        
        return {
            'photon_count': photon_number_dist,
            'wavelength': self.laser_wavelength,
            'pulse_width': self.gate_time,
            'timing_jitter': 50e-12  # 50ps
        }
    
    def polarization_controller(self, input_state: str, target_polarization: str) -> str:
        """偏振控制器"""
        # 模拟偏振态转换
        polarization_map = {
            ('linear_h', '0'): '→',
            ('linear_h', '90'): '↑',
            ('linear_h', '45'): '↗',
            ('linear_h', '135'): '↖'
        }
        return polarization_map.get((input_state, target_polarization), '→')
    
    def single_photon_detector(self, incident_photons: int) -> Dict[str, Any]:
        """单光子探测器响应"""
        # 探测概率计算
        detection_prob = 1 - (1 - self.detector_efficiency) ** incident_photons
        detected = random.random() < detection_prob
        
        # 暗计数噪声
        dark_count = random.random() < (self.dark_count_rate * self.gate_time)
        
        return {
            'detection_event': detected or dark_count,
            'detection_time': time.time(),
            'is_dark_count': dark_count and not detected,
            'efficiency': self.detector_efficiency
        }

class QuantumKeyManagementSystem:
    def __init__(self):
        self.key_storage = {}  # 安全密钥存储
        self.key_lifetime = 3600  # 密钥生存期1小时
        self.min_key_length = 256  # 最小密钥长度
    
    def establish_secure_channel(self, alice_id: str, bob_id: str) -> str:
        """建立安全通信通道"""
        channel_id = f"{alice_id}_{bob_id}_{int(time.time())}"
        
        # 运行QKD协议
        alice_key, bob_key = run_qkd_session(key_length=2000)
        
        if alice_key and len(alice_key) >= self.min_key_length:
            # 存储密钥
            self.key_storage[channel_id] = {
                'alice_key': alice_key,
                'bob_key': bob_key,
                'created_at': time.time(),
                'participants': [alice_id, bob_id],
                'usage_count': 0
            }
            
            print(f"安全通道 {channel_id} 建立成功，密钥长度：{len(alice_key)}比特")
            return channel_id
        else:
            raise Exception("QKD协议失败，无法建立安全通道")
    
    def get_encryption_key(self, channel_id: str, requester_id: str, 
                          key_length: int = 256) -> List[int]:
        """获取加密密钥"""
        if channel_id not in self.key_storage:
            raise Exception("通道不存在")
        
        channel_data = self.key_storage[channel_id]
        
        # 检查权限
        if requester_id not in channel_data['participants']:
            raise Exception("无访问权限")
        
        # 检查密钥是否过期
        if time.time() - channel_data['created_at'] > self.key_lifetime:
            del self.key_storage[channel_id]
            raise Exception("密钥已过期")
        
        # 提取密钥
        if requester_id == channel_data['participants'][0]:
            available_key = channel_data['alice_key']
        else:
            available_key = channel_data['bob_key']
        
        if len(available_key) < key_length:
            raise Exception("可用密钥长度不足")
        
        # 返回请求长度的密钥并从存储中移除
        encryption_key = available_key[:key_length]
        remaining_key = available_key[key_length:]
        
        if requester_id == channel_data['participants'][0]:
            channel_data['alice_key'] = remaining_key
        else:
            channel_data['bob_key'] = remaining_key
        
        channel_data['usage_count'] += 1
        
        return encryption_key
    
    def quantum_secure_encrypt(self, plaintext: str, channel_id: str, 
                             sender_id: str) -> Dict[str, Any]:
        """量子安全加密"""
        # 获取加密密钥
        key_bits = self.get_encryption_key(channel_id, sender_id, 
                                         len(plaintext) * 8)
        
        # 转换为字节密钥
        key_bytes = []
        for i in range(0, len(key_bits), 8):
            byte_bits = key_bits[i:i+8]
            byte_value = sum(bit * (2 ** (7-j)) for j, bit in enumerate(byte_bits))
            key_bytes.append(byte_value)
        
        # 一次性密码本加密（完美安全）
        plaintext_bytes = plaintext.encode('utf-8')
        ciphertext_bytes = []
        
        for i, plain_byte in enumerate(plaintext_bytes):
            if i < len(key_bytes):
                cipher_byte = plain_byte ^ key_bytes[i]
                ciphertext_bytes.append(cipher_byte)
        
        return {
            'ciphertext': bytes(ciphertext_bytes),
            'channel_id': channel_id,
            'timestamp': time.time(),
            'key_consumed': len(key_bits)
        }

class KyberKEM:
    def __init__(self, security_level: int = 3):
        self.security_level = security_level
        self.params = self.get_kyber_params(security_level)
    
    def get_kyber_params(self, level: int) -> Dict[str, int]:
        """获取Kyber参数"""
        params_map = {
            1: {'n': 256, 'q': 3329, 'k': 2, 'eta1': 3, 'eta2': 2},
            3: {'n': 256, 'q': 3329, 'k': 3, 'eta1': 2, 'eta2': 2},
            5: {'n': 256, 'q': 3329, 'k': 4, 'eta1': 2, 'eta2': 2}
        }
        return params_map.get(level, params_map[3])
    
    def keygen(self) -> Tuple[bytes, bytes]:
        """生成密钥对"""
        # 简化的密钥生成（实际实现需要完整的格密码算法）
        private_key = os.urandom(32 * self.params['k'])
        public_key = os.urandom(32 * (self.params['k'] + 1))
        
        return public_key, private_key
    
    def encapsulate(self, public_key: bytes) -> Tuple[bytes, bytes]:
        """密钥封装"""
        # 生成共享密钥
        shared_secret = os.urandom(32)
        
        # 封装（简化版本）
        ciphertext = os.urandom(32 * (self.params['k'] + 1))
        
        return shared_secret, ciphertext
    
    def decapsulate(self, private_key: bytes, ciphertext: bytes) -> bytes:
        """密钥解封装"""
        # 解封装恢复共享密钥（简化版本）
        # 实际实现需要完整的格基解密算法
        shared_secret = os.urandom(32)
        return shared_secret

# 混合密码系统：量子 + 后量子
class HybridCryptographySystem:
    def __init__(self):
        self.qkd_system = QuantumKeyManagementSystem()
        self.pqc_system = KyberKEM(security_level=3)
    
    def hybrid_key_establishment(self, alice_id: str, bob_id: str) -> Dict[str, Any]:
        """混合密钥建立"""
        # 方法1：尝试QKD
        quantum_channel = None
        try:
            quantum_channel = self.qkd_system.establish_secure_channel(alice_id, bob_id)
            quantum_key = self.qkd_system.get_encryption_key(quantum_channel, alice_id, 256)
        except Exception as e:
            print(f"QKD失败：{e}，回退到后量子密码")
            quantum_key = None
        
        # 方法2：后量子密钥交换
        bob_public_key, bob_private_key = self.pqc_system.keygen()
        pqc_shared_secret, ciphertext = self.pqc_system.encapsulate(bob_public_key)
        
        # 密钥组合
        if quantum_key:
            # XOR组合量子密钥和后量子密钥
            combined_key = []
            for i in range(32):  # 256位密钥
                q_byte = sum(quantum_key[i*8+j] * (2**j) for j in range(8)) if len(quantum_key) > i*8+7 else 0
                pq_byte = pqc_shared_secret[i] if i < len(pqc_shared_secret) else 0
                combined_key.append(q_byte ^ pq_byte)
            final_key = bytes(combined_key)
        else:
            final_key = pqc_shared_secret
        
        return {
            'final_key': final_key,
            'quantum_component': quantum_key is not None,
            'pqc_component': True,
            'security_level': 'HYBRID' if quantum_key else 'PQC_ONLY',
            'key_exchange_data': ciphertext
        }

class QuantumNetworkNode:
    def __init__(self, node_id: str, location: Tuple[float, float]):
        self.node_id = node_id
        self.location = location  # (latitude, longitude)
        self.quantum_memory = {}  # 量子态存储
        self.entanglement_links = {}  # 纠缠连接
        self.routing_table = {}  # 路由表
    
    def establish_entanglement_link(self, target_node: str, 
                                  link_quality: float) -> bool:
        """建立纠缠连接"""
        if link_quality < 0.5:
            return False  # 链路质量太低
        
        # 生成纠缠对
        entangled_pair_id = f"ENT_{self.node_id}_{target_node}_{int(time.time())}"
        
        self.entanglement_links[target_node] = {
            'pair_id': entangled_pair_id,
            'quality': link_quality,
            'created_at': time.time(),
            'usage_count': 0
        }
        
        return True
    
    def quantum_teleportation(self, quantum_state: Dict, target_node: str) -> bool:
        """量子隐形传态"""
        if target_node not in self.entanglement_links:
            return False
        
        link = self.entanglement_links[target_node]
        
        # 贝尔测量（简化）
        measurement_result = {
            'basis_measurement': random.randint(0, 3),
            'measurement_outcome': random.randint(0, 1),
            'timestamp': time.time()
        }
        
        # 经典信息传输
        classical_message = {
            'measurement': measurement_result,
            'original_state_id': quantum_state.get('state_id'),
            'correction_instructions': self.generate_correction_ops(measurement_result)
        }
        
        # 消耗纠缠资源
        link['usage_count'] += 1
        
        return True
    
    def generate_correction_ops(self, measurement: Dict) -> List[str]:
        """生成态纠正操作"""
        correction_map = {
            (0, 0): [],  # 无操作
            (0, 1): ['Z'],  # Pauli-Z
            (1, 0): ['X'],  # Pauli-X
            (1, 1): ['X', 'Z']  # Pauli-X然后Pauli-Z
        }
        
        key = (measurement['basis_measurement'] % 2, measurement['measurement_outcome'])
        return correction_map.get(key, [])

class QuantumNetworkProtocol:
    def __init__(self):
        self.nodes = {}  # 网络节点
        self.network_topology = {}  # 网络拓扑
    
    def add_node(self, node: QuantumNetworkNode):
        """添加网络节点"""
        self.nodes[node.node_id] = node
        self.network_topology[node.node_id] = []
    
    def connect_nodes(self, node1_id: str, node2_id: str, link_quality: float):
        """连接两个节点"""
        if node1_id in self.nodes and node2_id in self.nodes:
            self.nodes[node1_id].establish_entanglement_link(node2_id, link_quality)
            self.nodes[node2_id].establish_entanglement_link(node1_id, link_quality)
            
            self.network_topology[node1_id].append(node2_id)
            self.network_topology[node2_id].append(node1_id)
    
    def find_quantum_path(self, source: str, destination: str) -> List[str]:
        """寻找量子通信路径"""
        # 使用Dijkstra算法，考虑链路质量
        visited = set()
        distances = {node: float('inf') for node in self.nodes}
        distances[source] = 0
        previous = {}
        
        while visited != set(self.nodes.keys()):
            current = min(
                (node for node in self.nodes if node not in visited),
                key=lambda x: distances[x],
                default=None
            )
            
            if current is None or distances[current] == float('inf'):
                break
                
            visited.add(current)
            
            for neighbor in self.network_topology.get(current, []):
                if neighbor not in visited:
                    link_quality = self.nodes[current].entanglement_links.get(neighbor, {}).get('quality', 0)
                    distance = distances[current] + (1 - link_quality)  # 距离 = 1 - 质量
                    
                    if distance < distances[neighbor]:
                        distances[neighbor] = distance
                        previous[neighbor] = current
        
        # 重构路径
        if destination not in previous and destination != source:
            return []  # 无路径
        
        path = []
        current = destination
        while current is not None:
            path.insert(0, current)
            current = previous.get(current)
        
        return path
    
    def end_to_end_qkd(self, source: str, destination: str) -> List[int]:
        """端到端量子密钥分发"""
        path = self.find_quantum_path(source, destination)
        if not path or len(path) < 2:
            return []
        
        # 逐跳密钥分发
        final_key = None
        for i in range(len(path) - 1):
            current_node = path[i]
            next_node = path[i + 1]
            
            # 在相邻节点间执行QKD
            hop_key, _ = run_qkd_session(key_length=1000)
            
            if final_key is None:
                final_key = hop_key
            else:
                # 密钥组合（简化为XOR）
                min_length = min(len(final_key), len(hop_key))
                final_key = [final_key[j] ^ hop_key[j] for j in range(min_length)]
        
        return final_key or []

import numpy as np
from scipy.stats import entropy

class QuantumSecurityAnalysis:
    def __init__(self):
        self.security_parameters = {
            'key_length': 256,
            'error_threshold': 0.11,
            'privacy_amplification_ratio': 0.8
        }
    
    def calculate_mutual_information(self, alice_key: List[int], 
                                   bob_key: List[int], 
                                   eve_information: List[int] = None) -> Dict[str, float]:
        """计算互信息量"""
        # Alice和Bob之间的互信息
        I_AB = self.mutual_information(alice_key, bob_key)
        
        # Eve获得的信息（如果有）
        if eve_information:
            I_AE = self.mutual_information(alice_key, eve_information)
            I_BE = self.mutual_information(bob_key, eve_information)
        else:
            I_AE = I_BE = 0
        
        return {
            'I_AB': I_AB,  # Alice-Bob互信息
            'I_AE': I_AE,  # Alice-Eve互信息
            'I_BE': I_BE,  # Bob-Eve互信息
            'security_margin': I_AB - max(I_AE, I_BE)
        }
    
    def mutual_information(self, X: List[int], Y: List[int]) -> float:
        """计算两个序列的互信息"""
        if len(X) != len(Y):
            return 0
        
        # 计算联合分布
        joint_counts = {}
        for x, y in zip(X, Y):
            key = (x, y)
            joint_counts[key] = joint_counts.get(key, 0) + 1
        
        # 计算边际分布
        x_counts = {}
        y_counts = {}
        for x in X:
            x_counts[x] = x_counts.get(x, 0) + 1
        for y in Y:
            y_counts[y] = y_counts.get(y, 0) + 1
        
        # 计算互信息
        n = len(X)
        mi = 0
        for (x, y), joint_count in joint_counts.items():
            p_xy = joint_count / n
            p_x = x_counts[x] / n
            p_y = y_counts[y] / n
            
            if p_xy > 0 and p_x > 0 and p_y > 0:
                mi += p_xy * np.log2(p_xy / (p_x * p_y))
        
        return mi
    
    def security_proof(self, error_rate: float, key_length: int) -> Dict[str, Any]:
        """量子密码学安全性证明"""
        # 信息论安全界限
        h_error = -error_rate * np.log2(error_rate) - (1-error_rate) * np.log2(1-error_rate) if 0 < error_rate < 1 else 0
        
        # Shannon限制
        shannon_bound = 1 - 2 * error_rate
        
        # 安全密钥长度
        secure_key_length = int(key_length * shannon_bound * self.security_parameters['privacy_amplification_ratio'])
        
        # 安全性评估
        is_secure = error_rate < self.security_parameters['error_threshold']
        security_level = 'HIGH' if error_rate < 0.05 else 'MEDIUM' if error_rate < 0.1 else 'LOW'
        
        return {
            'is_secure': is_secure,
            'security_level': security_level,
            'error_rate': error_rate,
            'shannon_bound': shannon_bound,
            'secure_key_length': secure_key_length,
            'raw_key_length': key_length,
            'efficiency': secure_key_length / key_length,
            'binary_entropy': h_error
        }
    
    def simulate_eavesdropping_attack(self, key_length: int = 1000) -> Dict[str, Any]:
        """模拟窃听攻击"""
        print("模拟Eve的拦截重发攻击...")
        
        protocol = BB84Protocol()
        
        # Alice准备量子比特
        alice_bits, alice_bases, polarizations = protocol.alice_prepare_qubits(key_length)
        
        # Eve拦截并测量
        eve_bases = [random.choice(['+', '×']) for _ in range(key_length)]
        eve_measurements = [protocol.quantum_measurement(pol, base) 
                          for pol, base in zip(polarizations, eve_bases)]
        
        # Eve重新发送（根据她的测量结果）
        eve_retransmission = []
        for i, (measurement, base) in enumerate(zip(eve_measurements, eve_bases)):
            if base == '+':
                new_polarization = '↑' if measurement == 0 else '→'
            else:
                new_polarization = '↗' if measurement == 0 else '↖'
            eve_retransmission.append(new_polarization)
        
        # Bob测量Eve重新发送的量子比特
        bob_bases, bob_bits = protocol.bob_measure_qubits(eve_retransmission, key_length)
        
        # 筛选和错误检测
        alice_sifted, bob_sifted = protocol.sift_keys(alice_bases, bob_bases, alice_bits, bob_bits)
        
        if len(alice_sifted) > 0:
            errors = sum(1 for a, b in zip(alice_sifted, bob_sifted) if a != b)
            error_rate = errors / len(alice_sifted)
        else:
            error_rate = 0.5
        
        # Eve获得的信息
        eve_info_bits = []
        for i, (a_base, e_base) in enumerate(zip(alice_bases, eve_bases)):
            if a_base == e_base:  # Eve使用了正确的基态
                eve_info_bits.append(eve_measurements[i])
        
        return {
            'attack_detected': error_rate > 0.11,
            'error_rate_with_eve': error_rate,
            'error_rate_without_eve': 0.0,  # 理论值
            'eve_information_bits': len(eve_info_bits),
            'eve_success_rate': len(eve_info_bits) / key_length,
            'alice_sifted_length': len(alice_sifted),
            'security_analysis': self.security_proof(error_rate, len(alice_sifted))
        }

class QuantumBankingNetwork:
    def __init__(self):
        self.banks = {}  # 银行节点
        self.secure_channels = {}  # 安全通道
        self.transaction_log = []  # 交易日志
    
    def register_bank(self, bank_id: str, bank_info: Dict[str, Any]):
        """注册银行节点"""
        self.banks[bank_id] = {
            'info': bank_info,
            'quantum_hardware': QuantumCryptographyHardware(),
            'key_manager': QuantumKeyManagementSystem(),
            'last_key_refresh': time.time()
        }
    
    def establish_interbank_channel(self, bank1_id: str, bank2_id: str) -> str:
        """建立银行间量子安全通道"""
        if bank1_id not in self.banks or bank2_id not in self.banks:
            raise Exception("银行节点不存在")
        
        # 建立QKD通道
        qkd_system = self.banks[bank1_id]['key_manager']
        channel_id = qkd_system.establish_secure_channel(bank1_id, bank2_id)
        
        self.secure_channels[channel_id] = {
            'participants': [bank1_id, bank2_id],
            'established_at': time.time(),
            'transaction_count': 0,
            'security_level': 'QUANTUM_SECURE'
        }
        
        return channel_id
    
    def secure_transaction(self, channel_id: str, sender_bank: str, 
                         receiver_bank: str, transaction_data: Dict[str, Any]) -> str:
        """安全交易处理"""
        if channel_id not in self.secure_channels:
            raise Exception("安全通道不存在")
        
        channel = self.secure_channels[channel_id]
        
        # 验证参与方
        if sender_bank not in channel['participants'] or receiver_bank not in channel['participants']:
            raise Exception("未授权的交易参与方")
        
        # 获取加密密钥
        key_manager = self.banks[sender_bank]['key_manager']
        transaction_json = json.dumps(transaction_data, sort_keys=True)
        
        # 量子安全加密
        encrypted_transaction = key_manager.quantum_secure_encrypt(
            transaction_json, channel_id, sender_bank
        )
        
        # 生成交易ID
        transaction_id = hashlib.sha256(
            f"{channel_id}_{sender_bank}_{receiver_bank}_{time.time()}".encode()
        ).hexdigest()[:16]
        
        # 记录交易
        transaction_record = {
            'transaction_id': transaction_id,
            'channel_id': channel_id,
            'sender': sender_bank,
            'receiver': receiver_bank,
            'encrypted_data': encrypted_transaction,
            'timestamp': time.time(),
            'security_level': 'QUANTUM_ENCRYPTED'
        }
        
        self.transaction_log.append(transaction_record)
        channel['transaction_count'] += 1
        
        return transaction_id
    
    def verify_transaction_integrity(self, transaction_id: str) -> Dict[str, Any]:
        """验证交易完整性"""
        transaction = None
        for record in self.transaction_log:
            if record['transaction_id'] == transaction_id:
                transaction = record
                break
        
        if not transaction:
            return {'verified': False, 'error': '交易记录不存在'}
        
        # 量子签名验证（简化）
        signature_valid = True  # 在实际实现中会进行完整的量子数字签名验证
        
        # 时间戳验证
        time_valid = time.time() - transaction['timestamp'] < 86400  # 24小时内有效
        
        return {
            'verified': signature_valid and time_valid,
            'transaction_id': transaction_id,
            'timestamp': transaction['timestamp'],
            'security_level': transaction['security_level'],
            'signature_valid': signature_valid,
            'time_valid': time_valid
        }

class QuantumPerformanceBenchmark:
    def __init__(self):
        self.test_results = []
    
    def benchmark_qkd_throughput(self, test_duration: int = 60) -> Dict[str, Any]:
        """QKD系统吞吐量测试"""
        start_time = time.time()
        total_bits_generated = 0
        total_secure_bits = 0
        test_runs = 0
        
        while time.time() - start_time < test_duration:
            # 运行QKD会话
            alice_key, bob_key = run_qkd_session(key_length=1000)
            
            if alice_key:
                total_bits_generated += 1000
                total_secure_bits += len(alice_key)
                test_runs += 1
        
        actual_duration = time.time() - start_time
        
        return {
            'test_duration': actual_duration,
            'total_runs': test_runs,
            'total_bits_generated': total_bits_generated,
            'total_secure_bits': total_secure_bits,
            'throughput_bps': total_secure_bits / actual_duration,
            'efficiency': total_secure_bits / total_bits_generated if total_bits_generated > 0 else 0,
            'success_rate': test_runs / (actual_duration / 10)  # 假设每10秒一次尝试
        }
    
    def benchmark_error_rates(self, distance_km: float) -> Dict[str, Any]:
        """不同距离下的错误率测试"""
        # 模拟距离对错误率的影响
        base_error_rate = 0.01  # 1%基础错误率
        distance_factor = distance_km * 0.001  # 每公里增加0.1%错误率
        fiber_loss_db = distance_km * 0.2  # 每公里0.2dB损耗
        
        simulated_error_rate = base_error_rate + distance_factor
        signal_attenuation = 10 ** (-fiber_loss_db / 10)
        
        # 运行多次测试
        test_results = []
        for _ in range(10):
            # 注入模拟错误
            alice_key, bob_key = run_qkd_session(key_length=1000)
            if alice_key and bob_key:
                # 计算实际错误率
                errors = sum(1 for a, b in zip(alice_key[:100], bob_key[:100]) if a != b)
                measured_error_rate = errors / 100
                test_results.append(measured_error_rate)
        
        return {
            'distance_km': distance_km,
            'theoretical_error_rate': simulated_error_rate,
            'measured_error_rates': test_results,
            'average_error_rate': np.mean(test_results),
            'signal_attenuation': signal_attenuation,
            'fiber_loss_db': fiber_loss_db,
            'communication_feasible': np.mean(test_results) < 0.11
        }
    
    def security_stress_test(self, attack_intensity: float = 0.5) -> Dict[str, Any]:
        """安全压力测试"""
        print(f"执行安全压力测试，攻击强度：{attack_intensity}")
        
        analysis = QuantumSecurityAnalysis()
        attack_results = []
        
        for _ in range(20):  # 20次攻击模拟
            result = analysis.simulate_eavesdropping_attack(key_length=1000)
            attack_results.append(result)
        
        detection_rate = sum(1 for r in attack_results if r['attack_detected']) / len(attack_results)
        average_error_rate = np.mean([r['error_rate_with_eve'] for r in attack_results])
        
        return {
            'attack_intensity': attack_intensity,
            'total_attacks': len(attack_results),
            'detection_rate': detection_rate,
            'average_induced_error_rate': average_error_rate,
            'security_threshold': 0.11,
            'security_margin': 0.11 - average_error_rate,
            'system_secure': detection_rate > 0.95
        }

class AllOpticalQuantumNetwork:
    def __init__(self):
        self.optical_switches = {}  # 光交换设备
        self.wavelength_channels = {}  # 波长信道
        self.photonic_qubits = {}  # 光子量子比特
    
    def configure_optical_switch(self, switch_id: str, port_config: Dict[str, str]):
        """配置光交换机"""
        self.optical_switches[switch_id] = {
            'ports': port_config,
            'switching_time': 1e-9,  # 1纳秒切换时间
            'insertion_loss': 0.1,  # 0.1dB插入损耗
            'crosstalk': -40  # -40dB串扰
        }
    
    def route_photonic_qubit(self, qubit_id: str, source_port: str, 
                           destination_port: str, wavelength: float) -> bool:
        """路由光子量子比特"""
        # 分配波长信道
        channel_id = f"CH_{wavelength}nm"
        
        self.wavelength_channels[channel_id] = {
            'wavelength': wavelength,
            'source': source_port,
            'destination': destination_port,
            'qubit_id': qubit_id,
            'transmission_time': time.time()
        }
        
        # 记录光子量子比特
        self.photonic_qubits[qubit_id] = {
            'polarization': random.choice(['H', 'V', 'D', 'A']),  # 偏振态
            'wavelength': wavelength,
            'coherence_time': 1e-6,  # 1微秒相干时间
            'routing_path': [source_port, destination_port]
        }
        
        return True
    
    def quantum_frequency_conversion(self, input_wavelength: float, 
                                   target_wavelength: float) -> float:
        """量子频率转换"""
        # 非线性光学频率转换
        conversion_efficiency = 0.8  # 80%转换效率
        
        # 模拟转换过程
        if abs(input_wavelength - target_wavelength) < 100:  # 100nm范围内
            output_wavelength = target_wavelength
            success_probability = conversion_efficiency
        else:
            output_wavelength = input_wavelength
            success_probability = 0.1  # 大频差转换困难
        
        return output_wavelength if random.random() < success_probability else input_wavelength

def quantum_cryptography_lab_exercises():
    """量子密码学实验练习"""
    exercises = {
        '基础练习': [
            '实现简化版BB84协议',
            '模拟量子信道噪声',
            '错误率计算与分析',
            '密钥筛选算法实现'
        ],
        '中级项目': [
            '多用户量子密钥分发网络',
            '量子数字签名系统',
            '量子随机数生成器',
            '窃听检测算法优化'
        ],
        '高级挑战': [
            '混合经典-量子密码系统',
            '量子网络路由协议',
            '容错量子通信',
            '量子云安全架构'
        ]
    }
    
    return exercises

# 实验环境搭建指南
def setup_quantum_crypto_environment():
    return {
        '软件工具': [
            'Qiskit: pip install qiskit',
            'Cirq: pip install cirq',
            'QuTiP: pip install qutip',
            'PyQuil: pip install pyquil'
        ],
        '硬件模拟器': [
            'IBM Quantum Experience',
            'Google Quantum AI',
            'Rigetti Forest',
            'IonQ Cloud Platform'
        ],
        '开发环境': [
            'Jupyter Notebook',
            'Python 3.8+',
            'NumPy, SciPy, Matplotlib',
            'Git版本控制'
        ]
    }