cas-typescript-sdk 1.0.14 → 1.0.15

package/README.md

@@ -1,4 +1,4 @@
-# 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.

package/build-node.sh

@@ -0,0 +1,2 @@
+#!usr/bin/env bash
+rm -rf lib && tsc

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,6 +1,6 @@
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.14",
+  "version": "1.0.15",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -8,7 +8,9 @@
     "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",
+    "build": "npm run build:rust && npm run build:node",
+    "build:rust": "napi build --release",
+    "build:node": "bash build-node.sh",
     "prepare": "npm run build"
   },
   "repository": {

package/src-ts/hybrid/hybrid-encryption-wrapper.ts

@@ -0,0 +1,64 @@
+import { RSAWrapper } from "../asymmetric";
+import { AESWrapper } from "../symmetric";
+import { AesRsaHybridEncryptResult } from "./types/aes-rsa-hybird-encrypt-result";
+import { AESRSAHybridInitializer } from "./types/aes-rsa-hybrid-initializer";
+
+export class HybridEncryptionWrapper {
+  private aesWrapper: AESWrapper;
+  private rsaWrapper: RSAWrapper;
+
+  constructor() {
+    this.aesWrapper = new AESWrapper();
+    this.rsaWrapper = new RSAWrapper();
+  }
+
+  public encrypt(
+    dataToEncrypt: Array<number>,
+    initalizer: AESRSAHybridInitializer,
+  ): AesRsaHybridEncryptResult {
+    let encryptedData: Array<number> = (initalizer.aesType === 128)
+      ? this.aesWrapper.aes128Encrypt(
+        initalizer.aesKey,
+        initalizer.aesNonce,
+        dataToEncrypt,
+      )
+      : this.aesWrapper.aes256Encrypt(
+        initalizer.aesKey,
+        initalizer.aesNonce,
+        dataToEncrypt,
+      );
+    let encryptedAesKey: Array<number> = this.rsaWrapper.encrypt(
+      initalizer.rsaKeyPair.publicKey,
+      initalizer.aesKey,
+    );
+    let result: AesRsaHybridEncryptResult = new AesRsaHybridEncryptResult(
+      encryptedData,
+      encryptedAesKey,
+      initalizer.aesType,
+      initalizer.aesNonce,
+    );
+    return result;
+  }
+
+  public decrypt(
+    privateKey: string,
+    encryptResult: AesRsaHybridEncryptResult,
+  ): Array<number> {
+    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;
+  }
+}

package/src-ts/hybrid/index.ts

@@ -0,0 +1,9 @@
+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/src-ts/hybrid/types/aes-rsa-hybird-encrypt-result.ts

@@ -0,0 +1,13 @@
+export 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>) {
+        this.ciphertext = cipherText;
+        this.encryptedAesKey = encryptAesKey;
+        this.aesType = aesType;
+        this.aesNonce = aesNonce;
+    }
+}

package/src-ts/hybrid/types/aes-rsa-hybrid-initializer.ts

@@ -0,0 +1,24 @@
+import { RsaKeyPairResult } from "../../..";
+import { RSAWrapper } from "../../asymmetric";
+import { AESWrapper } from "../../symmetric";
+
+export class AESRSAHybridInitializer {
+    public aesType: number;
+    public aesKey: Array<number>;
+    public aesNonce: Array<number>;
+    public rsaKeyPair: RsaKeyPairResult;
+
+    constructor(aesType: number, rsaSize: number) {
+        if (aesType !== 128 && aesType !== 256) {
+            throw new Error("Need an appropriate AES size to generate a hybrid initalizer");
+        }
+        this.aesType = aesType;
+        let aesWrapper = new 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 RSAWrapper().generateKeys(rsaSize); 
+    }
+}

package/src-ts/index.ts

@@ -8,19 +8,27 @@ import {
 import { HasherFactory, HasherType, SHAWrapper } from "./hashers/index";
 import { X25519Wrapper } from "./key_exchange/index";
 import { AESWrapper } from "./symmetric/index";
-import { RSAWrapper, RsaKeyPairResult } from "./asymmetric";
+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,
-  AESWrapper,
-  RSAWrapper,
-  RsaKeyPairResult
 };

