openbadgeslib 4.6.1__tar.gz → 4.6.2__tar.gz

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/Changelog.txt

@@ -4,6 +4,71 @@ OpenBadgesLib - Changelog
 Newest first. Dates are ISO 8601 (YYYY-MM-DD).
 
 
+* v4.6.2 - 2026-10-16
+
+  - security(deps): the openvc-core floor of `[eudi]`, `[ldp-sd]` and
+    `[oid4vci]` rises to 1.35.0. Two behaviours below it reach this
+    library's public API. An SD-JWT VC whose issuer JWT carries `aud`
+    verified for any relying party, so a badge its issuer restricted to one
+    verifier was honoured by all (RFC 7519 §4.1.3); 1.35.0 enforces it, and
+    `verify_badge_sd_jwt(audience=…)` now also gates it. And
+    `status_list_token_resolver(leeway_s=…)` took any number, so an infinite
+    leeway made an expired status-list token verify as current; 1.35.0
+    accepts whole seconds from 0 to 86400 only. Neither is an advisory in
+    openvc-core. The run-time guard of the ecdsa-sd-2023 verify path stays at
+    1.33.2, the security minimum of that path. `[ldp]` and `[ldp-sd]` also cap
+    pyld below 4: pyld 4.0 (unreleased, breaking) drops statements from the
+    signed dataset that 3.x keeps, an IRI with two `#` or a literal with an
+    invalid `@language`, which context validation does not refuse, so the
+    credential would still show what the proof no longer covers.
+
+  - security(eudi): `verify_badge_sd_jwt` enforces the badge's own
+    `validFrom` and `validUntil` on both trust paths (pinned key and X.509
+    trust anchors), and `issue_badge_sd_jwt` writes the credential's
+    `validUntil` as the issuer JWT's `exp`, and a `validFrom` still ahead as
+    `nbf`. A badge is a flat IETF SD-JWT VC, and openvc-core reads
+    `validFrom` / `validUntil` as a validity window only for a W3C VCDM
+    payload, so a badge past its `validUntil` verified as unexpired unless
+    `expires_in_s` happened to be passed; badges issued by other
+    implementations with only a `validUntil` were affected the same way. The
+    earlier of `validUntil` and `expires_in_s` wins, a window value that is
+    not an ISO 8601 timestamp with an offset (as `datetime.fromisoformat`
+    reads it, which is stricter before Python 3.11) fails closed, and the
+    leeway is the 60 seconds the other OB 3.0 verifiers use.
+    `issue_badge_sd_jwt` now refuses, with `EudiError`, to make `name`,
+    `achievement`, `validFrom` or `validUntil` selectively disclosable: a
+    holder could withhold the disclosure and present an expired badge as one
+    that never expires, and the stripped presentation still verified. Only
+    the recipient (`credentialSubject`) is meant to be withheld. A bare string
+    for `disclosable=` is refused too (it was read one character at a time,
+    which left the recipient in the clear), and `expires_in_s` must be a
+    number within about 317 years of now. Nothing can detect a withheld
+    disclosure on a badge that already exists, and an existing badge has no
+    `exp`/`nbf` for other verifiers: re-issue badges issued with a
+    `disclosable=` that named one of those claims, and any badge that must
+    stop verifying at its `validUntil` everywhere. The Type Metadata document
+    is unchanged, byte for byte (a change would break the `vct#integrity` pin
+    of every badge already issued), and a test now pins its hash.
+    With `x5c_trust_anchors`, `verify_badge_sd_jwt` no longer accepts a plain
+    JWT (a token with no `~`): openvc-core's `verify_credential` takes one
+    and then ignored `expected_vct` and `require_key_binding` and returned
+    another type, so a JWT signed by an anchored issuer passed as a badge;
+    the pinned-key path always refused it. `status_list_token_resolver`
+    validates `leeway_s` when it is built, so a bad value fails there rather
+    than on the first status check of a later badge. A hostile issuer JWT
+    header nested deeper than the JSON parser recurses now fails as
+    `EudiError` instead of escaping `verify_badge_sd_jwt(x5c_trust_anchors=…)`
+    as a bare `RecursionError`, and a window value too long to be a timestamp
+    is not echoed back in the error.
+
+  - fix(did): a `did:web` document nested deeper than the JSON parser
+    recurses, or deeper than 64 levels (a DID document is a handful), is
+    reported as the usual `OB3VerificationError` instead of escaping
+    `resolve_did`, `fetch_did_web_document` and the verifiers that resolve an
+    issuer's DID as a bare `RecursionError`. CPython 3.14 and later parse
+    nesting far past the recursion limit, so the parser alone no longer bounds
+    what the later `repr()` and `json.dumps` of the document survive.
+
 * v4.6.1 - 2026-10-14
 
   - security(ldp): `OB3LdpVerifier` reads only JSON its Data Integrity proof

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 4.6.1
+Version: 4.6.2
 Summary: Production-ready Python library & CLI for Open Badges 3.0 (W3C Verifiable Credentials): issue, verify, and revoke JWT-VC credentials with Bitstring Status Lists and did:web — plus strict OB 2.0 and legacy OB 1.0.
 Author-email: Luis González Fernández <luisgf@luisgf.es>, Jesús Cea Avión <jcea@jcea.es>
 License: LGPLv3
@@ -35,14 +35,14 @@ Requires-Dist: PyJWT[crypto]>=2.15.1
 Requires-Dist: cryptography>=45
 Requires-Dist: defusedxml>=0.7
 Provides-Extra: ldp
-Requires-Dist: pyld>=3.3.0; extra == "ldp"
+Requires-Dist: pyld<4,>=3.3.0; extra == "ldp"
 Provides-Extra: eudi
-Requires-Dist: openvc-core<2,>=1.33.2; extra == "eudi"
+Requires-Dist: openvc-core<2,>=1.35.0; extra == "eudi"
 Provides-Extra: ldp-sd
-Requires-Dist: openvc-core[data-integrity]<2,>=1.33.2; extra == "ldp-sd"
-Requires-Dist: pyld>=3.3.0; extra == "ldp-sd"
+Requires-Dist: openvc-core[data-integrity]<2,>=1.35.0; extra == "ldp-sd"
+Requires-Dist: pyld<4,>=3.3.0; extra == "ldp-sd"
 Provides-Extra: oid4vci
-Requires-Dist: openvc-core<2,>=1.33.2; extra == "oid4vci"
+Requires-Dist: openvc-core<2,>=1.35.0; extra == "oid4vci"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/openbadgeslib/ob3/did.py

@@ -258,14 +258,46 @@ def _fetch_did_web_document(did: str, fetch: Any) -> dict[str, Any]:
             "could not fetch DID document %s: %s" % (url, exc)) from exc
     try:
         doc = json.loads(raw.decode('utf-8'))
-    except (ValueError, UnicodeDecodeError) as exc:
+    except (ValueError, UnicodeDecodeError, RecursionError) as exc:
+        # RecursionError: the host serves a document nested deeper than the
+        # parser recurses, which is untrusted input like any other malformed one.
         raise OB3VerificationError(
             "malformed DID document at %s: %s" % (url, exc)) from exc
     if not isinstance(doc, dict):
         raise OB3VerificationError("DID document is not a JSON object")
+    if _nested_deeper_than(doc, MAX_DID_DOCUMENT_DEPTH):
+        raise OB3VerificationError(
+            "DID document at %s is nested more than %d levels deep"
+            % (url, MAX_DID_DOCUMENT_DEPTH))
     return doc
 
 
