A Hash-Based Quantum-Resistant Chameleon Signature Scheme

As a standard digital signature may be verified by anybody, it is unsuitable for personal or economically sensitive applications. The chameleon signature system was presented by Krawczyk and Rabin as a solution to this problem. It is based on a hash then sign model. The chameleon hash function enables the trapdoor information holder to compute a message digest collision. The holder of a chameleon signature is the recipient of a chameleon signature. He could compute collision on the hash value using the trapdoor information. This keeps the recipient from disclosing his conviction to a third party and ensures the privacy of the signature. The majority of the extant chameleon signature methods are built on the computationally infeasible number theory problems, like integer factorization and discrete log. Unfortunately, the construction of quantum computers would be rendered insecure to those schemes. This creates a solid requirement for construct chameleon signatures for the quantum world. Hence, this paper proposes a novel quantum secure chameleon signature scheme based on hash functions. As a hash-based cryptosystem is an essential candidate of a post-quantum cryptosystem, the proposed hash-based chameleon signature scheme would be a promising alternative to the number of theoretic-based methods. Furthermore, the proposed method is key exposure-free and satisfies the security requirements such as semantic security, non-transferability, and unforgeability.


Introduction
An ordinary digital signature is not suitable for all applications that are personally or commercially sensitive. Consider the scenario where a software company issues a license of the software to the customer. When the company embeds an ordinary signature into its product to assure the customer Alice that the vendor provides the software, Alice can make several copies of the software and sell them at a lower price. She can prove that the software is from the vendor by presenting the vendor's signature on the product. A privacy-protecting signature can be embedded in the product by protecting the company's reputation and assuring the customer of having quality software. Though undeniable signature [1] proposed by Chaum et al. provides controlled dissemination of signature, a group of verifiers can verify it simultaneously, without telling the prover that he is proving the signature to too many people. This is done by setting the challenge collectively so that no subset of the verifiers could set the challenge on their own. To overcome the above-mentioned limitations of undeniable signature, Krawczyk & Rabin introduced chameleon signature [2], which prevents the dissemination of signed information by the recipient of the signature. It also preserves the non-repudiation property in the event of legal disputes.
Though undeniable signature and chameleon signature both provide non-transferability and non-repudiation, the former requires an interactive protocol between the signer and the verifier for the purpose of verifying the signature, which is based on zero-knowledge proof. It is quite natural that such additional properties and techniques increase the complexity of undeniable signature relative to ordinary signature in terms of computational and communication costs. As the chameleon signature scheme is non-interactive, it does not require the zero-knowledge paradigm, and hence its computational complexity is less compared to the undeniable signature scheme. Like an ordinary digital signature scheme, the chameleon signature scheme is constructed with the basic approach of the hash-and-sign paradigm. First, the message digest is computed using a special hash function called chameleon hash function, which uses the public key of the recipient of the signature. Like a cryptographic hash function, it provides collision resistance except for the trapdoor holder (recipient) of the public key. As a result, finding collisions to chameleon hash value is computationally infeasible even for the signer who produces the hash value, but it is feasible for the recipient to compute collisions using his trapdoor key. When a recipient receives a chameleon signature on a message, through collision finding, the recipient is able to produce different messages for the same signing value as the original one. Thus, the underlying chameleon hash function allows the recipient to forge the signature generated by the signer. The signatures generated by the signer and by the recipient are indistinguishable. This ability of the recipient to forge an indistinguishable signature prevents him from revealing the validity of the original signature made by the signer to a third party. Thus, the chameleon hash function is non-transferable. However, in the case of disputes, the signer can easily prove that the contested signature by the recipient is a forgery by producing a message-signature pair that has the same hash value as that of the contested message-signature pair. As the signer cannot compute a collision, the message-signature pair produced by the signer is taken as original, while the contested signature is considered forgery. The early designs of chameleon signature schemes are key-exposure, i.e., collisions that reveal the recipient's secret key. Because the key is exposed, the recipient is unable to use the signature scheme. Calculating hash collisions, putting the principle of non-transferability to the test. As a result, the major key exposure concern, as well as its related issues such as revocation and redistribution of keys, must be addressed. Henceforth, a key-exposure-free chameleon hash is proposed in a graph setting. It uses a double trapdoor mechanism. The proposed chameleon hash system is used to create a chameleon signature scheme. The non-transferability of the signature thus produced is simply achieved from the underlying chameleon hash.

