mirror of
https://github.com/wekan/wekan.git
synced 2026-11-20 09:45:04 -05:00
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 !
101 lines
4.7 KiB
JavaScript
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 };
|
|
},
|
|
});
|