Lösenordshantering i DjangoLink to this heading#

Använda Argon2 med DjangoLink to this heading#

Argon2 är vinnaren av 2015 års Password Hashing Competition, en öppen tävling som anordnas av en gemenskap för att välja nästa generations hashingalgoritm. Den är utformad för att inte vara lättare att beräkna på anpassad hårdvara än den är att beräkna på en vanlig CPU. Standardvarianten för Argon2-lösenordshashern är Argon2id.

Argon2 är inte standard för Django eftersom det kräver ett tredjepartsbibliotek. Tävlingspanelen för lösenordshashing rekommenderar dock omedelbar användning av Argon2 snarare än de andra algoritmerna som stöds av Django.

Gör så här om du vill använda Argon2id som standardalgoritm för lagring:

1. Installera paketet argon2-cffi. Detta kan göras genom att köra python -m pip install django[argon2], vilket är likvärdigt med python -m pip install argon2-cffi (tillsammans med eventuella versionskrav från Djangos pyproject.toml).

2. Ändra PASSWORD_HASHERS till att lista Argon2PasswordHasher först. Det vill säga, i din inställningsfil skulle du skriva:

   Code

   PASSWORD_HASHERS = [
       "django.contrib.auth.hashers.Argon2PasswordHasher",
       "django.contrib.auth.hashers.PBKDF2PasswordHasher",
       "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
       "django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
       "django.contrib.auth.hashers.ScryptPasswordHasher",
   ]
   

   Behåll och/eller lägg till poster i den här listan om du vill att Django ska uppgradera lösenord.

Använda bcrypt med DjangoLink to this heading#

Bcrypt är en populär algoritm för lagring av lösenord som är särskilt utformad för långvarig lagring av lösenord. Det är inte den standard som används av Django eftersom det kräver användning av tredjepartsbibliotek, men eftersom många människor kanske vill använda det stöder Django bcrypt med minimal ansträngning.

Gör så här om du vill använda Bcrypt som standardalgoritm för lagring:

1. Installera paketet bcrypt. Detta kan göras genom att köra python -m pip install django[bcrypt], vilket är likvärdigt med python -m pip install bcrypt (tillsammans med eventuella versionskrav från Djangos pyproject.toml).

2. Ändra PASSWORD_HASHERS till att lista BCryptSHA256PasswordHasher först. Det vill säga, i din inställningsfil skulle du skriva:

   Code

   PASSWORD_HASHERS = [
       "django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
       "django.contrib.auth.hashers.PBKDF2PasswordHasher",
       "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
       "django.contrib.auth.hashers.Argon2PasswordHasher",
       "django.contrib.auth.hashers.ScryptPasswordHasher",
   ]
   

   Behåll och/eller lägg till poster i den här listan om du vill att Django ska uppgradera lösenord.

Det var allt - nu kommer din Django-installation att använda Bcrypt som standardlagringsalgoritm.

Använda scrypt med DjangoLink to this heading#

scrypt liknar PBKDF2 och bcrypt genom att använda ett bestämt antal iterationer för att sakta ner brute-force-attacker. Men eftersom PBKDF2 och bcrypt inte kräver mycket minne kan angripare med tillräckliga resurser starta storskaliga parallella attacker för att påskynda angreppsprocessen. scrypt är särskilt utformad för att använda mer minne jämfört med andra lösenordsbaserade nyckeldrivningsfunktioner för att begränsa mängden parallellism som en angripare kan använda, se RFC 7914 för mer information.

Gör så här om du vill använda scrypt som standardalgoritm för lagring:

1. Ändra PASSWORD_HASHERS så att ScryptPasswordHasher listas först. Det vill säga, i din inställningsfil:

   Code

   PASSWORD_HASHERS = [
       "django.contrib.auth.hashers.ScryptPasswordHasher",
       "django.contrib.auth.hashers.PBKDF2PasswordHasher",
       "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
       "django.contrib.auth.hashers.Argon2PasswordHasher",
       "django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
   ]
   

   Behåll och/eller lägg till poster i den här listan om du vill att Django ska uppgradera lösenord.

