Devirt logo

Devirt

Archives
Log in
Subscribe
November 18, 2026

What Is Reverse Engineering? Meaning, 3 Types and 22 Tools

What is reverse engineering? How software, hardware and mechanical RE work, the law and careers, plus a census of 22 tools so you know where to start.

Reverse engineering is the process of working out how an existing product, machine or program works by studying the finished thing, without access to its original design documents or source code. It comes in three main types: software reverse engineering reads compiled programs, hardware reverse engineering traces circuit boards, chips and firmware, and mechanical reverse engineering measures physical parts and rebuilds them as CAD models. Much of the field works in public: on 18 November 2026, GitHub listed 17,025 public repositories tagged "reverse-engineering", and the NSA's Ghidra alone had 100,490 stars. This guide covers what reverse engineering means, the types, what it's used for, how the process works, the tools in each domain, where the law draws lines, and what reverse engineers do for a living.

When reverse engineering meets a virtual machine: some commercial protectors, VMProtect and Themida among them, turn selected functions of a program into bytecode for an interpreter built into the file. A decompiler still works, but it describes the interpreter rather than the logic that was protected. Devirt's software reverse engineering service recovers what those functions compute, with a coverage ledger for the agreed scope. Devirt accepts only files you own or are authorized to analyze.

What does reverse engineering mean?

Reverse engineering means running the design process backwards. A normal engineering project starts with requirements, turns them into a design and ends with a product. Reverse engineering starts with the product and works back toward the design: what the parts are, how they connect, and why the thing behaves the way it does. Wikipedia lists "backwards engineering" and "back engineering" as other names for it.

To reverse engineer something is the verb form, and it covers both the physical and the digital. Someone who 3D-scans a broken gear to make a new one is reverse engineering it. So is someone who opens a program in a disassembler to find out what file format it writes. What the two have in common is the starting point: a finished object, and no access to the drawings, schematics or source code its makers had.

The work usually ends in a model that explains the object (a CAD file, a circuit diagram, pseudocode or a protocol specification) and a decision about what to do with it: repair it, replace it, build something that works with it, or flag it as dangerous.

Reverse engineering doesn't give you the original files back. A scanned part comes back as measurements, and compiled code comes back without its original names and comments. The result is a rebuilt understanding, which is often all you need.

What are the types of reverse engineering?

Reverse engineering comes in three main types: software, hardware and mechanical. All three follow the same loop of observing, extracting, modeling and checking, but they start from different material and end with different models.

Type You start with You extract You end with Typical tools
Software A compiled program, a file format or network traffic Machine code, strings, imports, runtime behavior, packets Assembly, pseudocode, a protocol or format spec, a behavior report Ghidra, IDA Pro, x64dbg, Frida, Wireshark
Hardware A circuit board, a chip, a device's firmware Component IDs, board traces, signals, firmware images A schematic, a pinout, a firmware analysis Multimeter, logic analyzer, JTAG/SWD debugger, flash reader, binwalk
Mechanical A physical part or assembly Surface measurements as a point cloud or mesh A CAD model and a deviation report 3D scanner, CMM, calipers, CAD software

re three domains

Some projects cross all three. Reverse engineering a smart thermostat, for example, can mean measuring its case (mechanical), tracing its board and reading its flash chip (hardware), and then analyzing the firmware and the traffic it sends to the cloud (software). Wikipedia's article also covers biological uses, such as inferring gene regulatory networks, but software, hardware and mechanical are where most people meet the term.

What is reverse engineering used for?

