How secure is this process for creating passwords?

Question

I've been research into how to be as secure as possible when it comes to password security for online services and websites. Obviously there are some big no no's like using dictionary words, using the same password for multiple websites, personal information, etc.

I've looked into password managers and they seem like a pretty good idea, but also am a little skeptical on the security of password managers also.

I'm leaning towards having a strong unique passwords for different sites that I can remember, which is virtually impossible to remember if you were to have them almost entirely unique.

How secure is this process? If I were to for example have a base password of something around the lines of I^l@t(h$Y1G2 (Don't worry, not what I'm actually using)

I would use this base password for all of my passwords, but to make each unique I would do something around the lines of placing the first vowel of the website name at the front and the first consonant at the end.

So my theoretical password for Twitter.com would be iI^l@t(h$Y1G2T

How secure is using this type of system?

Answer 1

On a practical basis, I'm going to have to say that this type of system is extremely weak once any one of your passwords has leaked; it doesn't matter which one.

For example, if you used }P_-^cWi_OD~w{qjjA4f (randomly generated) as your "core" password, then you'd have

o}P_-^cWi_OD~w{qjjA4fN for NotSecureSite.

and a}P_-^cWi_OD~w{qjjA4fB for BankSite.

Assuming

1. Your NotSecureSite password gets found out by an attacker somehow, perhaps because they are a Plain Text Offender and suffer a breach

   a. And then those plaintext passwords make their way out, as the RockYou and Facebook lists did

2. Then another site you're on suffers a breach; we'll say it was BankSite, which used MD5 hashing (for simplicity; really, they could use anything, even fairly reasonable algorithms)

3. An attacker with both sets of data who uses the following simple rule will find your Paypal password using John the Ripper or oclHashcat and the following simple rule:

   a. Command line:

   1. ./oclHashcat64.bin --hash-type=0 --attack-mode=0 --rules-file=random.rule random.word.md5 random.dict

   a. One line in random.rule reads

   1. []^a$B

      a. [ - delete first character a. ] - delete last character a. ^ - prepend the next character a. $ - append the next character a. Note that there are only 3,844 rules to exhaustively search the space for each starting password if the attacker goes through a-zA-Z0-9 for both; your actual scheme can usually be found in 130 rules (5*26) for each password.

      1. Worse, this is pretty tiny. Rulesets distributed with oclHashcat by default include the 12 thousand rules of T0XlCv1.rule, the 35 thousand rules of d3ad0ne.rule, and the 123 thousand rules of dive.rule, so less than 4 thousand maximum is a drop in the bucket.

Try using unique cryptographically random, long passwords and a password manager like KeePass to generate and store them; it has ports for Apple, iPhone, Android, Linux, Windows, etc.

Make sure to go into Database Settings, Security, and set the number of rounds to at least one second's worth, preferably several (there's a button/link for 1 second delay; then make it bigger) particularly on slower devices.

As an alternative, I would suggest something very different. It can be done in many ways, but using any of the variety of PBKDF2 implementations on my github site, several of which include Windows executables, some of which are in Python or other common languages.

Then, use your "core" password as the password, the website name as the salt, a lot of iterations, since you have no or almost no special characters, you'll need even longer passwords than normal, but you'll be able to cut and paste. At this time I apologize, as Base64 output isn't implemented much yet, though I'm working on it. hex output is fine, though, if you use all of it and -o parameter, output length, is long enough - just know hex is twice as long.

• NotSecureSite:

  • ./pbkdf2 -p a}P_-^cWi_OD~w{qjjA4fB -s NotSecureSite.com -a SHA-512 -i 1024000 -o 20

    • 104d58f4c9fac5063ed9ed9303ccadc740053963

  • ./pbkdf2 -p a}P_-^cWi_OD~w{qjjA4fB -s NotSecureSite.com -a SHA-512 -i 1024000 -o 20 -O base64

    • EE1Y9Mn6xQY+2e2TA8ytx0AFOWM

• BankSite:

  • ./pbkdf2 -p a}P_-^cWi_OD~w{qjjA4fB -s BankSite.com -a SHA-512 -i 1024000 -o 20

    • acaafd556c984e1c225369a5b95e37a38e34e48f

  • ./pbkdf2 -p a}P_-^cWi_OD~w{qjjA4fB -s BankSite.com -a SHA-512 -i 1024000 -o 20 -O base64

    • rKr9VWyYThwiU2mluV43o4405I8

• The longer hex and shorter Base64 are exactly as secure, since they came from the same 20 binary bits.

• both the base password and the number of iterations must be the same

• note that the NotSecureSite and BankSite passwords look nothing alike, and have no discernable patterns beyond being clearly hex or Base64 encoded data.

• note that I used more than a million iterations AND a 20 character random base password; this should help protect against those who have determined your algorithm (since we must assume attackers figured it out/learned of it somehow) by giving a large keyspace and slowing them down.

Answer 2

Rule #1 of security: Assume attackers are cleverer than you.

Imagine if an attacker really wanted to get access to an account you own.

They search on the web and Pastebin for past breaches and find that the account [email protected] was involved in two breaches.

• In the first breach the password was cracked and it was oI^l@t(h$Y1G2G.
• In the second breach the cracked password was AI^l@t(h$Y1G2s.

It will be pretty obvious to the attacker that there is a password scheme in use, especially as the name of each breached website is already known. For any variations on this, see Rule #1.

Answer 3

The answer is, it depends!

Basically the security of this concept is the same as reusing the same password on multiple website, but adding some characters at the end.

If the base-password itself is complex and long enough this results in passwords that are harder to brute-force, assuming proper security on the website's back-end.

The problem with this technique is, that if one website would store your password in plaintext and an attacker would gain access to it's database he could test your password system on other websites. He would have your base password and thus the complexity is reduced to two characters, which frankly isn't a lot.

If all websites store your password properly it would be secure enough. But you never know if that is the case and you never know if somebody might target your account specifically.

Answer 4

You're on the right path -- the single most important thing you can do is have a different password for each site you log into. The key benefit is that if a site is hacked (they are, every day), sites using weak methods to obfuscate your password make it easier for your password to be cracked. Having the same password everywhere means if they know your password once, they know it lots of other places, too.

Complexity is important because it helps defeat the cracking methods. But schemes as you mention can be a little tricky, since there are other ways hackers get your password that don't need cracking.

So I strongly recommend password managers, and of all out there, 1Password is the one I trust most since their strategy is to never store your master password on their servers. Others password managers may do this, too -- so any good one is worth it. A password manager makes it feasible and convenient to have a long, complex, random and unique password for every site. The best ones do much more, too.

And for the most important sites, use their multi-factor authentication (MFA or 2FA). It's a total pain because you need to have something, typically a phone, that will provide a secondary code. But for the email account that will be the one used to confirm forgotten passwords, use it.

There are several ways bad people get passwords. They guess them from common uses like P@ssw0rd!, weakly encrypted passwords are stolen from breached sites then cracked using dictionary words. Your method solves these.

But there's a third: poorly secured or hacked sites, or phishing/social engineering scams get you to type in a password -- hackers now know it with very little effort. Sites serious about security protect against this, and monitor patterns that suggest breaches. But most don't. (Today, these methods are the most common way of effectively getting passwords).

If we assume that a hacker knows your password to a specific site, how secure is the method now?

Let's say the common part of the password is some long and complex string -- I'll use XXXX to represent it. But if you create a suffix or prefix based on something about the site, that is not complex or is guessable, like a SXXXX, using the first letter of "stackexchange", you're now at some risk. Make it longer, like sTaXXXX? Actually more guessable. Make it tricky, like sT@XXXX or atsXXXX ... getting warmer. Embed within, like XsXtXaX, better still, probably.

But this general technical is a widely promoted strategy because it's the only one humans can actually remember, so the people trying to hack it know what to look for.

So once your pattern is guessed, they have your email address, so try logging in there -- if Google, then XgXoXoX, right? And now, they change your Google password, and start resetting all of your other passwords. Now you're really sunk. How do I know? Almost happened to me in 2007, except I got lucky. And since then: 1Password.

Passwords are a terrible, terrible means of security. A physical key to your house is better: you need the key or a copy, and you need to be at the house! Generated random passwords from software like 1Password, especially combined with multi-factor authentication for the critical sites are the way to go. No two sites I have accounts on share a password, and I don't know a single one of them. The ones my family need are stored in a separate "vault" having a separate password, and I am the only person who knows the master, and I change it frequently.

Hope this helps!

Answer 5

Let's put aside security for a moment, and focus on usability.

Assume that at least one website you use is breached at some point. What then?

Obviously you must change that password. Luckily, you thought ahead and did not use the same password on every site you use, so only that one site has been compromised.

If you are using a password manager, you go to that one website, click the "generate password" button in your password manager, and copy-paste to the new password field in the website. Done.

With your reuse-with-modifications scheme, you can't just change the prefix, because that is really no better than a rolling counter like password1, password2, password3, etc. So you must change the base password.

Now that you've changed the base password, you either need to remember a per-site exception to your general rule, or you need to change every single password you have to use the new base password. Changing the base is actually probably a better idea anyway, since as other answers have pointed out, your scheme is basically known at this point.

How many passwords do you have? At this moment in my password manager I have 112 entries saved (admittedly not all are unique, or even website passwords; maybe the actual number is about 95). Do you want to go visit over 100 websites and come up with a new password for every one of them? How long will it take you to even remember all 100 websites where you have an account? What about websites you visit only once a year like tax preparation software? Can you remember all your usernames? What happens if on website number 99, you come across a draconian password restriction that means your base password for the first 99 websites won't work? Do you change you base password again and start over? IS there a base password that works for all sites? Remember, some sites require special characters, some prohibit them. Some have a minimum of 12 characters, some have a maximum of 10.

For a time I used a set of 4-5 re-used passwords across all my sites, with a different password for every "security tier", i.e. I had my banking password, my social media password, my throwaway site password, etc. and another fully unique password for my email since that could be used to reset passwords on any of the others. One day I learned of a breach at a site I was using and went through this process. The second time this happened, when I ran into the conflicting draconian password requirements screwing up my shared password YET AGAIN, was the day I decided to use a password manager.

I think AviD's rule of usability clearly applies here: "security at the expense of usability comes at the expense of security."

TL;DR—use a password manager. There are many secure options out there.

Answer 6

There would be some that would argue: "There is no entropy!!! That is insecure!!!" So here is a starting point. In security management/learning realms, passwords (authentication mechanisms) are broken down into:

• Something you know (password)
• Something you have (key fob/RSA key)
• Something you are (biometrics, fingerprint scanner)

Under the same premises as above you can create something complex, yet easy to memorize. There will be the naysayers: "Someone can figure that out easily" and I will disagree with them wholeheartedly as there can be too many variables to go by. So here goes your example:

• Something you know: mypassword
• Something you have: Twitter
• Something you are: Latin

You KNOW you have mypassword, let's say you are logging into Twitter, and let's say you are latin. You could agree on the char substitution here: a = @, e = 3, i = !, and so forth. Let's get a separator now #...

myp@ssw0rd#Tw!tter#L@t!n

How about say Gmail? = myp@ssw0rd#GM@!l#L@tin How about say your bank? = myp@ssw0rd#myB@nk#L@tin

Now... There is going to be someone who will respond with something snarky: "Yea but it if someone uses a keystroke logger and sees the structure..." If someone is monitoring your keystrokes you have bigger issues to worry about. Now, there will be someone who will say something snarky like: "Well if someone cracks ONE password, the entire structure will come crumbling down." This is NOT the case. While one can TRY to break other passwords using that structure (something you have something you are, and something you know), it still becomes a guessing game. "Well they're going to Citibank... Let me try myp@ssw0rd#C!t!b@nk#L@tin... Didn't work..." They would still go through too many iterations of a perceived structure. You could mix things up: "Know, Are, Have" for finance, "Are, Have, Know" for business, "Have, know, are" for personal. There are many methods to pull this off.

Downside? Good luck when you run into sites that don't allow for complex passwords. There is nothing wrong with password managers. I use Lastpass, and it works well. My master password is 34 characters, and I switch it up every 120 days, and never forget it.