Fully Dynamic Membership for Cryptographic Group Protocols

15 concepts16 papers1 proposal

In multi-user cryptographic systems—such as group signatures, multi-recipient encryption, threshold protocols, and consortium blockchains—security parameters have historically been tightly coupled to the identities or number of participants. This coupling introduces a fundamental bottleneck known as the static group membership constraint.

Under a static paradigm, the set of authorized participants or attributes must be permanently fixed during an initial, trusted setup phase. If a user joins, leaves, or has their credentials revoked, the entire system's verification state becomes obsolete. Remediating this requires a full system re-initialization or a complete re-generation of cryptographic keys, introducing prohibitive computational and administrative overhead.

To make these protocols viable for real-world applications like fluid federated learning pools or enterprise access control, researchers have shifted toward fully dynamic membership. This paradigm decouples the system's master parameters from the underlying participant pool, allowing seamless enrollment and revocation without resetting the system.


The Root of the Static Constraint

To understand why traditional group protocols are rigid, consider how group identity is mathematically constructed. In early multi-recipient public key encryption (MRPKE) or group signature schemes, the group’s public verification key is often an algebraic aggregate of its members' individual keys.

As noted by Pang et al., this creates an immediate dependency: any modification to the user pool alters the underlying mathematical structure. If a broadcasting network or a secure group communication channel needs to evict a user, the system must be re-initialized from scratch. Similarly, Yang et al. highlight that in group authentication frameworks, dynamic membership changes force the entire verification state to be re-generated, creating massive scalability bottlenecks.

This rigidity manifests across several distinct cryptographic domains:

  • Authentication and Consensus: In deniable group authentication protocols, a lack of threshold flexibility means that if a single member becomes unavailable or if the group composition evolves, the protocol fails entirely (Lu). In consortium blockchains, protocols often assume a fixed, pre-authenticated set of nodes, making the network incapable of adapting to node joins or exits without manual restarts (Li et al.).
  • Secret Sharing and Key Distribution: Traditional leakage-resilient secret sharing schemes fix the participant pool and threshold at initialization (Xiong et al.). In decentralized threshold signatures, changing the participant pool requires re-running the entire initialization unless proactive secret sharing mechanisms are introduced (Li et al.). Even in commercial group key distribution models, protocols often break down if the group leader or host leaves mid-session (Cremers et al.).
  • Key Hierarchies: Static key configurations manage permissions structurally but fail when key roles or attributes must change dynamically over time (Dax et al.).
  • Secure Aggregation: In multi-round privacy-preserving systems like federated learning, assuming a fixed client pool prevents new devices from participating in ongoing, long-running training sessions (Ma et al.).

Breaking the Constraint via Cryptographic Accumulators

The core insight behind achieving full dynamicity is to decouple member identities from the master public key. Instead of embedding user keys directly into the verification equations, the system embeds a cryptographic accumulator—a succinct mathematical representation of a set that supports dynamic updates and membership proofs.

The most intuitive way to visualize this is through an updatable Merkle tree accumulator.

       [ Root (Master Group State) ]
                /        \
            [Node A]    [Node B]
             /   \        /   \
          [U1]   [U2]  [U3]   [U4]  <-- Active User Leaves

In this architecture, the master public key of the group contains the root of the Merkle tree, rather than a hardcoded list of users.

  1. Enrollment: When a new user joins, they are assigned an empty leaf in the tree. The path from their leaf to the root is updated, generating a new root.
  2. Signing/Verification: To prove they belong to the group without revealing their identity, a user generates a zero-knowledge proof (ZKP). This ZKP demonstrates two things simultaneously:
  3. The user possesses a valid secret key corresponding to some leaf in the tree.
  4. There exists a valid cryptographic path connecting that leaf to the current root.

Because the verification equation only checks the validity of the ZKP against the root, the master parameters never have to change.

The "Zero-Leaf" Update Rule for Revocation

While adding users is straightforward, revoking them securely without rewriting the entire system is historically difficult. Early attempts at dynamic lattice-based signatures were only partially dynamic, meaning they could handle enrollment or revocation, but not both simultaneously.

To achieve full dynamicity, Ling et al. introduced a "zero-leaf" update rule for Merkle tree accumulators. When a user is revoked, their corresponding leaf in the tree is not deleted; instead, it is overwritten with a neutral "zero" state or a specific revocation token. The tree is then re-balanced, and a new root is computed.

When an active user wants to sign a message, their zero-knowledge inequality proof demonstrates that their leaf index does not contain a zero value and matches a valid path to the updated root. This elegant mechanism allows simultaneous enrollment and revocation while maintaining short, constant-size signatures.


Extending Dynamicity to Quantum-Resistant and Attribute-Based Systems

The transition from static to fully dynamic frameworks has been particularly impactful in post-quantum cryptography (such as lattice-based and code-based systems), where traditional algebraic tricks like bilinear pairings cannot be used.

Lattice-Based Group Signatures

Early post-quantum group signatures were strictly static due to the complexity of managing lattice trapdoors (Ling et al.; Ling et al.). By pairing the updatable Merkle tree accumulator with Stern-like zero-knowledge proofs, Ling et al. designed the first fully dynamic lattice-based group signature scheme. This approach was later extended to support advanced privacy features like deniability—allowing a tracing authority to legally prove a suspect did not author a signature without compromising the anonymity of innocent users (Ling et al.)—and forward security, ensuring past signatures remain secure even if a current key is compromised (Ling et al.). However, implementing these dynamic features in complex settings like accountable tracing signatures remains an active area of refinement (Ling et al.).

Code-Based Attribute Signatures

The accumulator-plus-commitment paradigm is not restricted to lattices. In Attribute-Based Signatures (ABS), users sign messages using a set of descriptive attributes rather than a single identity. Historically, these systems suffered from the same static limitations, making real-time credential revocation impossible.

Recently, Ling et al. bypassed this constraint by constructing a fully dynamic code-based ABS scheme for arbitrary Boolean circuits. By combining an updatable accumulator with a commitment scheme, the authors enabled the simultaneous enrollment and revocation of user attributes, allowing privacy-preserving systems to remain secure even as user permissions change continuously.


Summary

The shift from static to fully dynamic membership represents a fundamental re-engineering of how group identity is managed in cryptography. By replacing rigid, aggregated public keys with updatable accumulators and zero-knowledge proofs, modern protocols allow users to enter and exit systems seamlessly. This architectural decoupling eliminates the need for system re-initialization, providing the mathematical flexibility required for scalable, real-world deployment.

Key Foundational Work

Group Oriented Identity-based Deniable Authentication Protocol from the Bilinear Pairings (2007) — contributed 2 concept elements to this direction.
Design and Analysis of a Provable Secure Multi-Recipient Public Key Encryption Scheme (2009) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_static_group_membership_constraint_075b2229,
  title = {static group membership constraint},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/static-group-membership-constraint/rdr_075b2229f077462da95689a979006a6d},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-21},
}

This exact version (version 1, frozen text):

@misc{lacuna_static_group_membership_constraint_075b2229_v1,
  title = {static group membership constraint},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/static-group-membership-constraint/rdr_075b2229f077462da95689a979006a6d/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-21},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake