Struct wasi_crypto::CryptoCtx

pub struct CryptoCtx { /* private fields */ }

Implementations

impl CryptoCtx

pub fn array_output_len( &self, array_output_handle: Handle ) -> Result<usize, CryptoError>

pub fn array_output_pull( &self, array_output_handle: Handle, buf: &mut [u8] ) -> Result<usize, CryptoError>

impl CryptoCtx

pub fn keypair_generate( &self, alg_type: AlgorithmType, alg_str: &str, options_handle: Option<Handle> ) -> Result<Handle, CryptoError>

pub fn keypair_import( &self, alg_type: AlgorithmType, alg_str: &str, encoded: &[u8], encoding: KeyPairEncoding ) -> Result<Handle, CryptoError>

pub fn keypair_id( &self, kp_handle: Handle ) -> Result<(Vec<u8>, Version), CryptoError>

pub fn keypair_from_pk_and_sk( &self, pk_handle: Handle, sk_handle: Handle ) -> Result<Handle, CryptoError>

pub fn keypair_export( &self, kp_handle: Handle, encoding: KeyPairEncoding ) -> Result<Handle, CryptoError>

pub fn keypair_publickey( &self, kp_handle: Handle ) -> Result<Handle, CryptoError>

pub fn keypair_secretkey( &self, kp_handle: Handle ) -> Result<Handle, CryptoError>

pub fn keypair_close(&self, kp_handle: Handle) -> Result<(), CryptoError>

impl CryptoCtx

pub fn keypair_generate_managed( &self, _secrets_manager_handle: Handle, _alg_type: AlgorithmType, _alg_str: &str, _options_handle: Option<Handle> ) -> Result<Handle, CryptoError>

pub fn keypair_store_managed( &self, _secrets_manager_handle: Handle, kp_handle: Handle, _key_id_buf: &mut [u8] ) -> Result<(), CryptoError>

pub fn keypair_replace_managed( &self, _secrets_manager_handle: Handle, kp_old_handle: Handle, kp_new_handle: Handle ) -> Result<Version, CryptoError>

pub fn keypair_from_id( &self, _secrets_manager_handle: Handle, _symmetric_key_id: &[u8], _symmetric_key_version: Version ) -> Result<Handle, CryptoError>

impl CryptoCtx

pub fn publickey_import( &self, alg_type: AlgorithmType, alg_str: &str, encoded: &[u8], encoding: PublicKeyEncoding ) -> Result<Handle, CryptoError>

pub fn publickey_export( &self, pk_handle: Handle, encoding: PublicKeyEncoding ) -> Result<Handle, CryptoError>

pub fn publickey_verify(&self, pk: Handle) -> Result<(), CryptoError>

pub fn publickey_close(&self, pk: Handle) -> Result<(), CryptoError>

impl CryptoCtx

pub fn secretkey_import( &self, alg_type: AlgorithmType, alg_str: &str, encoded: &[u8], encoding: SecretKeyEncoding ) -> Result<Handle, CryptoError>

pub fn secretkey_export( &self, sk_handle: Handle, encoding: SecretKeyEncoding ) -> Result<Handle, CryptoError>

pub fn publickey(&self, sk_handle: Handle) -> Result<Handle, CryptoError>

pub fn secretkey_close(&self, sk: Handle) -> Result<(), CryptoError>

impl CryptoCtx

pub fn kx_encapsulate( &self, pk_handle: Handle ) -> Result<(Handle, Handle), CryptoError>

impl CryptoCtx

pub fn kx_dh( &self, pk_handle: Handle, sk_handle: Handle ) -> Result<Handle, CryptoError>

pub fn kx_decapsulate( &self, sk_handle: Handle, encapsulated_secret: &[u8] ) -> Result<Handle, CryptoError>

impl CryptoCtx

pub fn options_open( &self, algorithm_type: AlgorithmType ) -> Result<Handle, CryptoError>

pub fn options_close(&self, options_handle: Handle) -> Result<(), CryptoError>

pub fn options_set( &self, options_handle: Handle, name: &str, value: &[u8] ) -> Result<(), CryptoError>

