Хеширование пароля один раз небезопасно

Нет, несколько hashей не менее безопасны; они являются неотъемлемой частью безопасного использования пароля.

Итерирование hashа увеличивает время, необходимое злоумышленнику для проверки каждого пароля в списке кандидатов. Вы можете легко увеличить время, затрачиваемое на атаку пароля с нескольких часов до нескольких лет.

Простой итерации недостаточно

Для обеспечения безопасности недостаточно простого хеш-вывода на входе. Итерация должна выполняться в контексте алгоритма, который сохраняет энтропию пароля. К счастью, есть несколько опубликованных алгоритмов, которые достаточно тщательно изучили, чтобы дать уверенность в их дизайне.

Хороший алгоритм вывода ключей, такой как PBKDF2, вводит пароль в каждый раунд hashирования, смягчая опасения по поводу столкновений в hash-выходе. PBKDF2 может использоваться для аутентификации пароля как есть. Bcrypt следует за ключевым деривацией с шагом шифрования; Таким образом, если обнаружен быстрый способ отменить вывод ключа, злоумышленнику еще предстоит выполнить атаку известного типа.

Как разбить пароль

Сохраненные пароли требуют защиты от автономной атаки. Если пароли не соленые, их можно сломать с помощью заранее вычисленной атаки словаря (например, используя таблицу Rainbow). В противном случае злоумышленник должен потратить время на вычисление hashа для каждого пароля и посмотреть, совпадает ли он с сохраненным hashем.

Все пароли не одинаково вероятны. Атакующие могут исчерпывающе искать все короткие пароли, но они знают, что их шансы на успех грубой силы резко падают с каждым дополнительным персонажем. Вместо этого они используют упорядоченный список наиболее вероятных паролей. Они начинаются с «password123» и продвигаются к менее часто используемым паролям.

Скажем, список нападающих длинный, с 10 миллиардами кандидатов; предположим также, что настольная система может вычислить 1 миллион hashей в секунду. Злоумышленник может проверить весь ее список менее трех часов, если используется только одна итерация. Но если используется только 2000 итераций, это время простирается почти до 8 месяцев. Чтобы победить более изощренного атакующего – например, способного загрузить программу, которая может задействовать мощность своего GPU, вам нужно больше итераций.

Сколько достаточно?

Количество итераций для использования – это компромисс между безопасностью и опытом пользователей. Специализированное оборудование, которое может быть использовано злоумышленниками, дешево, но оно может выполнять сотни миллионов итераций в секунду. Производительность системы злоумышленника определяет, сколько времени потребуется, чтобы сломать пароль, учитывая количество итераций. Но ваше приложение вряд ли будет использовать это специализированное оборудование. Сколько итераций, которые вы можете выполнять без отягчающих пользователей, зависит от вашей системы.

Вероятно, вы можете позволить пользователям ждать еще ¾ секунды или около того во время аутентификации. Профилируйте свою целевую платформу и используйте столько итераций, сколько сможете. Платформы, которые я тестировал (один пользователь на мобильном устройстве или многие пользователи на серверной платформе), могут с комфортом поддерживать PBKDF2 с 60 000 и 120 000 итераций или bcrypt с коэффициентом затрат 12 или 13.

Больше фона

Прочтите PKCS № 5 за достоверную информацию о роли соли и итераций в хешировании. Несмотря на то, что PBKDF2 предназначен для генерации ключей шифрования из паролей, он хорошо работает как односторонний hash для аутентификации пароля. Каждая итерация bcrypt дороже, чем hash SHA-2, поэтому вы можете использовать меньше итераций, но идея такая же. Bcrypt также выходит за frameworks большинства решений на базе PBKDF2, используя производный ключ для шифрования хорошо известного текста. Полученный в результате шифрованный текст сохраняется как «hash», а также некоторые метаданные. Однако ничто не мешает вам делать то же самое с PBKDF2.

Вот еще ответы, которые я написал на эту тему:

• Хеширование паролей
• Хеширование паролей
• Поваренная соль
• Сокрытие соли
• PBKDF2 против bcrypt
• Bcrypt

