<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Devirt</title>
    <description>The latest articles on DEV Community by Devirt (@devirt).</description>
    <link>https://dev.to/devirt</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4208891%2F71843363-e7bc-4b62-8a8a-e6495d53a9b9.png</url>
      <title>DEV Community: Devirt</title>
      <link>https://dev.to/devirt</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/devirt"/>
    <language>en</language>
    <item>
      <title>IDA Pro Alternatives in 2026: Prices and Decompilers Compared</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Fri, 13 Nov 2026 09:59:02 +0000</pubDate>
      <link>https://dev.to/devirt/ida-pro-alternatives-in-2026-prices-and-decompilers-compared-1b7m</link>
      <guid>https://dev.to/devirt/ida-pro-alternatives-in-2026-prices-and-decompilers-compared-1b7m</guid>
      <description>&lt;p&gt;The main IDA Pro alternatives in November 2026 are Ghidra, Binary Ninja, Rizin with its Cutter GUI, radare2 and Hopper, with x64dbg covering live debugging on Windows. Four of those six are free and open source. This comparison checks what each one costs, how it's licensed and which processors its decompiler handles, from a snapshot of vendor pages and GitHub taken on 13 November 2026, so every number below has a date on it.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;One limit every tool on this list shares:&lt;/strong&gt; Ghidra, IDA, Binary Ninja, Rizin and Hopper all open a VM-protected function as the protector's interpreter, not the code it replaced. Devirt recovers those functions for files you own or are authorized to analyze, and returns them as an IDA database, annotated pseudocode or LLVM IR, with a ledger that says which functions were proven. Here's how to &lt;a href="https://devirt.re/blog/evaluate-a-devirtualization-result-before-paying?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ida-pro-alternative" rel="noopener noreferrer"&gt;evaluate a devirtualization result&lt;/a&gt; before you pay for one.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  How this comparison was built
&lt;/h2&gt;

&lt;p&gt;The numbers come from a script run on 13 November 2026. It read the GitHub REST API for 12 open-source repositories (license, stars, latest release), saved and parsed the Binary Ninja purchase page and Hopper's store and FAQ, and reused a same-day read of Hex-Rays' pricing page and Ghidra's GitHub release data. Prices are copied in the currency each vendor lists. They aren't converted, because IDA is sold per year in euros and the others are one-time licenses in US dollars, so a single "cheapest" number would mislead. Vendor prices change; treat every price here as "as listed on that date".&lt;/p&gt;

&lt;h2&gt;
  
  
  Why look for an IDA Pro alternative?
&lt;/h2&gt;

&lt;p&gt;IDA Pro's price comes from two choices Hex-Rays makes: it sells IDA as a yearly license, and it sells decompilers by architecture. On 13 November 2026, &lt;a href="https://hex-rays.com/pricing" rel="noopener noreferrer"&gt;Hex-Rays' pricing page&lt;/a&gt; listed IDA Pro Essential at €1,099 a year with two cloud decompilers for one architecture family, and IDA Pro Expert from €4,999 a year with two, four or six local decompilers. Only IDA Pro Ultimate, at €8,599 a year, included all 15 local decompilers. Yearly add-ons such as Teams (€999) and Floating licenses (€1,700) cost extra.&lt;/p&gt;

&lt;p&gt;Price is the obvious reason to look elsewhere, and two of the four questions Google showed for this search in late October 2026 were about cost. The other reasons are narrower: needing a native macOS tool, wanting to read or change the source of your disassembler, or wanting a decompiler for an architecture your IDA tier doesn't include.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fd7icj5oic8jwp8n9worj.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fd7icj5oic8jwp8n9worj.png" alt="ida alternatives price chart" width="800" height="643"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  IDA Pro alternatives at a glance
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;What it is&lt;/th&gt;
&lt;th&gt;License&lt;/th&gt;
&lt;th&gt;Price as listed, 13 Nov 2026&lt;/th&gt;
&lt;th&gt;Decompiler&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;IDA Pro (reference)&lt;/td&gt;
&lt;td&gt;Disassembler, decompiler, debugger&lt;/td&gt;
&lt;td&gt;Commercial, yearly&lt;/td&gt;
&lt;td&gt;€1,099 to €8,599 a year (IDA Home €365, non-commercial)&lt;/td&gt;
&lt;td&gt;2 cloud (Essential) to 15 local (Ultimate) architectures&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Ghidra&lt;/td&gt;
&lt;td&gt;Disassembler, decompiler, debugger&lt;/td&gt;
&lt;td&gt;Apache 2.0&lt;/td&gt;
&lt;td&gt;Free&lt;/td&gt;
&lt;td&gt;Built in, driven by SLEIGH processor specs (61 processor names)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Binary Ninja&lt;/td&gt;
&lt;td&gt;Disassembler, decompiler, debugger&lt;/td&gt;
&lt;td&gt;Commercial, perpetual with 1 year of updates&lt;/td&gt;
&lt;td&gt;Free edition; $199 non-commercial; $1,799 commercial; $3,499 Ultimate&lt;/td&gt;
&lt;td&gt;5 (Free), 12+ (Non-Commercial, Commercial), 19+ (Ultimate) architectures&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Rizin + Cutter&lt;/td&gt;
&lt;td&gt;Framework + GUI&lt;/td&gt;
&lt;td&gt;LGPL-3.0 / GPL-3.0&lt;/td&gt;
&lt;td&gt;Free&lt;/td&gt;
&lt;td&gt;Ghidra's decompiler via the rz-ghidra plugin&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;radare2&lt;/td&gt;
&lt;td&gt;Command-line framework&lt;/td&gt;
&lt;td&gt;LGPLv3 (plugins vary)&lt;/td&gt;
&lt;td&gt;Free&lt;/td&gt;
&lt;td&gt;r2ghidra and r2dec plugins&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Hopper&lt;/td&gt;
&lt;td&gt;Disassembler, decompiler, debugger (macOS, Linux)&lt;/td&gt;
&lt;td&gt;Commercial, perpetual with 1 year of updates&lt;/td&gt;
&lt;td&gt;$99 personal; $129 per computer&lt;/td&gt;
&lt;td&gt;Built in; disassembles Intel 32/64-bit, ARM, PowerPC&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;x64dbg&lt;/td&gt;
&lt;td&gt;Windows user-mode debugger&lt;/td&gt;
&lt;td&gt;GPLv3 (modified license text)&lt;/td&gt;
&lt;td&gt;Free&lt;/td&gt;
&lt;td&gt;None in the current source (Snowman removed)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Sources: hex-rays.com/pricing, binary.ninja/purchase, Hopper's FastSpring store (US) and FAQ, and each project's GitHub repository, all read on 13 November 2026.&lt;/p&gt;

&lt;h2&gt;
  
  
  Ghidra: the free default
&lt;/h2&gt;

&lt;p&gt;Ghidra is a free reverse engineering suite from the NSA, open source under the Apache 2.0 license since 2019. It includes a disassembler, a decompiler, scripting in Java and Python, and, since Ghidra 10.0 in June 2021, a debugger. Its &lt;a href="https://github.com/NationalSecurityAgency/ghidra" rel="noopener noreferrer"&gt;GitHub repository&lt;/a&gt; had 99,858 stars and 419 contributors on 13 November 2026.&lt;/p&gt;

&lt;p&gt;Ghidra's decompiler works from the same SLEIGH processor specifications as its disassembler. The release tagged on 22 October 2026 ships specs for 61 processor names, from x86, ARM, AARCH64 and MIPS to Dalvik, eBPF and a long tail of microcontrollers. That breadth is Ghidra's strongest argument against paying per architecture. Stable releases arrived at a median of 35 days apart between June 2021 and November 2026.&lt;/p&gt;

&lt;p&gt;Is Ghidra as good as IDA Pro? For a lot of native work the question comes down to price and workflow rather than whether the tool can do the job. The practical differences are setup and habit: Ghidra needs a supported Java JDK, and years of IDA tutorials and scripts don't carry over as they are.&lt;/p&gt;

&lt;h2&gt;
  
  
  Binary Ninja: a paid alternative you own outright
&lt;/h2&gt;

&lt;p&gt;Binary Ninja is a commercial disassembler and decompiler from Vector 35, sold as a perpetual license with one year of updates. On 13 November 2026 the &lt;a href="https://binary.ninja/purchase/" rel="noopener noreferrer"&gt;purchase page&lt;/a&gt; listed four editions:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Free&lt;/strong&gt;, "for evaluation and education", with 5 decompilation architectures. Plugins don't run in the Free edition.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Non-Commercial&lt;/strong&gt; at $199 ($49 with the student discount), 12+ architectures, plugins through the GUI.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Commercial&lt;/strong&gt; at $1,799, 12+ architectures, plus headless processing (running plugins without the GUI).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ultimate&lt;/strong&gt; at $3,499 ($5,499 floating), 19+ architectures, plus binary similarity and Ghidra export. Collaboration features such as single sign-on need a separate add-on.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Binary Ninja exposes its intermediate languages (BNIL) through a Python API, so scripted analysis is a first-class use rather than an add-on. Every edition, Free included, can import from Ghidra and IDB files, which helps if your team uses more than one tool.&lt;/p&gt;

&lt;h3&gt;
  
  
  Which is better, Binary Ninja or IDA Pro?
&lt;/h3&gt;

&lt;p&gt;Binary Ninja and IDA Pro differ mainly in licensing and decompiler packaging. Binary Ninja's Ultimate edition listed 19+ decompilation architectures as a one-time purchase with a year of updates on 13 November 2026, while IDA Pro Ultimate includes 15 local decompilers on a yearly license. Binary Ninja's license is perpetual, so the version you bought keeps working after the update year; IDA Pro is priced per year.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rizin, Cutter and radare2: the open-source frameworks
&lt;/h2&gt;

&lt;p&gt;Rizin is a reverse engineering framework that, in its own README's words, was "born as a fork of the radare2". Cutter is the free, open-source GUI "powered by rizin", and the &lt;a href="https://github.com/rizinorg/rz-ghidra" rel="noopener noreferrer"&gt;rz-ghidra plugin&lt;/a&gt; gives it Ghidra's decompiler natively. Rizin is LGPL-3.0, Cutter is GPL-3.0, and both had releases at the end of June 2026. Cutter ships builds for Linux, macOS and Windows.&lt;/p&gt;

&lt;p&gt;radare2 is the original command-line framework, distributed under LGPLv3 (individual plugins can carry other licenses). Its decompilers are plugins too: r2ghidra (the &lt;code&gt;pdg&lt;/code&gt; command) wraps Ghidra's decompiler, r2dec (&lt;code&gt;pdd&lt;/code&gt;) is written in JavaScript, and decai is an AI-based decompiler. radare2's latest release was on 5 November 2026.&lt;/p&gt;

&lt;p&gt;Pick radare2 if you live in a terminal and script everything. Pick Cutter if you want the same lineage with a graphical interface.&lt;/p&gt;

&lt;h2&gt;
  
  
  Hopper: native on macOS
&lt;/h2&gt;

&lt;p&gt;Hopper is a commercial disassembler, decompiler and debugger built as a native macOS app, with a Linux version for Ubuntu, Fedora and Arch. It decodes Swift names and Objective-C selectors, debugs through LLDB or GDB, and now ships a local MCP server. According to its &lt;a href="https://www.hopperapp.com/faq.html" rel="noopener noreferrer"&gt;FAQ&lt;/a&gt;, Hopper disassembles Intel (32 and 64-bit), ARM (ARMv6, ARMv7, ARM64) and PowerPC binaries, and other processors can be added through its SDK.&lt;/p&gt;

&lt;p&gt;On 13 November 2026, Hopper's US store listed a Personal License at $99 and a Computer License at $129, each with one year of updates. The FAQ says the license never expires after the update year ends, and there are no restrictions on commercial use. The free demo limits sessions to 30 minutes and disables saving and the debugger.&lt;/p&gt;

&lt;h2&gt;
  
  
  x64dbg for dynamic work
&lt;/h2&gt;

&lt;p&gt;x64dbg is an open-source user-mode debugger for Windows programs, aimed at malware analysis and reverse engineering. It's not a decompiler: x64dbg.com still lists the Snowman decompiler among its libraries, but the current source marks the Snowman tab as removed. So it doesn't replace IDA's static view. It replaces IDA's debugger for Windows targets. The download includes x32dbg for 32-bit programs and x64dbg for 64-bit ones, and its license file is the GPLv3 text marked as modified.&lt;/p&gt;

&lt;p&gt;A common pairing is x64dbg with Ghidra or Cutter: read the code statically, then set breakpoints in x64dbg to confirm what a function does at runtime. On Linux, GDB fills the same role, and Ghidra, Binary Ninja and Hopper all have debuggers of their own.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwdytg2y9cwq6qch0jr3b.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fwdytg2y9cwq6qch0jr3b.png" alt="ida alternatives tool roles" width="800" height="438"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Specialist and research tools
&lt;/h2&gt;

&lt;p&gt;Some targets don't need a native disassembler at all. If the file is an Android APK, &lt;a href="https://github.com/skylot/jadx" rel="noopener noreferrer"&gt;JADX&lt;/a&gt; (Apache 2.0) decompiles Dalvik bytecode to Java. If it's a .NET assembly, ILSpy (MIT) and dnSpyEx (GPL-3.0) decompile it to C#. All three are free, and they read the bytecode directly instead of making you work through native code.&lt;/p&gt;

&lt;p&gt;For research and automation, angr (BSD-2-Clause) is a Python binary analysis framework with symbolic execution and a decompiler, and angr-management is its GUI. RetDec, the LLVM-based decompiler Avast released as open source, still works, but its README says the project is in "limited maintenance mode" and its last release was on 8 December 2022.&lt;/p&gt;

&lt;p&gt;The GIF below plots the latest GitHub release of each open-source tool in the snapshot, with dot size following stars. Of the 12 tools that publish GitHub releases, 11 shipped one between 13 May and 13 November 2026. RetDec is the exception.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz4tv2tay1o4zcgjnv1xz.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fz4tv2tay1o4zcgjnv1xz.gif" alt="ida alternatives release timeline" width="800" height="520"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What are the best Ghidra alternatives?
&lt;/h2&gt;

&lt;p&gt;The best Ghidra alternatives are IDA Pro and Binary Ninja if you can pay, Rizin with Cutter or radare2 if you want to stay open source, and Hopper on macOS. The two open-source frameworks can even run Ghidra's own decompiler, through the rz-ghidra and r2ghidra plugins, so moving to them doesn't mean giving up its output. Rizin, Cutter, radare2 and both decompiler plugins each shipped a release between 21 June and 5 November 2026, according to GitHub on 13 November 2026.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is there a free version of IDA Pro?
&lt;/h2&gt;

&lt;p&gt;IDA Free is the free version of IDA Pro, licensed by Hex-Rays for non-commercial use. On 13 November 2026 its decompiler covered two architectures, x86 and x86-64, and ran in the cloud rather than on your machine. IDA Home (€365 a year) raises that to 11 cloud decompilers, still for non-commercial use. Hex-Rays also offers IDA Classroom Free to education providers. Any commercial use needs one of the IDA Pro editions.&lt;/p&gt;

&lt;p&gt;If you're starting out, Ghidra is the stronger free starting point: it has no non-commercial restriction, and its decompiler isn't limited to x86 and x86-64. A first session with Ghidra, x64dbg and a triage tool on a program you compiled yourself is the subject of a separate post on &lt;a href="https://dev.to/devirt/reverse-engineering-tools-a-free-starter-kit-for-your-first-binary-1oh9"&gt;free reverse engineering tools&lt;/a&gt;, and a longer list of &lt;a href="https://devirt.re/blog/reverse-engineering-tools?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ida-pro-alternative" rel="noopener noreferrer"&gt;reverse engineering tools&lt;/a&gt; sorts them by the job each one does.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why can't any of these tools read VM-protected functions?
&lt;/h2&gt;

&lt;p&gt;A VM-protected function is code that a protector such as VMProtect or Themida has translated into bytecode for a virtual machine the protector embeds in the program. The original instructions are no longer in the file. Ghidra, IDA Pro, Binary Ninja, Rizin and Hopper disassemble what is there: the virtual machine's dispatcher loop and its handlers, which look much the same whatever the function did.&lt;/p&gt;

&lt;p&gt;Switching tools doesn't change that, because the problem isn't the decompiler's quality. Each protected build can use a different instruction set, so the handlers have to be worked out before the bytecode means anything. Turning that bytecode back into a readable function is a separate step called devirtualization, and it produces new output that should say which functions were recovered and checked.&lt;/p&gt;

&lt;p&gt;The same limit applies to AI assistants wired into these tools. A &lt;a href="https://devirt.re/blog/reverse-engineering-mcp-obfuscated-binaries?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ida-pro-alternative" rel="noopener noreferrer"&gt;Ghidra MCP or IDA MCP&lt;/a&gt; server gives a model the same interpreter loop the human sees.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which IDA Pro alternative should you use?
&lt;/h2&gt;

&lt;p&gt;The right IDA Pro alternative depends on the job and the budget. Based on the snapshot:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;No budget, native code:&lt;/strong&gt; Ghidra, plus x64dbg on Windows or GDB on Linux.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Terminal and scripting first:&lt;/strong&gt; radare2, or Rizin if you also want Cutter's GUI.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Paid, and you want to own the license:&lt;/strong&gt; Binary Ninja, Non-Commercial for personal work, Commercial or Ultimate for a team.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;macOS and iOS targets:&lt;/strong&gt; Hopper.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Android or .NET:&lt;/strong&gt; JADX, ILSpy or dnSpyEx before any native disassembler.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Staying in the IDA workflow on a budget:&lt;/strong&gt; IDA Free for non-commercial x86 and x64, or IDA Home.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Whichever you pick, check the vendor's page on the day you buy, because the prices in this post are from one date. And if triage shows a VM protector, expect every tool on this list to show you the interpreter until the functions are devirtualized.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Written by Devirt, an automated devirtualization service for authorized analysis of protected software. Data and the script behind it: snapshot of 13 November 2026.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>reverseengineering</category>
      <category>security</category>
      <category>opensource</category>
      <category>tooling</category>
    </item>
    <item>
      <title>Ghidra MCP Servers on GitHub: We Counted 138 of Them</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Fri, 13 Nov 2026 09:39:21 +0000</pubDate>
      <link>https://dev.to/devirt/ghidra-mcp-servers-on-github-we-counted-138-of-them-1og6</link>
      <guid>https://dev.to/devirt/ghidra-mcp-servers-on-github-we-counted-138-of-them-1og6</guid>
      <description>&lt;p&gt;Ghidra has no official MCP server, but on 13 November 2026 we counted 138 public community Ghidra MCP servers on GitHub, and 113 of them were created this year. A Ghidra MCP server is a Model Context Protocol server that exposes Ghidra's decompiler and program database as tools an AI agent can call: decompile a function, list cross-references, rename a variable. We ran a census of every public one we could find, with stars, last commit, tool count and transport, because the search results for "ghidra mcp" quote one project at 110, 179, 200+ and 219 tools, and none of the ranking pages says how many servers exist.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Your Ghidra MCP server has a read-only neighbour:&lt;/strong&gt; Devirt's MCP connector registers in the same client as GhidraMCP or any server in this census. Its six tools read the status, coverage ledger and proof summary of devirtualization work you have already submitted and approved, and none of them can upload a file, start a job or pay. That is how &lt;a href="https://devirt.re/ai-reverse-engineering?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ghidra-mcp" rel="noopener noreferrer"&gt;AI reverse engineering&lt;/a&gt; on protected binaries stays under your control.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  Is there an official Ghidra MCP server?
&lt;/h2&gt;

&lt;p&gt;No. The NSA's Ghidra repository ships no MCP server. The seven issues and pull requests with "MCP" in the title that asked for one, the newest from July 2026, are all closed, and neither pull request was merged. Every Ghidra MCP server is a community project, and the most starred is LaurieWired's &lt;a href="https://github.com/LaurieWired/GhidraMCP" rel="noopener noreferrer"&gt;GhidraMCP&lt;/a&gt;, first released in March 2025: a Ghidra plugin plus a small Python bridge that an MCP client such as Claude Code or VS Code talks to.&lt;/p&gt;

&lt;p&gt;The devirt.re guide to &lt;a href="https://devirt.re/blog/reverse-engineering-mcp-obfuscated-binaries?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ghidra-mcp" rel="noopener noreferrer"&gt;ghidra mcp&lt;/a&gt; servers explains what the three best-known ones do and where they fit next to IDA and Binary Ninja servers. This post counts the rest.&lt;/p&gt;

&lt;h2&gt;
  
  
  How the census was run
&lt;/h2&gt;

&lt;p&gt;The census used the GitHub REST API on 13 November 2026. The method, so you can check it or rerun it:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Search:&lt;/strong&gt; six repository searches (&lt;code&gt;ghidra mcp&lt;/code&gt;, &lt;code&gt;ghidra-mcp&lt;/code&gt;, &lt;code&gt;ghidramcp&lt;/code&gt;, &lt;code&gt;pyghidra mcp&lt;/code&gt;, &lt;code&gt;topic:ghidra topic:mcp&lt;/code&gt;, &lt;code&gt;ghidra model context protocol&lt;/code&gt;). GitHub returned complete results for all six. They gave 338 unique repositories; GitHub search leaves forks out by default.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Implementation check:&lt;/strong&gt; a script read each repository's source at the head of its default branch and kept the 215 that contain an MCP implementation (an MCP SDK import, a tool registration or a &lt;code&gt;tools/list&lt;/code&gt; handler).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Name test:&lt;/strong&gt; 148 of those tie "Ghidra" to "MCP" in their name or description.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hand review:&lt;/strong&gt; we read the descriptions of all 148, and the README where a description was unclear. We removed 10 that aren't Ghidra MCP servers (a Blender SDK, a statistics tool, a Cutter fork) and 7 self-declared mirrors, snapshots or bundles.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Recall check:&lt;/strong&gt; we also went through the 190 repositories the rules rejected and added back 7 Ghidra MCP servers they missed, such as a server written in Zig and one whose description never says "MCP". Multi-engine reverse-engineering servers that mention Ghidra only in their README stay out.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Result:&lt;/strong&gt; 138 Ghidra MCP servers. 107 are dedicated servers; 31 are wider toolkits that include one.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Stars come from the search API. "Last commit" is the newest commit on the default branch, not GitHub's &lt;code&gt;pushed_at&lt;/code&gt;, which moves when any branch changes. Tool counts and transports have their own caveats, covered in their sections. Nothing was cloned, installed or run. The first step anyone can repeat:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gh api -X GET search/repositories -f &lt;span class="nv"&gt;q&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;&lt;span class="s2"&gt;"ghidra mcp"&lt;/span&gt; -f &lt;span class="nv"&gt;per_page&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;100 \
  --jq &lt;span class="s1"&gt;'.total_count, (.items[] | "\(.stargazers_count)\t\(.full_name)")'&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h2&gt;
  
  
  How many Ghidra MCP servers are there?
&lt;/h2&gt;

&lt;p&gt;The census counted 138 public Ghidra MCP servers on GitHub on 13 November 2026, and the count is climbing fast. 24 were created in 2025, 113 in 2026, and 28 in October 2026 alone, the busiest month so far. One server, cyberkaida's ReVa, is older: its repository dates from August 2023 and gained an MCP server later.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyk541wimx1wcwh9vc85k.gif" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fyk541wimx1wcwh9vc85k.gif" alt="ghidra mcp servers by month" width="800" height="451"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Activity is uneven. 46 of the 138 Ghidra MCP servers had a commit in the 30 days before the census, and 85 in the last 90 days, but 37 had nothing for more than 180 days. One is archived, and 35 have no licence file GitHub can detect, which matters if you plan to build on one.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who holds the stars
&lt;/h2&gt;

&lt;p&gt;GitHub stars on Ghidra MCP servers are concentrated in very few projects. LaurieWired's GhidraMCP holds 11,911 of the 23,376 stars across all 138 servers, 51% on its own. The three most-starred repositories hold 83%, the top ten hold 97%, and 71 servers have no stars at all.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgaermqf85udaxb01qfyx.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fgaermqf85udaxb01qfyx.png" alt="ghidra mcp stars top10" width="799" height="606"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;These are the ten most-starred dedicated Ghidra MCP servers. Three wider toolkits outrank some of them on stars (open-reverselab, a batch-rename tool built on GhidraMCP, and RE-MCP, which drives IDA Pro as well), so they appear in the chart above but not in this table:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Server&lt;/th&gt;
&lt;th&gt;Stars&lt;/th&gt;
&lt;th&gt;Last commit&lt;/th&gt;
&lt;th&gt;Tools&lt;/th&gt;
&lt;th&gt;Transport in README&lt;/th&gt;
&lt;th&gt;Runs as&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;LaurieWired/GhidraMCP&lt;/td&gt;
&lt;td&gt;11,911&lt;/td&gt;
&lt;td&gt;10 Oct 2026&lt;/td&gt;
&lt;td&gt;30 (counted)&lt;/td&gt;
&lt;td&gt;stdio, streamable HTTP&lt;/td&gt;
&lt;td&gt;Ghidra plugin + Python bridge, headless option&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;bethington/ghidra-mcp&lt;/td&gt;
&lt;td&gt;6,211&lt;/td&gt;
&lt;td&gt;8 Nov 2026&lt;/td&gt;
&lt;td&gt;219 (README)&lt;/td&gt;
&lt;td&gt;stdio, SSE, streamable HTTP&lt;/td&gt;
&lt;td&gt;plugin, headless server, Docker&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;cyberkaida/reverse-engineering-assistant&lt;/td&gt;
&lt;td&gt;958&lt;/td&gt;
&lt;td&gt;3 Nov 2026&lt;/td&gt;
&lt;td&gt;83 (counted)&lt;/td&gt;
&lt;td&gt;streamable HTTP&lt;/td&gt;
&lt;td&gt;Ghidra extension&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;symgraph/GhidrAssistMCP&lt;/td&gt;
&lt;td&gt;810&lt;/td&gt;
&lt;td&gt;9 Oct 2026&lt;/td&gt;
&lt;td&gt;100 (README)&lt;/td&gt;
&lt;td&gt;SSE, streamable HTTP&lt;/td&gt;
&lt;td&gt;Ghidra extension&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;clearbluejar/pyghidra-mcp&lt;/td&gt;
&lt;td&gt;465&lt;/td&gt;
&lt;td&gt;6 Nov 2026&lt;/td&gt;
&lt;td&gt;25 (counted)&lt;/td&gt;
&lt;td&gt;stdio, SSE, streamable HTTP&lt;/td&gt;
&lt;td&gt;headless, or with a shared GUI&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;mrphrazer/ghidra-headless-mcp&lt;/td&gt;
&lt;td&gt;198&lt;/td&gt;
&lt;td&gt;16 Sep 2026&lt;/td&gt;
&lt;td&gt;212 (README)&lt;/td&gt;
&lt;td&gt;stdio&lt;/td&gt;
&lt;td&gt;headless&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;13bm/GhidraMCP&lt;/td&gt;
&lt;td&gt;150&lt;/td&gt;
&lt;td&gt;6 Sep 2026&lt;/td&gt;
&lt;td&gt;70 (README)&lt;/td&gt;
&lt;td&gt;stdio&lt;/td&gt;
&lt;td&gt;Ghidra extension&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;themixednuts/GhidraMCP&lt;/td&gt;
&lt;td&gt;93&lt;/td&gt;
&lt;td&gt;23 Sep 2026&lt;/td&gt;
&lt;td&gt;14 (README)&lt;/td&gt;
&lt;td&gt;not stated&lt;/td&gt;
&lt;td&gt;Ghidra extension&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;elliottophellia/Ryuumonbuchi&lt;/td&gt;
&lt;td&gt;80&lt;/td&gt;
&lt;td&gt;28 Aug 2026&lt;/td&gt;
&lt;td&gt;212 to 217 (README states both)&lt;/td&gt;
&lt;td&gt;stdio, streamable HTTP&lt;/td&gt;
&lt;td&gt;headless&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;ghidra-user-jp/mecha_ghidra&lt;/td&gt;
&lt;td&gt;68&lt;/td&gt;
&lt;td&gt;26 Oct 2026&lt;/td&gt;
&lt;td&gt;not stated&lt;/td&gt;
&lt;td&gt;stdio&lt;/td&gt;
&lt;td&gt;headless&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The repositories are &lt;a href="https://github.com/bethington/ghidra-mcp" rel="noopener noreferrer"&gt;bethington/ghidra-mcp&lt;/a&gt;, &lt;a href="https://github.com/cyberkaida/reverse-engineering-assistant" rel="noopener noreferrer"&gt;ReVa&lt;/a&gt;, &lt;a href="https://github.com/symgraph/GhidrAssistMCP" rel="noopener noreferrer"&gt;GhidrAssistMCP&lt;/a&gt; and &lt;a href="https://github.com/clearbluejar/pyghidra-mcp" rel="noopener noreferrer"&gt;pyghidra-mcp&lt;/a&gt; for the four you'll meet most after LaurieWired's. Popularity and maintenance don't line up neatly. bethington's server, second on stars, had the most recent commit of the ten, while LaurieWired's had gone more than a month without one.&lt;/p&gt;

&lt;h2&gt;
  
  
  How many tools does a Ghidra MCP server expose?
&lt;/h2&gt;

&lt;p&gt;A Ghidra MCP server exposes anywhere from a handful of tools to more than 200, so a tool count says more about a project's scope than its quality. bethington's README lists 219 MCP tools, GhidrAssistMCP lists 100 (93 enabled by default), and LaurieWired's GhidraMCP registers 30 in its current code.&lt;/p&gt;

&lt;p&gt;The census found a cluster: 11 Ghidra MCP servers register exactly 27 tools. That's the number in LaurieWired's bridge script from its 1.3 release in April 2025 until the 2.0 release on 10 October 2026, which suggests a good share of the "new" servers started from that code without forking it on GitHub.&lt;/p&gt;

&lt;p&gt;Two caveats on the "counted" figures. The script counts tool registrations it can recognise in source (decorators such as &lt;code&gt;@mcp.tool&lt;/code&gt;, Java tool annotations, SDK tool objects), so servers that build their tool list at runtime show low or zero. That's why the table uses the README figure where a project states one. And a large toolset has a cost of its own: every tool definition takes up room in the agent's context, which is why bethington's server lazy-loads tools and mecha_ghidra exposes only what a task needs.&lt;/p&gt;

&lt;h2&gt;
  
  
  stdio, SSE or streamable HTTP: how the servers connect
&lt;/h2&gt;

&lt;p&gt;Most Ghidra MCP servers talk to the MCP client over stdio. Of the 135 census servers with a README, 79 document stdio, 35 document SSE and 31 document streamable HTTP. 36 name no transport at all, so you find out from the code or the client config.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn1ajond1zde54406cdal.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fn1ajond1zde54406cdal.png" alt="ghidra mcp connection modes" width="800" height="486"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The other split is where the server runs. 47 of the 138 ship a Ghidra extension that runs inside the Ghidra GUI. 90 reference a headless path (pyghidra or Ghidra's headless analyzer) in their code or README; a headless server lets the agent work without anyone opening Ghidra. Headless suits batch work across many binaries; the GUI plugin suits sitting next to the agent and watching what it renames.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you pick a Ghidra MCP server?
&lt;/h2&gt;

&lt;p&gt;Pick a Ghidra MCP server by maintenance and fit before tool count. With 37 of the 138 untouched for six months, the first filter does most of the work:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Recent commits:&lt;/strong&gt; a commit on the default branch in the last month, and issues that get answers.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A transport your client supports:&lt;/strong&gt; stdio for local desktop clients, streamable HTTP if the server runs on another machine or in Docker.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;GUI or headless:&lt;/strong&gt; a plugin if you want to watch the session in Ghidra, headless for scripted runs over many files.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write tools you can review:&lt;/strong&gt; many servers can rename, retype and comment. Snapshot the Ghidra project first and check the agent's changes the way you would a colleague's.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Then the tool list,&lt;/strong&gt; trimmed to what the job needs.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;If Ghidra itself is new to you, learn &lt;a href="https://devirt.substack.com/p/how-to-use-ghidra" rel="noopener noreferrer"&gt;how to use Ghidra&lt;/a&gt; before adding an agent on top. You need to recognise a wrong rename when you see one.&lt;/p&gt;

&lt;h2&gt;
  
  
  What no Ghidra MCP server changes
&lt;/h2&gt;

&lt;p&gt;Every Ghidra MCP server in the census reads what Ghidra's decompiler can read, no more. On a function protected by code virtualization, which developers apply to the functions they most want to protect, that's the protector's interpreter loop: a dispatcher, virtual registers and handlers. A 139th server would change the tool list, not what the agent sees. Agents stall at the same wall in &lt;a href="https://dev.to/devirt/ai-decompiler-workflows-for-agents-and-where-they-stall-4ha2"&gt;AI decompiler workflows&lt;/a&gt;, and for the same reason.&lt;/p&gt;

&lt;p&gt;Recovering that function is a devirtualization step, and its output should say which functions were proven, which depend on runtime data and which remain open. Devirt reports those &lt;a href="https://devirt.re/research/devirtualization/runtime-dependent-functions?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ghidra-mcp" rel="noopener noreferrer"&gt;proof states&lt;/a&gt; per function, and its read-only connector hands them back to the same agent. That's for binaries you own or are authorized to analyze.&lt;/p&gt;

&lt;p&gt;The census is a snapshot, and a field that added 28 servers in a month will look different by December. We'll rerun it and update the numbers with a new date.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Written by Devirt, an automated devirtualization service for authorized analysis of protected software. Census data: GitHub REST API, 13 November 2026.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>security</category>
      <category>reverseengineering</category>
      <category>mcp</category>
    </item>
    <item>
      <title>Reverse Engineering Tools: A Free Starter Kit for Your First Binary</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Wed, 11 Nov 2026 05:28:28 +0000</pubDate>
      <link>https://dev.to/devirt/reverse-engineering-tools-a-free-starter-kit-for-your-first-binary-1oh9</link>
      <guid>https://dev.to/devirt/reverse-engineering-tools-a-free-starter-kit-for-your-first-binary-1oh9</guid>
      <description>&lt;p&gt;Reverse engineering tools are the programs that let you read software without its source code: a disassembler and decompiler to turn machine code into something readable, a debugger to watch it run, and a couple of small utilities to tell you what kind of file you're holding. In November 2026 you can build a capable starter kit from four free tools, and this post sets them up and walks through a first session on a program you compile yourself.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Where Devirt fits in this kit:&lt;/strong&gt; the free tools below take you a long way. They stop when a function has been virtualized by a protector like VMProtect or Themida. That is the part Devirt recovers, as an IDA database with a ledger of which functions were proven. You can &lt;a href="https://devirt.re/?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;start with a free assessment&lt;/a&gt; on a file you own or are authorized to analyze.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Practicing on your own build matters for two reasons. You know what the answer should be, so you can check every guess the tools make. And you're not taking apart someone else's software, which keeps the legal question simple.&lt;/p&gt;

&lt;h2&gt;
  
  
  What tools do you need to start reverse engineering?
&lt;/h2&gt;

&lt;p&gt;The reverse engineering tools you need to start are four free programs: a disassembler and decompiler (Ghidra), a debugger (x64dbg on Windows), a file triage tool (Detect It Easy) and a hex editor (such as ImHex). With those four installed, a beginner can take apart a small program they compiled themselves, without paying for a license.&lt;/p&gt;

&lt;p&gt;IDA Pro and Binary Ninja are commercial and very good, and both have free editions for non-commercial use. You don't need either for a first binary. A longer list of &lt;a href="https://devirt.re/blog/reverse-engineering-tools?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;reverse engineering tools&lt;/a&gt;, sorted by the job each one does, covers what to add later.&lt;/p&gt;

&lt;h2&gt;
  
  
  Install the starter kit
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Ghidra (disassembler and decompiler)
&lt;/h3&gt;

&lt;p&gt;Ghidra is free. The NSA released it as open source in 2019, and its source code is on &lt;a href="https://github.com/NationalSecurityAgency/ghidra" rel="noopener noreferrer"&gt;GitHub&lt;/a&gt; under the Apache 2.0 license. It disassembles and decompiles programs for many processor families, including x86, x64 and ARM. It runs on Java, so install a supported JDK first, then unzip the release and start it with the launcher script.&lt;/p&gt;

&lt;h3&gt;
  
  
  x64dbg (debugger)
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://x64dbg.com/" rel="noopener noreferrer"&gt;x64dbg&lt;/a&gt; is an open-source debugger for Windows programs. The download includes x32dbg for 32-bit programs and x64dbg for 64-bit ones, so open whichever matches your binary. On Linux, GDB fills the same role.&lt;/p&gt;

&lt;h3&gt;
  
  
  Detect It Easy (file triage)
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://github.com/horsicq/Detect-It-Easy" rel="noopener noreferrer"&gt;Detect It Easy&lt;/a&gt;, usually shortened to DIE, reads a file's headers and signatures and tells you what it is: the file format, the compiler that probably built it, and whether a packer or protector has been applied. It's the first thing to run on any binary you didn't build.&lt;/p&gt;

&lt;h3&gt;
  
  
  A hex editor
