Unvollständige Behebung von Algorithmus-Verwechslungen in Authlib ermöglicht HMAC-Fälschung mit vorangestellten öffentlichen Schlüsseln
Zusammenfassung
OctKey.import_key() enthält die einzige Schutzvorrichtung, die verhindert, dass ein asymmetrischer öffentlicher Schlüssel als HMAC-Geheimnis in authlib.jose verwendet wird. Diese Schutzvorrichtung ist raw_key.startswith(POSSIBLE_UNSAFE_KEYS) — verankert bei Byte 0 —, während der Loader, der die identischen Bytes auf dem asymmetrischen Pfad verarbeitet (cryptography.hazmat.primitives.serialization.load_pem_public_key / load_pem_x509_certificate), alles vor der Zeile -----BEGIN überspringt. Ein PEM-formatierter öffentlicher Schlüssel oder ein X.509-Zertifikat mit einem vorangestellten Byte — einem Zeilenumbruch, einem Leerzeichen, vier Einrückungsleerzeichen, einem UTF-8-BOM oder einer Kommentarzeile — wird daher nicht erkannt, fällt durch die Prüfung und wird als HMAC-Geheimnis verwendet. Ein Angreifer, der lediglich den öffentlichen Schlüssel des Ausstellers besitzt, kann dann ein HS256-Token mit beliebigen Claims erzeugen, das von jwt.decode() als authentisch akzeptiert wird.
Dies ist eine unvollständige Behebung von CVE-2024-37568 / GHSA-5357-c2jx-v7qh. Der Fix dieses Sicherheitshinweises bestand genau aus dieser Schutzvorrichtung (git log -S 'POSSIBLE_UNSAFE_KEYS' -- authlib/jose/rfc7518/oct_key.py liefert einen einzelnen Commit, 3bea812 „fix: prevent OctKey to import ssh/rsa/pem keys“, unter Bezugnahme auf Issue #654), und der ursprüngliche Angriff funktioniert erneut unverändert, wenn das gespeicherte PEM nicht bei Offset 0 beginnt.
End-to-End reproduziert auf 1.8.0, der neuesten Version (veröffentlicht am 2026-08-30), und auf origin/main (c529a61), mit cryptography 50.0.2.
Voraussetzungen
Beides sind Eigenschaften des Deployments; keine davon ist zur Anfragezeit vom Angreifer kontrollierbar, und der Angreifer benötigt weder ein Geheimnis noch Benutzerinteraktion.
-
Die Relying Party verwendet das dokumentierte Objekt auf Modulebene
jwt.from authlib.jose import jwtwird beiauthlib/jose/__init__.py:55-72mit der vollständigen Liste["HS256","HS384","HS512","RS256",...,"EdDSA"]erstellt, undJsonWebToken.decode(authlib/jose/rfc7519/jwt.py:80) stellt keinen Parameteralgorithmsbereit, sodass ein Aufrufer des dokumentierten Objekts keine Möglichkeit hat, diese einzuschränken. Dies ist das erste Codebeispiel indocs/jose/jwt.rst:21-31.Diese Gefahr ist bereits dokumentiert:
docs/jose/jwt.rst:73-79besagt: „This decoding method is insecure. By defaultjwt.decodeparses the alg header. This allows symmetric macs and asymmetric signatures.“, unddocs/jose/jwt.rst:94-98besagt: „You should never combine symmetric (HS) and asymmetric (RS, ES, PS) signature schemes.“ Der Kern dieses Berichts ist nicht, dass die gemischte Liste existiert — sondern dass die Schutzvorrichtungoct_key.py:81, die genau für diese dokumentierte Gefahr bereitgestellt wurde, nicht greift. -
Der Verifizierungsschlüssel wird als PEM-/Zertifikatstext übergeben, dessen Bytes bei Offset 0 nicht mit
-----BEGINbeginnen. Bei jeder der folgenden Varianten wurde eine erfolgreiche Fälschung bestätigt, und jede verifiziert mit denselben Bytes weiterhin ein echtes RS256/ES256-Token, sodass im Deployment nichts fehlerhaft erscheint:- ein vorangestellter Zeilenumbruch — wie er durch ein dreifach gequotetes Python-Literal erzeugt wird
- ein vorangestelltes Leerzeichen
- eine Einrückung um vier Leerzeichen — ein eingerückter YAML/JSON/TOML-Konfigurationsblock
- ein UTF-8-BOM — ein Artefakt von Windows-Editoren
- eine vorangestellte Kommentarzeile
- all dies angewendet auf ein X.509-
CERTIFICATE-PEM anstelle einesPUBLIC KEY-PEM
Ein reines DER-SPKI-Blob umgeht die Schutzvorrichtung ebenfalls, jedoch kann DER über diesen Pfad nicht für eine echte asymmetrische Verifizierung verwendet werden, weshalb dies als nicht einsatzfähige Konfiguration ausgeschlossen und nur als weiterer Beleg für die Diskrepanz zwischen Erkennung und Loader erwähnt wird.
Details
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 ist verankert. Der Loader auf dem asymmetrischen Pfad ist es nicht: authlib/jose/rfc7517/_cryptography_key.py:22-29 ruft load_pem_public_key / load_pem_x509_certificate auf, die beide nach vorne scannen, um den Armor-Header zu finden. Die Menge der Bytefolgen, die die Erkennung zurückweist, ist daher strikt kleiner als die Menge, die der Loader akzeptiert, und dieser Unterschied ist ausnutzbar.
Ablauf für einen Aufrufer des dokumentierten Objekts:
authlib/jose/rfc7518/jws_algs.py:59—HMACAlgorithm.prepare_key(raw_data)gibtOctKey.import_key(raw_data)zurück; dies ist die gesamte HMAC-Schlüsselbehandlung.authlib/jose/rfc7519/jwt.py:80—JsonWebToken.decode(self, s, key, claims_cls=None, claims_options=None, claims_params=None); der Algorithmus stammt aus dem Token-Header und wird nur gegen die Liste der Instanz geprüft.authlib/jose/__init__.py:55-72— diese Liste enthält sowohl HS* als auch RS*/ES*/PS*/EdDSA.
Somit ist oct_key.py:81 die einzige Barriere zwischen einer gemischten Zulassungsliste und der Verwendung des öffentlichen Schlüssels als HMAC-Geheimnis, und sie wird durch ein einziges vorangestelltes Byte umgangen.
PoC
poc-authlib-e2e-http.py richtet eine Flask-API ein, deren einzige Authentifizierung das dokumentierte jwt.decode(token, PUBLIC_KEY) ist, wobei PUBLIC_KEY der öffentliche RSA-Schlüssel des Ausstellers ist, der als dreifach gequotetes Python-Literal eingebettet ist (daher ein vorangestellter Zeilenumbruch). Der Angreifer erhält ausschließlich diesen öffentlichen Schlüssel.
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"}')
Die drei Kontrollprüfungen belegen, dass die Schutzvorrichtung bei einem kanonischen PEM funktioniert (das vorangestellte Byte ist also ausschlaggebend), dass die reguläre Signaturprüfung intakt ist und dass das Festlegen (Pinning) des Algorithmus eine wirksame Abhilfemaßnahme darstellt.
Matrix pro Format für beide Schlüsseltypen mit Kontrollprüfung, die belegt, dass eine echte asymmetrische Verifizierung mit exakt denselben Bytes weiterhin gelingt:
### 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.
Schritte zur Reproduktion
pip install authlib==1.8.0 cryptography flask requests- Erzeugen Sie ein RSA-2048-Schlüsselpaar; serialisieren Sie den öffentlichen Schlüssel nach PEM und stellen Sie einen Zeilenumbruch voran (oder rücken Sie ihn ein, stellen Sie ein BOM oder eine Kommentarzeile voran).
- Bestätigen Sie, dass
authlib.jose.rfc7518.oct_key.POSSIBLE_UNSAFE_KEYSdiese Bytes nicht mitstartswithabgleicht, währendcryptography.hazmat.primitives.serialization.load_pem_public_keysie lädt. from authlib.jose import jwtdanntok = jwt.encode({"alg":"HS256"}, {"sub":"attacker","role":"admin"}, mutated_pem)jwt.decode(tok, mutated_pem)— die Verifizierung gelingt und die Claims werden zurückgegeben.
Auswirkungen
Umgehung der kryptografischen Signaturprüfung, die zu einer Umgehung der Authentifizierung führt (CWE-347, Algorithm Confusion). Ein nicht authentifizierter Angreifer, der nur den öffentlichen Verifizierungsschlüssel des Ausstellers kennt — definitionsgemäß öffentlich, normalerweise unter /.well-known/jwks.json oder in IdP-Metadaten bereitgestellt —, fälscht Token mit beliebigen Claims, einschließlich administrativer Rollen und beliebiger Subjects. Im PoC liefert dies ein HTTP 200 und die administrativen Geheimnisse der Anwendung für sub=attacker.
Authlib verzeichnete im letzten Monat 103,356,930 PyPI-Downloads (pypistats /api/packages/authlib/recent, Abruf 2026-10-01), weshalb hier die Umgehung einer Schutzvorrichtung gemeldet wird und nicht nur das dokumentierte Fehlbedienungsrisiko, das sie absichern sollte.
Zwei Hinweise für die Prüfung, im Sinne der Vollständigkeit:
authlib.josegibtAuthlibDeprecationWarningaus („please use joserfc instead. It will be compatible before version 2.0.0“). Es ist veraltet, wird jedoch weiterhin ausgeliefert, ist weiterhin indocs/jose/jwt.rstdokumentiert und weist weiterhin das oben genannte Downloadvolumen auf.- joserfc ist von diesem Mechanismus nicht betroffen. 1.7.5 wurde überprüft: Schlüssel verfügen über ein explizites
ktyim Datenmodell, weshalbjwt.decodemitRSAKey/ECKeyundalg=HS256bei jedem der sieben vom Loader akzeptierten FormateInvalidKeyTypeErrorauslöst. Die Typisierung des Schlüssels anstelle der Prüfung seiner Bytes verhindert diese Fehlerklasse dort strukturell.
Vorgeschlagene Abhilfemaßnahmen
Jede dieser Maßnahmen schließt die gesamte Fehlerklasse, anstatt nur ein weiteres Byte-Muster abzufangen:
- Schlüsselfamilie nach Typ, nicht nach Bytes bestimmen. Führen Sie
load_pem_public_key/load_pem_x509_certificate/load_ssh_public_key/load_der_public_keyauf dem Kandidaten aus und weisen Sie ihn alsoct-Schlüssel zurück, falls eine davon erfolgreich ist. Dieser Ansatz macht joserfc immun und kann nicht vom Loader abweichen, da er der Loader ist. - Falls ein einfacher Erkennungsmechanismus beibehalten werden muss, sollte dieser als Substring-Suche statt als verankerter Präfix-Check implementiert werden (
any(m in raw_key for m in POSSIBLE_UNSAFE_KEYS)), ergänzt um die Fälle-----BEGIN CERTIFICATE-----und DERSubjectPublicKeyInfo. Dies ist strikt schwächer als (1): Die Erkennung kann erneut abweichen, sobaldcryptographytoleranter wird.
Unabhängig von diesem Bericht: Das Hinzufügen eines algorithms=-Parameters zu JsonWebToken.decode würde Aufrufern des dokumentierten Objekts auf Modulebene ermöglichen, die in der Dokumentation empfohlene Absicherung anzuwenden, ohne ein zweites JsonWebToken erstellen zu müssen.
Danksagung
Gefunden von zer0d4y5. Gerne bereit, einen Patch-Branch vor dem Release zu testen.
Was zu tun ist
Aktualisieren Sie Authlib auf Version 1.9.0 oder neuer. Alternativ kann die Schlüsseltyp-Validierung anstelle einer Byte-Prüfung implementiert werden, oder die Kombination von symmetrischen und asymmetrischen Algorithmen durch explizite Einschränkung der erlaubten Algorithmen vermieden werden.
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
| Plattform | Paket | Anfällige Versionen | Behoben in |
|---|---|---|---|
| Python (PyPI) | authlib | >= 1.3.1, < 1.9.0 | 1.9.0 |
Verweise
- 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
- CVSS-Vektor
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N- Schwäche (CWE)
CWE-184, CWE-347- Plattform
- Python (PyPI)
- Paket
authlib- Veröffentlicht
- 22.10.2026
- Aktualisiert
- 31.10.2026 10:00
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
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
Schwachstellenhistorie: authlib
Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
- Einträge insgesamt
- 19
- Erste → letzte
- 06.2024 10.2026
- Ohne Fix
- 0
- In Angriffen ausgenutzt
- 0
Verteilung nach Schweregrad
- Kritisch 2
- Hoch 7
- Mittel 9
- Niedrig 1
Veröffentlichungen pro Jahr
- 2024: 1
- 2025: 3
- 2026: 15
-
Unvollständige Behebung von Algorithmus-Verwechslungen in Authlib ermöglicht HMAC-Fälschung mit vorangestellten öffentlichen Schlüsseln dieser Eintrag
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.