A METHOD AND A DEVICE FOR PERFORMING TORUS-BASED CRYPTOGRAPHY

Abstract

At CRYPTO 2003, Rubin and Silverberg introduced the concept of torus-based cryptography over a finite field. The present invention extends their setting to the ring of integers modulo N, thus obtaining compact representations for cryptographic systems that base their security on the discrete logarithm problem and the factoring problem. This can result in small key sizes and substantial savings in memory and bandwidth. However, unlike the case of finite field, analogous trace-based compression methods cannot be adapted to accommodate the extended setting of the invention when the underlying systems require more than a mere exponentiation. The invention finds particular application in a torus-based implementation of the ACJT group signature scheme. Also provided is a processor.

Description

TECHNICAL FIELD

The present invention relates generally to cryptography, and more particularly to torus-based cryptography.

BACKGROUND

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.

Groups where the discrete logarithm problem is assumed to be intractable are central in the design of public-key cryptography. This was first pointed out by Diffie and Hellman in their seminal report: Whitfield Diffie and Martin E. Hellman, “New Directions in Cryptography”, IEEE, Transactions on Information Theory, 22(6):644-654, 1976.

The security of the Diffie-Hellman key-distribution system relies on the intractability of the discrete logarithm problem in the multiplicative group of finite fields. Such groups also enable the construction of encryption schemes, digital signature schemes, and many other cryptographic primitives and protocols; see Alfred J. Menezes, Paul C. van Oorchot, and Scott A. Vanstone, “Handbook of Applied Cryptography”, CRC Press, 1997.

Several solutions have been proposed to improve the efficiency of the so-obtained schemes.

Schnorr suggests working in a prime-order subgroup of _p^x rather than in the whole group _p^x; see Claus-Peter Schnorr, “Efficient Signature Generation by Smart Cards”. Journal of Cryptology, 4(3):161-174, 1991.

Lenstra extends this idea to the cyclotomic subgroup of _p^xr, stating that the underlying field is really _pr and not some intermediate subfield; see Arjen K. Lenstra, “Using Cyclotomic Polynomials to Construct Efficient Discrete Logarithm Cryptosystems Over Finite Fields”, in V. V. Varadharajan, J. Pieprzyk, and Y. Mu, editors, Information Security and Privacy (ACISP '97), volume 1270 of Lecture Notes in Computer Science, pages 127-138. Springer-Verlag, 1997.

More recently, Rubin and Silverberg rephrased cyclotomic subgroups in terms of algebraic tori over _p. The main advantage of their approach resides in the compact representation of the elements. See Karl Rubin and Alice Silverberg, Torus-Based Cryptography, In D. Boneh, editor, Advances in Cryptology—CRYPTO 2003, volume 2729 of Lecture Notes in Computer Science, pages 349-365. Springer-Verlag, 2003.

Other prominent proposals featuring a compact representation include LUC (see Peter Smith and Christopher Skinner, “A public-key cryptosystem and a digital signature system based on the Lucas function analogue to discrete logarithms”, In J. Pieprzyk and R. Safavi-Naini, editors, Advances in Cryptology—ASIACRYPT'94, volume 917 of Lecture Notes in Computer Science, pages 357-364. Springer-Verlag, 1995.) and XTR (see Arjen K. Lenstra and Eric R. Verheul, “The XTR public key system”. In M. Bellare, editor, Advances in Cryptology—CRYPTO 2000, volume 1880 of Lecture Notes in Computer Science, page 119. Springer-Verlag, 2000).

Variants of Diffie-Hellman key-distribution system in the multiplicative group _N^x, where N is the product of two primes are proposed by Kevin S. McCurley (see “A key distribution system equivalent to factoring”, Journal of Cryptology, 1(2):95-105, 1988) and Zahava Shmuely (see “Composite Diffie-Hellman public key generating systems hard to break”, Technical Report 356, Israel Institute of Technology, Computer Science Department, Technion, February 1985). The goal is to combine the security of the original scheme with the difficulty of factoring large numbers. McCurley argues that it may be desirable to design cryptographic systems with the property that breaking them requires solving two different computational problems.

SUMMARY OF INVENTION

In a first aspect, the invention is directed to a cryptographic method for obtaining an intermediate result for use in enciphering, authenticating or signing data. The method operates on a torus over _N, where N is a product of at least two prime factors and the torus has parameter D in _N. A processor performs at least one multiplication of two elements m₁ and m₂ over the torus, and outputs the result of the multiplication. The result of the torus multiplication is equal to a division over _N, where the dividend is the sum of D with the product of m₁ and m₂ and the divisor is the sum of m₁ and m₂. At least one of m₁ or m₂ is one of: a) the data to be enciphered, authenticated or signed, b) a cryptographic key, or c) an intermediate result depending of at least one of a) or b).

