Request a firmware review
Menu
About 23 minutes to read

Rollback vs anti-rollback: recovering without downgrade risk

Reader question: How do we let devices recover from a bad update while still blocking attackers from installing older, vulnerable firmware?

Micrograph-style illustration of the bordered pits in a pine wood cell wall, each round pit with a central plug that seals in one direction, with one pit tinted amber.

Run two separate mechanisms. Recovery rollback boots a new image on trial and returns to the previous image unless the new one confirms itself after a self-test; firmware anti-rollback keeps a security counter in trusted, one-way storage and refuses any image whose counter is below it. They stop fighting each other when the counter rises only after the new image has confirmed, and only for releases that fix a vulnerability you never want reinstalled. MCUboot’s hardware downgrade prevention works this way for test swaps, and ESP-IDF raises its eFuse secure version when the application marks itself valid.

This article is for the firmware engineer or security lead writing a startup’s update and downgrade policy before launch. It separates the two meanings of “rollback”, shows how MCUboot, ESP-IDF, Trusted Firmware-M and one vendor’s Wi-Fi SoC implement each, explains the failure where the downgrade floor rises too early, and ends with a policy and a test plan you can adopt.

Two mechanisms that share a name

“Rollback” means two opposite things in firmware. Recovery rollback puts an older image back when a new one fails. Anti-rollback, also called downgrade prevention or rollback protection, stops an older image from being installed at all. A product that is updated in the field needs both, and they must be designed together.

Recovery rollback Anti-rollback
Protects against A bad release: a crash loop, a broken driver, a device that cannot reconnect An attacker installing an old, validly signed image that has a known vulnerability
Who triggers it The bootloader, when a new image fails to confirm The bootloader, on every update and boot
Where state lives Image trailer or OTA metadata in ordinary flash A counter in trusted, usually one-way storage: eFuse, OTP or a protected non-volatile counter
Moves backward? Yes, that is its purpose Never; it only rises
Failure if misconfigured A bad image stays installed Devices refuse the only image that works, or accept images they should refuse

The threat anti-rollback answers is specific. IETF RFC 9124, the manifest model for IoT firmware updates, describes it as an attacker who “sends an old, but valid, manifest with an old, but valid, firmware image to a device”, where a known vulnerability in that image lets the attacker “gain control of the device”. Signatures do not stop this, because the old image was signed by you. Only a rule about which versions are acceptable does.

The two mechanisms pull against each other. Recovery rollback needs the previous image to remain bootable until the new one is proven. Anti-rollback wants the previous image to become unbootable as soon as possible. The rest of this article is about where to draw that line.

How recovery rollback works: test, confirm, revert

Recovery rollback is a trial boot. The bootloader runs the new image once, the image checks itself, and if it does not explicitly confirm before the next reset, the bootloader puts the previous image back. Everything depends on the image confirming only when it has evidence that it works.

MCUboot swap types

The MCUboot design document names the outcomes as swap types. The ones that matter here:

  • BOOT_SWAP_TYPE_TEST: “Boot the contents of the secondary slot by swapping images. Unless the swap is made permanent, revert back on the next boot.”
  • BOOT_SWAP_TYPE_PERM: “Permanently swap images, and boot the upgraded image firmware.”
  • BOOT_SWAP_TYPE_REVERT: “A previous test swap was not made permanent; swap back to the old image whose data are now in the secondary slot.”

The state lives in the image trailer at the end of each slot. After a test swap, the primary slot’s image_ok flag is unset; after a permanent swap it is already set. The running image makes a test swap permanent by setting image_ok. In Zephyr that is one call, boot_write_img_confirmed(), and the update agent chooses the mode when it marks the new image, with boot_request_upgrade(BOOT_UPGRADE_TEST) (“run image once, then confirm or revert”) or BOOT_UPGRADE_PERMANENT (“run image forever”), per Zephyr’s MCUboot API header. The signing tool can also pre-mark an image: imgtool’s --test and --confirm options set the trailer when padding, per the imgtool documentation.

Direct-XIP mode, where the device runs from either slot in place, has an equivalent. With MCUBOOT_DIRECT_XIP_REVERT enabled, the bootloader picks the newest image by version, and if an image that was selected on a previous boot never marked itself “OK”, it erases that image and falls back to the previous one.

ESP-IDF app rollback

