The most urgent part of the post-quantum migration is the core of authenticated key agreement, TLS above all: without it, secure communication stops working once a cryptographically relevant quantum computer exists. But TLS is far from the only place where quantum-vulnerable cryptography is in use.
Privacy Pass, the protocol site operators such as Cloudflare use to defend applications against abuse, is one example. Rate-limiting individual clients normally forces a choice between friction and privacy: CAPTCHAs and other challenges, or accounts and fingerprinting. Privacy Pass avoids that tradeoff by issuing a client a set of tokens that can be redeemed for access to the site, with each token unlinkable to the client it was issued to. Site operators have a decade of deployment experience with it in privacy proxies (iCloud Private Relay) and relays (Privacy Gateway), and are now working with others to bring the next generation of the technology to the web.
Two goals drive that work: better handling of agentic traffic that would otherwise exhaust resources and degrade performance for human visitors, and a more open ecosystem in which more kinds of clients can take part. Both require capabilities beyond what Privacy Pass offers today.
Where Privacy Pass stands against a quantum attacker
Privacy Pass currently depends on classical cryptography, RSA and elliptic curves among them, so a quantum attacker could forge tokens at will and bypass whatever control the site operator is enforcing, rate limiting included. Privacy itself is a different matter: the protocol is unconditionally private, so no attacker, quantum or otherwise, can link a token's redemption to its issuance. The new capabilities under development for this next generation can be instantiated so that the same guarantee holds — a user's interaction stays private even after Q-day.
That buys some time, but a replacement is needed soon, and the research area has advanced considerably in recent years. As elsewhere in the transition, the central obstacle is size: ML-DSA-44 signatures run 2,420 bytes against 64 bytes for ECDSA-P256. Drop-in replacements are not expected any time soon, so, as with TLS, the practical path is to accept primitives with higher cost and re-engineer systems to bear it.
Which primitives those will be remains open. One possible future for post-quantum privacy on the web rests on a recent breakthrough in the design of blind signatures.
Blind signatures and the MOLE design
The new technology is currently called MOLE ("Moderation Of unLinkable Endorsements"). A central building block of Privacy Pass is a blind signature scheme: a client obtains a signature under an issuer's secret key without revealing the signed message to the issuer, and can later reveal message and signature without linking the signature to its issuance.

A Privacy Pass token of this type consists of the message and the blindly issued signature. Verifying it requires the issuer's public key, so the verifier necessarily learns who the issuer is: these tokens hide the client's identity but not the issuer's.
For some use cases that is exactly the point. The issuer's identity says something about the type of client connecting to the edge, a signal used in some products and for some customers — a client might present a token from one of those customers to prove it is authorized to use that customer's VPN, for instance. For many use cases, though, granting access requires far less: normally it only matters that the token came from some trusted entity. MOLE goes further and requires that the token hide the issuer's identity entirely, so that tokens cannot be treated differently according to who issued them. Equal treatment regardless of client type follows, which makes it easier for more clients to participate.

