---
title: "Bainistíocht pasfhocal i Django"
version: 6.0
locale: ga
source: https://docs.djangoproject.com/ga/6.0/topics/auth/passwords/
canonical: https://djangodocs.dev/ga/6.0/topics/auth/passwords/
---
# Bainistíocht pasfhocal i Django

Is rud é bainistíocht pasfhocal nár cheart é a athchruthú go ginearálta gan ghá, agus déanann Django iarracht sraith uirlisí slán solúbtha a sholáthar chun pasfhocail úsáideora a bhainistiú. Déanann an doiciméad seo cur síos ar an gcaoi a stórálann Django pasfhocail, conas is féidir an hashing stórála a chumrú, agus roinnt fóntais chun oibriú le pasfhocail

> **See also**
>
> Cé go bhféadfadh úsáideoirí pasfhocail láidre a úsáid, b'fhéidir go mbeadh ionsaitheoirí in ann cluaise a gcuid naisc. Úsáid: tagairt: HTTPS \<security-recommendation-ssl\>\`chun pasfhocail a sheachaint (nó aon sonraí íogaire eile) a sheachaint thar naisc simplí HTTP toisc go mbeidh siad leochaileach do shnifeadh pasfhocal.

## Conas a stórálann Django pasfhocail

Soláthraíonn Django córas stórála pasfhocal solúbtha agus úsáideann sé PBKDF2 de réir réamhshocraithe.

Is teaghrán sa fhormáid seo é an tréith: Attr: ~django.contrib.auth.models.user.password tréith a:class: ~django.contrib.auth.models.user réad:

```text
<algorithm>$<iterations>$<salt>$<hash>
```

Those are the components used for storing a User's password, separated by the
dollar-sign character and consist of: the hashing algorithm, the number of
algorithm iterations (work factor), the random salt, and the resulting password
hash. The algorithm is one of a number of one-way hashing or password storage
algorithms Django can use; see below. Iterations describe the number of times
the algorithm is run over the hash. Salt is the random seed used and the hash
is the result of the one-way function.

