Otras personas han mostrado cómo se puede hacer, por lo que sobre los principios en general ...
Como ya se vinculado por NullUserException en los comentarios, no debe hacerlo simplemente agregando una sal estática a md5, si la seguridad es importante. Note however that you can store your salt as-is. Tanto la sal estática como md5 no se consideran enfoques muy seguros. Están bien si no importa mucho, pero si lo hace, deberías ir por el otro lado.
About static salt:
Un error común es el uso de la misma sal en cada hash. O la sal está codificada en el programa, o se genera aleatoriamente una vez. Esto es ineficaz porque si dos usuarios tienen la misma contraseña, todavía tendrán tienen el mismo hash. Un atacante aún puede usar un ataque de tabla de búsqueda inversa para ejecutar un ataque de diccionario en cada hash al mismo tiempo. Ellos solo tienen que aplicar la sal a cada contraseña adivinar antes de que ellos lo hagan . Si la sal está codificada de forma rígida en un producto popular, las tablas de búsqueda y las tablas de arcoiris se pueden construir para esa sal, para facilitar hashes de grieta generados por el producto.
Se debe generar un nuevo sal aleatorio cada vez que un usuario cree una cuenta o cambie su contraseña.
Si la sal es estática, un atacante solo puede generar una tabla de arcoíris para todas las posibilidades. Con una sal que es exclusiva de un usuario, no tiene sentido hacer eso.
md5 está diseñado para la velocidad computacional, por lo que es fundamentally not the way to go. Además, ya hay un montón de pre-created rainbow tables para él, y un montón de online cracking tools.
La página vinculada contiene PHP source code, también, como un ejemplo de cómo hacerlo correctamente.
<?php
/*
* Password hashing with PBKDF2.
* Author: havoc AT defuse.ca
* www: https://defuse.ca/php-pbkdf2.htm
*/
// These constants may be changed without breaking existing hashes.
define("PBKDF2_HASH_ALGORITHM", "sha256");
define("PBKDF2_ITERATIONS", 1000);
define("PBKDF2_SALT_BYTES", 24);
define("PBKDF2_HASH_BYTES", 24);
define("HASH_SECTIONS", 4);
define("HASH_ALGORITHM_INDEX", 0);
define("HASH_ITERATION_INDEX", 1);
define("HASH_SALT_INDEX", 2);
define("HASH_PBKDF2_INDEX", 3);
function create_hash($password)
{
// format: algorithm:iterations:salt:hash
$salt = base64_encode(mcrypt_create_iv(PBKDF2_SALT_BYTES, MCRYPT_DEV_URANDOM));
return PBKDF2_HASH_ALGORITHM . ":" . PBKDF2_ITERATIONS . ":" . $salt . ":" .
base64_encode(pbkdf2(
PBKDF2_HASH_ALGORITHM,
$password,
$salt,
PBKDF2_ITERATIONS,
PBKDF2_HASH_BYTES,
true
));
}
function validate_password($password, $good_hash)
{
$params = explode(":", $good_hash);
if(count($params) < HASH_SECTIONS)
return false;
$pbkdf2 = base64_decode($params[HASH_PBKDF2_INDEX]);
return slow_equals(
$pbkdf2,
pbkdf2(
$params[HASH_ALGORITHM_INDEX],
$password,
$params[HASH_SALT_INDEX],
(int)$params[HASH_ITERATION_INDEX],
strlen($pbkdf2),
true
)
);
}
// Compares two strings $a and $b in length-constant time.
function slow_equals($a, $b)
{
$diff = strlen($a)^strlen($b);
for($i = 0; $i < strlen($a) && $i < strlen($b); $i++)
{
$diff |= ord($a[$i])^ord($b[$i]);
}
return $diff === 0;
}
/*
* PBKDF2 key derivation function as defined by RSA's PKCS #5: https://www.ietf.org/rfc/rfc2898.txt
* $algorithm - The hash algorithm to use. Recommended: SHA256
* $password - The password.
* $salt - A salt that is unique to the password.
* $count - Iteration count. Higher is better, but slower. Recommended: At least 1000.
* $key_length - The length of the derived key in bytes.
* $raw_output - If true, the key is returned in raw binary format. Hex encoded otherwise.
* Returns: A $key_length-byte key derived from the password and salt.
*
* Test vectors can be found here: https://www.ietf.org/rfc/rfc6070.txt
*
* This implementation of PBKDF2 was originally created by https://defuse.ca
* With improvements by http://www.variations-of-shadow.com
*/
function pbkdf2($algorithm, $password, $salt, $count, $key_length, $raw_output = false)
{
$algorithm = strtolower($algorithm);
if(!in_array($algorithm, hash_algos(), true))
die('PBKDF2 ERROR: Invalid hash algorithm.');
if($count <= 0 || $key_length <= 0)
die('PBKDF2 ERROR: Invalid parameters.');
$hash_length = strlen(hash($algorithm, "", true));
$block_count = ceil($key_length/$hash_length);
$output = "";
for($i = 1; $i <= $block_count; $i++) {
// $i encoded as 4 bytes, big endian.
$last = $salt . pack("N", $i);
// first iteration
$last = $xorsum = hash_hmac($algorithm, $last, $password, true);
// perform the other $count - 1 iterations
for ($j = 1; $j < $count; $j++) {
$xorsum ^= ($last = hash_hmac($algorithm, $last, $password, true));
}
$output .= $xorsum;
}
if($raw_output)
return substr($output, 0, $key_length);
else
return bin2hex(substr($output, 0, $key_length));
}
Lea: [Lo que debe saber sobre la seguridad de las contraseñas] (http://crackstation.net/hashing-security.htm) – NullUserException
Gracias, lo estoy revisando – deerox
Me gustaría recomendar no usar md5, sino más bien un algoritmo de hash moderno. – Aleph