ESP-IDF calls the same idea app rollback, enabled with CONFIG_BOOTLOADER_APP_ROLLBACK_ENABLE. Its OTA documentation describes the states: a newly installed image is ESP_OTA_IMG_NEW, becomes ESP_OTA_IMG_PENDING_VERIFY on first boot, and the application then calls esp_ota_mark_app_valid_cancel_rollback() if its diagnostics pass or esp_ota_mark_app_invalid_rollback_and_reboot() if they fail. If the device resets before either call, “the application is rolled back”, so “a new application has only one attempt to boot successfully”. The state is kept in the otadata partition, not in the image.

What the self-test should prove before it confirms

The confirm call is the most important line in the update path, because after it the previous image is gone as a fallback. Confirm too early and recovery rollback protects nothing; never confirm and every update reverts. A useful self-test checks the things a bad release most often breaks:

  1. The application reached its main loop and every task or thread started.
  2. Each sensor and peripheral the product depends on answered, with plausible readings.
  3. Persistent settings were read and, if the format changed, migrated without error.
  4. The device reconnected to the network it reports to, such as a gateway or cloud endpoint.
  5. The device can still receive the next update. Confirm only after the update channel has been exercised, because an image that cannot download a fix cannot be fixed.

Put a time limit on the whole sequence and let the watchdog reset the device if the self-test hangs; an unconfirmed image that resets is reverted, which is the outcome you want. How the slot layout affects revert, power loss and flash wear is covered in A/B versus single-slot updates.

Check the counter before you download

The bootloader enforces the floor, but the update agent should check it first. An image that will be refused still costs a full download, radio time and battery, and MCUboot may then erase it: in v2.4.0, an image refused by the swap-mode downgrade check is scrambled with the log line “Image %d in slot 1 erased due to downgrade prevention”. ESP-IDF recommends the same early check. If the server might offer an image with a lower security version, “you have to get new_app_info.secure_version from the first package of an image and compare it with the secure version of efuse”, using esp_efuse_check_secure_version(), and abort the download if it fails.

On MCUboot the equivalent is to read the new image’s header and protected TLVs as soon as they arrive, compare its security counter with the device’s stored value, and stop early if it is lower. Report the refusal to the update service with both numbers, so a misconfigured release shows up on a dashboard instead of as a fleet of devices quietly re-downloading the same image.

How anti-rollback works: version, security counter and one-way storage

Anti-rollback compares a number in the new image against a number the device already trusts and refuses the image if it is lower. Implementations differ in which number they compare and where the trusted value lives, and those two choices decide what the protection is worth.

Comparing against the other slot

MCUboot’s software-based downgrade prevention, MCUBOOT_DOWNGRADE_PREVENTION, compares the new image’s version with the image currently in the primary slot. The design document describes it as available with overwrite-only upgrades; in the v2.4.0 source and its Kconfig for Zephyr builds it is also applied in swap modes, optionally using the images’ security counters instead of versions. Either way, the reference is whatever sits in flash, and the Kconfig help is candid: the mechanism “only protects against some attacks against version downgrades (for example, a JTAG could be used to write an older version).”

Comparing against a trusted counter

Hardware-based downgrade prevention, MCUBOOT_HW_ROLLBACK_PROT, is the stronger form. “Each signed image can contain a security counter in its protected TLV area”, added with imgtool’s -s option, and the new image’s counter “will be compared with the currently active security counter value which must be stored in a non-volatile and trusted component of the device.” The target supplies the storage through MCUboot’s security counter interface. MCUboot’s Kconfig for Zephyr builds adds that “any upgrade must have greater or equal security counter value”.

Trusted Firmware-M, which uses MCUboot as its second-stage bootloader, describes the same counter as “an independent (from the image version) counter to ensure rollback protection”. It says the last valid counter should be kept “in a non-volatile and trusted component of the device and its value should always be increased if a security flaw was fixed in the current image version.”

eFuse and OTP

Some chips keep the floor in fuses that can only be set, never cleared. On the ESP32, ESP-IDF’s anti-rollback (CONFIG_BOOTLOADER_APP_ANTI_ROLLBACK) compares the image’s secure_version, set with CONFIG_BOOTLOADER_APP_SECURE_VERSION, against an eFuse field in which “The number of bits set in this register is the security_version from app.” Because a programmed eFuse bit “can never be reverted to 0”, the field is a one-way counter with a fixed number of steps.

