Endbranch Instructions for Fine-Grained Control Flow Integrity
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing program compiling and execution techniques are vulnerable to malicious call/jump oriented programming due to indirect branch instructions, which can be exploited to hijack the code execution flow, leading to security vulnerabilities.
Innovation Solution
The implementation of endbranch instructions with scope, granularity, and hash bit parameters to control flow integrity checks, which restrict indirect branches to within module boundaries and verify source instructions, reducing the risk of malicious control flow transfers.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If indirect branch instructions are used to enable flexible control flow, then program versatility is improved, but security vulnerability increases due to malicious call/jump oriented programming
Solution Approach 1:
The patent segments the control flow verification into fine-grained checkpoints distributed throughout the code. Instead of a single coarse-grained check, multiple endbranch instructions are placed at specific locations to create segmented verification points that collectively cover the entire control flow path, preventing malicious jumps while maintaining legitimate flexibility.
Solution Approach 2:
The patent implements preliminary action by pre-computing and storing hash values of valid source instructions that can jump to each endbranch target. During execution, the hash of the actual source instruction is compared against the pre-stored hash values, enabling rapid verification before the jump occurs and blocking malicious control flow transfers.
2Reliability
If control flow integrity checks are implemented to prevent malicious exploits, then security is improved, but performance overhead increases due to verification complexity
Solution Approach 1:
The patent changes the verification parameter from comparing full instruction sequences or addresses to comparing compact hash values. This parameter transformation reduces the verification operation to a simple hash comparison, significantly decreasing the computational overhead while maintaining the integrity check's effectiveness in preventing malicious control flow transfers.
Solution Approach 2:
The patent introduces hash values as an intermediary representation between the source instruction and the verification process. Instead of directly analyzing or comparing complex instruction structures, the system uses hash values as a simplified mediator that captures the essential identity of valid source instructions, enabling fast verification with minimal performance impact.
3Reliability
If fine grained control flow enforcement is implemented, then security against malicious exploits is improved, but device complexity increases due to additional verification mechanisms
Solution Approach 1:
The patent uses copying by storing hash values of valid source instructions in a data structure (such as a hash table or array) that can be efficiently queried during execution. This copied representation of validity information allows the verification mechanism to operate with simple lookup and comparison operations, reducing the complexity of the verification logic while maintaining fine-grained security enforcement.
Data Source
AI summary
In one embodiment, a processor comprises a decoder to decode a first instruction, the first instruction comprising an opcode and at least one parameter, the opcode to identify the first instruction as an instruction associated with an indirect branch, the at least one parameter indicative of whether the indirect branch is allowed; and circuitry to generate an error message based on the at least one parameter.