De réir réamhshocraithe, úsáideann Django algartam [PBKDF2](https://en.wikipedia.org/wiki/PBKDF2) le hash SHA256, meicníocht síneadh pasfhocal a mhol [NIST](https://nvlpubs.nist.gov/nistpubs/Legacy/SP/nistspecialpublication800-132.pdf). Ba chóir go mbeadh sé seo leordhóthanach don chuid is mó d'úsáideoirí: tá sé slán go leor, ag teastáil go leor ama ríomhaireachta chun briseadh.

However, depending on your requirements, you may choose a different
algorithm, or even use a custom algorithm to match your specific
security situation. Again, most users shouldn't need to do this -- if
you're not sure, you probably don't. If you do, please read on:

Roghnaíonn Django an algartam le húsáid trí chomhairle leis an socrú: setting: PASSWORD\_HASHERS. Seo liosta de ranganna algartam hashing a thacaíonn an suiteáil Django seo.

Chun pasfhocail a stóráil, úsáidfidh Django an chéad hasher in:setting: PASSWORD\_HASHERS. Chun pasfhocail nua a stóráil le halgartam difriúil, cuir an algartam is fearr leat ar dtús in:setting: PASSWORD\_HASHERS.

Chun pasfhocail a fhíorú, gheobhaidh Django an hasher sa liosta a mheaitseálann ainm an algartam sa phasfhocal stóráilte. Má ainmníonn pasfhocal stóráilte algartam nach bhfaightear in:setting: PASSWORD\_HASHERS, ardóidh sé `ValueError` ag iarraidh a fhíorú.

Is é an réamhshocrú le haghaidh: socrú: PASSWORD\_HASHERS:

```
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",
]
```

Ciallaíonn sé seo go n-úsáidfidh Django [PBKDF2](https://en.wikipedia.org/wiki/PBKDF2) chun gach pasfhocal a stóráil ach tacóidh sé le pasfhocail a stóráiltear le PBKDF2SHA1, [argon2](https://en.wikipedia.org/wiki/Argon2), agus [bcrypt](https://en.wikipedia.org/wiki/Bcrypt) a sheiceáil.

Déanann na cúpla chuid eile cur síos ar chúpla bealach coitianta a d'fhéadfadh ardúsáideoirí a bheith ag iarraidh an socrú seo a

### Ag baint úsáide as Argon2 le Django

Is é [Argon2](https://en.wikipedia.org/wiki/Argon2) buaiteoir an “Comórtas Hashing Pasfhocal” 2015, comórtas oscailte eagraithe ag an bpobal chun algartam hashing den chéad ghlúin eile a roghnú. Tá sé deartha chun nach mbeadh sé níos éasca a ríomh ar chrua-earraí saincheaptha ná mar atá sé a ríomh ar ghnáth LAP. Is é Argon2id an leagan réamhshocraithe don hasher pasfhocal Argon2.

Ní hé [Argon2](https://en.wikipedia.org/wiki/Argon2) an réamhshocrú do Django toisc go dteastaíonn leabharlann tríú páirtí uaidh. Molann an painéal Comórtais Hashing Pasfhocal, áfach, Argon2 a úsáid láithreach seachas na halgartaim eile a thacaíonn Django.

Chun Argon2id a úsáid mar do algartam stórála réamhshocraithe, déan an méid seo a leanas:

1. Suiteáil an pacáiste: pypi: argon2-cffi. Is féidir é seo a dhéanamh trí ```python -m pip install django [argon2] ``a reáchtáil, atá comhionann le ``python -m pip install argon2-cffi``` (in éineacht le haon riachtanas leagan ó `pyproject.toml` Django).
2. Athraigh: Socrú: PASSWORD\_HASHERS chun Argon2PasswordHasher\` a liostáil ar dtús. Is é sin, i do chomhad socruithe, chuirfeá:

   ```
   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",
   ]
   ```

   \<password-upgrades\>Coinnigh agus/nó cuir aon iontrálacha sa liosta seo má theastaíonn Django uait to:ref: pasfhocail a uasghrádú .

### Ag baint úsáide as `bcrypt` le Django

Is algartam stórála pasfhocal móréilimh é [Bcrypt](https://en.wikipedia.org/wiki/Bcrypt) atá deartha go sonrach le haghaidh stórála pasfhocal fadtéarmach. Ní hé an réamhshocrú a úsáideann Django é ós rud é go n-éilíonn sé leabharlanna tríú páirtí a úsáid, ach ós rud é go bhféadfadh go leor daoine é a úsáid tacaíonn Django le bcrypt gan iarracht íosta.

Chun Bcrypt a úsáid mar do algartam stórála réamhshocraithe, déan an méid seo a leanas:

1. Suiteáil an pacáiste: pypi: bcrypt. Is féidir é seo a dhéanamh trí ```python -m pip install django [bcrypt] ``a reáchtáil, atá comhionann le ``python -m pip install bcrypt``` (in éineacht le haon riachtanas leagan ó `pyproject.toml` Django).
2. Athraigh: Socrú: PASSWORD\_HASHERS chun bCryptSha256PasswordHasher\` a liostáil ar dtús. Is é sin, i do chomhad socruithe, chuirfeá:

   ```
   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",
   ]
   ```

   \<password-upgrades\>Coinnigh agus/nó cuir aon iontrálacha sa liosta seo má theastaíonn Django uait to:ref: pasfhocail a uasghrádú .

Sin é - anois úsáidfidh do shuiteáil Django Bcrypt mar an algartam stórála réamhshocraithe.

### Ag baint úsáide as `scrypt` le Django

Tá [scrypt](https://en.wikipedia.org/wiki/Scrypt) cosúil le PBKDF2 agus bcrypt agus líon socraithe athraitheanna a úsáid chun ionsaithe brute-force a mhoilliú. Mar sin féin, toisc nach dteastaíonn go leor cuimhne ó PBKDF2 agus bcrypt, is féidir le hionsaitheoirí a bhfuil dóthain acmhainní acu ionsaithe a sheoladh chun an próiseas ionsaitheora a bhrostú. Tá [scrypt](https://en.wikipedia.org/wiki/Scrypt) deartha go sonrach chun níos mó feidhmeanna díorthaithe bunaithe ar phasfhocal eile d'fhonn teorainn a chur ar an méid comhthreomhaíochta is féidir le hionsaitheoir a úsáid, féach: rfc: 7914 le haghaidh tuilleadh sonraí.

Chun [scrypt](https://en.wikipedia.org/wiki/Scrypt) a úsáid mar do algartam stórála réamhshocraithe, déan an méid seo a leanas:

1. Athraigh: Socrú: PASSWORD\_HASHERS chun ScryptPasswordHasher\` a liostáil ar dtús. Is é sin, i do chomhad socruithe:

   ```
   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",
   ]
   ```

   \<password-upgrades\>Coinnigh agus/nó cuir aon iontrálacha sa liosta seo má theastaíonn Django uait to:ref: pasfhocail a uasghrádú .

> **Note**
>
> Éilíonn `scrypt` OpenSSL 1.1+.

### An t-entróp salainn a mhéadú

Cuimsíonn an chuid is mó de na hashes pasfhocal salann in éineacht lena hash pasfhocal d'fhonn cosaint a dhéanamh ar ionsaithe tábla tuar ceatha. Is luach randamach é an salann féin a mhéadaíonn méid agus dá bhrí sin costas an tábla ceatha agus tá sé socraithe faoi láthair ag 128 giotán leis an luach salt\_entropy\` sa BasePasswordHasher\`. Mar a laghdaíonn costais ríomhaireachta agus stórála ba chóir an luach seo a ardú Agus do phasfhocal féin á chur i bhfeidhm tá saor agat an luach seo a shárú d'fhonn an leibhéal entróp atá ag teastáil a úsáid le haghaidh do hashes pasfhocal. Tomhaistear salt\_entropy\` i ngiotáin.

> **Sonraí cur chun feidhme**
>
> Mar gheall ar an modh ina stóráiltear luachanna salainn is íosluach é an luach salt\_entropy\` go héifeachtach. Mar shampla, chuirfeadh luach 128 salann ar fáil ina mbeadh 131 giotán d'entróp i ndáiríre.

### An fachtóir oibre a mhéadú

#### PBKDF2 agus bcrypt

Úsáideann halgartaim PBKDF2 agus bcrypt roinnt athrá nó babhtaí hashing. Moillíonn sé seo ionsaitheoirí d'aon ghnó, rud a fhágann go bhfuil ionsaithe i gcoinne pasfhoc Mar sin féin, de réir mar a mhéadaíonn cumhacht ríomhaireachta, is gá líon na n-athrá a mhéadú. Tá réamhshocrú réasúnta roghnaithe againn (agus méadóimid sé le gach scaoileadh de Django), ach b'fhéidir gur mhaith leat é a thiúnadh suas nó síos, ag brath ar do riachtanais slándála agus ar an chumhacht próiseála atá ar fáil. Chun é sin a dhéanamh, déanfaidh tú an algartam cuí a fho-aicmiú agus an paraiméadar iterations\` a shárú (bain úsáid as an paraiméadar rounds\` agus tú ag fo-aicmiú hasher bcrypt). Mar shampla, chun líon na n-athrú a úsáideann an algartam PBKDF2 réamhshocraithe a mhéadú:

1. Cruthaigh fo-aicme de 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
   ```

   Sábháil seo áit éigin i do thionscadal. Mar shampla, b'fhéidir go gcuirfeá é seo i gcomhad mar `myproject/hashers.py`.
2. Cuir do hasher nua leis mar an gcéad iontráil in:setting: 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",
   ]
   ```

Sin é - anois úsáidfidh do shuiteáil Django níos mó athraithe nuair a stóráil sé pasfhocail ag baint úsáide as PBKDF2.

> **Note**
>
> Is fachtóir oibre logartamach é bcrypt ```babhtaí ``, m.sh. ciallaíonn 12 babhta ``2 ** 12``` athraitheanna.

#### Argon2

Tá na tréithe seo a leanas ag Argon2 is féidir a shaincheapadh:

1. Rialaíonn `time_cost` líon na n-athrá laistigh den hash.
2. Rialaíonn `memory_cost` méid na cuimhne nach mór a úsáid le linn ríomh an hash.
3. Rialaíonn `parallelism` cé mhéad CPU is féidir ríomh an hash a dhéanamh comhthreomhar orthu.

Is dócha go bhfuil luachanna réamhshocraithe na dtréithe seo go breá duit. Má chinneann tú go bhfuil an hash pasfhocal ró-tapa nó ró-mhall, is féidir leat é a tweak mar seo a leanas:

1. Roghnaigh paralelism\` mar líon na snáitheanna is féidir leat a spáráil a ríomh an hash.
2. Roghnaigh memory\_cost\` chun a bheith mar an KiB de chuimhne is féidir leat a spáráil.
3. Coigeartaigh `time_cost` agus tomhas an t-am a thógann hashú pasfhocal. Roghnaigh `time_cost` a thógann am inghlactha duit. Má tá `time_cost` socraithe go 1 go neamhghlactha go mall, ísligh `memory_cost`.

> **Léirmhíniú memory_cost**
>
> Léirmhíníonn fóntais líne ordaithe argon2 agus roinnt leabharlanna eile an paraiméadar memory\_cost difriúil ón luach a úsáideann Django. Tugann an tiontú le `memory_cost == 2 ** memory_cost_commandline`.

#### `scrípt`

Tá na tréithe seo a leanas ag [scrypt](https://en.wikipedia.org/wiki/Scrypt) is féidir a shaincheapadh:

1. `work_factor` controls the number of iterations within the hash and the
   size of memory for computation (*N*). It must be a power of 2.
2. `block_size` controls the internal block size (*r*), tuning the algorithm
   to memory latency.
3. `parallelism` controls how many independent computations may run in
   parallel (*p*).
4. Cuireann maxmem\` teorainn leis an méid uasta na cuimhne is féidir a úsáid le linn ríomh an hash. Réamhshocraithe go `0`, rud a chiallaíonn an teorannú réamhshocraithe ón leabharlann OpenSSL.

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

> **Úsáid cuimhne a mheas**
>
> Is é an riachtanas cuimhne íosta [scrypt](https://en.wikipedia.org/wiki/Scrypt):
>
> ```
> work_factor * 2 * block_size * 64
> ```
>
> mar sin b'fhéidir go mbeidh ort `maxmem` a tweak agus na luachanna `work_factor` nó block\_size\` á athrú.
>
> If the underlying implementation of [scrypt](https://en.wikipedia.org/wiki/Scrypt) is fully multithreaded, the
> memory requirement is multiplied by the `parallelism` value.

### Uasghrádú Pasfho

Nuair a logálann úsáideoirí isteach, má stóráiltear a gcuid pasfhocail le rud ar bith seachas an algartam is fearr leat, déanfaidh Django an algartam a uasghrádú go huathoibríoch go dt Ciallaíonn sé seo go n-éireoidh sean-shuiteálacha de Django níos sábháilte go huathoibríoch de réir mar a logálann úsáideoirí isteach, agus ciallaíonn sé freisin gur féidir leat aistriú chuig halgartaim stórála nua (agus níos fearr) de réir mar a chruthaítear iad.

Mar sin féin, ní féidir le Django ach pasfhocail a úsáideann halgartaim a luaitear in:setting: PASSWORD\_HASHERS a uasghrádú, mar sin agus tú ag uasghrádú chuig córais nua ba chóir duit a chinntiú nach ndéanfaidh tú iontrálacha a bhaint riamh ón liosta seo. Má dhéanann tú, ní bheidh úsáideoirí a úsáideann halgartaim neamhluaite in ann uasghrádú a dhéanamh. Déanfar pasfhocail hashaithe a nuashonrú nuair a mhéadaítear (nó ag laghdú) líon na n-athrú PBKDF2, babhtaí bcrypt, nó tréithe argon2.

Bí ar an eolas mura bhfuil na pasfhocail go léir i do bhunachar sonraí ionchódaithe in algartam réamhshocraithe, d'fhéadfá a bheith leochaileach d'ionsaí uainiúcháin úsáideora mar gheall ar difríocht idir fad iarratais logála isteach d'úsáideoir le haghaidh pasfhocal ionchódaithe in algartam neamhréamhshocraithe agus fad iarratais logála isteach d'úsáideoir nach bhfuil ann (a ritheann an hasher réamhshocraithe). \<wrapping-password-hashers\>B'fhéidir go mbeidh tú in ann é seo a mhaolú trí:ref: hashes pasfhocal níos sine a uasghrádú .

### Uasghrádú pasfhocal gan logáil isteach a dhéanamh

Má tá bunachar sonraí agat le hash níos sine, lag mar MD5, b'fhéidir gur mhaith leat na hashes sin a uasghrádú féin in ionad fanacht go dtarlóidh an t-uasghrádú nuair a logálann úsáideoir isteach (nach bhféadfadh tarlú riamh mura bhfillfidh úsáideoir ar do shuíomh). Sa chás seo, is féidir leat hasher pasfhocal “fillte” a úsáid.

Don sampla seo, aistróimid bailiúchán de hashes MD5 chun PBKDF2 (MD5 (pasfhocal) a úsáid agus cuirfimid an hasher pasfhocal comhfhreagrach le seiceáil an chuir úsáideoir an bhféadfadh úsáideoir an focal faire ceart isteach ar logáil isteach. Glacaimid leis go bhfuilimid ag úsáid an tsamhail ```Úsáideoir ``ionsuite agus go bhfuil aip ``cuntas``` ag ár dtionscadal. Is féidir leat an patrún a mhodhnú chun oibriú le haon algartam nó le samhail úsáideora saincheaptha.

Ar dtús, cuirfimid an hasher saincheaptha leis:

*`accounts/hashers.py`*

```python
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)
```

D'fhéadfadh go mbeadh cuma ar an imirce sonraí mar:

*`cuntas/imirceach/0002_migrate_md5_passwords.py`*

```python
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),
    ]
```

Bí ar an eolas go dtógfaidh an imirce seo ar ord cúpla nóiméad do roinnt mílte úsáideoir, ag brath ar luas do chrua-earraí.

Faoi dheireadh, cuirfimid suíomh a:setting: PASSWORD\_HASHERS leis:

*`mysite/settings.py`*

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

Cuir aon hashers eile a úsáideann do shuíomh sa liosta seo san áireamh.

### Hashers san áireamh

Is é an liosta iomlán de hashers atá san áireamh i Django:

```
[
    "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",
]
```

Is iad na hainmneacha algartam comhfhreagrach

- `pbkdf2_sha256`
- `pbkdf2_sha1`
- `Argon2`
- `bcrypt_sha256`
- `bcrypt`
- `scrípt`
- `md5`

### Do hasher féin a scríobh

Má scríobhann tú do phasfhocal féin ina bhfuil fachtóir oibre cosúil le roinnt athraithe, ba cheart duit modh harden\_runtime (self, password, ionchódaithe) a chur i bhfeidhm chun an bearna réamhshocraithe idir an fachtóir oibre a sholáthraítear sa phasfhocal encoded agus fachtóir oibre réamhshocraithe an hasher. Cuireann sé seo cosc ar ionsaí uainiúcháin áireamh úsáideora mar gheall ar difríocht idir iarratas logála isteach d'úsáideoir le pasfhocal atá ionchódaithe i líon níos sine athrá agus úsáideoir nach bhfuil ann (a ritheann líon réamhshocraithe athraithe an hasher réamhshocraithe).

Ag glacadh le PBKDF2 mar shampla, má tá 20,000 athraitheach sa ```encoded ``agus is é 30,000 réamhshocraithe an hasher, ba chóir don modh ``pasfhocal``` a reáchtáil trí 10,000 athrú eile de PBKDF2.

Mura bhfuil fachtóir oibre ag do hasher, cuir an modh i bhfeidhm mar no-op (pass ).

## Pasfhocal úsáideora a bhainistiú de láimh

Soláthraíonn an modúl:MOD: django.contrib.auth.hashers sraith feidhmeanna chun pasfhocail hashaithe a chruthú agus a bhailíochtú. Is féidir leat iad a úsáid go neamhspleách ón tsamhail Úsáideoir .

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

#### `acheck_password(password, encoded, asetter=None, preferred='default')`

*Leagan asincrón*: acheck\_password () \`\`

If you'd like to manually authenticate a user by comparing a plaintext
password to the hashed password in the database, use the convenience
function [`check_password()`](#django.contrib.auth.hashers.check_password). It takes two mandatory arguments: the
plaintext 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
[Hashers san áireamh](#auth-included-hashers) 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 plaintext password (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 [Hashers san áireamh](#auth-included-hashers) 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()`](#django.contrib.auth.hashers.check_password)).

#### `is_password_usable(encoded_password)`

Filleann `False` má tá an pasfhocal mar thoradh ar:meth: .user.set\_unusable\_password.

## Bailíochtú pasfhocal

Is minic a roghnaíonn úsáideoirí pasfhocail Chun cabhrú leis an bhfadhb seo a mhaolú, cuireann Django bailíochtú pasfhocal plugáilte ar fáil Is féidir leat bailíochtóirí pasfhocal iolracha a chumrú ag an am céanna. Tá cúpla bailíochtóir san áireamh i Django, ach is féidir leat do chuid féin a scríobh freisin.

Caithfidh gach bailíochtóir pasfhocal téacs cabhrach a sholáthar chun na riachtanais a mhíniú don úsáideoir, pasfhocal ar leith a bhailíochtú agus teachtaireacht earráide a thabhairt ar ais mura gcomhlíonann sé na riachtanais, agus glaoch ar ais a shainiú go roghnach a chuirfear in iúl nuair a athraítear an focal faire d'úsáideoir. Is féidir le bailíochtóirí socruithe roghnacha a bheith acu freisin chun a n-iompar a mhíniú.

Tá bailíochtú á rialú ag an socrú: setting: AUTH\_PASSWORD\_VALIDATORS. Is é liosta folamh an réamhshocraithe don socrú, rud a chiallaíonn nach gcuirtear aon bhailíochtóirí i bhfeidhm. I dtionscadail nua a cruthaíodh leis an teimpléad réamhshocraithe: djadmin: startproject, cumasaítear tacar bailíochtóirí de réir réamhshocraithe.

De réir réamhshocraithe, úsáidtear bailíochtóirí sna foirmeacha chun pasfhocail a athshocrú nó a athrú agus sna horduithe bainistíochta: djadmin: createsuperuser agus:djadmin: changepassword. Ní chuirtear bailíochtóirí i bhfeidhm ag an leibhéal samhail, mar shampla in User.objects.create\_user () agus create\_superuser () , toisc go nglacaimid leis go n-idirghníomhaíonn forbróirí, ní úsáideoirí, le Django ag an leibhéal sin agus freisin toisc nach ritheann bailíochtú samhail go huathoibríoch mar chuid de mhúnlaí a chruthú.

> **Note**
>
> Is féidir le bailíochtú pasfhocal cosc a chur ar úsáid go leor cineálacha pasfhocail laga. Mar sin féin, ní ráthaíonn an fíric go dtéann pasfhocal ar na bailíochtóirí go léir gur pasfhocal láidir é. Tá go leor fachtóirí ann a d'fhéadfadh pasfhocal a lagú nach féidir fiú na bailíochtóirí pasfhocal is úire a bhrath.

### Cumasú bailíochtú pasfhocal

Tá bailíochtú pasfhocal cumraithe sa socrú:: 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",
    },
]
```

Cumasaíonn an sampla seo na ceithre bhailíochtóirí san áireamh

- `UserAttributeSimilarityValidator`, a sheiceálann an chosúlacht idir an pasfhocal agus sraith tréithe an úsáideora.
- `MinimumLengthValidator`, a sheiceálann an gcomhlíonann an pasfhocal fad íosta. Tá an bailíochtóir seo cumraithe le rogha saincheaptha: éilíonn sé anois go mbeadh an fad íosta ná naoi charachtar, in ionad na hocht réamhshocraithe.
- `CommonPasswordValidator`, a sheiceálann an dtarlaíonn an pasfhocal i liosta de phasfhocail choitianta. De réir réamhshocraithe, déanann sé comparáid le liosta san áireamh de 20,000 pasfhocal coitianta.
- `NumericPasswordValidator`, a sheiceálann an bhfuil an pasfhocal uimhriúil go hiomlán.

Maidir le `UserAttributeSimilarityValidator` agus `CommonPasswordValidator`, táimid ag úsáid na socruithe réamhshocraithe sa sampla seo. Níl aon socruithe ag `NumericPasswordValidator`.

Cuirtear na téacsanna cabhrach agus aon earráidí ó bhailíochtóirí pasfhocal ar ais i gcónaí san ord a liostaítear ion:setting: AUTH\_PASSWORD\_VALIDATORS.

### Bailíochtóirí san áireamh

Cuimsíonn Django ceithre bhailíochtóir:

#### `class MinimumLengthValidator(min_length=8)`

Bailíonn sé go bhfuil an pasfhocal ar fad íosta. Is féidir an fad íosta a shaincheapadh leis an bparaiméadar min\_length .

#### `get_error_message()`

> **New in Django 5.2**

A hook for customizing the `ValidationError` error message. Defaults
to `"This password is too short. It must contain at least <min_length>
characters."`.

