Struct RsaPrivateKey 

pub struct RsaPrivateKey { /* private fields */ }

Represents a whole RSA key, public and private parts.

Implementations

impl RsaPrivateKey

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

Generate a new Rsa key pair of the given bit size using the passed in rng.

pub fn new_with_exp<R: CryptoRngCore + ?Sized>( rng: &mut R, bit_size: usize, exp: &BigUint, ) -> 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.

pub fn from_components( n: BigUint, e: BigUint, d: BigUint, primes: Vec<BigUint>, ) -> 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: BigUint, q: BigUint, public_exponent: BigUint, ) -> 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<BigUint>, public_exponent: BigUint, ) -> Result<RsaPrivateKey>

Constructs an RSA key pair from its primes.

This will rebuild the private exponent and the modulus.

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<BigUint>

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: CryptoRngCore, 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: CryptoRngCore, 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 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 DER-encoded PKCS#8 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,

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) -> &BigUint

Returns the private exponent of the key.

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

Returns the prime factors.

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

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

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

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

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

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

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

Returns an iterator over the CRT Values

impl PublicKeyParts for RsaPrivateKey

fn n(&self) -> &BigUint

Returns the modulus of the key.

fn e(&self) -> &BigUint

Returns the public exponent of the key.

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.

impl TryFrom<PrivateKeyInfo<'_>> for RsaPrivateKey

type Error = Error

The type returned in the event of a conversion error.

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

Performs the conversion.

impl Eq for RsaPrivateKey

impl ZeroizeOnDrop for RsaPrivateKey

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: 344 bytes