Know what is inside every firmware you ship

Your firmware carries code from chip vendors, open-source projects and contractors. See every component, known vulnerability, secret and failing security check in it, and what changed since your last release, every day after you ship.

Request access
The release overview for OWASP IoTGoat router v1.0, a deliberately vulnerable training firmware: blocked on all three gate rules, with 30 critical issues, 11 known exploited vulnerabilities and what is inside.
The release overview of OWASP IoTGoat, a deliberately vulnerable training router firmware.

How an analysis runs

The same four steps for every release, whether you upload it by hand or your CI pipeline sends it.

  1. Bring the image and the source

    Upload an image of up to 8 GiB or import it from a GitHub or GitLab release, and connect the source if you have it. A supplier's SBOM can stand in for an image.

  2. Unpack and read

    Our own readers unpack file systems, vendor formats and microcontroller images, then disassemble the programs. With runtime evidence on, programs from the image also run under emulation in a separate isolated job.

  3. Match and check

    Components are matched to known vulnerabilities, the 64 security checks run, and secrets, crypto and code findings are collected.

  4. Decide, report and watch

    Your release rules say ship or hold, reports go to auditors and customers, and shipped releases are matched again every day.

Firmware analysis

See what the SDK put in your image

Upload an image of up to 8 GiB, or import one from a GitHub or GitLab release. Our own readers unpack Linux file systems, vendor wrappers and bare-metal images such as ESP32 and Cortex-M, then disassemble the programs.

Each program is read for its architecture, libraries and hardening, and its functions are mapped into a call graph, so later checks can say whether a vulnerable function is actually called.

  1. Firmware image
  2. File systems
  3. Programs
  4. Components
  5. Findings
  • 22 instruction sets disassembled, from ARM and MIPS to Xtensa and RISC-V
  • Containers unpacked up to six levels deep
  • Archive and decompression bombs refused
  • Unreadable parts listed as coverage gaps, with the reason
Formats and processors
Components of the OWASP IoTGoat router training firmware, among them kernel 4.9.152, mbedtls 2.12.0, dnsmasq 2.73 and busybox 1.28.4, with licence, vulnerabilities and the upgrade that fixes them.

Components and vulnerabilities

Know which flaws attackers already use

Every component with its version and licence, from package databases, version strings, linked libraries and signatures for common embedded software, exported as an SBOM in CycloneDX 1.6 or SPDX 2.3. Components are matched to NVD and OSV, ranked with CISA KEV and EPSS, and function use says whether your programs call the vulnerable function.

Your team records whether each vulnerability affects the product, as VEX in CycloneDX, OpenVEX or CSAF 2.0, and those decisions are kept when the data is refreshed.

  • Known exploited vulnerabilities first, from CISA KEV
  • Severity, EPSS probability and the version that fixes each one
  • SBOM per release, per product or per repository
  • A supplier's SBOM analysed when you have no image
How matching works
Vulnerabilities in the OWASP IoTGoat router training firmware, known exploited kernel flaws first, with the component, severity, function use, whether each applies and the version that fixes it.

Security checks

64 security checks, mapped to the rules you sell under

A check passes only when every test behind it ran clean. When an image cannot decide, the check says what evidence it needs. Each check feeds the requirements of every framework it maps to, so one analysis fills the evidence for several markets.

  • Credentials and keys
  • Cryptography
  • Binary hardening
  • Secure boot
  • Updates
  • Attack surface
  • Known vulnerabilities
  • Scripts and web interface
  • Runtime behaviour
All 64 checks
Security checks on the OWASP IoTGoat router training firmware: 27 of 64 fail, among them hard-coded root password hashes and MD5 password hashes, each with the evidence behind it.

Secrets and cryptography

Find default passwords and keys left in the image

Hard-coded passwords, private keys, tokens and default camera accounts are found in images and in source code, and shown masked. A private key shared by every device, an empty password or an extra root account is flagged on its own.

The crypto inventory lists keys, certificates and algorithms, and flags weak ones such as MD5, DES or RSA keys under 2048 bits, along with expired certificates and TLS library settings that allow old protocols.

  • 58 credential formats recognised in source code
  • Evidence masked before results leave the engine
  • The release gate can fail on any hard-coded credential
Secrets and crypto in detail
Findings for the OWASP IoTGoat router, a deliberately vulnerable training firmware, and its source: hard-coded root password hashes, a shell command built from request input and telnet enabled.

Release comparison

Prove an update fixed what it promised

