Next Article in Journal
Full Automorphism Group of (m,2)-Graph in Finite Classical Polar Spaces
Previous Article in Journal
Parabolic and Linear Rotational Motions on Cones and Hyperboloids
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Fuzzy Signature from Computational Diffie–Hellman Assumption in the Standard Model

School of Computer Science and Technology, Donghua University, Shanghai 201620, China
*
Author to whom correspondence should be addressed.
Axioms 2025, 14(8), 613; https://doi.org/10.3390/axioms14080613
Submission received: 19 June 2025 / Revised: 2 August 2025 / Accepted: 4 August 2025 / Published: 6 August 2025

Abstract

Fuzzy signature ( SIG F ) is a type of digital signature that preserves the core functionalities of traditional signatures, while accommodating variations and non-uniformity in the signing key. This property enables the direct use of high-entropy fuzzy data, such as biometric information, as the signing key. In this paper, we define the m-existentially unforgeable under chosen message attack ( m - EUF - CMA ) security of fuzzy signature. Furthermore, we propose a generic construction of fuzzy signature, which is composed of a homomorphic secure sketch ( SS ) with an error-recoverable property, a homomorphic average-case strong extractor ( Ext ), and a homomorphic and key-shift* secure signature scheme ( SIG ). By instantiating the foundational components, we present a m - EUF - CMA secure fuzzy signature instantiation based on the Computational Diffie–Hellman (CDH) assumption over bilinear groups in the standard model.

1. Introduction

1.1. Digital Signature and Fuzzy Signature

A digital signature [1,2] is a fundamental cryptographic primitive that ensures integrity, authentication, and non-repudiation in digital communication. Traditional signature algorithms [3] generally require the signing keys to be uniformly random and precisely accurate. When using a digital signature for authentication, users need to take care to retain their signing key. They may store the signing key on devices such as a smart card [4,5] or a USB token [6,7]. Hence, it is unavoidable for users to carry an additional device.
Fuzzy signature [8] is an advanced digital signature scheme that permits non-uniformity and approximate matching of the signing key. This property enables fuzzy signatures to leverage fuzzy data (e.g., biometric information) as the signing key. Note that the same individual’s biometric information [9,10,11] (e.g., fingerprints, iris scans, and facial features) may vary slightly with each capture due to environmental conditions, equipment differences, and measurement noise. Additionally, the distribution of biometric information is not uniform, but has high entropy.
Fuzzy signature ( SIG F ) consists of four algorithms, as depicted in Figure 1. The setup algorithm Setup F takes the security parameter as input, and it outputs the public parameters p p . Given the public parameters p p and a fuzzy signing key s k , such as a sample of biometric data, the key-generation algorithm KeyGen F computes the verification key v k . The signing algorithm Sign F takes s k (a new sample of the same biometric data), a message m, and the public parameters p p as inputs, and it outputs a signature σ . The verification algorithm Verify F takes p p , v k , a message m, and a signature σ as inputs, and it outputs 1 (valid) or 0 (invalid). The signature σ is guaranteed to be valid when the signing keys s k and s k are sufficiently close.
The notion of fuzzy signature was first introduced by Takahashi et al. [8]. In their work, they proposed a general construction of fuzzy signature based on a tool called linear sketch and a signature with homomorphic properties regarding keys and signatures. However, their security model assumes that the differences between different samples drawn from identical biometric data are independent of the biometric data itself, which deviates from real-world applications. In addition, their fuzzy signature has a critical limitation: it requires biometric information to be uniformly distributed, a condition that is clearly unrealistic in practical scenarios. Furthermore, their fuzzy signature requires bilinear groups and has large public parameters (proportional to the security parameter), making it less practical for real-world deployment.
Matsuda et al. [12] relaxed the constraints imposed on the underlying linear sketch and homomorphic signature scheme. Through this relaxation, they constructed a new fuzzy signature scheme based on the Schnorr signature scheme [13] and an improved linear sketch. Their construction operates under the assumption that the fuzzy data has high average min-entropy, even in the presence of information leakage. Thanks to the use of the Schnorr signature scheme, their fuzzy signature scheme achieves greater efficiency. Nevertheless, its security is guaranteed only in the random oracle model.
In 2021, Katsumata et al. [14] proposed a simple and efficient generic construction of fuzzy signature based on linear sketch and the tweaked Schnorr signature scheme. In their work, the linear sketch is formalized using lattice theory [15]. The security of the scheme relies on the DL sketch assumption, which combines the hardness of the discrete logarithm problem (DLP) [16] with the security of the sketch mechanism. Analysis shows that under a low Conditional False Matching Rate (ConFMR), DL sketch reduces to the standard DLP, and remains unconditionally secure in the generic group model, even for higher ConFMR values. To connect theory with practice, the authors develop a statistical framework using extreme value analysis and t-tests to estimate the ConFMR for real biometric data. However, their fuzzy signature is secure only in the random oracle model [17]. Similarly to previous works, their fuzzy signature requires that the differences between different samples drawn from identical biometric data are independent of the biometric data itself, which is not compatible with real-world applications.
Song et al. [18] introduced a novel security model called m -existentially unforgeable under chosen message attack ( m - EUF - CMA ) security for fuzzy signature, which requires only that the fuzzy signing key s k possesses sufficient entropy [19] and that the error distribution across different biometric samples can be arbitrarily correlated to the biometric data. In addition, they proposed a generic construction of fuzzy signature based on a fuzzy extractor [20] and a signature scheme with a simple key-generation process. By instantiating their framework with different signature schemes, they presented two concrete constructions: one based on the Computational Diffie–Hellman (CDH) assumption [21] in the standard model, and another based on lattice assumptions which is post-quantum secure in the random oracle model.
However, their signature generation algorithm requires the verification key v k as an additional input, which may impose a usability burden on the user. For instance, consider a scenario where a user signs messages using biometric data (e.g., a fingerprint or iris scan) as the signing key. If v k is required during signing, the user must securely store v k and may need to carry an external device (e.g., a smart card or USB token), which introduces usability challenges and potential security risks. Is such a device is compromised, it could undermine the overall security of the system. In contrast, if v k is not required during the signing process, the user can generate signatures solely based on biometric data, without the need to manage or protect the verification key. This leads to a more practical, user-friendly, and device-free signing experience.
With the advancement of quantum computing, growing attention has been devoted to the development of post-quantum secure cryptographic algorithms. Tian et al. [22] presented a new reusable fuzzy signature based on a reusable fuzzy extractor from LWE [23,24,25] and lattice-based digital signatures [26]. While their fuzzy signature scheme achieves post-quantum security, its security is established in the random oracle model.
In 2023, zheng et al. [27] proposed another efficient quantum-resistant fuzzy signature scheme based on the small integer solution problem (SIS) [28] by employing a modified linear sketch. Although their security proof is more rigorous than that of prior work, it can only be established under the random oracle model.
The aforementioned fuzzy signature schemes typically employ either a linear sketch or a fuzzy extractor as the core technique to bridge the gap between fuzzy biometric data and cryptographic primitives (e.g., signing keys).
A fundamental limitation of fuzzy signature schemes [8,12,14,27] based on linear sketches is the requirement that the errors across different biometric samples are statistically independent of the biometric data itself. This assumption is difficult to justify in practice, as real-world biometric variations are typically correlated with the underlying data, rendering such schemes impractical for real-life applications.
On the other hand, fuzzy extractor–based constructions face their own limitations. For instance, the scheme proposed in [22] is only proven secure in the random oracle model, while the one in [18] requires the verification key as input during signing, which introduces usability and security challenges.
Motivated by these observations, we are naturally led to the following question:
Does there exist a construction of a fuzzy signature scheme that (1) relaxes the assumptions on the distribution of fuzzy data, (2) does not require the verification key as input during signing, and (3) achieves security in the standard model without relying on random oracles?

1.2. Our Contributions

In this work, we provide an affirmative answer to the above question. The principal contributions of our work are as follows:
First, we redefine the notion of fuzzy signature and propose a new security model, which we call m -existential unforgeability under chosen-message attack ( m - EUF - CMA ), for fuzzy signatures. Compared with previous work [18], this new definition eliminates the requirement for the signing algorithm to take a verification key as input, thereby reducing the burden on users to maintain the verification key. Furthermore, our new security model is stronger than the one proposed by Matsuda et al. [12], because our security model allows the adversary to determine the differences between different biometric samples.
We formally define the error-recoverable property of the secure sketch and show that the syndrome-based secure sketch possesses the error recoverable property. We redefine the homomorphic property and define the key-shift* security of the signature scheme. In our key-shift* security model, the adversary can modify not only the signing key s k , but also the verification key v k . We also prove that the Waters signature scheme SIG Wat is homomorphic and key-shift* secure.
We present a generic construction of a fuzzy signature scheme, built upon three core primitives: a homomorphic secure sketch ( SS ) with error recovery, a homomorphic average-case strong extractor ( Ext ), and a homomorphic signature scheme ( SIG ) satisfying key-shift security.
Instantiating these primitives yields a fuzzy signature scheme that achieves m - EUF - CMA security under the Computational Diffie–Hellman (CDH) assumption in the standard model over bilinear groups, and, notably, does not require the verification key as input to the signing algorithm.
In Table 1, we present an overview of our constructions compared with existing fuzzy signature schemes.

