Worried about pushing code to devices you can’t reach? IoT OTA firmware updates work best when they are automatic, authenticated and integrity-protected. RFC 9019 sets out that architecture, and this guide walks through it.
Firmware updates are one piece of the bigger picture covered in our iot development guide.
| Item | Value |
|---|---|
| Document | RFC 9019, A Firmware Update Architecture for Internet of Things |
| Published | April 2021 |
| Status | Informational, not Internet Standards Track |
| Update expectation for IoT devices | Automatic, without user involvement |
| Protections a deployment must use | Authentication and integrity protection; confidentiality optional |
| Originating group | IETF SUIT working group |
These figures come from RFC 9019 on the IETF Datatracker. Details can change, so check the source before you rely on them.
Why IoT devices need to update themselves
The abstract of RFC 9019, published in April 2021, says vulnerabilities in IoT devices created the need for a reliable and secure update mechanism that suits devices with resource constraints. That is the core case for IoT OTA firmware updates: you cannot fix what you cannot reach.
Patching is not the only job. The same document calls an update mechanism a fundamental requirement for fixing vulnerabilities, and says it also lets you change configuration settings and add new functionality.
Updates matter most when devices have a long lifetime or sit in remote or inaccessible areas. In those places, the RFC says, manual intervention is cost prohibitive or otherwise difficult.
The RFC lists several reasons a device may need new firmware:
- Fixing bugs and security vulnerabilities.
- Adding new functionality.
- Reconfiguring the device to work in a new environment.
- Changing how it behaves in an already-deployed context.
Should an IoT update ask the user first?
Usually not. The RFC expects firmware updates for IoT devices to work automatically, without user involvement, while non-IoT devices are expected to account for user preferences and consent when scheduling updates.
Two reasons follow from the document. Many IoT devices have no user interface, so unattended updates are essential to a practical design. Automatic updates that need no human intervention are also what make fixing software vulnerabilities scale.
What a secure update must guarantee
The image must be authenticated and integrity protected. A maliciously modified image, or one from an unknown and untrusted source, must never be flashed onto the device.
Confidentiality is the optional layer. According to RFC 9019, a deployment must use authentication and integrity protection, but protecting the firmware’s confidentiality is not required.
There is still a reason to consider it. Obtaining the firmware is often one of the first steps in mounting an attack, because it reveals the software libraries used, configuration settings and general functionality.
On key material, the RFC’s examples use asymmetric cryptography because many IoT deployments prefer it. Symmetric credentials are also supported and can suit very constrained devices.

How the manifest fits in
RFC 9019 motivates standardizing a manifest format as a transport-agnostic means of describing and protecting firmware updates. Transport-agnostic here means the description and protection of an update do not depend on how the image travels to the device.
The architecture is not limited to firmware. The RFC says it can also manage the delivery of arbitrary data, such as configuration information and keys.
Constrained devices versus higher-end devices
The standardization work was informed by, and optimized for, Class 1 devices as defined in RFC 7228. Even so, the document says nothing in the architecture restricts its use to those constrained devices; see RFC 9019 for the full wording.
The way software is packaged differs between device types. Constrained IoT devices often rely on a developer creating and compiling all software into a single, monolithic firmware image. On higher-end devices, application software is often downloaded separately and may come from different developers than the lower-level software.
For a single-image device, one update carries the whole software stack. That raises the stakes for checking each image before it is installed.
Planning your own rollout
RFC 9019 describes an architecture rather than a rollout playbook. Treat the steps below as editorial planning questions drawn from its themes, not as requirements from the document.
- Decide how each image will be authenticated and integrity protected before the device accepts it.
- Decide whether the image also needs confidentiality protection, knowing the RFC treats that layer as optional.
- Design the process to run unattended, since many devices have no user interface.
- Plan how you will learn which devices updated successfully and which did not.
- Keep the update description separate from the delivery channel, in the spirit of a transport-agnostic manifest.
Reporting what happened on each device is a data problem as much as a firmware one, so it belongs in your iot data pipeline.
The question of where update decisions get made, on the device, at the edge or in the cloud, ties into the trade-offs behind edge computing vs cloud computing iot designs.
This site is an independent educational resource. It does not sell or run update services.
Frequently asked questions
Is RFC 9019 an Internet standard?
Show answer
No. Its status memo describes it as informational rather than a standards-track specification, so use it as design guidance. That was its status as of its April 2021 publication.
Do OTA updates have to be encrypted?
Show answer
Not according to the RFC. Encrypting the image is the optional extra. What a deployment must always do is verify where an image came from and that nobody altered it.
Does this only apply to tiny devices?
Show answer
No. The work was tuned for the smallest device class, but nothing in the architecture limits it to those devices. It can also deliver other data, including configuration and keys.
Where did the SUIT working group come from?
Show answer
The Internet Architecture Board held a workshop on IoT software updates. The challenges it exposed for developers led the IETF to form the Software Updates for Internet of Things (SUIT) Working Group, as RFC 9019 explains.
