Skip to content

Node.js based forum software built for the modern web

fix: only administrators and admin:users holders handle user flags (#14890)

palmoni5b9121aab96df
diff --git a/src/api/flags.js b/src/api/flags.js
index 9280cad415..d5e48d269d 100644
--- a/src/api/flags.js
+++ b/src/api/flags.js
@@ -1,6 +1,5 @@
'use strict';
-const user = require('../user');
const flags = require('../flags');
const flagsApi = module.exports;
@@ -27,8 +26,7 @@ flagsApi.create = async (caller, data) => {
};
flagsApi.get = async (caller, { flagId }) => {
- const isPrivileged = await user.isPrivileged(caller.uid);
- if (!isPrivileged) {
+ if (!await flags.canView(flagId, caller.uid)) {
throw new Error('[[error:no-privileges]]');
}
@@ -36,12 +34,11 @@ flagsApi.get = async (caller, { flagId }) => {
};
flagsApi.update = async (caller, data) => {
- const allowed = await user.isPrivileged(caller.uid);
- if (!allowed) {
+ const { flagId } = data;
+ if (!await flags.canView(flagId, caller.uid)) {
throw new Error('[[error:no-privileges]]');
}
- const { flagId } = data;
delete data.flagId;
await flags.update(flagId, caller.uid, data);
@@ -79,8 +76,7 @@ flagsApi.rescindUser = async ({ uid }, { uid: targetUid }) => {
};
flagsApi.appendNote = async (caller, data) => {
- const allowed = await user.isPrivileged(caller.uid);
- if (!allowed) {
+ if (!await flags.canView(data.flagId, caller.uid)) {
throw new Error('[[error:no-privileges]]');
}
if (data.datetime && data.flagId) {
diff --git a/src/controllers/mods.js b/src/controllers/mods.js
index 402e76f106..00eee1fdce 100644
--- a/src/controllers/mods.js
+++ b/src/controllers/mods.js
@@ -6,7 +6,6 @@ const user = require('../user');
const groups = require('../groups');
const meta = require('../meta');
const posts = require('../posts');
-const db = require('../database');
const flags = require('../flags');
const analytics = require('../analytics');
const plugins = require('../plugins');
@@ -36,14 +35,17 @@ modsController.flags.list = async function (req, res) {
type: ['post', 'user', 'message'],
};
- const [isAdminOrGlobalMod, moderatedCids, { filters: allFilters }, { sorts: allSorts }] = await Promise.all([
+ const [
+ isAdminOrGlobalMod, moderatedCids, visibleSets, { filters: allFilters }, { sorts: allSorts },
+ ] = await Promise.all([
user.isAdminOrGlobalMod(req.uid),
user.getModeratedCids(req.uid),
+ flags.getVisibleSets(req.uid),
plugins.hooks.fire('filter:flags.validateFilters', { filters: coreFilters, validation }),
plugins.hooks.fire('filter:flags.validateSort', { sorts: validation.sort }),
]);
- if (!(isAdminOrGlobalMod || !!moderatedCids.length)) {
+ if (visibleSets && !visibleSets.length) {
return helpers.notAllowed(req, res);
}
@@ -54,16 +56,19 @@ modsController.flags.list = async function (req, res) {
const validFilters = helpers.validateParameters(req.query, allFilters, validation);
let hasFilter = !!Object.keys(validFilters).length;
+ let cidIsDefault = false;
if (res.locals.cids) {
if (!validFilters.cid) {
// If mod and no cid filter, add filter for their modded categories
validFilters.cid = res.locals.cids;
+ cidIsDefault = true;
} else if (Array.isArray(validFilters.cid)) {
// Remove cids they do not moderate
validFilters.cid = validFilters.cid.filter(cid => res.locals.cids.includes(String(cid)));
} else if (!res.locals.cids.includes(String(validFilters.cid))) {
validFilters.cid = res.locals.cids;
+ cidIsDefault = true;
hasFilter = false;
}
}
@@ -82,9 +87,17 @@ modsController.flags.list = async function (req, res) {
hasFilter = hasFilter || !!sort;
+ const listFilters = { ...validFilters };
+ if (cidIsDefault) {
+ delete listFilters.cid;
+ }
+ if (visibleSets) {
+ listFilters.visible = visibleSets;
+ }
+
const [flagsData, analyticsData, selectData] = await Promise.all([
flags.list({
- filters: validFilters,
+ filters: listFilters,
sort: sort,
uid: req.uid,
query: req.query,
@@ -125,39 +138,14 @@ modsController.flags.list = async function (req, res) {
};
modsController.flags.detail = async function (req, res, next) {
+ if (!await flags.canView(req.params.flagId, req.uid)) {
+ return next(); // 404
+ }
const results = await utils.promiseParallel({
- isAdmin: user.isAdministrator(req.uid),
- isAdminOrGlobalMod: user.isAdminOrGlobalMod(req.uid),
- moderatedCids: user.getModeratedCids(req.uid),
flagData: flags.get(req.params.flagId),
privileges: Promise.all(['global', 'admin'].map(async type => privileges[type].get(req.uid))),
});
results.privileges = { ...results.privileges[0], ...results.privileges[1] };
- if (!results.flagData || (!(results.isAdminOrGlobalMod || !!results.moderatedCids.length))) {
- return next(); // 404
- }
-
- // message flags require admin access regardless of global mod status
- if (results.flagData.type === 'message' && !results.isAdmin) {
- return next();
- }
-
- // extra checks for plain moderators
- if (!results.isAdminOrGlobalMod) {
- if (results.flagData.type === 'user') {
- return next();
- }
- if (results.flagData.type === 'post') {
- const isFlagInModeratedCids = await db.isMemberOfSortedSets(
- results.moderatedCids.map(cid => `flags:byCid:${cid}`),
- results.flagData.flagId
- );
- if (!isFlagInModeratedCids.includes(true)) {
- return next();
- }
- }
- }
-
async function getAssignees(flagData, uid) {
let uids = [];
diff --git a/src/flags.js b/src/flags.js
index 158f9761f7..94a7a890ba 100644
--- a/src/flags.js
+++ b/src/flags.js
@@ -75,6 +75,9 @@ Flags.init = async function () {
cid: function (sets, orSets, key) {
prepareSets(sets, orSets, 'flags:byCid:', key);
},
+ visible: function (sets, orSets, key) {
+ orSets.push(key);
+ },
page: function () { /* noop */ },
perPage: function () { /* noop */ },
quick: function (sets, orSets, key, uid) {
@@ -707,6 +710,10 @@ Flags.canView = async (flagId, uid) => {
return user.isAdministrator(uid);
}
+ if (type === 'user') {
+ return privileges.admin.can('admin:users', uid);
+ }
+
if (type === 'post') {
const cid = await Flags.getTargetCid(type, targetId);
const isModerator = await user.isModerator(uid, cid);
@@ -717,6 +724,25 @@ Flags.canView = async (flagId, uid) => {
return isAdminOrGlobalMod;
};
+Flags.getVisibleSets = async (uid) => {
+ const [isAdmin, isAdminOrGlobalMod, canManageUsers, moderatedCids] = await Promise.all([
+ user.isAdministrator(uid),
+ user.isAdminOrGlobalMod(uid),
+ privileges.admin.can('admin:users', uid),
+ user.getModeratedCids(uid),
+ ]);
+ if (isAdmin) {
+ return null;
+ }
+ const sets = isAdminOrGlobalMod ?
+ ['flags:byType:post'] :
+ moderatedCids.map(cid => `flags:byCid:${cid}`);
+ if (canManageUsers) {
+ sets.push('flags:byType:user');
+ }
+ return sets;
+};
+
Flags.getTarget = async function (type, id, uid) {
if (type === 'user') {
const userData = await user.getUserData(id);
@@ -988,6 +1014,7 @@ Flags.notify = async function (flagObj, uid, notifySelf = false) {
});
uids = uids.concat(modUids[0]);
} else if (flagObj.type === 'user') {
+ uids = _.uniq(admins.concat(await privileges.admin.getUidsWithPrivilege('admin:users')));
const targetDisplayname = await user.getNotificationDisplayname(flagObj.targetId);
notifObj = await notifications.create({
type: 'new-user-flag',
diff --git a/src/middleware/render.js b/src/middleware/render.js
index 5ec01fd369..6847a5d27d 100644
--- a/src/middleware/render.js
+++ b/src/middleware/render.js
@@ -412,17 +412,18 @@ module.exports = function (middleware) {
unreadChatCount: messaging.getUnreadCount(uid),
unreadNotificationCount: user.notifications.getUnreadCount(uid),
unreadFlagCount: (async function () {
- if (routes.includes('/flags') && await user.isPrivileged(uid)) {
- return flags.getCount({
- uid,
- query,
- filters: {
- quick: 'unresolved',
- cid: (await user.isAdminOrGlobalMod(uid)) ? [] : (await user.getModeratedCids(uid)),
- },
- });
+ if (!routes.includes('/flags')) {
+ return 0;
}
- return 0;
+ const visibleSets = await flags.getVisibleSets(uid);
+ if (visibleSets && !visibleSets.length) {
+ return 0;
+ }
+ const filters = { quick: 'unresolved' };
+ if (visibleSets) {
+ filters.visible = visibleSets;
+ }
+ return flags.getCount({ uid, query, filters });
}()),
};
const results = await utils.promiseParallel(calls);
diff --git a/test/flags.js b/test/flags.js
index 5508f6f2be..d7a3b9993a 100644
--- a/test/flags.js
+++ b/test/flags.js
@@ -1526,4 +1526,99 @@ describe('Flags', () => {
});
});
+
+ describe('user flag access', () => {
+ let globalModUid;
+ let userManagerUid;
+ let targetUid;
+ let flagId;
+ let globalModJar;
+ let userManagerJar;
+
+ before(async () => {
+ globalModUid = await User.create({ username: 'user-flag-global-mod', password: 'abcdef' });
+ await Groups.join('Global Moderators', globalModUid);
+ userManagerUid = await User.create({ username: 'user-flag-user-manager', password: 'abcdef' });
+ await Privileges.admin.give(['admin:users'], userManagerUid);
+ targetUid = await User.create({ username: 'user-flag-target' });
+
+ ({ flagId } = await api.flags.create({ uid: uid1 }, { type: 'user', id: targetUid, reason: 'spam' }));
+ await sleep(2000);
+
+ ({ jar: globalModJar } = await helpers.loginUser('user-flag-global-mod', 'abcdef'));
+ ({ jar: userManagerJar } = await helpers.loginUser('user-flag-user-manager', 'abcdef'));
+ });
+
+ after(async () => {
+ await Privileges.admin.rescind(['admin:users'], userManagerUid);
+ await Groups.leave('Global Moderators', globalModUid);
+ });
+
+ it('should let admin:users holders view a user flag, but not global moderators', async () => {
+ assert.strictEqual(await Flags.canView(flagId, userManagerUid), true);
+ assert.strictEqual(await Flags.canView(flagId, globalModUid), false);
+ assert.strictEqual(await Flags.canView(flagId, adminUid), true);
+ });
+
+ it('should notify admin:users holders of a new user flag, but not global moderators', async () => {
+ const nid = `flag:user:${targetUid}:${uid1}`;
+ assert(await db.isSortedSetMember(`uid:${userManagerUid}:notifications:unread`, nid));
+ assert(await db.isSortedSetMember(`uid:${adminUid}:notifications:unread`, nid));
+ assert(!await db.isSortedSetMember(`uid:${globalModUid}:notifications:unread`, nid));
+ });
+
+ it('should open the flag detail page only for those who can view the flag', async () => {
+ let { response } = await request.get(`${nconf.get('url')}/api/flags/${flagId}`, { jar: userManagerJar });
+ assert.strictEqual(response.statusCode, 200);
+
+ ({ response } = await request.get(`${nconf.get('url')}/api/flags/${flagId}`, { jar: globalModJar }));
+ assert.strictEqual(response.statusCode, 404);
+ });
+
+ it('should list user flags only to those who can view them', async () => {
+ const { body: managerList } = await request.get(`${nconf.get('url')}/api/flags`, { jar: userManagerJar });
+ assert(managerList.flags.some(flag => flag.flagId === flagId));
+ assert(managerList.flags.every(flag => flag.type === 'user'));
+
+ const { body: globalModList } = await request.get(`${nconf.get('url')}/api/flags`, { jar: globalModJar });
+ assert(globalModList.flags.every(flag => flag.type !== 'user'));
+
+ const { body: filteredList } = await request.get(`${nconf.get('url')}/api/flags?type=user`, { jar: globalModJar });
+ assert.strictEqual(filteredList.flags.length, 0);
+ });
+
+ it('should list both user flags and moderated category flags to a moderator who holds admin:users', async () => {
+ const { postData } = await Topics.post({
+ cid: category.cid,
+ uid: uid3,
+ title: utils.generateUUID(),
+ content: utils.generateUUID(),
+ });
+ const { flagId: postFlagId } = await Flags.create('post', postData.pid, uid1, 'spam');
+ await Privileges.admin.give(['admin:users'], moderatorUid);
+ try {
+ const { body } = await request.get(`${nconf.get('url')}/api/flags`, { jar });
+ const flagIds = body.flags.map(flag => flag.flagId);
+ assert(flagIds.includes(flagId));
+ assert(flagIds.includes(postFlagId));
+ } finally {
+ await Privileges.admin.rescind(['admin:users'], moderatorUid);
+ }
+ });
+
+ it('should let admin:users holders read and update a user flag through the write API', async () => {
+ let { response } = await helpers.request('get', `/api/v3/flags/${flagId}`, { jar: userManagerJar });
+ assert.strictEqual(response.statusCode, 200);
+
+ ({ response } = await helpers.request('get', `/api/v3/flags/${flagId}`, { jar: globalModJar }));
+ assert.strictEqual(response.statusCode, 404);
+
+ await api.flags.update({ uid: userManagerUid }, { flagId, state: 'wip' });
+ assert.strictEqual(await db.getObjectField(`flag:${flagId}`, 'state'), 'wip');
+ await assert.rejects(
+ api.flags.update({ uid: globalModUid }, { flagId, state: 'resolved' }),
+ { message: '[[error:no-privileges]]' }
+ );
+ });
+ });
});