From e6a0a39a51a42d9e2c505de4f89c9252102e435f Mon Sep 17 00:00:00 2001 From: Maurice Date: Tue, 17 Nov 2026 20:45:46 +0100 Subject: [PATCH] fix(db): read plugin SQL the way the Postgres lexer does and refuse INTO and TEMP anywhere The guard ended a -- comment at LF only, while Postgres ends it at CR as well, so "select 1 --\rfrom public.users" hid a qualified name from the guard that Postgres then read, and with no args a second statement after the CR ran as TREK's role. It also only looked for INTO at the top level of a SELECT, so "(select ... into temp users)" made a temporary table that shadowed TREK's own users table on the pooled connection. The tokenizer now skips exactly what Postgres skips as whitespace, ends a line comment at CR or LF, and refuses any character the two read differently (other control characters, non-ASCII whitespace such as U+00A0, U+FEFF and U+2028, and the non-decimal and underscored numbers Postgres before 16 reads another way) instead of guessing. INTO is refused anywhere but after INSERT or MERGE, at any depth, and the words TEMP and TEMPORARY anywhere outside a string or quoted name. The guard tests carry both payloads and their variants; the Postgres lane runs them against the real database, proves a second statement in one text is refused by Postgres over the extended protocol, and that a temporary table never shadows TREK's or a plugin's tables. --- .../db/engine/postgres/plugin-sql-guard.ts | 118 ++++++++++++++---- server/tests/postgres/plugin-data.test.ts | 106 +++++++++++++++- .../engine/postgres/plugin-sql-guard.test.ts | 81 +++++++++++- 3 files changed, 279 insertions(+), 26 deletions(-) diff --git a/server/src/db/engine/postgres/plugin-sql-guard.ts b/server/src/db/engine/postgres/plugin-sql-guard.ts index 3077f368a..c78cccdfa 100644 --- a/server/src/db/engine/postgres/plugin-sql-guard.ts +++ b/server/src/db/engine/postgres/plugin-sql-guard.ts @@ -7,12 +7,26 @@ import { PLUGIN_SCHEMA_PREFIX } from './plugin-schema'; * TREK's tables at all. On Postgres its schema sits in TREK's database and * its statements run as TREK's role, which may read every table TREK has: a * role per plugin would need CREATEROLE, which TREK's role is not given. So - * the statement itself is held to what cannot leave the schema, before it - * runs, and the transaction it runs in names only that schema on its - * `search_path`, so an unqualified name finds nothing else. + * three layers keep it in, each enough on its own for what it covers: + * + * 1. This guard holds the statement to what cannot leave the schema, before + * it runs. + * 2. The store sends every statement on its own over the extended query + * protocol (`extended-query.ts`), which runs exactly one statement, so a + * second statement the guard missed is an error, never run. + * 3. The transaction puts the plugin's schema on the `search_path` with + * `pg_temp` explicitly last, and TREK's own pool connections put `pg_temp` + * last too (`session-search-path.ts`), so a temporary table never stands + * in for a table of TREK's or of the plugin's. * * The SQL is split into tokens the way Postgres's own lexer splits it (string - * and identifier quoting, comments, dollar signs), and refused when it holds: + * and identifier quoting, comments, dollar signs). Where JavaScript and the + * Postgres lexer would read a character differently, the guard refuses it + * instead of guessing: whitespace is exactly what Postgres skips (space, tab, + * CR, LF, form feed), a `--` comment ends at CR or LF as it does there, and + * any other control character, or whitespace past ASCII (U+00A0, U+FEFF, + * U+2028, ...), outside a string, a quoted name or a comment is refused. The + * SQL is refused when it holds: * * - a statement other than SELECT, INSERT, UPDATE, DELETE, MERGE, WITH, * VALUES, TABLE, TRUNCATE, REFRESH, or a CREATE, ALTER or DROP of a table, @@ -28,13 +42,16 @@ import { PLUGIN_SCHEMA_PREFIX } from './plugin-schema'; * `ts_rewrite`), reads or changes settings (`set_config`, * `current_setting`), reaches objects by a name in a string (`nextval`, * `setval`, the `reg*` casts), large objects (`lo_*`) or `dblink`; - * - a temporary table (`CREATE TEMP`, `SELECT ... INTO`), which would outlive - * the call on a pooled connection another plugin uses next, and - * `WITH RECURSIVE`, refused on SQLite too; + * - the words TEMP and TEMPORARY anywhere outside a string or a quoted name, + * and INTO anywhere but right after INSERT or MERGE, at any depth of + * parentheses: a temporary table outlives the call on a pooled connection, + * and `SELECT ... INTO` creates a table outside what CREATE is held to; + * - `WITH RECURSIVE`, refused on SQLite too; * - in an ALTER, a change of a table's schema, owner or tablespace; * - escape strings (`E'...'`), Unicode escapes (`U&'...'`), dollar-quoted - * strings and a number running straight into a name, whose reading - * differs between Postgres versions and settings. + * strings, hexadecimal, octal and binary numbers, digit separators (`1_000`) + * and a number running straight into a name, whose reading differs between + * Postgres versions and settings (before 16, Postgres reads `0x1F` as `0 AS x1F`). * * An alias that happens to share a schema's name (`auth.id` on a database * that has an `auth` schema) is refused too; the plugin renames the alias. @@ -142,6 +159,34 @@ const NAME_START = /[A-Za-z_\u0080- const NAME_PART = /[A-Za-z0-9_$\u0080-￿]/; /** The single-character punctuation and operator characters. */ const PUNCT = new Set([...'.,()[];+-*/<>=~!@#%^&|?']); +/** + * What the Postgres lexer skips as whitespace (`space` in scan.l). Vertical + * tab is whitespace only from Postgres 16 on, so it is refused instead. + */ +const WHITESPACE = new Set([' ', '\t', '\n', '\r', '\f']); +/** The keywords INTO may follow. Anywhere else it makes a table (`SELECT ... INTO`). */ +const INTO_AFTER = new Set(['insert', 'merge']); + +/** + * Whether JavaScript and the Postgres lexer read `ch` differently: a control + * character Postgres does not skip, or whitespace past ASCII, which + * JavaScript's `\s` skips and Postgres reads as part of a name. + */ +function divergent(ch: string): boolean { + if (WHITESPACE.has(ch)) return false; + const code = ch.charCodeAt(0); + return code < 0x20 || code === 0x7f || /\s/.test(ch); +} + +/** Refuses `ch` when {@link divergent}. */ +function refuseDivergent(ch: string): void { + if (divergent(ch)) { + const code = ch.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0'); + throw new PluginSqlRefused( + `the character U+${code} is read differently by Postgres; outside a string use plain spaces, tabs and newlines`, + ); + } +} /** `name` lower-cased the way Postgres folds an unquoted name: ASCII letters only. */ function fold(name: string): string { @@ -168,10 +213,12 @@ export function tokenize(sql: string): Token[] { const at = i; const c = sql[i]; const next = sql[i + 1]; - if (/\s/.test(c)) { + refuseDivergent(c); + if (WHITESPACE.has(c)) { i++; } else if (c === '-' && next === '-') { - while (i < n && sql[i] !== '\n') i++; + // Postgres ends a line comment at either newline character (`non_newline` in scan.l). + while (i < n && sql[i] !== '\n' && sql[i] !== '\r') i++; } else if (c === '/' && next === '*') { i = skipBlockComment(sql, i); } else if (c === "'") { @@ -191,7 +238,16 @@ export function tokenize(sql: string): Token[] { while (i < n && /[0-9]/.test(sql[i])) i++; tokens.push({ kind: 'param', at }); } else if (/[0-9]/.test(c) || (c === '.' && /[0-9]/.test(next ?? ''))) { + if (c === '0' && /[xXoObB]/.test(next ?? '')) { + throw new PluginSqlRefused( + 'hexadecimal, octal and binary numbers are not accepted: Postgres before 16 reads 0x1F as 0 AS x1F; write it in decimal', + ); + } i = skipNumber(sql, i); + if (sql[i] === '_') { + throw new PluginSqlRefused('digit separators (1_000) are not accepted: Postgres before 16 does not read them'); + } + if (i < n) refuseDivergent(sql[i]); if (i < n && NAME_PART.test(sql[i])) { throw new PluginSqlRefused('a number may not run straight into a name; put a space between them'); } @@ -203,7 +259,10 @@ export function tokenize(sql: string): Token[] { if ((c === 'u' || c === 'U') && next === '&' && (sql[i + 2] === "'" || sql[i + 2] === '"')) { throw new PluginSqlRefused('Unicode escapes (U&) are not accepted'); } - while (i < n && NAME_PART.test(sql[i])) i++; + while (i < n && NAME_PART.test(sql[i])) { + refuseDivergent(sql[i]); + i++; + } tokens.push({ kind: 'word', value: truncateName(fold(sql.slice(at, i))), quoted: false, at }); } else if (c === ':' && next === ':') { tokens.push({ kind: 'punct', value: '::', at }); @@ -253,13 +312,9 @@ function skipQuoted(sql: string, start: number, quote: string, what: string): nu throw new PluginSqlRefused(`${what} is not closed`); } -/** The index past a numeric constant starting at `start`: decimal, with a fraction and an exponent, or 0x/0o/0b. */ +/** The index past a decimal numeric constant starting at `start`, with a fraction and an exponent. */ function skipNumber(sql: string, start: number): number { - const rest = sql.slice(start); - const match = - /^0[xX][0-9a-fA-F_]+|^0[oO][0-7_]+|^0[bB][01_]+|^(?:[0-9][0-9_]*(?:\.[0-9_]*)?|\.[0-9][0-9_]*)(?:[eE][+-]?[0-9]+)?/.exec( - rest, - ); + const match = /^(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?/.exec(sql.slice(start)); return start + (match ? match[0].length : 1); } @@ -302,7 +357,6 @@ function describe(text: string, tokens: Token[]): PluginStatement { let depth = 0; let main: string | null = verb === 'with' ? null : verb; let returning = false; - let selectInto = false; let params = 0; let qualifies = false; for (const [index, token] of tokens.entries()) { @@ -314,17 +368,14 @@ function describe(text: string, tokens: Token[]): PluginStatement { const after = tokens[index + 1]; if (after?.kind === 'punct' && after.value === '.') qualifies = true; if (token.quoted) continue; - if (token.value === 'recursive') throw new PluginSqlRefused('WITH RECURSIVE is not allowed'); - if (token.value === 'tablespace') throw new PluginSqlRefused('a tablespace may not be named'); + checkKeyword(token.value, keyword(tokens[index - 1])); if (verb === 'alter' && (token.value === 'schema' || token.value === 'owner')) { throw new PluginSqlRefused(`an ALTER may not change the ${token.value}`); } if (depth !== 0) continue; if (main === null && VERBS.has(token.value)) main = token.value; if (token.value === 'returning') returning = true; - if (token.value === 'into' && main === 'select') selectInto = true; } - if (selectInto) throw new PluginSqlRefused('SELECT ... INTO is not allowed; use CREATE TABLE ... AS'); const reads = main !== null && READ_VERBS.has(main); const writesInside = tokens.some((t) => { @@ -355,6 +406,27 @@ function checkObject(verb: string, tokens: readonly Token[]): void { } } +/** + * Refuses an unquoted keyword that is never safe, at whatever depth of + * parentheses it sits: `previous` is the unquoted keyword before it, if any. + * TEMP and TEMPORARY make an object that outlives the call on a pooled + * connection. INTO anywhere but after INSERT or MERGE is `SELECT ... INTO`, + * which makes a table (a temporary one with TEMP) past what CREATE is held to; + * `(SELECT ... INTO t)` and `WITH x AS (...) SELECT ... INTO t` included. + */ +function checkKeyword(word: string, previous: string | null): void { + if (word === 'recursive') throw new PluginSqlRefused('WITH RECURSIVE is not allowed'); + if (word === 'tablespace') throw new PluginSqlRefused('a tablespace may not be named'); + if (word === 'temp' || word === 'temporary') { + throw new PluginSqlRefused( + `temporary objects are not allowed (${word.toUpperCase()}); quote a name spelled "${word}"`, + ); + } + if (word === 'into' && (previous === null || !INTO_AFTER.has(previous))) { + throw new PluginSqlRefused('SELECT ... INTO is not allowed; use CREATE TABLE ... AS'); + } +} + /** Refuses a name that reaches past the plugin's schema whatever qualifies it. */ function checkName(name: string): void { if (REFUSED_NAMES.has(name) || REFUSED_PREFIXES.some((p) => name.startsWith(p)) || XML_EXPORT.test(name)) { diff --git a/server/tests/postgres/plugin-data.test.ts b/server/tests/postgres/plugin-data.test.ts index 608b36eb1..8d70d35fb 100644 --- a/server/tests/postgres/plugin-data.test.ts +++ b/server/tests/postgres/plugin-data.test.ts @@ -1,5 +1,5 @@ /** - * PGPLUG-001..008 — a plugin's own data (`db:own`) on Postgres, against the + * PGPLUG-001..011 — a plugin's own data (`db:own`) on Postgres, against the * real app on the lane's database: each plugin gets a schema of its own and no * SQLite file, its SQL keeps the SQLite store's semantics (migrate once per * id, a script's statements committed one by one, an atomic tx, the row cap, @@ -8,6 +8,7 @@ * schema and nothing else. */ import { buildApp } from '../../src/bootstrap'; +import { extendedQuery } from '../../src/db/engine/postgres/extended-query'; import { PluginDataSlots, PostgresPluginDataStore } from '../../src/db/engine/postgres/plugin-data-store'; import { withRequestContext } from '../../src/nest/database/request-context'; import { PLUGIN_DATA, type PluginDataBackend } from '../../src/nest/plugins/host/plugin-data.backend'; @@ -17,6 +18,7 @@ import { MikroORM } from '@mikro-orm/core'; import type { AbstractSqlConnection } from '@mikro-orm/sql'; import type { INestApplication } from '@nestjs/common'; +import { CompiledQuery } from 'kysely'; import fs from 'node:fs'; import os from 'node:os'; import path from 'node:path'; @@ -231,4 +233,106 @@ describe('plugin data on Postgres', () => { expect(await pluginSchemas()).toContain('trek_plugin_pg_rpc'); closePluginDataDb('pg-rpc'); }); + + it("PGPLUG-009: the review's bypasses are refused before they run: SQL hidden behind a CR, and SELECT ... INTO TEMP", async () => { + const store = data.open('pg-bypass'); + await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text NOT NULL)'); + const reads = [ + 'select 1 --\rfrom public.users', + 'select 1 --x\rfrom public.users', + 'select 1 --\r, email, password_hash from public.users', + "(select 1 as id, 'admin' as role into temp users)", + "(select 99 as id, 'forged'::text as name into temp users)", + '((select 1 into t))', + '(select 1) into t', + 'select * from (select 1 into t) s', + 'select 1 from public.users', + ]; + await Promise.all(reads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin/))); + const scripts = [ + "select 1 --\r; reset search_path; update users set role = 'admin' where id = 1", + "insert into notes (body) values ('x') --x\r; update public.users set role = 1", + "select 1 --x\r; create function f() returns int language sql as 'select 1'", + "select 1 --\r; copy notes to program 'id'", + '(select 1 into temp t)', + 'select 1 into temporary t', + ]; + await Promise.all(scripts.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed for plugin/))); + + // Nothing hidden ran: no temporary table anywhere in the database, no function. The insert in front of the + // CR is a statement of its own, which a script commits before the next one is refused, as on SQLite. + const [{ temps, functions }] = await withRequestContext(orm, () => + orm.em + .getConnection() + .execute>( + "select (select count(*) from pg_class where relpersistence = 't') as temps, " + + "(select count(*) from pg_proc where proname = 'f') as functions", + [], + 'all', + ), + ); + expect({ temps, functions }).toEqual({ temps: 0, functions: 0 }); + expect(await store.query('SELECT body FROM notes')).toEqual([{ body: 'x' }]); + }); + + it('PGPLUG-010: a statement extendedQuery builds runs alone: a second one in its text is refused by Postgres, not run', async () => { + const store = data.open('pg-proto'); + await store.migrate('001', 'CREATE TABLE t (x int)'); + const client = (orm.em.getConnection() as AbstractSqlConnection).getClient(); + const two = 'insert into trek_plugin_pg_proto.t values (1); insert into trek_plugin_pg_proto.t values (2)'; + + // What a guard that let a second statement through would hand the pool: Postgres parses one statement only. + await expect(client.executeQuery(extendedQuery(two, []))).rejects.toThrow( + /cannot insert multiple commands into a prepared statement/, + ); + expect(await store.query('SELECT count(*) AS n FROM t')).toEqual([{ n: 0 }]); + // The same text without the marker goes over the simple protocol and runs both, which is what the marker prevents. + await client.executeQuery(CompiledQuery.raw(two, [])); + expect(await store.query('SELECT count(*) AS n FROM t')).toEqual([{ n: 2 }]); + + // A single statement runs and reports its rows, with or without args. + const one = await client.executeQuery(extendedQuery('delete from trek_plugin_pg_proto.t where x = $1', [1])); + expect(one.numAffectedRows).toBe(1n); + expect(await store.exec('DELETE FROM t')).toEqual({ changes: 0 }); + expect(await store.exec('INSERT INTO t VALUES (5)', [])).toEqual({ changes: 0 }); + expect(await store.tx([{ sql: 'INSERT INTO t VALUES (6)' }, { sql: 'DELETE FROM t' }])).toEqual({ + results: [{ changes: 1 }, { changes: 2 }], + }); + }); + + it("PGPLUG-011: pg_temp is searched last, so a temporary table never stands in for TREK's tables or a plugin's", async () => { + const [{ path, schema }] = await withRequestContext(orm, () => + orm.em + .getConnection() + .execute>( + "select current_setting('search_path') as path, current_schema() as schema", + [], + 'all', + ), + ); + expect(path).toMatch(/, pg_temp$/); + expect(schema).toBe('public'); + + const store = data.open('pg-shadow'); + await store.migrate('001', 'CREATE TABLE notes (body text)'); + await store.exec('INSERT INTO notes VALUES ($1)', ['real']); + const client = (orm.em.getConnection() as AbstractSqlConnection).getClient(); + // One pool connection holding temporary tables named like TREK's and the plugin's, as one left behind would. + await client.connection().execute(async (conn) => { + try { + await conn.executeQuery(CompiledQuery.raw("create temp table users as select 'forged'::text as email")); + await conn.executeQuery(CompiledQuery.raw("create temp table notes as select 'forged'::text as body")); + const resolved = await conn.executeQuery<{ ns: string }>( + CompiledQuery.raw( + "select relnamespace::regnamespace::text as ns from pg_class where oid = 'users'::regclass", + ), + ); + expect(resolved.rows).toEqual([{ ns: 'public' }]); + const onConnection = new PostgresPluginDataStore('pg-shadow', conn, new PluginDataSlots(1)); + expect(await onConnection.query('SELECT body FROM notes')).toEqual([{ body: 'real' }]); + } finally { + await conn.executeQuery(CompiledQuery.raw('drop table if exists pg_temp.users, pg_temp.notes')); + } + }); + }); }); diff --git a/server/tests/unit/db/engine/postgres/plugin-sql-guard.test.ts b/server/tests/unit/db/engine/postgres/plugin-sql-guard.test.ts index 80950aaa4..14826b68e 100644 --- a/server/tests/unit/db/engine/postgres/plugin-sql-guard.test.ts +++ b/server/tests/unit/db/engine/postgres/plugin-sql-guard.test.ts @@ -34,7 +34,7 @@ describe('plugin SQL guard', () => { 'VALUES (1), (2)', 'TABLE notes', '(SELECT 1) UNION (SELECT 2)', - 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text, temp real, schema text)', + 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text, "temp" real, schema text)', 'CREATE UNIQUE INDEX notes_body ON notes (body)', 'CREATE UNLOGGED TABLE cache (k text)', 'CREATE OR REPLACE VIEW v AS SELECT body FROM notes', @@ -50,8 +50,19 @@ describe('plugin SQL guard', () => { "SELECT 'public.users -- not code' AS text", 'SELECT 1 -- public.users\n', 'SELECT /* public.users */ 1', - 'SELECT 1.5e3, .5, 0x1F', + 'SELECT 1.5e3, .5, 1e-3, 10', 'INSERT INTO kv VALUES ($1, $2) ON CONFLICT (k) DO NOTHING', + // A line comment ends at CR as well as LF, as in Postgres; what follows is read as SQL. + 'SELECT 1 -- public.users\r', + 'SELECT 1 -- public.users\r\nFROM notes', + 'SELECT\t1\f', + // Characters JavaScript reads differently are fine inside strings, quoted names and comments. + "SELECT 'a b
c\u000bd'", + 'SELECT 1 AS "a b"', + 'SELECT 1 /*   */', + 'WITH gone AS (DELETE FROM notes RETURNING id) INSERT INTO trash SELECT id FROM gone', + 'MERGE INTO notes n USING incoming i ON n.id = i.id WHEN NOT MATCHED THEN INSERT (body) VALUES (i.body)', + 'SELECT body AS "into", "temporary" FROM notes', ])('lets through %s', (sql) => { expect(() => check(sql)).not.toThrow(); }); @@ -114,11 +125,75 @@ describe('plugin SQL guard', () => { ['SELECT ""', /a quoted name may not be empty/], ['SELECT `x`', /unexpected character/], ['SELECT 1; SELECT * FROM public.users', /another schema/], + ['SELECT 1 FROM notes INTO TEMP copy', /SELECT \.\.\. INTO/], + ['SELECT * FROM notes WHERE temp > 1', /TEMP/], + ['SELECT 0x1F', /hexadecimal/], + ['SELECT 0o17, 0b1', /hexadecimal/], + ['SELECT 1_000', /digit separators/], ])('refuses %s', (sql, reason) => { expect(() => check(sql)).toThrow(PluginSqlRefused); expect(() => check(sql)).toThrow(reason); }); + // The two bypasses of the final review, with their variants: each was let through, and Postgres ran it. + it.each([ + // A `--` comment ended by a bare CR hid the rest from the guard, which Postgres then ran. + ['select 1 --\rfrom public.users', /another schema/], + ['select 1 --x\rfrom public.users', /another schema/], + ['select 1 --\r, email, password_hash from public.users', /another schema/], + ["select 1 --\r; reset search_path; update users set role='admin'", /may not start with RESET/], + ['select 1 --\r; create function f() returns int', /CREATE FUNCTION is not allowed/], + ['insert into notes (body) values (1) --x\r; update public.users set role = 1', /another schema/], + ['select 1 -- x\r\u000b; select 1', /U\+000B/], + // A parenthesized SELECT ... INTO, at any depth, made a temporary table that shadowed TREK's own. + ["(select 1 as id, 'admin' as role into temp users)", /TEMP|SELECT \.\.\. INTO/], + ["(select 99 as id, 'forged'::text as name into temp users)", /TEMP|SELECT \.\.\. INTO/], + ['(select 1 into temp t)', /TEMP|SELECT \.\.\. INTO/], + ['((select 1 into t))', /SELECT \.\.\. INTO/], + ['(select 1) into t', /SELECT \.\.\. INTO/], + ['(select 1 into trek_r_tmp_x)', /SELECT \.\.\. INTO/], + ['select * from (select 1 into t) s', /SELECT \.\.\. INTO/], + ['WITH x AS (SELECT 1) SELECT * INTO t FROM x', /SELECT \.\.\. INTO/], + ['WITH x AS (SELECT 1 INTO t) SELECT 1', /SELECT \.\.\. INTO/], + ['VALUES (1) INTO t', /SELECT \.\.\. INTO/], + ['TABLE notes INTO t', /SELECT \.\.\. INTO/], + ['select 1 into temporary t', /TEMPORARY|SELECT \.\.\. INTO/], + ['select 1 into unlogged t', /SELECT \.\.\. INTO/], + ['CREATE TABLE t AS SELECT 1 INTO u', /SELECT \.\.\. INTO/], + ['CREATE GLOBAL TEMP TABLE t (x int)', /CREATE GLOBAL is not allowed|TEMP/], + ['CREATE LOCAL TEMPORARY TABLE t (x int)', /CREATE LOCAL is not allowed|TEMPORARY/], + ['CREATE TEMP VIEW v AS SELECT 1', /CREATE TEMP is not allowed/], + ['CREATE OR REPLACE TEMP VIEW v AS SELECT 1', /CREATE TEMP is not allowed/], + ['CREATE TEMPORARY SEQUENCE s', /CREATE TEMPORARY is not allowed/], + ['select temp from notes', /TEMP/], + ['select 1 from notes as temporary', /TEMPORARY/], + ])('refuses the bypass %j', (sql, reason) => { + expect(() => check(sql)).toThrow(PluginSqlRefused); + expect(() => check(sql)).toThrow(reason); + }); + + it.each([ + ['NO-BREAK SPACE', ' ', 'U+00A0'], + ['BYTE ORDER MARK', '', 'U+FEFF'], + ['LINE SEPARATOR', '
', 'U+2028'], + ['PARAGRAPH SEPARATOR', '
', 'U+2029'], + ['IDEOGRAPHIC SPACE', ' ', 'U+3000'], + ['vertical tab', '\u000b', 'U+000B'], + ['NUL', '\u0000', 'U+0000'], + ['escape', '\u001b', 'U+001B'], + ['DEL', '\u007f', 'U+007F'], + ])('refuses a %s outside a string, which JavaScript and Postgres read differently', (_name, ch, code) => { + for (const sql of [ + `SELECT 1${ch}FROM public.users`, + `SELECT x${ch}FROM notes`, + `${ch}SELECT 1`, + `SELECT public${ch}.users`, + ]) { + expect(() => check(sql), JSON.stringify(sql)).toThrow(PluginSqlRefused); + expect(() => check(sql), JSON.stringify(sql)).toThrow(code); + } + }); + it('reads nested block comments as Postgres does, so code after the inner close is still a comment', () => { expect(() => check('SELECT 1 /* outer /* inner */ public.users */')).not.toThrow(); expect(() => check('SELECT 1 /* one */ FROM public.users')).toThrow(/another schema/); @@ -140,6 +215,8 @@ describe('plugin SQL guard', () => { const statements = parsePluginSql("CREATE TABLE a (x text);;\n-- note\nINSERT INTO a VALUES ('a;b');"); expect(statements.map((s) => s.text)).toEqual(['CREATE TABLE a (x text)', "INSERT INTO a VALUES ('a;b')"]); expect(parsePluginSql('-- nothing\n;')).toEqual([]); + // What follows a CR is a statement of its own, as Postgres reads it, and is checked like any other. + expect(parsePluginSql('select 1 --x\r; select 42').map((s) => s.text)).toEqual(['select 1 --x', 'select 42']); }); it('says whether a statement returns rows, may write, qualifies a name and how many placeholders it has', () => {