Ökning av saltets entropiLink to this heading#

De flesta lösenordshashar innehåller ett salt tillsammans med sin lösenordshash för att skydda mot regnbågstabellsattacker. Själva saltet är ett slumpmässigt värde som ökar storleken och därmed kostnaden för regnbågstabellen och är för närvarande inställt på 128 bitar med värdet salt_entropy i BasePasswordHasher. I takt med att beräknings- och lagringskostnaderna minskar bör detta värde höjas. När du implementerar din egen lösenordshasher kan du åsidosätta detta värde för att använda en önskad entropinivå för dina lösenordshashar. salt_entropy mäts i bitar.

Ökning av arbetsfaktornLink to this heading#

Uppgradering av lösenordLink to this heading#

När användare loggar in, om deras lösenord lagras med något annat än den föredragna algoritmen, kommer Django automatiskt att uppgradera algoritmen till den föredragna algoritmen. Detta innebär att gamla installationer av Django automatiskt blir säkrare när användare loggar in, och det innebär också att du kan byta till nya (och bättre) lagringsalgoritmer när de uppfinns.

Django kan dock endast uppgradera lösenord som använder algoritmer som nämns i PASSWORD_HASHERS, så när du uppgraderar till nya system bör du se till att aldrig ta bort poster från den här listan. Om du gör det kommer användare som använder algoritmer som inte nämns inte att kunna uppgradera. Hashade lösenord kommer att uppdateras när antalet PBKDF2-iterationer, bcrypt-rundor eller argon2-attribut ökas (eller minskas).

Tänk på att om alla lösenord i din databas inte är kodade i standardalgoritmen för hasharen, kan du vara sårbar för en tidsattack med uppräkning av användare på grund av en skillnad mellan varaktigheten för en inloggningsbegäran för en användare med ett lösenord som är kodat i en icke-standardalgoritm och varaktigheten för en inloggningsbegäran för en icke-existerande användare (som kör standardalgoritmen för hasharen). Du kanske kan mildra detta genom att uppgradera äldre lösenordshashar.

Lösenordsuppgradering utan krav på inloggningLink to this heading#

Om du har en befintlig databas med en äldre, svag hash, t.ex. MD5, kanske du vill uppgradera dessa hashar själv istället för att vänta på att uppgraderingen ska ske när en användare loggar in (vilket kanske aldrig sker om en användare inte återvänder till din webbplats). I det här fallet kan du använda en ”wrappad” lösenordshash.

I det här exemplet migrerar vi en samling MD5-hashar till att använda PBKDF2(MD5(password)) och lägger till motsvarande lösenordshash för att kontrollera om en användare angav rätt lösenord vid inloggning. Vi antar att vi använder den inbyggda User-modellen och att vårt projekt har en accounts-app. Du kan ändra mönstret så att det fungerar med vilken algoritm som helst eller med en anpassad användarmodell.

Först ska vi lägga till den anpassade hasharen:

from django.contrib.auth.hashers import (
    PBKDF2PasswordHasher,
    MD5PasswordHasher,
)


class PBKDF2WrappedMD5PasswordHasher(PBKDF2PasswordHasher):
    algorithm = "pbkdf2_wrapped_md5"

    def encode_md5_hash(self, md5_hash, salt, iterations=None):
        return super().encode(md5_hash, salt, iterations)

    def encode(self, password, salt, iterations=None):
        _, _, md5_hash = MD5PasswordHasher().encode(password, salt).split("$", 2)
        return self.encode_md5_hash(md5_hash, salt, iterations)

Datamigreringen kan se ut ungefär som följer:

from django.db import migrations

from ..hashers import PBKDF2WrappedMD5PasswordHasher


