[−][src]Enum parsec_interface::operations::psa_algorithm::Algorithm

pub enum Algorithm {
    None,
    Hash(Hash),
    Mac(Mac),
    Cipher(Cipher),
    Aead(Aead),
    AsymmetricSignature(AsymmetricSignature),
    AsymmetricEncryption(AsymmetricEncryption),
    KeyAgreement(KeyAgreement),
    KeyDerivation(KeyDerivation),
}

Enumeration of possible algorithm definitions. Each variant of the enum contains a main algorithm type (which is required for that variant).

Variants

None

An invalid algorithm identifier value. None does not allow any cryptographic operation with the key. The key can still be used for non-cryptographic actions such as exporting, if permitted by the usage flags.

Hash(Hash)

Hash algorithm.

Mac(Mac)

MAC algorithm.

Cipher(Cipher)

Symmetric Cipher algorithm.

Aead(Aead)

Authenticated Encryption with Associated Data (AEAD) algorithm.

AsymmetricSignature(AsymmetricSignature)

Public-key signature algorithm.

AsymmetricEncryption(AsymmetricEncryption)

Public-key encryption algorithm.

KeyAgreement(KeyAgreement)

Key agreement algorithm.

KeyDerivation(KeyDerivation)

Key derivation algorithm.

Implementations

`impl Algorithm`[src]

`pub fn is_hmac(self) -> bool`[src]

Check if the algorithm is a HMAC algorithm, truncated or not

Example

use psa_crypto::types::algorithm::{Algorithm, Mac, FullLengthMac, Hash};
let hmac = Algorithm::Mac(Mac::Truncated {
    mac_alg: FullLengthMac::Hmac { hash_alg: Hash::Sha256 },
    mac_length: 30,
});
assert!(hmac.is_hmac());

Trait Implementations

`impl Clone for Algorithm`[src]

`pub fn clone(&self) -> Algorithm`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl Copy for Algorithm`[src]

`impl Debug for Algorithm`[src]

`pub fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`[src]

`impl<'de> Deserialize<'de> for Algorithm`[src]

`pub fn deserialize<D>( deserializer: D ) -> Result<Algorithm, <D as Deserializer<'de>>::Error> where __D: Deserializer<'de>,` [src]

`impl From<Aead> for Algorithm`[src]

`pub fn from(alg: Aead) -> Algorithm`[src]

`impl From<AsymmetricEncryption> for Algorithm`[src]

`pub fn from(alg: AsymmetricEncryption) -> Algorithm`[src]

`impl From<AsymmetricSignature> for Algorithm`[src]

`pub fn from(alg: AsymmetricSignature) -> Algorithm`[src]

`impl From<Cipher> for Algorithm`[src]

`pub fn from(alg: Cipher) -> Algorithm`[src]

`impl From<Hash> for Algorithm`[src]

`pub fn from(alg: Hash) -> Algorithm`[src]

`impl From<KeyAgreement> for Algorithm`[src]

`pub fn from(alg: KeyAgreement) -> Algorithm`[src]

`impl From<KeyDerivation> for Algorithm`[src]

`pub fn from(alg: KeyDerivation) -> Algorithm`[src]

`impl From<Mac> for Algorithm`[src]

`pub fn from(alg: Mac) -> Algorithm`[src]

`impl PartialEq<Algorithm> for Algorithm`[src]

`pub fn eq(&self, other: &Algorithm) -> bool`[src]

`pub fn ne(&self, other: &Algorithm) -> bool`[src]

`impl Serialize for Algorithm`[src]

`pub fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where S: Serializer,` [src]

`impl StructuralPartialEq for Algorithm`[src]

`impl Zeroize for Algorithm`[src]

`pub fn zeroize(&mut self)`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Algorithm`[src]

`impl Send for Algorithm`[src]

`impl Sync for Algorithm`[src]

`impl Unpin for Algorithm`[src]

`impl UnwindSafe for Algorithm`[src]

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de>,` [src]

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]