Upload 3 files

app.py

@@ -0,0 +1,47 @@
+import json
+import gradio as gr
+
+from sovereign_core import (
+    ENGINE_NAME,
+    SovereignFingerprint,
+    generate_attestation,
+    generate_integrity_certificate,
+    verify_attestation,
+    verify_certificate,
+)
+
+
+def run_sentinel(engine_name: str):
+    engine = engine_name.strip() or ENGINE_NAME
+
+    fpgen = SovereignFingerprint(engine)
+    _, fp_value = fpgen.export()
+
+    att = generate_attestation(fp_value)
+    cert = generate_integrity_certificate(fp_value, att)
+
+    att_ok = verify_attestation(att)
+    cert_ok = verify_certificate(cert)
+
+    result = {
+        "engine": engine,
+        "fingerprint": fp_value,
+        "attestation": att,
+        "certificate": cert,
+        "verify_attestation": att_ok,
+        "verify_certificate": cert_ok,
+    }
+
+    return json.dumps(result, indent=4)
+
+
+demo = gr.Interface(
+    fn=run_sentinel,
+    inputs=gr.Textbox(label="Engine name", value=ENGINE_NAME),
+    outputs=gr.Code(label="Sovereign Security Snapshot (JSON)", language="json"),
+    title="AI Sovereign Sentinel – Integrity Engine",
+    description="Generates a sovereign fingerprint, attestation, and integrity certificate, then verifies the full chain."
+)
+
+if __name__ == "__main__":
+    demo.launch(share=True)

requirements.txt

@@ -0,0 +1 @@
+gradio>=4.0.0

sovereign_core.py

@@ -0,0 +1,140 @@
+import os
+import json
+import time
+import uuid
+import hashlib
+
+
+ENGINE_NAME = "AI_Sovereign_Sentinel_Core_v1"
+AUTHORITY_NAME = "DataClear Sovereign Authority"
+
+
+class SovereignFingerprint:
+    """
+    Minimal fingerprint generator for AI Sovereign Sentinel.
+    Creates a JSON file with engine, fingerprint and issued_at.
+    """
+    def __init__(self, engine: str, output: str = "sovereign_fingerprint.json"):
+        self.engine = engine
+        self.output = output
+
+    def _build(self):
+        issued_at = int(time.time())
+        base = f"{self.engine}|{issued_at}"
+        fp_hash = hashlib.sha256(base.encode()).hexdigest()
+        return {
+            "engine": self.engine,
+            "fingerprint": fp_hash,
+            "issued_at": issued_at,
+            "version": "1.0",
+        }
+
+    def export(self):
+        fp = self._build()
+        with open(self.output, "w") as f:
+            json.dump(fp, f, indent=4)
+        return self.output, fp["fingerprint"]
+
+
+class SovereignValidator:
+    """
+    Simple registry to bind engine name → fingerprint string.
+    Stored in sovereign_registry.json
+    """
+    def __init__(self, path: str = "sovereign_registry.json"):
+        self.path = path
+        if os.path.exists(self.path):
+            with open(self.path, "r") as f:
+                self.registry = json.load(f)
+        else:
+            self.registry = {}
+
+    def register(self, engine: str, fingerprint: str) -> bool:
+        self.registry[engine] = {
+            "fingerprint": fingerprint,
+            "registered_at": int(time.time()),
+        }
+        with open(self.path, "w") as f:
+            json.dump(self.registry, f, indent=4)
+        return True
+
+    def validate(self, engine: str, fingerprint: str) -> bool:
+        entry = self.registry.get(engine)
+        if not entry:
+            return False
+        return entry.get("fingerprint") == fingerprint
+
+
+def attestation_signature(att: dict) -> str:
+    """
+    Unified, stable signature generation for attestation objects.
+    """
+    base = f"{att['attestation_id']}|{att['issued_at']}|{att['fingerprint']}|{att['issuer']}|{att['version']}"
+    return hashlib.sha256(base.encode()).hexdigest()
+
+
+def generate_attestation(fp):
+    """
+    Create a signed attestation for a given fingerprint (dict or string).
+    """
+    if isinstance(fp, dict):
+        fp_value = fp.get("fingerprint", "")
+    else:
+        fp_value = fp
+
+    att = {
+        "attestation_id": str(uuid.uuid4()),
+        "issued_at": int(time.time()),
+        "fingerprint": fp_value,
+        "issuer": AUTHORITY_NAME,
+        "version": "1.0",
+    }
+
+    att["signature"] = attestation_signature(att)
+    return att
+
+
+def verify_attestation(att: dict) -> bool:
+    expected = attestation_signature(att)
+    return expected == att.get("signature")
+
+
+def generate_integrity_certificate(fp, att, output: str = "sovereign_certificate.json"):
+    """
+    Bundle fingerprint + attestation into a single integrity certificate file.
+    """
+    if isinstance(fp, dict):
+        fp_value = fp.get("fingerprint", "")
+    else:
+        fp_value = fp
+
+    cert = {
+        "engine": ENGINE_NAME,
+        "fingerprint": fp_value,
+        "issued_at": att["issued_at"],
+        "attestation": att,
+        "certificate_version": "1.0",
+        "authority": AUTHORITY_NAME,
+    }
+
+    with open(output, "w") as f:
+        json.dump(cert, f, indent=4)
+
+    return cert
+
+
+def verify_certificate(cert: dict) -> bool:
+    """
+    High-level check over the full certificate.
+    """
+    if cert.get("engine") != ENGINE_NAME:
+        return False
+
+    if cert.get("authority") != AUTHORITY_NAME:
+        return False
+
+    att = cert.get("attestation", {})
+    if not verify_attestation(att):
+        return False
+
+    return True