Native Code Security via Software Fault Isolation on ARM
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing computing systems grant trust to applications on an all-or-nothing basis, leading to security issues where native applications have full access to resources, potentially causing unwanted side effects, while web applications execute slower and provide limited functionality due to lack of direct access, necessitating a finer-grained application of trust.
Innovation Solution
A system that loads native code modules into a secure runtime environment using Software Fault Isolation (SFI) mechanisms to constrain store instructions and maintain control flow integrity, validating the modules before execution, and masking destination addresses to prevent unauthorized access, specifically adapted for ARM instruction set architectures.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If native applications are granted full access to resources, then execution performance is improved, but security risks increase due to potential unwanted side effects and resource manipulation
Solution Approach 1:
The patent segments the execution environment by loading native code modules into a sandboxed runtime environment rather than allowing direct system access. This segmentation isolates potentially harmful code while preserving execution performance, resolving the contradiction between performance and security.
Solution Approach 2:
The patent introduces a sandboxed runtime environment as an intermediary layer between native code modules and the operating system. This intermediary provides controlled access to resources, enabling performance optimization while preventing direct harmful access to system resources.
2Object-affected harmful factors
If web applications are executed with limited access to resources, then security is improved, but execution speed decreases by one to two orders of magnitude
Solution Approach 1:
The patent allows web applications to invoke native code modules that provide optimized execution paths. By copying the performance benefits of native code into the sandboxed environment through controlled native module invocation, the system achieves both security and improved execution speed.
Solution Approach 2:
The patent changes the execution parameters by allowing native code modules to run with optimized performance characteristics within the sandboxed environment. This parameter change enables web applications to achieve native-level performance while maintaining security through the sandboxed execution context.
3Object-affected harmful factors
If a sandboxed runtime environment is used for native code modules, then security is improved through isolation, but device complexity increases due to additional validation and constraint mechanisms
Solution Approach 1:
The patent applies preliminary validation actions by validating native code modules before execution and maintaining control flow integrity through code block division. These preliminary actions prevent harmful execution paths while maintaining relatively simple runtime mechanisms through advance preparation.
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 constrain store instructions in the native code module. The SFI mechanisms also maintain control flow integrity for the native code module by dividing a code region associated with the native code module into equally sized code blocks and data blocks and starting each of the data blocks with an illegal instruction.