Enum parsec_interface::operations::psa_algorithm::AsymmetricSignature

pub enum AsymmetricSignature {
    RsaPkcs1v15Sign {
        hash_alg: SignHash,
    },
    RsaPkcs1v15SignRaw,
    RsaPss {
        hash_alg: SignHash,
    },
    Ecdsa {
        hash_alg: SignHash,
    },
    EcdsaAny,
    DeterministicEcdsa {
        hash_alg: SignHash,
    },
}

Enumeration of asymmetric signing algorithms supported.

Variants

RsaPkcs1v15Sign

Fields

hash_alg: SignHash

A hash algorithm to use.

RSA PKCS#1 v1.5 signature with hashing.

RsaPkcs1v15SignRaw

Raw PKCS#1 v1.5 signature.

RsaPss

Fields

hash_alg: SignHash

A hash algorithm to use.

RSA PSS signature with hashing.

Ecdsa

Fields

hash_alg: SignHash

A hash algorithm to use.

ECDSA signature with hashing.

EcdsaAny

ECDSA signature without hashing.

DeterministicEcdsa

Fields

hash_alg: SignHash

A hash algorithm to use.

Deterministic ECDSA signature with hashing.

Implementations

impl AsymmetricSignature

pub fn is_alg_permitted(self, alg: AsymmetricSignature) -> bool

Check if the alg given for a cryptographic operation is permitted to be used with this algorithm as a policy

Example

use psa_crypto::types::algorithm::{AsymmetricSignature, SignHash, Hash};
assert!(AsymmetricSignature::RsaPkcs1v15Sign { hash_alg: SignHash::Any }
        .is_alg_permitted(AsymmetricSignature::RsaPkcs1v15Sign {
            hash_alg:  SignHash::Specific(Hash::Sha1)
        })
       );
assert!(!AsymmetricSignature::RsaPkcs1v15Sign { hash_alg: SignHash::Specific(Hash::Sha256) }
        .is_alg_permitted(AsymmetricSignature::RsaPkcs1v15Sign {
            hash_alg:  SignHash::Specific(Hash::Sha1)
        })
       );

pub fn is_rsa_alg(self) -> bool

Check if this is a RSA algorithm

pub fn is_ecc_alg(self) -> bool

Check if this is an ECC algorithm

pub fn is_hash_len_permitted(self, hash_len: usize) -> bool

Determines if the given hash length is compatible with the asymmetric signature scheme

pub fn hash(self) -> Option<SignHash>

Retrieves the specific hash that the AsymmetricSignature algorithm is restricted to.

For algorithms that do not specify a hash, None is returned.

Trait Implementations

impl Clone for AsymmetricSignature

fn clone(&self) -> AsymmetricSignature

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AsymmetricSignature

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for AsymmetricSignature

fn deserialize<__D>(
    __deserializer: __D
) -> Result<AsymmetricSignature, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<AsymmetricSignature> for Algorithm

fn from(alg: AsymmetricSignature) -> Algorithm

Converts to this type from the input type.

impl PartialEq<AsymmetricSignature> for AsymmetricSignature

fn eq(&self, other: &AsymmetricSignature) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for AsymmetricSignature

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl Zeroize for AsymmetricSignature

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

impl Copy for AsymmetricSignature

impl Eq for AsymmetricSignature

impl StructuralEq for AsymmetricSignature

impl StructuralPartialEq for AsymmetricSignature