#70 benchmark sender

Cargo.toml

@@ -14,5 +14,5 @@ crate-type = ["dylib"]
 
 [dependencies]
 libc = "0.2.146"
-cas-lib = "0.2.65"
+cas-lib = "0.2.67"
 zeroizing-alloc = "0.1.0"

src/benchmark_http/http.rs

@@ -0,0 +1,53 @@
+use std::ffi::CStr;
+use libc::c_char;
+
+use cas_lib::http::{send_benchmark, set_api_key_in_cache, set_base_url_in_cache, set_tokens_in_cache, types::runtime::RUNTIME};
+
+
+#[no_mangle]
+pub extern "C" fn set_base_url(base_url: *const c_char) {
+    let base_url_string = unsafe {
+        assert!(!base_url.is_null());
+        CStr::from_ptr(base_url)
+    }
+    .to_str()
+    .unwrap()
+    .to_string();
+    set_base_url_in_cache(base_url_string);
+}
+
+#[no_mangle]
+pub extern "C" fn set_api_key(api_key: *const c_char) {
+    let api_key_string = unsafe {
+        assert!(!api_key.is_null());
+        CStr::from_ptr(api_key)
+    }
+    .to_str()
+    .unwrap()
+    .to_string();
+    RUNTIME.block_on(set_api_key_in_cache(api_key_string));
+}
+
+#[no_mangle]
+pub extern "C" fn send_benchmark_to_api(time_in_milliseconds: i64, class_name: *const c_char, method_name: *const c_char) {
+    let class_name_string = unsafe {
+        assert!(!class_name.is_null());
+        CStr::from_ptr(class_name)
+    }
+    .to_str()
+    .unwrap()
+    .to_string();
+    let method_name_string = unsafe {
+        assert!(!method_name.is_null());
+        CStr::from_ptr(method_name)
+    }
+    .to_str()
+    .unwrap()
+    .to_string();
+
+    let class_name_for_async = class_name_string.clone();
+    let method_name_for_async = method_name_string.clone();
+    RUNTIME.spawn(async move {
+        send_benchmark(time_in_milliseconds, class_name_for_async, method_name_for_async).await;
+    });
+}

src/digital_signature.rs

@@ -1,10 +1,8 @@
 use std::ffi::{c_char, c_uchar, CStr, CString};
 
 use cas_lib::digital_signature::{
-    cas_digital_signature_rsa::{ED25519DigitalSignature, RSADigitalSignature},
-    sha_256_ed25519::SHA256ED25519DigitalSignature,
+    cas_digital_signature_rsa::{RSADigitalSignature},
     sha_256_rsa::SHA256RSADigitalSignature,
-    sha_512_ed25519::SHA512ED25519DigitalSignature,
     sha_512_rsa::SHA512RSADigitalSignature,
 };
 
@@ -148,123 +146,4 @@ pub extern "C" fn sha_256_rsa_digital_signature_verify(
         signature_slice,
     );
     result
-}
-
-
-#[no_mangle]
-pub extern "C" fn sha512_ed25519_digital_signature(
-    data_to_sign: *const c_uchar,
-    data_length: usize,
-) -> SHAED25519DalekDigitalSignatureResult {
-    let data_to_sign_slice = unsafe {
-        assert!(!data_to_sign.is_null());
-        std::slice::from_raw_parts(data_to_sign, data_length)
-    }
-    .to_vec();
-    let result =
-        <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(
-            data_to_sign_slice,
-        );
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let signature_capacity = signature.capacity();
-    signature.reserve_exact(signature_capacity);
-    let result = SHAED25519DalekDigitalSignatureResult {
-        public_key: public_key.as_mut_ptr(),
-        public_key_length: public_key.len(),
-        signature_raw_ptr: signature.as_mut_ptr(),
-        signature_length: signature.len(),
-    };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
-    result
-}
-
-#[no_mangle]
-pub extern "C" fn sha256_ed25519_digital_signature(
-    data_to_sign: *const c_uchar,
-    data_length: usize,
-) -> SHAED25519DalekDigitalSignatureResult {
-    let data_to_sign_slice = unsafe {
-        assert!(!data_to_sign.is_null());
-        std::slice::from_raw_parts(data_to_sign, data_length)
-    }
-    .to_vec();
-    let result =
-        <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519(
-            data_to_sign_slice,
-        );
-    let mut public_key = result.public_key;
-    let public_key_capacity = public_key.capacity();
-    public_key.reserve_exact(public_key_capacity);
-    let mut signature = result.signature;
-    let signature_capacity = signature.capacity();
-    signature.reserve_exact(signature_capacity);
-    let result = SHAED25519DalekDigitalSignatureResult {
-        public_key: public_key.as_mut_ptr(),
-        public_key_length: public_key.len(),
-        signature_raw_ptr: signature.as_mut_ptr(),
-        signature_length: signature.len(),
-    };
-    std::mem::forget(public_key);
-    std::mem::forget(signature);
-    result
-}
-
-#[no_mangle]
-pub extern "C" fn sha512_ed25519_digital_signature_verify(
-    public_key: *const c_uchar,
-    public_key_length: usize,
-    data_to_verify: *const c_uchar,
-    data_to_verify_length: usize,
-    signature: *const c_uchar,
-    signature_length: usize,
-) -> bool {
-    let public_key_slice = unsafe {
-        assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }
-    .to_vec();
-    let data_to_verify_slice = unsafe {
-        assert!(!data_to_verify.is_null());
-        std::slice::from_raw_parts(data_to_verify, data_to_verify_length)
-    }
-    .to_vec();
-    let signature_slice = unsafe {
-        assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }
-    .to_vec();
-    let result = <SHA512ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(public_key_slice, data_to_verify_slice,  signature_slice);
-    result
-}
-
-#[no_mangle]
-pub extern "C" fn sha256_ed25519_digital_signature_verify(
-    public_key: *const c_uchar,
-    public_key_length: usize,
-    data_to_verify: *const c_uchar,
-    data_to_verify_length: usize,
-    signature: *const c_uchar,
-    signature_length: usize,
-) -> bool {
-    let public_key_slice = unsafe {
-        assert!(!public_key.is_null());
-        std::slice::from_raw_parts(public_key, public_key_length)
-    }
-    .to_vec();
-    let data_to_verify_slice = unsafe {
-        assert!(!data_to_verify.is_null());
-        std::slice::from_raw_parts(data_to_verify, data_to_verify_length)
-    }
-    .to_vec();
-    let signature_slice = unsafe {
-        assert!(!signature.is_null());
-        std::slice::from_raw_parts(signature, signature_length)
-    }
-    .to_vec();
-    let result = <SHA256ED25519DigitalSignature as ED25519DigitalSignature>::digital_signature_ed25519_verify(public_key_slice, data_to_verify_slice,  signature_slice);
-    result
 }