&lt;/h3&gt;

&lt;p&gt;A hex editor shows the raw bytes. &lt;a href="https://github.com/WerWolv/ImHex" rel="noopener noreferrer"&gt;ImHex&lt;/a&gt; is free and open source, and HxD is a popular free choice on Windows. You won't live in it. It's where you check what the other tools claim.&lt;/p&gt;

&lt;h2&gt;
  
  
  Build a practice binary you're allowed to take apart
&lt;/h2&gt;

&lt;p&gt;The best first target is a program you wrote, because you can check every conclusion against the source. Save this as &lt;code&gt;practice.c&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight c"&gt;&lt;code&gt;&lt;span class="cp"&gt;#include &amp;lt;stdio.h&amp;gt;&lt;/span&gt;
&lt;span class="cp"&gt;#include &amp;lt;string.h&amp;gt;&lt;/span&gt;

&lt;span class="kd"&gt;static&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;checksum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;sum&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;size_t&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nb"&gt;strlen&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;sum&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;sum&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt; &lt;span class="mi"&gt;31&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="n"&gt;s&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;i&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;sum&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="nf"&gt;main&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="n"&gt;argc&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt; &lt;span class="o"&gt;**&lt;/span&gt;&lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="kt"&gt;char&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;argc&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt; &lt;span class="o"&gt;?&lt;/span&gt; &lt;span class="n"&gt;argv&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"devirt"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="nb"&gt;printf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"checksum(%s) = %d\n"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nf"&gt;checksum&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;name&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Build it twice with GCC (on Windows, the MinGW-w64 toolchain): once with debug symbols and no optimization, once optimized and stripped, the way most shipped programs look.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;gcc -O0 -g -o practice.exe practice.c
gcc -O2 -s -o practice_stripped.exe practice.c
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Start with &lt;code&gt;practice.exe&lt;/code&gt;, then repeat everything below on &lt;code&gt;practice_stripped.exe&lt;/code&gt;. The difference between the two is most of what reverse engineering is about.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fa08zsqf0h063wfgfidsd.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fa08zsqf0h063wfgfidsd.png" alt="Illustration of the three passes in a first reverse engineering session: triage with Detect It Easy and a hex editor, static reading in Ghidra, dynamic checking in x64dbg, and a stop point when triage reports a VM protector." width="800" height="317"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Pass 1: triage
&lt;/h2&gt;

&lt;p&gt;Triage tells you what you're dealing with before you spend time on it. Open &lt;code&gt;practice_stripped.exe&lt;/code&gt; in Detect It Easy. It should report a PE64 file built by a GCC/MinGW toolchain, with no packer. That "no packer" line is the important one: if DIE reported a packer or a protector, everything you see in Ghidra later would be the wrapper, not the program. A guide to &lt;a href="https://devirt.re/blog/identify-packer-or-protector?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;Detect It Easy and PEiD results&lt;/a&gt; explains how to read that output.&lt;/p&gt;

&lt;p&gt;Then open the same file in the hex editor. The first two bytes are &lt;code&gt;MZ&lt;/code&gt;, and a little further in you'll find &lt;code&gt;PE&lt;/code&gt; followed by two zero bytes, the start of the PE header. Scroll down and the string &lt;code&gt;checksum(%s) = %d&lt;/code&gt; is sitting in plain sight. That's a quick sanity check that the file isn't encrypted.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pass 2: read it in Ghidra
&lt;/h2&gt;

&lt;p&gt;Ghidra turns the machine code into assembly and then into C-like pseudocode. Create a project, import &lt;code&gt;practice.exe&lt;/code&gt;, and accept the auto-analysis when Ghidra offers it.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;In the Symbol Tree, open Functions and select &lt;code&gt;main&lt;/code&gt;. The debug build keeps the name, so the Decompiler window shows something close to your source.&lt;/li&gt;
&lt;li&gt;Now import &lt;code&gt;practice_stripped.exe&lt;/code&gt;. There's no &lt;code&gt;main&lt;/code&gt; in the symbol list any more, only names like &lt;code&gt;FUN_140001500&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Open Window → Defined Strings, find &lt;code&gt;checksum(%s) = %d&lt;/code&gt;, and follow its cross-reference to the function that uses it. That's &lt;code&gt;main&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Press &lt;code&gt;L&lt;/code&gt; on the function and on its variables to rename them. At &lt;code&gt;-O2&lt;/code&gt;, GCC will most likely have inlined &lt;code&gt;checksum&lt;/code&gt; into &lt;code&gt;main&lt;/code&gt;, so look for a loop inside &lt;code&gt;main&lt;/code&gt; that walks the string and multiplies by 31 (Ghidra may show &lt;code&gt;* 0x1f&lt;/code&gt;, or a shift and a subtraction). That loop is &lt;code&gt;checksum&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That last step is the core skill, and it's why you build the stripped version too: the optimizer reshapes your code, and you learn to recognize it anyway. Ghidra hands you correct but anonymous code, and you supply the meaning. An &lt;a href="https://devirt.re/blog/ai-decompiler?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;AI decompiler&lt;/a&gt; can suggest names, but you still confirm them the way you just did.&lt;/p&gt;

&lt;h2&gt;
  
  
  Pass 3: watch it run in x64dbg
&lt;/h2&gt;

&lt;p&gt;x64dbg shows what the code does at runtime, which settles anything the static view left unclear. Open &lt;code&gt;practice_stripped.exe&lt;/code&gt;, then right-click in the CPU view and choose Search for → Current Module → String references. Double-click &lt;code&gt;checksum(%s) = %d&lt;/code&gt; to land in &lt;code&gt;main&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A few lines below the string reference is the call to &lt;code&gt;printf&lt;/code&gt;. Set a breakpoint on that call with F2 and run with F9 (x64dbg pauses at the program's entry point first, so you may need to press it again). Windows x64 code passes the first arguments in &lt;code&gt;RCX&lt;/code&gt;, &lt;code&gt;RDX&lt;/code&gt; and &lt;code&gt;R8&lt;/code&gt;, so when the breakpoint hits, &lt;code&gt;R8&lt;/code&gt; holds the checksum about to be printed. Step over the call with F8 and compare it with the console output. Then set an argument with File → Change Command Line, such as your own name, restart, and watch the value change. When the debugger, the decompiler and the source all agree, you've completed the loop that every bigger job repeats.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where do AI tools fit?
&lt;/h2&gt;

&lt;p&gt;AI tools fit on top of a reverse engineering toolchain, not in place of it. A language model can rename variables and explain decompiled code that Ghidra or IDA produced, but it reads the decompiler's output, so its answers are only as reliable as that output. Treat AI suggestions as hypotheses to check in the debugger, not as findings.&lt;/p&gt;

&lt;p&gt;The next step up is connecting an agent to your tools. A &lt;a href="https://devirt.re/blog/reverse-engineering-mcp-obfuscated-binaries?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;Ghidra MCP or IDA MCP&lt;/a&gt; server lets an assistant query the open project instead of pasted snippets. It's worth trying once you can check its answers yourself.&lt;/p&gt;

&lt;h2&gt;
  
  
  When does the starter kit stop working?
&lt;/h2&gt;

&lt;p&gt;The starter kit stops working on VM-protected code. Protectors such as VMProtect and Themida convert selected functions into bytecode for a private virtual machine, so Ghidra and x64dbg show the protector's interpreter loop instead of the original logic. Recovering those functions is a separate job called devirtualization.&lt;/p&gt;

&lt;p&gt;You'll usually spot it in triage, because DIE names the protector. In Ghidra it shows up as one large function full of jumps between short handlers, with your strings nowhere near the code that uses them. Packing is different: a packed file unpacks itself in memory, and a dump gets the original code back. The difference between &lt;a href="https://devirt.re/blog/devirtualization-vs-deobfuscation-vs-unpacking?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;unpacking and devirtualization&lt;/a&gt; decides which of those jobs you're facing. Lighter tricks such as renamed symbols and encoded strings fall under general &lt;a href="https://medium.com/@devirt/what-is-code-obfuscation-techniques-and-how-theyre-undone-376706fb1dfd" rel="noopener noreferrer"&gt;code obfuscation&lt;/a&gt;, and the starter kit still handles those.&lt;/p&gt;

&lt;p&gt;Before opening a file you didn't build, Devirt's &lt;a href="https://devirt.re/?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-tools" rel="noopener noreferrer"&gt;free browser check&lt;/a&gt; reads its file type and protection indicators on your own machine, without uploading it. When it reports a VM protector, you know the starter kit will show you the protector's interpreter, not the program.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is it legal to reverse engineer software?
&lt;/h2&gt;

&lt;p&gt;Reverse engineering software you wrote, or are authorized to analyze, is generally lawful. The legal limits usually come from license terms and copyright law: the EU Software Directive and the US DMCA, for example, both contain interoperability exceptions with conditions. This is general information, not legal advice. Practice on programs you compiled yourself, and keep anything you didn't write inside a virtual machine.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to keep practicing with reverse engineering tools
&lt;/h2&gt;

&lt;p&gt;Repeat the three passes on slightly bigger programs of your own: one that reads a file, one that opens a network socket, one built with a different compiler. Each new program teaches you a pattern you'll recognize in the next one. When a target turns out to be VM-protected and you're authorized to analyze it, that's the point where the free tools hand over to devirtualization.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Written by Devirt, an automated devirtualization service for authorized analysis of protected software.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>reverseengineering</category>
      <category>security</category>
      <category>beginners</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>JavaScript Deobfuscator Output: Reading It Layer by Layer</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Wed, 11 Nov 2026 05:27:42 +0000</pubDate>
      <link>https://dev.to/devirt/javascript-deobfuscator-output-reading-it-layer-by-layer-459m</link>
      <guid>https://dev.to/devirt/javascript-deobfuscator-output-reading-it-layer-by-layer-459m</guid>
      <description>&lt;p&gt;A JavaScript deobfuscator is a tool that rewrites obfuscated JavaScript into code a person can read: it decodes hidden strings, inlines helper functions, unwraps &lt;code&gt;eval&lt;/code&gt; layers and straightens out tangled control flow. Most obfuscated scripts that land on an analyst's desk in November 2026, a card skimmer on a checkout page or a dropper in a phishing attachment, are built from the same four layers. Knowing those layers is what lets you judge whether the tool's output is the real logic or a confident guess.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Where Devirt comes in:&lt;/strong&gt; most obfuscated JavaScript gives way to the tools below. When a script turns out to be its own interpreter, running custom bytecode, Devirt handles the &lt;a href="https://devirt.re/javascript-vm-deobfuscation?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=js-deobfuscator" rel="noopener noreferrer"&gt;JavaScript VM deobfuscation&lt;/a&gt; and reports which recovered functions were proven, for code you own or are authorized to analyze.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This post walks through the layers from the outside in, the way you meet them when you open a malicious script you've been asked to explain. It's written for defenders reading code found on their own or a client's systems.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does a JavaScript deobfuscator actually do?
&lt;/h2&gt;

&lt;p&gt;A JavaScript deobfuscator parses the script into a syntax tree (an AST), applies transformations that undo common obfuscation tricks, and prints the result as readable code. &lt;a href="https://github.com/HumanSecurity/restringer" rel="noopener noreferrer"&gt;REstringer&lt;/a&gt;, for example, is built on an AST library, and &lt;a href="https://github.com/relative/synchrony" rel="noopener noreferrer"&gt;synchrony&lt;/a&gt; runs AST visitors over the code. Working on the tree rather than on raw text is what lets a deobfuscator rename a variable everywhere it's used without breaking the script.&lt;/p&gt;

&lt;p&gt;They differ in which tricks they target. Some are tuned for output from javascript-obfuscator (the engine behind obfuscator.io), others handle older encoders such as Dean Edwards' packer or JSFuck, and picking between &lt;a href="https://devirt.re/blog/javascript-deobfuscators-compared?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=js-deobfuscator" rel="noopener noreferrer"&gt;JavaScript deobfuscators&lt;/a&gt; mostly comes down to which technique each one undoes. This post is about the next step: reading what they hand back.&lt;/p&gt;

&lt;p&gt;One distinction first, because it comes up constantly: minification is not obfuscation. Minification shortens code so it loads faster, and a beautifier undoes most of it. Obfuscation changes code on purpose to make it hard to understand, and the same ideas behind &lt;a href="https://medium.com/@devirt/what-is-code-obfuscation-techniques-and-how-theyre-undone-376706fb1dfd" rel="noopener noreferrer"&gt;code obfuscation&lt;/a&gt; in native programs (renaming, encoded strings, flattened control flow) show up in JavaScript as the layers below.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feectn6m2ld9e3evb7r9f.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feectn6m2ld9e3evb7r9f.png" alt="js obfuscation layers" width="800" height="385"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Layer 1: the wrapper (eval, packers and encoders)
&lt;/h2&gt;

&lt;p&gt;The outermost layer of obfuscated JavaScript is usually a wrapper that builds the real code as a string and hands it to &lt;code&gt;eval&lt;/code&gt; or the &lt;code&gt;Function&lt;/code&gt; constructor. Dean Edwards' packer, JSFuck, AAencode and JJencode all produce wrappers like this. The visible script is a decoder; the program you care about only exists after it runs.&lt;/p&gt;

&lt;p&gt;Reading tip: the giveaway is a script whose last action is executing a string it just assembled. A deobfuscator unwraps this layer by evaluating the decoder in a controlled way and printing the string instead of running it. de4js and js-beautify both handle the classic packers this way.&lt;/p&gt;

&lt;h2&gt;
  
  
  Layer 2: the string array
&lt;/h2&gt;

&lt;p&gt;Inside the wrapper, most modern obfuscated JavaScript moves every string literal into one large array, often shuffled, and replaces each use with a call to a small decoder function such as &lt;code&gt;_0x3f2a(0x1b)&lt;/code&gt;. Function names, URLs and DOM selectors all disappear from view, which is the point: the strings are what tell you what a skimmer is after.&lt;/p&gt;

&lt;p&gt;Reading tip: find the array, then the function that indexes into it, then the short loop near the top that rotates the array before first use. Tools tuned for javascript-obfuscator output resolve this automatically. synchrony's README describes its string decoder as working with no configuration, and REstringer is built around reconstructing these strings.&lt;/p&gt;

&lt;p&gt;When this layer resolves cleanly, the script usually becomes legible. The strings name the targets.&lt;/p&gt;

&lt;h2&gt;
  
  
  Layer 3: helper and proxy functions
&lt;/h2&gt;

&lt;p&gt;The third layer replaces simple operations with calls to tiny helper functions. &lt;code&gt;a + b&lt;/code&gt; becomes &lt;code&gt;_0x1c(a, b)&lt;/code&gt;, where &lt;code&gt;_0x1c&lt;/code&gt; returns its two arguments added together. Comparisons, property lookups and calls get the same treatment, scattered across objects with meaningless keys.&lt;/p&gt;

&lt;p&gt;Reading tip: a deobfuscator inlines these proxy functions, replacing each call with the operation it wraps, then folds constants such as &lt;code&gt;0x4 * 0x2 + -0x8&lt;/code&gt; down to a single value. If you're reading by hand, list each helper and what it returns before reading the main code. The main code reads very differently once you know &lt;code&gt;_0x1c&lt;/code&gt; means &lt;code&gt;+&lt;/code&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Layer 4: flattened control flow and dead code
&lt;/h2&gt;

&lt;p&gt;The innermost layer breaks the order of the code. Control-flow flattening takes a function's statements, puts them in the cases of a &lt;code&gt;switch&lt;/code&gt; inside an infinite loop, and drives the order with a counter or a string like &lt;code&gt;"3|1|4|0|2"&lt;/code&gt;. Dead-code injection adds branches that can never run, to waste your time.&lt;/p&gt;

&lt;p&gt;Reading tip: follow the dispatch string and read the cases in that order, not top to bottom. A good JavaScript deobfuscator rebuilds the straight-line order and removes branches whose conditions are always false. Be careful with that second part, which leads into the next two sections.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is it safe to run a JavaScript deobfuscator on malicious code?
&lt;/h2&gt;

&lt;p&gt;Running a JavaScript deobfuscator on malicious code is only safe when nothing in the sample can execute outside a sandbox. Several of the layers above come off by evaluating part of the script, and evaluation is what the script's author wants you to do.&lt;/p&gt;

&lt;p&gt;REstringer's README says its unsafe modules run inside &lt;a href="https://github.com/laverdet/isolated-vm" rel="noopener noreferrer"&gt;isolated-vm&lt;/a&gt;, and &lt;a href="https://github.com/j4k0xb/webcrack" rel="noopener noreferrer"&gt;webcrack&lt;/a&gt; also depends on isolated-vm. That limits the damage, but it isn't a reason to paste a skimmer into an online playground. Analysts still run unknown scripts in an isolated lab, with no access to production networks, cookies or credentials, and keep the sample out of shared folders afterwards.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you know the deobfuscated output is right?
&lt;/h2&gt;

&lt;p&gt;A JavaScript deobfuscator's output is trustworthy when it behaves the same as the original, and you can only claim that for what you checked. Three checks catch most errors:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Strings:&lt;/strong&gt; the decoded strings match what the original produces at runtime in your sandbox. A wrong rotation count gives plausible but wrong URLs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Behavior:&lt;/strong&gt; the cleaned script makes the same network requests and DOM changes as the original when run on the same page in the lab.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Removed branches:&lt;/strong&gt; anything the tool deleted as "dead" can't run. Some branches only fire on a date, a domain or a fetched value, and a tool can misjudge them.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Whatever you couldn't confirm, say so in the report. The labels Devirt uses for recovered code fit deobfuscated scripts too: proven, &lt;a href="https://devirt.re/research/devirtualization/runtime-dependent-functions?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=js-deobfuscator" rel="noopener noreferrer"&gt;runtime-dependent&lt;/a&gt; (depends on data your sandbox didn't have), or unresolved. "We didn't see it exfiltrate anything" and "it can't exfiltrate anything" are different findings.&lt;/p&gt;

