AOT Compiler Bytecode Execution Secure Runtime
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing secure runtime environments face inefficiencies and increased memory usage when executing bytecode due to the impracticality of direct JIT compiler execution, which is slower and more memory-intensive compared to non-secured environments.
Innovation Solution
Implementing an AOT compiler outside the secure runtime environment to compile bytecode, with signature validation ensuring security and efficiency by checking the compiler and additional components' signatures before execution within the secure environment.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a JIT compiler is used to compile bytecode within the secure runtime environment, then the program can be executed with hardware independence, but the execution speed becomes significantly slower and memory consumption increases
Solution Approach 1:
The patent applies preliminary action by performing the compilation of bytecode to native code before the program execution in the secure runtime environment. An AOT (Ahead-of-Time) compiler compiles the bytecode externally into native code, which is then loaded and executed in the secure environment. This eliminates the need for JIT compilation during runtime, thereby resolving the contradiction by achieving both hardware independence through compilation and high execution speed through pre-compilation.
2Adaptability or versatility
If a JIT compiler is executed within the secure runtime environment, then bytecode can be translated to native code, but the memory consumption increases significantly
Solution Approach 1:
The patent applies the extraction principle by removing the compilation function from the secure runtime environment. The AOT compiler is executed outside the secure environment to generate native code, which is then imported into the secure environment for execution. This extraction eliminates the need for the secure environment to contain a JIT compiler, thereby reducing memory consumption while preserving bytecode translation capability.
3Reliability
If signature verification is performed on the compiler before compilation, then security is enhanced, but the compilation process becomes more complex
Solution Approach 1:
The patent applies preliminary action by performing signature verification of the compiler before the actual compilation process. The secure runtime environment verifies the digital signature of the AOT compiler to ensure its authenticity and integrity before allowing it to compile bytecode. This preliminary security check enhances reliability while maintaining a relatively simple compilation process, as the verification is performed once before compilation rather than during each compilation operation.
Data Source
Figure 1
AI summary
The method involves checking one or more signatures (S) comprising the signature of a compiler (AOT) outside of the secured run-time environment for validity by the secured run-time environment (TZ). A compilat (JBF) provided with a signature is generated from the bytecode by the compiler in the case of validity of the signature or signatures. An independent claim is also included for a microprocessor unit of a mobile terminal.