openbadgeslib 3.4.2__tar.gz → 3.5.0__tar.gz

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/Changelog.txt

@@ -4,6 +4,32 @@ OpenBadgesLib - Changelog
 Newest first. Dates are ISO 8601 (YYYY-MM-DD).
 
 
+* v3.5.0 - 2026-07-07
+
+  - fix(status): serialise status-registry writes with an exclusive
+    inter-process lock. Concurrent `openbadges-signer` runs (or a signer
+    overlapping `openbadges-publish --revoke`) each did load→mutate→save with
+    no lock, so the second `save()` clobbered the first's new entry — and a
+    delivered credential missing from the registry can never be revoked. Both
+    mutation paths now run inside the new `StatusRegistry.locked(path)` context
+    manager, which holds a POSIX `fcntl` lock on a sibling `<registry>.lock`
+    file across the whole load→mutate→save (a dedicated lock file, because
+    `save()` renames the JSON and a lock on its inode would be orphaned). The
+    revoke path searches unlocked and reloads the winning registry under the
+    lock before mutating. Where `fcntl` is unavailable (non-POSIX) it degrades
+    to the previous unlocked behaviour, so single-operator use is unchanged.
+
+  - feat(eudi): the SD-JWT VC track now also signs with NIST **P-384**
+    (ES384) keys, not only Ed25519 and P-256. `issue_badge_sd_jwt` reads the
+    ECDSA curve from the key and picks openvc-core's matching backend
+    (`P256SigningKey`/`P384SigningKey`), stamping an `alg: ES384` issuer JWT
+    for a P-384 PEM; verification was already curve-agnostic. Other curves
+    (e.g. P-521) and RSA are still rejected with an actionable message. New
+    `openbadgeslib.keys.ec_curve_from_pem` helper. Note: HAIP profiles the
+    P-256 family, so P-384 badges may be refused by HAIP-strict EUDI wallets
+    — P-256 remains the recommended default.
+
+
 * v3.4.2 - 2026-07-07
 
   - build(eudi): the `[eudi]` extra now tracks `openvc-core>=1.8,<2` (was

{openbadgeslib-3.4.2/openbadgeslib.egg-info → openbadgeslib-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 3.4.2
+Version: 3.5.0
 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
@@ -111,7 +111,7 @@ additive EUDI SD-JWT VC wallet track.
 | Issue / verify | ✅ both | verify only | issue; partial verify | both | both (VC + VP) |
 | OB 3.0 proof: VC-JWT (JOSE) | ✅ RS/ES/EdDSA | — | — | roadmap | ✅ not OB-aware |
 | OB 3.0 proof: Data Integrity / LDP | ✅ issue + verify (`eddsa-rdfc-2022`) | — | issue only (Ed25519) | home-grown, non-conformant | older suites; no `rdfc-2022` in wheel |
-| OB 3.0 as EUDI SD-JWT VC (selective disclosure) | ✅ issue + verify (Ed25519/P-256, `[eudi]` extra) | — | — | — | — |
+| OB 3.0 as EUDI SD-JWT VC (selective disclosure) | ✅ issue + verify (Ed25519/P-256/P-384, `[eudi]` extra) | — | — | — | — |
 | Revocation / suspension | ✅ W3C Bitstring Status List | hosted check | `1EdTechRevocationList` | ad-hoc flag | — |
 | `did:web` (generate + resolve) | ✅ | — | — | — | resolve only |
 | Image baking (SVG + PNG) | ✅ | unbake only | ✅ | — | — |
@@ -306,7 +306,9 @@ crypto to the generic [`openvc-core`](https://pypi.org/project/openvc-core/)
 library. It does not touch the native VC-JWT / Data Integrity issuance above:
 it is a separate credential format for wallet flows, not a third image proof.
 Needs the `[eudi]` extra (`pip install "openbadgeslib[eudi]"`) and an Ed25519
-(EdDSA) or NIST P-256 (ES256) key — SD-JWT's algorithm set (RSA is rejected).
+(EdDSA), NIST P-256 (ES256) or P-384 (ES384) key — SD-JWT's algorithm set (RSA
+is rejected). HAIP profiles the P-256 family, so P-256 stays the safe default
+for EUDI wallets; P-384 may be refused by HAIP-strict verifiers.
 The achievement is always disclosed; the recipient identity is *selectively
 disclosable*, so a holder can prove the badge while withholding who they are.
 

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/README.md

@@ -60,7 +60,7 @@ additive EUDI SD-JWT VC wallet track.
 | Issue / verify | ✅ both | verify only | issue; partial verify | both | both (VC + VP) |
 | OB 3.0 proof: VC-JWT (JOSE) | ✅ RS/ES/EdDSA | — | — | roadmap | ✅ not OB-aware |
 | OB 3.0 proof: Data Integrity / LDP | ✅ issue + verify (`eddsa-rdfc-2022`) | — | issue only (Ed25519) | home-grown, non-conformant | older suites; no `rdfc-2022` in wheel |
-| OB 3.0 as EUDI SD-JWT VC (selective disclosure) | ✅ issue + verify (Ed25519/P-256, `[eudi]` extra) | — | — | — | — |
+| OB 3.0 as EUDI SD-JWT VC (selective disclosure) | ✅ issue + verify (Ed25519/P-256/P-384, `[eudi]` extra) | — | — | — | — |
 | Revocation / suspension | ✅ W3C Bitstring Status List | hosted check | `1EdTechRevocationList` | ad-hoc flag | — |
 | `did:web` (generate + resolve) | ✅ | — | — | — | resolve only |
 | Image baking (SVG + PNG) | ✅ | unbake only | ✅ | — | — |
@@ -255,7 +255,9 @@ crypto to the generic [`openvc-core`](https://pypi.org/project/openvc-core/)
 library. It does not touch the native VC-JWT / Data Integrity issuance above:
 it is a separate credential format for wallet flows, not a third image proof.
 Needs the `[eudi]` extra (`pip install "openbadgeslib[eudi]"`) and an Ed25519
-(EdDSA) or NIST P-256 (ES256) key — SD-JWT's algorithm set (RSA is rejected).
+(EdDSA), NIST P-256 (ES256) or P-384 (ES384) key — SD-JWT's algorithm set (RSA
+is rejected). HAIP profiles the P-256 family, so P-256 stays the safe default
+for EUDI wallets; P-384 may be refused by HAIP-strict verifiers.
 The achievement is always disclosed; the recipient identity is *selectively
 disclosable*, so a holder can prove the badge while withholding who they are.
 

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/openbadgeslib/keys.py

@@ -253,6 +253,32 @@ def public_jwk_from_pem(pubkey_pem: Union[str, bytes]) -> dict:
     return json.loads(jwk_json)
 
 
+def ec_curve_from_pem(pem_data: Union[str, bytes]) -> Optional[str]:
+    """Return the NIST curve name of an elliptic-curve key PEM, else ``None``.
+
+    The name is ``cryptography``'s (``'secp256r1'`` for P-256, ``'secp384r1'``
+    for P-384, …); ``None`` if the PEM is not an EC key (RSA, Ed25519 or
+    unreadable). Accepts a public or private PEM. The SD-JWT VC (EUDI) track
+    uses this to pick the ES256 vs ES384 signing backend — the ECDSA curve
+    fixes the JOSE algorithm.
+    """
+    from cryptography.hazmat.primitives.asymmetric import ec
+    data = _pem_bytes(pem_data)
+    for load in (
+        lambda: _crypto_serialization.load_pem_public_key(data),
+        lambda: _crypto_serialization.load_pem_private_key(data, password=None),
+    ):
+        try:
+            key = load()
+        except Exception:
+            continue
+        if isinstance(key, (ec.EllipticCurvePublicKey,
+                            ec.EllipticCurvePrivateKey)):
+            return key.curve.name
+        return None                                   # readable, but not EC
+    return None
+
+
 def _is_ed25519_pem(pem_data: Union[str, bytes]) -> bool:
     """True if pem_data is an Ed25519 public or private key.
 

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/openbadgeslib/ob3/eudi.py

@@ -31,14 +31,15 @@
 # withholding their identity.
 #
 # Requires the optional ``[eudi]`` extra (``pip install openbadgeslib[eudi]``),
-# which pulls ``openvc-core``. SD-JWT allows only Ed25519 (EdDSA) and NIST P-256
-# (ES256) keys — RSA is not in its algorithm set.
+# which pulls ``openvc-core``. SD-JWT allows only Ed25519 (EdDSA) and the NIST
+# curves P-256 (ES256) / P-384 (ES384) — RSA is not in its algorithm set.
 
 from typing import Any, Iterable, Optional
 
 from .credential import OpenBadgeCredential
 from ..errors import LibOpenBadgesException
-from ..keys import KeyType, detect_key_type, public_jwk_from_pem
+from ..keys import (
+    KeyType, detect_key_type, ec_curve_from_pem, public_jwk_from_pem)
 
 # 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"
@@ -58,24 +59,37 @@ class EudiError(LibOpenBadgesException):
 def _require_openvc() -> Any:
     """Import the openvc-core pieces, or raise with an actionable hint."""
     try:
-        from openvc.keys import Ed25519SigningKey, P256SigningKey
+        from openvc.keys import (
+            Ed25519SigningKey, P256SigningKey, P384SigningKey)
         from openvc.proof.sd_jwt import SdJwtVcProofSuite
     except ImportError as exc:
         raise EudiError(_INSTALL_HINT) from exc
-    return Ed25519SigningKey, P256SigningKey, SdJwtVcProofSuite
+    return Ed25519SigningKey, P256SigningKey, P384SigningKey, SdJwtVcProofSuite
 
 
 def _signing_key(privkey_pem: Any, kid: str) -> Any:
-    """Build the openvc SigningKey matching the PEM's key type (Ed25519 / P-256)."""
-    Ed25519SigningKey, P256SigningKey, _ = _require_openvc()
+    """Build the openvc SigningKey matching the PEM's key type / curve.
+
+    Ed25519 -> EdDSA; NIST P-256 -> ES256; NIST P-384 -> ES384. The ECDSA
+    curve is read from the key itself, since it fixes the JOSE algorithm.
+    """
+    Ed25519SigningKey, P256SigningKey, P384SigningKey, _ = _require_openvc()
     key_type = detect_key_type(privkey_pem)
     if key_type is KeyType.ED25519:
         return Ed25519SigningKey.from_pem(privkey_pem, kid=kid)
-    if key_type is KeyType.ECC:                       # NIST P-256 -> ES256
-        return P256SigningKey.from_pem(privkey_pem, kid=kid)
+    if key_type is KeyType.ECC:                       # NIST curve -> ES256/ES384
+        curve = ec_curve_from_pem(privkey_pem)
+        if curve == "secp256r1":                      # P-256 -> ES256
+            return P256SigningKey.from_pem(privkey_pem, kid=kid)
+        if curve == "secp384r1":                      # P-384 -> ES384
+            return P384SigningKey.from_pem(privkey_pem, kid=kid)
+        raise EudiError(
+            "SD-JWT VC over ECDSA needs a NIST P-256 (ES256) or P-384 (ES384) "
+            "key; got curve %r." % curve)
     raise EudiError(
-        "SD-JWT VC allows only Ed25519 (EdDSA) or NIST P-256 (ES256) keys; got "
-        "%s (RSA is not in the SD-JWT algorithm set)." % key_type.value)
+        "SD-JWT VC allows only Ed25519 (EdDSA) or NIST P-256/P-384 (ES256/"
+        "ES384) keys; got %s (RSA is not in the SD-JWT algorithm set)."
+        % key_type.value)
 
 
 def badge_to_sd_jwt_claims(credential: OpenBadgeCredential) -> dict:
@@ -117,9 +131,9 @@ def issue_badge_sd_jwt(
     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
-    Key-Binding presentation. Ed25519 / P-256 keys only.
+    Key-Binding presentation. Ed25519, P-256 or P-384 keys only.
     """
-    _, _, SdJwtVcProofSuite = _require_openvc()
+    _, _, _, SdJwtVcProofSuite = _require_openvc()
     signing_key = _signing_key(privkey_pem, kid or ("%s#key-1" % credential.issuer.id))
     claims = badge_to_sd_jwt_claims(credential)
     present = [name for name in disclosable if name in claims]
@@ -149,7 +163,7 @@ def verify_badge_sd_jwt(
     Pass *audience*/*nonce* (and ``require_key_binding=True``) to check a Key
     Binding JWT from a holder presentation.
     """
-    _, _, SdJwtVcProofSuite = _require_openvc()
+    _, _, _, SdJwtVcProofSuite = _require_openvc()
     try:
         public_key_jwk = public_jwk_from_pem(pubkey_pem)
         return SdJwtVcProofSuite().verify(

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/openbadgeslib/ob3/status_registry.py

@@ -32,14 +32,20 @@
 # leave a truncated registry behind, because a lost registry makes every
 # outstanding credential unrevocable.
 
+import contextlib
 import json
 import os
 import secrets
 import tempfile
 
+try:
+    import fcntl                    # POSIX advisory file locking
+except ImportError:                 # pragma: no cover - non-POSIX (e.g. Windows)
+    fcntl = None                    # type: ignore[assignment]
+
 from dataclasses import dataclass
 from datetime import datetime, timezone
-from typing import Dict, List, Optional, Set
+from typing import Dict, Iterator, List, Optional, Set
 
 from ..errors import (
     AlreadyRevoked,
@@ -59,6 +65,35 @@ _SCHEMA_VERSION = 1
 _MAX_RANDOM_TRIES = 1000
 
 
+@contextlib.contextmanager
+def _exclusive_file_lock(lock_path: str) -> Iterator[None]:
+    """Hold an exclusive inter-process lock for the duration of the block.
+
+    Backed by POSIX ``fcntl.flock`` on a dedicated lock file. Where ``fcntl``
+    is unavailable (non-POSIX platforms) it degrades to no locking — the same
+    behaviour as before this guard existed — so single-process use is
+    unaffected and nothing regresses; concurrent writers are simply not
+    serialised there.
+    """
+    directory = os.path.dirname(lock_path) or '.'
+    umask = os.umask(0o077)
+    try:
+        os.makedirs(directory, exist_ok=True)
+        fd = os.open(lock_path, os.O_CREAT | os.O_RDWR, 0o600)
+    finally:
+        os.umask(umask)
+    try:
+        if fcntl is not None:
+            fcntl.flock(fd, fcntl.LOCK_EX)        # blocks until the lock frees
+        yield
+    finally:
+        try:
+            if fcntl is not None:
+                fcntl.flock(fd, fcntl.LOCK_UN)
+        finally:
+            os.close(fd)
+
+
 @dataclass
 class StatusEvent:
     """A revocation or suspension, with when and (optionally) why."""
@@ -148,6 +183,26 @@ class StatusRegistry:
             raise RegistryCorrupt('%s: %s' % (path, exc)) from exc
         return registry
 
+    @classmethod
+    @contextlib.contextmanager
+    def locked(cls, path: str,
+               size_bits: int = DEFAULT_SIZE_BITS) -> Iterator['StatusRegistry']:
+        """Load the registry under an exclusive inter-process lock, yield it.
+
+        The lock (a sibling ``<path>.lock`` file) is held for the whole block,
+        so a ``load → allocate/revoke/… → save()`` sequence inside it is
+        atomic against other processes. This closes the race where two
+        concurrent writers both load, and the second :meth:`save` clobbers the
+        first's new entry — leaving a delivered credential unrevocable. Call
+        :meth:`save` inside the block; the lock releases on exit.
+
+        A dedicated lock file (not the registry JSON) is used on purpose:
+        :meth:`save` replaces the JSON via ``os.rename``, so a lock held on the
+        JSON inode would be orphaned by the first write.
+        """
+        with _exclusive_file_lock(path + '.lock'):
+            yield cls.load(path, size_bits)
+
     def save(self) -> None:
         """Write the registry atomically (temp file + rename) under a
         restrictive umask; the file names recipients and is issuer-private."""

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/openbadgeslib/openbadges_publish.py

@@ -200,19 +200,25 @@ def _publish_ob3(args: argparse.Namespace, parser: argparse.ArgumentParser) -> N
             sys.exit(-1)
 
         name, registry, entry = matches[0]
+        jti = entry.jti
         now = datetime.now(tz=timezone.utc)
+        # The search above is an unlocked best-effort locator; the mutation
+        # reloads the winning registry under an exclusive lock so it is atomic
+        # against a concurrent signer or revoke (see StatusRegistry.locked).
         try:
-            if op == 'revoke':
-                registry.revoke(entry.jti, now, args.reason)
-            elif op == 'suspend':
-                registry.suspend(entry.jti, now, args.reason)
-            else:
-                registry.unsuspend(entry.jti)
-            registry.save()
-        except StatusError as exc:
+            with StatusRegistry.locked(registry.path,
+                                       registry.size_bits) as registry:
+                if op == 'revoke':
+                    registry.revoke(jti, now, args.reason)
+                elif op == 'suspend':
+                    registry.suspend(jti, now, args.reason)
+                else:
+                    registry.unsuspend(jti)
+                registry.save()
+        except (StatusError, OSError) as exc:
             print('[!] %s' % exc)
             sys.exit(-1)
-        print('[+] %s %s %s (index %d)' % (verb, name, entry.jti, entry.index))
+        print('[+] %s %s %s (index %d)' % (verb, name, jti, entry.index))
 
     # ── regenerate every managed artefact from the registries ───────────────
     publish_url = conf['issuer']['publish_url']

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/openbadgeslib/openbadges_signer.py

@@ -348,15 +348,17 @@ def _sign_ob3(args: argparse.Namespace, conf: configparser.ConfigParser, badge:
 
         # The registry is persisted BEFORE the badge is signed and written:
         # a signing failure leaves a harmless orphan index, while a delivered
-        # badge missing from the registry could never be revoked.
+        # badge missing from the registry could never be revoked. The whole
+        # load→allocate→save runs under an exclusive lock so a concurrent
+        # signer cannot clobber this allocation (see StatusRegistry.locked).
         try:
-            registry = StatusRegistry.load(status_conf.registry_path,
-                                           status_conf.size_bits)
-            assert credential.id is not None \
-                and credential.issuance_date is not None
-            status_index = registry.allocate(credential.id, recipient_id,
-                                             credential.issuance_date)
-            registry.save()
+            with StatusRegistry.locked(status_conf.registry_path,
+                                       status_conf.size_bits) as registry:
+                assert credential.id is not None \
+                    and credential.issuance_date is not None
+                status_index = registry.allocate(credential.id, recipient_id,
+                                                 credential.issuance_date)
+                registry.save()
         except (StatusError, OSError) as exc:
             print('[!] Could not allocate a status list index: %s' % exc)
             sys.exit(-1)

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/openbadgeslib/util.py

@@ -21,7 +21,7 @@
         License along with this library.
 """
 
-__version__ = '3.4.2'
+__version__ = '3.5.0'
 
 import hashlib
 import ipaddress

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0/openbadgeslib.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 3.4.2
+Version: 3.5.0
 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
@@ -111,7 +111,7 @@ additive EUDI SD-JWT VC wallet track.
 | Issue / verify | ✅ both | verify only | issue; partial verify | both | both (VC + VP) |
 | OB 3.0 proof: VC-JWT (JOSE) | ✅ RS/ES/EdDSA | — | — | roadmap | ✅ not OB-aware |
 | OB 3.0 proof: Data Integrity / LDP | ✅ issue + verify (`eddsa-rdfc-2022`) | — | issue only (Ed25519) | home-grown, non-conformant | older suites; no `rdfc-2022` in wheel |
-| OB 3.0 as EUDI SD-JWT VC (selective disclosure) | ✅ issue + verify (Ed25519/P-256, `[eudi]` extra) | — | — | — | — |
+| OB 3.0 as EUDI SD-JWT VC (selective disclosure) | ✅ issue + verify (Ed25519/P-256/P-384, `[eudi]` extra) | — | — | — | — |
 | Revocation / suspension | ✅ W3C Bitstring Status List | hosted check | `1EdTechRevocationList` | ad-hoc flag | — |
 | `did:web` (generate + resolve) | ✅ | — | — | — | resolve only |
 | Image baking (SVG + PNG) | ✅ | unbake only | ✅ | — | — |
@@ -306,7 +306,9 @@ crypto to the generic [`openvc-core`](https://pypi.org/project/openvc-core/)
 library. It does not touch the native VC-JWT / Data Integrity issuance above:
 it is a separate credential format for wallet flows, not a third image proof.
 Needs the `[eudi]` extra (`pip install "openbadgeslib[eudi]"`) and an Ed25519
-(EdDSA) or NIST P-256 (ES256) key — SD-JWT's algorithm set (RSA is rejected).
+(EdDSA), NIST P-256 (ES256) or P-384 (ES384) key — SD-JWT's algorithm set (RSA
+is rejected). HAIP profiles the P-256 family, so P-256 stays the safe default
+for EUDI wallets; P-384 may be refused by HAIP-strict verifiers.
 The achievement is always disclosed; the recipient identity is *selectively
 disclosable*, so a holder can prove the badge while withholding who they are.
 

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/tests/conftest.py

@@ -39,6 +39,33 @@ def ecc_pub_pem():
     return (TESTS_DIR / 'test_verify_ecc.pem').read_bytes()
 
 
+@pytest.fixture(scope='session')
+def p384_keypair():
+    # Generated in-session (no committed P-384 key material on disk), like the
+    # Ed25519 keypair. NIST P-384 -> ES384 on the EUDI SD-JWT track.
+    from cryptography.hazmat.primitives import serialization
+    from cryptography.hazmat.primitives.asymmetric import ec
+    priv = ec.generate_private_key(ec.SECP384R1())
+    priv_pem = priv.private_bytes(
+        serialization.Encoding.PEM,
+        serialization.PrivateFormat.PKCS8,
+        serialization.NoEncryption())
+    pub_pem = priv.public_key().public_bytes(
+        serialization.Encoding.PEM,
+        serialization.PublicFormat.SubjectPublicKeyInfo)
+    return priv_pem, pub_pem
+
+
+@pytest.fixture(scope='session')
+def p384_priv_pem(p384_keypair):
+    return p384_keypair[0]
+
+
+@pytest.fixture(scope='session')
+def p384_pub_pem(p384_keypair):
+    return p384_keypair[1]
+
+
 @pytest.fixture(scope='session')
 def ed25519_keypair():
     # Generated in-session (not a committed key file) so the suite ships no

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/tests/test_ob3_eudi_sd_jwt.py

@@ -39,6 +39,19 @@ class TestSdJwtBadge:
         assert result.issuer == ob3_credential.issuer.id
         assert result.claims["achievement"]["name"] == ob3_credential.achievement.name
 
+    def test_roundtrip_es384(self, ob3_credential, p384_priv_pem, p384_pub_pem):
+        import base64
+        import json
+        token = issue_badge_sd_jwt(ob3_credential, privkey_pem=p384_priv_pem)
+        # A P-384 key must pin the ES384 algorithm in the issuer JWT header.
+        header_b64 = token.split(".", 1)[0]
+        header = json.loads(base64.urlsafe_b64decode(header_b64 + "=="))
+        assert header["alg"] == "ES384"
+        result = verify_badge_sd_jwt(token, pubkey_pem=p384_pub_pem)
+        assert result.issuer == ob3_credential.issuer.id
+        assert result.claims["achievement"]["name"] == ob3_credential.achievement.name
+        assert result.claims["credentialSubject"]["id"] == ob3_credential.recipient_id
+
     def test_claims_shape(self, ob3_credential):
         claims = badge_to_sd_jwt_claims(ob3_credential)
         assert claims["iss"] == ob3_credential.issuer.id
@@ -100,10 +113,22 @@ class TestSdJwtBadge:
                                 expected_vct="https://example.com/other-type")
 
     def test_rsa_key_rejected(self, ob3_credential, rsa_priv_pem):
-        # SD-JWT's algorithm set is {ES256, EdDSA}; RSA is not allowed.
+        # SD-JWT's algorithm set is {ES256, ES384, EdDSA}; RSA is not allowed.
         with pytest.raises(EudiError, match="Ed25519|P-256|RSA"):
             issue_badge_sd_jwt(ob3_credential, privkey_pem=rsa_priv_pem)
 
+    def test_unsupported_curve_rejected(self, ob3_credential):
+        # SD-JWT's ECDSA set is P-256/P-384; a P-521 key must be refused with a
+        # clear message rather than mis-signed under the wrong algorithm.
+        from cryptography.hazmat.primitives import serialization
+        from cryptography.hazmat.primitives.asymmetric import ec
+        p521 = ec.generate_private_key(ec.SECP521R1()).private_bytes(
+            serialization.Encoding.PEM,
+            serialization.PrivateFormat.PKCS8,
+            serialization.NoEncryption())
+        with pytest.raises(EudiError, match="P-256|P-384|curve"):
+            issue_badge_sd_jwt(ob3_credential, privkey_pem=p521)
+
 
 # ── behaviour without the [eudi] extra (runs with or without openvc) ─────────
 

{openbadgeslib-3.4.2 → openbadgeslib-3.5.0}/tests/test_ob3_status_registry.py

@@ -38,6 +38,55 @@ def _registry(tmp_path, size_bits=131072):
     return StatusRegistry.load(str(tmp_path / 'badge_1.json'), size_bits)
 
 
+# ── inter-process locking ────────────────────────────────────────────────────
+
+def _alloc_worker(path, size_bits, jti, recipient, when):
+    # Module-level so it is importable under the 'spawn' start method. Each
+    # call is a separate process doing the full locked load→allocate→save.
+    from openbadgeslib.ob3.status_registry import StatusRegistry
+    with StatusRegistry.locked(path, size_bits) as registry:
+        registry.allocate(jti, recipient, when)
+        registry.save()
+
+
+class TestLocked:
+    def test_yields_loaded_registry_and_creates_lock_file(self, tmp_path):
+        path = str(tmp_path / 'badge_1.json')
+        with StatusRegistry.locked(path, 131072) as registry:
+            assert registry.path == path
+            registry.allocate(JTI, 'mailto:a@example.org', NOW)
+            registry.save()
+        assert os.path.exists(path + '.lock')          # dedicated lock file
+        assert JTI in StatusRegistry.load(path, 131072).entries
+
+    def test_concurrent_allocations_are_never_lost(self, tmp_path):
+        # Without the lock, N processes each load→allocate→save would clobber
+        # one another and only the last save() would survive. With it, every
+        # allocation must be present.
+        pytest.importorskip('fcntl')                   # POSIX-only guarantee
+        import multiprocessing as mp
+        path = str(tmp_path / 'badge_1.json')
+        bits = 131072
+        n = 6
+        ctx = mp.get_context('spawn')                  # deterministic on macOS
+        procs = [
+            ctx.Process(target=_alloc_worker,
+                        args=(path, bits, 'urn:jti:%d' % i,
+                              'mailto:u%d@example.org' % i, NOW))
+            for i in range(n)
+        ]
+        for p in procs:
+            p.start()
+        for p in procs:
+            p.join(timeout=60)
+            assert p.exitcode == 0
+
+        registry = StatusRegistry.load(path, bits)
+        assert {e.jti for e in registry.entries.values()} == \
+            {'urn:jti:%d' % i for i in range(n)}
+        assert len({e.index for e in registry.entries.values()}) == n
+
+
 # ── allocation ───────────────────────────────────────────────────────────────
 
 class TestAllocate: