Security risks in field operations

Many embedded systems are functionally stable, but their security has evolved over time. Vulnerabilities often do not arise from a single point, but from the interplay between system boot-up, the operating system, update paths and access policies. This is precisely why embedded security must be taken into account at an early stage in the system architecture.

 

Unsicherer SystemstartUnstable system start-up
A lack of verification in the boot chain jeopardises the trustworthiness of the entire device.
Zu große Angriffsfläche im ZielsystemExcessive surface area in the targeting system
Unnecessary services, broad permissions and uncontrolled persistence increase operational risk.
Unsichere Update-PfadeInsecure update paths
Updates that are not adequately secured jeopardise both security and device availability.
Teilabsicherung statt SicherheitsarchitekturPartial protection rather than a security architecture
Encrypted communication alone is not enough if the boot chain, OS configuration or key management remain vulnerable.

 

Embedded security is not achieved through a single measure, but through the coordinated interaction of several system levels.

 

Technical security components of embedded security

A robust safety concept for embedded systems is not achieved through a single function. What is crucial is the interaction of several technical components, which must be suited to the platform, the application scenario and subsequent field operation.

 

Secure Boot & Chain of Trust

Securing the system boot process using verified and signed boot components as the basis for a trusted boot chain.

 

Operating system hardening

Reducing the attack surface through targeted configuration of the target system, deactivation of unnecessary services and well-defined access rights policies.

 

Secure updates & OTA

Controlled software distribution with signature verification, protection against tampered images, and rollback and recovery strategies.

 

Cryptography & Device Identities

Secure integration of cryptographic methods, controlled key management and the use of device-specific identities.

 

Hardware-based security features

Targeted use of existing security mechanisms at platform and SoC level, for example to isolate sensitive functions.

 

Communications & Access Security

Securing protocols, remote stations, remote access points and communication paths in networked embedded systems.

 

Secure Boot & Chain of Trust

The foundation of trust in an embedded system is established right from the start. If boot components are not verified, tampered software may be executed before higher-level protection mechanisms even come into play.

 

Secure Boot ensures that only authorised and unmodified components are loaded. Depending on the platform, this involves verifying several stages of the boot chain – for example, from the bootloader through the kernel and device tree to other boot-related artefacts. This is precisely where the technical chain of trust begins.

A robust chain of trust is particularly important when devices are operated in a networked environment, updated in the field or maintained over long lifecycles.

Typical implementation component

 

  • Signed boot components
  • Verification of the boot chain
  • Securing the bootloader and kernel
  • Platform-specific security mechanisms
  • Alignment with update and key management concepts

Operating system hardening

A functioning embedded system is not automatically a hardened system. Operating system hardening reduces the attack surface and translates security requirements into a controlled system configuration.

The focus is solely on those components, services and access paths that are actually required for the device’s real-world deployment. The aim is to achieve a target system that is functionally complete but deliberately stripped back in terms of security.


Relevant curing zones
  • Disable unnecessary services
  • Reduce the target system’s attack surface
  • Clearly define permissions and roles
  • Securing the root filesystem
  • Checking persistence
  • Designing a secure system configuration

Secure updates & OTA

An embedded system can only remain manageable in the long term if software updates can be distributed, verified and activated securely. That is why the update architecture – comprising signature verification, validation and a fallback strategy – is a key component of embedded security.

 

Integrität und Herkunft prüfenCheck integrity and origin
An update may only be installed if its origin and integrity can be technically verified.
Manipulierte Images erkennenSpotting manipulated images
The system architecture must prevent modified or unauthorised software versions from being activated without being detected.
Rollback und Recovery absichernEnsure rollback and recovery
Faulty updates must not lead to uncontrolled device states, systems that cannot boot, or permanent failures in the field.

Secure updates are not achieved through signatures alone, but through the coordinated interplay of verification, activation and fallback strategies. For embedded Linux systems, established mechanisms such as RAUC can provide a sound foundation when signed images, controlled activation and robust fallback paths need to be integrated.

 

Typical procedure
Update bereitstellen

Deploy the update

Herkunft und Integrität prüfen

Check origin and integrity

Kontrollierte Installation

Carry out the installation in a controlled manner

Aktivierung absichern

Ensure activation

Bei Fehlern Rollback oder Recovery auslösen

Trigger a rollback or recovery in the event of errors

Cryptography & Device Identities

Cryptography only works reliably in embedded systems if keys, identities and trust relationships are properly integrated into the device architecture.

 

Key management

Keys must be generated, managed and used in a controlled manner throughout the device’s lifecycle.

 

Secure key storage

The effectiveness of cryptographic methods depends very much on how sensitive keys are integrated into and protected within the system.

 

Device-specific identities

Unique device identities form the basis for authentication, establishing trust and secure communication.

 

Signature & Encryption

Signature and encryption methods protect the integrity, origin and confidentiality of security-relevant data paths.

 

