Post-Quantum Secure Lightweight Revocable IBE with Decryption Key Exposure Resistance

TL;DR

This paper introduces a new post-quantum secure identity-based encryption system that efficiently handles user revocation and maintains security even if decryption keys are exposed.

Contribution

A dual-key trapdoor method is proposed to reduce ciphertext redundancy in revocable identity-based encryption with decryption key exposure resistance.

Findings

The proposed scheme generates a single ciphertext per plaintext message, reducing computational and communication overhead.

The system achieves post-quantum security based on LWE and ISIS hardness assumptions.

Indirect revocation is enabled through controllable key derivation using identity and time keys.

Abstract

Revocable Identity-Based Encryption (RIBE) can dynamically revoke users whose secret keys have been compromised, ensuring a system’s backward security. An RIBE scheme with decryption key exposure resistance (DKER) guarantees the confidentiality of ciphertext during any time period where the decryption key remains undisclosed. Existing RIBE schemes with DKER generate O(rlog(N/r)) ciphertexts for each plaintext message. Redundant ciphertexts impose significant computational burdens on users and substantial communication overhead on the system. To reduce high computation and communication overhead in existing schemes, this paper proposes a dual-key combination trapdoor generation method. Based on the proposed method, an indirect RIBE scheme with DKER is constructed, reducing ciphertext redundancy and obtaining computation and communication efficiency. Firstly, this paper proposes a dual-key combination trapdoor generation mechanism. By constructing an Inhomogeneous Small Integer Solution (ISIS) instance, the Key Generation Center (KGC) generates and distributes short bases to users as their identity keys. Subsequently, based on the constructed ISIS instance, a new inverse ISIS instance is derived. Furthermore, during each time period, KGC generates short bases for all non-revoked users as their time keys. By linearly combining their identity key with the corresponding time key, every non-revoked user can derive a re-randomized decryption key, achieving controlled key derivation. Secondly, based on the proposed method, a Post-Quantum Secure, Lightweight RIBE scheme with DKER (PQS-LRIBE-DKER) is constructed. For every non-revoked user, their identity key and time key serve as their own user secret key and key update, respectively. Controllable key derivation enables indirect revocation of the scheme. By adopting an indirect revocation, the PQS-LRIBE-DKER scheme achieves a single ciphertext per plaintext message, significantly reducing the sender’s computational load and the system’s communication overhead. Finally, under the hardness assumptions of the Learning with Errors (LWE) and ISIS problems, we prove that the proposed scheme achieves selective identity security in the standard model.

Figures

Full text

1. Introduction

In Identity-Based Encryption (IBE), the users’ identities serve as public keys, obviating digital certificates and eliminating the complex burden of certificate storage and management inherent in traditional public key infrastructures [1]. However, this characteristic also poses a critical challenge for IBE: how to achieve efficient user revocation when faced with key compromise or expiration.

Boneh first proposed a user revocation mechanism for the IBE scheme [2]. In his Revocable IBE (RIBE) scheme, the public key consists of the user identity and time period. The Key Generation Center (KGC) revokes users by regenerating and distributing new secret keys to all non-revoked users at each time period, which incurs a computational overhead proportional to the number of non-revoked users. In practical scenarios, the number of non-revoked users typically far exceeds that of revoked users. Consequently, Boneh’s revocation approach exhibits significant deficiencies in both efficiency and practicality.

To alleviate the efficiency bottleneck, Boldyreva et al. introduced the complete subtree method [3], which avoids generating secret keys individually for every non-revoked user per time period. This scheme assigns users to leaf nodes and calculates the smallest subtree set covering all non-revoked users. KGC generates time keys only for set nodes. This significantly reduces KGC’s computational complexity from $[eqn]$ to $[eqn]$ , where *N *is the total number of users and *r *is the number of revoked users. This scheme achieves revocation by preventing revoked recipients from decrypting messages, which is referred to as indirect revocation.

As research progressed, scholars uncovered new security vulnerabilities in RIBE schemes. In the scheme of [4], the decryption key for each time period is concatenated from the secret key and the key update for that period. Leaking any single period’s decryption key reveals the user’s long-term secret key, thereby compromising ciphertext confidentiality across all time periods. To counter this threat, Seo et al. introduced the decryption key exposure resistance (DKER) and constructed an RIBE scheme with DKER, which guarantees that even after a decryption key compromise, ciphertext confidentiality for all other periods remains secure [5].

Subsequently, RIBE schemes with DKER based on bilinear or multilinear pairings rapidly evolved. However, the rapid advancement of quantum computing threatens to break cryptographic schemes based on traditional mathematical hard problems. Consequently, research on post-quantum secure RIBE schemes with DKER has become an important topic.

1.1. Motivations

To implement DKER, users in Reference [6] autonomously generate re-randomized decryption keys for arbitrary time periods based on their secret keys. As shown in Figure 1a, KGC distributes a short basis corresponding to each user’s identity-based public key matrix as the user’s secret key. Then, the user employs the short basis trapdoor to solve for the randomized short vector corresponding to an identity–time matrix, which serves as the decryption key. This scheme excludes revoked users from the sender’s encryption list to revoke users. The sender has to generate $[eqn]$ ciphertexts for each plaintext message, significantly increasing the computational overhead on the sender and the communication overhead on the system.

