llamaCVEVulnerability Intelligence
/
Advisory · GitHub · Go · github.com/dunglas/frankenphp

GHSA-4PRG-HV4R-G6MV

FrankenPHP aborta todo el proceso del servidor al registrar un array manipulado

Parche disponible
Descargar PNG JSON
CVSS 3.1
5.9
Media
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H Fuente: GitHub
ExplotaciónSin evidenciaNo figura en CISA KEV
Exploits públicos0Ninguno conocido
Parche1 versiónPrimer parche el mismo día de la divulgación
Exposición48 dDesde la divulgación, 4 oct 2026, 9:04 a. m.
Detección46 dDesde la divulgación hasta su ingreso al índice
Decisión estimadaSeguir
Remediar en la ventana regular de mantenimiento
Estimación de Llama con el árbol SSVC de CISA a partir de vector CVSS 3.1 y la evidencia de explotación (sin evaluación oficial): sin explotación conocida, no automatizable e impacto técnico parcial. Hay versiones corregidas disponibles.
Mi diagnóstico: un ticket y una sonrisa.Esta la tienes controlada, confío en ti.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada +1
Explotación
Remediación
Parche v1.13.0
Monitoreo
Detectada +1
4 oct 26
19 nov 26
21 nov 26
4 oct 26
16 oct 26
28 oct 26
9 nov 26
21 nov 26
FechaFaseEventoDetalle
Divulgación Publicada GHSA-4PRG-HV4R-G6MV divulgada · CVSS 5.9 (GitHub)
Divulgación Modificada Última actualización del registro
Remediación Parche v1.13.0 github.com/dunglas/frankenphp · 0 d desde divulgación
Monitoreo Detectada Ingresó al índice
Monitoreo Verificada Última verificación contra las fuentes
Resumen
Traducción automática · Ver original
Descripción del advisory
Traducción automática · GitHub

Resumen

`types.go` de `goArray()` realiza una aserción de tipo de interfaz sin verificación en la rama que maneja los buckets sin clave de cadena, es decir, los elementos con clave entera de una tabla hash de Zend no empaquetada:

// types.go:156-161
// as fallback convert the bucket index to a string key
strIndex := strconv.Itoa(int(bucket.h))
entries[strIndex] = v.(T)        // ← types.go:158, no nil guard

`goValue()` reporta un `null` de PHP como una interfaz nil (`types.go:278` / `types.go:355`), y `v.(T)` entra en pánico con una interfaz nil para cualquier `T`, incluido `any`. La rama de clave de cadena, unas líneas más arriba, sí protege este caso (`types.go:143-147`, `entries[keyStr] = v.(T)` solo en el `else` de `if v == nil`); el respaldo para claves enteras no lo hace.

El pánico se produce dentro de un callback de cgo: Go no puede desenrollar la pila hacia C, y una búsqueda en todo el repositorio de `recover()` devuelve cero apariciones (tanto en código de producción como de pruebas). El resultado no es una solicitud fallida, sino un aborto de todo el proceso (código de salida 2), que derriba todos los vhosts, todos los inquilinos y todas las solicitudes en curso atendidas por esa instancia.

Tres rutas de producción llegan a este punto. Las rutas 1 y 2 están verificadas de extremo a extremo aquí (compiladas, ejecutadas y con el aborto del proceso observado); la ruta 3 es el mismo camino de código alcanzado desde la API de extensiones documentada, solo verificada mediante documentación:

  1. `frankenphp_log()`: la API de registro estructurado documentada (`frankenphp.stub.php:52-56`) → `frankenphp.c:1012` → `frankenphp.go:767` `GoMap[any]()` → `types.go:82` → `types.go:158`.
  2. El valor de retorno de un callback de worker: `frankenphp.c:925` → `threadworker.go:284` `GoValue[any]()` → `types.go:345` → `types.go:158`. Nótese que en un despliegue de worker de Caddy común, este valor de retorno no lo consume nadie (solo `SendMessage` de la API de extensiones en Go lo lee), pero devolver ese array igualmente mata el proceso.
  3. La API de extensiones documentada: `docs/extensions.md:225-237` muestra una función PHP exportada declarada como `process_data_unordered(array $input)` cuyo cuerpo es `frankenphp.GoMap[any](unsafe.Pointer(arr))`; cualquier extensión en Go que acepte un array de PHP desde la aplicación o la solicitud y lo convierta con la llamada documentada hereda el mismo fallo.

Detalles

Causa raíz