Reverse engineering is used to repair, replace, secure, connect and compare things whose design isn't available. The main uses:

  • Interoperability: making a new product work with an existing one. Samba, the free implementation of the SMB file-sharing protocol, began in December 1991 and January 1992 when Andrew Tridgell used a packet sniffer to study the protocol spoken by DEC Pathworks server software.
  • Compatibility and competition: Phoenix Technologies introduced its first PC BIOS in May 1984. It was written with a clean room design: engineers who had read IBM's reference listings wrote specifications, and a separate engineer wrote code from those specifications alone. That BIOS let clone makers such as Hewlett-Packard, Tandy and AT&T build IBM-compatible PCs.
  • Security: malware analysts take apart malicious programs to learn what they do, and vulnerability researchers look for flaws in software and devices whose source code they can't see.
  • Legacy and repair: when a part, a program or a file format outlives its maker, reverse engineering is often the only way to keep it running. Siemens describes scanning legacy parts to recreate CAD data for maintenance and redesign.
  • Quality and inspection: comparing a manufactured part to its CAD model shows where production drifted. Metrology vendors such as ZEISS describe this as a core use.
  • Learning: students reverse engineer crackmes and old games for the same reason mechanics take engines apart. Plenty of working reverse engineers started that way.

Common examples of reverse engineering, one per domain: a malware analyst reading a ransomware sample to find how it encrypts files (software); a researcher dumping a router's flash chip to check its firmware for hardcoded passwords (hardware); and an engineer 3D-scanning an out-of-production pump housing to make a replacement (mechanical).

How does reverse engineering work?

Reverse engineering works in four stages in every domain: acquire and observe the object, extract raw data from it, build a model that explains the data, and verify the model against the original. TechTarget's three-step version (information extraction, modeling and review) and Siemens's five steps for product design describe the same loop at different levels of detail.

  1. Acquire and observe. Get a legitimate copy and watch it work: run the program, power the device, use the part.
  2. Extract. Turn the object into data: disassemble the binary, capture signals and dump firmware, or scan the surface into a point cloud.
  3. Model. Explain the data: name functions and rebuild their logic, draw the schematic, or fit CAD surfaces to the mesh.
  4. Verify. Check the model against the original: run the code path, probe the circuit, overlay the CAD model on the scan. Anything that doesn't match sends you back to step 2.

re process loop

The loop rarely runs once. Each pass answers some questions and raises narrower ones, and most of the time goes into steps 3 and 4. Extraction is largely automated by tools; deciding what the data means is the skilled part.

What is software reverse engineering?

Software reverse engineering is the analysis of a compiled program to establish how it behaves when the source code isn't available. Analysts disassemble the machine code into assembly, decompile it into C-like pseudocode, and run it under a debugger or in a sandbox to watch what it does. It's the kind of reverse engineering with the most open-source tooling by far, as the GitHub census further down shows.

What compiling throws away

Software reverse engineering is hard mostly because compilers discard information. Source code is written for people: it has names, comments, types and structure. A compiler turns it into machine instructions for a processor and keeps only what the processor needs. Comments never reach the binary. Local variable names usually don't either, unless debug information ships with the program. Optimization then reorders and merges code, so the binary's shape can differ from the source's.

How much survives depends on the language. A .NET program keeps its class and method names as metadata, so it decompiles back to near-readable C#. A C or C++ program keeps far less, and comes back as pseudo-C with invented names. When we tried to decompile an EXE we compiled ourselves, 14 of its 23 named source items survived and every comment was gone.

re software layers

Static analysis: reading the program without running it

Static analysis is software reverse engineering without executing the program. The analyst reads the file itself:

  • File structure: a Windows program is a PE file, with headers, sections and an import table that lists the system functions it calls. The imports alone often hint at what a program does.
  • Strings: readable text inside the binary, such as error messages, file paths and URLs.
  • Disassembly: a disassembler turns machine code into assembly language, one instruction per line.
  • Decompilation: a decompiler goes a level higher and rebuilds functions, loops and conditions as C-like pseudocode.

Ghidra, developed by the NSA and released publicly at the RSA Conference in March 2019 under the Apache 2.0 license, is the free tool most people start with. IDA Pro and Binary Ninja are the main commercial alternatives, and radare2, rizin and Cutter are open-source frameworks with a command-line heritage.

Dynamic analysis: watching it run

Dynamic analysis is software reverse engineering by running the program and observing it. A debugger such as x64dbg lets the analyst pause the program at any instruction, inspect memory and registers, and step through code one instruction at a time. Instrumentation frameworks such as Frida inject code into a running process to log or change function calls. A sandbox runs untrusted software in an isolated environment and records the files, registry keys and network connections it touches.

