PyGoat Analizando la seguridad en aplicaciones Django.pdf

PyGoat: Analizando la
seguridad en aplicaciones
Django José Manuel Ortega
@jmortegac

Agenda
● Introducción a la seguridad en aplicaciones
Django
● Pygoat como ejemplo de aplicación vulnerable
● Vulnerabilidades OWASP top 10 y mitigación

Introducción a la seguridad en aplicaciones Django
● Inyección SQL: El ORM (Object-Relational Mapping) de Django puede
prevenir algunos tipos de inyección SQL, pero no es infalible. Se debe
tener cuidado de escapar correctamente cualquier entrada
suministrada por el usuario al crear consultas SQL.
● Cross-site scripting (XSS): El motor de plantillas de Django escapa
automáticamente cualquier dato que se muestre en una página, pero
aún es posible crear una vulnerabilidad si los datos suministrados por el
usuario se incluyen en un script JavaScript.
● Falsiﬁcación de petición en sitios cruzados (CSRF): Django incluye
protección contra CSRF por defecto, pero esta protección puede ser
eludida si el desarrollador no toma las medidas adecuadas.

● Vulnerabilidades de carga de archivos: Si una aplicación permite a los
usuarios subir archivos, es importante validar correctamente los
archivos para evitar que se ejecute código malicioso en el servidor.
● Vulnerabilidades de divulgación de archivos: Los desarrolladores
deben asegurarse de que cualquier archivo que no esté destinado a ser
accesible públicamente esté debidamente protegido contra el acceso
no autorizado.
● Validación de entrada inadecuada: Los desarrolladores no
comprueban las entradas del usuario, lo que da lugar a posibles
inyecciones de código en la plantilla. Esto se conoce comúnmente como
CWE-20: Improper Input Validation.

● Vulnerabilidades SQL Injection
● CVE-2022-34265: Potential SQL injection via
Trunc(kind) and Extract(lookup_name) arguments

● https://github.com/django/django/commit/54eb8
a374d5d98594b264e8ec22337819b37443c

● CVE-2023-31047: Potential bypass of validation
when uploading multiple ﬁles using one form ﬁeld
● https://www.djangoproject.com/weblog/2023/ma
y/03/security-releases/
● https://nvd.nist.gov/vuln/detail/CVE-2023-31047

