Debian Codegraph @

django/contrib/auth/backends.py

raw
1 from asgiref.sync import sync_to_async
2
3 from django.contrib.auth import get_user_model
4 from django.contrib.auth.models import Permission
5 from django.db.models import Exists, OuterRef, Q
6
7 UserModel = get_user_model()
8
9
10 class BaseBackend:
11 def authenticate(self, request, **kwargs):
12 return None
13
14 async def aauthenticate(self, request, **kwargs):
15 return await sync_to_async(self.authenticate)(request, **kwargs)
16
17 def get_user(self, user_id):
18 return None
19
20 async def aget_user(self, user_id):
21 return await sync_to_async(self.get_user)(user_id)
22
23 def get_user_permissions(self, user_obj, obj=None):
24 return set()
25
26 async def aget_user_permissions(self, user_obj, obj=None):
27 return await sync_to_async(self.get_user_permissions)(user_obj, obj)
28
29 def get_group_permissions(self, user_obj, obj=None):
30 return set()
31
32 async def aget_group_permissions(self, user_obj, obj=None):
33 return await sync_to_async(self.get_group_permissions)(user_obj, obj)
34
35 def get_all_permissions(self, user_obj, obj=None):
36 return {
37 *self.get_user_permissions(user_obj, obj=obj),
38 *self.get_group_permissions(user_obj, obj=obj),
39 }
40
41 async def aget_all_permissions(self, user_obj, obj=None):
42 return {
43 *await self.aget_user_permissions(user_obj, obj=obj),
44 *await self.aget_group_permissions(user_obj, obj=obj),
45 }
46
47 def has_perm(self, user_obj, perm, obj=None):
48 return perm in self.get_all_permissions(user_obj, obj=obj)
49
50 async def ahas_perm(self, user_obj, perm, obj=None):
51 return perm in await self.aget_all_permissions(user_obj, obj)
52
53
54 class ModelBackend(BaseBackend):
55 """
56 Authenticates against settings.AUTH_USER_MODEL.
57 """
58
59 def authenticate(self, request, username=None, password=None, **kwargs):
60 if username is None:
61 username = kwargs.get(UserModel.USERNAME_FIELD)
62 if username is None or password is None:
63 return
64 try:
65 user = UserModel._default_manager.get_by_natural_key(username)
66 except UserModel.DoesNotExist:
67 # Run the default password hasher once to reduce the timing
68 # difference between an existing and a nonexistent user (#20760).
69 UserModel().set_password(password)
70 else:
71 if user.check_password(password) and self.user_can_authenticate(user):
72 return user
73
74 async def aauthenticate(self, request, username=None, password=None, **kwargs):
75 if username is None:
76 username = kwargs.get(UserModel.USERNAME_FIELD)
77 if username is None or password is None:
78 return
79 try:
80 user = await UserModel._default_manager.aget_by_natural_key(username)
81 except UserModel.DoesNotExist:
82 # Run the default password hasher once to reduce the timing
83 # difference between an existing and a nonexistent user (#20760).
84 UserModel().set_password(password)
85 else:
86 if await user.acheck_password(password) and self.user_can_authenticate(
87 user
88 ):
89 return user
90
91 def user_can_authenticate(self, user):
92 """
93 Reject users with is_active=False. Custom user models that don't have
94 that attribute are allowed.
95 """
96 return getattr(user, "is_active", True)
97
98 def _get_user_permissions(self, user_obj):
99 return user_obj.user_permissions.all()
100
101 def _get_group_permissions(self, user_obj):
102 return Permission.objects.filter(group__in=user_obj.groups.all())
103
104 def _get_permissions(self, user_obj, obj, from_name):
105 """
106 Return the permissions of `user_obj` from `from_name`. `from_name` can
107 be either "group" or "user" to return permissions from
108 `_get_group_permissions` or `_get_user_permissions` respectively.
109 """
110 if not user_obj.is_active or user_obj.is_anonymous or obj is not None:
111 return set()
112
113 perm_cache_name = "_%s_perm_cache" % from_name
114 if not hasattr(user_obj, perm_cache_name):
115 if user_obj.is_superuser:
116 perms = Permission.objects.all()
117 else:
118 perms = getattr(self, "_get_%s_permissions" % from_name)(user_obj)
119 perms = perms.values_list("content_type__app_label", "codename").order_by()
120 setattr(
121 user_obj, perm_cache_name, {"%s.%s" % (ct, name) for ct, name in perms}
122 )
123 return getattr(user_obj, perm_cache_name)
124
125 async def _aget_permissions(self, user_obj, obj, from_name):
126 """See _get_permissions()."""
127 if not user_obj.is_active or user_obj.is_anonymous or obj is not None:
128 return set()
129
130 perm_cache_name = "_%s_perm_cache" % from_name
131 if not hasattr(user_obj, perm_cache_name):
132 if user_obj.is_superuser:
133 perms = Permission.objects.all()
134 else:
135 perms = getattr(self, "_get_%s_permissions" % from_name)(user_obj)
136 perms = perms.values_list("content_type__app_label", "codename").order_by()
137 setattr(
138 user_obj,
139 perm_cache_name,
140 {"%s.%s" % (ct, name) async for ct, name in perms},
141 )
142 return getattr(user_obj, perm_cache_name)
143
144 def get_user_permissions(self, user_obj, obj=None):
145 """
146 Return a set of permission strings the user `user_obj` has from their
147 `user_permissions`.
148 """
149 return self._get_permissions(user_obj, obj, "user")
150
151 async def aget_user_permissions(self, user_obj, obj=None):
152 """See get_user_permissions()."""
153 return await self._aget_permissions(user_obj, obj, "user")
154
155 def get_group_permissions(self, user_obj, obj=None):
156 """
157 Return a set of permission strings the user `user_obj` has from the
158 groups they belong.
159 """
160 return self._get_permissions(user_obj, obj, "group")
161
162 async def aget_group_permissions(self, user_obj, obj=None):
163 """See get_group_permissions()."""
164 return await self._aget_permissions(user_obj, obj, "group")
165
166 def get_all_permissions(self, user_obj, obj=None):
167 if not user_obj.is_active or user_obj.is_anonymous or obj is not None:
168 return set()
169 if not hasattr(user_obj, "_perm_cache"):
170 user_obj._perm_cache = super().get_all_permissions(user_obj)
171 return user_obj._perm_cache
172
173 def has_perm(self, user_obj, perm, obj=None):
174 return user_obj.is_active and super().has_perm(user_obj, perm, obj=obj)
175
176 async def ahas_perm(self, user_obj, perm, obj=None):
177 return user_obj.is_active and await super().ahas_perm(user_obj, perm, obj=obj)
178
179 def has_module_perms(self, user_obj, app_label):
180 """
181 Return True if user_obj has any permissions in the given app_label.
182 """
183 return user_obj.is_active and any(
184 perm[: perm.index(".")] == app_label
185 for perm in self.get_all_permissions(user_obj)
186 )
187
188 async def ahas_module_perms(self, user_obj, app_label):
189 """See has_module_perms()"""
190 return user_obj.is_active and any(
191 perm[: perm.index(".")] == app_label
192 for perm in await self.aget_all_permissions(user_obj)
193 )
194
195 def with_perm(self, perm, is_active=True, include_superusers=True, obj=None):
196 """
197 Return users that have permission "perm". By default, filter out
198 inactive users and include superusers.
199 """
200 if isinstance(perm, str):
201 try:
202 app_label, codename = perm.split(".")
203 except ValueError:
204 raise ValueError(
205 "Permission name should be in the form "
206 "app_label.permission_codename."
207 )
208 elif not isinstance(perm, Permission):
209 raise TypeError(
210 "The `perm` argument must be a string or a permission instance."
211 )
212
213 if obj is not None:
214 return UserModel._default_manager.none()
215
216 permission_q = Q(group__user=OuterRef("pk")) | Q(user=OuterRef("pk"))
217 if isinstance(perm, Permission):
218 permission_q &= Q(pk=perm.pk)
219 else:
220 permission_q &= Q(codename=codename, content_type__app_label=app_label)
221
222 user_q = Exists(Permission.objects.filter(permission_q))
223 if include_superusers:
224 user_q |= Q(is_superuser=True)
225 if is_active is not None:
226 user_q &= Q(is_active=is_active)
227
228 return UserModel._default_manager.filter(user_q)
229
230 def get_user(self, user_id):
231 try:
232 user = UserModel._default_manager.get(pk=user_id)
233 except UserModel.DoesNotExist:
234 return None
235 return user if self.user_can_authenticate(user) else None
236
237 async def aget_user(self, user_id):
238 try:
239 user = await UserModel._default_manager.aget(pk=user_id)
240 except UserModel.DoesNotExist:
241 return None
242 return user if self.user_can_authenticate(user) else None
243
244
245 class AllowAllUsersModelBackend(ModelBackend):
246 def user_can_authenticate(self, user):
247 return True
248
249
250 class RemoteUserBackend(ModelBackend):
251 """
252 This backend is to be used in conjunction with the ``RemoteUserMiddleware``
253 found in the middleware module of this package, and is used when the server
254 is handling authentication outside of Django.
255
256 By default, the ``authenticate`` method creates ``User`` objects for
257 usernames that don't already exist in the database. Subclasses can disable
258 this behavior by setting the ``create_unknown_user`` attribute to
259 ``False``.
260 """
261
262 # Create a User object if not already in the database?
263 create_unknown_user = True
264
265 def authenticate(self, request, remote_user):
266 """
267 The username passed as ``remote_user`` is considered trusted. Return
268 the ``User`` object with the given username. Create a new ``User``
269 object if ``create_unknown_user`` is ``True``.
270
271 Return None if ``create_unknown_user`` is ``False`` and a ``User``
272 object with the given username is not found in the database.
273 """
274 if not remote_user:
275 return
276 created = False
277 user = None
278 username = self.clean_username(remote_user)
279
280 # Note that this could be accomplished in one try-except clause, but
281 # instead we use get_or_create when creating unknown users since it has
282 # built-in safeguards for multiple threads.
283 if self.create_unknown_user:
284 user, created = UserModel._default_manager.get_or_create(
285 **{UserModel.USERNAME_FIELD: username}
286 )
287 else:
288 try:
289 user = UserModel._default_manager.get_by_natural_key(username)
290 except UserModel.DoesNotExist:
291 pass
292 user = self.configure_user(request, user, created=created)
293 return user if self.user_can_authenticate(user) else None
294
295 async def aauthenticate(self, request, remote_user):
296 """See authenticate()."""
297 if not remote_user:
298 return
299 created = False
300 user = None
301 username = self.clean_username(remote_user)
302
303 # Note that this could be accomplished in one try-except clause, but
304 # instead we use get_or_create when creating unknown users since it has
305 # built-in safeguards for multiple threads.
306 if self.create_unknown_user:
307 user, created = await UserModel._default_manager.aget_or_create(
308 **{UserModel.USERNAME_FIELD: username}
309 )
310 else:
311 try:
312 user = await UserModel._default_manager.aget_by_natural_key(username)
313 except UserModel.DoesNotExist:
314 pass
315 user = await self.aconfigure_user(request, user, created=created)
316 return user if self.user_can_authenticate(user) else None
317
318 def clean_username(self, username):
319 """
320 Perform any cleaning on the "username" prior to using it to get or
321 create the user object. Return the cleaned username.
322
323 By default, return the username unchanged.
324 """
325 return username
326
327 def configure_user(self, request, user, created=True):
328 """
329 Configure a user and return the updated user.
330
331 By default, return the user unmodified.
332 """
333 return user
334
335 async def aconfigure_user(self, request, user, created=True):
336 """See configure_user()"""
337 return await sync_to_async(self.configure_user)(request, user, created)
338
339
340 class AllowAllUsersRemoteUserBackend(RemoteUserBackend):
341 def user_can_authenticate(self, user):
342 return True