1.3. Our Approach

Our generic construction of fuzzy signature consists of a homomorphic secure sketch with an error-recoverable property, a homomorphic average-case strong extractor, and a SIG with a homomorphic property and a simple key-generation process.
In the setup algorithm Setup F , the seed i of extractor Ext and public parameters p p , generated by the underlying signature scheme’s setup algorithm Setup , serve as the public parameters p p F of the entire fuzzy signature SIG F . In the key-generation algorithm KeyGen F , the public parameters p p F and a biometric sample w are taken as input, and the verification key v k F of SIG F is generated. Specifically, w is first computed by the sketch generation algorithm SS . Gen to produce a sketch s , and then the extractor Ext is used to extract the secret key s k from w for the underlying signature scheme ( SIG ). Subsequently, the SIG ’s simple key-generation process enables the verification key v k of the SIG to be derived. Therefore, the final verification key of the SIG F is given by v k F = ( v k , s ) .
The signing algorithm Sign F uses a new biometric sample w as the signing key of fuzzy signature to sign the message m. Specifically, the process begins by computing a new sketch s from w , while the extractor Ext is used to extract the new s k as the secret key (signing key) for the underlying signature scheme SIG . Subsequently, the message m and the sketch s are signed together using the SIG to obtain σ . The final signature σ F is then given by ( σ , s ) . In Verify F , utilizing the values of s and s generated during the KeyGen F and Sign F , the error-recovery property of SS allows us to compute Δ w = w w . This enables the extractor Ext to calculate Δ s k = s k s k . Next, thanks to the homomorphic property of the SIG , we can obtain the verification key v k corresponding to s k , thereby ensuring the correctness of SIG . Consequently, the correctness of the entire fuzzy signature scheme SIG F is also guaranteed. In addition, the security of our SIG F is ensured by Ext and SIG . More precisely, the security of Ext guarantees the uniform randomness of the secret key in SIG , thereby guaranteeing the security of SIG . Furthermore, the m - EUF - CMA security we defined for Sign F can be reduced to the key-shift* security of SIG , which is further guaranteed by the homomorphic property and EUF-CMA security of SIG . Detailed information on this is presented in Section 4.

2. Preliminaries

Throughout this paper, we denote the set of integers by Z and the set of real numbers by R . The notation “ u v ” denotes a deterministic assignment of the value v to the variable u. Given a finite set D , we use d $ D to indicate that d is drawn uniformly at random from D . The cardinality of a set D is denoted by | D | . For any bit strings a and b, we write | a | for the bit-length of a, and write a     b to denote the concatenation of a and b. A probabilistic algorithm that operates in polynomial time is referred to as a PPT algorithm. For a natural number k, we write [ k ] for the index set { 1 , 2 , , k } . Let A be a randomized procedure; we express ρ A ( x ; r ) to represent the outcome ρ when A is executed on input x with internal randomness r. A function negl ( n ) is called negligible if for every positive polynomial q ( · ) , there exists an integer n 0 , such that for all n > n 0 , it holds that negl ( n ) 1 q ( n ) .

2.1. Metric Spaces

Definition 1 (Metric Space [29]). 
A metric space is a set W equipped with a distance function dis : W × W R 0 , where dis satisfies the following properties for all w 1 , w 2 , w 3 W :
(i) 
dis ( w 1 , w 2 ) = 0 if, and only if, w 1 = w 2 ;
(ii) 
dis ( w 1 , w 2 ) = dis ( w 2 , w 1 ) (symmetry);
(iii) 
dis ( w 1 , w 3 ) dis ( w 1 , w 2 ) + dis ( w 2 , w 3 ) (triangle inequality).

2.2. Min-Entropy and Statistical Distance

Definition 2 (Min-Entropy [29]). 
Let ξ be a discrete random variable over a finite set D . The min-entropy of ξ is defined as
H ( ξ ) = log max d D Pr [ ξ = d ] .
Definition 3 (Average Min-Entropy [20]). 
Let A and B be two discrete random variables over finite sets A and B , respectively. The average min-entropy of A given B is defined as
H ˜ ( A B ) = log E b B max a A Pr [ A = a B = b ] .
Definition 4 (Statistical Distance [20]). 
Let U and V be two random variables taking values in a finite set W . The statistical distance between U and V is defined as
SD ( U , V ) = 1 2 w W Pr [ U = w ] Pr [ V = w ] .

2.3. Computational Diffie–Hellman (CDH) Assumption

Let IG be an algorithm that outputs ( p , g , G ) , where G is a cyclic group with order p, and g G is a generator.
Definition 5 (CDH Problem). 
Given the four-tuple ( G , g , g a , g b ) , compute g a b , where ( p , g , G ) IG and a , b Z p .
Definition 6 (CDH Assumption). 
The CDH assumption w.r.t. ( p , g , G ) is ϵ-hard if, for any PPT adversary A , the following holds:
Adv A CDH : = Pr [ A ( G , g , g a , g b ) g a b ] ϵ ,
where ( p , g , G ) IG and a , b Z p .

2.4. Secure Sketch and Average-Case Strong Extractor

Definition 7 (Secure Sketch [20]). 
A ( W , m , m ^ , t ) -secure sketch ( SS ) consists of two efficient algorithms, defined as follows:
SS . Gen ( w ) on input w W , outputs a sketch s S .
SS . Rec ( w , s ) on input w W and a sketch s S , outputs a recovered value w ˜ .
These algorithms must satisfy the following properties:
Correctness : When dis ( w , w ) t , then w = SS . Rec ( w , SS . Gen ( w ) ) = w ˜ .
Security : For any distribution W over W , if H ( W ) > m , H ˜ ( W | SS . Gen ( W ) ) > m ^ .
A secure sketch is regarded as homomorphic if for all u , v W , it holds that
SS . Gen ( u + v ) = SS . Gen ( u ) + SS . Gen ( v ) .
Definition 8 (Error-Recoverable Property). 
Let SS = ( SS . Gen , SS . Rec ) be a ( W , m , m ^ , t ) -secure sketch and w , w W , such that dis ( w , w ) t . Let Δ w = w w and s = SS . Gen ( w ) , s = SS . Gen ( w ) . We say that the secure sketch has the error-recoverable property if there is a deterministic function f r e c , such that Δ w = f r e c ( s , s ) .
Remark 1. 
In our fuzzy signature scheme, the user needs to compute the error between the fuzzy data w sampled during the generation of the verification key and w used for signing, by utilizing the values s and s . Here, s is included in the verification key, while s is part of the signature. Through this mechanism, the scheme can verify the validity of the signature. The details can be found in Section 4 of our paper. The error-recoverable property ensures that the user can perform the above operations reliably.
Lemma 1. 
The error-recoverable property mentioned above is satisfied by the syndrome-based secure sketch construction.
Proof. 
This lemma is a straightforward consequence of the inherent properties of the syndrome-based secure sketch construction [20]. Recall that the syndrome-based secure sketch is as follows. The generation algorithm SS . Gen ( w ) = syn ( w ) = s , and the recovery algorithm SS . Rec ( w , s ) = w decode ( syn ( w ) s ) = w decode ( s s ) , where decode is an efficient and deterministic function to find the unique e W , where dis ( e , 0 ) t such that syn ( e ) = syn ( w ) s . By the correctness of the secure sketch, if dis ( w , w ) t , then w = SS . Rec ( w , s ) = w decode ( s s ) . It is obvious that Δ w = w w = decode ( s s ) . The lemma follows. □
For completeness, we provide the details of the syndrome-based secure sketch in Appendix A.
Definition 9 (Average-Case Strong Extractor [20]). 
A function Ext : W × R V is called an average-case ( W , m , V , ε e x t ) -strong extractor with randomness R R if for every random variable W over W and any auxiliary information Z, the following holds:
SD Ext ( W , R ) , R , Z , U , R , Z ε e x t ,
where R and U are independently and uniformly sampled from R and V , respectively.
Definition 10 (Homomorphic Average-Case Strong Extractor). 
An average-case ( W , m , V , ε ) -strong extractor Ext : W × R V is said to be homomorphic if for all w 1 , w 2 W and all seeds r R , it satisfies
Ext ( w 1 + w 2 , r ) = Ext ( w 1 , r ) + Ext ( w 2 , r ) .
One instantiation of an average-case strong extractor [30] is defined as follows:
Ext ( w , r ) = w 0 + r 1 w 1 + + r l w l ,
where r = ( r 1 , , r l ) Z p l denotes the seed, and w = ( w 0 , w 1 , , w l ) Z p l + 1 represents the input. Note that
Ext ( w 0 + w 1 , r ) = ( w 0 , 0 + w 1 , 0 ) + r 1 ( w 0 , 1 + w 1 , 1 ) + + r l ( w 0 , l + w 1 , l ) = w 0 , 0 + r 1 w 0 , 1 + + r l w 0 , l + w 1 , 0 + r 1 w 1 , 1 + + r l w 1 , l = Ext ( w 0 , r ) + Ext ( w 1 , r ) .
Then we have that Equation (1) is a homomorphic average-case strong extractor.

