cas-typescript-sdk 1.0.47 → 1.0.49

package/src-ts/digital-signature/digital-signature-factory.ts

@@ -1,25 +0,0 @@
-import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
-import { DigitalSignatureSHA256Wrapper } from "./digital-signaturte-sha-256";
-
-export enum DigitalSignatureType {
-    SHA512 = 1,
-    SHA256 = 2
-}
-
-export class DigitalSignatureFactory {
-
-    /**
-     * Get the appropriate digital signature wrapper based upon the type passed in.
-     * @param type 
-     * @returns 
-     */
-    public static get(type: DigitalSignatureType) {
-        let ds = new DigitalSignatureSHA512Wrapper();
-        switch (type) {
-            case DigitalSignatureType.SHA256:
-                ds = new DigitalSignatureSHA256Wrapper();
-                break;
-        }
-        return ds;
-    }
-}

package/src-ts/digital-signature/digital-signaturte-sha-256.ts

@@ -1,41 +0,0 @@
-import { CASRSADigitalSignatureResult, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature } from "../../index";
-import { IDigitalSignature } from "./digital-signature-base";
-
-export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
-
-    /**
-     * 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 {
-        if (rsa_key_size !== 1024 && rsa_key_size !== 2048 && rsa_key_size !== 4096) {
-            throw new Error("You need to provide an appropriate RSA key size.");
-        }
-        if (data_to_sign?.length === 0) {
-            throw new Error("Must provide allocated data to sign");
-        }
-        return 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: string, data_to_verify: number[], signature: number[]): boolean {
-        if (!public_key) {
-            throw new Error("Must provide a public key");
-        }
-        if (data_to_verify?.length === 0) {
-            throw new Error("Must provide an allocated data to verify");
-        }
-        if (signature?.length === 0) {
-            throw new Error("Must provide an allocated signature");
-        }
-        return sha256RsaVerifyDigitalSignature(public_key, data_to_verify, signature);
-    }
-}

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

@@ -1,43 +0,0 @@
-import { blake2Sha512Verify, blake2Sha256Verify, blake2Sha256, blake2Sha512 } from "../../index";
-import { IHasherBase } from "./hasher-base";
-
-export class Blake2Wrapper implements IHasherBase {
-
-    /**
-     * Hashes the input data using Blake2b 512
-     * @param dataToHash The data to hash
-     * @returns The hashed output
-     */
-    hash512(dataToHash: number[]): number[] {
-        return blake2Sha512(dataToHash);
-    }
-
-    /**
-     * Verifies the input data against the hashed output using Blake2b 512
-     * @param dataToHash The data to hash
-     * @param dataToVerify The data to verify
-     * @returns True if the verification is successful, false otherwise
-     */
-    verify512(dataToHash: number[], dataToVerify: number[]): boolean {
-        return blake2Sha512Verify(dataToHash, dataToVerify);
-    }
-    /**
-     * Hashes the input data using Blake2b 256
-     * @param dataToHash The data to hash
-     * @returns The hashed output
-     */
-
-    hash256(dataToHash: number[]): number[] {
-        return blake2Sha256(dataToHash);
-    }
-    
-    /**
-     * Verifies the input data against the hashed output using Blake2b 256
-     * @param dataToHash The data to hash
-     * @param dataToVerify The data to verify
-     * @returns True if the verification is successful, false otherwise
-     */
-    verify256(dataToHash: number[], dataToVerify: number[]): boolean {
-        return blake2Sha256Verify(dataToHash, dataToVerify);
-    }
-}

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

@@ -1,6 +0,0 @@
-export interface IHasherBase {
-    hash512(dataToHash: number[]): number[];
-    verify512(dataToHash: number[], dataToVerify: number[]): boolean;
-    hash256(dataToHash: number[]): number[];
-    verify256(dataToHash: number[], dataToVerify: number[]): boolean;
-}

package/src-ts/hashers/hasher-factory.ts

@@ -1,19 +0,0 @@
-import { Blake2Wrapper } from "./blake2-wrapper";
-import { HasherType } from "./hasher-type";
-import { SHAWrapper } from "./sha-wrapper";
-
-export class HasherFactory {
-    /**
-     * Get the appropriate hasher wrapper based upon the type based in.
-     * @param type 
-     * @returns 
-     */
-    getHasher(type: HasherType): any {
-        let result: SHAWrapper = new SHAWrapper();
-        switch(type) {
-            case HasherType.Blake2:
-                result = new Blake2Wrapper(); 
-        }
-        return result;
-    }
-}

package/src-ts/hashers/hasher-type.ts

@@ -1,4 +0,0 @@
-export enum HasherType {
-    SHA = 1,
-    Blake2 = 2
-}

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

