Skip to content
Emberwire OTA firmware delivery

Trust model

A device should refuse our firmware as readily as anyone else's.

Emberwire moves bytes. It is not the thing your device trusts. The device trusts a 32-byte public key burned into it at manufacture, and it verifies every image against a chain that terminates there — whether the bytes came from a delivery node, a technician's laptop or a malicious network.

The assumption we build on

Assume the transport is hostile, the delivery node is compromised, and the platform operator — that is us — is untrustworthy. Under those assumptions a device must still refuse to install anything that is not signed by a key chaining to its own anchor. If that property does not hold, nothing else on this page matters.

The chain of trust

Three signing keys off the device, one anchor on it. The private root never touches an internet-connected machine.

OFF-DEVICE — SIGNING Root key offline HSM · air-gapped 10-year lifetime signs Product-line key ik_meter_g4 2-year lifetime · HSM signs Release key rk_meter_2026q3 rotated every 90 days signs Manifest digest · version · hw release counter 1184 the manifest and the image travel together; both are treated as untrusted until the chain has been checked ON-DEVICE — VERIFICATION 1 · chain check against ROM anchor root_2024 · 32 bytes 2 · digest check SHA-256, streamed per block, then whole 3 · bootloader slot marked valid trial boot, not final 4 · application ew_confirm() or the slot reverts mismatch → discarded, E_DIGEST no confirm → previous slot on next boot Nothing is written to the active slot at any stage. A failure at 1, 2 or 4 leaves the device on the build it booted with.
The only private key that can authorise a firmware image for your devices is, by default, one you hold. Emberwire can operate the signing service for you; it is an option, not the architecture.

Keys

Key Where the private half lives Lifetime Signs If it is compromised
root_2024 Offline HSM, air-gapped, customer custody by default. Used a handful of times a year under dual control. 10 years Product-line keys Recovery requires a factory or field operation. This is precisely why it is offline and why it signs almost nothing.
ik_<line> HSM, brought online only for signing operations. 2 years Release keys for one product line Rotate under the root, publish a revocation entry. Devices learn it from the next manifest they verify; blast radius is one product line.
rk_<line>_<quarter> Your CI's HSM, or the Emberwire signing service if you delegate it. 90 days Manifests Revoke; every release signed by it freezes immediately and devices reject it from the next check-in onward.
device identity On the device. Generated at first boot or provisioned in the factory. device life Its own check-ins That device is quarantined. It cannot sign firmware for anything — device identity authenticates, it does not authorise.

Emberwire holds no key that can produce an image your devices will accept, unless you have explicitly delegated the release key to our signing service. Nothing about the delivery path grants that ability — a delivery node only stores and serves blocks whose digests are already committed to in a signed manifest.

What the device checks, in order

  1. Manifest signature

    Verify the manifest against the release key, the release key against the product-line key, and the product-line key against the anchor in ROM. Any break and the manifest is discarded without a byte of the image being requested.

  2. Revocation and release counter

    Reject a manifest whose release_counter is below the highest the device has already accepted, and reject any key id present in the revocation list carried in the manifest. This is what stops a valid old image being replayed at a device to reintroduce a fixed vulnerability.

  3. Applicability

    Hardware revision, minimum agent version, product line. A manifest for a different board revision is refused even though it is perfectly well signed.

  4. Block digests while streaming

    Each block is hashed as it arrives and compared against the block list committed to in the manifest. A corrupt block is re-fetched — from a different node if that node has now produced three bad blocks — before anything is written.

  5. Whole-image digest

    After staging, the complete slot is re-hashed from flash, not from memory, and compared to the manifest digest. This catches a flash write that silently failed, which is a real failure mode on ageing parts.

  6. Trial boot

    The slot is marked valid-for-trial, never valid-permanent. The permanence comes from ew_confirm() and nothing else.

A signed manifest

