Dependency Network Weaving for Software Attack Resistance
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current software protection technologies inadequately address code-lifting and data-lifting attacks, as they fail to provide sufficient tamper resistance and concealment, making software applications vulnerable to unauthorized use and reverse-engineering.
Innovation Solution
A system and method that generate a highly dependent code by automatically weaving aggressive dependencies throughout the software application, combining tamper resistance and concealment mechanisms to prevent parts of the software from being used independently, and making it difficult to identify and remove these dependencies.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional software protection techniques (concealment and tamper-resistance) are used, then basic software protection is provided, but code-lifting and data-lifting attacks remain effective
Solution Approach 1:
The patent segments the software application into multiple modules with inter-dependencies, where each module relies on specific functions and data from other modules. This segmentation prevents code-lifting and data-lifting attacks by ensuring that extracted code or data cannot function independently without the complete dependency network.
Solution Approach 2:
The patent introduces a new dimension of protection by creating temporal and contextual dependencies between code segments. Code execution is made dependent on specific sequences and conditions, adding a temporal dimension to the traditional spatial/module-based protection, making lifted code ineffective outside its original context.
2Reliability
If dependencies are added to prevent code-lifting attacks, then attack resistance improves, but system complexity increases
Solution Approach 1:
The patent merges dependency management with the existing software architecture by integrating dependency declarations into standard programming practices. The dependency network is combined with the codebase in a way that leverages existing compilers and build systems, avoiding separate complex management layers.
Solution Approach 2:
The system performs self-verification of dependencies automatically during execution. The dependency verification mechanism operates transparently without requiring manual intervention or complex user-side management, allowing the system to self-manage and self-verify its integrity.
3Reliability
If aggressive dependencies are woven throughout the application, then tamper-resistance improves, but performance may be impacted
Solution Approach 1:
The patent applies partial dependency weaving by selectively adding dependencies to critical code segments and data structures rather than uniformly across the entire application. This partial action approach provides sufficient tamper-resistance for security-critical components while minimizing performance impact on less sensitive areas.
Solution Approach 2:
The patent changes execution parameters dynamically based on dependency verification results. When dependencies are satisfied, execution proceeds normally with standard performance characteristics. When dependencies fail or are suspicious, execution is modified to prevent tampering, allowing performance optimization for legitimate execution paths.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A method and system is provided to automatically propagate dependencies from one part of a software application to another previously unrelated part. Propagation of essential code functionality and data to other parts of the program serves to augment common arithmetic functions with Mixed Boolean Arithmetic (MBA) formulae that are bound to pre-existing parts of the program. A software application is first analyzed on a compiler level to determine the program properties which hold in the program. Thereafter, conditions are constructed based on these properties and encoded in formulae that encode the condition in data and operations. Real dependencies throughout the application are therefore created such that if a dependency is broken the program will no longer function correctly.