Quantum-Safe Cryptography Systems

import os
import hashlib
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from pqcrypto.kem.kyber512 import generate_keypair, encrypt, decrypt

class HybridKeyExchange:
    def __init__(self):
        self.classical_private_key = None
        self.classical_public_key = None
        self.pq_private_key = None
        self.pq_public_key = None
        
    def generate_keys(self):
        """Generate both classical and post-quantum key pairs"""
        # Classical RSA key pair
        self.classical_private_key = rsa.generate_private_key(
            public_exponent=65537,
            key_size=3072
        )
        self.classical_public_key = self.classical_private_key.public_key()
        
        # Post-quantum Kyber key pair
        self.pq_public_key, self.pq_private_key = generate_keypair()
        
        return {
            'classical_public': self.classical_public_key,
            'pq_public': self.pq_public_key
        }
    
    def initiate_key_exchange(self, peer_public_keys):
        """Initiate hybrid key exchange"""
        # Generate random session key material
        session_material = os.urandom(64)
        
        # Encrypt with classical algorithm
        classical_ciphertext = peer_public_keys['classical_public'].encrypt(
            session_material[:32],
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        
        # Encrypt with post-quantum algorithm
        pq_ciphertext, pq_shared_secret = encrypt(peer_public_keys['pq_public'])
        
        # Combine shared secrets
        combined_secret = self._combine_secrets(
            session_material[32:], 
            pq_shared_secret
        )
        
        return {
            'classical_ciphertext': classical_ciphertext,
            'pq_ciphertext': pq_ciphertext,
            'shared_secret': combined_secret
        }
    
    def complete_key_exchange(self, ciphertexts):
        """Complete hybrid key exchange"""
        # Decrypt classical part
        classical_secret = self.classical_private_key.decrypt(
            ciphertexts['classical_ciphertext'],
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        
        # Decrypt post-quantum part
        pq_shared_secret = decrypt(
            ciphertexts['pq_ciphertext'], 
            self.pq_private_key
        )
        
        # Combine shared secrets
        combined_secret = self._combine_secrets(classical_secret, pq_shared_secret)
        
        return combined_secret
    
    def _combine_secrets(self, classical_secret, pq_secret):
        """Securely combine classical and post-quantum shared secrets"""
        # Use HKDF to derive final shared key
        hkdf = HKDF(
            algorithm=hashes.SHA256(),
            length=32,
            salt=None,
            info=b'hybrid-key-exchange',
        )
        
        combined = classical_secret + pq_secret
        return hkdf.derive(combined)

# Usage example
def establish_secure_channel():
    # Initialize parties
    alice = HybridKeyExchange()
    bob = HybridKeyExchange()
    
    # Generate key pairs
    alice_public = alice.generate_keys()
    bob_public = bob.generate_keys()
    
    # Perform key exchange
    alice_exchange = alice.initiate_key_exchange(bob_public)
    bob_secret = bob.complete_key_exchange(alice_exchange)
    alice_secret = alice_exchange['shared_secret']
    
    # Verify shared secret
    assert alice_secret == bob_secret
    print(f"Secure channel established with {len(alice_secret)*8}-bit shared key")
    
    return alice_secret

if __name__ == "__main__":
    shared_key = establish_secure_channel()

import crypto from 'crypto';
import { SignatureManager } from './signature_manager';

interface QuantumSafeConfig {
  classicalAlgorithm: 'RSA' | 'ECDSA';
  postQuantumAlgorithm: 'Dilithium' | 'FALCON' | 'SPHINCS+';
  keySize: number;
  securityLevel: 128 | 192 | 256;
  hybridMode: boolean;
}

interface SignatureBundle {
  classicalSignature?: Buffer;
  postQuantumSignature: Buffer;
  timestamp: number;
  algorithm: string;
  metadata: SignatureMetadata;
}

interface SignatureMetadata {
  keyId: string;
  version: string;
  securityLevel: number;
  quantumSafe: boolean;
  expirationTime?: number;
}

class QuantumSafeSignatureSystem {
  private config: QuantumSafeConfig;
  private keyManager: KeyManager;
  private signatureManager: SignatureManager;

  constructor(config: QuantumSafeConfig) {
    this.config = config;
    this.keyManager = new KeyManager(config);
    this.signatureManager = new SignatureManager();
  }

  async generateKeyPair(): Promise<{
    privateKey: Buffer;
    publicKey: Buffer;
    keyId: string;
  }> {
    const keyId = this.generateKeyId();
    
    // Generate post-quantum key pair
    const pqKeyPair = await this.generatePostQuantumKeyPair();
    
    let classicalKeyPair;
    if (this.config.hybridMode) {
      // Generate classical key pair for hybrid mode
      classicalKeyPair = await this.generateClassicalKeyPair();
    }

    const keyBundle = {
      keyId,
      postQuantum: pqKeyPair,
      classical: classicalKeyPair,
      config: this.config,
      createdAt: Date.now()
    };

    return {
      privateKey: this.serializePrivateKey(keyBundle),
      publicKey: this.serializePublicKey(keyBundle),
      keyId
    };
  }

  async sign(
    message: Buffer, 
    privateKey: Buffer
  ): Promise<SignatureBundle> {
    const keyBundle = this.deserializePrivateKey(privateKey);
    const messageHash = this.hashMessage(message);
    
    const signature: SignatureBundle = {
      postQuantumSignature: await this.signWithPostQuantum(
        messageHash, 
        keyBundle.postQuantum.privateKey
      ),
      timestamp: Date.now(),
      algorithm: `${this.config.postQuantumAlgorithm}-${this.config.securityLevel}`,
      metadata: {
        keyId: keyBundle.keyId,
        version: '1.0',
        securityLevel: this.config.securityLevel,
        quantumSafe: true
      }
    };

    // Add classical signature if in hybrid mode
    if (this.config.hybridMode && keyBundle.classical) {
      signature.classicalSignature = await this.signWithClassical(
        messageHash,
        keyBundle.classical.privateKey
      );
    }

    return signature;
  }

  async verify(
    message: Buffer,
    signature: SignatureBundle,
    publicKey: Buffer
  ): Promise<boolean> {
    try {
      const keyBundle = this.deserializePublicKey(publicKey);
      const messageHash = this.hashMessage(message);

      // Verify post-quantum signature
      const pqValid = await this.verifyPostQuantumSignature(
        messageHash,
        signature.postQuantumSignature,
        keyBundle.postQuantum.publicKey
      );

      if (!pqValid) {
        return false;
      }

      // Verify classical signature if present
      if (signature.classicalSignature && keyBundle.classical) {
        const classicalValid = await this.verifyClassicalSignature(
          messageHash,
          signature.classicalSignature,
          keyBundle.classical.publicKey
        );
        
        if (!classicalValid) {
          return false;
        }
      }

      // Verify signature metadata
      return this.verifyMetadata(signature.metadata, keyBundle);
    } catch (error) {
      console.error('Signature verification failed:', error);
      return false;
    }
  }

  private async generatePostQuantumKeyPair() {
    switch (this.config.postQuantumAlgorithm) {
      case 'Dilithium':
        return this.generateDilithiumKeyPair();
      case 'FALCON':
        return this.generateFalconKeyPair();
      case 'SPHINCS+':
        return this.generateSphincsKeyPair();
      default:
        throw new Error(`Unsupported post-quantum algorithm: ${this.config.postQuantumAlgorithm}`);
    }
  }

  private async generateDilithiumKeyPair() {
    // Dilithium key generation (simplified)
    const seedLength = this.config.securityLevel / 8;
    const seed = crypto.randomBytes(seedLength);
    
    // This would use actual Dilithium implementation
    return {
      privateKey: crypto.randomBytes(2528), // Dilithium-2 private key size
      publicKey: crypto.randomBytes(1312),  // Dilithium-2 public key size
      algorithm: 'Dilithium-2'
    };
  }

  private async signWithPostQuantum(
    messageHash: Buffer,
    privateKey: Buffer
  ): Promise<Buffer> {
    // Implementation would use actual post-quantum signature library
    // This is a placeholder that demonstrates the interface
    const context = crypto.createHash('sha256');
    context.update(messageHash);
    context.update(privateKey);
    
    return context.digest();
  }

  private async verifyPostQuantumSignature(
    messageHash: Buffer,
    signature: Buffer,
    publicKey: Buffer
  ): Promise<boolean> {
    // Implementation would use actual post-quantum verification
    try {
      const context = crypto.createHash('sha256');
      context.update(messageHash);
      context.update(publicKey);
      
      const expectedSignature = context.digest();
      return crypto.timingSafeEqual(signature, expectedSignature);
    } catch {
      return false;
    }
  }

  private hashMessage(message: Buffer): Buffer {
    // Use SHA-3 for better quantum resistance
    return crypto.createHash('sha3-256').update(message).digest();
  }

  private generateKeyId(): string {
    return crypto.randomBytes(16).toString('hex');
  }

  private verifyMetadata(
    metadata: SignatureMetadata,
    keyBundle: any
  ): boolean {
    // Verify signature hasn't expired
    if (metadata.expirationTime && Date.now() > metadata.expirationTime) {
      return false;
    }

    // Verify key ID matches
    if (metadata.keyId !== keyBundle.keyId) {
      return false;
    }

    // Verify quantum-safe requirement
    if (!metadata.quantumSafe) {
      return false;
    }

    return true;
  }

  // Additional methods for classical signature operations
  private async generateClassicalKeyPair() {
    if (this.config.classicalAlgorithm === 'RSA') {
      const keyPair = crypto.generateKeyPairSync('rsa', {
        modulusLength: this.config.keySize,
        publicKeyEncoding: { type: 'spki', format: 'der' },
        privateKeyEncoding: { type: 'pkcs8', format: 'der' }
      });
      
      return {
        privateKey: keyPair.privateKey as Buffer,
        publicKey: keyPair.publicKey as Buffer,
        algorithm: 'RSA'
      };
    }
    
    throw new Error(`Unsupported classical algorithm: ${this.config.classicalAlgorithm}`);
  }

  private serializePrivateKey(keyBundle: any): Buffer {
    return Buffer.from(JSON.stringify(keyBundle));
  }

  private serializePublicKey(keyBundle: any): Buffer {
    const publicBundle = {
      keyId: keyBundle.keyId,
      postQuantum: { publicKey: keyBundle.postQuantum.publicKey },
      classical: keyBundle.classical ? { publicKey: keyBundle.classical.publicKey } : undefined,
      config: this.config
    };
    return Buffer.from(JSON.stringify(publicBundle));
  }

  private deserializePrivateKey(privateKey: Buffer): any {
    return JSON.parse(privateKey.toString());
  }

  private deserializePublicKey(publicKey: Buffer): any {
    return JSON.parse(publicKey.toString());
  }
}

// Usage example
export async function demonstrateQuantumSafeSignatures() {
  const config: QuantumSafeConfig = {
    classicalAlgorithm: 'RSA',
    postQuantumAlgorithm: 'Dilithium',
    keySize: 3072,
    securityLevel: 256,
    hybridMode: true
  };

  const signatureSystem = new QuantumSafeSignatureSystem(config);
  
  // Generate key pair
  const keyPair = await signatureSystem.generateKeyPair();
  console.log(`Generated quantum-safe key pair: ${keyPair.keyId}`);

  // Sign message
  const message = Buffer.from('Hello, quantum-safe world!');
  const signature = await signatureSystem.sign(message, keyPair.privateKey);
  console.log('Message signed with quantum-safe algorithm');

  // Verify signature
  const isValid = await signatureSystem.verify(message, signature, keyPair.publicKey);
  console.log(`Signature verification: ${isValid ? 'VALID' : 'INVALID'}`);
  
  return { keyPair, signature, isValid };
}