def insecure(request):
with connection.cursor() as cursor:
baz = request.GET.get('baz')
cursor.execute(f"SELECT foo FROM bar WHERE baz =
{baz}")
row = cursor.fetchone()
# ...
1 ; DELETE FROM users ;

def secure(request):
with connection.cursor() as cursor:
baz = request.GET.get('baz')
cursor.execute("SELECT foo FROM bar WHERE baz = %s",
[baz])
row = cursor.fetchone()

● Utilizar un mapeador relacional de objetos (ORM). Te ahorra escribir
consultas SQL manualmente y previene automáticamente inyecciones
SQL.
● El ORM más popular es SQLAlchemy https://www.sqlalchemy.org

● Impacto SQL Injection
● Exponer información confidencial
● Acceso no autorizado
● Denegación de servicio
● Ejecución de código

● Prevenir SQL Injection
● Consultas parametrizadas
● Validaciones en parámetros de entrada
● Prácticas de codificación segura
● Firewall de aplicaciones web (WAF)

Pygoat como ejemplo de aplicación vulnerable
● https://owasp.org/www-project-pygoat
● https://github.com/adeyosemanputra/pygoat
● https://hub.docker.com/r/pygoat/pygoat
$ docker pull pygoat/pygoat
$ docker run --rm -p 8000:8000
pygoat/pygoat

Vulnerabilidades OWASP top 10 y mitigación
● A1: Broken Access Control(Control de acceso roto)
● El control de acceso, a veces llamado autorización, es la
forma en que una aplicación web otorga acceso al
contenido y las funciones a algunos usuarios y no a otros.
● Estas comprobaciones se realizan después de la
autenticación y rigen lo que los usuarios "autorizados"
pueden hacer.

● Implementar mecanismos de control de acceso una vez y
reutilizarlos en toda la aplicación.
● Los controles de acceso al modelo deben validar que el usuario
pueda crear, leer, actualizar o eliminar cualquier registro.
● Deshabilitar la lista de directorios del servidor web
● Los identiﬁcadores de sesión con estado deben invalidarse en el
servidor después de cerrar sesión.

● Los tokens de sesión (como los JWT) incluyen información sobre el
usuario que ha iniciado sesión.
○ Validar que el token de sesión no está caducado
○ Comprobar que el token es válido
○ Veriﬁcar si el usuario (su información está en el token de
sesión) tiene permitido realizar peticiones al endpoint actual

● A3: Inyección
● La inyección ocurre cuando un atacante introduce datos
que no son de conﬁanza y engaña al intérprete para que
haga cosas que no debería, como ejecutar comandos no
deseados o acceder a datos no autorizados.

● A3: Inyección
● Proporcionar una interfaz parametrizada o utilizar otras herramientas de
mapeo relacional de objetos (ORM).
● Realizar validación de parámetros de entrada del lado del servidor.
● Para cualquier consulta dinámica, escapar los caracteres especiales
utilizando la sintaxis de escape especíﬁca para ese intérprete.

● A5: Security Misconﬁguration
● Se habilitan o instalan funciones innecesarias (por ejemplo, puertos,
servicios, páginas, cuentas o privilegios innecesarios).
● Las cuentas predeterminadas y sus contraseñas están habilitadas.
● El manejo de errores revela seguimientos de pila u otros mensajes de
error demasiado informativos para los usuarios.

● A5: Security Misconﬁguration
● El modo de depuración de Django estaba habilitado. Esto puede provocar
que se muestren a los usuarios mensajes de error y variables de entorno.
● En un entorno de producción, el modo de depuración debe desactivarse
utilizando la siguiente conﬁguración de Django (settings.py):
● DEBUG = False

● A8 Software and Data Integrity Failures
● Las errores de integridad del software y de los datos se relacionan con
código e infraestructura que no protegen contra violaciones de
integridad. Un ejemplo de esto es cuando una aplicación depende de
bibliotecas o módulos de fuentes, repositorios que no son conﬁables.
● Ataques relacionados con objetos y estructuras de datos en los que el
atacante modiﬁca la lógica de la aplicación o logra la ejecución remota de
código arbitrario si hay clases disponibles para la aplicación que pueden
cambiar el comportamiento durante o después de la deserialización.

● user+<script>document.getElementById("download_link").setA
ttribute("href"%2C"%2Fstatic%2Ffake.txt")%3B<%2Fscript>us
er+<script>document.getElementById("download_link").setAttr
ibute("href"%2C"%2Fstatic%2Ffake.txt")%3B<%2Fscript>
● La URL de descarga se modiﬁca y el usuario puede descargar un archivo
arbitrario conﬁando en el dominio.

● A10: Server Side Request Forgery (SSRF)
● Esta vulnerabilidad ocurre cada vez que una aplicación web busca un
recurso remoto sin validar la URL proporcionada por el usuario.
● Permite que la aplicación redireccione a una URL controlada por el
atacante.
● Ataques comunes: ataques a servicios/archivos internos, ataques a URL
externas (DoS)

https://github.com/boomcamp/django-security

from django.contrib.auth.decorators import
login_required
from django.http import HttpResponse
@login_required
def secure_view(request):
# Your view logic here
return HttpResponse(“This is a secure view”)

from functools import wraps
def admin_only(view_func):
@wraps(view_func)
def wrapper(request, *args, **kwargs):
if request.user.is_superuser:
return view_func(request, *args, **kwargs)
else:
return HttpResponse(“Access Denied”)
return wrapper

from django.contrib.auth import authenticate, login
def login_view(request):
if request.method == ‘POST’:
username = request.POST[‘username’]
password = request.POST[‘password’]
user = authenticate(request, username=username, password=password)
if user is not None:
login(request, user)
return HttpResponse(“Login successful”)
else:
return HttpResponse(“Invalid credentials”)
else:
# Render login form
return HttpResponse(“Login form”)

from django.http import HttpResponsePermanentRedirect
class EnforceHttpsMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
if not request.is_secure():
url = request.build_absolute_uri(request.get_full_path())
secure_url = url.replace(‘http://’, ‘https://’)
return HttpResponsePermanentRedirect(secure_url)
return self.get_response(request)

from django.core.validators import FileExtensionValidator
from django.forms import forms
class FileUploadForm(forms.Form):
file = forms.FileField(validators=[FileExtensionValidator(allowed_extensions=[‘pdf’,
‘docx’])])

<form method=”post” action=”/submit-form/”>
{% csrf_token %}
<!—Form fields –>
<button type=”submit”>Submit</button>
</form>

from django import forms
from django.utils.html import escape
class SecureForm(forms.Form):
name = forms.CharField(max_length=100)
email = forms.EmailField()
def clean_name(self):
name = self.cleaned_data[‘name’]
# Sanitize user input
sanitized_name = escape(name)
return sanitized_name
def clean_email(self):
email = self.cleaned_data[‘email’]
# Validate and sanitize user input
if not email.endswith(‘@domain.com’):
raise forms.ValidationError(“Invalid email domain”)
sanitized_email = escape(email)
return sanitized_email

¡Gracias!
@jmortegac
https://www.linkedin.com/in/jmortega1
https://jmortega.github.io
https://josemanuelortegablog.com
https://www.marcombo.com/desarrollo-
de-microservicios-con-python-9788426
737199
https://www.marcombo.com/desarrollo-
seguro-en-ingenieria-del-software-aplic
aciones-seguras-con-android-nodejs-p
ython-y-c-9788426728005/

PyGoat Analizando la seguridad en aplicaciones Django.pdf

Recommended

Recommended

More Related Content

Similar to PyGoat Analizando la seguridad en aplicaciones Django.pdf

Similar to PyGoat Analizando la seguridad en aplicaciones Django.pdf (20)

More from Jose Manuel Ortega Candel

More from Jose Manuel Ortega Candel (20)

Recently uploaded

Recently uploaded (20)

PyGoat Analizando la seguridad en aplicaciones Django.pdf