Binary Code Decompiler Using Fixed Dimension Vectors

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Conventional systems lack the capability to decompile binary codes without source code, making it difficult to modernize applications and generate high-level executable code, as they are language-specific and unable to preserve original functionality.

Innovation Solution

A system that extracts binary codes, disassembles them into assembly language, converts into fixed dimension vectors, generates skeleton code, compiles, corrects errors, and optimizes vectors to produce high-level code, which is language-independent and capable of modernizing applications without requiring source code.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Adaptability or versatility

If conventional systems are used to decompile binary codes, then language-specific decompilation may be achieved, but the capability to decompile binary codes without source code is lost and original functionality cannot be preserved

Engineering Contradiction:
Improvecapability to decompile binary codes without source codeVSAvoidpreservation of original functionality
Core Design Contradiction:
Adaptability or versatilityVSReliability

Solution Approach 1:

The patent introduces an intermediary model trained on paired assembly code and high-level code that acts as a mediator to translate between the two representations. This model enables decompilation of binary codes without source code while preserving original functionality by learning the semantic correspondence between low-level and high-level representations.

Inventive Principle:
Principle #24Intermediary (Mediator)

Solution Approach 2:

The system transforms the decompilation problem by changing the parameters from direct binary-to-highlevel translation to a learned transformation through training data. By using training pairs of assembly code and corresponding high-level code, the system adapts the translation process to preserve functional semantics while enabling decompilation without original source code.

Inventive Principle:
Principle #35Parameter changes

2Adaptability or versatility

If binary codes are disassembled into assembly language and converted to high-level code, then language-independent decompilation is achieved, but the process becomes complex requiring multiple transformation steps

Engineering Contradiction:
Improvelanguage-independent decompilationVSAvoidcomplexity of multiple transformation steps
Core Design Contradiction:
Adaptability or versatilityVSDevice complexity

Solution Approach 1:

The patent merges multiple transformation steps (disassembly, conversion, translation) into a unified neural network model that performs the entire decompilation process in one integrated system. The model takes binary code as input and directly produces high-level code output, eliminating the need for separate transformation stages while achieving language-independent decompilation.

Inventive Principle:
Principle #5Merging (Combining)

Solution Approach 2:

The neural network model is designed with universal applicability to handle different binary code formats and generate corresponding high-level code across multiple programming languages. The single model performs multiple functions including disassembly interpretation, semantic translation, and syntax generation, reducing overall system complexity.

Inventive Principle:
Principle #6Universality (Multi-functionality)

Data Source

PatentUS11055077B2Deterministic software code decompiler system
Publication Date: 2021.07.06 BANK OF AMERICA CORP
  • US11055077B2 patent drawing
  • US11055077B2 patent drawing
  • US11055077B2 patent drawing

AI summary

A system for decompiling one or more codes includes a memory operatively coupled to a processor. The system is configured for extracting a binary code and one or more inputs associated with the binary code, disassembling the binary code into a first assembly language code based on the one or more inputs, converting the first assembly language code into first set of fixed dimension vectors, generating a skeleton code from the first set of fixed dimension vectors, optimizing the skeleton code, and generating a high level code.