24-Oct-2026 · kgQuantum
Some news makes you stop scrolling. For me, this month it was a short PIB release: India's first free-space Quantum Key Distribution (QKD) link, over 5.56 km.
Back in 2021 I used this blog to log my Qiskit learning, one gate at a time. So today let me do the same thing with this news. We will understand what was demonstrated, why it matters, and then rebuild the core idea, the BB84 protocol, on our own laptops.
What happened?
According to the Press Information Bureau (3-Oct-2026), QNu Labs, together with BISAG-N and IIT Gandhinagar, set up a quantum-secured channel through open air between BISAG-N and IIT Gandhinagar on the night of 27–28 September.
A few numbers from the release:
- Quantum Bit Error Rate (QBER) stayed below 5%
- Secure keys were generated at 230–260 bits per second
- The keys were plugged into BISAG-N's post-quantum cryptography (PQC) platform, Vedic Kavach, which also uses quantum random number generation, to encrypt and decrypt test messages end to end
Two more October updates show the bigger picture:
- The Union Minister said India set an eight-year target of 2,000 km of quantum-secure communication under the National Quantum Mission and has reached 1,000 km in three years (PIB).
- DST's Technology Development Board signed up to support QNu Labs with ₹150 crore for a ₹300 crore project to take India's Quantum Secure and Sensing Networks from TRL 4–5 to TRL-9 (PIB, 16-Oct-2026).
QKD in plain language
Today's internet security relies on maths problems (like factoring) that are hard for classical computers. A large fault-tolerant quantum computer could break some of them. There are two ways to respond:
- PQC: new mathematical algorithms believed to resist quantum attacks. Software only.
- QKD: use the physics of single photons to share a secret key. If anyone looks, the physics leaves fingerprints.
The interesting part of the Gujarat demo is that it combined both layers. That hybrid thinking is exactly what learners and architects should absorb.
BB84: the idea behind QKD
BB84 (Bennett & Brassard, 1984) is the "Hello World" of QKD:
- Alice picks random bits and, for each bit, a random basis: Z (|0⟩/|1⟩) or X (|+⟩/|−⟩).
- Bob measures each qubit in his own random basis.
- Over a public channel they compare bases only, never bits, and keep the positions where the bases matched. This is called sifting.
- They sacrifice a sample to estimate the QBER. If an eavesdropper (Eve) measured the qubits in transit, she disturbs them, and errors jump.
With a simple intercept-and-resend attack, Eve introduces about 25% errors in the sifted key. That is why a low QBER, like the sub-5% in the trial, is the headline number.
Let's code it (Qiskit + Aer)
pip install qiskit qiskit-aer
# BB84 in a few lines of Qiskit (runs locally on the Aer simulator)
import random
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
sim = AerSimulator()
def send_qubit(bit, alice_basis, bob_basis, eve=False):
qc = QuantumCircuit(1, 1)
if bit: qc.x(0) # Alice encodes her bit...
if alice_basis == "X": qc.h(0) # ...in the Z (+) or X (x) basis
if eve: # Eve measures in a random basis and resends
e = random.choice("ZX")
if e == "X": qc.h(0)
qc.measure(0, 0)
if e == "X": qc.h(0)
if bob_basis == "X": qc.h(0) # Bob picks his own random basis
qc.measure(0, 0)
counts = sim.run(qc, shots=1).result().get_counts()
return int(max(counts, key=counts.get))
def bb84(n=400, eve=False):
alice_bits = [random.randint(0, 1) for _ in range(n)]
alice_bases = [random.choice("ZX") for _ in range(n)]
bob_bases = [random.choice("ZX") for _ in range(n)]
bob_bits = [send_qubit(b, a, c, eve) for b, a, c in zip(alice_bits, alice_bases, bob_bases)]
# Sifting: keep only positions where the bases matched (announced publicly)
keep = [i for i in range(n) if alice_bases[i] == bob_bases[i]]
errors = sum(alice_bits[i] != bob_bits[i] for i in keep)
return len(keep), errors / len(keep)
random.seed(7)
for eve in (False, True):
kept, qber = bb84(eve=eve)
print(f"Eve present: {eve!s:5} | sifted key bits: {kept} | QBER: {qber:.1%}")
When I ran it (Qiskit 2.6.1, qiskit-aer 0.18.0), I got:
Eve present: False | sifted key bits: 200 | QBER: 0.0%
Eve present: True | sifted key bits: 205 | QBER: 24.9%
About half the bits survive sifting, and Eve's presence pushes QBER to roughly 25%. Your exact numbers will vary from run to run. That is quantum randomness at work!
Try this yourself: - Let Eve attack only 20% of the qubits. How does QBER change? - Add a noise channel (Aer noise model) and see where honest noise starts to look like an attack. - Add a tiny "error correction + privacy amplification" step to get a final key.
Why this matters for learners
- Quantum security is no longer only theory in India. Field trials, national targets and TRL-9 funding mean industry will need people who understand both QKD and PQC.
- BB84 teaches the fundamentals in one go: superposition, measurement, basis choice and the no-cloning idea.
- Hybrid thinking wins. Real systems pair physics-based keys with post-quantum algorithms, so learn both stacks.
What next?
If you want to go deeper, try extending the code above: add a noise model, then error correction and privacy amplification, and read up on the post-quantum algorithms that real systems pair with QKD. Hybrid quantum-safe design is where the field is heading.
Share your QBER results in the comments. I would love to see what your Eve does!
Cheers! KG