Related Work
Krawczyk & Rabin proposed the first chameleon signature scheme in [2]. It suffers from a key exposure problem which means that, when the recipient does forgery through collision computation, the signer can easily retrieve the recipient's secret key. This creates a strong disincentive for the recipient to forge chameleon signatures which partially undermines the concept of non-transferability. Zhang et al. presented chameleon hash schemes in an ID-based setting in [3]. The proposed two schemes from bilinear pairings are not keyexposure-free. Ateniese & de Medeiros in [4] identified that the problem of key exposure on forgeries threatened the claim of non-transferability and provided a solution to the problem through an identity-based chameleon hash function. In their scheme, the signature forgery by the recipient results in the recovery of the recipient's trapdoor information associated with that single transaction by the signer. However, in other transactions, the signer could not be able deny the signature on any message. Thus, the authors provide a solution but do not solve the problem of key exposure completely. To overcome this drawback, Chen et al. proposed the first complete key-exposure free chameleon hash function in the gap Diffie-Hellman group with bilinear pairings [5].
In [4], Ateniese & de Medeiros introduced three nonpairing based key exposure-free systems, two of which are based on Integer Factorisation Problem (IFP) and one on Diffie-Hellman and the Discrete Logarithm Problem (DLP). Gao et al. developed a factoringbased chameleon hash function [6] and demonstrated its security by using a modified Rabin signature technique. Later, Gao et al. introduced a DLP-based key-exposure free chameleon hash function [6]. They modified the basic construction of the chameleon hash method [2] to allow a multi-trapdoor by considering the hash algorithm as a one-round protocol that runs between the signer and the specified recipient. This architecture differs slightly from Krawczyk & Rabin's original concept of chameleon hash. Later, Chen et al. suggested a DLP-based key-exposure-free chameleon hash and signature system that did not need the gap Diffie-Hellman groups [7]. Pan et al. proposed a family of chameleon hash functions and strongly unforgeable one-time signature schemes based on DLP over inner automorphism groups [8].
Integer factorization and discrete logarithm problems provide a secure basis for the above schemes and are threatened by quantum computers by Shor's algorithm [9]. Therefore, it is necessary to come up with alternative schemes that resist quantum computer attacks. Although quantum computers are currently in their infancy [10,11], the ongoing development of quantum computers and their theoretical ability to compromise modern cryptographic schemes has prompted the development of post-quantum cryptographic schemes. A cryptographic technique connected with a computational problem that cannot be solved in polynomial time on a quantum computer is currently referred to as postquantum security. This includes the fact that addressing the problem on a traditional computer is impossible. Because lattice-based signatures are thought to be secure against quantum computers, they have become fascinating alternatives to the current techniques, such as RSA, ECDSA, and others. Several lattice-based cryptographic signature techniques have been proposed since Ajtai's original work [12]. In hard random lattices, Xie et al. suggested a homomorphic chameleon function based on the Small Integer Solution (SIS) problem [13].
Other promising post-quantum signature schemes are hash-based signature schemes. Hash functions are sufficient to have an efficient and a secure transmission of data. As hash functions are one-way, hash-based signatures provide certain advantages over digital signatures based on trapdoor functions. The following are the advantages of hash-based signatures: they require less security assumptions than number-theoretic signature schemes, they are very efficient, and their security is well understood. The generic attacks on hash function and pseudorandom generator determine the security parameter. The minimum security parameter recommended is determined by the security level of preimage and collision resistance of the hash function. When classical computers are used, then finding a preimage of the hash function H : {0, 1} 2k → {0, 1} k by exhaustive search costs 2 k/2 and finding a collision by birthday attack costs 2 k/2 . However, when quantum computers are used, the Grover algorithm [14] requires 2 k/3 evaluations of the hash function to find a collision and requires 2 k/3 searches to find a preimage of H. For a pseudorandom generator PG : {0, 1} k → {0, 1} 2k , the attacker tries to find the patterns in the inputs example by guessing the PG seed that ends up at a target value after a number of rounds of the chaining function. All generic attacks again cost 2 k in pre-quantum and 2 k/2 in post-quantum.
Chen [15] proposed a PDP protocol which consists of an algebraic signature that uses a hash function with homomorphic property. It is shown that the homomorphic hash function enables fast and efficient retrieval of content and provides provable data possession and data integrity protection in cloud storage. Hence, this paper proposes a simple construction of a chameleon hash scheme under graph setting with minimal requirements such as homomorphic hash function and homomorphic pseudorandom generator and without complex algebraic computation. The security of the chameleon hash scheme relies on the Preimage Resistance (PR) of the hash function. The chameleon signature scheme constructed with the proposed chameleon hash scheme easily achieves the non-transferability property. In addition, the method obtains the unforgeability property directly from the unforgeability of the underlying signature scheme used.
The paper is organized as below: Section 3 contains a brief description of basic concepts of graph theory, the outline of a chameleon hash and signature scheme, and its security model. Section 4 proposes an efficient hash-based chameleon hash and signature scheme with DAG, and Section 5 presents an algorithm for the construction of a DAG. Section 6 presents the security analysis of the proposed method, and Section 7 discusses the performance analysis and comparison. Finally, Section 8 concludes the paper.

