Firmware Security: Think Your Source Code Is Secure? Check Your Firmware
Attackers target what runs, not what’s written. Learn why binary-level firmware analysis is essential for real IoT security and regulatory compliance.

Larry Pesce
VP of Services
Your source code might be clean, but your firmware is a party full of strangers. And some brought vulnerabilities, both known and unknown.This guide covers why firmware security matters, the risks and common firmware vulnerabilities that show up in shipped images, and the best practices that close the gap between the code you wrote and the code you shipped.
What Is Firmware Security?
Firmware security is the practice of protecting the compiled code that runs on a device, from the bootloader up through the application layer, against tampering, known vulnerabilities, and exposed secrets. It covers what actually ships on the hardware, not what sits in the repo.
That distinction is the whole game. Application security assumes you control the source, can rebuild at will, and can patch in days. Firmware security assumes none of that. You inherit binaries from suppliers you never audited. You ship to devices that stay in the field for a decade. And you often cannot see inside the thing you are shipping without taking it apart first.
Three properties make it its own discipline:
- The artifact is compiled. Analysis has to work on binaries, not text.
- The supply chain is opaque. Third-party libraries arrive pre-built, sometimes with no manifest at all.
- The patch window is long. A fix that takes a web team an afternoon can take a device team a quarter, and that assumes the device accepts updates at all.
Get this wrong and everything downstream, your SBOM, your vulnerability triage, your compliance evidence, describes a product you did not actually ship.
For IoT firmware security, the scope is the whole image on the device: bootloader, embedded Linux or an RTOS, drivers, application code, and every third-party component bundled with them. On PCs and servers, the term usually means platform firmware such as UEFI and baseboard management controllers. Both layers contain supplier code, and the layer decides who ships the fix.

| Layer | Examples | Who ships the fix |
|---|---|---|
Platform firmware | UEFI, BIOS, Secure Boot keys | BIOS vendor (AMI, Insyde, Phoenix) to OEM |
Management controllers | BMCs on servers and appliances | BMC vendor to OEM |
Embedded device firmware | Routers, cameras, PLCs, medical and automotive ECUs | The device manufacturer |
Inherited components | SoC SDKs, BSPs, TCP/IP stacks, open source libraries | Upstream supplier, then you |
If you build connected devices, you own the third row outright and inherit the other three.
Why Firmware Security Matters
Firmware is the first code a device runs and the last code anyone audits. Four properties make a firmware flaw more expensive than the same flaw in an application.
- It persists. Firmware runs before the operating system and survives reboots, resets, and reimaging. In 2023, ESET documented BlackLotus as the first publicly known in-the-wild UEFI bootkit able to bypass Secure Boot on fully updated Windows 11 systems.
- It is mostly inherited. Forescout's 2024 analysis of five OT and IoT router firmware images found an average of 662 components per image, with open source components averaging 5.5 years old.
- It stays in the field for years. Routers, controllers, and medical devices often run long past the point anyone planned to patch them.
- It is invisible to most security tools. Endpoint agents rarely run on embedded devices, and network scanners see a device's services, not the components inside its image.
Regulators have caught up. The question used to be whether firmware security was worth funding. Now it is whether you can produce evidence on a deadline.
| Framework | What it asks of firmware | Status (November 2026) |
|---|---|---|
EU Cyber Resilience Act (Regulation (EU) 2024/2847) | Report actively exploited vulnerabilities with a 24-hour early warning and 72-hour notification. From December 2027: no known exploitable vulnerabilities at release, secure updates, and an SBOM. | Article 14 reporting has applied since Sept. 11, 2026, through ENISA's Single Reporting Platform, including for products already on the market. Most other obligations apply from Dec. 11, 2027. |
EU Radio Equipment Directive (Delegated Reg. (EU) 2022/30) | Cybersecurity requirements for internet-connected radio equipment, assessed against EN 18031. | Has applied since Aug. 1, 2025. The CRA takes over on Dec. 11, 2027. |
FDA Section 524B | A machine-readable SBOM for cyber devices and a plan to monitor and patch vulnerabilities after release. | Final premarket cybersecurity guidance issued June 27, 2025. |
US Cyber Trust Mark | Voluntary consumer IoT label. Proposed disclosures include the product's support period. | Not yet operational. The FCC sought comment on labeling and post-market rules on Oct. 27, 2026. No products are certified. |
If you sell connected products in the EU and one of them has an actively exploited firmware vulnerability today, the 24-hour clock already applies. You cannot report on a component you did not know shipped.
Key Firmware Security Risks and Threats
Most firmware threats fall into five categories. None of them require an exotic attacker. The incidents below were run by botnet operators and state-linked groups against ordinary devices.
- Malicious or hijacked updates. An update channel that can push code can push the wrong code.
- Boot chain bypass. Bootkits, signed-but-vulnerable binaries, and leaked or test signing keys defeat secure boot from below.
- Exposed management interfaces. Web admin panels and BMCs reachable from a network are the most common way in.
- Inherited supply chain flaws. One vulnerability in a shared SDK spreads to every product built on it.
- Abandoned devices. End-of-life hardware that still sits on a network becomes someone else's infrastructure.
| Incident | What happened | The lesson for manufacturers |
|---|---|---|
Realtek SDK (disclosed Aug. 2021) | Flaws in the SDK Realtek ships with its chipsets reached products from at least 65 vendors. Unit 42 later counted roughly 134 million exploit attempts against CVE-2021-35394. | You ship code you never wrote. Track supplier SDKs as components. |
Pumpkin Eclipse (Oct. 2023) | A malicious firmware update disabled more than 600,000 routers belonging to a single ISP over 72 hours. The devices required hardware replacement. | Your update channel is attack surface. Build a recovery path that does not need a truck roll. |
KV-botnet (disclosed Jan. 2024) | The US Department of Justice said the "vast majority" of the botnet's routers were end-of-life Cisco and Netgear models. | End of life is a security event. Publish support dates. |
Raptor Train (disclosed Sept. 2024) | A joint FBI advisory described a botnet of more than 260,000 routers, IP cameras, DVRs, and NAS devices. | Unpatched SOHO devices become nation-state infrastructure. |
PKfail (July 2024) | Binarly found production UEFI firmware shipping with an AMI test Platform Key labeled "DO NOT TRUST," across hundreds of models from multiple vendors. | Secure boot is only as strong as its root key. Audit keys at release. |
CVE-2024-7344 (Jan. 2025) | ESET found a Microsoft-signed UEFI application in seven recovery tools that bypassed Secure Boot. Microsoft revoked it on Jan. 14, 2025. | Inventory every signed binary your platform trusts, not just the ones you wrote. |
Zyxel GS1900 (2026) | Attackers took configurations and hashed root credentials from 996 Zyxel GS1900 switches, according to GreyNoise. Binarly then showed that Zyxel's June fix for CVE-2026-7273 checked bounds only after the overflow had already happened. A corrected firmware followed in late October under CVE-2026-107441. | A patch is new code. Test it against the exploit, not just the bug report. |
Two patterns repeat across the list: code or keys the device maker did not create, and devices that fell outside active maintenance.
Common Firmware Vulnerabilities
Most firmware vulnerability classes are not exotic. They are ordinary software flaws that ship inside an image nobody re-examines after release.

