|
|
|
|
|
by AnthonyMouse
898 days ago
|
|
How is this supposed to protect against timing correlation attacks? If each time User 1234 signs into a particular site, Bob Smith requests a token, we know with high probability that Bob Smith is User 1234 (or anyway is using his ID to request tokens). You can solve this by giving the user a generic token that asserts that the bearer is e.g. over 18 and is valid on any site for e.g. 30 days, and then Bob can request arbitrarily many tokens on the first of the month and use them as needed. But now all of this ZK proof stuff is making things unnecessarily complicated, because you could then give every user the same token that expires at the end of 30 days. They're fungible and anonymous. Anonymous means you can't distinguish one from the other means you don't need different users to be different, and then you don't have to worry about vulnerabilities in your ZK system. Which leads back to the main problem with this whole mess: All it takes is for one person with an adult ID to share the token. Which is the problem with all of these systems -- most of the population has an ID and they can share access to it. There is no way to catch them or stop them if they're actually anonymous. If you could, they wouldn't be, and then the system fails as an invasion of privacy. |
|
In my zk group scheme, you do get one token for each epoch. (could be 30 days) It's simply suggested that you wait as long as possible between joining the group on your main account before minting your token on the anon account.
Finding applications for ZK tech is complicated because it only works for such narrow circumstances. Although in your case of "give every user the same token" makes the users anonymous to everyone except the issuer. The issuer is still able to know to whom they're giving them. With a ZK proof, the bearer instead mints the token by proving that they are one from the set of people the issuer has verified. The issuer cannot then break the privacy.
As for mitigating people sharing their tokens, of course that's always a fear but I think mitigation strategies would be unique to each application's use case.