Все заметки
Программирование

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 настроен правильно. На вас остаётся живой эндпоинт: лимиты, одинаковые ошибки и сравнение за постоянное время.

// комментарии

Загружаем комментарии...

    // следующий шаг

    Давайте построим что-нибудь вместе.

    Написать в Telegram
    aslbek@asldev: ~
    ❯