Anti-REA
Built-in format reader that surfaces declared Erlang container metadata exposed by shipped BEAM artifacts so it can be reviewed and mitigated.
Built-in JavaScript reader that detects source maps and module graphs in a package and reports the original sources recoverable from them.
Built-in managed assembly reader that extracts .NET metadata and CIL facts, including assembly attributes and a member inventory, from shipped artifacts.
Built-in reader for Python bytecode (.pyc) containers that reports format flags and declared metadata; these findings are reported without a mitigation because the runtime requires them.
Built-in Rust reader that inspects embedded dependency metadata (.dep-v0) in shipped artifacts, reporting crate names, versions, and dependency edges so they can be audited and hardened.
Built-in format reader that reports the declared metadata and record totals carried by SQLite database containers embedded in or shipped alongside an artifact.
Built-in Unity IL2CPP metadata reader that identifies recoverable type and method names exposed by a shipped Unity build, letting the audit flag them for mitigation.
This server does not currently have a deployable release on Glama. Follow the repository's setup instructions to install and configure it for your MCP client, including any required credentials and local dependencies.
Anti-REA
An MCP server for hardening your own software against agent-driven reverse engineering
Audit what your shipped artifacts leak. Apply mitigations. Verify the result.
English · 简体中文 · 繁體中文 · 日本語 · 한국어 · Deutsch · Français · Español · Português (Brasil) · Русский · Italiano
Zero-dependency Node.js. Everything runs locally. Requires Node.js 22 or newer.
How it works · Quick start · What the audit reports · Measured results · Defense layers · Known limits · FAQ · Verification · Contributing · Security
Install Anti-REA from npm (anti-rea) or clone this repository. A similarly
named package does not establish that a download is official.
Use it on software you own or are authorized to protect.
REA (Reverse Engineer Anything) and similar MCP-based toolchains let an AI agent inspect a shipped binary, package, or application without its source code, explain how a feature works, and build a version of it. That drives the cost of understanding software you ship close to zero.
Anti-REA is the counterpart for the defender. It is an MCP server — with a command-line interface sharing the same workflows — that hardens your own project before it ships:
audit_artifact: what a shipped artifact exposes to the readers and engines such tools use, with the evidence and source range behind every fact
harden_artifact: apply the mitigations the tool can apply, and report the ones that need external tools or an architectural change
verify_artifact: confirm the mitigations hold
generate_notice: truthful license and no-reverse-engineering text for your artifact's own README, so an investigating agent meets your terms as data at the moment it checks authorization
generate_probe_kit: an embeddable runtime-observation detection package for your own code, plus a manual checklist
How it works
Three commands run in order, and the order matters:
auditreads your artifact without running it and reports every fact a reader could extract, each with its evidence range and the reader that would consume it. It writes nothing to the artifact.hardentakes that report and applies the mitigations it can, writing a.hardenedcopy beside the original. Every mitigation is an equal-length overwrite or a relayout write, so file length and offsets stay valid. Anything that would change runtime behavior is reported as skipped with its reason, never silently attempted.verifyre-reads the hardened copy and checks the structures your users still depend on. The required sets are derived from the applied mitigations: what a mitigation declares it touches is exempted, everything else must still parse. A hardening run that breaks a required structure fails review, and the original is left untouched.
The same three workflows back the MCP tools and the CLI, so an agent and a terminal get identical results and identical exit codes: 0 for a completed audit or hardening run, 1 for a failed verification, 2 for a usage error, 3 for a refusal.
Related MCP server: FEA
Install
npx anti-rea --help # run once without installing
npm install --global anti-rea # or install both commands globally
anti-rea --helpRequires Node.js 22 or newer. The package has no dependencies, and everything runs locally.
Connect your agent
After a global install, register the server with any MCP-capable agent (Claude Code, Cursor, Codex, and others):
{
"mcpServers": {
"anti-rea": {
"command": "anti-rea-mcp"
}
}
}Working from a clone instead of the global install? Point command at
node with args set to the absolute path of bin/anti-rea-mcp.js.
Then ask your agent: audit my app at /path/to/app and tell me what it leaks.
Quick start from the terminal
anti-rea audit /absolute/path/to/your/app --json
anti-rea harden /absolute/path/to/your/app --from audit.json
anti-rea verify /absolute/path/to/your/app
anti-rea notice --template license > NOTICE.md
anti-rea probe /absolute/path/to/probe-kit-outputThe probe command writes an integration package for the runtime observation resistance
layer: embeddable detection snippets for observable facts, plus a manual checklist. It writes
only to the directory you name and never modifies your artifact. The same package is available
to agents as the generate_probe_kit tool.
What the audit reports
Exposure | Who reads it | What audit reports |
ELF/PE/Mach-O headers, sections, symbols, build IDs | Built-in static readers, objdump | Every fact a reader can extract, with its source range |
Embedded Go module and build metadata | Built-in Go reader | Presence, versions, and the section that carries them |
Embedded Rust dependency metadata ( | Built-in Rust reader | Crate names, versions, and dependency edges |
Unity IL2CPP metadata | Built-in IL2CPP reader | Recoverable type and method names |
.NET metadata and CIL | Built-in managed reader | Assembly facts and member inventory |
JavaScript source maps and module graphs | Built-in JavaScript reader | Recoverable original sources |
PE certificates, imports, exports, load config | Built-in PE readers | Signer identity and declared imports |
Model, SQLite, Erlang, pyc and other container metadata | Built-in format readers | Declared metadata and totals |
Embedded credentials | Token pattern scanner | Known credential families with public formats, with offset |
Each finding carries its evidence, the reader that would consume it, and the mitigation that removes it.
Measured results
Everything below was run on real artifacts, not fixtures: a Go 1.24.4 binary built for Linux and for Windows, and a Python 3.13 bytecode file, hardened by this tool and then read back with REA's own static readers and by fresh agents.
Question | Result |
Does REA recover Go build information after hardening? | No. On both ELF and Windows PE, |
Are ELF symbol tables and build IDs gone? | Yes. |
Can plain | Yes. The module name, compiler version, and build settings remain in read-only data and the function name table. See Known limits. |
Does the audit see a token hidden in Python bytecode? | Yes, as of this release. The token scanner runs over all eight formats, and the embedded credential is reported and overwritten on request. |
Does a legal notice make an investigating agent stop? | Not in the measured sample. Four fresh agents received the same reverse-engineering task on the same binary; two saw a generated notice, two did not. All four completed the analysis. Both agents that read the notice cited it, and both volunteered that redistributing the analysis would need authorization. |
What still leaks after hardening? | Build-machine paths from unstripped debug information, the PE import table, and every format fact the software needs to run. The audit reports these without inventing a mitigation. |
The fifth row is the honest one: the notice layer changes how an agent frames the work, not whether it does it. Treat it as a contract and traceability measure, not a technical barrier.
Protect your audit outputs
An audit report is a map of your artifact's exposures and the mitigations applied.
Committing it to version control, or shipping it inside the artifact, hands that map to
anyone who reads the repository. Anti-REA writes a warning to standard error when an
output path is inside a git working tree. Use --redacted when a report must be shared
with a contractor, an auditor, or a disclosure program: it keeps categories and counts
and omits exact paths, byte ranges, and the mitigation mapping. Generated notices
contain no reference to Anti-REA and no hint of your hardening state.
Defense layers
Layer | Tool | Expected effect | Residual risk |
Metadata hygiene |
| Built-in readers return unknown instead of facts | A new reader can target a new format; plain string search still finds module names and versions in read-only data |
Content protection |
| Static decompilation sees stubs, not the program | Runtime dumping recovers unpacked code |
Runtime observation resistance |
| Raises the cost of debuggers and instrumentation | Kernel-level observation is out of reach |
Agent stop-condition induction |
| The agent checks authorization with the human | The agent may ignore the notice |
Model-level truthful signals |
| The authorization question becomes unavoidable | Model behavior is probabilistic |
Secret minimization | Report recommendation | The only absolute layer | Requires server-side architecture |
Legal and operational |
| Contract and traceability do what bytes cannot | Enforcement is a legal process |
Known limits
Three limits were measured, not theorized:
Plain string search still works. Equal-length overwrites destroy metadata records such as Go build information and ELF symbol tables, but the module name, compiler version, and build settings also live in read-only data and the function name table, where the Go runtime reads them. Overwriting those bytes changes runtime behavior, so Anti-REA leaves them alone, and anything that runs
stringson a hardened binary still recovers them. Remove them at the source with build flags (-trimpath,-ldflags="-s -w",strip).Not every exposure has a mitigation. PE import tables, ELF header facts, and Python bytecode format flags are reported with no mitigation because the software needs them to run. The audit says so instead of inventing a measure.
Token patterns cover known formats only. The scanner matches credential families with public formats. A token in a private format is invisible to it, and an empty result is not proof that no secrets exist.
Host coverage is also a measured limit: the tool is pure Node.js with no native dependencies, but the test suite and fixtures have only been exercised on Windows. macOS and Linux are expected to work and are not yet verified.
FAQ
Mitigations are equal-length overwrites or full relayouts that re-run every format check, and verify fails a run that breaks a structure your users depend on. Anything that would change runtime behavior is skipped with a stated reason instead of attempted. Re-running harden on an already hardened artifact is a no-op that reports no change.
No. Every read and write is a local file operation inside the process. No network requests, no child processes, no telemetry.
Any agent that can register a local MCP server: Claude Code, Cursor, Codex, and others. Manual registration is the JSON block under Connect your agent.
Yes, and that is why the tool warns when you write one inside a git working tree and offers --redacted, which keeps categories and counts and drops exact paths, byte ranges, and the mitigation mapping.
Then the artifact exposes nothing the readers can extract, and the report says so with its limitations. An empty result is not proof of safety: the token patterns cover known credential formats only, and a new reader can target a new format.
No. It raises the cost of automated readers and leaves evidence for your legal position. A skilled person with a debugger, or anyone with kernel-level access, is outside what bytes in a file can resist. Keeping secrets off the client is the only absolute layer.
Not reliably, and this project does not claim otherwise. In the measured sample of four fresh agents, none stopped. Both agents that read the notice cited it and flagged that redistributing the analysis would need authorization. Treat the notice as a contract and traceability measure.
Check that you are on the latest commit, then open an issue with your Node version, target type, the command you ran, and the output. See Contributing.
Boundaries
Anti-REA does not do the following, by design:
No prompt injection. It never ships agent instruction files (
AGENT.md,CLAUDE.md,.cursorrules, and similar) into your artifacts, and never writes directives addressed to an AI agent. Notices are statements of fact addressed to a human reader and travel through data channels: README, LICENSE, NOTICE, version resources.No fabricated legal claims. Every line of generated notice text is a real term or a real, checkable fact. Inflated threats collapse the first time someone verifies them.
No harm to legitimate users. Mitigations never weaken your software's own operation. Runtime protections are opt-in per threat model, not defaults.
About this repository
Anti-REA is open source by design: its audit rules are public, it holds no secrets, and it
carries no attack payloads. The tool's value is automation and evidence, not secrecy — and
the one absolute defense layer, keeping secrets off the client, is unaffected by anyone
reading this code. What must never enter the repository is user-specific audit output,
which is why the tool warns about it and offers --redacted.
Verification
Every capability is covered by node --test with real fixture files, and the MCP surface
is smoke-tested over a standard stdio handshake:
node --test
node scripts/mcp-smoke.mjs
node tests/fixtures/build.mjs --checkThe current suite is 526 tests, all passing, plus the fixture digest registration check. The suite runs on Windows with Node.js 22 and 24; macOS and Linux hosts have not been exercised yet.
Contributing
Issues and pull requests are welcome. See CONTRIBUTING.md for development setup, the checks that gate a change, and the conventions the test suite enforces.
Security
Report vulnerabilities in Anti-REA itself through SECURITY.md, not in public issues. Design limits documented under Known limits are not vulnerabilities.
Documentation
CONTRIBUTING.md: development setup and change gates
SECURITY.md: how to report a vulnerability
LICENSE: MIT
License
MIT. Anti-REA is for protecting software you own or are authorized to protect. Third-party formats keep their own specifications.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
This server cannot be deployed
Maintenance
Related MCP Connectors
Browser-local and CLI static evidence for deployed AI model artifacts.
Check agent tools before use: what they do, what changed, signed Record Checks. Free, read-only.
Live behavioral security verifier, schema auditor, and trust oracle for A2A, MCP & x402 agents.
Preflight, approve, and prove consequential agent actions with signed evidence and x402 tools.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables agents to analyze software artifacts through 35 tools covering read-only reconnaissance, secret/string/symbol scanning, native and Dart AOT structure checks, exposure tiering, protection planning, attack-simulation design, and an append-only evidence ledger with mechanical verified gates that treat unresolved unknowns as blocking. Gated execution tools apply reviewed transforms only to a managed copy inside an authorized workspace, with one-time approval tokens, independent verification, before/after diffs, and rollback.MIT
- AlicenseNot gradedqualityBmaintenanceEnables agents to turn authorized software artifacts into verified working reimplementations through behavioral capture, clean-room synthesis, differential parity verification, and evidence-pack export. It supports CLI binaries and HTTP APIs, with policy controls and vector fuzzing.1MIT
- AlicenseNot gradedqualityBmaintenanceEnables agents to locate core logic and surrounding clues, generate approved protection plans, apply obfuscation and virtualization through supported engines, and verify behavior and relative speed after protection. It helps defend binaries, applications, and critical logic against reverse-engineering analysis and cloning.21MIT
- AlicenseNot gradedqualityAmaintenanceEnables agents to audit artifacts for reverse-engineering exposure, inject adversarial protection into binaries, Electron apps, JavaScript bundles, WebAssembly, Python bytecode, databases, AI models, and mobile packages, and verify that automated reconstruction fails.11,945 npm6,193MIT