Preliminaries
In this section, few graph preliminaries [16] that are required for the proposed scheme and definitions and properties of chameleon hashing and signatures are briefed.

Definition 1. Directed graph:
It is an ordered pair G = (V, E) where V is a finite set of elements called vertices and E is a set of ordered pairs of vertices called directed edges.

Definition 2. Degree:
In a directed graph, indegree of a vertex v is the number of edges (u, v) ∈ E which are pointing to the vertex v. Outdegree of a vertex v is the number of edges (v, u) ∈ E which are coming from the vertex v. The sum of indegree and outdegree is the total degree of v.
In a directed graph, the vertices with indegree zero are called source vertices and the vertices with outdegree zero are called sink vertices. The vertices which are neither sources nor sinks are called internal vertices.
Its length is the number of occurrences of edges in it. For simplicity, only DAGs which have a single source s with outdegree 1, a single sink t with indegree 1, and n > 0 internal vertices where each vertex that has a total degree of 3 is considered. Such graphs have only two types of internal vertices, namely expansion vertices and compression vertices. Expansion vertices are vertices with indegree 1 and outdegree 2, and compression vertices are those with indegree 2 and outdegree 1. A DAG G with n internal vertices where n is even will have n/2 expansion vertices and n/2 compression vertices. This particular type of DAG is considered throughout the paper. Definition 6. Cut; In a DAG G = (V, E) with a source edge e s and a sink edge e t , a cut is defined as a nontrivial partition W = (U, V \ U) of the vertices such that e s is in the edge set of U and e t is in the edge set of V \ U. A cut is represented by a single set of vertices U with the convention that e s ∈ U. Definition 7. Cross edge: A cross edge e = (u, v) of a cut W = (U, V \ U) is defined as an edge in which u ∈ U and v ∈ V \ U. The set of edges crossing W is denoted as (W). Definition 10. Antichain: A subset U ⊆ P is called an antichain if every pair of elements of U is incomparable. The maximal cardinality of antichains in P is called the width of a poset (P, ), and it is denoted by w(P). Definition 11. Allowable set: Let T be a set of edges in G. The set of directly computable nodes is defined as the set of nodes all of whose incoming arcs are in T. The set of computable nodes is defined recursively as the set of nodes computable from the union of T with the outgoing edges of the directly computable nodes. The set T is called an allowable set if it is verifiable and consistent. When T is allowable, the public key is obtained from the set of its computable nodes and the set either contains all the outgoing edges from a node or none from it.

