Struct XChaChaKey 

pub struct XChaChaKey(/* private fields */);

XChaCha20Poly1305 key (256 bits / 32 bytes)

Implementations

impl XChaChaKey

pub fn generate() -> Self

Generate a new random key

Examples found in repository

examples/basic_usage.rs (line 35)

fn xchacha_example() -> Result<()> {
    // Generate a key and nonce
    let key = XChaChaKey::generate();
    let nonce = XChaChaNonce::generate();
    
    // Message to encrypt
    let plaintext = b"Hello, World! This is a secret message.";
    let aad = b"Additional authenticated data";
    
    println!("  Original message: {:?}", std::str::from_utf8(plaintext).unwrap());
    println!("  Key size: {} bytes", key.as_bytes().len());
    println!("  Nonce size: {} bytes", nonce.as_bytes().len());
    
    // Encrypt the message
    let ciphertext = XChaChaCrypto::encrypt(&key, &nonce, plaintext, Some(aad))?;
    println!("  Ciphertext size: {} bytes", ciphertext.len());
    
    // Decrypt the message
    let decrypted = XChaChaCrypto::decrypt(&key, &nonce, &ciphertext, Some(aad))?;
    println!("  Decrypted message: {:?}", std::str::from_utf8(&decrypted).unwrap());
    
    // Verify they match
    assert_eq!(plaintext, &decrypted[..]);
    println!("  ✓ Encryption/Decryption successful!");
    
    Ok(())
}

examples/benchmark.rs (line 37)

fn benchmark_xchacha() -> Result<()> {
    let key = XChaChaKey::generate();
    let nonce = XChaChaNonce::generate();
    let plaintext = vec![0u8; MESSAGE_SIZE];
    
    // Benchmark encryption
    let start = Instant::now();
    let mut ciphertext = Vec::new();
    for _ in 0..BENCHMARK_ITERATIONS {
        ciphertext = XChaChaCrypto::encrypt(&key, &nonce, &plaintext, None)?;
    }
    let encryption_time = start.elapsed();
    
    // Benchmark decryption
    let start = Instant::now();
    for _ in 0..BENCHMARK_ITERATIONS {
        let _decrypted = XChaChaCrypto::decrypt(&key, &nonce, &ciphertext, None)?;
    }
    let decryption_time = start.elapsed();
    
    let encryption_throughput = (BENCHMARK_ITERATIONS * MESSAGE_SIZE) as f64 / encryption_time.as_secs_f64() / 1_000_000.0;
    let decryption_throughput = (BENCHMARK_ITERATIONS * MESSAGE_SIZE) as f64 / decryption_time.as_secs_f64() / 1_000_000.0;
    
    println!("  Encryption: {:.2} MB/s ({:.2} μs per operation)", 
             encryption_throughput, 
             encryption_time.as_micros() as f64 / BENCHMARK_ITERATIONS as f64);
    println!("  Decryption: {:.2} MB/s ({:.2} μs per operation)", 
             decryption_throughput, 
             decryption_time.as_micros() as f64 / BENCHMARK_ITERATIONS as f64);
    
    Ok(())
}

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Create a key from raw bytes

Examples found in repository

examples/benchmark.rs (line 115)

fn benchmark_hybrid() -> Result<()> {
    let plaintext = vec![0u8; MESSAGE_SIZE];
    
    // Benchmark full hybrid encryption
    let start = Instant::now();
    for _ in 0..BENCHMARK_ITERATIONS {
        // Key establishment
        let alice_keypair = KyberCrypto::generate_keypair();
        let (shared_secret, _kyber_ciphertext) = KyberCrypto::encapsulate(&alice_keypair.public_key);
        
        // Data encryption
        let xchacha_key = XChaChaKey::from_bytes(shared_secret.as_bytes())?;
        let (_nonce, _ciphertext) = XChaChaCrypto::encrypt_with_random_nonce(
            &xchacha_key,
            &plaintext,
            None,
        )?;
    }
    let hybrid_time = start.elapsed();
    
    let hybrid_throughput = (BENCHMARK_ITERATIONS * MESSAGE_SIZE) as f64 / hybrid_time.as_secs_f64() / 1_000_000.0;
    
    println!("  Hybrid Encryption: {:.2} MB/s ({:.2} ms per operation)", 
             hybrid_throughput, 
             hybrid_time.as_millis() as f64 / BENCHMARK_ITERATIONS as f64);
    
    Ok(())
}

