# Herranz & Saèz Generic Ring Signature

## 1. Introduction

In the next 4 parts of this series, we look at various ring signature schemes and prove their security in the RO model. This part is dedicated to the analysis of a generic class of ring signature schemes introduced in [1] and inspired by [2]. We also introduce a specific instance of the generic scheme which is itself a generalization of the non-interactive Schnorr signature.

## 2. Herranz & Saèz generic scheme

The scheme is built on a security parameter , which by design corresponds to the length in bits of the output of the random oracle . Given a message and a ring of members, the signing algorithm outputs a signature where:

• The ‘s are pairwise-different random elements chosen from a pre-defined large set. The term pairwise-different means that , .
• . That means that is the RO’s output on query .
• is fully determined by , and , for all .

By design, we require that the probability of selecting any particular be upper-bounded by . For example, consider the finite field over a large prime . The probability of choosing a particular value for in the mutiplicative cyclic group is equal to (assuming a uniform distribution over ). Clearly, this is less than or equal to .

## 3. Security analysis – Unforgeability vis-a-vis EFACM

For unforgeability proofs, we follow the 5-step approach mentioned in part 1 of this series.

Step 1: To prove that this generic scheme is secure against EFACM in the RO model, we proceed by contradiction and assume that there exists a PPT adversary such that:

( non-negligible in k).

Step 2: Next, we build a simulator such that it:

• Does not have access to the private key of any signer.
• Has the same range as the original signing algorithm (i.e., they output signatures taken from the same pool of potential signatures over all possible choices of RO functions and respective random tapes and ).
• Has indistinguishable probability distribution from that of over this range.

is specific to the particular instance of the generic scheme being used. In what follows, we build a simulator for the case of a Schnorr ring signature.

The Schnorr ring signature scheme is built on the finite field . Here is a large prime number and is the security parameter as described earlier. We let be a generator of the multiplicative cyclic group . We also let be a ring of members where has an associated key-pair given by (, ). The Schnorr ring signature scheme is defined as a set of 3 algorithms:

• The key generation algorithm . On input , it produces a pair of matching secret and public keys. The algorithm is modeled as a PPT Turing machine.
• The ring signing algorithm . Suppose a user decides to sign a message on behalf of the ring of users . proceeds as follows:
1. , choose pairwise different ‘s at random in . Assign . Set .
2. Choose a random . Assign . If s.t. and , then pick a different . Set .
3. Compute

finally outputs a signature . The algorithm is modeled as a PPT Turing machine.

• The ring verification algorithm . Given a ring signature , a message , the set of public keys of the ring members, verifies the validity of by checking the following:
1. (Verification equations to ): , for
2. (Verification equation ):

is a deterministic algorithm as opposed to probabilistic.

Note that this scheme satisifies the correctness property. That means that any signature generated by will satisfy the verification equations with overwhelming probability. To see why, let be a signature issued by user on message and ring of size . By construction, we automatically have . The first verification equations are thus met. Moreover,

, (by definition of in )

(since by construction, for , and ).

Finally, note that also mandates that and so . Hence, . The last verification equation is thus met.

We can now build a simulator specific to the Schnorr ring signature scheme:

By construction, the output of will satisfy the verification equations. Moreover, it assigns a random value for each and bypasses the RO in doing so. Next, note the following:

1. does not use any private key.
2. and both have a range such that

3. and have the same probability distribution over . Indeed, we have:
• For

The first factor is the probability of choosing the exact values given by the ‘s that are pairwise different. The second factor is the probability of choosing the exact values given by the ‘s .

• For :

The first factor is the probability of choosing the exact values given by the ‘s that are pairwise different. Note that in the above, is also an element of that is different than all the other ‘s. The second factor is the probability of choosing the exact values given by the ‘s .

With adequately built for the Schnorr ring signature scheme, we conclude that (refer to section 6 of part 1 of this series for a justification):

, for some non-negligible in k.

Step 3: We now show that the probability of faulty collisions is negligible (refer to section 6 of part 1 for a description of collision types). The 2 tyes of collisions fo the generic scheme are:

• : A tuple that encounters — recall that makes its own random assignment to and bypasses RO — also appears in the list of queries that sends to RO. A conflict in the 2 values will happen with overwhelming probability and the execution will halt.
• : A tuple that encounters — recall that makes its own random assignment to — is the same as another tuple that encountered at an earlier time instance — here too, would have made its own random assignment to . Since the 2 tuples are identical (i.e., ), it must be that the 2 random assignments match (i.e., . However, the 2 values will be different with overwhelming probability and the execution will halt.

The aforementioned collisions must be avoided. In order to do so, we first calculate the probability of their occurence. We assume that during an EFACM attack, can make a maximum of queries to RO and a maximum of queries to . and are both assumed to be polynomial in the security parameter , since the adversary is modeled as a PPT Turing machine.

Note that the query (and any query in general) to includes an assignment of random values of the form for . This is in contrast to the Schnorr signature scheme that we encountered in part 2 of the series, and where the query to consisted of a single assignment of the form . So we get:

Since and are polynomial in , we conclude that is negligible in .

Next, we compute:

Recall that the query (and any query in general) to includes an assignment of random values of the form for . Note that by construction of , all the ‘s corresponding to the random assignments are pairwise-different and hence distinct from each-other. So in order for a certain value to appear twice, it must be part of 2 different queries to We can choose the 2 queries in ways. And for each one of these 2 queries, the value can appear in any one of the assignments. So we get:

And so is also negligible in .

Putting it altogether, we find:

which is negligible in k. We can finally conclude (as per section 6 of part 1), that:

(non-negligible in )

Step 4: In this step, our objective is to show that if is a successful tuple that generated a first EFACM forgery, then the following quantity is non-negligible in :

Here is an appropriate index that we will define in the proof. To further simplify the notation, we let and for all . ( and denote respectively the query to RO and RO ).

Let’s take a closer look at

Any successful forgery must satisfy the verification equations. The first verification equations check if for all . And so we distinguish between 2 scenarios (w.l.o.g. we assume that all -queries sent to RO are distinct from each-other since can keep a local copy of previous query results and avoid redundant calls):

• Scenario 1: was successful in its forgery, and no collisions occured, and such that it never queried RO on input .
• Scenario 2: was successful in its forgery, and no collisions occured, and it queried RO on input during its execution.

Given a certain , the probability of scenario 1 is upperbounded by the probability that picks a value for that matches the value of . Here, is the value that RO returns to (the verification algorithm) when verifying the validity of the forged signature. (It is upper-bounded because at the very least, the constraint must be observed for a valid signature). And since can be any value in , we get:

(negligible in )

So we assume that a successful forgery will likely be of the Scenario 2 type. We have:

(non-negligible in )

By definition of scenario 2, we know for a fact that , there exists an integer such that is the index of the query to RO. (Recall that represents the total number of queries that sends to RO). We define to be the vector of indices corresponding to the queries that sends to RO during execution. Note that since we requested by definition that all the ‘s be distinct, then so will the ‘s. By convention, if a certain is not queried to RO, we let its corresponding . This definition allows us to build the following sets:

• In other terms, is the set of tuples that yield a successful EFACM forgery when no collisions occur, and when queried RO on all inputs (i.e., scenario 2).

• where

We let denote that the cardinality of . We have:

We can see that represents the set of tuples that yield a successful EFACM forgery when no collisions occur, and when queried RO on all inputs , such that the index of the input query is equal to (i.e., the component of ).

Recall that, , which is non-negligible in .

Clearly, the partition . So:

This implies that:

If this were not the case, then one would get the following contradiction:

So we introduce the set consisting of all vectors that meet the threshold, i.e.

We claim that .

Proof: By definition of the sets we have:

The next step is to apply the splitting lemma to each . First note that:

Let . Referring to the notation used in the splitting lemma (section 7 of part 1), we let:

, , , , and

is defined as the space of tuples of all random tapes , all random tapes , and all possibe RO answers to the first queries sent by . is defined as the space of all possible RO answers to the last queries sent by . (Recall that . The splitting lemma guarantees the existence of a subset of tuples such that:

• , we have

, and so:

We would like to compute the probability of finding a successful tuple given that was a successful tuple and such that .

That means finding the following probability:

From the splitting lemma results, we have a (non-negligible in ) lower-bound on

Note however, that and are generally distinct sets. And so we cannot conclude that

and therefore we cannot conclude that the following is non-negligible in

In order to show that the above quantity is non-negligible in , we proceed differently. Suppose we can show that the following probability is non-negligible in :

This would imply that with non-negligible probability, we can find a tuple that belongs to (and hence corresponds to a successful forgery) and at the same time belongs to . We can then invoke the splitting lemma result just mentioned, to find a second tuple coresponding to a second forgery and that has the desired properties.

To prove the above, we proceed as follows:

, since the ‘s are disjoint

, ( result of splitting lemma above)

(by the claim proven earlier) .

And so we conclude that:

, which is non-negligible in .

So let be such an index and such a tuple. From the result above, we know that finding such a can be done with non-negligible probability. And since , we must have . We can then invoke the consequence of the splitting lemma, and write:

We still have one last constraint to impose and that is that . We show that the following quantity is non-negligible:

To prove this, note that if and are independent events, then we can write:

And so we get . This results allows us to write:

, (because we chose

(non-negligible in )

Step 5: The final step uses the 2 forgeries obtained earlier to solve an instance of the Discrete Logarithm (DL) problem. Here is a recap of Step 4 results:

• With non-negligible probability of at least we get a successful tuple , s.t. for some vector of indices . So by running a number of times polynomial in , we can confidently find such a tuple.
• Once we find such a tuple, we’ve also shown that with non-negligible probability of at least , we can find another successful tuple such that and , but .

Without loss of generality, let
correspond to , and
correspond to .

Recall that is the vector where denotes the index of query that sends to the RO. Since the 2 experiments corresponding to the 2 successful tuples have the same random tapes and , and since the 2 corresponding ROs and behave the same way on the first queries (recall that , we can be confident that:

• The first queries sent to the 2 ROs are identical. In particular, we have .
• The first () replies of the 2 oracles and are the same. Suppose w.l.o.g. that , (where ), corresponds to the last query of this type that is sent to the ROs. is actually the query sent to RO (by definition of ). We then have

So we have 2 successful forgeries and , with . Since both are valid signatures, they must satisfy the verification equations. For the particular case of a Schnorr ring signature, they must satisfy the following 2 equations (1 equation per signature):

• , where is the set of public keys of the ring members associated with the signature.
• , where is the set of public keys of the ring members associated with the signature.

Writing ( is the secret key corresponding to ), we get:

Since, , we can solve for (the DL of ) in polynomial time. This contradicts the intractability of DL on multiplicative cyclic groups and we conclude that our signature scheme (in this case the Schnorr ring signature scheme) is secure against EFACM in the RO model.

## 4. Security analysis – Anonymity

In this section, we show that our generic scheme satisfies the anonymity definition #1 introduced in part 3 of this series. Recall that roughly speaking, this definition mandates that the probability of guessing the real signer be (in an -ring setting). This probability is independent of any knowledge about any member’s private key. In other terms, even if a signer is coerced or subpoenaed to release her private key, nothing can be done to prove that she is the real signer (with probability better than random guessing).

To prove anonymity in our case, we show that any signature could have been created with equal probability by any of the members of the ring. We show that releasing information about the secret key of any ring member does not modify this probability. That automatically implies that even when a subset of private keys gets compromised, there is still an equiprobable likelihood that the signature was created by any member.

Proof: Let be a valid signature on message and ring . That means that all verification equations are satisfied. Let be any member of the ring (with compromised or non-compromised secret key The probability that was issued by is given by:

Note that once the ‘s are calculated, the ‘s will be automatically determined since we are using a specific hash function. Clearly, the above probability does not depend on any specific information about member . It is the same for all ring members.

## References

[1] J. Herranz and G. Saez. Forking lemmas in the ring signatures’ scenario. Proceedings of INDOCRYPT’03, Lecture Notes in Computer Science(2904):266{279, 2003.

[2] D. Pointcheval and J. Stern. Security arguments for digital signatures and blind signatures. Journal of Cryptology, 2000.