sdata 1.5.0__py3-none-any.whl

sdata/did/did_web.py

@@ -0,0 +1,222 @@
+# -*- coding: utf-8 -*-
+"""``did:web``: DID-Dokumente erzeugen und über HTTPS auflösen.
+
+Zwei Schlüsseldarstellungen werden unterstützt:
+
+* **JWK** (empfohlen für JWS/JWT): ``JsonWebKey2020`` + ``publicKeyJwk`` (jws-2020),
+* **Multibase**: ``Ed25519VerificationKey2020`` + ``publicKeyMultibase`` (ed25519-2020).
+
+``did:web:example.com`` wird zu ``https://example.com/.well-known/did.json``
+aufgelöst; mit Pfadanteilen (``did:web:example.com:user:alice``) entsprechend zu
+``https://example.com/user/alice/did.json``.
+
+CLI::
+
+    python -m sdata.did.did_web build --domain example.com \\
+        --pub issuer_pub.json --out did.json --format jwk
+    python -m sdata.did.did_web resolve --kid did:web:example.com#key-1
+
+Referenzen:
+    * `did:web Method <https://w3c-ccg.github.io/did-method-web/>`_
+"""
+from __future__ import annotations
+
+import json
+import logging
+import argparse
+from urllib.parse import quote
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple
+
+from ._http import http_get, HttpError
+from .base58btc import b58encode
+from .errors import EncodingError, ResolutionError
+from .utils_didkey import pub_jwk_from_did_key, b64url_decode
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["build_did_document", "did_web_to_url", "resolve_public_jwk_for_kid"]
+
+JWS2020_CONTEXT = "https://w3id.org/security/suites/jws-2020/v1"
+ED25519_2020_CONTEXT = "https://w3id.org/security/suites/ed25519-2020/v1"
+DID_CORE_CONTEXT = "https://www.w3.org/ns/did/v1"
+
+#: HTTP-Timeout (Sekunden) für die Auflösung.
+HTTP_TIMEOUT = 15
+
+
+def did_web(domain: str) -> str:
+    """``'example.com'`` → ``'did:web:example.com'``."""
+    return "did:web:{}".format(domain)
+
+
+def _load_pub_input(path: str) -> Tuple[str, Optional[Dict[str, Any]]]:
+    """Lade die ``--pub``-Eingabe.
+
+    Returns:
+        ``("jwk", jwk_dict)`` oder ``("multibase", {"mb": "z…"})``.
+
+    Akzeptiert ein JWK-JSON (``kty=OKP``/``crv=Ed25519``/``x``), ein
+    ``{"multibase": "z…"}``-JSON oder eine Textdatei mit einem ``z…``-String.
+
+    Raises:
+        EncodingError: wenn die Eingabe weder JWK noch gültige Multibase ist.
+    """
+    text = Path(path).read_text().strip()
+    try:
+        obj = json.loads(text)
+    except json.JSONDecodeError:
+        obj = None
+
+    if isinstance(obj, dict):
+        if obj.get("kty") == "OKP" and obj.get("crv") == "Ed25519" and "x" in obj:
+            return "jwk", obj
+        if "multibase" in obj and str(obj["multibase"]).startswith("z"):
+            return "multibase", {"mb": str(obj["multibase"])}
+
+    if text.startswith("z"):
+        return "multibase", {"mb": text}
+
+    raise EncodingError(
+        "--pub '{}' ist weder JWK-JSON noch eine gültige Multibase (z…)".format(path))
+
+
+def _did_context(add_security: str, variant: str):
+    """Stelle die ``@context``-Liste zusammen (``add_security``: 'auto'|'on'|'off')."""
+    ctx = [DID_CORE_CONTEXT]
+    if add_security == "off":
+        return ctx
+    security = JWS2020_CONTEXT if variant == "jwk" else ED25519_2020_CONTEXT
+    ctx.append(security)
+    return ctx
+
+
+def build_did_document(domain: str, public_input_path: str,
+                       key_id_suffix: str = "key-1", variant: str = "jwk",
+                       add_security_context: str = "auto") -> Dict[str, Any]:
+    """Erzeuge ein DID-Dokument (``did.json``) für ``did:web:<domain>``.
+
+    Args:
+        domain: Domain des Issuers.
+        public_input_path: Pfad zu Public-JWK-JSON **oder** Multibase-Datei.
+        key_id_suffix: Fragment der ``verificationMethod``-ID (Default ``key-1``).
+        variant: ``'jwk'`` (JsonWebKey2020) oder ``'multibase'`` (Ed25519VerificationKey2020).
+        add_security_context: ``'auto'`` | ``'on'`` | ``'off'``.
+
+    Raises:
+        EncodingError: bei ungültiger ``variant`` oder Eingabe.
+    """
+    if variant not in ("jwk", "multibase"):
+        raise EncodingError("variant muss 'jwk' oder 'multibase' sein")
+
+    kind, data = _load_pub_input(public_input_path)
+    did = did_web(domain)
+    vm_id = "{}#{}".format(did, key_id_suffix)
+    ctx = _did_context(add_security_context, variant)
+
+    if variant == "jwk":
+        jwk_pub = pub_jwk_from_did_key(data["mb"]) if kind == "multibase" else data
+        vm = {"id": vm_id, "type": "JsonWebKey2020", "controller": did,
+              "publicKeyJwk": jwk_pub}
+    else:
+        if kind == "jwk":
+            raw = b64url_decode(data["x"])
+            mb = "z" + b58encode(bytes([0xED, 0x01]) + raw)
+        else:
+            mb = data["mb"]
+        vm = {"id": vm_id, "type": "Ed25519VerificationKey2020", "controller": did,
+              "publicKeyMultibase": mb}
+
+    return {
+        "@context": ctx,
+        "id": did,
+        "verificationMethod": [vm],
+        "assertionMethod": [vm_id],
+        "authentication": [vm_id],
+    }
+
+
+def did_web_to_url(did: str) -> str:
+    """Bilde die HTTPS-URL des ``did.json`` für eine ``did:web``-DID.
+
+    Raises:
+        EncodingError: wenn ``did`` keine ``did:web``-DID ist.
+    """
+    if not did.startswith("did:web:"):
+        raise EncodingError("keine did:web-DID: {}".format(did))
+    segments = ":".join(did.split(":")[2:]).split(":")
+    host = segments[0]
+    path = "/".join(map(quote, segments[1:]))
+    if path:
+        return "https://{}/{}/did.json".format(host, path)
+    return "https://{}/.well-known/did.json".format(host)
+
+
+def resolve_public_jwk_for_kid(kid: str) -> Dict[str, str]:
+    """Lade das ``did.json`` und liefere immer einen Public-**JWK** zur ``kid``.
+
+    Unterstützt sowohl ``publicKeyJwk`` als auch ``publicKeyMultibase``
+    (Letzteres wird zu JWK konvertiert).
+
+    Raises:
+        ResolutionError: bei Netzwerkfehlern oder wenn die ``kid`` nicht gefunden
+            bzw. kein Schlüsselmaterial vorhanden ist.
+    """
+    did = kid.split("#")[0]
+    url = did_web_to_url(did)
+    try:
+        status, body = http_get(url, timeout=HTTP_TIMEOUT)
+    except HttpError as exc:
+        raise ResolutionError("did:web-Auflösung fehlgeschlagen ({}): {}".format(url, exc))
+    if not (200 <= status < 300):
+        raise ResolutionError(
+            "did:web-Auflösung fehlgeschlagen ({}): HTTP {}".format(url, status))
+    doc = json.loads(body)
+
+    by_id = {vm.get("id"): vm for vm in doc.get("verificationMethod", [])}
+    vm = by_id.get(kid)
+    if not vm:
+        raise ResolutionError("Schlüssel {} nicht im did.json gefunden".format(kid))
+
+    if "publicKeyJwk" in vm:
+        return vm["publicKeyJwk"]
+    mb = vm.get("publicKeyMultibase")
+    if isinstance(mb, str) and mb.startswith("z"):
+        return pub_jwk_from_did_key(mb)
+    raise ResolutionError("weder publicKeyJwk noch publicKeyMultibase gefunden")
+
+
+# --------------------------------------------------------------------------
+# CLI
+# --------------------------------------------------------------------------
+def main(argv=None) -> None:
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    ap = argparse.ArgumentParser(description="did:web-Dokumente erzeugen/auflösen")
+    sub = ap.add_subparsers(required=True)
+
+    p = sub.add_parser("build", help="did.json erzeugen")
+    p.add_argument("--domain", required=True)
+    p.add_argument("--pub", required=True, help="Public-JWK-JSON ODER Datei mit Multibase (z…)")
+    p.add_argument("--out", required=True)
+    p.add_argument("--key-id", default="key-1")
+    p.add_argument("--format", choices=["jwk", "multibase"], default="jwk")
+    p.add_argument("--context", choices=["auto", "on", "off"], default="auto")
+    p.set_defaults(cmd="build")
+
+    p = sub.add_parser("resolve", help="Public-JWK per kid auflösen")
+    p.add_argument("--kid", required=True)
+    p.set_defaults(cmd="resolve")
+
+    args = ap.parse_args(argv)
+    if args.cmd == "build":
+        doc = build_did_document(args.domain, args.pub, key_id_suffix=args.key_id,
+                                 variant=args.format, add_security_context=args.context)
+        with open(args.out, "w") as fh:
+            json.dump(doc, fh, indent=2)
+        logger.info("✔ did.json erzeugt: %s", args.out)
+    else:
+        logger.info("%s", json.dumps(resolve_public_jwk_for_kid(args.kid), indent=2))
+
+
+if __name__ == "__main__":
+    main()

