cas-typescript-sdk 1.0.22 → 1.0.24

package/Cargo.toml

@@ -8,27 +8,13 @@ path = "src/lib.rs"
 crate-type = ["cdylib"]
 
 [dependencies]
-aes-gcm = "0.10.3"
-argon2 = "0.5.2"
-bcrypt = "0.15.0"
-blake2 = "0.10.6"
 napi = "2"
 napi-derive = "2"
 rand = "0.8.5"
 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"]}
-rand_07 = { package = "rand", version = "0.7.0" }
-ascon-aead = "0.4.2"
 rayon = "1.10.0"
-
-[profile.dev.package.num-bigint-dig]
-opt-level = 3
-
-[dependencies.ed25519-dalek]
-version = "1"
+csbindgen = "1.9.1"
+cas-lib = "0.1.3"
 
 [build-dependencies]
-napi-build = "1"
+napi-build = "1"

package/README.md

@@ -2,23 +2,25 @@
 
 [![image](https://img.shields.io/badge/Discord-5865F2?style=for-the-badge&logo=discord&logoColor=white)](https://discord.gg/7bXXCQj45q)
 
-Ever wanted all of your most useful cryptographic operations in one module and not have to surf documentation for various packages? 
+Ever wanted all of your most useful cryptographic operations in one module and not had 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.**
 
-This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry standard cryptographic operations sequentially, on threads, and the thread pool.
+
+
 
 ## Consuming Library Documentation
+This Node.js NPM module is dependent on our Rust layer [here](./src) that contains methods to run industry-standard cryptographic operations sequentially, on threads, and the thread pool.
+
 We utilize some smart people's existing work and we believe their documentation should be reviewed when possible.
 - [Spin Research](https://github.com/SpinResearch)
 - [Dalek-Cryptography](https://github.com/dalek-cryptography)
 - [Rust Crypto](https://github.com/RustCrypto)
 - [Rayon](https://github.com/rayon-rs/rayon)
 
+## [Examples](./docs/EXAMPLES.md)
+
 ## Disclaimer
 Many of the cryptographic crates that are utilized in our core FFI [layer](./src) have never had a security audit performed. Utilize this SDK at your own risk.

package/index.d.ts

@@ -19,7 +19,7 @@ export function sha512(dataToHash: Array<number>): Array<number>
 export function sha512Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
 export function sha256(dataToHash: Array<number>): Array<number>
 export function sha256Verify(dataToHash: Array<number>, dataToVerify: Array<number>): boolean
-export function x25519GenerateSecretAndPublicKey(): X25519SecretPublicKeyResult
+export function x25519GenerateSecretAndPublicKey(): CASx25519SecretPublicKeyResult
 export function x25519DiffieHellman(mySecretKey: Array<number>, usersPublicKey: Array<number>): Array<number>
 export function aesNonce(): Array<number>
 export function aes128Key(): Array<number>
@@ -28,52 +28,53 @@ export function aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plain
 export function aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
 export function aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export function aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
-export function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): AesKeyFromX25519SharedSecret
-export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): AesKeyFromX25519SharedSecret
-export function generateRsaKeys(keySize: number): RsaKeyPairResult
+export function aes256KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export function aes128KeyFromX25519SharedSecret(sharedSecret: Array<number>): CASAesKeyFromX25519SharedSecret
+export function generateRsaKeys(keySize: number): CasrsaKeyPairResult
 export function encryptPlaintextRsa(publicKey: string, plaintext: Array<number>): Array<number>
 export function decryptCiphertextRsa(privateKey: string, ciphertext: Array<number>): Array<number>
 export function signRsa(privateKey: string, hash: Array<number>): Array<number>
 export function verifyRsa(publicKey: string, hash: Array<number>, signature: Array<number>): boolean
-export function sha512RsaDigitalSignature(rsaKeySize: number, dataToSign: Array<number>): RsaDigitalSignatureResult
+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>): RsaDigitalSignatureResult
+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>): Shaed25519DalekDigitalSignatureResult
+export function sha512Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
 export function sha512Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
-export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): Shaed25519DalekDigitalSignatureResult
+export function sha256Ed25519DigitalSignature(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult
 export function sha256Ed25519DigitalSignatureVerify(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean
 export function ascon128KeyGenerate(): Array<number>
 export function ascon128NonceGenerate(): Array<number>
 export function ascon128Encrypt(key: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number>
 export function ascon128Decrypt(key: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number>
-export type x25519SecretPublicKeyResult = X25519SecretPublicKeyResult
-export class X25519SecretPublicKeyResult {
+export type CASx25519SecretPublicKeyResult = CaSx25519SecretPublicKeyResult
+export class CaSx25519SecretPublicKeyResult {
   publicKey: Array<number>
   secretKey: Array<number>
   constructor(publicKey: Array<number>, secretKey: Array<number>)
 }
-export class AesKeyFromX25519SharedSecret {
+export type CASAesKeyFromX25519SharedSecret = CasAesKeyFromX25519SharedSecret
+export class CasAesKeyFromX25519SharedSecret {
   aesKey: Array<number>
   aesNonce: Array<number>
   constructor(aesKey: Array<number>, aesNonce: Array<number>)
 }
-export type RSAKeyPairResult = RsaKeyPairResult
-export class RsaKeyPairResult {
+export type CASRSAKeyPairResult = CasrsaKeyPairResult
+export class CasrsaKeyPairResult {
   privateKey: string
   publicKey: string
   constructor(privateKey: string, publicKey: string)
 }
-export type RSADigitalSignatureResult = RsaDigitalSignatureResult
-export class RsaDigitalSignatureResult {
+export type CASSHAED25519DalekDigitalSignatureResult = Casshaed25519DalekDigitalSignatureResult
+export class Casshaed25519DalekDigitalSignatureResult {
+  publicKey: Array<number>
+  signature: Array<number>
+  constructor(publicKey: Array<number>, signature: Array<number>)
+}
+export type CASRSADigitalSignatureResult = CasrsaDigitalSignatureResult
+export class CasrsaDigitalSignatureResult {
   publicKey: string
   privateKey: string
   signature: Array<number>
   constructor(publicKey: string, privateKey: string, signature: Array<number>)
 }
-export type SHAED25519DalekDigitalSignatureResult = Shaed25519DalekDigitalSignatureResult
-export class Shaed25519DalekDigitalSignatureResult {
-  publicKey: Array<number>
-  signature: Array<number>
-  constructor(publicKey: Array<number>, signature: Array<number>)
-}

package/lib/asymmetric/RSAWrapper.d.ts

@@ -1,8 +1,38 @@
-import { RsaKeyPairResult } from "../../index";
+import { CASRSAKeyPairResult } from "../../index";
 export declare class RSAWrapper {
-    generateKeys(keySize: number): RsaKeyPairResult;
+    /**
+     * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
+     * @param keySize
+     * @returns CASRSAKeyPairResult
+     */
+    generateKeys(keySize: number): CASRSAKeyPairResult;
+    /**
+     * Encrypts a plaintext byte array with a RSA public key
+     * @param publicKey
+     * @param plaintext
+     * @returns Array<number>
+     */
     encrypt(publicKey: string, plaintext: Array<number>): Array<number>;
+    /**
+     * Decrypts a ciphertext with an RSA private key.
+     * @param privateKey
+     * @param ciphertext
+     * @returns Array<number>
+     */
     decrypt(privateKey: string, ciphertext: Array<number>): Array<number>;
-    sign(privateKey: string, hash: Array<number>): Array<number>;
+    /**
+     * Signs a byte array with an RSA private key for verification.
+     * @param privateKey
+     * @param hash
+     * @returns Array<number>
+     */
+    sign(privateKey: string, dataToSign: Array<number>): Array<number>;
+    /**
+     * Verifies signed data by the corresponding private key with an RSA public key.
+     * @param publicKey
+     * @param hash
+     * @param signature
+     * @returns boolean
+     */
     verify(publicKey: string, hash: Array<number>, signature: Array<number>): boolean;
 }

package/lib/asymmetric/RSAWrapper.js

@@ -3,12 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RSAWrapper = void 0;
 const index_1 = require("../../index");
 class RSAWrapper {
+    /**
+     * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
+     * @param keySize
+     * @returns CASRSAKeyPairResult
+     */
     generateKeys(keySize) {
         if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
             throw new Error("You must provide an appropriate key size to generate RSA keys");
         }
         return (0, index_1.generateRsaKeys)(keySize);
     }
+    /**
+     * Encrypts a plaintext byte array with a RSA public key
+     * @param publicKey
+     * @param plaintext
+     * @returns Array<number>
+     */
     encrypt(publicKey, plaintext) {
         if (!publicKey) {
             throw new Error("You must provide a public key to encrypt with RSA");
@@ -18,6 +29,12 @@ class RSAWrapper {
         }
         return (0, index_1.encryptPlaintextRsa)(publicKey, plaintext);
     }
+    /**
+     * Decrypts a ciphertext with an RSA private key.
+     * @param privateKey
+     * @param ciphertext
+     * @returns Array<number>
+     */
     decrypt(privateKey, ciphertext) {
         if (!privateKey) {
             throw new Error("You must provide a private key to encrypt with RSA");
@@ -27,15 +44,28 @@ class RSAWrapper {
         }
         return (0, index_1.decryptCiphertextRsa)(privateKey, ciphertext);
     }
-    sign(privateKey, hash) {
+    /**
+     * Signs a byte array with an RSA private key for verification.
+     * @param privateKey
+     * @param hash
+     * @returns Array<number>
+     */
+    sign(privateKey, dataToSign) {
         if (!privateKey) {
             throw new Error("You must provide a private key to sign with RSA");
         }
-        if (!hash || hash.length === 0) {
+        if (!dataToSign || dataToSign.length === 0) {
             throw new Error("You must provide an allocated hash to sign with RSA");
         }
-        return (0, index_1.signRsa)(privateKey, hash);
+        return (0, index_1.signRsa)(privateKey, dataToSign);
     }
+    /**
+     * Verifies signed data by the corresponding private key with an RSA public key.
+     * @param publicKey
+     * @param hash
+     * @param signature
+     * @returns boolean
+     */
     verify(publicKey, hash, signature) {
         if (!publicKey) {
             throw new Error("You must provide a public key to verify with RSA");

package/lib/asymmetric/index.d.ts

@@ -1,3 +1,3 @@
 import { RSAWrapper } from "./RSAWrapper";
-import { RsaKeyPairResult } from "../../index";
-export { RSAWrapper, RsaKeyPairResult };
+import { CASRSAKeyPairResult } from "../../index";
+export { RSAWrapper, CASRSAKeyPairResult };

package/lib/asymmetric/index.js

@@ -1,7 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RsaKeyPairResult = exports.RSAWrapper = void 0;
+exports.RSAWrapper = void 0;
 const RSAWrapper_1 = require("./RSAWrapper");
 Object.defineProperty(exports, "RSAWrapper", { enumerable: true, get: function () { return RSAWrapper_1.RSAWrapper; } });
-const index_1 = require("../../index");
-Object.defineProperty(exports, "RsaKeyPairResult", { enumerable: true, get: function () { return index_1.RsaKeyPairResult; } });

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

@@ -1,8 +1,33 @@
-import { RsaDigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
-    createED25519(dataToSign: number[]): SHAED25519DalekDigitalSignatureResult;
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns CASSHAED25519DalekDigitalSignatureResult
+     */
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult;
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
-    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns CASRSADigitalSignatureResult
+     */
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CASRSADigitalSignatureResult;
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
 }

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

@@ -3,12 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA512Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA512Wrapper {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns CASSHAED25519DalekDigitalSignatureResult
+     */
     createED25519(dataToSign) {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
         return (0, index_1.sha512Ed25519DigitalSignature)(dataToSign);
     }
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey, dataToVerify, signature) {
         if (!publicKey) {
             throw new Error("You must provide a public key for verify with ED25519");
@@ -21,6 +33,12 @@ class DigitalSignatureSHA512Wrapper {
         }
         return (0, index_1.sha512Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
     }
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns CASRSADigitalSignatureResult
+     */
     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.");
@@ -30,6 +48,13 @@ class DigitalSignatureSHA512Wrapper {
         }
         return (0, index_1.sha512RsaDigitalSignature)(rsa_key_size, data_to_sign);
     }
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key, data_to_verify, signature) {
         if (!public_key) {
             throw new Error("Must provide a public key");

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

@@ -1,7 +1,7 @@
-import { RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 export interface IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: Array<number>): RSADigitalSignatureResult;
+    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
     verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
-    createED25519(dataToSign: Array<number>): SHAED25519DalekDigitalSignatureResult;
+    createED25519(dataToSign: Array<number>): CASSHAED25519DalekDigitalSignatureResult;
     verifyED25519(publicKey: Array<number>, dataToVerify: Array<number>, signature: Array<number>): boolean;
 }

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

@@ -4,5 +4,10 @@ export declare enum DigitalSignatureType {
     SHA256 = 2
 }
 export declare class DigitalSignatureFactory {
+    /**
+     * Get the appropriate digital signature wrapper based upon the type passed in.
+     * @param type
+     * @returns
+     */
     static get(type: DigitalSignatureType): DigitalSignatureSHA512Wrapper;
 }

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

@@ -9,6 +9,11 @@ var DigitalSignatureType;
     DigitalSignatureType[DigitalSignatureType["SHA256"] = 2] = "SHA256";
 })(DigitalSignatureType || (exports.DigitalSignatureType = DigitalSignatureType = {}));
 class DigitalSignatureFactory {
+    /**
+     * Get the appropriate digital signature wrapper based upon the type passed in.
+     * @param type
+     * @returns
+     */
     static get(type) {
         let ds = new digital_siganture_sha_512_1.DigitalSignatureSHA512Wrapper();
         switch (type) {

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

@@ -1,8 +1,33 @@
-import { RsaDigitalSignatureResult, Shaed25519DalekDigitalSignatureResult } from "../../index";
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
 import { IDigitalSignature } from "./digital-signature-base";
 export declare class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
-    createED25519(dataToSign: number[]): Shaed25519DalekDigitalSignatureResult;
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
+    createED25519(dataToSign: number[]): CASSHAED25519DalekDigitalSignatureResult;
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey: number[], dataToVerify: number[], signature: number[]): boolean;
-    createRsa(rsa_key_size: number, data_to_sign: number[]): RsaDigitalSignatureResult;
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns RsaDigitalSignatureResult
+     */
+    createRsa(rsa_key_size: number, data_to_sign: number[]): CASRSADigitalSignatureResult;
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key: string, data_to_verify: number[], signature: number[]): boolean;
 }

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

@@ -3,12 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DigitalSignatureSHA256Wrapper = void 0;
 const index_1 = require("../../index");
 class DigitalSignatureSHA256Wrapper {
+    /**
+     * Creates an ED25519 siganture from an array of bytes with SHA3-512.
+     * @param dataToSign
+     * @returns SHAED25519DalekDigitalSignatureResult
+     */
     createED25519(dataToSign) {
         if (dataToSign?.length === 0) {
             throw new Error("Must provide allocated data to sign");
         }
         return (0, index_1.sha256Ed25519DigitalSignature)(dataToSign);
     }
+    /**
+     * Verifies an ED25519 signature with the public key generated from running createED25519() with SHA3-512
+     * @param publicKey
+     * @param dataToVerify
+     * @param signature
+     * @returns boolean
+     */
     verifyED25519(publicKey, dataToVerify, signature) {
         if (!publicKey) {
             throw new Error("You must provide a public key for verify with ED25519");
@@ -21,6 +33,12 @@ class DigitalSignatureSHA256Wrapper {
         }
         return (0, index_1.sha256Ed25519DigitalSignatureVerify)(publicKey, dataToVerify, signature);
     }
+    /**
+     * Generates and RSA digital signature with SHA3-512
+     * @param rsa_key_size
+     * @param data_to_sign
+     * @returns RsaDigitalSignatureResult
+     */
     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.");
@@ -30,6 +48,13 @@ class DigitalSignatureSHA256Wrapper {
         }
         return (0, index_1.sha256RsaDigitalSignature)(rsa_key_size, data_to_sign);
     }
+    /**
+     * Verifies a digital signature created with the RSA public key.
+     * @param public_key
+     * @param data_to_verify
+     * @param signature
+     * @returns boolean
+     */
     verifyRSa(public_key, data_to_verify, signature) {
         if (!public_key) {
             throw new Error("Must provide a public key");

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

@@ -2,4 +2,5 @@ import { DigitalSignatureType } from "./digital-signature-factory";
 import { DigitalSignatureFactory } from "./digital-signature-factory";
 import { DigitalSignatureSHA256Wrapper } from "./digital-signaturte-sha-256";
 import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
-export { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType };
+import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
+export { DigitalSignatureFactory, DigitalSignatureSHA256Wrapper, DigitalSignatureSHA512Wrapper, DigitalSignatureType, CASSHAED25519DalekDigitalSignatureResult, CASRSADigitalSignatureResult };

package/lib/hashers/hasher-factory.d.ts

@@ -1,4 +1,9 @@
 import { HasherType } from "./hasher-type";
 export declare class HasherFactory {
+    /**
+     * Get the appropriate hasher wrapper based upon the type based in.
+     * @param type
+     * @returns
+     */
     getHasher(type: HasherType): any;
 }

package/lib/hashers/hasher-factory.js

@@ -3,6 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HasherFactory = void 0;
 const sha_wrapper_1 = require("./sha-wrapper");
 class HasherFactory {
+    /**
+     * Get the appropriate hasher wrapper based upon the type based in.
+     * @param type
+     * @returns
+     */
     getHasher(type) {
         let result = new sha_wrapper_1.SHAWrapper();
         switch (type) {

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

@@ -1,7 +1,29 @@
 import { IHasherBase } from "./hasher-base";
 export declare class SHAWrapper implements IHasherBase {
+    /**
+     * Hashes a byte array with SHA3-512.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash512(dataToHash: number[]): number[];
+    /**
+     * Verifies unsigned data against an SHA3-512 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify512(dataToHash: number[], dataToVerify: number[]): boolean;
+    /**
+     * Hashes a byte array with SHA3-256.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash256(dataToHash: number[]): number[];
+    /**
+     * Verifies unsigned data against an SHA3-256 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify256(dataToHash: number[], dataToVerify: number[]): boolean;
 }

package/lib/hashers/sha-wrapper.js

@@ -3,12 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SHAWrapper = void 0;
 const index_1 = require("../../index");
 class SHAWrapper {
+    /**
+     * Hashes a byte array with SHA3-512.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash512(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha512)(dataToHash);
     }
+    /**
+     * Verifies unsigned data against an SHA3-512 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify512(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
@@ -18,12 +29,23 @@ class SHAWrapper {
         }
         return (0, index_1.sha512Verify)(dataToHash, dataToVerify);
     }
+    /**
+     * Hashes a byte array with SHA3-256.
+     * @param dataToHash
+     * @returns number[]
+     */
     hash256(dataToHash) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");
         }
         return (0, index_1.sha256)(dataToHash);
     }
+    /**
+     * Verifies unsigned data against an SHA3-256 hash.
+     * @param dataToHash
+     * @param dataToVerify
+     * @returns boolean
+     */
     verify256(dataToHash, dataToVerify) {
         if (!dataToHash || dataToHash.length === 0) {
             throw new Error("You must provide an allocated array of data");

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

@@ -4,6 +4,18 @@ export declare class HybridEncryptionWrapper {
     private aesWrapper;
     private rsaWrapper;
     constructor();
+    /**
+     * Encrypts data with RSA/AES hybrid encryption. The data is encrypted with AES-GCM and the AES key is encrypted with the RSA public key.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     encrypt(dataToEncrypt: Array<number>, initalizer: AESRSAHybridInitializer): AesRsaHybridEncryptResult;
+    /**
+     * Decrypts data with RSA/AES hybrid encryption. The RSA private key decrypts the AES key and then the data is decrypted with AES-GCM.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     decrypt(privateKey: string, encryptResult: AesRsaHybridEncryptResult): Array<number>;
 }

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

@@ -11,6 +11,12 @@ class HybridEncryptionWrapper {
         this.aesWrapper = new symmetric_1.AESWrapper();
         this.rsaWrapper = new asymmetric_1.RSAWrapper();
     }
+    /**
+     * Encrypts data with RSA/AES hybrid encryption. The data is encrypted with AES-GCM and the AES key is encrypted with the RSA public key.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     encrypt(dataToEncrypt, initalizer) {
         let encryptedData = (initalizer.aesType === 128)
             ? this.aesWrapper.aes128Encrypt(initalizer.aesKey, initalizer.aesNonce, dataToEncrypt)
@@ -19,6 +25,12 @@ class HybridEncryptionWrapper {
         let result = new aes_rsa_hybird_encrypt_result_1.AesRsaHybridEncryptResult(encryptedData, encryptedAesKey, initalizer.aesType, initalizer.aesNonce);
         return result;
     }
+    /**
+     * Decrypts data with RSA/AES hybrid encryption. The RSA private key decrypts the AES key and then the data is decrypted with AES-GCM.
+     * @param dataToEncrypt
+     * @param initalizer
+     * @returns AesRsaHybridEncryptResult
+     */
     decrypt(privateKey, encryptResult) {
         let plaintextAesKey = this.rsaWrapper.decrypt(privateKey, encryptResult.encryptedAesKey);
         let plaintext = (encryptResult.aesType === 128)