mirror of
https://github.com/storytold/craft-anything.git
synced 2026-11-20 06:21:00 +01:00
* Take target file signatures from the shared craft-sniff table * Pin craft-sniff to the craft-libs #1841 merge and record the cutover The shared table is on main at 070005125f0af1a5ae4a59002270e5849505bfc0. * Keep named-but-unsupported formats as Unknown A CPIO file starting 070701 was identified by craft-sniff, then fell through to the unsigned path and was called text. Identified kinds this app does not inspect stay Unknown; the unsigned fallback is only for files with no signature.
332 lines
14 KiB
Rust
332 lines
14 KiB
Rust
//! Targets: what we're looking at, loaded once, identified by content hash.
|
|
|
|
use craft_anything_evidence::{ErrorCode, Subject, ToolError, sha256_hex};
|
|
use serde::{Deserialize, Serialize};
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::Arc;
|
|
|
|
/// Biggest file we load into memory. Bigger inputs get a clear error rather than an OOM.
|
|
pub const MAX_TARGET_BYTES: u64 = 2 * 1024 * 1024 * 1024;
|
|
|
|
pub type TargetId = String;
|
|
|
|
/// Metadata handed to an agent's MCP session. No file contents or caches cross the command
|
|
/// line; Deep mode reloads and verifies the file, while Clean room keeps only this metadata.
|
|
#[derive(Debug, Clone, Serialize, Deserialize, schemars::JsonSchema)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct TargetContext {
|
|
pub path: PathBuf,
|
|
pub sha256: String,
|
|
pub kind: TargetKind,
|
|
pub raw: Option<RawSpec>,
|
|
}
|
|
|
|
impl TargetContext {
|
|
pub fn from_target(target: &Target) -> Self {
|
|
Self { path: target.path.clone(), sha256: target.sha256.clone(), kind: target.kind, raw: target.raw.clone() }
|
|
}
|
|
|
|
pub fn open(&self, clean_room: bool) -> Result<Target, ToolError> {
|
|
if !self.path.is_absolute() || self.sha256.len() != 64 || !self.sha256.bytes().all(|byte| byte.is_ascii_hexdigit()) {
|
|
return Err(ToolError::invalid("A shared target needs an absolute path and a SHA-256 hash."));
|
|
}
|
|
let mut target = if clean_room {
|
|
Target {
|
|
id: format!("t_{}", self.sha256.get(..12).unwrap_or_default()),
|
|
path: self.path.clone(),
|
|
name: self.path.file_name().unwrap_or_default().to_string_lossy().into_owned(),
|
|
sha256: self.sha256.clone(),
|
|
kind: self.kind,
|
|
bytes: Arc::from([]),
|
|
raw: self.raw.clone(),
|
|
}
|
|
} else {
|
|
let target = Target::load(&self.path)?;
|
|
if target.sha256 != self.sha256 {
|
|
return Err(ToolError::invalid("The shared target changed after it was opened.")
|
|
.with_remediation("Reopen the target in Craft Anything, then start a new conversation."));
|
|
}
|
|
target
|
|
};
|
|
if self.raw.is_some() || self.kind == TargetKind::DosCom {
|
|
target.kind = self.kind;
|
|
target.raw = self.raw.clone();
|
|
}
|
|
Ok(target)
|
|
}
|
|
}
|
|
|
|
/// What kind of thing a target is. Detected from content, never from the extension alone.
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize, schemars::JsonSchema)]
|
|
#[serde(rename_all = "kebab-case")]
|
|
pub enum TargetKind {
|
|
Elf,
|
|
Pe,
|
|
MachO,
|
|
/// A fat/universal Mach-O.
|
|
MachOFat,
|
|
/// A .NET assembly (PE with a CLI header).
|
|
Managed,
|
|
Wasm,
|
|
Apk,
|
|
Dex,
|
|
Jar,
|
|
/// A single Java `.class` file.
|
|
JavaClass,
|
|
Zip,
|
|
Asar,
|
|
/// A folder: an app bundle, an unpacked Electron app, a project.
|
|
Directory,
|
|
/// A JavaScript or HTML file.
|
|
Script,
|
|
/// A HAR or other network capture.
|
|
NetworkCapture,
|
|
Plist,
|
|
/// EVM bytecode.
|
|
Evm,
|
|
/// A SQLite 3 database file.
|
|
Sqlite,
|
|
/// A DOS .COM program.
|
|
DosCom,
|
|
/// Raw bytes with a user-declared architecture (firmware, shellcode).
|
|
RawBinary,
|
|
/// Plain text, such as notes, source files and settings.
|
|
Text,
|
|
Unknown,
|
|
}
|
|
|
|
impl TargetKind {
|
|
/// Plain-English description for Beginner mode.
|
|
pub fn plain(self) -> &'static str {
|
|
match self {
|
|
TargetKind::Elf => "A Linux (or Unix) program",
|
|
TargetKind::Pe => "A Windows program",
|
|
TargetKind::MachO | TargetKind::MachOFat => "A Mac or iPhone program",
|
|
TargetKind::Managed => "A .NET program (C#, F# or VB)",
|
|
TargetKind::Wasm => "A WebAssembly module (code that runs in a browser)",
|
|
TargetKind::Apk => "An Android app",
|
|
TargetKind::Dex => "Android app code (DEX)",
|
|
TargetKind::Jar => "A Java program",
|
|
TargetKind::JavaClass => "Java program code (one class)",
|
|
TargetKind::Zip => "A ZIP archive",
|
|
TargetKind::Asar => "The packed contents of an Electron app (a website inside a desktop app)",
|
|
TargetKind::Directory => "A folder",
|
|
TargetKind::Script => "A script or web page",
|
|
TargetKind::NetworkCapture => "A recording of network traffic",
|
|
TargetKind::Plist => "An Apple settings file (plist)",
|
|
TargetKind::Evm => "A smart contract (EVM bytecode)",
|
|
TargetKind::Sqlite => "A SQLite database (how an app stores its data)",
|
|
TargetKind::DosCom => "A DOS program",
|
|
TargetKind::RawBinary => "Raw machine code",
|
|
TargetKind::Text => "A text file (notes, source code or settings)",
|
|
TargetKind::Unknown => "A file we don't recognise yet",
|
|
}
|
|
}
|
|
|
|
pub fn id(self) -> String {
|
|
serde_json::to_value(self).ok().and_then(|v| v.as_str().map(String::from)).unwrap_or_else(|| "unknown".into())
|
|
}
|
|
}
|
|
|
|
/// Whether an otherwise unknown file looks like text. Inspect at most 8 KiB:
|
|
/// a byte-order mark counts as text, otherwise require valid UTF-8, no NULs
|
|
/// and few control bytes. Empty input is not text.
|
|
pub fn looks_like_text(bytes: &[u8]) -> bool {
|
|
const SNIFF: usize = 8 * 1024;
|
|
if bytes.starts_with(b"\xEF\xBB\xBF") || bytes.starts_with(b"\xFF\xFE") || bytes.starts_with(b"\xFE\xFF") {
|
|
return true;
|
|
}
|
|
let head = bytes.get(..bytes.len().min(SNIFF)).unwrap_or_default();
|
|
if head.is_empty() || head.contains(&0) {
|
|
return false;
|
|
}
|
|
let cut_at_end = bytes.len() > SNIFF;
|
|
let mut chunks = head.utf8_chunks().peekable();
|
|
while let Some(chunk) = chunks.next() {
|
|
// The window may end inside a character; only that last sequence may be incomplete.
|
|
let last = chunks.peek().is_none();
|
|
if !chunk.invalid().is_empty() && !(last && cut_at_end && chunk.invalid().len() < 4) {
|
|
return false;
|
|
}
|
|
}
|
|
let control = head.iter().filter(|b| b.is_ascii_control() && !matches!(b, b'\t' | b'\n' | b'\r' | 0x0c | 0x1b)).count();
|
|
control.saturating_mul(100) <= head.len()
|
|
}
|
|
|
|
/// Sniff the kind from the first bytes (and the name, only to break ties).
|
|
///
|
|
/// Signatures come from the shared `craft_sniff` table; the tie-breaks that need our own parsers
|
|
/// (managed PE, Java class or universal Mach-O, APK by its manifest) and the kinds with no
|
|
/// signature (ASAR, XML plists, captures, scripts, text) stay here.
|
|
pub fn sniff(bytes: &[u8], name: &str) -> TargetKind {
|
|
use craft_sniff::Kind;
|
|
let lower = name.to_ascii_lowercase();
|
|
match craft_sniff::identify(bytes) {
|
|
Some(Kind::Sqlite) => TargetKind::Sqlite,
|
|
Some(Kind::Elf) => TargetKind::Elf,
|
|
Some(Kind::Pe | Kind::DosExecutable) => {
|
|
if craft_anything_formats::pe_is_managed(bytes) {
|
|
TargetKind::Managed
|
|
} else {
|
|
TargetKind::Pe
|
|
}
|
|
}
|
|
Some(Kind::MachO) => TargetKind::MachO,
|
|
// Both a Java class and a universal Mach-O start 0xCAFEBABE. A class has a plausible
|
|
// major version where a fat binary has a small big-endian architecture count, so prefer
|
|
// the .class extension, then the version check.
|
|
Some(Kind::MachOFat | Kind::JavaClass) => {
|
|
if lower.ends_with(".class") || craft_anything_formats::java_class::is_class(bytes) {
|
|
TargetKind::JavaClass
|
|
} else {
|
|
TargetKind::MachOFat
|
|
}
|
|
}
|
|
Some(Kind::Wasm) => TargetKind::Wasm,
|
|
Some(Kind::Dex) => TargetKind::Dex,
|
|
Some(Kind::Zip) => sniff_zip(bytes, &lower),
|
|
Some(Kind::BinaryPlist) => TargetKind::Plist,
|
|
Some(_) => TargetKind::Unknown,
|
|
None => sniff_unsigned(bytes, &lower),
|
|
}
|
|
}
|
|
|
|
/// A ZIP is an APK or a JAR by its name, then an APK by its manifest.
|
|
fn sniff_zip(bytes: &[u8], lower: &str) -> TargetKind {
|
|
if lower.ends_with(".apk") || lower.ends_with(".aab") || lower.ends_with(".xapk") {
|
|
TargetKind::Apk
|
|
} else if lower.ends_with(".jar") || lower.ends_with(".war") {
|
|
TargetKind::Jar
|
|
} else if craft_anything_formats::zip_has_entry(bytes, "AndroidManifest.xml") {
|
|
TargetKind::Apk
|
|
} else {
|
|
TargetKind::Zip
|
|
}
|
|
}
|
|
|
|
/// The kinds the shared table has no signature for, told apart by name and content.
|
|
fn sniff_unsigned(bytes: &[u8], lower: &str) -> TargetKind {
|
|
if lower.ends_with(".asar") || craft_anything_formats::looks_like_asar(bytes) {
|
|
TargetKind::Asar
|
|
} else if lower.ends_with(".plist") && bytes.windows(6).take(512).any(|w| w == b"<plist") {
|
|
TargetKind::Plist
|
|
} else if lower.ends_with(".har") {
|
|
TargetKind::NetworkCapture
|
|
} else if lower.ends_with(".com") && bytes.len() <= 0xff00 {
|
|
TargetKind::DosCom
|
|
} else if [".js", ".mjs", ".cjs", ".html", ".htm", ".ts"].iter().any(|e| lower.ends_with(e)) {
|
|
TargetKind::Script
|
|
} else if looks_like_text(bytes) {
|
|
TargetKind::Text
|
|
} else {
|
|
TargetKind::Unknown
|
|
}
|
|
}
|
|
|
|
/// A loaded target.
|
|
#[derive(Debug, Clone)]
|
|
pub struct Target {
|
|
/// `t_` + first 12 hex of the sha256 (+ a suffix if the same file is opened twice).
|
|
pub id: TargetId,
|
|
pub path: PathBuf,
|
|
pub name: String,
|
|
pub sha256: String,
|
|
pub kind: TargetKind,
|
|
/// File contents (empty for directories).
|
|
pub bytes: Arc<[u8]>,
|
|
/// For raw binaries: declared architecture and entry point.
|
|
pub raw: Option<RawSpec>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, schemars::JsonSchema)]
|
|
pub struct RawSpec {
|
|
/// `x86`, `x86_64`, `arm`, `arm64`.
|
|
pub architecture: String,
|
|
/// Load and entry address.
|
|
pub entry_point: u64,
|
|
}
|
|
|
|
impl Target {
|
|
/// Load a file or directory.
|
|
pub fn load(path: &Path) -> Result<Target, ToolError> {
|
|
let meta = std::fs::metadata(path).map_err(|e| ToolError::io(path.display(), e))?;
|
|
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| path.display().to_string());
|
|
if meta.is_dir() {
|
|
let digest = sha256_hex(path.to_string_lossy().as_bytes());
|
|
return Ok(Target {
|
|
id: format!("t_{}", digest.get(..12).unwrap_or(&digest)),
|
|
path: path.to_path_buf(),
|
|
name,
|
|
sha256: digest,
|
|
kind: TargetKind::Directory,
|
|
bytes: Arc::from(Vec::new()),
|
|
raw: None,
|
|
});
|
|
}
|
|
let bytes = craft_anything_platform::fs::read_file_capped(path, MAX_TARGET_BYTES)?;
|
|
Ok(Target::from_bytes(path.to_path_buf(), name, bytes))
|
|
}
|
|
|
|
pub fn from_bytes(path: PathBuf, name: String, bytes: Vec<u8>) -> Target {
|
|
let sha256 = sha256_hex(&bytes);
|
|
let kind = sniff(&bytes, &name);
|
|
Target { id: format!("t_{}", sha256.get(..12).unwrap_or(&sha256)), path, name, sha256, kind, bytes: Arc::from(bytes), raw: None }
|
|
}
|
|
|
|
pub fn subject(&self) -> Subject {
|
|
Subject { kind: self.kind.id(), sha256: Some(self.sha256.clone()), name: Some(self.name.clone()) }
|
|
}
|
|
|
|
/// Fail if the file on disk no longer matches what we loaded.
|
|
pub fn check_unchanged(&self) -> Result<(), ToolError> {
|
|
if self.kind == TargetKind::Directory {
|
|
return Ok(());
|
|
}
|
|
match craft_anything_platform::fs::read_file_capped(&self.path, MAX_TARGET_BYTES) {
|
|
Ok(b) if sha256_hex(&b) == self.sha256 => Ok(()),
|
|
Ok(_) => Err(ToolError::new(ErrorCode::FileChanged, format!("{} changed on disk since it was opened", self.path.display()))
|
|
.with_remediation("Open it again to analyse the new version.")),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
#[test]
|
|
fn sniffs_common_magics() {
|
|
assert_eq!(sniff(b"\x7fELF\x02\x01", "a"), TargetKind::Elf);
|
|
assert_eq!(sniff(b"\0asm\x01\0\0\0", "m"), TargetKind::Wasm);
|
|
assert_eq!(sniff(b"dex\n035\0", "classes.dex"), TargetKind::Dex);
|
|
assert_eq!(sniff(b"PK\x03\x04", "app.apk"), TargetKind::Apk);
|
|
assert_eq!(sniff(b"bplist00", "Info.plist"), TargetKind::Plist);
|
|
assert_eq!(sniff(b"SQLite format 3\0\x10\x00", "app.db"), TargetKind::Sqlite);
|
|
assert_eq!(sniff(b"\xcf\xfa\xed\xfe\x07\0\0\x01", "tool"), TargetKind::MachO);
|
|
assert_eq!(sniff(b"\xca\xfe\xba\xbe\0\0\0\x02", "tool"), TargetKind::MachOFat);
|
|
assert_eq!(sniff(b"\xca\xfe\xba\xbf\0\0\0\x02", "tool"), TargetKind::MachOFat);
|
|
assert_eq!(sniff(b"\xca\xfe\xba\xbe\0\0\0\x41", "Main"), TargetKind::JavaClass);
|
|
assert_eq!(sniff(b"\xca\xfe\xba\xbe\0\0\0\x02", "Main.class"), TargetKind::JavaClass);
|
|
assert_eq!(sniff(b"MZ\x90\0", "setup.exe"), TargetKind::Pe);
|
|
assert_eq!(sniff(b"PK\x03\x04", "lib.jar"), TargetKind::Jar);
|
|
assert_eq!(sniff(b"PK\x05\x06\0\0\0\0", "empty.zip"), TargetKind::Zip);
|
|
assert_eq!(sniff(b"<?xml?><plist version=\"1.0\"/>", "Info.plist"), TargetKind::Plist);
|
|
// Media and archives the shared table names are not targets we inspect by kind.
|
|
assert_eq!(sniff(b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR", "icon.png"), TargetKind::Unknown);
|
|
assert_eq!(sniff(b"070701", "archive.cpio"), TargetKind::Unknown);
|
|
assert_eq!(sniff(b"", "x"), TargetKind::Unknown);
|
|
assert_eq!(sniff(b"console.log(1)", "main.js"), TargetKind::Script);
|
|
assert_eq!(sniff(b"# Notes\n", "notes.md"), TargetKind::Text);
|
|
assert_eq!(sniff(b"key = true\n", "config.toml"), TargetKind::Text);
|
|
assert_eq!(sniff(b"\xEF\xBB\xBFhello", "notes.txt"), TargetKind::Text);
|
|
assert_eq!(sniff(b"\xFF\xFEh\0i\0", "notes.txt"), TargetKind::Text);
|
|
assert_eq!(sniff(b"\0\xFF\x02", "notes.md"), TargetKind::Unknown);
|
|
// The bytes decide, not the name: a gzip stream called `.txt` is not text.
|
|
assert_eq!(sniff(b"\x1f\x8b\x08\x00\x00\x00", "notes.txt"), TargetKind::Unknown);
|
|
assert_eq!(sniff(b"", "empty.txt"), TargetKind::Unknown);
|
|
assert_eq!(TargetKind::Text.id(), "text");
|
|
assert!(TargetKind::Text.plain().contains("text file"));
|
|
}
|
|
}
|