...

omikron-connector/Cargo.toml

@@ -4,6 +4,10 @@ version = "0.1.0"
 edition = "2024"
 
 [dependencies]
+iota-logger = { path = "../iota-logger" }
+iota-state = { path = "../iota-state" }
+iota-storage = { path = "../iota-storage" }
+iota-util = { path = "../iota-util" }
 ttp-core = { git = "https://github.com/Tensamin/TTP.git", package = "ttp-core" }
 ttp-native = { git = "https://github.com/Tensamin/TTP.git", package = "ttp-native" }
 
@@ -11,3 +15,8 @@ dashmap = "6.1.0"
 json = "*"
 tokio = { version = "1.50.0", features = ["full"] }
 uuid = { version = "*", features = ["v4"] }
+base64 = "0.22.1"
+hex = "*"
+rand_core = { version = "0.6", features = ["getrandom", "std"] }
+sha2 = "0.10.9"
+x448 = { version = "*" }

omikron-connector/src/lib.rs

@@ -1,2 +1,3 @@
 pub mod omikron_connection;
 pub mod ping_pong_task;
+pub mod user_ops;

omikron-connector/src/omikron_connection.rs

@@ -1,12 +1,14 @@
-use crate::users::contact::Contact;
-use crate::util::chat_files::{MessageState, change_message_state};
-use crate::util::chats_util::{get_user, mod_user};
-use crate::util::communities_util::CommunitiesUtil;
-use crate::util::crypto_util::{DataFormat, SecurePayload};
-use crate::util::file_util::{get_children, load_file, save_file};
-use crate::util::{chat_files, chats_util};
-use crate::util::{config_util::CONFIG, crypto_helper};
-use crate::{ACTIVE_TASKS, SHUTDOWN, log, log_cv_in, log_cv_out, log_t};
+use iota_storage::users::contact::Contact;
+use iota_storage::util::chat_files::{MessageState, change_message_state};
+use iota_storage::util::chats_util::{get_user, mod_user};
+use iota_storage::util::communities_util::CommunitiesUtil;
+use iota_util::crypto_util::{DataFormat, SecurePayload};
+use iota_util::file_util::{get_children, load_file, save_file};
+use iota_storage::util::{chat_files, chats_util};
+use iota_storage::util::config_util::CONFIG;
+use iota_util::crypto_helper;
+use iota_state::{ACTIVE_TASKS, SHUTDOWN};
+use iota_logger::{log, log_cv_in, log_cv_out, log_t};
 use dashmap::DashMap;
 use json::JsonValue;
 use std::collections::HashMap;

omikron-connector/src/ping_pong_task.rs

@@ -1,5 +1,6 @@
-use crate::omikron::omikron_connection::OmikronConnection;
-use crate::{APP_STATE, log};
+use crate::omikron_connection::OmikronConnection;
+use iota_state::APP_STATE;
+use iota_logger::log;
 use dashmap::DashMap;
 use std::sync::LazyLock;
 use std::time::Instant;

omikron-connector/src/user_ops.rs

@@ -0,0 +1,93 @@
+use base64::{Engine as _, engine::general_purpose::STANDARD};
+use hex;
+use iota_logger::{PrintType, log, log_cv};
+use iota_state::{RELOAD, SHUTDOWN};
+use iota_storage::users::user_manager::{add_user, save_users};
+use iota_storage::users::user_profile::UserProfile;
+use iota_util::crypto_helper::public_key_to_base64;
+use iota_util::file_util::save_file;
+use rand_core::{OsRng, RngCore};
+use sha2::{Digest, Sha256};
+use std::time::Duration;
+use ttp_core::{CommunicationType, CommunicationValue, DataTypes, DataValue};
+use x448::{PublicKey, Secret};
+
+use crate::omikron_connection::OMIKRON_CONNECTION;
+
+pub async fn create_user(username: &str) -> (Option<UserProfile>, Option<String>) {
+    let register_cv = CommunicationValue::new(CommunicationType::get_register);
+
+    let conn = OMIKRON_CONNECTION.clone();
+
+    let response_cv = match conn
+        .await_response(&register_cv, Some(Duration::from_secs(20)))
+        .await
+    {
+        Ok(cv) => cv,
+        Err(_) => return (None, None),
+    };
+    log_cv!(PrintType::Omega, response_cv);
+
+    let user_id = match response_cv.get_data(DataTypes::user_id).as_number() {
+        Some(id) => id,
+        None => return (None, None),
+    };
+    let mut buf = [0u8; 56];
+    let mut rng = OsRng;
+    rng.fill_bytes(&mut buf);
+    let private_key = Secret::from_bytes(&buf).unwrap();
+    let public_key = PublicKey::from(&private_key);
+
+    let mut hasher = Sha256::new();
+    hasher.update(&STANDARD.encode(&private_key.as_bytes()).as_bytes());
+    let result = hasher.finalize();
+    let private_key_hash = hex::encode(result);
+
+    let mut bytes = [0u8; 192];
+    OsRng.fill_bytes(&mut bytes);
+    let reset_token = STANDARD.encode(&bytes);
+
+    let up = UserProfile::new(
+        user_id,
+        username.to_string(),
+        None,
+        STANDARD.encode(&public_key.as_bytes()),
+        private_key_hash,
+        reset_token.clone(),
+    );
+
+    let cv = CommunicationValue::new(CommunicationType::complete_register_user)
+        .add_data(DataTypes::user_id, DataValue::Number(user_id))
+        .add_data(DataTypes::username, DataValue::Str(username.to_string()))
+        .add_data(
+            DataTypes::public_key,
+            DataValue::Str(public_key_to_base64(&public_key)),
+        )
+        .add_data(DataTypes::iota_id, DataValue::Number(user_id))
+        .add_data(DataTypes::reset_token, DataValue::Str(reset_token));
+
+    let response_cv = conn
+        .await_response(&cv, Some(Duration::from_secs(20)))
+        .await;
+
+    if let Ok(resp) = response_cv {
+        log_cv!(PrintType::Omega, resp);
+        if !resp.is_type(CommunicationType::success) {
+            return (None, None);
+        }
+    } else {
+        return (None, None);
+    }
+    *SHUTDOWN.write().await = true;
+    *RELOAD.write().await = true;
+    log!("Created User");
+    save_file(
+        "",
+        &format!("{}.tu", username),
+        &format!("{}::{}", user_id, STANDARD.encode(&private_key.as_bytes())),
+    );
+
+    add_user(up.clone());
+    save_users();
+    (Some(up), Some(STANDARD.encode(&private_key.as_bytes())))
+}