Enum SignAlgorithm 

#[non_exhaustive]
pub enum SignAlgorithm {
    RsaPkcs1Sha256,
    RsaPssSha256,
    EcdsaSha256,
    EcdsaSha384,
    Ed25519,
    MlDsa44,
    MlDsa65,
    MlDsa87,
}

Signature algorithm.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

RsaPkcs1Sha256

RSASSA-PKCS1-v1_5 with SHA-256.

RsaPssSha256

RSASSA-PSS with SHA-256.

EcdsaSha256

ECDSA with SHA-256.

EcdsaSha384

ECDSA with SHA-384.

Ed25519

Ed25519 (pure EdDSA, no hash function).

MlDsa44

ML-DSA-44 (pure, no pre-hash). FIPS 204.

MlDsa65

ML-DSA-65 (pure, no pre-hash). FIPS 204.

MlDsa87

ML-DSA-87 (pure, no pre-hash). FIPS 204.

Implementations

impl SignAlgorithm

pub fn key_algorithm(self) -> KeyAlgorithm

A representative key algorithm for this signature algorithm.

Used where a signature request must be turned into a concrete key algorithm: selecting a card algorithm, or minting a stand-in key for a rehearsal. Keeping that mapping here means those callers cannot drift apart from each other.

The mapping is deliberately lossy for RSA: both RSA schemes answer Rsa2048, because a signature algorithm does not name a modulus size. Use accepts_key to test whether a key may be used with this algorithm; the equality alg.key_algorithm() == key is not that test and rejects RSA-4096 keys.

pub fn accepts_key(self, key_algorithm: KeyAlgorithm) -> bool

Whether a key of key_algorithm may be used with this signature algorithm.

The compatibility check every signing backend needs, kept in one place. Curve and parameter set are pinned: ECDSA-SHA256 will not take a P-384 key. Only the RSA schemes span more than one key algorithm, since they are defined for any modulus size.

Trait Implementations

impl Clone for SignAlgorithm

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for SignAlgorithm

impl Debug for SignAlgorithm

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SignAlgorithm

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for SignAlgorithm

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

Formats the value using the given formatter.

impl Eq for SignAlgorithm

impl From<SignAlgorithm> for String

fn from(a: SignAlgorithm) -> String

Converts to this type from the input type.

impl FromStr for SignAlgorithm

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl PartialEq for SignAlgorithm

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for SignAlgorithm

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SignAlgorithm

impl TryFrom<String> for SignAlgorithm

type Error = ParseError

The type returned in the event of a conversion error.

fn try_from(s: String) -> Result<Self, Self::Error>

Performs the conversion.