Username, Password, Salting, Encrypting, Hash - Ho

问题:

This question already has answers here:

Closed 7 years ago.

Possible Duplicate:
Secure hash and salt for PHP passwords

Iv'e read a lot of posts both in stackoverflow and other websites talking about web security. Such as salting encrypting etc. And I'm kinda not getting it so a simple explanation would be really helpful.

So here's what I know so far. A user logs in types his username and password. The input then goes through a process. Lets say the username and password is combined like for example:

$username = (USERS USERNAME INPUT);
$password = (USERS PASSWORD INPUT);
$userinput = $username . $password;

Then we add some salt.

$salt1 = "13$13aVc!kd";
$salt2 = "4kr$!vlmeoc";

$salted = $salt1 . $userinput . $salt2;

Then we encrypt it.

$encrypted = encrypt($salted);

Then check with the database and if its right user gets logged in.

That's how it works right? But Iv'e read about brute force attack. It guesses the input values right? With the procedure above. Doesn't it shows that the attacker only needs to get the $userinput information correct to get in? He doesn't need to guess the long $encrypted string correct?

Note: Lets say in this situation there's no captcha, no number of tries limit, no lockout, nothing else but the one above.

Note: Be gentle I'm still learning.

回答1:

If you rule out captchas, try limits, lockouts, et cetera... then yes. You just have to brute force the plain text string.

However, that does take time - at the very least, it's bounded by the rate at which the server will respond to login requests. Even if the developer doesn't add any measures to prevent brute forcing, the server itself can only go through the encryption + verification process so quickly, and can only handle so many parallel requests.

That said, this is why it's important to

• As a user, use a strong, hard to brute-force password
• As a developer, have adequate measures to prevent brute-forcing of your login process

---

Hashing and salting passwords isn't to protect against people who brute force the natural login process (there are other things that protect against that). Instead, they're to protect against potential compromise of the password storage itself (e.g. someone dumping the contents of the database).

Both hashing and salting serve to decrease the speed at which someone with access to the stored passwords can retrieve the plain text string they'd need to be able to go through the natural login process (of your site or other sites, given that passwords are commonly shared between sites) without tripping anti-brute-forcing security measures.

回答2:

The idea of hashing and salting is more to prevent someone from taking user passwords if the database itself is compromised. If the passwords are stored as salted and hashed strings, the attacker can't just use them to access a user's account on another site.

回答3:

Password encryption is one-way encryption (or rather its suppose to be in a secure site). That is to say you take the password and you make a hash form it. bcrypt for example is the acceptable standard for doing this today.

If its one-way encryption a lot of people wonder how it can check a password. But you just hash the password the user submits and compare it to what hash you stored in the database. This way if your database is stolen an attacker has to work a lot harder.

The problem with just hashing a password is easily brute forced or rainbow tabled. You can google rainbow table to learn more on that. But essentially its a way to turn these hashes back into passwords.

Enter salting. Salting is adding random data essentially to every password. This trumps rainbow tables. Meaning a compromised database will mean brute force. Which if you're using a hash system like bcrypt takes a lot of time and effort for the attacked.

Having said all that. Best not to reinvent the wheel. Just use a known good authorization system if you can.

回答4:

See my answer here

And you should generate unique salts for each entry when you create the hash.

回答5:

One problem with brute force attacks is when you use a fast encryption like SHA1 or MD5. These functions are build to run the password through an algorithm fast. Instead you could use the Blowfish method, which im no expert on, but long story short it takes more calculation for a returned value, than SHA1 or MD5. This means it may take 5 years to brute force a password, hashed with Blowfish because of calculation time.

The next example is made with SHA1 and MD5, so it's vulnerable to bruteforce attacks, however the salt part should be OK to use:

$salt = md5(microtime().uniqueid());

This will output a unique 32 charecter salt, which you will put together with the password.

$passwod = $_POST['password'];
$hashed_password = sha1($password.$salt);

Now you have to store both the password and the salt in the database. And when you check the user inputtet password you get the salt, and hash the whole thing.

$temp_pass = $_POST['temp_pass'];
$salt = //from database;
$database_pass = //hashed pass from database;

$hashed_temp_pass = sha1($temp_pass.$salt);

if(hashed_temp_pass == $database_pass){
//Welcome user!
}
else{
//go away
}