Cryptography Reference
In-Depth Information
C
d
m
ˆ
=
mod
N
.
m
−
1
.The
induced error can be modeled as a
bit-flip
of the
t
-th bit of
d
. Therefore, we have
The fault is exploited by dividing the erroneous result by a correct one:
m
ˆ
·
C
i
=
n
−
1
d
t
t
2
i
2
t
·
d
i
+
m
ˆ
=
mod
N
.
i
=
0
,
i
=
C
−
2
t
mod
N
C
2
t
mod
N
m
−
1
m
−
1
That implies that either
m
ˆ
·
=
⇒
d
t
=
1, or
m
ˆ
·
=
⇒
d
t
0. This method can be repeated until we obtain enough information on the
private exponent. Note that this attack is also suitable in the case of a multiple error
model [20]. Moreover, the principle can be adapted to attacking cryptosystems based
on discrete logarithms (e.g. DSA, El-Gamal). Finally, this attack strategy has been
extended and generalized by Joye et al. [203], who describe an improved attack that
relies on knowledge of faulty deciphered texts.
=
7.3.1.3 Exploiting Safe-Errors
Classical fault attacks often exploit the difference between a correct and a faulty
output to deduce some secret information. However, Joye and Yen noticed that some
secret information may leak even if a fault causes no effect on the final result of
the computation [427]. This is why this particular kind of fault attacks is also called
“safe-error” attack. The attacker must be able to perform some perturbation which
has a significant probability of achieving a given effect. Among these attacks, two
categories are usually distinguished between: C safe-error attacks that target dummy
operations [429] and M-safe-error attacks that target register allocations [427]. In
order to illustrate the principle of safe-error attacks in the context of RSA, we have
chosen to detail the C safe-error attacks against the Square and Multiply Always
exponentiation [102].
General Methodology
The purpose of the Square and Multiply Always exponentiation is to make its
execution independent from the exponent value. Hence, the conditional branch is
withdrawn (see Sect.
7.2.2
) and an extra dummy multiplication is added such that,
regardless of the value of the exponent, a square and a multiplication are always
executed at each iteration. The principle of the C safe-error attacks proposed by Yen
et al. [429] is to exploit faults induced while dummy multiplications are performed.
To achieve this, the attacker has to inject a fault during the computation of an RSA
signature and, if the signature remains “error-free”, it means that a dummy multi-
plication has been infected. Therefore, the attacker can deduce that the exponent bit
value handled while the perturbation was provoked is 0. Otherwise, the result would
be incorrect and the exponent bit value equal to 1. The attacker has to repeat the attack
at each iteration to gradually recover the whole private exponent. One can notice that
this attack does not apply to the classical exponentiation algorithm but applies to a
