Abstract:
Processes for generating digital signatures for electronic messages. Modifying signature-generating algorithms, such as DSAs (Digital Signature Algorithms), in order to enable smart cards with reduced calculation and storage resources to produce digital signatures with a high degree of security in spite of their reduced resources. The signature-checking terminal sends a random number a and measures the time taken by the card to send back a signal s using this random number. If the time is greater than a given duration, the signature is rejected even if the check of its authenticity is positive. In addition, part of the signature (the part which does not use the secret card key but only the public algorithm parameters) is precalculated and stored in the card in the form of signature portions produced by a compression function such that they are short. Only the second part of the signature has to be calculated by the card. The calculations to be made are simple so that the card does not require extensive calculation and memory resources.

Description:
BACKGROUND OF THE INVENTION 
     1. Field of the Invention 
     The invention relates to a method for the generation of digital signatures for electronic messages. 
     The method can be applied especially to the signing of messages by portable devices of the microprocessor-based smart card type. 
     For example, it may be necessary to sign messages sent by the card to a reading terminal or to a central authority. Or again, it may be necessary to carry out a transaction (an electronic cheque transaction) and to sign this transaction so that it can be authenticated first of all by the reading terminal in which the transaction is made and then by a central authority that manages the transaction. 
     The method that shall be described is related to the algorithms for the generation of digital signatures published in recent years, especially by the U.S. National Institute of Standards and Technology, for example the DSA (Digital Signature Algorithm) described in the U.S. patent application Ser. No. 07/736451 filed Jul. 26, 1991 and now U.S. Pat. No. 5,231,668 and published on the 30the of Aug. 1991 in the Federal Register kept by this Institute, pages 42980-42982. 
     The invention is aimed at modifying the known methods, in particular to make them adaptable to microprocessor-based cards that do not have physical resources (processor, memories) sufficient to swiftly carry out mathematical operations on big numbers. The known algorithms, especially the DSA, use big numbers to generate signatures with a sufficient degree of security. 
     2. Description of the Related Art 
     In order to provide for a clear understanding of the invention, first of all a reminder shall be given of what is the DSA algorithm. 
     A DSA signature consists of a pair {r, s} of big numbers represented in computers by long strings of binary digits (160 digits). The digital signature is computed by means of a series of computation rules defined by the algorithm and a set of parameters used in these computations. The signature enables both the certifying of the identity of the signer (because it brings into action a secret key proper to the signer) and the integrity of the signed message (because it brings into action the message itself). The algorithm makes it possible firstly to generate signatures and secondly to check signatures. 
     The generation of DSA signatures brings into action a secret key. The check brings into action a public key that corresponds to the secret key but is not identical to it. Each user has a pair of keys (secret, public). The public keys may be known to all while the secret keys are never revealed. Anybody has the capacity to check the signature of a user by using the public key of this user but only the possessor of the secret key can generate a signature corresponding to the pair of keys. 
     The parameters of the DSA are the following: 
     a prime number p such that 2 L-1  &lt;p 2 L  for L ranging from 512 to 1024 (including the limits) and L=64a for a as any integer; 
     a prime number q such that 2 159  &lt;q 2 160  and p-1 is a multiple of q; 
     a number g, q order modulo p, such that: 
     g=h.sup.(p-l)/q modulo p where h is any integer checking 
     1&lt;h&lt;p-1 and g&gt;1; 
     a randomly or pseudo-randomly generated number x (this is the secret key, fixed for a given user); 
     a number y defined by the relationship 
     y=g x  modulo p; (this is the public key linked to the secret key); the modular operations defined here below, modulo p or modulo q, shall be designated by mod p or mod q respectively; 
     a randomly or pseudo-randomly generated number k such that 0&lt;k&lt;q. 
     The integers p, q and g are parameters of the system that can be published and/or shared by a group of users. The secret and public keys of a signer are respectively x and y. The parameter k which is a random parameter must be regenerated for each new signature. The parameters x and k are used for the generation of signatures and must be kept secret. 
     In order to sign a message m (which will generally be a hashed value of an initial file M), the signer computes the signature {r, s} by: 
     r=(g k  mod p) mod q, and 
     s=(m +xr)/k mod q 
     (where the division by k is taken to be modulo q, namely that 1/k is the number k&#39; such that kk&#39;=1 mod q; for example if q=5 and k=3, then 1/k=2 for 3×2=6, giving 1 mod 5). 
     After the fact that r and s are different from zero has been tested, the signature {r, s} is sent to the verifier. The verifier is generally the terminal into which the smart card that sends the message m and the signature {r, s} is inserted. 
     The verifier, which knows p, q, g (related to the application), y (related to the user) and m (the message that he has received from the card), computes: 
     a. w=(1/s) mod q 
     b. u1=mw mod q 
     c. u2=rw mod q 
     d. v= g u1  ·y u2  mod p! mod q 
     Now, this value  g u1 .y u2  mod p! mod q is precisely equal to r if s has the value (m+xr)/s mod q. 
     Consequently, the terminal receives r and s and ascertains that v is really equal to r to accept the signature or reject it otherwise. 
     Hereinafter, the term &#34;signer&#34; or signer unit or proving device or smart card shall be used without distinction to designate the device that sends out the signature and that will generally be a smart card. And the term &#34;verifier&#34; or verifier unit or verifier device or verifier terminal or again control authority shall be used without distinction to designate the device that receives the signature and checks it to accept or reject a transaction or a message. The simplest application of the invention is the sending of the signature by means of a smart card to a reading terminal into which the card is inserted, with the terminal performing the checking function and being connected or not connected to a central management authority. 
     SUMMARY OF THE INVENTION 
     One of the aims of the present invention is to increase the security of generation and checking of digital electronic signatures, in minimizing the computation and memory means that have to be present in the smart card to produce the signatures. 
     It would be particularly desirable to be able to use low-cost 8-bit microprocessors in the card rather than more powerful and costlier microprocessors, despite the fact that the 8-bit microprocessors cannot easily process big numbers. However this should not be done to the detriment of security. 
     According to a first major aspect, the invention proposes that the checking by a verifier (terminal) of the signature sent by the signer (card) uses a step for the timing of the period of time that elapses between an instant when a data element (in principle a random data element) is sent by the verifier to the signer (the card) and the instant when the signature (using this random data element) returns to the verifier. If the time that has elapsed is excessively lengthy, it means that the computational processing of the signature by the signer has been done abnormally and the signature is rejected even if its authenticity is confirmed by the verifier. 
     Indirectly, this approach makes it possible, as shall be seen, to preserve the same security of signature while at the same time using small physical resources (in terms of computation power and memories) in the smart card. Small resources entail the need to modify the methods of generation and checking of signatures, but this is to the detriment of security. The timing step according to the invention restores a sufficient level of security. 
     This approach shall be described in detail on the basis of algorithms derived from the DSA algorithm recalled here above, but it will be understood that this first aspect of the invention is applicable with other algorithms even if they are very different from the DSA algorithm. 
     In brief, the first aspect of the invention consists of an electronic signature method, comprising the generation of a digital signature by a signer unit that computes this signature by using a random data element sent by a verifier unit, and the checking of the signature by the verifier which ascertains that a mathematical condition, bringing into action the signature sent and the random data element, is fulfilled, this method being characterized in that the checking of the signature sent by the signer to the verifier further uses a step for the timing of the period that elapses between an instant when the random data element is sent by the verifier to the signer and the instant when the signature using this data element returns to the verifier after computation by the signer, the signature being accepted if the time elapsed is below a defined threshold and if the mathematical condition is verified. 
     Preferably, the algorithm used is of the type in which the signature generation produces two values {r, s}, s being computed from r and a secret key x, and in which the checking of the signature {r, s} consists of the checking of an equality v=f(r, s)=r between r and a function f of r and of s. It is then provided according to the invention that the function f will be chosen to be sufficiently complex so that the period of the search for a value s on the basis of this equality when there is no knowledge of the secret key is far greater, even if it is performed by a powerful computer, than the period of computation and transmission by the card of the value s on the basis of r and of the secret key, this being the case even if the card uses a low-power microprocessor (a 20 MHz 8-bit microprocessor for example). Thus, by making an accurate choice of the time condition introduced by the timing, it is seen to it that this condition cannot be fulfilled when there is no knowledge of the secret key, and especially that it cannot be fulfilled by a search for s on the basis of the equality r=f(r, s). 
     In practice, the function f(r, s) also brings into action a message m to be signed so that it can be referenced f(r, s, m). 
     Preferably, the function f comprises mathematical computations followed by a complex hash function. The first part of the signature r is established by other mathematical computations followed by the same complex hash function. 
     This complex hash function is preferably, as shall be explained further below, a complex compression function leading to a reduction of the length of the bit strings obtained by the mathematical computations performed. 
     It may be recalled that a hash function is a function of logic processing of binary strings that can be used to obtain a string of characters of determined length on the basis of another string of characters of the same length or of a different length. A complex hash function may be obtained by successive operations of hashing and/or mathematical computations implying the results of several hashing operations. A compression may be obtained at the end by taking, as the result, a modular value modulo 2 e  where e is the length of the string finally desired. 
     Furthermore, according to another major aspect of the invention, there is proposed a novel approach for the processing of the smallest numbers in the smart card, in digital signing algorithms of the type in which the signing brings into action two numbers, r and s, only the number s bringing into action the secret key of the card and the message to be sent. 
     This second aspect of the invention is an improvement to a method for the generation of signatures that has been described in the French patent application 93 14466. In this patent application, it is explained that, in an algorithm of this type (DSA is an example thereof), the number r depends neither on the message m sent by the card nor on the secret key contained in the card. It depends only on numbers that are unchanging for the application considered and on random numbers; for example these numbers are g, p, q and k in the DSA algorithm. It is therefore unnecessary to obtain a computation of r by the card, for this takes up a substantial amount of computation time. Rather, a certified central authority is made to carry out a computation in advance of a series of n possible values r, referenced r i , i being an index ranging from 1 to n. The values r i  are stored in the card. At each new use of the card, one of the values r i  is used (and this value will no longer be used at the following times). At the time of signing, the card computes only the other part of the signature s on the basis of a value r  i  and the secret key x of the message m, and the verifier is then sent the message m and the pair {r i , s} representing the signature that the verifier can then make the check in the manner laid down by the algorithm considered. 
     The numbers r i  are precomputed certificates, also called &#34;signature coupons&#34;. They form a part only of the signature to be sent and they may be prepared and stored in advance in the card. The index i represents the index of the coupon used during a given signature. 
     However, one of the difficulties lies in the great length of these coupons (160 bits in the DSA algorithm represented here above). They use up a substantial degree of non-volatile memory space in the card. It is not possible to save a large number of them in the card if a limited size of non-volatile memory is available. Furthermore, they entail a very lengthy computation time with an 8-bit microprocessor because it is necessary to search for these numbers in small pieces. However, if smaller signature coupons were to be used and stored, there would be the risk of the guarantee of authenticity of signature being far lower. 
     The invention described here makes it possible to reconcile the need for a guarantee of authenticity with the use of smaller signature coupons r i . 
     The invention therefore proposes a method for the generation of electronic signatures by a signer unit and for checking by a verifier unit, using a digital signature algorithm in which the signature sent by the signer comprises at least one signature coupon r i  and one signature complement s that is computed on the basis of the coupon r i  and of a secret key x of the card, this algorithm enabling the checking of a signature by a verifier by means of a checking formula of the following type: 
     v=f(r i , s)=r i   
     this method being characterized in that: 
     a. the signature coupon is established in advance by a certified authority, in two steps: 
     the computation of a number represented by a long binary string, by means of a mathematical formula bringing into action big binary numbers; 
     and the modification of the result of this computation by a complex compression function greatly reducing the length of this result, 
     b. a series of different coupons of small length are thus prepared in advance and stored in the signer unit (smart card with memory and microprocessor), 
     c. the signature generation comprises the sending of a coupon r i  and a signature complement s computed on the basis of at least r i  and x, 
     d. the signature checking algorithm comprises a mathematical computation followed by the same complex compression function as the one used to prepare the coupon, and the result is compared with the coupon for the signature check. 
     The compression function is preferably a complex hash function that requires a fairly lengthy computation time. This provides great security to the method of generation and checking of signatures. Hence the advantage of an efficient guarantee of authenticity of signatures is combined with the possibility of the saving in the card of only small-sized coupons, hence the possibility of saving many of them. If, in addition, the timing mentioned further above is used, it can be seen that it is possible to reinforce the guarantee of authenticity to a very high degree. 
     The computation of the signature s of course brings into action the message m that is to be signed in order to guarantee not only the authenticity of the signature but also the integrity of the message transmitted. 
     It is further possible to improve security by one or more of the following characteristics: 
     The formula for the computation of the coupon r i  is preferably established on the basis of a random element J generated at the outset by the card and stored in the card to be reused when the coupon is be used to establish a signature. 
     It is possible to provide for a situation where, in order to activate the generation of a signature, the verifier terminal will send a random element a to the card and then activate the timer; it can also seen to it that the establishment of the signature complement necessarily uses this random element a and that the checking of signatures also necessitates this random factor a. 
     The signature complement s is preferably established by a computation bringing into action a hash function SHA(m, a) of the message and of this random factor a, the same hash function being used for the signature check. 
     The signature complement s is preferably established by a computation bringing into action a random element J stored in the card and having been used to establish the signature coupon. Preferably again, this computation of s brings into action a hash function SHA(x, J, i) pertaining to this random element J and to an index i representing the number of the coupon used, this same hash function having been used previously during the computation of the long binary string provided for in the computation of the corresponding coupon. This hash function preferably also brings into action the secret key x of the card. 
     The signature function s is preferably established by a computation bringing into action a hash function of the coupon SHA(r i ), the same hash function SHA(r i ) being used for the signature check. 
     Thus, according to a particular aspect of the invention, there is proposed a method for the generation of digital signatures of messages by a signer device and for the checking of these signatures by a verifier device, the signer device comprising means for the computation, communication and retaining of data elements comprising at least one electrically programmable non-volatile memory according to which there are prepared enciphered data elements constituting signature coupons r i  that are loaded into the non-volatile memory and that are used by the signer device to sign messages, chiefly characterized in that: 
     the coupons are compressed by the application of a compression function, also called a hash function, by a certified authority before being loaded into the memory, and in that this method comprises the following exchanges: 
     a message m is transmitted and this message must be certified by a signature, 
     the signer sends a coupon r i  to the verifier, 
     the verifier sends a random number a to the signer and activates a timer, 
     the signer computes the signature s of the message and sends it to the verifier, 
     the verifier stops the timer and ascertains that the signature has been obtained through the secret held in the card and the coupon r i  received; this checking is done by checking the following equality: 
     
         v=f(r.sub.i, s, m)=r.sub.i 
    
     the verifier accepts the signature if the condition of checking v=r i  is fulfilled and if the measured time does not exceed an allocated predetermined period. 
     To simplify the description, hereinafter, reference shall be made above all to a card for the signer or to a signer. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     Other features and advantages of the invention shall appear from the following detailed description made with reference to the appended drawings, of which: 
     FIG. 1 describes the flow chart of a card implementing the system proposed by the present invention; 
     FIG. 2 describes the data elements transmitted between the card and the terminal at the time of the use of the coupon; 
     FIG. 3 describes the flow chart of a terminal implementing the system proposed by the present invention; 
     FIG. 4 shows the data elements transmitted between the card and the authority during the stage for the loading of the coupons and the organization of the memory of the card after the loading of n coupons. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     From the explanations given in the introduction, it will be understood that the main advantage of the signature coupons precomputed according to the method of the invention lies in the speed of computation of a signature by a card based on a single 8-bit microcontroller and the low memory storage requirement of the stored coupons. Typically, the signature computation can be done in 300 ms approximately, including transmission time, and each coupon may use two to four EPROM or EEPROM type memory bytes. 
     The invention shall be described in this example, bearing in mind that it is only an example, even if it is considered herein to be the most advantageous one 
     The method for the generation of signatures can be subdivided in this case into two distinct stages: the loading of the coupons by the authority that has delivered the card and then the use of these coupons by the card, before a terminal that does not know the secret x of the card. 
     The two stages herein make use of two different types of hash functions. It may be recalled that a hash function for the hashing of an number, represented by a string of bits, consists of the production of another string of bits of a specified length that may or may not be the same as the length of the initial string, this production being done on the basis of logic functions carried out on groups of bits of the initial string. 
     Simple hash functions are used, referenced SHA(ch) for the hashing of a string ch. These functions may be standard hash functions such as those published in the recent American standard SHA (Secure Hash Algorithm-FIPS PUB 180, dated Feb. 1, 1993, in Digital Signature Standard). These functions may be MDA or MD5 functions or a hashing operation based on the DES (Data Encryption Standard) algorithm. 
     Other functions, known as complex hash functions will also be used. Their characteristic used herein is not so much that of being a hash function as that of being a slowing-down function dictated during certain signal processing operations, and also that of being a compression function reducing the length of the signature coupons to be saved in the smart card. 
     This slowing-down and compression function is hereinafter referenced H(ch) for the processing of a string ch. 
     All sorts of slowing-down and compression functions could be used in the invention. For example, the following function has been taken as a function H(ch), where SHA(ch) designates a standard hash function: 
     
         H(ch)=SHA SHA{SHA(ch)}.sup.SHA(ch) mod p! mod 2.sup.e 
    
     where e is the length desired for the coupons, for example 16 to 40 bits, giving some bytes. 
     Hereinafter, we shall take up an algorithm directly inspired by the DSA algorithm to show how the original specific features of the invention are implemented. The parameters p, q, g, x, y used are those defined here above with respect to the algorithm DSA. 
     LOADING OF COUPONS INTO THE CARD 
     This is the preliminary step but of course only when a computation is made in advance, outside the card, of the first part r of the signature {r, s} and when several possible values r i  are loaded into the card. 
     1. The card resets a counter in the non-volatile memory (EPROM or EEPROM), generates a random element J (of 10 to 20 bytes for example) records it in the non-volatile memory and sends it to the control authority that knows the secret x of the card and that makes a computation, for i=1 to n, of several values k i  and several values r i  : 
     
         k.sub.i ={1/(SHA(x, J, i)} mod q 
    
     and r i  =H(g ki  mod p); H is the slowing-down and compression function. 
     It may also be envisaged that the card will make a computation for each i of the value SHA(x, J, i) and will send it to the control authority; this authority computes the numbers r i . 
     2. The authority sends the numbers r i  to the card that stores them in memory in preserving the link with the reference i. The numbers k i  are not preserved. 
     If we refer to the algorithm DSA, k i  represents the random number k, modified at each new signature. However, instead of being put out by the verifier terminal at the time of a signature, it will be recomputed at the appropriate time by the card. Since it depends on i and since a coupon with an index i is used only once, k i  is renewed each time. 
     THE USE OF A COUPON TO SIGN A MESSAGE 
     When the card seeks to sign a message, the following protocol is used after the transmission of the message m (preferably in the form of a hashed function of the true message, according to a known hash function of the terminal that receives the message): 
     1. The card: 
     extracts the state i from the counter (representing the current index of the signature that will be produced); 
     extracts, from the non-volatile memory, the random element J, the secret x, the coupon r i  corresponding to the index i; 
     computes I=SHA(x, J, i); this value I is none other than the modular reverse of k i  used for the computation of the coupon r i  ; 
     computes A=xSHA(r i ) mod a; 
     increments i (for a future signature); 
     sends r i  to the verifier terminal; this dispatch representing the first part of the signature. 
     2. The terminal then generates a random element a, to activate the generation of the second part of the signature s; this dispatch constitutes so to speak the sending of a challenge to the card for the verifier terminal, at the same time, acrtivates a timer to measure the response time of the card to this challenge. 
     The signature s that the card must send, given the checking formula f(r i , m, s, a)=r i  which is provided for in the verifier is: 
     
         s= xSHA(r.sub.i) mod q+SHA(m, a)!/k.sub.i mod q 
    
     This formula brings into action the coupon r i , the secret x of the card, the message m sent, the number k i , and the random element a sent by the verifier by way of a challenge. This formula is different from the one given by the DSA algorithm, s=(m+xr)/k, for several reasons: it must bring into action the random element to be sent by way of a challenge so that the verifier is sure that the timing computation of the signature s begins only when the random element a has reached the card. It is for this reason that a hashing of m and of the random element a, namely SHA(m, a), has been used instead of a hashing of m. Furthermore, preferably SHA(r i ) is used rather than r i  to use a coupon value in the form of a string that is longer than r i  which is a very short string. This increases security. But naturally, if xSHA(r i ) is used instead of xr i  and SHA(m, a) is used instead of m, then the checking formula must take account thereof and it shall be seen further below that this is what is done. Other variants of signature computation can be provided for, on condition simply that the checking formula takes account of them. 
     3. The card computes the signature s as speedily as possible. However since, before the activation of the timer, it has already computed A=xSHA(r i ) mod q and I=1/k i  =SHA(x, J, i), all that remains for it to do is to compute: 
     
         s=I.(SHA(m, a)+A) mod q 
    
     This computation can be swift even for a simple, low-cost 8-bit microcontroller, for example of the Intel 8051 type or Motorola 6805 type. Once the computation is over, the card sends back the signature s. 
     4. Upon reception of s, the terminal stops the timer and performs the computations for checking the authenticity of the signature. If the signature has been accurately computed according to the above formula, then it can be verified that it is necessary to have the following equality: 
     
          y.sup.(SHA(ri)/s) mod q g.sup.(SHA(m,a)/s) mod q mod p!=g.sup.ki mod p 
    
     The verifier does not possess k i . It possesses r i  =H(g ki  mod p); H is the slowing-down and compression function. 
     The equality can therefore be converted into: 
     
         G y.sup.(SHA(ri)/s) mod q g.sup.(SHA(m,a)/s) mod q mod p!=H(g.sup.ki mod p)=r.sub.i 
    
     The verifier has available r i , s, a, p, g, m, a, the simple hash function SHA, and the slowing-down and compression function H. It therefore checks the above equality. 
     If the equality is obtained and if the signature has been sent within a period of time smaller than a determined threshold, the signature is accepted by the verifier. If one of the two conditions is not fulfilled, it is not accepted. 
     By way of an example for the assessment of the duration, it is possible to give the following indications: let T be the time needed to assess H(ch) on an extremely powerful computer, possibly even the most powerful computer known today. It may be assumed that the slowing-down function H, leading to strings with a length e (H also having a function of compression) is sufficiently complex and in any case must be chosen to be sufficiently complex so that, for any value z and any existing computer, the search for a new value ch&#39; such that z=H(ch&#39;) requires a period of time T.2 e . 
     Given that someone who is unaware of the secret of the card can make a search for s only by trial and error on the basis of the checking formula (i.e. by making an exhaustive search), he cannot, even with a single attempt, find an accurate value of s if it is chosen to set the time threshold at a level very much smaller than this value T.2 e , for example a millionth of this value. 
     This gives an indication of the methodology to be followed to choose the slowing-down function H and the threshold duration. 
     In general, the principles explained here above and illustrated by an example can be applied to other signature protocols. In particular they can be applied to other protocols in which a precomputation of signature coupons is possible, especially the following protocols: 
     Rueppel-Nyberg 
     &#34;New signature schemes based on the discrete logarithm problem&#34;, in proceedings of the Eurocrypt&#39;94 conference. 
     Schnorr 
     &#34;Efficient identification and signatures for smart cards&#34;, in proceedings of the Crypto&#39;89 conference. 
     El-Gamal 
     &#34;A public-key cryptosystem and a signature scheme based on discrete logarithms&#34;, in the journal IEEE Transactions on Information Theory, Vol. IT30, No. 4, pp. 469-472. 
     Guillou-Quisquater 
     &#34;A practical zero-knowledge protocol fitted to security microprocessors minimizing both transmission and memory&#34;, in proceedings of the Eurocrypt&#39;88 conference and &#34;A paradoxical identity-based signature scheme resulting from zero-knowledge&#34;, in proceedings of the Crypto&#39;88 conference. 
     Other public key systems based on the discrete logarithm, where the equation (m+xr)/k mod q is replaced by another equality bringing into action m, x, r and k (as explained in the article by Horster et al, &#34;Meta message recovery and meta blind signature schemes based on the discrete logarithm problem and their applications&#34;, in proceedings of the Asiacrypt&#39;94 conference), or again systems using several distinct random elements k or several distinct secrets x in the same signature. 
     The invention can be applied to the signing of electronic cheques and can then be used to make these cheques with low-cost smart cards (resulting from the use of an 8-bit microprocessor and a non-volatile memory of limited size). 
     Indeed, the message m may represent a transaction performed by the card with the terminal which is, for example, the payment terminal of a tradesman. This message m is signed. The terminal checks the signature in order to accept the message and hence the transaction, but this terminal is also connected to a central management authority (a bank for example) which must itself be capable of checking the message and the authenticity of the signature before debiting the signer&#39;s account on the one hand and/or crediting the tradesman&#39;s account on the other hand. 
     Thus, after having performed the entire procedure of signing and signature checking described in detail here above, the terminal sends the checking authority the electronic cheque {i, r i , a, s, m}, and the authority ascertains that the signature s is the right signature, namely that: 
     
         s=SHA(x, J, i)  SHA(m, a)+xSHA(r.sub.i)! mod q 
    
     and the authority credits the account of the terminal with the amount of the transaction defined in the message m. 
     It will be noted that, in the computation of the signature by the card, it is possible to use the expression SHA(m, i, a) instead of SHA(m, a). In this case, the formula of checking by the terminal should take account of it and should therefore be: 
     
         H y.sup.(SHA(ri)/s) mod q g.sup.(SHA(m,i,a)/s) mod q mod p!=r.sub.i 
    
     and the formula for the checking of signatures by the authority should also take account of it and be: 
     
         s=SHA(x, J, i) SHA(m, i, a)+xSHA(r.sub.i)! mod q 
    
     Referring to the figures, each smart card consists of a processing unit (CPU) 11, a communications interface 10, a random-access memory (RAM) 13 and/or a read-only memory (ROM) 14 and/or an erasable or electrically erasable and programmable read-only memory (EPROM or EEPROM) 15. 
     The processing unit 11 and/or the ROM 14 of the smart card contain computation programs or resources corresponding to the performance of the computation steps performed by the card during the loading of the coupons and during the signing of a message or the sending of an electronic cheque. These programs contain in particular the rules of computation for the generation of s and the rules of the use of the hash function SHA. The computation unit and the ROM programs also comprise the resources needed for the operations of multiplication, addition and modular reduction. Some of these operations can be combined (for example the modular reduction may be directly integrated into the multiplication). 
     Just as in the case of the DSA algorithm, the RAM of the card contains the message M and the random element a to which there are applied the hash function SHA(m, a) or SHA(m, i, a) for example. The non-volatile memory 15 typically contains the parameters q, x, J and the set of precomputed coupons (r i ). The index is in a non-volatile counter incremented at each new generation of a signature and reset during the loading of coupons. 
     The processing unit of the card, through address and data buses 16 and the communications interface 10, activates the operations of reading and writing in the memory 13, 14 and 15. 
     Each smart card is protected from the exterior by physical protection systems 17. These protection systems ought to be sufficient to prevent any unauthorized entity from obtaining the secret key x. The techniques most commonly used at the present time in this field are the integration of the chip into a safety module and the fitting out of the chips with devices capable of detecting variations in temperature, light as well as abnormal voltages and clock frequencies. Special designing techniques such as the scrambling of the memory access are also used. 
     The terminal for its part consists of a minimum of one processing unit (CPU) 30 and memory resources 32, 33, 34. 
     The CPU 30, through the address and data buses 35 and the communications interface 31, controls the operations of reading and writing in the memories 32, 33, 34. 
     The CPU 30 and/or the ROM 34 of the authority contain computation programs or resources enabling the implementation of the rules of computation and of the hash, slowing-down and compression, multiplication, addition, modular inversion, exponentiation and modular reduction functions needed for the computation of the coupons and for the checking of signatures. Certain of these operations (for example the multiplication and modular reduction operations) may be combined. 
     The entire invention has been described with reference to smart cards, but it will be understood that it can be applied when the signer unit is another object and especially when it is a portable object such as a PCMCIA card which is a type of smart card with parallel and non-serial transmission protocols or a badge, contact-free card, etc. The communication may be between the card and the terminal, either directly by means of electronic signatures or by remote, radiofrequency or infrared transmission.