"""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"(?> 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"(?= 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()