You are on page 1of 8

Efcient Batch Signature Generation Using Tree Structures

Christopher J. Pavlovski and Colin Boyd Information Security Research Centre School of Data Communications Queensland University of Technology Brisbane, Australia E-mail: pavlovsk, boyd Abstract
We propose an efcient batch signature generation scheme for signing multiple messages simultaneously. The scheme can be based on any signature scheme with appendix and resultant signatures preserve the property of independent verication by different recipients. The scheme is shown to be of almost constant complexity for both generation and verication as the number of messages increases while the size of the signature increases only logarithmically with the number of messages in the batch. It is demonstrated that the security of the batch signature is equivalent to the security of the underlying signature mechanisms. introducing a new signature generation scheme that is able to sign many messages for almost the cost of one signature operation at the server, or signing, entity. We use batch cryptography, demonstrating an efcient means to generate signatures simultaneously on a number of messages. The scheme produces signed messages that may then be forwarded to unrelated recipients for independent verication. Our approach for signing can be used together with any existing signature scheme with appendix. (Signatures in schemes employing an appendix must be accompanied by the message from which they are generated, rather than allowing the message to be extracted from the signature itself [13].) A batch signature consists of an ordinary signature which depends on every message in the batch, and a batch residue which varies with every message (the batch residue is a component of the batch signature on the message). Signature verication consists of recalculating the input to the ordinary signature using the message and batch residue, and then verifying the ordinary signature. Because calculation of the batch residue, and its verication, only use hash calculations, the generation of the batch signature is almost as efcient as generation of a single ordinary signature. However, batch signatures are longer than ordinary signatures because of the need to accommodate a batch residue. We use a binary tree construction to limit the size of the batch residue in a similar fashion to its use by Merkle [15, 13] for tree authentication. (It is interesting that a tree structure is also used in Fiats batch RSA signature scheme [6].) However, to the best of our knowledge tree authentication has not been proposed for use in quite this way before. Employing such a tree structure, with messages representing the leaves of the tree, we are able to marshall an arbitrary number of messages into one batch for signing. The subsequently signed batch, and a unique batch residue, are then forwarded as independent signatures to different recipients for individual verication of their particular message. There have been several previous batch signature

Keywords: Batch Cryptography, Digital Signature, Efciency, Binary Tree.

1 Introduction
Electronic commerce is already presenting many new marketing opportunities for commercial organizations. Whilst the notion of electronic commerce pre-existed its usage over the Internet, today electronic commerce and the Internet are often considered as natural allies. A key requirement for the practical acceptance and wide usage of all forms of electronic commerce is the efciency of any proposed security mechanism employed. A major factor contributing to high computational load is the expense of digital signature schemes, which typically require modular exponentiation. Digital signatures are normally considered an essential mechanism for electronic commerce applications due to the need for non-repudiation and because they can provide authorisation in a distributed environment. We specically address this inefciency by
Conference attendance sponsored by IBM Global Services Australia

schemes which detail procedures to either verify or sign a number of messages [7, 8, 9, 10, 11, 22, 24, 1]. Whilst these techniques produce certain distinct efciencies, each specic scheme possesses some restriction, by way of batch size limitations, verication only, or no support for heterogeneous signature generation for different recipients . The scheme we propose addresses some unresolved issues of these batch signature techniques. This includes, an improved signature size, the ability to sign in batch for independent recipients, and no batch size limitations. The objectives of this paper include: 1. to propose a new batch signature scheme that is capable of generating multiple signed messages simultaneously for individual verication by different recipients. 2. to analyse the security and efciency of the new techniques. 3. to illustrate the applicability of the scheme. The following section discusses previous batch signature generation schemes and provides background to the basic concepts. This is followed by a detailed description of our new batch technique. We then analyse the security of the new scheme and compare its efciency to existing signature protocols. Some potential applications of the new batch signature scheme are also described.

