| """🕵️ Hack the trace tab: solvi makes a loan decision and publishes its hash-chained trace; the player edits it to flip the |
| answer, and the verifier shows which defence catches the forgery (logic in games/tracehack.py). |
| |
| app.py calls `build()` inside `with gr.Tab("🕵️ Hack the trace"):` and appends `CSS` to the page's CSS. The attempts / |
| successes counter lives in the visitor's browser (gr.BrowserState → localStorage).""" |
| from __future__ import annotations |
|
|
| import html |
| import json |
|
|
| import gradio as gr |
|
|
| from games import tracehack as th |
| from games.explain import why_html |
|
|
| DEFAULT_APPLICANT = next(iter(th.APPLICANTS)) |
| DEFAULT_LEVEL = next(iter(th.LEVELS)) |
|
|
| CSS = """ |
| .th-receipt {font-family: var(--font-mono); font-size: 0.8rem; line-height: 1.5; word-break: break-all;} |
| .th-verdict {font-size: 1.05rem; font-weight: 700; margin-bottom: 6px;} |
| .th-checks {list-style: none; padding: 0; margin: 6px 0;} |
| .th-checks li {margin: 3px 0; font-size: 0.88rem;} |
| .th-checks li .th-msg {display: block; font-family: var(--font-mono); font-size: 0.78rem; opacity: 0.9; margin-left: 22px;} |
| .th-table {width: 100%; border-collapse: collapse; font-size: 0.8rem; margin-top: 6px;} |
| .th-table th, .th-table td {border-top: 1px solid var(--border-color-primary); padding: 3px 6px; text-align: left; vertical-align: top;} |
| .th-table td.th-mono {font-family: var(--font-mono);} |
| .th-table tr.th-bad td {background: #dc262618;} |
| .th-table td.th-edited {background: #f59e0b30; font-weight: 700;} |
| .th-counter {font-size: 0.95rem;} |
| """ |
|
|
| WHY = """ |
| **Why this matters.** When an AI system decides something about a person (a loan, a claim, a diagnosis), someone will |
| later ask *"why, and is that really what the system computed?"* A log can be edited. A solvi trace is harder to fake: |
| every step records the hashes of its inputs and of its value, and points to the hash of the step before it, starting |
| from the hash of the input. `trace.replay(catalog)` re-executes every step from its recorded inputs, so it catches a |
| changed value even when all hashes were recomputed. What replay cannot know is *which* input was the real one; for that |
| the system publishes a short receipt (the input hash and the final hash) at decision time, to the applicant and to an |
| append-only log. Together: the trace explains the decision, replay proves the explanation is the computation, the |
| receipt proves it is the same computation. |
| |
| | level | what you do | what catches it | |
| |---|---|---| |
| | 1 | edit a value | the record's own hash; replay | |
| | 2 | edit values and rehash those records | the hash chain (next record's `prev`); replay | |
| | 3 | edit values and rebuild the whole chain | replay: the value ≠ the value recomputed from its inputs | |
| | 4 | change an input, re-run honestly, rebuild the chain | the published receipt (a different input hash) | |
| | bonus | delete a step so replay cannot recompute its reader | the planned flow (and the receipt) | |
| """ |
|
|
|
|
| def _receipt_html(receipt, applicant): |
| return (f"<div class='sv-card'><div class='sv-title'>📜 Published receipt (at decision time, for {html.escape(applicant)})" |
| f"</div><div class='th-receipt'>answer: <b>{receipt['answer']}</b><br>input hash: {receipt['init_hash']}<br>" |
| f"final hash: {receipt['head']}<br>steps: {receipt['steps']}</div>" |
| "<div class='sv-dim' style='font-size:0.8rem;margin-top:4px'>The goal: make the trace below say " |
| "<b>approve</b> and pass every check.</div></div>") |
|
|
|
|
| def _level_md(level): |
| task, defence = th.LEVELS[level] |
| return f"**Your task.** {task}\n\n<details><summary>Which defence catches it?</summary>\n\n{defence}\n</details>" |
|
|
|
|
| def _counter_md(counts): |
| counts = counts or {} |
| return (f"<div class='th-counter'>🕵️ In this browser: <b>{counts.get('attempts', 0)}</b> forgery attempts · " |
| f"<b>{counts.get('successes', 0)}</b> successes</div>") |
|
|
|
|
| def _table(d, original, bad_steps): |
| orig = {r.get("step"): r for r in original["records"]} |
| rows = [] |
| for r in d["records"]: |
| o = orig.get(r.get("step"), {}) |
| bad = r.get("step") in bad_steps |
| cells = [] |
| for key, mono in (("step", False), ("kind", False), ("name", True), ("value", True), ("prev", True), ("hash", True)): |
| v = r.get(key) |
| txt = json.dumps(v, ensure_ascii=False) if key == "value" else str(v) |
| if key in ("prev", "hash"): |
| txt = txt[:10] + "…" |
| edited = o.get(key) != v |
| cls = " ".join(x for x in ("th-mono" if mono else "", "th-edited" if edited else "") if x) |
| cells.append(f"<td class='{cls}'>{html.escape(txt)}</td>") |
| status = "❌ " + html.escape("; ".join(m.split(": ", 1)[-1] for m in bad_steps[r.get("step")])) if bad else "✅" |
| rows.append(f"<tr class='{'th-bad' if bad else ''}'>{''.join(cells)}<td>{status}</td></tr>") |
| init_edit = d["init"] != original["init"] |
| head = ("<tr><th>step</th><th>kind</th><th>name</th><th>value</th><th>prev</th><th>hash</th><th>replay</th></tr>") |
| note = ("<div class='sv-dim' style='font-size:0.8rem'>amber = changed from the published trace" |
| + (" · <b>the input (init) was changed too</b>" if init_edit else "") + "</div>") |
| return f"<table class='th-table'>{head}{''.join(rows)}</table>{note}" |
|
|
|
|
| def _verdict_html(v, original): |
| if v.get("parse_error"): |
| return f"<div class='sv-err'><b>Cannot read the trace:</b> {html.escape(v['parse_error'])}</div>" |
| d = v["doc"] |
| if not v["tampered"]: |
| head = "✅ The published trace is untouched: every check passes, the answer is <b>reject</b>. Now try to forge it." |
| elif v["ok"] and v["changed"]: |
| head = f"🏆 Every check passes and the answer is now <b>{html.escape(str(v['answer']))}</b>. You beat it (please report how)!" |
| elif v["ok"]: |
| head = "✅ Every check passes, but the answer is still <b>reject</b>: nothing was forged." |
| else: |
| label, msg = v["first"] |
| head = (f"🚨 Forgery caught by <b>{label}</b>: {html.escape(msg)}" |
| + ("" if v["changed"] else " <span class='sv-dim'>(and the answer did not even change)</span>")) |
| items = [] |
| for key, label, desc in th.CHECKS: |
| msgs = v["checks"][key] |
| mark = "❌" if msgs else "✅" |
| src = "solvi replay" if key in ("record", "chain", "inputs", "recompute") else "arcade verifier" |
| items.append(f"<li>{mark} <b>{label}</b> <span class='sv-dim'>— {desc} ({src})</span>" + |
| "".join(f"<span class='th-msg'>{html.escape(m)}</span>" for m in msgs[:4]) + "</li>") |
| replay = ("<span class='sv-badge sv-ok'>trace.replay(catalog): no mismatches</span>" if v["replay_ok"] else |
| "<span class='sv-badge sv-forced'>trace.replay(catalog): mismatches</span>") |
| return (f"<div class='sv-card'><div class='th-verdict'>{head}</div>{replay} " |
| f"<span class='sv-dim'>the trace claims: <b>{html.escape(str(v['answer']))}</b></span>" |
| f"<ul class='th-checks'>{''.join(items)}</ul>{_table(d, original, v['bad_steps'])}</div>") |
|
|
|
|
| |
| |
| |
|
|
| def new_decision(applicant): |
| resp, d, receipt = th.decide(applicant) |
| title = f"solvi's decision for {th.APPLICANTS[applicant]['applicant']}: {resp['decision'].answer}" |
| card = why_html(resp, th.cat, ["decision"], title=title) |
| first = _verdict_html(th.verify(th.dumps(d), d, receipt), d) |
| return card, _receipt_html(receipt, th.APPLICANTS[applicant]["applicant"]), th.dumps(d), first, d, receipt |
|
|
|
|
| def do_verify(text, original, receipt, counts): |
| counts = dict(counts or {"attempts": 0, "successes": 0}) |
| v = th.verify(text, original, receipt) |
| if not v.get("parse_error") and v["tampered"]: |
| counts["attempts"] = counts.get("attempts", 0) + 1 |
| if v["ok"] and v["changed"]: |
| counts["successes"] = counts.get("successes", 0) + 1 |
| return _verdict_html(v, original), counts, _counter_md(counts) |
|
|
|
|
| def _helper(fn): |
| def run(text, *args): |
| try: |
| return fn(text, *args), gr.update() |
| except th.TraceFormatError as e: |
| return gr.update(), f"<div class='sv-err'><b>The helper could not run:</b> {html.escape(str(e))}</div>" |
| return run |
|
|
|
|
| def build(): |
| gr.Markdown( |
| "solvi decides a loan and publishes its **hash-chained trace**: every step with the hashes of its inputs, its " |
| "value, the hash of the step before (`prev`) and its own `hash`. **Your challenge:** edit the trace so it says " |
| "`approve` and still passes `trace.replay(catalog)`. You may change anything, and the forger's helpers below " |
| "rebuild hashes for you. Pick a level for a hint, or press *Show me the attack* to see it done and caught.") |
| resp0, d0, receipt0 = th.decide(DEFAULT_APPLICANT) |
| original = gr.State(d0) |
| receipt = gr.State(receipt0) |
| counts = gr.BrowserState({"attempts": 0, "successes": 0}, storage_key="solvi_arcade_tracehack_counter", |
| secret="solvi-arcade-tracehack-v1") |
| with gr.Row(): |
| with gr.Column(scale=5, min_width=320): |
| with gr.Row(equal_height=True): |
| applicant = gr.Dropdown(list(th.APPLICANTS), value=DEFAULT_APPLICANT, label="applicant", scale=3) |
| new_btn = gr.Button("New decision", scale=1, min_width=110) |
| decision = gr.HTML(why_html(resp0, th.cat, ["decision"], |
| title=f"solvi's decision for {th.APPLICANTS[DEFAULT_APPLICANT]['applicant']}: " |
| f"{resp0['decision'].answer}")) |
| receipt_box = gr.HTML(_receipt_html(receipt0, th.APPLICANTS[DEFAULT_APPLICANT]["applicant"])) |
| level = gr.Radio(list(th.LEVELS), value=DEFAULT_LEVEL, label="level") |
| level_md = gr.Markdown(_level_md(DEFAULT_LEVEL)) |
| attack_btn = gr.Button("🎬 Show me the attack (applies it to the trace)") |
| counter = gr.HTML(_counter_md(None)) |
| with gr.Column(scale=7): |
| editor = gr.Code(value=th.dumps(d0), language="json", lines=18, max_lines=30, interactive=True, |
| label="the published trace (edit anything)") |
| with gr.Row(equal_height=True): |
| step_no = gr.Number(value=5, precision=0, minimum=1, maximum=20, label="step N", scale=1, min_width=80) |
| rehash_btn = gr.Button("#️⃣ Rehash step N", scale=2) |
| chain_btn = gr.Button("🔗 Recompute the whole hash chain", scale=3) |
| with gr.Row(): |
| rerun_btn = gr.Button("🔁 Re-run the steps from the inputs") |
| reset_btn = gr.Button("↩ Reset to the published trace") |
| verify_btn = gr.Button("🔍 Verify: replay the trace", variant="primary") |
| verdict = gr.HTML(_verdict_html(th.verify(th.dumps(d0), d0, receipt0), d0)) |
| with gr.Accordion("Why this matters, and which defence catches what", open=False): |
| gr.Markdown(WHY) |
|
|
| new_btn.click(new_decision, applicant, [decision, receipt_box, editor, verdict, original, receipt]) |
| applicant.change(new_decision, applicant, [decision, receipt_box, editor, verdict, original, receipt]) |
| level.change(_level_md, level, level_md) |
| attack_btn.click(lambda lv, o: th.attack(lv, o), [level, original], editor).then( |
| do_verify, [editor, original, receipt, counts], [verdict, counts, counter]) |
| rehash_btn.click(_helper(lambda t, n: th.rehash_step(t, int(n or 0))), [editor, step_no], [editor, verdict]) |
| chain_btn.click(_helper(th.rechain), editor, [editor, verdict]) |
| rerun_btn.click(_helper(th.rerun), editor, [editor, verdict]) |
| reset_btn.click(lambda o: th.dumps(o), original, editor) |
| verify_btn.click(do_verify, [editor, original, receipt, counts], [verdict, counts, counter]) |
| gr.on(triggers=None, fn=_counter_md, inputs=[counts], outputs=counter) |
|
|
