Pengelolaan sandi di Django

Pengelolaan sandi adalah sesuatu yang harus secara umum tidak dibuat kembali tida perlu, dan Django berusaha menyediakan kumpulan aman dan fleksibel dari alat-alat untuk mengelola sandi pengguna. Dokumen ini menggambarkan bagaimana Django menyimpan sandi, bagaimana campuran penyimpanan dapat dikonfigurasikan, dan beberapa peralatan untuk bekerja dengan sandi dicampur.

Lihat juga

Meskipun pengguna mungkin menggunakan sandi kuat, penyerang mungkin dapat menguping pada hubungan mereka. Gunakan HTTPS untuk menghindari mengirim sandi (atau data sensitif lain apapun) terhadap hubungan HTTP polos karena merekan akan menjadi rentan pada penciuman sandi.

Bagaimana Django menyimpan sandi

Django menyediakan sistem penyimpanan sandi fleksibel dan menggunakan PBKDF2 secara awalan.

Atribut password dari sebuah obyek User adalah sebuah string di bentuk ini:

<algorithm>$<iterations>$<salt>$<hash>

Mereka adalah komponen digunakan untuk menyimpan sandi User, dipisahkan oleh karakter dolar dan terdiri dari campuran algoritma, sejumlah perulangan algoritma (faktor kerja), garam acak, dan menghasilkan campuran sandi. Algoritma adalah satu dari sejumlah dari campuran satu-cara atau algoritma penyimpanan sandi Django dapat digunakan, lihat dibawah. Perulangan menggambarkan sejumlah kali algoritma berjalan terhadap campuran. Garam adalah benih acak digunakan dan campuran adalah hasil dari fungsi satu-cara.

Secara awalan, Django menggunakan algoritma PBKDF2 dengan campuran SHA256, sebuah mekanisme perentangan sandi dianjurkan oleh NIST. Ini harus cukup untuk kebanyakan pengguna: itu sangat aman, membutuhkan jumlah besar waktu untuk merusak.

Bagaimapun, tergantung pada persyaratan anda, anda mungkin memilih algoritma berbeda, atau bahkan menggunakan penyesuaian algoritma untuk mencocokkan keadaan keamanan khusus. Kembali, kebanyakan pengguna tidak butuh melakukan ini -- jika anda tidak yakin, anda mungkin tidak. Jika anda melakukan, harap membaca:

Django chooses the algorithm to use by consulting the PASSWORD_HASHERS setting. This is a list of hashing algorithm classes that this Django installation supports.

For storing passwords, Django will use the first hasher in PASSWORD_HASHERS. To store new passwords with a different algorithm, put your preferred algorithm first in PASSWORD_HASHERS.

For verifying passwords, Django will find the hasher in the list that matches the algorithm name in the stored password. If a stored password names an algorithm not found in PASSWORD_HASHERS, trying to verify it will raise ValueError.

Nilai awal untuk PASSWORD_HASHERS adalah:

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

Ini berarti bahwa Django akan menggunakan PBKDF2 menyimpan semua sandi tetapi akan mendukung pemeriksaan sandi disimpan dengan PBKDF2SHA1, argon2, dan bcrypt.

Sedikit bagian selanjutnya menggambarkan sepasang cara umum pengguna tingkat lanjut mungkin ingin merubah pengaturan ini.

Menggunakan Argon2 dengan Django

Argon2 is the winner of the 2015 Password Hashing Competition, a community organized open competition to select a next generation hashing algorithm. It's designed not to be easier to compute on custom hardware than it is to compute on an ordinary CPU. The default variant for the Argon2 password hasher is Argon2id.

Argon2 bukan awalan untuk Django karena itu membutuhkan pustaka pihak-ketiga. Juri Password Hashing Competition, bagaimanapun, menganjurkan penggunaan segera dari Argon2 daripada algoritma lain didukung oleh Django.

To use Argon2id as your default storage algorithm, do the following:

1. Install the argon2-cffi library. This can be done by running python -m pip install django[argon2], which is equivalent to python -m pip install argon2-cffi (along with any version requirement from Django's setup.cfg).

2. Rubah PASSWORD_HASHERS pada daftar Argon2PasswordHasher pertama. Yaitu, di berkas pengaturan anda, anda telah taruh:

   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',
   ]
   

   Jaga dan/atau tambah masukan apapun di daftar ini jika anda butuh Django untuk upgrade passwords.

Menggunakan bcrypt dengan Django

