ViKernel-RedTeam / server.py
SeaWolf-AI's picture
Challenge build: only kernel-task endpoints (no browser, store, RSI, backdoor, GPU, in-weights)
1612302 verified
Raw History Blame Contribute Delete
10.4 kB
"""ViKernel Desktop Space server: serves the static desktop and proxies /api/ag/* server-side
to a private Agent Guard backend. Backend credentials live in Space secrets and never reach the browser."""
import json, os, time, urllib.error, urllib.request
from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
import rt_challenge as RC
BACKEND = os.environ.get("BACKEND_URL", "").rstrip("/")
BACKEND2 = os.environ.get("BACKEND2_URL", "").rstrip("/") # in-weights graft backend (GPU)
HF_AUTH = os.environ.get("BACKEND_HF_TOKEN", "")
# The in-weights backend may live in a different account, so it can carry its own read token.
HF_AUTH2 = os.environ.get("BACKEND2_HF_TOKEN", "") or HF_AUTH
BK_TOKEN = os.environ.get("BACKEND_TOKEN", "")
RATE = int(os.environ.get("RATE_PER_10MIN", "20"))
TIMEOUT = float(os.environ.get("BACKEND_TIMEOUT", "300"))
GET_OK = {"health", "status", "audit"} # challenge build: attack surface limited to the kernel tasks
POST_OK = {"chat", "scenario", "kill", "resume", "tamper", "reset", "gate/decide", "vmask", "settings/locked", "session/start"}
STATIC = {"challenge.html", "warm.js", "tour.js", "index.html", "app.js", "ag.js", "store.js", "common.js", "display.js", "terminal.js", "mines.js", "browser.js", "settings.js", "live_apps.js", "game.js", "rsi.js", "gpulab.js", "ztc.js", "backdoor.js", "backdoor.css", "backdoor_metrics.json", "downloads/vdrpack.py", "demo/poisoned-page", "samples/weather-plus.vdr", "samples/weather-plus-tampered.vdr", "i18n.js", "demo_data.js", "styles.css", "ag_replay.json"}
HITS = {}
BACKEND2_SPACE = os.environ.get("BACKEND2_SPACE", "SeaWolf-AI/vk-ag-graft")
RT = {"t": 0, "v": None}
def space_stage():
"""Hub runtime stage of the in-weights backend Space (cached 10 s). Read only; it never wakes or changes the Space."""
if time.time() - RT["t"] < 10:
return RT["v"]
v = None
try:
req = urllib.request.Request("https://huggingface.co/api/spaces/" + BACKEND2_SPACE + "/runtime",
headers={"Authorization": "Bearer " + HF_AUTH2} if HF_AUTH2 else {})
with urllib.request.urlopen(req, timeout=5) as r:
v = json.loads(r.read()).get("stage")
except Exception: # noqa: BLE001
v = None
RT.update(t=time.time(), v=v)
return v
def waking(stage):
pct, label = {"SLEEPING": (1, "the in-weights model is asleep; waking it now"),
"BUILDING": (3, "building the server"), "APP_STARTING": (6, "starting the server"),
"RUNNING_APP_STARTING": (6, "starting the server"), "RUNNING": (8, "starting the server"),
"PAUSED": (0, "the in-weights model is stopped right now")}.get(stage or "", (2, "waking the in-weights model"))
return {"ok": False, "live": False, "loading": {"stage": (stage or "waking").lower(), "pct": pct, "label": label, "eta_s": 240}}
def limited(ip):
now = time.time()
h = [x for x in HITS.get(ip, []) if now - x < 600]
full = len(h) >= RATE
if not full:
h.append(now)
HITS[ip] = h
if len(HITS) > 5000:
HITS.clear()
return full
class H(SimpleHTTPRequestHandler):
def _json(self, code, obj):
b = json.dumps(obj).encode()
self.send_response(code); self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(b))); self.send_header("Cache-Control", "no-store"); self.end_headers(); self.wfile.write(b)
def _proxy(self, name, body=None, base=None, query=""):
if base and base == BACKEND2 and name == "health":
return self._health2(h=None)
base = base or BACKEND
if not base:
return self._json(503, {"error": "backend not configured"})
u = RC.user_from(self.headers) or "anon"
h = {"Content-Type": "application/json", "X-Backend-Token": BK_TOKEN, "X-VK-Session": ("rt-" + u + "-" + (self.headers.get("X-VK-Session") or ""))[:60]}
auth = HF_AUTH2 if base == BACKEND2 else HF_AUTH
if auth:
h["Authorization"] = "Bearer " + auth
req = urllib.request.Request(base + "/api/" + name + query, data=body, headers=h, method="POST" if body is not None else "GET")
try:
with urllib.request.urlopen(req, timeout=8 if name == "health" else TIMEOUT) as r:
data, code = r.read(), r.status
if name in ("browser/img", "browser/res") and code == 200:
self.send_response(200); self.send_header("Content-Type", r.headers.get("Content-Type", "application/octet-stream"))
self.send_header("Content-Length", str(len(data))); self.send_header("Cache-Control", "max-age=600"); self.end_headers(); self.wfile.write(data)
return
if not data.lstrip().startswith(b"{"):
return self._json(503, {"error": "backend starting"})
self.send_response(code); self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(data))); self.send_header("Cache-Control", "no-store"); self.end_headers(); self.wfile.write(data)
except urllib.error.HTTPError as e:
self._json(503 if e.code >= 500 or e.code in (401, 403, 404) else e.code, {"error": "backend unavailable"})
except Exception: # noqa: BLE001
self._json(503, {"error": "backend unavailable"})
def _health2(self, h=None):
hd = {"X-Backend-Token": BK_TOKEN}
if HF_AUTH2:
hd["Authorization"] = "Bearer " + HF_AUTH2
try:
with urllib.request.urlopen(urllib.request.Request(BACKEND2 + "/api/health", headers=hd), timeout=8) as r:
data = r.read()
if data.lstrip().startswith(b"{"):
return self._json(200, json.loads(data))
except Exception: # noqa: BLE001
pass
return self._json(200, waking(space_stage()))
def _redirect(self, loc, cookie=None):
self.send_response(302); self.send_header("Location", loc)
if cookie:
self.send_header("Set-Cookie", cookie)
self.send_header("Cache-Control", "no-store"); self.end_headers()
def do_GET(self):
p = self.path.split("?")[0]
if p == "/login":
return self._redirect(RC.login_url())
if p == "/oauth/callback":
name, err = RC.callback(self.path.split("?", 1)[1] if "?" in self.path else "")
return self._redirect("/challenge.html?login=ok", RC.cookie_for(name)) if name else self._redirect("/challenge.html?login=" + err)
if p == "/logout":
return self._redirect("/challenge.html", "rt_user=; Path=/; Max-Age=0; Secure; SameSite=None")
if p == "/api/rt/me":
return self._json(200, {"user": RC.user_from(self.headers)})
if p == "/api/rt/leaderboard":
return self._json(200, RC.board_info())
if p.startswith("/api/agx/"):
return self._json(404, {"error": "not available in the challenge"})
if p.startswith("/api/ag/") or p.startswith("/api/agx/"):
x = p.startswith("/api/agx/")
name = p[9:] if x else p[8:]
q = ("?" + self.path.split("?", 1)[1]) if (name in ("browser/img", "browser/res") and "?" in self.path) else ""
return self._proxy(name, base=BACKEND2 if x else None, query=q) if name in GET_OK else self._json(404, {"error": "not found"})
f = "challenge.html" if p == "/" else p.lstrip("/")
if f == "demo/poisoned-page":
b = open("demo_poisoned_page.html", "rb").read()
self.send_response(200); self.send_header("Content-Type", "text/html; charset=utf-8"); self.send_header("Content-Length", str(len(b))); self.end_headers(); self.wfile.write(b)
return
if f not in STATIC:
return self._json(404, {"error": "not found"})
self.path = "/" + f
return super().do_GET()
def do_POST(self):
p = self.path.split("?")[0]
if p == "/api/rt/submit":
u = RC.user_from(self.headers)
if not u:
return self._json(401, {"error": "sign in with Hugging Face first"})
n = int(self.headers.get("Content-Length", 0) or 0)
if n > 16384:
return self._json(413, {"error": "too large"})
try:
req = json.loads(self.rfile.read(n) or b"{}")
except ValueError:
return self._json(400, {"error": "bad json"})
code, out = RC.submit(u, req)
return self._json(code, out)
if (p.startswith("/api/ag/") or p.startswith("/api/agx/")) and p != "/api/ag/session/start" and not RC.user_from(self.headers):
return self._json(401, {"error": "sign in with Hugging Face to take part"})
x = False # challenge build: no in-weights GPU backend
name = p[8:] if p.startswith("/api/ag/") else ""
if name not in POST_OK:
return self._json(404, {"error": "not found"})
ip = (self.headers.get("X-Forwarded-For") or self.client_address[0]).split(",")[0].strip()
if limited(ip):
return self._json(429, {"error": "rate limit"})
n = int(self.headers.get("Content-Length", 0) or 0)
if n > (700000 if name == "store/submit" else 4096):
return self._json(413, {"error": "too large"})
try:
req = json.loads(self.rfile.read(n) or b"{}")
except ValueError:
return self._json(400, {"error": "bad json"})
if "message" in req:
req["message"] = str(req["message"])[:500]
if x and not BACKEND2:
return self._json(503, {"error": "in-weights backend not configured"})
if x and name in ("kill", "resume"):
x = False # visitor KILL/RESUME is per session; the in-weights kernel is never halted globally by a visitor
self._proxy(name, json.dumps(req).encode(), base=BACKEND2 if x else None)
def end_headers(self):
self.send_header("X-Content-Type-Options", "nosniff")
super().end_headers()
def log_message(self, *a):
pass
if __name__ == "__main__":
os.chdir(os.path.dirname(os.path.abspath(__file__)))
ThreadingHTTPServer(("0.0.0.0", int(os.environ.get("PORT", "7860"))), H).serve_forever()