Files
wekan/tests/authBleedCopyMethods.test.cjs
T
Lauri Ojansivu 3202a1d7ac A list's role exception also refuses deleting, archiving or moving it, and its swimlane.
Decided by the maintainer on 2026-11-18 (TODO.md). Deleting, archiving,
restoring or moving a list, and deleting, archiving or moving a
swimlane, does the same to the cards in it, so a list that refuses a
role write access (#4527) now refuses those too:

- lists.softRemove, lists.restore and moveList answer not-authorized;
- the REST list DELETE, archive, unarchive and move, and the REST
  swimlane DELETE, answer 403, recorded as ListLockBleed;
- moveSwimlane is refused when a list holding its cards, or bound to
  it, refuses the role (swimlaneRefusingListIds);
- client writes meet new Lists and Swimlanes deny rules, and the list
  menu no longer offers Archive list or Archive all cards in such a list.

Renaming, recolouring and reordering are not refused, and board admins
are never restricted.

tests/listLockStructure.test.cjs runs the swimlane gate and pins every
path; list-lock-bulk.e2e.js replays the REST cases. Sandboxed route
tests get a pass-through gate.

Thanks to xet7 !
2026-11-18 23:08:06 +02:00

401 lines
21 KiB
JavaScript

'use strict';
// AuthBleed sub-findings (reported by Qiulin Deng against WeKan v9.08, fixed
// in v9.09 2026-05-07, commit 62c01725f9): six Meteor methods that copied or
// created board content checked nothing about WHO was calling them.
//
// CopyBoardBleed copyBoard - an unauthenticated caller cloned an entire
// private board, and the `properties` argument let them set
// the copy's members / permission afterwards.
// CopyCardBleed copyCard - an unauthenticated caller cloned a victim's
// private card into a board of their own.
// CopyListBleed copyList - a logged-in non-member cloned a victim's
// private list (and its cards) into their own board.
// CopySwimlaneBleed copySwimlane - an unauthenticated caller cloned a
// victim's private swimlane with its lists and cards.
// DueDateBleed createCardWithDueDate - a logged-in non-member inserted
// cards into another user's private board.
// MoveListBleed moveList - a logged-in non-member moved (and so archived)
// a victim's private list: destructive partial changes.
//
// The fix: every one of them refuses an unauthenticated caller, requires
// membership (and, for anything it changes, write access) on the SOURCE board,
// and write access on the DESTINATION board - before anything is written.
// copyBoard now requires board admin (matching POST /api/boards/:id/copy), and
// only title/sort/type/card selection may be set on the copy
// (models/lib/boardCopyProperties.js, CopyIdentityBleed).
//
// The TEST runs each real method body against stub collections and checks the
// reporter's attacks are refused with no write reached, while the owner's own
// copy still goes through (so the harness is not vacuous). The NEGATIVE TEST
// lists every Meteor method and REST route in the tree that copies, moves or
// clones, and requires each to refuse before its first write - so a new
// copy/move method has to be added here, i.e. checked, to pass.
//
// Admin Panel / Problems: copyList, moveList and moveSwimlane refuse through
// requireBoardMutation, which records 'authz.mutation'. copyBoard, copyCard,
// copySwimlane and createCardWithDueDate record 'authz.copy' (AuthBleed) for
// a signed-out caller, and createCardWithDueDate - which no WeKan client
// calls - for any refusal. Their membership refusals are not recorded: a
// template or a stale dialog reaches them in ordinary use, and a
// high-severity record would disable that user's login.
// Run: node tests/authBleedCopyMethods.test.cjs
const assert = require('assert');
const fs = require('fs');
const path = require('path');
const root = path.join(__dirname, '..');
const read = p => fs.readFileSync(path.join(root, p), 'utf8');
const pending = [];
const test = (name, fn) => pending.push([name, fn]);
const { memberCan } = require(path.join(root, 'models/lib/boardRoleCapabilities'));
const boardCopyProps = require(path.join(root, 'models/lib/boardCopyProperties'));
// ---- harness ---------------------------------------------------------------
class MeteorError extends Error {
constructor(error, reason) { super(reason || error); this.error = error; }
}
const Meteor = { Error: MeteorError, isServer: true };
const check = () => {};
const Match = { OneOf: () => null, Optional: () => null, Maybe: () => null };
// Real requireBoardMutation, with its securityLog require captured.
const recorded = [];
const guardSrc = read('models/lib/boardMutationGuard.js');
const requireBoardMutation = new Function('require', 'module',
`${guardSrc}\nreturn module.exports.requireBoardMutation;`)(
name => {
if (name === './boardRoleCapabilities') return { memberCan };
if (name === '/server/lib/securityLog') return { record: e => recorded.push(e) };
throw new Error(`unexpected require ${name}`);
}, { exports: {} });
// server/lib/utils.js, same definitions.
const allowIsBoardMember = (userId, board) => board && board.hasMember(userId);
const allowIsBoardMemberWithWriteAccess = (userId, board) => !!(board && memberCan(board, userId, 'write'));
let writes;
const wrote = what => (...args) => { writes.push(what); return 'new-id'; };
function board(_id, members) {
return {
_id, title: _id, members,
hasMember(u) { return members.some(m => m.userId === u && m.isActive); },
hasAdmin(u) { return members.some(m => m.userId === u && m.isActive && m.isAdmin); },
copy: wrote(`board.copy:${_id}`),
};
}
const boards = {
victim: board('victim', [{ userId: 'victim', isActive: true, isAdmin: true }]),
mine: board('mine', [{ userId: 'attacker', isActive: true, isAdmin: true }]),
// The attacker is a read-only member here: may see, may not change.
shared: board('shared', [
{ userId: 'victim', isActive: true, isAdmin: true },
{ userId: 'attacker', isActive: true, isAdmin: false, isReadOnly: true },
]),
};
const doc = (kind, boardId) => ({
_id: `${kind}-${boardId}`, boardId, title: kind, type: kind, assignees: [],
copy: wrote(`${kind}.copy:${boardId}`), move: wrote(`${kind}.move:${boardId}`),
archive: wrote(`${kind}.archive:${boardId}`), getSort: async () => 0,
});
const byId = (kind, id) => {
const boardId = String(id).replace(`${kind}-`, '');
return boards[boardId] ? doc(kind, boardId) : null;
};
const ReactiveCache = {
getBoard: async id => boards[id] || null,
getCard: async id => byId('card', id),
getList: async q => (typeof q === 'string' ? byId('list', q) : null),
getLists: async () => [],
getSwimlane: async id => byId('swimlane', id),
getCards: async () => [],
};
const Boards = { findOneAsync: async id => boards[id] || null };
const Cards = { insertAsync: wrote('Cards.insertAsync') };
const Lists = { insertAsync: wrote('Lists.insertAsync'), updateAsync: wrote('Lists.updateAsync'),
findOneAsync: async q => (q && typeof q === 'object' && boards[q.boardId] ? { _id: q._id, boardId: q.boardId } : null) };
// ListLockBulkBleed's list check: no list here has an exception, so it passes
// (tests/listLockBulkBleed.test.cjs runs the real one).
const assertListsWritable = async () => {};
const listException = async () => undefined;
// What the methods require after the guards: pass-through stubs.
const requireStub = name => {
if (name === '/models/lib/boardCardScope') return { mayCopyFromBoard: () => true };
if (name === '/models/lib/boardCopyProperties') return boardCopyProps;
if (name === '/server/lib/securityLog') return { record: e => recorded.push(e) };
if (name === '/server/lib/adminOnlyCustomFields') return { assertFieldWrite: async () => {} };
if (name === '/models/lib/cardCopyOverrides') return { cardWithCopyOverrides: card => card };
if (name === '/server/lib/cardCopyDestination') return { requireCardCopyDestination: async () => {} };
if (name === '/models/lib/scrumCopy') return { copiedScrumMetadata: () => ({}) };
// CreateBleed's guard (tests/createBleed.test.cjs): creating is allowed here,
// so these tests see the copy methods' own checks.
if (name === '/server/lib/boardCreationGuard') return { assertMayCreateBoard: async () => {} };
// The per-list exception passes here (tests/listLockStructure.test.cjs).
if (name === '/server/lib/listPermissionGate') return { assertSwimlaneListsWritable: async () => {} };
throw new Error(`unexpected require ${name}`);
};
// Extract ` async NAME(...) { ... },` from a Meteor.methods block.
function methodSource(file, name) {
const src = read(file);
const start = src.indexOf(` async ${name}(`);
assert.ok(start >= 0, `${name} not found in ${file}`);
const end = src.indexOf('\n },\n', start);
return src.slice(start, end + 4);
}
function loadMethod(file, name) {
const body = methodSource(file, name).replace(`async ${name}(`, `async function ${name}(`);
return new Function('check', 'Match', 'Meteor', 'Boards', 'ReactiveCache', 'Cards', 'Lists',
'require', 'allowIsBoardMember', 'allowIsBoardMemberWithWriteAccess', 'requireBoardMutation',
'normalizeBoardCopyOptions', 'assertListsWritable', 'listException', `return ${body.trim().replace(/,$/, '')};`)(
check, Match, Meteor, Boards, ReactiveCache, Cards, Lists, requireStub,
allowIsBoardMember, allowIsBoardMemberWithWriteAccess, requireBoardMutation, o => o,
assertListsWritable, listException);
}
async function refused(fn, userId, args, expectedError = 'not-authorized') {
writes = [];
let error;
try { await fn.apply({ userId }, args); } catch (e) { error = e; }
assert.ok(error, `expected a refusal for ${userId} ${JSON.stringify(args)}`);
assert.strictEqual(error.error, expectedError, `${error.stack}`);
assert.deepStrictEqual(writes, [], 'nothing may be written before the refusal');
}
async function allowed(fn, userId, args) {
writes = [];
await fn.apply({ userId }, args);
assert.ok(writes.length > 0, 'the legitimate call must reach its write');
}
const copyCard = loadMethod('server/models/cards.js', 'copyCard');
const createCardWithDueDate = loadMethod('server/models/cards.js', 'createCardWithDueDate');
const copyList = loadMethod('server/models/lists.js', 'copyList');
const moveList = loadMethod('server/models/lists.js', 'moveList');
const copySwimlane = loadMethod('server/publications/swimlanes.js', 'copySwimlane');
const moveSwimlane = loadMethod('server/publications/swimlanes.js', 'moveSwimlane');
const copyBoard = loadMethod('server/publications/boards.js', 'copyBoard');
// ---- TEST: the reported attacks --------------------------------------------
test('CopyCardBleed: copyCard refuses anonymous, non-member source and read-only destination', async () => {
const args = dest => ['card-victim', dest, 'swimlane-mine', 'list-mine', false, {}];
await refused(copyCard, null, args('mine'));
await refused(copyCard, 'attacker', args('mine'));
await refused(copyCard, 'attacker', ['card-mine', 'victim', 's', 'l', false, {}]);
await refused(copyCard, 'attacker', ['card-mine', 'shared', 's', 'l', false, {}]);
await allowed(copyCard, 'attacker', ['card-mine', 'mine', 's', 'l', false, {}]);
});
test('CopyBoardBleed: copyBoard refuses anonymous and non-admin callers, and members/permission on the copy', async () => {
await refused(copyBoard, null, ['victim', {}]);
await refused(copyBoard, 'attacker', ['victim', {}]);
await refused(copyBoard, 'attacker', ['shared', {}]);
// Post-copy permission tampering: the copy's members and visibility are not
// the caller's to set - refused before copying, and recorded.
recorded.length = 0;
await refused(copyBoard, 'attacker',
['mine', { members: [{ userId: 'x', isAdmin: true, isActive: true }], permission: 'public' }],
'invalid-copy-properties');
assert.strictEqual(recorded.length, 1);
assert.strictEqual(recorded[0].key, 'authz.board-copy-overrides');
await allowed(copyBoard, 'attacker', ['mine', { title: 'Copy' }]);
});
test('CopyListBleed: copyList refuses anonymous, non-member source and non-writable destination', async () => {
await refused(copyList, null, ['list-victim', 'mine', 's', 'Copy', null, null]);
recorded.length = 0;
await refused(copyList, 'attacker', ['list-victim', 'mine', 's', 'Copy', null, null]);
assert.ok(recorded.some(e => e.key === 'authz.mutation'), 'the refusal is visible in Problems');
await refused(copyList, 'attacker', ['list-mine', 'victim', 's', 'Copy', null, null]);
await refused(copyList, 'attacker', ['list-mine', 'shared', 's', 'Copy', null, null]);
await allowed(copyList, 'attacker', ['list-mine', 'mine', 's', 'Copy', null, null]);
});
test('CopySwimlaneBleed: copySwimlane (and moveSwimlane) refuse anonymous, non-member source and destination', async () => {
for (const fn of [copySwimlane, moveSwimlane]) {
await refused(fn, null, ['swimlane-victim', 'mine', null, 'below', '']);
await refused(fn, 'attacker', ['swimlane-victim', 'mine', null, 'below', '']);
await refused(fn, 'attacker', ['swimlane-mine', 'victim', null, 'below', '']);
await refused(fn, 'attacker', ['swimlane-mine', 'shared', null, 'below', '']);
await allowed(fn, 'attacker', ['swimlane-mine', 'mine', null, 'below', '']);
}
// Moving removes from the source, so read-only membership is not enough.
await refused(moveSwimlane, 'attacker', ['swimlane-shared', 'mine', null, 'below', '']);
});
test('DueDateBleed: createCardWithDueDate refuses anonymous, non-member and read-only destinations', async () => {
const due = new Date();
await refused(createCardWithDueDate, null, ['victim', 'l', 'pwned', due, 's']);
await refused(createCardWithDueDate, 'attacker', ['victim', 'l', 'pwned', due, 's']);
await refused(createCardWithDueDate, 'attacker', ['shared', 'l', 'pwned', due, 's']);
await refused(createCardWithDueDate, 'attacker', ['nonexistent', 'l', 'pwned', due, 's'], 'not-found');
await allowed(createCardWithDueDate, 'attacker', ['mine', 'l', 'mine', due, 's']);
});
test('Problems: an attempt no WeKan client can make is recorded as AuthBleed', async () => {
const card = ['card-mine', 'mine', 's', 'l', false, {}];
for (const [fn, args, source] of [
[copyBoard, ['victim', {}], 'method:copyBoard'],
[copyCard, card, 'method:copyCard'],
[copySwimlane, ['swimlane-victim', 'mine'], 'method:copySwimlane'],
[createCardWithDueDate, ['victim', 'l', 'pwned', new Date(), 's'], 'method:createCardWithDueDate'],
]) {
recorded.length = 0;
await refused(fn, null, args);
assert.deepStrictEqual(recorded.map(e => [e.key, e.action, e.source]), [['authz.copy', 'blocked', source]]);
assert.strictEqual(recorded[0].userId, undefined, 'signed out: nobody to block');
}
// createCardWithDueDate has no WeKan client, so a signed-in refusal is an
// attempt too - and it names the account.
recorded.length = 0;
await refused(createCardWithDueDate, 'attacker', ['victim', 'l', 'pwned', new Date(), 's']);
assert.deepStrictEqual(recorded.map(e => [e.key, e.userId]), [['authz.copy', 'attacker']]);
const { categoryFor } = require(path.join(root, 'models/lib/securityCategories'));
assert.strictEqual(categoryFor('authz.copy').bleed, 'AuthBleed');
});
test('negative: a refusal ordinary use reaches is not recorded, so it cannot disable a login', async () => {
// A member who is not admin of a (default) template board, or a stale Copy
// Card / Copy Swimlane dialog, reaches these in ordinary use; an
// authz.copy record names the account at high severity, which disables
// its login.
for (const [fn, args] of [
[copyBoard, ['shared', {}]],
[copyCard, ['card-victim', 'mine', 's', 'l', false, {}]],
[copySwimlane, ['swimlane-victim', 'mine']],
]) {
recorded.length = 0;
await refused(fn, 'attacker', args);
assert.deepStrictEqual(recorded.filter(e => e.key === 'authz.copy'), [], fn.name);
}
});
test('MoveListBleed: moveList refuses before any move or archive of a victim list', async () => {
await refused(moveList, null, ['list-victim', 'mine', '', null, null, null]);
recorded.length = 0;
await refused(moveList, 'attacker', ['list-victim', 'mine', '', null, null, null]);
assert.ok(recorded.some(e => e.key === 'authz.mutation' && /moveList:source/.test(e.source)));
// A read-only member may not move a list out (that archives it at the source).
await refused(moveList, 'attacker', ['list-shared', 'mine', '', null, null, null]);
await refused(moveList, 'attacker', ['list-mine', 'victim', '', null, null, null]);
await allowed(moveList, 'attacker', ['list-mine', 'mine', '', null, null, null]);
});
// ---- NEGATIVE TEST: the shape nowhere else ---------------------------------
const walk = dir => fs.readdirSync(path.join(root, dir), { withFileTypes: true }).flatMap(e => {
const rel = path.join(dir, e.name);
if (e.isDirectory()) return /^(node_modules|_build|\.build|tests?)$/.test(e.name) ? [] : walk(rel);
return /\.js$/.test(e.name) && !/\.tests?\.js$/.test(e.name) ? [rel] : [];
});
const sources = [...walk('server'), ...walk('models')];
const GUARD = /!this\.userId|requireBoardMutation\(|allowIsBoardMember(?:WithWriteAccess)?\(|\.hasMember\(|\.hasAdmin\(|userHasBoardWriteAccess\(|boardAccess\(|destination\(this\.userId|canExport\(|requireAdmin\(|\.isAdmin\b|check[A-Za-z]*Access\(|checkBoardAdmin\(/g;
const WRITE = /\.(copy|move|archive)\(|\b[A-Z]\w*\.(insert|update|remove|upsert)Async\(|\.direct\.|Meteor\.defer\(/;
// Every copy/move/clone method, with the number of guards it must pass before
// its first write. A method missing from this table fails: check it first.
const METHODS = {
'server/publications/boards.js copyBoard': 2, // login + board admin
'server/models/cards.js copyCard': 3, // login + source member + destination write
'server/models/cards.js createCardWithDueDate': 2, // login + destination write
'server/models/lists.js copyList': 3,
'server/models/lists.js moveList': 3,
'server/publications/swimlanes.js copySwimlane': 3,
'server/publications/swimlanes.js moveSwimlane': 3,
'server/models/checklists.js moveChecklist': 3,
'server/moveBoardObjects.js moveBoardObjects': 2, // boardAccess(source) + destination()->boardAccess
'server/moveBoardObjects.js structuralMoveOptions': 2, // read-only: login + boardAccess(target)
'server/attachmentApi.js api.attachment.copy': 3,
'server/attachmentApi.js api.attachment.move': 3,
'models/import.js cloneBoard': 2, // login + canExport
'models/attachments.server.js moveAttachmentToStorage': 2, // login + site admin
'models/attachments.server.js validateAttachmentAndMoveToStorage': 2,
'server/attachmentBulkMove.js startBulkAttachmentMove': 1, // site admin
'server/attachmentBulkMove.js pauseBulkAttachmentMove': 1,
'server/attachmentBulkMove.js resumeBulkAttachmentMove': 1,
'server/attachmentBulkMove.js cancelBulkAttachmentMove': 1,
'server/models/users.js moveStarredPage': 1, // the caller's own starred pages
};
// get/set...DialogOption(s) are user-document helpers for the caller's own
// remembered dialog choices (models/users.js), not board writes.
const isCopyMoveName = n => !/^(get|set)\w*DialogOptions?$/.test(n) && (/^(copy|move|clone|duplicate)/.test(n) ||
/[a-z](Copy|Move|Clone|Duplicate)(?:[A-Z]|$)/.test(n) || /WithDueDate$/.test(n));
function bodyAt(src, at) {
// Matching closing brace of the block whose '{' is at or after `at` (pass the
// body's own brace: a default parameter such as `options = {}` comes first).
let depth = 0;
for (let i = src.indexOf('{', at); i < src.length; i++) {
if (src[i] === '{') depth++;
else if (src[i] === '}' && --depth === 0) return src.slice(at, i + 1);
}
throw new Error('unbalanced');
}
const guardsBeforeWrite = body => {
const w = body.search(WRITE);
const head = w < 0 ? body : body.slice(0, w);
return (head.match(GUARD) || []).length;
};
test('every copy/move/clone Meteor method refuses before its first write', () => {
const found = [];
for (const file of sources) {
const src = read(file);
if (!src.includes('Meteor.methods')) continue;
for (const m of src.matchAll(/^ {2,4}(?:async )?'?([\w.]+)'?\s*\([^)]*\)\s*\{/gm)) {
if (!isCopyMoveName(m[1].split('.').pop())) continue;
const id = `${file} ${m[1]}`;
found.push(id);
assert.ok(Object.prototype.hasOwnProperty.call(METHODS, id),
`${id} copies/moves board content and is not checked here - verify it refuses anonymous, ` +
'source non-member and destination non-writer callers, then add it to METHODS');
const n = guardsBeforeWrite(bodyAt(src, m.index + m[0].length - 1));
assert.ok(n >= METHODS[id], `${id}: ${n} guard(s) before its first write, expected ${METHODS[id]}`);
}
}
assert.deepStrictEqual(found.sort(), Object.keys(METHODS).sort(), 'METHODS lists a method that no longer exists');
});
test('every REST copy/move route checks the source AND the destination board before writing', () => {
const routes = [];
for (const file of sources) {
const src = read(file);
for (const m of src.matchAll(/WebApp\.(?:handlers|connectHandlers)\.(?:post|put)\(\s*'([^']*\/(?:copy|move|clone|duplicate))'/g)) {
const body = bodyAt(src, src.indexOf('function', m.index));
const n = guardsBeforeWrite(body);
const twoBoards = /toBoardId/.test(body);
routes.push(m[1]);
assert.ok(n >= (twoBoards ? 2 : 1),
`${file} ${m[1]}: ${n} access check(s) before writing, expected ${twoBoards ? 2 : 1}`);
}
}
for (const r of ['/api/boards/:boardId/copy', '/api/boards/:boardId/lists/:listId/copy',
'/api/boards/:boardId/lists/:listId/move', '/api/boards/:boardId/swimlanes/:swimlaneId/copy',
'/api/boards/:boardId/swimlanes/:swimlaneId/move', '/api/boards/:boardId/lists/:listId/cards/:cardId/copy']) {
assert.ok(routes.includes(r), `route ${r} not found - the scan no longer sees it`);
}
});
test('copyBoard does not let the caller choose members or permission of the copy', () => {
for (const field of ['members', 'permission', '_id', 'archived']) {
assert.throws(() => boardCopyProps.boardCopyProperties({ [field]: 'x' }),
e => e.securityAttempt === true, `${field} must be refused as an attempt`);
}
assert.doesNotThrow(() => boardCopyProps.boardCopyProperties({ title: 't', sort: 1, type: 'board', withoutCards: true }));
});
(async () => {
let failed = 0;
for (const [name, fn] of pending) {
try { await fn(); console.log(` ok ${name}`); }
catch (e) { failed++; console.log(` FAIL ${name}\n${e.stack}`); }
}
console.log(`\n${pending.length - failed}/${pending.length} passed`);
if (failed) process.exit(1);
})();