mivia-verify 1.0.0__tar.gz

mivia_verify-1.0.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

mivia_verify-1.0.0/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: mivia-verify
+Version: 1.0.0
+Summary: Check a Mivia evidence pack without relying on Mivia.
+Author: Mivia Software Ltd
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/MiviaCo/mivia-verify
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pynacl>=1.5
+Requires-Dist: blake3>=0.4
+Dynamic: license-file
+
+# mivia-verify
+
+Check a [Mivia](https://mivia.co) evidence pack yourself, without relying on Mivia.
+
+Every recording registered with Mivia has a public Certificate of Registration. Its owner can download an **evidence pack**: a zip with the signed registration record, its Bitcoin timestamp and Mivia's signed, dated statement about the record. This tool checks every part of a pack and tells you, in plain language, what passed.
+
+**What a pack proves:** what was registered, by which Mivia account, and that the record existed no later than a given Bitcoin block. **What it does not prove:** who wrote the music or who owns it. That is for contracts, registries and courts.
+
+## Install
+
+Python 3.9 or later:
+
+```
+pip install git+https://github.com/MiviaCo/mivia-verify
+```
+
+To compare an audio file by its acoustic fingerprint, also install Chromaprint's `fpcalc` (`brew install chromaprint`, `apt install libchromaprint-tools`, or <https://acoustid.org/chromaprint>).
+
+## Use
+
+```
+mivia-verify mivia-evidence-<id>-<date>.zip
+mivia-verify mivia-evidence-<id>-<date>.zip --audio the-recording.wav
+```
+
+| Option | What it does |
+|---|---|
+| `--audio FILE` | Check whether FILE is the exact registered file, and whether it matches the registered recording by fingerprint |
+| `--offline` | No network at all: skips comparing keys with mivia.co and looking up the Bitcoin block |
+| `--bitcoin-node` | Look the block up with your own Bitcoin node (`bitcoin-cli`) instead of a public block explorer |
+| `--json` | Machine-readable output |
+
+The exit code is 0 when every check that could run passed, and 1 otherwise.
+
+## What it checks
+
+1. **The record is intact.** BLAKE3 of `1-registration/manifest.json` gives the record id, the same id as in the certificate address `mivia.co/c/<id>`.
+2. **Signed by Mivia.** The Ed25519 signature in `manifest.sig` is valid for the record.
+3. **The keys are Mivia's.** The keys in the pack match the copy pinned in this repository (`src/mivia_verify/keys.py`) and the copy published at <https://mivia.co/.well-known/mivia-keys.json>.
+4. **The Bitcoin timestamp.** The OpenTimestamps proof starts from the record's BLAKE3 hash and leads to the merkle root of a Bitcoin block, confirmed with a public block explorer or your own node. Nobody, including Mivia, can backdate it.
+5. **The watermark payload** (web registrations) points to this record and to Mivia's key. Reading the payload from audio needs Mivia's decoder or the public scan on mivia.co; this tool checks that the payload in the pack belongs to the record.
+6. **Mivia's dated statement** is signed by Mivia's statement key and lists every other file in the pack with its SHA-256, so nothing can be added, removed or changed. It is Mivia's account on the date shown (assurance level, warnings, creation history, lineage, scan dates); a later pack may say more.
+7. **The audio** (with `--audio`):
+   - **exact file:** for records registered from October 2026, the record contains the SHA-256 of the file that was uploaded; a creator who kept that file can prove it is the one;
+   - **fingerprint:** compared with the registered Chromaprint fingerprint. A similarity measure: it also matches re-encoded or edited copies.
+
+A check that could not run (offline, no proof yet, no fingerprint) is shown as `----`, not as a failure.
+
+You do not have to trust this tool either: [SPEC.md](SPEC.md) describes the pack precisely enough to write your own checker.
+
+## Licence
+
+Apache-2.0. This repository contains the pack format and the checks only; Mivia's watermarking engine is not part of it.

mivia_verify-1.0.0/README.md

@@ -0,0 +1,53 @@
+# mivia-verify
+
+Check a [Mivia](https://mivia.co) evidence pack yourself, without relying on Mivia.
+
+Every recording registered with Mivia has a public Certificate of Registration. Its owner can download an **evidence pack**: a zip with the signed registration record, its Bitcoin timestamp and Mivia's signed, dated statement about the record. This tool checks every part of a pack and tells you, in plain language, what passed.
+
+**What a pack proves:** what was registered, by which Mivia account, and that the record existed no later than a given Bitcoin block. **What it does not prove:** who wrote the music or who owns it. That is for contracts, registries and courts.
+
+## Install
+
+Python 3.9 or later:
+
+```
+pip install git+https://github.com/MiviaCo/mivia-verify
+```
+
+To compare an audio file by its acoustic fingerprint, also install Chromaprint's `fpcalc` (`brew install chromaprint`, `apt install libchromaprint-tools`, or <https://acoustid.org/chromaprint>).
+
+## Use
+
+```
+mivia-verify mivia-evidence-<id>-<date>.zip
+mivia-verify mivia-evidence-<id>-<date>.zip --audio the-recording.wav
+```
+
+| Option | What it does |
+|---|---|
+| `--audio FILE` | Check whether FILE is the exact registered file, and whether it matches the registered recording by fingerprint |
+| `--offline` | No network at all: skips comparing keys with mivia.co and looking up the Bitcoin block |
+| `--bitcoin-node` | Look the block up with your own Bitcoin node (`bitcoin-cli`) instead of a public block explorer |
+| `--json` | Machine-readable output |
+
+The exit code is 0 when every check that could run passed, and 1 otherwise.
+
+## What it checks
+
+1. **The record is intact.** BLAKE3 of `1-registration/manifest.json` gives the record id, the same id as in the certificate address `mivia.co/c/<id>`.
+2. **Signed by Mivia.** The Ed25519 signature in `manifest.sig` is valid for the record.
+3. **The keys are Mivia's.** The keys in the pack match the copy pinned in this repository (`src/mivia_verify/keys.py`) and the copy published at <https://mivia.co/.well-known/mivia-keys.json>.
+4. **The Bitcoin timestamp.** The OpenTimestamps proof starts from the record's BLAKE3 hash and leads to the merkle root of a Bitcoin block, confirmed with a public block explorer or your own node. Nobody, including Mivia, can backdate it.
+5. **The watermark payload** (web registrations) points to this record and to Mivia's key. Reading the payload from audio needs Mivia's decoder or the public scan on mivia.co; this tool checks that the payload in the pack belongs to the record.
+6. **Mivia's dated statement** is signed by Mivia's statement key and lists every other file in the pack with its SHA-256, so nothing can be added, removed or changed. It is Mivia's account on the date shown (assurance level, warnings, creation history, lineage, scan dates); a later pack may say more.
+7. **The audio** (with `--audio`):
+   - **exact file:** for records registered from October 2026, the record contains the SHA-256 of the file that was uploaded; a creator who kept that file can prove it is the one;
+   - **fingerprint:** compared with the registered Chromaprint fingerprint. A similarity measure: it also matches re-encoded or edited copies.
+
+A check that could not run (offline, no proof yet, no fingerprint) is shown as `----`, not as a failure.
+
+You do not have to trust this tool either: [SPEC.md](SPEC.md) describes the pack precisely enough to write your own checker.
+
+## Licence
+
+Apache-2.0. This repository contains the pack format and the checks only; Mivia's watermarking engine is not part of it.

mivia_verify-1.0.0/pyproject.toml

@@ -0,0 +1,28 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mivia-verify"
+version = "1.0.0"
+description = "Check a Mivia evidence pack without relying on Mivia."
+readme = "README.md"
+license = { text = "Apache-2.0" }
+authors = [{ name = "Mivia Software Ltd" }]
+requires-python = ">=3.9"
+dependencies = ["pynacl>=1.5", "blake3>=0.4"]
+classifiers = [
+  "License :: OSI Approved :: Apache Software License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Multimedia :: Sound/Audio",
+  "Topic :: Security :: Cryptography",
+]
+
+[project.urls]
+Homepage = "https://github.com/MiviaCo/mivia-verify"
+
+[project.scripts]
+mivia-verify = "mivia_verify.cli:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

mivia_verify-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mivia_verify-1.0.0/src/mivia_verify/__init__.py

@@ -0,0 +1,6 @@
+"""Check a Mivia evidence pack without relying on Mivia."""
+
+from .verify import Check, Keys, Verdict, verify_pack
+
+__all__ = ["Check", "Keys", "Verdict", "verify_pack"]
+__version__ = "1.0.0"

mivia_verify-1.0.0/src/mivia_verify/cli.py

@@ -0,0 +1,91 @@
+"""mivia-verify: check a Mivia evidence pack from the command line."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import subprocess
+import sys
+import urllib.request
+from typing import Optional, Tuple
+
+from . import __version__, keys
+from .verify import verify_pack
+
+MARK = {True: "PASS", False: "FAIL", None: "----"}
+
+
+def mempool_block(height: int) -> Optional[Tuple[str, int]]:
+    """Merkle root and time of a block, from a public block explorer."""
+    for base in ("https://mempool.space/api", "https://blockstream.info/api"):
+        try:
+            with urllib.request.urlopen(f"{base}/block-height/{height}", timeout=15) as r:
+                block_hash = r.read().decode().strip()
+            with urllib.request.urlopen(f"{base}/block/{block_hash}", timeout=15) as r:
+                b = json.load(r)
+            return b["merkle_root"], int(b["timestamp"])
+        except Exception:
+            continue
+    return None
+
+
+def node_block(height: int) -> Optional[Tuple[str, int]]:
+    """Merkle root and time of a block, from your own Bitcoin node (bitcoin-cli)."""
+    try:
+        h = subprocess.run(["bitcoin-cli", "getblockhash", str(height)], capture_output=True, check=True, text=True)
+        b = subprocess.run(["bitcoin-cli", "getblockheader", h.stdout.strip()], capture_output=True, check=True, text=True)
+        j = json.loads(b.stdout)
+        return j["merkleroot"], int(j["time"])
+    except Exception:
+        return None
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="mivia-verify",
+        description="Check a Mivia evidence pack without relying on Mivia.",
+    )
+    ap.add_argument("pack", help="the evidence pack (.zip)")
+    ap.add_argument("--audio", help="an audio file to compare with the registered recording")
+    ap.add_argument("--offline", action="store_true", help="no network: skip the published-key and Bitcoin lookups")
+    ap.add_argument("--bitcoin-node", action="store_true", help="look blocks up with your own node (bitcoin-cli)")
+    ap.add_argument("--json", action="store_true", help="print the result as JSON")
+    ap.add_argument("--version", action="version", version=f"mivia-verify {__version__}")
+    a = ap.parse_args(argv)
+
+    with open(a.pack, "rb") as fh:
+        pack = fh.read()
+    lookup = None if a.offline else (node_block if a.bitcoin_node else mempool_block)
+    v = verify_pack(
+        pack,
+        audio_path=a.audio,
+        published=None if a.offline else keys.published(),
+        pinned=keys.pinned(),
+        block_lookup=lookup,
+    )
+
+    if a.json:
+        print(json.dumps({
+            "record_id": v.record_id,
+            "passed": not v.failed,
+            "checks": [c.__dict__ for c in v.checks],
+        }, indent=2))
+        return 1 if v.failed else 0
+
+    m = v.manifest
+    print(f"Mivia evidence pack, record {v.record_id}")
+    if m.get("title"):
+        print(f'"{m.get("title")}" registered by {m.get("creator")} on {str(m.get("created_utc", ""))[:10]}')
+    print()
+    for c in v.checks:
+        print(f"[{MARK[c.ok]}] {c.title}")
+        print(f"       {c.detail}")
+    print()
+    print("Result:", "FAILED: do not rely on this pack." if v.failed else "every check that could run passed.")
+    print("A pack shows what was registered, by which account, and since when.")
+    print("It does not prove who wrote the music or who owns it.")
+    return 1 if v.failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mivia_verify-1.0.0/src/mivia_verify/keys.py

@@ -0,0 +1,43 @@
+"""Mivia's public keys, pinned in this repository.
+
+The verifier compares the keys inside a pack with this copy and with the
+one published at https://mivia.co/.well-known/mivia-keys.json. Two
+independent copies: changing one is not enough to make a forged pack pass.
+
+Production keys, published 2026-10-16. The platform key was read from
+decode.mivia.co/healthz and matches the issuer id (447fb581) in every web
+registration's watermark payload. A rotated key is added here, never
+removed, so older packs keep verifying.
+"""
+
+from __future__ import annotations
+
+import base64
+import json
+import urllib.request
+from typing import Optional
+
+from .verify import Keys
+
+PLATFORM_KEY_B64: Optional[str] = "1Z5ayax4CYcVDDVfmWaAaCwATMmBEH77gKVRB4kOEUc="
+STATEMENT_KEY_B64: Optional[str] = "APm0sr6P9ctu6IkiFzq/IsFjZuG8/TJh+0zaAJfR4w0="
+
+PUBLISHED_URL = "https://mivia.co/.well-known/mivia-keys.json"
+
+
+def pinned() -> Optional[Keys]:
+    if not PLATFORM_KEY_B64 or not STATEMENT_KEY_B64:
+        return None
+    return Keys(base64.b64decode(PLATFORM_KEY_B64), base64.b64decode(STATEMENT_KEY_B64))
+
+
+def published(url: str = PUBLISHED_URL, timeout: float = 10) -> Optional[Keys]:
+    try:
+        with urllib.request.urlopen(url, timeout=timeout) as r:
+            k = json.load(r)["keys"]
+        return Keys(
+            base64.b64decode(k["platform"]["public_key_b64"]),
+            base64.b64decode(k["statement"]["public_key_b64"]),
+        )
+    except Exception:
+        return None

mivia_verify-1.0.0/src/mivia_verify/ots.py

@@ -0,0 +1,134 @@
+"""Minimal OpenTimestamps proof reader.
+
+Walks a .ots proof from its starting digest and returns every attestation
+reached, with the digest at that point. For a Bitcoin attestation that
+digest is the merkle root of the block it names. Wire format:
+https://github.com/opentimestamps/python-opentimestamps (core/serialize.py,
+core/timestamp.py, core/op.py, core/notary.py).
+
+Kept dependency-free on purpose so the whole check can be read in one
+sitting. The standard client gives the same answer:
+    ots verify -d <BLAKE3 hex of manifest.json> timestamp.ots
+"""
+
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass
+from typing import List, Optional
+
+HEADER_MAGIC = (
+    b"\x00OpenTimestamps\x00\x00Proof\x00\xbf\x89\xe2\xe8\x84\xe8\x92\x94"
+)
+VERSION = 1
+OP_SHA256 = 0x08
+
+BITCOIN = bytes.fromhex("0588960d73d71901")
+PENDING = bytes.fromhex("83dfe30d2ef90c8e")
+
+
+class OtsError(ValueError):
+    pass
+
+
+@dataclass
+class Attestation:
+    kind: str  # "bitcoin", "pending" or "unknown"
+    digest: bytes
+    height: Optional[int] = None
+    url: Optional[str] = None
+
+
+class _Reader:
+    def __init__(self, data: bytes):
+        self.data = data
+        self.pos = 0
+
+    def eof(self) -> bool:
+        return self.pos >= len(self.data)
+
+    def byte(self) -> int:
+        if self.eof():
+            raise OtsError("unexpected end of proof")
+        b = self.data[self.pos]
+        self.pos += 1
+        return b
+
+    def peek(self) -> int:
+        if self.eof():
+            raise OtsError("unexpected end of proof")
+        return self.data[self.pos]
+
+    def take(self, n: int) -> bytes:
+        if self.pos + n > len(self.data):
+            raise OtsError("unexpected end of proof")
+        out = self.data[self.pos : self.pos + n]
+        self.pos += n
+        return out
+
+    def varuint(self) -> int:
+        value, shift = 0, 0
+        while True:
+            b = self.byte()
+            value |= (b & 0x7F) << shift
+            if not b & 0x80:
+                return value
+            shift += 7
+            if shift > 63:
+                raise OtsError("varuint too long")
+
+    def varbytes(self) -> bytes:
+        return self.take(self.varuint())
+
+
+def _apply(tag: int, r: _Reader, digest: bytes) -> bytes:
+    if tag == 0x08:
+        return hashlib.sha256(digest).digest()
+    if tag == 0x02:
+        return hashlib.sha1(digest).digest()
+    if tag == 0x03:
+        return hashlib.new("ripemd160", digest).digest()
+    if tag == 0xF0:
+        return digest + r.varbytes()
+    if tag == 0xF1:
+        return r.varbytes() + digest
+    if tag == 0xF2:
+        return digest[::-1]
+    if tag == 0xF3:
+        return digest.hex().encode()
+    raise OtsError(f"unsupported operation 0x{tag:02x}")
+
+
+def _walk(r: _Reader, digest: bytes, out: List[Attestation]) -> None:
+    while True:
+        tag = r.byte()
+        if tag == 0x00:
+            magic = r.take(8)
+            payload = r.varbytes()
+            if magic == BITCOIN:
+                out.append(Attestation("bitcoin", digest, height=_Reader(payload).varuint()))
+            elif magic == PENDING:
+                p = _Reader(payload)
+                out.append(Attestation("pending", digest, url=p.varbytes().decode("utf-8", "replace")))
+            else:
+                out.append(Attestation("unknown", digest))
+        else:
+            _walk(r, _apply(tag, r, digest), out)
+        if r.eof() or r.peek() != 0xFF:
+            return
+        r.byte()
+
+
+def read_file(ots_file: bytes) -> tuple[bytes, List[Attestation]]:
+    """Parse a complete .ots file. Returns (the digest it starts from, attestations)."""
+    r = _Reader(ots_file)
+    if r.take(len(HEADER_MAGIC)) != HEADER_MAGIC:
+        raise OtsError("not an OpenTimestamps file")
+    if r.varuint() != VERSION:
+        raise OtsError("unsupported OpenTimestamps version")
+    if r.byte() != OP_SHA256:
+        raise OtsError("unexpected file hash operation")
+    digest = r.take(32)
+    atts: List[Attestation] = []
+    _walk(r, digest, atts)
+    return digest, atts

mivia_verify-1.0.0/src/mivia_verify/verify.py

@@ -0,0 +1,344 @@
+"""The checks. Same rules as the web checker on mivia.co; see SPEC.md."""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import io
+import json
+import shutil
+import subprocess
+import zipfile
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from typing import Callable, Dict, List, Optional, Tuple
+
+import blake3
+from nacl.exceptions import BadSignatureError
+from nacl.signing import VerifyKey
+
+from . import ots
+
+# Fingerprint matching, as on mivia.co (functions/_lib/chromaprint.ts).
+FP_MATCH_THRESHOLD = 0.35
+FP_MIN_OVERLAP_FRAMES = 80
+
+
+@dataclass
+class Check:
+    id: str
+    ok: Optional[bool]  # True pass, False fail, None could not be checked
+    title: str
+    detail: str
+
+
+@dataclass
+class Keys:
+    platform: bytes
+    statement: bytes
+
+
+@dataclass
+class Verdict:
+    checks: List[Check] = field(default_factory=list)
+    record_id: Optional[str] = None
+    manifest: Dict = field(default_factory=dict)
+    statement: Optional[Dict] = None
+
+    @property
+    def failed(self) -> bool:
+        return any(c.ok is False for c in self.checks)
+
+
+BlockLookup = Callable[[int], Optional[Tuple[str, int]]]  # height -> (merkle root hex as explorers show it, unix time)
+
+
+def _verify_sig(sig: Optional[bytes], msg: bytes, pub: Optional[bytes]) -> bool:
+    if not sig or not pub:
+        return False
+    try:
+        VerifyKey(pub).verify(msg, sig)
+        return True
+    except (BadSignatureError, ValueError):
+        return False
+
+
+def _crc16(data: bytes) -> int:
+    crc = 0xFFFF
+    for byte in data:
+        crc ^= byte << 8
+        for _ in range(8):
+            crc = ((crc << 1) ^ 0x1021) & 0xFFFF if crc & 0x8000 else (crc << 1) & 0xFFFF
+    return crc
+
+
+def _day(unix: int) -> str:
+    return datetime.fromtimestamp(unix, tz=timezone.utc).strftime("%-d %B %Y")
+
+
+def _u32s(raw: bytes) -> List[int]:
+    return [int.from_bytes(raw[i : i + 4], "little") for i in range(0, len(raw) - len(raw) % 4, 4)]
+
+
+def alignment_score(a: List[int], b: List[int]) -> float:
+    """Lowest bit-error rate over all alignments with at least 80 overlapping frames."""
+    best = 1.0
+    la, lb, m = len(a), len(b), FP_MIN_OVERLAP_FRAMES
+    for offset in range(-(lb - m), la - m + 1):
+        if offset >= 0:
+            ao, bo, n = offset, 0, min(la - offset, lb)
+        else:
+            ao, bo, n = 0, -offset, min(lb + offset, la)
+        diff = sum(bin(a[ao + i] ^ b[bo + i]).count("1") for i in range(n))
+        best = min(best, diff / (n * 32))
+    return best
+
+
+def fpcalc_fingerprint(path: str) -> Optional[List[int]]:
+    """Chromaprint of an audio file, computed the way Mivia computes it at registration."""
+    exe = shutil.which("fpcalc")
+    if not exe:
+        return None
+    out = subprocess.run(
+        [exe, "-length", "120", "-raw", "-json", path], capture_output=True, check=False
+    )
+    if out.returncode != 0:
+        return None
+    return [v & 0xFFFFFFFF for v in json.loads(out.stdout)["fingerprint"]]
+
+
+def verify_pack(
+    pack: bytes,
+    audio_path: Optional[str] = None,
+    published: Optional[Keys] = None,
+    pinned: Optional[Keys] = None,
+    block_lookup: Optional[BlockLookup] = None,
+) -> Verdict:
+    v = Verdict()
+    try:
+        with zipfile.ZipFile(io.BytesIO(pack)) as z:
+            files = {n: z.read(n) for n in z.namelist() if not n.endswith("/")}
+    except zipfile.BadZipFile:
+        v.checks.append(Check("record", False, "Not an evidence pack", "The file is not a readable zip."))
+        return v
+    manifest = files.get("1-registration/manifest.json")
+    if manifest is None:
+        v.checks.append(Check("record", False, "Not an evidence pack", "There is no 1-registration/manifest.json."))
+        return v
+
+    pack_keys: Optional[Keys] = None
+    try:
+        k = json.loads(files["3-keys/mivia-keys.json"])["keys"]
+        pack_keys = Keys(
+            base64.b64decode(k["platform"]["public_key_b64"]),
+            base64.b64decode(k["statement"]["public_key_b64"]),
+        )
+    except (KeyError, ValueError, TypeError):
+        pack_keys = None
+
+    # 1. Record integrity.
+    h = blake3.blake3(manifest).digest()
+    rid = h[:8].hex()
+    v.record_id = rid
+    try:
+        v.manifest = json.loads(manifest)
+    except ValueError:
+        v.manifest = {}
+    try:
+        v.statement = json.loads(files["2-statement/statement.json"])
+    except (KeyError, ValueError):
+        v.statement = None
+    rec = (v.statement or {}).get("record", {})
+    rec_ok = not rec.get("id") or (rec.get("id") == rid and rec.get("manifest_blake3") == h.hex())
+    v.checks.append(
+        Check(
+            "record",
+            rec_ok,
+            "The record is intact" if rec_ok else "The record does not match its id",
+            f"BLAKE3 of the record gives the id {rid}. Make sure this is the id in the certificate "
+            f"address you were given (mivia.co/c/{rid})."
+            if rec_ok
+            else f"The record's content gives the id {rid}, but the pack says {rec.get('id')}. "
+            "The record has been changed.",
+        )
+    )
+
+    # 2. Mivia's signature over the record.
+    sig_ok = _verify_sig(files.get("1-registration/manifest.sig"), manifest, pack_keys and pack_keys.platform)
+    v.checks.append(
+        Check(
+            "signature",
+            sig_ok,
+            "Signed by Mivia" if sig_ok else "The signature does not match",
+            "Mivia's Ed25519 signature on the record is valid, so it has not been changed since it was registered."
+            if sig_ok
+            else "The record was changed after signing, or was not signed by the key in this pack.",
+        )
+    )
+
+    # 3. The keys are Mivia's: compared with the copy pinned in this tool and the one on mivia.co.
+    if pack_keys is None:
+        v.checks.append(Check("keys", False, "Keys missing", "The pack has no readable 3-keys/mivia-keys.json."))
+    else:
+        refs = [(n, k) for n, k in (("this tool", pinned), ("mivia.co", published)) if k is not None]
+        if not refs:
+            v.checks.append(
+                Check("keys", None, "Keys not compared", "No reference copy of Mivia's keys was available.")
+            )
+        else:
+            bad = [n for n, k in refs if (k.platform, k.statement) != (pack_keys.platform, pack_keys.statement)]
+            names = " and ".join(n for n, _ in refs)
+            v.checks.append(
+                Check(
+                    "keys",
+                    not bad,
+                    "The keys are Mivia's published keys" if not bad else "The keys are not Mivia's",
+                    f"The keys in the pack match the copy held by {names}."
+                    if not bad
+                    else f"The keys in the pack differ from the copy held by {' and '.join(bad)}. Do not rely on it.",
+                )
+            )
+
+    # 4. Bitcoin timestamp for BLAKE3(manifest.json).
+    ots_file = files.get("1-registration/timestamp.ots")
+    if ots_file is None:
+        v.checks.append(Check("timestamp", None, "No timestamp yet", "The pack has no Bitcoin timestamp proof yet."))
+    else:
+        try:
+            start, atts = ots.read_file(ots_file)
+        except ots.OtsError as e:
+            v.checks.append(Check("timestamp", False, "The timestamp proof is damaged", str(e)))
+            atts, start = [], b""
+        if ots_file is not None and start and start != h:
+            v.checks.append(
+                Check("timestamp", False, "The timestamp is for another record",
+                      "The proof does not start from this record's hash.")
+            )
+        elif start:
+            btc = [a for a in atts if a.kind == "bitcoin"]
+            if not btc:
+                v.checks.append(
+                    Check("timestamp", None, "Timestamp waiting for Bitcoin",
+                          "The proof is valid but not yet anchored in a Bitcoin block.")
+                )
+            elif block_lookup is None:
+                v.checks.append(
+                    Check("timestamp", None, f"Claims Bitcoin block {btc[0].height}",
+                          "Offline: the block was not looked up, so the claim was not confirmed.")
+                )
+            else:
+                confirmed = None
+                for a in btc:
+                    found = block_lookup(a.height)
+                    if found and a.digest[::-1].hex() == found[0].lower():
+                        confirmed = (a.height, found[1])
+                        break
+                v.checks.append(
+                    Check("timestamp", True, f"Existed by {_day(confirmed[1])}",
+                          f"The record is committed in Bitcoin block {confirmed[0]}, mined on {_day(confirmed[1])}. "
+                          "Nobody, including Mivia, can backdate it.")
+                    if confirmed
+                    else Check("timestamp", False, "The Bitcoin block does not match",
+                               f"The proof points to block {btc[0].height}, but that block does not contain it.")
+                )
+
+    # 5. The watermark payload belongs to this record.
+    payload_hex = files.get("1-registration/watermark-payload.hex")
+    if payload_hex is None:
+        v.checks.append(
+            Check("watermark", None, "No watermark payload",
+                  "This record has no watermark payload in the pack (normal for DAW plug-in registrations).")
+        )
+    else:
+        try:
+            p = bytes.fromhex(payload_hex.decode().strip())
+        except ValueError:
+            p = b""
+        wm_ok = (
+            len(p) == 20
+            and p[0] == 0xFB
+            and _crc16(p[:18]) == int.from_bytes(p[18:20], "big")
+            and p[6:14] == h[:8]
+            and pack_keys is not None
+            and p[2:6] == blake3.blake3(pack_keys.platform).digest()[:4]
+        )
+        v.checks.append(
+            Check(
+                "watermark",
+                wm_ok,
+                "The watermark payload points to this record" if wm_ok else "The watermark payload does not match",
+                "The payload embedded in the audio carries this record's id and Mivia's issuer id. Reading it "
+                "from an audio file needs Mivia's decoder or the public scan on mivia.co."
+                if wm_ok
+                else "The payload in the pack does not point to this record.",
+            )
+        )
+
+    # 6. Mivia's dated statement.
+    st = files.get("2-statement/statement.json")
+    if st is None or v.statement is None:
+        v.checks.append(Check("statement", False, "Statement missing", "No readable 2-statement/statement.json."))
+    else:
+        s_ok = _verify_sig(files.get("2-statement/statement.sig"), st, pack_keys and pack_keys.statement)
+        listed = v.statement.get("files", [])
+        others = sorted(n for n in files if not n.startswith("2-statement/"))
+        list_ok = [f.get("path") for f in listed] == others and all(
+            hashlib.sha256(files[f["path"]]).hexdigest() == f.get("sha256") for f in listed
+        )
+        ok = s_ok and list_ok
+        v.checks.append(
+            Check(
+                "statement",
+                ok,
+                f"Mivia's statement of {str(v.statement.get('generated_utc', ''))[:10]} is genuine"
+                if ok
+                else "The statement does not match the pack",
+                "The statement is signed by Mivia and covers every other file in the pack. It is Mivia's "
+                "account of the record on that date; a later pack may say more (for example, a dispute)."
+                if ok
+                else ("The statement's signature is not valid." if not s_ok
+                      else "Files were added, removed or changed after the statement was signed."),
+            )
+        )
+
+    # 7. The audio file: exact match where the record has the file's hash, fingerprint otherwise too.
+    if audio_path:
+        with open(audio_path, "rb") as fh:
+            got = hashlib.sha256(fh.read()).hexdigest()
+        want = ((v.manifest.get("extensions") or {}).get("audio") or {}).get("file_sha256")
+        if want:
+            v.checks.append(
+                Check("audio", True, "This is the exact file that was registered",
+                      f"Its SHA-256 ({got}) is the one signed in the record.")
+                if want == got
+                else Check("audio", False, "Not the exact registered file",
+                           "This file is not byte-for-byte the registered one. See the fingerprint check.")
+            )
+        registered = files.get("1-registration/fingerprint.chromaprint")
+        if registered is None:
+            v.checks.append(Check("fingerprint", None, "No registered fingerprint",
+                                  "This record has no fingerprint in the pack."))
+        else:
+            fp = fpcalc_fingerprint(audio_path)
+            if fp is None:
+                v.checks.append(
+                    Check("fingerprint", None, "Fingerprint not compared",
+                          "Install Chromaprint's fpcalc (https://acoustid.org/chromaprint) to compare the audio.")
+                )
+            elif len(fp) < FP_MIN_OVERLAP_FRAMES or len(_u32s(registered)) < FP_MIN_OVERLAP_FRAMES:
+                v.checks.append(Check("fingerprint", None, "Audio too short to compare",
+                                      "At least 10 seconds of overlap are needed."))
+            else:
+                score = alignment_score(fp, _u32s(registered))
+                match = score < FP_MATCH_THRESHOLD
+                v.checks.append(
+                    Check(
+                        "fingerprint",
+                        match,
+                        "The audio matches the registered recording" if match
+                        else "The audio does not match the registered recording",
+                        f"Chromaprint bit-error rate {score:.3f} (a match is below {FP_MATCH_THRESHOLD}). "
+                        "This is a similarity measure: it also matches re-encoded or edited copies.",
+                    )
+                )
+    return v

mivia_verify-1.0.0/src/mivia_verify.egg-info/PKG-INFO

@@ -0,0 +1,71 @@
+Metadata-Version: 2.4
+Name: mivia-verify
+Version: 1.0.0
+Summary: Check a Mivia evidence pack without relying on Mivia.
+Author: Mivia Software Ltd
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/MiviaCo/mivia-verify
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pynacl>=1.5
+Requires-Dist: blake3>=0.4
+Dynamic: license-file
+
+# mivia-verify
+
+Check a [Mivia](https://mivia.co) evidence pack yourself, without relying on Mivia.
+
+Every recording registered with Mivia has a public Certificate of Registration. Its owner can download an **evidence pack**: a zip with the signed registration record, its Bitcoin timestamp and Mivia's signed, dated statement about the record. This tool checks every part of a pack and tells you, in plain language, what passed.
+
+**What a pack proves:** what was registered, by which Mivia account, and that the record existed no later than a given Bitcoin block. **What it does not prove:** who wrote the music or who owns it. That is for contracts, registries and courts.
+
+## Install
+
+Python 3.9 or later:
+
+```
+pip install git+https://github.com/MiviaCo/mivia-verify
+```
+
+To compare an audio file by its acoustic fingerprint, also install Chromaprint's `fpcalc` (`brew install chromaprint`, `apt install libchromaprint-tools`, or <https://acoustid.org/chromaprint>).
+
+## Use
+
+```
+mivia-verify mivia-evidence-<id>-<date>.zip
+mivia-verify mivia-evidence-<id>-<date>.zip --audio the-recording.wav
+```
+
+| Option | What it does |
+|---|---|
+| `--audio FILE` | Check whether FILE is the exact registered file, and whether it matches the registered recording by fingerprint |
+| `--offline` | No network at all: skips comparing keys with mivia.co and looking up the Bitcoin block |
+| `--bitcoin-node` | Look the block up with your own Bitcoin node (`bitcoin-cli`) instead of a public block explorer |
+| `--json` | Machine-readable output |
+
+The exit code is 0 when every check that could run passed, and 1 otherwise.
+
+## What it checks
+
+1. **The record is intact.** BLAKE3 of `1-registration/manifest.json` gives the record id, the same id as in the certificate address `mivia.co/c/<id>`.
+2. **Signed by Mivia.** The Ed25519 signature in `manifest.sig` is valid for the record.
+3. **The keys are Mivia's.** The keys in the pack match the copy pinned in this repository (`src/mivia_verify/keys.py`) and the copy published at <https://mivia.co/.well-known/mivia-keys.json>.
+4. **The Bitcoin timestamp.** The OpenTimestamps proof starts from the record's BLAKE3 hash and leads to the merkle root of a Bitcoin block, confirmed with a public block explorer or your own node. Nobody, including Mivia, can backdate it.
+5. **The watermark payload** (web registrations) points to this record and to Mivia's key. Reading the payload from audio needs Mivia's decoder or the public scan on mivia.co; this tool checks that the payload in the pack belongs to the record.
+6. **Mivia's dated statement** is signed by Mivia's statement key and lists every other file in the pack with its SHA-256, so nothing can be added, removed or changed. It is Mivia's account on the date shown (assurance level, warnings, creation history, lineage, scan dates); a later pack may say more.
+7. **The audio** (with `--audio`):
+   - **exact file:** for records registered from October 2026, the record contains the SHA-256 of the file that was uploaded; a creator who kept that file can prove it is the one;
+   - **fingerprint:** compared with the registered Chromaprint fingerprint. A similarity measure: it also matches re-encoded or edited copies.
+
+A check that could not run (offline, no proof yet, no fingerprint) is shown as `----`, not as a failure.
+
+You do not have to trust this tool either: [SPEC.md](SPEC.md) describes the pack precisely enough to write your own checker.
+
+## Licence
+
+Apache-2.0. This repository contains the pack format and the checks only; Mivia's watermarking engine is not part of it.

mivia_verify-1.0.0/src/mivia_verify.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/mivia_verify/__init__.py
+src/mivia_verify/cli.py
+src/mivia_verify/keys.py
+src/mivia_verify/ots.py
+src/mivia_verify/verify.py
+src/mivia_verify.egg-info/PKG-INFO
+src/mivia_verify.egg-info/SOURCES.txt
+src/mivia_verify.egg-info/dependency_links.txt
+src/mivia_verify.egg-info/entry_points.txt
+src/mivia_verify.egg-info/requires.txt
+src/mivia_verify.egg-info/top_level.txt
+tests/test_verify.py

mivia_verify-1.0.0/src/mivia_verify.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mivia_verify-1.0.0/src/mivia_verify.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mivia-verify = mivia_verify.cli:main

mivia_verify-1.0.0/src/mivia_verify.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pynacl>=1.5
+blake3>=0.4

mivia_verify-1.0.0/src/mivia_verify.egg-info/top_level.txt

@@ -0,0 +1 @@
+mivia_verify

mivia_verify-1.0.0/tests/test_verify.py

@@ -0,0 +1,173 @@
+"""Tests build packs the way mivia.co does (functions/_lib/evidence.ts) and tamper with them."""
+
+import hashlib
+import io
+import json
+import os
+import zipfile
+from pathlib import Path
+
+import blake3
+import pytest
+from nacl.signing import SigningKey
+
+from mivia_verify import Keys, verify_pack
+from mivia_verify import ots as ots_mod
+
+PLATFORM = SigningKey(bytes([7]) * 32)
+STATEMENT = SigningKey(bytes([9]) * 32)
+KEYS = Keys(bytes(PLATFORM.verify_key), bytes(STATEMENT.verify_key))
+AUDIO = b"RIFF....fake wav bytes"
+
+
+def canonical(d):
+    return json.dumps(d, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode()
+
+
+MANIFEST = canonical({
+    "created_utc": "2026-10-15T12:00:00Z",
+    "creator": "Artist",
+    "extensions": {"audio": {"file_sha256": hashlib.sha256(AUDIO).hexdigest()}},
+    "title": "Song",
+})
+H = blake3.blake3(MANIFEST).digest()
+APPEND = bytes([3]) * 16
+TREE = bytes([0xF0, 16]) + APPEND + bytes([0x08, 0x00]) + ots_mod.BITCOIN + bytes([3, 0xA0, 0xF7, 0x36])
+MERKLE = hashlib.sha256(H + APPEND).digest()
+
+
+def lookup(height):
+    return (MERKLE[::-1].hex(), 1760500000) if height == 900000 else None
+
+
+def crc16(data):
+    crc = 0xFFFF
+    for b in data:
+        crc ^= b << 8
+        for _ in range(8):
+            crc = ((crc << 1) ^ 0x1021) & 0xFFFF if crc & 0x8000 else (crc << 1) & 0xFFFF
+    return crc
+
+
+def payload():
+    p = bytes([0xFB, 5]) + blake3.blake3(KEYS.platform).digest()[:4] + H[:8] + bytes(4)
+    return p + crc16(p).to_bytes(2, "big")
+
+
+def files():
+    import base64
+    keys = {"keys": {
+        "platform": {"public_key_b64": base64.b64encode(KEYS.platform).decode()},
+        "statement": {"public_key_b64": base64.b64encode(KEYS.statement).decode()},
+    }}
+    f = {
+        "1-registration/manifest.json": MANIFEST,
+        "1-registration/manifest.sig": PLATFORM.sign(MANIFEST).signature,
+        "1-registration/timestamp.ots": ots_mod.HEADER_MAGIC + b"\x01\x08" + H + TREE,
+        "1-registration/watermark-payload.hex": (payload().hex() + "\n").encode(),
+        "3-keys/mivia-keys.json": json.dumps(keys).encode(),
+        "README.txt": b"readme",
+    }
+    return f
+
+
+def seal(f):
+    st = canonical({
+        "generated_utc": "2026-10-20T09:00:00.000Z",
+        "record": {"id": H[:8].hex(), "manifest_blake3": H.hex()},
+        "files": [{"path": p, "sha256": hashlib.sha256(f[p]).hexdigest()} for p in sorted(f)],
+    })
+    f["2-statement/statement.json"] = st
+    f["2-statement/statement.sig"] = STATEMENT.sign(st).signature
+    return f
+
+
+def zipped(f):
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        for k, v in f.items():
+            z.writestr(k, v)
+    return buf.getvalue()
+
+
+def results(v):
+    return {c.id: c.ok for c in v.checks}
+
+
+@pytest.fixture
+def audio(tmp_path):
+    p = tmp_path / "song.wav"
+    p.write_bytes(AUDIO)
+    return str(p)
+
+
+def test_genuine_pack_passes(audio):
+    v = verify_pack(zipped(seal(files())), audio_path=audio, published=KEYS, pinned=KEYS, block_lookup=lookup)
+    assert results(v) == {
+        "record": True, "signature": True, "keys": True, "timestamp": True,
+        "watermark": True, "statement": True, "audio": True, "fingerprint": None,
+    }
+    assert v.record_id == H[:8].hex()
+    assert not v.failed
+
+
+def test_one_changed_byte_in_the_record_fails():
+    f = files()
+    m = bytearray(f["1-registration/manifest.json"])
+    m[10] ^= 1
+    f["1-registration/manifest.json"] = bytes(m)
+    r = results(verify_pack(zipped(seal(files()) | {"1-registration/manifest.json": bytes(m)}), published=KEYS, block_lookup=lookup))
+    assert r["record"] is False and r["signature"] is False and r["timestamp"] is False and r["statement"] is False
+
+
+def test_edited_statement_fails():
+    f = seal(files())
+    f["2-statement/statement.json"] = f["2-statement/statement.json"].replace(b"2026-10-20", b"2026-10-21")
+    assert results(verify_pack(zipped(f), published=KEYS))["statement"] is False
+
+
+def test_added_file_fails():
+    f = seal(files())
+    f["extra.txt"] = b"hi"
+    assert results(verify_pack(zipped(f), published=KEYS))["statement"] is False
+
+
+def test_keys_that_differ_from_either_reference_fail():
+    other = Keys(bytes(SigningKey(bytes([1]) * 32).verify_key), KEYS.statement)
+    v = verify_pack(zipped(seal(files())), published=KEYS, pinned=other)
+    assert results(v)["keys"] is False
+
+
+def test_wrong_bitcoin_block_fails():
+    v = verify_pack(zipped(seal(files())), published=KEYS, block_lookup=lambda h: ("00" * 32, 1))
+    assert results(v)["timestamp"] is False
+
+
+def test_a_different_audio_file_fails(tmp_path):
+    p = tmp_path / "other.wav"
+    p.write_bytes(b"other")
+    assert results(verify_pack(zipped(seal(files())), audio_path=str(p), published=KEYS))["audio"] is False
+
+
+def test_offline_reports_unchecked_not_failed():
+    r = results(verify_pack(zipped(seal(files()))))
+    assert r["keys"] is None and r["timestamp"] is None
+
+
+def test_not_a_pack():
+    assert verify_pack(b"not a zip").failed
+
+
+def test_pack_built_by_the_website_verifies():
+    """A pack downloaded from a local run of mivia.co (local test keys)."""
+    pack = (Path(__file__).parent / "vectors" / "website-pack.zip").read_bytes()
+    r = results(verify_pack(pack))
+    assert r["record"] is True and r["signature"] is True and r["statement"] is True
+
+
+def test_alignment_score_identical_and_unrelated():
+    from mivia_verify.verify import alignment_score
+    a = [int.from_bytes(os.urandom(4), "little") for _ in range(200)]
+    b = [int.from_bytes(os.urandom(4), "little") for _ in range(200)]
+    assert alignment_score(a, a) == 0
+    assert alignment_score(a, b) > 0.35