Skip to content

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.

11.2 KB
Raw Blame
//! Per-analyzer TDD: each shipped entry on analysis_lab.pe asserts concrete fields.

use ghidrust_core::{fixture_path, load_path, run_analyzers, AnalyzerOutput};

fn lab() -> ghidrust_core::Program {
    load_path(fixture_path("analysis_lab.pe")).expect("fixtures/analysis_lab.pe")
}

fn run(name: &str) -> AnalyzerOutput {
    let mut prog = lab();
    let rep = run_analyzers(&mut prog, &[name]).unwrap();
    assert_eq!(rep.results.len(), 1);
    assert_eq!(
        rep.results[0].status, "ok",
        "{}: {}",
        name, rep.results[0].message
    );
    rep.results.into_iter().next().unwrap()
}

#[test]
fn ascii_strings_finds_api_and_class_names() {
    let o = run("ASCII Strings");
    let s = o.strings.as_ref().expect("strings field");
    assert!(s.iter().any(|x| x.value.contains("ExitProcess")), "{s:?}");
    assert!(
        s.iter().any(|x| x.value.contains("printf")
            || x.value.contains("LabClass")
            || x.value.contains("MyFunc")),
        "{s:?}"
    );
}

#[test]
fn function_start_finds_entry_and_lab_functions() {
    let o = run("Function Start Search");
    let fns = o.functions.as_ref().expect("functions");
    assert!(fns.iter().any(|f| f.entry == 0x140001000), "{fns:?}");
    // prologue-based starts
    assert!(
        fns.iter()
            .any(|f| f.entry == 0x140001030 || f.entry == 0x140001018),
        "expected stack/orphan start: {fns:?}"
    );
    // Must NOT create mid-prologue seed at 0x140001034 (sub rsp inside func_stack)
    assert!(
        !fns.iter().any(|f| f.entry == 0x140001034),
        "mid-prologue seed: {fns:?}"
    );
    // No start strictly inside another function body
    for f in fns {
        for g in fns {
            if f.entry != g.entry {
                assert!(
                    !(f.entry > g.entry && f.entry < g.end),
                    "nested start {:#x} inside {:#x}..{:#x}",
                    f.entry,
                    g.entry,
                    g.end
                );
            }
        }
    }
}

#[test]
fn aggressive_finds_orphan_or_gap_code() {
    let mut prog = lab();
    // Register only entry so orphan at 0x18 is a gap for AIF
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    // Keep only entry function to force gap
    prog.analysis.functions.retain(|f| f.entry == 0x140001000);
    let rep = run_analyzers(&mut prog, &["Aggressive Instruction Finder"]).unwrap();
    let ranges = rep.results[0]
        .recovered_ranges
        .as_ref()
        .expect("recovered_ranges");
    assert!(
        ranges
            .iter()
            .any(|r| r.start == 0x140001018 || r.start == 0x140001030),
        "expected gap recovery: {ranges:?}"
    );
}

#[test]
fn call_convention_tags_entry() {
    let mut prog = lab();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    let rep = run_analyzers(&mut prog, &["Call Convention ID"]).unwrap();
    let c = rep.results[0].conventions.as_ref().expect("conventions");
    assert!(
        c.iter()
            .any(|(va, name)| *va == 0x140001000 && !name.is_empty()),
        "{c:?}"
    );
}

#[test]
fn call_fixup_finds_security_cookie_string() {
    let o = run("Call-Fixup Installer");
    let f = o.call_fixups.as_ref().expect("call_fixups");
    assert!(f.iter().any(|x| x.fixup_name == "security_cookie"), "{f:?}");
    assert!(
        f.iter().any(|x| x.call_va == 0x140002018),
        "cookie VA: {f:?}"
    );
}

#[test]
fn address_tables_find_jump_table() {
    let o = run("Create Address Tables");
    let t = o.address_tables.as_ref().expect("address_tables");
    assert!(!t.is_empty(), "{t:?}");
    let tab = t.iter().find(|t| t.count >= 3).expect("table len>=3");
    assert_eq!(tab.base, 0x140002070, "{tab:?}");
    assert!(tab.entries.contains(&0x140001030), "{tab:?}");
}

