cas-typescript-sdk 1.0.46 → 1.0.48

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/hybrid/index.ts

@@ -1,3 +0,0 @@
-import { HpkeWrapper } from "./hpke";
-
-export { HpkeWrapper };

package/src-ts/index.ts

@@ -1,10 +0,0 @@
-export * from "./password-hashers/index";
-export * from "./hashers/index";
-export * from "./key_exchange/index";
-export * from "./symmetric/index";
-export * from "./asymmetric/index";
-export * from "./digital-signature";
-export * from "./sponges/index";
-export * from "./message/index";
-export * from "./signature/index";
-export * from "./hybrid/index";

package/src-ts/key_exchange/index.ts

@@ -1,4 +0,0 @@
-import { CASx25519SecretPublicKeyResult } from "../../index";
-import { X25519Wrapper } from "./x25519";
-
-export { X25519Wrapper, CASx25519SecretPublicKeyResult };

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/message/index.ts

@@ -1,3 +0,0 @@
-import { HmacWrapper } from "./hmac";
-
-export { HmacWrapper };

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/index.ts

@@ -1,14 +0,0 @@
-import { Argon2Wrapper } from "./argon2-wrapper";
-import { BCryptWrapper } from "./bcrypt-wrapper";
-import { ScryptWrapper } from "./scrypt-wrapper";
-
-import { PasswordHasherType } from "./password-hasher-type";
-import { PasswordHasherFactory } from "./password-hasher-factory";
-
-export {
-  Argon2Wrapper,
-  BCryptWrapper,
-  PasswordHasherFactory,
-  PasswordHasherType,
-  ScryptWrapper,
-};

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/signature/index.ts

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

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/sponges/index.ts

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

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/src-ts/symmetric/index.ts

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

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

package/test-ts/digital-signature.test.spec.ts

@@ -1,70 +0,0 @@
-import { assert } from "chai";
-import { DigitalSignatureFactory, DigitalSignatureType } from "../src-ts/digital-signature/digital-signature-factory";
-import { CASRSADigitalSignatureResult } from "../index";
-import { Ed25519Wrapper } from "../src-ts/signature/ed25519-wrapper";
-
-describe("Digital Signature", () => {
-    it("SHA 512 RSA pass", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-        const tohashed: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
-        assert.equal(verify, true);
-    });
-
-    it("SHA 512 RSA fails", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA512)
-        const tohashed: string = "This is my array to encrypt";
-        const notOriginal: string = "This is not a fun time";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
-        assert.equal(verify, false);
-    });
-
-    it("SHA 256 RSA pass", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
-        const tohashed: string = "This is my array to encrypt";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(2048, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, tohashBytes, dsResult.signature);
-        assert.equal(verify, true);
-    });
-
-    it("SHA 256 RSA fails", () => {
-        const shaDsWrapper = DigitalSignatureFactory.get(DigitalSignatureType.SHA256)
-        const tohashed: string = "This is my array to encrypt";
-        const notOriginal: string = "This is not a fun time";
-        const encoder = new TextEncoder();
-        const tohashBytes: Array<number> = Array.from(encoder.encode(tohashed));
-        const badBytes: Array<number> = Array.from(encoder.encode(notOriginal));
-        const dsResult: CASRSADigitalSignatureResult = shaDsWrapper.createRsa(4096, tohashBytes);
-        const verify = shaDsWrapper.verifyRSa(dsResult.publicKey, badBytes, dsResult.signature);
-        assert.equal(verify, false);
-    });
-
-
-    it("ED25519 Sign and Verify", () => {
-        const ed25519 = new Ed25519Wrapper();
-        const keyPair = ed25519.getKeyPair();
-        const message = Array.from(new TextEncoder().encode("This is a test message"));
-        const signature = ed25519.signMessage(keyPair.privateKey, message);
-        const isValid = ed25519.verifyMessage(keyPair.publicKey, message, signature);
-        assert.equal(isValid, true);
-    });
-
-    it("ED25519 Verify Fails with Wrong Message", () => {
-        const ed25519 = new Ed25519Wrapper();
-        const keyPair = ed25519.getKeyPair();
-        const message = Array.from(new TextEncoder().encode("This is a test message"));
-        const wrongMessage = Array.from(new TextEncoder().encode("This is a different message"));
-        const signature = ed25519.signMessage(keyPair.privateKey, message);
-        const isValid = ed25519.verifyMessage(keyPair.publicKey, wrongMessage, signature);
-        assert.equal(isValid, false);
-    });
-});