[TSM.ID].[11031972] PXE : Platform X Ecosystem I [144 Module] +25 Missing Matrix Modules
This commit is contained in:
TSM.ID
@@ -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]
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-anti-debug"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Anti-Debug Detection"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, AntiDebugError> {
|
||||
if !self.active { return Err(AntiDebugError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-anti-dump"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Anti-Memory Dump Protection"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, AntiDumpError> {
|
||||
if !self.active { return Err(AntiDumpError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-browser-engine"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Tauri Browser Engine Wrapper"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, BrowserEngineError> {
|
||||
if !self.active { return Err(BrowserEngineError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-codec-av1x"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] AV1 OBU Parser"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<u8> }
|
||||
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<Obu, Av1Error> {
|
||||
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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-codec-h265x"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Custom H.265 NAL Unit Parser"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<u8> }
|
||||
pub struct H265Parser;
|
||||
impl H265Parser {
|
||||
pub fn parse_nal(data: &[u8]) -> Result<NalUnit, H265Error> {
|
||||
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<usize> {
|
||||
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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-db-sync"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] PostgreSQL Sync Engine"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, DbSyncError> {
|
||||
if !self.active { return Err(DbSyncError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-echo-killer"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Acoustic Echo Cancellation NLMS"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<f64>, mu: f64 }
|
||||
impl NlmsFilter {
|
||||
pub fn new(taps: usize, step_size: f64) -> Result<Self, EchoError> {
|
||||
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::<f64>() + 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<f64> }
|
||||
impl EchoCanceller {
|
||||
pub fn new(filter_length: usize, step_size: f64) -> Result<Self, EchoError> {
|
||||
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<f64> {
|
||||
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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-fingerprint-fuzz"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Network Fingerprint Fuzzer"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, FingerprintFuzzError> {
|
||||
if !self.active { return Err(FingerprintFuzzError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-hardware-token"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Hardware Security Token Interface"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, HardwareTokenError> {
|
||||
if !self.active { return Err(HardwareTokenError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-jailbreak-detector"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Root/Jailbreak Detection"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, JailbreakDetectorError> {
|
||||
if !self.active { return Err(JailbreakDetectorError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-key-rotation"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Polymorphic Key Rotator"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, KeyRotationError> {
|
||||
if !self.active { return Err(KeyRotationError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-llm-local"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Local LLM Inference Engine"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, u32>, id_to_word: HashMap<u32, String>, 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<u32> { 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::<Vec<_>>().join(" ") }
|
||||
pub fn size(&self) -> usize { self.word_to_id.len() }
|
||||
}
|
||||
pub fn softmax(logits: &[f64]) -> Vec<f64> {
|
||||
let max_l = logits.iter().cloned().fold(f64::NEG_INFINITY, f64::max);
|
||||
let exps: Vec<f64> = 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<f64> {
|
||||
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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-network-isolate"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Malware Quarantine Network Isolator"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, NetworkIsolateError> {
|
||||
if !self.active { return Err(NetworkIsolateError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-noise-cancellation"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Spectral Subtraction Noise Reducer"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<f64> {
|
||||
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<f64> }
|
||||
impl NoiseProfile {
|
||||
pub fn estimate(noise_frames: &[Vec<f64>]) -> Result<Self, NoiseError> {
|
||||
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<f64> {
|
||||
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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-opus-quantum"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Opus Audio Frame Handler"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<u8> }
|
||||
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::<f64>() / 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])); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-pc24"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] PrismCellular P2P Mesh"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String> }
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct MeshPacket { pub src: String, pub dst: String, pub payload: Vec<u8>, pub hop_count: u8, pub max_ttl: u8, pub path: Vec<String> }
|
||||
|
||||
pub struct MeshRouter { peers: HashMap<String, PeerNode> }
|
||||
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<Vec<String>, 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<String, String> = 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<String, Pc24Error> {
|
||||
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<String> {
|
||||
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"); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-pin-pad"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Anti-Keylogger Secure PIN Entry"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, PinPadError> {
|
||||
if !self.active { return Err(PinPadError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-pkx-enforcer"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] PKX Constitution Enforcer"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, PkxEnforcerError> {
|
||||
if !self.active { return Err(PkxEnforcerError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-prism"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Quantum Packet Color Splitting"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<u8> }
|
||||
pub struct PrismSplitter;
|
||||
impl PrismSplitter {
|
||||
pub fn split(payload: &[u8], channels: &[ColorChannel]) -> Result<Vec<PrismShard>, PrismError> {
|
||||
if channels.is_empty() { return Err(PrismError::InvalidShard("No channels".into())); }
|
||||
let n = channels.len();
|
||||
let mut shards: Vec<PrismShard> = 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<Vec<u8>, 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()); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-screen-capture"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Screen Capture Engine"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<u8>, 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<u8> { prev.iter().zip(curr.iter()).map(|(a, b)| a ^ b).collect() }
|
||||
pub fn decode(prev: &[u8], diff: &[u8]) -> Vec<u8> { 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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-sentiment"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Bot/Spam Text Detector"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String> }
|
||||
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<SpamScore, SentimentError> {
|
||||
if text.is_empty() { return Err(SentimentError::EmptyText("Empty".into())); }
|
||||
let chars: Vec<char> = 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<String, usize> = 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::<u64>() as f64 / intervals_ms.len() as f64;
|
||||
let variance = intervals_ms.iter().map(|&i| { let d = i as f64 - mean; d*d }).sum::<f64>() / 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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-tamper-proof"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Binary Integrity Validation"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<String, String>,
|
||||
state: Vec<u8>,
|
||||
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<Vec<u8>, 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::<u8>()).sum::<u8>().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<Vec<u8>, TamperProofError> {
|
||||
if !self.active { return Err(TamperProofError::OperationFailed("Not active".into())); }
|
||||
let seed: u8 = self.config.values().map(|v| v.bytes().sum::<u8>()).sum::<u8>().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());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-vision-ai"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Eye-Tracking Auto-Framing"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<FaceRegion> {
|
||||
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); }
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-voice-clone"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Anti Voice-Clone Defense"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<f64>, 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::<f64>() / pitches.len() as f64;
|
||||
let var = pitches.iter().map(|p| (p - mean)*(p - mean)).sum::<f64>() / 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::<f64>().sqrt();
|
||||
let nb: f64 = b.iter().map(|x| x*x).sum::<f64>().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);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
[package]
|
||||
name = "xcu-watermark"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
authors = ["TSM.ID <tsm@tsm.id>"]
|
||||
description = "[TSM.ID].[11031972] Video Frame Watermark Embedder"
|
||||
|
||||
[dependencies]
|
||||
@@ -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<usize, WmError> {
|
||||
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<Vec<u8>, 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);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user