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.

6.4 KB
Raw Blame
#!/usr/bin/env python3
"""Build fixtures/analysis_lab.pe — PE32+ with real patterns for all analyzers."""
from __future__ import annotations
import struct
from pathlib import Path

ROOT = Path(__file__).resolve().parents[1]
FIX = ROOT / "fixtures"
FIX.mkdir(exist_ok=True)

IMAGE_BASE = 0x140000000
FILE_ALIGN = 0x200
SECT_ALIGN = 0x1000


def align(n: int, a: int) -> int:
    return (n + a - 1) & ~(a - 1)


def build() -> bytes:
    # --- .text layout (RVA 0x1000) ---
    # entry @ 0: standard FID prologue
    entry = bytes([0x55, 0x48, 0x89, 0xE5, 0x31, 0xC0, 0x5D, 0xC3])
    # gap then second function (AIF target) with same start hash
    pad = b"\xCC" * 8
    # func_stack @ offset 0x20: push rbp; mov rbp,rsp; sub rsp,0x20; mov [rbp+10h],rcx; ret
    func_stack = bytes(
        [
            0x55,
            0x48,
            0x89,
            0xE5,
            0x48,
            0x83,
            0xEC,
            0x20,
            0x48,
            0x89,
            0x4D,
            0x10,
            0xC3,
        ]
    )
    # func_nr @ 0x40: no ret, ends in int3 (noreturn body)
    func_nr = bytes([0x48, 0x83, 0xEC, 0x28, 0xFF, 0x15, 0x00, 0x00, 0x00, 0x00, 0xCC, 0xCC])
    # shared epilogue pattern twice for shared-return (add rsp; pop rbp; ret)
    shared_ep = bytes([0x48, 0x83, 0xC4, 0x20, 0x5D, 0xC3])
    # func_a ends with shared_ep; func_b ends with same
    func_a = bytes([0x55, 0x48, 0x89, 0xE5, 0x90, 0x90]) + shared_ep
    func_b = bytes([0x55, 0x48, 0x89, 0xE5, 0x31, 0xC9]) + shared_ep

    text = bytearray(0x200)
    text[0:8] = entry
    text[0x10:0x10 + len(pad)] = pad
    # orphan code for AIF at 0x18 (gap from entry which ends 0x8)
    text[0x18:0x18 + 8] = bytes([0x55, 0x48, 0x89, 0xE5, 0x90, 0x90, 0x5D, 0xC3])
    text[0x30 : 0x30 + len(func_stack)] = func_stack
    text[0x50 : 0x50 + len(func_nr)] = func_nr
    text[0x70 : 0x70 + len(func_a)] = func_a
    text[0x90 : 0x90 + len(func_b)] = func_b

    # --- .rdata (RVA 0x2000) ---
    rdata = bytearray()
    text_va = IMAGE_BASE + 0x1000

    def rva_here() -> int:
        return 0x2000 + len(rdata)

    def va_here() -> int:
        return IMAGE_BASE + rva_here()

    # API name strings (scanned by call_fixup / varargs / noreturn / external_params)
    api_names = [
        b"ExitProcess\0",
        b"printf\0",
        b"__security_check_cookie\0",
        b"?MyFunc@@YAXXZ\0",
        b".?AVLabClass@@\0",
    ]
    api_vas = []
    for name in api_names:
        api_vas.append(va_here())
        rdata += name
        while len(rdata) % 8:
            rdata += b"\0"

    # PNG
    png_va = va_here()
    rdata += bytes([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A])
    rdata += bytes([0, 0, 0, 0x0D, ord("I"), ord("H"), ord("D"), ord("R")]) + b"\0" * 16

    # Address / switch table: 4 pointers into .text
    while len(rdata) % 8:
        rdata += b"\0"
    at_va = va_here()
    targets = [text_va + 0x30, text_va + 0x50, text_va + 0x70, text_va + 0x90]
    for t in targets:
        rdata += struct.pack("<Q", t)

    # Resource marker
    rsrc_va = va_here()
    rdata += b"RS\0\0" + struct.pack("<I", 16) + b"VS_VERSION_INFO\0"
    while len(rdata) % 8:
        rdata += b"\0"

    # Mini-PDB: MSF7 magic + page size + symbol stream (hand format)
    pdb_va = va_here()
    pdb = bytearray(b"Microsoft C/C++ MSF 7.00\r\n\x1aDS\0\0\0")
    pdb += struct.pack("<I", 0x1000)  # page size
    # stream: u32 count, then (u64 va, u16 len, name bytes)
    syms = [
        (text_va, b"LabEntry"),
        (text_va + 0x30, b"LabStackFrame"),
        (text_va + 0x50, b"LabNoReturn"),
    ]
    stream = struct.pack("<I", len(syms))
    for va, nm in syms:
        stream += struct.pack("<QH", va, len(nm)) + nm
    pdb += stream
    rdata += pdb

    # --- assemble PE ---
    text_rva, rdata_rva = 0x1000, 0x2000
    entry_rva = text_rva
    size_of_headers = 0x200
    text_raw_size = align(len(text), FILE_ALIGN)
    rdata_raw_size = align(len(rdata), FILE_ALIGN)
    text_file = size_of_headers
    rdata_file = text_file + text_raw_size
    size_of_image = align(rdata_rva + align(len(rdata), SECT_ALIGN), SECT_ALIGN)

    dos = bytearray(0x80)
    dos[0:2] = b"MZ"
    struct.pack_into("<I", dos, 0x3C, 0x80)

    coff = struct.pack("<HHIIIHH", 0x8664, 2, 0, 0, 0, 0xF0, 0x22)
    opt = bytearray(0xF0)
    struct.pack_into("<H", opt, 0, 0x20B)
    opt[2] = 14
    struct.pack_into("<I", opt, 16, entry_rva)
    struct.pack_into("<Q", opt, 24, IMAGE_BASE)
    struct.pack_into("<I", opt, 32, SECT_ALIGN)
    struct.pack_into("<I", opt, 36, FILE_ALIGN)
    struct.pack_into("<H", opt, 40, 6)
    struct.pack_into("<I", opt, 56, size_of_image)
    struct.pack_into("<I", opt, 60, size_of_headers)
    struct.pack_into("<H", opt, 68, 3)
    struct.pack_into("<H", opt, 70, 0x160)
    struct.pack_into("<Q", opt, 72, 0x100000)
    struct.pack_into("<Q", opt, 80, 0x1000)
    struct.pack_into("<Q", opt, 88, 0x100000)
    struct.pack_into("<Q", opt, 96, 0x1000)
    struct.pack_into("<I", opt, 108, 0x10)

    def sec(name, vsize, va, raw_size, raw_ptr, chars):
        return name[:8].ljust(8, b"\0") + struct.pack(
            "<IIIIIIHHI", vsize, va, raw_size, raw_ptr, 0, 0, 0, 0, chars
        )

    sh = sec(b".text", SECT_ALIGN, text_rva, text_raw_size, text_file, 0x60000020)
    sh += sec(b".rdata", SECT_ALIGN, rdata_rva, rdata_raw_size, rdata_file, 0x40000040)

    out = bytearray()
    out += dos + b"PE\0\0" + coff + opt + sh
    out += b"\0" * (size_of_headers - len(out))
    out += bytes(text).ljust(text_raw_size, b"\0")
    out += bytes(rdata).ljust(rdata_raw_size, b"\0")

    meta = {
        "image_base": hex(IMAGE_BASE),
        "entry": hex(IMAGE_BASE + entry_rva),
        "func_stack": hex(text_va + 0x30),
        "func_nr": hex(text_va + 0x50),
        "func_a": hex(text_va + 0x70),
        "func_b": hex(text_va + 0x90),
        "aif_orphan": hex(text_va + 0x18),
        "png_va": hex(png_va),
        "addr_table": hex(at_va),
        "rsrc_va": hex(rsrc_va),
        "pdb_va": hex(pdb_va),
        "api_exit": hex(api_vas[0]),
        "api_printf": hex(api_vas[1]),
        "api_cookie": hex(api_vas[2]),
        "mangled": hex(api_vas[3]),
    }
    (FIX / "analysis_lab.meta.txt").write_text(
        "\n".join(f"{k}={v}" for k, v in meta.items()) + "\n", encoding="utf-8"
    )
    return bytes(out)


def main():
    pe = build()
    path = FIX / "analysis_lab.pe"
    path.write_bytes(pe)
    print(f"wrote {path} ({len(pe)} bytes)")
    print((FIX / "analysis_lab.meta.txt").read_text())


if __name__ == "__main__":
    main()