examples/basic_usage.rs (line 102)

fn hybrid_example() -> Result<()> {
    println!("  Setting up hybrid encryption...");
    
    // Step 1: Key establishment with Kyber1024
    let alice_keypair = KyberCrypto::generate_keypair();
    let (shared_secret, kyber_ciphertext) = KyberCrypto::encapsulate(&alice_keypair.public_key);
    
    // Step 2: Use shared secret as XChaCha20Poly1305 key
    let xchacha_key = XChaChaKey::from_bytes(shared_secret.as_bytes())?;
    
    // Step 3: Encrypt data with XChaCha20Poly1305
    let plaintext = b"This is a secret message using hybrid post-quantum encryption!";
    println!("  Message to encrypt: {:?}", std::str::from_utf8(plaintext).unwrap());
    
    let (nonce, ciphertext) = XChaChaCrypto::encrypt_with_random_nonce(
        &xchacha_key,
        plaintext,
        None,
    )?;
    
    println!("  Hybrid encryption complete!");
    println!("  - Kyber ciphertext size: {} bytes", kyber_ciphertext.as_bytes().len());
    println!("  - XChaCha nonce size: {} bytes", nonce.as_bytes().len());
    println!("  - XChaCha ciphertext size: {} bytes", ciphertext.len());
    
    // Decryption process:
    println!("  Decrypting...");
    
    // Step 1: Alice decapsulates the shared secret
    let alice_shared_secret = KyberCrypto::decapsulate(&kyber_ciphertext, &alice_keypair.secret_key);
    let alice_xchacha_key = XChaChaKey::from_bytes(alice_shared_secret.as_bytes())?;
    
    // Step 2: Decrypt the message
    let decrypted = XChaChaCrypto::decrypt(&alice_xchacha_key, &nonce, &ciphertext, None)?;
    
    println!("  Decrypted message: {:?}", std::str::from_utf8(&decrypted).unwrap());
    
    // Verify they match
    assert_eq!(plaintext, &decrypted[..]);
    println!("  ✓ Hybrid encryption/decryption successful!");
    
    Ok(())
}

pub fn as_bytes(&self) -> &[u8]

Get the raw key bytes

Examples found in repository

examples/basic_usage.rs (line 43)

fn xchacha_example() -> Result<()> {
    // Generate a key and nonce
    let key = XChaChaKey::generate();
    let nonce = XChaChaNonce::generate();
    
    // Message to encrypt
    let plaintext = b"Hello, World! This is a secret message.";
    let aad = b"Additional authenticated data";
    
    println!("  Original message: {:?}", std::str::from_utf8(plaintext).unwrap());
    println!("  Key size: {} bytes", key.as_bytes().len());
    println!("  Nonce size: {} bytes", nonce.as_bytes().len());
    
    // Encrypt the message
    let ciphertext = XChaChaCrypto::encrypt(&key, &nonce, plaintext, Some(aad))?;
    println!("  Ciphertext size: {} bytes", ciphertext.len());
    
    // Decrypt the message
    let decrypted = XChaChaCrypto::decrypt(&key, &nonce, &ciphertext, Some(aad))?;
    println!("  Decrypted message: {:?}", std::str::from_utf8(&decrypted).unwrap());
    
    // Verify they match
    assert_eq!(plaintext, &decrypted[..]);
    println!("  ✓ Encryption/Decryption successful!");
    
    Ok(())
}

Trait Implementations

impl Clone for XChaChaKey

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Zeroize for XChaChaKey

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.