@@ -1,60 +0,0 @@
-import { sha256, sha256Verify, sha512, sha512Verify } from "../../index";
-import { IHasherBase } from "./hasher-base";
-
-export class SHAWrapper implements IHasherBase {
-    /**
-     * Hashes a byte array with SHA3-512.
-     * @param dataToHash 
-     * @returns number[]
-     */
-    hash512(dataToHash: number[]): number[] {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return sha512(dataToHash);
-    }
-
-    /**
-     * Verifies unsigned data against an SHA3-512 hash.
-     * @param dataToHash 
-     * @param dataToVerify 
-     * @returns boolean
-     */
-    verify512(dataToHash: number[], dataToVerify: number[]): boolean {
-        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 sha512Verify(dataToHash, dataToVerify);
-    }
-
-    /**
-     * Hashes a byte array with SHA3-256.
-     * @param dataToHash 
-     * @returns number[]
-     */
-    hash256(dataToHash: number[]): number[] {
-        if (!dataToHash || dataToHash.length === 0) {
-            throw new Error("You must provide an allocated array of data");
-        }
-        return sha256(dataToHash);
-    }
-
-    /**
-     * Verifies unsigned data against an SHA3-256 hash.
-     * @param dataToHash 
-     * @param dataToVerify 
-     * @returns boolean
-     */
-    verify256(dataToHash: number[], dataToVerify: number[]): boolean {
-        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 sha256Verify(dataToHash, dataToVerify);
-    }
-}

package/src-ts/hybrid/hpke.ts

@@ -1,44 +0,0 @@
-import { hpkeGenerateKeypair, hpkeEncrypt, hpkeDecrypt, generateInfoStr, HpkeKeyResult, HpkeEncryptResult} from "../../index"
-
-export class HpkeWrapper {
-
-    /**
-     * Generate a new HPKE key pair along with an info string
-     * @returns HpkeKeyResult
-     */
-    public generateKeyPair(): HpkeKeyResult {
-        return hpkeGenerateKeypair();
-    }
-
-    /**
-     * Generate a new info string for HPKE
-     * @returns A byte array representing the info string
-     */
-    public generateInfoString(): number[] {
-        return generateInfoStr();
-    }
-
-    /**
-     * Encrypt a message using HPKE
-     * @param plaintext The message to encrypt
-     * @param publicKey The recipient's public key
-     * @param infoStr Additional information to include in the encryption
-     * @returns HpkeEncryptResult
-     */
-    public encrypt(plaintext: number[], publicKey: number[], infoStr: number[]): HpkeEncryptResult {
-        return hpkeEncrypt(plaintext, publicKey, infoStr);
-    }
-
-    /**
-     * Decrypt a message using HPKE
-     * @param ciphertext The encrypted message
-     * @param privateKey The recipient's private key
-     * @param encapsulatedKey The encapsulated key
-     * @param tag The tag
-     * @param infoStr Additional information to include in the decryption
-     * @returns The decrypted message
-     */
-    public decrypt(ciphertext: number[], privateKey: number[], encapsulatedKey: number[], tag: number[], infoStr: number[]): number[] {
-        return hpkeDecrypt(ciphertext, privateKey, encapsulatedKey, tag, infoStr);
-    }
-}

package/src-ts/key_exchange/x25519.ts

@@ -1,23 +0,0 @@
-import { CASx25519SecretPublicKeyResult, x25519DiffieHellman, x25519GenerateSecretAndPublicKey } from "../../index"
-
-export class X25519Wrapper {
-    /**
-     * Generates and secret and public key to be used to create a shared secret with Diffie Hellman.
-     * User should share their public key with the other user and take the other user's public key and they can generate a Shared Secret.
-     * @returns X25519SecretPublicKeyResult
-     */
-    public generateSecretAndPublicKey(): CASx25519SecretPublicKeyResult {
-        return x25519GenerateSecretAndPublicKey();
-    }
-
-    /**
-     * User takes their secret key and the other user's public key to generate a shared secret.
-     * Can be used to derive an AES key over insecure channel.
-     * @param secretKey 
-     * @param publicKey 
-     * @returns Array<number>
-     */
-    public generateSharedSecret(secretKey: Array<number>, publicKey: Array<number>): Array<number> {
-        return x25519DiffieHellman(secretKey, publicKey);
-    }
-}

package/src-ts/message/hmac.ts

@@ -1,26 +0,0 @@
-import { hmacSign, hmacVerify } from "../../index";
-
-export class HmacWrapper {
-    public hmacSignBytes(key: Array<number>, message: Array<number>): Array<number> {
-        if (key?.length === 0) {
-            throw new Error("Must provide an allocated key");
-        }
-        if (message?.length === 0) {
-            throw new Error("Must provide an allocated message");
-        }
-        return hmacSign(key, message);
-    }
-    
-    public hmacVerifyBytes(key: Array<number>, message: Array<number>, signature: Array<number>): boolean {
-        if (key?.length === 0) {
-            throw new Error("Must provide an allocated key");
-        }
-        if (message?.length === 0) {
-            throw new Error("Must provide an allocated message");
-        }
-        if(signature?.length===0) {
-            throw new Error("Must provide an allocated signature");
-        }
-        return hmacVerify(key, message, signature);
-    }
-}

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

@@ -1,31 +0,0 @@
-import { argon2Hash, argon2Verify} from "./../../index";
-import { IPasswordHasherBase } from "./password-hasher-base";
-
-export class Argon2Wrapper implements IPasswordHasherBase {
-  /**
-   * Hashes a password with Argon2
-   * @param password 
-   * @returns string
-   */
-  public hashPassword(password: string): string {
-    if (!password) {
-      throw new Error("You must provide a password to hash with Argon2");
-    }
-    return argon2Hash(password);
-  }
-
-  /**
-   * Verifies that a password is the same as the hashed password with Argon2.
-   * @param hashedPassword 
-   * @param passwordToVerify 
-   * @returns 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",
-      );
-    }
-    return argon2Verify(hashedPassword, passwordToVerify);
-  }
-}

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

@@ -1,35 +0,0 @@
-import { IPasswordHasherBase } from "./password-hasher-base";
-import { bcryptHash, bcryptVerify } from "./../../index";
-
-export class BCryptWrapper implements IPasswordHasherBase {
-
-  /**
-   * Hashes a password with BCrypt
-   * @param password 
-   * @returns string
-   */
-  public hashPassword(password: string): string {
-    if (!password) {
-      throw new Error("You must provide a password to hash with Argon2");
-    }
-    return bcryptHash(password);
-  }
-
-  /**
-   * Verifies that a password is the same as the hashed password with BCrypt.
-   * @param hashedPassword 
-   * @param passwordToVerify 
-   * @returns 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",
-      );
-    }
-    return bcryptVerify(hashedPassword, passwordToVerify);
-  }
-}

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

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

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

@@ -1,25 +0,0 @@
-import { Argon2Wrapper } from "./argon2-wrapper";
-import { BCryptWrapper } from "./bcrypt-wrapper";
-import { PasswordHasherType } from "./password-hasher-type";
-import { ScryptWrapper } from "./scrypt-wrapper";
-
-export class PasswordHasherFactory {
-  /**
-   * Returns the appropriate hasher type based upon the type passed in.
-   * @param type 
-   * @returns 
-   */
-  static getHasher(type: PasswordHasherType): any {
-    // Argon2 by default
-    let hasher = new Argon2Wrapper();
-    switch (type) {
-      case PasswordHasherType.Bcrypt:
-        hasher = new BCryptWrapper();
-        break;
-      case PasswordHasherType.Scrypt:
-        hasher = new ScryptWrapper();
-        break;
-    }
-    return hasher;
-  }
-}

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

@@ -1,5 +0,0 @@
-export enum PasswordHasherType {
-    Bcrypt = 1,
-    Scrypt = 2,
-    Argon2 = 3
-}

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

@@ -1,32 +0,0 @@
-import { scryptHash, scryptVerify} from "../../index";
-import { IPasswordHasherBase } from "./password-hasher-base";
-
-export class ScryptWrapper implements IPasswordHasherBase {
-
-  /**
-   * Hashes a password with SCrypt
-   * @param password 
-   * @returns string
-   */
-  public hashPassword(password: string): string {
-    if (!password) {
-      throw new Error("You must provide a password to hash with Scrypt");
-    }
-    return scryptHash(password);
-  }
-
-  /**
-   * Verifies that a password is the same as the hashed password with SCrypt.
-   * @param hashedPassword 
-   * @param passwordToVerify 
-   * @returns 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",
-      );
-    }
-    return scryptVerify(hashedPassword, passwordToVerify);
-  }
-}

package/src-ts/signature/ed25519-wrapper.ts

@@ -1,36 +0,0 @@
-import {
-  Cased25519KeyPairResult,
-  generateEd25519Keys,
-  signEd25519,
-  verifyEd25519,
-} from "../../index";
-
-export class Ed25519Wrapper {
-  /**
-   * Generates a new Ed25519 key pair
-   */
-  public getKeyPair(): Cased25519KeyPairResult {
-    return generateEd25519Keys();
-  }
-
-  /**
-   * Signs a message with the given Ed25519 private key
-   * @param privateKey The private key to sign the message with
-   * @param message The message to sign
-   * @returns The signature
-   */
-  public signMessage(privateKey: number[], message: number[]): number[] {
-    return signEd25519(privateKey, message);
-  }
-
-  /**
-   * Verifies a signature for a message with the given Ed25519 public key
-   * @param publicKey The public key to verify the signature with
-   * @param message The signed message
-   * @param signature The signature to verify
-   * @returns True if the signature is valid, false otherwise
-   */
-  public verifyMessage(publicKey: number[], message: number[], signature: number[]): boolean {
-    return verifyEd25519(publicKey, message, signature);
-  }
-}

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

