Puncturable registered attribute-based keyword search for secure cloud data sharing
Figures
Abstract
Cloud data sharing requires methods that protect sensitive files while allowing authorized users to find and access them. Centralized key generation creates a risk of key escrow, while exposed user keys may compromise previously shared data. We develop a scheme that combines encrypted keyword search with selective restriction of decryption keys in a registered framework. Users generate their own secret keys, and a key curator verifies and aggregates public registration information. Owners attach descriptive keywords and tags to encrypted files. Search compares combined keyword representations, and each new index excludes users according to the owner’s current list. Users can update their keys to remove access to selected tags while retaining access to others. Protection against later key exposure requires secure erasure of earlier secret states; existing indexes are not automatically updated when the exclusion list changes. We analyze the mechanisms and compare their computational, communication, and storage costs with two related schemes. Under the tested configuration, registration and search costs remain close to the corresponding baselines, while the combined functionality adds encryption and decryption work. The scheme provides a framework for combining encrypted retrieval with selective key restriction, clarifying the associated cost trade-offs and conditions for its use.
Citation: Song Z, Guo Y, Jiang M, Yang Z (2026) Puncturable registered attribute-based keyword search for secure cloud data sharing. PLoS One 21(11): e0363164. https://doi.org/10.1371/journal.pone.0363164
Editor: Suo Gao, Dalian Polytechnic University, CHINA
Received: September 1, 2026; Accepted: November 4, 2026; Published: November 20, 2026
Copyright: © 2026 Song et al. This is an open access article distributed under the terms of the Creative Commons Attribution License, which permits unrestricted use, distribution, and reproduction in any medium, provided the original author and source are credited.
Data Availability: All relevant data are within the paper and its Supporting Information files. The numerical data underlying Figs 4–11 are provided in S1 Dataset. The corrected research implementation of PR-ABKS is publicly available under the MIT License at https://github.com/zeyangsong002-spec/PR-ABKS. Version v1.0.0 is archived in Zenodo at https://doi.org/10.5281/zenodo.23335024. The release supports functional verification and new benchmark runs; its correspondence with the manuscript experiments and associated limitations are documented in docs/EXPERIMENT_MAPPING.md.
Funding: This work was supported by the Natural Science Foundation of Anhui Higher Education Institutions (Grant Nos. 2025AHGXZK20015, 2025AHGXZK31100, and 2023AH050331 to Y.G.; https://jyt.ah.gov.cn/). The funder had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript.
Competing interests: The authors have declared that no competing interests exist.
Introduction
Cloud services allow individuals and organizations to store and share data without maintaining local infrastructure [1]. Sharing sensitive files requires control over access privileges, yet third-party servers cannot be assumed fully trusted. Data owners therefore need cryptographic control over outsourced data.
Ciphertext-policy attribute-based encryption (CP-ABE) [2] supports one-to-many sharing by embedding an access policy in the ciphertext. Decryption requires a user attribute set that satisfies that policy [3].
Access control alone does not help users locate relevant encrypted files. Attribute-based keyword search (ABKS) [4,5] addresses retrieval through encrypted indexes and query trapdoors [6]. The cloud evaluates matches without receiving plaintext query keywords, with keyword privacy defined by the scheme’s security model.
Many attribute-based schemes rely on an authority to generate user secret keys, creating a key-escrow risk. Registered ABE [7,8] instead lets users generate their own secrets. A key curator verifies and aggregates public registration information without holding those secrets [9].
Registered key management does not eliminate the consequences of user-key exposure. Puncturable encryption [10] lets an honest user update a key to exclude selected ciphertext tags before a subsequent compromise. Protection requires secure erasure of earlier usable secret states. User revocation [11] concerns a different operation: changing access to existing cryptographic objects requires an explicit update or authorization mechanism [12,13]. Here, the revocation list determines user exclusion when an index is generated.
Our objective is to bring tag-level key puncturing into registered keyword search. The construction combines local key restriction with encrypted retrieval and index-generation-time exclusion. The system model and correctness analysis specify the distinct scope of these mechanisms.
Contribution
We propose puncturable registered attribute-based keyword search (PR-ABKS), which combines encrypted retrieval and selective restriction of an updated decryption key within one registered framework. Its main contributions are as follows.
- Tag-level puncturing within registered keyword search. Users locally update their keys to exclude selected ciphertext tags while retaining access to other tags. This capability complements encrypted retrieval under the honest-update and secure-erasure assumptions.
- Registered key management with index-generation-time exclusion. Users generate their own secrets, while the key curator verifies and aggregates public registration information. The revocation-list snapshot determines which users are represented in each new index.
- Explicit characterization of search and cost. We derive the aggregate keyword-matching predicate and compare computation, communication, and storage costs with PR-ABE and RRABKS. The analysis identifies the cost of combining searchable and puncturable components.
Related work
Attribute-based encryption (ABE) is a widely adopted cryptographic primitive for enforcing fine-grained authorization in cloud data sharing. Bethencourt et al. [2] proposed CP-ABE, in which a data owner embeds an access policy into the ciphertext, and only users whose attributes meet the policy can recover the data. Subsequent works improved ABE from different aspects, such as outsourced decryption, verifiability, traceability, and revocation. For cross-domain sharing, Zhang et al. [14] combined CP-ABE with proxy re-encryption for industrial IoT, optimizing re-encryption-key generation and simplifying recipient-side decryption. Their construction focuses on delegated access across attribute domains and retains authority-issued attribute keys. Encrypted keyword retrieval and selective restriction of an updated user key address additional requirements in shared repositories.
To remove the key escrow problem, Garg et al. [19] introduced registration-based encryption, in which users generate their own key pairs and a key curator only aggregates public keys. Hohenberger et al. [7] extended this idea to registered ABE, allowing users to keep their secret keys under their own control while the KC manages public registration information. Li et al. [20] proposed a revocable registered ABE scheme with user deregistration, and Weng et al. [9] designed an efficient registered attribute-based access control scheme for mobile cloud computing. These schemes demonstrate that registered key management can reduce the trust placed on traditional authorities. However, they do not simultaneously support encrypted keyword search and puncturable access removal.
Puncturable encryption was introduced by Green and Miers [21] to revoke decryption capability for selected messages, recipients, or time periods without distributing new key material. Cui and Yi [22] proposed puncturable ABE with user revocation, where the authority broadcasts update information for key update. Ghopur et al. [23] designed a puncturable key-policy attribute-based encryption (KP-ABE) scheme for efficient user revocation. Li et al. [24] proposed a cloud data sharing system with flexible user revocation by introducing edge-server-assisted key puncturing. These works demonstrate that puncturing is effective for forward security, user revocation, and fine-grained access removal. However, they are not constructed under a registered ABKS framework and cannot simultaneously provide escrow-free key management and encrypted keyword search.
Federated learning offers a complementary approach to using distributed data through collaborative model training while retaining raw training data locally. Liu et al. [25] proposed FedCFE to balance client personalization and global knowledge sharing through composite feature extraction and knowledge distillation. Hu et al. [26] developed AISS-VFL to reduce communication overhead in vertical federated learning through adaptive importance-aware sample selection. Bi et al. [27] introduced FedSEA to improve knowledge exchange between client groups under heterogeneous data distributions. Bi et al. [28] further proposed FedDN to address noisy clients and noisy samples jointly through dual recognition and negative learning. These studies improve collaborative learning under data heterogeneity, communication constraints, and label noise. Their training objectives complement the encrypted retrieval and access-management requirements considered here.
The closest schemes are puncturable registered ABE (PR-ABE) by Wang et al. [29] and registered-based revocable ABKS (RRABKS) by Li et al. [30]. PR-ABE supplies registered key management and local puncturable key update but does not support keyword search. RRABKS supplies the registered searchable component used here. Our construction combines these mechanisms: encryption produces a tagged ciphertext and a searchable index, while local updates restrict the user’s decryption key. The correctness analysis derives the inherited aggregate search predicate and distinguishes index-generation-time exclusion from historical-index revocation.
Materials and methods
We introduce the cryptographic assumptions and system model, define the security requirements, and present the eight algorithms of PR-ABKS.
Cryptographic preliminaries
Bilinear pairing and the DBDH assumption.
Let G, be two multiplicative cyclic groups of order q, and g be the generator of G. The bilinear pairing function fulfills the following properties.
- Bilinearity: For , .
- Non-degeneracy: .
- Computability: , can be computed efficiently.
Decisional Bilinear Diffie-Hellman (DBDH) assumption: Given the tuple , where and , the DBDH assumption is to determine whether P is equal to .
Binary tree.
Let L denote the set of users in the scheme, and let R denote the revocation list. The binary tree BT is defined below:
- The user i is associated with a leaf node in the binary tree. For users in the scheme, the tree contains nodes. We use the breadth-first search method to assign numbers to the nodes so that the root node is numbered 0 and the last leaf node is numbered .
- The function path(i) denotes the path from the root to node i, and cover(R) is a minimum set of nodes covering all users not in the revocation list R.
- For each non-revoked user i, there is a unique node such that .
In Fig 1, gives cover(R) = {4,5,8,14}. User u6 is assigned leaf 12, so path(u6) = {0,2,5,12} and . The selected node is therefore .
Let denote the leaf assigned to user j; path(j) abbreviates . For , this path intersects cover(R) at one node. A cover node may represent several users, but and retain user-level subscripts and distinct identity keys. Cover nodes must therefore not replace user identities in component counts. Each index uses a fixed revocation-list snapshot, denoted Renc.
System model and threat model
The main notations are summarized in Table 1.
System model and entities.
The proposed scheme is designed for secure cloud data sharing with fine-grained access control, aggregate keyword matching, index-generation-time user exclusion, and local key puncturing. The system consists of four entities: the key curator (KC), the cloud server (CS), data owners (DOs), and data users (DUs) as depicted in Fig 2.
KC: The key curator initializes the system, verifies public registration information, aggregates valid public keys, and generates auxiliary tokens. It neither generates nor stores users’ secret keys.
DOs: A data owner defines an access policy, selects a keyword set, and assigns a ciphertext tag set for the shared data. It encrypts the data under the master public key, generates the corresponding searchable index, and uploads the ciphertext and index to the cloud server.
The owner supplies Renc when generating an index. A later list change affects new index generation; it triggers no update to stored indexes, keys, or trapdoors. The KC retains its registration duties, and the CS evaluates indexes as stored.
CS: The cloud server stores ciphertexts and indexes, evaluates query trapdoors, and returns matching ciphertexts. It may perform the specified partial decryption using public information and auxiliary tokens, but it does not recover plaintext.
DUs: Users generate their own key pairs, submit public registration information, and create query trapdoors. They can puncture local keys and decrypt returned ciphertexts when the attribute policy and the current key’s tag restrictions permit.
Threat model and security requirements.
The KC follows the registration and aggregation procedures but is not trusted with user secret keys. The cloud server is modeled as honest-but-curious: it stores ciphertexts, evaluates encrypted indexes, and performs the prescribed partial-decryption operations, while attempting to infer plaintexts or keywords from the information it observes. Data users may be revoked or corrupted, and the adversary may adaptively request public keys, registration outputs, key updates, corruptions, and query trapdoors subject to the challenge restrictions defined below. The two principal security requirements are data confidentiality after key updates and privacy of the keywords embedded in searchable indexes.
User exclusion is evaluated against Renc; the construction has no historical-index or ciphertext update algorithm. Post-puncture confidentiality concerns an honest device that completes and erases all earlier usable secret states before compromise. Erasure covers old key copies, recoverable backups, and randomness or key-generation secrets, such as , that could reconstruct an earlier key with available parameters. Public registration outputs and auxiliary tokens remain available to the adversary. The objective excludes a malicious holder who retains an earlier usable key. Puncturing does not alter other users’ keys or remove previously recovered plaintext. Secure erasure is an exposure assumption, not a capability enforced by .
Let K and Q be finite keyword sets using a common, unambiguous keyword representation, and define
with the empty product equal to . For correctly matched identity components, tests F(K) = F(Q) rather than . Equal aggregates need not imply equal sets, and collision resistance of individual hash evaluations does not establish an aggregate-collision bound. The correctness analysis treats equal, subset, and other query sets. Throughout this paper, matching refers to this aggregate predicate unless literal set equality is stated.
For the IND-KU-CPA game, let denote the challenge access policy. A disclosed key state of user i, with punctured-tag set , is inadmissible if both
Here, means that the registered attributes of user i satisfy the challenge policy. This restriction applies to every disclosed state of every user, including non-target users. Before issuing a challenge, the challenger checks all prior disclosure records against the chosen policy and tag set; after the challenge, it rejects any disclosure that violates the same condition. A later puncture cannot make an earlier inadmissible disclosure admissible. Public registration information and the auxiliary tokens returned by remain available to the adversary; their secrecy is not an admissibility assumption. This restriction excludes direct decryption using an exposed, policy-satisfying unpunctured key. It does not, by itself, establish the security reduction or rule out attacks combining admissible information.
The data confidentiality of PR-ABKS is defined by the indistinguishability under key updating and chosen-plaintext attacks, denoted as IND-KU-CPA. The security game is played between a challenger and a PPT adversary as follows.
init: declares the challenge tag set . Meanwhile, selects a target user index , maintains an initially empty punctured-tag list for each user i, and records every disclosed key state together with its punctured-tag set at the time of disclosure. These records are not replaced by later key updates.
: executes the algorithm and publishes the common reference string crs.
Query I: can adaptively make the following queries.
- : When issues this query on , executes and returns to .
- : When issues this query on and , executes and returns to .
- : When issues this query with a tag on , executes and inserts into .
- : For a query on , considers the latest state . If the challenge has been fixed and the disclosure is inadmissible under the above condition, it returns . Otherwise, it records and returns that state. A disclosure before the challenge is checked when the challenge is chosen. As in the specified game, after a successful corruption disclosure, all subsequent oracle queries return ; the challenge and final guess are not oracle queries.
Challenge: submits two equal-length plaintexts , a master public key , an access policy , the attached tag set , and a revocation list . The challenger checks every prior disclosure record, for target and non-target users alike, against and . If any disclosed state satisfies the inadmissibility condition above, it rejects the challenge. Otherwise, chooses a random bit , executes the algorithm with to compute the challenge ciphertext and returns it to .
Query II: Subject to the post-corruption stopping rule, may issue the queries of Query I. The challenger rejects any corruption query that would disclose an inadmissible state, regardless of whether the queried user is . It evaluates the punctured-tag set of the state being disclosed, not a later state.
Guess: outputs a bit and wins the game if . The advantage of in the above game is defined as .
Definition 1. The proposed PR-ABKS scheme is IND-KU-CPA secure if, for any PPT adversary , is negligible in the security parameter .
The puncture restriction is evaluated on the key state at the time it is disclosed. A later update cannot make an earlier disclosure of an unpunctured challenge-capable key admissible. The game therefore does not model recovery of confidentiality after such a key has already leaked. In particular, the target-key restriction above must not be interpreted as allowing an unpunctured, policy-satisfying non-target key to be disclosed for the same challenge: any such disclosure would give a direct decryption attack and is excluded from the confidentiality objective.
The keyword privacy of PR-ABKS is defined by indistinguishability against chosen keyword attacks, denoted as IND-CKA. This game captures whether an adversary can distinguish which one of two chosen keyword sets is embedded in the challenge index. The security game is played between a challenger and a PPT adversary as follows.
init: commits to the number of key-generation queries and specifies the static user setting. runs to generate crs and sends crs to . The challenger internally maintains the registration information required for generating query trapdoors.
Query I: can adaptively access the following oracles.
- : specifies a user index . executes and returns to .
- : When issues this query on a user index and a query keyword set Q, executes and returns the trapdoor to .
Challenge: submits two keyword sets and of equal size, an access policy , a plaintext , the attached tag set , and a revocation list . The challenge is admissible only if has not queried a trapdoor that can directly test the challenge keyword sets for an unrevoked valid user. In particular, is not allowed to obtain for or when and the search identity of i is valid. If the admissibility condition is not satisfied, rejects this challenge. Otherwise, chooses a random bit , executes the algorithm with the keyword set and returns the challenge ciphertext to .
Query II: can further make queries as in Query I, except that it is not allowed to query a trapdoor that directly tests or for an unrevoked valid user.
In both phases, direct testing refers to the actual aggregate predicate. Thus, for a valid identity not excluded by , trapdoors satisfying or are inadmissible, even when Q is a different keyword set. Literal set equality in the examples above is a sufficient, not an exhaustive, reason to reject a query. This restriction does not assert that the aggregate map is collision-free.
Guess: outputs a bit and wins the game if . The advantage of in the above game is defined as .
Definition 2. The proposed PR-ABKS scheme is IND-CKA secure if, for any PPT adversary , is negligible in the security parameter .
Scheme construction
Algorithm overview.
As shown in Fig 3, the proposed scheme consists of eight algorithms. Their inputs, outputs, and responsibilities are summarized below; the subsequent subsection gives the complete construction.
- : This algorithm is run by the KC. It takes as input the security parameter , the attribute universe , the maximum number of registered users n and the tag-polynomial coefficient-vector length , supporting at most ciphertext tags. It outputs the common reference string crs and an initially empty registration table Tab.
- : This algorithm is run by data user . It takes the common reference string crs and the user index i as input. It outputs a public key , an initial private key , auxiliary registration information , and a public identity . The private key is kept locally by , while is submitted to the KC for registration, where is the attribute set of .
- : This algorithm is run by the KC. It verifies the validity of users’ public registration information. For each valid user, the KC records the corresponding identity and attribute set in Tab. It then aggregates all valid public keys into a master public key mpk and generates an auxiliary token for each registered user.
- : This algorithm is run by a data owner. It takes as input the master public key mpk, an access policy , the data , the attached tag set , a keyword set K, and a user revocation list . It outputs the ciphertext Ciph. For this output, is the index-generation-time snapshot, not a mutable input to subsequent searches.
- : This algorithm is run by data user . It takes as input the master public key mpk, identity key , and a query keyword set Q. It outputs a trapdoor . The trapdoor enables the CS to evaluate aggregate keyword matching against an encrypted index.
- : This algorithm is run by the CS. It takes as input a searchable index Ind and a trapdoor . If the trapdoor matches the index and the user is search-authorized with respect to the components generated using Renc, the algorithm returns the corresponding ciphertext CT. Otherwise, it outputs . It neither takes a current revocation list as input nor updates historical indexes.
- : This algorithm is run by data user . It takes as input the previous private key , the previous punctured-tag set , and a new puncturing tag . It outputs the updated private key and the updated punctured-tag set . The restriction applies to the updated key for ciphertexts whose tag set contains . Protection against a later compromise additionally requires secure erasure of the previous usable secret state.
- : This decryption algorithm takes CT, the attached tag set , the token , the secret key , and the punctured-tag set as input and returns the plaintext data or .
Detailed construction.
: Given the security parameter and the attribute universe , the KC specifies the number of user indexes n and proceeds as follows:
- The KC generates bilinear pairing parameters and selects system exponents . The KC then computes .
- Let be the distinguished tag, and let be the tag-polynomial coefficient-vector length, supporting at most attached tags. The KC randomly selects and computes . The KC defines , where . The KC then computes .
- For each user index and attribute , the KC randomly selects . The KC then calculates , , , , , and for . The KC selects three hash functions: , , and .
- The KC constructs a binary subtree BT to support user exclusion at index generation. For each node in the tree, it randomly selects and computes . The KC maintains an initially empty table Tab and publishes the common reference string:
: The data user takes as input the common reference string and a user index .
- The user chooses two random values and computes the public key and initial secret key as follows: (2)
- The user computes the cross-verification terms for . The user collects these terms as .
- To support keyword search, each user selects a random identity key and computes .
- The user submits a registration request containing to the KC.
: After receiving the registration request and the user information, the KC performs the following steps.
- For , the KC checks whether . If the equality holds, the KC inserts into Tab and computes aggregated components: (3)
- The KC randomly inserts into the leaf nodes of the tree BT to form a new binary tree .
- Finally, the KC publishes the master public key and the auxiliary token .
: Given the master public key mpk, an access policy , the keyword set K, and a revocation list , the data owner encrypts the shared data with the attached tag set as follows.
- Let M be an matrix. The data owner i randomly selects and defines , where s is the secret to be shared. The data owner then computes the LSSS secret share: .
- The data owner calculates the tag polynomial according to the tag set , where . For m = 0, the empty product is . To obtain , set for ; no padding is needed when .
- The data owner randomly selects , samples satisfying , and computes
- The data owner randomly selects . For each non-revoked user , the data owner calculates . For each keyword , the data owner selects . The data owner sets and computes . These components form the keyword index .
- Finally, the data owner uploads the ciphertext and index to the cloud server as .
: User j takes a query keyword set and samples . The user computes for , , and the identity verification term
The output is .
: The CS takes an index Ind and a trapdoor , and computes . For a valid identity component represented in the index generated using Renc, the corresponding index component j satisfies . If no applicable index component is available, the algorithm returns . Otherwise, the CS checks the following equation using the components of that index:
If the equation holds, the CS returns the ciphertext. Otherwise, the CS outputs .
Here the product on the index side ranges over the complete indexed set K, not an arbitrarily selected subset. Consequently, this equation evaluates F(K) = F(Q) when the identity terms match. The reference to Renc describes how Ind was generated; it does not add a new current-list check to .
: Given the secret key , the punctured-tag set , and a tag to be punctured, the user performs the following steps.
- If , the user returns the unchanged key and punctured-tag set. Otherwise, the user parses as and as . The user then sets .
- The user randomly selects and defines for . The user then computes the new secret key as follows:
After a successful update, an honest user commits the new key state and securely erases the superseded secret state and any update randomness that would enable recovery of that state. Secure erasure is an assumption about local state management, not an operation that can invalidate copies outside the user’s control.
: The CS finds in Tab. If does not satisfy the access policy , the CS returns . Otherwise, let and . There exist reconstruction coefficients such that .
- The CS computes as follows and returns to the user. (6)
- The user first returns if . Otherwise, the user calculates as in the algorithm . The user parses as , and parses as . Before evaluating any inverse below, the user also checks that and all are nonzero in ; otherwise, the user returns . The user then computes as follows: (7)
- The user computes . Finally, the user checks . If the equality does not hold, the user returns to the KC.
Results
Correctness and scope of the three mechanisms
Predicate implemented by the search equation.
Proposition (conditional search correctness). Suppose that the index and trapdoor are honestly generated in groups of prime order q, that , and that the selected identity components satisfy . The search equation accepts if and only if F(K) = F(Q).
Proof. Write and . The products evaluated by the search algorithm are
By bilinearity, with L and R denoting the left- and right-hand sides of the search equation,
Non-degeneracy and prime order make injective. Since in , the last expression is exactly when F(K) = F(Q).
Thus Q = K guarantees acceptance regardless of keyword order. A strict subset, partially overlapping set, or disjoint set is rejected when its aggregate differs from F(K) and accepted otherwise. For example, K = {a,b,c} and Q = {a,b} satisfy , but the test accepts only if . These are algebraic consequences, not experimental results. The proposition assumes identity matching and does not establish identity authorization or keyword privacy.
Revocation-list snapshots and historical indexes.
Let Ind0 be generated using R0, and suppose that . If a later list R1 adds user i but neither Ind0 nor changes, the inputs to the deterministic search test remain identical. Consequently,
still holds, including for a newly generated valid trapdoor with unchanged identity credentials. Historical-index revocation therefore needs an additional update protocol or current-state authorization mechanism. Moreover, takes neither a search result nor a current revocation list as input. Denying a later search response cannot prevent decryption with an already held ciphertext, usable key, and required auxiliary information.
Punctured keys and retained secret states.
For a well-formed tag polynomial represented by the coefficient vector used in decryption, the denominator associated with a punctured tag is
If , then , so its inverse does not exist. The explicit rejection check in makes this failure condition well-defined for honest execution. This algebraic observation and the check do not, by themselves, prove that an adversary cannot decrypt using modified computations; that is the separate objective of the key-exposure security model.
The update produces without changing a retained , the ciphertext, or another user’s key. Previously usable decryption inputs therefore remain usable. Protection concerns exposure after honest erasure under the threat model, including its backup and rollback restrictions.
Security analysis
We analyze the security of PR-ABKS in two parts. First, we prove data confidentiality under key updating and chosen-plaintext attacks by reducing the message indistinguishability of PR-ABKS to the DBDH assumption. Second, we prove keyword privacy against chosen keyword attacks by reducing the keyword indistinguishability of PR-ABKS to the IND-CKA security of the registered-based ABKS component. The security of this component is based on the DBDH assumption.
These security statements apply to the challenge-restricted models defined above: confidentiality of an admissible post-puncture state and privacy for the aggregate-matching search interface. These statements do not assert general conjunctive-search correctness, retroactive revocation of historical indexes, or invalidation of retained pre-puncture keys. The algebraic observations in the preceding subsection establish the functional boundaries independently of the indistinguishability reductions.
IND-KU-CPA security.
Theorem 1. If the DBDH assumption holds, then the proposed PR-ABKS scheme satisfies IND-KU-CPA security with respect to message confidentiality.
Proof. Assume that there exists a PPT adversary who can break the IND-KU-CPA security of PR-ABKS with a non-negligible advantage. We construct an algorithm to break the DBDH assumption.
Init: Given the DBDH instance , the goal of is to distinguish whether or whether . The adversary declares the challenge tag set . Meanwhile, selects the target index and maintains the following initially empty lists.
- .
- .
- .
- .
The simulation uses the disclosure rule of Definition 1 for every user. If a user satisfies the challenge policy, a disclosed state must have a punctured tag in . Earlier disclosure records are checked when the challenge is fixed, and later inadmissible disclosures are rejected. Registration outputs, including auxiliary tokens, remain available to the adversary.
: first chooses a distinguished tag and defines in which . The challenger then computes the challenge tag polynomial . Using the same coefficient-vector convention as , let and set for . The degree bound is ; no padding is needed when . Since , we have . The challenger then randomly selects . The challenger implicitly sets , and computes , , , . For each , the challenger computes , . For each user index and each attribute , chooses and computes , , , , . The challenger also generates the hash functions , , . Finally, generates the binary tree BT and the internal tree value honestly and sends crs to .
Query I: can adaptively make the following queries.
: When adversary queries , the challenger executes the following steps.
- For , randomly chooses and executes the algorithm to compute . The challenger stores in and returns to .
- For , randomly chooses . The challenger implicitly sets and computes , , , , , . The challenger returns to and inserts into .
: When issues this query on and , returns if . Otherwise, the challenger computes , , , . The challenger randomly inserts into the leaf nodes of the tree BT to form a new binary tree . The challenger sets and . The challenger inserts into and returns to .
: When issues this query with a tag on , obtains from . The challenger executes the algorithm to compute . inserts into and into .
: Upon a query on , obtains the latest state from . Once the challenge is fixed, the challenger returns if and . Otherwise, the challenger records and returns the state, subject to the same stopping rule as the game. For a pre-challenge disclosure, the challenger preserves the disclosed state for the admissibility check at the challenge. The rule is identical for target and non-target users.
Challenge: A submits two equal-length plaintexts under . Before generating the challenge, checks all prior disclosure records using the same admissibility condition as the game and rejects if any record violates it. C chooses a random bit and samples . The challenger sets and defines . calculates the index honestly and constructs the challenge ciphertext as follows:
returns the challenge ciphertext to .
Query II: Subject to the same post-corruption stopping rule, may issue the queries of Query I. For every user, the simulator rejects a disclosure satisfying and , where is the punctured-tag set of the disclosed state. Earlier records cannot be made admissible by later punctures.
Guess: outputs a bit and wins if . Consequently, the adversary has an overall advantage given by .
IND-CKA security.
Theorem 2. If the DBDH assumption holds, then the proposed PR-ABKS scheme satisfies IND-CKA security with respect to keyword privacy.
Proof. Assume that there exists a PPT adversary who can break the IND-CKA security of PR-ABKS with a non-negligible advantage. We construct an algorithm to break the DBDH assumption.
Init: The adversary declares the number of key generation queries , the registered set , and the attribute set of the registered users. Meanwhile, maintains the following initially empty lists.
: runs the algorithm honestly and sends crs to .
Query I: can adaptively make the following queries.
: When adversary queries , the challenger checks whether the user record already exists in . If so, returns the stored result. Otherwise, runs the real algorithm and returns to . The challenger then stores the record in .
: When adversary issues this query on user i and keyword set Q, first checks . If the query has already appeared, the challenger returns the previously recorded trapdoor . Otherwise, randomly selects and defines , , . The challenger outputs the trapdoor . inserts this record into and returns to .
Challenge: A submits two equal-length keyword sets under . first checks whether the challenge is admissible. If, during Query I, the adversary has already obtained a valid trapdoor for a keyword set with or for a valid identity represented in the challenge index generated using , returns . Otherwise, randomly chooses , . For each keyword , the challenger selects . The challenger sets and uses the keyword set to generate the challenge index as follows:
(8)The challenger calculates the ciphertext honestly and returns the challenge ciphertext to .
Query II: can further issue queries as in Query I, except that a trapdoor query satisfying or for a valid identity represented in the challenge index is rejected with .
Guess: outputs a bit and wins if . Consequently, the adversary has an overall advantage given by .
Performance evaluation
Table 2 broadens the comparison beyond the two component baselines to include related searchable and puncturable schemes. PR-ABKS combines all five evaluated functionalities within one registered framework, offering a more comprehensive functional combination than the individual schemes compared here. This combination makes PR-ABKS a competitive option for applications requiring encrypted retrieval together with local key restriction and user exclusion.
For cost evaluation, we select PR-ABE [29] and RRABKS [30] as the closest baselines: the former provides registered key management and puncturable key update, whereas the latter provides registered keyword search. Comparing their implementations under the same experimental settings helps isolate the additional cost of combining these mechanisms. The functional comparison establishes the breadth of the combination, while the cost evaluation quantifies its trade-offs. Theoretical computation costs are summarized in Table 3, where “–” denotes an unavailable algorithm, and experimental results appear in Figs 4–11.
Table 3 compares the theoretical computation costs of our scheme with those of PR-ABE [29] and RRABKS [30]. For consistency, represents the total cost of generating keys for all N users in the three schemes.
Theoretical analysis.
The dominant setup and registration terms in Table 3 scale with N2U, reflecting public parameters and aggregation over users and attributes. Relative to PR-ABE [29], PR-ABKS adds search-related parameters; relative to RRABKS [30], it adds tag-related parameters. PR-ABE and PR-ABKS have identical registration costs, whereas RRABKS has a different pairing term.
Key generation in the puncturable schemes includes tag-related secret components governed by . Encryption combines access-policy components, tag-related components, and a searchable index. Decryption combines policy reconstruction with punctured-key processing, so its cost depends on the reconstruction rows and, for puncturable schemes, on and the accumulated puncture count p.
PR-ABKS inherits the mechanism from PR-ABE and the and mechanisms from RRABKS. These inherited operations retain their respective theoretical costs. The main trade-off is additional ciphertext/index generation and decryption work to support both functionalities. Object sizes and the identity-based index count are specified below.
Communication and storage analysis.
Table 4 reports analytical object lengths under a common encoding convention. Components are counted from the constructions of PR-ABE [29] and RRABKS [30], including row-dependent ciphertext elements and the index in Fig 2 of RRABKS. The table note specifies included objects and exclusions; the lengths are not network measurements.
The ciphertext body of PR-ABE and ours contains I components C3,w, components C5,k, and four fixed elements in G, together with C1. RRABKS contains two row-dependent elements per access-matrix row, two fixed elements in G, and one element in . A searchable index adds three fixed elements and elements for each represented user identity. A trapdoor contains keyword components and two additional group elements. Thus, the index size grows with the number of represented identities as well as the keyword count.
To relate object sizes to communication, let be the encoded metadata sent with a ciphertext in scheme s, including its policy, applicable tags, and required labels. The owner-to-cloud upload lengths are
For RRABKS and ours, a query transmits bits of trapdoor material, plus any request metadata. The persistent cloud storage for each uploaded package has the same object size as its upload, excluding transport framing and implementation-specific storage overhead. Response traffic depends on the number and form of returned objects. Sending complete ciphertexts incurs the sum of their encoded sizes and accompanying metadata. If our specified partial-decryption interface is used, the returned tuple contains . Since , its length per returned object is
before result identifiers and transport framing. For multiple results, these lengths are summed over the returned objects.
Puncturing adds three group elements and one tag record locally, with no protocol-required message to the cloud or other users. Optional backup or synchronization traffic is excluded. The table distinguishes this local operation from unsupported functionality. Actual serialization, registration traffic, and deployed network performance remain to be measured.
Experimental evaluation.
All schemes were implemented under the same software and hardware environment to ensure a fair comparison. The experiments were conducted on a computer equipped with an AMD Ryzen 7 7745HX processor with Radeon Graphics, running at 3.60 GHz, and 16 GB of RAM, under 64-bit Windows 11. The experiments were conducted using Type-A pairing and the PBC library. The pairing is determined over the 512-bit finite field , using the equation . Each experimental result represents the total execution time of 10 independent runs. Unless otherwise specified, the default parameter settings are N = 10, U = 10, Q = 10, and I = 4. The numerical execution-time values underlying Figs 4–11 are provided in S1 Dataset.
Fig 4 shows increasing setup time with the attribute count (a) and user count (b), consistent with the dominant N2U term in Table 3. PR-ABKS incurs additional tag-related work relative to RRABKS [30] and search-related work relative to PR-ABE [29].
In Fig 5, key-generation time increases with the user count. The key-generation times of PR-ABE [29] and PR-ABKS are similar because both generate puncturable secret-key components, while RRABKS [30] omits that tag-related work.
Fig 6 shows increasing registration time as more user information is validated and aggregated. The registration times of PR-ABE [29] and PR-ABKS are similar, consistent with their identical theoretical registration costs. RRABKS [30] follows a comparable trend with a different pairing term.
In Fig 7(a), encryption time increases with the access-matrix row count I because larger policies require more ciphertext components. PR-ABKS adds searchable-index work to PR-ABE [29]. In Fig 7(b), encryption time increases with the keyword count for RRABKS [30] and PR-ABKS; the latter also generates tag-related components. PR-ABE is omitted from this keyword comparison because it has no search function.
Fig 8 compares puncturable key update in PR-ABE [29] and PR-ABKS as the tag count varies. Their similar timings agree with the shared theoretical cost . RRABKS [30] does not provide this operation.
Figs 9 and 10 show increasing trapdoor-generation and search time with the query keyword count. RRABKS [30] and PR-ABKS remain close because they share these mechanisms. PR-ABE [29] is omitted because it does not support keyword search.
Fig 11 shows increasing decryption time with the access-matrix row count. RRABKS [30] performs policy reconstruction, while PR-ABE [29] and PR-ABKS also process puncturable-key components. The observed differences describe the tested configuration.
The observed trends are consistent with the theoretical comparison in Table 3. PR-ABKS retains the baseline behavior of inherited operations while adding work to support searchable and puncturable components together. These measurements characterize relative computational costs under the reported implementation settings.
Discussion
Principal findings and design trade-offs
PR-ABKS brings tag-level key puncturing into registered encrypted search. PR-ABE [29] supplies the local update mechanism, and RRABKS [30] supplies the searchable component. The combination retains their respective update and search costs but adds work to encryption and decryption. Table 4 also shows the resulting index-storage and key-growth costs. These comparisons describe a trade-off between combined functionality and resource use, rather than uniform performance gains.
The correctness analysis establishes the scope of each mechanism: aggregate keyword matching, exclusion when an index is generated, and restriction of an updated key. Their deployment implications are distinct. Repositories must choose compatible query metadata, while devices must preserve the latest puncture state and prevent recovery of earlier usable secrets. Key storage and decryption work grow as punctures accumulate.
Application scenarios, deployment considerations, and limitations
The construction is relevant to repositories that combine encrypted metadata retrieval with local key restriction before possible compromise. Deployment requires authenticated registration, protected identity credentials, consistent keyword and tag encodings, and secure erasure as specified in the threat model. Applications requiring arbitrary keyword-subset queries or retroactive withdrawal of access need additional mechanisms.
Secure multimedia sharing involves both protection of media content and management of access to stored objects. Liu et al. [31] improve selective image encryption through semantic region detection and parallel processing, while Yu et al. [32] develop a memristive-chaos-based encryption method for medical images. These studies address protection of image content; PR-ABKS examines registered key management, encrypted metadata matching, and tag-based restriction of updated decryption keys. A possible deployment would protect large media objects with authenticated symmetric encryption and control recovery of their content keys through an attribute-based mechanism, with keywords and tags assigned at the object or collection level. Such an extension would require a precise specification and separate composition analysis, including the treatment of cached content keys. Lin et al. [33] demonstrate structural attacks against a video cryptosystem, illustrating why visual or statistical assessments alone cannot establish cryptographic security. Evaluation of a multimedia extension should therefore distinguish payload protection, retrieval leakage, and key-exposure assumptions. The present experiments evaluate the proposed algorithms rather than a complete multimedia deployment.
Federated learning could support collaborative analysis in cloud-assisted data-sharing applications where participants retain their training data locally. The reviewed approaches address personalization, communication efficiency, and robustness in such training [25–28]. A complementary role for PR-ABKS would be to manage encrypted model files or other resources that participants choose to share through the cloud. Participants could train models locally and publish selected artifacts with keywords, access policies, and tags; authorized users could then retrieve matching encrypted objects and decrypt them when the policy and current key state permit. Tag-based puncturing could restrict an updated key’s access to selected artifacts under the stated secure-erasure assumption. This combination would address collaborative training and controlled access to stored outputs at different stages of the application. It is a possible extension rather than an evaluated component of the present scheme; protection of training updates would require mechanisms appropriate to the federated-learning setting.
Several limitations remain. The confidentiality and keyword-privacy models do not hide access patterns, search patterns, repeated queries, or result sizes. The key curator remains a coordination point despite not holding user secrets. The experiments use one workstation and a 512-bit Type-A pairing setting, which supports a relative implementation comparison rather than a production security recommendation. The analytical storage and communication comparison excludes registration traffic and actual serialization overhead; concurrent workloads, network delay, and failure behavior have not been evaluated.
Future work
Future work should evaluate modern pairing-friendly curves at standardized security levels and measure costs in a deployed cloud environment. Algorithmic priorities include historical-index updates, general conjunctive search, aggregate-collision analysis, and lower key-growth and decryption costs. Distributed registration and mitigation of access- and search-pattern leakage are further directions.
Conclusions
PR-ABKS combines registered encrypted keyword search with tag-based restriction of an updated decryption key. Users retain control of their secrets, and the construction supports aggregate keyword matching and index-generation-time exclusion. The analysis identifies the costs of combining these functions: inherited update and search operations remain close to their baselines, while encryption, decryption, and storage incur additional work. Its use requires the query semantics and secure-erasure conditions defined in the model; historical-index revocation requires a separate mechanism. The reported evaluation characterizes this combined construction under the tested configuration.
Supporting information
S1 Dataset. Numerical data underlying Figs 4–11.
The workbook contains the execution-time values (in milliseconds) used to generate the performance figures for Setup, KeyGen, Reg, Enc, KeyUpt, TrapGen, Search, and Dec.
https://doi.org/10.1371/journal.pone.0363164.s001
(XLSX)
References
- 1. Ahmad S, Mehfuz S. Efficient time-oriented latency-based secure data encryption for cloud storage. Cyber Security and Applications. 2024;2:100027.
- 2.
Bethencourt J, Sahai A, Waters B. Ciphertext-Policy Attribute-Based Encryption. In: 2007 IEEE Symposium on Security and Privacy (SP ’07), 2007. 321–34. https://doi.org/10.1109/sp.2007.11
- 3. Ge C, Liu Z, Susilo W, Fang L, Wang H. Attribute-Based Encryption With Reliable Outsourced Decryption in Cloud Computing Using Smart Contract. IEEE Trans Dependable and Secure Comput. 2024;21(2):937–48.
- 4.
Li J, Ma M, Zhang J, Fan S, Li S. Attribute-based keyword search from lattices. In: International Conference on Information Security and Cryptology, 2019. 66–85.
- 6. Miao Y, Li F, Li X, Liu Z, Ning J, Li H, et al. Time-Controllable Keyword Search Scheme With Efficient Revocation in Mobile E-Health Cloud. IEEE Trans on Mobile Comput. 2024;23(5):3650–65.
- 7.
Hohenberger S, Lu G, Waters B, Wu DJ. Registered attribute-based encryption. In: Annual international conference on the theory and applications of cryptographic techniques, 2023. 511–42.
- 8.
Garg R, Lu G, Waters B, Wu DJ. Reducing the CRS size in registered ABE systems. In: Annual international cryptology conference. Springer; 2024. p. 143–77.
- 9. Weng W, Li J, Zhang Y, Lu Y, Shen J, Han J. Efficient Registered Attribute Based Access Control With Same Sub-Policies in Mobile Cloud Computing. IEEE Trans on Mobile Comput. 2025;24(9):8441–53.
- 10.
Sun S-F, Sakzad A, Steinfeld R, Liu JK, Gu D. Public-Key Puncturable Encryption: Modular and Compact Constructions. Lecture Notes in Computer Science. Springer International Publishing. 2020. p. 309–38. https://doi.org/10.1007/978-3-030-45374-9_11
- 11. Chen S, Li J, Zhang Y, Han J. Efficient Revocable Attribute-Based Encryption With Verifiable Data Integrity. IEEE Internet Things J. 2024;11(6):10441–51.
- 12.
Hoang V-H, Lehtihet E, Ghamri-Doudane Y. Forward-Secure Data Outsourcing Based on Revocable Attribute-Based Encryption. In: 2019 15th International Wireless Communications & Mobile Computing Conference (IWCMC), 2019. 1839–46. https://doi.org/10.1109/iwcmc.2019.8766674
- 13. Rasori M, Perazzo P, Dini G, Yu S. Indirect Revocable KP-ABE With Revocation Undoing Resistance. IEEE Trans Serv Comput. 2022;15(5):2854–68.
- 14. Zhang Y, Li D, Zhang X, Lv W. An Efficient Cross-Domain Fine Grain Proxy Re-encryption Scheme for Secure Transmission in IIOT. ACM Trans Sen Netw. 2025;21(3):1–21.
- 15. Zhang Y, Zhu T, Guo R, Xu S, Cui H, Cao J. Multi-Keyword Searchable and Verifiable Attribute-Based Encryption Over Cloud Data. IEEE Trans Cloud Comput. 2023;11(1):971–83.
- 16. Zhang D, Wang S, Zhang Q, Zhang Y. Attribute Based Conjunctive Keywords Search With Verifiability and Fair Payment Using Blockchain. IEEE Trans Serv Comput. 2023;16(6):4168–82.
- 17. Meng F, Cheng L. STR-ABKS: Server-Aided Traceable and Revocable Attribute-Based Encryption With Keyword Search. IEEE Internet Things J. 2024;11(7):12649–59.
- 18. Li J, Li C, Zhang K, He Y. Traceable and Revocable Attribute-Based Conjunctive Keyword Search. IEEE Trans Emerg Topics Comput. 2026;14(1):240–53.
- 19.
Garg S, Hajiabadi M, Mahmoody M, Rahimi A. Registration-Based Encryption: Removing Private-Key Generator from IBE. Lecture Notes in Computer Science. Springer International Publishing. 2018. p. 689–718. https://doi.org/10.1007/978-3-030-03807-6_25
- 20. Li J, Chen S, Lu Y, Ning J, Shen J, Zhang Y. Revocable Registered Attribute-Based Encryption With User Deregistration. IEEE Internet Things J. 2025;12(15):31526–35.
- 21.
Green MD, Miers I. Forward Secure Asynchronous Messaging from Puncturable Encryption. In: 2015 IEEE Symposium on Security and Privacy, 2015. 305–20. https://doi.org/10.1109/sp.2015.26
- 22. Cui H, Yi X. Secure Internet of Things in Cloud Computing via Puncturable Attribute-Based Encryption With User Revocation. IEEE Internet Things J. 2024;11(2):3662–70.
- 23. Ghopur D, Ma J, Ma X, Hao J, Jiang T, Wang X. Puncturable Key-Policy Attribute-Based Encryption Scheme for Efficient User Revocation. IEEE Trans Serv Comput. 2023;16(6):3999–4011.
- 24. Li B, Zhong H, Cui J, Gu C, He D. Cloud Data Sharing System With Enhanced Effectiveness for Flexible User Revocation. IEEE Trans Dependable and Secure Comput. 2026;23(1):670–84.
- 25. Liu C, Zhou N, Yu W. Personalized federated learning algorithm based on composite feature extractor. IEEE Internet Things J. 2026;13(11):22947–58.
- 26. Hu X-B, Wang Y-P, Zhou N-R. AISS-VFL: Efficient adaptive importance-aware sample selection for vertical federated learning over distributed labels. Expert Systems with Applications. 2026;318:132011.
- 27. Bi W-Z, Yu W-J, Gong L-H. Personalized federated learning based on self-excluding aggregation with knowledge distillation. Cluster Comput. 2026;29(9).
- 28. Bi W-Z, Li D-M, Chen S-H, Gong L-H. Dual-recognition federated learning with negative learning. Neurocomputing. 2026;704:134827.
- 29. Wang C, Ming Y, Liu H, Deng Y, Yang M, Feng J. Puncturable Registered ABE for Vehicular Social Networks: Enhancing Security and Practicality. IEEE Trans Dependable and Secure Comput. 2025;22(6):5998–6011.
- 30. Li C, Qiao Y, Bo J, Yang F. Registered-Based Revocable Attribute-Based Encryption With Keyword Search for Secure Cloud Data Sharing. IEEE Internet Things J. 2025;12(23):50082–95.
- 31. Liu B, Song W, Zheng M, Fu C, Chen J, Wang X. Semantically enhanced selective image encryption scheme with parallel computing. Expert Systems with Applications. 2025;279:127404.
- 32. Yu Z, Zhu K, Song X, Yang F. An image encryption algorithm based on memristive chaotic neuron in medical internet of things environments. Engineering Applications of Artificial Intelligence. 2026;173:114371.
- 33. Lin Y, Wei Y, Chen D, Li Y, Erkan U, Toktas A, et al. Cryptanalysis and Improvement of a Video Cryptosystem via Chaos and S-Box. ACM Trans Multimedia Comput Commun Appl. 2026;22(6):1–28.