O hash duplo é uma senha menos segura do que apenas uma vez?

O hashing de uma senha duas vezes antes do armazenamento é mais ou menos seguro do que apenas uma vez?

O que eu estou falando é fazer isso:

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

em vez de apenas isso:

 $hashed_password = hash($plaintext_password); 

Se for menos seguro, você pode fornecer uma boa explicação (ou um link para um)?

Além disso, a function hash usada faz diferença? Faz alguma diferença se você misturar md5 e sha1 (por exemplo) em vez de repetir a mesma function hash?

Nota 1: Quando digo “hash duplo”, estou falando sobre hashing de uma senha duas vezes na tentativa de torná-lo mais obscuro. Não estou falando sobre a técnica para resolver colisões .

Nota 2: Eu sei que preciso adicionar um sal random para torná-lo seguro. A questão é se o hash duas vezes com o mesmo algoritmo ajuda ou prejudica o hash.

Hashing uma senha uma vez é inseguro

Não, vários hashes não são menos seguros; eles são uma parte essencial do uso seguro de senhas.

A iteração do hash aumenta o tempo necessário para que um invasor tente cada senha em sua lista de candidatos. Você pode facilmente aumentar o tempo que leva para atacar uma senha de horas para anos.

A iteração simples não é suficiente

Encadear simplesmente a saída hash para input não é suficiente para segurança. A iteração deve ocorrer no contexto de um algoritmo que preserve a entropia da senha. Felizmente, existem vários algoritmos publicados que tiveram escrutínio suficiente para dar confiança em seu design.

Um bom algoritmo de derivação de chaves como o PBKDF2 injeta a senha em cada rodada de hashing, mitigando as preocupações sobre colisões na saída do hash. O PBKDF2 pode ser usado para autenticação de senha como está. Bcrypt segue a derivação de chave com uma etapa de criptografia; Dessa forma, se uma maneira rápida de reverter a derivação de chave for descoberta, um invasor ainda terá que completar um ataque de texto sem formatação.

Como quebrar uma senha

As senhas armazenadas precisam de proteção contra um ataque offline. Se as senhas não forem salgadas, elas poderão ser quebradas com um ataque de dictionary pré-calculado (por exemplo, usando uma tabela do arco-íris). Caso contrário, o invasor deve gastar tempo para calcular um hash para cada senha e ver se ele corresponde ao hash armazenado.

Todas as senhas não são igualmente prováveis. Os atacantes podem procurar exaustivamente todas as senhas curtas, mas sabem que suas chances de sucesso de força bruta caem drasticamente com cada personagem adicional. Em vez disso, eles usam uma lista ordenada das senhas mais prováveis. Eles começam com “password123” e progridem para senhas usadas com menos frequência.

Digamos que uma lista de invasores seja longa, com 10 bilhões de candidatos; Suponha também que um sistema desktop possa computar 1 milhão de hashes por segundo. O atacante pode testar toda a sua lista em menos de três horas se apenas uma iteração for usada. Mas se apenas 2000 iterações forem usadas, esse tempo se estende por quase 8 meses. Para derrotar um invasor mais sofisticado – um capaz de fazer o download de um programa que pode aproveitar o poder de sua GPU, por exemplo – você precisa de mais iterações.

Quanto custa o suficiente?

O número de iterações a usar é uma troca entre segurança e experiência do usuário. O hardware especializado que pode ser usado por invasores é barato, mas ainda pode executar centenas de milhões de iterações por segundo. O desempenho do sistema do invasor determina quanto tempo leva para quebrar uma senha, devido a várias iterações. Mas seu aplicativo provavelmente não usará esse hardware especializado. Quantas iterações você pode executar sem agravar os usuários depende do seu sistema.

Você provavelmente pode permitir que os usuários esperem mais ou menos ¾ segundo durante a autenticação. Faça o perfil da sua plataforma de destino e use quantas iterações você puder pagar. Plataformas que testei (um usuário em um dispositivo móvel ou muitos usuários em uma plataforma de servidor) podem suportar confortavelmente PBKDF2 com 60.000 e 120.000 iterações, ou criptografar com fator de custo de 12 ou 13.

Mais fundo

Leia PKCS # 5 para informações autoritativas sobre o papel do sal e as iterações no hashing. Embora o PBKDF2 tenha sido criado para gerar chaves de criptografia a partir de senhas, ele funciona bem como um hash unidirecional para autenticação de senha. Cada iteração do bcrypt é mais cara que um hash SHA-2, então você pode usar menos iterações, mas a ideia é a mesma. O Bcrypt também vai além da maioria das soluções baseadas em PBKDF2 usando a chave derivada para criptografar um texto simples bem conhecido. O texto cifrado resultante é armazenado como “hash”, junto com alguns meta-dados. No entanto, nada impede que você faça a mesma coisa com o PBKDF2.

Aqui estão outras respostas que escrevi sobre esse tópico:

  • Hashing passwords
  • Hashing passwords
  • Sal
  • Escondendo sal
  • PBKDF2 versus bcrypt
  • Bcrypt

Para aqueles que dizem que é seguro, eles estão corretos em geral . O hashing “duplo” (ou a expansão lógica disso, iterando uma function hash) é absolutamente seguro se for feito corretamente , para uma preocupação específica.

Para aqueles que dizem que é inseguro, eles estão corretos neste caso . O código que é postado na pergunta é inseguro. Vamos falar sobre o porquê:

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

Existem duas propriedades fundamentais de uma function hash que nos preocupam:

  1. Resistência Pré-Imagem – Dado um hash $h , deve ser difícil encontrar uma mensagem $m tal que $h === hash($m)

  2. Second-Pre-Image Resistance – Dado uma mensagem $m1 , deve ser difícil encontrar uma mensagem diferente $m2 tal forma que o hash($m1) === hash($m2)

  3. Resistência à colisão – Deve ser difícil encontrar um par de mensagens ($m1, $m2) tal forma que o hash($m1) === hash($m2) (note que isso é semelhante à segunda resistência pré-imagem, mas diferente em que aqui o atacante tem controle sobre ambas as mensagens) …

Para o armazenamento de senhas , tudo o que realmente nos interessa é a Resistência Pré-Imagem . Os outros dois seriam irrelevantes, porque $m1 é a senha do usuário que estamos tentando manter em segurança. Então, se o atacante já tem, o hash não tem nada para proteger …

AVISO LEGAL

Tudo o que se segue baseia-se na premissa de que tudo o que nos interessa é a Resistência Pré-Imagem . As outras duas propriedades fundamentais das funções hash não podem (e tipicamente não) se mantêm da mesma maneira. Portanto, as conclusões deste post são aplicáveis ​​apenas ao usar funções hash para o armazenamento de senhas. Eles não são aplicáveis ​​em geral …

Vamos começar

Por causa desta discussão, vamos inventar nossa própria function hash:

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

Agora deve ser bastante óbvio o que esta function hash faz. Soma os valores ASCII de cada caractere de input e, em seguida, pega o módulo desse resultado com 256.

Então vamos testar:

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

Agora, vamos ver o que acontece se o rodarmos algumas vezes em torno de uma function:

 $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"; } 

Isso resulta:

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

Hmm, uau. Nós geramos colisões !!! Vamos tentar ver porque:

Aqui está a saída do hash de uma string de cada e toda possível saída hash:

 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 a tendência para números mais altos. Isso acaba sendo o nosso ponto morto. Rodar o hash 4 vezes ($ hash = ourHash ($ hash) `, para cada elemento) acaba nos dando:

 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 

Nós nos limitamos a 8 valores ... Isso é ruim ... Nossa function original mapeou S(∞) para S(256) . Ou seja, nós criamos uma function $input mapeada de function Surjectiva para $output .

Como temos uma function Surjectiva, não temos garantia de que o mapeamento para qualquer subconjunto da input não terá colisões (de fato, na prática elas terão).

Foi o que aconteceu aqui! Nossa function era ruim, mas não é por isso que isso funcionou (é por isso que funcionou tão rapidamente e tão completamente).

O mesmo acontece com o MD5 . Ele mapeia S(∞) para S(2^128) . Já que não há garantia de que executar o MD5(S(output)) será Injetivo , o que significa que ele não terá colisões.

Seção TL / DR

Portanto, como alimentar a saída de volta para md5 diretamente pode gerar colisões, cada iteração aumentará a chance de colisões. No entanto, este é um aumento linear, o que significa que, embora o conjunto de resultados de 2^128 seja reduzido, não é reduzido de forma significativa com rapidez suficiente para ser uma falha crítica.

Assim,

 $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 

Quanto mais vezes você repetir, maior será a redução.

O conserto

Felizmente para nós, há uma maneira trivial de corrigir isso: retornar algo para as outras iterações:

 $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 

Observe que as outras iterações não são 2 ^ 128 para cada valor individual de $input . Isso significa que podemos gerar valores de $input que ainda colidem abaixo da linha (e, portanto, vão resolver ou ressoar com muito menos do que 2^128 saídas possíveis). Mas o caso geral de $input ainda é tão forte quanto foi para uma única rodada.

Espere, foi isso? Vamos testar isso com a nossa function ourHash() . Mudando para $hash = ourHash($input . $hash); , por 100 iterações:

 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 

Ainda existe um padrão grosseiro, mas note que não é mais um padrão do que a nossa function subjacente (que já era bastante fraca).

Observe, entretanto, que 0 e 3 se tornaram colisões, mesmo que não estivessem na única corrida. Isso é uma aplicação do que eu disse antes (que a resistência à colisão permanece a mesma para o conjunto de todas as inputs, mas rotas de colisão específicas podem se abrir devido a falhas no algoritmo subjacente).

Seção TL / DR

Ao retornar a input em cada iteração, efetivamente quebramos quaisquer colisões que possam ter ocorrido na iteração anterior.

Portanto, md5($input . md5($input)); deve ser ( teoricamente pelo menos) tão forte quanto md5($input) .

Isso é importante?

Sim. Esta é uma das razões pelas quais o PBKDF2 substituiu o PBKDF1 no RFC 2898 . Considere os loops internos dos dois:

PBKDF1:

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

Onde c é a contagem de iteração, P é a senha e S é o sal

PBKDF2:

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

Onde PRF é realmente apenas um HMAC. Mas para os nossos propósitos aqui, vamos apenas dizer que PRF(P, S) = Hash(P || S) (isto é, o PRF de 2 inputs é o mesmo, grosso modo, como hash com os dois concatenados juntos). Não é muito, mas para nossos propósitos é.

Portanto, o PBKDF2 mantém a resistência à colisão da function Hash subjacente, onde o PBKDF1 não.

Amarrando tudo isso juntos:

Sabemos de formas seguras de iterar um hash. De fato:

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

Normalmente é seguro.

Agora, para saber por que queremos fazer hash, vamos analisar o movimento de entropia.

Um hash recebe o conjunto infinito: S(∞) e produz um conjunto menor e consistente de tamanho S(n) . A próxima iteração (assumindo que a input é passada de volta) mapeia S(∞) para S(n) novamente:

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

Observe que a saída final tem exatamente a mesma quantidade de entropia que a primeira . A iteração não "tornará mais obscura". A entropia é idêntica. Não há nenhuma fonte mágica de imprevisibilidade (é uma function pseudo-aleatória, não uma function aleatória).

No entanto, há um ganho para iterar. Isso torna o processo de hash artificialmente mais lento. E é por isso que iterar pode ser uma boa ideia. Na verdade, é o princípio básico da maioria dos algoritmos hash de senhas modernas (o fato de fazer algo over-and-over o torna mais lento).

Lento é bom, porque está combatendo a ameaça primária de segurança: força bruta. Quanto mais devagar fizermos o nosso algoritmo de hashing, mais os atacantes terão que trabalhar para atacar os hashes de senha roubados de nós. E isso é uma coisa boa !!!

Sim, o re-hashing reduz o espaço de busca, mas não, não importa – a redução efetiva é insignificante.

Re-hashing aumenta o tempo que leva para a força bruta, mas fazê-lo apenas duas vezes também é sub-ótimo.

O que você realmente quer é hash a senha com PBKDF2 – um método comprovado de usar um hash seguro com sal e iterações. Confira esta resposta SO .

EDIT : eu quase esqueci – NÃO USE MD5 !!!! Use um hash criptográfico moderno, como a família SHA-2 (SHA-256, SHA-384 e SHA-512).

Sim – reduz o número de strings possíveis que correspondem à string.

Como você já mencionou, os hashes salgados são muito melhores.

Um artigo aqui: http://websecurity.ro/blog/2007/11/02/md5md5-vs-md5/ , tenta uma prova de por que é equivalente, mas não tenho certeza com a lógica. Em parte, eles assumem que não há software disponível para analisar o md5 (md5 (texto)), mas obviamente é bastante trivial produzir as tabelas do arco-íris.

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; it’s not. 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.

Sim.

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.