From 98b7f2f9352e4d92b44245d0737f9a45adb4ae2b Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 22 Oct 2016 09:16:38 -0700 Subject: Flatten crypto module --- openssl/src/rsa.rs | 487 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 487 insertions(+) create mode 100644 openssl/src/rsa.rs (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs new file mode 100644 index 00000000..b8702f97 --- /dev/null +++ b/openssl/src/rsa.rs @@ -0,0 +1,487 @@ +use ffi; +use std::fmt; +use std::ptr; +use std::mem; +use libc::{c_int, c_void, c_char}; + +use {cvt, cvt_p, cvt_n}; +use bn::{BigNum, BigNumRef}; +use bio::{MemBio, MemBioSlice}; +use error::ErrorStack; +use util::{CallbackState, invoke_passwd_cb}; + +/// Type of encryption padding to use. +#[derive(Copy, Clone)] +pub struct Padding(c_int); + +impl Padding { + pub fn none() -> Padding { + Padding(ffi::RSA_NO_PADDING) + } + + pub fn pkcs1() -> Padding { + Padding(ffi::RSA_PKCS1_PADDING) + } + + pub fn pkcs1_oaep() -> Padding { + Padding(ffi::RSA_PKCS1_OAEP_PADDING) + } +} + +pub struct RSA(*mut ffi::RSA); + +impl Drop for RSA { + fn drop(&mut self) { + unsafe { + ffi::RSA_free(self.0); + } + } +} + +impl RSA { + /// only useful for associating the key material directly with the key, it's safer to use + /// the supplied load and save methods for DER formatted keys. + pub fn from_public_components(n: BigNum, e: BigNum) -> Result { + unsafe { + let rsa = RSA(try!(cvt_p(ffi::RSA_new()))); + try!(cvt(compat::set_key(rsa.0, + n.as_ptr(), + e.as_ptr(), + ptr::null_mut()))); + mem::forget((n, e)); + Ok(rsa) + } + } + + pub fn from_private_components(n: BigNum, + e: BigNum, + d: BigNum, + p: BigNum, + q: BigNum, + dp: BigNum, + dq: BigNum, + qi: BigNum) + -> Result { + unsafe { + let rsa = RSA(try!(cvt_p(ffi::RSA_new()))); + try!(cvt(compat::set_key(rsa.0, n.as_ptr(), e.as_ptr(), d.as_ptr()))); + mem::forget((n, e, d)); + try!(cvt(compat::set_factors(rsa.0, p.as_ptr(), q.as_ptr()))); + mem::forget((p, q)); + try!(cvt(compat::set_crt_params(rsa.0, dp.as_ptr(), dq.as_ptr(), + qi.as_ptr()))); + mem::forget((dp, dq, qi)); + Ok(rsa) + } + } + + pub unsafe fn from_ptr(rsa: *mut ffi::RSA) -> RSA { + RSA(rsa) + } + + /// Generates a public/private key pair with the specified size. + /// + /// The public exponent will be 65537. + pub fn generate(bits: u32) -> Result { + unsafe { + let rsa = RSA(try!(cvt_p(ffi::RSA_new()))); + let e = try!(BigNum::from_u32(ffi::RSA_F4 as u32)); + try!(cvt(ffi::RSA_generate_key_ex(rsa.0, bits as c_int, e.as_ptr(), ptr::null_mut()))); + Ok(rsa) + } + } + + /// Reads an RSA private key from PEM formatted data. + pub fn private_key_from_pem(buf: &[u8]) -> Result { + let mem_bio = try!(MemBioSlice::new(buf)); + unsafe { + let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), + ptr::null_mut(), + None, + ptr::null_mut()))); + Ok(RSA(rsa)) + } + } + + /// Reads an RSA private key from PEM formatted data and supplies a password callback. + pub fn private_key_from_pem_cb(buf: &[u8], pass_cb: F) -> Result + where F: FnOnce(&mut [c_char]) -> usize + { + let mut cb = CallbackState::new(pass_cb); + let mem_bio = try!(MemBioSlice::new(buf)); + + unsafe { + let cb_ptr = &mut cb as *mut _ as *mut c_void; + let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), + ptr::null_mut(), + Some(invoke_passwd_cb::), + cb_ptr))); + Ok(RSA(rsa)) + } + } + + /// Reads an RSA public key from PEM formatted data. + pub fn public_key_from_pem(buf: &[u8]) -> Result { + let mem_bio = try!(MemBioSlice::new(buf)); + unsafe { + let rsa = try!(cvt_p(ffi::PEM_read_bio_RSA_PUBKEY(mem_bio.as_ptr(), + ptr::null_mut(), + None, + ptr::null_mut()))); + Ok(RSA(rsa)) + } + } + + /// Writes an RSA private key as unencrypted PEM formatted data + pub fn private_key_to_pem(&self) -> Result, ErrorStack> { + let mem_bio = try!(MemBio::new()); + + unsafe { + try!(cvt(ffi::PEM_write_bio_RSAPrivateKey(mem_bio.as_ptr(), + self.0, + ptr::null(), + ptr::null_mut(), + 0, + None, + ptr::null_mut()))); + } + Ok(mem_bio.get_buf().to_owned()) + } + + /// Writes an RSA public key as PEM formatted data + pub fn public_key_to_pem(&self) -> Result, ErrorStack> { + let mem_bio = try!(MemBio::new()); + + unsafe { + try!(cvt(ffi::PEM_write_bio_RSA_PUBKEY(mem_bio.as_ptr(), self.0))); + } + + Ok(mem_bio.get_buf().to_owned()) + } + + pub fn size(&self) -> usize { + unsafe { + assert!(self.n().is_some()); + + ffi::RSA_size(self.0) as usize + } + } + + /// 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()`. + pub fn private_decrypt(&self, + from: &[u8], + to: &mut [u8], + padding: Padding) + -> Result { + assert!(self.d().is_some(), "private components missing"); + assert!(from.len() <= i32::max_value() as usize); + assert!(to.len() >= self.size()); + + unsafe { + let len = try!(cvt_n(ffi::RSA_private_decrypt(from.len() as c_int, + from.as_ptr(), + to.as_mut_ptr(), + self.0, + 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()`. + pub fn private_encrypt(&self, + from: &[u8], + to: &mut [u8], + padding: Padding) + -> Result { + assert!(self.d().is_some(), "private components missing"); + assert!(from.len() <= i32::max_value() as usize); + assert!(to.len() >= self.size()); + + unsafe { + let len = try!(cvt_n(ffi::RSA_private_encrypt(from.len() as c_int, + from.as_ptr(), + to.as_mut_ptr(), + self.0, + padding.0))); + Ok(len as usize) + } + } + + /// Decrypts data using the public key, returning the number of decrypted bytes. + /// + /// # Panics + /// + /// Panics if `to` is smaller than `self.size()`. + pub fn public_decrypt(&self, + from: &[u8], + to: &mut [u8], + padding: Padding) + -> Result { + assert!(from.len() <= i32::max_value() as usize); + assert!(to.len() >= self.size()); + + unsafe { + let len = try!(cvt_n(ffi::RSA_public_decrypt(from.len() as c_int, + from.as_ptr(), + to.as_mut_ptr(), + self.0, + padding.0))); + Ok(len as usize) + } + } + + /// Encrypts data using the private key, returning the number of encrypted bytes. + /// + /// # Panics + /// + /// Panics if `to` is smaller than `self.size()`. + pub fn public_encrypt(&self, + from: &[u8], + to: &mut [u8], + padding: Padding) + -> Result { + assert!(from.len() <= i32::max_value() as usize); + assert!(to.len() >= self.size()); + + unsafe { + let len = try!(cvt_n(ffi::RSA_public_encrypt(from.len() as c_int, + from.as_ptr(), + to.as_mut_ptr(), + self.0, + padding.0))); + Ok(len as usize) + } + } + + pub fn as_ptr(&self) -> *mut ffi::RSA { + self.0 + } + + pub fn n(&self) -> Option<&BigNumRef> { + unsafe { + let n = compat::key(self.0)[0]; + if n.is_null() { + None + } else { + Some(BigNumRef::from_ptr(n as *mut _)) + } + } + } + + pub fn d(&self) -> Option<&BigNumRef> { + unsafe { + let d = compat::key(self.0)[2]; + if d.is_null() { + None + } else { + Some(BigNumRef::from_ptr(d as *mut _)) + } + } + } + + pub fn e(&self) -> Option<&BigNumRef> { + unsafe { + let e = compat::key(self.0)[1]; + if e.is_null() { + None + } else { + Some(BigNumRef::from_ptr(e as *mut _)) + } + } + } + + pub fn p(&self) -> Option<&BigNumRef> { + unsafe { + let p = compat::factors(self.0)[0]; + if p.is_null() { + None + } else { + Some(BigNumRef::from_ptr(p as *mut _)) + } + } + } + + pub fn q(&self) -> Option<&BigNumRef> { + unsafe { + let q = compat::factors(self.0)[1]; + if q.is_null() { + None + } else { + Some(BigNumRef::from_ptr(q as *mut _)) + } + } + } +} + +impl fmt::Debug for RSA { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "RSA") + } +} + +#[cfg(ossl110)] +mod compat { + use std::ptr; + + use ffi::{self, BIGNUM, RSA}; + use libc::c_int; + + pub unsafe fn key(r: *const RSA) -> [*const BIGNUM; 3] { + let (mut n, mut e, mut d) = (ptr::null(), ptr::null(), ptr::null()); + ffi::RSA_get0_key(r, &mut n, &mut e, &mut d); + [n, e, d] + } + + pub unsafe fn factors(r: *const RSA) -> [*const BIGNUM; 2] { + let (mut p, mut q) = (ptr::null(), ptr::null()); + ffi::RSA_get0_factors(r, &mut p, &mut q); + [p, q] + } + + pub unsafe fn set_key(r: *mut RSA, + n: *mut BIGNUM, + e: *mut BIGNUM, + d: *mut BIGNUM) -> c_int { + ffi::RSA_set0_key(r, n, e, d) + } + + pub unsafe fn set_factors(r: *mut RSA, + p: *mut BIGNUM, + q: *mut BIGNUM) -> c_int { + ffi::RSA_set0_factors(r, p, q) + } + + pub unsafe fn set_crt_params(r: *mut RSA, + dmp1: *mut BIGNUM, + dmq1: *mut BIGNUM, + iqmp: *mut BIGNUM) -> c_int { + ffi::RSA_set0_crt_params(r, dmp1, dmq1, iqmp) + } +} + +#[cfg(ossl10x)] +mod compat { + use libc::c_int; + use ffi::{BIGNUM, RSA}; + + pub unsafe fn key(r: *const RSA) -> [*const BIGNUM; 3] { + [(*r).n, (*r).e, (*r).d] + } + + pub unsafe fn factors(r: *const RSA) -> [*const BIGNUM; 2] { + [(*r).p, (*r).q] + } + + pub unsafe fn set_key(r: *mut RSA, + n: *mut BIGNUM, + e: *mut BIGNUM, + d: *mut BIGNUM) -> c_int { + (*r).n = n; + (*r).e = e; + (*r).d = d; + 1 // TODO: is this right? should it be 0? what's success? + } + + pub unsafe fn set_factors(r: *mut RSA, + p: *mut BIGNUM, + q: *mut BIGNUM) -> c_int { + (*r).p = p; + (*r).q = q; + 1 // TODO: is this right? should it be 0? what's success? + } + + pub unsafe fn set_crt_params(r: *mut RSA, + dmp1: *mut BIGNUM, + dmq1: *mut BIGNUM, + iqmp: *mut BIGNUM) -> c_int { + (*r).dmp1 = dmp1; + (*r).dmq1 = dmq1; + (*r).iqmp = iqmp; + 1 // TODO: is this right? should it be 0? what's success? + } +} + + +#[cfg(test)] +mod test { + use libc::c_char; + + use super::*; + + #[test] + pub fn test_password() { + let mut password_queried = false; + let key = include_bytes!("../test/rsa-encrypted.pem"); + RSA::private_key_from_pem_cb(key, |password| { + password_queried = true; + password[0] = b'm' as c_char; + password[1] = b'y' as c_char; + password[2] = b'p' as c_char; + password[3] = b'a' as c_char; + password[4] = b's' as c_char; + password[5] = b's' as c_char; + 6 + }).unwrap(); + + assert!(password_queried); + } + + #[test] + pub fn test_public_encrypt_private_decrypt_with_padding() { + let key = include_bytes!("../test/rsa.pem.pub"); + let public_key = RSA::public_key_from_pem(key).unwrap(); + + let mut result = vec![0; public_key.size()]; + let original_data = b"This is test"; + let len = public_key.public_encrypt(original_data, &mut result, Padding::pkcs1()).unwrap(); + assert_eq!(len, 256); + + let pkey = include_bytes!("../test/rsa.pem"); + let private_key = RSA::private_key_from_pem(pkey).unwrap(); + let mut dec_result = vec![0; private_key.size()]; + let len = private_key.private_decrypt(&result, &mut dec_result, Padding::pkcs1()).unwrap(); + + assert_eq!(&dec_result[..len], original_data); + } + + #[test] + fn test_private_encrypt() { + let k0 = super::RSA::generate(512).unwrap(); + let k0pkey = k0.public_key_to_pem().unwrap(); + let k1 = super::RSA::public_key_from_pem(&k0pkey).unwrap(); + + let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; + + let mut emesg = vec![0; k0.size()]; + k0.private_encrypt(&msg, &mut emesg, Padding::pkcs1()).unwrap(); + let mut dmesg = vec![0; k1.size()]; + let len = k1.public_decrypt(&emesg, &mut dmesg, Padding::pkcs1()).unwrap(); + assert_eq!(msg, &dmesg[..len]); + } + + #[test] + fn test_public_encrypt() { + let k0 = super::RSA::generate(512).unwrap(); + let k0pkey = k0.private_key_to_pem().unwrap(); + let k1 = super::RSA::private_key_from_pem(&k0pkey).unwrap(); + + let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; + + let mut emesg = vec![0; k0.size()]; + k0.public_encrypt(&msg, &mut emesg, Padding::pkcs1()).unwrap(); + let mut dmesg = vec![0; k1.size()]; + let len = k1.private_decrypt(&emesg, &mut dmesg, Padding::pkcs1()).unwrap(); + assert_eq!(msg, &dmesg[..len]); + } + +} -- cgit v1.2.3 From 3c50c74444e841c9178758fe18dcef38f56da243 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sat, 22 Oct 2016 10:21:16 -0700 Subject: Camel case Rsa --- openssl/src/rsa.rs | 50 +++++++++++++++++++++++++------------------------- 1 file changed, 25 insertions(+), 25 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index b8702f97..550ce6e4 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -28,9 +28,9 @@ impl Padding { } } -pub struct RSA(*mut ffi::RSA); +pub struct Rsa(*mut ffi::RSA); -impl Drop for RSA { +impl Drop for Rsa { fn drop(&mut self) { unsafe { ffi::RSA_free(self.0); @@ -38,12 +38,12 @@ impl Drop for RSA { } } -impl RSA { +impl Rsa { /// only useful for associating the key material directly with the key, it's safer to use /// the supplied load and save methods for DER formatted keys. - pub fn from_public_components(n: BigNum, e: BigNum) -> Result { + pub fn from_public_components(n: BigNum, e: BigNum) -> Result { unsafe { - let rsa = RSA(try!(cvt_p(ffi::RSA_new()))); + let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); try!(cvt(compat::set_key(rsa.0, n.as_ptr(), e.as_ptr(), @@ -61,9 +61,9 @@ impl RSA { dp: BigNum, dq: BigNum, qi: BigNum) - -> Result { + -> Result { unsafe { - let rsa = RSA(try!(cvt_p(ffi::RSA_new()))); + let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); try!(cvt(compat::set_key(rsa.0, n.as_ptr(), e.as_ptr(), d.as_ptr()))); mem::forget((n, e, d)); try!(cvt(compat::set_factors(rsa.0, p.as_ptr(), q.as_ptr()))); @@ -75,16 +75,16 @@ impl RSA { } } - pub unsafe fn from_ptr(rsa: *mut ffi::RSA) -> RSA { - RSA(rsa) + pub unsafe fn from_ptr(rsa: *mut ffi::RSA) -> Rsa { + Rsa(rsa) } /// Generates a public/private key pair with the specified size. /// /// The public exponent will be 65537. - pub fn generate(bits: u32) -> Result { + pub fn generate(bits: u32) -> Result { unsafe { - let rsa = RSA(try!(cvt_p(ffi::RSA_new()))); + let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); let e = try!(BigNum::from_u32(ffi::RSA_F4 as u32)); try!(cvt(ffi::RSA_generate_key_ex(rsa.0, bits as c_int, e.as_ptr(), ptr::null_mut()))); Ok(rsa) @@ -92,19 +92,19 @@ impl RSA { } /// Reads an RSA private key from PEM formatted data. - pub fn private_key_from_pem(buf: &[u8]) -> Result { + pub fn private_key_from_pem(buf: &[u8]) -> Result { let mem_bio = try!(MemBioSlice::new(buf)); unsafe { let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), ptr::null_mut(), None, ptr::null_mut()))); - Ok(RSA(rsa)) + Ok(Rsa(rsa)) } } /// Reads an RSA private key from PEM formatted data and supplies a password callback. - pub fn private_key_from_pem_cb(buf: &[u8], pass_cb: F) -> Result + pub fn private_key_from_pem_cb(buf: &[u8], pass_cb: F) -> Result where F: FnOnce(&mut [c_char]) -> usize { let mut cb = CallbackState::new(pass_cb); @@ -116,19 +116,19 @@ impl RSA { ptr::null_mut(), Some(invoke_passwd_cb::), cb_ptr))); - Ok(RSA(rsa)) + Ok(Rsa(rsa)) } } /// Reads an RSA public key from PEM formatted data. - pub fn public_key_from_pem(buf: &[u8]) -> Result { + pub fn public_key_from_pem(buf: &[u8]) -> Result { let mem_bio = try!(MemBioSlice::new(buf)); unsafe { let rsa = try!(cvt_p(ffi::PEM_read_bio_RSA_PUBKEY(mem_bio.as_ptr(), ptr::null_mut(), None, ptr::null_mut()))); - Ok(RSA(rsa)) + Ok(Rsa(rsa)) } } @@ -323,7 +323,7 @@ impl RSA { } } -impl fmt::Debug for RSA { +impl fmt::Debug for Rsa { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "RSA") } @@ -422,7 +422,7 @@ mod test { pub fn test_password() { let mut password_queried = false; let key = include_bytes!("../test/rsa-encrypted.pem"); - RSA::private_key_from_pem_cb(key, |password| { + Rsa::private_key_from_pem_cb(key, |password| { password_queried = true; password[0] = b'm' as c_char; password[1] = b'y' as c_char; @@ -439,7 +439,7 @@ mod test { #[test] pub fn test_public_encrypt_private_decrypt_with_padding() { let key = include_bytes!("../test/rsa.pem.pub"); - let public_key = RSA::public_key_from_pem(key).unwrap(); + let public_key = Rsa::public_key_from_pem(key).unwrap(); let mut result = vec![0; public_key.size()]; let original_data = b"This is test"; @@ -447,7 +447,7 @@ mod test { assert_eq!(len, 256); let pkey = include_bytes!("../test/rsa.pem"); - let private_key = RSA::private_key_from_pem(pkey).unwrap(); + let private_key = Rsa::private_key_from_pem(pkey).unwrap(); let mut dec_result = vec![0; private_key.size()]; let len = private_key.private_decrypt(&result, &mut dec_result, Padding::pkcs1()).unwrap(); @@ -456,9 +456,9 @@ mod test { #[test] fn test_private_encrypt() { - let k0 = super::RSA::generate(512).unwrap(); + let k0 = super::Rsa::generate(512).unwrap(); let k0pkey = k0.public_key_to_pem().unwrap(); - let k1 = super::RSA::public_key_from_pem(&k0pkey).unwrap(); + let k1 = super::Rsa::public_key_from_pem(&k0pkey).unwrap(); let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; @@ -471,9 +471,9 @@ mod test { #[test] fn test_public_encrypt() { - let k0 = super::RSA::generate(512).unwrap(); + let k0 = super::Rsa::generate(512).unwrap(); let k0pkey = k0.private_key_to_pem().unwrap(); - let k1 = super::RSA::private_key_from_pem(&k0pkey).unwrap(); + let k1 = super::Rsa::private_key_from_pem(&k0pkey).unwrap(); let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; -- cgit v1.2.3 From 8604668a1831551359c7b9512efb151002acaf48 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Thu, 27 Oct 2016 19:56:52 -0700 Subject: Make padding types consts --- openssl/src/rsa.rs | 28 +++++++++------------------- 1 file changed, 9 insertions(+), 19 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index 550ce6e4..e63e567d 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -14,19 +14,9 @@ use util::{CallbackState, invoke_passwd_cb}; #[derive(Copy, Clone)] pub struct Padding(c_int); -impl Padding { - pub fn none() -> Padding { - Padding(ffi::RSA_NO_PADDING) - } - - pub fn pkcs1() -> Padding { - Padding(ffi::RSA_PKCS1_PADDING) - } - - pub fn pkcs1_oaep() -> Padding { - Padding(ffi::RSA_PKCS1_OAEP_PADDING) - } -} +pub const NO_PADDING: Padding = Padding(ffi::RSA_NO_PADDING); +pub const PKCS1_PADDING: Padding = Padding(ffi::RSA_PKCS1_PADDING); +pub const PKCS1_OAEP_PADDING: Padding = Padding(ffi::RSA_PKCS1_OAEP_PADDING); pub struct Rsa(*mut ffi::RSA); @@ -443,13 +433,13 @@ mod test { let mut result = vec![0; public_key.size()]; let original_data = b"This is test"; - let len = public_key.public_encrypt(original_data, &mut result, Padding::pkcs1()).unwrap(); + let len = public_key.public_encrypt(original_data, &mut result, PKCS1_PADDING).unwrap(); assert_eq!(len, 256); let pkey = include_bytes!("../test/rsa.pem"); let private_key = Rsa::private_key_from_pem(pkey).unwrap(); let mut dec_result = vec![0; private_key.size()]; - let len = private_key.private_decrypt(&result, &mut dec_result, Padding::pkcs1()).unwrap(); + let len = private_key.private_decrypt(&result, &mut dec_result, PKCS1_PADDING).unwrap(); assert_eq!(&dec_result[..len], original_data); } @@ -463,9 +453,9 @@ mod test { let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; let mut emesg = vec![0; k0.size()]; - k0.private_encrypt(&msg, &mut emesg, Padding::pkcs1()).unwrap(); + k0.private_encrypt(&msg, &mut emesg, PKCS1_PADDING).unwrap(); let mut dmesg = vec![0; k1.size()]; - let len = k1.public_decrypt(&emesg, &mut dmesg, Padding::pkcs1()).unwrap(); + let len = k1.public_decrypt(&emesg, &mut dmesg, PKCS1_PADDING).unwrap(); assert_eq!(msg, &dmesg[..len]); } @@ -478,9 +468,9 @@ mod test { let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; let mut emesg = vec![0; k0.size()]; - k0.public_encrypt(&msg, &mut emesg, Padding::pkcs1()).unwrap(); + k0.public_encrypt(&msg, &mut emesg, PKCS1_PADDING).unwrap(); let mut dmesg = vec![0; k1.size()]; - let len = k1.private_decrypt(&emesg, &mut dmesg, Padding::pkcs1()).unwrap(); + let len = k1.private_decrypt(&emesg, &mut dmesg, PKCS1_PADDING).unwrap(); assert_eq!(msg, &dmesg[..len]); } -- cgit v1.2.3 From f75f82e466993848393c7a26ccb51dc31b4547fe Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sun, 30 Oct 2016 16:37:45 -0700 Subject: Rustfmt --- openssl/src/rsa.rs | 83 +++++++++++++++++++++++++----------------------------- 1 file changed, 38 insertions(+), 45 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index e63e567d..666b99dd 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -178,7 +178,7 @@ impl Rsa { to.as_mut_ptr(), self.0, padding.0))); - Ok(len as usize) + Ok(len as usize) } } @@ -203,7 +203,7 @@ impl Rsa { to.as_mut_ptr(), self.0, padding.0))); - Ok(len as usize) + Ok(len as usize) } } @@ -338,23 +338,19 @@ mod compat { [p, q] } - pub unsafe fn set_key(r: *mut RSA, - n: *mut BIGNUM, - e: *mut BIGNUM, - d: *mut BIGNUM) -> c_int { + pub unsafe fn set_key(r: *mut RSA, n: *mut BIGNUM, e: *mut BIGNUM, d: *mut BIGNUM) -> c_int { ffi::RSA_set0_key(r, n, e, d) } - pub unsafe fn set_factors(r: *mut RSA, - p: *mut BIGNUM, - q: *mut BIGNUM) -> c_int { + pub unsafe fn set_factors(r: *mut RSA, p: *mut BIGNUM, q: *mut BIGNUM) -> c_int { ffi::RSA_set0_factors(r, p, q) } pub unsafe fn set_crt_params(r: *mut RSA, dmp1: *mut BIGNUM, dmq1: *mut BIGNUM, - iqmp: *mut BIGNUM) -> c_int { + iqmp: *mut BIGNUM) + -> c_int { ffi::RSA_set0_crt_params(r, dmp1, dmq1, iqmp) } } @@ -372,19 +368,14 @@ mod compat { [(*r).p, (*r).q] } - pub unsafe fn set_key(r: *mut RSA, - n: *mut BIGNUM, - e: *mut BIGNUM, - d: *mut BIGNUM) -> c_int { + pub unsafe fn set_key(r: *mut RSA, n: *mut BIGNUM, e: *mut BIGNUM, d: *mut BIGNUM) -> c_int { (*r).n = n; (*r).e = e; (*r).d = d; 1 // TODO: is this right? should it be 0? what's success? } - pub unsafe fn set_factors(r: *mut RSA, - p: *mut BIGNUM, - q: *mut BIGNUM) -> c_int { + pub unsafe fn set_factors(r: *mut RSA, p: *mut BIGNUM, q: *mut BIGNUM) -> c_int { (*r).p = p; (*r).q = q; 1 // TODO: is this right? should it be 0? what's success? @@ -393,7 +384,8 @@ mod compat { pub unsafe fn set_crt_params(r: *mut RSA, dmp1: *mut BIGNUM, dmq1: *mut BIGNUM, - iqmp: *mut BIGNUM) -> c_int { + iqmp: *mut BIGNUM) + -> c_int { (*r).dmp1 = dmp1; (*r).dmq1 = dmq1; (*r).iqmp = iqmp; @@ -413,15 +405,16 @@ mod test { let mut password_queried = false; let key = include_bytes!("../test/rsa-encrypted.pem"); Rsa::private_key_from_pem_cb(key, |password| { - password_queried = true; - password[0] = b'm' as c_char; - password[1] = b'y' as c_char; - password[2] = b'p' as c_char; - password[3] = b'a' as c_char; - password[4] = b's' as c_char; - password[5] = b's' as c_char; - 6 - }).unwrap(); + password_queried = true; + password[0] = b'm' as c_char; + password[1] = b'y' as c_char; + password[2] = b'p' as c_char; + password[3] = b'a' as c_char; + password[4] = b's' as c_char; + password[5] = b's' as c_char; + 6 + }) + .unwrap(); assert!(password_queried); } @@ -441,11 +434,11 @@ mod test { let mut dec_result = vec![0; private_key.size()]; let len = private_key.private_decrypt(&result, &mut dec_result, PKCS1_PADDING).unwrap(); - assert_eq!(&dec_result[..len], original_data); + assert_eq!(&dec_result[..len], original_data); } #[test] - fn test_private_encrypt() { + fn test_private_encrypt() { let k0 = super::Rsa::generate(512).unwrap(); let k0pkey = k0.public_key_to_pem().unwrap(); let k1 = super::Rsa::public_key_from_pem(&k0pkey).unwrap(); @@ -457,21 +450,21 @@ mod test { let mut dmesg = vec![0; k1.size()]; let len = k1.public_decrypt(&emesg, &mut dmesg, PKCS1_PADDING).unwrap(); assert_eq!(msg, &dmesg[..len]); - } - - #[test] - fn test_public_encrypt() { - let k0 = super::Rsa::generate(512).unwrap(); - let k0pkey = k0.private_key_to_pem().unwrap(); - let k1 = super::Rsa::private_key_from_pem(&k0pkey).unwrap(); - - let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; - - let mut emesg = vec![0; k0.size()]; - k0.public_encrypt(&msg, &mut emesg, PKCS1_PADDING).unwrap(); - let mut dmesg = vec![0; k1.size()]; - let len = k1.private_decrypt(&emesg, &mut dmesg, PKCS1_PADDING).unwrap(); - assert_eq!(msg, &dmesg[..len]); - } + } + + #[test] + fn test_public_encrypt() { + let k0 = super::Rsa::generate(512).unwrap(); + let k0pkey = k0.private_key_to_pem().unwrap(); + let k1 = super::Rsa::private_key_from_pem(&k0pkey).unwrap(); + + let msg = vec![0xdeu8, 0xadu8, 0xd0u8, 0x0du8]; + + let mut emesg = vec![0; k0.size()]; + k0.public_encrypt(&msg, &mut emesg, PKCS1_PADDING).unwrap(); + let mut dmesg = vec![0; k1.size()]; + let len = k1.private_decrypt(&emesg, &mut dmesg, PKCS1_PADDING).unwrap(); + assert_eq!(msg, &dmesg[..len]); + } } -- cgit v1.2.3 From 610403a562450099a3744a60c23678ffc3b0dd5f Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Sun, 30 Oct 2016 16:59:06 -0700 Subject: Add RsaRef --- openssl/src/rsa.rs | 250 ++++++++++++++++++++++++++++------------------------- 1 file changed, 134 insertions(+), 116 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index 666b99dd..c6c96223 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -2,6 +2,7 @@ use ffi; use std::fmt; use std::ptr; use std::mem; +use std::ops::Deref; use libc::{c_int, c_void, c_char}; use {cvt, cvt_p, cvt_n}; @@ -9,6 +10,7 @@ use bn::{BigNum, BigNumRef}; use bio::{MemBio, MemBioSlice}; use error::ErrorStack; use util::{CallbackState, invoke_passwd_cb}; +use opaque::Opaque; /// Type of encryption padding to use. #[derive(Copy, Clone)] @@ -18,108 +20,15 @@ pub const NO_PADDING: Padding = Padding(ffi::RSA_NO_PADDING); pub const PKCS1_PADDING: Padding = Padding(ffi::RSA_PKCS1_PADDING); pub const PKCS1_OAEP_PADDING: Padding = Padding(ffi::RSA_PKCS1_OAEP_PADDING); -pub struct Rsa(*mut ffi::RSA); - -impl Drop for Rsa { - fn drop(&mut self) { - unsafe { - ffi::RSA_free(self.0); - } - } -} - -impl Rsa { - /// only useful for associating the key material directly with the key, it's safer to use - /// the supplied load and save methods for DER formatted keys. - pub fn from_public_components(n: BigNum, e: BigNum) -> Result { - unsafe { - let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); - try!(cvt(compat::set_key(rsa.0, - n.as_ptr(), - e.as_ptr(), - ptr::null_mut()))); - mem::forget((n, e)); - Ok(rsa) - } - } - - pub fn from_private_components(n: BigNum, - e: BigNum, - d: BigNum, - p: BigNum, - q: BigNum, - dp: BigNum, - dq: BigNum, - qi: BigNum) - -> Result { - unsafe { - let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); - try!(cvt(compat::set_key(rsa.0, n.as_ptr(), e.as_ptr(), d.as_ptr()))); - mem::forget((n, e, d)); - try!(cvt(compat::set_factors(rsa.0, p.as_ptr(), q.as_ptr()))); - mem::forget((p, q)); - try!(cvt(compat::set_crt_params(rsa.0, dp.as_ptr(), dq.as_ptr(), - qi.as_ptr()))); - mem::forget((dp, dq, qi)); - Ok(rsa) - } - } - - pub unsafe fn from_ptr(rsa: *mut ffi::RSA) -> Rsa { - Rsa(rsa) - } - - /// Generates a public/private key pair with the specified size. - /// - /// The public exponent will be 65537. - pub fn generate(bits: u32) -> Result { - unsafe { - let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); - let e = try!(BigNum::from_u32(ffi::RSA_F4 as u32)); - try!(cvt(ffi::RSA_generate_key_ex(rsa.0, bits as c_int, e.as_ptr(), ptr::null_mut()))); - Ok(rsa) - } - } +pub struct RsaRef(Opaque); - /// Reads an RSA private key from PEM formatted data. - pub fn private_key_from_pem(buf: &[u8]) -> Result { - let mem_bio = try!(MemBioSlice::new(buf)); - unsafe { - let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), - ptr::null_mut(), - None, - ptr::null_mut()))); - Ok(Rsa(rsa)) - } +impl RsaRef { + pub unsafe fn from_ptr<'a>(ptr: *mut ffi::RSA) -> &'a RsaRef { + &*(ptr as *mut _) } - /// Reads an RSA private key from PEM formatted data and supplies a password callback. - pub fn private_key_from_pem_cb(buf: &[u8], pass_cb: F) -> Result - where F: FnOnce(&mut [c_char]) -> usize - { - let mut cb = CallbackState::new(pass_cb); - let mem_bio = try!(MemBioSlice::new(buf)); - - unsafe { - let cb_ptr = &mut cb as *mut _ as *mut c_void; - let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), - ptr::null_mut(), - Some(invoke_passwd_cb::), - cb_ptr))); - Ok(Rsa(rsa)) - } - } - - /// Reads an RSA public key from PEM formatted data. - pub fn public_key_from_pem(buf: &[u8]) -> Result { - let mem_bio = try!(MemBioSlice::new(buf)); - unsafe { - let rsa = try!(cvt_p(ffi::PEM_read_bio_RSA_PUBKEY(mem_bio.as_ptr(), - ptr::null_mut(), - None, - ptr::null_mut()))); - Ok(Rsa(rsa)) - } + pub fn as_ptr(&self) -> *mut ffi::RSA { + self as *const _ as *mut _ } /// Writes an RSA private key as unencrypted PEM formatted data @@ -128,7 +37,7 @@ impl Rsa { unsafe { try!(cvt(ffi::PEM_write_bio_RSAPrivateKey(mem_bio.as_ptr(), - self.0, + self.as_ptr(), ptr::null(), ptr::null_mut(), 0, @@ -143,7 +52,7 @@ impl Rsa { let mem_bio = try!(MemBio::new()); unsafe { - try!(cvt(ffi::PEM_write_bio_RSA_PUBKEY(mem_bio.as_ptr(), self.0))); + try!(cvt(ffi::PEM_write_bio_RSA_PUBKEY(mem_bio.as_ptr(), self.as_ptr()))); } Ok(mem_bio.get_buf().to_owned()) @@ -153,7 +62,7 @@ impl Rsa { unsafe { assert!(self.n().is_some()); - ffi::RSA_size(self.0) as usize + ffi::RSA_size(self.as_ptr()) as usize } } @@ -176,7 +85,7 @@ impl Rsa { let len = try!(cvt_n(ffi::RSA_private_decrypt(from.len() as c_int, from.as_ptr(), to.as_mut_ptr(), - self.0, + self.as_ptr(), padding.0))); Ok(len as usize) } @@ -201,7 +110,7 @@ impl Rsa { let len = try!(cvt_n(ffi::RSA_private_encrypt(from.len() as c_int, from.as_ptr(), to.as_mut_ptr(), - self.0, + self.as_ptr(), padding.0))); Ok(len as usize) } @@ -224,7 +133,7 @@ impl Rsa { let len = try!(cvt_n(ffi::RSA_public_decrypt(from.len() as c_int, from.as_ptr(), to.as_mut_ptr(), - self.0, + self.as_ptr(), padding.0))); Ok(len as usize) } @@ -247,19 +156,15 @@ impl Rsa { let len = try!(cvt_n(ffi::RSA_public_encrypt(from.len() as c_int, from.as_ptr(), to.as_mut_ptr(), - self.0, + self.as_ptr(), padding.0))); Ok(len as usize) } } - pub fn as_ptr(&self) -> *mut ffi::RSA { - self.0 - } - pub fn n(&self) -> Option<&BigNumRef> { unsafe { - let n = compat::key(self.0)[0]; + let n = compat::key(self.as_ptr())[0]; if n.is_null() { None } else { @@ -270,7 +175,7 @@ impl Rsa { pub fn d(&self) -> Option<&BigNumRef> { unsafe { - let d = compat::key(self.0)[2]; + let d = compat::key(self.as_ptr())[2]; if d.is_null() { None } else { @@ -281,7 +186,7 @@ impl Rsa { pub fn e(&self) -> Option<&BigNumRef> { unsafe { - let e = compat::key(self.0)[1]; + let e = compat::key(self.as_ptr())[1]; if e.is_null() { None } else { @@ -292,7 +197,7 @@ impl Rsa { pub fn p(&self) -> Option<&BigNumRef> { unsafe { - let p = compat::factors(self.0)[0]; + let p = compat::factors(self.as_ptr())[0]; if p.is_null() { None } else { @@ -303,7 +208,7 @@ impl Rsa { pub fn q(&self) -> Option<&BigNumRef> { unsafe { - let q = compat::factors(self.0)[1]; + let q = compat::factors(self.as_ptr())[1]; if q.is_null() { None } else { @@ -313,9 +218,122 @@ impl Rsa { } } +pub struct Rsa(*mut ffi::RSA); + +impl Drop for Rsa { + fn drop(&mut self) { + unsafe { + ffi::RSA_free(self.0); + } + } +} + +impl Rsa { + /// only useful for associating the key material directly with the key, it's safer to use + /// the supplied load and save methods for DER formatted keys. + pub fn from_public_components(n: BigNum, e: BigNum) -> Result { + unsafe { + let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); + try!(cvt(compat::set_key(rsa.0, + n.as_ptr(), + e.as_ptr(), + ptr::null_mut()))); + mem::forget((n, e)); + Ok(rsa) + } + } + + pub fn from_private_components(n: BigNum, + e: BigNum, + d: BigNum, + p: BigNum, + q: BigNum, + dp: BigNum, + dq: BigNum, + qi: BigNum) + -> Result { + unsafe { + let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); + try!(cvt(compat::set_key(rsa.0, n.as_ptr(), e.as_ptr(), d.as_ptr()))); + mem::forget((n, e, d)); + try!(cvt(compat::set_factors(rsa.0, p.as_ptr(), q.as_ptr()))); + mem::forget((p, q)); + try!(cvt(compat::set_crt_params(rsa.0, dp.as_ptr(), dq.as_ptr(), + qi.as_ptr()))); + mem::forget((dp, dq, qi)); + Ok(rsa) + } + } + + pub unsafe fn from_ptr(rsa: *mut ffi::RSA) -> Rsa { + Rsa(rsa) + } + + /// Generates a public/private key pair with the specified size. + /// + /// The public exponent will be 65537. + pub fn generate(bits: u32) -> Result { + unsafe { + let rsa = Rsa(try!(cvt_p(ffi::RSA_new()))); + let e = try!(BigNum::from_u32(ffi::RSA_F4 as u32)); + try!(cvt(ffi::RSA_generate_key_ex(rsa.0, bits as c_int, e.as_ptr(), ptr::null_mut()))); + Ok(rsa) + } + } + + /// Reads an RSA private key from PEM formatted data. + pub fn private_key_from_pem(buf: &[u8]) -> Result { + let mem_bio = try!(MemBioSlice::new(buf)); + unsafe { + let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), + ptr::null_mut(), + None, + ptr::null_mut()))); + Ok(Rsa(rsa)) + } + } + + /// Reads an RSA private key from PEM formatted data and supplies a password callback. + pub fn private_key_from_pem_cb(buf: &[u8], pass_cb: F) -> Result + where F: FnOnce(&mut [c_char]) -> usize + { + let mut cb = CallbackState::new(pass_cb); + let mem_bio = try!(MemBioSlice::new(buf)); + + unsafe { + let cb_ptr = &mut cb as *mut _ as *mut c_void; + let rsa = try!(cvt_p(ffi::PEM_read_bio_RSAPrivateKey(mem_bio.as_ptr(), + ptr::null_mut(), + Some(invoke_passwd_cb::), + cb_ptr))); + Ok(Rsa(rsa)) + } + } + + /// Reads an RSA public key from PEM formatted data. + pub fn public_key_from_pem(buf: &[u8]) -> Result { + let mem_bio = try!(MemBioSlice::new(buf)); + unsafe { + let rsa = try!(cvt_p(ffi::PEM_read_bio_RSA_PUBKEY(mem_bio.as_ptr(), + ptr::null_mut(), + None, + ptr::null_mut()))); + Ok(Rsa(rsa)) + } + } +} + impl fmt::Debug for Rsa { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "RSA") + write!(f, "Rsa") + } +} + +impl Deref for Rsa { + type Target = RsaRef; + + fn deref(&self) -> &RsaRef { + unsafe { RsaRef::from_ptr(self.0) } } } -- cgit v1.2.3 From 3363046c34ca3f968ce8b34e885d25aebac2b1f4 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 31 Oct 2016 19:45:52 -0700 Subject: Update bignum --- openssl/src/rsa.rs | 23 ++++++++++++----------- 1 file changed, 12 insertions(+), 11 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index c6c96223..a12dc4d1 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -6,10 +6,11 @@ use std::ops::Deref; use libc::{c_int, c_void, c_char}; use {cvt, cvt_p, cvt_n}; -use bn::{BigNum, BigNumRef}; +use bn::BigNum; use bio::{MemBio, MemBioSlice}; use error::ErrorStack; use util::{CallbackState, invoke_passwd_cb}; +use types::{OpenSslType, Ref}; use opaque::Opaque; /// Type of encryption padding to use. @@ -162,57 +163,57 @@ impl RsaRef { } } - pub fn n(&self) -> Option<&BigNumRef> { + pub fn n(&self) -> Option<&Ref> { unsafe { let n = compat::key(self.as_ptr())[0]; if n.is_null() { None } else { - Some(BigNumRef::from_ptr(n as *mut _)) + Some(Ref::::from_ptr(n as *mut _)) } } } - pub fn d(&self) -> Option<&BigNumRef> { + pub fn d(&self) -> Option<&Ref> { unsafe { let d = compat::key(self.as_ptr())[2]; if d.is_null() { None } else { - Some(BigNumRef::from_ptr(d as *mut _)) + Some(Ref::::from_ptr(d as *mut _)) } } } - pub fn e(&self) -> Option<&BigNumRef> { + pub fn e(&self) -> Option<&Ref> { unsafe { let e = compat::key(self.as_ptr())[1]; if e.is_null() { None } else { - Some(BigNumRef::from_ptr(e as *mut _)) + Some(Ref::::from_ptr(e as *mut _)) } } } - pub fn p(&self) -> Option<&BigNumRef> { + pub fn p(&self) -> Option<&Ref> { unsafe { let p = compat::factors(self.as_ptr())[0]; if p.is_null() { None } else { - Some(BigNumRef::from_ptr(p as *mut _)) + Some(Ref::::from_ptr(p as *mut _)) } } } - pub fn q(&self) -> Option<&BigNumRef> { + pub fn q(&self) -> Option<&Ref> { unsafe { let q = compat::factors(self.as_ptr())[1]; if q.is_null() { None } else { - Some(BigNumRef::from_ptr(q as *mut _)) + Some(Ref::::from_ptr(q as *mut _)) } } } -- cgit v1.2.3 From e9d78181c334bb0398f65b30f6165ec1b54fe623 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 31 Oct 2016 20:15:12 -0700 Subject: Update Rsa --- openssl/src/rsa.rs | 36 ++---------------------------------- 1 file changed, 2 insertions(+), 34 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index a12dc4d1..57a07bd1 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -2,7 +2,6 @@ use ffi; use std::fmt; use std::ptr; use std::mem; -use std::ops::Deref; use libc::{c_int, c_void, c_char}; use {cvt, cvt_p, cvt_n}; @@ -11,7 +10,6 @@ use bio::{MemBio, MemBioSlice}; use error::ErrorStack; use util::{CallbackState, invoke_passwd_cb}; use types::{OpenSslType, Ref}; -use opaque::Opaque; /// Type of encryption padding to use. #[derive(Copy, Clone)] @@ -21,17 +19,9 @@ pub const NO_PADDING: Padding = Padding(ffi::RSA_NO_PADDING); pub const PKCS1_PADDING: Padding = Padding(ffi::RSA_PKCS1_PADDING); pub const PKCS1_OAEP_PADDING: Padding = Padding(ffi::RSA_PKCS1_OAEP_PADDING); -pub struct RsaRef(Opaque); - -impl RsaRef { - pub unsafe fn from_ptr<'a>(ptr: *mut ffi::RSA) -> &'a RsaRef { - &*(ptr as *mut _) - } - - pub fn as_ptr(&self) -> *mut ffi::RSA { - self as *const _ as *mut _ - } +type_!(Rsa, ffi::RSA, ffi::RSA_free); +impl Ref { /// Writes an RSA private key as unencrypted PEM formatted data pub fn private_key_to_pem(&self) -> Result, ErrorStack> { let mem_bio = try!(MemBio::new()); @@ -219,16 +209,6 @@ impl RsaRef { } } -pub struct Rsa(*mut ffi::RSA); - -impl Drop for Rsa { - fn drop(&mut self) { - unsafe { - ffi::RSA_free(self.0); - } - } -} - impl Rsa { /// only useful for associating the key material directly with the key, it's safer to use /// the supplied load and save methods for DER formatted keys. @@ -266,10 +246,6 @@ impl Rsa { } } - pub unsafe fn from_ptr(rsa: *mut ffi::RSA) -> Rsa { - Rsa(rsa) - } - /// Generates a public/private key pair with the specified size. /// /// The public exponent will be 65537. @@ -330,14 +306,6 @@ impl fmt::Debug for Rsa { } } -impl Deref for Rsa { - type Target = RsaRef; - - fn deref(&self) -> &RsaRef { - unsafe { RsaRef::from_ptr(self.0) } - } -} - #[cfg(ossl110)] mod compat { use std::ptr; -- cgit v1.2.3 From 01ae978db0dc8620b2cc754c0d5cf94a68c1f549 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Fri, 4 Nov 2016 16:32:20 -0700 Subject: Get rid of Ref There's unfortunately a rustdoc bug that causes all methods implemented for any Ref to be inlined in the deref methods section :( --- openssl/src/rsa.rs | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) (limited to 'openssl/src/rsa.rs') diff --git a/openssl/src/rsa.rs b/openssl/src/rsa.rs index 57a07bd1..bd1d16d3 100644 --- a/openssl/src/rsa.rs +++ b/openssl/src/rsa.rs @@ -5,11 +5,11 @@ use std::mem; use libc::{c_int, c_void, c_char}; use {cvt, cvt_p, cvt_n}; -use bn::BigNum; +use bn::{BigNum, BigNumRef}; use bio::{MemBio, MemBioSlice}; use error::ErrorStack; use util::{CallbackState, invoke_passwd_cb}; -use types::{OpenSslType, Ref}; +use types::OpenSslTypeRef; /// Type of encryption padding to use. #[derive(Copy, Clone)] @@ -19,9 +19,9 @@ pub const NO_PADDING: Padding = Padding(ffi::RSA_NO_PADDING); pub const PKCS1_PADDING: Padding = Padding(ffi::RSA_PKCS1_PADDING); pub const PKCS1_OAEP_PADDING: Padding = Padding(ffi::RSA_PKCS1_OAEP_PADDING); -type_!(Rsa, ffi::RSA, ffi::RSA_free); +type_!(Rsa, RsaRef, ffi::RSA, ffi::RSA_free); -impl Ref { +impl RsaRef { /// Writes an RSA private key as unencrypted PEM formatted data pub fn private_key_to_pem(&self) -> Result, ErrorStack> { let mem_bio = try!(MemBio::new()); @@ -153,57 +153,57 @@ impl Ref { } } - pub fn n(&self) -> Option<&Ref> { + pub fn n(&self) -> Option<&BigNumRef> { unsafe { let n = compat::key(self.as_ptr())[0]; if n.is_null() { None } else { - Some(Ref::::from_ptr(n as *mut _)) + Some(BigNumRef::from_ptr(n as *mut _)) } } } - pub fn d(&self) -> Option<&Ref> { + pub fn d(&self) -> Option<&BigNumRef> { unsafe { let d = compat::key(self.as_ptr())[2]; if d.is_null() { None } else { - Some(Ref::::from_ptr(d as *mut _)) + Some(BigNumRef::from_ptr(d as *mut _)) } } } - pub fn e(&self) -> Option<&Ref> { + pub fn e(&self) -> Option<&BigNumRef> { unsafe { let e = compat::key(self.as_ptr())[1]; if e.is_null() { None } else { - Some(Ref::::from_ptr(e as *mut _)) + Some(BigNumRef::from_ptr(e as *mut _)) } } } - pub fn p(&self) -> Option<&Ref> { + pub fn p(&self) -> Option<&BigNumRef> { unsafe { let p = compat::factors(self.as_ptr())[0]; if p.is_null() { None } else { - Some(Ref::::from_ptr(p as *mut _)) + Some(BigNumRef::from_ptr(p as *mut _)) } } } - pub fn q(&self) -> Option<&Ref> { + pub fn q(&self) -> Option<&BigNumRef> { unsafe { let q = compat::factors(self.as_ptr())[1]; if q.is_null() { None } else { - Some(Ref::::from_ptr(q as *mut _)) + Some(BigNumRef::from_ptr(q as *mut _)) } } } -- cgit v1.2.3