Stage 1 The messages to be signed are combined using a series of small exponentiations, dened by a tree structure formed from the public exponents. Stage 2 The combined message set is signed with a full length exponentiation. Stage 3 The message set is split up, again using the tree structure, to form the individual signatures. The reader may gain the general idea of Fiats scheme by examining the signing process for two messages and , using respective exponents and . Stage 1 Compute the product of the public keys , then combine the messages to form . Stage 2 Sign the batch of messages using one modular ex ponentiation, . Note that . Stage 3 Split the signed batch into individual signatures. First nd the unique value modulo with and . Then one signature is , and the other signature can be found as is found using . Note that the value the Chinese remainder theorem, made possible as exponents are relatively prime. After the nal step, the signed (distinct) messages may then be forwarded to recipients for individual verication under normal RSA verication procedures. This basic approach may be applied to any number of messages using a binary tree construction. It is shown by Fiat that as the number of bits in the RSA modulus increases, the number of multiplications required per message increases as . However, in practice the modulus size is likely to be xed, and we will be more interested in how the performance varies with different size batches. We now calculate a theoretical lower bound on the computation required with Fiats scheme as the batch size varies. This bound is sufcient to demonstrate the computational advantage of our scheme. Before continuing, we provide a little more detail on the rst step of the scheme. A binary tree is constructed where each message and corresponding exponent are assigned to a leaf node (see the appendix for basic denitions and terminology of binary trees). Each arc connecting the leaf node to its parent node is assigned the exponent value of its opposite leaf node (i.e. interchange exponents). In a associated with internal nodes similar fashion, each arc is assigned the exponent , where is the product of all exponents assigned to arcs on the opposite branch.

2 Previous Work
As well as work on batch verication, there have been two main previous approaches to batch signature generation. These are Fiats batch RSA approach [6, 7] and various work on general batch exponentiation, particularly by MRahi and Naccache [16]. We will look at these in turn in sufcient detail to compare their performance and properties with our proposed technique.

2.1 Fiats Batch RSA

Fiats paper [6] appears to be the rst to introduce the notion of batched operations, and he applied the idea to the generation of RSA signatures [19]. The fundamental philosophy is to spread the computational complexity of one full-strength operation over many individual operations. Fiats scheme requires that the signer has several private exponents which are prime with respect to each other and relies on multiplication to form a batch of messages for signing. The batch signing process produces a number of individually signed messages that may then be forwarded to individual recipients in the usual manner. There are three stages in the batch signature procedure (which can also be used for batch RSA decryption).

Number of Messages 5 10 20 50 75 100 200 500

Total Length of Exponents in Stage 1 31 118 400 1734 3194 4872 13035 45243

Effective Modulus Per Message 211 114 71 55 56 59 70 92

appendix, while Fiats is applicable only to RSA.

Our scheme has a small expansion (logarithmic in the number of messages) over the original signature size, while Fiats has no expansion. Fiats scheme, however, requires that veriers know which verication exponent to use. Both schemes allow signatures to be veried independently. Both schemes are provably as secure as the original signature scheme with reasonable assumptions.

Table 1. Lower bounds on computation for Fiats scheme with modulus size of 1024 bits

2.2 Batch Exponentiation Techniques

Because exponentiation is a fundamental computational process for most public key cryptosystems, there has been intense research in optimising exponentiation algorithms. MRahi and Naccache [16], and also Naccache et al. [17], have proposed methods to produce batch random exponentiations. (Similar algorithms are also due to Tsuruoka [21].) These can be used in ElGamal type signatures, such as the Digital Signature Standard (DSS) [5], and are particularly useful for low powered devices. A major gain can be obtained from a straightforward parallel square and multiply algorithm [16] which allows all squarings (the main computational effort) to be shared amongst any number of exponentiations. A number of more sophisticated techniques allow further substantial savings to be made. Some tables showing typical performance [16] show that for batches of Schnorr signatures of size around 100 savings of over 80% of computations can be made. The main points to note, in comparison with batch exponentiation and the proposed method, are the following.

Performance is best when the public exponents are taken to be the rst primes, where is the batch size, so we assume this case from now on. As is stated by Fiat, the number of multiplications required in the rst stage is minimised by choosing the tree to minimise where is the depth of the leaf node of . If we let then the set is a probability distribution and the tree denes a prex free code on any memoryless source with symbols having this probability disttribution. Then by Shannons Noiseless Coding Theorem [4] the entropy, , of that source is a bound on the average codeword length (which is the average value of ), and hence is a lower bound on . Table 1 shows how this estimate of the effective modulus size varies when the size of the RSA modulus used is 1024 bits. The middle column shows that total length of all exponents used in stage 1, while the nal column shows the effective size modulus per message signed. It is interesting to note that the scheme is most efcient when the number of messages is around 75, and in this case the total effort is roughly equivalent to 4 full signature calculations. Note that in table 1 we have only included the rst and second stages (i.e. excluding the split-up phase) of Fiats scheme, so the effort shown is a conservative estimate. The effort in the third stage will usually be less than that of the rst stage, and is shown by Fiat to be asymptotically (with ) the same as the rst stage1 . The main points to note in comparison with Fiats method and the proposed method are the following.

