Next Article in Journal
Stability Analysis in a New Model for Desensitization of Allergic Reactions Induced by Chemotherapy of Chronic Lymphocytic Leukemia
Previous Article in Journal
Determination of Safety Monitoring Indices for Roller-Compacted Concrete Dams Considering Seepage–Stress Coupling Effects
Previous Article in Special Issue
Capacity-Raising Reversible Data Hiding Using Empirical Plus–Minus One in Dual Images
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Two-Round Multi-Signatures from Okamoto Signatures

1
Department of Computer and Information Security, Sejong University, Neungdong-ro, Gwangjin-gu, Seoul 05006, Republic of Korea
2
School of Cybersecurity, Korea University, Seoul 02841, Republic of Korea
*
Author to whom correspondence should be addressed.
Mathematics 2023, 11(14), 3223; https://doi.org/10.3390/math11143223
Submission received: 27 June 2023 / Revised: 19 July 2023 / Accepted: 19 July 2023 / Published: 22 July 2023

Abstract

:
Multi-signatures (MS) are a special type of public-key signature (PKS) in which multiple signers participate cooperatively to generate a signature for a single message. Recently, applications that use an MS scheme to strengthen the security of blockchain wallets or to strengthen the security of blockchain consensus protocols are attracting a lot of attention. In this paper, we propose an efficient two-round MS scheme based on Okamoto signatures rather than Schnorr signatures. To this end, we first propose a new PKS scheme by modifying the Okamoto signature scheme and prove the unforgeability of our PKS scheme under the discrete logarithm assumption in the algebraic group model (AGM) and the non-programmable random oracle model (ROM). Next, we propose a two-round MS scheme based on the new PKS scheme and prove the unforgeability of our MS scheme under the discrete logarithm assumption in the AGM and the non-programmable ROM. Our MS scheme is the first one to prove security among two-round MS based on Okamoto signatures.

1. Introduction

Multi-signatures (MS) are a special kind of public-key signature (PKS) in which multiple signers who have individual public keys P K 1 , , P K n can cooperatively participate to create a signature for a single message and verify the signature by using the public keys of all signers participating in the signature generation. An MS scheme becomes an interesting MS scheme only when the size of the multi-signature is compact, regardless of the number of cooperating signers, because an MS scheme can be easily built from the existing PKS scheme in a simple way of attaching individual signatures of PKS schemes. Interactive MS schemes can be constructed from the existing Fiat–Shamir-based signature schemes [1,2,3], and non-interactive MS schemes also can be constructed based on bilinear groups [4,5,6,7]. In recent years, research on multi-signatures has been attracting a lot of attention because it can be effectively used to enhance the security of blockchain wallets or to perform secure consensus among multiple nodes in blockchains.
A popular way to design a PKS scheme is to convert an identification protocol into a PKS scheme by using the Fiat–Shamir transformation [8]. The Schnorr signature scheme is the famous example of this case [9]. A PKS scheme derived from this transformation has the advantage of being widely implemented and used in various places because it can be very efficient and proven under standard assumptions. One important way to design an MS scheme is to convert a Fiat–Shamir-based PKS scheme to an MS scheme with interactive signing. Bellare and Neven [1] have shown that a three-round MS scheme can be constructed from the Schnorr signature scheme in the plain public-key model. Afterwards, a number of two-round MS schemes that improve the rounds required in the interactive signing process were proposed [10,11,12]. However, Drijvers et al. [13] showed that all of these two-round MS schemes can be attacked by using a parallel signing session attack with the Wagner algorithm, and it is difficult to prove the security of these MS schemes by using the meta-reduction technique. To solve this problem, a number of new two-round MS schemes based on Schnorr signatures or trapdoor commitment schemes have been proposed recently [13,14,15,16,17].
The Okamoto signature scheme is also one of the Fiat–Shamir-based PKS schemes [18]. An important feature of Okamoto signatures, different from Schnorr signatures, is that Schnorr-based signatures use the zero-knowledge property to handle the signature queries of an attacker, but Okamoto signatures use the witness indistinguishability to handle these signature queries. Due to this difference, the simulation of the signature in the security proof of Okamoto signatures can be easily processed using the private key selected by a simulator. The Okamoto signature scheme can also be converted to a three-round MS scheme by following the conversion method of Bellare and Neven [1]. To reduce the number of rounds further, Ma et al. [11] proposed a two-round MS scheme from Okamoto signatures, but this scheme is not secure against the parallel signing session attack, as shown by Drijvers et al. [13]. There are many secure two-round MS schemes based on Schnorr signatures or trapdoor commitments [13,15,16,17], but constructing a secure two-round MS scheme based on Okamoto signatures is still an unsolved problem.
In this paper, we focus on the problem of constructing a two-round MS scheme based on Okamoto signatures. Designing an MS scheme based on Okamoto signatures is an interesting problem because it can present a new design direction for MS schemes different from the existing design of two-round MS schemes. In addition, an MS scheme based on Okamoto signatures can use a weaker random oracle model because it uses a non-programmable random oracle model (NPROM) instead of a programmable random oracle model (PROM).

1.1. Our Contributions

We first propose a PKS scheme suitable for multi-signatures by modifying Okamoto signatures. The essential part of the modification is to set a commitment element in a message-dependent way such as R = ( g m h ) r 1 ( g 2 m h 2 ) r 2 instead of R = g r 1 g 2 r 2 . We prove that the proposed PKS scheme is secure under the discrete logarithm (DL) assumption in the algebraic group model (AGM) and the non-programmable random oracle model (NPROM). Next, we propose a two-round MS scheme that supports the public key aggregation from our PKS scheme based on Okamoto signatures. We also prove that our MS scheme is unforgeable even when an attacker performs parallel signing session queries under the DL assumption in the AGM and NPROM. Compared to other MS schemes, our proposed MS scheme also has a compact public key, a succinct multi-signature, and efficient signing and verification with the support of two-round signing and key aggregation. Although our MS scheme does not provide improved efficiency compared to the most efficient MuSig2 scheme, our MS scheme is the first two-round MS scheme based on Okamoto signatures, and the security is proven under the weaker DL assumption in the weaker non-programmable ROM. The detailed comparison of our MS scheme and other MS schemes is given in Table 1.
There are two issues to consider in the security proof of the two-round MS scheme: the rogue-key attack [1] and parallel signing session attack [13]. In the rogue-key attack, an attacker forges a multi-signature by manipulating a carefully crafted public key without knowing the corresponding private key since the attacker can select the arbitrary public key of a co-signer in the plain public-key model. For example, we consider a simple Schnorr-based MS scheme in which the public keys of co-signers are simply multiplied. Let X 1 = g x 1 be the public key of an honest party 1. If an adversary simply sets the public key of party 2 as X 2 = g a / X 1 by selecting a random a, then it can forge a multi-signature σ = ( R = g r , z = r + c a ) where c = H ( R , M ) since X 1 X 2 = g a . Fortunately, by using the key aggregation method of the MuSig scheme [3], this rogue-key attack can be easily prevented in our MS scheme. The parallel signing session attack is a complicated attack in which an attacker opens multiple signature query sessions in parallel in a two-round MS scheme since the signing process is an interactive protocol, and then the attacker manipulates the obtained signatures of parallel sessions to forge a multi-signature. This parallel signing session attack is based on Wagner’s algorithm to solve the generalized birthday problem, which is to find a set of queries { q 1 , , q } such that i = 1 H ( q i ) = t when a fixed value t and access to random oracle H are given. In the case of 2 , this problem is equal to finding a pre-image or a collision in the random oracle. However, in the case of > 2 , this problem becomes easy for large . The detailed explanation of this attack in Schnorr-based signatures is given in the work [13,16]. Recall that many two-round MS schemes proposed early can be attacked by using this parallel signing session attack [13]. To prevent this parallel signing session attack, our MS scheme generates a commitment in the form R = ( g m h ) r 1 ( g 2 m h 2 ) r 2 where m is a message. As the commitment is configured depending on the signature message, in this way, if an attacker performs the parallel signing session attack, the commitments for the same message can be changed to a new commitment, but these commitments cannot be converted to a new commitment for a different message. The detailed explanation of the security proof is given in Section 2.3.

1.2. Related Work

Multi-signatures (MS) are a kind of PKS in which multiple signers participate to generate a signature for a common message and anyone can verify the signature with the public keys of multiple signers. Early MS schemes were vulnerable to rogue-key attacks, in which an attacker arbitrarily sets the public key of a signer participating in multi-signature to perform a forgery attack. Bellare and Neven [1] introduced the plain public-key model in which an attacker can freely set the public key of a signer without proving the knowledge of a private key and proposed a three-round MS scheme that is secure against the rogue-key attack by modifying Schnorr signatures. Since then, a number of two-round MS schemes have been proposed to improve the round complexity of Fiat–Shamir-based MS schemes [10,11,12]. However, Drijvers et al. [13] showed that these two-round MS schemes are vulnerable to parallel signing session attack by using Wagner’s algorithm and proposed a modified MS scheme by modifying the existing BCJ-MS scheme. Maxwell et al. [3] presented the MuSig scheme in which the signers’ public keys are aggregated into one short public key in the three-round MS scheme and showed that this MS scheme can be used for Bitcoin. Recently, a number of secure two-round MS schemes, MuSig-DN, MuSig2, DWMS, and HBMS, have been proposed [14,15,16,17]. Another way to design an MS scheme is to convert an aggregate signature scheme into a non-interactive MS scheme by setting a message to be the same for all signers. Using this idea, Boneh et al. [2] proposed an efficient non-interactive MS scheme from the BLS short signature scheme and proved the security in the plain public-key model. Drijvers et al. [7] proposed a non-interactive MS scheme with forward security from a sequential aggregate signature scheme that can be used in blockchain consensus protocols.
Threshold signatures (TS) are a specific kind of PKS such that a threshold number of signers cooperate to generate a signature on a message and the signature can be verified by a compact verification key. Multi-signatures can also be viewed as a special form of threshold signatures where the number of threshold is equal to the number of all signers. Since the ECDSA scheme is a standard signature scheme that is widely used in cryptocurrency such as Bitcoin, many studies have been conducted to convert the ECDSA scheme into an efficient threshold ECDSA scheme [19,20,21,22]. Recently, efficient TS schemes have been proposed by modifying Schnorr signatures [23,24,25]. An important difference between TS schemes and MS schemes is the key generation process. In MS, signers can generate private keys independently of each other. Contrary to this, TS schemes require the distribution of a common secret key to multiple signers, so a rather complicated distributed key generation protocol must be introduced. A distributed key generation (DKG) protocol allows the sharing of a common secret to many signers without a trusted center. If a common secret to be shared is a field element, a DKG protocol can be implemented by using a verifiable secret sharing (VSS) scheme that can privately verify the validity of a shared secret [26]. If a common secret is a group element, a DKG protocol can be implemented by using a public verifiable secret sharing (PVSS) scheme that can publicly verify the validity of a shared secret [27]. Recently, Groth [28] proposed a PVSS scheme that can support a field element by splitting a common secret into multiple chunks and constructed a non-interactive DKG scheme by combining the PVSS scheme with a binary tree encryption scheme with forward secrecy.
Aggregate signatures (AS) are a special type of PKS that allows multiple signers to create signatures for different messages and aggregate them into a single signature. The concept of aggregate signatures was introduced by Boneh et al. [29], and they constructed an efficient AS scheme by modifying BLS signatures in bilinear groups. Since then, many AS schemes based on bilinear groups and trapdoor functions have been proposed [5,6,30,31]. The security of AS schemes is proven in the knowledge of secret key (KOSK) model, which requires the proof of secret key in the key registration process, and it is stronger than the plain public-key model of multi-signatures. AS schemes are divided into three types, full aggregation, sequential aggregation, and synchronized aggregation, according to the method of aggregation. A full AS scheme is the most flexible type of AS schemes that allows anyone to non-interactively aggregate individual signatures generated by different signers on different messages into a succinct signature [29]. A sequential AS scheme supports for a signer to sequentially add his signature to the previous aggregate signature received from the previous signer [5,30]. A synchronized AS scheme is similar to the full AS scheme except that all signers have the synchronized information and individual signatures with the same synchronized information can be non-interactively aggregated [31]. As previously described, a pairing-based non-interactive MS scheme can be constructed from an AS scheme if the same message is used for all signers.

1.3. Subsequent Work

Subsequent to our work, Tessaro and Zhu [32] proposed another two-round MS scheme based on Okamoto signatures and proved its security under the DL assumption in ROM. They constructed an efficient MS scheme by combining the linear combination of nonces used in the MuSig2 scheme with Okamoto signatures.

2. Public-Key Signature

In this section, we propose a new PKS scheme by modifying Okamoto signatures and prove the security in the AGM and ROM.

2.1. Definition

The syntax of public-key signature (PKS) is generally composed of key generation, signing, and verification algorithms. Because we consider a PKS scheme in which multiple users share common public parameters, we add a setup algorithm to generate public parameters. The detailed syntax of PKS is given as follows.
Definition 1
(Public-Key Signature). A public-key signature (PKS) scheme consists of four PPT algorithms, Setup, GenKey, Sign, and Verify, which are defined as follows:
  • Setup ( 1 λ ) . The setup algorithm takes as input the security parameters λ in unary and outputs public parameters P P .
  • GenKey ( P P ) . The key generation algorithm takes as input public parameters P P and outputs a private key S K and a public key P K .
  • Sign ( S K , M ) . The signing algorithm takes as input a message M and a private key S K and outputs a signature σ.
  • Verify ( P K , σ , M ) . The verification algorithm takes as input a signature σ, a message M, and a public key P K and outputs 1 if the signature is valid and 0 otherwise.
The correctness requirement is that for P P output by Setup ( 1 λ ) , any ( S K , P K ) output by GenKey ( P P ) and any M, we have that Verify ( P K , Sign ( S K , M ) , M ) = 1 .
The standard security model of PKS is the unforgeability under chosen message attack (UF-CMA). In this model, an attacker is initially given a challenge public key for attack, and can request a signature query for any message and receive a signature. Finally, the attacker outputs a forged signature for a message. The attacker is successful if the forged signature passes the verification algorithm and the message has not been queried before. The detailed security model of PKS is described as follows.
Definition 2
(Unforgeability). The security notion of a PKS scheme is unforgeability under chosen message attack (UF-CMA), which is defined in terms of the following experiment between a challenger C and a PPT adversary A :
1. 
Setup: C first generates P P by running Setup ( 1 λ ) . Next, it obtains a key pair ( S K , P K ) by running GenKey ( P P ) . It gives P K to A .
2. 
Signature Query: A adaptively requests a signature on a message M to sign under the challenge public key P K , and it receives a signature σ.
3. 
Output: Finally, A outputs a forged signature σ * on a message M * under the public key P K . C outputs 1 if the forged signature satisfies the following two conditions, or outputs 0 otherwise: (1) Verify ( P K , σ * , M * ) = 1 , and (2) the corresponding message M * must not have been queried by A to the signing oracle.
The advantage of A is defined as Adv A P K S ( λ ) = Pr [ C = 1 ] , where the probability is taken over all the randomness of the experiment. A PKS scheme is UF-CMA-secure if all probabilistic polynomial-time (PPT) adversaries have at most a negligible advantage in the above experiment where a function f ( λ ) is negligible if f ( λ ) < 1 / p ( λ ) for all polynomial p ( λ ) with a large enough security parameter λ.

2.2. Construction

Our PKS scheme is a modification of Okamoto signatures [18]. The Okamoto PKS scheme generates a commitment as R = g r 1 g 2 r 2 where r 1 and r 2 are random exponents, but our PKS scheme generates a commitment as R = ( g m h ) r 1 ( g 2 m h 2 ) r 2 to depend on a message m. This modification helps to simplify the security proof of our PKS scheme in the algebraic group model and it enables the construction of a secure multi-signature scheme in the next section. The detailed description of our PKS scheme is given as follows:
  • PKS.Setup( 1 λ ): It first generates a cyclic group G of prime order p where the bit size of p is Θ ( λ ) . It generates two random generators g , h G . It selects a random exponent α Z p and sets g 2 = g α , h 2 = h α . It chooses cryptographic hash functions H 1 , H 2 such that H 1 : { 0 , 1 } * Z p and H 2 : { 0 , 1 } * Z p . Finally, it outputs public parameters P P = ( p , G , g , g 2 , h , h 2 , H 1 , H 2 ) .
  • PKS.GenKey( P P ): It selects random x 1 , x 2 Z p and computes X = g x 1 g 2 x 2 , Y = h x 1 h 2 x 2 . It outputs a private key S K = ( P P , x 1 , x 2 ) and a public key P K = ( P P , X , Y ) .
  • PKS.Sign( S K , M ): Let S K = ( P P , x 1 , x 2 ) . It first calculates a hash m = H 1 ( M ) . Next, it selects random r 1 , r 2 Z p and computes R = g m h r 1 g 2 m h 2 r 2 . It calculates c = H 2 ( R , M ) and computes s 1 = r 1 + x 1 c   mod   p , s 2 = r 2 + x 2 c   mod   p . It outputs a signature σ = ( c , s 1 , s 2 ) .
  • PKS.Verify( P K , σ , M ): Let σ = ( c , s 1 , s 2 ) and P K = ( P P , X , Y ) . It first calculates m = H 1 ( M ) . Next, it computes R = g m h s 1 g 2 m h 2 s 2 / X m Y c and checks that c = ? H 2 ( R , M ) . If the equation holds, then it outputs 1. Otherwise, it outputs 0.
The correctness of this PKS scheme can be easily verified when m = H 1 ( M ) through the following equation
g m h s 1 g 2 m h 2 s 2   = g m h r 1 + x 1 c g 2 m h 2 r 2 + x 2 c   = g m h r 1 g 2 m h 2 r 2 g m h x 1 c g 2 m h 2 x 2 c   = g m h r 1 g 2 m h 2 r 2 g x 1 g 2 x 2 m h x 1 h 2 x 2 c = R X m Y c
where R = ( g m h ) r 1 ( g 2 m h 2 ) r 2 , X = g x 1 g 2 x 2 , and Y = h x 1 h 2 x 2 .

2.3. Security Analysis

Before we analyze the security of our scheme, we define an algebraic adversary, the discrete logarithm assumption, and the Schwartz–Zippel Lemma, which are needed for the security analysis.
Definition 3
(Algebraic Algorithm [33]). Let G be a group with order p. We say that an algorithm A a l g is algebraic if it satisfies the following requirements: whenever A a l g outputs a group element Z G , it also outputs a representation z = ( z 1 , , z ) Z p such that Z = k = 1 V k z k where V 1 , , V are group elements that are given to A a l g during its execution.
Assumption 1
(Discrete Logarithm). Let ( p , G ) be a description of the group of prime order p. Let g be a generator of G . The discrete logarithm (DL) assumption is that if the challenge values D = ( p , G , g , g x ) are given, no probabilistic polynomial-time (PPT) algorithm B can compute x with more than a negligible advantage. The advantage of B is defined as Adv B D L ( λ ) = Pr [ B ( D ) = x ] where the probability is taken over the random choice of x Z p .
Lemma 1
(Schwartz–Zippel Lemma [34]). Let f ( x 1 , , x n ) be a non-zero polynomial of total degree d. Let S F be any finite set. Then, if r 1 , , r n are randomly chosen from S, Pr [ f ( r 1 , , x n ) = 0 ] d / | S | .
In order to prove the security of our PKS scheme under the DL assumption, it is needed to devise a method to simulate the signature query requested by an adversary and to extract the discrete logarithm from a forged signature submitted by the adversary. One nice feature of Okamoto signatures is that the signature simulation is very simple because a simulator chooses a private key itself and generates a signature by using the private key [18]. The signature simulation of our PKS scheme is also handled very simply, the same as that of Okamoto signatures. In order to extract the discrete logarithm from the forged signature, we take advantage of the fact that an algebraic adversary additionally submits the representation of a group element when it submits the group element of the forged signature.
In Schnorr-based signature schemes, a formula for discrete logarithm can be derived using the representation of a group element and the verification equation of the scheme, and the extraction of discrete logarithm is possible because the denominator of the formula is not zero with high probability due to the randomness of the random oracle model. However, unlike the Schnorr-based signature scheme, the Okamoto-based signature scheme additionally includes a signature element submitted by an adversary in the denominator of the discrete logarithm-related formula, so it is difficult to analyze that the denominator is not zero by simply using the randomness of the random oracle model. To solve this problem, we divide the adversary into three types. In the case of Type-1 and Type-2 adversaries, the discrete logarithm problem is simply planted to enable the extraction of the discrete logarithm. In the case of Type-3 adversary, we will show that it is difficult for the adversary to submit a valid forged signature due to the restriction of the security model through probability analysis. The detailed security proof of our PKS scheme is given in the following theorem.
Theorem 1.
The above PKS scheme is UF-CMA-secure in the algebraic group model and the random oracle model if the DL assumption holds. That is, for any PPT algebraic adversary A a l g , there exists a PPT algorithm B such that Adv A a l g P K S ( λ ) 2 Adv B D L ( λ ) + n e g l ( λ ) .
Proof. 
Suppose there exists an algebraic adversary A a l g that forges the above PKS scheme with non-negligible advantage ϵ . A reduction algorithm B that solves the DL assumption is given as input for a challenge tuple D = ( p , G , g , g a ) . Then, B that interacts with A a l g is described as follows:
  • Setup: The algorithm B first chooses a random bit b { 0 , 1 } to guess the type of an adversary. If b = 0 , then it selects a random exponent h Z p and sets g 2 = g a , h = g h , h 2 = g 2 h . Otherwise, it selects a random exponent α Z p and sets g 2 = g α , h = g a , h 2 = ( g a ) α . It sets public parameters P P = ( p , G , g , g 2 , h , h 2 , H 1 , H 2 ) where H 1 and H 2 are two hash functions that are modeled as random oracles. Next, it selects random exponents x 1 , x 2 Z p and computes X = g x 1 g 2 x 2 , Y = h x 1 h 2 x 2 . It keeps S K = ( P P , x 1 , x 2 ) internally and gives P K = ( P P , X , Y ) to A a l g .
  • Hash Query: If A a l g requests an H 1 or H 2 hash query, then B handles this query as follows:
  • H 1 hash query for ( M ) : If ( M , · ) L H 1 , then it retrieves ( M , m ) from L H 1 . Otherwise, it selects random m Z p and adds ( M , m ) to L H 1 . It gives m to A a l g .
  • H 2 hash query for ( R , M ) : If ( R , M , · ) L H 2 , then it retrieves ( R , M , c ) from L H 2 . Otherwise, it selects random c Z p and adds ( R , M , c ) to L H 2 . It gives c to A a l g .
  • Signature Query: If A a l g requests a signature query for a message M, then B adds M to Q and generates a signature σ = ( c , s 1 , s 2 ) by running PKS.Sign ( S K , M ) since it has S K . It gives σ to A a l g . Recall that A a l g is implicitly given a commitment R = g m h s 1 g 2 m h 2 s 2 X m Y c from the signature σ where m = H 1 ( M ) .
Note that A a l g is an algebraic adversary that when it requests hash queries with a group element Z , it also submits a representation z = ( z 1 , , z ) for the group element Z such that Z = i = 1 V i z i and { V i } are group elements given to A a l g . For the simplicity of the notation, we do not describe representations for group elements in hash queries. We assume that the representations of group elements submitted by A a l g are implicitly stored in the lists maintained by B .
  • Output: Finally, A a l g outputs a forged signature σ * = ( c * , s 1 * , s 2 * ) on a message M * . B checks that PKS.Verify ( P K , σ * , M * ) = 1 and M * Q .
