4 ms·
Usually this blog is very practical and easy to understand. This post, though, just talks about how great PAKE is and what this new proposal achieves, but not t
by lucb1e 8y ago
Usually this blog is very practical and easy to understand. This post, though, just talks about how great PAKE is and what this new proposal achieves, but not the how of it. It sounds better than client side hashing, but it doesn't explain how (or whether) that's achieved. Actually looking into PAKE is left as an exercise for the reader (other than one screenshot full of math at the bottom).
Wikipedia is actually more clear in this case:
> an eavesdropper or man in the middle cannot obtain enough information to be able to brute force guess a password without further interactions with the parties for each (few) guesses. This means that strong security can be obtained using weak passwords.
Looking into SRP, it seems that a server can still brute force a stored login. While cool, TLS achieves the same goal in popular login systems: eavesdroppers cannot learn anything (in fact, they cannot even make a single attempt at the password, unlike with PAKE). The other advantage of PAKE, the server never receiving the password, can be done with client side hashing (for which I've been advocating for years, as it would have prevented many issues).
- the_clarence 8y agoIf you are an active server attacker, you can simply disable hashing and store passwords in clear. With SRP you cannot.
- panopticon 8y agoMaybe this is naive, but if the server is compromised such that an attacker can circumventing your hashing function can't the attacker just send some JS down to the client that records the password before it's hashed?
- tptacek 8y agoYes, you can't securely deploy a PAKE using browser javascript. If it's web applications you want to secure, your users will have to install something to make a PAKE secure.
- cipherboy 8y agoThat something can be minimized to "a browser" when SPAKE+2FA support is finalized in Kerberos. Admittedly, only really useful for enterprise clients who already have krb5 deployed, but still it is something better than JS.
- tptacek 8y agoThe word "admittedly" is doing a lot of work in that sentence.
- lucb1e 8y agoThis still sounds the same as client side hashing to me. At some point I tried talking to people to make client side hashing an option in <input type=password hashmethod=X>, but nobody cared more than saying "yeah sounds good" when prompted. If this would have been implemented and would have become mainstream, browsers can warn if a site (suddenly) doesn't use it, much like warning for http (or even pinning a la hsts). So as it is, it indeed cannot be done securely in browsers.
- tptacek 8y agoApart from the fact that I think client-side hashing is silly, I agree with you; we're saying the same thing about the feasibility of PAKEs in browser applications.
- the_clarence 8y agoIt’s not silly if it’s done outside of browsers I’d say. But with browsers it's tricky to implement (and its where it would be useful)
- tptacek 8y agoIt's silly because as soon as you're doing something custom clientside, you might as well just use a PAKE.
- fileworm 8y agoIt's worse than that. In the web app use case, if the browser is sending cleartext passwords to the server, all an attacker has to do is hijack the server IP with BGP, get a DV SSL cert and slurp up all the passwords.
- gdavisson 8y agoGiven how common SSL interception is becoming, I don't consider TLS sufficient protection for passwords. Your security appliance may have a legitimate need to see my network traffic, but not my password. And if someone pwns the appliance, they pwn everything. Client-side hashing helps a little, but not enough; you're still vulnerable to pass-the-hash attacks. Using PAKE inside a TLS connection avoids all of these vulnerabilities.
- eridius 8y agoHow does client-side hashing solve the "server shouldn't have the password" problem? Doesn't that just make the hash into the real password? It may solve the problem of password reuse across different sites, but it doesn't solve the problem of the server's password database is leaked and the attacker can now try and break the passwords in order to use them to log back into the server and impersonate the user.
- matthewdgreen 8y agoClient side hashing solves only one aspect of the problem. Effectively, this means a password breach of your service will give the attacker a “password equivalent” that they can subsequently use to log into the service without further cracking. This may or may not be a problem, depending on whether you’re willing to lock all user accounts. Whereas a proper asymmetric PAKE means that even if your password file is breached, the attacker can’t use the leaked hashes to log into the service without first cracking each password. The problem you point out: that password hashes can be brute-force cracked, is unfortunately not a problem we can solve. Consider that a server can always “attempt a login to itself”, so given a password database you can always run a dictionary attack. The only thing truly protecting you in that case is the combination of strong passwords and a hard password hashing algorithm. Passwords are fundamentally a drag.
- kijin 8y agoIt's not all-or-nothing. You can hash passwords on the client side, and hash it some more on the server side before committing the final result to permanent storage. A breach of your database won't give the attacker a password equivalent in that case.
- xyzzy123 8y ago[Orthogonally to client-side hashing] Using a hardware one-way function you can ensure that even if your database is breached or disclosed, attackers cannot brute-force outside of your environment (e.g. the hashed are “anchored” to your systems). You can construct such a function using something like CloudHSM (pity that KMS cannot be coaxed to be deterministic or you could use that). All you need is an encrypt operation with no corresponding decrypt or way to extract the key. I’m surprised that more large online services don’t use anchoring.