Our scheme is considerably more efcient for xed parameter sizes in the signature, and the efciency continues to grow as the batch size increases. Our scheme is applicable to all signature schemes with appendix, while batch exponentiation is applicable only those requiring random exponentiations to the same base, particularly ElGamal type signatures. Our scheme has a small expansion (logarithmic in the number of messages) over the original scheme, while batch exponentiation can be used without changing the existing signatures at all. Both schemes allow signatures to be veried independently. Both schemes are provably as secure as the original signature scheme (with reasonable assumptions in our case).

1 It

Our scheme is considerably more efcient for xed parameter sizes in the signature, and the efciency continues to grow as the batch size increases. Our scheme is applicable to all signature schemes with

seems more difcult to give a useful lower bound on the effort for the third stage, and since it is not necessary for our comparison we ignore it.

3 Proposed Batch Signature Generation Scheme

The method we propose may be used with trees that accommodate an arbitrary number of child nodes. It is not clear a priori that binary trees are always the best choice. However, we demonstrate below that if we wish to minimise the length of the residue then binary trees are indeed the optimal choice. Following on, we shall only consider the binary tree approach. As stated before, the method can be used with any signature scheme with appendix. This includes all the most popular signatures schemes such as RSA and ElGamal type signatures including the DSS (either in its original form or an elliptic curve variant). Any signature scheme with appendix can be dened by two functions.

The function takes any message from a message space and any private key from the key space and outputs a signature in the space . If is the private key of entity and is any message, then we will denote by .

in 1. In this example the residue of consists of the two nodes and while the residue for consists of the single node . We now give a more formal treatment of the signature generation and verication processes. Suppose that the number of messages to be signed is for some . Then the tree to be used will have nodes of depth and nodes of depth . (We will justify below that this is the best choice of tree with reasonable assumptions.) The Kraft inequality [4] can be used to show that such a tree exists, and in fact this is the tree that will be built by the Huffman code [4] with symbols if all symbols are equally likely. The signer must assign the hash of each message (arbitrarily) to a leaf node. Then all the internal nodes are assigned their values so that a node with left and right child nodes and respectively, has value . All the required hashes can be calculated in a single tree buildup phase. Once the value of the root has been found it can be signed to form the batch signature by user as . If the node for message has depth then its residue consists of the values which can be found as follows. The direction of a node is denoted by and the sibling node of is denoted .

The verication function takes a claimed signature on a specic message and a public key, and outputs a boolean value which indicates whether the verication is satised (output 1) or unsatised (output 0). For our scheme we require two collision resistant hash functions and . In fact, to minimise assumptions, we and for any can dene collision resistant function , where the symbol denotes concatenation of bit strings. This means that nding any and with gives a collision for . In order to generate the batch signature of a set of messages, the hash of each message is placed at a leaf node of the tree. Each parent node is formed by concatenating each of its child nodes and hashing the result. Finally the root node of the tree is signed using the ordinary signature scheme on which the batch signature is based. In order to prevent messages representing the internal nodes from having valid signature (even though they would be random messages) we use the function to hash the leaves and the different function to hash the internal nodes. Now, to form the batch signature of any individual message, consider the unique path from the node representing the message to the root of the tree, found by taking the parent node of each node traversed. The batch residue for that message consists of the sibling nodes of all nodes in this path, together with their direction, which is a single bit denoted or . An example with three messages is shown



if else


(Note that the formation of a specic batch residue is merely a selection process after the tree build-up phase.) The batch signature for message is then the following sequence.

We will consider the overhead caused by the use of the batch signature below. Verication of a claimed signature of user with public key consists of the following procedure.


to then

if else

Figure 1. Batch tree Then, using the verication procedure for the ordinary signature, is evaluated, to give the result of the verication of the batch signature. communications and storage requirements of the generated batch signature. We rst show that binary trees are the best choice, based on the assumption that the most important issue is to minimise the average size of the batch residue. Note that adding more child nodes to every node results in a longer average batch residue but reduces the number of hashes required for both signer and receiver. We expect that in most applications a few extra hash values will be less important than an increased signature size, but if this is not the case then non-binary trees could be considered. Lemma 2 Use of a binary tree minimises the average size of the batch residue.

4 Analysis of Batch Signature Scheme

In this section we consider the security and efciency issues surrounding our new proposed scheme.

4.1 Security Analysis

