Struct QuantumSignature 

pub struct QuantumSignature { /* private fields */ }

Quantum digital signature

Implementations

impl QuantumSignature

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

Creates a new quantum signature

Examples found in repository

examples/quantum_crypto.rs (line 136)

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 {} qubits",
        num_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

Examples found in repository

examples/quantum_crypto.rs (line 147)

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 {} qubits",
        num_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

Examples found in repository

examples/quantum_crypto.rs (line 154)

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 {} qubits",
        num_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(())
}

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.