Almost all the implementations require the old password when you change it to the new password, so it's trivial to check if they are too similar.
def changePassword(login, cleartextOld, cleartextNew):
if too_similar(cleartextOld, cleartextNew):
return new Error("too similar")
hashOld = hash(cleartextOld)
hashNew = hash(cleartextNew)
if authorized(login, hashOld):
setPassword(login, hashNew)
return new Ok();
If you're afraid of sending cleartext passwords - do the too_similar check on the client side. The users that can write their own client to bypass client-side checks are exactly the users you don't need to worry about.That's why, to encourage users to assume last month's password was compromised, when my users change their password the old password is automatically posted to twitter
/s
Sure there is. In your update logic, decrement any numbers and check the hash against the existing password. Alternatively, require the existing password in the same form and you don't have to check against hashes, since you have the plaintext password right there.
People will either keep trying new strategies to embed counters in their passwords (maybe increment a letter, or multiple a number by 10), or they’ll just write the password on a post-it they keep on their laptop.
Either way you’ve now got a whole load of complicated code that makes it harder to people to create genuinely strong and memorable passwords, and no additional security.
Presumably, you will also have a forgot password flow that allows you to change your password without entering the old one.
People will make things easy for themselves. Coming up with good passwords is hard. Having to rotate passwords just seems like a lot of busywork and people will make it as easy for themselves as possible.
Because it had a fairly short password cycle, I'm sure most users ended up with something like "password1!TwentyFour" then "password1!TwentyFive".
Me: I just changed my password 51 times when it was time. I'm not sure what point I was proving, but I was proud of myself.
Of course, it's also possible they stored the clear text password, I have no real way of knowing.
This is impractical if you're following good password storage practices. Assume the user's new password is 16 characters long, and that only the 95 printable characters are allowed in passwords. Then to test that the Levenshtein distances between it and the user's last 5 passwords are all greater than 1, the server would have to compute (5 * (1 + 95 * 17 + 16 + 94 * 16)) = 15,680 different hashes, which will take quite a while if you picked a secure iteration count for your password hashing function. And even if you did this, it still couldn't detect mypassword100100 -> mypassword101101 -> mypassword102102, etc. (Making sure the Levenshtein distances are greater than 2 would require checking millions of hashes.)
SomePasswordABC SomePasswordDEF SomePasswordGHI
...
Or
My1Password! My2Password! My3Password!
...
Or
MyPasswordUno MyPasswordDue MyPasswordTre
> Thus if there really is a breach where the plaintext password is recovered by an attacker it is trivial to find out what this year's version is.
These are contradictory statements.
basepassword-2021
which they will change next year to
basepassword-2022
Because password hashing makes it impossible to retrieve the original password, there is no way to guard against people just using a basepassword and appending some type of counter to it.
Thus if there really is a breach where the plaintext password is recovered by an attacker it is trivial to find out what this year's version is.
So all you end up doing is needlessly irritating your users, for not much security.
Multifactor Authentication is a much better solution for the issues of unknown breaches.