#### `get_help_text()`

A hook for customizing the validator's help text. Defaults to `"Your
password must contain at least <min_length> characters."`.

#### `class UserAttributeSimilarityValidator(user_attributes=DEFAULT_USER_ATTRIBUTES, max_similarity=0.7)`

Bailíonn sé go bhfuil an pasfhocal difriúil go leor ó thréithe áirithe an úsáideora.

Ba chóir go mbeadh an paraiméadar `user_attributes` ina athraitheach d'ainmneacha tréithe úsáideora le comparáid a dhéanamh leo. Mura gcuirtear an argóint seo ar fáil, úsáidtear an réamhshocrú: ``` ``ainm úsáideora', 'first_name', 'last _name', 'r-phost' ```. Déantar neamhaird ar thréithe nach bhfuil ann.

Is féidir an cosúlacht uasta ceadaithe de phasfhocail a shocrú ar scála 0.1 go 1.0 leis an bparaiméadar `max_similarity`. Déantar é seo i gcomparáid leis an toradh ar:meth: Difflib.sequencematcher.quick\_ratio. Diúltaíonn luach 0.1 do phasfhocail mura bhfuil siad difriúil go suntasach ón `user_attributes`, ach ní dhiúltaíonn luach 1.0 ach pasfhocail atá comhionann le luach tréithe.

#### `get_error_message()`

> **New in Django 5.2**

A hook for customizing the `ValidationError` error message. Defaults
to `"The password is too similar to the <user_attribute>."`.

#### `get_help_text()`

A hook for customizing the validator's help text. Defaults to `"Your
password can’t be too similar to your other personal information."`.

