The OWASP Firmware Security Testing Methodology (FSTM) is a free, nine-stage firmware security testing playbook, published by the OWASP Internet of Things project since November 2019 under the Creative Commons Attribution Share Alike 4.0 International licence. First released in November 2019 by project lead Aaron Guzman (@scriptingxss), FSTM's own overview states it "comprises nine structured stages designed to help security researchers, software developers, consultants, hobbyists, and information security professionals conduct comprehensive firmware security assessments." Rather than a list of controls a device must have, FSTM is a sequence of concrete testing steps, with named tools and example commands, for going from a firmware image to evidence of exploitable vulnerabilities.
Key takeaways
- Stage 3 decides whether extraction can work at all.
- Stage 5 directs testers to search extracted filesystem contents for "legacy insecure network daemons such as telnetd...
- Stage 9 is explicit that exploit development is a distinct skill from vulnerability discovery: "Developing exploit code requires programming experience in lower level languages (e.g.
- Decide first how much of Stages 1–4 you want to pay for.
What are the nine stages?
| Stage | Name | What it covers |
|---|---|---|
| 1 | Information gathering and reconnaissance | Acquire technical and documentation details — CPU architecture, bootloader, schematics, datasheets, source location, third-party components, licences, changelogs, FCC IDs, threat models, prior pentest reports |
| 2 | Obtaining firmware | Acquire the firmware image: from the vendor/manufacturer, update-server MITM, cloud storage exposure, hardware extraction (UART/JTAG), or chip removal as a last resort |
| 3 | Analyzing firmware | Identify file characteristics, platform and possible encryption (via entropy analysis) using file, strings, binwalk and similar utilities |
| 4 | Extracting the filesystem | Carve and unpack filesystem contents (squashfs, ubifs, romfs, jffs2, cramfs, etc.) for review, typically with binwalk -ev |
| 5 | Analyzing filesystem contents | Statically analyze extracted configuration files and binaries for hardcoded credentials, insecure daemons, update-server endpoints and command-injection-prone startup scripts |
| 6 | Emulating firmware | Emulate standalone binaries (user-mode) or the full firmware image, via QEMU, a real device, or a matching virtual machine |
| 7 | Dynamic analysis | Test the running firmware/application interfaces — web/API testing, fuzzing, bootloader and firmware-integrity tampering |
| 8 | Runtime analysis | Attach a debugger (gdb-multiarch) to a running process to find overflows and crashes in compiled binaries |
| 9 | Binary Exploitation | Build a working proof-of-concept for an identified vulnerability, using techniques such as return-oriented programming (ROP) where runtime protections are present |
FSTM's own note on sequencing: "Consider visiting the OWASP Internet of Things Project page and GitHub repository for the latest methodology updates and forthcoming project releases," signalling the document is actively maintained rather than frozen at its 2019 release — the current text adds static-analysis tooling (Cppcheck, Flawfinder, Clang-Tidy, CodeQL, Semgrep) and a Software Bill of Materials section referencing CISA's minimum SBOM elements, both absent from the original release. The current FSTM text also lists binwalk v3 (a Rust rewrite) and unblob among its extraction tools, and advises generating an SBOM "during initial firmware acquisition (Stage 2) to establish a baseline".
How do testers obtain and extract firmware (Stages 2-4)?
Stage 2 lists acquisition methods in roughly increasing order of difficulty: directly from the manufacturer or vendor support site; via man-in-the-middle capture of an update; through exposed cloud storage (with an explicit caveat to "follow local laws and regulations when downloading data from exposed cloud provider storage services"); from hardware debug interfaces such as UART or JTAG; or, as a last resort, by desoldering the flash chip. FSTM recommends requesting both debug and release builds "to maximize testing coverage... in the event debug code or functionality is compiled within a release." Stage 4 then carves the extracted image's filesystem with binwalk -ev, falling back to manual offset carving with dd when binwalk's signature database does not recognize the filesystem's magic bytes — the methodology walks through squashfs, cpio, jffs2 and ubifs extraction commands as worked examples.
Stage 3 decides whether extraction can work at all. FSTM notes the image may be bare-metal, an RTOS with a custom filesystem, or encrypted, and checks with an entropy plot (binwalk -E): low entropy means the image is "not likely to be encrypted", high entropy means it is likely encrypted or compressed. An encrypted update file is good practice, but it moves the test effort: testers then need the decrypted image from you, or a dump from a unit, before Stages 4 and 5 can start.
What happens in static and dynamic analysis (Stages 5-8)?
Stage 5 directs testers to search extracted filesystem contents for "legacy insecure network daemons such as telnetd... hardcoded credentials (usernames, passwords, API keys, SSH keys, and backdoor variants)... hardcoded API endpoints... [and] startup scripts for remote code execution," using tools such as firmwalker for pattern-based scanning and FACT or EMBA for automated component identification, CVE correlation and binary-mitigation detection (NX, DEP, ASLR, stack canaries, RELRO). From Stage 6 onward the testing shifts from static inspection to a running target: Stage 7's dynamic analysis covers embedded web-application testing (default credentials, directory traversal, injection in diagnostic pages), bootloader tampering (interrupting boot to reach a U-Boot shell, modifying bootargs to add init=/bin/sh), and firmware-integrity testing (uploading a custom image to check signature verification); Stage 8's runtime analysis attaches a debugger to the emulated or live binary to set breakpoints on functions like memcpy and strcmp and fuzz for overflows.
How does Stage 9 work, and how does FSTM fit with ISTG and ISVS?
Stage 9 is explicit that exploit development is a distinct skill from vulnerability discovery: "Developing exploit code requires programming experience in lower level languages (e.g. ASM, C/C++, shellcode, etc.) as well as background within the particular target architecture," and names return-oriented programming as the technique needed when NX/DEP/ASLR protections — uncommon in embedded systems, per FSTM's own observation, but not absent — block a straightforward shellcode injection.
FSTM is deliberately scoped to the firmware image alone. The methodology states its complementary documents cover the rest of a device's attack surface: the OWASP IoT Security Testing Guide (ISTG) "provides additional test cases for hardware interfaces, wireless protocols, network services, and user interfaces," while the OWASP IoT Security Verification Standard (ISVS) "defines WHAT security controls must be implemented, while FSTM defines HOW to test firmware components." OWASP's own recommendation is to use the three together — ISVS as the requirements checklist, ISTG for the device's broader surface, FSTM for the firmware binary — rather than treating any one as sufficient on its own. OWASP also maintains IoTGoat, a deliberately vulnerable firmware image used in FSTM's own worked examples, as practice material for applying the methodology end to end.
The ISTG test case catalogue is organised by device component. This is where FSTM's firmware focus sits inside it:
| ISTG category | Typical tests | Covered by FSTM? |
|---|---|---|
| Firmware (ISTG-FW), installed firmware and update mechanism | Image analysis, secrets, update integrity | Yes, Stages 2–9 |
| Data Exchange Services (ISTG-DES) | Network services and APIs on the device | Partly, Stage 7 |
| User Interfaces (ISTG-UI) | Web UI, local and companion interfaces | Partly, Stage 7 |
| Internal Interfaces (ISTG-INT), UART and I2C | Console access, bus sniffing | Only as a firmware source in Stage 2 |
| Physical Interfaces (ISTG-PHY) | External ports | No |
| Wireless Interfaces (ISTG-WRLS) | Radio protocols | No |
| Processing Units (ISTG-PROC) and Memory (ISTG-MEM) | Chip-level and storage tests | Only as a firmware source in Stage 2 |
For the requirement side, see our OWASP ISVS guide and the OWASP IoT Top 10.
How should a device maker scope an FSTM-style test?
Decide first how much of Stages 1–4 you want to pay for. A black-box test spends days obtaining, decrypting and unpacking an image you already have. A grey-box test hands that material over, and the budget goes to Stages 5–9, where the findings are. FSTM's Stage 1 list doubles as a hand-over checklist:
| Hand over | Stage it shortens | Note |
|---|---|---|
| Release and debug builds of the same version | 2, 7, 8 | FSTM asks for both to catch debug code left in release |
| Decryption keys or a decrypted image | 3, 4 | Without them, an encrypted image can stall the test |
| Component list or SBOM, licences, changelog | 1, 5 | Lets testers go straight to version-specific CVEs |
| Datasheets, schematics, boot and update design | 1, 2, 7 | Points testers to debug pads and the update path |
| Threat model and earlier pentest reports | 1 | Avoids re-testing closed findings |
| Two or three production-state units | 6, 7, 8 | Emulation does not always work; spare units cover bricking |
Agree the rules too: which interfaces are in scope (only firmware, or the ISTG categories above as well), whether exploitation (Stage 9) is wanted or a confirmed crash is enough, and how findings flow into your PSIRT. See PSIRT setup for a hardware company.
What evidence does each stage produce, and which requirement can it support?
FSTM output is test evidence, and several regulations ask for exactly that kind of record. The Cyber Resilience Act, Annex I Part II (3), requires manufacturers to "apply effective and regular tests and reviews of the security of the product", and ETSI EN 303 645 V3.1.3 sets testable provisions. The mapping below shows where stage output can support a requirement; it does not make the test a conformity assessment.
| Stage output | Can support |
|---|---|
| Component list and SBOM (Stages 3–5) | CRA Annex I Part II (1): identify and document components, including an SBOM |
| Known CVEs in identified components (Stage 5) | CRA Annex I Part I (2)(a): made available on the market without known exploitable vulnerabilities |
| Hard-coded or shared default passwords (Stage 5) | ETSI 5.1-1: passwords unique per device or set by the user |
| Legacy daemons such as telnetd, open debug consoles (Stages 5, 7) | ETSI 5.6-1 and 5.6-4A: unused interfaces disabled, debug interfaces disabled or protected; CRA (2)(j) attack surface |
| Unsigned image accepted, U-Boot shell reachable (Stage 7) | ETSI 5.7-1 secure boot; CRA (2)(f) integrity of programs |
| Fuzzing and injection results on web UI and APIs (Stage 7) | ETSI 5.13-1A and 5.13-1B: validate input via user and network interfaces |
| Retest after fixes, per release | CRA Annex I Part II (3): regular tests and reviews |
See CRA Annex I explained, ETSI EN 303 645 explained and secure boot and hardware root of trust.
Worked example: what does an FSTM-style plan look like for one camera?
Synthetic example. The company, camera and plan are invented for this guide; no findings are reported.
A hypothetical maker of an embedded-Linux Wi-Fi camera commissions a grey-box test before a CRA release. The plan, by stage:
Stages 1–2, hand-overRelease and debug images of firmware 2.4, the decryption key for the update package, the SBOM, the boot and update design note, and three production-state units. Stage 3Entropy check on the decrypted image, identification of the bootloader, kernel and root filesystem type. Stage 4Unpack the squashfs root filesystem and the web UI assets; record any partition that cannot be unpacked. Stage 5Search for credentials, keys and certificates; list network daemons started at boot; match component versions to known CVEs; check binaries for NX, stack canaries and RELRO. Stage 6Emulate the web server and the ONVIF service in user mode; fall back to a unit where emulation fails. Stage 7Test the web UI and API for injection and authentication bypass, fuzz the RTSP and discovery services, interrupt U-Boot on the UART, and try installing a modified, unsigned image. Stage 8Attach gdb-multiarchto any service that crashes under fuzzing to classify the crash.Stage 9Proof of concept only for findings rated high, to confirm exploitability. ReportEach finding with the stage, evidence, CWE, affected versions and a retest result after the fix.
Before commissioning, the team can rehearse on OWASP's IoTGoat, "a deliberately insecure firmware" that FSTM uses in its own examples.
What are the common pitfalls?
- Stopping after the automated scan. FACT or EMBA output covers Stages 3–5; the exploitable issues usually surface in Stages 7–8.
- Testing only the release build when a debug build would show code left in by mistake.
- An encrypted image with no key handed over, so most of the budget goes on extraction.
- Skipping a service because emulation failed instead of testing it on a unit.
- Leaving the update path out of scope, although it is where signature checks fail.
- Acquiring images from exposed cloud storage without checking local law, as FSTM itself warns.
- One test per product life instead of a retest per release.
- Findings that never reach the PSIRT, so fixed issues are not disclosed and tracked.
Why does this matter for device and firmware makers?
FSTM is a testing methodology, not a regulatory control — no regulation known to us names FSTM itself as a required step, so a claim that completing an FSTM-style assessment alone satisfies the EU Cyber Resilience Act, RED/EN 18031 or similar regimes should not be assumed. Where it is directly useful is as a structured way to generate the kind of technical evidence — hardcoded-credential findings, confirmed memory-corruption or command-injection vulnerabilities, exploitability proof — that a vulnerability-handling process or secure-development lifecycle narrative does need to produce. A firmware SBOM answers what components are inside an image; an FSTM-style assessment answers whether those components, and the glue code around them, are actually exploitable.
Where does SoftWSP fit in an FSTM-style assessment?
SoftWSP automates part of Stages 3–5: it extracts a software bill of materials from the firmware image as CycloneDX JSON and matches the components against NVD, CISA KEV, FIRST EPSS and CISA ICS advisories. An AI-drafted report cites each source, and an engineer reviews it before you receive it. It does not emulate, fuzz or exploit firmware, and it does not judge whether a matched vulnerability is reachable on your device; Stages 6–9 stay with your testers. See device & firmware security.
This guide summarises the public OWASP FSTM documentation (CC BY-SA 4.0); it does not constitute legal or compliance advice.
Put this guide to work
Frequently asked questions
What is the OWASP Firmware Security Testing Methodology (FSTM)?
FSTM is an OWASP Internet of Things project document that, per its own overview, "comprises nine structured stages designed to help security researchers, software developers, consultants, hobbyists, and information security professionals conduct comprehensive firmware security assessments." It was first released under OWASP in November 2019 by Aaron Guzman (@scriptingxss), who leads the project, and is published under the Creative Commons Attribution Share Alike 4.0 International licence. Unlike a compliance standard, FSTM is a testing playbook: a sequence of stages, with concrete tool commands, for examining a firmware image rather than a checklist of controls a product must have.
What are the nine stages of FSTM?
1) Information gathering and reconnaissance; 2) Obtaining firmware; 3) Analyzing firmware; 4) Extracting the filesystem; 5) Analyzing filesystem contents; 6) Emulating firmware; 7) Dynamic analysis; 8) Runtime analysis; 9) Binary Exploitation. The methodology's own description frames the arc as: "Acquire all relative technical and documentation details... Attain firmware... Examine the target firmware's characteristics... Carve filesystem contents... Statically analyze extracted filesystem configuration files and binaries for vulnerabilities... Emulate firmware files and components... Perform dynamic security testing... Analyze compiled binaries during device runtime... Exploit identified vulnerabilities discovered in previous stages to attain root and/or code execution."
How does FSTM relate to OWASP's ISTG and ISVS?
FSTM documents its own place in OWASP's wider IoT work directly: this firmware-specific methodology "complements the OWASP IoT Security Testing Guide (ISTG), which provides additional test cases for hardware interfaces, wireless protocols, network services, and user interfaces," while "the OWASP IoT Security Verification Standard (ISVS) defines WHAT security controls must be implemented, while FSTM defines HOW to test firmware components." The guidance is to use all three together: ISVS as the control checklist, ISTG for the device's non-firmware attack surface, and FSTM for the firmware image itself.
What tools does FSTM reference for each stage?
Named tools vary by stage: binwalk for identifying and carving firmware filesystems (Stage 3-4); firmwalker, Cppcheck, Flawfinder, Clang-Tidy, CodeQL and Semgrep for static analysis of extracted filesystem contents and source (Stage 5); QEMU-based partial or full-system emulation (Stage 6); OWASP ZAP, Burp Suite, Commix, AFL, Mutiny, boofuzz, kitty, Nmap, NCrack and Metasploit for dynamic testing (Stage 7); gdb-multiarch for attaching to running binaries (Stage 8); and ROPGadget for building exploit chains against identified vulnerabilities (Stage 9). FSTM also names FACT and EMBA as combined automated-analysis frameworks spanning extraction through dynamic analysis.
Does passing FSTM satisfy a regulation like the Cyber Resilience Act?
No. FSTM is an OWASP testing methodology, not a named control in the EU Cyber Resilience Act, RED/EN 18031 or any other regulation known to us as of this guide's publication; no regulation confirms that an FSTM-based assessment equates to regulatory conformity. What FSTM is useful for is structuring the technical testing work (and resulting evidence) that can feed a vulnerability-handling or secure-development narrative a regulation does require.
Sources
- OWASP Firmware Security Testing Methodology (FSTM) — scriptingxss.gitbook.io
- GitHub: scriptingxss/owasp-fstm (source repository, CC BY-SA 4.0 licence file)
- OWASP: Internet of Things project page (project home, licence, related resources)
- OWASP IoT Security Testing Guide (ISTG) project page
- GitHub: OWASP/IoT-Security-Verification-Standard-ISVS
- GitHub: OWASP/owasp-istg (IoT Security Testing Guide, test case catalogue)
- GitHub: OWASP/IoTGoat (deliberately insecure firmware)
- ETSI EN 303 645 V3.1.3 (2024-09): Cyber Security for Consumer Internet of Things: Baseline Requirements
- Regulation (EU) 2024/2847 (Cyber Resilience Act), Annex I
About this guide
SoftWSP Firmware Security Desk
Covers the Firmware vulnerabilities & fixes cluster: 131 guides.

All guides in this cluster: Firmware vulnerabilities & fixes
Questions about this page?
