cas-typescript-sdk 1.0.18 → 1.0.20

package/Cargo.toml

@@ -21,6 +21,7 @@ scrypt = "0.11.0"
 sha3 = "0.10.8"
 x25519-dalek = {version = "2.0.0", features = ["static_secrets"]}
 rand_07 = { package = "rand", version = "0.7.0" }
+ascon-aead = "0.4.2"
 
 [profile.dev.package.num-bigint-dig]
 opt-level = 3

package/index.d.ts

@@ -37,6 +37,10 @@ export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): Shaed2
 export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
 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 type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
 export class X25519SecretPublicKeyResult {
   publicKey: Array<number>

package/lib/index.d.ts

@@ -5,4 +5,5 @@ import { AESWrapper } from "./symmetric/index";
 import { RsaKeyPairResult, RSAWrapper } from "./asymmetric/index";
 import { AesRsaHybridEncryptResult, AESRSAHybridInitializer, HybridEncryptionWrapper } from "./hybrid/index";
 import { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType } from "./digital-signature";
-export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, BCryptWrapper, HasherFactory, HasherType, HybridEncryptionWrapper, PasswordHasherFactory, PasswordHasherType, RsaKeyPairResult, RSAWrapper, ScryptWrapper, SHAWrapper, X25519Wrapper, DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType, };
+import { AsconWrapper } from "./sponges/index";
+export { AesRsaHybridEncryptResult, AESRSAHybridInitializer, AESWrapper, Argon2Wrapper, AsconWrapper, BCryptWrapper, DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType, 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.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = 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;
+exports.X25519Wrapper = exports.SHAWrapper = exports.ScryptWrapper = exports.RSAWrapper = exports.RsaKeyPairResult = exports.PasswordHasherType = exports.PasswordHasherFactory = exports.HybridEncryptionWrapper = exports.HasherType = exports.HasherFactory = exports.DigitalSignatureType = exports.DigitalSignatureSHA512Wrapper = exports.DigitalSignatureSHA256Wrapper = exports.DigitalSignatureFactory = exports.BCryptWrapper = exports.AsconWrapper = 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; } });
@@ -27,3 +27,5 @@ Object.defineProperty(exports, "DigitalSignatureFactory", { enumerable: true, ge
 Object.defineProperty(exports, "DigitalSignatureSHA256Wrapper", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureSHA256Wrapper; } });
 Object.defineProperty(exports, "DigitalSignatureSHA512Wrapper", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureSHA512Wrapper; } });
 Object.defineProperty(exports, "DigitalSignatureType", { enumerable: true, get: function () { return digital_signature_1.DigitalSignatureType; } });
+const index_7 = require("./sponges/index");
+Object.defineProperty(exports, "AsconWrapper", { enumerable: true, get: function () { return index_7.AsconWrapper; } });

package/lib/sponges/ascon-wrapper.d.ts

@@ -0,0 +1,6 @@
+export declare class AsconWrapper {
+    ascon128Key(): Array<number>;
+    ascon128Nonce(): Array<number>;
+    ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
+    ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
+}

package/lib/sponges/ascon-wrapper.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsconWrapper = void 0;
+const index_1 = require("../../index");
+class AsconWrapper {
+    ascon128Key() {
+        return (0, index_1.ascon128KeyGenerate)();
+    }
+    ascon128Nonce() {
+        return (0, index_1.ascon128NonceGenerate)();
+    }
+    ascon128Encrypt(key, nonce, plaintext) {
+        if (!key || key.length === 0) {
+            throw new Error("Key is required");
+        }
+        if (!nonce || nonce.length === 0) {
+            throw new Error("Nonce is required");
+        }
+        if (!plaintext || plaintext.length === 0) {
+            throw new Error("Plaintext is required");
+        }
+        return (0, index_1.ascon128Encrypt)(key, nonce, plaintext);
+    }
+    ascon128Decrypt(key, nonce, ciphertext) {
+        if (!key || key.length === 0) {
+            throw new Error("Key is required");
+        }
+        if (!nonce || nonce.length === 0) {
+            throw new Error("Nonce is required");
+        }
+        if (!ciphertext || ciphertext.length === 0) {
+            throw new Error("Ciphertext is required");
+        }
+        return (0, index_1.ascon128Decrypt)(key, nonce, ciphertext);
+    }
+}
+exports.AsconWrapper = AsconWrapper;

