Program Execution Integrity via Precomputed Signature Verification
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Data processing systems face challenges in ensuring the integrity of data due to unpredictable bit changes from radiation, faulty software, and malicious software, necessitating a reliable method for detecting data corruption and ensuring safe code execution.
Innovation Solution
A method and device that utilize signature functions, such as checksums or hash functions, to verify the integrity of program instructions by comparing protection signatures with recomputed verification signatures during execution, and store instructions with associated protection signatures on data carriers, ensuring data integrity and protection against unauthorized access.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If signature functions (checksums or hash functions) are used to verify data integrity, then data corruption detection capability is improved, but device complexity increases due to additional computation and storage requirements
Solution Approach 1:
The patent pre-computes and stores protection signatures for all instructions during program compilation or loading. This preliminary action eliminates the need for complex real-time verification computations during execution, as the system only needs to compare the pre-stored signature with a simple recomputed value, thus resolving the contradiction between reliability improvement and complexity increase
Solution Approach 2:
The patent creates a copy of the protection signature and stores it separately alongside the instruction. This copying approach allows for simple comparison-based verification without requiring complex verification algorithms during execution, maintaining low device complexity while achieving high data corruption detection capability
2Reliability
If protection signatures are stored with each instruction, then code execution safety is improved, but memory usage increases
Solution Approach 1:
The patent applies protection signatures selectively to instructions that require integrity verification, rather than uniformly to all data in the system. This local quality approach ensures that memory is consumed only where necessary for safety-critical code execution, balancing reliability improvement with controlled memory usage
Solution Approach 2:
The patent allows the protection signature length to be configured based on system requirements. By changing the parameter of signature bit length (e.g., 7 bits providing 128 possible signatures), the system can adjust the balance between code execution safety and memory consumption to match specific application needs
3Reliability
If verification is performed for every instruction during execution, then data integrity is improved, but execution speed decreases
Solution Approach 1:
The patent pre-computes protection signatures during program loading or compilation and stores them with instructions. During execution, the verification process simply compares the pre-stored signature with a quickly recomputed value, rather than performing complex verification algorithms, thus maintaining high data integrity while minimizing impact on execution speed
Solution Approach 2:
The patent uses simple, computationally inexpensive signature verification that can be performed rapidly for each instruction. The verification process uses basic operations (recomputation and comparison) that are cheap in terms of processing time, allowing frequent verification without significantly slowing down program execution
Data Source
AI summary
A device and a method for executing a program, and a method for storing a program are described. The method of executing a program includes a sequence of instruction cycles, wherein each instruction cycle comprises: updating the program counter value; reading a data word from a memory location identified by the updated program counter value, wherein the data word comprises an instruction and a protection signature; determining a verification signature by applying a signature function associated with the program counter value to the instruction; executing the instruction if the verification signature and the protection signature are consistent with each other; and initiating an error action if they are inconsistent with each other. A method for storing a program on a data carrier is also described.