diff --git a/Cargo.toml b/Cargo.toml
index a5e6dd9..5f7c271 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -14,4 +14,4 @@ crate-type = ["dylib"]
 
 [dependencies]
 libc = "0.2.146"
-cas-lib = "0.2.6"
\ No newline at end of file
+cas-lib = "0.2.45"
\ No newline at end of file
diff --git a/src/digital_signature.rs b/src/digital_signature.rs
index 29bf0ab..9de4105 100644
--- a/src/digital_signature.rs
+++ b/src/digital_signature.rs
@@ -18,9 +18,9 @@ pub struct SHARSADigitalSignatureResult {
 
 #[repr(C)]
 pub struct SHAED25519DalekDigitalSignatureResult {
-    pub public_key: *mut c_uchar,
+    pub public_key: *mut u8,
     pub public_key_length: usize,
-    pub signature_raw_ptr: *mut c_uchar,
+    pub signature_raw_ptr: *mut u8,
     pub signature_length: usize,
 }
 
@@ -65,10 +65,11 @@ pub extern "C" fn sha_512_rsa_digital_signature_threadpool(
     if rsa_key_size != 1024 && rsa_key_size != 2048 && rsa_key_size != 4096 {
         panic!("Not a valid RSA key length");
     }
-    let result = <SHA512RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa_threadpool(
-        rsa_key_size as u32,
-        data_to_sign_slice,
-    );
+    let result =
+        <SHA512RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa_threadpool(
+            rsa_key_size as u32,
+            data_to_sign_slice,
+        );
     let mut signed_data = result.signature;
     let capacity = signed_data.capacity();
     signed_data.reserve_exact(capacity);
@@ -123,10 +124,11 @@ pub extern "C" fn sha_256_rsa_digital_signature_threadpool(
     if rsa_key_size != 1024 && rsa_key_size != 2048 && rsa_key_size != 4096 {
         panic!("Not a valid RSA key length");
     }
-    let result = <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa_threadpool(
-        rsa_key_size as u32,
-        data_to_sign_slice,
-    );
+    let result =
+        <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa_threadpool(
+            rsa_key_size as u32,
+            data_to_sign_slice,
+        );
     let mut signed_data = result.signature;
     let capacity = signed_data.capacity();
     signed_data.reserve_exact(capacity);
@@ -280,26 +282,29 @@ pub extern "C" fn sha512_ed25519_digital_signature(
     let data_to_sign_slice = unsafe {
         assert!(!data_to_sign.is_null());
         std::slice::from_raw_parts(data_to_sign, data_length)
-    }
-    .to_vec();
+    };
     let result =
         <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(
             data_to_sign_slice,
         );
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let signature_capacity = signature.capacity();
-    signature.reserve_exact(signature_capacity);
+    let public_key = result.public_key;
+    let public_key_pair_ptr = unsafe {
+        let ptr = libc::malloc(public_key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len());
+        ptr
+    };
+    let signature = result.signature;
+    let signature_ptr = unsafe {
+        let ptr = libc::malloc(signature.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len());
+        ptr
+    };
     let result = SHAED25519DalekDigitalSignatureResult {
-        public_key: public_key.as_mut_ptr(),
+        public_key: public_key_pair_ptr,
         public_key_length: public_key.len(),
-        signature_raw_ptr: signature.as_mut_ptr(),
+        signature_raw_ptr: signature_ptr,
         signature_length: signature.len(),
     };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
     result
 }
 
@@ -311,26 +316,29 @@ pub extern "C" fn sha512_ed25519_digital_signature_threadpool(
     let data_to_sign_slice = unsafe {
         assert!(!data_to_sign.is_null());
         std::slice::from_raw_parts(data_to_sign, data_length)
-    }
-    .to_vec();
+    };
     let result =
         <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_threadpool(
             data_to_sign_slice,
         );
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let signature_capacity = signature.capacity();
-    signature.reserve_exact(signature_capacity);
+    let public_key = result.public_key;
+    let public_key_pair_ptr = unsafe {
+        let ptr = libc::malloc(public_key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len());
+        ptr
+    };
+    let signature = result.signature;
+    let signature_ptr = unsafe {
+        let ptr = libc::malloc(signature.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len());
+        ptr
+    };
     let result = SHAED25519DalekDigitalSignatureResult {
-        public_key: public_key.as_mut_ptr(),
+        public_key: public_key_pair_ptr,
         public_key_length: public_key.len(),
-        signature_raw_ptr: signature.as_mut_ptr(),
+        signature_raw_ptr: signature_ptr,
         signature_length: signature.len(),
     };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
     result
 }
 
@@ -342,26 +350,29 @@ pub extern "C" fn sha256_ed25519_digital_signature(
     let data_to_sign_slice = unsafe {
         assert!(!data_to_sign.is_null());
         std::slice::from_raw_parts(data_to_sign, data_length)
-    }
-    .to_vec();
+    };
     let result =
         <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(
             data_to_sign_slice,
         );
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let signature_capacity = signature.capacity();
-    signature.reserve_exact(signature_capacity);
+    let public_key = result.public_key;
+    let public_key_pair_ptr = unsafe {
+        let ptr = libc::malloc(public_key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len());
+        ptr
+    };
+    let signature = result.signature;
+    let signature_ptr = unsafe {
+        let ptr = libc::malloc(signature.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len());
+        ptr
+    };
     let result = SHAED25519DalekDigitalSignatureResult {
-        public_key: public_key.as_mut_ptr(),
+        public_key: public_key_pair_ptr,
         public_key_length: public_key.len(),
-        signature_raw_ptr: signature.as_mut_ptr(),
+        signature_raw_ptr: signature_ptr,
         signature_length: signature.len(),
     };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
     result
 }
 
@@ -373,26 +384,29 @@ pub extern "C" fn sha256_ed25519_digital_signature_threadpool(
     let data_to_sign_slice = unsafe {
         assert!(!data_to_sign.is_null());
         std::slice::from_raw_parts(data_to_sign, data_length)
-    }
-    .to_vec();
+    };
     let result =
         <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_threadpool(
             data_to_sign_slice,
         );
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let signature_capacity = signature.capacity();
-    signature.reserve_exact(signature_capacity);
+    let public_key = result.public_key;
+    let public_key_pair_ptr = unsafe {
+        let ptr = libc::malloc(public_key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len());
+        ptr
+    };
+    let signature = result.signature;
+    let signature_ptr = unsafe {
+        let ptr = libc::malloc(signature.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len());
+        ptr
+    };
     let result = SHAED25519DalekDigitalSignatureResult {
-        public_key: public_key.as_mut_ptr(),
+        public_key: public_key_pair_ptr,
         public_key_length: public_key.len(),
-        signature_raw_ptr: signature.as_mut_ptr(),
+        signature_raw_ptr: signature_ptr,
         signature_length: signature.len(),
     };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
     result
 }
 
@@ -407,19 +421,24 @@ pub extern "C" fn sha512_ed25519_digital_signature_verify(
 ) -> bool {
     let public_key_slice = unsafe {
         assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }
-    .to_vec();
+        assert!(public_key_length == 32, "Public key must be 32 key bytes");
+        let slice = std::slice::from_raw_parts(public_key, public_key_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let data_to_verify_slice = unsafe {
         assert!(!data_to_verify.is_null());
         std::slice::from_raw_parts(data_to_verify, data_to_verify_length)
-    }
-    .to_vec();
+    };
     let signature_slice = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }
-    .to_vec();
+        assert!(signature_length == 64, "Signature must be 64 key bytes");
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let result = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(public_key_slice, data_to_verify_slice,  signature_slice);
     result
 }
@@ -435,19 +454,24 @@ pub extern "C" fn sha512_ed25519_digital_signature_verify_threadpool(
 ) -> bool {
     let public_key_slice = unsafe {
         assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }
-    .to_vec();
+        assert!(public_key_length == 32, "Public key must be 32 key bytes");
+        let slice = std::slice::from_raw_parts(public_key, public_key_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let data_to_verify_slice = unsafe {
         assert!(!data_to_verify.is_null());
         std::slice::from_raw_parts(data_to_verify, data_to_verify_length)
-    }
-    .to_vec();
+    };
     let signature_slice = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }
-    .to_vec();
+        assert!(signature_length == 64, "Signature must be 64 key bytes");
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let result = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify_threadpool(public_key_slice, data_to_verify_slice,  signature_slice);
     result
 }
@@ -463,19 +487,30 @@ pub extern "C" fn sha256_ed25519_digital_signature_verify(
 ) -> bool {
     let public_key_slice = unsafe {
         assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }
-    .to_vec();
+        assert!(
+            public_key_length == 32,
+            "Public key must be 32 byes in length"
+        );
+        let slice = std::slice::from_raw_parts(public_key, public_key_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let data_to_verify_slice = unsafe {
         assert!(!data_to_verify.is_null());
         std::slice::from_raw_parts(data_to_verify, data_to_verify_length)
-    }
-    .to_vec();
+    };
     let signature_slice = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }
-    .to_vec();
+        assert!(
+            signature_length == 64,
+            "Signature must be 64 byes in length"
+        );
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let result = <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(public_key_slice, data_to_verify_slice,  signature_slice);
     result
 }
@@ -491,19 +526,30 @@ pub extern "C" fn sha256_ed25519_digital_signature_verify_threadpool(
 ) -> bool {
     let public_key_slice = unsafe {
         assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }
-    .to_vec();
+        assert!(
+            public_key_length == 32,
+            "Public Key must be 32 bytes in length"
+        );
+        let slice = std::slice::from_raw_parts(public_key, public_key_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let data_to_verify_slice = unsafe {
         assert!(!data_to_verify.is_null());
         std::slice::from_raw_parts(data_to_verify, data_to_verify_length)
-    }
-    .to_vec();
+    };
     let signature_slice = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }
-    .to_vec();
+        assert!(
+            signature_length == 64,
+            "Signature must be 64 bytes in length"
+        );
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let result = <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify_threadpool(public_key_slice, data_to_verify_slice,  signature_slice);
     result
-}
\ No newline at end of file
+}
diff --git a/src/ed25519.rs b/src/ed25519.rs
index 5625c33..08b0e4c 100644
--- a/src/ed25519.rs
+++ b/src/ed25519.rs
@@ -1,43 +1,49 @@
 use cas_lib::signatures::ed25519::{ed25519_sign_with_key_pair, ed25519_sign_with_key_pair_threadpool, ed25519_verify_with_key_pair, ed25519_verify_with_key_pair_threadpool, ed25519_verify_with_public_key, ed25519_verify_with_public_key_threadpool, get_ed25519_key_pair, get_ed25519_key_pair_threadpool};
-use libc::c_uchar;
+use libc::{c_uchar, printf};
 
 #[repr(C)]
 pub struct Ed25519KeyPairBytesResult {
-    key_pair: *mut c_uchar,
+    key_pair: *mut u8,
     length: usize,
 }
 
 #[repr(C)]
 pub struct Ed25519ByteSignatureResult {
-    pub signature_byte_ptr: *mut c_uchar,
+    pub signature_byte_ptr: *mut u8,
     pub signature_length: usize,
-    pub public_key: *mut c_uchar,
+    pub public_key: *mut u8,
     pub public_key_length: usize,
 }
 
 #[no_mangle]
 pub extern "C" fn get_ed25519_key_pair_bytes() -> Ed25519KeyPairBytesResult {
-    let mut keypair = get_ed25519_key_pair();
-    let capacity = keypair.capacity();
-    keypair.reserve_exact(capacity);
+    let keypair = get_ed25519_key_pair();
+    let len = keypair.len();
+    let key_pair_ptr = unsafe {
+        let ptr = libc::malloc(len) as *mut u8;
+        std::ptr::copy_nonoverlapping(keypair.as_ptr(), ptr, len);
+        ptr
+    };
     let result = Ed25519KeyPairBytesResult {
         length: keypair.len(),
-        key_pair: keypair.as_mut_ptr(),
+        key_pair: key_pair_ptr,
     };
-    std::mem::forget(keypair);
     result
 }
 
 #[no_mangle]
 pub extern "C" fn get_ed25519_key_pair_bytes_threadpool() -> Ed25519KeyPairBytesResult {
-    let mut keypair = get_ed25519_key_pair_threadpool();
-    let capacity = keypair.capacity();
-    keypair.reserve_exact(capacity);
+    let keypair = get_ed25519_key_pair_threadpool();
+    let len = keypair.len();
+    let key_pair_ptr = unsafe {
+        let ptr = libc::malloc(len) as *mut u8;
+        std::ptr::copy_nonoverlapping(keypair.as_ptr(), ptr, len);
+        ptr
+    };
     let result = Ed25519KeyPairBytesResult {
         length: keypair.len(),
-        key_pair: keypair.as_mut_ptr(),
+        key_pair: key_pair_ptr,
     };
-    std::mem::forget(keypair);
     result
 }
 
@@ -58,29 +64,35 @@ pub extern "C" fn sign_with_key_pair_bytes(
 ) -> Ed25519ByteSignatureResult {
     let key_pair_slice = unsafe {
         assert!(!key_pair.is_null());
-        std::slice::from_raw_parts(key_pair, key_pair_length)
-    }
-    .to_vec();
+        assert!(key_pair_length == 32, "Key pair must be 32 bytes");
+        let slice = std::slice::from_raw_parts(key_pair, key_pair_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let message_to_sign_slice = unsafe {
         assert!(!message_to_sign.is_null());
         std::slice::from_raw_parts(message_to_sign, message_to_sign_length)
-    }
-    .to_vec();
+    };
     let result = ed25519_sign_with_key_pair(key_pair_slice, message_to_sign_slice);
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let siganture_capacity = signature.capacity();
-    signature.reserve_exact(siganture_capacity);
+    let public_key = result.public_key;
+    let signature = result.signature;
+    let public_key_pointer = unsafe {
+        let ptr = libc::malloc(public_key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len());
+        ptr
+    };
+    let signature_pointer = unsafe {
+        let ptr = libc::malloc(signature.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len());
+        ptr
+    };
     let result = Ed25519ByteSignatureResult {
-        signature_byte_ptr: signature.as_mut_ptr(),
+        signature_byte_ptr: signature_pointer,
         signature_length: signature.len(),
-        public_key: public_key.as_mut_ptr(),
+        public_key: public_key_pointer,
         public_key_length: public_key.len(),
     };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
     result
 }
 