In addition to the direct revocation discussed above, IBE also incorporates indirect revocation. As shown in Figure 1b, KGC distributes an identity-related secret key to each user. In each time period, the KGC distributes key updates to non-revoked users. Non-revoked users utilize these two keys to generate their decryption keys. Indirect revocation works by ensuring that revoked users cannot obtain decryption keys, thus losing decryption capability. The sender encrypts without excluding revoked users, effectively reducing the number of ciphertexts required and alleviating the system’s communication overhead. Consequently, designing RIBE schemes that support both indirect revocation and DKER has emerged as a significant research direction.

1.2. Contributions

As a solution to the heavy computational burden and high system communication overhead caused by direct revocation in previous RIBE schemes with DKER, this paper proposes a dual-key combination trapdoor generation mechanism to achieve indirect revocation. This enables the construction of a lightweight RIBE scheme with DKER. The contributions are as follows:

• Proposing a dual-key combination trapdoor generation mechanism

• Starting from an Inhomogeneous Small Integer Solution (ISIS) instance, KGC generates and distributes short bases to users of different identities as their identity keys.

• In each time period, the KGC constructs a new ISIS instance using the additive inverse of the target matrix and generates short bases as time keys for non-revoked users. Due to the target matrix in the ISIS instance, users cannot directly compute the decryption key for any time period using the short basis alone.

• Non-revoked users must linearly combine their identity key and time key to obtain the short basis trapdoor corresponding to the public key matrix, thus solving for the current time period’s re-randomized decryption key. By allowing non-revoked users to compute the current decryption key from both keys while denying this capability to revoked users, the scheme successfully achieves controlled key derivation.

• Constructing a post-quantum secure lightweight RIBE scheme with DKER

• By adopting the above mechanism for key generation and distribution, treating identity keys as user secret keys and time keys as key updates, we construct a Post-Quantum Secure, Lightweight RIBE scheme with DKER (PQS-LRIBE-DKER).

• Controllable key derivation enables indirect revocation in the scheme. Ultimately, the scheme shifts the periodic computational burden of revocation to a more powerful KGC, maintains a one-to-one correspondence between plaintext and ciphertext, and significantly reduces the sender’s computational load and the system’s communication overhead.

• Providing rigorous formal security proofs

• Assuming the hardness of the Learning with Errors (LWE) and ISIS problems, the proposed scheme has been proven to possess selective identity security in the standard model.

1.3. Related Works

Boneh et al. proposed the first RIBE scheme, which relies on traditional bilinear pairing assumptions [2]. In 2012, building upon the work of Agrawal et al. [7] and incorporating the complete subtree method [3], Chen et al. presented the first lattice-based RIBE scheme [8]. In 2016, Nguyen et al. proposed the first lattice-based server-aided revocable IBE scheme [9], which significantly reduces the users’ computational burden through an innovative server-assisted revocation mechanism. In 2021, Zhang et al. presented the first lattice-based RIBE with server-aided ciphertext evolution, preventing revoked users from accessing ciphertexts created prior to revocation [10]. In 2022, Zhang et al. introduced a scalable revocable IBE scheme with cloud-aided ciphertext update, achieving constant-size ciphertexts and a streamlined update mechanism [11]. In 2023, Chen et al. proposed a more efficient cloud-assisted ciphertext-evolving RIBE scheme [12]. In 2024, Huang et al. proposed a generic framework for post-quantum secure identity-based matchmaking encryption with revocable decryption keys, constructed from an identity-based signature scheme and a revocable hierarchical IBE scheme [13]. In 2025, Takayasu et al. presented an RIBE scheme based on the Middle-Product LWE (MPLWE) hardness assumption, achieving the shortest master public key and ciphertext lengths [14].

In 2013, Seo and Emura first introduced the concept of DKER and constructed the first RIBE scheme with DKER based on bilinear pairings [5]. In 2017, Takayasu and Watanabe proposed a lattice-based RIBE scheme satisfying Bounded-DKER (B-DKER), a security model weaker than full DKER [15]. In 2019, Katsumata et al. realized a hierarchical RIBE scheme with DKER and proved its security against selective-identity attacks in the standard model [16]. In 2023, Wang et al. introduced an Enhanced DKER (En-DKER) security notion and constructed a lattice-based RIBE scheme with En-DKER supporting direct revocation [6]. In 2025, Huang et al. proposed an integrated revocation model and used it to construct an efficient lattice-based online/offline integrated revocable IBE scheme with En-DKER [17].

In terms of applications, in 2021, Xia et al. employed an adaptively chosen-ciphertext secure RIBE scheme based on bilinear pairings for IoT device authentication [18]. RIBE schemes have also demonstrated significant potential in authenticated key exchange and proxy re-encryption [19,20]. In 2025, Zhu et al. proposed a revocable hierarchical identity-based inner-product functional encryption scheme with a malicious user revocation mechanism, designed to address patient privacy concerns in smart healthcare systems [21].

2. Preliminaries

This paper assumes line vectors. Bold uppercase letters denote matrices, e.g., A. Bold lowercase letters denote vectors, e.g., b. $[eqn]$ represents the set of real numbers, $[eqn]$ represents the set of integers, and $[eqn]$ represents the set of natural numbers. $[eqn]$ denotes the $[eqn]$ norm of vector x. The norm of a matrix is the largest $[eqn]$ norm among its rows: $[eqn]$ .

Definition 1. (Full-Rank Differences). *Let q be a prime and n be a positive integer. We say that a function H: * $[eqn]$ is an encoding with full-rank differences if the following criteria are met:

1. *For all distinct u, v

$[eqn]$ *, the matrix * $[eqn]$ is full rank; 2. $[eqn]$ is computable in polynomial time in nlogq.

2.1. Lattice and Discrete Gaussians

Let $[eqn]$ be a set of *n *linearly independent vectors. The n-dimensional lattice generated by the basis B is defined as

$$[eqn]$$

Let n, m, and *q *be positive integers. For a matrix $[eqn]$ , this paper employs two types of m-dimensional full-rank integer lattices defined by A:

$$[eqn]$$

For any $[eqn]$ , the Gaussian function on $[eqn]$ with center c and parameter *s *is defined as follows:

$$[eqn]$$

For any $[eqn]$ , and real number $[eqn]$ , an n-dimensional lattice $[eqn]$ , the discrete Gaussian distribution is defined as follows:

$$[eqn]$$

For any ordered set of *n *linearly independent vectors $[eqn]$ , let $[eqn]$ denote the Gram–Schmidt orthogonalized vectors of S.

2.2. Useful Facts

Lemma 1.****(Leftover Hash Lemma [7]). Suppose that m > (n + 1)  $[eqn]$ *and that q > 2 is prime. Let R be an m × k matrix chosen uniformly in * $[eqn]$ *where k = k(n) is polynomial in n. Let A and B be matrices chosen uniformly in * $[eqn]$ *and * $[eqn]$ *respectively. Then, for all vectors w in * $[eqn]$ , the distribution (A, AR, $[eqn]$ *) is statistically close to the distribution (A, B, * $[eqn]$ ).

Lemma 2.****(Smudging Lemma [22]). *Let * $[eqn]$ *be two polynomials over the integers, and let * $[eqn]$ *be any * $[eqn]$ *-bounded distribution family. Let * $[eqn]$ be the uniform distribution over the integers in [− $[eqn]$ *]. The family of distributions * $[eqn]$ are statistically indistinguishable if there exists a negligible function negl ( $[eqn]$ *) such that for all * $[eqn]$ *it holds that * $[eqn]$ negl $[eqn]$ .

2.3. Sampling Algorithms

Lemma **3.****([7]).**Let n $[eqn]$ ,m $[eqn]$ , q  $[eqn]$ 2

• $[eqn]$ : On input q, n, output a pair ( $[eqn]$ *) such that A is statistically close to a uniform matrix in * $[eqn]$ *and S is a basis for * $[eqn]$ *satisfying * $[eqn]$ *and * $[eqn]$   $[eqn]$ . $[eqn]$ *: On input a rank n matrix A in * $[eqn]$ *, a matrix * $[eqn]$ *, a short basis * $[eqn]$ *of * $[eqn]$ *, a Gaussian parameter * $[eqn]$ , output a vector  $[eqn]$ *sampled from a distribution statistically close to * $[eqn]$ . $[eqn]$ *: On input a rank n matrix A in * $[eqn]$ *, the gadget matrix G and its trapdoor * $[eqn]$ *, and a Gaussian parameter * $[eqn]$ , output a vector  $[eqn]$ *sampled from a distribution statistically close to * $[eqn]$ .

2.4. Hardness Assumptions

Definition 2.( $[eqn]$  [23]). *Given m independent samples * $[eqn]$ *where every sample is distributed according to either (1) * $[eqn]$ with  $[eqn]$ *for a uniformly random * $[eqn]$ (fixed for all samples), or uniform distribution, distinguish which is the case with non-negligible advantage.

Definition 3.(ISIS [24]). The Inhomogeneous Small Integer Solution problem is as follows: given an integer q, a matrix A $[eqn]$ *, a syndrome * $[eqn]$ *, and a real * $[eqn]$ *, find an integer vector * $[eqn]$ *such that * $[eqn]$ *and * $[eqn]$ .

Definition 4. (Preimage Sampleable Function).*The function * $[eqn]$ *maps inputs from the domain * $[eqn]$ to the range $[eqn]$ *. For any * $[eqn]$ *, the probability that * $[eqn]$ *output a particular value in * $[eqn]$ *is the same as any other value in * $[eqn]$ .

2.5. Complete Subtree

The PQS-LRIBE scheme adopts the complete subtree method from Reference [3] to reduce the periodic workload of KGC. During the setup phase, KGC constructs a binary tree BT, where user identities are assigned and stored at leaf nodes. A user’s secret key is composed of the keys at each node along the path from the root to that leaf. During the key update phase, KGC uses the algorithm KUNodes to compute the minimal node set $[eqn]$ covering all non-revoked users. It then generates key updates only for nodes within this set. Non-revoked users derive new decryption keys for the current time period based on valid nodes along their path, while revoked users lose decryption capability due to the absence of a valid key update. Let RL denote the revocation list. Let $[eqn]$ denote the set of all nodes on the path from the leaf node $[eqn]$ to the root node (including both the leaf and the root). Let $[eqn]$ be a node in the BT, and let $[eqn]$ and $[eqn]$ represent its left and right child nodes, respectively.

$$[eqn]$$

3. Formal Definitions for RIBE with DKER

3.1. Scheme Model for RIBE with DKER

An RIBE scheme consists of the six algorithms (Setup, GenSK, KeyUp, Enc, GenDK, Dec). The syntactic definition of the RIBE does not include an explicit revocation algorithm; the revocation is performed simply by adding the user’s identity to the revocation list RL.

$[eqn]$ (PP, MSK): Executed by KGC, this algorithm takes a security parameter $[eqn]$ and the maximum number of users *N *in the system as input, generating the system public parameters PP and the system master secret key MSK as output.

$[eqn]$ : Executed by the KGC, this algorithm takes the system public parameters PP, the master secret key MSK, and a user’s identity ID as input, generating a secret key $[eqn]$ as the output.

$[eqn]$ : Executed by KGC, this algorithm takes the system public parameters PP, the master secret key MSK, and the revocation list RL as input, generating the key update $[eqn]$ for time period *t *as output.

Enc $[eqn]$ : Executed by the sender, this algorithm takes the system public parameters PP, a user’s identity ID, a plaintext message m, and a time period *t *as input, generating a ciphertext $[eqn]$ as output.

$[eqn]$ : Executed by the receiver, this algorithm takes the system public parameters PP, a secret key $[eqn]$ , and a key update $[eqn]$ as input, generating the decryption key $[eqn]$ for the receiver with identity in time period *t *as output.

$[eqn]$ : Executed by the receiver, this algorithm takes a ciphertext $[eqn]$ and a decryption key $[eqn]$ as input, generating the plaintext message m as output.

Correctness:For all $[eqn]$ , and any revocation list RL, the RIBE scheme satisfies correctness if the following probability equation holds:

$$[eqn]$$

3.2. Security Model for RIBE with DKER

The selective identity security of the RIBE scheme against chosen plaintext attacks is defined through a game between an adversary $[eqn]$ and a challenger $[eqn]$ in Figure 2. Let the current time period be denoted as $[eqn]$ , which is a global variable initialized to 1.

Definition **5.***An RIBE with DKER scheme is selectively secure if the advantage $[eqn]$ **is negligible for any PPT adversaries * $[eqn]$ .

To simplify the reduction, this paper categorizes the adversary $[eqn]$ into two types:

Type I: $[eqn]$ queries the secret key $[eqn]$ corresponding to the challenge identity $[eqn]$

Type II: $[eqn]$ does not query the secret key $[eqn]$ corresponding to the challenge identity $[eqn]$ .

4. Dual-Key Combination Trapdoor Generation Mechanism

KGC directly distributes a short basis trapdoor to users based on their public key matrix, enabling them to compute re-randomized decryption keys for DKER. This allows users to derive decryption keys for any time period using that trapdoor. However, this approach restricts the scheme to direct revocation, resulting in a ciphertext-to-plaintext ratio of $[eqn]$ , which significantly increases the computational burden on users and the system’s communication overhead. Therefore, designing a more efficient IBE scheme that supports indirect revocation and DKER to enable lightweight user computation has become a critical research focus.

To overcome the limitations of the aforementioned schemes, this chapter proposes a dual-key combination trapdoor generation mechanism. First, KGC generates and allocates a short basis to each user based on an ISIS instance, which serves as their identity key. Subsequently, a new ISIS instance is constructed by taking the additive inverse of the original target matrix. Building upon this derived instance, KGC generates short bases as time keys for non-revoked users across different time periods. Due to the target matrix in the ISIS instance, users cannot directly compute decryption keys using only their identity keys. Non-revoked users must linearly combine their identity key with the corresponding time key. This combination neutralizes the target matrix in the ISIS instance, yielding the short basis trapdoor associated with the public key matrix, which in turn enables the computation of a re-randomized decryption key. Crucially, since time keys are only valid for non-revoked users, revoked users are unable to compute any valid decryption key, thus achieving controlled key derivation.

As shown in Figure 3, the specific procedural details are as follows:

Firstly, KGC generates an identity key $[eqn]$ for each user, satisfying $[eqn]$ . At this point, the identity key $[eqn]$ is no longer a trapdoor for $[eqn]$ and cannot be directly used to solve the short vectors of other instances.

Secondly, in each time period, KGC computes time keys $[eqn]$ for non-revoked users satisfying $[eqn]$ , where $[eqn]$ is a matrix representing the time period.

Finally, non-revoked users perform a linear combination of their identity key $[eqn]$ and time key $[eqn]$ This operation corresponds to adding the two key equations, which yields:

$$[eqn]$$

Through simple matrix block operations and vector concatenation, this equation can be rewritten as:

$$[eqn]$$

At this step, the non-revoked user obtains a short basis for the lattice $[eqn]$ , the matrix S $[eqn]$ .

The security of the proposed mechanism relies entirely on the computational hardness of the ISIS problem. Specifically, the core of its security hinges on the computational infeasibility of finding a short-norm solution vector s from the publicly available matrix $[eqn]$ that satisfies the equation $[eqn]$ .

The compromise of the ISIS problem would lead to a complete loss of confidentiality, as an adversary could derive valid decryption keys directly from public parameters—enabling decryption of any ciphertext for any identity across all time periods without requiring user-specific keys. Ultimately, such a scenario would trigger total system collapse, since the attack targets the cryptographic core rather than individual users, thereby invalidating all security guarantees and rendering the entire encryption scheme practically useless.

Based on the above mechanism, and drawing inspiration from the lattice-based delegation method in [6], we leverage the gadget matrix G to outsource the vector sampling operation during decryption key generation to untrusted servers, which further reduces the computational overhead for users. The scheme is constructed as follows:

Setup. KGC generates a matrix A and its corresponding trapdoor $[eqn]$ using a trapdoor generation algorithm. Matrix A serves as a system’s public parameter, while the trapdoor $[eqn]$ serves as the system’s master secret key.

Secret Key Generation. KGC inputs $[eqn]$ into the algorithm SampleLeft and generates a secret key $[eqn]$ for each user. This key satisfies the equation $[eqn]$ . Here, C is a public parameter, $[eqn]$ is a matrix representing the user identity, and G is the gadget matrix.

