BIKE

BIKE (Bit Flipping Key Encapsulation) is a code-based KEM built on quasi-cyclic moderate-density parity-check (QC-MDPC) codes. A NIST Round-4 candidate that was ultimately not selected, it offers small keys but carries decoding-failure and reaction-attack considerations that demand careful, constant-time implementation.

How it works

BIKE is a KEM based on decoding QC-MDPC codes. The private key is a sparse parity-check matrix; the public key is a quasi-cyclic representation derived from it. Encapsulation introduces an error pattern, and decapsulation runs an iterative bit-flipping decoder to recover it. The quasi-cyclic structure keeps keys compact compared with other code-based schemes.

The subtlety is the decoding-failure rate (DFR). Bit-flipping decoders occasionally fail, and an attacker who can observe whether decoding succeeds — and correlate that with chosen ciphertexts — can mount a reaction attack to recover the secret key over many queries. Mitigating this requires a constant-time decoder and a conservatively low, well-analyzed DFR.

Parameter sets

BIKE submitted parameters targeting NIST security categories 1, 3, and 5, but it was not selected by NIST for standardization; its public keys and ciphertexts are small (approximate bytes).

Strengths & tradeoffs

• Small keys. Thanks to the quasi-cyclic structure, keys and ciphertexts are far smaller than Classic McEliece — only a couple of kilobytes.
• Code-based diversity. Like HQC, it offers an alternative to lattice assumptions.
• Tradeoff — DFR / reaction attacks. The iterative decoder's failure behavior must be tightly controlled; a non-constant-time decoder or an underestimated DFR opens the door to key-recovery reaction attacks. BIKE was not selected by NIST, with HQC chosen as the code-based standard instead.

When to use it

For new deployments, prefer the standardized code-based KEM HQC over BIKE, since HQC was selected and has a cleaner decoding-failure analysis. BIKE remains of research and historical interest, and may appear in experimental libraries; if you must use it, deploy only an audited constant-time implementation with conservative parameters.

Code example

import oqs

# Availability depends on the liboqs build; BIKE is not a NIST standard.
kem = "BIKE-L1"
if kem in oqs.get_enabled_kem_mechanisms():
    with oqs.KeyEncapsulation(kem) as server:
        public_key = server.generate_keypair()
        with oqs.KeyEncapsulation(kem) as client:
            ct, ss_c = client.encap_secret(public_key)
        ss_s = server.decap_secret(ct)
        assert ss_c == ss_s
else:
    print("BIKE not enabled in this liboqs build")

Related

Standards & references

• NIST PQC project — BIKE (Round 4) — status and specification pointers.
• NIST PQC project — Round-4 evaluation; HQC was selected over BIKE.
• Resources — full standards register