titanpl 7.0.0 → 7.0.1

package/packages/core-source/native/Cargo.toml

@@ -1,30 +0,0 @@
-[package]
-name = "titan-core"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-serde = { version = "1.0", features = ["derive"] }
-serde_json = "1.0"
-uuid = { version = "1.4", features = ["v4", "fast-rng"] }
-sha2 = "0.10"
-md-5 = "0.10"
-base64 = "0.21"
-rand = "0.8"
-sys-info = "0.9"
-chrono = "0.4"
-dns-lookup = "2.0"
-local-ip-address = "0.5"
-whoami = "1.4"
-hex = "0.4"
-aes-gcm = "0.10"
-hmac = "0.12"
-subtle = "2.5"
-regex = "1"
-parking_lot = "0.12"
-sysinfo = "0.30"
-v8 = "0.106.0"
-

package/packages/core-source/native/src/crypto_impl.rs

@@ -1,139 +0,0 @@
-use aes_gcm::{
-    aead::{Aead, KeyInit},
-    Aes256Gcm, Nonce,
-};
-use hmac::{Hmac, Mac};
-use sha2::{Sha256, Sha512};
-use sha2::Digest;
-use subtle::ConstantTimeEq;
-use base64::{Engine as _, engine::general_purpose};
-use std::str;
-
-// Helper to decode key or use as is
-fn prepare_key(key: &str, expected_len: usize) -> Result<Vec<u8>, String> {
-    // Try user string as bytes
-    let bytes = key.as_bytes();
-    if bytes.len() == expected_len {
-        return Ok(bytes.to_vec());
-    }
-    // If not, maybe it is hex?
-    if let Ok(decoded) = hex::decode(key) {
-        if decoded.len() == expected_len {
-            return Ok(decoded);
-        }
-    }
-    // If not, maybe base64?
-    if let Ok(decoded) = general_purpose::STANDARD.decode(key) {
-        if decoded.len() == expected_len {
-            return Ok(decoded);
-        }
-    }
-    Err(format!("Invalid key length. Expected {} bytes.", expected_len))
-}
-
-/// Encrypts plaintext using AES-256-GCM.
-/// Returns Base64 encoded string containing nonce + ciphertext.
-pub fn encrypt(algo: &str, key: &str, plaintext: &str) -> Result<String, String> {
-    match algo {
-        "aes-256-gcm" | "aes256" => {
-            let key_bytes = prepare_key(key, 32)?;
-            let cipher = Aes256Gcm::new_from_slice(&key_bytes).map_err(|e| e.to_string())?;
-            // Generate a random 96-bit nonce
-            let mut nonce_bytes = [0u8; 12];
-            rand::Rng::fill(&mut rand::thread_rng(), &mut nonce_bytes);
-            let nonce = Nonce::from_slice(&nonce_bytes);
-
-            let ciphertext = cipher.encrypt(nonce, plaintext.as_bytes())
-                .map_err(|_| "Encryption failed".to_string())?;
-            
-            // Return format: nonce + ciphertext (base64)
-            let mut combined = nonce_bytes.to_vec();
-            combined.extend(ciphertext);
-            Ok(general_purpose::STANDARD.encode(&combined))
-        },
-        _ => Err(format!("Unsupported algorithm: {}", algo))
-    }
-}
-
-/// Decrypts a Base64 encoded string (nonce + ciphertext) using AES-256-GCM.
-pub fn decrypt(algo: &str, key: &str, ciphertext: &str) -> Result<Vec<u8>, String> {
-    match algo {
-        "aes-256-gcm" | "aes256" => {
-            let key_bytes = prepare_key(key, 32)?;
-            let cipher = Aes256Gcm::new_from_slice(&key_bytes).map_err(|e| e.to_string())?;
-
-            let data = general_purpose::STANDARD.decode(ciphertext)
-                .map_err(|_| "Invalid Base64 ciphertext".to_string())?;
-            
-            if data.len() < 12 {
-                return Err("DECRYPTION_FAILED: Invalid ciphertext length".to_string());
-            }
-
-            let (nonce_bytes, ciphertext_bytes) = data.split_at(12);
-            let nonce = Nonce::from_slice(nonce_bytes);
-
-            let plaintext_bytes = cipher.decrypt(nonce, ciphertext_bytes)
-                .map_err(|_| "DECRYPTION_FAILED".to_string())?;
-            
-            Ok(plaintext_bytes)
-        },
-        _ => Err(format!("Unsupported algorithm: {}", algo))
-    }
-}
-
-pub fn hash_keyed(algo: &str, key: &str, message: &str) -> Result<String, String> {
-    match algo {
-        "sha256" => {
-            type HmacSha256 = Hmac<Sha256>;
-            let mut mac = <HmacSha256 as Mac>::new_from_slice(key.as_bytes())
-                .map_err(|_| "Invalid key length".to_string())?;
-            mac.update(message.as_bytes());
-            let result = mac.finalize();
-            Ok(hex::encode(result.into_bytes()))
-        },
-        "sha512" => {
-            type HmacSha512 = Hmac<Sha512>;
-            let mut mac = <HmacSha512 as Mac>::new_from_slice(key.as_bytes())
-                .map_err(|_| "Invalid key length".to_string())?;
-            mac.update(message.as_bytes());
-            let result = mac.finalize();
-            Ok(hex::encode(result.into_bytes()))
-        },
-        _ => Err(format!("Unsupported algorithm: {}", algo))
-    }
-}
-
-
-pub fn compare(a: &str, b: &str) -> bool {
-    let a_bytes = a.as_bytes();
-    let b_bytes = b.as_bytes();
-    if a_bytes.len() != b_bytes.len() {
-        return false;
-    }
-    a_bytes.ct_eq(b_bytes).into()
-}
-
-pub fn hash(algo: &str, data: &str) -> String {
-    match algo {
-        "sha512" => {
-            use sha2::Digest;
-            let mut h = Sha512::new();
-            h.update(data.as_bytes());
-            hex::encode(h.finalize())
-        },
-        _ => {
-            // Default: sha256
-            use sha2::Digest;
-            let mut h = Sha256::new();
-            h.update(data.as_bytes());
-            hex::encode(h.finalize())
-        }
-    }
-}
-
-pub fn random_bytes(size: usize) -> String {
-    use rand::RngCore;
-    let mut bytes = vec![0u8; size];
-    rand::thread_rng().fill_bytes(&mut bytes);
-    general_purpose::STANDARD.encode(&bytes)
-}