Índice
Verifique se o usuário está logado Exemplo
5. Use o esquema de senha fornecido no Django
1. Arquivos estáticos
O CSS, imagens e js no projeto são todos arquivos estáticos
Configurar arquivos estáticos
1. Defina o conteúdo estático no arquivo de configurações
STATIC_URL = '/static/'
STATICFILES_DIRS = [
os.path.join(BASE_DIR, 'static'),
]
2. Crie um diretório estático no diretório raiz do projeto e, em seguida, crie um diretório com o nome do aplicativo atual
mysite/static/myapp/
3. Hardcoding pode ser usado no modelo
/static/my_app/myexample.jpg
4. A codificação estática pode ser usada no modelo
{ % load static from staticfiles % }
<img src="{ % static "my_app/myexample.jpg" % }" alt="My image"/>2. Csrf
CSRF (falsificação de solicitação entre sites) A falsificação de solicitação entre sites, também conhecida como "One Click Attack" ou Session Riding, geralmente abreviada como CSRF ou XSRF, é um uso malicioso de sites. Embora pareça cross-site scripting (XSS) , é muito diferente de XSS, que explora usuários confiáveis dentro de um site, e CSRF, que explora sites confiáveis disfarçando solicitações de usuários confiáveis. Em comparação com os ataques XSS , os ataques CSRF tendem a ser menos populares (portanto os recursos para preveni-los são bastante escassos) e difíceis de prevenir, por isso são considerados mais perigosos que o XSS
O middleware CSRF e as tags de modelo fornecem proteção fácil de usar contra falsificação de solicitação entre sites .
Esse tipo de ataque é realizado usando as credenciais de um usuário conectado que visita o site malicioso em um navegador, quando o site malicioso contém links, botões de formulário ou algum JavaScript projetado para executar determinadas ações em seu site.
Um tipo de ataque relacionado, "login CSRF", também é descrito, no qual um site de ataque engana o navegador de um usuário para fazer login em um site usando as credenciais de outra pessoa.
O uso de csrf
No modelo Django, é fornecido um método para evitar ataques entre sites. As etapas são as seguintes:
- step1: Habilite o middleware 'django.middleware.csrf.CsrfViewMiddleware' em settings.py, que é habilitado por padrão ao criar um projeto
- passo 2: Adicionar tags ao formulário HTML
<form> { % csrf_token % } ... </form>
desproteger
Se algumas visualizações não precisam ser protegidas, você pode usar o decorador csrf_exempt e não precisa escrever tags no modelo. Modifique a visualização de csrf2 como segue em django.views.decorators.csrf import csrf_exempt
@csrf_exempt
def csrf2(request):
uname=request.POST['uname']
return render(request,'booktest/csrf2.html',{'uname':uname})
运行上面的两个请求，发现都可以请求
princípio de proteção
Depois de adicionar a tag, você pode visualizar o código-fonte e encontrar o seguinte código
<input type='hidden' name='csrfmiddlewaretoken' value='nGjAB3Md9ZSb4NmG1sXDolPmh3bR2g59' />
-
Na ferramenta de depuração do navegador, as informações do cookie podem ser visualizadas na guia rede
-
As informações de cookies são adicionadas automaticamente a este site, conforme mostrado na figura a seguir csrf3
-
Verifique as informações entre sites, não há informações de cookies, mesmo se você adicionar o código de domínio oculto acima, poderá visitá-lo novamente
-
Conclusão: o csrf do django não é completamente seguro
-
Ao enviar uma solicitação, o middleware 'django.middleware.csrf.CsrfViewMiddleware' verificará o conteúdo do cookie enviado e do domínio oculto e retornará um erro 403 se falhar
Autenticação Ajax CSRF
As solicitações GET não requerem autenticação CSRF e as solicitações POST requerem autenticação correta para obter resultados de retorno corretos.
Se você usar chamadas Ajax, será mais problemático. Observe os seguintes pontos:
- Use render na exibição (em vez de render_to_response)
-
Adicione este código js antes de usar o ajax ou post do jQuery
jQuery(document).ajaxSend(function(event, xhr, settings) { function getCookie(name) { var cookieValue = null; if (document.cookie && document.cookie != '') { var cookies = document.cookie.split(';'); for (var i = 0; i < cookies.length; i++) { var cookie = jQuery.trim(cookies[i]); // Does this cookie string begin with the name we want? if (cookie.substring(0, name.length + 1) == (name + '=')) { cookieValue = decodeURIComponent(cookie.substring(name.length + 1)); break; } } } return cookieValue; } function sameOrigin(url) { // url could be relative or scheme relative or absolute var host = document.location.host; // host + port var protocol = document.location.protocol; var sr_origin = '//' + host; var origin = protocol + sr_origin; // Allow absolute or scheme relative URLs to same origin return (url == origin || url.slice(0, origin.length + 1) == origin + '/') || (url == sr_origin || url.slice(0, sr_origin.length + 1) == sr_origin + '/') || // or any other URL that isn't scheme relative or absolute i.e relative. !(/^(\/\/|http:|https:).*/.test(url)); } function safeMethod(method) { return (/^(GET|HEAD|OPTIONS|TRACE)$/.test(method)); } if (!safeMethod(settings.type) && sameOrigin(settings.url)) { xhr.setRequestHeader("X-CSRFToken", getCookie('csrftoken')); } }); -
Ou um código mais elegante e conciso (não pode ser escrito em .js, mas diretamente no arquivo de template ):
$.ajaxSetup({ data: {csrfmiddlewaretoken: '{ { csrf_token } }' }, });
Depois disso, você pode usar jQuery.ajax() e jQuery.post() como antes
3. Manutenção do estado
- O protocolo HTTP é sem estado: cada solicitação é uma nova solicitação e o estado
- Uma comunicação entre o cliente e o servidor é uma sessão
- A maneira de alcançar a preservação do estado: armazenar dados relacionados à sessão no cliente ou servidor
- Os métodos de armazenamento incluem cookie, sessão, sessão geralmente se refere ao objeto de sessão
- Usando cookies, todos os dados são armazenados no lado do cliente, tenha cuidado para não armazenar informações confidenciais
- Recomenda-se usar o método de sessão, todos os dados são armazenados no lado do servidor e o session_id é armazenado no cookie do cliente
- O objetivo da manutenção do estado é rastrear o estado do solicitante por um período de tempo, o que pode realizar acesso entre páginas aos dados do solicitante atual
- Nota: Esses dados não serão compartilhados entre diferentes solicitantes, e correspondem ao solicitante one-to-one
sessão aberta
- Projetos criados com django-admin startproject são ativados por padrão
- Desativar sessão: remova os dois valores especificados abaixo, desativar a sessão economizará algum consumo de desempenho
- A sessão no Django precisa contar com o banco de dados, por isso é necessário confirmar se existem tabelas relacionadas à sessão no banco de dados
-
No arquivo settings.py
* 项INSTALLED_APPS列表中添加： * 'django.contrib.sessions', * 项MIDDLEWARE_CLASSES列表中添加： * 'django.contrib.sessions.middleware.SessionMiddleware',
usar sessão
- Quando as sessões são habilitadas, cada objeto HttpRequest terá um atributo de sessão, que é um objeto semelhante a um dicionário
- get(key, default=None): Obtém o valor da sessão de acordo com a chave
- clear (): Limpa todas as sessões
- flush (): exclui os dados da sessão atual e exclui o cookie da sessão
- del request.session['member_id']: excluir sessão
-
Exemplo:
#session设置 request.session[key] = value #session获取 request.session.get(key,default=Node) #session删除 # 删除单个key 不存在时报错 del request.session['a'] #清除所有会话,但不会删除数据 request.session.clear() #删除当前的会话数据 request.session.flush()
4. Middleware
- Middleware é um sistema plug-in leve e de baixo nível que pode intervir no processamento de solicitação e resposta do Django e modificar a entrada ou saída do Django
- Ativação: adicionada à tupla MIDDLEWARE_CLASSES no arquivo de configuração do Django
- Usando middleware, você pode interferir em todo o processo de processamento, e esse método de middleware será executado em cada solicitação
Verifique se o usuário está logado Exemplo
Crie um arquivo AdminLoginMiddleware.py em seu aplicativo
from django.shortcuts import render
from django.http import HttpResponse
import re
class AdminLoginMiddleware:
def __init__(self, get_response):
self.get_response = get_response
# One-time configuration and initialization.
def __call__(self, request):
# 检测当前的请求是否已经登录,如果已经登录,.则放行,如果未登录,则跳转到登录页
# 获取当前用户的请求路径 /admin/开头 但不是 /admin/login/ /admin/dologin/ /admin/verifycode
urllist = ['/admin/login','/admin/dologin','/admin/vcode']
# 判断是否进入了后台,并且不是进入登录页面
if re.match('/admin/',request.path) and request.path not in urllist:
# 检测session中是否存在 adminlogin的数据记录
if request.session.get('Vuser','') == '':
# 如果在session没有记录,则证明没有登录,跳转到登录页面
return HttpResponse('<script>alert("请先登录");location.href="/admin/login";</script>')
response = self.get_response(request)
return response
Configurar middleware
Modifique a opção MIDDLEWARE_CLASSES no arquivo settings.py
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
#自定义的中间件
'myadmin.AdminMiddleware.AdminLoginMiddleware'
]5. Use o esquema de senha fornecido no Django
O módulo django.contrib.auth.hashers fornece um conjunto de funções para criar e verificar senhas com hash. Você pode usá-los independentemente do
Usermodelo.
# from django.contrib.auth.hashers import make_password, check_password
# 对密码进行加密操作
# upass = make_password(request.POST['password'], None, 'pbkdf2_sha256')
# upass = check_password('1234567','pbkdf2_sha256$36000$197nqXM6yxYv$Zxh/Vsns8qszkvUmY81BgrjCeLPXhCHLEilP6VO+Rnc=')
Criptografia MD5 em python
#获取密码并md5
import hashlib
m = hashlib.md5()
m.update(bytes(request.POST['password'],encoding="utf8"))
print(m.hexdigest())