Arguably, it was to make early rainbow tables less feasible.
> if you are already generating the password, please do not include special characters.
This would make your generator useless on most sites. Since it's not the generator making up this rule, it's the web site's password "complexity" requirements.
I do agree password strength tests should just measure bits of entropy and allow whatever's typed that's high enough.
There is a special place in hell for anyone who creates a maximum password length limit, however. That prevents passphrases and gains nothing. If you're working with some weird legacy system that can't handle long password (worst way: just truncating them and matching the first 8 characters), then add Argon2 or heck even SHA where you otherwise add the password length check.
If they have some perverse check to make sure I am not re-using one of my last X passwords I just rotate in another permutation like A2!
Some research suggests that arbitrary password rotations results in a real-world decrease in security, because as users get frustrated they make simpler and simpler passwords.
[0] https://docs-prv.pcisecuritystandards.org/PCI%20DSS/Standard...
"Oh yeah your password change properly is not synced to all servers yet. Just wait and try again later"
"Oh you tried the new password too many times while it was not synced yet. Your account is now locked. You need a manager approval to unlock your account."
There was a PayPal bug just a couple years ago where the reset-password page didn't enforce length like other pages did. So it allowed you to create an otherwise illegal password and then your account is completely locked out (I guess, unless you realized the truncation was happening...)
And so I would reset my password, generate a new one... and it would happen again. Took me a while to realize it was the length and not a special character I added messing up with bad encoding logic or something.
JetBlue truncated to 10, e.g.:
fly0nJetBlue -> fly0nJetBl
So I can tell you it's even worse when they silently truncate it on save, and on some logins, but not on all logins!'!' is a good one. Quotation marks are not. Currency signs are not.
TLDR; limit on older mainframe system, however password were properly hashed & they plan to remove the limit in the next year, which they did.
> Usernames and passwords containing letters need to be translated to numbers to enter them in a Fidelity phone system (like FAST®, or if you call a representative). Use your telephone keypad to convert the letters to numbers. There is no case sensitivity. Substitute an asterisk (*) for all special characters. Here's an example:
> To enter a username, e.g., Smith123, press or say 7-6-4-8-4-1-2-3
> To enter a password, e.g., Lucky1$23, press or say 5-8-2-5-9-1-*-2-3
People abuse everything, you can be dossed trying to compute <pick your hashing algorithm-of-choice> of a password as big as the maximum body size your webserver accept (which is a limit btw, so remember to dress light :-p )
There's no reason* why the time a hashing algorithm takes to do security rounds should vary with the length of the user's password. If you want to prevent DoS as GP mentioned then run all passwords through one round of a (fast) secure hash algorithm, then do security rounds with the output. This is what Argon2 does by default https://en.wikipedia.org/wiki/Argon2
I understand where it comes from (having computer systems designed by people who never spend a second thinking about your language) but still.
It’s 2024!
Then you get my personal favorite, which is sites that force you to use symbols, but when you do, they say you've used illegal symbols, but don't even tell you what symbols they accept, or which of the ones you've used were illegal.
Finally? It's almost been a decade since since special publication 800-63B was published recommending against silly things like composition rules and arbitrary password rotations.
> Verifiers and CSPs SHALL NOT impose other composition rules (e.g., requiring mixtures of different character types) for passwords and > Verifiers and CSPs SHALL NOT require users to change passwords periodically. However, verifiers SHALL force a change if there is evidence of compromise of the authenticator. > Verifiers and CSPs SHALL NOT impose other composition rules (e.g., requiring mixtures of different character types) for passwords.
> Verifiers and CSPs SHALL NOT prompt subscribers to use knowledge-based authentication (KBA) (e.g., “What was the name of your first pet?”) or security questions when choosing passwords.
It's possible to read "hunter2" from /dev/random.
To infer entropy from a single password, the best you can do is to see if it falls within the domain of some known, low-entropy systems. This works ok in practice, but is very far from perfect.
But your password is 10-20 bytes so you can say nothing about the generator.
Here’s a ‘not meaningful’ formula then: E = L × log₂(R)
• E is the entropy, in bits, representing how hard the password is to crack.
• L is the password length (number of characters).
• R is the size of the character set (e.g., 26 for lowercase letters, 52 for upper/lowercase, 62 if digits are included).
• log₂(R) is the number of bits needed to represent each character.
I hear your point: a single password might not actually use all character types, so the actual entropy could be less than its potential. Maybe they could have drawn from a wider range and didn’t.
But for everyday user feedback, assuming the fewest sets seems fine to nudge people toward picking stronger passwords.
If my string is "aaaa", does that mean its entropy is zero? There is at least information about its length. And by your definition, how do we know that this password isn't from a 256 character set? Does "Aaab" have 26 times the entropy of "aaab"?
Topics like this make more sense to me when the strings are infinite, or when the population of strings is known.
I realize I'm far from a typical use case, which is why I'm so glad when people consider password ergonomics. It makes life easier for me and does not make it harder for anyone else.
Software typing of password:
Linux - ydotool / xdotool. Win/Mac have similar tools:
$ sleep 5 ; xdotool type 'RC-A"c\EJe,0l@q'
>> physical device provided by the customer.Hardware : Rubber Ducky - https://shop.hak5.org/products/usb-rubber-ducky
sleep 3; xdotool type "abc123" $ export HISTCONTROL=ignoreboth
$ echo 'supersecret' | whateverAlright if you prefer:
read PW; sleep 3; xdotool type "$PW"
Or if it's already on your clipboard: sleep 3; xdotool type "$(xclip -o)"It is also the default on fish shell in the same anecdotal experience.
In your obscure set of requirements (no paste?), yes you might have to copy it again, but at least you don't have to remember it.
Your comment was interesting to me, so I was trying to come up with the most "ergonomically unsound" password. How did I do?
Å`÷½¸Å^çÏ+Í?«~Ðñø'`¾ ĮǶľƶₔâ¾ijĤĬ辶ıęśij²ÔķÕĜ́北¹«ƶħĸ«Have you tried entering a random password using the buttons and dials on the back of a Sony camera? After three tries, I just gave up.
With that it would be easy to build a temporary "type my secret key" dongle.
An ESP32 S2 or S3 dev kit board from a reputable source along with the other necessary hardware would probably be under $20.
There are also some models of Arduino that have the necessary USB support such as the Arduino Leonardo [2], but the Leonardo is more than an EPS32 at the non-sketchy sellers I've seen.
Even if you've never played around with microcontrollers this would be a beginner level project.
[1] https://github.com/espressif/arduino-esp32/tree/master/libra...
But that usually requires some sort of two way communication between your computer or phone and the device you are setting up or requires that the device has a network connection to a server that your phone or computer can also connect to.
You may still need to manually enter the password for that network connection.
Many WiFi streaming TV boxes are like that if I recall correctly. Manual setup to give them network access, but then later when setting up apps on them for Disney+, Netflix, and the like the apps can use an authentication protocol that doesn't need manual password entry.
I make my WiFi password easy to type for that reason.
I use a password manager but generally set it to only upper, lower and numbers and 24 characters, because so many sites seem to be broken for symbols.
But I do live in fear of the sites that are broken for long passwords (or even worse, silently broken).
But you can also fix it yourself if it fails. How is detailed here: https://support.apple.com/en-au/guide/iphone/iphf9219d8c9/io...
https://www.stefanjudis.com/today-i-learned/safari-allows-to...
https://github.com/whatwg/html/issues/3518
Another cool feature Apple spearheaded was the ability for websites to indicate the change password page in standard manner: https://w3c.github.io/webappsec-change-password-url/
But there's something bigger here that stood out and that kind of makes me angry: Apple, a multi-trillion dollar company, is influencing people to stop using products by small companies and small teams.
It's stuff like this, stuff like requirements to "sign in / pay with Apple", and stuff like the green text boxes that make you have to fit everything to Apple and give them their dues.
I really wish we'd regulate or break up the big tech companies. Innovation has barriers to entry because of them.
Apple shouldn't be making their own password standard. They should work in an industry consortium to agree across the board, and they should put in the extra effort to tell users when websites may not comply with their new rules. It's not the website's fault that they didn't get the new and unannounced memo.
Add a new HTML password form property to indicate compliance with the standard before you go generating uncompliant passwords. Do a graceful migration. Stop beating up the little players.
I'm starting to think that neither Google nor Apple should be allowed to have their own web browsers. They're only using them as a means to deepen their platform reach and hobble up more control.
Pretty soon Apple and Google won't generate passwords at all. They'll deprecate the password field and mark it dangerous. Then it'll be an Apple passkey where companies will have to negotiate payment rates and won't be privileged to know their own customer.
Reasonable sites should already allow passwords of the sort Apple generates, because they tick the usual boxes (length, entropy, and the pointless at-least-one-uppercase/digit/punctuation requirement). Now, many websites are not reasonable and enforce even-more-pointless requirements. Apple tries to mitigate this with a hardcoded list of popular websites’ password policies [1], which is used to tailor password generation for those websites. To be fair, this approach doesn’t scale for smaller websites. But there’s not much more Apple could do. In any case, at this point websites have had many years to adapt to Apple’s password manager and its password style (which has not changed recently).
Accepting passkeys doesn’t cost money, and they’re based on a web standard. There are valid objections to passkeys but this ain’t it.
[1] https://github.com/apple/password-manager-resources/blob/mai...
https://github.com/apple/password-manager-resources/tree/mai...
The password generators that generate me 20 characters of different character classes are crazy.
alias genpasswd='openssl rand -rand /dev/random -base64'
Additionally I have a function in Bash that takes words from particular languages which are separated, along with "gpw" ("Generate Pronounceable Password", a C program).It also offers Passphrase generation using dictionary words plus digits and specials (as word separators). You can change the special character used, but it's not randomly chosen each time.
I'd love it if it had an option for pronounceable or syllable-based generation as described in the article.
include only one of each I/l/1, 0/O
soundalikes without phonetics - so include only one of the following e, p, c, v, t, 3
"Summer2024!" is perfectly fine, if you use it for exactly one service. Frankly, "1235" is probably fine. No one is out there brute-forcing passwords.
I just find it funny that my bank doesn't say to reset my bank website password if my identity gets stolen or there's fraudulent charges on my account. They go after the root of the problem.
People are walking around trying car doors at night and people are throwing dictionaries and tables at log in forms. Would you blame the bank if someone guessed your password of 1234? How are they supposed to tell it isn't you?
I suppose, if it's some random forum, they could just post some bot spam with your account and get you banned, no big deal. You'll live.
We could explore that further: are there any recent examples of this happening? is cracking password hashes still hard, given modern GPU hardware techniques? This could help us establish what "low" actually means when I say "low threshold."
Modern password hashing is very good.
Yes, if the entropy is high enough. What else would be the point of salting and hashing passwords?
There's no known way to reverse major hash algorithms like SHA-256 or bcrypt; you have to try all the combinations. So you have to do exponential work in the amount of entropy whereas GPUs only give a constant factor speedup over CPUs.
If this ever changes (e.g., someone breaks SHA-256 or bcrypt) you will definitely see it as the #1 story on HN (and probably pretty prominently in mainstream media too).
So in your very specific contrived scenario that a user is using weak passwords but never reusing them, yes they are fine provided the site with the leaked account data realizes this and makes you reset your password.
But we already know that in reality most people reuse weak passwords. If your reused password was a passphrase that wasn't in the dictionary and couldn't be brute forced in a reasonable time, then you would be fine.
It would be better to focus on easy and unique, than to focus on entropy.
I have no idea what that minimum should be though. Aren't passwords cracked with GPU? I admittedly have no clue about this, but it sounds right to me lol. Assuming they are, a 4090 can probably guess a hell of a lot of passwords per second. I've had the same generated strong Reddit password for like 15 years, what are GPUs going to look like in the next 15?
The last time I had to implement password login for something we just followed NIST guidelines and called it a day.
Your point that using entropy rich passwords is foolish, is incorrect most of the time, and even if it weren't people's general understanding of where specifically to draw that line is generally significantly underestimated as a collective. The evidence of this is the amount of data breach information available, and the actual attacks which are available using this information.
Service breaches happen where the password database is insufficiently secured, and that often correlates strongly with insufficient protection of the password hashes. This means that low entropy passwords can be cracked and used for a period of time before the data breach is discovered. Entropy (and MFA) are the only protections against that.
56 DES was cracked in a day in 1999. Your passwords should definitely have more entropy than that. Probably around 80 bits is enough (about 16 alphanumeric characters or so). Your much lower threshold on entropy is insufficient for pretty much any reasonable threat model except public access.
They definitely are. I’ve been locked out of my own banks website twice because of people trying to guess the password too many times.
https://haveibeenpwned.com/Passwords says Summer2024! has been seen in two breaches, which means even if it weren't being brute forced it's less safe. 1235 has been seen significantly more times...
I'm curious if you're just being satirical here - it's not entirely obvious.
Credential stuffing is an attack people are actually doing.
flat wrong ... if one thinks this, one likely isn't operating a high value target
Respectfully, I disagree. "Summer2024!" is probably the second password I'd try after the username itself if I have to guess a password. Use it in a password spraying attack on a company with 500 users and you will get a few hits, I promise.
If you already know it's in apple password format, then you know 1/17 of the letters are capital, but not which one so the number of combinations you have to try is multiplied by 17, for just over 4 additional bits of entropy.
Extra character classes can help if you're stuck needing to make a really short password for some reason, but if you're randomly generating each symbol anyway, just tossing a few more on the end is *far* more effective. You massively increase the brute force search space with each additional symbol.
On the other hand, any extra lowercase letter will increase the entropy by 4.7 bits (assuming a password on [a-z]).
Given that most passwords have at best 2 uppercase letters, I would argue it is safer to force longer passwords than passwords with at least one uppercase letter.
With the constraint that it has to be half upper/half lower you only get 252 times as many passwords instead of 1024 times as many.
The iOS keyboard layout and behavior for many years undoubtedly made password rules like this a necessity - can't be mode switching all the time just to put in a password.
Edit: Xyzzy could also be used to generate plausible drug names or RPG character names.
The usual advice about character classes is only for casual users who don't know what makes a secure password. Entropy is the deciding factor: Ten random lower case letters is much more secure than "Summer2024!", which satisfies most password rules and has more characters.
Personally I stick to lower case letters for things like my Netflix password or Wifi key, because typing with a TV remote can be a huge pain. To keep a similar entropy, just increase the length by one or two characters.