`goValue()` no puede señalar "esto era un null" mediante su valor de error de retorno: un `null` se convierte en un `any` nil con `err == nil`:

// types.go:276-278
case C.IS_NULL:
    resAny = any(nil)
...
// types.go:355-357
if resAny == nil {
    return resZero, nil      // nil interface, err == nil
}

`goArray()` luego trata los dos tipos de bucket de forma asimétrica:

// types.go:130-162 (abreviado)
for i := C.uint32_t(0); i < nNumUsed; i++ {
    bucket := C.get_ht_bucket_data(array, i)
    if bucket == nil || C.zval_get_type(&bucket.val) == C.IS_UNDEF {
        continue
    }

    v, err := goValue[any](&bucket.val)
    if err != nil {
        return nil, nil, err
    }

    if bucket.key != nil {                       // string key → guarded
        keyStr := GoString(unsafe.Pointer(bucket.key))
        if v == nil {
            entries[keyStr] = zeroVal
        } else {
            entries[keyStr] = v.(T)              // types.go:146
        }
        if ordered { order = append(order, keyStr) }
        continue
    }

    // as fallback convert the bucket index to a string key
    strIndex := strconv.Itoa(int(bucket.h))
    entries[strIndex] = v.(T)                    // types.go:158 — UNGUARDED
    if ordered { order = append(order, strIndex) }
}

Zend almacena las claves enteras en el campo `h` del bucket y deja `key == NULL`:

typedef struct _Bucket {
	zval         val;
	zend_ulong   h;    /* hash value (or numeric index) */
	zend_string *key;  /* string key or NULL for numerics */
} Bucket;

por lo que cualquier elemento con clave entera de una tabla hash real (no empaquetada) toma la rama sin protección. La rama `packed` de `types.go:105-126` es segura por otro motivo: asigna `e, err := goValue[T](v)` directamente en el mapa, sin aserción de tipo, por lo que este defecto queda confinado a la ruta de claves enteras no empaquetadas. Tanto los comentarios citados como la frontera empaquetado/hash se verificaron contra php-src: `_zend_hash_index_add_or_update_i` almacena un índice numérico por debajo de `nTableSize` (8 para un array nuevo) como slot empaquetado y rellena el hueco con `ZVAL_UNDEF` (`zend_hash.c:1104-1137`), mientras que una clave >= 8 sin una heurística de crecimiento coincidente llama a `zend_hash_packed_to_hash()` (`zend_hash.c:1146-1155`); insertar cualquier clave de cadena también convierte la tabla. El comportamiento medido coincide exactamente con esto; véase la tabla de desencadenantes más abajo (las claves 0-7 sobreviven, las >= 8 provocan el aborto).

`v.(T)` sobre una interfaz nil entra en pánico por definición del lenguaje; verificado en Go 1.27:

recovered: interface conversion: interface is nil, not interface {}

El propio contrato de la API indica claramente la intención: se supone que informa de los fallos de conversión en lugar de morir. `frankenphp.go:767-769` ya devuelve `"Failed to log message: converting attrs: …"` como excepción de PHP en la ruta de `err`, y `frankenphp.stub.php:54` documenta `$context` como valores que "will be converted to the corresponding Go type (if supported by FrankenPHP)".

Por qué muere el proceso en lugar de fallar la solicitud
  • El pánico ocurre en una función de Go llamada desde C (el bucle de hilos de PHP); Go no puede desenrollar los marcos de C, así que el runtime imprime el volcado de la goroutine y termina.
  • No existe ningún `recover()` en todo el repositorio (verificado con grep: cero apariciones en código de producción y de pruebas).
  • Resultado observado de una única solicitud HTTP: el proceso principal del contenedor `Running=false exit=2`; el cliente ve `curl: (52) Empty reply from server`.
Condiciones de activación (medidas)

El array debe ser una tabla hash real y no un array empaquetado, y debe contener un elemento con clave entera cuyo valor sea `null`. Cualquiera de estas dos condiciones convierte el array en una tabla hash real: (a) cualquier clave de cadena en cualquier parte del array, o (b) una clave numérica que Zend no puede mantener como slot empaquetado. Para un array nuevo `nTableSize` es 8, así que una clave numérica única `>= 8` convierte la tabla (`zend_hash.c:1146-1155`), mientras que las claves `< 8` se almacenan como slots empaquetados con huecos `IS_UNDEF` y, por lo tanto, la rama empaquetada, que no usa aserciones, las omite. La carga útil puede anidarse a cualquier profundidad, porque `goValue()` recorre recursivamente los arrays anidados (`types.go:345`).

