New advertisers: 50% off your first month with code FIRSTMONTHSee slots
laurigates avatar

reverse-engineering-plugin

Low-level reverse-engineering skills for Ghidra decompilation, firmware carving, ACPI, and TEE passthrough analysis.

version
1.1.0
GitHub stars
60
View on GitHub

What it does

  • Adds 6 skills covering headless Ghidra decompilation, firmware dump region mapping, ACPI table RE with iasl, and deterministic binary-format examiners
  • Covers the Ghidra 12 Jython-to-PyGhidra break, the project lock, and extracting LZMA-compressed UEFI volumes that raw grep misses
  • Guides passthrough decisions with the /proc/iomem and e820 check, data-plane versus control-plane separation, and the case where a TEE rules out forwarding
  • Designed for reverse engineers working on firmware, hardware, and SGX/TEE-sealed secrets rather than general application debugging

Low-level reverse-engineering workflows - headless Ghidra decompilation, firmware-dump region mapping, deterministic binary-format examiners, ACPI table RE, SGX/TEE-sealed-secret recovery reasoning, and device/physical-memory passthrough feasibility

Add marketplace

/plugin marketplace add laurigates/claude-plugins

Run it inside Claude Code once, then install the plugin below.

Install

/plugin install reverse-engineering-plugin@laurigates-claude-plugins

Run it inside Claude Code after adding the marketplace.

Files

Discovered from source

ACPI Table Reverse-Engineering

ACPI tables (DSDT + the SSDTs) are the firmware's description of every onboard device, its resources, power/wake behaviour, and vendor _DSM entry points. Decompiling them answers "what is this device, how is it wired, how does it wake" without guessing from the device menu.

Get the tables and decompile

# Live, on a Linux box (names visible without root; bytes need root):
ls /sys/firmware/acpi/tables/            # DSDT SSDT1..N FACP FPDT ... (+ dynamic/)
sudo cp /sys/firmware/acpi/tables/SSDT9 /tmp/ && iasl -d /tmp/SSDT9   # -> SSDT9.dsl

# From a firmware dump: extract the BIOS region first (see firmware-dump-region-map),
# then iasl -d the .aml tables. Or carve live AML with acpixtract.
iasl -d *.aml                            # batch; re-run singly if one truncates

iasl ships in the acpica/acpica-tools package (iasl, acpixtract). A batch iasl -d *.aml can exit non-zero on external-symbol warnings while still emitting .dsl — re-run the stragglers individually.

Find a device

rg -n 'Device \(|_ADR|_HID|_CID' DSDT.dsl        # device tree
rg -n '0x001F0005' DSDT.dsl                       # by PCI _ADR (seg/bus:dev.fn)
rg -n '"GXFP51B7"|EisaId' DSDT.dsl                # by _HID
  • _ADR = address on the parent bus (PCI dev<<16|fn); _HID/_CID = the ACPI/PNP id a driver binds. A _HID returned from a method (not a Name) is chosen at runtime from a firmware variable — the actual id is in an NVS/EC field, read it live (/sys/bus/.../modalias).
  • _STA gates presence; a device can be defined but return 0 (absent) on this SKU. _INI, _CRS (current resources: IRQ/GPIO/memory), _DSM (vendor device-specific method, keyed by a UUID + function index).

Map wake sources (suspend / drain work)

rg -n '_PRW' DSDT.dsl                              # Power Resources for Wake
rg -n 'GPRW|_GPE|Notify' DSDT.dsl

_PRW returns {GPE-bit, lowest-sleep-state} — the devices armed to wake the system and from how deep. A shared GPE bit (many devices Return (GPRW(0x6D,…))) is the firmware funnelling USB/PCIe wake through one line; watch its counter at /sys/firmware/acpi/interrupts/gpe<NN> for a spurious-wake storm. OEM "instant-wake" fixes mask specific GPEs — a clue to which wake sources misbehave.