Chameleon Hash Scheme
A chameleon hash function is a collision-resistant trapdoor hash function linked to a public/secret key combination (pk, sk). Anyone with access to the public key pk can easily compute the hash value for each input. Except for the trapdoor key sk holder, no one can efficiently compute a collision on any given input. The following three polynomial-time algorithms define the formal definition of a chameleon hash scheme [7]: Key Generation (1 k ): A probabilistic polynomial-time algorithm that generates a public/secret key pair (pk, sk) based on the security parameter k. Hashing Computation: A probabilistic polynomial-time algorithm that computes and outputs the chameleon hash value G pk (M, r) given a public key pk, a message M, and a random parameter r. Collision Computation: A deterministic polynomial-time method that outputs r such that G pk (M, r) = z = G pk (M , r ) when given the secret key sk, a message M, a random parameter r, and another message M as inputs.
Furthermore, if r is taken from a uniform probability distribution, the distribution of r is computationally indistinguishable from the uniform.
The following properties should be met by a secure chameleon hash technique [7]: Collision resistance: Without knowing the trapdoor key sk, there is no efficient algorithm that, given a message M, an auxiliary random parameter r and another message M , outputs r with a non-zero probability that G pk (M, r) = z = G pk (M , r ). Semantic security: Let E[X] denote the entropy of a random variable X, and E[X|Y] denote the entropy of a random function Y of X given the value of the variable X. If the conditional entropy E[M|z ] of a message given its chameleon hash value z equals the total entropy E[M] of the message space, the system is semantically secure. key-exposure freeness: If a recipient has never computed a collision on a chameleon hash G pk (M, r), no adversary will be able to identify an efficient algorithm to compute a collision on that G pk (M, r). This is true even if the adversary has access to the collision computation oracle for polynomially many queries on tuples (M i , r i ) of his choosing, except for the challenge query.

Chameleon Signature Schemes
A message's chameleon signature is created by digitally signing the message's chameleon hash value. A chameleon signature scheme, as defined by Chen et al., consists of the techniques described in [7]: Key Generation (1 k ): A probabilistic polynomial-time algorithm that outputs a public/secret key pair (pk S , sk S ) for the signer and (pk V , sk V ) for the verifier based on the security parameter k. Sign: A probabilistic polynomial-time algorithm that outputs a signature σ on the chameleon hash value z using the recipient's public key pk V , the signer's secret key sk S , a random string r, and a message M as inputs. Verify: A deterministic polynomial-time procedure that outputs Accept if σ is valid else outputs Reject given the the recipient's public key pk V , the signer's public key pk S , the random string r, the message M, and the signature σ. Denial protocol: A protocol between the signer and the judge that is not interactive. The signer submits a valid collision (M , r ) to the judge when given a chameleon signature σ on a message M. If M = M and σ are both legitimate, the judge concludes that the signature σ on the message M is forged.

Security Requirements of Chameleon Signature Schemes
The following are the properties of a chameleon signature scheme: unforgeability, non-transferability, non-repudiation, and deniability: Unforgeability: A valid chameleon signature cannot be generated by a third party. Furthermore, a recipient can only produce a forgery for a chameleon signature that was previously generated by the signer. Non-transferability: Because the recipient can forge a signature, the recipient cannot persuade a third party that the signer generated a signature on a specific message. Non-repudiation: The signer is not allowed to deny legitimate signature claims. Deniability: By providing a collision to the chameleon hash value, the signer can deny a forgery of the signature.

