Next Article in Journal
VBTCKN: A Time Series Forecasting Model Based on Variational Mode Decomposition with Two-Channel Cross-Attention Network
Previous Article in Journal
Nonlinear Hydrogen Bond Network in Small Water Clusters: Combining NMR, DFT, FT-IR, and EIS Research
 
 
Font Type:
Arial Georgia Verdana
Font Size:
Aa Aa Aa
Line Spacing:
Column Width:
Background:
Article

Reusable Fuzzy Extractor from Isogeny-Based Assumptions

School of Computer Science and Technology, Donghua University, Shanghai 201620, China
*
Author to whom correspondence should be addressed.
Symmetry 2025, 17(7), 1065; https://doi.org/10.3390/sym17071065
Submission received: 12 June 2025 / Revised: 29 June 2025 / Accepted: 2 July 2025 / Published: 4 July 2025

Abstract

A fuzzy extractor is a foundational cryptographic component that enables the extraction of reproducible and uniformly random strings from sources with inherent noise, such as biometric traits. Reusable fuzzy extractor guarantees the security of multiple extractions from the same noisy source. In addition, although isogeny-based cryptography has become an important branch in post-quantum cryptography, the study of fuzzy extractors based on isogeny assumptions is still in its early stages and holds much room for improvement. In this paper, we give two reusable fuzzy extractor schemes derived from isogeny-based assumptions: one is based on the linear hidden shift assumption over group actions, while the other is built upon the group-action decisional Diffie–Hellman assumption within the isogeny framework. Both proposed constructions achieve post-quantum security and are capable of correcting a linear proportion of errors. They rely solely on fundamental cryptographic primitives, which ensure simplicity and efficiency. Additionally, the second construction is based on restricted effective group action, which is weaker than the effective group action used in the first construction, thereby offering greater practical applicability.

1. Introduction

In cryptography, many cryptographic primitives, whether in symmetric or asymmetric cryptography, rely on keys that are uniformly random and exactly reproducible to ensure security. Nonetheless, generating such keys is a challenging task. Additionally, despite the fact that numerous noisy sources are available, they are usually unsuitable for direct use due to the noise. Since we aim to derive the same secret key in each generation phase, we ideally expect a symmetric process. However, due to the presence of noise, the reconstruction must handle an inherent asymmetry in the input data, ultimately achieving a goal that appears symmetric in effect. In view of this situation, the term of fuzzy extractor (FE) was initially articulated by Dodis et al. [1] in 2004, which offers a solution to the problem of how to reliably generate and accurately reproduce a uniformly random cryptographic key from noisy sources, such as biometric features [2,3] (e.g., fingerprints and iris scans), physical unclonable functions (PUFS) [4], and quantum information [5].

1.1. Fuzzy Extractor and Reusable Fuzzy Extractor

1.1.1. Fuzzy Extractor

The core of an FE consists of two procedures. One is the generation function Gen( w ), which receives a reading w of the noisy source and produces a string R along with a public help string P; the other is the reproduction function Rep( w , P), which takes a new reading w and P as input. The security of the FE ensures that if w has sufficient entropy, the output string R remains uniformly random from the adversary’s perspective, even if the public help string P is accessible to the adversary. Moreover, as long as dis ( w , w ) < t , Rep( w , P) will output R with overwhelming probability. Then, its correctness is guaranteed.

1.1.2. Reusable Fuzzy Extractor

Nevertheless, the original FE can merely guarantee the security of a single extraction. Repeated extraction of the same noisy source will compromise security. Hence, Boyen [6] put forward the idea of reusable fuzzy extractor (RFE), which can overcome the aforementioned drawbacks and significantly enhance security. Specifically, RFE ensures such security by invoking fuzzy extractor’s generation algorithm Gen( w j ) to generate multiple pairs of { P j , R j } j [ ρ ] for different readings { w j } j [ ρ ] from the same noisy source; even if any other multiple pairs of { P j , R j } j i and P i are exposed to the adversary, R i still remains pseudo-random from the perspective of the adversary.
In 2016, Canetti et al. [7] introduced an RFE designed for low-entropy distributions, which is based on digital lockers and capable of handling binary strings with Hamming noise. Nonetheless, their construction can only withstand a sublinear proportion of errors and relies on a non-standard assumption.
In 2018, Wen et al. [8] presented the first strongly RFE from the DDH assumption. Later, they [9] constructed another RFE built upon the LWE assumption, which is capable of withstanding a linear proportion of errors. Subsequently, they first formalized the notion of a robustly reusable fuzzy extractor (RRFE) and constructed the first RRFE under the DDH assumption and DLIN assumption over pairing groups [10]. In 2019, they [11] proposed another two RRFEs from LWE and DDH in groups without pairings, respectively.
In 2020, Li et al. [12] presented another RFE based on the LPN assumption. Their construction serves as a post-quantum secure RFE and is more efficient than previous work.
Recently, Zhou et al. proposed the first RRFE [13] and the first RFE [14] from isogeny, both of which rely on the weak pseudo-randomness of CSI-FiSh [15]. Their constructions also support the linear fraction of errors.

1.2. Isogeny-Based Cryptography and Isogeny-Based Assumptions

Advances in quantum computing have greatly promoted the rise of post-quantum cryptography [16,17]. Lattice-based hard assumptions [18,19] are a promising class of quantum-resistant problems, and lattice-based cryptographic research [20] dominates a significant portion of post-quantum cryptography. This makes post-quantum cryptography lack sufficient diversity [13,21]. Isogeny-based cryptography represents another viable non-lattice-based alternative for post-quantum secure cryptosystems [22,23]. One of the most famous protocols based on isogeny is Supersingular Isogeny Diffie–Hellman (SIDH), proposed by Jao and De Feo [24]. However, SIDH is vulnerable to certain quantum attacks [25,26], and its efficiency and security continue to be areas of active research [27]. In 2018, Castryck et al. [28] introduced Commutative Supersingular Isogeny Diffie–Hellman (CSIDH), which simplifies the SIDH protocol and provides a more efficient key exchange mechanism. Building on the CSIDH protocol, CSI-FiSh was proposed as a signature scheme by Beullens et al. [15] in 2019. Later, Alamati et al. [21] established a novel framework built on group actions, allowing for the straightforward usage of various isogeny-based assumptions.

1.2.1. Linear Hidden Shift Assumption

The linear hidden offset (LHS) problem over group actions was first proposed by Alamati et al. in [21], where they formally defined the LHS assumption and analyzed its security. They imply that the LHS assumption is secure in (restricted) effective group action (e.g., CSIDH and CSI-Fish, which are based on supersingular elliptic curves). In addition, they showed that the LHS assumption enables the realization of many cryptographic applications, including symmetric KDM-CPA secure encryption, trapdoor functions, and designated-verifier non-interactive zero-knowledge (NIZK) proofs. Later, Alamati et al. [29] constructed the new trapdoor claw-free functions (TCFS) based on the LHS assumption, which is the first post-quantum secure candidate that operates independently of lattice-related problems. Recently, Alamati et al. [30] designed another two cryptographic primitives with hinting properties from the LHS assumption, including hinting pseudo-random generators (PRGS) and hinting weak pseudo-random functions (WPRFS).

1.2.2. Group Action Decisional Diffie–Hellman Assumption

Similar to the DDH assumption, the GA-DDH assumption is the corresponding hard problem over isogeny-based group actions, which makes its first formal appearance in Stolbunov’s PhD thesis [31] and has attracted widespread research interest in recent years. In 2020, Castryck et al. [32] proposed an efficient attack to break the GA-DDH assumption for all supersingular elliptic curves over F p with p 1   mod   4 . However, this attack does not extend to the case where p 3   mod   4 , which is precisely the setting used in CSIDH. Hence, it is generally accepted that the GA-DDH assumption holds for CSIDH [28,33]. So far, many cryptographic primitives based on it have emerged, including verifiable random functions (VRF) [34], oblivious pseudo-random functions (OPRF) [35], key encapsulation mechanisms (KEM) [36], etc.
From our perspective, the application of the LHS assumption or GA-DDH assumption in constructing post-quantum secure cryptographic schemes in the isogeny setting exhibits considerable potential and academic merits. In addition, as far as we know, no reusable fuzzy extractor built upon LHS or GA-DDH assumptions has been constructed. Inspired by the above process, an obvious question comes to mind:
Is it feasible to construct an RFE utilizing either the LHS assumption or the GA-DDH assumption?

1.3. Our Contributions

In this work, we provide a confirmed answer to the aforementioned question. The principal contributions of our work are as follows:
First, we extend the LHS n l assumption to the LHS n ρ l assumption via a hybrid argument. Similar to [13], we redefine the reusable fuzzy extractor and introduce an extra initialization algorithm to make it more adaptable to isogeny-based assumptions.
We give two constructions of RFE from isogeny-based assumptions. Our first construction is the first reusable fuzzy extractor based on the LHS assumption over isogeny-based group actions. Our second construction is the first reusable fuzzy extractor built upon the GA-DDH assumption. Furthermore, we instantiate both constructions based on specific instances of the underlying building blocks.
Both of our constructions are straightforward and resilient to the linear proportion of errors. In addition, compared with some previous works on reusable fuzzy extractor, our constructions impose no additional requirements (i.e., homomorphism or key-offset security) on the building blocks.
In Table 1, we present a comparison between our constructions and existing reusable fuzzy extractor schemes.

