Struct RsaPrivateKey 

pub struct RsaPrivateKey {
    pubkey_components: RsaPublicKey,
    pub(crate) d: BoxedUint,
    pub(crate) primes: Vec<BoxedUint>,
    pub(crate) precomputed: Option<PrecomputedValues>,
}

Represents a whole RSA key, public and private parts.

Fields

pubkey_components: RsaPublicKey

Public components of the private key.

d: BoxedUint

Private exponent

primes: Vec<BoxedUint>

Prime factors of N, contains >= 2 elements.

precomputed: Option<PrecomputedValues>

Precomputed values to speed up private operations

Implementations

impl RsaPrivateKey

const EXP: u64 = 65537

Default exponent for RSA keys.

const MIN_SIZE: u32 = 1024

Minimum size of the modulus n in bits. Currently only applies to keygen.

pub fn new<R: CryptoRng + ?Sized>(rng: &mut R, bit_size: usize) -> Result<Self>

Generate a new RSA key pair with a modulus of the given bit size using the passed in rng.

Errors

• If bit_size is lower than the minimum 1024-bits.

pub fn new_with_exp<R: CryptoRng + ?Sized>( rng: &mut R, bit_size: usize, exp: BoxedUint, ) -> Result<RsaPrivateKey>

Generate a new RSA key pair of the given bit size and the public exponent using the passed in rng.

Unless you have specific needs, you should use RsaPrivateKey::new instead.

fn from_components_inner( n: BoxedUint, e: BoxedUint, d: BoxedUint, primes: Vec<BoxedUint>, ) -> Result<RsaPrivateKey>

Private helper function that constructs an RSA key pair from components WITHOUT performing any validation or precomputation.

This is the shared implementation used by from_components and from_components_with_large_exponent.

Callers are responsible for:

1. Validating the key (to ensure precomputation won’t fail)
2. Calling precompute() after validation

pub fn from_components( n: BoxedUint, e: BoxedUint, d: BoxedUint, primes: Vec<BoxedUint>, ) -> Result<RsaPrivateKey>

Constructs an RSA key pair from individual components:

• n: RSA modulus
• e: public exponent (i.e. encrypting exponent)
• d: private exponent (i.e. decrypting exponent)
• primes: prime factors of n: typically two primes p and q. More than two primes can be provided for multiprime RSA, however this is generally not recommended. If no primes are provided, a prime factor recovery algorithm will be employed to attempt to recover the factors (as described in NIST SP 800-56B Revision 2 Appendix C.2). This algorithm only works if there are just two prime factors p and q (as opposed to multiprime), and e is between 2^16 and 2^256.

pub fn from_p_q( p: BoxedUint, q: BoxedUint, public_exponent: BoxedUint, ) -> Result<RsaPrivateKey>

Constructs an RSA key pair from its two primes p and q.

This will rebuild the private exponent and the modulus.

Private exponent will be rebuilt using the method defined in NIST 800-56B Section 6.2.1.

pub fn from_primes( primes: Vec<BoxedUint>, public_exponent: BoxedUint, ) -> Result<RsaPrivateKey>

Constructs an RSA key pair from its primes.

This will rebuild the private exponent and the modulus.

pub fn as_public_key(&self) -> &RsaPublicKey

Get the public key from the private key.

Specific alternative to AsRef::as_ref.

pub fn to_public_key(&self) -> RsaPublicKey

Get the public key from the private key, cloning n and e.

Generally this is not needed since RsaPrivateKey implements the PublicKey trait, but it can occasionally be useful to discard the private information entirely.

pub fn precompute(&mut self) -> Result<()>

Performs some calculations to speed up private key operations.

pub fn clear_precomputed(&mut self)

Clears precomputed values by setting to None

pub fn crt_coefficient(&self) -> Option<BoxedUint>

Compute CRT coefficient: (1/q) mod p.

pub fn validate(&self) -> Result<()>

Performs basic sanity checks on the key. Returns Ok(()) if everything is good, otherwise an appropriate error.

pub fn decrypt<P: PaddingScheme>( &self, padding: P, ciphertext: &[u8], ) -> Result<Vec<u8>>

Decrypt the given message.

pub fn decrypt_blinded<R: CryptoRng + ?Sized, P: PaddingScheme>( &self, rng: &mut R, padding: P, ciphertext: &[u8], ) -> Result<Vec<u8>>

Decrypt the given message.

Uses rng to blind the decryption process.

pub fn sign<S: SignatureScheme>( &self, padding: S, digest_in: &[u8], ) -> Result<Vec<u8>>

Sign the given digest.

pub fn sign_with_rng<R: CryptoRng + ?Sized, S: SignatureScheme>( &self, rng: &mut R, padding: S, digest_in: &[u8], ) -> Result<Vec<u8>>

Sign the given digest using the provided rng, which is used in the following ways depending on the SignatureScheme:

• Pkcs1v15Sign padding: uses the RNG to mask the private key operation with random blinding, which helps mitigate sidechannel attacks.
• Pss always requires randomness. Use Pss::new for a standard RSASSA-PSS signature, or Pss::new_blinded for RSA-BSSA blind signatures.

Trait Implementations

impl<D> AsRef<RsaPrivateKey> for BlindedSigningKey<D>

where D: Digest,

fn as_ref(&self) -> &RsaPrivateKey

Converts this type into a shared reference of the (usually inferred) input type.

impl<D> AsRef<RsaPrivateKey> for SigningKey<D>

where D: Digest,

fn as_ref(&self) -> &RsaPrivateKey

Converts this type into a shared reference of the (usually inferred) input type.

impl<D> AsRef<RsaPrivateKey> for SigningKey<D>

where D: Digest,

fn as_ref(&self) -> &RsaPrivateKey

Converts this type into a shared reference of the (usually inferred) input type.

impl AsRef<RsaPublicKey> for RsaPrivateKey

fn as_ref(&self) -> &RsaPublicKey

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for RsaPrivateKey

fn clone(&self) -> RsaPrivateKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RsaPrivateKey

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

Formats the value using the given formatter.

impl DecodeRsaPrivateKey for RsaPrivateKey

fn from_pkcs1_der(bytes: &[u8]) -> Result<Self>

Deserialize PKCS#1 private key from ASN.1 DER-encoded data (binary format).

fn from_pkcs1_pem(s: &str) -> Result<Self, Error>

Deserialize PKCS#1-encoded private key from PEM.

fn read_pkcs1_der_file(path: impl AsRef<Path>) -> Result<Self, Error>

Load PKCS#1 private key from an ASN.1 DER-encoded file on the local filesystem (binary format).

fn read_pkcs1_pem_file(path: impl AsRef<Path>) -> Result<Self, Error>

Load PKCS#1 private key from a PEM-encoded file on the local filesystem.

impl Drop for RsaPrivateKey

fn drop(&mut self)

Executes the destructor for this type.

impl EncodePrivateKey for RsaPrivateKey

fn to_pkcs8_der(&self) -> Result<SecretDocument>

Serialize a SecretDocument containing a PKCS#8-encoded private key.

fn to_pkcs8_pem( &self, line_ending: LineEnding, ) -> Result<Zeroizing<String>, Error>

Serialize this private key as PEM-encoded PKCS#8 with the given LineEnding.

fn write_pkcs8_der_file(&self, path: impl AsRef<Path>) -> Result<(), Error>

Write ASN.1 DER-encoded PKCS#8 private key to the given path.

fn write_pkcs8_pem_file( &self, path: impl AsRef<Path>, line_ending: LineEnding, ) -> Result<(), Error>

Write ASN.1 PEM-encoded PKCS#8 private key to the given path.

impl EncodeRsaPrivateKey for RsaPrivateKey

fn to_pkcs1_der(&self) -> Result<SecretDocument>

Serialize a SecretDocument containing a PKCS#1-encoded private key.

fn to_pkcs1_pem( &self, line_ending: LineEnding, ) -> Result<Zeroizing<String>, Error>

Serialize this private key as PEM-encoded PKCS#1 with the given LineEnding.

