Using functions to obfuscate the hash generation does not increase security. This is security by obscurity. The algorithm used to hash the data needs to be secure by itself.
I would not suggest to use other data as salt. For example if you use the username, you won't be able to change the values without rehashing the password.
I would use a dedicated salt value stored in the same database table.
Why? Because a lot of users use the same login credentials on different web services. And in case another service also uses the username as salt, the resulting hashed password might be the same!
Also an attacker may prepare a rainbow table with prehashed passwords using the username and other known data as salt. Using random data would easily prevent this with little programming effort.
Model de stocare criptată
SSL/SSH protejează traversarea datelor de la client la server, însă SSL/SSH nu protejează datele stocate în baza de date. SSL este un protocol de tranzit.
Odată ce atacatorul capătă acces la baza de date direct (evitând serverul web), informația stocată poate fi expusă sau abuzată, dacă ea nu este protejată de însăși baza de date. Criptarea datelor este o bună masură pentru a diminua acest risc, însă prea puține baze de date oferă acest tip de criptare.
Cea mai ușoară cale de a rezolva problema este de a crea propriul pachet de criptare, și apoi folosirea lui cu scripturile PHP. PHP vă poate ajuta în aceasta prin intermediul câtorva extensii, cum ar fi Mcrypt și Mhash, care acoperă o varietate largă de algoritmi de criptare. Scriptul criptează datele înainte de a fi inserate în baza de date, și le decriptează la extragerea acestora. Verificați documentația de rigoare pentru a studia mai multe despre modalitățile de operare ale criptării.
Hashing
În cazul datelor cu adevărat ascunse, dacă reprezentarea lor deschisă nu este necesară (de ex. nu vor fi afișate), ar trebui luată în considerare procedura de hashing. Cel mai cunoscut exemplu este stocarea hash-ului criptografic al unei parole în baza de date, în loc de stocarea parolei înseși.
În PHP 5.5 sau ulterior funcțiile de lucru cu parole oferă o metodă comodă de a transforma în hash date confidențiale și de a lucra mai departe cu aceste hash-uri. În PHP 5.3.7+ poate fi utilizată și biblioteca » password_compat.
password_hash() este utilizată pentru a transforma în hash un șir de caractere dat utilizând cel mai puternic algoritm disponibil la moment, și password_verify() verifică dacă o parolă dată se potrivește hash-ului stocat în baza de date.
Example #1 Transformarea parolei în hash
<?php
// storing password hash
$query = sprintf("INSERT INTO users(name,pwd) VALUES('%s','%s');",
pg_escape_string($username),
password_hash($password, PASSWORD_DEFAULT));
$result = pg_query($connection, $query);
// querying if user submitted the right password
$query = sprintf("SELECT pwd FROM users WHERE name='%s';",
pg_escape_string($username));
$row = pg_fetch_assoc(pg_query($connection, $query));
if ($row && password_verify($password, $row['pwd'])) {
echo 'Welcome, ' . htmlspecialchars($username) . '!';
} else {
echo 'Authentication failed for ' . htmlspecialchars($username) . '.';
}
?>
În versiuni mai vechi ale PHP aceasta poate fi obținut cu ajutorul funcției crypt().
Example #2 Transformarea parolei în hash utilizând crypt()
<?php
// storing password hash
// $random_chars retrieved e.g. using /dev/random
$query = sprintf("INSERT INTO users(name,pwd) VALUES('%s','%s');",
pg_escape_string($username),
pg_escape_string(crypt($password, '$2a$07$' . $random_chars . '$')));
$result = pg_query($connection, $query);
// querying if user submitted the right password
$query = sprintf("SELECT pwd FROM users WHERE name='%s';",
pg_escape_string($username));
$row = pg_fetch_assoc(pg_query($connection, $query));
if ($row && crypt($password, $row['pwd']) == $row['pwd']) {
echo 'Welcome, ' . htmlspecialchars($username) . '!';
} else {
echo 'Authentication failed for ' . htmlspecialchars($username) . '.';
}
?>
add a note
User Contributed Notes 5 notes
Reiner ¶
13 years ago
seigoryu at hotmail dot de ¶
11 years ago
I would strongly recommend using SHA-2 or better the new SHA-3 hash algorithm. MD5 is practically unusable, since there are very well working rainbow tables around the whole web. Almost the same for SHA-1. Of course you should never do a hash without salting!
somebody ¶
17 years ago
A better way to hash would be to use a separate salt for each user. Changing the salt upon each password update will ensure the hashes do not become stale.
about2mount at gmail dot com ¶
8 years ago
It's difficult to post scripts here for all to view on the subject of best security practices. But i would wish to point out that using a salt with a randomized and odd numbered long length salt value is do_able with two Php functions while retrieving and separating the salt when it comes out using simple math functions. But with everything we add we also have to think of the constant standardized login systems we stay behind with.
For one,,, adding and validating two to four passwords is not a bad idea. Also having no username or email going in. They can be stored after the user logs in after the validation process. It is possible to store the email on the first signup and only at that time. And if the user loses his passwords then validate by email only upon request within a contact form by a validated phone number stored in the database,, and then via their email account.
Fairydave at the location of dodo.com.au ¶
18 years ago
I think the best way to have a salt is not to randomly generate one or store a fixed one. Often more than just a password is saved, so use the extra data. Use things like the username, signup date, user ID, anything which is saved in the same table. That way you save on space used by not storing the salt for each user.
Although your method can always be broken if the hacker gets access to your database AND your file, you can make it more difficult. Use different user data depending on random things, the code doesn't need to make sense, just produce the same result each time. For example:
if ((asc(username character 5) > asc(username character 2))
{
if (month the account created > 6)
salt = ddmmyyyy of account created date
else
salt = yyyyddmm of account created date
}
else
{
if (day of account created > 15)
salt = user id * asc(username character 3)
else
salt = user id + asc(username character 1) + asc(username character 4)
}
This wont prevent them from reading passwords when they have both database and file access, but it will confuse them and slow them up without much more processing power required to create a random salt
