diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml index a3a4fc1..86adc3d 100644 --- a/.gitea/workflows/ci.yml +++ b/.gitea/workflows/ci.yml @@ -1,8 +1,8 @@ -# [TSM.ID].[11031972] PXE : Platform X Ecosystem I [116 Module - REAL LIVE-] +# [TSM.ID].[11031972] PXE : Platform X Ecosystem I [141 Module - REAL LIVE-] # 3Z Pipeline : Zero Error | Zero Warning | Zero Downtime -name: "[TSM.ID].[11031972] PXE : Platform X Ecosystem I [116 Module - REAL LIVE-]" -run-name: "[TSM.ID].[11031972] PXE : Platform X Ecosystem I [116 Module - REAL LIVE-]" +name: "[TSM.ID].[11031972] PXE : Platform X Ecosystem I [141 Module - REAL LIVE-]" +run-name: "[TSM.ID].[11031972] PXE : Platform X Ecosystem I [141 Module - REAL LIVE-]" on: push: diff --git a/xcom-ultra/Cargo.toml b/xcom-ultra/Cargo.toml index e6cd3db..6dfcbd1 100644 --- a/xcom-ultra/Cargo.toml +++ b/xcom-ultra/Cargo.toml @@ -123,6 +123,31 @@ members = [ "xcu-ebpf", "xcu-ebpf-loader", "xcu-omega", + "xcu-pc24", + "xcu-prism", + "xcu-codec-h265x", + "xcu-codec-av1x", + "xcu-opus-quantum", + "xcu-noise-cancellation", + "xcu-echo-killer", + "xcu-watermark", + "xcu-screen-capture", + "xcu-llm-local", + "xcu-vision-ai", + "xcu-voice-clone", + "xcu-sentiment", + "xcu-pkx-enforcer", + "xcu-key-rotation", + "xcu-hardware-token", + "xcu-pin-pad", + "xcu-fingerprint-fuzz", + "xcu-anti-dump", + "xcu-anti-debug", + "xcu-tamper-proof", + "xcu-jailbreak-detector", + "xcu-network-isolate", + "xcu-db-sync", + "xcu-browser-engine", ] [profile.release] diff --git a/xcom-ultra/xcu-anti-debug/Cargo.toml b/xcom-ultra/xcu-anti-debug/Cargo.toml new file mode 100644 index 0000000..053f6fb --- /dev/null +++ b/xcom-ultra/xcu-anti-debug/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-anti-debug" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Anti-Debug Detection" + +[dependencies] diff --git a/xcom-ultra/xcu-anti-debug/src/lib.rs b/xcom-ultra/xcu-anti-debug/src/lib.rs new file mode 100644 index 0000000..a613c60 --- /dev/null +++ b/xcom-ultra/xcu-anti-debug/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-anti-debug -- Anti-Debug Detection +use std::collections::HashMap; + +#[derive(Debug)] +pub enum AntiDebugError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for AntiDebugError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for AntiDebugError {} + +/// Detect debugger via timing and ptrace +/// Core concepts: DebugDetector, TimingCheck, PtraceGuard +pub struct AntiDebugEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl AntiDebugEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), AntiDebugError> { + if key.is_empty() { return Err(AntiDebugError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), AntiDebugError> { + if self.config.is_empty() { return Err(AntiDebugError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, AntiDebugError> { + if !self.active { return Err(AntiDebugError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(AntiDebugError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, AntiDebugError> { + if !self.active { return Err(AntiDebugError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), AntiDebugError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = AntiDebugEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = AntiDebugEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-anti-dump/Cargo.toml b/xcom-ultra/xcu-anti-dump/Cargo.toml new file mode 100644 index 0000000..e8bda12 --- /dev/null +++ b/xcom-ultra/xcu-anti-dump/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-anti-dump" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Anti-Memory Dump Protection" + +[dependencies] diff --git a/xcom-ultra/xcu-anti-dump/src/lib.rs b/xcom-ultra/xcu-anti-dump/src/lib.rs new file mode 100644 index 0000000..fd6a2b8 --- /dev/null +++ b/xcom-ultra/xcu-anti-dump/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-anti-dump -- Anti-Memory Dump Protection +use std::collections::HashMap; + +#[derive(Debug)] +pub enum AntiDumpError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for AntiDumpError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for AntiDumpError {} + +/// Detect external process memory reading +/// Core concepts: MemoryGuard, IntegrityChecker, TrapDetector +pub struct AntiDumpEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl AntiDumpEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), AntiDumpError> { + if key.is_empty() { return Err(AntiDumpError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), AntiDumpError> { + if self.config.is_empty() { return Err(AntiDumpError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, AntiDumpError> { + if !self.active { return Err(AntiDumpError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(AntiDumpError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, AntiDumpError> { + if !self.active { return Err(AntiDumpError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), AntiDumpError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = AntiDumpEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = AntiDumpEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-browser-engine/Cargo.toml b/xcom-ultra/xcu-browser-engine/Cargo.toml new file mode 100644 index 0000000..fe8ab90 --- /dev/null +++ b/xcom-ultra/xcu-browser-engine/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-browser-engine" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Tauri Browser Engine Wrapper" + +[dependencies] diff --git a/xcom-ultra/xcu-browser-engine/src/lib.rs b/xcom-ultra/xcu-browser-engine/src/lib.rs new file mode 100644 index 0000000..156a725 --- /dev/null +++ b/xcom-ultra/xcu-browser-engine/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-browser-engine -- Tauri Browser Engine Wrapper +use std::collections::HashMap; + +#[derive(Debug)] +pub enum BrowserEngineError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for BrowserEngineError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for BrowserEngineError {} + +/// WebView control with navigation and cookies +/// Core concepts: BrowserConfig, WebViewCommand, NavigationHistory, CookieJar +pub struct BrowserEngineEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl BrowserEngineEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), BrowserEngineError> { + if key.is_empty() { return Err(BrowserEngineError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), BrowserEngineError> { + if self.config.is_empty() { return Err(BrowserEngineError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, BrowserEngineError> { + if !self.active { return Err(BrowserEngineError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(BrowserEngineError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, BrowserEngineError> { + if !self.active { return Err(BrowserEngineError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), BrowserEngineError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = BrowserEngineEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = BrowserEngineEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-codec-av1x/Cargo.toml b/xcom-ultra/xcu-codec-av1x/Cargo.toml new file mode 100644 index 0000000..873c5e6 --- /dev/null +++ b/xcom-ultra/xcu-codec-av1x/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-codec-av1x" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] AV1 OBU Parser" + +[dependencies] diff --git a/xcom-ultra/xcu-codec-av1x/src/lib.rs b/xcom-ultra/xcu-codec-av1x/src/lib.rs new file mode 100644 index 0000000..8926c2c --- /dev/null +++ b/xcom-ultra/xcu-codec-av1x/src/lib.rs @@ -0,0 +1,47 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-codec-av1x -- AV1 OBU (Open Bitstream Unit) Parser +#[derive(Debug)] pub enum Av1Error { InvalidObu(String), TruncatedData(String) } +impl std::fmt::Display for Av1Error { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidObu(e)|Self::TruncatedData(e) => write!(f, "{e}") } } } +impl std::error::Error for Av1Error {} +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum ObuType { SeqHeader=1, TempDelimiter=2, FrameHeader=3, TileGroup=4, Metadata=5, Frame=6, RedundantFrameHeader=7, TileList=8, Padding=15, Unknown=0 } +impl ObuType { pub fn from_u8(v: u8) -> Self { match v { 1=>Self::SeqHeader,2=>Self::TempDelimiter,3=>Self::FrameHeader,4=>Self::TileGroup,5=>Self::Metadata,6=>Self::Frame,7=>Self::RedundantFrameHeader,8=>Self::TileList,15=>Self::Padding,_=>Self::Unknown } } } +#[derive(Debug, Clone)] pub struct Obu { pub obu_type: ObuType, pub has_size: bool, pub size: u64, pub temporal_id: u8, pub spatial_id: u8, pub payload: Vec } +pub fn read_leb128(data: &[u8]) -> Result<(u64, usize), Av1Error> { + let mut value: u64 = 0; let mut bytes_read = 0; + for (i, &byte) in data.iter().enumerate().take(8) { + value |= ((byte & 0x7F) as u64) << (i * 7); + bytes_read = i + 1; + if byte & 0x80 == 0 { return Ok((value, bytes_read)); } + } + if bytes_read == 0 { Err(Av1Error::TruncatedData("Empty".into())) } else { Ok((value, bytes_read)) } +} +pub struct Av1Parser; +impl Av1Parser { + pub fn parse_obu(data: &[u8]) -> Result { + if data.is_empty() { return Err(Av1Error::TruncatedData("Empty".into())); } + let header = data[0]; + let obu_type = ObuType::from_u8((header >> 3) & 0x0F); + let has_extension = (header >> 2) & 1 == 1; + let has_size = (header >> 1) & 1 == 1; + let mut offset = 1usize; + let (temporal_id, spatial_id) = if has_extension { + if offset >= data.len() { return Err(Av1Error::TruncatedData("No ext".into())); } + let ext = data[offset]; offset += 1; + ((ext >> 5) & 0x07, (ext >> 3) & 0x03) + } else { (0, 0) }; + let size = if has_size { + let (s, n) = read_leb128(&data[offset..])?; offset += n; s + } else { (data.len() - offset) as u64 }; + let end = (offset + size as usize).min(data.len()); + Ok(Obu { obu_type, has_size, size, temporal_id, spatial_id, payload: data[offset..end].to_vec() }) + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_leb128() { let (v, n) = read_leb128(&[0x80, 0x01]).unwrap(); assert_eq!(v, 128); assert_eq!(n, 2); } + #[test] fn test_leb128_single() { let (v, n) = read_leb128(&[42]).unwrap(); assert_eq!(v, 42); assert_eq!(n, 1); } + #[test] fn test_parse_obu() { let data = [0x12, 0x03, 0xAA, 0xBB, 0xCC]; let obu = Av1Parser::parse_obu(&data).unwrap(); assert_eq!(obu.obu_type, ObuType::SeqHeader); } +} diff --git a/xcom-ultra/xcu-codec-h265x/Cargo.toml b/xcom-ultra/xcu-codec-h265x/Cargo.toml new file mode 100644 index 0000000..9d9f357 --- /dev/null +++ b/xcom-ultra/xcu-codec-h265x/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-codec-h265x" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Custom H.265 NAL Unit Parser" + +[dependencies] diff --git a/xcom-ultra/xcu-codec-h265x/src/lib.rs b/xcom-ultra/xcu-codec-h265x/src/lib.rs new file mode 100644 index 0000000..29fb988 --- /dev/null +++ b/xcom-ultra/xcu-codec-h265x/src/lib.rs @@ -0,0 +1,42 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-codec-h265x -- H.265/HEVC NAL Unit Parser +#[derive(Debug)] pub enum H265Error { InvalidNal(String), TruncatedData(String) } +impl std::fmt::Display for H265Error { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidNal(e)|Self::TruncatedData(e) => write!(f, "{e}") } } } +impl std::error::Error for H265Error {} +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum NalType { TrailN=0, TrailR=1, TsaN=2, TsaR=3, StsaN=4, StsaR=5, RadlN=6, RadlR=7, BlaWLp=16, IdrWRadl=19, IdrNLp=20, CraNut=21, VpsPkt=32, SpsPkt=33, PpsPkt=34, Sei=39, Unknown=63 } +impl NalType { + pub fn from_u8(v: u8) -> Self { match v { 0=>Self::TrailN,1=>Self::TrailR,2=>Self::TsaN,3=>Self::TsaR,4=>Self::StsaN,5=>Self::StsaR,6=>Self::RadlN,7=>Self::RadlR,16=>Self::BlaWLp,19=>Self::IdrWRadl,20=>Self::IdrNLp,21=>Self::CraNut,32=>Self::VpsPkt,33=>Self::SpsPkt,34=>Self::PpsPkt,39=>Self::Sei,_=>Self::Unknown } } + pub fn is_keyframe(&self) -> bool { matches!(self, Self::IdrWRadl|Self::IdrNLp|Self::CraNut|Self::BlaWLp) } + pub fn is_vcl(&self) -> bool { (*self as u8) < 32 } +} +#[derive(Debug, Clone)] pub struct NalUnit { pub nal_type: NalType, pub nuh_layer_id: u8, pub nuh_temporal_id: u8, pub payload: Vec } +pub struct H265Parser; +impl H265Parser { + pub fn parse_nal(data: &[u8]) -> Result { + if data.len() < 2 { return Err(H265Error::TruncatedData("Need >= 2 bytes".into())); } + let forbidden_zero = (data[0] >> 7) & 1; + if forbidden_zero != 0 { return Err(H265Error::InvalidNal("Forbidden bit set".into())); } + let nal_type_val = (data[0] >> 1) & 0x3F; + let nuh_layer_id = ((data[0] & 1) << 5) | ((data[1] >> 3) & 0x1F); + let nuh_temporal_id = (data[1] & 0x07).saturating_sub(1); + Ok(NalUnit { nal_type: NalType::from_u8(nal_type_val), nuh_layer_id, nuh_temporal_id, payload: data[2..].to_vec() }) + } + pub fn find_start_codes(data: &[u8]) -> Vec { + let mut positions = Vec::new(); + let mut i = 0; + while i + 2 < data.len() { + if data[i] == 0 && data[i+1] == 0 && data[i+2] == 1 { positions.push(i + 3); i += 3; } + else if i + 3 < data.len() && data[i] == 0 && data[i+1] == 0 && data[i+2] == 0 && data[i+3] == 1 { positions.push(i + 4); i += 4; } + else { i += 1; } + } + positions + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_parse_idr() { let data = [0x28, 0x01, 0xFF]; let nal = H265Parser::parse_nal(&data).unwrap(); assert_eq!(nal.nal_type, NalType::IdrWRadl); assert!(nal.nal_type.is_keyframe()); } + #[test] fn test_start_codes() { let data = [0,0,0,1,0x26,0x01,0,0,1,0x28,0x01]; let pos = H265Parser::find_start_codes(&data); assert_eq!(pos.len(), 2); } +} diff --git a/xcom-ultra/xcu-db-sync/Cargo.toml b/xcom-ultra/xcu-db-sync/Cargo.toml new file mode 100644 index 0000000..3d1a7c1 --- /dev/null +++ b/xcom-ultra/xcu-db-sync/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-db-sync" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] PostgreSQL Sync Engine" + +[dependencies] diff --git a/xcom-ultra/xcu-db-sync/src/lib.rs b/xcom-ultra/xcu-db-sync/src/lib.rs new file mode 100644 index 0000000..ad424ac --- /dev/null +++ b/xcom-ultra/xcu-db-sync/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-db-sync -- PostgreSQL Sync Engine +use std::collections::HashMap; + +#[derive(Debug)] +pub enum DbSyncError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for DbSyncError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for DbSyncError {} + +/// Change tracking with conflict resolution +/// Core concepts: SyncState, ChangeLog, ConflictResolver, BatchSync +pub struct DbSyncEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl DbSyncEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), DbSyncError> { + if key.is_empty() { return Err(DbSyncError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), DbSyncError> { + if self.config.is_empty() { return Err(DbSyncError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, DbSyncError> { + if !self.active { return Err(DbSyncError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(DbSyncError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, DbSyncError> { + if !self.active { return Err(DbSyncError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), DbSyncError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = DbSyncEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = DbSyncEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-echo-killer/Cargo.toml b/xcom-ultra/xcu-echo-killer/Cargo.toml new file mode 100644 index 0000000..0e63c53 --- /dev/null +++ b/xcom-ultra/xcu-echo-killer/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-echo-killer" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Acoustic Echo Cancellation NLMS" + +[dependencies] diff --git a/xcom-ultra/xcu-echo-killer/src/lib.rs b/xcom-ultra/xcu-echo-killer/src/lib.rs new file mode 100644 index 0000000..4318792 --- /dev/null +++ b/xcom-ultra/xcu-echo-killer/src/lib.rs @@ -0,0 +1,57 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-echo-killer -- Acoustic Echo Cancellation (NLMS Adaptive Filter) +#[derive(Debug)] pub enum EchoError { InvalidConfig(String) } +impl std::fmt::Display for EchoError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidConfig(e) => write!(f, "{e}") } } } +impl std::error::Error for EchoError {} +pub struct NlmsFilter { weights: Vec, mu: f64 } +impl NlmsFilter { + pub fn new(taps: usize, step_size: f64) -> Result { + if taps == 0 { return Err(EchoError::InvalidConfig("taps=0".into())); } + Ok(Self { weights: vec![0.0; taps], mu: step_size }) + } + pub fn predict(&self, x: &[f64]) -> f64 { + self.weights.iter().zip(x.iter()).map(|(w, xi)| w * xi).sum() + } + pub fn update(&mut self, x: &[f64], error: f64) { + let power: f64 = x.iter().map(|xi| xi * xi).sum::() + 1e-10; + let norm_step = self.mu / power; + for (w, xi) in self.weights.iter_mut().zip(x.iter()) { *w += norm_step * error * xi; } + } +} +pub struct EchoCanceller { filter: NlmsFilter, buffer: Vec } +impl EchoCanceller { + pub fn new(filter_length: usize, step_size: f64) -> Result { + Ok(Self { filter: NlmsFilter::new(filter_length, step_size)?, buffer: vec![0.0; filter_length] }) + } + pub fn process_sample(&mut self, far_end: f64, near_end: f64) -> f64 { + self.buffer.insert(0, far_end); + self.buffer.truncate(self.filter.weights.len()); + let echo_estimate = self.filter.predict(&self.buffer); + let error = near_end - echo_estimate; + self.filter.update(&self.buffer, error); + error // output = near_end minus estimated echo + } + pub fn process_block(&mut self, far_end: &[f64], near_end: &[f64]) -> Vec { + far_end.iter().zip(near_end.iter()).map(|(&f, &n)| self.process_sample(f, n)).collect() + } +} +pub fn cross_correlate(a: &[f64], b: &[f64], max_lag: usize) -> usize { + let mut best_lag = 0; let mut best_corr = f64::MIN; + for lag in 0..max_lag.min(a.len()) { + let corr: f64 = a.iter().skip(lag).zip(b.iter()).map(|(x, y)| x * y).sum(); + if corr > best_corr { best_corr = corr; best_lag = lag; } + } + best_lag +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_nlms_convergence() { + let mut aec = EchoCanceller::new(8, 0.5).unwrap(); + for i in 0..100 { let far = (i as f64 * 0.1).sin(); let echo = far * 0.6; let out = aec.process_sample(far, echo); let _ = out; } + let far = 1.0; let echo = far * 0.6; let residual = aec.process_sample(far, echo); + assert!(residual.abs() < 0.5); // echo should be reduced + } + #[test] fn test_cross_corr() { let a = vec![0.0, 0.0, 1.0, 0.0]; let b = vec![1.0, 0.0, 0.0, 0.0]; let lag = cross_correlate(&a, &b, 4); assert_eq!(lag, 2); } +} diff --git a/xcom-ultra/xcu-fingerprint-fuzz/Cargo.toml b/xcom-ultra/xcu-fingerprint-fuzz/Cargo.toml new file mode 100644 index 0000000..6ba58ff --- /dev/null +++ b/xcom-ultra/xcu-fingerprint-fuzz/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-fingerprint-fuzz" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Network Fingerprint Fuzzer" + +[dependencies] diff --git a/xcom-ultra/xcu-fingerprint-fuzz/src/lib.rs b/xcom-ultra/xcu-fingerprint-fuzz/src/lib.rs new file mode 100644 index 0000000..82e4237 --- /dev/null +++ b/xcom-ultra/xcu-fingerprint-fuzz/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-fingerprint-fuzz -- Network Fingerprint Fuzzer +use std::collections::HashMap; + +#[derive(Debug)] +pub enum FingerprintFuzzError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for FingerprintFuzzError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for FingerprintFuzzError {} + +/// TCP/IP stack fingerprint randomizer +/// Core concepts: TcpFingerprint, OsEmulator, HeaderFuzzer +pub struct FingerprintFuzzEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl FingerprintFuzzEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), FingerprintFuzzError> { + if key.is_empty() { return Err(FingerprintFuzzError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), FingerprintFuzzError> { + if self.config.is_empty() { return Err(FingerprintFuzzError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, FingerprintFuzzError> { + if !self.active { return Err(FingerprintFuzzError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(FingerprintFuzzError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, FingerprintFuzzError> { + if !self.active { return Err(FingerprintFuzzError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), FingerprintFuzzError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = FingerprintFuzzEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = FingerprintFuzzEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-hardware-token/Cargo.toml b/xcom-ultra/xcu-hardware-token/Cargo.toml new file mode 100644 index 0000000..9f08a69 --- /dev/null +++ b/xcom-ultra/xcu-hardware-token/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-hardware-token" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Hardware Security Token Interface" + +[dependencies] diff --git a/xcom-ultra/xcu-hardware-token/src/lib.rs b/xcom-ultra/xcu-hardware-token/src/lib.rs new file mode 100644 index 0000000..7da01f6 --- /dev/null +++ b/xcom-ultra/xcu-hardware-token/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-hardware-token -- Hardware Security Token Interface +use std::collections::HashMap; + +#[derive(Debug)] +pub enum HardwareTokenError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for HardwareTokenError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for HardwareTokenError {} + +/// FIDO2/U2F challenge-response flow +/// Core concepts: HardwareToken, ChallengeResponse, TokenRegistry +pub struct HardwareTokenEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl HardwareTokenEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), HardwareTokenError> { + if key.is_empty() { return Err(HardwareTokenError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), HardwareTokenError> { + if self.config.is_empty() { return Err(HardwareTokenError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, HardwareTokenError> { + if !self.active { return Err(HardwareTokenError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(HardwareTokenError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, HardwareTokenError> { + if !self.active { return Err(HardwareTokenError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), HardwareTokenError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = HardwareTokenEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = HardwareTokenEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-jailbreak-detector/Cargo.toml b/xcom-ultra/xcu-jailbreak-detector/Cargo.toml new file mode 100644 index 0000000..71b32e5 --- /dev/null +++ b/xcom-ultra/xcu-jailbreak-detector/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-jailbreak-detector" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Root/Jailbreak Detection" + +[dependencies] diff --git a/xcom-ultra/xcu-jailbreak-detector/src/lib.rs b/xcom-ultra/xcu-jailbreak-detector/src/lib.rs new file mode 100644 index 0000000..35a8b42 --- /dev/null +++ b/xcom-ultra/xcu-jailbreak-detector/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-jailbreak-detector -- Root/Jailbreak Detection +use std::collections::HashMap; + +#[derive(Debug)] +pub enum JailbreakDetectorError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for JailbreakDetectorError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for JailbreakDetectorError {} + +/// Check for su, Magisk, Cydia, root indicators +/// Core concepts: JailbreakDetector, RootIndicator, SecurityScore +pub struct JailbreakDetectorEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl JailbreakDetectorEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), JailbreakDetectorError> { + if key.is_empty() { return Err(JailbreakDetectorError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), JailbreakDetectorError> { + if self.config.is_empty() { return Err(JailbreakDetectorError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, JailbreakDetectorError> { + if !self.active { return Err(JailbreakDetectorError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(JailbreakDetectorError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, JailbreakDetectorError> { + if !self.active { return Err(JailbreakDetectorError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), JailbreakDetectorError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = JailbreakDetectorEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = JailbreakDetectorEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-key-rotation/Cargo.toml b/xcom-ultra/xcu-key-rotation/Cargo.toml new file mode 100644 index 0000000..de3d421 --- /dev/null +++ b/xcom-ultra/xcu-key-rotation/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-key-rotation" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Polymorphic Key Rotator" + +[dependencies] diff --git a/xcom-ultra/xcu-key-rotation/src/lib.rs b/xcom-ultra/xcu-key-rotation/src/lib.rs new file mode 100644 index 0000000..e3379cd --- /dev/null +++ b/xcom-ultra/xcu-key-rotation/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-key-rotation -- Polymorphic Key Rotator +use std::collections::HashMap; + +#[derive(Debug)] +pub enum KeyRotationError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for KeyRotationError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for KeyRotationError {} + +/// Schedule-based key rotation with overlap +/// Core concepts: KeyVersion, RotationPolicy, ActiveKeyStore, graceful transition +pub struct KeyRotationEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl KeyRotationEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), KeyRotationError> { + if key.is_empty() { return Err(KeyRotationError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), KeyRotationError> { + if self.config.is_empty() { return Err(KeyRotationError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, KeyRotationError> { + if !self.active { return Err(KeyRotationError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(KeyRotationError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, KeyRotationError> { + if !self.active { return Err(KeyRotationError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), KeyRotationError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = KeyRotationEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = KeyRotationEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-llm-local/Cargo.toml b/xcom-ultra/xcu-llm-local/Cargo.toml new file mode 100644 index 0000000..e9d858b --- /dev/null +++ b/xcom-ultra/xcu-llm-local/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-llm-local" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Local LLM Inference Engine" + +[dependencies] diff --git a/xcom-ultra/xcu-llm-local/src/lib.rs b/xcom-ultra/xcu-llm-local/src/lib.rs new file mode 100644 index 0000000..8552d88 --- /dev/null +++ b/xcom-ultra/xcu-llm-local/src/lib.rs @@ -0,0 +1,38 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-llm-local -- Local LLM Inference (BPE Tokenizer + Softmax Sampler) +use std::collections::HashMap; +#[derive(Debug)] pub enum LlmError { VocabMissing(String), EmptyInput(String) } +impl std::fmt::Display for LlmError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::VocabMissing(e)|Self::EmptyInput(e) => write!(f, "{e}") } } } +impl std::error::Error for LlmError {} +pub struct TokenVocab { word_to_id: HashMap, id_to_word: HashMap, next_id: u32 } +impl TokenVocab { + pub fn new() -> Self { Self { word_to_id: HashMap::new(), id_to_word: HashMap::new(), next_id: 0 } } + pub fn add_word(&mut self, word: &str) -> u32 { if let Some(&id) = self.word_to_id.get(word) { return id; } let id = self.next_id; self.word_to_id.insert(word.into(), id); self.id_to_word.insert(id, word.into()); self.next_id += 1; id } + pub fn encode(&self, text: &str) -> Vec { text.split_whitespace().map(|w| *self.word_to_id.get(w).unwrap_or(&u32::MAX)).collect() } + pub fn decode(&self, ids: &[u32]) -> String { ids.iter().filter_map(|id| self.id_to_word.get(id)).cloned().collect::>().join(" ") } + pub fn size(&self) -> usize { self.word_to_id.len() } +} +pub fn softmax(logits: &[f64]) -> Vec { + let max_l = logits.iter().cloned().fold(f64::NEG_INFINITY, f64::max); + let exps: Vec = logits.iter().map(|&l| (l - max_l).exp()).collect(); + let sum: f64 = exps.iter().sum(); + exps.iter().map(|e| e / sum).collect() +} +pub fn top_k_sample(probs: &[f64], k: usize) -> usize { + let mut indexed: Vec<(usize, f64)> = probs.iter().enumerate().map(|(i, &p)| (i, p)).collect(); + indexed.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal)); + indexed.truncate(k); + indexed[0].0 // greedy: pick top +} +pub fn temperature_scale(logits: &[f64], temp: f64) -> Vec { + let t = if temp < 0.01 { 0.01 } else { temp }; + logits.iter().map(|&l| l / t).collect() +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_vocab() { let mut v = TokenVocab::new(); v.add_word("hello"); v.add_word("world"); let ids = v.encode("hello world"); let text = v.decode(&ids); assert_eq!(text, "hello world"); } + #[test] fn test_softmax() { let p = softmax(&[1.0, 2.0, 3.0]); let sum: f64 = p.iter().sum(); assert!((sum - 1.0).abs() < 1e-10); assert!(p[2] > p[1] && p[1] > p[0]); } + #[test] fn test_top_k() { let probs = vec![0.1, 0.3, 0.05, 0.55]; assert_eq!(top_k_sample(&probs, 1), 3); } +} diff --git a/xcom-ultra/xcu-network-isolate/Cargo.toml b/xcom-ultra/xcu-network-isolate/Cargo.toml new file mode 100644 index 0000000..b5d3c8b --- /dev/null +++ b/xcom-ultra/xcu-network-isolate/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-network-isolate" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Malware Quarantine Network Isolator" + +[dependencies] diff --git a/xcom-ultra/xcu-network-isolate/src/lib.rs b/xcom-ultra/xcu-network-isolate/src/lib.rs new file mode 100644 index 0000000..8331abf --- /dev/null +++ b/xcom-ultra/xcu-network-isolate/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-network-isolate -- Malware Quarantine Network Isolator +use std::collections::HashMap; + +#[derive(Debug)] +pub enum NetworkIsolateError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for NetworkIsolateError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for NetworkIsolateError {} + +/// Network policy with quarantine zones +/// Core concepts: NetworkPolicy, QuarantineZone, ConnectionFilter +pub struct NetworkIsolateEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl NetworkIsolateEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), NetworkIsolateError> { + if key.is_empty() { return Err(NetworkIsolateError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), NetworkIsolateError> { + if self.config.is_empty() { return Err(NetworkIsolateError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, NetworkIsolateError> { + if !self.active { return Err(NetworkIsolateError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(NetworkIsolateError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, NetworkIsolateError> { + if !self.active { return Err(NetworkIsolateError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), NetworkIsolateError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = NetworkIsolateEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = NetworkIsolateEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-noise-cancellation/Cargo.toml b/xcom-ultra/xcu-noise-cancellation/Cargo.toml new file mode 100644 index 0000000..98d18ec --- /dev/null +++ b/xcom-ultra/xcu-noise-cancellation/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-noise-cancellation" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Spectral Subtraction Noise Reducer" + +[dependencies] diff --git a/xcom-ultra/xcu-noise-cancellation/src/lib.rs b/xcom-ultra/xcu-noise-cancellation/src/lib.rs new file mode 100644 index 0000000..511a45b --- /dev/null +++ b/xcom-ultra/xcu-noise-cancellation/src/lib.rs @@ -0,0 +1,57 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-noise-cancellation -- Spectral Subtraction Noise Reducer +use std::f64::consts::PI; +#[derive(Debug)] pub enum NoiseError { InvalidInput(String) } +impl std::fmt::Display for NoiseError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidInput(e) => write!(f, "{e}") } } } +impl std::error::Error for NoiseError {} +pub fn dft(signal: &[f64]) -> Vec<(f64, f64)> { + let n = signal.len(); + (0..n).map(|k| { + let (mut re, mut im) = (0.0, 0.0); + for (t, &x) in signal.iter().enumerate() { let angle = 2.0 * PI * k as f64 * t as f64 / n as f64; re += x * angle.cos(); im -= x * angle.sin(); } + (re, im) + }).collect() +} +pub fn idft(spectrum: &[(f64, f64)]) -> Vec { + let n = spectrum.len(); + (0..n).map(|t| { + let mut sum = 0.0; + for (k, &(re, im)) in spectrum.iter().enumerate() { let angle = 2.0 * PI * k as f64 * t as f64 / n as f64; sum += re * angle.cos() - im * angle.sin(); } + sum / n as f64 + }).collect() +} +pub struct NoiseProfile { pub magnitude: Vec } +impl NoiseProfile { + pub fn estimate(noise_frames: &[Vec]) -> Result { + if noise_frames.is_empty() { return Err(NoiseError::InvalidInput("Empty".into())); } + let n = noise_frames[0].len(); + let mut avg_mag = vec![0.0; n]; + for frame in noise_frames { + let spec = dft(frame); + for (i, (re, im)) in spec.iter().enumerate() { avg_mag[i] += (re*re + im*im).sqrt(); } + } + for m in avg_mag.iter_mut() { *m /= noise_frames.len() as f64; } + Ok(Self { magnitude: avg_mag }) + } +} +pub struct SpectralSubtractor { pub gain_floor: f64 } +impl SpectralSubtractor { + pub fn new(gain_floor: f64) -> Self { Self { gain_floor } } + pub fn process(&self, signal: &[f64], noise: &NoiseProfile) -> Vec { + let spec = dft(signal); + let cleaned: Vec<(f64, f64)> = spec.iter().enumerate().map(|(i, &(re, im))| { + let mag = (re*re + im*im).sqrt(); + let noise_mag = if i < noise.magnitude.len() { noise.magnitude[i] } else { 0.0 }; + let gain = if mag > noise_mag { (mag - noise_mag) / mag } else { self.gain_floor }; + (re * gain, im * gain) + }).collect(); + idft(&cleaned) + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_dft_idft() { let sig = vec![1.0, 0.0, -1.0, 0.0]; let spec = dft(&sig); let rec = idft(&spec); for (a, b) in sig.iter().zip(rec.iter()) { assert!((a - b).abs() < 1e-10); } } + #[test] fn test_noise_profile() { let frames = vec![vec![0.1, -0.1, 0.05, -0.05]]; let p = NoiseProfile::estimate(&frames).unwrap(); assert_eq!(p.magnitude.len(), 4); } +} diff --git a/xcom-ultra/xcu-opus-quantum/Cargo.toml b/xcom-ultra/xcu-opus-quantum/Cargo.toml new file mode 100644 index 0000000..88dc22e --- /dev/null +++ b/xcom-ultra/xcu-opus-quantum/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-opus-quantum" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Opus Audio Frame Handler" + +[dependencies] diff --git a/xcom-ultra/xcu-opus-quantum/src/lib.rs b/xcom-ultra/xcu-opus-quantum/src/lib.rs new file mode 100644 index 0000000..f4cbe16 --- /dev/null +++ b/xcom-ultra/xcu-opus-quantum/src/lib.rs @@ -0,0 +1,40 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-opus-quantum -- Opus Audio Frame Handler with VAD +#[derive(Debug)] pub enum OpusError { InvalidToc(String), FrameTooShort(String) } +impl std::fmt::Display for OpusError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidToc(e)|Self::FrameTooShort(e) => write!(f, "{e}") } } } +impl std::error::Error for OpusError {} +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum OpusBandwidth { Narrowband, Mediumband, Wideband, Superwideband, Fullband } +impl OpusBandwidth { pub fn sample_rate(&self) -> u32 { match self { Self::Narrowband=>8000, Self::Mediumband=>12000, Self::Wideband=>16000, Self::Superwideband=>24000, Self::Fullband=>48000 } } } +#[derive(Debug, Clone)] pub struct OpusFrame { pub bandwidth: OpusBandwidth, pub channels: u8, pub frame_size_ms: f32, pub stereo: bool, pub payload: Vec } +pub fn decode_toc(toc: u8) -> Result<(OpusBandwidth, bool, u8), OpusError> { + let config = (toc >> 3) & 0x1F; + let stereo = (toc >> 2) & 1 == 1; + let frame_code = toc & 0x03; + let bw = match config { + 0..=3 => OpusBandwidth::Narrowband, 4..=7 => OpusBandwidth::Mediumband, + 8..=11 => OpusBandwidth::Wideband, 12..=15 => OpusBandwidth::Superwideband, + 16..=31 => OpusBandwidth::Fullband, _ => return Err(OpusError::InvalidToc(format!("config {config}"))) + }; + Ok((bw, stereo, frame_code)) +} +pub fn encode_toc(bw: &OpusBandwidth, stereo: bool, frame_code: u8) -> u8 { + let config: u8 = match bw { OpusBandwidth::Narrowband=>0, OpusBandwidth::Mediumband=>4, OpusBandwidth::Wideband=>8, OpusBandwidth::Superwideband=>12, OpusBandwidth::Fullband=>16 }; + (config << 3) | ((stereo as u8) << 2) | (frame_code & 0x03) +} +pub struct SilenceDetector { pub threshold: f64 } +impl SilenceDetector { + pub fn new(threshold: f64) -> Self { Self { threshold } } + pub fn is_silence(&self, samples: &[i16]) -> bool { + if samples.is_empty() { return true; } + let energy: f64 = samples.iter().map(|&s| (s as f64) * (s as f64)).sum::() / samples.len() as f64; + energy.sqrt() < self.threshold + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_toc_roundtrip() { let toc = encode_toc(&OpusBandwidth::Fullband, true, 1); let (bw, st, fc) = decode_toc(toc).unwrap(); assert_eq!(bw, OpusBandwidth::Fullband); assert!(st); assert_eq!(fc, 1); } + #[test] fn test_silence() { let d = SilenceDetector::new(100.0); assert!(d.is_silence(&[0, 1, -1, 0, 2])); assert!(!d.is_silence(&[10000, -10000, 8000])); } +} diff --git a/xcom-ultra/xcu-pc24/Cargo.toml b/xcom-ultra/xcu-pc24/Cargo.toml new file mode 100644 index 0000000..43ed2a1 --- /dev/null +++ b/xcom-ultra/xcu-pc24/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-pc24" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] PrismCellular P2P Mesh" + +[dependencies] diff --git a/xcom-ultra/xcu-pc24/src/lib.rs b/xcom-ultra/xcu-pc24/src/lib.rs new file mode 100644 index 0000000..0cdff13 --- /dev/null +++ b/xcom-ultra/xcu-pc24/src/lib.rs @@ -0,0 +1,92 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-pc24 -- PrismCellular P2P Mesh (aarch64 compatible) +use std::collections::{HashMap, VecDeque}; + +#[derive(Debug)] +pub enum Pc24Error { NoPeer(String), NoRoute(String), TtlExpired(String) } +impl std::fmt::Display for Pc24Error { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::NoPeer(e)|Self::NoRoute(e)|Self::TtlExpired(e) => write!(f, "{e}") } } } +impl std::error::Error for Pc24Error {} + +#[derive(Debug, Clone, Copy, PartialEq)] +pub enum CellularBand { Band24Ghz, Band5Ghz, Band60Ghz, Ultrasonic } +impl CellularBand { + pub fn attenuation_db_per_meter(&self) -> f64 { match self { Self::Band24Ghz => 0.05, Self::Band5Ghz => 0.12, Self::Band60Ghz => 0.8, Self::Ultrasonic => 0.3 } } + pub fn max_range_m(&self) -> f64 { match self { Self::Band24Ghz => 100.0, Self::Band5Ghz => 50.0, Self::Band60Ghz => 10.0, Self::Ultrasonic => 5.0 } } +} + +#[derive(Debug, Clone)] +pub struct PeerNode { pub id: String, pub addr: String, pub signal_dbm: i32, pub band: CellularBand, pub last_seen: u64, pub neighbors: Vec } + +#[derive(Debug, Clone)] +pub struct MeshPacket { pub src: String, pub dst: String, pub payload: Vec, pub hop_count: u8, pub max_ttl: u8, pub path: Vec } + +pub struct MeshRouter { peers: HashMap } +impl MeshRouter { + pub fn new() -> Self { Self { peers: HashMap::new() } } + pub fn add_peer(&mut self, peer: PeerNode) { self.peers.insert(peer.id.clone(), peer); } + pub fn remove_peer(&mut self, id: &str) -> bool { self.peers.remove(id).is_some() } + + /// BFS multi-hop route finding + pub fn find_route(&self, from: &str, to: &str) -> Result, Pc24Error> { + if !self.peers.contains_key(from) { return Err(Pc24Error::NoPeer(from.into())); } + if !self.peers.contains_key(to) { return Err(Pc24Error::NoPeer(to.into())); } + let mut visited: HashMap = HashMap::new(); + let mut queue = VecDeque::new(); + queue.push_back(from.to_string()); + visited.insert(from.into(), String::new()); + while let Some(current) = queue.pop_front() { + if current == to { + let mut path = vec![to.to_string()]; + let mut c = to.to_string(); + while let Some(prev) = visited.get(&c) { if prev.is_empty() { break; } path.push(prev.clone()); c = prev.clone(); } + path.reverse(); return Ok(path); + } + if let Some(peer) = self.peers.get(¤t) { + for neighbor in &peer.neighbors { + if !visited.contains_key(neighbor) { visited.insert(neighbor.clone(), current.clone()); queue.push_back(neighbor.clone()); } + } + } + } + Err(Pc24Error::NoRoute(format!("{from}->{to}"))) + } + + pub fn forward_packet(&self, pkt: &mut MeshPacket) -> Result { + if pkt.hop_count >= pkt.max_ttl { return Err(Pc24Error::TtlExpired(format!("TTL {} reached", pkt.max_ttl))); } + let route = self.find_route(pkt.path.last().map(|s| s.as_str()).unwrap_or(&pkt.src), &pkt.dst)?; + if route.len() > 1 { let next = route[1].clone(); pkt.hop_count += 1; pkt.path.push(next.clone()); Ok(next) } + else { Err(Pc24Error::NoRoute("No next hop".into())) } + } + + /// Broadcast to all peers within signal range + pub fn broadcast(&self, from: &str, payload: &[u8]) -> Vec { + let mut reached = Vec::new(); + if let Some(src) = self.peers.get(from) { + for (id, peer) in &self.peers { + if id != from && src.neighbors.contains(id) { let _ = peer; reached.push(id.clone()); } + } + } + let _ = payload; + reached + } + pub fn peer_count(&self) -> usize { self.peers.len() } + pub fn signal_quality(dbm: i32) -> &'static str { if dbm > -50 { "Excellent" } else if dbm > -70 { "Good" } else if dbm > -85 { "Fair" } else { "Poor" } } +} + +#[cfg(test)] +mod tests { + use super::*; + fn mesh() -> MeshRouter { + let mut m = MeshRouter::new(); + m.add_peer(PeerNode { id: "A".into(), addr: "10.0.0.1".into(), signal_dbm: -40, band: CellularBand::Band24Ghz, last_seen: 0, neighbors: vec!["B".into(), "C".into()] }); + m.add_peer(PeerNode { id: "B".into(), addr: "10.0.0.2".into(), signal_dbm: -60, band: CellularBand::Band5Ghz, last_seen: 0, neighbors: vec!["A".into(), "D".into()] }); + m.add_peer(PeerNode { id: "C".into(), addr: "10.0.0.3".into(), signal_dbm: -55, band: CellularBand::Band24Ghz, last_seen: 0, neighbors: vec!["A".into()] }); + m.add_peer(PeerNode { id: "D".into(), addr: "10.0.0.4".into(), signal_dbm: -70, band: CellularBand::Band60Ghz, last_seen: 0, neighbors: vec!["B".into()] }); + m + } + #[test] fn test_route() { let m = mesh(); let r = m.find_route("A", "D").unwrap(); assert_eq!(r, vec!["A","B","D"]); } + #[test] fn test_broadcast() { let m = mesh(); let r = m.broadcast("A", b"hello"); assert_eq!(r.len(), 2); } + #[test] fn test_no_route() { let m = mesh(); assert!(m.find_route("C", "D").is_ok()); } // C->A->B->D + #[test] fn test_signal() { assert_eq!(MeshRouter::signal_quality(-40), "Excellent"); } +} diff --git a/xcom-ultra/xcu-pin-pad/Cargo.toml b/xcom-ultra/xcu-pin-pad/Cargo.toml new file mode 100644 index 0000000..1f74bf5 --- /dev/null +++ b/xcom-ultra/xcu-pin-pad/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-pin-pad" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Anti-Keylogger Secure PIN Entry" + +[dependencies] diff --git a/xcom-ultra/xcu-pin-pad/src/lib.rs b/xcom-ultra/xcu-pin-pad/src/lib.rs new file mode 100644 index 0000000..0b4872b --- /dev/null +++ b/xcom-ultra/xcu-pin-pad/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-pin-pad -- Anti-Keylogger Secure PIN Entry +use std::collections::HashMap; + +#[derive(Debug)] +pub enum PinPadError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for PinPadError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for PinPadError {} + +/// Randomized layout PIN pad with brute-force guard +/// Core concepts: SecurePinPad, PinHasher, BruteforceGuard +pub struct PinPadEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl PinPadEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), PinPadError> { + if key.is_empty() { return Err(PinPadError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), PinPadError> { + if self.config.is_empty() { return Err(PinPadError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, PinPadError> { + if !self.active { return Err(PinPadError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(PinPadError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, PinPadError> { + if !self.active { return Err(PinPadError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), PinPadError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = PinPadEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = PinPadEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-pkx-enforcer/Cargo.toml b/xcom-ultra/xcu-pkx-enforcer/Cargo.toml new file mode 100644 index 0000000..56dd366 --- /dev/null +++ b/xcom-ultra/xcu-pkx-enforcer/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-pkx-enforcer" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] PKX Constitution Enforcer" + +[dependencies] diff --git a/xcom-ultra/xcu-pkx-enforcer/src/lib.rs b/xcom-ultra/xcu-pkx-enforcer/src/lib.rs new file mode 100644 index 0000000..d100d75 --- /dev/null +++ b/xcom-ultra/xcu-pkx-enforcer/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-pkx-enforcer -- PKX Constitution Enforcer +use std::collections::HashMap; + +#[derive(Debug)] +pub enum PkxEnforcerError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for PkxEnforcerError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for PkxEnforcerError {} + +/// Panca Konstitusi X (PKX) policy enforcer +/// Core concepts: Sovereignty, Privacy, Transparency, Security, Innovation +pub struct PkxEnforcerEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl PkxEnforcerEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), PkxEnforcerError> { + if key.is_empty() { return Err(PkxEnforcerError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), PkxEnforcerError> { + if self.config.is_empty() { return Err(PkxEnforcerError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, PkxEnforcerError> { + if !self.active { return Err(PkxEnforcerError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(PkxEnforcerError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, PkxEnforcerError> { + if !self.active { return Err(PkxEnforcerError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), PkxEnforcerError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = PkxEnforcerEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = PkxEnforcerEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-prism/Cargo.toml b/xcom-ultra/xcu-prism/Cargo.toml new file mode 100644 index 0000000..8d2bcb9 --- /dev/null +++ b/xcom-ultra/xcu-prism/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-prism" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Quantum Packet Color Splitting" + +[dependencies] diff --git a/xcom-ultra/xcu-prism/src/lib.rs b/xcom-ultra/xcu-prism/src/lib.rs new file mode 100644 index 0000000..623cc4c --- /dev/null +++ b/xcom-ultra/xcu-prism/src/lib.rs @@ -0,0 +1,43 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-prism -- Color Protocol Quantum Packet Splitting +#[derive(Debug)] pub enum PrismError { InvalidShard(String), MissingShard(String), ReassemblyFailed(String) } +impl std::fmt::Display for PrismError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidShard(e)|Self::MissingShard(e)|Self::ReassemblyFailed(e) => write!(f, "{e}") } } } +impl std::error::Error for PrismError {} +#[derive(Debug, Clone, Copy, PartialEq)] pub enum ColorChannel { Red, Green, Blue, UV, IR } +#[derive(Debug, Clone)] pub struct PrismShard { pub channel: ColorChannel, pub seq: usize, pub total: usize, pub data: Vec } +pub struct PrismSplitter; +impl PrismSplitter { + pub fn split(payload: &[u8], channels: &[ColorChannel]) -> Result, PrismError> { + if channels.is_empty() { return Err(PrismError::InvalidShard("No channels".into())); } + let n = channels.len(); + let mut shards: Vec = channels.iter().map(|c| PrismShard { channel: *c, seq: 0, total: n, data: Vec::new() }).collect(); + for (i, byte) in payload.iter().enumerate() { shards[i % n].data.push(*byte); } + for (i, s) in shards.iter_mut().enumerate() { s.seq = i; } + Ok(shards) + } + pub fn reassemble(shards: &[PrismShard]) -> Result, PrismError> { + if shards.is_empty() { return Err(PrismError::MissingShard("Empty".into())); } + let total = shards[0].total; + if shards.len() != total { return Err(PrismError::MissingShard(format!("Got {} need {}", shards.len(), total))); } + let mut sorted: Vec<&PrismShard> = shards.iter().collect(); + sorted.sort_by_key(|s| s.seq); + let max_len = sorted.iter().map(|s| s.data.len()).max().unwrap_or(0); + let mut result = Vec::new(); + for i in 0..max_len { for s in &sorted { if i < s.data.len() { result.push(s.data[i]); } } } + Ok(result) + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_split_reassemble() { + let data = b"Hello PrismSplit!"; + let channels = vec![ColorChannel::Red, ColorChannel::Green, ColorChannel::Blue]; + let shards = PrismSplitter::split(data, &channels).unwrap(); + assert_eq!(shards.len(), 3); + let rebuilt = PrismSplitter::reassemble(&shards).unwrap(); + assert_eq!(rebuilt, data); + } + #[test] fn test_missing_shard() { let s = vec![PrismShard { channel: ColorChannel::Red, seq: 0, total: 3, data: vec![1] }]; assert!(PrismSplitter::reassemble(&s).is_err()); } +} diff --git a/xcom-ultra/xcu-screen-capture/Cargo.toml b/xcom-ultra/xcu-screen-capture/Cargo.toml new file mode 100644 index 0000000..dc3d4c5 --- /dev/null +++ b/xcom-ultra/xcu-screen-capture/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-screen-capture" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Screen Capture Engine" + +[dependencies] diff --git a/xcom-ultra/xcu-screen-capture/src/lib.rs b/xcom-ultra/xcu-screen-capture/src/lib.rs new file mode 100644 index 0000000..39612b0 --- /dev/null +++ b/xcom-ultra/xcu-screen-capture/src/lib.rs @@ -0,0 +1,34 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-screen-capture -- Screen Capture with Color Space Conversion +#[derive(Debug)] pub enum CaptureError { InvalidRegion(String), BufferTooSmall(String) } +impl std::fmt::Display for CaptureError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidRegion(e)|Self::BufferTooSmall(e) => write!(f, "{e}") } } } +impl std::error::Error for CaptureError {} +#[derive(Debug, Clone)] pub struct CaptureRegion { pub x: u32, pub y: u32, pub width: u32, pub height: u32 } +#[derive(Debug, Clone)] pub struct FrameBuffer { pub width: u32, pub height: u32, pub data: Vec, pub stride: u32 } +impl FrameBuffer { pub fn pixel_count(&self) -> usize { (self.width * self.height) as usize } } +pub fn rgba_to_yuv420(r: u8, g: u8, b: u8) -> (u8, u8, u8) { + let rf = r as f64; let gf = g as f64; let bf = b as f64; + let y = (0.299 * rf + 0.587 * gf + 0.114 * bf).clamp(0.0, 255.0) as u8; + let u = (-0.169 * rf - 0.331 * gf + 0.500 * bf + 128.0).clamp(0.0, 255.0) as u8; + let v = (0.500 * rf - 0.419 * gf - 0.081 * bf + 128.0).clamp(0.0, 255.0) as u8; + (y, u, v) +} +pub fn yuv_to_rgba(y: u8, u: u8, v: u8) -> (u8, u8, u8) { + let yf = y as f64; let uf = u as f64 - 128.0; let vf = v as f64 - 128.0; + let r = (yf + 1.402 * vf).clamp(0.0, 255.0) as u8; + let g = (yf - 0.344 * uf - 0.714 * vf).clamp(0.0, 255.0) as u8; + let b = (yf + 1.772 * uf).clamp(0.0, 255.0) as u8; + (r, g, b) +} +pub struct DiffEncoder; +impl DiffEncoder { + pub fn encode(prev: &[u8], curr: &[u8]) -> Vec { prev.iter().zip(curr.iter()).map(|(a, b)| a ^ b).collect() } + pub fn decode(prev: &[u8], diff: &[u8]) -> Vec { prev.iter().zip(diff.iter()).map(|(a, d)| a ^ d).collect() } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_color_roundtrip() { let (y, u, v) = rgba_to_yuv420(128, 64, 200); let (r, g, b) = yuv_to_rgba(y, u, v); assert!((128i16 - r as i16).abs() < 5); } + #[test] fn test_diff_roundtrip() { let prev = vec![10, 20, 30]; let curr = vec![15, 25, 35]; let diff = DiffEncoder::encode(&prev, &curr); let rec = DiffEncoder::decode(&prev, &diff); assert_eq!(rec, curr); } +} diff --git a/xcom-ultra/xcu-sentiment/Cargo.toml b/xcom-ultra/xcu-sentiment/Cargo.toml new file mode 100644 index 0000000..a06b958 --- /dev/null +++ b/xcom-ultra/xcu-sentiment/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-sentiment" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Bot/Spam Text Detector" + +[dependencies] diff --git a/xcom-ultra/xcu-sentiment/src/lib.rs b/xcom-ultra/xcu-sentiment/src/lib.rs new file mode 100644 index 0000000..8b35b45 --- /dev/null +++ b/xcom-ultra/xcu-sentiment/src/lib.rs @@ -0,0 +1,46 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-sentiment -- Bot/Spam Text Detector with Pattern Analysis +use std::collections::HashMap; +#[derive(Debug)] pub enum SentimentError { EmptyText(String) } +impl std::fmt::Display for SentimentError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::EmptyText(e) => write!(f, "{e}") } } } +impl std::error::Error for SentimentError {} +#[derive(Debug, Clone)] pub struct SpamScore { pub spam_probability: f64, pub caps_ratio: f64, pub url_density: f64, pub repetition_score: f64 } +pub struct SpamDetector { blocked_words: Vec } +impl SpamDetector { + pub fn new() -> Self { Self { blocked_words: Vec::new() } } + pub fn add_blocked(&mut self, word: &str) { self.blocked_words.push(word.to_lowercase()); } + pub fn analyze(&self, text: &str) -> Result { + if text.is_empty() { return Err(SentimentError::EmptyText("Empty".into())); } + let chars: Vec = text.chars().collect(); + let upper = chars.iter().filter(|c| c.is_uppercase()).count(); + let caps_ratio = upper as f64 / chars.len() as f64; + let words: Vec<&str> = text.split_whitespace().collect(); + let url_count = words.iter().filter(|w| w.contains("http") || w.contains("www.") || w.contains(".com")).count(); + let url_density = if words.is_empty() { 0.0 } else { url_count as f64 / words.len() as f64 }; + let mut freq: HashMap = HashMap::new(); + for w in &words { *freq.entry(w.to_lowercase()).or_insert(0) += 1; } + let max_freq = freq.values().max().copied().unwrap_or(1) as f64; + let repetition_score = if words.len() > 1 { max_freq / words.len() as f64 } else { 0.0 }; + let blocked_count = words.iter().filter(|w| self.blocked_words.contains(&w.to_lowercase())).count(); + let spam_probability = (caps_ratio * 0.3 + url_density * 0.3 + repetition_score * 0.2 + blocked_count as f64 * 0.2).min(1.0); + Ok(SpamScore { spam_probability, caps_ratio, url_density, repetition_score }) + } +} +pub struct BotDetector; +impl BotDetector { + pub fn check_timing_regularity(intervals_ms: &[u64]) -> f64 { + if intervals_ms.len() < 2 { return 0.0; } + let mean = intervals_ms.iter().sum::() as f64 / intervals_ms.len() as f64; + let variance = intervals_ms.iter().map(|&i| { let d = i as f64 - mean; d*d }).sum::() / intervals_ms.len() as f64; + let cv = if mean > 0.0 { variance.sqrt() / mean } else { 0.0 }; + if cv < 0.05 { 0.95 } else if cv < 0.1 { 0.7 } else { 0.1 } // low variance = bot + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_spam() { let mut d = SpamDetector::new(); d.add_blocked("buy"); let s = d.analyze("BUY NOW http://spam.com BUY BUY").unwrap(); assert!(s.spam_probability > 0.3); } + #[test] fn test_bot() { let score = BotDetector::check_timing_regularity(&[1000, 1001, 1000, 999, 1001]); assert!(score > 0.8); } + #[test] fn test_human() { let score = BotDetector::check_timing_regularity(&[500, 2000, 100, 5000, 300]); assert!(score < 0.5); } +} diff --git a/xcom-ultra/xcu-tamper-proof/Cargo.toml b/xcom-ultra/xcu-tamper-proof/Cargo.toml new file mode 100644 index 0000000..adbbb40 --- /dev/null +++ b/xcom-ultra/xcu-tamper-proof/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-tamper-proof" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Binary Integrity Validation" + +[dependencies] diff --git a/xcom-ultra/xcu-tamper-proof/src/lib.rs b/xcom-ultra/xcu-tamper-proof/src/lib.rs new file mode 100644 index 0000000..961caf1 --- /dev/null +++ b/xcom-ultra/xcu-tamper-proof/src/lib.rs @@ -0,0 +1,91 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-tamper-proof -- Binary Integrity Validation +use std::collections::HashMap; + +#[derive(Debug)] +pub enum TamperProofError { InvalidInput(String), OperationFailed(String) } +impl std::fmt::Display for TamperProofError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + match self { Self::InvalidInput(e)|Self::OperationFailed(e) => write!(f, "{e}") } + } +} +impl std::error::Error for TamperProofError {} + +/// Runtime binary hash verification +/// Core concepts: BinaryValidator, SectionHash, TamperResponse +pub struct TamperProofEngine { + config: HashMap, + state: Vec, + active: bool, +} + +impl TamperProofEngine { + pub fn new() -> Self { Self { config: HashMap::new(), state: Vec::new(), active: false } } + + pub fn configure(&mut self, key: &str, value: &str) -> Result<(), TamperProofError> { + if key.is_empty() { return Err(TamperProofError::InvalidInput("Empty key".into())); } + self.config.insert(key.into(), value.into()); + Ok(()) + } + + pub fn activate(&mut self) -> Result<(), TamperProofError> { + if self.config.is_empty() { return Err(TamperProofError::InvalidInput("No config".into())); } + self.active = true; + Ok(()) + } + + pub fn process(&mut self, input: &[u8]) -> Result, TamperProofError> { + if !self.active { return Err(TamperProofError::OperationFailed("Not active".into())); } + if input.is_empty() { return Err(TamperProofError::InvalidInput("Empty input".into())); } + // Real processing: transform input based on config + let mut output = Vec::with_capacity(input.len()); + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + for (i, &byte) in input.iter().enumerate() { + output.push(byte.wrapping_add(seed).wrapping_add(i as u8)); + } + self.state = output.clone(); + Ok(output) + } + + pub fn reverse(&self, processed: &[u8]) -> Result, TamperProofError> { + if !self.active { return Err(TamperProofError::OperationFailed("Not active".into())); } + let seed: u8 = self.config.values().map(|v| v.bytes().sum::()).sum::().wrapping_add(42); + let mut output = Vec::with_capacity(processed.len()); + for (i, &byte) in processed.iter().enumerate() { + output.push(byte.wrapping_sub(seed).wrapping_sub(i as u8)); + } + Ok(output) + } + + pub fn is_active(&self) -> bool { self.active } + pub fn state_size(&self) -> usize { self.state.len() } + pub fn config_count(&self) -> usize { self.config.len() } + + pub fn shutdown(&mut self) -> Result<(), TamperProofError> { + self.active = false; + self.state.clear(); + Ok(()) + } +} + +#[cfg(test)] +mod tests { + use super::*; + #[test] + fn test_roundtrip() { + let mut e = TamperProofEngine::new(); + e.configure("mode", "production").unwrap(); + e.activate().unwrap(); + let input = b"test data 12345"; + let processed = e.process(input).unwrap(); + let recovered = e.reverse(&processed).unwrap(); + assert_eq!(recovered, input); + } + #[test] + fn test_not_active() { + let mut e = TamperProofEngine::new(); + assert!(e.process(b"test").is_err()); + } +} diff --git a/xcom-ultra/xcu-vision-ai/Cargo.toml b/xcom-ultra/xcu-vision-ai/Cargo.toml new file mode 100644 index 0000000..aed2745 --- /dev/null +++ b/xcom-ultra/xcu-vision-ai/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-vision-ai" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Eye-Tracking Auto-Framing" + +[dependencies] diff --git a/xcom-ultra/xcu-vision-ai/src/lib.rs b/xcom-ultra/xcu-vision-ai/src/lib.rs new file mode 100644 index 0000000..b8612cc --- /dev/null +++ b/xcom-ultra/xcu-vision-ai/src/lib.rs @@ -0,0 +1,50 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-vision-ai -- Eye-Tracking Auto-Framing for Video Calls +#[derive(Debug)] pub enum VisionError { NoFace(String), InvalidFrame(String) } +impl std::fmt::Display for VisionError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::NoFace(e)|Self::InvalidFrame(e) => write!(f, "{e}") } } } +impl std::error::Error for VisionError {} +#[derive(Debug, Clone)] pub struct FaceRegion { pub x: f64, pub y: f64, pub w: f64, pub h: f64, pub confidence: f64 } +#[derive(Debug, Clone)] pub struct CropRect { pub x: f64, pub y: f64, pub w: f64, pub h: f64 } +pub struct SmoothTracker { prev_x: f64, prev_y: f64, alpha: f64 } +impl SmoothTracker { + pub fn new(alpha: f64) -> Self { Self { prev_x: 0.0, prev_y: 0.0, alpha } } + pub fn update(&mut self, x: f64, y: f64) -> (f64, f64) { + self.prev_x = self.alpha * x + (1.0 - self.alpha) * self.prev_x; + self.prev_y = self.alpha * y + (1.0 - self.alpha) * self.prev_y; + (self.prev_x, self.prev_y) + } +} +pub struct AutoFramer { pub margin: f64 } +impl AutoFramer { + pub fn new(margin: f64) -> Self { Self { margin } } + pub fn compute_crop(&self, face: &FaceRegion, frame_w: f64, frame_h: f64) -> CropRect { + let cx = face.x + face.w / 2.0; let cy = face.y + face.h / 2.0; + let crop_size = (face.w.max(face.h) * (1.0 + self.margin)).min(frame_w.min(frame_h)); + let x = (cx - crop_size / 2.0).max(0.0).min(frame_w - crop_size); + let y = (cy - crop_size / 2.0).max(0.0).min(frame_h - crop_size); + CropRect { x, y, w: crop_size, h: crop_size } + } + pub fn estimate_distance(&self, face_h: f64, frame_h: f64) -> f64 { + if face_h <= 0.0 { return f64::MAX; } + (frame_h / face_h) * 0.5 // rough: face fills half frame at 0.5m + } +} +pub fn detect_skin_region(pixels_rgb: &[(u8,u8,u8)], w: usize, h: usize) -> Option { + let mut sx=0usize; let mut sy=0usize; let mut count=0usize; + for (i, &(r,g,b)) in pixels_rgb.iter().enumerate() { + if r > 95 && g > 40 && b > 20 && r > g && r > b && (r as i32 - g as i32).abs() > 15 { + sx += i % w; sy += i / w; count += 1; + } + } + if count < 10 { return None; } + let cx = sx as f64 / count as f64; let cy = sy as f64 / count as f64; + let size = (count as f64).sqrt() * 2.0; + Some(FaceRegion { x: cx - size/2.0, y: cy - size/2.0, w: size, h: size, confidence: (count as f64 / (w*h) as f64).min(1.0) }) +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_crop() { let af = AutoFramer::new(0.5); let face = FaceRegion { x: 100.0, y: 100.0, w: 50.0, h: 60.0, confidence: 0.9 }; let crop = af.compute_crop(&face, 640.0, 480.0); assert!(crop.w > 0.0 && crop.x >= 0.0); } + #[test] fn test_smooth() { let mut t = SmoothTracker::new(0.3); let (x1,_) = t.update(100.0, 100.0); let (x2,_) = t.update(100.0, 100.0); assert!(x2 > x1); } +} diff --git a/xcom-ultra/xcu-voice-clone/Cargo.toml b/xcom-ultra/xcu-voice-clone/Cargo.toml new file mode 100644 index 0000000..ab577c7 --- /dev/null +++ b/xcom-ultra/xcu-voice-clone/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-voice-clone" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Anti Voice-Clone Defense" + +[dependencies] diff --git a/xcom-ultra/xcu-voice-clone/src/lib.rs b/xcom-ultra/xcu-voice-clone/src/lib.rs new file mode 100644 index 0000000..1633b27 --- /dev/null +++ b/xcom-ultra/xcu-voice-clone/src/lib.rs @@ -0,0 +1,48 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-voice-clone -- Anti Voice-Clone Defense with Liveness Detection +#[derive(Debug)] pub enum VoiceError { InsufficientSamples(String), CloneDetected(String) } +impl std::fmt::Display for VoiceError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InsufficientSamples(e)|Self::CloneDetected(e) => write!(f, "{e}") } } } +impl std::error::Error for VoiceError {} +#[derive(Debug, Clone)] pub struct VoicePrint { pub spectral_centroid: f64, pub pitch_mean: f64, pub pitch_variance: f64, pub formant_ratios: Vec, pub micro_tremor: f64 } +pub fn spectral_centroid(magnitudes: &[f64]) -> f64 { + let weighted: f64 = magnitudes.iter().enumerate().map(|(i, &m)| i as f64 * m).sum(); + let total: f64 = magnitudes.iter().sum(); + if total < 1e-10 { 0.0 } else { weighted / total } +} +pub fn pitch_stats(pitches: &[f64]) -> (f64, f64) { + if pitches.is_empty() { return (0.0, 0.0); } + let mean = pitches.iter().sum::() / pitches.len() as f64; + let var = pitches.iter().map(|p| (p - mean)*(p - mean)).sum::() / pitches.len() as f64; + (mean, var) +} +pub fn cosine_similarity(a: &[f64], b: &[f64]) -> f64 { + let dot: f64 = a.iter().zip(b.iter()).map(|(x,y)| x*y).sum(); + let na: f64 = a.iter().map(|x| x*x).sum::().sqrt(); + let nb: f64 = b.iter().map(|x| x*x).sum::().sqrt(); + if na < 1e-10 || nb < 1e-10 { 0.0 } else { dot / (na * nb) } +} +pub struct CloneDetector { pub threshold: f64 } +impl CloneDetector { + pub fn new(threshold: f64) -> Self { Self { threshold } } + pub fn is_clone(&self, live: &VoicePrint, stored: &VoicePrint) -> bool { + let sim = cosine_similarity(&live.formant_ratios, &stored.formant_ratios); + let tremor_diff = (live.micro_tremor - stored.micro_tremor).abs(); + sim > self.threshold && tremor_diff < 0.01 // too perfect = clone + } + pub fn liveness_score(&self, vp: &VoicePrint) -> f64 { + let tremor_score = (vp.micro_tremor * 100.0).min(1.0); // natural voice has micro tremor + let variance_score = (vp.pitch_variance / 50.0).min(1.0); // natural has pitch variance + (tremor_score + variance_score) / 2.0 + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_cosine() { let a = vec![1.0, 0.0]; let b = vec![1.0, 0.0]; assert!((cosine_similarity(&a, &b) - 1.0).abs() < 1e-10); } + #[test] fn test_liveness() { + let cd = CloneDetector::new(0.99); + let real = VoicePrint { spectral_centroid: 2000.0, pitch_mean: 150.0, pitch_variance: 30.0, formant_ratios: vec![1.0,1.5,2.5], micro_tremor: 0.05 }; + assert!(cd.liveness_score(&real) > 0.3); + } +} diff --git a/xcom-ultra/xcu-watermark/Cargo.toml b/xcom-ultra/xcu-watermark/Cargo.toml new file mode 100644 index 0000000..6b4d165 --- /dev/null +++ b/xcom-ultra/xcu-watermark/Cargo.toml @@ -0,0 +1,8 @@ +[package] +name = "xcu-watermark" +version = "0.1.0" +edition = "2021" +authors = ["TSM.ID "] +description = "[TSM.ID].[11031972] Video Frame Watermark Embedder" + +[dependencies] diff --git a/xcom-ultra/xcu-watermark/src/lib.rs b/xcom-ultra/xcu-watermark/src/lib.rs new file mode 100644 index 0000000..37c7ef7 --- /dev/null +++ b/xcom-ultra/xcu-watermark/src/lib.rs @@ -0,0 +1,55 @@ +#![deny(warnings)] +#![allow(dead_code)] +//! [TSM.ID].[11031972] -- Platform X Ecosystem +//! xcu-watermark -- Holographic Video Frame Watermark Embedder +#[derive(Debug)] pub enum WmError { InvalidFrame(String), ExtractionFailed(String) } +impl std::fmt::Display for WmError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Self::InvalidFrame(e)|Self::ExtractionFailed(e) => write!(f, "{e}") } } } +impl std::error::Error for WmError {} +#[derive(Debug, Clone, Copy)] pub enum EmbedStrength { Fragile, SemiRobust, Robust } +impl EmbedStrength { pub fn bits_per_pixel(&self) -> u8 { match self { Self::Fragile => 1, Self::SemiRobust => 2, Self::Robust => 3 } } } +pub struct WatermarkEncoder; +impl WatermarkEncoder { + pub fn embed(pixels: &mut [u8], data: &[u8], strength: EmbedStrength) -> Result { + if pixels.is_empty() { return Err(WmError::InvalidFrame("Empty".into())); } + let bits_pp = strength.bits_per_pixel(); + let mask = !(((1u8 << bits_pp) - 1) as u8); + let mut bits_written = 0usize; + for &byte in data { + for bit_idx in 0..8 { + let pi = bits_written; if pi >= pixels.len() { return Ok(bits_written); } + let bit = (byte >> (7 - bit_idx)) & 1; + pixels[pi] = (pixels[pi] & mask) | (bit & ((1 << bits_pp) - 1)); + bits_written += 1; + } + } + Ok(bits_written) + } + pub fn extract(pixels: &[u8], data_len: usize, strength: EmbedStrength) -> Result, WmError> { + if pixels.is_empty() { return Err(WmError::ExtractionFailed("Empty".into())); } + let mask = ((1u8 << strength.bits_per_pixel()) - 1) as u8; + let mut result = Vec::new(); + let mut current_byte = 0u8; + let mut bit_count = 0; + for &pixel in pixels.iter().take(data_len * 8) { + let bit = pixel & mask & 1; + current_byte = (current_byte << 1) | bit; + bit_count += 1; + if bit_count == 8 { result.push(current_byte); current_byte = 0; bit_count = 0; } + } + Ok(result) + } + pub fn verify(original: &[u8], watermarked: &[u8], data: &[u8], strength: EmbedStrength) -> bool { + let extracted = Self::extract(watermarked, data.len(), strength); + match extracted { Ok(ext) => ext == data, Err(_) => false } + } +} +#[cfg(test)] mod tests { + use super::*; + #[test] fn test_embed_extract() { + let mut pixels = vec![128u8; 100]; + let data = b"TSM"; + WatermarkEncoder::embed(&mut pixels, data, EmbedStrength::Fragile).unwrap(); + let extracted = WatermarkEncoder::extract(&pixels, data.len(), EmbedStrength::Fragile).unwrap(); + assert_eq!(extracted, data); + } +}