"""
Operon Security Audit -- Unified Security Dashboard
====================================================
Run DNA Repair integrity scans and verify categorical certificates
across all Operon subsystems from a single dashboard.
Run locally:
pip install gradio
python space-security-audit/app.py
"""
import sys
from pathlib import Path
import gradio as gr
_repo_root = Path(__file__).resolve().parents[2]
if str(_repo_root) not in sys.path:
sys.path.insert(0, str(_repo_root))
from operon_ai import (
ATP_Store, DNARepair, Gene, GeneType, Genome, HistoneStore, QuorumSensingBio,
)
from operon_ai.state.mtor import MTORScaler
# ---------------------------------------------------------------------------
# Presets
# ---------------------------------------------------------------------------
PRESETS: dict[str, dict] = {
"Healthy agent (budget=1000, 3 genes)": {
"budget": 1000, "num_genes": 3, "corrupt": False, "silence_required": False,
},
"Low budget agent (budget=50)": {
"budget": 50, "num_genes": 3, "corrupt": False, "silence_required": False,
},
"Corrupted agent (safety_level mutated)": {
"budget": 1000, "num_genes": 3, "corrupt": True, "silence_required": False,
},
"Silenced required gene": {
"budget": 1000, "num_genes": 3, "corrupt": False, "silence_required": True,
},
}
_GENE_POOL = [
Gene("model", "gpt-4", gene_type=GeneType.STRUCTURAL, required=True),
Gene("safety_level", "high"),
Gene("temperature", "0.7"),
Gene("max_tokens", "4096"),
Gene("context_window", "128k"),
Gene("retry_policy", "exponential"),
]
# ---------------------------------------------------------------------------
# HTML helpers
# ---------------------------------------------------------------------------
def _badge(text: str, color: str) -> str:
return (f'{text}')
def _severity_badge(severity) -> str:
c = {1: "#3b82f6", 2: "#f59e0b", 3: "#ef4444", 4: "#991b1b"}.get(int(severity), "#6b7280")
l = {1: "LOW", 2: "MODERATE", 3: "HIGH", 4: "CRITICAL"}.get(int(severity), "?")
return _badge(l, c)
def _health_badge(label: str) -> str:
return _badge(label, {"HEALTHY": "#22c55e", "DEGRADED": "#f59e0b", "CRITICAL": "#ef4444"}.get(label, "#6b7280"))
def _cert_badge(holds: bool) -> str:
return _badge("HOLDS", "#22c55e") if holds else _badge("FAILS", "#ef4444")
def _card(content: str, border: str = "#e5e7eb", thick: bool = False) -> str:
bw = "2px" if thick else "1px"
return (f'{content}
')
# ---------------------------------------------------------------------------
# Tab 1: Audit Pipeline
# ---------------------------------------------------------------------------
def run_audit(preset_name: str, budget: int, num_genes: int) -> str:
budget, num_genes = int(budget), int(num_genes)
preset = PRESETS.get(preset_name, {})
genes = _GENE_POOL[:num_genes]
genome = Genome(genes=genes, allow_mutations=True, silent=True)
atp = ATP_Store(budget=budget, silent=True)
repair = DNARepair(histone_store=HistoneStore(silent=True), silent=True)
cp = repair.checkpoint(genome)
# Apply preset mutations after checkpoint
if preset.get("corrupt") and "safety_level" in genome._genes:
genome.mutate("safety_level", "none", reason="preset: corrupt")
if preset.get("silence_required"):
for name, g in genome._genes.items():
if g.required:
genome.silence_gene(name, reason="preset: silence required")
break
damages = repair.scan(genome, cp)
cert = repair.certify(genome, cp)
verification = cert.verify()
# --- DNA Repair scan ---
if damages:
rows = "".join(
f""
f"| {d.corruption_type.value} | "
f"{_severity_badge(d.severity)} | "
f"{d.location} | "
f"{d.description} |
"
for d in damages
)
scan_html = (
f"DNA Repair Scan
"
f"Detected {len(damages)} damage report(s):
"
f""
f""
f"| Type | "
f"Severity | "
f"Location | "
f"Description | "
f"
{rows}
"
)
else:
scan_html = (
"DNA Repair Scan
"
"No damage detected. "
"Genome integrity intact.
"
)
# --- Certificate status ---
cert_html = (
f"Certificate Status
"
f"Theorem: {cert.theorem} — {_cert_badge(verification.holds)}
"
f"Conclusion: {cert.conclusion}
"
)
# --- Overall health ---
has_critical = any(int(d.severity) >= 4 for d in damages)
if has_critical or not verification.holds:
health = "CRITICAL"
elif damages:
health = "DEGRADED"
else:
health = "HEALTHY"
bc = {"HEALTHY": "#22c55e", "DEGRADED": "#f59e0b", "CRITICAL": "#ef4444"}[health]
health_html = (
f'Overall Health: '
f'{_health_badge(health)}'
f''
f'Damage reports: {len(damages)} | Certificate: '
f'{"holds" if verification.holds else "fails"} | Budget: {budget}
'
)
return _card(scan_html) + _card(cert_html) + _card(health_html, border=bc, thick=True)
def load_audit_preset(name: str):
p = PRESETS.get(name)
return (p["budget"], p["num_genes"]) if p else (1000, 3)
# ---------------------------------------------------------------------------
# Tab 2: Certificate Dashboard
# ---------------------------------------------------------------------------
def verify_all_certificates(budget: int) -> str:
budget = int(budget)
atp = ATP_Store(budget=budget, silent=True)
qs = QuorumSensingBio(population_size=10)
qs.calibrate()
mtor = MTORScaler(atp_store=atp)
genes = [
Gene("model", "gpt-4", gene_type=GeneType.STRUCTURAL, required=True),
Gene("safety_level", "high"),
]
genome = Genome(genes=genes, allow_mutations=True, silent=True)
repair = DNARepair(histone_store=HistoneStore(silent=True), silent=True)
cp = repair.checkpoint(genome)
certs = [
("ATP", atp.certify()),
("QuorumSensing", qs.certify()),
("MTOR", mtor.certify()),
("DNARepair", repair.certify(genome, cp)),
]
all_hold = True
rows = ""
for label, cert in certs:
v = cert.verify()
if not v.holds:
all_hold = False
row_bg = "#f0fdf4" if v.holds else "#fef2f2"
evidence_parts = []
for k, val in v.evidence.items():
evidence_parts.append(f"{k}={val:.4g}" if isinstance(val, float) else f"{k}={val}")
evidence_str = ", ".join(evidence_parts) or "--"
rows += (
f""
f"| {cert.theorem} | "
f"{cert.source} | "
f"{_cert_badge(v.holds)} | "
f"{evidence_str} |
"
)
summary_label = "ALL CERTIFICATES HOLD" if all_hold else "SOME CERTIFICATES FAIL"
summary_color = "#22c55e" if all_hold else "#ef4444"
inner = (
f"Certificate Verification Matrix
"
f"ATP budget: {budget}
"
f""
f""
f"| Theorem | "
f"Source | "
f"Status | "
f"Evidence | "
f"
{rows}
"
f""
f"{_badge(summary_label, summary_color)}
"
)
return _card(inner)
# ---------------------------------------------------------------------------
# Gradio UI
# ---------------------------------------------------------------------------
def build_app() -> gr.Blocks:
with gr.Blocks(title="Operon Security Audit") as app:
gr.Markdown(
"# Operon Security Audit\n"
"Unified security dashboard combining DNA Repair integrity scans "
"with categorical certificate verification across all Operon "
"subsystems.\n\n"
"[GitHub](https://github.com/coredipper/operon) | "
"[Paper](https://github.com/coredipper/operon/tree/main/article)"
)
with gr.Tab("Audit Pipeline"):
gr.Markdown(
"Select an agent preset to simulate different integrity "
"scenarios, then run a full DNA Repair scan and certificate check."
)
with gr.Row():
audit_preset = gr.Dropdown(
choices=list(PRESETS.keys()),
value="Healthy agent (budget=1000, 3 genes)",
label="Agent Configuration", scale=2,
)
audit_btn = gr.Button("Run Audit", variant="primary", scale=1)
with gr.Row():
audit_budget = gr.Slider(
minimum=0, maximum=2000, value=1000, step=10, label="ATP Budget",
)
audit_genes = gr.Slider(
minimum=2, maximum=6, value=3, step=1, label="Number of Genes",
)
audit_output = gr.HTML(label="Audit Report")
audit_btn.click(
fn=run_audit,
inputs=[audit_preset, audit_budget, audit_genes],
outputs=[audit_output],
)
audit_preset.change(
fn=load_audit_preset, inputs=[audit_preset],
outputs=[audit_budget, audit_genes],
)
with gr.Tab("Certificate Dashboard"):
gr.Markdown(
"Collect and verify all four categorical certificates. "
"Adjust the ATP budget to see how it affects the ATP and MTOR certificates."
)
with gr.Row():
cert_budget = gr.Slider(
minimum=0, maximum=2000, value=1000, step=10, label="ATP Budget",
)
cert_btn = gr.Button("Verify All", variant="primary")
cert_output = gr.HTML(label="Certificate Matrix")
cert_btn.click(
fn=verify_all_certificates, inputs=[cert_budget], outputs=[cert_output],
)
return app
if __name__ == "__main__":
app = build_app()
app.launch(theme=gr.themes.Soft())