cas-typescript-sdk 1.0.47 → 1.0.49

package/src/hashers/blake2.rs

@@ -1,60 +0,0 @@
-use cas_lib::hashers::{blake2::CASBlake2, cas_hasher::CASHasher};
-use napi_derive::napi;
-
-#[napi]
-pub fn blake2_sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return CASBlake2::hash_512(data_to_hash);
-}
-
-#[napi]
-pub fn blake2_sha_512_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return CASBlake2::verify_512(data_to_hash, data_to_verify);
-}
-
-#[napi]
-pub fn blake2_sha_256(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return CASBlake2::hash_256(data_to_hash);
-}
-
-#[napi]
-pub fn blake2_sha_256_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return CASBlake2::verify_256(data_to_hash, data_to_verify);
-}
-
-#[test]
-pub fn blake2_sha_512_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = blake2_sha_512(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn blake2_sha_512_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = blake2_sha_512(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, blake2_sha_512_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn blake2_sha_256_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = blake2_sha_256(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn blake2_sha_256_verify_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = blake2_sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
-    assert_ne!(true, blake2_sha_256_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn blake2_sha_256_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = blake2_sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, blake2_sha_256_verify(data_to_hash, data_to_verify));
-}

package/src/hashers/sha.rs

@@ -1,68 +0,0 @@
-use cas_lib::hashers::{cas_hasher::CASHasher, sha::CASSHA};
-use napi_derive::napi;
-
-#[napi]
-pub fn sha_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return <CASSHA as CASHasher>::hash_512(data_to_hash);
-}
-
-#[napi]
-pub fn sha_512_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return <CASSHA as CASHasher>::verify_512(data_to_hash, data_to_verify);
-}
-
-#[napi]
-pub fn sha_256(data_to_hash: Vec<u8>) -> Vec<u8> {
-    return <CASSHA as CASHasher>::hash_256(data_to_hash);
-}
-
-#[napi]
-pub fn sha_256_verify(data_to_hash: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-    return <CASSHA as CASHasher>::verify_256(data_to_hash, data_to_verify);
-}
-
-#[test]
-pub fn sha_512_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_512(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn sha_512_verify_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_512(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
-    assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn sha_512_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = sha_512(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, sha_512_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn sha_256_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let hashed_data = sha_256(data_to_hash.clone());
-    assert_ne!(true, hashed_data.eq(&data_to_hash));
-}
-
-#[test]
-pub fn sha_256_verify_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash".as_bytes().to_vec();
-    assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
-}
-
-#[test]
-pub fn sha_256_verify_fail_test() {
-    let data_to_hash = "NotMyDataToHash".as_bytes().to_vec();
-    let _hashed_data = sha_256(data_to_hash.clone());
-    let data_to_verify = "NotMyDataToHash2".as_bytes().to_vec();
-    assert_ne!(true, sha_256_verify(data_to_hash, data_to_verify));
-}

package/src/hybrid/hpke.rs

@@ -1,63 +0,0 @@
-use crate::hybrid::types::{HpkeEncryptResult, HpkeKeyResult};
-use cas_lib::hybrid::{cas_hybrid::CASHybrid, hpke::CASHPKE};
-use napi_derive::napi;
-
-#[napi]
-pub fn hpke_generate_keypair() -> HpkeKeyResult {
-    let (secret_key, public_key, info_str) = <CASHPKE as CASHybrid>::generate_key_pair();
-    HpkeKeyResult {
-        public_key: public_key,
-        secret_key: secret_key,
-        info_str: info_str
-    }
-}
-
-#[napi]
-pub fn generate_info_str() -> Vec<u8> {
-    return <CASHPKE as CASHybrid>::generate_info_str();
-}
-
-#[napi]
-pub fn hpke_encrypt(
-    plaintext: Vec<u8>,
-    public_key: Vec<u8>,
-    info_str: Vec<u8>,
-) -> HpkeEncryptResult {
-    let encrypt_result: (Vec<u8>, Vec<u8>, Vec<u8>) =
-        <CASHPKE as CASHybrid>::encrypt(plaintext, public_key, info_str);
-    return HpkeEncryptResult {
-        tag: encrypt_result.2,
-        ciphertext: encrypt_result.1,
-        encapsulated_key: encrypt_result.0,
-    }
-}
-
-#[napi]
-pub fn hpke_decrypt(
-    ciphertext: Vec<u8>,
-    private_key: Vec<u8>,
-    encapped_key: Vec<u8>,
-    tag: Vec<u8>,
-    info_str: Vec<u8>,
-) -> Vec<u8> {
-    return <CASHPKE as CASHybrid>::decrypt(ciphertext, private_key, encapped_key, tag, info_str);
-}
-
-#[test]
-pub fn hpke_encrypt_decrypt_test() {
-    let hpke_keypair = hpke_generate_keypair();
-    let plaintext = "This is a secret message".as_bytes().to_vec();
-    let encrypt_result = hpke_encrypt(
-        plaintext.clone(),
-        hpke_keypair.public_key,
-        hpke_keypair.info_str.clone(),
-    );
-    let decrypted_plaintext = hpke_decrypt(
-        encrypt_result.ciphertext,
-        hpke_keypair.secret_key,
-        encrypt_result.encapsulated_key,
-        encrypt_result.tag,
-        hpke_keypair.info_str,
-    );
-    assert_eq!(plaintext, decrypted_plaintext);
-}

package/src/hybrid/types.rs

@@ -1,15 +0,0 @@
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct HpkeKeyResult {
-    pub public_key: Vec<u8>,
-    pub secret_key: Vec<u8>,
-    pub info_str: Vec<u8>
-}
-
-#[napi(constructor)]
-pub struct HpkeEncryptResult {
-    pub tag: Vec<u8>,
-    pub ciphertext: Vec<u8>,
-    pub encapsulated_key: Vec<u8>,
-}

package/src/key_exchange/types.rs

@@ -1,17 +0,0 @@
-use cas_lib::key_exchange::x25519::X25519SecretPublicKeyResult;
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASx25519SecretPublicKeyResult {
-    pub public_key: Vec<u8>,
-    pub secret_key: Vec<u8>,
-}
-
-impl From<X25519SecretPublicKeyResult> for CASx25519SecretPublicKeyResult {
-    fn from(value: X25519SecretPublicKeyResult) -> Self {
-        CASx25519SecretPublicKeyResult {
-            public_key: value.public_key,
-            secret_key: value.secret_key
-        }
-    }
-}

package/src/key_exchange/x25519.rs

@@ -1,25 +0,0 @@
-use cas_lib::key_exchange::{cas_key_exchange::CASKeyExchange, x25519::X25519};
-use napi_derive::napi;
-
-use super::types::CASx25519SecretPublicKeyResult;
-
-
-#[napi]
-pub fn x25519_generate_secret_and_public_key() -> CASx25519SecretPublicKeyResult {
-    return <X25519 as CASKeyExchange>::generate_secret_and_public_key().into();
-}
-
-#[napi]
-pub fn x25519_diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8> {
-    return <X25519 as CASKeyExchange>::diffie_hellman(my_secret_key, users_public_key).to_vec();
-}
-
-#[test]
-pub fn x25519_diffie_hellman_test() {
-    let alice = x25519_generate_secret_and_public_key();
-    let bob = x25519_generate_secret_and_public_key();
-
-    let alice_shared_secret = x25519_diffie_hellman(alice.secret_key, bob.public_key);
-    let bob_shared_secret = x25519_diffie_hellman(bob.secret_key, alice.public_key);
-    assert_eq!(true, alice_shared_secret.eq(&bob_shared_secret));
-}

package/src/lib.rs

@@ -1,47 +0,0 @@
-use zeroizing_alloc::ZeroAlloc;
-
-#[global_allocator]
-static ALLOC: ZeroAlloc<std::alloc::System> = ZeroAlloc(std::alloc::System);
-mod password_hashers {
-    pub mod argon2;
-    pub mod bcrypt;
-    pub mod scrypt;
-}
-
-mod hashers {
-    pub mod sha;
-    pub mod blake2;
-}
-
-mod key_exchange {
-    pub mod x25519;
-    mod types;
-}
-
-mod symmetric {
-    pub mod aes;
-}
-
-mod asymmetric {
-    pub mod cas_rsa;
-    pub mod cas_ed25519;
-}
-
-mod digital_signature {
-    pub mod sha_512_rsa;
-    pub mod sha_256_rsa;
-    mod types;
-}
-
-mod sponges {
-    pub mod ascon_aead;
-}
-
-mod message {
-    pub mod hmac;
-}
-
-mod hybrid {
-    pub mod hpke;
-    pub mod types;
-}

package/src/message/hmac.rs

@@ -1,21 +0,0 @@
-use cas_lib::message::{cas_hmac::CASHMAC, hmac::HMAC};
-use napi_derive::napi;
-
-#[napi]
-pub fn hmac_sign(key: Vec<u8>, message: Vec<u8>) -> Vec<u8> {
-    return <HMAC as CASHMAC>::sign(key, message);
-}
-
-#[napi]
-pub fn hmac_verify(key: Vec<u8>, message: Vec<u8>, signature: Vec<u8>) -> bool {
-    return <HMAC as CASHMAC>::verify(key, message, signature);
-}
-
-#[test]
-fn hmac_sign_and_verify_test() {
-    let key = b"ThisIsMyKeyForHmac".to_vec();
-    let message = b"ThisIsMyMessageToSign".to_vec();
-    let signature = hmac_sign(key.clone(), message.clone());
-    let result = hmac_verify(key, message, signature);
-    assert_eq!(true, result);
-}

package/src/password_hashers/argon2.rs

@@ -1,37 +0,0 @@
-
-use napi_derive::napi;
-use cas_lib::password_hashers::argon2::CASArgon;
-
-#[napi]
-pub fn argon2_hash(password: String) -> String {
-    return CASArgon::hash_password(password);
-}
-
-#[napi]
-pub fn argon2_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return CASArgon::verify_password(hashed_password, password_to_verify);
-}
-
-#[test]
-pub fn argon2_hash_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = argon2_hash(password.clone());
-    assert_ne!(password, hashed);
-}
-
-#[test]
-pub fn argon2_verify_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = argon2_hash(password.clone());
-    let verified = argon2_verify(hashed, password);
-    assert_eq!(true, verified);
-}
-
-#[test]
-pub fn argon2_verify_fail_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = argon2_hash(password.clone());
-    let verified = "Nope".to_string();
-    let verified = argon2_verify(hashed, verified);
-    assert_eq!(false, verified);
-}