&lt;h2&gt;
  
  
  When the code is an interpreter, not obfuscation
&lt;/h2&gt;

&lt;p&gt;Sometimes every layer comes off and the script still makes no sense. What's left is a loop that reads numbers out of a large array and calls one small function per number. That isn't obfuscated JavaScript any more. It's virtualized JavaScript: the protected functions were compiled into bytecode for an interpreter shipped inside the script.&lt;/p&gt;

&lt;p&gt;A JavaScript deobfuscator can tidy that interpreter, but it can't turn the bytecode back into the original functions, because the logic lives in the data, not in the code it rewrites. Some obfuscators also generate a new interpreter for every build, so the instruction set you work out for one sample doesn't carry over to the next. The difference between rewriting text and translating a virtual machine is the same one that separates &lt;a href="https://devirt.re/blog/devirtualization-vs-deobfuscation-vs-unpacking?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=js-deobfuscator" rel="noopener noreferrer"&gt;devirtualization from deobfuscation&lt;/a&gt; in native binaries.&lt;/p&gt;

&lt;p&gt;At that point the job is &lt;a href="https://devirt.re/javascript-vm-deobfuscation?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=js-deobfuscator" rel="noopener noreferrer"&gt;JavaScript VM deobfuscation&lt;/a&gt;: working out what each handler does, mapping the opcodes, and lifting the bytecode back into readable logic, with a record of which functions were actually recovered.&lt;/p&gt;

&lt;h2&gt;
  
  
  How to use a JavaScript deobfuscator, step by step
&lt;/h2&gt;

&lt;p&gt;Read obfuscated JavaScript from the outside in: unwrap, resolve strings, inline helpers, then reorder the flow. Let a deobfuscator do the mechanical work, then check its output against the original before you trust it. Stop when you hit an interpreter, because from there you're translating a virtual machine, not cleaning up code. If that happens on a script you're authorized to analyze, Devirt's free assessment tells you what can be recovered before anything is charged.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Written by Devirt, an automated devirtualization service for authorized analysis of protected software.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>javascript</category>
      <category>security</category>
      <category>reverseengineering</category>
      <category>webdev</category>
    </item>
    <item>
      <title>Software Reverse Engineering Services Compared: 4 Provider Types</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Tue, 10 Nov 2026 04:20:18 +0000</pubDate>
      <link>https://dev.to/devirt/software-reverse-engineering-services-compared-4-provider-types-48ab</link>
      <guid>https://dev.to/devirt/software-reverse-engineering-services-compared-4-provider-types-48ab</guid>
      <description>&lt;p&gt;There are four kinds of software reverse engineering service in 2026: specialist consultancies, R&amp;amp;D outsourcing firms, independent freelancers and automated services. Picking between them is mostly a scoping question. Can the job be defined before it starts, and how will you check the result when it arrives? This post compares the four by job type, then covers the one factor that changes the answer most: whether the binary is protected.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;About Devirt:&lt;/strong&gt; Devirt recovers the code that protectors such as VMProtect and Themida hide inside their own virtual machines, for files you own or are authorized to analyze. You get an IDA database and annotated pseudocode, with a ledger showing which functions were proven. If nothing is proven, you pay nothing. &lt;a href="https://devirt.re/?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-services" rel="noopener noreferrer"&gt;Start with a free assessment&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Disclosure:&lt;/strong&gt; written by Devirt, which runs an automated reverse engineering service for protected and ordinary binaries. The comparison describes provider &lt;em&gt;types&lt;/em&gt;, not named companies, and doesn't rank anyone.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  What a software reverse engineering service sells
&lt;/h2&gt;

&lt;p&gt;A software reverse engineering service sells recovered understanding of a compiled program: what it does, how its parts talk to each other, and how confident you can be in each conclusion. It doesn't sell source code. Identifiers, comments and project layout are gone after compilation, so the deliverable is some mix of:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;pseudocode for the functions in scope&lt;/li&gt;
&lt;li&gt;a disassembler database (an IDA &lt;code&gt;.i64&lt;/code&gt; or a Ghidra project) with the recovered functions in place&lt;/li&gt;
&lt;li&gt;a written report&lt;/li&gt;
&lt;li&gt;machine-readable output such as LLVM IR or JSON&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;What differs between provider types is how the scope gets set, which of these you get, and whether there's evidence attached.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which kind of software reverse engineering provider should you use?
&lt;/h2&gt;

&lt;p&gt;Pick by the job, not the provider. Scope-able, repeatable work suits a standardized service. Open-ended work suits people who can invent the method as they go.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Specialist consultancy&lt;/th&gt;
&lt;th&gt;R&amp;amp;D outsourcing firm&lt;/th&gt;
&lt;th&gt;Freelancer&lt;/th&gt;
&lt;th&gt;Automated service&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Best for&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Undocumented protocols, custom formats, one-off hard problems&lt;/td&gt;
&lt;td&gt;Recovery that feeds a rebuild or modernization&lt;/td&gt;
&lt;td&gt;Small, well-defined tasks&lt;/td&gt;
&lt;td&gt;Repeatable recovery, e.g. functions behind a known protector&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;How scope is set&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Discovery call, then a statement of work&lt;/td&gt;
&lt;td&gt;Project scoping, often milestone-based&lt;/td&gt;
&lt;td&gt;Task description&lt;/td&gt;
&lt;td&gt;Upload, assessment, written scope&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Typical deliverable&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Report plus working notes and databases&lt;/td&gt;
&lt;td&gt;Documentation plus new code&lt;/td&gt;
&lt;td&gt;Whatever was agreed, often notes or pseudocode&lt;/td&gt;
&lt;td&gt;Standard outputs: database, pseudocode, report, IR/JSON&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Turnaround depends on&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Analyst availability and how novel the problem is&lt;/td&gt;
&lt;td&gt;Team allocation and project size&lt;/td&gt;
&lt;td&gt;One person's calendar&lt;/td&gt;
&lt;td&gt;Queue and file size&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Confidentiality&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;NDA, analyst workstations&lt;/td&gt;
&lt;td&gt;NDA, team access controls&lt;/td&gt;
&lt;td&gt;NDA if you ask; varies&lt;/td&gt;
&lt;td&gt;Written processing and deletion policy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;How you check the result&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Ask for it explicitly&lt;/td&gt;
&lt;td&gt;Ask for it explicitly&lt;/td&gt;
&lt;td&gt;Usually on you&lt;/td&gt;
&lt;td&gt;Should be built into the output (ask)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Two things stand out in that last row. Only one model tends to build verification into the output by default, and for the other three you have to ask for it. Ask anyway, because it's the difference between a result you can audit and a result you have to trust.&lt;/p&gt;

&lt;h2&gt;
  
  
  Four example jobs, matched to a provider type
&lt;/h2&gt;

&lt;p&gt;Abstract tables only go so far. Here are four common software reverse engineering jobs and the provider type each one usually points to.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A legacy file format nobody documented.&lt;/strong&gt; Your company owns a 15-year-old desktop tool, the vendor is gone, and you need to read its project files in a new system. The job is open-ended: nobody knows yet how the format is structured or how many versions exist. That points to a specialist consultancy, or to an R&amp;amp;D outsourcing firm if the reader then has to be built and maintained.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A malware sample your team has to explain.&lt;/strong&gt; The question is narrow (what does this sample do, and what does it talk to?) and the deadline is usually short. If the sample is unprotected, an in-house analyst or a freelancer with malware experience may be enough. If key functions are virtualized, the bottleneck is devirtualization, which is where an automated service earns its place before the analyst takes over.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A protected DLL in software you license.&lt;/strong&gt; Your license allows analysis for interoperability, but the functions you care about sit behind a commercial protector. The scope is clear and the protector is known, so this is repeatable work. An automated service with support for that protector fits, as long as it reports which functions were proven and which weren't.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;An undocumented network protocol.&lt;/strong&gt; You need two systems to talk, and only one side's binary is available. The work mixes static analysis with traffic captures and testing against a live system. That points to a consultancy, because the method has to be worked out on the job.&lt;/p&gt;

&lt;p&gt;The pattern holds across all four. The better the job can be scoped before it starts, the more it suits a standardized service. The more it depends on discovery, the more it needs people.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you check what a provider delivered?
&lt;/h2&gt;

&lt;p&gt;You check a software reverse engineering result against a scope agreed before the work, and the tool for it is a coverage ledger. The ledger lists every unit in scope (every function, say) and puts each one in one of four states:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Proven:&lt;/strong&gt; there is verification evidence inside a declared scope.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Runtime-dependent:&lt;/strong&gt; settling it needs a real input or environment state.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Unresolved:&lt;/strong&gt; it was inspected and the evidence didn't settle it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permanently bounded:&lt;/strong&gt; an explicit limit was agreed.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Then run the one check that matters. The count of units in scope before the work has to equal the count in the ledger. If 140 functions were in scope and the report discusses 110, ask where the other 30 went. A result where the unproven units quietly disappear will always look better than it is.&lt;/p&gt;

&lt;p&gt;Whatever provider you pick, ask them to report in something like this shape. Some of them won't, and that tells you something too.&lt;/p&gt;

&lt;h2&gt;
  
  
  What changes when the binary is protected?
&lt;/h2&gt;

&lt;p&gt;Protected software is a compiled program that a commercial protector (VMProtect, Themida and the like) has packed, obfuscated or virtualized. Protection is where the four models split hardest.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Packing&lt;/strong&gt; compresses or encrypts code, and unpacking gets it back. Most providers can handle this.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Obfuscation&lt;/strong&gt; keeps code native but makes it miserable to read: substituted instructions, junk code, flattened control flow.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Virtualization&lt;/strong&gt; replaces a function's instructions with bytecode for an interpreter embedded in the binary. Point a decompiler at a virtualized function and it will faithfully decompile the interpreter. You get handlers and a dispatch loop, not the logic you came for.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Recovering what a virtualized function computes is called &lt;strong&gt;devirtualization&lt;/strong&gt;. It's slow by hand, which is why it's the one job where an automated service can beat a team on turnaround, as long as the protector is supported. If yours isn't, you're back to a consultancy, or to a service that does a feasibility review first.&lt;/p&gt;

&lt;p&gt;There's a longer explanation of why an unpacked binary can still be unreadable in this &lt;a href="https://devirt.re/blog/vmprotect-unpacking-vs-devirtualization?utm_source=devto&amp;amp;utm_medium=article&amp;amp;utm_campaign=sre-services" rel="noopener noreferrer"&gt;comparison of unpacking and devirtualization&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Questions to send any provider
&lt;/h2&gt;

&lt;p&gt;Copy these into your first email:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;What exactly is in scope, in one sentence?&lt;/li&gt;
&lt;li&gt;Which formats will you deliver? (Name the disassembler you use.)&lt;/li&gt;
&lt;li&gt;How will you report units you couldn't recover?&lt;/li&gt;
&lt;li&gt;Will the count of units in scope match the count in your report?&lt;/li&gt;
&lt;li&gt;What do you need from me to confirm I'm authorized to analyze this file?&lt;/li&gt;
&lt;li&gt;Where does the analysis run, who can access the binary, and when is it deleted?&lt;/li&gt;
&lt;li&gt;What happens to payment if the result falls short?&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A provider who answers these clearly is probably worth talking to. One who can't is probably not the right fit, whatever their portfolio says.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is hiring reverse engineering legal?
&lt;/h2&gt;

&lt;p&gt;It depends on the jurisdiction, the software license and your authorization. Get legal advice for your case, since this post isn't it. What you can check is the provider's intake. Legitimate services ask whether you own the binary or are authorized to analyze it, and they refuse requests to strip licensing, defeat DRM or enable cheating. The &lt;a href="https://www.eff.org/issues/coders/reverse-engineering-faq" rel="noopener noreferrer"&gt;EFF reverse engineering FAQ&lt;/a&gt; is a reasonable primer for the US.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the automated model fits, using Devirt as the example
&lt;/h2&gt;

&lt;p&gt;Disclosure again, since this is our product. Devirt is an automated service for protected and ordinary binaries:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Inputs:&lt;/strong&gt; native executables, .NET assemblies and JavaScript bundles.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Automated devirtualization:&lt;/strong&gt; eligible VMProtect, Themida, Code Virtualizer, Enigma Protector and Obsidium profiles.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Feasibility first:&lt;/strong&gt; custom or unsupported VMs get a free feasibility review and a written scope and quote before any paid work.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Outputs:&lt;/strong&gt; an IDA database, annotated pseudocode, a full report, LLVM IR and API JSON, with a coverage ledger in the four states above.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Your file:&lt;/strong&gt; analysis is isolated, uploads are never used for training, and inputs are deleted after the artifacts are generated and verified.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Details are on the &lt;a href="https://devirt.re/binary-reverse-engineering?utm_source=devto&amp;amp;utm_medium=article&amp;amp;utm_campaign=sre-services" rel="noopener noreferrer"&gt;software reverse engineering services page&lt;/a&gt;, and pricing is at &lt;a href="https://devirt.re/pricing?utm_source=devto&amp;amp;utm_medium=article&amp;amp;utm_campaign=sre-services" rel="noopener noreferrer"&gt;devirt.re/pricing&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;For a one-off protocol nobody has documented, a consultancy is still the better fit. For a VMProtect-protected DLL you need to read by Friday, it usually isn't.&lt;/p&gt;

</description>
      <category>reverseengineering</category>
      <category>security</category>
      <category>malware</category>
      <category>programming</category>
    </item>
    <item>
      <title>AI Decompiler Workflows for Agents, and Where They Stall</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Tue, 10 Nov 2026 04:19:39 +0000</pubDate>
      <link>https://dev.to/devirt/ai-decompiler-workflows-for-agents-and-where-they-stall-4ha2</link>
      <guid>https://dev.to/devirt/ai-decompiler-workflows-for-agents-and-where-they-stall-4ha2</guid>
      <description>&lt;p&gt;An AI decompiler is a language model wired into a decompiler or disassembler that rewrites assembly or pseudocode as readable code, renames variables and explains what functions do. In November 2026 most developers meet one of three setups: a plugin inside the decompiler they already use, a model trained specifically on compiled code, or an agent that drives those tools through the Model Context Protocol (MCP).&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;About Devirt:&lt;/strong&gt; Devirt recovers the code that protectors such as VMProtect and Themida hide inside their own virtual machines, for files you own or are authorized to analyze. You get an IDA database and annotated pseudocode, with a ledger showing which functions were proven. If nothing is proven, you pay nothing. &lt;a href="https://devirt.re/?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=ai-decompiler" rel="noopener noreferrer"&gt;Start with a free assessment&lt;/a&gt;.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;This post maps the AI decompiler tools people use, shows how an agent sits on top of them, and covers the place every one of these workflows stalls: functions protected by a virtual machine. It ends with a read-only way to hand an agent results it can trust, using an MCP server with six read tools and no write access at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is an AI decompiler?
&lt;/h2&gt;

&lt;p&gt;An AI decompiler is the model-driven layer on top of classic decompilation. Ghidra, IDA Pro's Hex-Rays decompiler and Binary Ninja turn machine code into pseudocode using rules: control-flow recovery, type inference, signature libraries. An AI decompiler takes that pseudocode, or the raw assembly, and predicts what a human would have written.&lt;/p&gt;

&lt;p&gt;In practice that means three jobs:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Naming:&lt;/strong&gt; &lt;code&gt;sub_401A30&lt;/code&gt; becomes &lt;code&gt;parse_header&lt;/code&gt;, &lt;code&gt;local_28&lt;/code&gt; becomes &lt;code&gt;buffer_len&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Restructuring:&lt;/strong&gt; goto ladders become loops, nested conditions get flattened.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Explaining:&lt;/strong&gt; a summary of what the function appears to do, often with comments inline.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;All three are predictions. They're often good, and they're never proof.&lt;/p&gt;

&lt;h2&gt;
  
  
  The AI decompiler tools people use
&lt;/h2&gt;

&lt;p&gt;AI decompiler tools fall into three groups: plugins that add a model to your existing decompiler, models trained to decompile assembly, and hosted platforms that pair a decompiler with an agent.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Tool&lt;/th&gt;
&lt;th&gt;Type&lt;/th&gt;
&lt;th&gt;What it does&lt;/th&gt;
&lt;th&gt;Where it runs&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/mahaloz/DAILA" rel="noopener noreferrer"&gt;DAILA&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Plugin&lt;/td&gt;
&lt;td&gt;One AI interface across IDA Pro, Ghidra, Binary Ninja and angr-management. Any LiteLLM-supported model, plus the local VarBERT model for variable renaming&lt;/td&gt;
&lt;td&gt;Your decompiler, local or remote models&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://www.nowsecure.com/blog/2025/01/29/decompiling-apps-with-ai-language-models/" rel="noopener noreferrer"&gt;r2ai / Decai&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Plugin&lt;/td&gt;
&lt;td&gt;Decai is an r2js plugin for radare2 focused on AI decompilation into many languages. It works with local or hosted models&lt;/td&gt;
&lt;td&gt;radare2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://reveng.ai/blog/training-an-llm-to-decompile-assembly-code" rel="noopener noreferrer"&gt;RevEng.AI&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Trained model&lt;/td&gt;
&lt;td&gt;Foundation models trained to decompile assembly into C-like source&lt;/td&gt;
&lt;td&gt;Hosted on the RevEng.AI platform&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://openbin.ai/" rel="noopener noreferrer"&gt;OpenBin&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Platform&lt;/td&gt;
&lt;td&gt;Open source (AGPL). Decompiles locally with Ghidra (native) or JADX (APK) in Docker, uploads the result to a shared workspace with an agent&lt;/td&gt;
&lt;td&gt;Browser plus local CLI&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;If you're picking one, the plugin route (DAILA or Decai) keeps everything inside the tool you already know. The hosted routes trade some control for convenience and a shared workspace.&lt;/p&gt;

&lt;h2&gt;
  
  
  How an agent drives a decompiler over MCP
&lt;/h2&gt;

&lt;p&gt;An MCP-based workflow exposes analysis tools, such as a disassembler, decompiler or debugger, as functions an AI agent can call. The agent asks for the function list, opens a function, reads the pseudocode, renames symbols and keeps going until it can answer your question. NowSecure describes the same pattern in r2ai's auto mode, where the model "plans, executes radare2 commands and analyzes their output."&lt;/p&gt;

&lt;p&gt;The loop looks like this:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;you:    "What does this binary do with the config file it reads at startup?"
agent:  list functions → find candidates by strings and xrefs
agent:  decompile candidate → read pseudocode → rename → summarize
agent:  follow calls → repeat
agent:  answer, with the functions it relied on
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;It works well on ordinary compiled code. It works badly in two places.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where AI decompilers stall
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Stripped binaries and invented names
&lt;/h3&gt;

&lt;p&gt;With no symbols, every name the agent produces is a guess. The guess then steers the next step. If the model decides a field is &lt;code&gt;timeout&lt;/code&gt; when it's a retry counter, the summary built on top inherits the mistake, and nothing in the output marks it.&lt;/p&gt;