In a second aspect, the invention is directed to a processor for performing a cryptographic method for obtaining an intermediate result for use in enciphering, authenticating or signing data. The cryptographic method operates on a torus over _N, where N is a product of at least two prime factors and the torus has parameter D in _N. The processor is adapted to perform at least one multiplication of two elements m₁ and m₂ over the torus, and output the result of the torus multiplication. The result of the torus multiplication being equal to a division over _N, where the dividend is the sum of D with the product of m₁ and m₂, and the divisor is the sum of m₁ and m₂. At least one of m₁ or m₂ is one of: a) the data to be enciphered, authenticated or signed, b) a cryptographic key, or c) an intermediate result depending of at least one of a) or b).

BRIEF DESCRIPTION OF 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 performing cryptography calculations according to a preferred embodiment of the present invention.

DESCRIPTION OF EMBODIMENTS

The present application introduces torus-based cryptography over the ring _N. It can find applications in settings similar to those considered by McCurley. An advantage is that it can increase the performance of cryptographic schemes whose security requires both the integer factorization assumption and the discrete logarithm assumption, or related assumptions (see for example: Niko Baric and Birgit Pfitzmann, “Collision-free accumulators and fail-stop signature schemes without trees”, In W. Fumy, editor, Advances in Cryptology—EUROCRYPT'97, volume 1233 of Lecture Notes in Computer Science, pages 480-494, Springer-Verlag, 1997. Dan Boneh, “The decision Diffie-Hellman problem”, In J. Buhler, editor, Algorithmic Number Theory (ANTS-III), volume 1423 of Lecture Notes in Computer Science, pages 48-63. Springer-Verlag, 1998. Eiichiro Fujisaki and Tatsuaki Okamoto, “Statistical zero-knowledge protocols to prove modular polynomial equations”, In B. Kaliski, Jr, editor, Advances in Cryptology—CRYPTO'97, volume 1294 of Lecture Notes in Computer Science, pages 16-30. Springer-Verlag, 1997.) Substantial savings both in memory and in transmission can be achieved without security loss. The representation used in LUC offers the same savings as one-dimensional tori over _N . Unfortunately, its usage is mostly restricted to exponentiation: LUC presents an analogue of RSA. However, numerous applications require full use of multiplication. Tori over _N embed a group structure and therefore suit a much wider range of applications. This can be considered as a main feature of torus-based cryptography.

As an illustration, consider the ACJT group signature scheme, Giuseppe Ateniese, Jan Camenisch, Marc Joye, and Gene Tsudik, “A practical and provably secure coalition-resistant group signature scheme”, In M. Bellare, editor, Advances in Cryptology—CRYPTO 2000, volume 1880 of Lecture Notes in Computer Science, pages 255-270. Springer-Verlag, 2000. This AJCT scheme was used in the design of the protocol standardized by the Trusted Computing Group to protect privacy of the device's user (see Trusted Computing Group. TCG TPM specification 1.2. Available at http://www.trustedcomputinggroup.org/, 2003). Group signature schemes, as introduced by Chaum and van Heyst allow a group member to sign anonymously on behalf of the group (see David Chaum and Eugene van Heyst, “Group signatures”, In D. W. Davies, editor, Advances in Cryptology—EUROCRYPT'91, volume 547 of Lecture Notes in Computer Science, pages 257-265. Springer-Verlag, 1991). However, the group manager is able to recover the signer's identity. The ACJT scheme makes use of arithmetic modulo N, where N=pq is a strong RSA modulus. Each group member possesses a membership certificate [A; e] satisfying A^e=a^xa₀(mod N) where {a, a₀,N} are common public parameters and x denotes the member's private key. As the group manager may know the factorization of N, the secrecy of private key x is only guaranteed modulo p and q. As remarked by Camenisch and Groth (see Jan Camenisch and Jens Groth, “Group signatures: Better efficiency and new theoretical aspects”, In C. Blundo and S. Cimato, editors, Security in Communication Networks (SCN 2004), volume 3352 of Lecture Notes in Computer Science, pages 120-133. Springer-Verlag, 2004), if it is desired to disallow the group manager to frame group members, the length of modulus N should typically be doubled. Based on current understanding, a torus-based implementation offers the same security level but without requiring an increase of the length of N. For example, for an expected 80-bit security level, the size of the resulting signatures is about 11 kb (this is half than that of the original scheme in the case of a malicious group manager) and the generation of a group signature is more than three times faster.

The rest of this description is organized as follows. First, some background on algebraic tori is provided. A compact representation of one-dimensional tori from the geometric interpretation of the group law on Pell conics is detailed. Compact representations for higher-dimensional tori are also discussed. Then, tori-based representations are extended over rings. The main focus is put on the ring _N where N is an RSA modulus. The so-obtained representations are compared with Lucas-based representations and it is explained why the latter are inappropriate. Finally, applications of the compression are addressed. A torus-based implementation of the basic EIGamal encryption scheme is presented, as is a detailed implementation of the ACJT group signature scheme using a torus-based representation and the performance of the resulting scheme is discussed.