src/ed25519.rs

@@ -3,8 +3,10 @@ use libc::c_uchar;
 
 #[repr(C)]
 pub struct Ed25519KeyPairBytesResult {
-    key_pair: *mut c_uchar,
-    length: usize,
+    signing_key: *mut c_uchar,
+    signing_key_length: usize,
+    verifying_key: *mut c_uchar,
+    verifying_key_length: usize,
 }
 
 #[repr(C)]
@@ -18,22 +20,29 @@ pub struct Ed25519ByteSignatureResult {
 #[no_mangle]
 pub extern "C" fn get_ed25519_key_pair_bytes() -> Ed25519KeyPairBytesResult {
     let mut keypair = get_ed25519_key_pair();
-    let capacity = keypair.capacity();
-    keypair.reserve_exact(capacity);
+    let signing_key_capacity = keypair.key_pair.capacity();
+    keypair.key_pair.reserve_exact(signing_key_capacity);
+    let verifying_key_capacity = keypair.public_key.capacity();
+    keypair.public_key.reserve_exact(verifying_key_capacity);
     let result = Ed25519KeyPairBytesResult {
-        length: keypair.len(),
-        key_pair: keypair.as_mut_ptr(),
+        signing_key_length: keypair.key_pair.len(),
+        signing_key: keypair.key_pair.as_mut_ptr(),
+        verifying_key_length: keypair.public_key.len(),
+        verifying_key: keypair.public_key.as_mut_ptr(),
     };
-    std::mem::forget(keypair);
+    std::mem::forget(keypair.key_pair);
+    std::mem::forget(keypair.public_key);
     result
 }
 
 
 #[test]
 fn get_ed25519_key_pair_bytes_test() {
     let key_pair_result = get_ed25519_key_pair_bytes();
-    assert_eq!(false, key_pair_result.key_pair.is_null());
-    assert_eq!(true, key_pair_result.length > 0);
+    assert_eq!(false, key_pair_result.signing_key.is_null());
+    assert_eq!(true, key_pair_result.signing_key_length > 0);
+    assert_eq!(false, key_pair_result.verifying_key.is_null());
+    assert_eq!(true, key_pair_result.verifying_key_length > 0);
 }
 
 #[no_mangle]
@@ -78,8 +87,8 @@ fn sign_with_key_pair_bytes_test() {
     let message: &str = "ThisIsAMessageToSignWithED25519Dalek";
     let message_byte: &[u8] = message.as_bytes();
     let signature_result: Ed25519ByteSignatureResult = sign_with_key_pair_bytes(
-        key_pair_result.key_pair,
-        key_pair_result.length,
+        key_pair_result.signing_key,
+        key_pair_result.signing_key_length,
         message_byte.as_ptr(),
         message_byte.len(),
     );
@@ -119,14 +128,14 @@ fn verify_with_key_pair_bytes_test() {
     let key_pair = get_ed25519_key_pair_bytes();
     let message = "SignThisMessageWithED25519Dalek".as_bytes();
     let sign_result: Ed25519ByteSignatureResult = sign_with_key_pair_bytes(
-        key_pair.key_pair,
-        key_pair.length,
+        key_pair.signing_key,
+        key_pair.signing_key_length,
         message.as_ptr(),
         message.len(),
     );
     let is_valid = verify_with_key_pair_bytes(
-        key_pair.key_pair,
-        key_pair.length,
+        key_pair.signing_key,
+        key_pair.signing_key_length,
         sign_result.signature_byte_ptr,
         sign_result.signature_length,
         message.as_ptr(),
@@ -164,8 +173,8 @@ fn verify_with_public_key_bytes_test() {
     let key_pair = get_ed25519_key_pair_bytes();
     let message = "SignThisMessageWithED25519Dalek".as_bytes();
     let signature_result: Ed25519ByteSignatureResult = sign_with_key_pair_bytes(
-        key_pair.key_pair,
-        key_pair.length,
+        key_pair.signing_key,
+        key_pair.signing_key_length,
         message.as_ptr(),
         message.len(),
     );

src/lib.rs

@@ -24,4 +24,8 @@ pub mod password_hashers {
     pub mod argon2;
     pub mod scrypt;
     pub mod bcrypt;
+}
+
+pub mod benchmark_http {
+    pub mod http;
 }