Em julho de 2020, o Twitter enfrentou uma grande violação de segurança na qual contas importantes foram comprometidas e tweets fraudulentos foram feitos exigindo Bitcoin. O incidente destacou a vulnerabilidade das plataformas em linha aos ataques cibernéticos e destacou a necessidade urgente de medidas de segurança robustas no ambiente digital atual.
Proteger seus aplicativos contra invasores maliciosos é essencial. Quer você administre um pequeno site de comércio eletrônico ou uma grande plataforma de mídia social, priorizar a segurança não é negociável.
No artigo…
Explore como os desenvolvedores podem proteger o comércio eletrônico e outras plataformas contra atores mal-intencionados, como a violação do Twitter.
Primeiro, exploraremos os recursos e bibliotecas de segurança integrados do Python para ajudar a proteger contra vulnerabilidades de senha, detecção de MIME, ataques de clickjacking, injeção de SQL e muito mais.
A seguir, apresentamos as principais ferramentas de terceiros, como Cloudinary, OWASP dependency-Check e Bandit, que automatizam tarefas de segurança importantes que são difíceis de gerenciar manualmente. Essas ferramentas lidam com segurança de arquivos, verificação de vulnerabilidade de dependência e verificação de vulnerabilidade de base de código para garantir que seu aplicativo esteja protegido contra ataques potenciais.
Finalmente, aqui estão algumas práticas recomendadas de codificação que você deve incorporar como parte de sua rotina diária.
Observação: encontre este aplicativo no GitHub que reflete os conceitos discutidos nesta postagem do blog. Vou orientá-lo no código.
Sobre recursos de segurança integrados e middleware
A primeira linha de defesa para a segurança do aplicativo Python são os recursos de segurança integrados e o middleware fornecido pela estrutura Django (ou Flask). Este recurso ajuda muito a resolver as 10 principais vulnerabilidades do OWASP (Open Web Application Security Project). Aqui estão algumas medidas que são facilmente acessíveis com o framework Django:
Validação de senha
Django fornece ferramentas para garantir segurança de senha forte. Isso inclui verificar se as senhas não são muito semelhantes aos atributos do usuário, definir um comprimento mínimo (o padrão é 8 caracteres), bloquear senhas comumente usadas e garantir que as senhas não sejam inteiramente numéricas. Inclui os seguintes recursos: Além disso, as regras de validação podem ser ajustadas para incluir combinações de letras, números, símbolos, etc., para maior segurança.
Para garantir que seu aplicativo implemente essas validações, altere o comprimento mínimo padrão para 12 caracteres.
1. No arquivo settings.py do seu projeto, certifique-se de que os validadores integrados estejam listados na configuração `AUTH_PASSWORD_VALIDATORS`.
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
2. Adicione 'OPTIONS': {'min_length': 12} ao validador 'django.contrib.auth.password_validation.MinimumLengthValidator'.
AUTH_PASSWORD_VALIDATORS = [
{
'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator',
'OPTIONS': {'min_length': 12},
},
{
'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator',
},
{
'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator',
},
]
3. Salve o arquivo settings.py e reinicie o servidor de desenvolvimento Django para aplicar as alterações.
Se você quiser personalizar regras de validação adicionais, consulte a documentação.
A magia do middleware
O middleware do Django fornece um conjunto de medidas de segurança, incluindo:
- middleware de segurança: defina cabeçalhos de segurança padrão para evitar vários ataques de injeção de código. Cabeçalhos como “X-Content-Type-Options” evitam ataques de detecção de MIME, informando ao navegador para não adivinhar um tipo de arquivo com base em seu conteúdo. Isso evita que scripts maliciosos sejam explorados, disfarçando-os como arquivos de imagem benignos.
- Middleware CsrfView: Mitigue ataques CSRF verificando se os envios de formulários vêm do seu aplicativo, evitando que os usuários sejam induzidos a enviar solicitações maliciosas por meio de links ou e-mails maliciosos. Inclua um token CSRF em seu template Django usando a tag de template `{% csrf_token %}`.
- Middleware XFrameOptions: protege contra ataques de clickjacking, impedindo que páginas da Web sejam incorporadas em frames ou iframes. Isso evita que elementos interativos maliciosos ocultem e engane os usuários para que executem ações que expõem dados ou funcionalidades confidenciais.
A implementação desses recursos de segurança e middleware integrados pode melhorar muito a segurança de seus aplicativos Web Python contra vulnerabilidades comuns.
Para integrar esses middlewares em seu aplicativo Django:
1. No arquivo settings.py do seu projeto, certifique-se de que esses recursos estejam incluídos nas configurações do MIDDLEWARE.
MIDDLEWARE = [
...
'django.middleware.security.SecurityMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
...
]
- Adicione `{% csrf_token %}` ao formulário HTML
{% block body %}
<div id='backend_upload'>
<form action="{% url "upload" %}" method="post" enctype="multipart/form-data">
{% csrf_token %}
{{ backend_form }}
<input type="submit" value="Upload">
</form>
</div>
{% endblock %}
-
Para obter mais informações sobre como configurar a autenticação em seu aplicativo, consulte Como configurar inscrição, login e logout usando o middleware do Django.
-
Permitir ações apenas para usuários autenticados em views.py.
# views.py
from django.shortcuts import render
def my_view(request):
if request.user.is_authenticated:
# User is authenticated, perform user-specific actions
username = request.user.username
# Other user-related logic
else:
# User is not authenticated, handle anonymous user case
pass
return render(request, 'my_template.html')
- Permita ações apenas para usuários autenticados por um modelo como my_template.html. Use variáveis de modelo como esta:
｛｛ user ｝｝,｛｛ user.username ｝｝ou｛% if user.is_authenticated %｝Você pode exibir conteúdo específico do usuário e personalizar a interface do usuário com base no status de autenticação do usuário.
<!-- my_template.html -->
{% if user.is_authenticated %}
<p>Welcome, {{ user.username }}!</p>
<!-- Display user-specific content -->
{% else %}
<p>Welcome, Guest!</p>
<!-- Display content for anonymous users -->
{% endif %}
ORM (Mapeamento Objeto-Relacional)
Um ORM atua como uma camada protetora para interações de dados com o banco de dados, garantindo a integridade e a segurança dos dados. Os ORMs evitam efetivamente ataques de injeção de SQL, automatizando consultas parametrizadas que separam o código SQL da entrada do usuário. Além disso, os ORMs realizam validação de dados, como verificações de comprimento de string e intervalo de números inteiros, para aumentar a segurança e reduzir possíveis vulnerabilidades.
Se você executar migrações usando o comando manager.py (por exemplo, python manage.py makemigrations ou python manage.py mite), você estará usando o ORM do Django para gerenciar o esquema do seu banco de dados.
Aqui está um código que mostra como o Django ORM reforça a segurança SQL.
# upload_app/models.py
from django.db import models
class Photo(models.Model):
image = models.ImageField(upload_to='images/') # Secure file uploads
transformed_image = models.URLField(blank=True, null=True) # Secure URL storage
# Example of parameterized query (data insertion)
@classmethod
def create_photo(cls, image_path):
photo = cls(image=image_path) # Creating a new Photo instance with parameterized data
photo.save() # Saving the instance to the database
return photo
# Example of data validation (ensuring image size doesn't exceed a certain limit)
def save(self, *args, **kwargs):
# Check if the image file size is within a specific limit (e.g., 10MB)
if self.image.size > 10 * 1024 * 1024: # 10MB limit
raise ValueError("Image size exceeds the maximum allowed limit.")
super().save(*args, **kwargs) # Call the parent class's save method to save the object to the database
Alcançar segurança abrangente pode ser um empreendimento complexo e difícil de implementar individualmente. É aqui que entram em ação as ferramentas de terceiros, oferecendo automação dos principais processos de segurança. Vamos dar uma olhada em três ferramentas de terceiros que podem ajudar a manter seus aplicativos seguros. Cloudinary para segurança de arquivos, OWASP dependency-Check para verificação de dependências e Bandit para identificar vulnerabilidades no código Python.
Cloudinary: cuida da segurança dos arquivos
Permitir o upload de arquivos para o seu site pode expô-lo a riscos de segurança, como acesso não autorizado e violações de dados. Um invasor pode explorar vulnerabilidades no processo de upload para introduzir arquivos maliciosos ou executar scripts prejudiciais. Cloudinary, uma plataforma abrangente para gerenciamento de imagens e vídeos, oferece uma variedade de recursos de processamento de arquivos, incluindo medidas de segurança robustas para lidar com esses riscos.
O Cloudinary verifica arquivos e uploads de usuários para evitar que vírus e códigos prejudiciais cheguem aos visualizadores da Web e de dispositivos móveis, inspecionando minuciosamente a presença de malware e garantindo a segurança ao validar os arquivos antes de serem aceitos.
Além disso, as ferramentas de moderação da Cloudinary avaliam as imagens enviadas para garantir o conteúdo apropriado e detectar e filtrar materiais potencialmente ofensivos antes que se tornem acessíveis ao público, tornando-os seguros e em conformidade, mantendo um ambiente compatível e promovendo uma experiência segura e fácil de usar para os visitantes do nosso site. .
Para obter mais informações sobre os produtos Cloudinary, consulte nossa documentação.
Observação: as ferramentas de moderação do Cloudinary estão disponíveis como complementos e os limites de uso são determinados pelo seu plano de assinatura.
Para implementar a segurança de arquivos usando Cloudinary:
1. Cadastre-se para criar uma conta e obter credenciais de API. Assista a este vídeo rápido para instalar e configurar o Cloudinary em seu aplicativo Python.
2. Visite a página Complementos nas configurações do console Cloudinary e assine os complementos Rekognition Moderation AI e Perception Point.
3. Adapte e integre o código fornecido conforme necessário para garantir uma segurança robusta dos arquivos.
import cloudinary.uploader
import cloudinary.utils
# Configure Cloudinary with your credentials
cloudinary.config(
cloud_name = 'your_cloud_name',
api_key = 'your_api_key',
api_secret = 'your_api_secret'
)
# Upload a file securely using HTTPS, name it new_image, and automatically run it through moderation to block inappropriate and malicious files from being uploaded.
upload_result = cloudinary.uploader.upload('path/to/your/image.jpg', public_id='new_image', secure=True, moderation=’aws_rek|perception_point')
if result['moderation'][0].get('status') == 'approved'
print('Secure upload successful:',
upload_result['secure_url'])
# Display the image in an HTML template.
else:
print('The image failed moderation'])
Verificação de dependência OWASP: verifica dependências em busca de vulnerabilidades.
Você pode estar introduzindo riscos ao seu projeto sem saber por meio de dependências do projeto. A verificação de dependências do OWASP automatiza a identificação de vulnerabilidades nessas dependências. Isso aumenta significativamente a segurança dos aplicativos e permite a detecção precoce e a rápida resolução de vulnerabilidades durante o processo de desenvolvimento.
Veja como instalar o OWASP dependency-Check para verificar seu projeto.
1. Vá para. [OWASP DependencyCheck](https://github.com/jeremylong/DependencyCheck) Repositório no GitHub.
2.[**リリース**]Role para baixo e clique na versão mais recente para baixar o arquivo ZIP.
3. “descompacte ~Downloads/verificação de dependência-“
4. Digite cd dependency-check/bin para mudar para o diretório dependency-check/bin.
5. Digite ls para exibir os arquivos no diretório. Você deverá ver “dependency-check.bat” e “dependency-check.sh”.
6. Digite pwd para obter o caminho do arquivo.
Veja como digitalizar seu projeto:
1. Mude os diretórios para o diretório do projeto que deseja verificar.
2. No prompt de comando, digite: <dependency-check-path>/dependency-check.sh –scan <project_name>
ObservaçãoNota: Na primeira vez que você executar o Dependency-Check, pode levar algum tempo para que a lista de todas as vulnerabilidades seja baixada.
3. Depois que o relatório for gerado, visualize-o como uma página da web digitando: firefox dependency-check-report.html. Este relatório fornece uma visão geral dos arquivos do seu projeto e de todas as vulnerabilidades de terceiros encontradas, juntamente com sua gravidade. Role para baixo para detalhar todas as vulnerabilidades e conselhos sobre o que fazer a seguir.
Bandido: verifique seu código em busca de vulnerabilidades
Resolver manualmente todas as falhas de segurança em sua base de código pode ser uma tarefa difícil. Em vez disso, o Bandit fornece detecção automática de vulnerabilidades para identificar possíveis problemas de segurança em seu código.
Para escanear seu projeto com o Bandit:
1. Instale o Bandit usando pip.
pip install bandit
-
Basta ir ao diretório que contém seu código Python e executar o seguinte comando para verificar todos os arquivos em seu projeto que contenham problemas de baixa gravidade.
bandit -r . -ll
Práticas recomendadas de segurança adicionais
Além de contar com medidas de segurança robustas incorporadas ao Python e a ferramentas de terceiros, certifique-se de seguir as práticas recomendadas de segurança em sua rotina de codificação. Por exemplo, sempre faça hash e criptografe senhas e dados confidenciais usando uma biblioteca como: fernet e cryptography.
Além disso, para garantir que suas chaves e segredos de API nunca sejam expostos, os Use uma biblioteca ou variáveis de ambiente. Além disso, preste atenção à validação de entrada do usuário, ao tratamento de erros e ao uso de instruções SQL preparadas para interações seguras com o banco de dados.
conclusão
Manter a segurança do Python em seu aplicativo requer extremo cuidado. Aproveite os recursos de segurança integrados e o middleware fornecidos pelo Python para se proteger contra possíveis adulterações.
Além disso, é importante integrar ferramentas essenciais de terceiros para lidar com tarefas que estão além de suas capacidades, como proteger arquivos e verificar vulnerabilidades em dependências e bases de código. Automatize esses processos usando ferramentas como Cloudinary, OWASP dependency-check e Bandit.
Além disso, lembre-se de priorizar a segurança em sua rotina de codificação.
Proteger aplicativos Python é fundamental para sua segurança e integridade. Aja agora para implementar eficazmente estas medidas de segurança.
Remova todas as informações acima antes de criar e enviar seu rascunho. obrigado!