pub fn options_set_guest_buffer( &self, options_handle: Handle, name: &str, buffer: &'static mut [u8] ) -> Result<(), CryptoError>

pub fn options_set_u64( &self, options_handle: Handle, name: &str, value: u64 ) -> Result<(), CryptoError>

pub fn options_get( &self, options_handle: Handle, name: &str, value: &mut [u8] ) -> Result<usize, CryptoError>

pub fn options_get_u64( &self, options_handle: Handle, name: &str ) -> Result<u64, CryptoError>

impl CryptoCtx

pub fn secrets_manager_open( &self, _options: Option<Handle> ) -> Result<Handle, CryptoError>

pub fn secrets_manager_close( &self, _secrets_manager_handle: Handle ) -> Result<(), CryptoError>

pub fn secrets_manager_invalidate( &self, _secrets_manager_handle: Handle, _key_id: &[u8], _key_version: Version ) -> Result<(), CryptoError>

impl CryptoCtx

pub fn signature_export( &self, signature_handle: Handle, encoding: SignatureEncoding ) -> Result<Handle, CryptoError>

pub fn signature_import( &self, alg_str: &str, encoded: &[u8], encoding: SignatureEncoding ) -> Result<Handle, CryptoError>

pub fn signature_state_open( &self, kp_handle: Handle ) -> Result<Handle, CryptoError>

pub fn signature_state_update( &self, state_handle: Handle, input: &[u8] ) -> Result<(), CryptoError>

pub fn signature_state_sign( &self, state_handle: Handle ) -> Result<Handle, CryptoError>

pub fn signature_state_close(&self, handle: Handle) -> Result<(), CryptoError>

pub fn signature_verification_state_open( &self, pk_handle: Handle ) -> Result<Handle, CryptoError>

pub fn signature_verification_state_update( &self, verification_state_handle: Handle, input: &[u8] ) -> Result<(), CryptoError>

pub fn signature_verification_state_verify( &self, verification_state_handle: Handle, signature_handle: Handle ) -> Result<(), CryptoError>

pub fn signature_verification_state_close( &self, verification_state_handle: Handle ) -> Result<(), CryptoError>

pub fn signature_close( &self, signature_handle: Handle ) -> Result<(), CryptoError>

impl CryptoCtx

pub fn symmetric_key_generate( &self, alg_str: &str, options_handle: Option<Handle> ) -> Result<Handle, CryptoError>

pub fn symmetric_key_import( &self, alg_str: &str, raw: &[u8] ) -> Result<Handle, CryptoError>

pub fn symmetric_key_export( &self, symmetric_key_handle: Handle ) -> Result<Handle, CryptoError>

pub fn symmetric_key_id( &self, symmetric_key_handle: Handle ) -> Result<(Vec<u8>, Version), CryptoError>

pub fn symmetric_key_close( &self, symmetric_key_handle: Handle ) -> Result<(), CryptoError>

impl CryptoCtx

pub fn symmetric_key_generate_managed( &self, _secrets_manager_handle: Handle, _alg_str: &str, _options_handle: Option<Handle> ) -> Result<Handle, CryptoError>

pub fn symmetric_key_store_managed( &self, _secrets_manager_handle: Handle, symmetric_key_handle: Handle, _key_id_buf: &mut [u8] ) -> Result<(), CryptoError>

pub fn symmetric_key_replace_managed( &self, _secrets_manager_handle: Handle, symmetric_key_old_handle: Handle, symmetric_key_new_handle: Handle ) -> Result<Version, CryptoError>

pub fn symmetric_key_from_id( &self, _secrets_manager_handle: Handle, _symmetric_key_id: &[u8], _symmetric_key_version: Version ) -> Result<Handle, CryptoError>

impl CryptoCtx

pub fn symmetric_state_open( &self, alg_str: &str, key_handle: Option<Handle>, options_handle: Option<Handle> ) -> Result<Handle, CryptoError>

pub fn symmetric_state_options_get( &self, symmetric_state_handle: Handle, name: &str, value: &mut [u8] ) -> Result<usize, CryptoError>

pub fn symmetric_state_options_get_u64( &self, symmetric_state_handle: Handle, name: &str ) -> Result<u64, CryptoError>

pub fn symmetric_state_close( &self, symmetric_state_handle: Handle ) -> Result<(), CryptoError>

pub fn symmetric_state_clone( &self, symmetric_state_handle: Handle ) -> Result<Handle, CryptoError>

pub fn symmetric_state_absorb( &self, symmetric_state_handle: Handle, data: &[u8] ) -> Result<(), CryptoError>

pub fn symmetric_state_squeeze( &self, symmetric_state_handle: Handle, out: &mut [u8] ) -> Result<(), CryptoError>

pub fn symmetric_state_squeeze_tag( &self, symmetric_state_handle: Handle ) -> Result<Handle, CryptoError>

pub fn symmetric_state_squeeze_key( &self, symmetric_state_handle: Handle, alg_str: &str ) -> Result<Handle, CryptoError>

pub fn symmetric_state_max_tag_len( &self, symmetric_state_handle: Handle ) -> Result<usize, CryptoError>

pub fn symmetric_state_encrypt( &self, symmetric_state_handle: Handle, out: &mut [u8], data: &[u8] ) -> Result<usize, CryptoError>

pub fn symmetric_state_encrypt_detached( &self, symmetric_state_handle: Handle, out: &mut [u8], data: &[u8] ) -> Result<Handle, CryptoError>

pub fn symmetric_state_decrypt( &self, symmetric_state_handle: Handle, out: &mut [u8], data: &[u8] ) -> Result<usize, CryptoError>

pub fn symmetric_state_decrypt_detached( &self, symmetric_state_handle: Handle, out: &mut [u8], data: &[u8], raw_tag: &[u8] ) -> Result<usize, CryptoError>

pub fn symmetric_state_ratchet( &self, symmetric_state_handle: Handle ) -> Result<(), CryptoError>

impl CryptoCtx

pub fn symmetric_tag_len( &self, symmetric_tag_handle: Handle ) -> Result<usize, CryptoError>

pub fn symmetric_tag_pull( &self, symmetric_tag_handle: Handle, buf: &mut [u8] ) -> Result<usize, CryptoError>

pub fn symmetric_tag_verify( &self, symmetric_tag_handle: Handle, expected_raw: &[u8] ) -> Result<(), CryptoError>

pub fn symmetric_tag_close( &self, symmetric_tag_handle: Handle ) -> Result<(), CryptoError>

impl CryptoCtx

pub fn new() -> Self

pub fn set_limits(&mut self, limits: Limits)

pub fn new_with_limits(limits: Limits) -> Self