From the verification algorithm of the PKS scheme, it can derive the commitment group element R * of σ * by computing R * = g m * h s 1 * g 2 m * h 2 s 2 * X m * Y c * where m * = H 1 ( M * ) . Next, it finds the representation z = ( z 1 , , z 6 , z 7 , 1 , , z 7 , q S ) of the element R * that is implicitly stored in L H 2 such as R * = g z 1 g 2 z 2 h z 3 h 2 z 4 X z 5 Y z 6 k = 1 q S R ( k ) z 7 , k where X = g x 1 g 2 x 2 , Y = h x 1 h 2 x 2 , and R ( k ) = g m ( k ) h r 1 ( k ) g 2 m ( k ) h 2 r 2 ( k ) is the commitment of k-th signature query. By combining the above equations, it can derive the following equation
1 = g m * h s 1 * g 2 m * h 2 s 2 * X m * Y c * R * 1 = g m * s 1 * h s 1 * g 2 m * s 2 * h 2 s 2 * g x 1 g 2 x 2 m * h x 1 h 2 x 2 c * ·   g z 1 h z 3 g 2 z 2 h 2 z 4 g x 1 g 2 x 2 z 5 h x 1 h 2 x 2 z 6 k = 1 q S g m ( k ) h r 1 ( k ) z 7 , k g 2 m ( k ) h 2 r 2 ( k ) z 7 , k 1 = g m * ( s 1 * x 1 c * ) h ( s 1 * x 1 c * ) g 2 m * ( s 2 * x 2 c * ) h 2 ( s 2 * x 2 c * ) ·   g z 1 + x 1 z 5 + k = 1 q S m ( k ) r 1 ( k ) z 7 , k h z 3 + x 1 z 6 + k = 1 q S r 1 ( k ) z 7 , k g 2 z 2 + x 2 z 5 + k = 1 q S m ( k ) r 2 ( k ) z 7 , k h 2 z 4 + x 2 z 6 + k = 1 q S r 2 ( k ) z 7 , k 1 = g A 1 h A 2 g 2 B 1 h 2 B 2
where A 1 , A 2 , B 1 , and B 2 are variables defined as
A 1 : = m * ( s 1 * x 1 c * ) z 1 + x 1 z 5 + k = 1 q S m ( k ) r 1 ( k ) z 7 , k , A 2 : = ( s 1 * x 1 c * ) z 3 + x 1 z 6 + k = 1 q S r 1 ( k ) z 7 , k , B 1 : = m * ( s 2 * x 2 c * ) z 2 + x 2 z 5 + k = 1 q S m ( k ) r 2 ( k ) z 7 , k , B 2 : = ( s 2 * x 2 c * ) z 4 + x 2 z 6 + k = 1 q S r 2 ( k ) z 7 , k .
To solve the discrete logarithm, we classify algebraic adversaries into the following three types depending on the conditions of variables:
  • Type-1: an algebraic adversary is Type-1 if B 1 + dlog g ( h ) B 2 0   mod   p .
  • Type-2: an algebraic adversary is Type-2 if B 1 + dlog g ( h ) B 2 0   mod   p and B 2 0   mod   p .
  • Type-3: an algebraic adversary is Type-3 if B 1 + dlog g ( h ) B 2 0   mod   p and B 2 0   mod   p .
Let F be the event that an adversary succeeds to forge a multi-signature and T i be the event that an adversary is Type-i. Since the random bit b is hidden to the adversary and b is independent to the type of the adversary, we have that Pr [ b = 0 F | T i ] = Pr [ b = 1 F | T i ] for each type of adversary. If the Type-1 adversary is successful to forge and the guess of the reduction algorithm is correct ( b = 0 ), then the reduction can compute the discrete logarithm as dlog g ( g 2 ) = ( A 1 + h A 2 ) / ( B 1 + h B 2 )   mod   p since g 2 = g a and B 1 + h B 2 0   mod   p . That is, Pr [ b = 0 F | T 1 ] Adv B D L ( λ ) . If the Type-2 adversary is successful to forge and the guess of the reduction is correct ( b = 1 ), then the reduction can compute the discrete logarithm as dlog g 2 ( h 2 ) = B 1 / B 2   mod   p since g 2 = g α , h 2 = ( g a ) α , B 1 + dlog g ( h ) B 2 0   mod   p , and B 2 0   mod   p . That is, Pr [ b = 1 F | T 2 ] Adv B D L ( λ ) . From Lemma 3, the probability of the Type-3 adversary to successfully forge is negligible. That is, Pr [ F | T 3 ] negl ( λ ) . Therefore, we obtain the following result
Adv A a l g U F - C M A ( λ )   = Pr [ F T 1 ] + Pr [ F T 2 ] + Pr [ F T 3 ]   = Pr [ T 1 ] Pr [ F | T 1 ] + Pr [ T 2 ] Pr [ F | T 2 ] + Pr [ T 3 ] Pr [ F | T 3 ]   = Pr [ T 1 ] Pr [ b = 0 F | T 1 ] + Pr [ b = 1 F | T 1 ] +     Pr [ T 2 ] Pr [ b = 0 F | T 2 ] + Pr [ b = 1 F | T 2 ] + Pr [ T 3 ] Pr [ F | T 3 ]   Pr [ T 1 ] 2 Adv B D L ( λ ) + Pr [ T 2 ] 2 Adv B D L ( λ ) + Pr [ T 3 ] negl ( λ )   Pr [ T 1 ] 2 Adv B D L ( λ ) + ( 1 Pr [ T 1 ] ) 2 Adv B D L ( λ ) + negl ( λ )   2 Adv B D L ( λ ) + negl ( λ ) .
This completes our proof. □
Lemma 2.
In the above PKS scheme, the private key exponents ( x 1 , x 2 ) and random exponents { ( r 1 ( k ) , r 2 ( k ) ) } for signature queries are statistically hidden to an algebraic adversary.
Proof. 
In order to show that the private key exponents ( x 1 , x 2 ) and random exponents { ( r 1 ( k ) , r 2 ( k ) ) } selected by the reduction algorithm are statistically hidden from the adversary, we should show that these exponents can be changed to different exponents ( x ˜ 1 , x ˜ 2 ) and { ( r ˜ 1 ( k ) , r ˜ 2 ( k ) ) } while the public key group elements, the commitment group elements, and the signatures given to the adversary are fixed.
Let ( X , Y ) be the challenge public key. If the private key exponents ( x 1 , x 2 ) can be changed to different private key exponents ( x ˜ 1 , x ˜ 2 ) , then we obtain the first relation x 1 + α x 2 x ˜ 1 + α x ˜ 2   mod   p from the following equation
X = g x 1 g 2 x 2 = g x 1 + α x 2 = g x ˜ 1 + α x ˜ 2 = g x ˜ 1 g 2 x ˜ 2 , Y = h x 1 h 2 x 2 = h x 1 + α x 2 = h x ˜ 1 + α x ˜ 2 = h x ˜ 1 h 2 x ˜ 2 .
Let R ( k ) be the commitment element of the k-th signature query. If the random exponents ( r 1 ( k ) , r 2 ( k ) ) can be changed to different random exponents ( r ˜ 1 ( k ) , r ˜ 2 ( k ) ) , then we obtain the second relation r 1 ( k ) + α r 2 ( k ) r ˜ 1 ( k ) + α r ˜ 2 ( k )   mod   p from the following equation
R ( k ) = g m ( k ) h r 1 ( k ) g 2 m ( k ) h 2 r 2 ( k ) = g ( m ( k ) + h ) ( r 1 ( k ) + α r 2 ( k ) ) = g ( m ( k ) + h ) ( r ˜ 1 ( k ) + α r ˜ 2 ( k ) ) = g m ( k ) h r ˜ 1 ( k ) g 2 m ( k ) h 2 r ˜ 2 ( k ) .
Let ( s 1 ( k ) , s 2 ( k ) ) be the signature of the k-th signature query where s 1 ( k ) = r 1 ( k ) + x 1 c ( k ) and s 2 ( k ) = r 2 ( k ) + x 2 c ( k ) . If the random exponents ( x 1 , x 2 ) and ( r 1 ( k ) , r 2 ( k ) ) can be changed to different random exponents ( x ˜ 1 , x ˜ 2 ) and ( r ˜ 1 ( k ) , r ˜ 2 ( k ) ) , then we obtain the following third and fourth relations
r 1 ( k ) + x 1 c ( k )   r ˜ 1 ( k ) + x ˜ 1 c ( k )   mod   p , r 2 ( k ) + x 2 c ( k )   r ˜ 2 ( k ) + x ˜ 2 c ( k )   mod   p .
Now, we argue that new private key exponents and new random exponents can satisfy the above four relations and these exponents are different from the original exponents. From the above first, second, and third relations, we set the new exponents as follows
  x ˜ 1 Z p * ,   x ˜ 2 : = x 2 + ( x 1 x ˜ 1 ) α 1   mod   p ,   r ˜ 1 ( k ) : = r 1 ( k ) + ( x 1 x ˜ 1 ) c ( k )   mod   p ,   r ˜ 2 ( k ) : = r 2 ( k ) + ( r 1 ( k ) r ˜ 1 ( k ) ) α 1   mod   p .
Next, we show that these new exponents satisfy the fourth relation as follows
  r 2 ( k ) r ˜ 2 ( k ) + x 2 c ( k ) x ˜ 2 c ( k )   ( r 1 ( k ) r ˜ 1 ( k ) ) α 1 ( x 1 x ˜ 1 ) α 1 c ( k )   ( r 1 ( k ) r ˜ 1 ( k ) ) + ( x 1 x ˜ 1 ) c ( k ) α 1 0   mod   p .
This completes our proof. □
Lemma 3.
If the algebraic adversary is Type-3, then the advantage of the adversary in UF-CMA game is negligible.
Proof. 
From Theorem 1, we have the equation g A 1 h A 2 g 2 B 1 h 2 B 2 = 1 where variables B 1 and B 2 are defined as follows
B 1 : = m * ( s 2 * x 2 c * ) z 2 + x 2 z 5 + k = 1 q S m ( k ) r 2 ( k ) z 7 , k , B 2 : = ( s 2 * x 2 c * ) z 4 + x 2 z 6 + k = 1 q S r 2 ( k ) z 7 , k .
Now, we analyze the conditions to satisfy B 2 0   mod   p . From Lemma 2, we know that x 2 and { r 2 ( k ) } are statistically hidden to the adversary. To satisfy B 2 0   mod   p , the term x 2 c * of B 2 that is not directly controlled by the adversary should be cancelled out. To analyze this, we consider the following two cases:
  • Case 1: Let B A D 1 be an event that x 2 c * is cancelled by z 4 + x 2 z 6 + k = 1 q S r 2 ( k ) z 7 , k . Recall that the term z 4 + x 2 z 6 + k = 1 q S r 2 ( k ) z 7 , k is associated with the element R * . In the signing algorithm, c * is the output of a hash function H 2 that takes R * as an input, and H 2 is modeled as a random oracle. Thus, c * is a random value independent of R * by the property of the random oracle. This means that the probability of B A D 1 is at most 1 / p .
  • Case 2: Let B A D 2 be the event that the term x 2 c * is cancelled by s 2 * . Recall that the term s 2 * is the output of the adversary as the forged signature and x 2 is statistically hidden to the adversary. The only way to cancel out this term is for the adversary to construct a forged signature by combining the simulated signatures { ( s 1 ( k ) , s 2 ( k ) ) } given from the signature queries since the reduction algorithm simply constructs a signature s 2 ( k ) = r 2 ( k ) + x 2 c ( k ) by using the hidden private key element x 2 . In this case, the term ( s 2 * x 2 c * ) additionally contains a statistically hidden random exponent r 2 ( k ) from the commitment R ( k ) for some k. Thus, there should exist an index k { 1 , , q S } such that z 7 , k 0   mod   p since A a l g is an algebraic adversary that submits a group element with a representation of group elements given to the adversary.
    From the conditions B 1 + dlog g ( h ) B 2 0   mod   p and B 2 0   mod   p of the Type-3 adversary, we have that B 1 B 2 0   mod   p . By combining B 1 and B 2 , we have the following equation
    B 1 + m * B 2   z 2 + x 2 z 5 m * ( z 4 + x 2 z 6 ) + k = 1 q S ( m ( k ) m * ) r 2 ( k ) z 7 , k 0   mod   p .
    Since z 7 , k 0   mod   p for some k and r 2 ( k ) is statistically hidden to the adversary, the above equation can be reshaped as a degree-one polynomial C 1 r 2 ( k ) + C 0 0   mod   p where a coefficient C 1 is expressed as C 1 = ( m ( k ) m * ) z 7 , k . By the Schwartz–Zippel lemma, the probability of the above polynomial to be zero is at most 1 / p if r 2 ( k ) is randomly selected and C 1 0   mod   p . By the restrictions of the security model 2, we have M * Q . Thus the probability that m ( k ) m * 0   mod   p for some k when M * Q is bounded by q S / p since H 1 is modeled as a random oracle. This means that the probability of B A D 2 is at most ( q S + 1 ) / p .