&lt;p&gt;A made-up example shows how quietly this happens. The decompiler prints:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight c"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ctx&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mh"&gt;0x18&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="no"&gt;FUN_00402210&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ctx&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="mh"&gt;0xffffffff&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ctx&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mh"&gt;0x18&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ctx&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mh"&gt;0x18&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;+&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The AI rewrite reads well:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight c"&gt;&lt;code&gt;&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;session&lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;timeout_seconds&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;3&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nf"&gt;close_session&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;session&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="o"&gt;-&lt;/span&gt;&lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;session&lt;/span&gt;&lt;span class="o"&gt;-&amp;gt;&lt;/span&gt;&lt;span class="n"&gt;timeout_seconds&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A field that's compared against 3 and incremented once per call is far more likely to be an attempt counter than a timeout in seconds. And &lt;code&gt;close_session&lt;/code&gt; is a guess about a function the agent hasn't opened yet. Each name is plausible on its own. Together they produce a confident, wrong story about why the function returns -1. The pseudocode was correct the whole time. The interpretation drifted.&lt;/p&gt;

&lt;p&gt;The practical defense is to make the agent keep two lists: what it read directly (constants, calls, control flow) and what it named or inferred. Summaries should only be built from the first list unless something has checked the second.&lt;/p&gt;

&lt;h3&gt;
  
  
  VM-protected functions: the dispatcher problem
&lt;/h3&gt;

&lt;p&gt;AI decompilers stall completely on VM-protected functions because there's no original logic left to read. Protectors such as VMProtect and Themida compile the protected function into bytecode for a private virtual machine. The binary keeps an interpreter: a dispatcher loop that fetches the next bytecode instruction and a table of handlers that execute it.&lt;/p&gt;

&lt;p&gt;Decompile that and you get a perfectly accurate decompilation of the interpreter. Hand it to a model and you get a perfectly reasonable explanation of a dispatcher. Neither tells you what the protected function computes.&lt;/p&gt;

&lt;p&gt;A &lt;a href="https://arxiv.org/abs/2604.14317" rel="noopener noreferrer"&gt;2026 review of agentic reverse-engineering systems&lt;/a&gt; lists obfuscation among the cases where these systems still fail. Devirt's &lt;a href="https://devirt.re/blog/reverse-engineering-mcp-obfuscated-binaries" rel="noopener noreferrer"&gt;reverse engineering MCP guide&lt;/a&gt; walks through where that happens inside an agent workflow. The agent can identify the protector, trace the unprotected code around it and describe the VM. The function stays bytecode until it's devirtualized.&lt;/p&gt;

&lt;h2&gt;
  
  
  Giving the agent something it can trust
&lt;/h2&gt;

&lt;p&gt;The fix for both failure modes is the same: give the agent inputs that carry their own evidence, so it can tell checked facts from guesses.&lt;/p&gt;

&lt;p&gt;Devirt's approach is to recover the protected scope and label every in-scope function with one of four states:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Proven:&lt;/strong&gt; the accepted check supports the stated behavior within the declared scope.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Runtime-dependent:&lt;/strong&gt; the result needs runtime evidence before an agent should treat it as settled.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Unresolved:&lt;/strong&gt; the available evidence didn't establish the behavior.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Permanently bounded:&lt;/strong&gt; the question is outside the accepted model or artifact boundary.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A coverage ledger keeps facts, inferences and unknowns separate. An agent reading that ledger can cite "proven" functions and flag the rest, instead of turning an unresolved path into a claim.&lt;/p&gt;

&lt;h2&gt;
  
  
  Wiring a read-only result source into your MCP client
&lt;/h2&gt;

&lt;p&gt;The Devirt MCP server (&lt;code&gt;@devirt/mcp-server&lt;/code&gt; on npm) is a read-only MCP server. It lets your agent read Devirt assessments, jobs, coverage ledgers and completed results, next to whatever other MCP tools you use. It needs Node 22 or later and a separately scoped read-only API key from your Devirt workspace.&lt;/p&gt;

&lt;p&gt;The setup steps and the config block for your MCP client are in the &lt;a href="https://www.npmjs.com/package/@devirt/mcp-server" rel="noopener noreferrer"&gt;package README on npm&lt;/a&gt;. It needs a Devirt API key; keep the key out of prompts and source control.&lt;/p&gt;

&lt;p&gt;The server exposes six tools:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;devirt_get_capabilities
devirt_list_assessments
devirt_get_assessment
devirt_list_jobs
devirt_get_job
devirt_get_result
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Responses come back in a versioned &lt;code&gt;structuredContent&lt;/code&gt; envelope (&lt;code&gt;devirt.mcp.v1&lt;/code&gt;). The server also exposes account-scoped assessment, job and coverage-ledger resources.&lt;/p&gt;

&lt;h2&gt;
  
  
  What the agent can and can't do with it
&lt;/h2&gt;

&lt;p&gt;The Devirt MCP server is deliberately narrow. A tool that can only read can't be talked into uploading something.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;It can:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;list your assessments and jobs&lt;/li&gt;
&lt;li&gt;open an individual record&lt;/li&gt;
&lt;li&gt;fetch a completed result, including the coverage ledger and proof states&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;It can't:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;upload a binary&lt;/li&gt;
&lt;li&gt;submit a job&lt;/li&gt;
&lt;li&gt;accept an offer&lt;/li&gt;
&lt;li&gt;start checkout&lt;/li&gt;
&lt;li&gt;run a hosted model&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Upload, authorization, scope approval and payment all happen in your Devirt account, not through an agent tool. Your model stays your model: Devirt is not an AI model, and you can revoke the key from workspace settings whenever you choose.&lt;/p&gt;

&lt;h2&gt;
  
  
  A workflow that holds up
&lt;/h2&gt;

&lt;p&gt;Put together, the setup that survives contact with real binaries looks like this:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Orient with the AI decompiler.&lt;/strong&gt; DAILA, Decai or your agent maps functions, strings and the question you're stuck on.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Find the blocked boundary.&lt;/strong&gt; If the function you need sits behind a VM protector, the agent will keep describing a dispatcher. That's your signal.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Recover and check the protected scope.&lt;/strong&gt; For a file you own or are authorized to analyze, upload it and get a feasibility decision and scope. The recovered functions come back with proof states.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Continue with evidence.&lt;/strong&gt; Your MCP client reads the result, and the agent picks the investigation back up from checked functions.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Questions developers ask
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Is AI good at decompiling?&lt;/strong&gt;&lt;br&gt;
AI is good at readability and weak at correctness. In a decompiler workflow a language model is most useful for naming, summarizing and navigating functions. It's least reliable when it has to infer behavior the assembly doesn't show: types, indirect calls, virtualized code. Treat AI decompiler output as a lead to verify, not a finding.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Can an AI decompiler handle VMProtect or Themida?&lt;/strong&gt;&lt;br&gt;
It can describe the protector's virtual machine, not the protected logic. The function has to be devirtualized first. After that, an AI decompiler is useful again for explaining the recovered code.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do I have to use a specific agent?&lt;/strong&gt;&lt;br&gt;
No. Any MCP-compatible client can register the server. It sits beside REA, IDA, Ghidra or Binary Ninja integrations, or your own model pipeline.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Is decompiling legal?&lt;/strong&gt;&lt;br&gt;
It depends on the jurisdiction, the software license and the purpose, and using AI doesn't change that. Devirt only accepts files you own or are authorized to analyze, and it doesn't remove DRM, bypass license checks or crack software.&lt;/p&gt;

&lt;p&gt;If you want to try the handoff, Devirt's &lt;a href="https://devirt.re/ai-reverse-engineering" rel="noopener noreferrer"&gt;AI reverse engineering page&lt;/a&gt; covers the agent workflow and the free triage. Start there before you upload anything.&lt;/p&gt;

</description>
      <category>reverseengineering</category>
      <category>ai</category>
      <category>security</category>
      <category>mcp</category>
    </item>
    <item>
      <title>Malware Reverse Engineering: What Your SOC Should Get Back</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Mon, 09 Nov 2026 06:52:14 +0000</pubDate>
      <link>https://dev.to/devirt/malware-reverse-engineering-what-your-soc-should-get-back-353h</link>
      <guid>https://dev.to/devirt/malware-reverse-engineering-what-your-soc-should-get-back-353h</guid>
      <description>&lt;p&gt;A malware reverse engineering pass is finished when it hands the SOC eight things it can act on, not when the analyst runs out of functions to read. That standard matters more now that commercial protectors are routine in malware. MITRE ATT&amp;amp;CK tracks them as sub-technique T1027.002, Software Packing, and protected samples are exactly where reports go vague.&lt;/p&gt;

&lt;p&gt;This checklist is for analysts writing up a sample and for SOC and IR leads deciding whether a report is done. It covers what to deliver, how to mark findings you couldn't prove, and what changes when the sample is VM-protected.&lt;/p&gt;

&lt;h2&gt;
  
  
  What should a malware reverse engineering pass produce?
&lt;/h2&gt;

&lt;p&gt;A malware reverse engineering pass should produce eight things for a SOC: a short summary for decision-makers, the observed behavior across files, processes and network, the persistence mechanisms and triggers, indicators of compromise ready for detection rules, the recovered functions in a format analysts can keep working in, the configuration and C2 details found, the analysis limits, and a statement of how sure each finding is.&lt;/p&gt;

&lt;p&gt;Sandbox output covers part of this. Reverse engineering exists for the rest: the branches that didn't fire in the lab, the configuration that was encrypted at rest, and the honest answer to "could it have done more than we saw?"&lt;/p&gt;

&lt;h2&gt;
  
  
  The checklist
&lt;/h2&gt;

&lt;p&gt;Copy this into your report template:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;[ ] &lt;strong&gt;Summary&lt;/strong&gt; that a non-analyst can act on in two minutes&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Behavior&lt;/strong&gt;: files, registry, processes, network, each marked observed or inferred from code&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Persistence and triggers&lt;/strong&gt;: how it survives a reboot, and what makes it act or stay dormant&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Indicators of compromise&lt;/strong&gt;: hashes, domains, IPs, mutexes, file paths, ready for detection rules&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Configuration and C2&lt;/strong&gt;: decrypted config, keys and campaign identifiers, with how they were recovered&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Recovered functions&lt;/strong&gt; in a format the next analyst can open&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Analysis limits&lt;/strong&gt;: what was out of scope, and what couldn't be reached&lt;/li&gt;
&lt;li&gt;[ ] &lt;strong&gt;Confidence per finding&lt;/strong&gt;: proven, depends on runtime, unresolved, or bounded&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  Summary for decision-makers
&lt;/h3&gt;

&lt;p&gt;Two or three sentences. Name the malware family if you're confident, what the sample can do, whether it ran in your environment, and what to do now. Leave the opcodes for the appendix.&lt;/p&gt;

&lt;h3&gt;
  
  
  Behavior: files, processes, network
&lt;/h3&gt;

