[−][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]

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

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

`impl Copy for Algorithm`[src]

`impl Debug for Algorithm`[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl Serialize for Algorithm`[src]

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

`impl StructuralPartialEq for Algorithm`[src]

Auto Trait Implementations

`impl RefUnwindSafe for Algorithm`

`impl Send for Algorithm`

`impl Sync for Algorithm`

`impl Unpin for Algorithm`

`impl UnwindSafe for Algorithm`

Blanket Implementations

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

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

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

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

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

`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]

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

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

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

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

`type Owned = T`

The resulting type after obtaining ownership.

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

`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.

`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.

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