cas-typescript-sdk 1.0.14 → 1.0.16

package/.github/workflows/main-pr-linux.yml

@@ -0,0 +1,28 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Linux Build / Test
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm test

package/.github/workflows/main-pr-windows.yml

@@ -0,0 +1,28 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Windows Build / Test 
+
+on:
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: windows-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        cache: 'npm'
+    - run: npm ci
+    - run: npm test

package/.github/workflows/main-publish.yml

@@ -0,0 +1,32 @@
+# This workflow will do a clean installation of node dependencies, cache/restore them, build the source code and run tests across different versions of node
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-nodejs
+
+name: Node.js CI
+
+on:
+  push:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [20.x]
+        # See supported Node.js release schedule at https://nodejs.org/en/about/releases/
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v3
+      with:
+        node-version: ${{ matrix.node-version }}
+        registry-url: 'https://registry.npmjs.org'
+        cache: 'npm'
+    - run: npm ci
+    - run: npm test
+    - run: npm publish
+      env:
+        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/Cargo.toml

@@ -19,7 +19,14 @@ rand_chacha = "0.3.1"
 rsa = "0.9.6"
 scrypt = "0.11.0"
 sha3 = "0.10.8"
-x25519-dalek = {version = "2.0.0", features = ["static_secrets"] }
+x25519-dalek = {version = "2.0.0", features = ["static_secrets"]}
+rand_07 = { package = "rand", version = "0.7.0" }
+
+[profile.dev.package.num-bigint-dig]
+opt-level = 3
+
+[dependencies.ed25519-dalek]
+version = "1"
 
 [build-dependencies]
 napi-build = "1"

package/README.md

@@ -1,9 +1,11 @@
-# eas-typescript-sdk
+# cas-typescript-sdk
 
 Ever wanted all of your most useful cryptograpihc operations in one module and not have to surf documentation for various packages? 
 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).
 
+## [Examples](./docs/EXAMPLES.md)
+
 ## Consuming Library Documentation
 **Note: All work is experimental and we understand some benchmarks might not be the most optimal.**
 

package/build.rs

@@ -1,5 +1,5 @@
-extern crate napi_build;
-
-fn main() {
-  napi_build::setup();
-}
+extern crate napi_build;
+
+fn main() {
+    napi_build::setup();
+}

package/docs/EXAMPLES.md

@@ -0,0 +1,39 @@
+### Symmetric
+- AES 256
+```typescript
+const aesWrapper: AESWrapper = new AESWrapper();
+const aesKey = aesWrapper.aes128Key();
+const aesNonce = aesWrapper.aesNonce();
+const toEncrypt: string = "This is my array to encrypt";
+const encoder = new TextEncoder();
+const tohashBytes: Array<number> = Array.from(encoder.encode(toEncrypt));
+const ciphertext = aesWrapper.aes128Encrypt(aesKey, aesNonce, tohashBytes);
+const plaintxt = aesWrapper.aes128Decrypt(aesKey, aesNonce, ciphertext);
+```
+
+
+### Passwords
+- BCrypt
+```typescript
+const hasher: BCryptWrapper = new BCryptWrapper();
+const password: string = "ThisOneBadPassword!@";
+const hashedPassword: string = hasher.hashPassword(password);
+```
+
+- SCrypt
+```typescript
+const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Scrypt,
+    );
+const password: string = "ScryptRocks";
+const hashed: string = hasher.hashPassword(password);
+```
+
+- Argon2
+```typescript
+    const hasher: ScryptWrapper = PasswordHasherFactory.getHasher(
+      PasswordHasherType.Argon2,
+    );
+    const password: string = "ScryptRocks";
+    const hashed: string = hasher.hashPassword(password);
+```

package/index.d.ts

