---
title: "Djangoの認証システムを使用する"
version: 3.2
locale: ja
source: https://docs.djangoproject.com/ja/3.2/topics/auth/default/
canonical: https://djangodocs.dev/ja/3.2/topics/auth/default/
---
# Djangoの認証システムを使用する

このドキュメントでは、デフォルト設定でのDjangoの認証システムの使用方法を説明します。この設定は、タスクの適切な範囲を管理することで、最も一般的なプロジェクトのニーズにかなうよう徐々に発展してきました。そして、パスワードや権限の入念な実装を持っています。デフォルトの認証システムからの変更が必要なプロジェクトのために、Djangoは認証システムの広範囲の [拡張とカスタマイズ](/ja/3.2/topics/auth/customizing/) をサポートします。

Djangoの認証は、認証機能と権限機能の両方を共に提供しています。そして、一般的に、これらの機能を合わせて認証システムと呼びます。

## `User` オブジェクト

[`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) オブジェクトは、認証システムの中核です。一般的に、このオブジェクトはあなたのサイトに関係する人々を表し、アクセスを制限すること、ユーザ情報を登録すること、コンテンツを作成者と関連付けることを可能にする際などに利用されます。
Djangoの認証フレームワークにはUserクラスという、ただひとつのクラスのみが存在します。すなわち、 [`'superusers'`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.is_superuser) または admin [`'staff'`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.is_staff) ユーザは、Userオブジェクトと異なるクラスではなく、特別な属性セットを持ったUserオブジェクトなのです。

デフォルトのユーザの主要な属性は次のとおりです。

- [`username`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.username)
- [`password`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.password)
- [`email`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.email)
- [`first_name`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.first_name)
- [`last_name`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.last_name)

仕様については [`full API documentation`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) を参照してください。 以下のドキュメントは、よりタスク指向の形式となっています。

### ユーザを作成する

ユーザを作成するための最も直接的な方法は、組み込まれている [`create_user()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.UserManager.create_user) というヘルパー関数を利用することです。

```
>>> from django.contrib.auth.models import User
>>> user = User.objects.create_user('john', 'lennon@thebeatles.com', 'johnpassword')

# At this point, user is a User object that has already been saved
# to the database. You can continue to change its attributes
# if you want to change other fields.
>>> user.last_name = 'Lennon'
>>> user.save()
```

