Machine Code Construction Instructions for Fault Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for executing machine code of secure functions in microprocessors cannot detect faults injection attacks with sufficient granularity, particularly failing to detect skipping of individual instructions, which compromises control flow integrity.
Innovation Solution
Incorporating a construction instruction into each word containing a protected instruction to ensure that skipping any instruction results in incomplete word loading, preventing the construction instruction from being loaded and thus detecting faults at a finer granularity, along with using unique expected signature values for each basic block to reliably identify control flow deviations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If construction instructions are associated with each basic block to detect control flow faults, then control flow integrity is improved, but instruction-level fault detection granularity deteriorates
Solution Approach 1:
The patent divides each basic block into multiple words, and associates construction instructions with individual instructions within those words rather than at the basic block level. This segmentation enables detection of faults at the instruction level (finer granularity) while maintaining control flow integrity verification at the basic block level.
Solution Approach 2:
The patent introduces a new dimension of verification by adding construction instructions that operate at the instruction/word level within each basic block. This creates a multi-level verification structure where both control flow (basic block level) and individual instruction execution (instruction level) can be monitored simultaneously, resolving the granularity limitation.
2Reliability
If each instruction is treated as protected with construction instructions, then fault detection capability is improved, but machine code complexity deteriorates
Solution Approach 1:
The patent segments the protection mechanism by applying construction instructions selectively at the word/instruction level within basic blocks rather than uniformly across the entire program. This segmentation allows fine-grained fault detection while managing complexity through localized application of protection instructions.
Solution Approach 2:
The patent applies construction instructions locally to specific words containing instructions to be protected, rather than applying the same protection mechanism uniformly throughout the machine code. This local quality approach enables enhanced fault detection capability while controlling overall code complexity by applying protection only where needed.
Data Source
AI summary
An execution method includes supplying of a machine code, the machine code being formed by a succession of base blocks and each base block being associated with a signature and comprising instructions to be protected. Each instruction to be protected is immediately preceded or followed by an instruction for constructing the value of the signature associated with the base block. Each construction instruction is coded on strictly less than N bits, and each word of the machine code which comprises at least one portion of one of said instructions to be protected also comprises one of the construction instructions so that A is not possible to load an instruction to be protected into an execution file, without at the same time loading a construction instruction which modifies the value of the signature associated with the base block when it is executed.