feat(guardrails): secure-by-default rule and /guardrails scanner
Always-on rules/secure-by-default.md: hosting, a11y, Supabase RLS, SMS/email consent, cloud functions, API hygiene incl. password storage. Stdlib scanner (FAIL/WARN/MANUAL) + skill, 89-check suite, auditor gate wiring, profiles, routing row (plus Explore rows confirmed through the router dialog).
This commit is contained in:
1 parent
c5fad5ee8f
commit
558c49e1a1
45 files changed
+2473
-5
No files matched your search
@@ -0,0 +1 @@
|
||||
"""Static guardrail checks, one module per domain."""
|
||||
@@ -0,0 +1,239 @@
|
||||
"""Accessibility checks: keyboard, visible focus, alt text, field labels."""
|
||||
import re
|
||||
from collections import namedtuple
|
||||
|
||||
from .common import Rule, blank_markup_comments
|
||||
|
||||
DOMAIN = "a11y"
|
||||
MARKUP_EXTS = (".html", ".htm", ".jsx", ".tsx", ".vue", ".svelte", ".astro")
|
||||
STYLE_EXTS = (".css", ".scss", ".sass", ".less")
|
||||
SCRIPT_EXTS = (".ts", ".js", ".mjs")
|
||||
FIELD_TAGS = {"input", "select", "textarea"}
|
||||
CLICK_TAGS = {"div", "span", "li", "p", "td", "tr", "section", "article"}
|
||||
SKIP_INPUT_TYPES = {"hidden", "submit", "button", "reset", "image"}
|
||||
INTERACTIVE = {"*", "a", "button", "input", "select", "textarea", "summary"}
|
||||
|
||||
_BRACES = r"\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\}"
|
||||
TAG = re.compile(
|
||||
r"<(?P<name>[A-Za-z][\w.:-]*)(?P<attrs>(?:[^<>{}]|" + _BRACES + r")*)>")
|
||||
SPREAD = re.compile(r"\{\s*\.\.\.|v-bind\s*=")
|
||||
CLICK = re.compile(
|
||||
r"(?<![\w-])(?:onclick|@click|v-on:click|on:click)(?![\w-])", re.I)
|
||||
KEYS = re.compile(
|
||||
r"(?<![\w-])(?:onkey(?:down|up|press)|@key(?:down|up|press)"
|
||||
r"|v-on:key(?:down|up|press)|on:key(?:down|up|press))(?![\w-])", re.I)
|
||||
POSITIVE_TABINDEX = re.compile(
|
||||
r"(?<![\w-])tabindex\s*=\s*[{\"']*\s*[1-9]", re.I)
|
||||
STYLE_TAG = re.compile(r"<style\b[^>]*>(.*?)</style>", re.I | re.S)
|
||||
CSS_RULE = re.compile(r"(?P<sel>[^{}]+)\{(?P<body>[^{}]*)\}")
|
||||
OUTLINE_OFF = re.compile(r"outline(?:-style)?\s*:\s*(?:none|0)\b", re.I)
|
||||
REPLACEMENT = re.compile(
|
||||
r"(?:box-shadow|border(?:-color)?)\s*:\s*(?!none\b|0\b)", re.I)
|
||||
NOT_A_CONTROL = re.compile(
|
||||
r"role\s*=\s*[\"'{]\s*[\"']?(?:presentation|none|dialog|alertdialog)\b"
|
||||
r"|stopPropagation", re.I)
|
||||
TW_STRING = re.compile(
|
||||
r"[\"'`]([^\"'`\n]*\boutline-(?:none|hidden)\b[^\"'`\n]*)[\"'`]")
|
||||
TW_REPLACED = re.compile(
|
||||
r"\bfocus(?:-visible|-within)?:(?:ring|outline\b(?!-none|-hidden)"
|
||||
r"|shadow|border|underline|bg-)")
|
||||
|
||||
|
||||
def applies(project):
|
||||
return bool(project.with_ext(*MARKUP_EXTS, *STYLE_EXTS))
|
||||
|
||||
|
||||
def has_attr(attrs, name):
|
||||
pattern = (r"(?<![\w-])(?:v-bind:|bind:|:)?" + re.escape(name)
|
||||
+ r"(?=[\s=/]|$)")
|
||||
return re.search(pattern, attrs, re.I) is not None
|
||||
|
||||
|
||||
def attr_value(attrs, name):
|
||||
"""Literal value, '{expr}' for a braced value, None if absent."""
|
||||
pattern = (r"(?<![\w:-])" + re.escape(name)
|
||||
+ r"\s*=\s*(?:\"([^\"]*)\"|'([^']*)'|\{([^}]*)\})")
|
||||
m = re.search(pattern, attrs, re.I)
|
||||
if not m:
|
||||
return None
|
||||
literal = m.group(1) if m.group(1) is not None else m.group(2)
|
||||
return literal if literal is not None else "{" + m.group(3) + "}"
|
||||
|
||||
|
||||
def check(project):
|
||||
out = []
|
||||
for path in project.with_ext(*MARKUP_EXTS):
|
||||
text = blank_markup_comments(project.text(path))
|
||||
out += _tag_findings(project, path, text)
|
||||
return out + _focus_css(project) + _focus_tailwind(project)
|
||||
|
||||
|
||||
def _tag_findings(project, path, text):
|
||||
out = []
|
||||
for m in TAG.finditer(text):
|
||||
for rule, severity, message in _tag_issues(m, text):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, rule, severity), path, m.start(), message))
|
||||
return out
|
||||
|
||||
|
||||
def _tag_issues(m, text):
|
||||
name, attrs = m["name"], m["attrs"]
|
||||
if SPREAD.search(attrs):
|
||||
return []
|
||||
issues = [_tabindex_issue(attrs)]
|
||||
if name.lower() == "img" or name == "Image":
|
||||
issues.append(_img_issue(attrs))
|
||||
elif name in FIELD_TAGS:
|
||||
issues.append(_field_issue(m, text))
|
||||
elif name in CLICK_TAGS:
|
||||
issues.append(_click_issue(attrs))
|
||||
return [issue for issue in issues if issue]
|
||||
|
||||
|
||||
def _img_issue(attrs):
|
||||
if has_attr(attrs, "alt"):
|
||||
return None
|
||||
return ("A11Y-IMG-ALT", "FAIL",
|
||||
'image without alt: describe it, or alt="" when decorative')
|
||||
|
||||
|
||||
def _tabindex_issue(attrs):
|
||||
if not POSITIVE_TABINDEX.search(attrs):
|
||||
return None
|
||||
return ("A11Y-TABINDEX-POSITIVE", "WARN",
|
||||
"positive tabindex breaks the natural keyboard order")
|
||||
|
||||
|
||||
def _click_issue(attrs):
|
||||
if not CLICK.search(attrs) or NOT_A_CONTROL.search(attrs):
|
||||
return None
|
||||
if attrs.rstrip().endswith("/"): # empty overlay, nothing to operate
|
||||
return None
|
||||
missing = [label for label, ok in (
|
||||
("role", has_attr(attrs, "role")),
|
||||
("tabindex", has_attr(attrs, "tabindex")),
|
||||
("key handler", bool(KEYS.search(attrs))),
|
||||
) if not ok]
|
||||
if not missing:
|
||||
return None
|
||||
return ("A11Y-CLICK-NO-KEYBOARD", "FAIL",
|
||||
"click handler on a non-interactive element, missing "
|
||||
+ ", ".join(missing) + ": use a <button>")
|
||||
|
||||
|
||||
def _field_issue(m, text):
|
||||
attrs = m["attrs"]
|
||||
kind = (attr_value(attrs, "type") or "text").lower()
|
||||
if kind in SKIP_INPUT_TYPES or _is_hidden_field(attrs):
|
||||
return None
|
||||
if _is_labelled(attrs, text, m.start()):
|
||||
return None
|
||||
return ("A11Y-FIELD-LABEL", "FAIL",
|
||||
"form field without a label: add <label for>, a wrapping "
|
||||
"<label> or aria-label (a placeholder is not a label)")
|
||||
|
||||
|
||||
def _is_hidden_field(attrs):
|
||||
"""Fields that are never rendered need no label."""
|
||||
if has_attr(attrs, "hidden"):
|
||||
return True
|
||||
classes = attr_value(attrs, "className") or attr_value(attrs, "class")
|
||||
if "hidden" in (classes or "").split():
|
||||
return True
|
||||
return re.search(r"display\s*:\s*['\"]?none", attrs) is not None
|
||||
|
||||
|
||||
def _is_labelled(attrs, text, position):
|
||||
if has_attr(attrs, "aria-label") or has_attr(attrs, "aria-labelledby"):
|
||||
return True
|
||||
before = text[:position].lower()
|
||||
if before.count("<label") > before.count("</label"):
|
||||
return True
|
||||
ident = attr_value(attrs, "id")
|
||||
if ident is None:
|
||||
return has_attr(attrs, "id") # bound id: cannot tell, assume ok
|
||||
if not re.fullmatch(r"[\w-]+", ident):
|
||||
return True
|
||||
return re.search(
|
||||
r"(?:for|htmlFor)\s*=\s*[\"']" + re.escape(ident) + r"[\"']",
|
||||
text) is not None
|
||||
|
||||
|
||||
Block = namedtuple("Block", "path css start")
|
||||
|
||||
|
||||
def _style_blocks(project):
|
||||
"""Yield a Block for each CSS source: stylesheets and <style> tags."""
|
||||
for path in project.with_ext(*STYLE_EXTS):
|
||||
yield Block(path, blank_markup_comments(project.text(path)), 0)
|
||||
for path in project.with_ext(*MARKUP_EXTS):
|
||||
for m in STYLE_TAG.finditer(project.text(path)):
|
||||
yield Block(path, blank_markup_comments(m.group(1)), m.start(1))
|
||||
|
||||
|
||||
def _targets_focus(selector):
|
||||
for part in selector.split(","):
|
||||
part = part.strip()
|
||||
last = re.split(r"[\s>+~]+", part)[-1] if part else ""
|
||||
if ":focus" in part or last in INTERACTIVE:
|
||||
return True
|
||||
if last.startswith("[tabindex"):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def _kills_focus_ring(selector, body):
|
||||
return (OUTLINE_OFF.search(body) is not None
|
||||
and _targets_focus(selector)
|
||||
and ":not(:focus-visible)" not in selector
|
||||
and REPLACEMENT.search(body) is None)
|
||||
|
||||
|
||||
def _focus_visible_defined(project, blocks):
|
||||
if any(":focus-visible" in block.css for block in blocks):
|
||||
return True
|
||||
return project.has(r"focus-visible:", project.with_ext(*MARKUP_EXTS))
|
||||
|
||||
|
||||
def _lead(text):
|
||||
return len(text) - len(text.lstrip())
|
||||
|
||||
|
||||
def _css_findings(project, block, covered):
|
||||
out = []
|
||||
for rule in CSS_RULE.finditer(block.css):
|
||||
if _kills_focus_ring(rule["sel"], rule["body"]):
|
||||
offset = block.start + rule.start("sel") + _lead(rule["sel"])
|
||||
out.append(_outline_finding(project, block.path, offset, covered))
|
||||
return out
|
||||
|
||||
|
||||
def _focus_css(project):
|
||||
blocks = list(_style_blocks(project))
|
||||
covered = _focus_visible_defined(project, blocks)
|
||||
out = []
|
||||
for block in blocks:
|
||||
out += _css_findings(project, block, covered)
|
||||
return out
|
||||
|
||||
|
||||
def _outline_finding(project, path, offset, covered):
|
||||
if covered:
|
||||
return project.found(
|
||||
Rule(DOMAIN, "A11Y-FOCUS-OUTLINE", "WARN"), path, offset,
|
||||
"outline removed here: confirm a :focus-visible style covers it")
|
||||
return project.found(
|
||||
Rule(DOMAIN, "A11Y-FOCUS-OUTLINE", "FAIL"), path, offset,
|
||||
"focus outline removed and no :focus-visible style exists")
|
||||
|
||||
|
||||
def _focus_tailwind(project):
|
||||
out = []
|
||||
files = project.with_ext(*MARKUP_EXTS, *SCRIPT_EXTS)
|
||||
for path, m in project.matches(TW_STRING.pattern, files, 0):
|
||||
if not TW_REPLACED.search(m.group(1)):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "A11Y-FOCUS-OUTLINE", "FAIL"), path, m.start(),
|
||||
"outline-none without a focus-visible ring replacement"))
|
||||
return out
|
||||
@@ -0,0 +1,173 @@
|
||||
"""Checks for every project: secrets, public env vars, CORS, route auth."""
|
||||
import fnmatch
|
||||
import re
|
||||
|
||||
from . import passwords
|
||||
from .common import Rule, SOURCE_EXTS, non_doc_files, redact
|
||||
|
||||
DOMAIN = "api"
|
||||
|
||||
SECRET_PATTERNS = [
|
||||
("Stripe live key", r"sk_live_[0-9A-Za-z]{10,}"),
|
||||
("AWS access key id", r"AKIA[0-9A-Z]{16}"),
|
||||
("GitHub token", r"gh[pousr]_[A-Za-z0-9]{30,}"),
|
||||
("Slack token", r"xox[abprs]-[A-Za-z0-9-]{10,}"),
|
||||
("SendGrid key", r"SG\.[A-Za-z0-9_-]{16,}\.[A-Za-z0-9_-]{16,}"),
|
||||
("Supabase secret key", r"sb_secret_[A-Za-z0-9_-]{10,}"),
|
||||
("private key block", r"-----BEGIN (?:[A-Z]+ )?PRIVATE KEY-----"
|
||||
r"(?:\\n|\s)*[A-Za-z0-9+/=]{20,}"),
|
||||
]
|
||||
PUBLIC_ENV = (
|
||||
r"\b(?:NEXT_PUBLIC|VITE|REACT_APP|EXPO_PUBLIC|NUXT_PUBLIC|GATSBY"
|
||||
r"|VUE_APP|PUBLIC)_\w*(?:SERVICE_ROLE|SECRET|PRIVATE|PASSWORD)\w*"
|
||||
)
|
||||
CORS_WILDCARD = (
|
||||
r"Access-Control-Allow-Origin['\"]?\s*[:,=)]\s*['\"]\*['\"]"
|
||||
r"|\borigin\s*:\s*(?:['\"]\*['\"]|true)\b"
|
||||
r"|allow_origins\s*=\s*\[\s*['\"]\*['\"]"
|
||||
r"|allow_any_origin\(\)|CorsLayer::permissive\(\)"
|
||||
)
|
||||
CORS_CREDENTIALS = (
|
||||
r"credentials\s*:\s*true|Allow-Credentials|allow_credentials\s*=\s*True"
|
||||
r"|allow_credentials\(true\)|supports_credentials"
|
||||
)
|
||||
ROUTE_PATH = re.compile(
|
||||
r"(?:^|/)(?:api|routes|controllers|handlers)/"
|
||||
r"|(?:^|/)route\.[jt]s$|\+server\.[jt]s$"
|
||||
r"|(?:^|/)supabase/functions/[^/]+/index\.", re.I)
|
||||
API_DIR = re.compile(r"(?:^|/)api/", re.I)
|
||||
UI_EXTS = (".tsx", ".jsx", ".vue", ".svelte", ".astro")
|
||||
ROUTE_SKIP = re.compile(
|
||||
r"_shared|\.test\.|\.spec\.|health|ping|status|robots|sitemap"
|
||||
r"|favicon|/og[./]"
|
||||
r"|(?:^|/)(?:bin|scripts?|cron|jobs?|tests?|__tests__|migrations?"
|
||||
r"|seeds?|public|config|helpers?|libs?|models?|utils?|services?"
|
||||
r"|middleware|core|includes|types|schemas?|constants|templates?"
|
||||
r"|views?)/", re.I)
|
||||
AUTH_EVIDENCE = re.compile(
|
||||
r"\b(?:auth\w*|getUser|getSession|session|jwt\w*|bearer|verify\w*"
|
||||
r"|signature|hmac|login_required|Depends|requireAuth|requireUser"
|
||||
r"|requireRole|guard|permission\w*|clerk\w*|csrf)\b", re.I)
|
||||
ENV_NAME = re.compile(r"\.env(?:\.[\w.-]+)?")
|
||||
ENV_SAMPLE = (".example", ".sample", ".template", ".dist")
|
||||
|
||||
|
||||
def applies(project):
|
||||
return True
|
||||
|
||||
|
||||
def ignore_patterns(project):
|
||||
"""Patterns from every .gitignore in the tree."""
|
||||
patterns = []
|
||||
for gitignore in project.named(".gitignore"):
|
||||
for line in project.text(gitignore).splitlines():
|
||||
line = line.strip()
|
||||
if line and not line.startswith(("#", "!")):
|
||||
patterns.append(line.strip("/"))
|
||||
return patterns
|
||||
|
||||
|
||||
def is_ignored_env(path, patterns):
|
||||
"""True for an env file that .gitignore keeps out of git."""
|
||||
return bool(ENV_NAME.fullmatch(path.name)) and any(
|
||||
fnmatch.fnmatch(path.name, pat) for pat in patterns)
|
||||
|
||||
|
||||
def _is_route(rel, ext):
|
||||
if ROUTE_SKIP.search(rel) or not ROUTE_PATH.search(rel):
|
||||
return False
|
||||
return ext not in UI_EXTS or bool(API_DIR.search(rel))
|
||||
|
||||
|
||||
def route_files(project):
|
||||
return [
|
||||
p for p in project.with_ext(*SOURCE_EXTS)
|
||||
if _is_route(project.rel(p), p.suffix.lower())
|
||||
]
|
||||
|
||||
|
||||
def check(project):
|
||||
return (_secret_literals(project) + _public_env(project)
|
||||
+ _unignored_env(project) + _cors(project)
|
||||
+ _routes_without_auth(project) + passwords.check(project))
|
||||
|
||||
|
||||
def _unignored_files(project):
|
||||
patterns = ignore_patterns(project)
|
||||
return [p for p in non_doc_files(project)
|
||||
if not is_ignored_env(p, patterns)]
|
||||
|
||||
|
||||
def _literal_hits(project, files, label, pattern):
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "API-SECRET-LITERAL", "FAIL"), path, m.start(),
|
||||
f"{label} hardcoded ({redact(m.group())}): "
|
||||
"move it to env and rotate it")
|
||||
for path, m in project.matches(pattern, files, 0)
|
||||
]
|
||||
|
||||
|
||||
def _secret_literals(project):
|
||||
files = _unignored_files(project)
|
||||
out = []
|
||||
for label, pattern in SECRET_PATTERNS:
|
||||
out += _literal_hits(project, files, label, pattern)
|
||||
return out
|
||||
|
||||
|
||||
def _public_env(project):
|
||||
files = [p for p in project.files
|
||||
if p.suffix.lower() not in (".md", ".mdx")]
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "API-PUBLIC-ENV-SECRET", "FAIL"), path, m.start(),
|
||||
f"{m.group()} ships to the browser: secrets stay server-side")
|
||||
for path, m in project.matches(PUBLIC_ENV, files, 0)
|
||||
]
|
||||
|
||||
|
||||
def _has_value(text):
|
||||
return re.search(r"^\s*[A-Za-z_]\w*\s*=\s*\S", text, re.M) is not None
|
||||
|
||||
|
||||
def _unignored_env(project):
|
||||
patterns = ignore_patterns(project)
|
||||
out = []
|
||||
for path in project.files:
|
||||
if not ENV_NAME.fullmatch(path.name):
|
||||
continue
|
||||
if path.name.endswith(ENV_SAMPLE) or not _has_value(project.text(path)):
|
||||
continue
|
||||
if not is_ignored_env(path, patterns):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "API-ENV-NOT-IGNORED", "FAIL"), path, 0,
|
||||
f"{path.name} holds values and is not in .gitignore"))
|
||||
return out
|
||||
|
||||
|
||||
def _cors_finding(project, path, m):
|
||||
creds = re.search(CORS_CREDENTIALS, project.text(path), re.I)
|
||||
note = " with credentials" if creds else ""
|
||||
return project.found(
|
||||
Rule(DOMAIN, "API-CORS-WILDCARD", "FAIL" if creds else "WARN"),
|
||||
path, m.start(),
|
||||
f"CORS allows any origin{note}: use an explicit allowlist")
|
||||
|
||||
|
||||
def _cors(project):
|
||||
return [
|
||||
_cors_finding(project, path, m)
|
||||
for path, m in project.matches(CORS_WILDCARD, non_doc_files(project))
|
||||
]
|
||||
|
||||
|
||||
def _routes_without_auth(project):
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "API-ROUTE-NO-AUTH", "WARN"), path, 0,
|
||||
"no authentication evidence in this route; if it is public "
|
||||
"on purpose, say so and rate limit it")
|
||||
for path in route_files(project)
|
||||
if not AUTH_EVIDENCE.search(project.text(path))
|
||||
]
|
||||
@@ -0,0 +1,163 @@
|
||||
"""Shared types and file helpers for the guardrails checks."""
|
||||
import os
|
||||
import re
|
||||
from dataclasses import asdict, dataclass
|
||||
from pathlib import Path
|
||||
|
||||
SKIP_DIRS = {
|
||||
".git", "node_modules", "dist", "build", ".next", ".astro", "target",
|
||||
"vendor", ".venv", "venv", "coverage", "__pycache__", ".svelte-kit",
|
||||
".nuxt", ".output", ".turbo", ".vercel", ".cache", ".phpunit.cache",
|
||||
".pytest_cache", ".mypy_cache",
|
||||
}
|
||||
SKIP_FILES = {
|
||||
"package-lock.json", "pnpm-lock.yaml", "yarn.lock", "Cargo.lock",
|
||||
"bun.lockb", "poetry.lock", "composer.lock",
|
||||
}
|
||||
BINARY_EXTS = {
|
||||
".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".pdf",
|
||||
".woff", ".woff2", ".ttf", ".otf", ".zip", ".gz", ".mp4", ".mov",
|
||||
".mp3", ".wasm", ".log",
|
||||
}
|
||||
MAX_BYTES = 1_000_000
|
||||
SOURCE_EXTS = {
|
||||
".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".py", ".rs", ".go",
|
||||
".php", ".rb", ".vue", ".svelte", ".astro",
|
||||
}
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Rule:
|
||||
domain: str
|
||||
id: str
|
||||
severity: str # FAIL | WARN | MANUAL
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Finding:
|
||||
domain: str
|
||||
rule: str
|
||||
severity: str # FAIL | WARN | MANUAL
|
||||
path: str
|
||||
line: int
|
||||
message: str
|
||||
|
||||
def as_dict(self):
|
||||
return asdict(self)
|
||||
|
||||
|
||||
def line_of(text, offset):
|
||||
return text.count("\n", 0, offset) + 1
|
||||
|
||||
|
||||
def redact(value):
|
||||
return value[:6] + "..."
|
||||
|
||||
|
||||
SQL_COMMENT = re.compile(r"--[^\n]*|/\*.*?\*/", re.S)
|
||||
MARKUP_COMMENT = re.compile(
|
||||
r"<!--.*?-->|/\*.*?\*/|(?:^|(?<=\s))//[^\n]*", re.S | re.M)
|
||||
|
||||
|
||||
def _blank(pattern, text):
|
||||
"""Replace matches with spaces, keeping offsets and newlines."""
|
||||
return pattern.sub(lambda m: re.sub(r"[^\n]", " ", m.group()), text)
|
||||
|
||||
|
||||
def blank_comments(text):
|
||||
return _blank(SQL_COMMENT, text)
|
||||
|
||||
|
||||
def blank_markup_comments(text):
|
||||
return _blank(MARKUP_COMMENT, text)
|
||||
|
||||
|
||||
def _is_scannable(path):
|
||||
if path.name in SKIP_FILES or path.suffix.lower() in BINARY_EXTS:
|
||||
return False
|
||||
try:
|
||||
return (path.is_file() and not path.is_symlink()
|
||||
and path.stat().st_size <= MAX_BYTES)
|
||||
except OSError:
|
||||
return False
|
||||
|
||||
|
||||
def _excluded(root, path, prefixes):
|
||||
rel = Path(path).relative_to(root).as_posix()
|
||||
return any(rel == p or rel.startswith(p + "/") for p in prefixes)
|
||||
|
||||
|
||||
def _kept_dirs(root, base, dirs, prefixes):
|
||||
return [
|
||||
d for d in dirs
|
||||
if d not in SKIP_DIRS and not _excluded(root, Path(base) / d, prefixes)
|
||||
]
|
||||
|
||||
|
||||
def _kept_files(root, base, names, prefixes):
|
||||
for name in names:
|
||||
path = Path(base) / name
|
||||
if _is_scannable(path) and not _excluded(root, path, prefixes):
|
||||
yield path
|
||||
|
||||
|
||||
def _walk(root, prefixes):
|
||||
for base, dirs, names in os.walk(root):
|
||||
dirs[:] = _kept_dirs(root, base, dirs, prefixes)
|
||||
yield from _kept_files(root, base, names, prefixes)
|
||||
|
||||
|
||||
class Project:
|
||||
"""A directory tree read as data. Nothing in it is ever executed."""
|
||||
|
||||
def __init__(self, root, exclude=()):
|
||||
self.root = Path(root).resolve()
|
||||
prefixes = [e.strip("/") for e in exclude if e.strip("/")]
|
||||
self.files = sorted(_walk(self.root, prefixes))
|
||||
self._text = {}
|
||||
|
||||
def rel(self, path):
|
||||
return path.relative_to(self.root).as_posix()
|
||||
|
||||
def text(self, path):
|
||||
if path not in self._text:
|
||||
try:
|
||||
self._text[path] = path.read_text(
|
||||
encoding="utf-8", errors="ignore")
|
||||
except OSError:
|
||||
self._text[path] = ""
|
||||
return self._text[path]
|
||||
|
||||
def with_ext(self, *exts):
|
||||
return [p for p in self.files if p.suffix.lower() in exts]
|
||||
|
||||
def named(self, *names):
|
||||
return [p for p in self.files if p.name in names]
|
||||
|
||||
def segments(self, path):
|
||||
return self.rel(path).split("/")[:-1]
|
||||
|
||||
def matches(self, pattern, files=None, flags=re.I):
|
||||
"""Yield (path, match) for each regex hit in the given files."""
|
||||
regex = re.compile(pattern, flags)
|
||||
for path in (self.files if files is None else files):
|
||||
for match in regex.finditer(self.text(path)):
|
||||
yield path, match
|
||||
|
||||
def has(self, pattern, files=None, flags=re.I):
|
||||
return next(self.matches(pattern, files, flags), None) is not None
|
||||
|
||||
def found(self, rule, path, offset, message):
|
||||
line = line_of(self.text(path), offset) if offset else 1
|
||||
return Finding(
|
||||
rule.domain, rule.id, rule.severity, self.rel(path), line,
|
||||
message)
|
||||
|
||||
def found_at_root(self, domain, rule, severity, message):
|
||||
return Finding(domain, rule, severity, ".", 1, message)
|
||||
|
||||
|
||||
def non_doc_files(project):
|
||||
"""Files that can hold behavior: everything except docs and samples."""
|
||||
skip = (".md", ".mdx", ".txt", ".example", ".sample", ".template")
|
||||
return [p for p in project.files if not p.name.endswith(skip)]
|
||||
@@ -0,0 +1,242 @@
|
||||
"""Cloud function checks: no self-trigger, instance cap, budget stop."""
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .common import Rule, SOURCE_EXTS, non_doc_files
|
||||
from .supabase import function_statement, sql_files, split_name
|
||||
|
||||
DOMAIN = "functions"
|
||||
INFRA_EXTS = (".yml", ".yaml", ".tf", ".toml", ".json", ".sh")
|
||||
AWS_PATTERN = r"AWS::Serverless|AWS::Lambda|aws_lambda_function|lambda_runtime"
|
||||
GCP_PATTERN = (
|
||||
r"google_cloudfunctions|google_cloud_run"
|
||||
r"|gcloud\s+(?:functions|run)\s+deploy"
|
||||
)
|
||||
CAPS = {
|
||||
"Firebase": r"maxInstances|max_instances",
|
||||
"AWS Lambda": r"reserved_?concurren\w*",
|
||||
"Google Cloud": (
|
||||
r"max[-_]instances|max_instance_count|maxInstanceCount|maxInstances"
|
||||
),
|
||||
}
|
||||
_NAME = r'(?:"?\w+"?\.)?"?\w+"?'
|
||||
TRIGGER = re.compile(
|
||||
r"create\s+(?:or\s+replace\s+)?trigger\s+(?P<name>\w+)\s+"
|
||||
r"(?:before|after|instead\s+of)\s+[^;]*?\bon\s+(?P<table>" + _NAME
|
||||
+ r")\s+(?P<rest>[^;]*?)execute\s+(?:function|procedure)\s+"
|
||||
r"(?P<func>" + _NAME + r")\s*\((?P<args>[^;]*)\)\s*;", re.I | re.S)
|
||||
CREATE_FUNCTION = re.compile(
|
||||
r"create\s+(?:or\s+replace\s+)?function\s+(" + _NAME + r")\s*\(", re.I)
|
||||
FN_URL = re.compile(r"/functions/v1/([\w-]+)")
|
||||
FIREBASE_V2 = re.compile(
|
||||
r"(onDocument\w+)\(\s*(?:\{[^}]*\}\s*,\s*)?['\"`]([^'\"`]+)['\"`]")
|
||||
FIREBASE_V1 = re.compile(
|
||||
r"\.document\(\s*['\"`]([^'\"`]+)['\"`]\s*\)\s*\.(on\w+)\(")
|
||||
REWRITES_SELF = ("Written", "Updated", "onWrite", "onUpdate")
|
||||
|
||||
|
||||
def supabase_functions(project):
|
||||
"""Map edge function name to its files."""
|
||||
found = {}
|
||||
for path in project.files:
|
||||
parts = project.rel(path).split("/")
|
||||
if parts[:2] == ["supabase", "functions"] and len(parts) > 3:
|
||||
if parts[2] != "_shared":
|
||||
found.setdefault(parts[2], []).append(path)
|
||||
return found
|
||||
|
||||
|
||||
def _infra(project):
|
||||
return project.with_ext(*INFRA_EXTS)
|
||||
|
||||
|
||||
def _firebase(project):
|
||||
return bool(project.named("firebase.json")) and project.has(
|
||||
r'"functions"|firebase-functions', project.files)
|
||||
|
||||
|
||||
def _vercel(project):
|
||||
return bool(project.named("vercel.json")) and any(
|
||||
"api" in project.segments(p) for p in project.with_ext(*SOURCE_EXTS))
|
||||
|
||||
|
||||
def detect(project):
|
||||
on = {
|
||||
"Supabase Edge Functions": bool(supabase_functions(project)),
|
||||
"Firebase": _firebase(project),
|
||||
"AWS Lambda": project.has(AWS_PATTERN, _infra(project)),
|
||||
"Google Cloud": project.has(GCP_PATTERN, _infra(project)),
|
||||
"Vercel Functions": _vercel(project),
|
||||
"Netlify Functions": any(
|
||||
"netlify/functions/" in project.rel(p) for p in project.files),
|
||||
"Cloudflare Workers": bool(
|
||||
project.named("wrangler.toml", "wrangler.json", "wrangler.jsonc")),
|
||||
}
|
||||
return [label for label, enabled in on.items() if enabled]
|
||||
|
||||
|
||||
def applies(project):
|
||||
return bool(detect(project))
|
||||
|
||||
|
||||
def check(project):
|
||||
platforms = detect(project)
|
||||
out = _instance_caps(project, platforms)
|
||||
out += _budget_stop(project, platforms)
|
||||
out += _supabase_loops(project) + _self_invoke(project)
|
||||
return out + _firebase_loops(project)
|
||||
|
||||
|
||||
def _instance_caps(project, platforms):
|
||||
out = []
|
||||
docs = non_doc_files(project)
|
||||
for label in platforms:
|
||||
pattern = CAPS.get(label)
|
||||
if pattern is None:
|
||||
out.append(project.found_at_root(
|
||||
DOMAIN, "FN-CAP-UNVERIFIED", "MANUAL",
|
||||
f"{label}: no instance cap to verify from code; check the "
|
||||
"provider docs for a concurrency limit, and rely on the "
|
||||
"spend cap, rate limiting and a short timeout"))
|
||||
elif not project.has(pattern, docs):
|
||||
out.append(project.found_at_root(
|
||||
DOMAIN, "FN-NO-MAX-INSTANCES", "FAIL",
|
||||
f"{label}: no max instances or reserved concurrency set"))
|
||||
return out
|
||||
|
||||
|
||||
def _budget_stop(project, platforms):
|
||||
return [
|
||||
project.found_at_root(
|
||||
DOMAIN, "FN-BUDGET-STOP", "MANUAL",
|
||||
f"{label}: wire a budget alert to an automatic stop (throttle "
|
||||
"concurrency to zero, revoke invoke rights or disable billing); "
|
||||
"verify it in the console")
|
||||
for label in platforms
|
||||
]
|
||||
|
||||
|
||||
def _function_bodies(sql):
|
||||
"""Map function name to the text of its CREATE FUNCTION statement."""
|
||||
bodies = {}
|
||||
for _, text in sql:
|
||||
for m in CREATE_FUNCTION.finditer(text):
|
||||
bodies[split_name(m.group(1))[1]] = function_statement(
|
||||
text, m.start())
|
||||
return bodies
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Loop:
|
||||
"""An edge function fired by a database trigger on `table`."""
|
||||
function: str
|
||||
table: str
|
||||
trigger: str
|
||||
guarded: bool
|
||||
|
||||
|
||||
def _loops_of(m, bodies):
|
||||
func = split_name(m["func"])[1]
|
||||
source = m["args"] if func == "http_request" else bodies.get(func, "")
|
||||
guarded = bool(re.search(r"\bwhen\b", m["rest"], re.I))
|
||||
table = split_name(m["table"])[1]
|
||||
return [Loop(u.group(1), table, m["name"], guarded)
|
||||
for u in FN_URL.finditer(source)]
|
||||
|
||||
|
||||
def _triggered_edge_functions(sql):
|
||||
"""Yield a Loop per edge function that a database trigger calls."""
|
||||
bodies = _function_bodies(sql)
|
||||
for _, text in sql:
|
||||
for m in TRIGGER.finditer(text):
|
||||
yield from _loops_of(m, bodies)
|
||||
|
||||
|
||||
def _writes_table(table):
|
||||
return re.compile(
|
||||
r"\.(?:from|table)\(\s*['\"`](?:public\.)?" + re.escape(table)
|
||||
+ r"['\"`]\s*\)\s*\.(?:insert|update|upsert|delete)\s*\("
|
||||
r"|(?:update|insert\s+into|delete\s+from)\s+(?:public\.)?"
|
||||
+ re.escape(table) + r"\b", re.I)
|
||||
|
||||
|
||||
def _supabase_loops(project):
|
||||
functions = supabase_functions(project)
|
||||
out = []
|
||||
for loop in _triggered_edge_functions(sql_files(project)):
|
||||
for path in functions.get(loop.function, []):
|
||||
out += _loop_findings(project, path, loop)
|
||||
return out
|
||||
|
||||
|
||||
def _loop_findings(project, path, loop):
|
||||
m = _writes_table(loop.table).search(project.text(path))
|
||||
return [_loop_finding(project, path, m.start(), loop)] if m else []
|
||||
|
||||
|
||||
def _loop_finding(project, path, offset, loop):
|
||||
head = (f'"{loop.function}" writes "{loop.table}" which fires trigger '
|
||||
f"{loop.trigger}")
|
||||
if loop.guarded:
|
||||
return project.found(
|
||||
Rule(DOMAIN, "FN-SELF-TRIGGER", "WARN"), path, offset,
|
||||
head + ", guarded by WHEN: confirm the write cannot satisfy it")
|
||||
return project.found(
|
||||
Rule(DOMAIN, "FN-SELF-TRIGGER", "FAIL"), path, offset,
|
||||
head + ": infinite loop; add a WHEN guard or an idempotency flag")
|
||||
|
||||
|
||||
def _invocations(project, name, paths):
|
||||
pattern = (r"functions/v1/" + re.escape(name)
|
||||
+ r"\b|invoke\(\s*['\"]" + re.escape(name) + r"['\"]")
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "FN-SELF-INVOKE", "FAIL"), path, m.start(),
|
||||
f'"{name}" invokes itself: cap the depth or remove the call')
|
||||
for path, m in project.matches(pattern, paths)
|
||||
]
|
||||
|
||||
|
||||
def _self_invoke(project):
|
||||
out = []
|
||||
for name, paths in supabase_functions(project).items():
|
||||
out += _invocations(project, name, paths)
|
||||
return out
|
||||
|
||||
|
||||
def _firebase_handlers(text):
|
||||
"""Yield (collection, kind, offset) for each Firestore trigger."""
|
||||
for m in FIREBASE_V2.finditer(text):
|
||||
yield m.group(2).split("/")[0], m.group(1), m.start()
|
||||
for m in FIREBASE_V1.finditer(text):
|
||||
yield m.group(1).split("/")[0], m.group(2), m.start()
|
||||
|
||||
|
||||
def _file_loops(project, path):
|
||||
text = project.text(path)
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "FN-SELF-TRIGGER", "WARN"), path, offset,
|
||||
f'trigger on "{collection}" also writes it in this file: '
|
||||
"confirm the write cannot fire the trigger again")
|
||||
for collection, kind, offset in _firebase_handlers(text)
|
||||
if _rewrites_trigger(text, collection, kind)
|
||||
]
|
||||
|
||||
|
||||
def _firebase_loops(project):
|
||||
out = []
|
||||
for path in project.with_ext(".js", ".ts", ".mjs"):
|
||||
if not project.rel(path).startswith("supabase/"):
|
||||
out += _file_loops(project, path)
|
||||
return out
|
||||
|
||||
|
||||
def _rewrites_trigger(text, collection, kind):
|
||||
own_ref = re.search(r"\.ref\.(?:set|update)\(", text)
|
||||
if own_ref and kind.endswith(REWRITES_SELF):
|
||||
return True
|
||||
return re.search(
|
||||
r"collection\(\s*['\"`]" + re.escape(collection)
|
||||
+ r"['\"`]\s*\)(?:\s*\.doc\([^)]*\))?\s*\.(?:add|set|update)\(",
|
||||
text) is not None
|
||||
@@ -0,0 +1,101 @@
|
||||
"""Hosting checks: rate limit, CDN and firewall, spend cap."""
|
||||
from .apis import route_files
|
||||
from .common import Rule, non_doc_files
|
||||
|
||||
DOMAIN = "hosting"
|
||||
|
||||
PLATFORMS = {
|
||||
"vercel.json": ("Vercel", True),
|
||||
"netlify.toml": ("Netlify", True),
|
||||
"wrangler.toml": ("Cloudflare", True),
|
||||
"wrangler.json": ("Cloudflare", True),
|
||||
"wrangler.jsonc": ("Cloudflare", True),
|
||||
"firebase.json": ("Firebase Hosting", True),
|
||||
"amplify.yml": ("AWS Amplify", True),
|
||||
"fly.toml": ("Fly.io", False),
|
||||
"render.yaml": ("Render", False),
|
||||
"railway.json": ("Railway", False),
|
||||
"railway.toml": ("Railway", False),
|
||||
"docker-compose.yml": ("Docker Compose", False),
|
||||
"docker-compose.yaml": ("Docker Compose", False),
|
||||
"compose.yml": ("Docker Compose", False),
|
||||
"compose.yaml": ("Docker Compose", False),
|
||||
"nginx.conf": ("nginx", False),
|
||||
"Caddyfile": ("Caddy", False),
|
||||
".htaccess": ("Apache", False),
|
||||
"app.yaml": ("App Engine", False),
|
||||
}
|
||||
RATE_LIMIT = (
|
||||
r"rate[-_ ]?limit|ratelimit|limit_req|throttl|governor|slowapi"
|
||||
r"|flask[-_]limiter|django[-_]ratelimit|@vercel/firewall|fail2ban"
|
||||
r"|\blimiter\b"
|
||||
)
|
||||
CDN_MENTION = (
|
||||
r"cloudflare|cloudfront|fastly|bunny\.net|akamai|cf-connecting-ip"
|
||||
r"|set_real_ip_from"
|
||||
)
|
||||
SPEND_HINTS = {
|
||||
"Vercel": "set a Spend Management amount with automatic pause",
|
||||
}
|
||||
SPEND_DEFAULT = (
|
||||
"check the plan for a hard spend cap and enable it; if there is none, "
|
||||
"set a budget alert and write the kill-switch step in the deploy notes"
|
||||
)
|
||||
|
||||
|
||||
def detect(project):
|
||||
"""Map platform label to (has_cdn, config path)."""
|
||||
found = {}
|
||||
for path in project.files:
|
||||
entry = ("Docker", False) if path.name.startswith("Dockerfile") \
|
||||
else PLATFORMS.get(path.name)
|
||||
if entry:
|
||||
found.setdefault(entry[0], (entry[1], path))
|
||||
return found
|
||||
|
||||
|
||||
def applies(project):
|
||||
return bool(detect(project)) or bool(route_files(project))
|
||||
|
||||
|
||||
def check(project):
|
||||
platforms = detect(project)
|
||||
return (_rate_limit(project, platforms)
|
||||
+ _origin_exposure(project, platforms)
|
||||
+ _manual_items(project, platforms))
|
||||
|
||||
|
||||
def _rate_limit(project, platforms):
|
||||
if project.has(RATE_LIMIT, non_doc_files(project)):
|
||||
return []
|
||||
return [project.found_at_root(
|
||||
DOMAIN, "HOST-NO-RATE-LIMIT", "FAIL",
|
||||
"no rate limiting found: add it per IP and per account on login, "
|
||||
"signup, reset, send and upload")]
|
||||
|
||||
|
||||
def _origin_exposure(project, platforms):
|
||||
origins = sorted(
|
||||
label for label, (has_cdn, _) in platforms.items() if not has_cdn)
|
||||
if not origins or project.has(CDN_MENTION):
|
||||
return []
|
||||
return [project.found_at_root(
|
||||
DOMAIN, "HOST-ORIGIN-EXPOSED", "WARN",
|
||||
", ".join(origins) + ": the origin is served directly; put a CDN "
|
||||
"and firewall in front (Cloudflare, CloudFront, Fastly)")]
|
||||
|
||||
|
||||
def _manual_items(project, platforms):
|
||||
out = [project.found_at_root(
|
||||
DOMAIN, "HOST-WAF-DDOS", "MANUAL",
|
||||
"enable the CDN firewall: DDoS protection, bot rules, rate rules "
|
||||
"(dashboard setting, not visible from code)")]
|
||||
if not platforms:
|
||||
out.append(project.found_at_root(
|
||||
DOMAIN, "HOST-SPEND-CAP", "MANUAL",
|
||||
"no hosting config found: " + SPEND_DEFAULT))
|
||||
for label, (_, path) in platforms.items():
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "HOST-SPEND-CAP", "MANUAL"), path, 0,
|
||||
f"{label}: " + SPEND_HINTS.get(label, SPEND_DEFAULT)))
|
||||
return out
|
||||
@@ -0,0 +1,164 @@
|
||||
"""SMS and email checks: recorded consent, unsubscribe, STOP handling."""
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .common import Rule, SOURCE_EXTS, non_doc_files
|
||||
|
||||
DOMAIN = "messaging"
|
||||
MANIFESTS = (
|
||||
"package.json", "Cargo.toml", "requirements.txt", "pyproject.toml",
|
||||
"composer.json", "go.mod", "deno.json",
|
||||
)
|
||||
EMAIL_SENDER = (
|
||||
r"nodemailer|@sendgrid/mail|sendgrid\.com|api\.resend\.com"
|
||||
r"|new Resend\(|from ['\"]resend['\"]|postmark|mailgun|sib-api-v3"
|
||||
r"|sendinblue|brevo|mailjet|mandrill|client-ses|SendEmailCommand"
|
||||
r"|smtplib|use lettre|lettre::|PHPMailer|mailchimp"
|
||||
)
|
||||
SMS_SENDER = (
|
||||
r"twilio|vonage|nexmo|messagebird|sns\.publish|@aws-sdk/client-sns"
|
||||
r"|PublishCommand|ovh.{0,20}sms|plivo|sinch|clicksend|smsapi"
|
||||
r"|sendTransacSms|telnyx|infobip|africastalking"
|
||||
)
|
||||
CONSENT_STORED = (
|
||||
r"consent(?:ed)?_?(?:at|date|ts|timestamp|source|status|given|version"
|
||||
r"|text)|opt_?in_?(?:at|date|source|ts|timestamp)|opted_?in|double_?opt"
|
||||
r"|marketing_consent|has_consented|sms_consent|email_consent"
|
||||
)
|
||||
CONSENT_CHECKED = (
|
||||
r"consent|opt_?in|opted|subscribed|unsubscrib|suppress|allowed_to_contact"
|
||||
)
|
||||
UNSUBSCRIBE = r"unsubscrib|d[ée]sinscri"
|
||||
OPT_OUT_STORED = (
|
||||
r"opt_?out|unsubscribed|stopped|suppress|blocklist|do_not_(?:contact|text)"
|
||||
)
|
||||
TRANSACTIONAL = re.compile(
|
||||
r"contact|reset|verif|otp|password|confirm|receipt|invoice|welcome"
|
||||
r"|magic|login|signin|2fa|mfa|booking|reservation", re.I)
|
||||
MARKETING = re.compile(
|
||||
r"newsletter|campaign|subscriber|mailing|broadcast|promo|marketing"
|
||||
r"|bulk|audience|relance|blast", re.I)
|
||||
TRANSACTIONAL_NOTE = " (only transactional senders found: confirm no marketing)"
|
||||
TEST_PATH = re.compile(
|
||||
r"(?:^|/)(?:tests?|__tests__|spec)/|\.(?:test|spec)\.|Test\.php$", re.I)
|
||||
BULK_STORAGE = (
|
||||
r"subscriber|newsletter|mailing[_ ]?list|contact_list|audience"
|
||||
)
|
||||
|
||||
|
||||
def sender_files(project):
|
||||
files = project.with_ext(*SOURCE_EXTS) + project.named(*MANIFESTS)
|
||||
return [p for p in files if not TEST_PATH.search(project.rel(p))]
|
||||
|
||||
|
||||
def _sends(project, path):
|
||||
return project.has(EMAIL_SENDER, [path]) or project.has(SMS_SENDER, [path])
|
||||
|
||||
|
||||
def _kind(project, path):
|
||||
rel = project.rel(path)
|
||||
if MARKETING.search(rel):
|
||||
return "marketing"
|
||||
return "transactional" if TRANSACTIONAL.search(rel) else "unknown"
|
||||
|
||||
|
||||
def _severity(project, senders):
|
||||
"""FAIL unless a sender looks transactional and nothing bulk exists."""
|
||||
code = [p for p in senders if p.suffix.lower() in SOURCE_EXTS] or senders
|
||||
kinds = {_kind(project, p) for p in code}
|
||||
if "marketing" in kinds or "transactional" not in kinds:
|
||||
return "FAIL"
|
||||
if project.has(BULK_STORAGE, non_doc_files(project)):
|
||||
return "FAIL"
|
||||
return "WARN"
|
||||
|
||||
|
||||
def applies(project):
|
||||
files = sender_files(project)
|
||||
return project.has(EMAIL_SENDER, files) or project.has(SMS_SENDER, files)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Sending:
|
||||
senders: list
|
||||
severity: str
|
||||
email: object
|
||||
sms: object
|
||||
|
||||
|
||||
def _first_hit(project, pattern, files):
|
||||
return next(project.matches(pattern, files), None)
|
||||
|
||||
|
||||
def _context(project):
|
||||
files = sender_files(project)
|
||||
senders = [p for p in files if _sends(project, p)]
|
||||
return Sending(
|
||||
senders, _severity(project, senders),
|
||||
_first_hit(project, EMAIL_SENDER, files),
|
||||
_first_hit(project, SMS_SENDER, files))
|
||||
|
||||
|
||||
def check(project):
|
||||
ctx = _context(project)
|
||||
out = _consent(project, ctx.email or ctx.sms, ctx.senders, ctx.severity)
|
||||
if ctx.email:
|
||||
out += _email_rules(project, ctx.email, ctx.severity)
|
||||
if ctx.sms:
|
||||
out += _sms_rules(project, ctx.sms, ctx.severity)
|
||||
return out
|
||||
|
||||
|
||||
def _note(severity):
|
||||
return TRANSACTIONAL_NOTE if severity == "WARN" else ""
|
||||
|
||||
|
||||
def _consent(project, hit, senders, severity):
|
||||
path, m = hit
|
||||
if not project.has(CONSENT_STORED, non_doc_files(project), 0):
|
||||
return [project.found(
|
||||
Rule(DOMAIN, "MSG-NO-CONSENT-RECORD", severity), path, m.start(),
|
||||
"messages are sent but no consent record exists: store who, "
|
||||
"when, channel, source and wording per contact" + _note(severity))]
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "MSG-SEND-UNCHECKED", "WARN"), p, 0,
|
||||
"sends messages without checking consent or the suppression "
|
||||
"list in this file")
|
||||
for p in senders
|
||||
if p.suffix.lower() in SOURCE_EXTS
|
||||
and _kind(project, p) != "transactional"
|
||||
and not project.has(CONSENT_CHECKED, [p])
|
||||
]
|
||||
|
||||
|
||||
def _email_rules(project, hit, severity):
|
||||
path, m = hit
|
||||
docs = non_doc_files(project)
|
||||
if not project.has(UNSUBSCRIBE, docs):
|
||||
return [project.found(
|
||||
Rule(DOMAIN, "MSG-NO-UNSUBSCRIBE", severity), path, m.start(),
|
||||
"emails are sent but no unsubscribe link exists" + _note(severity))]
|
||||
if not project.has(r"list-unsubscribe", docs):
|
||||
return [project.found(
|
||||
Rule(DOMAIN, "MSG-NO-LIST-UNSUBSCRIBE", "WARN"), path, m.start(),
|
||||
"add the List-Unsubscribe header (one-click); Gmail and Yahoo "
|
||||
"require it from bulk senders")]
|
||||
return []
|
||||
|
||||
|
||||
def _sms_rules(project, hit, severity):
|
||||
path, m = hit
|
||||
docs = non_doc_files(project)
|
||||
out = []
|
||||
if not project.has(r"\bSTOP\b", docs, 0):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "MSG-SMS-NO-STOP", severity), path, m.start(),
|
||||
"SMS are sent but nothing tells the recipient to reply STOP"
|
||||
+ _note(severity)))
|
||||
if not project.has(OPT_OUT_STORED, docs):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "MSG-SMS-NO-OPTOUT-STORE", severity), path, m.start(),
|
||||
"no opt-out storage: a STOP reply must be recorded and "
|
||||
"checked before every send" + _note(severity)))
|
||||
return out
|
||||
@@ -0,0 +1,137 @@
|
||||
"""Password handling: clear storage or compare, fast hash, log, literal."""
|
||||
import re
|
||||
|
||||
from .common import Rule, SOURCE_EXTS, non_doc_files, redact
|
||||
|
||||
DOMAIN = "api"
|
||||
NAME = r"(?:password|passwd|pwd|mot_de_passe)"
|
||||
CONFIG_EXTS = {".yml", ".yaml", ".toml", ".ini", ".cfg", ".conf", ".sh",
|
||||
".properties", ".json"}
|
||||
SKIP_PATH = re.compile(
|
||||
r"\.(?:test|spec|e2e|stories)\.|(?:^|/)(?:tests?|__tests__|spec|e2e"
|
||||
r"|fixtures?|i18n|locales?|lang|translations?|messages)/", re.I)
|
||||
HASH_EVIDENCE = (
|
||||
r"bcrypt|argon2|scrypt|pbkdf2|password_hash\(|password_verify\("
|
||||
r"|Hash::make|make_password|hashpw|PasswordHasher|hash_password"
|
||||
r"|verify_password|\bphpass\b")
|
||||
COLUMN = (
|
||||
rf"\b{NAME}\s+(?:text|varchar|character varying|char|citext|string)\b"
|
||||
rf"|->string\(\s*['\"]{NAME}['\"]"
|
||||
rf"|\b{NAME}\s*=\s*models\.(?:Char|Text)Field"
|
||||
rf"|\b{NAME}\s*:\s*(?:text|varchar)\(")
|
||||
COMPARE = (
|
||||
rf"(?:\.|->|\[['\"]){NAME}['\"]?\]?\s*[!=]==?\s*[\w$]"
|
||||
rf"|[\w$\]\)]\s*[!=]==?\s*\$?\w+(?:\.|->){NAME}\b"
|
||||
rf"|\b(?:where|and)\s+(?:\w+\.)?{NAME}\s*=\s*(?:\$\d+|\?|:\w+|%s)")
|
||||
COMPARE_SKIP = re.compile(
|
||||
r"confirm|repeat|again|undefined|null|hash|digest|length", re.I)
|
||||
WEAK_HASH = (
|
||||
rf"\b(?:md5|sha1|sha256|sha512|crc32|hashlib\.\w+)\s*\(\s*[^()\n]*{NAME}"
|
||||
rf"|createHash\([^)\n]*\)\s*\.update\(\s*[^()\n]*{NAME}"
|
||||
rf"|\bhash\(\s*['\"](?:md5|sha1|sha256|sha512)['\"]\s*,\s*[^()\n]*{NAME}")
|
||||
WEAK_SKIP = re.compile(r"token|reset|otp|nonce|session", re.I)
|
||||
LOG_CALL = (
|
||||
r"\b(?:console\.\w+|logger?\.\w+|log\.\w+|logging\.\w+|print(?:ln!?)?"
|
||||
r"|error_log|Log::\w+|tracing::\w+!|dbg!|var_dump|print_r)\s*\(([^\n]*)")
|
||||
STRING = re.compile(r"'[^'\n]*'|\"[^\"\n]*\"|`[^`\n]*`")
|
||||
LOGGED_NAME = re.compile(
|
||||
rf"\b(?:(?:new|old|plain|raw|user|current)_?)?{NAME}\b|\bcredentials\b",
|
||||
re.I)
|
||||
LITERAL = rf"\b(\w*{NAME})['\"]?\s*(?:[:=]|=>)\s*['\"]([^'\"\n]{{8,}})['\"]"
|
||||
BARE_LITERAL = rf"\b(\w*{NAME})(?:=\s*|:\s+)([^'\"\s#]{{8,}})"
|
||||
PLACEHOLDER = re.compile(
|
||||
r"change|your|xxx|\*\*|example|placeholder|dummy|sample|secret[-_ ]?here"
|
||||
r"|^[$%<{.*/]|\||required|^\$argon|^[0-9a-f]{32,}$|^[a-z]+(?:_[a-z]+)+$| ",
|
||||
re.I)
|
||||
PLAINTEXT = Rule(DOMAIN, "API-PASSWORD-PLAINTEXT", "FAIL")
|
||||
LITERAL_RULE = Rule(DOMAIN, "API-PASSWORD-LITERAL", "WARN")
|
||||
|
||||
|
||||
def _line(text, offset):
|
||||
start = text.rfind("\n", 0, offset) + 1
|
||||
end = text.find("\n", offset)
|
||||
return text[start:] if end < 0 else text[start:end]
|
||||
|
||||
|
||||
def _files(project):
|
||||
return [p for p in non_doc_files(project)
|
||||
if not SKIP_PATH.search(project.rel(p))]
|
||||
|
||||
|
||||
def check(project):
|
||||
files = _files(project)
|
||||
return (_columns(project, files) + _compares(project, files)
|
||||
+ _weak_hash(project, files) + _logged(project, files)
|
||||
+ _literals(project, files))
|
||||
|
||||
|
||||
def _columns(project, files):
|
||||
if project.has(HASH_EVIDENCE, files):
|
||||
return []
|
||||
return [
|
||||
project.found(
|
||||
PLAINTEXT, path, m.start(),
|
||||
"password column and no hashing library anywhere: store an "
|
||||
"argon2id or bcrypt hash, never the password")
|
||||
for path, m in project.matches(COLUMN, files)
|
||||
]
|
||||
|
||||
|
||||
def _compares(project, files):
|
||||
return [
|
||||
project.found(
|
||||
PLAINTEXT, path, m.start(),
|
||||
"stored password compared in clear: verify a hash with the "
|
||||
"library's constant-time check")
|
||||
for path, m in project.matches(COMPARE, files)
|
||||
if not COMPARE_SKIP.search(_line(project.text(path), m.start()))
|
||||
]
|
||||
|
||||
|
||||
def _weak_hash(project, files):
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "API-PASSWORD-WEAK-HASH", "FAIL"), path, m.start(),
|
||||
"password through a fast hash: use argon2id, scrypt or bcrypt")
|
||||
for path, m in project.matches(WEAK_HASH, files)
|
||||
if not WEAK_SKIP.search(_line(project.text(path), m.start()))
|
||||
]
|
||||
|
||||
|
||||
def _log_args(args):
|
||||
"""Call arguments with string literals reduced to their interpolations."""
|
||||
return STRING.sub(
|
||||
lambda m: " ".join(re.findall(r"\{([^}]*)\}", m.group())), args)
|
||||
|
||||
|
||||
def _logged(project, files):
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "API-PASSWORD-LOGGED", "FAIL"), path, m.start(),
|
||||
"password reaches a log: never log credentials")
|
||||
for path, m in project.matches(LOG_CALL, files)
|
||||
if LOGGED_NAME.search(_log_args(m.group(1)))
|
||||
]
|
||||
|
||||
|
||||
def _is_placeholder(key, value):
|
||||
return value.lower() == key.lower() or bool(PLACEHOLDER.search(value))
|
||||
|
||||
|
||||
def _literal_hits(project, files, pattern):
|
||||
return [
|
||||
project.found(
|
||||
LITERAL_RULE, path, m.start(),
|
||||
f"{m.group(1)} set to a literal ({redact(m.group(2))}): a real "
|
||||
"credential moves to env and gets rotated; a dev default is "
|
||||
"documented as such")
|
||||
for path, m in project.matches(pattern, files)
|
||||
if not _is_placeholder(m.group(1), m.group(2))
|
||||
]
|
||||
|
||||
|
||||
def _literals(project, files):
|
||||
config = [p for p in files if p.suffix.lower() in CONFIG_EXTS]
|
||||
source = [p for p in files if p.suffix.lower() in SOURCE_EXTS]
|
||||
return (_literal_hits(project, source + config, LITERAL)
|
||||
+ _literal_hits(project, config, BARE_LITERAL))
|
||||
@@ -0,0 +1,332 @@
|
||||
"""Supabase checks: RLS, owner-scoped policies, keys kept off the client."""
|
||||
import base64
|
||||
import json
|
||||
import re
|
||||
from dataclasses import dataclass
|
||||
|
||||
from .apis import ignore_patterns, is_ignored_env
|
||||
from .common import Rule, SOURCE_EXTS, blank_comments
|
||||
|
||||
DOMAIN = "supabase"
|
||||
_NAME = r'(?:"?\w+"?\.)?"?\w+"?'
|
||||
TABLE = re.compile(
|
||||
r"create\s+(?:unlogged\s+)?table\s+(?:if\s+not\s+exists\s+)?(?P<name>"
|
||||
+ _NAME + r")", re.I)
|
||||
RLS_ON = re.compile(
|
||||
r"alter\s+table\s+(?:only\s+)?(?:if\s+exists\s+)?(?P<name>" + _NAME
|
||||
+ r")\s+enable\s+row\s+level\s+security", re.I)
|
||||
DROP = re.compile(
|
||||
r"drop\s+table\s+(?:if\s+exists\s+)?(?P<name>" + _NAME + r")", re.I)
|
||||
POLICY = re.compile(
|
||||
r"create\s+policy\s+(?P<pname>\"[^\"]+\"|\w+)\s+on\s+(?P<table>"
|
||||
+ _NAME + r")(?P<rest>[^;]*);", re.I)
|
||||
VIEW = re.compile(
|
||||
r"create\s+(?:or\s+replace\s+)?(?P<mat>materialized\s+)?view\s+"
|
||||
r"(?P<name>" + _NAME + r")(?P<rest>[^;]*);", re.I)
|
||||
FUNCTION = re.compile(
|
||||
r"create\s+(?:or\s+replace\s+)?function\s+(?P<name>" + _NAME + r")\s*\(",
|
||||
re.I)
|
||||
BUCKET_SQL = re.compile(
|
||||
r"(?:insert\s+into|update)\s+storage\.buckets[^;]*;", re.I)
|
||||
OPEN_EXPR = re.compile(r"\b(?:using|with\s+check)\s*\(\s*true\s*\)")
|
||||
OWNER = re.compile(r"auth\.(?:uid|jwt|role)\s*\(")
|
||||
WRITE_CMDS = {"all", "insert", "update", "delete"}
|
||||
ANON_ROLES = {"anon", "public"}
|
||||
PRIVILEGED_ROLES = {"service_role", "postgres", "supabase_admin"}
|
||||
|
||||
SERVICE_REF = r"service_role|SERVICE_ROLE|SUPABASE_SECRET_KEY|sb_secret_"
|
||||
SERVER_SEGMENTS = {
|
||||
"functions", "api", "server", "scripts", "tests", "test", "migrations",
|
||||
"seed", ".github", "supabase", "tools",
|
||||
}
|
||||
CLIENT_SEGMENTS = {
|
||||
"components", "public", "static", "client", "browser", "www", "islands",
|
||||
}
|
||||
CLIENT_EXTS = (".vue", ".svelte", ".html", ".htm")
|
||||
SCRIPT_EXTS = (".ts", ".tsx", ".js", ".jsx", ".mjs")
|
||||
JWT = r"eyJ[\w-]{8,}\.(eyJ[\w-]{8,})\.[\w-]{8,}"
|
||||
MANIFESTS = (
|
||||
"package.json", "Cargo.toml", "requirements.txt", "pyproject.toml",
|
||||
"pubspec.yaml", "composer.json", "go.mod", "deno.json",
|
||||
)
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Policy:
|
||||
name: str
|
||||
table: str
|
||||
cmd: str
|
||||
roles: tuple
|
||||
open_expr: bool
|
||||
owner: bool
|
||||
offset: int
|
||||
|
||||
|
||||
def split_name(raw):
|
||||
"""Return (schema, name), schema defaulting to public."""
|
||||
parts = raw.replace('"', "").lower().split(".")
|
||||
return (parts[0], parts[1]) if len(parts) == 2 else ("public", parts[0])
|
||||
|
||||
|
||||
def function_statement(text, start):
|
||||
"""Text of a CREATE FUNCTION from `start` to its closing semicolon."""
|
||||
tag = re.compile(r"\bas\s+(\$\w*\$)", re.I).search(text, start)
|
||||
if not tag:
|
||||
end = text.find(";", start)
|
||||
else:
|
||||
close = text.find(tag.group(1), tag.end())
|
||||
end = text.find(";", close if close != -1 else tag.end())
|
||||
return text[start:end if end != -1 else len(text)]
|
||||
|
||||
|
||||
def sql_files(project):
|
||||
return [(p, blank_comments(project.text(p)))
|
||||
for p in project.with_ext(".sql")]
|
||||
|
||||
|
||||
def applies(project):
|
||||
if (project.root / "supabase").is_dir():
|
||||
return True
|
||||
return project.has(r"supabase", project.named(*MANIFESTS))
|
||||
|
||||
|
||||
def check(project):
|
||||
sql = sql_files(project)
|
||||
out = _rls(project, sql)
|
||||
for path, text in sql:
|
||||
out += (_policies(project, path, text) + _views(project, path, text)
|
||||
+ _functions(project, path, text, sql)
|
||||
+ _buckets(project, path, text))
|
||||
out += _config(project) + _client_leaks(project) + _jwt_literals(project)
|
||||
return _dedupe_last(out)
|
||||
|
||||
|
||||
def _dedupe_last(findings):
|
||||
"""An object redefined by a later migration is reported once, there."""
|
||||
latest = {(f.rule, f.message): f for f in findings}
|
||||
return [f for f in findings if latest[(f.rule, f.message)] is f]
|
||||
|
||||
|
||||
LIVE_NOTE = (
|
||||
"static check sees migrations only: run the RLS query from "
|
||||
"references/checks.md against the live project")
|
||||
|
||||
|
||||
def _public_name(m):
|
||||
schema, name = split_name(m["name"])
|
||||
return name if schema == "public" else None
|
||||
|
||||
|
||||
def _created_tables(sql):
|
||||
created = {}
|
||||
for path, text in sql:
|
||||
for m in TABLE.finditer(text):
|
||||
name = _public_name(m)
|
||||
if name:
|
||||
created.setdefault(name, (path, m.start()))
|
||||
return created
|
||||
|
||||
|
||||
def _all_names(pattern, sql):
|
||||
return {split_name(m["name"])[1]
|
||||
for _, text in sql for m in pattern.finditer(text)}
|
||||
|
||||
|
||||
def _rls(project, sql):
|
||||
live = project.found_at_root(DOMAIN, "SB-RLS-LIVE", "MANUAL", LIVE_NOTE)
|
||||
covered = _all_names(RLS_ON, sql) | _all_names(DROP, sql)
|
||||
return [live] + [
|
||||
project.found(
|
||||
Rule(DOMAIN, "SB-RLS-MISSING", "FAIL"), path, offset,
|
||||
f'table "{name}" never enables row level security')
|
||||
for name, (path, offset) in _created_tables(sql).items()
|
||||
if name not in covered
|
||||
]
|
||||
|
||||
|
||||
def _roles(rest):
|
||||
to = re.search(r"\bto\s+(.+?)(?=\s+(?:using|with\s+check)\b|$)", rest, re.S)
|
||||
listed = to.group(1).split(",") if to else ["public"]
|
||||
return tuple(r.strip(' "') for r in listed)
|
||||
|
||||
|
||||
def parse_policy(m):
|
||||
rest = m["rest"].lower()
|
||||
cmd = re.search(r"\bfor\s+(all|select|insert|update|delete)\b", rest)
|
||||
return Policy(
|
||||
m["pname"].strip('"'), split_name(m["table"])[1],
|
||||
cmd.group(1) if cmd else "all", _roles(rest),
|
||||
bool(OPEN_EXPR.search(rest)), bool(OWNER.search(rest)), m.start())
|
||||
|
||||
|
||||
def policy_issues(pol):
|
||||
"""Return (Rule, message) pairs for one policy."""
|
||||
if set(pol.roles) <= PRIVILEGED_ROLES:
|
||||
return []
|
||||
writes = pol.cmd in WRITE_CMDS
|
||||
anon = bool(ANON_ROLES & set(pol.roles))
|
||||
where = f'policy "{pol.name}" on "{pol.table}"'
|
||||
if pol.open_expr and writes:
|
||||
return [(Rule(DOMAIN, "SB-POLICY-OPEN-WRITE", "FAIL"),
|
||||
f"{where}: true on a write lets anyone change rows")]
|
||||
if writes and anon and not pol.owner:
|
||||
return [(Rule(DOMAIN, "SB-POLICY-ANON-WRITE", "FAIL"),
|
||||
f"{where}: anon can write; scope it to auth.uid()")]
|
||||
if pol.open_expr:
|
||||
return [(Rule(DOMAIN, "SB-POLICY-PUBLIC-READ", "WARN"),
|
||||
f"{where}: open read; confirm the data is public")]
|
||||
if not pol.owner:
|
||||
return [(Rule(DOMAIN, "SB-POLICY-NOT-OWNER", "WARN"),
|
||||
f"{where}: not tied to auth.uid(); confirm owner scoping")]
|
||||
return []
|
||||
|
||||
|
||||
def _policies(project, path, text):
|
||||
out = []
|
||||
for m in POLICY.finditer(text):
|
||||
pol = parse_policy(m)
|
||||
for rule, message in policy_issues(pol):
|
||||
out.append(project.found(rule, path, pol.offset, message))
|
||||
return out
|
||||
|
||||
|
||||
def _views(project, path, text):
|
||||
out = []
|
||||
for m in VIEW.finditer(text):
|
||||
schema, name = split_name(m["name"])
|
||||
if schema != "public":
|
||||
continue
|
||||
if m["mat"]:
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "SB-MATVIEW-EXPOSED", "WARN"), path, m.start(),
|
||||
f'materialized view "{name}" ignores RLS: do not expose it'))
|
||||
elif "security_invoker" not in m["rest"].lower():
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "SB-VIEW-INVOKER", "WARN"), path, m.start(),
|
||||
f'view "{name}" runs as its owner: add security_invoker'))
|
||||
return out
|
||||
|
||||
|
||||
def _statements(sql, word):
|
||||
return " ".join(t for _, t in sql if word in t.lower())
|
||||
|
||||
|
||||
def _revoked(revokes, name):
|
||||
pattern = r"revoke\s+(?:all|execute)[^;]*\b" + re.escape(name) + r"\b"
|
||||
return re.search(pattern, revokes, re.I) is not None
|
||||
|
||||
|
||||
def _execute_issue(revokes, grants, name, stmt):
|
||||
if "returns trigger" in stmt or _revoked(revokes, name):
|
||||
return None
|
||||
granted = r"grant\s+(?:all|execute)[^;]*\b" + re.escape(name)
|
||||
if re.search(granted + r"\b[^;]*\banon\b", grants, re.I):
|
||||
return (f'definer function "{name}" is explicitly granted to anon: '
|
||||
"confirm it is meant to be public")
|
||||
return (f'definer function "{name}" is callable by anon by default: '
|
||||
"revoke execute from public, anon")
|
||||
|
||||
|
||||
def _definer_findings(project, path, m, text, privileges):
|
||||
schema, name = split_name(m["name"])
|
||||
stmt = function_statement(text, m.start()).lower()
|
||||
if schema != "public" or "security definer" not in stmt:
|
||||
return []
|
||||
out = []
|
||||
if "set search_path" not in stmt:
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "SB-DEFINER-SEARCH-PATH", "WARN"), path, m.start(),
|
||||
f'definer function "{name}" must pin search_path'))
|
||||
issue = _execute_issue(*privileges, name, stmt)
|
||||
if issue:
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "SB-DEFINER-EXECUTE", "WARN"), path, m.start(),
|
||||
issue))
|
||||
return out
|
||||
|
||||
|
||||
def _functions(project, path, text, sql):
|
||||
privileges = (_statements(sql, "revoke"), _statements(sql, "grant"))
|
||||
out = []
|
||||
for m in FUNCTION.finditer(text):
|
||||
out += _definer_findings(project, path, m, text, privileges)
|
||||
return out
|
||||
|
||||
|
||||
def _buckets(project, path, text):
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "SB-BUCKET-PUBLIC", "WARN"), path, m.start(),
|
||||
"storage bucket set public: confirm every file is meant "
|
||||
"to be world-readable")
|
||||
for m in BUCKET_SQL.finditer(text)
|
||||
if re.search(r"\btrue\b", m.group(), re.I)
|
||||
]
|
||||
|
||||
|
||||
def _config(project):
|
||||
out = []
|
||||
for path in project.named("config.toml"):
|
||||
if path.parent.name != "supabase":
|
||||
continue
|
||||
text = project.text(path)
|
||||
for m in re.finditer(
|
||||
r"\[functions\.([\w-]+)\][^\[]*?verify_jwt\s*=\s*false",
|
||||
text, re.S):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "SB-EDGE-NO-JWT", "WARN"), path, m.start(),
|
||||
f'function "{m.group(1)}" skips JWT verification: confirm '
|
||||
"it checks a webhook signature instead"))
|
||||
for m in re.finditer(
|
||||
r"\[storage\.buckets\.([\w-]+)\][^\[]*?public\s*=\s*true",
|
||||
text, re.S):
|
||||
out.append(project.found(
|
||||
Rule(DOMAIN, "SB-BUCKET-PUBLIC", "WARN"), path, m.start(),
|
||||
f'bucket "{m.group(1)}" is public: confirm it is intended'))
|
||||
return out
|
||||
|
||||
|
||||
def _client_reachable(project, path):
|
||||
segments = set(project.segments(path))
|
||||
if segments & SERVER_SEGMENTS:
|
||||
return False
|
||||
if path.suffix.lower() in CLIENT_EXTS:
|
||||
return True
|
||||
if path.suffix.lower() not in SCRIPT_EXTS:
|
||||
return False
|
||||
head = project.text(path)[:300]
|
||||
return bool(segments & CLIENT_SEGMENTS) or "use client" in head
|
||||
|
||||
|
||||
def _client_leaks(project):
|
||||
files = project.with_ext(*SOURCE_EXTS, *CLIENT_EXTS)
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "SB-SERVICE-ROLE-CLIENT", "FAIL"), path, m.start(),
|
||||
"service role or secret key referenced in client-reachable "
|
||||
"code: it bypasses RLS for anyone who reads the bundle")
|
||||
for path, m in project.matches(SERVICE_REF, files, 0)
|
||||
if _client_reachable(project, path)
|
||||
]
|
||||
|
||||
|
||||
def _jwt_role(payload):
|
||||
try:
|
||||
raw = base64.urlsafe_b64decode(payload + "=" * (-len(payload) % 4))
|
||||
data = json.loads(raw)
|
||||
except ValueError:
|
||||
return None
|
||||
return data.get("role") if isinstance(data, dict) else None
|
||||
|
||||
|
||||
def _jwt_literals(project):
|
||||
patterns = ignore_patterns(project)
|
||||
return [
|
||||
project.found(
|
||||
Rule(DOMAIN, "SB-SERVICE-ROLE-LITERAL", "FAIL"), path, m.start(),
|
||||
"service_role JWT hardcoded: rotate the key, keep it in "
|
||||
"server env only")
|
||||
for path, m in project.matches(JWT, None, 0)
|
||||
if _jwt_role(m.group(1)) == "service_role"
|
||||
and not is_ignored_env(path, patterns)
|
||||
]
|
||||
Reference in new issue
Block a user