cas-typescript-sdk 1.0.32 → 1.0.34

package/Cargo.toml

@@ -11,7 +11,9 @@ crate-type = ["cdylib"]
 napi = "2.16.17"
 napi-derive = "2.16.13"
 csbindgen = "1.9.3"
-cas-lib = "0.2.50"
+cas-lib = "0.2.56"
+zeroize = "1.8.1"
+zeroizing-alloc = "0.1.0"
 
 [build-dependencies]
-napi-build = "1"
+napi-build = "1"

package/README.md

@@ -6,9 +6,7 @@ Ever wanted all of your most useful cryptographic operations in one module and n
 CAS is here to provide a unified development experience as an abstract layer to the RustCrypto and Dalek-Cryptography suite of algorithms.
 The official NPM page can be found [here](https://www.npmjs.com/package/cas-typescript-sdk).
 
-**Note: All work is experimental and we understand some benchmarks might not be the most optimal.**
-
-**[You can find some usage examples here](https://github.com/Cryptographic-API-Services/cas-typescript-sdk/blob/main/docs/EXAMPLES.md)**
+**Note: All work is experimental and we understand some benchmarks might not be the most optimal.**\
 
 ## Consuming Library Documentation
 This Node.js NPM module is dependent on our Rust layer [cas-lib](https://github.com/Cryptographic-API-Services/cas-lib). that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.32",
+  "version": "1.0.34",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/digital_signature/sha_256_ed25519.rs

@@ -5,7 +5,7 @@ use super::types::CASSHAED25519DalekDigitalSignatureResult;
 
 #[napi]
 pub fn sha_256_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
-    return <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign).into();
+    return <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
 }
 
 #[napi]
@@ -13,37 +13,25 @@ pub fn sha_256_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_ver
     if public_key.len() != 32 || signature.len() != 64 {
         return false;
     }
-    let mut pk = [0u8; 32];
-    pk.copy_from_slice(&public_key[..32]);
-    let mut sig = [0u8; 64];
-    sig.copy_from_slice(&signature[..64]);
-    SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(pk, &data_to_verify, sig)
+    SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
 }
 
 
 #[test]
 fn sha_256_ed25519_test() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes";
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(&data_to_sign.clone()).into();
-    let mut pk = [0u8; 32];
-    pk.copy_from_slice(&signature_result.public_key[..32]);
-    let mut sig = [0u8; 64];
-    sig.copy_from_slice(&signature_result.signature[..64]);
-    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(pk, data_to_sign, sig);
+    let data_to_sign = b"GetTheseBytes".to_vec();
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
+    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
 
 #[test]
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes";
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(&data_to_sign.clone()).into();
-    let not_original_data = b"NOtTHoseBytes";
-    let mut pk = [0u8; 32];
-    pk.copy_from_slice(&signature_result.public_key[..32]);
-    let mut sig = [0u8; 64];
-    sig.copy_from_slice(&signature_result.signature[..64]);
-    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(pk, not_original_data, sig);
+    let data_to_sign = b"GetTheseBytes".to_vec();
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA256ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone()).into();
+    let not_original_data = b"NOtTHoseBytes".to_vec();
+    let is_verified: bool = SHA256ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
     assert_eq!(is_verified, false);
 }

package/src/digital_signature/sha_512_ed25519.rs

@@ -7,25 +7,23 @@ use super::types::CASSHAED25519DalekDigitalSignatureResult;
 
 #[napi]
 pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
-    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign).into();
+    return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign).into();
 }
 
 #[napi]
 pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
-    let public_key_array: [u8; 32] = public_key.try_into().expect("public_key must be 32 bytes");
-    let signature_array: [u8; 64] = signature.try_into().expect("signature must be 64 bytes");
     return <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(
-        public_key_array,
-        &data_to_verify,
-        signature_array,
+        public_key,
+        data_to_verify,
+        signature,
     );
 }
 
 #[test]
 fn sha_512_ed25519_test() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes";
-    let signature_result: SHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign.clone());
+    let data_to_sign = b"GetTheseBytes".to_vec();
+    let signature_result: SHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone());
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
     assert_eq!(is_verified, true);
 }
