- cross-posted to:
- [email protected]
- [email protected]
- cross-posted to:
- [email protected]
- [email protected]
Edit: obligatory explanation (thanks mods for squaring me away)…
What you see via the UI isn’t “all that exists”. Unlike Reddit, where everything is a black box, there are a lot more eyeballs who can see “under the hood”. Any instance admin, proper or rogue, gets a ton of information that users won’t normally see. The attached example demonstrates that while users will only see upvote/downvote tallies, admins can see who actually performed those actions.
Edit: To clarify, not just YOUR instance admin gets this info. This is ANY instance admin across the Fediverse.
Couldn’t we just use a hash for the usernames instead?
Nothing too over the top, but just a simple hash and match that instead?
Also, there’s way too much trust in instances. Like, one person could easily make a post on lemmy.world, go on their personal instance, and just give themselves, say, 2000 upvotes.
Instances should have their own settings on what instances are allowed to keep a local copy. (Default behavior should be to get the post itself from the instance “hosting” it).
If that is a solution you’d need to change the ActivityPub specification. You are more than welcome to submit your idea.
I’d first have to create 2000 users, then I’d have to send 2000 upvotes. And then I’d get blocked by all instances.
This is also not compatible with the ActivityPub spec but even if it were you’d win nothing because as soon as you fetch the post it is still on the server.
Hey, just curious: how would all the instances discover this type of fraud?
They’d have to check the upvotes, notice most of them came from one instance, look at the instance, check multiple users, and if they realize that these users were just created to get upvotes then they can defederate. However, it’s too big of an assumption that moderators will go through that kind of effort to validate all the upvotes.
AFAIK, the ActivityPub specification has no requirements on how likes should be stored. The two things that is requires are that likes are added to the user’s liked collection, and that the post’s like count is updated.
Mastodon actually just stores all this data on the server containing the post itself. Instance admins get as much information about the post as the client does. Both Lemmy and Mastodon use the same protocol, but Mastodon chooses to only to trust the server the user is using, and not the third-party servers.
Creating that many users wouldn’t be hard to do(you don’t need to use the GUI, just a little SQL is all that’s needed). And you don’t need to “send” the upvotes; you can sidestep the protocol entirely and just update the database. That’s the problem.
And while yeah, the instances would block me, they probably wouldn’t notice if I did it at a much smaller scale. In fact, there’s no real easy way to check whether these upvotes from an instance are actually real.
The hash function would still need to be public to share data between instances.
That’s the point of a hash function. You have a public hash function, say SHA-256. It’s easy to check a username against it’s hash, but virtually impossible to reverse the hash back to the username.
Edit: Instead of storing, say,
eddie, we’d store3b9d8298f1b5086d012618feebb2da1a394357c1dab7523443c9f6a743c4c84d. Then when the instance gets aLikefromeddie, it hashes his username to get3b9d8298f1b5086d012618feebb2da1a394357c1dab7523443c9f6a743c4c84d, realizes there’s a match, and doesn’t update the count.Note that when given
3b9d8298f1b5086d012618feebb2da1a394357c1dab7523443c9f6a743c4c84d, it would take millions of CPU years to compute the original username from it. Therefore, we can check for duplicates without actually checking the name itself (a similar method is used for checking passwords; Lemmy is open source, we know the hashing algorithm, but we can’t unhash user passwords, only check them).While there is an enormous amount of possible passwords, there is only a limited (and quite small) amount of users. Couldn’t you just hash all the usernames one by one and map the hashes to the usernames? So you could still reverse engineer the usernames of those who voted on a post.
Edit: Salting with the post id would make this attacking process harder, but still realistic. Probably the only real solution is to hide the votes table from federated instances, I’m not sure if that brings technical problems.
If anything, wouldn’t that make vote abuse even easier? Just send 100 upvotes with 100 random hashes.
That was what I was implying, yes.
Just hash each username and store it. Then just check the usernames hash to see if it matches.
I was more comnenting that you could still reverse engineer the users who voted on a post
Actually, you’re not really wrong.
All the more reason to give out limited data to all other instances. Why do these instances really need this data? Mastodon doesn’t need it, not quite sure why Lemmy does it.
Yeah I don’t understand why every instance can’t keep track of their own votes privately. Sure, voting manipulation is a thing, but it’s possible regardless.
Honestly I really hope Lemmy does something to address this issue. Otherwise it’s kind of a dealbreaker for me.
I say there’s too much care about votes. Because someone can just give themselves infinite votes from their private instance, it makes it all the more worthless.
There’s a setting for that, it’s called the allowed list - configures who are allowed to federate with you. Beyond that - if it’s out, it’s out.
Votes are the only real way currently to gauge opinion about the post itself. IMO, if the votes system is so bad that people are starting to completely disregard it, there’s something wrong.
It’s a lot easier to fake a hash than a username. If I’m an instance owner and I suspect another instance of this, I can grab a random username and check their post history. Pretty easy to see rampant fraud that way.
If you’re putting something out on the internet, even upvotes or clicks, expect it to be public.