Frequent Password Changes Is a Bad Security Idea
schneier.com
schneier.com
https://medium.com/the-lighthouse/how-a-password-changed-my-...
Previous discussion on it: https://news.ycombinator.com/item?id=8015470
I hope that the passwords thus created emerge from good thoughts and not otherwise.
Some edict came through that scans had to be stored and accessed digitally. There were numerous teething problems in accessing the system, so a brain surgeon was going nuts running back and forth across the hospital trying to do his work.
A nurse in another department said he could use their consultant's login with the password 'fuckoff'. He ran back to his own desk, no go. So he went back and they said, "Ah, he has to keep changing the password each week so try fuckoff45" because the system had been set up almost a year prior. It didn't work, but after realizing more time had passed, he tried "fuckoff47" and it did the trick(!) Note that the problem here wasn't just the password but that sharing entire logins was/is rife.
(Update: I've found a reference to the story at https://www.theguardian.com/books/2014/mar/30/do-no-harm-sto...)
(The NHS is full of fun IT-related stories. Another was that due to patient privacy laws, keys to access scans had to be sent under separate transport. So you'd end up with situations where two couriers would be delivering separate USB sticks each to access a single scan.)
I just had a major banking institution send me a plaintext pw instead of reset token, with a 15 char limit, and a rotation requirement.
Probably not. But if you work as a contractor for somebody with non-sensical requirements, at least you have some research that you can link to to support your point.
Because to me requiring frequent password change seems like the ultimate non-technical management blunder: management wants to say they did something to prevent hacks, so they ask IT to require password changes; IT doesn't want to be blamed so they implement it; users comply with the requirements but can't remember their new password (and don't really care about the company's security in the first place), so they come up with something insecure and keep it somewhere even less secure.
https://www.schneier.com/blog/archives/2005/06/write_down_yo...
Obviously sticking it on your screen is a terrible idea, but if it's in a drawer (especially a locker one), it's probably not going to get stolen, especially not in a bank.
A similar scenario of disruption happens if you use lots of devices and need to update a password on several boxes to get working again. There may not be the communication overhead of my special code analogy (which is invariably delayed due to waiting for the manager to get out of meeting), however there is still disruption and time taken out from the task in hand.
As an aside, I like 'ambient' passwords, e.g. the VAT number on the receipt that you got given buying your lunch, the receipt can be kept in the top drawer - safe from the cleaner - and, if it is lost, you can go to the shop again to get another receipt.
I've seen people handle such requirements by creating an initial password, say p@$$w0rd and then appending a digit to it. On any subsequent mandatory password change event, they increment the new password from p@$$w0rd0 to p@$$w0rd1.
Not sure if it leads to anything more secure.
Wish more people started to use GPG based password store such as pass [0].
[1]: Or maybe "Foobar" (because you need a capital letter) or "Foobar!" (because you need a capital letter and a non-alphanumeric letter).
This isn't about setting the characteristics of a single password, it's about setting the allowed editing distance between them during a password change.
I asked about the backend to see if you know of one that supports more than just the current password. You can assume you have the current one as it's required to confirm your current identity. What you wouldn't have is the plaintext of the prior N passwords (N>1).
A custom backend could save the previous N hashes and either check for exact matches or check permutations against it. I'm just not aware of any off the shelf system that does so.
> This isn't about setting the characteristics of a single password, it's about setting the allowed editing distance between them during a password change.
Sure but I meant across more than just one previous password. In the system you describe if I have "FooBar1" and "BazQuz7" as both being acceptable, I can hop between them endlessly.
Just about all backends test the previous N passwords, so no, you couldn't.
What the system I describe does not prevent is switching between "FooBarX" and "BazQuxY" where X and Y are changing numbers or characters every time you switch back to them. To prevent that you would need a custom backend, sure.
Yes that's what I figured. Thanks!
Thinking about the problem a bit, I came up with two possible solutions[1].
The first is to save N prior hashes and brute force the permutations. The main issue with this is that if the CPU cost of the hashing is non-trivial (which you hope it would be) then this will be prohibitively slow (though still feasible for a small number of permutations).
The second is to store the plaintext of the old passwords encrypted using the current password. That way after verifying the current password you can decrypt the old ones and run the permutation checks against those as well. Updating the password would decrypt/encrypt the old passwords with the new password as the key[2].
[1]: If anybody else is following this thread and wants to build this, it's all yours!
[2]: Or more likely the new password would be the seed used to derive a key.
Where I work, we change passwords every 90 days, but every password other than full disk encryption, login and password manager are auto generated by password manager, so this mechanic is less of a concern.
Unless you have the same password across a dozen sites.
As I recall, the boundary was somewhere around 20 characters.
if similarity(old_password,new_password) > 50% then reject password change...
Seriously you cannot invent a password scheme where people can choose passwords that will not be vulnerable to this.
A password change dialog needs to be asking for the old password anyway and then verifying that it is correct to protect against people who step away from logged in sessions having their passwords changed by pranksters or worse.
I doubt "new not similar to old" policies actually accomplish much. If they are implemented securely using standard technology they will only be able to check the proposed new password against the current password. That just means that instead of having a sequence of similar passwords, P1, P2, P3, ..., users will have two such sequences interleaved: P1, Q1, P2, Q2, ..., where all the P's are similar and all the Q's are similar but the P's are not similar to the Q's.
There's probably a way to do a similarity check between two passwords given just hashes of the passwords (for instance, using homomorphic encryption), but that kind of thing is more research level than deploy live level, I believe. If/when that becomes practical, then a no similarity policy could go back as far as you are willing to keep old password hashes around without being any less secure than a no reuse policy going back as far.
But WHY ARE YOUR PASSWORDS BEING COMPROMISED?
That's what you need to address.
$ echo "Password" | md5sum 29f33cab54c2a8858885b95d8fbb7ff1
$ echo "PAssword" | md5sum 20a68cafb28eb68e306be529a29a8a62
$ echo "PASsword" | md5sum 2ed0aec406faee855f7739bc94fa60d0
If nothing else, it means the person has to have physical access and be able to pass off rifling through someones desk after breaking it open.
While this sort of stuff has happened in on-premise pentests, it's certainly not the normal way to attack when it's done for real.