The issuer-hiding property comes from a new object called an endorsement, issued by an anchor and redeemed by a moderator. Before redemption, client and moderator agree on an anchor set — the public keys of the anchors the moderator trusts. During redemption the client proves that it holds an endorsement from one of the anchors in that set without revealing which one. Once it accepts the proof, the moderator issues the MOLE credential that will govern the client's interaction with the site.
Endorsements can take many forms; what matters is that they can be redeemed while the issuing anchor stays hidden. Credentials will also come in many types, but since each is meant for a particular moderator, it need not be anchor-hiding or even publicly verifiable. That opens the instantiation to blind signatures, to anonymous credit tokens and to anonymous rate-limited credentials alike.
Trading specificity for composability
The core tension in post-quantum credential design is that a protocol tuned tightly to one use case resists reuse. Most deployed post-quantum schemes follow this pattern: ML-DSA, for instance, derives from a general framework but its parameters are locked to an efficient and secure signature construction, and those same parameters would not necessarily be safe elsewhere. MOLE instead needs a toolkit whose pieces can be recombined into many credential systems as traffic patterns and attacker behavior shift.
Concretely, the challenge is decoupling parameter selection from protocol design. Classical systems make this look easy — designers rarely reason about the curve parameters they rely on — while efficient post-quantum credentials have until recently demanded deep specialist expertise. A 2026 result (Baum et al., USENIX Security 2026) suggests that is changing.
Proof-friendly primitives
VOLE-in-the-Head (Baum et al., Crypto 2023) is the foundation. It is a zero-knowledge proof system, meaning a prover convinces a verifier of knowledge of a hidden witness satisfying a public statement without revealing it, and the Fiat-Shamir transformation makes it non-interactive. VOLE ("Vector Oblivious Linear Evaluation") ordinarily gives two parties correlated random values that serve as authentication tags; in VOLEitH the prover generates both sides locally, commits to them, and lets Fiat-Shamir pick what gets checked. The construction is simple to implement securely, but not succinct: proof size grows linearly with witness size and arithmetic complexity.
What it does brilliantly is statements expressed as equations over small binary fields. Two examples matter here:
- FAEST proves knowledge of an AES key via relations like Y=AES(K,X), exploiting GF(28) arithmetic; 128s proofs run about 4KB at NIST Round 3.
- KuMQuat proves a solution to the Multivariate Quadratic (MQ) problem roughly of the form P(s) = (sTA1s + b1s,…,sTAms + bms), with signatures as small as 2.6KB.
These numbers don't compete with ML-DSA or FN-DSA, but that comparison misses the point: MOLE requires balance between performance and breadth of credential types.
Trapdoored MQ maps
UOV builds signatures by embedding structure into P. The public key is an MQ map and the signature is an s with P(s)=t, where t comes from hashing and salting the message; the secret key is a trapdoor that splits each equation's variables into "oil" and "vinegar" sets. Fixing vinegar values linearizes the system, which the signer solves for oil values, while the public key mixes the two types to hide the split. UOV offers 135-byte signatures against 46.6KB public keys; MAYO shrinks public keys at the cost of slightly larger signatures. Crucially, evaluating UOV or MAYO is about as expensive as evaluating an MQ instance, making both natural VOLEitH targets.
PoMFRIT: blind signatures from the combination
PoMFRIT pairs VOLEitH with MAYO and set a size record for candidate post-quantum blind signatures: 6.7KB for the signature, a few hundred bytes for issuance. Substituting UOV for MAYO (uov-Ip with FAEST-EM-128s) brings that to 4.3KB, at the price of larger public keys — acceptable where a key can be cached and reused.
The underlying paradigm is standard. The client commits with c=H(m,r); the issuer returns s=Sign(sk,c) without learning m; the client then proves knowledge of s and r such that Verify(pk,H(m,r))=1. That proof π is the blind signature. Unlinkability follows because issuance and presentation show completely different objects, so even a colluding issuer and verifier can't join the sessions.
Proof size is dominated by the hash, so the hash must suit the proof system. Keccak — used in SHAKE and TurboSHAKE — fits VOLEitH unusually well: XOR maps to addition, AND to multiplication, rotations just move values, whereas prime-field SNARKs handle bit-oriented operations awkwardly. Even so, Keccak dominates cost, so PoMFRIT uses exactly two permutations. The proved statement is roughly P(s)=H(H(m,r),rs), with s the signature, rs an issuer salt, P the UOV public key, and H the Keccak permutation truncated to the needed length.
Reconfiguring the blocks
Extending to endorsements means hiding the issuing anchor: given keys P1,…,PN, the statement becomes Pi(s)=H(H(m,r),rs) with index i added to the hidden witness. It still costs about two hashes and one MQ evaluation. Anonymous credit tokens and anonymous rate-limited credentials likewise add an extra hash or two, plus a range check on part of the witness (a credit count, say), which is cheap in VOLEitH. Across every MOLE construction examined, the dominant cost is the Keccak evaluation and its multiplicity — so any hashing saving pays off everywhere.
Cutting hashing costs
Two independent optimizations target proof size. The first plays the same trick as PoMFRIT. VOLEitH proving splits in two: the client commits to a random mask, hashes the message outside the circuit, masks the target and sends it to the issuer, who finds a preimage via the UOV trapdoor; the client then finishes the proof that preimage and mask agree. The issuer, acting as verifier, computes the hash directly instead of having the proof reproduce it.
This strengthens the assumption needed. Plain UOV says no quantum attacker finds a preimage of a random target without the trapdoor; the optimization enlarges the attacker's information, captured by a one-more-UOV assumption (analogous to one-more-MAYO in the PoMFRIT paper). That assumption may be optimistic: UCSD and INRIA researchers recently forged a 1024-bit RSA signature using a Privacy Pass issuer as a signing oracle, though deployed 2048-bit RSA plus other defenses retains margin, and UOV could move to NIST Level 3 rather than Level 1. Notably, a break here would affect forgery resistance only, not client privacy.
The second optimization makes each hash cheaper. TurboSHAKE runs 12 rounds instead of SHAKE's 24, substantially shrinking proofs at an acceptable margin. Shrinking the state from 1600 to 800 bits also works: 256 bits go to capacity for 128-bit security, leaving a 544-bit rate — plenty — and with less state an attacker has less to manipulate, while the circuit uses half the multiplications.
Native algebraic alternatives
The cleanest long-term win would be dropping conventional hashes entirely. One proposal fixes public random MQ maps F and G and commits via c=(m+F(r),G(r)), mirroring Pedersen commitments: constraints match the degree of UOV's, so proofs shrink and get simpler because symmetric crypto never enters the circuit. Experiments looked impressive, but whether the parameter regime giving improvement is also secure is unresolved — and the risk extends to privacy, not just unforgeability, so more study is required.
Another route is an MQ-friendly PRG. In typical VOLEitH parameters an extra witness bit costs ten proof bits; committing to a short PRG key and stretching it at low degree gets that to one bit, storing w XOR k. The trade-off is computing the PRG and raising witness degree from 1 to 2 — painful for prover time — and the savings only land once enough witness bits are needed. The PRG itself is the open problem: a random MQ instance is very slow and probably unnecessarily conservative, the Goldreich PRG is an as-sparse-as-possible MQ construction, and what's wanted is something between the two, a regime that has received little study.
Maturing MOLE for a post-quantum world
Post-quantum privacy primitives already exist today, which buys some time before a concrete replacement is needed. That window is what makes now the right moment to build alternatives rather than to wait.
Multivariate cryptography looks like a promising foundation for a broad range of anonymous tokens and credentials. Two schemes are currently in development on that basis: VOLE-IHAT, a candidate for MOLE endorsements, and VOLE-ACT, a candidate for MOLE credentials. Current cost estimates for both appear in the table below; the figures remain subject to change as the constructions are analyzed and developed. Both use UOV (uov-Ip), giving public keys of 46.6KB in every case, and VOLEitH runs with the same parameters as FAEST-EM-128s:
issuance | presentation | |
PoMFRIT (with UOV) | <1KB | 4.3KB (redemption) |
VOLE-IHAT | 5.6KB | 6.5KB (redemption) |
VOLE-ACT | 5.4KB | 12.0KB (spend) |
These sizes are considerably larger than their classical counterparts — no great surprise, since "PQ is big" is the defining property of the transition across the board. Still, the overhead of swapping RSA blind signatures for PoMFRIT is comparable to swapping ECDSA for ML-DSA.
Runtimes are also strong: with our implementation, each operation takes just a few milliseconds. Runtime can be improved substantially, though at the cost of higher communication.
From cryptography design to protocol engineering
If these numbers hold, an important milestone has been reached: the migration to post-quantum anonymous credentials for the web can move from cryptography design to protocol engineering. In practical terms, the belief is that these numbers can be made to work. Classical blind signatures, for instance, may be cheap enough to redeem on every request, whereas here redemption will have to be amortized over multiple requests.
What remains to be done
Two items stand between the current state and deployment. First, the protocols must be shown to be sound, in particular through security proofs establishing that they are secure as long as UOV is. Second, cryptanalysis of UOV needs time to catch up. Cryptographers are encouraged to spend time with multivariate cryptography; once the parameters stabilize, these schemes are expected to find a place in many useful applications. So far only the surface has been scratched.



