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,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