galleta, la sesión, el sistema de autenticación de autenticación de Django
navegación
COOKIE 与 SESIÓN
concepto
http cookie no pertenece al ámbito de aplicación del acuerdo, debido al protocolo HTTP no puede sostener, pero la realidad, pero tenemos que "espera" y por lo tanto la galleta nace bajo un escenario de este tipo.
Funciona cookie es: contenido generado desde el servidor, el navegador recibe la solicitud guardada localmente, cuando las visitas del navegador, el navegador mostrará automáticamente la cookie, por lo que el servidor puede ser juzgado por el contenido de la cookie es "¿Quién "a.
A pesar de galletas resuelto hasta cierto punto, a los requisitos de "mantener", pero debido a la cookie en sí soporta hasta 4096 bytes, y la cookie se almacena en el propio cliente, pueden ser interceptadas o robados, y por lo tanto hay una necesidad de algo nuevo, admite más bytes, y se guarda en el servidor, hay un alto nivel de seguridad. Es por sesión.
La cuestión es, en base a las características de un protocolo sin estado HTTP, el servidor no sabe que el visitante "quién". A continuación, la cookie antes mencionado desempeñará el papel de puente.
Podemos dar una cookie identificador único de asignación de cada cliente para que los usuarios acceden a través de la cookie, el servidor sabe que las personas "que". Luego ID diferente en función de la cookie, la información privada almacenada en el servidor durante algún tiempo, como "contraseña de la cuenta" y así sucesivamente.
Para resumir: cookie para compensar la falta de http sin estado, que el conocimiento del servidor a las personas "que"; pero la galleta en forma de texto almacenados localmente, su seguridad es pobre, de modo que podemos identificar los diferentes usuarios de la galleta, correspondiente a guardar la información privada y el texto de 4096 bytes en la sesión.
Además, la mencionada galleta y comunalidad sesión es en realidad algo que no se limita a la lengua y el marco
Registro de aplicaciones
Introducción secciones anteriores, hemos sido capaces de hacer una página de destino, después de verificar la exactitud de un nombre de usuario y contraseña para saltar a la página de fondo. Sin embargo, las pruebas también encontraron que si la página de inicio de sesión de derivación. dirección URL fondo entrada directa también se puede acceder directamente. Esto es claramente irrazonable. De hecho, nos falta es una galleta y una sesión con la verificación. Con este proceso de verificación, podemos lograr y otros sitios web que estar registrado para entrar en la página de atrás.
Permítanme hablar de este tipo de mecanismo de autenticación. Cada vez que se utiliza un navegador para acceder a una página de destino, una vez que han pasado la certificación. El servidor envía un conjunto aleatorio de cadenas únicas (que se supone 123abc) al navegador, la cookie se almacena en lo que se llama el lado del navegador. Y el servidor almacenará sobre su propio estado actual del usuario, como el nombre de usuario de inicio de sesión = true = la información, el usuario jajaja similares. Pero esta memoria se almacena en forma de diccionarios, diccionarios de la edición única clave es sólo un valor de cookie único del usuario. Así que si ve información de la sesión en el servidor y, a continuación, en teoría, verá el siguiente aspecto diccionario como
{ '123abc': { 'login': true, 'nombre de usuario: jajaja'}}
Debido a que cada cookie es único, así que cambiamos el navegador de su ordenador y luego aterrizando con un sitio web también debe ser verificado de nuevo. Entonces, ¿por qué nos limitamos a decir, teóricamente, vemos como este diccionario? Debido a consideraciones de seguridad en el hecho de que un gran diccionario no sólo para la clave anterior está cifrada valor 123abc, valor un valor { 'login': true, 'nombre de usuario: jajaja'} en el lado del servidor es el mismo cifrado. Así que abrimos en el servidor incluso si la información de la sesión ver algo como lo siguiente también parecerse
{ '123abc': dasdasdasd1231231da1231231}
Conocer el principio, después de ser implementado en el código.
Django logra COOKIE
Obtener Cookies
request.COOKIES['key']
request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
#参数：
default: 默认值
salt: 加密盐
max_age: 后台控制过期时间ajustes de cookies
rep = HttpResponse(...) 或 rep ＝ render(request, ...) 或 rep ＝ redirect()
rep.set_cookie(key,value,...)
rep.set_signed_cookie(key,value,salt='加密盐',...)
def set_cookie(self, key, 键
value='', 值
max_age=None, 超长时间
expires=None, 超长时间
path='/', Cookie生效的路径，
浏览器只会把cookie回传给带有该路径的页面，这样可以避免将
cookie传给站点中的其他的应用。
/ 表示根路径，特殊的：根路径的cookie可以被任何url的页面访问
domain=None, Cookie生效的域名
你可用这个参数来构造一个跨站cookie。
如， domain=".example.com"
所构造的cookie对下面这些站点都是可读的：
www.example.com 、 www2.example.com
和an.other.sub.domain.example.com 。
如果该参数设置为 None ，cookie只能由设置它的站点读取。
secure=False, 如果设置为 True ，浏览器将通过HTTPS来回传cookie。
httponly=False 只能http协议传输，无法被JavaScript获取
（不是绝对，底层抓包可以获取到也可以被覆盖）
): pass
Dado que la cookie se almacena en el ordenador cliente, por lo que, JavaScript y jQuery pueden también operar galleta.
<script src='/static/js/jquery.cookie.js'>
</script> $.cookie("key", value,{ path: '/' });Borrar cookies
response.delete_cookie ( "cookie_key", path = "/", dominio = nombre)
cookies almacenan en el cliente de
beneficios:
existen datos en el cliente, reducir la presión en el lado del servidor, para mejorar el rendimiento del sitio.
Contras:
la seguridad no es muy alta: es fácil de ser visto o información de sesión de usuario grieta en la máquina cliente
Django logra SESIÓN
Operaciones básicas
1, estableciendo el valor de Sesiones
request.session [ 'session_name'] = "admin"
2, el valor de adquisición de Sesiones
session_name = request.session [ "session_name"]
3, elimine el valor de Sesiones
del request.session [ "session_name"]
4, si el valor detectado de la sesión de trabajo
si "session_name" es request.session:
5, get (clave, por defecto = None)
fav_color = request.session.get ( 'fav_color', 'rojo')
6, pop (clave)
fav_color = request.session.pop ( 'fav_color')
7, teclas ()
8, los elementos ()
9, setdefault ()
10, flush () Eliminar los datos de sesión actual y borrar la sesión de cookies.
Esto se utiliza para asegurarse de que los datos de la sesión anterior no se puede volver a acceder el navegador del usuario
Por ejemplo, la función django.contrib.auth.logout () se llama ella.
11 cadena aleatoria de sesión de usuario
request.session.session_key
# Todos Sesión fecha de caducidad inferior a la eliminación de datos fecha actual
request.session.clear_expired ()
# cadena aleatoria para comprobar si la sesión de usuario en la base de datos
request.session.exists ( "session_key")
Corriente Sesión # borrar todos los datos de usuario
request.session.delete ( "session_key")
request.session.set_expiry (valor)
* Si el valor es un número entero, la sesión expirará después de un número de segundos.
* Si el valor es DataTime o timedelta, la sesión expirará después de este tiempo.
* Si el valor es 0, el usuario cierra la sesión del navegador fallará.
* Si el valor es Ninguno, sesión dependerá de la política global de caducidad sesión.
Tabla de Análisis de Flujo
Ejemplos
def log_in(request):
if request.method=="POST":
username=request.POST['user']
password=request.POST['pwd']
user=UserInfo.objects.filter(username=username,password=password)
if user:
#设置session内部的字典内容
request.session['is_login']='true'
request.session['username']=username
#登录成功就将url重定向到后台的url
return redirect('/backend/')
#登录不成功或第一访问就停留在登录页面
return render(request,'login.html')
def backend(request):
print(request.session,"------cookie")
print(request.COOKIES,'-------session')
"""
这里必须用读取字典的get()方法把is_login的value缺省设置为False，
当用户访问backend这个url先尝试获取这个浏览器对应的session中的
is_login的值。如果对方登录成功的话，在login里就已经把is_login
的值修改为了True,反之这个值就是False的
"""
is_login=request.session.get('is_login',False)
#如果为真，就说明用户是正常登陆的
if is_login:
#获取字典的内容并传入页面文件
cookie_content=request.COOKIES
session_content=request.session
username=request.session['username']
return render(request,'backend.html',locals())
else:
"""
如果访问的时候没有携带正确的session，
就直接被重定向url回login页面
"""
return redirect('/login/')
def log_out(request):
"""
直接通过request.session['is_login']回去返回的时候，
如果is_login对应的value值不存在会导致程序异常。所以
需要做异常处理
"""
try:
#删除is_login对应的value值
del request.session['is_login']
# OR---->request.session.flush() # 删除django-session表中的对应一行记录
except KeyError:
pass
#点击注销之后，直接重定向回登录页面
return redirect('/login/')
===================================login.html==================
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<form action="/login/" method="post">
<p>用户名: <input type="text" name="user"></p>
<p>密码: <input type="password" name="pwd"></p>
<p><input type="submit"></p>
</form>
</body>
</html>
===================================backend.html==================
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h3>hello {{ username }}</h3>
<a href="/logout/">注销</a>
</body>
</html>
configuración almacenada ESIÓN
1. Base de datos de configuración (por defecto)
El soporte de sesiones predeterminado Django, y el valor predeterminado es la sesión de datos se almacena en una base de datos, a saber: mesa django_session.
a. Configure settings.py
SESSION_ENGINE = motor # 'django.contrib.sessions.backends.db' (por defecto)
SESSION_COOKIE_NAME = tecla cuando el "sessionId" cookie # de sesión en el navegador, a saber: cadena aleatoria sessionid = (por defecto)
SESSION_COOKIE_PATH = "/" # Guardar la ruta de cookies de sesión (por defecto)
SESSION_COOKIE_DOMAIN = Ninguno # sesión del dominio de la cookie guardada (por defecto)
SESSION_COOKIE_SECURE = False # https si cookie de transmisión (por defecto)
SESSION_COOKIE_HTTPONLY = true # si la cookie de sesión sólo es compatible con la transmisión HTTP (por defecto)
SESSION_COOKIE_AGE = 1209600 # Sesión de la fecha de caducidad de la cookie (dos semanas) (por defecto)
SESSION_EXPIRE_AT_BROWSER_CLOSE = false # si cierra el navegador hace sesión ha expirado (por defecto)
SESSION_SAVE_EVERY_REQUEST = false # si cada solicitud Guardar sesión, se salvó después de modificar por defecto (default)
2. caché de configuración
a. Configure settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.cache' # 引擎
SESSION_CACHE_ALIAS = 'defecto' # alias tampón (la memoria caché predeterminado, puede ser memcache) usado, proporcionado por la dependencia de caché alias
clave cuando SESSION_COOKIE_NAME = "sessionId" cookies de sesión # en el navegador, a saber: sessionid = cadena aleatoria
SESSION_COOKIE_PATH = "/" ruta de cookies guardadas # Sesión
SESSION_COOKIE_DOMAIN = Ninguno # sesión del nombre de dominio de la cookie guardada
SESSION_COOKIE_SECURE = False # https si la transmisión de cookies
SESSION_COOKIE_HTTPONLY = true # si la cookie de sesión sólo es compatible con la transmisión HTTP
SESSION_COOKIE_AGE = 1209600 # Sesión de la fecha de caducidad de la cookie (dos semanas)
SESSION_EXPIRE_AT_BROWSER_CLOSE = false # si cierra el navegador hace sesión ha expirado
SESSION_SAVE_EVERY_REQUEST = false # si cada solicitud Guardar sesión, se salvó después de modificar por defecto
3. El archivo de configuración
a. 配置 settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.file' # 引擎
SESSION_FILE_PATH = None # 缓存文件路径，如果为None，则使用tempfile模块获取一个临时地址tempfile.gettempdir()
SESSION_COOKIE_NAME ＝ "sessionid" # Session的cookie保存在浏览器上时的key，即：sessionid＝随机字符串
SESSION_COOKIE_PATH ＝ "/" # Session的cookie保存的路径
SESSION_COOKIE_DOMAIN = None # Session的cookie保存的域名
SESSION_COOKIE_SECURE = False # 是否Https传输cookie
SESSION_COOKIE_HTTPONLY = True # 是否Session的cookie只支持http传输
SESSION_COOKIE_AGE = 1209600 # Session的cookie失效日期（2周）
SESSION_EXPIRE_AT_BROWSER_CLOSE = False # 是否关闭浏览器使得Session过期
SESSION_SAVE_EVERY_REQUEST = False # 是否每次请求都保存Session，默认修改之后才保存sistema de autenticación de autenticación
módulo auth
django.contrib de autenticación de importación
django.contrib.auth proporciona una serie de métodos, aquí nos centramos en tres de ellos:
1 authenticate ()
Proporciona autenticación de usuarios, lo que valida el nombre de usuario y la contraseña son correctos, que normalmente toma dos argumentos clave Nombre de usuario Contraseña
Si la información de autenticación es válido, se devuelve un objeto de usuario. authenticate () se proporcionan en un atributo de objeto de usuario que identifica la autenticación backend autenticación de usuario y la información de acceso es posterior en el se requiere el proceso. Cuando se intentó aterrizar una toma directamente de la base de datos sin autenticar () objeto Usuario se quejará! !
user = autenticación (nombre de usuario = 'alguien', password = 'somepassword')
2 login (HttpRequest, usuario)
Esta función toma un objeto HttpRequest y certificado un objeto Usuario
Esta función utiliza el entorno de sesiones de Django de un usuario autenticado para adjuntar el identificador de sesión y otra información.
from django.contrib.auth import authenticate, login
def my_view(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
# Redirect to a success page.
...
else:
# Return an 'invalid login' error message.
...
3 de cierre de sesión (petición) Salir
from django.contrib.auth import logout
def logout_view(request):
logout(request)
# Redirect to a success page.Esta función toma un objeto HttpRequest, no devuelve ningún valor. Cuando la función es llamada, la petición actual se borrará toda la información de sesión. Incluso si el usuario no está conectado, utilice esta función también no se queja.
4 is_authenticated ()
requisitos:
1 usuarios registrado para acceder a algunas de las páginas,
2 Si el usuario no está registrado para acceder a esta página, a continuación, vaya directamente a la página de inicio de sesión
3 Después de que el usuario complete la pantalla de inicio de sesión de aterrizaje del salto, el salto a direcciones de acceso de forma automática visitado antes
| 1 2 3 4 |
|
# Django ha sido bueno para nosotros diseñamos un decorador para este tipo de situaciones: login_requier
from django.contrib.auth.decorators import login_required
@login_required
def my_view(request):
...
Si el usuario no está conectado, saltará a la URL de inicio de sesión predeterminado Django '/ accounts / login /' (este valor puede ser modificado por LOGIN_URL en el archivo de configuración). Y pasando la URL actual para acceder a la ruta absoluta (después de un aterrizaje con éxito, se le redirige a la trayectoria).
objetos de usuario
las propiedades del objeto de usuario: nombre de usuario, contraseña (requerido) contraseña guardan en la base de datos utilizando un algoritmo de hash
is_staff: si el usuario tiene permisos administrativos para el sitio.
is_active: si desea permitir la conexión del usuario, conjunto de `` False``, puede usuarios no elimina Para desactivar la conexión del usuario
2,1 is_authenticated ()
Si bien es cierto el objeto Usuario, el valor de retorno de la constante en True. Para comprobar si el usuario ha pasado la certificación.
Por certificado no significa que el usuario no tiene derechos, ni siquiera comprobar si el usuario está en un estado activo, que sólo indica el éxito de la certificación por parte del usuario. Este método es muy importante, () para determinar si el usuario ha iniciado sesión con request.user.is_authenticated en el fondo, si es cierto, se puede visualizar el request.user.name recepción
2.2 Creación de un usuario
Crear un ayudante create_user usuario:
La importación de usuarios de django.contrib.auth.models user = User.objects.create_user (nombre de usuario = '', contraseña = '', email = '')
2,3 check_password (passwd)
用户需要修改密码的时候 首先要让他输入原来的密码 ，如果给定的字符串通过了密码检查，返回 True
def change_password(request):
if request.is_ajax():
data = json.loads(request.POST.get('data'))
oldPassword = data.get('oldPassword')
newPassword = data.get('newPassword')
confirmPassword = data.get('confirmPassword')
if request.user.check_password(oldPassword): # 判断旧密码是否正确
request.user.set_password(newPassword)
request.user.save()
result = {'status': 0, "info": "密码修改登录成功！！"}
else:
result = {'status': 1, "info": "原密码不正确！！"}
return HttpResponse(json.dumps(result))
return render(request, 'changepassword.html')
2.4 Cambiar contraseña
Uso set_password () para cambiar la contraseña:
def change_password(request):
if request.is_ajax():
data = json.loads(request.POST.get('data'))
oldPassword = data.get('oldPassword')
newPassword = data.get('newPassword')
confirmPassword = data.get('confirmPassword')
if request.user.check_password(oldPassword): # 判断旧密码是否正确
request.user.set_password(newPassword) # 设置密码
request.user.save()
result = {'status': 0, "info": "密码修改登录成功！！"}
else:
result = {'status': 1, "info": "原密码不正确！！"}
return HttpResponse(json.dumps(result))
return render(request, 'changepassword.html')
Ejemplos
from django.shortcuts import render, HttpResponse, redirect
from . import models
from utils import page
import json
from django.db.models import Count, Max
from django.contrib import auth
from django.contrib.auth.models import User
# Create your views here.
# 登录注册，验证， 注销
def login_auth(func):
def inner(request, *args, **kwargs):
if request.user.is_authenticated():
return func(request, *args, **kwargs)
else:
return redirect('/app01/login/')
return inner
def log_in(request):
if request.is_ajax():
path = request.GET.get('getUrl')
if not path:
path = '/app01/books/'
data = json.loads(request.POST.get('data'))
username = data.get('user')
passwd = data.get('password')
user = auth.authenticate(username=username, password=passwd)
if user:
auth.login(request, user)
result = {'status': 0, 'path': path, "info": "{} 登录成功！！".format(user)}
else:
result = {'status': 1, "info": "账户或密码不正确！！"}
return HttpResponse(json.dumps(result))
else:
return render(request, 'Signin.html')
def login_out(request):
auth.logout(request)
return redirect('/app01/login/')
def register(request):
if request.is_ajax():
data = json.loads(request.POST.get('data'))
confirmPwd = data.pop('confirmPassword')
User.objects.create_user(**data)
redirect('/app01/login')
return render(request, 'register.html')
def change_password(request):
if request.is_ajax():
data = json.loads(request.POST.get('data'))
oldPassword = data.get('oldPassword')
newPassword = data.get('newPassword')
confirmPassword = data.get('confirmPassword')
if request.user.check_password(oldPassword):
request.user.set_password(newPassword)
request.user.save()
result = {'status': 0, "info": "密码修改登录成功！！"}
else:
result = {'status': 1, "info": "原密码不正确！！"}
return HttpResponse(json.dumps(result))
return render(request, 'changepassword.html')fuente original: https://www.cnblogs.com/wangyuanming/p/8028623.html
