Run-time Execution Validator Processor Pipeline Signature Cache
Solution Overview
Problem
Existing systems fail to effectively validate program execution at runtime, particularly in untrusted environments, as they are vulnerable to code injection and control flow attacks, which can bypass traditional security mechanisms and compromise kernel integrity.
Innovation Solution
The Run-time Execution Validator (REV) mechanism integrates a signature cache into the processor pipeline to validate control flow paths and instructions dynamically, ensuring that only legitimate code executions occur by comparing cryptographic hashes with reference signatures stored in memory, without requiring binary modification or ISA extensions.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If continuous runtime validation of program execution is implemented, then security against control flow attacks is improved, but system complexity increases
Solution Approach 1:
The patent embeds a validation unit within the processor pipeline that contains a signature cache and validation logic. This nested structure integrates security validation functionality inside the existing processor architecture without requiring external validation systems, thereby improving security while controlling system complexity through hierarchical integration.
Solution Approach 2:
The patent introduces a signature cache as an intermediary component that stores pre-computed cryptographic signatures of valid control flow paths. This intermediary enables efficient validation by comparing actual control flow against stored signatures without requiring complex real-time cryptographic computations, thus improving security while managing system complexity.
2Reliability
If runtime validation of all program executions is performed, then detection of code compromises is improved, but execution speed deteriorates
Solution Approach 1:
The patent pre-computes and stores cryptographic signatures of all valid control flow paths in the signature cache during system initialization or code loading. By performing this computationally intensive work beforehand, the actual runtime validation only requires simple comparison operations, thereby improving detection capability while minimizing impact on execution speed.
Solution Approach 2:
The validation unit operates continuously within the processor pipeline, validating control flow instructions as they are executed without interrupting the normal execution flow. This continuous validation approach detects compromises in real-time while maintaining steady execution throughput, as the validation occurs in parallel with instruction execution rather than as a separate blocking step.
3Measurement precision
If cryptographic hash validation is performed for every control flow instruction, then integrity verification is improved, but computational overhead increases
Solution Approach 1:
The patent creates copies of cryptographic signatures and stores them in the signature cache for rapid comparison. Instead of performing full cryptographic hash computations for every control flow instruction, the system uses pre-computed signature copies that can be quickly matched against actual control flow, thereby improving integrity verification precision while significantly reducing computational overhead and energy consumption.
Data Source
AI summary
Trustworthy systems require that code be validated as genuine. Most systems implement this requirement prior to execution by matching a cryptographic hash of the binary file against a reference hash value, leaving the code vulnerable to run time compromises, such as code injection, return and jump-oriented programming, and illegal linking of the code to compromised library functions. The Run-time Execution Validator (REV) validates, as the program executes, the control flow path and instructions executed along the control flow path. REV uses a signature cache integrated into the processor pipeline to perform live validation of executions, at basic block boundaries, and ensures that changes to the program state are not made by the instructions within a basic block until the control flow path into the basic block and the instructions within the basic block are both validated.