Key Update Generation. In each time period, KGC inputs $[eqn]$ into the algorithm SampleLeft. Given the equation $[eqn]$ , it generates and broadcasts key updates for non-revoked users. $[eqn]$ is a matrix representing the time period t.

Decryption Key Generation. The user possesses the short basis **S, **which satisfies $[eqn]$ . The receiver needs to generate the decryption key $[eqn]$ satisfying $[eqn]$ , where u is a public parameter. The user accomplishes this by outsourcing the sampling of an intermediate vector x satisfying $[eqn]$ to an untrusted server. After obtaining x, the user computes $[eqn]$ This derivation is valid because $[eqn]$ , which produces a valid short solution to the target equation.

5. Post-Quantum Secure, Lightweight RIBE Scheme with DKER

Parameters. We set the message space as $[eqn]$ , the identity space as $[eqn]$ , and the time period space as $[eqn]$ . Typically, time periods are treated as natural numbers, and a hash function $[eqn]$ is used to map natural numbers into vector form. For any $[eqn]$ denotes the uniformly random distribution on $[eqn]$ . Moreover, the selection of our security parameters is constrained by the following requirements: $[eqn]$ .

5.1. Setup

Input a security parameter $[eqn]$ and the maximum number of system users N. Output the system public parameter PP and master secret key MSK.

Run the trapdoor generation algorithm $[eqn]$ to generate a matrix $[eqn]$ and its corresponding trapdoor $[eqn]$ .Select uniformly random matrices B, W $[eqn]$ , and select an n-dimensional vector $[eqn]$ uniformly at random.Create a binary tree BT containing at least *N *leaf nodes. Mark all leaf nodes as unassigned. For each node $[eqn]$ in the binary tree, select a uniformly random matrix $[eqn]$ Output the system public parameters $[eqn]$ and the master secret key $[eqn]$ .

5.2. GenSK

Input the system public parameters PP, the master secret key MSK, and a user identity $[eqn]$ . Output the secret key $[eqn]$ corresponding to identity ID.

Randomly select an unassigned leaf node $[eqn]$ in the binary tree BT, and store the identity ID in this leaf node. Let $[eqn]$ denote the leaf node storing identity ID. Let $[eqn]$ denote the set of all nodes on the path from the leaf node $[eqn]$ to the root node (including both the leaf and the root).Let $[eqn]$ , where the hash function H is defined in Definition 1, and G is the gadget matrix in Lemma 3.For the identity ID and each node $[eqn]$ in $[eqn]$ , generate $[eqn]$ satisfying the equation $[eqn]$ , as follows:

• Select a uniformly random matrix $[eqn]$ . Compute $[eqn]$ .
• Sample $[eqn]$ .
• Split $[eqn]$ into two parts, the first m rows denoted as $[eqn]$ , and the last m rows denoted as $[eqn]$ . Similarly, split $[eqn]$ into $[eqn]$ and $[eqn]$ . Construct the key update matrix as: $[eqn]$ .

Output the secret key $[eqn]$ .

5.3. KeyUp

Input the system public parameters PP, the master secret key MSK, the revocation list $[eqn]$ for time period t, and the binary tree BT. Output the key update $[eqn]$ .

Run the KUNode algorithm, inputting the binary tree BT and the revocation list $[eqn]$ for time period t. This outputs the node update set $[eqn]$ for time period t.Compute $[eqn]$ , where the hash function H is defined in Definition 1, and G is the gadget matrix from Lemma 3.For each node in the $[eqn]$ , generate a key update $[eqn]$ satisfying the equation $[eqn]$ , as follows:

• Select a uniformly random matrix $[eqn]$ . Compute $[eqn]$ .
• Sample $[eqn]$ .
• Split $[eqn]$ into two parts, the first *m *rows denoted as $[eqn]$ , and the last *m *rows denoted as $[eqn]$ . Similarly, split $[eqn]$ into $[eqn]$ and $[eqn]$ . Construct the key update matrix as:

$$[eqn]$$

Broadcast the key update $[eqn]$ .

5.4. Enc

Input the system public parameters PP, a message $[eqn]$ , an identity $[eqn]$ , and a time period $[eqn]$ . Output ciphertext $[eqn]$ .

Select uniformly random matrices R, V $[eqn]$ , and select a uniformly random vector $[eqn]$ .Sample noise $[eqn]$ , and sample an m-dimensional noise vector $[eqn]$ .Compute: $[eqn]$ , $[eqn]$ , where $[eqn]$ is an identity matrix.Output the ciphertext $[eqn]$ .

5.5. GenDK

Input system public parameters PP, the secret key $[eqn]$ corresponding to the identity ID, and the key update $[eqn]$ for time period t. Output the decryption key $[eqn]$ .

Compare the binary tree nodes associated with their secret key against the nodes in the key update $[eqn]$ for time period t. If a common node exists, denote this node as $[eqn]$ and proceed with the following steps. Otherwise, the algorithm aborts.Select $[eqn]$ from their secret key $[eqn]$ and $[eqn]$ from the key update $[eqn]$ . Generate the decryption key $[eqn]$ satisfying the equation $[eqn]$ .

• Select a vector $[eqn]$ and compute $[eqn]$ .
• Sample $[eqn]$ .
• Construct the combined matrix S using the secret key component $[eqn]$ and the key update component $[eqn]$ : $[eqn]$ .
• Compute $[eqn]$ .
• Split the vector $[eqn]$ into three blocks of *m *elements each, denoted as $[eqn]$ , $[eqn]$ , and $[eqn]$ . Split the resulting vector $[eqn]$ into three blocks of *m *elements each, denoted as $[eqn]$ and $[eqn]$ . Construct the final decryption key vector:

$$[eqn]$$

Output decryption key $[eqn]$ .

5.6. Dec

Input the system public parameters PP, the ciphertext $[eqn]$ , and the decryption key $[eqn]$ . Output message $[eqn]$ .

Compute $[eqn]$ . If $[eqn]$ then $[eqn]$ ; otherwise $[eqn]$ .Output the message $[eqn]$ .

6. Performance Comparison

6.1. Correctness

Next, we analyze the correctness of the proposed scheme,

$$[eqn]$$

The error term in the decryption process is $[eqn]$ .

$$[eqn]$$

According to Lemma 1, $[eqn]$ .

According to Lemma 3, $[eqn]$ .

According to Lemma 3, $[eqn]$ , and similarly for other terms of this matrix.

According to Lemma 3, $[eqn]$ . Therefore, this analysis leads to the following upper bound for the error term:

$$[eqn]$$

When the parameters in the scheme satisfy the relation $[eqn]$ the scheme can successfully decrypt and recover the plaintext.

6.2. Security Analysis

Theorem 1. Under the decision-LWE and ISIS hardness assumptions, the proposed PQS-LRIBE-DKER scheme is provably secure in the IND-sID-CPA security model.

Proof. The selective identity security is proved through a series of games. The first game in this sequence is indistinguishable from the real IND-sID-CPA. In the final game of the sequence, the adversary’s advantage is zero. Since any probabilistic polynomial-time adversary cannot distinguish any two consecutive games in the sequence, the adversary’s advantage in winning the original IND-sID-CPA game is negligible. In conclusion, under the decision-LWE and ISIS hardness assumptions, the proposed scheme possesses selective identity security.Game 0: The adversary $[eqn]$ interacts with the challenger $[eqn]$ in the original IND-sID-CPA game as defined by the security model.Game 1: Building upon Game 0, the challenger $[eqn]$ generates matrices B and W in the following manner during the setup phase. Let $[eqn]$ and $[eqn]$ denote the challenge identity and challenge time period chosen by the adversary $[eqn]$ . The challenger $[eqn]$ moves the step of selecting matrices $[eqn]$ and $[eqn]$ forward to the setup phase, sampling uniformly random matrices $[eqn]$ . Then, compute the following:

$$[eqn]$$ $$[eqn]$$

Reduction from Game 0 to Game 1: According to Lemma 1, if a matrix A $[eqn]$ is selected uniformly at random, and a matrix $[eqn]$ is uniformly random, then the distribution of (A, AR) is statistically indistinguishable from the distribution of (A, E), where E is a uniformly random matrix in $[eqn]$ . Therefore, in Game 1, the distribution of matrix $[eqn]$ is statistically indistinguishable from the distribution of E to the adversary $[eqn]$ . The same applies to matrix W. Consequently, Game 0 and Game 1 are indistinguishable to the adversary $[eqn]$ .Game 2: Based on Game 1, the challenger $[eqn]$ changes the way of responding to secret key queries.For a Type I adversary, challenger $[eqn]$ needs to respond to queries for the secret key $[eqn]$ corresponding to the challenge identity. During the setup phase, set $[eqn]$ .

1. $[eqn]$ .For $[eqn]$ , select $[eqn]$ and compute $[eqn]$ .
2. $[eqn]$ .For $[eqn]$ , compute $[eqn]$ .

• Select $[eqn]$ and compute $[eqn]$ .

• Sample $[eqn]$ . For $[eqn]$ , select uniformly random matrices $[eqn]$ .

• Select $[eqn]$ and compute $[eqn]$ .

• Sample $[eqn]$ .

For a Type II adversary, challenger $[eqn]$ responds to secret key queries except challenge identity $[eqn]$ . In the setup phase, select uniformly random matrices $[eqn]$ .

1. ID ≠ ID^∗^.

• Select $[eqn]$ and compute $[eqn]$ .
• Sample $[eqn]$ .

Reduction from Game 1 to Game 2: In Game 1, the matrices $[eqn]$ are selected uniformly at random. In Game 2, the matrices $[eqn]$ are defined as $[eqn]$ where $[eqn]$ . According to the ISIS assumption, the output of the preimage sampleable function is uniformly random. Therefore, the matrices $[eqn]$ in Game 1 and Game 2 are indistinguishable to the adversary $[eqn]$ . Furthermore, in Game 1, the matrices $[eqn]$ are generated using the SampleLeft algorithm. In Game 2, the challenger samples the matrices $[eqn]$ using the SampleRight algorithm. According to Lemma 3, the statistical distance between the outputs of the SampleLeft and SampleRight algorithms is negligible, and the output of the SampleRight algorithm is computationally indistinguishable from the $[eqn]$ . Consequently, Game 1 and Game 2 are also indistinguishable to the adversary $[eqn]$ .Game 3: Building upon Game 2, the challenger $[eqn]$ modifies the method for responding to key update queries.For a Type I adversary, while the adversary $[eqn]$ is permitted to query the secret key $[eqn]$ corresponding to the challenge identity, according to the security model definition, the adversary $[eqn]$ is subsequently prohibited from querying the key update corresponding to the challenge time period.

1. $[eqn]$ .

• Select $[eqn]$ and set $[eqn]$ .
• Sample $[eqn]$ .

For a Type II adversary, the challenger $[eqn]$ must respond to the adversary’s query for the key update $[eqn]$ corresponding to the challenge time $[eqn]$ . The matrix $[eqn]$ is set as $[eqn]$ .