#### `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 passwords created by [Royce Williams](https://gist.github.com/roycewilliams/226886fd01572964e1431ac8afc999ce).

Is féidir an password\_list\_path\` a shocrú go cosán comhad saincheaptha de phasfhocail choitianta. Ba chóir go mbeadh pasfhocal beaga amháin in aghaidh an líne sa chomhad seo agus d'fhéadfadh sé go mbeadh sé téacs simplí nó gzipped.

#### `get_error_message()`

> **New in Django 5.2**

A hook for customizing the `ValidationError` error message. Defaults
to `"This password is too common."`.

#### `get_help_text()`

A hook for customizing the validator's help text. Defaults to `"Your
password can’t be a commonly used password."`.

#### `class NumericPasswordValidator`

Bailíochtaigh nach bhfuil an pasfhocal uimhriúil go hiomlán.

#### `get_error_message()`

> **New in Django 5.2**

A hook for customizing the `ValidationError` error message. Defaults
to `"This password is entirely numeric."`.

#### `get_help_text()`

A hook for customizing the validator's help text. Defaults to `"Your
password can’t be entirely numeric."`.

### Bailíochtú a chomhth

Tá cúpla feidhm i `django.contrib.auth.password_validation` ar féidir leat glaoch a ghlaoch ó d'fhoirmeacha féin nó ó chód eile chun bailíochtú pasfhocal a chomhtháthú. Is féidir leis seo a bheith úsáideach má úsáideann tú foirmeacha saincheaptha le haghaidh socrú pasfhocal, nó má tá glaonna API agat a cheadaíonn pasfhocail a shocrú, mar shampla.

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

