cas-typescript-sdk 1.0.14 → 1.0.16

package/src/asymmetric/cas_rsa.rs

@@ -1,80 +1,88 @@
-use napi_derive::napi;
-use rand::rngs::OsRng;
-use rsa::{
-    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey}, pkcs8::{DecodePrivateKey, EncodePrivateKey}, Pkcs1v15Encrypt, Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey
-};
-
-use super::cas_asymmetric_encryption::{CASRSAEncryption, RSAKeyPairResult};
-pub struct CASRSA;
-
-impl CASRSAEncryption for CASRSA {
-    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
-        let mut rng: OsRng = OsRng;
-        let private_key: RsaPrivateKey = RsaPrivateKey::new(&mut rng, key_size as usize).expect("failed to generate a key");
-        let public_key: RsaPublicKey = private_key.to_public_key();
-        let result = RSAKeyPairResult {
-            public_key: public_key.to_pkcs1_pem(rsa::pkcs1::LineEnding::LF).unwrap().to_string(),
-            private_key: private_key.to_pkcs8_pem(rsa::pkcs8::LineEnding::LF).unwrap().to_string()
-        };
-        result
-    }
-
-    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8> {
-        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
-        let mut rng = rand::thread_rng();
-        let ciphertext = public_key.encrypt(&mut rng, Pkcs1v15Encrypt, &plaintext).unwrap();
-        ciphertext
-    }
-
-    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8> {
-        let private_key = RsaPrivateKey::from_pkcs8_pem(&private_key).unwrap();
-        let plaintext = private_key.decrypt(Pkcs1v15Encrypt, &ciphertext).unwrap();
-        plaintext
-    }
-
-    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8> {
-        let private_key = RsaPrivateKey::from_pkcs8_pem(&private_key).unwrap();
-        let mut signed_data = private_key.sign(Pkcs1v15Sign::new_unprefixed(), &hash).unwrap();
-        signed_data
-    }
-
-    fn verify(public_key: String, hash: Vec<u8>, signature: Vec<u8>) -> bool {
-        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
-        let verified = public_key.verify(
-            Pkcs1v15Sign::new_unprefixed(),
-            &hash,
-            &signature,
-        );
-        if verified.is_err() == false {
-            return true;
-        } else {
-            return false;
-        }
-    }
-}
-
-
-#[napi]
-pub fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
-    return CASRSA::generate_rsa_keys(key_size);
-}
-
-#[napi]
-pub fn encrypt_plaintext_rsa(public_key: String, plaintext: Vec<u8>) -> Vec<u8> {
-    return CASRSA::encrypt_plaintext(public_key, plaintext);
-}
-
-#[napi]
-pub fn decrypt_ciphertext_rsa(private_key: String, ciphertext: Vec<u8>) -> Vec<u8> {
-    return CASRSA::decrypt_ciphertext(private_key, ciphertext);
-}
-
-#[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);
-}
+use napi_derive::napi;
+use rand::rngs::OsRng;
+use rsa::{
+    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey},
+    pkcs8::{DecodePrivateKey, EncodePrivateKey},
+    Pkcs1v15Encrypt, Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
+};
+
+use super::cas_asymmetric_encryption::{CASRSAEncryption, RSAKeyPairResult};
+pub struct CASRSA;
+
+impl CASRSAEncryption for CASRSA {
+    fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
+        let mut rng: OsRng = OsRng;
+        let private_key: RsaPrivateKey =
+            RsaPrivateKey::new(&mut rng, key_size as usize).expect("failed to generate a key");
+        let public_key: RsaPublicKey = private_key.to_public_key();
+        let result = RSAKeyPairResult {
+            public_key: public_key
+                .to_pkcs1_pem(rsa::pkcs1::LineEnding::LF)
+                .unwrap()
+                .to_string(),
+            private_key: private_key
+                .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
+                .unwrap()
+                .to_string(),
+        };
+        result
+    }
+
+    fn encrypt_plaintext(public_key: String, plaintext: Vec<u8>) -> Vec<u8> {
+        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
+        let mut rng = rand::thread_rng();
+        let ciphertext = public_key
+            .encrypt(&mut rng, Pkcs1v15Encrypt, &plaintext)
+            .unwrap();
+        ciphertext
+    }
+
+    fn decrypt_ciphertext(private_key: String, ciphertext: Vec<u8>) -> Vec<u8> {
+        let private_key = RsaPrivateKey::from_pkcs8_pem(&private_key).unwrap();
+        let plaintext = private_key.decrypt(Pkcs1v15Encrypt, &ciphertext).unwrap();
+        plaintext
+    }
+
+    fn sign(private_key: String, hash: Vec<u8>) -> Vec<u8> {
+        let private_key = RsaPrivateKey::from_pkcs8_pem(&private_key).unwrap();
+        let mut signed_data = private_key
+            .sign(Pkcs1v15Sign::new_unprefixed(), &hash)
+            .unwrap();
+        signed_data
+    }
+
+    fn verify(public_key: String, hash: Vec<u8>, signature: Vec<u8>) -> bool {
+        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
+        let verified = public_key.verify(Pkcs1v15Sign::new_unprefixed(), &hash, &signature);
+        if verified.is_err() == false {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+#[napi]
+pub fn generate_rsa_keys(key_size: u32) -> RSAKeyPairResult {
+    return CASRSA::generate_rsa_keys(key_size);
+}
+
+#[napi]
+pub fn encrypt_plaintext_rsa(public_key: String, plaintext: Vec<u8>) -> Vec<u8> {
+    return CASRSA::encrypt_plaintext(public_key, plaintext);
+}
+
+#[napi]
+pub fn decrypt_ciphertext_rsa(private_key: String, ciphertext: Vec<u8>) -> Vec<u8> {
+    return CASRSA::decrypt_ciphertext(private_key, ciphertext);
+}
+
+#[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/cas_digital_signature_rsa.rs

@@ -0,0 +1,27 @@
+use napi_derive::napi;
+
+#[napi(constructor)]
+pub struct CASRSADigitalSignatureResult {
+    pub public_key: String,
+    pub private_key: String,
+    pub signature: Vec<u8>,
+}
+
+#[napi(constructor)]
+pub struct CASSHAED25519DalekDigitalSignatureResult {
+    pub public_key: Vec<u8>,
+    pub signature: Vec<u8>
+}
+
+pub trait CASRSADigitalSignature {
+    fn digital_signature_rsa(
+        rsa_key_size: u32,
+        data_to_sign: Vec<u8>,
+    ) -> CASRSADigitalSignatureResult;
+    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
+}
+
+pub trait CASED25519DigitalSignature {
+    fn digital_signature_ed25519(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult;
+    fn digital_signature_ed25519_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool;
+}

package/src/digital_signature/sha_256_rsa.rs

@@ -0,0 +1,96 @@
+use napi_derive::napi;
+use rand::rngs::OsRng;
+use rsa::{
+    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey},
+    pkcs8::EncodePrivateKey,
+    Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
+};
+use sha3::{Digest, Sha3_256};
+
+
+use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature};
+
+pub struct SHA256RSADigitalSignature;
+
+impl CASRSADigitalSignature for SHA256RSADigitalSignature {
+    fn digital_signature_rsa(
+        rsa_key_size: u32,
+        data_to_sign: Vec<u8>,
+    ) -> CASRSADigitalSignatureResult {
+        let mut hasher = Sha3_256::new();
+        hasher.update(data_to_sign);
+        let sha_hasher_result = hasher.finalize();
+        let mut rng: OsRng = OsRng;
+        let private_key: RsaPrivateKey =
+            RsaPrivateKey::new(&mut rng, rsa_key_size as usize).expect("failed to generate a key");
+        let public_key = private_key.to_public_key();
+        let mut signed_data = private_key
+            .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
+            .unwrap();
+        let result = CASRSADigitalSignatureResult {
+            private_key: private_key
+                .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
+                .unwrap()
+                .to_string(),
+            public_key: public_key
+                .to_pkcs1_pem(rsa::pkcs8::LineEnding::LF)
+                .unwrap()
+                .to_string(),
+            signature: signed_data,
+        };
+        result
+    }
+
+    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
+        let mut hasher = Sha3_256::new();
+        hasher.update(data_to_verify);
+        let sha_hasher_result = hasher.finalize();
+        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
+        let verified = public_key.verify(
+            Pkcs1v15Sign::new_unprefixed(),
+            &sha_hasher_result,
+            &signature,
+        );
+        if verified.is_err() == false {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+#[napi]
+pub fn sha_256_rsa_digital_signature(
+    rsa_key_size: u32,
+    data_to_sign: Vec<u8>,
+) -> CASRSADigitalSignatureResult {
+    return SHA256RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
+}
+
+#[napi]
+pub fn sha_256_rsa_verify_digital_signature(
+    public_key: String,
+    data_to_verify: Vec<u8>,
+    signature: Vec<u8>,
+) -> bool {
+    return SHA256RSADigitalSignature::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::digital_signature_rsa(key_size, data_to_sign.clone());
+    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::digital_signature_rsa(key_size, data_to_sign.clone());
+    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_ed25519.rs

@@ -0,0 +1,75 @@
+use ed25519_dalek::{Keypair, Signature, Signer, Verifier};
+use napi_derive::napi;
+use sha3::{Digest, Sha3_512};
+
+use super::cas_digital_signature_rsa::{
+    CASED25519DigitalSignature, CASSHAED25519DalekDigitalSignatureResult,
+};
+
+pub struct SHA512ED25519DigitalSignature;
+
+impl CASED25519DigitalSignature for SHA512ED25519DigitalSignature {
+    fn digital_signature_ed25519(
+        data_to_sign: Vec<u8>,
+    ) -> CASSHAED25519DalekDigitalSignatureResult {
+        let mut hasher = Sha3_512::new();
+        hasher.update(data_to_sign);
+        let sha_hasher_result = hasher.finalize();
+        let mut csprng = rand_07::rngs::OsRng {};
+        let keypair = Keypair::generate(&mut csprng);
+
+        let signature = keypair.sign(&sha_hasher_result);
+        let signature_bytes = signature.to_bytes();
+        let public_keypair_bytes = keypair.public.to_bytes();
+        let result = CASSHAED25519DalekDigitalSignatureResult {
+            public_key: public_keypair_bytes.to_vec(),
+            signature: signature_bytes.to_vec(),
+        };
+        result
+    }
+
+    fn digital_signature_ed25519_verify(
+        public_key: Vec<u8>,
+        data_to_verify: Vec<u8>,
+        signature: Vec<u8>,
+    ) -> bool {
+        let mut hasher = Sha3_512::new();
+        hasher.update(data_to_verify);
+        let sha_hasher_result = hasher.finalize();
+
+        let public_key_parsed = ed25519_dalek::PublicKey::from_bytes(&public_key).unwrap();
+        let signature_parsed = Signature::from_bytes(&signature).unwrap();
+        return public_key_parsed
+            .verify(&sha_hasher_result, &signature_parsed)
+            .is_ok();
+    }
+}
+
+#[napi]
+pub fn sha_512_ed25519_digital_signature(data_to_sign: Vec<u8>) -> CASSHAED25519DalekDigitalSignatureResult {
+    return SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign);
+}
+
+#[napi]
+pub fn sha_512_ed25519_digital_signature_verify(public_key: Vec<u8>, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
+    return SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(public_key, data_to_verify, signature)
+}
+
+#[test]
+fn sha_512_ed25519_test() {
+    let key_size: u32 = 1024;
+    let data_to_sign = b"GetTheseBytes".to_vec();
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, data_to_sign, signature_result.signature);
+    assert_eq!(is_verified, true);
+}
+
+#[test]
+fn sha_512_ed25519_test_fail() {
+    let key_size: u32 = 1024;
+    let data_to_sign = b"GetTheseBytes".to_vec();
+    let signature_result: CASSHAED25519DalekDigitalSignatureResult = SHA512ED25519DigitalSignature::digital_signature_ed25519(data_to_sign.clone());
+    let not_original_data = b"NOtTHoseBytes".to_vec();
+    let is_verified: bool = SHA512ED25519DigitalSignature::digital_signature_ed25519_verify(signature_result.public_key, not_original_data, signature_result.signature);
+    assert_eq!(is_verified, false);
+}

package/src/digital_signature/sha_512_rsa.rs

@@ -0,0 +1,93 @@
+use napi_derive::napi;
+use rand::rngs::OsRng;
+use rsa::{
+    pkcs1::{DecodeRsaPublicKey, EncodeRsaPublicKey},
+    pkcs8::EncodePrivateKey,
+    Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey,
+};
+use sha3::{Digest, Sha3_512};
+use super::cas_digital_signature_rsa::{CASRSADigitalSignatureResult, CASRSADigitalSignature};
+pub struct SHA512RSADigitalSignature;
+
+impl CASRSADigitalSignature for SHA512RSADigitalSignature {
+    fn digital_signature_rsa(
+        rsa_key_size: u32,
+        data_to_sign: Vec<u8>,
+    ) -> CASRSADigitalSignatureResult {
+        let mut hasher = Sha3_512::new();
+        hasher.update(data_to_sign);
+        let sha_hasher_result = hasher.finalize();
+        let mut rng: OsRng = OsRng;
+        let private_key: RsaPrivateKey =
+            RsaPrivateKey::new(&mut rng, rsa_key_size as usize).expect("failed to generate a key");
+        let public_key = private_key.to_public_key();
+        let mut signed_data = private_key
+            .sign(Pkcs1v15Sign::new_unprefixed(), &sha_hasher_result)
+            .unwrap();
+        let result = CASRSADigitalSignatureResult {
+            private_key: private_key
+                .to_pkcs8_pem(rsa::pkcs8::LineEnding::LF)
+                .unwrap()
+                .to_string(),
+            public_key: public_key
+                .to_pkcs1_pem(rsa::pkcs8::LineEnding::LF)
+                .unwrap()
+                .to_string(),
+            signature: signed_data,
+        };
+        result
+    }
+
+    fn verify_rsa(public_key: String, data_to_verify: Vec<u8>, signature: Vec<u8>) -> bool {
+        let mut hasher = Sha3_512::new();
+        hasher.update(data_to_verify);
+        let sha_hasher_result = hasher.finalize();
+        let public_key = RsaPublicKey::from_pkcs1_pem(&public_key).unwrap();
+        let verified = public_key.verify(
+            Pkcs1v15Sign::new_unprefixed(),
+            &sha_hasher_result,
+            &signature,
+        );
+        if verified.is_err() == false {
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+
+#[napi]
+pub fn sha_512_rsa_digital_signature(
+    rsa_key_size: u32,
+    data_to_sign: Vec<u8>,
+) -> CASRSADigitalSignatureResult {
+    return SHA512RSADigitalSignature::digital_signature_rsa(rsa_key_size, data_to_sign);
+}
+
+#[napi]
+pub fn sha_512_rsa_verify_digital_signature(
+    public_key: String,
+    data_to_verify: Vec<u8>,
+    signature: Vec<u8>,
+) -> bool {
+    return SHA512RSADigitalSignature::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());
+    let is_verified: bool = SHA512RSADigitalSignature::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());
+    let new_data = b"NOtTheOriginalData".to_vec();
+    let is_verified: bool = SHA512RSADigitalSignature::verify_rsa(signature_result.public_key, new_data, signature_result.signature);
+    assert_eq!(is_verified, false);
+}

package/src/hashers/blake2.rs

@@ -1,39 +1,37 @@
-use blake2::{Blake2b512, Blake2s256, Digest};
-use super::cas_hasher::CASHasher;
-
-pub struct CASBlake2;
-
-impl CASHasher for CASBlake2 {
-    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-        let mut hasher = Blake2b512::new();
-        hasher.update(data_to_hash);
-        let result = hasher.finalize();
-        return result.to_vec();
-    }
-
-    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-        let mut hasher = Blake2b512::new();
-        hasher.update(data_to_verify);
-        let result = hasher.finalize();
-        return hash_to_verify.eq(&result.to_vec());
-    }
-
-    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8> {
-        let mut hasher = Blake2s256::new();
-        hasher.update(data_to_hash);
-        let result = hasher.finalize();
-        return result.to_vec();
-    }
-
-    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
-        let mut hasher = Blake2s256::new();
-        hasher.update(data_to_verify);
-        let result = hasher.finalize();
-        return hash_to_verify.eq(&result.to_vec());
-    }
-}
-
-#[test]
-fn hash_512_test() {
-    
-}
+use super::cas_hasher::CASHasher;
+use blake2::{Blake2b512, Blake2s256, Digest};
+
+pub struct CASBlake2;
+
+impl CASHasher for CASBlake2 {
+    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8> {
+        let mut hasher = Blake2b512::new();
+        hasher.update(data_to_hash);
+        let result = hasher.finalize();
+        return result.to_vec();
+    }
+
+    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+        let mut hasher = Blake2b512::new();
+        hasher.update(data_to_verify);
+        let result = hasher.finalize();
+        return hash_to_verify.eq(&result.to_vec());
+    }
+
+    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8> {
+        let mut hasher = Blake2s256::new();
+        hasher.update(data_to_hash);
+        let result = hasher.finalize();
+        return result.to_vec();
+    }
+
+    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool {
+        let mut hasher = Blake2s256::new();
+        hasher.update(data_to_verify);
+        let result = hasher.finalize();
+        return hash_to_verify.eq(&result.to_vec());
+    }
+}
+
+#[test]
+fn hash_512_test() {}

package/src/hashers/cas_hasher.rs

@@ -1,8 +1,8 @@
-use napi::bindgen_prelude::Array;
-
-pub trait CASHasher {
-    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8>;
-    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool;
-    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8>;
-    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool;
-}
+use napi::bindgen_prelude::Array;
+
+pub trait CASHasher {
+    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8>;
+    fn verify_512(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool;
+    fn hash_256(data_to_hash: Vec<u8>) -> Vec<u8>;
+    fn verify_256(hash_to_verify: Vec<u8>, data_to_verify: Vec<u8>) -> bool;
+}