RidgeRun Platform Security Manual - How Can RidgeRun Help?
🚧 Documentation is under development
The RidgeRun Platform Security Manual guide is currently under active development. Some sections may be incomplete or change without notice.
Questions? Contact RidgeRun or email to support@ridgerun.com.
- Introduction
- General Security Concepts
- Getting Started
- Contact Us
- Sponsor your Favorite Feature
How Can RidgeRun Help?
RidgeRun provides engineering services for embedded products that need to define, implement, integrate, validate, or bring security features into production.
Security in an embedded product is rarely the result of enabling a single feature. Secure Boot, key management, Trusted Execution Environments, storage encryption, secure updates, system hardening, and recovery mechanisms must work together as part of the complete product architecture.
RidgeRun can help throughout this process, from understanding the security requirements of a project to implementing and validating the required security mechanisms on the target hardware and software platform.
A typical security engagement can include:
- Understanding the product's security requirements and threat model.
- Evaluating the security capabilities available on the selected platform.
- Designing the security architecture.
- Implementing and integrating security mechanisms.
- Integrating security into Yocto, BSP, manufacturing, and deployment workflows.
- Testing both expected and unauthorized scenarios.
- Documenting reproducible procedures for development and production.
Our security service areas and expertise
At RidgeRun, we have more than 20 years of experience working with embedded Linux systems across platforms from vendors such as NVIDIA, NXP and others.
Our embedded experience allows security work to be approached as part of the complete product architecture rather than as an isolated software feature.
Depending on the project's requirements and target platform, RidgeRun can assist in the following areas:
From security requirements to implementation
A RidgeRun security engagement can begin at different stages of a product.
Some projects already know exactly which mechanism they need. For example, a project may require Secure Boot integration on a specific SoC.
Other projects may begin with a requirement rather than a specific technology.
For example:
RidgeRun can assist with individual stages of this process or with the complete security implementation.
Security architecture and platform capabilities
Security mechanisms differ significantly between hardware platforms.
The same high-level security requirement may require different implementations depending on the SoC, boot architecture, operating system, BSP, and product requirements.
For example, a requirement such as:
Only software authorized by the product owner shall execute during boot.
may involve different vendor-specific technologies and tools.
RidgeRun can help identify the mechanisms provided by the target platform and determine how they fit into the product's security architecture.
This may include:
- Hardware Root of Trust.
- Boot ROM and bootloader authentication.
- Secure Boot and chain-of-trust configuration.
- Hardware security engines.
- Trusted Execution Environments.
- TPMs or secure elements.
- Hardware-backed key storage.
- Debug authentication and debug restrictions.
- Security fuses and lifecycle states.
- Storage encryption capabilities.
- Measured boot and attestation.
- Secure update and recovery mechanisms.
The objective is not simply to enable the available features, but to map them to the security requirements identified for the product.
Security implementation
Once the security architecture has been defined, RidgeRun can assist with the platform-specific implementation.
Depending on the project, this can include modifications to:
- Bootloaders.
- Linux kernel configuration.
- Device Tree.
- Trusted firmware.
- Trusted Execution Environments.
- Yocto layers and recipes.
- Root filesystem configuration.
- Initramfs and early-boot logic.
- Update systems.
- Application services.
- Manufacturing and flashing tools.
- CI/CD and signing infrastructure.
Security mechanisms should be reproducible as part of the product build and deployment process rather than depending on undocumented manual steps.
Bringing security into production
A security mechanism working on a development board is not necessarily ready for production.
Production deployment may introduce additional considerations such as:
- Production signing keys.
- Device-specific credentials.
- Fuse programming.
- Device lifecycle configuration.
- Debug restrictions.
- Manufacturing provisioning.
- Secure flashing.
- Recovery procedures.
- Update infrastructure.
- Key backup and recovery policies.
- Reproducibility across production units.
Some security configuration operations may also be irreversible.
For this reason, RidgeRun can help define and validate the production sequence before security settings are permanently applied to production devices.
Supported platforms
RidgeRun works with embedded Linux platforms from multiple semiconductor vendors.
Security capabilities vary between platforms, SoCs, BSP releases, and operating systems. Therefore, support for a specific security mechanism must be evaluated against the hardware and software baseline selected for the project.
The RidgeRun Platform Security Manual currently contains implementation guides and information for supported platforms.
See the Platform Support section for the security features currently documented for each platform.
If your platform or security requirement is not currently documented, RidgeRun can evaluate the available platform security capabilities and assist with the required integration.
How an engagement can start
You do not need to have the complete security architecture defined before contacting RidgeRun.
An engagement can start from different points:
| Starting point | Example | RidgeRun can help with |
|---|---|---|
| I know my concern | "An attacker must not be able to replace our firmware." | Translate the concern into security requirements and identify appropriate mechanisms. |
| I know my requirement | "Only software authorized by us may execute." | Design the chain of trust and select the required platform mechanisms. |
| I know the mechanism | "We need Secure Boot." | Implement and validate the mechanism on the selected platform. |
| We already have an implementation | "Secure Boot is enabled, but we need to bring it into production." | Review the implementation and develop provisioning, signing, validation, and production procedures. |
| We need a security review | "We want to understand what is missing before production." | Review the architecture, configuration, attack surface, security mechanisms, and deployment process. |
A typical engagement defines the target hardware and software baseline, security requirements, scope, expected deliverables, and measurable acceptance criteria before implementation begins.
FAQ
- Can RidgeRun help if I do not know which security features my product needs?
- Yes. RidgeRun can help analyze the product requirements, assets, attack surface, deployment environment, and platform capabilities to identify appropriate security requirements and mechanisms.
- Can RidgeRun implement only one security feature?
- Yes. An engagement can focus on a specific mechanism such as Secure Boot, TEE, disk encryption, TPM integration, secure OTA, or another platform-specific security requirement.
- Can RidgeRun review an existing security implementation?
- Yes. Existing implementations can be reviewed to identify gaps in the architecture, configuration, key management, update path, recovery strategy, production process, and validation coverage.
- Can RidgeRun help move a security implementation from development to production?
- Yes. The scope can include production signing, provisioning, security fuses or lifecycle configuration, debug restrictions, manufacturing procedures, validation, recovery, and reproducible deployment workflows.
- Does RidgeRun support different embedded platforms?
- Yes. RidgeRun works with embedded Linux platforms from multiple vendors. The exact security capabilities and implementation depend on the selected SoC, board, BSP, operating system, and software release.
- Can RidgeRun integrate security into Yocto?
- Yes. Security mechanisms can be integrated into the product's Yocto build, including recipes, layers, signing workflows, image generation, configuration, and deployment procedures.
- Is enabling Secure Boot enough to secure my product?
- Not necessarily. Secure Boot addresses specific threats related to software authenticity and integrity during the boot chain. Other requirements may need additional mechanisms such as secure updates, key protection, storage encryption, system hardening, access control, or debug restrictions.
Contact RidgeRun
If you need assistance defining, implementing, validating, or bringing embedded security features into production, RidgeRun can help evaluate the requirements of your project and define an appropriate engineering scope.