Dynamic Anonymous Blocklisting Scheme

Updated 29 December 2025

Dynamic anonymous blocklisting schemes are protocols that enable service providers to ban or unban users in real time while preserving anonymity through non-membership proofs.
They employ advanced cryptographic primitives such as pseudorandom functions, dynamic accumulators, and zero-knowledge proofs to ensure scalability and privacy.
Applications include cross-chain moderation, privacy-preserving rate limiting, and decentralized access control, addressing challenges like quantum security and key management.

A dynamic anonymous blocklisting scheme is a cryptographic protocol enabling service providers to efficiently, flexibly, and privately ban users or objects, such that honest users can prove non-membership (i.e., “I am not currently blocked”) without revealing their identity or linkable information. These schemes achieve dynamicity (support for real-time insertions and deletions from the blocklist), anonymous proofs of non-membership (unlinkable and privacy-preserving), and often scalable verification and update costs even as the blocklist grows. Applications include anonymous group messaging moderation, privacy-preserving rate-limiting, cross-chain blocklisting, and zero-knowledge access control in blockchains and distributed systems.

1. Core Cryptographic Foundations

Dynamic anonymous blocklisting schemes rely on several advanced cryptographic primitives, parameterized for security, scalability, and privacy:

Pseudorandom Function (PRF)–based pseudonyms: User identities are mapped to unlinkable group- or service-specific pseudonyms via secure PRFs. This unlinkability is foundational for privacy, as in FAB’s $ps^R_U = \mathrm{PRF}_x(s_R)$ or ShadowBlock’s $tag = \mathrm{PRF}_k(n)$ (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025).
Negative/dynamic accumulators: These allow succinct proofs that a value (e.g., a pseudonym or tag) is not present in the current blocklist, with constant- or logarithmic-time updates and compact proofs. Complementary Merkle trees (FAB), RSA accumulators (ShadowBlock), or lattice-based accumulators (post-quantum) are typical realizations (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025, Song et al., 26 Sep 2025).
Zero-knowledge non-membership proofs: SNARKs (e.g., Groth16), aggregated SNARKs, or post-quantum NIZKs allow users to prove to the verifier that their pseudonym is not in the blocklist without revealing their secret (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025, Song et al., 26 Sep 2025).
Flexible trust models: Real-world deployments often combine decentralized or federated authorities, credential issuers trusted only for Sybil-resistance and not for pseudonym linkage, and high-availability relays or blockchains to publish current blocklist state (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025, Sato et al., 2020).

2. Dynamic Blocklist Update and Proof Mechanisms

A defining feature is the scheme’s ability to process blocklist insertions (“ban”) and deletions (“unban”) with negligible overhead, and to allow legitimate users to prove their unbanned status efficiently.

Blocklist updates with minimal state churn: In FAB, the negative accumulator (complementary Merkle tree) supports O(1) updates to the root, and updates are published immediately. There is no need for clients to reprocess the event log or synchronize prior additions (Soler et al., 5 Nov 2025).
Proof reuse and aggregation: ShadowBlock’s RSA accumulator admits O(1) update for both add/del, and further allows client-side proofs to be patched incrementally in constant time, avoiding full regeneration (Deng et al., 22 Dec 2025). Its aggregation mechanism enables multiple logical queries to be bundled into a single SNARK of constant size, yielding O(1) proof and verification even over many tags.
Post-quantum support: Lattice-based schemes utilize trapdoorless dynamic accumulators and modern NIZK compilers to provide forward secrecy and quantum resistance, with dynamic revocation and short proofs (Song et al., 26 Sep 2025).
On-chain and cross-chain compatibility: Several protocols (ShadowBlock, anonymous ring signature blocklisting) encode accumulator updates and proofs into blockchain events, allowing multi-domain synchronization of the global blocklist state (Deng et al., 22 Dec 2025, Sato et al., 2020).

3. Authentication, Non-membership Proofs, and Security Properties

Most schemes operationalize authentication through a combination of credential validation, non-membership proofs, and SNARK/NIZK verifiability:

Authentication workflow: Users obtain credentials from an identity provider, derive a fresh pseudonym for each group/service, and generate a zero-knowledge proof showing that this pseudonym is not present in any relevant blocklist(s). For federated/multi-field settings, users efficiently compose non-membership proofs across all “trusted” blocklists using one SNARK per field (Soler et al., 5 Nov 2025).
Security properties:
- Blocklistability (soundness): Only users whose derived pseudonym is unbanned can produce an accepting proof. This is ensured by PRF collision-resistance, accumulator soundness, and SNARK knowledge-extractability (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025).
- Unlinkability/anonymity: Proofs are statistically or computationally indistinguishable even for adversaries observing multiple authentications by the same user. This is formalized by reduction to PRF indistinguishability and ZK proof zero-knowledge (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025, Song et al., 26 Sep 2025).
- Non-frameability: Honest, unbanned users can always produce a valid proof. Proof failure implies compromise or revocation.
- Traceability or accountability (where required): In some blockchain protocols, admitted auditors can open signatures to trace which authority imposed a block, while the public remains unable to link blocklist events to blocklist imposees (Sato et al., 2020).