@@ -93,29 +105,35 @@ pub extern "C" fn sign_with_key_pair_bytes_threadpool(
 ) -> Ed25519ByteSignatureResult {
     let key_pair_slice = unsafe {
         assert!(!key_pair.is_null());
-        std::slice::from_raw_parts(key_pair, key_pair_length)
-    }
-    .to_vec();
+        assert!(key_pair_length == 32, "Key pair must be 32 bytes in length");
+        let slice = std::slice::from_raw_parts(key_pair, key_pair_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let message_to_sign_slice = unsafe {
         assert!(!message_to_sign.is_null());
         std::slice::from_raw_parts(message_to_sign, message_to_sign_length)
-    }
-    .to_vec();
+    };
     let result = ed25519_sign_with_key_pair_threadpool(key_pair_slice, message_to_sign_slice);
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let siganture_capacity = signature.capacity();
-    signature.reserve_exact(siganture_capacity);
+    let public_key = result.public_key;
+    let signature = result.signature;
+    let public_key_pointer = unsafe {
+        let ptr = libc::malloc(public_key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(public_key.as_ptr(), ptr, public_key.len());
+        ptr
+    };
+    let signature_pointer = unsafe {
+        let ptr = libc::malloc(signature.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(signature.as_ptr(), ptr, signature.len());
+        ptr
+    };
     let result = Ed25519ByteSignatureResult {
-        signature_byte_ptr: signature.as_mut_ptr(),
+        signature_byte_ptr: signature_pointer,
         signature_length: signature.len(),
-        public_key: public_key.as_mut_ptr(),
+        public_key: public_key_pointer,
         public_key_length: public_key.len(),
     };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
     result
 }
 
@@ -147,16 +165,24 @@ pub extern "C" fn verify_with_key_pair_bytes(
 ) -> bool {
     let key_pair_slice = unsafe {
         assert!(!key_pair.is_null());
-        std::slice::from_raw_parts(key_pair, key_pair_length)
-    }.to_vec();
+        assert!(key_pair_length == 32, "Key pair length must be 32 bytes");
+        let slice = std::slice::from_raw_parts(key_pair, key_pair_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let signature_slice = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }.to_vec();
+        assert!(signature_length == 64, "Key pair length must be 64 bytes");
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let message_slice = unsafe {
         assert!(!message.is_null());
         std::slice::from_raw_parts(message, message_length)
-    }.to_vec();
+    };
     return ed25519_verify_with_key_pair(key_pair_slice, signature_slice, message_slice);
 }
 
@@ -169,18 +195,26 @@ pub extern "C" fn verify_with_key_pair_bytes_threadpool(
     message: *const c_uchar,
     message_length: usize,
 ) -> bool {
-    let key_pair_slice = unsafe {
+    let key_pair_slice: [u8; 32] = unsafe {
         assert!(!key_pair.is_null());
-        std::slice::from_raw_parts(key_pair, key_pair_length)
-    }.to_vec();
+        assert!(key_pair_length == 32, "Key pair length must be 32 bytes");
+        let slice = std::slice::from_raw_parts(key_pair, key_pair_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
     let signature_slice = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }.to_vec();
+        assert!(signature_length == 64, "Signature length must be 64 bytes");
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let message_slice = unsafe {
         assert!(!message.is_null());
         std::slice::from_raw_parts(message, message_length)
-    }.to_vec();
+    };
     return ed25519_verify_with_key_pair_threadpool(key_pair_slice, signature_slice, message_slice);
 }
 
@@ -214,18 +248,26 @@ pub extern "C" fn verify_with_public_key_bytes(
     message: *const c_uchar,
     message_length: usize,
 ) -> bool {
-    let public_key_slice = unsafe {
+    let public_key_slice: [u8; 32] = unsafe {
         assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }.to_vec();
-    let signature_slice = unsafe {
+        assert!(public_key_length == 32);
+        let slice = std::slice::from_raw_parts(public_key, public_key_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
+    let signature_slice: [u8; 64] = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }.to_vec();
+        assert!(signature_length == 64, "Signature slice must be 64 bytes");
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let message_slice = unsafe {
         assert!(!message.is_null());
         std::slice::from_raw_parts(message, message_length)
-    }.to_vec();
+    };
     return ed25519_verify_with_public_key(public_key_slice, signature_slice, message_slice);
 }
 
@@ -238,18 +280,26 @@ pub extern "C" fn verify_with_public_key_bytes_threadpool(
     message: *const c_uchar,
     message_length: usize,
 ) -> bool {
-    let public_key_slice = unsafe {
+    let public_key_slice: [u8; 32] = unsafe {
         assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }.to_vec();
-    let signature_slice = unsafe {
+        assert!(public_key_length == 32, "Public key length must be 64 bytes");
+        let slice = std::slice::from_raw_parts(public_key, public_key_length);
+        let mut array = [0u8; 32];
+        array.copy_from_slice(slice);
+        array
+    };
+    let signature_slice: [u8; 64] = unsafe {
         assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }.to_vec();
+        assert!(signature_length == 64, "Signature Slice must be 32 bytes");
+        let slice = std::slice::from_raw_parts(signature, signature_length);
+        let mut array = [0u8; 64];
+        array.copy_from_slice(slice);
+        array
+    };
     let message_slice = unsafe {
         assert!(!message.is_null());
         std::slice::from_raw_parts(message, message_length)
-    }.to_vec();
+    };
     return ed25519_verify_with_public_key_threadpool(public_key_slice, signature_slice, message_slice);
 }
 
diff --git a/src/lib.rs b/src/lib.rs
index b9919a2..8b0f9a9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -12,6 +12,7 @@ mod zstd;
 mod hpke;
 
 pub mod password_hashers {
+    mod types;
     pub mod argon2;
     pub mod scrypt;
     pub mod bcrypt;
diff --git a/src/password_hashers/argon2.rs b/src/password_hashers/argon2.rs
index d8dabd4..1bb9301 100644
--- a/src/password_hashers/argon2.rs
+++ b/src/password_hashers/argon2.rs
@@ -1,5 +1,51 @@
 use std::ffi::{c_char, CStr, CString};
-use cas_lib::password_hashers::{argon2::CASArgon, cas_password_hasher::CASPasswordHasher};
+use cas_lib::password_hashers::argon2::CASArgon;
+
+use super::types::Argon2KDFAes128;
+
+#[no_mangle]
+pub extern "C" fn argon2_derive_aes_128_key(hashed_password: *const c_char) -> Argon2KDFAes128{
+    let hashed_password_bytes = unsafe {
+        assert!(!hashed_password.is_null());
+        CStr::from_ptr(hashed_password)
+    }
+    .to_str()
+    .unwrap()
+    .as_bytes();
+    let key: [u8; 16] = CASArgon::derive_aes_128_key(hashed_password_bytes);
+    let key_ptr = unsafe {
+        let ptr = libc::malloc(key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(key.as_ptr(), ptr, key.len());
+        ptr
+    };
+    let result = Argon2KDFAes128 {
+        key: key_ptr,
+        length: key.len()
+    };
+    result
+}
+
+#[no_mangle]
+pub extern "C" fn argon2_derive_aes_256_key(hashed_password: *const c_char) -> Argon2KDFAes128 {
+    let hashed_password_bytes = unsafe {
+        assert!(!hashed_password.is_null());
+        CStr::from_ptr(hashed_password)
+    }
+    .to_str()
+    .unwrap()
+    .as_bytes();
+    let key: [u8; 32] = CASArgon::derive_aes_256_key(hashed_password_bytes);
+    let key_ptr = unsafe {
+        let ptr = libc::malloc(key.len()) as *mut u8;
+        std::ptr::copy_nonoverlapping(key.as_ptr(), ptr, key.len());
+        ptr
+    };
+    let result = Argon2KDFAes128 {
+        key: key_ptr,
+        length: key.len()
+    };
+    result
+}
 
 #[no_mangle]
 pub extern "C" fn argon2_verify(hashed_pass: *const c_char, password: *const c_char) -> bool {
@@ -18,7 +64,7 @@ pub extern "C" fn argon2_verify(hashed_pass: *const c_char, password: *const c_c
     .to_str()
     .unwrap()
     .to_string();
-    return <CASArgon as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
+    return CASArgon::verify_password(hashed_password, password_to_verify);
 }
 
 #[test]
@@ -52,7 +98,7 @@ pub extern "C" fn argon2_verify_threadpool(hashed_pass: *const c_char, password:
     .to_str()
     .unwrap()
     .to_string();
-    let result: bool = <CASArgon as CASPasswordHasher>::verify_password_threadpool(hashed_pass_string, password_string);
+    let result: bool = CASArgon::verify_password_threadpool(hashed_pass_string, password_string);
     result
 }
 
@@ -79,7 +125,7 @@ pub extern "C" fn argon2_hash(pass_to_hash: *const c_char) -> *mut c_char {
     .to_str()
     .unwrap()
     .to_string();
-    let new_hash = <CASArgon as CASPasswordHasher>::hash_password(password);
+    let new_hash = CASArgon::hash_password(password);
     let password_hash = CString::new(new_hash).unwrap().into_raw();
     return password_hash;
 }
@@ -105,7 +151,7 @@ pub extern "C" fn argon2_hash_threadpool(pass_to_hash: *const c_char) -> *mut c_
     .to_str()
     .unwrap()
     .to_string();
-    let new_hash = <CASArgon as CASPasswordHasher>::hash__password_threadpool(password);
+    let new_hash = CASArgon::hash_password_threadpool(password);
     let result = CString::new(new_hash).unwrap().into_raw();
     result
 }
diff --git a/src/password_hashers/bcrypt.rs b/src/password_hashers/bcrypt.rs
index 2badb80..b49bd91 100644
--- a/src/password_hashers/bcrypt.rs
+++ b/src/password_hashers/bcrypt.rs
@@ -39,7 +39,7 @@ pub extern "C" fn bcrypt_hash_threadpool(pass_to_hash: *const c_char) -> *mut c_
     .to_str()
     .unwrap()
     .to_string();
-    let new_hash = <CASBCrypt as CASPasswordHasher>::hash__password_threadpool(string_pass);
+    let new_hash = <CASBCrypt as CASPasswordHasher>::hash_password_threadpool(string_pass);
     return CString::new(new_hash).unwrap().into_raw();
 }
 
diff --git a/src/password_hashers/scrypt.rs b/src/password_hashers/scrypt.rs
index 2273222..ae25fb1 100644
--- a/src/password_hashers/scrypt.rs
+++ b/src/password_hashers/scrypt.rs
@@ -37,7 +37,7 @@ pub extern "C" fn scrypt_hash_threadpool(pass_to_hash: *const c_char) -> *mut c_
     .to_str()
     .unwrap()
     .to_string();
-    let new_hash = <CASScrypt as CASPasswordHasher>::hash__password_threadpool(string_pass);
+    let new_hash = <CASScrypt as CASPasswordHasher>::hash_password_threadpool(string_pass);
     return CString::new(new_hash).unwrap().into_raw();
 }
 
diff --git a/src/password_hashers/types.rs b/src/password_hashers/types.rs
new file mode 100644
index 0000000..79d81be
--- /dev/null
+++ b/src/password_hashers/types.rs
@@ -0,0 +1,7 @@
+use std::ffi::c_uchar;
+
+#[repr(C)]
+pub struct Argon2KDFAes128 {
+    pub key: *mut c_uchar,
+    pub length: usize,
+}
\ No newline at end of file