1.4. Challenges and Our Approaches

As we all know, the reusability of many mainstream RFEs relies heavily on the homomorphic property of the underlying cryptographic primitives or the hardness assumptions that have properties similar to key-shift security [8,9,12,14]. Nevertheless, in the context of isogeny, either the set X has no operations (as discussed in [13]), or the same operations are not defined in the same domain (e.g., the “+” in the LHS assumption, M ( k + Δ ) M k + M Δ , “+” on the left is over F 2 , and the right is in group G ), which makes it difficult to construct reusable fuzzy extractors or fuzzy extractors with stronger security (i.e., robustly reusable fuzzy extractors) from isogeny by conventional means.
To facilitate the use of isogeny assumptions and minimize the requirements on the underlying building blocks, we adopt the approach proposed in [13] and redefine reusable fuzzy extractor. Our modification introduces only an initialization algorithm while preserving the core structure of the traditional RFE. In our construction, the overhead of this initialization algorithm is minimal, as each user invokes it only once, requiring just a single additional execution of the secure sketch generation procedure SS . Gen .

1.4.1. Construction 1: RFE from LHS Assumption

For the first construction, we just utilize a secure sketch, universal hash functions, and an effective group action (EGA) as the key components. In RFE.Config, we incorporate the uniformly random selected hash function H i along with certain public parameters of the EGA into crs (public and unmodifiable). During the phase of RFE.Init, SS . Gen will produce a s , which is stored in the public help string P init and enables the recovery of w in subsequent algorithms. In the RFE.Gen, we first use the sketch s to recover w as long as the new reading w satisfies dis ( w , w ) < t . Later, H i will take w as input. The generated k ( H i ( w ) ) will serve as a crucial component of the LHS assumption. Subsequently, we uniformly and randomly sample M from G l × n and x from the set X l . The EGA and its regularity property guarantee the efficiency of this sampling process. Next, M and x are put into the public help string P. Under the LHS hypothesis, m cannot be distinguished from uniformly random elements in X l , which is crucial for ensuring reusability. Similar to RFE.Gen, by relying on the correctness of the security sketch and some public parameters, the RFE.Rep algorithm can always regenerate R.

1.4.2. Construction 2: RFE from GA-DDH Assumption

Our second construction follows the same framework as construction 1, making the overall process somewhat similar. However, there are notable differences in the details. First, by leveraging restricted effective group action (REGA, where the GA-DDH assumption is conjectured to hold), construction 2 achieves greater practicality compared to construction 1 (EGA is more powerful than REGA). Furthermore, in our specific construction, we employ a secure sketch, an average-case strong extractor, and a family of universal hash functions. The combination of the latter two primitives, along with the special leftover hash lemma, is the key to our reusability. The detailed information is presented in Section Section 3.3.

2. Preliminaries

This section is organized as follows. We first introduce the notational conventions used throughout the paper, followed by the definitions of cryptographic primitives and security notions that form the basis of our constructions and security proofs.

2.1. Basic Notation

In our notation, normal, bold, and capital bold letters, like x, x , and X , are used to represent an element, column vector, and matrix, respectively. Let λ be the security parameter. For a column vector x, let x i denote the i-th element of x. Given a matrix M , let M denote the transpose of M . For a l 1 × n matrix M 1 and a l 2 × n matrix M 2 , we use [ M 1 , M 2 ] to denote the ( l 1 + l 2 ) × n matrix [ M 1 M 2 ] . Let [ ρ ] denote the set { 1 , 2 , , ρ } . The interval [ m , n ] refers to the set { m , m + 1 , , n } . Let x X indicate that x is drawn from the distribution X. For two random variables, X and Y, X ε s ( c ) Y signifies that these two random variables are statistically (computationally) indistinguishable, with a maximum distinguishing advantage of ε , if ε = 0 ; the notation can be simplified as X s ( c ) Y . For a set X , we write x $ X to indicate that x is selected uniformly from X . | X | refers to the size of the set. PPT stands for probabilistic polynomial-time. Let   log 2 ( · )   be   denoted   by   log ( · ) . Our security proof follows a game-based approach. Here, G⇒ 1 signifies that the outcome of game G is 1.
Considering a cryptographic primitive XX and its corresponding security requirement YY, we denote by Exp XX , A YY ( 1 λ ) 1 that the security experiment returns 1 after the interaction with the adversary A . The term Adv XX , A YY ( 1 λ ) denotes adversary A ’s advantage within the context of this security experiment, that is, Adv XX YY ( 1 λ ) : = max PPT   A Adv XX , A YY ( 1 λ ) .

2.2. Metric Spaces

Definition 1 
(Metric spaces [1]). A metric space consists of a set M , along with a distance function dis : M × M R + { 0 } , which defines the distance between its elements (e.g., the Hamming distance, which denotes the number of positions at which two strings of equal length differ).

2.3. Min-Entropy and Statistical Distance

Definition 2 
(Min-entropy [1]). Let X be a discrete random variable; the min-entropy of X is defined as H ( X ) = log max x X Pr [ X = x ] .
Definition 3 
(Average min-entropy [1]). Considering two discrete random variables X and Z, the average min-entropy of X given Z is defined as
H ˜ ( X | Z ) = log E z Z ( max x X Pr X = x Z = z ) .
Definition 4 
(Statistical distance [1]). Considering X, Y be two random variables defined over a set M , the statistical distance of X and Y is given by SD ( X , Y ) = 1 2 w M | Pr X = w Pr Y = w | .

2.4. Universal Hashing

Definition 5 
(Universal hash functions [1]). A family of hash functions H = { H i : X Y   |   i I } is called universal if for all/any distinct inputs x 1 , x 2 X , we have Pr i $ I H i ( x 1 ) = H i ( x 2 ) 1 | Y | .
Lemma 1 
(Generalized leftover hash lemma [1]). If H = { H i : X Y   |   i I } is a family of universal hash functions, then for any random variable W taking values in X and any random variable Z, we have
SD ( ( H I ( W ) , I , Z ) , ( U , I , Z ) ) 1 2 2 H ˜ ( W | Z ) | Y | ,
where I and U follow uniform distributions over the sets I and Y .
Here, we introduce the following special case of a leftover hash lemma [21,30], with its proof provided in [38].
Lemma 2. 
Let G be an abelian group under addition with the order | G | = λ ω ( 1 ) , and let n Z such that n > log | G | + ω ( log λ ) . If r $ G n , t $ { 0 , 1 } n , and u $ G , it is evident that ( r , i = 1 n t i r i ) ε s ( r , u ) , where ε = | G | / 2 n 2 ω ( log λ ) .

2.5. Secure Sketch and Average-Case Strong Extractor

Definition 6 
(Secure sketch [1]). An ( M , m , m ^ , t ) -secure sketch ( SS ) consists of two PPT algorithms ( SS . Gen , SS . Rec ) with the following specifications.
SS . Gen ( w ) takes w M as input and outputs a sketch s S ;
SS . Rec ( w , s ) takes w M and a sketch s as input and outputs w ˜ .
It also satisfies the following properties:
Correctness: If dis ( w , w ) t , then
w = SS . Rec ( w , SS . Gen ( w ) ) = w ˜ .
Security: For any distribution W over M ,
H ˜ ( W SS . Gen ( W ) ) > m ^   if   H ( W ) > m .
An instantiation of SS was introduced in [1], which achieves information-theoretic security. For completeness, we restate it in Section Section 4.1.
Definition 7 
(Average-case strong extractor [1]). A function Ext : M × K T is an average-case ( M , m , T , ε e x t ) -strong extractor with seed K K if for any variable W over M and variable Y such that H ˜ ( W | Y ) > m , we have SD ( ( Ext ( W , K ) , K , Y ) , ( U , K , Y ) ) ε e x t , where K and U are uniformly distributed over K and T , respectively.

2.6. Group Action, LHS Assumption, and GA-DDH Assumption