Compare two releases: components, vulnerabilities, programs and functions, findings and security checks. Patch checks read the disassembled code and give each vulnerability a state, fix verified, patch candidate or still vulnerable, even when the version string did not change.

The last release's open findings are retested on the new one by fingerprint, so fixes show as fixed and regressions are flagged.

  • Components added, removed, upgraded and downgraded
  • The last release's open findings retested on the new one
  • A delta report to share as a PDF
Patch verification
The delta between DVRF v0.2 and v0.3, the Damn Vulnerable Router Firmware used for training: no new vulnerabilities, 92 critical ones in both releases and the coverage that limits the comparison.

Source code

Fix it in the code, not just the image

Connect GitHub, GitLab, Bitbucket or Azure DevOps, or upload an archive. 1,784 rules read firmware and device code first: embedded C and C++, Lua, shell and CGI scripts, device web interfaces and build configuration, plus your companion app and cloud backend.

Each finding says why it matters and how to fix it. Exact dependency upgrades open as pull requests on a new branch, never merged for you, and the source is deleted once its scan finishes unless your agreement sets a period.

  • Untrusted input traced across files, up to three calls deep
  • Automatic upgrades: one pull request per package, at most five open
  • Code findings beside the firmware findings of the same product
Languages and rules
Code findings in the OWASP IoTGoat source: a shell command built from request input in a LuCI handler, a script that starts telnet, unescaped output and a missing CSRF check, each with file, line and CWE.

Compliance evidence

Evidence for every market you sell in

Each analysed release is assessed against the requirements of 17 frameworks for India, the EU, the UK, the US and international standards. Every requirement shows what passed, what failed and what still needs your evidence.

Your team adds documents, test reports and procedures where the checks cannot decide, and the evidence pack lists who added each item and when.

  • MeitY ER-01 and NCCS ITSAR for India
  • The EU Cyber Resilience Act and EN 18031, for products sold in the EU
  • UK PSTI, ETSI EN 303 645, NIST IR 8425 and IEC 62443-4-2
Compliance by market
Compliance for the OWASP IoTGoat router training firmware sold in India, the EU, the UK and the US: 23 of 556 requirements met, 128 gaps and 401 needing evidence across 14 frameworks.

Release gate and monitoring

Gate risky releases, and monitor what you shipped

Your release rules say ship or hold, with the reasons, and accepting a risk takes a second person. A kernel vulnerability counts toward the gate only when the image shows its driver is built in, or it is known exploited; the rest are listed as unverified. Leads from binary taint never hold a release on their own. A CI token lets your pipeline upload each build and fail on the gate.

Shipped releases are matched against new vulnerability data every day, with alerts by email, Slack, Microsoft Teams and webhooks. Reports are signed PDFs: readiness reports, evidence packs, SBOM and VEX, device passports and management summaries.

  • Quiet hours from 22:00 to 07:00 India time, never for known exploited alerts
  • Reports signed with Ed25519
  • A release check step for Jenkins, GitHub Actions, GitLab CI, Azure DevOps and Bitbucket, ready in the app
Reports from the training firmware analyses: a device passport, an evidence pack and a readiness report for the DVID training board, and the SBOM and VEX for the OWASP IoTGoat router.

What the built image shows that manifests do not

Source scanners read what your manifests declare. The image is what ships, and some questions only it can answer. Connect the source too, and code findings sit beside the firmware findings of the same product.

What the built image shows that manifests do not
QuestionFrom source manifestsFrom the firmware image
What the chip vendor's SDK added as prebuilt binariesOften missing: prebuilt libraries have no manifestFound from version strings, linked libraries and signatures
Default passwords and keys in the root file systemOnly those committed to the repositoryFound in binaries, scripts and configuration, shown masked
Hardening of the compiled programsNot visible before the buildNX, PIE, RELRO, stack canary and FORTIFY_SOURCE read for each program
A fix backported without a version changeThe version still reads as vulnerablePatch checks read the disassembled code
Services left on, such as telnet or FTPNot visible in most manifestsRead from init scripts, configuration and the programs present

Works with the tools your team already uses

  • Code hosts

    GitHub, GitLab, Bitbucket and Azure DevOps, or a zip or tar.gz upload. Firmware images import from GitHub and GitLab releases.

  • CI pipelines

    A release check step for Jenkins, GitHub Actions, GitLab CI, Azure DevOps and Bitbucket Pipelines, with the token read from the CI secret store.

  • Alerts

    Email, Slack and Microsoft Teams, and up to five webhooks signed with HMAC SHA-256.

  • Exports

    CycloneDX 1.6 and SPDX 2.3 SBOMs, VEX as CycloneDX, OpenVEX or CSAF 2.0, and CSV, JSON and signed PDF.

  • Your AI tools

    Read results over MCP with a personal read-only key, valid for 1 to 90 days and revocable at any time.

  • Your AI provider

    OpenAI-compatible APIs, Anthropic, Google Gemini, Amazon Bedrock, Azure OpenAI or your own model server.