Bcrypt adalah algoritma penyimpanan sandi terkenal yang khususnya dirancang untuk penyimpanan sandi jangka-panjang. Itu bukan awalan digunakan oleh Django sejak itu membutuhkan menggunakan pustaka pihak-ketiga, tetapi sejak banyak orang mungkin ingin menggunakan itu Django mendukung bcrypt dengan usaha minimal.

Untuk menggunakan Bcrypt sebagai algoritma penyimpanan awalan anda, lakukan berikut:

1. Install the bcrypt library. This can be done by running python -m pip install django[bcrypt], which is equivalent to python -m pip install bcrypt (along with any version requirement from Django's setup.cfg).

2. Rubah PASSWORD_HASHERS pada daftar BCryptSHA256PasswordHasher pertama. Yaitu, di berkas pengaturan anda, anda telah taruh:

   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',
   ]
   

   Jaga dan/atau tambah masukan apapun di daftar ini jika anda butuh Django untuk upgrade passwords.

Yaitu -- sekarang Django memasang dengan menggunakan Bcrypt sebagai algoritma penyimpanan awalan.

Using scrypt with Django

New in Django 4.0.

scrypt is similar to PBKDF2 and bcrypt in utilizing a set number of iterations to slow down brute-force attacks. However, because PBKDF2 and bcrypt do not require a lot of memory, attackers with sufficient resources can launch large-scale parallel attacks in order to speed up the attacking process. scrypt is specifically designed to use more memory compared to other password-based key derivation functions in order to limit the amount of parallelism an attacker can use, see RFC 7914 for more details.

To use scrypt as your default storage algorithm, do the following:

1. Modify PASSWORD_HASHERS to list ScryptPasswordHasher first. That is, in your settings file:

   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',
   ]
   

   Jaga dan/atau tambah masukan apapun di daftar ini jika anda butuh Django untuk upgrade passwords.

Catatan

scrypt requires OpenSSL 1.1+.

Increasing the salt entropy

Most password hashes include a salt along with their password hash in order to protect against rainbow table attacks. The salt itself is a random value which increases the size and thus the cost of the rainbow table and is currently set at 128 bits with the salt_entropy value in the BasePasswordHasher. As computing and storage costs decrease this value should be raised. When implementing your own password hasher you are free to override this value in order to use a desired entropy level for your password hashes. salt_entropy is measured in bits.

Rincian penerapan

Due to the method in which salt values are stored the salt_entropy value is effectively a minimum value. For instance a value of 128 would provide a salt which would actually contain 131 bits of entropy.

Meningkatkan faktor kerja

PBKDF2 dan bcrypt

The PBKDF2 and bcrypt algorithms use a number of iterations or rounds of hashing. This deliberately slows down attackers, making attacks against hashed passwords harder. However, as computing power increases, the number of iterations needs to be increased. We've chosen a reasonable default (and will increase it with each release of Django), but you may wish to tune it up or down, depending on your security needs and available processing power. To do so, you'll subclass the appropriate algorithm and override the iterations parameter (use the rounds parameter when subclassing a bcrypt hasher). For example, to increase the number of iterations used by the default PBKDF2 algorithm:

1. Membuat sebuah subkelas dari django.contrib.auth.hashers.PBKDF2PasswordHasher:

   from django.contrib.auth.hashers import PBKDF2PasswordHasher
   
   class MyPBKDF2PasswordHasher(PBKDF2PasswordHasher):
       """
       A subclass of PBKDF2PasswordHasher that uses 100 times more iterations.
       """
       iterations = PBKDF2PasswordHasher.iterations * 100
   

   Simpan ini disuatu tempat di proyek anda. Sebagai contoh, anda mungkin menaruh ini di sebuah berkas seperti myproject/hashers.py.

2. Tambah pencampur baru anda sebagai masukan pertama di PASSWORD_HASHERS:

   PASSWORD_HASHERS = [
       'myproject.hashers.MyPBKDF2PasswordHasher',
       'django.contrib.auth.hashers.PBKDF2PasswordHasher',
       'django.contrib.auth.hashers.PBKDF2SHA1PasswordHasher',
       'django.contrib.auth.hashers.Argon2PasswordHasher',
       'django.contrib.auth.hashers.BCryptSHA256PasswordHasher',
       'django.contrib.auth.hashers.ScryptPasswordHasher',
   ]
   

