@itphx/synth-shared 0.10.1 → 0.11.3
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/dist/config/defaults.js +49 -3
- package/dist/config/env-overrides.d.ts +4 -1
- package/dist/config/env-overrides.js +37 -4
- package/dist/config/index.d.ts +3 -0
- package/dist/config/index.js +3 -0
- package/dist/config/loader.js +19 -0
- package/dist/config/proxy.d.ts +415 -0
- package/dist/config/proxy.js +1565 -0
- package/dist/config/resolve.d.ts +67 -0
- package/dist/config/resolve.js +187 -1
- package/dist/config/tls-runtime.d.ts +78 -0
- package/dist/config/tls-runtime.js +356 -0
- package/dist/config/tls.d.ts +215 -0
- package/dist/config/tls.js +394 -0
- package/dist/config/types.d.ts +1536 -50
- package/dist/config/types.js +273 -7
- package/dist/i18n/index.d.ts +1 -1
- package/dist/i18n/index.js +2 -0
- package/dist/index.d.ts +11 -2
- package/dist/index.js +11 -2
- package/dist/protocols/index.d.ts +0 -1
- package/dist/schemas/index.d.ts +134 -9
- package/dist/schemas/index.js +51 -4
- package/dist/types/analytics.d.ts +113 -0
- package/dist/types/analytics.js +61 -0
- package/dist/types/egress.d.ts +114 -0
- package/dist/types/egress.js +68 -0
- package/dist/types/events.d.ts +0 -1
- package/dist/types/fs.d.ts +11 -0
- package/dist/types/fs.js +11 -0
- package/dist/types/hooks.d.ts +20 -0
- package/dist/types/index.d.ts +3 -0
- package/dist/types/index.js +6 -0
- package/dist/types/maintenance.d.ts +39 -0
- package/dist/types/maintenance.js +11 -0
- package/dist/types/mcp.d.ts +68 -3
- package/dist/types/mcp.js +83 -4
- package/dist/types/permission.d.ts +7 -5
- package/dist/types/prompt.d.ts +3 -2
- package/dist/types/session.d.ts +0 -1
- package/dist/types/webhooks.d.ts +1 -1
- package/dist/utils/index.d.ts +15 -0
- package/dist/utils/index.js +53 -0
- package/dist/version.d.ts +1 -1
- package/dist/version.js +1 -1
- package/package.json +1 -1
|
@@ -0,0 +1,394 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* ADR-099: единый механизм доверия TLS/CA — конфиг-резолверы секции
|
|
3
|
+
* `security.tls` (ADR-023: приоритет `env > config.yaml > defaults`).
|
|
4
|
+
*
|
|
5
|
+
* Здесь только **чтение и валидация конфигурации** доверия: слияние env/config,
|
|
6
|
+
* взаимоисключение `caFile`/`caPem` и fail-closed проверка явно заданного
|
|
7
|
+
* PEM-файла. Построение dispatcher'а и применение доверия к исходящим запросам —
|
|
8
|
+
* в core (`packages/core/src/security/tls.ts`).
|
|
9
|
+
*
|
|
10
|
+
* Пусто/не задано — системное доверие (системные CA Node), поведение не меняется.
|
|
11
|
+
*/
|
|
12
|
+
import { readFileSync } from 'node:fs';
|
|
13
|
+
import { isIP } from 'node:net';
|
|
14
|
+
/** Env-имена секции `security.tls` (ADR-023). */
|
|
15
|
+
export const TLS_ENV = {
|
|
16
|
+
caFile: 'SYNTH_TLS_CA_FILE',
|
|
17
|
+
caPem: 'SYNTH_TLS_CA_PEM',
|
|
18
|
+
certFile: 'SYNTH_TLS_CERT_FILE',
|
|
19
|
+
keyFile: 'SYNTH_TLS_KEY_FILE',
|
|
20
|
+
rejectUnauthorized: 'SYNTH_TLS_REJECT_UNAUTHORIZED',
|
|
21
|
+
};
|
|
22
|
+
/** PEM-маркер блока (заголовок `-----BEGIN <TYPE>-----`). */
|
|
23
|
+
const PEM_BLOCK_RE = /-----BEGIN [A-Z0-9 ]+-----/;
|
|
24
|
+
/** `true`, если строка содержит PEM-блок. */
|
|
25
|
+
export function isPemContent(value) {
|
|
26
|
+
return PEM_BLOCK_RE.test(value);
|
|
27
|
+
}
|
|
28
|
+
/**
|
|
29
|
+
* Сливает env, runtime (bootstrap) и config.yaml для `security.tls`
|
|
30
|
+
* (ADR-023): приоритет **поле-уровнево** `env > runtime > config`. Пустая
|
|
31
|
+
* строка env — «не задано». `caFile` и `caPem` взаимоисключащи: после слияния
|
|
32
|
+
* оба непусты (в т.ч. из разных источников) → ошибка конфигурации (fail-closed).
|
|
33
|
+
*/
|
|
34
|
+
export function resolveTlsConfig(config, env = process.env, runtime) {
|
|
35
|
+
const resolved = resolveTlsProfiles(config, env, runtime);
|
|
36
|
+
const result = { rejectUnauthorized: resolved.rejectUnauthorized };
|
|
37
|
+
if (resolved.caFile !== undefined)
|
|
38
|
+
result.caFile = resolved.caFile;
|
|
39
|
+
if (resolved.caPem !== undefined)
|
|
40
|
+
result.caPem = resolved.caPem;
|
|
41
|
+
if (resolved.default !== undefined) {
|
|
42
|
+
result.certFile = resolved.default.certFile;
|
|
43
|
+
result.keyFile = resolved.default.keyFile;
|
|
44
|
+
}
|
|
45
|
+
return result;
|
|
46
|
+
}
|
|
47
|
+
/** Значение с источником (для статуса/приоритетов). */
|
|
48
|
+
function pickWithSource(envValue, runtimeValue, configValue) {
|
|
49
|
+
if (envValue !== undefined && envValue !== '')
|
|
50
|
+
return { value: envValue, source: 'env' };
|
|
51
|
+
if (runtimeValue !== undefined && runtimeValue !== '')
|
|
52
|
+
return { value: runtimeValue, source: 'runtime' };
|
|
53
|
+
if (configValue !== undefined && configValue !== '')
|
|
54
|
+
return { value: configValue, source: 'config' };
|
|
55
|
+
return { source: 'none' };
|
|
56
|
+
}
|
|
57
|
+
/**
|
|
58
|
+
* Эффективные клиентские профили (mTLS) + CA/rejectUnauthorized с источниками.
|
|
59
|
+
*
|
|
60
|
+
* Приоритет поле-уровневый: `env > runtime > config`. Клиентская пара
|
|
61
|
+
* `certFile`/`keyFile` собирается по полям; неполная пара (серт без ключа или
|
|
62
|
+
* наоборот) — fail-closed: mTLS без ключа/серта не работает, а «тихий» выбор
|
|
63
|
+
* одного источника скрыл бы опечатку. Маппинги — только runtime (редактируемые).
|
|
64
|
+
*/
|
|
65
|
+
export function resolveTlsProfiles(config, env = process.env, runtime) {
|
|
66
|
+
const e = env;
|
|
67
|
+
const cfg = config?.security?.tls ?? {};
|
|
68
|
+
const rt = runtime ?? {};
|
|
69
|
+
const caFile = pickWithSource(e[TLS_ENV.caFile], rt.caFile, cfg.caFile);
|
|
70
|
+
const caPem = pickWithSource(e[TLS_ENV.caPem], rt.caPem, cfg.caPem);
|
|
71
|
+
if (caFile.value !== undefined && caPem.value !== undefined) {
|
|
72
|
+
throw new Error(`[config] security.tls: 'caFile' и 'caPem' взаимоисключащи — задайте ровно один ` +
|
|
73
|
+
`источник CA (${TLS_ENV.caFile} ИЛИ ${TLS_ENV.caPem}); конфликт между источниками ` +
|
|
74
|
+
'(env/runtime/config) не разрешается автоматически');
|
|
75
|
+
}
|
|
76
|
+
const caSource = caFile.value !== undefined ? caFile.source : caPem.source;
|
|
77
|
+
const reject = resolveRejectUnauthorizedWithSource(e[TLS_ENV.rejectUnauthorized], rt.rejectUnauthorized, cfg.rejectUnauthorized);
|
|
78
|
+
const certFile = pickWithSource(e[TLS_ENV.certFile], rt.defaultClient?.certFile, cfg.certFile);
|
|
79
|
+
const keyFile = pickWithSource(e[TLS_ENV.keyFile], rt.defaultClient?.keyFile, cfg.keyFile);
|
|
80
|
+
let defaultClient;
|
|
81
|
+
if (certFile.value !== undefined || keyFile.value !== undefined) {
|
|
82
|
+
if (certFile.value === undefined || keyFile.value === undefined) {
|
|
83
|
+
throw new Error('[config] security.tls: mTLS требует и certFile, и keyFile (задайте оба либо ни одного; ' +
|
|
84
|
+
'неполная пара между env/runtime/config — fail-closed)');
|
|
85
|
+
}
|
|
86
|
+
const clientSource = certFile.source === 'env' || keyFile.source === 'env'
|
|
87
|
+
? 'env'
|
|
88
|
+
: certFile.source === 'runtime' || keyFile.source === 'runtime'
|
|
89
|
+
? 'runtime'
|
|
90
|
+
: 'config';
|
|
91
|
+
defaultClient = {
|
|
92
|
+
id: 'default',
|
|
93
|
+
hosts: [],
|
|
94
|
+
certFile: certFile.value,
|
|
95
|
+
keyFile: keyFile.value,
|
|
96
|
+
source: clientSource,
|
|
97
|
+
readOnly: clientSource !== 'runtime',
|
|
98
|
+
};
|
|
99
|
+
}
|
|
100
|
+
const mappings = (rt.mappings ?? []).map((mapping) => ({
|
|
101
|
+
id: mapping.id,
|
|
102
|
+
hosts: [...mapping.hosts],
|
|
103
|
+
...(mapping.label !== undefined && mapping.label !== '' ? { label: mapping.label } : {}),
|
|
104
|
+
certFile: mapping.certFile,
|
|
105
|
+
keyFile: mapping.keyFile,
|
|
106
|
+
source: 'runtime',
|
|
107
|
+
readOnly: false,
|
|
108
|
+
}));
|
|
109
|
+
const resolved = {
|
|
110
|
+
mappings,
|
|
111
|
+
rejectUnauthorized: reject.value,
|
|
112
|
+
sources: {
|
|
113
|
+
ca: caSource,
|
|
114
|
+
rejectUnauthorized: reject.source,
|
|
115
|
+
defaultClient: defaultClient?.source ?? 'none',
|
|
116
|
+
},
|
|
117
|
+
};
|
|
118
|
+
if (defaultClient !== undefined)
|
|
119
|
+
resolved.default = defaultClient;
|
|
120
|
+
if (caFile.value !== undefined)
|
|
121
|
+
resolved.caFile = caFile.value;
|
|
122
|
+
if (caPem.value !== undefined)
|
|
123
|
+
resolved.caPem = caPem.value;
|
|
124
|
+
return resolved;
|
|
125
|
+
}
|
|
126
|
+
/** `rejectUnauthorized` с источником; невалидный env — warn + фоллбэк ниже. */
|
|
127
|
+
function resolveRejectUnauthorizedWithSource(rawEnv, runtimeValue, cfgValue) {
|
|
128
|
+
if (rawEnv !== undefined && rawEnv !== '') {
|
|
129
|
+
const v = rawEnv.toLowerCase();
|
|
130
|
+
if (v === 'true' || v === '1')
|
|
131
|
+
return { value: true, source: 'env' };
|
|
132
|
+
if (v === 'false' || v === '0')
|
|
133
|
+
return { value: false, source: 'env' };
|
|
134
|
+
console.warn(`[config] невалидное значение ${TLS_ENV.rejectUnauthorized}="${rawEnv}" (ожидается true/1/false/0) — игнорируется`);
|
|
135
|
+
}
|
|
136
|
+
if (runtimeValue !== undefined)
|
|
137
|
+
return { value: runtimeValue, source: 'runtime' };
|
|
138
|
+
if (cfgValue !== undefined)
|
|
139
|
+
return { value: cfgValue, source: 'config' };
|
|
140
|
+
return { value: true, source: 'none' };
|
|
141
|
+
}
|
|
142
|
+
/**
|
|
143
|
+
* Выбирает клиентский профиль по host: точное совпадение, `*.suffix` (поддомены)
|
|
144
|
+
* либо `*` (все хосты), регистронезависимо; **первое** совпадение в порядке
|
|
145
|
+
* маппингов, затем профиль по умолчанию, иначе `undefined` (без клиентского серта).
|
|
146
|
+
*/
|
|
147
|
+
export function selectTlsClientProfile(profiles, host) {
|
|
148
|
+
const normalized = normalizeTlsHost(host);
|
|
149
|
+
if (normalized !== undefined) {
|
|
150
|
+
for (const mapping of profiles.mappings) {
|
|
151
|
+
if (mapping.hosts.some((pattern) => matchTlsHostPattern(pattern, normalized))) {
|
|
152
|
+
return mapping;
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
}
|
|
156
|
+
return profiles.default;
|
|
157
|
+
}
|
|
158
|
+
/** Матчинг одного паттерна (`host` | `*.suffix` | `*`); регистронезависимо. */
|
|
159
|
+
export function matchTlsHostPattern(pattern, rawHost) {
|
|
160
|
+
const host = normalizeTlsHost(rawHost);
|
|
161
|
+
if (host === undefined)
|
|
162
|
+
return false;
|
|
163
|
+
const value = pattern.trim().toLowerCase().replace(/\.$/, '');
|
|
164
|
+
if (value === '*')
|
|
165
|
+
return true;
|
|
166
|
+
if (value.startsWith('*.')) {
|
|
167
|
+
const suffix = value.slice(2);
|
|
168
|
+
return suffix !== '' && host.endsWith(`.${suffix}`);
|
|
169
|
+
}
|
|
170
|
+
return host === value;
|
|
171
|
+
}
|
|
172
|
+
/** Нормализует host (нижний регистр, без точки в конце и скобок IPv6). */
|
|
173
|
+
export function normalizeTlsHost(rawHost) {
|
|
174
|
+
if (typeof rawHost !== 'string')
|
|
175
|
+
return undefined;
|
|
176
|
+
let host = rawHost.trim().toLowerCase().replace(/\.$/, '');
|
|
177
|
+
if (host.startsWith('[') && host.endsWith(']'))
|
|
178
|
+
host = host.slice(1, -1);
|
|
179
|
+
return host === '' ? undefined : host;
|
|
180
|
+
}
|
|
181
|
+
/**
|
|
182
|
+
* Эффективное доверие с прочитанным CA. Fail-closed: `caFile` задан, но файл
|
|
183
|
+
* отсутствует/не читается/не PEM → внятная ошибка (никакого тихого фоллбэка на
|
|
184
|
+
* системное доверие, иначе опечатка в пути молча ломает доверие к корпоративному CA).
|
|
185
|
+
* `caPem` также проверяется на PEM-блок.
|
|
186
|
+
*/
|
|
187
|
+
export function resolveTlsTrust(config, env = process.env, runtime) {
|
|
188
|
+
const resolved = resolveTlsConfig(config, env, runtime);
|
|
189
|
+
const profiles = resolveTlsProfiles(config, env, runtime);
|
|
190
|
+
let ca;
|
|
191
|
+
if (resolved.caFile !== undefined) {
|
|
192
|
+
let content;
|
|
193
|
+
try {
|
|
194
|
+
content = readFileSync(resolved.caFile, 'utf-8');
|
|
195
|
+
}
|
|
196
|
+
catch (err) {
|
|
197
|
+
const reason = err instanceof Error ? err.message : String(err);
|
|
198
|
+
throw new Error(`[config] security.tls.caFile: не удалось прочитать файл "${resolved.caFile}": ${reason}`);
|
|
199
|
+
}
|
|
200
|
+
if (!isPemContent(content)) {
|
|
201
|
+
throw new Error(`[config] security.tls.caFile: файл "${resolved.caFile}" не содержит PEM-сертификат ` +
|
|
202
|
+
`(ожидается блок "-----BEGIN CERTIFICATE-----")`);
|
|
203
|
+
}
|
|
204
|
+
ca = content;
|
|
205
|
+
}
|
|
206
|
+
else if (resolved.caPem !== undefined) {
|
|
207
|
+
if (!isPemContent(resolved.caPem)) {
|
|
208
|
+
throw new Error('[config] security.tls.caPem: значение не содержит PEM-сертификат ' +
|
|
209
|
+
'(ожидается блок "-----BEGIN CERTIFICATE-----")');
|
|
210
|
+
}
|
|
211
|
+
ca = resolved.caPem;
|
|
212
|
+
}
|
|
213
|
+
const enabled = ca !== undefined ||
|
|
214
|
+
resolved.certFile !== undefined ||
|
|
215
|
+
resolved.keyFile !== undefined ||
|
|
216
|
+
resolved.rejectUnauthorized === false ||
|
|
217
|
+
profiles.mappings.length > 0;
|
|
218
|
+
const trust = { enabled, rejectUnauthorized: resolved.rejectUnauthorized };
|
|
219
|
+
if (ca !== undefined)
|
|
220
|
+
trust.ca = ca;
|
|
221
|
+
if (resolved.certFile !== undefined)
|
|
222
|
+
trust.certFile = resolved.certFile;
|
|
223
|
+
if (resolved.keyFile !== undefined)
|
|
224
|
+
trust.keyFile = resolved.keyFile;
|
|
225
|
+
return trust;
|
|
226
|
+
}
|
|
227
|
+
/** Допустимые значения `sslmode` (в порядке документации; `verify-ca` — алиас). */
|
|
228
|
+
export const POSTGRES_SSL_MODES = ['disable', 'require', 'verify-full'];
|
|
229
|
+
/**
|
|
230
|
+
* Алиасы `sslmode`, нормализуемые к канонической форме. `verify-ca`
|
|
231
|
+
* (`pg-connection-string` v2 трактует его как `verify-full`) — принимаем как
|
|
232
|
+
* `verify-full` **с предупреждением**: тихая трактовка «с проверкой hostname»
|
|
233
|
+
* сюрпризом не будет.
|
|
234
|
+
*/
|
|
235
|
+
export const POSTGRES_SSL_MODE_ALIASES = {
|
|
236
|
+
'verify-ca': 'verify-full',
|
|
237
|
+
};
|
|
238
|
+
/**
|
|
239
|
+
* Нормализует `sslmode` (`disable`/`require`/`verify-full`, алиас `verify-ca` →
|
|
240
|
+
* `verify-full` с warn). Пусто — `undefined` (прежнее поведение, без TLS).
|
|
241
|
+
* Неизвестное значение — `undefined` (вызывающий решает: env → warn + игнор,
|
|
242
|
+
* config — Zod отвергает на схеме).
|
|
243
|
+
*/
|
|
244
|
+
export function normalizePostgresSslMode(raw) {
|
|
245
|
+
if (raw === undefined || raw === '')
|
|
246
|
+
return undefined;
|
|
247
|
+
if (POSTGRES_SSL_MODES.includes(raw))
|
|
248
|
+
return raw;
|
|
249
|
+
const alias = POSTGRES_SSL_MODE_ALIASES[raw];
|
|
250
|
+
if (alias !== undefined) {
|
|
251
|
+
console.warn(`[config] storage.postgres.sslmode="${raw}" принят как алиас "${alias}" ` +
|
|
252
|
+
`(проверка имени хоста включена)`);
|
|
253
|
+
return alias;
|
|
254
|
+
}
|
|
255
|
+
return undefined;
|
|
256
|
+
}
|
|
257
|
+
/**
|
|
258
|
+
* TLS-параметры, запрещённые в `dsn`. `pg` накладывает распарсенный
|
|
259
|
+
* `connectionString` **поверх** явного конфига (`Object.assign({}, config,
|
|
260
|
+
* parse(connectionString))`), поэтому `sslmode`/`sslrootcert`/… из DSN молча
|
|
261
|
+
* перекрывают переданный `ssl`-объект — вплоть до отключения TLS. Запрещаем их
|
|
262
|
+
* в DSN, чтобы политика доверия задавалась **только** в `storage.postgres.sslmode`
|
|
263
|
+
* + `security.tls`.
|
|
264
|
+
*/
|
|
265
|
+
export const DSN_TLS_PARAMS = [
|
|
266
|
+
'sslmode',
|
|
267
|
+
'sslrootcert',
|
|
268
|
+
'sslcert',
|
|
269
|
+
'sslkey',
|
|
270
|
+
'sslnegotiation',
|
|
271
|
+
'uselibpqcompat',
|
|
272
|
+
'ssl',
|
|
273
|
+
];
|
|
274
|
+
/**
|
|
275
|
+
* Находит TLS-параметры в строке подключения (URL-форма `?sslmode=…` и
|
|
276
|
+
* libpq-подобная `sslmode=…`). Возвращает уникальные имена (нижний регистр);
|
|
277
|
+
* пусто — DSN «чистый» по TLS.
|
|
278
|
+
*/
|
|
279
|
+
export function findDsnTlsParams(dsn) {
|
|
280
|
+
if (dsn === undefined || dsn.trim() === '')
|
|
281
|
+
return [];
|
|
282
|
+
const names = new Set();
|
|
283
|
+
try {
|
|
284
|
+
const url = new URL(dsn);
|
|
285
|
+
for (const key of url.searchParams.keys()) {
|
|
286
|
+
const k = key.toLowerCase();
|
|
287
|
+
if (DSN_TLS_PARAMS.includes(k))
|
|
288
|
+
names.add(k);
|
|
289
|
+
}
|
|
290
|
+
}
|
|
291
|
+
catch {
|
|
292
|
+
// не URL — проверим regex'ом ниже (libpq-подобная форма)
|
|
293
|
+
}
|
|
294
|
+
const re = /(?:^|[\s?&])(sslmode|sslrootcert|sslcert|sslkey|sslnegotiation|uselibpqcompat|ssl)\s*=/gi;
|
|
295
|
+
let match;
|
|
296
|
+
while ((match = re.exec(dsn)) !== null) {
|
|
297
|
+
if (match[1])
|
|
298
|
+
names.add(match[1].toLowerCase());
|
|
299
|
+
}
|
|
300
|
+
return [...names];
|
|
301
|
+
}
|
|
302
|
+
/**
|
|
303
|
+
* Собирает `ssl`-опции `pg` из **единого** источника доверия (ADR-099):
|
|
304
|
+
*
|
|
305
|
+
* | sslmode | ssl-опции `pg` |
|
|
306
|
+
* |----------------|----------------------------------------------------------------------|
|
|
307
|
+
* | не задан | прежнее поведение: `ssl` из legacy-поля либо ничего (без TLS) |
|
|
308
|
+
* | `disable` | `false` (TLS выключен явно) |
|
|
309
|
+
* | `require` | `{ rejectUnauthorized: false }` (+ `cert`/`key` при mTLS) |
|
|
310
|
+
* | `verify-full` | `{ rejectUnauthorized: true, ca, cert?, key?, servername? }` |
|
|
311
|
+
* | `verify-ca` | алиас `verify-full` (нормализуется с предупреждением) |
|
|
312
|
+
*
|
|
313
|
+
* **Fail-closed**: `verify-full` без сконфигурированного CA (`security.tls`)
|
|
314
|
+
* бросает ошибку — никакого тихого `rejectUnauthorized: false`.
|
|
315
|
+
* mTLS (`certFile`/`keyFile`) добавляется в `require`/`verify-full`.
|
|
316
|
+
* Для `verify-full` без DSN `servername` = host (кроме IP — SNI по IP запрещён);
|
|
317
|
+
* `pg` и сам выводит `servername` из host, явное значение — для прозрачности.
|
|
318
|
+
*/
|
|
319
|
+
export function buildPostgresSslOptions(input) {
|
|
320
|
+
const env = input.env ?? process.env;
|
|
321
|
+
const mode = normalizePostgresSslMode(input.sslmode);
|
|
322
|
+
if (mode === undefined) {
|
|
323
|
+
return input.ssl === undefined ? {} : { ssl: input.ssl };
|
|
324
|
+
}
|
|
325
|
+
if (mode === 'disable')
|
|
326
|
+
return { ssl: false };
|
|
327
|
+
// ADR-099: per-host mTLS — профиль выбирается по host БД (явный `host` либо
|
|
328
|
+
// host из DSN), затем default. CA/rejectUnauthorized — общие.
|
|
329
|
+
const profiles = resolveTlsProfiles(input.config, env, input.runtime);
|
|
330
|
+
const pgHost = input.host ?? hostFromDsn(input.connectionString);
|
|
331
|
+
const profile = selectTlsClientProfile(profiles, pgHost);
|
|
332
|
+
if (mode === 'require') {
|
|
333
|
+
// Шифрование без проверки сертификата; mTLS (сертификат клиента) — если задан.
|
|
334
|
+
const ssl = { rejectUnauthorized: false };
|
|
335
|
+
applyClientIdentity(ssl, profile ?? {});
|
|
336
|
+
return { ssl };
|
|
337
|
+
}
|
|
338
|
+
// verify-full: CA обязателен (fail-closed — не тихий фоллбэк на системное доверие).
|
|
339
|
+
const trust = resolveTlsTrust(input.config, env, input.runtime);
|
|
340
|
+
if (trust.ca === undefined) {
|
|
341
|
+
throw new Error("[config] storage.postgres.sslmode='verify-full' требует доверенный CA: задайте " +
|
|
342
|
+
'security.tls.caFile или security.tls.caPem (иначе проверка сертификата сервера ' +
|
|
343
|
+
'невозможна — fail-closed, тихое rejectUnauthorized:false запрещено)');
|
|
344
|
+
}
|
|
345
|
+
const ssl = { rejectUnauthorized: true, ca: trust.ca };
|
|
346
|
+
applyClientIdentity(ssl, profile ?? {});
|
|
347
|
+
if (input.connectionString === undefined &&
|
|
348
|
+
typeof input.host === 'string' &&
|
|
349
|
+
input.host !== '' &&
|
|
350
|
+
isIP(input.host) === 0) {
|
|
351
|
+
ssl.servername = input.host;
|
|
352
|
+
}
|
|
353
|
+
return { ssl };
|
|
354
|
+
}
|
|
355
|
+
/** Host из строки подключения (URL-форма); невалидный DSN → `undefined`. */
|
|
356
|
+
function hostFromDsn(dsn) {
|
|
357
|
+
if (dsn === undefined || dsn.trim() === '')
|
|
358
|
+
return undefined;
|
|
359
|
+
try {
|
|
360
|
+
return new URL(dsn).hostname || undefined;
|
|
361
|
+
}
|
|
362
|
+
catch {
|
|
363
|
+
return undefined;
|
|
364
|
+
}
|
|
365
|
+
}
|
|
366
|
+
/**
|
|
367
|
+
* Добавляет клиентский сертификат/ключ (mTLS) в `ssl`-объект. Задан ровно один из
|
|
368
|
+
* `certFile`/`keyFile` — ошибка (нужны оба); читается только при их наличии.
|
|
369
|
+
*/
|
|
370
|
+
function applyClientIdentity(ssl, cfg) {
|
|
371
|
+
if (cfg.certFile === undefined && cfg.keyFile === undefined)
|
|
372
|
+
return;
|
|
373
|
+
if (cfg.certFile === undefined || cfg.keyFile === undefined) {
|
|
374
|
+
throw new Error('[config] security.tls: mTLS требует и certFile, и keyFile (задайте оба либо ни одного)');
|
|
375
|
+
}
|
|
376
|
+
ssl.cert = readPemFileContent(cfg.certFile, 'certFile', /-----BEGIN CERTIFICATE-----/);
|
|
377
|
+
ssl.key = readPemFileContent(cfg.keyFile, 'keyFile', /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/);
|
|
378
|
+
}
|
|
379
|
+
/** Читает PEM-файл клиентского сертификата/ключа; нет/не PEM → внятная ошибка. */
|
|
380
|
+
function readPemFileContent(path, field, marker) {
|
|
381
|
+
let content;
|
|
382
|
+
try {
|
|
383
|
+
content = readFileSync(path, 'utf-8');
|
|
384
|
+
}
|
|
385
|
+
catch (err) {
|
|
386
|
+
const reason = err instanceof Error ? err.message : String(err);
|
|
387
|
+
throw new Error(`[config] security.tls.${field}: не удалось прочитать файл "${path}": ${reason}`);
|
|
388
|
+
}
|
|
389
|
+
if (!marker.test(content)) {
|
|
390
|
+
throw new Error(`[config] security.tls.${field}: файл "${path}" не содержит PEM ` +
|
|
391
|
+
`(ожидается блок "-----BEGIN ${field === 'keyFile' ? 'PRIVATE KEY' : 'CERTIFICATE'}-----")`);
|
|
392
|
+
}
|
|
393
|
+
return content;
|
|
394
|
+
}
|