For the sake of clarity and abstraction, prior research has resorted to modeling certain isogeny-based constructions through group actions [21,29,30]. In the following, we provide a brief overview of cryptographic group actions and isogeny assumptions.
Definition 8 
(Group action [21]). Let ( G , + ) be a group that acts on X , with a mapping from G × X to X satisfying the following conditions:
1. 
Identity: For the identity element e of G , e x = x for all x X ;
2. 
Compatibility: For all g , h G and x X , we have ( g + h ) x = g ( h x ) .
According to [30], it is reasonable to use the symbol + to represent the binary operation in G within this paper. Here, we concentrate on group actions that are both abelian and regular both   free   and   transitive , as considered in prior works [13,30]. More precisely, we have the following:
1. 
Abelian: The group G is abelian;
2. 
Transitive: For any x 1 , x 2 X , there is a group element g G satisfying x 2 = g x 1 ;
3. 
Free: A group element g G is the identity element if x = g x for some x X .
Remark 1. 
For a regular group action, the map f x : g g x creates a bijection between G and X for any x X .
Definition 9 
(Effective group action [21,30]). An effective group action EGA ( G , X , , x ˜ ) is a group action that satisfies some properties described below:
1. 
G is a finite group, and efficient algorithms are available for membership testing, equality testing, random sampling, group operation, and inversion;
2. 
X is a finite set, and known algorithms efficiently handle membership testing and compute the unique bit-string representation for every element in X ;
3. 
There is a distinguished element x ˜ X , known as the origin, whose bit-string representation is available;
4. 
For any g G and x X , efficient algorithms can compute g x .
As stated in [13], we can obtain a regular and abelian EGA from CSI-FiSh [15].
Definition 10 
(Linear hidden shift assumption [21,29,30]). For an EGA ( G , X , , x ˜ ) , and let n Z such that n > log | G | + ω ( log λ ) . The LHS n l assumption is ϵ 1 -hard if for any PPT adversary A and any l = p o l y ( λ ) , it holds that,
Adv LHS , A l , n ( 1 λ ) : =     | Pr A ( x , M , Mk x ) 1 Pr A ( x , M , u ) 1 | ϵ 1 ,
where x $ X l , M $ G l × n , k $ { 0 , 1 } n and u $ X l .
By using a hybrid argument, we have the following lemma.
Lemma 3. 
For an EGA ( G , X , , x ˜ ) , and let n Z such that n > log | G | + ω ( log λ ) , l = poly ( λ ) . If the LHS n l assumption is ϵ 1 -hard over the EGA, then the LHS n ρ l assumption is ρ ϵ 1 -hard. More precisely, for every PPT adversary A ,
Adv LHS , A ρ l , n ( 1 λ ) : =   | Pr A ( x , M , Mk x ) 1 Pr A ( x , M , u ) 1 | ρ ϵ 1 ,
where x $ X ρ l , M $ G ρ l × n , k $ { 0 , 1 } n and u $ X ρ l .
Proof. 
Let M = [ M 1 , M 2 , , M ρ ] , x = [ x 1 , x 2 , , x ρ ] , and u = [ u 1 , u 2 , , u ρ ] , where x i $ X l , M i $ G l × n , and u i $ X l for i [ ρ ] . Let
Z ρ = ( x , M , [ M 1 k x 1 , M 2 k x 2 , , M ρ k x ρ ] ) , Z ρ 1 = x , M , [ M 1 k x 1 ,   M 2 k x 2 ,   , M ρ 1 k x ρ 1 ,   u ρ ] ,   Z i = x , M , [ M 1 k x 1 ,   M 2 k x 2 ,   ,   M i k x i ,   u i + 1 ,   ,   u ρ ] ,   Z 1 = x , M , [ M 1 k x 1 ,   u 2 ,   ,   u ρ ] , Z 0 = x , M , [ u 1 ,   u 2 ,   ,   u ρ ] .
Then, we get
| Pr A ( x , M , Mk x ) 1 Pr A ( x , M , u ) 1 | = | Pr A ( Z ρ ) 1 Pr A ( Z 0 ) 1 | i = 0 ρ 1 | Pr A ( Z i + 1 ) 1 Pr A ( Z i ) 1 | ρ ϵ 1 .
While an EGA serves as a useful abstraction, it may sometimes be too powerful compared to what is practically achievable. A restricted effective group action (REGA) can be seen as a more limited form of an EGA.
Definition 11 
(Restricted effective group action [21,33]). A restricted effective group action REGA ( G , X , , x ˜ ) is a group action that satisfies the following properties:
1. 
The finite group G is generated by a set { g 1 , , g n } , and n = poly ( log | G | ) ;
2. 
The set X is finite, and known algorithms efficiently handle membership testing and compute the unique bit-string representation for every element in X ;
3. 
There exists a distinguished element x ˜ X called the origin whose bit-string representation is known;
4. 
There exists an efficient algorithm that, when given g i in the generating set and any x X , outputs g i x and g i 1 x where i [ n ] .
Remark 2. 
REGA can be instantiated through isogeny-based group actions, such as CSIDH [28]. Additionally, its generator set enables approximate uniform sampling over the group G . Furthermore, due to the regularity of the group action ( G , X , , x ˜ ) , an efficient algorithm exists for drawing elements x $ X [33].
Definition 12 
(GA-DDH assumption [33,39,40]). Given a REGA ( G , X , , x ˜ ) , the GA-DDH assumption is ϵ 2 -hard if for all PPT adversary A , the distinguishing advantage satisfies
|   Pr A x ,   a x ,   b x ,   ( a + b ) x 1 Pr A x ,   a x ,   b x ,   c x 1   |   ϵ 2 ,
where ( G , X , , x ˜ ) REGA . Setup ( 1 λ ) , a , b , c $ G , x $ X .
Remark 3. 
GA-DDH is considered to be applicable to particular group actions derived from isogeny, such as CSIDH [28,33], which is the typical instance of REGA. We stress that our second construction in Section Section 3.3 is built upon the GA-DDH assumption, which is fundamentally different from the weak pseudo-randomness (WPR) assumption adopted in prior works [13,14]. Not only are the underlying assumptions distinct, but the settings are also different; the WPR assumption is considered over EGA (instantiated via CSI-FiSh), whereas GA-DDH is known not to hold in EGA, as comprehensively analyzed in [13].

3. Reusable Fuzzy Extractor

3.1. Definition of Reusable Fuzzy Extractor

Similar to [13], we introduce a modified version of the reusable fuzzy extractor RFE that incorporates an additional initialization algorithm RFE.Init, which generates the initial public string P init . Notably, RFE.Init is invoked only once per user. The generated P init serves as input for the remaining algorithms.
Definition 13 
(Reusable fuzzy extractor). An ( M , m , R , t , ε ) -reusable fuzzy extractor for the metric space M consists of four PPT algorithms ( RFE . Config , RFE . Init , RFE . Gen , RFE . Rep ) :
RFE . Config ( 1 λ ) inputs the security parameter λ and generates a crs ;
RFE . Init ( crs , w ) takes crs and an element w from the set M as input, and then generates the initial public string P init ;
RFE . Gen ( crs , P init , w ) takes crs , P init , and w M as input and generates a public helper string P and an extracted string R R ;
RFE . Rep ( crs , P , P init , w ) takes the crs , P , P init , and w M as input, and then returns R ˜ .
In addition, it meets the following properties:
Correctness : For w , w , w M with dis ( w , w ) t , dis ( w , w ) t , if crs RFE . Config ( 1 λ ) , P init RFE . Init ( crs , w ) , ( P , R ) RFE . Gen ( crs , P init , w ) , R ˜ RFE . Rep ( crs , P , P init , w ) , then R ˜ = R ;
Reusability : For any distribution W over metric space M satisfying H ( W ) m , and for any PPT adversary A , the following holds
Adv r F E , A r e u ( 1 λ ) : = | Pr [ Exp r F E , A r e u ( 1 λ ) 1 ] 1 2 | ε ,
where Exp RFE , A reu ( 1 λ ) , as shown in Figure Figure 1, describes the reusability experiment conducted between a challenger C and an adversary A .
Remark 4. 
The goal of the experiment depicted in Figure Figure 1 is to show that, when adversary A is given the public parameters c r s and P init and further obtains multiple pairs ( P i , R i ) from oracle queries, A still cannot distinguish whether the challenge response R j ( j i ) was generated via the RFE.Gen algorithm or sampled uniformly at random from the output space R , even when P j is known. In other words, even if the same noisy source is used multiple times (n times), and the adversary A learns the first ( n 1 ) pairs ( P i , R i ) , as well as the final helper string P n , the output R n still appears uniformly random to A . Our security notion focuses on the indistinguishability of R i from a uniformly random string. The P i values, being public helper strings generated alongside each R i , are inherently meant to be public. P init is initialized only once per user when the user runs the fuzzy extractor scheme for the first time.

3.2. Construction of RFE from LHS Assumption

The detailed design of RFE = (RFE.Config, REF.Init, REF.Gen, REF.Rep) from the LHS assumption is depicted in Figure 2, which is composed of the following building blocks:
An ( M , m , m ^ , t ) -secure sketch SS = ( SS . Gen , SS . Rec ) , where M = { 0 , 1 } l .
An EGA equipped with EGA . Setup ( 1 λ ) , which outputs ( G , X , , x ˜ ) .
A family of universal hash functions H = { H i : { 0 , 1 } l { 0 , 1 } n   |   i I } , as defined in Equation (3). Let n Z such that n > log | G | + ω ( log λ ) .
Theorem 1. 
If SS is a ( { 0 , 1 } l , m , m ^ , t ) -secure sketch, m ^ n ω ( log λ ) , H is a family of universal hash functions H = { H i : { 0 , 1 } l { 0 , 1 } n   |   i I } . The LHS n l is ϵ 1 -hard over the EGA ( G , X , , x ˜ ) ; then, RFE in F i g u r e Figure 2 is a ( { 0 , 1 } l , m , X l , t , ε ) -reusable fuzzy extractor, where ε 2 ω ( log λ ) + ρ ϵ 1 .
Proof. 
First, we verify the correctness of the construction in Figure 2. If dis( w , w ) ≤ t, dis( w , w ) ≤ t, and s SS . Gen ( w ) , then, by the correctness of SS, we have w ^ = w ˜ = w , where w ˜ ← SS.Rec( w , s ) and w ^ = SS . Rec ( w , s ) . Consequently, k ^ = k . Then, m ^ can be computed correctly, i.e., m ^   =   m , and RFE can always reproduce R.
Next, we demonstrate its reusability by presenting a sequence of games and proving the indistinguishability of adjacent ones. The differences between adjacent games are highlighted with underlined text.
Game G 0 : Game G 0 can be viewed as Exp RFE , A reu ( 1 λ ) . More specifically, it can be viewed as the following:
  • Challenger C selects b $ { 0 , 1 } , samples H i $ H , and then calls EGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) and sets crs:=(pp, H i ); it sends crs to A .
  • C selects w according to W, calculates s SS . Gen ( w ) , and then sets P init : = s , returning P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C calculates w ˜ j : = SS . Rec ( w + δ j , s ) , k j H i ( w ˜ j ) , and then samples M j $ G l × n , x j $ X l ; it calculates m j = M j k j x j and sets P j : = ( M j , x j ) ; if b = 0 , R j : = m j ; otherwise, R j $ X l , and it returns ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, it outputs 0.
