pkey: add get bn & utf-8 param

Author: huwcbjones

openssl/src/pkey.rs

@@ -41,6 +41,8 @@
 //! ```
 #![allow(clippy::missing_safety_doc)]
 use crate::bio::{MemBio, MemBioSlice};
+#[cfg(ossl300)]
+use crate::bn::BigNumRef;
 #[cfg(ossl110)]
 use crate::cipher::CipherRef;
 use crate::dh::Dh;
@@ -51,10 +53,14 @@ use crate::error::ErrorStack;
 use crate::pkey_ctx::PkeyCtx;
 use crate::rsa::Rsa;
 use crate::symm::Cipher;
+#[cfg(ossl300)]
+use crate::util::ForeignTypeRefExt;
 use crate::util::{invoke_passwd_cb, CallbackState};
 use crate::{cvt, cvt_p};
 use cfg_if::cfg_if;
 use foreign_types::{ForeignType, ForeignTypeRef};
+#[cfg(ossl300)]
+use libc::c_char;
 use libc::{c_int, c_long};
 use openssl_macros::corresponds;
 use std::convert::{TryFrom, TryInto};
@@ -207,6 +213,43 @@ impl<T> PKeyRef<T> {
     pub fn size(&self) -> usize {
         unsafe { ffi::EVP_PKEY_size(self.as_ptr()) as usize }
     }
+
+    /// Returns the BigNum value associated with the given key name.
+    #[corresponds(EVP_PKEY_get_bn_param)]
+    #[cfg(ossl300)]
+    pub fn get_bn_param(&self, key: &str) -> Result<&BigNumRef, ErrorStack> {
+        let key = CString::new(key).unwrap();
+        let mut value = ptr::null_mut();
+        unsafe {
+            cvt(ffi::EVP_PKEY_get_bn_param(
+                self.as_ptr(),
+                key.as_ptr(),
+                &mut value,
+            ))?;
+            Ok(BigNumRef::from_const_ptr(value))
+        }
+    }
+
+    /// Returns the String value associated with the given key name.
+    #[corresponds(EVP_PKEY_get_utf8_string_param)]
+    #[cfg(ossl300)]
+    pub fn get_utf8_string_param(&self, key: &str) -> Result<String, ErrorStack> {
+        const VALUE_LEN: usize = 4096;
+        let key = CString::new(key).unwrap();
+        let mut value_buf: Vec<u8> = vec![0; VALUE_LEN];
+        let mut out_len: usize = 0;
+        unsafe {
+            cvt(ffi::EVP_PKEY_get_utf8_string_param(
+                self.as_ptr(),
+                key.as_ptr(),
+                value_buf.as_mut_ptr().cast::<c_char>(),
+                VALUE_LEN,
+                &mut out_len,
+            ))?;
+        }
+        value_buf.truncate(out_len);
+        Ok(String::from_utf8(value_buf).unwrap())
+    }
 }
 
 impl<T> PKeyRef<T>
@@ -916,11 +959,15 @@ impl<T> TryFrom<PKey<T>> for Dh<T> {
 
 #[cfg(test)]
 mod tests {
+    #[cfg(ossl300)]
+    use std::cmp::Ordering;
     use std::convert::TryInto;
 
     #[cfg(not(boringssl))]
     use crate::dh::Dh;
     use crate::dsa::Dsa;
+    #[cfg(ossl300)]
+    use crate::ec::EcGroup;
     use crate::ec::EcKey;
     use crate::error::Error;
     use crate::nid::Nid;
@@ -1219,4 +1266,32 @@ mod tests {
         assert!(!pkey1.public_eq(&pkey2));
         assert!(Error::get().is_none());
     }
+
+    #[cfg(ossl300)]
+    #[test]
+    fn test_get_bn_param() {
+        let rsa = Rsa::generate(2048).unwrap();
+        let pkey = PKey::from_rsa(rsa.clone()).unwrap();
+        assert_eq!(
+            pkey.get_bn_param("n").unwrap().ucmp(rsa.n()),
+            Ordering::Equal
+        );
+        assert_eq!(
+            pkey.get_bn_param("d").unwrap().ucmp(rsa.d()),
+            Ordering::Equal
+        );
+    }
+
+    #[cfg(ossl300)]
+    #[test]
+    fn test_get_utf8_string_param() {
+        let group = EcGroup::from_curve_name(Nid::X9_62_PRIME256V1).unwrap();
+        let ec = EcKey::generate(&group).unwrap();
+        let pkey = PKey::from_ec_key(ec.clone()).unwrap();
+
+        assert_eq!(
+            pkey.get_utf8_string_param("group").unwrap(),
+            String::from("prime256v1")
+        );
+    }
 }