Dynamic Memory Page Execution Control for ROP Attack Inhibition
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Computing systems are vulnerable to Return-Oriented Programming (ROP) attacks, which exploit predictable code and data addresses to create malicious code sequences without injecting new code, posing a significant threat by allowing attackers to control execution flow and induce arbitrary behavior.
Innovation Solution
Implementing a method that sets a state indicator for memory pages to a non-executable state by default, using indirection stubs to modify the state from non-executable to executable only when necessary for function calls, thereby preventing execution of malicious code and limiting the availability of instructions for ROP attacks.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If memory pages are marked as executable by default to allow normal function execution, then system operation is maintained, but ROP attacks can exploit these executable pages to execute malicious code sequences
Solution Approach 1:
The system performs preliminary action by marking all memory pages as non-executable before any code execution. This pre-configuration prevents ROP attacks from exploiting executable memory pages, while the indirection layer is pre-established to enable legitimate function calls when needed.
Solution Approach 2:
An indirection layer is introduced as an intermediary between the non-executable memory pages and the processor. This indirection layer contains executable stubs that modify page state indicators and redirect execution, allowing legitimate function execution while blocking direct execution of malicious code sequences.
2Reliability
If all memory pages are marked as non-executable to prevent ROP attacks, then system security is improved, but legitimate function execution is blocked
Solution Approach 1:
The system implements dynamic control of memory page execution states. Page state indicators are modified in real-time based on execution needs: pages are marked non-executable by default for security, then dynamically changed to executable when legitimate functions need to run, and reverted to non-executable afterward.
Solution Approach 2:
The system changes the execution state parameter of memory pages dynamically. The indirection layer modifies page state indicators (from non-executable to executable and back) based on function call requirements, enabling flexible control that maintains both security and functionality.
3Reliability
If indirection stubs are used to modify page state dynamically, then ROP attacks are prevented while maintaining function execution, but system complexity increases
Solution Approach 1:
The system segments memory management into distinct components: non-executable data/code pages, an executable indirection layer with stubs, and a state indicator mechanism. This segmentation allows each component to have a specific security function while working together to provide overall protection.
Solution Approach 2:
The indirection layer with its stubs serves as an intermediary structure that manages the complexity of dynamic page state modification. This intermediate layer handles security decisions and execution redirection, isolating the complexity from both the application code and the core security mechanism.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A method, apparatus, and/or system for execution prevention is provided. A state indicator for a first subset of a plurality of memory pages of executable code in a memory device is set to a non-executable state. A state indicator for a second subset of the plurality of memory pages is set to an executable state, where the second subset of the plurality of memory pages includes indirection stubs to functions in the first subset of the plurality of memory pages. Upon execution of an application, a function call is directed to a corresponding indirection stub in the second subset of the plurality of memory pages which modifies the state indicator for a corresponding function in the first subset of the plurality of memory pages prior to directing execution of the called function from the first subset of the plurality of memory pages.