Torus-Based Cryptography

Let _q denote the finite field with q=p^r elements. The order of the multiplicative group _p^xr=_pr\{0} is p^r−1. Note that p^r−1Π_d|rΦ_d(p) where Φ_d (x) represents the r-th cyclotomic polynomial. We let G_p,r⊂_p^xr denote the cyclic subgroup of order Φ_r (p).

In the previously mentioned article, Rubin and Silverberg identify G_p,r with the _p-points of an algebraic torus _r(_p). Namely, they consider _r(_p)={αε_p^xr|N_pr/F(α)=1 whenever _p⊂ F_pr}, that is, the elements of _p^xr whose norm is one down to every intermediate subfield F. The key observation is that _p) forms a group whose elements can be represented with only φ(r) elements of _p, where φ denotes Euler's totient function. The compression factor is thus of r/φ(r) over the field representation.

Parameterization of (_p)

Now follows an explicit compact representation of _r(_p) for the case r=2. This gives |_p^x2|=p²−1, Φ₂(p+1, and G_p,2={αε_p^x2|α^Φ2(p)=1}. It is assumed that p is odd. _p²=_p(√{square root over (Δ)}) for some non-square Δε_p^x. Also G_p,2={x+y√{square root over (Δ)}|x,yε_p and (x+y√{square root over (Δ)})^p+1=1}. Since (x+y√{square root over (Δ)})^p=x−y√{square root over (Δ)}, it follows that (x+y√{square root over (Δ)})^p+1=(x−y√{square root over (Δ)})(x+y√{square root over (Δ)})=x²−Δy².

So, the group G_p,2 can be seen as the set of _F points on the genus 0 curve C over _p given by the Pell equation

C _{/ p} :x ² −Δy ²=1  (1)

Further, G_p,2≅(_p)≅C(_p); see lemma 7 in Rubin and Silverberg (and also theorem 4.5 of Alfred J. Menezes, Elliptic Curve Public Key Cryptosystems; Kluwer Academic Publishers, 1993). If ⊕ denotes the group law on C(_p), given two points (x₁, y₁), (x₂, y₂)εC(_p), then

(x₁, y₁)⊕(x₂, y₂)=(x₁x₂+Δ_y1y₂, x₁y₂+x₂y₁).

The neutral element is =(1,0) and the inverse of (x, y) is (x, −y).

As remarked by Isabelle Déchène in chapter 3 of Generalized Jacobians in Cryptography (PhD thesis, McGill University, Montreal, Canada), the geometric interpretation of the group law on C(_p) gives rise to a compact representation. Let =(x₁, y₁) and Q=(x₂,y₂) be two points of C(_p). The group law on C(_p) is given by the so-called ‘chord-and-tangent’ rule (see Boleslas Niewenglowski, Note sur les équations x²ay²=1 et x²−ay²=−1; Bulletin de la Société Mathématique de France, 35:126-131, 1907; see also §1 of Franz Lemmermeyer, Higher descent on Pell conics (III), Preprint, 2003 for a detailed account). denotes the line passing through and Q; represents the tangent line at if =Q. The parallel line, say ′, to that passes through =(1,0) intersects (counting multiplicity) the Pell conic C(_p) at precisely one other point (x₃, y₃), which is defined as ⊕Q. If m denotes the slope of then the equation of ′ is given by y=m(x−1). Therefore, (x₃, y₃) satisfies x₃²−Δy₃²=1 and y₃=m(x₃−1). Thus,

$x_3^2-\Delta {m^2\left(x_3-1\right)}^2=1\iff \left(x_3-1\right)\left(x_3\left(1-\Delta m^2\right)+\Delta m^2+1\right)=0.$ $\mathrm{As}y_3=m\left(x_3-1\right),\left(x_3,y_3\right)=\left(\frac{\Delta m^2+1}{\Delta m^2-1},\frac{2m}{\Delta m^2-1}\right)=\left(\frac{{\left(\Delta m\right)}^2+\Delta }{{\left(\Delta m\right)}^2-\Delta },\frac{2\left(\Delta m\right)}{{\left(\Delta m\right)}^2-\Delta }\right)$

Let now =(x, y) be a point in C(_p)\{}. Since =+, there is a map

$\begin{array}{cc}\psi \text{:}{}_p\to C\left({}_p\right)\backslash \left\{\right\},\stackrel{\_}{m}\mapsto =\left(\frac{{\stackrel{\_}{m}}^2+\Delta }{{\stackrel{\_}{m}}^2-\Delta },\frac{2\stackrel{\_}{m}}{{\stackrel{\_}{m}}^2-\Delta }\right)& \left(2\right)\end{array}$

where m=Δm and m is the slope of the line passing through and . (A slightly faster arithmetic is obtained by considering m rather than m; this corresponds to the map in §5.2 of Rubin and Silverberg.) Note that m²−Δ≠0 for all mε_p, since Δ is a non-square in _p.Proposition 1. The set of solutions satisfying Eq. (1) is given by

{ψ( m)| mε_p}∪{}

Proof. It is easy to see that ψ is injective. Indeed, assuming ψ( m₁)=ψ( m₂) gets

(m₁²+Δ)m₂²−Δ)=m₂²+Δ)m₁²−Δ)

