Cryptography Reference
In-Depth Information
The board was connected to a PC with both a null modem cable and an Ethernet
cable: the first provided an interface with the Linux shell running on the ARM chip,
while the second was used to provide the network connection needed for both booting
the board via TFTP and providing the storage via NFS.
16.3.2 Graceful Degradation of Outputs
The first experiment run on the target chip was aimed at investigating whether the
appearance of errors in the system followed the gradual behavior we expected. The
ARM9 processor has three separate supply lines, one for the core, one for the I/O
buses and one for the memory interface; we chose to interact with the one feeding
the computational part, due to its critical importance for the correct execution of the
binaries run on the device.
To detect the frequency of the appearance of faults, in order to determine how fast
they appear during the execution of a program, we tested the correct functioning of
the CPU using a simple probe program, whose core loop is as follows:
for (a = i = 0; i < 1000000; i++) {
a=a+1;
if (a != i + 1) {
printc('?');
if (a != i + 1) {
printc('#');
a = i + 1;
/* fix the fault */
if (a != i + 1)
a=i+1;
}
}
}
The aforementioned code increments a variable a million times, and checks if a
fault has happened exactly after the increment. A redundant check is added to lower
the likelihood of a false positive occurring in the detection: we consider an actual
fault as such only if both checks confirm it. This program was run multiple times
while decreasing the voltage of the power supply of 1 mV at a time: 500
10
3
runs
were performed at each voltage level probed and the results output by the code were
stored.
Figure
16.3
represents the percentage of correct computations over 5
×
10
7
runs
for each voltage level probed. The errors in the output grow linearly with the lapse
in the voltage supply, thus confirming our hypothesis of gradual degradation in the
quality of the results. The dashed line in the figure points out the voltage point where
the number of faulty computations is the same as that of the correct ones.
After ascertaining that the faulty computations of a program were happening
slowly, we moved on to consider the number of faults appearing during each single
×
