cas-typescript-sdk 1.0.25 → 1.0.27

package/index.d.ts

@@ -3,76 +3,80 @@
 
 /* auto-generated by NAPI-RS */
 
-export function argon2Hash(password: string): string
-export function argon2HashThreadPool(password: string): string
-export function argon2Verify(hashedPassword: string, passwordToVerify: string): boolean
-export function argon2VerifyThreadpool(hashedPassword: string, passwordToVerify: string): boolean
-export function bcryptHash(passwordToHash: string): string
-export function bcryptHashThreadpool(passwordToHash: string): string
-export function bcryptVerify(hashedPassword: string, passwordToVerify: string): boolean
-export function bcryptVerifyThreadpool(passwordToHash: string, passwordToVerify: string): boolean
-export function scryptHash(passwordToHash: string): string
-export function scryptVerify(hashedPassword: string, passwordToVerify: string): boolean
-export function scryptHashThreadpool(passwordToHash: string): string
-export function scryptVerifyThreadpool(hashedPassword: string, passwordToVerify: string): boolean
-export function sha512(dataToHash: Array<number>): Array<number>
-export function sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
-export function sha256(dataToHash: Array<number>): Array<number>
-export function sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
-export function x25519GenerateSecretAndPublicKey(): CASx25519SecretPublicKeyResult
-export function x25519DiffieHellman(mySecretKey: Array<number>, usersPublicKey: Array<number>): Array<number>
-export function aesNonce(): Array<number>
-export function aes128Key(): Array<number>
-export function aes256Key(): Array<number>
-export function aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
-export function aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
-export function aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
-export function aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
-export function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
-export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
-export function generateRsaKeys(keySize: number): CasrsaKeyPairResult
-export function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>): Array<number>
-export function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
-export function signRsa(privateKey: string, hash: Array<number>): Array<number>
-export function verifyRsa(publicKey: string, hash: Array<number>, signature: Array<number>): boolean
-export function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CASRSADigitalSignatureResult
-export function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CASRSADigitalSignatureResult
-export function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
-export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
-export function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
-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 declare function argon2Hash(password: string): string
+export declare function argon2HashThreadPool(password: string): string
+export declare function argon2Verify(hashedPassword: string, passwordToVerify: string): boolean
+export declare function argon2VerifyThreadpool(hashedPassword: string, passwordToVerify: string): boolean
+export declare function bcryptHash(passwordToHash: string): string
+export declare function bcryptHashThreadpool(passwordToHash: string): string
+export declare function bcryptVerify(hashedPassword: string, passwordToVerify: string): boolean
+export declare function bcryptVerifyThreadpool(passwordToHash: string, passwordToVerify: string): boolean
+export declare function scryptHash(passwordToHash: string): string
+export declare function scryptVerify(hashedPassword: string, passwordToVerify: string): boolean
+export declare function scryptHashThreadpool(passwordToHash: string): string
+export declare function scryptVerifyThreadpool(hashedPassword: string, passwordToVerify: string): boolean
+export declare function sha512(dataToHash: Array<number>): Array<number>
+export declare function sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export declare function sha256(dataToHash: Array<number>): Array<number>
+export declare function sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
+export declare function x25519GenerateSecretAndPublicKey(): CASx25519SecretPublicKeyResult
+export declare function x25519DiffieHellman(mySecretKey: Array<number>, usersPublicKey: Array<number>): Array<number>
+export declare function aesNonce(): Array<number>
+export declare function aes128Key(): Array<number>
+export declare function aes256Key(): Array<number>
+export declare function aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
+export declare function aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
+export declare function aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
+export declare function aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
+export declare function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export declare function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export declare function generateRsaKeys(keySize: number): CasrsaKeyPairResult
+export declare function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>): Array<number>
+export declare function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
+export declare function signRsa(privateKey: string, hash: Array<number>): Array<number>
+export declare function verifyRsa(publicKey: string, hash: Array<number>, signature: Array<number>): boolean
+export declare function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CASRSADigitalSignatureResult
+export declare function sha512RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
+export declare function sha256RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): CASRSADigitalSignatureResult
+export declare function sha256RsaVerifyDigitalSignature(publicKey: string, dataToVerify: Array<number>, signature: Array<number>): boolean
+export declare function sha512Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
+export declare function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
+export declare function sha256Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
+export declare function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
+export declare function ascon128KeyGenerate(): Array<number>
+export declare function ascon128NonceGenerate(): Array<number>
+export declare function ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
+export declare function ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
+export declare function hmacSign(key: Array<number>, message: Array<number>): Array<number>
+export declare function hmacSignThreadpool(key: Array<number>, message: Array<number>): Array<number>
+export declare function hmacVerify(key: Array<number>, message: Array<number>, signature: Array<number>): boolean
+export declare function hmacVerifyThreadpool(key: Array<number>, message: Array<number>, signature: Array<number>): boolean
 export type CASx25519SecretPublicKeyResult = CaSx25519SecretPublicKeyResult
-export class CaSx25519SecretPublicKeyResult {
+export declare class CaSx25519SecretPublicKeyResult {
   publicKey: Array<number>
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
 export type CASAesKeyFromX25519SharedSecret = CasAesKeyFromX25519SharedSecret
-export class CasAesKeyFromX25519SharedSecret {
+export declare class CasAesKeyFromX25519SharedSecret {
   aesKey: Array<number>
   aesNonce: Array<number>
   constructor(aesKey: Array<number>, aesNonce: Array<number>)
 }
 export type CASRSAKeyPairResult = CasrsaKeyPairResult
-export class CasrsaKeyPairResult {
+export declare class CasrsaKeyPairResult {
   privateKey: string
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
 export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
-export class Casshaed25519DalekDigitalSignatureResult {
+export declare class Casshaed25519DalekDigitalSignatureResult {
   publicKey: Array<number>
   signature: Array<number>
   constructor(publicKey: Array<number>, signature: Array<number>)
 }
 export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
-export class CasrsaDigitalSignatureResult {
+export declare class CasrsaDigitalSignatureResult {
   publicKey: string
   privateKey: string
   signature: 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,6 @@
-
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -9,7 +8,7 @@
     "test": "cargo test && npm run build && mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
     "node:test": "mocha -r ts-node/register ./test-ts/**/*.ts --timeout 20000 --recursive",
     "rust:test": "cargo test",
-    "build": "npm run build:rust && rm -rf lib && tsc",
+    "build": "npm run build:rust && rimraf lib && tsc",
     "build:rust": "napi build --release",
     "prepare": "npm run build"
   },
@@ -29,13 +28,14 @@
     "registry": "https://registry.npmjs.org/"
   },
   "devDependencies": {
-    "@napi-rs/cli": "^2.17.0",
+    "@napi-rs/cli": "^2.18.4",
     "@types/chai": "^4.3.11",
     "@types/mocha": "^10.0.6",
     "@types/node-fetch": "^2.6.3",
     "chai": "^4.4.1",
     "mocha": "^10.2.0",
     "ts-node": "^10.9.1",
-    "typescript": "^5.0.3"
+    "typescript": "^5.0.3",
+    "rimraf": "^6.0.1"
   }
 }

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 key = b"ThisIsMyKeyForHmac".to_vec();
+    let 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 key = b"ThisIsMyKeyForHmac7789".to_vec();
+    let 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-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);
+  });
+});