Static Previrtualization for Untrusted Application Security
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing virtualization techniques leave vulnerabilities and inefficiencies in host systems, allowing untrusted applications to access unauthorized data and perform unauthorized device operations, despite efforts to ensure security and efficiency.
Innovation Solution
The method of static previrtualization transforms untrusted applications into trusted executables by replacing privileged and non-privileged system calls with hypercalls and library calls, respectively, and performing partial evaluation to create a scaled-down, self-contained, and secure application that can run on various platforms.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If virtualization is used to execute multiple independent programs on shared servers, then resource sharing and platform portability are improved, but security vulnerabilities and unauthorized access remain
Solution Approach 1:
The patent applies preliminary action by performing static analysis and transformation of applications before they are executed on the host system. The untrusted application is analyzed in advance to identify privileged system calls, and a transformed version is generated that replaces these calls with safe alternatives or removes them entirely, preventing unauthorized operations before execution occurs
Solution Approach 2:
The patent extracts and removes harmful components from the application by identifying privileged system calls that could enable unauthorized access or operations. These dangerous system calls are extracted from the application code and replaced with sanitized versions that either perform the operation safely or return an error, thereby eliminating the security vulnerability while preserving legitimate functionality
2Reliability
If proof carrying code is used to verify application safety, then security is improved, but system complexity and processing overhead increase
Solution Approach 1:
The patent applies self-service by enabling the application verification process to be performed automatically by the host system itself without requiring external trusted third parties. The host system's static analysis tools autonomously examine the application code, identify privileged system calls, and generate transformed versions, eliminating the need for complex external verification infrastructure
Solution Approach 2:
The patent replaces the mechanical manual verification process with automated static analysis tools that use software-based transformation techniques. Instead of requiring complex runtime monitoring or external verification systems, the solution uses compile-time or load-time static analysis to automatically generate safe versions of applications, simplifying the overall verification mechanism
3Ease of operation
If privileged system calls are allowed in applications, then functionality is improved, but unauthorized operations and data access become possible
Solution Approach 1:
The patent applies local quality by differentiating between different types of system calls and applying selective transformation rules. Not all system calls are treated uniformly - privileged system calls that could enable unauthorized operations are identified and transformed or removed, while non-privileged system calls are preserved to maintain application functionality. This selective approach ensures security where needed while preserving ease of operation where safe
Data Source
AI summary
A method for transforming untrusted applications into trusted executables through static previrtualization is disclosed. For example, the method receives an untrusted application and extracts a system call from the untrusted application. The method then determines if the system call is privileged or non-privileged. If the system call is privileged, the method replaces the system call with a hypercall. If the system call is non-privileged, it is replaced with a library call. The method repeats this process for additional system calls in the untrusted application to create a trusted executable. The method then forwards the trusted executable.