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
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
🔧 refactor: Change Permissions Check from `some` to `every` for Stricter Access Validation (#8270)
Danny Avila91a2df47599c
diff --git a/api/server/services/Endpoints/index.js b/api/server/services/Endpoints/index.jsindex 8171789418..71d04a1ae2 100644--- a/api/server/services/Endpoints/index.js+++ b/api/server/services/Endpoints/index.js@@ -13,7 +13,7 @@ const { getCustomEndpointConfig } = require('~/server/services/Config');*/function isKnownCustomProvider(provider) {return [Providers.XAI, Providers.OLLAMA, Providers.DEEPSEEK, Providers.OPENROUTER].includes(- provider || '',+ provider?.toLowerCase() || '',);}@@ -56,7 +56,7 @@ async function getProviderConfig(provider) {overrideProvider = Providers.OPENAI;}- if (isKnownCustomProvider(overrideProvider)) {+ if (isKnownCustomProvider(overrideProvider || provider) && !customEndpointConfig) {customEndpointConfig = await getCustomEndpointConfig(provider);if (!customEndpointConfig) {throw new Error(`Provider ${provider} not supported`);diff --git a/packages/api/src/middleware/access.spec.ts b/packages/api/src/middleware/access.spec.tsnew file mode 100644index 0000000000..7731957259--- /dev/null+++ b/packages/api/src/middleware/access.spec.ts@@ -0,0 +1,554 @@+import { Request, Response, NextFunction } from 'express';+import {+ Permissions,+ PermissionTypes,+ EModelEndpoint,+ EndpointURLs,+} from 'librechat-data-provider';+import type { IRole, IUser } from '@librechat/data-schemas';+import { checkAccess, generateCheckAccess, skipAgentCheck } from './access';++// Mock logger+jest.mock('@librechat/data-schemas', () => ({+ logger: {+ warn: jest.fn(),+ error: jest.fn(),+ debug: jest.fn(),+ },+}));++describe('access middleware', () => {+ let mockReq: Partial<Request>;+ let mockRes: Partial<Response>;+ let mockNext: jest.MockedFunction<NextFunction>;+ let mockGetRoleByName: jest.Mock;++ beforeEach(() => {+ mockReq = {+ user: {+ id: 'user123',+ role: 'user',+ email: '[email protected]',+ emailVerified: true,+ provider: 'local',+ } as IUser,+ body: {},+ originalUrl: '/api/test',+ method: 'POST',+ } as Partial<Request>;++ mockRes = {+ status: jest.fn().mockReturnThis(),+ json: jest.fn().mockReturnThis(),+ };++ mockNext = jest.fn() as jest.MockedFunction<NextFunction>;+ mockGetRoleByName = jest.fn();+ });++ afterEach(() => {+ jest.clearAllMocks();+ });++ describe('skipAgentCheck', () => {+ it('should return false when req is undefined', () => {+ expect(skipAgentCheck(undefined)).toBe(false);+ });++ it('should return false when req.body.endpoint is not present', () => {+ expect(skipAgentCheck(mockReq as Request)).toBe(false);+ });++ it('should return false when method is not POST', () => {+ mockReq.method = 'GET';+ mockReq.body = { endpoint: 'gpt-4' };+ expect(skipAgentCheck(mockReq as Request)).toBe(false);+ });++ it('should return false when URL does not include agents endpoint', () => {+ mockReq.body = { endpoint: 'gpt-4' };+ mockReq.originalUrl = '/api/messages';+ expect(skipAgentCheck(mockReq as Request)).toBe(false);+ });++ it('should return true when not an agents endpoint but URL includes agents', () => {+ mockReq.body = { endpoint: 'gpt-4' };+ mockReq.originalUrl = EndpointURLs[EModelEndpoint.agents];+ expect(skipAgentCheck(mockReq as Request)).toBe(true);+ });++ it('should return false when is an agents endpoint', () => {+ mockReq.body = { endpoint: EModelEndpoint.agents };+ mockReq.originalUrl = EndpointURLs[EModelEndpoint.agents];+ expect(skipAgentCheck(mockReq as Request)).toBe(false);+ });+ });++ describe('checkAccess', () => {+ const defaultParams = {+ user: {+ id: 'user123',+ role: 'user',+ email: '[email protected]',+ emailVerified: true,+ provider: 'local',+ } as IUser,+ permissionType: PermissionTypes.AGENTS,+ permissions: [Permissions.USE],+ getRoleByName: jest.fn(),+ };++ it('should return true when skipCheck function returns true', async () => {+ const skipCheck = jest.fn().mockReturnValue(true);+ const result = await checkAccess({+ ...defaultParams,+ req: mockReq as Request,+ skipCheck,+ });+ expect(result).toBe(true);+ expect(skipCheck).toHaveBeenCalledWith(mockReq);+ });++ it('should return false when user is not provided', async () => {+ const result = await checkAccess({+ ...defaultParams,+ user: null as unknown as IUser,+ });+ expect(result).toBe(false);+ });++ it('should return false when user has no role', async () => {+ const result = await checkAccess({+ ...defaultParams,+ user: {+ id: 'user123',+ email: '[email protected]',+ emailVerified: true,+ provider: 'local',+ } as IUser,+ });+ expect(result).toBe(false);+ });++ it('should return true when user has required permissions', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: true,+ },+ },+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const result = await checkAccess(defaultParams);+ expect(result).toBe(true);+ expect(defaultParams.getRoleByName).toHaveBeenCalledWith('user');+ });++ it('should return false when user lacks required permissions', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: false,+ },+ },+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const result = await checkAccess(defaultParams);+ expect(result).toBe(false);+ });++ it('should check multiple permissions with AND logic', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: true,+ [Permissions.CREATE]: true,+ },+ },+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const result = await checkAccess({+ ...defaultParams,+ permissions: [Permissions.USE, Permissions.CREATE],+ });+ expect(result).toBe(true);+ });++ it('should return false when user has only some of the required permissions', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: true,+ [Permissions.CREATE]: false,+ },+ },+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const result = await checkAccess({+ ...defaultParams,+ permissions: [Permissions.USE, Permissions.CREATE],+ });+ expect(result).toBe(false);+ });++ it('should check bodyProps when permission is not directly granted', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: true,+ [Permissions.SHARED_GLOBAL]: false,+ },+ },+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const checkObject = {+ projectIds: ['project1'],+ removeProjectIds: ['project2'],+ };++ const result = await checkAccess({+ ...defaultParams,+ permissions: [Permissions.USE, Permissions.SHARED_GLOBAL],+ bodyProps: {+ [Permissions.SHARED_GLOBAL]: ['projectIds', 'removeProjectIds'],+ } as Record<Permissions, string[]>,+ checkObject,+ });+ expect(result).toBe(true);+ });++ it('should return false when bodyProps requirements are not met', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.SHARED_GLOBAL]: false,+ },+ },+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const checkObject = {+ projectIds: ['project1'],+ // missing removeProjectIds+ };++ const result = await checkAccess({+ ...defaultParams,+ permissions: [Permissions.SHARED_GLOBAL],+ bodyProps: {+ [Permissions.SHARED_GLOBAL]: ['projectIds', 'removeProjectIds'],+ } as Record<Permissions, string[]>,+ checkObject,+ });+ expect(result).toBe(false);+ });++ it('should handle role without permissions object', async () => {+ const mockRole = {+ name: 'user',+ } as unknown as IRole;++ defaultParams.getRoleByName.mockResolvedValue(mockRole);++ const result = await checkAccess(defaultParams);+ expect(result).toBe(false);+ });++ it('should handle getRoleByName returning null', async () => {+ defaultParams.getRoleByName.mockResolvedValue(null);++ const result = await checkAccess(defaultParams);+ expect(result).toBe(false);+ });+ });++ describe('generateCheckAccess', () => {+ it('should create middleware that allows access when user has permissions', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.MEMORIES]: {+ [Permissions.USE]: true,+ [Permissions.READ]: true,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);++ const middleware = generateCheckAccess({+ permissionType: PermissionTypes.MEMORIES,+ permissions: [Permissions.USE, Permissions.READ],+ getRoleByName: mockGetRoleByName,+ });++ await middleware(mockReq as Request, mockRes as Response, mockNext);++ expect(mockNext).toHaveBeenCalled();+ expect(mockRes.status).not.toHaveBeenCalled();+ });++ it('should create middleware that denies access when user lacks permissions', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.MEMORIES]: {+ [Permissions.USE]: false,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);++ const middleware = generateCheckAccess({+ permissionType: PermissionTypes.MEMORIES,+ permissions: [Permissions.USE],+ getRoleByName: mockGetRoleByName,+ });++ await middleware(mockReq as Request, mockRes as Response, mockNext);++ expect(mockNext).not.toHaveBeenCalled();+ expect(mockRes.status).toHaveBeenCalledWith(403);+ expect(mockRes.json).toHaveBeenCalledWith({ message: 'Forbidden: Insufficient permissions' });+ });++ it('should handle bodyProps in middleware', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: true,+ [Permissions.CREATE]: true,+ [Permissions.SHARED_GLOBAL]: false,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);+ mockReq.body = {+ projectIds: ['project1'],+ removeProjectIds: ['project2'],+ };++ const middleware = generateCheckAccess({+ permissionType: PermissionTypes.AGENTS,+ permissions: [Permissions.USE, Permissions.CREATE, Permissions.SHARED_GLOBAL],+ bodyProps: {+ [Permissions.SHARED_GLOBAL]: ['projectIds', 'removeProjectIds'],+ } as Record<Permissions, string[]>,+ getRoleByName: mockGetRoleByName,+ });++ await middleware(mockReq as Request, mockRes as Response, mockNext);++ expect(mockNext).toHaveBeenCalled();+ expect(mockRes.status).not.toHaveBeenCalled();+ });++ it('should use skipCheck function when provided', async () => {+ const skipCheck = jest.fn().mockReturnValue(true);++ const middleware = generateCheckAccess({+ permissionType: PermissionTypes.AGENTS,+ permissions: [Permissions.USE],+ skipCheck,+ getRoleByName: mockGetRoleByName,+ });++ await middleware(mockReq as Request, mockRes as Response, mockNext);++ expect(skipCheck).toHaveBeenCalledWith(mockReq);+ expect(mockNext).toHaveBeenCalled();+ expect(mockGetRoleByName).not.toHaveBeenCalled();+ });++ it('should handle errors and return 500 status', async () => {+ const error = new Error('Database error');+ mockGetRoleByName.mockRejectedValue(error);++ const middleware = generateCheckAccess({+ permissionType: PermissionTypes.AGENTS,+ permissions: [Permissions.USE],+ getRoleByName: mockGetRoleByName,+ });++ await middleware(mockReq as Request, mockRes as Response, mockNext);++ expect(mockRes.status).toHaveBeenCalledWith(500);+ expect(mockRes.json).toHaveBeenCalledWith({+ message: 'Server error: Database error',+ });+ });++ it('should handle non-Error objects in catch block', async () => {+ mockGetRoleByName.mockRejectedValue('String error');++ const middleware = generateCheckAccess({+ permissionType: PermissionTypes.AGENTS,+ permissions: [Permissions.USE],+ getRoleByName: mockGetRoleByName,+ });++ await middleware(mockReq as Request, mockRes as Response, mockNext);++ expect(mockRes.status).toHaveBeenCalledWith(500);+ expect(mockRes.json).toHaveBeenCalledWith({+ message: 'Server error: Unknown error',+ });+ });+ });++ describe('Real-world usage patterns', () => {+ it('should handle memory access patterns', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.MEMORIES]: {+ [Permissions.USE]: true,+ [Permissions.CREATE]: true,+ [Permissions.UPDATE]: true,+ [Permissions.READ]: true,+ [Permissions.OPT_OUT]: true,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);++ // Test memory read access+ const checkMemoryRead = generateCheckAccess({+ permissionType: PermissionTypes.MEMORIES,+ permissions: [Permissions.USE, Permissions.READ],+ getRoleByName: mockGetRoleByName,+ });++ await checkMemoryRead(mockReq as Request, mockRes as Response, mockNext);+ expect(mockNext).toHaveBeenCalled();++ // Test memory create access+ mockNext.mockClear();+ const checkMemoryCreate = generateCheckAccess({+ permissionType: PermissionTypes.MEMORIES,+ permissions: [Permissions.USE, Permissions.CREATE],+ getRoleByName: mockGetRoleByName,+ });++ await checkMemoryCreate(mockReq as Request, mockRes as Response, mockNext);+ expect(mockNext).toHaveBeenCalled();+ });++ it('should handle agent access patterns with skipCheck', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.AGENTS]: {+ [Permissions.USE]: true,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);+ mockReq.body = { endpoint: 'gpt-4' };+ mockReq.originalUrl = EndpointURLs[EModelEndpoint.agents];++ const checkAgentAccess = generateCheckAccess({+ permissionType: PermissionTypes.AGENTS,+ permissions: [Permissions.USE],+ skipCheck: skipAgentCheck,+ getRoleByName: mockGetRoleByName,+ });++ await checkAgentAccess(mockReq as Request, mockRes as Response, mockNext);++ // Should skip check because endpoint is not agents+ expect(mockNext).toHaveBeenCalled();+ expect(mockGetRoleByName).not.toHaveBeenCalled();+ });++ it('should handle prompt access patterns', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.PROMPTS]: {+ [Permissions.USE]: true,+ [Permissions.CREATE]: true,+ [Permissions.SHARED_GLOBAL]: false,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);++ const checkPromptAccess = generateCheckAccess({+ permissionType: PermissionTypes.PROMPTS,+ permissions: [Permissions.USE],+ getRoleByName: mockGetRoleByName,+ });++ await checkPromptAccess(mockReq as Request, mockRes as Response, mockNext);+ expect(mockNext).toHaveBeenCalled();+ });++ it('should handle bookmark access patterns', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.BOOKMARKS]: {+ [Permissions.USE]: true,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);++ const checkBookmarkAccess = generateCheckAccess({+ permissionType: PermissionTypes.BOOKMARKS,+ permissions: [Permissions.USE],+ getRoleByName: mockGetRoleByName,+ });++ await checkBookmarkAccess(mockReq as Request, mockRes as Response, mockNext);+ expect(mockNext).toHaveBeenCalled();+ });++ it('should handle tool access patterns', async () => {+ const mockRole = {+ name: 'user',+ permissions: {+ [PermissionTypes.RUN_CODE]: {+ [Permissions.USE]: true,+ },+ },+ } as unknown as IRole;++ mockGetRoleByName.mockResolvedValue(mockRole);++ const result = await checkAccess({+ user: mockReq.user as IUser,+ permissionType: PermissionTypes.RUN_CODE,+ permissions: [Permissions.USE],+ getRoleByName: mockGetRoleByName,+ });++ expect(result).toBe(true);+ });+ });+});diff --git a/packages/api/src/middleware/access.ts b/packages/api/src/middleware/access.tsindex d88ade1e56..7853e71c72 100644--- a/packages/api/src/middleware/access.ts+++ b/packages/api/src/middleware/access.ts@@ -64,7 +64,7 @@ export const checkAccess = async ({const role = await getRoleByName(user.role);if (role && role.permissions && role.permissions[permissionType]) {- const hasAnyPermission = permissions.some((permission) => {+ const hasAnyPermission = permissions.every((permission) => {if (role.permissions?.[permissionType as keyof typeof role.permissions]?.[permission as keyof (typeof role.permissions)[typeof permissionType]@@ -74,7 +74,7 @@ export const checkAccess = async ({}if (bodyProps[permission] && checkObject) {- return bodyProps[permission].some((prop) =>+ return bodyProps[permission].every((prop) =>Object.prototype.hasOwnProperty.call(checkObject, prop),);}