eif-sdk 0.1.0__py3-none-any.whl

eif/__init__.py

@@ -0,0 +1,82 @@
+"""EIF — Evidence Integrity Framework reference SDK.
+
+EIF is an open file format that binds a photograph to cryptographic proof of
+how it was captured. The proof is structural: it lives inside the container
+alongside the pixels, covers a per-tile Merkle tree of the image, and cannot
+be separated from the image without invalidating it.
+
+Quick start::
+
+    from eif import KeyPair, CaptureAttestation, Device, EIFFile, imaging
+
+    keypair = KeyPair.generate()
+    attestation = CaptureAttestation(
+        device=Device(make="Acme", model="Field-1", app_id="com.example.claims"),
+        challenge="server-issued-nonce",
+    )
+    png = imaging.encode_png("damage.jpg")
+    eif = EIFFile.capture(png, attestation, keypair)
+    eif.save("damage.eif")
+
+    report = EIFFile.load("damage.eif").verify(
+        expected_public_key=keypair.public_key
+    )
+    print(report["valid"])
+
+Specification: https://github.com/eif-format/specification
+"""
+
+from .cab import CaptureAttestation, Device, Location
+from .constants import (
+    DEFAULT_TILE_SIZE,
+    FORMAT_VERSION_MAJOR,
+    FORMAT_VERSION_MINOR,
+    PERMITTED_TILE_SIZES,
+    SIGNATURE_ALGORITHM,
+    VERIFICATION_LEVELS,
+)
+from .errors import (
+    EIFCanonicalisationError,
+    EIFCryptoError,
+    EIFError,
+    EIFFormatError,
+    EIFImageError,
+    EIFProvenanceError,
+)
+from .file import EIFFile, Seal, StructuralIntegrityLayer
+from .keys import KeyPair, PublicKey
+from .merkle import InclusionProof, MerkleTree
+from .provenance import ProvenanceChain, ProvenanceEntry
+from .verify import summarise, verify
+
+__version__ = "0.1.0"
+__spec_version__ = f"{FORMAT_VERSION_MAJOR}.{FORMAT_VERSION_MINOR}"
+
+__all__ = [
+    "DEFAULT_TILE_SIZE",
+    "PERMITTED_TILE_SIZES",
+    "SIGNATURE_ALGORITHM",
+    "VERIFICATION_LEVELS",
+    "CaptureAttestation",
+    "Device",
+    "EIFCanonicalisationError",
+    "EIFCryptoError",
+    "EIFError",
+    "EIFFile",
+    "EIFFormatError",
+    "EIFImageError",
+    "EIFProvenanceError",
+    "InclusionProof",
+    "KeyPair",
+    "Location",
+    "MerkleTree",
+    "ProvenanceChain",
+    "ProvenanceEntry",
+    "PublicKey",
+    "Seal",
+    "StructuralIntegrityLayer",
+    "__spec_version__",
+    "__version__",
+    "summarise",
+    "verify",
+]

eif/cab.py

