From 3363046c34ca3f968ce8b34e885d25aebac2b1f4 Mon Sep 17 00:00:00 2001 From: Steven Fackler Date: Mon, 31 Oct 2016 19:45:52 -0700 Subject: [PATCH] Update bignum --- openssl/src/bn.rs | 231 ++++++++++++++++++--------------------------- openssl/src/dsa.rs | 19 ++-- openssl/src/rsa.rs | 23 ++--- 3 files changed, 114 insertions(+), 159 deletions(-) diff --git a/openssl/src/bn.rs b/openssl/src/bn.rs index ab5f7769..7542b25a 100644 --- a/openssl/src/bn.rs +++ b/openssl/src/bn.rs @@ -3,12 +3,12 @@ use libc::c_int; use std::cmp::Ordering; use std::ffi::CString; use std::{fmt, ptr}; -use std::ops::{Add, Div, Mul, Neg, Rem, Shl, Shr, Sub, Deref, DerefMut}; +use std::ops::{Add, Div, Mul, Neg, Rem, Shl, Shr, Sub, Deref}; use {cvt, cvt_p, cvt_n}; use crypto::CryptoString; use error::ErrorStack; -use opaque::Opaque; +use types::{Ref, OpenSslType}; /// Specifies the desired properties of a randomly generated `BigNum`. #[derive(Copy, Clone)] @@ -33,19 +33,19 @@ impl BnCtx { /// Places the result of `a * b` in `r`. pub fn mul(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - b: &BigNumRef) + r: &mut Ref, + a: &Ref, + b: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_mul(r.as_ptr(), a.as_ptr(), b.as_ptr(), self.as_ptr())).map(|_| ()) } } /// Places the result of `a / b` in `dv` and `a mod b` in `rem`. pub fn div(&mut self, - dv: Option<&mut BigNumRef>, - rem: Option<&mut BigNumRef>, - a: &BigNumRef, - b: &BigNumRef) + dv: Option<&mut Ref>, + rem: Option<&mut Ref>, + a: &Ref, + b: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_div(dv.map(|b| b.as_ptr()).unwrap_or(ptr::null_mut()), @@ -58,25 +58,25 @@ impl BnCtx { } /// Places the result of `a²` in `r`. - pub fn sqr(&mut self, r: &mut BigNumRef, a: &BigNumRef) -> Result<(), ErrorStack> { + pub fn sqr(&mut self, r: &mut Ref, a: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_sqr(r.as_ptr(), a.as_ptr(), self.as_ptr())).map(|_| ()) } } /// Places the result of `a mod m` in `r`. pub fn nnmod(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - m: &BigNumRef) + r: &mut Ref, + a: &Ref, + m: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_nnmod(r.as_ptr(), a.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) } } /// Places the result of `(a + b) mod m` in `r`. pub fn mod_add(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - b: &BigNumRef, - m: &BigNumRef) + r: &mut Ref, + a: &Ref, + b: &Ref, + m: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_mod_add(r.as_ptr(), a.as_ptr(), b.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) @@ -85,10 +85,10 @@ impl BnCtx { /// Places the result of `(a - b) mod m` in `r`. pub fn mod_sub(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - b: &BigNumRef, - m: &BigNumRef) + r: &mut Ref, + a: &Ref, + b: &Ref, + m: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_mod_sub(r.as_ptr(), a.as_ptr(), b.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) @@ -97,10 +97,10 @@ impl BnCtx { /// Places the result of `(a * b) mod m` in `r`. pub fn mod_mul(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - b: &BigNumRef, - m: &BigNumRef) + r: &mut Ref, + a: &Ref, + b: &Ref, + m: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_mod_mul(r.as_ptr(), a.as_ptr(), b.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) @@ -109,28 +109,28 @@ impl BnCtx { /// Places the result of `a² mod m` in `r`. pub fn mod_sqr(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - m: &BigNumRef) + r: &mut Ref, + a: &Ref, + m: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_mod_sqr(r.as_ptr(), a.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) } } /// Places the result of `a^p` in `r`. pub fn exp(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - p: &BigNumRef) + r: &mut Ref, + a: &Ref, + p: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_exp(r.as_ptr(), a.as_ptr(), p.as_ptr(), self.0)).map(|_| ()) } } /// Places the result of `a^p mod m` in `r`. pub fn mod_exp(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - p: &BigNumRef, - m: &BigNumRef) + r: &mut Ref, + a: &Ref, + p: &Ref, + m: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_mod_exp(r.as_ptr(), a.as_ptr(), p.as_ptr(), m.as_ptr(), self.0)).map(|_| ()) @@ -139,9 +139,9 @@ impl BnCtx { /// Places the inverse of `a` modulo `n` in `r`. pub fn mod_inverse(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - n: &BigNumRef) + r: &mut Ref, + a: &Ref, + n: &Ref) -> Result<(), ErrorStack> { unsafe { cvt_p(ffi::BN_mod_inverse(r.as_ptr(), a.as_ptr(), n.as_ptr(), self.as_ptr())) @@ -151,9 +151,9 @@ impl BnCtx { /// Places the greatest common denominator of `a` and `b` in `r`. pub fn gcd(&mut self, - r: &mut BigNumRef, - a: &BigNumRef, - b: &BigNumRef) + r: &mut Ref, + a: &Ref, + b: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_gcd(r.as_ptr(), a.as_ptr(), b.as_ptr(), self.as_ptr())).map(|_| ()) } } @@ -163,7 +163,7 @@ impl BnCtx { /// Performs a Miller-Rabin probabilistic primality test with `checks` iterations. /// /// Returns `true` if `p` is prime with an error probability of less than `0.25 ^ checks`. - pub fn is_prime(&mut self, p: &BigNumRef, checks: i32) -> Result { + pub fn is_prime(&mut self, p: &Ref, checks: i32) -> Result { unsafe { cvt_n(ffi::BN_is_prime_ex(p.as_ptr(), checks.into(), self.as_ptr(), ptr::null_mut())) .map(|r| r != 0) @@ -180,7 +180,7 @@ impl BnCtx { /// /// Returns `true` if `p` is prime with an error probability of less than `0.25 ^ checks`. pub fn is_prime_fasttest(&mut self, - p: &BigNumRef, + p: &Ref, checks: i32, do_trial_division: bool) -> Result { @@ -201,7 +201,7 @@ impl BnCtx { /// * `bits`: Length of the number in bits. /// * `prop`: The desired properties of the number. /// * `odd`: If `true`, the generated number will be odd. - pub fn rand(r: &mut BigNumRef, + pub fn rand(r: &mut Ref, bits: i32, prop: RNGProperty, odd: bool) @@ -212,7 +212,7 @@ impl BnCtx { } /// The cryptographically weak counterpart to `checked_new_random`. - pub fn pseudo_rand(r: &mut BigNumRef, + pub fn pseudo_rand(r: &mut Ref, bits: i32, prop: RNGProperty, odd: bool) @@ -224,22 +224,7 @@ impl BnCtx { } } -/// A borrowed, signed, arbitrary-precision integer. -pub struct BigNumRef(Opaque); - -impl BigNumRef { - pub unsafe fn from_ptr<'a>(handle: *mut ffi::BIGNUM) -> &'a BigNumRef { - &*(handle as *mut _) - } - - pub unsafe fn from_ptr_mut<'a>(handle: *mut ffi::BIGNUM) -> &'a mut BigNumRef { - &mut *(handle as *mut _) - } - - pub fn as_ptr(&self) -> *mut ffi::BIGNUM { - self as *const _ as *mut _ - } - +impl Ref { /// Adds a `u32` to `self`. pub fn add_word(&mut self, w: u32) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_add_word(self.as_ptr(), w as ffi::BN_ULONG)).map(|_| ()) } @@ -281,12 +266,12 @@ impl BigNumRef { /// Places a cryptographically-secure pseudo-random number nonnegative /// number less than `self` in `rnd`. - pub fn rand_in_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack> { + pub fn rand_in_range(&self, rnd: &mut Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_rand_range(self.as_ptr(), rnd.as_ptr())).map(|_| ()) } } /// The cryptographically weak counterpart to `rand_in_range`. - pub fn pseudo_rand_in_range(&self, rnd: &mut BigNumRef) -> Result<(), ErrorStack> { + pub fn pseudo_rand_in_range(&self, rnd: &mut Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_pseudo_rand_range(self.as_ptr(), rnd.as_ptr())).map(|_| ()) } } @@ -317,32 +302,32 @@ impl BigNumRef { } /// Places `self << 1` in `r`. - pub fn lshift1(&self, r: &mut BigNumRef) -> Result<(), ErrorStack> { + pub fn lshift1(&self, r: &mut Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_lshift1(r.as_ptr(), self.as_ptr())).map(|_| ()) } } /// Places `self >> 1` in `r`. - pub fn rshift1(&self, r: &mut BigNumRef) -> Result<(), ErrorStack> { + pub fn rshift1(&self, r: &mut Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_rshift1(r.as_ptr(), self.as_ptr())).map(|_| ()) } } /// Places `self + b` in `r`. - pub fn add(&self, r: &mut BigNumRef, b: &BigNumRef) -> Result<(), ErrorStack> { + pub fn add(&self, r: &mut Ref, b: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_add(r.as_ptr(), self.as_ptr(), b.as_ptr())).map(|_| ()) } } /// Places `self - b` in `r`. - pub fn sub(&self, r: &mut BigNumRef, b: &BigNumRef) -> Result<(), ErrorStack> { + pub fn sub(&self, r: &mut Ref, b: &Ref) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_sub(r.as_ptr(), self.as_ptr(), b.as_ptr())).map(|_| ()) } } /// Places `self << n` in `r`. - pub fn lshift(&self, r: &mut BigNumRef, b: i32) -> Result<(), ErrorStack> { + pub fn lshift(&self, r: &mut Ref, b: i32) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_lshift(r.as_ptr(), self.as_ptr(), b.into())).map(|_| ()) } } /// Places `self >> n` in `r`. - pub fn rshift(&self, r: &mut BigNumRef, n: i32) -> Result<(), ErrorStack> { + pub fn rshift(&self, r: &mut Ref, n: i32) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_rshift(r.as_ptr(), self.as_ptr(), n.into())).map(|_| ()) } } @@ -365,7 +350,7 @@ impl BigNumRef { /// /// assert_eq!(s.ucmp(&o), Ordering::Equal); /// ``` - pub fn ucmp(&self, oth: &BigNumRef) -> Ordering { + pub fn ucmp(&self, oth: &Ref) -> Ordering { unsafe { ffi::BN_ucmp(self.as_ptr(), oth.as_ptr()).cmp(&0) } } @@ -446,13 +431,7 @@ impl BigNumRef { } } -/// An owned, signed, arbitrary-precision integer. -/// -/// `BigNum` provides wrappers around OpenSSL's checked arithmetic functions. -/// Additionally, it implements the standard operators (`std::ops`), which -/// perform unchecked arithmetic, unwrapping the returned `Result` of the -/// checked operations. -pub struct BigNum(*mut ffi::BIGNUM); +type_!(BigNum, ffi::BIGNUM, ffi::BN_clear_free); impl BigNum { /// Creates a new `BigNum` with the value 0. @@ -491,10 +470,6 @@ impl BigNum { } } - pub unsafe fn from_ptr(handle: *mut ffi::BIGNUM) -> BigNum { - BigNum(handle) - } - /// Creates a new `BigNum` from an unsigned, big-endian encoded number of arbitrary length. /// /// ``` @@ -519,11 +494,11 @@ impl BigNum { /// * `safe`: If true, returns a "safe" prime `p` so that `(p-1)/2` is also prime. /// * `add`/`rem`: If `add` is set to `Some(add)`, `p % add == rem` will hold, where `p` is the /// generated prime and `rem` is `1` if not specified (`None`). - pub fn generate_prime(r: &mut BigNumRef, + pub fn generate_prime(r: &mut Ref, bits: i32, safe: bool, - add: Option<&BigNumRef>, - rem: Option<&BigNumRef>) + add: Option<&Ref>, + rem: Option<&Ref>) -> Result<(), ErrorStack> { unsafe { cvt(ffi::BN_generate_prime_ex(r.as_ptr(), @@ -537,35 +512,13 @@ impl BigNum { } } -impl Drop for BigNum { - fn drop(&mut self) { - unsafe { - ffi::BN_clear_free(self.as_ptr()); - } - } -} - -impl Deref for BigNum { - type Target = BigNumRef; - - fn deref(&self) -> &BigNumRef { - unsafe { BigNumRef::from_ptr(self.0) } - } -} - -impl DerefMut for BigNum { - fn deref_mut(&mut self) -> &mut BigNumRef { - unsafe { BigNumRef::from_ptr_mut(self.0) } - } -} - -impl AsRef for BigNum { - fn as_ref(&self) -> &BigNumRef { +impl AsRef> for BigNum { + fn as_ref(&self) -> &Ref { self.deref() } } -impl fmt::Debug for BigNumRef { +impl fmt::Debug for Ref { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.to_dec_str() { Ok(s) => f.write_str(&s), @@ -583,7 +536,7 @@ impl fmt::Debug for BigNum { } } -impl fmt::Display for BigNumRef { +impl fmt::Display for Ref { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match self.to_dec_str() { Ok(s) => f.write_str(&s), @@ -601,19 +554,19 @@ impl fmt::Display for BigNum { } } -impl PartialEq for BigNumRef { - fn eq(&self, oth: &BigNumRef) -> bool { +impl PartialEq> for Ref { + fn eq(&self, oth: &Ref) -> bool { self.cmp(oth) == Ordering::Equal } } -impl PartialEq for BigNumRef { +impl PartialEq for Ref { fn eq(&self, oth: &BigNum) -> bool { self.eq(oth.deref()) } } -impl Eq for BigNumRef {} +impl Eq for Ref {} impl PartialEq for BigNum { fn eq(&self, oth: &BigNum) -> bool { @@ -621,28 +574,28 @@ impl PartialEq for BigNum { } } -impl PartialEq for BigNum { - fn eq(&self, oth: &BigNumRef) -> bool { +impl PartialEq> for BigNum { + fn eq(&self, oth: &Ref) -> bool { self.deref().eq(oth) } } impl Eq for BigNum {} -impl PartialOrd for BigNumRef { - fn partial_cmp(&self, oth: &BigNumRef) -> Option { +impl PartialOrd> for Ref { + fn partial_cmp(&self, oth: &Ref) -> Option { Some(self.cmp(oth)) } } -impl PartialOrd for BigNumRef { +impl PartialOrd for Ref { fn partial_cmp(&self, oth: &BigNum) -> Option { Some(self.cmp(oth.deref())) } } -impl Ord for BigNumRef { - fn cmp(&self, oth: &BigNumRef) -> Ordering { +impl Ord for Ref { + fn cmp(&self, oth: &Ref) -> Ordering { unsafe { ffi::BN_cmp(self.as_ptr(), oth.as_ptr()).cmp(&0) } } } @@ -653,8 +606,8 @@ impl PartialOrd for BigNum { } } -impl PartialOrd for BigNum { - fn partial_cmp(&self, oth: &BigNumRef) -> Option { +impl PartialOrd> for BigNum { + fn partial_cmp(&self, oth: &Ref) -> Option { self.deref().partial_cmp(oth) } } @@ -667,7 +620,7 @@ impl Ord for BigNum { macro_rules! delegate { ($t:ident, $m:ident) => { - impl<'a, 'b> $t<&'b BigNum> for &'a BigNumRef { + impl<'a, 'b> $t<&'b BigNum> for &'a Ref { type Output = BigNum; fn $m(self, oth: &BigNum) -> BigNum { @@ -675,10 +628,10 @@ macro_rules! delegate { } } - impl<'a, 'b> $t<&'b BigNumRef> for &'a BigNum { + impl<'a, 'b> $t<&'b Ref> for &'a BigNum { type Output = BigNum; - fn $m(self, oth: &BigNumRef) -> BigNum { + fn $m(self, oth: &Ref) -> BigNum { $t::$m(self.deref(), oth) } } @@ -693,10 +646,10 @@ macro_rules! delegate { } } -impl<'a, 'b> Add<&'b BigNumRef> for &'a BigNumRef { +impl<'a, 'b> Add<&'b Ref> for &'a Ref { type Output = BigNum; - fn add(self, oth: &BigNumRef) -> BigNum { + fn add(self, oth: &Ref) -> BigNum { let mut r = BigNum::new().unwrap(); self.add(&mut r, oth).unwrap(); r @@ -705,10 +658,10 @@ impl<'a, 'b> Add<&'b BigNumRef> for &'a BigNumRef { delegate!(Add, add); -impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNumRef { +impl<'a, 'b> Sub<&'b Ref> for &'a Ref { type Output = BigNum; - fn sub(self, oth: &BigNumRef) -> BigNum { + fn sub(self, oth: &Ref) -> BigNum { let mut r = BigNum::new().unwrap(); self.sub(&mut r, oth).unwrap(); r @@ -717,10 +670,10 @@ impl<'a, 'b> Sub<&'b BigNumRef> for &'a BigNumRef { delegate!(Sub, sub); -impl<'a, 'b> Mul<&'b BigNumRef> for &'a BigNumRef { +impl<'a, 'b> Mul<&'b Ref> for &'a Ref { type Output = BigNum; - fn mul(self, oth: &BigNumRef) -> BigNum { + fn mul(self, oth: &Ref) -> BigNum { let mut ctx = BnCtx::new().unwrap(); let mut r = BigNum::new().unwrap(); ctx.mul(&mut r, self, oth).unwrap(); @@ -730,10 +683,10 @@ impl<'a, 'b> Mul<&'b BigNumRef> for &'a BigNumRef { delegate!(Mul, mul); -impl<'a, 'b> Div<&'b BigNumRef> for &'a BigNumRef { +impl<'a, 'b> Div<&'b Ref> for &'a Ref { type Output = BigNum; - fn div(self, oth: &'b BigNumRef) -> BigNum { + fn div(self, oth: &'b Ref) -> BigNum { let mut ctx = BnCtx::new().unwrap(); let mut dv = BigNum::new().unwrap(); ctx.div(Some(&mut dv), None, self, oth).unwrap(); @@ -743,10 +696,10 @@ impl<'a, 'b> Div<&'b BigNumRef> for &'a BigNumRef { delegate!(Div, div); -impl<'a, 'b> Rem<&'b BigNumRef> for &'a BigNumRef { +impl<'a, 'b> Rem<&'b Ref> for &'a Ref { type Output = BigNum; - fn rem(self, oth: &'b BigNumRef) -> BigNum { + fn rem(self, oth: &'b Ref) -> BigNum { let mut ctx = BnCtx::new().unwrap(); let mut rem = BigNum::new().unwrap(); ctx.div(None, Some(&mut rem), self, oth).unwrap(); @@ -756,7 +709,7 @@ impl<'a, 'b> Rem<&'b BigNumRef> for &'a BigNumRef { delegate!(Rem, rem); -impl<'a> Shl for &'a BigNumRef { +impl<'a> Shl for &'a Ref { type Output = BigNum; fn shl(self, n: i32) -> BigNum { @@ -774,7 +727,7 @@ impl<'a> Shl for &'a BigNum { } } -impl<'a> Shr for &'a BigNumRef { +impl<'a> Shr for &'a Ref { type Output = BigNum; fn shr(self, n: i32) -> BigNum { @@ -792,7 +745,7 @@ impl<'a> Shr for &'a BigNum { } } -impl<'a> Neg for &'a BigNumRef { +impl<'a> Neg for &'a Ref { type Output = BigNum; fn neg(self) -> BigNum { diff --git a/openssl/src/dsa.rs b/openssl/src/dsa.rs index e92b8ca3..c98d9c35 100644 --- a/openssl/src/dsa.rs +++ b/openssl/src/dsa.rs @@ -5,11 +5,12 @@ use std::fmt; use std::ops::Deref; use std::ptr; -use {cvt, cvt_p}; -use bn::BigNumRef; use bio::{MemBio, MemBioSlice}; -use util::{CallbackState, invoke_passwd_cb}; +use bn::BigNum; +use {cvt, cvt_p}; use opaque::Opaque; +use types::Ref; +use util::{CallbackState, invoke_passwd_cb}; pub struct DsaRef(Opaque); @@ -53,35 +54,35 @@ impl DsaRef { } } - pub fn p(&self) -> Option<&BigNumRef> { + pub fn p(&self) -> Option<&Ref> { unsafe { let p = compat::pqg(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::pqg(self.as_ptr())[1]; if q.is_null() { None } else { - Some(BigNumRef::from_ptr(q as *mut _)) + Some(Ref::::from_ptr(q as *mut _)) } } } - pub fn g(&self) -> Option<&BigNumRef> { + pub fn g(&self) -> Option<&Ref> { unsafe { let g = compat::pqg(self.as_ptr())[2]; if g.is_null() { None } else { - Some(BigNumRef::from_ptr(g as *mut _)) + Some(Ref::::from_ptr(g as *mut _)) } } } 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 _)) } } }