package/src/password_hashers/bcrypt.rs

@@ -1,37 +0,0 @@
-use cas_lib::password_hashers::bcrypt::CASBCrypt;
-use cas_lib::password_hashers::cas_password_hasher::CASPasswordHasher;
-use napi_derive::napi;
-
-#[napi]
-pub fn bcrypt_hash(password_to_hash: String) -> String {
-    return <CASBCrypt as CASPasswordHasher>::hash_password(password_to_hash);
-}
-
-#[napi]
-pub fn bcrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASBCrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-}
-
-#[test]
-pub fn bcrypt_hash_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = bcrypt_hash(password.clone());
-    assert_ne!(password, hashed);
-}
-
-#[test]
-pub fn bcrypt_verify_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = bcrypt_hash(password.clone());
-    let verified = bcrypt_verify(hashed, password);
-    assert_eq!(true, verified);
-}
-
-#[test]
-pub fn bcrypt_verify_fail_test() {
-    let password = "ThisIsNotMyPasswolrd".to_string();
-    let hashed = bcrypt_hash(password.clone());
-    let verified = "nope".to_string();
-    let verified = bcrypt_verify(hashed, verified);
-    assert_eq!(false, verified);
-}

package/src/password_hashers/scrypt.rs

@@ -1,36 +0,0 @@
-use cas_lib::password_hashers::{cas_password_hasher::CASPasswordHasher, scrypt::CASScrypt};
-use napi_derive::napi;
-
-#[napi]
-pub fn scrypt_hash(password_to_hash: String) -> String {
-    return <CASScrypt as CASPasswordHasher>::hash_password(password_to_hash);
-}
-
-#[napi]
-pub fn scrypt_verify(hashed_password: String, password_to_verify: String) -> bool {
-    return <CASScrypt as CASPasswordHasher>::verify_password(hashed_password, password_to_verify);
-}
-
-#[test]
-pub fn scrypt_hash_test() {
-    let password = "BadPassword".to_string();
-    let hashed_password = scrypt_hash(password.clone());
-    assert_ne!(password, hashed_password);
-}
-
-#[test]
-pub fn scrypt_verify_test() {
-    let password = "BadPassword".to_string();
-    let hashed_password = scrypt_hash(password.clone());
-    let verified = scrypt_verify(hashed_password, password);
-    assert_eq!(true, verified);
-}
-
-#[test]
-pub fn scrypt_verify_fail_test() {
-    let password = "BadPassword".to_string();
-    let hashed_password = scrypt_hash(password.clone());
-    let verified = "Nope".to_string();
-    let verified = scrypt_verify(hashed_password, verified);
-    assert_eq!(false, verified);
-}

