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.
Everything a release needs, in one analysis
Eight capabilities on one product. Start with the firmware image, and add the source when you have it.
- Firmware analysisUnpack the image and read the programs in it
- Components and vulnerabilitiesAn SBOM, with known exploited vulnerabilities first
- Security checks64 checks mapped to the rules you sell under
- Secrets and cryptoDefault passwords, keys and weak algorithms
- Release comparisonWhat changed, and whether each fix is real
- Source codeCode findings and fix pull requests
- Compliance evidenceEach requirement of 17 frameworks
- Release gate and monitoringShip or hold, and alerts after you ship
How an analysis runs
The same four steps for every release, whether you upload it by hand or your CI pipeline sends it.
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.
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.
Match and check
Components are matched to known vulnerabilities, the 64 security checks run, and secrets, crypto and code findings are collected.
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.
- Firmware image
- File systems
- Programs
- Components
- 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
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
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
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
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
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
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
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
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.
| Question | From source manifests | From the firmware image |
|---|---|---|
| What the chip vendor's SDK added as prebuilt binaries | Often missing: prebuilt libraries have no manifest | Found from version strings, linked libraries and signatures |
| Default passwords and keys in the root file system | Only those committed to the repository | Found in binaries, scripts and configuration, shown masked |
| Hardening of the compiled programs | Not visible before the build | NX, PIE, RELRO, stack canary and FORTIFY_SOURCE read for each program |
| A fix backported without a version change | The version still reads as vulnerable | Patch checks read the disassembled code |
| Services left on, such as telnet or FTP | Not visible in most manifests | Read 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.
Questions
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.