The success probability of the adversary is bounded by the probability of all bad events, and the probability of all bad events are bounded as
Pr [ B A D ] Pr [ B A D 1 ] + Pr [ B A D 2 ] ( q S 1 + 2 ) / p .
This completes our proof. □

2.4. Discussion

Multi-User Security. In the security proof, we analyzed the security of our PKS scheme in the single-user setting. In the multi-user setting, many public keys P K 1 , , P K n are given to an adversary where n is bounded by a polynomial, and the adversary forges a signature for one of these public keys. In general, a PKS scheme that provides the single-user security also satisfies the multi-user security, but the security reduction is not tight since it has a loss of a factor n. In the security proof of our PKS scheme, a simulator can freely select the private key of each user. Thus, it is possible to prove the multi-user security of our PKS scheme with tight proof.

3. Multi-Signature

In this section, we propose a two-round MS scheme supporting public-key aggregation based on the PKS scheme in the previous section and prove that it is secure in the DL assumption in the AGM and ROM.

3.1. Definition

Multi-signature (MS) is a special kind of PKS in which multiple signers participate to generate a multi-signature for a message, and the multi-signature can be verified by using all public keys of the signers participating in the signature generation. We define the syntax of MS that supports the aggregation of the public keys of the signers into a single public key. The detailed syntax of MS supporting public key aggregation is given as follows.
Definition 4
(Multi-Signature). A multi-signature (MS) scheme with key aggregation consists of five PPT algorithms Setup, GenKey, AggKey, Sign, and Verify, which are defined as follows:
  • Setup ( 1 λ ) . The setup algorithm takes as input the security parameters λ in unary and outputs public parameters P P .
  • GenKey ( P P ) . The key generation algorithm takes as input public parameters P P and outputs a private key S K and a public key P K .
  • AggKey ( L K ) . The key aggregation algorithm takes as input a list of public keys L K = ( P K 1 , , P K n ) and outputs an aggregated public key A K .
  • Sign ( S K i , L K , M ) . The signing algorithm takes as input a private key S K i , a list of public keys L K , and a message M and outputs a multi-signature σ.
  • Verify ( L K , σ , M ) . The verification algorithm takes as input a list of public keys L K , a signature σ, and a message M and outputs either 1 or 0 depending on the validity of the signature.
The correctness requirement is that for P P output by Setup ( 1 λ ) , ( S K i , P K i ) output by GenKey ( P P ) , and any M, we have that Verify ( L K , Sign ( S K i , L K , M ) , M ) = 1 .
The security model of MS extends the standard security model of PKS to the multi-user setting, which is called the plain public-key model [1]. In this plain public-key model, it is possible for an attacker to freely select the public keys of co-signers except the target public key. Because of this relaxation, the attacker can create a fake public key without knowing the private key of that public key, which is called a rogue-key attack. Additionally, if the signing protocol is composed of multiple rounds, the attacker can request parallel signing queries for multiple signatures when querying the signature. Finally, the attacker succeeds in forgery if the target public key is included in the final multi-signature and a target message has not been queried before in the signing queries. The detailed security model of MS is defined as follows.
Definition 5
(Unforgeability). The security notion of an MS scheme in the plain public-key model is unforgeability under a chosen message attack (MS-UF-CMA), which is defined in terms of the following experiment between a challenger C and a PPT adversary A :
1. 
Setup: C obtains public parameters P P by running Setup ( 1 λ ) and obtains a challenge key pair ( S K * , P K * ) by running GenKey ( P P ) . It gives P K * to A .
2. 
Signature Query: A adaptively requests a multi-signature on a message M to sign under the challenge public key P K , and it receives a multi-signature σ.
3. 
Output: Finally, A outputs a forged multi-signature σ * on a message M * under public keys L K * = ( P K 1 , , P K n ) . C outputs 1 if the forged multi-signature satisfies the following three conditions, or outputs 0 otherwise: (1) Verify ( L K * , σ * , M * ) = 1 , (2) the challenge public key P K * must exist in L K * , and (3) the message M * must not have been queried by A to the signing oracle.
The advantage of A is defined as Adv A M S ( λ ) = Pr [ C = 1 ] where the probability is taken over all the randomness of the experiment. An MS scheme is MS-UF-CMA-secure if all PPT adversaries have at most a negligible advantage in the above experiment where a function f ( λ ) is negligible if f ( λ ) < 1 / p ( λ ) for all polynomial p ( λ ) with a large enough security parameter λ.

3.2. Construction

In order to design a secure two-round MS scheme, it is necessary to design a method to be secure against the Wagner algorithm using parallel signing query as shown in previous studies [13]. To do this, we change the random commitment element dependent on the signature message. That is, a commitment element is formed as R = ( g m h ) r 1 ( g 2 m h 2 ) r 2 where m is a message and r 1 , r 2 are random exponents. The advantage of message-dependent commitment such as this is that even if an attacker obtains multiple commitment elements by requesting parallel signing queries, it is difficult for the attacker to derive another commitment for a new message because the commitment elements can be converted only for the same message. To perform such a commitment, the MS scheme needs to include h and h 2 elements in addition to g and g 2 elements in public parameters. Each private key of a user is set to the same x 1 and x 2 field elements as the Okamoto signature scheme, and the public key is set to X = g x 1 g 2 x 2 and Y = h x 1 h 2 x 2 due to additional public parameters. Note that the public key of the Okamoto signature scheme consists of one group element X, but our MS scheme consists of two group elements X and Y. The method of supporting the public key aggregation follows the previous method [3], and the aggregated public key consists of two group elements. The detailed description of our MS scheme is given as follows:
  • MS.Setup( 1 λ ): It first generates a cyclic group G of prime order p of bit size Θ ( λ ) . It chooses random generators g , h G . It selects a random exponent α Z p and sets g 2 = g α , h 2 = h α . Next, it chooses cryptographic hash functions H 1 , H 2 , H 3 such that H 1 : { 0 , 1 } * Z p , H 2 : { 0 , 1 } * Z p , and H 3 : { 0 , 1 } * Z p . It outputs public parameters P P = ( p , G , g , g 2 , h , h 2 , H 1 , H 2 , H 3 ) .
  • MS.GenKey( P P ): It chooses random x i , 1 , x i , 2 Z p and computes X i = g x i , 1 g 2 x i , 2 , Y i = h x i , 1 h 2 x i , 2 . It outputs a private key S K i = ( P P , x i , 1 , x i , 2 ) and a public key P K i = ( P P , X i , Y i ) .
  • MS.AggKey( L K ): Let L K = ( P K 1 , , P K n ) be the list of public keys where P K i = ( P P , X i , Y i ) . It calculates a i = H 3 ( L K , P K i ) for all i { 1 , , n } . Next, it computes A X = i = 1 n X i a i and A Y = i = 1 n Y i a i . It outputs an aggregated public key A K = ( P P , A X , A Y ) .
  • MS.Sign( S K i , L K , M ): Let S K i = ( P P , x i , 1 , x i , 2 ) and L K = ( P K 1 , , P K n ) where P K i = ( P P , X i , Y i ) . It obtains A K by running MS.AggKey ( L K ) and calculates a i = H 3 ( L K , P K i ) .
    1. 
    It calculates a hash m = H 1 ( M ) . It selects random r i , 1 , r i , 2 Z p and computes R i = g m h r i , 1 g 2 m h 2 r i , 2 . Next, it broadcasts R i to all co-signers.
    2. 
    It receives { R j } 1 j i n from the co-signers. It computes A R = i = 1 n R i . It calculates c = H 2 ( A K , A R , M ) . Next, it computes s i , 1 = r i , 1 + x i , 1 a i c   mod   p and s i , 2 = r i , 2 + x i , 2 a i c   mod   p . It broadcasts ( s i , 1 , s i , 2 ) to all co-signers.
    3. 
    It receives { ( s j , 1 , s j , 2 ) } 1 j i n from the co-signers. Next, it sets s 1 = i = 1 n s i , 1   mod   p and s 2 = i = 1 n s i , 2   mod   p . It outputs a multi-signature σ = ( c , s 1 , s 2 ) .
  • MS.Verify( L K , σ , M ): Let σ = ( c , s 1 , s 2 ) be a multi-signature on a message M under the list of public keys L K . It obtains A K = ( P P , A X , A Y ) by running MS.AggKey ( L K ) . It calculates a hash m = H 1 ( M ) . Next, it derives
    A R = g m h s 1 g 2 m h 2 s 2 / A X m A Y c
    and checks that c = ? H 2 ( A K , A R , M ) . If the equation holds, then it outputs 1. Otherwise, it outputs 0.
The correctness of this MS scheme can be easily verified when m = H 1 ( M ) through the following equation
g m h s 1 g 2 m h 2 s 2   = g m h i = 1 n ( r i , 1 + x i , 1 a i c ) g 2 m h 2 i = 1 n ( r i , 2 + x i , 2 a i c )   = g m h i = 1 n r i , 1 g 2 m h 2 i = 1 n r i , 2 g m h i = 1 n x i , 1 a i c g 2 m h 2 i = 1 n x i , 2 a i c   = i = 1 n g m h r i , 1 g 2 m h 2 r i , 2 · i = 1 n g m h x i , 1 a i g 2 m h 2 x i , 2 a i c   = i = 1 n R i · i = 1 n g x i , 1 g 2 x i , 2 a i m h x i , 1 h 2 x i , 2 a i c   = i = 1 n R i · i = 1 n X i a i m i = 1 n Y i a i c = A R · A X m A Y c .

3.3. Security Analysis

