pq-verify 2.6.5__tar.gz

pq_verify-2.6.5/DEMO.ipynb

@@ -0,0 +1,13 @@
+{
+ "cells": [
+  {"cell_type":"markdown","metadata":{},"source":["# pq-verify v2.6.0 — One-Click Demo\n","\n","Run all cells (Runtime -> Run all). ~3 minutes to 240/240 NIST ACVP vectors.\n","\n","Upload `pq_verify_v2_6_0.py` when the file picker appears in Cell 2."]},
+  {"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Cell 1: dependencies (~60s)\n","!apt-get install -y -qq coq gcc g++ > /dev/null 2>&1\n","!pip install kyber-py -q --break-system-packages\n","print('dependencies installed')"]},
+  {"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Cell 2: upload + load the stack (runs 160-test self-suite)\n","from google.colab import files\n","up = files.upload()\n","fn = list(up.keys())[0]\n","exec(open(fn).read())"]},
+  {"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Cell 3: full NIST ACVP — all 12 groups, 240/240\n","pqverify_acvp()"]},
+  {"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Cell 4: parameter security check\n","pqverify_params('ML-KEM-1024')"]},
+  {"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Cell 5: native full-KEM at Level 5\n","pqverify_kem(k=4)"]},
+  {"cell_type":"code","execution_count":null,"metadata":{},"outputs":[],"source":["# Cell 6: audit a compiled .so (build a demo NTT, then audit it)\n","ntt_c = '''#include <stdint.h>\n","#define Q 3329\n","#define N 256\n","static uint16_t pw(uint16_t b,uint32_t e,uint16_t q){uint32_t r=1,x=b;while(e){if(e&1)r=r*x%q;x=x*x%q;e>>=1;}return(uint16_t)r;}\n","static uint32_t br(uint32_t x){uint32_t r=0;for(int i=0;i<7;i++){r=(r<<1)|(x&1);x>>=1;}return r;}\n","static uint16_t z[128];static int rdy=0;\n","void ntt(uint16_t f[N]){if(!rdy){for(int i=0;i<128;i++)z[i]=pw(17,br(i),Q);rdy=1;}int k=1;\n","for(int L=128;L>=2;L>>=1)for(int s=0;s<N;s+=2*L){uint16_t zz=z[k++];for(int j=s;j<s+L;j++){\n","uint16_t t=(uint16_t)(((uint32_t)zz*f[j+L])%Q);f[j+L]=(uint16_t)((f[j]+Q-t)%Q);f[j]=(uint16_t)((f[j]+t)%Q);}}}'''\n","open('kyber_ntt.c','w').write(ntt_c)\n","import os; os.system('gcc -O3 -shared -fPIC -o libkyber_ntt.so kyber_ntt.c')\n","ntt = pqverify_load_so('./libkyber_ntt.so','ntt')\n","pqverify_kat(ntt, k=4)\n","pqverify_leakage()"]}
+ ],
+ "metadata":{"kernelspec":{"display_name":"Python 3","name":"python3"},"language_info":{"name":"python"}},
+ "nbformat":4,"nbformat_minor":0
+}

pq_verify-2.6.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicholas Maino (iamweare)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pq_verify-2.6.5/MANIFEST.in

@@ -0,0 +1,7 @@
+include README.md
+include LICENSE
+include QUICKSTART.md
+include DEMO.ipynb
+include vendor_audit_template.py
+include sample_report.json
+recursive-include pq_verify/vectors *.json.gz *.json *.md

pq_verify-2.6.5/PKG-INFO

