Struct lib3h_sodium::SodiumCryptoSystem

pub struct SodiumCryptoSystem { /* fields omitted */ }

the libsodium (NaCl) implementation of lib3h_crypto_api::CryptoSystem

Examples

extern crate lib3h_crypto_api;
use lib3h_crypto_api::{Buffer, CryptoSystem};

extern crate lib3h_sodium;
use lib3h_sodium::{
    SecureBuffer,
    SodiumCryptoSystem,
};

// CryptoSystem is designed to be used through trait-objects like this:
fn test(crypto: Box<dyn CryptoSystem>) {
    let mut seed = crypto.buf_new_secure(crypto.sign_seed_bytes());
    crypto.randombytes_buf(&mut seed).unwrap();

    let mut pubkey: Box<dyn Buffer> =
        Box::new(vec![0; crypto.sign_public_key_bytes()]);
    let mut seckey = crypto.buf_new_secure(crypto.sign_secret_key_bytes());

    crypto.sign_seed_keypair(&seed, &mut pubkey, &mut seckey).unwrap();

    let mut signature: Box<dyn Buffer> =
        Box::new(vec![0; crypto.sign_bytes()]);

    let message: Box<dyn Buffer> = Box::new(vec![1, 2, 3, 4]);
    let bad_message: Box<dyn Buffer> = Box::new(vec![4, 3, 2, 1]);

    crypto.sign(
        &mut signature, &message, &seckey).unwrap();

    assert!(crypto.sign_verify(
        &signature, &message, &pubkey).unwrap());
    assert!(!crypto.sign_verify(
        &signature, &bad_message, &pubkey).unwrap());
}

fn main() {
    let crypto: Box<dyn CryptoSystem> =
        Box::new(SodiumCryptoSystem::new());
    test(crypto);
}

Methods

impl SodiumCryptoSystem

pub fn new() -> Self

Trait Implementations

impl Clone for SodiumCryptoSystem

fn clone(&self) -> SodiumCryptoSystem

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CryptoSystem for SodiumCryptoSystem

fn box_clone(&self) -> Box<dyn CryptoSystem>

Crypto System is designed to be used as a trait-object Since we can't get a sized clone, provide clone in a Box.

fn as_crypto_system(&self) -> &dyn CryptoSystem

helps work around some sizing issues with rust trait-objects

fn buf_new_secure(&self, size: usize) -> Box<dyn Buffer>

create a new memory secured buffer that is compatible with this crypto system

fn randombytes_buf(&self, buffer: &mut Box<dyn Buffer>) -> CryptoResult<()>

fill all the bytes in the buffer with secure random data

fn sign_seed_bytes(&self) -> usize

bytelength of signature seed

fn sign_public_key_bytes(&self) -> usize

bytelength of signature public key

fn sign_secret_key_bytes(&self) -> usize

bytelength of signature secret key

fn sign_bytes(&self) -> usize

bytelength of a digital signature

fn sign_seed_keypair(
    &self,
    seed: &Box<dyn Buffer>,
    public_key: &mut Box<dyn Buffer>,
    secret_key: &mut Box<dyn Buffer>
) -> CryptoResult<()>

generate a deterministic signature public / secret keypair based off the given seed entropy

fn sign_keypair(
    &self,
    public_key: &mut Box<dyn Buffer>,
    secret_key: &mut Box<dyn Buffer>
) -> CryptoResult<()>

generate a pure entropy based signature public / secret keypair

fn sign(
    &self,
    signature: &mut Box<dyn Buffer>,
    message: &Box<dyn Buffer>,
    secret_key: &Box<dyn Buffer>
) -> CryptoResult<()>

generate a digital signature for message with the given secret key

fn sign_verify(
    &self,
    signature: &Box<dyn Buffer>,
    message: &Box<dyn Buffer>,
    public_key: &Box<dyn Buffer>
) -> CryptoResult<bool>

verify that the digital signature is valid for given message and public_key

fn buf_new_insecure(
    &self,
    size: usize
) -> Box<dyn Buffer<Target = [u8]> + 'static>

this is just a helper to create a sized boxed Vec as a Box