Struct QuantumSignature 

pub struct QuantumSignature { /* private fields */ }

Quantum-safe one-time digital signature key pair.

Implements a Lamport one-time signature (Lamport, 1979): a hash-based scheme whose security rests only on the one-wayness of a hash function, not on factoring/discrete-log assumptions that Shor’s algorithm breaks – making it “quantum-safe” in the sense this module’s name advertises, unlike the previous XOR-based placeholder. Verification (see QuantumSignatureVerifyingKey::verify) uses only the public key, structurally correcting the previous bug where verify could only be called by whoever held the private key.

This is genuinely a one-time signature scheme: signing two different messages with the same key pair reveals enough of the private key to forge further signatures, exactly as with real Lamport signatures. A new QuantumSignature::new key pair should be generated per message.

Implementations

impl QuantumSignature

pub fn new(security_bits: usize, algorithm: &str) -> Result<Self>

Creates a new quantum signature key pair.

Examples found in repository

examples/quantum_crypto.rs (line 141)

fn run_signature_example() -> Result<()> {
    println!("\nQuantum Digital Signatures");
    println!("-------------------------");

    // Create quantum signature with 256 qubits
    let num_qubits = 256;
    println!("Creating quantum signature scheme with {num_qubits} qubits");

    // Choose a quantum-resistant algorithm
    let algorithm = "Dilithium";
    println!("Using algorithm: {algorithm}");

    let signature = QuantumSignature::new(num_qubits, algorithm)?;
    println!("Quantum signature scheme created");

    // Sign a message
    let message = b"This message is quantum-signed";
    println!(
        "Signing message: '{}'",
        std::str::from_utf8(message).unwrap()
    );

    let start = Instant::now();
    let sig = signature.sign(message)?;
    println!("Signature generated in {:.2?}", start.elapsed());
    println!("Signature size: {} bytes", sig.len());

    // Verify signature
    println!("Verifying signature...");
    let start = Instant::now();
    let is_valid = signature.verify(message, &sig)?;
    println!("Verification completed in {:.2?}", start.elapsed());

    if is_valid {
        println!("✓ Signature verification successful!");
    } else {
        println!("✗ Signature verification failed!");
    }

    // Try with tampered message
    let tampered = b"This message has been modified";
    println!("Verifying signature with tampered message...");
    let is_valid = signature.verify(tampered, &sig)?;

    if is_valid {
        println!("✗ Signature incorrectly verified on tampered message!");
    } else {
        println!("✓ Signature correctly rejected tampered message!");
    }

    Ok(())
}

pub fn sign(&self, message: &[u8]) -> Result<Vec<u8>>

Signs a message: hashes it with SHA-256, then reveals one of the two private-key preimages per digest bit (selected by that bit’s value).

Examples found in repository

examples/quantum_crypto.rs (line 152)

fn run_signature_example() -> Result<()> {
    println!("\nQuantum Digital Signatures");
    println!("-------------------------");

    // Create quantum signature with 256 qubits
    let num_qubits = 256;
    println!("Creating quantum signature scheme with {num_qubits} qubits");

    // Choose a quantum-resistant algorithm
    let algorithm = "Dilithium";
    println!("Using algorithm: {algorithm}");

    let signature = QuantumSignature::new(num_qubits, algorithm)?;
    println!("Quantum signature scheme created");

    // Sign a message
    let message = b"This message is quantum-signed";
    println!(
        "Signing message: '{}'",
        std::str::from_utf8(message).unwrap()
    );

    let start = Instant::now();
    let sig = signature.sign(message)?;
    println!("Signature generated in {:.2?}", start.elapsed());
    println!("Signature size: {} bytes", sig.len());

    // Verify signature
    println!("Verifying signature...");
    let start = Instant::now();
    let is_valid = signature.verify(message, &sig)?;
    println!("Verification completed in {:.2?}", start.elapsed());

    if is_valid {
        println!("✓ Signature verification successful!");
    } else {
        println!("✗ Signature verification failed!");
    }

    // Try with tampered message
    let tampered = b"This message has been modified";
    println!("Verifying signature with tampered message...");
    let is_valid = signature.verify(tampered, &sig)?;

    if is_valid {
        println!("✗ Signature incorrectly verified on tampered message!");
    } else {
        println!("✓ Signature correctly rejected tampered message!");
    }

    Ok(())
}

pub fn verify(&self, message: &[u8], signature: &[u8]) -> Result<bool>

Verifies a signature using this key pair’s public key. Structurally identical to QuantumSignatureVerifyingKey::verify – exposed here too so existing callers that only have a full QuantumSignature (e.g. the signer itself, checking its own work) do not need to call Self::verifying_key first.

Examples found in repository

examples/quantum_crypto.rs (line 159)

fn run_signature_example() -> Result<()> {
    println!("\nQuantum Digital Signatures");
    println!("-------------------------");

    // Create quantum signature with 256 qubits
    let num_qubits = 256;
    println!("Creating quantum signature scheme with {num_qubits} qubits");

    // Choose a quantum-resistant algorithm
    let algorithm = "Dilithium";
    println!("Using algorithm: {algorithm}");

    let signature = QuantumSignature::new(num_qubits, algorithm)?;
    println!("Quantum signature scheme created");

    // Sign a message
    let message = b"This message is quantum-signed";
    println!(
        "Signing message: '{}'",
        std::str::from_utf8(message).unwrap()
    );

    let start = Instant::now();
    let sig = signature.sign(message)?;
    println!("Signature generated in {:.2?}", start.elapsed());
    println!("Signature size: {} bytes", sig.len());

    // Verify signature
    println!("Verifying signature...");
    let start = Instant::now();
    let is_valid = signature.verify(message, &sig)?;
    println!("Verification completed in {:.2?}", start.elapsed());

    if is_valid {
        println!("✓ Signature verification successful!");
    } else {
        println!("✗ Signature verification failed!");
    }

    // Try with tampered message
    let tampered = b"This message has been modified";
    println!("Verifying signature with tampered message...");
    let is_valid = signature.verify(tampered, &sig)?;

    if is_valid {
        println!("✗ Signature incorrectly verified on tampered message!");
    } else {
        println!("✓ Signature correctly rejected tampered message!");
    }

    Ok(())
}

pub fn verifying_key(&self) -> QuantumSignatureVerifyingKey

Extracts a standalone QuantumSignatureVerifyingKey containing only the public key, for distribution to verifiers.

pub fn public_key_bytes(&self) -> Vec<u8>

Serializes this key pair’s public key; see QuantumSignatureVerifyingKey::to_bytes.

Trait Implementations

impl Clone for QuantumSignature

fn clone(&self) -> QuantumSignature

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for QuantumSignature

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.