pkey_ctx: add ability to crate a PKey from params

Author: huwcbjones

openssl/src/pkey_ctx.rs

@@ -70,19 +70,22 @@ use crate::error::ErrorStack;
 use crate::md::MdRef;
 use crate::nid::Nid;
 #[cfg(ossl300)]
+use crate::params::ParamsRef;
+#[cfg(ossl300)]
 use crate::pkey::Public;
 use crate::pkey::{HasPrivate, HasPublic, Id, PKey, PKeyRef, Params, Private};
 use crate::rsa::Padding;
 use crate::sign::RsaPssSaltlen;
 use crate::{cvt, cvt_p};
+use cfg_if::cfg_if;
 use foreign_types::{ForeignType, ForeignTypeRef};
 #[cfg(not(any(boringssl, awslc)))]
 use libc::c_int;
 #[cfg(ossl320)]
 use libc::c_uint;
 use openssl_macros::corresponds;
 use std::convert::TryFrom;
-#[cfg(ossl320)]
+#[cfg(ossl300)]
 use std::ffi::CStr;
 use std::ptr;
 
@@ -455,6 +458,31 @@ impl<T> PkeyCtxRef<T> {
         Ok(())
     }
 
+    /// Prepares the context for creating a key from user data.
+    #[corresponds(EVP_PKEY_fromdata_init)]
+    #[inline]
+    #[cfg(ossl300)]
+    #[allow(dead_code)]
+    pub(crate) fn fromdata_init(&mut self) -> Result<(), ErrorStack> {
+        cvt(unsafe { ffi::EVP_PKEY_fromdata_init(self.as_ptr()) }).map(|_| ())
+    }
+
+    /// Convert a stack of Params into a PKey.
+    #[corresponds(EVP_PKEY_fromdata)]
+    #[inline]
+    #[cfg(ossl300)]
+    #[allow(dead_code)]
+    pub(crate) fn fromdata<K: Selection>(
+        &mut self,
+        params: &ParamsRef<'_>,
+    ) -> Result<PKey<K>, ErrorStack> {
+        let mut key_ptr = ptr::null_mut();
+        cvt(unsafe {
+            ffi::EVP_PKEY_fromdata(self.as_ptr(), &mut key_ptr, K::SELECTION, params.as_ptr())
+        })?;
+        Ok(unsafe { PKey::from_ptr(key_ptr) })
+    }
+
     /// Sets which algorithm was used to compute the digest used in a
     /// signature. With RSA signatures this causes the signature to be wrapped
     /// in a `DigestInfo` structure. This is almost always what you want with
@@ -894,20 +922,38 @@ impl<T> PkeyCtxRef<T> {
     }
 }
 
+/// Creates a new `PKey` from the given ID and parameters.
+#[cfg(ossl300)]
+#[allow(dead_code)]
+pub(crate) fn pkey_from_params<K: Selection>(
+    id: Id,
+    params: &ParamsRef<'_>,
+) -> Result<PKey<K>, ErrorStack> {
+    let mut ctx = PkeyCtx::new_id(id)?;
+    ctx.fromdata_init()?;
+    ctx.fromdata(params)
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
+    #[cfg(ossl300)]
+    use crate::bn::BigNum;
     #[cfg(not(any(boringssl, awslc)))]
     use crate::cipher::Cipher;
     use crate::ec::{EcGroup, EcKey};
     use crate::hash::{hash, MessageDigest};
     use crate::md::Md;
     use crate::nid::Nid;
+    #[cfg(ossl300)]
+    use crate::params::ParamBuilder;
     use crate::pkey::PKey;
     use crate::rsa::Rsa;
     use crate::sign::Verifier;
     #[cfg(not(boringssl))]
     use cfg_if::cfg_if;
+    #[cfg(ossl300)]
+    use std::cmp::Ordering;
 
     #[test]
     fn rsa() {
@@ -1267,4 +1313,30 @@ mxJ7imIrEg9nIQ==
         assert_eq!(output, expected_output);
         assert!(ErrorStack::get().errors().is_empty());
     }
+
+    #[test]
+    #[cfg(ossl300)]
+    fn test_fromdata() {
+        let n = BigNum::from_u32(0xbc747fc5).unwrap();
+        let e = BigNum::from_u32(0x10001).unwrap();
+        let d = BigNum::from_u32(0x7b133399).unwrap();
+
+        let params = ParamBuilder::new()
+            .push_bignum(CStr::from_bytes_with_nul(b"n\0").unwrap(), &n)
+            .unwrap()
+            .push_bignum(CStr::from_bytes_with_nul(b"e\0").unwrap(), &e)
+            .unwrap()
+            .push_bignum(CStr::from_bytes_with_nul(b"d\0").unwrap(), &d)
+            .unwrap()
+            .build()
+            .unwrap();
+
+        let pkey: PKey<Private> = pkey_from_params(Id::RSA, &params).unwrap();
+
+        let rsa = pkey.rsa().unwrap();
+
+        assert_eq!(rsa.n().ucmp(&n), Ordering::Equal);
+        assert_eq!(rsa.e().ucmp(&e), Ordering::Equal);
+        assert_eq!(rsa.d().ucmp(&d), Ordering::Equal);
+    }
 }