Silicon Labs’ SiWG917 Wi-Fi SoC does the same for its network processor firmware. Its firmware fallback guide says that “Once the NWP firmware is verified to be working as expected”, an API call burns the security version into one-time programmable memory, and the bootloader then switches slots only to firmware with a higher security version. “Security version burned in OTP can only be increased.”

Where the counter can live

The counter is only as strong as the storage behind it. MCUboot leaves the storage to the platform, through the security counter interface in security_cnt.h, and TF-M asks only for “a non-volatile and trusted component of the device”. On a real chip that means one of a few options, and the reference manual decides which you have:

  • Fuses or one-time programmable bits, as on the ESP32 and the SiWG917. They cannot be cleared, which is the point, and they cannot be recovered from a mistake, which is the cost.
  • A monotonic counter in a protected region, such as storage that only secure-world code can write on a chip with an isolated security partition.
  • A secure element on the board, if the product already carries one for keys.
  • A value in ordinary internal flash, protected only by firmware. This is no stronger than software downgrade prevention against anyone who can write flash, so treat it as a stopgap until the debug port is locked and the hardware option is wired in.

Check this before the board is final. A part with no one-way storage pushes the whole design toward “update on command” with the floor held by a backend, which protects less.

Version comparison details that catch teams out

When an implementation compares versions rather than counters, read exactly what it compares. MCUboot’s image header holds major, minor, revision and build number, and MCUboot’s Kconfig for Zephyr builds notes that “By default, the image version comparison relies only on version major, minor and revision”; the build number counts only with BOOT_VERSION_CMP_USE_BUILD_NUMBER. Two builds of 1.2.0 with different build numbers therefore look identical to the comparison unless you enable that option. Pre-release labels such as “rc2” are not in the header at all; the version scheme builder warns that MCUboot “compares only the numbers, not the pre-release tag”.

Direct-XIP adds one more subtlety. The bootloader always prefers the higher version, and Zephyr’s sysbuild help text for direct-XIP with revert warns that once a higher version is approved, “it is not possible to select lower version for boot”, but also that “MCUboot may do that if application with higher version will not get confirmed.” Version selection is not the same thing as a trusted floor.

What the counter does not protect

Anti-rollback does not stop an attacker who can sign images; key protection does that. It does not stop someone with debug access from rewriting flash, unless the debug port is locked and the counter lives somewhere the debugger cannot reach. And RFC 9124 notes a subtler case: a device that has been offline for a long time can be offered an image that is newer than the one it runs but older than the latest, which a counter alone will accept. Keys and debug locking are covered in firmware signing key management and on our firmware security services page.

Where the two collide: raising the floor before the image is proven

The dangerous moment is the gap between “the new image booted” and “the new image works”. If the counter rises inside that gap, the previous image becomes unbootable while the new one is still on trial, and recovery rollback has nowhere to go. Every implementation handles this gap differently, and you need to know which behavior your configuration gets.

MCUboot’s own source shows the rule. In loader.c at v2.4.0, the function that updates the hardware counter explains: “In case of a successful image swapping when the swap type is TEST the security counter can be increased only after a reset, when the image has marked itself ‘OK’ (the image_ok flag has been set). This way a ‘revert’ can be performed when it’s necessary.” For a permanent swap the code does the opposite: “In case of a permanent image swap mcuboot will never attempt to revert the images on the next reboot. Therefore, the security counter must be increased right after the image upgrade.” Overwrite-only upgrades also update the counter immediately after copying. In direct-XIP mode, the counter waits for image_ok only when the revert option is enabled.

Download to slot 2 Swap, boot new image Self-test on device Confirm image_ok set Raise floor next boot fails, or resets first Revert old image runs Floor rises at the swap: permanent swap or overwrite-only, so no revert Floor rises after confirm: test swap, direct-XIP with revert, ESP-IDF
Figure 1. When the downgrade floor rises relative to the trial boot. Source: MCUboot v2.4.0 loader.c comments and ESP-IDF OTA documentation, checked November 2026; the timeline is simplified to one image.

ESP-IDF follows the safe order by design. Its anti-rollback scheme says the application “should perform diagnostics of the operation and if it is completed successfully, you should call esp_ota_mark_app_valid_cancel_rollback() function to mark the running application with the ESP_OTA_IMG_VALID state and update the secure version on chip.” The one exception it documents is a first image loaded over a serial connection when otadata is blank, for which “the secure version of efuse will be immediately updated in the bootloader.”