Proposed Hash-Based Chameleon Hashing and Signature Scheme
In this section, first, a chameleon hash function is constructed, and then a signature scheme is designed using the proposed hash function.

Construction of a Chameleon Hash Scheme
The proposed chameleon hash scheme consists of the following polynomial-time algorithms: Key Generation (1 k ): Let G be a publicly known DAG. Associate a homomorphic hash function H : F k 2 × F k 2 → F k 2 in the compression vertices and a homomorphic pseudorandom generator PG : F k 2 → F k 2 × F k 2 in the expansion vertices of G. The public parameters are G, H and PG with respect to the security parameter κ. The algorithm randomly chooses sk ∈ F k 2 and computes pk = Ext {e t } [sk : G(e s )]. It chooses a cut W in G. Let (W) be the cross edges of the cut W with |W| = l. It chooses a labeling r = (r 1 , r 2 , . . . , r l ) for (W) where r i ∈ F k 2 is the labeling of the i'th edge in (W) and computes r = Ext {e t } [r : G(W)]. It outputs (pk, ((W), r ) as a public key, where pk is the permanent public key and ((W), r ) is the ephemeral public key which is changed periodically. The corresponding private key is (sk, r). Hashing Computation: On input (M, pk, (W), r ), the algorithm computes G pk (M, r ) = h ⊕ r ⊕ pk = z Outputs chameleon hash z , for the tuple (M, r ). Collision Computation For any valid hash value z , the collision computation algorithm computes a hash collision with the trapdoor key (sk, r) as follows: The algorithm outputs a collision tuple (M * , r * ) for the chameleon hash value z .

Construction of the Chameleon Signature Scheme
A chameleon signature scheme is constructed by having the proposed chameleon hash function in a standard signature scheme of the same public key setting. The public key and the secret key of the proposed chameleon hash scheme are related in terms of a DAG. Hence, it is convenient to design a chameleon signature scheme by combining the proposed chameleon hash scheme and a graph-based signature scheme.
In the proposed signature scheme, each of the signer S and verifier V chooses a DAG and a secret value and labels the source edge of their DAG with the secret value and labels all the other edges by means of extension labeling from the source edge. The label obtained at the sink edge is their public key. The signer first computes the chameleon hash value for a message using the verifier's DAG G V and his public key. Then, he computes all minimal allowable sets for the graph G S and defines a partially ordered relation on it. The associated poset of G S is (G * S , ) with width w(G * S ). Then, with an efficient mapping function, the signer maps the chameleon hash value to a minimum allowable set in the antichain of width w(G * S ). Then, he outputs the values associated with the minimal allowable set with respect to his secret key as the signature for the chameleon hash value.
Signatures thus obtained are verifiable with respect to the signer's public key and are compatible which means that without inverting hash functions or pseudorandom functions, no signature can be computable from the signatures of different messages. Consequently, the essential requirements for the proposed signature scheme are maximal antichain of minimal allowable sets and an efficiently computable collision-resistant mapping from the hash space to the maximal antichain. In addition, for the chameleon signature scheme to be recipient-specific, the hash computation has to be done on the verifier's graph, and signature computation has to be done on the signer's graph.
The following algorithms describe the proposed Hash-Based Chameleon Signature (HBCS) scheme: Key Generation (1 k ): The signer S and the verifier V selects DAG's G i (i = S, V). Let H be a homomorphic hash function and PG be a homomorphic pseudorandom generator associated with the compression vertices and expansion vertices of G i (i = S, V). The signer randomly chooses sk S ∈ F k 2 , computes pk S = Ext {e t } [sk S : G S (e s )] and outputs the public key as (pk S , ((U), t )) where pk S is the permanent public key and ((U), t ) is the ephemeral public key. The corresponding private key is (sk S , t). Similarly, the verifier on his graph G V , computes and outputs the public key (pk V , ((W), r )) where pk V is the permanent public key and ((W), r ) is the ephemeral public key. The corresponding private key is (sk V , r). The signature on M is σ = (r , λ). Verify (pk S , M, λ): The verifier computes G pk V (M, r ) = z Verifies pk S = Ext {e t } λ : G S (µ(z )) Correctness pk S = Ext {e t } [sk S : G S (e s ))] Denial Protocol: In the event of a legal dispute between the recipient and the signer, i.e., when the recipient submits a message-signature tuple (M * , (r * , λ)) to the judge J and claims that it was generated by the signer, the judge first applies the above signature verification process and determines whether (r * , λ) is a proper signature on M * . If the verification fails, the judge rejects the alleged signature. Otherwise, he requests that the signer denies or accepts the claim. If the signer wishes to accept the signature, he simply informs the judge. If the signer wishes to declare the signature to be a forgery, he must provide a collision tuple (M, (r , λ)) i.e., G pk V (M, r , λ) = G pk V (M * , r * , λ). It is worth noting that, if (M * , (r * , λ)) is a forgery, the signer can always supply the original message-signature tuple (M, (r , λ)) that differs from (M * , (r * , λ)). If (M * , (r * , λ)) is valid, the signer cannot provide a collision on the hash value without knowing the secret key of the recipient. As providing collision is equivalent to finding the preimage of the hash function, which is shown in Theorem 1, the signer cannot provide collision and repudiate a valid signature. The inability of the signer in providing a collision on the chameleon hash value enables the judge to determine the signature is valid or forged.