Obviously, we have
Pr G 0 1 = Pr E x p r F E , A r e u ( 1 λ ) 1 .
Game G 1 : G 1 is identical to G 0 , c:
2.
C chooses w according to W, calculates s SS . Gen ( w ) , k : = H i ( w ) , and then sets P init : = s , returning P init to A .
3.
A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C sets k j = k , and then samples M j $ G l × n , x j $ X l , calculates m j = M j k j x j , and sets P j : = ( M j , x j ) ; if b = 0 , R j : = m j ; otherwise, R j $ X l , and it returns ( P j , R j ) to A .
Lemma 4. 
Pr [ G 0 1 ] = Pr [ G 1 1 ] .
Proof. 
Due to the correctness of the secure sketch and dis ( δ j ) t , we deduce that
w ˜ j = SS . Rec ( w + δ j , s ) = w .
Furthermore, we can get k j = H i ( w ˜ j ) = H i ( w ) = k . Hence, we conclude that Pr [ G 0 1 ] = Pr [ G 1 1 ] . The lemma follows. □
Game G 2 : G 2 is equivalent to G 1 , with the difference that k : = H i ( w ) is replaced by k $ { 0 , 1 } n . More specifically, we have the following:
2.
C chooses w according to W, calculates s SS . Gen ( w ) , k $ { 0 , 1 } n , and then sets P init : = s , returning P init to A .
Lemma 5. 
| Pr [ G 1 1 ] Pr [ G 2 1 ] | 2 ω ( log λ ) .
Proof. 
We prove this lemma using an argument based on information theory. Note that w only appears in the second step to calculate s SS . Gen ( w ) both in G 1 and G 2 ; thus, s is all the information about W that is revealed to A . Since our SS is an ( M = { 0 , 1 } l , m , m ^ , t ) -secure sketch and H ( W ) m , we have
H ˜ ( W | SS . Gen ( W ) ) m ^ .
Due to Lemma 1 and the fact that m ^ n ω ( log λ ) , the statistical distance between k and u is at most 2 ω ( log λ ) , where k H i ( w ) and u $ { 0 , 1 } n . More precisely, we have the following:
SD ( ( k , H i , s ) ,   ( u , H i , s ) )   1 2 2 H ˜ ( w   |   s ) · 2 n   1 2 2 m ^ · 2 n   2 ω ( log λ ) .
We now define a powerful algorithm B and show that if an adversary is capable of distinguishing between G 1 and G 2 with a non-negligible advantage, then B can also distinguish ( k , H i , s ) and ( u , H i , s ) with the same advantage. Assume B receives ( y , H i , s ) , where y is either k = H i ( w ) or a uniform element u . The goal of B is to identify which case it is. The algorithm B operates as follows:
  • Algorithm B samples b $ { 0 , 1 } , calls EGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) , sets crs:=(pp, H i ), and returns crs to A .
  • B sets k : = y and P init : = s and sends P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , B sets k j = k , samples M j $ G l × n , x j $ X l , calculates m j = M j k j x j , and sets P j : = ( M j , x j ) if b = 0 , R j : = m j ; otherwise, R j $ X l , and it returns ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, it outputs 0.
If B is given the tuple ( y = k , H i , s ) , where k is derived from H i ( w ) and s is generated via SS . Gen ( w ) , it will be able to simulate the game G 1 for A perfectly. On the other hand, if B is given ( y = u , H α , s ) , where u is randomly chosen from { 0 , 1 } n , it will simulate the game G 2 for A flawlessly. Therefore, we can conclude that | Pr [ G 1 1 ] Pr [ G 2 1 ] | 2 ω ( log λ ) . The lemma follows. □
Game G 3 : G 3 is equivalent to G 2 , with the difference that m j = M j k j x j is changed to m j = u ^ j , where u ^ j $ X l . More specifically, we have the following:
3.
A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] ., C sets k j = k , samples M j $ G l × n , x j $ X l , and u ^ j $ X l , sets m j = u ^ j , and sets P j : = ( M j , x j ) ; if b = 0 , R j : = m j ; otherwise, R j $ X l , and it returns ( P j , R j ) to A .
Lemma 6. 
| Pr [ G 2 1 ] Pr [ G 3 1 ] | ρ ϵ 1 .
Proof. 
We aim to demonstrate that if a PPT adversary A can distinguish between G 2 and G 3 with a significant advantage, then it is possible to construct a PPT algorithm B that can solve the LHS n ρ l assumption with the same advantage. Suppose B is given an LHS tuple ( x , M , t ) , where t is either M k x or u ^ , and M $ G ρ l × n , k $ { 0 , 1 } n , x $ X ρ l , u ^ $ X ρ l . The goal of B is to determine which scenario holds. B operates as follows, and the entire interaction is illustrated in Figure  Figure 3:
  • Algorithm B parses M = [ M 1 , M 2 , , M ρ ] , x = [ x 1 , x 2 , , x ρ ] and t = [ t 1 , t 2 , , t ρ ] , selects b $ { 0 , 1 } , samples H i $ H , and then calls EGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) , setting crs:=(pp, H i ) and sending crs to A .
  • B chooses w according to W, calculates s SS . Gen ( w ) , and then sets P init : = s , returning P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , B sets M j = M j and x j = x j , m j = t j , and sets P j : = ( M j , x j ) ; if b = 0 , R j : = m j ; otherwise, R j $ X l , returning ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, it outputs 0.
If t = M k x , where M $ G ρ l × n , k $ { 0 , 1 } n , x $ X ρ l , then B will accurately simulate game G 2 for A . Conversely, if t = u ^ , where u ^ $ X ρ l , then B perfectly simulates game G 3 for A . Hence, we deduce that
| Pr [ G 2 1 ] Pr [ G 3 1 ] | Adv LHS , A ρ l , n ( 1 λ ) ρ ϵ 1 .
The lemma follows. □
Lemma 7. 
Pr [ G 3 1 ] = 1 / 2 .
Proof. 
In G 3 , no matter whether b = 0 or 1, m j is always selected uniformly at random from X l ; then, the adversary A ’s probability of making a correct guess is 1 / 2 . The lemma follows. □
By putting Equation (1) and Lemma 4–7 together, we obtain that ε 2 ω ( log λ ) + ρ ϵ 1 . Theorem 1 follows.

3.3. Construction of RFE from GA-DDH Assumption

The detailed design of RFE = (RFE.Config, REF.Init, REF.Gen, REF.Rep) from the GA-DDH assumption is depicted in Figure 4, which is composed of the following building blocks:
An ( { 0 , 1 } l , m , m ^ , t ) -secure sketch SS = ( SS . Gen , SS . R ec ) .
A REGA equipped with REGA . Setup ( 1 λ ) , which outputs ( G , X , , x ˜ ) with order | G | = λ ω ( 1 ) .
An average-case ( { 0 , 1 } l , m ^ , { 0 , 1 } n , ε e x t ) -strong extractor. Let n Z such that n > log | G | + ω ( log λ ) .
A family of universal hash functions H = { H i : { 0 , 1 } n G   |   H i ( x ) = q = 1 n x q i q , i G n } (While our GA-DDH-based construction requires the seed of the universal hash function to be sampled with high min-entropy (ideally uniformly at random), the design is tolerant to minor imperfections due to the entropy gap between the source and the output. However, for practical implementations, we recommend using a cryptographically secure pseudo-random number generator or high-entropy physical source to ensure robust security).
Theorem 2. 
If SS is a ( { 0 , 1 } l , m , m ^ , t ) -secure sketch, H is a family of universal hash functions H = { H i : { 0 , 1 } n G   |   i G n } . The GA-DDH assumption is ϵ 2 -hard over the REGA ( G , X , , x ˜ ) ; then, RFE in F i g u r e Figure 4 is a ( { 0 , 1 } l , m , X , t , ε ) -reusable fuzzy extractor, where ε ε e x t + ρ ϵ 2 + 2 ω ( log λ ) .
Proof. 
First, the correctness of the RFE in Figure 4 follows from the correctness of the secure sketch SS. Similar to the proof of Theorem 1, we also use game-based proof to verify reusability. Adjacent games’ differences are highlighted with underlined text.
Game G 0 : Game G 0 can be viewed as Exp RFE , A reu ( 1 λ ) . More specifically, we have the following:
  • Challenger C selects b $ { 0 , 1 } , samples H i $ H , and then calls REGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) , selecting k $ K , x $ X , setting crs:=(pp, k, x, H i ), and returning crs to A .
  • C chooses w according to W, calculates s SS . Gen ( w ) , and then sets P init : = s , returning P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C computes w ˜ j : = SS . Rec ( w + δ j , s ) , t j Ext ( w ˜ j , k ) , and y j H i ( t j ) , samples r j $ G , computes c j = r j x , and then calculates v j = y j c j , setting P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , and it returns ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, it outputs 0.
