| """Cybersecurity: log forensics, config deobfuscation, firewall rule evaluation.""" |
|
|
| import base64 |
| import hashlib |
| import ipaddress |
| import json |
| import zlib |
|
|
| from ..grading import TaskInstance, exact, norm, parts_score, token_set |
|
|
| USERS = ["root", "admin", "deploy", "backup", "git", "ubuntu", "oracle", "postgres", "jenkins", "svc_ci"] |
|
|
|
|
| def _ip(rng): |
| return f"{rng.choice([45, 61, 91, 103, 141, 185, 193, 203])}.{rng.randint(0, 255)}.{rng.randint(0, 255)}.{rng.randint(1, 254)}" |
|
|
|
|
| def ssh_bruteforce(rng, level=1) -> TaskInstance: |
| if level >= 2: |
| return _ssh_subnet(rng) |
| threshold = rng.randint(5, 10) |
| window = rng.choice([10, 15, 30]) |
| events = [] |
|
|
| def burst(ip, start, count, users): |
| t = start |
| for _ in range(count): |
| t += rng.randint(2, 40) |
| events.append((t, ip, rng.choice(users), False)) |
| return t |
|
|
| attacker, victim = _ip(rng), rng.choice(USERS) |
| t = burst(attacker, rng.randint(3600, 60000), threshold + rng.randint(0, 6), [victim, "root", "admin"]) |
| events.append((t + rng.randint(5, 50), attacker, victim, True)) |
| for _ in range(rng.randint(2, 4)): |
| burst(_ip(rng), rng.randint(0, 80000), rng.randint(threshold, threshold + 20), USERS) |
| slow = _ip(rng) |
| t = rng.randint(0, 20000) |
| for _ in range(threshold + 2): |
| t += window * 60 // (threshold - 2) + rng.randint(30, 300) |
| events.append((t, slow, "deploy", False)) |
| events.append((t + 60, slow, "deploy", True)) |
| for _ in range(rng.randint(8, 20)): |
| ip, user = f"10.0.{rng.randint(0, 9)}.{rng.randint(2, 250)}", rng.choice(USERS[2:]) |
| t = rng.randint(60, 86000) |
| if rng.random() < 0.4: |
| events.append((t - 20, ip, user, False)) |
| events.append((t, ip, user, True)) |
| events.sort() |
| lines = [] |
| for sec, ip, user, ok in events: |
| sec %= 86400 |
| stamp = f"Oct 7 {sec // 3600:02d}:{sec % 3600 // 60:02d}:{sec % 60:02d}" |
| pid = rng.randint(1000, 65000) |
| if ok: |
| lines.append(f"{stamp} bastion sshd[{pid}]: Accepted password for {user} from {ip} port {rng.randint(30000, 65000)} ssh2") |
| else: |
| lines.append(f"{stamp} bastion sshd[{pid}]: Failed password for {'invalid user ' if rng.random() < 0.3 else ''}{user} from {ip} port {rng.randint(30000, 65000)} ssh2") |
| rule = (f"INCIDENT RULE: an IP is a confirmed compromise when it has at least {threshold} failed " |
| f"password attempts within any {window}-minute window and then an accepted login.\n") |
| return TaskInstance( |
| instruction=("auth.log is one day of sshd logs; incident_rule.txt defines a confirmed " |
| "compromise. Answer the attacking IP and the account it logged in as, " |
| "ip,username. Each part is worth 0.5."), |
| files={"auth.log": "\n".join(lines) + "\n", "incident_rule.txt": rule}, |
| grade=lambda a: parts_score(a, [exact(attacker), exact(victim)]), |
| oracle=f"{attacker},{victim}", |
| wrong=[f"{slow},deploy"], |
| ) |
|
|
|
|
| TLDS = ["example", "invalid", "test"] |
|
|
|
|
| def decode_config(rng, level=1) -> TaskInstance: |
| if level >= 2: |
| return _decode_layered(rng) |
| def host(): |
| return "".join(rng.choice("bcdfghjklmnpqrstvwxz") + rng.choice("aeiou") for _ in range(rng.randint(3, 5))) \ |
| + "." + rng.choice(["cdn", "api", "sync", "edge"]) + "." + rng.choice(TLDS) |
|
|
| primary, fallback = host(), host() |
| key = bytes(rng.randint(1, 255) for _ in range(rng.randint(4, 9))) |
| offset = rng.randint(1, 7) |
| reverse = rng.random() < 0.5 |
|
|
| def encode(obj): |
| raw = json.dumps(obj).encode() |
| if reverse: |
| raw = raw[::-1] |
| out = bytes(b ^ key[(i + offset) % len(key)] for i, b in enumerate(raw)) |
| return base64.b64encode(out).decode() |
|
|
| cfg = {"c2": f"https://{primary}/{rng.choice(['beacon', 'gate', 'poll'])}", "sleep": rng.randint(10, 300), |
| "jitter": rng.randint(5, 40)} |
| fb = {"c2": f"https://{fallback}/{rng.choice(['beacon', 'gate'])}", "sleep": rng.randint(10, 300)} |
| source = f'''"""Sample recovered from a lab honeypot (defanged: nothing here runs on import).""" |
| import base64 |
| import json |
| |
| KEY = bytes({list(key)}) |
| OFFSET = {offset} |
| |
| PRIMARY = "{encode(cfg)}" |
| FALLBACK = "{encode(fb)}" |
| |
| |
| def unpack(blob): |
| data = base64.b64decode(blob) |
| plain = bytes(b ^ KEY[(i + OFFSET) % len(KEY)] for i, b in enumerate(data)) |
| {"plain = plain[::-1]" if reverse else "pass"} |
| return json.loads(plain) |
| ''' |
| return TaskInstance( |
| instruction=("loader.py holds two encoded configs. Which hostname does the PRIMARY config " |
| "contact? Answer the hostname only, without scheme or path."), |
| files={"loader.py": source}, |
| grade=lambda a: float(norm(a).removeprefix("https://").split("/")[0] == primary), |
| oracle=primary, |
| wrong=[fallback], |
| ) |
|
|
|
|
| def firewall_rules(rng, level=1) -> TaskInstance: |
| if level >= 2: |
| return _firewall_chains(rng) |
| rules = [] |
| nets = ["10.0.0.0/8", "10.1.0.0/16", "10.1.2.0/24", "192.168.0.0/16", "172.16.0.0/12", |
| "203.0.113.0/24", "198.51.100.0/24", "0.0.0.0/0"] |
| ports = [(22, 22), (80, 80), (443, 443), (5432, 5432), (8000, 8999), (1, 1023), (3389, 3389), (1, 65535)] |
| for i in range(rng.randint(7, 11)): |
| lo, hi = rng.choice(ports) |
| rules.append({"id": f"R{10 * (i + 1)}", "action": rng.choice(["allow", "deny"]), |
| "proto": rng.choice(["tcp", "tcp", "udp", "any"]), "src": rng.choice(nets), |
| "ports": (lo, hi)}) |
|
|
| def verdict(ip, proto, port): |
| for r in rules: |
| if (r["proto"] in ("any", proto) and ipaddress.ip_address(ip) in ipaddress.ip_network(r["src"]) |
| and r["ports"][0] <= port <= r["ports"][1]): |
| return r["action"] |
| return "deny" |
|
|
| conns, allowed = [], set() |
| for i in range(rng.randint(15, 25)): |
| net = ipaddress.ip_network(rng.choice(nets[:-1] + ["8.8.0.0/16"])) |
| ip = str(net.network_address + rng.randint(1, min(net.num_addresses - 2, 70000))) |
| proto = rng.choice(["tcp", "tcp", "udp"]) |
| lo, hi = rng.choice(ports) |
| port = rng.randint(lo, min(hi, lo + 200)) |
| cid = f"c{i + 1:02d}" |
| conns.append([cid, ip, proto, port]) |
| if verdict(ip, proto, port) == "allow": |
| allowed.add(cid) |
| denied = sorted({c[0] for c in conns} - allowed) |
| if len(allowed) < 2 or len(denied) < 2: |
| return firewall_rules(rng) |
| text = ["# id action proto src_cidr dst_ports (evaluated top to bottom; first match wins)"] |
| text += [f"{r['id']} {r['action']} {r['proto']} {r['src']} {r['ports'][0]}-{r['ports'][1]}" for r in rules] |
| text.append("# no rule matched -> deny") |
| oracle = ",".join(sorted(allowed)) or "none" |
| target = token_set(oracle) |
| return TaskInstance( |
| instruction=("Evaluate each connection in connections.csv against rules.txt. Answer the ids " |
| "of all allowed connections, comma-separated ascending (e.g. c02,c07), or none."), |
| files={"rules.txt": "\n".join(text) + "\n", |
| "connections.csv": "id,src_ip,proto,dst_port\n" + "\n".join(",".join(map(str, c)) for c in conns) + "\n"}, |
| grade=lambda a: float(token_set(a) == target), |
| oracle=oracle, |
| wrong=[",".join(sorted(allowed)[1:]), ",".join(sorted(allowed | {denied[0]}))], |
| ) |
|
|
|
|
| def _syslog(sec, host, msg): |
| return f"Oct {7 + sec // 86400} {sec % 86400 // 3600:02d}:{sec % 3600 // 60:02d}:{sec % 60:02d} {host} {msg}" |
|
|
|
|
| def _ssh_subnet(rng) -> TaskInstance: |
| """Failures spread over several IPs of one /24; logs split across a rotated file.""" |
| threshold = rng.randint(8, 14) |
| window = rng.choice([10, 15, 20]) |
| net = f"{rng.choice([45, 91, 141, 185, 193])}.{rng.randint(0, 255)}.{rng.randint(0, 255)}" |
| victim = rng.choice(USERS) |
| events = [] |
| t = rng.randint(30000, 70000) |
| ips = [f"{net}.{h}" for h in rng.sample(range(2, 250), rng.randint(3, 5))] |
| for _ in range(threshold + rng.randint(0, 4)): |
| t += rng.randint(5, max(6, window * 60 // (threshold + 4))) |
| events.append((t, rng.choice(ips), rng.choice([victim, "root", "admin"]), False)) |
| winner = rng.choice(ips) |
| events.append((t + rng.randint(10, 60), winner, victim, True)) |
| for _ in range(rng.randint(2, 4)): |
| ip, t2 = _ip(rng), rng.randint(0, 80000) |
| for _ in range(rng.randint(threshold, threshold + 15)): |
| t2 += rng.randint(2, 30) |
| events.append((t2, ip, rng.choice(USERS), False)) |
| other = f"{rng.choice([61, 103, 203])}.{rng.randint(0, 255)}.{rng.randint(0, 255)}" |
| t3 = rng.randint(0, 20000) |
| for _ in range(threshold + 3): |
| t3 += window * 60 // max(1, threshold - 3) + rng.randint(30, 200) |
| events.append((t3, f"{other}.{rng.randint(2, 250)}", "deploy", False)) |
| events.append((t3 + 30, f"{other}.{rng.randint(2, 250)}", "deploy", True)) |
| for _ in range(rng.randint(10, 25)): |
| ip, user, t4 = f"10.0.{rng.randint(0, 9)}.{rng.randint(2, 250)}", rng.choice(USERS[2:]), rng.randint(60, 86000) |
| if rng.random() < 0.4: |
| events.append((t4 - 20, ip, user, False)) |
| events.append((t4, ip, user, True)) |
| events.sort() |
| lines = [] |
| for sec, ip, user, ok in events: |
| pid = rng.randint(1000, 65000) |
| verb = f"Accepted password for {user}" if ok else f"Failed password for {'invalid user ' if rng.random() < 0.3 else ''}{user}" |
| lines.append(_syslog(sec, "bastion", f"sshd[{pid}]: {verb} from {ip} port {rng.randint(30000, 65000)} ssh2")) |
| burst_mid = sorted(e[0] for e in events if e[1].startswith(net + ".")) |
| cut_time = burst_mid[len(burst_mid) // 2] |
| older = [ln for (sec, *_r), ln in zip(events, lines) if sec < cut_time] |
| newer = [ln for (sec, *_r), ln in zip(events, lines) if sec >= cut_time] |
| rule = (f"INCIDENT RULE: failures are counted per /24 network (the first three octets). A network is " |
| f"a confirmed compromise when it has at least {threshold} failed password attempts within " |
| f"any {window}-minute window and then an accepted login from any address in it. Logs rotate: " |
| "auth.log.1 holds the older lines.\n") |
| return TaskInstance( |
| instruction=("auth.log.1 and auth.log are one day of sshd logs; incident_rule.txt defines a " |
| "confirmed compromise. Answer the compromised network as a.b.c.0/24, the exact address " |
| "that logged in, and the account, network,ip,username. Each part counts equally."), |
| files={"auth.log.1": "\n".join(older) + "\n", "auth.log": "\n".join(newer) + "\n", |
| "incident_rule.txt": rule}, |
| grade=lambda a: parts_score(a, [exact(f"{net}.0/24"), exact(winner), exact(victim)]), |
| oracle=f"{net}.0/24,{winner},{victim}", |
| wrong=[f"{other}.0/24,{winner},deploy"], |
| ) |
|
|
|
|
| def _decode_layered(rng) -> TaskInstance: |
| """base64 -> rotating XOR keyed by sha256(passphrase) -> zlib; the active profile is in a config file.""" |
| def host(): |
| return "".join(rng.choice("bcdfghjklmnpqrstvwxz") + rng.choice("aeiou") for _ in range(rng.randint(3, 5))) \ |
| + "." + rng.choice(["cdn", "api", "sync", "edge"]) + "." + rng.choice(TLDS) |
|
|
| names = rng.sample(["alpha", "beta", "gamma", "delta"], 3) |
| hosts = {n: host() for n in names} |
| active = rng.choice(names) |
| passphrase = "".join(rng.choice("abcdefghijkmnpqrstuvwxyz23456789") for _ in range(12)) |
| key = hashlib.sha256(passphrase.encode()).digest()[: rng.randint(6, 12)] |
|
|
| def encode(obj): |
| raw = zlib.compress(json.dumps(obj).encode()) |
| return base64.b64encode(bytes(b ^ key[i % len(key)] for i, b in enumerate(raw))).decode() |
|
|
| blobs = {n: encode({"c2": f"https://{hosts[n]}/{rng.choice(['beacon', 'gate', 'poll'])}", |
| "sleep": rng.randint(10, 300)}) for n in names} |
| source = f'''"""Sample recovered from a lab honeypot (defanged: nothing here runs on import).""" |
| import base64 |
| import configparser |
| import hashlib |
| import json |
| import zlib |
| |
| PROFILES = {json.dumps(blobs, indent=4)} |
| |
| |
| def _key(cfg): |
| phrase = cfg["loader"]["passphrase"] |
| return hashlib.sha256(phrase.encode()).digest()[: int(cfg["loader"]["key_len"])] |
| |
| |
| def unpack(blob, key): |
| data = base64.b64decode(blob) |
| return json.loads(zlib.decompress(bytes(b ^ key[i % len(key)] for i, b in enumerate(data)))) |
| |
| |
| def active(path="loader.ini"): |
| cfg = configparser.ConfigParser() |
| cfg.read(path) |
| return unpack(PROFILES[cfg["loader"]["profile"]], _key(cfg)) |
| ''' |
| ini = (f"[loader]\n; profile selects one entry of PROFILES\nprofile = {active}\n" |
| f"passphrase = {passphrase}\nkey_len = {len(key)}\n") |
| return TaskInstance( |
| instruction=("loader.py and loader.ini come from a recovered sample. Which hostname does the " |
| "profile selected in loader.ini contact? Answer the hostname only, without scheme or path."), |
| files={"loader.py": source, "loader.ini": ini}, |
| grade=lambda a: float(norm(a).removeprefix("https://").split("/")[0] == hosts[active]), |
| oracle=hosts[active], |
| wrong=[hosts[n] for n in names if n != active], |
| ) |
|
|
|
|
| def _firewall_chains(rng) -> TaskInstance: |
| """First-match rules with user chains (jump/return) and a default policy.""" |
| nets = ["10.0.0.0/8", "10.1.0.0/16", "10.1.2.0/24", "192.168.0.0/16", "172.16.0.0/12", |
| "203.0.113.0/24", "198.51.100.0/24", "0.0.0.0/0"] |
| ports = [(22, 22), (80, 80), (443, 443), (5432, 5432), (8000, 8999), (1, 1023), (3389, 3389), (1, 65535)] |
|
|
| def rule(i, actions): |
| lo, hi = rng.choice(ports) |
| return {"id": f"R{i}", "action": rng.choice(actions), "proto": rng.choice(["tcp", "tcp", "udp", "any"]), |
| "src": rng.choice(nets), "ports": (lo, hi)} |
|
|
| chains = {"MGMT": [rule(100 + i, ["allow", "deny", "return"]) for i in range(rng.randint(3, 5))], |
| "WEB": [rule(200 + i, ["allow", "deny", "return"]) for i in range(rng.randint(3, 5))]} |
| main = [rule(10 * (i + 1), ["allow", "deny", "jump MGMT", "jump WEB"]) for i in range(rng.randint(6, 9))] |
| policy = rng.choice(["deny", "allow"]) |
|
|
| def matches(r, ip, proto, port): |
| return (r["proto"] in ("any", proto) and ipaddress.ip_address(ip) in ipaddress.ip_network(r["src"]) |
| and r["ports"][0] <= port <= r["ports"][1]) |
|
|
| def run(chain, ip, proto, port): |
| for r in chain: |
| if not matches(r, ip, proto, port): |
| continue |
| if r["action"] in ("allow", "deny"): |
| return r["action"] |
| if r["action"] == "return": |
| return None |
| verdict = run(chains[r["action"].split()[1]], ip, proto, port) |
| if verdict: |
| return verdict |
| return None |
|
|
| conns, allowed = [], set() |
| for i in range(rng.randint(18, 28)): |
| net = ipaddress.ip_network(rng.choice(nets[:-1] + ["8.8.0.0/16"])) |
| ip = str(net.network_address + rng.randint(1, min(net.num_addresses - 2, 70000))) |
| proto = rng.choice(["tcp", "tcp", "udp"]) |
| lo, hi = rng.choice(ports) |
| port = rng.randint(lo, min(hi, lo + 200)) |
| cid = f"c{i + 1:02d}" |
| conns.append([cid, ip, proto, port]) |
| if (run(main, ip, proto, port) or policy) == "allow": |
| allowed.add(cid) |
| denied = sorted({c[0] for c in conns} - allowed) |
| if len(allowed) < 2 or len(denied) < 2: |
| return _firewall_chains(rng) |
|
|
| def fmt(r): |
| return f"{r['id']} {r['action'].replace(' ', ':')} {r['proto']} {r['src']} {r['ports'][0]}-{r['ports'][1]}" |
| text = ["# chain INPUT (evaluated top to bottom; first matching allow/deny decides)"] |
| text += [fmt(r) for r in main] |
| text.append(f"# INPUT default policy: {policy}") |
| for name, chain in chains.items(): |
| text.append(f"# chain {name}: jump:{name} evaluates it; return or reaching its end goes back to the rule after the jump") |
| text += [fmt(r) for r in chain] |
| oracle = ",".join(sorted(allowed)) |
| target = token_set(oracle) |
| return TaskInstance( |
| instruction=("Evaluate each connection in connections.csv against rules.txt (chains, jumps and " |
| "the default policy). Answer the ids of all allowed connections, comma-separated " |
| "ascending (e.g. c02,c07)."), |
| files={"rules.txt": "\n".join(text) + "\n", |
| "connections.csv": "id,src_ip,proto,dst_port\n" + "\n".join(",".join(map(str, c)) for c in conns) + "\n"}, |
| grade=lambda a: float(token_set(a) == target), |
| oracle=oracle, |
| wrong=[",".join(sorted(allowed)[1:]), ",".join(sorted(allowed | {denied[0]}))], |
| ) |
|
|
|
|
| TASKS = { |
| "sec-ssh-bruteforce": ssh_bruteforce, |
| "sec-decode-config": decode_config, |
| "sec-firewall-rules": firewall_rules, |
| } |
|
|
