Cryptography Deep Dive FAQ

🔬 Understanding Lattice-Based Cryptography

ML-KEM (Module-Lattice Key Encapsulation Mechanism) is based on the Learning With Errors (LWE) problem, a mathematical problem that is believed to be hard for both classical and quantum computers to solve.

📐 The LWE Problem (Simplified)

The security of ML-KEM is based on this mathematical challenge:

The small error e "hides" the secret key s. Without e, this would be easy to solve (simple linear algebra). With e, it becomes extremely difficult—even for quantum computers!

🔑 ML-KEM Key Generation (Step-by-Step)

📨 Encapsulation (Sending a Secret)

To share a secret with someone, we use their public key (a, b):

🔓 Decapsulation (Recovering the Secret)

The recipient uses their secret key s to recover the shared secret:

🛡️ Why Quantum Computers Can't Break This

🎯 ML-KEM-1024 Parameters

📚 Further Reading: The actual ML-KEM uses polynomial rings and module lattices for efficiency, but the core security principle remains the same: adding small errors to linear equations makes them exponentially hard to solve!

🔬 Two Implementations, Same Mathematical Foundation

The PQXDH simulation uses JavaScript to demonstrate ML-KEM (Kyber), while the Slow Lynx Cryptography Discovery project includes a Rust implementation of educational LWE encryption. Both are based on the same lattice cryptography principles!

📝 Code Comparison: Key Generation

Both implementations follow the same core algorithm: b = a·s + e (mod q)

// Key Generation: b = a·s + e (mod q)
generateKeyPair() {
    // Generate public lattice vector 'a' (uniformly random)
    const a = new Uint8Array(this.publicKeySize);
    crypto.getRandomValues(a);

    // Generate secret key 's' (small binary values)
    const s = new Uint8Array(this.publicKeySize);
    crypto.getRandomValues(s);
    for (let i = 0; i < s.length; i++) {
        s[i] = s[i] & 1; // Extract lowest bit for binary secret
    }

    // Sample small error 'e' (centered binomial)
    const e = this.sampleSmallError(this.publicKeySize);

    // Compute b = a·s + e (mod q)
    const b = new Uint8Array(this.publicKeySize);
    for (let i = 0; i < this.publicKeySize; i++) {
        let sum = 0;
        for (let j = 0; j < Math.min(8, this.publicKeySize - i); j++) {
            sum += a[i + j] * s[j];
        }
        b[i] = (sum + e[i]) % 256;
    }

    return { publicKey: a, secretKey: s };
}

// Key Generation: b = a·s + e (mod q)
pub fn generate(rng: &CspRng, params: &LatticeParams)
    -> Result<LatticeKeyPair, &'static str> {
    let n = params.dimension;
    let q = params.modulus;

    // Generate secret key s (binary values {0, 1})
    let mut s = vec![0u32; n];
    for i in 0..n {
        s[i] = rng.next_u32()? % 2;
    }

    // Generate random lattice vector a
    let mut a = vec![0u32; n];
    for i in 0..n {
        a[i] = rng.next_u32()? % q;
    }

    // Sample small error e (Gaussian approximation)
    let mut e = vec![0u32; n];
    for i in 0..n {
        e[i] = sample_discrete_gaussian(rng, params.error_stddev, q)?;
    }

    // Compute b = a*s + e (mod q) - element-wise
    let mut b = vec![0u32; n];
    for i in 0..n {
        let mut sum = 0u64;
        sum = (a[i] as u64 * s[i] as u64) % q as u64;
        b[i] = ((sum + e[i] as u64) % q as u64) as u32;
    }

    Ok(LatticeKeyPair { public_key: (a, b), secret_key: s })
}

🎯 Key Similarities

🔧 Parameter Design Comparison

The Rust implementation offers configurable security levels through parameter presets:

🔗 Cryptography Education Toolkit

💡 Design Philosophy: The JavaScript version prioritizes browser accessibility and protocol demonstration (ML-KEM in PQXDH). The Rust version emphasizes configurable parameters, comprehensive testing, and integration with a CSPRNG for cryptographic research. Both teach the same core LWE concepts from different angles!