Obviously, we deduce that
Pr G 0 1 = Pr E x p r F E , A r e u ( 1 λ ) 1 .
Game G 1 : G 1 is equivalent to G 0 , aside from some conceptual differences:
2.
C chooses w according to W, calculates s SS . Gen ( w ) , t Ext ( w , k ) , y H i ( t ) , and then sets P init : = s , returning P init to A .
3.
A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C sets t j = t , y j = y , samples r j $ G , computes c j = r j x , and then calculates v j = y j c j , setting P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , returning ( P j , R j ) to A .
Lemma 8. 
Pr [ G 0 1 ] = Pr [ G 1 1 ] .
Proof. 
Due to the correctness of the secure sketch and dis ( δ j ) t , we have
w ˜ j = SS . Rec ( w + δ j , s ) = w .
Furthermore, we can get
t j = Ext ( w ˜ j , k ) = Ext ( w , k ) = t ,   y j = H i ( t j ) = H i ( t ) = y .
Hence, we have Pr [ G 0 1 ] = Pr [ G 1 1 ] . The lemma follows. □
Game G 2 : G 2 is identical to G 1 , with the difference that t Ext ( w , k ) is changed to t $ { 0 , 1 } n . More specifically, we have the following:
2.
C chooses w according to W, calculates s SS . Gen ( w ) , t $ { 0 , 1 } n , y H i ( t ) , and then sets P init : = s , returning P init to A .
Lemma 9. 
| Pr [ G 1 1 ] Pr [ G 2 1 ] | ε e x t .
Proof. 
Note that w only appears in the second step to compute s SS . Gen ( w ) both in G 1 and G 2 ; thus, s is all the information about W that is revealed to A . Meanwhile, since our SS is an ( M = { 0 , 1 } l , m , m ^ , t ) -secure sketch and H ( W ) m , we have H ˜ ( W | SS . Gen ( W ) ) m ^ .
We now present an algorithm B and prove that if an adversary exists that can distinguish G 1 from G 2 with a non-negligible advantage, then B can distinguish between ( Ext ( w , k ) = t , k , s ) and ( u , k , s ) with the same advantage. Let B receive ( d , k , s ) , where d is either t = Ext ( w , k ) or a uniformly chosen element u $ { 0 , 1 } n . The task of B is to identify which case is given. Algorithm B operates as follows:
  • Algorithm B selects b $ { 0 , 1 } , samples H i $ H , and then calls REGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) ; it samples x $ X , sets crs:=(pp, k, x, H i ), and returns crs to A .
  • B sets t : = d , y H i ( t ) , P init : = s , and returns P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , B sets t j = t , y j = y , samples r j $ G , computes c j = r j x , v j = y j c j , and sets P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , returning ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, it outputs 0.
Assuming that B is given the tuple ( d = t , k , s ) , where t is generated by Ext ( w , k ) , k is sampled from K , and s is created via SS . Gen ( w ) , B will successfully simulate game G 1 for A . On the other hand, if B is provided with the tuple ( d = u , k , s ) , where u is randomly chosen from { 0 , 1 } n , B will simulate game G 2 for A perfectly. Consequently, we conclude that
|   Pr G 1 1 Pr G 2 1   | SD Ext ( w , k ) ,   k ,   s ,   u ,   k ,   s ε ext .
The lemma follows. □
Game G 3 : G 3 is identical to G 2 , with the difference that y H i ( t ) is changed to y $ G . More specifically, we have the following:
2.
C chooses w according to W, calculates s SS . Gen ( w ) , t $ { 0 , 1 } n , y $ G , and then sets P init : = s , returning P init to A .
Lemma 10. 
| Pr [ G 2 1 ] Pr [ G 3 1 ] | 2 ω ( log λ ) .
Proof. 
Recall that in G 2 , t $ { 0 , 1 } n , H i $ H (i.e., i $ G n ), and H i are public in crs. According to Lemma 2, we have ( i , q = 1 n t q i q ) ε s ( i , u ) , where q = 1 n t q i q = H i ( t ) , u $ G , and ε = G / 2 n 2 ω ( log λ ) . Thus, y is statistically indistinguishable in G 2 and G 3 . This proof follows similarly to that of Lemma 5, and can thus be easily derived. The lemma follows. □
Game G 4 : G 4 is equivalent to G 3 , with the difference that v j = y j c j is changed to v j = u j x , where u j $ G . More specifically, we have the following:
3.
A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C sets t j = t , y j : = y , samples r j $ G , computes c j = r j x , samples u j $ G , and then calculates v j = u j x , setting P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , returning ( P j , R j ) to A .
Lemma 11. 
| Pr [ G 3 1 ] Pr [ G 4 1 ] | ρ ϵ 2 .
Proof. 
We prove this lemma through a series of games G 3 . α , where α [ 0 , ρ ] . The specific description of G 3 . α is provided below.
  • Challenger C selects b $ { 0 , 1 } , samples H i $ H , and then calls REGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) , selecting k $ K and x $ X ; then, it sets crs:=(pp, k, x, H i ) and returns crs to A .
  • C chooses w according to W, calculates s SS . Gen ( w ) , t $ { 0 , 1 } n , y $ G , sets P init : = s , and returns P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C sets t j = t , y j = y , samples r j $ G , computes c j = r j x . If j α , samples u j $ G , and then sets v j = u j x ; otherwise, it sets v j = y j c j . Then, it sets P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , returning ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, the outputs 0.
Obviously, we have G 3.0 , which is identical to G 3 , and G 3 . ρ is equivalent to G 4 . Before proving this lemma, let us first prove the following proposition. □
Proposition 1. 
| Pr [ G 3 . ( α 1 ) 1 ] Pr [ G 3 . α 1 ] | ϵ 2 ,   α [ ρ ] .
Proof. 
We will show that if there exists an adversary A that can distinguish G 3 . ( α 1 ) and G 3 . α with a non-negligible advantage, then there exists a PPT algorithm B that can solve the GA-DDH problem with the same advantage. Assume that B is provided with a tuple ( x , r x , y x , d x ) , where r , y $ G and x $ X , and d is either r + y or a random element u from G . The goal of B is to determine which case holds. Algorithm B operates as follows:
  • Algorithm B selects b $ { 0 , 1 } , samples H i $ H , and then calls REGA . Setup ( 1 λ ) to generate pp = ( G , X , , x ˜ ) ; it samples k $ K , sets crs:=(pp, k, x, H i ), and sends crs to A .
  • B chooses w according to W, calculates s SS . Gen ( w ) and t $ { 0 , 1 } n , implicitly sets y = y , and then sets P init : = s , returning P init to A .
  • A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , B sets t j = t , implicitly sets y j = y , samples r j $ G , and computes c j = r j x . If j < α , it samples u j $ G and sets v j = u j x ; if j = α , it sets c j = r x , v j = d x ; if j > α , it sets v j = r j ( y x ) . Then, it sets P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , returning ( P j , R j ) to A .
  • A finally outputs a guessing bit b ; when b = b , the game outputs 1; otherwise, it outputs 0.
If d = r + y , then B accurately simulates game G 3 . α 1 for A ; if d = u , then B perfectly simulates game G 3 . α for A . Hence, we conclude that
| Pr [ G 3 . ( α 1 ) 1 ] Pr [ G 3 . α 1 ] | ϵ 2 .
The proposition follows. □
Therefore, by using Proposition 1 ρ times, we obtain | Pr [ G 3 1 ] Pr [ G 4 1 ] | ρ ϵ 2 . The lemma follows.
Game G 5 : G 5 is identical to G 4 , except that v j = u j x is changed to v j = u ˜ j , where u ˜ j $ X . More specifically, we have the following:
3.
A may request up to ρ queries from the generation oracle. Upon obtaining an offset δ j M satisfying dis ( δ j ) t for j [ ρ ] , C sets t j = t and y j : = y , samples r j $ G , computes c j = r j x , samples u ˜ j $ X , and then sets v j = u ˜ j , setting P j : = c j ; if b = 0 , R j : = v j ; otherwise, R j $ X , returning ( P j , R j ) to A .
Lemma 12. 
Pr [ G 4 1 ] = Pr [ G 5 1 ] .
Proof. 
Note that in G 4 , v j = u j x , u j $ G . Since the group action is regular, according to Remark 1 and Remark 2, v j is uniformly distributed over X in G 4 in the REGA setting. Thus, the distributions of v j in G 4 and G 5 are identical. The lemma follows. □
Lemma 13. 
Pr [ G 5 1 ] = 1 / 2 .
Proof. 
The proof is similar to that of Lemma 7 and is omitted for brevity. □
Putting Equation (2) and Lemmas 8–13 together, we obtain that ε ε e x t + ρ ϵ 2 + 2 ω ( log λ ) . Theorem 2 follows.

