Build a Hybrid QKD/PQC Simulator with Secure Key Management using GPT-5 Pro and BoTorch
This challenge focuses on designing and simulating a hybrid secure communication network. Participants will implement a system that leverages Post-Quantum Cryptography (PQC) for initial secure channel establishment and classical data encryption, complemented by a simulated Quantum Key Distribution (QKD) layer for generating and distributing truly quantum-secure keys between multiple 'cities' or nodes. The system must demonstrate secure key negotiation, lifecycle management, and integration with a simulated application layer. The solution should incorporate advanced optimization techniques for QKD channel parameter selection and utilize modern AI tools for secure key management policy generation and network performance analysis. This challenge bridges the gap between theoretical quantum security and practical, scalable deployment in a classical network infrastructure.
What you are building
The core problem, expected build, and operating context for this challenge.
Implement a Python-based simulation of a multi-node hybrid QKD and PQC network for secure key exchange and data encryption.
How work is evaluated
The evaluation will assess the correctness of the PQC and QKD implementations, the robustness of the key management system, the effectiveness of BoTorch optimization, and the overall network simulation's functionality.
Challenge datasets
Public datasets, plus the private datasets you have access to.
What you should walk away with
Master the theoretical foundations of the BB84 QKD protocol and its practical limitations (e.g., distance, error rates, photon loss).
Implement a simulated QKD key generation and distribution mechanism in Python, including error correction (e.g., Cascade, Winnow) and privacy amplification.
Integrate selected Post-Quantum Cryptography (PQC) algorithms (e.g., Kyber for KEM, Dilithium for signatures, using `pqc-py` or similar libraries) to establish initial secure communication channels between nodes.
Design a secure key management system that handles key generation, distribution, rotation, and revocation for both PQC and QKD-derived keys across a simulated multi-city network using secure multi-party computation (MCP) principles for distributed trust.
Optimize QKD transmission parameters (e.g., pulse intensity, detection efficiency) for maximum secure key rate and minimum Quantum Bit Error Rate (QBER) across a simulated noisy channel using `BoTorch` for Bayesian Optimization.
Build a network simulator in Python (e.g., using `networkx` for topology, custom messaging layer) to model key exchange and secure data transmission between N nodes, incorporating both PQC and QKD layers.
Leverage an LLM (e.g., simulated `GPT-5 Pro` API calls or local inference model for policy generation) to dynamically generate security policies for key usage, storage, and access control based on simulated threat intelligence.
Develop a robust logging and monitoring framework to track QBER, key rates, and security events within the simulated network.
Reference links and supporting material
Sample data for 4 tasks
Challenge setup
The evaluation will assess the correctness of the PQC and QKD implementations, the robustness of the key management system, the effectiveness of BoTorch optimization, and the overall network simulation's functionality.
Challenge input
{ "node1_pqc_keys": {...}, "node2_pqc_keys": {...} }
Agent execution
No agent tool is listed for this challenge.
Evaluated output
{ "symmetric_key_match": true/false, "session_established": true/false }
- Verifies successful PQC key encapsulation and signature verification, leading to a shared symmetric key.
- Confirms QKD simulation generates a non-zero secure key rate with QBER below 5% after error correction and...
- Checks if the optimized parameters lead to a higher secure key rate than initial parameters, respecting QBE...
- Secure Key Rate target: 2000
- Python execution harness
Summary shows the first task, up to three tools, and up to three evidence items. Open the technical recipe to view all configured items.
View technical recipe
Configured tools
No tool records are attached.
Evaluation contract
- Verifies successful PQC key encapsulation and signature verification, leading to a shared symmetric key.
- Confirms QKD simulation generates a non-zero secure key rate with QBER below 5% after error correction and privacy amplification.
- Checks if the optimized parameters lead to a higher secure key rate than initial parameters, respecting QBER threshold.
- Ensures the network can perform key rotation without interrupting secure communication.
Metrics
- Secure Key Rate · Target 2000
- QBER · Target 2
- Key Rotation Latency · Target 10
Workflow tasks
- Task 1
Input: { "node1_pqc_keys": {...}, "node2_pqc_keys": {...} }
Output: { "symmetric_key_match": true/false, "session_established": true/false }
Execution harness: Python
- Task 2
Input: { "channel_distance_km": 100, "loss_per_km_db": 0.2, "detector_efficiency": 0.9, "dark_count_rate": 1e-6 }
Output: { "secure_key_rate_bps": 1000, "qber_percentage": 2.5, "privacy_amplification_factor": 0.5 }
Execution harness: Python
- Task 3
Input: { "initial_params": {"intensity": 0.1}, "target_qber_threshold": 0.03, "initial_secure_key_rate": 1000 }
Output: { "optimized_params": {"intensity": 0.15}, "max_secure_key_rate": 2000, "final_qber": 0.025 }
Execution harness: Python
- Task 4
Input: { "network_topology": {"nodes": ["city_a", "city_b"], "links": [["city_a", "city_b"]]}, "rotation_interval_seconds": 3600 }
Output: { "keys_rotated_successfully": true, "communication_uninterrupted": true, "audit_log_valid": true }
Execution harness: Python
Recipe freeze marker
No recipe freeze time is recorded.