def forwards_func(apps, schema_editor):
    User = apps.get_model("auth", "User")
    users = User.objects.filter(password__startswith="md5$")
    hasher = PBKDF2WrappedMD5PasswordHasher()
    for user in users:
        algorithm, salt, md5_hash = user.password.split("$", 2)
        user.password = hasher.encode_md5_hash(md5_hash, salt)
        user.save(update_fields=["password"])


class Migration(migrations.Migration):
    dependencies = [
        ("accounts", "0001_initial"),
        # replace this with the latest migration in contrib.auth
        ("auth", "####_migration_name"),
    ]

    operations = [
        migrations.RunPython(forwards_func),
    ]

Tänk på att denna migrering kommer att ta i storleksordningen flera minuter för flera tusen användare, beroende på hastigheten på din maskinvara.

Slutligen lägger vi till en PASSWORD_HASHERS-inställning:

PASSWORD_HASHERS = [
    "django.contrib.auth.hashers.PBKDF2PasswordHasher",
    "accounts.hashers.PBKDF2WrappedMD5PasswordHasher",
]

Inkludera alla andra hashrar som din webbplats använder i den här listan.

Inkluderade hasplarLink to this heading#

Den fullständiga listan över hashare som ingår i Django är:

[
    "django.contrib.auth.hashers.PBKDF2PasswordHasher",
    "django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher",
    "django.contrib.auth.hashers.Argon2PasswordHasher",
    "django.contrib.auth.hashers.BCryptSHA256PasswordHasher",
    "django.contrib.auth.hashers.BCryptPasswordHasher",
    "django.contrib.auth.hashers.ScryptPasswordHasher",
    "django.contrib.auth.hashers.MD5PasswordHasher",
]

De motsvarande algoritmnamnen är:

• pbkdf2_sha256

• pbkdf2_sha1

• argon2

• bcrypt_sha256

• bcrypt

• skryptera

• md5

Skriva din egen haschmaskinLink to this heading#

Om du skriver en egen lösenordshash som innehåller en arbetsfaktor, t.ex. ett antal iterationer, bör du implementera metoden harden_runtime(self, password, encoded) för att överbrygga körtidsgapet mellan den arbetsfaktor som anges i det kodade lösenordet och hasherns standardarbetsfaktor. Detta förhindrar en tidsattack för uppräkning av användare på grund av skillnaden mellan en inloggningsbegäran för en användare med ett lösenord som kodats i ett äldre antal iterationer och en icke-existerande användare (som kör standardhasherns standardantal iterationer).

Om vi tar PBKDF2 som exempel och encoded innehåller 20.000 iterationer och hasherns standardvärde för iterationer är 30.000, bör metoden köra password genom ytterligare 10.000 iterationer av PBKDF2.

Om din hasher inte har en arbetsfaktor, implementera metoden som en no-op (pass).

Aktivering av lösenordsvalideringLink to this heading#

Lösenordsvalidering konfigureras i inställningen AUTH_PASSWORD_VALIDATORS:

AUTH_PASSWORD_VALIDATORS = [
    {
        "NAME": "django.contrib.auth.password_validation.UserAttributeSimilarityValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.MinimumLengthValidator",
        "OPTIONS": {
            "min_length": 9,
        },
    },
    {
        "NAME": "django.contrib.auth.password_validation.CommonPasswordValidator",
    },
    {
        "NAME": "django.contrib.auth.password_validation.NumericPasswordValidator",
    },
]

I detta exempel aktiveras alla fyra validerare som ingår:

• UserAttributeSimilarityValidator, som kontrollerar likheten mellan lösenordet och en uppsättning attribut för användaren.

• MinimumLengthValidator, som kontrollerar om lösenordet uppfyller en minimilängd. Den här valideraren är konfigurerad med ett anpassat alternativ: den kräver nu att den minsta längden är nio tecken, i stället för standardvärdet åtta.

• CommonPasswordValidator, som kontrollerar om lösenordet finns med i en lista över vanliga lösenord. Som standard jämförs det med en inkluderad lista med 20 000 vanliga lösenord.

