Enum PublicKeyAlgorithm 

#[non_exhaustive]
pub enum PublicKeyAlgorithm {
    RSAEncryptSign,
    RSAEncrypt,
    RSASign,
    ElGamalEncrypt,
    DSA,
    ECDH,
    ECDSA,
    ElGamalEncryptSign,
    EdDSA,
    X25519,
    X448,
    Ed25519,
    Ed448,
    MLDSA65_Ed25519,
    MLDSA87_Ed448,
    SLHDSA128s,
    SLHDSA128f,
    SLHDSA256s,
    MLKEM768_X25519,
    MLKEM1024_X448,
    Private(u8),
    Unknown(u8),
}

The OpenPGP public key algorithms as defined in Section 9.1 of RFC 9580.

Examples

use sequoia_openpgp as openpgp;
use openpgp::cert::prelude::*;
use openpgp::types::PublicKeyAlgorithm;

let (cert, _) = CertBuilder::new()
    .set_cipher_suite(CipherSuite::Cv25519)
    .generate()?;

assert_eq!(cert.primary_key().key().pk_algo(), PublicKeyAlgorithm::EdDSA);

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.

RSAEncryptSign

RSA (Encrypt or Sign)

RSAEncrypt

👎Deprecated:

Use PublicKeyAlgorithm::RSAEncryptSign.

RSA Encrypt-Only, deprecated in RFC 4880.

RSASign

👎Deprecated:

Use PublicKeyAlgorithm::RSAEncryptSign.

RSA Sign-Only, deprecated in RFC 4880.

ElGamalEncrypt

👎Deprecated:

Use a newer public key algorithm instead.

ElGamal (Encrypt-Only), deprecated in RFC 9580.

DSA

👎Deprecated:

Use a newer public key algorithm instead.

DSA (Digital Signature Algorithm)

ECDH

Elliptic curve DH

ECDSA

Elliptic curve DSA

ElGamalEncryptSign

👎Deprecated:

Use a newer public key algorithm instead.

ElGamal (Encrypt or Sign), deprecated in RFC 4880.

EdDSA

“Twisted” Edwards curve DSA

X25519

X25519 (RFC 7748).

X448

X448 (RFC 7748).

Ed25519

Ed25519 (RFC 8032).

Ed448

Ed448 (RFC 8032).

MLDSA65_Ed25519

Composite signature algorithm using ML-DSA-65 and Ed25519.

MLDSA87_Ed448

Composite signature algorithm using ML-DSA-87 and Ed448.

SLHDSA128s

SLH-DSA-SHAKE signature algorithm 128 bit, small signatures.

Note: RFC 9980 only specifies the SHAKE variant of the SLH-DSA algorithm.

SLHDSA128f

SLH-DSA-SHAKE signature algorithm 128 bit, fast signatures.

Note: RFC 9980 only specifies the SHAKE variant of the SLH-DSA algorithm.

SLHDSA256s

SLH-DSA-SHAKE signature algorithm 256 bit, small signatures.

Note: RFC 9980 only specifies the SHAKE variant of the SLH-DSA algorithm.

MLKEM768_X25519

Composite KEM using ML-KEM-768 and X25519.

MLKEM1024_X448

Composite KEM using ML-KEM-1024 and X448.

Private(u8)

Private algorithm identifier.

Unknown(u8)

Unknown algorithm identifier.

Implementations

impl PublicKeyAlgorithm

pub fn for_signing(&self) -> bool

Returns true if the algorithm can sign data.

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::PublicKeyAlgorithm;

assert!(PublicKeyAlgorithm::EdDSA.for_signing());
assert!(PublicKeyAlgorithm::RSAEncryptSign.for_signing());
assert!(!PublicKeyAlgorithm::ElGamalEncrypt.for_signing());

pub fn for_encryption(&self) -> bool

Returns true if the algorithm can encrypt data.

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::PublicKeyAlgorithm;

assert!(!PublicKeyAlgorithm::EdDSA.for_encryption());
assert!(PublicKeyAlgorithm::RSAEncryptSign.for_encryption());
assert!(PublicKeyAlgorithm::ElGamalEncrypt.for_encryption());

pub fn is_supported(&self) -> bool

Returns whether this algorithm is supported.

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::PublicKeyAlgorithm;

assert!(PublicKeyAlgorithm::EdDSA.is_supported());
assert!(PublicKeyAlgorithm::RSAEncryptSign.is_supported());
assert!(!PublicKeyAlgorithm::Private(101).is_supported());

pub fn variants() -> impl Iterator<Item = PublicKeyAlgorithm>

Returns an iterator over all valid variants.

Returns an iterator over all known variants. This does not include the PublicKeyAlgorithm::Private, or PublicKeyAlgorithm::Unknown variants.

Trait Implementations

impl Clone for PublicKeyAlgorithm

fn clone(&self) -> PublicKeyAlgorithm

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for PublicKeyAlgorithm

impl Debug for PublicKeyAlgorithm

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

Formats the value using the given formatter.

impl Display for PublicKeyAlgorithm

Formats the public key algorithm name.

There are two ways the public key algorithm name can be formatted. By default the short name is used. The alternate format uses the full public key algorithm name.

Examples

use sequoia_openpgp as openpgp;
use openpgp::types::PublicKeyAlgorithm;

// default, short format
assert_eq!("ECDH", format!("{}", PublicKeyAlgorithm::ECDH));

// alternate, long format
assert_eq!("ECDH public key algorithm", format!("{:#}", PublicKeyAlgorithm::ECDH));

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

Formats the value using the given formatter.

impl Eq for PublicKeyAlgorithm

impl From<u8> for PublicKeyAlgorithm

fn from(u: u8) -> PublicKeyAlgorithm

Converts to this type from the input type.

impl Hash for PublicKeyAlgorithm

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for PublicKeyAlgorithm

fn cmp(&self, other: &PublicKeyAlgorithm) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for PublicKeyAlgorithm

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for PublicKeyAlgorithm

fn partial_cmp(&self, other: &PublicKeyAlgorithm) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for PublicKeyAlgorithm