2m₁(m₂²−Δ)=2m₂(m₁²−Δ)

m ₁ ²= m₂²

2m₁(m₂²−Δ)=2m₂(m₁²−Δ)

m ₁= m₂

This concludes the proof by noting that there are (p+1) solutions to Eq. (1).□

The inverse map is given by

$\begin{array}{cc}{\psi }^{-1}:C\left({}_p\right)\backslash \left\{\right\}->{}_p,\left(x,y\right)\mapsto \stackrel{\_}{m}=\frac{\Delta y}{x-1}& \left(3\right)\end{array}$

By augmenting _p with ∞, maps ψ and ψ⁻¹ yield an isomorphism C(_p){tilde over (∵)}_p, ∪{∞} by defining ψ(∞)= and ψ⁻¹()=∞.

The latter representation enables the following definition

₂(_p)={ m| m=ψ⁻¹(x,y) with (x,y)εC(_p)}  (4)

The neutral element in ₂(_p) is ∞. The inverse of m is − m. Let m₁, m₂ε₂(_p)\{∞}, is the group law (torus multiplication) in ₂(_p). If m₁=− m₂ then m₁m₂=∞. If m₁≠− m₂, then

$\begin{array}{cc}{\stackrel{\_}{m}}_1\otimes {\stackrel{\_}{m}}_2={\psi }^{-1}\left(\psi \left(m_1\right)\oplus \psi \left(m_2\right)\right)=\frac{{\stackrel{\_}{m}}_1{\stackrel{\_}{m}}_2+\Delta }{{\stackrel{\_}{m}}_1+{\stackrel{\_}{m}}_2}& \left(5\right)\end{array}$

As a result, it is possible to do cryptography in ₂(_p) by doing all arithmetic directly in _p.

Trace-Based Compression

The trace map is defined by

Tr: _p ² →_p:αTr(α)=α+α^p.

Then αεG_p,2 and its conjugate α^p are the roots of polynomial (X−α)(X−α^p)=X²−Tr(α)X+1. Define V_k=Tr(α^k). Since V_k=α^k+α^−k, it is easily verified that V_i+j=V_iV_j−V_i−j. In particular, V_2i=V_i²2 and V_2i+1=V_i+1V_i−Tr(α). Therefore, if l is the binary length of k, Tr(α^k) can be evaluated quickly with only l multiplications and l squarings in _p using the Montgomery ladder (see e.g. FIG. 4 of Marc Joye and Sung-Ming Yen. The Montgomery powering ladder. In B. S. Kaliski, Jr., ç. K. Koç, and C. Paar, editors, Cryptographic Hardware and Embedded Systems—CHES 2000, volume 2523 of Lecture Notes in Computer Science, pages 291-302. Springer-Verlag, 2000). As can be seen, trace-based representations are well suited for exponentiation.

It should be noted that letting P=Tr(α),V_k=V_k(P, 1) corresponds to the k^th item of Lucas sequence {V_k(P, Q)} with parameter Q=1. Moreover, since a αεG_p,2, it follows that α≠α^p and Δ:=Tr(α)²4=P²−4 is a non-square. Let {U_k(P,1)} denote the companion Lucas sequence where U_kε_p satisfies V_k+U_k√{square root over (Δ)}=2α^k. Noting that √{square root over (Δ)}=α−α⁻¹ gives U_k=(α^k−a^−k)/(α−α⁻¹). In addition, V_k²−ΔU_k²=(V_k+U_k√{square root over (Δ)})(V_k−U_k√{square root over (Δ)})=(2α^k)(2α^−k)=4. Consequently, an element α=x+y√{square root over (Δ)}εG_p,2 can be equivalently written as

$\alpha =\frac{V_1}{2}+\frac{U_1}{2}\sqrt{\Delta }\mathrm{and}{\alpha }^k=\frac{V_k}{2}+\frac{U_k}{2}\sqrt{\Delta }$

such that

${\left(\frac{V_k}{2}\right)}^2-{\Delta \left(\frac{U_k}{2}\right)}^2=1.$

In other words,

$C\left({}_p\right)=\left\{\left(\frac{V_k}{2},\frac{U_k}{2}\right)|0\le k\le p\right\}.$