• NumericPasswordValidator, som kontrollerar om lösenordet inte är helt numeriskt.

För UserAttributeSimilarityValidator och CommonPasswordValidator använder vi standardinställningarna i det här exemplet. NumericPasswordValidator har inga inställningar.

Hjälptexter och eventuella fel från lösenordsvalidatorer returneras alltid i den ordning de listas i AUTH_PASSWORD_VALIDATORS.

Inkluderade validerareLink to this heading#

Django innehåller fyra validerare:

class MinimumLengthValidator(min_length=8)Link to this definition#

Verifierar att lösenordet har en minimilängd. Minimilängden kan anpassas med parametern min_length.

get_error_message()Link to this definition#

En hook för att anpassa felmeddelandet ValidationError. Standard är "Det här lösenordet är för kort. Det måste innehålla minst <min_length> tecken.".

get_help_text()Link to this definition#

En hook för att anpassa validatorns hjälptext. Standard är "Ditt lösenord måste innehålla minst <min_längd> tecken.".

class UserAttributeSimilarityValidator(user_attributes=DEFAULT_USER_ATTRIBUTES, max_similarity=0.7)Link to this definition#

Kontrollerar att lösenordet skiljer sig tillräckligt mycket från vissa av användarens attribut.

Parametern user_attributes bör vara en iterabel med namn på användarattribut att jämföra med. Om detta argument inte anges används standardvärdet: 'username', 'first_name', 'last_name', 'email'. Attribut som inte existerar ignoreras.

Den maximalt tillåtna likheten mellan lösenord kan ställas in på en skala från 0,1 till 1,0 med parametern max_similarity. Detta jämförs med resultatet av difflib.SequenceMatcher.quick_ratio(). Ett värde på 0,1 avvisar lösenord om de inte skiljer sig väsentligt från user_attributes, medan ett värde på 1,0 endast avvisar lösenord som är identiska med ett attributs värde.

get_error_message()Link to this definition#

En hook för att anpassa felmeddelandet ValidationError. Standardvärdet är "Lösenordet är för likt <user_attribute>.".

get_help_text()Link to this definition#

En hook för att anpassa validatorns hjälptext. Standard är "Ditt lösenord får inte vara för likt din övriga personliga information.".

class CommonPasswordValidator(password_list_path=DEFAULT_PASSWORD_LIST_PATH)Link to this definition#

Validates that the password is not a common password. This converts the password to lowercase (to do a case-insensitive comparison) and checks it against a list of 20,000 common passwords created by Royce Williams.

Sökvägen för password_list_path kan anges till sökvägen för en anpassad fil med vanliga lösenord. Filen ska innehålla ett lösenord med gemener per rad och kan vara i klartext eller gzippad.

get_error_message()Link to this definition#

En hook för att anpassa felmeddelandet ValidationError. Standard är "Det här lösenordet är för vanligt.".

get_help_text()Link to this definition#

En hook för att anpassa validatorns hjälptext. Standard är "Ditt lösenord kan inte vara ett vanligt lösenord.".

class NumericPasswordValidatorLink to this definition#

Kontrollera att lösenordet inte är helt numeriskt.

get_error_message()Link to this definition#

En hook för att anpassa felmeddelandet ValidationError. Standard är "Det här lösenordet är helt numeriskt.".

get_help_text()Link to this definition#

En hook för att anpassa validatorns hjälptext. Standard är "Ditt lösenord kan inte vara helt numeriskt.".

Integrering av valideringLink to this heading#

Det finns några funktioner i django.contrib.auth.password_validation som du kan anropa från dina egna formulär eller annan kod för att integrera lösenordsvalidering. Detta kan vara användbart om du använder anpassade formulär för lösenordsinställning, eller om du har API-anrop som gör det möjligt att ställa in lösenord, till exempel.

validate_password(password, user=None, password_validators=None)Link to this definition#

Validerar ett lösenord. Om alla validerare anser att lösenordet är giltigt returneras None. Om en eller flera validerare avvisar lösenordet, skapas en ValidationError med alla felmeddelanden från validerarna.