@@ -33,15 +31,13 @@ fn sha_512_ed25519_test() {
 #[test]
 fn sha_512_ed25519_test_fail() {
     let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes";
-    let signature_result: CASSHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(&data_to_sign.clone()).into();
+    let data_to_sign = b"GetTheseBytes".to_vec();
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(data_to_sign.clone()).into();
     let not_original_data = b"NOtTHoseBytes".to_vec();
-    let public_key_array: [u8; 32] = signature_result.public_key.clone().try_into().expect("public_key must be 32 bytes");
-    let signature_array: [u8; 64] = signature_result.signature.clone().try_into().expect("signature must be 64 bytes");
     let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(
-        public_key_array,
-        &not_original_data,
-        signature_array,
+        signature_result.public_key,
+        not_original_data,
+        signature_result.signature,
     );
     assert_eq!(is_verified, false);
 }

package/src/lib.rs

@@ -1,3 +1,7 @@
+use zeroizing_alloc::ZeroAlloc;
+
+#[global_allocator]
+static ALLOC: ZeroAlloc<std::alloc::System> = ZeroAlloc(std::alloc::System);
 mod password_hashers {
     pub mod argon2;
     pub mod bcrypt;

package/src/sponges/ascon_aead.rs

@@ -26,9 +26,7 @@ pub fn test_ascon128_nonce_generate() {
 
 #[napi]
 pub fn ascon128_encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    let key_arr: [u8; 16] = key.try_into().expect("Key must be 16 bytes");
-    let nonce_arr: [u8; 16] = nonce.try_into().expect("Nonce must be 16 bytes");
-    return <AsconAead as CASAsconAead>::encrypt(key_arr, nonce_arr, plaintext);
+    return <AsconAead as CASAsconAead>::encrypt(key, nonce, plaintext);
 }
 
 #[test]
@@ -46,9 +44,7 @@ pub fn test_ascon128_encrypt() {
 
 #[napi]
 pub fn ascon128_decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    let key_arr: [u8; 16] = key.try_into().expect("Key must be 16 bytes");
-    let nonce_arr: [u8; 16] = nonce.try_into().expect("Nonce must be 16 bytes");
-    return <AsconAead as CASAsconAead>::decrypt(key_arr, nonce_arr, ciphertext);
+    return <AsconAead as CASAsconAead>::decrypt(key, nonce, ciphertext);
 }
 
 #[test]

package/src/symmetric/aes.rs

@@ -20,46 +20,36 @@ pub fn aes256_key() -> Vec<u8> {
 
 #[napi]
 pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    let key: [u8; 16] = aes_key.try_into().expect("Key must be 16 bytes");
-    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
-    <CASAES128 as CASAES128Encryption>::encrypt_plaintext(key, nonce_arr, plaintext)
+    <CASAES128 as CASAES128Encryption>::encrypt_plaintext(aes_key, nonce, plaintext)
 }
 
 #[napi]
 pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    let key: [u8; 16] = aes_key.try_into().expect("Key must be 16 bytes");
-    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
-    <CASAES128 as CASAES128Encryption>::decrypt_ciphertext(key, nonce_arr, ciphertext)
+    <CASAES128 as CASAES128Encryption>::decrypt_ciphertext(aes_key, nonce, ciphertext)
 }
 
 #[napi]
 pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    let key: [u8; 32] = aes_key.try_into().expect("Key must be 32 bytes");
-    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
-    <CASAES256 as CASAES256Encryption>::encrypt_plaintext(key, nonce_arr, plaintext)
+    <CASAES256 as CASAES256Encryption>::encrypt_plaintext(aes_key, nonce, plaintext)
 }
 
 #[napi]
 pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    let key: [u8; 32] = aes_key.try_into().expect("Key must be 32 bytes");
-    let nonce_arr: [u8; 12] = nonce.try_into().expect("Nonce must be 12 bytes");
-    <CASAES256 as CASAES256Encryption>::decrypt_ciphertext(key, nonce_arr, ciphertext)
+    <CASAES256 as CASAES256Encryption>::decrypt_ciphertext(aes_key, nonce, ciphertext)
 }
 
 #[napi]
 pub fn aes_256_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
 ) -> CASAesKeyFromX25519SharedSecret {
-    let shared_secret_arr: [u8; 32] = shared_secret.try_into().expect("Shared secret must be 32 bytes");
-    return <CASAES256 as CASAES256Encryption>::key_from_x25519_shared_secret(shared_secret_arr).into();
+    return <CASAES256 as CASAES256Encryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[napi]
 pub fn aes_128_key_from_x25519_shared_secret(
     shared_secret: Vec<u8>,
 ) -> CASAesKeyFromX25519SharedSecret {
-    let shared_secret_arr: [u8; 32] = shared_secret.try_into().expect("Shared secret must be 32 bytes");
-    return <CASAES128 as CASAES128Encryption>::key_from_x25519_shared_secret(shared_secret_arr).into();
+    return <CASAES128 as CASAES128Encryption>::key_from_x25519_shared_secret(shared_secret).into();
 }
 
 #[test]