+#: A DID document is shallow (a handful of levels). json.loads accepts nesting
+#: far past what anything that later walks, repr()s or re-serialises the document
+#: survives (on CPython 3.14 and later its limit is a C stack budget, well beyond
+#: the recursion limit), and the host serving it is the one party the verifier
+#: does not control.
+MAX_DID_DOCUMENT_DEPTH = 64
+
+
+def _nested_deeper_than(value: Any, limit: int) -> bool:
+    """True if *value* (parsed JSON) has containers nested more than *limit*
+    deep. Iterative: the point is to survive input a recursive walk would not."""
+    stack: list[Tuple[Any, int]] = [(value, 1)]
+    while stack:
+        node, depth = stack.pop()
+        if isinstance(node, dict):
+            children: Any = node.values()
+        elif isinstance(node, list):
+            children = node
+        else:
+            continue
+        if depth > limit:
+            return True
+        stack.extend((child, depth + 1) for child in children)
+    return False
+
+
 def fetch_did_web_document(did: str, download: Any = None) -> dict[str, Any]:
     """Fetch and parse the DID document a did:web identifier resolves to.
 

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/openbadgeslib/ob3/eudi.py

@@ -41,15 +41,19 @@
 import base64
 import hashlib
 import json
+import math
+import time
 
+from datetime import datetime, timezone
 from typing import Any, Callable, Iterable, Mapping, Optional, Union, cast
 
 from .credential import OpenBadgeCredential
+from .._jsonmodel import _parse_iso
 from .._jws.utils import base64url_decode
 from ..errors import LibOpenBadgesException, UnknownKeyType
 from ..keys import (
     KeyType, detect_key_type, ec_curve_from_pem, public_jwk_from_pem)
-from ..util import download_file
+from ..util import CLOCK_SKEW_LEEWAY, download_file
 
 # A vct (Verifiable Credential Type) for Open Badges expressed as SD-JWT VC.
 OB3_SD_JWT_VCT = "https://purl.imsglobal.org/spec/ob/v3p0#OpenBadgeCredential"
@@ -61,6 +65,25 @@ OB3_SD_JWT_FORMAT = "dc+sd-jwt"
 # holder can present the achievement while withholding who they are.
 DEFAULT_DISCLOSABLE = ("credentialSubject",)
 
+# Claims issue_badge_sd_jwt refuses to make selectively disclosable. A holder
+# may withhold any disclosure and a withheld one is indistinguishable from a
+# decoy (RFC 9901 §9.7), so a disclosable validFrom/validUntil lets the holder
+# present an expired or not-yet-valid badge as one with no validity window; the
+# achievement and its name are what the badge IS, and the Type Metadata marks
+# them mandatory. Only the recipient identity is meant to be withheld.
+_NEVER_DISCLOSABLE = ("name", "achievement", "validFrom", "validUntil")
+
+# The largest leeway_s openvc-core accepts for a status-list token (one day).
+_MAX_LEEWAY_S = 86400
+
+# The longest validity timestamp worth parsing ("2026-10-16T12:34:56.123456+00:00"
+# is 32); anything longer is not one and is not echoed back in an error message.
+_MAX_TIMESTAMP_CHARS = 64
+
+# A bound on expires_in_s (about 317 years): enough for any real credential, and
+# it keeps the exp a number every verifier can read.
+_MAX_EXPIRES_IN_S = 10 ** 10
+
 _INSTALL_HINT = (
     "SD-JWT VC support needs the [eudi] extra: pip install openbadgeslib[eudi]")
 
@@ -183,8 +206,12 @@ def badge_type_metadata(vct: str = OB3_SD_JWT_VCT, *, name: str = "Open Badge 3.
 
     Its ``claims`` describe the payload :func:`badge_to_sd_jwt_claims` emits:
     ``name`` / ``achievement`` / ``validFrom`` are always disclosed (``mandatory``),
-    the recipient ``credentialSubject`` and ``validUntil`` are optional (selective
-    disclosure). ``vct`` is the type identifier a wallet resolves this from — it
+    the recipient ``credentialSubject`` and ``validUntil`` are optional (``sd:
+    allowed``). The document is deliberately left as published: :func:`issue_badge_sd_jwt`
+    never makes ``validUntil`` disclosable even though the document permits it
+    (nothing that reads Type Metadata enforces ``sd``), because a byte change here
+    would break the ``vct#integrity`` pin of every badge already issued against
+    the old bytes. ``vct`` is the type identifier a wallet resolves this from — it
     must equal the issued badge's ``vct`` (openvc-core enforces that identity
     check). Serve :func:`type_metadata_document_bytes` of this document at *vct*
     and pin it with :func:`type_metadata_integrity`.
@@ -428,6 +455,60 @@ def badge_credential_configuration(
     return configuration
 
 
+def _timestamp(value: Any, name: str) -> datetime:
+    """Parse a badge's validity timestamp (ISO 8601 with a UTC offset, as
+    ``datetime.fromisoformat`` reads it: stricter before Python 3.11), raising
+    ValueError with a short message whatever the value: it came from the
+    token and is never echoed back whole."""
+    if not isinstance(value, str):
+        raise ValueError("%s must be an ISO 8601 string, got a %s"
+                         % (name, type(value).__name__))
+    if len(value) > _MAX_TIMESTAMP_CHARS:
+        raise ValueError("%s is not an ISO 8601 timestamp (%d characters)"
+                         % (name, len(value)))
+    return _parse_iso(value, name)
+
+
+def _expiry(claims: Mapping[str, Any], expires_in_s: Optional[float]) -> Optional[int]:
+    """The issuer JWT ``exp`` for a badge: its ``validUntil`` and/or now plus
+    *expires_in_s*, whichever is earlier; None when it has neither."""
+    candidates: list[int] = []
+    if "validUntil" in claims:
+        try:
+            candidates.append(int(_timestamp(claims["validUntil"], "validUntil").timestamp()))
+        except (ValueError, OverflowError) as exc:
+            raise EudiError("cannot derive the expiry of this badge: %s" % exc) from exc
+    if expires_in_s is not None:
+        if (isinstance(expires_in_s, bool) or not isinstance(expires_in_s, (int, float))
+                or (isinstance(expires_in_s, float) and not math.isfinite(expires_in_s))
+                or abs(expires_in_s) > _MAX_EXPIRES_IN_S):
+            raise EudiError(
+                "expires_in_s must be a number of seconds within %d of now, got %r"
+                % (_MAX_EXPIRES_IN_S, expires_in_s))
+        candidates.append(int(time.time() + expires_in_s))
+    return min(candidates) if candidates else None
+
+
+def _not_before(claims: Mapping[str, Any]) -> Optional[int]:
+    """The issuer JWT ``nbf`` for a badge whose ``validFrom`` is still ahead:
+    the claim every SD-JWT VC verifier enforces, so a verifier that does not
+    know ``validFrom`` refuses it too. None for a badge valid from now or
+    earlier — setting it there would only turn a verifier's clock skew into a
+    refusal of a freshly issued badge."""
+    if "validFrom" not in claims:
+        return None
+    try:
+        starts = _timestamp(claims["validFrom"], "validFrom")
+    except ValueError as exc:
+        raise EudiError("cannot derive the start of this badge: %s" % exc) from exc
+    if starts <= datetime.now(timezone.utc):
+        return None
+    try:
+        return int(starts.timestamp())
+    except OverflowError as exc:
+        raise EudiError("cannot derive the start of this badge: %s" % exc) from exc
+
+
 def issue_badge_sd_jwt(
     credential: OpenBadgeCredential,
     *,
@@ -444,10 +525,22 @@ def issue_badge_sd_jwt(
     """Issue *credential* as an SD-JWT VC.
 
     Returns the compact SD-JWT (``<issuer-jwt>~<disclosure>~…``). Only claims in
