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.
//! Integration tests: real CLI binary + MCP against fixtures.
use ghidrust_core::fixture_path;
use serde_json::json;
use std::io::Write;
use std::process::{Command, Stdio};
fn bin() -> Command {
Command::new(env!("CARGO_BIN_EXE_ghidrust"))
}
#[test]
fn cli_load_and_rtti_fixture() {
let pe = fixture_path("tiny_x64.pe");
let out = bin()
.args(["rtti", pe.to_str().unwrap(), "-json"])
.output()
.expect("run cli");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(s.contains("Widget"), "stdout={s}");
}
#[test]
fn cli_disasm_fixture() {
let pe = fixture_path("tiny_x64.pe");
let out = bin()
.args(["disasm", pe.to_str().unwrap(), "-count", "5"])
.output()
.expect("run");
assert!(out.status.success());
let s = String::from_utf8_lossy(&out.stdout);
assert!(s.contains("push") && s.contains("ret"), "{s}");
}
#[test]
fn cli_disasm_pretty_brief_and_text_out() {
let pe = fixture_path("tiny_x64.pe");
let pe_s = pe.to_str().unwrap();
let pretty = bin()
.args(["disasm", pe_s, "--count", "8", "--pretty"])
.output()
.expect("pretty");
assert!(
pretty.status.success(),
"stderr={}",
String::from_utf8_lossy(&pretty.stderr)
);
let pretty_s = String::from_utf8_lossy(&pretty.stdout);
assert!(pretty_s.contains("; entry="), "{pretty_s}");
assert!(
pretty_s.contains("push") || pretty_s.contains("ret"),
"{pretty_s}"
);
let brief = bin()
.args(["disasm", pe_s, "-count", "5", "-brief"])
.output()
.expect("brief");
assert!(brief.status.success());
let brief_s = String::from_utf8_lossy(&brief.stdout);
assert!(brief_s.contains("0x") && brief_s.contains(':'), "{brief_s}");
let tmp = std::env::temp_dir().join("ghidrust_disasm_brief_out.txt");
let _ = std::fs::remove_file(&tmp);
let out = bin()
.args([
"disasm",
pe_s,
"-count",
"5",
"-brief",
"-out",
tmp.to_str().unwrap(),
])
.output()
.expect("out");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let file = std::fs::read_to_string(&tmp).expect("read text out");
assert!(
file.contains(':') && !file.trim_start().starts_with('{'),
"{file}"
);
let _ = std::fs::remove_file(&tmp);
let json = bin()
.args(["disasm", pe_s, "-count", "5", "-json"])
.output()
.expect("json");
assert!(json.status.success());
let js = String::from_utf8_lossy(&json.stdout);
assert!(js.contains("listing_text"), "{js}");
assert!(js.contains("bounds_suspect"), "{js}");
}
#[test]
fn cli_analyzers_all_implemented() {
let out = bin()
.args(["analyzers", "-json"])
.output()
.expect("analyzers");
assert!(out.status.success());
let s = String::from_utf8_lossy(&out.stdout);
assert!(
s.contains("\"status\": \"implemented\"")
|| s.contains("Implemented")
|| s.contains("implemented")
);
assert!(!s.contains("not_implemented") && !s.contains("NotImplemented"));
}
#[test]
fn cli_analyze_multi_ok() {
let pe = fixture_path("analysis_lab.pe");
let out = bin()
.args([
"analyze",
pe.to_str().unwrap(),
"-analyzers",
"Function Start Search,Function ID,ASCII Strings,Call-Fixup Installer,Embedded Media,PDB Universal,Create Address Tables",
"-json",
])
.output()
.expect("analyze");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(!s.contains("not_implemented"));
assert!(s.contains("security_cookie"), "{s}");
assert!(s.contains("PNG"), "{s}");
assert!(s.contains("LabEntry"), "{s}");
assert!(s.contains("ExitProcess"), "{s}");
}
#[test]
fn mcp_list_and_analyze() {
let pe = fixture_path("tiny_x64.pe");
let mut child = bin()
.arg("mcp")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn mcp");
let mut stdin = child.stdin.take().unwrap();
let pe_s = pe.to_str().unwrap();
let reqs = format!(
"{}\n{}\n",
json!({"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}),
json!({"jsonrpc":"2.0","id":2,"method":"tools/call","params":{
"name":"analyze","arguments":{
"path": pe_s,
"analyzers": ["ASCII Strings", "WindowsPE x86 PE RTTI Analyzer", "Function Start Search"]
}
}}),
);
stdin.write_all(reqs.as_bytes()).unwrap();
drop(stdin);
let out = child.wait_with_output().unwrap();
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(s.contains("Widget") || s.contains("ok"), "{s}");
}
#[test]
fn cli_strings_utf16_and_json_no_bom() {
let pe = fixture_path("analysis_lab.pe");
let out = bin()
.args([
"strings",
pe.to_str().unwrap(),
"-encoding",
"utf16",
"-filter",
"WideLabString",
"-json",
])
.output()
.expect("strings");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
assert!(
!out.stdout.starts_with(&[0xEF, 0xBB, 0xBF]),
"JSON must be BOM-free"
);
assert_eq!(out.stdout.first().copied(), Some(b'['));
let s = String::from_utf8_lossy(&out.stdout);
assert!(s.contains("WideLabString"), "{s}");
assert!(s.contains("utf16le"), "{s}");
}
#[test]
fn cli_function_at_entry() {
let pe = fixture_path("analysis_lab.pe");
let out = bin()
.args([
"function-at",
pe.to_str().unwrap(),
"-addr",
"0x140001000",
"-json",
])
.output()
.expect("function-at");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(s.contains("0x140001000"), "{s}");
}
#[test]
fn cli_imports_lists_slots() {
let pe = fixture_path("analysis_lab.pe");
let out = bin()
.args(["imports", pe.to_str().unwrap(), "-json"])
.output()
.expect("imports");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
// Lab fixture imports at least one named symbol when the PE directory is present.
assert!(s.starts_with('[') || s.contains("iat_va"), "{s}");
}
#[test]
fn mcp_lists_new_lookup_tools() {
let mut child = bin()
.arg("mcp")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn mcp");
let mut stdin = child.stdin.take().unwrap();
let req = format!(
"{}\n",
json!({"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}})
);
stdin.write_all(req.as_bytes()).unwrap();
drop(stdin);
let out = child.wait_with_output().unwrap();
assert!(out.status.success());
let s = String::from_utf8_lossy(&out.stdout);
for tool in [
"list_strings",
"get_xrefs_to",
"get_string_xrefs",
"list_imports",
"get_import_xrefs",
"function_at",
] {
assert!(s.contains(tool), "missing {tool} in {s}");
}
}
#[test]
fn cli_version_matches_package() {
let out = bin().args(["-version"]).output().expect("version");
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
assert!(
s.contains(env!("CARGO_PKG_VERSION")),
"missing package version in {s}"
);
assert!(s.contains("tool_surface="), "{s}");
}
#[test]
fn mcp_server_info_and_live_tools() {
let mut child = bin()
.arg("mcp")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.spawn()
.expect("spawn mcp");
let mut stdin = child.stdin.take().unwrap();
let reqs = format!(
"{}\n{}\n{}\n",
json!({"jsonrpc":"2.0","id":1,"method":"initialize","params":{
"protocolVersion":"2024-11-05",
"capabilities":{},
"clientInfo":{"name":"test","version":"0"}
}}),
json!({"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}),
json!({"jsonrpc":"2.0","id":3,"method":"tools/call","params":{
"name":"server_info","arguments":{}
}}),
);
stdin.write_all(reqs.as_bytes()).unwrap();
drop(stdin);
let out = child.wait_with_output().unwrap();
assert!(
out.status.success(),
"stderr={}",
String::from_utf8_lossy(&out.stderr)
);
let s = String::from_utf8_lossy(&out.stdout);
let ver = env!("CARGO_PKG_VERSION");
assert!(
s.contains(ver),
"initialize/server_info missing version {ver}: {s}"
);
assert!(
s.contains("toolSurface") || s.contains("tool_surface"),
"missing tool_surface in {s}"
);
for tool in [
"server_info",
"process_list",
"process_attach",
"process_launch",
"process_resume",
"process_resolve",
"process_read",
"artifact_query",
"inventory",
"il2cpp_touch_map",
"function_create",
"net_rules_update",
"net_rules_list",
"net_detect",
] {
assert!(s.contains(tool), "missing {tool} in {s}");
}
assert!(
s.contains("et-open") || s.contains("\"et-open\""),
"initialize/server_info missing et-open network cap: {s}"
);
// tool_surface must be at least 3 (touch-map / body_class / function_create surface)
let surface_ok = s.contains("\"toolSurface\":3")
|| s.contains("\"tool_surface\": 3")
|| s.contains("\"tool_surface\":3")
|| s.contains("\"toolSurface\":4")
|| s.contains("\"tool_surface\": 4")
|| s.contains("\"tool_surface\":4")
|| s.contains("\"toolSurface\":5")
|| s.contains("\"tool_surface\": 5")
|| s.contains("\"tool_surface\":5")
|| s.contains("\"tool_surface\": 6")
|| s.contains("\"tool_surface\":6")
|| s.contains("\"tool_surface\": 7")
|| s.contains("\"tool_surface\":7")
|| s.contains("\"toolSurface\":8")
|| s.contains("\"tool_surface\": 8")
|| s.contains("\"tool_surface\":8");
assert!(surface_ok, "expected tool_surface >= 3 in {s}");
assert!(s.contains("net_dig"), "missing net_dig in {s}");
}