#[test]
fn decomp_param_recovers_rcx_spill() {
    let mut prog = lab();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    let rep = run_analyzers(&mut prog, &["Decompiler Parameter ID"]).unwrap();
    let fns = rep.results[0].functions.as_ref().expect("functions");
    let stack_fn = fns
        .iter()
        .find(|f| f.entry == 0x140001030)
        .expect("func_stack");
    assert!(
        stack_fn.parameters.iter().any(|p| p.contains("rcx")),
        "{stack_fn:?}"
    );
}

#[test]
fn decomp_param_bare_entry_no_fabricated_rcx() {
    // tiny_x64 entry is push/mov/xor/pop/ret — no arg spill
    let mut prog = load_path(fixture_path("tiny_x64.pe")).unwrap();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    let rep = run_analyzers(&mut prog, &["Decompiler Parameter ID"]).unwrap();
    let fns = rep.results[0].functions.as_ref().expect("functions");
    let entry = fns
        .iter()
        .find(|f| f.entry == 0x140001000)
        .expect("entry fn");
    assert!(
        entry.parameters.is_empty(),
        "must not invent arg0:rcx: {entry:?}"
    );
    assert!(!entry.parameters.iter().any(|p| p.contains("rcx")));
}

#[test]
fn decomp_switch_from_real_table() {
    let o = run("Decompiler Switch Analysis");
    let sw = o.switches.as_ref().expect("switches");
    assert!(!sw.is_empty(), "{sw:?}");
    assert!(sw[0].cases.len() >= 2, "{sw:?}");
    assert_eq!(sw[0].jump_va, 0x140002070);
    assert!(sw[0].cases.iter().any(|(_, t)| *t == 0x140001030), "{sw:?}");
}

#[test]
fn demangler_microsoft_lab_mangled() {
    let o = run("Demangler Microsoft");
    let s = o.symbols.as_ref().expect("symbols");
    assert!(
        s.iter().any(|x| x.demangled.as_deref() == Some("MyFunc")
            || x.demangled.as_deref() == Some("LabClass")
            || x.name.contains("MyFunc")),
        "{s:?}"
    );
}

#[test]
fn embedded_media_finds_png() {
    let o = run("Embedded Media");
    let m = o.media.as_ref().expect("media");
    assert!(
        m.iter().any(|h| h.kind == "PNG" && h.va == 0x140002050),
        "{m:?}"
    );
}

#[test]
fn function_id_matches_entry_prolog() {
    let mut prog = lab();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    let rep = run_analyzers(&mut prog, &["Function ID"]).unwrap();
    let m = rep.results[0].fid_matches.as_ref().expect("fid");
    assert!(
        m.iter()
            .any(|x| x.entry == 0x140001000 && x.matched_name.contains("fid_")),
        "{m:?}"
    );
}

#[test]
fn noreturn_marks_exitprocess_and_body() {
    let o = run("Non-Returning Functions - Discovered");
    let n = o.noreturn_entries.as_ref().expect("noreturn");
    assert!(n.contains(&0x140002000), "ExitProcess string VA: {n:?}");
    // body at 0x50 has no ret + int3
    assert!(n.iter().any(|&e| e == 0x140001050), "func_nr: {n:?}");
}

#[test]
fn pdb_universal_parses_stream_symbols() {
    let o = run("PDB Universal");
    let s = o.symbols.as_ref().expect("pdb symbols");
    assert!(s.iter().any(|x| x.name.contains("MSF7")), "{s:?}");
    assert!(
        s.iter()
            .any(|x| x.name == "LabEntry" || x.name == "LabStackFrame"),
        "stream names: {s:?}"
    );
}

#[test]
fn pdb_msdia_same_portable_path() {
    let o = run("PDB MSDIA");
    let s = o.symbols.as_ref().expect("symbols");
    assert!(
        s.iter()
            .any(|x| x.name == "LabNoReturn" || x.name.contains("Lab")),
        "{s:?}"
    );
}

#[test]
fn shared_return_matches_two_epilogues() {
    let mut prog = lab();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    let rep = run_analyzers(&mut prog, &["Shared Return Calls"]).unwrap();
    let sh = rep.results[0].shared_returns.as_ref().expect("shared");
    assert!(sh.len() >= 2, "{sh:?}");
    assert!(
        sh.contains(&0x140001070) || sh.iter().any(|&e| e == 0x140001090 || e == 0x140001070),
        "{sh:?}"
    );
}

