# If the attacker knows part of the password but not the length, does that help him in any way?

The idea behind this is that if knowing part of the password and not the length is useless, "passwords" can be easily stored in cleartext or paper since you would just add your own n characters identifier and you're "safe".

Password on paper: `dad458t5sdADSdkarh`

Real password: `dad458t5sdADSdkarh PC`

Sub question: Does the position of your own identifier matter?

`dad458t5sdADSdkarh PC`

`dad458t5sPC dADSdkarh`

`PC dad458t5sdADSdkarh`

Sub question #2: Does the length of the personal identifier matter ? Meaning is even 1 character enough (with the baseline being long enough).

• This strikes me as just a variation on a salt. Sure it helps, but the secret part still needs to be long enough otherwise the attacker can still bruteforce it. – Steve Jul 24 '12 at 23:03
• yes, it makes it a lot easier for an attacker to brute force it, the "personal identifier" is now the password in effect, the rest is the salt. – ewanm89 Jul 24 '12 at 23:21

This would work as a personal scheme for keeping long passwords on paper - if you work out a system and apply it to your long passwords, but don't tell anyone else, it would be an effective form of security by obscurity. An attacker finding your password list might try the written password, then perhaps if he was very enterprising he might try variations on the written passwords, transpositions, subsequences and so on, but his chances of finding your exact transformation would be very low indeed.

However, an attacker might gain access to your password list and one or more of your actual passwords. The attacker could then observe the relationship between some passwords in your written list and the ones he knows in full, then know exactly how much space he had to bruteforce to get the real passwords from the written ones. In this case your effective password strength is reduced to the strength of your inserted string.

In practice many people use schemes like this for their most important and longest passwords, changing a few characters in an algorithmic but unguessable way then writing down the transformed password. This protects you very well against the common scenario of a house-burglary yielding a piece of paper with 'CitiBank: Login: xxx Password: yyy' written on it, but would be no use at all applied systematically, for all the usual reasons given against security by obscurity.

Knowing part of a password will surely make it easier, from a mathematical/theoretical perspective, even if you don't know the length. Basically, you can consider that whole segment of the password which is known to be a single character which the hacker knows.

E.g. consider a 10 digit password that accepts only 0-9 as input (for argument's sake). This password will have 10^10 possible answers. Whereas, if we know that one is a 1, there are 10*(9^10) (which is ten times nine raised to the ten), as far as I understand. Please correct me if I'm wrong.

Edit: I was wrong. There are actually s^l possible passwords, where s=the number of symbols and l=the length of the password. This is for a fixed length password, but for the sake of argument, I'll use it anyway (if it's variable length, then it's s^1+s^2+...+s^l where l is the max length). The reason that it's s^l is because for each position there are s different symbols that could be there. s*s*s...*s (that is, s times s, times s, times s ...., times s) l times are the total number of possible combinations for each length l.

Back to the example, if one of the characters are known, but you don't know the position, it's really just 10^9 different guesses, because there are effectively only 9 positions. Because you always know what's in the remaining one!

tl;dr this definitely makes it easier from a guessing perspective: if you know one chunk of the password, you remove a big chunk of the guesswork.

In practice, any of your options would be valid and secure enough.

Assuming:

• The random paper password is not available to a large number of people (i.e. on internet)
• The password scheme is not used by a large number of people or applications.
• That you aren't trying to secure high value contents.
• That your private text is random and 4 characters or more.

But to clarify the details:

• The variable / unknown location for the private text does increase the entropy / security / resistance to brute forcing.
• Brute forcing with a known prefix would be easy to brute force, especially if the private text is short (assuming that the attacker has the hash of the password).
• The attack type is very important: if the hashed passwords are leaked is different to remote password attempts.