Bailíonn sé pasfhocal. Má aimsíonn gach bailíochtóir an pasfhocal bailí, filleann sé `None`. Má dhiúltaíonn bailíochtóirí amháin nó níos mó don phasfhocal, ardaíonn sé a:exc: ~django.core.exceptions.validationError leis na teachtaireachtaí earráide go léir ó na bailíochtóirí.

Tá an réad úsáideoir roghnach: mura gcuirtear ar fáil é, b'fhéidir nach mbeidh roinnt bailíochtóirí in ann aon bhailíochtú a dhéanamh agus glacfaidh siad le haon phasfhocal.

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

Cuireann gach bailíochtóir ar an eolas go bhfuil an pasfhocal athraithe. Is féidir le bailíochtóirí mar cheann a chuireann cosc ar athúsáid pasfhocal é seo a úsáid. Ba chóir é seo a ghlaoch nuair a athraítear an pasfhocal go rathúil.

Maidir le fo-aicmí de:class: ~Django.Contrib.Auth.Models.AbstractBaseUser, marcálfar an réimse pasfhocal mar “salach” agus tú ag glao:meth: ~django.contrib.auth.models.abstractBaseUser.set\_password a spreagann glao ar password\_modified () tar éis an úsáideoir a shábháil.

#### `password_validators_help_texts(password_validators=None)`

