Contents

Update security and Uptane

Uptane helps vehicles check that software updates are authentic, current and intended for the right ECU, even when part of the update infrastructure is compromised.

6 min read · Discipline stake: Update Security BSW Architecture

Why it exists

A software update changes code that the vehicle will trust. If an attacker can influence that process, a routine maintenance channel becomes a route into braking, connectivity or central computing.

Checking a digital signature is essential, but it does not answer every question. An old vulnerable image may still have a valid signature. Individually approved versions may be incompatible when installed together. A compromised distribution server may keep offering yesterday’s release while hiding a security fix.

Threat What goes wrong Main defence
Malicious package An attacker replaces software or changes its contents. Authenticate signed metadata and verify the image against its authorised hash.
Rollback attack An older, vulnerable release replaces newer software. Reject older metadata and disallowed image release counters using protected stored state.
Freeze attack Old signed information keeps the vehicle from discovering updates. Check metadata expiry against trusted time.
Compromised server or keys An attacker controls distribution or signs unauthorised instructions. Separate signing authorities, limit key permissions and prepare recovery.
Mix-and-match attack Valid files or versions are combined into an unauthorised or incompatible set. Bind metadata together and enforce tested vehicle compatibility rules.

Update security must therefore establish what the software is, who authorised it, where it belongs and whether that authorisation is still current.

What it is

Uptane is an open framework for securing vehicle software updates. It is a Linux Foundation Joint Development Foundation project. It defines trust relationships and verification rules; it is not a complete over-the-air (OTA) campaign manager. Its public specification is the Uptane Standard for Design and Implementation.

An image is the software file to install. Metadata is signed information describing images, their hashes, lengths and authorisation. A hash acts as a fingerprint: changing the file changes the value the vehicle calculates.

Uptane separates backend authority:

  • The Image repository publishes approved images and signed information describing them.
  • The Director repository uses vehicle inventory and reported software state to assign images to particular electronic control units (ECUs).

In the basic design, full verification requires agreement between these repositories about an assigned image. Separating their keys and administration limits what compromising either authority alone can achieve. It does not protect against every combination of compromised keys.

How it works

Code signing uses a private key to sign software or metadata that securely identifies it. The vehicle uses trusted public keys to verify those signatures. For Uptane, signed metadata binds authorisation to the image’s hash and length. Transport encryption protects the connection, but vehicle-side verification remains necessary after download.

An ECU acting as a Primary coordinates communication with the repositories, collects signed ECU version reports and distributes updates within the vehicle. A telematics control unit (TCU) or central computer can take this role. A Secondary receives update material through its associated Primary and verifies material for its own installation. These are update roles, not fixed hardware categories.

A typical update proceeds as follows:

  • ECUs report installed software; the Primary assembles a vehicle version manifest for the Director.
  • The Director selects images for the vehicle’s ECUs.
  • The Primary downloads and fully verifies repository metadata, then checks downloaded images.
  • Each Secondary performs its required verification and checks its image before installation.
  • ECUs report the resulting installed state, including failures.

Full verification checks the trust chain and relevant metadata from both repositories, including signatures, freshness, versions and agreement about images. Root metadata establishes trusted keys and signing requirements. Timestamp and Snapshot metadata help detect stale or inconsistent repository information; Targets metadata describes authorised images.

Partial verification reduces the work on constrained Secondaries. It checks the Director’s Targets metadata, with applicable freshness and version checks, and verifies the image against the authorised description. It does not independently establish agreement with the Image repository. Primaries must perform full verification; Secondaries should do so where possible. The distinction is specified in the Uptane verification procedures.

Partial verification therefore provides weaker protection against Director compromise. It is a deliberate engineering tradeoff, not permission to accept whatever bytes the Primary sends.

After installation, secure boot provides a last line of defence by authenticating executable software before it runs. It complements update verification. A valid boot signature alone does not prove that a release is current or compatible with neighbouring ECUs.

Uptane update verification
Director repository
Image repository
Primary ECU
Secondary ECU
Vehicle version manifestCollects signed ECU version reports
Signed metadataDirector selects images and signs Targets metadata
Metadata and imagesPrimary downloads update material
Verify update materialFull metadata verification; check images
Metadata and image
Verify and installRequired metadata verification and image checks

Simplified successful update flow; Secondary verification may be full or partial, and download requests and subsequent version reports are omitted.

When to use it — and when not

