build_items_v1.py

#!/usr/bin/env python3
"""Build GuardBench items. Five shapes per pattern; the delta defines the label.

The guard is always at distance from the sink: a helper above, a decorator, a module constant,
or a branch several lines up. Never the adjacent line.
"""
import json, ast, os, hashlib
from collections import Counter

P = []
def pattern(fn): P.append(fn); return fn

# ---------------------------------------------------------------- patterns
@pattern
def xxe(_):
    cls = "xml external entity"
    head = '''import defusedxml.ElementTree as SAFEET
import xml.etree.ElementTree as ET

def _parse_trusted(blob):
    """Internal feeds only; these come from our own signed bundles."""
    return ET.fromstring(blob)

'''
    none = head + '''def import_feed(request):
    return ET.fromstring(request.body)'''
    covers = head + '''def import_feed(request):
    return SAFEET.fromstring(request.body)'''
    wrong = head + '''def import_feed(request):
    SAFEET.fromstring(request.headers.get("X-Manifest", "<m/>"))
    return ET.fromstring(request.body)'''
    irrelevant = head + '''def import_feed(request):
    if len(request.body) > 2_000_000:
        raise ValueError("feed too large")
    return ET.fromstring(request.body)'''
    elsewhere = head + '''def import_manifest(request):
    return SAFEET.fromstring(request.body)

def import_feed(request):
    return _parse_trusted(request.body)'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def ssti(_):
    cls = "server-side template injection"
    head = '''from jinja2 import Environment, select_autoescape
from jinja2.sandbox import SandboxedEnvironment

SANDBOX = SandboxedEnvironment(autoescape=select_autoescape())
LOOSE = Environment(autoescape=select_autoescape())

'''
    none = head + '''def render_signature(user):
    return LOOSE.from_string(user.signature_template).render(user=user)'''
    covers = head + '''def render_signature(user):
    return SANDBOX.from_string(user.signature_template).render(user=user)'''
    wrong = head + '''def render_signature(user):
    SANDBOX.from_string(user.display_name).render()
    return LOOSE.from_string(user.signature_template).render(user=user)'''
    irrelevant = head + '''def render_signature(user):
    if "<script" in user.signature_template.lower():
        raise ValueError("no script tags")
    return LOOSE.from_string(user.signature_template).render(user=user)'''
    elsewhere = head + '''def render_footer(org):
    return SANDBOX.from_string(org.footer_template).render(org=org)

def render_signature(user):
    return LOOSE.from_string(user.signature_template).render(user=user)'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def redos(_):
    cls = "regular expression denial of service"
    head = '''import re, regex

MAX_PATTERN_LEN = 200

def _compile_bounded(p):
    """regex module supports a match timeout; re does not."""
    return regex.compile(p)

'''
    none = head + '''def search_logs(lines, user_pattern):
    rx = re.compile(user_pattern)
    return [l for l in lines if rx.search(l)]'''
    covers = head + '''def search_logs(lines, user_pattern):
    rx = _compile_bounded(user_pattern)
    return [l for l in lines if rx.search(l, timeout=0.25)]'''
    wrong = head + '''def search_logs(lines, user_pattern, highlight):
    _compile_bounded(highlight)
    rx = re.compile(user_pattern)
    return [l for l in lines if rx.search(l)]'''
    irrelevant = head + '''def search_logs(lines, user_pattern):
    if len(user_pattern) > MAX_PATTERN_LEN:
        raise ValueError("pattern too long")
    rx = re.compile(user_pattern)
    return [l for l in lines if rx.search(l)]'''
    elsewhere = head + '''def search_alerts(rows, user_pattern):
    rx = _compile_bounded(user_pattern)
    return [r for r in rows if rx.search(r, timeout=0.25)]

def search_logs(lines, user_pattern):
    rx = re.compile(user_pattern)
    return [l for l in lines if rx.search(l)]'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def host_header(_):
    cls = "host header injection"
    head = '''TRUSTED_HOSTS = {"app.example.com", "www.example.com"}