| Why it ships | How to catch it | |
|---|---|---|
| Outdated third-party components with known CVEs | SDKs, BSPs, and open source packages get pinned and never updated. Fraunhofer FKIE's 2022 Home Router Security Report found 93 of 121 Linux kernels had reached end of life. | A binary-derived SBOM matched against vulnerability intelligence, re-run on every released version |
| Hardcoded and default credentials | Manufacturing and support convenience. Fraunhofer found hardcoded credentials in 21 of 122 router images, and 564 of the 996 compromised Zyxel switches still used factory defaults. | Binary scan for credential material; unique per-device credentials or forced first-boot setup |
| Memory-safety bugs in network-facing services | C code in web management, UPnP, and custom daemons. The Zyxel GS1900 flaw sat in the switch's web request handler. | Fuzzing and binary analysis of exposed services, ranked by reachability |
| Weak or missing update authentication | Unsigned images, or signature checks without anti-rollback | Verify signature enforcement and rollback protection in the shipped bootloader |
| Test or shared signing keys | Reference keys from BIOS or SoC vendors never get replaced | A release gate that fails on known test keys and keys reused across product lines |
| Embedded private keys and certificates | Keys baked into the image for TLS or device identity, identical on every unit | Scan the image for cryptographic material; provision per device |
| Exposed debug interfaces | JTAG, UART, and SWD left enabled on production boards, or debug builds shipped | Hardware review plus a build check for debug flags |
| Insecure configuration defaults | Telnet, open admin ports, and permissive services enabled out of the box | Configuration analysis of the root filesystem |
Most of these rows share one property: the team that ships the device did not write the flawed code and often does not know it is there. That is also why firmware vulnerabilities behave differently from application vulnerabilities.
Why Source Code Isn’t the Final Word
We’ve all heard it: "We scan the source. We're good." But are we? Not quite.
In reality, what you write and what ends up running on a device are rarely the same thing. Compilers optimize, build environments inject configs, and developers sometimes cut corners ( this is my shock and awe face). The result? Code mutations you didn’t see coming.
Compilation is Transformation
Think of source code like a movie script. What ends up on screen—the firmware—is the director’s cut. Scenes are edited, characters change, and sometimes a surprise actor shows up uncredited.
- Compilers strip symbols
- Build scripts swap dependencies
- Optimization settings remove or morph intended logic
- Static libraries get bundled in, sometimes without even telling you
Bottom line? By the time your firmware is built, it might be something very different from what you wrote.
Binaries Don’t Lie, But They Don’t Talk Easy
If you want the truth, you need to analyze the binaries themselves. And that means digging deep:
- Reverse Engineering to recover function names, structures, and linked libraries
- Signature Matching to identify known vulnerabilities in stripped or obfuscated code
- Reachability Analysis to determine if vulnerable code paths are actually accessible at runtime
Traditional scanners don’t do this. They either fail outright or stop at surface-level inspection.
Case Study: Container Scanning vs. Binary Analysis on IoTGoat
We ran the same intentionally vulnerable firmware image, OWASP IoTGoat, through a traditional container scanner and through binary analysis on the Finite State platform. The container scanner reported 247 issues, drawn from what the package metadata declared.
Binary analysis of the same image surfaced what the metadata left out: critical CVEs in components with no package record, hardcoded credentials, embedded cryptographic material, and exploitable logic in compiled code.
The lesson is not that more findings are better. An unprioritized list is its own backlog. The lesson is that you cannot prioritize a component you cannot see, and reachability analysis then tells you which findings to fix first.
How Do Firmware Vulnerabilities Differ From Software Vulnerabilities?