Тем, кто говорит, что это безопасно, они правильны в целом . «Двойное» хеширование (или логическое расширение этого, итерация хеш-функции) абсолютно безопасно, если сделать это правильно , для конкретной проблемы.

Тем, кто говорит, что это небезопасно, в этом случае они верны. Код, размещенный в вопросе , небезопасен. Давайте поговорим о том, почему:

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

Есть два основных свойства hash-функции, которые нас беспокоят:

1. Сопротивление предварительного изображения. Учитывая hash $h , должно быть сложно найти сообщение $m такое, что $h === hash($m)

2. Сопротивление второго изображения – Учитывая сообщение $m1 , должно быть сложно найти другое сообщение $m2 такое, что hash($m1) === hash($m2)

3. Сопротивление столкновениям. Трудно найти пару сообщений ($m1, $m2) , для которых hash($m1) === hash($m2) (обратите внимание, что это похоже на сопротивление второго изображения, но отличается тем, что здесь атакующий имеет контроль над обоими сообщениями) …

Для хранения паролей все, что нам действительно нужно, это Pre-Image Resistance . Остальные два будут спорными, потому что $m1 является паролем пользователя, который мы пытаемся сохранить в безопасности. Так что, если злоумышленник уже имеет его, hash не имеет ничего, чтобы защитить …

ОТКАЗ ОТ ОТВЕТСТВЕННОСТИ

Все, что следует, основывается на предпосылке, что все, о чем мы заботимся, – это предварительное изображение . Остальные два основных свойства хеш-функций не могут (и, как правило, не) удерживаться одинаково. Таким образом, выводы в этом сообщении применимы только при использовании хеш-функций для хранения паролей. Они вообще не применимы …

Давайте начнем

Ради этой дискуссии давайте придумаем собственную хеш-функцию:

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

Теперь должно быть довольно очевидно, что делает эта хеш-функция. Он суммирует значения ASCII каждого символа ввода, а затем принимает по модулю результат с 256.

Итак, давайте проверим это:

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

Теперь давайте посмотрим, что произойдет, если мы несколько раз запустим его вокруг функции:

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

Это означает:

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

Хм, ничего себе. Мы создали столкновения !!! Попробуем посмотреть, почему:

Вот результат хеширования строки каждого и каждого возможного 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 