Implementation and modeWhen the trusted floor risesCan the device still revert during the trial?
MCUboot, swap, test upgrade, hardware counterOn the boot after the image sets image_okYes
MCUboot, swap, permanent upgradeRight after the swapNo
MCUboot, overwrite-onlyRight after the copyNo; there is no old image to revert to
MCUboot, direct-XIP with revertOn the boot after the image sets image_okYes
MCUboot, direct-XIP without revertWhen the selected image is validated and bootedNo
ESP-IDF anti-rollback with app rollbackWhen the app calls esp_ota_mark_app_valid_cancel_rollback()Yes, to images at or above the eFuse version
SiWG917 network processorWhen the application calls the burn API after verifying the firmwareYes, until the burn
Figure 2. When each implementation raises the downgrade floor. Sources: MCUboot v2.4.0 loader.c, ESP-IDF OTA documentation and Silicon Labs UG625 (WiSeConnect 4.0.2), checked November 2026.

The practical rule follows directly: if you enable a hardware counter, deliver updates as test upgrades and confirm from the application after the self-test. Marking images permanent at signing time, or choosing overwrite-only, trades away the trial period the moment the counter changes.

Choosing when the floor moves: automatic or on command

There are two ways to decide that a new image is good enough to raise the floor: the device decides for itself after a successful boot, or a trusted management service tells it to. MITRE’s embedded threat model describes both and the risk each carries.

MITRE EMB3D’s mitigation MID-030, “Firmware Rollback Protections”, rated foundational, frames the goal as making sure that “once new firmware has been deployed and is confirmed to be operational on the device, older firmware cannot be deployed again”. It names two implementations:

  • Automatic update on reset. The boot code raises the reference version “when a newer version has been successfully loaded” and has passed secure boot checks. This leaves no window for an attacker, but “if there are errors in the firmware the user cannot revert to the last-known-good copy.” The vendor can still go back “by repackaging the firmware and distributing it with new version numbers.”
  • Update on command. The reference version rises “in response to a secure message from an authorized management service”, only after that service signals that the new version has no identified faults. Devices can revert until then, but they “are left vulnerable during the window”, and blocking the completion message becomes a denial-of-service route.

MCUboot’s test-swap behavior and ESP-IDF’s mark-valid call sit between the two: the device raises the floor itself, but only after its own self-test passes. That is usually the right default for a startup fleet, because it does not depend on a cloud message reaching every device.

Update on command is worth its complexity when a self-test cannot see the failures that matter, for example a sensor drift that shows up only in fleet data after days. Then the device confirms the image locally to stop it reverting, but the counter rises only when the backend, after the rollout’s soak period, sends a signed instruction. Silicon Labs’ burn API is shaped for this: the application decides when to call it.

A simple way to choose:

  • Raise the floor automatically after confirm when the self-test can detect the failures that would make you want the old image back, when devices may go weeks without reaching your backend, and when the fleet is small enough that a staged rollout already limits exposure.
  • Raise it on command when the important failures only show up in fleet data, when your backend reliably reaches every device, and when you can sign and track a per-release instruction.
  • Either way, write the choice into the release notes for every release that changes the counter, so support and security staff know which images devices will still accept.

Whichever model you pick, MITRE adds a warning: “If an attacker can spoof the anti-rollback references to increment the versions, the device could be rendered inoperable.” Only authenticated code paths may raise the counter. MCUboot offers MCUBOOT_HW_DOWNGRADE_PREVENTION_LOCK, which locks counter updates before the application boots so that it “prevents the application from accidental updates of the counter, that may invalidate the currently running image.”

Keep the security counter separate from the version number

The image version tells people what changed; the security counter tells the bootloader which old images are no longer safe. Keeping them separate lets you rebuild and ship an old codebase when you need to, and it saves the counter’s limited steps for releases that actually close a vulnerability.

The MCUboot design document lists the benefits of handling the counter “independently from image version number”: “It does not need to increase with each software release”, and “It makes it possible to do software downgrade to some extent: if the security counter has the same value in the older image then it is accepted.” TF-M says the counter “can be independent from the image version, but not necessarily”. Both tools will derive it from the version if you let them: imgtool’s -s auto “automatically generate[s] it from the image version”, and TF-M’s scripts do the same when no counter is set.