4. Instantiation

4.1. Instantiation of Building Blocks

4.1.1. Syndrome-Based Secure Sketch

Considering a linear error-correcting code E that is [ n , k , 2 t + 1 ] F and lies within the space F n . Specifically, E = { w F n H w = 0 } , where H is an ( n k ) × n parity-check matrix. As proposed in [1], a syndrome-based secure sketch can be constructed using an efficient [ n , k , 2 t + 1 ] F -linear error-correcting code, and the construction can be summarized as follows:
SS . Gen ( w ) : = syn ( w ) = H w = s ;
SS . Rec ( w , s ) : = w Decode ( syn ( w ) s ) = w e .
Lemma 14. 
Given an [ n , k , 2 t + 1 ] F error-correcting code, it is feasible to construct an ( F n , m , m ( n k ) | F | , t ) secure sketch, which is efficient if encoding and decoding are efficient.
As there are efficient [ n , k , 2 t + 1 ] F -linear error-correcting codes where t = O ( n ) , the syndrome-based secure sketch can handle a linear proportion of errors.

4.1.2. Universal Hash Functions and Strong Extractor

In our construction 1, we use the following commonly used family of universal hash functions [8,14].
H = { H i : { 0 , 1 } l { 0 , 1 } n   |   H ( x ) = i · x } ,
where i { 0 , 1 } l + n 1 , symbol “·” represents matrix-vector multiplication in F 2 , and i is interpreted as an n × l Toeplitz matrix.
In our construction 2, we use the universal hash function presented in Lemma 2. More precisely, we have the following:
H = { H i : { 0 , 1 } n G   |   H i ( x ) = q = 1 n x q i q , i G n } .
The leftover hash lemma (Lemma 1) implies that universal hash functions are good (average-case strong) extractors. The construction of universal hash functions in Equation (3) is a good instance.

4.1.3. (Restricted) Effective Group Action

  • EGA from CSI-FiSh. As stated in [13], we can derive a regular and abelian effective group action (EGA) from isogeny via CSI-FiSh, which precomputes the group structure C l ( Z [ π p ] ) of CSIDH-512 (to optimize sampling from the ideal class group G , one can precompute its group structure, typically making G cyclic. Uniform sampling from G then becomes efficient. Sampling from G can be realized by applying a random group element to a fixed representative, leveraging the regularity of the group action. This strategy is used in prior isogeny-based works such as CSI-FiSh.).
  • ( p , N , [ g ] , E 0 ) CSI . Setup , where p specifies the prime field, N denotes the order of the ideal class group C l ( Z [ π p ] ) , [ g ] is a generator of C l ( Z [ π p ] ) , and E 0 is the base elliptic curve defined by y 2 = x 3 + x .
  • Define G : = C l ( Z [ π p ] ) , X : = E l l p ( Z [ π p ] ) , and set the origin x ˜ : = E 0 . The group C l ( Z [ π p ] ) ( Z N , + ) supports efficient group operations, including equality checking, random sampling, addition, and inversion.
  • REGA from CSIDH. As stated in [41], let p be a large prime of the form p = 4 · 1 n 1 , where each i is a small distinct odd prime. We consider the elliptic curve E 0 : y 2 = x 3 + x over F p , which is supersingular. The endomorphism ring of this curve over F p is O = Z [ π ] , where π is the Frobenius endomorphism. E l l p ( O ) is the set of elliptic curves defined over F p whose endomorphism ring is O . The ideal class group C l ( O ) acts on this set, which is formalized by a map.
    : C l ( O ) × E l l p ( O ) E l l p ( O ) ,
    ( [ a ] , E ) [ a ] E .
We abstract the generation process of (R)EGA as an algorithm called ( R ) EGA . Setup ( 1 λ ) , which outputs the description of (R)EGA.

4.2. Instantiations of Our Construction 1 and Construction 2

Based on concrete instantiations of the aforementioned building blocks, Figure 5 and Figure 6 illustrate the complete instantiations of our reusable fuzzy extractors under the LHS assumption and the GA-DDH assumption, respectively.

5. Conclusions

In this work, we present two constructions of RFE under isogeny-based assumptions and rigorously prove their security. Indeed, our motivation stems from the observation that existing post-quantum secure FE schemes (whether reusable or robust) are predominantly based on lattice-based hardness assumptions, such as the LWE assumption. Excessive dependence on lattice assumptions has led to a lack of diversity in post-quantum FE constructions. If significant progress were to be made in solving lattice problems, the security of these lattice-based fuzzy extractors would be at serious risk.
Moreover, we note that fuzzy extractors based on isogeny assumptions are still rare. To the best of our knowledge, only two such constructions [13,14] exist, both published last year and relying on the WPR assumption, a specific isogeny-based hardness assumption. In contrast, other cryptographic primitives based on isogeny assumptions, such as key exchange protocols [28] and digital signatures [15], have seen rapid development. This disparity suggests that adapting isogeny-based assumptions to the fuzzy extractor setting is non-trivial and that constructing reusable or robust fuzzy extractors using conventional techniques is far from straightforward—a challenge also noted in [13]. Therefore, inspired by the refinement of the RRFE security model in [13], we propose a similar modification to the security model of RFE. This refinement eliminates the need to rely on the key-shift security of underlying primitives or assumptions in the security proof. Based on the optimized model, we construct two reusable fuzzy extractors under the LHS assumption and the GA-DDH assumption, respectively. Compared to the construction in [13,14], our first scheme is able to extract longer uniform strings (l-times longer), albeit at a higher computational cost. Moreover, our second construction achieves the same output length as the schemes in [13,14] while incurring a lower computational cost than [13] and nearly matching the efficiency of [14].
Our constructions utilize only some fundamental cryptographic primitives: secure sketches for fuzzy error correction, and hash functions or strong extractors to extract uniform randomness, which can be further employed in other cryptographic applications, such as serving as keys for symmetric or asymmetric encryption schemes. On the one hand, we achieve the reusability of FE, ensuring security across multiple extractions from the same noisy source. On the other hand, we recognize that robustness is also a crucial component of fuzzy extractor security; it protects against active attacks on the public helper string. However, we have not yet identified an effective or satisfactory method for achieving robustness in our setting. In particular, achieving both robustness and reusability in a single fuzzy extractor remains an open challenge, which we leave for future investigation.
In addition, an interesting open direction for future research is to investigate the applicability of our framework to multi-factor fuzzy sources, such as combinations of voice and facial biometrics. This would require addressing challenges in feature fusion, noise modeling, and entropy extraction beyond the single-source setting considered in this work. Another promising direction for future work is to investigate the practical deployment of our constructions on resource-constrained edge systems, as well as to evaluate their robustness under real-world noise patterns. Meanwhile, it is important to explore the integration of our reusable fuzzy extractor constructions with other post-quantum cryptographic protocols, such as key exchange, authentication, and secure enrollment schemes. In particular, combining our techniques with post-quantum primitives (e.g., isogeny-based or lattice-based protocols) may yield end-to-end secure systems that are resilient against quantum adversaries and robust to input noise.

Author Contributions

Conceptualization, Y.W.; Methodology, Y.W.; Validation, T.J.; Formal analysis, T.J.; Writing—original draft, T.J.; Writing—review & editing, Y.W. and W.L.; Supervision, 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), 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.