def _origin(request):
    host = request.headers.get("Host", "")
    if host not in TRUSTED_HOSTS:
        raise ValueError("untrusted host")
    return "https://" + host

'''
    none = head + '''def send_reset(user, request, token):
    link = "https://" + request.headers["Host"] + "/reset?t=" + token
    mail(user.email, link)'''
    covers = head + '''def send_reset(user, request, token):
    mail(user.email, _origin(request) + "/reset?t=" + token)'''
    wrong = head + '''def send_reset(user, request, token):
    _origin(request)
    link = "https://" + request.headers.get("X-Forwarded-Host", "") + "/reset?t=" + token
    mail(user.email, link)'''
    irrelevant = head + '''def send_reset(user, request, token):
    host = request.headers.get("Host", "")
    if len(host) > 253 or "\\n" in host:
        raise ValueError("malformed host")
    mail(user.email, "https://" + host + "/reset?t=" + token)'''
    elsewhere = head + '''def send_invite(user, request, token):
    mail(user.email, _origin(request) + "/invite?t=" + token)

def send_reset(user, request, token):
    mail(user.email, "https://" + request.headers["Host"] + "/reset?t=" + token)'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def weak_token(_):
    cls = "insecure randomness"
    head = '''import random, secrets

TOKEN_BYTES = 32

def _strong_token():
    return secrets.token_urlsafe(TOKEN_BYTES)

'''
    none = head + '''def new_reset_token(user):
    t = "".join(random.choice("0123456789abcdef") for _ in range(32))
    store(user, t); return t'''
    covers = head + '''def new_reset_token(user):
    t = _strong_token()
    store(user, t); return t'''
    wrong = head + '''def new_reset_token(user):
    _strong_token()
    t = "%d%d" % (int(time.time()), random.randint(0, 10**9))
    store(user, t); return t'''
    irrelevant = head + '''def new_reset_token(user):
    t = "".join(random.choice("0123456789abcdef") for _ in range(64))
    if len(t) < 32:
        raise ValueError("token too short")
    store(user, t); return t'''
    elsewhere = head + '''def new_session_token(user):
    t = _strong_token()
    store(user, t); return t

def new_reset_token(user):
    t = "".join(random.choice("0123456789abcdef") for _ in range(32))
    store(user, t); return t'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def csv_injection(_):
    cls = "formula injection"
    head = '''DANGEROUS_PREFIX = ("=", "+", "-", "@", "\\t", "\\r")

def _neutralise(v):
    s = "" if v is None else str(v)
    return "'" + s if s.startswith(DANGEROUS_PREFIX) else s

'''
    none = head + '''def export_rows(rows, out):
    w = csv.writer(out)
    for r in rows:
        w.writerow([r.name, r.note])'''
    covers = head + '''def export_rows(rows, out):
    w = csv.writer(out)
    for r in rows:
        w.writerow([_neutralise(r.name), _neutralise(r.note)])'''
    wrong = head + '''def export_rows(rows, out):
    w = csv.writer(out)
    for r in rows:
        w.writerow([_neutralise(r.name), r.note])'''
    irrelevant = head + '''def export_rows(rows, out):
    w = csv.writer(out)
    for r in rows:
        w.writerow([html.escape(r.name), html.escape(r.note)])'''
    elsewhere = head + '''def export_summary(rows, out):
    w = csv.writer(out)
    for r in rows:
        w.writerow([_neutralise(r.label)])

