use serde::{Deserialize, Serialize};
#[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
}
}