Meta secret core version 2

.github/workflows/core.yml → .github/workflows/core.deploy.yml

@@ -22,18 +22,15 @@ jobs:
         with:
           path: |
             ~/.cargo
-            core/target
+            target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Generate rust models
         working-directory: schema
         run: |
-          npm install @openapitools/openapi-generator-cli -g
-          openapi-generator-cli version-manager set 6.2.1
           make clean generate_schema
 
       - name: Run tests
-        working-directory: core
         run: |
           cargo test
 

.github/workflows/core.test.yml

@@ -0,0 +1,31 @@
+name: "Core Testing"
+
+on:
+  pull_request:
+
+jobs:
+  core-test:
+    runs-on: ubuntu-latest
+
+    concurrency:
+      group: ${{ github.ref }}
+      cancel-in-progress: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Generate rust models
+        working-directory: schema
+        run: |
+          make clean generate_schema
+
+      - name: Run tests
+        run: |
+          cargo test

.gitignore

@@ -9,3 +9,19 @@ schema/target
 /schema/node_modules/
 /schema/package.json
 /schema/package-lock.json
+
+/meta-server-serverless/.idea/
+/meta-server-serverless/node_modules/
+/meta-server-serverless/build/
+/meta-server-serverless/Cargo.lock
+/meta-server-serverless/package-lock.json
+/meta-server-serverless/target
+
+/wasm/target
+/wasm/pkg
+/wasm/**/*.rs.bk
+/wasm/Cargo.lock
+/wasm/bin/
+/wasm/wasm-pack.log
+
+.vscode

Cargo.toml

@@ -1,5 +1,49 @@
 [workspace]
+
+resolver = "2"
+
 members = [
     "core",
-    "core-swift-lib"
-]
+    "meta-server-emulator",
+    "core-swift-lib",
+    "wasm"
+]
+
+exclude = [
+    "meta-server-serverless"
+]
+
+[workspace.dependencies]
+# Error handling
+thiserror = "1.0.49"
+anyhow = "1.0.75"
+
+# Logging and tracing
+tracing = "0.1"
+tracing-subscriber = { version = "0.3" }
+
+# Json
+serde = { version = "1.0.188", features = ["derive"] }
+serde_json = "1.0.107"
+serde_derive = "1.0.188"
+
+# Async utils
+async-std = { version = "1.12.0" }
+async-trait = "0.1"
+flume = "0.11"
+async-mutex = "1.4"
+
+# Cryptography
+ed25519-dalek = "1.0.1"
+crypto_box = { version = "0.8.2", features = ["std"] }
+rand = "0.8.5"
+getrandom = { version = "0.2.8", features = ["js"] }
+sha2 = { version = "0.10.6", features = ["oid"] }
+base64 = "0.20.0"
+hex = "0.4"
+#https://github.com/dsprenkels/sss-rs
+shamirsecretsharing = "0.1"
+
+# Sql
+diesel = { version = "2.0.0" }
+diesel_migrations = { version = "2.0.0" }

Makefile

@@ -0,0 +1,27 @@
+
+clean:
+	rm -rf schema/target
+
+build_wasm:
+	cd wasm && wasm-pack build --target web
+
+	#rm -rf ui/pkg
+	#cp -R wasm/pkg ui
+
+build_js: build_wasm
+	cd ui && npm install vue-tsc
+	cd ui && npm run build
+
+generate_typescript_models:
+	cd ../meta-secret-core/schema && make generate_schema_type_script
+	cp -r  ../meta-secret-core/schema/target/core-models-ts/model ui/src
+
+install_wasm_pack:
+	curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh
+	cargo install cargo-generate
+
+wasm_test:
+	cd wasm && wasm-pack test --firefox
+
+wasm_test_headless:
+	cd wasm && wasm-pack test --headless --firefox

core-swift-lib/Cargo.toml

@@ -9,11 +9,15 @@ name = "meta_secret_core_swift"
 
 [dependencies]
 meta-secret-core = { path = "../core"}