Обратите внимание на тенденцию к увеличению числа. Это оказывается нашим безвыходным. Запуск hashа 4 раза ($ hash = ourHash ($ hash) `, для каждого элемента) завершается, давая нам:

 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 

Мы сузились до 8 значений ... Это плохо ... Наша оригинальная функция отображала S(∞) на S(256) . То есть мы создали функцию Surjective Function, сопоставляющую $input с $output .

Поскольку у нас есть Сургующая функция, мы не гарантируем, что отображение для любого подмножества входных данных не будет иметь столкновений (фактически, на практике они будут).

Вот что здесь произошло! Наша функция была плохая, но это не помогло (поэтому она работала так быстро и так полностью).

То же самое происходит с MD5 . Он отображает S(∞) на S(2^128) . Поскольку нет гарантии, что запуск MD5(S(output)) будет Injective , что означает, что он не будет иметь коллизий.

Раздел TL / DR

Поэтому, поскольку подача выходного сигнала обратно в md5 напрямую может генерировать столкновения, каждая итерация увеличивает вероятность столкновений. Это, однако, линейное увеличение, а это означает, что в то время как результирующий набор 2^128 сокращен, он не будет значительно уменьшен достаточно быстро, чтобы стать критическим недостатком.

Так,

 $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 

Чем больше вы повторяете, тем дальше идет сокращение.

Исправление

К счастью для нас, есть тривиальный способ исправить это: вернуть что-то в дальнейшие итерации:

 $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 

Обратите внимание, что дальнейшие итерации не равны 2 ^ 128 для каждого отдельного значения для $input . Это означает, что мы можем генерировать $input значения, которые все еще сталкиваются по линии (и, следовательно, будут оседать или резонировать на гораздо меньших, чем 2^128 возможных выходах). Но общий случай для $input по-прежнему столь же силен, как и для одного раунда.

Подожди, не так ли? Давайте проверим это с помощью нашей нашей ourHash() . Переключение на $hash = ourHash($input . $hash); , для 100 итераций:

 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 

Там все еще есть грубая картина, но обратите внимание, что это не более шаблон, чем наша основная функция (которая уже была довольно слабой).

Обратите внимание, однако, что 0 и 3 стали столкновениями, хотя они не были в одиночном режиме. Это приложение того, что я сказал ранее (что сопротивление столкновению остается одинаковым для набора всех входов, но конкретные маршруты столкновений могут открыться из-за недостатков в базовом алгоритме).

Раздел TL / DR

Подавая назад вход на каждую итерацию, мы эффективно разрушаем любые столкновения, которые могли произойти в предыдущей итерации.

Следовательно, md5($input . md5($input)); должен быть ( теоретически, по крайней мере) сильным, как md5($input) .

Это важно?

Да. Это одна из причин того, что PBKDF2 заменил PBKDF1 в RFC 2898 . Рассмотрим внутренние циклы двух ::

PBKDF1:

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

Где c - счетчик итераций, P - пароль, а S - соль

PBKDF2:

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

Где PRF действительно просто HMAC. Но для наших целей здесь просто скажем, что PRF(P, S) = Hash(P || S) (т. Е. PRF из двух входов одинаково, грубо говоря, как hash с двумя конкатенированными вместе). Это очень не так , но для наших целей.

Таким образом, PBKDF2 поддерживает сопротивление столкновению базовой функции Hash , где PBKDF1 этого не делает.

Связывание всего этого вместе:

Мы знаем о безопасных способах итерации hashа. По факту:

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

Обычно безопасен.

Теперь, чтобы понять, почему мы хотим хешировать его, давайте проанализируем движение энтропии.

Хэш принимает бесконечное множество: S(∞) и производит меньший набор последовательностей S(n) . Следующая итерация (при условии, что вход снова возвращается) отображает S(∞) на S(n) :

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

Обратите внимание, что конечный результат имеет точно такое же количество энтропии, как и первое . Итерация не будет «замалчивать». Энтропия идентична. Не существует волшебного источника непредсказуемости (это псевдослучайная функция, а не случайная функция).

Однако есть все шансы на повторение. Это делает процесс хеширования искусственно медленнее. И поэтому итерация может быть хорошей идеей. Фактически, это основной принцип большинства современных алгоритмов hashирования паролей (тот факт, что выполнение чего-то сверх-и-over-over делает его медленнее).

Медленное - это хорошо, потому что это борьба с основной угрозой безопасности: грубое форсирование. Чем медленнее мы используем алгоритм hashирования, тем сложнее нападающие должны работать, чтобы нанести у нас хеш-пароль. И это хорошо!

Да, повторное хеширование уменьшает пространство поиска, но нет, это не имеет значения – эффективное сокращение несущественно.

Повторное хеширование увеличивает время, затрачиваемое на грубую силу, но при этом только дважды также субоптимально.

Вы действительно хотите хешировать пароль с помощью PBKDF2 – проверенный метод использования безопасного хеша с солью и итерациями. Проверьте этот ответ SO .

EDIT : Я почти забыл – НЕ ИСПОЛЬЗУЙТЕ MD5 !!!! Используйте современный криптографический хеш, такой как семейство SHA-2 (SHA-256, SHA-384 и SHA-512).

Да – уменьшает количество возможных строк, соответствующих строке.

Как вы уже упоминали, соленые хеши намного лучше.

Статья здесь: http://websecurity.ro/blog/2007/11/02/md5md5-vs-md5/ , пытается доказать, почему она эквивалентна, но я не уверен в логике. Частично они предполагают, что нет никакого программного обеспечения для анализа md5 (md5 (текст)), но, очевидно, довольно сложно создавать таблицы радуги.

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.

Да.

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.