@@ -0,0 +1,178 @@
+"""The Capture Attestation Block.
+
+The CAB records the circumstances of capture: when, by what device, under
+what software, at what location if any, and — the part that matters most for
+fraud — against what server-issued challenge.
+
+The challenge is what separates EIF from a timestamp. A capture pipeline
+requests a nonce from the relying party's server immediately before capture
+and binds it into the CAB before signing. An image produced any other way
+cannot carry a fresh, unused, server-recognised nonce. That is the control
+that addresses the recapture attack, in which a fraudster displays a
+generated image on a screen and photographs it with a genuine camera: the
+photograph is real, the provenance metadata is honest, and the content is
+fabricated. Provenance alone cannot catch this. A challenge bound to a
+session the relying party opened can.
+
+Location is optional and, when present, carries its own source and accuracy.
+A verifier must not treat a location field as trustworthy merely because it
+is signed; the signature attests that the capture software asserted it, not
+that it is true.
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Any
+
+from .canonical import canonicalise
+from .errors import EIFFormatError
+
+
+def _utc_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+@dataclass
+class Device:
+    """Identity of the capturing hardware and software."""
+
+    make: str = ""
+    model: str = ""
+    os: str = ""
+    app_id: str = ""
+    app_version: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "app_id": self.app_id,
+            "app_version": self.app_version,
+            "make": self.make,
+            "model": self.model,
+            "os": self.os,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Device:
+        return cls(
+            make=data.get("make", ""),
+            model=data.get("model", ""),
+            os=data.get("os", ""),
+            app_id=data.get("app_id", ""),
+            app_version=data.get("app_version", ""),
+        )
+
+
+@dataclass
+class Location:
+    """A geographic assertion made by the capture software.
+
+    Latitude and longitude are strings holding decimal degrees. They are not
+    floating-point numbers because signed structures must canonicalise
+    identically on every implementation, and float formatting does not.
+    """
+
+    latitude: str
+    longitude: str
+    accuracy_m: int
+    source: str = "gps"  # gps | network | fused | manual
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "accuracy_m": self.accuracy_m,
+            "latitude": self.latitude,
+            "longitude": self.longitude,
+            "source": self.source,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Location:
+        return cls(
+            latitude=str(data["latitude"]),
+            longitude=str(data["longitude"]),
+            accuracy_m=int(data["accuracy_m"]),
+            source=data.get("source", "gps"),
+        )
+
+
+@dataclass
+class CaptureAttestation:
+    """The signed record of how an image came to exist."""
+
+    capture_time: str = field(default_factory=_utc_now)
+    device: Device = field(default_factory=Device)
+    location: Location | None = None
+    #: Server-issued challenge bound into this capture. Absent for offline
+    #: captures, which a relying party should treat as a lower assurance tier.
+    challenge: str | None = None
+    #: Identifier for the relying party's capture session, if any.
+    session_id: str | None = None
+    #: Free-form, non-normative annotations. Excluded from no signature —
+    #: everything in the CAB is signed — but carrying no defined meaning.
+    annotations: dict[str, Any] = field(default_factory=dict)
+
+    # Populated by the SDK at capture time; not set by callers.
+    image_width: int = 0
+    image_height: int = 0
+    image_format: str = ""
+    tile_size: int = 0
+    key_id: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "capture_time": self.capture_time,
+            "device": self.device.to_dict(),
+            "image": {
+                "format": self.image_format,
+                "height": self.image_height,
+                "tile_size": self.tile_size,
+                "width": self.image_width,
+            },
+            "key_id": self.key_id,
+            "spec_version": "1.0",
+        }
+        if self.location is not None:
+            data["location"] = self.location.to_dict()
+        if self.challenge is not None:
+            data["challenge"] = self.challenge
+        if self.session_id is not None:
+            data["session_id"] = self.session_id
+        if self.annotations:
+            data["annotations"] = self.annotations
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CaptureAttestation:
+        try:
+            image = data["image"]
+            return cls(
+                capture_time=data["capture_time"],
+                device=Device.from_dict(data.get("device", {})),
+                location=(
+                    Location.from_dict(data["location"]) if "location" in data else None
+                ),
+                challenge=data.get("challenge"),
+                session_id=data.get("session_id"),
+                annotations=data.get("annotations", {}),
+                image_width=int(image["width"]),
+                image_height=int(image["height"]),
+                image_format=str(image["format"]),
+                tile_size=int(image["tile_size"]),
+                key_id=str(data["key_id"]),
+            )
+        except (KeyError, TypeError, ValueError) as exc:
+            raise EIFFormatError(f"malformed Capture Attestation Block: {exc}") from exc
+
+    def encode(self) -> bytes:
+        return canonicalise(self.to_dict())
+
+    @classmethod
+    def decode(cls, payload: bytes) -> CaptureAttestation:
+        from .canonical import parse
+
+        return cls.from_dict(parse(payload))
+
+    def digest(self) -> bytes:
+        return hashlib.sha256(self.encode()).digest()

eif/canonical.py

@@ -0,0 +1,76 @@
+"""Canonical serialisation.
+
+Signatures are computed over bytes, not over objects. Two implementations
+that serialise the same Capture Attestation Block differently would produce
+different signatures over identical data, so the specification fixes exactly
+one byte representation.
+
+EIF v1.0 uses JSON Canonicalization Scheme (RFC 8785) semantics, restricted
+to the subset of JSON the format actually uses: objects, arrays, strings,
+integers, booleans and null. Floating-point values are prohibited in
+signed structures precisely because their shortest round-trip representation
+is the hardest part of RFC 8785 to implement consistently; where a decimal
+quantity is needed (latitude, for example) the specification stores it as a
+string.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from .errors import EIFCanonicalisationError
+
+
+def _check(value: Any, path: str = "$") -> None:
+    """Reject values that cannot be canonicalised deterministically."""
+    if value is None or isinstance(value, (str, bool)):
+        return
+    if isinstance(value, float):
+        raise EIFCanonicalisationError(
+            f"floating-point value at {path}; use a string-encoded decimal instead"
+        )
+    if isinstance(value, int):
+        # JSON numbers beyond 2^53 lose precision in many parsers.
+        if abs(value) > 2**53 - 1:
+            raise EIFCanonicalisationError(
+                f"integer at {path} exceeds the safe range; encode it as a string"
+            )
+        return
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if not isinstance(key, str):
+                raise EIFCanonicalisationError(f"non-string object key at {path}")
+            _check(item, f"{path}.{key}")
+        return
+    if isinstance(value, list):
+        for index, item in enumerate(value):
+            _check(item, f"{path}[{index}]")
+        return
+    raise EIFCanonicalisationError(
+        f"value of type {type(value).__name__} at {path} is not representable"
+    )
+
+
+def canonicalise(value: Any) -> bytes:
+    """Serialise ``value`` to the single byte string EIF signs over.
+
+    Object keys are sorted by Unicode code point, no insignificant whitespace
+    is emitted, and the result is UTF-8.
+    """
+    _check(value)
+    return json.dumps(
+        value,
+        sort_keys=True,
+        separators=(",", ":"),
+        ensure_ascii=False,
+        allow_nan=False,
+    ).encode("utf-8")
+
+
+def parse(data: bytes) -> Any:
+    """Parse canonical JSON bytes back into Python objects."""
+    try:
+        return json.loads(data.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise EIFCanonicalisationError(f"payload is not valid canonical JSON: {exc}") from exc

eif/cli.py

@@ -0,0 +1,255 @@
+"""Command line interface: ``eif``.
+
+    eif keygen        --out signing-key.pem
+    eif capture       damage.png --key signing-key.pem --out damage.eif
+    eif verify        damage.eif [--key public.pem] [--json]
+    eif inspect       damage.eif
+    eif append        damage.eif --action received --actor "adjuster:4471"
+    eif extract       damage.eif --out damage.png
+    eif tamper-test   damage.eif --out tampered.eif
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from . import __version__, imaging
+from .cab import CaptureAttestation, Device, Location
+from .constants import DEFAULT_TILE_SIZE, PERMITTED_TILE_SIZES
+from .errors import EIFError
+from .file import EIFFile
+from .keys import KeyPair, PublicKey
+from .verify import summarise
+
+
+def _cmd_keygen(args: argparse.Namespace) -> int:
+    keypair = KeyPair.generate()
+    keypair.save(args.out)
+    public_path = Path(args.out).with_suffix(".pub.pem")
+    keypair.public_key.save(public_path)
+    print(f"Private key : {args.out}")
+    print(f"Public key  : {public_path}")
+    print(f"Key ID      : {keypair.key_id}")
+    print()
+    print("Keep the private key out of version control. This is a software key,")
+    print("suitable for development. Production capture should sign in hardware.")
+    return 0
+
+
+def _cmd_capture(args: argparse.Namespace) -> int:
+    keypair = KeyPair.load(args.key)
+    source = Path(args.image)
+    data = source.read_bytes() if source.suffix.lower() == ".png" else imaging.encode_png(source)
+
+    location = None
+    if args.location:
+        try:
+            lat, lon = args.location.split(",")
+            location = Location(
+                latitude=lat.strip(), longitude=lon.strip(), accuracy_m=args.location_accuracy
+            )
+        except ValueError:
+            print("--location must be 'latitude,longitude'", file=sys.stderr)
+            return 2
+
+    attestation = CaptureAttestation(
+        device=Device(
+            make=args.make, model=args.model, os=args.os,
+            app_id=args.app_id, app_version=args.app_version,
+        ),
+        location=location,
+        challenge=args.challenge,
+        session_id=args.session,
+    )
+    eif = EIFFile.capture(data, attestation, keypair, tile_size=args.tile_size)
+    out = args.out or str(source.with_suffix(".eif"))
+    eif.save(out)
+    print(f"Sealed  : {out}")
+    print(f"Image   : {eif.cab.image_width}x{eif.cab.image_height}, "
+          f"{eif.sil.columns}x{eif.sil.rows} tiles of {eif.sil.tile_size}px")
+    print(f"Root    : {eif.sil.root.hex()}")
+    print(f"Key ID  : {eif.cab.key_id}")
+    if args.challenge is None:
+        print()
+        print("No challenge was bound into this capture. Offline captures cannot be")
+        print("distinguished from a photograph of a screen; treat as lower assurance.")
+    return 0
+
+
+def _cmd_verify(args: argparse.Namespace) -> int:
+    eif = EIFFile.load(args.file)
+    expected = PublicKey.load(args.key) if args.key else None
+    report = eif.verify(expected_public_key=expected)
+    if args.json:
+        print(json.dumps(report, indent=2, default=str))
+    else:
+        print(summarise(report))
+        if expected is None:
+            print()
+            print("No key was pinned with --key. This checks internal consistency only:")
+            print("it does not establish who signed the file.")
+    return 0 if report["valid"] else 1
+
+
+def _cmd_inspect(args: argparse.Namespace) -> int:
+    eif = EIFFile.load(args.file)
+    print(f"EIF file      : {args.file}")
+    print("Spec version  : 1.0")
+    print(f"Capture time  : {eif.cab.capture_time}")
+    device = eif.cab.device
+    print(f"Device        : {device.make} {device.model} ({device.os})".rstrip())
+    print(f"Application   : {device.app_id} {device.app_version}".rstrip())
+    if eif.cab.location:
+        loc = eif.cab.location
+        print(f"Location      : {loc.latitude}, {loc.longitude} "
+              f"(+/-{loc.accuracy_m}m, {loc.source})")
+    print(f"Challenge     : {eif.cab.challenge or '(none)'}")
+    print(f"Session       : {eif.cab.session_id or '(none)'}")
+    print(f"Image         : {eif.cab.image_width}x{eif.cab.image_height} "
+          f"{eif.cab.image_format}")
+    print(f"Tile grid     : {eif.sil.columns}x{eif.sil.rows} @ {eif.sil.tile_size}px "
+          f"({len(eif.sil.leaves)} tiles)")
+    print(f"Merkle root   : {eif.sil.root.hex()}")
+    print(f"Image SHA-256 : {eif.image_hash}")
+    print(f"Algorithm     : {eif.seal.algorithm}")
+    print(f"Key ID        : {eif.cab.key_id}")
+    print(f"Provenance    : {len(eif.provenance.entries)} entries")
+    for entry in eif.provenance.entries:
+        signed = "signed" if entry.signature else "unsigned"
+        print(f"  [{entry.seq}] {entry.timestamp}  {entry.action:<12} "
+              f"{entry.actor}  ({signed})")
+    return 0
+
+
+def _cmd_append(args: argparse.Namespace) -> int:
+    eif = EIFFile.load(args.file)
+    keypair = KeyPair.load(args.key) if args.key else None
+    detail = json.loads(args.detail) if args.detail else None
+    entry = eif.provenance.append(
+        action=args.action, actor=args.actor, detail=detail, keypair=keypair
+    )
+    eif.save(args.out or args.file)
+    print(f"Appended entry {entry.seq}: {entry.action} by {entry.actor}")
+    print(f"Entry hash : {entry.entry_hash}")
+    if keypair is None:
+        print("Entry is unsigned; the chain records it but does not attribute it.")
+    return 0
+
+
+def _cmd_extract(args: argparse.Namespace) -> int:
+    eif = EIFFile.load(args.file)
+    eif.export_image(args.out)
+    print(f"Wrote {args.out}")
+    return 0
+
+
+def _cmd_tamper_test(args: argparse.Namespace) -> int:
+    """Alter a region of the embedded image and show that EIF localises it."""
+    import io
+
+    from PIL import Image
+
+    eif = EIFFile.load(args.file)
+    with Image.open(io.BytesIO(eif.image_data)) as img:
+        edited = img.convert("RGBA")
+        x0 = min(args.x, edited.width - 1)
+        y0 = min(args.y, edited.height - 1)
+        x1 = min(x0 + args.width, edited.width)
+        y1 = min(y0 + args.height, edited.height)
+        for y in range(y0, y1):
+            for x in range(x0, x1):
+                edited.putpixel((x, y), (255, 0, 0, 255))
+        buffer = io.BytesIO()
+        edited.save(buffer, format="PNG", optimize=False)
+        eif.image_data = buffer.getvalue()
+
+    out = args.out or str(Path(args.file).with_suffix(".tampered.eif"))
+    eif.save(out)
+    print(f"Wrote tampered file: {out}")
+    print(f"Altered region: [{x0},{y0}] to [{x1},{y1}]")
+    print()
+    print(summarise(EIFFile.load(out).verify()))
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="eif", description="Evidence Integrity Framework reference tool"
+    )
+    parser.add_argument("--version", action="version", version=f"eif {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p = sub.add_parser("keygen", help="generate a P-256 signing key")
+    p.add_argument("--out", default="eif-signing-key.pem")
+    p.set_defaults(func=_cmd_keygen)
+
+    p = sub.add_parser("capture", help="seal an image into an EIF file")
+    p.add_argument("image")
+    p.add_argument("--key", required=True)
+    p.add_argument("--out")
+    p.add_argument("--tile-size", type=int, default=DEFAULT_TILE_SIZE,
+                   choices=PERMITTED_TILE_SIZES)
+    p.add_argument("--challenge", help="server-issued nonce to bind into the capture")
+    p.add_argument("--session", help="relying-party session identifier")
+    p.add_argument("--location", help="'latitude,longitude' in decimal degrees")
+    p.add_argument("--location-accuracy", type=int, default=0)
+    p.add_argument("--make", default="")
+    p.add_argument("--model", default="")
+    p.add_argument("--os", default="")
+    p.add_argument("--app-id", default="")
+    p.add_argument("--app-version", default="")
+    p.set_defaults(func=_cmd_capture)
+
+    p = sub.add_parser("verify", help="run the L1-L5 verification protocol")
+    p.add_argument("file")
+    p.add_argument("--key", help="pin the expected signing public key (PEM)")
+    p.add_argument("--json", action="store_true")
+    p.set_defaults(func=_cmd_verify)
+
+    p = sub.add_parser("inspect", help="print the contents of an EIF file")
+    p.add_argument("file")
+    p.set_defaults(func=_cmd_inspect)
+
+    p = sub.add_parser("append", help="append a provenance chain entry")
+    p.add_argument("file")
+    p.add_argument("--action", required=True)
+    p.add_argument("--actor", required=True)
+    p.add_argument("--detail", help="JSON object of additional detail")
+    p.add_argument("--key", help="sign the entry with this private key")
+    p.add_argument("--out")
+    p.set_defaults(func=_cmd_append)
+
+    p = sub.add_parser("extract", help="write the embedded image to a file")
+    p.add_argument("file")
+    p.add_argument("--out", required=True)
+    p.set_defaults(func=_cmd_extract)
+
+    p = sub.add_parser("tamper-test", help="alter a region and localise the change")
+    p.add_argument("file")
+    p.add_argument("--x", type=int, default=0)
+    p.add_argument("--y", type=int, default=0)
+    p.add_argument("--width", type=int, default=100)
+    p.add_argument("--height", type=int, default=100)
+    p.add_argument("--out")
+    p.set_defaults(func=_cmd_tamper_test)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return int(args.func(args))
+    except EIFError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+    except FileNotFoundError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

eif/constants.py

@@ -0,0 +1,92 @@
+"""Constants defined by the EIF Format Specification v1.0.
+
+Every value in this module is normative. Changing one produces files that
+are not EIF files. See the specification repository:
+https://github.com/eif-format/specification
+"""
+
+# --- Container ---------------------------------------------------------------
+
+#: File magic. Eight bytes, chosen on the same principle as the PNG signature:
+#: byte 0 has the high bit set so that transfer over a 7-bit channel is
+#: detected; b"\r\n" then b"\x1a" then b"\n" detect CRLF translation, DOS
+#: end-of-file truncation, and LF translation respectively.
+MAGIC = b"\x89EIF\r\n\x1a\n"
+
+FORMAT_VERSION_MAJOR = 1
+FORMAT_VERSION_MINOR = 0
+
+#: Fixed-size file header: MAGIC (8) + major (1) + minor (1) + reserved (2)
+#: + chunk_count (4).
+HEADER_SIZE = 16
+
+#: Chunk framing: type (4) + length (4) + payload (length) + crc32 (4).
+CHUNK_TYPE_SIZE = 4
+CHUNK_LENGTH_SIZE = 4
+CHUNK_CRC_SIZE = 4
+
+# Chunk type codes.
+CHUNK_CAB = b"CABK"  # Capture Attestation Block
+CHUNK_SIL = b"SILT"  # Structural Integrity Layer
+CHUNK_SEAL = b"SEAL"  # Cryptographic Seal
+CHUNK_PVCH = b"PVCH"  # Provenance Chain
+CHUNK_IMGD = b"IMGD"  # Image Data
+CHUNK_IEND = b"IEND"  # End of file
+
+#: Chunks that must be present in a conformant v1.0 file, in this order.
+REQUIRED_CHUNKS = (CHUNK_CAB, CHUNK_SIL, CHUNK_SEAL, CHUNK_PVCH, CHUNK_IMGD, CHUNK_IEND)
+
+#: Maximum size of any single chunk payload (256 MiB). Bounds memory use in
+#: verifiers processing untrusted input.
+MAX_CHUNK_PAYLOAD = 256 * 1024 * 1024
+
+# --- Structural Integrity Layer ----------------------------------------------
+
+#: Default tile edge in pixels. The specification permits 16, 32, 64 or 128.
+DEFAULT_TILE_SIZE = 64
+PERMITTED_TILE_SIZES = (16, 32, 64, 128)
+
+#: Domain separation tags for the Merkle tree, following the construction in
+#: RFC 6962 Section 2.1. Distinct prefixes for leaves and internal nodes
+#: prevent the second-preimage attack that affects naive Merkle trees.
+MERKLE_LEAF_PREFIX = b"\x00"
+MERKLE_NODE_PREFIX = b"\x01"
+
+# --- Cryptography ------------------------------------------------------------
+
+#: The only signature algorithm defined in v1.0: ECDSA over NIST P-256 with
+#: SHA-256, as specified in FIPS 186-4.
+SIGNATURE_ALGORITHM = "ES256"
+
+HASH_ALGORITHM = "SHA-256"
+
+#: Domain separation string prefixed to the seal signing input. Prevents a
+#: signature produced for one EIF purpose being replayed as another.
+SEAL_DOMAIN = b"EIF-SEAL-v1\x00"
+
+#: Domain separation string for provenance chain entry hashing.
+PROVENANCE_DOMAIN = b"EIF-PVCH-v1\x00"
+
+# --- Image data --------------------------------------------------------------
+
+#: v1.0 stores image data in a losslessly decodable form so that tile hashes
+#: recompute bit-identically on any conformant decoder. Lossy payload profiles
+#: are deferred to a later version; see specification Section 5.4.
+PERMITTED_IMAGE_FORMATS = ("PNG",)
+
+# --- Verification ------------------------------------------------------------
+
+VERIFICATION_LEVELS = (
+    "L1_format",
+    "L2_cryptographic",
+    "L3_temporal",
+    "L4_provenance",
+    "L5_device",
+)
+
+#: Levels that a verifier can complete with no network access.
+OFFLINE_LEVELS = ("L1_format", "L2_cryptographic", "L3_temporal", "L4_provenance")
+
+#: Default tolerance, in seconds, for L3 temporal checks. A capture timestamp
+#: further ahead of the verifier's clock than this is rejected.
+DEFAULT_CLOCK_SKEW_TOLERANCE = 300