GET https://api.{{DOMAIN}}/v1/releases/rel_2026_09_16_a/manifest
{
  "manifest_version": 2,
  "product_line": "pl_meter_g4",
  "version": "4.19.2",
  "release_counter": 1184,
  "published": "2026-09-16T08:41:07Z",
  "image": {
    "id": "img_8f3a21c9",
    "size": 3355443,
    "block_size": 65536,
    "digest": "sha256:4c1b9e77a0d5f382c6be41d09ab7255ef8c3410d6b9a7f2e5c8d1049ab3e77c2"
  },
  "delta_from": [
    { "base": "img_7d1c05b4", "size": 184320,
      "digest": "sha256:91ac3f0e5b2d784419c6ae0d3f5b81726ad4c9e0158f3b6d27ea94c0b5138ef7" },
    { "base": "img_6b90fe23", "size": 402124,
      "digest": "sha256:0d5e4471bb28a90c3f6172ae55d8b04913c7ea6f28b15d90c4e7a3b6218df05a" }
  ],
  "requires": { "hw_rev": ["G4-B", "G4-C"], "agent": ">=2.7.0" },
  "revoked_keys": ["rk_meter_2025q4"],
  "signature": {
    "alg": "ed25519",
    "key_id": "rk_meter_2026q3",
    "chain": ["ik_meter_g4", "root_2024"],
    "value": "b61f0a27c4d9e5138a7f206be4c91d0873ae5f26c0b8194df3a72e6c50918bd4"
  }
}

The agent needs the manifest and the trust anchor to decide. It does not need to reach Emberwire to validate a signature, and it does not accept an unsigned instruction to install anything, from any source, including us.

When a bad update reaches devices

Signed does not mean correct. A perfectly valid image can still break the product, and that case is more common than a forged one.

Blast radius is bounded before it starts

The ramp means a broken build reaches 0.1 % of the fleet before anything else happens. With the default halt rule — 0.5 % failed confirms in the cohort, or 25 consecutive failures — the largest cohort a bad build can reach before the wave stops is the one after the last healthy one.

For a 480,000-device fleet on default settings, a build that fails on every device stops after 480 devices. One that fails on 1 in 50 stops in cohort 2, at 4,800 exposed and roughly 96 actually affected.

Affected devices recover themselves

A device that boots the bad image and cannot confirm reverts on the next boot. No command has to reach it — which matters, because the failure most likely to need a rollback is the one that broke the network stack.

A device that cannot boot the image at all is reverted by the bootloader after the watchdog reset, without the agent running at all.

The release is frozen, not deleted

A halted release stays visible with its full per-device record: who was offered it, who downloaded it, who confirmed, who rolled back, and with what error code. You need that to decide whether the next build fixes the problem.

Forward-fix path

Devices stuck in a rollback loop — confirmed failure on the same build three times — are moved into a quarantine cohort and excluded from the selector until you explicitly target them, so a fix can be aimed at exactly those devices and nothing else.

Platform side

Tenant isolation

Images, manifests, device records and audit logs are scoped to one customer namespace. Delivery nodes serve content-addressed blocks and hold no cross-tenant index. A block is reachable only by a device presenting a manifest that commits to its digest.

Operator access

Access to production requires hardware-backed multi-factor authentication and is logged per action. Operators cannot read customer private keys, because the platform does not hold them in the default configuration.

Audit export

Per-device state transitions are exportable as signed JSONL for the full retention period — 24 months on the Fleet plans. Regulated metering customers use this directly in their filings.

Transport

TLS 1.3 to the control plane and to delivery nodes, with per-session node pinning. Transport security is a privacy and integrity measure for check-in metadata; it is deliberately not part of the firmware trust decision.

Data retained

Device identifier, product line, current and previous build, state transitions with timestamps, error codes, and coarse region. No payload from your application, no user data, no precise location.

Reporting a vulnerability

Write to security@{{DOMAIN}}. We acknowledge within two business days, agree a disclosure timeline of up to 90 days, and credit reporters who want it. Findings that affect the agent are published in the changelog.