cas-typescript-sdk 1.0.15 → 1.0.16

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

package/src/hashers/sha.rs

@@ -1,103 +1,102 @@
-use napi::bindgen_prelude::Array;
-use napi_derive::napi;
-
-use super::cas_hasher::CASHasher;
-use sha3::{Digest, Sha3_256, Sha3_512};
-pub struct CASSHA;
-
-impl CASHasher for CASSHA {
-    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8> {
-        let mut hasher = Sha3_512::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 = Sha3_512::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 = Sha3_256::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 = Sha3_256::new();
-        hasher.update(data_to_verify);
-        let result = hasher.finalize();
-        return hash_to_verify.eq(&result.to_vec());
-    }
-}
-
-#[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));
-}
+use napi::bindgen_prelude::Array;
+use napi_derive::napi;
+
+use super::cas_hasher::CASHasher;
+use sha3::{Digest, Sha3_256, Sha3_512};
+pub struct CASSHA;
+
+impl CASHasher for CASSHA {
+    fn hash_512(data_to_hash: Vec<u8>) -> Vec<u8> {
+        let mut hasher = Sha3_512::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 = Sha3_512::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 = Sha3_256::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 = Sha3_256::new();
+        hasher.update(data_to_verify);
+        let result = hasher.finalize();
+        return hash_to_verify.eq(&result.to_vec());
+    }
+}
+
+#[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/key_exchange/cas_key_exchange.rs

@@ -1,6 +1,6 @@
-use super::x25519::x25519SecretPublicKeyResult;
-
-pub trait CASKeyExchange {
-    fn generate_secret_and_public_key() -> x25519SecretPublicKeyResult;
-    fn diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8>;
-}
+use super::x25519::x25519SecretPublicKeyResult;
+
+pub trait CASKeyExchange {
+    fn generate_secret_and_public_key() -> x25519SecretPublicKeyResult;
+    fn diffie_hellman(my_secret_key: Vec<u8>, users_public_key: Vec<u8>) -> Vec<u8>;
+}