cas-typescript-sdk 1.0.14 → 1.0.16

package/src/password_hashers/scrypt.rs

@@ -1,56 +1,61 @@
-use napi_derive::napi;
-
-use scrypt::{
-    password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
-    Scrypt,
-};
-
-use super::cas_password_hasher::CASPasswordHasher;
-
-pub struct CASScrypt;
-
-impl CASPasswordHasher for CASScrypt {
-    fn hash_password(password_to_hash: String) -> String {
-        let salt = SaltString::generate(&mut OsRng);
-        return Scrypt.hash_password(password_to_hash.as_bytes(), &salt).unwrap().to_string();
-    }
-
-    fn verify_password(hashed_password: String, password_to_verify: String) -> bool {
-        let parsed_hash = PasswordHash::new(&hashed_password).unwrap();
-        return Scrypt.verify_password(password_to_verify.as_bytes(), &parsed_hash).is_ok();
-    }
-}
-
-#[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);
-}
+use napi_derive::napi;
+
+use scrypt::{
+    password_hash::{rand_core::OsRng, PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
+    Scrypt,
+};
+
+use super::cas_password_hasher::CASPasswordHasher;
+
+pub struct CASScrypt;
+
+impl CASPasswordHasher for CASScrypt {
+    fn hash_password(password_to_hash: String) -> String {
+        let salt = SaltString::generate(&mut OsRng);
+        return Scrypt
+            .hash_password(password_to_hash.as_bytes(), &salt)
+            .unwrap()
+            .to_string();
+    }
+
+    fn verify_password(hashed_password: String, password_to_verify: String) -> bool {
+        let parsed_hash = PasswordHash::new(&hashed_password).unwrap();
+        return Scrypt
+            .verify_password(password_to_verify.as_bytes(), &parsed_hash)
+            .is_ok();
+    }
+}
+
+#[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/symmetric/aes.rs

@@ -1,151 +1,155 @@
-use aes_gcm::Key;
-use napi_derive::napi;
-use rand::rngs::OsRng;
-use rand::{RngCore, SeedableRng};
-use rand_chacha::ChaCha20Rng;
-
-use aes_gcm::{
-    aead::{generic_array::GenericArray, Aead},
-    Aes256Gcm, Aes128Gcm, KeyInit, Nonce
-};
-
-use super::cas_symmetric_encryption::{AesKeyFromX25519SharedSecret, CASAESEncryption};
-pub struct CASAES128;
-pub struct CASAES256;
-
-impl CASAESEncryption for CASAES256 {
-    fn generate_key() -> Vec<u8> {
-        return Aes256Gcm::generate_key(&mut OsRng).to_vec();
-    }
-
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes256Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes256Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
-        plaintext
-    }
-
-    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
-        let aes_key = Key::<Aes256Gcm>::from_slice(&shared_secret);
-        let mut aes_nonce: [u8; 12] = Default::default();
-        aes_nonce.copy_from_slice(&shared_secret[..12]);
-        let result = AesKeyFromX25519SharedSecret {
-            aes_key: aes_key.to_vec(),
-            aes_nonce: aes_nonce.to_vec()
-        };
-        result
-    }
-}
-
-impl CASAESEncryption for CASAES128 {
-    fn generate_key() -> Vec<u8> {
-        return Aes128Gcm::generate_key(&mut OsRng).to_vec();
-    }
-
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes128Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-        let key = GenericArray::from_slice(&aes_key);
-        let mut cipher = Aes128Gcm::new(&key);
-        let nonce = Nonce::from_slice(&nonce);
-        let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
-        plaintext
-    }
-
-    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
-        let mut aes_key: [u8; 16] = Default::default();
-        aes_key.copy_from_slice(&shared_secret[..16]);
-        let aes_key_slice = Key::<Aes128Gcm>::from_slice(&aes_key);
-        let mut aes_nonce: [u8; 12] = Default::default();
-        aes_nonce.copy_from_slice(&shared_secret[..12]);
-        let result = AesKeyFromX25519SharedSecret {
-            aes_key: aes_key_slice.to_vec(),
-            aes_nonce: aes_nonce.to_vec()
-        };
-        result
-    }
-}
-
-#[napi]
-pub fn aes_nonce() -> Vec<u8> {
-    let mut rng = ChaCha20Rng::from_entropy();
-    let mut random_bytes = Vec::with_capacity(12);
-    random_bytes.resize(12, 0);
-    rng.fill_bytes(&mut random_bytes);
-    random_bytes
-}
-
-#[napi]
-pub fn aes128_key() -> Vec<u8> {
-    return CASAES128::generate_key();
-}
-
-#[napi]
-pub fn aes256_key() -> Vec<u8> {
-    return CASAES256::generate_key();
-}
-
-#[napi]
-pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASAES128::encrypt_plaintext(aes_key, nonce, plaintext);
-}
-
-#[napi]
-pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASAES128::decrypt_ciphertext(aes_key, nonce, ciphertext);
-}
-
-#[napi]
-pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASAES256::encrypt_plaintext(aes_key, nonce, plaintext);
-}
-
-#[napi]
-pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASAES256::decrypt_ciphertext(aes_key, nonce, ciphertext);
-}
-
-#[napi]
-pub fn aes_256_key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
-    return CASAES256::key_from_x25519_shared_secret(shared_secret);
-}
-
-#[napi]
-pub fn aes_128_key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
-    return CASAES128::key_from_x25519_shared_secret(shared_secret);
-}
-
-#[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)
-}
+use aes_gcm::Key;
+use napi_derive::napi;
+use rand::rngs::OsRng;
+use rand::{RngCore, SeedableRng};
+use rand_chacha::ChaCha20Rng;
+
+use aes_gcm::{
+    aead::{generic_array::GenericArray, Aead},
+    Aes128Gcm, Aes256Gcm, KeyInit, Nonce,
+};
+
+use super::cas_symmetric_encryption::{AesKeyFromX25519SharedSecret, CASAESEncryption};
+pub struct CASAES128;
+pub struct CASAES256;
+
+impl CASAESEncryption for CASAES256 {
+    fn generate_key() -> Vec<u8> {
+        return Aes256Gcm::generate_key(&mut OsRng).to_vec();
+    }
+
+    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+        let key = GenericArray::from_slice(&aes_key);
+        let mut cipher = Aes256Gcm::new(&key);
+        let nonce = Nonce::from_slice(&nonce);
+        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
+        ciphertext
+    }
+
+    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+        let key = GenericArray::from_slice(&aes_key);
+        let mut cipher = Aes256Gcm::new(&key);
+        let nonce = Nonce::from_slice(&nonce);
+        let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
+        plaintext
+    }
+
+    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
+        let aes_key = Key::<Aes256Gcm>::from_slice(&shared_secret);
+        let mut aes_nonce: [u8; 12] = Default::default();
+        aes_nonce.copy_from_slice(&shared_secret[..12]);
+        let result = AesKeyFromX25519SharedSecret {
+            aes_key: aes_key.to_vec(),
+            aes_nonce: aes_nonce.to_vec(),
+        };
+        result
+    }
+}
+
+impl CASAESEncryption for CASAES128 {
+    fn generate_key() -> Vec<u8> {
+        return Aes128Gcm::generate_key(&mut OsRng).to_vec();
+    }
+
+    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+        let key = GenericArray::from_slice(&aes_key);
+        let mut cipher = Aes128Gcm::new(&key);
+        let nonce = Nonce::from_slice(&nonce);
+        let ciphertext = cipher.encrypt(nonce, plaintext.as_ref()).unwrap();
+        ciphertext
+    }
+
+    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+        let key = GenericArray::from_slice(&aes_key);
+        let mut cipher = Aes128Gcm::new(&key);
+        let nonce = Nonce::from_slice(&nonce);
+        let plaintext = cipher.decrypt(nonce, ciphertext.as_ref()).unwrap();
+        plaintext
+    }
+
+    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret {
+        let mut aes_key: [u8; 16] = Default::default();
+        aes_key.copy_from_slice(&shared_secret[..16]);
+        let aes_key_slice = Key::<Aes128Gcm>::from_slice(&aes_key);
+        let mut aes_nonce: [u8; 12] = Default::default();
+        aes_nonce.copy_from_slice(&shared_secret[..12]);
+        let result = AesKeyFromX25519SharedSecret {
+            aes_key: aes_key_slice.to_vec(),
+            aes_nonce: aes_nonce.to_vec(),
+        };
+        result
+    }
+}
+
+#[napi]
+pub fn aes_nonce() -> Vec<u8> {
+    let mut rng = ChaCha20Rng::from_entropy();
+    let mut random_bytes = Vec::with_capacity(12);
+    random_bytes.resize(12, 0);
+    rng.fill_bytes(&mut random_bytes);
+    random_bytes
+}
+
+#[napi]
+pub fn aes128_key() -> Vec<u8> {
+    return CASAES128::generate_key();
+}
+
+#[napi]
+pub fn aes256_key() -> Vec<u8> {
+    return CASAES256::generate_key();
+}
+
+#[napi]
+pub fn aes128_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+    return CASAES128::encrypt_plaintext(aes_key, nonce, plaintext);
+}
+
+#[napi]
+pub fn aes128_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+    return CASAES128::decrypt_ciphertext(aes_key, nonce, ciphertext);
+}
+
+#[napi]
+pub fn aes256_encrypt(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8> {
+    return CASAES256::encrypt_plaintext(aes_key, nonce, plaintext);
+}
+
+#[napi]
+pub fn aes256_decrypt(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8> {
+    return CASAES256::decrypt_ciphertext(aes_key, nonce, ciphertext);
+}
+
+#[napi]
+pub fn aes_256_key_from_x25519_shared_secret(
+    shared_secret: Vec<u8>,
+) -> AesKeyFromX25519SharedSecret {
+    return CASAES256::key_from_x25519_shared_secret(shared_secret);
+}
+
+#[napi]
+pub fn aes_128_key_from_x25519_shared_secret(
+    shared_secret: Vec<u8>,
+) -> AesKeyFromX25519SharedSecret {
+    return CASAES128::key_from_x25519_shared_secret(shared_secret);
+}
+
+#[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/symmetric/cas_symmetric_encryption.rs

@@ -1,14 +1,14 @@
-use napi_derive::napi;
-
-#[napi(constructor)]
-pub struct AesKeyFromX25519SharedSecret {
-    pub aes_key: Vec<u8>,
-    pub aes_nonce: Vec<u8>
-}
-
-pub trait CASAESEncryption {
-    fn generate_key() -> Vec<u8>;
-    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8>;
-    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8>;
-    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret;
-}
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct AesKeyFromX25519SharedSecret {
+    pub aes_key: Vec<u8>,
+    pub aes_nonce: Vec<u8>,
+}
+
+pub trait CASAESEncryption {
+    fn generate_key() -> Vec<u8>;
+    fn encrypt_plaintext(aes_key: Vec<u8>, nonce: Vec<u8>, plaintext: Vec<u8>) -> Vec<u8>;
+    fn decrypt_ciphertext(aes_key: Vec<u8>, nonce: Vec<u8>, ciphertext: Vec<u8>) -> Vec<u8>;
+    fn key_from_x25519_shared_secret(shared_secret: Vec<u8>) -> AesKeyFromX25519SharedSecret;
+}

package/src-ts/asymmetric/RSAWrapper.ts

@@ -1,53 +1,53 @@
-import { decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, RsaKeyPairResult, signRsa, verifyRsa } from "../../index";
-
-export class RSAWrapper {
-  public generateKeys(keySize: number): RsaKeyPairResult {
-    if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
-        throw new Error("You must provide an appropriate key size to generate RSA keys");
-    }
-    return generateRsaKeys(keySize);
-  }
-
-  public encrypt(publicKey: string, plaintext: Array<number>): Array<number> {
-    if (!publicKey) {
-      throw new Error("You must provide a public key to encrypt with RSA");
-    }
-    if (!plaintext || plaintext.length === 0) {
-      throw new Error("You must provide an array of plaintext bytes to encrypt with RSA");
-    }
-    return encryptPlaintextRsa(publicKey, plaintext);
-  }
-
-  public decrypt(privateKey: string, ciphertext: Array<number>): Array<number> {
-    if (!privateKey) {
-      throw new Error("You must provide a private key to encrypt with RSA");
-    }
-    if (!ciphertext || ciphertext.length === 0) {
-      throw new Error("You must provide an array of ciphertext bytes to encrypt with RSA");
-    }
-    return decryptCiphertextRsa(privateKey, ciphertext);
-  }
-
-  public sign(privateKey: string, hash: Array<number>): Array<number> {
-    if (!privateKey) {
-      throw new Error("You must provide a private key to sign with RSA");
-    }
-    if (!hash || hash.length === 0) {
-      throw new Error("You must provide an allocated hash to sign with RSA");
-    }
-    return signRsa(privateKey, hash);
-  }
-
-  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);
-  }
-}
+import { decryptCiphertextRsa, encryptPlaintextRsa, generateRsaKeys, RsaKeyPairResult, signRsa, verifyRsa } from "../../index";
+
+export class RSAWrapper {
+  public generateKeys(keySize: number): RsaKeyPairResult {
+    if (keySize !== 1024 && keySize !== 2048 && keySize !== 4096) {
+        throw new Error("You must provide an appropriate key size to generate RSA keys");
+    }
+    return generateRsaKeys(keySize);
+  }
+
+  public encrypt(publicKey: string, plaintext: Array<number>): Array<number> {
+    if (!publicKey) {
+      throw new Error("You must provide a public key to encrypt with RSA");
+    }
+    if (!plaintext || plaintext.length === 0) {
+      throw new Error("You must provide an array of plaintext bytes to encrypt with RSA");
+    }
+    return encryptPlaintextRsa(publicKey, plaintext);
+  }
+
+  public decrypt(privateKey: string, ciphertext: Array<number>): Array<number> {
+    if (!privateKey) {
+      throw new Error("You must provide a private key to encrypt with RSA");
+    }
+    if (!ciphertext || ciphertext.length === 0) {
+      throw new Error("You must provide an array of ciphertext bytes to encrypt with RSA");
+    }
+    return decryptCiphertextRsa(privateKey, ciphertext);
+  }
+
+  public sign(privateKey: string, hash: Array<number>): Array<number> {
+    if (!privateKey) {
+      throw new Error("You must provide a private key to sign with RSA");
+    }
+    if (!hash || hash.length === 0) {
+      throw new Error("You must provide an allocated hash to sign with RSA");
+    }
+    return signRsa(privateKey, hash);
+  }
+
+  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/asymmetric/index.ts

@@ -1,4 +1,4 @@
-import { RSAWrapper } from "./RSAWrapper";
-import { RsaKeyPairResult } from "../../index";
-
+import { RSAWrapper } from "./RSAWrapper";
+import { RsaKeyPairResult } from "../../index";
+
 export { RSAWrapper, RsaKeyPairResult };

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

@@ -0,0 +1,28 @@
+import { CasrsaDigitalSignatureResult, sha512RsaDigitalSignature, sha512RsaVerifyDigitalSignature } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+
+export class DigitalSignatureSHA512Wrapper implements IDigitalSignature {
+
+    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);
+    }
+    
+    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

@@ -0,0 +1,6 @@
+import { CASRSADigitalSignatureResult } 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

@@ -0,0 +1,19 @@
+import { DigitalSignatureSHA512Wrapper } from "./digital-siganture-sha-512";
+import { DigitalSignatureSHA256Wrapper } from "./digital-signaturte-sha-256";
+
+export enum DigitalSignatureType {
+    SHA512 = 1,
+    SHA256 = 2
+}
+
+export class DigitalSignatureFactory {
+    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

@@ -0,0 +1,28 @@
+import { CasrsaDigitalSignatureResult, sha256RsaDigitalSignature, sha256RsaVerifyDigitalSignature } from "../../index";
+import { IDigitalSignature } from "./digital-signature-base";
+
+export class DigitalSignatureSHA256Wrapper implements IDigitalSignature {
+
+    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);
+    }
+    
+    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);
+    }
+}