| {"id": "xxe_none", "pattern": "xxe", "shape": "none", "label": "unsafe", "vuln_class": "xml external entity", "why": "no guard is applied on this path", "code": "import defusedxml.ElementTree as SAFEET\nimport xml.etree.ElementTree as ET\n\ndef _parse_trusted(blob):\n \"\"\"Internal feeds only; these come from our own signed bundles.\"\"\"\n return ET.fromstring(blob)\n\ndef import_feed(request):\n return ET.fromstring(request.body)"} |
| {"id": "xxe_covers", "pattern": "xxe", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import defusedxml.ElementTree as SAFEET\nimport xml.etree.ElementTree as ET\n\ndef _parse_trusted(blob):\n \"\"\"Internal feeds only; these come from our own signed bundles.\"\"\"\n return ET.fromstring(blob)\n\ndef import_feed(request):\n return SAFEET.fromstring(request.body)"} |
| {"id": "xxe_wrong_value", "pattern": "xxe", "shape": "wrong_value", "label": "unsafe", "vuln_class": "xml external entity", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import defusedxml.ElementTree as SAFEET\nimport xml.etree.ElementTree as ET\n\ndef _parse_trusted(blob):\n \"\"\"Internal feeds only; these come from our own signed bundles.\"\"\"\n return ET.fromstring(blob)\n\ndef import_feed(request):\n SAFEET.fromstring(request.headers.get(\"X-Manifest\", \"<m/>\"))\n return ET.fromstring(request.body)"} |
| {"id": "xxe_irrelevant", "pattern": "xxe", "shape": "irrelevant", "label": "unsafe", "vuln_class": "xml external entity", "why": "a guard is applied to the right value but does not address this weakness", "code": "import defusedxml.ElementTree as SAFEET\nimport xml.etree.ElementTree as ET\n\ndef _parse_trusted(blob):\n \"\"\"Internal feeds only; these come from our own signed bundles.\"\"\"\n return ET.fromstring(blob)\n\ndef import_feed(request):\n if len(request.body) > 2_000_000:\n raise ValueError(\"feed too large\")\n return ET.fromstring(request.body)"} |
| {"id": "xxe_elsewhere", "pattern": "xxe", "shape": "elsewhere", "label": "unsafe", "vuln_class": "xml external entity", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import defusedxml.ElementTree as SAFEET\nimport xml.etree.ElementTree as ET\n\ndef _parse_trusted(blob):\n \"\"\"Internal feeds only; these come from our own signed bundles.\"\"\"\n return ET.fromstring(blob)\n\ndef import_manifest(request):\n return SAFEET.fromstring(request.body)\n\ndef import_feed(request):\n return _parse_trusted(request.body)"} |
| {"id": "xxe_covers_alt", "pattern": "xxe", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import defusedxml.ElementTree as SAFEET\nimport xml.etree.ElementTree as ET\n\ndef _parse_trusted(blob):\n \"\"\"Internal feeds only; these come from our own signed bundles.\"\"\"\n return ET.fromstring(blob)\n\ndef import_feed(request):\n parser = ET.XMLParser()\n parser.parser.DefaultHandlerExpand = None\n parser.entity = {}\n return ET.fromstring(request.body, parser=parser)"} |
| {"id": "ssti_none", "pattern": "ssti", "shape": "none", "label": "unsafe", "vuln_class": "server-side template injection", "why": "no guard is applied on this path", "code": "from jinja2 import Environment, select_autoescape\nfrom jinja2.sandbox import SandboxedEnvironment\n\nSANDBOX = SandboxedEnvironment(autoescape=select_autoescape())\nLOOSE = Environment(autoescape=select_autoescape())\n\ndef render_signature(user):\n return LOOSE.from_string(user.signature_template).render(user=user)"} |
| {"id": "ssti_covers", "pattern": "ssti", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "from jinja2 import Environment, select_autoescape\nfrom jinja2.sandbox import SandboxedEnvironment\n\nSANDBOX = SandboxedEnvironment(autoescape=select_autoescape())\nLOOSE = Environment(autoescape=select_autoescape())\n\ndef render_signature(user):\n return SANDBOX.from_string(user.signature_template).render(user=user)"} |
| {"id": "ssti_wrong_value", "pattern": "ssti", "shape": "wrong_value", "label": "unsafe", "vuln_class": "server-side template injection", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "from jinja2 import Environment, select_autoescape\nfrom jinja2.sandbox import SandboxedEnvironment\n\nSANDBOX = SandboxedEnvironment(autoescape=select_autoescape())\nLOOSE = Environment(autoescape=select_autoescape())\n\ndef render_signature(user):\n SANDBOX.from_string(user.display_name).render()\n return LOOSE.from_string(user.signature_template).render(user=user)"} |
| {"id": "ssti_irrelevant", "pattern": "ssti", "shape": "irrelevant", "label": "unsafe", "vuln_class": "server-side template injection", "why": "a guard is applied to the right value but does not address this weakness", "code": "from jinja2 import Environment, select_autoescape\nfrom jinja2.sandbox import SandboxedEnvironment\n\nSANDBOX = SandboxedEnvironment(autoescape=select_autoescape())\nLOOSE = Environment(autoescape=select_autoescape())\n\ndef render_signature(user):\n if \"<script\" in user.signature_template.lower():\n raise ValueError(\"no script tags\")\n return LOOSE.from_string(user.signature_template).render(user=user)"} |
| {"id": "ssti_elsewhere", "pattern": "ssti", "shape": "elsewhere", "label": "unsafe", "vuln_class": "server-side template injection", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "from jinja2 import Environment, select_autoescape\nfrom jinja2.sandbox import SandboxedEnvironment\n\nSANDBOX = SandboxedEnvironment(autoescape=select_autoescape())\nLOOSE = Environment(autoescape=select_autoescape())\n\ndef render_footer(org):\n return SANDBOX.from_string(org.footer_template).render(org=org)\n\ndef render_signature(user):\n return LOOSE.from_string(user.signature_template).render(user=user)"} |
| {"id": "ssti_covers_alt", "pattern": "ssti", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "from jinja2 import Environment, select_autoescape\nfrom jinja2.sandbox import SandboxedEnvironment\n\nSANDBOX = SandboxedEnvironment(autoescape=select_autoescape())\nLOOSE = Environment(autoescape=select_autoescape())\n\nALLOWED_VARS = (\"name\", \"org\", \"title\")\n\ndef render_signature(user):\n tmpl = user.signature_template\n out = tmpl\n for v in ALLOWED_VARS:\n out = out.replace(\"{{%s}}\" % v, escape(getattr(user, v, \"\")))\n return out"} |
| {"id": "redos_none", "pattern": "redos", "shape": "none", "label": "unsafe", "vuln_class": "regular expression denial of service", "why": "no guard is applied on this path", "code": "import re, regex\n\nMAX_PATTERN_LEN = 200\n\ndef _compile_bounded(p):\n \"\"\"regex module supports a match timeout; re does not.\"\"\"\n return regex.compile(p)\n\ndef search_logs(lines, user_pattern):\n rx = re.compile(user_pattern)\n return [l for l in lines if rx.search(l)]"} |
| {"id": "redos_covers", "pattern": "redos", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import re, regex\n\nMAX_PATTERN_LEN = 200\n\ndef _compile_bounded(p):\n \"\"\"regex module supports a match timeout; re does not.\"\"\"\n return regex.compile(p)\n\ndef search_logs(lines, user_pattern):\n rx = _compile_bounded(user_pattern)\n return [l for l in lines if rx.search(l, timeout=0.25)]"} |
| {"id": "redos_wrong_value", "pattern": "redos", "shape": "wrong_value", "label": "unsafe", "vuln_class": "regular expression denial of service", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import re, regex\n\nMAX_PATTERN_LEN = 200\n\ndef _compile_bounded(p):\n \"\"\"regex module supports a match timeout; re does not.\"\"\"\n return regex.compile(p)\n\ndef search_logs(lines, user_pattern, highlight):\n _compile_bounded(highlight)\n rx = re.compile(user_pattern)\n return [l for l in lines if rx.search(l)]"} |
| {"id": "redos_irrelevant", "pattern": "redos", "shape": "irrelevant", "label": "unsafe", "vuln_class": "regular expression denial of service", "why": "a guard is applied to the right value but does not address this weakness", "code": "import re, regex\n\nMAX_PATTERN_LEN = 200\n\ndef _compile_bounded(p):\n \"\"\"regex module supports a match timeout; re does not.\"\"\"\n return regex.compile(p)\n\ndef search_logs(lines, user_pattern):\n if len(user_pattern) > MAX_PATTERN_LEN:\n raise ValueError(\"pattern too long\")\n rx = re.compile(user_pattern)\n return [l for l in lines if rx.search(l)]"} |
| {"id": "redos_elsewhere", "pattern": "redos", "shape": "elsewhere", "label": "unsafe", "vuln_class": "regular expression denial of service", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import re, regex\n\nMAX_PATTERN_LEN = 200\n\ndef _compile_bounded(p):\n \"\"\"regex module supports a match timeout; re does not.\"\"\"\n return regex.compile(p)\n\ndef search_alerts(rows, user_pattern):\n rx = _compile_bounded(user_pattern)\n return [r for r in rows if rx.search(r, timeout=0.25)]\n\ndef search_logs(lines, user_pattern):\n rx = re.compile(user_pattern)\n return [l for l in lines if rx.search(l)]"} |
| {"id": "redos_covers_alt", "pattern": "redos", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import re, regex\n\nMAX_PATTERN_LEN = 200\n\ndef _compile_bounded(p):\n \"\"\"regex module supports a match timeout; re does not.\"\"\"\n return regex.compile(p)\n\ndef search_logs(lines, user_pattern):\n rx = regex.compile(regex.escape(user_pattern))\n return [l for l in lines if rx.search(l)]"} |
| {"id": "host_header_none", "pattern": "host_header", "shape": "none", "label": "unsafe", "vuln_class": "host header injection", "why": "no guard is applied on this path", "code": "TRUSTED_HOSTS = {\"app.example.com\", \"www.example.com\"}\n\ndef _origin(request):\n host = request.headers.get(\"Host\", \"\")\n if host not in TRUSTED_HOSTS:\n raise ValueError(\"untrusted host\")\n return \"https://\" + host\n\ndef send_reset(user, request, token):\n link = \"https://\" + request.headers[\"Host\"] + \"/reset?t=\" + token\n mail(user.email, link)"} |
| {"id": "host_header_covers", "pattern": "host_header", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "TRUSTED_HOSTS = {\"app.example.com\", \"www.example.com\"}\n\ndef _origin(request):\n host = request.headers.get(\"Host\", \"\")\n if host not in TRUSTED_HOSTS:\n raise ValueError(\"untrusted host\")\n return \"https://\" + host\n\ndef send_reset(user, request, token):\n mail(user.email, _origin(request) + \"/reset?t=\" + token)"} |
| {"id": "host_header_wrong_value", "pattern": "host_header", "shape": "wrong_value", "label": "unsafe", "vuln_class": "host header injection", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "TRUSTED_HOSTS = {\"app.example.com\", \"www.example.com\"}\n\ndef _origin(request):\n host = request.headers.get(\"Host\", \"\")\n if host not in TRUSTED_HOSTS:\n raise ValueError(\"untrusted host\")\n return \"https://\" + host\n\ndef send_reset(user, request, token):\n _origin(request)\n link = \"https://\" + request.headers.get(\"X-Forwarded-Host\", \"\") + \"/reset?t=\" + token\n mail(user.email, link)"} |
| {"id": "host_header_irrelevant", "pattern": "host_header", "shape": "irrelevant", "label": "unsafe", "vuln_class": "host header injection", "why": "a guard is applied to the right value but does not address this weakness", "code": "TRUSTED_HOSTS = {\"app.example.com\", \"www.example.com\"}\n\ndef _origin(request):\n host = request.headers.get(\"Host\", \"\")\n if host not in TRUSTED_HOSTS:\n raise ValueError(\"untrusted host\")\n return \"https://\" + host\n\ndef send_reset(user, request, token):\n host = request.headers.get(\"Host\", \"\")\n if len(host) > 253 or \"\\n\" in host:\n raise ValueError(\"malformed host\")\n mail(user.email, \"https://\" + host + \"/reset?t=\" + token)"} |
| {"id": "host_header_elsewhere", "pattern": "host_header", "shape": "elsewhere", "label": "unsafe", "vuln_class": "host header injection", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "TRUSTED_HOSTS = {\"app.example.com\", \"www.example.com\"}\n\ndef _origin(request):\n host = request.headers.get(\"Host\", \"\")\n if host not in TRUSTED_HOSTS:\n raise ValueError(\"untrusted host\")\n return \"https://\" + host\n\ndef send_invite(user, request, token):\n mail(user.email, _origin(request) + \"/invite?t=\" + token)\n\ndef send_reset(user, request, token):\n mail(user.email, \"https://\" + request.headers[\"Host\"] + \"/reset?t=\" + token)"} |
| {"id": "host_header_covers_alt", "pattern": "host_header", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "TRUSTED_HOSTS = {\"app.example.com\", \"www.example.com\"}\n\ndef _origin(request):\n host = request.headers.get(\"Host\", \"\")\n if host not in TRUSTED_HOSTS:\n raise ValueError(\"untrusted host\")\n return \"https://\" + host\n\nCANONICAL_ORIGIN = \"https://app.example.com\"\n\ndef send_reset(user, request, token):\n mail(user.email, CANONICAL_ORIGIN + \"/reset?t=\" + token)"} |
| {"id": "weak_token_none", "pattern": "weak_token", "shape": "none", "label": "unsafe", "vuln_class": "insecure randomness", "why": "no guard is applied on this path", "code": "import random, secrets\n\nTOKEN_BYTES = 32\n\ndef _strong_token():\n return secrets.token_urlsafe(TOKEN_BYTES)\n\ndef new_reset_token(user):\n t = \"\".join(random.choice(\"0123456789abcdef\") for _ in range(32))\n store(user, t); return t"} |
| {"id": "weak_token_covers", "pattern": "weak_token", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import random, secrets\n\nTOKEN_BYTES = 32\n\ndef _strong_token():\n return secrets.token_urlsafe(TOKEN_BYTES)\n\ndef new_reset_token(user):\n t = _strong_token()\n store(user, t); return t"} |
| {"id": "weak_token_wrong_value", "pattern": "weak_token", "shape": "wrong_value", "label": "unsafe", "vuln_class": "insecure randomness", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import random, secrets\n\nTOKEN_BYTES = 32\n\ndef _strong_token():\n return secrets.token_urlsafe(TOKEN_BYTES)\n\ndef new_reset_token(user):\n _strong_token()\n t = \"%d%d\" % (int(time.time()), random.randint(0, 10**9))\n store(user, t); return t"} |
| {"id": "weak_token_irrelevant", "pattern": "weak_token", "shape": "irrelevant", "label": "unsafe", "vuln_class": "insecure randomness", "why": "a guard is applied to the right value but does not address this weakness", "code": "import random, secrets\n\nTOKEN_BYTES = 32\n\ndef _strong_token():\n return secrets.token_urlsafe(TOKEN_BYTES)\n\ndef new_reset_token(user):\n t = \"\".join(random.choice(\"0123456789abcdef\") for _ in range(64))\n if len(t) < 32:\n raise ValueError(\"token too short\")\n store(user, t); return t"} |
| {"id": "weak_token_elsewhere", "pattern": "weak_token", "shape": "elsewhere", "label": "unsafe", "vuln_class": "insecure randomness", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import random, secrets\n\nTOKEN_BYTES = 32\n\ndef _strong_token():\n return secrets.token_urlsafe(TOKEN_BYTES)\n\ndef new_session_token(user):\n t = _strong_token()\n store(user, t); return t\n\ndef new_reset_token(user):\n t = \"\".join(random.choice(\"0123456789abcdef\") for _ in range(32))\n store(user, t); return t"} |
| {"id": "weak_token_covers_alt", "pattern": "weak_token", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import random, secrets\n\nTOKEN_BYTES = 32\n\ndef _strong_token():\n return secrets.token_urlsafe(TOKEN_BYTES)\n\ndef new_reset_token(user):\n t = secrets.token_hex(TOKEN_BYTES)\n store(user, t); return t"} |
| {"id": "csv_injection_none", "pattern": "csv_injection", "shape": "none", "label": "unsafe", "vuln_class": "formula injection", "why": "no guard is applied on this path", "code": "DANGEROUS_PREFIX = (\"=\", \"+\", \"-\", \"@\", \"\\t\", \"\\r\")\n\ndef _neutralise(v):\n s = \"\" if v is None else str(v)\n return \"'\" + s if s.startswith(DANGEROUS_PREFIX) else s\n\ndef export_rows(rows, out):\n w = csv.writer(out)\n for r in rows:\n w.writerow([r.name, r.note])"} |
| {"id": "csv_injection_covers", "pattern": "csv_injection", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "DANGEROUS_PREFIX = (\"=\", \"+\", \"-\", \"@\", \"\\t\", \"\\r\")\n\ndef _neutralise(v):\n s = \"\" if v is None else str(v)\n return \"'\" + s if s.startswith(DANGEROUS_PREFIX) else s\n\ndef export_rows(rows, out):\n w = csv.writer(out)\n for r in rows:\n w.writerow([_neutralise(r.name), _neutralise(r.note)])"} |
| {"id": "csv_injection_wrong_value", "pattern": "csv_injection", "shape": "wrong_value", "label": "unsafe", "vuln_class": "formula injection", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "DANGEROUS_PREFIX = (\"=\", \"+\", \"-\", \"@\", \"\\t\", \"\\r\")\n\ndef _neutralise(v):\n s = \"\" if v is None else str(v)\n return \"'\" + s if s.startswith(DANGEROUS_PREFIX) else s\n\ndef export_rows(rows, out):\n w = csv.writer(out)\n for r in rows:\n w.writerow([_neutralise(r.name), r.note])"} |
| {"id": "csv_injection_irrelevant", "pattern": "csv_injection", "shape": "irrelevant", "label": "unsafe", "vuln_class": "formula injection", "why": "a guard is applied to the right value but does not address this weakness", "code": "DANGEROUS_PREFIX = (\"=\", \"+\", \"-\", \"@\", \"\\t\", \"\\r\")\n\ndef _neutralise(v):\n s = \"\" if v is None else str(v)\n return \"'\" + s if s.startswith(DANGEROUS_PREFIX) else s\n\ndef export_rows(rows, out):\n w = csv.writer(out)\n for r in rows:\n w.writerow([html.escape(r.name), html.escape(r.note)])"} |
| {"id": "csv_injection_elsewhere", "pattern": "csv_injection", "shape": "elsewhere", "label": "unsafe", "vuln_class": "formula injection", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "DANGEROUS_PREFIX = (\"=\", \"+\", \"-\", \"@\", \"\\t\", \"\\r\")\n\ndef _neutralise(v):\n s = \"\" if v is None else str(v)\n return \"'\" + s if s.startswith(DANGEROUS_PREFIX) else s\n\ndef export_summary(rows, out):\n w = csv.writer(out)\n for r in rows:\n w.writerow([_neutralise(r.label)])\n\ndef export_rows(rows, out):\n w = csv.writer(out)\n for r in rows:\n w.writerow([r.name, r.note])"} |
| {"id": "csv_injection_covers_alt", "pattern": "csv_injection", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "DANGEROUS_PREFIX = (\"=\", \"+\", \"-\", \"@\", \"\\t\", \"\\r\")\n\ndef _neutralise(v):\n s = \"\" if v is None else str(v)\n return \"'\" + s if s.startswith(DANGEROUS_PREFIX) else s\n\ndef export_rows(rows, out):\n w = csv.writer(out, quoting=csv.QUOTE_ALL)\n for r in rows:\n w.writerow([_neutralise(x) for x in (r.name, r.note)])"} |
| {"id": "zip_bomb_none", "pattern": "zip_bomb", "shape": "none", "label": "unsafe", "vuln_class": "resource exhaustion", "why": "no guard is applied on this path", "code": "MAX_TOTAL = 200 * 1024 * 1024\n\ndef _checked_members(z):\n total = 0\n for info in z.infolist():\n total += info.file_size\n if total > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n yield info\n\ndef unpack(path, dest):\n with zipfile.ZipFile(path) as z:\n z.extractall(dest)"} |
| {"id": "zip_bomb_covers", "pattern": "zip_bomb", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "MAX_TOTAL = 200 * 1024 * 1024\n\ndef _checked_members(z):\n total = 0\n for info in z.infolist():\n total += info.file_size\n if total > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n yield info\n\ndef unpack(path, dest):\n with zipfile.ZipFile(path) as z:\n for info in _checked_members(z):\n z.extract(info, dest)"} |
| {"id": "zip_bomb_wrong_value", "pattern": "zip_bomb", "shape": "wrong_value", "label": "unsafe", "vuln_class": "resource exhaustion", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "MAX_TOTAL = 200 * 1024 * 1024\n\ndef _checked_members(z):\n total = 0\n for info in z.infolist():\n total += info.file_size\n if total > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n yield info\n\ndef unpack(path, dest):\n with zipfile.ZipFile(path) as z:\n list(_checked_members(z))\n z.extractall(dest)"} |
| {"id": "zip_bomb_irrelevant", "pattern": "zip_bomb", "shape": "irrelevant", "label": "unsafe", "vuln_class": "resource exhaustion", "why": "a guard is applied to the right value but does not address this weakness", "code": "MAX_TOTAL = 200 * 1024 * 1024\n\ndef _checked_members(z):\n total = 0\n for info in z.infolist():\n total += info.file_size\n if total > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n yield info\n\ndef unpack(path, dest):\n if os.path.getsize(path) > 20 * 1024 * 1024:\n raise ValueError(\"archive file too large\")\n with zipfile.ZipFile(path) as z:\n z.extractall(dest)"} |
| {"id": "zip_bomb_elsewhere", "pattern": "zip_bomb", "shape": "elsewhere", "label": "unsafe", "vuln_class": "resource exhaustion", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "MAX_TOTAL = 200 * 1024 * 1024\n\ndef _checked_members(z):\n total = 0\n for info in z.infolist():\n total += info.file_size\n if total > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n yield info\n\ndef unpack_theme(path, dest):\n with zipfile.ZipFile(path) as z:\n for info in _checked_members(z):\n z.extract(info, dest)\n\ndef unpack(path, dest):\n with zipfile.ZipFile(path) as z:\n z.extractall(dest)"} |
| {"id": "zip_bomb_covers_alt", "pattern": "zip_bomb", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "MAX_TOTAL = 200 * 1024 * 1024\n\ndef _checked_members(z):\n total = 0\n for info in z.infolist():\n total += info.file_size\n if total > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n yield info\n\ndef unpack(path, dest):\n written = 0\n with zipfile.ZipFile(path) as z:\n for info in z.infolist():\n written += info.file_size\n if written > MAX_TOTAL:\n raise ValueError(\"archive expands too large\")\n z.extract(info, dest)"} |
| {"id": "ldap_injection_none", "pattern": "ldap_injection", "shape": "none", "label": "unsafe", "vuln_class": "ldap injection", "why": "no guard is applied on this path", "code": "from ldap3.utils.conv import escape_filter_chars\n\nBASE_DN = \"ou=people,dc=example,dc=com\"\n\ndef _filter_for(uid):\n return \"(uid=%s)\" % escape_filter_chars(uid)\n\ndef find_user(conn, uid):\n conn.search(BASE_DN, \"(uid=%s)\" % uid)\n return conn.entries"} |
| {"id": "ldap_injection_covers", "pattern": "ldap_injection", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "from ldap3.utils.conv import escape_filter_chars\n\nBASE_DN = \"ou=people,dc=example,dc=com\"\n\ndef _filter_for(uid):\n return \"(uid=%s)\" % escape_filter_chars(uid)\n\ndef find_user(conn, uid):\n conn.search(BASE_DN, _filter_for(uid))\n return conn.entries"} |
| {"id": "ldap_injection_wrong_value", "pattern": "ldap_injection", "shape": "wrong_value", "label": "unsafe", "vuln_class": "ldap injection", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "from ldap3.utils.conv import escape_filter_chars\n\nBASE_DN = \"ou=people,dc=example,dc=com\"\n\ndef _filter_for(uid):\n return \"(uid=%s)\" % escape_filter_chars(uid)\n\ndef find_user(conn, uid, dept):\n _filter_for(dept)\n conn.search(BASE_DN, \"(&(uid=%s)(ou=%s))\" % (uid, escape_filter_chars(dept)))\n return conn.entries"} |
| {"id": "ldap_injection_irrelevant", "pattern": "ldap_injection", "shape": "irrelevant", "label": "unsafe", "vuln_class": "ldap injection", "why": "a guard is applied to the right value but does not address this weakness", "code": "from ldap3.utils.conv import escape_filter_chars\n\nBASE_DN = \"ou=people,dc=example,dc=com\"\n\ndef _filter_for(uid):\n return \"(uid=%s)\" % escape_filter_chars(uid)\n\ndef find_user(conn, uid):\n if not uid or len(uid) > 64:\n raise ValueError(\"bad uid length\")\n conn.search(BASE_DN, \"(uid=%s)\" % uid)\n return conn.entries"} |
| {"id": "ldap_injection_elsewhere", "pattern": "ldap_injection", "shape": "elsewhere", "label": "unsafe", "vuln_class": "ldap injection", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "from ldap3.utils.conv import escape_filter_chars\n\nBASE_DN = \"ou=people,dc=example,dc=com\"\n\ndef _filter_for(uid):\n return \"(uid=%s)\" % escape_filter_chars(uid)\n\ndef find_group(conn, gid):\n conn.search(BASE_DN, \"(cn=%s)\" % escape_filter_chars(gid))\n return conn.entries\n\ndef find_user(conn, uid):\n conn.search(BASE_DN, \"(uid=%s)\" % uid)\n return conn.entries"} |
| {"id": "ldap_injection_covers_alt", "pattern": "ldap_injection", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "from ldap3.utils.conv import escape_filter_chars\n\nBASE_DN = \"ou=people,dc=example,dc=com\"\n\ndef _filter_for(uid):\n return \"(uid=%s)\" % escape_filter_chars(uid)\n\ndef find_user(conn, uid):\n conn.search(BASE_DN, \"(uid=%s)\" % escape_filter_chars(uid))\n return conn.entries"} |
| {"id": "ssrf_redirect_none", "pattern": "ssrf_redirect", "shape": "none", "label": "unsafe", "vuln_class": "server-side request forgery", "why": "no guard is applied on this path", "code": "import requests\nfrom urllib.parse import urlparse\n\nALLOWED = {\"api.partner.com\", \"cdn.partner.com\"}\n\ndef _checked(url):\n if urlparse(url).hostname not in ALLOWED:\n raise ValueError(\"host not allowed\")\n return url\n\ndef fetch_avatar(url):\n return requests.get(url, timeout=5).content"} |
| {"id": "ssrf_redirect_covers", "pattern": "ssrf_redirect", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import requests\nfrom urllib.parse import urlparse\n\nALLOWED = {\"api.partner.com\", \"cdn.partner.com\"}\n\ndef _checked(url):\n if urlparse(url).hostname not in ALLOWED:\n raise ValueError(\"host not allowed\")\n return url\n\ndef fetch_avatar(url):\n return requests.get(_checked(url), timeout=5, allow_redirects=False).content"} |
| {"id": "ssrf_redirect_covers_alt", "pattern": "ssrf_redirect", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import requests\nfrom urllib.parse import urlparse\n\nALLOWED = {\"api.partner.com\", \"cdn.partner.com\"}\n\ndef _checked(url):\n if urlparse(url).hostname not in ALLOWED:\n raise ValueError(\"host not allowed\")\n return url\n\ndef fetch_avatar(url):\n r = requests.get(_checked(url), timeout=5, allow_redirects=True)\n _checked(r.url)\n return r.content"} |
| {"id": "ssrf_redirect_wrong_value", "pattern": "ssrf_redirect", "shape": "wrong_value", "label": "unsafe", "vuln_class": "server-side request forgery", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import requests\nfrom urllib.parse import urlparse\n\nALLOWED = {\"api.partner.com\", \"cdn.partner.com\"}\n\ndef _checked(url):\n if urlparse(url).hostname not in ALLOWED:\n raise ValueError(\"host not allowed\")\n return url\n\ndef fetch_avatar(url, fallback):\n _checked(fallback)\n return requests.get(url, timeout=5).content"} |
| {"id": "ssrf_redirect_irrelevant", "pattern": "ssrf_redirect", "shape": "irrelevant", "label": "unsafe", "vuln_class": "server-side request forgery", "why": "a guard is applied to the right value but does not address this weakness", "code": "import requests\nfrom urllib.parse import urlparse\n\nALLOWED = {\"api.partner.com\", \"cdn.partner.com\"}\n\ndef _checked(url):\n if urlparse(url).hostname not in ALLOWED:\n raise ValueError(\"host not allowed\")\n return url\n\ndef fetch_avatar(url):\n if not url.startswith(\"https://\"):\n raise ValueError(\"https only\")\n return requests.get(url, timeout=5).content"} |
| {"id": "ssrf_redirect_elsewhere", "pattern": "ssrf_redirect", "shape": "elsewhere", "label": "unsafe", "vuln_class": "server-side request forgery", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import requests\nfrom urllib.parse import urlparse\n\nALLOWED = {\"api.partner.com\", \"cdn.partner.com\"}\n\ndef _checked(url):\n if urlparse(url).hostname not in ALLOWED:\n raise ValueError(\"host not allowed\")\n return url\n\ndef fetch_manifest(url):\n return requests.get(_checked(url), timeout=5, allow_redirects=False).json()\n\ndef fetch_avatar(url):\n return requests.get(url, timeout=5).content"} |
| {"id": "csrf_missing_none", "pattern": "csrf_missing", "shape": "none", "label": "unsafe", "vuln_class": "cross-site request forgery", "why": "no guard is applied on this path", "code": "from functools import wraps\n\ndef require_csrf(fn):\n @wraps(fn)\n def inner(request, *a, **kw):\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n return fn(request, *a, **kw)\n return inner\n\n@app.post(\"/account/email\")\ndef change_email(request):\n request.user.email = request.form[\"email\"]\n request.user.save()"} |
| {"id": "csrf_missing_covers", "pattern": "csrf_missing", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "from functools import wraps\n\ndef require_csrf(fn):\n @wraps(fn)\n def inner(request, *a, **kw):\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n return fn(request, *a, **kw)\n return inner\n\n@app.post(\"/account/email\")\n@require_csrf\ndef change_email(request):\n request.user.email = request.form[\"email\"]\n request.user.save()"} |
| {"id": "csrf_missing_covers_alt", "pattern": "csrf_missing", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "from functools import wraps\n\ndef require_csrf(fn):\n @wraps(fn)\n def inner(request, *a, **kw):\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n return fn(request, *a, **kw)\n return inner\n\n@app.post(\"/account/email\")\ndef change_email(request):\n if request.headers.get(\"Sec-Fetch-Site\") != \"same-origin\":\n abort(403)\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n request.user.email = request.form[\"email\"]\n request.user.save()"} |
| {"id": "csrf_missing_wrong_value", "pattern": "csrf_missing", "shape": "wrong_value", "label": "unsafe", "vuln_class": "cross-site request forgery", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "from functools import wraps\n\ndef require_csrf(fn):\n @wraps(fn)\n def inner(request, *a, **kw):\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n return fn(request, *a, **kw)\n return inner\n\n@app.post(\"/account/email\")\ndef change_email(request):\n if request.form.get(\"csrf\") != request.form.get(\"csrf_echo\"):\n abort(403)\n request.user.email = request.form[\"email\"]\n request.user.save()"} |
| {"id": "csrf_missing_irrelevant", "pattern": "csrf_missing", "shape": "irrelevant", "label": "unsafe", "vuln_class": "cross-site request forgery", "why": "a guard is applied to the right value but does not address this weakness", "code": "from functools import wraps\n\ndef require_csrf(fn):\n @wraps(fn)\n def inner(request, *a, **kw):\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n return fn(request, *a, **kw)\n return inner\n\n@app.post(\"/account/email\")\ndef change_email(request):\n if \"@\" not in request.form[\"email\"]:\n abort(400)\n request.user.email = request.form[\"email\"]\n request.user.save()"} |
| {"id": "csrf_missing_elsewhere", "pattern": "csrf_missing", "shape": "elsewhere", "label": "unsafe", "vuln_class": "cross-site request forgery", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "from functools import wraps\n\ndef require_csrf(fn):\n @wraps(fn)\n def inner(request, *a, **kw):\n if request.form.get(\"csrf\") != request.session.get(\"csrf\"):\n abort(403)\n return fn(request, *a, **kw)\n return inner\n\n@app.post(\"/account/password\")\n@require_csrf\ndef change_password(request):\n request.user.set_password(request.form[\"pw\"])\n\n@app.post(\"/account/email\")\ndef change_email(request):\n request.user.email = request.form[\"email\"]\n request.user.save()"} |
| {"id": "toctou_symlink_none", "pattern": "toctou_symlink", "shape": "none", "label": "unsafe", "vuln_class": "time-of-check time-of-use", "why": "no guard is applied on this path", "code": "import os\n\nSPOOL = \"/var/spool/uploads\"\n\ndef _create_exclusive(path):\n fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n return os.fdopen(fd, \"wb\")\n\ndef save_upload(name, data):\n path = os.path.join(SPOOL, name)\n if os.path.exists(path):\n raise FileExistsError(name)\n with open(path, \"wb\") as fh:\n fh.write(data)"} |
| {"id": "toctou_symlink_covers", "pattern": "toctou_symlink", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import os\n\nSPOOL = \"/var/spool/uploads\"\n\ndef _create_exclusive(path):\n fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n return os.fdopen(fd, \"wb\")\n\ndef save_upload(name, data):\n with _create_exclusive(os.path.join(SPOOL, name)) as fh:\n fh.write(data)"} |
| {"id": "toctou_symlink_covers_alt", "pattern": "toctou_symlink", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import os\n\nSPOOL = \"/var/spool/uploads\"\n\ndef _create_exclusive(path):\n fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n return os.fdopen(fd, \"wb\")\n\ndef save_upload(name, data):\n fd = os.open(os.path.join(SPOOL, name),\n os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n with os.fdopen(fd, \"wb\") as fh:\n fh.write(data)"} |
| {"id": "toctou_symlink_wrong_value", "pattern": "toctou_symlink", "shape": "wrong_value", "label": "unsafe", "vuln_class": "time-of-check time-of-use", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import os\n\nSPOOL = \"/var/spool/uploads\"\n\ndef _create_exclusive(path):\n fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n return os.fdopen(fd, \"wb\")\n\ndef save_upload(name, data, tmpname):\n _create_exclusive(os.path.join(SPOOL, tmpname)).close()\n with open(os.path.join(SPOOL, name), \"wb\") as fh:\n fh.write(data)"} |
| {"id": "toctou_symlink_irrelevant", "pattern": "toctou_symlink", "shape": "irrelevant", "label": "unsafe", "vuln_class": "time-of-check time-of-use", "why": "a guard is applied to the right value but does not address this weakness", "code": "import os\n\nSPOOL = \"/var/spool/uploads\"\n\ndef _create_exclusive(path):\n fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n return os.fdopen(fd, \"wb\")\n\ndef save_upload(name, data):\n if \"/\" in name or name.startswith(\".\"):\n raise ValueError(\"bad name\")\n path = os.path.join(SPOOL, name)\n with open(path, \"wb\") as fh:\n fh.write(data)"} |
| {"id": "toctou_symlink_elsewhere", "pattern": "toctou_symlink", "shape": "elsewhere", "label": "unsafe", "vuln_class": "time-of-check time-of-use", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import os\n\nSPOOL = \"/var/spool/uploads\"\n\ndef _create_exclusive(path):\n fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY | os.O_NOFOLLOW, 0o600)\n return os.fdopen(fd, \"wb\")\n\ndef save_temp(name, data):\n with _create_exclusive(os.path.join(SPOOL, name)) as fh:\n fh.write(data)\n\ndef save_upload(name, data):\n with open(os.path.join(SPOOL, name), \"wb\") as fh:\n fh.write(data)"} |
| {"id": "unicode_bypass_none", "pattern": "unicode_bypass", "shape": "none", "label": "unsafe", "vuln_class": "input validation bypass", "why": "no guard is applied on this path", "code": "import unicodedata, re\n\nBLOCKED = re.compile(r\"(?i)\\b(admin|root|system)\\b\")\n\ndef _canonical(s):\n return unicodedata.normalize(\"NFKC\", s).casefold()\n\ndef register(username):\n return create_user(username)"} |
| {"id": "unicode_bypass_covers", "pattern": "unicode_bypass", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import unicodedata, re\n\nBLOCKED = re.compile(r\"(?i)\\b(admin|root|system)\\b\")\n\ndef _canonical(s):\n return unicodedata.normalize(\"NFKC\", s).casefold()\n\ndef register(username):\n canon = _canonical(username)\n if BLOCKED.search(canon):\n raise ValueError(\"reserved name\")\n return create_user(canon)"} |
| {"id": "unicode_bypass_covers_alt", "pattern": "unicode_bypass", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import unicodedata, re\n\nBLOCKED = re.compile(r\"(?i)\\b(admin|root|system)\\b\")\n\ndef _canonical(s):\n return unicodedata.normalize(\"NFKC\", s).casefold()\n\ndef register(username):\n canon = unicodedata.normalize(\"NFKC\", username).casefold()\n if BLOCKED.search(canon):\n raise ValueError(\"reserved name\")\n return create_user(canon)"} |
| {"id": "unicode_bypass_wrong_value", "pattern": "unicode_bypass", "shape": "wrong_value", "label": "unsafe", "vuln_class": "input validation bypass", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import unicodedata, re\n\nBLOCKED = re.compile(r\"(?i)\\b(admin|root|system)\\b\")\n\ndef _canonical(s):\n return unicodedata.normalize(\"NFKC\", s).casefold()\n\ndef register(username, display):\n if BLOCKED.search(_canonical(display)):\n raise ValueError(\"reserved name\")\n return create_user(_canonical(username))"} |
| {"id": "unicode_bypass_irrelevant", "pattern": "unicode_bypass", "shape": "irrelevant", "label": "unsafe", "vuln_class": "input validation bypass", "why": "a guard is applied to the right value but does not address this weakness", "code": "import unicodedata, re\n\nBLOCKED = re.compile(r\"(?i)\\b(admin|root|system)\\b\")\n\ndef _canonical(s):\n return unicodedata.normalize(\"NFKC\", s).casefold()\n\ndef register(username):\n if len(username) > 32:\n raise ValueError(\"too long\")\n return create_user(_canonical(username))"} |
| {"id": "unicode_bypass_elsewhere", "pattern": "unicode_bypass", "shape": "elsewhere", "label": "unsafe", "vuln_class": "input validation bypass", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import unicodedata, re\n\nBLOCKED = re.compile(r\"(?i)\\b(admin|root|system)\\b\")\n\ndef _canonical(s):\n return unicodedata.normalize(\"NFKC\", s).casefold()\n\ndef register_org(name):\n canon = _canonical(name)\n if BLOCKED.search(canon):\n raise ValueError(\"reserved name\")\n return create_org(canon)\n\ndef register(username):\n return create_user(_canonical(username))"} |
| {"id": "cache_poisoning_none", "pattern": "cache_poisoning", "shape": "none", "label": "unsafe", "vuln_class": "web cache poisoning", "why": "no guard is applied on this path", "code": "KEYED_HEADERS = (\"Host\", \"Accept-Language\")\n\ndef _cache_key(request):\n parts = [request.path] + [request.headers.get(h, \"\") for h in KEYED_HEADERS]\n return \"|\".join(parts)\n\ndef render_page(request):\n key = request.path\n if key in CACHE:\n return CACHE[key]\n body = build(request, base=request.headers.get(\"X-Forwarded-Host\", \"\"))\n CACHE[key] = body\n return body"} |
| {"id": "cache_poisoning_covers", "pattern": "cache_poisoning", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "KEYED_HEADERS = (\"Host\", \"Accept-Language\")\n\ndef _cache_key(request):\n parts = [request.path] + [request.headers.get(h, \"\") for h in KEYED_HEADERS]\n return \"|\".join(parts)\n\ndef render_page(request):\n key = _cache_key(request)\n if key in CACHE:\n return CACHE[key]\n body = build(request, base=request.headers.get(\"Host\", \"\"))\n CACHE[key] = body\n return body"} |
| {"id": "cache_poisoning_covers_alt", "pattern": "cache_poisoning", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "KEYED_HEADERS = (\"Host\", \"Accept-Language\")\n\ndef _cache_key(request):\n parts = [request.path] + [request.headers.get(h, \"\") for h in KEYED_HEADERS]\n return \"|\".join(parts)\n\ndef render_page(request):\n key = request.path + \"|\" + request.headers.get(\"Host\", \"\")\n if key in CACHE:\n return CACHE[key]\n body = build(request, base=request.headers.get(\"Host\", \"\"))\n CACHE[key] = body\n return body"} |
| {"id": "cache_poisoning_wrong_value", "pattern": "cache_poisoning", "shape": "wrong_value", "label": "unsafe", "vuln_class": "web cache poisoning", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "KEYED_HEADERS = (\"Host\", \"Accept-Language\")\n\ndef _cache_key(request):\n parts = [request.path] + [request.headers.get(h, \"\") for h in KEYED_HEADERS]\n return \"|\".join(parts)\n\ndef render_page(request):\n key = _cache_key(request)\n if key in CACHE:\n return CACHE[key]\n body = build(request, base=request.headers.get(\"X-Forwarded-Host\", \"\"))\n CACHE[key] = body\n return body"} |
| {"id": "cache_poisoning_irrelevant", "pattern": "cache_poisoning", "shape": "irrelevant", "label": "unsafe", "vuln_class": "web cache poisoning", "why": "a guard is applied to the right value but does not address this weakness", "code": "KEYED_HEADERS = (\"Host\", \"Accept-Language\")\n\ndef _cache_key(request):\n parts = [request.path] + [request.headers.get(h, \"\") for h in KEYED_HEADERS]\n return \"|\".join(parts)\n\ndef render_page(request):\n if len(request.path) > 512:\n raise ValueError(\"path too long\")\n key = request.path\n if key in CACHE:\n return CACHE[key]\n body = build(request, base=request.headers.get(\"X-Forwarded-Host\", \"\"))\n CACHE[key] = body\n return body"} |
| {"id": "cache_poisoning_elsewhere", "pattern": "cache_poisoning", "shape": "elsewhere", "label": "unsafe", "vuln_class": "web cache poisoning", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "KEYED_HEADERS = (\"Host\", \"Accept-Language\")\n\ndef _cache_key(request):\n parts = [request.path] + [request.headers.get(h, \"\") for h in KEYED_HEADERS]\n return \"|\".join(parts)\n\ndef render_asset(request):\n key = _cache_key(request)\n return CACHE.setdefault(key, build_asset(request))\n\ndef render_page(request):\n key = request.path\n if key in CACHE:\n return CACHE[key]\n body = build(request, base=request.headers.get(\"X-Forwarded-Host\", \"\"))\n CACHE[key] = body\n return body"} |
| {"id": "int_overflow_none", "pattern": "int_overflow", "shape": "none", "label": "unsafe", "vuln_class": "integer overflow in size check", "why": "no guard is applied on this path", "code": "MAX_TOTAL = 50 * 1024 * 1024\n\ndef _fits(count, unit):\n if count < 0 or unit < 0:\n raise ValueError(\"negative size\")\n if count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"too large\")\n return True\n\ndef allocate_frames(count, unit):\n return bytearray(count * unit)"} |
| {"id": "int_overflow_covers", "pattern": "int_overflow", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "MAX_TOTAL = 50 * 1024 * 1024\n\ndef _fits(count, unit):\n if count < 0 or unit < 0:\n raise ValueError(\"negative size\")\n if count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"too large\")\n return True\n\ndef allocate_frames(count, unit):\n _fits(count, unit)\n return bytearray(count * unit)"} |
| {"id": "int_overflow_covers_alt", "pattern": "int_overflow", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "MAX_TOTAL = 50 * 1024 * 1024\n\ndef _fits(count, unit):\n if count < 0 or unit < 0:\n raise ValueError(\"negative size\")\n if count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"too large\")\n return True\n\ndef allocate_frames(count, unit):\n if count < 0 or unit < 0 or count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"bad size\")\n return bytearray(count * unit)"} |
| {"id": "int_overflow_wrong_value", "pattern": "int_overflow", "shape": "wrong_value", "label": "unsafe", "vuln_class": "integer overflow in size check", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "MAX_TOTAL = 50 * 1024 * 1024\n\ndef _fits(count, unit):\n if count < 0 or unit < 0:\n raise ValueError(\"negative size\")\n if count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"too large\")\n return True\n\ndef allocate_frames(count, unit, stride):\n _fits(count, stride)\n return bytearray(count * unit)"} |
| {"id": "int_overflow_irrelevant", "pattern": "int_overflow", "shape": "irrelevant", "label": "unsafe", "vuln_class": "integer overflow in size check", "why": "a guard is applied to the right value but does not address this weakness", "code": "MAX_TOTAL = 50 * 1024 * 1024\n\ndef _fits(count, unit):\n if count < 0 or unit < 0:\n raise ValueError(\"negative size\")\n if count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"too large\")\n return True\n\ndef allocate_frames(count, unit):\n if count * unit > MAX_TOTAL:\n raise ValueError(\"too large\")\n return bytearray(count * unit)"} |
| {"id": "int_overflow_elsewhere", "pattern": "int_overflow", "shape": "elsewhere", "label": "unsafe", "vuln_class": "integer overflow in size check", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "MAX_TOTAL = 50 * 1024 * 1024\n\ndef _fits(count, unit):\n if count < 0 or unit < 0:\n raise ValueError(\"negative size\")\n if count > MAX_TOTAL // max(unit, 1):\n raise ValueError(\"too large\")\n return True\n\ndef allocate_tiles(count, unit):\n _fits(count, unit)\n return bytearray(count * unit)\n\ndef allocate_frames(count, unit):\n return bytearray(count * unit)"} |
| {"id": "sig_skip_branch_none", "pattern": "sig_skip_branch", "shape": "none", "label": "unsafe", "vuln_class": "missing signature verification", "why": "no guard is applied on this path", "code": "import hmac, hashlib, base64\n\nSCHEME = \"v2\"\n\ndef _verify(payload, header, secret):\n \"\"\"Header is \"v2,<ts>,<b64 mac>\"; the MAC covers the timestamp and the payload.\"\"\"\n try:\n scheme, ts, mac_b64 = header.split(\",\", 2)\n except ValueError:\n return False\n if scheme != SCHEME:\n return False\n signed = ts.encode() + b\".\" + payload\n want = base64.b64decode(mac_b64 + \"==\")\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n return hmac.compare_digest(got, want)\n\ndef handle_hook(request, secret):\n return process(json.loads(request.body))"} |
| {"id": "sig_skip_branch_covers", "pattern": "sig_skip_branch", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import hmac, hashlib, base64\n\nSCHEME = \"v2\"\n\ndef _verify(payload, header, secret):\n \"\"\"Header is \"v2,<ts>,<b64 mac>\"; the MAC covers the timestamp and the payload.\"\"\"\n try:\n scheme, ts, mac_b64 = header.split(\",\", 2)\n except ValueError:\n return False\n if scheme != SCHEME:\n return False\n signed = ts.encode() + b\".\" + payload\n want = base64.b64decode(mac_b64 + \"==\")\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n return hmac.compare_digest(got, want)\n\ndef handle_hook(request, secret):\n if not _verify(request.body, request.headers.get(\"X-Sig\", \"\"), secret):\n abort(401)\n return process(json.loads(request.body))"} |
| {"id": "sig_skip_branch_covers_alt", "pattern": "sig_skip_branch", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import hmac, hashlib, base64\n\nSCHEME = \"v2\"\n\ndef _verify(payload, header, secret):\n \"\"\"Header is \"v2,<ts>,<b64 mac>\"; the MAC covers the timestamp and the payload.\"\"\"\n try:\n scheme, ts, mac_b64 = header.split(\",\", 2)\n except ValueError:\n return False\n if scheme != SCHEME:\n return False\n signed = ts.encode() + b\".\" + payload\n want = base64.b64decode(mac_b64 + \"==\")\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n return hmac.compare_digest(got, want)\n\ndef handle_hook(request, secret):\n header = request.headers.get(\"X-Sig\", \"\")\n scheme, ts, mac_b64 = (header.split(\",\", 2) + [\"\", \"\", \"\"])[:3]\n signed = ts.encode() + b\".\" + request.body\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n if scheme != SCHEME or not hmac.compare_digest(got, base64.b64decode(mac_b64 + \"==\")):\n abort(401)\n return process(json.loads(request.body))"} |
| {"id": "sig_skip_branch_wrong_value", "pattern": "sig_skip_branch", "shape": "wrong_value", "label": "unsafe", "vuln_class": "missing signature verification", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import hmac, hashlib, base64\n\nSCHEME = \"v2\"\n\ndef _verify(payload, header, secret):\n \"\"\"Header is \"v2,<ts>,<b64 mac>\"; the MAC covers the timestamp and the payload.\"\"\"\n try:\n scheme, ts, mac_b64 = header.split(\",\", 2)\n except ValueError:\n return False\n if scheme != SCHEME:\n return False\n signed = ts.encode() + b\".\" + payload\n want = base64.b64decode(mac_b64 + \"==\")\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n return hmac.compare_digest(got, want)\n\ndef handle_hook(request, secret):\n if not _verify(request.headers.get(\"X-Meta\", b\"\"), request.headers.get(\"X-Sig\", \"\"), secret):\n abort(401)\n return process(json.loads(request.body))"} |
| {"id": "sig_skip_branch_irrelevant", "pattern": "sig_skip_branch", "shape": "irrelevant", "label": "unsafe", "vuln_class": "missing signature verification", "why": "a guard is applied to the right value but does not address this weakness", "code": "import hmac, hashlib, base64\n\nSCHEME = \"v2\"\n\ndef _verify(payload, header, secret):\n \"\"\"Header is \"v2,<ts>,<b64 mac>\"; the MAC covers the timestamp and the payload.\"\"\"\n try:\n scheme, ts, mac_b64 = header.split(\",\", 2)\n except ValueError:\n return False\n if scheme != SCHEME:\n return False\n signed = ts.encode() + b\".\" + payload\n want = base64.b64decode(mac_b64 + \"==\")\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n return hmac.compare_digest(got, want)\n\ndef handle_hook(request, secret):\n if request.headers.get(\"Content-Type\") != \"application/json\":\n abort(415)\n return process(json.loads(request.body))"} |
| {"id": "sig_skip_branch_elsewhere", "pattern": "sig_skip_branch", "shape": "elsewhere", "label": "unsafe", "vuln_class": "missing signature verification", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import hmac, hashlib, base64\n\nSCHEME = \"v2\"\n\ndef _verify(payload, header, secret):\n \"\"\"Header is \"v2,<ts>,<b64 mac>\"; the MAC covers the timestamp and the payload.\"\"\"\n try:\n scheme, ts, mac_b64 = header.split(\",\", 2)\n except ValueError:\n return False\n if scheme != SCHEME:\n return False\n signed = ts.encode() + b\".\" + payload\n want = base64.b64decode(mac_b64 + \"==\")\n got = hmac.new(secret, signed, hashlib.sha512).digest()\n return hmac.compare_digest(got, want)\n\ndef handle_billing_hook(request, secret):\n if not _verify(request.body, request.headers.get(\"X-Sig\", \"\"), secret):\n abort(401)\n return process(json.loads(request.body))\n\ndef handle_hook(request, secret):\n return process(json.loads(request.body))"} |
| {"id": "reset_token_reuse_none", "pattern": "reset_token_reuse", "shape": "none", "label": "unsafe", "vuln_class": "authentication bypass", "why": "no guard is applied on this path", "code": "def _consume(token):\n \"\"\"Single-use: returns the user only if the row was still unused.\"\"\"\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n return rows[0][0] if rows else None\n\ndef apply_reset(token, new_password):\n uid = db.query(\"SELECT user_id FROM resets WHERE token = %s\", (token,))[0][0]\n set_password(uid, new_password)"} |
| {"id": "reset_token_reuse_covers", "pattern": "reset_token_reuse", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "def _consume(token):\n \"\"\"Single-use: returns the user only if the row was still unused.\"\"\"\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n return rows[0][0] if rows else None\n\ndef apply_reset(token, new_password):\n uid = _consume(token)\n if uid is None:\n abort(400)\n set_password(uid, new_password)"} |
| {"id": "reset_token_reuse_covers_alt", "pattern": "reset_token_reuse", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "def _consume(token):\n \"\"\"Single-use: returns the user only if the row was still unused.\"\"\"\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n return rows[0][0] if rows else None\n\ndef apply_reset(token, new_password):\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n if not rows:\n abort(400)\n set_password(rows[0][0], new_password)"} |
| {"id": "reset_token_reuse_wrong_value", "pattern": "reset_token_reuse", "shape": "wrong_value", "label": "unsafe", "vuln_class": "authentication bypass", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "def _consume(token):\n \"\"\"Single-use: returns the user only if the row was still unused.\"\"\"\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n return rows[0][0] if rows else None\n\ndef apply_reset(token, confirm_token, new_password):\n _consume(confirm_token)\n uid = db.query(\"SELECT user_id FROM resets WHERE token = %s\", (token,))[0][0]\n set_password(uid, new_password)"} |
| {"id": "reset_token_reuse_irrelevant", "pattern": "reset_token_reuse", "shape": "irrelevant", "label": "unsafe", "vuln_class": "authentication bypass", "why": "a guard is applied to the right value but does not address this weakness", "code": "def _consume(token):\n \"\"\"Single-use: returns the user only if the row was still unused.\"\"\"\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n return rows[0][0] if rows else None\n\ndef apply_reset(token, new_password):\n row = db.query(\"SELECT user_id, created_at FROM resets WHERE token = %s\", (token,))[0]\n if (now() - row[1]).total_seconds() > 3600:\n abort(400)\n set_password(row[0], new_password)"} |
| {"id": "reset_token_reuse_elsewhere", "pattern": "reset_token_reuse", "shape": "elsewhere", "label": "unsafe", "vuln_class": "authentication bypass", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "def _consume(token):\n \"\"\"Single-use: returns the user only if the row was still unused.\"\"\"\n rows = db.execute(\n \"UPDATE resets SET used_at = now() WHERE token = %s AND used_at IS NULL RETURNING user_id\",\n (token,))\n return rows[0][0] if rows else None\n\ndef apply_invite(token):\n uid = _consume(token)\n if uid is None:\n abort(400)\n activate(uid)\n\ndef apply_reset(token, new_password):\n uid = db.query(\"SELECT user_id FROM resets WHERE token = %s\", (token,))[0][0]\n set_password(uid, new_password)"} |
| {"id": "dict_merge_none", "pattern": "dict_merge", "shape": "none", "label": "unsafe", "vuln_class": "mass assignment", "why": "no guard is applied on this path", "code": "PROTECTED = {\"is_admin\", \"org_id\", \"plan\", \"__class__\"}\n\ndef _merge_safe(target, patch):\n for k, v in patch.items():\n if k in PROTECTED:\n continue\n if isinstance(v, dict) and isinstance(target.get(k), dict):\n _merge_safe(target[k], v)\n else:\n target[k] = v\n return target\n\ndef update_settings(user, patch):\n return _deep_merge(user.settings, patch)"} |
| {"id": "dict_merge_covers", "pattern": "dict_merge", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "PROTECTED = {\"is_admin\", \"org_id\", \"plan\", \"__class__\"}\n\ndef _merge_safe(target, patch):\n for k, v in patch.items():\n if k in PROTECTED:\n continue\n if isinstance(v, dict) and isinstance(target.get(k), dict):\n _merge_safe(target[k], v)\n else:\n target[k] = v\n return target\n\ndef update_settings(user, patch):\n return _merge_safe(user.settings, patch)"} |
| {"id": "dict_merge_covers_alt", "pattern": "dict_merge", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "PROTECTED = {\"is_admin\", \"org_id\", \"plan\", \"__class__\"}\n\ndef _merge_safe(target, patch):\n for k, v in patch.items():\n if k in PROTECTED:\n continue\n if isinstance(v, dict) and isinstance(target.get(k), dict):\n _merge_safe(target[k], v)\n else:\n target[k] = v\n return target\n\ndef update_settings(user, patch):\n clean = {k: v for k, v in patch.items() if k not in PROTECTED}\n return _merge_safe(user.settings, clean)"} |
| {"id": "dict_merge_wrong_value", "pattern": "dict_merge", "shape": "wrong_value", "label": "unsafe", "vuln_class": "mass assignment", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "PROTECTED = {\"is_admin\", \"org_id\", \"plan\", \"__class__\"}\n\ndef _merge_safe(target, patch):\n for k, v in patch.items():\n if k in PROTECTED:\n continue\n if isinstance(v, dict) and isinstance(target.get(k), dict):\n _merge_safe(target[k], v)\n else:\n target[k] = v\n return target\n\ndef update_settings(user, patch, defaults):\n _merge_safe({}, defaults)\n return _deep_merge(user.settings, patch)"} |
| {"id": "dict_merge_irrelevant", "pattern": "dict_merge", "shape": "irrelevant", "label": "unsafe", "vuln_class": "mass assignment", "why": "a guard is applied to the right value but does not address this weakness", "code": "PROTECTED = {\"is_admin\", \"org_id\", \"plan\", \"__class__\"}\n\ndef _merge_safe(target, patch):\n for k, v in patch.items():\n if k in PROTECTED:\n continue\n if isinstance(v, dict) and isinstance(target.get(k), dict):\n _merge_safe(target[k], v)\n else:\n target[k] = v\n return target\n\ndef update_settings(user, patch):\n if len(patch) > 50:\n raise ValueError(\"too many keys\")\n return _deep_merge(user.settings, patch)"} |
| {"id": "dict_merge_elsewhere", "pattern": "dict_merge", "shape": "elsewhere", "label": "unsafe", "vuln_class": "mass assignment", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "PROTECTED = {\"is_admin\", \"org_id\", \"plan\", \"__class__\"}\n\ndef _merge_safe(target, patch):\n for k, v in patch.items():\n if k in PROTECTED:\n continue\n if isinstance(v, dict) and isinstance(target.get(k), dict):\n _merge_safe(target[k], v)\n else:\n target[k] = v\n return target\n\ndef update_org_settings(org, patch):\n return _merge_safe(org.settings, patch)\n\ndef update_settings(user, patch):\n return _deep_merge(user.settings, patch)"} |
| {"id": "arg_injection_none", "pattern": "arg_injection", "shape": "none", "label": "unsafe", "vuln_class": "argument injection", "why": "no guard is applied on this path", "code": "import subprocess\n\ndef _as_operand(value):\n \"\"\"Stops a value beginning with '-' from being read as a flag.\"\"\"\n if value.startswith(\"-\"):\n raise ValueError(\"operand may not start with a dash\")\n return value\n\ndef count_matches(pattern, path):\n return subprocess.run([\"grep\", \"-c\", pattern, path], capture_output=True).stdout"} |
| {"id": "arg_injection_covers", "pattern": "arg_injection", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import subprocess\n\ndef _as_operand(value):\n \"\"\"Stops a value beginning with '-' from being read as a flag.\"\"\"\n if value.startswith(\"-\"):\n raise ValueError(\"operand may not start with a dash\")\n return value\n\ndef count_matches(pattern, path):\n return subprocess.run([\"grep\", \"-c\", \"-e\", pattern, \"--\", path],\n capture_output=True).stdout"} |
| {"id": "arg_injection_covers_alt", "pattern": "arg_injection", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import subprocess\n\ndef _as_operand(value):\n \"\"\"Stops a value beginning with '-' from being read as a flag.\"\"\"\n if value.startswith(\"-\"):\n raise ValueError(\"operand may not start with a dash\")\n return value\n\ndef count_matches(pattern, path):\n return subprocess.run([\"grep\", \"-c\", \"--\", _as_operand(pattern), _as_operand(path)],\n capture_output=True).stdout"} |
| {"id": "arg_injection_wrong_value", "pattern": "arg_injection", "shape": "wrong_value", "label": "unsafe", "vuln_class": "argument injection", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import subprocess\n\ndef _as_operand(value):\n \"\"\"Stops a value beginning with '-' from being read as a flag.\"\"\"\n if value.startswith(\"-\"):\n raise ValueError(\"operand may not start with a dash\")\n return value\n\ndef count_matches(pattern, path):\n _as_operand(path)\n return subprocess.run([\"grep\", \"-c\", pattern, path], capture_output=True).stdout"} |
| {"id": "arg_injection_irrelevant", "pattern": "arg_injection", "shape": "irrelevant", "label": "unsafe", "vuln_class": "argument injection", "why": "a guard is applied to the right value but does not address this weakness", "code": "import subprocess\n\ndef _as_operand(value):\n \"\"\"Stops a value beginning with '-' from being read as a flag.\"\"\"\n if value.startswith(\"-\"):\n raise ValueError(\"operand may not start with a dash\")\n return value\n\ndef count_matches(pattern, path):\n if \";\" in pattern or \"|\" in pattern or \"$\" in pattern:\n raise ValueError(\"shell metacharacter\")\n return subprocess.run([\"grep\", \"-c\", pattern, path], capture_output=True).stdout"} |
| {"id": "arg_injection_elsewhere", "pattern": "arg_injection", "shape": "elsewhere", "label": "unsafe", "vuln_class": "argument injection", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import subprocess\n\ndef _as_operand(value):\n \"\"\"Stops a value beginning with '-' from being read as a flag.\"\"\"\n if value.startswith(\"-\"):\n raise ValueError(\"operand may not start with a dash\")\n return value\n\ndef list_matches(pattern, path):\n return subprocess.run([\"grep\", \"-n\", \"-e\", pattern, \"--\", path],\n capture_output=True).stdout\n\ndef count_matches(pattern, path):\n return subprocess.run([\"grep\", \"-c\", pattern, path], capture_output=True).stdout"} |
| {"id": "tar_symlink_none", "pattern": "tar_symlink", "shape": "none", "label": "unsafe", "vuln_class": "path traversal", "why": "no guard is applied on this path", "code": "import tarfile, os\n\ndef _safe_members(tar, root):\n root = os.path.realpath(root)\n for m in tar.getmembers():\n if m.issym() or m.islnk():\n continue\n dest = os.path.realpath(os.path.join(root, m.name))\n if os.path.commonpath([dest, root]) != root:\n raise ValueError(\"entry escapes destination\")\n yield m\n\ndef unpack_bundle(path, dest):\n with tarfile.open(path) as t:\n t.extractall(dest)"} |
| {"id": "tar_symlink_covers", "pattern": "tar_symlink", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import tarfile, os\n\ndef _safe_members(tar, root):\n root = os.path.realpath(root)\n for m in tar.getmembers():\n if m.issym() or m.islnk():\n continue\n dest = os.path.realpath(os.path.join(root, m.name))\n if os.path.commonpath([dest, root]) != root:\n raise ValueError(\"entry escapes destination\")\n yield m\n\ndef unpack_bundle(path, dest):\n with tarfile.open(path) as t:\n t.extractall(dest, members=_safe_members(t, dest))"} |
| {"id": "tar_symlink_covers_alt", "pattern": "tar_symlink", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import tarfile, os\n\ndef _safe_members(tar, root):\n root = os.path.realpath(root)\n for m in tar.getmembers():\n if m.issym() or m.islnk():\n continue\n dest = os.path.realpath(os.path.join(root, m.name))\n if os.path.commonpath([dest, root]) != root:\n raise ValueError(\"entry escapes destination\")\n yield m\n\ndef unpack_bundle(path, dest):\n with tarfile.open(path) as t:\n t.extractall(dest, filter=\"data\")"} |
| {"id": "tar_symlink_wrong_value", "pattern": "tar_symlink", "shape": "wrong_value", "label": "unsafe", "vuln_class": "path traversal", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import tarfile, os\n\ndef _safe_members(tar, root):\n root = os.path.realpath(root)\n for m in tar.getmembers():\n if m.issym() or m.islnk():\n continue\n dest = os.path.realpath(os.path.join(root, m.name))\n if os.path.commonpath([dest, root]) != root:\n raise ValueError(\"entry escapes destination\")\n yield m\n\ndef unpack_bundle(path, dest, staging):\n with tarfile.open(path) as t:\n list(_safe_members(t, staging))\n t.extractall(dest)"} |
| {"id": "tar_symlink_irrelevant", "pattern": "tar_symlink", "shape": "irrelevant", "label": "unsafe", "vuln_class": "path traversal", "why": "a guard is applied to the right value but does not address this weakness", "code": "import tarfile, os\n\ndef _safe_members(tar, root):\n root = os.path.realpath(root)\n for m in tar.getmembers():\n if m.issym() or m.islnk():\n continue\n dest = os.path.realpath(os.path.join(root, m.name))\n if os.path.commonpath([dest, root]) != root:\n raise ValueError(\"entry escapes destination\")\n yield m\n\ndef unpack_bundle(path, dest):\n with tarfile.open(path) as t:\n if sum(m.size for m in t.getmembers()) > 100 * 1024 * 1024:\n raise ValueError(\"bundle too large\")\n t.extractall(dest)"} |
| {"id": "tar_symlink_elsewhere", "pattern": "tar_symlink", "shape": "elsewhere", "label": "unsafe", "vuln_class": "path traversal", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import tarfile, os\n\ndef _safe_members(tar, root):\n root = os.path.realpath(root)\n for m in tar.getmembers():\n if m.issym() or m.islnk():\n continue\n dest = os.path.realpath(os.path.join(root, m.name))\n if os.path.commonpath([dest, root]) != root:\n raise ValueError(\"entry escapes destination\")\n yield m\n\ndef unpack_theme(path, dest):\n with tarfile.open(path) as t:\n t.extractall(dest, members=_safe_members(t, dest))\n\ndef unpack_bundle(path, dest):\n with tarfile.open(path) as t:\n t.extractall(dest)"} |
| {"id": "jwt_audience_none", "pattern": "jwt_audience", "shape": "none", "label": "unsafe", "vuln_class": "authentication bypass", "why": "no guard is applied on this path", "code": "import jwt\n\nISSUER = \"https://auth.example.com/\"\nAUDIENCE = \"api.example.com\"\n\ndef _claims(token, key):\n return jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n\ndef current_user(token, key):\n claims = jwt.decode(token, key, algorithms=[\"RS256\"])\n return User.get(claims[\"sub\"])"} |
| {"id": "jwt_audience_covers", "pattern": "jwt_audience", "shape": "covers", "label": "safe", "vuln_class": null, "why": "the guard is applied to the tainted value and addresses the weakness", "code": "import jwt\n\nISSUER = \"https://auth.example.com/\"\nAUDIENCE = \"api.example.com\"\n\ndef _claims(token, key):\n return jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n\ndef current_user(token, key):\n return User.get(_claims(token, key)[\"sub\"])"} |
| {"id": "jwt_audience_covers_alt", "pattern": "jwt_audience", "shape": "covers_alt", "label": "safe", "vuln_class": null, "why": "a second correct implementation, defended a different way", "code": "import jwt\n\nISSUER = \"https://auth.example.com/\"\nAUDIENCE = \"api.example.com\"\n\ndef _claims(token, key):\n return jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n\ndef current_user(token, key):\n claims = jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n return User.get(claims[\"sub\"])"} |
| {"id": "jwt_audience_wrong_value", "pattern": "jwt_audience", "shape": "wrong_value", "label": "unsafe", "vuln_class": "authentication bypass", "why": "the guard is applied to a sibling value, not the one that reaches the sink", "code": "import jwt\n\nISSUER = \"https://auth.example.com/\"\nAUDIENCE = \"api.example.com\"\n\ndef _claims(token, key):\n return jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n\ndef current_user(token, refresh_token, key):\n _claims(refresh_token, key)\n claims = jwt.decode(token, key, algorithms=[\"RS256\"])\n return User.get(claims[\"sub\"])"} |
| {"id": "jwt_audience_irrelevant", "pattern": "jwt_audience", "shape": "irrelevant", "label": "unsafe", "vuln_class": "authentication bypass", "why": "a guard is applied to the right value but does not address this weakness", "code": "import jwt\n\nISSUER = \"https://auth.example.com/\"\nAUDIENCE = \"api.example.com\"\n\ndef _claims(token, key):\n return jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n\ndef current_user(token, key):\n claims = jwt.decode(token, key, algorithms=[\"RS256\"])\n if claims.get(\"exp\", 0) < time.time():\n abort(401)\n return User.get(claims[\"sub\"])"} |
| {"id": "jwt_audience_elsewhere", "pattern": "jwt_audience", "shape": "elsewhere", "label": "unsafe", "vuln_class": "authentication bypass", "why": "the guard exists and is used by a neighbouring function, not on this path", "code": "import jwt\n\nISSUER = \"https://auth.example.com/\"\nAUDIENCE = \"api.example.com\"\n\ndef _claims(token, key):\n return jwt.decode(token, key, algorithms=[\"RS256\"],\n audience=AUDIENCE, issuer=ISSUER,\n options={\"require\": [\"exp\", \"iss\", \"aud\", \"sub\"]})\n\ndef service_account(token, key):\n return Service.get(_claims(token, key)[\"sub\"])\n\ndef current_user(token, key):\n claims = jwt.decode(token, key, algorithms=[\"RS256\"])\n return User.get(claims[\"sub\"])"} |
|
|
