Method, apparatus and computer program support for regular recording of a positive integer

Abstract

A regular method for recoding a positive integer n in which an integer s smaller than n is chosen for defining an integer n′=n−s whose m-ary representation is added digit-wise to the m-ary representation of s to yield a recoded representation of n, for some integer m. Also provided are a device and a computer program product. An advantage of the present method is that it is regular.

Description

FIELD OF THE INVENTION

The present invention relates generally to digit recoding and, more specifically, to unsigned digit recoding.

BACKGROUND OF THE INVENTION

This section is intended to introduce the reader to various aspects of art, which may be related to various aspects of the present invention that are described and/or claimed below. This discussion is believed to be helpful in providing the reader with background information to facilitate a better understanding of the various aspects of the present invention. Accordingly, it should be understood that these statements are to be read in this light, and not as admissions of prior art.

Cryptographic exponentiation algorithms have been shown to be vulnerable to side channel attacks. In “Differential Power Analysis” (in M. J. Wiener, editor, Advances in Cryptology—CRYPTO '99, volume 1666 of Lecture Notes in Computer Science, pages 388-397, Springer Verlag 1999), Paul Kocher, Joshua Jaffe and Benjamin Jun describe an attack using observation of the power consumption, while attacks using observation of electromagnetic emanations have been described by Karine Gandolfi, Christophe Mourtel and Francis Olivier in “Electromagnetic Analysis: Concrete Results (in . K. Koç, D. Naccache and C. Paar, editors, Cryptographic Hardware and Embedded Systems—CHES 2001, volume 2162 of Lecture Notes in Computer Science, pages 251-261, Springer Verlag 2001) and by Jean-Jacques Quisquater and David Samyde in “Electromagnetic Analysis (EMA): Measures and Counter-Measures for Smart Cards” (in I. Attali and T. P. Jensen, editors, Smart Card Programming and Security (E-Smart 2001), volume 2140 of Lecture Notes in Computer Science, pages 200-210, Springer Verlag 2001).

These attacks, called Simple Power Analysis (SPA) and Simple Electromagnetic Analysis (SEMA), can reveal the exponent used in naïvely implemented exponentiation algorithms, as the operations required are dependent on the bitwise representation of the exponent.

Recoding algorithms have been developed in order to decrease the number of operations required to compute an exponentiation. The most commonly known example is Non-Adjacent Form (NAF) recoding described by Ian Blake, Gadiel Seroussi and Nigel Smart in “Elliptic Curves in Cryptography” (volume 265 of London Mathematical Society Lecture Note Series. Cambridge University Press. 1999). NAF recoding recodes the bits of an exponent using the values in {−1, 0, 1}. This reduces the number of multiplications that are required in the subsequent exponentiation algorithm, something that can be generalised to m-ary recoding, as described by Donald E. Knuth in The Art of Computer Programming (volume 2/Seminumerical Algorithms. Addison-Wesley, 2^nd edition, 1981). However, these recoding algorithms are designed to increase the efficiency of the exponentiation algorithms and not to increase the resistance to side channel attacks.

Several other recoding algorithms have been proposed:

• • Bodo Möller. “Parallelizable Elliptic Curve Point Multiplication Method with Resistance against Side-Channel Attacks”. In A. H. Chan and V. Gligor, editors, Information Security (ISC 2002), volume 2433 of Lecture Notes in Computer Science, pages 402-413, Springer Verlag 2002.
  • Bodo Möller. “Fractional Windows Revisited: Improved Signed-Digit Representation for Efficient Exponentiation”. In C. Park and S. Chee, editors, Information Security and Cryptology—ICISC 2004, volume 3506 of Lecture Notes in Computer Science, pages 137-153, Springer Verlag 2004.
  • Katsuyuki Okeya and Tsuyoshi Takagi. “A More Flexible Countermeasure against Side-Channel Attacks Using Window Method”. In C. D. Walter, . K. Koç and C. Paar, editors, Cryptographic Hardware and Embedded Systems—CHES 2003, volume 2779 of Lecture Notes in Computer Science, pages 397-410, Springer Verlag 2003.
  • Katsuyuki Okeya and Tsuyoshi Takagi. “The Width-w NAF method Provides Small Memory and Fast Elliptic Scalar Multiplications Secure against Side-Channel Attacks”. In M. Joye, editor, Topics in Cryptology—CT-RSA 2003, volume 2612 of Lecture Notes in Computer Science, pages 328-342, Springer Verlag 2003.

However, as noted by Yasuyuki Sakai and Kouichi Sakurai in “A New Attack with Side Channel Leakage During Exponent Recoding Computations” (In M. Joye and J.-J. Quisquater, editors, Cryptographic Hardware and Embedded Systems—CHES 2004, volume 3156 of Lecture Notes in Computer Science, pages 298-311, Springer Verlag 2004), to achieve a regular exponentiation algorithm any recoding algorithm that is used must also be regular. In a regular recoding algorithm, there is no test in the main loop during the evaluation of the algorithm.

While it could be argued that the recoding could be performed when the exponent is generated, this is for example not possible if the exponent is combined with a random value, as the recoding has to be performed just prior to the exponentiation. The combination with a random value is made to prevent certain side channel analyses, as described by Jean-Sébastien Coron in “Resistance against Differential Power Analysis for Elliptic Curve Cryptosystems” (In . K. Koç and C. Paar, editors, Cryptographic Hardware and Embedded Systems—CHES '99, volume 1717 of Lecture Notes in Computer Science, pages 292-302, Springer Verlag 1999) and by Paul Kocher in “Timing Attacks on Implementations of Diffie-Hellman, RSA, DSS, and Other Systems” (In N. Koblitz, editor, Advances in Cryptology—CRYPTO '96, volume 1109 of Lecture Notes in Computer Science, pages 104-113, Springer Verlag 1996).

Other recoding algorithms have been proposed in order to make the exponentiation regular. Bodo Möller describes in “Securing Elliptic Curve Point Multiplication against Side-Channel Attacks” (In G. Davida and Y. Frankel, editors, Information Security (ISC 2001), volume 2200 of Lecture Notes in Computer Science, pages 324-334, Springer Verlag 2001) a recoding algorithm for m-ary exponentiation. Each digit equal to zero is replaced with −m, and the next most significant digit is incremented by one. This leads to an exponent recoded with digits comprised in the set {1, . . . , m−1}U{-m}. Combined with the m-ary exponentiation algorithm, this implies that x^−m should be pre-computed. While this “computation is “easy” on elliptic curves, it is not the case for the multiplicative group of a finite ring.

An unsigned version of Möller's algorithm is described by Camille Vuillaume and Katsuyuki Okeya in “Flexible Exponentiation With Resistance to Side Channel Attacks” (In J. Zhou, M. Yung and F. Bao, editors, Applied Cryptography and Network Security—ACNS 2006, volume 3989 of Lecture Notes in Computer Science, pages 268-283, Springer Verlag 2006). The digits are recoded in the set {1, . . . , m}: each zero digit is replaced with m and the next digit is decremented by one.

A drawback with the signed and the unsigned versions of Möller's algorithm is that they cannot easily be implemented in a regular manner.

It will thus be appreciated that there is a need for a recoding algorithm for regular exponentiation where the exponent is simply recoded in a regular manner. This invention provides several variants for such a solution.

SUMMARY OF THE INVENTION

In a first aspect, the invention is directed to a regular method for recoding a first positive integer n being the exponent of a cryptographic exponentiation algorithm. A processor chooses a second integer s smaller than n, defines a third integer n′=n−s, and adds, for a fourth integer m, the m-ary representation of the third integer n′ digit-wise to the m-ary representation of s to yield a recoded representation of n.

In a first preferred embodiment, m=2^k.

In a second preferred embodiment,

$s=\sum _{i=0}^{I-2}s_im^i,$

where l denotes the m-ary length of n. It is advantageous that s_i=α for some 0<α<m; where, preferably, α=1 or α=m−1.

In a second aspect, the invention is directed to a device for regularly recoding a first positive integer n. The device comprises a processor adapted to: choose a second integer s smaller than n; define a third integer n′=n−s; and add, for a fourth integer m, the m-ary representation of the third integer n′ digit-wise to the m-ary representation of s to yield a recoded representation of n.

In a third aspect, the invention is directed to a computer program product storing instructions that, when executed by a processor, performs the method of the first aspect of the invention.

BRIEF DESCRIPTION OF THE DRAWINGS

Preferred features of the present invention will now be described, by way of non-limiting example, with reference to the accompanying drawings, in which:

FIG. 1 illustrates a device for digit recoding according to a preferred embodiment of the invention.

In the FIGURE, the represented blocks are functional entities, which do not necessarily correspond to physically separate entities. These functional entities may be implemented as hardware, software, or a combination of software and hardware; furthermore, they may be implemented in one or more integrated circuits.

PREFERRED EMBODIMENT OF THE INVENTION

FIG. 1 illustrates a device 100 for recoding digits, in particular digits of an exponent to be used in an exponentiation algorithm. The device 100 comprises at least one processor 110 (hereinafter “processor”) adapted to execute a computer program that performs the calculations of the recoding algorithm of any of the embodiments described hereinafter. It should be noted that the processor 110 may also be implemented in hardware, or a combination of software and hardware. The device 100 further comprises a memory 120 adapted to store data, such as for example intermediate calculation results from the processor 110. The device 100 also comprises at least one interface 130 (hereinafter “interface”) for interaction with other devices (not shown). FIG. 1 further illustrates a computer program product 140, such as for example a CD-ROM, storing a computer program that, when executed by the processor 110 performs recoding algorithms according to any of the two embodiments of the method of the invention.

In exponentiation, z=xⁿ is computed for an integer n and an element x in a (multiplicatively written) group. Let

$n=\sum _{i=0}^{I-1}d_im^i,$

where l is the m-ary length of n, denote the expansion of n in radix m (typically m=2^k). Take a positive integer s<n and define n′:=n−s. If

$n^{\prime }=\sum _{i=0}^{I-1}d_i^{\prime }m^i\mathrm{and}s=\sum _{i=0}^{I-1}s_im^i$

respectively denote the m-expansion of n′ and s, it follows that xⁿ=x^n′+s, where

$n^{\prime }+s=\sum _{i=0}^{I-1}k_im^i,$

where in turn k_i=d′_i+s_i.

If we define the most significant digit of s in radix m to be zero, then the most significant digit of n′ in radix m (i.e. k_l-1) will remain greater than, or equal to, zero. If this were not the case, then the recoding would not be unsigned and would thus not be suitable for groups where computing inversions are expensive.

First Preferred Embodiment

Let α be an integer satisfying 0<α<m.

Choose

$s=\sum _{i=0}^{I-2}\alpha m^i=\alpha \frac{m^{I-1}-1}{m-1}.$

This may be seen as setting all digits of s to the same value, i.e. α. Since n′_iε{0, . . . , m−1}, it follows that k_iε{α, . . . , α+(m−1)}. The following algorithm may then be used for the recoding.

Input: n≧1, m=2^k, l (the m-ary length of n).

Output: n=(k_l-1, . . . k₀)_m with k_iε{α, . . . , α+(m−1)}, 0≦i≦l−2

Algorithm:

s                    ←                                          α                                                                                                                          m                                                          l                              -                              1                                                                                -                          1                                                                          m                          -                          1                                                                                                                                                                                    and                                                                                                                                      n                                        ←                                          n                      -                      s
for i = 0 to l − 2 do
d ← n mod m
n ← └n/m┘
ki ← d + α
end
kl−1 ← n

A first preferred choice for α is 1, as it leads to smaller values for recoded digits. A second preferred choice for α is m−1, since this gives s=m^l-1 (i.e. a succession of k(l−1) set to 1).

Two examples will now illustrate the first preferred embodiment. For the two examples the parameters take the following values:

k=2

m=4

n=73=(1,0,2,1)₄=1·4⁰+2·4¹+0·4²+1·4³

l=4

In the first example α=1; in the second example α=m−1=3.

First Example (α=1) for the First Embodiment

$s:=\alpha \frac{m^{I-1}-1}{m-1}=1\frac{4^{4-1}-1}{4-1}=\frac{4^3-1}{3}=\frac{63}{3}=21$

n:=n−s=73−21=52

loop: for i=0 to l−2, i.e. for i=0 to 2

• • i=0:
    • d:=n mod m=52 mod 4=0
    • n:=└n/m┘=└52/4┘=13
    • k₀:=d+α=0+1=1
  • i=1:
    • d:=n mod m=13 mod 4=1
    • n:=└n/m┘=└13/4┘=3
    • k₁:=d+α=1+1=2
  • i=2:
    • d:=n mod m=3 mod 4=3
    • n:=└n/m┘=└3/4┘=0
    • k₂:=d+α=3+1=4

k₃:=n=0

k=(k₃,k₂,k₁,k₀)=(0,4,2,1)

$\begin{array}{c}n=\sum _{i=0}^{I-1}k_im^i\\ =1·4^0+2·4^1+4·4^2+0·4^3\\ =1·1+2·4+4·16\\ =1+8+64\\ =73\end{array}$

As expected, the recoded n is equal to the original n.

Second Example (α=m−1=3) for the First Embodiment

$s:=\alpha \frac{m^{I-1}-1}{m-1}=m^{I-1}-1=4^3-1=63$

n:=n−s=73−63=10

loop: for i=0 to l−2, i.e. for i=0 to 2

• • i=0:
    • d:=n mod m=10 mod 4=2
    • n:=└n/m┘=└10/4┘=2
    • k₀:=d+α=2+3=5
  • i=1:
    • d:=n mod m=2 mod 4=2
    • n:=└n/m┘=└2/4┘=0
    • k₁:=d+α=2+3=5
  • i=2:
    • d:=n mod m=0 mod 4=0
    • n:=└n/m┘=└0/4┘=0
    • k₂:=d+α=0+3=3

k₃:=n=0

k=(k₃,k₂,k₁,k₀)=(0,3,5,5)

$\begin{array}{c}n=\sum _{i=0}^{I-1}k_im^i\\ =5·4^0+5·4^1+3·4^2+0·4^3\\ =5·1+5·4+3·16\\ =5+20+48\\ =73\end{array}$

As expected, the recoded n is once more equal to the original n.

It should be noted that the algorithm according to the first embodiment is simple to implement, but that it requires knowledge of the m-ary length of n (i.e. of l) ahead of time. As this may be a drawback, a second preferred embodiment overcomes this problem, while it is a little bit more complicated to implement.

Second Preferred Embodiment

If one looks in more detail at the subtraction step, n′:=n−s, one may set up the following equations d′_i=(d_i−s_i+γ_i)mod m and

${\gamma }_{i+1}=\lfloor \frac{d_i-s_i+{\gamma }_i}{m}\rfloor \in \left\{-1,0\right\},$

where the “borrow” is initialised to 0, i.e. γ₀=0. This is the classical subtraction algorithm learnt at school. Since d_i,s_iε{0, . . . , m−1}, this gives k_i=d′_i+s_i which is equal to d_i+γ_i, if d_i+γ_i≧s_i, and d_i+γ_i+m otherwise.

Hence, for any choice of s_i≠0 when d_iε{0,1} leads to a non-zero value for k_i. As in the first preferred embodiment,

$s=\sum _{i=0}^{I-2}\alpha m^i$

for some 0<α<m. Further, to use only unsigned arithmetic, γ′_i=γ_i+1ε{0,1}:

$\begin{array}{c}{\gamma }_i^{\prime }={\gamma }_i+1\\ =\lfloor \frac{d_i-s_i+{\gamma }_i}{m}\rfloor +1\\ =\lfloor \frac{d_i-s_i+{\gamma }_i+m}{m}\rfloor \\ =\lfloor \frac{d_i-s_i+{\gamma }_i^{\prime }-1+m}{m}\rfloor \end{array}$

Input: n≧1, m=2^k, 0<α<m

Output: n=(k_l-1, . . . k₀)_m with k_iε{α, . . . , α+(m−1)}, 0≦i≦l−2

Algorithm:

i ← 0; γ′ ← 1
while n ≧ (m + α) do
d ← n mod m
d′ ← d + γ′ + m − α − 1
ki ← (d′ mod m) + α
γ′ ← └d′/m┘
n ← └n/m┘
i ← i + 1
end
ki ← n + γ′ − 1

As in the first preferred embodiment, preferred choices for α are 1 and m−1.

Two examples will now illustrate the second preferred embodiment. For the two examples the parameters take the following values:

k=2

m=4

n=73=(1,0,2,1)₄=1·4⁰+2·4¹+0·4²+1·4³

In the first example α=1; in the second example α=m−1=3.

First Example (α=1) for the Second Embodiment

i:=0

γ′=1

n=73≧(m+α)=4+1=5, so the while-loop is executed

• • d:=n mod m=73 mod 4=1
  • d′:=d+γ′+m−α−1=1+1+4−1−1=4
  • k₀:=(d′ mod m)+α=(4 mod 4)+1=0+1=1
  • γ′:=└d′/m┘=└4/4┘=1
  • n:=└n/m┘=└73/4┘=18
  • i:=i+1=0+1=1

n=18≧(m+α)=4+1=5, so the while-loop is executed again

• • d:=n mod m=18 mod 4=2
  • d′:=d+γ′+m−a−1=2+1+4−1=5
  • k₁:=(d′ mod m)+α=(5 mod 4)+1=1+1=2
  • γ′:=└d′/m┘=└5/4┘=1
  • n:=└n/m┘=└18/4┘=4
  • i:=i+1=1+1=2

n=4<(m+α)=4+1=5, so the while-loop is NOT executed again k₂:=n+γ′1=4+1−1=4

k=(k₃,k₂,k₁,k₀)=(0,4,2,1)

$\begin{array}{c}n=\sum _{i=0}^{I-1}k_im^i\\ =1·4^0+2·4^1+4·4^2+0·4^3\\ =1·1+2·4+4·16\\ =1+8+64\\ =73\end{array}$

As expected, the recoded n is equal to the original n.

Second Example (α=m−1=3) for the Second Embodiment

i:=0

γ′=1

n=73≧(m+α)=4+3=7, so the while-loop is executed

• • d:=n mod m=73 mod 4=1
  • d′:=d+γ′+m−α−1=1+1+4−3−1=2
  • k₀:=(d′ mod m)+α=(2 mod 4)+3=2+3=5
  • γ′:=└d′/m┘=└2/4┘=0
  • n:=└n/m┘=└73/4┘=18
  • i:=i+1=0+1=1

n=18≧(m+α)=4+1=5, so the while-loop is executed again

• • d:=n mod m=18 mod 4=2
  • d′:=d+γ′+m−α−1=2+0+4−3−1=2
  • k₁:=(d′ mod m)+α=(2 mod 4)+3=2+3=5
  • γ′:=└d′/m┘=└2/4┘=0
  • n:=└n/m┘=└18/4┘=4
  • i:=i+1=1+1=2

n=4<(m+α)=4+1=5, so the while-loop is NOT executed again k₂:=n+γ′−1=4+0−1=3

k=(k₃,k₂,k₁,k₀)=(0,3,5,5)

$\begin{array}{c}n=\sum _{i=0}^{I-1}k_im^i\\ =5·4^0+5·4^1+3·4^2+0·4^3\\ =5·1+5·4+3·16\\ =5+20+48\\ =73\end{array}$

As expected, the recoded n is equal to the original n.

It will be appreciated that both embodiments as expected give the same recoded digits for the same input. For example the first example gives (4,2,1) for both embodiments, while the second embodiment gives (3,5,5) for both embodiments.

It will also be appreciated that both embodiments are regular, as there are no tests inside the main loop; in the first embodiment, there is no test inside the for loop, and in the second embodiment, there is no test inside the while loop.

It may thus be appreciated that the present invention enables regular recoding of a positive integer.

Each feature disclosed in the description and (where appropriate) the claims and drawings may be provided independently or in any appropriate combination. Features described as being implemented in hardware may also be implemented in software, and vice versa. Connections may, where applicable, be implemented as wireless connections or wired, not necessarily direct or dedicated, connections.

Reference numerals appearing in the claims are by way of illustration only and shall have no limiting effect on the scope of the claims.

Claims

1. A regular method for recoding a first positive integer n being the exponent of a cryptographic exponentiation algorithm, the method comprising the steps, in a processor, of: choosing a second integer s smaller than n;defining a third integer n′=n−s;adding, for a fourth integer m, the m-ary representation of the third integer n′ digit-wise to the m-ary representation of s to yield a recoded representation of n.

2. The method of claim 1, wherein m=2k.

3. The method of claim 1, wherein

4. The method of claim 3, wherein si=α for some 0<α<m.

5. The method of claim 4, wherein α=1.

6. The method of claim 4, wherein α=m−1.

7. A device for regularly recoding a first positive integer n, the device comprising a processor adapted to: choose a second integer s smaller than n;define a third integer n′=n−s;add, for a fourth integer m, the m-ary representation of the third integer n′ digit-wise to the m-ary representation of s to yield a recoded representation of n.

8. A computer program product storing instructions that, when executed by a processor, performs the method of.