2.5. Signature Scheme

Definition 11 (Signature Scheme). 
A digital signature scheme SIG = ( Setup , KeyGen , Sign , Verify ) consists of four probabilistic polynomial-time (PPT) algorithms.
  • p p Setup ( 1 λ ) : On input the security parameter λ, Setup outputs public parameters p p .
  • ( v k , s k ) KeyGen ( p p ) : On input p p , KeyGen generates a key pair consisting of a verification key v k VK and a signing key s k SK .
  • σ Sign ( p p , s k , m ) : On input p p , s k , and a message m M , Sign outputs a signature σ.
  • b Verify ( p p , v k , m , σ ) : On input p p , v k , m, and σ, Verify outputs a bit b { 0 , 1 } indicating whether the signature is valid (1) or invalid (0).
Correctness. 
For any message m M , let p p Setup ( 1 λ ) , ( v k , s k ) KeyGen ( p p ) , and signature σ Sign ( p p , s k , m ) ; then
Pr [ Verify ( p p , v k , m , σ ) = 1 ] 1 negl ( λ ) .
Definition 12 (EUF-CMA Security). 
We say that a digital signature SIG achieves existentially unforgeable under adaptive chosen-message attack (EUF-CMA) security if for any PPT adversary, it holds that
Adv SIG , A EUF CMA ( 1 λ ) : = Pr [ Expt SIG , A EUF CMA ( 1 λ ) 1 ] negl ( λ ) ,
where Expt SIG , A EUF CMA ( 1 λ ) is defined as follows.
Expt SIG , A EUF CMA ( 1 λ ) :
1. 
The challenger C runs p p Setup ( 1 λ ) , generates ( v k , s k ) KeyGen ( p p ) , initializes an empty query set Q = , and sends p p and v k to the adversary A .
2. 
Throughout the experiment, A may adaptively query a signing oracle:
  • A submits a message m j M to C .
  • C computes σ j Sign ( p p , s k , m j ) , adds m j to Q , and returns σ j to A .
3. 
Finally, A outputs a forgery ( m , σ ) . The experiment outputs 1 if, and only if,
m Q a n d Verify ( p p , v k , m , σ ) = 1 .
Otherwise, it outputs 0.
Definition 13 
(Simple Key-Generation Process [8]). We say that a digital signature scheme SIG = ( Setup , KeyGen , Sign , Verify ) supports a simple key-generation process if the public parameters p p Setup ( 1 λ ) implicitly define the signing key space SK , and there exists a deterministic polynomial-time ( PPT ) algorithm KG such that KeyGen ( p p ) is functionally equivalent to the following procedure:
KeyGen ( p p ) : s k $ SK , v k KG ( p p , s k ) , r e t u r n ( v k , s k ) .
Definition 14 (Homomorphic Signature). 
A signature scheme SIG = ( Setup , KeyGen , Sign , Verify ) , equipped with a simple key-generation process KG , is said to be homomorphic if the following properties are satisfied:
1. 
For all p p Setup ( 1 λ ) , the signing key space SK constitutes an abelian group ( SK , + ) .
2. 
For all s k , Δ s k SK , there exists a deterministic and efficient algorithm A vk such that
KG ( p p , s k + Δ s k ) = A vk ( p p , v k , Δ s k ) ,
where p p Setup ( 1 λ ) , v k KG ( p p , s k ) .
3. 
Suppose the random space of the signing algorithm is R . For all r R , m M and s k , Δ s k SK , there exists a deterministic and efficient algorithm A Sign such that
Sign ( p p , s k + Δ s k , m , r ) = A Sign ( p p , m , σ , Δ s k ) ,
where p p Setup ( 1 λ ) , σ Sign ( p p , s k , m , r ) .
Remark 2. 
For simplicity, we sometimes omit r and say that there exists a deterministic and efficient algorithm A Sign such that
Sign ( p p , s k + Δ s k , m ) = A Sign ( p p , m , σ , Δ s k ) .
where p p Setup ( 1 λ ) , σ Sign ( p p , s k , m ) .
Remark 3. 
Our definition of a homomorphic signature differs from the definition provided in [8] in three aspects.
1. 
The first difference lies in the inputs required by the algorithm A Sign . In our definition, A Sign takes p p , m , σ , Δ s k as input and generates a valid signature of m under the signing key s k + Δ s k . However, in [8], the algorithm additionally requires v k as part of its input.
2. 
The second difference is that in our definition with the same random number r, Sign ( p p , s k + Δ s k , m , r ) = A Sign ( p p , m , Sign ( p p , s k , m , r ) , Δ s k ) , while in [8], the distribution of { σ Sign ( p p , s k + Δ s k , m ) : σ } and { σ Sign ( p p , s k , m ) ; σ A Sign ( p p , m , σ , Δ s k ) : σ } is required to be identical.
3. 
The third difference is that our definition omits the requirement that for all s k , Δ s k and all pairs ( m , σ ) satisfying Verify ( p p , KG ( p p , s k ) , m , σ ) = 1 , it holds that Verify ( p p , KG ( p p , s k + Δ s k ) , m , A Sign ( p p , m , σ , Δ s k ) ) = 1 .
Next, we will formally define the key-shift* security of a signature scheme. In the traditional related-key attack (RKA) security experiment [31], only the signing key s k can be changed by the adversary A . More precisely, the adversary is allowed to modify the secret key s k using a predefined set of transformations, and obtains signatures under the modified keys on adaptively chosen messages, while the verification key v k remains unchanged. The adversary’s goal is to produce a valid forgery—a message–signature pair ( m , σ ) —such that σ verifies correctly under the corresponding verification key v k . If the adversary succeeds in producing such a forgery, it is said to have broken the scheme under related-key attacks. These transformations can include various functions, such as affine transformations, bitwise operations, or other structured modifications. A more detailed RKA security definition is given in Appendix B.
The key-shift security notion is a special case of RKA security, in which the adversary is restricted to applying only additive shifts to the secret key. That is, the adversary can choose a shift value Δ s k and obtain signatures under s k + Δ s k .
Our proposed key-shift* security strengthens the key-shift model by also allowing the adversary to submit not only a forged message–signature pair ( m , σ ) , but also a corresponding secret key shift Δ s k . The adversary succeeds if the signature σ verifies correctly with respect to the verification key associated with the shifted secret key s k + Δ s k . This captures a stronger adversarial capability and provides a more refined security guarantee in settings where both the signing and verification keys may be subject to related-key manipulations.
Definition 15 (Key-Shift* Security). 
A signature scheme SIG = ( Setup , KeyGen , Sign , Verify ) with a simple key-generation process KG is key-shift* secure if for all PPT adversaries A , it holds that
Adv SIG , A key shift ( 1 λ ) : = Pr [ Expt SIG , A key shift ( 1 λ ) 1 ] negl ( λ ) ,
where Expt SIG , A key shift ( 1 λ ) is defined as follows.
Expt SIG , A key shift ( 1 λ ) :
1. 
The challenger C runs p p Setup ( 1 λ ) , generates ( v k , s k ) KeyGen ( p p ) , initializes an empty query set Q = , and sends p p and v k to the adversary A .
2. 
Throughout the experiment, A may adaptively query a signing oracle with pairs ( m j , Δ s k j ) , where m j M and Δ s k j is a key shift:
  • A submits ( m j , Δ s k j ) to C .
  • C computes the signature σ j Sign ( p p , s k + Δ s k j , m j ) , adds m j to Q , and returns σ j to A .
3. 
Finally, A outputs a forgery ( m , σ ) and a final shift Δ s k . The experiment outputs 1 if, and only if,
m Q a n d Verify p p , KG ( p p , s k + Δ s k ) , m , σ = 1 .
Otherwise, it outputs 0.
Remark 4. 
Compared to standard key-shift security, key-shift* security captures a stronger adversarial capability. In this work, key-shift* security is specifically designed to support the construction of fuzzy signature schemes, where secret keys are often derived from noisy or biometric data that may vary across different uses.
Lemma 2. 
Let SIG = ( Setup , KeyGen , Sign , Verify ) be a signature scheme with a simple key-generation process KG and a signing key space SK . If SIG is EUF-CMA secure and homomorphic, then SIG is key-shift* secure.
Proof. 
We prove the key-shift* security of SIG via a reduction to its EUF-CMA security, leveraging the homomorphic property of the scheme SIG . Suppose there exists a probabilistic polynomial-time (PPT) adversary A that breaks the key-shift* security of SIG with a non-negligible advantage. Then, we construct a new adversary B that uses A as a subroutine to break the EUF-CMA security of SIG .
The adversary B interacts with its own EUF-CMA challenger and simulates the key-shift* experiment for A as follows:
  • Upon receiving the public parameters p p and verification key v k from its EUF-CMA challenger, B forwards ( p p , v k ) to A .
  • For each j-th signing query ( m j , Δ s k j ) made by A , B proceeds as follows:
    • B queries its signing oracle on m j and receives a signature σ j ˜ Sign ( p p , s k , m j ) .
    • B computes σ j A Sign ( p p , m j , σ j ˜ , Δ s k j ) using the homomorphic signing algorithm, and returns σ j to A .
  • In the final phase, when A outputs a forgery ( m , σ ) and a shift Δ s k , B computes
    σ ˜ A Sign ( p p , m , σ , Δ s k ) ,
    and submits ( m , σ ˜ ) to its challenger. B then outputs whatever its challenger returns.
We now argue that the simulation is perfect. By the homomorphic property of SIG , we have
Sign ( p p , s k + Δ s k j , m j ) = A Sign ( p p , m j , σ j ˜ , Δ s k j ) ,
where σ j ˜ = Sign ( p p , s k , m j ) . Therefore, the signatures returned by B are distributed identically to those in the real key-shift* experiment.
Next, we will show that B has the same advantage of A .
Note that if A ’s forgery ( m , σ ) is valid under the shifted key s k + Δ s k , i.e.,
m Q Verify ( p p , KG ( p p , s k + Δ s k ) , m , σ ) = 1 ,
by the homomorphic property, we have
σ ˜ = A Sign ( p p , m , σ , Δ s k ) = Sign ( p p , s k + Δ s k Δ s k , m ) = Sign ( p p , s k , m ) .
This implies that σ ˜ is a valid signature of m under the signing key s k . As a result, if A wins the key-shift* experiment, then B wins the EUF-CMA experiment. So we have
Adv SIG , A key shift ( 1 λ ) Adv SIG , B EUF CMA ( 1 λ ) negl ( λ ) .

3. Fuzzy Signature

A fuzzy signature scheme SIG F differs from a traditional digital signature scheme SIG in that the signing key is no longer required to be uniformly random or precisely reproducible. Instead, the signing key in a fuzzy signature can be any high-entropy fuzzy data, such as biometric inputs (e.g., facial scans or fingerprints). The key-generation algorithm takes a fuzzy signing key w W (e.g., an initial facial scan) and outputs a verification key v k F . Any signature generated using w W (e.g., a later facial scan of the same person) will verify successfully under v k F , provided that w and w are sufficiently close according to an appropriate distance metric. Below, we formally define a fuzzy signature scheme SIG F .
Definition 16(Fuzzy Signature). 
Let W be the fuzzy signing key space, M the message space, and t N a threshold parameter governing the acceptable distance between keys. A ( W , M , t ) -fuzzy signature scheme SIG F = ( Setup F , KeyGen F , Sign F , Verify F ) consists of four probabilistic polynomial-time ( PPT ) algorithms:
  • p p F Setup F ( 1 λ ) . Upon input of the security parameter 1 λ , this algorithm outputs public parameters p p F .
  • v k F KeyGen F ( p p F , w ) . Given the public parameters p p F and a fuzzy signing key w W (e.g., a biometric template), this algorithm generates a verification key v k F .
  • σ F Sign F ( p p F , w , m ) . To sign a message m M , the signer uses a (possibly different) fuzzy key w W close to the original w , along with p p F , to produce a signature σ F .
  • b Verify F ( p p F , v k F , m , σ F ) , where b { 0 , 1 } . This algorithm checks the validity of the signature σ F on message m under the verification key v k F and public parameters p p F , returning 1 if valid and 0 otherwise.
Correctness. 
For any m M , w , w W , if p p F Setup F ( 1 λ ) , v k F KeyGen F ( p p F , w ) , σ F Sign ( p p F , w , m ) , dis ( w , w ) t , we have
Pr [ Verify ( p p F , v k F , m , σ F ) = 1 ] 1 negl ( λ ) .
Next, we present a new security model in which the adversary can adaptively determine the differences between biometric samples.
Definition 17 
( m - EUF - CMA Security). A ( W , M , t ) -fuzzy signature scheme SIG F is said to be m -existentially unforgeable under adaptive chosen-message attacks secure ( m -EUF- CMA ) if no efficient adversary A can produce a valid forgery with non-negligible probability when the signing key is sampled from an arbitrary distribution W over W with min-entropy of at least m , i.e., H ( W ) m .
Formally, for all probabilistic polynomial-time (PPT) adversaries A , we require that
Adv SIG F , A m - EUF CMA ( 1 λ ) : = Pr [ Expt SIG F , A m - EUF CMA ( 1 λ ) 1 ] negl ( λ ) ,
where Expt SIG , A m - EUF CMA ( 1 λ ) is defined as follows.
Expt SIG , A m - EUF CMA ( 1 λ ) :
1. 
The challenger C runs p p F Setup F ( 1 λ ) ; samples a signing key w W , where W is a distribution over W with H ( W ) m ; computes v k F KenGen F ( p p F , w ) ; and initializes an empty query set Q = . Next, it returns p p F and v k F to A .
2. 
Over the course of the experiment, A is allowed to adaptively make signing oracle queries in the following form:
  • A sends a message m j M and a shift Δ w j W to C .
  • If dis ( Δ w j , 0 ) > t , C returns(invalid shift). Else, C invokes σ F , j Sign F ( p p F , w + Δ w j , m j ) , adds m j to the query set Q , and returns σ F , j to A .
3. 
In the final phase, A outputs a forgery ( m , σ F ) . The experiment returns 1 if m Q Verify F ( p p , v k , m , σ F ) = 1 ; otherwise, it returns 0.
Remark 5. 
In our security model, the shift Δ w j between different samples of the same noisy source is adaptively chosen by the adversary A . Note that, before the adversary submits a shift Δ w j , the adversary has received p p F , v k F , and ( σ F , 1 , , σ F , j 1 ) . Since v k F and ( σ F , 1 , , σ F , j 1 ) are dependent on W, Δ w j can be dependent on W. However, due to A ’s limited computational ability, the shift Δ w j cannot depend on the biometric data in an arbitrary manner. Nevertheless, our security model is still stronger than the security model in [12], which requires the errors between different samples to be independent of the noisy source.
Remark 6. 
From a theoretical perspective, the adversary-selected shift model subsumes the scenario of independent errors, provided that the adversary chooses the shifts randomly and independently. From a practical perspective, however, we argue that modeling only independent errors may not be sufficient to capture real-world threats. For instance, in biometric-based systems, an adversary could manipulate the sampling device to deterministically flip or fix certain bits of the biometric data. Consider, for example, the i-th bit of the biometric template:
  • If the original bit is 1, it remains unchanged.
  • If the original bit is 0, it is flipped to 1.
This type of deterministic bit manipulation cannot be captured by independent random-error models, as the error is not random, but depends on the biometric template. In contrast, our adversary-selected shift model is specifically designed to account for such scenarios, thereby providing a stronger and more realistic security guarantee in the presence of active and targeted distortions.

4. Construction of Fuzzy Signature

4.1. Construction

Our fuzzy signature scheme SIG F = ( Setup F , KeyGen F , Sign F , Verify F ) , which is depicted in Figure 2, is composed of the following building blocks.
  • A homomorphic ( W , m , m ˜ , t ) -secure sketch SS = ( SS . Gen , SS . Rec ) with a sketching space S that satisfies the error-recoverable property.
  • A key-shift* secure and homomorphic SIG = ( Setup , KeyGen , Sign , Verify ) with a secret key space SK and a message space M × S .
  • A homomorphic average-case ( W , m ˜ , SK , ε e x t ) -strong extractor Ext with seed space I .