Built for the whole product team

Engineers, security, compliance and management work on the same releases, each with the access their role needs.

  • Four roles

    Owner, admin, analyst or viewer. Viewers read, analysts do the analysis work, and settings and keys stay with owners and admins.

  • Two-step sign-in

    People join by invitation, from our team or their own admins, and sign in with a password, Google Workspace, Microsoft 365 or single sign-on, always followed by an authenticator code.

  • An audit log

    Sign-ins, changes and decisions with the person, the target and the country, which the app cannot change or delete.

AI

Bring your own AI (BYOK)

Full results without AI: every finding comes from FDIE's own rules and engines. Bring your own AI key (BYOK) and your AI makes them sharper. AI writes each analysis's summary and priorities, explains the top findings, explains what each program and function does, suggests names for stripped functions, reviews network-facing code, checks whether fixes are present, judges whether each vulnerability applies to your product, identifies unknown components, sorts real secrets from test values, triages findings, explains alerts and suggests risk scores. It also answers questions on a finding and suggests code fixes that a person opens as pull requests.

  • Your provider, your key

    An admin pastes the key; the provider is recognised, and the key is saved only when the model answers. Keys are encrypted and never shown again.

  • Proposals only

    AI never changes evidence, and a person accepts or rejects every proposal. Each answer is labelled with the model that gave it.

  • Spending you control

    Monthly and per-analysis limits, or rules only. Without a key, every result still comes from the rules and engines.

  • Your data and training

    MAGDOX never uses your data, including your code, firmware, findings, files and personal data, to train any artificial intelligence or machine-learning model. If your organisation connects its own AI provider, that provider's handling of the data it receives, including whether it trains on it, is governed by your organisation's own agreement with it.

Runtime evidence

Emulation

Runtime evidence runs programs from the image under emulation instead of only reading them, and checks the device's services live. Firmware is read, unpacked and examined without running it. When runtime evidence is on (on Business by default, on the paid pilot on request), programs from the image also run under emulation in a separate isolated job, with the firmware's own network refused. What it observes joins the findings, the device checks and the network services.

How emulation works
Which firmware can it read?

Embedded Linux images with SquashFS, UBIFS, ext4 and other file systems, vendor formats such as uImage and TRX, UEFI firmware, and bare-metal images for ESP32, Cortex-M and other microcontrollers in Intel HEX, S-record, UF2 and DfuSe files. The full list, with the formats tested on sample files only, is in the technical details.

Is anything in my image run?

Only with runtime evidence. Both engines read the image or the source without running anything in it; with runtime evidence on (on Business by default), programs from the image also run under emulation in a separate isolated job, with the firmware's own network refused.

Do I need an AI provider?

No. Without a key, every analysis, check and report comes from our rules and engines. MAGDOX never supplies AI: with your own key, AI explains and proposes, and people decide.

Do I need the source code?

No. A firmware image on its own gives you components, vulnerabilities, security checks, secrets, delta and patch checks. Connecting the source adds code findings to the same product.

What happens when part of an image cannot be read?

It is listed as a coverage gap with the reason: a format without a reader, encrypted content or a limit reached. What was unpacked is still analysed, and an image encrypted throughout fails with a reason.

Can we analyse a supplier's SBOM instead of firmware?

Yes. A release can be analysed from a CycloneDX 1.4 to 1.6, SPDX 2.2 or 2.3, or SPDX 3.0 SBOM of up to 20 MiB. What only the firmware shows, such as the security checks, is marked as not available.

Can our CI pipeline stop a risky build?

Yes. A CI token lets your pipeline upload each build and wait for the release gate, then fail the build when the gate says hold. Tokens last 30 to 365 days, are shown once and only their hash is kept.

How are vulnerabilities matched?

Components with a package URL are matched against OSV's version ranges, the others against NVD's CPE ranges, then ranked by CISA KEV and EPSS. Your team's decisions are kept when the data is refreshed.

See what is inside your next release

Book a 30 or 45 minute demo with the team that builds FDIE, or request access for your organisation.

Request access