Files
mtusi2026lab7/student-tests/security-probe.mjs
T

149 lines
8.2 KiB
JavaScript

import assert from 'node:assert/strict';
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
import { readFileSync } from 'node:fs';
import { request } from 'node:https';
import amqp from 'amqplib';
import pg from 'pg';
import { S3Client, PutObjectCommand, GetObjectCommand, ListObjectsV2Command, CopyObjectCommand } from '@aws-sdk/client-s3';
import { baoRequest, serviceSecretName, serviceTls } from '../src/security.ts';
const mode = process.argv[2];
const ca = serviceTls().ca;
const tls = serviceTls();
if (process.env.PROBE_IDENTITY) {
tls.cert = readFileSync(`/run/probes/${process.env.PROBE_IDENTITY}/tls.crt`);
tls.key = readFileSync(`/run/probes/${process.env.PROBE_IDENTITY}/tls.key`);
}
const target = process.env.PROBE_HOST;
const role = process.env.PROBE_ROLE ?? 'worker';
const ensure = (p, predicate) => assert.rejects(p, predicate);
const http = (url, method = 'GET') => new Promise((resolve, reject) => {
const req = request(url, { ...tls, agent: false, method,
servername: process.env.PROBE_SERVERNAME || undefined,
headers: method === 'POST' ? { 'Content-Type': 'application/x-protobuf', 'Content-Length': 0 } : undefined },
(res) => { res.resume(); res.on('end', () => resolve(res.statusCode)); });
req.on('error', reject);
req.setTimeout(4000, () => req.destroy(new Error('timeout')));
req.end();
});
if (process.env.PROBE_NO_CERT === '1') {
delete tls.cert;
delete tls.key;
}
const broker = () => amqp.connect('amqps://rabbitmq:5671/messenger', {
...tls, timeout: 4000, credentials: amqp.credentials.external(),
});
const auth = () => baoRequest('/v1/auth/cert/login', { name: role });
const tlsDeny = (err) => /TLS|SSL|CERT|ECONNRESET|socket hang up/.test(err.code ?? err.message);
const amqpDeny = (err) => /403|ACCESS_REFUSED|not allowed|Login was refused/i.test(err.message);
const s3Deny = (err) => err.$metadata?.httpStatusCode === 403;
const s3 = (values) => new S3Client({
endpoint: 'https://s3:9000', region: 'us-east-1', forcePathStyle: true, maxAttempts: 1,
credentials: { accessKeyId: values.S3_ACCESS_KEY_ID, secretAccessKey: values.S3_SECRET_ACCESS_KEY },
});
const Bucket = 'messenger-attachments';
const params = (Key) => ({ Bucket, Key });
const read = async (store, key) => (await store.send(new GetObjectCommand(params(key)))).Body.transformToString();
const write = (store, key) => store.send(new PutObjectCommand({ ...params(key), Body: 'security-probe' }));
const db = (values) => new pg.Client({ connectionString: values.DATABASE_URL, ssl: { ca, rejectUnauthorized: true },
connectionTimeoutMillis: 3000 });
if (mode === 'tls-audit') {
const matrix = process.env.AUDIT_NETWORK === 'backend'
? ['api', 'rabbitmq', 'otel-collector'].flatMap((host) => {
const leaf = host === 'api' ? 'lb-client' : 'worker';
return [[host, leaf, 'allow'], [host, 'wrong', 'deny'], [host, 'foreign', 'tls-deny'],
[host, leaf, 'tls-deny', '1'], [host, leaf, 'tls-deny', '', 'wrong.internal']];
})
: ['prometheus', 'loki', 'tempo'].flatMap((host) =>
[[host, 'grafana-query', 'allow'], [host, 'worker', 'tls-deny']]);
const exec = promisify(execFile);
for (const [host, leaf, expected, noCert, wrongHost] of matrix) {
if (host === 'rabbitmq' && wrongHost) continue;
const { stdout } = await exec(process.execPath, [import.meta.filename, 'tls'], { env: {
...process.env, PROBE_HOST: host, PROBE_IDENTITY: leaf, PROBE_EXPECT: expected,
PROBE_NO_CERT: noCert ?? '', PROBE_SERVERNAME: wrongHost ?? '',
}});
process.stdout.write(stdout);
}
} else if (mode === 'tls') {
const expected = process.env.PROBE_EXPECT;
if (target === 'rabbitmq') {
if (expected === 'allow') await (await broker()).close();
else await ensure(broker(), expected === 'deny' ? amqpDeny : tlsDeny);
} else {
const port = { api: 8080, 'otel-collector': 4318, prometheus: 9090, loki: 3100, tempo: 3200 }[target];
const suffix = { api: '/health/live', 'otel-collector': '/v1/traces', prometheus: '/-/ready', loki: '/loki/api/v1/labels', tempo: '/api/search?limit=1' }[target];
const call = http(`https://${target}:${port}${suffix}`, target === 'otel-collector' ? 'POST' : 'GET');
if (expected === 'allow') assert.equal(await call, 200);
else if (expected === 'deny' && target === 'otel-collector') assert.equal(await call, 403);
else await ensure(call, tlsDeny);
}
console.log(`PASS ${target} ${expected}`);
} else if (mode === 'scope') {
const { auth: session } = await auth();
const token = session.client_token;
assert.equal(session.lease_duration, 45);
{
const { data: { data: values } } = await baoRequest(`/v1/messenger/data/${serviceSecretName('worker')}`, undefined, token);
await ensure(baoRequest('/v1/messenger/data/api', undefined, token), /HTTP 403/);
await ensure(baoRequest('/v1/sys/policies/acl/api', { policy: '' }, token), /HTTP 403/);
await ensure(baoRequest(`/v1/messenger/data/${serviceSecretName('worker')}`, { data: {} }, token), /HTTP 403/);
console.log('PASS OpenBao own read; cross-role read, write and policy update denied; TTL 45s');
const client = db(values);
await client.connect();
assert.equal((await client.query('SELECT ssl FROM pg_stat_ssl WHERE pid=pg_backend_pid()')).rows[0].ssl, true);
await client.query('SELECT state FROM jobs LIMIT 1');
await client.query("UPDATE jobs SET state = 'done' WHERE false");
await ensure(client.query('SELECT password_hash FROM users LIMIT 1'), { code: '42501' });
await ensure(client.query('SELECT text FROM messages LIMIT 1'), { code: '42501' });
await ensure(client.query('DELETE FROM attachments WHERE false'), { code: '42501' });
await ensure(client.query('ALTER TABLE jobs ADD COLUMN probe int'), { code: '42501' });
await client.end();
console.log('PASS PostgreSQL TLS; job select/update allowed; users, messages, delete and DDL denied');
const store = s3(values);
const suffix = process.env.PROBE_KEY;
assert.equal(await read(store, 'staging/' + suffix), 'security-probe');
await write(store, 'variants/' + suffix);
await write(store, 'originals/' + suffix);
await ensure(read(store, 'private/' + suffix), s3Deny);
await ensure(write(store, 'private/' + suffix), s3Deny);
await ensure(store.send(new CopyObjectCommand({ ...params('originals/' + suffix), CopySource: Bucket + '/private/' + suffix })), s3Deny);
await ensure(store.send(new ListObjectsV2Command({ Bucket })), s3Deny);
console.log('PASS S3 staging read; variants/originals write; private read/write/copy and bucket list denied');
const conn = await broker();
const channel = await conn.createChannel();
const consumer = await channel.consume('attachments.process', () => {}, { noAck: false });
await channel.cancel(consumer.consumerTag);
await channel.close();
const publisher = await conn.createConfirmChannel();
publisher.on('error', () => {});
publisher.publish('attachments', 'process', Buffer.from('{}'));
await ensure(publisher.waitForConfirms(), /closed|ended|nack/i);
const configure = await conn.createChannel();
configure.on('error', () => {});
await ensure(configure.assertQueue('probe.unauthorized', { durable: false }), amqpDeny);
await conn.close();
console.log('PASS RabbitMQ worker consumes attachments.process; publish and queue creation denied');
}
} else if (mode === 'seed') {
const store = s3(JSON.parse(readFileSync('/run/probe/credentials.json', 'utf8')).data);
for (const prefix of ['staging', 'private']) await write(store, prefix + '/' + process.env.PROBE_KEY);
assert.equal(await read(store, 'private/' + process.env.PROBE_KEY), 'security-probe');
console.log('PASS operator seeds staging/private and reads private');
} else if (mode === 'revoked') {
const values = JSON.parse(readFileSync('/run/probe/credentials.json', 'utf8')).data;
await ensure(auth(), /HTTP (400|403)/);
await ensure(broker(), amqpDeny);
await ensure(http('https://otel-collector:4318/v1/traces', 'POST'), tlsDeny);
await ensure(db(values).connect(), { code: '28P01' });
await ensure(write(s3(values), 'variants/' + process.env.PROBE_KEY), s3Deny);
console.log('PASS old leaf denied by OpenBao, AMQP and OTLP; old DB password and S3 key denied');
} else {
throw new Error('Unknown probe');
}