Shared Resource Leakage

Shared system resources (e.g., processor registers, main memory, secondary storage, cache) may retain residual data or security-relevant state after a process releases them for reuse. If a subsequent process can access that residual information, it may obtain data from the prior process, including sensitive information or encrypted representations of information that were not intended to cross process or partition boundaries. This countermeasure requires that shared resources be sanitized, zeroed, or otherwise cleared of prior process data before being allocated to a new process, ensuring that information transfer between processes occurs only through explicitly authorized channels. The protection must apply to encrypted representations as well as plaintext because encrypted data remains information belonging to the prior process and must not be transferred to another process solely because its contents are not immediately readable. This is particularly significant in space system environments where multiple processes of varying criticality and trust levels may share the same hardware resources.

ID: CM0040
Tier: I
Onboard SV CM 
Created: 2022/10/19
Last Modified: 2026/08/06

Pre-Operations Government

Acquisition requirements should explicitly address shared-resource leakage, requiring that a process reusing a shared resource cannot access information retained from its prior use. Clearing or zeroization should be required for resources that retain directly accessible data, while other resources should use isolation, reinitialization, flushing, partitioning, or equivalent mechanisms appropriate to the resource. Protection should be enforced by trusted system resource-management mechanisms rather than relying solely on individual processes. Requirements should specify that shared-resource protections apply to both plaintext and encrypted information retained from prior use, and that the implementation be verified through testing that confirms no residual data from a prior process is accessible to a subsequent process following resource reallocation. Contract language should require that the resource management architecture be documented in the system security design, identifying each category of shared resource, the clearing mechanism applied to each, and the assurance argument for why the mechanism is sufficient. Evaluation criteria should assess offerors' proposed operating environment, their demonstrated experience with resource sanitization in safety- and security-critical embedded systems, and the adequacy of their proposed verification approach for shared resource leakage prevention. Flow-down provisions should ensure that operating system and runtime environment providers whose software manages shared resources implement clearing behaviors consistent with the program's requirements.

Pre-Operations Developer/Supplier

Shared-resource protections should be enforced by the trusted layer responsible for allocating and reassigning the resource, such as the operating system, runtime environment, hypervisor, firmware, or hardware resource controller. Application-level sanitization may supplement these controls but should not be the sole protection against leakage to another process. Memory allocation routines, register management, and storage block assignment functions should be configured or implemented to zero or overwrite the allocated region before returning it to the requesting process, ensuring that no prior content is accessible regardless of the allocation source or the trust level of the requesting process. In resource-constrained flight environments, the selected protection mechanism should balance leakage prevention with timing, performance, and resource constraints. Where clearing on every reuse is not operationally feasible, the design should use an alternative mechanism, such as dedicated allocation, partitioning, controlled reuse, or resource reinitialization, that still prevents a subsequent process from accessing information from the prior use. Residual-data clearing does not address every shared-resource side channel. Timing, contention, cache-state, queue-state, and other indirect leakage paths should be evaluated through the threat model and addressed through appropriate isolation, flushing, partitioning, or scheduling controls. Testing for shared resource leakage should include scenarios in which a process is allocated a resource immediately following a process that handled sensitive data, with verification that no residual sensitive data is accessible in the newly allocated resource.