Update README.md
This commit is contained in:
Matthew D Porter
GitHub
parent
7dc7314a4f
commit
fb4e91f35c
458
README.md
458
README.md
|
|
@ -1,4 +1,460 @@
|
|||
<p align="center">
|
||||
# Δ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)<p align="center">
|
||||
<img src="assets/TauricResearch.png" style="width: 60%; height: auto;">
|
||||
</p>
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue