Struct PrivateKeyInfo

pub struct PrivateKeyInfo {
    pub version: u8,
    pub private_key_algorithm: AlgorithmIdentifier,
    pub private_key: PrivateKeyValue,
    pub public_key: Option<ExplicitContextTag1<Optional<BitStringAsn1>>>,
}

Public-Key Cryptography Standards (PKCS) #8 Asymmetric Key Packages

Section 5

Private-key information shall have ASN.1 type OneAsymmetricKey (Backwards-compatible with PrivateKeyInfo from RFC5208):

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

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

  PrivateKeyAlgorithmIdentifier ::= AlgorithmIdentifier

  PrivateKey ::= OCTET STRING

  PublicKey ::= BIT STRING

  Attributes ::= SET OF Attribute { { OneAsymmetricKeyAttributes } }

The fields of type OneAsymmetricKey have the following meanings:

version identifies the version of OneAsymmetricKey. If publicKey is present, then version is set to v2(1) else version is set to v1(0).

privateKeyAlgorithm identifies the private-key algorithm. One example of a private-key algorithm is PKCS #1’s rsaEncryption.

privateKey is an octet string whose contents are the value of the private key. The interpretation of the contents is defined in the registration of the private-key algorithm. For an RSA private key, for example, the contents are a BER encoding of a value of type RSAPrivateKey.

publicKey is OPTIONAL. When present, it contains the public key encoded in a BIT STRING. The structure within the BIT STRING, if any, depends on the privateKeyAlgorithm

attributes is a set of attributes. These are the extended information that is encrypted along with the private-key information.

Fields

version: u8

private_key_algorithm: AlgorithmIdentifier

private_key: PrivateKeyValue

public_key: Option<ExplicitContextTag1<Optional<BitStringAsn1>>>

Implementations

impl PrivateKeyInfo

pub fn new_rsa_encryption( modulus: IntegerAsn1, public_exponent: IntegerAsn1, private_exponent: IntegerAsn1, primes: (IntegerAsn1, IntegerAsn1), exponents: (IntegerAsn1, IntegerAsn1), coefficient: IntegerAsn1, ) -> Self

pub fn new_ec_encryption( curve_oid: ObjectIdentifier, secret: impl Into<OctetStringAsn1>, public_point: Option<BitString>, skip_optional_params: bool, ) -> Self

Creates a new PrivateKeyInfo with the given curve_oid and secret.

If skip_optional_params is true, the parameters field will be omitted from internal ECPrivateKey ASN.1 structure, reducing duplication. This information is still present in the private_key_algorithm field.

pub fn new_ed_encryption( algorithm: ObjectIdentifier, secret: impl Into<OctetStringAsn1>, public_key: Option<BitString>, ) -> Self

Trait Implementations

impl Clone for PrivateKeyInfo

fn clone(&self) -> PrivateKeyInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PrivateKeyInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PrivateKeyInfo

fn deserialize<D>( deserializer: D, ) -> Result<Self, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for PrivateKeyInfo

fn eq(&self, other: &PrivateKeyInfo) -> 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 Serialize for PrivateKeyInfo

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for PrivateKeyInfo

impl StructuralPartialEq for PrivateKeyInfo