Add test crate

Signed-off-by: Gowtham Suresh Kumar <gowtham.sureshkumar@arm.com>

Author: gowthamsk-arm

Cargo.toml

@@ -4,4 +4,5 @@ members = [
     "parsec-openssl2",
     "parsec-openssl-provider",
     "parsec-openssl-provider-shared",
+    "parsec-openssl-provider-shared-test",
 ]

parsec-openssl-provider-shared-test/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "parsec-openssl-provider-shared-test"
+version = "0.1.0"
+authors = ["Parsec Project Contributors"]
+description = "A parsec openssl provider dynamic library"
+license = "Apache-2.0"
+readme = "README.md"
+keywords = ["security", "service"]
+categories = ["cryptography", "hardware-support"]
+edition = "2021"
+
+[dependencies]
+openssl = "0.10.63"
+parsec-openssl2 = { path = "../parsec-openssl2" }
+foreign-types = "0.3"
+foreign-types-shared = "0.1"
+
+[build-dependencies]
+pkg-config = "0.3.18"
+bindgen = { version = "0.66.1" }

parsec-openssl-provider-shared-test/build.rs

@@ -0,0 +1,38 @@
+// Copyright 2023 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use std::env;
+use std::io::{Error, ErrorKind};
+use std::path::PathBuf;
+
+const MINIMUM_VERSION: &str = "3.0.0";
+
+fn main() -> std::io::Result<()> {
+    // Use package config to ensure openssl version 3.0.0 or higher is installed
+    let openssl = pkg_config::Config::new()
+        .atleast_version(MINIMUM_VERSION)
+        .probe("openssl")
+        .expect("Failed to find openssl version above 3.0.0");
+
+    // The include path points to the openssl development headers installed by libss-dev
+    let openssl_include_path = openssl.include_paths[0]
+        .clone()
+        .into_os_string()
+        .into_string()
+        .expect("Error converting OsString to String.");
+
+    // Generate bindings for the required headers
+    let openssl_builder = bindgen::Builder::default()
+        .header(format!("{}/openssl/evp.h", openssl_include_path))
+        .generate_comments(false)
+        .size_t_is_usize(true);
+
+    // Build the bindings
+    let openssl_bindings = openssl_builder
+        .generate()
+        .map_err(|_| Error::new(ErrorKind::Other, "Unable to generate bindings to openssl"))?;
+
+    let out_path = PathBuf::from(env::var("OUT_DIR").unwrap());
+    openssl_bindings.write_to_file(out_path.join("openssl_test_bindings.rs"))?;
+
+    Ok(())
+}

parsec-openssl-provider-shared-test/src/lib.rs

@@ -0,0 +1,23 @@
+// Copyright 202 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+
+use openssl::error::ErrorStack;
+use openssl::{lib_ctx::LibCtx, provider::Provider};
+use parsec_openssl2::openssl_binding;
+use parsec_openssl2::types::VOID_PTR_PTR;
+
+#[allow(non_camel_case_types)]
+#[allow(non_upper_case_globals)]
+#[allow(non_snake_case)]
+#[allow(improper_ctypes)]
+#[ignore]
+pub mod openssl_test_bindings {
+
+    include!(concat!(env!("OUT_DIR"), "/openssl_test_bindings.rs"));
+}
+
+pub fn load_provider(lib_ctx: &LibCtx, provider_name: String, provider_path: String) -> Provider {
+    Provider::set_default_search_path(None, &provider_path);
+    let provider = Provider::load(Some(&lib_ctx), &provider_name).unwrap();
+    provider
+}

parsec-openssl-provider-shared-test/tests/provider.rs

@@ -0,0 +1,68 @@
+// Copyright 202 Contributors to the Parsec project.
+// SPDX-License-Identifier: Apache-2.0
+use openssl::{lib_ctx::LibCtx, provider::Provider};
+use openssl_test_bindings::*;
+use parsec_openssl_provider_shared_test::*;
+
+use foreign_types_shared::ForeignType;
+use parsec_openssl2::openssl_binding;
+use parsec_openssl2::ossl_param;
+
+// Simple test to load a provider. Test fails if load_provider function reports error
+#[test]
+fn test_loading_parsec_provider() {
+    let provider_path = String::from("/tmp/parsec/target/debug/");
+    //let provider_name = String::from("libparsec_openssl_provider_shared");
+    let provider_name = String::from("default");
+    let mut lib_ctx: LibCtx = LibCtx::new().unwrap();
+    let mut provider: Provider = load_provider(&lib_ctx, provider_name, provider_path);
+}
+
+pub const PARSEC_PROVIDER_RSA: &[u8; 4] = b"RSA\0";
+pub const PARSEC_PROVIDER_PROPERTY: &[u8; 17] = b"provider=default\0";
+
+// Loads a keys from the provider and returns an EVP_PKEY object with the details
+// This is working against the default provider and currently loads a key with
+// no parameters. In order to test it with the parsec provider 3 changes are needed
+// explained in comments below.
+#[test]
+fn test_loading_keys() {
+    // Change 1: toggle comment below to load the parsec provider
+    let provider_path = String::from("/tmp/parsec/target/debug/");
+    //let provider_name = String::from("libparsec_openssl_provider_shared");
+
+    let provider_name = String::from("default");
+    unsafe {
+        let mut lib_ctx: LibCtx = LibCtx::new().unwrap();
+        let mut parsec_pkey: *mut EVP_PKEY = std::ptr::null_mut();
+        let mut parsec_pkey_ptr: *mut *mut EVP_PKEY = &mut parsec_pkey;
+        let mut provider: Provider = load_provider(&lib_ctx, provider_name, provider_path);
+
+        // Change 2: Setup the param as needed for the parsec provider.
+        // Create a key beforehand using the parsec-tool and then run the test.
+        let mut param = ossl_param!();
+        let mut param_ptr: *mut OSSL_PARAM = &mut param;
+
+        let mut evp_ctx: *mut EVP_PKEY_CTX = EVP_PKEY_CTX_new_from_name(
+            lib_ctx.as_ptr() as *mut ossl_lib_ctx_st,
+            PARSEC_PROVIDER_RSA.as_ptr() as *const ::std::os::raw::c_char,
+            PARSEC_PROVIDER_PROPERTY.as_ptr() as *const ::std::os::raw::c_char,
+        );
+        assert_ne!(evp_ctx, std::ptr::null_mut());
+        assert_eq!(EVP_PKEY_fromdata_init(evp_ctx), 1);
+        assert_eq!(
+            EVP_PKEY_fromdata(
+                evp_ctx,
+                parsec_pkey_ptr,
+                // Change 3: Select the appropriate macro here to load the param value
+                EVP_PKEY_KEY_PARAMETERS.try_into().unwrap(),
+                param_ptr,
+            ),
+            1
+        );
+
+        EVP_PKEY_CTX_free(evp_ctx);
+        evp_ctx = std::ptr::null_mut();
+        //OSSL_PARAM_free(param_ptr);
+    }
+}