-    *disclosable* that are actually present are made selectively disclosable.
-    Pass *holder_jwk* to bind the credential to a holder key (``cnf``) for a later
+    *disclosable* that are actually present are made selectively disclosable, and
+    ``name``, ``achievement``, ``validFrom`` and ``validUntil`` are not eligible:
+    naming one raises :class:`EudiError`, because a holder could withhold it
+    undetected (an expired badge would present as one with no expiry). Pass
+    *holder_jwk* to bind the credential to a holder key (``cnf``) for a later
     Key-Binding presentation. Ed25519, P-256 or P-384 keys only.
 
+    EXPIRY: the credential's ``validUntil`` is also written as the issuer JWT's
+    ``exp``, the claim every SD-JWT VC verifier enforces (a flat IETF payload's
+    ``validUntil`` is not read as a bound by the delegate). *expires_in_s* sets an
+    earlier expiry still; when both are present the earlier one wins, so neither
+    can lengthen the other. A credential whose ``validUntil`` is already past is
+    issued as it stands and fails verification as expired. A ``validFrom`` still
+    ahead is written as ``nbf`` for the same reason (not when it is now or past:
+    that would only turn a verifier's clock skew into a refusal).
+
     Pass *vct_integrity* (from :func:`type_metadata_integrity`) to embed a
     ``vct#integrity`` claim that pins the Type Metadata served at *vct*, so a
     wallet resolving it fails closed on any tampering — always disclosed,
@@ -492,6 +585,20 @@ def issue_badge_sd_jwt(
             "issue this copy from a credential without credentialStatus and pass "
             "status=build_token_status_reference(uri=…, index=…) with its own "
             "index in the status-list token.")
+    if isinstance(disclosable, (str, bytes)):
+        raise EudiError(
+            "disclosable must be an iterable of claim names, not a single "
+            "string (it would be read one character at a time)")
+    requested = list(disclosable)
+    refused = [name for name in requested if name in _NEVER_DISCLOSABLE]
+    if refused:
+        raise EudiError(
+            "%s cannot be selectively disclosable: a holder could withhold %s "
+            "undetected, so a verifier could not tell a badge without %s from "
+            "one that hides it. Only the recipient (credentialSubject) is "
+            "meant to be withheld."
+            % (", ".join(refused), "it" if len(refused) == 1 else "them",
+               "it" if len(refused) == 1 else "them"))
     status_claim = _status_claim(status) if status is not None else None
     _, _, _, SdJwtVcProofSuite = _require_openvc()
     signing_key = _signing_key(privkey_pem, kid or ("%s#key-1" % credential.issuer.id))
@@ -500,13 +607,19 @@ def issue_badge_sd_jwt(
         claims["vct#integrity"] = vct_integrity
     if status_claim is not None:
         claims["status"] = status_claim
+    expiry = _expiry(claims, expires_in_s)
+    if expiry is not None:
+        claims["exp"] = expiry
+    not_before = _not_before(claims)
+    if not_before is not None:
+        claims["nbf"] = not_before
     # "status" is never made selectively disclosable, whatever the caller passed
     # in *disclosable* — see the docstring.
-    present = [name for name in disclosable if name in claims and name != "status"]
+    present = [name for name in requested if name in claims and name != "status"]
     try:
         return cast(str, SdJwtVcProofSuite().issue(
             claims, signing_key=signing_key, disclosable=present, vct=vct,
-            holder_jwk=holder_jwk, expires_in_s=expires_in_s, x5c=x5c))
+            holder_jwk=holder_jwk, x5c=x5c))
     except EudiError:
         raise
     except Exception as exc:
@@ -536,6 +649,14 @@ def status_list_token_resolver(
     key, as ``openbadges-publish`` does for the Bitstring track). Writing your
     own is fine — it must return the verified token's claims dict.
     """
+    # The delegate validates this too (a whole number of seconds, 0 to 86400,
+    # from openvc-core 1.35.0; older releases clamped or took any number, so an
+    # infinite leeway made an expired list verify). Fail when the resolver is
+    # built, not on the first status check of some later badge.
+    if (isinstance(leeway_s, bool) or not isinstance(leeway_s, int)
+            or not 0 <= leeway_s <= _MAX_LEEWAY_S):
+        raise EudiError("leeway_s must be a whole number of seconds from 0 to %d, "
+                        "got %r" % (_MAX_LEEWAY_S, leeway_s))
     fetch = download if download is not None else download_file
 
     def resolve(uri: str) -> dict[str, Any]:
@@ -610,6 +731,32 @@ def _check_sd_jwt_status(claims: Mapping[str, Any], *, require_status: bool,
     return result
 
 
+def _check_validity_window(claims: Mapping[str, Any]) -> None:
+    """Enforce the badge's own ``validFrom`` / ``validUntil`` on verified claims.
+
+    The delegate reads them as a validity window only for a W3C VCDM payload
+    (one with a VCDM ``@context``); this track's payload is a flat IETF SD-JWT
+    VC, so on its own a badge past its ``validUntil`` verifies as long as its
+    ``exp`` (which :func:`issue_badge_sd_jwt` derives from it) is absent or
+    unexpired. Third-party badges, and badges issued before ``exp`` was
+    derived, rely on this. Same window and the same leeway as the other OB 3.0
+    verifiers (``CLOCK_SKEW_LEEWAY``); a value that is present but not a
+    timestamp with an offset fails closed.
+    """
+    now = datetime.now(timezone.utc)
+    for name in ("validFrom", "validUntil"):
+        if name not in claims:
+            continue
+        try:
+            when = _timestamp(claims[name], name)
+        except ValueError as exc:
+            raise EudiError("badge has a malformed %s: %s" % (name, exc)) from exc
+        if name == "validUntil" and when < now - CLOCK_SKEW_LEEWAY:
+            raise EudiError("badge has expired (validUntil %s)" % claims[name])
+        if name == "validFrom" and when > now + CLOCK_SKEW_LEEWAY:
+            raise EudiError("badge is not yet valid (validFrom %s)" % claims[name])
+
+
 def verify_badge_sd_jwt(
     token: str,
     *,
@@ -627,7 +774,20 @@ def verify_badge_sd_jwt(
     Returns openvc-core's ``VerifiedSdJwt`` (``.claims``, ``.issuer``, ``.vct``,
     ``.key_bound``, ``.confirmation``). Raises :class:`EudiError` on any failure.
     Pass *audience*/*nonce* (and ``require_key_binding=True``) to check a Key
-    Binding JWT from a holder presentation.
+    Binding JWT from a holder presentation. *audience* also gates the issuer
+    JWT's own ``aud`` when it has one (openvc-core >=1.35.0, RFC 7519 §4.1.3): a
+    badge its issuer restricted to a relying party is refused by every other
+    verifier, and by this one when *audience* is unset or different.
+
+    The badge's validity window is enforced on both trust paths: a ``validUntil``
+    in the past (beyond the usual clock-skew leeway) or a ``validFrom`` in the
+    future raises :class:`EudiError`, as does a value that is not an ISO 8601
+    timestamp with an offset (as ``datetime.fromisoformat`` reads it, which is
+    stricter before Python 3.11), alongside the issuer JWT's ``exp``/``nbf`` that
+    the delegate checks. A holder can still hide a ``validUntil`` that a *third-party*
+    issuer made selectively disclosable and the holder withheld; that cannot be
+    detected, so badges from issuers that do so must be treated accordingly
+    (this library never issues one: see :func:`issue_badge_sd_jwt`).
 
     Revocation (IETF Token Status List) is checked when you supply
     *resolve_status_list_token* — the callable
@@ -704,6 +864,7 @@ def verify_badge_sd_jwt(
         raise
     except Exception as exc:
         raise EudiError("SD-JWT VC badge verification failed: %s" % exc) from exc
+    _check_validity_window(verified.claims)
     # The suite verifies the signature and the disclosures but has no status
     # stage (the delegate does status one layer up, in verify_credential — which
     # is the x5c path). Check it here so both paths honour the same seam.
@@ -722,7 +883,9 @@ def _issuer_jwt_has_x5c(token: str) -> bool:
     header_b64 = token.split("~", 1)[0].split(".", 1)[0]
     try:
         header = json.loads(base64url_decode(header_b64))
-    except (ValueError, TypeError) as exc:
+    except (ValueError, TypeError, RecursionError) as exc:
+        # RecursionError: a hostile header nested deep enough to blow the JSON
+        # decoder's stack; it is not a ValueError and must not escape raw.
         raise EudiError(
             "could not parse the SD-JWT issuer JWT header: %s" % exc) from exc
     return bool(isinstance(header, dict) and header.get("x5c"))
@@ -751,6 +914,15 @@ def _verify_sd_jwt_x5c(token: str, x5c_trust_anchors: Any, *,
         from openvc import VerificationPolicy, verify_credential
     except ImportError as exc:
         raise EudiError(_INSTALL_HINT) from exc
+    # This is the SD-JWT VC verifier. openvc-core's verify_credential also takes
+    # a plain VC-JWT (no "~") and then ignores expected_vct and
+    # require_key_binding and hands back a different result type, so a JWT an
+    # anchored issuer signed would pass here as a badge; the pinned-key path
+    # refuses it for lacking the separator, and so must this one.
+    if not isinstance(token, str) or "~" not in token:
+        raise EudiError(
+            "not an SD-JWT VC (no ~ separator): verify_badge_sd_jwt does not "
+            "accept a plain JWT on the X.509 trust path either")
     # X.509 trust MUST anchor to the chain in the issuer JWT's x5c header.
     # openvc-core silently falls back to DID / issuer-URL key resolution when the
     # token carries no x5c, which would bypass x5c_trust_anchors entirely (a
@@ -774,4 +946,8 @@ def _verify_sd_jwt_x5c(token: str, x5c_trust_anchors: Any, *,
         raise EudiError(
             "SD-JWT VC badge verification against the X.509 trust anchors "
             "failed: %s" % exc) from exc
-    return result.raw
+    verified = result.raw
+    if not isinstance(getattr(verified, "claims", None), Mapping):
+        raise EudiError("the delegate returned something other than an SD-JWT VC")
+    _check_validity_window(verified.claims)
+    return verified

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/openbadgeslib/ob3/ldp.py

@@ -88,7 +88,11 @@ MAX_LDP_DOCUMENT_BYTES = 256 * 1024
 #: let nested arrays, re-spelled policy terms or a derived proof that merges
 #: blank nodes through (GHSA-vrxg-57v4-85mc, GHSA-h9rq-wxcw-4rjc; see
 #: ob3/_context_validation.py), so the JSON they report could differ from
-#: what the issuer signed.
+#: what the issuer signed. This is the security minimum of the delegated
+#: verify path, deliberately below the ``>=1.35.0`` the extras declare (that
+#: floor adds the SD-JWT VC issuer-JWT ``aud`` check, which this path does not
+#: use): it refuses a hand-installed release that is unsafe here, not one that
+#: is merely older than the tested pin.
 _OPENVC_MIN_VERSION = (1, 33, 2)
 
 

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/openbadgeslib/util.py

@@ -21,7 +21,7 @@
         License along with this library.
 """
 
