Byte-Pattern Code Integrity Checks Embedded in Program Logic
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional code integrity solutions are vulnerable to attacks due to their static nature, leading to inefficiencies, performance overhead, and ineffective protection, especially in large-scale systems, as attackers can predict and bypass integrity checks.
Innovation Solution
A dynamic code integrity solution that entangles the byte-pattern of target instructions with computations at selected check locations, integrating integrity checks into the program's logic, reducing computational overhead and obfuscating protection mechanisms.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of manufacture
If static signatures or hardcoded markers are used for code integrity verification, then the verification mechanism is simple to implement, but the system becomes predictable and vulnerable to attacks
Solution Approach 1:
The patent transforms static code integrity verification into a dynamic system by computing integrity values at runtime based on actual code execution states. Instead of using fixed signatures, the system calculates integrity metrics dynamically during program execution, making the verification process adaptive and unpredictable to attackers.
Solution Approach 2:
The patent changes the parameter of integrity verification from static hash values to dynamic computed values that vary based on execution context. This parameter transformation allows the system to maintain security robustness while keeping the implementation complexity manageable through algorithmic computation rather than static embedding.
2Reliability
If integrity checks are performed at all code locations, then comprehensive protection is achieved, but performance overhead increases significantly
Solution Approach 1:
The patent applies different verification intensities to different code regions based on their security criticality. High-risk areas receive more frequent or stringent checks, while low-risk areas use lighter verification, optimizing the balance between protection coverage and execution performance.
Solution Approach 2:
The patent implements selective integrity verification at strategically chosen locations rather than exhaustive checking throughout the entire codebase. This partial action approach achieves sufficient protection coverage while minimizing performance overhead by focusing resources on critical verification points.
3Reliability
If multiple integrity checks are distributed throughout the program, then coverage is improved, but the complexity of maintaining robust protection increases
Solution Approach 1:
The patent implements a universal integrity verification mechanism that can be applied consistently across different code locations and contexts. This multi-functional approach uses the same core verification logic adapted to various scenarios, reducing maintenance complexity compared to location-specific verification implementations.
Solution Approach 2:
The patent divides the codebase into segments or regions with similar verification requirements, allowing standardized integrity checks to be applied to each segment. This segmentation reduces overall system complexity by creating modular, reusable verification patterns rather than unique checks for every location.
4Reliability
If comprehensive integrity checks are performed on all code, then complete verification is achieved, but unnecessary resources are wasted on non-critical code
Solution Approach 1:
The patent applies differentiated verification strategies to different code regions based on their security importance. Critical code sections receive thorough integrity verification, while non-critical sections use simplified or skipped checks, eliminating waste of computational resources on low-value verification.
Solution Approach 2:
The patent performs integrity verification selectively on essential code portions rather than universally across all code. This partial action approach achieves sufficient verification completeness for security-critical areas while avoiding unnecessary computational expenditure on non-essential code.
Data Source
AI summary
A system and a method are disclosed for providing a lightweight code integrity solution. The system identifies one or more target code blocks in program code and determines one or more locations in the program code where an integrity check is to be embedded to verify the integrity of the code block. The system may determine an integer value associated with a byte-pattern of machine-code instructions in the code blocks and generates the integrity check by entangling the integer value into one or more computations of the program code. The system embeds the integrity check at the determined location in the program code.