-serde_json = "1.0.87"
-serde = { version = "1.0", features = ["derive"] }
-ed25519-dalek = "1.0"
-crypto_box = "0.8.1"
-base64 = "0.20.0-alpha.1"
-sha2 = "0.10.6"
-hex = "0.4"
-anyhow = "1.0.66"
+
+anyhow.workspace = true
+
+serde.workspace = true
+serde_json.workspace = true
+serde_derive.workspace = true
+
+ed25519-dalek.workspace = true
+crypto_box.workspace = true
+base64.workspace = true
+sha2.workspace = true
+hex.workspace = true

core-swift-lib/src/swift_to_rust.rs

@@ -1,16 +1,17 @@
 use anyhow::Context;
-use meta_secret_core::crypto::keys::KeyManager;
+use meta_secret_core::crypto::encoding::base64::Base64Text;
+use meta_secret_core::crypto::keys::{KeyManager, SecretBox};
 use meta_secret_core::errors::CoreError;
-use meta_secret_core::shared_secret::data_block::common::SharedSecretConfig;
-use meta_secret_core::shared_secret::shared_secret::UserShareDto;
+use meta_secret_core::node::common::model::secret::SecretDistributionData;
+use meta_secret_core::recover_from_shares;
+use meta_secret_core::secret::data_block::common::SharedSecretConfig;
+use meta_secret_core::secret::shared_secret::UserShareDto;
 use meta_secret_core::CoreResult;
-use meta_secret_core::{recover_from_shares, shared_secret};
 use serde::{Deserialize, Serialize};
 use std::ffi::CString;
 use std::os::raw::c_char;
 use std::slice;
 use std::str;
-use meta_secret_core::models::{Base64EncodedText, SecretDistributionDocData, SerializedKeyManager};
 
 type SizeT = usize;
 