package/test-ts/hybrid.test.spec.ts

@@ -0,0 +1,33 @@
+import { assert } from "chai";
+import {
+  AESRSAHybridInitializer,
+  AesRsaHybridEncryptResult,
+  HybridEncryptionWrapper,
+} from "../src-ts/hybrid/index";
+import { areEqual } from "./helpers/array";
+
+describe("Hybrid Encryption Tests", () => {
+  it("RSA 4096 AES 128 encrypt and decrypt equals", () => {
+    const hybridWrapper = new HybridEncryptionWrapper();
+    let initalizer = new AESRSAHybridInitializer(128, 4096);
+    const tohashed: string = "This is my encrypt text for rsa hybrid";
+    const encoder = new TextEncoder();
+    const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
+    let result: AesRsaHybridEncryptResult = hybridWrapper.encrypt(toEncrypt, initalizer);
+    let plaintext: Array<number> = hybridWrapper.decrypt(initalizer.rsaKeyPair.privateKey, result);
+    let result2 = areEqual(toEncrypt, plaintext);
+    assert.isTrue(result2);
+  });
+
+  it("RSA 2048 AES 256 encrypt and decrypt equals", () => {
+    const hybridWrapper = new HybridEncryptionWrapper();
+    let initalizer = new AESRSAHybridInitializer(256, 2048);
+    const tohashed: string = "This is my encrypt text for rsa hybrid";
+    const encoder = new TextEncoder();
+    const toEncrypt: Array<number> = Array.from(encoder.encode(tohashed));
+    let result: AesRsaHybridEncryptResult = hybridWrapper.encrypt(toEncrypt, initalizer);
+    let plaintext: Array<number> = hybridWrapper.decrypt(initalizer.rsaKeyPair.privateKey, result);
+    let result2 = areEqual(toEncrypt, plaintext);
+    assert.isTrue(result2);
+  });
+});

package/lib/hashers/IHasherBase.d.ts

@@ -1,6 +0,0 @@
-export interface IHasherBase {
-    hash_512(dataToHash: number[]): number[];
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash_256(dataToHash: number[]): number[];
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
-}

package/lib/hashers/IHasherBase.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/hashers/SHAWrapper.d.ts

@@ -1,7 +0,0 @@
-import { IHasherBase } from "./IHasherBase";
-export declare class SHAWrapper implements IHasherBase {
-    hash_512(dataToHash: number[]): number[];
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash_256(dataToHash: number[]): number[];
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean;
-}

package/lib/hashers/SHAWrapper.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SHAWrapper = void 0;
-const index_1 = require("../../index");
-class SHAWrapper {
-    hash_512(dataToHash) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return (0, index_1.sha512)(dataToHash);
-    }
-    verify_512(dataToHash, dataToVerify) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        if (!dataToVerify || dataToVerify.length === 0) {
-            throw new Error("You must provide an allocated array of data to verify");
-        }
-        return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
-    }
-    hash_256(dataToHash) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return (0, index_1.sha256)(dataToHash);
-    }
-    verify_256(dataToHash, dataToVerify) {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        if (!dataToVerify || dataToVerify.length === 0) {
-            throw new Error("You must provide an allocated array of data to verify");
-        }
-        return (0, index_1.sha256Verify)(dataToHash, dataToVerify);
-    }
-}
-exports.SHAWrapper = SHAWrapper;

package/lib/password-hashers/types/argon2-hash-thread-result.d.ts

@@ -1,3 +0,0 @@
-import koffi from "koffi";
-declare const Argon2HashThreadResult: koffi.IKoffiCType;
-export default Argon2HashThreadResult;

package/lib/password-hashers/types/argon2-hash-thread-result.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const koffi_1 = __importDefault(require("koffi"));
-const Argon2HashThreadResult = koffi_1.default.struct("Argon2HashThreadResult", {
-    passwords: 'char *',
-    length: 'int'
-});
-exports.default = Argon2HashThreadResult;