1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Conceptual example of Kyber
import numpy as np
from cryptography.hazmat.primitives import hashes

class Kyber:
    def __init__(self, n=256, q=3329, k=2):
        self.n = n  # Polynomial degree
        self.q = q  # Modulus
        self.k = k  # Module dimension
    
    def keygen(self):
        # Generate public and private key
        s = self.sample_secret()
        A = self.sample_matrix()
        e = self.sample_error()
        
        t = (A @ s + e) % self.q
        pk = (A, t)
        sk = s
        
        return pk, sk
    
    def encrypt(self, pk, message):
        A, t = pk
        r = self.sample_secret()
        e1 = self.sample_error()
        e2 = self.sample_error()
        
        u = (A.T @ r + e1) % self.q
        v = (t @ r + e2 + message) % self.q
        
        return (u, v)
    
    def decrypt(self, sk, ciphertext):
        u, v = ciphertext
        message = (v - sk @ u) % self.q
        return message

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

# Conceptual example of Dilithium
class Dilithium:
    def __init__(self, n=256, q=8380417, k=4, l=4):
        self.n = n
        self.q = q
        self.k = k
        self.l = l
    
    def keygen(self):
        # Generate public and private key
        rho = self.sample_random()
        K = self.sample_random()
        
        A = self.expand_matrix(rho)
        s1 = self.sample_secret(self.l)
        s2 = self.sample_secret(self.k)
        
        t = (A @ s1 + s2) % self.q
        pk = (rho, t)
        sk = (rho, K, s1, s2, t)
        
        return pk, sk
    
    def sign(self, sk, message):
        rho, K, s1, s2, t = sk
        
        mu = self.hash_message(message)
        rho_prime = self.hash_keys(rho, t)
        kappa = 0
        
        while True:
            y = self.sample_gamma1()
            w = self.expand_matrix(rho_prime) @ y
            w1 = self.high_bits(w)
            c = self.hash_challenge(mu, w1)
            z = y + c * s1
            
            if self.check_norm(z) and self.check_norm(c * s2):
                h = self.make_hint(w - c * s2, w1)
                return (c, z, h)
            
            kappa += 1
            if kappa >= 100:
                return None
    
    def verify(self, pk, message, signature):
        rho, t = pk
        c, z, h = signature
        
        mu = self.hash_message(message)
        rho_prime = self.hash_keys(rho, t)
        w1 = self.expand_matrix(rho_prime) @ z - c * t
        w1 = self.use_hint(w1, h)
        c_prime = self.hash_challenge(mu, w1)
        
        return c == c_prime and self.check_norm(z)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Example of hybrid approach
class HybridCrypto:
    def __init__(self):
        self.classical_crypto = RSACrypto()
        self.post_quantum_crypto = KyberCrypto()
    
    def encrypt(self, message):
        # Encrypt with both algorithms
        classical_cipher = self.classical_crypto.encrypt(message)
        pq_cipher = self.post_quantum_crypto.encrypt(message)
        
        return {
            'classical': classical_cipher,
            'post_quantum': pq_cipher
        }
    
    def decrypt(self, ciphertext):
        # Attempt to decrypt with both
        try:
            return self.classical_crypto.decrypt(ciphertext['classical'])
        except:
            return self.post_quantum_crypto.decrypt(ciphertext['post_quantum'])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Example with liboqs
import oqs

# Generate Kyber keys
kem = oqs.KeyEncapsulation("Kyber512")
public_key, secret_key = kem.generate_keypair()

# Encrypt
ciphertext, shared_secret = kem.encap_secret(public_key)

# Decrypt
shared_secret_decrypted = kem.decap_secret(ciphertext, secret_key)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Example with reference implementation
from pqcrypto import kyber, dilithium

# Kyber KEM
pk, sk = kyber.keypair()
ct, ss = kyber.encapsulate(pk)
ss_dec = kyber.decapsulate(ct, sk)

# Dilithium Signatures
pk, sk = dilithium.keypair()
sig = dilithium.sign(sk, message)
valid = dilithium.verify(pk, message, sig)