¿Es “doble hashing” una contraseña menos segura que solo hashing una vez?

¿Es hashing una contraseña dos veces antes del almacenamiento más o menos seguro que simplemente hashing una vez?

De lo que estoy hablando es de hacer esto:

$hashed_password = hash(hash($plaintext_password)); 

en lugar de solo esto:

 $hashed_password = hash($plaintext_password); 

Si es menos seguro, ¿puede proporcionar una buena explicación (o un enlace a uno)?

Además, ¿la función de hash utilizada marca la diferencia? ¿Hay alguna diferencia si mezclas md5 y sha1 (por ejemplo) en lugar de repetir la misma función hash?

Nota 1: Cuando digo “doble hashing”, estoy hablando de hash una contraseña dos veces en un bash de hacerlo más oscurecido. No estoy hablando de la técnica para resolver colisiones .

Nota 2: Sé que necesito agregar una sal aleatoria para asegurarla realmente. La pregunta es si hashing dos veces con el mismo algoritmo ayuda o lastima el hash.

Hashing una contraseña una vez es inseguro

No, los hashes múltiples no son menos seguros; son una parte esencial del uso seguro de contraseñas.

Al iterar el hash aumenta el tiempo que le toma a un atacante probar cada contraseña en su lista de candidatos. Puede boost fácilmente el tiempo que lleva atacar una contraseña de horas a años.

La iteración simple no es suficiente

Simplemente encadenar la salida de hash a la entrada no es suficiente para la seguridad. La iteración debe tener lugar en el contexto de un algoritmo que preserve la entropía de la contraseña. Afortunadamente, hay varios algoritmos publicados que han tenido suficiente escrutinio para dar confianza en su diseño.

Un buen algoritmo de derivación de clave como PBKDF2 inyecta la contraseña en cada ronda de hash, mitigando las preocupaciones sobre las colisiones en la salida hash. PBKDF2 se puede usar para autenticar contraseñas tal como está. Bcrypt sigue la derivación de la clave con un paso de encriptación; De esta forma, si se descubre una forma rápida de revertir la derivación de la clave, el atacante aún tiene que completar un ataque conocido de texto plano.

Cómo romper una contraseña

Las contraseñas almacenadas necesitan protección contra un ataque fuera de línea. Si las contraseñas no están saladas, se pueden romper con un ataque de diccionario precalculado (por ejemplo, usando una tabla Rainbow). De lo contrario, el atacante debe dedicar tiempo a calcular un hash para cada contraseña y ver si coincide con el hash almacenado.

Todas las contraseñas no son igualmente probables. Los atacantes pueden buscar exhaustivamente todas las contraseñas cortas, pero saben que sus posibilidades de éxito con la fuerza bruta disminuyen drásticamente con cada personaje adicional. En su lugar, usan una lista ordenada de las contraseñas más probables. Comienzan con “password123” y progresan a contraseñas usadas con menos frecuencia.

Digamos que una lista de atacantes es larga, con 10 mil millones de candidatos; supongamos también que un sistema de escritorio puede calcular 1 millón de hashes por segundo. El atacante puede probar que toda su lista es menos de tres horas si solo se usa una iteración. Pero si solo se usan 2000 iteraciones, ese tiempo se extiende a casi 8 meses. Para vencer a un atacante más sofisticado, uno capaz de descargar un progtwig que pueda aprovechar el poder de su GPU, por ejemplo, necesita más iteraciones.

¿Cuánto es suficiente?

La cantidad de iteraciones que se deben usar es una compensación entre la seguridad y la experiencia del usuario. El hardware especializado que pueden usar los atacantes es barato, pero aún puede realizar cientos de millones de iteraciones por segundo. El rendimiento del sistema del atacante determina cuánto tiempo lleva romper una contraseña dado un número de iteraciones. Pero es probable que su aplicación no use este hardware especializado. Cuántas iteraciones puede realizar sin agravar a los usuarios depende de su sistema.

Probablemente pueda dejar que los usuarios esperen aproximadamente ¾ segundos más o menos durante la autenticación. Perfile su plataforma objective y use tantas iteraciones como pueda. Las plataformas que he probado (un usuario en un dispositivo móvil o muchos usuarios en una plataforma de servidor) pueden soportar PBKDF2 con entre 60,000 y 120,000 iteraciones, o bcrypt con un factor de costo de 12 o 13.

Más antecedentes

Lea PKCS # 5 para obtener información autorizada sobre el papel de la sal y las iteraciones en hash. A pesar de que PBKDF2 fue creado para generar claves de cifrado a partir de contraseñas, funciona bien como un hash unidireccional para la autenticación de contraseñas. Cada iteración de bcrypt es más costosa que un hash SHA-2, por lo que puede usar menos iteraciones, pero la idea es la misma. Bcrypt también va un paso más allá de la mayoría de las soluciones basadas en PBKDF2 mediante el uso de la clave derivada para encriptar un texto simple bien conocido. El texto de cifrado resultante se almacena como “hash”, junto con algunos metadatos. Sin embargo, nada le impide hacer lo mismo con PBKDF2.

Aquí hay otras respuestas que he escrito sobre este tema:

  • Contraseñas hash
  • Contraseñas hash
  • sal
  • Escondiendo sal
  • PBKDF2 contra bcrypt
  • Bcrypt

Para aquellos que dicen que es seguro, son correctos en general . El hashing “doble” (o la expansión lógica de eso, iterar una función hash) es absolutamente seguro si se hace bien , para una preocupación específica.