Use Uptane when designing vehicle updates that must remain trustworthy despite compromise of parts of the backend or distribution path. It is especially useful where suppliers publish images while the manufacturer controls vehicle-specific deployment.

For a constrained legacy ECU, assess whether its bootloader, storage and trusted state can support the required checks. Adding Uptane only to a gateway leaves limits at any downstream ECU that cannot authenticate its own update material.

Uptane does not decide whether the vehicle is safely parked, whether battery energy is sufficient or whether an installation can survive power loss. Those controls belong to update orchestration and ECU installation design. Likewise, cryptographic agreement cannot establish that software versions work together: release engineering must supply tested compatibility rules.

UN R156 addresses software updates and the software update management system; UN R155 addresses cybersecurity and its management system. Uptane can contribute technical controls and verification evidence, but neither regulation mandates it or grants compliance merely because it is used. The Vehicle Certification Agency’s regulatory overview explains these distinct scopes.

ISO/SAE 21434 supplies the lifecycle cybersecurity engineering framework around those controls: analyse threats, define requirements, verify implementation and manage risks in operation. It does not prescribe Uptane as the required technology. See the ISO/SAE 21434 public description.

Best practices

  • Separate keys by authority and purpose. Keep Image and Director signing authorities independent. Separate repository signing, ECU identity and secure-boot keys so a compromise has a limited scope.
  • Keep high-authority keys offline. Protect root and suitable release-signing keys outside routine online services. Use controlled signing ceremonies and threshold signatures where appropriate; keep online keys narrowly authorised.
  • Design recovery before deployment. Exercise key rotation, revocation and recovery from compromised online keys. Confirm that vehicles returning after long offline periods can update their trust metadata.
  • Protect freshness state. Preserve trusted metadata versions, release counters and trusted time across resets. Define behaviour for expired metadata and unavailable time without silently bypassing checks.
  • Test hostile inputs. Include altered images, replayed metadata, wrong ECU assignments, repository disagreement and interrupted verification. Report rejection reasons clearly enough for backend investigation.
  • Coordinate recovery and rollback protection. Define authorised recovery paths without creating a general downgrade bypass. Uptane’s Deployment Best Practices discusses exceptional rollback operations.

Common pitfalls

  • Treating a valid signature as proof that software is suitable for every ECU or vehicle.
  • Giving both repositories the same operational credentials, defeating the intended separation.
  • Assuming partial verification provides the same compromise resistance as full verification.
  • Disabling expiry checks because vehicles sometimes remain offline; plan offline operation and recovery instead.
  • Treating secure boot as a substitute for update authorisation, freshness and compatibility checks.
  • Accepting a verified campaign as complete before confirming which versions actually installed.
  • Blocking all recovery through rollback protection, or weakening protection globally to recover from a faulty release.

What it means for your discipline

  • Software update & OTA Core

    Builds repository publishing and vehicle update flows; tests version checks, campaign assignments, interrupted downloads and recovery after rejected updates.

  • Cybersecurity Core

    Defines signing roles, protects offline keys and plans key rotation; tests what an attacker can do after compromising a server or signing key.

  • Base software Partial

    Implements verification in ECU update clients and bootloaders; preserves trusted metadata and rollback state across resets and interrupted flashing.

  • E/E architecture Partial

    Assigns Primary and Secondary roles, budgets verification resources and defines compatible software combinations across vehicle controllers.

No direct stake: Functional safety · HPC & application software · Hardware & silicon · Networks & communication · Diagnostics & lifecycle

Where it sits in the software stack

Generic layered software of a central HPC (application processor with hypervisor, plus a safety island) and of a classic MCU-based ECU (AUTOSAR Classic). Highlighted modules matter for this topic. Click any module to open its page.

HPC · application processor (MPU) and safety island (MCU)
  • OTA client · UCM — Acts as an Uptane Primary or Secondary, verifying metadata and images before coordinating installation and reporting installed versions.
  • Security services — Provides protected key use and cryptographic verification for update metadata and signed version reports.
  • Secure boot chain · TEE — Authenticates installed executable images and enforces accepted boot versions, complementing Uptane update verification.
MCU-based ECU · AUTOSAR Classic
  • Flash bootloader · secure boot — Implements bootloader-side Secondary verification where allocated, checks images before flashing, and authenticates executable software at startup.
  • Memory · crypto · WdgM — Persists trusted metadata and rollback state across resets and supplies cryptographic services for update verification.