signature: Add unit test for OSSL_FUNC_SIGNATURE_DUPCTX

Signed-off-by: Tomás González <tomasagustin.gonzalezorlando@arm.com>

Author: tgonzalezorlandoarm

parsec-openssl-provider/src/keymgmt/mod.rs

@@ -38,6 +38,13 @@ pub fn kmgmt_keyobj_new(provctx: Arc<ParsecProviderContext>) -> Arc<ParsecProvid
     })
 }
 
+#[cfg(test)]
+impl ParsecProviderKeyObject {
+    pub fn get_key_name(&self) -> std::sync::MutexGuard<'_, Option<String>> {
+        self.key_name.lock().unwrap()
+    }
+}
+
 /*
 should create a provider side key object. The provider context provctx is passed and may be incorporated
 in the key object, but that is not mandatory.

parsec-openssl-provider/src/signature/mod.rs

@@ -119,3 +119,57 @@ pub const PARSEC_PROVIDER_SIGNATURE: [OSSL_ALGORITHM; 3] = [
     ),
     ossl_algorithm!(),
 ];
+
+#[test]
+fn test_sign_dup() {
+    use crate::parsec_provider_provider_init;
+
+    let out: *const OSSL_DISPATCH = std::ptr::null();
+    let mut provctx: types::VOID_PTR = std::ptr::null_mut();
+
+    // Initialize the provider
+    let result: Result<(), parsec_openssl2::Error> = unsafe {
+        parsec_provider_provider_init(
+            std::ptr::null(),
+            std::ptr::null(),
+            &out as *const _ as *mut _,
+            &mut provctx as *mut VOID_PTR,
+        )
+    };
+    assert!(result.is_ok());
+    assert_ne!(provctx, std::ptr::null_mut());
+    let s = String::from("");
+
+    let sig_ctx = unsafe { parsec_provider_signature_newctx(provctx, s.as_ptr() as _) };
+    assert_ne!(sig_ctx, std::ptr::null_mut());
+
+    /*
+    Change the Signature Context.
+    The way we change it doesn't really matter.
+    All we care about is whether this change is preserved after duplication.
+    For this test, we are just changing the key_name of the Signature Context's Key Object.
+    */
+    let arc_sig_ctx = unsafe { Arc::from_raw(sig_ctx as *const ParsecProviderSignatureContext) };
+    *(arc_sig_ctx.keyobj.get_key_name()) = Some("PARSEC_TEST_KEYNAME".to_string());
+
+    // We change back to using pointers instead of Arcs so that we use the provider functions
+    let sig_ctx = Arc::into_raw(arc_sig_ctx) as VOID_PTR;
+
+    // Duplicate the context and verify if the change is preserved on the duplicated context.
+    let duplicated_ptr = unsafe { parsec_provider_signature_dupctx(sig_ctx) };
+    assert_ne!(duplicated_ptr, std::ptr::null_mut());
+
+    let arc_duplicated =
+        unsafe { Arc::from_raw(duplicated_ptr as *const ParsecProviderSignatureContext) };
+    assert_eq!(
+        *(arc_duplicated.clone().keyobj.clone().get_key_name()),
+        Some("PARSEC_TEST_KEYNAME".to_string())
+    );
+
+    // We change back to using pointers instead of Arcs to use the provider's free
+    let duplicated_ptr = Arc::into_raw(arc_duplicated) as VOID_PTR;
+    unsafe {
+        parsec_provider_signature_freectx(duplicated_ptr);
+        parsec_provider_signature_freectx(sig_ctx);
+    }
+}