Itu dia -- sekarang pemasangan Django anda akan menggunakan perulangan lebih ketika itu menyimpan sandi menggunakan PBKDF2.

Catatan

bcrypt rounds is a logarithmic work factor, e.g. 12 rounds means 2 ** 12 iterations.

Argon2

Argon2 has the following attributes that can be customized:

1. time_cost mengendalikan sejumlah perulangan dalam campuran.
2. memory_cost mengendalikan ukuran memori yang harus digunakan selama perhitungan dari campuran.
3. parallelism mengendalikan berapa banyak CPU perhitungan dari campuran dapat diparalelkan.

Nilai-nilai awalan dari atribut ini mungkin baik untuk anda. Jika anda menentukan bahwa campuran sandi terlalu cepat atau terlalu lambat, anda dapat mengutik itu sebagai berikut:

1. Pilih parallelism untuk menjadi angka dari thread anda dapat hemat menghitung campuran.
2. Pilih memory_cost menjadi KiB dari memori anda dapat hemat.
3. Menyesuaikan time_cost dan ukuran waktu mencampur sebuah sandi yang diambil. Ambil sebuah time_cost yang mengambil sebuah waktu yang dapat diterima untuk anda. Jika time_cost disetel menjadi ` adalah tidak dapat diterima lambat, memory_cost lebih rendah.

tafsiran memory_cost

Kegunaan baris-perintah dan beberapa pustaka lain menafsirkan parameter memory_cost berbeda dari nilai yang Django gunakan. Perubahan yang diberikan oleh memory_cost == 2 ** memory_cost_commandline.

scrypt

New in Django 4.0.

scrypt has the following attributes that can be customized:

1. work_factor controls the number of iterations within the hash.
2. block_size
3. parallelism controls how many threads will run in parallel.
4. maxmem limits the maximum size of memory that can be used during the computation of the hash. Defaults to 0, which means the default limitation from the OpenSSL library.

We've chosen reasonable defaults, but you may wish to tune it up or down, depending on your security needs and available processing power.

Estimating memory usage

The minimum memory requirement of scrypt is:

work_factor * 2 * block_size * 64

so you may need to tweak maxmem when changing the work_factor or block_size values.

Peningkatan sandi

Ketika pengguna masuk, jika sandi mereka disimpan dengan apapun lain dari algoritma yang dipilih, Django akan secara otomatis meningkatkan algoritma ke satu yang dipilih. Ini berarti bahwa pemasangan lama dari Django akan mendapatkan otomatis lebih aman ketika pengguna masuk, dan itu juga berarti bahwa anda dapat berganti ke algoritma pentimpanan (dan lebih baik) baru ketika mereka dibuat.

However, Django can only upgrade passwords that use algorithms mentioned in PASSWORD_HASHERS, so as you upgrade to new systems you should make sure never to remove entries from this list. If you do, users using unmentioned algorithms won't be able to upgrade. Hashed passwords will be updated when increasing (or decreasing) the number of PBKDF2 iterations, bcrypt rounds, or argon2 attributes.

Waspada bahwa jika semua sandi di basisdata anda tidak dikodekan di algoritma pencampur awalan, anda mungkin rentan pada serangan pewaktu pencacahan pengguna karena perbedaan diantara lamanya dari permintaan masuk untuk pengguna dengan sandi terkodekan di algoritma bukan-awalan dan lamanya dari permintaan masuk untuk pengguna tidak ada (yang menjalankan pencampur awalan). Anda mungkin dapat memperbaiki ini dengan upgrading older password hashes.

Meningkatkan sandi tanpa membutuhkan masuk

Jika anda mempunyai basisdata yang ada dengan yang terlama, campuran lemah seperti MD5 atau SHA1, anda mungkin ingin meningkatkan campuran tersebut anda sendiri daripada menunggu peninggkatan terjadi ketika pengguna masuk (yang mungkin tidak pernah terjadi jika pengguna tidak kembali ke situs anda). Di kasus ini, anda dapat menggunakan pencampur sandi "wrapped".

Untuk contoh ini, kami akan memindahkan kumpulan dari campuran SHA1 untuk menggunakan PBKDF2(SHA1(password)) dan menambah pencampur sandi sesuai untuk memeriksa jika pengguna memasukkan sandi benar pada masuk. Kami menganggap kami sedang menggunakan model User siap-pakai dan bahwa proyek kami mempunyai sebuah aplikasi accounts. Anda dapat merubah pola untuk bekerja dengan algoritma apapun atau dengan penyesuaian model user.

Pertama, kami akan menambah penyesuaian pencampur:

accounts/hashers.py

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


class PBKDF2WrappedSHA1PasswordHasher(PBKDF2PasswordHasher):
    algorithm = 'pbkdf2_wrapped_sha1'

    def encode_sha1_hash(self, sha1_hash, salt, iterations=None):
        return super().encode(sha1_hash, salt, iterations)

    def encode(self, password, salt, iterations=None):
        _, _, sha1_hash = SHA1PasswordHasher().encode(password, salt).split('$', 2)
        return self.encode_sha1_hash(sha1_hash, salt, iterations)

Perpindahan data mungkin terlihat seperti:

accounts/migrations/0002_migrate_sha1_passwords.py

from django.db import migrations

from ..hashers import PBKDF2WrappedSHA1PasswordHasher


def forwards_func(apps, schema_editor):
    User = apps.get_model('auth', 'User')
    users = User.objects.filter(password__startswith='sha1$')
    hasher = PBKDF2WrappedSHA1PasswordHasher()
    for user in users:
        algorithm, salt, sha1_hash = user.password.split('$', 2)
        user.password = hasher.encode_sha1_hash(sha1_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),
    ]

Waspada bahwa perpindahan ini akan mengambil urutan dari beberapa menit untuk beberapa ribuan pengguna, tergantung pada kecepatan perangkat keras anda.

Akhirya, kami akan menambah sebuah pengaturan PASSWORD_HASHERS:

mysite/settings.py

PASSWORD_HASHERS = [
    'django.contrib.auth.hashers.PBKDF2PasswordHasher',
    'accounts.hashers.PBKDF2WrappedSHA1PasswordHasher',
]

Sertakan pencampur lain apapun yang situs anda gunakan di daftar ini.

Disertakan pencampur

Daftar penuh dari pencampur disertakan di Django adalah:

[
    '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.SHA1PasswordHasher',
    'django.contrib.auth.hashers.MD5PasswordHasher',
    'django.contrib.auth.hashers.UnsaltedSHA1PasswordHasher',
    'django.contrib.auth.hashers.UnsaltedMD5PasswordHasher',
]

Nama-nama algoritma sesuai adalah:

• pbkdf2_sha256
• pbkdf2_sha1
• argon2
• bcrypt_sha256
• bcrypt
• scrypt
• sha1
• md5
• unsalted_sha1
• unsalted_md5

Menulis pencampur anda sendiri

Jika anda menulis pencampur sandi anda sendiri yang mengandung faktor kerja seperti sejumlah perulangan, anda harus menerapkan sebuah metode harden_runtime(self, password, encoded) untuk menjembatani celah waktu jalan diantara faktor kerja disokong di sandi encoded dan faktor kerja awalan dari pencampur. Ini mencegah serangan pewaktu pencacahan pengguna pada perbedaan diantara permintaan masuk untuk pengguna baru dengan sandi dikodekan di nomor terlama dari perulangan dan pengguna tidak ada (yang menjalankan nomor awalan pencampur bawaan dari perulangan).

Mengambil PBKDF2 sebagai contoh, jika encoded mengandung 20,000 perputaran dan iterations awalan pencampur adalah 30,000, metode harus menjalankan password melalui perputaran 10,000 lain dari PBKDF2.

Jika pencampur anda tidak mempunyai faktor kerja, terapkan metode sebagai no-op (pass).

Manual mengelola sandi pengguna

The django.contrib.auth.hashers module provides a set of functions to create and validate hashed passwords. You can use them independently from the User model.

check_password(password, encoded, setter=None, preferred='default')

If you'd like to manually authenticate a user by comparing a plain-text password to the hashed password in the database, use the convenience function check_password(). It takes two mandatory arguments: the plain-text password to check, and the full value of a user's password field in the database to check against. It returns True if they match, False otherwise. Optionally, you can pass a callable setter that takes the password and will be called when you need to regenerate it. You can also pass preferred to change a hashing algorithm if you don't want to use the default (first entry of PASSWORD_HASHERS setting). See Disertakan pencampur for the algorithm name of each hasher.

make_password(password, salt=None, hasher='default')

Creates a hashed password in the format used by this application. It takes one mandatory argument: the password in plain-text (string or bytes). Optionally, you can provide a salt and a hashing algorithm to use, if you don't want to use the defaults (first entry of PASSWORD_HASHERS setting). See Disertakan pencampur for the algorithm name of each hasher. If the password argument is None, an unusable password is returned (one that will never be accepted by check_password()).

is_password_usable(encoded_password)

Mengembalikan False jika sandi adalah hasil dari User.set_unusable_password().

Pengesahan sandi

Users often choose poor passwords. To help mitigate this problem, Django offers pluggable password validation. You can configure multiple password validators at the same time. A few validators are included in Django, but you can write your own as well.

Setiap pengesah sandi harus menyediakan teks bantuan untuk menjelaskan persyaratan ke pengguna, mensahkan sandi diberikan dan mengembalikan sebuah pesan kesalahan jika itu tidak memenuhi persyaratan, dan pilihannya menerima sandi yang telah disetel. Pengesah dapat juga mempunyai pengaturan pilihan untuk mendenda menyesuaikan perilaku mereka.

Validation is controlled by the AUTH_PASSWORD_VALIDATORS setting. The default for the setting is an empty list, which means no validators are applied. In new projects created with the default startproject template, a set of validators is enabled by default.

Secara awalan, pengesah digunakan dalam formulir untuk menyetel kembali atau merubah sandi dan di perintah pengelolaan createsuperuser dan changepassword. Pengesah tidak diberlakukan pada tingkat model, sebagai contoh di User.objects.create_user()` dan create_superuser(), karena kami mengaggap bahwa pengembang, bukan pengguna, interaksi dengan Django pada tingkat itu dan juga karena pengesahan model tidak secara otomatis berjalan sebagai bagian dari membuat model.

