Skip to content

Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active

🔒 fix: Access Control on Agent Permission Queries (#11145)

Danny Avila06ba025bd955
diff --git a/api/server/routes/accessPermissions.js b/api/server/routes/accessPermissions.js
index 7431a86f1e..3e70f2610f 100644
--- a/api/server/routes/accessPermissions.js
+++ b/api/server/routes/accessPermissions.js
@@ -36,52 +36,65 @@ router.get('/search-principals', checkPeoplePickerAccess, searchPrincipals);
*/
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) => (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.PROMPTGROUP) {
+ middleware = canAccessResource({
+ resourceType: ResourceType.PROMPTGROUP,
+ requiredPermission,
+ resourceIdParam: 'resourceId',
+ });
+ } else if (resourceType === ResourceType.MCPSERVER) {
+ middleware = canAccessResource({
+ resourceType: ResourceType.MCPSERVER,
+ requiredPermission,
+ resourceIdParam: 'resourceId',
+ idResolver: findMCPServerById,
+ });
+ } else {
+ return res.status(400).json({
+ error: 'Bad Request',
+ message: `Unsupported resource type: ${resourceType}`,
+ });
+ }
+
+ // Execute the middleware
+ middleware(req, res, 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', getResourcePermissions);
+router.get(
+ '/:resourceType/:resourceId',
+ checkResourcePermissionAccess(PermissionBits.SHARE),
+ getResourcePermissions,
+);
/**
* PUT /api/permissions/{resourceType}/{resourceId}
* Bulk update permissions for a specific resource
+ * SECURITY: Requires SHARE permission to modify resource permissions
*/
router.put(
'/:resourceType/:resourceId',
- // Use middleware that dynamically handles resource type and permissions
- (req, res, next) => {
- const { resourceType } = req.params;
- let middleware;
-
- if (resourceType === ResourceType.AGENT) {
- middleware = canAccessResource({
- resourceType: ResourceType.AGENT,
- requiredPermission: PermissionBits.SHARE,
- resourceIdParam: 'resourceId',
- });
- } else if (resourceType === ResourceType.PROMPTGROUP) {
- middleware = canAccessResource({
- resourceType: ResourceType.PROMPTGROUP,
- requiredPermission: PermissionBits.SHARE,
- resourceIdParam: 'resourceId',
- });
- } else if (resourceType === ResourceType.MCPSERVER) {
- middleware = canAccessResource({
- resourceType: ResourceType.MCPSERVER,
- requiredPermission: PermissionBits.SHARE,
- resourceIdParam: 'resourceId',
- idResolver: findMCPServerById,
- });
- } else {
- return res.status(400).json({
- error: 'Bad Request',
- message: `Unsupported resource type: ${resourceType}`,
- });
- }
-
- // Execute the middleware
- middleware(req, res, next);
- },
+ checkResourcePermissionAccess(PermissionBits.SHARE),
updateResourcePermissions,
);
diff --git a/api/server/routes/accessPermissions.test.js b/api/server/routes/accessPermissions.test.js
new file mode 100644
index 0000000000..c7e7b5957c
--- /dev/null
+++ b/api/server/routes/accessPermissions.test.js
@@ -0,0 +1,228 @@
+const express = require('express');
+const request = require('supertest');
+const mongoose = require('mongoose');
+const { v4: uuidv4 } = require('uuid');
+const { createMethods } = require('@librechat/data-schemas');
+const { MongoMemoryServer } = require('mongodb-memory-server');
+const { ResourceType, PermissionBits } = require('librechat-data-provider');
+const { createAgent } = require('~/models/Agent');
+
+/**
+ * Mock the PermissionsController to isolate route testing
+ */
+jest.mock('~/server/controllers/PermissionsController', () => ({
+ getUserEffectivePermissions: jest.fn((req, res) => res.json({ permissions: [] })),
+ getAllEffectivePermissions: jest.fn((req, res) => res.json({ permissions: [] })),
+ updateResourcePermissions: jest.fn((req, res) => res.json({ success: true })),
+ getResourcePermissions: jest.fn((req, res) =>
+ res.json({
+ resourceType: req.params.resourceType,
+ resourceId: req.params.resourceId,
+ principals: [],
+ public: false,
+ }),
+ ),
+ getResourceRoles: jest.fn((req, res) => res.json({ roles: [] })),
+ searchPrincipals: jest.fn((req, res) => res.json({ principals: [] })),
+}));
+
+jest.mock('~/server/middleware/checkPeoplePickerAccess', () => ({
+ checkPeoplePickerAccess: jest.fn((req, res, next) => next()),
+}));
+
+// Import actual middleware to get canAccessResource
+const { canAccessResource } = require('~/server/middleware');
+const { findMCPServerById } = require('~/models');
+
+/**
+ * Security Tests for SBA-ADV-20251203-02
+ *
+ * These tests verify that users cannot query or modify agent permissions
+ * without proper SHARE permission.
+ */
+describe('Access Permissions Routes - Security Tests (SBA-ADV-20251203-02)', () => {
+ let app;
+ let mongoServer;
+ let authorId;
+ let attackerId;
+ let agentId;
+ let methods;
+ let User;
+ let modelsToCleanup = [];
+
+ beforeAll(async () => {
+ mongoServer = await MongoMemoryServer.create();
+ const mongoUri = mongoServer.getUri();
+ await mongoose.connect(mongoUri);
+
+ // Initialize models
+ const { createModels } = require('@librechat/data-schemas');
+ const models = createModels(mongoose);
+ modelsToCleanup = Object.keys(models);
+ Object.assign(mongoose.models, models);
+
+ methods = createMethods(mongoose);
+ User = models.User;
+
+ await methods.seedDefaultRoles();
+ });
+
+ afterAll(async () => {
+ const collections = mongoose.connection.collections;
+ for (const key in collections) {
+ await collections[key].deleteMany({});
+ }
+ for (const modelName of modelsToCleanup) {
+ delete mongoose.models[modelName];
+ }
+ await mongoose.disconnect();
+ await mongoServer.stop();
+ });
+
+ beforeEach(async () => {
+ // Clear all collections
+ const collections = mongoose.connection.collections;
+ for (const key in collections) {
+ await collections[key].deleteMany({});
+ }
+ await methods.seedDefaultRoles();
+
+ // Create author (owner of the agent)
+ authorId = new mongoose.Types.ObjectId().toString();
+ await User.create({
+ _id: authorId,
+ name: 'Agent Owner',
+ email: '[email protected]',
+ username: '[email protected]',
+ provider: 'local',
+ });
+
+ // Create attacker (should not have access)
+ attackerId = new mongoose.Types.ObjectId().toString();
+ await User.create({
+ _id: attackerId,
+ name: 'Attacker',
+ email: '[email protected]',
+ username: '[email protected]',
+ provider: 'local',
+ });
+
+ // Create private agent owned by author
+ const customAgentId = `agent_${uuidv4().replace(/-/g, '').substring(0, 20)}`;
+ await createAgent({
+ id: customAgentId,
+ name: 'Private Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ author: authorId,
+ });
+ agentId = customAgentId;
+
+ // Create Express app with attacker as current user
+ app = express();
+ app.use(express.json());
+
+ // Mock authentication middleware - attacker is the current user
+ app.use((req, res, next) => {
+ req.user = { id: attackerId, role: 'USER' };
+ req.app = { locals: {} };
+ next();
+ });
+
+ // Middleware factory for permission access check (mirrors actual implementation)
+ const checkResourcePermissionAccess = (requiredPermission) => (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.PROMPTGROUP) {
+ middleware = canAccessResource({
+ resourceType: ResourceType.PROMPTGROUP,
+ requiredPermission,
+ resourceIdParam: 'resourceId',
+ });
+ } else if (resourceType === ResourceType.MCPSERVER) {
+ middleware = canAccessResource({
+ resourceType: ResourceType.MCPSERVER,
+ requiredPermission,
+ resourceIdParam: 'resourceId',
+ idResolver: findMCPServerById,
+ });
+ } else {
+ return res.status(400).json({
+ error: 'Bad Request',
+ message: `Unsupported resource type: ${resourceType}`,
+ });
+ }
+
+ middleware(req, res, next);
+ };
+
+ // GET route with access control (THE FIX)
+ app.get(
+ '/permissions/:resourceType/:resourceId',
+ checkResourcePermissionAccess(PermissionBits.SHARE),
+ (req, res) =>
+ res.json({
+ resourceType: req.params.resourceType,
+ resourceId: req.params.resourceId,
+ principals: [],
+ public: false,
+ }),
+ );
+
+ // PUT route with access control
+ app.put(
+ '/permissions/:resourceType/:resourceId',
+ checkResourcePermissionAccess(PermissionBits.SHARE),
+ (req, res) => res.json({ success: true }),
+ );
+ });
+
+ describe('GET /permissions/:resourceType/:resourceId', () => {
+ it('should deny permission query for user without access (main vulnerability test)', async () => {
+ /**
+ * SECURITY TEST: This is the core test for SBA-ADV-20251203-02
+ *
+ * Before the fix, any authenticated user could query permissions for
+ * any agent by just knowing the agent ID, exposing information about
+ * who has access to private agents.
+ *
+ * After the fix, users must have SHARE permission to view permissions.
+ */
+ const response = await request(app)
+ .get(`/permissions/agent/${agentId}`)
+ .set('Content-Type', 'application/json');
+
+ // Should be denied - attacker has no permission on the agent
+ expect(response.status).toBe(403);
+ expect(response.body.error).toBe('Forbidden');
+ });
+
+ it('should return 400 for unsupported resource type', async () => {
+ const response = await request(app)
+ .get(`/permissions/unsupported/${agentId}`)
+ .set('Content-Type', 'application/json');
+
+ expect(response.status).toBe(400);
+ expect(response.body.message).toContain('Unsupported resource type');
+ });
+ });
+
+ describe('PUT /permissions/:resourceType/:resourceId', () => {
+ it('should deny permission update for user without access', async () => {
+ const response = await request(app)
+ .put(`/permissions/agent/${agentId}`)
+ .set('Content-Type', 'application/json')
+ .send({ principals: [] });
+
+ expect(response.status).toBe(403);
+ expect(response.body.error).toBe('Forbidden');
+ });
+ });
+});