#[test]
fn stack_recovers_frame_size() {
    let mut prog = lab();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    let rep = run_analyzers(&mut prog, &["Stack"]).unwrap();
    let frames = rep.results[0].stack_frames.as_ref().expect("frames");
    let stack_fn = frames.iter().find(|(va, _)| *va == 0x140001030);
    assert!(stack_fn.is_some(), "{frames:?}");
    let locals = &stack_fn.unwrap().1;
    assert!(
        locals
            .iter()
            .any(|l| l.contains("frame_size=0x20") || l.contains("param_")),
        "{locals:?}"
    );
}

#[test]
fn stack_entry_not_polluted_by_later_body() {
    let mut prog = lab();
    run_analyzers(&mut prog, &["Function Start Search"]).unwrap();
    // entry ends before func_stack; must not pick up sub rsp from 0x30
    let entry_fn = prog
        .analysis
        .functions
        .iter()
        .find(|f| f.entry == 0x140001000)
        .expect("entry");
    assert!(
        entry_fn.end <= 0x140001018,
        "entry end: {:#x}",
        entry_fn.end
    );
    let rep = run_analyzers(&mut prog, &["Stack"]).unwrap();
    let frames = rep.results[0]
        .stack_frames
        .as_ref()
        .cloned()
        .unwrap_or_default();
    // Entry has no sub rsp / param spill — must not appear in frames (no filler)
    assert!(
        !frames.iter().any(|(va, _)| *va == 0x140001000),
        "entry must not get fabricated frame: {frames:?}"
    );
    // func_stack still real
    assert!(
        frames
            .iter()
            .any(|(va, locs)| *va == 0x140001030
                && locs.iter().any(|l| l.contains("frame_size=0x20"))),
        "{frames:?}"
    );
}

#[test]
fn variadic_marks_printf() {
    let o = run("Variadic Function Signature Override");
    let v = o.varargs_entries.as_ref().expect("varargs");
    assert!(v.contains(&0x140002010), "printf VA: {v:?}");
}

#[test]
fn rtti_still_works_on_tiny_pe() {
    let mut prog = load_path(fixture_path("tiny_x64.pe")).unwrap();
    let rep = run_analyzers(&mut prog, &["WindowsPE x86 PE RTTI Analyzer"]).unwrap();
    let r = rep.results[0].rtti.as_ref().unwrap();
    assert!(r.classes.iter().any(|c| c.name == "Widget"));
}

#[test]
fn external_params_exitprocess() {
    let o = run("Windows x86 Propagate External Parameters");
    let e = o.external_params.as_ref().expect("external_params");
    assert!(
        e.iter()
            .any(|(va, p)| *va == 0x140002000 && p.contains("ExitProcess")),
        "{e:?}"
    );
}

#[test]
fn resources_find_version_marker() {
    let o = run("WindowsResourceReference");
    let r = o.resources.as_ref().expect("resources");
    assert!(
        r.iter()
            .any(|x| x.name.contains("VERSION") && x.va == 0x140002090),
        "{r:?}"
    );
}

#[test]
fn bare_tiny_pe_no_fake_switch_or_pdb_entry() {
    let mut prog = load_path(fixture_path("tiny_x64.pe")).unwrap();
    let rep = run_analyzers(&mut prog, &["Decompiler Switch Analysis"]).unwrap();
    // may be empty if no jump table — must not invent entry cases
    if let Some(sw) = &rep.results[0].switches {
        for s in sw {
            assert!(
                !(s.jump_va == prog.entry.unwrap()
                    && s.cases.len() == 2
                    && s.cases[0].1 == prog.entry.unwrap()),
                "fabricated switch at entry: {s:?}"
            );
        }
    }
    let rep2 = run_analyzers(&mut prog, &["PDB Universal"]).unwrap();
    let syms = rep2.results[0]
        .symbols
        .as_ref()
        .cloned()
        .unwrap_or_default();
    assert!(
        !syms.iter().any(|s| s.name == "PDB_entry"),
        "fabricated PDB_entry: {syms:?}"
    );
}