SHA-256 paroldan himoya qilmaydi: salt, pepper, Argon2id va Django'da avtomatik qayta hashlash
Hash qilingan parollar jadvali sizib chiqsa, nega ular baribir bir necha soatda tiklanadi? Sekin hash funksiyalar, Django PASSWORD_HASHERS, legacy hash'larni o'rash, brute force'ga qarshi limit va vaqt bo'yicha xavfsiz solishtirish.
Tasavvur qiling: foydalanuvchilar jadvalining dump'i ochiq joyda paydo bo'ldi. Har bir qatordagi password ustunida 64 belgili hex satr turibdi: sha256(parol). Jamoa "xavotir yo'q, ular hash qilingan" deydi. Xavotir bor. Bir necha soat ichida eng ommabop parollar tiklanadi, keyingi navbatda esa o'sha parolni pochta va bank ilovasida ham ishlatgan odamlar turadi.
Bu maqola parollarni shunday saqlash haqidaki, jadval sizib chiqsa ham bu falokat emas, shunchaki noxush holat bo'lib qolsin: tez hash nega ishlamaydi, salt va pepper aslida nima qiladi, PBKDF2, bcrypt, scrypt va Argon2id nimasi bilan farq qiladi, Django hash'larni o'zi qanday yangilaydi va hash atrofidagi, ko'pincha unutiladigan ikki narsa: brute force'dan himoya va o'zgarmas vaqtda solishtirish.
Nega SHA-256 yetarli emas
Mana legacy kodda hali ham uchrab turadigan variant:
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
Bu yerda uchta alohida muammo bor.
U tez. SHA-256 gigabaytlab ma'lumotni tez hash qilish uchun yaratilgan. Fayllarning nazorat summasi uchun bu ajoyib, parollar uchun esa dahshat: dump qo'liga tushgan hujumchi so'zlar ro'yxatini GPU'da xuddi shu funksiyadan o'tkazadi va solishtiradi. Hash qanchalik tez bo'lsa, u sekundiga shuncha ko'p urinishni tekinga oladi.
Salt yo'q. Bir xil parol doim bir xil hash beradi. Oldindan hisoblangan jadvallar (rainbow table) to'g'ridan-to'g'ri ishlaydi, kimlarning paroli bir xilligi esa darhol ko'rinadi:
SELECT password, count(*) AS users
FROM legacy_users
GROUP BY password
HAVING count(*) > 1
ORDER BY users DESC
LIMIT 10;
Agar bu query qator qaytarsa, guruhdagi barcha akkauntlar birga yiqiladi.
Oddiy ==. Satrlarni solishtirish birinchi farq qilgan belgida to'xtaydi. Parol hash'lari uchun bu kichik masala, lekin API kalitlari va webhook imzolarini tekshirishdagi xuddi shu odat haqiqiy sizib chiqishga olib keladi. Bu haqda pastroqda.
Salt va pepper: har biri nimadan himoya qiladi
Salt har bir parol uchun alohida yaratiladigan va hash yonida saqlanadigan tasodifiy qiymat. U sir emas. Uning yagona vazifasi har bir hash'ni noyob qilish: qwerty123 paroli bor ikki foydalanuvchida turli hash chiqadi, tayyor jadvallar foydasiz bo'lib qoladi va hujumchi har bir akkauntga alohida hujum qilishga majbur.
Pepper butun tizim uchun bitta sir qiymat bo'lib, u bazada saqlanmaydi: environment o'zgaruvchisida yoki sirlar omborida turadi. Agar faqat baza sizib chiqsa, hujumchi pepper'siz parol tanlashni boshlay ham olmaydi. Buning narxi ekspluatatsiyada: pepper yo'qolsa, hech kim tizimga kira olmaydi, uni almashtirish (rotation) esa og'riqli, chunki o'zingiz bilmagan parolni qayta hash qila olmaysiz.
Salt har bir hash'ni noyob qiladi. Sekinlik har bir urinishni qimmat qiladi. Pepper faqat baza ilova sirlarisiz sizib chiqqandagina yordam beradi. Birinchi ikkisi doim kerak, uchinchisi ixtiyoriy.
Sekin hash funksiyalar: PBKDF2, bcrypt, scrypt, Argon2id
Parol hash'i ataylab qimmat bo'lishi kerak, shunda ham narxini sozlash mumkin bo'lsin: temir kuchaygan sari uni oshirib borasiz. To'rtta keng tarqalgan variant:
| Algoritm | Narx parametrlari | Memory-hard | Django hasher | Izoh |
|---|---|---|---|---|
| PBKDF2-HMAC-SHA256 | iteratsiyalar | yo'q | PBKDF2PasswordHasher (standart) |
Keng tasdiqlangan (masalan, FIPS), lekin GPU'da arzon parallellashadi |
| bcrypt | rounds (log2) | ozgina (4 KiB) | BCryptSHA256PasswordHasher |
Faqat birinchi 72 baytni hisobga oladi; Django oldin SHA-256 bilan hash qiladi |
| scrypt | N, r, p | ha | ScryptPasswordHasher |
Xotira ≈ 128 · N · r bayt |
| Argon2id | vaqt, xotira, parallellik | ha | Argon2PasswordHasher |
Password Hashing Competition g'olibi (2015), OWASP'ning birinchi tavsiyasi |
Xotira nega muhim: GPU va ASIC'da minglab yadro bor, lekin har bir yadroga to'g'ri keladigan xotira kam. PBKDF2 faqat protsessor vaqtini sarflaydi, shuning uchun hujumchi uni arzonga parallellashtiradi. scrypt va Argon2 esa har bir urinishni katta hajmdagi RAM bilan ishlashga majbur qiladi, natijada ommaviy parallel tanlash ancha qimmatlashadi. Argon2id gibrid variant: Argon2i'ning yon kanal (side-channel) hujumlariga chidamliligini va Argon2d'ning GPU'ga chidamliligini birlashtiradi. Django aynan shuni ishlatadi.
Algoritm va parametrlarni Django saqlagan qiymatning o'zidan o'qish mumkin:
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>
Format: algoritm$parametrlar$salt$hash. Migratsiyani mumkin qiladigan narsa aynan shu prefiks: Django har bir qator qaysi hasher bilan yaratilganini biladi.
Django: Argon2'ga o'tamiz
Standart holatda PASSWORD_HASHERS ro'yxatida birinchi bo'lib PBKDF2 turadi. Argon2 uchun qo'shimcha kutubxonani (argon2-cffi) o'rnating:
pip install "django[argon2]"
Va Argon2'ni birinchi qilib qo'ying:
# 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",
]
Qoida oddiy: birinchi hasher barcha yangi parollar uchun ishlatiladi, ro'yxatdagi barcha hasher'lar esa mavjud parollarni tekshirish uchun. Bazada hali o'sha formatdagi hash'lar bor ekan, eski hasher'larni o'chirmang: check_password algoritmni aniqlay olmaydi va shunchaki False qaytaradi, bu foydalanuvchilar esa hech qanday xatosiz tizimga kira olmay qoladi.
Django'da Argon2'ning standart parametrlari: time_cost=2, memory_cost=102400 (KiB'da, ya'ni 100 MiB) va parallelism=8. Bu yaxshi himoya, lekin kichik konteynerga bir vaqtda o'nta login so'rovi kelganda har bir tekshiruvga 100 MiB sezilarli bo'ladi. Parametrlarni algoritm nomini saqlagan holda subclass orqali sozlash mumkin:
# 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
Bu klassni standart Argon2PasswordHasher qatori o'rniga qo'ying (yoniga emas: ikkalasi ham argon2 nomiga da'vo qiladi). Parametrlarni taxmin bilan emas, o'lchab tanlang. Production bilan bir xil temirda ishga tushiring:
# 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")
Odatiy mo'ljal: serveringizda bir tekshiruvga bir necha yuz millisekund. Milliardlab urinish qiladigan hujumchi uchun bu sekin, bir marta login qiladigan foydalanuvchi uchun esa sezilmaydi.
Avtomatik qayta hashlash: yangilanish qanday bo'ladi
Yoqimli tomoni shundaki, foydalanuvchilarni Argon2'ga o'tkazish uchun migratsiya kerak emas. AbstractBaseUser.check_password nima qilishiga qarang:
# 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 ichida Django hasher'ni prefiks bo'yicha aniqlaydi va must_update qiymatini hisoblaydi: saqlangan algoritm afzal ko'rilganidan farq qilsa yoki afzal hasher parametrlari o'zgargan bo'lsa (PBKDF2 iteratsiyalari, Argon2'ning vaqt/xotira/parallelligi, bcrypt rounds, scrypt work factor yoki juda qisqa salt), u true bo'ladi. Parol to'g'ri va must_update true bo'lsa, setter parolni joriy hasher bilan qayta hash qiladi va faqat password maydonini saqlaydi.
Iteratsiyalar soni ham shu bilan tushuntiriladi: Django har bir feature release'da PBKDF2'ning standart qiymatini oshiradi, yangilanishdan keyin esa har bir foydalanuvchi keyingi muvaffaqiyatli login'da yangi qiymat bilan qayta hash qilinadi.
Zaif joyi: login qilmaydigan foydalanuvchilar eski hash bilan abadiy qoladi. Eski PBKDF2 uchun bunga chidash mumkin. Maqola boshidagi sha256(parol) ustuni uchun esa yo'q.
Legacy hash'larni login'ni kutmasdan yangilash
Django hujjatlaridagi usul: eski hash'ni o'rab olish, ya'ni mavjud sha256(parol) qiymatini PBKDF2'ga kirish sifatida ishlatish. Ochiq parol kerak emas, zaif hash esa bazadan darhol yo'qoladi.
# 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)
Barcha legacy qatorlarni qayta yozadigan data migratsiya (regex lookup PostgreSQL'ning ~ operatoriga aylanadi):
# 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),
]
Va Django bu qatorlarni tekshira olishi uchun hasher'ni ro'yxatdan o'tkazamiz:
PASSWORD_HASHERS = [
"django.contrib.auth.hashers.Argon2PasswordHasher",
"django.contrib.auth.hashers.PBKDF2PasswordHasher",
"accounts.hashers.PBKDF2WrappedSHA256PasswordHasher",
]
Bunday foydalanuvchi login qilganda pbkdf2_wrapped_sha256 algoritmi afzal ko'rilgan argon2'dan farq qiladi va setter uni Argon2'ga qayta hash qiladi. Ikki ogohlantirish: har bir qator bitta to'liq PBKDF2 hisobiga tushadi, shuning uchun avval o'lchang va katta jadvalda buni deploy ichida emas, batch'lab ishlaydigan management command sifatida ishga tushiring; eski hash salt'siz bo'lgani uchun bu faqat saqlashni tuzatadi, allaqachon sizib chiqqan parollarni emas.
Django'da pepper, agar kerak bo'lsa
Django'da tayyor pepper yo'q, lekin hasher subclass'i yetarli. Bu klass parolni Argon2'dan oldin maxfiy kalit bilan HMAC'dan o'tkazadi:
# 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)
Yangi algoritm nomini (argon2_peppered) ishlating, uni PASSWORD_HASHERS'da birinchi qilib qo'ying, mavjud argon2 hash'lari esa boshqa har qanday yangilanish kabi login paytida ko'chadi. PASSWORD_PEPPER'ga bazani shifrlash kalitiga qaragandek qarang: zaxira nusxasi bo'lsin, repozitoriyda bo'lmasin, bekordan-bekorga almashtirilmasin.
Brute force'dan himoya: hash yolg'iz yetmaydi
Sekin hash o'g'irlangan bazani himoya qiladi. Jonli login endpoint uchun esa hech narsa qilmaydi: hujumchi shunchaki urinishlarni yuboraveradi. Bundan ham yomoni, qimmat hash har bir login so'rovini qimmat qiladi, ya'ni himoyasiz endpoint CPU va xotirangizni yuklashning arzon usuliga ham aylanadi.
Django'ning o'zi login urinishlarini cheklamaydi. django-axes kabi paketlar bor; mexanizm ko'rinib turishi uchun mana Redis kesh ustidagi kichik versiya:
# 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})
Bu koddagi asosiy qarorlar:
- Limit hash'dan oldin tekshiriladi. Bloklangan so'rov 100 MiB'lik Argon2 emas, bitta Redis murojaatiga tushadi.
- Ikkita hisoblagich. Username bo'yicha: bitta akkauntni tanlashga qarshi; IP bo'yicha: bitta ommabop parolni ko'plab akkauntlarda sinab chiqishga qarshi.
- Doimiy bloklash emas, vaqtinchalik cheklov. Agar beshta xato urinish akkauntni support ochguncha bloklasa, istalgan odam login'ini bilgan har qanday foydalanuvchini bloklab qo'ya oladi. Muddati o'tadigan oyna xavfsizroq.
- "Bunday foydalanuvchi yo'q" va "parol noto'g'ri" uchun bitta xato. Aks holda endpoint'ning o'zi foydalanuvchilarni aniqlash (user enumeration) vositasiga aylanadi.
Vaqt bo'yicha xavfsiz solishtirish
Satrlar uchun == farqni topishi bilan javob qaytaradi, shuning uchun javob vaqti boshidagi nechta bayt mos kelganiga bog'liq. Yetarlicha o'lchov bilan sirni bayt-bayt tiklash mumkin. To'g'ridan-to'g'ri solishtiradigan har qanday sir uchun (API kalitlari, to'lov webhook'larining HMAC imzolari, parolni tiklash tokenlari) o'zgarmas vaqtli funksiyadan foydalaning:
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):
...
Standart kutubxonadagi hmac.compare_digest ham xuddi shu ishni qiladi; faqat u str'ni ikkala satr ham ASCII bo'lsagina qabul qiladi, constant_time_compare esa avval baytga o'giradi. Django'ning o'z hasher'lari ichkarida allaqachon constant_time_compare ishlatadi.
Vaqt bo'yicha ikkinchi sizib chiqish ham bor: foydalanuvchilarni aniqlash. Agar backend'ingiz foydalanuvchi topilmaganda darhol None qaytarsa, "noma'lum telefon" bir millisekundda, "noto'g'ri parol" esa yuzlab millisekundda javob beradi. Bunday holatda ModelBackend standart hasher'ni bir marta ishga tushiradi; o'zingiz yozgan backend ham shunday qilishi kerak:
# 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
Production'dagi tuzoqlar
- Hasher'ni juda erta o'chirish. Hash'i shu formatdagi foydalanuvchilar endi kira olmaydi, log'da esa hech qanday xato yo'q. Avval jadvalda qaysi prefikslar qolganini tekshiring:
SELECT split_part(password, '$', 1), count(*) FROM accounts_user GROUP BY 1;. - Yuklama ostida Argon2 xotirasi.
memory_costbitta tekshiruv uchun. Ko'p parallel login uni ko'paytiradi. Worker'lar va limitlarni shunga qarab tanlang, rate limit'ni esa oldinda saqlang. make_passwordbilan solishtirish.make_password(raw) == user.passworddoim false, chunki salt tasodifiy.check_passwordishlating.- Sekin testlar. Har bir
create_userhaqiqiy hasher'ni ishga tushiradi. Test sozlamalarida tezkorini ishlating:
# settings/test.py
PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher"]
- Log'dagi parollar. Xato hisobotlariga POST ma'lumotlari kirishi mumkin.
sensitive_post_parametersmaydonni yashiradi; o'zingizning logging va APM middleware'ingizni ham tekshiring. - Cheklanmagan kirish. Parol maydoniga oqilona maksimal uzunlik qo'ying, toki hech kim hasher'ingizga megabaytlab ma'lumot yubormasin.
X-Forwarded-For'ga ko'r-ko'rona ishonish. Agar uni istalgan odam o'rnata olsa, IP bo'yicha limit foydasiz. Mijoz IP'sini faqat proksi'ngiz qo'yadigan sarlavhadan oling.
Checklist
PASSWORD_HASHERS'da birinchi Argon2id, parametrlari production temirida o'lchab tanlangan.- Eski hasher'lar ularni ishlatadigan qator qolmaguncha ro'yxatda turadi.
- Legacy tez hash'lar login'ni kutmay, data migratsiya bilan o'ralgan.
- Pepper faqat sirni to'g'ri boshqara olsangiz.
- Login uchun username va IP bo'yicha rate limit: hash'dan oldin tekshiriladi, abadiy bloklamaydi, muddati o'tadi.
- Noma'lum foydalanuvchi va noto'g'ri parol uchun bitta xato; o'zingiz yozgan backend'lar ham hash uchun bir xil vaqt sarflaydi.
- Sirlarni har bir solishtirishda
constant_time_compare. - Test sozlamalarida tez hasher, login view'larida
sensitive_post_parameters.
Xulosa
Parollar jadvali bir kun sizib chiqadi, shuning uchun o'sha kunga tayyorlab loyihalang: har bir parolga noyob salt, Argon2id kabi ataylab sekin memory-hard funksiya va vaqti-vaqti bilan qayta ko'rib chiqiladigan parametrlar. Eng murakkab qismini Django o'zi bajaradi, jumladan eski formatlarni tekshirish va login paytida qayta hashlashni, faqat PASSWORD_HASHERS to'g'ri sozlangan bo'lsa. Sizga jonli endpoint qoladi: limitlar, bir xil xato xabarlari va o'zgarmas vaqtda solishtirish.
// izohlar
Izohlar yuklanmoqda...