Use when reverse engineering a shipped native binary, Go or Rust executable, Android application, Electron or JavaScript package, firmware image, browser target, or other artifact where behavior must be established from the artifact or observed runtime. Routes supported investigations through REA while preserving evidence, limitations, and unknowns; skip it for ordinary source-repository analysis.
REA is the artifact- and runtime-evidence workflow for questions that cannot be answered reliably from available source alone. Use it for shipped binaries and packages, decompilation, passive application runtime evidence, firmware, Android applications, Electron/JavaScript bundles, browser behavior, and version comparisons. It is an evidence collection and reasoning workflow, not a replacement for ordinary repository tools or a license to execute an untrusted target without authorization.
When to Use
Trigger phrases:
"reverse engineer this binary/package with REA"
"what does this shipped artifact do?"
"compare these versions"
"decompile this application"
"observe the application's requests without replaying them"
"inspect this Go/Rust/Android/Electron artifact"
Use REA when the claim depends on an artifact, decompiled code, passive runtime observation, or behavior comparison that is not established by available source. Route to the more specific workflow after triage when the task is malware, ELF, Go/Rust, Android, JavaScript, or exploitation focused.
When NOT to Use
The complete source repository already establishes the answer; use normal search, tests, and repository tools.
The task is ordinary implementation or architecture review rather than artifact behavior.
You do not have authorization to inspect, execute, instrument, or collect evidence from the target.
The request requires active exploitation, persistence, credential theft, or endpoint interaction outside an approved test environment.
Safety and Authorization
Work on a copy and record the artifact SHA-256 before analysis.
Treat samples as hostile: use an isolated VM/container, least privilege, no production credentials, and controlled networking.
Prefer static inspection and passive observation. Do not replay captured requests or execute unknown code merely to fill an evidence gap.
State scope and approval before instrumenting a target. Redact secrets and personal data from reports.
Separate observed behavior, tool-derived interpretation, and analyst inference; never present an inference as direct observation.
Workflow
Phase 1: Route and scope
Write the concrete question and the smallest artifact/runtime evidence needed to answer it.
Decide whether source analysis is sufficient. If yes, skip REA.
Hash and preserve the original artifact. Work from a copy and record tool versions.
Choose the focused path: native/package inspection, Go/Rust metadata, Android, JavaScript/Electron/browser, firmware, malware, or vulnerability analysis.
Phase 2: Connect only when required
Use the installed REA CLI/MCP integration when available and follow its live schema/help rather than assuming a particular release. If REA is unavailable, use the approved package invocation documented by the installation; do not invent tool names or arguments. A connection failure is a blocker to the REA path, not evidence about the target.
For a native artifact, open only the required local file and retain its returned session/reference. For package, Android, JavaScript, or runtime work, use the corresponding artifact inspection or passive observation operation. Keep all analysis actions tied to a scoped question.
Phase 3: Collect evidence
Start with artifact identity, format, architecture, hashes, entry points, imports/exports, strings, resources, and metadata.
For Go, inspect embedded build/module metadata before treating generic decompilation as complete. For Rust, use panic strings, crate paths, and symbol/string anchors as leads.
For Android, inspect manifest/components/resources and then trace only the relevant code or behavior.
For JavaScript/Electron/browser targets, capture the request/function path and observed values; do not invent browser globals or replay requests.
For runtime questions, prefer passive observation and record environment, timing, selected scope, coverage, and exclusions.
Read normalized tool results and preserve evidence IDs, artifact ranges, SHA-256 values, and pagination/coverage information.
Phase 4: Reason and verify
Maintain a question ledger with answered, partially answered, or unresolved for every requested question.
Tie each claim to an evidence record, artifact range, observed value, or clearly labeled inference.
Cross-check important conclusions with an independent signal: decompilation plus strings/xrefs, metadata plus symbols, or runtime behavior plus a local reproduction.
Treat missing records, unsupported formats, truncated output, and bounded negative searches as unknowns—not proof of absence.
Re-run only the smallest necessary observation after a hypothesis changes. Do not broaden collection without a reason.
Phase 5: Report and close
Report the target identity, scope, tools/versions, evidence references, findings, confidence, limitations, residual unknowns, and safe next steps. Mark what was observed versus inferred. Export or copy portable evidence before closing an opened native session, then close the session according to the installed REA integration. Do not claim completeness while required questions remain unresolved.
Focused Routing
Task
Start here
Malware behavior, C2, persistence, or unpacking
Malware-specific skill, with this workflow for artifact evidence
Linux ELF or native binary
analyzing-linux-elf-malware or reverse-engineering-malware-with-ghidra
Go or Rust executable
go-rust-reverse
Android application
reverse-engineering-android-malware-with-jadx or analyzing-android-malware-with-apktool
JavaScript, Electron, or browser logic
js-reverse or deobfuscating-javascript-malware
Memory corruption or exploitability
binary-breaker, only in an authorized lab
Source-only code understanding
Do not use REA; use repository tools
Evidence Record
For each meaningful operation, preserve:
Question:
Target and version:
Artifact SHA-256 / runtime scope:
Operation and tool version:
Evidence ID or artifact range:
Observed result:
Interpretation:
Confidence:
Coverage and limitations:
Residual unknowns:
Verification
Authorization, isolation, target identity, and allowed actions are documented.
Original artifact is preserved and its SHA-256 is recorded.
REA was used only because artifact/runtime evidence was required.
Every material claim maps to evidence or is labeled as inference.
Unsupported, missing, truncated, and unobserved behavior remains explicitly unknown.
Focused route and independent cross-check are documented.
Evidence was exported before native sessions were closed.
Final report includes scope, findings, confidence, limitations, and unresolved questions.
Anti-Rationalization Table
Rationalization
Reality
"The decompiler output is the truth."
Decompilation is an interpretation; preserve addresses, ranges, tool version, and corroborating evidence.
"No result means it is absent."
Unsupported or incomplete coverage is an unknown, not a negative finding.
"I can just run the sample."
Execution requires authorization, isolation, least privilege, and a question that static evidence cannot answer.
"The request capture can be replayed."
REA observation is passive; replay changes behavior and can affect real systems.
"I will report the whole application."
Scope the question and disclose coverage; bounded analysis is stronger than an unsupported completeness claim.
1---2name: reverse-engineer-anything-with-rea3description: Use when reverse engineering a shipped native binary, Go or Rust executable, Android application, Electron or JavaScript package, firmware image, browser target, or other artifact where behavior must be established from the artifact or observed runtime. Routes supported investigations through REA while preserving evidence, limitations, and unknowns; skip it for ordinary source-repository analysis.4domain: cybersecurity5author: oyi776license: Apache-2.07subdomain: reverse-engineering8tags:9 - reverse-engineering10 - REA11 - binaries12 - malware-analysis13 - runtime-observation14 - artifact-analysis15version: 1.0.016category: cybersecurity17metadata:18 source: https://skillmd.com/skills/oyi77/reverse-engineer-anything-with-rea19---2021# Reverse Engineer Anything with REA2223## Overview2425REA is the artifact- and runtime-evidence workflow for questions that cannot be answered reliably from available source alone. Use it for shipped binaries and packages, decompilation, passive application runtime evidence, firmware, Android applications, Electron/JavaScript bundles, browser behavior, and version comparisons. It is an evidence collection and reasoning workflow, not a replacement for ordinary repository tools or a license to execute an untrusted target without authorization.2627## When to Use2829**Trigger phrases:**30- "reverse engineer this binary/package with REA"31- "what does this shipped artifact do?"32- "compare these versions"33- "decompile this application"34- "observe the application's requests without replaying them"35- "inspect this Go/Rust/Android/Electron artifact"3637Use REA when the claim depends on an artifact, decompiled code, passive runtime observation, or behavior comparison that is not established by available source. Route to the more specific workflow after triage when the task is malware, ELF, Go/Rust, Android, JavaScript, or exploitation focused.3839## When NOT to Use4041- The complete source repository already establishes the answer; use normal search, tests, and repository tools.42- The task is ordinary implementation or architecture review rather than artifact behavior.43- You do not have authorization to inspect, execute, instrument, or collect evidence from the target.44- The request requires active exploitation, persistence, credential theft, or endpoint interaction outside an approved test environment.4546## Safety and Authorization4748- Work on a copy and record the artifact SHA-256 before analysis.49- Treat samples as hostile: use an isolated VM/container, least privilege, no production credentials, and controlled networking.50- Prefer static inspection and passive observation. Do not replay captured requests or execute unknown code merely to fill an evidence gap.51- State scope and approval before instrumenting a target. Redact secrets and personal data from reports.52- Separate observed behavior, tool-derived interpretation, and analyst inference; never present an inference as direct observation.5354## Workflow5556### Phase 1: Route and scope57581. Write the concrete question and the smallest artifact/runtime evidence needed to answer it.592. Decide whether source analysis is sufficient. If yes, skip REA.603. Confirm authorization, target identity, version, architecture, environment, and allowed network/runtime actions.614. Hash and preserve the original artifact. Work from a copy and record tool versions.625. Choose the focused path: native/package inspection, Go/Rust metadata, Android, JavaScript/Electron/browser, firmware, malware, or vulnerability analysis.6364### Phase 2: Connect only when required6566Use the installed REA CLI/MCP integration when available and follow its live schema/help rather than assuming a particular release. If REA is unavailable, use the approved package invocation documented by the installation; do not invent tool names or arguments. A connection failure is a blocker to the REA path, not evidence about the target.6768For a native artifact, open only the required local file and retain its returned session/reference. For package, Android, JavaScript, or runtime work, use the corresponding artifact inspection or passive observation operation. Keep all analysis actions tied to a scoped question.6970### Phase 3: Collect evidence7172- Start with artifact identity, format, architecture, hashes, entry points, imports/exports, strings, resources, and metadata.73- For Go, inspect embedded build/module metadata before treating generic decompilation as complete. For Rust, use panic strings, crate paths, and symbol/string anchors as leads.74- For Android, inspect manifest/components/resources and then trace only the relevant code or behavior.75- For JavaScript/Electron/browser targets, capture the request/function path and observed values; do not invent browser globals or replay requests.76- For runtime questions, prefer passive observation and record environment, timing, selected scope, coverage, and exclusions.77- Read normalized tool results and preserve evidence IDs, artifact ranges, SHA-256 values, and pagination/coverage information.7879### Phase 4: Reason and verify80811. Maintain a question ledger with `answered`, `partially answered`, or `unresolved` for every requested question.822. Tie each claim to an evidence record, artifact range, observed value, or clearly labeled inference.833. Cross-check important conclusions with an independent signal: decompilation plus strings/xrefs, metadata plus symbols, or runtime behavior plus a local reproduction.844. Treat missing records, unsupported formats, truncated output, and bounded negative searches as unknowns—not proof of absence.855. Re-run only the smallest necessary observation after a hypothesis changes. Do not broaden collection without a reason.8687### Phase 5: Report and close8889Report the target identity, scope, tools/versions, evidence references, findings, confidence, limitations, residual unknowns, and safe next steps. Mark what was observed versus inferred. Export or copy portable evidence before closing an opened native session, then close the session according to the installed REA integration. Do not claim completeness while required questions remain unresolved.9091## Focused Routing9293| Task | Start here |94|---|---|95| Malware behavior, C2, persistence, or unpacking | Malware-specific skill, with this workflow for artifact evidence |96| Linux ELF or native binary | `analyzing-linux-elf-malware` or `reverse-engineering-malware-with-ghidra` |97| Go or Rust executable | `go-rust-reverse` |98| Android application | `reverse-engineering-android-malware-with-jadx` or `analyzing-android-malware-with-apktool` |99| JavaScript, Electron, or browser logic | `js-reverse` or `deobfuscating-javascript-malware` |100| Memory corruption or exploitability | `binary-breaker`, only in an authorized lab |101| Source-only code understanding | Do not use REA; use repository tools |102103## Evidence Record104105For each meaningful operation, preserve:106107```text108Question:109Target and version:110Artifact SHA-256 / runtime scope:111Operation and tool version:112Evidence ID or artifact range:113Observed result:114Interpretation:115Confidence:116Coverage and limitations:117Residual unknowns:118```119120## Verification121122- [ ] Authorization, isolation, target identity, and allowed actions are documented.123- [ ] Original artifact is preserved and its SHA-256 is recorded.124- [ ] REA was used only because artifact/runtime evidence was required.125- [ ] Every material claim maps to evidence or is labeled as inference.126- [ ] Unsupported, missing, truncated, and unobserved behavior remains explicitly unknown.127- [ ] Focused route and independent cross-check are documented.128- [ ] Evidence was exported before native sessions were closed.129- [ ] Final report includes scope, findings, confidence, limitations, and unresolved questions.130131## Anti-Rationalization Table132133| Rationalization | Reality |134|---|---|135| "The decompiler output is the truth." | Decompilation is an interpretation; preserve addresses, ranges, tool version, and corroborating evidence. |136| "No result means it is absent." | Unsupported or incomplete coverage is an unknown, not a negative finding. |137| "I can just run the sample." | Execution requires authorization, isolation, least privilege, and a question that static evidence cannot answer. |138| "The request capture can be replayed." | REA observation is passive; replay changes behavior and can affect real systems. |139| "I will report the whole application." | Scope the question and disclose coverage; bounded analysis is stronger than an unsupported completeness claim. |
Run npx get-skill add oyi77/reverse-engineer-anything-with-rea in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.
Use when reverse engineering a shipped native binary, Go or Rust executable, Android application, Electron or JavaScript package, firmware image, browser target, or other artifact where behavior must be established from the artifact or observed runtime. Routes supported investigations through REA while preserving evidence, limitations, and unknowns; skip it for ordinary source-repository analysis. It is listed under Coding & Dev Tools on SkillMD.
This skill has not completed SkillMD's automated safety review yet. Independent scanners report: SkillSpector: PASS, Skill Scanner: PASS. Capability flags: docs only. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.
This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.
Yes. Installing skills from SkillMD is free. This skill is licensed under Apache-2.
oyi77 (@oyi77) published this skill. Their other Agent Skills are listed on their SkillMD profile.