Executable Code Information Hiding via Reversible Instruction Swapping
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for hiding information in executable code are easily discoverable and lack effectiveness in maintaining functionality and performance.
Innovation Solution
The method involves identifying interchangeable assembly-level instructions, organizing them into random matrices, inverting submatrices to achieve full column rank, and encoding binary information by reversing instruction orders, which are stored securely to maintain executable code functionality.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of information
If previous methods switch between semantically equivalent instructions to embed data, then information can be hidden in executable code, but the method is easily discoverable and lacks effectiveness
Solution Approach 1:
The patent changes the parameters of instruction embedding by using multiple interchangeable instruction pairs with different operational characteristics (arithmetic, logic, data movement). Instead of relying on simple semantic equivalence, the method varies instruction parameters such as opcode types, operand structures, and execution semantics while maintaining functional equivalence. This makes detection more difficult because the embedded data is distributed across diverse instruction types rather than a single pattern.
Solution Approach 2:
The patent introduces a new dimension to instruction swapping by organizing interchangeable instructions into matrix structures where rows represent different instruction pairs and columns represent different embedding positions. This matrix-based approach adds structural complexity beyond simple pairwise substitution, creating a multi-dimensional embedding space that is harder to analyze and detect through traditional static analysis methods.
2Loss of information
If instructions are swapped to encode binary information, then data can be embedded, but the complexity of identifying valid swap locations increases
Solution Approach 1:
The patent performs preliminary analysis to identify all valid interchangeable instruction pairs before the embedding process. By pre-computing and storing the set of valid swap locations and their corresponding instruction pairs, the method eliminates the need for complex real-time analysis during data embedding. This preliminary action creates a lookup table of valid positions, simplifying the actual embedding operation while maintaining comprehensive coverage of possible swap locations.
Solution Approach 2:
The patent introduces an intermediary matrix structure that mediates between the hidden data and the instruction swaps. The matrix serves as an intermediate representation that maps data bits to specific instruction pair selections and swap positions. This intermediary layer simplifies the embedding process by providing a systematic method to translate arbitrary data into a sequence of valid instruction swaps without requiring complex optimization or analysis at embedding time.
3Difficulty of detecting and measuring
If random matrices are used to organize instruction pairs, then undetectability improves, but the process requires generating and managing multiple matrices with full column rank
Solution Approach 1:
The patent changes the parameters of the embedding process by using random matrix generation with specific mathematical properties (full column rank). Instead of using fixed or deterministic patterns to select instruction pairs, the method employs randomly generated matrices where the statistical properties provide unpredictability. The full column rank requirement ensures mathematical validity for data recovery while the randomness enhances undetectability. This parameter change from deterministic to probabilistic selection is key to improving security.
Solution Approach 2:
The patent creates multiple copies of the embedding structure through generating multiple random matrices, each capable of independently embedding and recovering data. Rather than relying on a single complex embedding scheme, the method produces a set of equivalent matrices that can serve as backups or alternatives. This copying approach distributes the complexity across multiple simpler structures, making the overall system more robust and harder to analyze while maintaining the same functional capabilities.
Data Source
AI summary
A method for hiding information in executable code comprising: identifying a set of pairs of interchangeable instructions, wherein each pair has an instruction order of execution that is reversible without changing a functionality of the executable code; organizing the pairs into a plurality of matrices based on a set of random seeds; for each matrix, inverting a submatrix consisting of a subset of columns from each matrix to identify a subset of pairs; identifying a matrix that has full column rank on a subset of columns that is a function of the pairs' location; storing an index of the identified matrix's associated seed in a secure data storage location; and encoding data into the executable code by reversing the order of execution of the subset of pairs and treating each pair having reversed instructions as a “1” and each pair of non-reversed instructions as a “0” or vice versa.


