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.

3.8 KB
Raw Blame
//! Aggressive Instruction Finder — recover code only in real gaps (no fabrication).

use super::AnalyzerOutput;
use crate::disasm::decode_one;
use crate::error::Result;
use crate::program::{DiscoveredRange, FunctionInfo, Program};

pub fn run(prog: &mut Program) -> Result<AnalyzerOutput> {
    if prog.analysis.functions.is_empty() {
        let _ = super::function_start::run(prog)?;
    }
    let mut start_hashes: Vec<[u8; 4]> = Vec::new();
    for f in &prog.analysis.functions {
        if let Some(b) = prog.read_va(f.entry, 4) {
            if b.len() == 4 {
                let mut h = [0u8; 4];
                h.copy_from_slice(&b);
                start_hashes.push(h);
            }
        }
    }

    let func_ranges: Vec<(u64, u64)> = prog
        .analysis
        .functions
        .iter()
        .map(|f| (f.entry, f.end))
        .collect();

    let mut recovered = Vec::new();
    let exec: Vec<(u64, Vec<u8>)> = prog
        .exec_blocks()
        .map(|b| (b.va, b.bytes.clone()))
        .collect();

    for (block_va, bytes) in exec {
        let mut i = 0;
        while i + 4 <= bytes.len() {
            let va = block_va + i as u64;
            let covered = func_ranges.iter().any(|(s, e)| va >= *s && va < *e);
            if covered {
                i += 1;
                continue;
            }
            let slice = &bytes[i..i + 4];
            let hash_ok =
                start_hashes.is_empty() || start_hashes.iter().any(|h| h.as_slice() == slice);
            // Also accept classic prologues even if hash set empty
            let prolog = slice == [0x55, 0x48, 0x89, 0xE5] || bytes[i] == 0x55;
            if !(hash_ok || prolog) {
                i += 1;
                continue;
            }
            if validate_body(prog, va, &bytes[i..]) {
                let end = va + measure(prog, va);
                if end > va + 2 {
                    recovered.push(DiscoveredRange { start: va, end });
                    if prog.function_at(va).is_none() {
                        prog.analysis.functions.push(
                            FunctionInfo::new(va, end, format!("AIF_{va:08x}"))
                                .with_seed_kind(crate::program::FunctionSeedKind::Prologue),
                        );
                    }
                    i += (end - va) as usize;
                    continue;
                }
            }
            i += 1;
        }
    }

    // Dedup overlapping
    recovered.sort_by_key(|r| r.start);
    recovered.dedup_by_key(|r| r.start);
    let n = recovered.len();
    prog.analysis.recovered_code = recovered.clone();
    Ok(AnalyzerOutput {
        name: "Aggressive Instruction Finder".into(),
        status: "ok".into(),
        message: format!("found {n} recovered code range(s)"),
        recovered_ranges: Some(recovered),
        ..Default::default()
    })
}

fn validate_body(prog: &Program, va: u64, bytes: &[u8]) -> bool {
    let mut pos = 0u64;
    let mut n = 0;
    while n < 12 && (pos as usize) < bytes.len() {
        match decode_one(&bytes[pos as usize..], va + pos) {
            Ok(insn) => {
                n += 1;
                if insn.mnemonic == "ret" {
                    return n >= 2;
                }
                if insn.mnemonic == "int3" && n < 2 {
                    return false;
                }
                pos += insn.length as u64;
            }
            Err(_) => return false,
        }
    }
    n >= 3 && prog.contains_va(va)
}

fn measure(prog: &Program, va: u64) -> u64 {
    let mut cur = va;
    for _ in 0..32 {
        let Some(b) = prog.read_va(cur, 15) else {
            break;
        };
        let Ok(insn) = decode_one(&b, cur) else {
            break;
        };
        cur += insn.length as u64;
        if insn.mnemonic == "ret" || insn.mnemonic == "int3" {
            break;
        }
    }
    cur - va
}