Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Django-faille-CVE-2025-57833_test — Dimostrazione proof-of-concept a scopo educativo dell'iniezione SQL tramite alias dinamici nei metodi annotate() e alias() di Django (CVE-2025-57833). Include codice vulnerabile, esempio di sfruttamento e analisi della correzione. | Kitploit
Strumenti/GitHubGitHub/loic-houchi/django-faille-cve-2025-57833_test
Analisi StaticaAnalisi delle VulnerabilitàAnalisi del CodiceSfruttamento di Applicazioni WebApprendimento e FormazioneSicurezza dei Database
GitHubloic-houchi/django-faille-cve-2025-57833_test

Django-faille-CVE-2025-57833_test

Dimostrazione proof-of-concept a scopo educativo dell'iniezione SQL tramite alias dinamici nei metodi annotate() e alias() di Django (CVE-2025-57833). Include codice vulnerabile, esempio di sfruttamento e analisi della correzione.

Vedi Repository
231 anno faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

Test della vulnerabilità SQL Injection tramite alias in Django

Definizione: cos'è un alias?

Un alias è un nome dato a una colonna o a un risultato di aggregazione in una query SQL.
In Django, gli alias vengono utilizzati con i metodi annotate() o alias() per nominare campi calcolati.

Esempio:

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

Qui, book_count è un alias per il risultato di Count('id').
Ciò consente di ottenere un nome leggibile per una colonna calcolata.


Inserimento dei dati tramite shell

Per andare veloci, si possono inserire i dati tramite la shell:

root@kitploit:~
python manage.py shell

Comandi da eseguire:

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()

Contesto della vulnerabilità

Prima di Django 4.2.23, era possibile iniettare SQL tramite alias dinamici forniti dall'utente.
Questa vulnerabilità è nota come CVE-2025-57833.

Colpiva le funzioni annotate() e alias() quando veniva utilizzato un dizionario con espansione (**kwargs) con chiavi non filtrate provenienti dall'utente.


Esempio di codice vulnerabile (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)})

Spiegazioni:

  1. alias_param = request.GET.get("alias", "{}")
    Recupera il valore del parametro alias passato dall'utente.

  2. alias_dict = json.loads(alias_param)
    Trasforma la stringa JSON in un dizionario Python.

  3. alias_dict[key] = eval(value)
    ⚠️ Molto pericoloso: eval() esegue la stringa come codice Python.
    L'utente potrebbe iniettare SQL distruttivo.

  4. Author.objects.annotate(**alias_dict)
    Applica dinamicamente le annotazioni con gli alias forniti.


Modelli (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

Spiegazione:

  • Author e Book sono collegati da una relazione ForeignKey.
  • Le annotazioni dinamiche vengono utilizzate su Author per calcolare informazioni sui suoi libri.

Esempio di sfruttamento prima della correzione

  • URL dannosa:
root@kitploit:~
http://127.0.0.1:8000/vuln/?alias={"evil); DROP TABLE myapp_book;--":"Count('id')"}
  • Rischio:
    • Esecuzione di qualunque comando SQL, eliminazione di tabelle o modifica di dati.
    • Ciò sfrutta direttamente la vulnerabilità tramite l'alias iniettato.

Correzione in Django 4.2.23

  • Django ora vieta alcuni caratteri negli alias:

    • Spazi
    • Virgolette
    • Punto e virgola
    • Commenti SQL (--)
  • Se l'URL contiene questi caratteri, Django solleva un errore:

root@kitploit:~
Column aliases cannot contain whitespace characters, quotation marks, semicolons, or SQL comments.
  • Conseguenza: nessuna iniezione SQL distruttiva è possibile.

Esempio sicuro

root@kitploit:~
http://127.0.0.1:8000/vuln/?alias={"books_count":"Count('book')"}
  • Questo non costituisce una falla.
  • La falla nelle versioni vulnerabili (CVE-2025-57833) si presenta solo se un utente malintenzionato può iniettare SQL tramite:
    • caratteri vietati nell'alias (spazio, punto e virgola, virgolette, commenti SQL)
    • oppure eval() su valori provenienti dall'utente.

Buone pratiche per evitare questa falla

  1. Non usare mai eval() su dati forniti dall'utente.
  2. Validare i nomi degli alias per accettare solo caratteri sicuri.
  3. Limitare i valori di annotazione a funzioni o espressioni autorizzate.
  4. Mantenere Django aggiornato per beneficiare delle correzioni.

Conclusione

  • La vulnerabilità CVE-2025-57833 permetteva di iniettare SQL tramite alias dinamici.
  • Django 4.2.23 e versioni successive correggono questa falla.
  • La validazione rigorosa dei dati forniti dall'utente rimane indispensabile.

Autore: Loïc
Data: 06/09/2025

Scarica lo strumento