mirror of
https://github.com/garrytan/gstack.git
synced 2026-11-22 08:01:32 +01:00
Telemetry backend only accepts writes through its own endpoint, and tests stop sending to it (GST-3234) (#4537)
The telemetry backend now takes writes only through its validated endpoint, signed-in Supabase users can read or write nothing, and gstack's tests can no longer send telemetry to the live project. Why: a signed-in prober read two views on 2026-11-19, probes wrote about 2,000 junk rows through the open insert policy, and 41% of all skill-run rows were test-suite traffic. Nothing changes for users until the migrations and edge functions are deployed; the deploy order is under Deploy. Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com> Review-Finding: p1/red-team#1 reader=red-team Review-Finding: supabase/migrations/008_close_anon_writes.sql:9:published-number reader=core Review-Finding: p2/outside-voice#3 reader=outside-voice
This commit is contained in:
1 parent
dab7549451
commit
12cc21872d
15 files changed
+704
-270
No files matched your search
@@ -0,0 +1 @@
|
||||
**gstack's telemetry backend only accepts writes through its own validated endpoint, and the community dashboard now counts real use.** The public key can no longer read or write the telemetry tables, and a signed-in Supabase user is denied everything. Test runs never send telemetry, test traffic is filtered out of `gstack-community-dashboard`, and its weekly active count is now real installs instead of update checks. The ingest endpoint also keeps whether an event came from a test and stores prompt-injection detections, which it used to drop. Clients older than v0.11.16.0 (March 2026) no longer report usage.
|
||||
+5
-2
@@ -26,8 +26,11 @@ no, and `gstack-config set telemetry off` turns it off at any time.
|
||||
- **Where it goes:** [Supabase](https://supabase.com) (an open-source Firebase
|
||||
alternative). The schema is in [`supabase/migrations/`](../supabase/migrations/),
|
||||
so you can verify what's collected. The publishable key in the repo is a
|
||||
public key; row-level security denies direct access, and edge functions
|
||||
enforce schema checks, event allowlists and field length limits.
|
||||
public key that can neither read nor write those tables; every write goes
|
||||
through edge functions that enforce schema checks, event allowlists and
|
||||
field length limits. gstack never uses Supabase sign-in, and signed-in users
|
||||
are denied everything too. gstack's own test suite never sends telemetry
|
||||
to the live project.
|
||||
|
||||
**Update check (on by default, regardless of telemetry).** Every interactive
|
||||
skill start runs `gstack-update-check`. When its cache is stale (60 minutes after an
|
||||
|
||||
@@ -6,3 +6,11 @@
|
||||
|
||||
GSTACK_SUPABASE_URL="https://frugpmstpnojnhfyimgv.supabase.co"
|
||||
GSTACK_SUPABASE_ANON_KEY="sb_publishable_tR4i6cyMIrYTE3s6OyHGHw_ppx2p6WK"
|
||||
|
||||
# Tests must never reach the live project (old test runs left about 554,000
|
||||
# fixture rows in it). test-setup.ts sets this for every `bun test`; with it
|
||||
# set, a client that falls back to this file finds no endpoint and sends nothing.
|
||||
if [ -n "${GSTACK_TEST_BLOCK_LIVE_TELEMETRY:-}" ]; then
|
||||
GSTACK_SUPABASE_URL=""
|
||||
GSTACK_SUPABASE_ANON_KEY=""
|
||||
fi
|
||||
@@ -1,6 +1,7 @@
|
||||
// gstack community-pulse edge function
|
||||
// Returns aggregated community stats for the dashboard:
|
||||
// weekly active count, top skills, crash clusters, version distribution.
|
||||
// Returns aggregated community stats for the dashboard: weekly active
|
||||
// community-tier installs, update checks, top skills, crash clusters, version
|
||||
// distribution and the prompt-injection aggregate, all from live traffic.
|
||||
// Uses server-side cache (community_pulse_cache table) to prevent DoS.
|
||||
//
|
||||
// Fail-closed contract (#1947): success responses carry `status: "ok"` so
|
||||
@@ -40,7 +41,7 @@ Deno.serve(async () => {
|
||||
cached = null; // cache miss/failure is non-fatal — recompute decides
|
||||
}
|
||||
|
||||
if (cached?.refreshed_at) {
|
||||
if (cached?.refreshed_at && cached.data && "weekly_update_checks" in cached.data) {
|
||||
const age = Date.now() - new Date(cached.refreshed_at).getTime();
|
||||
if (age < CACHE_MAX_AGE_MS) {
|
||||
// Serving the cache means this (new) backend is healthy; assert the
|
||||
@@ -53,153 +54,15 @@ Deno.serve(async () => {
|
||||
}
|
||||
|
||||
try {
|
||||
// Cache is stale or missing — recompute
|
||||
const weekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
|
||||
const twoWeeksAgo = new Date(Date.now() - 14 * 24 * 60 * 60 * 1000).toISOString();
|
||||
// Cache is stale or missing — recompute. community_pulse_summary()
|
||||
// (migration 006) counts every live row of the last 7 days in SQL: test
|
||||
// traffic, fixture-shaped session ids and probe versions are left out, and
|
||||
// weekly_active is distinct community-tier installs, not update checks.
|
||||
const { data: summary, error: summaryErr } = await supabase.rpc("community_pulse_summary");
|
||||
if (summaryErr) throw summaryErr;
|
||||
if (!summary || typeof summary !== "object") throw new Error("empty pulse summary");
|
||||
|
||||
// Weekly active (update checks this week)
|
||||
const { count: thisWeek, error: thisWeekErr } = await supabase
|
||||
.from("update_checks")
|
||||
.select("*", { count: "exact", head: true })
|
||||
.gte("checked_at", weekAgo);
|
||||
if (thisWeekErr) throw thisWeekErr;
|
||||
|
||||
// Last week (for change %)
|
||||
const { count: lastWeek, error: lastWeekErr } = await supabase
|
||||
.from("update_checks")
|
||||
.select("*", { count: "exact", head: true })
|
||||
.gte("checked_at", twoWeeksAgo)
|
||||
.lt("checked_at", weekAgo);
|
||||
if (lastWeekErr) throw lastWeekErr;
|
||||
|
||||
const current = thisWeek ?? 0;
|
||||
const previous = lastWeek ?? 0;
|
||||
const changePct = previous > 0
|
||||
? Math.round(((current - previous) / previous) * 100)
|
||||
: 0;
|
||||
|
||||
// Top skills (last 7 days)
|
||||
const { data: skillRows, error: skillErr } = await supabase
|
||||
.from("telemetry_events")
|
||||
.select("skill")
|
||||
.eq("event_type", "skill_run")
|
||||
.gte("event_timestamp", weekAgo)
|
||||
.not("skill", "is", null)
|
||||
.limit(1000);
|
||||
if (skillErr) throw skillErr;
|
||||
|
||||
const skillCounts: Record<string, number> = {};
|
||||
for (const row of skillRows ?? []) {
|
||||
if (row.skill) {
|
||||
skillCounts[row.skill] = (skillCounts[row.skill] ?? 0) + 1;
|
||||
}
|
||||
}
|
||||
const topSkills = Object.entries(skillCounts)
|
||||
.sort(([, a], [, b]) => b - a)
|
||||
.slice(0, 10)
|
||||
.map(([skill, count]) => ({ skill, count }));
|
||||
|
||||
// Crash clusters (top 5)
|
||||
const { data: crashes, error: crashErr } = await supabase
|
||||
.from("crash_clusters")
|
||||
.select("error_class, gstack_version, total_occurrences, identified_users")
|
||||
.limit(5);
|
||||
if (crashErr) throw crashErr;
|
||||
|
||||
// Version distribution (last 7 days)
|
||||
const versionCounts: Record<string, number> = {};
|
||||
const { data: versionRows, error: versionErr } = await supabase
|
||||
.from("telemetry_events")
|
||||
.select("gstack_version")
|
||||
.eq("event_type", "skill_run")
|
||||
.gte("event_timestamp", weekAgo)
|
||||
.limit(1000);
|
||||
if (versionErr) throw versionErr;
|
||||
|
||||
for (const row of versionRows ?? []) {
|
||||
if (row.gstack_version) {
|
||||
versionCounts[row.gstack_version] = (versionCounts[row.gstack_version] ?? 0) + 1;
|
||||
}
|
||||
}
|
||||
const topVersions = Object.entries(versionCounts)
|
||||
.sort(([, a], [, b]) => b - a)
|
||||
.slice(0, 5)
|
||||
.map(([version, count]) => ({ version, count }));
|
||||
|
||||
// Security events — aggregate attack_attempt events from the last 7 days.
|
||||
// Fields emitted by gstack-telemetry-log --event-type attack_attempt:
|
||||
// security_url_domain, security_payload_hash, security_confidence,
|
||||
// security_layer, security_verdict.
|
||||
const { data: attackRows, error: attackErr } = await supabase
|
||||
.from("telemetry_events")
|
||||
.select("security_url_domain, security_layer, security_verdict, installation_id")
|
||||
.eq("event_type", "attack_attempt")
|
||||
.gte("event_timestamp", weekAgo)
|
||||
.limit(5000);
|
||||
if (attackErr) throw attackErr;
|
||||
|
||||
// k-anonymity threshold. A domain (or layer) must be reported by at least
|
||||
// K_ANON distinct installations to appear in the aggregate. Without this,
|
||||
// a single user's attack log leaks their targeted domains to every other
|
||||
// gstack user who polls /community-pulse. With it, the dashboard shows
|
||||
// only community-wide patterns.
|
||||
const K_ANON = 5;
|
||||
|
||||
const attacksTotal = attackRows?.length ?? 0;
|
||||
const domainCounts: Record<string, number> = {};
|
||||
const domainInstallations: Record<string, Set<string>> = {};
|
||||
const layerCounts: Record<string, number> = {};
|
||||
const layerInstallations: Record<string, Set<string>> = {};
|
||||
const verdictCounts: Record<string, number> = {};
|
||||
for (const row of attackRows ?? []) {
|
||||
const iid = row.installation_id ?? "";
|
||||
if (row.security_url_domain) {
|
||||
domainCounts[row.security_url_domain] = (domainCounts[row.security_url_domain] ?? 0) + 1;
|
||||
if (iid) {
|
||||
(domainInstallations[row.security_url_domain] ??= new Set()).add(iid);
|
||||
}
|
||||
}
|
||||
if (row.security_layer) {
|
||||
layerCounts[row.security_layer] = (layerCounts[row.security_layer] ?? 0) + 1;
|
||||
if (iid) {
|
||||
(layerInstallations[row.security_layer] ??= new Set()).add(iid);
|
||||
}
|
||||
}
|
||||
if (row.security_verdict) {
|
||||
// Verdict distribution is low-cardinality (block/warn/log_only) and
|
||||
// aggregates population-wide with no re-identification risk, so no
|
||||
// k-anon filter.
|
||||
verdictCounts[row.security_verdict] = (verdictCounts[row.security_verdict] ?? 0) + 1;
|
||||
}
|
||||
}
|
||||
const topAttackDomains = Object.entries(domainCounts)
|
||||
.filter(([domain]) => (domainInstallations[domain]?.size ?? 0) >= K_ANON)
|
||||
.sort(([, a], [, b]) => b - a)
|
||||
.slice(0, 10)
|
||||
.map(([domain, count]) => ({ domain, count }));
|
||||
const topAttackLayers = Object.entries(layerCounts)
|
||||
.filter(([layer]) => (layerInstallations[layer]?.size ?? 0) >= K_ANON)
|
||||
.sort(([, a], [, b]) => b - a)
|
||||
.map(([layer, count]) => ({ layer, count }));
|
||||
const attackVerdictDistribution = Object.entries(verdictCounts)
|
||||
.sort(([, a], [, b]) => b - a)
|
||||
.map(([verdict, count]) => ({ verdict, count }));
|
||||
|
||||
const result = {
|
||||
status: "ok",
|
||||
weekly_active: current,
|
||||
change_pct: changePct,
|
||||
top_skills: topSkills,
|
||||
crashes: crashes ?? [],
|
||||
versions: topVersions,
|
||||
// Security aggregate for the /security-dashboard view
|
||||
security: {
|
||||
attacks_last_7_days: attacksTotal,
|
||||
top_attack_domains: topAttackDomains,
|
||||
top_attack_layers: topAttackLayers,
|
||||
verdict_distribution: attackVerdictDistribution,
|
||||
},
|
||||
};
|
||||
const result = { status: "ok", ...(summary as Record<string, unknown>) };
|
||||
|
||||
// Upsert cache
|
||||
await supabase
|
||||
|
||||
@@ -21,6 +21,48 @@ interface TelemetryEvent {
|
||||
used_browse?: boolean;
|
||||
sessions?: number;
|
||||
installation_id?: string;
|
||||
source?: string;
|
||||
security_url_domain?: string;
|
||||
security_payload_hash?: string;
|
||||
security_confidence?: number;
|
||||
security_layer?: string;
|
||||
security_verdict?: string;
|
||||
}
|
||||
|
||||
// bin/gstack-telemetry-log writes source from --source or
|
||||
// GSTACK_TELEMETRY_SOURCE (default "live"). Keep it so test and eval traffic
|
||||
// can be told apart from real use; anything unexpected is "other", never "live".
|
||||
const SOURCES = ["live", "test", "eval", "ci"];
|
||||
function normalizeSource(source: unknown): string {
|
||||
if (source === undefined || source === null || source === "") return "live";
|
||||
return SOURCES.includes(String(source)) ? String(source) : "other";
|
||||
}
|
||||
|
||||
// Prompt-injection detections (browse/src/security.ts via gstack-telemetry-log
|
||||
// --event-type attack_attempt; columns from migration 004). Domain only, a
|
||||
// salted hash, a 0..1 score and two enums; anything else is dropped.
|
||||
const SECURITY_LAYERS = [
|
||||
"stackone_content", "testsavant_content", "transcript_classifier",
|
||||
"aria_regex", "canary", "deberta_content",
|
||||
];
|
||||
const SECURITY_VERDICTS = ["block", "warn", "log_only"];
|
||||
function securityFields(event: TelemetryEvent) {
|
||||
const domain = typeof event.security_url_domain === "string" &&
|
||||
/^[A-Za-z0-9.-]{1,253}$/.test(event.security_url_domain)
|
||||
? event.security_url_domain.toLowerCase() : null;
|
||||
const hash = typeof event.security_payload_hash === "string" &&
|
||||
/^[0-9a-f]{16,128}$/.test(event.security_payload_hash)
|
||||
? event.security_payload_hash : null;
|
||||
const confidence = typeof event.security_confidence === "number" &&
|
||||
event.security_confidence >= 0 && event.security_confidence <= 1
|
||||
? event.security_confidence : null;
|
||||
return {
|
||||
security_url_domain: domain,
|
||||
security_payload_hash: hash,
|
||||
security_confidence: confidence,
|
||||
security_layer: SECURITY_LAYERS.includes(String(event.security_layer)) ? event.security_layer : null,
|
||||
security_verdict: SECURITY_VERDICTS.includes(String(event.security_verdict)) ? event.security_verdict : null,
|
||||
};
|
||||
}
|
||||
|
||||
const MAX_BATCH_SIZE = 100;
|
||||
@@ -45,15 +87,14 @@ Deno.serve(async (req) => {
|
||||
return new Response(`Batch too large (max ${MAX_BATCH_SIZE})`, { status: 400 });
|
||||
}
|
||||
|
||||
// Use the anon key, not the service role key.
|
||||
// The service role key bypasses Row Level Security (RLS) and grants full
|
||||
// unrestricted database access — wildly over-privileged for a public
|
||||
// telemetry endpoint that only needs INSERT on two tables.
|
||||
// The anon key + properly configured RLS INSERT policies is correct.
|
||||
// See: https://supabase.com/docs/guides/database/postgres/row-level-security
|
||||
// Service role key, as update-check and community-pulse use. The public
|
||||
// anon key can no longer write to these tables (migration 008): the RLS
|
||||
// insert policies it relied on also let anyone write arbitrary rows
|
||||
// straight through PostgREST. This function is now the only write path,
|
||||
// and it validates every field before the insert below.
|
||||
const supabase = createClient(
|
||||
Deno.env.get("SUPABASE_URL") ?? "",
|
||||
Deno.env.get("SUPABASE_ANON_KEY") ?? ""
|
||||
Deno.env.get("SUPABASE_SERVICE_ROLE_KEY") ?? ""
|
||||
);
|
||||
|
||||
// Validate and transform events
|
||||
@@ -72,6 +113,7 @@ Deno.serve(async (req) => {
|
||||
// Validate event_type. Activation-funnel events (v1.x) join the originals:
|
||||
// onboarding (P0 setup nudge), first_task_scaffold_shown (P4 first-run
|
||||
// scaffold), handoff (P1 office-hours → next skill), route (gstack router).
|
||||
// attack_attempt carries the prompt-injection fields (migration 004).
|
||||
const validTypes = [
|
||||
"skill_run",
|
||||
"upgrade_prompted",
|
||||
@@ -80,6 +122,7 @@ Deno.serve(async (req) => {
|
||||
"first_task_scaffold_shown",
|
||||
"handoff",
|
||||
"route",
|
||||
"attack_attempt",
|
||||
];
|
||||
if (!validTypes.includes(event.event_type)) continue;
|
||||
|
||||
@@ -100,6 +143,8 @@ Deno.serve(async (req) => {
|
||||
used_browse: event.used_browse === true,
|
||||
concurrent_sessions: typeof event.sessions === "number" ? event.sessions : 1,
|
||||
installation_id: event.installation_id ? String(event.installation_id).slice(0, 64) : null,
|
||||
source: normalizeSource(event.source),
|
||||
...(event.event_type === "attack_attempt" ? securityFields(event) : {}),
|
||||
});
|
||||
|
||||
// Track installations for upsert
|
||||
|
||||
@@ -25,20 +25,23 @@
|
||||
-- * salt is per-device local file (~/.gstack/security/device-salt) —
|
||||
-- preventing cross-device rainbow table attacks
|
||||
|
||||
-- IF NOT EXISTS: this migration was not applied to the live project until
|
||||
-- after 006 was written, so it must be safe to run twice. It must run before
|
||||
-- 006, whose view and function read these columns.
|
||||
ALTER TABLE telemetry_events
|
||||
ADD COLUMN security_url_domain TEXT,
|
||||
ADD COLUMN security_payload_hash TEXT,
|
||||
ADD COLUMN security_confidence NUMERIC,
|
||||
ADD COLUMN security_layer TEXT,
|
||||
ADD COLUMN security_verdict TEXT;
|
||||
ADD COLUMN IF NOT EXISTS security_url_domain TEXT,
|
||||
ADD COLUMN IF NOT EXISTS security_payload_hash TEXT,
|
||||
ADD COLUMN IF NOT EXISTS security_confidence NUMERIC,
|
||||
ADD COLUMN IF NOT EXISTS security_layer TEXT,
|
||||
ADD COLUMN IF NOT EXISTS security_verdict TEXT;
|
||||
|
||||
-- Top-domains query: ORDER BY count DESC WHERE event_type='attack_attempt'
|
||||
-- AND event_timestamp > now() - interval '7 days'
|
||||
CREATE INDEX idx_telemetry_attack_domain
|
||||
CREATE INDEX IF NOT EXISTS idx_telemetry_attack_domain
|
||||
ON telemetry_events (security_url_domain, event_timestamp)
|
||||
WHERE event_type = 'attack_attempt';
|
||||
|
||||
-- Layer-distribution query
|
||||
CREATE INDEX idx_telemetry_attack_layer
|
||||
CREATE INDEX IF NOT EXISTS idx_telemetry_attack_layer
|
||||
ON telemetry_events (security_layer, event_timestamp)
|
||||
WHERE event_type = 'attack_attempt';
|
||||
@@ -0,0 +1,43 @@
|
||||
-- 005_revoke_authenticated.sql
|
||||
-- gstack never uses Supabase Auth, so a signed-in user (the `authenticated`
|
||||
-- role) must reach nothing. Supabase's default grants give `authenticated`
|
||||
-- the same table privileges as `anon`, and views run as their owner, so
|
||||
-- RLS does not protect them: migration 002 revoked crash_clusters and
|
||||
-- skill_sequences from anon only. On 2026-11-19 someone signed up through the
|
||||
-- public Auth endpoint, so this closes that path.
|
||||
--
|
||||
-- This mirrors the lockdown applied to the live project on 2026-11-19, and
|
||||
-- also makes both views security_invoker so they read with the caller's
|
||||
-- privileges and RLS instead of their owner's. 008 closes anon's write path.
|
||||
|
||||
BEGIN;
|
||||
REVOKE ALL ON ALL TABLES IN SCHEMA public FROM authenticated;
|
||||
REVOKE ALL ON ALL SEQUENCES IN SCHEMA public FROM authenticated;
|
||||
REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM authenticated;
|
||||
REVOKE ALL ON public.crash_clusters, public.skill_sequences FROM anon, authenticated;
|
||||
ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE ALL ON TABLES FROM authenticated;
|
||||
ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE ALL ON SEQUENCES FROM authenticated;
|
||||
ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE EXECUTE ON FUNCTIONS FROM authenticated;
|
||||
ALTER VIEW public.crash_clusters SET (security_invoker = true);
|
||||
ALTER VIEW public.skill_sequences SET (security_invoker = true);
|
||||
COMMIT;
|
||||
|
||||
-- The lines above change the running role's defaults only. Objects that
|
||||
-- supabase_admin creates later still default to granting `authenticated`.
|
||||
-- Only a member of supabase_admin can change that; on the hosted project the
|
||||
-- migration role (postgres) is not one, so this says so and moves on.
|
||||
DO $$
|
||||
BEGIN
|
||||
ALTER DEFAULT PRIVILEGES FOR ROLE supabase_admin IN SCHEMA public REVOKE ALL ON TABLES FROM authenticated;
|
||||
ALTER DEFAULT PRIVILEGES FOR ROLE supabase_admin IN SCHEMA public REVOKE ALL ON SEQUENCES FROM authenticated;
|
||||
ALTER DEFAULT PRIVILEGES FOR ROLE supabase_admin IN SCHEMA public REVOKE EXECUTE ON FUNCTIONS FROM authenticated;
|
||||
EXCEPTION
|
||||
WHEN insufficient_privilege OR undefined_object THEN
|
||||
RAISE NOTICE 'supabase_admin default privileges unchanged (%): objects it creates later still grant authenticated', SQLERRM;
|
||||
END
|
||||
$$;
|
||||
|
||||
-- Postgres also grants EXECUTE on every new function to PUBLIC, which
|
||||
-- `authenticated` inherits, and the default-privilege line above does not
|
||||
-- remove that. Every function a later migration adds must therefore
|
||||
-- `REVOKE EXECUTE ... FROM PUBLIC, anon, authenticated` itself (006 does).
|
||||
@@ -0,0 +1,140 @@
|
||||
-- 006_live_traffic_and_pulse_summary.sql
|
||||
-- Separates real use from test traffic and moves community-pulse's counting
|
||||
-- into SQL.
|
||||
--
|
||||
-- Why: until v1.86.0.0 test/telemetry.test.ts posted to this project, and
|
||||
-- older checkouts still do when their tests run; about 41% of skill_run rows
|
||||
-- to 2026-11-19 carry test-fixture session ids (`a-1`, `inj-3`, ...). The
|
||||
-- community-pulse function also counted only the first 1,000 rows of a week
|
||||
-- and reported update-check rows as "weekly active".
|
||||
--
|
||||
-- What counts as live (telemetry_live_events):
|
||||
-- * source is 'live' (rows from before this column default to 'live'),
|
||||
-- * a numeric gstack version other than 0.0.0 (probes used 0.0.0-*),
|
||||
-- * an event type the ingest function accepts, and
|
||||
-- * for skill_run, a session id in the shape bin/gstack-skill-start mints
|
||||
-- (<pid>-<epoch> or <pid>-<epoch>-<suffix>); for upgrade_prompted, the
|
||||
-- shape bin/gstack-update-check mints (update-<pid>-<epoch>).
|
||||
--
|
||||
|
||||
ALTER TABLE telemetry_events ADD COLUMN IF NOT EXISTS source TEXT NOT NULL DEFAULT 'live';
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_telemetry_received_at ON telemetry_events (received_at);
|
||||
|
||||
CREATE OR REPLACE VIEW telemetry_live_events WITH (security_invoker = true) AS
|
||||
SELECT *
|
||||
FROM telemetry_events
|
||||
WHERE source = 'live'
|
||||
AND gstack_version ~ '^[0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?$'
|
||||
AND gstack_version NOT LIKE '0.0.0%'
|
||||
AND event_type IN ('skill_run', 'upgrade_prompted', 'upgrade_completed', 'onboarding',
|
||||
'first_task_scaffold_shown', 'handoff', 'route', 'attack_attempt')
|
||||
AND (
|
||||
(event_type = 'skill_run' AND session_id ~ '^[0-9]+-[0-9]+(-[0-9A-Za-z]+)?$')
|
||||
OR (event_type = 'upgrade_prompted' AND session_id ~ '^update-[0-9]+-[0-9]+$')
|
||||
OR event_type NOT IN ('skill_run', 'upgrade_prompted')
|
||||
);
|
||||
|
||||
REVOKE ALL ON telemetry_live_events FROM PUBLIC, anon, authenticated;
|
||||
|
||||
-- Same columns as 001's view; it now reads live rows only.
|
||||
CREATE OR REPLACE VIEW crash_clusters WITH (security_invoker = true) AS
|
||||
SELECT
|
||||
error_class,
|
||||
gstack_version,
|
||||
COUNT(*) as total_occurrences,
|
||||
COUNT(DISTINCT installation_id) as identified_users,
|
||||
COUNT(*) - COUNT(installation_id) as anonymous_occurrences,
|
||||
MIN(event_timestamp) as first_seen,
|
||||
MAX(event_timestamp) as last_seen
|
||||
FROM telemetry_live_events
|
||||
WHERE outcome = 'error' AND error_class IS NOT NULL
|
||||
GROUP BY error_class, gstack_version
|
||||
ORDER BY total_occurrences DESC;
|
||||
|
||||
REVOKE ALL ON crash_clusters FROM PUBLIC, anon, authenticated;
|
||||
|
||||
-- One call returns everything community-pulse shows, counted over every live
|
||||
-- row of the last 7 days (by server receive time). weekly_active is distinct
|
||||
-- community-tier installs that ran a skill; anonymous-tier use has no id and
|
||||
-- is not in it. Attack domains and layers need 5 distinct installs (k-anonymity).
|
||||
CREATE OR REPLACE FUNCTION community_pulse_summary()
|
||||
RETURNS jsonb
|
||||
LANGUAGE sql
|
||||
STABLE
|
||||
SECURITY INVOKER
|
||||
SET search_path = public
|
||||
AS $$
|
||||
WITH week AS (
|
||||
SELECT * FROM telemetry_live_events WHERE received_at >= now() - interval '7 days'
|
||||
),
|
||||
prev AS (
|
||||
SELECT * FROM telemetry_live_events
|
||||
WHERE received_at >= now() - interval '14 days' AND received_at < now() - interval '7 days'
|
||||
),
|
||||
runs AS (
|
||||
SELECT * FROM week WHERE event_type = 'skill_run' AND skill IS NOT NULL AND skill NOT LIKE '\_%'
|
||||
),
|
||||
active AS (
|
||||
SELECT
|
||||
(SELECT COUNT(DISTINCT installation_id) FROM runs) AS this_week,
|
||||
(SELECT COUNT(DISTINCT installation_id) FROM prev
|
||||
WHERE event_type = 'skill_run' AND skill IS NOT NULL AND skill NOT LIKE '\_%') AS last_week
|
||||
),
|
||||
attacks AS (
|
||||
SELECT * FROM week WHERE event_type = 'attack_attempt'
|
||||
)
|
||||
SELECT jsonb_build_object(
|
||||
'weekly_active', (SELECT this_week FROM active),
|
||||
'change_pct', (SELECT CASE WHEN last_week > 0
|
||||
THEN round(((this_week - last_week)::numeric / last_week) * 100)::int
|
||||
ELSE 0 END FROM active),
|
||||
'weekly_update_checks', (
|
||||
SELECT COUNT(*) FROM update_checks
|
||||
WHERE checked_at >= now() - interval '7 days'
|
||||
AND gstack_version ~ '^[0-9]+\.[0-9]+\.[0-9]+(\.[0-9]+)?$'
|
||||
AND gstack_version NOT LIKE '0.0.0%'
|
||||
),
|
||||
'top_skills', COALESCE((
|
||||
SELECT jsonb_agg(jsonb_build_object('skill', skill, 'count', n) ORDER BY n DESC, skill)
|
||||
FROM (SELECT skill, COUNT(*) AS n FROM runs GROUP BY skill ORDER BY n DESC, skill LIMIT 10) t
|
||||
), '[]'::jsonb),
|
||||
'crashes', COALESCE((
|
||||
SELECT jsonb_agg(jsonb_build_object(
|
||||
'error_class', error_class, 'gstack_version', gstack_version,
|
||||
'total_occurrences', total_occurrences, 'identified_users', identified_users))
|
||||
FROM (SELECT * FROM crash_clusters LIMIT 5) t
|
||||
), '[]'::jsonb),
|
||||
'versions', COALESCE((
|
||||
SELECT jsonb_agg(jsonb_build_object('version', gstack_version, 'count', n) ORDER BY n DESC, gstack_version)
|
||||
FROM (SELECT gstack_version, COUNT(*) AS n FROM runs GROUP BY gstack_version
|
||||
ORDER BY n DESC, gstack_version LIMIT 5) t
|
||||
), '[]'::jsonb),
|
||||
'security', jsonb_build_object(
|
||||
'attacks_last_7_days', (SELECT COUNT(*) FROM attacks),
|
||||
'top_attack_domains', COALESCE((
|
||||
SELECT jsonb_agg(jsonb_build_object('domain', security_url_domain, 'count', n) ORDER BY n DESC, security_url_domain)
|
||||
FROM (SELECT security_url_domain, COUNT(*) AS n FROM attacks
|
||||
WHERE security_url_domain IS NOT NULL
|
||||
GROUP BY security_url_domain
|
||||
HAVING COUNT(DISTINCT installation_id) >= 5
|
||||
ORDER BY n DESC, security_url_domain LIMIT 10) t
|
||||
), '[]'::jsonb),
|
||||
'top_attack_layers', COALESCE((
|
||||
SELECT jsonb_agg(jsonb_build_object('layer', security_layer, 'count', n) ORDER BY n DESC, security_layer)
|
||||
FROM (SELECT security_layer, COUNT(*) AS n FROM attacks
|
||||
WHERE security_layer IS NOT NULL
|
||||
GROUP BY security_layer
|
||||
HAVING COUNT(DISTINCT installation_id) >= 5) t
|
||||
), '[]'::jsonb),
|
||||
'verdict_distribution', COALESCE((
|
||||
SELECT jsonb_agg(jsonb_build_object('verdict', security_verdict, 'count', n) ORDER BY n DESC, security_verdict)
|
||||
FROM (SELECT security_verdict, COUNT(*) AS n FROM attacks
|
||||
WHERE security_verdict IS NOT NULL GROUP BY security_verdict) t
|
||||
), '[]'::jsonb)
|
||||
)
|
||||
);
|
||||
$$;
|
||||
|
||||
REVOKE EXECUTE ON FUNCTION community_pulse_summary() FROM PUBLIC, anon, authenticated;
|
||||
GRANT EXECUTE ON FUNCTION community_pulse_summary() TO service_role;
|
||||
@@ -0,0 +1,28 @@
|
||||
-- 007_drop_unused_installation_columns.sql
|
||||
-- The live installations table carries seven columns that no migration in
|
||||
-- this repo defines and no gstack code reads or writes: user_id, email,
|
||||
-- config_snapshot, analytics_snapshot, retro_history, last_backup_at and
|
||||
-- backup_version. On 2026-11-19 all seven were empty in all 37,566 rows.
|
||||
-- An email column has no place in a telemetry table (docs/privacy.md: no
|
||||
-- personal data), so drop them. The guard refuses if any row holds a value,
|
||||
-- so this can never delete data; it does nothing where the columns are absent.
|
||||
|
||||
DO $$
|
||||
DECLARE
|
||||
col text;
|
||||
filled bigint;
|
||||
BEGIN
|
||||
LOCK TABLE public.installations IN ACCESS EXCLUSIVE MODE;
|
||||
FOREACH col IN ARRAY ARRAY['user_id', 'email', 'config_snapshot', 'analytics_snapshot',
|
||||
'retro_history', 'last_backup_at', 'backup_version'] LOOP
|
||||
IF EXISTS (SELECT 1 FROM information_schema.columns
|
||||
WHERE table_schema = 'public' AND table_name = 'installations' AND column_name = col) THEN
|
||||
EXECUTE format('SELECT COUNT(*) FROM public.installations WHERE %I IS NOT NULL', col) INTO filled;
|
||||
IF filled > 0 THEN
|
||||
RAISE EXCEPTION 'installations.% holds % values; refusing to drop it', col, filled;
|
||||
END IF;
|
||||
EXECUTE format('ALTER TABLE public.installations DROP COLUMN %I', col);
|
||||
END IF;
|
||||
END LOOP;
|
||||
END
|
||||
$$;
|
||||
@@ -0,0 +1,42 @@
|
||||
-- 008_close_anon_writes.sql
|
||||
-- Closes the last direct write path. Since v0.11.16.0 every gstack client
|
||||
-- writes through the edge functions (telemetry-ingest, update-check); only
|
||||
-- older clients POST straight to the tables with the public key. The policies
|
||||
-- kept for them in 002 also let anyone write arbitrary rows: probes on
|
||||
-- 2026-11-16..19 added about 2,000 junk events and 500 fake installs.
|
||||
--
|
||||
-- What this drops: clients older than v0.11.16.0 (released 2026-03-24) stop
|
||||
-- landing. In the 30 days to 2026-11-19 that was 245 events from 23 installs
|
||||
-- and 163 update checks. Their sync keeps the batch and retries, so nothing
|
||||
-- breaks on their side; it just never arrives.
|
||||
--
|
||||
-- Deploy order: apply 004, 005, 006 and 007; deploy telemetry-ingest and
|
||||
-- community-pulse (the new ingest writes 004's and 006's columns, and the new
|
||||
-- pulse calls 006's function); confirm one ingest event lands; then apply
|
||||
-- this. Run earlier, it refuses every new event. Undo by re-granting anon's
|
||||
-- table privileges and recreating the policies this file drops (created in
|
||||
-- 001 and 003).
|
||||
|
||||
DROP POLICY IF EXISTS "anon_insert_only" ON telemetry_events;
|
||||
DROP POLICY IF EXISTS "anon_insert_only" ON installations;
|
||||
DROP POLICY IF EXISTS "anon_insert_only" ON update_checks;
|
||||
DROP POLICY IF EXISTS "anon_update_tracking" ON installations;
|
||||
DROP POLICY IF EXISTS "anon_update_last_seen" ON installations;
|
||||
|
||||
REVOKE ALL ON ALL TABLES IN SCHEMA public FROM anon;
|
||||
REVOKE ALL ON ALL SEQUENCES IN SCHEMA public FROM anon;
|
||||
REVOKE EXECUTE ON ALL FUNCTIONS IN SCHEMA public FROM anon;
|
||||
ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE ALL ON TABLES FROM anon;
|
||||
ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE ALL ON SEQUENCES FROM anon;
|
||||
ALTER DEFAULT PRIVILEGES IN SCHEMA public REVOKE EXECUTE ON FUNCTIONS FROM anon;
|
||||
|
||||
DO $$
|
||||
BEGIN
|
||||
ALTER DEFAULT PRIVILEGES FOR ROLE supabase_admin IN SCHEMA public REVOKE ALL ON TABLES FROM anon;
|
||||
ALTER DEFAULT PRIVILEGES FOR ROLE supabase_admin IN SCHEMA public REVOKE ALL ON SEQUENCES FROM anon;
|
||||
ALTER DEFAULT PRIVILEGES FOR ROLE supabase_admin IN SCHEMA public REVOKE EXECUTE ON FUNCTIONS FROM anon;
|
||||
EXCEPTION
|
||||
WHEN insufficient_privilege OR undefined_object THEN
|
||||
RAISE NOTICE 'supabase_admin default privileges unchanged (%): objects it creates later still grant anon', SQLERRM;
|
||||
END
|
||||
$$;
|
||||
+135
-105
@@ -1,14 +1,30 @@
|
||||
#!/usr/bin/env bash
|
||||
# verify-rls.sh — smoke test after deploying 002_tighten_rls.sql
|
||||
# verify-rls.sh — smoke test the telemetry project's access rules after
|
||||
# applying migrations 005-008.
|
||||
#
|
||||
# Verifies:
|
||||
# - SELECT denied on all tables and views (security fix)
|
||||
# - UPDATE denied on installations (security fix)
|
||||
# - INSERT still allowed on tables (kept for old client compat)
|
||||
# Verifies, for the public key (anon) and for a signed-in user
|
||||
# (a JWT whose role is `authenticated`):
|
||||
# - every table, view and the pulse function is unreadable
|
||||
# - no table accepts an INSERT or UPDATE (008 closed the legacy inserts;
|
||||
# every write now goes through the telemetry-ingest edge function)
|
||||
#
|
||||
# A check passes only on a permission denial (Postgres error 42501) in the
|
||||
# response body. A missing table or function fails, except community_benchmarks,
|
||||
# which may be absent (ABSENT). An invalid JWT, a constraint error or any other
|
||||
# response fails, so a wrong key or an unapplied migration cannot pass.
|
||||
#
|
||||
# Writes nothing: insert probes send an empty row, so a table that wrongly
|
||||
# accepts the insert still rejects the row on its NOT NULL columns, and the
|
||||
# check reports that as a failure.
|
||||
#
|
||||
# The signed-in checks need a user JWT. Set GSTACK_VERIFY_AUTH_JWT to one, or
|
||||
# SUPABASE_JWT_SECRET (Dashboard > Settings > JWT, legacy secret) to mint a
|
||||
# five-minute token for a random user id. Neither is ever printed. Without
|
||||
# either, the signed-in checks are skipped and the verdict is INCOMPLETE.
|
||||
#
|
||||
# Run manually after deploying the migration:
|
||||
# bash supabase/verify-rls.sh
|
||||
set -uo pipefail
|
||||
BASH_COMPAT=50
|
||||
|
||||
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
||||
. "$SCRIPT_DIR/config.sh"
|
||||
@@ -18,131 +34,145 @@ KEY="$GSTACK_SUPABASE_ANON_KEY"
|
||||
PASS=0
|
||||
FAIL=0
|
||||
TOTAL=0
|
||||
SKIPPED=0
|
||||
|
||||
# check <description> <expected> <method> <path> [data]
|
||||
# expected: "deny" (want 401/403) or "allow" (want 200/201)
|
||||
# check <role-label> <bearer> <description> <method> <path> [data]
|
||||
# Every check expects a permission denial, and decides from the response body:
|
||||
# - PASS only when the body carries Postgres error 42501 (permission denied).
|
||||
# - PGRST205 or PGRST202 (table or function not found) is ABSENT, which
|
||||
# counts as a pass for community_benchmarks only. For any other object it
|
||||
# is a FAIL: the migration that creates it is not applied.
|
||||
# - Anything else is a FAIL: data, an empty read, an update that matched no
|
||||
# row, an invalid JWT (401 PGRST301), a write stopped only by a constraint
|
||||
# (400 or 409), or a failed connection.
|
||||
check() {
|
||||
local desc="$1"
|
||||
local expected="$2"
|
||||
local method="$3"
|
||||
local path="$4"
|
||||
local data="${5:-}"
|
||||
local label="$1" bearer="$2" desc="$3" method="$4" path="$5" data="${6:-}"
|
||||
TOTAL=$(( TOTAL + 1 ))
|
||||
|
||||
local resp_file
|
||||
# Use mktemp strictly. Don't fall back to a predictable $$-based path —
|
||||
# that's a race/overwrite footgun on shared machines.
|
||||
resp_file="$(mktemp "${TMPDIR:-/tmp}/verify-rls-XXXXXX")" || {
|
||||
echo "verify-rls: mktemp failed, aborting" >&2
|
||||
return 1
|
||||
}
|
||||
local hdr_file
|
||||
hdr_file="$(mktemp "${TMPDIR:-/tmp}/verify-rls-hdr-XXXXXX")" || {
|
||||
rm -f "$resp_file"; echo "verify-rls: mktemp failed, aborting" >&2
|
||||
return 1
|
||||
}
|
||||
chmod 600 "$hdr_file" 2>/dev/null || true
|
||||
printf 'apikey: %s\nAuthorization: Bearer %s\nContent-Type: application/json\n' "$KEY" "$bearer" > "$hdr_file"
|
||||
|
||||
local http_code
|
||||
if [ "$method" = "GET" ]; then
|
||||
http_code="$(curl -s -o "$resp_file" -w '%{http_code}' --max-time 10 \
|
||||
"${URL}/rest/v1/${path}" \
|
||||
-H "apikey: ${KEY}" \
|
||||
-H "Authorization: Bearer ${KEY}" \
|
||||
-H "Content-Type: application/json" 2>/dev/null)" || http_code="000"
|
||||
elif [ "$method" = "POST" ]; then
|
||||
http_code="$(curl -s -o "$resp_file" -w '%{http_code}' --max-time 10 \
|
||||
-X POST "${URL}/rest/v1/${path}" \
|
||||
-H "apikey: ${KEY}" \
|
||||
-H "Authorization: Bearer ${KEY}" \
|
||||
-H "Content-Type: application/json" \
|
||||
-H "Prefer: return=minimal" \
|
||||
-d "$data" 2>/dev/null)" || http_code="000"
|
||||
elif [ "$method" = "PATCH" ]; then
|
||||
http_code="$(curl -s -o "$resp_file" -w '%{http_code}' --max-time 10 \
|
||||
-X PATCH "${URL}/rest/v1/${path}" \
|
||||
-H "apikey: ${KEY}" \
|
||||
-H "Authorization: Bearer ${KEY}" \
|
||||
-H "Content-Type: application/json" \
|
||||
-d "$data" 2>/dev/null)" || http_code="000"
|
||||
fi
|
||||
|
||||
# Trim to last 3 chars (the HTTP code) in case of concatenation
|
||||
case "$method" in
|
||||
GET) http_code="$(curl -s -o "$resp_file" -w '%{http_code}' --max-time 10 -H @"$hdr_file" \
|
||||
"${URL}/rest/v1/${path}" 2>/dev/null)" || http_code="000" ;;
|
||||
POST) http_code="$(curl -s -o "$resp_file" -w '%{http_code}' --max-time 10 -H @"$hdr_file" \
|
||||
-H "Prefer: return=minimal" -X POST "${URL}/rest/v1/${path}" -d "$data" 2>/dev/null)" || http_code="000" ;;
|
||||
PATCH) http_code="$(curl -s -o "$resp_file" -w '%{http_code}' --max-time 10 -H @"$hdr_file" \
|
||||
-X PATCH "${URL}/rest/v1/${path}" -d "$data" 2>/dev/null)" || http_code="000" ;;
|
||||
esac
|
||||
rm -f "$hdr_file" 2>/dev/null || true
|
||||
http_code="$(echo "$http_code" | grep -oE '[0-9]{3}$' || echo "000")"
|
||||
|
||||
if [ "$expected" = "deny" ]; then
|
||||
case "$http_code" in
|
||||
401|403)
|
||||
echo " PASS $desc (HTTP $http_code, denied)"
|
||||
PASS=$(( PASS + 1 )) ;;
|
||||
200|204)
|
||||
# For GETs: 200+empty means RLS filtering (pass). 200+data means leak (fail).
|
||||
# For PATCH: 204 means no rows matched — could be RLS or missing row.
|
||||
if [ "$method" = "GET" ]; then
|
||||
body="$(cat "$resp_file" 2>/dev/null || echo "")"
|
||||
if [ "$body" = "[]" ] || [ -z "$body" ]; then
|
||||
echo " PASS $desc (HTTP $http_code, empty — RLS filtering)"
|
||||
PASS=$(( PASS + 1 ))
|
||||
else
|
||||
echo " FAIL $desc (HTTP $http_code, got data!)"
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
fi
|
||||
else
|
||||
# PATCH 204 = no rows affected. RLS blocked the update or row doesn't exist.
|
||||
# Either way, the attacker can't modify data.
|
||||
echo " PASS $desc (HTTP $http_code, no rows affected)"
|
||||
PASS=$(( PASS + 1 ))
|
||||
fi ;;
|
||||
000)
|
||||
echo " WARN $desc (connection failed)"
|
||||
FAIL=$(( FAIL + 1 )) ;;
|
||||
*)
|
||||
echo " WARN $desc (HTTP $http_code — unexpected)"
|
||||
FAIL=$(( FAIL + 1 )) ;;
|
||||
esac
|
||||
elif [ "$expected" = "allow" ]; then
|
||||
case "$http_code" in
|
||||
200|201|204|409)
|
||||
# 409 = conflict (duplicate key) — INSERT policy works, row already exists
|
||||
echo " PASS $desc (HTTP $http_code, allowed as expected)"
|
||||
PASS=$(( PASS + 1 )) ;;
|
||||
401|403)
|
||||
echo " FAIL $desc (HTTP $http_code, denied — should be allowed)"
|
||||
FAIL=$(( FAIL + 1 )) ;;
|
||||
000)
|
||||
echo " WARN $desc (connection failed)"
|
||||
FAIL=$(( FAIL + 1 )) ;;
|
||||
*)
|
||||
echo " WARN $desc (HTTP $http_code — unexpected)"
|
||||
FAIL=$(( FAIL + 1 )) ;;
|
||||
esac
|
||||
fi
|
||||
|
||||
local body object
|
||||
body="$(cat "$resp_file" 2>/dev/null || echo "")"
|
||||
rm -f "$resp_file" 2>/dev/null || true
|
||||
object="${path%%\?*}"
|
||||
object="${object#rpc/}"
|
||||
|
||||
if [ "$http_code" = "000" ]; then
|
||||
echo " FAIL [$label] $desc (connection failed)"
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
elif [[ "$body" == *'"42501"'* ]]; then
|
||||
echo " PASS [$label] $desc (HTTP $http_code, permission denied)"
|
||||
PASS=$(( PASS + 1 ))
|
||||
elif [[ "$body" == *PGRST205* || "$body" == *PGRST202* ]]; then
|
||||
if [ "$object" = "community_benchmarks" ]; then
|
||||
echo " ABSENT [$label] $desc (HTTP $http_code, not present)"
|
||||
PASS=$(( PASS + 1 ))
|
||||
else
|
||||
echo " FAIL [$label] $desc (HTTP $http_code: $object not found; is its migration applied?)"
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
fi
|
||||
elif [[ "$body" == *PGRST301* ]]; then
|
||||
echo " FAIL [$label] $desc (HTTP $http_code: JWT rejected, so nothing was checked)"
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
elif [ "$http_code" = "200" ] || [ "$http_code" = "204" ] || [ "$http_code" = "201" ]; then
|
||||
if [ "$method" = "GET" ] && { [ "$body" = "[]" ] || [ -z "$body" ]; }; then
|
||||
echo " FAIL [$label] $desc (HTTP $http_code: readable, empty only because of row filtering)"
|
||||
elif [ "$method" = "PATCH" ]; then
|
||||
echo " FAIL [$label] $desc (HTTP $http_code: update permitted, no row matched)"
|
||||
else
|
||||
echo " FAIL [$label] $desc (HTTP $http_code: got data!)"
|
||||
fi
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
elif [ "$http_code" = "400" ] || [ "$http_code" = "409" ]; then
|
||||
echo " FAIL [$label] $desc (HTTP $http_code: write permitted, stopped only by a constraint)"
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
else
|
||||
echo " FAIL [$label] $desc (HTTP $http_code, not a permission denial)"
|
||||
FAIL=$(( FAIL + 1 ))
|
||||
fi
|
||||
}
|
||||
|
||||
echo "RLS Verification (after 002_tighten_rls.sql)"
|
||||
check_all() {
|
||||
local label="$1" bearer="$2"
|
||||
echo "Reads ($label):"
|
||||
for rel in telemetry_events installations update_checks community_pulse_cache community_benchmarks \
|
||||
crash_clusters telemetry_live_events; do
|
||||
check "$label" "$bearer" "SELECT $rel" GET "${rel}?select=*&limit=1"
|
||||
done
|
||||
check "$label" "$bearer" "SELECT skill_sequences" GET "skill_sequences?select=skill_a&limit=1"
|
||||
check "$label" "$bearer" "CALL community_pulse_summary" POST "rpc/community_pulse_summary" '{}'
|
||||
echo ""
|
||||
echo "Writes ($label):"
|
||||
for rel in telemetry_events installations update_checks; do
|
||||
check "$label" "$bearer" "INSERT $rel" POST "$rel" '{}'
|
||||
done
|
||||
check "$label" "$bearer" "UPDATE installations" PATCH "installations?installation_id=eq.verify_rls_none" '{"gstack_version":"x"}'
|
||||
echo ""
|
||||
}
|
||||
|
||||
mint_jwt() {
|
||||
[ -n "${SUPABASE_JWT_SECRET:-}" ] || return 1
|
||||
command -v python3 >/dev/null 2>&1 || { echo "verify-rls: python3 is needed to mint a JWT" >&2; return 1; }
|
||||
python3 - <<'PY'
|
||||
import base64, hashlib, hmac, json, os, time, uuid
|
||||
def b64(b): return base64.urlsafe_b64encode(b).rstrip(b"=").decode()
|
||||
now = int(time.time())
|
||||
head = b64(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
|
||||
body = b64(json.dumps({"role": "authenticated", "aud": "authenticated", "sub": str(uuid.uuid4()),
|
||||
"iat": now, "exp": now + 300}).encode())
|
||||
sig = hmac.new(os.environ["SUPABASE_JWT_SECRET"].encode(), f"{head}.{body}".encode(), hashlib.sha256).digest()
|
||||
print(f"{head}.{body}.{b64(sig)}")
|
||||
PY
|
||||
}
|
||||
|
||||
echo "Access verification (migrations 005-008)"
|
||||
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
|
||||
echo ""
|
||||
echo "Read denial (should be blocked):"
|
||||
check "SELECT telemetry_events" deny GET "telemetry_events?select=*&limit=1"
|
||||
check "SELECT installations" deny GET "installations?select=*&limit=1"
|
||||
check "SELECT update_checks" deny GET "update_checks?select=*&limit=1"
|
||||
check "SELECT crash_clusters" deny GET "crash_clusters?select=*&limit=1"
|
||||
check "SELECT skill_sequences" deny GET "skill_sequences?select=skill_a&limit=1"
|
||||
check_all "anon" "$KEY"
|
||||
|
||||
echo ""
|
||||
echo "Update denial (should be blocked):"
|
||||
check "UPDATE installations" deny PATCH "installations?installation_id=eq.test_verify_rls" '{"gstack_version":"hacked"}'
|
||||
USER_JWT="${GSTACK_VERIFY_AUTH_JWT:-}"
|
||||
[ -n "$USER_JWT" ] || USER_JWT="$(mint_jwt 2>/dev/null || true)"
|
||||
if [ -n "$USER_JWT" ]; then
|
||||
check_all "signed-in" "$USER_JWT"
|
||||
else
|
||||
echo "SKIP signed-in checks: set GSTACK_VERIFY_AUTH_JWT or SUPABASE_JWT_SECRET to run them"
|
||||
SKIPPED=1
|
||||
echo ""
|
||||
fi
|
||||
|
||||
echo ""
|
||||
echo "Insert allowed (kept for old client compat):"
|
||||
check "INSERT telemetry_events" allow POST "telemetry_events" '{"gstack_version":"verify_rls_test","os":"test","event_timestamp":"2026-01-01T00:00:00Z","outcome":"test"}'
|
||||
check "INSERT update_checks" allow POST "update_checks" '{"gstack_version":"verify_rls_test","os":"test"}'
|
||||
check "INSERT installations" allow POST "installations" '{"installation_id":"verify_rls_test"}'
|
||||
|
||||
echo ""
|
||||
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
|
||||
echo "Results: $PASS passed, $FAIL failed (of $TOTAL checks)"
|
||||
|
||||
if [ "$FAIL" -gt 0 ]; then
|
||||
echo "VERDICT: FAIL"
|
||||
exit 1
|
||||
elif [ "$SKIPPED" -gt 0 ]; then
|
||||
echo "VERDICT: INCOMPLETE — public-key checks passed; signed-in checks not run"
|
||||
exit 2
|
||||
else
|
||||
echo "VERDICT: PASS — reads/updates blocked, inserts allowed"
|
||||
echo "VERDICT: PASS — the public key and signed-in users can read and write nothing"
|
||||
exit 0
|
||||
fi
|
||||
@@ -50,6 +50,11 @@ for (const name of ['GBRAIN_DATABASE_URL', 'GBRAIN_DIRECT_DATABASE_URL', 'DATABA
|
||||
delete process.env[name];
|
||||
process.stderr.write(`test-setup: stripped inherited ${name}; tests must not reach a live gbrain\n`);
|
||||
}
|
||||
// Telemetry clients fall back to supabase/config.sh, the live project, when a
|
||||
// test leaves GSTACK_SUPABASE_URL unset; that is how about 554,000 test rows
|
||||
// reached it. With this set, config.sh yields no endpoint and nothing is sent.
|
||||
// test/telemetry-no-live-endpoint.test.ts holds the tripwire.
|
||||
process.env.GSTACK_TEST_BLOCK_LIVE_TELEMETRY = '1';
|
||||
// One fixture root per test process (GST-1695). TMPDIR (TMP and TEMP on Windows)
|
||||
// points at it, so os.tmpdir() here, and $TMPDIR in a child spawned through
|
||||
// node:child_process or with this process's env, put each fixture inside it; a
|
||||
|
||||
@@ -28,6 +28,7 @@ for (const variable of ['GSTACK_HOME', 'GSTACK_STATE_ROOT', 'GSTACK_STATE_DIR']
|
||||
...(process.env as Record<string, string>),
|
||||
HOME: home, GSTACK_HOME: '', GSTACK_STATE_ROOT: '', GSTACK_STATE_DIR: '', CLAUDE_PLUGIN_DATA: '',
|
||||
GSTACK_TEST_LEGACY_ROOT: '', [variable]: root,
|
||||
GSTACK_SUPABASE_URL: 'https://telemetry.fixture.invalid', GSTACK_SUPABASE_ANON_KEY: 'fixture-anon-key',
|
||||
};
|
||||
expect(resolveStateRoot(env)).toBe(root);
|
||||
const run = (cmd: string, args: string[], input?: string) =>
|
||||
|
||||
@@ -0,0 +1,96 @@
|
||||
/**
|
||||
* The telemetry backend in supabase/ matches what the client sends and keeps
|
||||
* the public key and signed-in users out. These are source checks: the edge
|
||||
* functions run on Deno in Supabase and the migrations on the live project,
|
||||
* neither of which the free suite can reach.
|
||||
*/
|
||||
import { describe, test, expect } from 'bun:test';
|
||||
import * as fs from 'fs';
|
||||
import * as path from 'path';
|
||||
|
||||
const ROOT = path.resolve(import.meta.dir, '..');
|
||||
const MIGRATIONS = path.join(ROOT, 'supabase', 'migrations');
|
||||
const INGEST = fs.readFileSync(path.join(ROOT, 'supabase', 'functions', 'telemetry-ingest', 'index.ts'), 'utf-8');
|
||||
|
||||
function emittedEventTypes(): Set<string> {
|
||||
const types = new Set<string>();
|
||||
const scan = (file: string) => {
|
||||
for (const m of fs.readFileSync(file, 'utf-8').matchAll(/--event-type['", ]+([a-z_]+)/g)) types.add(m[1]);
|
||||
};
|
||||
const walk = (dir: string, keep: (name: string) => boolean) => {
|
||||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||||
const p = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) { if (!['node_modules', 'test', 'dist'].includes(entry.name)) walk(p, keep); }
|
||||
else if (keep(entry.name)) scan(p);
|
||||
}
|
||||
};
|
||||
walk(path.join(ROOT, 'bin'), () => true);
|
||||
walk(path.join(ROOT, 'browse', 'src'), n => n.endsWith('.ts'));
|
||||
walk(ROOT, n => n.endsWith('.tmpl'));
|
||||
scan(path.join(ROOT, 'setup'));
|
||||
return types;
|
||||
}
|
||||
|
||||
describe('telemetry-ingest accepts what the client sends', () => {
|
||||
test('every event type the client emits is on the ingest allowlist', () => {
|
||||
const allow = new Set([...(INGEST.match(/const validTypes = \[([^\]]*)\]/)?.[1] ?? '').matchAll(/"([a-z_]+)"/g)].map(m => m[1]));
|
||||
const emitted = emittedEventTypes();
|
||||
expect(emitted.size).toBeGreaterThanOrEqual(6);
|
||||
expect([...emitted].filter(t => !allow.has(t))).toEqual([]);
|
||||
});
|
||||
|
||||
test('ingest stores source, so test and eval traffic stay separable', () => {
|
||||
expect(INGEST).toContain('source: normalizeSource(event.source)');
|
||||
});
|
||||
|
||||
test('ingest writes with the service role key, the only write path once 008 drops the anon policies', () => {
|
||||
expect(INGEST).toContain('Deno.env.get("SUPABASE_SERVICE_ROLE_KEY")');
|
||||
expect(INGEST).not.toContain('SUPABASE_ANON_KEY');
|
||||
});
|
||||
});
|
||||
|
||||
describe('migrations keep the public key and signed-in users out', () => {
|
||||
const files = fs.readdirSync(MIGRATIONS).filter(f => f.endsWith('.sql')).sort();
|
||||
const later = files.filter(f => Number(f.slice(0, 3)) >= 5);
|
||||
|
||||
test('every view, function or table created from 005 on is revoked from anon and authenticated', () => {
|
||||
const missing: string[] = [];
|
||||
for (const f of later) {
|
||||
const sql = fs.readFileSync(path.join(MIGRATIONS, f), 'utf-8');
|
||||
for (const m of sql.matchAll(/CREATE (?:OR REPLACE )?(VIEW|FUNCTION|TABLE)(?: IF NOT EXISTS)? (?:public\.)?([a-z_]+)/gi)) {
|
||||
const name = m[2];
|
||||
const revoke = new RegExp(`REVOKE [A-Z ]+ON (?:FUNCTION )?(?:public\\.)?${name}\\b[^;]*FROM [^;]*\\banon\\b[^;]*\\bauthenticated\\b`, 'i');
|
||||
if (!revoke.test(sql)) missing.push(`${f}: ${m[1]} ${name}`);
|
||||
}
|
||||
}
|
||||
expect(missing).toEqual([]);
|
||||
});
|
||||
|
||||
test('every view created from 005 on runs with the caller\'s privileges', () => {
|
||||
for (const f of later) {
|
||||
const sql = fs.readFileSync(path.join(MIGRATIONS, f), 'utf-8');
|
||||
for (const m of sql.matchAll(/CREATE (?:OR REPLACE )?VIEW ([a-z_]+)([^\n]*)/gi)) {
|
||||
expect(m[2], `${f}: ${m[1]}`).toContain('security_invoker = true');
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
test('the older views are switched to security_invoker and revoked from both roles', () => {
|
||||
const sql = fs.readFileSync(path.join(MIGRATIONS, '005_revoke_authenticated.sql'), 'utf-8');
|
||||
for (const view of ['crash_clusters', 'skill_sequences']) {
|
||||
expect(sql).toContain(`ALTER VIEW public.${view} SET (security_invoker = true);`);
|
||||
}
|
||||
expect(sql).toContain('REVOKE ALL ON public.crash_clusters, public.skill_sequences FROM anon, authenticated;');
|
||||
expect(sql).toContain('REVOKE ALL ON ALL TABLES IN SCHEMA public FROM authenticated;');
|
||||
});
|
||||
|
||||
test('no migration leaves an anon insert or update policy standing', () => {
|
||||
const created = new Set<string>();
|
||||
for (const f of files) {
|
||||
const sql = fs.readFileSync(path.join(MIGRATIONS, f), 'utf-8');
|
||||
for (const m of sql.matchAll(/CREATE POLICY "([^"]+)" ON ([a-z_]+)/g)) created.add(`${m[1]} ON ${m[2]}`);
|
||||
for (const m of sql.matchAll(/DROP POLICY IF EXISTS "([^"]+)" ON ([a-z_]+)/g)) created.delete(`${m[1]} ON ${m[2]}`);
|
||||
}
|
||||
expect([...created].filter(p => /^anon_(insert|update)/.test(p))).toEqual([]);
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,126 @@
|
||||
/**
|
||||
* Tests never reach the live telemetry project. Before v1.86.0.0 every run of
|
||||
* test/telemetry.test.ts posted fixture events to it, and
|
||||
* test/state-root-one-variable.test.ts still did until this file landed:
|
||||
* about 554,000 of the 1.34M skill_run rows there are test fixtures.
|
||||
*
|
||||
* The guard: test-setup.ts sets GSTACK_TEST_BLOCK_LIVE_TELEMETRY, and
|
||||
* supabase/config.sh (the fallback every telemetry client sources when
|
||||
* GSTACK_SUPABASE_URL is unset) then yields no endpoint.
|
||||
*/
|
||||
import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
|
||||
import { spawnSync } from 'child_process';
|
||||
import * as fs from 'fs';
|
||||
import * as os from 'os';
|
||||
import * as path from 'path';
|
||||
|
||||
const ROOT = path.resolve(import.meta.dir, '..');
|
||||
const BIN = path.join(ROOT, 'bin');
|
||||
const CONFIG = path.join(ROOT, 'supabase', 'config.sh');
|
||||
const LIVE_HOST = (fs.readFileSync(CONFIG, 'utf-8').match(/GSTACK_SUPABASE_URL="https:\/\/([^"/]+)"/) ?? [])[1];
|
||||
const CONFIG_CLIENTS = ['gstack-community-dashboard', 'gstack-security-dashboard', 'gstack-telemetry-sync', 'gstack-update-check'];
|
||||
|
||||
let tmp: string;
|
||||
let curlLog: string;
|
||||
|
||||
function run(args: string[], env: Record<string, string | undefined> = {}) {
|
||||
const merged: Record<string, string> = {};
|
||||
for (const [k, v] of Object.entries({ ...process.env, ...env })) if (v !== undefined) merged[k] = v;
|
||||
return spawnSync('bash', args, { cwd: ROOT, env: merged, encoding: 'utf-8', timeout: 20_000 });
|
||||
}
|
||||
|
||||
function curlCalls(): string[] {
|
||||
return fs.existsSync(curlLog) ? fs.readFileSync(curlLog, 'utf-8').split('\n').filter(Boolean) : [];
|
||||
}
|
||||
|
||||
beforeEach(() => {
|
||||
tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'gstack-no-live-'));
|
||||
curlLog = path.join(tmp, 'curl.log');
|
||||
fs.mkdirSync(path.join(tmp, 'bin'));
|
||||
fs.mkdirSync(path.join(tmp, 'state', 'analytics'), { recursive: true });
|
||||
fs.writeFileSync(path.join(tmp, 'bin', 'curl'), `#!/bin/sh\nprintf '%s ' "$@" >> "$GSTACK_TEST_CURL_LOG"\necho >> "$GSTACK_TEST_CURL_LOG"\nprintf '200'\n`, { mode: 0o755 });
|
||||
fs.writeFileSync(path.join(tmp, 'state', 'config.yaml'), 'telemetry: anonymous\n');
|
||||
fs.writeFileSync(
|
||||
path.join(tmp, 'state', 'analytics', 'skill-usage.jsonl'),
|
||||
'{"v":1,"ts":"2026-11-19T00:00:00Z","event_type":"skill_run","skill":"qa","session_id":"1-2","gstack_version":"1.0.0.0","os":"linux","outcome":"success"}\n',
|
||||
);
|
||||
});
|
||||
|
||||
afterEach(() => {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
function clientEnv(extra: Record<string, string | undefined> = {}) {
|
||||
return {
|
||||
GSTACK_HOME: path.join(tmp, 'state'), GSTACK_STATE_ROOT: undefined, GSTACK_STATE_DIR: undefined,
|
||||
HOME: path.join(tmp, 'home'), GSTACK_DIR: ROOT, GSTACK_TEST_CURL_LOG: curlLog,
|
||||
PATH: `${path.join(tmp, 'bin')}:${process.env.PATH ?? ''}`,
|
||||
GSTACK_SUPABASE_URL: undefined, GSTACK_SUPABASE_ANON_KEY: undefined,
|
||||
...extra,
|
||||
};
|
||||
}
|
||||
|
||||
describe('telemetry never reaches the live project from tests', () => {
|
||||
test('the test preload sets the guard', () => {
|
||||
expect(process.env.GSTACK_TEST_BLOCK_LIVE_TELEMETRY).toBe('1');
|
||||
expect(LIVE_HOST).toBeTruthy();
|
||||
});
|
||||
|
||||
test('config.sh yields no endpoint under the guard, and the live one without it', () => {
|
||||
const show = '. "$1"; printf "[%s][%s]" "$GSTACK_SUPABASE_URL" "${GSTACK_SUPABASE_ANON_KEY:+key}"';
|
||||
const guarded = run(['-c', show, 'x', CONFIG]);
|
||||
expect(guarded.status).toBe(0);
|
||||
expect(guarded.stdout).toBe('[][]');
|
||||
const unguarded = run(['-c', show, 'x', CONFIG], { GSTACK_TEST_BLOCK_LIVE_TELEMETRY: '' });
|
||||
expect(unguarded.stdout).toBe(`[https://${LIVE_HOST}][key]`);
|
||||
});
|
||||
|
||||
test('every client that reads config.sh reads it only as the fallback for an unset GSTACK_SUPABASE_URL', () => {
|
||||
for (const name of CONFIG_CLIENTS) {
|
||||
const src = fs.readFileSync(path.join(BIN, name), 'utf-8');
|
||||
expect(src, name).toContain('if [ -z "${GSTACK_SUPABASE_URL:-}" ] && [ -f "$GSTACK_DIR/supabase/config.sh" ]; then');
|
||||
}
|
||||
const sourcing = fs.readdirSync(BIN).filter(f => {
|
||||
const p = path.join(BIN, f);
|
||||
return fs.statSync(p).isFile() && fs.readFileSync(p, 'utf-8').includes('. "$GSTACK_DIR/supabase/config.sh"');
|
||||
});
|
||||
expect(sourcing.sort()).toEqual([...CONFIG_CLIENTS].sort());
|
||||
});
|
||||
|
||||
test('telemetry sync with telemetry on and no endpoint set sends nothing', () => {
|
||||
const r = run([path.join(BIN, 'gstack-telemetry-sync')], clientEnv());
|
||||
expect(r.status).toBe(0);
|
||||
expect(curlCalls()).toEqual([]);
|
||||
});
|
||||
|
||||
test('the community dashboard with no endpoint set sends nothing', () => {
|
||||
const r = run([path.join(BIN, 'gstack-community-dashboard')], clientEnv());
|
||||
expect(r.status).toBe(0);
|
||||
expect(r.stdout).toContain('Supabase not configured');
|
||||
expect(curlCalls()).toEqual([]);
|
||||
});
|
||||
|
||||
test('control: the curl stub does record a send to an explicit fixture endpoint', () => {
|
||||
const r = run([path.join(BIN, 'gstack-telemetry-sync')], clientEnv({
|
||||
GSTACK_SUPABASE_URL: 'https://telemetry.fixture.invalid', GSTACK_SUPABASE_ANON_KEY: 'fixture-anon-key',
|
||||
}));
|
||||
expect(r.status).toBe(0);
|
||||
const calls = curlCalls();
|
||||
expect(calls).toHaveLength(1);
|
||||
expect(calls[0]).toContain('https://telemetry.fixture.invalid/functions/v1/telemetry-ingest');
|
||||
});
|
||||
|
||||
test('no test file names the live project', () => {
|
||||
const offenders: string[] = [];
|
||||
const walk = (dir: string) => {
|
||||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||||
const p = path.join(dir, entry.name);
|
||||
if (entry.isDirectory()) { if (entry.name !== 'node_modules') walk(p); continue; }
|
||||
if (!/\.(ts|js|sh|json|jsonl)$/.test(entry.name)) continue;
|
||||
if (fs.readFileSync(p, 'utf-8').includes(LIVE_HOST!)) offenders.push(path.relative(ROOT, p));
|
||||
}
|
||||
};
|
||||
walk(path.join(ROOT, 'test'));
|
||||
expect(offenders).toEqual([]);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user