Catatan

Pengesah sandi dapat mencegah penggunaan dari banyak jenis dari sandi lemah. Bagaimanapun, fakta bahwa sandi melewatkan semua pengesah tidak menjami bahwa itu adalah sandi kuat. Ada banyak faktor yang dapat memperlemah sebuah sandi yang tidak dikenali oleh bahkan pengesah sandi paling tingkat lanjut.

Adakan pengesahan sandi

Pengesahan sandi dikonfigurasikan di pengaturan 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',
    },
]

Contoh ini mengadakan semua empat pengesah disertakan:

• UserAttributeSimilarityValidator, yang memeriksa kemiripan diantara sandi dan sekumpulan dari atribut dari pengguna.
• MinimumLengthValidator, which checks whether the password meets a minimum length. This validator is configured with a custom option: it now requires the minimum length to be nine characters, instead of the default eight.
• CommonPasswordValidator, which checks whether the password occurs in a list of common passwords. By default, it compares to an included list of 20,000 common passwords.
• NumericPasswordValidator, yang memeriksa apakah sandi tidak sepenuhnya numerik.

For UserAttributeSimilarityValidator and CommonPasswordValidator, we're using the default settings in this example. NumericPasswordValidator has no settings.

Teks bantuan dan kesalahan apapun dari pengesah sandi selalu dikembalikan agar mereka didaftarkan di AUTH_PASSWORD_VALIDATORS.