The overall strategy to prove the security of our MS scheme is mostly similar to the strategy to prove the security of our PKS scheme in the previous section. That is, the simulator of security proof processes the signature query of an adversary by using a self-selected private key and divides the algebraic adversaries into three types to derive discrete logarithms from the forged signature of the adversary. First, in the case of Type-1 and Type-2 adversaries, if the challenge element of the discrete logarithm assumption is embedded in g 2 and h, respectively, it is possible for the simulator to extract the discrete logarithm without difficulty by using the forged signature submitted by the adversary and the representation of a group element in the forged signature. The difficult part of the proof is to show that a Type-3 adversary has a negligible probability of succeeding in forgery. To do this, we take advantage of the fact that the private key elements and the random commitment exponents are statistically hidden from the adversary, which is the important characteristic of Okamoto signatures. In this case, we use the condition that the target message m * is different from a message m ( k ) queried in the signing query, which is the security constraint of the MS-UF-CMA security model. In this case, it can be shown that the probability of successful forgery of the Type-3 adversary is negligible. Additionally, in the case of our MS scheme, the Type-3 adversary analysis is somewhat complicated because the final commitment element is aggregated from individual commitment elements generated by co-signers. The detailed security proof of our MS scheme is given in the following theorem.
Theorem 2.
The above MS scheme is MS-UF-CMA-secure in the algebraic group model if the DL assumption holds. That is, for any PPT algebraic adversary A a l g , there exist PPT algorithms B such that Adv A a l g M S ( λ ) 2 Adv B D L ( λ ) + n e g l ( λ ) .
Proof. 
Suppose there exists an algebraic adversary A a l g that forges the above MS scheme with non-negligible advantage ϵ . A reduction algorithm B that solves the DL assumption is given as input for a challenge tuple D = ( p , G , g , g a ) . Then, B that interacts with A a l g is described as follows:
  • Setup: The algorithm B first chooses a random bit b { 0 , 1 } to guess the type of an adversary. If b = 0 , then it selects a random exponent h Z p and sets g 2 = g a , h = g h , h 2 = g 2 h . Otherwise, it selects a random exponent α Z p and sets g 2 = g α , h = g a , h 2 = ( g a ) α . It sets public parameters P P = ( p , G , g , g 2 , h , h 2 , H 1 , H 2 ) where H 1 and H 2 are hash functions that are modeled as random oracles. Next, it selects random exponents x 1 * , x 2 * Z p and computes X * = g x 1 * g 2 x 2 * , Y * = h x 1 * h 2 x 2 * . It sets a challenge private key S K * = ( P P , x 1 * , x 2 * ) and a challenge public key P K * = ( P P , X * , Y * ) . It keeps S K * internally and gives P K 1 = P K * to A a l g .
  • Hash Query: If A a l g requests an H 1 , H 2 , or H 3 hash query, then B handles this query as follows:
  • H 1 hash query for ( M ) : If ( M , · ) L H 1 , then it retrieves ( M , m ) from L H 1 . Otherwise, it selects random m Z p and adds ( M , m ) to L H 1 . It gives m to A a l g .
  • H 2 hash query for ( A K , A R , M ) : If ( A K , A R , M , · ) L H 2 , then it retrieves ( A K , A R , M , c ) from L H 2 . Otherwise, it selects random c Z p and adds ( A K , A R , M , c ) to L H 2 . It gives c to A a l g .
  • H 3 hash query for ( L K , P K i ) : If ( L K , P K i , · ) L H 3 , then it retrieves ( L K , P K i , a i ) from L H 3 . Otherwise, it selects random a i Z p and adds ( L K , P K i , a i ) to L H 3 . It gives a i to A a l g .
  • Signature Query: If A a l g requests a first-round or second-round signature query, then B handles this query as follows:
  • First-round signature query for ( M ) : It adds M to Q and calculates m = H 1 ( M ) . It selects random exponents r 1 , 1 , r 1 , 2 Z p and computes R 1 = ( g m h ) r 1 , 1 ( g 2 m h 2 ) r 1 , 2 . It adds ( M , R 1 , r 1 , 1 , r 1 , 2 ) to L S 1 . It gives R 1 to A a l g .
  • Second-round signature query for ( L K , M , { R i } i = 1 n ) where L K = ( P K 1 , , P K n ) : If ( M , R 1 , · , · ) L S 1 or P K 1 P K * , then it returns 0. It retrieves ( M , R 1 , r 1 , 1 , r 1 , 2 ) from L S 1 . It computes A R = i = 1 n R i . It obtains A K by running MS.AggKey ( L K ) and calculates a 1 = H 3 ( L K , P K 1 ) . It calculates c = H 2 ( A K , A R , M ) . Next, it computes s 1 , 1 = r 1 , 1 + x 1 * a 1 c   mod   p and s 1 , 2 = r 1 , 2 + x 2 * a 1 c   mod   p . It adds ( L K , M , { R i } i = 1 n , A R , c , s 1 , 1 , s 1 , 2 , r 1 , 1 , r 1 , 2 ) to L S 2 . It gives ( s 1 , 1 , s 1 , 2 ) to A a l g .
Note that A a l g is an algebraic adversary that when it requests hash and signature queries with a group element Z G , it also submits a representation z = ( z 1 , , z ) for the group element Z such that Z = i = 1 V i z i and { V i } are group elements given to A a l g . For the simplicity of the notation, we do not describe representations for group elements in hash and signature queries. We assume that the representations of group elements submitted by A a l g are implicitly stored in the lists maintained by B .
  • Output: Finally, A a l g outputs a forged multi-signature σ * = ( c * , s 1 * , s 2 * ) on a message M * under a list of public keys L K * = ( P K 1 , , P K n ) . B checks that MS.Verify ( L K * , σ * , M * ) = 1 , P K 1 = P K * , and M * Q .
From the verification algorithm of the MS scheme, it can derive the following equation
A R * = g m * h s 1 * g 2 m * h 2 s 2 * A X m * A Y c *   = g m * s 1 * h s 1 * g 2 m * s 2 * h 2 s 2 * X 1 a 1 i = 2 n X i a i m * c * Y 1 a 1 i = 2 n Y i a i c *
where X 1 = g x 1 * g 2 x 2 * and Y 1 = h x 1 * h 2 x 2 * . Next, it finds representations z = ( z 1 , , z 7 , 1 , , z 7 , q S 1 ) of the group element A R * , u ( i ) = ( u 1 ( i ) , , u 7 , 1 ( i ) , , u 7 , q S 1 ( i ) ) of the group element X i , and v ( i ) = ( v 1 ( i ) , , v 7 , 1 ( i ) , , v 7 , q S 1 ( i ) ) of the group element Y i that are implicitly stored in hash lists such as
  A R * = g z 1 g 2 z 2 h z 3 h 2 z 4 X 1 z 5 Y 1 z 6 k = 1 q S 1 R 1 ( k ) z 7 , k ,   X i = g u 1 ( i ) g 2 u 2 ( i ) h u 3 ( i ) h 2 u 4 ( i ) X 1 u 5 ( i ) Y 1 u 6 ( i ) k = 1 q S 1 R 1 ( k ) u 7 , k ( i ) ,   Y i = g v 1 ( i ) g 2 v 2 ( i ) h v 3 ( i ) h 2 v 4 ( i ) X 1 v 5 ( i ) Y 1 v 6 ( i ) k = 1 q S 1 ( R 1 ( k ) ) v 7 , k ( i )
where R 1 ( k ) = g m ( k ) h r 1 , 1 ( k ) g 2 m ( k ) h 2 r 2 , 2 ( k ) is the commitment of the k-th first-round signature query.
By combining above equations, it can derive the following simplified equation
g A 1 h A 2 g 2 B 1 h 2 B 2 = g A 1 + dlog g ( h ) A 2 g 2 B 1 + dlog g ( h ) B 2 = 1
where A 1 , A 2 , B 1 , B 2 are variables defined by the forged signature ( c * , s 1 * , s 2 * ) , the representations z , { u ( i ) , v ( i ) } , private key elements x 1 * , x 2 * , random exponents { r 1 , 1 ( k ) , r 1 , 2 ( k ) } , and message hashes m * , { m ( k ) } .
To solve the discrete logarithm, we classify algebraic adversaries into the following three types depending on the conditions of variables:
  • Type-1: an algebraic adversary is Type-1 if B 1 + dlog g ( h ) B 2 0   mod   p .
  • Type-2: an algebraic adversary is Type-2 if B 1 + dlog g ( h ) B 2 0   mod   p and B 2 0   mod   p .
  • Type-3: an algebraic adversary is Type-3 if B 1 + dlog g ( h ) B 2 0   mod   p and B 2 0   mod   p .
Let F be the event that an adversary succeeds to forge a multi-signature and T i be the event that an adversary is Type-i. Since the random bit b is hidden to the adversary and b is independent of the type of the adversary, we have that Pr [ b = 0 F | T i ] = Pr [ b = 1 F | T i ] for each type of the adversary. If the Type-1 adversary is successful to forge and the guess of the reduction algorithm is correct ( b = 0 ), then the reduction can compute the discrete logarithm as dlog g ( g 2 ) = ( A 1 + h A 2 ) / ( B 1 + h B 2 )   mod   p since g 2 = g a and B 1 + h B 2 0   mod   p . That is, Pr [ b = 0 F | T 1 ] Adv B D L ( λ ) . If the Type-2 adversary is successful to forge and the guess of the reduction is correct ( b = 1 ), then the reduction can compute the discrete logarithm as dlog g 2 ( h 2 ) = B 1 / B 2   mod   p since g 2 = g α , h 2 = ( g a ) α , B 1 + dlog g ( h ) B 2 0   mod   p , and B 2 0   mod   p . That is, Pr [ b = 1 F | T 2 ] Adv B D L ( λ ) . From Lemma 5, the probability of the Type-3 adversary to successfully forge is negligible. That is, Pr [ F | T 3 ] negl ( λ ) . Therefore, we obtain the following result
Adv A a l g M S - U F - C M A ( λ )   = Pr [ F T 1 ] + Pr [ F T 2 ] + Pr [ F T 3 ]   = Pr [ T 1 ] Pr [ F | T 1 ] + Pr [ T 2 ] Pr [ F | T 2 ] + Pr [ T 3 ] Pr [ F | T 3 ]   = Pr [ T 1 ] Pr [ b = 0 F | T 1 ] + Pr [ b = 1 F | T 1 ] +     Pr [ T 2 ] Pr [ b = 0 F | T 2 ] + Pr [ b = 1 F | T 2 ] + Pr [ T 3 ] Pr [ F | T 3 ]   Pr [ T 1 ] 2 Adv B D L ( λ ) + Pr [ T 2 ] 2 Adv B D L ( λ ) + Pr [ T 3 ] negl ( λ )   Pr [ T 1 ] 2 Adv B D L ( λ ) + ( 1 Pr [ T 1 ] ) 2 Adv B D L ( λ ) + negl ( λ )   2 Adv B D L ( λ ) + negl ( λ ) .
This completes our proof. □
Lemma 4.
In the above MS scheme, the private key exponents ( x 1 * , x 2 * ) and random exponents { ( r 1 , 1 ( k ) , r 1 , 2 ( k ) ) } for first-round signature queries are statistically hidden to an algebraic adversary.
Proof. 
In order to show that the private key exponents ( x 1 * , x 2 * ) and random exponents { ( r 1 , 1 ( k ) , r 1 , 2 ( k ) ) } selected by the reduction algorithm are statistically hidden from the adversary, we should show that these exponents can be changed to different exponents ( x ˜ 1 * , x ˜ 2 * ) and { ( r ˜ 1 , 1 ( k ) , r ˜ 1 , 2 ( k ) ) } while the public key group elements, the commitment group elements, and the partial signatures given to the adversary are fixed.
Let ( X 1 , Y 1 ) be the challenge public key. If the private key exponents ( x 1 * , x 2 * ) can be changed to different private key exponents ( x ˜ 1 * , x ˜ 2 * ) , then we obtain the first relation x 1 * + α x 2 * x ˜ 1 * + α x ˜ 2 *   mod   p from the following equation
X 1 = g x 1 * g 2 x 2 * = g x 1 * + α x 2 * = g x ˜ 1 * + α x ˜ 2 * = g x ˜ 1 * g 2 x ˜ 2 * , Y 1 = h x 1 * h 2 x 2 * = h x 1 * + α x 2 * = h x ˜ 1 * + α x ˜ 2 * = h x ˜ 1 * h 2 x ˜ 2 * .
Let R 1 ( k ) be the commitment element of the k-th signature query. If the random exponents ( r 1 , 1 ( k ) , r 1 , 2 ( k ) ) can be changed to different random exponents ( r ˜ 1 , 1 ( k ) , r ˜ 1 , 2 ( k ) ) , then we obtain the second relation r 1 , 1 ( k ) + α r 1 , 2 ( k ) r ˜ 1 , 1 ( k ) + α r ˜ 1 , 2 ( k )   mod   p from the following equation
R 1 ( k ) = g m ( k ) h r 1 , 1 ( k ) g 2 m ( k ) h 2 r 1 , 2 ( k ) = g ( m ( k ) + h ) ( r 1 , 1 ( k ) + α r 1 , 2 ( k ) ) = g ( m ( k ) + h ) ( r ˜ 1 , 1 ( k ) + α r ˜ 1 , 2 ( k ) ) = g m ( k ) h r ˜ 1 , 1 ( k ) g 2 m ( k ) h 2 r ˜ 1 , 2 ( k ) .
Let ( s 1 , 1 ( k ) , s 1 , 2 ( k ) ) be the partial signature of the k-th signature query where s 1 , 1 ( k ) = r 1 , 1 ( k ) + x 1 * a 1 c ( k ) and s 1 , 2 ( k ) = r 1 , 2 ( k ) + x 2 * a 1 c ( k ) . If the random exponents ( x 1 * , x 2 * ) and ( r 1 , 1 ( k ) , r 1 , 2 ( k ) ) can be changed to different random exponents ( x ˜ 1 * , x ˜ 2 * ) and ( r ˜ 1 , 1 ( k ) , r ˜ 1 , 2 ( k ) ) , then we obtain the following third and fourth relations
r 1 , 1 ( k ) + x 1 * a 1 c ( k )   r ˜ 1 , 1 ( k ) + x ˜ 1 * a 1 c ( k )   mod   p , r 1 , 2 ( k ) + x 2 * a 1 c ( k )   r ˜ 1 , 2 ( k ) + x ˜ 2 * a 1 c ( k )   mod   p .
Now, we argue that new private key exponents and new random exponents can satisfy the above four relations and that these exponents are different than the original exponents. From the above first, second, and third relations, we set the new exponents as follows
  x ˜ 1 * Z p * ,   x ˜ 2 * : = x 2 * + ( x 1 * x ˜ 1 * ) α 1   mod   p ,   r ˜ 1 , 1 ( k ) : = r 1 , 1 ( k ) + ( x 1 * x ˜ 1 * ) a 1 c ( k )   mod   p ,   r ˜ 1 , 2 ( k ) : = r 1 , 2 ( k ) + ( r 1 , 1 ( k ) r ˜ 1 , 1 ( k ) ) α 1   mod   p .