-__version__ = '4.6.1'
+__version__ = '4.6.2'
 
 import contextlib
 import hashlib

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/openbadgeslib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 4.6.1
+Version: 4.6.2
 Summary: Production-ready Python library & CLI for Open Badges 3.0 (W3C Verifiable Credentials): issue, verify, and revoke JWT-VC credentials with Bitstring Status Lists and did:web — plus strict OB 2.0 and legacy OB 1.0.
 Author-email: Luis González Fernández <luisgf@luisgf.es>, Jesús Cea Avión <jcea@jcea.es>
 License: LGPLv3
@@ -35,14 +35,14 @@ Requires-Dist: PyJWT[crypto]>=2.15.1
 Requires-Dist: cryptography>=45
 Requires-Dist: defusedxml>=0.7
 Provides-Extra: ldp
-Requires-Dist: pyld>=3.3.0; extra == "ldp"
+Requires-Dist: pyld<4,>=3.3.0; extra == "ldp"
 Provides-Extra: eudi
-Requires-Dist: openvc-core<2,>=1.33.2; extra == "eudi"
+Requires-Dist: openvc-core<2,>=1.35.0; extra == "eudi"
 Provides-Extra: ldp-sd
-Requires-Dist: openvc-core[data-integrity]<2,>=1.33.2; extra == "ldp-sd"
-Requires-Dist: pyld>=3.3.0; extra == "ldp-sd"
+Requires-Dist: openvc-core[data-integrity]<2,>=1.35.0; extra == "ldp-sd"
+Requires-Dist: pyld<4,>=3.3.0; extra == "ldp-sd"
 Provides-Extra: oid4vci