For better clarity and understanding of our construction, we have added Figure 3 to visually depict the key components and their interactions.

4.2. Correctness

Theorem 1. 
If SS is a homomorphic ( W , m , m ˜ , t ) -secure sketch with a sketch space S and the error-recoverable property, Ext is a homomorphic average-case ( W , m ˜ , SK , ε ext ) -strong extractor with a seed space I , and the signature scheme SIG is homomorphic with the secret key space SK and message space M × S , then the constructed fuzzy signature scheme SIG F is correct.
Proof. 
To establish the correctness of the fuzzy signature scheme, we need to show that for any m M and w , w W , if dis ( w , w ) t , the verification algorithm accepts the signature. Specifically, it holds that Verify F ( p p F , v k F , m , σ F ) = 1 , where p p F Setup F ( 1 λ ) , v k F KeyGen F ( p p F , w ) , and σ F Sign F ( p p F , w , m ) .
Note that verification algorithm accepts the signature if, and only if, the underlying signature scheme successfully verifies. That is, Verify ( p p , v k , M , σ ) = 1 , where σ Sign ( p p , s k , M ) , s SS . Gen ( w ) , s k Ext ( w , i ) , and M ( m , s ) .
By the correctness of the underlying signature SIG , if v k = KG ( p p , s k ) , then Verify ( p p , v k , M , σ ) = 1 , since σ Sign ( p p , s k , M ) . So we need to prove that if dis ( w , w ) t , v k = KG ( p p , s k ) .
Recall that Δ w f r e c ( s , s ) , Δ s k Ext ( Δ w , i ) , v k A vk ( p p , v k , Δ s k ) , where s SS . Gen ( w ) and s SS . Gen ( w ) . Due to the the error-recoverable property of the secure sketch SS , for any w , w W , if dis ( w , w ) t , it holds that Δ w = w w = f r e c ( s , s ) .
Due to the homomorphic property of Ext , we have
s k = Ext ( w ) = Ext ( w + Δ w ) = Ext ( w ) + Ext ( Δ w ) = s k + Δ s k .
Similarly, due to the homomorphic property of SIG , it follows that
v k = A vk ( p p , v k , Δ s k ) = KG ( p p , s k + Δ s k ) = KG ( p p , s k ) .
As a result, the fuzzy signature scheme SIG F is correct. □

4.3. Security

Theorem 2. 
If SS is a homomorphic ( W , m , m ˜ , t ) -secure sketch with a sketching space S and it satisfies the error-recoverable property, Ext is a homomorphic average-case ( W , m ˜ , SK , ε e x t ) -strong extractor with a seed space I , SIG is a homomorphic signature scheme with a secret key space SK , message space M × S and key-shift* security, then the construction of fuzzy signature SIG F in Figure 2 is a ( W , M , t ) -fuzzy signature satisfying m EUF CMA security. In addition,
Adv SIG F , A m - EUF CMA ( 1 λ ) Adv SIG key shift ( 1 λ ) + ε e x t .
Proof. 
Let A be an arbitrary PPT adversary that attacks the m EUF CMA security of fuzzy signature SIG F . We will prove this theorem by a sequence of games, where the first game Game 0 is the original game Expt SIG F , A m - EUF CMA ( 1 λ ) . For i { 0 , 1 , 2 } , let S i denote the event that A wins (i.e., the experiment returns 1) in Game i . Our goal is to show that Adv SIG F , A m - EUF CMA ( 1 λ ) : = Pr [ Expt SIG F , A m - EUF CMA ( 1 λ ) 1 ] is negligible. Differences between adjacent games are highlighted with underline.
Game 0. 
Game 0 is identical to the m -EUF- CMA experiment Expt SIG F , A m - EUF - CMA ( 1 λ ) . Specifically, it proceeds as follows:
  • Challenger C samples i $ I , invokes p p Setup ( 1 λ ) , sets p p F ( i , p p ) , then samples w W , computes s SS . Gen ( w ) , s k Ext ( w , i ) , v k KG ( p p , s k ) , and sets v k F ( s , v k ) . Next, it initializes the query set Q = , which denotes the set of queries selected by A . Afterwards, C returns ( p p F , v k F ) to A .
  • The adversary A may adaptively make signing queries.
    • A submits a message m j M and a shift Δ w j W to C .
    • If dis ( Δ w j , 0 ) > t , C returns ⊥. Else, C parses p p F = ( i , p p ) , invokes s j SS . Gen ( w + Δ w j ) and s k j Ext ( w + Δ w j , i ) , then sets M j ( m j , s j ) , invokes σ j Sign ( p p , s k j , M j ) , sets σ F , j ( s j , σ j ) , adds m j to the set Q , and returns σ F , j to A .
  • Finally, A submits a forgery ( m , σ F ) . C parses p p F = ( i , p p ) , v k F = ( s , v k ) , σ F = ( s , σ ) , then sets M ( m , s ) , and computes Δ w f r e c ( s , s ) , Δ s k Ext ( Δ w , i ) and v k A vk ( p p , v k , Δ s k ) . If m Q Verify ( p p , v k , M , σ ) = 1 , the experiment outputs 1; else, it outputs 0.
    Obviously,
    Adv SIG F , A m - EUF CMA ( 1 λ ) = Pr [ Expt SIG F , A m - EUF CMA ( 1 λ ) 1 ] = Pr [ S 0 ] .
Game 1. 
This game behaves equivalently to Game 0, apart from some conceptual changes. More precisely,
  • The adversary A may adaptively make signing queries.
    • A submits a message m j M and a shift Δ w j W to C .
    • If dis ( Δ w j , 0 ) > t , C returns ⊥. Else, C parses p p F = ( i , p p ) , invokes s j s + SS . Gen ( Δ w j ) and s k j s k + Ext ( Δ w j , i ) , then sets M j ( m j , s j ) , invokes σ j Sign ( p p , s k j , M j ) , sets σ F , j ( s j , σ j ) , adds m j to the set Q , and returns σ F , j to A .
Lemma 3. 
Pr [ S 0 ] = Pr [ S 1 ] .
Proof. 
Due to the homomorphic property of Ext , it follows that
s k j = Ext ( w + Δ w j , i ) = Ext ( w , i ) + Ext ( Δ w j , i ) = s k + Ext ( Δ w j , i ) .
Similarly, due to the homomorphic property of SS , it follows that
s j = SS . Gen ( w + Δ w j ) = SS . Gen ( w ) + SS . Gen ( Δ w j ) = s + SS . Gen ( Δ w j ) .
Therefore, in both games, the signing key s k j and the sketch s j used in response to each query are computed correctly according to the homomorphic property. Since all oracle responses are identically distributed in Game 0 and Game 1 , it follows that Pr [ S 0 ] = Pr [ S 1 ] . The lemma is thus established. □
Game 2. 
This game is identical to Game 1, except that in step 1, s k is uniformly chosen from SK other than s k Ext ( w , i ) . More specifically,
  • Challenger C samples i $ I , invokes p p Setup ( 1 λ ) , sets p p F ( i , p p ) , then samples w W , computes s SS . Gen ( w ) , randomly chooses s k $ SK , computes v k KG ( p p , s k ) , and sets v k F ( s , v k ) . Next, it initializes the query set Q = , which denotes the set of queries selected by A . Afterwards, C returns ( p p F , v k F ) to A .
