Input-Driven Code Execution Randomization Against Side-Channel Attacks
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Computer programs are vulnerable to side-channel attacks that exploit synchronized ordering and repeatability of execution, allowing attackers to generate valid datasets for extracting secret information.
Innovation Solution
A method and system that transform computer programs into randomized execution by generating a graph structure representing code instructions, allowing traversal in multiple orders and using function definitions to execute nodes in a unique manner for each input, thereby misaligning execution data across inputs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the computer program executes code instructions in a fixed sequential order, then the execution is predictable and easy to analyze, but this predictability enables side-channel attacks to generate synchronized datasets for extracting secret information
Solution Approach 1:
The patent transforms the static, fixed execution order into a dynamic, randomized execution order. The graph structure allows nodes (code portions) to be traversed in multiple valid orders, and the system randomly selects one valid order for each execution. This dynamic randomization maintains execution correctness while preventing attackers from predicting or synchronizing execution traces across multiple runs.
Solution Approach 2:
The patent segments the computer program into discrete portions represented as nodes in a graph structure. By dividing the code into separable units with defined dependencies, the system can randomize the traversal order of these segments while maintaining correct execution. This segmentation enables the randomization mechanism to work without compromising program correctness.
2Object-affected harmful factors
If the code instructions are executed in a randomized order, then side-channel attacks cannot generate synchronized datasets, but this randomization increases the complexity of the program structure
Solution Approach 1:
The patent performs preliminary analysis of the code to construct the graph structure with all dependency relationships established before execution. This pre-computation of valid traversal orders allows the system to randomly select from pre-validated options during runtime, avoiding the need for complex real-time analysis. The heavy lifting is done upfront, keeping runtime complexity manageable.
Solution Approach 2:
The patent introduces a graph structure as an intermediary representation between the original code and its execution. This graph acts as a mediator that captures all valid execution orders while enabling randomization. The graph structure simplifies the complexity by providing a clear visual and computational model of dependencies, making the randomization process more manageable than directly manipulating the original code structure.
3Adaptability or versatility
If multiple function definitions are constructed to execute different nodes, then execution variability increases to prevent attack dataset synchronization, but the number of function definitions and traversal paths increases
Solution Approach 1:
The patent creates function definitions that can execute multiple different nodes of the graph structure. Each function is designed to be versatile, capable of handling different code portions depending on the randomization selection. This multi-functionality reduces the total number of functions needed compared to having a dedicated function for each node, while still providing sufficient variability to prevent attack dataset synchronization.
Data Source
Figure 1
Figure 2
Figure 3A~3B
AI summary
Embodiments of systems, devices and methods for protecting computer programs against analysis and/or attacks that rely on synchronized ordering and repeatability are provided herein. Embodiments disclosed herein include receiving input source code, the source code comprising code instructions of a computer program; generating a graph structure representative of the code instructions comprising nodes representative of portions of the code instructions and links representative of dependencies between the portions of the code instructions, wherein the nodes can be traversed in a plurality of orders without invalidating the dependencies between the portions of the code instructions; constructing a plurality of function definitions based on the graph structure, each function definition configured to execute one or more nodes of the graph structure and each node of the graph structure is executable by one or more function definitions; transforming the input source code into transformed source code based on combining the graph structure and the plurality of function.