As long as we assume that the hash function used in the construction of the signature scheme is collision resistant then the following result can be easily proved. Lemma 1 If the ordinary signature scheme used as the basis for the batch signature is secure against existential forgery with an adaptive chosen signature attack then so is the batch signature scheme. Lemma 1 can be proven by observing that a forgery of a new tree root implies an existential forgery for the ordinary signature. So the only possible forgeries must leave the root unchanged. However it can be seen that the tree values cannot be changed because any new value away from the root leads to a collision at the parent node. Finally we note that the tree cannot be truncated to change an internal node into a leaf because, for this to be a valid forgery, there must be a values and with which is again a collision for . This is essentially the same argument as for the security of Merkles authentication trees [15]. There are variants of both RSA [3] and ElGamal [18] signature which are known to be secure against adaptive chosen signature attacks in the widely accepted random oracle model. It follows that there are practical implementations of the batch signature that are provably secure in this sense.

Proof sketch We can show that reducing the number of branches from any node reduces the average residue size. Consider, for example, a node which is the parent of three leaf nodes. Each leaf node must include the other two in its residue so for this subtree each node carries a residue of two hash values. By replacing this subtree with a binary subtree (see gure 2) the single node only requires one hash in its residue while the other two nodes still require only two, and thus the average size of the residue is reduced. Given that a binary tree will be used there are still many different trees possible. It seems likely that in most applications it will be desirable to minimise the average size of the batch residue. This is the same as minimising the average depth of the leaves of the tree, and is achieved by using the Huffman construction mentioned in section 3 which makes the tree as balanced as possible. Recall that the residue consists of hash values, whose length we denote , and the direction which is a single bit denoting right or left. Then as stated before, there are leaf nodes of depth and leaf nodes of depth . Since the depth of the leaf node determines exactly the number of nodes in the residue the following result can be easily derived. Note in particular that the size of the residue increases only as for signed messages.

4.2 Efciency of Batch Signature

To quantify the efciencies of the batch signature technique we now consider the computational costs, and the

Figure 2. Reduction of hash residue with binary tree Lemma 3 The average size of the batch residue is

5 Discussion
In the previous sections we have presented a new batch signature generation scheme that uses efcient tree construction to minimise the batch signature size. The scheme is able to produce multiple signatures simultaneously on multiple messages, in a manner that allows each message to be independently veried by unrelated recipients. We have demonstrated that the signing effort required is signicantly improved, with batches of hundreds, or even thousands of messages, being quite practical. We have also shown that security is equivalent to the ordinary digital signature scheme employed. An important feature of the proposed new scheme is that the signature scheme allows for independent verication of each signed message while there is no restriction for batch verication of multiple messages. This provides many opportunities for applications in electronic commerce where signed authorisations are currently viewed as a necessary computational burden. Two example applications are for signatures of servers in payment schemes and batch processing of coins. Many electronic commerce payment schemes, such as SET [20], include a payment authorisation server (the payment gateway in SET) in their architecture, whose job is to authorise payments for multiple merchants. These servers are likely to receive large numbers of requests almost simultaneously. Use of batch signature generation would have a signicant effect in reducing delay and minimising the duplication of server machines. Anonymous cash schemes [2] are computationally expensive for all parties involved. However, the worst computational burden is carried by the bank which needs to sign each coin withdrawn for every customer. (It should be remembered that all practical off-line anonymous cash schemes use single term coins which can be spent only once). Batch signature generation allows for multiple coins to be signed together. This will allow for linking of the batch of coins (thereby weakening the anonymity) in return

It is interesting to note that there may be applications in which it is desirable to minimise the batch residue size for certain signatures at the cost of increasing it for others. In this event batch signatures may still be used but an alternative tree can be built. A simple way to do this would be to use the Huffman algorithm again, but instead of assigning all messages the same probability as before, one or more messages may be assigned a high probability, and the others smaller probabilities. Of course this will increase the average residue size, but will have little effect on computation. With regard to computational efciency the main observation is that for the signer only one ordinary signature generation is required no matter how large the batch is. The only additional computation required is dictated by the hash transformations for tree building. It can be seen that to sign up to messages no more than hashes are required, or 2 hashes per signed message. For all known signature schemes a hash computation can be regarded as trivial in comparison to the modular exponentiation of signature generation. Therefore, we claim that for the signer the computational cost can be regarded as almost constant in the number of messages signed for any reasonable batch size. For the signature verier the extra computation required is one hash for every node in the batch residue. As remarked above, this number is not more than the base 2 logarithm of the size of the batch. Even for quite large batch sizes this is a minor additional cost compared with the effort of signature verication. Even for RSA verication with small exponents, batch sizes up to a thousand will not cause a major increase in verication time.

for a major saving in computational costs at the bank.