Static and dynamic analysis answer different questions. Static analysis shows everything the program could do; dynamic analysis shows what it did on one run. Most real work alternates between the two: read a function statically, confirm a guess dynamically, then go back to reading.

File formats and network protocols

Not all software reverse engineering targets code. Much of it targets data: an undocumented file format, a save-game structure, or the messages a device sends to its cloud service. Analysts capture traffic with Wireshark, compare many samples of a file in a hex editor such as ImHex, and change one input at a time to see which bytes move. The goal is a specification another program can implement, which is how Samba began.

When the code is protected

Some programs are built to resist reverse engineering. Developers protect software to slow down cracking and tampering, and malware authors use the same tools to hide from analysts. Protection comes in three broad layers:

  • Packing: the real code is compressed or encrypted and only unpacked in memory at run time, so the file on disk shows a small loader instead of the program.
  • Obfuscation: the code stays native but is rewritten to be hard to read, with junk instructions, substituted operations and tangled control flow.
  • Virtualization: selected functions are translated into bytecode for a private virtual machine embedded in the program. A disassembler then shows the virtual machine's interpreter, not the function's logic.

Each layer calls for different work, and the difference between unpacking and devirtualization decides what comes next. Unpacking recovers native code that was hidden. Devirtualization recovers what virtualized functions compute, because there's no native code left to recover. This is the part of software reverse engineering where generic tools stop being enough.

What is reverse engineering in cyber security?

Reverse engineering in cyber security is the analysis of software, firmware or network traffic to find out what it does, especially when it is malicious or untrusted. It shows up in three jobs:

  • Malware analysis: analysts take samples apart to extract indicators of compromise, understand how the malware spreads and persists, and write detections. Reverse engineering malware usually moves from quick triage to static and dynamic analysis, and slows sharply when a sample is packed or virtualized.
  • Vulnerability research: researchers look for memory-safety bugs, logic flaws and hardcoded secrets in closed-source software and devices, then report them so they can be fixed.
  • Verification: defenders check that third-party code, drivers or firmware do what the vendor says and nothing more.

Of the tagged GitHub repositories counted on 18 November 2026, 4,125 carried the "malware-analysis" topic and 1,303 "binary-analysis", the second and third largest of the nine topics we checked.

What is hardware reverse engineering?

Hardware reverse engineering is working out how an electronic device is built and how its parts talk to each other, usually to understand, repair, secure or interface with it. It typically moves from the outside in:

  1. Board level: identify the components by their markings, look up their datasheets, and trace the copper connections between them. Multi-layer boards hide traces between layers, so a multimeter in continuity mode and good photographs do a lot of the work.
  2. Signals: a logic analyzer records the digital conversations between chips on buses such as UART, SPI and I2C. An oscilloscope shows the analog side.
  3. Debug interfaces: many boards keep test points for JTAG or SWD, standard ports for debugging chips. OpenOCD is the common open-source tool for talking to them.
  4. Firmware: the software stored on the device's flash chip. A flash programmer driven by a tool such as flashrom can copy it, and binwalk identifies and extracts the file systems and compressed data inside the image. From there, firmware analysis is software reverse engineering.
  5. Silicon: at the far end, labs remove a chip's packaging and image its layers under a microscope to recover the circuit. Wikipedia describes this for integrated circuits and smart cards; it is specialist work with specialist equipment.

Hardware reverse engineering is where software and electronics meet, and where a lot of security research on routers, cameras and other connected devices starts. The open-source hardware tools in our census are smaller projects by stars, partly because several (OpenOCD, flashrom, PulseView) keep their main repositories elsewhere and only mirror to GitHub.

What is mechanical reverse engineering?

Mechanical reverse engineering is measuring a physical part and rebuilding it as a digital design, usually a CAD model that can be edited, inspected or manufactured. It's the sense of the term most CAD and metrology vendors use. The workflow, as Siemens and ZEISS describe it:

  1. Measure. Capture the part's shape with calipers for simple features, a coordinate measuring machine (CMM) for precise points, or a 3D scanner for whole surfaces.
  2. Build a mesh. The scanner produces a point cloud, which software turns into a polygon mesh, often saved as an STL or OBJ file.
  3. Model. Fit CAD geometry to the mesh: planes, cylinders and freeform surfaces. This "scan to CAD" step turns a dumb mesh into a model with real dimensions and design intent.
  4. Check. Overlay the CAD model on the scan and color the differences in a deviation map. Large deviations mean the model, or the original part, is off.

The main scanning methods are structured light, where a projector casts a calibrated pattern of white or blue light onto the part and a camera measures how the pattern bends (Artec's description); laser triangulation; photogrammetry, which rebuilds shape from many overlapping photos; and contact probing with a CMM. Typical jobs include replacement parts for machines whose maker no longer exists, tooling and molds, aftermarket parts, and checking production parts against their design.

Which tools do reverse engineers use?

Reverse engineers use different tools in each domain, and the open-source core of each set is well known. On 18 November 2026 we pulled 22 widely used open-source reverse engineering tools from the GitHub API, plus the repository counts for nine reverse engineering topics. The script and its raw output are kept with this post.

re tools census

Domain Tool What it does GitHub stars (18 Nov 2026)
Software Ghidra Disassembler and decompiler suite from the NSA 100,490
Software ImHex Hex editor built for reverse engineers 55,913
Software x64dbg Windows user-mode debugger 50,340
Software ILSpy .NET decompiler 27,095
Software radare2 Disassembler and RE framework 25,451
Software Frida Dynamic instrumentation 22,825
Software Cutter GUI for the rizin framework 20,236
Software Detect It Easy File type and packer identifier 11,971
Software dnSpyEx .NET debugger and decompiler 11,496
Software angr Binary analysis with symbolic execution 9,387
Software capa Detects capabilities in executables 6,339
Hardware binwalk Firmware image analysis and extraction 14,717
Hardware Glasgow Digital electronics multitool 2,241
Mechanical FreeCAD Parametric CAD modeler 35,565
Mechanical COLMAP Structure-from-motion and multi-view stereo 13,242
Mechanical Meshroom Photogrammetry pipeline 13,101
Mechanical MeshLab Mesh processing for 3D scans 5,920

Not in the table: rizin (4,202) and four tools whose GitHub repositories are mirrors of a main repository hosted elsewhere, so their stars undercount real use: Wireshark (10,239), OpenOCD (2,389), flashrom (1,194) and PulseView (821). Stars measure attention, not quality, and the census covers open-source tools only. IDA Pro and Binary Ninja (software), commercial logic analyzers (hardware), and Geomagic, NX and other commercial scan-to-CAD packages (mechanical) are widely used and don't appear in GitHub counts at all.

The topic counts point the same way. GitHub had 17,025 repositories tagged "reverse-engineering", 988 tagged "disassembler" and 865 tagged "decompiler", but only 349 tagged "hardware-hacking", 239 "firmware-analysis" and 210 "3d-scanning". On GitHub, at least, open-source reverse engineering is mostly software reverse engineering; mechanical work runs mostly on commercial CAD and metrology tools. Choosing among the software reverse engineering tools comes down to the task in front of you: identifying a file, reading it statically, debugging it or instrumenting it.

Is reverse engineering legal?

Reverse engineering is generally legal in the United States when you obtained the product lawfully, but contracts, patents and anti-circumvention law can limit it. This is a short overview, not legal advice; the rules depend on your jurisdiction, what you're analyzing and what you agreed to.

re legal map

In the United States:

  • Trade secrets: the Defend Trade Secrets Act of 2016 says the term "improper means" does not include reverse engineering (18 U.S.C. 1839(6)). Reverse engineering a product you bought is not, by itself, trade secret theft.
  • Copyright: in Sega v. Accolade (9th Cir. 1992), the court held that where disassembly is the only way to reach a program's ideas and functional elements and there is a legitimate reason for that access, disassembly is a fair use.
  • Anti-circumvention: the DMCA generally prohibits circumventing technical protection measures, with an exception in 17 U.S.C. 1201(f) that lets someone who lawfully obtained the right to use a program circumvent a protection solely to identify and analyze the parts needed for an independently created program to interoperate with other programs, when that information wasn't already readily available.
  • Contracts: a license can forbid reverse engineering. In Bowers v. Baystate (Fed. Cir. 2003), a shrink-wrap license's ban on reverse engineering was upheld as a contract term, not preempted by copyright law.
  • Patents: a patent protects the invention itself, so building a product you learned about through reverse engineering can still infringe a patent on it.

In the European Union, the Software Directive 2009/24/EC takes a different route. Article 5(3) lets anyone with the right to use a program observe, study and test how it works while loading, running or otherwise using it as they are entitled to. Article 6 allows decompilation without the rightholder's permission when it is indispensable for interoperability, limited to the parts needed and to information not already available. Article 8 voids contract terms that try to override those two rights.

The practical rule most professionals follow is simple: work on things you own or are authorized to analyze, know what your license says, and get advice before you publish or ship anything built from what you found.

What does a reverse engineer do?

A reverse engineer studies how existing systems work, usually software or firmware, and turns that into findings other people can act on: a malware report, a vulnerability write-up, an interoperability spec or a replacement-part model. The job titles vary by domain:

  • Malware analyst / malware reverse engineer: works in a security operations center, an incident response team or a security vendor, taking samples apart and writing detections.
  • Vulnerability researcher: finds and reports security flaws, for vendors, consultancies or bug bounty programs.
  • Firmware or embedded security engineer: reverse engineers devices, often combining hardware and software skills.
  • Software engineer on legacy or interoperability work: documents and replaces systems whose source is lost or whose formats are undocumented.
  • Mechanical or metrology engineer: scans and models parts, often with a CMM or 3D scanner and CAD software.

There's no Bureau of Labor Statistics category called "reverse engineer". The closest tracked occupation for the security roles is information security analyst, which the BLS puts at a median pay of $129,180 in 2025, with employment projected to grow 21% from 2025 to 2035. Mechanical reverse engineering jobs usually sit under mechanical engineering or quality titles.

The skills overlap more than the titles suggest. Software reverse engineers need assembly for at least one architecture (x86-64 and ARM are the common ones), C, how operating systems load and run programs, and fluency in a disassembler and a debugger. Hardware work adds electronics and datasheets. Most people start with free tools such as Ghidra and x64dbg and practice targets built for the purpose: crackmes (small programs written to be reversed) and capture-the-flag (CTF) competitions.

Is reverse engineering harder than engineering?

Reverse engineering is usually harder than forward engineering in one specific way: the engineer starts without the design intent, so names, comments and reasons have to be inferred from behavior. It's easier in another: the finished product already proves that the design works, so you never have to wonder whether a solution exists.

How hard reverse engineering is depends mostly on two things. The first is how much information the build process threw away: a .NET program or a simple machined bracket gives a lot back, while an optimized C++ binary or a molded part with hidden internal features gives back much less. The second is whether the maker added protection, such as code obfuscation and virtualization in software or epoxy-covered chips and disabled debug ports in hardware.

How powerful is reverse engineering?

Reverse engineering is powerful enough to rebuild a working understanding of almost any product you can hold or run, but it recovers how something works, not the original files. Code comes back without its original names and comments, and scanned parts come back as measurements that a designer still has to turn into intent. In practice that's often enough: it's how clone PCs got a compatible BIOS in 1984, how Samba learned to speak SMB, and how analysts work out what a new piece of malware does.

The limits are practical more than theoretical. Time is the main one. A protected program, a multi-layer board or a complex freeform surface can take far longer to reverse engineer than the original took to build. That's why the field keeps building better tools, and why the hardest cases, such as virtualized code, have become specialties of their own.

Written by Devirt, an automated devirtualization service for authorized analysis of protected software. Census data: GitHub REST API, 18 November 2026; script and raw output kept with this post.

Don't miss what's next. Subscribe to Devirt:
← Newer Reverse Engineering AI in 2026: What It Can and Can't Do Older → Types of Malware: 31 Classic Kinds and the New AI Malware
devirt.re
GitHub
devirt.gitbook.io
YouTube
dev.to
Twitter
Medium
Substack
Powered by Buttondown, the easiest way to start and grow your newsletter.