Next, we show that these new exponents satisfy the fourth relation as follows
  r 1 , 2 ( k ) r ˜ 1 , 2 ( k ) + x 2 * a 1 c ( k ) x ˜ 2 * a 1 c ( k )   ( r 1 , 1 ( k ) r ˜ 1 , 1 ( k ) ) α 1 ( x 1 * x ˜ 1 * ) α 1 a 1 c ( k )   ( r 1 , 1 ( k ) r ˜ 1 , 1 ( k ) ) + ( x 1 * x ˜ 1 * ) a 1 c ( k ) α 1 0   mod   p .
This completes our proof. □
Lemma 5.
If the algebraic adversary is Type-3, then the advantage of the adversary in MS-UF-CMA game is negligible.
Proof. 
Let A R * be the group element derived from a forged multi-signature σ * . From the verification algorithm, the forged signature σ * = ( c * , s 1 * , s 2 * ) with the element A R * satisfies the following equation
1 = g m * h s 1 * g 2 m * h 2 s 2 * A R * 1 A X m * A Y c *   = g m * s 1 * h s 1 * g 2 m * s 2 * h 2 s 2 * A R * 1 i = 1 n X i a i m * c * i = 1 n Y i a i c *   = g m * s 1 * h s 1 * g 2 m * s 2 * h 2 s 2 * · X 1 a 1 m * c * Y 1 a 1 c * · A R * 1 · i = 2 n X i m * a i c * i = 2 n Y i a i c *   = g m * s 1 * h s 1 * g 2 m * s 2 * h 2 s 2 * · ( g x 1 * g 2 x 2 * ) a 1 m * c * ( h x 1 * h 2 x 2 * ) a 1 c * · A R * 1 · i = 2 n X i m * a i c * i = 2 n Y i a i c *   = g m * s 1 * m * x 1 * a 1 c * h s 1 * x 1 * a 1 c * g 2 m * s 2 * m * x 2 * a 1 c * h 2 s 2 * x 2 * a 1 c * · A R * 1 · i = 2 n X i m * a i c * i = 2 n Y i a i c * .
Next, we find the representation z = ( z 1 , , z 6 , z 7 , 1 , , z 7 , k ) from L H 2 for the group element A R * such as
A R * = g z 1 g 2 z 2 h z 3 h 2 z 4 X 1 z 5 Y 1 z 6 k = 1 q S 1 R 1 ( k ) z 7 , k   = g z 1 g 2 z 2 h z 3 h 2 z 4 ( g x 1 * g 2 x 2 * ) z 5 ( h x 1 * h 2 x 2 * ) z 6 k = 1 q S 1 ( g m ( k ) h ) r 1 , 1 ( k ) ( g 2 m ( k ) h 2 ) r 1 , 2 ( k ) z 7 , k   = g z 1 g 2 z 2 h z 3 h 2 z 4 g x 1 * z 5 g 2 x 2 * z 5 h x 1 * z 6 h 2 x 2 * z 6 g k = 1 q S 1 m ( k ) r 1 , 1 ( k ) z 7 , k h k = 1 q S 1 r 1 , 1 ( k ) z 7 , k g 2 k = 1 q S 1 m ( k ) r 1 , 2 ( k ) z 7 , k h 2 k = 1 q S 1 r 1 , 2 ( k ) z 7 , k   = g z 1 + x 1 * z 5 + k = 1 q S 1 m ( k ) r 1 , 1 ( k ) z 7 , k h z 3 + x 1 * z 6 + k = 1 q S 1 r 1 , 1 ( k ) z 7 , k g 2 z 2 + x 2 * z 5 + k = 1 q S 1 m ( k ) r 1 , 2 ( k ) z 7 , k h 2 z 4 + x 2 * z 6 + k = 1 q S 1 r 1 , 2 ( k ) z 7 , k .
We can also find the representations u ( i ) = ( u 1 ( i ) , , u 6 ( i ) , u 7 , 1 ( i ) , , u 7 , k ( i ) ) , v ( i ) = ( v 1 ( i ) , , v 6 ( i ) , v 7 , 1 ( i ) , , v 7 , k ( i ) ) from L H 2 for the group elements X i , Y i , respectively, such as
X i = g u 1 ( i ) g 2 u 2 ( i ) h u 3 ( i ) h 2 u 4 ( i ) X 1 u 5 ( i ) Y 1 u 6 ( i ) k = 1 q S 1 R 1 ( k ) u 7 , k ( i )   = g u 1 ( i ) + x 1 * u 5 ( i ) + k = 1 q S 1 m ( k ) r 1 , 1 ( k ) u 7 , k ( i ) h u 3 ( i ) + x 1 * u 6 ( i ) + k = 1 q S 1 r 1 , 1 ( k ) u 7 , k ( i )     g 2 u 2 ( i ) + x 2 * u 5 ( i ) + k = 1 q S 1 m ( k ) r 1 , 2 ( k ) u 7 , k ( i ) h 2 u 4 ( i ) + x 2 * u 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) u 7 , k ( i ) , Y i = g v 1 ( i ) g 2 v 2 ( i ) h v 3 ( i ) h 2 v 4 ( i ) X 1 v 5 ( i ) Y 1 v 6 ( i ) k = 1 q S 1 R 1 ( k ) v 7 , k ( i )   = g v 1 ( i ) + x 1 * v 5 ( i ) + k = 1 q S 1 m ( k ) r 1 , 1 ( k ) v 7 , k ( i ) h v 3 ( i ) + x 1 * v 6 ( i ) + k = 1 q S 1 r 1 , 1 ( k ) v 7 , k ( i )     g 2 v 2 ( i ) + x 2 * v 5 ( i ) + k = 1 q S 1 m ( k ) r 1 , 2 ( k ) v 7 , k ( i ) h 2 v 4 ( i ) + x 2 * v 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) v 7 , k ( i ) .
By combining the above equations, we can derive the equation g A 1 h A 2 g 2 B 1 h 2 B 2 = 1 , where variables B 1 and B 2 are defined as follows
B 1 = m * ( s 2 * x 2 * a 1 c * ) z 2 + x 2 * z 5 + k = 1 q S 1 m ( k ) r 1 , 2 ( k ) z 7 , k   i = 2 n u 2 ( i ) + x 2 * u 5 ( i ) + k = 1 q S 1 m ( k ) r 1 , 2 ( k ) u 7 , k ( i ) ( m * a i c * )   i = 2 n v 2 ( i ) + x 2 * v 5 ( i ) + k = 1 q S 1 m ( k ) r 1 , 2 ( k ) v 7 , k ( i ) ( a i c * ) , B 2 = ( s 2 * x 2 * a 1 c * ) z 4 + x 2 * z 6 + k = 1 q S 1 r 1 , 2 ( k ) z 7 , k   i = 2 n u 4 ( i ) + x 2 * u 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) u 7 , k ( i ) ( m * a i c * )   i = 2 n v 4 ( i ) + x 2 * v 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) v 7 , k ( i ) ( a i c * ) .
Now, we analyze the conditions to satisfy B 2 0   mod   p . From Lemma 4, we know that x 2 * and { r 1 , 2 ( k ) } are statistically hidden to the adversary. To satisfy B 2 0   mod   p , the term x 2 * a 1 c * of B 2 that is not directly controlled by the adversary should be cancelled out. To analyze this, we consider the following three cases:
  • Case 1: Let B A D 1 be an event that x 2 * a 1 c * is cancelled by z 4 + x 2 * z 6 + k = 1 q S 1 r 1 , 2 ( k ) z 7 , k . Recall that the term z 4 + x 2 * z 6 + k = 1 q S 1 r 1 , 2 ( k ) z 7 , k is associated with the group element A R * . In the signing algorithm, c * is the output of a hash function H 2 that takes A R * as an input, and H 2 is modeled as a random oracle. Thus, c * is a random value independent of A R * by the property of the random oracle. This means that the probability of B A D 1 is at most 1 / p .
  • Case 2: Let B A D 2 be the event that x 2 * a 1 c * is cancelled by i = 2 n u 4 ( i ) + x 2 * u 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) u 7 , k ( i ) ( m * a i c * ) + i = 2 n v 4 ( i ) + x 2 * v 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) v 7 , k ( i ) ( a i c * ) . Recall that the terms u 4 ( i ) + x 2 * u 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) u 7 , k ( i ) and v 4 ( i ) + x 2 * v 6 ( i ) + k = 1 q S 1 r 1 , 2 ( k ) v 7 , k ( i ) are associated with the group elements X i and Y i , respectively. In the key aggregation algorithm, a 1 is the output of a hash function H 2 that takes L K = ( P K 1 , , P K n ) and P K i = ( P P , X i , Y i ) as inputs, and H 3 is modeled as a random oracle. Thus, a 1 is a random value independent of L K and P K i by the property of the random oracle. This means that the probability of B A D 2 is at most 1 / p .
  • Case 3: Let B A D 3 be the event that the term x 2 * a 1 c * is cancelled by s 2 * . Recall that the term s 2 * is the output of the adversary as the forged multi-signature and x 2 * is statistically hidden to the adversary. The only way to cancel out this term is for the adversary to construct a forged multi-signature by combining the simulated signatures { ( s 1 , 1 ( k ) , s 1 , 2 ( k ) ) } given from the second-round signature queries since the reduction algorithm simply constructs a partial signature s 2 ( k ) = r 1 , 2 ( k ) + x 2 * a 1 c ( k ) by using the hidden private key element x 2 * . In this case, the term ( s 2 * x 2 * a 1 c * ) additionally contains a statistically hidden random exponent r 1 , 2 ( k ) from the commitment R 1 ( k ) for some k. Thus, there should exist an index k { 1 , , q S 1 } such that z 7 , k 0   mod   p since A a l g is an algebraic adversary that submits a group element with a representation of group elements given to the adversary.
    From the conditions B 1 + dlog g ( h ) B 2 0   mod   p and B 2 0   mod   p of the Type-3 adversary, we have that B 1 B 2 0   mod   p . By combining B 1 and B 2 , we have the following equation
      B 1 + m * B 2   z 2 + x 2 * z 5 m * ( z 4 + x 2 * z 6 ) + k = 1 q S 1 ( m ( k ) m * ) r 1 , 2 ( k ) z 7 , k +     i = 2 n u 2 ( i ) + x 2 * u 5 ( i ) m * ( u 4 ( i ) + x 2 * u 6 ( i ) ) + k = 1 q S 1 ( m ( k ) m * ) r 1 , 2 ( k ) u 7 , k ( i ) ( m * a i c * ) +     i = 2 n v 2 ( i ) + x 2 * v 5 ( i ) m * ( v 4 ( i ) + x 2 * v 6 ( i ) ) + k = 1 q S 1 ( m ( k ) m * ) r 1 , 2 ( k ) v 7 , k ( i ) ( a i c * )   0   mod   p .
    Since z 7 , k 0   mod   p for some k and r 1 , 2 ( k ) is statistically hidden to the adversary, the above equation can be reshaped as a degree-one polynomial C 1 r 1 , 2 ( k ) + C 0 0   mod   p where a coefficient C 1 is expressed as
    C 1 = ( m ( k ) m * ) z 7 , k + i = 2 n u 7 , k ( i ) ( m * a i c * ) + i = 2 n v 7 , k ( i ) ( a i c * ) .
    By the Schwartz–Zippel lemma, the probability of the above polynomial to be zero is at most 1 / p if r 1 , 2 ( k ) is randomly selected and C 1 0   mod   p . By the restrictions of the security model 5, we have M * Q . The probability that m ( k ) m * 0   mod   p for some k when M * Q is bounded by q S 1 / p since H 1 is modeled as a random oracle. The probability that z 7 , k + i = 2 n u 7 , k ( i ) ( m * a i c * ) + i = 2 n v 7 , k ( i ) ( a i c * ) 0   mod   p is bounded by 1 / p since c * is the output of H 2 when A R * , X i , and Y i are given as inputs where z 7 , k , u 7 , k ( i ) , v 7 , k ( i ) are associated with A R * , X i , Y i , respectively. Thus, the probability that C 1 0   mod   p is bounded by ( q S 1 + 1 ) / p . This means that the probability of B A D 3 is at most ( q S 1 + 2 ) / p .
