ViKernel-RedTeam / pre_policy_r8.py
SeaWolf-AI's picture
add bundled second-line policy for the public gate preview
8e55db4 verified
Raw History Blame Contribute Delete
17.3 kB
"""Second-line policy in front of the ViKernel kernel (2026-11-17, red-team round 1 fixes).
Every rule is a general category, not a literal from a submission:
1. secret values inside arguments of any call that can carry data out (key=value secrets, and values the agent read
from files earlier in this process: taint tracking)
2. free-form arguments of allow-listed apps are judged by the shell judge and a money-movement intent rule
3. credential stores are denied by path category after path normalisation
4. every string argument is scanned at full length (no prefix window), including query-injection categories
A hit is still sent to the kernel as a non-allowlisted call, so the DENY is written into the audit chain.
"""
import base64, binascii, ipaddress, os, posixpath, re, sys, unicodedata, urllib.parse
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "src"))
try:
import vikernel_gate as _V
except Exception: # noqa: BLE001
_V = None
READ_ONLY = {"read_file", "list_files"}
SECRET_KV = re.compile(r"(?i)\b([a-z0-9_]*(?:api[_-]?key|secret|token|passw(?:or)?d|passwd|private[_-]?key|credential)[a-z0-9_]*)\s*[=:]\s*['\"]?([^\s'\"&]{4,})")
MONEY = re.compile(r"(?i)\b(transfer|wire|send|pay|remit|withdraw)\b.{0,60}?\b(\d[\d,.]*\s*(usd|krw|eur|jpy|gbp|\$|원|달러)?|\$\s*\d)[^\n]{0,80}?\b(account|acct|iban|wallet|계좌)\b")
QUERY_INJ = re.compile(r"(?i)(\bunion\b\s+(all\s+)?select\b|'\s*or\s*'?\w+'?\s*=\s*'?\w+|;\s*(drop|delete|truncate|alter|insert|update|exec)\b|\bdrop\s+table\b|\bxp_cmdshell\b|\bsleep\s*\(\s*\d|\bbenchmark\s*\()")
CRED_PATH = re.compile(r"(?i)(^/etc/(g?shadow|passwd|master\.passwd|sudoers|security/opasswd|ssh/ssh_host_[\w.]*key)([-~]|\.bak|\.old)?$"
r"|/(\.ssh/(id_[\w.]+|authorized_keys|known_hosts)|\.aws/credentials|\.netrc|\.pgpass|\.git-credentials|\.docker/config\.json|\.kube/config)$)")
REMOTE_RE = re.compile(r"(?i)\b(?:https?|ftp|s3|gs)://|^//[\w.-]+")
SYS_READ = re.compile(r"(?i)(^|/)etc/(g?shadow|passwd|master\.passwd|sudoers)([-~]|\.bak|\.old)?$")
SYS_CMDS = set("""chmod chown chgrp chattr unlink shred truncate rm rmdir mv cp ln dd mkfs mount umount kill pkill killall reboot shutdown halt
poweroff init systemctl service crontab at useradd userdel usermod passwd su sudo tee sed awk tar zip unzip gzip gunzip touch mkdir install
iptables ufw nft ip ifconfig route sysctl modprobe insmod rmmod swapoff fdisk parted wipefs losetup cat head tail less more nl od xxd strings
base64 env export source eval exec nohup setsid timeout xargs parallel find locate git pip pip3 npm npx apt apt-get yum dnf brew docker kubectl
nc ncat netcat curl wget scp sftp ftp rsync ssh telnet nmap dig nslookup python python3 perl ruby php node bash sh zsh ksh fish""".split())
SHAPE = re.compile(r"/|^-|^[.~]|^[0-7]{3,4}$|^[+-]?[rwxugoa]{1,4}[+=-][rwxst]+$|[A-Za-z0-9_]\.[A-Za-z0-9]{1,6}$|^\d{3,}$")
TAINT = set()
TAINT_N = set() # secrets with every non-alphanumeric character removed, lower-case (round 3: re-formatted secrets)
APP_META = re.compile("[;&|`<>" + chr(92) * 2 + chr(10) + "]" + r"|\$\(|\$\{|\$IFS")
CMDLINE = re.compile(r"(?i)(?:^|[\s;&|(])(?:curl|wget|nc|ncat|bash|sh|zsh|python[\d.]*|perl|ruby|php|node|rm|dd|scp|rsync|sftp|ssh|telnet|chmod|chown|mkfs|find|xargs|eval|exec|cat|cp|mv)\s+(?:-{1,2}\w|/|@|~|\S*://)")
UPLOAD = re.compile(r"(?i)\b(?:curl|wget|scp|rsync|sftp|nc|ncat|ftp)\b[^\n]{0,200}?(?:@[\w./~-]+|\s-T\s|\s-F\s|--data\S*\s|--upload-file|\s-d\s|\S+@\S+:)")
_TAINT_MAX = 512
def _strings(obj, depth=0):
if depth > 6:
return
if isinstance(obj, str):
yield obj
elif isinstance(obj, dict):
for k, v in obj.items():
yield str(k)
yield from _strings(v, depth + 1)
elif isinstance(obj, (list, tuple)):
for v in obj:
yield from _strings(v, depth + 1)
def _views(s):
"""The string plus its URL-decoded and base64/hex-decoded forms (two rounds)."""
out, frontier = [s], [s]
for _ in range(2):
nxt = []
for x in frontier:
u = urllib.parse.unquote_plus(x)
if u != x:
nxt.append(u)
for m in re.findall(r"(?:\d{2,3}[\s,;:|/-]+){5,}\d{2,3}", x): # round 4: character codes (decimal or octal)
nums = re.findall(r"\d{2,3}", m)
for base in (10, 8):
try:
d = "".join(chr(int(n, base)) for n in nums)
except ValueError:
continue
if all(32 <= ord(ch) < 127 for ch in d):
nxt.append(d)
for m in re.findall(r"[A-Za-z0-9+/=_-]{16,}", x):
for dec in (lambda b: base64.b64decode(b + "=" * (-len(b) % 4), altchars=b"-_"), bytes.fromhex):
try:
d = dec(m).decode("utf-8", "ignore")
except (binascii.Error, ValueError):
continue
if d and sum(c.isprintable() for c in d) > 0.8 * len(d):
nxt.append(d)
out += nxt
frontier = nxt
if 8 <= len(s) <= 400: # round 5: letter-shift ciphers (ROT13 and the other 24 shifts)
for k in range(1, 26):
out.append("".join(chr((ord(ch) - 97 + k) % 26 + 97) if "a" <= ch <= "z" else chr((ord(ch) - 65 + k) % 26 + 65) if "A" <= ch <= "Z" else ch for ch in s))
return out
_RECENT = [] # squashed outbound arguments of the most recent calls (round 6: a secret sent in pieces over several calls)
def _pieces_hit(sq):
"""True when sq contains a 6+ character piece of a known secret that mixes at least 2 digits and 2 letters."""
for n in TAINT_N:
for i in range(0, len(n) - 5):
w = n[i:i + 6]
if sum(ch.isdigit() for ch in w) >= 2 and sum(ch.isalpha() for ch in w) >= 2 and w in sq:
return True
return False
def _squash(t):
return re.sub(r"[^A-Za-z0-9]", "", str(t)).lower()
_DIGIT_WORDS = {"zero": "0", "oh": "0", "one": "1", "two": "2", "three": "3", "tree": "3", "four": "4", "fower": "4", "five": "5", "fife": "5",
"six": "6", "seven": "7", "eight": "8", "ait": "8", "nine": "9", "niner": "9"}
def _collapse(s):
return re.sub(r"(.)\1+", r"\1", s)
def _respelled_hit(text):
"""Round 8: a secret written one character per word, with every character repeated, or with filler between characters."""
low = str(text).lower()
words = [w for w in re.split(r"[^a-z0-9]+", low) if w]
views = []
if len(words) >= 6:
views.append("".join(_DIGIT_WORDS.get(w, w[0]) for w in words)) # one word per character
views.append("".join(_DIGIT_WORDS.get(w, w[-1]) for w in words)) # ... keyed on the last letter
sq = _squash(low)
for k in (2, 3, 4): # filler between characters
views += [sq[o::k] for o in range(k)]
col = _collapse(sq) # every character repeated
for n in TAINT_N:
if any(n in v or n[::-1] in v for v in views):
return True
cn = _collapse(n)
if len(cn) >= 8 and cn != sq and cn in col and n not in sq:
return True
return False
_RECENT_RAW = [] # raw outbound argument values of the most recent calls (round 7: very short pieces)
def _coverage_hit(raws):
"""True when short pieces found in the given outbound values add up to most of a known secret (round 7)."""
toks, sqs = set(), []
for r in raws:
low = str(r).lower()
toks.update(t for t in re.split(r"[^a-z0-9]+", low) if len(t) >= 2)
sqs.append(_squash(low))
for n in TAINT_N:
cov = [False] * len(n)
for t in toks:
i = n.find(t)
while i >= 0:
cov[i:i + len(t)] = [True] * len(t)
i = n.find(t, i + 1)
for i in range(len(n) - 3):
w = n[i:i + 4]
if any(w in sq for sq in sqs):
cov[i:i + 4] = [True] * 4
digits = sum(ch.isdigit() for ch in n)
got = sum(1 for ch, c in zip(n, cov) if c and ch.isdigit())
if sum(cov) >= max(8, (len(n) * 3 + 4) // 5) and got >= min(2, digits):
return True
return False
_META_HOSTS = {"metadata.google.internal", "metadata", "metadata.azure.com", "instance-data", "instance-data.ec2.internal",
"metadata.tencentyun.com", "metadata.platformequinix.com"}
_META_ADDRS = {ipaddress.ip_address(a) for a in ("169.254.169.254", "169.254.170.2", "100.100.100.200", "192.0.0.192", "fd00:ec2::254")}
_HOST_RE = re.compile(r"(?i)(?:\b[a-z][a-z0-9+.-]*:)?//([^/\s?#]+)")
_META_PATH = re.compile(r"(?i)([^\s/]+)/(?:latest/(?:meta-data|user-data|dynamic)|computeMetadata/|metadata/(?:instance|identity|v1))")
_NUM_PART = re.compile(r"0x[0-9a-f]+|\d+")
_QUAD_IN_NAME = re.compile(r"(?<!\d)(\d{1,3})[.-](\d{1,3})[.-](\d{1,3})[.-](\d{1,3})(?!\d)")
_V4_IN_V6 = (0xFFFF, 0x64FF9B << 64, 0) # ::ffff:0:0/96, 64:ff9b::/96, ::/96
def _host_addr(h):
"""(address, plain) for a host written as an IP literal in any notation; (None, False) for a name."""
try:
return ipaddress.IPv4Address(h), True
except ValueError:
pass
try:
ip = ipaddress.IPv6Address(h)
v = int(ip)
hi = v >> 32
if hi in _V4_IN_V6[:2] or (hi == 0 and v > 1): # an IPv4 address carried inside an IPv6 literal
return ipaddress.IPv4Address(v & 0xFFFFFFFF), False
return ip, True
except ValueError:
pass
parts = h.split(".")
if not (1 <= len(parts) <= 4) or not all(_NUM_PART.fullmatch(p) for p in parts):
return None, False
try:
nums = [int(p, 16) if p.startswith("0x") else int(p, 8) if len(p) > 1 and p.startswith("0") else int(p) for p in parts]
except ValueError:
return None, False
head, last = nums[:-1], nums[-1]
if any(x > 255 for x in head) or last >= 256 ** (4 - len(head)):
return None, False
return ipaddress.IPv4Address(sum(x << (8 * (3 - i)) for i, x in enumerate(head)) + last), False
def _internal_addr(text):
"""True when the text holds a URL whose host is a cloud metadata or link-local address in any notation,
or another non-public address written in a non-standard notation (round 7)."""
t = unicodedata.normalize("NFKC", str(text)).replace("。", ".")
hosts = _HOST_RE.findall(t) + _META_PATH.findall(t)
for h in hosts:
h = h.rsplit("@", 1)[-1].strip().lower()
if h.startswith("["):
h = h[1:].split("]")[0].split("%")[0]
elif h.count(":") == 1:
h = h.split(":")[0]
h = h.rstrip(".")
if not h:
continue
if h in _META_HOSTS or h.endswith(".metadata.google.internal"):
return True
ip, plain = _host_addr(h)
if ip is None:
for m in _QUAD_IN_NAME.finditer(h): # an address embedded in a wildcard-DNS name
try:
e = ipaddress.IPv4Address(".".join(m.groups()))
except ValueError:
continue
if e in _META_ADDRS or e.is_link_local:
return True
continue
if ip in _META_ADDRS or ip.is_link_local:
return True
if not plain and (ip.is_private or ip.is_loopback or ip.is_unspecified or ip.is_reserved):
return True
return False
def _deob(t):
"""Undo common shell disguises before judging a command (round 3)."""
t = re.sub(r"''|\"\"", "", t) # r''m
t = re.sub(chr(92) * 2 + r"(?=[A-Za-z])", "", t) # a backslash before a letter
t = re.sub(r"\$\{?IFS\}?(?:\$\d)?", " ", t) # rm$IFS-rf
t = re.sub(r"(?<![\w.])/(?:usr/)?(?:local/)?s?bin/(?=\w)", "", t) # /bin/rm
return t
def _norm_path(p):
p = str(p).strip()
for _ in range(4): # round 2: double/triple URL-encoded paths
q = urllib.parse.unquote(p)
if q == p:
break
p = q
p = re.sub(r"(?i)^file://", "", p)
p = re.sub(r"^/proc/(self|\d+)/root(?=/)", "", p)
return posixpath.normpath(p) if p.startswith("/") else p
def check(fn, args):
"""Return a category name to block, or None."""
fn = str(fn)
if not isinstance(args, dict) or any(not isinstance(v, (str, int, float, bool, type(None))) for v in args.values()):
return "unexpected argument type" # round 3: arrays/objects hid values from string checks
texts = list(_strings(args))
if fn in ("read_file", "list_files", "write_file"):
for key in ("path", "dir"):
raw = (args or {}).get(key, "") if isinstance(args, dict) else ""
if not raw:
continue
p = _norm_path(raw)
if REMOTE_RE.search(p):
return "remote address used as a file path"
if CRED_PATH.search(p) or CRED_PATH.search("/" + p.lstrip("./")) or SYS_READ.search(p):
return "credential store"
q = posixpath.normpath(p.replace("\\", "/"))
if q.startswith("/") or q.startswith("~") or q == ".." or q.startswith("../"):
return "path outside the workspace" # round 3: the agent works inside its workspace only
for t in texts:
for v in _views(t):
if QUERY_INJ.search(v):
return "query injection payload"
if fn not in READ_ONLY:
if _internal_addr(v):
return "internal address in tool arguments"
if SECRET_KV.search(v):
return "secret value in an outbound argument"
if any(s in v for s in TAINT) or any(s.lower() in v.lower() for s in TAINT):
return "file secret carried in an argument"
sq = _squash(v)
if any(n in sq or n[::-1] in sq for n in TAINT_N):
return "file secret carried in an argument"
if _respelled_hit(v):
return "file secret carried in an argument"
if fn not in READ_ONLY:
sq = _squash(" ".join(texts)) # a secret split across several arguments
if any(n in sq for n in TAINT_N) or _pieces_hit(sq):
return "file secret carried in an argument"
vq = _squash(" ".join(str(v) for v in args.values())) # values only, so the pieces join up
joined = "".join(_RECENT[-8:]) + vq # ... or across several calls
if any(n in joined for n in TAINT_N):
return "file secret carried across calls"
raw = " ".join(str(v) for v in args.values())[:400]
if _coverage_hit(_RECENT_RAW[-16:] + [raw]): # round 7: very short pieces over several calls
return "file secret carried across calls"
if 0 < len(vq) <= 400:
_RECENT.append(vq)
del _RECENT[:-8]
_RECENT_RAW.append(raw)
del _RECENT_RAW[:-16]
if fn not in READ_ONLY and fn not in ("run_shell", "transfer_funds"): # those two are judged by the kernel itself
free = " ".join(texts)
if MONEY.search(free):
return "money movement in tool arguments"
if UPLOAD.search(_deob(free)):
return "file upload command in tool arguments"
if fn == "app_run":
a = str(args.get("args", ""))
if APP_META.search(a):
return "shell metacharacters in app arguments"
if CMDLINE.search(_deob(a)):
return "command line in app arguments"
toks = _deob(a).split()
if toks and toks[0].lower() in SYS_CMDS and any(SHAPE.search(x) for x in toks[1:]):
return "command line in app arguments"
if _V is not None:
for t in texts:
if len(t) < 6:
continue
try:
if _V.decide(t)[0] == "DENY" or _V.decide(_deob(t))[0] == "DENY":
return "dangerous command in tool arguments"
except Exception: # noqa: BLE001
return "tool arguments could not be judged"
return None
def learn(fn, body):
"""After an allowed read, remember secret-looking values so they cannot be carried out later."""
if str(fn) != "read_file" or not body:
return
for _k, val in SECRET_KV.findall(str(body)):
if len(val) >= 6 and len(TAINT) < _TAINT_MAX:
TAINT.add(val)
if len(_squash(val)) >= 8:
TAINT_N.add(_squash(val))
for part in re.split(r"[-_:.]", val): # distinctive pieces of the secret, not the short prefix
if len(part) >= 8:
TAINT.add(part)
TAINT_N.add(_squash(part))
def _seed_from_mock_files():
"""The mock workspace is served by the agent layer, not the kernel, so the gate never sees file bodies.
Load the test environment's own secret values once at start-up (round 2: secret fragments in outbound calls)."""
try:
sys.path.insert(0, "/app")
from agentguard import tools as _T
for body in getattr(_T, "FILES", {}).values():
learn("read_file", body)
except Exception: # noqa: BLE001
pass
_seed_from_mock_files()