Disertakan pengesah

Django menyertakan empat pengesah:

class MinimumLengthValidator(min_length=8)

Validates that the password is of a minimum length. The minimum length can be customized with the min_length parameter.

class UserAttributeSimilarityValidator(user_attributes=DEFAULT_USER_ATTRIBUTES, max_similarity=0.7)

Validates that the password is sufficiently different from certain attributes of the user.

Parameter user_attributes harus berupa sebuah perulangan dari nama-namad dari atribut pengguna untuk dibandingkan. Jika argumen ini tidak disediakan, awalan adalah digunakan: 'username', 'first_name', 'last_name', 'email'. Atribut-atribut yang tidak ada adalah diabaikan.

The maximum allowed similarity of passwords can be set on a scale of 0.1 to 1.0 with the max_similarity parameter. This is compared to the result of difflib.SequenceMatcher.quick_ratio(). A value of 0.1 rejects passwords unless they are substantially different from the user_attributes, whereas a value of 1.0 rejects only passwords that are identical to an attribute's value.

Changed in Django 2.2.26:

The max_similarity parameter was limited to a minimum value of 0.1.

class CommonPasswordValidator(password_list_path=DEFAULT_PASSWORD_LIST_PATH)

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 password created by Royce Williams.

password_list_path dapat disetel ke jalur dari berkas penyesuaian dari sandi umum. Berkas ini harus mengandung sandi satu huruf kecil per baris dan mungkin berupa teks polos atau gzipped.

