Dynamic JavaScript Obfuscation for Rogue Process Protection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional systems for electronic transactions over the Internet are vulnerable to rogue processes that can modify or prevent the execution of scripts, compromising personally identifiable information due to lack of persistent obfuscation and control flow alteration.
Innovation Solution
An improved technique that repeatedly delivers differently obfuscated scripts for each web page request, using meaningless function and variable names, and incorporating dummy procedure calls to misdirect attackers, ensuring the scripts remain functional and difficult to decipher, thereby enhancing security against malware interference.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional script obfuscators are used to protect against rogue processes, then script security is improved, but the obfuscation is easily reversed by determined attackers who can analyze execution patterns
Solution Approach 1:
The patent applies dynamic obfuscation by transforming the script at runtime based on execution context, rather than using static obfuscation. The script structure and function names are dynamically altered during execution, making it impossible for attackers to reverse-engineer the original functionality through static analysis or pattern recognition.
Solution Approach 2:
The system periodically transforms the script into different obfuscated versions during execution. Each transformation cycle changes function names, control flow, and data structures, creating a moving target that prevents attackers from establishing persistent analysis patterns across multiple execution cycles.
2Object-affected harmful factors
If static script obfuscation is applied to prevent rogue process interference, then function name recognition is blocked, but control flow patterns remain detectable by smart malware
Solution Approach 1:
The patent implements dynamic transformation of both control flow structures and function names during script execution. Control flow patterns are dynamically reordered and conditional logic is transformed based on runtime context, preventing malware from detecting functional patterns even when function names are obfuscated.
Solution Approach 2:
The system changes multiple script parameters simultaneously including function names, variable names, control flow structure, and execution order. This multi-parameter transformation approach ensures that even if one obfuscation layer is penetrated, multiple other layers remain to prevent rogue process interference.
3Reliability
If repeatedly differently obfuscated scripts are delivered for each web page request, then security against malware is significantly improved, but server processing overhead increases
Solution Approach 1:
The system performs preliminary transformation of the script into multiple pre-obfuscated versions before they are needed for delivery. These transformed versions are cached and ready for rapid delivery to clients, eliminating the need for real-time transformation during request handling and reducing server processing overhead.
Solution Approach 2:
The patent creates multiple copies of the script, each transformed into a different obfuscated version. These copies are stored and served to different clients or at different times, allowing the server to deliver secure scripts without performing transformation operations during actual request processing, thus maintaining high productivity.
Data Source
AI summary
An improved technique of providing computer code to a set of client computers is disclosed. In the improved technique, a set of files is generated, each file in the set of files including computer code configured to be read by an interpreter on each client computer, the computer code in each file including a set of functions, each function in the set of functions having a name, the name of a function in the set of functions in a first file in the set of files differing from the name of a corresponding function in the set of functions in a second file in the set of files, the computer code in the first file and the computer code in the second file being constructed and arranged to produce functionally equivalent sets of computer instructions when run through the interpreter on each client computer.