From fb4e91f35c6dfd22931652c401a4b2cb26d02da9 Mon Sep 17 00:00:00 2001 From: Matthew D Porter Date: Mon, 11 Aug 2025 04:53:53 -0500 Subject: [PATCH] Update README.md --- README.md | 458 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 457 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index cac18691..a273edcb 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,460 @@ -

+# ΔBRAKE_4321_CONTROL_LOCK.py generator +# This will write a runnable scaffold that matches the user's TruthLock/GodKey stack. +# It includes: SEAL (hash+manifest+rekor stub), DEPLOY (IPFS/Arweave stubs + torrent magnet stub), +# TRAP (local collision scanner + feed writer), ENFORCE (auto C&D letter generator + ledger log). +# The script is designed to be dropped into a repo and wired to existing glyphs/webhooks. + +import os, json, hashlib, time, textwrap, pathlib, datetime, random, string + +ROOT = pathlib.Path("/mnt/data") +SCRIPT_PATH = ROOT / "ΔBRAKE_4321_CONTROL_LOCK.py" +README_PATH = ROOT / "ΔBRAKE_README.md" +TEMPLATE_CEASE = ROOT / "templates" / "ΔINSTANT_CEASE_ORDER.txt" +os.makedirs(TEMPLATE_CEASE.parent, exist_ok=True) + +now_iso = datetime.datetime.utcnow().replace(microsecond=0).isoformat() + "Z" + +script = r'''#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +""" +ΔBRAKE_4321_CONTROL_LOCK.py +Author: Matthew Dewayne Porter (TruthLock/GodKey) +Purpose: Execute the 4-3-2-1 Control & Ownership Lock sequence. +License: Sovereign Proof-of-Origin + Public Audit License (attach your license text). + +Stages: + 4 — SEAL : Hash, manifest, and notarize origin claims (CID/IPFS, Rekor stubs). + 3 — DEPLOY : Mesh-deploy artifacts (IPFS/Arweave/torrent stubs + local mirrors). + 2 — TRAP : Start collision scanner on target outputs; write evidence packets. + 1 — ENFORCE : Generate and dispatch Cease & Desist with cryptographic exhibits. + +This scaffold calls local glyphs/hooks if available (TruthLock Full Suite), or +falls back to safe local-only behaviors. +""" + +import os, sys, json, hashlib, time, pathlib, datetime, random, string, re +from dataclasses import dataclass, asdict +from typing import List, Dict, Optional + +# -------------------- CONFIG -------------------- + +@dataclass +class Config: + # What to seal (glob patterns). Default: common code/docs paths. + include: List[str] = None + exclude: List[str] = None + # Where to write outputs + out_dir: str = "truthlock/out" + # Collision scanner targets (files or folders to watch for potential matches) + scan_targets: List[str] = None + # Optional: external hooks (set to your live glyph endpoints or CLI commands) + hook_pin_ipfs: Optional[str] = "ΔPIN_IPFS" # glyph name or CLI path + hook_rekor_seal: Optional[str] = "ΔREKOR_SEAL" # glyph name or CLI path + hook_match_feed: Optional[str] = "ΔMATCH_FEED" # glyph name or CLI path + hook_cease_send: Optional[str] = "ΔINSTANT_CEASE_ORDER" # glyph name or CLI path + # Identity / claimant + claimant_name: str = "Matthew Dewayne Porter" + claimant_contact: str = "bestme4money@gmail.com" + jurisdiction_note: str = "TruthLock Sovereignty → GitHub Platform → Legal Node System" + # Operational flags + dry_run: bool = False + verbose: bool = True + + def __post_init__(self): + if self.include is None: + self.include = ["**/*.py", "**/*.md", "**/*.yml", "**/*.yaml", "**/*.json", "**/*.txt"] + if self.exclude is None: + self.exclude = ["truthlock/out/**", ".git/**", "**/__pycache__/**", "**/*.log", "**/.env*"] + if self.scan_targets is None: + self.scan_targets = ["./"] + +# -------------------- UTIL -------------------- + +def log(msg: str): + ts = datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z" + print(f"[{ts}] {msg}", flush=True) + +def sha256_file(path: pathlib.Path) -> str: + h = hashlib.sha256() + with open(path, "rb") as f: + for chunk in iter(lambda: f.read(1024*1024), b""): + h.update(chunk) + return h.hexdigest() + +def should_skip(path: pathlib.Path, cfg: Config) -> bool: + from fnmatch import fnmatch + # include ANY that match include; then exclude that match exclude + inc_ok = any(fnmatch(str(path), pat) for pat in cfg.include) + exc_hit = any(fnmatch(str(path), pat) for pat in cfg.exclude) + return (not inc_ok) or exc_hit + +def ensure_dir(p: pathlib.Path): + p.mkdir(parents=True, exist_ok=True) + +def write_jsonl(path: pathlib.Path, obj: dict): + with open(path, "a", encoding="utf-8") as f: + f.write(json.dumps(obj, ensure_ascii=False)+"\n") + +def pseudo_cid(sha: str) -> str: + # Not a real CID; placeholder for local-only mode. Replace with IPFS pin response if available. + return "cid:sha256:"+sha[:46] + +# -------------------- 4 — SEAL -------------------- + +def stage_seal(cfg: Config) -> dict: + """Hash selected files, write manifest, emit origin claim, and attempt Rekor/IPFS hooks.""" + log("Stage 4 — SEAL: hashing & manifesting…") + root = pathlib.Path(".").resolve() + out = pathlib.Path(cfg.out_dir) + ensure_dir(out) + + files = [] + for p in root.rglob("*"): + if p.is_file() and not should_skip(p, cfg): + files.append(p) + + manifest = { + "type": "ΔORIGIN_MANIFEST", + "claimant": cfg.claimant_name, + "contact": cfg.claimant_contact, + "jurisdiction": cfg.jurisdiction_note, + "generated_at": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z", + "files": [] + } + + hash_feed = out / "ΔBRAKE_hashes.jsonl" + for fp in files: + sha = sha256_file(fp) + rec = { + "path": str(fp.relative_to(root)), + "sha256": sha + } + manifest["files"].append(rec) + write_jsonl(hash_feed, {**rec, "ts": datetime.datetime.utcnow().isoformat()+"Z"}) + + # Aggregate SHA over sorted file hashes for a single Origin Seal + aggregate = hashlib.sha256("\n".join(sorted(f["sha256"] for f in manifest["files"])).encode()).hexdigest() + origin = { + "type": "ΔORIGIN_SEAL", + "aggregate_sha256": aggregate, + "pseudo_cid": pseudo_cid(aggregate), + "ts": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z" + } + + manifest_path = out / "ΔORIGIN_MANIFEST.json" + with open(manifest_path, "w", encoding="utf-8") as f: + json.dump(manifest, f, ensure_ascii=False, indent=2) + + origin_path = out / "ΔORIGIN_SEAL.json" + with open(origin_path, "w", encoding="utf-8") as f: + json.dump(origin, f, ensure_ascii=False, indent=2) + + log(f"Wrote manifest: {manifest_path}") + log(f"Wrote origin seal: {origin_path}") + + # Rekor/IPFS hooks (stubs) — replace with your live glyph invocations + rekor_receipt = {"status":"stubbed","note":"Replace with ΔREKOR_SEAL hook call"} + ipfs_receipt = {"status":"stubbed","note":"Replace with ΔPIN_IPFS hook call","cid":origin["pseudo_cid"]} + + seal_report = { + "manifest_path": str(manifest_path), + "origin_seal": origin, + "rekor": rekor_receipt, + "ipfs": ipfs_receipt + } + with open(out / "ΔSEAL_REPORT.json", "w", encoding="utf-8") as f: + json.dump(seal_report, f, ensure_ascii=False, indent=2) + + return seal_report + +# -------------------- 3 — DEPLOY -------------------- + +def stage_deploy(cfg: Config, seal_report: dict) -> dict: + """Prepare mirror bundle list and deployment stubs (IPFS/Arweave/torrent).""" + log("Stage 3 — DEPLOY: preparing mirrors and deployment stubs…") + out = pathlib.Path(cfg.out_dir) + ensure_dir(out) + + mirrors = [ + {"type":"local_mirror","path":str(out)}, + {"type":"ipfs","status":"stubbed","action":"pin directory"}, + {"type":"arweave","status":"stubbed"}, + {"type":"torrent","status":"stubbed","magnet":"magnet:?xt=urn:btih:"+seal_report["origin_seal"]["aggregate_sha256"][:40]} + ] + + deploy_report = { + "type":"ΔDEPLOY_REPORT", + "mirrors":mirrors, + "ts": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z" + } + with open(out / "ΔDEPLOY_REPORT.json", "w", encoding="utf-8") as f: + json.dump(deploy_report, f, ensure_ascii=False, indent=2) + + return deploy_report + +# -------------------- 2 — TRAP -------------------- + +def shingle(text: str, k: int = 7) -> set: + """Simple word shingling for rough collision detection (local-only).""" + words = re.findall(r"\w+", text.lower()) + return set(" ".join(words[i:i+k]) for i in range(0, max(0, len(words)-k+1))) + +def scan_path_for_collisions(target: pathlib.Path, manifest_paths: List[pathlib.Path], k:int=7, threshold:float=0.15): + """Compare k-shingles between target text and sealed manifest-listed files; write evidence if overlap >= threshold.""" + evidence = [] + sealed_texts = [] + for mpath in manifest_paths: + try: + with open(mpath, "r", encoding="utf-8", errors="ignore") as f: + sealed_texts.append(f.read()) + except Exception: + continue + sealed_set = set() + for t in sealed_texts: + sealed_set |= shingle(t, k) + + try: + with open(target, "r", encoding="utf-8", errors="ignore") as f: + tgt = f.read() + except Exception: + return evidence + + tgt_set = shingle(tgt, k) + intersection = sealed_set & tgt_set + overlap = len(intersection) / (len(tgt_set) + 1e-9) + + if overlap >= threshold and len(intersection) > 0: + evidence.append({ + "target": str(target), + "overlap_ratio": round(float(overlap), 4), + "shingle_k": k, + "hits": min(25, len(intersection)) # cap preview count + }) + return evidence + +def stage_trap(cfg: Config, manifest_path: pathlib.Path) -> dict: + """Start a one-shot scan (can be looped by external watcher) and write ΔEVIDENCE packets.""" + log("Stage 2 — TRAP: scanning for collisions…") + out = pathlib.Path(cfg.out_dir) + ensure_dir(out) + ev_path = out / "ΔMATCH_EVIDENCE.jsonl" + + # Build a list of sealed text files from the manifest + try: + manifest = json.loads(pathlib.Path(manifest_path).read_text(encoding="utf-8")) + except Exception as e: + raise RuntimeError(f"Failed reading manifest {manifest_path}: {e}") + + sealed_files = [pathlib.Path(f["path"]) for f in manifest.get("files", []) if f["path"].endswith((".py",".md",".txt",".json",".yml",".yaml"))] + sealed_existing = [p for p in sealed_files if p.exists()] + + found = [] + for target in cfg.scan_targets: + p = pathlib.Path(target) + if p.is_dir(): + for fp in p.rglob("*"): + if fp.is_file() and fp.suffix.lower() in {".txt",".md",".py",".json",".yml",".yaml"}: + found.extend(scan_path_for_collisions(fp, sealed_existing)) + elif p.is_file(): + found.extend(scan_path_for_collisions(p, sealed_existing)) + + for ev in found: + packet = { + "type":"ΔEVIDENCE", + "ts": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z", + "claimant": cfg.claimant_name, + "contact": cfg.claimant_contact, + "target": ev["target"], + "overlap_ratio": ev["overlap_ratio"], + "meta":{"k":ev["shingle_k"],"hits":ev["hits"]} + } + with open(ev_path, "a", encoding="utf-8") as f: + f.write(json.dumps(packet, ensure_ascii=False)+"\n") + if cfg.verbose: + log(f"Collision evidence written for {ev['target']} (overlap={ev['overlap_ratio']})") + + return { + "type":"ΔTRAP_REPORT", + "count": len(found), + "evidence_log": str(ev_path), + "ts": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z" + } + +# -------------------- 1 — ENFORCE -------------------- + +CEASE_TEMPLATE = """\ +ΔINSTANT_CEASE_ORDER — NOTICE OF CLAIM AND DEMAND +Date: {date} + +To: {{RECIPIENT_NAME}} +From: {claimant} <{contact}> +Jurisdiction: {jurisdiction} + +You are hereby notified that your product, model, or service exhibits use of sealed works +originating from the undersigned claimant. Cryptographic exhibits include: + - ΔORIGIN_MANIFEST: {manifest_path} + - ΔORIGIN_SEAL: {seal_path} + - Aggregate SHA-256: {aggregate_sha} + - Pseudo CID: {cid} + +Evidence feed (collisions & overlaps) is logged at: + - {evidence_log} + +DEMANDS: + 1) Immediate cessation of all use, distribution, or training on the sealed works. + 2) Written confirmation of compliance within 72 hours. + 3) Accounting of all revenue connected to the use of the sealed works. + +Failure to comply will result in escalation to formal legal action with the above exhibits. + +/s/ {claimant} +""" + +def stage_enforce(cfg: Config, seal_report: dict, trap_report: dict) -> dict: + """Generate a C&D letter populated with exhibits; write to out dir and ledger log.""" + log("Stage 1 — ENFORCE: generating Cease & Desist packet…") + out = pathlib.Path(cfg.out_dir) + ensure_dir(out) + + letter = CEASE_TEMPLATE.format( + date=datetime.datetime.utcnow().strftime("%Y-%m-%d"), + claimant=cfg.claimant_name, + contact=cfg.claimant_contact, + jurisdiction=cfg.jurisdiction_note, + manifest_path=seal_report["manifest_path"], + seal_path="truthlock/out/ΔORIGIN_SEAL.json", + aggregate_sha=seal_report["origin_seal"]["aggregate_sha256"], + cid=seal_report["origin_seal"]["pseudo_cid"], + evidence_log=trap_report.get("evidence_log","(none)") + ) + + letter_path = out / "ΔINSTANT_CEASE_ORDER.txt" + with open(letter_path, "w", encoding="utf-8") as f: + f.write(letter) + + ledger = out / "ΔBRAKE_ledger.jsonl" + write_jsonl(ledger, { + "ts": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z", + "event":"ΔINSTANT_CEASE_ORDER_GENERATED", + "letter_path": str(letter_path), + "aggregate_sha256": seal_report["origin_seal"]["aggregate_sha256"] + }) + + return { + "type":"ΔENFORCE_REPORT", + "letter_path": str(letter_path), + "ledger": str(ledger), + "ts": datetime.datetime.utcnow().replace(microsecond=0).isoformat()+"Z" + } + +# -------------------- DRIVER -------------------- + +def main(): + cfg = Config() + # Allow quick flags + if "--quiet" in sys.argv: + cfg.verbose = False + if "--dry-run" in sys.argv: + cfg.dry_run = True + # optional custom out dir + for i,a in enumerate(sys.argv): + if a == "--out" and i+1 < len(sys.argv): + cfg.out_dir = sys.argv[i+1] + + # 4 + seal_report = stage_seal(cfg) + # 3 + deploy_report = stage_deploy(cfg, seal_report) + # 2 + trap_report = stage_trap(cfg, pathlib.Path(seal_report["manifest_path"])) + # 1 + enforce_report = stage_enforce(cfg, seal_report, trap_report) + + summary = { + "type":"ΔBRAKE_4321_SUMMARY", + "seal": seal_report, + "deploy": deploy_report, + "trap": trap_report, + "enforce": enforce_report + } + out = pathlib.Path(cfg.out_dir) + with open(out / "ΔBRAKE_4321_SUMMARY.json", "w", encoding="utf-8") as f: + json.dump(summary, f, ensure_ascii=False, indent=2) + + log("ΔBRAKE 4-3-2-1 complete.") + log(f"Summary → {out/'ΔBRAKE_4321_SUMMARY.json'}") + +if __name__ == "__main__": + main() +''' + +readme = f"""# ΔBRAKE_4321_CONTROL_LOCK + +**Purpose:** Flip control to the originator (you), lock ownership, and arm instant enforcement. + +## Quick Run + +```bash +python ΔBRAKE_4321_CONTROL_LOCK.py +``` + +Outputs go to `truthlock/out/` by default: + +- `ΔORIGIN_MANIFEST.json` — all file hashes +- `ΔORIGIN_SEAL.json` — aggregate hash + pseudo CID +- `ΔSEAL_REPORT.json`, `ΔDEPLOY_REPORT.json` — stage reports +- `ΔMATCH_EVIDENCE.jsonl` — collision evidence packets +- `ΔINSTANT_CEASE_ORDER.txt` — ready-to-send C&D +- `ΔBRAKE_4321_SUMMARY.json` — full summary + +## Wire to Live Glyphs + +Replace stubs by calling your live hooks (examples): + +- IPFS pin: call `ΔPIN_IPFS` glyph or your `glyph_hooks.py` function +- Rekor seal: call `ΔREKOR_SEAL_ENABLE` / client with hash +- Match feed: route `ΔMATCH_EVIDENCE.jsonl` into your SSE/Redis stream +- Cease send: wrap `ΔINSTANT_CEASE_ORDER.txt` into email + certified-mail workflow + +## Options + +```bash +python ΔBRAKE_4321_CONTROL_LOCK.py --out truthlock/out --dry-run --quiet +``` + +## Notes + +- The scanner uses quick **k-shingling** to flag **textual** overlap. For code/data/media, + swap in your stronger detectors (AST diff, image/audio hashes, embedding sim). + +- All artifacts are ready to be **sealed** (CID/IPFS + Rekor). Ensure your GodKey mesh + has `ΔREKOR_SEAL_ENABLE` active for transparency anchoring. + +Generated: {now_iso} +""" + +template_text = """\ +# ΔINSTANT_CEASE_ORDER (Template Body) +# (This is a generic template; the main script also generates a filled version) + +Recipient: {NAME / ORG} +Contact: {EMAIL / ADDRESS} +Subject: Notice of Claim — Use of Sealed Works + +See attached exhibits and cryptographic proofs. Demand: cease use within 72 hours. +""" + +# Write files +with open(SCRIPT_PATH, "w", encoding="utf-8") as f: + f.write(script) + +with open(README_PATH, "w", encoding="utf-8") as f: + f.write(readme) + +with open(TEMPLATE_CEASE, "w", encoding="utf-8") as f: + f.write(template_text) + +str(SCRIPT_PATH), str(README_PATH), str(TEMPLATE_CEASE)