qiyu-cli 0.2.1 → 0.2.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +345 -56
- package/dist/cli.js +48 -7
- package/dist/commands/api-notes.js +54 -0
- package/dist/commands/api.js +112 -38
- package/dist/commands/auth.js +150 -28
- package/dist/commands/credentials-source.js +30 -5
- package/dist/commands/db-notes.js +75 -0
- package/dist/commands/db.js +112 -113
- package/dist/commands/query-notes.js +58 -0
- package/dist/commands/query.js +427 -56
- package/dist/commands/skill.js +445 -51
- package/dist/commands/spec-types.js +101 -1
- package/dist/commands/stats.js +139 -30
- package/dist/commands/store-flags.js +18 -0
- package/dist/commands/store-notes.js +38 -0
- package/dist/commands/store-precheck.js +254 -0
- package/dist/commands/store.js +128 -75
- package/dist/commands/sync-notes.js +367 -0
- package/dist/commands/sync-run.js +155 -44
- package/dist/commands/sync.js +181 -120
- package/dist/core/config.js +274 -24
- package/dist/core/credentials.js +38 -4
- package/dist/core/edition.js +1 -1
- package/dist/core/envelope.js +73 -9
- package/dist/core/errors.js +73 -16
- package/dist/core/http.js +151 -52
- package/dist/core/ratelimit.js +5 -1
- package/dist/core/registry/index.js +26 -2
- package/dist/core/registry/params/export.session.check.json +17 -2
- package/dist/core/registry/params/export.session.json +24 -2
- package/dist/core/registry/params/export.session.one.json +10 -2
- package/dist/core/registry/params/export.session.one.message.json +17 -2
- package/dist/core/registry/specs.json +64 -42
- package/dist/core/shell.js +30 -0
- package/dist/core/time.js +1 -1
- package/dist/core/validate.js +21 -2
- package/dist/output.js +204 -28
- package/dist/postinstall.js +14 -5
- package/dist/query/errors.js +145 -45
- package/dist/query/mask.js +1277 -25
- package/dist/query/metric-catalog.js +11 -0
- package/dist/query/native-error.js +189 -0
- package/dist/query/sandbox.js +129 -24
- package/dist/query/table-query.js +36 -5
- package/dist/schedule/install.js +136 -13
- package/dist/skill/check.js +11 -6
- package/dist/skill/detect.js +89 -29
- package/dist/skill/install.js +233 -43
- package/dist/skill/paths.js +54 -0
- package/dist/skill/qiyu/SKILL.md +29 -5
- package/dist/skill/qiyu/errors.md +5 -4
- package/dist/skill/qiyu/protocols.md +57 -5
- package/dist/skill/qiyu/setup.md +6 -2
- package/dist/store/config.js +92 -16
- package/dist/store/duckdb.js +51 -5
- package/dist/store/retry.js +92 -4
- package/dist/store/schema.js +26 -3
- package/dist/sync/engine.js +257 -65
- package/dist/sync/registry.js +4 -0
- package/dist/sync/state.js +20 -0
- package/dist/sync/tasks/dim.js +23 -14
- package/dist/sync/tasks/knowledge.js +50 -8
- package/dist/sync/tasks/pipeline.js +29 -9
- package/dist/sync/tasks/reports.js +176 -49
- package/dist/sync/tasks/sessions.js +88 -21
- package/dist/sync/tasks/tickets.js +59 -8
- package/dist/sync/types.js +60 -1
- package/dist/sync/windowing.js +0 -22
- package/dist/sync/write-contract.js +47 -0
- package/package.json +1 -1
package/dist/query/mask.js
CHANGED
|
@@ -1,3 +1,4 @@
|
|
|
1
|
+
import { dbDescribeCommand, queryTableCommand } from '../output.js';
|
|
1
2
|
/** spec §7.1:无格式敏感值的整值替换标记。导出供命令层/测试复用,避免文案漂移。 */
|
|
2
3
|
export const FULL = '<已脱敏>';
|
|
3
4
|
/** spec §7.1 的三个可识别形态。均无 g 标志 —— test 不携带 lastIndex 状态。 */
|
|
@@ -6,7 +7,7 @@ const EMAIL_RE = /^[^@\s]+@[^@\s]+$/;
|
|
|
6
7
|
const IPV4_RE = /^\d{1,3}(\.\d{1,3}){3}$/;
|
|
7
8
|
/** --no-mask 的 PII 风险警告(spec §7.2)。导出供命令层/测试复用。 */
|
|
8
9
|
export const NO_MASK_WARNING = '输出包含未脱敏的客户 PII;不要写入日志或对外报表';
|
|
9
|
-
/**
|
|
10
|
+
/** 缺口警告的**每类别**上限(spec §7.2:去重、上限 5 条)——按类别计,不让一类吃掉另一类的预算。 */
|
|
10
11
|
const WARNING_LIMIT = 5;
|
|
11
12
|
// 列名 → 规则(brief 给定,与 spec §7.1 的可识别形态对应)。用显式集合而不是
|
|
12
13
|
// `endsWith('Email')` 之类的模式:敏感列清单是实测出来的有限集,模式匹配会随上游
|
|
@@ -125,12 +126,921 @@ function sqlSensitiveNames(tables) {
|
|
|
125
126
|
}
|
|
126
127
|
return names;
|
|
127
128
|
}
|
|
129
|
+
/**
|
|
130
|
+
* 只在**顶层**(括号外、字面量/注释已被抹成空格)执行正则,返回的 `index` 是**绝对**下标。
|
|
131
|
+
*
|
|
132
|
+
* 用于定位子句起点与 `DISTINCT` 关键字:子查询里的同名子句不算本层的。
|
|
133
|
+
*/
|
|
134
|
+
function execTopLevel(scan, re) {
|
|
135
|
+
let depth = 0;
|
|
136
|
+
let inDouble = false;
|
|
137
|
+
for (let i = 0; i < scan.length; i++) {
|
|
138
|
+
const ch = scan[i];
|
|
139
|
+
if (inDouble) {
|
|
140
|
+
if (ch === '"') {
|
|
141
|
+
if (scan[i + 1] === '"')
|
|
142
|
+
i++;
|
|
143
|
+
else
|
|
144
|
+
inDouble = false;
|
|
145
|
+
}
|
|
146
|
+
continue;
|
|
147
|
+
}
|
|
148
|
+
if (ch === '"') {
|
|
149
|
+
inDouble = true;
|
|
150
|
+
continue;
|
|
151
|
+
}
|
|
152
|
+
if (ch === '(') {
|
|
153
|
+
depth++;
|
|
154
|
+
continue;
|
|
155
|
+
}
|
|
156
|
+
if (ch === ')') {
|
|
157
|
+
depth = Math.max(0, depth - 1);
|
|
158
|
+
continue;
|
|
159
|
+
}
|
|
160
|
+
if (depth !== 0 || !/[A-Za-z]/.test(ch))
|
|
161
|
+
continue;
|
|
162
|
+
if (i > 0 && /[A-Za-z0-9_$]/.test(scan[i - 1]))
|
|
163
|
+
continue;
|
|
164
|
+
// ⚠️ 必须要求 `m.index === 0`:起点正则有的带 `^` 有的不带(`GROUP BY` 那条没有)。
|
|
165
|
+
// 不校验就会把「切片里任意位置」的匹配错误地改写成「起始于 i」—— 于是第一个字母
|
|
166
|
+
// 位置就「命中」,切片从错误处开始(实测:所有普通 GROUP BY 查询都不再告警)。
|
|
167
|
+
// 校验通过后再把下标改写成**绝对**下标 i(调用方按 `m.index + m[0].length` 定位)。
|
|
168
|
+
const m = new RegExp(re.source, re.flags.replace(/[gy]/g, '')).exec(scan.slice(i));
|
|
169
|
+
if (m !== null && m.index === 0) {
|
|
170
|
+
m.index = i;
|
|
171
|
+
return m;
|
|
172
|
+
}
|
|
173
|
+
}
|
|
174
|
+
return null;
|
|
175
|
+
}
|
|
176
|
+
/**
|
|
177
|
+
* 顶层子句切片:从 `startRe` 匹配处之后切到下一个**顶层**子句关键字(或在结尾)。
|
|
178
|
+
*
|
|
179
|
+
* ⚠️ 为什么需要(Codex 2026-11-05 P2):分组失真的判据必须看**分组键**本身,
|
|
180
|
+
* 而不是「SQL 里出现过敏感列」—— `SELECT session_type, COUNT(*) … WHERE userPhone = '…'
|
|
181
|
+
* GROUP BY session_type` 里敏感列只用于过滤,脱敏不会改变分组键或计数;按整条 SQL 判
|
|
182
|
+
* 会把这类查询谎报成「分组失真」,警告还建议 `--no-mask`,等于诱导用户白关脱敏。
|
|
183
|
+
*
|
|
184
|
+
* 扫描规则(启发式,边界如实记录):
|
|
185
|
+
* · 单/双引号内的内容跳过(`` 'FROM' `` 这种字面量不算子句边界);
|
|
186
|
+
* · 括号内不算边界(`GROUP BY (CASE …)` 里的关键字不截断);
|
|
187
|
+
* · 只认裸词边界(前面不是标识符字符)。SQL 注释里的关键字仍可能被误认 ——
|
|
188
|
+
* `--sql` 是单条语句、注释罕见,且误判方向只影响要不要发提示。
|
|
189
|
+
*/
|
|
190
|
+
function sliceClause(sql, startRe, stopSource = 'ORDER\\s+BY|LIMIT|HAVING|QUALIFY|WINDOW|UNION|EXCEPT|INTERSECT|FROM') {
|
|
191
|
+
// 定位作用在「抹掉字面量/注释但等长」的文本上,切片仍取原文(偏移逐位对齐)。
|
|
192
|
+
const scan = withoutLiterals(sql);
|
|
193
|
+
// ⚠️ 起点必须找**顶层**的那个(括号外):`SELECT userPhone … FROM (SELECT … GROUP BY
|
|
194
|
+
// session_type) t GROUP BY userPhone` 里第一个 `GROUP BY` 在子查询里,取它就会漏掉
|
|
195
|
+
// 外层真正决定分组的那一个(Codex 2026-11-05 第四轮 P2 实测:漏报分组失真)。
|
|
196
|
+
const m = execTopLevel(scan, startRe);
|
|
197
|
+
if (m === null)
|
|
198
|
+
return '';
|
|
199
|
+
const from = m.index + m[0].length;
|
|
200
|
+
let depth = 0;
|
|
201
|
+
let inSingle = false;
|
|
202
|
+
let inDouble = false;
|
|
203
|
+
for (let i = from; i < sql.length; i++) {
|
|
204
|
+
const ch = sql[i];
|
|
205
|
+
if (inSingle) {
|
|
206
|
+
if (ch === "'") {
|
|
207
|
+
if (sql[i + 1] === "'")
|
|
208
|
+
i++;
|
|
209
|
+
else
|
|
210
|
+
inSingle = false;
|
|
211
|
+
}
|
|
212
|
+
continue;
|
|
213
|
+
}
|
|
214
|
+
if (inDouble) {
|
|
215
|
+
if (ch === '"') {
|
|
216
|
+
if (sql[i + 1] === '"')
|
|
217
|
+
i++;
|
|
218
|
+
else
|
|
219
|
+
inDouble = false;
|
|
220
|
+
}
|
|
221
|
+
continue;
|
|
222
|
+
}
|
|
223
|
+
if (ch === "'") {
|
|
224
|
+
inSingle = true;
|
|
225
|
+
continue;
|
|
226
|
+
}
|
|
227
|
+
if (ch === '"') {
|
|
228
|
+
inDouble = true;
|
|
229
|
+
continue;
|
|
230
|
+
}
|
|
231
|
+
if (ch === '(') {
|
|
232
|
+
depth++;
|
|
233
|
+
continue;
|
|
234
|
+
}
|
|
235
|
+
// ⚠️ 深度 0 遇到 `)` = 切片起点在子查询里、子查询到此结束 —— 必须就此收尾:
|
|
236
|
+
// `SELECT * FROM (… GROUP BY session_type) t WHERE userPhone = '1'` 里,越过这个
|
|
237
|
+
// 右括号会把外层 WHERE 并进分组子句,userPhone 就被误认成分组键并谎报分组失真
|
|
238
|
+
//(CodeRabbit PR #68 第二轮指出)。
|
|
239
|
+
if (ch === ')') {
|
|
240
|
+
if (depth === 0)
|
|
241
|
+
return sql.slice(from, i);
|
|
242
|
+
depth--;
|
|
243
|
+
continue;
|
|
244
|
+
}
|
|
245
|
+
if (depth !== 0 || !/[A-Za-z]/.test(ch))
|
|
246
|
+
continue;
|
|
247
|
+
if (i > from && /[A-Za-z0-9_$]/.test(sql[i - 1]))
|
|
248
|
+
continue;
|
|
249
|
+
if (new RegExp('^(?:' + stopSource + ')\\b', 'i').test(scan.slice(i)))
|
|
250
|
+
return sql.slice(from, i);
|
|
251
|
+
}
|
|
252
|
+
return sql.slice(from);
|
|
253
|
+
}
|
|
254
|
+
/** SQL 关键字:解析 `SELECT userPhone FROM t` 时别把 `FROM` 当成别名。 */
|
|
255
|
+
const SQL_KEYWORDS = new Set([
|
|
256
|
+
'as', 'from', 'where', 'group', 'order', 'by', 'limit', 'having', 'on', 'join', 'left',
|
|
257
|
+
'right', 'inner', 'outer', 'full', 'cross', 'using', 'union', 'except', 'intersect',
|
|
258
|
+
'qualify', 'window', 'select', 'distinct', 'and', 'or', 'not', 'is', 'null', 'case',
|
|
259
|
+
'when', 'then', 'else', 'end', 'asc', 'desc', 'nulls', 'first', 'last', 'like', 'ilike',
|
|
260
|
+
'in', 'between', 'over', 'partition', 'filter', 'cast', 'collate',
|
|
261
|
+
]);
|
|
262
|
+
/** 聚合函数(判断「这个 SELECT 项是聚合值还是分组键」用,DuckDB 常用集)。 */
|
|
263
|
+
const AGGREGATE_FUNCS = new Set([
|
|
264
|
+
'count', 'sum', 'avg', 'mean', 'min', 'max', 'median', 'product', 'list', 'array_agg',
|
|
265
|
+
'string_agg', 'group_concat', 'first', 'last', 'any_value', 'any', 'every', 'bool_and',
|
|
266
|
+
'bool_or', 'bit_and', 'bit_or', 'bit_xor', 'approx_count_distinct', 'approx_quantile',
|
|
267
|
+
'quantile', 'quantile_cont', 'quantile_disc', 'mode', 'histogram', 'stddev', 'stddev_pop',
|
|
268
|
+
'stddev_samp', 'variance', 'var_pop', 'var_samp', 'corr', 'covar_pop', 'covar_samp',
|
|
269
|
+
'skewness', 'kurtosis', 'entropy', 'arg_min', 'arg_max', 'min_by', 'max_by',
|
|
270
|
+
'regr_avgx', 'regr_avgy', 'regr_count', 'regr_intercept', 'regr_r2', 'regr_slope',
|
|
271
|
+
'regr_sxx', 'regr_sxy', 'regr_syy',
|
|
272
|
+
]);
|
|
273
|
+
/**
|
|
274
|
+
* SELECT 项是否以**聚合函数**开头(`max(userPhone) AS userPhone` 是聚合值,不是分组键)。
|
|
275
|
+
* 只看开头:`userPhone || '-x'` 这类表达式是投影出来的分组键(会被打码),不能当成聚合。
|
|
276
|
+
*/
|
|
277
|
+
const AGGREGATE_CALL = new RegExp(`\\b(?:${[...AGGREGATE_FUNCS].join('|')})\\s*\\(`, 'i');
|
|
278
|
+
/**
|
|
279
|
+
* SELECT 项是不是**聚合表达式**(`max(userPhone)`、`coalesce(max(userPhone), NULL)` 都算)。
|
|
280
|
+
*
|
|
281
|
+
* ⚠️ 必须搜**整个表达式**,不能只看开头(Codex 2026-11-05 第三轮 P2 实测):
|
|
282
|
+
* `SELECT coalesce(max(userPhone), NULL) AS userPhone … GROUP BY ALL` 实测返回一行 ——
|
|
283
|
+
* 它明明是聚合值,开头是 coalesce,只看函数名会被当成非聚合项 → 误报分组失真并建议 --no-mask。
|
|
284
|
+
* 覆盖整个表达式是安全的方向:含聚合函数的项不可能同时是分组键(DuckDB 会拒绝)。
|
|
285
|
+
*/
|
|
286
|
+
function isAggregateItem(item) {
|
|
287
|
+
// ⚠️ 双引号标识符(输出别名)里的文本也要剥掉(Codex 2026-11-08 第六轮 P2):
|
|
288
|
+
// `SELECT userPhone AS "Bob's COUNT(*)'s label", COUNT(*) AS n … GROUP BY userPhone`
|
|
289
|
+
// 是 DuckDB 实测合法查询,别名文本里的 `COUNT(*` 会让投影项被误判成聚合、把真实
|
|
290
|
+
// 手机号投影排除出 `projected` → 分组失真警告静默丢失。别名永远是标识符,不可能
|
|
291
|
+
// 是聚合函数调用本身,剥掉方向安全。
|
|
292
|
+
return AGGREGATE_CALL.test(bareKeywords(item));
|
|
293
|
+
}
|
|
294
|
+
/**
|
|
295
|
+
* 抹掉单引号字符串字面量与 SQL 注释(判据只看标识符,不看字面量/注释里的文本)。
|
|
296
|
+
*
|
|
297
|
+
* ⚠️ Codex 2026-11-05 第二轮 P3 实测:`SELECT COUNT(*) … GROUP BY 'userPhone'` 是
|
|
298
|
+
* **按常量分组**(实测一行 `n=2`),但字面量里恰好写着列名时,按原文本搜索会谎报分组失真。
|
|
299
|
+
* 双引号是**标识符**(`"userPhone"` 就是那一列),不抹。
|
|
300
|
+
*/
|
|
301
|
+
/**
|
|
302
|
+
* 把用户/元数据给出的标识符转义成可安全拼进 `RegExp` 的字面量。
|
|
303
|
+
*
|
|
304
|
+
* ⚠️ 别名由用户提供(`SELECT userPhone AS "p("`),DuckDB 实测接受带正则元字符的别名;
|
|
305
|
+
* 不转义时 `new RegExp('\\bp(\\b')` 直接抛 `SyntaxError` —— 查询本身**已经成功**,
|
|
306
|
+
* 却因为脱敏阶段崩掉而让整条命令报 internal、一行数据都拿不回来
|
|
307
|
+
*(CodeRabbit PR #68 第六轮 minor,实测 `"p("`/`"[x"` 两种形态都抛)。
|
|
308
|
+
*/
|
|
309
|
+
function escapeRe(s) {
|
|
310
|
+
return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
|
|
311
|
+
}
|
|
312
|
+
/** 只定位代码位置上的调用;注释和字面量不参与匹配,双引号名字按完整标识符比较。 */
|
|
313
|
+
export function sqlFunctionCalls(text, name) {
|
|
314
|
+
const code = withoutLiterals(text);
|
|
315
|
+
const out = [];
|
|
316
|
+
for (let i = 0; i < code.length;) {
|
|
317
|
+
const start = i;
|
|
318
|
+
let value;
|
|
319
|
+
if (code[i] === '"') {
|
|
320
|
+
for (i++; i < code.length; i++) {
|
|
321
|
+
if (code[i] === '"') {
|
|
322
|
+
if (code[i + 1] !== '"')
|
|
323
|
+
break;
|
|
324
|
+
i++;
|
|
325
|
+
}
|
|
326
|
+
}
|
|
327
|
+
value = code.slice(start + 1, i).replace(/""/g, '"');
|
|
328
|
+
i = Math.min(i + 1, code.length);
|
|
329
|
+
}
|
|
330
|
+
else if (isIdentAt(code, i)) {
|
|
331
|
+
do {
|
|
332
|
+
i += String.fromCodePoint(code.codePointAt(i)).length;
|
|
333
|
+
} while (isIdentAt(code, i));
|
|
334
|
+
value = code.slice(start, i);
|
|
335
|
+
}
|
|
336
|
+
else {
|
|
337
|
+
i++;
|
|
338
|
+
continue;
|
|
339
|
+
}
|
|
340
|
+
if (value.toLowerCase() !== name.toLowerCase())
|
|
341
|
+
continue;
|
|
342
|
+
const open = skipSqlTrivia(text, i);
|
|
343
|
+
if (text[open] === '(')
|
|
344
|
+
out.push({ nameStart: start, open: open + 1 });
|
|
345
|
+
}
|
|
346
|
+
return out;
|
|
347
|
+
}
|
|
348
|
+
/** 跳过 DuckDB 的 ASCII 空白与嵌套注释,返回下一个代码位置。 */
|
|
349
|
+
export function skipSqlTrivia(text, start) {
|
|
350
|
+
let i = start;
|
|
351
|
+
for (;;) {
|
|
352
|
+
while (i < text.length && ASCII_WS.has(text[i]))
|
|
353
|
+
i++;
|
|
354
|
+
if (text[i] === '/' && text[i + 1] === '*') {
|
|
355
|
+
i = skipBlockComment(text, i);
|
|
356
|
+
continue;
|
|
357
|
+
}
|
|
358
|
+
if (text[i] === '-' && text[i + 1] === '-') {
|
|
359
|
+
while (i < text.length && text[i] !== '\n' && text[i] !== '\r')
|
|
360
|
+
i++;
|
|
361
|
+
continue;
|
|
362
|
+
}
|
|
363
|
+
return i;
|
|
364
|
+
}
|
|
365
|
+
}
|
|
366
|
+
/** end 恒为闭定界符之后的下标;解码与 query() 内层 SQL 使用同一套字符串规则。 */
|
|
367
|
+
export function readSqlString(text, start) {
|
|
368
|
+
if (text[start] === '$' && !isIdentCharAt(text, start)) {
|
|
369
|
+
const dq = dollarQuoteEnd(text, start);
|
|
370
|
+
return dq === null ? null : {
|
|
371
|
+
end: dq.closeStart + (dq.openEnd - start), value: text.slice(dq.openEnd, dq.closeStart),
|
|
372
|
+
};
|
|
373
|
+
}
|
|
374
|
+
const prefixed = (text[start] === 'E' || text[start] === 'e') && text[start + 1] === "'";
|
|
375
|
+
const q = prefixed ? start + 1 : start;
|
|
376
|
+
if (text[q] !== "'")
|
|
377
|
+
return null;
|
|
378
|
+
const isEscape = q > 0 && (text[q - 1] === 'E' || text[q - 1] === 'e') && !isIdentCharAt(text, q - 1);
|
|
379
|
+
let i = q + 1;
|
|
380
|
+
for (; i < text.length; i++) {
|
|
381
|
+
if (isEscape && text[i] === '\\') {
|
|
382
|
+
i++;
|
|
383
|
+
continue;
|
|
384
|
+
}
|
|
385
|
+
if (text[i] === "'") {
|
|
386
|
+
if (text[i + 1] !== "'")
|
|
387
|
+
break;
|
|
388
|
+
i++;
|
|
389
|
+
}
|
|
390
|
+
}
|
|
391
|
+
if (i >= text.length)
|
|
392
|
+
return null;
|
|
393
|
+
return { end: i + 1, value: decodeStringLiteral(text.slice(q + 1, i), isEscape) };
|
|
394
|
+
}
|
|
395
|
+
/**
|
|
396
|
+
* 只展开整个实参都是字面量、括号或保值字符串 CAST 的形态。
|
|
397
|
+
* 不求值拼接或其它函数;不能把表达式的静态前缀冒认成实际执行的 SQL。
|
|
398
|
+
*/
|
|
399
|
+
function readStaticArg(text, open) {
|
|
400
|
+
let i = skipSqlTrivia(text, open);
|
|
401
|
+
const wrappers = [];
|
|
402
|
+
for (;;) {
|
|
403
|
+
if (text[i] === '(') {
|
|
404
|
+
wrappers.push('paren');
|
|
405
|
+
i = skipSqlTrivia(text, i + 1);
|
|
406
|
+
continue;
|
|
407
|
+
}
|
|
408
|
+
if (/^cast/i.test(text.slice(i, i + 4)) && !isIdentAt(text, i + 4)) {
|
|
409
|
+
const next = skipSqlTrivia(text, i + 4);
|
|
410
|
+
if (text[next] !== '(')
|
|
411
|
+
return null;
|
|
412
|
+
wrappers.push('cast');
|
|
413
|
+
i = skipSqlTrivia(text, next + 1);
|
|
414
|
+
continue;
|
|
415
|
+
}
|
|
416
|
+
break;
|
|
417
|
+
}
|
|
418
|
+
const lit = readSqlString(text, i);
|
|
419
|
+
if (lit === null)
|
|
420
|
+
return null;
|
|
421
|
+
i = skipSqlTrivia(text, lit.end);
|
|
422
|
+
for (let w = wrappers.length - 1; w >= 0; w--) {
|
|
423
|
+
if (wrappers[w] === 'cast') {
|
|
424
|
+
if (text.slice(i, i + 2).toLowerCase() !== 'as' || isIdentAt(text, i + 2))
|
|
425
|
+
return null;
|
|
426
|
+
i = skipSqlTrivia(text, i + 2);
|
|
427
|
+
const type = /^(varchar|text|string)/i.exec(text.slice(i));
|
|
428
|
+
if (type === null || isIdentAt(text, i + type[0].length))
|
|
429
|
+
return null;
|
|
430
|
+
i = skipSqlTrivia(text, i + type[0].length);
|
|
431
|
+
}
|
|
432
|
+
if (text[i] !== ')')
|
|
433
|
+
return null;
|
|
434
|
+
i = skipSqlTrivia(text, i + 1);
|
|
435
|
+
}
|
|
436
|
+
return text[i] === ')' ? lit.value : null;
|
|
437
|
+
}
|
|
438
|
+
/**
|
|
439
|
+
* 剥掉**所有**引号内容(单引号串、美元引号串、双引号标识符)与注释,只留裸 token。
|
|
440
|
+
* 与 `withoutLiterals` 的区别:双引号标识符也抹掉(那个函数保留它是为了列名匹配)。
|
|
441
|
+
* 用于「这个词是不是 SQL 关键字」的判断 —— `SELECT "SUMMARIZE" AS x`、注释里的
|
|
442
|
+
* `query('SUMMARIZE …')`、字符串字面量里的同名词都不是关键字(Codex 2026-11-08 第三轮 P2)。
|
|
443
|
+
* ⚠️ 抹除保持等长(空格),返回文本的下标与原文逐位对齐。
|
|
444
|
+
*/
|
|
445
|
+
function bareKeywords(text) {
|
|
446
|
+
const lit = withoutLiterals(text);
|
|
447
|
+
let out = '';
|
|
448
|
+
for (let i = 0; i < lit.length; i++) {
|
|
449
|
+
if (lit[i] !== '"') {
|
|
450
|
+
out += lit[i];
|
|
451
|
+
continue;
|
|
452
|
+
}
|
|
453
|
+
const start = i;
|
|
454
|
+
for (i++; i < lit.length; i++) {
|
|
455
|
+
if (lit[i] === '"') {
|
|
456
|
+
if (lit[i + 1] !== '"')
|
|
457
|
+
break;
|
|
458
|
+
i++;
|
|
459
|
+
}
|
|
460
|
+
}
|
|
461
|
+
out += ' '.repeat(Math.min(i, lit.length - 1) - start + 1);
|
|
462
|
+
}
|
|
463
|
+
return out;
|
|
464
|
+
}
|
|
465
|
+
/**
|
|
466
|
+
* `SUMMARIZE` 是**语句头关键字**(`SUMMARIZE sessions` / `SELECT * FROM (SUMMARIZE …)`),
|
|
467
|
+
* 不是任意位置出现的裸词 —— `SELECT 0 AS SUMMARIZE, 'userName' AS column_name, 3 AS min`
|
|
468
|
+
* 是合法别名(DuckDB 实测),按裸词判会把这条元数据查询误判成统计输出、把数字 3 改成
|
|
469
|
+
* `<已脱敏>`(Codex 2026-11-08 第五轮 P2)。判据作用在 bareKeywords(字面量/注释/双引号
|
|
470
|
+
* 标识符全剥)上,要求是文首,或深度 1 的 `FROM (`/`JOIN (`。旧判据的 `;` 后语句头不认:
|
|
471
|
+
* 多语句被沙箱语句数闸门拒绝(src/query/sandbox.ts 语句数闸门),带 `;` 的 SQL 到不了脱敏。
|
|
472
|
+
*
|
|
473
|
+
* 返回两个信号(调用方据此**声明缺口**,见 maskQueryRows):
|
|
474
|
+
* · recognized:可识别的语句头 —— 行级脱敏按 `column_name` 行值生效;
|
|
475
|
+
* · unrecognizedParen:过标识符边界、前面(跳空白)紧邻 `(`,但不在可识别的层级
|
|
476
|
+
* (如 `FROM (SELECT * FROM (SUMMARIZE …))`、逗号连接的 `, (SUMMARIZE …)`、CTE 内的
|
|
477
|
+
* 子查询)。这类位置**合法**且输出仍是 SUMMARIZE 形状(真机实测 min/max 明文),
|
|
478
|
+
* 本判据不脱敏 —— 必须由调用方发缺口警告,绝不静默(CodeRabbit 2026-11-08 第七轮
|
|
479
|
+
* major;`WITH t AS (SUMMARIZE …)` 已被真机否决为 Parser Error —— A CTE needs a SELECT)。
|
|
480
|
+
* ⚠️ `AS SUMMARIZE` 别名前面不是 `(`,不会进这一档(方向安全,误报会改写元数据数字)。
|
|
481
|
+
*/
|
|
482
|
+
function summarizeTokenPositions(sql) {
|
|
483
|
+
const bare = bareKeywords(sql);
|
|
484
|
+
const re = /SUMMARIZE/gi;
|
|
485
|
+
let recognized = false;
|
|
486
|
+
let unrecognizedParen = false;
|
|
487
|
+
let m;
|
|
488
|
+
while ((m = re.exec(bare)) !== null) {
|
|
489
|
+
// ⚠️ `\b` 不够:`SUMMARIZE$q$` 是合法标识符(`$` 不是词字符,`\b` 会误判成
|
|
490
|
+
// 完整关键字,DuckDB 实测 `SELECT (SUMMARIZE$q$) AS marker, …` 返回普通行)——
|
|
491
|
+
// 前后都必须按 DuckDB 的标识符字符判据检查(Codex 2026-11-08 第六轮 P2)。
|
|
492
|
+
if (isIdentCharAt(bare, m.index))
|
|
493
|
+
continue;
|
|
494
|
+
if (isIdentAt(bare, m.index + m[0].length))
|
|
495
|
+
continue;
|
|
496
|
+
const before = bare.slice(0, m.index);
|
|
497
|
+
// 顶层语句头:前面只有空白。
|
|
498
|
+
if (/^\s*$/.test(before)) {
|
|
499
|
+
recognized = true;
|
|
500
|
+
continue;
|
|
501
|
+
}
|
|
502
|
+
// 顶层 `FROM (SUMMARIZE …)` / `JOIN (SUMMARIZE …)`(深度 1,且 `(` 顶层直接跟在
|
|
503
|
+
// FROM/JOIN 后)。深度用括号计数 —— bareKeywords 已把字面量/注释/双引号标识符抹空,
|
|
504
|
+
// 剩下的括号都是真括号。更深层的不认:认了会把元数据查询的数字误改
|
|
505
|
+
//(Codex 2026-11-08 第六轮 P2),但必须落在 unrecognizedParen 里由调用方声明缺口。
|
|
506
|
+
const depth = (before.match(/\(/g)?.length ?? 0) - (before.match(/\)/g)?.length ?? 0);
|
|
507
|
+
if (depth === 1 && /(?:\bFROM|\bJOIN)\s*\(\s*$/i.test(before)) {
|
|
508
|
+
recognized = true;
|
|
509
|
+
continue;
|
|
510
|
+
}
|
|
511
|
+
if (/\(\s*$/.test(before))
|
|
512
|
+
unrecognizedParen = true;
|
|
513
|
+
}
|
|
514
|
+
return { recognized, unrecognizedParen };
|
|
515
|
+
}
|
|
516
|
+
/**
|
|
517
|
+
* `query('…')` 内层 SQL 里出现 SUMMARIZE 关键字(`SELECT * FROM query('SUMMARIZE sessions')`)。
|
|
518
|
+
*
|
|
519
|
+
* ⚠️ 第十二轮起 query() 的来源**不再进入行级脱敏**:内层 SQL 的输出来源十余轮复审都被
|
|
520
|
+
* 构造出合法反例(`SELECT 常量 FROM (SUMMARIZE …)` 等),无法静态证明。因此这里只服务
|
|
521
|
+
* 一个目的 —— **发现缺口**(返回 `hit` / `gap` 即调用方发对应警告):
|
|
522
|
+
* · `hit`:内层可静态展开,且自身输出是 SUMMARIZE;
|
|
523
|
+
* · `gap`:内层有 SUMMARIZE 痕迹但输出无法确认(含探测到 query() 实参展不开);
|
|
524
|
+
* · `unresolved`:至少一个 query() 实参展不开 —— 此时「内层含 SUMMARIZE」只是猜测、
|
|
525
|
+
* 不是检出,文案必须说「可能含」(CodeRabbit 第十六轮 minor:展不开 ≠ 检出)。
|
|
526
|
+
* 两种情形都**不改写任何值** —— 实测
|
|
527
|
+
* `SELECT 'userName' AS column_name, 3 AS min WHERE EXISTS (SELECT 1 FROM query('SUMMARIZE sessions'))`
|
|
528
|
+
* 合法且输出 min 是常量 3,按全 SQL 判据脱敏会把业务常量改成 `<已脱敏>`(Codex 第七轮 P2)。
|
|
529
|
+
*/
|
|
530
|
+
/** 遍历每个 `query(<静态字符串实参>)` 调用,回调**解码后的内层 SQL** 与调用位置;展不开的走 `onUnresolved`。 */
|
|
531
|
+
function forEachQueryArg(sql, cb, onUnresolved) {
|
|
532
|
+
for (const { open, nameStart } of sqlFunctionCalls(sql, 'query')) {
|
|
533
|
+
const inner = readStaticArg(sql, open);
|
|
534
|
+
if (inner === null)
|
|
535
|
+
onUnresolved?.();
|
|
536
|
+
else
|
|
537
|
+
cb(inner, nameStart);
|
|
538
|
+
}
|
|
539
|
+
}
|
|
540
|
+
/** query() 的静态实参;无法展开的完整表达式通过独立信号报告,不冒认前缀。 */
|
|
541
|
+
export function queryCallArgs(sql, onUnresolved) {
|
|
542
|
+
const out = [];
|
|
543
|
+
forEachQueryArg(sql, (inner) => out.push(inner), onUnresolved);
|
|
544
|
+
return out;
|
|
545
|
+
}
|
|
546
|
+
function queryCallSummarize(sql) {
|
|
547
|
+
const bare = bareKeywords(sql);
|
|
548
|
+
let hit = false;
|
|
549
|
+
let atTopOutput = false;
|
|
550
|
+
let gap = false;
|
|
551
|
+
let unresolved = false;
|
|
552
|
+
forEachQueryArg(sql, (inner, callIndex) => {
|
|
553
|
+
const innerTokens = summarizeTokenPositions(inner);
|
|
554
|
+
const sub = queryCallSummarize(inner);
|
|
555
|
+
// 里层的不可展开同样向上传播(CodeRabbit 第十七轮 minor):展不开只说明内容未知,
|
|
556
|
+
// 丢了它外层就会把里层的猜测重新当成检出。
|
|
557
|
+
if (sub.unresolved)
|
|
558
|
+
unresolved = true;
|
|
559
|
+
// ⚠️ innerTokens.recognized 对 `SELECT expr FROM (SUMMARIZE …)` 成立(SUMMARIZE 在
|
|
560
|
+
// 深度 1 的 FROM 内),但 SELECT 自身输出的是**表达式求值结果**、不是 SUMMARIZE 统计值。
|
|
561
|
+
// 例如 `SELECT * FROM query('SELECT ''userName'' AS column_name, 3 AS min FROM
|
|
562
|
+
// (SUMMARIZE (SELECT 1 AS userName))')` 输出 min=3(常量)—— 按统计值脱敏会篡改它
|
|
563
|
+
//(Codex 2026-11-09 第十一轮 P2)。验证:内层 SQL 要么自身就是 SUMMARIZE(语句头),
|
|
564
|
+
// 要么是纯透传 —— 复用唯一判据 passthroughReason(`SELECT *` 单一 SUMMARIZE 来源)。
|
|
565
|
+
const innerIsPure = passthroughReason(inner) === null;
|
|
566
|
+
if ((innerTokens.recognized && innerIsPure) || sub.atTopOutput) {
|
|
567
|
+
hit = true;
|
|
568
|
+
const before = bare.slice(0, callIndex);
|
|
569
|
+
const depth = (before.match(/\(/g)?.length ?? 0) - (before.match(/\)/g)?.length ?? 0);
|
|
570
|
+
if (depth === 0 && /(?:\bFROM|\bJOIN)\s*$/i.test(before))
|
|
571
|
+
atTopOutput = true;
|
|
572
|
+
}
|
|
573
|
+
else if ((innerTokens.recognized && !innerIsPure) || innerTokens.unrecognizedParen
|
|
574
|
+
|| sub.gap || (sub.hit && !sub.atTopOutput)) {
|
|
575
|
+
// 内层有 SUMMARIZE 痕迹但输出无法确认(深层子查询 / 内层 query() 不在输出路径)——
|
|
576
|
+
// 向上传播「无法确认」,由调用方声明缺口,绝不冒认脱敏。
|
|
577
|
+
gap = true;
|
|
578
|
+
}
|
|
579
|
+
}, () => {
|
|
580
|
+
// 实参无法静态展开(拼接 / 函数调用):内层可能含 SUMMARIZE(也可能不含)——
|
|
581
|
+
// 与「内层有 SUMMARIZE 但输出不确定」同属「没检查」,只声明缺口,不冒认脱敏。
|
|
582
|
+
gap = true;
|
|
583
|
+
unresolved = true;
|
|
584
|
+
});
|
|
585
|
+
return { hit, atTopOutput, gap, unresolved };
|
|
586
|
+
}
|
|
587
|
+
/**
|
|
588
|
+
* 把一个字符串字面量的**原始内容**(不含两端引号)解码为它表示的字符序列,即内层 SQL 源码。
|
|
589
|
+
* 真机实测(2026-11-08)DuckDB 的字符串词法:
|
|
590
|
+
* · `''`(两个引号)**在两种串里都表示一个引号字符** —— 折叠必须与转义解码在**同一次扫描**
|
|
591
|
+
* 里各做一次:若先解 E 转义再全局折叠 `''`,`\x27\x27`(两个引号字符)会被二次折成一个,
|
|
592
|
+
* 内层 SQL 的引号边界失衡 → 把字符串里的 SUMMARIZE 误认成语句(Codex 第八轮 P2)。
|
|
593
|
+
* · 普通串(无 E 前缀)**不做**转义解码(实测 `'a\x41b'` 保留字面量 `\x41`)。
|
|
594
|
+
* · E 串转义:`\xHH`(**仅小写 x**,1-2 位十六进制;实测大写 `\X41` → `X41`,走未知转义;
|
|
595
|
+
* Codex 第八轮 P2)、`\NNN`(1-3 位八进制)、`\n \r \t \b \f`、其余未知转义丢弃反斜杠
|
|
596
|
+
* 保留字符(实测 `\v` → `v`、`\q` → `q`、非法十六进制 `\xzz` → `xzz`);
|
|
597
|
+
* `\u`/`\U`/`\0` 在 DuckDB 是 Parser Error,这类 SQL 根本执行不了。
|
|
598
|
+
*/
|
|
599
|
+
function decodeStringLiteral(raw, isEscape) {
|
|
600
|
+
let out = '';
|
|
601
|
+
for (let i = 0; i < raw.length; i++) {
|
|
602
|
+
const ch = raw[i];
|
|
603
|
+
if (ch === "'" && raw[i + 1] === "'") {
|
|
604
|
+
out += "'";
|
|
605
|
+
i++;
|
|
606
|
+
continue;
|
|
607
|
+
}
|
|
608
|
+
if (!isEscape || ch !== '\\') {
|
|
609
|
+
out += ch;
|
|
610
|
+
continue;
|
|
611
|
+
}
|
|
612
|
+
const next = raw[i + 1];
|
|
613
|
+
if (next === undefined) {
|
|
614
|
+
out += ch;
|
|
615
|
+
continue;
|
|
616
|
+
}
|
|
617
|
+
if (next === 'x') {
|
|
618
|
+
const hex = /^[0-9A-Fa-f]{1,2}/.exec(raw.slice(i + 2));
|
|
619
|
+
if (hex !== null) {
|
|
620
|
+
out += String.fromCharCode(parseInt(hex[0], 16));
|
|
621
|
+
i += 1 + hex[0].length;
|
|
622
|
+
continue;
|
|
623
|
+
}
|
|
624
|
+
out += 'x';
|
|
625
|
+
i++;
|
|
626
|
+
continue;
|
|
627
|
+
}
|
|
628
|
+
if (next >= '0' && next <= '7') {
|
|
629
|
+
const oct = /^[0-7]{1,3}/.exec(raw.slice(i + 1));
|
|
630
|
+
out += String.fromCharCode(parseInt(oct[0], 8));
|
|
631
|
+
i += oct[0].length;
|
|
632
|
+
continue;
|
|
633
|
+
}
|
|
634
|
+
if (next === 'n') {
|
|
635
|
+
out += '\n';
|
|
636
|
+
i++;
|
|
637
|
+
continue;
|
|
638
|
+
}
|
|
639
|
+
if (next === 'r') {
|
|
640
|
+
out += '\r';
|
|
641
|
+
i++;
|
|
642
|
+
continue;
|
|
643
|
+
}
|
|
644
|
+
if (next === 't') {
|
|
645
|
+
out += '\t';
|
|
646
|
+
i++;
|
|
647
|
+
continue;
|
|
648
|
+
}
|
|
649
|
+
if (next === 'b') {
|
|
650
|
+
out += '\b';
|
|
651
|
+
i++;
|
|
652
|
+
continue;
|
|
653
|
+
}
|
|
654
|
+
if (next === 'f') {
|
|
655
|
+
out += '\f';
|
|
656
|
+
i++;
|
|
657
|
+
continue;
|
|
658
|
+
}
|
|
659
|
+
// `\\`、`\'`、`\"`、`\?` 及未知转义(含大写 `\X`):输出字符本身(丢弃反斜杠)
|
|
660
|
+
out += next;
|
|
661
|
+
i++;
|
|
662
|
+
}
|
|
663
|
+
return out;
|
|
664
|
+
}
|
|
665
|
+
/**
|
|
666
|
+
* 取 `i` 之前的**完整码点**(UTF-16 代理对被 `text[i-1]` 截成孤立低代理项时补齐高代理项)。
|
|
667
|
+
* 美元引号边界判据必须按码点判:补充平面字母(实测 DuckDB 接受 `𝒜$q$`,U+1D49C)由两个
|
|
668
|
+
* UTF-16 单元组成,只看 `text[i-1]` 会拿到孤立低代理项、`\p{L}` 判不出(Codex 2026-11-08
|
|
669
|
+
* 第五轮 P2)。
|
|
670
|
+
*/
|
|
671
|
+
function prevCodePoint(text, i) {
|
|
672
|
+
if (i >= 2) {
|
|
673
|
+
const hi = text.charCodeAt(i - 2);
|
|
674
|
+
const lo = text.charCodeAt(i - 1);
|
|
675
|
+
if (hi >= 0xd800 && hi <= 0xdbff && lo >= 0xdc00 && lo <= 0xdfff)
|
|
676
|
+
return text.slice(i - 2, i);
|
|
677
|
+
}
|
|
678
|
+
return i > 0 ? text[i - 1] : '';
|
|
679
|
+
}
|
|
680
|
+
/** ASCII 空白集合 —— DuckDB 的词法空白只有这几个。⚠️ 不能用 `\s`:JS 的 `\s` 把
|
|
681
|
+
* U+2028/U+2029 等也算空白,而 DuckDB 实测把它们当**标识符字符**(`1 AS x\u2028$q$`
|
|
682
|
+
* 合法,两个 `$q$` 都被当成标识符的一部分,Codex 2026-11-08 第六轮 P2)。 */
|
|
683
|
+
const ASCII_WS = new Set([' ', '\t', '\n', '\r', '\f', '\v']);
|
|
684
|
+
/** 单个码点是否 DuckDB 标识符字符(ASCII:字母/数字/`_`/`$`;非 ASCII:一律算,除 ASCII 空白)。 */
|
|
685
|
+
function isIdentCp(cp) {
|
|
686
|
+
if (cp === '')
|
|
687
|
+
return false;
|
|
688
|
+
if (/^[A-Za-z0-9_$]$/.test(cp))
|
|
689
|
+
return true;
|
|
690
|
+
const code = cp.codePointAt(0);
|
|
691
|
+
if (code === undefined || code < 0x80)
|
|
692
|
+
return false;
|
|
693
|
+
return !ASCII_WS.has(cp);
|
|
694
|
+
}
|
|
695
|
+
/**
|
|
696
|
+
* DuckDB 的标识符字符判据(美元引号边界用):ASCII 字母/数字/`_`/`$`,以及**任何非 ASCII、
|
|
697
|
+
* 非空白**字符 —— DuckDB(utf8proc 词法)把 Unicode 字母/数字/组合符/连接符乃至货币符号
|
|
698
|
+
* 都接受为标识符字符(实测 `¢$q$` U+00A2 合法),补充平面字母按代理对处理(实测 `𝒜$q$`)。
|
|
699
|
+
* ASCII 标点(`=`、`(`、`,`、空白等)不是标识符字符 —— 美元引号合法地跟在它们之后。
|
|
700
|
+
* 方向:把模棱两可的非 ASCII 字符按**标识符**处理(不认成引号开头)—— 误判成字面量会
|
|
701
|
+
* 抹掉后续内容并让分组/缺口分析静默失效,误判成标识符只是少抹一段(该段是非法 SQL)。
|
|
702
|
+
*/
|
|
703
|
+
export function isIdentCharAt(text, i) {
|
|
704
|
+
return isIdentCp(prevCodePoint(text, i));
|
|
705
|
+
}
|
|
706
|
+
/**
|
|
707
|
+
* `text[i]` 处的码点是否标识符字符(next 方向;`codePointAt` 天然按码点处理代理对)。
|
|
708
|
+
* 导出给 `commands/query.ts` 的键引用扫描:标识符判据只许一个实现点(ASCII 正则会漏掉
|
|
709
|
+
* `数据['stat_date']` 这类合法 Unicode 别名,Codex 2026-11-11 第十四轮 P2)。
|
|
710
|
+
*/
|
|
711
|
+
export function isIdentAt(text, i) {
|
|
712
|
+
if (i >= text.length)
|
|
713
|
+
return false;
|
|
714
|
+
return isIdentCp(String.fromCodePoint(text.codePointAt(i)));
|
|
715
|
+
}
|
|
716
|
+
/** 嵌套块注释:`/*` 开头可再嵌 `/*`(DuckDB 实测合法),按深度数到配对的 `*`+`/` 才算结束。返回注释结束后的下标。 */
|
|
717
|
+
function skipBlockComment(text, start) {
|
|
718
|
+
let i = start + 2;
|
|
719
|
+
let depth = 1;
|
|
720
|
+
while (i < text.length && depth > 0) {
|
|
721
|
+
if (text[i] === '/' && text[i + 1] === '*') {
|
|
722
|
+
depth++;
|
|
723
|
+
i += 2;
|
|
724
|
+
continue;
|
|
725
|
+
}
|
|
726
|
+
if (text[i] === '*' && text[i + 1] === '/') {
|
|
727
|
+
depth--;
|
|
728
|
+
i += 2;
|
|
729
|
+
continue;
|
|
730
|
+
}
|
|
731
|
+
i++;
|
|
732
|
+
}
|
|
733
|
+
return Math.min(i, text.length);
|
|
734
|
+
}
|
|
735
|
+
/**
|
|
736
|
+
* 美元引号字符串(`$$…$$` / `$tag$…$tag$`)的唯一扫描点:`text[start] === '$'`,返回终止定界符
|
|
737
|
+
* 之后的**开区间**下标(内容为 `text[start + 定界符长度, 结束)`),不成对时返回 -1。
|
|
738
|
+
*
|
|
739
|
+
* ⚠️ 两处共用(`withoutLiterals` 抹字面量、`queryCallSummarize` 读 query() 实参):同一套解码
|
|
740
|
+
* 规则复制到两处会让同一条 SQL 在两个判据里得到不同结论。调用方负责「标识符边界」判断
|
|
741
|
+
* (紧跟在标识符字符后的 `$` 属于标识符,不是引号开头)。
|
|
742
|
+
*/
|
|
743
|
+
export function dollarQuoteEnd(text, start) {
|
|
744
|
+
const m = /^\$([A-Za-z_][A-Za-z0-9_]*)?\$/.exec(text.slice(start));
|
|
745
|
+
if (m === null)
|
|
746
|
+
return null;
|
|
747
|
+
const closeStart = text.indexOf(m[0], start + m[0].length);
|
|
748
|
+
if (closeStart === -1)
|
|
749
|
+
return null;
|
|
750
|
+
return { openEnd: start + m[0].length, closeStart };
|
|
751
|
+
}
|
|
752
|
+
/**
|
|
753
|
+
* 抹掉单引号/美元引号字面量与 SQL 注释(判据只看标识符,不看字面量/注释里的文本)。
|
|
754
|
+
* 导出给 `commands/query.ts` 的日期字面量警告用(列名判据)。
|
|
755
|
+
*/
|
|
756
|
+
export function withoutLiterals(text) {
|
|
757
|
+
return blankSql(text, true);
|
|
758
|
+
}
|
|
759
|
+
/**
|
|
760
|
+
* 只抹注释(双引号标识符与字面量原样保留,下标逐位对齐)。
|
|
761
|
+
* `commands/query.ts` 的日期字面量警告在它上面定位孤立 `'` 再取字面量内容。
|
|
762
|
+
*/
|
|
763
|
+
export function withoutComments(text) {
|
|
764
|
+
return blankSql(text, false);
|
|
765
|
+
}
|
|
766
|
+
/**
|
|
767
|
+
* 抹掉单引号/美元引号字面量与注释的唯一词法状态机。`blankLiterals=false` 时
|
|
768
|
+
* **原样保留**字面量(含美元引号内容)——供需要在字面量内部读值的判据用。
|
|
769
|
+
*/
|
|
770
|
+
function blankSql(text, blankLiterals) {
|
|
771
|
+
let out = '';
|
|
772
|
+
// ⚠️ 被抹掉的字符一律换成等长空格:下标与原文**逐位对齐**,`sliceClause` 才能在抹过的
|
|
773
|
+
// 文本上定位 `GROUP BY`/`DISTINCT` 而不会命中字符串字面量里的同一串词(Codex 2026-11-05
|
|
774
|
+
// 第三轮 P2:`SELECT userPhone, 'GROUP BY userPhone' AS label …` 曾被误判成分组查询)。
|
|
775
|
+
const blank = (n) => ' '.repeat(n);
|
|
776
|
+
for (let i = 0; i < text.length; i++) {
|
|
777
|
+
const ch = text[i];
|
|
778
|
+
if (ch === "'") {
|
|
779
|
+
// E 串(`E'…'`):`\'` 是转义引号、不结束字符串(DuckDB 实测
|
|
780
|
+
// `E'it\'s FROM (SUMMARIZE sessions)'` 合法)—— 不按此跳过会把字符串后半段当成
|
|
781
|
+
// 裸 SQL,从中误判出 SUMMARIZE 关键字(Codex 2026-11-08 第九轮 P2)。
|
|
782
|
+
const isEscape = i >= 1 && (text[i - 1] === 'E' || text[i - 1] === 'e')
|
|
783
|
+
&& !isIdentCharAt(text, i - 1);
|
|
784
|
+
const start = i;
|
|
785
|
+
for (i++; i < text.length; i++) {
|
|
786
|
+
if (isEscape && text[i] === '\\') {
|
|
787
|
+
i++;
|
|
788
|
+
continue;
|
|
789
|
+
}
|
|
790
|
+
if (text[i] === "'") {
|
|
791
|
+
if (text[i + 1] !== "'")
|
|
792
|
+
break;
|
|
793
|
+
i++;
|
|
794
|
+
}
|
|
795
|
+
}
|
|
796
|
+
out += blankLiterals ? blank(i - start + 1) : text.slice(start, Math.min(i, text.length - 1) + 1);
|
|
797
|
+
continue;
|
|
798
|
+
}
|
|
799
|
+
// 双引号是**标识符**(`SELECT "userPhone"` 是真实列引用,抹掉会漏判)→ 原样保留,
|
|
800
|
+
// 但必须整段跳过:标识符里可以带 `'`(DuckDB 实测接受 `"it's"`),只抹单引号会让
|
|
801
|
+
// 那个 `'` 被当成字符串起点、把后面的 GROUP BY 一起抹掉 → 分组失真警告静默丢失
|
|
802
|
+
//(2026-11-07 审查)。
|
|
803
|
+
if (ch === '"') {
|
|
804
|
+
const start = i;
|
|
805
|
+
for (i++; i < text.length; i++) {
|
|
806
|
+
if (text[i] === '"') {
|
|
807
|
+
if (text[i + 1] !== '"')
|
|
808
|
+
break;
|
|
809
|
+
i++;
|
|
810
|
+
}
|
|
811
|
+
}
|
|
812
|
+
out += text.slice(start, Math.min(i, text.length - 1) + 1);
|
|
813
|
+
continue;
|
|
814
|
+
}
|
|
815
|
+
// 美元引号字符串(`$$…$$` / `$tag$…$tag$`,DuckDB 实测支持)是**字面量** → 抹掉。
|
|
816
|
+
// `$` 在标识符里也合法,形似引号却找不到配对结束符时按普通字符放行。
|
|
817
|
+
// ⚠️ 必须先判**标识符边界**(Codex 2026-11-08 P2 实测):PostgreSQL/DuckDB 规定
|
|
818
|
+
// 美元引号必须与前一个关键字/标识符用空白分隔 —— 紧跟在标识符字符后的 `$` 属于该
|
|
819
|
+
// 标识符。`SELECT userPhone, 1 AS marker$q$, COUNT(*) AS n FROM … GROUP BY …,
|
|
820
|
+
// marker$q$` 是合法 SQL,不做边界判据会把两个别名里的 `$q$` 当成一对引号,把中间的
|
|
821
|
+
// `GROUP BY` 整段抹掉 → 分组失真警告静默丢失(实测判据双边:去掉 alias 的对照组
|
|
822
|
+
// 警告在场)。字母/数字/下划线/`$` 与本文件其它词边界正则的字符类一致。
|
|
823
|
+
if (ch === '$') {
|
|
824
|
+
// 标识符字符按 DuckDB 的实际规则判定(见 isIdentCharAt):中文、补充平面字母、
|
|
825
|
+
// 货币符号等都是合法标识符字符(Codex 第三/五轮 P2 实测),紧跟在它们之后的 `$`
|
|
826
|
+
// 属于标识符,不是美元引号开头。
|
|
827
|
+
if (isIdentCharAt(text, i)) {
|
|
828
|
+
out += ch;
|
|
829
|
+
continue;
|
|
830
|
+
}
|
|
831
|
+
const dq = dollarQuoteEnd(text, i);
|
|
832
|
+
if (dq !== null) {
|
|
833
|
+
const delim = dq.openEnd - i;
|
|
834
|
+
const end = dq.closeStart + delim; // 整个 `$tag$…$tag$` 之后的第一个字符
|
|
835
|
+
out += blankLiterals ? blank(end - i) : text.slice(i, end);
|
|
836
|
+
i = end - 1;
|
|
837
|
+
continue;
|
|
838
|
+
}
|
|
839
|
+
out += ch;
|
|
840
|
+
continue;
|
|
841
|
+
}
|
|
842
|
+
if (ch === '-' && text[i + 1] === '-') {
|
|
843
|
+
// 行注释抹到行尾(**不含**换行符):`\n` 与 `\r` 都算行尾 —— DuckDB 实测
|
|
844
|
+
// `--c\rGROUP BY …` 会按 `\r` 之后的内容分组,只认 `\n` 会把 GROUP BY 一起抹掉。
|
|
845
|
+
while (i < text.length && text[i] !== '\n' && text[i] !== '\r') {
|
|
846
|
+
out += ' ';
|
|
847
|
+
i++;
|
|
848
|
+
}
|
|
849
|
+
if (i < text.length)
|
|
850
|
+
out += text[i];
|
|
851
|
+
else
|
|
852
|
+
i--;
|
|
853
|
+
continue;
|
|
854
|
+
}
|
|
855
|
+
if (ch === '/' && text[i + 1] === '*') {
|
|
856
|
+
// ⚠️ 必须按**嵌套深度**跳过(Codex 2026-11-08 第六轮 P2):`/* outer /* inner */ … */`
|
|
857
|
+
// 是 DuckDB 实测合法语法,停在第一个 `*/` 会把仍在注释里的内容当成 SQL 记号。
|
|
858
|
+
const end = skipBlockComment(text, i);
|
|
859
|
+
out += blank(end - i);
|
|
860
|
+
i = end - 1;
|
|
861
|
+
continue;
|
|
862
|
+
}
|
|
863
|
+
out += ch;
|
|
864
|
+
}
|
|
865
|
+
return out;
|
|
866
|
+
}
|
|
867
|
+
/** 顶层逗号切分(括号与引号内不算),用于 SELECT 列表与 GROUP BY 的项。 */
|
|
868
|
+
function splitTopLevel(text) {
|
|
869
|
+
const out = [];
|
|
870
|
+
let depth = 0;
|
|
871
|
+
let inSingle = false;
|
|
872
|
+
let inDouble = false;
|
|
873
|
+
let start = 0;
|
|
874
|
+
for (let i = 0; i < text.length; i++) {
|
|
875
|
+
const ch = text[i];
|
|
876
|
+
if (inSingle) {
|
|
877
|
+
if (ch === "'") {
|
|
878
|
+
if (text[i + 1] === "'")
|
|
879
|
+
i++;
|
|
880
|
+
else
|
|
881
|
+
inSingle = false;
|
|
882
|
+
}
|
|
883
|
+
continue;
|
|
884
|
+
}
|
|
885
|
+
if (inDouble) {
|
|
886
|
+
if (ch === '"') {
|
|
887
|
+
if (text[i + 1] === '"')
|
|
888
|
+
i++;
|
|
889
|
+
else
|
|
890
|
+
inDouble = false;
|
|
891
|
+
}
|
|
892
|
+
continue;
|
|
893
|
+
}
|
|
894
|
+
if (ch === "'") {
|
|
895
|
+
inSingle = true;
|
|
896
|
+
continue;
|
|
897
|
+
}
|
|
898
|
+
if (ch === '"') {
|
|
899
|
+
inDouble = true;
|
|
900
|
+
continue;
|
|
901
|
+
}
|
|
902
|
+
if (ch === '(') {
|
|
903
|
+
depth++;
|
|
904
|
+
continue;
|
|
905
|
+
}
|
|
906
|
+
if (ch === ')') {
|
|
907
|
+
depth = Math.max(0, depth - 1);
|
|
908
|
+
continue;
|
|
909
|
+
}
|
|
910
|
+
if (ch === ',' && depth === 0) {
|
|
911
|
+
out.push(text.slice(start, i));
|
|
912
|
+
start = i + 1;
|
|
913
|
+
}
|
|
914
|
+
}
|
|
915
|
+
out.push(text.slice(start));
|
|
916
|
+
return out;
|
|
917
|
+
}
|
|
918
|
+
/**
|
|
919
|
+
* SELECT 列表里「引用了敏感列的输出项」的别名(用于 `GROUP BY <别名>` 这种写法)。
|
|
920
|
+
*
|
|
921
|
+
* ⚠️ 按**选择项**(顶层逗号切分)而不是整串正则来解析(Codex 2026-11-05 第四轮 P2):
|
|
922
|
+
* 整串正则只认「列名紧跟别名」,`SELECT lower(userPhone) AS p … GROUP BY p` 这种
|
|
923
|
+
* **表达式别名**会漏报 —— 实测 DuckDB 按 `lower(userPhone)` 分成两组,脱敏后照样塌成一行。
|
|
924
|
+
* 逐项解析也让「别名必须属于该项的结尾」这件事由切分本身保证,不需要再拿子句关键字
|
|
925
|
+
* 做前瞻(`userPhone = 'x'` 这类项不以标识符结尾,自然不产生别名)。
|
|
926
|
+
*
|
|
927
|
+
* 判据:
|
|
928
|
+
* ① 项形如 `<表达式> [AS] <标识符>`,`<表达式>` 里**引用**敏感列(词边界;字面量已抹掉);
|
|
929
|
+
* ② 别名可以是双引号标识符(`AS "p"`,DuckDB 里 `GROUP BY p` 能引用它),去引号后比较;
|
|
930
|
+
* ③ 聚合项不算(`max(userPhone) AS worst` 是聚合值,DuckDB 也不接受按它分组)。
|
|
931
|
+
*/
|
|
932
|
+
function aliasesOf(selectList, name) {
|
|
933
|
+
const out = [];
|
|
934
|
+
const nameRe = new RegExp(`(?<![A-Za-z0-9_$])${escapeRe(name)}(?![A-Za-z0-9_$])`, 'i');
|
|
935
|
+
const aliasRe = /^([\s\S]*\S)\s+(?:AS\s+)?([A-Za-z_][A-Za-z0-9_]*|"[^"]+")\s*$/i;
|
|
936
|
+
for (const item of splitTopLevel(withoutLiterals(selectList))) {
|
|
937
|
+
if (isAggregateItem(item))
|
|
938
|
+
continue;
|
|
939
|
+
const m = aliasRe.exec(item);
|
|
940
|
+
const expr = m?.[1];
|
|
941
|
+
const raw = m?.[2];
|
|
942
|
+
if (expr === undefined || raw === undefined)
|
|
943
|
+
continue;
|
|
944
|
+
if (!nameRe.test(expr))
|
|
945
|
+
continue;
|
|
946
|
+
const alias = raw.startsWith('"') ? raw.slice(1, -1) : raw;
|
|
947
|
+
if (!SQL_KEYWORDS.has(alias.toLowerCase()) && !out.includes(alias))
|
|
948
|
+
out.push(alias);
|
|
949
|
+
}
|
|
950
|
+
return out;
|
|
951
|
+
}
|
|
952
|
+
/**
|
|
953
|
+
* 分析顶层投影能否**静态证明**是 SUMMARIZE 原始统计输出的透传。
|
|
954
|
+
*
|
|
955
|
+
* ⚠️ 历史(2026-11-08 ~ 11-09 十余轮双路复审的共同结论):行级脱敏只能靠「输出列名 + 行值」
|
|
956
|
+
* 猜来源,任何 SQL 重写都可能猜错并把**普通值**改成 `<已脱敏>`(数据损坏比漏脱敏更糟)。
|
|
957
|
+
* 每轮复审都能构造出新的合法 SQL 让更精细的猜测失效:`3 AS min`、`3 min` 省略 AS、
|
|
958
|
+
* `'not PII' AS min`、`min: 3` 前置别名、UNION 追加普通行、重排自连接 `:N` 错配、
|
|
959
|
+
* `SELECT *` + CROSS JOIN、`query('SELECT 常量 FROM (SUMMARIZE …)')`、`v.min` 来自 VALUES、
|
|
960
|
+
* `SELECT *, 3 AS min`、三源串联 JOIN、`AS "ON"` 别名、FROM-first 查询、来源列别名列表、
|
|
961
|
+
* `lower(column_name)` 跨表大小写误配 —— 全部真机实测。
|
|
962
|
+
*
|
|
963
|
+
* 因此收窄到**只有两类**可证明形态,其余一律 enabled=false,由调用方声明缺口:
|
|
964
|
+
* ① 顶层语句本身是 SUMMARIZE(`SUMMARIZE <表>` / `SUMMARIZE SELECT …`)—— 无外层投影;
|
|
965
|
+
* ② 顶层 `SELECT *`,且 FROM 子句去掉括号内容后**恰好一个**来源 `(SUMMARIZE …) <别名>`:
|
|
966
|
+
* 没有 JOIN / 逗号并列 / ON / 列别名列表 / 集合操作 / FROM-first;
|
|
967
|
+
* 别名只允许裸标识符或双引号标识符(`AS "ON"` 这类词形也不再歧义,因为不做关键字切分)。
|
|
968
|
+
* 连 `query('…')` 包装也不再启用行级脱敏:内层 SQL 的可分析性是另一套递归词法,
|
|
969
|
+
* 每轮都被找出反例;这类查询输出**原值 + 缺口警告**,用户可改用 `query --table`
|
|
970
|
+
*(内层也复用本判据 passthroughReason,但只用来区分「纯透传 / 不可证明」两档缺口文案)。
|
|
971
|
+
* 残余边界:②里的 `SUMMARIZE` 子查询自身若带 `(SELECT … AS min …)` 入参(如
|
|
972
|
+
* `SUMMARIZE SELECT 3 AS min FROM …`),输出仍是统计结果,不受影响 —— 入参不改变
|
|
973
|
+
* 输出列语义。
|
|
974
|
+
*/
|
|
975
|
+
/** 不可证明时的统一成因(外层缺口文案与内层缺口判定共用同一句)。 */
|
|
976
|
+
const UNPROVABLE = '投影或 FROM 来源无法静态证明是单一 SUMMARIZE 输出';
|
|
977
|
+
/**
|
|
978
|
+
* 一段 SQL 能**静态证明**输出是 SUMMARIZE 统计结果的唯一判据(外层投影与 query() 内层共用
|
|
979
|
+
* —— 判据只许一个实现点,否则内外层迟早漂移)。可证明时返回 null,否则返回成因文本。
|
|
980
|
+
* 形态见下方 analyzeSummarizeProjection 的文档。
|
|
981
|
+
*/
|
|
982
|
+
function passthroughReason(sql) {
|
|
983
|
+
const bare = withoutLiterals(sql);
|
|
984
|
+
// ① 语句头就是 SUMMARIZE —— 输出即统计结果。
|
|
985
|
+
if (/^\s*SUMMARIZE\b/i.test(bare))
|
|
986
|
+
return null;
|
|
987
|
+
// 集合操作:非 SUMMARIZE 分支会被混进来 → 不认。
|
|
988
|
+
if (execTopLevel(bare, /\b(?:UNION|INTERSECT|EXCEPT)\b/i) !== null) {
|
|
989
|
+
return '含 UNION/INTERSECT/EXCEPT(后续分支不是 SUMMARIZE 输出)';
|
|
990
|
+
}
|
|
991
|
+
// ② 必须是 `SELECT *`(或 `SELECT <限定>.*`),且只允许这一个投影项。
|
|
992
|
+
// FROM-first 查询(`FROM (SUMMARIZE …) t`):选择列表隐式、来源组合不可见 → 不认。
|
|
993
|
+
const selectM = /^\s*(?:SELECT|FROM)\b/i.exec(bare);
|
|
994
|
+
if (selectM === null || /^\s*FROM\b/i.test(selectM[0]))
|
|
995
|
+
return UNPROVABLE;
|
|
996
|
+
const selectClause = sliceClause(bare, /^\s*SELECT\s+(?:ALL\s+)?/i, 'FROM\\b');
|
|
997
|
+
const items = splitTopLevel(selectClause).map((t) => t.trim()).filter((t) => t !== '');
|
|
998
|
+
if (items.length !== 1 || !/^(?:(?:"[^"]+"|[A-Za-z_][A-Za-z0-9_$]*)\s*\.\s*)?\*$/.test(items[0])) {
|
|
999
|
+
// 显式列举 / `*, expr` 混合 / 表达式。
|
|
1000
|
+
return UNPROVABLE;
|
|
1001
|
+
}
|
|
1002
|
+
const fromClause = sliceClause(bare, /\bFROM\b/i, 'WHERE\\b|GROUP\\s+BY|ORDER\\s+BY|LIMIT|HAVING|QUALIFY|WINDOW|UNION|EXCEPT|INTERSECT').trim();
|
|
1003
|
+
// 单一来源:`(SUMMARIZE …)` 后只跟裸别名或双引号别名;ON/USING/JOIN/逗号/列别名列表都不允许。
|
|
1004
|
+
// ⚠️ 用**平衡括号扫描**取出来源块(不按关键字切分 —— `AS "ON"`、`(SELECT … JOIN …)`
|
|
1005
|
+
// 等内容全在括号里,与关键字无关),再看剩余文本是否只是别名。
|
|
1006
|
+
if (!fromClause.startsWith('('))
|
|
1007
|
+
return UNPROVABLE;
|
|
1008
|
+
let depth = 0;
|
|
1009
|
+
let close = -1;
|
|
1010
|
+
for (let i = 0; i < fromClause.length; i++) {
|
|
1011
|
+
const ch = fromClause[i];
|
|
1012
|
+
if (ch === '(')
|
|
1013
|
+
depth++;
|
|
1014
|
+
else if (ch === ')') {
|
|
1015
|
+
depth--;
|
|
1016
|
+
if (depth === 0) {
|
|
1017
|
+
close = i;
|
|
1018
|
+
break;
|
|
1019
|
+
}
|
|
1020
|
+
}
|
|
1021
|
+
}
|
|
1022
|
+
if (close === -1)
|
|
1023
|
+
return UNPROVABLE;
|
|
1024
|
+
if (!/^\s*SUMMARIZE\b/i.test(fromClause.slice(1, close)))
|
|
1025
|
+
return UNPROVABLE;
|
|
1026
|
+
const rest = fromClause.slice(close + 1).trim();
|
|
1027
|
+
// 允许:空 / 裸别名 / `AS 别名`;别名本身是裸标识符或双引号标识符;不得有 `(列列表)`
|
|
1028
|
+
if (rest !== '' && !/^(?:AS\s+)?(?:"[^"]+"|[A-Za-z_][A-Za-z0-9_$]*)$/i.test(rest))
|
|
1029
|
+
return UNPROVABLE;
|
|
1030
|
+
return null;
|
|
1031
|
+
}
|
|
1032
|
+
function analyzeSummarizeProjection(mode, shapeColumns) {
|
|
1033
|
+
if (mode.kind !== 'sql' || !shapeColumns)
|
|
1034
|
+
return { enabled: false, reason: '' };
|
|
1035
|
+
const reason = passthroughReason(mode.sql);
|
|
1036
|
+
return reason === null ? { enabled: true, reason: '' } : { enabled: false, reason };
|
|
1037
|
+
}
|
|
128
1038
|
/**
|
|
129
1039
|
* 对一次查询的输出行脱敏(spec §7.2)。纯函数:输入行不被就地改写;
|
|
130
1040
|
* `noMask` 时直接返回入参数组(不拷贝,因为一个字节都不会改)。
|
|
131
1041
|
*/
|
|
132
1042
|
export function maskQueryRows(input) {
|
|
133
|
-
const { rows, columns, mode, noMask } = input;
|
|
1043
|
+
const { rows, columns, mode, noMask, loc } = input;
|
|
134
1044
|
// --no-mask:脱敏整体关闭,缺口警告随之失去意义(没有「脱敏不完整」,只有「没脱敏」)。
|
|
135
1045
|
// ⚠️ 但**形态类**警告与脱敏开关无关,必须保留(契约审查 C-06):
|
|
136
1046
|
// `--table --no-mask` 时 `TABLES` 之外的列仍未被脱敏、仍应点名——README 明说
|
|
@@ -164,8 +1074,8 @@ export function maskQueryRows(input) {
|
|
|
164
1074
|
const undeclared = columns.filter((n) => n !== 'count' && !declared.has(n));
|
|
165
1075
|
const driftWarnings = undeclared.length > 0
|
|
166
1076
|
? [`输出含表定义之外的列 ${undeclared.join('、')}(可能来自旧版 CLI 或库损坏):`
|
|
167
|
-
+ '这些列不在 `TABLES` 元数据中,未做脱敏。要核对请用 `
|
|
168
|
-
+ mode.table.name + '`']
|
|
1077
|
+
+ '这些列不在 `TABLES` 元数据中,未做脱敏。要核对请用 `'
|
|
1078
|
+
+ dbDescribeCommand(mode.table.name, loc) + '`']
|
|
169
1079
|
: [];
|
|
170
1080
|
const sensitive = new Set(mode.table.columns.filter((c) => c.sensitive).map((c) => c.name));
|
|
171
1081
|
const hit = columns.filter((name) => sensitive.has(name));
|
|
@@ -213,7 +1123,59 @@ export function maskQueryRows(input) {
|
|
|
213
1123
|
const changed = new Set();
|
|
214
1124
|
// 整行/STRUCT/LIST 命中的列:那是「整值替换」而不是「按值形态误判业务数字」,
|
|
215
1125
|
// 不进下面的误伤提示(场景审查 7.2 只针对字符串形态命中)。
|
|
216
|
-
|
|
1126
|
+
/**
|
|
1127
|
+
* 值级兜底真正改写过的列(形态命中或 JSON 整段)——「值形态误伤」告警的唯一依据。
|
|
1128
|
+
* ⚠️ 只有**字符串**被改写才记账:对象/数组(STRUCT/LIST 整行)走 S1 整值替换,
|
|
1129
|
+
* 那是安全动作而非「值形态误判业务数字」,不该触发误伤警告(Codex 2026-11-08 P2)。
|
|
1130
|
+
*/
|
|
1131
|
+
const valueFormMasked = new Set();
|
|
1132
|
+
/** SUMMARIZE 行规则改写过统计单元格的列(有意的按列脱敏,不单独构成误伤告警)。 */
|
|
1133
|
+
const summarizeMasked = new Set();
|
|
1134
|
+
// ⚠️ SUMMARIZE 形态(**严重**,2026-11-07 审查实测):`SUMMARIZE sessions` 的输出列是
|
|
1135
|
+
// 通用的 `column_name / min / max / q25 / …`,真正的列名在**行值**里 —— 三条列名级启发式
|
|
1136
|
+
// (输出列名、SQL 文本、payload)全部落空,`userName` / `userAddress` 的 min/max **原值
|
|
1137
|
+
// 静默输出**,且 `mask_warnings` 为空(实测:`min:"张三丰"`、`max:"李四光"`)。
|
|
1138
|
+
// 这是「声明敏感但可从一条只读语句拿到明文」的完整绕过,必须在行级补一道判据。
|
|
1139
|
+
// · 形状判据:**SQL 词法上的 SUMMARIZE 关键字**(不是字符串/注释里的同名词)+ 输出含
|
|
1140
|
+
// `column_name` 且含 `min`/`max`。⚠️ 只看列名不够(Codex 2026-11-08 P2 实测):
|
|
1141
|
+
// `SELECT column_name, MIN(ordinal_position) AS min FROM information_schema.columns
|
|
1142
|
+
// GROUP BY column_name` 输出同样的 `column_name/min`,min 是列位置数字而非客户数据,
|
|
1143
|
+
// 只按列名判会把 `min: 3` 误改成 `<已脱敏>`。
|
|
1144
|
+
// ⚠️ 关键字判据必须作用在**剥除字面量与注释后**的文本上(Codex 2026-11-08 第二轮 P2
|
|
1145
|
+
// 实测):`SELECT 'SUMMARIZE' AS marker, column_name, MIN(ordinal_position) AS min …`
|
|
1146
|
+
// 的字符串字面量里出现同名词,按原始 SQL 判会把这条合法元数据查询误判成 SUMMARIZE。
|
|
1147
|
+
// `withoutLiterals` 把单引号串/美元引号串/注释抹成空格、双引号标识符原样保留 —— 正好
|
|
1148
|
+
// 是「词法上下文」判据。
|
|
1149
|
+
// · 嵌套形态 `query('SUMMARIZE …')` 的关键字在**字符串里**(query() 的实参),
|
|
1150
|
+
// withoutLiterals 会把它抹掉 —— 单独判:裸 SQL 里出现 `query('…SUMMARIZE…')` 即视为
|
|
1151
|
+
// 内层 SQL 为 SUMMARIZE(内层执行本来就是 nestedSql 警告声明的「无法分析」缺口方向,
|
|
1152
|
+
// 这里是对已知形态的补强)。残余边界:`query('SUMM' || 'ARIZE …')` 动态拼串取不到。
|
|
1153
|
+
// · 命中判据:该行 `column_name` 的**基名**精确匹配敏感列清单(与列名级同一口径);
|
|
1154
|
+
// · 动作:命中行的统计列按该列规则脱敏。
|
|
1155
|
+
const summarizeTokens = mode.kind === 'sql'
|
|
1156
|
+
? summarizeTokenPositions(mode.sql)
|
|
1157
|
+
: { recognized: false, unrecognizedParen: false };
|
|
1158
|
+
const queryCall = mode.kind === 'sql'
|
|
1159
|
+
? queryCallSummarize(mode.sql)
|
|
1160
|
+
: { hit: false, atTopOutput: false, gap: false, unresolved: false };
|
|
1161
|
+
const summarizeSql = mode.kind === 'sql'
|
|
1162
|
+
&& (summarizeTokens.recognized || queryCall.atTopOutput);
|
|
1163
|
+
// 第十二轮起 query() 来源不再进入行级脱敏入口(无法静态证明输出是统计值),
|
|
1164
|
+
// 其信号只用于发缺口警告:
|
|
1165
|
+
// · hit:内层**纯透传**(语句头/`SELECT *` 单一来源)—— 输出可能原样含统计值;
|
|
1166
|
+
// · gap:内层含 SUMMARIZE 但投影是重投影 / 位置不可识别 —— 输出是否含统计值未知;
|
|
1167
|
+
// · hit 且非输出路径(WHERE EXISTS / IN / 逗号并列)—— 输出不是统计值,只声明缺口。
|
|
1168
|
+
const summarizeUnconfirmed = summarizeTokens.unrecognizedParen
|
|
1169
|
+
|| queryCall.hit
|
|
1170
|
+
|| queryCall.gap;
|
|
1171
|
+
const summarizeShapeColumns = columns.includes('column_name')
|
|
1172
|
+
&& (columns.includes('min') || columns.includes('max'));
|
|
1173
|
+
const summarizeShape = summarizeSql && summarizeShapeColumns;
|
|
1174
|
+
// avg/std 只对数值列出现:`SUMMARIZE SELECT userPhone::DOUBLE AS userPhone` 的均值/标准差
|
|
1175
|
+
// 同样是 PII 派生值,一并整值替换。count 是行数、approx_unique 是去重计数,单看它们
|
|
1176
|
+
// 恢复不出任何一个原值,不在此列。
|
|
1177
|
+
const SUMMARIZE_STATS = ['min', 'max', 'avg', 'std', 'q25', 'q50', 'q75'];
|
|
1178
|
+
const summarizeProj = analyzeSummarizeProjection(mode, summarizeSql && summarizeShapeColumns);
|
|
217
1179
|
const outRows = rows.map((row) => {
|
|
218
1180
|
const out = { ...row };
|
|
219
1181
|
for (const name of columns) {
|
|
@@ -236,13 +1198,61 @@ export function maskQueryRows(input) {
|
|
|
236
1198
|
}
|
|
237
1199
|
else {
|
|
238
1200
|
out[name] = maskCellByValue(before);
|
|
239
|
-
if (out[name] !== before &&
|
|
240
|
-
|
|
1201
|
+
if (out[name] !== before && typeof before === 'string') {
|
|
1202
|
+
// 字符串被值级兜底改写(手机号/邮箱/IPv4 形态或 JSON 整段):这是「值形态误伤」
|
|
1203
|
+
// 告警的依据,按列记账。与 `changed` 的区别:`changed` 还包含有意脱敏
|
|
1204
|
+
// (列名级 / SUMMARIZE 行规则 / 对象整值替换),那些不该触发误伤告警。
|
|
1205
|
+
valueFormMasked.add(name);
|
|
241
1206
|
}
|
|
242
1207
|
}
|
|
243
1208
|
if (out[name] !== before)
|
|
244
1209
|
changed.add(name);
|
|
245
1210
|
}
|
|
1211
|
+
// ⚠️ 行级脱敏**只在可静态证明**是 SUMMARIZE 原始统计输出时启用(第十二轮收窄,判据见
|
|
1212
|
+
// analyzeSummarizeProjection):其余形态(表达式重投影、显式列举、集合操作、多来源、
|
|
1213
|
+
// query() 包装等)按列名+行值猜来源会把**普通值**改成 `<已脱敏>` —— 数据损坏比漏脱敏
|
|
1214
|
+
// 更糟,统一降级为缺口警告。
|
|
1215
|
+
// ⚠️ 后缀(`:N`)不处理:可证明形态里 SUMMARIZE 输出列名唯一,不会出现 `:N`;
|
|
1216
|
+
// 一旦出现说明输出被其他来源污染(与白名单结论矛盾)—— 而已证明形态下不会发生。
|
|
1217
|
+
if (summarizeShape && summarizeProj.enabled)
|
|
1218
|
+
for (const nameCol of columns) {
|
|
1219
|
+
if (nameCol !== 'column_name')
|
|
1220
|
+
continue;
|
|
1221
|
+
if (typeof out[nameCol] !== 'string')
|
|
1222
|
+
continue;
|
|
1223
|
+
// 行值匹配**大小写敏感**(第十二轮收窄):可证明形态里 column_name 是原样输出,
|
|
1224
|
+
// 无需大小写折叠;否则非敏感的 `staff.username` 会误匹配 sessions.userName
|
|
1225
|
+
//(Codex 第九/十二轮 P2)。
|
|
1226
|
+
const rawCol = baseName(out[nameCol]);
|
|
1227
|
+
const col = sensitiveNames.includes(rawCol) ? rawCol : undefined;
|
|
1228
|
+
if (col !== undefined) {
|
|
1229
|
+
for (const key of SUMMARIZE_STATS) {
|
|
1230
|
+
if (!(key in row))
|
|
1231
|
+
continue;
|
|
1232
|
+
const before = row[key];
|
|
1233
|
+
if (before === null || before === undefined)
|
|
1234
|
+
continue;
|
|
1235
|
+
// ⚠️ 值级兜底的**整值替换必须保留**(Codex 2026-11-08 P1 实测):`out[stat]` 若已被
|
|
1236
|
+
// `maskCellByValue` 判成 FULL(JSON 含 PII 叶子 / 畸形 JSON / STRUCT),这里再用列规则
|
|
1237
|
+
// 重算会把 `<已脱敏>` 降级 —— 紧凑 JSON(`{"userEmail":"a@x.com","secret":"z"}` 无空白、
|
|
1238
|
+
// 恰含一个 `@`)会整串命中邮箱正则,变成 `{***@x.com","secret":"z"}`,`@` 之后的内容
|
|
1239
|
+
// 重新可见。规则:已是 FULL → 保持;否则按该列规则脱敏(非字符串与列名级同一条 S1 规则)。
|
|
1240
|
+
// 强度关系:能过 EMAIL/PHONE/IPV4 正则的值,值级判出的规则就是列规则本身,两者逐字相等;
|
|
1241
|
+
// 值级是 FULL 而列规则给出弱形态的唯一路径就是上面这种 JSON 整串误配 —— 故 FULL 优先。
|
|
1242
|
+
out[key] = out[key] === FULL || typeof before !== 'string'
|
|
1243
|
+
? FULL
|
|
1244
|
+
: maskValue(before, ruleForColumn(col));
|
|
1245
|
+
if (out[key] !== before) {
|
|
1246
|
+
changed.add(key);
|
|
1247
|
+
summarizeMasked.add(key);
|
|
1248
|
+
// ⚠️ 不写 `structuralMasked`(Codex 2026-11-08 P2 实测):它是一个**列级**集合,
|
|
1249
|
+
// 任一敏感行把它塞进去,后面「值形态误伤」的判据就会跳过该列的全部单元格 ——
|
|
1250
|
+
// 混合结果里非敏感行(如 session_id 的 min 恰好是手机号形态)被值级兜底改写时
|
|
1251
|
+
// 的告警会一起消失。这里是**有意**脱敏,按 SUMMARIZE 来源单独记账。
|
|
1252
|
+
}
|
|
1253
|
+
}
|
|
1254
|
+
}
|
|
1255
|
+
}
|
|
246
1256
|
return out;
|
|
247
1257
|
});
|
|
248
1258
|
// 缺口警告:SQL 文本按词边界命中敏感列名(除 payload),但该名不在输出列名中。
|
|
@@ -299,6 +1309,8 @@ export function maskQueryRows(input) {
|
|
|
299
1309
|
return false;
|
|
300
1310
|
}
|
|
301
1311
|
}));
|
|
1312
|
+
// ⚠️ 这一段(payload 引用)作用在**原始** SQL 上:`row_to_json(t)->>'payload'`、
|
|
1313
|
+
// `json_extract(payload, '$.x')` 这类构造里字典键/列名只以字面量出现。
|
|
302
1314
|
const payloadReferenced = columns.includes('payload') || /\bpayload\b/i.test(mode.sql);
|
|
303
1315
|
// ⚠️ 第四类绕过(安全审查 Major,2026-10-20 实测):`query()` 表函数把内层 SQL 当作
|
|
304
1316
|
// **字符串**执行,外层文本与输出列名都看不到内层标识符——
|
|
@@ -312,16 +1324,251 @@ export function maskQueryRows(input) {
|
|
|
312
1324
|
if (nestedSql) {
|
|
313
1325
|
warnings.push('SQL 使用了 query()/query_table()/COLUMNS() 这类**在其内部再执行 SQL 或批量重命名**的构造:'
|
|
314
1326
|
+ '内层引用的敏感列无法被列名级识别,姓名/地址等无格式 PII 可能未经脱敏。'
|
|
315
|
-
+ '需要可靠脱敏请把内层查询单独执行,或改用 `
|
|
1327
|
+
+ '需要可靠脱敏请把内层查询单独执行,或改用 `' + queryTableCommand('<表>', loc) + '`');
|
|
316
1328
|
}
|
|
317
1329
|
if ((payloadReferenced || hasJsonBlob) && payloadPiiTables.length > 0) {
|
|
318
1330
|
warnings.push(`引用了 payload 或整行 JSON(含 PII 的表 ${payloadPiiTables.join('、')}):`
|
|
319
1331
|
+ '本通道只对 payload 做值级检测(手机号/邮箱/IPv4),其中的姓名/地址等无格式 PII 可能未脱敏'
|
|
320
|
-
+ '(别名、JSON 提取、整行序列化都绕得过列名级)。要整值替换请用 `
|
|
1332
|
+
+ '(别名、JSON 提取、整行序列化都绕得过列名级)。要整值替换请用 `'
|
|
1333
|
+
+ queryTableCommand('<表>', loc) + '`');
|
|
1334
|
+
}
|
|
1335
|
+
// 分组 / 去重会把不同原值压成同一个脱敏值(场景审查 7.3,2026-10-20 实测):
|
|
1336
|
+
// `SELECT userPhone, COUNT(*) … GROUP BY userPhone` 对 3 个不同手机号输出 3 行同一个
|
|
1337
|
+
// `138****1111`、每行 count=1 —— Agent 会读成「只有 1 个手机号」或「数据坏了」,而
|
|
1338
|
+
// 输出里没有任何提示。`--table --group-by` 直接拒绝敏感列正是为了这个,`--sql` 只能声明。
|
|
1339
|
+
//
|
|
1340
|
+
// ⚠️ 触发条件不能只看 `matchedSensitive`(= 输出列名命中):`SELECT userPhone AS p,
|
|
1341
|
+
// COUNT(*) … GROUP BY p` 的输出列叫 `p`,脱敏走的仍是列名级(列名 `p` 不敏感 →
|
|
1342
|
+
// 实际走值级,手机号照常被打码),但 `p` 不在 matchedSensitive 里,于是**分组失真
|
|
1343
|
+
// 一条警告都没有**(2026-11-05 审查实测)。
|
|
1344
|
+
//
|
|
1345
|
+
// ⚠️ 但也不能按「SQL 里出现过敏感列」判(Codex 2026-11-05 P2 实测):
|
|
1346
|
+
// `SELECT session_type, COUNT(*) … WHERE userPhone = '…' GROUP BY session_type` 里
|
|
1347
|
+
// 敏感列只用于**过滤**,脱敏不会改变分组键或计数 —— 按整条 SQL 判会谎报「分组失真」,
|
|
1348
|
+
// 而这条警告建议 `--no-mask`,等于诱导用户白关脱敏。判据只看**分组键本身**:
|
|
1349
|
+
// ① `GROUP BY` 的项里按词边界出现敏感列名(`GROUP BY userPhone`);
|
|
1350
|
+
// ② `GROUP BY <别名>`,而该别名是 SELECT 列表里某个敏感列的别名(`userPhone AS p`);
|
|
1351
|
+
// ③ `GROUP BY <序号>`(`GROUP BY 1`)指向的 SELECT 项引用了敏感列;
|
|
1352
|
+
// ④ `SELECT DISTINCT` 的选择列表(`DISTINCT ON (…)` 只取括号内的列)里出现敏感列。
|
|
1353
|
+
// ⚠️ `matchedSensitive`(输出列名命中)本身**不再**算作分组证据:`SELECT max(userPhone)
|
|
1354
|
+
// AS userPhone … GROUP BY session_type` 的分组键不含敏感列,输出列名却命中 —— 那是聚合
|
|
1355
|
+
// 而非分组,打码不会改变计数。分组列是否敏感由上面的分组键判据决定。
|
|
1356
|
+
// 都是词边界 + 大小写不敏感(DuckDB 标识符不分大小写)。
|
|
1357
|
+
//
|
|
1358
|
+
// ⚠️ 再加一个条件「**可见**」(Codex 2026-11-05 第二轮 P2 实测):脱敏只会把**输出里**
|
|
1359
|
+
// 被投影的分组值压平,计数不变。`SELECT COUNT(*) FROM sessions GROUP BY userPhone`
|
|
1360
|
+
// 只输出计数,分组键根本没投影 —— 两张不同手机号各计 1 条,脱敏前后输出完全一样,
|
|
1361
|
+
// 报「分组失真」并建议 --no-mask 是纯粹的误报(实测该 SQL 返回 `n=1, n=1`)。
|
|
1362
|
+
// 所以分组键命中后还要看它有没有作为**非聚合**选择项被投影出来
|
|
1363
|
+
// (`SELECT userPhone, COUNT(*) … GROUP BY userPhone`、`SELECT userPhone AS p … GROUP BY p`
|
|
1364
|
+
// 都是可见的;`SELECT max(userPhone) AS userPhone … GROUP BY ALL` 里那一项是聚合值,不可见)。
|
|
1365
|
+
//
|
|
1366
|
+
// ⚠️ 字面量与注释先抹掉(Codex 第二轮 P3 实测):`GROUP BY 'userPhone'` 是按**常量**分组
|
|
1367
|
+
//(实测一行 `n=2`),字面量里写着列名不该算命中。双引号是标识符,不抹。
|
|
1368
|
+
//
|
|
1369
|
+
// ⚠️ 引用判定作用在**原始** SQL 上(含字面量):`struct_extract(t, 'userName')`、
|
|
1370
|
+
// `row_to_json(t)->>'userName'` 里列名**只**以字符串字面量出现,而姓名/地址没有值级
|
|
1371
|
+
// 检测 —— 抹掉字面量会让这类查询静默零警告(CodeRabbit PR #68 第三轮 major 实测)。
|
|
1372
|
+
// 方向按 spec §十五.4:缺口警告宁多勿少(`WHERE session_type = 'userPhone'` 会多报一条,
|
|
1373
|
+
// 这是可接受的代价)。
|
|
1374
|
+
const referencedSensitive = sensitiveNames
|
|
1375
|
+
.filter((n) => new RegExp(`(?<![A-Za-z0-9_$])${escapeRe(n)}(?![A-Za-z0-9_$])`, 'i').test(mode.sql));
|
|
1376
|
+
const referencesSensitive = referencedSensitive.length > 0;
|
|
1377
|
+
// SUMMARIZE 的残余缺口(2026-11-07 审查):行级判据只认 `column_name` **恰好**是敏感列名;
|
|
1378
|
+
// `SUMMARIZE SELECT userName AS n …` 的 column_name 是 `n`,脱敏不命中。与 query()/
|
|
1379
|
+
// COLUMNS() 同属「无法可靠分析」,按既有口径**声明缺口而不拒绝**(只读、不越权)。
|
|
1380
|
+
// ⚠️ 触发条件用 `summarizeMasked`(SUMMARIZE 行级判据**真命中过**)而非 `changed.size > 0`
|
|
1381
|
+
//(Codex 2026-11-08 P2 实测):changed 含值级兜底的改写 —— `SUMMARIZE sessions` 里只有
|
|
1382
|
+
// 非敏感列 min 恰为手机号形态时,本警告会凭空声称「已按 column_name 精确匹配脱敏」,而
|
|
1383
|
+
// 实际一条 SUMMARIZE 规则都没跑。范围收敛到「本判据确实改写过单元格」。
|
|
1384
|
+
if (summarizeMasked.size > 0) {
|
|
1385
|
+
warnings.push('SUMMARIZE 的统计值(min/max/分位数)可能来自敏感列:本次已按输出里的 column_name '
|
|
1386
|
+
+ '精确匹配脱敏;**别名/表达式列**(如 `SUMMARIZE SELECT userName AS n …`)不在其列。'
|
|
1387
|
+
+ '要可靠覆盖请用 `' + queryTableCommand('<表>', loc) + '` 取指定列');
|
|
1388
|
+
}
|
|
1389
|
+
// ⚠️ SQL 含 SUMMARIZE 但**输出列名被改写**(`SELECT column_name AS c, min AS m, max AS x
|
|
1390
|
+
// FROM (SUMMARIZE sessions)`,CodeRabbit 2026-11-08 第六轮实测):形状判据不匹配 → 行级
|
|
1391
|
+
// 脱敏不触发,而 SQL 文本又不含敏感列名、其余缺口警告也不发 —— PII 统计值原样输出且
|
|
1392
|
+
// mask_warnings 为空。按本文件对 query()/COLUMNS() 的同一策略:**声明缺口,绝不静默**。
|
|
1393
|
+
// ⚠️ 位置无法确认的嵌套形态同样要覆盖(CodeRabbit 2026-11-09 第十三轮 major,真机实测
|
|
1394
|
+
// 两种写法都输出明文 c/m/x 且 warnings=[]):
|
|
1395
|
+
// · `SELECT * FROM (SELECT column_name AS c, min AS m, max AS x FROM (SUMMARIZE sessions))`
|
|
1396
|
+
// · `WITH t AS (SELECT column_name AS c, min AS m FROM (SUMMARIZE sessions)) SELECT * FROM t`
|
|
1397
|
+
// 但**不能**只按 `unrecognizedParen` 放宽:可证明透传的 SQL 里若别处还有无法识别位置的
|
|
1398
|
+
// SUMMARIZE(如 `SELECT * FROM (SUMMARIZE sessions), (SUMMARIZE staff) t`,真机实测合法、
|
|
1399
|
+
// 输出 12 + 12 列),`unrecognizedParen` 也会置真,而输出是标准统计形状 —— 那类只走
|
|
1400
|
+
// 「无法确认是否构成最终输出」泛化档,不该被说成「列名已被改写」。
|
|
1401
|
+
// 判据:位置无法确认(非 summarizeSql)**且**输出不是可静态证明的透传 —— 后者在进入本档时
|
|
1402
|
+
// 形状必然不匹配(可证明形态恒为 column_name/min/max),只作显式兜底、如实记录未单独承重。
|
|
1403
|
+
// 「含 SUMMARIZE」是事实断言:探测只来自 query() 的未解析实参时它未知 → 排到下面「可能含」档。
|
|
1404
|
+
const summarizePresenceUnknown = queryCall.unresolved && !queryCall.hit;
|
|
1405
|
+
if (!summarizeShape
|
|
1406
|
+
&& (summarizeSql || (summarizeUnconfirmed && !summarizeProj.enabled && !summarizePresenceUnknown))) {
|
|
1407
|
+
warnings.push('SQL 含 SUMMARIZE,但输出列名已被改写(缺 column_name / min / max 形状):'
|
|
1408
|
+
+ '行级脱敏无法按行值识别敏感列,统计值(min/max/分位数)可能**未脱敏**。'
|
|
1409
|
+
+ '要可靠覆盖请用 `' + queryTableCommand('<表>', loc) + '` 取指定列');
|
|
1410
|
+
}
|
|
1411
|
+
// ⚠️ 投影无法**静态证明**是 SUMMARIZE 原始统计输出 → 只声明缺口、不改写任何值。
|
|
1412
|
+
// 第十二轮收窄后只剩两类可证明形态(见 analyzeSummarizeProjection),其余全部走这里:
|
|
1413
|
+
// 表达式重投影(`3 AS min`、`COUNT(*) AS min`、省略 AS、字符串常量)、显式列举、
|
|
1414
|
+
// 集合操作(UNION 追加普通行)、`*` + 多来源、FROM-first、来源列别名列表、`query()` 包装等。
|
|
1415
|
+
// 具体成因由 `reason` 给出(单一出处,判据与文案同源)。
|
|
1416
|
+
if (summarizeShape && !summarizeProj.enabled) {
|
|
1417
|
+
const reason = summarizeProj.reason;
|
|
1418
|
+
warnings.push('SQL 的 SUMMARIZE 输出投影**无法确认来源**:' + reason + '。'
|
|
1419
|
+
+ '本次只声明缺口、未按 SUMMARIZE 改写任何值 —— 统计值可能**未脱敏**,'
|
|
1420
|
+
+ '这些行也可能根本不是统计结果。'
|
|
1421
|
+
+ '要可靠覆盖请用 `' + queryTableCommand('<表>', loc) + '` 取指定列,'
|
|
1422
|
+
+ '或改用 `SELECT * FROM (SUMMARIZE <表>)` 原样透传');
|
|
1423
|
+
}
|
|
1424
|
+
// ⚠️ SQL 里的 SUMMARIZE 位置**无法确认是最终输出**但输出是 SUMMARIZE 形状
|
|
1425
|
+
//(CodeRabbit 2026-11-08 第七轮 major + Codex 第七轮 P2,均真机实测):
|
|
1426
|
+
// · `SELECT * FROM (SELECT * FROM (SUMMARIZE sessions))` 合法,输出 column_name/min/max,
|
|
1427
|
+
// userName 的 min/max 是明文 —— 行级判据不生效、其余警告也不发;
|
|
1428
|
+
// · `SELECT 'userName' AS column_name, 3 AS min WHERE EXISTS (SELECT 1 FROM query('SUMMARIZE sessions'))`
|
|
1429
|
+
// 也合法,但输出 min 是**常量 3** —— 按全 SQL 判据脱敏会把业务常量篡改成 `<已脱敏>`;
|
|
1430
|
+
// · `SELECT * FROM query('SELECT column_name, min FROM (SUMMARIZE sessions)')` 内层是重投影,
|
|
1431
|
+
// 输出仍可能是统计值 —— 第十二轮收窄时曾被这一档漏掉,现由 queryCall.gap 兜住,
|
|
1432
|
+
// 并有**单独一档文案**(下一条),因为它的成因与修复建议都与位置类不同。
|
|
1433
|
+
// 两向都不安全:漏脱敏与误改。与上一档同一策略:**只声明缺口,不冒认脱敏**。
|
|
1434
|
+
if (!summarizeSql && summarizeUnconfirmed && !queryCall.gap && summarizeShapeColumns
|
|
1435
|
+
&& !summarizePresenceUnknown) {
|
|
1436
|
+
warnings.push('SQL 里的 SUMMARIZE **无法确认是否构成最终输出**(如多层子查询 '
|
|
1437
|
+
+ '`FROM (SELECT * FROM (SUMMARIZE …))`、逗号连接、CTE 内的子查询,'
|
|
1438
|
+
+ '或 query() 只出现在 WHERE/EXISTS/IN 子查询里):'
|
|
1439
|
+
+ '输出可能仍是 SUMMARIZE 形状,但无法确认统计值是否未脱敏 —— '
|
|
1440
|
+
+ '行级脱敏未生效,统计值(min/max/分位数)可能**未脱敏**;若这些行不是 SUMMARIZE 结果则保持原值。'
|
|
1441
|
+
+ '要可靠覆盖请用 `' + queryTableCommand('<表>', loc) + '` 取指定列,'
|
|
1442
|
+
+ '或把 SUMMARIZE 提到顶层(`SUMMARIZE <表>`)');
|
|
1443
|
+
}
|
|
1444
|
+
// 「内层使用了 SUMMARIZE」同上:未解析实参只代表「可能含」,走最后一档。
|
|
1445
|
+
if (!summarizeSql && queryCall.gap && summarizeShapeColumns && !summarizePresenceUnknown) {
|
|
1446
|
+
warnings.push('SQL 在 `query()` 内层使用了 SUMMARIZE,但内层投影**不是原样透传**'
|
|
1447
|
+
+ '(显式列举 / 表达式重投影 / 位置不可识别):'
|
|
1448
|
+
+ '统计值(min/max/分位数)可能**未脱敏**;若内层输出被改写成常量则保持原值。'
|
|
1449
|
+
+ '要可靠覆盖请用 `' + queryTableCommand('<表>', loc) + '` 取指定列,'
|
|
1450
|
+
+ '或改用 `SELECT * FROM (SUMMARIZE <表>)` 原样透传');
|
|
1451
|
+
}
|
|
1452
|
+
// ⚠️ query() 实参无法静态展开(拼接 / 函数调用)—— **只声明缺口,不改写任何值**。
|
|
1453
|
+
// 展不开 ≠ 检出:`query('SELECT ' || '1')` 里没有 SUMMARIZE,旧实现在这里发「SQL 在 query()
|
|
1454
|
+
// 内层使用了 SUMMARIZE」是把它当成检出(CodeRabbit 第十六轮 minor,真机实测该 SQL 合法)。
|
|
1455
|
+
// 所以 `queryCall.unresolved` 让上面两句「使用了 / 含 SUMMARIZE」失效,改由本档如实说
|
|
1456
|
+
// 「可能含、无法检查」,并给出可执行的收口(实参改成单个字符串字面量)。
|
|
1457
|
+
// 只在**输出确实是统计形状**时才发(与同族两档一致):否则外层已投影成别的列,
|
|
1458
|
+
// 内层含不含 SUMMARIZE 都不影响输出,泛化的 query() 警告已够,不必再添一条。
|
|
1459
|
+
if (!summarizeSql && summarizePresenceUnknown && summarizeShapeColumns) {
|
|
1460
|
+
warnings.push('SQL 里的 `query()` 实参无法静态展开(拼接 / 函数调用),无法确认内层是否含 SUMMARIZE:'
|
|
1461
|
+
+ '若含,其统计值(min/max/分位数)可能**未脱敏**;若不含则保持原值。'
|
|
1462
|
+
+ '要可靠覆盖请用 `' + queryTableCommand('<表>', loc) + '` 取指定列,'
|
|
1463
|
+
+ '或把 query() 的实参改为单个字符串字面量(如 `query(\'SUMMARIZE <表>\')`)');
|
|
1464
|
+
}
|
|
1465
|
+
// 边界用「前后不是标识符字符」而不是 `\\b`:别名可以带标点(`"p("`),
|
|
1466
|
+
// 而 `\\b` 只在词字符与非词字符之间成立 —— `\\bp(\\b` 即使不抛也永远匹配不上
|
|
1467
|
+
// `GROUP BY "p("` 里的 `p(`。转义 + lookaround 两个方向都对(CodeRabbit 第六轮 minor)。
|
|
1468
|
+
const wordHit = (text, names) => {
|
|
1469
|
+
const plain = withoutLiterals(text);
|
|
1470
|
+
return names.some((n) => new RegExp(`(?<![A-Za-z0-9_$])${escapeRe(n)}(?![A-Za-z0-9_$])`, 'i').test(plain));
|
|
1471
|
+
};
|
|
1472
|
+
const groupedSensitive = new Set();
|
|
1473
|
+
// ⚠️ `DISTINCT` 后面是 `\s*` 不是 `\s+`(CodeRabbit PR #68 第十四轮 minor):
|
|
1474
|
+
// DuckDB 接受 `SELECT DISTINCT(userPhone) FROM sessions`(实测去重生效,3 行 → 2 行),
|
|
1475
|
+
// 要求空白会把 `DISTINCT(userPhone)` 整个当成一个选择项留在列表里。
|
|
1476
|
+
// 如实记录:这一处**不单独承重** —— 把下面 distinct 检测正则修好后,前缀剥不剥都
|
|
1477
|
+
// 会报警(`projectedPlain` 里照样含列名),变异实测用例仍绿。保留是因为它让选择项的
|
|
1478
|
+
// 文本语义正确,但不算进变异数。
|
|
1479
|
+
const selectList = withoutLiterals(sliceClause(mode.sql, /^\s*SELECT\s+(?:ALL\s+|DISTINCT\b\s*(?:ON\s*\([^)]*\)\s*)?)?/i, 'FROM\\b'));
|
|
1480
|
+
const selectItems = splitTopLevel(selectList);
|
|
1481
|
+
const projected = selectItems.filter((it) => it.trim() !== '' && !isAggregateItem(it));
|
|
1482
|
+
const projectedPlain = projected.join(',');
|
|
1483
|
+
// ⚠️ 选择列表解析不了(`WITH … SELECT`、前导注释、`SELECT *` / `t.*`)时无法判断「哪一列被
|
|
1484
|
+
// 投影出来」—— 退回输出列名命中(matchedSensitive),保住旧行为里的警告
|
|
1485
|
+
//(`SELECT DISTINCT * FROM sessions` 实测会输出全部敏感列;CodeRabbit PR #68 第三轮 minor)。
|
|
1486
|
+
// 解析得出来时不退回:`SELECT max(userPhone) AS userPhone … GROUP BY ALL` 的列名命中
|
|
1487
|
+
// 是聚合值,不该当成可见分组键(Codex 第二轮 P2)。
|
|
1488
|
+
const selectUnparsed = selectList.trim() === ''
|
|
1489
|
+
|| selectItems.some((it) => /\*\s*$/.test(it.trim()));
|
|
1490
|
+
/** 分组键是否**被投影出来**(可见):按列名、其别名或裸表达式出现于非聚合选择项。 */
|
|
1491
|
+
const visible = (n) => wordHit(projectedPlain, [n]) || aliasesOf(selectList, n).some((a) => wordHit(projectedPlain, [a]))
|
|
1492
|
+
|| (selectUnparsed && matchedSensitive.has(n));
|
|
1493
|
+
const groupByClause = sliceClause(mode.sql, /\bGROUP\s+BY\b/i);
|
|
1494
|
+
if (groupByClause !== '') {
|
|
1495
|
+
let keys = splitTopLevel(groupByClause);
|
|
1496
|
+
// 字面量先抹掉(`GROUP BY 'x'` 是按常量分组,不是列 —— Codex 第二轮 P3 实测),
|
|
1497
|
+
// 抹完的键只含标识符,再参与列名匹配。
|
|
1498
|
+
const plainKeys = keys.map((k) => withoutLiterals(k));
|
|
1499
|
+
// `GROUP BY ALL`(DuckDB)= 按**全部非聚合选择项**分组 —— 选择项里出现敏感列就是分组键
|
|
1500
|
+
//(聚合项如 `max(userPhone) AS userPhone` 不是分组键,见上面的聚合判定)。
|
|
1501
|
+
const groupByAll = plainKeys.length === 1 && /^\s*ALL\s*$/i.test(plainKeys[0]);
|
|
1502
|
+
for (const n of sensitiveNames) {
|
|
1503
|
+
if (!visible(n))
|
|
1504
|
+
continue;
|
|
1505
|
+
// `GROUP BY ALL` + `SELECT *`:选择项是星号,projectedPlain 里没有列名 —— 退回输出列名命中
|
|
1506
|
+
//(`SELECT * … GROUP BY ALL` 实测输出全部敏感列并按它们分组,Codex 第三轮 P2)。
|
|
1507
|
+
const viaKey = plainKeys.some((k) => wordHit(k, [n]))
|
|
1508
|
+
|| (groupByAll && (wordHit(projectedPlain, [n]) || (selectUnparsed && matchedSensitive.has(n))));
|
|
1509
|
+
const viaAlias = aliasesOf(selectList, n).some((a) => plainKeys.some((k) => wordHit(k, [a])));
|
|
1510
|
+
const viaOrdinal = plainKeys.some((k) => {
|
|
1511
|
+
const t = k.trim();
|
|
1512
|
+
if (!/^\d+$/.test(t))
|
|
1513
|
+
return false;
|
|
1514
|
+
const target = selectItems[Number(t) - 1];
|
|
1515
|
+
return target !== undefined && !isAggregateItem(target) && wordHit(target, [n]);
|
|
1516
|
+
});
|
|
1517
|
+
if (viaKey || viaAlias || viaOrdinal)
|
|
1518
|
+
groupedSensitive.add(n);
|
|
1519
|
+
}
|
|
321
1520
|
}
|
|
1521
|
+
// 判据作用在抹掉字面量/注释但等长的文本上:`SELECT userPhone, 'SELECT DISTINCT' AS label` 不是
|
|
1522
|
+
// DISTINCT 查询(Codex 第三轮 P2)。切片偏移与原 SQL 逐位对齐。
|
|
1523
|
+
const sqlBlank = withoutLiterals(mode.sql);
|
|
1524
|
+
// 只在顶层找 DISTINCT:`… WHERE x IN (SELECT DISTINCT x …)` 的去重发生在子查询、且去重的是
|
|
1525
|
+
// 该子查询的原值行,脱敏不过多合并行;误把它当外层 DISTINCT 会对外层投影列误报(第四轮)。
|
|
1526
|
+
// `DISTINCT\b\s*`:`DISTINCT(userPhone)` 这种无空格写法同样算一次去重
|
|
1527
|
+
const distinct = execTopLevel(sqlBlank, /\bSELECT\s+(?:ALL\s+)?DISTINCT\b\s*(ON\s*\()?/i);
|
|
1528
|
+
if (distinct !== null) {
|
|
1529
|
+
// `DISTINCT ON (a, b) …` 的分组键是括号里的列;普通 `DISTINCT` 是整张选择列表
|
|
1530
|
+
//(DISTINCT 的选择项本身就是可见分组键;聚合项不会出现在 DISTINCT 列表里,但仍排除)。
|
|
1531
|
+
// 括号配对走抹过字面量的 `sqlBlank`:字面量里的 `(`/`)` 不参与配对(等长,偏移对齐)。
|
|
1532
|
+
const list = distinct[1] === undefined
|
|
1533
|
+
? projectedPlain
|
|
1534
|
+
: (() => {
|
|
1535
|
+
const open = distinct.index + distinct[0].length;
|
|
1536
|
+
let depth = 1;
|
|
1537
|
+
for (let i = open; i < sqlBlank.length; i++) {
|
|
1538
|
+
if (sqlBlank[i] === '(')
|
|
1539
|
+
depth++;
|
|
1540
|
+
else if (sqlBlank[i] === ')') {
|
|
1541
|
+
depth--;
|
|
1542
|
+
if (depth === 0)
|
|
1543
|
+
return sqlBlank.slice(open, i);
|
|
1544
|
+
}
|
|
1545
|
+
}
|
|
1546
|
+
return sqlBlank.slice(open);
|
|
1547
|
+
})();
|
|
1548
|
+
for (const n of sensitiveNames) {
|
|
1549
|
+
if (!visible(n))
|
|
1550
|
+
continue;
|
|
1551
|
+
// 选择列表是 `*` / 解析不了时,`DISTINCT` 去重的就是**整行输出**(含全部敏感列)——
|
|
1552
|
+
// 按 matchedSensitive 报,方向宁多勿少(CodeRabbit PR #68 第三轮 minor)。
|
|
1553
|
+
if (selectUnparsed && matchedSensitive.has(n)) {
|
|
1554
|
+
groupedSensitive.add(n);
|
|
1555
|
+
continue;
|
|
1556
|
+
}
|
|
1557
|
+
if (wordHit(list, [n]) || aliasesOf(selectList, n).some((a) => wordHit(list, [a]))) {
|
|
1558
|
+
groupedSensitive.add(n);
|
|
1559
|
+
}
|
|
1560
|
+
}
|
|
1561
|
+
}
|
|
1562
|
+
if (groupedSensitive.size > 0) {
|
|
1563
|
+
warnings.push(`SQL 对脱敏列做了 GROUP BY / DISTINCT(${[...groupedSensitive].join('、')}):`
|
|
1564
|
+
+ '不同原值会映射成同一个脱敏值,分组结果与计数可能失真。'
|
|
1565
|
+
+ '需要准确分组请用 `--no-mask`(并自行承担 PII 风险),或改用不敏感列分组');
|
|
1566
|
+
}
|
|
1567
|
+
// 先收集**全部**该报的列,再按上限逐条发:最后一条替成「另有 N 个未列出」的清单。
|
|
1568
|
+
// ⚠️ 只在循环里 `break` 会让被截掉的列**静默消失**(2026-11-09 审计实测:7 个未匹配
|
|
1569
|
+
// 敏感列只出 5 条,没有「等/其余」字样,Agent 读到的 5 条看起来就是全部缺口)。
|
|
1570
|
+
const unmatched = [];
|
|
322
1571
|
for (const name of sensitiveNames) {
|
|
323
|
-
if (warnings.length >= WARNING_LIMIT)
|
|
324
|
-
break;
|
|
325
1572
|
if (matchedSensitive.has(name))
|
|
326
1573
|
continue;
|
|
327
1574
|
// `\b` 两侧都要求非标识符字符:userPhoneBook 这类更长标识符不会误报 userPhone。
|
|
@@ -334,18 +1581,24 @@ export function maskQueryRows(input) {
|
|
|
334
1581
|
// spec 明确要求这个方向。
|
|
335
1582
|
if (!new RegExp(`\\b${name}\\b`, 'i').test(mode.sql))
|
|
336
1583
|
continue;
|
|
337
|
-
|
|
338
|
-
'建议用 `qiyu query --table` 或保持列名原样');
|
|
1584
|
+
unmatched.push(name);
|
|
339
1585
|
}
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
//
|
|
343
|
-
//
|
|
344
|
-
|
|
345
|
-
|
|
346
|
-
|
|
347
|
-
|
|
348
|
-
|
|
1586
|
+
const warnOne = (name) => `SQL 引用了敏感列 ${name},但输出列名不匹配;脱敏可能不完整,`
|
|
1587
|
+
+ '建议用 `' + queryTableCommand('<表>', loc) + '` 或保持列名原样';
|
|
1588
|
+
// 上限是**本类别自己的**行数(spec §7.2 说的是「这个判据的去重上限」),不按
|
|
1589
|
+
// `warnings.length` 扣减:扣减会让其它类别的警告把预算吃光(Codex 2026-11-10 第三轮 P2:
|
|
1590
|
+
// 前 5 条已存在时这里仍要发汇总 → 超上限;不发汇总 → 又回到「静默截断」,是本轮修的 bug)。
|
|
1591
|
+
// 现在本块最多出 WARNING_LIMIT 行:截断时最后一行是点名剩余列的汇总。
|
|
1592
|
+
const perColumnSlots = unmatched.length > WARNING_LIMIT
|
|
1593
|
+
? WARNING_LIMIT - 1
|
|
1594
|
+
: unmatched.length;
|
|
1595
|
+
for (const name of unmatched.slice(0, perColumnSlots))
|
|
1596
|
+
warnings.push(warnOne(name));
|
|
1597
|
+
if (unmatched.length > perColumnSlots) {
|
|
1598
|
+
// 剩余列并成一条:既不超本类别的行数上限,又点名全部被截断的列。
|
|
1599
|
+
const rest = unmatched.slice(perColumnSlots);
|
|
1600
|
+
warnings.push(`另有 ${rest.length} 个敏感列的缺口警告未列出(受 ${WARNING_LIMIT} 条上限):`
|
|
1601
|
+
+ `${rest.join('、')};这些列的脱敏同样可能不完整`);
|
|
349
1602
|
}
|
|
350
1603
|
// 值级兜底命中了**非敏感列**(场景审查 7.2):11 位、以 1 开头的订单号/聚合值会被
|
|
351
1604
|
// 当成手机号打码,而 `--table` 通道对同一列返回原值。规则本身不能放宽(放宽就漏 PII),
|
|
@@ -354,14 +1607,13 @@ export function maskQueryRows(input) {
|
|
|
354
1607
|
// ⚠️ 只在 SQL **完全没有引用任何敏感列**时提示:`SELECT userPhone AS p` 的 p 也是
|
|
355
1608
|
// 「非敏感列名」,但它显然来自敏感列,上面已有缺口警告,再报一条就是噪音。
|
|
356
1609
|
// payload 同理(它有自己的缺口警告,且刻意不在 sensitiveNames 里)。
|
|
357
|
-
const referencesSensitive = sensitiveNames.some((n) => new RegExp(`\\b${n}\\b`, 'i').test(mode.sql));
|
|
358
1610
|
const falsePositive = referencesSensitive
|
|
359
1611
|
? []
|
|
360
|
-
: [...
|
|
1612
|
+
: [...valueFormMasked].filter((n) => n !== 'payload' && !sensitiveNames.includes(baseName(n)));
|
|
361
1613
|
if (falsePositive.length > 0) {
|
|
362
1614
|
warnings.push(`列 ${falsePositive.join('、')} 不在敏感列清单里,是按**值形态**(手机号/邮箱/IPv4)`
|
|
363
1615
|
+ '命中的脱敏:若它其实是订单号、聚合值等业务数字,输出值已被改写。'
|
|
364
|
-
+ '这类列可用 `
|
|
1616
|
+
+ '这类列可用 `' + queryTableCommand('<表>', loc) + '` 取得原始值(该通道按列声明脱敏)');
|
|
365
1617
|
}
|
|
366
1618
|
const maskedColumns = columns.filter((n) => changed.has(n));
|
|
367
1619
|
return { rows: outRows, maskedColumns, warnings };
|