ApostropheCMS: Same-parent page reorder in @apostrophecms/page move() re-ranks a restricted parent's children without create authorization

Summary

ApostropheCMS enforces per-type authorization on pages: a page type may declare editRole / publishRole (the core @apostrophecms/archive-page does), so a project can define restricted subtrees that only higher-privileged roles may create or edit within. The move() operation in the @apostrophecms/page module is supposed to enforce that a page may only be moved into a parent the actor has create rights over, the same boundary the page-insert route enforces. The destination-parent authorization check in move() is gated on the move being a cross-parent move (oldParent._id !== parent._id). A same-parent reorder (repositioning a page among its existing siblings under the same parent) short-circuits that check entirely, so an authenticated low-privileged editor who holds edit rights on one ordinary page nested under a restricted parent can reposition it and, in doing so, trigger an unguarded bulk database write that re-ranks the restricted parent's other children, documents the editor has no authorization to modify.

Root Cause

The security invariant is that mutating the sibling ordering of a restricted parent's children requires create authority on that parent, which is exactly what the page-insert path enforces (insert() throws forbidden when !parent._create before it nudges peers). The destination authorization guard in move() restores this boundary only for cross-parent moves: its leading conjunct is (oldParent._id !== parent._id). For a same-parent reorder both oldParent and parent are the identical restricted parent, so the conjunct is false, the whole conditional short-circuits, and the parent._create requirement is never evaluated. The only surviving gate on the path is moved._edit, which the editor legitimately holds for the ordinary page being moved. The subsequent sibling re-rank is issued as a raw MongoDB updateMany that never passes through the per-document beforeUpdate edit check, so the restricted siblings are modified with no authorization at all.

Affected function: @apostrophecms/page move() (inner body)
  packages/apostrophe/modules/@apostrophecms/page/index.js:1684-1691
    if (
      (oldParent._id !== parent._id) &&               // false for a same-parent reorder -> whole check skipped
      (parent.type !== '@apostrophecms/archive-page') &&
      (!parent._create) &&
      !(oldParent.type === '@apostrophecms/archive-page' && parent._edit)
    ) {
      throw self.apos.error('forbidden');
    }

Unguarded sink: nudgeNewPeers()
  packages/apostrophe/modules/@apostrophecms/page/index.js:1781-1803
    await self.apos.doc.db.updateMany(
      { path: matchDescendants(parent), level: parent.level + 1,
        aposLocale: { $in: [ draft, published ] }, rank: { $gte: rank } },
      { $inc: { rank: 1 } });   // no permission clause; bypasses beforeUpdate

Contrasting correct boundary: insert()
  packages/apostrophe/modules/@apostrophecms/page/index.js:1436-1439
    if (!parent._create) { throw self.apos.error('forbidden'); }  // enforced for every position

Impact

The attacker is an authenticated low-privileged user, an editor (or a contributor operating in draft mode), who holds edit rights on at least one ordinary page that is nested as a direct child of a restricted-type parent. No admin rights and no special tokens are required. Authorization in this CMS is resolved per page type, not per subtree: a page's editability is judged by its own type's editRole, so an ordinary public-page child can be editable by an editor even though its restricted secret-page-type parent (declaring editRole: admin) is not. Exploiting the gap, the editor can persistently alter the rank (sibling ordering, which drives navigation and menu order) of the restricted parent's other children, documents on which the editor holds no edit, create, publish, or delete authority. Repeating the reposition monotonically inflates those siblings' ranks. This is an integrity and authorization-boundary violation (CWE-862 / CWE-639) confined to sibling ordering; it does not disclose restricted field contents (confidentiality is unaffected) and it does not affect availability. The precondition (an editor-editable page already nested under a restricted parent) is a non-default tree state that an administrator establishes, or that arises from configuration drift when a page type gains a restricting editRole after editable children were already placed beneath it.

Proof of Concept

Dependencies: Node.js and a local MongoDB instance. The reproduction uses ApostropheCMS's own test harness to drive the real apos.page.move() code path with a non-admin editor request. No fresh end-to-end run was performed in the review environment (no MongoDB available); the chain was verified against source, and the sink behavior is independently corroborated by the CVE-2026-63669 advisory's own description and its cross-parent-only regression test.

1. Configure a restricted page type secret-page with editRole: 'admin' and publishRole: 'admin', and an ordinary type public-page with no role restriction.
2. As an admin, create a secret-page section under home, then create two secret-page children beneath it (the pre-existing restricted siblings), and place one editor-editable public-page as a further child of the secret section (the non-default nesting precondition).
3. As a non-admin editor, confirm the editor lacks _create/_edit on the secret section, then reposition the editable public-page among its siblings under the same secret parent.

// Same-parent reorder under a restricted parent, driven as a non-admin editor.
// The move must be forbidden but is not; the restricted siblings are re-ranked.
const editorReq = apos.task.getReq({
  role: 'editor',
  user: { _id: 'editor-user', title: 'Editor', role: 'editor' }
});

// `mine` is an editor-editable public-page already nested under the admin-only `secret` section.
// `secretChild` is a pre-existing admin-only sibling under the same `secret` parent.
const before = await apos.page.find(adminReq, { _id: secretChild._id }).toObject();

// Reposition `mine` to firstChild of its OWN current parent (secret) -> same-parent reorder.
await apos.page.move(editorReq, mine._id, secret._id, 'firstChild');

const after = await apos.page.find(adminReq, { _id: secretChild._id }).toObject();
console.log('secret child rank before:', before.rank, 'after:', after.rank);

Expected (secure) behavior: apos.page.move() throws "forbidden" for the editor.
Observed behavior (source-derived): move() succeeds; nudgeNewPeers() issues
updateMany({ ... rank: { $gte: 0 } }, { $inc: { rank: 1 } }) over the secret
section's children, so the admin-only sibling's rank changes (e.g. 0 -> 1)
even though the editor holds no edit/create rights on it.

Over HTTP the identical effect is reachable by a logged-in non-admin via PATCH /api/v1/@apostrophecms/page/<myPageId>:en:draft with body { "_targetId": "<sameParentId>:en:draft", "_position": "firstChild" } (also before/after a sibling), since the route reaches move() after only the page._edit gate on the moved page.

Attack Chain

1. Exposure: An authenticated editor sends PATCH (or PUT) /api/v1/@apostrophecms/page/<C> where C is an ordinary page the editor may edit, with body { _targetId: <P>, _position: 'firstChild' } and P is C's own current restricted parent. The route enforces only page._edit on the moved page C (index.js:1245 for patch, 619 for put).
2. Control: The attacker controls _targetId and _position. C's editability is resolved from C's own type via checkRoleConfig (permission/index.js:99-102, 114-122); an ordinary public-page passes for an editor regardless of the parent's type.
3. Path: move() resolves the target with using (index.js:1873-1899), so no authorization is applied to the restricte