loopgrid-verify 0.1.0__py3-none-any.whl

loopgrid_verify/__init__.py

@@ -0,0 +1,6 @@
+"""Standalone offline verification for LoopGrid evidence bundles."""
+
+from .verifier import verify_bundle
+from .version import __version__
+
+__all__ = ["verify_bundle", "__version__"]

loopgrid_verify/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+main()

loopgrid_verify/cli.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import argparse
+
+from .verifier import verify_bundle
+from .version import __version__
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="loopgrid-verify",
+        description="Offline verifier for LoopGrid evidence bundles",
+    )
+    parser.add_argument(
+        "bundle",
+        help="Path to a LoopGrid evidence ZIP bundle",
+    )
+    parser.add_argument(
+        "--tsa-ca-file",
+        default=None,
+        help="Trusted CA bundle for RFC3161 signer validation via OpenSSL",
+    )
+    parser.add_argument(
+        "--expected-key-id",
+        default=None,
+        help="Pin the expected LoopGrid signer key id, e.g. ed25519:abc123...",
+    )
+    parser.add_argument(
+        "--trusted-public-key",
+        default=None,
+        help="Pin signer identity to an out-of-band trusted PEM public key",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+    return parser
+
+
+def _has_failure(result: dict, reason: str) -> bool:
+    return any(
+        isinstance(item, dict) and item.get("reason") == reason
+        for item in (result.get("failures") or [])
+    )
+
+
+def main() -> None:
+    args = build_parser().parse_args()
+
+    result = verify_bundle(
+        args.bundle,
+        args.tsa_ca_file,
+        args.expected_key_id,
+        args.trusted_public_key,
+    )
+
+    # Keep CLI output intentionally concise and avoid printing the full
+    # verification object. Detailed structured results remain available
+    # through the Python verify_bundle() API.
+    print("LOOPGRID EVIDENCE VERIFICATION")
+
+    bundle_integrity = result.get("bundle_integrity") or {}
+
+    if result["valid"] and bundle_integrity.get("attested"):
+        print("[OK] VERIFIED")
+        print("[DETAIL] Bundle integrity: attested")
+
+    elif result["valid"]:
+        print("[OK] LEDGER VERIFIED")
+        print(
+            "[WARN] Legacy/unattested bundle: exported file bytes are not "
+            "covered by a signed bundle attestation."
+        )
+
+    else:
+        print("[FAIL] INVALID")
+
+        if _has_failure(result, "bundle_file_digest_mismatch"):
+            print("[DETAIL] Bundle file digest mismatch.")
+        elif _has_failure(result, "trusted_public_key_mismatch"):
+            print("[DETAIL] Trusted public key mismatch.")
+        elif _has_failure(result, "expected_key_id_mismatch"):
+            print("[DETAIL] Expected signer key ID mismatch.")
+        elif _has_failure(result, "bundle_attestation_signature_invalid"):
+            print("[DETAIL] Bundle attestation signature is invalid.")
+        elif _has_failure(result, "bundle_attestation_digest_mismatch"):
+            print("[DETAIL] Bundle attestation digest mismatch.")
+        else:
+            print("[DETAIL] Verification checks failed.")
+
+    raise SystemExit(0 if result["valid"] else 2)
+
+
+if __name__ == "__main__":
+    main()

loopgrid_verify/verifier.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+import argparse,base64,hashlib,json,subprocess,tempfile,zipfile
+from pathlib import Path
+from cryptography.hazmat.primitives import hashes,serialization
+from cryptography.hazmat.primitives.asymmetric import ec,utils
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+
+
+def canonical_json(obj)->bytes:
+    return json.dumps(obj,sort_keys=True,separators=(",",":"),ensure_ascii=False,allow_nan=False).encode("utf-8")
+
+def sha256_hex(data:bytes)->str:return hashlib.sha256(data).hexdigest()
+
+def _lines(z,name):
+    try:return [json.loads(x) for x in z.read(name).decode().splitlines() if x.strip()]
+    except KeyError:return []
+
+def _json_file(z,name,default=None):
+    try:return json.loads(z.read(name))
+    except KeyError:return default
+
+def _policy_digest(policy,workspace_id=None):
+    if not isinstance(policy,dict):return None
+    required={
+        "workspace_id":policy.get("workspace_id") or workspace_id,
+        "policy_id":policy.get("policy_id"),
+        "version":policy.get("version"),
+        "rule":policy.get("rule"),
+    }
+    return sha256_hex(canonical_json(required))
+
+
+def _public_key_id(public)->str:
+    if isinstance(public,Ed25519PublicKey):
+        raw=public.public_bytes(serialization.Encoding.Raw,serialization.PublicFormat.Raw)
+        return "ed25519:"+sha256_hex(raw)[:16]
+    if isinstance(public,ec.EllipticCurvePublicKey):
+        pem=public.public_bytes(serialization.Encoding.PEM,serialization.PublicFormat.SubjectPublicKeyInfo)
+        return "aws-kms:"+sha256_hex(pem)[:16]
+    return "unknown:"+sha256_hex(public.public_bytes(serialization.Encoding.DER,serialization.PublicFormat.SubjectPublicKeyInfo))[:16]
+
+
+def _verify_sig(public,algorithm,hex_hash,signature_b64):
+    try:
+        sig=base64.b64decode(signature_b64);digest=bytes.fromhex(hex_hash)
+        if algorithm=="Ed25519":
+            if not isinstance(public,Ed25519PublicKey):return False
+            public.verify(sig,digest);return True
+        if algorithm=="ECDSA_SHA_256":
+            if not isinstance(public,ec.EllipticCurvePublicKey):return False
+            public.verify(sig,digest,ec.ECDSA(utils.Prehashed(hashes.SHA256())));return True
+        return False
+    except Exception:return False
+
+
+def _verify_rfc3161_imprint(raw: bytes, expected_digest: str) -> dict:
+    """Validate RFC3161 status, SHA-256 algorithm and message imprint without OpenSSL."""
+    try:
+        from asn1crypto import tsp
+
+        resp = tsp.TimeStampResp.load(raw)
+        status = resp["status"]["status"].native
+        if status not in {"granted", "granted_with_mods"}:
+            return {"valid": False, "status": status, "reason": "timestamp_status_not_granted"}
+        token = resp["time_stamp_token"]
+        content = token["content"]["encap_content_info"]["content"]
+        info = content.parsed
+        imprint = info["message_imprint"]["hashed_message"].native.hex()
+        algorithm = info["message_imprint"]["hash_algorithm"]["algorithm"].native
+        valid = algorithm == "sha256" and imprint.lower() == expected_digest.lower()
+        return {
+            "valid": valid,
+            "status": status,
+            "algorithm": algorithm,
+            "imprint": imprint,
+            "gen_time": str(info["gen_time"].native),
+        }
+    except Exception as exc:
+        return {"valid": False, "reason": "timestamp_parse_error", "detail": type(exc).__name__}
+
+
+def _signed_body(e):
+    return {k:e.get(k) for k in ["event_id","decision_id","workspace_id","event_type","occurred_at","actor","privacy_mode","payload_commitment","payload"]}
+
+
+def _verify_bundle_file_attestation(z,manifest,public,computed_key_id):
+    failures=[];warnings=[]
+    bundle_schema=manifest.get('bundle_schema')
+    result={
+        "status":"legacy_unattested",
+        "attested":False,
+        "attestation_schema":None,
+        "hash_algorithm":None,
+        "files_checked":0,
+        "signature_valid":None,
+        "attestation_digest_valid":None,
+    }
+    integrity_declared=manifest.get('bundle_integrity') or {}
+    attestation_expected=(
+        integrity_declared.get('mode')=='signed_file_attestation'
+        or 'bundle-attestation.json' in z.namelist()
+    )
+    if not attestation_expected:
+        warnings.append({
+            "reason":"bundle_file_attestation_unavailable",
+            "detail":"Legacy/unattested bundle: signed ledger verification is available, but exported file bytes are not covered by a bundle-level file attestation.",
+        })
+        return result,failures,warnings
+
+    try:
+        attestation=json.loads(z.read('bundle-attestation.json'))
+    except KeyError:
+        failures.append({"reason":"bundle_attestation_missing"})
+        result["status"]="invalid"
+        return result,failures,warnings
+    except Exception as exc:
+        failures.append({"reason":"bundle_attestation_unreadable","detail":type(exc).__name__})
+        result["status"]="invalid"
+        return result,failures,warnings
+
+    result["attestation_schema"]=attestation.get('attestation_schema')
+    result["hash_algorithm"]=attestation.get('hash_algorithm')
+    if attestation.get('attestation_schema')!='loopgrid/bundle-attestation/1':
+        failures.append({"reason":"bundle_attestation_schema_invalid","attestation_schema":attestation.get('attestation_schema')})
+    if attestation.get('bundle_schema')!=bundle_schema:
+        failures.append({"reason":"bundle_attestation_bundle_schema_mismatch"})
+    if attestation.get('decision_id')!=manifest.get('decision_id'):
+        failures.append({"reason":"bundle_attestation_decision_mismatch"})
+    if attestation.get('workspace_id')!=manifest.get('workspace_id'):
+        failures.append({"reason":"bundle_attestation_workspace_mismatch"})
+    if attestation.get('hash_algorithm')!='SHA-256':
+        failures.append({"reason":"bundle_attestation_hash_algorithm_invalid","algorithm":attestation.get('hash_algorithm')})
+
+    declared_signer=attestation.get('signer') or {}
+    if declared_signer.get('key_id')!=computed_key_id:
+        failures.append({
+            "reason":"bundle_attestation_key_id_mismatch",
+            "attestation_key_id":declared_signer.get('key_id'),
+            "computed_key_id":computed_key_id,
+        })
+    manifest_key_id=(manifest.get('signer') or {}).get('key_id') or (manifest.get('integrity') or {}).get('key_id')
+    if manifest_key_id and declared_signer.get('key_id')!=manifest_key_id:
+        failures.append({"reason":"bundle_attestation_manifest_key_id_mismatch"})
+
+    body={k:attestation.get(k) for k in [
+        'attestation_schema','bundle_schema','decision_id','workspace_id','hash_algorithm','files','signer'
+    ]}
+    computed_attestation_digest=sha256_hex(canonical_json(body))
+    declared_digest=attestation.get('attestation_digest')
+    result["attestation_digest_valid"]=declared_digest==computed_attestation_digest
+    if not result["attestation_digest_valid"]:
+        failures.append({
+            "reason":"bundle_attestation_digest_mismatch",
+            "computed":computed_attestation_digest,
+            "declared":declared_digest,
+        })
+
+    algorithm=declared_signer.get('algorithm') or (manifest.get('signer') or {}).get('algorithm') or 'Ed25519'
+    result["signature_valid"]=_verify_sig(public,algorithm,computed_attestation_digest,attestation.get('signature',''))
+    if not result["signature_valid"]:
+        failures.append({"reason":"bundle_attestation_signature_invalid","algorithm":algorithm})
+
+    files=attestation.get('files')
+    if not isinstance(files,dict) or not files:
+        failures.append({"reason":"bundle_attestation_files_missing"})
+        files={}
+    if 'manifest.json' not in files:
+        failures.append({"reason":"bundle_attestation_manifest_digest_missing"})
+    if 'bundle-attestation.json' in files:
+        failures.append({"reason":"bundle_attestation_self_reference"})
+
+    archive_names=[n for n in z.namelist() if not n.endswith('/')]
+    if len(archive_names)!=len(set(archive_names)):
+        failures.append({"reason":"duplicate_archive_entry"})
+    archive_set=set(archive_names)
+    expected_set=set(files)|{'bundle-attestation.json'}
+    for missing in sorted(expected_set-archive_set):
+        failures.append({"reason":"attested_file_missing","file":missing})
+    for extra in sorted(archive_set-expected_set):
+        failures.append({"reason":"unattested_archive_file","file":extra})
+
+    for name,declared_hash in sorted(files.items()):
+        if not isinstance(name,str) or not isinstance(declared_hash,str):
+            failures.append({"reason":"bundle_attestation_file_entry_invalid","file":str(name)})
+            continue
+        try:
+            raw=z.read(name)
+        except KeyError:
+            continue
+        actual=sha256_hex(raw)
+        result["files_checked"]+=1
+        if actual!=declared_hash:
+            failures.append({
+                "reason":"bundle_file_digest_mismatch",
+                "file":name,
+                "computed":actual,
+                "declared":declared_hash,
+            })
+
+    manifest_files=manifest.get('files') or {}
+    for role,name in manifest_files.items():
+        if not name:
+            continue
+        if name=='bundle-attestation.json':
+            continue
+        if name not in files:
+            failures.append({"reason":"manifest_file_not_attested","role":role,"file":name})
+
+    result["attested"]=not failures
+    result["status"]='attested' if result["attested"] else 'invalid'
+    return result,failures,warnings
+
+
+def verify_bundle(path:str,tsa_ca_file:str|None=None,expected_key_id:str|None=None,trusted_public_key:str|None=None)->dict:
+    failures=[];warnings=[]
+    with zipfile.ZipFile(path) as z:
+        manifest=json.loads(z.read('manifest.json'))
+        bundled_pem=z.read('public-key.pem');public=serialization.load_pem_public_key(bundled_pem)
+        computed_key_id=_public_key_id(public);manifest_key_id=(manifest.get('signer') or {}).get('key_id') or (manifest.get('integrity') or {}).get('key_id')
+        bundle_schema=manifest.get('bundle_schema')
+        if bundle_schema and bundle_schema!='loopgrid/evidence-bundle/2':
+            warnings.append({"reason":"unknown_bundle_schema","bundle_schema":bundle_schema})
+        bundle_integrity,bundle_failures,bundle_warnings=_verify_bundle_file_attestation(z,manifest,public,computed_key_id)
+        failures.extend(bundle_failures);warnings.extend(bundle_warnings)
+
+        # For attested bundles, authenticate the exact exported bytes before parsing
+        # auxiliary JSON/JSONL documents. This prevents malformed tampered files from
+        # turning a clean verification failure into a parser exception.
+        if (manifest.get('bundle_integrity') or {}).get('mode')=='signed_file_attestation' and bundle_failures:
+            return {
+                "valid":False,"events":0,"witnesses":0,"disclosures":0,
+                "failures":failures,"warnings":warnings,
+                "decision_id":manifest.get('decision_id'),"workspace_id":manifest.get('workspace_id'),
+                "software_version":manifest.get('software_version'),"evidence_profile":manifest.get('version'),
+                "bundle_schema":bundle_schema,
+                "signature_algorithm":manifest.get('signer',{}).get('algorithm') or manifest.get('integrity',{}).get('signature_algorithm'),
+                "key_identity":{
+                    "computed_key_id":computed_key_id,
+                    "manifest_key_id":manifest_key_id,
+                    "manifest_match":not manifest_key_id or computed_key_id==manifest_key_id,
+                    "expected_key_id":expected_key_id,
+                    "expected_key_match":None if expected_key_id is None else computed_key_id==expected_key_id,
+                    "trusted_public_key_supplied":bool(trusted_public_key),
+                    "trusted_public_key_match":None,
+                    "trust_note":"An embedded public key proves bundle integrity under that key. Pin --expected-key-id or --trusted-public-key when signer identity/authenticity must be established out of band."
+                },
+                "bundle_integrity":bundle_integrity,"checkpoint":{"present":False,"signature_valid":None,"linked_to_bundle_chain":None},
+                "timestamp":{"present":'timestamp.tsr' in z.namelist(),"imprint_valid":None,"trust_validated":None},
+                "lifecycle":manifest.get('lifecycle'),"policy_digest":(manifest.get('policy') or {}).get('policy_digest')
+            }
+
+        events=_lines(z,'events.jsonl');witnesses=_lines(z,'chain-witness.jsonl');disclosures=_lines(z,'disclosures.jsonl')
+        signer_doc=_json_file(z,'signer.json')
+        verification_doc=_json_file(z,'verification.json')
+        lifecycle_doc=_json_file(z,'lifecycle.json')
+        policy_doc=_json_file(z,'policy/policy.json')
+        if signer_doc and signer_doc.get('key_id') and signer_doc.get('key_id')!=computed_key_id:
+            failures.append({"reason":"signer_document_key_id_mismatch","signer_key_id":signer_doc.get('key_id'),"computed_key_id":computed_key_id})
+        if lifecycle_doc is not None and manifest.get('lifecycle') is not None and lifecycle_doc!=manifest.get('lifecycle'):
+            failures.append({"reason":"lifecycle_document_mismatch"})
+        if verification_doc and verification_doc.get('decision_id') not in {None,manifest.get('decision_id')}:
+            failures.append({"reason":"verification_document_decision_mismatch"})
+        if policy_doc:
+            digest=_policy_digest(policy_doc,manifest.get('workspace_id'))
+            declared=policy_doc.get('policy_digest')
+            manifest_digest=(manifest.get('policy') or {}).get('policy_digest')
+            if declared and digest!=declared:
+                failures.append({"reason":"policy_digest_mismatch","computed":digest,"declared":declared})
+            if manifest_digest and digest!=manifest_digest:
+                failures.append({"reason":"manifest_policy_digest_mismatch","computed":digest,"manifest":manifest_digest})
+        if manifest_key_id and computed_key_id!=manifest_key_id:
+            failures.append({"reason":"manifest_public_key_id_mismatch","manifest_key_id":manifest_key_id,"computed_key_id":computed_key_id})
+        if expected_key_id and computed_key_id!=expected_key_id:
+            failures.append({"reason":"expected_key_id_mismatch","expected_key_id":expected_key_id,"computed_key_id":computed_key_id})
+        trusted_key_match=None
+        if trusted_public_key:
+            try:
+                trusted=serialization.load_pem_public_key(Path(trusted_public_key).read_bytes())
+                trusted_der=trusted.public_bytes(serialization.Encoding.DER,serialization.PublicFormat.SubjectPublicKeyInfo)
+                bundle_der=public.public_bytes(serialization.Encoding.DER,serialization.PublicFormat.SubjectPublicKeyInfo)
+                trusted_key_match=trusted_der==bundle_der
+                if not trusted_key_match:failures.append({"reason":"trusted_public_key_mismatch"})
+            except Exception as e:
+                failures.append({"reason":"trusted_public_key_unreadable","detail":type(e).__name__})
+
+        # Verify target events and opaque continuity witnesses in workspace-ledger order.
+        nodes=[]
+        for e in events:nodes.append({"seq":e['seq'],"event":e,"proof":e['proof'],"opaque":False})
+        for w in witnesses:nodes.append({"seq":w['seq'],"event":None,"proof":w['proof'],"opaque":True})
+        nodes.sort(key=lambda n:n['seq'])
+        prev=None
+        for node in nodes:
+            proof=node['proof'];seq=node['seq'];alg=proof.get('signature_algorithm') or manifest.get('integrity',{}).get('signature_algorithm') or manifest.get('signer',{}).get('algorithm') or 'Ed25519'
+            proof_key_id=proof.get('key_id')
+            if proof_key_id and proof_key_id!=computed_key_id:
+                failures.append({"seq":seq,"reason":"proof_key_id_mismatch","proof_key_id":proof_key_id,"computed_key_id":computed_key_id})
+            if not node['opaque']:
+                e=node['event'];expected_content=sha256_hex(canonical_json(_signed_body(e)))
+                if expected_content!=proof.get('content_hash'):failures.append({"seq":seq,"reason":"content_hash_mismatch"})
+                try:expected_chain=sha256_hex(bytes.fromhex(proof.get('previous_chain_hash','0'*64))+bytes.fromhex(expected_content))
+                except Exception:
+                    expected_chain='';failures.append({"seq":seq,"reason":"malformed_chain_hash"})
+                if expected_chain!=proof.get('chain_hash'):failures.append({"seq":seq,"reason":"chain_hash_mismatch"})
+            if prev is not None and proof.get('previous_chain_hash')!=prev:failures.append({"seq":seq,"reason":"previous_chain_hash_mismatch"})
+            if not _verify_sig(public,alg,proof.get('chain_hash',''),proof.get('signature','')):failures.append({"seq":seq,"reason":"signature_invalid","algorithm":alg})
+            prev=proof.get('chain_hash')
+
+        # Verify optional full-payload disclosures against the commitments sealed in events.
+        by_id={e['event_id']:e for e in events}
+        for d in disclosures:
+            e=by_id.get(d.get('event_id'))
+            if not e:failures.append({"event_id":d.get('event_id'),"reason":"orphan_disclosure"});continue
+            digest=sha256_hex(canonical_json(d.get('payload')))
+            if digest!=e.get('payload_commitment') or digest!=d.get('payload_commitment'):failures.append({"event_id":d.get('event_id'),"reason":"disclosure_commitment_mismatch"})
+
+        # Checkpoint proof + RFC3161 timestamp. Imprint validation is portable; optional
+        # certificate-chain trust verification still uses OpenSSL when a CA bundle is supplied.
+        cp=manifest.get('checkpoint') or {}
+        checkpoint={"present":bool(cp),"signature_valid":None,"linked_to_bundle_chain":None}
+        if cp:
+            cp_digest=cp.get('chain_hash')
+            cp_sig=cp.get('signature')
+            cp_alg=cp.get('signature_algorithm') or manifest.get('signer',{}).get('algorithm')
+            cp_key=cp.get('key_id')
+            if cp_key and cp_key!=computed_key_id:
+                failures.append({"reason":"checkpoint_key_id_mismatch","checkpoint_key_id":cp_key,"computed_key_id":computed_key_id})
+            checkpoint['signature_valid']=bool(cp_digest and cp_sig and _verify_sig(public,cp_alg,cp_digest,cp_sig))
+            if not checkpoint['signature_valid']:
+                failures.append({"reason":"checkpoint_signature_invalid"})
+            cp_seq=cp.get('ledger_seq')
+            matched=next((n for n in nodes if n.get('seq')==cp_seq),None)
+            checkpoint['linked_to_bundle_chain']=bool(matched and matched.get('proof',{}).get('chain_hash')==cp_digest)
+            if not checkpoint['linked_to_bundle_chain']:
+                warnings.append({"reason":"checkpoint_not_linked_to_bundle_chain","detail":"Bundle remains event-verifiable, but this checkpoint is not bridged by included nodes."})
+
+        timestamp={"present":'timestamp.tsr' in z.namelist(),"imprint_valid":None,"trust_validated":None}
+        if timestamp['present']:
+            digest=cp.get('chain_hash') if cp else None
+            if not digest:
+                failures.append({"reason":"timestamp_checkpoint_missing"})
+            else:
+                imprint_result=_verify_rfc3161_imprint(z.read('timestamp.tsr'),digest)
+                timestamp['imprint_valid']=imprint_result.get('valid') is True
+                timestamp['status']=imprint_result.get('status')
+                timestamp['algorithm']=imprint_result.get('algorithm')
+                timestamp['gen_time']=imprint_result.get('gen_time')
+                if not timestamp['imprint_valid']:
+                    failures.append({"reason":"timestamp_imprint_invalid","detail":imprint_result.get('reason') or 'imprint mismatch'})
+
+        if timestamp['present'] and tsa_ca_file:
+            try:
+                digest=cp.get('chain_hash')
+                if not digest:raise ValueError('checkpoint chain hash missing')
+                with tempfile.NamedTemporaryFile(suffix='.tsr',delete=False) as f:f.write(z.read('timestamp.tsr'));ts_path=f.name
+                r=subprocess.run(['openssl','ts','-verify','-digest',digest,'-in',ts_path,'-CAfile',tsa_ca_file],capture_output=True,text=True,timeout=10)
+                timestamp['trust_validated']=r.returncode==0
+                if r.returncode!=0:failures.append({"reason":"timestamp_trust_invalid","detail":r.stderr[-300:]})
+            except Exception as e:warnings.append({"reason":"timestamp_trust_not_checked","detail":type(e).__name__})
+        elif timestamp['present']:
+            warnings.append({"reason":"timestamp_present_trust_not_checked","detail":"RFC3161 imprint is valid; pass --tsa-ca-file for signer certificate-chain trust validation."})
+
+        key_identity={
+            "computed_key_id":computed_key_id,
+            "manifest_key_id":manifest_key_id,
+            "manifest_match":not manifest_key_id or computed_key_id==manifest_key_id,
+            "expected_key_id":expected_key_id,
+            "expected_key_match":None if expected_key_id is None else computed_key_id==expected_key_id,
+            "trusted_public_key_supplied":bool(trusted_public_key),
+            "trusted_public_key_match":trusted_key_match,
+            "trust_note":"An embedded public key proves bundle integrity under that key. Pin --expected-key-id or --trusted-public-key when signer identity/authenticity must be established out of band."
+        }
+        return {"valid":not failures,"events":len(events),"witnesses":len(witnesses),"disclosures":len(disclosures),"failures":failures,"warnings":warnings,"decision_id":manifest.get('decision_id'),"workspace_id":manifest.get('workspace_id'),"software_version":manifest.get('software_version'),"evidence_profile":manifest.get('version'),"bundle_schema":manifest.get('bundle_schema') or 'legacy','signature_algorithm':manifest.get('signer',{}).get('algorithm') or manifest.get('integrity',{}).get('signature_algorithm'),"key_identity":key_identity,"bundle_integrity":bundle_integrity,"checkpoint":checkpoint,"timestamp":timestamp,"lifecycle":manifest.get('lifecycle'),"policy_digest":(manifest.get('policy') or {}).get('policy_digest')}

loopgrid_verify/version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

loopgrid_verify-0.1.0.dist-info/METADATA

@@ -0,0 +1,240 @@
+Metadata-Version: 2.4
+Name: loopgrid-verify
+Version: 0.1.0
+Summary: Standalone offline verifier for LoopGrid evidence bundles
+Author: LoopGrid
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://loopgrid.io
+Project-URL: Repository, https://github.com/loopgridio/loopgrid-verify
+Project-URL: Issues, https://github.com/loopgridio/loopgrid-verify/issues
+Project-URL: Documentation, https://github.com/loopgridio/loopgrid-verify#readme
+Keywords: ai-agents,evidence,verification,audit,cryptography,ed25519,tamper-evident
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cryptography<47,>=42
+Requires-Dist: asn1crypto<2,>=1.5
+Provides-Extra: dev
+Requires-Dist: build<2,>=1.2; extra == "dev"
+Requires-Dist: pytest<10,>=8; extra == "dev"
+Requires-Dist: twine<8,>=5; extra == "dev"
+Dynamic: license-file
+
+# LoopGrid Verify
+
+**Standalone offline verification for LoopGrid evidence bundles.**
+
+`loopgrid-verify` verifies exported LoopGrid evidence without connecting to a LoopGrid server. It is designed for design partners, reviewers, auditors, operators, and engineering teams that want to inspect a portable evidence bundle independently of the running LoopGrid service.
+
+Current package: **0.1.0 design preview**
+
+## Install
+
+```bash
+pip install loopgrid-verify
+```
+
+Python 3.10–3.13 is supported.
+
+## Verify a bundle
+
+```bash
+loopgrid-verify evidence.zip
+```
+
+For higher-assurance verification, pin signer identity using an out-of-band trusted public key:
+
+```bash
+loopgrid-verify evidence.zip \
+  --trusted-public-key trusted-public-key.pem
+```
+
+Or pin the expected LoopGrid signer key ID:
+
+```bash
+loopgrid-verify evidence.zip \
+  --expected-key-id ed25519:0123456789abcdef
+```
+
+For an RFC3161 timestamp token, the verifier validates the timestamp status, SHA-256 message imprint, and imprint match locally. To additionally validate the timestamp signer certificate chain, provide a trusted CA bundle and ensure `openssl` is available:
+
+```bash
+loopgrid-verify evidence.zip \
+  --tsa-ca-file tsa-ca.pem
+```
+
+## Verification result
+
+A valid attested bundle prints:
+
+```text
+LOOPGRID EVIDENCE VERIFICATION
+[OK] VERIFIED
+```
+
+A modified or otherwise invalid bundle prints:
+
+```text
+LOOPGRID EVIDENCE VERIFICATION
+[FAIL] INVALID
+```
+
+and exits with status code `2`.
+
+Legacy Evidence Bundle v2 exports created before signed file attestation remain ledger-verifiable. They are explicitly labeled:
+
+```text
+[OK] LEDGER VERIFIED
+[WARN] Legacy/unattested bundle: exported file bytes are not covered by a signed bundle attestation.
+```
+
+## What is verified
+
+For current attested Evidence Bundle v2 exports, the verifier checks:
+
+- the signed bundle-attestation digest;
+- the attestation signature;
+- SHA-256 digests for attested exported files;
+- missing, duplicate, and unexpected archive entries;
+- the embedded signer key identity;
+- optional out-of-band public-key or key-ID pinning;
+- signed event content hashes and signatures;
+- workspace hash-chain continuity across events and proof-only witnesses;
+- disclosed payload commitments when disclosures are included;
+- policy digest consistency;
+- lifecycle and verification-document consistency;
+- checkpoint signatures and linkage when present;
+- RFC3161 timestamp imprint validity when present;
+- optional RFC3161 signer certificate-chain trust when `--tsa-ca-file` is supplied.
+
+## Trust model
+
+The public key embedded in an evidence bundle proves that the bundle is internally consistent under that key. It does **not**, by itself, establish who controls that key.
+
+When signer authenticity matters, pin trust out of band using:
+
+```text
+--trusted-public-key
+```
+
+or:
+
+```text
+--expected-key-id
+```
+
+This distinction is intentional: bundle integrity and signer authenticity are separate questions.
+
+## Python API
+
+```python
+from loopgrid_verify import verify_bundle
+
+result = verify_bundle(
+    "evidence.zip",
+    trusted_public_key="trusted-public-key.pem",
+)
+
+if result["valid"]:
+    print("verified")
+else:
+    print(result["failures"])
+```
+
+The API is:
+
+```python
+verify_bundle(
+    path,
+    tsa_ca_file=None,
+    expected_key_id=None,
+    trusted_public_key=None,
+) -> dict
+```
+
+## What this verifier does not determine
+
+`loopgrid-verify` checks cryptographic and structural evidence properties. It does not determine whether an AI decision was correct, safe, fair, lawful, compliant, or otherwise appropriate. It is evidence-verification infrastructure, not a legal or regulatory compliance determination.
+
+## Server-independent by design
+
+Verification does not require:
+
+- a LoopGrid server;
+- a database;
+- Docker;
+- an API key;
+- an MCP server;
+- a network connection.
+
+The only optional external executable is `openssl`, and only when certificate-chain trust validation is requested for an RFC3161 timestamp using `--tsa-ca-file`.
+
+## Development
+
+```bash
+python -m venv .venv
+```
+
+Windows PowerShell:
+
+```powershell
+.\.venv\Scripts\Activate.ps1
+python -m pip install --upgrade pip
+pip install -e ".[dev]"
+python -m pytest -q
+python scripts/release_check.py
+```
+
+macOS/Linux:
+
+```bash
+source .venv/bin/activate
+python -m pip install --upgrade pip
+pip install -e ".[dev]"
+python -m pytest -q
+python scripts/release_check.py
+```
+
+Build:
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+## Fixture coverage
+
+The test suite includes:
+
+- a current signed-file-attested Evidence Bundle v2;
+- the same bundle with `report.html` modified;
+- a legacy/unattested Evidence Bundle v2;
+- the correct trusted public key;
+- a deliberately incorrect trusted public key.
+
+The tampered bundle must fail verification. The legacy bundle may pass signed-ledger verification only with the explicit `legacy_unattested` status/warning.
+
+## Release posture
+
+`0.1.0` is a design-preview verifier release. The package is intended for technical evaluation and design-partner workflows. It is not a legal-compliance certification tool.
+
+## Related projects
+
+- LoopGrid core: `https://github.com/cybertechsoft/loopgrid`
+- LoopGrid MCP: `https://github.com/loopgridio/loopgrid-mcp`
+- Website: `https://loopgrid.io`
+
+## License
+
+Apache-2.0. See `LICENSE`.

loopgrid_verify-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+loopgrid_verify/__init__.py,sha256=kv7J5doxEwuyiz0IQjeHGjMtHFRwvPnNbzA9Zu8e5-Q,183
+loopgrid_verify/__main__.py,sha256=bYt9eEaoRQWdejEHFD8REx9jxVEdZptECFsV7F49Ink,30
+loopgrid_verify/cli.py,sha256=8SW3Azssp6OmgBUglHvj_2ujjTudF4k2w5J_2UV484g,2964
+loopgrid_verify/verifier.py,sha256=aRC0jylD_UDFyR9nZdvkqnL8S0aLBhkcbsyTK2oJjX8,22344
+loopgrid_verify/version.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+loopgrid_verify-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+loopgrid_verify-0.1.0.dist-info/METADATA,sha256=NGnvrLMXGCn6NHet7ORjx-fkQ_Bptba0ZxCTqgb384Y,6697
+loopgrid_verify-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+loopgrid_verify-0.1.0.dist-info/entry_points.txt,sha256=iinW0TbtLmSGqZ_ei3iCJSEut6LCx3gmHg_yAta1FBw,61
+loopgrid_verify-0.1.0.dist-info/top_level.txt,sha256=6pqEgJp6LisGJ7sivjHz3HZ801w65Q9iRVp4PnGj2iY,16
+loopgrid_verify-0.1.0.dist-info/RECORD,,

loopgrid_verify-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

loopgrid_verify-0.1.0.dist-info/entry_points.txt

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

loopgrid_verify-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 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.

loopgrid_verify-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+loopgrid_verify