@@ -29,6 +29,12 @@ export function encryptPlaintextRsa(publicKey: string, plaintext: 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 type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>
@@ -46,3 +52,16 @@ export class RsaKeyPairResult {
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
+export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
+export class CasrsaDigitalSignatureResult {
+  publicKey: string
+  privateKey: string
+  signature: Array<number>
+  constructor(publicKey: string, privateKey: string, signature: Array<number>)
+}
+export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
+export class Casshaed25519DalekDigitalSignatureResult {
+  publicKey: Array<number>
+  signature: Array<number>
+  constructor(publicKey: Array<number>, signature: Array<number>)
+}

package/lib/digital-signature/digital-siganture-sha-512.d.ts

@@ -0,0 +1,6 @@
+import { CasrsaDigitalSignatureResult } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult;
+    verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
+}

package/lib/digital-signature/digital-siganture-sha-512.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureSHA512Wrapper = void 0;
+const index_1 = require("../../index");
+class DigitalSignatureSHA512Wrapper {
+    createRsa(rsa_key_size, data_to_sign) {
+        if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
+            throw new Error("You need to provide an appropriate RSA key size.");
+        }
+        if (data_to_sign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha512RsaDigitalSignature)(rsa_key_size, data_to_sign);
+    }
+    verifyRSa(public_key, data_to_verify, signature) {
+        if (!public_key) {
+            throw new Error("Must provide a public key");
+        }
+        if (data_to_verify?.length === 0) {
+            throw new Error("Must provide an allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return (0, index_1.sha512RsaVerifyDigitalSignature)(public_key, data_to_verify, signature);
+    }
+}
+exports.DigitalSignatureSHA512Wrapper = DigitalSignatureSHA512Wrapper;

package/lib/digital-signature/digital-signature-base.d.ts

@@ -0,0 +1,5 @@
+import { CASRSADigitalSignatureResult } from "../../index";
+export interface IDigitalSignature {
+    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
+    verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
+}

package/lib/digital-signature/digital-signature-factory.d.ts

@@ -0,0 +1,8 @@
+import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
+export declare enum DigitalSignatureType {
+    SHA512 = 1,
+    SHA256 = 2
+}
+export declare class DigitalSignatureFactory {
+    static get(type: DigitalSignatureType): DigitalSignatureSHA512Wrapper;
+}

package/lib/digital-signature/digital-signature-factory.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureFactory = exports.DigitalSignatureType = void 0;
+const digital_siganture_sha_512_1 = require("./digital-siganture-sha-512");
+const digital_signaturte_sha_256_1 = require("./digital-signaturte-sha-256");
+var DigitalSignatureType;
+(function (DigitalSignatureType) {
+    DigitalSignatureType[DigitalSignatureType["SHA512"] = 1] = "SHA512";
+    DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
+})(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));
+class DigitalSignatureFactory {
+    static get(type) {
+        let ds = new digital_siganture_sha_512_1.DigitalSignatureSHA512Wrapper();
+        switch (type) {
+            case DigitalSignatureType.SHA256:
+                ds = new digital_signaturte_sha_256_1.DigitalSignatureSHA256Wrapper();
+                break;
+        }
+        return ds;
+    }
+}
+exports.DigitalSignatureFactory = DigitalSignatureFactory;

package/lib/digital-signature/digital-signaturte-sha-256.d.ts

@@ -0,0 +1,6 @@
+import { CasrsaDigitalSignatureResult } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CasrsaDigitalSignatureResult;
+    verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
+}