-Requires-Dist: openvc-core<2,>=1.33.2; extra == "oid4vci"
+Requires-Dist: openvc-core<2,>=1.35.0; extra == "oid4vci"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-cov>=5.0; extra == "dev"

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/openbadgeslib.egg-info/requires.txt

@@ -17,14 +17,14 @@ jsonschema[format-nongpl]>=4.20
 sh<3,>=2.2.4
 
 [eudi]
-openvc-core<2,>=1.33.2
+openvc-core<2,>=1.35.0
 
 [ldp]
-pyld>=3.3.0
+pyld<4,>=3.3.0
 
 [ldp-sd]
-openvc-core[data-integrity]<2,>=1.33.2
-pyld>=3.3.0
+openvc-core[data-integrity]<2,>=1.35.0
+pyld<4,>=3.3.0
 
 [oid4vci]
-openvc-core<2,>=1.33.2
+openvc-core<2,>=1.35.0

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/pyproject.toml

@@ -94,8 +94,14 @@ dependencies = [
 # refused. pyld before 3.3 also canonicalizes an integral float (3.0) as
 # "3.0E0" where 3.3 and jsonld.js give "3", so a proof made on one did not
 # verify on the other.
+# Ceiling below 4: pyld 4.0 is unreleased and breaking, and its toRDF drops
+# statements 3.x keeps (an IRI with two `#`, a literal with an invalid
+# @language). Context validation is written against 3.x's absolute-IRI test and
+# reads the JSON, not the dataset, so a statement pyld 4 drops would still read
+# as present in the credential while the proof never signed it
+# (GHSA-rp5q-966c-5592). Lift the ceiling only with that reworked and tested.
 ldp = [
-    "pyld>=3.3.0",
+    "pyld>=3.3.0,<4",
 ]
 # EUDI track: issue/verify badges as SD-JWT VC (the EU wallet / ARF format) via
 # the generic openvc-core library. openvc-core is stable (1.x) with a published
@@ -110,13 +116,17 @@ ldp = [
 # only one of them came back key_bound=True although it was never bound to
 # this verifier. 1.30.0 refuses that half-configured check, and it also
 # bounds untrusted JSON nesting so a deep document fails with a typed error,
-# not a bare RecursionError. Per the rule above, the pin itself sits at
-# 1.33.2, the release the suite is tested against, which also carries
-# every openvc fix in between (GHSA-h9rq-wxcw-4rjc among them). Every extra that pulls openvc-core
+# not a bare RecursionError. 1.35.0 starts enforcing the issuer JWT's own
+# `aud` (RFC 7519 §4.1.3): before it, a third-party SD-JWT VC whose issuer
+# restricted it to another relying party verified for everyone, and a status
+# list token verified as unexpired under a hostile leeway_s. Per the rule
+# above, the pin itself sits at 1.35.0, the release the suite is tested
+# against, which also carries every openvc fix in between
+# (GHSA-h9rq-wxcw-4rjc among them). Every extra that pulls openvc-core
 # shares this one floor; the CI `eudi` job checks that they agree and runs
 # the [eudi] and [ldp-sd] suites against it.
 eudi = [
-    "openvc-core>=1.33.2,<2",
+    "openvc-core>=1.35.0,<2",
 ]
 # ecdsa-sd-2023 (selective disclosure) VERIFY for the OB 3.0 Data Integrity
 # track: credentials secured with the ecdsa-sd-2023 cryptosuite are verified by
@@ -131,13 +141,14 @@ eudi = [
 # of what was signed, so a member re-keyed to its full IRI or moved under
 # @included escaped them; 1.33.2 closes GHSA-h9rq-wxcw-4rjc (nested arrays,
 # re-spelled policy terms, a derived proof merging blank nodes). The pin sits
-# at 1.33.2, the shared tested floor
+# at 1.35.0, the shared tested floor
 # described under [eudi]. OB3LdpVerifier also runs its own context validation
 # (with pyld) before it delegates, and openvc-core[data-integrity] admits
-# pyld 2.x, so this extra carries the same pyld floor as [ldp].
+# pyld 2.x (and, unbounded above, pyld 4), so this extra carries the same pyld
+# range as [ldp].
 ldp-sd = [
-    "openvc-core[data-integrity]>=1.33.2,<2",
-    "pyld>=3.3.0",
+    "openvc-core[data-integrity]>=1.35.0,<2",
+    "pyld>=3.3.0,<4",
 ]
 # OID4VCI issuance: hand a badge to a wallet over the pre-authorized code flow.
 # openbadgeslib owns the offers, the state (codes, tokens, nonces, grants) and
@@ -150,7 +161,7 @@ ldp-sd = [
 # require_key_attestation= on verify_credential_request_proofs, so an
 # issuer that advertises key_attestations_required can refuse a proof
 # without one before the signature and before the nonce is spent. Those are
-# the feature minimums; the pin is the shared 1.33.2 floor described under
+# the feature minimums; the pin is the shared 1.35.0 floor described under
 # [eudi], which also applies 1.30.0's bound on untrusted JSON nesting to the
 # Credential Requests and key proofs this extra hands to openvc.
 #
@@ -159,7 +170,7 @@ ldp-sd = [
 # so an install that does not ask for [oid4vci] is never broken by its absence.
 # See openbadgeslib/oid4vci/ and wiki/Issuing-to-Wallets-with-OID4VCI.md.
 oid4vci = [
-    "openvc-core>=1.33.2,<2",
+    "openvc-core>=1.35.0,<2",
 ]
 dev = [
     "pytest>=8.0",

{openbadgeslib-4.6.1 → openbadgeslib-4.6.2}/tests/test_ob3_did.py

@@ -495,3 +495,35 @@ class TestForIssuerDidKid:
         with pytest.raises(OB3VerificationError, match='different DID'):
             OB3Verifier.for_issuer_did(
                 did, download=_doc_download(doc)).verify(token)
+
+
+def test_a_did_document_nested_past_the_parser_is_a_typed_failure():
+    # 200 000 `[`: json.loads raises RecursionError, which is neither a
+    # ValueError nor caught as one, and used to escape the fetch raw.
+    from openbadgeslib.ob3.did import fetch_did_web_document
+    with pytest.raises(OB3VerificationError, match='malformed DID document'):
+        fetch_did_web_document('did:web:example.com',
+                               download=lambda url: b'[' * 200000)
+
+
+@pytest.mark.parametrize('depth', [65, 5000, 90000])
+def test_a_did_document_nested_past_the_bound_is_refused(depth):
+    # Balanced and valid JSON. Depends on the interpreter whether json.loads
+    # takes it (3.14 parses ~100 000 levels, older ones stop near the recursion
+    # limit); either way it must come out as a typed failure, never as the
+    # RecursionError that repr() or json.dumps raise later on what it parsed.
+    from openbadgeslib.ob3.did import fetch_did_web_document
+    body = b'{"a":' * depth + b'1' + b'}' * depth
+    with pytest.raises(OB3VerificationError, match='nested|malformed DID document'):
+        fetch_did_web_document('did:web:example.com', download=lambda url: body)
+
+
+def test_an_ordinary_did_document_is_far_below_the_depth_bound():
+    from openbadgeslib.ob3.did import (MAX_DID_DOCUMENT_DEPTH,
+                                       _nested_deeper_than)
+    doc = {'id': 'did:web:example.com',
+           'verificationMethod': [{'id': '#k', 'publicKeyJwk': {'kty': 'OKP'}}],
+           'service': [{'serviceEndpoint': {'uris': ['https://a', ['b']]}}]}
+    assert not _nested_deeper_than(doc, MAX_DID_DOCUMENT_DEPTH)
+    assert _nested_deeper_than(doc, 3)
+    assert not _nested_deeper_than([], 1) and not _nested_deeper_than('x', 0)