Modello didattico offline di CVE-2026-112936 (filelock SQLite symlink follow)
Laboratorio locale per CVE-2026-112936 (GHSA-j8f7-rjxc-mr56): ReadWriteLock di filelock indicizzava le proprie istanze tramite Path(lock_file).resolve() e lasciava che sqlite3.connect() aprisse il percorso del lock, così un symlink piantato su quel percorso veniva seguito: il processo creava o bloccava il file a cui il link puntava, e ripuntando il link si davano a due processi "il" lock di scrittura su file diversi. La correzione, commit 4d45e83caf7e (filelock 4.0.9), apre il percorso con O_NOFOLLOW | O_NONBLOCK, rifiuta qualsiasi cosa che non sia un file regolare, risolve solo la directory padre per la chiave e connette SQLite tramite /proc/self/fd/N. Didattico, deterministico, C11 verificato con ASan/UBSan.
Nessun SQLite, nessun filelock, nessuna rete, nessun altro utente. Ogni caso costruisce i propri nomi all'interno di una sandbox mkdtemp() nuova, esegue le due aperture con vere syscall e rimuove la sandbox; l'output è composto solo da etichette e chiavi relative alla sandbox.
Spagnolo: README.es.md. Esercizi: PRACTICE.md.
src/filelock/_read_write.py)| Riga del diff | Codice | Laboratorio |
|---|---|---|
| vecchia 212, vecchia 309 | pathlib.Path(lock_file).resolve() | chiave pre: fl_resolve (non strict, segue i link) |
| nuova 224-225, nuova 322 | pathlib.Path(_canonical(lock_file)), "risolve solo il padre" | chiave post: fl_canonical (padre risolto, nome mantenuto) |
| vecchia 740-746 | sqlite3.connect(database, ...) | apertura pre: sostituto open(name, O_RDWR|O_CREAT|O_NONBLOCK) |
| nuova 54-55 | _DB_OPEN_FLAGS = O_RDWR|O_CREAT|O_NOFOLLOW|O_NONBLOCK | flag di apertura post, modalità 0600 (nuova 775) |
| nuova 776-779 | if not S_ISREG(os.fstat(fd).st_mode): chiusura, "rifiuto di un database di lock non regolare" | REFUSED_NONREG |
| nuova 753-765, 59 | mantiene l'fd; target = f"{_FD_DIR}/{fd}" (/proc/self/fd su Linux) | azione reopen |
Il GHSA afferma che il VFS di SQLite risolve il symlink finale nello spazio utente, quindi fs.protected_symlinks e lo sticky bit non lo fermano; il sostituto pre del laboratorio lascia invece che il kernel segua il link, il che dà lo stesso risultato in una sandbox a utente singolo. _canonical risiede in _api.py, fuori dal diff: viene modellato solo il suo commento ("risolve solo il padre").
results/)| Al percorso del lock | pre | post |
|---|---|---|
symlink a private/pwned.flag (mancante), anche tramite una catena | FOLLOWED_CREATED, un nuovo file fuori dal percorso del lock | REFUSED_SYMLINK, nulla creato |
| symlink a un file esistente (assoluto o relativo) | FOLLOWED_EXISTING, chiave = il target | REFUSED_SYMLINK, chiave = il link |
| symlink a una FIFO / a una directory / a se stesso / a una directory mancante | OPENED_NONREG / ERR_EISDIR / ERR_ELOOP / ERR_ENOENT | REFUSED_SYMLINK |
| FIFO | OPENED_NONREG | REFUSED_NONREG |
| link ripuntato tra due aperture (passo 3 del PoC del GHSA) | EXCLUSION_BROKEN, chiavi S/a.db e S/b.db | REFUSED |
| link sostituito dopo la validazione, poi connessione | REOPEN_FOLLOWED (il nome viene aperto di nuovo) | REOPEN_SAME_INODE (/proc/self/fd/N) |
| file regolare, nome mancante, directory, padre symlinkato, hard link | uguale in entrambi | uguale in entrambi |
results/sweep.csv attraversa 13 tipi di oggetto al percorso del lock. Su 400 configurazioni casuali i test verificano che post non crei mai un nome fuori dal percorso del lock, rifiuti sempre un symlink finale, e che senza un symlink finale entrambe le versioni concordino tranne che per i file non regolari.
Due casi sono osservazioni del laboratorio, non scoperte: un hard link al percorso (c13) viene aperto da entrambe le versioni (O_NOFOLLOW riguarda i symlink; fs.protected_hardlinks non è modellato), e rinominare il file di lock altrove e crearne uno nuovo tra due aperture (s04) divide l'inode in entrambe le versioni; farlo sul file di un altro utente in una directory sticky richiede permessi che il laboratorio non modella.
sh scripts/build.sh test # -Wall -Wextra -Werror, ASan + UBSan
python3 scripts/derive_expected.py | diff - fixtures/expected.tsv
sh scripts/build.sh results /tmp/r && diff -r results /tmp/r
./build/fllab case pre 'F:a.db;L:lock.db>a.db' 'open:lock.db'
fixtures/cases.tsv contiene casi positivi, negativi, limite e fuori dominio
con etichette derivate manualmente. fixtures/expected.tsv proviene da
scripts/derive_expected.py, che esegue gli stessi scenari con il modulo
os di Python nella propria sandbox e calcola la chiave pre con il vero
resolve() di pathlib; i test C confrontano le etichette e le chiavi con entrambi.
Un modello non è una scoperta: vedi LIMITATIONS.md e SOURCES.md. Licenza: Apache-2.0.