package/lib/digital-signature/digital-signaturte-sha-256.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureSHA256Wrapper = void 0;
+const index_1 = require("../../index");
+class DigitalSignatureSHA256Wrapper {
+    createRsa(rsa_key_size, data_to_sign) {
+        if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
+            throw new Error("You need to provide an appropriate RSA key size.");
+        }
+        if (data_to_sign?.length === 0) {
+            throw new Error("Must provide allocated data to sign");
+        }
+        return (0, index_1.sha256RsaDigitalSignature)(rsa_key_size, data_to_sign);
+    }
+    verifyRSa(public_key, data_to_verify, signature) {
+        if (!public_key) {
+            throw new Error("Must provide a public key");
+        }
+        if (data_to_verify?.length === 0) {
+            throw new Error("Must provide an allocated data to verify");
+        }
+        if (signature?.length === 0) {
+            throw new Error("Must provide an allocated signature");
+        }
+        return (0, index_1.sha256RsaVerifyDigitalSignature)(public_key, data_to_verify, signature);
+    }
+}
+exports.DigitalSignatureSHA256Wrapper = DigitalSignatureSHA256Wrapper;

package/lib/digital-signature/index.d.ts

@@ -0,0 +1,4 @@
+export declare enum DigitalSignatureType {
+    SHA512 = 1,
+    SHA256 = 2
+}

package/lib/digital-signature/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DigitalSignatureType = void 0;
+var DigitalSignatureType;
+(function (DigitalSignatureType) {
+    DigitalSignatureType[DigitalSignatureType["SHA512"] = 1] = "SHA512";
+    DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
+})(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));

package/lib/hybrid/hybrid-encryption-wrapper.d.ts

@@ -0,0 +1,9 @@
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+export declare class HybridEncryptionWrapper {
+    private aesWrapper;
+    private rsaWrapper;
+    constructor();
+    encrypt(dataToEncrypt: Array<number>, initalizer: AESRSAHybridInitializer): AesRsaHybridEncryptResult;
+    decrypt(privateKey: string, encryptResult: AesRsaHybridEncryptResult): Array<number>;
+}

package/lib/hybrid/hybrid-encryption-wrapper.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridEncryptionWrapper = void 0;
+const asymmetric_1 = require("../asymmetric");
+const symmetric_1 = require("../symmetric");
+const aes_rsa_hybird_encrypt_result_1 = require("./types/aes-rsa-hybird-encrypt-result");
+class HybridEncryptionWrapper {
+    aesWrapper;
+    rsaWrapper;
+    constructor() {
+        this.aesWrapper = new symmetric_1.AESWrapper();
+        this.rsaWrapper = new asymmetric_1.RSAWrapper();
+    }
+    encrypt(dataToEncrypt, initalizer) {
+        let encryptedData = (initalizer.aesType === 128)
+            ? this.aesWrapper.aes128Encrypt(initalizer.aesKey, initalizer.aesNonce, dataToEncrypt)
+            : this.aesWrapper.aes256Encrypt(initalizer.aesKey, initalizer.aesNonce, dataToEncrypt);
+        let encryptedAesKey = this.rsaWrapper.encrypt(initalizer.rsaKeyPair.publicKey, initalizer.aesKey);
+        let result = new aes_rsa_hybird_encrypt_result_1.AesRsaHybridEncryptResult(encryptedData, encryptedAesKey, initalizer.aesType, initalizer.aesNonce);
+        return result;
+    }
+    decrypt(privateKey, encryptResult) {
+        let plaintextAesKey = this.rsaWrapper.decrypt(privateKey, encryptResult.encryptedAesKey);
+        let plaintext = (encryptResult.aesType === 128)
+            ? this.aesWrapper.aes128Decrypt(plaintextAesKey, encryptResult.aesNonce, encryptResult.ciphertext)
+            : this.aesWrapper.aes256Decrypt(plaintextAesKey, encryptResult.aesNonce, encryptResult.ciphertext);
+        return plaintext;
+    }
+}
+exports.HybridEncryptionWrapper = HybridEncryptionWrapper;

package/lib/hybrid/index.d.ts

@@ -0,0 +1,4 @@
+import { HybridEncryptionWrapper } from "./hybrid-encryption-wrapper";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper, };