package/src/sponges/ascon_aead.rs

@@ -1,66 +0,0 @@
-
-use cas_lib::sponges::{ascon_aead::AsconAead, cas_ascon_aead::CASAsconAead};
-use napi_derive::napi;
-
-#[napi]
-pub fn ascon128_key_generate() -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::generate_key().to_vec();
-}
-
-#[test]
-fn test_ascon128_key_generate() {
-    let key = ascon128_key_generate();
-    assert_eq!(key.len(), 16);
-}
-
-#[napi]
-pub fn ascon128_nonce_generate() -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::generate_nonce().to_vec();
-}
-
-#[test]
-pub fn test_ascon128_nonce_generate() {
-    let nonce = ascon128_nonce_generate();
-    assert_eq!(nonce.len(), 16);
-}
-
-#[napi]
-pub fn ascon128_encrypt(key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::encrypt(key, nonce, plaintext);
-}
-
-#[test]
-pub fn test_ascon128_encrypt() {
-    let key = <AsconAead as CASAsconAead>::generate_key();
-    let nonce = <AsconAead as CASAsconAead>::generate_nonce();
-    let plaintext = b"Hello, World!";
-    let ciphertext = ascon128_encrypt(
-        key.clone().to_vec(),
-        nonce.clone().to_vec(),
-        plaintext.to_vec(),
-    );
-    assert_ne!(ciphertext, plaintext.to_vec());
-}
-
-#[napi]
-pub fn ascon128_decrypt(key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return <AsconAead as CASAsconAead>::decrypt(key, nonce, ciphertext);
-}
-
-#[test]
-pub fn test_ascon128_decrypt() {
-    let key = <AsconAead as CASAsconAead>::generate_key();
-    let nonce = <AsconAead as CASAsconAead>::generate_nonce();
-    let plaintext = b"Hello, World!";
-    let ciphertext = ascon128_encrypt(
-        key.clone().to_vec(),
-        nonce.clone().to_vec(),
-        plaintext.to_vec(),
-    );
-    let decrypted = ascon128_decrypt(
-        key.clone().to_vec(),
-        nonce.clone().to_vec(),
-        ciphertext.clone(),
-    );
-    assert_eq!(decrypted, plaintext.to_vec());
-}

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