Trace-based representations over _p can be ‘enhanced’ to allow the multiplication of two compressed elements. For yε_p, the parity bit of y can be defined as par(y)=y mod 2. As prime p is odd, it is obvious that par(p−y)=1-par(y) if yε_p\{0}. Hence, a point =(x,y)εC(_p) is uniquely identified by the pair (x, β) where β=par(y). This is called the enhanced trace-based representation. Hence, given (x₁, β₁) and (x₂, β₂) (corresponding to ₁ and ₂ E C(_p)), the compressed value (x₃, β₃) (corresponding to ₃=⊕₂) can be obtained as follows:

• • evaluate square roots √{square root over ((x₁²−1)/Δ)}and √{square root over ((x₂²−1)/Δ)}over _p,
  • recover ₁=(x₁, y₁) and ₂=(x₂, y₂) from β₁ and β₂,
  • compute (x₃,y₃)=(x₁, y₁)⊕(x₂,y₂), and
  • output (x₃, β₃) with β₃=y₃ mod 2.Compared to torus-based representation, this is however at the expense of the computation of two square roots and of further memory requirements.

Parameterization of Higher Dimensional Tori

The next cases for which the ratio r/(φ(r) is large (and thus leading to optimal compression factors) are r=6 and r=30. An explicit compact representation of ₆(_p) is detailed Section 5.1 of the previously mentioned Torus-Based Cryptography by Karl Rubin and Alice Silverberg. For the case r=30, see section 5 of Marten van Dijk, Robert Granger, Dan Page, Karl Rubin, Alice Silverberg, Martijn Stam, and David Woodruff, Practical cryptography in high dimensional tori. In R. Cramer, editor, Advances in Cryptology—EUROCRYPT 2005, volume 3492 of Lecture Notes in Computer Science, pages 234-250. Springer-Verlag, 2005.

Compact Representations over the Ring _N

Let N=pq be the product of two large primes and _N denote the ring of integers modulo N. The isomorphism _N≅_p×_q induces an isomorphism between _r (_N) and _r(_p)×_r(_q).

Current knowledge in cryptanalytic techniques implies that the hardness of factoring an RSA modulus N or computing discrete logarithms in a finite field of the size of N is broadly the same. Assuming that p and q are of equal size, the discrete logarithm problem in _r(_p) and in _r(_q) will thus not be easier than factoring N provided that r≧2. For efficiency reasons, a smaller value of r yields better performance. Henceforth, the description will focus on _r(_N) with r=2.

Tori ₂(_N) and ₂(_N)

Consider the Pell equation over _N,

:x²−Δy²=1

where Δε_N^x is a non-square modulo p and modulo q. By Chinese remaindering, the set of points (x, y)ε_N×_N satisfying this equation form a group, C(_N)=C(_p)×C(_q), under the ‘chord-and-tangent’ law (see “Parameterization of ₂(_p)”). The neutral element is (1,0). For each point εC(_N), there exists a unique pair of points _pεC(_p) and _qεC(_q) such that mod p=_p and mod q=_q. This equivalence is denoted by =[_p,_q].

It is now possible to extend the previous compression map (cf. Eq. (3)) to _N. The only complication is that they are some points of the form [_p, ₇] or [_p, _q]. To deal more easily with these points, a projective representation is considered for the compressed result. m is written as a pair (M:Z) and m=(M:Z) is said to be equivalent to m′=(M′:Z′) if there exists some tε_N^x such that M′=tM and Z′=tZ. Definition:

ψ⁻¹:C(_N)→¹(_N),(x,y)m=(Δy:x−1)  (6)

This in turn leads to the definition of ₂(_N),

₂(_N)={m| m=ψ⁻¹(x,y) with (x,y)εC(_N)}  (7)

Group law. The group law (torus multiplication) on ₂(_N) is denoted . The neutral element is (t:0) for some tε_N^x. The inverse of an element m=(M:Z) is (−M:Z). From Eq. (5), given m₁=(M₁:Z₁) and m₂=(M₂:Z₂) in ₂(_N), a simple calculation shows that

(M₁:Z₁)(M₂:Z₂)=(M₁M₂+ΔZ₁Z₂:M₁Z₂+M₂Z₁)  (8)

A further advantage of the projective representation is that the group law is complete: it works for all inputs m₁, m₂ε₂ (_N).

Affine parameterization. The map given by Eq. (6) does not yield a compact representation for ₂(_N) since each element m then requires two elements of _N. A possible workaround is to ignore input points of the form [_p, _q] or [_p, _p] and to restrict to subset {tilde over (C)}(_N)={(x,y)εC(_N)x−1ε_N^x}∪{}. A point =(x,y)ε{tilde over (C)}(_N) corresponds to

$\stackrel{\_}{m}=\left(\frac{\Delta y}{x-1}:1\right)$

if ≠, and m=(1:0) otherwise. Definition

₂(_N)={m| m=ψ⁻¹(x,y) with (x,y)ε{tilde over (C)}(_N)}  (9)

From the above observation, an element m in ₂(_N) can be represented by an element of _N plus one bit:

$\left(\frac{\Delta y}{x-1}:1\right)$

or (1:0). Yet another possibility is to represent m as an element of ¹(_N)∪{∞}. Namely, if =(x,y)ε{tilde over (C)}(_N) then

$\stackrel{\_}{m}=\left(\frac{\Delta y}{x-1}:1\right)$

if ≠, and m=∞ otherwise. Both cases result in a compact representation for ₂(_N).

The group ₂(_N) consists of all the elements of ₂(_N) together with a number of elements of the form (M:Z) with gcd(Z,N)=p or q (corresponding to points [_p, _q] and [_p,_q]in C(_N)). The ‘chord-and-tangent’ law on {tilde over (C)}(_N), whenever it is defined, coincides with the group law on C(_N)=C(_p)×C(_q). The same holds for ₂(_N). In practice, for cryptographic applications, N is the product of two large primes. It is therefore extremely unlikely that operation is not defined on ₂(_N).

Torus-Based vs. Trace-Based Compression

Similarly to the section “Trace-based compression”, Lucas sequences can be defined over the ring _N by Chinese remaindering. Trace-based or equivalently Lucas-based compressions are well suited to exponentiation. For example, Smith and Lennon proposed an analogue to RSA using Lucas sequence {V_k(P, 1)} over _N (see Peter J. Smith and Michael J. J. Lennon. LUC: A New Public Key System. In E. G. Dougall, editor, 9^th International Conference on Information Security (IFIP/Sec '93), volume A-37 of IFIP Transactions, pages 103-117, North-Holland, 1993).

When more than a mere exponentiation is required, trace-based representations are not applicable. Indeed, let ₁=(x₁,y₁), ₂=(x₂,y₂)εC(_N). Computing ₃=₁⊕₂ being given ₁ and ₂ is easy: ₃=(x₁x₂+Δy₁y₂,x₁y₂+x₂y₁). However, computing x₃=x₁x₂+Δy₁y₂ being only given x₁ and x₂ is not possible.

Even an enhanced trace-based representation (cf. “Trace-based compression”) does not seem helpful when working over _N. Here is an example of such an enhanced compression for Blum integers N (i.e. N=pq with primes p,q≡3 (mod 4)). As before, for yε_N, par(y) is defined as y mod 2 (i.e. par(y)=y mod 2). In addition, chr(y) is defined as: chr(y)=0 if

$\left(\frac{y}{N}\right)=1$

and chr(y)=1 otherwise, where

$\left(\frac{y}{N}\right)$

denotes the Jacobi symbol of y modulo N. Since p,c≡3 (mod 4),

$\left(\frac{-1}{p}\right)=\left(\frac{-1}{q}\right)=-1.$

It is therefore easily verified that a point =(x, y)εC(_N) is uniquely identified by the tuple (x, β, χ) where β=par(y) and χ=chr(y), that is, with one element of _N and two bits. Unfortunately, decompressing (x, β, χ) into =(x,y) requires the knowledge of p and q, which are, in most settings, private values. Unlike the finite field case, enhanced trace-based representation over _N allowing to multiply compressed elements is unknown. Only torus-based representation over _N is available in this case to get a compact representation.

Extensions and Generalizations

Because the problems of computing discrete logarithms and of factoring were assumed to be balanced for an RSA modulus N=pq, the focus was on the case ₂(_N). But the same methodology extends to higher-dimensional tori. It also generalizes to more general moduli; for example, to RSA moduli made of three prime factors. This allows for different trade-offs between the two computational problems.

Applications

The compression technique herein reduces the parameter size (typically by a factor of two). This in turn reduces the requirements for storage and transmission. It saves a significant amount in cryptographic methods where many group elements are evaluated. The inputs of those methods are at least two elements in ₂(_N), say m₁ and m₂, to result in a third element m₃= m₁m₂ satisfying

${\stackrel{\_}{m}}_3=\frac{{\stackrel{\_}{m}}_1{\stackrel{\_}{m}}_2+\Delta }{{\stackrel{\_}{m}}_1+{\stackrel{\_}{m}}_2}$

on a torus modulo N parameterized by Δ; the computations being performed on a processor 10 (in FIG. 1) or a crypto-processor. FIG. 1 illustrates how the processor 10 receives input and outputs a result.

A first example is a torus-based implementation of the basic EIGamal encryption scheme (see Taher EIGamal. A public key cryptosystem and a signature scheme based on discrete logarithms. IEEE Transactions on Information Theory, 31(4):469-472, 1985). Let N=pq denote a RSA modulus. The public key consists of an element gε₂(_N) and of y=g^rε₂₂(_N) for some integer x. The corresponding secret key is x. To encrypt a message m viewed as an element in ₂(_N), the ciphertext (c₁,c₂) is computed in ₂(_N), where c₁=g^r and c₂=my^r. Then, using secret key x, plain message m can be recovered from (c₁,c₂) as c₂(c₁)^−r.

A second example is the ACJT group signature scheme. To simplify the presentation, the various security lengths (λ₁, λ₂, y₁, y₂) and corresponding ranges (, ) are omitted (for details, see “A practical and provably secure coalition-resistant group signature scheme” already mentioned herein).

Slight modifications need to be brought to the scheme. The original ACJT group signature scheme makes use of a strong RSA modulus, that is, N=pq with p=2p′+1 and q=2q′−1 for primes p′, q′. Since G_p,2 (resp. G_q,2) has order p+1 (resp. q+1), a RSA modulus N=pq is chosen with p=4p′−1 and q=4q′−1 for primes p′, q′. Note that doing so −1 is a non-square modulo p and modulo q (i.e., p, q≡3 (mod 4), which yields faster arithmetic. The subgroup of squares in ₂(_N) is denoted by ₂. Finally, ₂ is set ₂=₂∩₂(_N).

Being a group signature scheme, the modified scheme consists of five algorithms. The notation from “A practical and provably secure coalition-resistant group signature scheme” will be used.

Setup Select two random primes p′, q′≡1 (mod 4) such that p=4p′−1 and q=4q′−1 are prime. Set the modulus N=pq. Choose random elements a, a₀, g, h in ₂. Choose a random element xε_prq^x, and set y=g^xε₂. The group public key is =(N,a,a₀,y,g,h). The corresponding secret key (known only to the group manager) is S=(p′, q′, x).

Join Each user U_i interactively constructs with the group manager a membership certificate [A_i, e_i] satisfying A_i^ei=α^xiα₀ in ₂ for some prime e_i. Parameter x_i is the private key of U_i (and is unknown to the group manager).

Sign Generate a random value w and compute in ₂

T ₁ =A _i y ^w ,T ₂ =g ^w ,T ₃=g^eih^w

Randomly choose values r₁, r₂, r₃, r₄ and compute,

1. in ₂, d₁=T₁^T1(a^r2(y^r3)⁻¹,d₂=T₂^r1(g^r3)⁻¹,d₃=g^r4,d₄,d₄=g^r1h^r4

2. c=(∥T₁∥T₂∥T₃∥d₁∥d₂∥d₃∥d₄∥m) where m is the message being signed;

3. in , s₁=r₁−c(e_i−2^yq),s₂=r₂−C(x_i−2^λ1),s₃=r₃−ce_iw,s₄=r₄−cw

The signature on message m is σ=(c, s₁, s₂, s₃, s₄, T₁, T₂, T₃).

Verify Compute in ₂

d′₁=a₀^cT₁^s1−c2y1((z^s2−c2λ1y^s3)⁻¹,d′₂=T₂^s1−c2y1(g^s₃)⁻¹,

d′₃=T₂^cg^s4,d′₄=T₃^c(g^s1−c2y1h^s4

Accept the signature if and only if c′=(∥T₁∥T₂∥T₃∥d′₁∥d′₂∥d′₃∥d′₄∥m) is equal to c (and if the signature components belong to appropriate ranges).

Open Check the signature's validity. The group manager then recovers A_i=T₁(T₂^x)⁻¹ in ₂.

The performance of the modified scheme will now be discussed and compared with the original ACJT scheme.

Let l_N denote the binary length of modulus N. The system secret key δS requires 2l_N bits. As shown in “Tori ₂(_N) and ₂(_N)”, an element in ₂\{∞} can be coded with l_N bits using an affine parameterization. Hence, the common public key consisting of 6 elements of ₂ requires 6l_N bits. The size of exponent e_i in membership certificate [A_i, e_i] and of corresponding private key x_i are about the size of N²; therefore, a membership certificate requires roughly 3l_N bits and the user's private key roughly 2l_N bits. Since the size of s_j(1≦j≦4) is about the size of N², a signature σ=(c, s₁, s₂, s₃, s₄, T₁, T₂, T₃) requires approximatively 11l_N bits. Typically, for a 80-bit security level (i.e., 2048-bit modulus for the ACJT scheme and 1024-bit modulus for its torus-based implementation), which gives

TABLE 1
Performance comparison: Typical lengths.
	ACJT scheme	Torus-based scheme
	Common public key	12 kb	6 kb
	System secret key	4 kb	2 kb
	Membership certificate	6 kb	3 kb
	User's private key	4 kb	2 kb
	Signature (approx.)	22 kb	11 kb

The torus-based signatures are not only shorter, they are also, as will be seen, faster to generate. The cost of additions and hash computations will be neglected. For the sake of comparison, it is assumed that exponentiations are done with the basic square-and-multiply algorithm and that multi-exponentiations are evaluated with the simultaneous binary exponentiation algorithm (see e.g. Algorithm 14.88 of Handbook of Applied Cryptography]). A k-exponentiation with exponent of binary length l then amounts to

$\left(-1\right)\left(S+\frac{2^k-1}{2^k}M\right)$

on average, where S and M respectively represent the cost of a squaring and of a multiplication in ₂ . It also requires (2^k−2)M for the precomputation. Since T₁, T₂ involve exponents of size about l_N bits and T₃, d₁, d₂, d₃, d₄ involve exponents of size about 2l_N bits, the generation of a signature takes about

$\begin{array}{cc}{}_N\left(S+\frac{1}{2}M\right)+{}_N\left(S+\frac{1}{2}M\right)+2{}_N\left(S+\frac{3}{4}M\right)+2{}_N\left(S+\frac{7}{8}M\right)+2{}_N\left(S+\frac{3}{4}M\right)+2{}_N\left(S+\frac{1}{2}M\right)+2{}_N\left(S+\frac{3}{4}M\right)=12{}_NS+8.25{}_NM& \left(10\right)\end{array}$

neglecting the precomputation.

In the scheme of the present application, p, q≡3 (mod 4). It is thus possible to take Δ==−1. In this case, using projective coordinates, the multiplication of two elements m₁=(M₁:Z₁) and m₂=(M₂:Z₂) in ₂, m₃= m₁m₂, simplifies to m₃=(M₃:Z₃) with M₃=M₁M₂+Z₁Z₂ and Z₃=M₁Z₂+M₂Z₁=(M₁+Z₁)(M₂+Z₂)−M₃. Let s and m denote the cost of a square and a multiplication in _N . The multiplication of two elements of ₂ thus requires 3m. Note that for a mixed multiplication (i.e., when one of the two operands has its Z-coordinate equal to 1), the cost reduces to 2m. Squaring m₁=(M₁:Z₁) can be evaluated as m₃=(M₃:Z₃) with Z₃=2M₁Z₁ and M₃=(M₁+Z₁)²−Z₃ and requires thus 1s+1m. If the precomputed values in the k-exponentiation are expressed in affine way (this can be done with a single inversion and a few multiplications in _N using the so-called Montgomery's trick), then M=2m and S=1s+1 m. Therefore, neglecting the cost of this inversion in _N and assuming s=0.8m, the cost of a torus-based ACJT group signature is about (12·1.8+8.25·2)l_Nm=38.1l_Nm.

Similarly, Eq. (10) gives that the cost of a regular ACJT group signature is about (12·0.8+8.25)l_Nm=17.85l_Nm, assuming again s=0.8m. But since the length of l_N is half as long in ₂, the expected speed-up factor amounts to

$\frac{17.85{}_N·{\left({}_N\right)}^2}{38.1\left({}_N/2\right)·{\left({}_N/2\right)}^2}\approx 3.75$

In practice, the expected speed-up factor is even more spectacular as the above value assumes that the same exponentiation algorithms are being used; however, for the same amount of memory, the torus-based implementation can be sped up using more pre-computed values and higher-order methods. Note also that the above analysis neglects the cost of inversion in _N^x (in the evaluation of d₁ and d₂) for the regular ACJT signatures.

It will thus be appreciated that the present invention can offer a cryptographic method that is more efficient than the prior art solutions.

Each feature disclosed in the description and (where appropriate) the claims and drawings may be provided independently or in any appropriate combination. 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 cryptographic method for obtaining an intermediate result for use in enciphering, authenticating or signing data, the method operating on a torus over N, wherein N is a product of at least two prime factors and the torus has parameter D in N, the method comprising the steps, at a processor, of: performing at least one multiplication of two elements m1 and m2 over the torus, andoutputting the result of the torus multiplication,the result of the torus multiplication being equal to a division over N, where the dividend is the sum of D with the product of m1 and m2,the divisor is the sum of m1 and m2,where at least one of m1 or m2 is one of the following: a) the data to be enciphered, authenticated or signed,b) a cryptographic key, orc) an intermediate result depending of at least one of a) or b).

2. A processor for performing a cryptographic method for obtaining an intermediate result for use in enciphering, authenticating or signing data, the cryptographic method operating on a torus over N, wherein N is a product of at least two prime factors and the torus has parameter D in N, the processor being configured to: perform at least one multiplication of two elements m1 and m2 over the torus, andoutput the result of the torus multiplication,the result of the torus multiplication being equal to a division over N, where the dividend is the sum of D with the product of m1 and m2,the divisor is the sum of m1 and m2,where at least one of m1 or m2 is one of the following: a) the data to be enciphered, authenticated or signed,b) a cryptographic key, orc) an intermediate result depending of at least one of a) or b).