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

218 lines
11 KiB
JavaScript

// Board View / Email (#794): the board as a Gmail-like mailbox
// (client/components/boards/emailView.*, docs/Features/Board-Header/Board-Views/Email-View.md).
//
// folders inbox the list email-to-card puts new cards in
// sent cards sent from this view
// all every card that came from or went out as email
// list:<listId> any list of the board, as a folder
// label:<labelId> any label of the board, as a Gmail label
//
// One page of rows at a time, newest first, as every WeKan table page does
// (docs/Features/General/Table.md): the publication applies skip/limit on the
// server and names its card ids in the page index (models/lib/reportPageIndex.js),
// so the client renders exactly the page and never re-slices the board's cards;
// the total comes from emailViewCount.
//
// Compose and reply send From the member's own board address, so the answer
// comes back to the same board - and, by its In-Reply-To, to the same card.
import { Meteor } from 'meteor/meteor';
import { check, Match } from 'meteor/check';
import { Random } from 'meteor/random';
import { ReactiveCache } from '/imports/reactiveCache';
import Cards from '/models/cards';
import { cardCreation } from '/models/cards';
import { allowIsBoardMemberWithWriteAccess } from '/server/lib/utils';
import { pageInfo, TABLE_PAGE_ROWS_PER_PAGE } from '/models/lib/tablePage';
import { publishReportPage, reportPageKey } from '/models/lib/reportPageIndex';
const { EMAIL_VIEW_PAGE_ID, emailViewPageArgs, emailFolderSelector, emailSearchSelector, cleanOutgoingEmail } = require('/models/lib/emailView');
const { createRateLimiter, resolveEmailToCard } = require('/models/lib/emailToCard');
const { boardAddress } = require('/server/lib/inboundBoardAddress');
const { assignedOnlyCardScope, mergeCardScope, isAssignedOnlyMember } = require('/models/lib/boardCardScope');
const ROW_FIELDS = {
title: 1, description: 1, createdAt: 1, receivedAt: 1, userId: 1, labelIds: 1, listId: 1,
boardId: 1, dueAt: 1, email: 1, cardNumber: 1,
};
// Admin Panel first, then EMAIL_VIEW_SENDS_PER_HOUR, read at every send
// (models/lib/authConfigCatalog.js, section inboundEmail).
const { authEnv } = require('/server/lib/authConfig');
const allowSend = createRateLimiter({ limit: () => Number(authEnv('EMAIL_VIEW_SENDS_PER_HOUR')) || 50 });
async function readableBoard(userId, boardId) {
check(boardId, String);
const board = await ReactiveCache.getBoard(boardId);
if (!board || !userId) return null;
const user = await ReactiveCache.getUser(userId);
return user && board.isVisibleBy(user) ? board : null;
}
// The Inbox: the list email to card puts cards in, else the first list.
export async function inboxListId(board) {
const chosen = board.emailToCard && board.emailToCard.listId;
if (chosen && await ReactiveCache.getList({ _id: chosen, boardId: board._id, archived: false })) return chosen;
const lists = await ReactiveCache.getLists({ boardId: board._id, archived: false }, { sort: { sort: 1 } });
return lists && lists[0] ? lists[0]._id : null;
}
// The folder and search, narrowed by the member's board role: an
// assigned-only member's mailbox holds only the cards assigned to them, as
// every other view of the board does (GHSA-r4gm-mjj9-g3x8). Opening the view
// is ordinary use, so nothing is recorded.
async function selectorFor(board, userId, folder, search) {
return mergeCardScope({
...emailFolderSelector(board._id, folder, { inboxListId: await inboxListId(board) }),
...emailSearchSelector(search),
}, assignedOnlyCardScope(board, userId));
}
const OptionsPattern = { folder: String, page: Match.Optional(Number), search: Match.Optional(String) };
// Published manually (fetch + this.added + the page index), like the other
// table pages (server/publications/boards.js publicBoards): a sorted, limited
// live cursor would re-run the query on every card change of the board. The
// client subscribes again when the board's card count moves, so new mail
// still appears.
Meteor.publish('emailViewPage', async function emailViewPage(boardId, options) {
check(options, OptionsPattern);
const board = await readableBoard(this.userId, boardId);
if (!board) return this.ready();
const selector = await selectorFor(board, this.userId, options.folder, options.search);
const page = Math.max(1, Math.floor(options.page || 1));
const docs = await Cards.find(selector, {
sort: { createdAt: -1, _id: 1 },
skip: (page - 1) * TABLE_PAGE_ROWS_PER_PAGE,
limit: TABLE_PAGE_ROWS_PER_PAGE,
fields: ROW_FIELDS,
}).fetchAsync();
for (const doc of docs) {
const { _id, ...fields } = doc;
this.added('cards', _id, fields);
}
publishReportPage(this, reportPageKey(EMAIL_VIEW_PAGE_ID, emailViewPageArgs(boardId, options)), docs);
return this.ready();
});
Meteor.methods({
async emailViewCount(boardId, options) {
check(options, OptionsPattern);
const board = await readableBoard(this.userId, boardId);
if (!board) throw new Meteor.Error('not-authorized');
const total = await Cards.find(await selectorFor(board, this.userId, options.folder, options.search)).countAsync();
return { total, inboxListId: await inboxListId(board), pages: pageInfo(total, 1).totalPages };
},
// Compose, or reply on a card (cardId). From is the member's board
// address; the email is recorded on the board - a new card in the Inbox
// (Sent shows it), or a comment on the card replied to.
async sendBoardEmail(boardId, input) {
check(boardId, String);
check(input, { to: [String], cc: Match.Optional([String]), subject: String, text: String,
cardId: Match.Optional(String) });
const userId = this.userId;
const board = await ReactiveCache.getBoard(boardId);
if (!userId || !board || !allowIsBoardMemberWithWriteAccess(userId, board)) throw new Meteor.Error('not-authorized');
let email;
try {
email = cleanOutgoingEmail(input);
} catch (e) {
throw new Meteor.Error(e.message);
}
const { inboundMailSettings, addressRow } = require('/server/emailToCard');
const inboundMail = await inboundMailSettings();
const user = await Meteor.users.findOneAsync(userId, { fields: { profile: 1, username: 1 } });
const resolved = resolveEmailToCard({
admin: { enabled: inboundMail.enabled === true, domain: inboundMail.domain || '' },
board: board.emailToCard || {},
member: (user.profile && user.profile.emailToCard) || {},
});
// Without a board address a reply would have nowhere to come back to.
if (!resolved.enabled) throw new Meteor.Error(`email-to-card-off-${resolved.reason}`);
if (!allowSend(userId)) throw new Meteor.Error('email-view-too-many');
const row = await addressRow(board._id, userId);
const sandstorm = !!Meteor.settings?.public?.sandstorm;
const from = boardAddress(row.token, inboundMail.domain);
const name = (user.profile && user.profile.fullname) || user.username || '';
// On Sandstorm From is the grain's own address; the token in the subject
// brings the reply back to this member's board (server/sandstormEmail.js).
const subject = sandstorm ? `${email.subject} [board+${row.token}]` : email.subject;
const messageId = `<${Random.id(24)}@${inboundMail.domain || 'wekan.invalid'}>`;
let card = null;
if (input.cardId) {
card = await ReactiveCache.getCard({ _id: input.cardId, boardId: board._id });
if (!card) throw new Meteor.Error('not-found');
// A reply comments on the card and continues its thread: an
// assigned-only member replies only on their own cards. The view never
// lists another card to them, so this is an attempt.
if (isAssignedOnlyMember(board, userId) && !(card.assignees || []).includes(userId)) {
try {
require('/server/lib/securityLog').record({
key: 'authz.assigned', action: 'blocked', source: 'email-view:reply', userId,
detail: 'Assigned-only member replied by email on a card not assigned to them.',
});
} catch (e) { /* logging must never break the guard */ }
throw new Meteor.Error('not-found');
}
}
// ListLockBulkBleed: a reply writes on the card, a new email puts a card in
// the Inbox - either list may refuse this role (#4527). Asked before the
// mail goes out, so a refused send sends nothing.
await require('/server/lib/listPermissionGate').assertListsWritable(userId, board,
[card ? card.listId : await inboxListId(board)]);
const thread = card && card.email && Array.isArray(card.email.threadIds) ? card.email.threadIds : [];
const { Email } = require('meteor/email');
try {
await Email.sendAsync({
from: name ? `"${name.replace(/["\\\r\n]/g, '')}" <${from}>` : from,
replyTo: from,
to: email.to,
cc: email.cc,
subject,
text: email.text,
messageId,
inReplyTo: thread.length ? thread[thread.length - 1] : undefined,
references: thread.length ? thread.slice(-20) : undefined,
});
} catch (error) {
// The mail server said no, or could not be reached: the member sees
// that it was not sent, and the administrator sees why.
require('/server/lib/mailProblems').recordMailProblem('send-failed', {
source: 'email-view', userId,
detail: `${(error && (error.responseCode || error.code)) || ''} ${(error && (error.response || error.message)) || error}`.trim(),
});
throw new Meteor.Error('email-view-send-failed');
}
const { addEmailComment } = require('/server/emailToCard');
if (card) {
await addEmailComment(card, userId, email.text);
await Cards.direct.updateAsync(card._id, { $addToSet: { 'email.threadIds': messageId } });
return { cardId: card._id };
}
const listId = await inboxListId(board);
const swimlane = await board.getDefaultSwimlineAsync();
if (!listId || !swimlane) throw new Meteor.Error('email-view-no-list');
const siblings = await ReactiveCache.getCards({ listId, archived: false });
const cardId = await Cards.direct.insertAsync({
title: email.subject,
description: email.text,
boardId: board._id,
listId,
swimlaneId: swimlane._id,
userId,
sort: (siblings || []).length,
cardNumber: await board.getNextCardNumber(),
email: {
direction: 'out', from: { name, address: from }, to: email.to, cc: email.cc,
subject: email.subject, messageId, threadIds: [messageId], at: new Date(),
},
});
const created = await ReactiveCache.getCard(cardId);
if (created) await cardCreation(userId, created);
return { cardId };
},
});