Objektet user är valfritt: om det inte anges kan det hända att vissa validerare inte kan utföra någon validering och accepterar vilket lösenord som helst.

password_changed(password, user=None, password_validators=None)Link to this definition#

Informerar alla validerare om att lösenordet har ändrats. Detta kan användas av validerare som t.ex. förhindrar återanvändning av lösenord. Detta bör anropas när lösenordet har ändrats på ett framgångsrikt sätt.

För underklasser till AbstractBaseUser kommer lösenordsfältet att markeras som ”dirty” vid anrop av set_password() som utlöser ett anrop till password_changed() efter att användaren har sparats.

password_validators_help_texts(password_validators=None)Link to this definition#

Returnerar en lista med hjälptexter för alla validerare. Dessa förklarar lösenordskraven för användaren.

password_validators_help_text_html(password_validators=None)Link to this definition#

Returnerar en HTML-sträng med alla hjälptexter i en <ul>. Detta är användbart när du lägger till lösenordsvalidering i formulär, eftersom du kan skicka utdata direkt till parametern help_text i ett formulärfält.

get_password_validators(validator_config)Link to this definition#

Returnerar en uppsättning valideringsobjekt baserat på parametern validator_config. Som standard använder alla funktioner de validerare som definieras i AUTH_PASSWORD_VALIDATORS, men genom att anropa den här funktionen med en alternativ uppsättning validerare och sedan skicka resultatet till parametern password_validators i de andra funktionerna kommer din anpassade uppsättning validerare att användas istället. Detta är användbart när du har en typisk uppsättning validerare som kan användas för de flesta scenarier, men också har en speciell situation som kräver en anpassad uppsättning. Om du alltid använder samma uppsättning validerare behöver du inte använda den här funktionen, eftersom konfigurationen från AUTH_PASSWORD_VALIDATORS används som standard.

Strukturen för validator_config är identisk med strukturen för AUTH_PASSWORD_VALIDATORS. Returvärdet för denna funktion kan skickas till parametern password_validators i de funktioner som listas ovan.

Observera att om lösenordet skickas till någon av dessa funktioner ska det alltid vara lösenordet i klartext - inte ett hashat lösenord.

Skriva din egen validatorLink to this heading#

Om Djangos inbyggda validerare inte räcker till kan du skriva dina egna lösenordsvaliderare. Validerare har ett ganska litet gränssnitt. De måste implementera två metoder:

• validate(self, password, user=None): validerar ett lösenord. Returnerar None om lösenordet är giltigt, eller ger ett ValidationError med ett felmeddelande om lösenordet inte är giltigt. Du måste kunna hantera att user är None - om det betyder att din validerare inte kan köras, returnera None för inget fel.

• get_help_text(): ger en hjälptext för att förklara kraven för användaren.

Alla objekt i OPTIONS i AUTH_PASSWORD_VALIDATORS för din validator kommer att skickas till konstruktören. Alla konstruktörens argument bör ha ett standardvärde.

Här är ett grundläggande exempel på en validator, med en valfri inställning:

from django.core.exceptions import ValidationError
from django.utils.translation import gettext as _


class MinimumLengthValidator:
    def __init__(self, min_length=8):
        self.min_length = min_length

    def validate(self, password, user=None):
        if len(password) < self.min_length:
            raise ValidationError(
                _("This password must contain at least %(min_length)d characters."),
                code="password_too_short",
                params={"min_length": self.min_length},
            )

    def get_help_text(self):
        return _(
            "Your password must contain at least %(min_length)d characters."
            % {"min_length": self.min_length}
        )

Du kan också implementera password_changed(password, user=None), som kommer att anropas efter en lyckad lösenordsändring. Det kan till exempel användas för att förhindra återanvändning av lösenord. Men om du bestämmer dig för att lagra en användares tidigare lösenord bör du aldrig göra det i klartext.