Construction of DAG
Algorithm 1 is proposed to generate a DAG as explained in Section 3. Setting second edges for expansion vertices 8: if k is even then 9: for i ← 2 to k do 10: 11: end for 12: else if k is odd then 13: for i ← 2 to k do 14: if i is even then 15 19: end for 20: end if DAG's G V and G S are constructed and shown in Figures 1 and 2, respectively. In order to demonstrate the idea of the scheme, G V and G S are considered as the public graphs of verifier and signer, respectively. The hash function and pseudorandom generator are associated with the compression and expansion vertices of DAG's respectively. The signer chooses his secret key sk S and computes the public key pk S using G S . Similarly, the verifier chooses sk V and computes the public key pk V using G V . In addition, the verifier chooses a cut W in G V and chooses random value r along the cross

Security Analysis
This section examines the proposed chameleon hash function's security properties. It also discusses the proposed chameleon signature scheme's security against forgery, transferability, repudiation, and undeniability.

Security Analysis of the Proposed Hash-Based Chameleon Hash Scheme
In this subsection, the three properties of the chameleon hash scheme-collision resistance, semantic security, and key-exposure freeness-are proved.  Proof. Even if the adversary A has been given oracle access to collision computation and has been given polynomially many queries with the tuples (M i , r i ), i ≥ 1, of his choice, except for the challenge question, we assert that he cannot detect a collision on the hash value z = G pk (M, r ) using an efficient technique. The adversary can use two sorts of attacks to find collision on z . He might try to recover the secret values of r and pk along the cut's cross edges in the first attack, and he might try to discover collision on z without recovering the secret keys in the second attack. The hash function's Preimage Resistance (PR) is the target of the first attack. The second approach is to identify a collision on the given challenge z without knowing the private key, which is similar to cracking the graph-based one-time signature technique [16]. Because the graph-based one-time signature technique is safe against existential forgery in the standard model under a chosen message attack, it can be deduced that, even if the adversary has a polynomial number of signatures on messages, finding a collision on the hash G pk (M, r ) is difficult. As a result, the suggested chameleon hash has no key exposure.

