openbadgeslib 3.5.1__tar.gz → 3.7.0__tar.gz

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/Changelog.txt

@@ -4,6 +4,97 @@ OpenBadgesLib - Changelog
 Newest first. Dates are ISO 8601 (YYYY-MM-DD).
 
 
+* v3.7.0 - 2026-07-08
+
+  - security(deps): `keys.py` (and the OB1 key-loading path) are ported to
+    `cryptography`, and both `pycryptodome` and `python-ecdsa` are dropped as
+    dependencies. They only generated and parsed key material here — signing
+    always went through PyJWT+`cryptography` — all of which `cryptography`
+    (already a hard dependency via `PyJWT[crypto]`) covers. This removes
+    python-ecdsa's permanent pip-audit flag (CVE-2024-23342 "Minerva", wontfix
+    upstream), moves ECC key generation onto constant-time code, and shrinks
+    the install to a single crypto backend. PEM output is byte-compatible
+    (PKCS#1 `RSA PRIVATE KEY`, SEC1 `EC PRIVATE KEY`, SubjectPublicKeyInfo
+    public keys), so existing key files round-trip. `key_to_pem` still accepts
+    a live pycryptodome/python-ecdsa key object via a soft import, for a caller
+    predating the port. (#167)
+
+  - feat(cli): `--json` machine-readable output and a documented exit-code
+    contract for `openbadges-signer`, `openbadges-publish` and
+    `openbadges-keygenerator` (the verifier already had one), so issuance can
+    be automated without scraping human text. Each prints exactly one JSON
+    object to stdout — the signer `{ob_version, badge_file, jti, status_index,
+    proof_format}`, the keygenerator `{key_type, private_key, public_key}`,
+    publish `{did, files_written, status_operation, skipped}`, and
+    `--list`/`--status` the queried records — under a shared exit contract:
+    `0` success, `2` partial (some badges skipped), `1` any error (reported as
+    `{"error": "..."}`). Human output and its historical (inconsistent) exit
+    codes are untouched — unifying those is reserved for 4.0.0. `publish
+    --json` is OpenBadges 3.0 only. (#166)
+
+  - feat(ob3): JWT-VC verification now honours the token's `kid` header for a
+    multi-key did:web issuer. `OB3Verifier.for_issuer_did` fetches the DID
+    document once and selects the exact `verificationMethod` the kid names (an
+    absolute `did:web:…#badge_N` URL, or a bare `#badge_N` resolved against the
+    issuer DID), so issuers that rotate keys or publish one key per badge now
+    verify without pinning `-k`/`-l` — closing the gap where only the first
+    listed key worked. Fails closed when the kid names a method of a *different*
+    DID (the header is attacker-controlled) or one absent from the document; a
+    token with no kid still falls back to the first method. (#163)
+
+  - feat(ob1): OpenBadges 1.0 is now deprecated (removal scheduled for the
+    grouped 4.0.0 release, #170). Reaching the legacy import surface — the
+    `openbadgeslib.ob1` package, the top-level `openbadgeslib.badge` /
+    `openbadgeslib.signer` / `openbadgeslib.verifier` shims, and the
+    unprefixed `openbadgeslib.Signer` / `Verifier` / `Badge` / … re-exports —
+    now emits a `DeprecationWarning`, and the `-V 1` CLI paths (signer,
+    verifier, publish) print a `[!]` notice (suppressed under the verifier's
+    `--json`, so machine output stays clean). OB1 stays fully functional; a
+    bare `import openbadgeslib` and the OB2/OB3 APIs stay silent. OpenBadges
+    2.0 is **not** affected — it remains fully supported. The lifecycle policy
+    and the rejected alternatives (a `[legacy]` extra, a separate PyPI
+    package) are recorded on the "Python API OB1" wiki page. (#159)
+
+  - feat(publish): `openbadges-publish -V 3` gains two read-only registry
+    query commands, closing the credential lifecycle from the CLI
+    (issue → revoke → audit). `--list [-b badge]` tabulates every issued
+    credential — jti, recipient, issue date and state (active / REVOKED /
+    SUSPENDED); `--status <jti|email>` prints the full record of the matching
+    credential(s), including the revocation or suspension date and reason.
+    Both read only the private status registries, so neither needs an output
+    directory (`-o`). (#157)
+
+  - refactor(cli): `openbadges-keygenerator` no longer accepts the decorative
+    `-V/--ob-version` flag. Key material never depended on the OpenBadges
+    version (the algorithm comes from the badge's `key_type`), so the flag only
+    changed a log line. Internal tidy-ups alongside it: a dead `if args.badge`
+    guard in the signer (`-b` is required), the redundant `tests/runtests.sh`
+    wrapper, and an inaccurate conftest comment. (#156)
+
+
+* v3.6.0 - 2026-07-08
+
+  - feat(ob3): the verifier now exposes the raw, already-validated VC document
+    on the returned credential (`credential.raw`) — on both the JWT-VC and the
+    Data Integrity path — so an integrator can read spec fields the dataclass
+    does not map (alignment, results, multiple evidence, endorsements, …)
+    without re-parsing the token. It is None for an in-memory credential built
+    to issue, and excluded from equality/repr so it never affects comparisons.
+
+  - feat(ob3): issued OB 3.0 credentials now carry a `credentialSchema` entry
+    (`1EdTechJsonSchemaValidator2019`) pointing at 1EdTech's published
+    AchievementCredential JSON Schema, so validators and wallets can
+    self-check them. The offline conformance gate proves our issued
+    credentials satisfy that exact schema.
+
+  - refactor(typing): the library now type-checks clean under `mypy --strict`
+    (73 bare `dict` annotations parameterised as `dict[str, Any]`, 20 Any
+    returns narrowed with `typing.cast`), and `strict = true` is enabled in
+    the mypy config so CI enforces it. This makes the README's long-standing
+    `mypy --strict` claim true and improves the shipped `py.typed` annotations
+    for downstream type-checkers. Annotations only — no runtime change.
+
+
 * v3.5.1 - 2026-07-07
 
   - fix(ob3): a naive datetime passed as the issuance/expiration date is now

{openbadgeslib-3.5.1/openbadgeslib.egg-info → openbadgeslib-3.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openbadgeslib
-Version: 3.5.1
+Version: 3.7.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
@@ -29,8 +29,6 @@ Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGP
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: pycryptodome>=3.20
-Requires-Dist: ecdsa>=0.19
 Requires-Dist: pypng>=0.20220715.0
 Requires-Dist: PyJWT[crypto]>=2.8
 Requires-Dist: cryptography>=42
@@ -136,8 +134,6 @@ all three OB versions.
 ## Requirements
 
 - Python >= 3.10 (tested on 3.10–3.14)
-- [pycryptodome](https://pypi.org/project/pycryptodome/) >= 3.20
-- [ecdsa](https://pypi.org/project/ecdsa/) >= 0.19
 - [pypng](https://pypi.org/project/pypng/) >= 0.20220715.0
 - [PyJWT[crypto]](https://pypi.org/project/PyJWT/) >= 2.8
 - [cryptography](https://pypi.org/project/cryptography/) >= 42

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/README.md

@@ -85,8 +85,6 @@ all three OB versions.
 ## Requirements
 
 - Python >= 3.10 (tested on 3.10–3.14)
-- [pycryptodome](https://pypi.org/project/pycryptodome/) >= 3.20
-- [ecdsa](https://pypi.org/project/ecdsa/) >= 0.19
 - [pypng](https://pypi.org/project/pypng/) >= 0.20220715.0
 - [PyJWT[crypto]](https://pypi.org/project/PyJWT/) >= 2.8
 - [cryptography](https://pypi.org/project/cryptography/) >= 42

openbadgeslib-3.7.0/SECURITY.md

@@ -0,0 +1,54 @@
+# Security Policy
+
+`openbadgeslib` issues and verifies cryptographically-signed credentials, so we
+take reports seriously and aim to respond quickly.
+
+## Supported versions
+
+Security fixes land in a new release on the latest minor line and are published
+to [PyPI](https://pypi.org/project/openbadgeslib/). Always run the latest
+release; older versions are not patched in place.
+
+| Version        | Supported                     |
+| -------------- | ----------------------------- |
+| Latest release | ✅ security fixes              |
+| Older releases | ❌ upgrade to the latest       |
+
+## Reporting a vulnerability
+
+**Please do not open a public issue for a suspected vulnerability.** Report it
+privately instead:
+
+- **Preferred:** GitHub private vulnerability reporting — the **“Report a
+  vulnerability”** button under this repository’s
+  [Security tab](https://github.com/luisgf/openbadgeslib/security/advisories).
+- **Email:** `luisgf@luisgf.es` (you may encrypt to the same address’s public
+  key if you have it).
+
+Please include enough to reproduce: the affected version, a minimal example or
+proof of concept, and the impact you observed. If it touches signature
+verification, revocation, DID/key resolution, or the handling of untrusted
+input (downloaded documents, baked images, status lists), say so — those are the
+highest-priority areas.
+
+## What to expect
+
+- Acknowledgement of your report, normally within a few days.
+- An assessment of severity and scope, and a fix or mitigation plan.
+- Coordinated disclosure: we will agree a timeline with you and credit you in
+  the release notes and advisory unless you prefer to stay anonymous.
+- A patched release on PyPI and a published GitHub Security Advisory once the
+  fix is available.
+
+## Scope and threat model
+
+What the library defends against, and what it delegates to the operator (key
+custody, DNS/TLS for `did:web`, hosting of published documents), is documented
+in the [Security Model](https://github.com/luisgf/openbadgeslib/wiki/Security-Model)
+wiki page. Reports that fall within that model — a bypass of algorithm pinning,
+signature or recipient-binding verification, the SSRF/decompression guards, the
+context allowlist, or the status-list checks — are especially welcome.
+
+Out of scope: issues that require the operator’s own private keys or config to
+already be compromised, and hardening we already document as a deliberate,
+human-owned decision (for example, passphrase-encrypted private keys at rest).

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/openbadgeslib/__init__.py

@@ -21,17 +21,7 @@
         License along with this library.
 """
 
-# ── OpenBadges 1.0 (legacy) ─────────────────────────────────────────────────────
-# The classes formerly exposed as "OpenBadges 2.0" are the pre-2.0 wire format
-# (no @context/type, uid, verify{}, Unix timestamps). They are re-exported here
-# unchanged for backward compatibility; the strict OB 2.0 implementation lives
-# in openbadgeslib.ob2 (OB2Signer/OB2Verifier).
-from .ob1 import (  # noqa: F401
-    Signer, Verifier, VerifyInfo,
-    Badge, BadgeSigned, Assertion,
-    BadgeStatus, BadgeImgType, BadgeType,
-    extract_svg_assertion, extract_png_assertion,
-)
+from typing import Any
 
 # ── OpenBadges 2.0 (strict) ──────────────────────────────────────────────────
 from .ob2 import (  # noqa: F401
@@ -47,3 +37,34 @@ from .ob3 import (  # noqa: F401
 # ── Shared utilities ────────────────────────────────────────────────────────────
 from .keys import KeyFactory, KeyRSA, KeyECC  # noqa: F401
 from .util import __version__  # noqa: F401
+
+
+# ── OpenBadges 1.0 (legacy) ──────────────────────────────────────────────────
+# The unprefixed OB1 names (Signer, Verifier, Badge, …) stay importable from
+# the top-level package for backward compatibility, but they are the legacy
+# OpenBadges 1.0 surface: accessing one now emits a DeprecationWarning
+# (removal in 4.0.0). Modern code uses openbadgeslib.ob2 / openbadgeslib.ob3.
+# They are resolved lazily from the ob1 leaf modules (PEP 562), so a bare
+# `import openbadgeslib` neither warns nor drags in the ob1 package.
+_OB1_API = {
+    'Signer': 'signer', 'Verifier': 'verifier', 'VerifyInfo': 'verifier',
+    'Badge': 'badge', 'BadgeSigned': 'badge', 'Assertion': 'badge',
+    'BadgeStatus': 'badge', 'BadgeImgType': 'badge', 'BadgeType': 'badge',
+    'extract_svg_assertion': 'badge', 'extract_png_assertion': 'badge',
+}
+
+
+def __getattr__(name: str) -> Any:
+    module = _OB1_API.get(name)
+    if module is None:
+        raise AttributeError(
+            'module %r has no attribute %r' % (__name__, name))
+    import importlib
+    import warnings
+    warnings.warn(
+        'openbadgeslib.%s is the legacy OpenBadges 1.0 API and is deprecated; '
+        'it will be removed in openbadgeslib 4.0.0. Use openbadgeslib.ob2 '
+        '(strict OB 2.0) or openbadgeslib.ob3 (OB 3.0). See the "OpenBadges '
+        '1.0 lifecycle" wiki page.' % name,
+        DeprecationWarning, stacklevel=2)
+    return getattr(importlib.import_module('.ob1.' + module, __name__), name)

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/openbadgeslib/_jws/__init__.py

@@ -1,6 +1,6 @@
 """JWS sign/verify backed by PyJWT algorithm implementations (RS256/384/512, ES256/384/512)."""
 
-from typing import Any, Dict, Optional, Set, Union
+from typing import Any, Dict, Optional, Set, Union, cast
 
 from . import utils
 from .exceptions import SignatureError, MissingKey, MissingSigner, MissingVerifier, RouteMissingError
@@ -66,7 +66,7 @@ def sign(header_dict: Dict[str, Any], payload_dict: Dict[str, Any], key: Any) ->
     algo = _algo_for(alg_name)
     try:
         prepared = algo.prepare_key(key_to_pem(key))
-        return algo.sign(signing_input, prepared)
+        return cast(bytes, algo.sign(signing_input, prepared))
     except (InvalidKeyError, ValueError) as exc:
         raise SignatureError(str(exc)) from exc
 

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/openbadgeslib/badge.py

@@ -1,10 +1,19 @@
 """OpenBadges 1.0 (legacy) badge objects — compatibility shim, re-exports from openbadgeslib.ob1."""
+import warnings
+
 from .ob1.badge import (
     BadgeStatus, BadgeImgType, BadgeType,
     Assertion, Badge, BadgeSigned,
     extract_svg_assertion, extract_png_assertion,
 )
 
+warnings.warn(
+    'openbadgeslib.badge is a legacy OpenBadges 1.0 compatibility shim and is '
+    'deprecated; it will be removed in openbadgeslib 4.0.0. Import from '
+    'openbadgeslib.ob2 (strict OB 2.0) or openbadgeslib.ob3 (OB 3.0) instead. '
+    'See the "OpenBadges 1.0 lifecycle" wiki page.',
+    DeprecationWarning, stacklevel=2)
+
 __all__ = [
     'BadgeStatus', 'BadgeImgType', 'BadgeType',
     'Assertion', 'Badge', 'BadgeSigned',

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/openbadgeslib/baking.py

@@ -29,7 +29,7 @@
 from struct import pack
 from zlib import crc32
 
-from typing import List, Optional, Tuple, Union
+from typing import List, Optional, Tuple, Union, cast
 
 from defusedxml.minidom import parseString
 from png import Reader, signature as _png_signature
@@ -98,7 +98,7 @@ def bake_svg(image_bytes: bytes, token: str, comment: Optional[str] = None, *,
         svg_tag.appendChild(node)
         if comment:
             svg_tag.appendChild(svg_doc.createComment(comment))
-        return svg_doc.toxml().encode('utf-8')
+        return cast(bytes, svg_doc.toxml().encode('utf-8'))
     finally:
         svg_doc.unlink()
 
@@ -133,7 +133,7 @@ def extract_svg(image_bytes: bytes, *, element: str = SVG_ELEMENT,
             return None
         attrs = nodes[0].attributes
         if 'verify' in attrs:
-            return attrs['verify'].nodeValue
+            return cast(Optional[str], attrs['verify'].nodeValue)
         if not text_fallback:
             return None
         text = ''.join(
@@ -158,7 +158,7 @@ def _serialize_png(chunks: List[Tuple[Union[str, bytes], bytes]]) -> bytes:
         checksum = crc32(tag)
         checksum = crc32(data, checksum) & 0xFFFFFFFF
         out += pack("!I", checksum)
-    return out
+    return cast(bytes, out)
 
 
 def bake_png(image_bytes: bytes, token: str, text_comment: Optional[str] = None, *,

{openbadgeslib-3.5.1 → openbadgeslib-3.7.0}/openbadgeslib/keys.py

@@ -21,11 +21,17 @@
         License along with this library.
 """
 
-from typing import Any, Optional, Tuple, Union
+# Key material generation and parsing. All backed by ``cryptography`` (already
+# a hard dependency through PyJWT[crypto]); pycryptodome and python-ecdsa were
+# dropped in the 3.7 port (#167) — they only ever generated/parsed keys here,
+# never signed, and python-ecdsa carried a permanent pip-audit CVE flag
+# (CVE-2024-23342, Minerva). ``key_to_pem`` still accepts a live pycryptodome /
+# python-ecdsa key object via a soft import, for a caller predating the port.
+
+from typing import Any, Optional, Tuple, Union, cast
 from .errors import PublicKeyReadError, UnknownKeyType
-from ecdsa import SigningKey, VerifyingKey, NIST256p
-from Crypto.PublicKey import RSA
 from cryptography.hazmat.primitives import serialization as _crypto_serialization
+from cryptography.hazmat.primitives.asymmetric import ec, rsa
 from cryptography.hazmat.primitives.asymmetric.ed25519 import (
     Ed25519PrivateKey, Ed25519PublicKey)
 from enum import Enum
@@ -52,6 +58,27 @@ def KeyFactory(key_type: 'KeyType' = KeyType.RSA) -> 'Union[KeyRSA, KeyECC, KeyE
         raise UnknownKeyType()
 
 
+def _pem_bytes(key_pem: Union[str, bytes]) -> bytes:
+    return key_pem.encode('utf-8') if isinstance(key_pem, str) else key_pem
+
+
+def _private_pem(key: Any) -> bytes:
+    """Serialise an RSA/EC private key to a TraditionalOpenSSL PEM — PKCS#1
+    ``RSA PRIVATE KEY`` / SEC1 ``EC PRIVATE KEY``, exactly what pycryptodome and
+    python-ecdsa emitted, so existing key files round-trip unchanged."""
+    return cast(bytes, key.private_bytes(
+        _crypto_serialization.Encoding.PEM,
+        _crypto_serialization.PrivateFormat.TraditionalOpenSSL,
+        _crypto_serialization.NoEncryption()))
+
+
+def _public_pem(key: Any) -> bytes:
+    """Serialise a public key to a SubjectPublicKeyInfo ``PUBLIC KEY`` PEM."""
+    return cast(bytes, key.public_bytes(
+        _crypto_serialization.Encoding.PEM,
+        _crypto_serialization.PublicFormat.SubjectPublicKeyInfo))
+
+
 class KeyBase():
     def __init__(self) -> None:
         self.priv_key: Any = None         # crypto Object
@@ -73,67 +100,56 @@ class KeyRSA(KeyBase):
 
     def generate_keypair(self) -> Tuple[bytes, bytes]:
         """ Generate a RSA Key, returning in PEM Format """
-
-        # RSA Key Generation
-        self.priv_key = RSA.generate(self._key_size)
-        priv_key_pem = self.priv_key.export_key('PEM')
-        self.pub_key = self.priv_key.publickey()
-        pub_key_pem = self.pub_key.export_key('PEM')
-
-        return priv_key_pem, pub_key_pem
+        self.priv_key = rsa.generate_private_key(
+            public_exponent=65537, key_size=self._key_size)
+        self.pub_key = self.priv_key.public_key()
+        return self.get_priv_key_pem(), self.get_pub_key_pem()
 
     def read_private_key(self, key_pem: Any = None) -> None:
         """ Read the private key from param in PEM format """
-        self.priv_key = RSA.import_key(key_pem)
+        self.priv_key = _crypto_serialization.load_pem_private_key(
+            _pem_bytes(key_pem), password=None)
 
     def read_public_key(self, key_pem: Any = None) -> None:
         """ Read the public key from param in PEM format """
-        self.pub_key = RSA.import_key(key_pem)
+        self.pub_key = _crypto_serialization.load_pem_public_key(
+            _pem_bytes(key_pem))
 
     def get_priv_key_pem(self) -> bytes:
-        return self.priv_key.export_key('PEM')
+        return _private_pem(self.priv_key)
 
     def get_pub_key_pem(self) -> bytes:
-        return self.pub_key.export_key('PEM')
+        return _public_pem(self.pub_key)
 
 
 class KeyECC(KeyBase):
-    """ Elliptic Curve Cryptography Factory class """
+    """ Elliptic Curve Cryptography Factory class (NIST P-256 / ES256) """
 
-    def __init__(self, key_curve: Any = NIST256p) -> None:
-        self._key_curve = key_curve
+    def __init__(self, key_curve: Any = None) -> None:
+        self._key_curve = key_curve or ec.SECP256R1()
         super().__init__()
 
     def generate_keypair(self) -> Tuple[bytes, bytes]:
-        """ Generate a ECDSA keypair """
-
-        # Private key generation
-        self.priv_key = SigningKey.generate(curve=self._key_curve)
-        priv_key_pem = self.priv_key.to_pem()
-
-        # Derive the public (verifying) key from the private key.
-        self.pub_key = self.priv_key.get_verifying_key()
-        pub_key_pem = self.pub_key.to_pem()
-
-        return priv_key_pem, pub_key_pem
+        """ Generate an ECDSA keypair """
+        self.priv_key = ec.generate_private_key(self._key_curve)
+        self.pub_key = self.priv_key.public_key()
+        return self.get_priv_key_pem(), self.get_pub_key_pem()
 
-    def read_private_key(self, key_pem: Optional[Union[str, bytes]] = None) -> None:
+    def read_private_key(self, key_pem: Any = None) -> None:
         """ Read the private key from param in PEM format """
-        self.priv_key = SigningKey.from_pem(key_pem)
+        self.priv_key = _crypto_serialization.load_pem_private_key(
+            _pem_bytes(key_pem), password=None)
 
-    def read_public_key(self, key_pem: Optional[Union[str, bytes]] = None) -> None:
+    def read_public_key(self, key_pem: Any = None) -> None:
         """ Read the public key from param in PEM format """
-        self.pub_key = VerifyingKey.from_pem(key_pem)
+        self.pub_key = _crypto_serialization.load_pem_public_key(
+            _pem_bytes(key_pem))
 
     def get_priv_key_pem(self) -> bytes:
-        return self.priv_key.to_pem()
+        return _private_pem(self.priv_key)
 
     def get_pub_key_pem(self) -> bytes:
-        return self.pub_key.to_pem()
-
-
-def _pem_bytes(key_pem: Union[str, bytes]) -> bytes:
-    return key_pem.encode('utf-8') if isinstance(key_pem, str) else key_pem
+        return _public_pem(self.pub_key)
 
 
 def _load_ed25519_private_key(key_pem: Optional[Union[str, bytes]]) -> Ed25519PrivateKey:
@@ -158,8 +174,8 @@ class KeyEd25519(KeyBase):
     """Edwards-curve Ed25519 (EdDSA) key class, backed by ``cryptography``.
 
     Kept separate from KeyECC: Ed25519 is an EdDSA curve, not an ECDSA NIST
-    curve. It maps to the JWS ``EdDSA`` algorithm, and the ``ecdsa`` library
-    used for the NIST curves would misread its PEM (see detect_key_type).
+    curve. It maps to the JWS ``EdDSA`` algorithm, and its PEM is PKCS#8
+    (Ed25519 has no TraditionalOpenSSL encoding).
     """
 
     def generate_keypair(self) -> Tuple[bytes, bytes]:
@@ -177,15 +193,13 @@ class KeyEd25519(KeyBase):
         self.pub_key = _load_ed25519_public_key(key_pem)
 
     def get_priv_key_pem(self) -> bytes:
-        return self.priv_key.private_bytes(
+        return cast(bytes, self.priv_key.private_bytes(
             _crypto_serialization.Encoding.PEM,
             _crypto_serialization.PrivateFormat.PKCS8,
-            _crypto_serialization.NoEncryption())
+            _crypto_serialization.NoEncryption()))
 
     def get_pub_key_pem(self) -> bytes:
-        return self.pub_key.public_bytes(
-            _crypto_serialization.Encoding.PEM,
-            _crypto_serialization.PublicFormat.SubjectPublicKeyInfo)
+        return _public_pem(self.pub_key)
 
 
 def alg_for_key_type(key_type: 'KeyType') -> str:
@@ -199,32 +213,58 @@ def alg_for_key_type(key_type: 'KeyType') -> str:
     raise UnknownKeyType('No signing algorithm for key type: %r' % (key_type,))
 
 
+def _legacy_key_to_pem(key: Any) -> Optional[Union[str, bytes]]:
+    """Best-effort PEM for a live pycryptodome RSA or python-ecdsa key object.
+
+    Kept for backward compatibility with a caller still holding one from before
+    the cryptography port (#167). Both libraries were dropped as dependencies,
+    so this soft-imports them and returns ``None`` when they are absent (or the
+    object is neither) — the caller then raises UnknownKeyType.
+    """
+    try:
+        from Crypto.PublicKey import RSA as _RSA
+        if isinstance(key, _RSA.RsaKey):
+            return cast(bytes, key.export_key('PEM'))
+    except ImportError:
+        pass
+    try:
+        from ecdsa import SigningKey as _SigningKey, VerifyingKey as _VerifyingKey
+        if isinstance(key, (_SigningKey, _VerifyingKey)):
+            return cast(Union[str, bytes], key.to_pem())
+    except ImportError:
+        pass
+    return None
+
+
 def key_to_pem(key: Any) -> Union[str, bytes]:
-    """Convert a pycryptodome RSA or ecdsa key object to PEM bytes.
+    """Convert a key object to PEM bytes.
 
-    Bytes/str are passed through unchanged. Centralised here so the OB2 JWS
-    layer and both OB3 signer/verifier share one implementation instead of
-    three hand-maintained copies.
+    Handles ``cryptography`` key objects (what keys.py and ob1.badge now
+    produce) and passes bytes/str through unchanged; a live pycryptodome /
+    python-ecdsa object is still accepted via :func:`_legacy_key_to_pem`.
+    Centralised here so the OB1/OB2 JWS layer and both OB3 signer/verifier
+    share one implementation instead of hand-maintained copies.
     """
-    if isinstance(key, RSA.RsaKey):
-        return key.export_key('PEM')
-    if isinstance(key, (SigningKey, VerifyingKey)):
-        return key.to_pem()
+    if isinstance(key, (bytes, str)):
+        return key
+    if isinstance(key, (rsa.RSAPrivateKey, ec.EllipticCurvePrivateKey)):
+        return _private_pem(key)
+    if isinstance(key, (rsa.RSAPublicKey, ec.EllipticCurvePublicKey)):
+        return _public_pem(key)
     if isinstance(key, Ed25519PrivateKey):
         return key.private_bytes(
             _crypto_serialization.Encoding.PEM,
             _crypto_serialization.PrivateFormat.PKCS8,
             _crypto_serialization.NoEncryption())
     if isinstance(key, Ed25519PublicKey):
-        return key.public_bytes(
-            _crypto_serialization.Encoding.PEM,
-            _crypto_serialization.PublicFormat.SubjectPublicKeyInfo)
-    if isinstance(key, (bytes, str)):
-        return key
+        return _public_pem(key)
+    legacy = _legacy_key_to_pem(key)
+    if legacy is not None:
+        return legacy
     raise UnknownKeyType('Unsupported key object type: %r' % type(key))
 
 
-def public_jwk_from_pem(pubkey_pem: Union[str, bytes]) -> dict:
+def public_jwk_from_pem(pubkey_pem: Union[str, bytes]) -> dict[str, Any]:
     """Serialise a public key PEM as a public JWK dict.
 
     Counterpart of the OB3 signer's private-key-based JWK derivation, for
@@ -232,7 +272,6 @@ def public_jwk_from_pem(pubkey_pem: Union[str, bytes]) -> dict:
     verification keys in a did:web DID document.
     """
     import json
-    from cryptography.hazmat.primitives.asymmetric import ec, rsa
     from jwt.algorithms import ECAlgorithm, OKPAlgorithm, RSAAlgorithm
     try:
         pub = _crypto_serialization.load_pem_public_key(_pem_bytes(pubkey_pem))
@@ -250,7 +289,7 @@ def public_jwk_from_pem(pubkey_pem: Union[str, bytes]) -> dict:
     except Exception as exc:
         raise PublicKeyReadError(
             'could not read public key PEM: %s' % exc) from exc
-    return json.loads(jwk_json)
+    return cast(dict[str, Any], json.loads(jwk_json))
 
 
 def ec_curve_from_pem(pem_data: Union[str, bytes]) -> Optional[str]:
@@ -262,7 +301,6 @@ def ec_curve_from_pem(pem_data: Union[str, bytes]) -> Optional[str]:
     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),
@@ -279,53 +317,30 @@ def ec_curve_from_pem(pem_data: Union[str, bytes]) -> Optional[str]:
     return None
 
 
-def _is_ed25519_pem(pem_data: Union[str, bytes]) -> bool:
-    """True if pem_data is an Ed25519 public or private key.
+def detect_key_type(pem_data: Union[str, bytes]) -> 'KeyType':
+    """Positive key-type detection via ``cryptography``'s PEM loaders.
 
-    Probed before the RSA/ECC checks in detect_key_type: the ``ecdsa`` library's
-    VerifyingKey/SigningKey.from_pem *accept* an Ed25519 PEM and would otherwise
-    misclassify it as KeyType.ECC, pinning the wrong (ES*) algorithm family.
-    ``cryptography``'s loaders are unambiguous about the key type.
+    Accepts a public or private PEM and distinguishes Ed25519/RSA/EC by the
+    loaded key's concrete type — cryptography's loaders are unambiguous, unlike
+    the old python-ecdsa loader which accepted an Ed25519 PEM as an EC key and
+    forced the wrong (ES*) algorithm family.
     """
     data = _pem_bytes(pem_data)
-    try:
-        if isinstance(_crypto_serialization.load_pem_public_key(data), Ed25519PublicKey):
-            return True
-    except Exception:
-        pass
-    try:
-        if isinstance(_crypto_serialization.load_pem_private_key(data, password=None),
-                      Ed25519PrivateKey):
-            return True
-    except Exception:
-        pass
-    return False
-
-
-def detect_key_type(pem_data: Union[str, bytes]) -> 'KeyType':
-    """ Positive Key type detection """
+    key: Any = None
+    for load in (
+        lambda: _crypto_serialization.load_pem_public_key(data),
+        lambda: _crypto_serialization.load_pem_private_key(data, password=None),
+    ):
+        try:
+            key = load()
+            break
+        except Exception:
+            continue
 
-    # Ed25519 first: see _is_ed25519_pem — the ecdsa library would otherwise
-    # claim an Ed25519 PEM as ECC below.
-    if _is_ed25519_pem(pem_data):
+    if isinstance(key, (Ed25519PrivateKey, Ed25519PublicKey)):
         return KeyType.ED25519
-
-    try:
-        RSA.import_key(pem_data)
+    if isinstance(key, (rsa.RSAPrivateKey, rsa.RSAPublicKey)):
         return KeyType.RSA
-    except Exception:
-        pass
-
-    try:
-        VerifyingKey.from_pem(pem_data)
-        return KeyType.ECC
-    except Exception:
-        pass
-
-    try:
-        SigningKey.from_pem(pem_data)
+    if isinstance(key, (ec.EllipticCurvePrivateKey, ec.EllipticCurvePublicKey)):
         return KeyType.ECC
-    except Exception:
-        pass
-
     raise UnknownKeyType('Unable to guess Key type')