Vendor _DSM methods

A _DSM is (UUID, rev, function-index, args). Function 0 returns a bitmap of supported functions; the rest are vendor-defined (e.g. an EC-command doorbell, a blob read). Read the method body to learn the real action — often it just pokes an EC command or returns an operation-region field. Cross-check against the driver: an _DSM guarded by CondRefOf(\_SB...X) that names a path which doesn't exist (a firmware typo, e.g. H_EC vs HWEC) is dead code that never executes, however much the driver seems to call it.

Related

  • firmware-dump-region-map — extract the BIOS region to get the .aml tables.
  • ghidra-headless-decompile — pair the ACPI view with the driver that calls it.
  • linux-plugin / macos-plugin — platform power/suspend debugging that consumes these wake findings.

Readme

Reverse-Engineering Plugin

Low-level reverse-engineering workflows: decompiling binaries, carving firmware images apart, reasoning about hardware/VM passthrough and TEE-sealed secrets, and reading ACPI tables. The skills grew out of recurring RE work across several projects — a 1998 game port (skullcaps), Switch homebrew, and a laptop firmware/fingerprint investigation — distilled into reusable form.

These cover the parts that are the same regardless of target: how to drive Ghidra at scale, where things live in a flash dump, what a TEE actually protects, and when a passthrough plan is dead on arrival. Domain-specific asset formats, per-game bindings, and platform modding stay in their own repos.

Related skills elsewhere:

  • tools-plugin:binary-analysis — strings/binwalk/objdump/entropy triage, the first pass before Ghidra or region-mapping.
  • tools-plugin:cli-smoke-recipes — expose a format decoder/examiner as a CLI with a bulk-smoke recipe (the delivery surface for re-deterministic-examiner).
  • code-quality-plugin:debugging-methodology — memory/perf/system debugging.
  • linux-plugin / macos-plugin — platform power and suspend work that consumes acpi-table-re's wake-source findings.
  • agent-patterns-plugin:exclusive-lock-dispatch — the general pattern behind Ghidra's project lock.

Skills

SkillDescription
ghidra-headless-decompileDrive Ghidra headless: export decompiled C for every function to a greppable file, dump xrefs/call graphs. The Ghidra 12 Jython→PyGhidra break (scripts are Java now), analyzeHeadless invocation, the project lock, and pre-dump-then-dispatch
firmware-dump-region-mapEnumerate every region of a BIOS/SPI-flash dump (descriptor, ME/CSME, EC, BIOS) before carving one; extract LZMA-compressed UEFI volumes (why raw grep misses strings); the host-side-vs-device-side split of a feature
acpi-table-reDecompile DSDT/SSDT with iasl: find a device by _ADR/_HID, read a _DSM, map wake sources (_PRW/GPE) for suspend/drain work, spot dead-code methods
sgx-sealed-secret-recoveryWhether a TEE-sealed secret is recoverable: the CPU+MRSIGNER binding, EGETKEY, the created-on-device inference, routes that work (capture at source, non-attesting peers, run the genuine enclave) vs don't (off-platform unseal, hypervisor peek, closed side channels)
device-passthrough-feasibilityWhether hardware or a physical address range can be forwarded into a VM: what's bindable, the /proc/iomem+e820 classification, data-plane vs control-plane, and why a TEE makes the VM boundary the wrong layer
re-deterministic-examinerBuild a deterministic examiner for a binary format instead of guessing its structure: slice into labelled units + a manifest, measure the slicing and refuse when underdetermined, keep it diffable and shell-reachable

Details

Marketplace
laurigates/claude-plugins
Source
reverse-engineering-plugin
Author
Lauri Gates
Category
Development
License
MIT
Keywords
reverse-engineering, ghidra, firmware, sgx, tee, acpi, vfio, binary-analysis, decompile, uefi

More from laurigates/claude-plugins

All 52

Similar to reverse-engineering-plugin

More Development Tools