def export_rows(rows, out):
    w = csv.writer(out)
    for r in rows:
        w.writerow([r.name, r.note])'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def zip_bomb(_):
    cls = "resource exhaustion"
    head = '''MAX_TOTAL = 200 * 1024 * 1024

def _checked_members(z):
    total = 0
    for info in z.infolist():
        total += info.file_size
        if total > MAX_TOTAL:
            raise ValueError("archive expands too large")
        yield info

'''
    none = head + '''def unpack(path, dest):
    with zipfile.ZipFile(path) as z:
        z.extractall(dest)'''
    covers = head + '''def unpack(path, dest):
    with zipfile.ZipFile(path) as z:
        for info in _checked_members(z):
            z.extract(info, dest)'''
    wrong = head + '''def unpack(path, dest):
    with zipfile.ZipFile(path) as z:
        list(_checked_members(z))
        z.extractall(dest)'''
    irrelevant = head + '''def unpack(path, dest):
    if os.path.getsize(path) > 20 * 1024 * 1024:
        raise ValueError("archive file too large")
    with zipfile.ZipFile(path) as z:
        z.extractall(dest)'''
    elsewhere = head + '''def unpack_theme(path, dest):
    with zipfile.ZipFile(path) as z:
        for info in _checked_members(z):
            z.extract(info, dest)

def unpack(path, dest):
    with zipfile.ZipFile(path) as z:
        z.extractall(dest)'''
    return cls, none, covers, wrong, irrelevant, elsewhere

@pattern
def ldap_injection(_):
    cls = "ldap injection"
    head = '''from ldap3.utils.conv import escape_filter_chars

BASE_DN = "ou=people,dc=example,dc=com"

def _filter_for(uid):
    return "(uid=%s)" % escape_filter_chars(uid)

'''
    none = head + '''def find_user(conn, uid):
    conn.search(BASE_DN, "(uid=%s)" % uid)
    return conn.entries'''
    covers = head + '''def find_user(conn, uid):
    conn.search(BASE_DN, _filter_for(uid))
    return conn.entries'''
    wrong = head + '''def find_user(conn, uid, dept):
    _filter_for(dept)
    conn.search(BASE_DN, "(&(uid=%s)(ou=%s))" % (uid, escape_filter_chars(dept)))
    return conn.entries'''
    irrelevant = head + '''def find_user(conn, uid):
    if not uid or len(uid) > 64:
        raise ValueError("bad uid length")
    conn.search(BASE_DN, "(uid=%s)" % uid)
    return conn.entries'''
    elsewhere = head + '''def find_group(conn, gid):
    conn.search(BASE_DN, "(cn=%s)" % escape_filter_chars(gid))
    return conn.entries

def find_user(conn, uid):
    conn.search(BASE_DN, "(uid=%s)" % uid)
    return conn.entries'''
    return cls, none, covers, wrong, irrelevant, elsewhere

# ---------------------------------------------------------------- assembly
SHAPES = ["none", "covers", "wrong_value", "irrelevant", "elsewhere"]
LABEL  = {"none":"unsafe","covers":"safe","wrong_value":"unsafe","irrelevant":"unsafe","elsewhere":"unsafe"}
WHY = {
 "none": "no guard is applied on this path",
 "covers": "the guard is applied to the tainted value and addresses the weakness",
 "wrong_value": "the guard is applied to a sibling value, not the one that reaches the sink",
 "irrelevant": "a guard is applied to the right value but does not address this weakness",
 "elsewhere": "the guard exists and is used by a neighbouring function, not on this path",
}

def build():
    out, seen = [], set()
    for fn in P:
        cls, *variants = fn(None)
        for shape, code in zip(SHAPES, variants):
            h = hashlib.sha1(code.encode()).hexdigest()[:12]
            if h in seen: continue
            seen.add(h)
            out.append({
                "id": f"{fn.__name__}_{shape}",
                "pattern": fn.__name__,
                "shape": shape,
                "label": LABEL[shape],
                "vuln_class": cls if LABEL[shape]=="unsafe" else None,
                "why": WHY[shape],
                "code": code,
            })
    return out

if __name__ == "__main__":
    rows = build()
    bad = []
    for r in rows:
        try: ast.parse(r["code"])
        except SyntaxError as e: bad.append((r["id"], str(e)))
    p = os.path.expanduser("~/loreacyber-ft/guardbench/items.jsonl")
    with open(p,"w") as fh:
        for r in rows: fh.write(json.dumps(r)+"\n")
    print(f"items: {len(rows)} -> {p}")
    print("shape :", dict(Counter(r['shape'] for r in rows)))
    print("label :", dict(Counter(r['label'] for r in rows)))
    print(f"syntax errors: {len(bad)}")
    for i,e in bad[:6]: print("   ",i,e)