Program Code Flow Integrity via Pre-Branch Check Value Reset
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Secure computational applications face challenges in maintaining program code flow integrity, as changes in functionality can create security vulnerabilities that attackers can exploit, especially due to indeterministic execution flows at branch points.
Innovation Solution
A system that uses a check value function to determine and compare reference and run-time check values, storing the pre-branch run-time check value before conditional branches and resetting it upon exit, ensuring the integrity of program execution by verifying the consistency of these values.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional program execution is used without integrity checks, then execution speed is fast and device complexity is low, but program code flow integrity cannot be ensured and security vulnerabilities can be exploited
Solution Approach 1:
The patent applies preliminary action by computing and storing reference check values for program instructions before execution. The system pre-calculates check values for each instruction and stores them in a lookup table, so that during execution, the processor can quickly compare run-time check values against these pre-computed references without adding complex real-time computation overhead.
Solution Approach 2:
The patent introduces an intermediary mechanism in the form of a check value function and lookup table that mediates between the program execution and integrity verification. This intermediary layer handles the complexity of integrity checking separately from the main execution flow, allowing fast execution while maintaining security through the mediation of check value comparisons.
2Reliability
If check values are computed and compared at every instruction level, then program code flow integrity is ensured, but processing time increases and productivity decreases
Solution Approach 1:
The patent computes check values in advance during program loading or initialization, storing them in a lookup table. This preliminary computation eliminates the need for complex real-time check value generation during execution, allowing the system to maintain integrity verification without significant runtime penalty.
Solution Approach 2:
The patent creates a copy of the check values in a separate lookup table structure. During execution, the system copies or retrieves pre-computed check values from this table rather than regenerating them, which significantly reduces processing time while maintaining the integrity verification function.
3Reliability
If the system stores and compares check values at every branch point, then code flow integrity is maintained, but device complexity and memory requirements increase
Solution Approach 1:
The system performs preliminary computation of check values for all possible instructions and stores them in a compact lookup table. This approach allows the system to verify integrity at branch points without storing complex runtime state information, reducing memory requirements compared to alternative approaches.
Solution Approach 2:
The patent uses a lightweight check value mechanism that can be quickly computed and compared. The check values themselves are relatively simple data structures that can be stored efficiently in memory, and the system can discard or reuse these values without requiring substantial memory resources for long-term storage.
Data Source
AI summary
In one embodiment a device is described, the device including a memory operative to store an program, a storage operative to store a reference check value for at least one operation in the program, a processor operative to execute the program, including, determining a run-time check value upon execution of the at least one operation in the program, comparing the stored reference check value with the run-time check value, storing the run-time check value as a pre-branch run-time check value prior to entering a conditional branch of the program when the compared stored reference check value and the run-time check value are equal values, resetting the run-time check value of the executing program to the pre-branch run-time check value upon exiting the conditional branch of the program, wherein the reference check value, the run-time check value, and the pre-branch run-time check value are determined as a result of a single function. Related apparatus, methods and systems are also described.