sdata/did/diddoc.py

@@ -0,0 +1,75 @@
+# -*- coding: utf-8 -*-
+"""Lern-/Demo-Modul: Signieren einer DIDComm-Nachricht als Flattened JWS.
+
+.. warning::
+   Nur zu Demonstrationszwecken. Es nutzt :mod:`sdata.did.ed25519`, eine
+   **nicht** für den Produktiveinsatz geeignete (nicht constant-time)
+   Referenzimplementierung. Für echte Anwendungen :mod:`sdata.did.jose`
+   (python-ecdsa) bzw. ein libsodium-Backend verwenden.
+
+Ausführen::
+
+    python -m sdata.did.diddoc
+"""
+from __future__ import annotations
+
+import base64
+import json
+import logging
+
+from .ed25519 import sign, publickey
+
+logger = logging.getLogger(__name__)
+
+__all__ = ["base64url_encode", "base64url_decode", "build_didcomm_jws"]
+
+
+def base64url_encode(data: bytes) -> bytes:
+    return base64.urlsafe_b64encode(data).rstrip(b"=")
+
+
+def base64url_decode(data: bytes) -> bytes:
+    return base64.urlsafe_b64decode(data + b"=" * (4 - len(data) % 4))
+
+
+def build_didcomm_jws(message: dict, seed: bytes, kid: str = "did:example:alice#key-1") -> dict:
+    """Signiere eine DIDComm-Nachricht und gib die Flattened-JWS-Struktur zurück.
+
+    Args:
+        message: Die DIDComm-Nachricht (wird als JSON serialisiert).
+        seed: 32-Byte-Ed25519-Seed (privater Schlüssel; nur Demo!).
+        kid: Schlüssel-ID für den JWS-Header.
+    """
+    pk = publickey(seed)
+    header = {"typ": "JWM", "alg": "EdDSA", "kid": kid}
+    protected = base64url_encode(json.dumps(header, separators=(",", ":")).encode())
+    payload = base64url_encode(json.dumps(message, separators=(",", ":")).encode())
+    sig = sign(protected + b"." + payload, seed, pk)
+    return {
+        "payload": payload.decode("utf-8"),
+        "signatures": [{
+            "protected": protected.decode("utf-8"),
+            "signature": base64url_encode(sig).decode("utf-8"),
+            "header": {"kid": kid},
+        }],
+    }
+
+
+def _demo() -> dict:
+    import os
+    message = {
+        "id": "1234567890",
+        "type": "http://example.com/protocols/lets_do_lunch/1.0/proposal",
+        "from": "did:example:alice",
+        "to": ["did:example:bob"],
+        "created_time": 1516269022,
+        "expires_time": 1516385931,
+        "body": {"messagespecificattribute": "and its value"},
+    }
+    return build_didcomm_jws(message, seed=os.urandom(32))
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    logger.info("Signierte DIDComm-Nachricht (JWS):")
+    logger.info("%s", json.dumps(_demo(), indent=2))

