Struct EmptyCal 

pub struct EmptyCal;

An implementation of Cal that provides no single algorithm.

It implements all the individual traits, as well as the full Cal trait. The former is useful for hardware implementations that don’t touch an area at all; the latter is useful in testing or when an extender is used standalone.

Trait Implementations

impl AeadProvider for EmptyCal

type Algorithm = NoAlgorithms

type Key = NoAlgorithms

type Tag = NoAlgorithms

fn load_from_keydata(&mut self, alg: Self::Algorithm, _key: &[u8]) -> Self::Key

Loads a key from the key’s bytes.

fn encrypt_in_place( &mut self, key: &Self::Key, _nonce: &[u8], _message: &mut [u8], _aad: impl AadGenerator, ) -> Self::Tag

Encrypts data in place.

fn decrypt_in_place( &mut self, key: &Self::Key, _nonce: &[u8], _message: &mut [u8], _tag: &[u8], _aad: impl AadGenerator, ) -> Result<(), DecryptionFailed>

Decrypts data in place.

impl Cal for EmptyCal

type DhProvider = EmptyCal

The non-supertrait responsible for key establishment.

type AeadProvider = EmptyCal

type HashProvider = EmptyCal

type HmacProvider = EmptyCal

fn dh(&mut self) -> &mut Self::DhProvider

fn aead(&mut self) -> &mut Self::AeadProvider

fn hash(&mut self) -> &mut Self::HashProvider

fn hmac(&mut self) -> &mut Self::HmacProvider

impl DhProvider for EmptyCal

type Algorithm = NoAlgorithms

type VisibleSecretKey = NoAlgorithms

A secret key that is intended to be exported.

type SecretKey = NoAlgorithms

type PublicKey = NoAlgorithms

type SharedSecret = NoAlgorithms

fn generate_visible(&mut self, alg: Self::Algorithm) -> Self::VisibleSecretKey

Generates a secret key that is intended to be exported / shared (e.g. to be persisted across program executions).

fn shared_secret( &mut self, private: &Self::SecretKey, _public: &Self::PublicKey, ) -> Result<Self::SharedSecret, IncompatibleKeys>

Derives a shared secret from a public and a private key.

fn public_key(&mut self, private: &Self::SecretKey) -> Self::PublicKey

Produces the public key corresponding to a private key.

fn raw_secret_bytes<'s>( &mut self, secret: &'s Self::SharedSecret, ) -> impl AsRef<[u8]> + use<'s>

Produces the bytes of the shared secret, in the algorithm’s .output_length().

fn export_secretkey_bytes<'s>( &mut self, secretkey: &'s Self::VisibleSecretKey, ) -> impl AsRef<[u8]> + use<'s>

Exposes a visible secret key’s secret.

fn import_secretkey_bytes( &mut self, alg: Self::Algorithm, _secret: &[u8], ) -> Result<Self::VisibleSecretKey, ImportError>

Inverse operation of .export_secretkey_bytes().

fn export_publickey_bytes<'p>( &mut self, public: &'p Self::PublicKey, ) -> impl AsRef<[u8]> + use<'p>

Exposes a public key’s key data bytes.

fn import_publickey_bytes( &mut self, alg: Self::Algorithm, _data: &[u8], ) -> Result<Self::PublicKey, ImportError>

Imports a public key in the inverse operation of .export_publickey_bytes().

fn generate(&mut self, alg: Self::Algorithm) -> Self::SecretKey

Generates a secret key.

impl Ec for EmptyCal

const MAX_SCALAR_LENGTH: usize = 0

The longest slice length ever usable with scalar import / export from any of the primitives.

type PrimitivesP256 = EmptyCal

type PrimitivesX25519 = EmptyCal

type PrimitivesX448 = EmptyCal

fn p256(&mut self) -> &mut Self::PrimitivesP256

fn x25519(&mut self) -> &mut Self::PrimitivesX25519

fn x448(&mut self) -> &mut Self::PrimitivesX448

impl<C: Curve> EcPrimitives<C> for EmptyCal

const HAS_MULTIPLY_SCALAR_POINT: bool = false

Indicates whether Self::multiply_scalar_point() is available (otherwise it will likely panic).

type Scalar = NoAlgorithms

type Point = NoAlgorithms

fn multiply_scalar_point( &mut self, a: &Self::Scalar, _b: &Self::Point, ) -> Self::Point

Performs a scalar × point multiplication on the curve.

fn point(&mut self, x: Self::Scalar, _y: Self::Scalar) -> Self::Point

Constructs a point from two scalars.

fn import_scalar_bytes( &mut self, _scalar: &[u8], ) -> Result<Self::Scalar, ImportError>

Loads byte data into a scalar from the curve’s native format.

fn export_scalar_bytes<'s>( &mut self, _scalar: &'s Self::Scalar, ) -> impl AsRef<[u8]> + use<'s, C>

Inverse function of Self::import_scalar_bytes().

fn x_coord(&mut self, point: &Self::Point) -> Self::Scalar

Accesses the first coordinate of a point.

fn y_coord(&mut self, point: &Self::Point) -> Self::Scalar

Accesses the second coordinate of a point.

impl Hash for EmptyCal

impl HashProvider for EmptyCal

type Algorithm = NoAlgorithms

type State = NoAlgorithms

State in which is carried between rounds of feeding data.

type Output = NoAlgorithms

Output of a hashing operation.

fn init(&mut self, algorithm: Self::Algorithm) -> Self::State

fn update(&mut self, instance: &mut Self::State, _data: &[u8])

fn finalize(&mut self, instance: Self::State) -> Self::Output

fn hash(&mut self, algorithm: Self::Algorithm, data: &[u8]) -> Self::Output

Hash contiguous in-memory data in a single pass.

impl HmacProvider for EmptyCal

type Algorithm = NoAlgorithms

type Key = NoAlgorithms

A nascent state that has only received a key as input.

type State = NoAlgorithms

State carried between rounds of feeding data into the HMAC.

type Output = NoAlgorithms

Output of an HMAC operation.

fn load_from_keydata( &mut self, algorithm: Self::Algorithm, _key: &[u8], ) -> Self::Key

Initializes a key from raw bytes.

fn init(&mut self, key: Self::Key) -> Self::State

Starts an HMAC operation.

fn update(&mut self, state: &mut Self::State, _data: &[u8])

fn finalize(&mut self, state: Self::State) -> Self::Output

fn init_with_keydata( &mut self, algorithm: Self::Algorithm, key: &[u8], ) -> Self::State

Starts an HMAC operation based on a key that is entered as raw bytes.

fn hmac_with_keydata( &mut self, algorithm: Self::Algorithm, key: &[u8], data: &[u8], ) -> Self::Output

Compute HMAC over contiguous in-memory data in a single pass, based on a key directly entered as bytes.

impl Plumbing for EmptyCal

impl Sha2Short for EmptyCal

const SUPPORTED: bool = false

Whether this trait is actually supported. See Plumbing docs for rationale..

const SEND_PADDING: bool = false

If true, the user needs to send all the padding data into the implementation through the Self::update() function.

const FIRST_CHUNK_SIZE: usize = 0

Size of the first chunk to be sent to Self::update(), if it differs from the block size.

const UPDATE_MULTICHUNK: bool = false

If true, the Self::update() function can be passed data from consecutive blocks.

type State = NoAlgorithms

State containing an ongoing operation.

fn init(&mut self, _variant: Sha2ShortVariant) -> Self::State

Initiates a Self::State according to the selected algorithm.

fn update(&mut self, instance: &mut Self::State, _data: &[u8])

Iteratively sends data to be hashed into the instance.

fn finalize( &mut self, instance: Self::State, _last_chunk: &[u8], _target: &mut [u8], )

Extracts the hash into a target slice.