すでにDjango adminをインストールしている場合は、 [インタラクティブにユーザを作成する](#auth-admin) こともできます。

### スーパーユーザを作成する

Create superusers using the [`createsuperuser`](/ja/3.2/ref/django-admin/#django-admin-createsuperuser) command:

```
$ python manage.py createsuperuser --username=joe --email=joe@example.com
```

パスワードを入力するように促されます。入力後、ただちにユーザが作成されます。 [`--username`](/ja/3.2/ref/django-admin/#cmdoption-createsuperuser-username) または [`--email`](/ja/3.2/ref/django-admin/#cmdoption-createsuperuser-email) オプションを使用しなければ、これらの値を入力するように促されます。

### パスワードを変更する

Djangoはユーザモデルに未加工の (単なるテキストの) パスワードは保存せず、ハッシュ値でのみ保存します (詳細は、[パスワードは管理方法に関するドキュメント](/ja/3.2/topics/auth/passwords/) を参照してください)。したがって、ユーザのパスワード属性を直接操作しないでください。これが、ユーザを作成する際にヘルパー関数を使用する理由です。

ユーザのパスワードを変更するには、いくつかのオプションがあります。

[`manage.py changepassword *username*`](/ja/3.2/ref/django-admin/#django-admin-changepassword) は、コマンドラインからユーザのパスワードを変更する方法を提供します。ユーザのパスワードを変更するよう促されたら、パスワードを 2 回入力してください。2 つのパスワードが一致した場合、新しいパスワードが直ちに有効になります。ユーザを指定しない場合、コマンドは、現在のシステムユーザとユーザ名が一致するユーザのパスワードを変更するよう試みます。

[`set_password()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.set_password) を使用することで、プログラムでパスワードを変更することもできます:

```pycon
>>> from django.contrib.auth.models import User
>>> u = User.objects.get(username='john')
>>> u.set_password('new password')
>>> u.save()
```

Django admin がインストールされていれば、 [認証システムのadminページ](#auth-admin) にて、ユーザのパスワードを変更することも可能です。

また、Djangoはユーザ自身のパスワードを変更するための [ビュー](#built-in-auth-views) と [フォーム](#built-in-auth-forms) を提供します。

ユーザーのパスワード変更を行う事とそのユーザーのセッションは全てログアウトされます。詳細は [Session invalidation on password change](#session-invalidation-on-password-change) を参照してください。

### ユーザを認証する

#### `authenticate(request=None, **credentials)`

認証情報のセットを検証するには [`authenticate()`](#django.contrib.auth.authenticate) を利用してください。このメソッドは認証情報をキーワード引数として受け取ります。検証する対象はデフォルトでは `username` と `password` であり、その組み合わせを個々の [認証バックエンド](/ja/3.2/topics/auth/customizing/#authentication-backends) に対して問い合わせ、認証バックエンドで認証情報が有効とされれば [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) オブジェクトを返します。もしいずれの認証バックエンドでも認証情報が有効と判定されなければ [`PermissionDenied`](/ja/3.2/ref/exceptions/#django.core.exceptions.PermissionDenied) が送出され、`None` が返されます。以下は実装例です:

```
from django.contrib.auth import authenticate
user = authenticate(username='john', password='secret')
if user is not None:
    # A backend authenticated the credentials
else:
    # No backend authenticated the credentials
```

`request` はオプションで、[`HttpRequest`](/ja/3.2/ref/request-response/#django.http.HttpRequest) のインスタンスを取ります。このインスタンスは認証バックエンドの `authenticate()` メソッドに渡されます。

> **Note**
>
> This is a low level way to authenticate a set of credentials; for
> example, it's used by the
> [`RemoteUserMiddleware`](/ja/3.2/ref/middleware/#django.contrib.auth.middleware.RemoteUserMiddleware). Unless
> you are writing your own authentication system, you probably won't use
> this. Rather if you're looking for a way to login a user, use the
> [`LoginView`](#django.contrib.auth.views.LoginView).

## 権限と認可

Django comes with a built-in permissions system. It provides a way to assign
permissions to specific users and groups of users.

これは、Djangoのadminサイトでも使われていますが、独自のコード内でも自由に使えます。

Djangoのadminサイトは、次のように権限を使用します：

- Access to view objects is limited to users with the "view" or "change"
  permission for that type of object.
- "追加"フォームのビューにアクセスし、オブジェクトの追加をすることは、そのオブジェクトの型への"追加"権限を持つユーザに限定されています。
- 変更リストを表示し、"変更"フォームを表示し、オブジェクトを変更することは、そのオブジェクトの型への"変更"権限を持つユーザーに限定されています。
- オブジェクトを削除することは、そのオブジェクトの型への"削除"権限を持つユーザに限定されています。

Permissions can be set not only per type of object, but also per specific
object instance. By using the
[`has_view_permission()`](/ja/3.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.has_view_permission),
[`has_add_permission()`](/ja/3.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.has_add_permission),
[`has_change_permission()`](/ja/3.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.has_change_permission) and
[`has_delete_permission()`](/ja/3.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin.has_delete_permission) methods provided
by the [`ModelAdmin`](/ja/3.2/ref/contrib/admin/#django.contrib.admin.ModelAdmin) class, it is possible to
customize permissions for different object instances of the same type.

[`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) オブジェクトは 2 つの多対多のフィールド、`groups` および `user_permissions` を持っています。他の [Django におけるモデル](/ja/3.2/topics/db/models/) で行えるのと同様に [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) オブジェクトは関連を持っているオブジェクトにアクセスできます:

```
myuser.groups.set([group_list])
myuser.groups.add(group, group, ...)
myuser.groups.remove(group, group, ...)
myuser.groups.clear()
myuser.user_permissions.set([permission_list])
myuser.user_permissions.add(permission, permission, ...)
myuser.user_permissions.remove(permission, permission, ...)
myuser.user_permissions.clear()
```

### デフォルトの権限

When `django.contrib.auth` is listed in your [`INSTALLED_APPS`](/ja/3.2/ref/settings/#std-setting-INSTALLED_APPS)
setting, it will ensure that four default permissions -- add, change, delete,
and view -- are created for each Django model defined in one of your installed
applications.

これらの権限は [`manage.py migrate`](/ja/3.2/ref/django-admin/#django-admin-migrate) 実行時に作成されます。[`INSTALLED_APPS`](/ja/3.2/ref/settings/#std-setting-INSTALLED_APPS) に `django.contrib.auth` を追加後初めての `migrate` を実行した場合は、新たにインストールされるモデルに対してと同様、それまでに作成されたモデルに対してもデフォルトの権限が作成されます。以後 [`manage.py migrate`](/ja/3.2/ref/django-admin/#django-admin-migrate) (この権限を作成する関数は [`post_migrate`](/ja/3.2/ref/signals/#django.db.models.signals.post_migrate) シグナルに接続されています)を実行する度作成されるモデルに対してデフォルトの権限が作成されます。

[`app_label`](/ja/3.2/ref/models/options/#django.db.models.Options.app_label) が `foo` でモデルが `Bar` であるアプリケーションを想定し、デフォルトの権限を試すには以下を利用する必要が有ります:

- 追加: `user.has_perm('foo.add_bar')`
- 変更: `user.has_perm('foo.change_bar')`
- 削除: `user.has_perm('foo.delete_bar')`
- view: `user.has_perm('foo.view_bar')`

[`Permission`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.Permission) モデルに対して直接アクセスする事はほぼ有りません。

### グループ

[`django.contrib.auth.models.Group`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.Group) モデルはユーザーを分類する一般的な方法で、対象となるユーザーに権限や、何らかの分類名を付けることが可能となります。個々のユーザーは複数のグループに属する事ができます。

グループに属するユーザーは、そのグループに対して許可されている権限を自動的に持つ事になります。例えば、`Site editors` グループが `can_edit_home_page` 権限を持っていた場合、そのグループに属する全てのユーザーはその権限を持つ事になります。

権限の管理に限らず、グループはユーザーに何らかの分類名や、拡張された機能を付与する上で有用です。例えば `Special users` というグループを作成して、そのグループのメンバーに対してサイトのメンバー限定の領域にアクセスする権限を付与したり、メンバー限定のメールを送るコードを書いたりする事も可能なのです。

### プログラムによる権限作成

[カスタム権限](/ja/3.2/topics/auth/customizing/#custom-permissions) はモデルの `Meta` クラス内に定義され、直接作成する事も可能です。例えば、`myapp` 内の `BlogPost` モデルに対する権限 `can_publish` は下記のように作成する事ができます:

```
from myapp.models import BlogPost
from django.contrib.auth.models import Permission
from django.contrib.contenttypes.models import ContentType

content_type = ContentType.objects.get_for_model(BlogPost)
permission = Permission.objects.create(
    codename='can_publish',
    name='Can Publish Posts',
    content_type=content_type,
)
```

この権限は `user_permissions` 属性を介して [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) に、あるいは `permissions` 属性を介して [`Group`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.Group) に割り当てられます。

> **Proxy models need their own content type**
>
> If you want to create [permissions for a proxy model](#proxy-models-permissions-topic), pass `for_concrete_model=False` to
> [`ContentTypeManager.get_for_model()`](/ja/3.2/ref/contrib/contenttypes/#django.contrib.contenttypes.models.ContentTypeManager.get_for_model) to get the appropriate
> `ContentType`:
>
> ```
> content_type = ContentType.objects.get_for_model(BlogPostProxy, for_concrete_model=False)
> ```

### 権限のキャッシュ

[`ModelBackend`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.backends.ModelBackend) はユーザーオブジェクトが権限の確認のため最初に要求した情報をキャッシュします。この仕組みはリクエスト-レスポンスのサイクルの中では(例えば管理機能によって)通常の場合、権限が付与されてから直ちに権限の確認が生じる事が無いため大抵の場合問題がありません。もし権限を付与した後直ちに権限の確認を行う場合、テストあるいは認証をビューで例示する場合等、最も簡単な解決手段はデータベースから再度ユーザーの情報を取得する事です。以下は実装例です:

```
from django.contrib.auth.models import Permission, User
from django.contrib.contenttypes.models import ContentType
from django.shortcuts import get_object_or_404

from myapp.models import BlogPost

def user_gains_perms(request, user_id):
    user = get_object_or_404(User, pk=user_id)
    # any permission check will cache the current set of permissions
    user.has_perm('myapp.change_blogpost')

    content_type = ContentType.objects.get_for_model(BlogPost)
    permission = Permission.objects.get(
        codename='change_blogpost',
        content_type=content_type,
    )
    user.user_permissions.add(permission)

    # Checking the cached permission set
    user.has_perm('myapp.change_blogpost')  # False

    # Request new instance of User
    # Be aware that user.refresh_from_db() won't clear the cache.
    user = get_object_or_404(User, pk=user_id)

    # Permission cache is repopulated from the database
    user.has_perm('myapp.change_blogpost')  # True

    ...
```

### プロキシモデル

Proxy models work exactly the same way as concrete models. Permissions are
created using the own content type of the proxy model. Proxy models don't
inherit the permissions of the concrete model they subclass:

```
class Person(models.Model):
    class Meta:
        permissions = [('can_eat_pizzas', 'Can eat pizzas')]

class Student(Person):
    class Meta:
        proxy = True
        permissions = [('can_deliver_pizzas', 'Can deliver pizzas')]

>>> # Fetch the content type for the proxy model.
>>> content_type = ContentType.objects.get_for_model(Student, for_concrete_model=False)
>>> student_permissions = Permission.objects.filter(content_type=content_type)
>>> [p.codename for p in student_permissions]
['add_student', 'change_student', 'delete_student', 'view_student',
'can_deliver_pizzas']
>>> for permission in student_permissions:
...     user.user_permissions.add(permission)
>>> user.has_perm('app.add_person')
False
>>> user.has_perm('app.can_eat_pizzas')
False
>>> user.has_perms(('app.add_student', 'app.can_deliver_pizzas'))
True
```

## Web のリクエストにおける認証

Django は [`リクエストオブジェクト`](/ja/3.2/ref/request-response/#django.http.HttpRequest) に対して認証システムを接続させるのに [セッション](/ja/3.2/topics/http/sessions/) とミドルウェアを利用します。

それらは現在のユーザーを示す [`request.user`](/ja/3.2/ref/request-response/#django.http.HttpRequest.user) 属性を付与します。もしユーザーが現在ログインしていない場合、この属性には [`AnonymousUser`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.AnonymousUser) のインスタンスが、ログインしている場合は [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) のインスタンスがセットされます。

この二者は [`is_authenticated`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.is_authenticated) を用いて次のように識別する事ができます:

```
if request.user.is_authenticated:
    # Do something for authenticated users.
    ...
else:
    # Do something for anonymous users.
    ...
```

### ユーザーをログインさせるには

現在のセッションにおいて認証を有効としたいユーザーがいる場合 - [`login()`](#django.contrib.auth.login) 関数によってそれを行う事ができます。

#### `login(request, user, backend=None)`

あるユーザーをログインさせる場合は、[`login()`](#django.contrib.auth.login) を利用してください。この関数は [`HttpRequest`](/ja/3.2/ref/request-response/#django.http.HttpRequest) オブジェクトと [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) オブジェクトを受け取ります。[`login()`](#django.contrib.auth.login) は Django のセッションフレームワークを利用して、ユーザーのセッション中での ID を保持します。

匿名ユーザーとしてのセッション中にセットされたデータが、ログイン後も継続して利用できる事に注意してください。

以下の例では [`authenticate()`](#django.contrib.auth.authenticate) および [`login()`](#django.contrib.auth.login) をどのように用いるかを示します:

```
from django.contrib.auth import authenticate, login

def my_view(request):
    username = request.POST['username']
    password = request.POST['password']
    user = authenticate(request, username=username, password=password)
    if user is not None:
        login(request, user)
        # Redirect to a success page.
        ...
    else:
        # Return an 'invalid login' error message.
        ...
```

#### 認証バックエンドの選択

ユーザーがログインする際、そのユーザーの ID と認証時に用いた認証バックエンドはセッション中保持されます。その仕組みによって、ユーザーの詳細情報を取得するリクエストが発生した場合に同じ [認証バックエンド](/ja/3.2/topics/auth/customizing/#authentication-backends) を利用できます。セッション中に保持される認証バックエンドは下記の手順を経て選択されます:

1. 省略可能な `backend` 引数が与えられている場合は利用します。
2. 存在すれば属性 `user.backend` の値を利用する。[`authenticate()`](#django.contrib.auth.authenticate) は返すユーザーオブジェクトに属性値 `user.backend` を付与するので、[`authenticate()`](#django.contrib.auth.authenticate) と [`login()`](#django.contrib.auth.login) とで連携を図ることができる。
3. ただ一つだけ設定が存在すれば [`AUTHENTICATION_BACKENDS`](/ja/3.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS) の `backend` を利用する。
4. いずれにも該当しなかった場合、例外が送出される。

1 もしくは 2 においては、引数 `backend` あるいは属性値 `user.backend` は([`AUTHENTICATION_BACKENDS`](/ja/3.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS) で定義されているのと同様に)ドット付きのインポート先を示すパスの文字列でなければなりません。

### ユーザーをログアウトさせるには

#### `logout(request)`

[`django.contrib.auth.login()`](#django.contrib.auth.login) を利用してログインしたユーザーをログアウトさせるためには、[`django.contrib.auth.logout()`](#django.contrib.auth.logout) をビューの中で利用してください。この関数は [`HttpRequest`](/ja/3.2/ref/request-response/#django.http.HttpRequest) オブジェクトを受け取り、値を返しません。実装例は下記のようになります:

```
from django.contrib.auth import logout

def logout_view(request):
    logout(request)
    # Redirect to a success page.
```

[`logout()`](#django.contrib.auth.logout) は対象となるユーザーが最初からログインしていなかった場合でも例外を送出しない事に注意してください。

[`logout()`](#django.contrib.auth.logout) を呼び出すと、現在処理しているリクエストに対応したセッション情報は完全に破棄されます。その時点までに存在している全てのデータが削除されます。これは、別の人物が同じウェブブラウザを利用してログインし、前のユーザーのセッションにアクセスして使用してしまう事態を防ぐためです。ログアウトした直後でも利用できる何らかの情報をセッションに保存したい場合は、[`django.contrib.auth.logout()`](#django.contrib.auth.logout) を呼び出した *後* に行ってください。

### ログインしているユーザーにアクセスを制限する

#### 原理的な方法

The raw way to limit access to pages is to check
[`request.user.is_authenticated`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.is_authenticated) and either redirect to a
login page:

```
from django.conf import settings
from django.shortcuts import redirect

def my_view(request):
    if not request.user.is_authenticated:
        return redirect('%s?next=%s' % (settings.LOGIN_URL, request.path))
    # ...
```

もしくはエラーメッセージを出力します。

```
from django.shortcuts import render

def my_view(request):
    if not request.user.is_authenticated:
        return render(request, 'myapp/login_error.html')
    # ...
```

#### `login_required` デコレータ

#### `login_required(redirect_field_name='next', login_url=None)`

ショートカットとして、便利な [`login_required()`](#django.contrib.auth.decorators.login_required) デコレータを利用できます:

```
from django.contrib.auth.decorators import login_required

@login_required
def my_view(request):
    ...
```

[`login_required()`](#django.contrib.auth.decorators.login_required) は下記の処理を行います:

- もしユーザがログインしていなければ、[`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) にリダイレクトし、クエリ文字列に現在の絶対パスを渡します。リダイレクト先の例: `/accounts/login/?next=/polls/3/`
- もしユーザがログインしていれば、通常通りビューを処理します。ビューのコードの中ではユーザがログインしているかを意識しなくて良いのです。

デフォルトでは、認証に成功したユーザがリダイレクトされる先のパスは `"next"` という名称のクエリパラメータに格納されています。もし異なるパラメータ名を利用したい場合、[`login_required()`](#django.contrib.auth.decorators.login_required) が `redirect_field_name` という省略可能な引数を受け取ります:

```
from django.contrib.auth.decorators import login_required

@login_required(redirect_field_name='my_redirect_field')
def my_view(request):
    ...
```

`redirect_field_name` に値を持たせた場合、ログインテンプレートもカスタマイズする必要があるでしょう。これは、リダイレクト先のパスを格納しているテンプレートコンテキスト変数が、キーとして (デフォルトの) `"next"` でなく `redirect_field_name` の値を使用してしまうためです。

[`login_required()`](#django.contrib.auth.decorators.login_required) はまた省略可能な引数として `login_url` を受け取る事ができます。以下の例のように利用します:

```
from django.contrib.auth.decorators import login_required

@login_required(login_url='/accounts/login/')
def my_view(request):
    ...
```

`` `login_url` `` のパラメータを定義しない場合、[`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) が設定されかつログイン用ビューが適切に配置されている必要が有ります。例えば、デフォルトの設定を利用して下記の内容を URLconf に追加してください:

```
from django.contrib.auth import views as auth_views

path('accounts/login/', auth_views.LoginView.as_view()),
```

[`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) はまたビュー関数名と [命名された URL パターン](/ja/3.2/topics/http/urls/#naming-url-patterns) を受け付けます。この仕組みによって設定を更新することなく URLconf 内のログイン用ビューを再配置する事ができます。

> **Note**
>
> `login_required` デコレータはユーザーのフラグ `is_active` をチェックしませんが、デフォルトの [`AUTHENTICATION_BACKENDS`](/ja/3.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS) はアクティブでないユーザを拒否します。

> **See also**
>
> もし Django の管理画面にカスタマイズしたビューを実装している(あるいはビルトインのビューが利用しているのと同じ認証チェックが必要である)場合は、[`django.contrib.admin.views.decorators.staff_member_required()`](/ja/3.2/ref/contrib/admin/#django.contrib.admin.views.decorators.staff_member_required) デコレータが `login_required()` の代替として有用であるはずです。

#### `LoginRequired` mixin

[クラスベースのビュー](/ja/3.2/topics/class-based-views/) を使う際、 `LoginRequiredMixin` を使うことで `login_required` と同じ動作をさせることができます。 この mixin は、継承リストの一番左に記述される必要があります。

#### `class LoginRequiredMixin`

ビューがこの mixin を使う場合、認証されていないユーザによるすべてのリクエストは、ログインページにリダイレクトされるか、HTTP 403 Forbidden エラー表示となります。これは、[`raise_exception`](#django.contrib.auth.mixins.AccessMixin.raise_exception) パラメータにて設定します。

[`AccessMixin`](#django.contrib.auth.mixins.AccessMixin) のパラメータをセットすると、認証されていないユーザの管理をカスタムできます:

```
from django.contrib.auth.mixins import LoginRequiredMixin

class MyView(LoginRequiredMixin, View):
    login_url = '/login/'
    redirect_field_name = 'redirect_to'
```

> **Note**
>
> `login_required` デコレータと同様に、この mixin はユーザの `is_active` フラグをチェックしません。しかし、デフォルトの [`AUTHENTICATION_BACKENDS`](/ja/3.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS) が非アクティブのユーザを拒否します。

#### テストをパスしたログイン済みユーザのアクセスを制限する

To limit access based on certain permissions or some other test, you'd do
essentially the same thing as described in the previous section.

You can run your test on [`request.user`](/ja/3.2/ref/request-response/#django.http.HttpRequest.user) in
the view directly. For example, this view checks to make sure the user has an
email in the desired domain and if not, redirects to the login page:

```
from django.shortcuts import redirect

def my_view(request):
    if not request.user.email.endswith('@example.com'):
        return redirect('/login/?next=%s' % request.path)
    # ...
```

#### `user_passes_test(test_func, login_url=None, redirect_field_name='next')`

As a shortcut, you can use the convenient `user_passes_test` decorator
which performs a redirect when the callable returns `False`:

```
from django.contrib.auth.decorators import user_passes_test

def email_check(user):
    return user.email.endswith('@example.com')

@user_passes_test(email_check)
def my_view(request):
    ...
```

[`user_passes_test()`](#django.contrib.auth.decorators.user_passes_test) takes a required
argument: a callable that takes a
[`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) object and returns `True` if
the user is allowed to view the page. Note that
[`user_passes_test()`](#django.contrib.auth.decorators.user_passes_test) does not
automatically check that the [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) is
not anonymous.

[`user_passes_test()`](#django.contrib.auth.decorators.user_passes_test) takes two
optional arguments:

**`login_url`**

  Lets you specify the URL that users who don't pass the test will be
  redirected to. It may be a login page and defaults to
  [`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) if you don't specify one.

**`redirect_field_name`**

  Same as for [`login_required()`](#django.contrib.auth.decorators.login_required).
  Setting it to `None` removes it from the URL, which you may want to do
  if you are redirecting users that don't pass the test to a non-login
  page where there's no "next page".

例:

```
@user_passes_test(email_check, login_url='/login/')
def my_view(request):
    ...
```

#### `class UserPassesTestMixin`

When using [class-based views](/ja/3.2/topics/class-based-views/), you
can use the `UserPassesTestMixin` to do this.

#### `test_func()`

You have to override the `test_func()` method of the class to
provide the test that is performed. Furthermore, you can set any of the
parameters of [`AccessMixin`](#django.contrib.auth.mixins.AccessMixin) to
customize the handling of unauthorized users:

```
from django.contrib.auth.mixins import UserPassesTestMixin

class MyView(UserPassesTestMixin, View):

    def test_func(self):
        return self.request.user.email.endswith('@example.com')
```

#### `get_test_func()`

You can also override the `get_test_func()` method to have the mixin
use a differently named function for its checks (instead of
[`test_func()`](#django.contrib.auth.mixins.UserPassesTestMixin.test_func)).

> **UserPassesTestMixin を重ねる**
>
> Due to the way `UserPassesTestMixin` is implemented, you cannot stack
> them in your inheritance list. The following does NOT work:
>
> ```
> class TestMixin1(UserPassesTestMixin):
>     def test_func(self):
>         return self.request.user.email.endswith('@example.com')
>
> class TestMixin2(UserPassesTestMixin):
>     def test_func(self):
>         return self.request.user.username.startswith('django')
>
> class MyView(TestMixin1, TestMixin2, View):
>     ...
> ```
>
> If `TestMixin1` would call `super()` and take that result into
> account, `TestMixin1` wouldn't work standalone anymore.

#### `permission_required` デコレータ

#### `permission_required(perm, login_url=None, raise_exception=False)`

It's a relatively common task to check whether a user has a particular
permission. For that reason, Django provides a shortcut for that case: the
[`permission_required()`](#django.contrib.auth.decorators.permission_required) decorator.:

```
from django.contrib.auth.decorators import permission_required

@permission_required('polls.add_choice')
def my_view(request):
    ...
```

Just like the [`has_perm()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.has_perm) method,
permission names take the form `"<app label>.<permission codename>"`
(i.e. `polls.add_choice` for a permission on a model in the `polls`
application).

The decorator may also take an iterable of permissions, in which case the
user must have all of the permissions in order to access the view.

Note that [`permission_required()`](#django.contrib.auth.decorators.permission_required)
also takes an optional `login_url` parameter:

```
from django.contrib.auth.decorators import permission_required

@permission_required('polls.add_choice', login_url='/loginpage/')
def my_view(request):
    ...
```

As in the [`login_required()`](#django.contrib.auth.decorators.login_required) decorator,
`login_url` defaults to [`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL).

If the `raise_exception` parameter is given, the decorator will raise
[`PermissionDenied`](/ja/3.2/ref/exceptions/#django.core.exceptions.PermissionDenied), prompting [the 403
(HTTP Forbidden) view](/ja/3.2/ref/views/#http-forbidden-view) instead of redirecting to the
login page.

If you want to use `raise_exception` but also give your users a chance to
login first, you can add the
[`login_required()`](#django.contrib.auth.decorators.login_required) decorator:

```
from django.contrib.auth.decorators import login_required, permission_required

@login_required
@permission_required('polls.add_choice', raise_exception=True)
def my_view(request):
    ...
```

This also avoids a redirect loop when [`LoginView`](#django.contrib.auth.views.LoginView)'s
`redirect_authenticated_user=True` and the logged-in user doesn't have
all of the required permissions.

#### The `PermissionRequiredMixin` mixin

To apply permission checks to [class-based views](/ja/3.2/ref/class-based-views/), you can use the `PermissionRequiredMixin`:

#### `class PermissionRequiredMixin`

This mixin, just like the `permission_required`
decorator, checks whether the user accessing a view has all given
permissions. You should specify the permission (or an iterable of
permissions) using the `permission_required` parameter:

```
from django.contrib.auth.mixins import PermissionRequiredMixin

class MyView(PermissionRequiredMixin, View):
    permission_required = 'polls.add_choice'
    # Or multiple of permissions:
    permission_required = ('polls.view_choice', 'polls.change_choice')
```

You can set any of the parameters of
[`AccessMixin`](#django.contrib.auth.mixins.AccessMixin) to customize the handling
of unauthorized users.

You may also override these methods:

#### `get_permission_required()`

Returns an iterable of permission names used by the mixin. Defaults to
the `permission_required` attribute, converted to a tuple if
necessary.

#### `has_permission()`

Returns a boolean denoting whether the current user has permission to
execute the decorated view. By default, this returns the result of
calling [`has_perms()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.has_perms) with the
list of permissions returned by [`get_permission_required()`](#django.contrib.auth.mixins.PermissionRequiredMixin.get_permission_required).

### Redirecting unauthorized requests in class-based views

To ease the handling of access restrictions in [class-based views](/ja/3.2/ref/class-based-views/), the `AccessMixin` can be used to configure
the behavior of a view when access is denied. Authenticated users are denied
access with an HTTP 403 Forbidden response. Anonymous users are redirected to
the login page or shown an HTTP 403 Forbidden response, depending on the
[`raise_exception`](#django.contrib.auth.mixins.AccessMixin.raise_exception) attribute.

#### `class AccessMixin`

#### `login_url`

Default return value for [`get_login_url()`](#django.contrib.auth.mixins.AccessMixin.get_login_url).  Defaults to `None`
in which case [`get_login_url()`](#django.contrib.auth.mixins.AccessMixin.get_login_url) falls back to
[`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL).

#### `permission_denied_message`

Default return value for [`get_permission_denied_message()`](#django.contrib.auth.mixins.AccessMixin.get_permission_denied_message).
Defaults to an empty string.

#### `redirect_field_name`

Default return value for [`get_redirect_field_name()`](#django.contrib.auth.mixins.AccessMixin.get_redirect_field_name). Defaults to
`"next"`.

#### `raise_exception`

If this attribute is set to `True`, a
[`PermissionDenied`](/ja/3.2/ref/exceptions/#django.core.exceptions.PermissionDenied) exception is raised
when the conditions are not met.  When `False` (the default),
anonymous users are redirected to the login page.

#### `get_login_url()`

Returns the URL that users who don't pass the test will be redirected
to. Returns [`login_url`](#django.contrib.auth.mixins.AccessMixin.login_url) if set, or [`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) otherwise.

#### `get_permission_denied_message()`

When [`raise_exception`](#django.contrib.auth.mixins.AccessMixin.raise_exception) is `True`, this method can be used to
control the error message passed to the error handler for display to
the user. Returns the [`permission_denied_message`](#django.contrib.auth.mixins.AccessMixin.permission_denied_message) attribute by
default.

#### `get_redirect_field_name()`

Returns the name of the query parameter that will contain the URL the
user should be redirected to after a successful login. If you set this
to `None`, a query parameter won't be added. Returns the
[`redirect_field_name`](#django.contrib.auth.mixins.AccessMixin.redirect_field_name) attribute by default.

#### `handle_no_permission()`

Depending on the value of `raise_exception`, the method either raises
a [`PermissionDenied`](/ja/3.2/ref/exceptions/#django.core.exceptions.PermissionDenied) exception or
redirects the user to the `login_url`, optionally including the
`redirect_field_name` if it is set.

#### Session invalidation on password change

If your [`AUTH_USER_MODEL`](/ja/3.2/ref/settings/#std-setting-AUTH_USER_MODEL) inherits from
[`AbstractBaseUser`](/ja/3.2/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser) or implements its own
[`get_session_auth_hash()`](/ja/3.2/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash)
method, authenticated sessions will include the hash returned by this function.
In the [`AbstractBaseUser`](/ja/3.2/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser) case, this is an
HMAC of the password field. Django verifies that the hash in the session for
each request matches the one that's computed during the request. This allows a
user to log out all of their sessions by changing their password.

The default password change views included with Django,
[`PasswordChangeView`](#django.contrib.auth.views.PasswordChangeView) and the
`user_change_password` view in the [`django.contrib.auth`](/ja/3.2/topics/auth/#module-django.contrib.auth) admin, update
the session with the new password hash so that a user changing their own
password won't log themselves out. If you have a custom password change view
and wish to have similar behavior, use the [`update_session_auth_hash()`](#django.contrib.auth.update_session_auth_hash)
function.

#### `update_session_auth_hash(request, user)`

This function takes the current request and the updated user object from
which the new session hash will be derived and updates the session hash
appropriately. It also rotates the session key so that a stolen session
cookie will be invalidated.

使い方の例:

```
from django.contrib.auth import update_session_auth_hash

def password_change(request):
    if request.method == 'POST':
        form = PasswordChangeForm(user=request.user, data=request.POST)
        if form.is_valid():
            form.save()
            update_session_auth_hash(request, form.user)
    else:
        ...
```

> **Note**
>
> Since
> [`get_session_auth_hash()`](/ja/3.2/topics/auth/customizing/#django.contrib.auth.models.AbstractBaseUser.get_session_auth_hash)
> is based on [`SECRET_KEY`](/ja/3.2/ref/settings/#std-setting-SECRET_KEY), updating your site to use a new secret
> will invalidate all existing sessions.

### 認証の View

Django の提供する複数のビューを使って、ログイン、ログアウト、パスワード管理を行うことができます。これらは [ビルトインの認証フォーム](#built-in-auth-forms) を使用しますが、独自のフォームを使用することもできます。

認証ビューに対して、デフォルトのテンプレートはありません。使用したいビューのテンプレートを自分で作成する必要があります。テンプレートのコンテキストは各ビューに記述されています。 [すべての認証ビュー](#all-authentication-views) を参照してください。

#### ビューを使用する

プロジェクト内でこれらのビューを実装するには、いくつかの方法があります。最も簡単なのは、`django.contrib.auth.urls` で提供される URLconf をあなた独自の URLconf に含めることです。たとえば:

```
urlpatterns = [
    path('accounts/', include('django.contrib.auth.urls')),
]
```

これは以下の URL パターンを含みます:

```
accounts/login/ [name='login']
accounts/logout/ [name='logout']
accounts/password_change/ [name='password_change']
accounts/password_change/done/ [name='password_change_done']
accounts/password_reset/ [name='password_reset']
accounts/password_reset/done/ [name='password_reset_done']
accounts/reset/<uidb64>/<token>/ [name='password_reset_confirm']
accounts/reset/done/ [name='password_reset_complete']
```

これらのビューは、より簡単に参照できる URL 名を提供します. 名前付き URL パターンの詳細については、[URL ドキュメント](/ja/3.2/topics/http/urls/) をご覧ください。

URL をより詳細にコントロールしたい場合は、URLconf 内の特定のビューを指定することもできます:

```
from django.contrib.auth import views as auth_views

urlpatterns = [
    path('change-password/', auth_views.PasswordChangeView.as_view()),
]
```

これらのビューでは、挙動を操作するためのオプショナル引数を使えます。たとえば、ビューが参照するテンプレートの名前を変更したいときは、`template_name` 引数を指定します。引数指定の方法の 1 つは、URLconf 内でキーワード引数を渡すことです。指定した引数はビューに渡されます。たとえば:

```
urlpatterns = [
    path(
        'change-password/',
        auth_views.PasswordChangeView.as_view(template_name='change-password.html'),
    ),
]
```

すべてのビューは [クラスベース](/ja/3.2/topics/class-based-views/) なので、サブクラス化することで容易にカスタムできます。

#### すべての認証ビュー

以下は、`django.contrib.auth` が提供するすべてのビューのリストです。実装の詳細については、ビューを使う を参照してください。

#### `class LoginView`

**URL name:** `login`

名前付き URL パターンの使い方は、[URL ドキュメント](/ja/3.2/topics/http/urls/) をご覧ください。

**属性:**

- `template_name`: The name of a template to display for the view used to
  log the user in. Defaults to `registration/login.html`.
- `redirect_field_name`: The name of a `GET` field containing the
  URL to redirect to after login. Defaults to `next`.
- `authentication_form`: A callable (typically a form class) to use for
  authentication. Defaults to
  [`AuthenticationForm`](#django.contrib.auth.forms.AuthenticationForm).
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.
- `redirect_authenticated_user`: A boolean that controls whether or not
  authenticated users accessing the login page will be redirected as if
  they had just successfully logged in. Defaults to `False`.

  > **Warning**
  >
  > If you enable `redirect_authenticated_user`, other websites will be
  > able to determine if their visitors are authenticated on your site by
  > requesting redirect URLs to image files on your website. To avoid
  > this "[social media fingerprinting](https://robinlinus.github.io/socialmedia-leak/)" information
  > leakage, host all images and your favicon on a separate domain.
  >
  > Enabling `redirect_authenticated_user` can also result in a redirect
  > loop when using the [`permission_required()`](#django.contrib.auth.decorators.permission_required) decorator
  > unless the `raise_exception` parameter is used.
- `success_url_allowed_hosts`: A [`set`](https://docs.python.org/3/library/stdtypes.html#set) of hosts, in addition to
  [`request.get_host()`](/ja/3.2/ref/request-response/#django.http.HttpRequest.get_host), that are
  safe for redirecting after login. Defaults to an empty [`set`](https://docs.python.org/3/library/stdtypes.html#set).

Here's what `LoginView` does:

- If called via `GET`, it displays a login form that POSTs to the
  same URL. More on this in a bit.
- If called via `POST` with user submitted credentials, it tries to log
  the user in. If login is successful, the view redirects to the URL
  specified in `next`. If `next` isn't provided, it redirects to
  [`settings.LOGIN_REDIRECT_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_REDIRECT_URL) (which
  defaults to `/accounts/profile/`). If login isn't successful, it
  redisplays the login form.

It's your responsibility to provide the html for the login template
, called `registration/login.html` by default. This template gets passed
four template context variables:

- `form`: A [`Form`](/ja/3.2/ref/forms/api/#django.forms.Form) object representing the
  [`AuthenticationForm`](#django.contrib.auth.forms.AuthenticationForm).
- `next`: The URL to redirect to after successful login. This may
  contain a query string, too.
- `site`: The current [`Site`](/ja/3.2/ref/contrib/sites/#django.contrib.sites.models.Site),
  according to the [`SITE_ID`](/ja/3.2/ref/settings/#std-setting-SITE_ID) setting. If you don't have the
  site framework installed, this will be set to an instance of
  [`RequestSite`](/ja/3.2/ref/contrib/sites/#django.contrib.sites.requests.RequestSite), which derives the
  site name and domain from the current
  [`HttpRequest`](/ja/3.2/ref/request-response/#django.http.HttpRequest).
- `site_name`: An alias for `site.name`. If you don't have the site
  framework installed, this will be set to the value of
  [`request.META['SERVER_NAME']`](/ja/3.2/ref/request-response/#django.http.HttpRequest.META).
  For more on sites, see [The "sites" framework](/ja/3.2/ref/contrib/sites/).

If you'd prefer not to call the template `registration/login.html`,
you can pass the `template_name` parameter via the extra arguments to
the `as_view` method in your URLconf. For example, this URLconf line would
use `myapp/login.html` instead:

```
path('accounts/login/', auth_views.LoginView.as_view(template_name='myapp/login.html')),
```

You can also specify the name of the `GET` field which contains the URL
to redirect to after login using `redirect_field_name`. By default, the
field is called `next`.

Here's a sample `registration/login.html` template you can use as a
starting point. It assumes you have a `base.html` template that
defines a `content` block:

```html+django
{% extends "base.html" %}

{% block content %}

{% if form.errors %}
<p>Your username and password didn't match. Please try again.</p>
{% endif %}

{% if next %}
    {% if user.is_authenticated %}
    <p>Your account doesn't have access to this page. To proceed,
    please login with an account that has access.</p>
    {% else %}
    <p>Please login to see this page.</p>
    {% endif %}
{% endif %}

<form method="post" action="{% url 'login' %}">
{% csrf_token %}
<table>
<tr>
    <td>{{ form.username.label_tag }}</td>
    <td>{{ form.username }}</td>
</tr>
<tr>
    <td>{{ form.password.label_tag }}</td>
    <td>{{ form.password }}</td>
</tr>
</table>

<input type="submit" value="login">
<input type="hidden" name="next" value="{{ next }}">
</form>

{# Assumes you setup the password_reset view in your URLconf #}
<p><a href="{% url 'password_reset' %}">Lost password?</a></p>

{% endblock %}
```

If you have customized authentication (see [Customizing Authentication](/ja/3.2/topics/auth/customizing/)) you can use a custom authentication form by
setting the `authentication_form` attribute. This form must accept a
`request` keyword argument in its `__init__()` method and provide a
`get_user()` method which returns the authenticated user object (this
method is only ever called after successful form validation).

#### `class LogoutView`

Logs a user out.

**URL name:** `logout`

**属性:**

- `next_page`: The URL to redirect to after logout. Defaults to
  [`settings.LOGOUT_REDIRECT_URL`](/ja/3.2/ref/settings/#std-setting-LOGOUT_REDIRECT_URL).
- `template_name`: The full name of a template to display after
  logging the user out. Defaults to `registration/logged_out.html`.
- `redirect_field_name`: The name of a `GET` field containing the
  URL to redirect to after log out. Defaults to `next`. Overrides the
  `next_page` URL if the given `GET` parameter is passed.
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.
- `success_url_allowed_hosts`: A [`set`](https://docs.python.org/3/library/stdtypes.html#set) of hosts, in addition to
  [`request.get_host()`](/ja/3.2/ref/request-response/#django.http.HttpRequest.get_host), that are
  safe for redirecting after logout. Defaults to an empty [`set`](https://docs.python.org/3/library/stdtypes.html#set).

**Template context:**

- `title`: The string "Logged out", localized.
- `site`: The current [`Site`](/ja/3.2/ref/contrib/sites/#django.contrib.sites.models.Site),
  according to the [`SITE_ID`](/ja/3.2/ref/settings/#std-setting-SITE_ID) setting. If you don't have the
  site framework installed, this will be set to an instance of
  [`RequestSite`](/ja/3.2/ref/contrib/sites/#django.contrib.sites.requests.RequestSite), which derives the
  site name and domain from the current
  [`HttpRequest`](/ja/3.2/ref/request-response/#django.http.HttpRequest).
- `site_name`: An alias for `site.name`. If you don't have the site
  framework installed, this will be set to the value of
  [`request.META['SERVER_NAME']`](/ja/3.2/ref/request-response/#django.http.HttpRequest.META).
  For more on sites, see [The "sites" framework](/ja/3.2/ref/contrib/sites/).

#### `logout_then_login(request, login_url=None)`

Logs a user out, then redirects to the login page.

**URL name:** No default URL provided

**Optional arguments:**

- `login_url`: The URL of the login page to redirect to.
  Defaults to [`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) if not supplied.

#### `class PasswordChangeView`

**URL name:** `password_change`

Allows a user to change their password.

**属性:**

- `template_name`: The full name of a template to use for
  displaying the password change form. Defaults to
  `registration/password_change_form.html` if not supplied.
- `success_url`: The URL to redirect to after a successful password
  change. Defaults to `'password_change_done'`.
- `form_class`: A custom "change password" form which must accept a
  `user` keyword argument. The form is responsible for actually changing
  the user's password. Defaults to
  [`PasswordChangeForm`](#django.contrib.auth.forms.PasswordChangeForm).
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.

**Template context:**

- `form`: The password change form (see `form_class` above).

#### `class PasswordChangeDoneView`

**URL name:** `password_change_done`

The page shown after a user has changed their password.

**属性:**

- `template_name`: The full name of a template to use.
  Defaults to `registration/password_change_done.html` if not
  supplied.
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.

#### `class PasswordResetView`

**URL 名:** `password_reset`

パスワードをリセットするために使われる 1 回限り有効なリンクを生成し、ユーザがパスワードをリセットできるようにします。そのリンクはユーザーが登録した E メールアドレスに送信されます。

入力された E メールアドレスがシステムに存在しない場合、ビューはメール送信をせず、またエラーメッセージも表示しません。これは、潜在的な攻撃者への情報漏洩を防ぐためです。エラーメッセージを表示したい場合は、[`PasswordResetForm`](#django.contrib.auth.forms.PasswordResetForm) をサブクラス化して、`form_class` 属性を使用してください。

> **Note**
>
> Be aware that sending an email costs extra time, hence you may be
> vulnerable to an email address enumeration timing attack due to a
> difference between the duration of a reset request for an existing
> email address and the duration of a reset request for a nonexistent
> email address. To reduce the overhead, you can use a 3rd party package
> that allows to send emails asynchronously, e.g. [django-mailer](https://pypi.org/project/django-mailer/).

無効なパスワード (詳しくは [`set_unusable_password()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.set_unusable_password) ) でフラグが立てられたユーザは、パスワードリセットのリクエストができないようになっており、LDAP のような外部の認証ソースを使っているときに悪用されるのを防ぎます。アカウントの存在が漏洩しないように、ユーザーはエラーメッセージを受け取ることもメールが送信されることもありません。

**属性:**

- `template_name`: パスワードリセットのフォームを表示するためのテンプレート名です。指定しない場合のデフォルトは `registration/password_reset_form.html` です。
- `form_class`: パスワードをリセットするためのユーザの E メールアドレス入力用のフォームです。デフォルトは [`PasswordResetForm`](#django.contrib.auth.forms.PasswordResetForm) です。
- `email_template_name`: リセットパスワードのリンクとともに生成される E メールを生成するためのテンプレート名です。指定しない場合のデフォルトは `registration/password_reset_email.html` です。
- `subject_template_name`: リセットパスワードのリンクとともに生成される E メールの表題に対して使われるテンプレートの名前です。指定しない場合のデフォルトは `registration/password_reset_subject.txt` です。
- `token_generator`: 1 回限りのリンクをチェックするためのクラスのインスタンスです。デフォルトは `default_token_generator` で、これは `django.contrib.auth.tokens.PasswordResetTokenGenerator` のインスタンスです。
- `success_url`: The URL to redirect to after a successful password reset
  request. Defaults to `'password_reset_done'`.
- `from_email`: 検証済みの E メールアドレスです。デフォルトでは、Django は [`DEFAULT_FROM_EMAIL`](/ja/3.2/ref/settings/#std-setting-DEFAULT_FROM_EMAIL) を使います。
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.
- `html_email_template_name`: The full name of a template to use
  for generating a `text/html` multipart email with the password
  reset link. By default, HTML email is not sent.
- `extra_email_context`: A dictionary of context data that will be
  available in the email template. It can be used to override default
  template context values listed below e.g. `domain`.

**Template context:**

- `form`: ユーザのパスワードをリセットするためのフォームです (上述の `form_class` をご覧ください)。

**E メールテンプレートのコンテキスト:**

- `email`: `user.email` の別名 (エイリアス) です。
- `user`: 現在の [`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) で、`email` フォームフィールドから取得されます。アクティブなユーザ (`User.is_active が True`) だけがパスワードをリセットすることができます。
- `site_name`: An alias for `site.name`. If you don't have the site
  framework installed, this will be set to the value of
  [`request.META['SERVER_NAME']`](/ja/3.2/ref/request-response/#django.http.HttpRequest.META).
  For more on sites, see [The "sites" framework](/ja/3.2/ref/contrib/sites/).
- `domain`: `site.domain` の別名 (エイリアス) です。サイトのフレームワークをインストールしていない場合、`request.get_host()` の値がセットされます。
- `protocol`: http か https です。
- `uid`: Base 64 でエンコードされたユーザのプライマリキーです。
- `token`: リセットリンクを検証するためのトークンです。

以下はサンプルの `registration/password_reset_email.html` (E メール本文のテンプレート)です:

```html+django
Someone asked for password reset for email {{ email }}. Follow the link below:
{{ protocol}}://{{ domain }}{% url 'password_reset_confirm' uidb64=uid token=token %}
```

表題のテンプレートにも同じテンプレートコンテキストが使われます。表題は 1 行のプレーンテキスト文字列の必要があります。

#### `class PasswordResetDoneView`

**URL 名:** `password_reset_done`

パスワードリセット用のリンクがユーザにメール送信された後に表示されるページです。このビューは、デフォルトで [`PasswordResetView`](#django.contrib.auth.views.PasswordResetView) に明示的な `success_url` URL セットが指定されていないときに呼び出されます。

> **Note**
>
> 提供された E メールアドレスがシステムにない、ユーザーが非アクティブである、もしくは無効なパスワードの場合でも、ユーザはこのページにリダイレクトされますが、E メールは送信されません。

**属性:**

- `template_name`: テンプレートの名前です。指定しない場合のデフォルトは `registration/password_reset_done.html` です。
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.

#### `class PasswordResetConfirmView`

**URL 名:** `password_reset_confirm`

新しいパスワードを入力するためのフォームを提供します。

**Keyword arguments from the URL:**

- `uidb64`: The user's id encoded in base 64.
- `token`: Token to check that the password is valid.

**属性:**

- `template_name`: パスワード確認のビューを表示するためのテンプレートの名前です。デフォルト値は `registration/password_reset_confirm.html` です。
- `token_generator`: パスワードをチェックするためのクラスのインスタンスです。デフォルトは `default_token_generator` で、これは `django.contrib.auth.tokens.PasswordResetTokenGenerator` のインスタンスです。
- `post_reset_login`: A boolean indicating if the user should be
  automatically authenticated after a successful password reset. Defaults
  to `False`.
- `post_reset_login_backend`: A dotted path to the authentication
  backend to use when authenticating a user if `post_reset_login` is
  `True`. Required only if you have multiple
  [`AUTHENTICATION_BACKENDS`](/ja/3.2/ref/settings/#std-setting-AUTHENTICATION_BACKENDS) configured. Defaults to `None`.
- `form_class`: Form that will be used to set the password. Defaults to
  [`SetPasswordForm`](#django.contrib.auth.forms.SetPasswordForm).
- `success_url`: URL to redirect after the password reset done. Defaults
  to `'password_reset_complete'`.
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.
- `reset_url_token`: Token parameter displayed as a component of password
  reset URLs. Defaults to `'set-password'`.

**Template context:**

- `form`: The form (see `form_class` above) for setting the new user's
  password.
- `validlink`: 真偽値で、リンク (`uidb64` と `token` の組み合わせ) が有効か、まだ使われていない場合に True となります。

#### `class PasswordResetCompleteView`

**URL 名:** `password_reset_complete`

パスワードの変更が成功したことをユーザに知らせるためのビューを提供します。

**属性:**

- `template_name`: ビューを表示するためのテンプレートの名前です。デフォルトは `registration/password_reset_complete.html` です。
- `extra_context`: A dictionary of context data that will be added to the
  default context data passed to the template.

### ヘルパー関数

#### `redirect_to_login(next, login_url=None, redirect_field_name='next')`

ログインページにリダイレクトし、ログイン成功後にもう 1 つの URL に戻ります。

**必須の引数:**

- `next`: ログイン成功後のリダイレクト先の URL です。

**Optional arguments:**

- `login_url`: The URL of the login page to redirect to.
  Defaults to [`settings.LOGIN_URL`](/ja/3.2/ref/settings/#std-setting-LOGIN_URL) if not supplied.
- `redirect_field_name`: ログアウト後のリダイレクト先の URL を含む `GET` フィールドの名前です。指定された `GET` パラメータが与えられ場合、`next` をオーバーライドします。

### ビルトインのフォーム

ビルトインのビューを使いたくないけれども、ビューの機能を再利用したいと考えている場合、認証システムが提供しているビルトインのフォームを使うことができます。ビルトインのフォームは [`django.contrib.auth.forms`](#module-django.contrib.auth.forms) にあります。

> **Note**
>
> ビルトインの認証フォームは、扱うユーザーモデルについて一定の前提に基づいて設計されています。なので、もし [独自のユーザーモデル](/ja/3.2/topics/auth/customizing/#auth-custom-user) を使っている場合は、 認証システムに対して自分自身のフォームを定義する必要がある可能性があります。詳しくは、[独自のユーザーモデルでビルトインの認証フォームを使用する](/ja/3.2/topics/auth/customizing/#custom-users-and-the-built-in-auth-forms) を参照してください。

#### `class AdminPasswordChangeForm`

ユーザのパスワードを変更するために admin インターフェイス内で使われるフォームです。

第 1 引数として `user` を取ります。

#### `class AuthenticationForm`

ユーザーログインのためのフォームです。

第 1 引数として `request` を取り、サブクラスで使えるようにフォームのインスタンス上に保持されます。

#### `confirm_login_allowed(user)`

デフォルトでは、`AuthenticationForm` は `is_active` フラグが `False` にセットされたユーザを拒否します。どのユーザがログインできるかを決定する独自のポリシーによって、この挙動をオーバーライドできます。`AuthenticationForm` をサブクラス化した独自のフォームを使って、`confirm_login_allowed()` メソッドを上書きしてください。指定されたユーザがログインできない場合、このメソッドは [`ValidationError`](/ja/3.2/ref/exceptions/#django.core.exceptions.ValidationError) を投げます。

例えば、"active" ステータスにかかわらず全てのユーザにログインを許可するには:

```
from django.contrib.auth.forms import AuthenticationForm

class AuthenticationFormWithInactiveUsersOkay(AuthenticationForm):
    def confirm_login_allowed(self, user):
        pass
```

(In this case, you'll also need to use an authentication backend that
allows inactive users, such as
[`AllowAllUsersModelBackend`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.backends.AllowAllUsersModelBackend).)

または、何人かのアクティブユーザのみにログインを許可するには、以下のようにします:

```
class PickyAuthenticationForm(AuthenticationForm):
    def confirm_login_allowed(self, user):
        if not user.is_active:
            raise ValidationError(
                _("This account is inactive."),
                code='inactive',
            )
        if user.username.startswith('b'):
            raise ValidationError(
                _("Sorry, accounts starting with 'b' aren't welcome here."),
                code='no_b_users',
            )
```

#### `class PasswordChangeForm`

ユーザがパスワードを変更できるようにするフォームです。

#### `class PasswordResetForm`

ユーザのパスワードリセットするための 1 回限りのリンクを生成して E メール送信するためのフォームです。

#### `send_mail(subject_template_name, email_template_name, context, from_email, to_email, html_email_template_name=None)`

引数を使って `EmailMultiAlternatives` を送信します。オーバーライドして、どのように E メールが送信されるかカスタマイズできます。

**パラメータ:** - `subject_template_name` -- 表題用のテンプレートです。
- `email_template_name` -- E メール本文用のテンプレートです。
- `context` -- `subject_template`、`email_template`、`html_email_template` (`None` ではない場合のみ) に渡されるコンテキストです。
- `from_email` -- 送信者の E メールです。
- `to_email` -- リクエストしてきたユーザの E メールです。
- `html_email_template_name` -- HTML 本文用のテンプレートです; デフォルトは `None` で、この場合プレーンテキストの E メールが送信されます。

デフォルトでは、`save()` は [`PasswordResetView`](#django.contrib.auth.views.PasswordResetView) がメールコンテ キストに渡すのと同じ変数を持つ `context` を返します。

#### `class SetPasswordForm`

古いパスワードを入力しないでパスワードを変更できるようにするフォームです。

#### `class UserChangeForm`

ユーザの情報とパーミッションを変更するために admin インターフェイスで使われるフォームです。

#### `class UserCreationForm`

新しいユーザを作成するための [`ModelForm`](/ja/3.2/topics/forms/modelforms/#django.forms.ModelForm) です。

3 つのフィールドがあります: `username` (ユーザモデルより)、`password1`、```password2``です。``password1``` と `password2` が一致するか確認し、[`validate_password()`](/ja/3.2/topics/auth/passwords/#django.contrib.auth.password_validation.validate_password) を使ってパスワードを検証します。そして、[`set_password()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.set_password) を使ってユーザのパスワードをセットします。

### テンプレート内の認証データ

[`RequestContext`](/ja/3.2/ref/templates/api/#django.template.RequestContext) を使うと、現在ログインしているユーザとパーミッションを [template context](/ja/3.2/ref/templates/api/) 内で使えるようにできます。

> **技術的には**
>
> 技術的には、これらの変数は [`RequestContext`](/ja/3.2/ref/templates/api/#django.template.RequestContext) を使い、`'django.contrib.auth.context_processors.auth'` コンテキストプロセッサを有効にしたときのみ使うことができます。これは、デフォルトで生成される設定ファイル内にあります。より詳しくは [RequestContext docs](/ja/3.2/ref/templates/api/#subclassing-context-requestcontext) を参照してください。

#### ユーザ

テンプレート [`RequestContext`](/ja/3.2/ref/templates/api/#django.template.RequestContext) をレンダリングするとき、現在ログイン中のユーザ ([`User`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User) インスタンスか [`AnonymousUser`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.AnonymousUser) のどちらか) はテンプレート変数 `{{ user }}` 内に格納されます:

```html+django
{% if user.is_authenticated %}
    <p>Welcome, {{ user.username }}. Thanks for logging in.</p>
{% else %}
    <p>Welcome, new user. Please log in.</p>
{% endif %}
```

`RequestContext` が使用されていない場合、このテンプレートコンテキスト変数は無効となります。

#### パーミッション

現在ログイン中のユーザのパーミッションは、テンプレート変数 `{{ perms }}` 内に保持されています。 これは `django.contrib.auth.context_processors.PermWrapper` のインスタンスで、パーミッションをテンプレートで使いやすくするための代替表現です。

Evaluating a single-attribute lookup of `{{ perms }}` as a boolean is a proxy
to [`User.has_module_perms()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.has_module_perms). For example, to check if
the logged-in user has any permissions in the `foo` app:

```
{% if perms.foo %}
```

Evaluating a two-level-attribute lookup as a boolean is a proxy to
[`User.has_perm()`](/ja/3.2/ref/contrib/auth/#django.contrib.auth.models.User.has_perm). For example,
to check if the logged-in user has the permission `foo.add_vote`:

```
{% if perms.foo.add_vote %}
```

Here's a more complete example of checking permissions in a template:

```html+django
{% if perms.foo %}
    <p>You have permission to do something in the foo app.</p>
    {% if perms.foo.add_vote %}
        <p>You can vote!</p>
    {% endif %}
    {% if perms.foo.add_driving %}
        <p>You can drive!</p>
    {% endif %}
{% else %}
    <p>You don't have permission to do anything in the foo app.</p>
{% endif %}
```

`{% if in %}` ステートメントを使ってパーミッションをルックアップすることも可能です。例えば:

```html+django
{% if 'foo' in perms %}
    {% if 'foo.add_vote' in perms %}
        <p>In lookup works, too.</p>
    {% endif %}
{% endif %}
```

## admin 内でユーザを管理する

`django.contrib.admin` と `django.contrib.auth` の両方をインストールしていれば、admin でユーザ、グループおよびパーミッションを見たり管理することが簡単にできます。ユーザは通常の Django モデルと同じく作成や削除ができます。グループも作成することができ、パーミッションはユーザやグループにアサインすることができます。admin でのユーザー編集のログも保管および表示されます。

### ユーザを作成する

admin のメインインデックスページの "Auth" セクションに "Users" へのリンクがあります。"Add user" ページは通常の admin ページとは異なり、他のユーザーのフィールドを編集する際に、ユーザ名とパスワードを選択する必要があります。

また、Django の admin サイトを使用してユーザアカウントを作成できるようにするには、ユーザを追加 *および* 変更する権限をユーザに与える必要があります (つまり "Add user" と "Change user" パーミッション)。あるアカウントにユーザの追加権限のみが与えられ変更権限がない場合、そのアカウントはユーザを追加できません。なぜなら、追加権限によってスーパーユーザを作成することができ、そのスーパーユーザを使って他のユーザーを変更することができてしまうからです。 そのため、Django はちょっとしたセキュリティ対策として、追加と変更の *両方* の権限を必要とするのです。

ユーザに与えるパーミッション管理の権限については、よく考える必要があります。たとえば非スーパーユーザにユーザ編集の権限を与えてしまうと、結果的に彼らにスーパーユーザと同じ能力を与えることになります。というのも、彼らはユーザ編集の権限によってユーザのパーミッションを昇格させることができるため、彼ら自身のパーミッションも昇格させられるのです！

### パスワードを変更する

User passwords are not displayed in the admin (nor stored in the database), but
the [password storage details](/ja/3.2/topics/auth/passwords/) are displayed.
Included in the display of this information is a link to
a password change form that allows admins to change user passwords.