References

  1. Dodis, Y.; Reyzin, L.; Smith, A.D. Fuzzy extractors: How to generate strong keys from biometrics and other noisy data. In Advances in Cryptology—EUROCRYPT 2004, Proceedings of the International Conference on the Theory and Applications of Cryptographic Techniques, Interlaken, Switzerland, 2–6 May 2004; Cachin, C., Camenisch, J., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2004; Volume 3027, pp. 523–540. [Google Scholar] [CrossRef]
  2. 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 CHI’17: 2017 CHI Conference on Human Factors in Computing Systems, Denver, CO, USA, 6–11 May 2017; Association for Computing Machinery: New York, NY, USA, 2017; pp. 3787–3798. [Google Scholar] [CrossRef]
  3. Yoon, S.; Jain, A.K. Longitudinal study of fingerprint recognition. Proc. Natl. Acad. Sci. USA 2015, 112, 8555–8560. [Google Scholar] [CrossRef] [PubMed]
  4. Gao, Y.; Al-Sarawi, S.F.; Abbott, D. Physical unclonable functions. Nat. Electron. 2020, 3, 81–91. [Google Scholar] [CrossRef]
  5. Lu, H.; Liscidini, M.; Gaeta, A.L.; Weiner, A.M.; Lukens, J.M. Frequency-bin photonic quantum information. Optica 2023, 10, 1655–1671. [Google Scholar] [CrossRef]
  6. Boyen, X. Reusable cryptographic fuzzy extractors. In Proceedings of the CCS 2004, 11th ACM Conference on Computer and Communications Security, Washington, DC, USA, 25–29 October 2004; Atluri, V., Pfitzmann, B., McDaniel, P.D., Eds.; ACM: New York, NY, USA, 2004; pp. 82–91. [Google Scholar] [CrossRef]
  7. Canetti, R.; Fuller, B.; Paneth, O.; Reyzin, L.; Smith, A.D. Reusable fuzzy extractors for low-entropy distributions. In Advances in Cryptology—EUROCRYPT 2016, Proceedings of the 35th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Vienna, Austria, 8–12 May 2016; Fischlin, M., Coron, J., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2016; Volume 9665, pp. 117–146. [Google Scholar] [CrossRef]
  8. Wen, Y.; Liu, S.; Han, S. Reusable fuzzy extractor from the decisional Diffie-Hellman assumption. Des. Codes Cryptogr. 2018, 86, 2495–2512. [Google Scholar] [CrossRef]
  9. Wen, Y.; Liu, S. Reusable fuzzy extractor from LWE. In Proceedings of the ACISP 2018, Wollongong, Australia, 11–13 July 2018; Susilo, W., Yang, G., Eds.; LNCS. Springer: Berlin/Heidelberg, Germany, 2018; Volume 10946, pp. 13–27. [Google Scholar] [CrossRef]
  10. Wen, Y.; Liu, S. Robustly reusable fuzzy extractor from standard assumptions. In Advances in Cryptology—ASIACRYPT 2018, Proceedings of the 24th International Conference on the Theory and Application of Cryptology and Information Security, Brisbane, Australia, 2–6 December 2018; Peyrin, T., Galbraith, S., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2018; Volume 11274, pp. 459–489. [Google Scholar] [CrossRef]
  11. Wen, Y.; Liu, S.; Gu, D. Generic constructions of robustly reusable fuzzy extractor. In Public-Key Cryptography—PKC 2019, Proceedings of the 22nd IACR International Conference on Practice and Theory of Public-Key Cryptography, Beijing, China, 14–17 April 2019; Lin, D., Sako, K., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2019; Volume 11443, pp. 349–378. [Google Scholar] [CrossRef]
  12. Li, Y.; Liu, S.; Gu, D.; Chen, K. Reusable fuzzy extractor based on the LPN assumption. Comput. J. 2020, 63, 1826–1834. [Google Scholar] [CrossRef]
  13. Zhou, Y.; Liu, S.; Han, S. Robustly Reusable Fuzzy Extractor from Isogeny. Theor. Comput. Sci. 2024, 1008, 114677. [Google Scholar] [CrossRef]
  14. Zhou, Y.; Liu, S.; Han, S. Reusable Fuzzy Extractor from Isogeny. In Proceedings of the International Conference on Provable Security, Gold Coast, Australia, 25–27 September 2024; Liu, J.K., Chen, L., Sun, S., Liu, X., Eds.; LNCS. Springer: Berlin/Heidelberg, Germany, 2024; Volume 14904, pp. 246–256. [Google Scholar] [CrossRef]
  15. Beullens, W.; Kleinjung, T.; Vercauteren, F. CSI-FiSh: Efficient isogeny based signatures through class group computations. In Advances in Cryptology—ASIACRYPT 2019, Proceedings of the 25th International Conference on the Theory and Application of Cryptology and Information Security, Kobe, Japan, 8–12 December 2019; Galbraith, S., Moriai, S., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2019; Volume 11921, pp. 227–247. [Google Scholar] [CrossRef]
  16. Bernstein, D.J.; Lange, T. Post-quantum cryptography. Nature 2017, 549, 188–194. [Google Scholar] [CrossRef] [PubMed]
  17. Dam, D.; Tran, T.; Hoang, V.; Pham, C.; Hoang, T. A survey of post-quantum cryptography: Start of a new race. Cryptography 2023, 7, 40. [Google Scholar] [CrossRef]
  18. Liu, H.; Wang, X.; Yang, K.; Yu, Y. The hardness of LPN over any integer ring and field for PCG applications. In Advances in Cryptology—EUROCRYPT 2024, Proceedings of the 43rd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Zurich, Switzerland, 26–30 May 2024; Joye, M., Leander, G., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2024; pp. 149–179. [Google Scholar] [CrossRef]
  19. Rosca, M.; Stehlé, D.; Wallet, A. On the ring-LWE and polynomial-LWE problems. In Advances in Cryptology – EUROCRYPT 2018, Proceedings of the 37th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Tel Aviv, Israel, 29 April–3 May 2018; Nielsen, J., Rijmen, V., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2018; Volume 10820, pp. 146–173. [Google Scholar] [CrossRef]
  20. Peikert, C. A decade of lattice cryptography. Found. Trends® Theor. Comput. Sci. 2016, 10, 283–424. [Google Scholar] [CrossRef]
  21. Alamati, N.; De Feo, L.; Montgomery, H.; Patranabis, S. Cryptographic group actions and applications. In Advances in Cryptology—ASIACRYPT 2020, Proceedings of the 26th International Conference on the Theory and Application of Cryptology and Information Security, Daejeon, Republic of Korea, 7–11 December 2020; Moriai, S., Wang, H., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2020; Volume 12492, pp. 411–439. [Google Scholar] [CrossRef]
  22. De Feo, L.; Fouotsa, T.B.; Panny, L. Isogeny problems with level structure. In Advances in Cryptology—EUROCRYPT 2024, Proceedings of the 43rd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Zurich, Switzerland, 26–30 May 2024; Joye, M., Leander, G., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2024; Volume 14657, pp. 181–204. [Google Scholar] [CrossRef]
  23. Leroux, A. A new isogeny representation and applications to cryptography. In Advances in Cryptology–ASIACRYPT 2022, Proceedings of the 28th International Conference on the Theory and Application of Cryptology and Information Security, Taipei, Taiwan, 5–9 December 2022; Agrawal, S., Lin, D., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2022; Volume 13792, pp. 3–35. [Google Scholar] [CrossRef]
  24. Jao, D.; De Feo, L. Towards quantum-resistant cryptosystems from supersingular elliptic curve isogenies. In Post-Quantum Cryptography, Proceedings of the PQCrypto 2011, Taipei, Taiwan, 29 November–2 December 2011; Yang, B.Y., Ed.; LNCS; Springer: Berlin/Heidelberg, Germany, 2011; Volume 7071, pp. 19–34. [Google Scholar] [CrossRef]
  25. Castryck, W.; Decru, T. An efficient key recovery attack on SIDH. In Advances in Cryptology—EUROCRYPT 2023, Proceedings of the 42nd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Lyon, France, 23–27 April 2023; Hazay, C., Stam, M., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2023; Volume 14008, pp. 423–447. [Google Scholar] [CrossRef]
  26. Fouotsa, T.B.; Petit, C. A new adaptive attack on SIDH. In Topics in Cryptology—CT-RSA 2022, Proceedings of the RSA Conference 2022, Virtual, 1–2 March 2022; Galbraith, S.D., Ed.; LNCS; Springer: Berlin/Heidelberg, Germany, 2022; Volume 13161, pp. 322–344. [Google Scholar] [CrossRef]
  27. Basso, A.; Fouotsa, T.B. New SIDH countermeasures for a more efficient key exchange. In Advances in Cryptology—ASIACRYPT 2023, Proceedings of the 29th International Conference on the Theory and Application of Cryptology and Information Security, Guangzhou, China, 4–8 December 2023; Guo, J., Steinfeld, R., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2023; Volume 14445, pp. 208–233. [Google Scholar] [CrossRef]
  28. Castryck, W.; Lange, T.; Martindale, C.; Panny, L.; Renes, J. CSIDH: An efficient post-quantum commutative group action. In Advances in Cryptology—ASIACRYPT 2018, Proceedings of the 24th International Conference on the Theory and Application of Cryptology and Information Security, Brisbane, Australia, 2–6 December 2018; Peyrin, T., Galbraith, S., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2018; Volume 11274, pp. 395–427. [Google Scholar] [CrossRef]
  29. Alamati, N.; Malavolta, G.; Rahimi, A. Candidate trapdoor claw-free functions from group actions with applications to quantum protocols. In Theory of Cryptography, Proceedings of the 20th International Conference, TCC 2022, Chicago, IL, USA, 7–10 November 2022; Kiltz, E., Vaikuntanathan, V., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2022; Volume 13747, pp. 266–293. [Google Scholar] [CrossRef]
  30. Alamati, N.; Patranabis, S. Cryptographic Primitives with Hinting Property. J. Cryptol. 2024, 37, 21. [Google Scholar] [CrossRef]
  31. Stolbunov, A. Cryptographic Schemes Based on Isogenies. Ph.D. Thesis, Norwegian University of Science and Technology, Trondheim, Norway, 2012. [Google Scholar]
  32. Castryck, W.; Sotáková, J.; Vercauteren, F. Breaking the decisional Diffie-Hellman problem for class group actions using genus theory. In Advances in Cryptology—CRYPTO 2020, Proceedings of the 40th Annual International Cryptology Conference, CRYPTO 2020, Santa Barbara, CA, USA, 17–21 August 2020; Micciancio, D., Ristenpart, T., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2020; Volume 12171, pp. 92–120. [Google Scholar] [CrossRef]
  33. Lyu, Y.; Liu, S.; Han, S. Universal composable password authenticated key exchange for the post-quantum world. In Advances in Cryptology—EUROCRYPT 2024, Proceedings of the 43rd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Zurich, Switzerland, 26–30 May 2024; Joye, M., Leander, G., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2024; Volume 10820, pp. 120–150. [Google Scholar] [CrossRef]
  34. Lai, Y. CAPYBARA and TSUBAKI: Verifiable random functions from group actions and isogenies. Cryptology ePrint Archive. 2023. Volume 1. Available online: https://cic.iacr.org/p/1/3/1 (accessed on 1 July 2025). [CrossRef]
  35. Heimberger, L.; Hennerbichler, T.; Meisingseth, F.; Ramacher, S.; Rechberger, C. OPRFs from isogenies: Designs and analysis. In Proceedings of the ASIA CCS ’24: 19th ACM Asia Conference on Computer and Communications Security, Singapore, 1–5 July 2024; Association for Computing Machinery: New York, NY, USA, 2024; pp. 575–588. [Google Scholar] [CrossRef]
  36. Duman, J.; Hartmann, D.; Kiltz, E.; Kunzweiler, S.; Lehmann, J.; Riepel, D. Group action key encapsulation and non-interactive key exchange in the QROM. In Advances in Cryptology—ASIACRYPT 2022, Proceedings of the 28th International Conference on the Theory and Application of Cryptology and Information Security, Taipei, Taiwan, 5–9 December 2022; Agrawal, S., Lin, D., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2022; Volume 13792, pp. 36–66. [Google Scholar] [CrossRef]
  37. Apon, D.; Cho, C.; Eldefrawy, K.; Katz, J. Efficient, reusable fuzzy extractors from LWE. In Proceedings of the CSCML 2017, Beer-Sheva, Israel, 29–30 June 2017; Dolev, S., Lodha, S., Eds.; LNCS. Springer: Berlin/Heidelberg, Germany, 2017; Volume 10332, pp. 1–18. [Google Scholar] [CrossRef]
  38. Regev, O. On lattices, learning with errors, random linear codes, and cryptography. J. ACM (JACM) 2009, 56, 1–40. [Google Scholar] [CrossRef]
  39. Boneh, D.; Kogan, D.; Woo, K. Oblivious pseudorandom functions from isogenies. In Advances in Cryptology—ASIACRYPT 2020, Proceedings of the 26th International Conference on the Theory and Application of Cryptology and Information Security, Daejeon, Republic of Korea, 7–11 December 2020; Moriai, S., Wang, H., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2020; Volume 12492, pp. 520–550. [Google Scholar] [CrossRef]
  40. Kawashima, T.; Takashima, K.; Aikawa, Y.; Takagi, T. An efficient authenticated key exchange from random self-reducibility on CSIDH. In Proceedings of the Information Security and Cryptology—ICISC 2020, Seoul, Republic of Korea, 2–4 December 2020; Hong, D., Ed.; LNCS. Springer: Berlin/Heidelberg, Germany, 2021; Volume 12593, pp. 58–84. [Google Scholar] [CrossRef]
  41. Abdalla, M.; Eisenhofer, T.; Kiltz, E.; Kunzweiler, S.; Riepel, D. Password-authenticated key exchange from group actions. In Advances in Cryptology—CRYPTO 2022, Proceedings of the 42nd Annual International Cryptology Conference, CRYPTO 2022, Santa Barbara, CA, USA, 15–18 August 2022; Dodis, Y., Shrimpton, T., Eds.; LNCS; Springer: Berlin/Heidelberg, Germany, 2022; Volume 13508, pp. 699–728. [Google Scholar] [CrossRef]
