Consti @ p_consti @lemmy.world

Programming and reading.

---

Read more

Posts

2

Comments

53

Joined

2 yr. ago

Adding to this, I had to run both Windows and Linux from a USB-connected m.2 SSD for a while, and noticed similar patterns, checking the disk (or its connection) is probably a good clue.

The last character

Ternary, and inline switch (match expressions), as found in functional languages

Of course it won't do anything, you need to update (refresh the index) before you upgrade (download and install updates), silly you

Got any link for that? That's news to me

I would be very interested in that book. My university did not provide explicit book sources, so I can't tell you what that is based on, but here are the relevant slides (from page 9). Server-side hashing is so ubiquitous as the standard that e.g. OWASP cheat sheet doesn't even explicitly say it, but their recommendations hint at it.

A quick google search on the topic revealed others with the same opinion: stackoverflow stackoverflow. The second link (accepted answer in the same thread) argues that with a protocol around it, it can make sense, but never in the situation described here. There needs to be a meaningful computation on the server's side, otherwise the described scenario can happen.

It's a bit difficult to find papers on that because server-side hashing is standard, but here, for example, is a paper that explores client-side hashing (see the introduction with a reference to server-side hashing and section 2): Client Password Hashing paper. Very interesting is also section 3.4. Similar paper: Client-side hashing for efficient typo-tolerant password checkers. Essentially, both suggest that to avoid the described attack, both server-side and client-side hashing is necessary (but the server-side hash can be weaker), see "Authentication attacks after leaks". Neither paper describes how the client-side hashing is done on the Chinese websites they mention.

You'll also find that many frameworks (e.g. ASP.NET, Laravel) implement server-side hashing.

My conclusion from the little research I did after your prompt is that client-side hashing can work, but it's dangerous if done incorrectly (e.g. when done as suggested above), due to the scenario I described.

Not necessarily. If it's implemented well, the frontend will just show a "success" message, but the email sent will be different. This way, the owner of the account will know if they already have an account, or if it wasn't them, that someone else tried to use their email. Meanwhile the bad actor won't know anything new.

No, it is not. If the server accepts the hash from an untrusted source (the client), then that's equivalent to not using hashes at all. The reason why we hash is so a database leak does not allow malicious actors to login directly. If the server accepts a hash, that means it only does hash_from_client == hash_from_db, meaning that's the same as doing password_from_client == password_from_db in terms of security. This is because the client can just send the hash from the DB, the user does not actually need to know the password, hence your proposal is equivalent to not using hashes at all in terms of security.

The point of sending hashes info from the client is that each site uses a different key, even if publicly available. This means that leaked login data cannot be compared or matched across different leaks.

That is for keyed hash functions, which is not typically done for passwords (but peppers are sometimes used, which helps similarly). This does not prevent the above scenario, though, because the leaked hash can still be used on that site. Sending hashes is a bad idea, the hash should always be computed in a trusted environment to ensure the user actually knows the password.

The client doesn't hash. The client needs to send the plain text. Otherwise, that's a security problem; the server needs to confirm the user knows the actual password, so the server needs to compute the hash and compare. If the client sent the hash, then there was no reason to compute hashes in the first place, because the attacker can just send the leaked hash (the reason to hash it is to avoid that the leak can be used to log in directly).

Why the fuck would the client confirm the hashes? Don't trust the client. The server handles the login; an attacker can just write a lying client "yeah sure I know this guy, it's hitmyspot, now let me in".

The only reason we store passwords in hashed form is to prevent damage from leaks. How would storing it twice make login more secure? The client sends both the email and the password in plaintext, everything else is on the server's side. The client does not care or know how the data is stored (or if it is stored at all). So storing it twice does nothing except waste disk space.

The only thing that needs to be encrypted or hashed is the password.

But telling that an email is already in use is leaking information. A bad actor can use this to figure out if you are using a particular service, or alternatively try random email addresses and check if they belong to a real user. This is why it's usually encouraged to just say "invalid combination of username/email and password", instead of specifying which is incorrect.

... Says the guy using a pseudonym and the default profile picture

They're reading from the USB into /dev/null (effectively throwing the read data away), not writing

You replied to the wrong comment I believe

Did you really mirror the image part to repost this? Even the watermark is flipped

Not just reliably. If there was a chance, people would do it.

What the hell is that figure, it's 125mph

How in the world do you get a java exception in rust?? Also the invoking program is java

I was programming in assembly for ARM (some cortex chip) and I kid you not the C program we were integrating with required 255, with just 1 it read it as false