Skip to content

Node.js based forum software built for the modern web

9.6 KB
Raw Blame
'use strict';

const assert = require('assert');
const path = require('path');
const workerpool = require('workerpool');

describe('sendWorker', () => {
	let pool;

	beforeEach(() => {
		pool = workerpool.pool(path.join(__dirname, '../../src/activitypub/sendWorker.js'), {
			minWorkers: 1,
			maxWorkers: 1,
			workerType: 'process',
			forkOpts: { silent: true },
		});
	});

	afterEach((done) => {
		pool.terminate(true, 1000).then(() => {
			done();
		}).catch(() => {
			done();
		});
	});

	describe('send task', () => {
		it('should emit a result on failed send', async () => {
			// Use a private IP so the SSRF check rejects it immediately — a
			// non-resolving hostname (.invalid/.example) triggers a real DNS lookup
			// that times out at ~10s in CI containers.
			const result = await pool.exec('send', [{
				id: 'test-task-1',
				uri: 'http://10.0.0.1/test',
				payload: JSON.stringify({ type: 'Create' }),
				digest: 'SHA-256=invalid',
				key: '-----BEGIN PRIVATE KEY-----\nINVALID\n-----END PRIVATE KEY-----',
				keyId: 'https://example.org/actor#key',
			}], { timeout: 5000 });
			assert.strictEqual(result.success, false);
		});

		it('should reject tasks with missing fields', async () => {
			let result;
			try {
				result = await pool.exec('send', [{
					id: 'missing-fields-test',
					uri: 'https://example.org/test',
					// Missing payload, digest, key, keyId
				}], { timeout: 5000 });
			} catch (e) {
				result = { success: false, error: e.message };
			}
			assert.strictEqual(result.success, false);
			assert(result.error.toLowerCase().includes('missing'));
		});
	});

	describe('RFC 9421 signing with draft fallback', () => {
		const http = require('http');
		const { createHash, generateKeyPairSync, webcrypto } = require('crypto');
		const sfv = require('structured-headers');
		const {
			RFC9421SignatureBaseFactory,
			importPublicKey,
			parseDraftRequest,
			verifyDraftSignature,
		} = require('@misskey-dev/node-http-message-signatures');

		let innerPool;
		let server;
		let port;
		let requests;
		let pubPem;
		let privPem;
		const keyId = 'https://nodebb.test/actor#key';

		before(async () => {
			const kp = generateKeyPairSync('rsa', { modulusLength: 2048, publicExponent: 0x10001 });
			privPem = kp.privateKey.export({ format: 'pem', type: 'pkcs8' }).toString();
			pubPem = kp.publicKey.export({ format: 'pem', type: 'spki' }).toString();
		});

		beforeEach(async () => {
			requests = [];

			server = http.createServer((req, res) => {
				const chunks = [];
				req.on('data', (c) => chunks.push(c));
				req.on('end', async () => {
					const raw = Buffer.concat(chunks);
					const fullUrl = `http://127.0.0.1:${port}${req.url}`;
					const signatureInput = String(req.headers['signature-input'] || '');
					const entry = {
						hasRfc: !!req.headers['signature-input'],
						isDraft: typeof req.headers.signature === 'string' && req.headers.signature.includes('keyId="'),
						contentDigestOk: req.headers['content-digest'] ===
							`sha-256=:${createHash('sha256').update(raw).digest('base64')}:`,
						legacyDigestOk: req.headers.digest ===
							`SHA-256=${createHash('sha256').update(raw).digest('base64')}`,
						strictProfile: signatureInput.startsWith(
							'activitypub=("@method" "@authority" "@target-uri" "content-digest" "content-type" "date");'
						) &&
							signatureInput.includes(';alg="rsa-v1_5-sha256";tag="activitypub";nonce="') &&
							/;created=\d+$/.test(signatureInput),
					};
					try {
						if (entry.hasRfc) {
							const base = new RFC9421SignatureBaseFactory({
								method: req.method,
								url: fullUrl,
								headers: req.headers,
							});
							const sigDict = sfv.parseDictionary(String(req.headers.signature));
							const sigItem = sigDict.get('activitypub');
							if (!sigItem || !sfv.isByteSequence(sigItem[0])) {
								throw new Error('Signature value is not an activitypub byte sequence');
							}
							const pub = await importPublicKey(pubPem, ['verify']);
							entry.rfcValid = await webcrypto.subtle.verify(
								{ name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
								pub,
								Buffer.from(sigItem[0].base64Value, 'base64'),
								new TextEncoder().encode(base.generate('activitypub')),
							);
						} else if (entry.isDraft) {
							const parsed = parseDraftRequest({
								method: req.method,
								url: fullUrl,
								headers: req.headers,
							});
							entry.draftValid = await verifyDraftSignature(parsed.value, pubPem);
						}
					} catch (e) {
						entry.verifyError = e.message;
					}
					requests.push(entry);
					const accepted = (
						server.mode === 'rfc' &&
						entry.hasRfc &&
						entry.strictProfile &&
						entry.contentDigestOk &&
						entry.rfcValid === true
					) || (
						server.mode === 'draft' &&
						entry.isDraft &&
						entry.legacyDigestOk &&
						entry.draftValid === true
					);
					res.writeHead(accepted ? 202 : 401, { 'content-type': 'application/json' });
					res.end(JSON.stringify({ accepted }));
				});
			});
			await new Promise((resolve) => {
				server.listen(0, '127.0.0.1', resolve);
			});
			port = server.address().port;

			innerPool = workerpool.pool(path.join(__dirname, '../../src/activitypub/sendWorker.js'), {
				minWorkers: 1,
				maxWorkers: 1,
				workerType: 'process',
				forkOpts: {
					silent: true,
					execArgv: ['--require', require.resolve('./ssrf-allow-localhost')],
				},
			});
		});

		afterEach((done) => {
			Promise.all([
				innerPool ? innerPool.terminate(true, 1000) : Promise.resolve(),
				new Promise((resolve) => server.close(resolve)),
			]).then(() => done()).catch(() => done());
		});

		function task(mode) {
			const payload = JSON.stringify({ id: 'https://nodebb.test/activities/1', type: 'Create' });
			return {
				id: `rfc-strict-${mode}`,
				uri: `http://127.0.0.1:${port}/inbox`,
				payload,
				digest: `SHA-256=${createHash('sha256').update(payload).digest('base64')}`,
				key: privPem,
				keyId,
			};
		}

		it('should sign once with the strict ActivityPub RFC 9421 profile when the server accepts it', async () => {
			server.mode = 'rfc';
			const result = await innerPool.exec('send', [task('rfc')], { timeout: 30000 });

			assert.strictEqual(result.success, true);
			assert.strictEqual(requests.length, 1);
			assert.strictEqual(requests[0].hasRfc, true);
			assert.strictEqual(requests[0].isDraft, false);
			assert.strictEqual(requests[0].strictProfile, true);
			assert.strictEqual(requests[0].contentDigestOk, true);
			assert.strictEqual(requests[0].rfcValid, true);
		});

		it('should fall back to a draft signature when the server rejects RFC 9421', async () => {
			server.mode = 'draft';
			const result = await innerPool.exec('send', [task('draft')], { timeout: 30000 });

			assert.strictEqual(result.success, true);
			assert.strictEqual(requests.length, 2);
			assert.strictEqual(requests[0].hasRfc, true);
			assert.strictEqual(requests[0].isDraft, false);
			assert.strictEqual(requests[0].strictProfile, true);
			assert.strictEqual(requests[0].contentDigestOk, true);
			assert.strictEqual(requests[0].rfcValid, true);
			assert.strictEqual(requests[1].isDraft, true);
			assert.strictEqual(requests[1].legacyDigestOk, true);
			assert.strictEqual(requests[1].draftValid, true);
		});

		it('should fail when the server rejects both signature schemes', async () => {
			server.mode = 'none';
			const result = await innerPool.exec('send', [task('none')], { timeout: 30000 });

			assert.strictEqual(result.success, false);
			assert.strictEqual(requests.length, 2);
			assert.strictEqual(requests[0].hasRfc, true);
			assert.strictEqual(requests[0].isDraft, false);
			assert.strictEqual(requests[0].strictProfile, true);
			assert.strictEqual(requests[0].contentDigestOk, true);
			assert.strictEqual(requests[0].rfcValid, true);
			assert.strictEqual(requests[1].isDraft, true);
			assert.strictEqual(requests[1].legacyDigestOk, true);
			assert.strictEqual(requests[1].draftValid, true);
			assert(result.error.includes('401'));
			assert(result.fallback.includes('401'));
		});
	});

	describe('SSRF protection', () => {
		it('should reject localhost URLs', async () => {
			const result = await pool.exec('send', [{
				id: 'ssrf-test-1',
				uri: 'https://127.0.0.1/test',
				payload: JSON.stringify({ type: 'Create' }),
				digest: 'SHA-256=invalid',
				key: '-----BEGIN PRIVATE KEY-----\nINVALID\n-----END PRIVATE KEY-----',
				keyId: 'https://example.org/actor#key',
			}], { timeout: 10000 });
			assert.strictEqual(result.success, false);
			assert(result.error.toLowerCase().includes('ssrf') || result.error.toLowerCase().includes('forbidden'));
		});

		it('should reject private IP URLs', async () => {
			const result = await pool.exec('send', [{
				id: 'ssrf-test-2',
				uri: 'https://192.168.1.1/test',
				payload: JSON.stringify({ type: 'Create' }),
				digest: 'SHA-256=invalid',
				key: '-----BEGIN PRIVATE KEY-----\nINVALID\n-----END PRIVATE KEY-----',
				keyId: 'https://example.org/actor#key',
			}], { timeout: 10000 });
			assert.strictEqual(result.success, false);
			assert(result.error.toLowerCase().includes('ssrf') || result.error.toLowerCase().includes('forbidden'));
		});

		it('should reject link-local IP URLs', async () => {
			const result = await pool.exec('send', [{
				id: 'ssrf-test-3',
				uri: 'https://169.254.169.254/latest/meta-data/',
				payload: JSON.stringify({ type: 'Create' }),
				digest: 'SHA-256=invalid',
				key: '-----BEGIN PRIVATE KEY-----\nINVALID\n-----END PRIVATE KEY-----',
				keyId: 'https://example.org/actor#key',
			}], { timeout: 10000 });
			assert.strictEqual(result.success, false);
			assert(result.error.toLowerCase().includes('ssrf') || result.error.toLowerCase().includes('forbidden'));
		});
	});
});