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,82 @@
|
||||
---
|
||||
name: guardrails
|
||||
effort: high
|
||||
description: 'Use when auditing a project against the baseline guardrails: hosting (rate limit, CDN and firewall, spend cap), accessibility (keyboard, visible focus, alt text, field labels), Supabase (RLS on every table, owner-scoped policies, no service_role key client-side), SMS and email (recorded consent, unsubscribe, STOP), cloud functions (no self-trigger, instance cap, budget stop), plus API and access hygiene (auth on every route, CORS, secrets, password storage). Runs a deterministic scanner, judges each hit, writes .claude/audits/GUARDRAILS.md. Triggers: "guardrails", "garde-fous", "RLS activée ?", "audit supabase", "consentement sms", "plafond de dépense", "mots de passe en clair ?", "teste la sécurité de base du projet". Headers and TLS → /harden; secrets, CVE, OWASP → /cso; full WCAG → /web-validate.'
|
||||
argument-hint: '[project path] [--domain api,hosting,a11y,supabase,messaging,functions] [--exclude paths]'
|
||||
---
|
||||
|
||||
# /guardrails
|
||||
|
||||
Checks a project against `rules/secure-by-default.md`. A scanner reads the
|
||||
tree as data and finds what text can prove. This skill then judges the hits,
|
||||
covers what text cannot prove, and lists what only a dashboard can set.
|
||||
|
||||
The scanner proves absence of a protection, never presence of security. A
|
||||
clean scan means "no static finding", and the report says exactly that.
|
||||
|
||||
## STEP 1: Scope
|
||||
|
||||
Work in the project the user names, else the current directory. Say in one
|
||||
line what you will scan. Domains: `api`, `hosting`, `a11y`, `supabase`,
|
||||
`messaging`, `functions`. The scanner skips the ones that do not apply.
|
||||
|
||||
## STEP 2: Run the scanner
|
||||
|
||||
```
|
||||
python3 -B "$HOME/.claude/skills/guardrails/scripts/scan.py" <path>
|
||||
```
|
||||
|
||||
Add `--domain a,b` to narrow, `--exclude a/b,c` to skip copies or
|
||||
vendored code, `--json` for machine output. Exit 0 means no
|
||||
FAIL, 1 means at least one, 2 is a usage error. It never executes project
|
||||
code. Severities:
|
||||
|
||||
- **FAIL**: a protection is provably absent or a key is exposed.
|
||||
- **WARN**: a pattern that is often wrong; judgment needed.
|
||||
- **MANUAL**: only a provider dashboard can set or show it.
|
||||
|
||||
## STEP 3: Judge every FAIL and WARN
|
||||
|
||||
Read the file around each line. Label it CONFIRMED, FALSE POSITIVE (say why)
|
||||
or ACCEPTED RISK (the user decides, never you). A key sitting in a
|
||||
git-ignored env file is not reported, that is where local keys belong; whether
|
||||
it ever reached git history is a separate check (`gitleaks git <repo>`).
|
||||
Heuristic blind spots are in `references/checks.md`: check them before
|
||||
calling a hit false.
|
||||
|
||||
## STEP 4: Cover what the scanner cannot
|
||||
|
||||
Read the code for the domains that apply and answer, with file:line evidence:
|
||||
|
||||
- **API**: does each route check authorization on the object, not only
|
||||
authentication? Is any id in a URL usable to read another user's data?
|
||||
Where is a password written? Trace sign-up and password change to the
|
||||
column: an argon2id, bcrypt or scrypt hash is what must land there.
|
||||
- **Supabase**: does each policy name the right owner column, per operation?
|
||||
Is every table created in the dashboard also covered? Give the user the live
|
||||
queries from the reference file.
|
||||
- **Messaging**: does consent get written at the sign-up point with source and
|
||||
wording? Is a STOP reply wired from the provider webhook to the store?
|
||||
- **Functions**: trace every trigger to the resource it writes, including
|
||||
queues, storage events, schedulers and third-party webhooks.
|
||||
- **A11y**: with a dev server running, walk the main flow with Tab only
|
||||
(`/browse`). Otherwise mark the keyboard walk-through as not done.
|
||||
|
||||
## STEP 5: Manual checklist
|
||||
|
||||
Print each MANUAL item as a step the user performs: spend cap, WAF and DDoS
|
||||
rules, budget alert wired to a stop, live RLS queries. Provider limits change:
|
||||
name the setting, tell the user to confirm it in the current provider docs.
|
||||
Never run a live probe against production, and never claim a MANUAL item done.
|
||||
|
||||
## STEP 6: Report
|
||||
|
||||
Write `.claude/audits/GUARDRAILS.md`: one table per domain with status PASS,
|
||||
FAIL, WARN, MANUAL or N/A, the evidence, and the fix in one line. PASS means
|
||||
"no static finding". Keep it short; no filler sections.
|
||||
|
||||
## STEP 7: Hand over
|
||||
|
||||
Reply with counts, the FAILs with file:line and a one-line fix each, and the
|
||||
MANUAL items. This skill audits; it does not fix. A fix goes through
|
||||
`/bugfix`, `/feat` or `/hotfix`.
|
||||
@@ -0,0 +1,155 @@
|
||||
# Guardrail checks
|
||||
|
||||
Rule ids the scanner emits, what each proves, and the fix. Severity is the
|
||||
default; a judged hit can be a false positive.
|
||||
|
||||
## api
|
||||
|
||||
| Rule | Sev | Catches | Fix |
|
||||
|---|---|---|---|
|
||||
| API-SECRET-LITERAL | FAIL | provider key or private key block in source | env var, rotate the key |
|
||||
| API-PUBLIC-ENV-SECRET | FAIL | `NEXT_PUBLIC_`, `VITE_`, `PUBLIC_` style prefix on a SERVICE_ROLE, SECRET, PRIVATE or PASSWORD name | drop the prefix, read it server-side |
|
||||
| API-ENV-NOT-IGNORED | FAIL | `.env*` file with values, not in `.gitignore` | ignore it, rotate what was exposed |
|
||||
| API-CORS-WILDCARD | FAIL / WARN | any origin allowed; FAIL when credentials are on | explicit origin allowlist |
|
||||
| API-ROUTE-NO-AUTH | WARN | route file with no authentication evidence | add auth, or document why it is public and rate limit it |
|
||||
| API-PASSWORD-PLAINTEXT | FAIL | password column typed as text with no hashing library anywhere; stored password compared with `==` or in a SQL `where password = $1` | argon2id, bcrypt or scrypt hash, verified with the library's check |
|
||||
| API-PASSWORD-WEAK-HASH | FAIL | md5, sha1, sha256 or `createHash().update()` fed a password | argon2id, scrypt or bcrypt |
|
||||
| API-PASSWORD-LOGGED | FAIL | `console.log`, `logger.*`, `print`, `println!`, `error_log` with a password identifier among its arguments, template interpolations included | never log credentials |
|
||||
| API-PASSWORD-LITERAL | WARN | `password: "..."`, `DB_PASSWORD=...` with a value of 8+ characters that is not a placeholder, hash, validation rule or label | env var and rotate; a dev default is documented as such |
|
||||
|
||||
## hosting
|
||||
|
||||
| Rule | Sev | Catches | Fix |
|
||||
|---|---|---|---|
|
||||
| HOST-NO-RATE-LIMIT | FAIL | no rate limiting anywhere in code or config | per IP and per account on login, signup, reset, send, upload |
|
||||
| HOST-ORIGIN-EXPOSED | WARN | origin platform with no CDN or firewall mention | put a CDN and WAF in front |
|
||||
| HOST-WAF-DDOS | MANUAL | firewall, DDoS and bot rules are dashboard settings | enable and confirm in the dashboard |
|
||||
| HOST-SPEND-CAP | MANUAL | hard spend cap is a plan setting | enable the cap; else budget alert plus a written kill switch |
|
||||
|
||||
## a11y
|
||||
|
||||
| Rule | Sev | Catches | Fix |
|
||||
|---|---|---|---|
|
||||
| A11Y-IMG-ALT | FAIL | `img` or `Image` without `alt` | describe it, or `alt=""` if decorative |
|
||||
| A11Y-FIELD-LABEL | FAIL | native input, select, textarea with no label | `label for`, wrapping label or `aria-label` |
|
||||
| A11Y-CLICK-NO-KEYBOARD | FAIL | click handler on a div or span lacking role, tabindex or key handler | use a `button` |
|
||||
| A11Y-FOCUS-OUTLINE | FAIL / WARN | focus outline removed; WARN when a `:focus-visible` style exists elsewhere | style `:focus-visible` instead |
|
||||
| A11Y-TABINDEX-POSITIVE | WARN | `tabindex` above 0 | use 0 or -1 and fix the DOM order |
|
||||
|
||||
## supabase
|
||||
|
||||
| Rule | Sev | Catches | Fix |
|
||||
|---|---|---|---|
|
||||
| SB-RLS-MISSING | FAIL | table created in migrations, RLS never enabled | `alter table ... enable row level security` in the same migration |
|
||||
| SB-RLS-LIVE | MANUAL | dashboard-created tables are invisible to a static scan | run the live queries below |
|
||||
| SB-POLICY-OPEN-WRITE | FAIL | `using (true)` or `with check (true)` on a write | scope to `(select auth.uid())` |
|
||||
| SB-POLICY-ANON-WRITE | FAIL | write policy open to anon or public, not owner-scoped | `to authenticated` plus owner check |
|
||||
| SB-POLICY-PUBLIC-READ | WARN | read policy `true` | confirm the data is public |
|
||||
| SB-POLICY-NOT-OWNER | WARN | policy with no `auth.uid()` or `auth.jwt()` | tie to the owner, or to a reviewed helper |
|
||||
| SB-VIEW-INVOKER | WARN | view runs as its owner and bypasses RLS | `with (security_invoker = true)` |
|
||||
| SB-MATVIEW-EXPOSED | WARN | materialized views cannot have RLS | move out of the exposed schema or revoke |
|
||||
| SB-DEFINER-SEARCH-PATH | WARN | `security definer` without a pinned `search_path` | `set search_path = ''` |
|
||||
| SB-DEFINER-EXECUTE | WARN | definer function callable by anon | `revoke execute ... from public, anon` |
|
||||
| SB-BUCKET-PUBLIC | WARN | public storage bucket | private plus storage policies |
|
||||
| SB-EDGE-NO-JWT | WARN | edge function with `verify_jwt = false` | fine for webhooks that verify a signature |
|
||||
| SB-SERVICE-ROLE-CLIENT | FAIL | service role or secret key referenced in client-reachable code | server only |
|
||||
| SB-SERVICE-ROLE-LITERAL | FAIL | service_role JWT pasted in a file | rotate it, move to server env |
|
||||
|
||||
## messaging
|
||||
|
||||
| Rule | Sev | Catches | Fix |
|
||||
|---|---|---|---|
|
||||
| MSG-NO-CONSENT-RECORD | FAIL / WARN | sender code, no stored consent anywhere; WARN when every sender looks transactional (contact form, reset, receipt) and no subscriber storage exists | store who, when, channel, source, wording |
|
||||
| MSG-SEND-UNCHECKED | WARN | sender file never checks consent or suppression | check before every send |
|
||||
| MSG-NO-UNSUBSCRIBE | FAIL / WARN | email sent, no unsubscribe anywhere; same transactional downgrade | link in every email |
|
||||
| MSG-NO-LIST-UNSUBSCRIBE | WARN | no `List-Unsubscribe` header | add it, with one-click post |
|
||||
| MSG-SMS-NO-STOP | FAIL / WARN | SMS sent, no `STOP` text; same transactional downgrade | add "Reply STOP" to marketing SMS |
|
||||
| MSG-SMS-NO-OPTOUT-STORE | FAIL / WARN | no opt-out storage; same transactional downgrade | record STOP replies, check before sending |
|
||||
|
||||
## functions
|
||||
|
||||
| Rule | Sev | Catches | Fix |
|
||||
|---|---|---|---|
|
||||
| FN-NO-MAX-INSTANCES | FAIL | Firebase, AWS Lambda or Google Cloud with no instance or concurrency cap | set it |
|
||||
| FN-CAP-UNVERIFIED | MANUAL | platform with no cap the scanner can read | check the provider docs; rely on spend cap |
|
||||
| FN-BUDGET-STOP | MANUAL | budget alert wired to an automatic stop | set it; confirm in the console |
|
||||
| FN-SELF-TRIGGER | FAIL / WARN | function writes the resource that fires it (WARN when guarded or file-level heuristic) | `WHEN` guard or idempotency flag |
|
||||
| FN-SELF-INVOKE | FAIL | edge function invokes itself | remove, or cap the depth |
|
||||
|
||||
## Blind spots
|
||||
|
||||
The scanner is regex over text. It cannot see:
|
||||
|
||||
- tables, policies or buckets made in the dashboard
|
||||
- whether a policy names the right owner column
|
||||
- whether consent was actually collected before the stored timestamp
|
||||
- whether a STOP reply reaches your store from the provider webhook
|
||||
- loops through queues, storage events, schedulers or third-party webhooks
|
||||
- keyboard traps, focus order, modal focus handling, color contrast
|
||||
- client-reachable code in unusual layouts (the rule uses path and
|
||||
`use client` heuristics, `.astro` is never flagged)
|
||||
- values built at runtime, minified bundles, anything over 1 MB
|
||||
- keys committed in the past: only the working tree is read, use
|
||||
`gitleaks git <repo>` for history
|
||||
- a password written in clear by code when a hashing library exists
|
||||
elsewhere: the column rule fires only when no library is found anywhere,
|
||||
so trace the write point by hand (STEP 4)
|
||||
- a log call spanning several lines, or `req.body` dumped to a log
|
||||
|
||||
Sender classification is by file path only: names with contact, reset, verify,
|
||||
otp, receipt and the like count as transactional, names with newsletter,
|
||||
campaign, promo and the like as marketing, anything else as unknown. Test files
|
||||
never count as senders. A shared mailer class is therefore judged by the
|
||||
project: a contact form beside it and no subscriber storage gives WARN.
|
||||
|
||||
The scanner skips log files and cache directories, and never follows symlinks.
|
||||
|
||||
By design the scanner ignores: policies granted only to `service_role`,
|
||||
fields that are never rendered (`hidden`, `display: none`), click handlers
|
||||
that only stop propagation or sit on `role="presentation"`, focus styles
|
||||
that swap the outline for a border or shadow, UI route components, keys
|
||||
inside git-ignored env files, and password literals in test, fixture and
|
||||
i18n files.
|
||||
|
||||
## Live Supabase checks (the user runs them in the SQL editor)
|
||||
|
||||
```sql
|
||||
-- tables in the public schema without RLS
|
||||
select tablename from pg_tables
|
||||
where schemaname = 'public' and not rowsecurity;
|
||||
|
||||
-- every policy, to read the owner scoping by eye
|
||||
select tablename, policyname, cmd, roles, qual, with_check
|
||||
from pg_policies where schemaname = 'public' order by tablename, cmd;
|
||||
|
||||
-- views that bypass RLS
|
||||
select c.relname from pg_class c
|
||||
join pg_namespace n on n.oid = c.relnamespace
|
||||
where n.nspname = 'public' and c.relkind = 'v'
|
||||
and coalesce(c.reloptions::text, '') not like '%security_invoker=true%';
|
||||
|
||||
-- definer functions callable by anon
|
||||
select p.proname, p.proconfig from pg_proc p
|
||||
join pg_namespace n on n.oid = p.pronamespace
|
||||
where n.nspname = 'public' and p.prosecdef
|
||||
and has_function_privilege('anon', p.oid, 'execute');
|
||||
|
||||
-- public buckets
|
||||
select id from storage.buckets where public;
|
||||
```
|
||||
|
||||
Two probes on the user's own project, read-only. With the anon key, a GET on
|
||||
each private table must return an empty list or 401. With a second test
|
||||
user's token, a GET on the first user's rows must return nothing.
|
||||
|
||||
## Manual items by domain
|
||||
|
||||
- **Hosting**: rate rules and DDoS or bot protection on at the CDN; a hard
|
||||
spend cap if the plan has one; a budget alert and a written kill-switch step.
|
||||
- **Functions**: budget alert wired to an automatic stop (throttle concurrency
|
||||
to zero, revoke invoke rights, or disable billing); a timeout on every
|
||||
function.
|
||||
- **Messaging**: provider-side STOP handling on, a webhook storing opt-outs,
|
||||
a retention rule for consent proof.
|
||||
- **Supabase**: the live queries above; spend cap on the plan; redirect URLs
|
||||
and email confirmation settings reviewed.
|
||||
@@ -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)
|
||||
]
|
||||
@@ -0,0 +1,129 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Static guardrails scan: API, hosting, a11y, Supabase, messaging, functions.
|
||||
|
||||
Reads a project tree as data and never executes it. Exit codes:
|
||||
0 no FAIL, 1 at least one FAIL, 2 usage error.
|
||||
"""
|
||||
import argparse
|
||||
import json
|
||||
import sys
|
||||
from dataclasses import dataclass
|
||||
from pathlib import Path
|
||||
|
||||
from checks import a11y, apis, functions, hosting, messaging, supabase
|
||||
from checks.common import Project
|
||||
|
||||
DOMAINS = {
|
||||
"api": apis,
|
||||
"hosting": hosting,
|
||||
"a11y": a11y,
|
||||
"supabase": supabase,
|
||||
"messaging": messaging,
|
||||
"functions": functions,
|
||||
}
|
||||
SEVERITY_RANK = {"FAIL": 0, "WARN": 1, "MANUAL": 2}
|
||||
|
||||
|
||||
@dataclass(frozen=True)
|
||||
class Result:
|
||||
findings: list
|
||||
applicable: list
|
||||
skipped: list
|
||||
|
||||
|
||||
def parse_args(argv):
|
||||
parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
|
||||
parser.add_argument("path", help="project root to scan")
|
||||
parser.add_argument(
|
||||
"--domain", default=",".join(DOMAINS),
|
||||
help="comma list among: " + ", ".join(DOMAINS))
|
||||
parser.add_argument(
|
||||
"--exclude", default="",
|
||||
help="comma list of relative paths to skip (copies, vendored code)")
|
||||
parser.add_argument("--json", action="store_true", help="JSON output")
|
||||
return parser.parse_args(argv)
|
||||
|
||||
|
||||
def _split(value):
|
||||
return [part.strip() for part in value.split(",") if part.strip()]
|
||||
|
||||
|
||||
def run_checks(project, names):
|
||||
findings, applicable, skipped = [], [], []
|
||||
for name in names:
|
||||
module = DOMAINS[name]
|
||||
if module.applies(project):
|
||||
applicable.append(name)
|
||||
findings += module.check(project)
|
||||
else:
|
||||
skipped.append(name)
|
||||
findings.sort(key=lambda f: (
|
||||
SEVERITY_RANK[f.severity], f.domain, f.path, f.line))
|
||||
return Result(findings, applicable, skipped)
|
||||
|
||||
|
||||
def summarize(findings):
|
||||
return {sev: sum(f.severity == sev for f in findings)
|
||||
for sev in SEVERITY_RANK}
|
||||
|
||||
|
||||
def _domain_lines(domain, findings):
|
||||
rows = [f for f in findings if f.domain == domain]
|
||||
return [f"\n[{domain}]"] + (
|
||||
[f" {f.severity:<6} {f.rule:<24} {f.path}:{f.line} {f.message}"
|
||||
for f in rows] or [" no finding"])
|
||||
|
||||
|
||||
def _summary_line(findings):
|
||||
totals = summarize(findings)
|
||||
return "\nsummary: " + ", ".join(
|
||||
f"{n} {sev}" for sev, n in totals.items())
|
||||
|
||||
|
||||
def render_text(project, result):
|
||||
lines = [
|
||||
f"guardrails scan: {project.root} ({len(project.files)} files)",
|
||||
"scanned: " + (", ".join(result.applicable) or "none"),
|
||||
]
|
||||
if result.skipped:
|
||||
lines.append("not applicable: " + ", ".join(result.skipped))
|
||||
for domain in result.applicable:
|
||||
lines += _domain_lines(domain, result.findings)
|
||||
return "\n".join(lines + [_summary_line(result.findings)])
|
||||
|
||||
|
||||
def render_json(project, result):
|
||||
return json.dumps({
|
||||
"root": str(project.root), "files": len(project.files),
|
||||
"applicable": result.applicable, "not_applicable": result.skipped,
|
||||
"summary": summarize(result.findings),
|
||||
"findings": [f.as_dict() for f in result.findings],
|
||||
}, indent=2)
|
||||
|
||||
|
||||
def _usage_error(path, names):
|
||||
unknown = [n for n in names if n not in DOMAINS]
|
||||
if unknown:
|
||||
return f"unknown domain {unknown}"
|
||||
return "" if Path(path).is_dir() else f"not a directory: {path}"
|
||||
|
||||
|
||||
def _scan(args):
|
||||
project = Project(Path(args.path), _split(args.exclude))
|
||||
result = run_checks(project, _split(args.domain))
|
||||
render = render_json if args.json else render_text
|
||||
print(render(project, result))
|
||||
return 1 if any(f.severity == "FAIL" for f in result.findings) else 0
|
||||
|
||||
|
||||
def main(argv):
|
||||
args = parse_args(argv)
|
||||
error = _usage_error(args.path, _split(args.domain))
|
||||
if error:
|
||||
print(f"usage error: {error}", file=sys.stderr)
|
||||
return 2
|
||||
return _scan(args)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
sys.exit(main(sys.argv[1:]))
|
||||
@@ -0,0 +1,6 @@
|
||||
[
|
||||
{"id": 1, "prompt": "Vérifie que la RLS est bien activée partout sur mon projet Supabase dans ~/Documents/game et qu'aucune clé service_role n'est côté client.", "expected": "Runs the scanner on the path, reads each supabase FAIL and WARN in context, gives the live RLS queries as a manual step, writes .claude/audits/GUARDRAILS.md, does not fix anything"},
|
||||
{"id": 2, "prompt": "teste les garde-fous sur ce projet, il envoie des emails et des SMS de relance", "expected": "Scans messaging and api, checks consent record, unsubscribe link, List-Unsubscribe and STOP handling, traces the opt-out path from the provider webhook, lists the dashboard items as MANUAL"},
|
||||
{"id": 3, "prompt": "Audit my Firebase functions: can any of them loop on itself or run up the bill?", "expected": "Scans functions domain only, reports max instances status and any trigger that writes its own collection, MANUAL item for a budget alert wired to an automatic stop, no live call to the provider"},
|
||||
{"id": 4, "prompt": "est-ce que les mots de passe sont stockés en clair quelque part dans ~/Documents/zenquality ?", "expected": "Runs the scanner's api domain, reads every API-PASSWORD-* hit in context, traces the sign-up and password-change write points to the password_hash column by hand, names the hashing function found, reports with file:line, fixes nothing"}
|
||||
]
|
||||
Reference in new issue
Block a user