"""Independent verifier for the public Blessbri .brp example; imports no Blessbri code."""

from __future__ import annotations

import base64
import hashlib
import json
import sys
import zipfile
from pathlib import Path, PurePosixPath

from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey

ROOT = "Blessbri-Rights-Package/"


def fail(message: str) -> None:
    raise SystemExit(f"INVALID: {message}")


def main() -> int:
    if len(sys.argv) != 2:
        raise SystemExit("Usage: python verify-blessbri-public-example.py FILE.brp")
    package = Path(sys.argv[1])
    try:
        with zipfile.ZipFile(package) as archive:
            infos = archive.infolist()
            names = [item.filename for item in infos]
            if len(names) != len(set(names)) or len(names) > 10_000:
                fail("duplicate or excessive ZIP members")
            for name in names:
                path = PurePosixPath(name)
                if (
                    not name.startswith(ROOT)
                    or path.is_absolute()
                    or ".." in path.parts
                    or "\\" in name
                ):
                    fail("unsafe ZIP member path")
            manifest_name = ROOT + "package-manifest.json"
            signature_name = ROOT + "signature/signature.json"
            manifest_bytes = archive.read(manifest_name)
            manifest = json.loads(manifest_bytes)
            signature = json.loads(archive.read(signature_name))
            if (
                manifest.get("packageFormat") != "blessbri-rights-package"
                or manifest.get("packageVersion") != "0.2"
            ):
                fail("unsupported package format")
            public_key = base64.b64decode(signature["publicKey"], validate=True)
            supplied_signature = base64.b64decode(signature["signature"], validate=True)
            key_id = hashlib.sha256(public_key).hexdigest()
            if signature.get("algorithm") != "Ed25519" or signature.get("keyId") != key_id:
                fail("signature metadata mismatch")
            if signature.get("signedObject") != "package-manifest.json":
                fail("unexpected signed object")
            if signature.get("signedObjectSha256") != hashlib.sha256(manifest_bytes).hexdigest():
                fail("manifest digest mismatch")
            Ed25519PublicKey.from_public_bytes(public_key).verify(
                supplied_signature, manifest_bytes
            )
            expected = {manifest_name, signature_name}
            for entry in manifest.get("files", []):
                relative = entry["path"]
                if PurePosixPath(relative).is_absolute() or ".." in PurePosixPath(relative).parts:
                    fail("unsafe signed path")
                name = ROOT + relative
                if name in expected:
                    fail("duplicate signed path")
                content = archive.read(name)
                if (
                    len(content) != entry["byteLength"]
                    or hashlib.sha256(content).hexdigest() != entry["sha256"]
                ):
                    fail(f"member mismatch: {relative}")
                expected.add(name)
            if set(names) != expected:
                fail("unsigned or unlisted ZIP member")
    except (KeyError, ValueError, zipfile.BadZipFile) as error:
        fail(str(error))
    print(
        json.dumps(
            {
                "state": "valid",
                "sha256": hashlib.sha256(package.read_bytes()).hexdigest(),
                "keyId": key_id,
            }
        )
    )
    print(
        "BOUNDARY: integrity valid under a public test key; identity and authority are not verified"
    )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())