sdata/did/ed25519.py

@@ -0,0 +1,225 @@
+# ed25519_typed.py
+"""
+Lern-/Test-Implementierung von Ed25519 (pure Python).
+
+================================ SICHERHEITSHINWEIS ================================
+NICHT FÜR DEN PRODUKTIVEINSATZ GEEIGNET.
+
+Dieser Code dient ausschließlich Lehr- und Testzwecken (z. B. zum Nachvollziehen
+des RFC-8032-Testvektors). Er ist:
+  - NICHT constant-time → anfällig für Timing-/Seitenkanalangriffe, die den
+    privaten Schlüssel preisgeben können,
+  - nicht gehärtet gegen Fault-Injection und andere Angriffe,
+  - nicht unabhängig auditiert.
+
+Für echte Signaturen/Verifikation eine geprüfte Bibliothek verwenden, z. B.
+PyNaCl (libsodium), `cryptography` oder python-ecdsa (wie im übrigen did-Modul).
+===================================================================================
+
+Verwendet:
+- Point: typing.NamedTuple (x, y)
+- KeyPair: @dataclass (sk, pk)
+"""
+
+from __future__ import annotations
+import hashlib
+from dataclasses import dataclass
+from typing import NamedTuple
+
+# --- Konstanten ---
+b = 256
+q = 2**255 - 19
+l = 2**252 + 27742317777372353535851937790883648493  # Gruppenordnung
+
+class Point(NamedTuple):
+    x: int
+    y: int
+
+@dataclass(frozen=True)
+class KeyPair:
+    sk: bytes  # 32-Byte-Seed
+    pk: bytes  # 32-Byte Public Key (compressed)
+
+# --- Basisfunktionen ---
+def H(m: bytes) -> bytes:
+    """SHA-512-Hash m -> 64 Bytes."""
+    return hashlib.sha512(m).digest()
+
+def inv(x: int) -> int:
+    """Multiplikatives Inverses in F_q (q prim)."""
+    return pow(x, q - 2, q)
+
+# Edwards-d und sqrt(-1)
+d = (-121665 * inv(121666)) % q
+I = pow(2, (q - 1) // 4, q)
+
+def xrecover(y: int) -> int:
+    """Rekonstruiere x aus y gemäß Edwards-Kurvengleichung; even x."""
+    xx = (y*y - 1) * inv(d*y*y + 1) % q
+    x = pow(xx, (q + 3)//8, q)
+    if (x*x - xx) % q != 0:
+        x = (x * I) % q
+    if x % 2 != 0:
+        x = q - x
+    return x
+
+By = (4 * inv(5)) % q
+Bx = xrecover(By)
+B = Point(Bx, By)
+O = Point(0, 1)  # neutrales Element
+
+def edwards(P: Point, Q: Point) -> Point:
+    """Edwards-Punktaddition."""
+    x1, y1 = P
+    x2, y2 = Q
+    den_x = inv(1 + (d * x1 * x2 * y1 * y2) % q)
+    x3 = (x1*y2 + x2*y1) * den_x % q
+    den_y = inv(1 - (d * x1 * x2 * y1 * y2) % q)
+    y3 = (y1*y2 + x1*x2) * den_y % q
+    return Point(x3, y3)
+
+def scalarmult(P: Point, e: int) -> Point:
+    """Double-and-Add, iterativ (nicht constant-time)."""
+    Q = O
+    N = P
+    k = e
+    while k > 0:
+        if k & 1:
+            Q = edwards(Q, N)
+        N = edwards(N, N)
+        k >>= 1
+    return Q
+
+# --- Kodierung ---
+def encodeint(y: int) -> bytes:
+    """Little-Endian-Encoding von 256 Bit."""
+    bits = [(y >> i) & 1 for i in range(b)]
+    return bytes(sum(bits[8*i + j] << j for j in range(8)) for i in range(b//8))
+
+def bit(h: bytes, i: int) -> int:
+    """Lese Bit i aus Bytes (LE pro Byte)."""
+    return (h[i//8] >> (i % 8)) & 1
+
+def encodepoint(P: Point) -> bytes:
+    """Komprimierte Punktdarstellung: y (255 Bit) || sign(x) (1 Bit)."""
+    x, y = P
+    bits = [(y >> i) & 1 for i in range(b-1)] + [x & 1]
+    return bytes(sum(bits[8*i + j] << j for j in range(8)) for i in range(b//8))
+
+def isoncurve(P: Point) -> bool:
+    """Prüfe Kurvengleichung -x^2 + y^2 = 1 + d x^2 y^2 (mod q)."""
+    x, y = P
+    return (-x*x + y*y - 1 - d*x*x*y*y) % q == 0
+
+def decodeint(s: bytes) -> int:
+    """Little-Endian-Integer aus 32 Bytes (256 Bit)."""
+    if len(s) != 32:
+        raise ValueError("Integer-Kodierung muss 32 Bytes haben")
+    return sum(2**i * bit(s, i) for i in range(b))
+
+def decodepoint(s: bytes) -> Point:
+    """Dekodiere komprimierten Punkt und prüfe Kurvenzugehörigkeit."""
+    if len(s) != 32:
+        raise ValueError("Punktkodierung muss 32 Bytes haben")
+    y = sum(2**i * bit(s, i) for i in range(b-1))
+    x = xrecover(y)
+    if (x & 1) != bit(s, b-1):
+        x = q - x
+    P = Point(x, y)
+    if not isoncurve(P):  # pragma: no cover - Off-Curve-Punkt schwer konstruierbar
+        raise ValueError("Punkt liegt nicht auf der Kurve")
+    return P
+
+# --- Ed25519 API ---
+def publickey(sk: bytes) -> bytes:
+    """
+    Ableitung des Public Keys aus 32-Byte-Seed.
+    Clamping: Bits 0..2 = 0, Bit 254 = 1, Bit 255 = 0.
+    """
+    if len(sk) != 32:
+        raise ValueError("sk muss 32 Bytes (Seed) sein")
+    h = H(sk)
+    a = 2**(b-2) + sum(2**i * bit(h, i) for i in range(3, b-2))
+    A = scalarmult(B, a)
+    return encodepoint(A)
+
+def Hint(m: bytes) -> int:
+    """SHA-512(m) als 512-Bit little-endian Integer."""
+    h = H(m)
+    return sum(2**i * bit(h, i) for i in range(2*b))
+
+def sign(m: bytes, sk: bytes, pk: bytes) -> bytes:
+    """
+    Signiere Nachricht m mit Seed sk und zugehörigem pk.
+    Ergebnis: 64 Byte = R(32) || S(32).
+    """
+    if len(sk) != 32 or len(pk) != 32:
+        raise ValueError("sk/pk müssen 32 Bytes sein")
+    h = H(sk)
+    a = 2**(b-2) + sum(2**i * bit(h, i) for i in range(3, b-2))
+    inter = bytes(h[b//8 : b//4])          # h[32:64]
+    r = Hint(inter + m) % l
+    R = scalarmult(B, r)
+    Rcomp = encodepoint(R)
+    hram = Hint(Rcomp + pk + m) % l
+    S = (r + hram * a) % l
+    return Rcomp + encodeint(S)
+
+def verify(sig: bytes, m: bytes, pk: bytes) -> bool:
+    """
+    Verifiziere Signatur (R||S) über Nachricht m mit Public Key pk.
+    Zusätzliche Checks: Längen, S < l.
+    """
+    if len(sig) != 64 or len(pk) != 32:
+        return False
+    try:
+        R = decodepoint(sig[:32])
+        A = decodepoint(pk)
+        S = decodeint(sig[32:])
+    except Exception:  # pragma: no cover - nur bei Off-Curve-/Decode-Fehlern
+        return False
+    if S >= l:
+        return False
+    hram = Hint(encodepoint(R) + pk + m) % l
+    # Prüfe B*S == R + A*hram
+    left = scalarmult(B, S)
+    right = edwards(R, scalarmult(A, hram))
+    return left == right
+
+def keypair_from_seed(seed32: bytes) -> KeyPair:
+    """Erzeuge KeyPair aus 32-Byte-Seed."""
+    pk = publickey(seed32)
+    return KeyPair(sk=seed32, pk=pk)
+
+# --- Demo & Testvektor ---
+if __name__ == "__main__":
+    import os
+    import logging
+
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    logger = logging.getLogger(__name__)
+
+    # Demo
+    kp = keypair_from_seed(os.urandom(32))
+    msg = b"Hallo, DIDComm!"
+    sig = sign(msg, kp.sk, kp.pk)
+    logger.info("Sig OK?: %s", verify(sig, msg, kp.pk))
+
+    # RFC 8032 Testvektor (leere Nachricht)
+    sk_tv = bytes.fromhex(
+        "9d61b19deffd5a60ba844af492ec2cc4"
+        "4449c5697b326919703bac031cae7f60"
+    )
+    pk_tv = bytes.fromhex(
+        "d75a980182b10ab7d54bfed3c964073a"
+        "0ee172f3daa62325af021a68f707511a"
+    )
+    sig_tv = bytes.fromhex(
+        "e5564300c360ac729086e2cc806e828a"
+        "84877f1eb8e5d974d873e06522490155"
+        "5fb8821590a33bacc61e39701cf9b46b"
+        "d25bf5f0595bbe24655141438e7a100b"
+    )
+    kp_tv = keypair_from_seed(sk_tv)
+    logger.info("RFC PK OK: %s", kp_tv.pk == pk_tv)
+    logger.info("RFC SIG OK: %s", verify(sig_tv, b"", kp_tv.pk))

sdata/did/eddsa.py

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+"""Ed25519-Schlüsselobjekte – drop-in-Teilmenge der ``python-ecdsa``-API.
+
+Dieses Modul stellt genau die ``SigningKey``/``VerifyingKey``-Operationen
+bereit, die ``jose`` und ``keys`` zuvor aus dem externen Paket ``ecdsa``
+bezogen haben – jetzt jedoch ohne externe Abhängigkeit, gestützt auf die
+RFC-8032-Primitive in :mod:`sdata.did.ed25519`.
+
+.. warning::
+   Die zugrunde liegende Ed25519-Implementierung ist **pure Python und nicht
+   constant-time** (siehe Sicherheitshinweis in :mod:`sdata.did.ed25519`).
+   Sie verhält sich darin wie ``python-ecdsa`` (ebenfalls pure Python, nicht
+   seitenkanalresistent). Für Umgebungen mit Seitenkanal-Anforderungen ein
+   libsodium-basiertes Backend (PyNaCl) oder ``cryptography`` verwenden.
+
+Korrektheit wird gegen die offiziellen RFC-8032-Testvektoren abgesichert
+(siehe ``tests/test_eddsa.py``).
+"""
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+from . import ed25519 as _ed
+
+__all__ = ["Ed25519", "SigningKey", "VerifyingKey", "BadSignatureError"]
+
+
+class BadSignatureError(Exception):
+    """Signatur konnte nicht verifiziert werden (API-kompatibel zu ``ecdsa``)."""
+
+
+class _Ed25519Curve:
+    """Sentinel für den Kurvenparameter ``curve=Ed25519`` (API-Kompatibilität)."""
+
+    name = "Ed25519"
+
+    def __repr__(self) -> str:  # pragma: no cover - rein kosmetisch
+        return "Ed25519"
+
+
+#: Kurven-Sentinel, analog zu ``ecdsa.Ed25519``.
+Ed25519 = _Ed25519Curve()
+
+
+def _check_len(raw: bytes, expected: int, what: str) -> bytes:
+    if not isinstance(raw, (bytes, bytearray)) or len(raw) != expected:
+        raise ValueError("{} muss {} Bytes sein".format(what, expected))
+    return bytes(raw)
+
+
+class VerifyingKey:
+    """Öffentlicher Ed25519-Schlüssel (32-Byte, komprimiert)."""
+
+    def __init__(self, pub: bytes):
+        self._pub = pub
+
+    @classmethod
+    def from_string(cls, raw: bytes, curve=Ed25519) -> "VerifyingKey":
+        """Erzeuge einen ``VerifyingKey`` aus 32 rohen Public-Key-Bytes."""
+        return cls(_check_len(raw, 32, "Public Key"))
+
+    def to_string(self) -> bytes:
+        """Liefere den rohen 32-Byte Public Key."""
+        return self._pub
+
+    def verify(self, signature: bytes, data: bytes) -> bool:
+        """Verifiziere ``signature`` über ``data``.
+
+        Returns:
+            ``True`` bei gültiger Signatur.
+        Raises:
+            BadSignatureError: wenn die Signatur ungültig ist.
+        """
+        if not _ed.verify(bytes(signature), bytes(data), self._pub):
+            raise BadSignatureError("Signatur ungültig")
+        return True
+
+
+class SigningKey:
+    """Privater Ed25519-Schlüssel (32-Byte-Seed)."""
+
+    def __init__(self, seed: bytes):
+        self._seed = seed
+        self._pub = _ed.publickey(seed)
+
+    @classmethod
+    def generate(cls, curve=Ed25519) -> "SigningKey":
+        """Erzeuge einen frischen Schlüssel aus 32 zufälligen Bytes (``os.urandom``)."""
+        return cls(os.urandom(32))
+
+    @classmethod
+    def from_string(cls, raw: bytes, curve=Ed25519) -> "SigningKey":
+        """Erzeuge einen ``SigningKey`` aus einem 32-Byte-Seed."""
+        return cls(_check_len(raw, 32, "Seed"))
+
+    def to_string(self) -> bytes:
+        """Liefere den rohen 32-Byte-Seed (geheim halten!)."""
+        return self._seed
+
+    def get_verifying_key(self) -> VerifyingKey:
+        """Leite den zugehörigen öffentlichen Schlüssel ab."""
+        return VerifyingKey(self._pub)
+
+    def sign(self, data: bytes) -> bytes:
+        """Signiere ``data`` und gib die 64-Byte-Signatur zurück."""
+        return _ed.sign(bytes(data), self._seed, self._pub)

sdata/did/errors.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""Ausnahmehierarchie für das :mod:`sdata.did`-Subpackage.
+
+Bibliotheksfunktionen werfen ausschließlich diese Ausnahmen (nie ``SystemExit``),
+damit Aufrufer sie gezielt behandeln können::
+
+    from sdata.did import verify_presentation, VerificationError
+    try:
+        verify_presentation(vp_jws)
+    except VerificationError as exc:
+        ...
+
+Hierarchie::
+
+    DidError                     # Basisklasse für alles in sdata.did
+    ├── EncodingError            # ungültiges Format (JWK, Multibase, JWS-Struktur)
+    ├── ResolutionError          # DID/Schlüssel konnte nicht aufgelöst werden
+    └── VerificationError        # Signatur, Hash oder Claims ungültig
+
+``EncodingError`` erbt zusätzlich von :class:`ValueError`, damit bestehender Code,
+der ``ValueError`` abfängt, weiterhin funktioniert.
+"""
+
+__all__ = ["DidError", "EncodingError", "ResolutionError", "VerificationError"]
+
+
+class DidError(Exception):
+    """Basisklasse aller Fehler des ``sdata.did``-Subpackages."""
+
+
+class EncodingError(DidError, ValueError):
+    """Ein Wert hat ein ungültiges/unerwartetes Format (JWK, Multibase, JWS …)."""
+
+
+class ResolutionError(DidError):
+    """Eine DID oder ein Schlüssel konnte nicht aufgelöst werden."""
+
+
+class VerificationError(DidError):
+    """Eine Signatur, ein Hash oder eine Claim-Prüfung ist fehlgeschlagen."""