Files
skills/orchestrator/client/passkey.py
T
Kevin Veen-BirkenbachandClaude Opus 5.5 0e569323fb fix(orchestrator): refuse RS256 passkeys under 2048 bits
passkey.py accepted an RS256 public key of any modulus size. It now refuses a modulus under 2048 bits at registration and at every verification, before either signature backend, with a fixed error asking for a new passkey; the library backend checks key_size again and the openssl backend's key_type requires the same size. The SubjectPublicKeyInfo is read as strict DER (no negative or padded INTEGERs, minimal lengths, no unused bits, no trailing data) and the rsaEncryption identifier must match exactly. ES256 and EdDSA are unchanged. An already pinned weak key is refused on every use until a new passkey is pinned. Accepted MEDUSA findings: AIC-EXFIL-005 and PRIV-SCAN-762 at tests/hub_support.py:151 (public half of a throwaway test key) and PQC001 at passkey.py:236 (WebAuthn offers no post-quantum algorithm yet).

🎯 Fix: 95 %
💥 Break: 3 %
💸 Cost: –
⏱️ Time: –
🛡️ Security: 100 %
🏆 Score: 92
🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 %

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-13 18:48:04 +00:00

311 lines
13 KiB
Python

from __future__ import annotations
import base64
import hashlib
import json
import re
import subprocess
import tempfile
from pathlib import Path
from signing import RP_ID, Refused, b64encode, challenge
try:
from cryptography.exceptions import InvalidSignature, UnsupportedAlgorithm
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec, ed25519, padding, rsa
except ImportError:
serialization = None
FLAG_UP = 0x01
FLAG_AT = 0x40
EC_PREFIX = bytes.fromhex("3059301306072a8648ce3d020106082a8648ce3d030107034200")
P256_PRIME = 2**256 - 2**224 + 2**192 + 2**96 - 1
P256_B = 0x5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B
ED_PREFIX = bytes.fromhex("302a300506032b6570032100")
RSA_IDENTIFIER = bytes.fromhex("300d06092a864886f70d0101010500")
RSA_MIN_BITS = 2048
NOT_RSA = "the RS256 key is no RSA public key"
B64URL = re.compile(r"[A-Za-z0-9_-]+")
ASSERTION_KEYS = ("id", "clientDataJSON", "authenticatorData", "signature")
CBOR_DEPTH = 16
TIMEOUT = 30
def b64decode(text: object, name: str) -> bytes:
if not isinstance(text, str) or not B64URL.fullmatch(text):
raise Refused(f"{name} is no base64url text")
try:
return base64.urlsafe_b64decode(text + "=" * (-len(text) % 4))
except ValueError as error:
raise Refused(f"{name} is no base64url text") from error
def cbor(data: bytes, offset: int, depth: int) -> tuple[object, int]:
if depth > CBOR_DEPTH or offset >= len(data):
raise Refused("the CBOR data is truncated or nests too deep")
major, info = data[offset] >> 5, data[offset] & 0x1F
offset += 1
value = info
if 24 <= info <= 27:
size = 1 << (info - 24)
if offset + size > len(data):
raise Refused("the CBOR data is truncated")
value = int.from_bytes(data[offset : offset + size], "big")
offset += size
elif info > 27:
raise Refused("the CBOR data uses an indefinite or reserved length")
if major == 0:
return value, offset
if major == 1:
return -1 - value, offset
if major in (2, 3):
chunk = data[offset : offset + value]
if len(chunk) != value:
raise Refused("the CBOR data is truncated")
if major == 2:
return chunk, offset + value
try:
return chunk.decode("utf-8"), offset + value
except UnicodeDecodeError as error:
raise Refused("the CBOR text is no UTF-8") from error
if major == 4:
items = []
for _ in range(value):
item, offset = cbor(data, offset, depth + 1)
items.append(item)
return items, offset
if major == 5:
entries: dict = {}
for _ in range(value):
key, offset = cbor(data, offset, depth + 1)
if isinstance(key, bool) or not isinstance(key, int | str) or key in entries:
raise Refused("the CBOR map holds a bad or repeated key")
entries[key], offset = cbor(data, offset, depth + 1)
return entries, offset
if major == 7 and info in (20, 21, 22):
return {20: False, 21: True, 22: None}[info], offset
raise Refused("the CBOR data holds an unsupported item")
def der(tag: int, body: bytes) -> bytes:
size = len(body)
if size < 0x80:
return bytes([tag, size]) + body
octets = size.to_bytes((size.bit_length() + 7) // 8, "big")
return bytes([tag, 0x80 | len(octets)]) + octets + body
def der_integer(value: bytes) -> bytes:
digits = value.lstrip(b"\x00") or b"\x00"
return der(0x02, b"\x00" + digits if digits[0] & 0x80 else digits)
def der_item(data: bytes, offset: int, tag: int) -> tuple[bytes, int]:
if offset + 2 > len(data) or data[offset] != tag:
raise Refused(NOT_RSA)
size, offset = data[offset + 1], offset + 2
if size & 0x80:
width = size & 0x7F
head = data[offset : offset + width]
size, offset = int.from_bytes(head, "big"), offset + width
if size < 0x80 or head[0] == 0:
raise Refused(NOT_RSA)
if not 0 < size <= len(data) - offset:
raise Refused(NOT_RSA)
return data[offset : offset + size], offset + size
def der_whole(data: bytes, offset: int, tag: int) -> bytes:
body, end = der_item(data, offset, tag)
if end != len(data):
raise Refused(NOT_RSA)
return body
def der_unsigned(data: bytes, offset: int) -> tuple[int, int]:
body, end = der_item(data, offset, 0x02)
if body[0] & 0x80 or (body[0] == 0 and len(body) > 1 and not body[1] & 0x80):
raise Refused(NOT_RSA)
return int.from_bytes(body, "big"), end
def rsa_bits(spki: bytes) -> int:
outer = der_whole(spki, 0, 0x30)
if not outer.startswith(RSA_IDENTIFIER):
raise Refused(NOT_RSA)
bits = der_whole(outer, len(RSA_IDENTIFIER), 0x03)
if bits[0]:
raise Refused(NOT_RSA)
public = der_whole(bits, 1, 0x30)
modulus, offset = der_unsigned(public, 0)
if der_unsigned(public, offset)[1] != len(public):
raise Refused(NOT_RSA)
return modulus.bit_length()
def refuse_weak(alg: object, spki: bytes) -> None:
if alg == -257 and rsa_bits(spki) < RSA_MIN_BITS:
raise Refused(f"the RS256 key has a modulus under {RSA_MIN_BITS} bits; register a new passkey")
def octets(value: object, size: int) -> bool:
return isinstance(value, bytes) and len(value) == size
def p256_point(x: object, y: object) -> bytes | None:
# KeePassXC 2.7.12 drops leading zero bytes of x and y (Botan BigInt as hex), against RFC 9053; pad them back to 32.
if not all(isinstance(value, bytes) and 1 <= len(value) <= 32 for value in (x, y)):
return None
left, right = int.from_bytes(x, "big"), int.from_bytes(y, "big")
if left >= P256_PRIME or right >= P256_PRIME or (right * right - left**3 + 3 * left - P256_B) % P256_PRIME:
return None
return b"\x04" + left.to_bytes(32, "big") + right.to_bytes(32, "big")
def cose_key(key: object) -> tuple[int, bytes]:
if not isinstance(key, dict):
raise Refused("the credential public key is no COSE map")
kty, alg = key.get(1), key.get(3)
if kty == 2 and alg == -7 and key.get(-1) == 1 and (point := p256_point(key.get(-2), key.get(-3))):
return alg, EC_PREFIX + point
if kty == 1 and alg == -8 and key.get(-1) == 6 and octets(key.get(-2), 32):
return alg, ED_PREFIX + key[-2]
if kty == 3 and alg == -257 and isinstance(key.get(-1), bytes) and isinstance(key.get(-2), bytes) and key[-1] and key[-2]:
public = der(0x30, der_integer(key[-1]) + der_integer(key[-2]))
return alg, der(0x30, RSA_IDENTIFIER + der(0x03, b"\x00" + public))
raise Refused("the key is none of ES256 on P-256, EdDSA on Ed25519 or RS256")
def client_data(raw: bytes, kind: str, origin: str) -> dict:
try:
client = json.loads(raw)
except (ValueError, RecursionError) as error:
raise Refused("clientDataJSON is no JSON") from error
if not isinstance(client, dict) or client.get("type") != kind:
raise Refused(f"clientDataJSON is no {kind}")
if client.get("origin") != origin or client.get("crossOrigin") is True:
raise Refused(f"the origin is not {origin}")
return client
def rp_flags(data: bytes, size: int) -> int:
if len(data) < size or data[:32] != hashlib.sha256(RP_ID.encode("ascii")).digest():
raise Refused(f"the rpIdHash is not the one of {RP_ID}")
if not data[32] & FLAG_UP:
raise Refused("the user presence flag is missing")
return data[32]
def attested(credential: object, origin: str) -> dict:
"""Args:
credential: {"id", "attestationObject", "clientDataJSON"} as the
settings panel encodes the navigator.credentials.create answer.
origin: the only origin the registration may come from.
Returns:
The entry to pin: {"id", "alg", "spki"}, the key as base64url DER.
"""
if not isinstance(credential, dict) or set(credential) != {"id", "attestationObject", "clientDataJSON"}:
raise Refused("the credential needs exactly id, attestationObject and clientDataJSON")
raw_id = b64decode(credential["id"], "id")
client_data(b64decode(credential["clientDataJSON"], "clientDataJSON"), "webauthn.create", origin)
blob = b64decode(credential["attestationObject"], "attestationObject")
attestation, end = cbor(blob, 0, 0)
if end != len(blob) or not isinstance(attestation, dict) or not isinstance(attestation.get("authData"), bytes):
raise Refused("the attestationObject holds no authData")
data = attestation["authData"]
if not rp_flags(data, 55) & FLAG_AT:
raise Refused("the registration carries no attested credential")
size = int.from_bytes(data[53:55], "big")
if data[55 : 55 + size] != raw_id:
raise Refused("the attested credential id differs from the id")
key, _ = cbor(data, 55 + size, 0)
alg, spki = cose_key(key)
refuse_weak(alg, spki)
return {"id": b64encode(raw_id), "alg": alg, "spki": b64encode(spki)}
def by_library(alg: int, spki: bytes, data: bytes, signature: bytes) -> bool:
try:
key = serialization.load_der_public_key(spki)
if alg == -7 and isinstance(key, ec.EllipticCurvePublicKey) and isinstance(key.curve, ec.SECP256R1):
key.verify(signature, data, ec.ECDSA(hashes.SHA256()))
elif alg == -8 and isinstance(key, ed25519.Ed25519PublicKey):
key.verify(signature, data)
elif alg == -257 and isinstance(key, rsa.RSAPublicKey) and key.key_size >= RSA_MIN_BITS:
key.verify(signature, data, padding.PKCS1v15(), hashes.SHA256())
else:
return False
except (InvalidSignature, UnsupportedAlgorithm, ValueError, TypeError):
return False
return True
def key_type(alg: int, spki: bytes) -> bool:
if alg == -7:
return len(spki) == len(EC_PREFIX) + 65 and spki.startswith(EC_PREFIX)
if alg == -8:
return len(spki) == len(ED_PREFIX) + 32 and spki.startswith(ED_PREFIX)
try:
return alg == -257 and rsa_bits(spki) >= RSA_MIN_BITS
except Refused:
return False
def by_openssl(alg: int, spki: bytes, data: bytes, signature: bytes) -> bool:
if not key_type(alg, spki):
return False
try:
with tempfile.TemporaryDirectory(prefix="kvb-orchestrator-verify-") as folder:
key, message, sealed = (Path(folder) / name for name in ("key.pem", "data.bin", "signature.bin"))
key.write_text(f"-----BEGIN PUBLIC KEY-----\n{base64.encodebytes(spki).decode('ascii')}-----END PUBLIC KEY-----\n", encoding="ascii")
message.write_bytes(data)
sealed.write_bytes(signature)
if alg == -8:
argv = ["openssl", "pkeyutl", "-verify", "-pubin", "-inkey", str(key), "-rawin", "-in", str(message), "-sigfile", str(sealed)]
else:
argv = ["openssl", "dgst", "-sha256", "-verify", str(key), "-signature", str(sealed), str(message)]
try:
done = subprocess.run(argv, capture_output=True, timeout=TIMEOUT, check=False)
except (OSError, subprocess.TimeoutExpired):
return False
except OSError as error:
raise Refused(f"openssl found no writable temporary directory (TMPDIR): {error.strerror}") from None
return done.returncode == 0
def verify_signature(alg: int, spki: bytes, data: bytes, signature: bytes) -> bool:
if serialization is None:
return by_openssl(alg, spki, data, signature)
return by_library(alg, spki, data, signature)
def verify_assertion(assertion: object, payload: dict, credentials: list[dict], origin: str) -> int:
"""Args:
assertion: {"id", "clientDataJSON", "authenticatorData", "signature"}
from navigator.credentials.get, base64url.
payload: the payload whose challenge the operator signed.
credentials: the pinned keys.
origin: the only origin the signature may come from.
Returns:
The authenticator's signature counter.
"""
if not isinstance(assertion, dict) or not all(isinstance(assertion.get(name), str) for name in ASSERTION_KEYS):
raise Refused("the assertion is incomplete")
credential = next((entry for entry in credentials if entry["id"] == assertion["id"]), None)
if credential is None:
raise Refused("the signing key is not pinned")
spki = b64decode(credential["spki"], "spki")
refuse_weak(credential["alg"], spki)
raw = b64decode(assertion["clientDataJSON"], "clientDataJSON")
if client_data(raw, "webauthn.get", origin).get("challenge") != challenge(payload):
raise Refused("the challenge is not the one of the payload")
data = b64decode(assertion["authenticatorData"], "authenticatorData")
rp_flags(data, 37)
signed = data + hashlib.sha256(raw).digest()
if not verify_signature(credential["alg"], spki, signed, b64decode(assertion["signature"], "signature")):
raise Refused("the signature does not verify with the pinned key")
return int.from_bytes(data[33:37], "big")