Lemma 4. 
| Pr [ S 1 ] Pr [ S 2 ] | ε e x t .
Proof. 
Note that H ( W ) m ; by the security of the ( W , m , m ˜ , t ) -secure sketch, we have H ˜ ( W | SS ( W ) m ˜ . Since Ext is a average-case ( W , m ˜ , SK , ε e x t ) -strong extractor with a seed space I , then we have
SD ( ( Ext ( w , i ) , i , s = SS . Gen ( w ) ) , ( u , i , s = SS . Gen ( w ) ) ) ε e x t ,
where u $ SK .
Next we show that if there exists an adversary A that the difference between the probability of A winning in Game 1 and the probability of A winning in Game 2 is non-negligible, then we can construct an algorithm B that can distinguish ( Ext ( w , i ) , i , s = SS . Gen ( w ) ) and ( u , i , s = SS . Gen ( w ) ) with a non-negligible advantage. Assume that B is given ( d , i , s ) , where d is either Ext ( w , i ) or an element u $ SK . The aim of B is to tell which case it is. Adversary B proceeds as follows:
  • B invokes p p Setup ( 1 λ ) , sets p p F ( i , p p ) , then sets s k = d , computes v k KG ( p p , s k ) , and sets v k F ( s , v k ) . Next, it initializes the query set Q = , which denotes the set of queries selected by A . Afterwards, C returns ( p p F , v k F ) to A .
  • A may adaptively interact with the signing oracle in the following manner.
    • A submits a message m j M and a shift Δ w j W to B .
    • If dis ( Δ w j , 0 ) > t , B returns ⊥. Else, B parses p p F = ( i , p p ) , invokes s j s + SS . Gen ( Δ w j ) and s k j s k + Ext ( Δ w j , i ) , then sets M j ( m j , s j ) , invokes σ j Sign ( p p , s k j , M j ) , sets σ F , j ( s j , σ j ) , adds m j to the set Q , and returns σ F , j to A .
  • In the finalization phase, A outputs a forgery ( m , σ F ) . B parses p p F = ( i , p p ) , v k F = ( s , v k ) , σ F = ( s , σ ) , then sets M ( m , s ) , and computes Δ w f r e c ( s , s ) , Δ s k Ext ( Δ w , i ) , and v k A vk ( p p , v k , Δ s k ) . If m Q Verify ( p p , v k , M , σ ) = 1 , B returns 1; else, B returns 0.
If d = Ext ( w , i ) , then B accurately simulates Game 1 for A ; if d = u , where u $ SK , then B perfectly simulates Game 2 for A . As a result, we have
| Pr [ S 1 ] Pr [ S 2 ] | SD ( ( Ext ( w , i ) , i , s ) , ( u , i , s ) ) ε e x t .
The lemma follows. □
Lemma 5 
| Pr [ S 2 ] | Adv SIG key shift ( 1 λ ) .
Proof. 
We prove this lemma by showing that if there exists a PPT adversary A who wins in Game 2, then we can construct a PPT adversary B who can win in the key-shift* experiment of the underlying signature SIG .
  • Upon receiving ( p p , v k ) from its key-shift* challenger, B samples i $ I , w W , then calculates s = SS . Gen ( w ) , sets p p F ( i , p p ) , v k F ( s , v k ) , and returns ( p p F , v k F ) to adversary A .
  • When A makes a signing query on ( m j , Δ w j ) M × W , B responds to A ’s query in the following manner:
    • If dis ( Δ w j , 0 ) > t , B returns ⊥. Else, B computes Δ s k j Ext ( Δ w j , i ) and s j = s + SS . Gen ( Δ w j ) , sets M j = ( m j , s j ) , and sends ( M j , Δ s k j ) to its key-shift* challenger.
    • Upon receiving σ j from its key-shift* challenger, B sets σ F , j = ( s j , σ j ) and returns σ F , j to A .
  • In the finalization phase, A outputs a forgery ( m , σ F ) to B . B parses σ F = ( s , σ ) , sets M ( m , s ) , computes Δ w f r e c ( s , s ) and Δ s k Ext ( Δ w , i ) , submits ( M , σ ) and a shift Δ s k to its challenger, and returns what its challenger returns.
It is obvious that B perfectly simulates Game 2 for A . As a result, if A wins in Game 2, then B wins the key-shift* experiment. Consequently,
| Pr [ S 2 ] | Adv SIG key shift ( 1 λ ) .
Taking Equation (2) and Lemmas 3–5 together, we have
Adv SIG F , A m - EUF CMA ( 1 λ ) Adv SIG key shift ( 1 λ ) + ε e x t .
Theorem 2 follows.

5. Instantiation

In this section, we instantiate the generic construction presented in Section 4 using the Waters signature scheme. We choose the Waters signature scheme for this instantiation as it is one of the few schemes that simultaneously supports both the homomorphic property and key-shift* security—two desirable features that are seldom found together in existing signature schemes. To this end, we first recall SIG Wat , as depicted in Figure 4. Subsequently, we prove that SIG Wat is both homomorphic and key-shift* secure.
Waters [32] proved that the Waters signature scheme SIG Wat is EUF-CMA secure under the computational Diffie-Hellman (CDH) assumption in G (Further details regarding G can be found in Appendix C).
Theorem 3 
([32,33]). Suppose there exists a forger A that ( t , q , ϵ ) -breaks the EUF-CMA security of SIG Wat . Then, there exists an algorithm B ( ϵ , t ) -solving the computational Diffie–Hellman problem in G in time t t with success probability ϵ ϵ · O 1 q .
Lemma 6. 
SIG Wat is homomorphic. More precisely, A vk ( p p , v k , Δ s k ) = v k · g Δ s k , A Sign ( p p , m , ( σ 1 , σ 2 ) , Δ s k ) = ( h Δ s k · σ 1 , σ 2 ) .
Proof. 
We now show that SIG Wat is homomorphic by demonstrating that it satisfies Definition 14. It is straightforward to see that SIG Wat has a simple key-generation process,
v k = KG ( p p , s k ) = g s k .
  • Note that s k $ Z p . The signing key space SK = Z p , equipped with addition modulo p, constitutes an abelian group.
  • Note that KG ( p p , s k + Δ s k ) = g s k + Δ s k = g s k · g Δ s k = v k · g Δ s k , so there exsits a deterministic and efficient algorithm A vk , such that
    A vk ( p p , v k , Δ s k ) = v k · g Δ s k = KG ( p p , s k + Δ s k ) .
  • Given a message M and a fixed random number r $ Z p , the signature σ of M under signing key s k with random number r is
    σ = ( σ 1 = h s k · ( u · i [ l ] u i M i ) r , σ 2 g r ) .
    The signature σ ˜ of M under signing key s k + Δ s k with the same random number r is
    σ ˜ = ( σ 1 ˜ = h s k + Δ s k · ( u · i [ l ] u i M i ) r , σ 2 ˜ g r ) .
    Note that
    σ 1 ˜ = h s k + Δ s k · ( u · i [ l ] u i M i ) r = h s k · h Δ s k · ( u · i [ l ] u i M i ) r = h Δ s k · σ 1 ,
    and
    σ 2 = σ 2 ˜ .
    So there exisits a deterministic and efficient algorithm A Sign , such that
    A Sign ( p p , m , ( σ 1 , σ 2 ) , Δ s k ) = ( h Δ s k · σ 1 , σ 2 ) = Sign ( p p , s k + Δ s k , m , r ) .
    The lemma follows. □
It follows from Theorem 3 that SIG Wat achieves EUF-CMA security under the CDH assumption. Moreover, Lemma 6 demonstrates that SIG Wat possesses the homomorphic property. In addition, Lemma 2 states that any signature scheme that is both homomorphic and EUF-CMA secure also satisfies key- shift security. Therefore, by combining Theorem 3, Lemma 6, and Lemma 2, we derive the following corollary.
Corollary 1. 
SIG Wat is key- shift secure under the computational Diffie–Hellman (CDH) assumption in G .
We use the homomorphic average-case strong extractor Ext in Equation (1), the syndrome-based secure sketch introduced in Section 2.4, and the Waters signature scheme SIG Wat as fundamental components to instantiate the generic construction presented in Figure 2. The detailed construction is illustrated in Figure 5. This results in a fuzzy signature scheme SIG F that is secure under the CDH assumption over a bilinear group in the standard model. Moreover, the signing algorithm of this scheme does not require the verification key as extra input.
Corollary 2. 
The instantiation illustrated in Figure 5 constitutes a ( W , M , t ) - SIG F , for which m -EUF- CMA security is established in the standard model, assuming the hardness of the CDH problem in bilinear groups.

6. Future Work

One main limitation of our scheme is its reliance on pairing operations, which may impact efficiency in practice. Constructing a more efficient fuzzy signature scheme—potentially based on alternative assumptions such as lattices or hash-based primitives—is an important direction for future work.
Moreover, while our security model allows the adversary to choose errors adaptively, designing a fuzzy signature scheme in which the errors can be arbitrarily correlated with the biometric data itself remains an open and challenging problem.

Author Contributions

Conceptualization, Y.W.; Methodology, Y.W. and W.L.; Validation, T.J.; Investigation, T.J.; Writing—original draft, Y.W. and T.J.; Writing—review & editing, Y.W. and W.L.; Supervision, Y.W. and W.L. All authors have read and agreed to the published version of the manuscript.

Funding

This research was funded by National Natural Science Foundation of China (Grant No. 62102077) and the Shanghai Natural Science Foundation (Grant No. 24ZR1401300).

Data Availability Statement

Data are contained within the article.

Acknowledgments

We appreciate the editors and reviewers for their time and consideration in evaluating this paper.

Conflicts of Interest

The authors declare no conflicts of interest.

Appendix A. Syndrome-Based Secure Sketch

Recall that an efficiently decodable [ n , k , 2 t + 1 ] F linear error-correcting code C can correct up to t errors. This code is a linear subspace of F n with dimension k. The parity-check matrix H of C is an ( n k ) × n matrix whose rows span the orthogonal space C . For any vector w F n , the syndrome of w is defined as
syn ( w ) : = H w .
It is easy to verify that
w C syn ( w ) = 0 .
For any codeword c C and error vector e, we have
syn ( c + e ) = syn ( c ) + syn ( e ) = syn ( e ) .
A linear error-correcting code implies a syndrome-based secure sketch [20], which operates as follows:
  • Secure Sketch (SS):  SS ( w ) : = syn ( w ) = s .
  • Reconstruction (Rec):  Rec ( w , s ) : = w Decode ( syn ( w ) s ) .

Appendix B. RKA Security

Here, we revisit the definition of RKA security for signature schemes, as proposed by Bellare et al. [31].
Definition A1 (RKA Security). 
A signature scheme SIG = ( Setup , KeyGen , Sign , Verify ) is Φ-RKA secure if for all PPT adversaries A , it holds that
Adv SIG , A Φ RKA ( 1 λ ) : = Pr [ Expt SIG , A Φ RKA ( 1 λ ) 1 ] negl ( λ ) ,
where Expt SIG , A Φ RKA ( 1 λ ) , defined as follows, is an experiment played between an adversary A and a challenger C .
Expt SIG , A Φ RKA ( 1 λ ) :
1. 
The challenger C runs p p Setup ( 1 λ ) , computes ( v k , s k ) KeyGen ( p p ) , then initializes Q = , which denotes the set of queries selected by A . Afterwards, C returns p p and v k to A .
2. 
Over the course of the experiment, A is allowed to adaptively make signing oracle queries in the following form:
  • A sends a message m j M and a funcition ϕ j Φ to the challenger C .
  • C computes σ j Sign ( p p , ϕ j ( s k ) , m j ) , adds m j to the query set Q , and replies to A with σ j .
3. 
In the final phase, A outputs a candidate forgery in the form of a message–signature pair ( m , σ ) . The experiment returns 1 if m Q Verify ( p p , v k , m , σ ) = 1 ; otherwise, it returns 0.

Appendix C. Bilinear Groups

We define a tuple BG = ( p , G , G T , g , e ) to be a symmetric bilinear group if the following conditions are satisfied:
  • p is a prime number;
  • G and G T are cyclic groups of order p;
  • g is a generator of G ;
  • e : G × G G T is a bilinear map computable in time polynomial in | p | , satisfying the following:
    Bilinearity: For all g G and a , b Z p , we have
    e ( g a , g b ) = e ( g , g ) a b .
    Non-degeneracy: For all generators g of G , e ( g , g ) is not the identity in G T .
For simplicity, we let BGGen denote an algorithm—known as a “bilinear group generator”—which, on input 1 λ , returns a bilinear group description BG = ( p , G , G T , g , e ) such that | p | = Θ ( λ ) .

References

  1. Kaur, R.; Kaur, A. Digital signature. In Proceedings of the 2012 International Conference on Computing Sciences, Phagwara, India, 14–15 September 2012; IEEE: Piscataway, NJ, USA, 2012; pp. 295–301. [Google Scholar] [CrossRef]
  2. Yin, H.L.; Fu, Y.; Li, C.L.; Weng, C.X.; Li, B.H.; Gu, J.; Lu, Y.S.; Huang, S.; Chen, Z.B. Experimental quantum secure network with digital signatures and encryption. Natl. Sci. Rev. 2023, 10, nwac228. [Google Scholar] [CrossRef] [PubMed]
  3. Alzubi, J.A. Blockchain-based Lamport Merkle digital signature: Authentication tool in IoT healthcare. Comput. Commun. 2021, 170, 200–208. [Google Scholar] [CrossRef]
  4. Jiang, Q.; Ma, J.; Li, G.; Li, X. Improvement of robust smart-card-based password authentication scheme. Int. J. Commun. Syst. 2015, 28, 383–393. [Google Scholar] [CrossRef]
  5. Lu, H.K. Network smart card review and analysis. Comput. Netw. 2007, 51, 2234–2248. [Google Scholar] [CrossRef]
  6. Wala’a, M.A.; Abusaimeh, H. Modified USB Security Token for User Authentication. Comput. Inf. Sci. 2015, 8, 51–63. [Google Scholar] [CrossRef]
  7. Jiang, L.; Li, X.; Cheng, L.; Guo, D. Identity authentication scheme of cloud storage for user anonymity via USB token. In Proceedings of the 2013 International Conference on Anti-Counterfeiting, Security and Identification (ASID), Shanghai, China, 25–27 October 2013; IEEE: Piscataway, NJ, USA, 2013; pp. 1–6. [Google Scholar] [CrossRef]
  8. Takahashi, K.; Matsuda, T.; Murakami, T.; Hanaoka, G.; Nishigaki, M. A signature scheme with a fuzzy private key. In Applied Cryptography and Network Security, Proceedings of the International Conference on Applied Cryptography and Network Security, New York, NY, USA, 2–5 June 2015; Malkin, T., Kolesnikov, V., Lewko, A., Polychronakis, M., Eds.; LNCS; Springer: Cham, Switzerland, 2015; Volume 9092, pp. 105–126. [Google Scholar] [CrossRef]
  9. Tan, J.; Bauer, L.; Bonneau, J.; Cranor, L.F.; Thomas, J.; Ur, B. Can Unicorns Help Users Compare Crypto Key Fingerprints? In Proceedings of the 2017 CHI Conference on Human Factors in Computing Systems, CHI’17, Denver, CO, USA, 6–11 May 2017; Association for Computing Machinery: New York, NY, USA, 2017; pp. 3787–3798. [Google Scholar] [CrossRef]
  10. Yoon, S.; Jain, A.K. Longitudinal study of fingerprint recognition. Proc. Natl. Acad. Sci. USA 2015, 112, 8555–8560. [Google Scholar] [CrossRef]
  11. Omolara, A.E.; Jantan, A.; Abiodun, O.I.; Arshad, H.; Mohamed, N.A. Fingereye: Improvising security and optimizing ATM transaction time based on iris-scan authentication. Int. J. Electr. Comput. Eng. 2019, 9, 1879–1886. [Google Scholar] [CrossRef]
  12. Matsuda, T.; Takahashi, K.; Murakami, T.; Hanaoka, G. Fuzzy signatures: Relaxing requirements and a new construction. In Applied Cryptography and Network Security, Proceedings of the International Conference on Applied Cryptography and Network Security, Guildford, UK, 19–22 June 2016; Manulis, M., Sadeghi, A.R., Schneider, S., Eds.; LNCS; Springer: Cham, Switzerland, 2016; Volume 9696, pp. 97–116. [Google Scholar] [CrossRef]
  13. Schnorr, C.P. Efficient identification and signatures for smart cards. In Advances in Cryptology—CRYPTO’ 89 Proceedings, Proceedings of the 9th Annual International Cryptology Conference, Santa Barbara, CA, USA, 20–24 August 1989; Brassard, G., Ed.; LNCS; Springer: Cham, Switzerland, 1990; Volume 435, pp. 239–252. [Google Scholar] [CrossRef]
  14. Katsumata, S.; Matsuda, T.; Nakamura, W.; Ohara, K.; Takahashi, K. Revisiting fuzzy signatures: Towards a more risk-free cryptographic authentication system based on biometrics. In Proceedings of the 2021 ACM SIGSAC Conference on Computer and Communications Security, CCS ’21, Virtual, 15–19 November 2021; Association for Computing Machinery: New York, NY, USA, 2021; pp. 2046–2065. [Google Scholar] [CrossRef]
  15. Peikert, C. A decade of lattice cryptography. Found. Trends® Theor. Comput. Sci. 2016, 10, 283–424. [Google Scholar] [CrossRef]
  16. Odlyzko, A. Discrete logarithms in finite fields and their cryptographic significance. In Advances in Cryptology, Proceedings of the Workshop on the Theory and Application of of Cryptographic Techniques, Paris, France, 9–11 April 1984; Beth, T., Cot, N., Ingemarsson, I., Eds.; LNCS; Springer: Cham, Switzerland, 1984; Volume 209, pp. 224–314. [Google Scholar] [CrossRef]
  17. Koblitz, N.; Menezes, A.J. The random oracle model: A twenty-year retrospective. Des. Codes Cryptogr. 2015, 77, 587–610. [Google Scholar] [CrossRef]
  18. Song, J.; Wen, Y. A generic construction of fuzzy signature. In Information Security and Cryptology, Proceedings of the International Conference on Information Security and Cryptology, Virtual,12–14 August 2021; Yu, Y., Yung, M., Eds.; LNCS; Springer: Cham, Switzerland, 2021; Volume 13007, pp. 23–41. [Google Scholar] [CrossRef]
  19. Bein, B. Entropy. Best Pract. Res. Clin. Anaesthesiol. 2006, 20, 101–109. [Google Scholar] [CrossRef] [PubMed]
  20. Dodis, Y.; Reyzin, L.; Smith, A.D. Fuzzy extractors: How to generate strong keys from biometrics and other noisy data. In 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.; LNCS; Springer: Cham, Switzerland, 2004; Volume 3027, pp. 523–540. [Google Scholar] [CrossRef]
  21. Joux, A.; Nguyen, K. Separating decision Diffie–Hellman from computational Diffie–Hellman in cryptographic groups. J. Cryptol. 2003, 16, 239–247. [Google Scholar] [CrossRef]
  22. Tian, Y.; Li, Y.; Deng, R.; Sengupta, B.; Yang, G. Lattice-based remote user authentication from reusable fuzzy signature. J. Comput. Secur. 2021, 29, 273–298. [Google Scholar] [CrossRef]
  23. Apon, D.; Cho, C.; Eldefrawy, K.; Katz, J. Efficient, reusable fuzzy extractors from LWE. In Cyber Security Cryptography and Machine Learning, Proceedings of the first International Conference, CSCML 2017, Beer-Sheva, Israel, 29–30 June 2017; Dolev, S., Lodha, S., Eds.; LNCS; Springer: Cham, Switzerland, 2017; Volume 10332, pp. 1–18. [Google Scholar] [CrossRef]
  24. Wen, Y.; Liu, S. Reusable fuzzy extractor from LWE. In Information Security and Privacy, Proceedings of the ACISP 2018, Wollongong, NSW, Australia, 11–13 July 2018; Susilo, W., Yang, G., Eds.; LNCS; Springer: Cham, Switzerland, 2018; Volume 10946, pp. 13–27. [Google Scholar] [CrossRef]
  25. Zhou, Y.; Liu, S.; Han, S. Robustly Reusable Fuzzy Extractor from Isogeny. Theor. Comput. Sci. 2024, 1008, 114677. [Google Scholar] [CrossRef]
  26. Lyubashevsky, V. Lattice signatures without trapdoors. In Advances in Cryptology—EUROCRYPT 2012, Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, Cambridge, UK, 15–19 April 2012; Springer: Cham, Switzerland, 2012; Volume 7237, pp. 738–755. [Google Scholar] [CrossRef]
  27. Zheng, M.; Liu, Z.; Mambo, M. A Provably Secure Lattice-Based Fuzzy Signature Scheme Using Linear Sketch. IEEE Access 2023, 11, 62510–62521. [Google Scholar] [CrossRef]
  28. Wang, S.; Zhu, Y.; Ma, D.; Feng, R. Lattice-based key exchange on small integer solution problem. Sci. China Inf. Sci. 2014, 57, 1–12. [Google Scholar] [CrossRef]
  29. Wen, Y.; Liu, S. Robustly reusable fuzzy extractor from standard assumptions. In Advances in Cryptology—ASIACRYPT 2018, Proceedings of the International Conference on the Theory and Application of Cryptology and Information Security, Brisbane, QLD, Australia, 2–6 December 2018; Peyrin, T., Galbraith, S., Eds.; LNCS; Springer: Cham, Switzerland, 2018; Volume 11274, pp. 459–489. [Google Scholar] [CrossRef]
  30. Shoup, V. A Computational Introduction to Number Theory and Algebra; Cambridge University Press: Cambridge, UK, 2006. [Google Scholar]
  31. Bellare, M.; Cash, D.; Miller, R. Cryptography Secure against Related-Key Attacks and Tampering. In Advances in Cryptology—ASIACRYPT 2011, Proceedings of the 17th International Conference on the Theory and Application of Cryptology and Information Security, Seoul, Republic of Korea, 4–8 December 2011; Lee, D.H., Wang, X., Eds.; Lecture Notes in Computer Science; Springer: Cham, Switzerland, 2011; Volume 7073, pp. 486–503. [Google Scholar] [CrossRef]
  32. Waters, B. Efficient identity-based encryption without random oracles. In Advances in Cryptology—EUROCRYPT 2005, Proceedings of the Annual International Conference on the Theory and Applications of Cryptographic Techniques, Aarhus, Denmark, 22–26 May 2005; Springer: Cham, Switzerland, 2005; Volume 3494, pp. 114–127. [Google Scholar] [CrossRef]
  33. Hofheinz, D.; Jager, T.; Knapp, E. Waters Signatures with Optimal Security Reduction. In Public Key Cryptography—PKC 2012, Proceedings of the 15th International Conference on Practice and Theory in Public Key Cryptography, Darmstadt, Germany,21–23 May 2012; Fischlin, M., Buchmann, J., Manulis, M., Eds.; Springer: Cham, Switzerland, 2012; Volume 7293, pp. 66–83. [Google Scholar] [CrossRef]
Figure 1. Fuzzy signature SIG F . The public parameters p p are omitted for brevity.
Figure 1. Fuzzy signature SIG F . The public parameters p p are omitted for brevity.
Axioms 14 00613 g001
Figure 2. Generic construction of fuzzy signature scheme SIG F .
Figure 2. Generic construction of fuzzy signature scheme SIG F .
Axioms 14 00613 g002
Figure 3. An overview of our construction of fuzzy signature. We have omitted p p for brevity.
Figure 3. An overview of our construction of fuzzy signature. We have omitted p p for brevity.
Axioms 14 00613 g003
Figure 4. Waters signature scheme SIG Wat .
Figure 4. Waters signature scheme SIG Wat .
Axioms 14 00613 g004
Figure 5. Instantiation of fuzzy signature scheme SIG F from secure sketch.
Figure 5. Instantiation of fuzzy signature scheme SIG F from secure sketch.
Axioms 14 00613 g005
Table 1. An overview of representative fuzzy signature schemes. “ SIG F ” is the abbreviation of fuzzy signature scheme. “Method” represents the primary cryptographic primitive utilized in the construction of SIG F . “Correlation” explains the relationship between the error distribution e and the biometric information W, where e captures the deviation between the fuzzy signing key s k and s k (i.e., two readings derived from identical biometric input W). “ v k ” indicates that the signing algorithm does not need v k as input. “Assumption” specifies the cryptographic assumption underlying the SIG F . “Standard Model” asks whether the SIG F achieves security in the standard model.
Table 1. An overview of representative fuzzy signature schemes. “ SIG F ” is the abbreviation of fuzzy signature scheme. “Method” represents the primary cryptographic primitive utilized in the construction of SIG F . “Correlation” explains the relationship between the error distribution e and the biometric information W, where e captures the deviation between the fuzzy signing key s k and s k (i.e., two readings derived from identical biometric input W). “ v k ” indicates that the signing algorithm does not need v k as input. “Assumption” specifies the cryptographic assumption underlying the SIG F . “Standard Model” asks whether the SIG F achieves security in the standard model.
SIG F MethodCorrelation v k AssumptionStandard
Model
TMMHN15 [8]Linear SketchIndependentCDH
MTMH16 [12]Linear SketchIndependentDL
KK21 [14]Linear SketchIndependentDL
ZLM23 [27]Linear SketchIndependentSIS
SW21 [18]Fuzzy ExtractorArbitraryCDH
TLDSY21 [22]Fuzzy ExtractorAdversary-SelectedLWE, SIS
Our SchemeSecure SketchAdversary-SelectedCDH
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

Wen, Y.; Jin, T.; Li, W. Fuzzy Signature from Computational Diffie–Hellman Assumption in the Standard Model. Axioms 2025, 14, 613. https://doi.org/10.3390/axioms14080613

AMA Style

Wen Y, Jin T, Li W. Fuzzy Signature from Computational Diffie–Hellman Assumption in the Standard Model. Axioms. 2025; 14(8):613. https://doi.org/10.3390/axioms14080613

Chicago/Turabian Style

Wen, Yunhua, Tianlong Jin, and Wei Li. 2025. "Fuzzy Signature from Computational Diffie–Hellman Assumption in the Standard Model" Axioms 14, no. 8: 613. https://doi.org/10.3390/axioms14080613

APA Style

Wen, Y., Jin, T., & Li, W. (2025). Fuzzy Signature from Computational Diffie–Hellman Assumption in the Standard Model. Axioms, 14(8), 613. https://doi.org/10.3390/axioms14080613

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