&lt;p&gt;List behavior in two columns, &lt;strong&gt;observed&lt;/strong&gt; (it happened in the lab) and &lt;strong&gt;from code&lt;/strong&gt; (the code can do it, but it didn't fire). Incident leads scope containment from the second column.&lt;/p&gt;

&lt;h3&gt;
  
  
  Persistence and triggers
&lt;/h3&gt;

&lt;p&gt;Persistence answers "will it come back?" Triggers answer "why didn't it do anything in the sandbox?" Common triggers are dates, a reachable C2, locale or keyboard checks, and anti-VM checks. List each one with the condition it waits for.&lt;/p&gt;

&lt;h3&gt;
  
  
  Indicators of compromise
&lt;/h3&gt;

&lt;p&gt;Ship IOCs in a form your detection pipeline ingests directly. Prefer behavioral and code-based indicators over the sample hash, which changes with every rebuild.&lt;/p&gt;

&lt;h3&gt;
  
  
  Recovered functions you can keep working in
&lt;/h3&gt;

&lt;p&gt;Give the next analyst your work, not just your conclusions: an IDA or Ghidra database with your names, types and comments, or annotated pseudocode for the key functions. A PDF of screenshots can't be searched, diffed or extended.&lt;/p&gt;

&lt;h3&gt;
  
  
  How sure each finding is
&lt;/h3&gt;

&lt;p&gt;This is the item most reports skip, covered in the next sections.&lt;/p&gt;

&lt;h2&gt;
  
  
  What changes when the sample is VM-protected?
&lt;/h2&gt;

&lt;p&gt;A VM-protected malware sample is one where some functions were translated into bytecode for an interpreter embedded in the file. A decompiler shows the interpreter's dispatcher loop and handlers instead of the logic, so static findings for those functions are missing until someone traces or devirtualizes them.&lt;/p&gt;

&lt;p&gt;Two things follow for the deliverable:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Say which functions were virtualized.&lt;/strong&gt; A report that silently skips them reads as complete when it isn't.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Check before assuming.&lt;/strong&gt; A June 2024 &lt;a href="https://any.run/cybersecurity-blog/vmprotect-themida-malware-analysis/" rel="noopener noreferrer"&gt;ANY.RUN study&lt;/a&gt; of Themida- and VMProtect-protected samples from five families found that none of them used the protectors' code virtualization; the protectors were used much like basic packers.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqs1f3awhca12y5e46m82.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqs1f3awhca12y5e46m82.png" alt="Decision tree for a protected malware sample: unpack if the target code is only packed; if it is virtualized, trace dynamically or devirtualize, and report what stays unresolved." width="800" height="412"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How to mark what was not proven
&lt;/h2&gt;

&lt;p&gt;A reverse engineering report should label each finding by how it was established, rather than presenting every function as equally certain. One way to do this is Devirt's four proof states: proven, runtime-dependent, unresolved and permanently bounded. Each in-scope function stays in the count in exactly one of the four states, so an unproven function can't silently drop out of an incident note.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;State&lt;/th&gt;
&lt;th&gt;What it means in a malware report&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Proven&lt;/td&gt;
&lt;td&gt;The recovered logic is shown to match the sample&lt;/td&gt;
&lt;td&gt;String decryption routine, verified against decrypted output&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Runtime-dependent&lt;/td&gt;
&lt;td&gt;The result depends on something not available&lt;/td&gt;
&lt;td&gt;A command handler that needs the C2's real response&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Unresolved&lt;/td&gt;
&lt;td&gt;Not recovered with the evidence available&lt;/td&gt;
&lt;td&gt;A virtualized function nobody traced&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Permanently bounded&lt;/td&gt;
&lt;td&gt;Can't be recovered, and the reason is known&lt;/td&gt;
&lt;td&gt;Code that relies on a key held only on the victim machine&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The runtime-dependent row does the most work in malware reports. It keeps "we didn't see it do X" from turning into "it can't do X". &lt;a href="https://devirt.re/research/devirtualization/runtime-dependent-functions?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-malware" rel="noopener noreferrer"&gt;The proof-state article&lt;/a&gt; explains each state.&lt;/p&gt;

&lt;h2&gt;
  
  
  Handling live samples safely
&lt;/h2&gt;

&lt;p&gt;Live malware samples should only be analyzed in an isolated environment with no route to production networks, and kept out of shared storage once the analysis ends. A service handling samples for a SOC should state where samples run, whether they're shared or used for training, and when the input is deleted.&lt;/p&gt;

&lt;p&gt;Ask any third party those three questions in writing. Devirt's answer, for example, is published: uploads run in an isolated environment, aren't shared between customers or used for training, and input deletion begins once processing finishes and the output is available.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where outside recovery fits
&lt;/h2&gt;

&lt;p&gt;When the functions you need are virtualized and the deadline is short, an automated devirtualization service can return them in the deliverable formats above. Devirt returns an authorized sample's recovered functions as an IDA database (.i64), annotated pseudocode, a full RE report and API JSON for your own pipeline, each with the coverage ledger. An unfamiliar build can start with a free assessment. Its &lt;a href="https://devirt.re/use-cases/malware-analysts?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-malware" rel="noopener noreferrer"&gt;page for malware analysts&lt;/a&gt; explains the scoping. Malware analysis and defensive threat intelligence are accepted uses; deploying or improving malware is not.&lt;/p&gt;

&lt;h2&gt;
  
  
  Further reading
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://buttondown.com/devirt/archive/reverse-engineering-malware/" rel="noopener noreferrer"&gt;Reverse engineering malware: what it is and where it stops&lt;/a&gt;: the static and dynamic basics&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://devirt.substack.com/p/malware-reverse-engineer-job" rel="noopener noreferrer"&gt;What a malware reverse engineer actually does&lt;/a&gt;: the job, case by case&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://devirt.re/blog/protected-binary-analysis-workflow?utm_source=dev&amp;amp;utm_medium=article&amp;amp;utm_campaign=re-malware" rel="noopener noreferrer"&gt;Protected binary analysis workflow&lt;/a&gt;: the stages from triage to recovered code&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;em&gt;Written by Devirt, an automated devirtualization service for authorized analysis of protected software.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>malware</category>
      <category>security</category>
      <category>reverseengineering</category>
      <category>infosec</category>
    </item>
    <item>
      <title>REA MCP server: how AI agents drive Ghidra and IDA, and where the loop breaks</title>
      <dc:creator>Devirt</dc:creator>
      <pubDate>Wed, 28 Oct 2026 09:44:41 +0000</pubDate>
      <link>https://dev.to/devirt/rea-mcp-server-how-ai-agents-drive-ghidra-and-ida-and-where-the-loop-breaks-1ijj</link>
      <guid>https://dev.to/devirt/rea-mcp-server-how-ai-agents-drive-ghidra-and-ida-and-where-the-loop-breaks-1ijj</guid>
      <description>&lt;p&gt;The REA MCP server is the part of REA (Reverse Engineer Anything) that lets an AI coding agent call reverse engineering tools as structured tool calls. It ships in the &lt;a href="https://github.com/morluto/rea" rel="noopener noreferrer"&gt;morluto/rea&lt;/a&gt; project, created on April 14, 2026 under the MIT license, and it registers with Claude Code, Codex, Cursor, Gemini CLI, Grok Build or any agent that supports local MCP servers. Instead of guessing what a binary does, the agent asks the REA MCP server to run Hopper, Ghidra, IDA, JADX or a browser capture, and reasons over what comes back.&lt;/p&gt;

&lt;p&gt;We work on the far end of this pipeline. Devirt (devirt.re) turns VM-protected code back into readable functions, which is precisely the input where the REA MCP loop runs dry. Here is how that loop works, where it shines, and the exact point where it runs out of road.&lt;/p&gt;

&lt;p&gt;  &lt;iframe src="https://www.youtube.com/embed/fLPV61qJuhY" width="710" height="399"&gt;
  &lt;/iframe&gt;
&lt;/p&gt;

&lt;h2&gt;
  
  
  What the REA MCP server exposes
&lt;/h2&gt;

&lt;p&gt;The REA MCP server exposes reverse engineering tasks as MCP tools with defined input and output schemas. The project keeps a generated tool catalog in its MCP contracts guide, and the tools cover native binaries, .NET assemblies, JavaScript and Electron apps, Android packages, firmware, websites and a long tail of formats such as WASM, EVM bytecode and Unity IL2CPP metadata.&lt;/p&gt;

&lt;p&gt;Two configuration details matter if you run it inside an agent with a tight context window:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Input schemas are compact by default. Setting &lt;code&gt;REA_MCP_INPUT_SCHEMA_PROFILE=full&lt;/code&gt; in the MCP registration restores the complete field guidance and nested validation details.&lt;/li&gt;
&lt;li&gt;Output schemas are complete by default. If your client caps the size of the &lt;code&gt;tools/list&lt;/code&gt; response, &lt;code&gt;REA_MCP_OUTPUT_SCHEMA_PROFILE=compact&lt;/code&gt; shrinks them. Both profiles keep the full tool set.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How the REA MCP loop works
&lt;/h2&gt;

&lt;p&gt;The REA MCP loop is ask, inspect, read evidence, ask again. A typical investigation runs like this:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;The agent receives a question, for example "how does search work in this desktop app?"&lt;/li&gt;
&lt;li&gt;It calls an REA tool, say listing modules and imports of an Electron app or decompiling a native function through the configured provider.&lt;/li&gt;
&lt;li&gt;REA runs the underlying tool locally and returns findings with their evidence: code, references, and the unknowns it could not resolve.&lt;/li&gt;
&lt;li&gt;The agent forms a hypothesis and calls the next tool to confirm or reject it.&lt;/li&gt;
&lt;li&gt;When the evidence is strong enough, the agent explains the behavior or writes an implementation of its own.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;The design choice that makes this work is that REA returns unknowns explicitly. An agent that can see "this call target could not be resolved" asks a better follow-up than one handed a confident but incomplete summary.&lt;/p&gt;

&lt;h2&gt;
  
  
  Setting up the REA MCP server
&lt;/h2&gt;

&lt;p&gt;REA's setup command registers the MCP server and installs matching workflow instructions for each agent you pick:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;npx rea-agents setup
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Setup shows its proposed changes, backs up your existing agent configuration, and asks for approval before writing. Restart the agent afterwards. For manual MCP registration, provider configuration and the Claude Code or Codex plugin route, the project points to its installation guide.&lt;/p&gt;

&lt;p&gt;Things to have in place first:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Requirement&lt;/th&gt;
&lt;th&gt;Detail&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Node.js&lt;/td&gt;
&lt;td&gt;22, 24 or 26&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Native provider&lt;/td&gt;
&lt;td&gt;An existing Hopper, Ghidra or IDA install (setup can install Hopper with approval)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Commercial tools&lt;/td&gt;
&lt;td&gt;IDA, Hopper and JEB need their own licenses; REA provides none&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Linux&lt;/td&gt;
&lt;td&gt;A procps-compatible &lt;code&gt;ps&lt;/code&gt; on the path for Ghidra, JADX and some static analysis&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Sources&lt;/td&gt;
&lt;td&gt;Only the morluto/rea repo, rea.tools and the rea-agents npm package are official&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  What the REA MCP loop is good at
&lt;/h2&gt;

&lt;p&gt;The REA MCP loop is strongest where the underlying tools already produce readable output. That covers most of the targets developers care about day to day:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Electron and JavaScript apps, where modules, source maps and IPC routes give an agent a lot to reason over.&lt;/li&gt;
&lt;li&gt;Ordinary native binaries, where Ghidra or IDA pseudocode is readable and an agent can follow calls across functions.&lt;/li&gt;
&lt;li&gt;Android apps, where JADX output is close to source.&lt;/li&gt;
&lt;li&gt;Formats nobody has a decompiler habit for, such as IL2CPP metadata or EVM bytecode, where built-in parsers save real setup time.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Analysis runs on your machine. Keep in mind that the agent still forwards tool results to its model provider, so "local" describes where the tools run, not where the findings end up.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where the REA MCP loop breaks: VM-protected binaries
&lt;/h2&gt;

&lt;p&gt;The REA MCP loop breaks on code protected by a virtualizing protector, because every tool in the chain sees the protection instead of the program. VMProtect, Themida and Code Virtualizer replace selected functions with bytecode for a private virtual machine and add an interpreter that executes it. The virtual machine can differ from one protected file to the next.&lt;/p&gt;

&lt;p&gt;Ask the REA MCP server to decompile a virtualized function and the provider dutifully returns the interpreter: a dispatcher loop, handler routines, and bytecode tables. The agent can describe that machinery accurately and still learn nothing about what the original function did. More tool calls won't fix it. The information the agent needs isn't in any listing the tools can produce. As of October 2026 the REA README does not mention obfuscation, packing or virtualizing protectors at all.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo90n7dshh6rkk1ehh7l0.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fo90n7dshh6rkk1ehh7l0.png" alt="On a VM-protected function, the tools REA drives show the protector's interpreter, not the program" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The fix sits upstream of the agent. Devirtualization rebuilds the virtual machine's state and control flow and turns that behavior back into native-shaped functions, so the decompiler, and the agent reading its output, has real code to work with.&lt;/p&gt;

&lt;h2&gt;
  
  
  Adding devirtualization in front of the REA MCP loop
&lt;/h2&gt;

&lt;p&gt;Devirtualization is what Devirt does. Devirt (devirt.re) recovers the logic behind VMProtect, Themida and Code Virtualizer automatically, and handles Enigma Protector, Obsidium, Loki-based virtual machines, JavaScript VM obfuscation and custom VMs after a free assessment of the file. Two of its outputs fit straight back into an agent workflow:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;An IDA database, which opens in IDA, one of the providers the REA MCP server can drive.&lt;/li&gt;
&lt;li&gt;Structured JSON, which an agent can read directly.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Each recovered function carries a label in Devirt's coverage ledger: proven, runtime-dependent, unresolved or permanently bounded. That is the same idea as REA's explicit unknowns, applied to recovered code, and it tells the agent which functions to trust. Devirt only analyzes software that customers own or are authorized to examine. The &lt;a href="https://devirt.re/how-it-works" rel="noopener noreferrer"&gt;How It Works page&lt;/a&gt; shows the process end to end.&lt;/p&gt;

&lt;p&gt;If you want the non-technical overview of REA first, our &lt;a href="https://devirt.substack.com/p/rea-reverse-engineer-anything" rel="noopener noreferrer"&gt;Substack post on REA&lt;/a&gt; covers what it is and why "anything" has limits.&lt;/p&gt;

</description>
      <category>security</category>
      <category>mcp</category>
      <category>ai</category>
      <category>reverseengineering</category>
    </item>
  </channel>
</rss>