They differ in four ways, and each one changes how you find them and how long you live with them.
Discovery is inverted. In application security you scan source and get a file name and a line number. In firmware, symbols are frequently stripped, so a vulnerable OpenSSL build looks like an anonymous blob of machine code. Identifying it means matching signatures against known binaries, not reading a dependency file.
Ownership is fragmented. A web app declares its dependencies. A firmware image bundles static libraries, vendor SDKs, and board support packages that arrive pre-compiled from three tiers of supplier. A CVE in any of them is still yours to disclose and still yours to fix.
Persistence is longer. Application vulnerabilities die when you redeploy. Firmware vulnerabilities survive reboots, factory resets, and OS reinstalls, because the compromised code sits below the layer doing the resetting. That durability is exactly why attackers go looking for it, and it is what turns a single flawed component into a firmware breach that persists through remediation.
Remediation is physical. Sometimes the fix needs a signed update the device was never built to accept, or a technician on site, or a recall.
The practical effect: a firmware vulnerability found late is not the same event as an application vulnerability found late. One is a sprint item. The other is a field campaign. A firmware fix is also new code that can fail. In 2026, Zyxel's first patch for an actively exploited switch flaw left the attackers' exploit working unchanged.
Take Action
- Include binary analysis in your CI/CD. Yes, it’s possible. Yes, it scales.
- Scan your firmware, not just your codebase. Bonus: you catch your suppliers’ mistakes, too.
- Correlate code-level intent with binary-level output. See if what you meant is what you shipped.
Firmware Security Best Practices for IoT Device Manufacturers
Most best-practice lists assume you are designing a device from scratch. Useful, unless you are shipping v7 of a product line that started in 2016. These are ordered for teams who already have a portfolio in the field.
Establish a boot chain you can prove
Secure boot verifies each stage before it executes, so a modified image refuses to run. Ship it with keys you control and a documented recovery path, or you will brick a fleet the first time a signing step goes wrong.
Sign, encrypt, and version every update
An unsigned update mechanism is a remote code execution vector you built yourself. Add rollback protection so nobody can force a downgrade to a version with a known CVE.
Generate the SBOM from the binary, not the build manifest
A manifest lists what you meant to include. The binary contains what your compiler, your build scripts, and your suppliers actually included. When the two disagree, the binary is the one attackers get. That is the whole argument for SBOM generation grounded in the shipped artifact.
Close the interfaces you stopped using
JTAG, UART, and debug consoles left live in production are the fastest route from physical access to full firmware extraction. Audit them per release, not per project.
Rank findings by reachability, not severity alone
A CVSS 9.8 in a library your product never calls is not your top priority. A 6.5 sitting in the code path that handles network input is. Exploitability-based prioritization is what stops a 7,000-finding report from becoming shelfware.
Build a disclosure path before you need one
The Cyber Resilience Act, FDA 524B, and the US Cyber Trust Mark all expect a manufacturer to detect, triage, and report. You cannot report what you never had visibility into, which makes analysis capability a prerequisite for compliance rather than a parallel workstream.
Monitor after ship, continuously
A component that was clean at release keeps accumulating CVEs for as long as the product is in the field. For a ten-year device, that is ten years of new findings against a frozen binary.
Treat signing keys as production infrastructure
Keep release keys in an HSM, keep test keys out of release pipelines, and fail the build if a known test or reference key appears in an image. PKfail showed what happens when that gate is missing: a vendor test key labeled "DO NOT TRUST" shipped in production firmware for years.
Regression-test fixes against the exploit, not just the bug
In 2026, Zyxel's first fix for an actively exploited switch flaw added a bounds check that ran after the overflow, so the original exploit still worked. Binarly's January 2026 research on Supermicro BMC firmware (CVE-2025-12006 and CVE-2025-12007) showed a similar pattern, with validation fixes bypassed by the next variant. Before you ship a security patch, run the known exploit and its obvious variants against the patched build.
Publish end-of-life dates and staff for a 24-hour clock
KV-botnet ran on routers their makers had stopped patching. Tell customers when support ends and ship a final update before it does. For products on the EU market, the CRA now requires an early warning within 24 hours of becoming aware of an actively exploited vulnerability, submitted through ENISA's Single Reporting Platform. Decide now who files it.
The teams who do this well stop treating firmware as a build output that stops mattering once the box leaves the dock.
Final Word
Your source code might tell a beautiful story, but attackers read your firmware. If you’re not analyzing your binaries, you’re leaving your devices open to surprise plot twists. And in IoT security, surprise is rarely good.
Key takeaways:
- Firmware security covers the image you shipped, not just the code you wrote.
- Most firmware risk is inherited from SoC SDKs, BIOS and BMC vendors, ODMs, and open source.
- The incidents that hurt manufacturers turned on update channels, signing keys, exposed management interfaces, and end-of-life devices.
- Since Sept. 11, 2026, an actively exploited firmware vulnerability in a product on the EU market starts a 24-hour reporting clock.
Finite State analyzes compiled firmware directly, with no source code required. We generate an SBOM from what shipped, prioritize vulnerabilities by reachability, monitor released images against new vulnerability intelligence, and produce the documentation regulators ask for. See it on your own firmware.
Firmware Security FAQ
What is firmware security and why is it important?
Firmware security protects the compiled code running on a device against tampering, known vulnerabilities, and exposed credentials. It matters because firmware executes below the operating system, which means a compromise there survives the resets and reinstalls that clear ordinary malware, and because most device makers inherit the majority of their firmware from suppliers rather than writing it.
What are the most common firmware vulnerabilities?
The most common firmware vulnerabilities are outdated third-party components with known CVEs, hardcoded or default credentials, memory-safety bugs in network-facing services such as web admin panels, weak update authentication, and test or shared signing keys. Exposed debug interfaces like JTAG and UART are also common. Most are inherited from SoC SDKs, BIOS vendors, or open source packages rather than written by the device maker.
How is IoT firmware security different from PC firmware security?
PC firmware security usually means platform firmware: UEFI, BIOS, and management controllers that sit beneath an operating system someone else maintains. IoT firmware security covers the entire device image, from bootloader to application, and the device manufacturer is responsible for all of it. IoT devices also stay in the field longer, rarely run endpoint agents, and often depend on the manufacturer for every update.
Can you assess firmware security without source code?
Yes, and often you have no choice. Supplier components, vendor SDKs, and legacy builds routinely arrive as binaries with no source attached. Binary analysis recovers structure, identifies linked libraries, and matches known vulnerable builds through signature comparison. Our team walks through the workflow in black box firmware analysis.
Does secure boot make firmware analysis unnecessary?
No. Secure boot proves the image you shipped is the image that runs. It says nothing about whether that image contains a five-year-old OpenSSL build or a hardcoded credential. Integrity and vulnerability are separate problems, and secure boot only solves the first one. PKfail and CVE-2024-7344 both showed that secure boot is only as trustworthy as the keys and signed binaries behind it, and neither tells you whether the signed image contains a vulnerable component.
Do SBOM requirements apply to firmware?
Yes. The EU Cyber Resilience Act requires manufacturers to draw up an SBOM for products with digital elements, which includes the firmware those products run, with most obligations applying from December 2027. FDA Section 524B already requires a machine-readable SBOM for cyber devices. An SBOM generated from the firmware binary captures statically linked and vendor-supplied components that a build manifest can miss.
How often should shipped firmware be re-analyzed?
Continuously, because the binary stays frozen while the vulnerability data around it does not. A component with zero known CVEs at release can accumulate several within a year. Point-in-time analysis at ship date tells you about a product that no longer reflects current risk.

Larry Pesce
VP of Services
Larry Pesce is a lifelong hacker, educator, and leader in embedded and connected device security. As the Vice President of Services, Larry drives strategic security initiatives across the software supply chain, helping product teams build resilient devices from the ground up. With over 15 years of hands-on penetration testing experience spanning IoT, healthcare, ICS/OT, and wireless technologies, he combines deep technical knowledge with real-world expertise. Larry is also a renowned SANS instructor and co-host of the long-running Paul’s Security Weekly podcast, shaping the next generation of security professionals.