@@ -1,72 +0,0 @@
-import {
-  ascon128Decrypt,
-  ascon128Encrypt,
-  ascon128KeyGenerate,
-  ascon128NonceGenerate,
-} from "../../index";
-
-export class AsconWrapper {
-  /**
-   * Generates an Ascon 128 key
-   * @returns Array<number>
-   */
-  ascon128Key(): Array<number> {
-    return ascon128KeyGenerate();
-  }
-
-  /**
-   * Generates and Ascon 128 nonce.
-   * @returns Array<number>
-   */
-  ascon128Nonce(): Array<number> {
-    return ascon128NonceGenerate();
-  }
-
-  /**
-   * Encrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
-   * @param key 
-   * @param nonce 
-   * @param plaintext 
-   * @returns 
-   */
-  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);
-  }
-
-   /**
-   * Decrypts with Ascon 128 using the key and nonce generated from ascon128Key() and ascon128Nonce() respectively.
-   * @param key 
-   * @param nonce 
-   * @param ciphertext 
-   * @returns Array<number>
-   */
-  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/symmetric/aes-wrapper.ts

@@ -1,101 +0,0 @@
-import {
-  aes128Decrypt,
-  aes128Encrypt,
-  aes128Key,
-  aes128KeyFromX25519SharedSecret,
-  aes256Decrypt,
-  aes256Encrypt,
-  aes256Key,
-  aes256KeyFromX25519SharedSecret,
-  aesNonce,
-} from "../../index";
-
-
-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();
-    }
-
-    /**
-     * Generates an 96 bit AES nonce
-     * @returns Array<number>
-     */
-    public generateAESNonce(): Array<number> {
-        return aesNonce();
-    }
-
-    /**
-     * Encrypts with AES 128.
-     * @param aesKey 
-     * @param nonce 
-     * @param plaintext 
-     * @returns Array<number>
-     */
-    public aes128Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
-        return aes128Encrypt(aesKey, nonce, plaintext);
-    }
-
-    /**
-     * Decrypts with AES 128
-     * @param aesKey 
-     * @param nonce 
-     * @param ciphertext 
-     * @returns Array<number>
-     */
-    public aes128Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
-        return aes128Decrypt(aesKey, nonce, ciphertext);
-    }
-
-    /**
-     * Encrypts with AES-256
-     * @param aesKey 
-     * @param nonce 
-     * @param plaintext 
-     * @returns 
-     */
-    public aes256Encrypt(aesKey: Array<number>, nonce: Array<number>, plaintext: Array<number>): Array<number> {
-        return aes256Encrypt(aesKey, nonce, plaintext);
-    }
-
-    /**
-     * Decrypts with AES 256
-     * @param aesKey 
-     * @param nonce 
-     * @param ciphertext 
-     * @returns 
-     */
-    public aes256Decrypt(aesKey: Array<number>, nonce: Array<number>, ciphertext: Array<number>): Array<number> {
-        return aes256Decrypt(aesKey, nonce, ciphertext);
-    }
-
-    /**
-     * Derives an AES-256 key from a X25519 Diffie Hellman shared secret.
-     * @param shared_secret 
-     * @returns 
-     */
-    public aes256KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[] {
-         return aes256KeyFromX25519SharedSecret(shared_secret);
-    }
-
-    /**
-     * Derives an AES-128 key from a X25519 Diffie Hellman shared secret.
-     * @param shared_secret 
-     * @returns 
-     */
-    public aes128KeyNonceX25519DiffieHellman(shared_secret: Array<number>): number[] {
-        return aes128KeyFromX25519SharedSecret(shared_secret);
-   }
-}

package/test-ts/asymmetric.test.spec.ts

@@ -1,15 +0,0 @@
-import { assert } from "chai";
-import { CASRSAKeyPairResult, RSAWrapper } from "..";
-
-describe("Asymmetric Tests", () => {
-    it("RSA 2048 Sign and Verify", () => {
-      const rsaWrapper = new RSAWrapper();
-      const keys: CASRSAKeyPairResult = rsaWrapper.generateKeys(2048);
-      const tohashed: string = "This is my encrypt";
-      const encoder = new TextEncoder();
-      const toSignBytes: Array<number> = Array.from(encoder.encode(tohashed));
-      const signature: Array<number> = rsaWrapper.sign(keys.privateKey, toSignBytes);
-      const verified = rsaWrapper.verify(keys.publicKey, toSignBytes, signature);
-      assert.isTrue(verified);
-    });
-});