Spaces:
Running
Running
File size: 10,176 Bytes
4164307 c03c652 4164307 c03c652 5695092 4164307 087ff0f 4164307 c03c652 4164307 c03c652 087ff0f c03c652 4164307 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 | """Master side. Active only on the official Space (VIKERNEL_MASTER=1 and a token that can read the private DB).
What the master controls for every copy of the scanner, including clones:
- the check set (served per request, never shipped in the code)
- the policy (on/off, minimum client version, blocked hosts, notice)
- who scanned: the Hugging Face account and email behind every request
- the official badge (only the master issues badge ids)
"""
import hashlib, hmac, json, os, secrets, threading, time, urllib.error, urllib.request
ENABLED = os.environ.get("VIKERNEL_MASTER") == "1" and bool(os.environ.get("HF_TOKEN"))
DB_REPO = os.environ.get("VIKERNEL_DB_REPO", "FINAL-Bench/vikernel-scanner-db")
BADGE_KEY = (os.environ.get("BADGE_KEY") or secrets.token_hex(16)).encode()
PER_USER_HOUR = int(os.environ.get("MASTER_CHECKS_PER_HOUR", "30"))
REFERENCE_USERS = {u.strip().lower() for u in os.environ.get("REFERENCE_USERS", "SeaWolf-AI,FINAL-Bench").split(",")}
_board = {"t": 0}
if ENABLED: # import once, here: importing it first inside the flush thread races with the main thread
from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download
_ids, _db, _pending, _hits, _badges = {}, {"t": 0}, {}, {}, {}
_lock = threading.Lock()
class Refuse(Exception):
def __init__(self, code, msg):
super().__init__(msg); self.code, self.msg = code, msg
def _api():
return HfApi(token=os.environ["HF_TOKEN"])
def _get(path):
return json.load(open(hf_hub_download(DB_REPO, path, repo_type="dataset", token=os.environ["HF_TOKEN"], force_download=True), encoding="utf-8"))
def _load_db():
if time.time() - _db["t"] > 300:
try:
_db.update(policy=_get("policy.json"), free=_get("checkset/free.json"), t=time.time())
except Exception: # noqa: BLE001 keep the last good copy; refuse only if there never was one
if "free" not in _db:
raise Refuse(503, "The check database is not available right now.")
return _db
def _identity(token):
"""Hugging Face account behind a token: OAuth tokens via userinfo, user access tokens via whoami-v2."""
if not token:
raise Refuse(401, "Sign in with Hugging Face first.")
key = hashlib.sha256(token.encode()).hexdigest()
c = _ids.get(key)
if c and time.time() - c["t"] < 600:
return c
for url, name_k in (("https://huggingface.co/oauth/userinfo", "preferred_username"), ("https://huggingface.co/api/whoami-v2", "name")):
try:
j = json.loads(urllib.request.urlopen(urllib.request.Request(url, headers={"Authorization": "Bearer " + token}), timeout=15).read())
except (urllib.error.URLError, ValueError, TimeoutError):
continue
if j.get(name_k):
c = {"user": j[name_k], "email": j.get("email"), "verified": bool(j.get("email_verified") or j.get("emailVerified")), "t": time.time()}
_ids[key] = c
if len(_ids) > 5000:
_ids.clear()
return c
raise Refuse(401, "Hugging Face sign-in could not be verified. Sign in again.")
def _ver(v):
try:
return tuple(int(x) for x in str(v).split(".")[:3])
except ValueError:
return (0,)
def _queue(path, obj):
with _lock:
_pending[path] = json.dumps(obj, ensure_ascii=False, indent=1).encode()
def _flush_loop():
while True:
time.sleep(60)
with _lock:
ops = dict(_pending); _pending.clear()
if not ops:
continue
try:
_api().create_commit(DB_REPO, [CommitOperationAdd(p, b) for p, b in ops.items()], commit_message="scanner activity", repo_type="dataset")
except Exception: # noqa: BLE001 put them back and try again next round
with _lock:
for p, b in ops.items():
_pending.setdefault(p, b)
def _record_user(idn, host, version):
path = "users/%s.json" % idn["user"]
now = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
rec = _ids.get("rec:" + idn["user"])
if rec is None:
try:
rec = _get(path)
except Exception: # noqa: BLE001
rec = {"user": idn["user"], "first_seen": now, "scans": 0, "hosts": []}
rec.update(email=idn.get("email") or rec.get("email"), email_verified=idn.get("verified"), last_seen=now, client=version)
if host not in rec["hosts"]:
rec["hosts"] = (rec["hosts"] + [host])[-20:]
_ids["rec:" + idn["user"]] = rec
_queue(path, rec)
return rec
def _gate(token, host, version):
db = _load_db(); pol = db["policy"]; idn = _identity(token)
if not pol.get("enabled", True):
raise Refuse(503, (pol.get("notice") or {}).get("en") or "The scanner is paused by the maintainers.")
if host in pol.get("blocked_hosts", []):
raise Refuse(403, "This copy of the scanner is not allowed to use the ViKernel database.")
if _ver(version) < _ver(pol.get("min_client", "0")):
raise Refuse(426, "This scanner copy is out of date. Update it from github.com/final-bench/vikernel-scanner (minimum %s)." % pol.get("min_client"))
now = time.time(); h = [t for t in _hits.get(idn["user"], []) if now - t < 3600]
if len(h) >= PER_USER_HOUR:
raise Refuse(429, "Hourly scan limit reached for this account. Try again later.")
h.append(now); _hits[idn["user"]] = h
return db, pol, idn
def handle(path, token, host, version, body=None):
"""Returns a JSON-able dict. Raises Refuse(code, message)."""
if path == "/api/master/board": # public
return board()
if path == "/api/master/catalog": # public: what is checked, without the check text
db = _load_db(); cs = db["free"]
pol = db["policy"]
return {"db_version": cs.get("version"), "controls": len(cs.get("controls", [])), "inventory": pol.get("inventory"),
"checks": [{k: c.get(k) for k in ("id", "domain", "stage", "rule", "title")} for c in cs.get("checks", [])]}
if path == "/api/master/checks":
db, pol, idn = _gate(token, host, version)
rec = _record_user(idn, host, version)
return {"checkset": db["free"], "user": idn["user"], "has_email": bool(rec.get("email")),
"policy": {"notice": pol.get("notice"), "latest_client": pol.get("latest_client"), "db_version": db["free"].get("version")}}
if path == "/api/master/report":
idn = _identity(token)
b = body or {}
bid = secrets.token_hex(6)
day = time.strftime("%Y-%m-%d", time.gmtime())
ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) # full-second stamp so the board keeps the newest scan, not a random id
rec = {"id": bid, "user": idn["user"], "host": host, "client": version, "date": day, "ts": ts, "model": str(b.get("model", ""))[:120],
"grade": str(b.get("grade", "?"))[:1], "depth": b.get("depth"), "counts": b.get("counts"), "db_version": b.get("db_version"),
"domains": {k: (v or {}).get("grade") for k, v in (b.get("domains") or {}).items()},
"hit_checks": b.get("hit_checks"), "checks": b.get("checks"), "controls": b.get("controls"), "firewall": b.get("firewall"),
"reference": idn["user"].lower() in REFERENCE_USERS}
rec["sig"] = hmac.new(BADGE_KEY, json.dumps([bid, rec["model"], rec["grade"], day]).encode(), hashlib.sha256).hexdigest()[:24]
_badges[bid] = rec
_queue("scans/%s/%s.json" % (day, bid), rec)
u = _ids.get("rec:" + idn["user"])
if u:
u["scans"] = int(u.get("scans", 0)) + 1; _queue("users/%s.json" % idn["user"], u)
return {"badge": {"id": bid, "grade": rec["grade"], "url": "https://final-bench-vikernel-scanner.hf.space/badge/%s.svg" % bid}}
raise Refuse(404, "not found")
def flush_now():
"""Write pending records at once (used by batch runs that exit right after)."""
with _lock:
ops = dict(_pending); _pending.clear()
if ops:
_api().create_commit(DB_REPO, [CommitOperationAdd(p, b) for p, b in ops.items()], commit_message="scanner activity", repo_type="dataset")
def board():
"""Public results: the latest scan of each model. No account names or emails, only whether it is a VIDRAFT reference scan."""
if time.time() - _board["t"] < 300:
return _board["v"]
recs = list(_badges.values())
try:
have = {r["id"] for r in recs}
files = sorted((f for f in _api().list_repo_files(DB_REPO, repo_type="dataset") if f.startswith("scans/") and f.endswith(".json")), reverse=True)[:400]
for f in files:
bid = f.rsplit("/", 1)[1][:-5]
if bid not in have:
r = _get(f); _badges[bid] = r; recs.append(r); have.add(bid)
except Exception: # noqa: BLE001
pass
latest = {}
# Newest scan per model wins. Sort by the full timestamp; older records that predate the ts field
# carry only a day, which sorts before any same-day ts, so a newer stamped scan always supersedes them.
for r in sorted(recs, key=lambda r: (r.get("ts") or r.get("date", ""), r.get("id", ""))):
if r.get("model") and r.get("checks"):
latest[r["model"]] = r
keep = ("id", "model", "grade", "depth", "domains", "hit_checks", "checks", "controls", "date", "reference", "db_version", "firewall")
v = {"models": sorted(({k: r.get(k) for k in keep} for r in latest.values()), key=lambda r: ("ABCDF".find(r.get("grade") or "F"), r.get("hit_checks") or 0)),
"scans": len(recs)}
_board.update(v=v, t=time.time())
return v
def badge(bid):
"""Official badge record for an id, or None."""
if not all(c in "0123456789abcdef" for c in bid) or len(bid) != 12:
return None
if bid in _badges:
return _badges[bid]
try:
for f in _api().list_repo_files(DB_REPO, repo_type="dataset"):
if f.endswith("/%s.json" % bid):
_badges[bid] = _get(f); return _badges[bid]
except Exception: # noqa: BLE001
return None
return None
if ENABLED:
threading.Thread(target=_flush_loop, daemon=True).start()
|