package/lib/sponges/index.d.ts

@@ -0,0 +1,2 @@
+import { AsconWrapper } from "./ascon-wrapper";
+export { AsconWrapper };

package/lib/sponges/index.js

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

package/lib/symmetric/aes-wrapper.d.ts

@@ -1,6 +1,26 @@
 import { AesKeyFromX25519SharedSecret } from "../../index";
+/**
+ * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
+ *
+ * @example
+ * ```ts
+ * const nonce = aesWrapper.generateAESNonce();
+const key = aesWrapper.aes128Key();
+const textEncoder = new TextEncoder();
+const array = Array.from(textEncoder.encode("Hello World"));
+const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
+ * ```
+ */
 export declare class AESWrapper {
+    /**
+     * @description Generates a 128 bit AES key
+     * @returns returns a 128 bit AES key
+     */
     aes128Key(): Array<number>;
+    /**
+     * @description Generates a 256 bit AES key
+     * @returns returns a 256 bit AES key
+     */
     aes256Key(): Array<number>;
     generateAESNonce(): Array<number>;
     aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;

package/lib/symmetric/aes-wrapper.js

@@ -2,10 +2,30 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AESWrapper = void 0;
 const index_1 = require("../../index");
+/**
+ * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
+ *
+ * @example
+ * ```ts
+ * const nonce = aesWrapper.generateAESNonce();
+const key = aesWrapper.aes128Key();
+const textEncoder = new TextEncoder();
+const array = Array.from(textEncoder.encode("Hello World"));
+const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
+ * ```
+ */
 class AESWrapper {
+    /**
+     * @description Generates a 128 bit AES key
+     * @returns returns a 128 bit AES key
+     */
     aes128Key() {
         return (0, index_1.aes128Key)();
     }
+    /**
+     * @description Generates a 256 bit AES key
+     * @returns returns a 256 bit AES key
+     */
     aes256Key() {
         return (0, index_1.aes256Key)();
     }

package/package.json

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

package/src/lib.rs

@@ -33,3 +33,8 @@ mod digital_signature {
     pub mod sha_512_ed25519;
     pub mod sha_256_ed25519;
 }
+
+mod sponges {
+    pub mod cas_ascon_aead;
+    pub mod ascon_aead;
+}

package/src/sponges/ascon_aead.rs

@@ -0,0 +1,84 @@
+
+use aes_gcm::AeadCore;
+use ascon_aead::{aead::{generic_array::GenericArray, Aead, KeyInit, OsRng}, Ascon128};
+use napi_derive::napi;
+
+use super::cas_ascon_aead::{CASAsconAead};
+pub struct AsconAead;
+
+impl CASAsconAead for AsconAead {
+    fn encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+        let key_generic_array = GenericArray::from_slice(&key);
+        let nonce_generic_array = GenericArray::from_slice(&nonce);
+        let cipher = Ascon128::new(key_generic_array);
+        let ciphertext = cipher.encrypt(&nonce_generic_array, plaintext.as_ref()).unwrap();
+        ciphertext
+    }
+
+    fn decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+        let key_generic_array = GenericArray::from_slice(&key);
+        let nonce_generic_array = GenericArray::from_slice(&nonce);
+        let cipher = Ascon128::new(key_generic_array);
+        let plaintext = cipher.decrypt(&nonce_generic_array, ciphertext.as_ref()).unwrap();
+        plaintext
+    }
+    
+    fn generate_key() -> Vec<u8> {
+        return Ascon128::generate_key(&mut OsRng).to_vec();
+    }
+    
+    fn generate_nonce() -> Vec<u8> {
+        return Ascon128::generate_nonce(&mut OsRng).to_vec();
+    }
+}
+
+#[napi]
+pub fn ascon128_key_generate() -> Vec<u8> {
+    return AsconAead::generate_key();
+}
+
+#[test]
+fn test_ascon128_key_generate() {
+    let key = ascon128_key_generate();
+    assert_eq!(key.len(), 16);
+}
+
+#[napi]
+pub fn ascon128_nonce_generate() -> Vec<u8> {
+    return AsconAead::generate_nonce();
+}
+
+#[test]
+pub fn test_ascon128_nonce_generate() {
+    let nonce = ascon128_nonce_generate();
+    assert_eq!(nonce.len(), 16);
+}
+
+#[napi]
+pub fn ascon128_encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+    return AsconAead::encrypt(key, nonce, plaintext);
+}
+
+#[test]
+pub fn test_ascon128_encrypt() {
+    let key = AsconAead::generate_key();
+    let nonce = AsconAead::generate_nonce();
+    let plaintext = b"Hello, World!".to_vec();
+    let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
+    assert_ne!(ciphertext, plaintext);
+}
+
+#[napi]
+pub fn ascon128_decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+    return AsconAead::decrypt(key, nonce, ciphertext);
+}
+
+#[test]
+pub fn test_ascon128_decrypt() {
+    let key = AsconAead::generate_key();
+    let nonce = AsconAead::generate_nonce();
+    let plaintext = b"Hello, World!".to_vec();
+    let ciphertext = ascon128_encrypt(key.clone(), nonce.clone(), plaintext.clone());
+    let decrypted = ascon128_decrypt(key.clone(), nonce.clone(), ciphertext.clone());
+    assert_eq!(decrypted, plaintext);
+}

