Ghidrust provides a hyper fast, AI native reverse engineering platform built in Rust, inspired by Ghidra. Includes experimental GPU kernels to rapidly decompile large files, a decryption suite, and network monitor for packet to binary reverse engineering.
//! Agent friction closure — CLI helpers for artifacts, inventory, tree, process, identity.
use ghidrust_core::{
artifact_get, artifact_query, envelope_or_spill, inventory_pe_dir, list_artifacts, list_tree,
load_path, process_attach_opts, process_break_clear, process_break_list, process_break_set,
process_continue, process_detach, process_export_snapshot, process_launch, process_list,
process_modules, process_pause, process_read, process_regions, process_resolve, process_resume,
process_scan_mem, process_stack, process_step_into, process_step_out, process_step_over,
process_thread_context_get, process_threads, process_vtable_probe, process_wait,
process_watch_expr, resolve_function, resolve_result_json, rtti_query, section_notes_for,
spill_artifact, write_json_no_bom, AttachOpts, BreakKind, LaunchRequest, Project,
RttiMatchMode, ScanOpts, SessionMode, TreeListOpts, DEFAULT_PREVIEW_LIMIT,
};
use serde_json::{json, Value};
use std::path::PathBuf;
use std::process::ExitCode;
pub fn parse_u64(s: &str) -> Result<u64, String> {
let t = s.trim().trim_start_matches("0x").trim_start_matches("0X");
u64::from_str_radix(t, 16)
.or_else(|_| s.parse::<u64>())
.map_err(|e| e.to_string())
}
/// Resolve binary path from `-path` or `-project` + `-file-id`.
pub fn resolve_program_path(args: &[String]) -> Result<(PathBuf, Value), String> {
let mut path: Option<PathBuf> = None;
let mut project: Option<PathBuf> = None;
let mut file_id: Option<String> = None;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"-path" if i + 1 < args.len() => {
path = Some(PathBuf::from(&args[i + 1]));
i += 2;
}
"-project" if i + 1 < args.len() => {
project = Some(PathBuf::from(&args[i + 1]));
i += 2;
}
"-file-id" | "-file" if i + 1 < args.len() => {
file_id = Some(args[i + 1].clone());
i += 2;
}
other if !other.starts_with('-') && path.is_none() && project.is_none() => {
path = Some(PathBuf::from(other));
i += 1;
}
_ => i += 1,
}
}
if let Some(p) = path {
let facts = json!({
"path": p.display().to_string(),
"project": Value::Null,
"file_id": Value::Null,
"resolved_path": p.display().to_string(),
});
return Ok((p, facts));
}
let Some(proj) = project else {
return Err("provide <path> or -project DIR -file-id ID".into());
};
let Some(fid) = file_id else {
return Err("load with -project requires -file-id".into());
};
let project = Project::open(&proj).map_err(|e| e.to_string())?;
let entry = project
.list_files()
.into_iter()
.find(|f| f.id == fid)
.ok_or_else(|| format!("file_id not found: {fid}"))?;
let resolved = project.root.join(&entry.imported_rel);
if !resolved.is_file() {
return Err(format!(
"resolved path missing: {} (file_id={fid})",
resolved.display()
));
}
let facts = json!({
"path": Value::Null,
"project": proj.display().to_string(),
"file_id": fid,
"resolved_path": resolved.display().to_string(),
"display_name": entry.display_name,
});
Ok((resolved, facts))
}
pub fn load_json_for_prog(prog: &ghidrust_core::Program, identity: &Value) -> Value {
let notes = section_notes_for(prog);
json!({
"name": prog.name,
"format": prog.format,
"image_base": format!("{:#x}", prog.image_base),
"entry": prog.entry.map(|e| format!("{e:#x}")),
"identity": identity,
"resolved_path": identity.get("resolved_path").cloned().unwrap_or(Value::Null),
"sections": prog.sections.iter().map(|s| json!({
"name": s.name,
"va": format!("{:#x}", s.va),
"virtual_size": s.virtual_size,
"raw_size": s.raw_size,
"characteristics": format!("{:#x}", s.characteristics),
})).collect::<Vec<_>>(),
"section_notes": notes,
})
}
pub fn cmd_artifact(args: &[String], json: bool) -> ExitCode {
if args.is_empty() {
eprintln!("usage: ghidrust artifact get|query|list <id> [-offset N] [-limit N] [-json]");
return ExitCode::from(2);
}
match args[0].as_str() {
"list" => match list_artifacts(64) {
Ok(m) => {
if json {
println!("{}", serde_json::to_string_pretty(&m).unwrap());
} else {
for a in m {
println!(
"{} kind={} entries={} {}",
a.id, a.kind, a.entry_count, a.path
);
}
}
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
},
"get" => {
let id = match args.get(1) {
Some(i) => i.as_str(),
None => {
eprintln!("usage: ghidrust artifact get <id|path>");
return ExitCode::from(2);
}
};
match artifact_get(id) {
Ok(v) => {
println!("{}", serde_json::to_string_pretty(&v).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"query" => {
let id = match args.get(1) {
Some(i) => i.as_str(),
None => {
eprintln!("usage: ghidrust artifact query <id|path> [-offset N] [-limit N]");
return ExitCode::from(2);
}
};
let mut offset = 0usize;
let mut limit = DEFAULT_PREVIEW_LIMIT;
let mut i = 2;
while i < args.len() {
match args[i].as_str() {
"-offset" if i + 1 < args.len() => {
offset = args[i + 1].parse().unwrap_or(0);
i += 2;
}
"-limit" if i + 1 < args.len() => {
limit = args[i + 1].parse().unwrap_or(DEFAULT_PREVIEW_LIMIT);
i += 2;
}
_ => i += 1,
}
}
match artifact_query(id, offset, limit) {
Ok(env) => {
println!("{}", serde_json::to_string_pretty(&env).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
other => {
eprintln!("unknown artifact subcommand: {other}");
ExitCode::from(2)
}
}
}
pub fn cmd_inventory(args: &[String], json: bool) -> ExitCode {
let dir = match args.first() {
Some(d) => PathBuf::from(d),
None => {
eprintln!("usage: ghidrust inventory <dir> [-max-depth N] [-hash] [-out FILE] [-json]");
return ExitCode::from(2);
}
};
let mut max_depth = 8usize;
let mut with_hash = false;
let mut out_path: Option<PathBuf> = None;
let mut i = 1;
while i < args.len() {
match args[i].as_str() {
"-max-depth" if i + 1 < args.len() => {
max_depth = args[i + 1].parse().unwrap_or(8);
i += 2;
}
"-hash" => {
with_hash = true;
i += 1;
}
"-out" if i + 1 < args.len() => {
out_path = Some(PathBuf::from(&args[i + 1]));
i += 2;
}
_ => i += 1,
}
}
match inventory_pe_dir(&dir, max_depth, with_hash) {
Ok(inv) => {
let entries = serde_json::to_value(&inv.entries).unwrap();
let env = match envelope_or_spill(
"inventory",
entries,
64,
DEFAULT_PREVIEW_LIMIT,
Some(&inv.root),
) {
Ok(e) => e,
Err(e) => {
eprintln!("error: {e}");
return ExitCode::FAILURE;
}
};
let body = json!({
"schema_version": inv.schema_version,
"root": inv.root,
"notes": inv.notes,
"envelope": env,
"entries": if inv.entries.len() <= 64 { Value::Array(inv.entries.iter().map(|e| serde_json::to_value(e).unwrap()).collect()) } else { Value::Null },
});
if let Some(p) = out_path {
if let Err(e) = write_json_no_bom(&p, &body) {
eprintln!("error: {e}");
return ExitCode::FAILURE;
}
}
if json {
println!("{}", serde_json::to_string_pretty(&body).unwrap());
} else {
println!("inventory root={} entries={}", inv.root, inv.entries.len());
for e in inv.entries.iter().take(32) {
println!(
" {} size={} file_ver={:?} product_ver={:?}",
e.path, e.size, e.version.file_version, e.version.product_version
);
}
if inv.entries.len() > 32 {
println!(
" … {} more (use -json / artifact envelope)",
inv.entries.len() - 32
);
}
}
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
pub fn cmd_tree(args: &[String], json: bool) -> ExitCode {
let dir = match args.first() {
Some(d) => PathBuf::from(d),
None => {
eprintln!(
"usage: ghidrust tree <path> [-max-depth N] [-ext LIST] [-name GLOB] [-json]"
);
return ExitCode::from(2);
}
};
let mut opts = TreeListOpts::default();
let mut i = 1;
while i < args.len() {
match args[i].as_str() {
"-max-depth" if i + 1 < args.len() => {
opts.max_depth = args[i + 1].parse().unwrap_or(6);
i += 2;
}
"-ext" if i + 1 < args.len() => {
opts.extensions = Some(
args[i + 1]
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect(),
);
i += 2;
}
"-name" if i + 1 < args.len() => {
opts.name_glob = Some(args[i + 1].clone());
i += 2;
}
_ => i += 1,
}
}
let res = list_tree(&dir, opts);
let entries_v = serde_json::to_value(&res.entries).unwrap();
let env = envelope_or_spill(
"tree",
entries_v,
128,
DEFAULT_PREVIEW_LIMIT,
Some(&res.root),
);
let env = match env {
Ok(e) => e,
Err(e) => {
eprintln!("error: {e}");
return ExitCode::FAILURE;
}
};
let body = json!({
"root": res.root,
"truncated": res.truncated,
"envelope": env,
"entries": if res.entries.len() <= 128 {
serde_json::to_value(&res.entries).unwrap()
} else {
Value::Null
},
});
if json {
println!("{}", serde_json::to_string_pretty(&body).unwrap());
} else {
for e in res.entries.iter().take(64) {
if let Some(err) = &e.error {
println!("ERR {} ({err})", e.path);
} else if e.is_dir {
println!("DIR {}", e.path);
} else {
println!("FILE {} size={:?}", e.path, e.size);
}
}
if res.truncated || res.entries.len() > 64 {
println!("… truncated; drain via artifact envelope");
}
}
ExitCode::SUCCESS
}
pub fn cmd_process(args: &[String], json: bool) -> ExitCode {
if args.is_empty() {
eprintln!(
"usage: ghidrust process list|attach|launch|resume|detach|modules|read|resolve|regions|break|continue|pause|wait|step|step-out|threads|regs|stack|scan|watch|vtable|snapshot … [-json]"
);
return ExitCode::from(2);
}
match args[0].as_str() {
"list" => match process_list() {
Ok(list) => {
if json {
println!("{}", serde_json::to_string_pretty(&list).unwrap());
} else {
for p in list.iter().take(200) {
println!(
"{:>8} {} {}",
p.pid,
p.name,
p.path.as_deref().unwrap_or("-")
);
}
}
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
},
"attach" => {
let pid: u32 = match args.get(1).and_then(|s| s.parse().ok()) {
Some(p) => p,
None => {
eprintln!("usage: ghidrust process attach <pid> [-mode observe|debug]");
return ExitCode::from(2);
}
};
let mut mode = SessionMode::Observe;
let mut i = 2;
while i < args.len() {
match args[i].as_str() {
"-mode" if i + 1 < args.len() => {
mode = args[i + 1].parse().unwrap_or(SessionMode::Observe);
i += 2;
}
_ => i += 1,
}
}
match process_attach_opts(pid, &AttachOpts { mode }) {
Ok(s) => {
println!("{}", serde_json::to_string_pretty(&s).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"launch" => {
let image = match args.get(1).filter(|s| !s.starts_with('-')) {
Some(p) => PathBuf::from(p),
None => {
eprintln!(
"usage: ghidrust process launch <image.exe> [-args \"…\"] [-cwd DIR] [-mode observe|debug] [-break-at-entry] [-json]"
);
return ExitCode::from(2);
}
};
let mut launch_args: Option<String> = None;
let mut cwd: Option<PathBuf> = None;
let mut mode = SessionMode::Observe;
let mut break_at_entry = false;
let mut i = 2;
while i < args.len() {
match args[i].as_str() {
"-args" if i + 1 < args.len() => {
launch_args = Some(args[i + 1].clone());
i += 2;
}
"-cwd" if i + 1 < args.len() => {
cwd = Some(PathBuf::from(&args[i + 1]));
i += 2;
}
"-mode" if i + 1 < args.len() => {
mode = args[i + 1].parse().unwrap_or(SessionMode::Observe);
i += 2;
}
"-break-at-entry" => {
break_at_entry = true;
i += 1;
}
"-json" => i += 1,
_ => i += 1,
}
}
match process_launch(&LaunchRequest {
image,
args: launch_args,
cwd,
mode,
break_at_entry,
}) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"resume" => {
let sid = match args.get(1) {
Some(s) => s.as_str(),
None => {
eprintln!("usage: ghidrust process resume <session_id>");
return ExitCode::from(2);
}
};
match process_resume(sid) {
Ok(()) => {
println!("{{\"ok\":true,\"resumed\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"detach" => {
let sid = match args.get(1) {
Some(s) => s.as_str(),
None => {
eprintln!("usage: ghidrust process detach <session_id>");
return ExitCode::from(2);
}
};
match process_detach(sid) {
Ok(()) => {
println!("{{\"ok\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"modules" => {
let sid = match args.get(1) {
Some(s) => s.as_str(),
None => {
eprintln!("usage: ghidrust process modules <session_id>");
return ExitCode::from(2);
}
};
match process_modules(sid) {
Ok(m) => {
println!("{}", serde_json::to_string_pretty(&m).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"read" => {
let sid = match args.get(1) {
Some(s) => s.as_str(),
None => {
eprintln!("usage: ghidrust process read <session_id> -addr HEX -size N");
return ExitCode::from(2);
}
};
let mut addr = None;
let mut size = 64usize;
let mut i = 2;
while i < args.len() {
match args[i].as_str() {
"-addr" if i + 1 < args.len() => {
addr = parse_u64(&args[i + 1]).ok();
i += 2;
}
"-size" if i + 1 < args.len() => {
size = args[i + 1].parse().unwrap_or(64);
i += 2;
}
_ => i += 1,
}
}
let Some(va) = addr else {
eprintln!("missing -addr");
return ExitCode::from(2);
};
match process_read(sid, va, size) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"resolve" => {
let sid = match args.get(1) {
Some(s) => s.as_str(),
None => {
eprintln!("usage: ghidrust process resolve <session_id> -module NAME -rva HEX");
return ExitCode::from(2);
}
};
let mut module = None;
let mut rva = None;
let mut i = 2;
while i < args.len() {
match args[i].as_str() {
"-module" if i + 1 < args.len() => {
module = Some(args[i + 1].clone());
i += 2;
}
"-rva" if i + 1 < args.len() => {
rva = parse_u64(&args[i + 1]).ok();
i += 2;
}
_ => i += 1,
}
}
let (Some(m), Some(r)) = (module, rva) else {
eprintln!("need -module and -rva");
return ExitCode::from(2);
};
match process_resolve(sid, &m, r) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"regions" => {
let sid = match args.get(1) {
Some(s) => s.as_str(),
None => {
eprintln!("usage: ghidrust process regions <session_id> [-max N]");
return ExitCode::from(2);
}
};
let mut max = 256usize;
let mut i = 2;
while i < args.len() {
if args[i] == "-max" && i + 1 < args.len() {
max = args[i + 1].parse().unwrap_or(256);
i += 2;
} else {
i += 1;
}
}
match process_regions(sid, max) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"break" => {
// break set|clear|list
match args.get(1).map(|s| s.as_str()) {
Some("set") => {
let sid = args.get(2).map(|s| s.as_str()).unwrap_or("");
let mut addr = None;
let mut oneshot = false;
let mut i = 3;
while i < args.len() {
match args[i].as_str() {
"-addr" if i + 1 < args.len() => {
addr = parse_u64(&args[i + 1]).ok();
i += 2;
}
"-oneshot" => {
oneshot = true;
i += 1;
}
_ => i += 1,
}
}
let Some(va) = addr else {
eprintln!("usage: process break set <sid> -addr HEX [-oneshot]");
return ExitCode::from(2);
};
match process_break_set(sid, va, BreakKind::Software, oneshot) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
Some("clear") => {
let sid = args.get(2).map(|s| s.as_str()).unwrap_or("");
let mut id = None;
let mut addr = None;
let mut i = 3;
while i < args.len() {
match args[i].as_str() {
"-id" if i + 1 < args.len() => {
id = args[i + 1].parse().ok();
i += 2;
}
"-addr" if i + 1 < args.len() => {
addr = parse_u64(&args[i + 1]).ok();
i += 2;
}
_ => i += 1,
}
}
match process_break_clear(sid, id, addr) {
Ok(()) => {
println!("{{\"ok\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
Some("list") => {
let sid = args.get(2).map(|s| s.as_str()).unwrap_or("");
match process_break_list(sid) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
_ => {
eprintln!("usage: process break set|clear|list …");
ExitCode::from(2)
}
}
}
"continue" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
match process_continue(sid) {
Ok(()) => {
println!("{{\"ok\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"pause" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
match process_pause(sid) {
Ok(()) => {
println!("{{\"ok\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"wait" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let mut timeout = 5000u64;
let mut i = 2;
while i < args.len() {
if args[i] == "-timeout" && i + 1 < args.len() {
timeout = args[i + 1].parse().unwrap_or(5000);
i += 2;
} else {
i += 1;
}
}
match process_wait(sid, timeout) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"step" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let out = args.iter().any(|a| a == "-out");
let over = args.iter().any(|a| a == "-over");
let r = if out {
process_step_out(sid, None)
} else if over {
process_step_over(sid, None)
} else {
process_step_into(sid, None)
};
match r {
Ok(()) => {
println!("{{\"ok\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"step-out" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
match process_step_out(sid, None) {
Ok(()) => {
println!("{{\"ok\":true}}");
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"threads" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
match process_threads(sid) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"regs" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let tid: u32 = args.get(2).and_then(|s| s.parse().ok()).unwrap_or(0);
if tid == 0 {
eprintln!("usage: process regs <sid> <tid>");
return ExitCode::from(2);
}
match process_thread_context_get(sid, tid) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"stack" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let tid: u32 = args.get(2).and_then(|s| s.parse().ok()).unwrap_or(0);
if tid == 0 {
eprintln!("usage: process stack <sid> <tid>");
return ExitCode::from(2);
}
match process_stack(sid, tid, 32) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"scan" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let mut aob = None;
let mut string = None;
let mut i = 2;
while i < args.len() {
match args[i].as_str() {
"-aob" if i + 1 < args.len() => {
aob = Some(args[i + 1].clone());
i += 2;
}
"-string" if i + 1 < args.len() => {
string = Some(args[i + 1].clone());
i += 2;
}
_ => i += 1,
}
}
let opts = ScanOpts {
aob,
string,
..ScanOpts::default()
};
match process_scan_mem(sid, &opts) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"watch" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let expr = args.get(2).map(|s| s.as_str()).unwrap_or("");
if expr.is_empty() {
eprintln!("usage: process watch <sid> <expr>");
return ExitCode::from(2);
}
match process_watch_expr(sid, expr, false) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"vtable" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
let mut addr = None;
let mut i = 2;
while i < args.len() {
if args[i] == "-addr" && i + 1 < args.len() {
addr = parse_u64(&args[i + 1]).ok();
i += 2;
} else {
i += 1;
}
}
let Some(va) = addr else {
eprintln!("usage: process vtable <sid> -addr HEX");
return ExitCode::from(2);
};
match process_vtable_probe(sid, va, 32) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
"snapshot" => {
let sid = args.get(1).map(|s| s.as_str()).unwrap_or("");
match process_export_snapshot(sid, &[], &[]) {
Ok(r) => {
println!("{}", serde_json::to_string_pretty(&r).unwrap());
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
other => {
eprintln!("unknown process subcommand: {other}");
ExitCode::from(2)
}
}
}
pub fn cmd_rtti_query_cli(args: &[String], json: bool) -> ExitCode {
let path = match args.first() {
Some(p) if !p.starts_with('-') => PathBuf::from(p),
_ => {
eprintln!(
"usage: ghidrust rtti <path> [-filter SUB|-name NAME|-exact] [-match MODE] [-json]"
);
return ExitCode::from(2);
}
};
let mut filter: Option<String> = None;
let mut exact = false;
let mut mode = RttiMatchMode::Substr;
let mut i = 1;
while i < args.len() {
match args[i].as_str() {
"-filter" | "-name" if i + 1 < args.len() => {
filter = Some(args[i + 1].clone());
i += 2;
}
"-exact" => {
exact = true;
i += 1;
}
"-match" if i + 1 < args.len() => {
mode = RttiMatchMode::parse(&args[i + 1]);
i += 2;
}
_ => {
i += 1;
}
}
}
let prog = match load_path(&path) {
Ok(p) => p,
Err(e) => {
eprintln!("error: {e}");
return ExitCode::FAILURE;
}
};
match rtti_query(&prog, filter.as_deref(), exact, mode) {
Ok(q) => {
let entries = serde_json::to_value(&q.classes).unwrap();
let env = spill_if_large("rtti", entries, q.entry_count);
let body = json!({
"entry_count": q.entry_count,
"cache_hit": q.cache_hit,
"notes": q.notes,
"envelope": env,
"classes": if q.entry_count <= 64 {
serde_json::to_value(&q.classes).unwrap()
} else {
Value::Null
},
});
if json {
println!("{}", serde_json::to_string_pretty(&body).unwrap());
} else {
for c in q.classes.iter().take(64) {
println!(
"{} vtables={:?} col={:?} conf={} {:?}",
c.name, c.vtable_vas, c.col_va, c.confidence, c.reason
);
}
}
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("error: {e}");
ExitCode::FAILURE
}
}
}
fn spill_if_large(kind: &str, entries: Value, count: usize) -> Option<Value> {
if count <= 64 {
return None;
}
match spill_artifact(kind, entries, DEFAULT_PREVIEW_LIMIT, None) {
Ok(e) => Some(serde_json::to_value(e).unwrap()),
Err(_) => None,
}
}
pub fn resolve_and_entry(
prog: &mut ghidrust_core::Program,
addr: Option<u64>,
) -> Result<(u64, Value), String> {
let requested = addr.unwrap_or_else(|| prog.entry.unwrap_or(prog.image_base));
// Synthesize/heal orphans so decompile and other agent paths do not hard-fail
// on executable VAs outside analyzed function ranges.
let r = resolve_function(prog, requested).map_err(|e| e.to_string())?;
let meta = resolve_result_json(&r);
if !r.ok {
return Err(format!(
"resolve failed: {} ({})",
r.reason.as_deref().unwrap_or("unknown"),
meta
));
}
Ok((r.resolved_entry.unwrap(), meta))
}