# 1️ a virtual environment (optional but recommended)
python -m venv venv  

### 2.1 Python  

```bash
# Clone the repo (optional – you can work in any folder)
git clone https://github.com/icarax/blog-quantum-safe-demo.git
cd blog-quantum-safe-demo

# Create a virtual environment
python -m venv .venv
source .venv/bin/activate   # Windows: .venv\Scripts\activate

# Upgrade pip and install the OQS Python bindings
pip install --upgrade pip
pip install oqs   # pulls pre‑built liboqs wheels; falls back to source if needed

# Verify installation
python -c "import oqs; print(oqs.__version__)"

# Initialize a new npm project (if you don’t have one yet)
npm init -y

# Install the OQS Node.js binding (includes a pre‑built liboqs WASM binary)
npm install @open-quantum-safe/nodejs

# Optional: TypeScript support
npm install --save-dev typescript @types/node
npx tsc --init   # creates a basic tsconfig.json

#!/usr/bin/env python3
"""
Quantum‑safe demo using liboqs Python bindings.
- Kyber768: Key Encapsulation Mechanism (KEM) for encryption.
- Dilithium3: Digital signature scheme.
"""

import os
import oqs   # pip install oqs

# -------------------------------------------------
# Configuration – change these to experiment with other algorithms
# -------------------------------------------------
KEM_ALG = os.getenv("OQS_KEM_ALG", "Kyber768")   # NIST‑selected KEM
SIG_ALG = os.getenv("OQS_SIG_ALG", "Dilithium3") # NIST‑selected signature

def demo_kem():
    """Generate a Kyber keypair, encapsulate a secret, then decapsulate."""
    print(f"\n=== KEM Demo ({KEM_ALG}) ===")
    with oqs.KeyEncapsulation(KEM_ALG) as client:
        # Client generates its keypair
        public_key = client.generate_keypair()
        secret_key = client.export_secret_key()
        print(f"Client public key length: {len(public_key)} bytes")
        print(f"Client secret key length: {len(secret_key)} bytes")

        # Server (or any party) uses the public key to encapsulate a shared secret
        with oqs.KeyEncapsulation(KEM_ALG) as server:
            ciphertext, shared_secret_server = server.encap_secret(public_key)
            print(f"Ciphertext length: {len(ciphertext)} bytes")
            print(f"Shared secret (server) length: {len(shared_secret_server)} bytes")

        # Client decapsulates to recover the same shared secret
        shared_secret_client = client.decap_secret(ciphertext)
        print(f"Shared secret (client) length: {len(shared_secret_client)} bytes")
        assert shared_secret_client == shared_secret_server, "KEM mismatch!"
        print("✅ KEM success: shared secrets match.")

def demo_sig():
    """Generate a Dilithium keypair, sign a message, then verify."""
    print(f"\n=== Signature Demo ({SIG_ALG}) ===")
    with oqs.Signature(SIG_ALG) as signer:
        # Key pair generation
        public_key = signer.generate_keypair()
        secret_key = signer.export_secret_key()
        print(f"Public key length: {len(public_key)} bytes")
        print(f"Secret key length: {len(secret_key)} bytes")

        # Message to sign
        message = b"France mandates quantum‑safe encryption by 2027."
        signature = signer.sign(message)
        print(f"Signature length: {len(signature)} bytes")

        # Verification
        verifier = oqs.Signature(SIG_ALG)
        verifier.import_public_key(public_key)
        assert verifier.verify(message, signature), "Signature verification failed!"
        print("✅ Signature success: message verified.")
        # Clean up verifier (optional, but good practice)
        del verifier

if __name__ == "__main__":
    try:
        demo_kem()
        demo_sig()
    except Exception as exc:
        print(f"\n❌ Error: {exc}")
        raise

// src/demo.ts
import { KeyEncapsulation, Signature } from "@open-quantum-safe/nodejs";

/**
 * Environment variables (fallbacks shown)
 *   OQS_KEM_ALG – e.g., "Kyber768"
 *   OQS_SIG_ALG – e.g., "Dilithium3"
 */
const KEM_ALG = process.env.OQS_KEM_ALG ?? "Kyber768";
const SIG_ALG = process.env.OQS_SIG_ALG ?? "Dilithium3";

async function runKEMDemo() {
  console.log(`\n=== KEM Demo (${KEM_ALG}) ===`);

  // ----- Client side -----
  const client = new KeyEncapsulation(KEM_ALG);
  const clientKeypair = client.generateKeyPair();
  const clientPublicKey = clientKeypair.publicKey;
  const clientSecretKey = clientKeypair.secretKey;

  console.log(`Client public key length: ${clientPublicKey.length} bytes`);
  console.log(`Client secret key length: ${clientSecretKey.length} bytes`);

  // ----- Server side (encapsulation) -----
  const server = new KeyEncapsulation(KEM_ALG);
  const encapResult = server.encapSecret(clientPublicKey);
  const ciphertext = encapResult.ciphertext;
  const sharedSecretServer = encapResult.sharedSecret;

  console.log(`Ciphertext length: ${ciphertext.length} bytes`);
  console.log(`Shared secret (server) length: ${sharedSecretServer.length} bytes`);

  // ----- Client side (decapsulation) -----
  const sharedSecretClient = client.decapSecret(ciphertext);
  console.log(`Shared secret (client) length: ${sharedSecretClient.length} bytes`);

  if (!sharedSecretClient.equals(sharedSecretServer)) {
    throw new Error("KEM mismatch: shared secrets differ");
  }
  console.log("✅ KEM success: shared secrets match.");

  // Clean up
  client.delete();
  server.delete();
}

async function runSignatureDemo() {
  console.log(`\n=== Signature Demo (${SIG_ALG}) ===`);

  const signer = new Signature(SIG_ALG);
  const sigKeypair = signer.generateKeyPair();
  const publicKey = sigKeypair.publicKey;
  const secretKey = sigKeypair.secretKey;

  console.log(`Public key length: ${publicKey.length} bytes`);
  console.log(`Secret key length: ${secretKey.length} bytes`);

  const message = Buffer.from(
    "France mandates quantum‑safe encryption by 2027.",
    "utf8"
  );
  const signature = signer.sign(message);
  console.log(`Signature length: ${signature.length} bytes`);

  const verifier = new Signature(SIG_ALG);
  verifier.importPublicKey(publicKey);
  const isValid = verifier.verify(message, signature);
  if (!isValid) {
    throw new Error("Signature verification failed");
  }
  console.log("✅ Signature success: message verified.");

  // Clean up
  signer.delete();
  verifier.delete();
}

async function main() {
  try {
    await runKEMDemo();
    await runSignatureDemo();
  } catch (err) {
    console.error("\n❌ Error:", err);
    process.exit(1);
  }
}

// Run when executed directly
if (require.main === module) {
  main();
}

/* Export for use in other modules */
export { runKEMDemo, runSignatureDemo };

# Compile TypeScript (if you saved as .ts)
npx tsc demo.ts   # produces demo.js

# Or run directly with ts-node (dev only)
npx ts-node demo.ts

# With Node.js (compiled JS)
node demo.js

# .env example
OQS_KEM_ALG=Kyber768
OQS_SIG_ALG=Dilithium3
LOG_LEVEL=info

# Python – load .env
from dotenv import load_dotenv
load_dotenv()   # reads .env into os.environ

// Node – load .env
require('dotenv').config();

# Pseudo‑code (Python)
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes
import oqs, os

def hybrid_encap(recipient_pk_classical, recipient_pk_pqc):
    # 1. Generate random ephemeral secret
    z = os.urandom(32)

    # 2. Classical part (e.g., X25519)
    #    ... use cryptography.hazmat.primitives.asymmetric.x25519 ...

    # 3. PQC part
    with oqs.KeyEncapsulation("Kyber768") as kem:
        ct, ss_pqc = kem.encap_secret(recipient_pk_pqc)

    # 4. Combine via HKDF
    hkdf = HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=None,
        info=b"hybrid-encap",
    )
    key = hkdf.derive(z + ss_classical + ss_pqc)   # 32‑byte traffic key
    return key, ct   # send ct + classical ciphertext