Security Analysis of the Proposed Hash-Based Chameleon Signature Scheme
In this subsection, the properties of the chameleon signature scheme: unforgeability, non-transferability, non-repudiation, and deniability are proved. Theorem 4. Let G(V, E) be a directed acyclic graph with |V| = n, PG be a homomorphic pseudorandom generator and H be a homomorphic hash function. Let A be an adversary who performs an existential forgery under a chosen message attack against the proposed HBCS scheme with success probability . Then, ≤ (α D + C + PG + H )n + G where α ≤ n is the average number of predecessors of a random vertex in the graph and PG , H , C , D , and G are, respectively, the success probabilities on inverting PG, inverting function H, finding collision on H, distinguishing random strings and pseudorandom strings apart, and finding collision on a chameleon hash function.
Proof. As HBCS is based on the hash-and-sign approach, the adversary can produce forgery either by finding a valid collision on the chameleon hash or breaking the underlying signature. By Theorem 1, the signer cannot produce a valid collision on a chameleon hash value. The construction of the proposed underlying signature is based on the signature schemes proposed by Hevia et al. in [16] and Dod et al. in [17]. Hence, the security proof of the underlying signature scheme follows their proof. The proof is given by the following games between the adversary A against the signature and Challenger C. Each game is a slight modification of the preceding game in a way that the difference between the two games can be evaluated. Thus, the quality of the reduction can be easily quantified. The probability that A wins the Game i is denoted by Pr[Success i ]. #Game 1 : C chooses a DAG G and picks a random homomorphic hash function H and a homomorphic pseudorandom generator PG and associates them with the compression vertices and expansion vertices of G, respectively. C then runs the key generation algorithm and provides the public key to A . Because C knows the entire secret key, it can easily provide any one-time signature on A's requests. The success probability of this game is , so Pr[Success 1 ] = (1) Game 2 : As Game 1 , but with the modification that C picks an internal node at random and keeps it as the target node. C aborts if the adversary's signature query includes an arc predeceasing the target node or if the adversary's forgery does not invert the function on this node. Since the actions of C are independent of the chosen target, the forger behaves as in Game 1 . The success probability is at least Hence, the success probability in Game 2 is Game 3 : As in Game 2 , but with the following key generation change. C selects a target node on which to invert the function and replaces the selected node's output value with y. C additionally assigns random values to all arcs leading out of the previous graph of the target node. C recalculates the public key and hands it on to A. Except for those within the predecessor graph of the target, C can generate a value for all arcs. The arcs directly going out of the predecessor nodes in a direct line of the target node are the only arcs for which C has no value. C responds to the signature question if the adversary's inquiry does not contain any arcs within the preceding graph. C aborts the signature query if this is the case. When A wins Game 3 , the adversary has assigned a value y and its preimage to the targeted node. C discovered a preimage to the target if y = y. If y = y, on the other hand, a collision could occur somewhere along the way to the root. As a result, when A forges, Game 3 success results in either a collision on H or a preimage (for some y H or y PG ) It is also evident that, when A distinguishes between Game 2 and Game 3 , it is distinguishing between a right evaluation of the graph consisting of the predecessors in a direct line of the goal, along with their offspring, and an equal number of uniformly chosen uniform random values. As a result, this chance is negligible if all of the predecessors are undetectable. When an efficient signature forger exists, then From the sequence of the games and by considering the probability of finding collision on chameleon hash G , we have From Equation (5), if PG and H are cryptographically secure, then the HBCS scheme is unforgeable under a chosen message attack. Theorem 5. The proposed chameleon signature scheme satisfies the property of non-transferability.
Proof. The semantic security of the proposed hash scheme in Theorem 2 implies the non-transferability of the resulting chameleon signature scheme. Theorem 6. The proposed chameleon signature scheme satisfies the property of non-repudiation.
Proof. In the case of disputes, if a verifier provides a chameleon signature forgery, then the signer can repudiate it by producing collision pairs for the judge. By Theorem 1, the chameleon hash function is collision-resistant. Hence, in case of disputes, when the signer is not able to produce valid collision pairs on the chameleon hash to the judge, he is indeed the generator of the signature. Proof. It is ensured by the Denial protocol.