A Binary Trees
A binary tree (see gure 3) has a unique root node. All other nodes have a unique parent node, while all nodes have zero or two child nodes. A node with zero child nodes is called a leaf node. Pairs of nodes which share the same parent are called sibling nodes. Note that each non-root node has a unique sibling node. We need to distinguish any two siblings and so we assign each node the direction left or right. Each node, except the root node, is connected to its parent node via an arc. The number of edges traversed in the shortest path from a node to the root is called the depth of the node. Root Node

[6] Amos Fiat, Batch RSA, Crypto 89, Lecture Notes in Computer Science, Vol. 435, Springer-Verlag, 1990, pp. 175-185. [7] Amos Fiat, Batch RSA, Journal of Cryptology, Volume 10, Number 2, pp75-88, Spring 1997. [8] L.Harn, New digital signature scheme based on discrete logarithm, Electronic Letters, Vol. 30, 5, pp.396398, 3 March 1994. [9] L. Harn, DSA type secure interactive batch verication protocols, Electronic Letters, Vol. 31, 4, pp.257258, 16th Feb 1995. [10] L. Harn, Batch verifying multiple DSA-type digital signatures, Electronic Letters, Vol. 34, 9, pp.870-871, 30th April 1998. [11] L. Harn, Batch verifying multiple RSA digital signatures, Electronic Letters, Vol. 34, 12, pp.1219-1220, 11th June 1998. [12] C. H. Lim, P. J. Lee, Security of interactive DSA batch verication, Electronic Letters, Vol. 30, Issue 19, pp.1592-1593, 16 February 1994. [13] Alfred J. Menezes, Paul C. Van Oorschot, Scott A. Vanstone, Handbook of Applied Cryptography, CRC Press, (1996). [14] R.C. Merkle, Method of Providing Digital Signatures, U.S. Patent No. 4,309,569, 5 Jan 1982. [15] R.C. Merkle, A Certied Digital Signature, Advances in Cryptology - Crypto89, pp.218-238, SpringerVerlag. [16] D. MRahi, D. Naccache, Batch Exponentiation A fast DLP based signature generation strategy, 3rd ACM Conference on Computer and Communications Security, ACM, 1996. [17] D. Naccache, D. MRahi, D. Raphaeli, S. Vaudenay, Can DSA be improved?: complexity trade-offs with the digital signature standard, Proceedings of Eurocrypt94, pp.85-94, 1994. [18] D. Pointcheval and J. Stern, Security Proofs for Signature Schemes, Advances in Cryptology - Eurocrypt96, pp.387-396. [19] R. L. Rivest, A. Shamir, L. Adleman, A method for obtaining digital signatures and public key cryptosystems, ACM, Vol. 21, No. 2, pp.120-126, 1978. [20] SET Protocol Specications (1997): Book 1: Business Description, Book 2: Programmers Guide. Version 1.0, Mastercard & Visa, 1997.

Right Child of Root Node

Pair of Sibling Nodes

Figure 3. Binary tree

[1] M. Bellare, J. A. Garay, T. Rabin, Fast Batch Verication for Modular Exponentiation and Digital Signatures, Proceedings of Eurocrypt98, LNCS, Vol. 1403, Springer-Verlag, 1998. [2] Stefan Brands, Untraceable Off-line Cash in Wallets with Observers. In Advances in Cryptology - Proceedings of Crypto 93, LNCS, Springer-Verlag, volume 773, pp 302-318, 1993. [3] M. Bellare, P. Rogaway, The exact security of digital signatures: How to sign with RSA and Rabin, Advances in Cryptology - Eurocrypt 96 Proceedings, Lecture Notes in Computer Science, Vol. 1070, U. Maurer ed., Springer-Verlag, 1996. [4] T.M.Cover and J.A.Thomas, Elements of Information Theory, Wiley, 1991. [5] NIST, Digital Signature Standard (DSS), FIPS Federal Register, Vol. 56, No. 169, 1991.

[21] Y.Tsuruoka, A Fast Algorithm on Addition Sequence, JWISC93, 1993. (Cited in [16].) [22] Yacov Yacobi, Michael J. Beller, Batch DifeHellman Key Agreement Systems and their Application to Portable Communications, Proceedings of Eurocrypt92, Vol. 658, pp.208-217, 1992. [23] Yacov Yacobi, Michael J. Beller, Batch DifeHellman Key Agreement Systems, Journal of Cryptology, Volume 10, Number 2, pp.89-96, Spring 1997. [24] S. Yen, C. Laih, Improved Digital Signature Suitable for Batch Verication, IEEE Transactions on Computers, Vol. 44, No. 7, pp.957-959, July 1995.