Deriving the counter from the version is convenient and usually wrong for a product. Every release would then raise the floor, and every release would become the oldest image the device can ever run again.

RFC 9124 makes the same separation at the manifest level. Its monotonic sequence number exists “to prevent malicious actors from reverting a firmware update against the policies of the relevant authority”, but “This is not a firmware version field.” As the RFC puts it, “A firmware version may be rolled back by creating a new manifest for the old firmware version with a later sequence number.” A sanctioned downgrade is a new, signed decision, never the reuse of an old one.

Counters are a budget

One-way storage runs out. ESP-IDF states that on the ESP32 “The number of bits in the secure_version field is limited to 32 bits. This means that only 32 times you can do an anti-rollback.” MCUboot has a Kconfig option, MCUBOOT_HW_DOWNGRADE_PREVENTION_COUNTER_LIMITED, for counters with a limited number of updates; when it is set, MCUboot checks whether the counter can still be updated and rejects an image whose counter it cannot store. Spend the steps on security fixes, not releases.

Release What changed Security counter Why
1.0.0 First field release 1 Baseline
1.0.2 Bug fixes 1 Nothing in 1.0.0 is unsafe to run again
1.1.0 Feature, plus a security fix 2 Images before 1.1.0 carry the flaw
1.1.1 Fix for a 1.1.0 regression 2 No new security fix
1.2.0 Features 2 Rebuilding 1.1.1 as 1.2.1 stays possible

Products with more than one image

Many products run more than one updatable image: a secure-world image and an application, an application and a radio-core image, or a host application and a Wi-Fi network processor. Each image needs its own trial, its own confirm and its own counter, and the images must not be allowed to drift into combinations you never tested.

TF-M shows the pattern. In multiple-image boot, the secure and non-secure images “are signed independently with different keys and they can be updated separately”, and each has its own counter, set with SECURITY_COUNTER_S and SECURITY_COUNTER_NS. A security fix in the secure image raises only the secure image’s counter, so an application release that does not touch security code leaves the application floor alone.

Separate counters solve one problem and create another: a new application may depend on an interface that only the new secure image provides. MCUboot handles this with dependencies. imgtool’s -d option will “Add dependence on another image”, in the form (<image_ID>,<image_version>), so the bootloader will not run an application against a secure image older than the one it needs.

The SiWG917 is the same story with a different split. Its network processor firmware has its own slots, its own fallback and its own security version in OTP, separate from the application firmware. Your update policy has to name each image, its counter, who raises it and which combinations are allowed. Dual-image layouts and radio cores are covered in more depth in A/B versus single-slot updates.

How to ship a fix when the newest release is bad

When a release turns out to be bad after devices have confirmed it, you roll forward: you ship a new image with a higher version and a counter at or above the current floor. Whether that new image can contain the old code depends on whether the bad release raised the counter.

There are three cases:

  1. The bad image never confirmed. Recovery rollback already handled it; devices are back on the previous image. Fix the bug and release again.
  2. The bad image confirmed but did not raise the counter. Rebuild the previous good code with a higher version number and the same counter, and ship it as a new release. The bootloader accepts it, because its counter equals the floor. With version-based selection, such as direct-XIP, the higher version is what makes the bootloader choose it.
  3. The bad image confirmed and raised the counter. Older images are now refused, as designed. The fix has to be built on the bad release’s code, or on older code with the security fix ported in, and carry a counter at least equal to the new floor.

Case 3 is the reason to raise the counter only after the trial period, and to limit how many devices can reach it before you know a release is sound. A staged rollout does the second part: a small first wave, a soak period and a written halt rule. How to choose the waves and the health signals is in staged firmware rollouts, and keeping the last good image signed and ready is part of the firmware release checklist.

A worked example: one security fix on a pilot fleet

The rules above are easier to judge on a concrete release. The fictional example below follows the site’s soil-probe startup through the release that first raises its counter.

Example (fictional). Loamwick’s LW-1 soil probes run Zephyr and MCUboot with a swap upgrade and two 448 KB slots. The team enabled hardware downgrade prevention before the field trial and keeps the counter in a protected non-volatile counter on the probe’s microcontroller. Releases 1.0.0 and 1.0.2 both carry security counter 1.