@@ -0,0 +1,231 @@
+Metadata-Version: 2.4
+Name: pq-verify
+Version: 2.6.5
+Summary: Independent verification for ML-KEM / ML-DSA implementations — native field NTT verification, NIST ACVP, lattice parameter security, Coq certificates.
+Author-email: Nicholas Maino <maiknown@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/bigDSanalyst/pq-verify
+Project-URL: Repository, https://github.com/bigDSanalyst/pq-verify
+Project-URL: Zenodo DOI, https://doi.org/10.5281/zenodo.19302050
+Keywords: post-quantum,cryptography,ML-KEM,ML-DSA,Kyber,Dilithium,FIPS-203,FIPS-204,NIST,ACVP,NTT,verification,lattice
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Topic :: Security :: Cryptography
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: full
+Requires-Dist: kyber-py; extra == "full"
+Requires-Dist: dilithium-py; extra == "full"
+Requires-Dist: sympy; extra == "full"
+Requires-Dist: slh-dsa; extra == "full"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: kyber-py; extra == "dev"
+Requires-Dist: dilithium-py; extra == "dev"
+Requires-Dist: sympy; extra == "dev"
+Requires-Dist: slh-dsa; extra == "dev"
+Dynamic: license-file
+
+# pq-verify v2.6.4 — PQC Implementation Verification
+
+![version](https://img.shields.io/badge/version-2.6.4-blue)
+![license](https://img.shields.io/badge/license-MIT-green)
+![tests](https://img.shields.io/badge/tests-160%2F160-brightgreen)
+![ACVP-KEM](https://img.shields.io/badge/ML--KEM%20ACVP-240%2F240-brightgreen)
+![ACVP-DSA](https://img.shields.io/badge/ML--DSA%20ACVP-615%2F615-brightgreen)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21739511.svg)](https://doi.org/10.5281/zenodo.21739511)
+
+**Independent verification for ML-KEM (Kyber) and ML-DSA (Dilithium) implementations.**
+
+You deploy post-quantum cryptography. pq-verify proves your implementation computes the FIPS 203/204 standard correctly — in the native finite field, against NIST's own test vectors, with machine-checkable certificates. Plus FIPS 205 SLH-DSA parameter validation across all 12 parameter sets.
+
+It does not compute PQC. It verifies the implementations that do: liboqs, BoringSSL, OpenSSL+OQS, HSM firmware, or your own code.
+
+---
+
+## What you get
+
+A three-layer audit of any ML-KEM/ML-DSA implementation:
+
+| Layer | Question answered | How |
+|-------|-------------------|-----|
+| **Correctness** | Does the NTT compute the FIPS definition? | Field-native verification + non-circular KAT |
+| **Compliance** | Does it match NIST's published vectors? | ML-KEM 240/240 + ML-DSA 615/615 = 855/855 ACVP vectors (pinned) |
+| **Security** | Are the parameters hard enough? | Bai-Galbraith primal-uSVP + hybrid attack estimator |
+
+Plus per-layer side-channel leakage analysis with protection-allocation recommendations.
+
+Every result is **reproducible** — deterministic output, SHA-256 fingerprint, re-runnable by your own auditors.
+
+---
+
+## Proven (all tested on commodity hardware, Google Colab CPU)
+
+- **160/160** self-test across 6 field-native engines, 6 phases
+- **240/240** NIST ACVP ML-KEM vectors — keyGen + encaps + decaps byte-exact, KeyCheck bool-exact
+- **Native full-KEM** verified at ML-KEM-1024 (Level 5): recovery 20/20, negative control caught
+- **Non-circular KAT** 100/100 against the independent FIPS reference
+- Calibrated lattice estimator: reproduces lattice-estimator exactly (Kyber-512 β=406/118.6 bits)
+- **Coq certificates** verified by `coqc` with real exit codes
+
+---
+
+## Quick start
+
+Open `DEMO.ipynb` in Google Colab and run all cells. ~3 minutes to 855/855.
+
+Or, in any Python 3.8+ environment with gcc:
+
+```python
+exec(open('pq_verify_v2_6_1.py').read())   # 160-test self-suite + loads the API
+
+pqverify_acvp()                    # full NIST ACVP, all parameter sets
+pqverify_params('ML-KEM-1024')     # parameter security check
+pqverify_kem(k=4)                  # native full-KEM at Level 5
+```
+
+To audit your own compiled library:
+
+```python
+ntt = pqverify_load_so('/path/to/your_library.so', 'ntt_symbol')
+pqverify_scan(ntt)                 # full audit + KAT + leakage
+```
+
+See `vendor_audit_template.py` for the complete "give us your .so → get a JSON report" workflow.
+
+---
+
+## Public API
+
+| Function | Purpose |
+|----------|---------|
+| `main()` | 160-test self-suite |
+| `pqverify_acvp()` | Full NIST ACVP end-to-end ML-KEM (240/240, all groups) |
+| `pqverify_mldsa_acvp()` | Full NIST ACVP end-to-end ML-DSA (615/615, FIPS 204) |
+| `pqverify_slhdsa_acvp()` | NIST ACVP SLH-DSA keyGen (120/120, FIPS 205, all 12 parameter sets) |
+| `pqverify_acvp_all()` | ML-KEM + ML-DSA (855/855) offline; `slhdsa=True` adds FIPS 205 → 975/975 |
+| `pqverify_params(set)` | Parameter security: primal-uSVP + sparse hybrid |
+| `pqverify_kem(k=4)` | Native algebraic full-KEM verification |
+| `pqverify_kat(ntt, k=4)` | Non-circular KAT vs FIPS definition |
+| `pqverify_load_so(path, sym)` | Load NTT from a compiled .so |
+| `pqverify_scan(target)` | Auto-discover + audit NTT functions |
+| `pqverify_leakage()` | Per-layer protection-allocation table |
+
+---
+
+## Deterministic by default
+
+pq-verify ships with a **frozen, versioned snapshot of NIST's ACVP vectors** bundled
+inside the package (gzipped, ~7 MB). By default it verifies against those — so:
+
+- **the same input gives the same result, every run, forever**
+- **it works with no network** — air-gapped, offline, no GitHub reachability needed
+- **NIST editing their published files cannot change or break your result**
+
+That last point is not hypothetical: NIST periodically regenerates these vectors and
+has changed the ML-KEM `encapDecap` schema (the `keyFormat` seed/expanded split) more
+than once. A tool that fetches live gives different answers on different days. This one
+does not.
+
+```python
+pqverify_acvp_all()              # pinned bundle, offline, deterministic  → 855/855
+pqverify_acvp_all(live=True)     # opt in: fetch NIST's current vectors instead
+pqverify_acvp_all(vector_dir=d)  # or point at your own local vector set
+```
+
+Vector provenance and per-file sha256 are recorded in `pq_verify/vectors/MANIFEST.json`.
+A scheduled GitHub Action watches upstream and opens an issue when NIST changes
+something, so re-pinning is a deliberate, reviewed act rather than a live dependency.
+
+## Scope
+
+pq-verify verifies the **algebraic substance** of ML-KEM/ML-DSA (NTT, module-LWE relations, parameter security) natively in Z₃₃₂₉ / Z₈₃₈₀₄₁₇. The **non-algebraic layers** (SHAKE/SHA3 hashing, sampling, compression, the FO transform) are bit/byte operations verified by NIST ACVP end-to-end testing, not native field solving.
+
+The algebraic core is proven natively where the proof is exact; the full implementation is proven byte-exact against NIST's own bytes. We make the claims we can prove.
+
+---
+
+## What's in this package
+
+```
+pq_verify/
+  __init__.py              Public API (11 functions)
+  core.py                  The stack (~6,100 lines, 6 field-native engines)
+  cli.py                   Command-line interface
+tests/test_pqverify.py     18-test pytest suite
+pyproject.toml             Build config + console-script entry point
+dist/
+  pq_verify-2.6.4-py3-none-any.whl    Installable wheel
+  pq_verify-2.6.4.tar.gz              Source distribution
+DEMO.ipynb                 One-click Colab demo → 855/855
+vendor_audit_template.py   Drop-in .so audit → JSON report
+sample_report.json         Example output (what your auditors receive)
+README.md / QUICKSTART.md / LICENSE / CITATION.cff
+```
+
+Install: `pip install dist/pq_verify-2.6.4-py3-none-any.whl`
+
+---
+
+## Requirements
+
+**Minimum (core engines + ~149 self-tests):**
+- Python 3.8+
+- gcc and g++ (the C/C++ engines compile at runtime)
+
+**For the full 160/160 self-suite and the 855/855 ACVP claim:**
+- `kyber-py` — **required** for `pqverify_acvp()` (the byte-exact NIST reference) and the FIPS 203 roundtrip tests
+- `dilithium-py` — **required** for `pqverify_mldsa_acvp()` (the 615 ML-DSA vectors)
+- `coq` — required for the Coq certificate verification tests
+- `sympy` — required for the Engine-6 Conjecture 7 exact-rational test (without it: 159/160)
+
+```bash
+apt-get install -y coq gcc g++
+pip install kyber-py dilithium-py sympy --break-system-packages
+```
+
+**Optional (1 test each, everything works without them):**
+- `cryptominisat` — the CMS5 speed-comparison benchmark
+- `slh-dsa` — SLH-DSA live roundtrip (parameters still validate without it)
+- network access — `pqverify_acvp()` fetches NIST vectors from GitHub live; for air-gapped use, pass `prompt_dir=` pointing at local vector files
+
+**Deliberately NOT required** (a deployment advantage):
+- No numpy, scipy, or PyTorch — pure Python + ctypes + inline C
+- No SageMath — the `pqverify_params` lattice estimator is self-contained (it reproduces the lattice-estimator's results without it)
+
+---
+
+## License
+
+MIT. The verifier is open-source — builds trust, enables adoption. Commercial support, custom engine development, and PQC audit engagements available separately.
+
+## Citing this software
+
+Archived on Zenodo with a citable DOI:
+
+> Maino, N. C. (2026). *pq-verify: Independent verification for ML-KEM / ML-DSA
+> implementations* (v2.6.4). Zenodo. https://doi.org/10.5281/zenodo.21739511
+
+```bibtex
+@software{maino_pqverify_2026,
+  author    = {Maino, Nicholas Clifford},
+  title     = {pq-verify: Independent verification for ML-KEM / ML-DSA implementations},
+  version   = {2.6.4},
+  year      = {2026},
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.21739511},
+  url       = {https://doi.org/10.5281/zenodo.21739511}
+}
+```
+
+The DOI above resolves to this specific release. The companion paper is
+[10.5281/zenodo.19302050](https://doi.org/10.5281/zenodo.19302050).
+
+## Contact
+
+Nicholas Maino (iamweare) · maiknown@gmail.com · https://github.com/bigDSanalyst
+Zenodo: https://doi.org/10.5281/zenodo.19302050

pq_verify-2.6.5/QUICKSTART.md

@@ -0,0 +1,85 @@
+# pq-verify v2.6.0 — Quickstart
+
+## 1. Run the self-test (confirms the tool works on your machine)
+
+Google Colab, or any Linux with `gcc` + Python 3.8+:
+
+```bash
+apt-get install -y coq && pip install kyber-py dilithium-py sympy   # for full 160/160 + 885/885
+```
+
+```python
+exec(open('pq_verify_v2_6_1.py').read())
+```
+
+Expected: a 7-phase report ending in `OVERALL: 160/160 tests passed`.
+Without coq/kyber-py/sympy you'll see fewer (those tests report as failures, not skips).
+
+After loading, eight public functions are available: `main`, `pqverify_acvp`,
+`pqverify_params`, `pqverify_kem`, `pqverify_kat`, `pqverify_load_so`,
+`pqverify_scan`, and `pqverify_leakage`.
+
+## 2. Verify your own implementation
+
+### Option A — you have a compiled .so
+
+Edit the CONFIG block in `vendor_audit_template.py`:
+
+```python
+SO_PATH    = "/path/to/your_library.so"
+NTT_SYMBOL = "ntt"                # see "find your symbol" below
+ALGORITHM  = "ML-KEM-1024"        # or ML-KEM-512/768, ML-DSA-44/65/87
+```
+
+Then:
+
+```python
+exec(open('pq_verify_v2_6_1.py').read())          # load the engine
+exec(open('vendor_audit_template.py').read())      # runs the audit
+```
+
+Output: console report + `pqverify_vendor_report.json` (machine-readable,
+with a reproducible SHA-256 fingerprint).
+
+### Find your symbol (if you don't know it)
+
+```python
+discover_symbols("/path/to/your_library.so")
+```
+
+Lists exported NTT symbols. Note: many libraries inline the NTT as a
+`static` function, so it won't be exported — in that case a small dedicated
+`.so` exposing `void ntt(int16_t[256])` is the cleanest path.
+
+### Option B — you have a Python implementation
+
+```python
+exec(open('pq_verify_v2_6_1.py').read())
+# your_ntt(list[int]) -> list[int] defined in this session
+pqverify_scan(globals())     # auto-discovers and audits it
+```
+
+## 3. Individual checks
+
+```python
+pqverify_kem(k=4)                      # native full-KEM, ML-KEM-1024 / Level 5
+pqverify_kat(your_ntt, k=4)            # non-circular KAT vs FIPS definition
+pqverify_leakage()                     # per-layer protection-allocation table
+```
+
+`k` selects the security level: 2 → Level 1, 3 → Level 3, 4 → Level 5
+(Dilithium: 4/6/8 with `family='dilithium', q=8380417, zeta=1753`).
+
+## 4. Reproducibility
+
+The report is deterministic: same input → identical output → identical
+SHA-256 fingerprint. Re-run any audit and compare fingerprints to confirm
+the result wasn't tampered with.
+
+## Notes
+
+- Free Colab sessions are per-tab and reset after ~90 min idle. Keep the
+  `.py` files in Google Drive and `exec()` them from there to avoid re-uploading.
+- Engines compile at runtime via gcc/g++ — first run takes a few seconds.
+- Never install torchtext in the same Colab environment (unrelated, but it
+  corrupts the runtime).

pq_verify-2.6.5/README.md

@@ -0,0 +1,199 @@
+# pq-verify v2.6.4 — PQC Implementation Verification
+
+![version](https://img.shields.io/badge/version-2.6.4-blue)
+![license](https://img.shields.io/badge/license-MIT-green)
+![tests](https://img.shields.io/badge/tests-160%2F160-brightgreen)
+![ACVP-KEM](https://img.shields.io/badge/ML--KEM%20ACVP-240%2F240-brightgreen)
+![ACVP-DSA](https://img.shields.io/badge/ML--DSA%20ACVP-615%2F615-brightgreen)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.21739511.svg)](https://doi.org/10.5281/zenodo.21739511)
+
+**Independent verification for ML-KEM (Kyber) and ML-DSA (Dilithium) implementations.**
+
+You deploy post-quantum cryptography. pq-verify proves your implementation computes the FIPS 203/204 standard correctly — in the native finite field, against NIST's own test vectors, with machine-checkable certificates. Plus FIPS 205 SLH-DSA parameter validation across all 12 parameter sets.
+
+It does not compute PQC. It verifies the implementations that do: liboqs, BoringSSL, OpenSSL+OQS, HSM firmware, or your own code.
+
+---
+
+## What you get
+
+A three-layer audit of any ML-KEM/ML-DSA implementation:
+
+| Layer | Question answered | How |
+|-------|-------------------|-----|
+| **Correctness** | Does the NTT compute the FIPS definition? | Field-native verification + non-circular KAT |
+| **Compliance** | Does it match NIST's published vectors? | ML-KEM 240/240 + ML-DSA 615/615 = 855/855 ACVP vectors (pinned) |
+| **Security** | Are the parameters hard enough? | Bai-Galbraith primal-uSVP + hybrid attack estimator |
+
+Plus per-layer side-channel leakage analysis with protection-allocation recommendations.
+
+Every result is **reproducible** — deterministic output, SHA-256 fingerprint, re-runnable by your own auditors.
+
+---
+
+## Proven (all tested on commodity hardware, Google Colab CPU)
+
+- **160/160** self-test across 6 field-native engines, 6 phases
+- **240/240** NIST ACVP ML-KEM vectors — keyGen + encaps + decaps byte-exact, KeyCheck bool-exact
+- **Native full-KEM** verified at ML-KEM-1024 (Level 5): recovery 20/20, negative control caught
+- **Non-circular KAT** 100/100 against the independent FIPS reference
+- Calibrated lattice estimator: reproduces lattice-estimator exactly (Kyber-512 β=406/118.6 bits)
+- **Coq certificates** verified by `coqc` with real exit codes
+
+---
+
+## Quick start
+
+Open `DEMO.ipynb` in Google Colab and run all cells. ~3 minutes to 855/855.
+
+Or, in any Python 3.8+ environment with gcc:
+
+```python
+exec(open('pq_verify_v2_6_1.py').read())   # 160-test self-suite + loads the API
+
+pqverify_acvp()                    # full NIST ACVP, all parameter sets
+pqverify_params('ML-KEM-1024')     # parameter security check
+pqverify_kem(k=4)                  # native full-KEM at Level 5
+```
+
+To audit your own compiled library:
+
+```python
+ntt = pqverify_load_so('/path/to/your_library.so', 'ntt_symbol')
+pqverify_scan(ntt)                 # full audit + KAT + leakage
+```
+
+See `vendor_audit_template.py` for the complete "give us your .so → get a JSON report" workflow.
+
+---
+
+## Public API
+
+| Function | Purpose |
+|----------|---------|
+| `main()` | 160-test self-suite |
+| `pqverify_acvp()` | Full NIST ACVP end-to-end ML-KEM (240/240, all groups) |
+| `pqverify_mldsa_acvp()` | Full NIST ACVP end-to-end ML-DSA (615/615, FIPS 204) |
+| `pqverify_slhdsa_acvp()` | NIST ACVP SLH-DSA keyGen (120/120, FIPS 205, all 12 parameter sets) |
+| `pqverify_acvp_all()` | ML-KEM + ML-DSA (855/855) offline; `slhdsa=True` adds FIPS 205 → 975/975 |
+| `pqverify_params(set)` | Parameter security: primal-uSVP + sparse hybrid |
+| `pqverify_kem(k=4)` | Native algebraic full-KEM verification |
+| `pqverify_kat(ntt, k=4)` | Non-circular KAT vs FIPS definition |
+| `pqverify_load_so(path, sym)` | Load NTT from a compiled .so |
+| `pqverify_scan(target)` | Auto-discover + audit NTT functions |
+| `pqverify_leakage()` | Per-layer protection-allocation table |
+
+---
+
+## Deterministic by default
+
+pq-verify ships with a **frozen, versioned snapshot of NIST's ACVP vectors** bundled
+inside the package (gzipped, ~7 MB). By default it verifies against those — so:
+
+- **the same input gives the same result, every run, forever**
+- **it works with no network** — air-gapped, offline, no GitHub reachability needed
+- **NIST editing their published files cannot change or break your result**
+
+That last point is not hypothetical: NIST periodically regenerates these vectors and
+has changed the ML-KEM `encapDecap` schema (the `keyFormat` seed/expanded split) more
+than once. A tool that fetches live gives different answers on different days. This one
+does not.
+
+```python
+pqverify_acvp_all()              # pinned bundle, offline, deterministic  → 855/855
+pqverify_acvp_all(live=True)     # opt in: fetch NIST's current vectors instead
+pqverify_acvp_all(vector_dir=d)  # or point at your own local vector set
+```
+
+Vector provenance and per-file sha256 are recorded in `pq_verify/vectors/MANIFEST.json`.
+A scheduled GitHub Action watches upstream and opens an issue when NIST changes
+something, so re-pinning is a deliberate, reviewed act rather than a live dependency.
+
+## Scope
+
+pq-verify verifies the **algebraic substance** of ML-KEM/ML-DSA (NTT, module-LWE relations, parameter security) natively in Z₃₃₂₉ / Z₈₃₈₀₄₁₇. The **non-algebraic layers** (SHAKE/SHA3 hashing, sampling, compression, the FO transform) are bit/byte operations verified by NIST ACVP end-to-end testing, not native field solving.
+
+The algebraic core is proven natively where the proof is exact; the full implementation is proven byte-exact against NIST's own bytes. We make the claims we can prove.
+
+---
+
+## What's in this package
+
+```
+pq_verify/
+  __init__.py              Public API (11 functions)
+  core.py                  The stack (~6,100 lines, 6 field-native engines)
+  cli.py                   Command-line interface
+tests/test_pqverify.py     18-test pytest suite
+pyproject.toml             Build config + console-script entry point
+dist/
+  pq_verify-2.6.4-py3-none-any.whl    Installable wheel
+  pq_verify-2.6.4.tar.gz              Source distribution
+DEMO.ipynb                 One-click Colab demo → 855/855
+vendor_audit_template.py   Drop-in .so audit → JSON report
+sample_report.json         Example output (what your auditors receive)
+README.md / QUICKSTART.md / LICENSE / CITATION.cff
+```
+
+Install: `pip install dist/pq_verify-2.6.4-py3-none-any.whl`
+
+---
+
+## Requirements
+
+**Minimum (core engines + ~149 self-tests):**
+- Python 3.8+
+- gcc and g++ (the C/C++ engines compile at runtime)
+
+**For the full 160/160 self-suite and the 855/855 ACVP claim:**
+- `kyber-py` — **required** for `pqverify_acvp()` (the byte-exact NIST reference) and the FIPS 203 roundtrip tests
+- `dilithium-py` — **required** for `pqverify_mldsa_acvp()` (the 615 ML-DSA vectors)
+- `coq` — required for the Coq certificate verification tests
+- `sympy` — required for the Engine-6 Conjecture 7 exact-rational test (without it: 159/160)
+
+```bash
+apt-get install -y coq gcc g++
+pip install kyber-py dilithium-py sympy --break-system-packages
+```
+
+**Optional (1 test each, everything works without them):**
+- `cryptominisat` — the CMS5 speed-comparison benchmark
+- `slh-dsa` — SLH-DSA live roundtrip (parameters still validate without it)
+- network access — `pqverify_acvp()` fetches NIST vectors from GitHub live; for air-gapped use, pass `prompt_dir=` pointing at local vector files
+
+**Deliberately NOT required** (a deployment advantage):
+- No numpy, scipy, or PyTorch — pure Python + ctypes + inline C
+- No SageMath — the `pqverify_params` lattice estimator is self-contained (it reproduces the lattice-estimator's results without it)
+
+---
+
+## License
+
+MIT. The verifier is open-source — builds trust, enables adoption. Commercial support, custom engine development, and PQC audit engagements available separately.
+
+## Citing this software
+
+Archived on Zenodo with a citable DOI:
+
+> Maino, N. C. (2026). *pq-verify: Independent verification for ML-KEM / ML-DSA
+> implementations* (v2.6.4). Zenodo. https://doi.org/10.5281/zenodo.21739511
+
+```bibtex
+@software{maino_pqverify_2026,
+  author    = {Maino, Nicholas Clifford},
+  title     = {pq-verify: Independent verification for ML-KEM / ML-DSA implementations},
+  version   = {2.6.4},
+  year      = {2026},
+  publisher = {Zenodo},
+  doi       = {10.5281/zenodo.21739511},
+  url       = {https://doi.org/10.5281/zenodo.21739511}
+}
+```
+
+The DOI above resolves to this specific release. The companion paper is
+[10.5281/zenodo.19302050](https://doi.org/10.5281/zenodo.19302050).
+
+## Contact
+
+Nicholas Maino (iamweare) · maiknown@gmail.com · https://github.com/bigDSanalyst
+Zenodo: https://doi.org/10.5281/zenodo.19302050

pq_verify-2.6.5/pq_verify/__init__.py

@@ -0,0 +1,54 @@
+"""
+pq-verify — Independent verification for ML-KEM / ML-DSA implementations.
+
+Verifies that post-quantum cryptography implementations compute the
+FIPS 203/204 standard correctly: native field-native NTT verification,
+non-circular Known Answer Tests, NIST ACVP end-to-end (270/270), a
+Bai-Galbraith lattice parameter-security estimator, and per-layer
+side-channel leakage analysis. Coq-certified, reproducible.
+
+Author: Nicholas Maino (iamweare) — Melbourne AU
+License: MIT
+"""
+
+__version__ = "2.6.5"
+__author__ = "Nicholas Maino (iamweare)"
+__license__ = "MIT"
+
+# Re-export the public API from the core engine (the real 5451-line stack).
+from .core import (
+    main,
+    pqverify_kat,
+    pqverify_kem,
+    pqverify_acvp,
+    pqverify_mldsa_acvp,
+    pqverify_slhdsa_acvp,
+    pqverify_acvp_all,
+    pqverify_params,
+    pqverify_leakage,
+    pqverify_load_so,
+    pqverify_scan,
+)
+
+# FIPS 203 input-validation oracles (used by ACVP KeyCheck groups)
+try:
+    from .core import check_encapsulation_key, check_decapsulation_key
+except ImportError:
+    pass
+
+__all__ = [
+    "__version__",
+    "main",
+    "pqverify_kat",
+    "pqverify_kem",
+    "pqverify_acvp",
+    "pqverify_mldsa_acvp",
+    "pqverify_slhdsa_acvp",
+    "pqverify_acvp_all",
+    "pqverify_params",
+    "pqverify_leakage",
+    "pqverify_load_so",
+    "pqverify_scan",
+    "check_encapsulation_key",
+    "check_decapsulation_key",
+]