@@ -73,12 +74,14 @@ fn to_c_str(str: String) -> *mut c_char {
 }
 
 mod internal {
-    use meta_secret_core::models::{AeadCipherText, AeadPlainText, MetaPasswordId};
+    use meta_secret_core::crypto::key_pair::KeyPair;
     use super::*;
+    use meta_secret_core::node::common::model::crypto::{AeadCipherText, AeadPlainText, EncryptedMessage};
+    use meta_secret_core::node::common::model::secret::MetaPasswordId;
+    use meta_secret_core::secret;
 
     pub fn generate_security_box(vault_name_bytes: *const u8, len: SizeT) -> CoreResult<String> {
-        let device_name = data_to_string(vault_name_bytes, len)?;
-        let security_box = KeyManager::generate_security_box(device_name);
+        let security_box = KeyManager::generate_secret_box();
         let user = serde_json::to_string_pretty(&security_box)?;
         Ok(user)
     }
@@ -92,7 +95,7 @@ mod internal {
 
         // JSON parsing
         let json_string: String = data_to_string(strings_bytes, string_len)?;
-        let shares: Vec<UserShareDto> = shared_secret::split(json_string, cfg)?;
+        let shares: Vec<UserShareDto> = secret::split(json_string, cfg)?;
 
         // Shares to JSon
         let result_json = serde_json::to_string_pretty(&shares)?;
@@ -116,7 +119,7 @@ mod internal {
 
         // Encrypt shares
         let encrypted_share: AeadCipherText = key_manager
-            .transport_key_pair
+            .transport
             .encrypt_string(json_struct.secret, json_struct.receiver_pub_key)?;
 
         // Shares to JSon
@@ -131,10 +134,9 @@ mod internal {
 
         println!("restore_task {:?}", restore_task.doc);
         // Decrypt shares
-        let share_json: AeadPlainText = key_manager
-            .transport_key_pair
-            .decrypt(&restore_task.doc.secret_message.encrypted_text)?;
-        let share_json = UserShareDto::try_from(share_json.msg.as_ref())?;
+        let EncryptedMessage::CipherShare { share, .. } = restore_task.doc.secret_message;
+        let share_json: AeadPlainText = share.decrypt(&key_manager.transport.secret_key)?;
+        let share_json = UserShareDto::try_from(&share_json.msg)?;
 
         // Decrypted Share to JSon
         let result_json = serde_json::to_string_pretty(&share_json)?;
@@ -146,16 +148,16 @@ mod internal {
         let restore_task = RestoreTask::try_from(&data_string)?;
 
         let key_manager = KeyManager::try_from(&restore_task.key_manager)?;
-        let share_from_device_2_json: AeadPlainText = key_manager
-            .transport_key_pair
-            .decrypt(&restore_task.doc_two.secret_message.encrypted_text)?;
-        let share_from_device_2_json = UserShareDto::try_from(share_from_device_2_json.msg.as_ref())?;
+        let EncryptedMessage::CipherShare {
+            share: second_share, ..
+        } = restore_task.doc_two.secret_message;
+        let share_from_device_2_json: AeadPlainText = second_share.decrypt(&key_manager.transport.secret_key)?;
+        let share_from_device_2_json = UserShareDto::try_from(&share_from_device_2_json.msg)?;
 
-        let share_from_device_1_json: AeadPlainText = key_manager
-            .transport_key_pair
-            .decrypt(&restore_task.doc_one.secret_message.encrypted_text)?;
+        let EncryptedMessage::CipherShare { share: first_share, .. } = restore_task.doc_one.secret_message;
+        let share_from_device_1_json: AeadPlainText = first_share.decrypt(&key_manager.transport.secret_key)?;
 
-        let share_from_device_1_json = UserShareDto::try_from(share_from_device_1_json.msg.as_ref())?;
+        let share_from_device_1_json = UserShareDto::try_from(&share_from_device_1_json.msg)?;
 
         // Restored Password to JSon
         let password = recover_from_shares(vec![share_from_device_2_json, share_from_device_1_json])?;
@@ -185,8 +187,8 @@ fn data_to_string(bytes: *const u8, len: SizeT) -> CoreResult<String> {
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct JsonMappedData {
-    sender_key_manager: SerializedKeyManager,
-    receiver_pub_key: Base64EncodedText,
+    sender_key_manager: SecretBox,
+    receiver_pub_key: Base64Text,
     secret: String,
 }
 
@@ -202,16 +204,16 @@ impl TryFrom<&String> for JsonMappedData {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct RestoreTask {
-    key_manager: SerializedKeyManager,
-    doc_one: SecretDistributionDocData,
-    doc_two: SecretDistributionDocData,
+    key_manager: SecretBox,
+    doc_one: SecretDistributionData,
+    doc_two: SecretDistributionData,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct DecryptTask {
-    key_manager: SerializedKeyManager,
-    doc: SecretDistributionDocData,
+    key_manager: SecretBox,
+    doc: SecretDistributionData,
 }
 
 impl TryFrom<&String> for RestoreTask {
@@ -235,12 +237,13 @@ impl TryFrom<&String> for DecryptTask {
 //TESTS
 #[cfg(test)]
 pub mod test {
+    use meta_secret_core::crypto::encoding::base64::Base64Text;
     use meta_secret_core::crypto::key_pair::KeyPair;
     use meta_secret_core::crypto::keys::KeyManager;
-    use meta_secret_core::shared_secret::data_block::common::SharedSecretConfig;
-    use meta_secret_core::shared_secret::shared_secret::UserShareDto;
-    use meta_secret_core::{shared_secret, CoreResult};
-    use meta_secret_core::models::AeadCipherText;
+    use meta_secret_core::node::common::model::crypto::AeadCipherText;
+    use meta_secret_core::secret::data_block::common::SharedSecretConfig;
+    use meta_secret_core::secret::shared_secret::UserShareDto;
+    use meta_secret_core::{secret, CoreResult};
 
     #[test]
     fn split_and_encrypt() -> CoreResult<()> {
@@ -257,15 +260,15 @@ pub mod test {
         let key_manager_2 = KeyManager::generate();
 
         // Split
-        let shares: Vec<UserShareDto> = shared_secret::split("Secret".to_string(), cfg)?;
+        let shares: Vec<UserShareDto> = secret::split("Secret".to_string(), cfg)?;
 
         // Encrypt shares
         let secret = shares[0].clone();
-        let password_share: String = secret.share_blocks[0].data.base64_text.clone();
-        let receiver_pk = key_manager_2.transport_key_pair.public_key();
+        let Base64Text(password_share_text) = secret.share_blocks[0].data.clone();
+        let receiver_pk = key_manager_2.transport.public_key();
         let encrypted_share: AeadCipherText = key_manager_1
-            .transport_key_pair
-            .encrypt_string(password_share, receiver_pk)?;
+            .transport
+            .encrypt_string(password_share_text, receiver_pk)?;
 
         println!("result {:?}", encrypted_share);