4. System Architectures: Federation, Cross-Domain, and Blockchain

Dynamic anonymous blocklisting is realized under diverse collaboration and threat models:

Federated multi-field blocklisting: FAB instantiates a directed graph where each “field” manages an independent blocklist and forms trust links with other realms; a user must prove non-membership across all realms trusted by their target community. This design supports scalable, decentralized moderation and robust partitioning (Soler et al., 5 Nov 2025).
Cross-chain and interoperable blocklisting: ShadowBlock generalizes accumulator management and ZK proof validation across multiple blockchains (relay chain model), enabling a global blocklist state consumed by independent services (e.g., decentralized identity, DeFi, cross-chain messaging). Blockchain integration details address smart-contract interfaces, on-chain accumulator updates, and techniques for on-chain hiding of sensitive witness material (Deng et al., 22 Dec 2025).
Blockchain-native accountability: Anonymous ring signature–based blocklisting on blockchain allows dynamic (token-based) block or trust marks, where only designated auditors can deanonymize blocklist imposers. The system supports ring membership updates and explicit token revocation, with applications in censorship-resistant accountability and exchange operations (Sato et al., 2020).

5. Formal Efficiency, Scalability, and Benchmarking

Scalability and low per-operation overhead are achieved through the combination of cryptographic design choices:

Scheme	Block/Unblock Cost	Proof Generation	Proof Verification	Proof Size	Post-quantum
FAB (Soler et al., 5 Nov 2025)	O(1)	$O(R \cdot \log(\mathrm{BL}_{\max}))$	O(R)	$\Theta(R)$	No
ShadowBlock (Deng et al., 22 Dec 2025)	O(1)	O(1) (aggregated)	O(1)	O(1)	No
Lattice-based (Song et al., 26 Sep 2025)	O(1)	~25 ms	~10 ms	0.5 MB	Yes

Empirical results (e.g., ShadowBlock with $2^{10}$ blocklist size: 14 ms proof-gen and 15 ms verification per session, O(1) update and proof-patching cost, constant-size proof) demonstrate dramatic performance and scalability improvements compared to predecessors such as SNARKBlock or ALPACA, which require proof/verification time linear in the blocklist or per-event client resynchronization (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025).

6. Comparison to Prior Art and Applications

Dynamic anonymous blocklisting contrasts with traditional blacklist and anonymous authentication in both adversary model and efficiency:

Versus SNARKBlock and ALPACA: FAB and ShadowBlock eliminate the per-blocklist-size scaling of SNARKBlock (linear in $BL$ ), and the user-side update overhead of ALPACA, making dynamic blocklists with millions of entries practically supportable for high-velocity environments such as group messaging and cross-chain applications (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025).
Applications:
- Moderation of group messaging and federated chat: FAB integrates with the Messaging Layer Security (MLS) protocol, inserting authentication and blocklist proofs directly in the handshake. This enables robust, federated abuse prevention without centralization or loss of user anonymity (Soler et al., 5 Nov 2025).
- Cross-chain identity management and multi-chain anti-abuse: ShadowBlock’s RSA-based accumulator is deployed as a smart contract on a relay chain, synchronizing bans or unbans across diverse blockchain ecosystems, enabling truly decentralized enforcement (Deng et al., 22 Dec 2025).
- Anonymous trust marks and accountability: Accountable ring signature–based protocols enable dynamic, anonymous “block trust” overlays for public ledgers, with provisions for secure uncovering in cases of dispute or abuse (Sato et al., 2020).

7. Limitations, Open Challenges, and Future Directions

Despite substantial advancements, several problems remain open in dynamic anonymous blocklisting:

Key rotation and curator synchronization: For some Merkle or signature-based blocklists, coordinating auditor or curator key rotations while retaining consensus over blocklist history can introduce complexity (Thomas et al., 2023).
False positive/negative robustness and embedding accuracy: In approximate blocklist mechanisms (e.g., B-OPRF (Zhang et al., 21 Jul 2025)), performance and privacy can be impacted by the precision of embeddings and the underlying clustering algorithms.
Quantum security: Lattice-based dynamic accumulators and NIZK argument compilers offer strong post-quantum security, but incur larger communication and proof size compared to pairing- or SNARK-based constructions; further optimization is an active area (Song et al., 26 Sep 2025).
Integration with device-side and privacy-preserving search: Protocols utilizing PSI, homomorphic encryption, or client-blinded blocklist lookups can address privacy/censorship tradeoffs, but introduce new attack surfaces and engineering challenges (Thomas et al., 2023).
Scalability under high update rates: While constant-time updates and proof reuse are supported by leading designs, adversarial update flooding and synchronization in multi-domain deployments remain unaddressed in full generality.

Dynamic anonymous blocklisting schemes constitute a critical enabling primitive for privacy-preserving, accountable, and efficient access and abuse prevention in modern decentralized systems. Continued research is focused on minimizing latency, maximizing security against advanced adversaries, and supporting broader federated and post-quantum applications (Soler et al., 5 Nov 2025, Deng et al., 22 Dec 2025, Song et al., 26 Sep 2025, Sato et al., 2020, Thomas et al., 2023, Zhang et al., 21 Jul 2025).