Secure Runtime Environment for Untrusted Native Code Execution
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing techniques for executing untrusted native code on computing devices often sacrifice performance, safety, and portability, as they rely on interpreted languages or virtual machine environments that incur significant overhead, and are inadequate in detecting malicious code, especially when dealing with untrusted applications downloaded from the internet.
Innovation Solution
A secure runtime environment is implemented to execute untrusted native code modules, enforcing code integrity, control-flow integrity, and data integrity, while moderating resource access, using hardware-supported segmented memory and a validation process to ensure safe execution without emulation or interpretation, allowing native code performance with enhanced security.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If interpreted languages or virtual machine environments are used to execute untrusted code, then security is improved, but execution performance deteriorates
Solution Approach 1:
The patent introduces a secure runtime environment as an intermediary layer between the untrusted native code and the host system. This mediator enforces security policies, monitors control flow, and validates code integrity without requiring full virtualization or interpretation, thereby maintaining native execution performance while providing security guarantees
Solution Approach 2:
The patent segments the execution environment into distinct components: the secure runtime environment, the untrusted native code module, and the host system. By dividing the address space and enforcing boundaries between these segments, the system achieves security through isolation without the performance overhead of complete virtual machine execution
2Reliability
If security mechanisms are added to execute untrusted applications, then security is improved, but system complexity increases
Solution Approach 1:
The patent applies security measures locally within the secure runtime environment rather than system-wide. By focusing security enforcement only where untrusted code executes, the system avoids the complexity of modifying the entire operating system while still providing robust security for the specific use case
3Reliability
If code integrity and control-flow integrity enforcement are implemented, then security is improved, but execution overhead increases
Solution Approach 1:
The patent performs code integrity and control-flow validation in advance during the loading phase, before execution begins. By pre-computing control flow paths and validating code integrity upfront, the system minimizes runtime overhead while maintaining strong security guarantees during actual code execution
Data Source
Figure 1
Figure 2
Figure 3A~3B
AI summary
A system that safely executes a native code module on a computing device. The system receives the native code module, which is comprised of untrusted native program code expressed using native instructions in the instruction set architecture associated with the computing device. The system then loads the native code module into a secure runtime environment, and proceeds to execute a set of instructions from the native code module in the secure runtime environment. The secure runtime environment enforces code integrity, control flow integrity, and data integrity for the native code module. Furthermore, the secure runtime environment moderates which resources can be accessed by the native code module on the computing device and/or how these resources can be accessed. By executing the native code module in the secure runtime environment, the system facilitates achieving native code performance for untrusted program code without a significant risk of unwanted side effects.