cas-typescript-sdk 1.0.47 → 1.0.48

package/src/asymmetric/cas_ed25519.rs

@@ -1,35 +0,0 @@
-
-use cas_lib::signatures::cas_ed25519::{Ed25519ByteKeyPair, Ed25519ByteSignature};
-use cas_lib::signatures::ed25519::{get_ed25519_key_pair, ed25519_sign_with_key_pair, ed25519_verify_with_public_key};
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASED25519KeyPairResult {
-    pub private_key: Vec<u8>,
-    pub public_key: Vec<u8>,
-}
-
-impl From<Ed25519ByteKeyPair> for CASED25519KeyPairResult {
-    fn from(result: Ed25519ByteKeyPair) -> Self {
-        CASED25519KeyPairResult {
-            private_key: result.key_pair,
-            public_key: result.public_key
-        }
-    }
-}
-
-#[napi]
-pub fn generate_ed25519_keys() -> CASED25519KeyPairResult {
-    return get_ed25519_key_pair().into();
-}
-
-#[napi]
-pub fn sign_ed25519(private_key: Vec<u8>, message: Vec<u8>) -> Vec<u8> {
-    let signature = ed25519_sign_with_key_pair(private_key, message);
-    signature.signature // assuming Ed25519ByteSignature has a field named `signature: Vec<u8>`
-}
-
-#[napi]
-pub fn verify_ed25519(public_key: Vec<u8>, message: Vec<u8>, signature: Vec<u8>) -> bool {
-    return ed25519_verify_with_public_key(public_key, signature, message);
-}

package/src/asymmetric/cas_rsa.rs

@@ -1,32 +0,0 @@
-use cas_lib::asymmetric::{cas_rsa::CASRSA, types::{CASRSAEncryption, RSAKeyPairResult}};
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASRSAKeyPairResult {
-    pub private_key: String,
-    pub public_key: String,
-}
-
-impl From<RSAKeyPairResult> for CASRSAKeyPairResult {
-    fn from(result: RSAKeyPairResult) -> Self {
-        CASRSAKeyPairResult {
-            private_key: result.private_key,
-            public_key: result.public_key,
-        }
-    }
-}
-
-#[napi]
-pub fn generate_rsa_keys(key_size: u32) -> CASRSAKeyPairResult {
-    return CASRSA::generate_rsa_keys(key_size as usize).into();
-}
-
-#[napi]
-pub fn sign_rsa(private_key: String, hash: Vec<u8>) -> Vec<u8> {
-    return CASRSA::sign(private_key, hash);
-}
-
-#[napi]
-pub fn verify_rsa(public_key: String, hash: Vec<u8>, signature: Vec<u8>) -> bool {
-    return CASRSA::verify(public_key, hash, signature);
-}

package/src/digital_signature/sha_256_rsa.rs

@@ -1,40 +0,0 @@
-use cas_lib::digital_signature::{cas_digital_signature_rsa::RSADigitalSignature, sha_256_rsa::SHA256RSADigitalSignature};
-use napi_derive::napi;
-
-use super::types::CASRSADigitalSignatureResult;
-
-#[napi]
-pub fn sha_256_rsa_digital_signature(
-    rsa_key_size: u32,
-    data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
-    return <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(rsa_key_size, data_to_sign).into();
-}
-
-#[napi]
-pub fn sha_256_rsa_verify_digital_signature(
-    public_key: String,
-    data_to_verify: Vec<u8>,
-    signature: Vec<u8>,
-) -> bool {
-    return <SHA256RSADigitalSignature as RSADigitalSignature>::verify_rsa(public_key, data_to_verify, signature);
-}
-
-#[test]
-fn sha_256_rsa_digital_signature_test() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(key_size, data_to_sign.clone()).into();
-    let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
-    assert_eq!(is_verified, true);
-}
-
-#[test]
-fn sha_256_rsa_digital_signature_fail_test() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = <SHA256RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(key_size, data_to_sign.clone()).into();
-    let new_data = b"NOtTheOriginalData".to_vec();
-    let is_verified: bool = SHA256RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
-    assert_eq!(is_verified, false);
-}

package/src/digital_signature/sha_512_rsa.rs

@@ -1,40 +0,0 @@
-use cas_lib::digital_signature::{cas_digital_signature_rsa::RSADigitalSignature, sha_512_rsa::SHA512RSADigitalSignature};
-use napi_derive::napi;
-
-use super::types::CASRSADigitalSignatureResult;
-
-#[napi]
-pub fn sha_512_rsa_digital_signature(
-    rsa_key_size: u32,
-    data_to_sign: Vec<u8>,
-) -> CASRSADigitalSignatureResult {
-    return <SHA512RSADigitalSignature as RSADigitalSignature>::digital_signature_rsa(rsa_key_size, data_to_sign).into();
-}
-
-#[napi]
-pub fn sha_512_rsa_verify_digital_signature(
-    public_key: String,
-    data_to_verify: Vec<u8>,
-    signature: Vec<u8>,
-) -> bool {
-    return <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(public_key, data_to_verify, signature);
-}
-
-#[test]
-fn sha_512_rsa_digital_signature_test() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()).into();
-    let is_verified: bool = <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(signature_result.public_key, data_to_sign, signature_result.signature);
-    assert_eq!(is_verified, true);
-}
-
-#[test]
-fn sha_512_rsa_digital_signature_fail_test() {
-    let key_size: u32 = 1024;
-    let data_to_sign = b"GetTheseBytes".to_vec();
-    let signature_result: CASRSADigitalSignatureResult = SHA512RSADigitalSignature::digital_signature_rsa(key_size, data_to_sign.clone()).into();
-    let new_data = b"NOtTheOriginalData".to_vec();
-    let is_verified: bool = <SHA512RSADigitalSignature as RSADigitalSignature>::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
-    assert_eq!(is_verified, false);
-}

package/src/digital_signature/types.rs

@@ -1,34 +0,0 @@
-use cas_lib::digital_signature::cas_digital_signature_rsa::{RSADigitalSignatureResult, SHAED25519DalekDigitalSignatureResult};
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct CASSHAED25519DalekDigitalSignatureResult {
-    pub public_key: Vec<u8>,
-    pub signature: Vec<u8>
-}
-
-impl From<SHAED25519DalekDigitalSignatureResult> for CASSHAED25519DalekDigitalSignatureResult {
-    fn from(value: SHAED25519DalekDigitalSignatureResult) -> Self {
-        CASSHAED25519DalekDigitalSignatureResult {
-            public_key: value.public_key.to_vec(),
-            signature: value.signature.to_vec()
-        }
-    }
-}
-
-#[napi(constructor)]
-pub struct CASRSADigitalSignatureResult {
-    pub public_key: String,
-    pub private_key: String,
-    pub signature: Vec<u8>,
-}
-
-impl From<RSADigitalSignatureResult> for CASRSADigitalSignatureResult {
-    fn from(value: RSADigitalSignatureResult) -> Self {
-        CASRSADigitalSignatureResult {
-            public_key: value.public_key,
-            private_key: value.private_key,
-            signature: value.signature
-        }
-    }
-}

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