fn write_pkcs1_der_file(&self, path: impl AsRef<Path>) -> Result<(), Error>

Write ASN.1 DER-encoded PKCS#1 private key to the given path.

fn write_pkcs1_pem_file( &self, path: impl AsRef<Path>, line_ending: LineEnding, ) -> Result<(), Error>

Write ASN.1 PEM-encoded PKCS#1 private key to the given path.

impl From<&RsaPrivateKey> for RsaPublicKey

fn from(private_key: &RsaPrivateKey) -> Self

Converts to this type from the input type.

impl<D> From<BlindedSigningKey<D>> for RsaPrivateKey

where D: Digest,

fn from(key: BlindedSigningKey<D>) -> Self

Converts to this type from the input type.

impl<D> From<RsaPrivateKey> for BlindedSigningKey<D>

where D: Digest,

fn from(key: RsaPrivateKey) -> Self

Converts to this type from the input type.

impl From<RsaPrivateKey> for RsaPublicKey

fn from(private_key: RsaPrivateKey) -> Self

Converts to this type from the input type.

impl<D> From<RsaPrivateKey> for SigningKey<D>

where D: Digest + AssociatedOid,

fn from(key: RsaPrivateKey) -> Self

Converts to this type from the input type.

impl<D> From<RsaPrivateKey> for SigningKey<D>

where D: Digest,

fn from(key: RsaPrivateKey) -> Self

Converts to this type from the input type.

impl<D> From<SigningKey<D>> for RsaPrivateKey

where D: Digest,

fn from(key: SigningKey<D>) -> Self

Converts to this type from the input type.

impl<D> From<SigningKey<D>> for RsaPrivateKey

where D: Digest,

fn from(key: SigningKey<D>) -> Self

Converts to this type from the input type.

impl Hash for RsaPrivateKey

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 PartialEq for RsaPrivateKey

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

fn d(&self) -> &BoxedUint

Returns the private exponent of the key.

fn primes(&self) -> &[BoxedUint]

Returns the prime factors.

fn dp(&self) -> Option<&BoxedUint>

Returns the precomputed dp value, D mod (P-1)

fn dq(&self) -> Option<&BoxedUint>

Returns the precomputed dq value, D mod (Q-1)

fn qinv(&self) -> Option<&BoxedMontyForm>

Returns the precomputed qinv value, Q^-1 mod P

fn crt_values(&self) -> Option<&[CrtValue]>

Returns an iterator over the CRT Values

fn p_params(&self) -> Option<&BoxedMontyParams>

Returns the params for p if precomputed.

fn q_params(&self) -> Option<&BoxedMontyParams>

Returns the params for q if precomputed.

impl PublicKeyParts for RsaPrivateKey

fn n(&self) -> &NonZero<BoxedUint>

Returns the modulus of the key.

fn e(&self) -> &BoxedUint

Returns the public exponent of the key.

fn n_params(&self) -> &BoxedMontyParams

Returns the parameters for montgomery operations.

fn size(&self) -> usize

Returns the modulus size in bytes. Raw signatures and ciphertexts for or by this public key will have the same size.

fn n_bits_precision(&self) -> u32

Returns precision (in bits) of n.

fn n_bytes(&self) -> Box<[u8]>

Returns the big endian serialization of the modulus of the key

fn e_bytes(&self) -> Box<[u8]>

Returns the big endian serialization of the public exponent of the key

impl TryFrom<PrivateKeyInfo<AnyRef<'_>, &OctetStringRef, BitStringRef<'_>>> for RsaPrivateKey

type Error = Error

The type returned in the event of a conversion error.

fn try_from(private_key_info: PrivateKeyInfoRef<'_>) -> Result<Self>

Performs the conversion.

impl TryFrom<RsaPrivateKey<'_>> for RsaPrivateKey

type Error = Error

The type returned in the event of a conversion error.

fn try_from(pkcs1_key: RsaPrivateKey<'_>) -> Result<RsaPrivateKey>

Performs the conversion.

impl Eq for RsaPrivateKey

impl ZeroizeOnDrop for RsaPrivateKey