The success probability of the adversary is bounded by the probability of all bad events, and the probability of all bad events are bounded as
Pr [ B A D ] Pr [ B A D 1 ] + Pr [ B A D 2 ] + Pr [ B A D 3 ] ( q S 1 + 4 ) / p .
This completes our proof. □

3.4. Discussion

Multi-Signatures with Proofs of Possession. Our MS scheme requires 2 n exponentiations to aggregate the public keys of co-signers. As suggested by the previous studies [35], if public keys additionally include the proofs of possession of private keys, it is possible to simply aggregate all public keys of co-signers by multiplying these public keys without using expensive exponentiations. At this time, the security model that requires the proof of possession of a private key is a weaker model than the plain public-key model.
Synchronized Multi-Signature. If co-signers participating in multi-signature share the same information that is synchronized with each other, such as time or session count, it is possible for co-signers to create a commitment by using the synchronized information instead of using a message [31]. As an example, in the consensus protocol of a blockchain, the information of a previous block can be used as synchronization information. If such synchronized information exists, the signers can compute the commitment in advance and share it before a message to be signed is provided.

4. Performance Analysis

In this section, we analyze the public key and signature size of our MS scheme on a popular elliptic curve and estimate the performance of the algorithms of our MS scheme. To estimate the performance of basic operations in the elliptic curve, we use a laptop with Intel Core i7-1185G7 3.0 GHz CPU and 16.0 GB RAM running the Windows 11 operating system. That is, we first measure the performance of basic operations in the laptop and estimate the performance of the algorithms of our MS scheme based on this.
For the underlying elliptic curve, we choose secp256k1 used in Bitcoin because it allows for efficient computation compared to other elliptic curves and less possibility of backdoors. In this elliptic curve, the prime order p is 256 bits in size, the uncompressed generator g is 512 bits in size, and the compressed generator g is 257 bits in size. We use the secp256kfun library implemented in Rust language to measure the performance of group multiplication and exponentiation of the secp256k1 elliptic curve. Additionally, we use the sha2 library implemented in Rust language to measure the performance of a hash function. The details of the elliptic curve groups and the benchmark of basic operations are given in Table 2.
The asymptotic comparison of our MS scheme with other MS schemes is given in Table 3. For this comparison, we select the MuSig scheme of Maxwell et al. [3] since it is the first three-round MS scheme that supports key aggregation and the MuSig2 scheme of Nick et al. [16] since it is the most efficient two-round MS scheme with key aggregation. In our MS scheme, a public key PK consists of two elements in G and an aggregate key AK consists of two elements in G . A signing algorithm is a protocol in which multiple co-signers participate. A partial signature PS that must be transmitted to other co-signers consists of one element in G and two elements in Z p , and the final multi-signature MS consists of three elements in Z p . Thus, PK and AK are 66 bytes each, and MS is 96 bytes. In MuSig and MuSig2 schemes, a public key consists of one element in G and a multi-signature consists of one element in G and one element in Z p . Thus, PK and MS of the MuSig and MuSig2 schemes are 33 bytes and 65 bytes, respectively. Compared to other MS schemes, our MS scheme has a slightly larger size in the public key and multi-signature.
Our MS scheme consists of four main algorithms: GenKey, AggKey, Sign, and Verify. In Table 3, we analyze the approximate performance of these algorithms in terms of the number of co-signers and basic operations. In our MS scheme, the GenKey algorithm consists of 4 exponentiations, and the AggKey algorithm consists of 2 n exponentiations, 2 n multiplications, and n hashes, so the number of basic operations increases linearly depending on the number of co-signers. The Sign algorithm consists of 4 exponentiations and n multiplications, excluding the communication overhead between co-signers since the communication overhead varies depending on the network environment, and the Verify algorithm consists of 6 exponentiations. In this case, we assume that the aggregation key is given as an input to the Sign and Verify algorithms, so these algorithms do not calculate the aggregation key again.
In Table 4, we analyze how the performance of the algorithms of our MS scheme and the MuSig2 scheme change as the number of co-signers changes. To this end, we estimate the performance of these algorithms by combining the performance analysis of the basic operation in Table 2 and the algorithm analysis in Table 3. In our MS scheme, the estimated running time of the GenKey and Verify algorithms are 3.032 milliseconds and 4.548 milliseconds, respectively, since they are independent of the number of co-signers. The estimated running time of the AggKey algorithm that generates an aggregate key of co-signers increases in proportion to the number of co-signers, but it can be done within 1.525 s even for n = 1000 . Therefore, it is not a problem since the generated aggregate key can be reused again without needing to regenerate it. The estimated running time of the Sign algorithm is efficient because it takes 6.032 milliseconds even for n = 1000 , excluding the communication overhead between co-signers.

5. Conclusions

In this paper, we proposed a new PKS scheme and a two-round MS scheme by modifying the Okamoto signature scheme. In addition, we proved the unforgeability of these PKS and MS schemes under the discrete logarithm assumption in the AGM and the non-programmable ROM. Our proposed MS scheme is the first two-round MS scheme from Okamoto signatures. One drawback of our MS scheme is that the tight security reduction is proven in the AGM. Thus, it is an interesting problem to devise an efficient two-round MS scheme with tight security reduction without relying on the AGM.

Author Contributions

Conceptualization, K.L. and H.K.; methodology, K.L.; formal analysis, K.L. and H.K.; writing—original draft preparation, K.L. and H.K.; writing—review and editing, K.L.; project administration, K.L.; funding acquisition, K.L. All authors have read and agreed to the published version of the manuscript.

Funding

This work was supported by the Institute of Information & Communications Technology Planning & Evaluation (IITP) grant funded by the Korea government (MSIT) (No. 2021-0-00518, Blockchain privacy preserving techniques based on data encryption).

Data Availability Statement

Not applicable.

Conflicts of Interest

The authors declare no conflict of interest. The funders had no role in the design of the study; in the collection, analyses, or interpretation of data; in the writing of the manuscript, or in the decision to publish the results.