Are you planning to implement Secure Boot, operating system hardening or a secure OTA solution? We can assist you with the technical assessment and integration into your device platform.

 

Hardware-based security features

Modern embedded platforms often offer security features that go beyond purely software-based measures. When used correctly, they can provide targeted protection for particularly sensitive functions.

 

Regular system area
This is where normal device functions and application processes run within the intended operational context.

Protected security area
Sensitive functions can be processed in separate execution areas, for example using TEE approaches or OP-TEE.

Defined transitions
Controlled communication between the regular and protected areas is crucial to ensure that the separation remains architecturally effective.

Communications & Access Security

As soon as embedded systems communicate with back-ends, other devices or service access points, it is necessary to secure not only data channels but also trust relationships. Communication security is a key component, but it is no substitute for a secure boot chain, hardening or a robust key management scheme.

 

Authentication of devices & remote stations

 

Securing network protocols

 

Securing remote access

 

Communication encryption

 

Taking service access into account

Depending on the type of device, locally accessible interfaces, debug ports or service ports should also be included in the security assessment – particularly if they are accessible in the field or can be activated for servicing.

The focus here is less on specialised measures for physical protection and more on the question of which local access paths are actually necessary during routine operation and how they are assessed, restricted or secured within the overall concept.

Relevant Issues

Which service ports are actually required in the field?

Which debug paths should be restricted or disabled?

Which local interfaces affect the device’s threat profile?

Security in the development process

Embedded security within the development process (security by design) should not be considered only after implementation. Robust security mechanisms are created when requirements, architecture, the threat landscape and technical implementation are integrated at an early stage, rather than being added as an afterthought.

 

Anforderungen analysieren

Analysing requirements

Clarify the application scenario, security objectives and field conditions.

Bedrohungsbild bewerten

Assessing the threat landscape

Identifying attack surfaces and typical misconfigurations.

Sicherheitsarchitektur festlegen

Define the security architecture

Integrate appropriate mechanisms into the boot, OS, update and communication concepts.

Umsetzung integrieren

Integrating implementation

Embed security functions into the platform, system software and device architecture.

Reviews und Prüfungen durchführen

Carrying out reviews and audits

Identifying vulnerabilities, inconsistencies and anomalies at an early stage.

Platforms & Security Requirements

Security requirements arise across platforms, but their technical implementation depends heavily on system architecture, device context and lifecycle.

 

Embedded Linux

particularly relevant for Secure Boot, BSP-level integration, operating system hardening, OTA strategies and recovery

 

Windows Embedded / WEC

relevant to secure system configuration, services, permissions, updates and access policies

 

Android-based systems

relevant to system customisation, update security, communication paths and rights management

 

Why SIGMA?

Practical application rather than theory

We work at the levels where embedded security has a practical impact: from the boot process through to the target system and on to software distribution.

 

A look at field operations

Updates, recovery, maintainability and long product lifecycles are taken into account right from the start.

 

Cross-platform

We carry out embedded security customisations for Linux, Windows Embedded and Android-based systems.

 

The SIGMA Group as a network

Short lines of communication and synergies within the group of companies complement the technical focus of the embedded division.

 

FAQ

Embedded security encompasses security mechanisms for embedded systems – from system boot-up, through the operating system and updates, to communication, identities and security checks during the development process.

Yes, because embedded security should be taken into account as early as possible in the project. In particular, secure boot, update architecture, key management and hardening can be implemented much more robustly if they are factored into the system architecture from the outset.

No. Security requirements also apply to Windows Embedded and Android-based devices. However, the technical implementation varies depending on the platform and device context.

Secure Boot ensures that an embedded system boots only with authorised and unmodified boot components. To this end, components of the boot chain – such as the bootloader, kernel or other boot-related artefacts – are verified before execution. This provides the technical foundation for a trusted boot chain and, consequently, for downstream security mechanisms within the system.

OTA stands for ‘Over The Air’ and refers to software updates that a device receives via a network connection – in other words, directly whilst in operation in the field, without any local intervention. This process is only secure once the origin, signature and integrity of the update packages have been verified, activation has been checked, and rollback or recovery mechanisms are in place in the event of an error. From a technical perspective, it is particularly important that a device remains in a controllable state even in the event of connection failures, incomplete packages or faulty software versions.

When particularly sensitive functions or security-critical operations need to be separated from the regular system context. A TEE (Trusted Execution Environment) is a protected execution environment running alongside the normal operating context. OP-TEE is a well-established open-source implementation of this principle. Such approaches are useful when security-critical processing needs to be specifically isolated and controlled, separate from the rest of the system.

Yes, this is often possible. The extent to which hardening is applied depends on the platform, the initial architecture, the update mechanism and the existing access paths.

Talk to us!

We will be happy to present solutions for your industry and your processes. Talk to the specialists for SMEs.

request now
Thomas Heinke
Thomas HeinkeHead of sales department
Roxana Bergt
Roxana BergtSales | Project Management Embedded