Executable Code Information Hiding via Reversible Instruction Swapping

Resolve Bottlenecks,
Find Innovative Solutions
Generate 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

VSEngineering 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

Engineering Contradiction:
Improveinformation hiding capabilityVSAvoiddetectability of hidden information
Core Design Contradiction:
Loss of informationVSDifficulty of detecting and measuring

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.

Inventive Principle:
Principle #35Parameter changes

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.

Inventive Principle:
Principle #17Another dimension (Dimensionality change)

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

Engineering Contradiction:
Improvedata embedding capacityVSAvoidcomplexity of identifying swap locations
Core Design Contradiction:
Loss of informationVSDevice complexity

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.

Inventive Principle:
Principle #10Preliminary action

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.

Inventive Principle:
Principle #24Intermediary (Mediator)

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

Engineering Contradiction:
Improveundetectability of embeddingVSAvoidcomplexity of matrix generation and management
Core Design Contradiction:
Difficulty of detecting and measuringVSDevice complexity

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.

Inventive Principle:
Principle #35Parameter changes

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.

Inventive Principle:
Principle #26Copying

Data Source

PatentUS11520865B2Method for swapping adjacent instructions midstream in software executables in order to hide information therein
Publication Date: 2022.12.06 THE UNITED STATES OF AMERICA AS REPRESENTED BY THE SECRETARY OF THE NAVY
  • US11520865B2 patent drawing
  • US11520865B2 patent drawing
  • US11520865B2 patent drawing

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.