Struct PrivateKeyInfo 

pub struct PrivateKeyInfo<'a> {
    pub algorithm: AlgorithmIdentifierRef<'a>,
    pub private_key: &'a [u8],
    pub public_key: Option<&'a [u8]>,
}

PKCS#8 PrivateKeyInfo.

ASN.1 structure containing an AlgorithmIdentifier, private key data in an algorithm specific format, and optional attributes (ignored by this implementation).

Supports PKCS#8 v1 as described in RFC 5208 and PKCS#8 v2 as described in RFC 5958. PKCS#8 v2 keys include an additional public key field.

PKCS#8 v1 PrivateKeyInfo

Described in RFC 5208 Section 5:

PrivateKeyInfo ::= SEQUENCE {
        version                   Version,
        privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
        privateKey                PrivateKey,
        attributes           [0]  IMPLICIT Attributes OPTIONAL }

Version ::= INTEGER

PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier

PrivateKey ::= OCTET STRING

Attributes ::= SET OF Attribute

PKCS#8 v2 OneAsymmetricKey

PKCS#8 OneAsymmetricKey as described in RFC 5958 Section 2:

PrivateKeyInfo ::= OneAsymmetricKey

OneAsymmetricKey ::= SEQUENCE {
    version                   Version,
    privateKeyAlgorithm       PrivateKeyAlgorithmIdentifier,
    privateKey                PrivateKey,
    attributes            [0] Attributes OPTIONAL,
    ...,
    [[2: publicKey        [1] PublicKey OPTIONAL ]],
    ...
  }

Version ::= INTEGER { v1(0), v2(1) } (v1, ..., v2)

PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier

PrivateKey ::= OCTET STRING

Attributes ::= SET OF Attribute

PublicKey ::= BIT STRING

Fields

algorithm: AlgorithmIdentifierRef<'a>

X.509 AlgorithmIdentifier for the private key type.

private_key: &'a [u8]

Private key data.

public_key: Option<&'a [u8]>

Public key data, optionally available if version is V2.

Implementations

impl<'a> PrivateKeyInfo<'a>

pub fn new(algorithm: AlgorithmIdentifierRef<'a>, private_key: &'a [u8]) -> Self

Create a new PKCS#8 PrivateKeyInfo message.

This is a helper method which initializes attributes and public_key to None, helpful if you aren’t using those.

pub fn version(&self) -> Version

Get the PKCS#8 Version for this structure.

Version::V1 if public_key is None, Version::V2 if Some.

Trait Implementations

impl<'a> Clone for PrivateKeyInfo<'a>

fn clone(&self) -> PrivateKeyInfo<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for PrivateKeyInfo<'a>

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

Formats the value using the given formatter.

impl<'a> DecodeValue<'a> for PrivateKeyInfo<'a>

fn decode_value<R: Reader<'a>>( reader: &mut R, header: Header, ) -> Result<PrivateKeyInfo<'a>>

Attempt to decode this message using the provided Reader.

impl EncodeValue for PrivateKeyInfo<'_>

fn value_len(&self) -> Result<Length>

Compute the length of this value (sans [Tag]+Length header) when encoded as ASN.1 DER.

fn encode_value(&self, writer: &mut impl Writer) -> Result<()>

Encode value (sans [Tag]+Length header) as ASN.1 DER using the provided Writer.

fn header(&self) -> Result<Header, Error>

where Self: Tagged,

Get the Header used to encode this value.

impl PemLabel for PrivateKeyInfo<'_>

Available on crate feature pem only.

const PEM_LABEL: &'static str = "PRIVATE KEY"

Expected PEM type label for a given document, e.g. "PRIVATE KEY"

fn validate_pem_label(actual: &str) -> Result<(), Error>

Validate that a given label matches the expected label.

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

type Error = Error

The type returned in the event of a conversion error.

fn try_from(bytes: &'a [u8]) -> Result<Self>

Performs the conversion.

impl TryFrom<&PrivateKeyInfo<'_>> for SecretDocument

Available on crate feature alloc only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(private_key: &PrivateKeyInfo<'_>) -> Result<SecretDocument>

Performs the conversion.

impl TryFrom<PrivateKeyInfo<'_>> for SecretDocument

Available on crate feature alloc only.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(private_key: PrivateKeyInfo<'_>) -> Result<SecretDocument>

Performs the conversion.

impl<'a> Sequence<'a> for PrivateKeyInfo<'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: 104 bytes