Para aquellos que dicen que es inseguro, tienen razón en este caso . El código que se publica en la pregunta es inseguro. Hablemos de por qué:

 $hashed_password1 = md5( md5( plaintext_password ) ); $hashed_password2 = md5( plaintext_password ); 

Hay dos propiedades fundamentales de una función hash que nos preocupan:

  1. Resistencia antes de la imagen : dado un hash $h , debería ser difícil encontrar un mensaje $m tal que $h === hash($m)

  2. Segunda resistencia antes de la imagen : dado un mensaje $m1 , debería ser difícil encontrar un mensaje diferente $m2 tal que hash($m1) === hash($m2)

  3. Resistencia a la colisión : debería ser difícil encontrar un par de mensajes ($m1, $m2) tales como hash($m1) === hash($m2) (tenga en cuenta que esto es similar a la resistencia a la segunda imagen previa, pero diferente en eso aquí el atacante tiene control sobre ambos mensajes) …

Para el almacenamiento de contraseñas , lo único que realmente nos importa es la resistencia a la imagen previa . Los otros dos serían discutibles, porque $m1 es la contraseña del usuario que intentamos mantener a salvo. Entonces, si el atacante ya lo tiene, el hash no tiene nada que proteger …

RENUNCIA

Todo lo que sigue se basa en la premisa de que lo único que nos importa es la resistencia a la imagen previa . Las otras dos propiedades fundamentales de las funciones hash pueden no (y normalmente no) sostenerse de la misma manera. Por lo tanto, las conclusiones de esta publicación solo son aplicables cuando se usan funciones hash para el almacenamiento de contraseñas. No son aplicables en general …

Empecemos

Por el bien de esta discusión, inventemos nuestra propia función hash:

 function ourHash($input) { $result = 0; for ($i = 0; $i < strlen($input); $i++) { $result += ord($input[$i]); } return (string) ($result % 256); } 

Ahora debería ser bastante obvio lo que hace esta función hash. Suma los valores ASCII de cada carácter de entrada, y luego toma el módulo de ese resultado con 256.

