Enum PrivateKeyDer

#[non_exhaustive]
pub enum PrivateKeyDer<'a> {
    Pkcs1(PrivatePkcs1KeyDer<'a>),
    Sec1(PrivateSec1KeyDer<'a>),
    Pkcs8(PrivatePkcs8KeyDer<'a>),
}

A DER-encoded X.509 private key, in one of several formats

See variant inner types for more detailed information.

This can load several types of PEM-encoded private key, and then reveal which types were found:

use rustls_pki_types::{PrivateKeyDer, pem::PemObject};

// load from a PEM file
let pkcs8 = PrivateKeyDer::from_pem_file("tests/data/nistp256key.pkcs8.pem").unwrap();
let pkcs1 = PrivateKeyDer::from_pem_file("tests/data/rsa1024.pkcs1.pem").unwrap();
let sec1 = PrivateKeyDer::from_pem_file("tests/data/nistp256key.pem").unwrap();
assert!(matches!(pkcs8, PrivateKeyDer::Pkcs8(_)));
assert!(matches!(pkcs1, PrivateKeyDer::Pkcs1(_)));
assert!(matches!(sec1, PrivateKeyDer::Sec1(_)));

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.

Pkcs1(PrivatePkcs1KeyDer<'a>)

An RSA private key

Sec1(PrivateSec1KeyDer<'a>)

A Sec1 private key

Pkcs8(PrivatePkcs8KeyDer<'a>)

A PKCS#8 private key

Implementations

impl<'a> PrivateKeyDer<'a>

pub fn clone_key(&self) -> PrivateKeyDer<'static>

Available on crate feature alloc only.

Clone the private key to a 'static value

pub fn secret_der(&self) -> &[u8]

Yield the DER-encoded bytes of the private key

Trait Implementations

impl<'a> Debug for PrivateKeyDer<'a>

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

Formats the value using the given formatter.

impl<'a> From<PrivatePkcs1KeyDer<'a>> for PrivateKeyDer<'a>

fn from(key: PrivatePkcs1KeyDer<'a>) -> PrivateKeyDer<'a>

Converts to this type from the input type.

impl<'a> From<PrivatePkcs8KeyDer<'a>> for PrivateKeyDer<'a>

fn from(key: PrivatePkcs8KeyDer<'a>) -> PrivateKeyDer<'a>

Converts to this type from the input type.

impl<'a> From<PrivateSec1KeyDer<'a>> for PrivateKeyDer<'a>

fn from(key: PrivateSec1KeyDer<'a>) -> PrivateKeyDer<'a>

Converts to this type from the input type.

impl<'a> PartialEq for PrivateKeyDer<'a>

fn eq(&self, other: &PrivateKeyDer<'a>) -> 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 PemObject for PrivateKeyDer<'static>

Available on crate feature alloc only.

fn from_pem(kind: SectionKind, value: Vec<u8>) -> Option<PrivateKeyDer<'static>>

Conversion from a PEM SectionKind and body data.

fn from_pem_slice(pem: &[u8]) -> Result<Self, Error>

Decode the first section of this type from PEM contained in a byte slice.

fn pem_slice_iter(pem: &[u8]) -> SliceIter<'_, Self>

Iterate over all sections of this type from PEM contained in a byte slice.

fn from_pem_file(file_name: impl AsRef<Path>) -> Result<Self, Error>

Available on crate feature std only.

Decode the first section of this type from the PEM contents of the named file.

fn pem_file_iter( file_name: impl AsRef<Path>, ) -> Result<ReadIter<BufReader<File>, Self>, Error>

Available on crate feature std only.

Iterate over all sections of this type from the PEM contents of the named file.

fn from_pem_reader(rd: impl Read) -> Result<Self, Error>

Available on crate feature std only.

Decode the first section of this type from PEM read from an io::Read.

fn pem_reader_iter<R>(rd: R) -> ReadIter<BufReader<R>, Self>

where R: Read,

Available on crate feature std only.

Iterate over all sections of this type from PEM present in an io::Read.

impl<'a> TryFrom<&'a [u8]> for PrivateKeyDer<'a>

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( key: &'a [u8], ) -> Result<PrivateKeyDer<'a>, <PrivateKeyDer<'a> as TryFrom<&'a [u8]>>::Error>

Performs the conversion.

impl<'a> TryFrom<Vec<u8>> for PrivateKeyDer<'a>

Available on crate feature alloc only.

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from( key: Vec<u8>, ) -> Result<PrivateKeyDer<'a>, <PrivateKeyDer<'a> as TryFrom<Vec<u8>>>::Error>

Performs the conversion.

impl<'a> Eq for PrivateKeyDer<'a>

impl<'a> StructuralPartialEq for PrivateKeyDer<'a>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes

Size for each variant:

• Pkcs1: 24 bytes
• Sec1: 24 bytes
• Pkcs8: 24 bytes