Compiler Modularization for Secure Enclave Protection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing software application protection methods, such as antipiracy and anti-cheat measures, often negatively impact legitimate users and are difficult to integrate after the software development is completed, reducing profitability and requiring significant developer effort.
Innovation Solution
A compiler that automatically modularizes identified functions or portions of source code to be executed within a secure enclave, enabling encryption and protection, thereby providing antipiracy and anti-cheat benefits with minimal developer effort, even after the software development is finished.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional antipiracy and anti-cheat functionality is integrated into software application programs, then piracy and cheating are prevented, but legitimate users experience negative impact and developer effort increases
Solution Approach 1:
The patent segments the software application into protected and unprotected portions, with only critical functions executed in secure enclaves. This segmentation allows piracy prevention to be applied selectively rather than globally, reducing the negative impact on legitimate users while maintaining protection where needed.
Solution Approach 2:
The patent introduces a compiler as an intermediary tool that automatically identifies and modularizes functions requiring protection. This intermediary handles the complexity of integration, shielding developers from the burden of manual protection implementation while maintaining user experience.
2Reliability
If antipiracy and anti-cheat functionality is added after software development is completed, then protection is provided, but developer time and effort increase significantly
Solution Approach 1:
The patent enables preliminary identification of protected functions during the compilation stage, allowing protection to be integrated automatically without requiring post-development modifications. Developers can specify protection requirements in advance, and the compiler handles the modularization and enclave integration automatically.
Solution Approach 2:
The patent implements self-service through automatic modularization, where the compiler autonomously identifies, separates, and protects critical functions without requiring extensive developer intervention. The system serves itself by using static analysis and developer annotations to automatically generate the protected architecture.
3Productivity
If developers focus on core functionality rather than antipiracy integration, then software development efficiency improves, but protection integration becomes more difficult
Solution Approach 1:
The compiler acts as an intermediary that bridges core functionality development and protection integration. Developers focus on writing core logic while the compiler automatically handles protection integration through static analysis and automatic modularization, reducing the perceived complexity for developers.
Solution Approach 2:
The system implements self-service through automatic protection integration, where the compiler autonomously performs the complex task of identifying protected functions, modularizing them, and integrating enclave execution without requiring developers to manually manage the complexity of protection integration.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A compiler automatically modularizes identified functions or portions of source code, thereby enabling developers to merely identify portions of source code that represent functionality that is to be protected, including going back and identifying such portions after the programming of the software application program has been substantially completed. Such identification can be inline, within the source code itself, or specified in an external file. During compilation of such source code, a compiler recognizes such identifications and appropriately compiles the source code such that the relevant portions of the software application program are appropriately modularized, including inserting functionality to provide for marshaling of parameters between functionality that will be protected and functionality that will be executed outside of the enclave, as well as appropriately modifying pointers or addresses to be position independent based upon where the functionality making reference to such pointers or addresses will be executed.