| Cuerpo de la solicitud (`json_decode($body, true)`) | Forma interna de PHP | Resultado |
|---|---|---|
| `{"a":1,"2":null}` | hash con claves mixtas | aborto del proceso |
| `{"a":1,"0":null}` | hash con claves mixtas | aborto del proceso |
| `{"x":9,"1":null}` | hash con claves mixtas | aborto del proceso |
| `{"a":1,"10":null}` | hash con claves mixtas | aborto del proceso |
| `{"a":1,"-1":null}` | hash con claves mixtas | aborto del proceso |
| `{"a":1,"1":null,"b":2}` | hash con claves mixtas | aborto del proceso |
| `["x",{"a":1,"0":null}]` | externo empaquetado, interno hash | aborto del proceso |
| `{"a":{"b":1,"0":null}}` | externo empaquetado, interno hash | aborto del proceso |
| `{"2":null}` | clave numérica única < 8 → slot empaquetado con huecos `IS_UNDEF` | sobrevive |
| `{"8":null}`, `{"9":null}`, `{"10":null}`, `{"12":null}` | clave numérica única >= 8 → `zend_hash_packed_to_hash()` | aborto del proceso |
| `{"0":null,"1":null}`, `[null]`, `[]` | empaquetado | sobrevive |
| `{"a":null}` | solo clave de cadena | sobrevive (rama protegida) |
| `{"a":1,"2":"x"}` | clave entera, valor no nulo | sobrevive |

Son necesarios tanto el `null` como una clave entera: un null con clave de cadena toma la rama protegida, una clave entera con valor no nulo hace que la aserción tenga éxito, y un null con clave entera empaquetada (claves 0-7 sin clave de cadena en el array) lo gestiona la rama empaquetada, que no usa aserciones. Obsérvense las filas de anidamiento y las de clave única: filtrar solo los campos de primer nivel no es una mitigación, y un objeto de un solo campo, como `{"8":null}`, ya es suficiente.

PoC

A. `php_server` (sin worker): la configuración del manejador por defecto
{
	frankenphp
}

:80 {
	root * /app/public
	php_server
}

Sobre este Caddyfile. Es la forma *mínima*: solo importan el bloque global de la app `frankenphp` y `php_server`.
`/app/public/logapi.php`: registro estructurado habitual del cuerpo de la solicitud decodificado:

<?php
$data = json_decode(file_get_contents('php://input'), true) ?? [];
frankenphp_log('request', FRANKENPHP_LOG_LEVEL_INFO, is_array($data) ? $data : []);
echo "handled-ok\n";

```console
$ docker run -d --name fp-poc -p 8080:80 dunglas/frankenphp:latest
$ docker cp logapi.php fp-poc:/app/public/logapi.php
$ docker cp Caddyfile fp-poc:/etc/frankenphp/Caddyfile
$ docker restart fp-poc

$ docker exec fp-poc frankenphp version
FrankenPHP v1.12.7 PHP 8.5.9 Caddy v2.11.4

# benign body: 200, logged normally
$ curl -i -X POST -H 'Content-Type: application/json' \
--data-binary '{"a":1,"b":2}' http://127.0.0.1:8080/logapi.php
handled-ok
HTTP/1.1 200 OK

$ docker

Incluye detalles técnicos publicados por el investigador. Úselos solo para validar y corregir sus propios sistemas.

Vector CVSS 3.1

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:H
BajaAlta
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaRequerida
AlcanceS:U
CambiadoSin cambio
ConfidencialidadC:N
AltoBajoNinguno
IntegridadI:N
AltoBajoNinguno
DisponibilidadA:H
AltoBajoNinguno
Score de explotaciónQué tan fácil y probable es que la exploten
7.1/ 10Alto
Vector 7.1 (fácil) · sin evidencia de explotación.
Versiones

Rangos afectados

Afectada Corregida Última
github.com/dunglas/frankenphp≤ 1.12.7
1.12.7
v1.13.6
Remediación

Estado del parche por paquete

Paquete / productoEstadoCorregida enDesde divulgaciónÚltima versión
gogithub.com/dunglas/frankenphp
Corregida v1.13.0 0 d v1.13.6 no afectada
Versiones corregidasv1.13.0
Explotación

Arsenal público

Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.

Referencias
Advisoryhttps://github.com/php/frankenphp/security/advisories/GHSA-4prg-hv4r-g6mv

Las referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.