BB84 Quantum Key Distribution Simulator

A Python simulation of the BB84 QKD protocol using Qiskit's Aer simulator. Demonstrates secure key exchange between Alice and Bob, and eavesdropper (Eve) detection via QBER (Quantum Bit Error Rate).

How It Works

Alice                          Quantum Channel                    Bob
  |                                                            |
  |-- random bit in random basis (Z/X) ----------------------->|
  |                    (Eve intercepts?)                       |
  |<-- measurement in random basis (Z/X) ---------------------|
  |                                                            |
  |-- basis reconciliation (public classical channel) ------->|
  |<-- basis reconciliation (public classical channel) -------|
  |                                                            |
  |-- QBER estimation on sample (public) -------------------->|
  |<-- QBER estimation on sample (public) --------------------|
  |                                                            |
   sifted key == sifted key  →  SECURE KEY

1. Alice prepares random bits in random bases (Z = computational, X = Hadamard)
2. Eve (optional) intercepts, measures in random basis, resends
3. Bob measures each qubit in his own random basis
4. Sifting — Alice and Bob publicly compare bases, keep only matching ones
5. QBER check — sample the sifted key; ~0% error = no Eve, ~25% error = Eve present

Files

File	Purpose
bb84_qkd.py	Core protocol implementation — encoding, measurement, sifting, QBER, Eve intercept
qkd_demo.py	Runnable demos: no Eve, Eve present, statistical analysis, QBER vs N
requirements.txt	Python dependencies

Requirements

• Python 3.8+
• pip

Installation

cd bb84-qkd-simulator
pip install -r requirements.txt

Usage

Run the demo

python3 qkd_demo.py

Sample output

==================================================
         BB84 Quantum Key Distribution
==================================================

=== Demo 1: No Eve (100 qubits) ===
Alice's key:  10110011010101101011
Bob's key:    10110011010101101011
Keys match?   YES
QBER:         0.0%

=== Demo 2: Eve Intercepting (100 qubits) ===
Alice's key:  10110011010101101011
Bob's key:    10010010010101001011
Keys match?   NO
QBER:         25.0%

=== Demo 3: Statistical Analysis (100 trials, no Eve) ===
Average QBER over 100 trials: 0.00%

=== Demo 4: QBER vs Number of Qubits (with Eve) ===
  N=  10 -> QBER = 30.0%
  N=  50 -> QBER = 24.0%
  N= 100 -> QBER = 25.0%
  N= 500 -> QBER = 25.0%
  N=1000 -> QBER = 25.0%

Conclusion: QBER stays ~25% regardless of N,
so eavesdropping is detected at any scale!

Use in your own code

from bb84_qkd import run_bb84, encode_bit, measure_qubit, sift_keys, calculate_qber

# Run full protocol
result = run_bb84(n=100, eve_present=False)
print(f"Key length: {result['key_length']}")
print(f"QBER: {result['qber']:.1%}")
print(f"Alice's key: {result['alice_key']}")
print(f"Bob's key:   {result['bob_key']}")

# Or build blocks manually
qc = encode_bit(1, "X")          # encode bit=1 in X basis (|->)
bit = measure_qubit(qc, "X")     # measure in X basis → should get 1

API Reference

Function	Description	Returns
encode_bit(bit, basis)	Encode 0/1 in Z or X basis	QuantumCircuit
measure_qubit(circuit, basis)	Measure qubit in Z or X basis	int (0 or 1)
alice_prepare_qubits(n)	Alice generates n random qubits	(bits, bases, circuits)
bob_measure_qubits(circuits, bases)	Bob measures with his bases	list[int]
sift_keys(alice_bases, bob_bases, alice_bits, bob_bits)	Keep matching-basis bits	(alice_key_str, bob_key_str)
calculate_qber(key1, key2)	Quantum Bit Error Rate	float (0.0–1.0)
eve_intercept(circuits)	Eve measures & resends in random basis	list[QuantumCircuit]
run_bb84(n, eve_present)	Full BB84 protocol run	dict with keys, QBER, metadata

Key Concepts

Concept	Value / Note
Bases	Z = computational (
QBER without Eve	0% (theoretical, ideal simulator)
QBER with intercept-resend Eve	25% (measures in wrong basis 50% of time, 50% error on those)
Sifted key length	~50% of sent qubits (bases match randomly)

Dependencies

• qiskit >= 1.0
• qiskit-aer >= 0.14

What's Next?

BB84 is the foundation for practical QKD. Extensions to explore:

• Error correction & privacy amplification — turn sifted key into identical secret key
• Decoy-state BB84 — defend against photon-number-splitting attacks (weak coherent pulses)
• E91 protocol — entanglement-based QKD using Bell states (see bell-state-generator)
• Device-independent QKD — security from Bell violation alone (CHSH game)
• Quantum repeaters — extend distance beyond ~100km fiber loss limit

License

MIT — educational / experimental use.