Encrypted Preamble for Software Algorithm Security
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Licensed software algorithm executables are vulnerable to unauthorized code modification and execution, as existing methods like checksums are inadequate in preventing hacking and unauthorized execution, with tools like DEBUG.EXE enabling hacking by altering the logic flow.
Innovation Solution
A novel solution is provided by using an encrypted preamble binary file that requires authorization for CPU execution, tracing unauthorized attempts through land line modem phone numbers, and disabling software execution when unauthorized, employing a system with licensing software engines, CPUs, and encryption/decryption technologies to ensure secure execution.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional checksum methods are used for software protection, then implementation is simple, but security against unauthorized execution and code modification is insufficient
Solution Approach 1:
The software is segmented into a protected preamble portion and a main algorithm portion. The preamble contains authorization logic that is separately protected and verified before the main algorithm executes. This segmentation allows the critical authorization code to be protected through multiple copies and verification mechanisms without protecting the entire software, thus improving security while managing complexity.
Solution Approach 2:
Authorization verification is performed as a preliminary action before the main software algorithm executes. The preamble must be successfully verified and authorized before the protected software can run. This preliminary check prevents unauthorized execution from occurring in the first place, addressing the security weakness of traditional checksum methods that only detect rather than prevent unauthorized execution.
2Reliability
If software authorization is strictly controlled, then unauthorized execution is prevented, but legitimate software updates and modifications become difficult
Solution Approach 1:
The authorization system is made dynamic by allowing the preamble to be re-authorized and re-loaded. When software updates are needed, the updated preamble can be authorized through the same verification process, enabling legitimate modifications while maintaining security. The system adapts to changes by re-running the authorization protocol rather than being locked into a static authorization state.
Solution Approach 2:
The authorization system provides self-service capabilities through automated verification processes. The software itself performs the authorization check of its preamble before execution, and can request re-authorization when needed. This automated approach reduces the manual overhead for both security enforcement and legitimate updates, balancing control with adaptability.
3Reliability
If multiple copies of preamble are stored for verification, then hacking opportunity is minimized, but storage space and system resources increase
Solution Approach 1:
Different qualities are assigned to different parts of the software system. The critical preamble portion is stored in multiple protected copies in ROM with specialized protection, while the main algorithm can be stored in more flexible locations. This local differentiation ensures high reliability for the authorization-critical preamble without requiring multiple copies of the entire software, thus minimizing storage overhead while maintaining hacking resistance.
Data Source
AI summary
A computer-implemented system for providing security to a proprietary software algorithm is presented. The system, known as Software Algorithm Security (“SAS”), is a form of individual heuristic copy protection requiring a provable national origination to execute. The SAS completely encrypts a software algorithm's executable preamble, thereby making alteration of executable image logic close to impossible. Making use of the ability to safeguard a single executable image, Software Licensing Logic was designed to preamble software for licensing purposes. Each algorithm licensed could be tracked and reported if executed illegally, or hacked. Illegal execution would include not originating execution from a preset collective of land line phone numbers or attempting to execute the executable image outside the confines of a national boundary.