Release 1.1.0 fixes moisture readings that drifted upward in wet clay, and it adds a security change: the probe now refuses images signed with the retired development key. Older images would still accept that key, so 1.1.0 carries security counter 2. The update agent marks each download as a test upgrade with boot_request_upgrade(BOOT_UPGRADE_TEST). On first boot the image reads both sensors, opens a Bluetooth LE connection to the gateway and checks that the gateway can offer an update, then calls boot_write_img_confirmed(). On the next boot MCUboot raises the stored counter to 2.

Wave 1 goes to the team’s 4 bench probes. One Rev C probe fails its sensor check, never confirms, resets on the watchdog and reverts to 1.0.2, whose counter 1 is still accepted because the floor has not moved on that probe. The halt rule (any probe that rolls back or goes silent) stops the rollout. The team fixes a sensor start-up timing issue on Rev C, ships 1.1.1 with counter 2, and restarts at wave 1. After 48 hours of soak per wave, 12 trial probes and then the remaining 24 confirm 1.1.1, and every probe’s floor ends at 2.

Had the update agent requested a permanent upgrade, or had 1.1.0 been signed pre-confirmed with imgtool’s --confirm, the swap would have been permanent and the counter would have risen before the sensor check, leaving that Rev C probe on a failing image it could not leave.

The fictional project’s full timeline is on the example project page.

How to test rollback and anti-rollback before launch

Both mechanisms fail silently until the day you need them, so test them on real boards before the first production release and again whenever the bootloader or its configuration changes. Each line below is a pass-or-fail test you can automate.

Test How to run it Pass condition
Unconfirmed image reverts Install an image that never calls confirm; let the watchdog reset it Previous image boots; counter unchanged
Failed self-test reverts Force the self-test to fail on the new image Previous image boots; counter unchanged
Power loss before confirm Cut power during the trial boot Device recovers to a bootable image
Confirm raises the floor Install an image with a higher counter; let it confirm; reboot Stored counter equals the new image’s counter
Older counter refused Offer a validly signed image with a lower counter Image rejected; running image unaffected
Equal counter accepted Offer an older version with the same counter, in a swap or overwrite build with only the hardware counter enabled Image accepted
Permanent mark blocked Try to install an image pre-marked as confirmed, if your policy forbids it Your update agent or CI rejects it
Counter at its limit On a test board, step the counter to its maximum Behavior matches your plan, documented
Application cannot raise the counter Try to raise it from application code Attempt fails

The counter tests consume one-way storage, so run them on boards set aside for the purpose and label them; a board whose fuse counter has been raised cannot run your older test images again. Interrupted-update and revert tests belong in an automated rig that runs on every release candidate; firmware testing with CI and hardware in the loop covers how to build one.

A downgrade policy you can write down

A downgrade policy is a short document that says which images a device may run, who decides when the floor rises, and how the team recovers from a bad release. Write it before launch, because the first security fix is a bad time to discover that your counter rises on every build.

  1. Two mechanisms, both enabled. Recovery rollback through test upgrades and an application confirm, and anti-rollback through a security counter in trusted, one-way storage.
  2. Updates are test upgrades. No production image is pre-confirmed at signing or requested as a permanent upgrade, and CI checks for it.
  3. The confirm rule. The image confirms only after its self-test passes, including a successful contact with the update service.
  4. The counter rule. The security counter rises only for releases that fix a vulnerability that older images still carry, and the release notes say so.
  5. Who approves a counter change. A named person, separate from the engineer who built the release, approves every counter increase.
  6. When the floor moves. Automatically after confirm, or on a signed command after the rollout soak, chosen per product and written here.
  7. The counter budget. How many steps the hardware allows, how many are used, and what happens at the limit.
  8. The fix-forward procedure. How to rebuild the last good code under a higher version with the same counter, and who can ship it.
  9. The tests. The matrix above, run on every bootloader change and every release candidate.

The update policy worksheet has a row for downgrades and turns these decisions into a one-page table, and the version scheme builder shows how the version numbers MCUboot compares are formed.

Fumbar is a Denver company that writes embedded firmware and over-the-air update systems for hardware startups. An update pipeline we set up ships with signed releases, a tested revert path and a written downgrade policy; our over-the-air update services describe the work. If you want your bootloader configuration and downgrade policy checked before launch, request a firmware review.

Facing this decision on a real device?

If this article describes a choice in front of you, a firmware review puts it in writing for your board, your code and your update plan.

Request a firmware review

Or email sales@fumbar.com, or call (720) 675-4202.