mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-22 13:10:29 +00:00
fix(db): hold plugin SQL on Postgres in layers the database enforces
The token guard kept leaking: on a superuser connection an unqualified `alter type int4 rename to int4x` renamed pg_catalog's type for the whole server, sequences and catalog-only objects grew the database past the quota, regtype/regconfig/regdictionary looked TREK's objects up by name, and a column alias named insert or merge in front of INTO made a table. Instead of a longer word list, the store now asks the database: - No plugin SQL while TREK's role is privileged in the sense of the restore check (PRIVILEGED_ROLE_SQL, imported from server-checks.ts): every db:own call fails with PRIVILEGED_ROLE_PLUGIN_REFUSAL, read once per pool connection, and the boot log says why. - The objects an ALTER, DROP, REFRESH, TRUNCATE or CREATE INDEX ... ON changes, and the tables a CREATE or ALTER TABLE ties to its own, are resolved with to_regclass/to_regtype in the transaction right before the statement, and it is refused unless each one found lies in the plugin's schema. An unqualified int4, text or box is pg_catalog's and refused even with the role check off. - The quota counts every relation of the schema with its TOAST table, and a schema holds at most PLUGIN_SCHEMA_MAX_OBJECTS catalog objects (relations, types, constraints, enum labels). - The guard refuses every reg* type and its array in every spelling, the has_*_privilege functions, currtid2 and the BRIN/GIN maintenance functions; INTO only after the INSERT or MERGE that is the statement's verb or a WITH body's; TEMP only where it makes a temporary object (CREATE TEMP/TEMPORARY, SELECT ... INTO TEMP), so a column named temp works again; a base type; and a NUL anywhere in the SQL text. - A bound value or a migration id holding NUL is refused with the reason instead of being stripped, so the plugin's keys never change meaning. Every bypass from the re-review is a test on the real database, on the role the plugin data is meant to run as and on a superuser connection with the role check off.
This commit is contained in:
@@ -1,5 +1,5 @@
|
||||
/**
|
||||
* PGPLUG-001..012 — a plugin's own data (`db:own`) on Postgres, against the
|
||||
* PGPLUG-001..020 — 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,
|
||||
@@ -7,8 +7,16 @@
|
||||
* plugin's schema however it spells the name, every statement runs alone,
|
||||
* the pool client a call used goes back without anything the call set, and
|
||||
* erasing a plugin drops its schema and nothing else.
|
||||
*
|
||||
* The lane connects as a superuser, which is exactly the role plugin SQL is
|
||||
* refused for (PGPLUG-013). So the stores here run as a role of the test's
|
||||
* own that may only create schemas in the database, the role TREK is meant
|
||||
* to run as, and the layers behind the role check are also shown to hold on
|
||||
* the superuser connection with that check switched off (PGPLUG-014 to 020).
|
||||
*/
|
||||
import type { DbSettings } from '../../src/app-config';
|
||||
import { buildApp } from '../../src/bootstrap';
|
||||
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL, type PluginRoleGate } from '../../src/db/engine/postgres/plugin-data-checks';
|
||||
import {
|
||||
type ConnectPluginClient,
|
||||
PluginDataSlots,
|
||||
@@ -16,62 +24,147 @@ import {
|
||||
poolClients,
|
||||
PostgresPluginDataStore,
|
||||
} from '../../src/db/engine/postgres/plugin-data-store';
|
||||
import { TrekPostgreSqlDriver } from '../../src/db/engine/postgres/postgres-driver';
|
||||
import { putTempSchemaLast } from '../../src/db/engine/postgres/session-search-path';
|
||||
import { DATABASE_SETTINGS } from '../../src/nest/database/database-engine.module';
|
||||
import { withRequestContext } from '../../src/nest/database/request-context';
|
||||
import { PLUGIN_DATA, type PluginDataBackend } from '../../src/nest/plugins/host/plugin-data.backend';
|
||||
import {
|
||||
PLUGIN_DATA,
|
||||
PostgresPluginDataBackend,
|
||||
type PluginDataBackend,
|
||||
} from '../../src/nest/plugins/host/plugin-data.backend';
|
||||
import { closePluginDataDb } from '../../src/nest/plugins/host/plugin-host-state';
|
||||
import { PluginRpcHostFactory } from '../../src/nest/plugins/host/plugin-rpc-host.factory';
|
||||
import { withAdmin } from './databases';
|
||||
import { MikroORM } from '@mikro-orm/core';
|
||||
import type { INestApplication } from '@nestjs/common';
|
||||
|
||||
import type { DatabaseConnection } from 'kysely';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import Cursor from 'pg-cursor';
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||||
|
||||
/** The roles this file creates: cluster-wide, so named after the worker and the process. */
|
||||
const ROLE = `trek_plugin_lane_${process.env.VITEST_POOL_ID ?? '0'}_${process.pid}`;
|
||||
const FILE_ROLE = `${ROLE}_files`;
|
||||
const PASSWORD = 'lane-plugin-role';
|
||||
|
||||
let app: INestApplication;
|
||||
let orm: MikroORM;
|
||||
let data: PluginDataBackend;
|
||||
/** The app's own backend, on the lane's superuser connection. */
|
||||
let superData: PluginDataBackend;
|
||||
/** A backend like the app's, on a pool connected as {@link ROLE}. */
|
||||
let data: PostgresPluginDataBackend;
|
||||
let roleOrm: MikroORM;
|
||||
let fileRoleOrm: MikroORM;
|
||||
let dataDir: string;
|
||||
|
||||
/** The lane's URL for this file's database, as the superuser. */
|
||||
function superUrl(): string {
|
||||
return process.env.TREK_DB_URL as string;
|
||||
}
|
||||
|
||||
/** An ORM on this file's database as `role`, built as the app builds its own (TREK's driver, `pg_temp` last). */
|
||||
async function ormAs(role: string): Promise<MikroORM> {
|
||||
const url = new URL(superUrl());
|
||||
url.username = role;
|
||||
url.password = PASSWORD;
|
||||
return MikroORM.init({
|
||||
driver: TrekPostgreSqlDriver,
|
||||
clientUrl: url.toString(),
|
||||
entities: [],
|
||||
discovery: { warnWhenNoEntities: false },
|
||||
pool: { min: 0, max: 4 },
|
||||
onCreateConnection: (connection: unknown) => putTempSchemaLast(connection as DatabaseConnection),
|
||||
});
|
||||
}
|
||||
|
||||
beforeAll(async () => {
|
||||
dataDir = fs.mkdtempSync(path.join(os.tmpdir(), 'trek-pg-plugin-data-'));
|
||||
process.env.TREK_PLUGINS_DATA_DIR = dataDir;
|
||||
app = await buildApp();
|
||||
orm = app.get(MikroORM);
|
||||
data = app.get<PluginDataBackend>(PLUGIN_DATA, { strict: false });
|
||||
superData = app.get<PluginDataBackend>(PLUGIN_DATA, { strict: false });
|
||||
const database = new URL(superUrl()).pathname.slice(1);
|
||||
await withAdmin(superUrl(), (run) =>
|
||||
inSequence(
|
||||
[
|
||||
...[ROLE, FILE_ROLE].flatMap((role) => [
|
||||
`create role "${role}" login password '${PASSWORD}'`,
|
||||
`grant create on database "${database}" to "${role}"`,
|
||||
]),
|
||||
// Reading server files is one of the privileges the role check counts.
|
||||
`grant pg_read_server_files to "${FILE_ROLE}"`,
|
||||
],
|
||||
(sql) => run(sql),
|
||||
),
|
||||
);
|
||||
roleOrm = await ormAs(ROLE);
|
||||
fileRoleOrm = await ormAs(FILE_ROLE);
|
||||
data = new PostgresPluginDataBackend(roleOrm, app.get<DbSettings>(DATABASE_SETTINGS, { strict: false }));
|
||||
}, 60_000);
|
||||
|
||||
afterAll(async () => {
|
||||
await roleOrm?.close(true);
|
||||
await fileRoleOrm?.close(true);
|
||||
await app?.close();
|
||||
await withAdmin(superUrl(), (run) =>
|
||||
inSequence(
|
||||
[ROLE, FILE_ROLE].flatMap((role) => [`drop owned by "${role}" cascade`, `drop role "${role}"`]),
|
||||
(sql) => run(sql),
|
||||
),
|
||||
);
|
||||
delete process.env.TREK_PLUGINS_DATA_DIR;
|
||||
fs.rmSync(dataDir, { recursive: true, force: true });
|
||||
});
|
||||
}, 60_000);
|
||||
|
||||
/** `work` for each item, one after the other. */
|
||||
async function inSequence<T>(items: readonly T[], work: (item: T) => Promise<unknown>): Promise<void> {
|
||||
await items.reduce<Promise<unknown>>((previous, item) => previous.then(() => work(item)), Promise.resolve());
|
||||
}
|
||||
|
||||
/** Runs `sql` as the superuser, outside any plugin store. */
|
||||
async function asSuper<T>(sql: string): Promise<T[]> {
|
||||
return withRequestContext(orm, () => orm.em.getConnection().execute<T[]>(sql, [], 'all'));
|
||||
}
|
||||
|
||||
/** The plugin schemas the database holds now. */
|
||||
async function pluginSchemas(): Promise<string[]> {
|
||||
const rows = await withRequestContext(orm, () =>
|
||||
orm.em
|
||||
.getConnection()
|
||||
.execute<Array<{ nspname: string }>>(
|
||||
"select nspname from pg_namespace where starts_with(nspname, 'trek_plugin_') order by nspname",
|
||||
[],
|
||||
'all',
|
||||
),
|
||||
const rows = await asSuper<{ nspname: string }>(
|
||||
"select nspname from pg_namespace where starts_with(nspname, 'trek_plugin_') order by nspname",
|
||||
);
|
||||
return rows.map((row) => row.nspname);
|
||||
}
|
||||
|
||||
/** Clients of the app's pool, as the backend hands them to a store. */
|
||||
/** Clients of the pool connected as {@link ROLE}, as the backend hands them to a store. */
|
||||
function appClients(): ConnectPluginClient {
|
||||
return poolClients(orm.em.getConnection());
|
||||
return poolClients(roleOrm.em.getConnection());
|
||||
}
|
||||
|
||||
/** A store on the app's pool with limits small enough to reach in a test. */
|
||||
function cappedStore(id: string, limits: { maxRows?: number; timeBudgetMs?: number; quotaBytes?: number }) {
|
||||
/** A store as {@link ROLE} with limits small enough to reach in a test. */
|
||||
function cappedStore(
|
||||
id: string,
|
||||
limits: { maxRows?: number; timeBudgetMs?: number; quotaBytes?: number; maxObjects?: number },
|
||||
) {
|
||||
return new PostgresPluginDataStore(id, appClients(), new PluginDataSlots(1), limits);
|
||||
}
|
||||
|
||||
/** No role check: what the layers behind it hold on their own. */
|
||||
const NO_ROLE_CHECK: PluginRoleGate = { refuseIfPrivileged: async () => undefined };
|
||||
|
||||
/** A store on the lane's superuser connection with the role check switched off. */
|
||||
function superuserStore(id: string, limits: { quotaBytes?: number; maxObjects?: number } = {}) {
|
||||
return new PostgresPluginDataStore(
|
||||
id,
|
||||
poolClients(orm.em.getConnection()),
|
||||
new PluginDataSlots(1),
|
||||
limits,
|
||||
NO_ROLE_CHECK,
|
||||
);
|
||||
}
|
||||
|
||||
/** `client` for every call of a store, kept checked out by the test: a release only records whether it would close it. */
|
||||
function keep(client: PluginSqlClient, released: boolean[] = []): ConnectPluginClient {
|
||||
return async () =>
|
||||
@@ -106,6 +199,15 @@ function smuggling(swap: Record<string, string>): ConnectPluginClient {
|
||||
};
|
||||
}
|
||||
|
||||
/** Whether the catalog type `name` still exists under that name. */
|
||||
async function catalogType(name: string): Promise<boolean> {
|
||||
const rows = await asSuper<{ n: number }>(
|
||||
`select count(*) as n from pg_type t join pg_namespace n on n.oid = t.typnamespace ` +
|
||||
`where n.nspname = 'pg_catalog' and t.typname = '${name}'`,
|
||||
);
|
||||
return Number(rows[0].n) === 1;
|
||||
}
|
||||
|
||||
describe('plugin data on Postgres', () => {
|
||||
it('PGPLUG-001: a plugin gets a schema of its own, migrates once per id, reads and writes there, and no SQLite file', async () => {
|
||||
const store = data.open('pg-alpha');
|
||||
@@ -191,9 +293,7 @@ describe('plugin data on Postgres', () => {
|
||||
].map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed/)),
|
||||
);
|
||||
// Nothing of TREK's was touched along the way.
|
||||
const [{ n }] = await withRequestContext(orm, () =>
|
||||
orm.em.getConnection().execute<Array<{ n: number }>>('select count(*) as n from users', [], 'all'),
|
||||
);
|
||||
const [{ n }] = await asSuper<{ n: number }>('select count(*) as n from users');
|
||||
expect(n).toBeGreaterThanOrEqual(0);
|
||||
});
|
||||
|
||||
@@ -256,24 +356,21 @@ describe('plugin data on Postgres', () => {
|
||||
await expect(data.erase('Not_An_Id')).resolves.toBeUndefined();
|
||||
});
|
||||
|
||||
it('PGPLUG-008: through the RPC host, db.* reaches the plugin schema and db.engine says postgres', async () => {
|
||||
it('PGPLUG-008: through the RPC host, db.engine says postgres and db.* answers the role refusal on a superuser', async () => {
|
||||
const router = { callPlugin: async () => undefined, emitPluginEvent: async () => {} };
|
||||
const host = app.get(PluginRpcHostFactory).create('pg-rpc', new Set(['db:own']), router);
|
||||
const call = (method: string, params: Record<string, unknown>) =>
|
||||
host.dispatch({ k: 'req', id: method, method, params });
|
||||
|
||||
expect(await call('db.engine', {})).toMatchObject({ ok: true, result: { engine: 'postgres' } });
|
||||
expect(await call('db.migrate', { id: '001', sql: 'CREATE TABLE t (v text)' })).toMatchObject({ ok: true });
|
||||
expect(await call('db.exec', { sql: 'INSERT INTO t VALUES ($1)', args: ['x'] })).toMatchObject({
|
||||
ok: true,
|
||||
result: { changes: 1 },
|
||||
});
|
||||
expect(await call('db.query', { sql: 'SELECT v FROM t' })).toMatchObject({ ok: true, result: [{ v: 'x' }] });
|
||||
expect(await call('db.query', { sql: 'SELECT email FROM public.users' })).toMatchObject({
|
||||
ok: false,
|
||||
error: { code: 'HOST_ERROR' },
|
||||
});
|
||||
expect(await pluginSchemas()).toContain('trek_plugin_pg_rpc');
|
||||
const answers = await Promise.all([
|
||||
call('db.migrate', { id: '001', sql: 'CREATE TABLE t (v text)' }),
|
||||
call('db.exec', { sql: 'INSERT INTO t VALUES ($1)', args: ['x'] }),
|
||||
call('db.query', { sql: 'SELECT 1' }),
|
||||
]);
|
||||
const refused = { ok: false, error: { code: 'HOST_ERROR', message: PRIVILEGED_ROLE_PLUGIN_REFUSAL } };
|
||||
expect(answers).toMatchObject([refused, refused, refused]);
|
||||
expect(await pluginSchemas()).not.toContain('trek_plugin_pg_rpc');
|
||||
closePluginDataDb('pg-rpc');
|
||||
});
|
||||
|
||||
@@ -289,7 +386,7 @@ describe('plugin data on Postgres', () => {
|
||||
'((select 1 into t))',
|
||||
'(select 1) into t',
|
||||
'select * from (select 1 into t) s',
|
||||
'select 1 from public.users',
|
||||
'select 1 from public.users',
|
||||
];
|
||||
await Promise.all(reads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/not allowed for plugin/)));
|
||||
const scripts = [
|
||||
@@ -304,15 +401,9 @@ describe('plugin data on Postgres', () => {
|
||||
|
||||
// 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<Array<{ temps: number; functions: number }>>(
|
||||
"select (select count(*) from pg_class where relpersistence = 't') as temps, " +
|
||||
"(select count(*) from pg_proc where proname = 'f') as functions",
|
||||
[],
|
||||
'all',
|
||||
),
|
||||
const [{ temps, functions }] = await asSuper<{ temps: number; functions: number }>(
|
||||
"select (select count(*) from pg_class where relpersistence = 't') as temps, " +
|
||||
"(select count(*) from pg_proc where proname = 'f') as functions",
|
||||
);
|
||||
expect({ temps, functions }).toEqual({ temps: 0, functions: 0 });
|
||||
expect(await store.query('SELECT body FROM notes')).toEqual([{ body: 'x' }]);
|
||||
@@ -356,16 +447,10 @@ describe('plugin data on Postgres', () => {
|
||||
});
|
||||
|
||||
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<Array<{ path: string; schema: string }>>(
|
||||
"select current_setting('search_path') as path, current_schema() as schema",
|
||||
[],
|
||||
'all',
|
||||
),
|
||||
const [{ path: searchPath, schema }] = await asSuper<{ path: string; schema: string }>(
|
||||
"select current_setting('search_path') as path, current_schema() as schema",
|
||||
);
|
||||
expect(path).toMatch(/, pg_temp$/);
|
||||
expect(searchPath).toMatch(/, pg_temp$/);
|
||||
expect(schema).toBe('public');
|
||||
|
||||
const store = data.open('pg-shadow');
|
||||
@@ -379,6 +464,8 @@ describe('plugin data on Postgres', () => {
|
||||
const released: boolean[] = [];
|
||||
const onClient = new PostgresPluginDataStore('pg-shadow', keep(client, released), new PluginDataSlots(1));
|
||||
expect(await onClient.query('SELECT body FROM notes')).toEqual([{ body: 'real' }]);
|
||||
// Nor can the plugin reach them, or change them, by naming the temporary schema.
|
||||
await expect(onClient.query('SELECT body FROM pg_temp.notes')).rejects.toThrow(/"pg_temp" may not be named/);
|
||||
// The call dropped them with the rest of the session's state before it gave the client back.
|
||||
const temps = await client.query(
|
||||
"select count(*)::int as n from pg_class where relpersistence = 't' and relnamespace = pg_my_temp_schema()",
|
||||
@@ -416,4 +503,188 @@ describe('plugin data on Postgres', () => {
|
||||
client.release();
|
||||
}
|
||||
});
|
||||
|
||||
it('PGPLUG-013: on a privileged role every db:own call is refused with the reason, before anything is created', async () => {
|
||||
// The lane's own connection is a superuser: the app's backend refuses it.
|
||||
const store = superData.open('pg-privileged');
|
||||
await Promise.all(
|
||||
[
|
||||
store.migrate('001', 'CREATE TABLE t (x int)'),
|
||||
store.exec('CREATE TABLE t (x int)'),
|
||||
store.query('SELECT 1'),
|
||||
store.tx([{ sql: 'SELECT 1' }]),
|
||||
].map((call) => expect(call).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL)),
|
||||
);
|
||||
// A role that may read the server's files is refused as well.
|
||||
const settings = app.get<DbSettings>(DATABASE_SETTINGS, { strict: false });
|
||||
const files = new PostgresPluginDataBackend(fileRoleOrm, settings).open('pg-files');
|
||||
await expect(files.query('SELECT 1')).rejects.toThrow(/db:own\) are refused on Postgres while TREK_DB_URL/);
|
||||
const schemas = await pluginSchemas();
|
||||
expect(schemas).not.toContain('trek_plugin_pg_privileged');
|
||||
expect(schemas).not.toContain('trek_plugin_pg_files');
|
||||
});
|
||||
|
||||
// The re-review's escape: an unqualified ALTER TYPE renamed pg_catalog's types for the whole database.
|
||||
const CATALOG_TARGETS = [
|
||||
'alter type int4 rename to int4x',
|
||||
'alter type text rename to evil',
|
||||
'alter type cstring rename to foo',
|
||||
'alter type box rename to boxx',
|
||||
'ALTER TYPE "int4" RENAME TO x',
|
||||
'alter type timestamptz owner to current_user',
|
||||
'drop type if exists box cascade',
|
||||
'drop type int4, text',
|
||||
];
|
||||
|
||||
it('PGPLUG-014: ALTER and DROP of a catalog type are refused by where Postgres resolves it, on a superuser too', async () => {
|
||||
const refused = /schema "pg_catalog"; a plugin changes its own objects only|may not change the owner/;
|
||||
await Promise.all(
|
||||
[data.open('pg-types'), superuserStore('pg-types-su')].map(async (store) => {
|
||||
await Promise.all(CATALOG_TARGETS.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(refused)));
|
||||
// TREK's own tables are not on the plugin's path, so a name of theirs resolves to nothing there.
|
||||
await expect(store.exec('drop table users')).rejects.toThrow(/does not exist/);
|
||||
await expect(store.exec('drop table if exists users, trips cascade')).resolves.toEqual({ changes: 0 });
|
||||
await expect(store.exec('truncate users')).rejects.toThrow(/does not exist/);
|
||||
await expect(store.exec('create index evil on users (email)')).rejects.toThrow(/does not exist/);
|
||||
await expect(store.exec('create table kid (x int) inherits (users)')).rejects.toThrow(/does not exist/);
|
||||
}),
|
||||
);
|
||||
const names = ['int4', 'text', 'cstring', 'box', 'timestamptz'];
|
||||
expect(await Promise.all(names.map(catalogType))).toEqual(names.map(() => true));
|
||||
expect(await asSuper('select 1::int4 as one, 1::text as two')).toEqual([{ one: 1, two: '1' }]);
|
||||
expect((await asSuper<{ n: number }>("select count(*) as n from pg_class where relname = 'users'"))[0].n).toBe(1);
|
||||
});
|
||||
|
||||
it('PGPLUG-015: a plugin still changes its own objects of every kind', async () => {
|
||||
const own = async (store: PostgresPluginDataStore | ReturnType<PluginDataBackend['open']>) => {
|
||||
await store.exec(
|
||||
"CREATE TYPE mood AS ENUM ('ok'); ALTER TYPE mood ADD VALUE 'sad'; ALTER TYPE mood RENAME TO feeling; " +
|
||||
'CREATE TABLE t (id bigserial PRIMARY KEY, f feeling, temp real); CREATE TABLE kid (y int) INHERITS (t); ' +
|
||||
'CREATE TABLE r (t_id bigint REFERENCES t (id)); CREATE INDEX t_f ON t (f); ALTER INDEX t_f RENAME TO t_g; ' +
|
||||
'CREATE MATERIALIZED VIEW mv AS SELECT count(*) AS n FROM t; REFRESH MATERIALIZED VIEW mv; ' +
|
||||
'ALTER TABLE t ADD COLUMN z int; CREATE SEQUENCE s; ALTER SEQUENCE s RESTART WITH 5; ' +
|
||||
'TRUNCATE r, kid; DROP TABLE r; DROP MATERIALIZED VIEW mv; DROP SEQUENCE s',
|
||||
);
|
||||
await store.exec("INSERT INTO t (f, temp) VALUES ('sad', 21.5)");
|
||||
expect(await store.query('SELECT f, temp FROM t ORDER BY temp')).toEqual([{ f: 'sad', temp: 21.5 }]);
|
||||
await store.exec('DROP TABLE kid; DROP TABLE t; DROP TYPE feeling');
|
||||
};
|
||||
await Promise.all([own(data.open('pg-own')), own(superuserStore('pg-own-su'))]);
|
||||
});
|
||||
|
||||
it('PGPLUG-016: the quota counts every relation, sequences and TOAST included, and the object cap catalog-only objects', async () => {
|
||||
const sequences = cappedStore('pg-seq', { quotaBytes: 64 * 1024 });
|
||||
const script = Array.from({ length: 20 }, (_, i) => `CREATE SEQUENCE s${i}`).join('; ');
|
||||
await expect(sequences.exec(script)).rejects.toThrow(/past its 0\.0625 MB quota/);
|
||||
const [{ made }] = await asSuper<{ made: number }>(
|
||||
'select count(*) as made from pg_class c join pg_namespace n on n.oid = c.relnamespace ' +
|
||||
"where n.nspname = 'trek_plugin_pg_seq' and c.relkind = 'S'",
|
||||
);
|
||||
expect(made).toBeGreaterThan(0);
|
||||
expect(made).toBeLessThan(20);
|
||||
|
||||
const toast = cappedStore('pg-toast', { quotaBytes: 64 * 1024 });
|
||||
await toast.migrate('001', 'CREATE TABLE big (body text)');
|
||||
await expect(
|
||||
toast.exec("INSERT INTO big SELECT string_agg(md5(random()::text), '') FROM generate_series(1, 8000)"),
|
||||
).rejects.toThrow(/past its 0\.0625 MB quota/);
|
||||
|
||||
const views = Array.from({ length: 30 }, (_, i) => `CREATE VIEW v${i} AS SELECT ${i} AS n`).join('; ');
|
||||
const capped = async (store: PostgresPluginDataStore) => {
|
||||
await expect(store.exec(views)).rejects.toThrow(/holds more than 40 catalog objects/);
|
||||
await expect(store.exec("CREATE TYPE e AS ENUM ('a')")).rejects.toThrow(/holds more than 40 catalog objects/);
|
||||
// At the cap, dropping still works.
|
||||
await expect(store.exec('DROP VIEW v0')).resolves.toEqual({ changes: 0 });
|
||||
};
|
||||
await Promise.all([
|
||||
capped(cappedStore('pg-objects', { maxObjects: 40 })),
|
||||
capped(superuserStore('pg-objects-su', { maxObjects: 40 })),
|
||||
]);
|
||||
});
|
||||
|
||||
it('PGPLUG-017: the reg* types and the functions that look objects up by name are refused in every spelling', async () => {
|
||||
const payloads = [
|
||||
"select 'public.users'::regtype::oid",
|
||||
"select cast('public.users' as regtype)",
|
||||
"select regtype 'public.users'",
|
||||
`select 'public.users'::"regtype"`,
|
||||
"select 'english'::regconfig",
|
||||
"select 'simple'::regdictionary",
|
||||
"select '{public.users}'::_regclass",
|
||||
"select has_table_privilege('public.users', 'select')",
|
||||
"select currtid2('public.users', '(0,1)')",
|
||||
"select to_regtype('public.users')",
|
||||
];
|
||||
const stores = [data.open('pg-reg'), superuserStore('pg-reg-su')];
|
||||
await Promise.all(
|
||||
stores.flatMap((store) =>
|
||||
payloads.map((sql) => expect(store.query(sql), sql).rejects.toThrow(/may not be named/)),
|
||||
),
|
||||
);
|
||||
});
|
||||
|
||||
it('PGPLUG-018: INTO makes no table unless INSERT or MERGE is the verb, whatever a column alias is called', async () => {
|
||||
const aliases = ['select 1 insert into t1', 'select 1 merge into t9', 'select 1 insert into unlogged t10'];
|
||||
const into = async (store: PostgresPluginDataStore | ReturnType<PluginDataBackend['open']>, schema: string) => {
|
||||
await store.migrate('001', 'CREATE TABLE notes (id bigserial PRIMARY KEY, body text)');
|
||||
await Promise.all(
|
||||
aliases.map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/SELECT \.\.\. INTO is not allowed/)),
|
||||
);
|
||||
const [{ made }] = await asSuper<{ made: number }>(
|
||||
`select count(*) as made from pg_class c join pg_namespace n on n.oid = c.relnamespace ` +
|
||||
`where n.nspname = '${schema}' and c.relname in ('t1', 't9', 't10')`,
|
||||
);
|
||||
expect(made).toBe(0);
|
||||
// INSERT INTO as the verb, after a WITH clause and inside one, still writes.
|
||||
await store.exec("WITH x AS (SELECT 'a' AS b) INSERT INTO notes (body) SELECT b FROM x");
|
||||
expect(
|
||||
await store.query("WITH n AS (INSERT INTO notes (body) VALUES ('b') RETURNING id) SELECT count(*) AS n FROM n"),
|
||||
).toEqual([{ n: 1 }]);
|
||||
expect(await store.query('SELECT body FROM notes ORDER BY id')).toEqual([{ body: 'a' }, { body: 'b' }]);
|
||||
};
|
||||
await Promise.all([
|
||||
into(data.open('pg-into'), 'trek_plugin_pg_into'),
|
||||
into(superuserStore('pg-into-su'), 'trek_plugin_pg_into_su'),
|
||||
]);
|
||||
});
|
||||
|
||||
it('PGPLUG-019: TEMP is refused where it makes a temporary object, and a column named temp works again', async () => {
|
||||
const store = data.open('pg-temp');
|
||||
await Promise.all(
|
||||
[
|
||||
'CREATE TEMP TABLE t (x int)',
|
||||
'CREATE LOCAL TEMPORARY TABLE t (x int)',
|
||||
'CREATE OR REPLACE TEMP VIEW v AS SELECT 1',
|
||||
'CREATE TEMPORARY SEQUENCE s',
|
||||
'select 1 into temp t',
|
||||
'(select 1 as id into temporary users)',
|
||||
].map((sql) => expect(store.exec(sql), sql).rejects.toThrow(/not allowed/)),
|
||||
);
|
||||
await store.migrate('001', 'CREATE TABLE readings (day text, temp real)');
|
||||
await store.exec('INSERT INTO readings (day, temp) VALUES ($1, $2), ($3, $4)', ['mon', 21.5, 'tue', 18]);
|
||||
expect(await store.query('SELECT day, temp FROM readings WHERE temp > 1 ORDER BY temp')).toEqual([
|
||||
{ day: 'tue', temp: 18 },
|
||||
{ day: 'mon', temp: 21.5 },
|
||||
]);
|
||||
const [{ temps }] = await asSuper<{ temps: number }>(
|
||||
"select count(*) as temps from pg_class where relpersistence = 't'",
|
||||
);
|
||||
expect(temps).toBe(0);
|
||||
});
|
||||
|
||||
it('PGPLUG-020: a NUL in an argument or in the SQL is refused with the reason, and nothing is stored', async () => {
|
||||
const store = data.open('pg-nul');
|
||||
await store.migrate('001', 'CREATE TABLE kv (k text PRIMARY KEY)');
|
||||
const reason = /U\+0000 \(NUL\), which Postgres text cannot store/;
|
||||
await expect(store.exec('INSERT INTO kv VALUES ($1)', ['a\u0000b'])).rejects.toThrow(reason);
|
||||
await expect(store.query('SELECT k FROM kv WHERE k = $1', ['ab\u0000'])).rejects.toThrow(reason);
|
||||
await expect(store.tx([{ sql: 'INSERT INTO kv VALUES ($1)', args: [['x', '\u0000']] }])).rejects.toThrow(reason);
|
||||
await expect(store.migrate('002\u0000', 'CREATE TABLE more (x int)')).rejects.toThrow(reason);
|
||||
await expect(store.exec("INSERT INTO kv VALUES ('a\u0000b')")).rejects.toThrow(/U\+0000 \(NUL\)/);
|
||||
expect(await store.query('SELECT count(*) AS n FROM kv')).toEqual([{ n: 0 }]);
|
||||
// Binary data with a zero byte goes to bytea.
|
||||
await store.migrate('003', 'CREATE TABLE raw (b bytea)');
|
||||
await store.exec('INSERT INTO raw VALUES ($1)', [Buffer.from([1, 0, 2])]);
|
||||
expect(await store.query('SELECT length(b) AS n FROM raw')).toEqual([{ n: 3 }]);
|
||||
});
|
||||
});
|
||||
|
||||
@@ -269,7 +269,14 @@ describe('moving a SQLite install to Postgres', () => {
|
||||
const highest = Math.max(...(await findRows(sqliteOrm, Users)).map((row) => row.id));
|
||||
expect(user.id).toBeGreaterThan(highest);
|
||||
|
||||
const store = new PostgresPluginDataStore(PLUGIN_ID, poolClients(pgOrm.em.getConnection()), new PluginDataSlots(1));
|
||||
// The lane connects as a superuser, for which plugin SQL is refused (PGPLUG-013); the move is what is read here.
|
||||
const store = new PostgresPluginDataStore(
|
||||
PLUGIN_ID,
|
||||
poolClients(pgOrm.em.getConnection()),
|
||||
new PluginDataSlots(1),
|
||||
{},
|
||||
{ refuseIfPrivileged: async () => undefined },
|
||||
);
|
||||
expect(await store.query('select id, body, score from notes order by id')).toEqual([
|
||||
{ id: 1, body: 'first', score: 1.5 },
|
||||
{ id: 2, body: 'second', score: null },
|
||||
|
||||
@@ -10,6 +10,7 @@
|
||||
* store on a real database is the Postgres lane's
|
||||
* tests/postgres/plugin-data.test.ts.
|
||||
*/
|
||||
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL } from '../../../../../src/db/engine/postgres/plugin-data-checks';
|
||||
import {
|
||||
dropPluginSchema,
|
||||
END_SESSION,
|
||||
@@ -18,6 +19,7 @@ import {
|
||||
PostgresPluginDataStore,
|
||||
type PluginSqlClient,
|
||||
} from '../../../../../src/db/engine/postgres/plugin-data-store';
|
||||
import { PRIVILEGED_ROLE_SQL } from '../../../../../src/db/engine/postgres/server-checks';
|
||||
|
||||
import type { Kysely } from 'kysely';
|
||||
import Cursor from 'pg-cursor';
|
||||
@@ -28,6 +30,12 @@ interface FakeOptions {
|
||||
schemas?: string[];
|
||||
/** The sizes the quota reads answer, in order. */
|
||||
sizes?: number[];
|
||||
/** The catalog object counts the quota reads answer, in order. */
|
||||
objects?: number[];
|
||||
/** Whether the role check answers that TREK's role is privileged. */
|
||||
privileged?: boolean;
|
||||
/** The objects the target check finds outside the plugin's schema. */
|
||||
foreign?: Array<{ name: string; nspname: string }>;
|
||||
/** Rows a cursor yields, by its statement's text; read two at a time. */
|
||||
rows?: Record<string, unknown[]>;
|
||||
/** What a write reports as changed. */
|
||||
@@ -62,6 +70,7 @@ function fakePool(options: FakeOptions = {}) {
|
||||
const cursors: Array<{ text: string; values: unknown[] | null; closed: boolean }> = [];
|
||||
const releases: boolean[] = [];
|
||||
let size = 0;
|
||||
let objects = 0;
|
||||
const run = (sql: string) => {
|
||||
log.push(sql);
|
||||
const err = options.fail?.(sql);
|
||||
@@ -69,7 +78,14 @@ function fakePool(options: FakeOptions = {}) {
|
||||
};
|
||||
const answer = (sql: string) => {
|
||||
if (sql.startsWith('select nspname')) return { rows: (options.schemas ?? []).map((nspname) => ({ nspname })) };
|
||||
if (sql.startsWith('select coalesce(sum(')) return { rows: [{ bytes: options.sizes?.[size++] ?? 0 }], rowCount: 1 };
|
||||
if (sql.startsWith('select (exists')) return { rows: [{ privileged: options.privileged === true }], rowCount: 1 };
|
||||
if (sql.startsWith('select t.name')) return { rows: options.foreign ?? [], rowCount: 0 };
|
||||
if (sql.startsWith('select coalesce((select sum(')) {
|
||||
return {
|
||||
rows: [{ bytes: options.sizes?.[size++] ?? 0, objects: options.objects?.[objects++] ?? 0 }],
|
||||
rowCount: 1,
|
||||
};
|
||||
}
|
||||
if (sql.startsWith('select 1 from')) return { rows: options.migrated ? [{ '?column?': 1 }] : [], rowCount: 0 };
|
||||
return { rows: [], rowCount: options.changes ?? 0 };
|
||||
};
|
||||
@@ -119,6 +135,9 @@ function store(options: FakeOptions = {}, limits = {}) {
|
||||
return { ...pool, store: new PostgresPluginDataStore('notes', pool.connect, new PluginDataSlots(4), limits) };
|
||||
}
|
||||
|
||||
/** The role check every first call on a client runs before its transaction. */
|
||||
const ROLE_CHECK = `select (${PRIVILEGED_ROLE_SQL}) as privileged`;
|
||||
|
||||
/** A pg error with its SQLSTATE. */
|
||||
function pgError(code: string, message: string): Error {
|
||||
return Object.assign(new Error(message), { code });
|
||||
@@ -132,6 +151,7 @@ describe('Postgres plugin data store', () => {
|
||||
expect(s.engine).toBe('postgres');
|
||||
expect(await s.query('SELECT body FROM notes')).toEqual([{ body: 'a' }, { body: 'b' }, { body: 'c' }]);
|
||||
expect(log).toEqual([
|
||||
ROLE_CHECK,
|
||||
'begin',
|
||||
[
|
||||
'create schema if not exists "trek_plugin_notes"',
|
||||
@@ -199,7 +219,7 @@ describe('Postgres plugin data store', () => {
|
||||
|
||||
const reads = store({}, { quotaBytes: 1 });
|
||||
await reads.store.query('SELECT 1');
|
||||
expect(reads.log.some((sql) => sql.startsWith('select coalesce(sum('))).toBe(false);
|
||||
expect(reads.log.some((sql) => sql.startsWith('select coalesce((select sum('))).toBe(false);
|
||||
});
|
||||
|
||||
it('PGSTORE-006: a script commits statement by statement and stops at the first that fails', async () => {
|
||||
@@ -304,7 +324,7 @@ describe('Postgres plugin data store', () => {
|
||||
expect(configs.filter((q) => q.queryMode === 'extended')).toHaveLength(plugin.length);
|
||||
});
|
||||
|
||||
it('PGSTORE-013: every read goes through a cursor on the same client, closed however the read ends, args without NUL', async () => {
|
||||
it('PGSTORE-013: every read goes through a cursor on the same client, closed however the read ends', async () => {
|
||||
// EXTQ-002 before the store checked out its own clients: what is not a plugin write reaches pg as it was.
|
||||
const rows = Array.from({ length: 7 }, (_, i) => ({ i }));
|
||||
const {
|
||||
@@ -312,9 +332,9 @@ describe('Postgres plugin data store', () => {
|
||||
cursors,
|
||||
configs,
|
||||
} = store({ rows: { 'SELECT i FROM t WHERE x = $1': rows, 'SELECT 1 FROM t': [{}] } }, { maxRows: 5 });
|
||||
await expect(s.query('SELECT i FROM t WHERE x = $1', ['a\u0000b'])).rejects.toThrow('more than 5 rows');
|
||||
await expect(s.query('SELECT i FROM t WHERE x = $1', ['ab'])).rejects.toThrow('more than 5 rows');
|
||||
await s.exec('SELECT 1 FROM t', ['x']);
|
||||
await s.exec('INSERT INTO t VALUES ($1)', ['c\u0000d']);
|
||||
await s.exec('INSERT INTO t VALUES ($1)', ['cd']);
|
||||
expect(cursors).toEqual([
|
||||
{ text: 'SELECT i FROM t WHERE x = $1', values: ['ab'], closed: true },
|
||||
{ text: 'SELECT 1 FROM t', values: ['x'], closed: true },
|
||||
@@ -322,6 +342,77 @@ describe('Postgres plugin data store', () => {
|
||||
expect(configs.find((q) => q.text.startsWith('INSERT'))?.values).toEqual(['cd']);
|
||||
});
|
||||
|
||||
it('PGSTORE-016: an argument or a migration id holding NUL is refused before a client is taken, never altered', async () => {
|
||||
const { store: s, log, releases } = store();
|
||||
const nul = /U\+0000 \(NUL\), which Postgres text cannot store/;
|
||||
await expect(s.query('SELECT 1 FROM t WHERE k = $1', ['a\u0000b'])).rejects.toThrow(nul);
|
||||
await expect(s.exec('INSERT INTO t VALUES ($1)', [['x', 'c\u0000d']])).rejects.toThrow(nul);
|
||||
await expect(s.tx([{ sql: 'SELECT 1' }, { sql: 'DELETE FROM t WHERE k = $1', args: ['\u0000'] }])).rejects.toThrow(
|
||||
nul,
|
||||
);
|
||||
await expect(s.migrate('001\u0000', 'CREATE TABLE t (k text)')).rejects.toThrow(nul);
|
||||
expect({ log, releases }).toEqual({ log: [], releases: [] });
|
||||
// A Buffer goes to bytea, which holds any byte.
|
||||
await expect(s.exec('INSERT INTO t VALUES ($1)', [Buffer.from([0, 1])])).resolves.toEqual({ changes: 0 });
|
||||
});
|
||||
|
||||
it('PGSTORE-017: a privileged role is refused before the transaction opens, and the answer is kept per connection', async () => {
|
||||
const privileged = store({ privileged: true });
|
||||
await expect(privileged.store.query('SELECT 1')).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
|
||||
await expect(privileged.store.exec('CREATE TABLE t (x int)')).rejects.toThrow(/db:own\) are refused on Postgres/);
|
||||
// One read for the connection, no transaction, and the client goes back clean.
|
||||
expect(privileged.log).toEqual([ROLE_CHECK, END_SESSION, END_SESSION]);
|
||||
expect(privileged.releases).toEqual([false, false]);
|
||||
|
||||
const plain = store();
|
||||
await plain.store.query('SELECT 1');
|
||||
await plain.store.query('SELECT 2');
|
||||
expect(plain.log.filter((sql) => sql === ROLE_CHECK)).toHaveLength(1);
|
||||
|
||||
// A read that failed is asked again on the next call.
|
||||
let fails = 1;
|
||||
const flaky = store({ fail: (sql) => (sql === ROLE_CHECK && fails-- > 0 ? new Error('reset') : undefined) });
|
||||
await expect(flaky.store.query('SELECT 1')).rejects.toThrow('reset');
|
||||
await expect(flaky.store.query('SELECT 1')).resolves.toEqual([]);
|
||||
expect(flaky.log.filter((sql) => sql === ROLE_CHECK)).toHaveLength(2);
|
||||
});
|
||||
|
||||
it('PGSTORE-018: the objects a statement changes are resolved right before it runs, and one outside the schema refuses it', async () => {
|
||||
const own = store();
|
||||
await own.store.migrate('001', 'CREATE TABLE a (x int); ALTER TYPE mood RENAME TO feeling; DROP TABLE "B", c');
|
||||
const checks = own.configs.filter((q) => q.text.startsWith('select t.name'));
|
||||
expect(checks.map((q) => q.values)).toEqual([
|
||||
[['"mood"'], ['type'], 'trek_plugin_notes'],
|
||||
[['"B"', '"c"'], ['relation', 'relation'], 'trek_plugin_notes'],
|
||||
]);
|
||||
// Each check comes right before its statement, after the ones before it ran.
|
||||
const order = own.log
|
||||
.filter((sql) => /^(select t\.name|CREATE|ALTER|DROP)/.test(sql))
|
||||
.map((sql) => sql.slice(0, 13));
|
||||
expect(order).toEqual(['CREATE TABLE ', 'select t.name', 'ALTER TYPE mo', 'select t.name', 'DROP TABLE "B']);
|
||||
|
||||
const foreign = store({ foreign: [{ name: '"int4"', nspname: 'pg_catalog' }] });
|
||||
await expect(foreign.store.exec('ALTER TYPE int4 RENAME TO int4x')).rejects.toThrow(
|
||||
/"int4" is an object of the schema "pg_catalog"; a plugin changes its own objects only/,
|
||||
);
|
||||
expect(foreign.log).not.toContain('ALTER TYPE int4 RENAME TO int4x');
|
||||
expect(foreign.log.slice(-2)).toEqual(['rollback', END_SESSION]);
|
||||
// A statement that changes no existing object asks nothing.
|
||||
const plain = store();
|
||||
await plain.store.exec('INSERT INTO a VALUES (1)');
|
||||
expect(plain.log.some((sql) => sql.startsWith('select t.name'))).toBe(false);
|
||||
});
|
||||
|
||||
it('PGSTORE-019: a write that takes the schema past its object cap and adds objects rolls back; a drop still runs', async () => {
|
||||
const grows = store({ sizes: [0, 0], objects: [10, 11] }, { maxObjects: 10 });
|
||||
await expect(grows.store.exec('CREATE TABLE t (x int)')).rejects.toThrow(
|
||||
'the plugin database holds more than 10 catalog objects',
|
||||
);
|
||||
expect(grows.log.slice(-2)).toEqual(['rollback', END_SESSION]);
|
||||
const drops = store({ sizes: [0, 0], objects: [12, 11] }, { maxObjects: 10 });
|
||||
await expect(drops.store.exec('DROP TABLE t')).resolves.toEqual({ changes: 0 });
|
||||
});
|
||||
|
||||
it('PGSTORE-014: each transaction checks out a client of its own and gives it back clean, or closes it', async () => {
|
||||
const ok = store({ changes: 1 });
|
||||
await ok.store.exec('INSERT INTO a VALUES (1); INSERT INTO b VALUES (2)');
|
||||
|
||||
@@ -11,6 +11,7 @@ import {
|
||||
parsePluginSql,
|
||||
PluginSqlRefused,
|
||||
tokenize,
|
||||
type PluginTarget,
|
||||
} from '../../../../../src/db/engine/postgres/plugin-sql-guard';
|
||||
|
||||
import { describe, expect, it } from 'vitest';
|
||||
@@ -63,6 +64,20 @@ describe('plugin SQL guard', () => {
|
||||
'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',
|
||||
// TEMP is refused only where it makes a temporary object; a column of that name is fine.
|
||||
'CREATE TABLE readings (day text, temp real, temporary bool)',
|
||||
'SELECT day, temp FROM readings WHERE temp > 1 ORDER BY temp',
|
||||
'select 1 from notes as temporary',
|
||||
'INSERT INTO temp (x) VALUES (1)',
|
||||
// INSERT INTO in a WITH query's body or after a WITH clause is the statement's own verb.
|
||||
'WITH n AS (INSERT INTO notes (body) VALUES ($1) RETURNING id) SELECT id FROM n',
|
||||
'WITH n AS NOT MATERIALIZED (SELECT 1) INSERT INTO notes (body) SELECT * FROM n',
|
||||
'WITH n AS MATERIALIZED (INSERT INTO notes (body) VALUES (1) RETURNING id) SELECT 1',
|
||||
// Names that only start like a refused one.
|
||||
'SELECT region, regexp_replace(body, $1, $2), regr_slope(1, 2) FROM notes',
|
||||
'CREATE TYPE span AS RANGE (subtype = float8)',
|
||||
'CREATE TABLE index (x int)',
|
||||
'CREATE INDEX ON notes (body)',
|
||||
])('lets through %s', (sql) => {
|
||||
expect(() => check(sql)).not.toThrow();
|
||||
});
|
||||
@@ -126,7 +141,6 @@ describe('plugin SQL guard', () => {
|
||||
['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/],
|
||||
@@ -165,8 +179,33 @@ describe('plugin SQL guard', () => {
|
||||
['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/],
|
||||
// The re-review's bypasses. A column alias named insert or merge in front of INTO made a table.
|
||||
['select 1 insert into t1', /SELECT \.\.\. INTO/],
|
||||
['select 1 merge into t9', /SELECT \.\.\. INTO/],
|
||||
['select 1 insert into unlogged t10', /SELECT \.\.\. INTO/],
|
||||
['select x as insert into t from notes', /SELECT \.\.\. INTO/],
|
||||
['WITH x AS (SELECT 1) SELECT 1 insert INTO t', /SELECT \.\.\. INTO/],
|
||||
['insert into notes select 1 insert into t', /SELECT \.\.\. INTO/],
|
||||
['select 1 insert into temp t', /SELECT \.\.\. INTO TEMP/],
|
||||
// The reg* types and functions that look an object up by a name in a string, in every spelling.
|
||||
["select 'public.users'::regtype::oid", /"regtype" may not be named/],
|
||||
["select cast('int4' as regtype)", /"regtype" may not be named/],
|
||||
["select regtype 'text'", /"regtype" may not be named/],
|
||||
[`select 'x'::"regtype"`, /"regtype" may not be named/],
|
||||
["select 'english'::regconfig", /"regconfig" may not be named/],
|
||||
["select 'simple'::regdictionary", /"regdictionary" may not be named/],
|
||||
["select '{public.users}'::_regclass", /"_regclass" may not be named/],
|
||||
["select 'x'::pg_catalog.regtype", /"pg_catalog" may not be named/],
|
||||
["select has_table_privilege('public.users', 'select')", /"has_table_privilege" may not be named/],
|
||||
["select currtid2('public.users', '(0,1)')", /"currtid2" may not be named/],
|
||||
["select gin_clean_pending_list('public.users_idx')", /"gin_clean_pending_list" may not be named/],
|
||||
["select to_regtype('int4')", /"to_regtype" may not be named/],
|
||||
// A base type is built from C functions, which only a superuser may do.
|
||||
['CREATE TYPE fake (INPUT = int4in, OUTPUT = int4out, INTERNALLENGTH = 1000)', /composite, enum or range/],
|
||||
// The protocol ends a statement's text at a NUL, in a string as anywhere else.
|
||||
["select 'a\u0000' -- then\nfrom public.users", /U\+0000/],
|
||||
['CREATE INDEX i (x)', /must name its table with ON/],
|
||||
['ALTER TABLE', /could not be read/],
|
||||
])('refuses the bypass %j', (sql, reason) => {
|
||||
expect(() => check(sql)).toThrow(PluginSqlRefused);
|
||||
expect(() => check(sql)).toThrow(reason);
|
||||
@@ -234,6 +273,54 @@ describe('plugin SQL guard', () => {
|
||||
expect(qualified.qualifies).toBe(true);
|
||||
});
|
||||
|
||||
it('refuses TEMP where it makes a temporary object, and says so', () => {
|
||||
for (const sql of [
|
||||
'CREATE TEMP TABLE t (x int)',
|
||||
'CREATE TEMPORARY VIEW v AS SELECT 1',
|
||||
'CREATE OR REPLACE TEMP VIEW v AS SELECT 1',
|
||||
'CREATE LOCAL TEMP TABLE t (x int)',
|
||||
'CREATE GLOBAL TEMPORARY TABLE t (x int)',
|
||||
]) {
|
||||
expect(() => check(sql), sql).toThrow(/is not allowed: a temporary object outlives the call/);
|
||||
}
|
||||
expect(() => check('select 1 into temp t')).toThrow(/SELECT \.\.\. INTO TEMP is not allowed: no temporary tables/);
|
||||
expect(() => check('CREATE LOCAL TABLE t (x int)')).toThrow(/CREATE LOCAL is not allowed$/);
|
||||
});
|
||||
|
||||
it('names the existing objects a statement changes, for the store to resolve in its transaction', () => {
|
||||
const targets = (sql: string) => parsePluginSql(sql)[0].targets;
|
||||
const rel = (...name: string[]): PluginTarget => ({ kind: 'relation', name });
|
||||
expect(targets('ALTER TYPE int4 RENAME TO int4x')).toEqual([{ kind: 'type', name: ['int4'] }]);
|
||||
expect(targets('DROP TYPE IF EXISTS mood, "Text" CASCADE')).toEqual([
|
||||
{ kind: 'type', name: ['mood'] },
|
||||
{ kind: 'type', name: ['Text'] },
|
||||
]);
|
||||
expect(targets('DROP TABLE IF EXISTS a, "B", trek_plugin_notes.c CASCADE')).toEqual([
|
||||
rel('a'),
|
||||
rel('B'),
|
||||
rel('trek_plugin_notes', 'c'),
|
||||
]);
|
||||
expect(targets('DROP INDEX CONCURRENTLY IF EXISTS i')).toEqual([rel('i')]);
|
||||
expect(targets('DROP MATERIALIZED VIEW mv')).toEqual([rel('mv')]);
|
||||
expect(targets('REFRESH MATERIALIZED VIEW CONCURRENTLY mv WITH DATA')).toEqual([rel('mv')]);
|
||||
expect(targets('TRUNCATE TABLE ONLY a, b * RESTART IDENTITY')).toEqual([rel('a'), rel('b')]);
|
||||
expect(targets('TRUNCATE a')).toEqual([rel('a')]);
|
||||
expect(targets('CREATE UNIQUE INDEX CONCURRENTLY IF NOT EXISTS i ON ONLY t USING btree (x)')).toEqual([rel('t')]);
|
||||
expect(targets('CREATE INDEX ON t (x)')).toEqual([rel('t')]);
|
||||
expect(targets('ALTER MATERIALIZED VIEW IF EXISTS mv RENAME TO mv2')).toEqual([rel('mv')]);
|
||||
expect(targets('ALTER TABLE IF EXISTS ONLY t ADD CONSTRAINT f FOREIGN KEY (x) REFERENCES p (id)')).toEqual([
|
||||
rel('t'),
|
||||
rel('p'),
|
||||
]);
|
||||
expect(targets('CREATE TABLE c (x int REFERENCES p) INHERITS (q, r)')).toEqual([rel('p'), rel('q'), rel('r')]);
|
||||
expect(targets('CREATE TABLE c PARTITION OF p FOR VALUES IN (1)')).toEqual([rel('p')]);
|
||||
expect(targets('ALTER TABLE p ATTACH PARTITION c FOR VALUES IN (1)')).toEqual([rel('p'), rel('c')]);
|
||||
expect(targets('ALTER TABLE c NO INHERIT p')).toEqual([rel('c'), rel('p')]);
|
||||
expect(targets('CREATE TABLE t (x int)')).toEqual([]);
|
||||
expect(targets('SELECT 1')).toEqual([]);
|
||||
expect(() => parsePluginSql('DROP TABLE a.b.c.d')).toThrow(/at most three parts/);
|
||||
});
|
||||
|
||||
it('turns a SQLite ? placeholder into a message about $1 when args are bound', () => {
|
||||
const [sqliteStyle] = parsePluginSql('SELECT * FROM notes WHERE id = ?');
|
||||
expect(() => checkPlaceholders(sqliteStyle, [1])).toThrow(/\$1, \$2/);
|
||||
|
||||
@@ -7,7 +7,9 @@
|
||||
*/
|
||||
import type { DbSettings } from '../../../src/app-config';
|
||||
import type { DatabaseEngine } from '../../../src/db/engine';
|
||||
import { PRIVILEGED_ROLE_PLUGIN_REFUSAL } from '../../../src/db/engine/postgres/plugin-data-checks';
|
||||
import { PostgresPluginDataStore } from '../../../src/db/engine/postgres/plugin-data-store';
|
||||
import { PRIVILEGED_ROLE_DESCRIPTION } from '../../../src/db/engine/postgres/server-checks';
|
||||
import {
|
||||
PLUGIN_DATA,
|
||||
PLUGIN_DATA_PROVIDERS,
|
||||
@@ -21,7 +23,13 @@ import type { FactoryProvider } from '@nestjs/common';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
||||
import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest';
|
||||
|
||||
const { logWarn } = vi.hoisted(() => ({ logWarn: vi.fn() }));
|
||||
vi.mock('../../../src/nest/audit/audit-log.logger', async (importOriginal) => ({
|
||||
...(await importOriginal<typeof import('../../../src/nest/audit/audit-log.logger')>()),
|
||||
logWarn,
|
||||
}));
|
||||
|
||||
let tmp: string;
|
||||
beforeAll(() => {
|
||||
@@ -33,15 +41,30 @@ afterAll(() => {
|
||||
fs.rmSync(tmp, { recursive: true, force: true });
|
||||
});
|
||||
|
||||
/** An ORM whose Kysely client records the SQL it is handed. */
|
||||
function fakeOrm(executed: string[]): MikroORM {
|
||||
/**
|
||||
* An ORM whose Kysely client records the SQL it is handed, and whose pool
|
||||
* hands out a client answering the role check with `privileged` (or failing
|
||||
* with it, when it is an Error).
|
||||
*/
|
||||
function fakeOrm(executed: string[], privileged: boolean | Error = false, released: boolean[] = []): MikroORM {
|
||||
const client = {
|
||||
executeQuery: async (query: { sql: string }) => {
|
||||
executed.push(query.sql);
|
||||
return { rows: [] };
|
||||
},
|
||||
};
|
||||
return { em: { getConnection: () => ({ getClient: () => client }) } } as unknown as MikroORM;
|
||||
const pgClient = {
|
||||
query: async (sql: string) => {
|
||||
executed.push(sql);
|
||||
if (privileged instanceof Error) throw privileged;
|
||||
return { rows: [{ privileged }], rowCount: 1 };
|
||||
},
|
||||
release: (destroy?: boolean) => released.push(destroy === true),
|
||||
};
|
||||
const pool = { connect: async () => pgClient };
|
||||
return {
|
||||
em: { getConnection: () => ({ getClient: () => client, getNativeClient: async () => pool }) },
|
||||
} as unknown as MikroORM;
|
||||
}
|
||||
|
||||
const POSTGRES = { engine: 'postgres', url: 'postgres://trek@db/trek', poolMax: 4 } as unknown as DbSettings;
|
||||
@@ -101,4 +124,30 @@ describe('plugin data port', () => {
|
||||
await expect(store.query('SELECT 1')).rejects.toThrow('The database connection is not open');
|
||||
await expect(store.query('SELECT * FROM public.users')).rejects.toThrow('The database connection is not open');
|
||||
});
|
||||
|
||||
it("PLUGDATA-006: on Postgres the boot log says when TREK's role keeps plugin databases refused, and why", async () => {
|
||||
logWarn.mockClear();
|
||||
const released: boolean[] = [];
|
||||
await new PostgresPluginDataBackend(fakeOrm([], true, released), POSTGRES).onApplicationBootstrap();
|
||||
expect(logWarn).toHaveBeenCalledWith(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
|
||||
expect(PRIVILEGED_ROLE_PLUGIN_REFUSAL).toContain(PRIVILEGED_ROLE_DESCRIPTION);
|
||||
expect(released).toEqual([false]);
|
||||
|
||||
logWarn.mockClear();
|
||||
await new PostgresPluginDataBackend(fakeOrm([], false), POSTGRES).onApplicationBootstrap();
|
||||
await new PostgresPluginDataBackend(fakeOrm([], true), SQLITE).onApplicationBootstrap();
|
||||
expect(logWarn).not.toHaveBeenCalled();
|
||||
|
||||
await new PostgresPluginDataBackend(fakeOrm([], new Error('down')), POSTGRES).onApplicationBootstrap();
|
||||
expect(logWarn).toHaveBeenCalledWith("Could not check whether TREK's role may run plugin SQL: down");
|
||||
});
|
||||
|
||||
it('PLUGDATA-007: the stores of one backend share its role check, so a connection is asked once', async () => {
|
||||
const executed: string[] = [];
|
||||
const backend = new PostgresPluginDataBackend(fakeOrm(executed, true), POSTGRES);
|
||||
await backend.onApplicationBootstrap();
|
||||
await expect(backend.open('pg-four').query('SELECT 1')).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
|
||||
await expect(backend.open('pg-five').query('SELECT 1')).rejects.toThrow(PRIVILEGED_ROLE_PLUGIN_REFUSAL);
|
||||
expect(executed.filter((sql) => sql.includes('as privileged'))).toHaveLength(1);
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user