Function Fingerprints for Partial Code Theft Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for combating software theft focus on the entire code and fail to detect when only portions of the underlying code are stolen, as they cannot identify unique portions that provide value, allowing thieves to modify or remove watermarks or hash values to evade detection.
Innovation Solution
Generating fingerprints for functions in compiled computer binaries using block rank scores and ordered lists of blocks to identify similarities, allowing for the detection of stolen code even when the overall operation of the software is different.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If watermarks are applied to the entire software code, then software theft can be detected, but the technique fails when only portions of code are stolen and allows thieves to remove watermarks to evade detection
Solution Approach 1:
The patent segments the software code into individual functions and further into basic blocks, creating a hierarchical structure where each segment can be independently analyzed. This allows the system to detect theft at multiple levels - entire software, specific functions, or individual basic blocks - without requiring modification of the entire codebase. The segmentation enables detection of partial theft while maintaining system simplicity.
Solution Approach 2:
The patent extracts unique identifying features (fingerprints) from specific segments of code (functions and basic blocks) without modifying the original code. By taking out only the essential fingerprint information and storing it separately, the system can detect theft through comparison without altering the software's operation or requiring complex code modifications.
2Measurement precision
If hash values are used to compare entire codebases, then complete software theft can be detected, but the method cannot identify partial code theft or unique valuable portions
Solution Approach 1:
The patent divides the codebase into functions and basic blocks, creating a segmented measurement system. Instead of analyzing the entire codebase as a single unit, the system measures and compares individual segments (functions and basic blocks) to identify unique valuable portions. This segmentation enables precise detection of partial theft while reducing the quantity of code that needs to be analyzed at any given time.
Solution Approach 2:
The patent applies local quality analysis by generating unique fingerprints for specific segments (functions and basic blocks) that contain distinctive characteristics. Rather than treating the entire codebase uniformly, the system identifies and analyzes local regions with unique properties, enabling detection of partial theft and identification of valuable code portions without analyzing the entire codebase.
3Reliability
If watermarks are embedded in the software, then theft detection is possible, but the watermarks can be removed from stolen software to evade detection
Solution Approach 1:
The patent extracts fingerprint information from code segments and stores it separately as a reference database. By taking out only the essential fingerprint data and storing it externally, the system can detect theft through comparison without embedding watermarks within the code itself. This eliminates the ability of thieves to remove watermarks while maintaining detection reliability.
Solution Approach 2:
The patent introduces a reference database of fingerprints as an intermediary between the original code and the detection process. Instead of embedding watermarks directly in the code, the system creates a mediator (fingerprint database) that stores characteristic features. Detection occurs by comparing fingerprints from suspected stolen code against this intermediary reference, making watermark removal ineffective since the fingerprints are extracted and stored separately.
Data Source
AI summary
Systems and methods of detecting copying of computer code or portions of computer code involve generating unique fingerprints from compiled computer binaries. The unique fingerprints are simplified representations of functions in the compiled computer binaries and are compared with each other to identify similarities between functions in the respective compiled computer binaries. Copying can be detected when there are sufficient similarities between fingerprints of two functions.