Native Code Security via Software Fault Isolation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing computing systems apply trust to software on a coarse, all-or-nothing basis, leading to security issues and performance disparities between native and web applications, with native applications having full access to system resources and web applications executing slower and providing limited functionality.
Innovation Solution
A system that executes native code modules in a secure runtime environment using software fault isolation mechanisms to maintain control flow integrity and constrain store instructions, validating the modules before execution and bounding memory regions with guard areas to ensure secure and efficient execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If native applications are granted full access to system resources, then execution performance is improved, but security and stability are worsened due to unwanted side effects and system modifications
Solution Approach 1:
The patent segments the execution environment by introducing separate execution contexts (e.g., browser sandbox, application sandbox) that isolate native code modules from the rest of the system. This allows native code to execute with full performance while containing its access to specific, authorized resources only, preventing unwanted side effects on system stability.
Solution Approach 2:
The patent implements local quality by granting different levels of access to different parts of the system. Native code modules receive full access to resources needed for their specific functionality, while other system components maintain restricted access. This selective granting of privileges maintains performance where needed while protecting system stability elsewhere.
2Reliability
If web applications are executed with limited access to system resources, then security is improved, but execution speed and functionality are worsened
Solution Approach 1:
The patent implements dynamic access control where the execution context can adaptively grant or restrict access to system resources based on the specific native code module being executed. This allows the system to maintain security by default while dynamically enabling full access to native code that requires it, thus improving both security and performance as needed.
Solution Approach 2:
The patent changes the access parameters dynamically based on the execution context. When executing native code modules, the system adjusts memory access permissions, CPU register access, and other system parameters to match the performance requirements of native code while maintaining security boundaries. This parameter adjustment resolves the contradiction between security and performance.
3Device complexity
If all applications are treated with the same trust level, then system simplicity is maintained, but security vulnerabilities and performance disparities are exacerbated
Solution Approach 1:
The patent applies preliminary action by establishing execution contexts and trust levels before code execution begins. The system pre-configures security boundaries, resource access permissions, and execution environments based on the application type and source. This preliminary setup maintains simplicity in trust management while enabling differentiated security and performance characteristics for different application types.
Data Source
AI summary
Some embodiments provide a system that executes a native code module. During operation, the system obtains the native code module. Next, the system loads the native code module into a secure runtime environment. Finally, the system safely executes the native code module in the secure runtime environment by using a set of software fault isolation (SFI) mechanisms that maintain control flow integrity for the native code module and constrain store instructions in the native code module by bounding a valid memory region of the native code module with one or more guard regions.