cas-typescript-sdk 1.0.24 → 1.0.26

package/Cargo.toml

@@ -10,11 +10,8 @@ crate-type = ["cdylib"]
 [dependencies]
 napi = "2"
 napi-derive = "2"
-rand = "0.8.5"
-rand_chacha = "0.3.1"
-rayon = "1.10.0"
 csbindgen = "1.9.1"
-cas-lib = "0.1.3"
+cas-lib = "0.1.6"
 
 [build-dependencies]
 napi-build = "1"

package/README.md

@@ -12,7 +12,7 @@ The official NPM page can be found [here](https://www.npmjs.com/package/cas-type
 
 
 ## Consuming Library Documentation
-This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.
+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.
 
 We utilize some smart people's existing work and we believe their documentation should be reviewed when possible.
 - [Spin Research](https://github.com/SpinResearch)

package/index.d.ts

@@ -47,6 +47,10 @@ export function ascon128KeyGenerate(): Array<number>
 export function ascon128NonceGenerate(): Array<number>
 export function ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export function ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
+export function hmacSign(key: Array<number>, message: Array<number>): Array<number>
+export function hmacSignThreadpool(key: Array<number>, message: Array<number>): Array<number>
+export function hmacVerify(key: Array<number>, message: Array<number>, signature: Array<number>): boolean
+export function hmacVerifyThreadpool(key: Array<number>, message: Array<number>, signature: Array<number>): boolean
 export type CASx25519SecretPublicKeyResult = CaSx25519SecretPublicKeyResult
 export class CaSx25519SecretPublicKeyResult {
   publicKey: Array<number>

package/lib/index.d.ts

@@ -6,3 +6,4 @@ export * from "./asymmetric/index";
 export * from "./hybrid/index";
 export * from "./digital-signature";
 export * from "./sponges/index";
+export * from "./message/index";

package/lib/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./asymmetric/index"), exports);
 __exportStar(require("./hybrid/index"), exports);
 __exportStar(require("./digital-signature"), exports);
 __exportStar(require("./sponges/index"), exports);
+__exportStar(require("./message/index"), exports);

package/lib/message/hmac.d.ts

@@ -0,0 +1,6 @@
+export declare class HmacWrapper {
+    hmacSignBytes(key: Array<number>, message: Array<number>): Array<number>;
+    hmacVerifyBytes(key: Array<number>, message: Array<number>, signature: Array<number>): boolean;
+    hmacSignBytesThreadpool(key: Array<number>, message: Array<number>): Array<number>;
+    hmacVerifyBytesThreadpool(key: Array<number>, message: Array<number>, signature: Array<number>): boolean;
+}

package/lib/message/hmac.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmacWrapper = void 0;
+const index_1 = require("../../index");
+class HmacWrapper {
+    hmacSignBytes(key, message) {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        return (0, index_1.hmacSign)(key, message);
+    }
+    hmacVerifyBytes(key, message, signature) {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return (0, index_1.hmacVerify)(key, message, signature);
+    }
+    hmacSignBytesThreadpool(key, message) {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        return (0, index_1.hmacSignThreadpool)(key, message);
+    }
+    hmacVerifyBytesThreadpool(key, message, signature) {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return (0, index_1.hmacVerifyThreadpool)(key, message, signature);
+    }
+}
+exports.HmacWrapper = HmacWrapper;

package/lib/message/index.d.ts

@@ -0,0 +1,2 @@
+import { HmacWrapper } from "./hmac";
+export { HmacWrapper };

package/lib/message/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmacWrapper = void 0;
+const hmac_1 = require("./hmac");
+Object.defineProperty(exports, "HmacWrapper", { enumerable: true, get: function () { return hmac_1.HmacWrapper; } });

package/package.json

@@ -1,7 +1,7 @@
 
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.24",
+  "version": "1.0.26",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/src/asymmetric/cas_rsa.rs

@@ -1,4 +1,4 @@
-use cas_lib::asymmetric::{cas_asymmetric_encryption::{CASRSAEncryption, RSAKeyPairResult}, cas_rsa::CASRSA};
+use cas_lib::asymmetric::{cas_asymmetric_encryption::CASRSAEncryption, cas_rsa::CASRSA, types::RSAKeyPairResult};
 use napi_derive::napi;
 
 #[napi(constructor)]
@@ -18,7 +18,7 @@ impl From<RSAKeyPairResult> for CASRSAKeyPairResult {
 
 #[napi]
 pub fn generate_rsa_keys(key_size: u32) -> CASRSAKeyPairResult {
-    return CASRSA::generate_rsa_keys(key_size).into();
+    return CASRSA::generate_rsa_keys(key_size as usize).into();
 }
 
 #[napi]

package/src/lib.rs

@@ -32,4 +32,8 @@ mod digital_signature {
 
 mod sponges {
     pub mod ascon_aead;
+}
+
+mod message {
+    pub mod hmac;
 }

package/src/message/hmac.rs

@@ -0,0 +1,40 @@
+use cas_lib::message::{cas_hmac::CASHMAC, hmac::HMAC};
+use napi_derive::napi;
+
+#[napi]
+pub fn hmac_sign(key: Vec<u8>, message: Vec<u8>) -> Vec<u8> {
+    return <HMAC as CASHMAC>::sign(key, message);
+}
+
+#[napi]
+pub fn hmac_sign_threadpool(key: Vec<u8>, message: Vec<u8>) -> Vec<u8> {
+    return <HMAC as CASHMAC>::sign_threadpool(key, message);
+}
+
+#[napi]
+pub fn hmac_verify(key: Vec<u8>, message: Vec<u8>, signature: Vec<u8>) -> bool {
+    return <HMAC as CASHMAC>::verify(key, message, signature);
+}
+
+#[napi]
+pub fn hmac_verify_threadpool(key: Vec<u8>, message: Vec<u8>, signature: Vec<u8>) -> bool {
+    return <HMAC as CASHMAC>::verify_threadpool(key, message, signature);
+}
+
+#[test]
+fn hmac_sign_and_verify_test() {
+    let mut key = b"ThisIsMyKeyForHmac".to_vec();
+    let mut message = b"ThisIsMyMessageToSign".to_vec();
+    let signature = hmac_sign(key.clone(), message.clone());
+    let result = hmac_verify(key, message, signature);
+    assert_eq!(true, result);
+}
+
+#[test]
+fn hmac_sign_and_verify_threadpool_test() {
+    let mut key = b"ThisIsMyKeyForHmac7789".to_vec();
+    let mut message = b"ThisIsMyMessageToSign1230".to_vec();
+    let signature = hmac_sign_threadpool(key.clone(), message.clone());
+    let result = hmac_verify_threadpool(key, message, signature);
+    assert_eq!(true, result);
+}

package/src/symmetric/aes.rs

@@ -1,17 +1,11 @@
 use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::CASAESEncryption};
 use napi_derive::napi;
-use rand::{RngCore, SeedableRng};
-use rand_chacha::ChaCha20Rng;
 
 use super::types::CASAesKeyFromX25519SharedSecret;
 
 #[napi]
 pub fn aes_nonce() -> Vec<u8> {
-    let mut rng = ChaCha20Rng::from_entropy();
-    let mut random_bytes = Vec::with_capacity(12);
-    random_bytes.resize(12, 0);
-    rng.fill_bytes(&mut random_bytes);
-    random_bytes
+    return <CASAES256 as CASAESEncryption>::generate_nonce();
 }
 
 #[napi]

package/src-ts/index.ts

@@ -5,4 +5,5 @@ export * from "./symmetric/index";
 export * from "./asymmetric/index";
 export * from "./hybrid/index";
 export * from "./digital-signature";
-export * from "./sponges/index";
+export * from "./sponges/index";
+export * from "./message/index";

package/src-ts/message/hmac.ts

@@ -0,0 +1,49 @@
+import { hmacSign, hmacSignThreadpool, hmacVerify, hmacVerifyThreadpool } from "../../index";
+
+export class HmacWrapper {
+    public hmacSignBytes(key: Array<number>, message: Array<number>): Array<number> {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        return hmacSign(key, message);
+    }
+    
+    public hmacVerifyBytes(key: Array<number>, message: Array<number>, signature: Array<number>): boolean {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        if(signature?.length===0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return hmacVerify(key, message, signature);
+    }
+
+    public hmacSignBytesThreadpool(key: Array<number>, message: Array<number>): Array<number> {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        return hmacSignThreadpool(key, message);
+    }
+    
+    public hmacVerifyBytesThreadpool(key: Array<number>, message: Array<number>, signature: Array<number>): boolean {
+        if (key?.length === 0) {
+            throw new Error("Must provide an allocated key");
+        }
+        if (message?.length === 0) {
+            throw new Error("Must provide an allocated message");
+        }
+        if(signature?.length===0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return hmacVerifyThreadpool(key, message, signature);
+    }
+}

package/src-ts/message/index.ts

@@ -0,0 +1,3 @@
+import { HmacWrapper } from "./hmac";
+
+export { HmacWrapper };

package/test-ts/hmac.test.spec.ts

@@ -0,0 +1,32 @@
+import { assert } from "chai";
+import { HmacWrapper } from "../src-ts/message/index";
+
+describe("HMAC Tests", () => {
+  it("Sign and Verify", () => {
+    const wrapper = new HmacWrapper();
+    const key: string = "This is my array to hash";
+    const encoder = new TextEncoder();
+    const keyBytes: Array<number> = Array.from(encoder.encode(key));
+    const message: string = "This is my message";
+    const messageBytes = Array.from(encoder.encode(message));
+    const signature = wrapper.hmacSignBytes(keyBytes, messageBytes);
+    const result = wrapper.hmacVerifyBytes(keyBytes, messageBytes, signature);
+    assert.equal(true, result);
+  });
+
+  it("Sign and Verify Threadpool", () => {
+    const wrapper = new HmacWrapper();
+    const key: string = "This is my array to hash";
+    const encoder = new TextEncoder();
+    const keyBytes: Array<number> = Array.from(encoder.encode(key));
+    const message: string = "This is my message";
+    const messageBytes = Array.from(encoder.encode(message));
+    const signature = wrapper.hmacSignBytesThreadpool(keyBytes, messageBytes);
+    const result = wrapper.hmacVerifyBytesThreadpool(
+      keyBytes,
+      messageBytes,
+      signature,
+    );
+    assert.equal(true, result);
+  });
+});