fix(db): refuse the column notation without parentheses and aclitem in plugin SQL

Postgres reads x.f as the call f(x) when x has no column f. The guard counted
that spelling only after ")." or "].", so over a function in FROM that
returns a single value, or a parameter, the allowlist was bypassed:
"select g.obj_description from generate_series(...) g" returned the comments
on every object of the database, and g.current_schemas, g.txid_status and
$1.ts_token_type passed as well. A refused catalog function after a dot is
now refused too, except the names in COLUMN_NAMES (money, name, oid, version,
xid, xml), which take no argument or only convert it to their type, so t.name
keeps working. PGPLUG-021 holds that list to pg_proc on the lane's server.

The type aclitem names roles: '=r'::aclitem printed the cluster's first
superuser and 'x=r/x'::aclitem told whether a role exists. It is refused in
every spelling like the reg* types.

The allowlist itself moves to assets/postgres/plugin-functions.txt, beside
the catalog list it is checked against. As TypeScript it spelled 'like' and
'json_each', names of Postgres functions that the SQLite dialect gate reads
as SQLite SQL.
This commit is contained in:
Maurice
2026-11-17 23:30:29 +00:00
parent adcda60f7d
commit 636fc7d0a6
9 changed files with 588 additions and 449 deletions
+10 -7
View File
@@ -219,18 +219,21 @@ What changes on Postgres:
aggregates and window functions (`count`, `sum`, `string_agg`, `row_number`, `lag`, ...),
UUIDs (`gen_random_uuid`), ranges, geometry, network addresses and full text search
(`to_tsvector`, `ts_rank`, ...). Any other function of Postgres's catalog is refused
however you spell the call (`f(...)`, `"f"(...)`, the column notation `(x).f`): the ones
that read the catalogs or the server rather than their arguments (`obj_description`,
`col_description`, `format_type`, `version`, `current_database`, `inet_server_addr`,
`txid_current`, ...), and so is every new function a later Postgres adds until TREK has
however you spell the call (`f(...)`, `"f"(...)`, the column notation `(x).f`, `t.f`,
`$1.f`): the ones that read the catalogs or the server rather than their arguments
(`obj_description`, `col_description`, `format_type`, `version`, `current_database`,
`inet_server_addr`, `txid_current`, ...), and so is every new function a later Postgres adds until TREK has
decided about it. The keywords `current_user`, `session_user`, `current_role`, `user`,
`system_user`, `current_catalog` and `current_schema` are refused too. `coalesce`,
`nullif`, `greatest`, `least`, `CASE` and `CAST` are syntax and always work. The complete
list is `PLUGIN_FUNCTIONS` in TREK's
[`plugin-sql-functions.ts`](https://github.com/liketrek/TREK/blob/main/server/src/db/engine/postgres/plugin-sql-functions.ts).
list is TREK's
[`plugin-functions.txt`](https://github.com/liketrek/TREK/blob/main/server/assets/postgres/plugin-functions.txt).
A table or type of yours may still share a refused function's name where it cannot be a
call (`INSERT INTO version (...)`, `CREATE TABLE version (...)`, `REFERENCES version (id)`);
as the table of `CREATE INDEX ... ON` it cannot, so name it differently.
as the table of `CREATE INDEX ... ON` it cannot, so name it differently. Postgres reads
`t.f` as the call `f(t)` when `t` has no column `f`, so a column named like a refused
function cannot follow a table's name and a dot either (`name`, `version`, `money`, `oid`,
`xid` and `xml` can); write it without the table's name, or name it differently.
- **You change your own objects only.** Right before an `ALTER`, `DROP`, `REFRESH`,
`TRUNCATE` or `CREATE INDEX ... ON` runs, Postgres resolves the object it names (and the
tables a `CREATE`/`ALTER TABLE` ties to with `REFERENCES`, `INHERITS`, `PARTITION OF`,
+1 -1
View File
File diff suppressed because one or more lines are too long
+424
View File
@@ -0,0 +1,424 @@
# The functions of Postgres's pg_catalog a plugin's own SQL may call, one name per line,
# grouped. Read by src/db/engine/postgres/plugin-sql-functions.ts; every name must be in
# catalog-functions.txt (a unit test checks). A line starting with # is a comment.
# Strings and bytes.
ascii
bit_count
bit_length
btrim
casefold
char_length
character_length
chr
concat
concat_ws
convert
convert_from
convert_to
crc32
crc32c
decode
encode
format
get_bit
get_byte
initcap
is_normalized
left
length
like
lower
lpad
ltrim
md5
normalize
octet_length
overlay
position
quote_ident
quote_literal
quote_nullable
regexp_count
regexp_instr
regexp_like
regexp_match
regexp_matches
regexp_replace
regexp_split_to_array
regexp_split_to_table
regexp_substr
repeat
replace
reverse
right
rpad
rtrim
set_bit
set_byte
sha224
sha256
sha384
sha512
split_part
starts_with
string_to_array
string_to_table
strpos
substr
substring
to_ascii
to_bin
to_hex
to_oct
translate
unistr
upper
# Numbers.
abs
acos
acosd
acosh
asin
asind
asinh
atan
atan2
atan2d
atand
atanh
cbrt
ceil
ceiling
cos
cosd
cosh
cot
cotd
degrees
div
erf
erfc
exp
factorial
floor
gamma
gcd
lcm
lgamma
ln
log
log10
min_scale
mod
pi
pow
power
radians
random
random_normal
round
scale
sign
sin
sind
sinh
sqrt
tan
tand
tanh
trim_scale
trunc
width_bucket
# Dates and times.
age
clock_timestamp
date_add
date_bin
date_part
date_subtract
date_trunc
extract
isfinite
justify_days
justify_hours
justify_interval
make_date
make_interval
make_time
make_timestamp
make_timestamptz
now
overlaps
statement_timestamp
timeofday
timezone
to_char
to_date
to_number
to_timestamp
transaction_timestamp
# Conversions, also the type names written with a modifier (`varchar(20)`, `numeric(10, 2)`).
bit
bool
bpchar
bytea
char
date
float4
float8
int2
int4
int8
interval
numeric
text
time
timestamp
timestamptz
timetz
varbit
varchar
# JSON.
array_to_json
json_agg
json_agg_strict
json_array_elements
json_array_elements_text
json_array_length
json_build_array
json_build_object
json_each
json_each_text
json_extract_path
json_extract_path_text
json_object
json_object_agg
json_object_agg_strict
json_object_agg_unique
json_object_agg_unique_strict
json_object_keys
json_populate_record
json_populate_recordset
json_strip_nulls
json_to_record
json_to_recordset
json_typeof
jsonb_agg
jsonb_agg_strict
jsonb_array_elements
jsonb_array_elements_text
jsonb_array_length
jsonb_build_array
jsonb_build_object
jsonb_each
jsonb_each_text
jsonb_extract_path
jsonb_extract_path_text
jsonb_insert
jsonb_object
jsonb_object_agg
jsonb_object_agg_strict
jsonb_object_agg_unique
jsonb_object_agg_unique_strict
jsonb_object_keys
jsonb_path_exists
jsonb_path_exists_tz
jsonb_path_match
jsonb_path_match_tz
jsonb_path_query
jsonb_path_query_array
jsonb_path_query_array_tz
jsonb_path_query_first
jsonb_path_query_first_tz
jsonb_path_query_tz
jsonb_populate_record
jsonb_populate_record_valid
jsonb_populate_recordset
jsonb_pretty
jsonb_set
jsonb_set_lax
jsonb_strip_nulls
jsonb_to_record
jsonb_to_recordset
jsonb_typeof
row_to_json
to_json
to_jsonb
# Arrays and sets.
array_append
array_cat
array_dims
array_fill
array_length
array_lower
array_ndims
array_position
array_positions
array_prepend
array_remove
array_replace
array_reverse
array_sample
array_shuffle
array_sort
array_to_string
array_upper
cardinality
generate_series
generate_subscripts
trim_array
unnest
num_nonnulls
num_nulls
# Aggregates.
any_value
array_agg
avg
bit_and
bit_or
bit_xor
bool_and
bool_or
corr
count
covar_pop
covar_samp
every
max
min
mode
percentile_cont
percentile_disc
range_agg
range_intersect_agg
regr_avgx
regr_avgy
regr_count
regr_intercept
regr_r2
regr_slope
regr_sxx
regr_sxy
regr_syy
stddev
stddev_pop
stddev_samp
string_agg
sum
var_pop
var_samp
variance
# Window functions.
cume_dist
dense_rank
first_value
lag
last_value
lead
nth_value
ntile
percent_rank
rank
row_number
# UUIDs.
gen_random_uuid
uuid_extract_timestamp
uuid_extract_version
uuidv4
uuidv7
# Ranges and the plugin's own enum types.
datemultirange
daterange
enum_first
enum_last
enum_range
int4multirange
int4range
int8multirange
int8range
isempty
lower_inc
lower_inf
multirange
nummultirange
numrange
range_merge
tsmultirange
tsrange
tstzmultirange
tstzrange
upper_inc
upper_inf
# Geometry.
area
bound_box
box
center
circle
diagonal
diameter
height
isclosed
isopen
line
lseg
npoints
path
pclose
point
polygon
popen
radius
slope
width
# Network addresses.
abbrev
broadcast
cidr
family
host
hostmask
inet_merge
inet_same_family
macaddr
macaddr8
masklen
netmask
network
set_masklen
# Full text search. ts_stat and ts_rewrite run SQL handed to them as text and stay refused.
array_to_tsvector
json_to_tsvector
jsonb_to_tsvector
numnode
phraseto_tsquery
plainto_tsquery
querytree
setweight
strip
to_tsquery
to_tsvector
ts_delete
ts_filter
ts_headline
ts_rank
ts_rank_cd
tsvector_to_array
websearch_to_tsquery
# The TABLESAMPLE methods (`TABLESAMPLE SYSTEM (10)`).
bernoulli
system
@@ -16,14 +16,16 @@ import path from 'node:path';
* activity. Listing those one by one would miss the next one Postgres adds.
*
* So the rule is an allowlist: a call to a function of `pg_catalog` is
* refused unless its name is in {@link PLUGIN_FUNCTIONS}, the string, math,
* refused unless its name is in {@link PLUGIN_FUNCTIONS_FILE}, the string, math,
* date and time, JSON, array, range, aggregate, window, UUID and text search
* functions a data plugin plausibly needs, each of which works only on its
* arguments. A name counts as called when `(` follows it (`version()`,
* `"version" ()`) or when it follows `).`, Postgres's column notation for a
* call (`(16386::oid).obj_description`). A plugin's own table or type may
* still carry such a name where it cannot be a call: after INTO, TABLE, VIEW,
* REFERENCES or IF NOT EXISTS (`INSERT INTO version (...)`).
* `"version" ()`) or when it follows a dot, Postgres's column notation for
* a call (`(16386::oid).obj_description`, `u.obj_description` over `FROM
* unnest(...) u`, `$1.obj_description`), unless it is one of
* {@link COLUMN_NAMES}. A plugin's own table or type may still carry such a
* name where it cannot be a call: after INTO, TABLE, VIEW, REFERENCES or IF
* NOT EXISTS (`INSERT INTO version (...)`).
*
* Which names are functions of `pg_catalog` is read from
* `assets/postgres/catalog-functions.txt`: every function name of every
@@ -38,417 +40,6 @@ import path from 'node:path';
* name starting with `pg_` is refused anywhere by the guard itself.
*/
/** The functions of `pg_catalog` a plugin may call. Each must exist in the catalog list (a unit test checks). */
export const PLUGIN_FUNCTIONS: ReadonlySet<string> = new Set([
// Strings and bytes.
'ascii',
'bit_count',
'bit_length',
'btrim',
'casefold',
'char_length',
'character_length',
'chr',
'concat',
'concat_ws',
'convert',
'convert_from',
'convert_to',
'crc32',
'crc32c',
'decode',
'encode',
'format',
'get_bit',
'get_byte',
'initcap',
'is_normalized',
'left',
'length',
'like',
'lower',
'lpad',
'ltrim',
'md5',
'normalize',
'octet_length',
'overlay',
'position',
'quote_ident',
'quote_literal',
'quote_nullable',
'regexp_count',
'regexp_instr',
'regexp_like',
'regexp_match',
'regexp_matches',
'regexp_replace',
'regexp_split_to_array',
'regexp_split_to_table',
'regexp_substr',
'repeat',
'replace',
'reverse',
'right',
'rpad',
'rtrim',
'set_bit',
'set_byte',
'sha224',
'sha256',
'sha384',
'sha512',
'split_part',
'starts_with',
'string_to_array',
'string_to_table',
'strpos',
'substr',
'substring',
'to_ascii',
'to_bin',
'to_hex',
'to_oct',
'translate',
'unistr',
'upper',
// Numbers.
'abs',
'acos',
'acosd',
'acosh',
'asin',
'asind',
'asinh',
'atan',
'atan2',
'atan2d',
'atand',
'atanh',
'cbrt',
'ceil',
'ceiling',
'cos',
'cosd',
'cosh',
'cot',
'cotd',
'degrees',
'div',
'erf',
'erfc',
'exp',
'factorial',
'floor',
'gamma',
'gcd',
'lcm',
'lgamma',
'ln',
'log',
'log10',
'min_scale',
'mod',
'pi',
'pow',
'power',
'radians',
'random',
'random_normal',
'round',
'scale',
'sign',
'sin',
'sind',
'sinh',
'sqrt',
'tan',
'tand',
'tanh',
'trim_scale',
'trunc',
'width_bucket',
// Dates and times.
'age',
'clock_timestamp',
'date_add',
'date_bin',
'date_part',
'date_subtract',
'date_trunc',
'extract',
'isfinite',
'justify_days',
'justify_hours',
'justify_interval',
'make_date',
'make_interval',
'make_time',
'make_timestamp',
'make_timestamptz',
'now',
'overlaps',
'statement_timestamp',
'timeofday',
'timezone',
'to_char',
'to_date',
'to_number',
'to_timestamp',
'transaction_timestamp',
// Conversions, also the type names written with a modifier (`varchar(20)`, `numeric(10, 2)`).
'bit',
'bool',
'bpchar',
'bytea',
'char',
'date',
'float4',
'float8',
'int2',
'int4',
'int8',
'interval',
'numeric',
'text',
'time',
'timestamp',
'timestamptz',
'timetz',
'varbit',
'varchar',
// JSON.
'array_to_json',
'json_agg',
'json_agg_strict',
'json_array_elements',
'json_array_elements_text',
'json_array_length',
'json_build_array',
'json_build_object',
'json_each',
'json_each_text',
'json_extract_path',
'json_extract_path_text',
'json_object',
'json_object_agg',
'json_object_agg_strict',
'json_object_agg_unique',
'json_object_agg_unique_strict',
'json_object_keys',
'json_populate_record',
'json_populate_recordset',
'json_strip_nulls',
'json_to_record',
'json_to_recordset',
'json_typeof',
'jsonb_agg',
'jsonb_agg_strict',
'jsonb_array_elements',
'jsonb_array_elements_text',
'jsonb_array_length',
'jsonb_build_array',
'jsonb_build_object',
'jsonb_each',
'jsonb_each_text',
'jsonb_extract_path',
'jsonb_extract_path_text',
'jsonb_insert',
'jsonb_object',
'jsonb_object_agg',
'jsonb_object_agg_strict',
'jsonb_object_agg_unique',
'jsonb_object_agg_unique_strict',
'jsonb_object_keys',
'jsonb_path_exists',
'jsonb_path_exists_tz',
'jsonb_path_match',
'jsonb_path_match_tz',
'jsonb_path_query',
'jsonb_path_query_array',
'jsonb_path_query_array_tz',
'jsonb_path_query_first',
'jsonb_path_query_first_tz',
'jsonb_path_query_tz',
'jsonb_populate_record',
'jsonb_populate_record_valid',
'jsonb_populate_recordset',
'jsonb_pretty',
'jsonb_set',
'jsonb_set_lax',
'jsonb_strip_nulls',
'jsonb_to_record',
'jsonb_to_recordset',
'jsonb_typeof',
'row_to_json',
'to_json',
'to_jsonb',
// Arrays and sets.
'array_append',
'array_cat',
'array_dims',
'array_fill',
'array_length',
'array_lower',
'array_ndims',
'array_position',
'array_positions',
'array_prepend',
'array_remove',
'array_replace',
'array_reverse',
'array_sample',
'array_shuffle',
'array_sort',
'array_to_string',
'array_upper',
'cardinality',
'generate_series',
'generate_subscripts',
'trim_array',
'unnest',
'num_nonnulls',
'num_nulls',
// Aggregates.
'any_value',
'array_agg',
'avg',
'bit_and',
'bit_or',
'bit_xor',
'bool_and',
'bool_or',
'corr',
'count',
'covar_pop',
'covar_samp',
'every',
'max',
'min',
'mode',
'percentile_cont',
'percentile_disc',
'range_agg',
'range_intersect_agg',
'regr_avgx',
'regr_avgy',
'regr_count',
'regr_intercept',
'regr_r2',
'regr_slope',
'regr_sxx',
'regr_sxy',
'regr_syy',
'stddev',
'stddev_pop',
'stddev_samp',
'string_agg',
'sum',
'var_pop',
'var_samp',
'variance',
// Window functions.
'cume_dist',
'dense_rank',
'first_value',
'lag',
'last_value',
'lead',
'nth_value',
'ntile',
'percent_rank',
'rank',
'row_number',
// UUIDs.
'gen_random_uuid',
'uuid_extract_timestamp',
'uuid_extract_version',
'uuidv4',
'uuidv7',
// Ranges and the plugin's own enum types.
'datemultirange',
'daterange',
'enum_first',
'enum_last',
'enum_range',
'int4multirange',
'int4range',
'int8multirange',
'int8range',
'isempty',
'lower_inc',
'lower_inf',
'multirange',
'nummultirange',
'numrange',
'range_merge',
'tsmultirange',
'tsrange',
'tstzmultirange',
'tstzrange',
'upper_inc',
'upper_inf',
// Geometry.
'area',
'bound_box',
'box',
'center',
'circle',
'diagonal',
'diameter',
'height',
'isclosed',
'isopen',
'line',
'lseg',
'npoints',
'path',
'pclose',
'point',
'polygon',
'popen',
'radius',
'slope',
'width',
// Network addresses.
'abbrev',
'broadcast',
'cidr',
'family',
'host',
'hostmask',
'inet_merge',
'inet_same_family',
'macaddr',
'macaddr8',
'masklen',
'netmask',
'network',
'set_masklen',
// Full text search. ts_stat and ts_rewrite run SQL handed to them as text and stay refused.
'array_to_tsvector',
'json_to_tsvector',
'jsonb_to_tsvector',
'numnode',
'phraseto_tsquery',
'plainto_tsquery',
'querytree',
'setweight',
'strip',
'to_tsquery',
'to_tsvector',
'ts_delete',
'ts_filter',
'ts_headline',
'ts_rank',
'ts_rank_cd',
'tsvector_to_array',
'websearch_to_tsquery',
// The TABLESAMPLE methods (`TABLESAMPLE SYSTEM (10)`).
'bernoulli',
'system',
]);
/**
* The SQL keywords that call a catalog function without parentheses and
* describe the session or the server: the role names, the database and the
@@ -464,6 +55,21 @@ export const SESSION_KEYWORDS: ReadonlySet<string> = new Set([
'user',
]);
/**
* The refused names a plugin's table may well have as a column, which may
* still follow a table, an alias or a parameter and a dot (`t.name`,
* `n.version`). Postgres reads `x.f` as the column `f` of `x` and, when `x`
* has no such column, as the call `f(x)`: with a function in FROM that
* returns a single value (`FROM unnest(...) u`, `FROM generate_series(...)
* g`) or a parameter (`$1.f`), that value is the argument. None of these
* reads anything called that way: `version` takes no argument, so the
* notation never calls it, and `money`, `name`, `oid`, `xid` and `xml` only
* convert their argument to the type of that name. Every other refused name
* is refused after a dot too. PGPLUG-021 holds each name here to that on the
* lane's server.
*/
export const COLUMN_NAMES: ReadonlySet<string> = new Set(['money', 'name', 'oid', 'version', 'xid', 'xml']);
/** The function names of `pg_catalog` on every supported major, one per line, sorted. */
export const CATALOG_FUNCTIONS_FILE = path.join(
__dirname,
@@ -476,21 +82,58 @@ export const CATALOG_FUNCTIONS_FILE = path.join(
'catalog-functions.txt',
);
/**
* The functions of `pg_catalog` a plugin may call, one per line, grouped under
* `#` comments. A list of names, not SQL, so it is kept as data beside the
* catalog list. Each must exist in that list (a unit test checks).
*/
export const PLUGIN_FUNCTIONS_FILE = path.join(
__dirname,
'..',
'..',
'..',
'..',
'assets',
'postgres',
'plugin-functions.txt',
);
/** The names in `file`: its lines without blanks and `#` comments. */
function namesIn(file: string): ReadonlySet<string> {
return new Set(
fs
.readFileSync(file, 'utf8')
.split('\n')
.map((line) => line.trim())
.filter((line) => line !== '' && !line.startsWith('#')),
);
}
let catalog: ReadonlySet<string> | undefined;
let allowed: ReadonlySet<string> | undefined;
/** The names in {@link CATALOG_FUNCTIONS_FILE}, read once. */
export function catalogFunctionNames(): ReadonlySet<string> {
catalog ??= new Set(
fs
.readFileSync(CATALOG_FUNCTIONS_FILE, 'utf8')
.split('\n')
.map((line) => line.trim())
.filter((line) => line !== ''),
);
catalog ??= namesIn(CATALOG_FUNCTIONS_FILE);
return catalog;
}
/** The names in {@link PLUGIN_FUNCTIONS_FILE}, read once. */
export function pluginFunctionNames(): ReadonlySet<string> {
allowed ??= namesIn(PLUGIN_FUNCTIONS_FILE);
return allowed;
}
/** Whether calling `name` reaches a function of `pg_catalog` a plugin may not call. */
export function refusedCatalogCall(name: string): boolean {
return !PLUGIN_FUNCTIONS.has(name) && catalogFunctionNames().has(name);
return !pluginFunctionNames().has(name) && catalogFunctionNames().has(name);
}
/**
* Whether `name` after a dot (`x.name`, the column notation) may call a
* function of `pg_catalog` a plugin may not call: one of
* {@link refusedCatalogCall} that is not in {@link COLUMN_NAMES}.
*/
export function refusedCatalogField(name: string): boolean {
return refusedCatalogCall(name) && !COLUMN_NAMES.has(name);
}
@@ -1,5 +1,5 @@
import { PLUGIN_SCHEMA_PREFIX } from './plugin-schema';
import { refusedCatalogCall, SESSION_KEYWORDS } from './plugin-sql-functions';
import { refusedCatalogCall, refusedCatalogField, SESSION_KEYWORDS } from './plugin-sql-functions';
/**
* What keeps a plugin's own SQL on Postgres inside its own schema.
@@ -74,13 +74,15 @@ import { refusedCatalogCall, SESSION_KEYWORDS } from './plugin-sql-functions';
* `plugin-sql-functions.ts` (`obj_description`, `format_type`, `version`,
* `current_database`, ...: whatever reads the catalogs or the server rather
* than its arguments), in either spelling of a call (`f(...)`, or the
* column notation `(x).f`), and the keywords that name the session's roles,
* database or schema (`current_user`, `session_user`, `current_catalog`, ...);
* column notation `(x).f`, `u.f`, `$1.f`), and the keywords that name the
* session's roles, database or schema (`current_user`, `session_user`,
* `current_catalog`, ...);
* - the object identifier types that look an object up by name
* (`regclass`, `regtype`, `regproc`, `regprocedure`, `regoper`,
* `regoperator`, `regconfig`, `regdictionary`, `regnamespace`, `regrole`,
* `regcollation`, and their array types `_regclass`, ...), in every
* spelling: `'x'::regtype`, `CAST('x' AS regtype)`, `regtype 'x'`, quoted;
* and `aclitem`, whose input and output name roles;
* - a temporary object: CREATE TEMP or TEMPORARY (also after OR REPLACE,
* LOCAL or GLOBAL), and SELECT ... INTO TEMP; a temporary table outlives
* the call on a pooled connection. Elsewhere `temp` is an ordinary name;
@@ -207,6 +209,14 @@ const NAME_LOOKUP_TYPES = [
'regcollation',
];
/**
* `aclitem`, a privilege as `grantee=privileges/grantor`, refused in every
* spelling like the object identifier types: its input looks each role up by
* name and its output names them, so `'=r'::aclitem` shows the cluster's
* first superuser and `'x=r/x'::aclitem` tells whether a role exists.
*/
const ROLE_LOOKUP_TYPES = ['aclitem', '_aclitem'];
/** Functions and types refused under any spelling, quoted or not. */
const REFUSED_NAMES = new Set([
'set_config',
@@ -221,6 +231,7 @@ const REFUSED_NAMES = new Set([
'lowrite',
...NAME_LOOKUP_TYPES,
...NAME_LOOKUP_TYPES.map((type) => `_${type}`),
...ROLE_LOOKUP_TYPES,
// Functions that take a relation, a type or another object by a name in a
// string, or reach an index by one to maintain it.
'has_any_column_privilege',
@@ -556,19 +567,24 @@ const NAME_BEFORE = new Set(['into', 'table', 'view', 'references', 'exists']);
/**
* Refuses the word at `index` when it calls a function of `pg_catalog` a
* plugin may not call (`plugin-sql-functions.ts`): followed by `(`, unless
* it names an object after one of {@link NAME_BEFORE}, or in Postgres's
* column notation for a call, right after `).` or `].` (`(16386::oid).obj_description`).
* plugin may not call (`plugin-sql-functions.ts`), unless it names an object
* after one of {@link NAME_BEFORE}: followed by `(`, or after a dot, in
* Postgres's column notation for a call (`(16386::oid).obj_description`, and
* `u.obj_description` or `$1.obj_description`, where `u` is a function in
* FROM that returns a single value); after a dot, the column names
* `COLUMN_NAMES` in `plugin-sql-functions.ts` lists still pass.
*/
function checkCall(tokens: readonly Token[], index: number): void {
const token = tokens[index];
if (token.kind !== 'word') return;
const before = tokens[index - 2];
const columnNotation = isPunct(tokens[index - 1], '.') && (isPunct(before, ')') || isPunct(before, ']'));
const called = columnNotation || (isPunct(tokens[index + 1], '(') && !namesObject(tokens, index));
if (called && refusedCatalogCall(token.value)) {
if (token.kind !== 'word' || namesObject(tokens, index)) return;
const call = isPunct(tokens[index + 1], '(');
const field = !call && isPunct(tokens[index - 1], '.');
if ((call && refusedCatalogCall(token.value)) || (field && refusedCatalogField(token.value))) {
throw new PluginSqlRefused(
`"${token.value}" is a function of the Postgres catalog that a plugin may not call; ` +
(field
? `after a dot Postgres may read x.${token.value} as ${token.value}(x), so name such a column without its table or rename it; `
: '') +
"the plugin SDK's README lists the functions a plugin may call",
);
}
+24 -3
View File
@@ -24,7 +24,7 @@ import {
poolClients,
PostgresPluginDataStore,
} from '../../src/db/engine/postgres/plugin-data-store';
import { catalogFunctionNames } from '../../src/db/engine/postgres/plugin-sql-functions';
import { catalogFunctionNames, COLUMN_NAMES } from '../../src/db/engine/postgres/plugin-sql-functions';
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';
@@ -615,6 +615,9 @@ describe('plugin data on Postgres', () => {
"select has_table_privilege('public.users', 'select')",
"select currtid2('public.users', '(0,1)')",
"select to_regtype('public.users')",
// aclitem names roles: the cluster's first superuser, whether a role exists.
"select '=r'::aclitem::text",
"select cast('x=r/x' as aclitem)",
];
const stores = [data.open('pg-reg'), superuserStore('pg-reg-su')];
await Promise.all(
@@ -697,8 +700,8 @@ describe('plugin data on Postgres', () => {
expect(
unlisted,
'These functions of this Postgres are missing from server/assets/postgres/catalog-functions.txt. ' +
'Add each name there (one per line, keep it sorted), and to PLUGIN_FUNCTIONS in ' +
'src/db/engine/postgres/plugin-sql-functions.ts only if it works on its arguments alone ' +
'Add each name there (one per line, keep it sorted), and to server/assets/postgres/plugin-functions.txt ' +
'only if it works on its arguments alone ' +
'and reads neither the catalogs nor the server.',
).toEqual([]);
@@ -712,6 +715,9 @@ describe('plugin data on Postgres', () => {
`select obj_description(${oid}, 'pg_class')`,
`select col_description(${oid}, 1)`,
`select (${oid}::oid).obj_description`,
`select g.obj_description from generate_series(${oid}, ${oid}) g`,
`select u.obj_description from unnest(array[${oid}::oid]) u`,
'select g.txid_status from generate_series(1, 3) g',
`select "obj_description"(${oid})`,
"select shobj_description(10, 'pg_authid')",
`select format_type(${oid}, null)`,
@@ -723,6 +729,14 @@ describe('plugin data on Postgres', () => {
'select current_catalog',
].map((sql) => expect(store.query(sql), sql).rejects.toThrow(/a plugin may not (call|read)/)),
);
await expect(store.query('select $1.obj_description', [oid])).rejects.toThrow(/a plugin may not call/);
// The refused names a column may have after a dot read nothing when Postgres calls them that way.
const calls = await asSuper<{ f: string }>(
'select p.oid::regprocedure::text as f from pg_proc p ' +
`where p.pronamespace = 'pg_catalog'::regnamespace and p.proname in (${[...COLUMN_NAMES].map((n) => `'${n}'`).join(', ')}) ` +
'and p.pronargs >= 1 and p.pronargs - p.pronargdefaults <= 1 and format_type(p.prorettype, null) <> p.proname',
);
expect(calls, 'a COLUMN_NAMES entry that the column notation calls with one argument').toEqual([]);
// A table named like a refused function, and the functions a plugin needs, still work.
await store.exec('INSERT INTO version (body) VALUES ($1), ($2)', ['Alpha', 'beta']);
expect(
@@ -735,6 +749,13 @@ describe('plugin data on Postgres', () => {
{ b: 'alpha', n: 5, k: '1', d: true, u: true },
{ b: 'beta', n: 4, k: '2', d: true, u: true },
]);
await store.migrate('002', 'ALTER TABLE version ADD COLUMN name text');
expect(
await store.query("SELECT v.name, excluded.name AS e FROM version v, (SELECT 'x' AS name) excluded"),
).toEqual([
{ name: null, e: 'x' },
{ name: null, e: 'x' },
]);
await asSuper('comment on table users is null');
});
});
@@ -9,7 +9,8 @@
import {
catalogFunctionNames,
CATALOG_FUNCTIONS_FILE,
PLUGIN_FUNCTIONS,
pluginFunctionNames,
PLUGIN_FUNCTIONS_FILE,
} from '../../../../../src/db/engine/postgres/plugin-sql-functions';
import { parsePluginSql } from '../../../../../src/db/engine/postgres/plugin-sql-guard';
@@ -24,8 +25,19 @@ describe('functions a plugin may call on Postgres', () => {
expect(lines.every((line) => /^[A-Za-z0-9_]+$/.test(line))).toBe(true);
});
it('lists the allowed functions one per line without duplicates, comments aside', () => {
const names = fs
.readFileSync(PLUGIN_FUNCTIONS_FILE, 'utf8')
.split(/\r?\n/)
.filter((line) => line !== '' && !line.startsWith('#'));
expect(names.length).toBeGreaterThan(300);
expect(names.every((line) => /^[a-z0-9_]+$/.test(line))).toBe(true);
expect(new Set(names).size).toBe(names.length);
expect(pluginFunctionNames()).toEqual(new Set(names));
});
it('allows only functions the catalog has, so a typo cannot stand in for one', () => {
const missing = [...PLUGIN_FUNCTIONS].filter((name) => !catalogFunctionNames().has(name));
const missing = [...pluginFunctionNames()].filter((name) => !catalogFunctionNames().has(name));
expect(missing).toEqual([]);
});
@@ -55,6 +67,15 @@ describe('functions a plugin may call on Postgres', () => {
'select (16386::oid).obj_description',
'select (16386::oid)."obj_description"',
'select (array[16386::oid])[1].obj_description',
// The column notation after an alias or a parameter: a function in FROM
// that returns a single value, or the parameter, is the argument.
'select u.obj_description from unnest(array[16386::oid]) u',
'select g.obj_description from generate_series(1, 20000) g',
'select o.obj_description from rows from (unnest(array[16386::oid])) o',
'select $1.obj_description',
'select g."current_schemas" from unnest(array[true]) g',
'select g.txid_status from generate_series(1, 3) g',
'select n.x from notes n, unnest(array[1]) g where g.mxid_age > 0',
'select n.x from notes n where n.body = (select version())',
'create table t (v text default version())',
'insert into notes (body) values (current_database())',
@@ -93,6 +114,11 @@ describe('functions a plugin may call on Postgres', () => {
'CREATE TABLE notes (id bigint, v bigint REFERENCES version (id))',
'CREATE VIEW version (a) AS SELECT 1',
'select n.version, n.user_id, "user", "current_user" from notes n',
// The refused names a table may well have as a column, after a dot.
'select n.name, n.money, n.oid, n.xid, n.xml, n.version from notes n',
'select (n).name, $1.name from notes n',
"insert into notes (id, name) values (1, 'a') on conflict (id) do update set name = excluded.name",
'select n.body from trek_plugin_notes.notes n join trek_plugin_notes.version v on v.id = n.id',
'select version from notes',
'select mine(1, 2)',
"select '[1,2)'::span",
@@ -200,6 +200,12 @@ describe('plugin SQL guard', () => {
["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/],
// aclitem looks its roles up by name and names them in its output.
["select '=r'::aclitem", /"aclitem" may not be named/],
["select cast('x=r/x' as aclitem)", /"aclitem" may not be named/],
[`select array['=r']::"aclitem"[]`, /"aclitem" may not be named/],
["select '{=r}'::_aclitem", /"_aclitem" may not be named/],
['CREATE TABLE grants (a aclitem)', /"aclitem" 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.
+1 -1
View File
@@ -200,7 +200,7 @@ A plugin with the `db:own` permission keeps its own database. On SQLite that is
- **TREK's role creates the schemas**, so it needs the `CREATE` privilege on the database, which the role that owns the database has.
- **No plugin SQL on a privileged role.** While `TREK_DB_URL` connects as a role TREK refuses restores for (a superuser or a member of one, or a role that may reach the server's files or programs; see [A role that is not a superuser](#a-role-that-is-not-a-superuser)), every plugin database call fails with "Plugin databases (db:own) are refused on Postgres ...", and the boot log says so. A plugin's SQL runs as TREK's role, and such a role could change the system catalogs for the whole server. Connect TREK as a role that owns its database and is not a superuser, and restart; TREK reads the role once per pool connection.
- **A plugin's SQL stays in its schema**, in layers the database enforces as well as TREK's own check:
- TREK refuses a statement before it runs when it names another schema, the system catalogs, a function that could reach past the schema, or a type that looks an object up by name (`regclass`, `regtype`, `regconfig` and the other `reg*` types, `has_table_privilege` and its siblings). Of PostgreSQL's own functions a plugin may call only those on an allowlist, the ones that work on their arguments alone (string, number, date and time, JSON, array, aggregate, window, UUID, range, geometry, network address and full text search functions). Every other one is refused, so a function that reads the catalogs or the server (`obj_description`, `format_type`, `version()`, `current_database()`, `inet_server_addr()`, ...) cannot reveal the names or comments of TREK's objects, and neither can a function a later PostgreSQL adds; the keywords `current_user`, `session_user` and their siblings are refused too. It also refuses temporary objects (`CREATE TEMP`/`TEMPORARY` and `SELECT ... INTO TEMP`; a column named `temp` is fine), `INTO` anywhere but after the `INSERT` or `MERGE` that is the statement's verb, hexadecimal, octal and binary numbers, and control characters or non-ASCII whitespace outside strings, which Postgres reads differently from the check.
- TREK refuses a statement before it runs when it names another schema, the system catalogs, a function that could reach past the schema, or a type that looks an object up by name (`regclass`, `regtype`, `regconfig` and the other `reg*` types, `aclitem`, `has_table_privilege` and its siblings). Of PostgreSQL's own functions a plugin may call only those on an allowlist, the ones that work on their arguments alone (string, number, date and time, JSON, array, aggregate, window, UUID, range, geometry, network address and full text search functions). Every other one is refused, so a function that reads the catalogs or the server (`obj_description`, `format_type`, `version()`, `current_database()`, `inet_server_addr()`, ...) cannot reveal the names or comments of TREK's objects, and neither can a function a later PostgreSQL adds; the keywords `current_user`, `session_user` and their siblings are refused too. It also refuses temporary objects (`CREATE TEMP`/`TEMPORARY` and `SELECT ... INTO TEMP`; a column named `temp` is fine), `INTO` anywhere but after the `INSERT` or `MERGE` that is the statement's verb, hexadecimal, octal and binary numbers, and control characters or non-ASCII whitespace outside strings, which Postgres reads differently from the check.
- Right before an `ALTER`, `DROP`, `REFRESH`, `TRUNCATE` or `CREATE INDEX ... ON`, Postgres itself resolves the objects the statement changes, and TREK refuses it unless each one lies in the plugin's schema. An unqualified `int4` or `text` is the built-in type and is refused, whatever the role may do.
- Each statement is sent on its own over the extended query protocol, which runs one statement and no more.
- Every connection of TREK's pool searches the temporary schema last, and a plugin call drops the temporary tables and other session state of the connection it used before handing it back, so a temporary table can never stand in for one of TREK's.