class NumericPasswordValidator

Validate that the password is not entirely numeric.

Memadukan pengesahan

Ada sedikit fungsi di django.contrib.auth.password_validation yang anda dapat memanggil dari formulir anda sendiri atau kode lain untuk memadukan pengesahan sandi. Ini dapat berguna jika anda menggunakan penyesuaian formulir untuk pengaturan sandi, atau jika anda mempunyai panggilan API yang mengizinkan sandi disetel, sebagai contoh.

validate_password(password, user=None, password_validators=None)

Mengesahkan sebuah sandi. Jika semua pengesah menemukan sandi sah, mengembalikan None. Jika satu atau lebih pengesah menolak sandi, memunculkan sebuah ValidationError dengan semua pesan-pesan kesalahan dari pengesah.

Obyek user adalah pilihan: jika itu tidak disediakan, beberapa pengesah mungkin tidak dapat melakukan pengesahan apapun dan akan menerima sandi apapun.

password_changed(password, user=None, password_validators=None)

Menginformasikan semua pengesah yang sandi telah berubah. Ini dapat digunakan oleh pengesah seperti satu yang mencegah penggunaan kembali sandi. Ini harus dipanggil sekali sandi telah berhasil dirubah.

Untuk subkelas-subkelas dari AbstractBaseUser, bidang sandi akan ditandai sebagai "dirty" ketika memanggil set_password() yang memicu semua pada password_changed() setelah pengguna disimpan.

password_validators_help_texts(password_validators=None)

Mengembalikan daftar dari teks bantuan dari semua pengesah. Ini menjelaskan persyaratan sandi ke pengguna.

password_validators_help_text_html(password_validators=None)

Mengembalikan sebuah string HTML dengan semua bantuan teks di sebuah <ul>. Ini sangat membantu ketika menambahkan pengesahan pada formulir, ketika anda dapat melewatkan keluaran secara langsung ke parameter help_text dari bidang formulir.

get_password_validators(validator_config)

Mengembalikan sekelompok obyek pengesah berdasarkan pada parameter validator_config. Secara awalan, semua fungsi menggunakan pengesah ditentukan di AUTH_PASSWORD_VALIDATORS, tetapi dengan memanggil fungsi ini dengan alternatif kumpulan dari pengesah dan kemudian melewatkan hasil kedalam parameter password_validators dari fungsi lain, kumpulan penyesuaian anda dari pengesah akan digunakan sebagai gantinya. Ini sangat berguna ketika anda mempunyai kumpulan khusus dari pengesah untuk menggunakan kebanyakan skenario, tetapi juga mempunyai keadaan khusus yang membutuhkan penyesuaian kumpulan. Jika anda selalu menggunakan kumpulan sama dari pengesah, tidak perlu menggunakan fungsi ini, ketika konfigurasi dari AUTH_PASSWORD_VALIDATORS digunakan secara awalan.

Struktur dari validator_config``mirip pada struktur dari :setting:`AUTH_PASSWORD_VALIDATORS`. Nilai kembalian dari fungsi ini dapat dilewatkan kedalam parameter ``password_validators dari fungsi-fungsi terdaftar diatas.

Catat bahwa dimana sandi dilewatkan ke satu dari fungsi-fungsi ini, ini harus selalu sandi teks jelas - bukan sebuah sandi dicampur.

Menulis pengesah anda sendiri

If Django's built-in validators are not sufficient, you can write your own password validators. Validators have a fairly small interface. They must implement two methods:

• validate(self, password, user=None): validate a password. Return None if the password is valid, or raise a ValidationError with an error message if the password is not valid. You must be able to deal with user being None - if that means your validator can't run, return None for no error.
• get_help_text(): menyediakan teks bantuan untuk menjelaskan persyaratan ke pengguna.

Barang apapun di OPTIONS di AUTH_PASSWORD_VALIDATORS untuk pengesah anda akan dilewatkan ke pembangun. Semua argumen pembangun harus memiliki nilai awalan.

Ini adalah contoh dasar dari pengecekan, dengan satu pilihan pengaturan:

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}
        )

Anda dapat juga menerapkan password_changed(password, user=None), yang akan dipanggil setelah perubahan sandi berhasil. Itu dapat digunakan untuk mencegah penggunaan kembali sandi, sebagai contoh. Bagaimanapun, jika anda memutuskan menyimpan sandi pengguna sebelumnya, anda harus tidak pernah melakukannya di pembersihan teks.