Skip to content

Node.js based forum software built for the modern web

16.0 KB
Raw Blame
'use strict';

const assert = require('assert');
const nconf = require('nconf');
const { createHash } = require('crypto');
const { importPublicKey, getWebcrypto } = require('@misskey-dev/node-http-message-signatures');

const db = require('../mocks/databasemock');
const user = require('../../src/user');
const utils = require('../../src/utils');
const activitypub = require('../../src/activitypub');

describe('http signature signing and verification', () => {
	describe('.sign()', () => {
		let uid;

		before(async () => {
			uid = await user.create({ username: utils.generateUUID().slice(0, 10) });
		});

		it('should create a key-pair for a user if the user does not have one already', async () => {
			const endpoint = `${nconf.get('url')}/uid/${uid}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			await activitypub.sign(keyData, endpoint);
			const { publicKey, privateKey } = await db.getObject(`uid:${uid}:keys`);

			assert(publicKey);
			assert(privateKey);
		});

		it('should return an object with date, a null digest, and signature, if no payload is passed in', async () => {
			const endpoint = `${nconf.get('url')}/uid/${uid}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { date, digest, signature } = await activitypub.sign(keyData, endpoint);
			const dateObj = new Date(date);

			assert(signature);
			assert(dateObj);
			assert.strictEqual(digest, undefined);
		});

		it('should also return a digest hash if payload is passed in', async () => {
			const endpoint = `${nconf.get('url')}/uid/${uid}/inbox`;
			const payload = { foo: 'bar' };
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const hash = createHash('sha256');
			hash.update(JSON.stringify(payload));
			const checksum = `SHA-256=${hash.digest('base64')}`;
			const { digest } = await activitypub.sign(keyData, endpoint, checksum);

			assert(digest);
			assert.strictEqual(digest, checksum);
		});

		it('should create a key for NodeBB itself if a uid of 0 is passed in', async () => {
			const endpoint = `${nconf.get('url')}/uid/${uid}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', 0);
			await activitypub.sign(keyData, endpoint);
			const { publicKey, privateKey } = await db.getObject(`uid:0:keys`);

			assert(publicKey);
			assert(privateKey);
		});

		it('should return headers with an appropriate key id uri', async () => {
			const endpoint = `${nconf.get('url')}/uid/${uid}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { signature } = await activitypub.sign(keyData, endpoint);
			const [keyId] = signature.split(',');

			assert(signature);
			assert.strictEqual(keyId, `keyId="${nconf.get('url')}/uid/${uid}#key"`);
		});

		it('should return the instance key id when uid is 0', async () => {
			const endpoint = `${nconf.get('url')}/uid/${uid}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', 0);
			const { signature } = await activitypub.sign(keyData, endpoint);
			const [keyId] = signature.split(',');

			assert(signature);
			assert.strictEqual(keyId, `keyId="${nconf.get('url')}/actor#key"`);
		});
	});

	describe('.verify()', () => {
		let uid;
		let username;
		const baseUrl = nconf.get('relative_path');
		const mockReqBase = {
			method: 'GET',
			// path: ...
			baseUrl,
			headers: {
				// host: ...
				// date: ...
				// signature: ...
				// digest: ...
			},
		};

		before(async () => {
			username = utils.generateUUID().slice(0, 10);
			uid = await user.create({ username });
		});

		it('should return true when the proper signature and relevant headers are passed in', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const path = `/user/${username}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const signature = await activitypub.sign(keyData, endpoint);
			const { host } = nconf.get('url_parsed');
			const req = {
				...mockReqBase,
				...{
					url: path,
					path,
					headers: { ...signature, host },
				},
			};

			const verified = await activitypub.verify(req);
			assert.strictEqual(verified, `${nconf.get('url')}/uid/${uid}#key`);
		});

		it('should return true when a digest is also passed in', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const path = `/user/${username}/inbox`;
			const payload = { foo: 'bar' };
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const hash = createHash('sha256');
			hash.update(JSON.stringify(payload));
			const checksum = `SHA-256=${hash.digest('base64')}`;
			const signature = await activitypub.sign(keyData, endpoint, checksum);
			const { host } = nconf.get('url_parsed');
			const req = {
				...mockReqBase,
				...{
					method: 'POST',
					url: path,
					path,
					body: payload,
					headers: { ...signature, host },
				},
			};

			const verified = await activitypub.verify(req);
			assert.strictEqual(verified, `${nconf.get('url')}/uid/${uid}#key`);
		});

		it('should return true when a valid RFC 9421 signature is passed in', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const path = `/user/${username}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { date, 'signature-input': signatureInput, signature } =
				await activitypub.signatures.signRfc9421(keyData, endpoint, 'GET');
			const { host } = nconf.get('url_parsed');
			const req = {
				...mockReqBase,
				...{
					url: path,
					path,
					headers: { date, 'signature-input': signatureInput, signature, host },
				},
			};

			const verified = await activitypub.verify(req);
			assert.strictEqual(verified, `${nconf.get('url')}/uid/${uid}#key`);
		});

		it('should return true when an RFC 9421 signature with content digest is passed in', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const path = `/user/${username}/inbox`;
			const payload = { foo: 'bar' };
			const body = JSON.stringify(payload);
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const hash = createHash('sha256');
			hash.update(body);
			const expectedContentDigest = `sha-256=:${hash.digest('base64')}:`;
			const {
				date,
				'content-digest': contentDigest,
				'content-type': contentType,
				'signature-input': signatureInput,
				signature,
			} = await activitypub.signatures.signRfc9421(keyData, endpoint, 'POST', body);
			assert.strictEqual(contentDigest, expectedContentDigest);
			assert.strictEqual(contentType, 'application/ld+json; profile="https://www.w3.org/ns/activitystreams"');
			const { host } = nconf.get('url_parsed');
			const req = {
				...mockReqBase,
				...{
					method: 'POST',
					url: path,
					path,
					body: payload,
					headers: {
						date,
						'content-digest': contentDigest,
						'content-type': contentType,
						'signature-input': signatureInput,
						signature,
						host,
					},
				},
			};

			const verified = await activitypub.verify(req);
			assert.strictEqual(verified, `${nconf.get('url')}/uid/${uid}#key`);
		});

		it('should return false when an RFC 9421 signature does not verify', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const path = `/user/${username}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { date, 'signature-input': signatureInput, signature } =
				await activitypub.signatures.signRfc9421(keyData, endpoint, 'GET');
			const { host } = nconf.get('url_parsed');
			const req = {
				...mockReqBase,
				...{
					url: path,
					path,
					headers: {
						// Tamper with a covered component (date)
						date: 'Wed, 01 Jan 2020 00:00:00 GMT',
						'signature-input': signatureInput,
						signature,
						host,
					},
				},
			};

			const verified = await activitypub.verify(req);
			assert.strictEqual(verified, false);
		});
	});

	describe('.signRfc9421()', () => {
		let uid;
		const username = utils.generateUUID().slice(0, 10);

		before(async () => {
			uid = await user.create({ username });
		});

		it('should produce an activitypub structured-field byte sequence Signature header', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { signature } = await activitypub.signatures.signRfc9421(keyData, endpoint, 'GET');
			// RFC 8941/9651 byte sequence: ":" + base64 + ":"
			assert.match(signature, /^activitypub=:[0-9A-Za-z+/]+={0,2}:$/);
		});

		it('should cover the strict ActivityPub GET components', async () => {
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { 'signature-input': signatureInput } =
				await activitypub.signatures.signRfc9421(keyData, endpoint, 'GET');
			const componentIds = [...signatureInput.matchAll(/"([^"]*)"/g)].map((m) => m[1]);
			assert.deepStrictEqual(componentIds.slice(0, 4), [
				'@method',
				'@authority',
				'@target-uri',
				'date',
			]);
			assert(signatureInput.includes('tag="activitypub"'));
			assert(signatureInput.includes('alg="rsa-v1_5-sha256"'));
			assert(/;nonce="[^"]+";created=\d+$/.test(signatureInput));
		});

		it('should produce a strict ActivityPub signature that verifies against an independent signature base reconstruction', async () => {
			// Reconstruct the signature base by hand instead of trusting the same
			// RFC9421SignatureBaseFactory on both sides of the test.
			const endpoint = `${nconf.get('url')}/user/${username}/inbox`;
			const keyData = await activitypub.getPrivateKey('uid', uid);
			const { date, 'signature-input': signatureInput, signature } =
				await activitypub.signatures.signRfc9421(keyData, endpoint, 'GET');
			const { host } = nconf.get('url_parsed');

			const paramsMatch = signatureInput.match(
				/^activitypub=(\([^)]*\));keyid="([^"]*)";alg="([^"]*)";tag="activitypub";nonce="([^"]+)";created=(\d+)$/
			);
			assert(paramsMatch, `unexpected Signature-Input format: ${signatureInput}`);
			const [, componentsInnerList, keyId, algorithm, nonce, created] = paramsMatch;
			const componentIds = [...componentsInnerList.matchAll(/"([^"]*)"/g)].map((m) => m[1]);
			assert.deepStrictEqual(componentIds, ['@method', '@authority', '@target-uri', 'date']);
			assert.strictEqual(algorithm, 'rsa-v1_5-sha256');
			const componentValues = {
				'@method': 'GET',
				'@authority': host,
				'@target-uri': endpoint,
				date,
			};
			const lines = componentIds.map((id) => `"${id}": ${componentValues[id]}`);
			lines.push(
				`"@signature-params": ${componentsInnerList};keyid="${keyId}";alg="${algorithm}";tag="activitypub";nonce="${nonce}";created=${created}`
			);
			const expectedBase = lines.join('\n');

			const publicKeyPem = await activitypub.getPublicKey('uid', uid);
			const publicKey = await importPublicKey(publicKeyPem, ['verify']);
			const webcrypto = await getWebcrypto();
			const verified = await webcrypto.subtle.verify(
				{ name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
				publicKey,
				Buffer.from(signature.slice('activitypub=:'.length, -1), 'base64'),
				new TextEncoder().encode(expectedBase),
			);
			assert.strictEqual(verified, true);
		});
	});

	describe('.getKeyId()', () => {
		it('should extract the keyId from a draft signature header', () => {
			const headers = {
				signature: 'keyId="https://example.org/user/test#key",algorithm="rsa-sha256",headers="(request-target) host date",signature="abc="',
			};
			assert.strictEqual(activitypub.signatures.getKeyId(headers), 'https://example.org/user/test#key');
		});

		it('should use the last keyId when a draft signature header contains duplicates', () => {
			const headers = {
				signature: 'keyId="https://example.org/a#key",keyId="https://example.org/b#key",signature="abc="',
			};
			assert.strictEqual(activitypub.signatures.getKeyId(headers), 'https://example.org/b#key');
		});

		it('should extract the keyid from an RFC 9421 Signature-Input header', () => {
			const headers = {
				'signature-input': 'sig1=("@request-target" "host" "date");created=1787933487;keyid="https://example.org/user/test#key"',
				signature: 'sig1="abc="',
			};
			assert.strictEqual(activitypub.signatures.getKeyId(headers), 'https://example.org/user/test#key');
		});

		it('should return null when no key identifier is present', () => {
			assert.strictEqual(activitypub.signatures.getKeyId({ signature: 'signature="abc="' }), null);
			assert.strictEqual(activitypub.signatures.getKeyId({}), null);
		});
	});

	describe('draft signatures with non-RSA keys', () => {
		it('should sign and verify a draft signature made with an EC key', async () => {
			const { generateKeyPairSync } = require('crypto');
			const kp = generateKeyPairSync('ec', { namedCurve: 'P-256' });
			const privPem = kp.privateKey.export({ format: 'pem', type: 'pkcs8' }).toString();
			const pubPem = kp.publicKey.export({ format: 'pem', type: 'spki' }).toString();
			const keyId = 'https://example.org/ec-actor#key';
			const endpoint = `${nconf.get('url')}/uid/999/inbox`;
			const headers = await activitypub.signatures.sign({ key: privPem, keyId }, endpoint, 'GET');

			// The header must advertise an EC algorithm, not rsa-sha256
			assert(headers.signature.includes('algorithm="ecdsa-p256-sha256"'),
				`unexpected draft algorithm string: ${headers.signature}`);

			const req = {
				method: 'GET',
				url: '/uid/999/inbox',
				path: '/uid/999/inbox',
				headers: { ...headers, host: nconf.get('url_parsed').host },
			};

			const verified = await activitypub.signatures.verify(req, async () => pubPem);
			assert.strictEqual(verified, 'https://example.org/ec-actor#key');
		});
	});

	describe('keyId parser mismatch (regression)', () => {
		it('should return the verified keyId, not a value a naive re-parse extracts from a crafted header', async () => {
			const { generateKeyPairSync } = require('crypto');
			const {
				genDraftSigningString, genDraftSignature, importPrivateKey,
			} = require('@misskey-dev/node-http-message-signatures');

			const attacker = generateKeyPairSync('ec', { namedCurve: 'P-256' });
			const attackerPrivPem = attacker.privateKey.export({ format: 'pem', type: 'pkcs8' }).toString();
			const attackerPubPem = attacker.publicKey.export({ format: 'pem', type: 'spki' }).toString();
			const attackerKeyId = 'https://attacker.example/actor#main-key';
			const victimKeyId = 'https://victim.example/actor#main-key';

			const endpoint = `${nconf.get('url')}/uid/1/inbox`;
			const url = new URL(endpoint);
			const date = new Date().toUTCString();
			const reqHeaders = { date, host: nconf.get('url_parsed').host };
			const includeHeaders = ['(request-target)', 'host', 'date'];
			const ALGO = 'ecdsa-p256-sha256';

			// The attacker signs with THEIR key; the signing string uses the attacker keyId.
			const signingString = genDraftSigningString(
				{ method: 'GET', url: url.href, headers: reqHeaders },
				includeHeaders,
				{ keyId: attackerKeyId, algorithm: ALGO }
			);
			const privateKey = await importPrivateKey(attackerPrivPem, ['sign']);
			const SIG = await genDraftSignature(privateKey, signingString);

			// A crafted header whose quoted `foo` value contains a comma: a naive
			// split(',')-based parser reports the VICTIM keyId (the comma-split tail
			// that looks like a standalone keyId="..." param), while the spec-aware
			// parser used for verification reports the ATTACKER keyId.
			const header = `keyId="${attackerKeyId}",algorithm="${ALGO}",headers="${includeHeaders.join(' ')}",signature="${SIG}",foo="x,keyId="${victimKeyId}"`;

			// Precondition: the two parsers actually disagree on this header.
			assert.strictEqual(activitypub.signatures.getKeyId({ signature: header }), victimKeyId);

			// The verified keyId MUST be the attacker's (the key that actually signed),
			// so downstream identity (req.uid) cannot be spoofed to the victim.
			const verified = await activitypub.signatures.verify(
				{
					method: 'GET',
					url: '/uid/1/inbox',
					path: '/uid/1/inbox',
					headers: { ...reqHeaders, signature: header },
				},
				async (keyId) => (keyId === attackerKeyId ? attackerPubPem : null)
			);
			assert.strictEqual(verified, attackerKeyId);
		});
	});
});