1. $[eqn]$ .For $[eqn]$ , select $[eqn]$ and return $[eqn]$ to the adversary $[eqn]$ .For $[eqn]$ ,

• Select $[eqn]$ and set $[eqn]$ .
• Sample $[eqn]$ .

2. $[eqn]$ .

• Select $[eqn]$ and set $[eqn]$ .
• Sample $[eqn]$ .

Reduction from Game 2 to Game 3: The difference between Game 2 and Game 3 lies in the method of generating key updates. In Game 2, the matrix $[eqn]$ is generated using the SampleLeft algorithm. In Game 3, the challenger selects the matrix $[eqn]$ from the $[eqn]$ obtaining it by sampling using the SampleRight algorithm. According to Lemma 3, the statistical distance between the outputs of the SampleLeft and SampleRight algorithms is negligible, and the output of the SampleRight algorithm is computationally indistinguishable from the $[eqn]$ distribution. Therefore, Game 2 and Game 3 are also indistinguishable to the adversary $[eqn]$ .Game 4: Building upon Game 3, the challenger $[eqn]$ modifies the method of generating decryption keys.For a Type I adversary, when $[eqn]$ , and $[eqn]$ , the challenger cannot simulate the key update $[eqn]$ . Challenger $[eqn]$ responds to decryption key queries for $[eqn]$ according to the following steps:

1. Select a matrix $[eqn]$ and compute $[eqn]$ .
2. Solve for the secret key $[eqn]$ satisfying the equation $[eqn]$ .

• Select a matrix $[eqn]$ and compute $[eqn]$ .
• Sample $[eqn]$ .

3. Compute $[eqn]$ using $[eqn]$ and $[eqn]$ .

• Select a vector $[eqn]$ and set $[eqn]$ .
• Sample $[eqn]$ .
• Compute $[eqn]$ using $[eqn]$ .
• Compute $[eqn]$ .
• Perform row blocking on the vector $[eqn]$ , dividing it into three blocks of *m *rows each, denoted as $[eqn]$ , $[eqn]$ , and $[eqn]$ . Perform row blocking on the $[eqn]$ , dividing it into three blocks of *m *rows each, denoted as $[eqn]$ , and $[eqn]$ . Construct the final decryption key vector by adding the corresponding blocks:

$$[eqn]$$

4. Output decryption key $[eqn]$ .

For a Type II adversary, when $[eqn]$ , and $[eqn]$ , the challenger cannot simulate the secret key $[eqn]$ . The challenger responds to decryption key queries for $[eqn]$ according to the following steps:

1. Select a matrix $[eqn]$ and let $[eqn]$ .
2. Next, solve for the key update $[eqn]$ satisfying the equation $[eqn]$ .

• Select a matrix $[eqn]$ and compute $[eqn]$ .
• Sample $[eqn]$ .

3. Compute the decryption key using $[eqn]$ and $[eqn]$ . The remaining steps are the same as in the scheme.

Reduction from Game 3 to Game 4: The difference between Game 4 and Game 3 exists in the method of generating decryption keys. In Game 3, the key update consists of a matrix $[eqn]$ and a matrix $[eqn]$ sampled via the SampleRight algorithm; the secret key consists of a matrix $[eqn]$ and a matrix $[eqn]$ . In Game 4, the key update is $[eqn]$ and the secret key is $[eqn]$ . For the adversary $[eqn]$ , the $[eqn]$ distribution is computationally indistinguishable from the output of the SampleRight algorithm. In the end, the decryption keys derived from the secret key and key update are indistinguishable for the adversary $[eqn]$ . Game 3 and Game 4 are also indistinguishable to the adversary $[eqn]$ .Game 5: Building upon Game 4, the challenger $[eqn]$ modifies the generation methods for matrices A, B, and W. In Game 4, the challenger $[eqn]$ uses the TrapGen algorithm to generate matrix A and its corresponding trapdoor $[eqn]$ , while selecting matrices B and W uniformly at random. In Game 5, the challenger selects the uniformly random matrix $[eqn]$ and uses the TrapGen algorithm to generate matrices B, W, and their corresponding trapdoors.Game 6: Building upon Game 5, the challenger $[eqn]$ modifies the method for generating the challenge ciphertext. In Game 6, the challenger $[eqn]$ randomly selects $[eqn]$ and $[eqn]$ as the challenge ciphertext.Reduction from Game 5 to Game 6: If the adversary $[eqn]$ can distinguish between Game 5 and Game 6, then the simulator $[eqn]$ can leverage the adversary $[eqn]$ to solve the decision-LWE problem.Assume the adversary $[eqn]$ can distinguish between Game 5 and Game 6 with a non-negligible probability. Then the simulator $[eqn]$ utilizes the adversary $[eqn]$ to solve the decision-LWE problem defined in Definition 2. The reduction process is as follows:Instance: Given the decision-LWE instance $[eqn]$ to simulator $[eqn]$ . The task for the simulator $[eqn]$ is to distinguish whether the $[eqn]$ are generated by $[eqn]$ or are chosen from a uniformly random distribution.Init: The adversary $[eqn]$ sends the challenge identity $[eqn]$ and challenge time period $[eqn]$ to the simulator BB.Setup: In the setup phase, the simulator $[eqn]$ constructs the matrix $[eqn]$ and sets $[eqn]$ .Query Phase: The adversary $[eqn]$ makes secret key queries, key update queries, decryption key queries, and revocation queries. The simulator $[eqn]$ responds to these queries according to the method used in Game 5.Challenge Phase: The adversary $[eqn]$ sends the plaintext messages $[eqn]$ to the simulator $[eqn]$ .The simulator $[eqn]$ generates the challenge ciphertext:

1. Let $[eqn]$ .
2. Compute $[eqn]$ . Send the challenge ciphertext $[eqn]$ to the adversary $[eqn]$ .

Guess Phase: After receiving the challenge ciphertext, the adversary $[eqn]$ makes a guess and returns b’. The simulator $[eqn]$ uses the adversary’s guess $[eqn]$ as the answer to the decision-LWE problem. Analysis:

• When $[eqn]$ , the challenge ciphertext is:

$$[eqn]$$ $$[eqn]$$

Therefore, when $[eqn]$ , the distribution of the challenge ciphertext is identical to that in Game 5.

• When the $[eqn]$ are uniformly random elements, the distribution of the challenge ciphertext is identical to that in Game 6.

Consequently, the advantage of the simulator $[eqn]$ for the decision-LWE problem equals the distinguishing advantage of the adversary $[eqn]$ between Game 5 and Game 6. Given that the simulator’s advantage is negligible, the adversary $[eqn]$ advantage must likewise be negligible. □

6.3. Comparison of Complexity

Table 1 presents a comparison of the proposed PQS-LRIBE-DKER scheme with other RIBE schemes with DKER across multiple key performance metrics. Specifically, KGC periodic workload refers to the computational effort required for KGC to execute undo operations within each time period; the user computational overhead includes the computational cost required to generate ciphertext during the encryption process.

In terms of security, both the Scalable RIBE with DKER scheme [5] and the Efficient RIBE with DKER scheme [25] are constructed based on traditional mathematical hard problems and cannot resist attacks from quantum computers. The LB-RIBE with B-DKER scheme [15] has an upper limit on the number of decryption key leaks, making it a bounded decryption key exposure resistance scheme.

For the LB-RHIBE with DKER scheme [16], users sample short vectors when generating decryption keys. Compared to the aforementioned schemes, the proposed PQS-LRIBE-DKER scheme enables the sampling process during decryption key generation to be outsourced to an untrusted third party, only needing to perform some simple matrix multiplication operations locally. In the LB-RIBE with En-DKER scheme [6], the sender needs to generate $[eqn]$ ciphertexts for a single plaintext message, while in the OO-IRIBE-EnDKER scheme [17], the number of ciphertexts is $[eqn]$ . The revocation in the LB-SA-RIBE scheme [26] requires a semi-trusted third-party server.

Table 2 presents a comparison between the PQS-LRIBE-DKER scheme and other lattice-based RIBE with DKER schemes, focusing on secret key length, key update length, decryption key length, and ciphertext length. Here, ciphertext length refers to the total length of the ciphertext generated by encrypting a single bit, while the parameters *n *and *m *denote the number of rows and columns of the matrix, respectively.

As shown in Table 2, the LB-RIBE with B-DKER scheme [15] achieves shorter key and ciphertext lengths, albeit with weaker security. The proposed PQS-LRIBE-DKER scheme offers multiple advantages: it employs a shorter decryption key than the LB-RHIBE with DKER scheme [16]; meanwhile, it also generates a shorter ciphertext length when encrypting a single bit compared to both the LB-RIBE with En-DKER scheme [6] and the OO-IRIBE-EnDKER scheme [17].

Table 3 compares the theoretical workload of users in our scheme with prior schemes across two dimensions: decryption key generation and ciphertext generation.

During the decryption key generation phase, users must execute the preimage sampling algorithm, which is the most computationally intensive and time-consuming operation in lattice-based cryptography, with a typical complexity of $[eqn]$ . Therefore, we use the number of invocations of the preimage sampling algorithm to measure the user’s workload for generating decryption keys. As shown in Table 3, both the LB-RIBE with B-DKER scheme [15] and the LB-RHIBE with DKER scheme [16] require users to perform preimage sampling once per time period to generate decryption keys. In contrast, the LB-RIBE with En-DKER scheme [6], OO-IRIBE-EnDKER scheme [17], and our proposed PQS-LRIBE-DKER scheme allow users to offload the sampling tasks to untrusted third-party servers, thereby completely avoiding this overhead.

In terms of ciphertext generation, the user’s workload is characterized by the number of ciphertexts produced. Table 3 shows that in the LB-RIBE with En-DKER scheme [6], encrypting a single plaintext message requires generating $[eqn]$ ciphertexts; in the OO-IRIBE-EnDKER scheme [17], the number of ciphertexts is $[eqn]$ , whereas our scheme requires only one ciphertext. This single-ciphertext characteristic ensures that the encryption process remains highly efficient, and its performance does not degrade as the system scales. In summary, our scheme imposes the lightest computational burden on users.

7. Conclusions

This paper addresses the excessive computational and communication overhead in existing RIBE schemes with DKER. It proposes a lightweight RIBE scheme with DKER. We design a dual-key combination trapdoor generation mechanism, enabling non-revoked users to controllably derive decryption keys for the current time period by linearly combining identity keys and time keys. Furthermore, based on this dual-key combination trapdoor generation mechanism, the proposed scheme implements indirect revocation. This successfully shifts the periodic computational burden to a more computationally capable KGC, significantly reducing user computational costs and system communication overhead while enhancing overall system efficiency. We compare our scheme with other similar schemes, showing that the computational burden on the user in our scheme is lower than that in others, achieving a lightweight design for the user. A promising direction for future work is to investigate the applicability of this mechanism to more complex access control paradigms, particularly attribute-based encryption.