package/lib/hybrid/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridEncryptionWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
+const hybrid_encryption_wrapper_1 = require("./hybrid-encryption-wrapper");
+Object.defineProperty(exports, "HybridEncryptionWrapper", { enumerable: true, get: function () { return hybrid_encryption_wrapper_1.HybridEncryptionWrapper; } });
+const aes_rsa_hybird_encrypt_result_1 = require("./types/aes-rsa-hybird-encrypt-result");
+Object.defineProperty(exports, "AesRsaHybridEncryptResult", { enumerable: true, get: function () { return aes_rsa_hybird_encrypt_result_1.AesRsaHybridEncryptResult; } });
+const aes_rsa_hybrid_initializer_1 = require("./types/aes-rsa-hybrid-initializer");
+Object.defineProperty(exports, "AESRSAHybridInitializer", { enumerable: true, get: function () { return aes_rsa_hybrid_initializer_1.AESRSAHybridInitializer; } });

package/lib/hybrid/types/aes-rsa-hybird-encrypt-result.d.ts

@@ -0,0 +1,7 @@
+export declare class AesRsaHybridEncryptResult {
+    ciphertext: Array<number>;
+    encryptedAesKey: Array<number>;
+    aesType: number;
+    aesNonce: Array<number>;
+    constructor(cipherText: Array<number>, encryptAesKey: Array<number>, aesType: number, aesNonce: Array<number>);
+}

package/lib/hybrid/types/aes-rsa-hybird-encrypt-result.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AesRsaHybridEncryptResult = void 0;
+class AesRsaHybridEncryptResult {
+    ciphertext;
+    encryptedAesKey;
+    aesType;
+    aesNonce;
+    constructor(cipherText, encryptAesKey, aesType, aesNonce) {
+        this.ciphertext = cipherText;
+        this.encryptedAesKey = encryptAesKey;
+        this.aesType = aesType;
+        this.aesNonce = aesNonce;
+    }
+}
+exports.AesRsaHybridEncryptResult = AesRsaHybridEncryptResult;

package/lib/hybrid/types/aes-rsa-hybrid-initializer.d.ts

@@ -0,0 +1,8 @@
+import { RsaKeyPairResult } from "../../..";
+export declare class AESRSAHybridInitializer {
+    aesType: number;
+    aesKey: Array<number>;
+    aesNonce: Array<number>;
+    rsaKeyPair: RsaKeyPairResult;
+    constructor(aesType: number, rsaSize: number);
+}

package/lib/hybrid/types/aes-rsa-hybrid-initializer.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AESRSAHybridInitializer = void 0;
+const asymmetric_1 = require("../../asymmetric");
+const symmetric_1 = require("../../symmetric");
+class AESRSAHybridInitializer {
+    aesType;
+    aesKey;
+    aesNonce;
+    rsaKeyPair;
+    constructor(aesType, rsaSize) {
+        if (aesType !== 128 && aesType !== 256) {
+            throw new Error("Need an appropriate AES size to generate a hybrid initalizer");
+        }
+        this.aesType = aesType;
+        let aesWrapper = new symmetric_1.AESWrapper();
+        this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
+        this.aesNonce = aesWrapper.aesNonce();
+        if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
+            throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
+        }
+        this.rsaKeyPair = new asymmetric_1.RSAWrapper().generateKeys(rsaSize);
+    }
+}
+exports.AESRSAHybridInitializer = AESRSAHybridInitializer;

package/lib/index.d.ts

@@ -2,5 +2,6 @@ import { Argon2Wrapper, BCryptWrapper, PasswordHasherFactory, PasswordHasherType
 import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
-import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
-export { Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, PasswordHasherFactory, PasswordHasherType, ScryptWrapper, SHAWrapper, X25519Wrapper, AESWrapper, RSAWrapper, RsaKeyPairResult };
+import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
+import { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper } from "./hybrid/index";
+export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, HybridEncryptionWrapper, PasswordHasherFactory, PasswordHasherType, RsaKeyPairResult, RSAWrapper, ScryptWrapper, SHAWrapper, X25519Wrapper, };

