Securing Intermediate Code Branch Instructions via Parameter Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing computer security measures for Java Card technology are inadequate in preventing fault injection attacks that exploit parameter bytecodes to execute malicious operations, as they are demanding in terms of execution resources and require significant modifications to the code structure.
Innovation Solution
Storing the parameters of an instruction in a separate memory area with memory address information, allowing the processing unit to easily retrieve them, thereby preventing a hacker from executing parameter bytecodes as instruction bytecodes and enhancing the security of intermediate language software without altering the rest of the code.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If parameter bytecodes are stored immediately after the instruction bytecode in memory, then the code structure is simple and easy to access, but the security is compromised as attackers can execute parameter bytecodes as instruction bytecodes
Solution Approach 1:
The patent divides the memory storage into separate segments: instruction bytecodes are stored in one area while their corresponding parameter bytecodes are stored in another area. This segmentation prevents attackers from executing parameter bytecodes as instructions while maintaining organized access through stored offset information.
Solution Approach 2:
The patent introduces an intermediary mechanism where the instruction bytecode stores offset information that points to the parameter bytecodes. This intermediary offset data allows the system to access parameters without storing them immediately after the instruction, creating a security buffer.
2Reliability
If existing security measures are implemented to prevent fault injection attacks, then security is improved, but execution resources are consumed and code structure requires significant modifications
Solution Approach 1:
The patent implements security measures during the compilation phase rather than during execution. The compiler generates code with separated parameter storage and embedded offset information, so that when the code executes, the security protection is already in place without consuming additional execution resources.
Solution Approach 2:
The instruction bytecode itself contains the offset information needed to locate its parameters. This self-referential approach allows the code to be its own map, eliminating the need for external security management structures or additional runtime resources.
3Reliability
If parameter bytecodes are stored in separate memory area, then security against malicious execution is enhanced, but memory access complexity increases
Solution Approach 1:
The compiler pre-calculates and embeds the offset information in the instruction bytecode during compilation. This preliminary action ensures that at runtime, the processor can directly access parameters using simple offset addition without complex lookup tables or additional memory access logic.
Data Source
Figure 1
Figure 2a~2c
Figure 3
AI summary
The invention relates to securing conditional branch instructions composed of intermediate code, which include an operation code followed by parameter fields. According to the invention, the parameters of these parameters are moved to a non-executable memory area, outside the bytecode array, and are replaced by, in the first parameter field, masked address information to this memory area and, in the other parameter fields, attack detection instructions. An attacker can thus no longer redirect the normal execution of the bytecode array to any of the parameters.