Trait lib3h_crypto_api::CryptoSystem

pub trait CryptoSystem: Sync + Send {
    fn box_clone(&self) -> Box<dyn CryptoSystem>;
    fn as_crypto_system(&self) -> &dyn CryptoSystem;
    fn buf_new_secure(&self, size: usize) -> Box<dyn Buffer>;
    fn randombytes_buf(&self, buffer: &mut Box<dyn Buffer>) -> CryptoResult<()>;
    fn hash_sha256_bytes(&self) -> usize;
    fn hash_sha512_bytes(&self) -> usize;
    fn hash_sha256(
        &self, 
        hash: &mut Box<dyn Buffer>, 
        data: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn hash_sha512(
        &self, 
        hash: &mut Box<dyn Buffer>, 
        data: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn generic_hash_min_bytes(&self) -> usize;
    fn generic_hash_max_bytes(&self) -> usize;
    fn generic_hash_key_min_bytes(&self) -> usize;
    fn generic_hash_key_max_bytes(&self) -> usize;
    fn generic_hash(
        &self, 
        hash: &mut Box<dyn Buffer>, 
        data: &Box<dyn Buffer>, 
        key: Option<&Box<dyn Buffer>>
    ) -> CryptoResult<()>;
    fn pwhash_salt_bytes(&self) -> usize;
    fn pwhash_bytes(&self) -> usize;
    fn pwhash(
        &self, 
        hash: &mut Box<dyn Buffer>, 
        password: &Box<dyn Buffer>, 
        salt: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn kdf_key_bytes(&self) -> usize;
    fn kdf_context_bytes(&self) -> usize;
    fn kdf_min_bytes(&self) -> usize;
    fn kdf_max_bytes(&self) -> usize;
    fn kdf(
        &self, 
        out_buffer: &mut Box<dyn Buffer>, 
        index: u64, 
        context: &Box<dyn Buffer>, 
        parent: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn sign_seed_bytes(&self) -> usize;
    fn sign_public_key_bytes(&self) -> usize;
    fn sign_secret_key_bytes(&self) -> usize;
    fn sign_bytes(&self) -> usize;
    fn sign_seed_keypair(
        &self, 
        seed: &Box<dyn Buffer>, 
        public_key: &mut Box<dyn Buffer>, 
        secret_key: &mut Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn sign_keypair(
        &self, 
        public_key: &mut Box<dyn Buffer>, 
        secret_key: &mut Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn sign(
        &self, 
        signature: &mut Box<dyn Buffer>, 
        message: &Box<dyn Buffer>, 
        secret_key: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn sign_verify(
        &self, 
        signature: &Box<dyn Buffer>, 
        message: &Box<dyn Buffer>, 
        public_key: &Box<dyn Buffer>
    ) -> CryptoResult<bool>;
    fn kx_seed_bytes(&self) -> usize;
    fn kx_public_key_bytes(&self) -> usize;
    fn kx_secret_key_bytes(&self) -> usize;
    fn kx_session_key_bytes(&self) -> usize;
    fn kx_seed_keypair(
        &self, 
        seed: &Box<dyn Buffer>, 
        public_key: &mut Box<dyn Buffer>, 
        secret_key: &mut Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn kx_keypair(
        &self, 
        public_key: &mut Box<dyn Buffer>, 
        secret_key: &mut Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn kx_client_session_keys(
        &self, 
        client_rx: &mut Box<dyn Buffer>, 
        client_tx: &mut Box<dyn Buffer>, 
        client_pk: &Box<dyn Buffer>, 
        client_sk: &Box<dyn Buffer>, 
        server_pk: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn kx_server_session_keys(
        &self, 
        server_rx: &mut Box<dyn Buffer>, 
        server_tx: &mut Box<dyn Buffer>, 
        server_pk: &Box<dyn Buffer>, 
        server_sk: &Box<dyn Buffer>, 
        client_pk: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn aead_nonce_bytes(&self) -> usize;
    fn aead_auth_bytes(&self) -> usize;
    fn aead_secret_bytes(&self) -> usize;
    fn aead_encrypt(
        &self, 
        cipher: &mut Box<dyn Buffer>, 
        message: &Box<dyn Buffer>, 
        adata: Option<&Box<dyn Buffer>>, 
        nonce: &Box<dyn Buffer>, 
        secret: &Box<dyn Buffer>
    ) -> CryptoResult<()>;
    fn aead_decrypt(
        &self, 
        message: &mut Box<dyn Buffer>, 
        cipher: &Box<dyn Buffer>, 
        adata: Option<&Box<dyn Buffer>>, 
        nonce: &Box<dyn Buffer>, 
        secret: &Box<dyn Buffer>
    ) -> CryptoResult<()>;

    fn buf_new_insecure(&self, size: usize) -> Box<dyn Buffer> { ... }
}

A trait describing a cryptographic system implementation compatible with Lib3h and Holochain.

Required methods

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 hash_sha256_bytes(&self) -> usize

bytelength of sha256 hash

fn hash_sha512_bytes(&self) -> usize

bytelength of sha512 hash

fn hash_sha256(
    &self,
    hash: &mut Box<dyn Buffer>,
    data: &Box<dyn Buffer>
) -> CryptoResult<()>

compute a sha256 hash for data, storing it in hash

fn hash_sha512(
    &self,
    hash: &mut Box<dyn Buffer>,
    data: &Box<dyn Buffer>
) -> CryptoResult<()>

compute a sha512 hash for data, storing it in hash

fn generic_hash_min_bytes(&self) -> usize

min bytelength of generic hash output

fn generic_hash_max_bytes(&self) -> usize

max bytelength of generic hash output

fn generic_hash_key_min_bytes(&self) -> usize

min bytelength of generic hash key

fn generic_hash_key_max_bytes(&self) -> usize

max bytelength of generic hash key

fn generic_hash(
    &self,
    hash: &mut Box<dyn Buffer>,
    data: &Box<dyn Buffer>,
    key: Option<&Box<dyn Buffer>>
) -> CryptoResult<()>

compute a deterministic (BLAKE2b) generic hash for given data key can be None

fn pwhash_salt_bytes(&self) -> usize

bytelength of pwhash salt

fn pwhash_bytes(&self) -> usize

bytelength of pwhash

fn pwhash(
    &self,
    hash: &mut Box<dyn Buffer>,
    password: &Box<dyn Buffer>,
    salt: &Box<dyn Buffer>
) -> CryptoResult<()>

run a cpu/memory intensive password hash against password / salt

fn kdf_key_bytes(&self) -> usize

bytelength of parent key from which to derive

fn kdf_context_bytes(&self) -> usize

bytelength of key derivation context

fn kdf_min_bytes(&self) -> usize

minimum bytelength of key derivation buffers

fn kdf_max_bytes(&self) -> usize

maximum bytelength of key derivation buffers

fn kdf(
    &self,
    out_buffer: &mut Box<dyn Buffer>,
    index: u64,
    context: &Box<dyn Buffer>,
    parent: &Box<dyn Buffer>
) -> CryptoResult<()>

derive a new deterministic key based of index, context, and parent

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 kx_seed_bytes(&self) -> usize

bytelength of key exchange seed

fn kx_public_key_bytes(&self) -> usize

bytelength of key exchange public key

fn kx_secret_key_bytes(&self) -> usize

bytelength of key exchange secret key

fn kx_session_key_bytes(&self) -> usize

bytelength of session keys derived from key exchange

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

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

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

generate a pure entropy based key exchange public / secret keypair

fn kx_client_session_keys(
    &self,
    client_rx: &mut Box<dyn Buffer>,
    client_tx: &mut Box<dyn Buffer>,
    client_pk: &Box<dyn Buffer>,
    client_sk: &Box<dyn Buffer>,
    server_pk: &Box<dyn Buffer>
) -> CryptoResult<()>

generate key exchange session keys from "client" perspective for named arguments for code clarity, consider using the macro: kx_client_session_keys!

fn kx_server_session_keys(
    &self,
    server_rx: &mut Box<dyn Buffer>,
    server_tx: &mut Box<dyn Buffer>,
    server_pk: &Box<dyn Buffer>,
    server_sk: &Box<dyn Buffer>,
    client_pk: &Box<dyn Buffer>
) -> CryptoResult<()>

generate key exchange session keys from "server" perspective for named arguments for code clarity, consider using the macro: kx_server_session_keys!

fn aead_nonce_bytes(&self) -> usize

bytelength of key exchange seed

fn aead_auth_bytes(&self) -> usize

bytelength of aead authentication tag

fn aead_secret_bytes(&self) -> usize

bytelength of aead symmetric key

fn aead_encrypt(
    &self,
    cipher: &mut Box<dyn Buffer>,
    message: &Box<dyn Buffer>,
    adata: Option<&Box<dyn Buffer>>,
    nonce: &Box<dyn Buffer>,
    secret: &Box<dyn Buffer>
) -> CryptoResult<()>

encrypt message into buffer cipher for named arguments for code clarity, consider using the macro: aead_encrypt!

fn aead_decrypt(
    &self,
    message: &mut Box<dyn Buffer>,
    cipher: &Box<dyn Buffer>,
    adata: Option<&Box<dyn Buffer>>,
    nonce: &Box<dyn Buffer>,
    secret: &Box<dyn Buffer>
) -> CryptoResult<()>

decrypt cipher into buffer message for named arguments for code clarity, consider using the macro: aead_encrypt!

Loading content...

Provided methods

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

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

Loading content...

Implementors

Loading content...