Enum PublicKeyAlgorithm

#[non_exhaustive]
pub enum PublicKeyAlgorithm {
    RSAEncryptSign,
    RSAEncrypt,
    RSASign,
    ElGamalEncrypt,
    DSA,
    ECDH,
    ECDSA,
    ElGamalEncryptSign,
    EdDSA,
    X25519,
    X448,
    Ed25519,
    Ed448,
    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).

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 = Self>

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 copy of the value.

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

Performs copy-assignment from source.

impl Debug for PublicKeyAlgorithm

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

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

Formats the value using the given formatter.

impl From<PublicKeyAlgorithm> for u8

fn from(p: PublicKeyAlgorithm) -> u8

Converts to this type from the input type.

impl From<u8> for PublicKeyAlgorithm

fn from(u: u8) -> Self

Converts to this type from the input type.

impl Hash for PublicKeyAlgorithm

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

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.

impl PartialEq for PublicKeyAlgorithm

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

Tests for self and other values to be equal, and is used by ==.

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

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

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 Copy for PublicKeyAlgorithm

impl Eq for PublicKeyAlgorithm

impl StructuralPartialEq for PublicKeyAlgorithm