package/lib/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RsaKeyPairResult = exports.RSAWrapper = exports.AESWrapper = exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = void 0;
+exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.BCryptWrapper = exports.Argon2Wrapper = exports.AESWrapper = exports.AESRSAHybridInitializer = exports.AesRsaHybridEncryptResult = void 0;
 const index_1 = require("./password-hashers/index");
 Object.defineProperty(exports, "Argon2Wrapper", { enumerable: true, get: function () { return index_1.Argon2Wrapper; } });
 Object.defineProperty(exports, "BCryptWrapper", { enumerable: true, get: function () { return index_1.BCryptWrapper; } });
@@ -15,6 +15,10 @@ const index_3 = require("./key_exchange/index");
 Object.defineProperty(exports, "X25519Wrapper", { enumerable: true, get: function () { return index_3.X25519Wrapper; } });
 const index_4 = require("./symmetric/index");
 Object.defineProperty(exports, "AESWrapper", { enumerable: true, get: function () { return index_4.AESWrapper; } });
-const asymmetric_1 = require("./asymmetric");
-Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return asymmetric_1.RSAWrapper; } });
-Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return asymmetric_1.RsaKeyPairResult; } });
+const index_5 = require("./asymmetric/index");
+Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return index_5.RsaKeyPairResult; } });
+Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return index_5.RSAWrapper; } });
+const index_6 = require("./hybrid/index");
+Object.defineProperty(exports, "AesRsaHybridEncryptResult", { enumerable: true, get: function () { return index_6.AesRsaHybridEncryptResult; } });
+Object.defineProperty(exports, "AESRSAHybridInitializer", { enumerable: true, get: function () { return index_6.AESRSAHybridInitializer; } });
+Object.defineProperty(exports, "HybridEncryptionWrapper", { enumerable: true, get: function () { return index_6.HybridEncryptionWrapper; } });

package/package.json

@@ -1,39 +1,41 @@
-{
-  "name": "cas-typescript-sdk",
-  "version": "1.0.14",
-  "description": "",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "scripts": {
-    "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": "napi build --release && tsc",
-    "prepare": "npm run build"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/Cryptographic-API-Services/cas-typescript-sdk"
-  },
-  "keywords": [],
-  "author": "Mike Mulchrone <mikemulchrone987@gmail.com>",
-  "license": "Apache 2.0",
-  "bugs": {
-    "url": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk/issues"
-  },
-  "homepage": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk#readme",
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "devDependencies": {
-    "@napi-rs/cli": "^2.17.0",
-    "@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"
-  }
-}
+
+{
+  "name": "cas-typescript-sdk",
+  "version": "1.0.16",
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "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:rust": "napi build --release",
+    "prepare": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cryptographic-API-Services/cas-typescript-sdk"
+  },
+  "keywords": [],
+  "author": "Mike Mulchrone <mikemulchrone987@gmail.com>",
+  "license": "Apache 2.0",
+  "bugs": {
+    "url": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk/issues"
+  },
+  "homepage": "https://github.com/Cryptographic-API-Services/cas-typescript-sdk#readme",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^2.17.0",
+    "@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"
+  }
+}

package/src/asymmetric/cas_asymmetric_encryption.rs

@@ -1,15 +1,15 @@
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct RSAKeyPairResult {
-    pub private_key: String,
-    pub public_key: String
-}
-
-pub trait CASRSAEncryption {
-    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult;
-    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8>;
-    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8>;
-    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8>;
-    fn verify(public_key: String, hash: Vec<u8>, signed_text: Vec<u8>) -> bool;
-}
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct RSAKeyPairResult {
+    pub private_key: String,
+    pub public_key: String,
+}
+
+pub trait CASRSAEncryption {
+    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult;
+    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8>;
+    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8>;
+    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8>;
+    fn verify(public_key: String, hash: Vec<u8>, signed_text: Vec<u8>) -> bool;
+}