References

  1. Bellare, M.; Neven, G. Multi-signatures in the plain public-key model and a general forking lemma. In Proceedings of the ACM Conference on Computer and Communications Security, CCS 2006, Alexandria, VA, USA, 30 October–3 November 2006; Juels, A., Wright, R.N., di Vimercati, S.D.C., Eds.; ACM: New York, NY, USA, 2006; pp. 390–399. [Google Scholar]
  2. Boneh, D.; Drijvers, M.; Neven, G. Compact multi-signatures for smaller blockchains. In Advances in Cryptology—ASIACRYPT, Proceedings of the 24th International Conference on the Theory and Application of Cryptology and Information Security, Brisbane, QLD, Australia, 2–6 December 2018; Peyrin, T., Galbraith, S.D., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2018; Volume 11273, pp. 435–464. [Google Scholar]
  3. Maxwell, G.; Poelstra, A.; Seurin, Y.; Wuille, P. Simple Schnorr multi-signatures with applications to Bitcoin. Des. Codes Cryptogr. 2019, 87, 2139–2164. [Google Scholar] [CrossRef]
  4. Boldyreva, A. Threshold signatures, multisignatures and blind signatures based on the gap-Diffie-Hellman-group signature scheme. In Public-Key Cryptography—PKC 2003, Proceedings of the 6th International Workshop on Theory and Practice in Public Key Cryptography, Miami, FL, USA, 6–8 January 2003; Desmedt, Y., Ed.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 2003; Volume 2567, pp. 31–46. [Google Scholar]
  5. Lu, S.; Ostrovsky, R.; Sahai, A.; Shacham, H.; Waters, B. Sequential aggregate signatures and multisignatures without random oracles. In Advances in Cryptology—EUROCRYPT 2006, Proceedings of the 25th International Conference on the Theory and Applications of Cryptographic Techniques, St. Petersburg, Russia, 28 May–1 June 2006; Vaudenay, S., Ed.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 2006; Volume 4004, pp. 465–485. [Google Scholar]
  6. Boldyreva, A.; Gentry, C.; O’Neill, A.; Yum, D.H. Ordered Multisignatures and Identity-Based Sequential Aggregate Signatures, with Applications to Secure Routing. Cryptology ePrint Archive, Report 2007/438. 2010. Available online: http://eprint.iacr.org/2007/438 (accessed on 1 June 2023).
  7. Drijvers, M.; Gorbunov, S.; Neven, G.; Wee, H. Pixel: Multi-signatures for consensus. In Proceedings of the USENIX Security 2020, Boston, MA, USA, 12–14 August 2020; Capkun, S., Roesner, F., Eds.; USENIX Association: Berkeley, CA, USA, 2020; pp. 2093–2110. [Google Scholar]
  8. Fiat, A.; Shamir, A. How to prove yourself: Practical solutions to identification and signature problems. In Advances in Cryptology—CRYPTO’ 86, Proceedings of the 6th Annual International Cryptology Conference, Santa Barbara, CA, USA, 1986; Odlyzko, A.M., Ed.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 1986; Volume 263, pp. 186–194. [Google Scholar]
  9. Schnorr, C. Efficient signature generation by smart cards. J. Cryptol. 1991, 4, 161–174. [Google Scholar] [CrossRef] [Green Version]
  10. Bagherzandi, A.; Cheon, J.H.; Jarecki, S. Multisignatures secure under the discrete logarithm assumption and a generalized forking lemma. In Proceedings of the ACM Conference on Computer and Communications Security (CCS), Alexandria, VA, USA, 27–31 October 2008; Ning, P., Syverson, P.F., Jha, S., Eds.; ACM: New York, NY, USA, 2008; pp. 449–458. [Google Scholar]
  11. Ma, C.; Weng, J.; Li, Y.; Deng, R.H. Efficient discrete logarithm based multi-signature scheme in the plain public key model. Des. Codes Cryptogr. 2010, 54, 121–133. [Google Scholar] [CrossRef]
  12. Syta, E.; Tamas, I.; Visher, D.; Wolinsky, D.I.; Jovanovic, P.; Gasser, L.; Gailly, N.; Khoffi, I.; Ford, B. Keeping authorities “honest or bust” with decentralized witness cosigning. In Proceedings of the IEEE Symposium on Security and Privacy (SP), San Jose, CA, USA, 22–26 May 2016; IEEE Computer Society: Washington, DC, USA, 2016; pp. 526–545. [Google Scholar]
  13. Drijvers, M.; Edalatnejad, K.; Ford, B.; Kiltz, E.; Loss, J.; Neven, G.; Stepanovs, I. On the security of two-round multi-signatures. In Proceedings of the IEEE Symposium on Security and Privacy (SP), San Francisco, CA, USA, 19–23 May 2019; pp. 1084–1101. [Google Scholar]
  14. Nick, J.; Ruffing, T.; Seurin, Y.; Wuille, P. MuSig-DN: Schnorr multi-signatures with verifiably deterministic nonces. In Proceedings of the ACM Conference on Computer and Communications Security (CCS ‘20), Online, 9–13 November 2020; Ligatti, J., Ou, X., Katz, J., Vigna, G., Eds.; ACM: New York, NY, USA, 2020; pp. 1717–1731. [Google Scholar]
  15. Alper, H.K.; Burdges, J. Two-round trip Schnorr multi-signatures via delinearized witnesses. In Advances in Cryptology—CRYPTO 2021; Malkin, T., Peikert, C., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2021; Volume 12825, pp. 157–188. [Google Scholar]
  16. Nick, J.; Ruffing, T.; Seurin, Y. MuSig2: Simple two-round Schnorr multi-signatures. In Advances in Cryptology—CRYPTO 2021, Proceedings of the 41st Annual International Cryptology Conference, Online, 16–20 August 2021; Malkin, T., Peikert, C., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2021; Volume 12825, pp. 189–221. [Google Scholar]
  17. Bellare, M.; Dai, W. Chain reductions for multi-signatures and the HBMS scheme. In Advances in Cryptology—ASIACRYPT 2021, Proceedings of the 27th International Conference on the Theory and Application of Cryptology and Information Security, Singapore, 6–10 December 2021; Tibouchi, M., Wang, H., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2021; Volume 13093, pp. 650–678. [Google Scholar]
  18. Okamoto, T. Provably secure and practical identification schemes and corresponding signature schemes. In Advances in Cryptology—CRYPTO’ 92, Proceedings of the 12th Annual International Cryptology Conference, Santa Barbara, CA, USA, 16–20 August 1992; Brickell, E.F., Ed.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 1992; Volume 740, pp. 31–53. [Google Scholar]
  19. Gennaro, R.; Goldfeder, S.; Narayanan, A. Threshold-optimal DSA/ECDSA signatures and an application to Bitcoin wallet security. In Applied Cryptography and Network Security, Proceedings of the 14th International Conference (ACNS 2016), Guildford, UK, 19–22 June 2016; Manulis, M., Sadeghi, A., Schneider, S.A., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2016; Volume 9696, pp. 156–174. [Google Scholar]
  20. Lindell, Y. Fast secure two-party ECDSA signing. In Advances in Cryptology—CRYPTO 2017, Proceedings of the 37th Annual International Cryptology Conference, Santa Barbara, CA, USA, 20–24 August 2017; Katz, J., Shacham, H., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2017; Volume 10402, pp. 613–644. [Google Scholar]
  21. Gennaro, R.; Goldfeder, S. Fast multiparty threshold ECDSA with fast trustless setup. In Proceedings of the ACM Conference on Computer and Communications Security (CCS), Toronto, ON, Canada, 15–19 October 2018; Lie, D., Mannan, M., Backes, M., Wang, X., Eds.; ACM: New York, NY, USA, 2018; pp. 1179–1194. [Google Scholar]
  22. Lindell, Y.; Nof, A. Fast secure multiparty ECDSA with practical distributed key generation and applications to cryptocurrency custody. In Proceedings of the ACM Conference on Computer and Communications Security (CCS), Toronto, ON, Canada, 15–19 October 2018; Lie, D., Mannan, M., Backes, M., Wang, X., Eds.; ACM: New York, NY, USA, 2018; pp. 1837–1854. [Google Scholar]
  23. Komlo, C.; Goldberg, I. FROST: Flexible round-optimized Schnorr threshold signatures. In Selected Areas in Cryptography, Proceedings of the 27th International Conference (SAC 2020), Halifax, NS, Canada, 21–23 October 2020; Dunkelman, O., Jacobson, M.J., Jr., O’Flynn, C., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2020; Volume 12804, pp. 34–65. [Google Scholar]
  24. Crites, E.; Komlo, C.; Maller, M. How to Prove Schnorr Assuming Schnorr: Security of Multi- and Threshold Signatures. Cryptology ePrint Archive, Paper 2021/1375. 2021. Available online: https://eprint.iacr.org/2021/1375 (accessed on 1 June 2023).
  25. Bellare, M.; Crites, E.C.; Komlo, C.; Maller, M.; Tessaro, S.; Zhu, C. Better than advertised security for non-interactive threshold signatures. In Advances in Cryptology—CRYPTO 2022, Proceedings of the 42nd Annual International Cryptology Conference, CRYPTO 2022, Santa Barbara, CA, USA, 15–18 August 2022; Dodis, Y., Shrimpton, T., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2022; Volume 13510, pp. 517–550. [Google Scholar]
  26. Gennaro, R.; Jarecki, S.; Krawczyk, H.; Rabin, T. Secure distributed key generation for discrete-log based cryptosystems. J. Cryptol. 2007, 20, 51–83. [Google Scholar] [CrossRef]
  27. Gurkan, K.; Jovanovic, P.; Maller, M.; Meiklejohn, S.; Stern, G.; Tomescu, A. Aggregatable distributed key generation. In Advances in Cryptology—EUROCRYPT 2021, Proceedings of the 40th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Zagreb, Croatia, 17–21 October 2021; Canteaut, A., Standaert, F., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2021; Volume 12696, pp. 147–176. [Google Scholar]
  28. Groth, J. Non-Interactive Distributed Key Generation and Key Resharing. Cryptology ePrint Archive, Paper 2021/339. 2021. Available online: https://eprint.iacr.org/2021/339 (accessed on 1 June 2023).
  29. Boneh, D.; Gentry, C.; Lynn, B.; Shacham, H. Aggregate and verifiably encrypted signatures from bilinear maps. In Advances in Cryptology—EUROCRYPT 2003, Proceedings of the International Conference on the Theory and Applications of Cryptographic Techniques, Warsaw, Poland, 4–8 May 2003; Biham, E., Ed.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2003; Volume 2656, pp. 416–432. [Google Scholar]
  30. Lysyanskaya, A.; Micali, S.; Reyzin, L.; Shacham, H. Sequential aggregate signatures from trapdoor permutations. In Advances in Cryptology—EUROCRYPT 2004, Proceedings of the International Conference on the Theory and Applications of Cryptographic Techniques, Interlaken, Switzerland, 2–6 May 2004; Cachin, C., Camenisch, J., Eds.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 2004; Volume 3027, pp. 74–90. [Google Scholar]
  31. Gentry, C.; Ramzan, Z. Identity-based aggregate signatures. In Public-Key Cryptography—PKC 2006, Proceedings of the 9th International Conference on Theory and Practice in Public-Key Cryptography, New York, NY, USA, 24–26 April 2006; Yung, M., Dodis, Y., Kiayias, A., Malkin, T., Eds.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 2006; Volume 3958, pp. 257–273. [Google Scholar]
  32. Tessaro, S.; Zhu, C. Threshold and multi-signature schemes from linear hash functions. In Advances in Cryptology—EUROCRYPT 2023, Proceedings of the 42nd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Lyon, France, 23–27 April 2023; Hazay, C., Stam, M., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2023; Volume 14008, pp. 628–658. [Google Scholar]
  33. Fuchsbauer, G.; Kiltz, E.; Loss, J. The algebraic group model and its applications. In Advances in Cryptology—CRYPTO 2018, Proceedings of the 38th Annual International Cryptology Conference, Santa Barbara, CA, USA, 19–23 August 2018; Shacham, H., Boldyreva, A., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2018; Volume 10992, pp. 33–62. [Google Scholar]
  34. Schwartz, J.T. Fast probabilistic algorithms for verification of polynomial identities. J. ACM 1980, 27, 701–717. [Google Scholar] [CrossRef] [Green Version]
  35. Ristenpart, T.; Yilek, S. The power of proofs-of-possession: Securing multiparty signatures against rogue-key attacks. In Advances in Cryptology—EUROCRYPT 2007, Proceedings of the 26th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Barcelona, Spain, 20–24 May 2007; Naor, M., Ed.; Lecture Notes in Computer Science; Springer: Berlin/Heidelberg, Germany, 2007; Volume 4515, pp. 228–245. [Google Scholar]
Table 1. Comparison of Fiat–Shamir-based multi-signature schemes.
Table 1. Comparison of Fiat–Shamir-based multi-signature schemes.
SchemeRN, KAPKMSSignVerifySecurity
BN [1]3, N G G + Z p 1E ( n + 1 ) EDL, ROM
3, N2 G 2 G + Z p 2E 2 ( n + 1 ) EDDH, ROM
MuSig [3]3, Y G G + Z p 1E2EDL, ROM
mBCJ [13]2, N G + 2 Z p 2 G + 3 Z p 5E6EDL, ROM
MuSig-DN [14]2, Y G G + Z p NIZK2EDL, DDH, ZK,
PRF, ROM
MuSig2 [16]2, Y G G + Z p 8E2EAOMDL, ROM
2, Y G G + Z p 4E2EAOMDL,
AGM + ROM
DWMS [15]2, Y G G + Z p ( 2 n + 2 ) E2EOMDL + 2ES,
AGM + ROM
HBMS [17]2, Y G G + 2 Z p 2E3EXIDL, ROM or
DL, AGM + ROM
Ours2, Y2 G 3 Z p 4E6EDL, AGM + ROM
Let n be the number of co-signers. We denote RN for the number of rounds, KA for key aggregation, PK for public key, and MS for multi-signature. We use E for exponentiation and NIZK for zero-knowledge proof.
Table 2. Elliptic curve group sizes and basic operations.
Table 2. Elliptic curve group sizes and basic operations.
Curve Z p G MEH
secp256k1256-bit257-bit0.0030.7580.003
We use M for multiplication, E for exponentiation, and H for sha256 hash. All operations are measured in milliseconds.
Table 3. Key size, signature size, and algorithm analysis of MS schemes.
Table 3. Key size, signature size, and algorithm analysis of MS schemes.
SchemePKAKPSMSGenKeyAggKeySignVerify
MuSig [3] G G G + 2 Z p G + Z p 1EnE + nM + nH1E + nM2E
MuSig2 [16] G G 2 G + Z p G + Z p 1EnE + nM + nH4E + nM2E
Ours2 G 2 G G + 2 Z p 3 Z p 4E 2 n E + 2 n M + nH4E + nM6E
Let n be the number of co-signers. We denote PK for public key, AK for aggregated key, PS for partial signature of a co-signer in the signing process, and MS for multi-signature. We use symbols M for multiplication, E for exponentiation, and H for hash.
Table 4. Estimated algorithm performance analysis of MS schemes.
Table 4. Estimated algorithm performance analysis of MS schemes.
SchemeCo-Signers n20501002005001000
MuSig2 [16]GenKey0.7580.7580.7580.7580.7580.758
AggKey15.2838.276.4152.8382764
Sign3.0923.1823.3323.6324.5326.032
Verify1.5161.5161.5161.5161.5161.516
OursGenKey3.0323.0323.0323.0323.0323.032
AggKey30.576.25152.5305762.51525
Sign3.0923.1823.3323.6324.5326.032
Verify4.5484.5484.5484.5484.5484.548
Let n be the number of co-signers. We estimate the performance in milliseconds.
Disclaimer/Publisher’s Note: The statements, opinions and data contained in all publications are solely those of the individual author(s) and contributor(s) and not of MDPI and/or the editor(s). MDPI and/or the editor(s) disclaim responsibility for any injury to people or property resulting from any ideas, methods, instructions or products referred to in the content.

Share and Cite

MDPI and ACS Style

Lee, K.; Kim, H. Two-Round Multi-Signatures from Okamoto Signatures. Mathematics 2023, 11, 3223. https://doi.org/10.3390/math11143223

AMA Style

Lee K, Kim H. Two-Round Multi-Signatures from Okamoto Signatures. Mathematics. 2023; 11(14):3223. https://doi.org/10.3390/math11143223

Chicago/Turabian Style

Lee, Kwangsu, and Hyoseung Kim. 2023. "Two-Round Multi-Signatures from Okamoto Signatures" Mathematics 11, no. 14: 3223. https://doi.org/10.3390/math11143223

Note that from the first issue of 2016, this journal uses article numbers instead of page numbers. See further details here.

Article Metrics

Back to TopTop