slh_dsa

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cas_core_lib"
-version = "0.2.3"
+version = "0.2.4"
 edition = "2021"
 description = "This is a Rust library providing external facing functions to performant and trusted encryption in Rust"
 license = "Apache-2.0"
@@ -14,5 +14,5 @@ crate-type = ["dylib"]
 
 [dependencies]
 libc = "0.2.146"
-cas-lib = "0.2.63"
+cas-lib = "0.2.64"
 zeroizing-alloc = "0.1.0"

src/lib.rs

@@ -2,18 +2,22 @@ use zeroizing_alloc::ZeroAlloc;
 
 #[global_allocator]
 static ALLOC: ZeroAlloc<std::alloc::System> = ZeroAlloc(std::alloc::System);
-mod aes;
-mod blake2;
-mod digital_signature;
-mod ed25519;
-mod helpers;
-mod hmac;
-mod rsa;
-mod sha;
-mod x25519;
-mod ascon_aead;
-mod zstd;
-mod hpke;
+pub mod aes;
+pub mod blake2;
+pub mod digital_signature;
+pub mod ed25519;
+pub mod helpers;
+pub mod hmac;
+pub mod rsa;
+pub mod sha;
+pub mod x25519;
+pub mod ascon_aead;
+pub mod zstd;
+pub mod hpke;
+pub mod pqc {
+    pub mod slh_dsa;
+    pub mod types;
+}
 
 pub mod password_hashers {
     pub mod types;

src/pqc/slh_dsa.rs

@@ -0,0 +1,69 @@
+use cas_lib::pqc::slh_dsa::{generate_signing_and_verification_key, sign_message, verify_signature};
+use crate::pqc::types::{SlhDsaKeyPairResult, SlhDsaSignature};
+
+#[no_mangle]
+pub extern "C" fn slh_dsa_generate_signing_and_verification_key() -> SlhDsaKeyPairResult {
+    let key_pair: cas_lib::pqc::cas_pqc::SlhDsaKeyPair = generate_signing_and_verification_key();
+    let result = SlhDsaKeyPairResult {
+        signing_key_ptr: key_pair.signing_key.as_ptr(),
+        signing_key_length: key_pair.signing_key.len(),
+        verification_key_ptr: key_pair.verification_key.as_ptr(),
+        verification_key_length: key_pair.verification_key.len(),
+    };
+    std::mem::forget(key_pair.signing_key);
+    std::mem::forget(key_pair.verification_key);
+    result
+}
+
+#[no_mangle]
+pub extern "C" fn slh_dsa_sign_message(
+    key_pair: *const u8,
+    key_pair_length: usize,
+    message: *const u8,
+    message_length: usize,
+) -> SlhDsaSignature {
+    let key_pair_slice = unsafe {
+        assert!(!key_pair.is_null());
+        std::slice::from_raw_parts(key_pair, key_pair_length)
+    }
+    .to_vec();
+    let message_slice = unsafe {
+        assert!(!message.is_null());
+        std::slice::from_raw_parts(message, message_length)
+    }
+    .to_vec();
+    let signature: Vec<u8> = sign_message(key_pair_slice, message_slice);
+    let result = SlhDsaSignature {
+        signature_ptr: signature.as_ptr(),
+        signature_length: signature.len(),
+    };
+    std::mem::forget(signature);
+    result
+}
+
+#[no_mangle]
+pub extern "C" fn slh_dsa_verify_signature(
+    public_key: *const u8,
+    public_key_length: usize,
+    signature: *const u8,
+    signature_length: usize,
+    message: *const u8,
+    message_length: usize,
+) -> bool {
+    let public_key_slice = unsafe {
+        assert!(!public_key.is_null());
+        std::slice::from_raw_parts(public_key, public_key_length)
+    }
+    .to_vec();
+    let signature_slice = unsafe {
+        assert!(!signature.is_null());
+        std::slice::from_raw_parts(signature, signature_length)
+    }
+    .to_vec();
+    let message_slice = unsafe {
+        assert!(!message.is_null());
+        std::slice::from_raw_parts(message, message_length)
+    }
+    .to_vec();
+    verify_signature(public_key_slice, signature_slice, message_slice)
+}

src/pqc/types.rs

@@ -0,0 +1,13 @@
+#[repr(C)]
+pub struct SlhDsaKeyPairResult {
+    pub signing_key_ptr: *const u8,
+    pub signing_key_length: usize,
+    pub verification_key_ptr: *const u8,
+    pub verification_key_length: usize,
+}
+
+#[repr(C)]
+pub struct SlhDsaSignature {
+    pub signature_ptr: *const u8,
+    pub signature_length: usize,
+}