Skip to content

Node.js based forum software built for the modern web

Split Domain support for remote users (#14676)

Julian Lamda87571620f1
diff --git a/install/data/defaults.json b/install/data/defaults.json
index fde027c5e7..c22c6d1df6 100644
--- a/install/data/defaults.json
+++ b/install/data/defaults.json
@@ -208,6 +208,7 @@
"tinyconBackground": "#ff0000",
"activitypubEnabled": 1,
"activitypubAllowLoopback": 0,
+ "activitypubAllowSplitDomain": 1,
"activitypubParentTraversalDepth": 50,
"activitypubPublicKeyFetchRateLimit": 256,
"activitypubProbe": 1,
diff --git a/public/language/en-GB/admin/settings/activitypub.json b/public/language/en-GB/admin/settings/activitypub.json
index 5cccb4579d..9f528c9507 100644
--- a/public/language/en-GB/admin/settings/activitypub.json
+++ b/public/language/en-GB/admin/settings/activitypub.json
@@ -13,6 +13,8 @@
"publicKeyFetchRateLimit-help": "Maximum number of public key fetch requests allowed per minute per IP. (Default: 256)",
"allowLoopback": "Allow loopback processing",
"allowLoopback-help": "Useful for debugging purposes only. You should probably leave this disabled.",
+ "allowSplitDomain": "Allow split-domain federation",
+ "allowSplitDomain-help": "Enable to allow actors whose WebFinger handle domain differs from their ActivityPub document domain. This is useful for instances that separate identity (WebFinger) from content hosting (ActivityPub).",
"parentTraversalDepth": "Parent traversal depth",
"parentTraversalDepth-help": "Maximum number of times to traverse up the reply chain when building context. (Default: 50)",
diff --git a/src/activitypub/actors.js b/src/activitypub/actors.js
index dd73803082..612b02f9fc 100644
--- a/src/activitypub/actors.js
+++ b/src/activitypub/actors.js
@@ -59,7 +59,7 @@ Actors.qualify = async (ids, options = {}) => {
ids = ids.filter(id => !activitypub._constants.acceptablePublicAddresses.includes(id));
// Translate webfinger handles to uris
- ids = (await Promise.all(ids.map(async (id) => {
+ const idsArr = (await Promise.all(ids.map(async (id) => {
const originalId = id;
if (activitypub.helpers.isWebfinger(id)) {
const host = id.replace(/^(acct:|@)/, '').split('@')[1];
@@ -67,7 +67,8 @@ Actors.qualify = async (ids, options = {}) => {
return 'loopback';
}
- ({ actorUri: id } = await activitypub.helpers.query(id));
+ const result = await activitypub.helpers.query(id);
+ ({ actorUri: id } = result || { actorUri: null });
}
// ensure the final id is a valid URI
if (!id || !activitypub.helpers.isUri(id)) {
@@ -78,18 +79,18 @@ Actors.qualify = async (ids, options = {}) => {
})));
// Webfinger failures = assertion failure
- if (!ids.length || !ids.every(Boolean)) {
+ if (!idsArr.length || !idsArr.every(Boolean)) {
return false;
}
// Filter out loopback uris — never persist local URIs as remote actors
- ids = ids.filter(uri => uri !== 'loopback' && new URL(uri).host !== nconf.get('url_parsed').host);
+ const filtered = idsArr.filter(uri => uri !== 'loopback' && new URL(uri).host !== nconf.get('url_parsed').host);
// Separate those who need migration from user to category
const migrate = new Set();
if (options.qualifyGroup) {
- const exists = await db.exists(ids.map(id => `userRemote:${id}`));
- ids.forEach((id, idx) => {
+ const exists = await db.exists(filtered.map(id => `userRemote:${id}`));
+ filtered.forEach((id, idx) => {
if (exists[idx]) {
migrate.add(id);
}
@@ -99,14 +100,15 @@ Actors.qualify = async (ids, options = {}) => {
// Only assert those who haven't been seen recently (configurable), unless update flag passed in (force refresh)
if (!options.update) {
const upperBound = Date.now() - (1000 * 60 * 60 * 24 * meta.config.activitypubUserPruneDays);
- const lastCrawled = await db.sortedSetScores('usersRemote:lastCrawled', ids.map(id => ((typeof id === 'object' && id.hasOwnProperty('id')) ? id.id : id)));
- ids = ids.filter((id, idx) => {
+ const lastCrawled = await db.sortedSetScores('usersRemote:lastCrawled', filtered.map(id => ((typeof id === 'object' && id.hasOwnProperty('id')) ? id.id : id)));
+ const remaining = filtered.filter((id, idx) => {
const timestamp = lastCrawled[idx];
return migrate.has(id) || !timestamp || timestamp < upperBound;
});
+ return { ids: remaining };
}
- return ids;
+ return { ids: filtered };
};
Actors.assert = async (ids, options = {}) => {
@@ -120,25 +122,28 @@ Actors.assert = async (ids, options = {}) => {
* - true: no new IDs processed; all passed-in IDs present.
*/
- ids = await Actors.qualify(ids, options);
- if (!ids || !ids.length) {
- return ids;
+ const qualified = await Actors.qualify(ids, options);
+ if (!qualified || !qualified.ids || !qualified.ids.length) {
+ return qualified;
}
- activitypub.helpers.log(`[activitypub/actors] Asserting ${ids.length} actor(s)`);
+ const { ids: idsArr } = qualified;
+
+ activitypub.helpers.log(`[activitypub/actors] Asserting ${idsArr.length} actor(s)`);
// NOTE: MAKE SURE EVERY DB ADDITION HAS A CORRESPONDING REMOVAL IN ACTORS.REMOVE!
const urlMap = new Map();
const followersUrlMap = new Map();
const pubKeysMap = new Map();
- const categories = new Set();
- let actors = await Promise.all(ids.map(async (id) => {
+ const actorCategories = new Set();
+ let actors = await Promise.all(idsArr.map(async (id) => {
try {
activitypub.helpers.log(`[activitypub/actors] Processing ${id}`);
const actor = (typeof id === 'object' && id.hasOwnProperty('id')) ? id : await activitypub.get('uid', 0, id, { cache: process.env.CI === 'true' });
- // Verify actor.id hostname matches the queried URL's hostname (prevent spoofed id overwrite)
+ // Verify actor.id hostname matches the queried URL's hostname (prevent spoofed id overwrite).
+ // This check runs unconditionally — before any WebFinger logic.
if (typeof id === 'string') {
const queriedHost = new URL(id).hostname;
const actorHost = new URL(actor.id).hostname;
@@ -148,24 +153,24 @@ Actors.assert = async (ids, options = {}) => {
}
}
- // webfinger backreference check
- const { hostname: domain } = new URL(id);
- const { actorUri: canonicalId } = await activitypub.helpers.query(`${actor.preferredUsername}@${domain}`);
- if (id !== canonicalId) {
+ // Two-way WebFinger verification (includes backreference + optional split-domain forward check).
+ const verdict = await activitypub.helpers.verifyActorWebfinger(actor.id, actor);
+ if (!verdict || !verdict.ok) {
+ activitypub.helpers.log(`[activitypub/actors] Webfinger verification failed (${verdict?.reason || 'unknown'}) for ${actor.id}`);
return null;
}
-
+ actor._canonicalHandle = verdict.canonicalHandle;
let typeOk = false;
if (Array.isArray(actor.type)) {
typeOk = actor.type.some(type => activitypub._constants.acceptableActorTypes.has(type));
if (!typeOk && actor.type.some(type => activitypub._constants.acceptableGroupTypes.has(type))) {
- categories.add(actor.id);
+ actorCategories.add(actor.id);
}
} else {
typeOk = activitypub._constants.acceptableActorTypes.has(actor.type);
if (!typeOk && activitypub._constants.acceptableGroupTypes.has(actor.type)) {
- categories.add(actor.id);
+ actorCategories.add(actor.id);
}
}
@@ -219,7 +224,7 @@ Actors.assert = async (ids, options = {}) => {
}
}));
actors = actors.filter(Boolean); // remove unresolvable actors
- if (!actors.length && !categories.size) {
+ if (!actors.length && !actorCategories.size) {
return [];
}
@@ -285,8 +290,8 @@ Actors.assert = async (ids, options = {}) => {
}
// Handle any actors that should be asserted as a group instead
- if (categories.size) {
- const assertion = await Actors.assertGroup(Array.from(categories), options);
+ if (actorCategories.size) {
+ const assertion = await Actors.assertGroup(Array.from(actorCategories), options);
if (assertion === false) {
return false;
} else if (Array.isArray(assertion)) {
@@ -310,27 +315,29 @@ Actors.assertGroup = async (ids, options = {}) => {
* - true: no new IDs processed; all passed-in IDs present.
*/
- ids = await Actors.qualify(ids, {
+ const qualified = await Actors.qualify(ids, {
qualifyGroup: true,
...options,
});
- if (!ids) {
- return ids;
+ if (!qualified || !qualified.ids) {
+ return qualified;
}
- activitypub.helpers.log(`[activitypub/actors] Asserting ${ids.length} group(s)`);
+ const { ids: idsArr } = qualified;
+
+ activitypub.helpers.log(`[activitypub/actors] Asserting ${idsArr.length} group(s)`);
// NOTE: MAKE SURE EVERY DB ADDITION HAS A CORRESPONDING REMOVAL IN ACTORS.REMOVEGROUP!
const urlMap = new Map();
const followersUrlMap = new Map();
const pubKeysMap = new Map();
- let groups = await Promise.all(ids.map(async (id) => {
+ let groups = await Promise.all(idsArr.map(async (id) => {
try {
activitypub.helpers.log(`[activitypub/actors] Processing group ${id}`);
const actor = (typeof id === 'object' && id.hasOwnProperty('id')) ? id : await activitypub.get('uid', 0, id, { cache: process.env.CI === 'true' });
- // Verify actor.id hostname matches the queried URL's hostname (prevent spoofed id overwrite)
+ // Verify actor.id hostname matches the queried URL's hostname (prevent spoofed id overwrite).
if (typeof id === 'string') {
const queriedHost = new URL(id).hostname;
const actorHost = new URL(actor.id).hostname;
@@ -340,10 +347,10 @@ Actors.assertGroup = async (ids, options = {}) => {
}
}
- // webfinger backreference check
- const { hostname: domain } = new URL(id);
- const { actorUri: canonicalId } = await activitypub.helpers.query(`${actor.preferredUsername}@${domain}`);
- if (id !== canonicalId) {
+ // Two-way WebFinger verification (backreference check for security).
+ const verdict = await activitypub.helpers.verifyActorWebfinger(actor.id, actor);
+ if (!verdict || !verdict.ok) {
+ activitypub.helpers.log(`[activitypub/actors] Webfinger verification failed (${verdict?.reason || 'unknown'}) for ${actor.id}`);
return null;
}
diff --git a/src/activitypub/helpers.js b/src/activitypub/helpers.js
index 6008c7acba..3c38b876a5 100644
--- a/src/activitypub/helpers.js
+++ b/src/activitypub/helpers.js
@@ -98,7 +98,7 @@ Helpers.isWebfinger = (value) => {
return false;
};
-Helpers.query = async (id) => {
+Helpers.query = async (id, { strict = true } = {}) => {
const isUri = Helpers.isUri(id);
// username@host ids use acct: URI schema
const uri = isUri ? new URL(id) : new URL(`acct:${id}`);
@@ -111,7 +111,7 @@ Helpers.query = async (id) => {
hostname = hostname.trim();
const cached = webfingerCache.get(id);
- if (cached !== undefined) {
+ if (cached !== undefined && !(strict && cached.splitDomain)) {
return cached;
}
@@ -177,20 +177,93 @@ Helpers.query = async (id) => {
} else {
subjectHostname = subjectUrl.hostname;
}
- if (subjectHostname !== hostname) {
+
+ // Check for split-domain: queried hostname differs from subject hostname.
+ const splitDomain = subjectHostname.toLowerCase() !== hostname.toLowerCase();
+ if (splitDomain && strict) {
+ // Strict mode: reject responses where the subject hostname differs
return false;
}
- const payload = { subject, username, hostname, actorUri, publicKey, _raw: body };
+ const payload = {
+ subject, username, hostname, actorUri, publicKey,
+ _raw: body,
+ subjectHostname: subjectUrl.protocol === 'acct:' ? subjectHostname : subjectHostname,
+ splitDomain,
+ };
const claimedId = subjectUrl.pathname;
- webfingerCache.set(claimedId, payload);
+ // Always cache by the queried id so subsequent queries hit the cache
+ webfingerCache.set(id, payload);
+ // Also cache by the claimed subject path for alias lookups
if (claimedId !== id) {
- webfingerCache.set(id, payload);
+ webfingerCache.set(claimedId, payload);
}
return payload;
};
+Helpers.verifyActorWebfinger = async (actorId, actor) => {
+ if (!Helpers.isUri(actorId)) {
+ return false;
+ }
+
+ const idHostname = new URL(actorId).hostname;
+ const preferredUsername = actor.preferredUsername || 'user';
+
+ // Step 1: Backreference — non-strict query on domain B (the actor's id host).
+ // This allows the WebFinger subject to point elsewhere (split-domain forward target).
+ const backref = await Helpers.query(`${preferredUsername}@${idHostname}`, { strict: false });
+ if (!backref) {
+ return { ok: false, splitDomain: false, canonicalHandle: null, reason: 'no-backreference' };
+ }
+
+ // The backreference self-link must point at this exact actor document.
+ if (backref.actorUri !== actorId) {
+ return { ok: false, splitDomain: false, canonicalHandle: null, reason: 'subject-mismatch' };
+ }
+
+ // The subject's hostname tells us the canonical domain (A).
+ // Missing subjectHostname (e.g., legacy cache entries) defaults to same-domain.
+ const subjectHost = backref.subjectHostname;
+ if (!subjectHost || subjectHost.toLowerCase() === idHostname.toLowerCase()) {
+ return {
+ ok: true,
+ splitDomain: false,
+ canonicalHandle: `${preferredUsername}@${idHostname}`,
+ reason: null,
+ };
+ }
+
+ const normalizedSubjectHost = subjectHost.toLowerCase();
+
+ if (!meta.config.activitypubAllowSplitDomain) {
+ // Split-domain disabled; reject actors whose subject hostname differs
+ return { ok: false, splitDomain: false, canonicalHandle: null, reason: 'forward-mismatch' };
+ }
+
+ const forwardResult = await Helpers.query(`${preferredUsername}@${normalizedSubjectHost}`, { strict: true });
+ if (!forwardResult || forwardResult.actorUri !== actorId) {
+ return { ok: false, splitDomain: false, canonicalHandle: null, reason: 'forward-mismatch' };
+ }
+
+ const blocked = await activitypub.instances.isAllowed(normalizedSubjectHost);
+ if (!blocked.allowed) {
+ return {
+ ok: false,
+ splitDomain: true,
+ canonicalHandle: null,
+ reason: 'canonical-blocked',
+ };
+ }
+
+ return {
+ ok: true,
+ splitDomain: true,
+ canonicalHandle: `${preferredUsername}@${normalizedSubjectHost}`,
+ reason: 'split-domain',
+ };
+};
+
Helpers.generateKeys = async (type, id) => {
activitypub.helpers.log(`[activitypub] Generating RSA key-pair for ${type} ${id}`);
const {
diff --git a/src/activitypub/mocks.js b/src/activitypub/mocks.js
index 7ba7ea07d0..c9c38de342 100644
--- a/src/activitypub/mocks.js
+++ b/src/activitypub/mocks.js
@@ -235,6 +235,13 @@ Mocks.profile = async (actors) => {
return null;
}
+ // For split-domain: use the canonical domain (domain A) for the handle
+ // instead of the actor's id hostname (domain B)
+ const canonicalHost = actor._canonicalHandle ?
+ actor._canonicalHandle.split('@').slice(1).join('@') :
+ hostname;
+ const canonicalHostname = canonicalHost;
+
let picture;
if (icon) {
picture = typeof icon === 'string' ? icon : icon.url;
@@ -278,8 +285,8 @@ Mocks.profile = async (actors) => {
const payload = {
uid,
- username: `${preferredUsername}@${hostname}`,
- userslug: `${preferredUsername}@${hostname}`,
+ username: `${preferredUsername}@${canonicalHostname}`,
+ userslug: `${preferredUsername}@${canonicalHostname}`.toLowerCase(),
displayname: name,
fullname: name,
joindate: new Date(published).getTime() || Date.now(),
@@ -299,6 +306,9 @@ Mocks.profile = async (actors) => {
sharedInbox: endpoints ? endpoints.sharedInbox : null,
followersUrl: followers,
customFields: customFields && new URLSearchParams(customFields).toString(),
+
+ // Store the canonical webfinger handle for split-domain identity verification
+ webfinger: canonicalHostname === hostname ? undefined : `acct:${preferredUsername}@${canonicalHostname}`,
};
return payload;
@@ -334,6 +344,12 @@ Mocks.category = async (actors) => {
return null;
}
+ // For split-domain: use the canonical domain (domain A) for the handle
+ const canonicalHost = actor._canonicalHandle ?
+ actor._canonicalHandle.split('@').slice(1).join('@') :
+ hostname;
+ const canonicalHostname = canonicalHost;
+
// No support for category avatars yet ;(
// let picture;
// if (image) {
@@ -348,8 +364,8 @@ Mocks.category = async (actors) => {
const payload = {
cid,
name,
- handle: `${preferredUsername}@${hostname}`,
- slug: `${preferredUsername}@${hostname}`,
+ handle: `${preferredUsername}@${canonicalHostname}`,
+ slug: `${preferredUsername}@${canonicalHostname}`,
description: summary,
descriptionParsed: posts.sanitize(activitypub.helpers.renderEmoji(summary || '', tag)),
icon: backgroundImage ? 'fa-nbb-none' : 'fa-comments',
@@ -369,6 +385,9 @@ Mocks.category = async (actors) => {
_activitypub: {
postingRestrictedToMods,
},
+
+ // Store the canonical webfinger handle for split-domain identity verification
+ webfinger: canonicalHostname === hostname ? undefined : `acct:${preferredUsername}@${canonicalHostname}`,
};
return payload;
diff --git a/src/views/admin/federation/general.tpl b/src/views/admin/federation/general.tpl
index 0839a7a08d..c3888bcbfd 100644
--- a/src/views/admin/federation/general.tpl
+++ b/src/views/admin/federation/general.tpl
@@ -22,6 +22,11 @@
<label class="form-check-label">{{tx("admin/settings/activitypub:allowLoopback")}}</label>
<p class="form-text">{{tx("admin/settings/activitypub:allowLoopback-help")}}</p>
</div>
+ <div class="form-check form-switch mb-3">
+ <input class="form-check-input" type="checkbox" data-field="activitypubAllowSplitDomain">
+ <label class="form-check-label">{{tx("admin/settings/activitypub:allowSplitDomain")}}</label>
+ <p class="form-text">{{tx("admin/settings/activitypub:allowSplitDomain-help")}}</p>
+ </div>
<div class="mb-3">
<label class="form-label" for="activitypubParentTraversalDepth">{{tx("admin/settings/activitypub:parentTraversalDepth")}}</label>
<input type="number" id="activitypubParentTraversalDepth" name="activitypubParentTraversalDepth" data-field="activitypubParentTraversalDepth" title="{{tx("admin/settings/activitypub:parentTraversalDepth")}}" class="form-control" />
diff --git a/test/activitypub/helpers.js b/test/activitypub/helpers.js
index 5147b95b61..fb99e6f355 100644
--- a/test/activitypub/helpers.js
+++ b/test/activitypub/helpers.js
@@ -17,6 +17,7 @@ Helpers.mocks.person = (override = {}) => {
id = override.id;
}
+ const username = override.preferredUsername || `user_${uuid.slice(0, 8)}`;
const actor = {
'@context': [
@@ -30,7 +31,7 @@ Helpers.mocks.person = (override = {}) => {
type: 'Person',
name: slugify(id),
- preferredUsername: id,
+ preferredUsername: username,
publicKey: {
id: `${id}#key`,
@@ -43,8 +44,11 @@ Helpers.mocks.person = (override = {}) => {
activitypub._cache.set(`0;${id}`, actor);
activitypub.helpers._webfingerCache.set(`${actor.preferredUsername}@example.org`, {
actorUri: id,
- username: id,
+ username: username,
hostname: 'example.org',
+ subject: `acct:${username}@example.org`,
+ splitDomain: false,
+ subjectHostname: 'example.org',
});
return { id, actor };
@@ -60,8 +64,11 @@ Helpers.mocks.group = (override = {}) => {
activitypub._cache.set(`0;${id}`, actor);
activitypub.helpers._webfingerCache.set(`${actor.preferredUsername}@${hostname}`, {
actorUri: id,
- username: id,
+ username: actor.preferredUsername,
hostname,
+ subject: `acct:${actor.preferredUsername}@${hostname}`,
+ splitDomain: false,
+ subjectHostname: hostname,
});
return { id, actor };
diff --git a/test/activitypub/split-domain.js b/test/activitypub/split-domain.js
new file mode 100644
index 0000000000..5e77f1e7e8
--- /dev/null
+++ b/test/activitypub/split-domain.js
@@ -0,0 +1,370 @@
+'use strict';
+
+const assert = require('assert');
+const nconf = require('nconf');
+const meta = require('../../src/meta');
+const utils = require('../../src/utils');
+
+const activitypub = require('../../src/activitypub');
+
+const Helpers = module.exports;
+
+Helpers.genSplitDomain = () => {
+ const username = `user_${utils.generateUUID().replace(/-/g, '').slice(0, 8)}`;
+ const domainA = `forum-${utils.generateUUID().replace(/-/g, '').slice(0, 6)}.example`;
+ const domainB = `ap-${utils.generateUUID().replace(/-/g, '').slice(0, 6)}.example`;
+ const actorUri = `https://${domainB}/uid/${username}`;
+ return { domainA, domainB, username, actorUri, preferredUsername: username };
+};
+
+Helpers.seedWebfinger = (domainA, domainB, username, actorUri) => {
+ activitypub.helpers._webfingerCache.set(`${username}@${domainB}`, {
+ actorUri, username, hostname: domainB,
+ subject: `acct:${username}@${domainA}`, splitDomain: true, subjectHostname: domainA,
+ _raw: {
+ links: [{ rel: 'self', href: actorUri, type: 'application/activity+json' }],
+ publicKey: null, subject: `acct:${username}@${domainA}`,
+ },
+ });
+ activitypub.helpers._webfingerCache.set(`${username}@${domainA}`, {
+ actorUri, username, hostname: domainA,
+ subject: `acct:${username}@${domainA}`, splitDomain: false, subjectHostname: domainA,
+ _raw: {
+ links: [{ rel: 'self', href: actorUri, type: 'application/activity+json' }],
+ publicKey: null, subject: `acct:${username}@${domainA}`,
+ },
+ });
+};
+
+Helpers.seedSameDomainWebfinger = (domainB, username, actorUri) => {
+ activitypub.helpers._webfingerCache.set(`${username}@${domainB}`, {
+ actorUri, username, hostname: domainB,
+ subject: `acct:${username}@${domainB}`, splitDomain: false, subjectHostname: domainB,
+ _raw: {
+ links: [{ rel: 'self', href: actorUri, type: 'application/activity+json' }],
+ publicKey: null, subject: `acct:${username}@${domainB}`,
+ },
+ });
+};
+
+Helpers.seedActor = (actorUri, overrides = {}) => {
+ const actor = {
+ '@context': ['https://www.w3.org/ns/activitystreams', 'https://w3id.org/security/v1'],
+ id: actorUri, url: actorUri, inbox: `${actorUri}/inbox`, outbox: `${actorUri}/outbox`,
+ type: 'Person', name: overrides.name || overrides.preferredUsername || 'User',
+ preferredUsername: overrides.preferredUsername || 'user',
+ publicKey: { id: `${actorUri}#key`, owner: actorUri, publicKeyPem: 'test-key' },
+ followers: `${actorUri}/followers`, following: `${actorUri}/following`,
+ ...overrides,
+ };
+ activitypub._cache.set(`0;${actorUri}`, actor);
+ return actor;
+};
+
+Helpers.reset = () => {
+ activitypub._cache.reset();
+ activitypub.helpers._webfingerCache.reset();
+ nconf.set('activitypubAllowSplitDomain', 1);
+ meta.config.activitypubAllowSplitDomain = 1;
+ nconf.set('activitypubAllowLoopback', 0);
+ meta.config.activitypubAllowLoopback = 0;
+};
+
+// ============================================================================
+
+describe('helpers.query strictness', () => {
+ beforeEach(Helpers.reset);
+
+ it('strict query of same-domain subject returns payload with splitDomain: false', async () => {
+ const { domainA, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedSameDomainWebfinger(domainA, username, actorUri);
+ const result = await activitypub.helpers.query(`${username}@${domainA}`);
+ assert.ok(result);
+ assert.equal(result.actorUri, actorUri);
+ assert.equal(result.splitDomain, false);
+ });
+
+ it('strict query of split-domain subject returns false', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ const result = await activitypub.helpers.query(`${username}@${domainB}`);
+ assert.equal(result, false);
+ });
+
+ it('non-strict query of split-domain subject returns full payload', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ const result = await activitypub.helpers.query(`${username}@${domainB}`, { strict: false });
+ assert.ok(result);
+ assert.equal(result.actorUri, actorUri);
+ assert.equal(result.splitDomain, true);
+ assert.equal(result.hostname, domainB);
+ assert.equal(result.subjectHostname, domainA);
+ });
+
+ it('cached split-domain payload is still rejected by strict query', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ const result = await activitypub.helpers.query(`${username}@${domainB}`);
+ assert.equal(result, false);
+ });
+});
+
+// ============================================================================
+
+describe('verifyActorWebfinger', () => {
+ beforeEach(Helpers.reset);
+
+ it('returns split-domain verdict for fully verified actor', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.ok(verdict.ok);
+ assert.equal(verdict.splitDomain, true);
+ assert.equal(verdict.canonicalHandle, `${username}@${domainA}`);
+ assert.equal(verdict.reason, 'split-domain');
+ });
+
+ it('returns same-domain verdict for same-domain actor', async () => {
+ const { username, actorUri } = Helpers.genSplitDomain();
+ const domain = new URL(actorUri).hostname;
+ Helpers.seedSameDomainWebfinger(domain, username, actorUri);
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.ok(verdict.ok);
+ assert.equal(verdict.splitDomain, false);
+ assert.equal(verdict.canonicalHandle, `${username}@${domain}`);
+ });
+
+ it('rejects with no-backreference when domain B WebFinger 404s', async () => {
+ const { domainA, username, actorUri } = Helpers.genSplitDomain();
+ activitypub.helpers._webfingerCache.set(`${username}@${domainA}`, {
+ actorUri, username, hostname: domainA,
+ subject: `acct:${username}@${domainA}`, splitDomain: false, subjectHostname: domainA,
+ _raw: {
+ links: [{ rel: 'self', href: actorUri, type: 'application/activity+json' }],
+ publicKey: null,
+ },
+ });
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.equal(verdict.ok, false);
+ assert.equal(verdict.reason, 'no-backreference');
+ });
+
+ it('rejects with subject-mismatch when backreference self-link points elsewhere', async () => {
+ const { domainB, username, actorUri } = Helpers.genSplitDomain();
+ const spoofedUri = `https://${domainB}/uid/spoofed_user`;
+ activitypub.helpers._webfingerCache.set(`${username}@${domainB}`, {
+ actorUri: spoofedUri, username, hostname: domainB,
+ subject: `acct:${username}@${domainB}`, splitDomain: false, subjectHostname: domainB,
+ _raw: {
+ links: [{ rel: 'self', href: spoofedUri, type: 'application/activity+json' }],
+ publicKey: null,
+ },
+ });
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.equal(verdict.ok, false);
+ assert.equal(verdict.reason, 'subject-mismatch');
+ });
+
+ it('rejects with forward-mismatch when forward query 404s', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ activitypub.helpers._webfingerCache.set(`${username}@${domainB}`, {
+ actorUri, username, hostname: domainB,
+ subject: `acct:${username}@${domainA}`, splitDomain: true, subjectHostname: domainA,
+ _raw: {
+ links: [{ rel: 'self', href: actorUri, type: 'application/activity+json' }],
+ publicKey: null,
+ },
+ });
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.equal(verdict.ok, false);
+ assert.equal(verdict.reason, 'forward-mismatch');
+ });
+
+ it('rejects when split-domain config is off', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ meta.config.activitypubAllowSplitDomain = 0;
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.equal(verdict.ok, false);
+ assert.equal(verdict.reason, 'forward-mismatch');
+ });
+
+ it('rejects with canonical-blocked when domain A is blocklisted', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const origCheck = activitypub.blocklists.check;
+ activitypub.blocklists.check = async (domain) => {
+ if (domain === domainA) {
+ return { allowed: false, severity: 'filter', listUrl: 'https://bad.example' };
+ }
+ return origCheck.call(activitypub.blocklists, domain);
+ };
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.equal(verdict.ok, false);
+ assert.equal(verdict.reason, 'canonical-blocked');
+ activitypub.blocklists.check = origCheck;
+ });
+});
+
+// ============================================================================
+
+describe('Actors.assert - hostname mismatch', () => {
+ beforeEach(Helpers.reset);
+
+ it('rejects when queried hostname differs from actor.id hostname (gh#13352)', async () => {
+ const username = 'alice';
+ const queriedDomain = 'honest.example';
+ const actorDomain = 'spoof.example';
+ const actorUri = `https://${actorDomain}/uid/${username}`;
+ activitypub.helpers._webfingerCache.set(`${username}@${queriedDomain}`, {
+ actorUri, username, hostname: queriedDomain,
+ subject: `acct:${username}@${queriedDomain}`, splitDomain: false, subjectHostname: queriedDomain,
+ _raw: {
+ links: [{ rel: 'self', href: actorUri, type: 'application/activity+json' }],
+ publicKey: null,
+ },
+ });
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const result = await activitypub.actors.assert([actorUri]);
+ assert.equal(result, false);
+ });
+
+ it('accepts same-domain actors via full WebFinger verification', async () => {
+ const { username, actorUri } = Helpers.genSplitDomain();
+ const domain = new URL(actorUri).hostname;
+ Helpers.seedSameDomainWebfinger(domain, username, actorUri);
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const result = await activitypub.actors.assert([actorUri]);
+ assert.ok(Array.isArray(result));
+ assert.equal(result.length, 1);
+ });
+
+ it('rejects split-domain actor when config is off', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ Helpers.seedActor(actorUri, { preferredUsername: username });
+ const orig = meta.config.activitypubAllowSplitDomain;
+ meta.config.activitypubAllowSplitDomain = 0;
+ const result = await activitypub.actors.assert([actorUri]);
+ meta.config.activitypubAllowSplitDomain = orig;
+ assert.equal(result.length, 0);
+ });
+});
+
+// ============================================================================
+
+describe('Mocks.profile canonical handle', () => {
+ beforeEach(Helpers.reset);
+
+ it('uses canonical domain when _canonicalHandle is set', async () => {
+ const { domainA, username, actorUri } = Helpers.genSplitDomain();
+ const actor = Helpers.seedActor(actorUri, { preferredUsername: username });
+ actor._canonicalHandle = `${username}@${domainA}`;
+ const profile = await activitypub.mocks.profile([actor]);
+ assert.ok(profile[0]);
+ assert.equal(profile[0].username, `${username}@${domainA}`);
+ assert.equal(profile[0].userslug, `${username}@${domainA}`);
+ assert.equal(profile[0].webfinger, `acct:${username}@${domainA}`);
+ });
+
+ it('uses actor id domain when _canonicalHandle is not set', async () => {
+ const { username, actorUri } = Helpers.genSplitDomain();
+ const hostname = new URL(actorUri).hostname;
+ const actor = Helpers.seedActor(actorUri, { preferredUsername: username });
+ const profile = await activitypub.mocks.profile([actor]);
+ assert.ok(profile[0]);
+ assert.equal(profile[0].username, `${username}@${hostname}`);
+ assert.equal(profile[0].userslug, `${username}@${hostname}`);
+ assert.equal(profile[0].webfinger, undefined);
+ });
+});
+
+// ============================================================================
+
+describe('Mocks.category canonical handle', () => {
+ beforeEach(Helpers.reset);
+
+ it('uses canonical domain when _canonicalHandle is set', async () => {
+ const { domainA, username, actorUri } = Helpers.genSplitDomain();
+ const groupActor = {
+ '@context': ['https://www.w3.org/ns/activitystreams', 'https://w3id.org/security/v1'],
+ id: actorUri, url: actorUri, type: 'Group',
+ name: 'Mod Team', preferredUsername: username, summary: 'Moderators',
+ publicKey: { id: `${actorUri}#key`, owner: actorUri, publicKeyPem: 'test-key' },
+ endpoints: {},
+ _canonicalHandle: `${username}@${domainA}`,
+ };
+ const cats = await activitypub.mocks.category([groupActor]);
+ assert.ok(cats[0]);
+ assert.equal(cats[0].handle, `${username}@${domainA}`);
+ assert.equal(cats[0].slug, `${username}@${domainA}`);
+ assert.equal(cats[0].webfinger, `acct:${username}@${domainA}`);
+ });
+
+ it('uses actor id domain when _canonicalHandle is not set', async () => {
+ const { username, actorUri } = Helpers.genSplitDomain();
+ const hostname = new URL(actorUri).hostname;
+ const groupActor = {
+ '@context': ['https://www.w3.org/ns/activitystreams', 'https://w3id.org/security/v1'],
+ id: actorUri, url: actorUri, type: 'Group',
+ name: 'Staff', preferredUsername: username, summary: 'Admins',
+ publicKey: { id: `${actorUri}#key`, owner: actorUri, publicKeyPem: 'test-key' },
+ endpoints: {},
+ };
+ const cats = await activitypub.mocks.category([groupActor]);
+ assert.ok(cats[0]);
+ assert.equal(cats[0].handle, `${username}@${hostname}`);
+ assert.equal(cats[0].slug, `${username}@${hostname}`);
+ assert.equal(cats[0].webfinger, undefined);
+ });
+});
+
+// ============================================================================
+
+describe('Split-Domain: Integration - full flow', () => {
+ beforeEach(Helpers.reset);
+
+ it('should pass through split-domain resolve -> verify -> profile', async () => {
+ const { domainA, domainB, username, actorUri } = Helpers.genSplitDomain();
+ Helpers.seedWebfinger(domainA, domainB, username, actorUri);
+ const queryResult = await activitypub.helpers.query(`${username}@${domainB}`, { strict: false });
+ assert.ok(queryResult);
+ assert.equal(queryResult.splitDomain, true);
+
+ const actor = Helpers.seedActor(actorUri, { preferredUsername: username });
+ const verdict = await activitypub.helpers.verifyActorWebfinger(
+ actorUri, activitypub._cache.get(`0;${actorUri}`));
+ assert.ok(verdict);
+ assert.ok(verdict.ok);
+ assert.equal(verdict.splitDomain, true);
+ assert.equal(verdict.canonicalHandle, `${username}@${domainA}`);
+
+ actor._canonicalHandle = verdict.canonicalHandle;
+ const profile = await activitypub.mocks.profile([actor]);
+ assert.equal(profile[0].username, `${username}@${domainA}`);
+ assert.equal(profile[0].userslug, `${username}@${domainA}`);
+ assert.equal(profile[0].webfinger, `acct:${username}@${domainA}`);
+ });
+});