Files
wekan/server/versionControlView.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

101 lines
4.7 KiB
JavaScript

// Board View / Version Control: the board as a GitHub / Gitea issue tracker
// (client/components/boards/versionControlView.*,
// docs/Features/Board-Header/Board-Views/Version-Control-View.md). Reading needs nothing new -
// the cards, labels, comments and attachments are the board's own, already
// published to whoever can see the board. Only two writes need the server:
//
// vcsCreateIssue New issue: a card in the board's open list
// vcsSetIssueState Close / Reopen: the card moves to the closed / open list
//
// Both write through the ordinary collections, not `.direct`, so the change
// history hooks (server/models/changeHistoryHooks.js) record them and the
// History tab - the board's history table - can undo them like any other move.
import { Meteor } from 'meteor/meteor';
import { check, Match } from 'meteor/check';
import { ReactiveCache } from '/imports/reactiveCache';
import Cards from '/models/cards';
import Lists from '/models/lists';
import { allowIsBoardMemberWithWriteAccess } from '/server/lib/utils';
import { canEditCardOrLinkedCard } from '/server/lib/linkedCardPermission';
const { cleanNewIssue, stateTarget, isSyncedIssue } = require('/models/lib/versionControlView');
async function writableBoard(userId, boardId) {
const board = await ReactiveCache.getBoard(boardId);
if (!userId || !board || !allowIsBoardMemberWithWriteAccess(userId, board)) throw new Meteor.Error('not-authorized');
return board;
}
// The list a state lives in, made when the board has none (a board that was
// not imported from a tracker has no "Closed" list until an issue is closed).
async function listFor(board, state) {
const lists = await ReactiveCache.getLists({ boardId: board._id, archived: false }, { sort: { sort: 1 } });
const target = stateTarget(lists || [], state);
if (target.listId) return target.listId;
const last = (lists || []).reduce((max, l) => Math.max(max, Number(l.sort) || 0), -1);
return Lists.insertAsync({
title: target.create, boardId: board._id, sort: last + 1, archived: false, createdAt: new Date(),
});
}
Meteor.methods({
async vcsCreateIssue(boardId, input) {
check(boardId, String);
check(input, { title: String, body: Match.Optional(String), labelIds: Match.Optional([String]) });
const userId = this.userId;
const board = await writableBoard(userId, boardId);
let issue;
try {
issue = cleanNewIssue(input);
} catch (e) {
throw new Meteor.Error(e.message);
}
const known = new Set((board.labels || []).map(l => l._id));
const listId = await listFor(board, 'open');
const swimlane = await board.getDefaultSwimlineAsync();
if (!listId || !swimlane) throw new Meteor.Error('vcs-no-list');
// ListLockBulkBleed: the Open list may refuse this role a new card (#4527).
await require('/server/lib/listPermissionGate').assertListsWritable(userId, board, [listId]);
const siblings = await ReactiveCache.getCards({ boardId: board._id, listId, archived: false });
const cardId = await Cards.insertAsync({
title: issue.title,
description: issue.body,
boardId: board._id,
listId,
swimlaneId: swimlane._id,
userId,
labelIds: issue.labelIds.filter(id => known.has(id)),
sort: (siblings || []).length,
cardNumber: await board.getNextCardNumber(),
});
// The "created" activity comes from Cards.after.insert (server/models/
// cards.js), as for any card inserted through the collection. Recording
// it here as well gave every new issue two, and its watchers two
// notifications (#6823).
return { cardId };
},
async vcsSetIssueState(cardId, state) {
check(cardId, String);
check(state, Match.OneOf('open', 'closed'));
const userId = this.userId;
const card = await ReactiveCache.getCard(cardId);
if (!card) throw new Meteor.Error('not-found');
const board = await writableBoard(userId, card.boardId);
// Closing an issue moves its card: only a card the caller may edit, which
// for an assigned-only member is their own (GHSA-r4gm-mjj9-g3x8).
if (!(await canEditCardOrLinkedCard(userId, card, board))) throw new Meteor.Error('not-authorized');
// A synced issue is closed and reopened in its tracker, and the next sync
// brings the state: moving the card out of its synced list would make
// the sync see the issue as gone.
if (isSyncedIssue(card)) throw new Meteor.Error('vcs-synced-issue');
// An archived card is a closed issue; reopening it restores it.
if (state === 'open' && card.archived) await card.restore();
const listId = await listFor(board, state);
if (listId && listId !== card.listId) {
await Cards.updateAsync(card._id, { $set: { listId, dateLastActivity: new Date() } });
}
return { listId };
},
});