Discussion
Performance Analysis and Comparison: The significant parameters for a graphbased signature scheme on a DAG G are the number of internal vertices, which reveals the number of function evaluations required to compute the public key from the secret key, the maximum number of incompatible signatures, which gives the upper bound on the size of the message space, and the maximal size of the signature.
The proposed scheme requires hash evaluations and pseudorandom evaluations for the computation of public key, signature generation, and the verification process. For a DAG with n internal vertices, the worst-case time complexity of hash evaluations and pseudorandom evaluations are O( n 2 ) and O( nk 2 ), respectively. When n 1 and n 2 are the number of vertices in G S and G V , respectively, the time complexity of signature generation is O(n 1 k) + O(n 2 k). The verification process also requires the same time.
For a given graph G with n internal vertices, let ν(n) be the width of the associated poset. Table 1 shows that, for a given G of n internal vertices, there are ν(n) compatible minimal allowable sets. By optimizing n and the structure of the graph, ν(n) can be increased and hence the scheme can achieve the best possible efficiency in terms of signature size and computational costs. The size of the chameleon signature σ depends on the length of r and the length of λ. The length of λ depends on n 1 -the number of internal vertices of G S and the length of r depends on the length of the output of the hash function H which is of k bits. The minimal allowable sets in the maximal antichain of the proposed graph construction in Algorithm 1 contain either n 1 2 or n 1 2 + 1 edges. Hence, λ consists of values of either n 1 2 edges or n 1 2 + 1 edges, where each value is of k-bits. Therefore, the maximum size of the signature σ = ( n 1 2 + 1)k + k = ( n 1 2 )k + 2k. Few chameleon signature schemes are constructed by combining different chameleon hash functions proposed in [2,4,18] with the standard signature algorithms (RSA, DSS, etc.) of the same public key settings, and the comparison of those schemes with the proposed work for the security level of 80 bits is shown in Table 2-for instance, the hash function defined in [19] and the pseudorandom generator defined in the [19] proposed scheme. The hash function H : {0, 1} 2k → {0, 1} k is defined by H(x) = Ax mod q, where A ∈ Z n×2k q and pseudorandom generator PG : {0, 1} k → {0, 1} 2k is defined by PG(x) = (g B (s, x), g B (s, x)), where g B (s, x) = Bs + x mod q for B ∈ Z n×k q and a fixed secret s ∈ Z k q . In order to get 80-bit security, one needs to set the parameters of the functions k, n and q as k = n log q and q = n 2 as suggested by Micciancio Daniele in [20]. To achieve comparable security, we set the discrete logarithm based schemes p = 1024 and q = 160 bits, and the RSA scheme's RSA modulus to 1024 bits. The suggested quantum resistant system's signature size is also compared to that of a quantum resistant latticebased chameleon signature technique [13]. The parameters q = 100,000,007 and n equals the security level λ are used to determine the signature size, as indicated in [13]. The comparison results in Table 2 show that the signature length of the proposed scheme is larger than that of non-quantum schemes. This cost can be considered as the price for the proposed scheme to be quantum safe. In addition, the proposed scheme is key-exposure free and its signature length is smaller when compared to the existing quantum resistant chameleon signature scheme proposed in [13].

Conclusions
First, a new quantum-resistant hash-based chameleon hash technique with graph configuration is proposed in this study. It meets all of the desired security requirements, including collision resistance, semantic security, and key-exposure freeness. Second, utilizing the suggested chameleon hash and a graph-based one-time signature method, a privacypreserving quantum-resistant chameleon signature technique is created. To the best of our knowledge, it is the first scheme under hash-based cryptography that could satisfy the quantum world's requirement of privacy-preserving signatures. Furthermore, the comparison of the proposed scheme with the existing chameleon signature schemes shows that it has a smaller signature length than the existing quantum-safe scheme.