clm-kernel 0.0.13

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
//! MagicSignature extracted from `type_interpreter.rs` (Sprint 534 ratchet).

use serde::{Deserialize, Serialize};

/// Byte-level magic signature for fast, deterministic binary identification.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MagicSignature {
    pub offset: usize,
    pub hex: String,
    pub mask: Option<String>,
    pub description: Option<String>,
}

impl MagicSignature {
    pub fn matches(&self, data: &[u8]) -> bool {
        let clean_hex: String = self.hex.chars().filter(|c| c.is_ascii_hexdigit()).collect();
        if !clean_hex.len().is_multiple_of(2) || clean_hex.is_empty() {
            return false;
        }

        let sig_bytes = match hex::decode(&clean_hex) {
            Ok(b) => b,
            Err(_) => return false,
        };

        let required_len = self.offset + sig_bytes.len();
        if data.len() < required_len {
            return false;
        }

        let target_slice = &data[self.offset..required_len];

        if let Some(mask_str) = &self.mask {
            let clean_mask: String = mask_str.chars().filter(|c| c.is_ascii_hexdigit()).collect();
            if let Ok(mask_bytes) = hex::decode(&clean_mask) {
                for (i, (&b, &sig)) in target_slice.iter().zip(sig_bytes.iter()).enumerate() {
                    let m = if i < mask_bytes.len() { mask_bytes[i] } else { 0xff };
                    if (b & m) != sig {
                        return false;
                    }
                }
                return true;
            }
        }

        target_slice == sig_bytes.as_slice()
    }

    pub fn byte_length(&self) -> usize {
        let clean: String = self.hex.chars().filter(|c| c.is_ascii_hexdigit()).collect();
        clean.len() / 2
    }
}