Files
wekan/server/moveBoardObjects.js
T
Lauri Ojansivu ba3d94390b ListLockBulkBleed: bulk and server-side card writes ask the list's role exception.
GHSA-83w9-74mx-7v83. A board admin can refuse a role write access in one
list (#4527, roleExceptions). REST DELETE /api/boards/:boardId/cards/bulk
and POST /api/boards/:boardId/cards/labels take their cards from the
body, so no URL names a list, and asked only for board write access; the
methods archiveSelectedCards, copyCard and createLinkedCard write from
server code, past the Cards allow/deny rules. A normal member the list
refused could delete, relabel and archive its cards and copy or link new
cards into it.

- The bulk routes read every card and ask each list before the first
  write (assertCardListsNotRefused): any refusal is a 403 and nothing
  changes, recorded in Admin Panel / Problems as ListLockBulkBleed
  (authz.list-locked-bulk, medium). Each removal and relabel is keyed on
  the list that was checked.
- The methods refuse with not-authorized (assertListsWritable), not
  recorded: Copy Card and Multi-Selection reach them in ordinary use.
- The same shape, fixed with the same check: createBoardFromCard,
  addSubtaskCard, createCardWithDueDate (which also did not check that
  the list is on the board), the iCalendar import over DDP and REST,
  sending and receiving board email, vcsCreateIssue, moveBoardObjects,
  History's undo/redo/Restore, position history undo/redo of a card,
  renameAttachment, the scoped import and a card's rule button.
  Dependency lines keep their own board-wide rule.

tests/listLockBulkBleed.test.cjs runs the gate on the reporter's board
and pins every path; tests/playwright/specs/list-lock-bulk.e2e.js replays
the proof of concept. Older guards that pinned the previous shape are
updated with the reason.

Thanks to immanuwell and xet7 !
2026-11-18 22:25:34 +02:00

225 lines
15 KiB
JavaScript

import { Meteor } from 'meteor/meteor';
import { check, Match } from 'meteor/check';
import Boards from '/models/boards';
import Swimlanes from '/models/swimlanes';
import Lists from '/models/lists';
import Cards from '/models/cards';
import Checklists from '/models/checklists';
import ChecklistItems from '/models/checklistItems';
import Activities from '/models/activities';
import { allowIsBoardAdminOrSiteAdmin } from '/server/lib/utils';
const { columnModifier, columnScrumVisibility } = require('/models/lib/boardSettingsColumns');
const { hiddenCardFieldKeys } = require('/models/lib/cardFieldVisibility');
import Settings from '/models/settings';
const { DRAG_SETTINGS, canDragSelection } = require('/models/lib/boardDragging');
import { requireBoardMutation } from '/models/lib/boardMutationGuard';
const { memberCan } = require('/models/lib/boardRoleCapabilities');
const { assignedOnlyCardScope } = require('/models/lib/boardCardScope');
const { selectionRoots, kinds } = require('/models/lib/structuralSelection');
const collections = { swimlane: Swimlanes, list: Lists, card: Cards, checklist: Checklists, item: ChecklistItems };
const targetShape = { boardId: String, swimlaneId: Match.Optional(String), listId: Match.Optional(String), cardId: Match.Optional(String), checklistId: Match.Optional(String), itemId: Match.Optional(String), position: Match.Optional(Match.OneOf('before', 'after')) };
async function boardAccess(userId, id) {
const board = await Boards.findOneAsync(id);
requireBoardMutation(userId, board, 'moveBoardObjects', Meteor);
return board;
}
async function describe(kind, doc) {
const ancestors = [];
let card = kind === 'card' ? doc : null;
if (kind === 'item') ancestors.push(`checklist:${doc.checklistId}`);
if (kind === 'checklist' || kind === 'item') {
card = await Cards.findOneAsync(doc.cardId);
if (!card) throw new Meteor.Error('not-found');
ancestors.push(`card:${card._id}`);
}
if (card) ancestors.push(`list:${card.listId}`, `swimlane:${card.swimlaneId}`);
if (kind === 'list' && doc.swimlaneId) ancestors.push(`swimlane:${doc.swimlaneId}`);
return { ...doc, kind, ancestors, boardId: card?.boardId || doc.boardId };
}
async function destination(userId, target) {
await boardAccess(userId, target.boardId);
const result = {};
for (const [kind, field] of [['swimlane', 'swimlaneId'], ['list', 'listId'], ['card', 'cardId'], ['checklist', 'checklistId'], ['item', 'itemId']]) {
if (!target[field]) continue;
const doc = await collections[kind].findOneAsync(target[field]);
if (!doc || doc.archived || (await describe(kind, doc)).boardId !== target.boardId) throw new Meteor.Error('invalid-destination');
result[kind] = doc;
}
if (result.list?.swimlaneId && result.list.swimlaneId !== target.swimlaneId) throw new Meteor.Error('invalid-destination');
if (result.card && (result.card.listId !== target.listId || result.card.swimlaneId !== target.swimlaneId)) throw new Meteor.Error('invalid-destination');
if (result.checklist && result.checklist.cardId !== target.cardId) throw new Meteor.Error('invalid-destination');
if (result.item && result.item.checklistId !== target.checklistId) throw new Meteor.Error('invalid-destination');
return result;
}
// Insert a stable ordered group before/after an unselected anchor, renumbering
// the destination siblings so repeated moves cannot exhaust fractional indexes.
async function positionGroup(kind, ids, selector, anchor, after) {
const collection = collections[kind];
const siblings = (await collection.find(selector, { sort: { sort: 1, _id: 1 } }).fetchAsync()).filter(doc => !ids.includes(doc._id));
let index = anchor ? siblings.findIndex(doc => doc._id === anchor) : after ? siblings.length : 0;
if (index < 0) throw new Meteor.Error('invalid-position');
if (anchor && after) index++;
const order = siblings.map(doc => doc._id); order.splice(index, 0, ...ids);
for (let i = 0; i < order.length; i++) await collection.updateAsync(order[i], { $set: { sort: i } });
}
Meteor.methods({
async setBoardSettingsColumn(boardId, section, column, enabled) {
check(boardId, String); check(section, String); check(column, String); check(enabled, Boolean);
// Card fields unticked in Admin Panel / Settings / Visibility / Features
// are not offered, so the column's tick leaves their board value alone.
const hidden = hiddenCardFieldKeys(await Settings.findOneAsync({}, { fields: { cardFieldStates: 1 } }));
const modifier = columnModifier(section, column, enabled, hidden);
if (!modifier) throw new Meteor.Error('invalid-setting');
const board = await Boards.findOneAsync(boardId);
if (!this.userId || !board || !(await allowIsBoardAdminOrSiteAdmin(this.userId, board))) throw new Meteor.Error('not-authorized');
const updated = await Boards.updateAsync(boardId, modifier);
// The Scrum rows of a card column, through the Scrum settings' own method.
const visibility = columnScrumVisibility(section, column, enabled, hidden);
if (Object.keys(visibility).length) {
await Meteor.server.method_handlers['scrum.configure'].call(this, boardId, { visibility }, null);
}
return updated;
},
async setBoardDragging(boardId, kind, enabled) {
check(boardId, String); check(kind, String); check(enabled, Boolean);
const setting = DRAG_SETTINGS.find(entry => entry.kind === kind);
if (!setting) throw new Meteor.Error('invalid-setting');
const board = await Boards.findOneAsync(boardId);
if (!this.userId || !board || !(await allowIsBoardAdminOrSiteAdmin(this.userId, board))) throw new Meteor.Error('not-authorized');
return Boards.updateAsync(boardId, { $set: { [setting.field]: enabled } });
},
async structuralMoveOptions(target) {
check(target, targetShape);
if (!this.userId) throw new Meteor.Error('not-authorized');
const boards = await Boards.find({ 'members.userId': this.userId, archived: false }).fetchAsync();
const writable = [];
for (const board of boards) if (memberCan(board, this.userId, 'write')) writable.push({ _id: board._id, title: board.title });
const targetBoard = await boardAccess(this.userId, target.boardId);
// An assigned-only member is offered only the cards they can see.
const cardScope = assignedOnlyCardScope(targetBoard, this.userId) || {};
const projected = async (collection, query) => (await collection.find(query, { sort: { sort: 1 }, fields: { title: 1 } }).fetchAsync());
const result = { boardId: writable, swimlaneId: await projected(Swimlanes, { boardId: target.boardId, archived: false }) };
if (target.swimlaneId) result.listId = await projected(Lists, { boardId: target.boardId, archived: false, $or: [{ swimlaneId: target.swimlaneId }, { swimlaneId: '' }, { swimlaneId: { $exists: false } }] });
if (target.listId) result.cardId = await projected(Cards, { boardId: target.boardId, listId: target.listId, swimlaneId: target.swimlaneId, archived: false, ...cardScope });
if (target.cardId && await Cards.findOneAsync({ _id: target.cardId, boardId: target.boardId, ...cardScope })) result.checklistId = await projected(Checklists, { cardId: target.cardId });
const targetChecklist = target.checklistId && await Checklists.findOneAsync({ _id: target.checklistId, boardId: target.boardId });
if (targetChecklist && await Cards.findOneAsync({ _id: targetChecklist.cardId, boardId: target.boardId, ...cardScope })) result.itemId = await projected(ChecklistItems, { checklistId: target.checklistId });
return result;
},
async moveBoardObjects(sourceBoardId, selection, target, options = {}) {
check(options, { drag: Match.Optional(Boolean) });
check(sourceBoardId, String); check(selection, [{ kind: String, id: String }]); check(target, targetShape);
if (!selection.length || selection.length > 200 || selection.some(entry => !kinds.includes(entry.kind))) throw new Meteor.Error('invalid-selection');
const sourceBoard = await boardAccess(this.userId, sourceBoardId);
if (options.drag && !canDragSelection(sourceBoard, selection)) throw new Meteor.Error('drag-disabled');
const dest = await destination(this.userId, target);
const entries = [];
for (const entry of selection) {
const doc = await collections[entry.kind].findOneAsync(entry.id);
if (!doc || doc.archived) throw new Meteor.Error('not-found');
const described = await describe(entry.kind, doc);
if (described.boardId !== sourceBoardId) throw new Meteor.Error('invalid-selection');
// Board roles apply here as in every view (GHSA-r4gm-mjj9-g3x8): an
// assigned-only member moves only their own cards and what is on them -
// never a list or swimlane, which holds cards they cannot see. The move
// dialog offers them nothing else, so this is an attempt.
const owner = entry.kind === 'card' ? doc
: ['checklist', 'item'].includes(entry.kind) ? await Cards.findOneAsync(doc.cardId) : null;
const { mayCopyFromBoard } = require('/models/lib/boardCardScope');
if (!mayCopyFromBoard(sourceBoard, this.userId, owner || undefined)) {
try {
require('/server/lib/securityLog').record({
key: 'authz.assigned', action: 'blocked', source: 'move-board-objects', userId: this.userId,
detail: 'Assigned-only member tried to move something they cannot see.',
});
} catch (e) { /* logging must never break the guard */ }
throw new Meteor.Error('not-found');
}
entries.push(described);
}
const roots = selectionRoots(entries);
const rootKeys = new Set(roots.map(doc => `${doc.kind}:${doc._id}`));
// Reject targets that themselves move, including unselected descendants.
for (const [kind, doc] of Object.entries(dest)) {
const described = await describe(kind, doc);
if ([`${kind}:${doc._id}`, ...described.ancestors].some(key => rootKeys.has(key))) throw new Meteor.Error('invalid-destination', 'Choose a destination outside the selected objects.');
}
const needsLane = roots.some(doc => doc.kind !== 'swimlane');
const needsList = roots.some(doc => ['card', 'checklist', 'item'].includes(doc.kind));
if ((needsLane && !dest.swimlane) || (needsList && !dest.list)) throw new Meteor.Error('invalid-destination', 'Choose a destination swimlane and list.');
const grouped = Object.fromEntries(kinds.map(kind => [kind, roots.filter(doc => doc.kind === kind)]));
// ListLockBulkBleed: a card, checklist or item leaves its card's list and
// lands in the destination list or on the destination card; any of those
// lists may refuse this role a write (#4527). Whole lists and swimlanes are
// board structure and keep the board's own rule.
const { assertListsWritable } = require('/server/lib/listPermissionGate');
const sourceListIds = [];
for (const doc of roots) {
if (doc.kind === 'card') sourceListIds.push((await Cards.findOneAsync(doc._id, { fields: { listId: 1 } }))?.listId);
else if (doc.kind === 'checklist' || doc.kind === 'item') {
const owner = await collections[doc.kind].findOneAsync(doc._id, { fields: { cardId: 1 } });
sourceListIds.push(owner && (await Cards.findOneAsync(owner.cardId, { fields: { listId: 1 } }))?.listId);
}
}
await assertListsWritable(this.userId, sourceBoard, sourceListIds);
if (needsList) {
await assertListsWritable(this.userId, await Boards.findOneAsync(target.boardId),
[dest.list && dest.list._id, dest.card && dest.card.listId]);
}
// All permissions and parent relationships above are checked before writes.
for (const lane of grouped.swimlane) {
// Card move hooks validate the destination lane against its board.
// Move the parent first or they substitute the destination default lane.
await Swimlanes.updateAsync(lane._id, { $set: { boardId: target.boardId } });
if (lane.boardId !== target.boardId) {
const lists = await Lists.find({ boardId: sourceBoardId, swimlaneId: lane._id }).fetchAsync();
for (const list of lists) await Lists.updateAsync(list._id, { $set: { boardId: target.boardId } });
const cards = await Cards.find({ boardId: sourceBoardId, swimlaneId: lane._id }).fetchAsync();
const mapping = new Map(lists.map(list => [list._id, list._id]));
for (const card of cards) {
if (!mapping.has(card.listId)) {
const list = await Lists.findOneAsync(card.listId);
const { _id, ...copy } = list;
mapping.set(_id, await Lists.insertAsync({ ...copy, boardId: target.boardId, swimlaneId: lane._id }));
}
await card.move(target.boardId, lane._id, mapping.get(card.listId), card.sort);
}
}
}
if (grouped.swimlane.length && sourceBoardId !== target.boardId) {
const source = await Boards.findOneAsync(sourceBoardId);
await source.getDefaultSwimlineAsync();
}
for (const list of grouped.list) {
await Lists.updateAsync(list._id, { $set: { boardId: target.boardId, swimlaneId: target.swimlaneId } });
for (const card of await Cards.find({ boardId: sourceBoardId, listId: list._id }).fetchAsync()) await card.move(target.boardId, target.swimlaneId, list._id, card.sort);
}
for (const card of grouped.card) {
const live = await Cards.findOneAsync(card._id);
await live.move(target.boardId, target.swimlaneId, target.listId);
}
let cardId = target.cardId;
if ((grouped.checklist.length || grouped.item.length) && !cardId) {
cardId = await Cards.insertAsync({ boardId: target.boardId, swimlaneId: target.swimlaneId, listId: target.listId,
title: (grouped.checklist[0] || grouped.item[0]).title, userId: this.userId, sort: 0 });
grouped.card.push({ _id: cardId });
}
for (const checklist of grouped.checklist) {
await Meteor.server.method_handlers.moveChecklist.apply(this, [checklist._id, cardId]);
}
let checklistId = target.checklistId;
if (grouped.item.length && !checklistId) {
checklistId = await Checklists.insertAsync({ cardId, title: grouped.item[0].title, sort: 0 });
grouped.checklist.push({ _id: checklistId });
}
for (const item of grouped.item) {
await ChecklistItems.updateAsync(item._id, { $set: { cardId, checklistId, boardId: target.boardId } });
await Activities.updateAsync({ checklistItemId: item._id }, { $set: { cardId, checklistId, boardId: target.boardId } }, { multi: true });
}
const selectors = { swimlane: { boardId: target.boardId, archived: false }, list: { boardId: target.boardId, archived: false, $or: [{ swimlaneId: target.swimlaneId }, { swimlaneId: '' }, { swimlaneId: { $exists: false } }] }, card: { boardId: target.boardId, swimlaneId: target.swimlaneId, listId: target.listId, archived: false }, checklist: { cardId }, item: { checklistId } };
const anchors = { swimlane: target.swimlaneId, list: target.listId, card: target.cardId, checklist: target.checklistId, item: target.itemId };
for (const kind of kinds) if (grouped[kind].length) await positionGroup(kind, grouped[kind].map(doc => doc._id), selectors[kind], anchors[kind], target.position !== 'before');
return { moved: roots.length, cardId, checklistId };
},
});