SHA-256 не защищает пароли: соль, перец, Argon2id и автоматическое перехеширование в Django
Почему «захешированные» пароли из утёкшей таблицы восстанавливаются за часы? Медленные хеш-функции, PASSWORD_HASHERS в Django, обёртка legacy-хешей, лимиты против перебора и сравнение за постоянное время.
Представьте, что дамп таблицы пользователей оказался в открытом доступе. В колонке password у каждой строки 64-символьная hex-строка: sha256(пароль). Команда говорит: «ничего страшного, они же захешированы». Страшно. За несколько часов самые популярные пароли восстановлены, а следующими под удар попадают те, кто использовал тот же пароль для почты и банковского приложения.
Эта статья о том, как хранить пароли так, чтобы утечка таблицы была неприятностью, а не катастрофой: почему быстрый хеш не работает, что на самом деле делают соль и перец, чем отличаются PBKDF2, bcrypt, scrypt и Argon2id, как Django сам обновляет хеши, и о двух вещах вокруг хеша, о которых забывают: защите от перебора и сравнении за постоянное время.
Почему SHA-256 недостаточно
Вот вариант, который до сих пор встречается в legacy-коде:
import hashlib
def hash_password(raw: str) -> str:
return hashlib.sha256(raw.encode()).hexdigest()
def check_password(raw: str, stored: str) -> bool:
return hash_password(raw) == stored
Здесь три отдельные проблемы.
Он быстрый. SHA-256 создавали, чтобы быстро хешировать гигабайты. Для контрольных сумм файлов это отлично, для паролей ужасно: атакующий с дампом прогоняет словарь через ту же функцию на GPU и сравнивает. Чем быстрее хеш, тем больше попыток в секунду он получает бесплатно.
Нет соли. Один и тот же пароль всегда даёт один и тот же хеш. Заранее вычисленные таблицы (rainbow tables) работают напрямую, а у кого одинаковые пароли, видно сразу:
SELECT password, count(*) AS users
FROM legacy_users
GROUP BY password
HAVING count(*) > 1
ORDER BY users DESC
LIMIT 10;
Если запрос вернул строки, все аккаунты в группе падают вместе.
Обычный ==. Сравнение строк останавливается на первом несовпавшем символе. Для хешей паролей это мелочь, но та же привычка при проверке API-ключей и подписей вебхуков даёт реальную утечку. Об этом ниже.
Соль и перец: от чего защищает каждый
Соль (salt) — случайное значение, которое генерируется для каждого пароля и хранится рядом с хешем. Это не секрет. Её единственная задача — сделать каждый хеш уникальным: у двух пользователей с qwerty123 получаются разные хеши, готовые таблицы бесполезны, и атаковать приходится каждый аккаунт отдельно.
Перец (pepper) — одно секретное значение на всю систему, которое не хранится в базе: оно живёт в переменной окружения или в хранилище секретов. Если утекла только база, без перца атакующий не может даже начать перебор. Цена — эксплуатационная: потеряли перец, и никто не может войти; ротировать его больно, потому что нельзя перехешировать пароль, которого вы не знаете.
Соль делает каждый хеш уникальным. Медленность делает каждую попытку дорогой. Перец помогает, только если база утекла без секретов приложения. Первые два нужны всегда, третий — по желанию.
Медленные хеш-функции: PBKDF2, bcrypt, scrypt, Argon2id
Хеш пароля должен быть намеренно дорогим, причём с настраиваемой стоимостью, которую можно поднимать по мере роста мощности железа. Четыре распространённых варианта:
| Алгоритм | Параметры стоимости | Memory-hard | Хешер Django | Заметки |
|---|---|---|---|---|
| PBKDF2-HMAC-SHA256 | итерации | нет | PBKDF2PasswordHasher (по умолчанию) |
Широко одобрен (например, FIPS), но дёшево распараллеливается на GPU |
| bcrypt | rounds (log2) | немного (4 KiB) | BCryptSHA256PasswordHasher |
Учитывает только первые 72 байта; Django предварительно хеширует SHA-256 |
| scrypt | N, r, p | да | ScryptPasswordHasher |
Память ≈ 128 · N · r байт |
| Argon2id | время, память, параллелизм | да | Argon2PasswordHasher |
Победитель Password Hashing Competition (2015), первый выбор OWASP |
Почему важна память: у GPU и ASIC тысячи ядер, но мало памяти на ядро. PBKDF2 тратит только процессорное время, поэтому атакующий дёшево распараллеливает перебор. scrypt и Argon2 заставляют каждую попытку задействовать большой кусок RAM, и массовый параллельный перебор становится намного дороже. Argon2id — гибридный вариант: он сочетает устойчивость Argon2i к атакам по сторонним каналам и устойчивость Argon2d к GPU, и именно его использует Django.
Алгоритм и параметры можно прочитать прямо из значения, которое хранит Django:
pbkdf2_sha256$<iterations>$<salt>$<hash>
argon2$argon2id$v=19$m=102400,t=2,p=8$<salt_b64>$<hash_b64>
bcrypt_sha256$$2b$12$<salt_and_hash>
scrypt$16384$<salt>$8$5$<hash>
Формат — алгоритм$параметры$соль$хеш. Именно префикс делает миграцию возможной: Django знает, каким хешером создана каждая строка.
Django: переходим на Argon2
По умолчанию в PASSWORD_HASHERS первым стоит PBKDF2. Для Argon2 установите дополнительную зависимость (argon2-cffi):
pip install "django[argon2]"
И поставьте Argon2 первым:
# settings.py
PASSWORD_HASHERS = [
"django.contrib.auth.hashers.Argon2PasswordHasher", # new hashes
"django.contrib.auth.hashers.PBKDF2PasswordHasher", # still verifies old ones
"django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
"django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
"django.contrib.auth.hashers.ScryptPasswordHasher",
]
Правило простое: первый хешер используется для всех новых паролей, а все хешеры из списка — для проверки существующих. Не удаляйте старые хешеры, пока в этом формате ещё есть хеши: check_password не сможет определить алгоритм и просто вернёт False, и эти пользователи молча перестанут входить.
Параметры Argon2 в Django по умолчанию: time_cost=2, memory_cost=102400 (в KiB, то есть 100 MiB) и parallelism=8. Это хорошая защита, но 100 MiB на одну проверку заметны, когда в небольшой контейнер одновременно приходят десять логинов. Параметры можно настроить подклассом с тем же именем алгоритма:
# accounts/hashers.py
from django.contrib.auth.hashers import Argon2PasswordHasher
class TunedArgon2PasswordHasher(Argon2PasswordHasher):
# algorithm stays "argon2", so existing hashes are still recognised
time_cost = 3
memory_cost = 65536 # KiB, i.e. 64 MiB per check
parallelism = 2
Подставьте этот класс вместо строки со стандартным Argon2PasswordHasher (а не рядом с ней: оба претендуют на имя argon2). Параметры выбирайте измерением, а не на глаз. Запустите на том же железе, что и продакшен:
# python manage.py shell
import statistics
import time
from django.contrib.auth.hashers import check_password, make_password
raw = "correct horse battery staple"
encoded = make_password(raw)
samples = []
for _ in range(20):
t0 = time.perf_counter()
check_password(raw, encoded)
samples.append(time.perf_counter() - t0)
print(encoded.split("$")[0], f"median={statistics.median(samples) * 1000:.1f} ms")
Обычный ориентир — несколько сотен миллисекунд на проверку на вашем сервере: медленно для атакующего с миллиардами попыток и незаметно для пользователя, который входит один раз.
Автоматическое перехеширование: как происходит обновление
Приятная часть: чтобы перевести пользователей на Argon2, миграция не нужна. Посмотрите, что делает AbstractBaseUser.check_password:
# django/contrib/auth/base_user.py (simplified)
def check_password(self, raw_password):
def setter(raw_password):
self.set_password(raw_password)
self._password = None # a hash upgrade is not a password change
self.save(update_fields=["password"])
return check_password(raw_password, self.password, setter)
Внутри django.contrib.auth.hashers.verify_password Django определяет хешер по префиксу и вычисляет must_update: true, если сохранённый алгоритм отличается от предпочтительного или если изменились параметры предпочтительного хешера (итерации PBKDF2, время/память/параллелизм Argon2, rounds bcrypt, work factor scrypt или слишком короткая соль). Если пароль верный и must_update истинно, setter перехеширует пароль текущим хешером и сохраняет только поле password.
Это же объясняет число итераций: Django поднимает значение PBKDF2 по умолчанию в каждом feature-релизе, и после обновления каждый пользователь перехешируется с новым значением при следующем успешном входе.
Слабое место: пользователи, которые не входят, навсегда остаются со старым хешем. Для старого PBKDF2 это терпимо. Для колонки sha256(пароль) из начала статьи — нет.
Обновляем legacy-хеши, не дожидаясь входа
Приём из документации Django — обернуть старый хеш: использовать существующее значение sha256(пароль) как вход для PBKDF2. Открытый пароль не нужен, а слабый хеш исчезает из базы сразу.
# accounts/hashers.py
import hashlib
from django.contrib.auth.hashers import PBKDF2PasswordHasher
from django.utils.encoding import force_bytes
class PBKDF2WrappedSHA256PasswordHasher(PBKDF2PasswordHasher):
"""PBKDF2 over the legacy sha256(password) value."""
algorithm = "pbkdf2_wrapped_sha256"
def encode_sha256_hash(self, sha256_hex, salt, iterations=None):
return super().encode(sha256_hex, salt, iterations)
def encode(self, password, salt, iterations=None):
sha256_hex = hashlib.sha256(force_bytes(password)).hexdigest()
return self.encode_sha256_hash(sha256_hex, salt, iterations)
Data-миграция, которая переписывает все legacy-строки (lookup regex превращается в оператор ~ PostgreSQL):
# accounts/migrations/0005_wrap_legacy_sha256.py
from django.db import migrations
def wrap_legacy_hashes(apps, schema_editor):
from accounts.hashers import PBKDF2WrappedSHA256PasswordHasher
User = apps.get_model("accounts", "User")
hasher = PBKDF2WrappedSHA256PasswordHasher()
legacy = User.objects.filter(password__regex=r"^[0-9a-f]{64}$")
for user in legacy.iterator(chunk_size=500):
user.password = hasher.encode_sha256_hash(user.password, hasher.salt())
user.save(update_fields=["password"])
class Migration(migrations.Migration):
dependencies = [("accounts", "0004_previous")]
operations = [
migrations.RunPython(wrap_legacy_hashes, migrations.RunPython.noop),
]
И регистрируем хешер, чтобы Django мог проверять такие строки:
PASSWORD_HASHERS = [
"django.contrib.auth.hashers.Argon2PasswordHasher",
"django.contrib.auth.hashers.PBKDF2PasswordHasher",
"accounts.hashers.PBKDF2WrappedSHA256PasswordHasher",
]
Когда такой пользователь входит, алгоритм pbkdf2_wrapped_sha256 отличается от предпочтительного argon2, и setter перехеширует его в Argon2. Две оговорки: каждая строка стоит полного вычисления PBKDF2, поэтому сначала измерьте, а на большой таблице запускайте это как management command с батчами, а не внутри деплоя; и поскольку старый хеш был без соли, это исправляет только хранение, но не пароли, которые уже успели утечь.
Перец в Django, если он нужен
Встроенного перца в Django нет, но хватит подкласса хешера. Этот перед Argon2 прогоняет пароль через HMAC с секретным ключом:
# accounts/hashers.py
import hashlib
import hmac
from django.conf import settings
from django.contrib.auth.hashers import Argon2PasswordHasher
from django.utils.encoding import force_bytes
class PepperedArgon2PasswordHasher(Argon2PasswordHasher):
algorithm = "argon2_peppered"
def _pepper(self, password):
key = force_bytes(settings.PASSWORD_PEPPER) # from env / secret store, not the DB
return hmac.new(key, force_bytes(password), hashlib.sha256).hexdigest()
def encode(self, password, salt):
return super().encode(self._pepper(password), salt)
def verify(self, password, encoded):
return super().verify(self._pepper(password), encoded)
Используйте новое имя алгоритма (argon2_peppered), поставьте его первым в PASSWORD_HASHERS, и существующие хеши argon2 мигрируют при входе, как при любом другом обновлении. Относитесь к PASSWORD_PEPPER как к ключу шифрования базы: бэкап обязателен, в репозитории его быть не должно, ротировать между делом нельзя.
Защита от перебора: одного хеша мало
Медленный хеш защищает украденную базу. Для живого эндпоинта логина он ничего не делает: атакующий просто отправляет попытки. Хуже того, дорогой хеш делает дорогим каждый запрос логина, так что незащищённый эндпоинт — ещё и дешёвый способ нагрузить ваш CPU и память.
Сам Django попытки входа не ограничивает. Есть пакеты вроде django-axes; вот небольшая версия поверх Redis-кеша, чтобы механизм был виден:
# accounts/throttle.py
from django.core.cache import cache
USER_LIMIT = 5 # failed attempts per username
IP_LIMIT = 50 # failed attempts per IP
WINDOW = 15 * 60 # seconds
def _keys(username: str, ip: str) -> tuple[str, str]:
return f"login:fail:u:{username.casefold()}", f"login:fail:ip:{ip}"
def is_throttled(username: str, ip: str) -> bool:
user_key, ip_key = _keys(username, ip)
counts = cache.get_many([user_key, ip_key])
return counts.get(user_key, 0) >= USER_LIMIT or counts.get(ip_key, 0) >= IP_LIMIT
def register_failure(username: str, ip: str) -> None:
for key in _keys(username, ip):
cache.add(key, 0, timeout=WINDOW) # sets TTL only if the key is missing
try:
cache.incr(key) # atomic INCR in Redis, TTL is kept
except ValueError: # expired between add() and incr()
cache.set(key, 1, timeout=WINDOW)
def reset_user(username: str, ip: str) -> None:
cache.delete(_keys(username, ip)[0])
# accounts/views.py
from django.contrib.auth import authenticate, login
from django.http import JsonResponse
from django.views.decorators.debug import sensitive_post_parameters
from django.views.decorators.http import require_POST
from .throttle import is_throttled, register_failure, reset_user
@sensitive_post_parameters("password")
@require_POST
def login_view(request):
username = request.POST.get("username", "")
password = request.POST.get("password", "")
ip = request.META["REMOTE_ADDR"] # behind a proxy: read it from a trusted header
if not username or not password or len(password) > 256:
return JsonResponse({"detail": "Invalid request."}, status=400)
# check the limit BEFORE the expensive hash
if is_throttled(username, ip):
return JsonResponse({"detail": "Too many attempts, try later."}, status=429)
user = authenticate(request, username=username, password=password)
if user is None:
register_failure(username, ip)
return JsonResponse({"detail": "Invalid username or password."}, status=401)
reset_user(username, ip)
login(request, user)
return JsonResponse({"ok": True})
Ключевые решения в этом коде:
- Лимит проверяется до хеширования. Заблокированный запрос стоит одного обращения к Redis, а не 100 MiB Argon2.
- Два счётчика. По username — против перебора одного аккаунта; по IP — против перебора одного популярного пароля по множеству аккаунтов.
- Временное ограничение, а не постоянная блокировка. Если пять неверных попыток блокируют аккаунт до вмешательства поддержки, кто угодно может заблокировать любого пользователя, зная его логин. Окно, которое истекает, безопаснее.
- Одна ошибка для «нет такого пользователя» и «неверный пароль». Иначе сам эндпоинт становится инструментом перечисления пользователей.
Сравнение за постоянное время
== для строк возвращает результат, как только находит различие, поэтому время ответа зависит от того, сколько первых байт совпало. При достаточном числе измерений секрет можно восстановить побайтно. Для всего секретного, что вы сравниваете напрямую (API-ключи, HMAC-подписи платёжных вебхуков, токены сброса), используйте функцию постоянного времени:
from django.utils.crypto import constant_time_compare
signature = request.headers.get("X-Signature", "")
# Wrong: == returns as soon as the first byte differs
if signature == expected_signature:
...
# Right: time does not depend on where the strings differ
if constant_time_compare(signature, expected_signature):
...
hmac.compare_digest из стандартной библиотеки делает то же самое; учтите, что str он принимает, только если обе строки ASCII, а constant_time_compare сначала приводит к байтам. Собственные хешеры Django уже используют constant_time_compare внутри.
Есть и вторая утечка по времени: перечисление пользователей. Если ваш бэкенд сразу возвращает None, когда пользователя нет, «неизвестный телефон» отвечает за миллисекунду, а «неверный пароль» — за сотни. ModelBackend в этом случае один раз прогоняет хешер по умолчанию; свой бэкенд должен делать то же самое:
# accounts/backends.py
from django.contrib.auth import get_user_model
from django.contrib.auth.backends import ModelBackend
class PhoneBackend(ModelBackend):
def authenticate(self, request, phone=None, password=None, **kwargs):
UserModel = get_user_model()
if phone is None or password is None:
return None
try:
user = UserModel._default_manager.get(phone=phone)
except UserModel.DoesNotExist:
# Wrong would be a bare `return None`: a fast answer reveals
# that the phone is not registered. Do the same hashing work.
UserModel().set_password(password)
return None
if user.check_password(password) and self.user_can_authenticate(user):
return user
return None
Подводные камни в продакшене
- Слишком раннее удаление хешера. Пользователи с хешами в его формате больше не могут войти, и ошибки в логах нет. Сначала проверьте, какие префиксы ещё есть в таблице:
SELECT split_part(password, '$', 1), count(*) FROM accounts_user GROUP BY 1;. - Память Argon2 под нагрузкой.
memory_cost— на одну проверку. Много параллельных логинов её умножают. Подбирайте воркеры и лимиты с учётом этого и держите rate limit впереди. - Сравнение через
make_password.make_password(raw) == user.passwordвсегда ложно, потому что соль случайная. Используйтеcheck_password. - Медленные тесты. Каждый
create_userзапускает настоящий хешер. В тестовых настройках используйте быстрый:
# settings/test.py
PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher"]
- Пароли в логах. Отчёты об ошибках могут включать POST-данные.
sensitive_post_parametersскрывает поле; проверьте также своё логирование и APM-middleware. - Неограниченный ввод. Задайте разумную максимальную длину поля пароля, чтобы никто не отправлял мегабайты в ваш хешер.
- Слепое доверие
X-Forwarded-For. Если заголовок может выставить кто угодно, лимит по IP бесполезен. Берите IP клиента только из заголовка, который ставит ваш прокси.
Чеклист
- Argon2id первым в
PASSWORD_HASHERS, параметры подобраны измерением на продакшен-железе. - Старые хешеры остаются в списке, пока ими пользуется хоть одна строка.
- Legacy быстрые хеши обёрнуты data-миграцией, а не ждут входа пользователей.
- Перец — только если вы можете правильно управлять секретом.
- Rate limit на логин по username и по IP, проверяется до хеширования, истекает, а не блокирует навсегда.
- Одна ошибка для неизвестного пользователя и неверного пароля; свои бэкенды тратят то же время на хеширование.
constant_time_compareдля каждого сравнения секретов.- Быстрый хешер в тестовых настройках,
sensitive_post_parametersна view логина.
Итог
Таблица паролей однажды утечёт, поэтому проектируйте под этот день: уникальная соль на каждый пароль, намеренно медленная memory-hard функция вроде Argon2id и параметры, которые вы пересматриваете. Самую сложную часть Django уже делает сам, включая проверку старых форматов и перехеширование при входе, если PASSWORD_HASHERS настроен правильно. На вас остаётся живой эндпоинт: лимиты, одинаковые ошибки и сравнение за постоянное время.
// комментарии
Загружаем комментарии...