cas-typescript-sdk 1.0.47 → 1.0.48

package/src/symmetric/aes.rs

@@ -1,71 +0,0 @@
-use cas_lib::symmetric::{aes::{CASAES128, CASAES256}, cas_symmetric_encryption::{CASAES128Encryption, CASAES256Encryption}};
-use napi_derive::napi;
-
-#[napi]
-pub fn aes_nonce() -> Vec<u8> {
-    return <CASAES256 as CASAES256Encryption>::generate_nonce().to_vec();
-}
-
-#[napi]
-pub fn aes128_key() -> Vec<u8> {
-    return <CASAES128 as CASAES128Encryption>::generate_key().to_vec();
-}
-
-#[napi]
-pub fn aes256_key() -> Vec<u8> {
-    return <CASAES256 as CASAES256Encryption>::generate_key().to_vec();
-}
-
-#[napi]
-pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    <CASAES128 as CASAES128Encryption>::encrypt_plaintext(aes_key, nonce, plaintext)
-}
-
-#[napi]
-pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    <CASAES128 as CASAES128Encryption>::decrypt_ciphertext(aes_key, nonce, ciphertext)
-}
-
-#[napi]
-pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    <CASAES256 as CASAES256Encryption>::encrypt_plaintext(aes_key, nonce, plaintext)
-}
-
-#[napi]
-pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    <CASAES256 as CASAES256Encryption>::decrypt_ciphertext(aes_key, nonce, ciphertext)
-}
-
-#[napi]
-pub fn aes_256_key_from_x25519_shared_secret(
-    shared_secret: Vec<u8>,
-) -> Vec<u8> {
-    return <CASAES256 as CASAES256Encryption>::key_from_x25519_shared_secret(shared_secret).into();
-}
-
-#[napi]
-pub fn aes_128_key_from_x25519_shared_secret(
-    shared_secret: Vec<u8>,
-) -> Vec<u8> {
-    return <CASAES128 as CASAES128Encryption>::key_from_x25519_shared_secret(shared_secret).into();
-}
-
-#[test]
-fn aes128_encrypt_decrypt_test() {
-    let aes_key = aes128_key();
-    let nonce = aes_nonce();
-    let plaintext = b"WelcomeHome".to_vec();
-    let ciphertext = aes128_encrypt(aes_key.clone(), nonce.clone(), plaintext.clone());
-    let decrypted_plaintext = aes128_decrypt(aes_key, nonce, ciphertext);
-    assert_eq!(decrypted_plaintext, plaintext)
-}
-
-#[test]
-fn aes256_encrypt_decrypt_test() {
-    let aes_key = aes256_key();
-    let nonce = aes_nonce();
-    let plaintext = b"WelcomeHome".to_vec();
-    let ciphertext = aes256_encrypt(aes_key.clone(), nonce.clone(), plaintext.clone());
-    let decrypted_plaintext = aes256_decrypt(aes_key, nonce, ciphertext);
-    assert_eq!(decrypted_plaintext, plaintext)
-}

package/src-ts/asymmetric/RSAWrapper.ts

@@ -1,59 +0,0 @@
-import { CASRSAKeyPairResult, generateRsaKeys, signRsa, verifyRsa } from "../../index";
-
-export class RSAWrapper {
-
-  /**
-   * Generates an RSA key pair based of parameter sent in 1024, 2048, and 4096 are supported.
-   * @param keySize 
-   * @returns CASRSAKeyPairResult
-   */
-  public generateKeys(keySize: number): CASRSAKeyPairResult {
-    if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
-        throw new Error("You must provide an appropriate key size to generate RSA keys");
-    }
-    return generateRsaKeys(keySize);
-  }
-
-  /**
-   * Encrypts a plaintext byte array with a RSA public key
-   * @param publicKey 
-   * @param plaintext 
-   * @returns Array<number>
-   */
-
-  /**
-   * Signs a byte array with an RSA private key for verification.
-   * @param privateKey 
-   * @param hash 
-   * @returns Array<number>
-   */
-  public sign(privateKey: string, dataToSign: Array<number>): Array<number> {
-    if (!privateKey) {
-      throw new Error("You must provide a private key to sign with RSA");
-    }
-    if (!dataToSign || dataToSign.length === 0) {
-      throw new Error("You must provide an allocated hash to sign with RSA");
-    }
-    return signRsa(privateKey, dataToSign);
-  }
-
-  /**
-   * Verifies signed data by the corresponding private key with an RSA public key.
-   * @param publicKey 
-   * @param hash 
-   * @param signature 
-   * @returns boolean
-   */
-  public verify(publicKey: string, hash: Array<number>, signature: Array<number>): boolean {
-    if (!publicKey) {
-      throw new Error("You must provide a public key to verify with RSA");
-    }
-    if (!hash || hash.length === 0) {
-      throw new Error("You must provide an allocated hash to verify with RSA");
-    }
-    if (!signature || signature.length === 0) {
-      throw new Error("You must provide and allocated signature to verify with RSA");
-    }
-    return verifyRsa(publicKey, hash, signature);
-  }
-}

package/src-ts/digital-signature/digital-siganture-sha-512.ts

@@ -1,40 +0,0 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
-import { IDigitalSignature } from "./digital-signature-base";
-
-export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
-    /**
-     * 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 {
-        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 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: 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 sha512RsaVerifyDigitalSignature(public_key, data_to_verify, signature);
-    }
-}

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

@@ -1,6 +0,0 @@
-import { CASRSADigitalSignatureResult, CASSHAED25519DalekDigitalSignatureResult } from "../../index";
-
-export interface IDigitalSignature {
-    createRsa(rsa_key_size: number, data_to_sign: Array<number>): CASRSADigitalSignatureResult;
-    verifyRSa(public_key: string, data_to_verify: Array<number>, signature: Array<number>): boolean;
-}

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