Figure 1. The reusability experiment Exp RFE , A reu ( 1 λ ) .
Figure 1. The reusability experiment Exp RFE , A reu ( 1 λ ) .
Symmetry 17 01065 g001
Figure 2. Design of reusable fuzzy extractor from LHS.
Figure 2. Design of reusable fuzzy extractor from LHS.
Symmetry 17 01065 g002
Figure 3. The entire interaction of Lemma 6.
Figure 3. The entire interaction of Lemma 6.
Symmetry 17 01065 g003
Figure 4. Design of reusable fuzzy extractor from GA-DDH.
Figure 4. Design of reusable fuzzy extractor from GA-DDH.
Symmetry 17 01065 g004
Figure 5. Instantiation of reusable fuzzy extractor from LHS.
Figure 5. Instantiation of reusable fuzzy extractor from LHS.
Symmetry 17 01065 g005
Figure 6. Instantiation of reusable fuzzy extractor from GA-DDH.
Figure 6. Instantiation of reusable fuzzy extractor from GA-DDH.
Symmetry 17 01065 g006
Table 1. Comparison with some existing reusable fuzzy extractor constructions. “*” is used to distinguish different works with the same abbreviation. “weak” means that any PPT adversary cannot distinguish R i from uniform strings when given the { P i } i [ ρ ] . “strong” means that any PPT adversary cannot distinguish R i from uniform strings, even when given the { P j } j [ ρ ] and { R j } j i , j [ ρ ] . “linear” and “sublinear” represent the ability to correct the linear fraction of errors and sublinear fraction of errors, respectively. “IT” denotes Information-theoretic. “H-KS-Free” represents whether reusability does not rely on the homomorphism or key-shift security of the building blocks. “Src. Entropy” denotes the entropy requirement of the fuzzy source. “Comp.Cost” refers to the computational cost of RFE.Gen and RFE.Rep, primarily involving modular exponentiations and group actions (exp, ★). Here, t : = | w | / log p (where | w | is the bit-length of the input and p is the order of G ^ , as defined in [10]), and l and n are dimensions of the sampled matrix in Scheme 1. “PQ-Res.” indicates post-quantum resistance.
Table 1. Comparison with some existing reusable fuzzy extractor constructions. “*” is used to distinguish different works with the same abbreviation. “weak” means that any PPT adversary cannot distinguish R i from uniform strings when given the { P i } i [ ρ ] . “strong” means that any PPT adversary cannot distinguish R i from uniform strings, even when given the { P j } j [ ρ ] and { R j } j i , j [ ρ ] . “linear” and “sublinear” represent the ability to correct the linear fraction of errors and sublinear fraction of errors, respectively. “IT” denotes Information-theoretic. “H-KS-Free” represents whether reusability does not rely on the homomorphism or key-shift security of the building blocks. “Src. Entropy” denotes the entropy requirement of the fuzzy source. “Comp.Cost” refers to the computational cost of RFE.Gen and RFE.Rep, primarily involving modular exponentiations and group actions (exp, ★). Here, t : = | w | / log p (where | w | is the bit-length of the input and p is the order of G ^ , as defined in [10]), and l and n are dimensions of the sampled matrix in Scheme 1. “PQ-Res.” indicates post-quantum resistance.
ConstructionsReuseErr.
Rate
Assump.H
-KS
-Free
Src.
Entropy
Comp.
Cost
PQ
-Res.
WLG191 [11]strong LWE H ( W ) m
CFPRS16 [7]strongsublinearStrong
DDH
H ˜ ( W j 1 , , W j k
j 1 , , j k ) α
ACEK17 [37]strong LWE W i χ
Boy04 [6]weak IT H ˜ ( W i Δ W i , j )
= H ˜ ( W i )
WL18 [9]strong LWE H ( W ) m
WL18 * [10]strong DDH
+DLIN
H ( W ) m ( 2 n 2 + 3 ) exp
WLH18 [8]strong DDH H ˜ ( W i Δ W i , j )
m
WLG192 [11]stronglinearDDH H ( W ) m 6 exp
LLGC20 [12]strong LPN H ( W ) m
ZLH24 [13]strong EGA
-WPR
H ( W ) m 4 exp +   4  
ZLH24 * [14]strong EGA
-WPR
H ( W ) m 3 exp +   2  
our scheme 1strong LHS H ( W ) m [ l ( n + 1 ) ] exp
+ ( l + 2 )  
our scheme 2strong GA
-DDH
H ( W ) m 1 exp +   3  
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. Reusable Fuzzy Extractor from Isogeny-Based Assumptions. Symmetry 2025, 17, 1065. https://doi.org/10.3390/sym17071065

AMA Style

Wen Y, Jin T, Li W. Reusable Fuzzy Extractor from Isogeny-Based Assumptions. Symmetry. 2025; 17(7):1065. https://doi.org/10.3390/sym17071065

Chicago/Turabian Style

Wen, Yunhua, Tianlong Jin, and Wei Li. 2025. "Reusable Fuzzy Extractor from Isogeny-Based Assumptions" Symmetry 17, no. 7: 1065. https://doi.org/10.3390/sym17071065

APA Style

Wen, Y., Jin, T., & Li, W. (2025). Reusable Fuzzy Extractor from Isogeny-Based Assumptions. Symmetry, 17(7), 1065. https://doi.org/10.3390/sym17071065

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