cas-typescript-sdk 1.0.17 → 1.0.19

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/hashers/hasher-base.d.ts

@@ -1,6 +1,6 @@
 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;
+    hash512(dataToHash: number[]): number[];
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash256(dataToHash: number[]): number[];
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/lib/hashers/sha-wrapper.d.ts

@@ -1,7 +1,7 @@
 import { IHasherBase } from "./hasher-base";
 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;
+    hash512(dataToHash: number[]): number[];
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash256(dataToHash: number[]): number[];
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/lib/hashers/sha-wrapper.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SHAWrapper = void 0;
 const index_1 = require("../../index");
 class SHAWrapper {
-    hash_512(dataToHash) {
+    hash512(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) {
+    verify512(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
@@ -18,13 +18,13 @@ class SHAWrapper {
         }
         return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
     }
-    hash_256(dataToHash) {
+    hash256(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) {
+    verify256(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }

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

@@ -15,7 +15,7 @@ class AESRSAHybridInitializer {
         this.aesType = aesType;
         let aesWrapper = new symmetric_1.AESWrapper();
         this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
-        this.aesNonce = aesWrapper.aesNonce();
+        this.aesNonce = aesWrapper.generateAESNonce();
         if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
             throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
         }

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/key_exchange/x25519.d.ts

@@ -1,5 +1,5 @@
 import { X25519SecretPublicKeyResult } from "../../index";
 export declare class X25519Wrapper {
     generateSecretAndPublicKey(): X25519SecretPublicKeyResult;
-    diffieHellman(secretKey: Array<number>, publicKey: Array<number>): number[];
+    generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): number[];
 }

package/lib/key_exchange/x25519.js

@@ -6,7 +6,7 @@ class X25519Wrapper {
     generateSecretAndPublicKey() {
         return (0, index_1.x25519GenerateSecretAndPublicKey)();
     }
-    diffieHellman(secretKey, publicKey) {
+    generateSharedSecret(secretKey, publicKey) {
         return (0, index_1.x25519DiffieHellman)(secretKey, publicKey);
     }
 }

package/lib/password-hashers/argon2-wrapper.d.ts

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class Argon2Wrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/argon2-wrapper.js

@@ -9,7 +9,7 @@ class Argon2Wrapper {
         }
         return (0, index_1.argon2Hash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
         }

package/lib/password-hashers/bcrypt-wrapper.d.ts

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class BCryptWrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/bcrypt-wrapper.js

@@ -9,7 +9,7 @@ class BCryptWrapper {
         }
         return (0, index_1.bcryptHash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
         }

package/lib/password-hashers/password-hasher-base.d.ts

@@ -1,4 +1,4 @@
 export interface IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/scrypt-wrapper.d.ts

@@ -1,5 +1,5 @@
 import { IPasswordHasherBase } from "./password-hasher-base";
 export declare class ScryptWrapper implements IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/lib/password-hashers/scrypt-wrapper.js

@@ -9,7 +9,7 @@ class ScryptWrapper {
         }
         return (0, index_1.scryptHash)(password);
     }
-    verifyPassword(hashedPassword, passwordToVerify) {
+    verify(hashedPassword, passwordToVerify) {
         if (!hashedPassword || !passwordToVerify) {
             throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
         }

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

@@ -2,11 +2,11 @@ import { AesKeyFromX25519SharedSecret } from "../../index";
 export declare class AESWrapper {
     aes128Key(): Array<number>;
     aes256Key(): Array<number>;
-    aesNonce(): Array<number>;
+    generateAESNonce(): Array<number>;
     aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
     aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>;
     aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>;
-    aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
-    aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
+    aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret;
 }

package/lib/symmetric/aes-wrapper.js

@@ -9,7 +9,7 @@ class AESWrapper {
     aes256Key() {
         return (0, index_1.aes256Key)();
     }
-    aesNonce() {
+    generateAESNonce() {
         return (0, index_1.aesNonce)();
     }
     aes128Encrypt(aesKey, nonce, plaintext) {
@@ -24,10 +24,10 @@ class AESWrapper {
     aes256Decrypt(aesKey, nonce, ciphertext) {
         return (0, index_1.aes256Decrypt)(aesKey, nonce, ciphertext);
     }
-    aes256KeyFromX25519SharedSecret(shared_secret) {
+    aes256KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes256KeyFromX25519SharedSecret)(shared_secret);
     }
-    aes128KeyFromX25519SharedSecret(shared_secret) {
+    aes128KeyNonceX25519DiffieHellman(shared_secret) {
         return (0, index_1.aes128KeyFromX25519SharedSecret)(shared_secret);
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 
 {
   "name": "cas-typescript-sdk",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "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/hashers/hasher-base.ts

@@ -1,6 +1,6 @@
 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;
+    hash512(dataToHash: number[]): number[];
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    hash256(dataToHash: number[]): number[];
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/src-ts/hashers/sha-wrapper.ts

@@ -2,14 +2,14 @@ import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
 import { IHasherBase } from "./hasher-base";
 
 export class SHAWrapper implements IHasherBase {
-    hash_512(dataToHash: number[]): number[] {
+    hash512(dataToHash: number[]): number[] {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return sha512(dataToHash);
     }
 
-    verify_512(dataToHash: number[], dataToVerify: number[]): boolean {
+    verify512(dataToHash: number[], dataToVerify: number[]): boolean {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
@@ -19,14 +19,14 @@ export class SHAWrapper implements IHasherBase {
         return sha512Verify(dataToHash, dataToVerify);
     }
 
-    hash_256(dataToHash: number[]): number[] {
+    hash256(dataToHash: number[]): number[] {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return sha256(dataToHash);
     }
 
-    verify_256(dataToHash: number[], dataToVerify: number[]): boolean {
+    verify256(dataToHash: number[], dataToVerify: number[]): boolean {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }

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

@@ -15,7 +15,7 @@ export class AESRSAHybridInitializer {
         this.aesType = aesType;
         let aesWrapper = new AESWrapper();
         this.aesKey = (aesType === 128) ? aesWrapper.aes128Key() : aesWrapper.aes256Key();
-        this.aesNonce = aesWrapper.aesNonce();
+        this.aesNonce = aesWrapper.generateAESNonce();
         if (rsaSize !== 1028 && rsaSize !== 2048 && rsaSize !== 4096) {
             throw new Error("You must provide an appropriate RSA Key pair size to generate a hybrid initalizer");
         }

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/key_exchange/x25519.ts

@@ -5,7 +5,7 @@ export class X25519Wrapper {
         return x25519GenerateSecretAndPublicKey();
     }
 
-    public diffieHellman(secretKey: Array<number>, publicKey: Array<number>) {
+    public generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>) {
         return x25519DiffieHellman(secretKey, publicKey);
     }
 }

package/src-ts/password-hashers/argon2-wrapper.ts

@@ -9,7 +9,7 @@ export class Argon2Wrapper implements IPasswordHasherBase {
     return argon2Hash(password);
   }
 
-  public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
+  public verify(hashedPassword: string, passwordToVerify: string): boolean {
     if (!hashedPassword || !passwordToVerify) {
       throw new Error("You must provide a hashed password and a plaintext password to verify with Argon2");
     }

package/src-ts/password-hashers/bcrypt-wrapper.ts

@@ -9,7 +9,7 @@ export class BCryptWrapper implements IPasswordHasherBase {
     return bcryptHash(password);
   }
 
-  public verifyPassword(
+  public verify(
     hashedPassword: string,
     passwordToVerify: string,
   ): boolean {

package/src-ts/password-hashers/password-hasher-base.ts

@@ -1,4 +1,4 @@
 export interface IPasswordHasherBase {
     hashPassword(password: string): string;
-    verifyPassword(hashedPassword: string, passwordToVerify: string): boolean;
+    verify(hashedPassword: string, passwordToVerify: string): boolean;
 }

package/src-ts/password-hashers/scrypt-wrapper.ts

@@ -10,7 +10,7 @@ export class ScryptWrapper implements IPasswordHasherBase {
         return scryptHash(password);
       }
     
-      public verifyPassword(hashedPassword: string, passwordToVerify: string): boolean {
+      public verify(hashedPassword: string, passwordToVerify: string): boolean {
         if (!hashedPassword || !passwordToVerify) {
           throw new Error("You must provide a hashed password and a plaintext password to verify with Scrypt");
         }

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

@@ -20,7 +20,7 @@ export class AESWrapper {
         return aes256Key();
     }
 
-    public aesNonce(): Array<number> {
+    public generateAESNonce(): Array<number> {
         return aesNonce();
     }
 
@@ -40,11 +40,11 @@ export class AESWrapper {
         return aes256Decrypt(aesKey, nonce, ciphertext);
     }
 
-    public aes256KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
          return aes256KeyFromX25519SharedSecret(shared_secret);
     }
 
-    public aes128KeyFromX25519SharedSecret(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
+    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): AesKeyFromX25519SharedSecret {
         return aes128KeyFromX25519SharedSecret(shared_secret);
    }
 }

package/test-ts/hasher.test.spec.ts

@@ -7,7 +7,7 @@ describe("SHA512 Tests", () => {
     const tohashed: string = "This is my array to hash";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const hashed = wrapper.hash_512(tohashBytes);
+    const hashed = wrapper.hash512(tohashBytes);
     assert.notEqual(tohashBytes, hashed);
   });
 
@@ -16,9 +16,9 @@ describe("SHA512 Tests", () => {
     const tohashed: string = "This is my array to hash";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const hashed = wrapper.hash_512(tohashBytes);
+    const hashed = wrapper.hash512(tohashBytes);
     const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const verified = wrapper.verify_512(hashed, toVerifyBytes);
+    const verified = wrapper.verify512(hashed, toVerifyBytes);
     assert.equal(true, verified);
   });
 
@@ -27,10 +27,10 @@ describe("SHA512 Tests", () => {
     const tohashed: string = "This is my array to hash";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-    const hashed = wrapper.hash_512(tohashBytes);
+    const hashed = wrapper.hash512(tohashBytes);
     const toVerify = "This Is Not The Same";
     const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
-    const verified = wrapper.verify_512(hashed, toVerifyBytes);
+    const verified = wrapper.verify512(hashed, toVerifyBytes);
     assert.equal(false, verified);
   });
 });
@@ -42,7 +42,7 @@ describe("SHA256 Tests", () => {
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const hashed = wrapper.hash_256(tohashBytes);
+      const hashed = wrapper.hash256(tohashBytes);
       assert.notEqual(tohashBytes, hashed);
     });
   
@@ -51,9 +51,9 @@ describe("SHA256 Tests", () => {
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const hashed = wrapper.hash_256(tohashBytes);
+      const hashed = wrapper.hash256(tohashBytes);
       const toVerifyBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const verified = wrapper.verify_256(hashed, toVerifyBytes);
+      const verified = wrapper.verify256(hashed, toVerifyBytes);
       assert.equal(true, verified);
     });
   
@@ -62,10 +62,10 @@ describe("SHA256 Tests", () => {
       const tohashed: string = "This is my array to hash";
       const encoder = new TextEncoder();
       const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const hashed = wrapper.hash_256(tohashBytes);
+      const hashed = wrapper.hash256(tohashBytes);
       const toVerify = "This Is Not The Same";
       const toVerifyBytes: Array<number> = Array.from(encoder.encode(toVerify));
-      const verified = wrapper.verify_256(hashed, toVerifyBytes);
+      const verified = wrapper.verify256(hashed, toVerifyBytes);
       assert.equal(false, verified);
     });
   });

package/test-ts/insecure-channel.test.spec.ts

@@ -11,11 +11,11 @@ describe("Insecure Channel Tests", () => {
       const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       
-      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
+      const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
+      const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
 
-      const alice_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes256KeyFromX25519SharedSecret(bob_shared_secret);
+      const alice_aes_key = aesWrapper.aes256KeyNonceX25519DiffieHellman(alice_shared_secret);
+      const bob_aes_key = aesWrapper.aes256KeyNonceX25519DiffieHellman(bob_shared_secret);
 
       const tohashed: string = "This is my encrypt text";
       const encoder = new TextEncoder();
@@ -33,11 +33,11 @@ describe("Insecure Channel Tests", () => {
       const alice_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       const bob_keys: X25519SecretPublicKeyResult = x25519Wrapper.generateSecretAndPublicKey();
       
-      const alice_shared_secret = x25519Wrapper.diffieHellman(alice_keys.secretKey, bob_keys.publicKey);
-      const bob_shared_secret = x25519Wrapper.diffieHellman(bob_keys.secretKey, alice_keys.publicKey);
+      const alice_shared_secret = x25519Wrapper.generateSharedSecret(alice_keys.secretKey, bob_keys.publicKey);
+      const bob_shared_secret = x25519Wrapper.generateSharedSecret(bob_keys.secretKey, alice_keys.publicKey);
 
-      const alice_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(alice_shared_secret);
-      const bob_aes_key = aesWrapper.aes128KeyFromX25519SharedSecret(bob_shared_secret);
+      const alice_aes_key = aesWrapper.aes128KeyNonceX25519DiffieHellman(alice_shared_secret);
+      const bob_aes_key = aesWrapper.aes128KeyNonceX25519DiffieHellman(bob_shared_secret);
 
       const tohashed: string = "This is my encrypt text";
       const encoder = new TextEncoder();

package/test-ts/{key-exchange-test.spec.ts → key-exchange.test.spec.ts}

@@ -8,11 +8,11 @@ describe("X25519 Key Exchange", () => {
     const alice = wrapper.generateSecretAndPublicKey();
     const bob = wrapper.generateSecretAndPublicKey();
 
-    const alice_shared_secret = wrapper.diffieHellman(
+    const alice_shared_secret = wrapper.generateSharedSecret(
       alice.secretKey,
       bob.publicKey,
     );
-    const bob_shared_secret = wrapper.diffieHellman(
+    const bob_shared_secret = wrapper.generateSharedSecret(
       bob.secretKey,
       alice.publicKey,
     );

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", () => {
@@ -18,7 +18,7 @@ describe("Bcrypt Tests", () => {
     const hasher: BCryptWrapper = new BCryptWrapper();
     const password: string = "NotThisPassword!@";
     const hashedPassword: string = hasher.hashPassword(password);
-    const isValid: boolean = hasher.verifyPassword(hashedPassword, password);
+    const isValid: boolean = hasher.verify(hashedPassword, password);
     expect(isValid).to.equal(true);
   });
 
@@ -26,7 +26,7 @@ describe("Bcrypt Tests", () => {
     const hasher: BCryptWrapper = new BCryptWrapper();
     const password: string = "NotThisPassword!@";
     const hashedPassword: string = hasher.hashPassword(password);
-    const isValid: boolean = hasher.verifyPassword(
+    const isValid: boolean = hasher.verify(
       hashedPassword,
       "ThesePasswordsDoNotMatch",
     );
@@ -50,7 +50,7 @@ describe("Scrypt Tests", () => {
     );
     const password: string = "ScryptRocks1231231";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(hashed, password);
+    const verified: boolean = hasher.verify(hashed, password);
     assert.isTrue(verified);
   });
 
@@ -60,7 +60,7 @@ describe("Scrypt Tests", () => {
     );
     const password: string = "ScryptRocksSomeGarbageText";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(
+    const verified: boolean = hasher.verify(
       hashed,
       "make this fail, its not the same",
     );
@@ -84,7 +84,7 @@ describe("Argon2 Tests", () => {
     );
     const password: string = "ScryptRocks1231231";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(hashed, password);
+    const verified: boolean = hasher.verify(hashed, password);
     assert.isTrue(verified);
   });
 
@@ -94,7 +94,7 @@ describe("Argon2 Tests", () => {
     );
     const password: string = "ScryptRocksSomeGarbageText";
     const hashed: string = hasher.hashPassword(password);
-    const verified: boolean = hasher.verifyPassword(
+    const verified: boolean = hasher.verify(
       hashed,
       "make this fail, its not the same",
     );

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);
+    });
+});

package/test-ts/symmetric.test.spec.ts

@@ -6,7 +6,7 @@ describe("Symmetric Tests", () => {
   it("aes 128 encrypt and decrypt equals", () => {
     const aesWrapper: AESWrapper = new AESWrapper();
     const aesKey = aesWrapper.aes128Key();
-    const aesNonce = aesWrapper.aesNonce();
+    const aesNonce = aesWrapper.generateAESNonce();
     const tohashed: string = "This is my array to encrypt";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
@@ -19,7 +19,7 @@ describe("Symmetric Tests", () => {
   it("aes 256 encrypt and decrypt equals", () => {
     const aesWrapper: AESWrapper = new AESWrapper();
     const aesKey = aesWrapper.aes256Key();
-    const aesNonce = aesWrapper.aesNonce();
+    const aesNonce = aesWrapper.generateAESNonce();
     const tohashed: string = "This is my array to encrypt";
     const encoder = new TextEncoder();
     const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));