Skip to content
KitploitKITPLOIT
HerramientasBlog
Enviar
HerramientasBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

··Feeds·Contacto·Privacidad·© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
Django-faille-CVE-2025-57833_test — Prueba de concepto educativa que demuestra la inyección SQL a través de alias dinámicos en los métodos annotate() y alias() de Django (CVE-2025-57833). Incluye código vulnerable, ejemplo de explotación y análisis de la corrección. | Kitploit
Herramientas/GitHubGitHub/loic-houchi/django-faille-cve-2025-57833_test
Análisis EstáticoAnálisis de VulnerabilidadesAnálisis de CódigoExplotación de Aplicaciones WebAprendizaje y EducaciónSeguridad de Bases de Datos
GitHubloic-houchi/django-faille-cve-2025-57833_test

Django-faille-CVE-2025-57833_test

Prueba de concepto educativa que demuestra la inyección SQL a través de alias dinámicos en los métodos annotate() y alias() de Django (CVE-2025-57833). Incluye código vulnerable, ejemplo de explotación y análisis de la corrección.

Ver Repositorio
23hace 1 añoAún no revisado

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →
Compartir

Prueba de la vulnerabilidad de inyección SQL mediante alias en Django

Definición: ¿Qué es un alias?

Un alias es un nombre dado a una columna o a un resultado de agregación en una consulta SQL.
En Django, los alias se utilizan con los métodos annotate() o alias() para nombrar campos calculados.

Ejemplo:

root@kitploit:~
from django.db.models import Count
books = Book.objects.annotate(book_count=Count('id'))

Aquí, book_count es un alias para el resultado de Count('id').
Esto permite obtener un nombre legible para una columna calculada.


Inserción de datos mediante el shell

Para ir rápido, se pueden insertar los datos mediante el shell:

root@kitploit:~
python manage.py shell

Comandos a ejecutar:

root@kitploit:~
from myapp.models import Author, Book

a = Author.objects.create(name=" houchi pierre")
Book.objects.create(title="Les belles filles", author=a)
Book.objects.create(title="Les baux arcons", author=a)

exit()

Contexto de la vulnerabilidad

Antes de Django 4.2.23, era posible inyectar SQL mediante alias dinámicos proporcionados por el usuario.
Esta vulnerabilidad es conocida como CVE-2025-57833.

Afectaba a las funciones annotate() y alias() cuando se utilizaba un diccionario con expansión (**kwargs) con claves no filtradas provenientes del usuario.


Ejemplo de código vulnerable (myapp/views.py)

root@kitploit:~
import json
from django.db.models import Count
from django.http import JsonResponse
from .models import Author

def vulnerable_view(request):
    # On récupère l'alias depuis l'URL
    alias_param = request.GET.get("alias", "{}")
    try:
        # ⚠️ Vulnérable : évaluation directe des données utilisateurs
        alias_dict = json.loads(alias_param)
        for key, value in alias_dict.items():
            alias_dict[key] = eval(value)  # dangereux ! permet l'exécution de code arbitraire

        # Création de la queryset avec annotation dynamique
        qs = Author.objects.annotate(**alias_dict).values("name", *alias_dict.keys())

        # Retour des résultats
        return JsonResponse(list(qs), safe=False)

    except Exception as e:
        return JsonResponse({"error": str(e)})

Explicaciones:

  1. alias_param = request.GET.get("alias", "{}")
    Obtiene el valor del parámetro alias pasado por el usuario.

  2. alias_dict = json.loads(alias_param)
    Transforma la cadena JSON en un diccionario Python.

  3. alias_dict[key] = eval(value)
    ⚠️ Muy peligroso: eval() ejecuta la cadena como código Python.
    El usuario podría inyectar SQL destructivo.

  4. Author.objects.annotate(**alias_dict)
    Aplica dinámicamente las anotaciones con los alias proporcionados.


Modelos (myapp/models.py)

root@kitploit:~
from django.db import models

class Author(models.Model):
    name = models.CharField(max_length=100)
    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=100)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    def __str__(self):
        return self.title

Explicación:

  • Author y Book están relacionados por una relación ForeignKey.
  • Las anotaciones dinámicas se utilizan en Author para calcular información sobre sus libros.

Ejemplo de explotación antes de la corrección

  • URL maliciosa:
root@kitploit:~
http://127.0.0.1:8000/vuln/?alias={"evil); DROP TABLE myapp_book;--":"Count('id')"}
  • Riesgo:
    • Ejecución de cualquier comando SQL, eliminación de tablas o modificación de datos.
    • Esto explota directamente la vulnerabilidad mediante el alias inyectado.

Corrección en Django 4.2.23

  • Django prohíbe ahora ciertos caracteres en los alias:

    • Espacios
    • Comillas
    • Punto y coma
    • Comentarios SQL (--)
  • Si la URL contiene estos caracteres, Django lanza un error:

root@kitploit:~
Column aliases cannot contain whitespace characters, quotation marks, semicolons, or SQL comments.
  • Consecuencia: ninguna inyección SQL destructiva es posible.

Ejemplo seguro

root@kitploit:~
http://127.0.0.1:8000/vuln/?alias={"books_count":"Count('book')"}
  • Esto no constituye una falla.
  • La falla en las versiones vulnerables (CVE-2025-57833) solo aparece si un usuario malintencionado puede inyectar SQL mediante:
    • caracteres prohibidos en el alias (espacio, punto y coma, comillas, comentarios SQL)
    • o eval() en valores provenientes del usuario.

Buenas prácticas para evitar esta falla

  1. Nunca usar eval() en datos de usuarios.
  2. Validar los nombres de alias para aceptar solo caracteres seguros.
  3. Limitar los valores de anotación a funciones o expresiones permitidas.
  4. Mantener Django actualizado para beneficiarse de las correcciones.

Conclusión

  • La vulnerabilidad CVE-2025-57833 permitía inyectar SQL mediante alias dinámicos.
  • Django 4.2.23 y superiores corrigen esta falla.
  • La validación estricta de los datos de usuario sigue siendo indispensable.

Autor: Loïc
Fecha: 06/09/2025

Descargar herramienta