pub struct Rsa<T>(_, _);
Expand description
An RSA key.
Implementations§
source§impl Rsa<Public>
impl Rsa<Public>
sourcepub fn from_public_components(
n: BigNum,
e: BigNum
) -> Result<Rsa<Public>, ErrorStack>
pub fn from_public_components(
n: BigNum,
e: BigNum
) -> Result<Rsa<Public>, ErrorStack>
Creates a new RSA key with only public components.
n
is the modulus common to both public and private key.
e
is the public exponent.
This corresponds to RSA_new
and uses RSA_set0_key
.
sourcepub fn public_key_from_pem(pem: &[u8]) -> Result<Rsa<Public>, ErrorStack>
pub fn public_key_from_pem(pem: &[u8]) -> Result<Rsa<Public>, ErrorStack>
Decodes a PEM-encoded SubjectPublicKeyInfo structure containing an RSA key.
The input should have a header of -----BEGIN PUBLIC KEY-----
.
This corresponds to PEM_read_bio_RSA_PUBKEY
.
sourcepub fn public_key_from_pem_pkcs1(pem: &[u8]) -> Result<Rsa<Public>, ErrorStack>
pub fn public_key_from_pem_pkcs1(pem: &[u8]) -> Result<Rsa<Public>, ErrorStack>
Decodes a PEM-encoded PKCS#1 RSAPublicKey structure.
The input should have a header of -----BEGIN RSA PUBLIC KEY-----
.
This corresponds to PEM_read_bio_RSAPublicKey
.
sourcepub fn public_key_from_der(der: &[u8]) -> Result<Rsa<Public>, ErrorStack>
pub fn public_key_from_der(der: &[u8]) -> Result<Rsa<Public>, ErrorStack>
Decodes a DER-encoded SubjectPublicKeyInfo structure containing an RSA key.
This corresponds to d2i_RSA_PUBKEY
.
sourcepub fn public_key_from_der_pkcs1(der: &[u8]) -> Result<Rsa<Public>, ErrorStack>
pub fn public_key_from_der_pkcs1(der: &[u8]) -> Result<Rsa<Public>, ErrorStack>
Decodes a DER-encoded PKCS#1 RSAPublicKey structure.
This corresponds to d2i_RSAPublicKey
.
source§impl Rsa<Private>
impl Rsa<Private>
sourcepub fn from_private_components(
n: BigNum,
e: BigNum,
d: BigNum,
p: BigNum,
q: BigNum,
dmp1: BigNum,
dmq1: BigNum,
iqmp: BigNum
) -> Result<Rsa<Private>, ErrorStack>
pub fn from_private_components(
n: BigNum,
e: BigNum,
d: BigNum,
p: BigNum,
q: BigNum,
dmp1: BigNum,
dmq1: BigNum,
iqmp: BigNum
) -> Result<Rsa<Private>, ErrorStack>
Creates a new RSA key with private components (public components are assumed).
This a convenience method over:
RsaPrivateKeyBuilder::new(n, e, d)?
.set_factors(p, q)?
.set_crt_params(dmp1, dmq1, iqmp)?
.build();
sourcepub fn generate(bits: u32) -> Result<Rsa<Private>, ErrorStack>
pub fn generate(bits: u32) -> Result<Rsa<Private>, ErrorStack>
Generates a public/private key pair with the specified size.
The public exponent will be 65537.
This corresponds to RSA_generate_key_ex
.
sourcepub fn generate_with_e(
bits: u32,
e: &BigNumRef
) -> Result<Rsa<Private>, ErrorStack>
pub fn generate_with_e(
bits: u32,
e: &BigNumRef
) -> Result<Rsa<Private>, ErrorStack>
Generates a public/private key pair with the specified size and a custom exponent.
Unless you have specific needs and know what you’re doing, use Rsa::generate
instead.
This corresponds to RSA_generate_key_ex
.
sourcepub fn private_key_from_pem(pem: &[u8]) -> Result<Rsa<Private>, ErrorStack>
pub fn private_key_from_pem(pem: &[u8]) -> Result<Rsa<Private>, ErrorStack>
Deserializes a private key from a PEM-encoded PKCS#1 RSAPrivateKey structure.
This corresponds to PEM_read_bio_RSAPrivateKey
.
sourcepub fn private_key_from_pem_passphrase(
pem: &[u8],
passphrase: &[u8]
) -> Result<Rsa<Private>, ErrorStack>
pub fn private_key_from_pem_passphrase(
pem: &[u8],
passphrase: &[u8]
) -> Result<Rsa<Private>, ErrorStack>
Deserializes a private key from a PEM-encoded encrypted PKCS#1 RSAPrivateKey structure.
This corresponds to PEM_read_bio_RSAPrivateKey
.
sourcepub fn private_key_from_pem_callback<F>(
pem: &[u8],
callback: F
) -> Result<Rsa<Private>, ErrorStack>where
F: FnOnce(&mut [u8]) -> Result<usize, ErrorStack>,
pub fn private_key_from_pem_callback<F>(
pem: &[u8],
callback: F
) -> Result<Rsa<Private>, ErrorStack>where
F: FnOnce(&mut [u8]) -> Result<usize, ErrorStack>,
Deserializes a private key from a PEM-encoded encrypted PKCS#1 RSAPrivateKey structure.
The callback should fill the password into the provided buffer and return its length.
This corresponds to PEM_read_bio_RSAPrivateKey
.
sourcepub fn private_key_from_der(der: &[u8]) -> Result<Rsa<Private>, ErrorStack>
pub fn private_key_from_der(der: &[u8]) -> Result<Rsa<Private>, ErrorStack>
Decodes a DER-encoded PKCS#1 RSAPrivateKey structure.
This corresponds to d2i_RSAPrivateKey
.
Methods from Deref<Target = RsaRef<T>>§
sourcepub fn private_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack>
pub fn private_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack>
Serializes the private key to a PEM-encoded PKCS#1 RSAPrivateKey structure.
The output will have a header of -----BEGIN RSA PRIVATE KEY-----
.
This corresponds to PEM_write_bio_RSAPrivateKey
.
sourcepub fn private_key_to_pem_passphrase(
&self,
cipher: Cipher,
passphrase: &[u8]
) -> Result<Vec<u8>, ErrorStack>
pub fn private_key_to_pem_passphrase(
&self,
cipher: Cipher,
passphrase: &[u8]
) -> Result<Vec<u8>, ErrorStack>
Serializes the private key to a PEM-encoded encrypted PKCS#1 RSAPrivateKey structure.
The output will have a header of -----BEGIN RSA PRIVATE KEY-----
.
This corresponds to PEM_write_bio_RSAPrivateKey
.
sourcepub fn private_key_to_der(&self) -> Result<Vec<u8>, ErrorStack>
pub fn private_key_to_der(&self) -> Result<Vec<u8>, ErrorStack>
Serializes the private key to a DER-encoded PKCS#1 RSAPrivateKey structure.
This corresponds to i2d_RSAPrivateKey
.
sourcepub fn private_decrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
pub fn private_decrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
Decrypts data using the private key, returning the number of decrypted bytes.
Panics
Panics if self
has no private components, or if to
is smaller
than self.size()
.
This corresponds to RSA_private_decrypt
.
sourcepub fn private_encrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
pub fn private_encrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
Encrypts data using the private key, returning the number of encrypted bytes.
Panics
Panics if self
has no private components, or if to
is smaller
than self.size()
.
This corresponds to RSA_private_encrypt
.
sourcepub fn d(&self) -> &BigNumRef
pub fn d(&self) -> &BigNumRef
Returns a reference to the private exponent of the key.
This corresponds to RSA_get0_key
.
sourcepub fn p(&self) -> Option<&BigNumRef>
pub fn p(&self) -> Option<&BigNumRef>
Returns a reference to the first factor of the exponent of the key.
This corresponds to RSA_get0_factors
.
sourcepub fn q(&self) -> Option<&BigNumRef>
pub fn q(&self) -> Option<&BigNumRef>
Returns a reference to the second factor of the exponent of the key.
This corresponds to RSA_get0_factors
.
sourcepub fn dmp1(&self) -> Option<&BigNumRef>
pub fn dmp1(&self) -> Option<&BigNumRef>
Returns a reference to the first exponent used for CRT calculations.
This corresponds to RSA_get0_crt_params
.
sourcepub fn dmq1(&self) -> Option<&BigNumRef>
pub fn dmq1(&self) -> Option<&BigNumRef>
Returns a reference to the second exponent used for CRT calculations.
This corresponds to RSA_get0_crt_params
.
sourcepub fn iqmp(&self) -> Option<&BigNumRef>
pub fn iqmp(&self) -> Option<&BigNumRef>
Returns a reference to the coefficient used for CRT calculations.
This corresponds to RSA_get0_crt_params
.
sourcepub fn check_key(&self) -> Result<bool, ErrorStack>
pub fn check_key(&self) -> Result<bool, ErrorStack>
Validates RSA parameters for correctness
This corresponds to RSA_check_key
.
sourcepub fn public_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack>
pub fn public_key_to_pem(&self) -> Result<Vec<u8>, ErrorStack>
Serializes the public key into a PEM-encoded SubjectPublicKeyInfo structure.
The output will have a header of -----BEGIN PUBLIC KEY-----
.
This corresponds to PEM_write_bio_RSA_PUBKEY
.
sourcepub fn public_key_to_der(&self) -> Result<Vec<u8>, ErrorStack>
pub fn public_key_to_der(&self) -> Result<Vec<u8>, ErrorStack>
Serializes the public key into a DER-encoded SubjectPublicKeyInfo structure.
This corresponds to i2d_RSA_PUBKEY
.
sourcepub fn public_key_to_pem_pkcs1(&self) -> Result<Vec<u8>, ErrorStack>
pub fn public_key_to_pem_pkcs1(&self) -> Result<Vec<u8>, ErrorStack>
Serializes the public key into a PEM-encoded PKCS#1 RSAPublicKey structure.
The output will have a header of -----BEGIN RSA PUBLIC KEY-----
.
This corresponds to PEM_write_bio_RSAPublicKey
.
sourcepub fn public_key_to_der_pkcs1(&self) -> Result<Vec<u8>, ErrorStack>
pub fn public_key_to_der_pkcs1(&self) -> Result<Vec<u8>, ErrorStack>
Serializes the public key into a DER-encoded PKCS#1 RSAPublicKey structure.
This corresponds to i2d_RSAPublicKey
.
sourcepub fn size(&self) -> u32
pub fn size(&self) -> u32
Returns the size of the modulus in bytes.
This corresponds to RSA_size
.
Examples found in repository?
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344
pub fn private_decrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding,
) -> Result<usize, ErrorStack> {
assert!(from.len() <= i32::max_value() as usize);
assert!(to.len() >= self.size() as usize);
unsafe {
let len = cvt_n(ffi::RSA_private_decrypt(
from.len() as LenType,
from.as_ptr(),
to.as_mut_ptr(),
self.as_ptr(),
padding.0,
))?;
Ok(len as usize)
}
}
/// Encrypts data using the private key, returning the number of encrypted bytes.
///
/// # Panics
///
/// Panics if `self` has no private components, or if `to` is smaller
/// than `self.size()`.
#[corresponds(RSA_private_encrypt)]
pub fn private_encrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding,
) -> Result<usize, ErrorStack> {
assert!(from.len() <= i32::max_value() as usize);
assert!(to.len() >= self.size() as usize);
unsafe {
let len = cvt_n(ffi::RSA_private_encrypt(
from.len() as LenType,
from.as_ptr(),
to.as_mut_ptr(),
self.as_ptr(),
padding.0,
))?;
Ok(len as usize)
}
}
/// Returns a reference to the private exponent of the key.
#[corresponds(RSA_get0_key)]
pub fn d(&self) -> &BigNumRef {
unsafe {
let mut d = ptr::null();
RSA_get0_key(self.as_ptr(), ptr::null_mut(), ptr::null_mut(), &mut d);
BigNumRef::from_const_ptr(d)
}
}
/// Returns a reference to the first factor of the exponent of the key.
#[corresponds(RSA_get0_factors)]
pub fn p(&self) -> Option<&BigNumRef> {
unsafe {
let mut p = ptr::null();
RSA_get0_factors(self.as_ptr(), &mut p, ptr::null_mut());
BigNumRef::from_const_ptr_opt(p)
}
}
/// Returns a reference to the second factor of the exponent of the key.
#[corresponds(RSA_get0_factors)]
pub fn q(&self) -> Option<&BigNumRef> {
unsafe {
let mut q = ptr::null();
RSA_get0_factors(self.as_ptr(), ptr::null_mut(), &mut q);
BigNumRef::from_const_ptr_opt(q)
}
}
/// Returns a reference to the first exponent used for CRT calculations.
#[corresponds(RSA_get0_crt_params)]
pub fn dmp1(&self) -> Option<&BigNumRef> {
unsafe {
let mut dp = ptr::null();
RSA_get0_crt_params(self.as_ptr(), &mut dp, ptr::null_mut(), ptr::null_mut());
BigNumRef::from_const_ptr_opt(dp)
}
}
/// Returns a reference to the second exponent used for CRT calculations.
#[corresponds(RSA_get0_crt_params)]
pub fn dmq1(&self) -> Option<&BigNumRef> {
unsafe {
let mut dq = ptr::null();
RSA_get0_crt_params(self.as_ptr(), ptr::null_mut(), &mut dq, ptr::null_mut());
BigNumRef::from_const_ptr_opt(dq)
}
}
/// Returns a reference to the coefficient used for CRT calculations.
#[corresponds(RSA_get0_crt_params)]
pub fn iqmp(&self) -> Option<&BigNumRef> {
unsafe {
let mut qi = ptr::null();
RSA_get0_crt_params(self.as_ptr(), ptr::null_mut(), ptr::null_mut(), &mut qi);
BigNumRef::from_const_ptr_opt(qi)
}
}
/// Validates RSA parameters for correctness
#[corresponds(RSA_check_key)]
#[allow(clippy::unnecessary_cast)]
pub fn check_key(&self) -> Result<bool, ErrorStack> {
unsafe {
let result = ffi::RSA_check_key(self.as_ptr()) as i32;
if result == -1 {
Err(ErrorStack::get())
} else {
Ok(result == 1)
}
}
}
}
impl<T> RsaRef<T>
where
T: HasPublic,
{
to_pem! {
/// Serializes the public key into a PEM-encoded SubjectPublicKeyInfo structure.
///
/// The output will have a header of `-----BEGIN PUBLIC KEY-----`.
#[corresponds(PEM_write_bio_RSA_PUBKEY)]
public_key_to_pem,
ffi::PEM_write_bio_RSA_PUBKEY
}
to_der! {
/// Serializes the public key into a DER-encoded SubjectPublicKeyInfo structure.
#[corresponds(i2d_RSA_PUBKEY)]
public_key_to_der,
ffi::i2d_RSA_PUBKEY
}
to_pem! {
/// Serializes the public key into a PEM-encoded PKCS#1 RSAPublicKey structure.
///
/// The output will have a header of `-----BEGIN RSA PUBLIC KEY-----`.
#[corresponds(PEM_write_bio_RSAPublicKey)]
public_key_to_pem_pkcs1,
ffi::PEM_write_bio_RSAPublicKey
}
to_der! {
/// Serializes the public key into a DER-encoded PKCS#1 RSAPublicKey structure.
#[corresponds(i2d_RSAPublicKey)]
public_key_to_der_pkcs1,
ffi::i2d_RSAPublicKey
}
/// Returns the size of the modulus in bytes.
#[corresponds(RSA_size)]
pub fn size(&self) -> u32 {
unsafe { ffi::RSA_size(self.as_ptr()) as u32 }
}
/// Decrypts data using the public key, returning the number of decrypted bytes.
///
/// # Panics
///
/// Panics if `to` is smaller than `self.size()`.
#[corresponds(RSA_public_decrypt)]
pub fn public_decrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding,
) -> Result<usize, ErrorStack> {
assert!(from.len() <= i32::max_value() as usize);
assert!(to.len() >= self.size() as usize);
unsafe {
let len = cvt_n(ffi::RSA_public_decrypt(
from.len() as LenType,
from.as_ptr(),
to.as_mut_ptr(),
self.as_ptr(),
padding.0,
))?;
Ok(len as usize)
}
}
/// Encrypts data using the public key, returning the number of encrypted bytes.
///
/// # Panics
///
/// Panics if `to` is smaller than `self.size()`.
#[corresponds(RSA_public_encrypt)]
pub fn public_encrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding,
) -> Result<usize, ErrorStack> {
assert!(from.len() <= i32::max_value() as usize);
assert!(to.len() >= self.size() as usize);
unsafe {
let len = cvt_n(ffi::RSA_public_encrypt(
from.len() as LenType,
from.as_ptr(),
to.as_mut_ptr(),
self.as_ptr(),
padding.0,
))?;
Ok(len as usize)
}
}
sourcepub fn public_decrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
pub fn public_decrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
Decrypts data using the public key, returning the number of decrypted bytes.
Panics
Panics if to
is smaller than self.size()
.
This corresponds to RSA_public_decrypt
.
sourcepub fn public_encrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
pub fn public_encrypt(
&self,
from: &[u8],
to: &mut [u8],
padding: Padding
) -> Result<usize, ErrorStack>
Encrypts data using the public key, returning the number of encrypted bytes.
Panics
Panics if to
is smaller than self.size()
.
This corresponds to RSA_public_encrypt
.
sourcepub fn n(&self) -> &BigNumRef
pub fn n(&self) -> &BigNumRef
Returns a reference to the modulus of the key.
This corresponds to RSA_get0_key
.
sourcepub fn e(&self) -> &BigNumRef
pub fn e(&self) -> &BigNumRef
Returns a reference to the public exponent of the key.
This corresponds to RSA_get0_key
.