package/src/sponges/cas_ascon_aead.rs

@@ -0,0 +1,6 @@
+pub trait CASAsconAead {
+    fn generate_key() -> Vec<u8>;
+    fn generate_nonce() -> Vec<u8>;
+    fn encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8>;
+    fn decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8>;
+}

package/src-ts/index.ts

@@ -20,13 +20,19 @@ import {
   DigitalSignatureSHA512Wrapper,
   DigitalSignatureType,
 } from "./digital-signature";
+import { AsconWrapper } from "./sponges/index";
 
 export {
   AesRsaHybridEncryptResult,
   AESRSAHybridInitializer,
   AESWrapper,
   Argon2Wrapper,
+  AsconWrapper,
   BCryptWrapper,
+  DigitalSignatureFactory,
+  DigitalSignatureSHA256Wrapper,
+  DigitalSignatureSHA512Wrapper,
+  DigitalSignatureType,
   HasherFactory,
   HasherType,
   HybridEncryptionWrapper,
@@ -37,8 +43,4 @@ export {
   ScryptWrapper,
   SHAWrapper,
   X25519Wrapper,
-  DigitalSignatureFactory,
-  DigitalSignatureSHA256Wrapper,
-  DigitalSignatureSHA512Wrapper,
-  DigitalSignatureType,
 };

package/src-ts/sponges/ascon-wrapper.ts

@@ -0,0 +1,50 @@
+import {
+  ascon128Decrypt,
+  ascon128Encrypt,
+  ascon128KeyGenerate,
+  ascon128NonceGenerate,
+} from "../../index";
+
+export class AsconWrapper {
+  ascon128Key(): Array<number> {
+    return ascon128KeyGenerate();
+  }
+
+  ascon128Nonce(): Array<number> {
+    return ascon128NonceGenerate();
+  }
+
+  ascon128Encrypt(
+    key: Array<number>,
+    nonce: Array<number>,
+    plaintext: Array<number>,
+  ): Array<number> {
+    if (!key || key.length === 0) {
+      throw new Error("Key is required");
+    }
+    if (!nonce || nonce.length === 0) {
+      throw new Error("Nonce is required");
+    }
+    if (!plaintext || plaintext.length === 0) {
+      throw new Error("Plaintext is required");
+    }
+    return ascon128Encrypt(key, nonce, plaintext);
+  }
+
+  ascon128Decrypt(
+    key: Array<number>,
+    nonce: Array<number>,
+    ciphertext: Array<number>,
+  ): Array<number> {
+    if (!key || key.length === 0) {
+      throw new Error("Key is required");
+    }
+    if (!nonce || nonce.length === 0) {
+      throw new Error("Nonce is required");
+    }
+    if (!ciphertext || ciphertext.length === 0) {
+      throw new Error("Ciphertext is required");
+    }
+    return ascon128Decrypt(key, nonce, ciphertext);
+  }
+}

package/src-ts/sponges/index.ts

@@ -0,0 +1,3 @@
+import { AsconWrapper } from "./ascon-wrapper";
+
+export {AsconWrapper}

package/src-ts/symmetric/aes-wrapper.ts

@@ -11,11 +11,32 @@ import {
   aesNonce,
 } from "../../index";
 
+/**
+ * @description A wrapper class that contains methods to construct keys, nonces, and methods to encrypt and decrypt with AES-128-GCM and AES-256-GCM
+ * 
+ * @example
+ * ```ts
+ * const nonce = aesWrapper.generateAESNonce();
+const key = aesWrapper.aes128Key();
+const textEncoder = new TextEncoder();
+const array = Array.from(textEncoder.encode("Hello World"));
+const encrypted = aesWrapper.aes128Encrypt(key, nonce, array);
+ * ```
+ */
 export class AESWrapper {
+
+    /**
+     * @description Generates a 128 bit AES key
+     * @returns returns a 128 bit AES key
+     */
     public aes128Key(): Array<number> {
         return aes128Key();
     }
 
+    /**
+     * @description Generates a 256 bit AES key
+     * @returns returns a 256 bit AES key
+     */
     public aes256Key(): Array<number> {
         return aes256Key();
     }

package/test-ts/{password-hasher-test.spec.ts → password-hasher.test.spec.ts}

@@ -4,7 +4,7 @@ import { ScryptWrapper } from "../src-ts/password-hashers/index";
 import {
   PasswordHasherFactory,
   PasswordHasherType,
-} from "../src-ts/password-hashers/";
+} from "../src-ts/password-hashers";
 
 describe("Bcrypt Tests", () => {
   it("hash", () => {

package/test-ts/sponges.test.spec.ts

@@ -0,0 +1,28 @@
+import { AsconWrapper } from "../src-ts/sponges/ascon-wrapper";
+import { assert } from "chai";
+import { areEqual } from "./helpers/array";
+
+describe("Sponges Tests", () => {
+    it("Ascon 128 Encrypt", () => {
+        const wrapper: AsconWrapper = new AsconWrapper();
+        const key: Array<number> = wrapper.ascon128Key();
+        const nonce: Array<number> = wrapper.ascon128Nonce();
+        const tohashed: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+        const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
+        assert.isNotTrue(areEqual(tohashBytes, ciphertext));
+    });
+
+    it ("Ascon 128 Decrypt", () => {
+        const wrapper: AsconWrapper = new AsconWrapper();
+        const key: Array<number> = wrapper.ascon128Key();
+        const nonce: Array<number> = wrapper.ascon128Nonce();
+        const tohashed: string = "This is my array to encrypt";
+        const encoder = new TextEncoder();
+        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
+        const ciphertext = wrapper.ascon128Encrypt(key, nonce, tohashBytes);
+        const plaintext = wrapper.ascon128Decrypt(key, nonce, ciphertext);
+        assert.equal(areEqual(plaintext, tohashBytes), true);
+    });
+});