mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-20 23:13:35 +00:00
* feat: Audit Resource ACL Changes and Fail Closed by Default * fix: Keep Non-Reversible Admin Audit Handlers Fail-Open * docs: Narrow AUDIT_LOG_FAIL_CLOSED Description * fix: Audit and Restore ACL and Insights Changes in One Pass * fix: Break Audit and Insights Permission Type Cycle * test: Cover Resource ACL Audit Scenarios * refactor: Audit Resource Permission Changes Before Writing * test: Align Concurrent Revoke Audit Expectation * fix: Skip Deleting ACL Entries That Were Not Audited * fix: Read ACL Snapshots Through the Write Session * fix: Never Block Revocations on Audit Outages and Normalize Principal Keys * fix: Let an Explicit Public Disable Win Over a Public Update * fix: Audit Duplicate ACL Rows as Combined Permissions * fix: Audit Permission Changes Under One Target and Dedupe Revokes * fix: Audit Capability Grants Before Writing Them * feat: Serialize Resource Permission Updates With a Per-Resource Lease * fix: Fence the Resource Lease Before Writes and Always Audit Grant Assignments * fix: Renew the Resource Lease Before Each ACL Write Phase * fix: Serialize System Grant Assignment and Revocation With a Per-Grant Lease * fix: Keep Leases Alive During Audits, Bound Lock Index Wait, Canonicalize Audit Target IDs * fix: Retry Deferred Revoke Audits Under the Lease and Audit Canonical Principal and Role IDs * test: Expect Role IDs in Permission Audit Metadata * fix: Read Mutation Snapshots From the Primary Outside Transactions * fix: Flush Deferred Audits Before Cache Invalidation, Keep Renewals Monotonic, Keep Role Case in Grant Lease Keys * refactor: Map the Busy Permission Error to Its Code in the API Package * style: Sort Lease Imports and Type the Renewal Spec Read * fix: Keep Success Audits After Commit, Report Downgrades as Revocations, Code Audit Outages * refactor: Move the Audit Outage Code to Its Own Module * fix: Translate Lock Failures, Lease Non-Transactional Sessions, and Code Grant Audit Outages * fix: Sanitize Lease Renewal Failures at the Permission Boundary * fix: Annotate the Unavailable Error Code for Isolated Declarations * fix: Keep the Admin Route Fail-Closed Opt-In and Document Lease Clock Skew Safety * fix: Translate Grant Lease Store Failures to a Retryable 503 * fix: Log Failed Grant Audit Writes With Safe Metadata Only * test: Detect Raw Error Arguments in the Grant Audit Log Spec * feat: Make Permission Lease Limits Configurable and Localize Retryable Sharing Failures * fix: Bound Lock Index Readiness by the Lease Wait and Carry the Resource ID in Every Audit Entry * test: Cover Lease Config Reaching the Leases and the Sharing Dialog Failure Messages * fix: Load App Config on the Sharing and Grant Routes and Log Failed Lease Releases * perf: Load App Config Only on the Grant Mutation Routes
223 lines
6.9 KiB
JavaScript
223 lines
6.9 KiB
JavaScript
const mongoose = require('mongoose');
|
|
const express = require('express');
|
|
const {
|
|
AccessRoleIds,
|
|
PrincipalType,
|
|
ResourceType,
|
|
PermissionBits,
|
|
} = require('librechat-data-provider');
|
|
const { createAgentAdminPermissionAccess, isAgentPermissionsAdmin } = require('@librechat/api');
|
|
const {
|
|
getUserEffectivePermissions,
|
|
getAllEffectivePermissions,
|
|
updateResourcePermissions,
|
|
getResourcePermissions,
|
|
getResourceRoles,
|
|
searchPrincipals,
|
|
} = require('~/server/controllers/PermissionsController');
|
|
const {
|
|
checkShareAccess,
|
|
checkSharePublicAccess,
|
|
} = require('~/server/middleware/checkSharePublicAccess');
|
|
const {
|
|
requireJwtAuth,
|
|
checkBan,
|
|
uaParser,
|
|
canAccessResource,
|
|
configMiddleware,
|
|
} = require('~/server/middleware');
|
|
const { checkPeoplePickerAccess } = require('~/server/middleware/checkPeoplePickerAccess');
|
|
const db = require('~/models');
|
|
const { findMCPServerByObjectId, getSkillById } = db;
|
|
|
|
const router = express.Router();
|
|
|
|
// Apply common middleware
|
|
router.use(requireJwtAuth);
|
|
router.use(checkBan);
|
|
router.use(uaParser);
|
|
|
|
/**
|
|
* Generic routes for resource permissions
|
|
* Pattern: /api/permissions/{resourceType}/{resourceId}
|
|
*/
|
|
|
|
/**
|
|
* GET /api/permissions/search-principals
|
|
* Search for users and groups to grant permissions
|
|
*/
|
|
router.get('/search-principals', checkPeoplePickerAccess, searchPrincipals);
|
|
|
|
/**
|
|
* GET /api/permissions/{resourceType}/roles
|
|
* Get available roles for a resource type
|
|
*/
|
|
router.get('/:resourceType/roles', getResourceRoles);
|
|
|
|
/**
|
|
* Middleware factory to check resource access for permission-related operations.
|
|
* SECURITY: Users must have SHARE permission to view or modify resource permissions.
|
|
* @param {string} requiredPermission - The permission bit required (e.g., SHARE)
|
|
* @returns Express middleware function
|
|
*/
|
|
const checkResourcePermissionAccess = (requiredPermission) =>
|
|
createAgentAdminPermissionAccess({
|
|
getAgent: db.getAgent,
|
|
fallback: (req, res, next) => {
|
|
const { resourceType } = req.params;
|
|
let middleware;
|
|
|
|
if (resourceType === ResourceType.AGENT) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.AGENT,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
});
|
|
} else if (resourceType === ResourceType.REMOTE_AGENT) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.REMOTE_AGENT,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
});
|
|
} else if (resourceType === ResourceType.PROMPTGROUP) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.PROMPTGROUP,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
});
|
|
} else if (resourceType === ResourceType.MCPSERVER) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.MCPSERVER,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
idResolver: findMCPServerByObjectId,
|
|
});
|
|
} else if (resourceType === ResourceType.SKILL) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.SKILL,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
idResolver: getSkillById,
|
|
});
|
|
} else if (resourceType === ResourceType.CODE_ENVIRONMENT) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.CODE_ENVIRONMENT,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
});
|
|
} else if (resourceType === ResourceType.SHARED_LINK) {
|
|
middleware = canAccessResource({
|
|
resourceType: ResourceType.SHARED_LINK,
|
|
requiredPermission,
|
|
resourceIdParam: 'resourceId',
|
|
});
|
|
} else {
|
|
return res.status(400).json({
|
|
error: 'Bad Request',
|
|
message: `Unsupported resource type: ${resourceType}`,
|
|
});
|
|
}
|
|
|
|
// Execute the middleware
|
|
middleware(req, res, next);
|
|
},
|
|
});
|
|
|
|
const checkShareAccessUnlessAgentAdmin = (req, res, next) => {
|
|
if (isAgentPermissionsAdmin(req)) {
|
|
return next();
|
|
}
|
|
return checkShareAccess(req, res, next);
|
|
};
|
|
|
|
const rejectSharedLinkOwnerPermissionChanges = async (req, res, next) => {
|
|
if (req.params.resourceType !== ResourceType.SHARED_LINK) {
|
|
return next();
|
|
}
|
|
|
|
const updated = Array.isArray(req.body?.updated) ? req.body.updated : [];
|
|
const removed = Array.isArray(req.body?.removed) ? req.body.removed : [];
|
|
const grantsOwner = updated.some(
|
|
(principal) => principal?.accessRoleId === AccessRoleIds.SHARED_LINK_OWNER,
|
|
);
|
|
const grantsPublicOwner = req.body?.publicAccessRoleId === AccessRoleIds.SHARED_LINK_OWNER;
|
|
|
|
if (grantsOwner || grantsPublicOwner) {
|
|
return res.status(400).json({
|
|
error: 'Bad Request',
|
|
message: 'Shared link owner permissions cannot be changed',
|
|
});
|
|
}
|
|
|
|
const userMutations = [...updated, ...removed].filter(
|
|
(principal) => principal?.type === PrincipalType.USER && principal?.id,
|
|
);
|
|
|
|
if (userMutations.length === 0) {
|
|
return next();
|
|
}
|
|
|
|
try {
|
|
const SharedLink = mongoose.models.SharedLink;
|
|
const link = await SharedLink.findById(req.params.resourceId, 'user').lean();
|
|
const ownerId = link?.user?.toString();
|
|
const touchesOwner = ownerId
|
|
? userMutations.some((principal) => principal.id?.toString() === ownerId)
|
|
: false;
|
|
|
|
if (touchesOwner) {
|
|
return res.status(400).json({
|
|
error: 'Bad Request',
|
|
message: 'Shared link owner permissions cannot be changed',
|
|
});
|
|
}
|
|
} catch (_error) {
|
|
return res.status(500).json({
|
|
error: 'Internal Server Error',
|
|
message: 'Failed to validate shared link owner permissions',
|
|
});
|
|
}
|
|
|
|
return next();
|
|
};
|
|
|
|
/**
|
|
* GET /api/permissions/{resourceType}/{resourceId}
|
|
* Get all permissions for a specific resource
|
|
* SECURITY: Requires SHARE permission to view resource permissions
|
|
*/
|
|
router.get(
|
|
'/:resourceType/:resourceId',
|
|
checkResourcePermissionAccess(PermissionBits.SHARE),
|
|
getResourcePermissions,
|
|
);
|
|
|
|
/**
|
|
* PUT /api/permissions/{resourceType}/{resourceId}
|
|
* Bulk update permissions for a specific resource
|
|
* SECURITY: Requires resource ACL SHARE and role SHARE to modify resource permissions
|
|
* SECURITY: Requires SHARE_PUBLIC permission to enable public sharing
|
|
*/
|
|
router.put(
|
|
'/:resourceType/:resourceId',
|
|
checkResourcePermissionAccess(PermissionBits.SHARE),
|
|
checkShareAccessUnlessAgentAdmin,
|
|
checkSharePublicAccess,
|
|
rejectSharedLinkOwnerPermissionChanges,
|
|
configMiddleware,
|
|
updateResourcePermissions,
|
|
);
|
|
|
|
/**
|
|
* GET /api/permissions/{resourceType}/effective/all
|
|
* Get user's effective permissions for all accessible resources of a type
|
|
*/
|
|
router.get('/:resourceType/effective/all', getAllEffectivePermissions);
|
|
|
|
/**
|
|
* GET /api/permissions/{resourceType}/{resourceId}/effective
|
|
* Get user's effective permissions for a specific resource
|
|
*/
|
|
router.get('/:resourceType/:resourceId/effective', getUserEffectivePermissions);
|
|
|
|
module.exports = router;
|