Tugann sé liosta de théacsanna cabhrach na mbailíochtóirí go léir ar ais. Míníonn siad seo na riachtanais phasfhocal don úsáideoir.

#### `password_validators_help_text_html(password_validators=None)`

Tugann teaghrán HTML ar ais le gach téacs cabhrach i \<ul\>\`\`\`. Tá sé seo cabhrach agus bailíochtú pasfhocal á chur le foirmeacha, mar is féidir leat an t-aschur a chur go díreach chuig paraiméadar `help_text` réimse foirme.

#### `get_password_validators(validator_config)`

Tugann sé tacar rudaí bailíochtaithe ar ais bunaithe ar an bparaiméadar `validator_config`. De réir réamhshocraithe, úsáideann gach feidhm na bailíochtóirí atá sainmhínithe in:setting: AUTH\_PASSWORD\_VALIDATORS, ach tríd an bhfeidhm seo a ghlaoch le tacar malartach bailíochtóirí agus ansin an toradh a chur isteach i bparaiméadar password\_validators na feidhmeanna eile, úsáidfear do shraith saincheaptha bailíochtóirí ina ionad. Tá sé seo úsáideach nuair a bhíonn tipiciúil tacar bailíochtóirí agat le húsáid don chuid is mó de na cásanna, ach tá cás speisialta agat freisin a éilíonn tacar saincheaptha. Má úsáideann tú an tacar bailíochtóirí céanna i gcónaí, ní gá an fheidhm seo a úsáid, mar úsáidtear an chumraíocht ó:setting: AUTH\_PASSWORD\_VALIDATORS de réir réamhshocraithe.

Tá struchtúr `validator_config` comhionann leis an struchtúr de:setting: AUTH\_PASSWORD\_VALIDATORS. Is féidir luach tuairisceáin na feidhme seo a chur isteach i bparaiméadar password\_validators de na feidhmeanna atá liostaithe thuas.

Tabhair faoi deara, nuair a chuirtear an focal faire chuig ceann de na feidhmeanna seo, ba cheart gurb é seo an pasfhocal téacs soiléir i gcónaí - ní pasfhocal hashed.

### Do bhailíochtóir féin a scríobh

Mura leor bailíochtóirí ionsuite Django, is féidir leat do bhailíochtóirí pasfhocal féin a scríobh. Tá comhéadan measartha beag ag bailíochtóirí. Ní mór dóibh dhá mhodh a chur chun feidhme:

- ```bailíochtú (féin, pasfhocal, úsáideoir = níl aon duine) ``: bailíochtú pasfhocal. Cuir ar ais ``None``` má tá an pasfhocal bailí, nó ardaigh a:exc: ~django.core.exceptions.validationError le teachtaireacht earráide mura bhfuil an pasfhocal bailí. Caithfidh tú a bheith in ann déileáil le ```` `úsáideoir ```None ```` \- más ciallaíonn sé sin nach féidir le do bhailíochtóir rith, filleadh `None` ar ais gan aon earráid.
- get\_help\_text () : téacs cabhrach a sholáthar chun na riachtanais a mhíniú don úsáideoir.

Cuirfear aon earraí sa OPTIONS\` in:setting: AUTH\_PASSWORD\_VALIDATORS do bhailíochtaitheoir chuig an tógálaí. Ba chóir go mbeadh luach réamhshocraithe ag gach argóint tógá

Seo sampla bunúsach de bhailíochtóir, le socrú roghnach amháin:

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

Is féidir leat `password_changes (password, user=none`) a chur i bhfeidhm freisin, a ghlaofar tar éis athrú pasfhocal rathúil. Is féidir é sin a úsáid chun athúsáid pasfhocal a chosc, mar shampla. Mar sin féin, má shocraíonn tú pasfhocail úsáideora roimhe seo a stóráil, níor cheart duit é sin a dhéanamh riamh i dtéacs soiléir.