Así que vamos a probarlo:

 var_dump( ourHash('abc'), // string(2) "38" ourHash('def'), // string(2) "47" ourHash('hij'), // string(2) "59" ourHash('klm') // string(2) "68" ); 

Ahora, veamos qué sucede si lo ejecutamos algunas veces alrededor de una función:

 $tests = array( "abc", "def", "hij", "klm", ); foreach ($tests as $test) { $hash = $test; for ($i = 0; $i < 100; $i++) { $hash = ourHash($hash); } echo "Hashing $test => $hash\n"; } 

Que resultados:

 Hashing abc => 152 Hashing def => 152 Hashing hij => 155 Hashing klm => 155 

Hrm, wow. ¡Hemos generado colisiones! Intentemos ver por qué:

Aquí está la salida de hash una cadena de todas y cada salida hash posible:

 Hashing 0 => 48 Hashing 1 => 49 Hashing 2 => 50 Hashing 3 => 51 Hashing 4 => 52 Hashing 5 => 53 Hashing 6 => 54 Hashing 7 => 55 Hashing 8 => 56 Hashing 9 => 57 Hashing 10 => 97 Hashing 11 => 98 Hashing 12 => 99 Hashing 13 => 100 Hashing 14 => 101 Hashing 15 => 102 Hashing 16 => 103 Hashing 17 => 104 Hashing 18 => 105 Hashing 19 => 106 Hashing 20 => 98 Hashing 21 => 99 Hashing 22 => 100 Hashing 23 => 101 Hashing 24 => 102 Hashing 25 => 103 Hashing 26 => 104 Hashing 27 => 105 Hashing 28 => 106 Hashing 29 => 107 Hashing 30 => 99 Hashing 31 => 100 Hashing 32 => 101 Hashing 33 => 102 Hashing 34 => 103 Hashing 35 => 104 Hashing 36 => 105 Hashing 37 => 106 Hashing 38 => 107 Hashing 39 => 108 Hashing 40 => 100 Hashing 41 => 101 Hashing 42 => 102 Hashing 43 => 103 Hashing 44 => 104 Hashing 45 => 105 Hashing 46 => 106 Hashing 47 => 107 Hashing 48 => 108 Hashing 49 => 109 Hashing 50 => 101 Hashing 51 => 102 Hashing 52 => 103 Hashing 53 => 104 Hashing 54 => 105 Hashing 55 => 106 Hashing 56 => 107 Hashing 57 => 108 Hashing 58 => 109 Hashing 59 => 110 Hashing 60 => 102 Hashing 61 => 103 Hashing 62 => 104 Hashing 63 => 105 Hashing 64 => 106 Hashing 65 => 107 Hashing 66 => 108 Hashing 67 => 109 Hashing 68 => 110 Hashing 69 => 111 Hashing 70 => 103 Hashing 71 => 104 Hashing 72 => 105 Hashing 73 => 106 Hashing 74 => 107 Hashing 75 => 108 Hashing 76 => 109 Hashing 77 => 110 Hashing 78 => 111 Hashing 79 => 112 Hashing 80 => 104 Hashing 81 => 105 Hashing 82 => 106 Hashing 83 => 107 Hashing 84 => 108 Hashing 85 => 109 Hashing 86 => 110 Hashing 87 => 111 Hashing 88 => 112 Hashing 89 => 113 Hashing 90 => 105 Hashing 91 => 106 Hashing 92 => 107 Hashing 93 => 108 Hashing 94 => 109 Hashing 95 => 110 Hashing 96 => 111 Hashing 97 => 112 Hashing 98 => 113 Hashing 99 => 114 Hashing 100 => 145 Hashing 101 => 146 Hashing 102 => 147 Hashing 103 => 148 Hashing 104 => 149 Hashing 105 => 150 Hashing 106 => 151 Hashing 107 => 152 Hashing 108 => 153 Hashing 109 => 154 Hashing 110 => 146 Hashing 111 => 147 Hashing 112 => 148 Hashing 113 => 149 Hashing 114 => 150 Hashing 115 => 151 Hashing 116 => 152 Hashing 117 => 153 Hashing 118 => 154 Hashing 119 => 155 Hashing 120 => 147 Hashing 121 => 148 Hashing 122 => 149 Hashing 123 => 150 Hashing 124 => 151 Hashing 125 => 152 Hashing 126 => 153 Hashing 127 => 154 Hashing 128 => 155 Hashing 129 => 156 Hashing 130 => 148 Hashing 131 => 149 Hashing 132 => 150 Hashing 133 => 151 Hashing 134 => 152 Hashing 135 => 153 Hashing 136 => 154 Hashing 137 => 155 Hashing 138 => 156 Hashing 139 => 157 Hashing 140 => 149 Hashing 141 => 150 Hashing 142 => 151 Hashing 143 => 152 Hashing 144 => 153 Hashing 145 => 154 Hashing 146 => 155 Hashing 147 => 156 Hashing 148 => 157 Hashing 149 => 158 Hashing 150 => 150 Hashing 151 => 151 Hashing 152 => 152 Hashing 153 => 153 Hashing 154 => 154 Hashing 155 => 155 Hashing 156 => 156 Hashing 157 => 157 Hashing 158 => 158 Hashing 159 => 159 Hashing 160 => 151 Hashing 161 => 152 Hashing 162 => 153 Hashing 163 => 154 Hashing 164 => 155 Hashing 165 => 156 Hashing 166 => 157 Hashing 167 => 158 Hashing 168 => 159 Hashing 169 => 160 Hashing 170 => 152 Hashing 171 => 153 Hashing 172 => 154 Hashing 173 => 155 Hashing 174 => 156 Hashing 175 => 157 Hashing 176 => 158 Hashing 177 => 159 Hashing 178 => 160 Hashing 179 => 161 Hashing 180 => 153 Hashing 181 => 154 Hashing 182 => 155 Hashing 183 => 156 Hashing 184 => 157 Hashing 185 => 158 Hashing 186 => 159 Hashing 187 => 160 Hashing 188 => 161 Hashing 189 => 162 Hashing 190 => 154 Hashing 191 => 155 Hashing 192 => 156 Hashing 193 => 157 Hashing 194 => 158 Hashing 195 => 159 Hashing 196 => 160 Hashing 197 => 161 Hashing 198 => 162 Hashing 199 => 163 Hashing 200 => 146 Hashing 201 => 147 Hashing 202 => 148 Hashing 203 => 149 Hashing 204 => 150 Hashing 205 => 151 Hashing 206 => 152 Hashing 207 => 153 Hashing 208 => 154 Hashing 209 => 155 Hashing 210 => 147 Hashing 211 => 148 Hashing 212 => 149 Hashing 213 => 150 Hashing 214 => 151 Hashing 215 => 152 Hashing 216 => 153 Hashing 217 => 154 Hashing 218 => 155 Hashing 219 => 156 Hashing 220 => 148 Hashing 221 => 149 Hashing 222 => 150 Hashing 223 => 151 Hashing 224 => 152 Hashing 225 => 153 Hashing 226 => 154 Hashing 227 => 155 Hashing 228 => 156 Hashing 229 => 157 Hashing 230 => 149 Hashing 231 => 150 Hashing 232 => 151 Hashing 233 => 152 Hashing 234 => 153 Hashing 235 => 154 Hashing 236 => 155 Hashing 237 => 156 Hashing 238 => 157 Hashing 239 => 158 Hashing 240 => 150 Hashing 241 => 151 Hashing 242 => 152 Hashing 243 => 153 Hashing 244 => 154 Hashing 245 => 155 Hashing 246 => 156 Hashing 247 => 157 Hashing 248 => 158 Hashing 249 => 159 Hashing 250 => 151 Hashing 251 => 152 Hashing 252 => 153 Hashing 253 => 154 Hashing 254 => 155 Hashing 255 => 156 

Observe la tendencia hacia números más altos. Eso resulta ser nuestro obstáculo. Ejecutando el hash 4 veces ($ hash = ourHash ($ hash) `, para cada elemento) termina dándonos:

 Hashing 0 => 153 Hashing 1 => 154 Hashing 2 => 155 Hashing 3 => 156 Hashing 4 => 157 Hashing 5 => 158 Hashing 6 => 150 Hashing 7 => 151 Hashing 8 => 152 Hashing 9 => 153 Hashing 10 => 157 Hashing 11 => 158 Hashing 12 => 150 Hashing 13 => 154 Hashing 14 => 155 Hashing 15 => 156 Hashing 16 => 157 Hashing 17 => 158 Hashing 18 => 150 Hashing 19 => 151 Hashing 20 => 158 Hashing 21 => 150 Hashing 22 => 154 Hashing 23 => 155 Hashing 24 => 156 Hashing 25 => 157 Hashing 26 => 158 Hashing 27 => 150 Hashing 28 => 151 Hashing 29 => 152 Hashing 30 => 150 Hashing 31 => 154 Hashing 32 => 155 Hashing 33 => 156 Hashing 34 => 157 Hashing 35 => 158 Hashing 36 => 150 Hashing 37 => 151 Hashing 38 => 152 Hashing 39 => 153 Hashing 40 => 154 Hashing 41 => 155 Hashing 42 => 156 Hashing 43 => 157 Hashing 44 => 158 Hashing 45 => 150 Hashing 46 => 151 Hashing 47 => 152 Hashing 48 => 153 Hashing 49 => 154 Hashing 50 => 155 Hashing 51 => 156 Hashing 52 => 157 Hashing 53 => 158 Hashing 54 => 150 Hashing 55 => 151 Hashing 56 => 152 Hashing 57 => 153 Hashing 58 => 154 Hashing 59 => 155 Hashing 60 => 156 Hashing 61 => 157 Hashing 62 => 158 Hashing 63 => 150 Hashing 64 => 151 Hashing 65 => 152 Hashing 66 => 153 Hashing 67 => 154 Hashing 68 => 155 Hashing 69 => 156 Hashing 70 => 157 Hashing 71 => 158 Hashing 72 => 150 Hashing 73 => 151 Hashing 74 => 152 Hashing 75 => 153 Hashing 76 => 154 Hashing 77 => 155 Hashing 78 => 156 Hashing 79 => 157 Hashing 80 => 158 Hashing 81 => 150 Hashing 82 => 151 Hashing 83 => 152 Hashing 84 => 153 Hashing 85 => 154 Hashing 86 => 155 Hashing 87 => 156 Hashing 88 => 157 Hashing 89 => 158 Hashing 90 => 150 Hashing 91 => 151 Hashing 92 => 152 Hashing 93 => 153 Hashing 94 => 154 Hashing 95 => 155 Hashing 96 => 156 Hashing 97 => 157 Hashing 98 => 158 Hashing 99 => 150 Hashing 100 => 154 Hashing 101 => 155 Hashing 102 => 156 Hashing 103 => 157 Hashing 104 => 158 Hashing 105 => 150 Hashing 106 => 151 Hashing 107 => 152 Hashing 108 => 153 Hashing 109 => 154 Hashing 110 => 155 Hashing 111 => 156 Hashing 112 => 157 Hashing 113 => 158 Hashing 114 => 150 Hashing 115 => 151 Hashing 116 => 152 Hashing 117 => 153 Hashing 118 => 154 Hashing 119 => 155 Hashing 120 => 156 Hashing 121 => 157 Hashing 122 => 158 Hashing 123 => 150 Hashing 124 => 151 Hashing 125 => 152 Hashing 126 => 153 Hashing 127 => 154 Hashing 128 => 155 Hashing 129 => 156 Hashing 130 => 157 Hashing 131 => 158 Hashing 132 => 150 Hashing 133 => 151 Hashing 134 => 152 Hashing 135 => 153 Hashing 136 => 154 Hashing 137 => 155 Hashing 138 => 156 Hashing 139 => 157 Hashing 140 => 158 Hashing 141 => 150 Hashing 142 => 151 Hashing 143 => 152 Hashing 144 => 153 Hashing 145 => 154 Hashing 146 => 155 Hashing 147 => 156 Hashing 148 => 157 Hashing 149 => 158 Hashing 150 => 150 Hashing 151 => 151 Hashing 152 => 152 Hashing 153 => 153 Hashing 154 => 154 Hashing 155 => 155 Hashing 156 => 156 Hashing 157 => 157 Hashing 158 => 158 Hashing 159 => 159 Hashing 160 => 151 Hashing 161 => 152 Hashing 162 => 153 Hashing 163 => 154 Hashing 164 => 155 Hashing 165 => 156 Hashing 166 => 157 Hashing 167 => 158 Hashing 168 => 159 Hashing 169 => 151 Hashing 170 => 152 Hashing 171 => 153 Hashing 172 => 154 Hashing 173 => 155 Hashing 174 => 156 Hashing 175 => 157 Hashing 176 => 158 Hashing 177 => 159 Hashing 178 => 151 Hashing 179 => 152 Hashing 180 => 153 Hashing 181 => 154 Hashing 182 => 155 Hashing 183 => 156 Hashing 184 => 157 Hashing 185 => 158 Hashing 186 => 159 Hashing 187 => 151 Hashing 188 => 152 Hashing 189 => 153 Hashing 190 => 154 Hashing 191 => 155 Hashing 192 => 156 Hashing 193 => 157 Hashing 194 => 158 Hashing 195 => 159 Hashing 196 => 151 Hashing 197 => 152 Hashing 198 => 153 Hashing 199 => 154 Hashing 200 => 155 Hashing 201 => 156 Hashing 202 => 157 Hashing 203 => 158 Hashing 204 => 150 Hashing 205 => 151 Hashing 206 => 152 Hashing 207 => 153 Hashing 208 => 154 Hashing 209 => 155 Hashing 210 => 156 Hashing 211 => 157 Hashing 212 => 158 Hashing 213 => 150 Hashing 214 => 151 Hashing 215 => 152 Hashing 216 => 153 Hashing 217 => 154 Hashing 218 => 155 Hashing 219 => 156 Hashing 220 => 157 Hashing 221 => 158 Hashing 222 => 150 Hashing 223 => 151 Hashing 224 => 152 Hashing 225 => 153 Hashing 226 => 154 Hashing 227 => 155 Hashing 228 => 156 Hashing 229 => 157 Hashing 230 => 158 Hashing 231 => 150 Hashing 232 => 151 Hashing 233 => 152 Hashing 234 => 153 Hashing 235 => 154 Hashing 236 => 155 Hashing 237 => 156 Hashing 238 => 157 Hashing 239 => 158 Hashing 240 => 150 Hashing 241 => 151 Hashing 242 => 152 Hashing 243 => 153 Hashing 244 => 154 Hashing 245 => 155 Hashing 246 => 156 Hashing 247 => 157 Hashing 248 => 158 Hashing 249 => 159 Hashing 250 => 151 Hashing 251 => 152 Hashing 252 => 153 Hashing 253 => 154 Hashing 254 => 155 Hashing 255 => 156 

Nos hemos reducido a 8 valores ... Eso es malo ... Nuestra función original mapeó S(∞) en S(256) . Es decir, hemos creado una $input asignación de función de Surjective a $output .

Como tenemos una función de Surjective, no tenemos ninguna garantía de que el mapeo de cualquier subconjunto de la entrada no tenga colisiones (de hecho, en la práctica lo harán).

¡Eso es lo que pasó aquí! Nuestra función era mala, pero no funcionó así (por eso funcionó tan rápido y completamente).

Lo mismo ocurre con MD5 . Mapea S(∞) en S(2^128) . Dado que no hay garantía de que ejecutar MD5(S(output)) será Inyectivo , lo que significa que no tendrá colisiones.

Sección TL / DR

Por lo tanto, dado que alimentar la salida de nuevo a md5 directamente puede generar colisiones, cada iteración boostá las posibilidades de colisiones. Sin embargo, este es un aumento lineal, lo que significa que, si bien el conjunto resultante de 2^128 se reduce, no se reduce significativamente lo suficientemente rápido como para ser un error crítico.

Asi que,

 $output = md5($input); // 2^128 possibilities $output = md5($output); // < 2^128 possibilities $output = md5($output); // < 2^128 possibilities $output = md5($output); // < 2^128 possibilities $output = md5($output); // < 2^128 possibilities 

Cuantas más veces itere, mayor será la reducción.

La solución

Afortunadamente para nosotros, hay una manera trivial de solucionar esto: retroalimenta algo en las iteraciones posteriores:

 $output = md5($input); // 2^128 possibilities $output = md5($input . $output); // 2^128 possibilities $output = md5($input . $output); // 2^128 possibilities $output = md5($input . $output); // 2^128 possibilities $output = md5($input . $output); // 2^128 possibilities 

Tenga en cuenta que las iteraciones adicionales no son 2 ^ 128 para cada valor individual para $input . Lo que significa que podemos generar $input valores de $input que todavía colisionan en la línea (y por lo tanto se estabilizarán o resonarán a menos de 2^128 salidas posibles). Pero el caso general para $input sigue siendo tan fuerte como lo fue para una sola ronda.

Espera, ¿verdad? Probemos esto con nuestra función ourHash() . Cambiando a $hash = ourHash($input . $hash); , para 100 iteraciones:

 Hashing 0 => 201 Hashing 1 => 212 Hashing 2 => 199 Hashing 3 => 201 Hashing 4 => 203 Hashing 5 => 205 Hashing 6 => 207 Hashing 7 => 209 Hashing 8 => 211 Hashing 9 => 204 Hashing 10 => 251 Hashing 11 => 147 Hashing 12 => 251 Hashing 13 => 148 Hashing 14 => 253 Hashing 15 => 0 Hashing 16 => 1 Hashing 17 => 2 Hashing 18 => 161 Hashing 19 => 163 Hashing 20 => 147 Hashing 21 => 251 Hashing 22 => 148 Hashing 23 => 253 Hashing 24 => 0 Hashing 25 => 1 Hashing 26 => 2 Hashing 27 => 161 Hashing 28 => 163 Hashing 29 => 8 Hashing 30 => 251 Hashing 31 => 148 Hashing 32 => 253 Hashing 33 => 0 Hashing 34 => 1 Hashing 35 => 2 Hashing 36 => 161 Hashing 37 => 163 Hashing 38 => 8 Hashing 39 => 4 Hashing 40 => 148 Hashing 41 => 253 Hashing 42 => 0 Hashing 43 => 1 Hashing 44 => 2 Hashing 45 => 161 Hashing 46 => 163 Hashing 47 => 8 Hashing 48 => 4 Hashing 49 => 9 Hashing 50 => 253 Hashing 51 => 0 Hashing 52 => 1 Hashing 53 => 2 Hashing 54 => 161 Hashing 55 => 163 Hashing 56 => 8 Hashing 57 => 4 Hashing 58 => 9 Hashing 59 => 11 Hashing 60 => 0 Hashing 61 => 1 Hashing 62 => 2 Hashing 63 => 161 Hashing 64 => 163 Hashing 65 => 8 Hashing 66 => 4 Hashing 67 => 9 Hashing 68 => 11 Hashing 69 => 4 Hashing 70 => 1 Hashing 71 => 2 Hashing 72 => 161 Hashing 73 => 163 Hashing 74 => 8 Hashing 75 => 4 Hashing 76 => 9 Hashing 77 => 11 Hashing 78 => 4 Hashing 79 => 3 Hashing 80 => 2 Hashing 81 => 161 Hashing 82 => 163 Hashing 83 => 8 Hashing 84 => 4 Hashing 85 => 9 Hashing 86 => 11 Hashing 87 => 4 Hashing 88 => 3 Hashing 89 => 17 Hashing 90 => 161 Hashing 91 => 163 Hashing 92 => 8 Hashing 93 => 4 Hashing 94 => 9 Hashing 95 => 11 Hashing 96 => 4 Hashing 97 => 3 Hashing 98 => 17 Hashing 99 => 13 Hashing 100 => 246 Hashing 101 => 248 Hashing 102 => 49 Hashing 103 => 44 Hashing 104 => 255 Hashing 105 => 198 Hashing 106 => 43 Hashing 107 => 51 Hashing 108 => 202 Hashing 109 => 2 Hashing 110 => 248 Hashing 111 => 49 Hashing 112 => 44 Hashing 113 => 255 Hashing 114 => 198 Hashing 115 => 43 Hashing 116 => 51 Hashing 117 => 202 Hashing 118 => 2 Hashing 119 => 51 Hashing 120 => 49 Hashing 121 => 44 Hashing 122 => 255 Hashing 123 => 198 Hashing 124 => 43 Hashing 125 => 51 Hashing 126 => 202 Hashing 127 => 2 Hashing 128 => 51 Hashing 129 => 53 Hashing 130 => 44 Hashing 131 => 255 Hashing 132 => 198 Hashing 133 => 43 Hashing 134 => 51 Hashing 135 => 202 Hashing 136 => 2 Hashing 137 => 51 Hashing 138 => 53 Hashing 139 => 55 Hashing 140 => 255 Hashing 141 => 198 Hashing 142 => 43 Hashing 143 => 51 Hashing 144 => 202 Hashing 145 => 2 Hashing 146 => 51 Hashing 147 => 53 Hashing 148 => 55 Hashing 149 => 58 Hashing 150 => 198 Hashing 151 => 43 Hashing 152 => 51 Hashing 153 => 202 Hashing 154 => 2 Hashing 155 => 51 Hashing 156 => 53 Hashing 157 => 55 Hashing 158 => 58 Hashing 159 => 0 Hashing 160 => 43 Hashing 161 => 51 Hashing 162 => 202 Hashing 163 => 2 Hashing 164 => 51 Hashing 165 => 53 Hashing 166 => 55 Hashing 167 => 58 Hashing 168 => 0 Hashing 169 => 209 Hashing 170 => 51 Hashing 171 => 202 Hashing 172 => 2 Hashing 173 => 51 Hashing 174 => 53 Hashing 175 => 55 Hashing 176 => 58 Hashing 177 => 0 Hashing 178 => 209 Hashing 179 => 216 Hashing 180 => 202 Hashing 181 => 2 Hashing 182 => 51 Hashing 183 => 53 Hashing 184 => 55 Hashing 185 => 58 Hashing 186 => 0 Hashing 187 => 209 Hashing 188 => 216 Hashing 189 => 219 Hashing 190 => 2 Hashing 191 => 51 Hashing 192 => 53 Hashing 193 => 55 Hashing 194 => 58 Hashing 195 => 0 Hashing 196 => 209 Hashing 197 => 216 Hashing 198 => 219 Hashing 199 => 220 Hashing 200 => 248 Hashing 201 => 49 Hashing 202 => 44 Hashing 203 => 255 Hashing 204 => 198 Hashing 205 => 43 Hashing 206 => 51 Hashing 207 => 202 Hashing 208 => 2 Hashing 209 => 51 Hashing 210 => 49 Hashing 211 => 44 Hashing 212 => 255 Hashing 213 => 198 Hashing 214 => 43 Hashing 215 => 51 Hashing 216 => 202 Hashing 217 => 2 Hashing 218 => 51 Hashing 219 => 53 Hashing 220 => 44 Hashing 221 => 255 Hashing 222 => 198 Hashing 223 => 43 Hashing 224 => 51 Hashing 225 => 202 Hashing 226 => 2 Hashing 227 => 51 Hashing 228 => 53 Hashing 229 => 55 Hashing 230 => 255 Hashing 231 => 198 Hashing 232 => 43 Hashing 233 => 51 Hashing 234 => 202 Hashing 235 => 2 Hashing 236 => 51 Hashing 237 => 53 Hashing 238 => 55 Hashing 239 => 58 Hashing 240 => 198 Hashing 241 => 43 Hashing 242 => 51 Hashing 243 => 202 Hashing 244 => 2 Hashing 245 => 51 Hashing 246 => 53 Hashing 247 => 55 Hashing 248 => 58 Hashing 249 => 0 Hashing 250 => 43 Hashing 251 => 51 Hashing 252 => 202 Hashing 253 => 2 Hashing 254 => 51 Hashing 255 => 53 

Todavía hay un patrón aproximado allí, pero tenga en cuenta que no es más un patrón que nuestra función subyacente (que ya era bastante débil).

Sin embargo, tenga en cuenta que 0 y 3 convirtieron en colisiones, a pesar de que no estaban en la única carrera. Esa es una aplicación de lo que dije antes (que la resistencia a la colisión permanece igual para el conjunto de todas las entradas, pero las rutas de colisión específicas pueden abrirse debido a fallas en el algoritmo subyacente).

Sección TL / DR

Al retroalimentar la entrada en cada iteración, efectivamente rompemos cualquier colisión que pueda haber ocurrido en la iteración anterior.

Por lo tanto, md5($input . md5($input)); debe ser (en teoría al menos) tan fuerte como md5($input) .

Es esto importante?

Sí. Esta es una de las razones por las que PBKDF2 reemplazó PBKDF1 en RFC 2898 . Considere los bucles internos de los dos ::

PBKDF1:

 T_1 = Hash (P || S) , T_2 = Hash (T_1) , ... T_c = Hash (T_{c-1}) 

Donde c es el recuento de iteraciones, P es la contraseña y S es la sal

PBKDF2:

 U_1 = PRF (P, S || INT (i)) , U_2 = PRF (P, U_1) , ... U_c = PRF (P, U_{c-1}) 

Donde PRF es realmente solo un HMAC. Pero para nuestros propósitos aquí, digamos que PRF(P, S) = Hash(P || S) (es decir, el PRF de 2 entradas es el mismo, en términos generales, como hash con los dos concatenados). No es mucho, pero para nuestros propósitos sí lo es.

Por lo tanto, PBKDF2 mantiene la resistencia a la colisión de la función Hash subyacente, donde PBKDF1 no lo hace.

Atar todo junto:

Conocemos formas seguras de iterar un hash. De hecho:

 $hash = $input; $i = 10000; do { $hash = hash($input . $hash); } while ($i-- > 0); 

Por lo general es seguro.

Ahora, para ver por qué querríamos usarlo, analicemos el movimiento de entropía.

Un hash toma el conjunto infinito: S(∞) y produce un conjunto S(n) más pequeño y de tamaño uniforme. La siguiente iteración (suponiendo que la entrada se devuelve) mapea S(∞) en S(n) nuevo:

 S(∞) -> S(n) S(∞) -> S(n) S(∞) -> S(n) S(∞) -> S(n) S(∞) -> S(n) S(∞) -> S(n) 

Tenga en cuenta que el resultado final tiene exactamente la misma cantidad de entropía que el primero . La iteración no "lo hará más oscurecido". La entropía es idéntica. No existe una fuente mágica de impredecibilidad (es una función pseudoaleatoria, no una función aleatoria).

Sin embargo, hay una ganancia para iterar. Hace que el proceso de hashing sea artificialmente más lento. Y es por eso que iterar puede ser una buena idea. De hecho, es el principio básico de la mayoría de los algoritmos de hash de contraseñas modernos (el hecho de que hacer algo una y otra vez lo hace más lento).

Lento es bueno, porque está combatiendo la amenaza de seguridad primaria: el forzamiento bruto. Cuanto más lento hagamos nuestro algoritmo hash, los atacantes más duros tendrán que trabajar para atacar los hash de contraseñas que nos han robado. ¡Y eso es algo bueno!

Sí, volver a mezclar reduce el espacio de búsqueda, pero no, no importa; la reducción efectiva es insignificante.

Volver a mezclar aumenta el tiempo que lleva la fuerza bruta, pero hacerlo solo dos veces tampoco es óptimo.

Lo que realmente quiere es codificar la contraseña con PBKDF2 , un método comprobado para usar un hash seguro con sal e iteraciones. Mira esta respuesta SO .

EDIT : casi lo olvido – ¡NO USE MD5! Utilice un hash criptográfico moderno como la familia SHA-2 (SHA-256, SHA-384 y SHA-512).

Sí, reduce la cantidad de posibles cadenas que coinciden con la cadena.

Como ya has mencionado, los hashes salados son mucho mejores.

Un artículo aquí: http://websecurity.ro/blog/2007/11/02/md5md5-vs-md5/ , intenta una prueba de por qué es equivalente, pero no estoy seguro con la lógica. En parte, suponen que no hay software disponible para analizar md5 (md5 (texto)), pero obviamente es bastante trivial producir las tablas del arco iris.

I’m still sticking with my answer that there are smaller number of md5(md5(text)) type hashes than md5(text) hashes, increasing the chance of collision (even if still to an unlikely probability) and reducing the search space.

I just look at this from a practical standpoint. What is the hacker after? Why, the combination of characters that, when put through the hash function, generates the desired hash.

You are only saving the last hash, therefore, the hacker only has to bruteforce one hash. Assuming you have roughly the same odds of stumbling across the desired hash with each bruteforce step, the number of hashes is irrelevant. You could do a million hash iterations, and it would not increase or reduce security one bit, since at the end of the line there’s still only one hash to break, and the odds of breaking it are the same as any hash.

Maybe the previous posters think that the input is relevant; no es. As long as whatever you put into the hash function generates the desired hash, it will get you through, correct input or incorrect input.

Now, rainbow tables are another story. Since a rainbow table only carries raw passwords, hashing twice may be a good security measure, since a rainbow table that contains every hash of every hash would be too large.

Of course, I’m only considering the example the OP gave, where it’s just a plain-text password being hashed. If you include the username or a salt in the hash, it’s a different story; hashing twice is entirely unnecessary, since the rainbow table would already be too large to be practical and contain the right hash.

Anyway, not a security expert here, but that’s just what I’ve figured from my experience.

Personally I wouldn’t bother with multiple hashses, but I’d make sure to also hash the UserName (or another User ID field) as well as the password so two users with the same password won’t end up with the same hash. Also I’d probably throw some other constant string into the input string too for good measure.

 $hashed_password = md5( "xxx" + "|" + user_name + "|" + plaintext_password); 

Most answers are by people without a background in cryptography or security. And they are wrong. Use a salt, if possible unique per record. MD5/SHA/etc are too fast, the opposite of what you want. PBKDF2 and bcrypt are slower (wich is good) but can be defeated with ASICs/FPGA/GPUs (very afordable nowadays). So a memory-hard algorithm is needed: enter scrypt .

Here’s a layman explanation on salts and speed (but not about memory-hard algorithms).

In general, it provides no additional security to double hash or double encrypt something. If you can break the hash once, you can break it again. It usually doesn’t hurt security to do this, though.

In your example of using MD5, as you probably know there are some collision issues. “Double Hashing” doesn’t really help protect against this, since the same collisions will still result in the same first hash, which you can then MD5 again to get the second hash.

This does protect against dictionary attacks, like those “reverse MD5-databases”, but so does salting.

On a tangent, Double encrypting something doesn’t provide any additional security because all it does is result in a different key which is a combination of the two keys actually used. So the effort to find the “key” is not doubled because two keys do not actually need to be found. This isn’t true for hashing, because the result of the hash is not usually the same length as the original input.

From what I’ve read, it may actually be recommended to re-hash the password hundreds or thousands of times.

The idea is that if you can make it take more time to encode the password, it’s more work for an attacker to run through many guesses to crack the password. That seems to be the advantage to re-hashing — not that it’s more cryptographically secure, but it simply takes longer to generate a dictionary attack.

Of course computers get faster all the time, so this advantage diminishes over time (or requires you to increase the iterations).

As several responses in this article suggest, there are some cases where it may improves security and others where it definately hurts it. There is a better solution that will definately improve security. Instead of doubling the number of times you calculate the hash, double the size of your salt, or double the number of bits used int the hash, or do both! Instead of SHA-245, jump up to SHA-512.

Let us assume you use the hashing algorithm: compute rot13, take the first 10 characters. If you do that twice (or even 2000 times) it is possible to make a function that is faster, but which gives the same result (namely just take the first 10 chars).

Likewise it may be possible to make a faster function that gives the same output as a repeated hashing function. So your choice of hashing function is very important: as with the rot13 example it is not given that repeated hashing will improve security. If there is no research saying that the algorithm is designed for recursive use, then it is safer to assume that it will not give you added protection.

That said: For all but the simplest hashing functions it will most likely take cryptography experts to compute the faster functions, so if you are guarding against attackers that do not have access to cryptography experts it is probably safer in practice to use a repeated hashing function.

Double hashing makes sense to me only if I hash the password on the client, and then save the hash (with different salt) of that hash on the server.

That way even if someone hacked his way into the server (thereby ignoring the safety SSL provides), he still can’t get to the clear passwords.

Yes he will have the data required to breach into the system, but he wouldn’t be able to use that data to compromise outside accounts the user has. And people are known to use the same password for virtually anything.

The only way he could get to the clear passwords is installing a keygen on the client – and that’s not your problem anymore.

So in short:

  1. The first hashing on the client protects your users in a ‘server breach’ scenario.
  2. The second hashing on the server serves to protect your system if someone got a hold of your database backup, so he can’t use those passwords to connect to your services.

The concern about reducing the search space is mathematically correct, although the search space remains large enough that for all practical purposes (assuming you use salts), at 2^128. However, since we are talking about passwords, the number of possible 16-character strings (alphanumeric, caps matter, a few symbols thrown in) is roughly 2^98, according to my back-of-the-envelope calculations. So the perceived decrease in the search space is not really relevant.

Aside from that, there really is no difference, cryptographically speaking.

Although there is a crypto primitive called a “hash chain” — a technique that allows you to do some cool tricks, like disclosing a signature key after it’s been used, without sacrificing the integrity of the system — given minimal time synchronization, this allows you to cleanly sidestep the problem of initial key distribution. Basically, you precompute a large set of hashes of hashes – h(h(h(h….(h(k))…))) , use the nth value to sign, after a set interval, you send out the key, and sign it using key (n-1). The recepients can now verify that you sent all the previous messages, and no one can fake your signature since the time period for which it is valid has passed.

Re-hashing hundreds of thousands of times like Bill suggests is just a waste of your cpu.. use a longer key if you are concerned about people breaking 128 bits.

Double hashing is ugly because it’s more than likely an attacker has built a table to come up with most hashes. Better is to salt your hashes, and mix hashes together. There are also new schemas to “sign” hashes (basically salting), but in a more secure manner.

Sí.

Absolutely do not use multiple iterations of a conventional hash function, like md5(md5(md5(password))) . At best you will be getting a marginal increase in security (a scheme like this offers hardly any protection against a GPU attack; just pipeline it.) At worst, you’re reducing your hash space (and thus security) with every iteration you add. In security, it’s wise to assume the worst.

Do use a password has that’s been designed by a competent cryptographer to be an effective password hash, and resistant to both brute-force and time-space attacks. These include bcrypt, scrypt, and in some situations PBKDF2. The glibc SHA-256-based hash is also acceptable.

I’m going to go out on a limb and say it’s more secure in certain circumstances… don’t downvote me yet though!

From a mathematical / cryptographical point of view, it’s less secure, for reasons that I’m sure someone else will give you a clearer explanation of than I could.

However , there exist large databases of MD5 hashes, which are more likely to contain the “password” text than the MD5 of it. So by double-hashing you’re reducing the effectiveness of those databases.

Of course, if you use a salt then this advantage (disadvantage?) goes away.