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: Harden Agent File Preview Access (#12981)

Danny Avila5c338a4642c2
diff --git a/api/server/controllers/agents/v1.js b/api/server/controllers/agents/v1.js
index 4f04a00be7..012eab36c0 100644
--- a/api/server/controllers/agents/v1.js
+++ b/api/server/controllers/agents/v1.js
@@ -220,6 +220,49 @@ const filterAuthorizedTools = async ({
return filteredTools;
};
+/**
+ * Removes file IDs from tool resources unless the referenced file is owned by
+ * the agent owner.
+ * @param {object} params
+ * @param {object} params.tool_resources
+ * @param {string | object} params.ownerId
+ * @param {string} params.logPrefix
+ * @returns {Promise<number>} Count of removed file references.
+ */
+const pruneToolResourceFileIdsForOwner = async ({ tool_resources, ownerId, logPrefix }) => {
+ const referencedFileIds = collectToolResourceFileIds(tool_resources);
+ if (referencedFileIds.length === 0) {
+ return 0;
+ }
+ if (!ownerId) {
+ return stripFileIdsFromToolResources(tool_resources, referencedFileIds).removedCount;
+ }
+ const ownerIdStr = ownerId.toString();
+
+ try {
+ const ownerFiles = await db.getFiles({ file_id: { $in: referencedFileIds } }, null, {
+ file_id: 1,
+ user: 1,
+ });
+ const allowedIds = new Set(
+ (ownerFiles ?? [])
+ .filter((file) => file.user && file.user.toString() === ownerIdStr)
+ .map((file) => file.file_id),
+ );
+ const disallowedIds = referencedFileIds.filter((id) => !allowedIds.has(id));
+ if (disallowedIds.length > 0) {
+ logger.warn(`${logPrefix} Pruning ${disallowedIds.length} invalid file reference(s)`);
+ return stripFileIdsFromToolResources(tool_resources, disallowedIds).removedCount;
+ }
+ return 0;
+ } catch (fileCheckError) {
+ logger.warn(`${logPrefix} File ownership check failed, pruning incoming file references`, {
+ error: fileCheckError?.message,
+ });
+ return stripFileIdsFromToolResources(tool_resources, referencedFileIds).removedCount;
+ }
+};
+
/**
* Creates an Agent.
* @route POST /Agents
@@ -239,6 +282,14 @@ const createAgentHandler = async (req, res) => {
const { id: userId, role: userRole } = req.user;
+ if (agentData.tool_resources) {
+ await pruneToolResourceFileIdsForOwner({
+ tool_resources: agentData.tool_resources,
+ ownerId: userId,
+ logPrefix: '[/Agents]',
+ });
+ }
+
if (agentData.edges?.length) {
const unauthorized = await validateEdgeAgentAccess(agentData.edges, userId, userRole);
if (unauthorized.length > 0) {
@@ -509,36 +560,12 @@ const updateAgentHandler = async (req, res) => {
updateData.tools = ocrConversion.tools;
}
- /*
- * Strip orphaned file_id stubs from the incoming payload (see issue #12776).
- * Scoped to updates that actually touch tool_resources: if the save does not
- * modify that field, the delete-time cleanup in processDeleteRequest and the
- * one-off migration already cover pre-existing corruption, so there's no
- * reason to pay an extra DB round-trip here. Wrapped in try/catch so a
- * transient failure in this integrity check never turns a good save into 500.
- */
if (updateData.tool_resources) {
- try {
- const referencedFileIds = collectToolResourceFileIds(updateData.tool_resources);
- if (referencedFileIds.length > 0) {
- const existingFiles = await db.getFiles({ file_id: { $in: referencedFileIds } }, null, {
- file_id: 1,
- });
- const existingIds = new Set((existingFiles ?? []).map((f) => f.file_id));
- const orphans = referencedFileIds.filter((id) => !existingIds.has(id));
- if (orphans.length > 0) {
- logger.warn(
- `[/Agents/:id] Pruning ${orphans.length} orphaned file reference(s) from agent ${id}`,
- );
- stripFileIdsFromToolResources(updateData.tool_resources, orphans);
- }
- }
- } catch (orphanCheckError) {
- logger.warn(
- '[/Agents/:id] Orphan file check failed, skipping cleanup for this request',
- orphanCheckError,
- );
- }
+ await pruneToolResourceFileIdsForOwner({
+ tool_resources: updateData.tool_resources,
+ ownerId: existingAgent.author,
+ logPrefix: `[/Agents/:id] Agent ${id}`,
+ });
}
if (updateData.tools) {
@@ -722,6 +749,14 @@ const duplicateAgentHandler = async (req, res) => {
});
}
+ if (newAgentData.tool_resources) {
+ await pruneToolResourceFileIdsForOwner({
+ tool_resources: newAgentData.tool_resources,
+ ownerId: userId,
+ logPrefix: '[/Agents/:id/duplicate]',
+ });
+ }
+
const newAgent = await db.createAgent(newAgentData);
try {
@@ -1056,6 +1091,7 @@ const revertAgentVersionHandler = async (req, res) => {
// Permissions are enforced via route middleware (ACL EDIT)
let updatedAgent = await db.revertAgentVersion({ id }, version_index);
+ const revertUpdates = {};
if (updatedAgent.tools?.length) {
const [availableTools, configServers] = await Promise.all([
@@ -1070,14 +1106,25 @@ const revertAgentVersionHandler = async (req, res) => {
configServers,
});
if (filteredTools.length !== updatedAgent.tools.length) {
- updatedAgent = await db.updateAgent(
- { id },
- { tools: filteredTools },
- { updatingUserId: req.user.id },
- );
+ revertUpdates.tools = filteredTools;
+ }
+ }
+
+ if (updatedAgent.tool_resources) {
+ const removedCount = await pruneToolResourceFileIdsForOwner({
+ tool_resources: updatedAgent.tool_resources,
+ ownerId: existingAgent.author,
+ logPrefix: '[/Agents/:id/revert]',
+ });
+ if (removedCount > 0) {
+ revertUpdates.tool_resources = updatedAgent.tool_resources;
}
}
+ if (Object.keys(revertUpdates).length > 0) {
+ updatedAgent = await db.updateAgent({ id }, revertUpdates, { updatingUserId: req.user.id });
+ }
+
if (updatedAgent.author) {
updatedAgent.author = updatedAgent.author.toString();
}
diff --git a/api/server/controllers/agents/v1.spec.js b/api/server/controllers/agents/v1.spec.js
index d191822add..81f72264bd 100644
--- a/api/server/controllers/agents/v1.spec.js
+++ b/api/server/controllers/agents/v1.spec.js
@@ -72,6 +72,8 @@ jest.mock('~/cache', () => ({
const {
createAgent: createAgentHandler,
+ duplicateAgent: duplicateAgentHandler,
+ revertAgentVersion: revertAgentVersionHandler,
updateAgent: updateAgentHandler,
getListAgents: getListAgentsHandler,
} = require('./v1');
@@ -111,6 +113,7 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
beforeEach(async () => {
await Agent.deleteMany({});
+ await mongoose.models.File.deleteMany({});
// Reset all mocks
jest.clearAllMocks();
@@ -278,6 +281,48 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
expect(agentInDb.tool_resources.invalid_resource).toBeUndefined();
});
+ test('should strip file_ids not owned by the creator from tool_resources', async () => {
+ const File = mongoose.models.File;
+
+ const ownedFileId = `file_${uuidv4()}`;
+ const otherFileId = `file_${uuidv4()}`;
+ await File.create({
+ file_id: ownedFileId,
+ user: mockReq.user.id,
+ filename: `${ownedFileId}.txt`,
+ filepath: `/tmp/${ownedFileId}`,
+ object: 'file',
+ type: 'text/plain',
+ bytes: 1,
+ source: FileSources.local,
+ });
+ await File.create({
+ file_id: otherFileId,
+ user: new mongoose.Types.ObjectId(),
+ filename: `${otherFileId}.txt`,
+ filepath: `/tmp/${otherFileId}`,
+ object: 'file',
+ type: 'text/plain',
+ bytes: 1,
+ source: FileSources.local,
+ });
+
+ mockReq.body = {
+ provider: 'openai',
+ model: 'gpt-4',
+ name: 'Agent with Files',
+ tool_resources: {
+ file_search: { file_ids: [ownedFileId, otherFileId] },
+ },
+ };
+
+ await createAgentHandler(mockReq, mockRes);
+
+ expect(mockRes.status).toHaveBeenCalledWith(201);
+ const createdAgent = mockRes.json.mock.calls[0][0];
+ expect(createdAgent.tool_resources.file_search.file_ids).toEqual([ownedFileId]);
+ });
+
test('should handle support_contact with empty strings', async () => {
const dataWithEmptyContact = {
provider: 'openai',
@@ -544,6 +589,48 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
expect(updatedAgent.name).toBe('Admin Update');
});
+ test('should prune admin-supplied file_ids against the agent author', async () => {
+ const File = mongoose.models.File;
+ const adminUserId = new mongoose.Types.ObjectId().toString();
+ const authorFileId = `file_${uuidv4()}`;
+ const adminFileId = `file_${uuidv4()}`;
+
+ await File.create({
+ file_id: authorFileId,
+ user: existingAgentAuthorId,
+ filename: `${authorFileId}.txt`,
+ filepath: `/tmp/${authorFileId}`,
+ object: 'file',
+ type: 'text/plain',
+ bytes: 1,
+ source: FileSources.local,
+ });
+ await File.create({
+ file_id: adminFileId,
+ user: adminUserId,
+ filename: `${adminFileId}.txt`,
+ filepath: `/tmp/${adminFileId}`,
+ object: 'file',
+ type: 'text/plain',
+ bytes: 1,
+ source: FileSources.local,
+ });
+
+ mockReq.user.id = adminUserId;
+ mockReq.user.role = 'ADMIN';
+ mockReq.params.id = existingAgentId;
+ mockReq.body = {
+ tool_resources: {
+ file_search: { file_ids: [authorFileId, adminFileId] },
+ },
+ };
+
+ await updateAgentHandler(mockReq, mockRes);
+
+ const agentInDb = await Agent.findOne({ id: existingAgentId }).lean();
+ expect(agentInDb.tool_resources.file_search.file_ids).toEqual([authorFileId]);
+ });
+
test('should validate tool_resources in updates', async () => {
// Back these ids with real File docs so the orphan-pruning added for
// issue #12776 does not strip them — this test is about OCR conversion
@@ -808,10 +895,9 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
expect(agentInDb.tool_resources.file_search.file_ids).toEqual([orphan]);
});
- test('swallows errors from the file-existence check and still completes the save', async () => {
+ test('prunes incoming file_ids when the file ownership check fails', async () => {
const db = require('~/models');
- const originalGetFiles = db.getFiles;
- db.getFiles = jest.fn().mockRejectedValue(new Error('transient DB error'));
+ jest.spyOn(db, 'getFiles').mockRejectedValueOnce(new Error('transient DB error'));
const orphan = `file_${uuidv4()}`;
mockReq.user.id = existingAgentAuthorId.toString();
@@ -821,23 +907,122 @@ describe('Agent Controllers - Mass Assignment Protection', () => {
tool_resources: { file_search: { file_ids: [orphan] } },
};
- try {
- await updateAgentHandler(mockReq, mockRes);
-
- expect(mockRes.status).not.toHaveBeenCalledWith(500);
- expect(mockRes.json).toHaveBeenCalled();
- const agentInDb = await Agent.findOne({ id: existingAgentId }).lean();
- expect(agentInDb.name).toBe('Save Succeeds');
- // Cleanup skipped on error, so the id remains — the delete-time path
- // or the next successful save will reconcile it.
- expect(agentInDb.tool_resources.file_search.file_ids).toEqual([orphan]);
- } finally {
- db.getFiles = originalGetFiles;
- }
+ await updateAgentHandler(mockReq, mockRes);
+
+ expect(mockRes.status).not.toHaveBeenCalledWith(500);
+ expect(mockRes.json).toHaveBeenCalled();
+ const agentInDb = await Agent.findOne({ id: existingAgentId }).lean();
+ expect(agentInDb.name).toBe('Save Succeeds');
+ expect(agentInDb.tool_resources.file_search.file_ids).toEqual([]);
+ });
+
+ test('strips file_ids owned by another user from incoming tool_resources', async () => {
+ const keeper = `file_${uuidv4()}`;
+ const otherUsersFile = `file_${uuidv4()}`;
+ await createFileDoc(keeper, existingAgentAuthorId);
+ await createFileDoc(otherUsersFile, new mongoose.Types.ObjectId());
+
+ mockReq.user.id = existingAgentAuthorId.toString();
+ mockReq.params.id = existingAgentId;
+ mockReq.body = {
+ tool_resources: {
+ file_search: { file_ids: [keeper, otherUsersFile] },
+ },
+ };
+
+ await updateAgentHandler(mockReq, mockRes);
+
+ const agentInDb = await Agent.findOne({ id: existingAgentId }).lean();
+ expect(agentInDb.tool_resources.file_search.file_ids).toEqual([keeper]);
});
});
});
+ describe('tool_resources ownership pruning in alternate write paths', () => {
+ const createFileDoc = (file_id, userId) =>
+ mongoose.models.File.create({
+ file_id,
+ user: userId,
+ filename: `${file_id}.txt`,
+ filepath: `/tmp/${file_id}`,
+ object: 'file',
+ type: 'text/plain',
+ bytes: 1,
+ source: FileSources.local,
+ });
+
+ test('duplicateAgentHandler should prune file_ids not owned by the clone author', async () => {
+ const sourceAuthorId = new mongoose.Types.ObjectId();
+ const cloneAuthorId = new mongoose.Types.ObjectId();
+ const sourceFileId = `file_${uuidv4()}`;
+ const cloneAuthorFileId = `file_${uuidv4()}`;
+
+ await createFileDoc(sourceFileId, sourceAuthorId);
+ await createFileDoc(cloneAuthorFileId, cloneAuthorId);
+ const sourceAgent = await Agent.create({
+ id: `agent_${uuidv4()}`,
+ name: 'Source Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ author: sourceAuthorId,
+ tool_resources: {
+ context: { file_ids: [sourceFileId, cloneAuthorFileId] },
+ },
+ });
+
+ const db = require('~/models');
+ jest.spyOn(db, 'getActions').mockResolvedValueOnce([]);
+
+ mockReq.user.id = cloneAuthorId.toString();
+ mockReq.params.id = sourceAgent.id;
+
+ await duplicateAgentHandler(mockReq, mockRes);
+
+ expect(mockRes.status).toHaveBeenCalledWith(201);
+ const { agent } = mockRes.json.mock.calls[0][0];
+ expect(agent.author.toString()).toBe(cloneAuthorId.toString());
+ expect(agent.tool_resources.context.file_ids).toEqual([cloneAuthorFileId]);
+ });
+
+ test('revertAgentVersionHandler should prune restored file_ids not owned by the agent author', async () => {
+ const agentAuthorId = new mongoose.Types.ObjectId();
+ const otherUserId = new mongoose.Types.ObjectId();
+ const ownedFileId = `file_${uuidv4()}`;
+ const otherFileId = `file_${uuidv4()}`;
+
+ await createFileDoc(ownedFileId, agentAuthorId);
+ await createFileDoc(otherFileId, otherUserId);
+ const agent = await Agent.create({
+ id: `agent_${uuidv4()}`,
+ name: 'Current Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ author: agentAuthorId,
+ tool_resources: {},
+ versions: [
+ {
+ name: 'Historical Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ tool_resources: {
+ file_search: { file_ids: [ownedFileId, otherFileId] },
+ },
+ },
+ ],
+ });
+
+ mockReq.user.id = agentAuthorId.toString();
+ mockReq.params.id = agent.id;
+ mockReq.body = { version_index: 0 };
+
+ await revertAgentVersionHandler(mockReq, mockRes);
+
+ expect(mockRes.json).toHaveBeenCalled();
+ const agentInDb = await Agent.findOne({ id: agent.id }).lean();
+ expect(agentInDb.tool_resources.file_search.file_ids).toEqual([ownedFileId]);
+ });
+ });
+
describe('Mass Assignment Attack Scenarios', () => {
test('should prevent setting system fields during creation', async () => {
const systemFields = {
diff --git a/api/server/middleware/accessResources/fileAccess.js b/api/server/middleware/accessResources/fileAccess.js
index 230148fb53..e1c5803c64 100644
--- a/api/server/middleware/accessResources/fileAccess.js
+++ b/api/server/middleware/accessResources/fileAccess.js
@@ -5,15 +5,16 @@ const { getAgents, getFiles } = require('~/models');
/**
* Checks if user has access to a file through agent permissions
- * Files inherit permissions from agents - if you can view the agent, you can access its files
+ * Files inherit permissions from agents authored by the file owner
*/
-const checkAgentBasedFileAccess = async ({ userId, role, fileId }) => {
+const checkAgentBasedFileAccess = async ({ userId, role, fileId, fileOwner }) => {
try {
/** Agents that have this file in their tool_resources */
const agentsWithFile = await getAgents({
$or: [
{ 'tool_resources.execute_code.file_ids': fileId },
{ 'tool_resources.file_search.file_ids': fileId },
+ { 'tool_resources.image_edit.file_ids': fileId },
{ 'tool_resources.context.file_ids': fileId },
{ 'tool_resources.ocr.file_ids': fileId },
],
@@ -23,15 +24,19 @@ const checkAgentBasedFileAccess = async ({ userId, role, fileId }) => {
return false;
}
- // Check if user has access to any of these agents
+ const fileOwnerId = fileOwner?.toString();
+ const userIdStr = userId.toString();
for (const agent of agentsWithFile) {
- // Check if user is the agent author
- if (agent.author && agent.author.toString() === userId) {
+ const agentAuthorId = agent.author?.toString();
+ if (!agentAuthorId || !fileOwnerId || agentAuthorId !== fileOwnerId) {
+ continue;
+ }
+
+ if (agentAuthorId === userIdStr) {
logger.debug(`[fileAccess] User is author of agent ${agent.id}`);
return true;
}
- // Check ACL permissions for VIEW access on the agent
try {
const permissions = await getEffectivePermissions({
userId,
@@ -49,7 +54,6 @@ const checkAgentBasedFileAccess = async ({ userId, role, fileId }) => {
`[fileAccess] Permission check failed for agent ${agent.id}:`,
permissionError.message,
);
- // Continue checking other agents
}
}
@@ -70,7 +74,7 @@ const denyFileAccess = (res) =>
/**
* Middleware to check if user can access a file
- * Checks: 1) File ownership, 2) Agent-based access (file inherits agent permissions)
+ * Checks: 1) File ownership, 2) Agent-based access through a file-owner agent
*/
const fileAccess = async (req, res, next) => {
try {
@@ -114,7 +118,12 @@ const fileAccess = async (req, res, next) => {
}
/** Agent-based access (file inherits agent permissions) */
- const hasAgentAccess = await checkAgentBasedFileAccess({ userId, role: userRole, fileId });
+ const hasAgentAccess = await checkAgentBasedFileAccess({
+ userId,
+ role: userRole,
+ fileId,
+ fileOwner: file.user,
+ });
if (hasAgentAccess) {
req.fileAccess = { file };
return next();
diff --git a/api/server/middleware/accessResources/fileAccess.spec.js b/api/server/middleware/accessResources/fileAccess.spec.js
index 90b7d8dca7..8fc13e585c 100644
--- a/api/server/middleware/accessResources/fileAccess.spec.js
+++ b/api/server/middleware/accessResources/fileAccess.spec.js
@@ -212,8 +212,7 @@ describe('fileAccess middleware', () => {
});
});
- test('should allow access when user is author of agent with file', async () => {
- // Create agent owned by testUser with the file
+ test('should deny access when user authored an agent with another user file id', async () => {
await createAgent({
id: `agent_${Date.now()}`,
name: 'Test Agent',
@@ -230,9 +229,8 @@ describe('fileAccess middleware', () => {
req.params.file_id = 'shared_file_via_agent';
await fileAccess(req, res, next);
- expect(next).toHaveBeenCalled();
- expect(req.fileAccess).toBeDefined();
- expect(req.fileAccess.file).toBeDefined();
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(403);
});
test('should allow access when user has VIEW permission on agent with file', async () => {
@@ -313,12 +311,12 @@ describe('fileAccess middleware', () => {
});
test('should check file in ocr tool_resources', async () => {
- await createAgent({
+ const agent = await createAgent({
id: `agent_ocr_${Date.now()}`,
name: 'OCR Agent',
provider: 'openai',
model: 'gpt-4',
- author: testUser._id,
+ author: otherUser._id,
tool_resources: {
ocr: {
file_ids: ['shared_file_via_agent'],
@@ -326,6 +324,47 @@ describe('fileAccess middleware', () => {
},
});
+ await AclEntry.create({
+ principalType: PrincipalType.USER,
+ principalId: testUser._id,
+ principalModel: PrincipalModel.USER,
+ resourceType: ResourceType.AGENT,
+ resourceId: agent._id,
+ permBits: 1,
+ grantedBy: otherUser._id,
+ });
+
+ req.params.file_id = 'shared_file_via_agent';
+ await fileAccess(req, res, next);
+
+ expect(next).toHaveBeenCalled();
+ expect(req.fileAccess).toBeDefined();
+ });
+
+ test('should check file in image_edit tool_resources', async () => {
+ const agent = await createAgent({
+ id: `agent_image_${Date.now()}`,
+ name: 'Image Edit Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ author: otherUser._id,
+ tool_resources: {
+ image_edit: {
+ file_ids: ['shared_file_via_agent'],
+ },
+ },
+ });
+
+ await AclEntry.create({
+ principalType: PrincipalType.USER,
+ principalId: testUser._id,
+ principalModel: PrincipalModel.USER,
+ resourceType: ResourceType.AGENT,
+ resourceId: agent._id,
+ permBits: 1,
+ grantedBy: otherUser._id,
+ });
+
req.params.file_id = 'shared_file_via_agent';
await fileAccess(req, res, next);
@@ -377,7 +416,7 @@ describe('fileAccess middleware', () => {
test('should check ALL agents with file, not just first one', async () => {
// Create a file owned by someone else
await createFile({
- user: otherUser._id.toString(),
+ user: thirdUser._id.toString(),
file_id: 'multi_agent_file',
filepath: '/test/multi.txt',
filename: 'multi.txt',
@@ -410,7 +449,7 @@ describe('fileAccess middleware', () => {
grantedBy: otherUser._id,
});
- // Create second agent (owned by thirdUser, but testUser has VIEW access)
+ // Create second agent (owned by the file owner, and testUser has VIEW access)
const agent2 = await createAgent({
id: 'agent_with_access',
name: 'Accessible Agent',
@@ -439,9 +478,8 @@ describe('fileAccess middleware', () => {
await fileAccess(req, res, next);
/**
- * Should succeed because testUser has access to agent2,
- * even though they don't have access to agent1.
- * The fix ensures all agents are checked, not just the first one.
+ * Should succeed because testUser has access to the file owner's agent,
+ * even though a non-owner agent without access is found first.
*/
expect(next).toHaveBeenCalled();
expect(req.fileAccess).toBeDefined();
@@ -474,12 +512,12 @@ describe('fileAccess middleware', () => {
});
// Agent 2: same file in execute_code (testUser has access)
- await createAgent({
+ const agent2 = await createAgent({
id: 'agent_execute_code',
name: 'Execute Code Agent',
provider: 'openai',
model: 'gpt-4',
- author: thirdUser._id,
+ author: otherUser._id,
tool_resources: {
execute_code: {
file_ids: ['multi_tool_file'],
@@ -487,13 +525,23 @@ describe('fileAccess middleware', () => {
},
});
- // Agent 3: same file in ocr (testUser also has access)
+ await AclEntry.create({
+ principalType: PrincipalType.USER,
+ principalId: testUser._id,
+ principalModel: PrincipalModel.USER,
+ resourceType: ResourceType.AGENT,
+ resourceId: agent2._id,
+ permBits: 1,
+ grantedBy: otherUser._id,
+ });
+
+ // Agent 3: same file in ocr (bad reference from a non-owner agent)
await createAgent({
id: 'agent_ocr',
name: 'OCR Agent',
provider: 'openai',
model: 'gpt-4',
- author: testUser._id, // testUser owns this one
+ author: testUser._id,
tool_resources: {
ocr: {
file_ids: ['multi_tool_file'],
@@ -505,7 +553,7 @@ describe('fileAccess middleware', () => {
await fileAccess(req, res, next);
/**
- * Should succeed because testUser owns agent3,
+ * Should succeed through the file owner's execute_code agent,
* even if other agents with the file are found first.
*/
expect(next).toHaveBeenCalled();
@@ -567,5 +615,35 @@ describe('fileAccess middleware', () => {
expect(next).not.toHaveBeenCalled();
expect(res.status).toHaveBeenCalledWith(403);
});
+
+ test('should deny agent-based access when file has no owner', async () => {
+ await mongoose.models.File.collection.insertOne({
+ file_id: 'ownerless_file',
+ filepath: '/test/ownerless.txt',
+ filename: 'ownerless.txt',
+ type: 'text/plain',
+ bytes: 100,
+ object: 'file',
+ });
+
+ await createAgent({
+ id: `agent_ownerless_${Date.now()}`,
+ name: 'Ownerless File Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ author: testUser._id,
+ tool_resources: {
+ file_search: {
+ file_ids: ['ownerless_file'],
+ },
+ },
+ });
+
+ req.params.file_id = 'ownerless_file';
+ await fileAccess(req, res, next);
+
+ expect(next).not.toHaveBeenCalled();
+ expect(res.status).toHaveBeenCalledWith(403);
+ });
});
});
diff --git a/api/server/routes/files/files.agents.test.js b/api/server/routes/files/files.agents.test.js
index cb0e4ff3d2..d2c76ea139 100644
--- a/api/server/routes/files/files.agents.test.js
+++ b/api/server/routes/files/files.agents.test.js
@@ -333,7 +333,7 @@ describe('File Routes - Agent Files Endpoint', () => {
expect(response.body).toHaveLength(2);
});
- it('should return files uploaded by other users to shared agent for author', async () => {
+ it('should not return files owned by other users through agent file references', async () => {
const anotherUserId = new mongoose.Types.ObjectId();
const otherUserFileId = uuidv4();
@@ -380,9 +380,9 @@ describe('File Routes - Agent Files Endpoint', () => {
expect(response.status).toBe(200);
expect(Array.isArray(response.body)).toBe(true);
- expect(response.body).toHaveLength(2);
+ expect(response.body).toHaveLength(1);
expect(response.body.map((f) => f.file_id)).toContain(fileId1);
- expect(response.body.map((f) => f.file_id)).toContain(otherUserFileId);
+ expect(response.body.map((f) => f.file_id)).not.toContain(otherUserFileId);
});
});
diff --git a/api/server/routes/files/files.js b/api/server/routes/files/files.js
index 8183bca973..7ac1d55e53 100644
--- a/api/server/routes/files/files.js
+++ b/api/server/routes/files/files.js
@@ -106,7 +106,9 @@ router.get('/agent/:agent_id', async (req, res) => {
return res.status(200).json([]);
}
- const files = await db.getFiles({ file_id: { $in: agentFileIds } }, null, { text: 0 });
+ const files = await db.getFiles({ file_id: { $in: agentFileIds }, user: agent.author }, null, {
+ text: 0,
+ });
res.status(200).json(files);
} catch (error) {
@@ -187,6 +189,7 @@ router.delete('/', async (req, res) => {
fileIds: nonOwnedFileIds,
agentId: req.body.agent_id,
isDelete: true,
+ files: nonOwnedFiles,
});
for (const file of nonOwnedFiles) {
diff --git a/api/server/routes/files/files.test.js b/api/server/routes/files/files.test.js
index ac1167c09e..b7c4772890 100644
--- a/api/server/routes/files/files.test.js
+++ b/api/server/routes/files/files.test.js
@@ -270,6 +270,59 @@ describe('File Routes - Delete with Agent Access', () => {
expect(processDeleteRequest).toHaveBeenCalled();
});
+ it('should prevent deleting files not owned by the agent author', async () => {
+ const thirdUserId = new mongoose.Types.ObjectId();
+ const thirdUserFileId = uuidv4();
+ await createFile({
+ user: thirdUserId,
+ file_id: thirdUserFileId,
+ filename: 'third-user-file.txt',
+ filepath: '/uploads/third-user-file.txt',
+ bytes: 300,
+ type: 'text/plain',
+ });
+
+ const agent = await createAgent({
+ id: uuidv4(),
+ name: 'Test Agent',
+ provider: 'openai',
+ model: 'gpt-4',
+ author: authorId,
+ tool_resources: {
+ file_search: {
+ file_ids: [thirdUserFileId],
+ },
+ },
+ });
+
+ const { grantPermission } = require('~/server/services/PermissionService');
+ await grantPermission({
+ principalType: PrincipalType.USER,
+ principalId: otherUserId,
+ resourceType: ResourceType.AGENT,
+ resourceId: agent._id,
+ accessRoleId: AccessRoleIds.AGENT_EDITOR,
+ grantedBy: authorId,
+ });
+
+ const response = await request(app)
+ .delete('/files')
+ .send({
+ agent_id: agent.id,
+ files: [
+ {
+ file_id: thirdUserFileId,
+ filepath: '/uploads/third-user-file.txt',
+ },
+ ],
+ });
+
+ expect(response.status).toBe(403);
+ expect(response.body.message).toBe('You can only delete files you have access to');
+ expect(response.body.unauthorizedFiles).toContain(thirdUserFileId);
+ expect(processDeleteRequest).not.toHaveBeenCalled();
+ });
+
it('should prevent deleting files not attached to the specified agent', async () => {
// Create another file not attached to the agent
const unattachedFileId = uuidv4();
diff --git a/api/server/routes/files/preview.spec.js b/api/server/routes/files/preview.spec.js
index 84790c1e5f..426b0697c6 100644
--- a/api/server/routes/files/preview.spec.js
+++ b/api/server/routes/files/preview.spec.js
@@ -24,11 +24,12 @@ jest.mock('@librechat/api', () => ({
const mockFindFileById = jest.fn();
const mockGetFiles = jest.fn();
const mockUpdateFile = jest.fn();
+const mockGetAgents = jest.fn().mockResolvedValue([]);
jest.mock('~/models', () => ({
findFileById: (...args) => mockFindFileById(...args),
getFiles: (...args) => mockGetFiles(...args),
updateFile: (...args) => mockUpdateFile(...args),
- getAgents: jest.fn().mockResolvedValue([]),
+ getAgents: (...args) => mockGetAgents(...args),
batchUpdateFiles: jest.fn(),
}));
@@ -96,6 +97,8 @@ describe('GET /files/:file_id/preview', () => {
mockFindFileById.mockReset();
mockGetFiles.mockReset();
mockUpdateFile.mockReset();
+ mockGetAgents.mockReset();
+ mockGetAgents.mockResolvedValue([]);
});
it('returns 404 when the file does not exist (auth check fails first via fileAccess)', async () => {
@@ -121,6 +124,26 @@ describe('GET /files/:file_id/preview', () => {
expect(mockFindFileById).not.toHaveBeenCalled();
});
+ it('does not disclose preview text through an attacker-authored agent file reference', async () => {
+ mockGetFiles.mockResolvedValueOnce([
+ { file_id: 'victim-file', user: 'victim-user', filename: 'secret.xlsx', status: 'ready' },
+ ]);
+ mockGetAgents.mockResolvedValueOnce([
+ {
+ id: 'agent-attacker',
+ author: 'attacker-user',
+ tool_resources: { execute_code: { file_ids: ['victim-file'] } },
+ },
+ ]);
+
+ const res = await request(buildApp({ user: { id: 'attacker-user', role: 'user' } })).get(
+ '/files/victim-file/preview',
+ );
+
+ expect(res.status).toBe(403);
+ expect(mockFindFileById).not.toHaveBeenCalled();
+ });
+
it('returns status:pending without text/textFormat while the deferred render is in flight', async () => {
mockGetFiles.mockResolvedValueOnce([
{
diff --git a/api/server/services/Files/permissions.js b/api/server/services/Files/permissions.js
index ffa8e74799..f3e2f7ce9c 100644
--- a/api/server/services/Files/permissions.js
+++ b/api/server/services/Files/permissions.js
@@ -1,7 +1,7 @@
const { logger } = require('@librechat/data-schemas');
const { PermissionBits, ResourceType, isEphemeralAgentId } = require('librechat-data-provider');
const { checkPermission } = require('~/server/services/PermissionService');
-const { getAgent } = require('~/models');
+const { getAgent, getFiles } = require('~/models');
/**
* @param {Object} agent - The agent document (lean)
@@ -21,18 +21,29 @@ function getAttachedFileIds(agent) {
return attachedFileIds;
}
+function getFilesById(files) {
+ const filesById = new Map();
+ for (const file of files ?? []) {
+ if (file?.file_id) {
+ filesById.set(file.file_id, file);
+ }
+ }
+ return filesById;
+}
+
/**
* Checks if a user has access to multiple files through a shared agent (batch operation).
- * Access is always scoped to files actually attached to the agent's tool_resources.
+ * Access is scoped to files attached to the agent and owned by the agent author.
* @param {Object} params - Parameters object
* @param {string} params.userId - The user ID to check access for
* @param {string} [params.role] - Optional user role to avoid DB query
* @param {string[]} params.fileIds - Array of file IDs to check
* @param {string} params.agentId - The agent ID that might grant access
* @param {boolean} [params.isDelete] - Whether the operation is a delete operation
+ * @param {Array<{ file_id: string, user: string }>} [params.files] - Pre-fetched file documents
* @returns {Promise<Map<string, boolean>>} Map of fileId to access status
*/
-const hasAccessToFilesViaAgent = async ({ userId, role, fileIds, agentId, isDelete }) => {
+const hasAccessToFilesViaAgent = async ({ userId, role, fileIds, agentId, isDelete, files }) => {
const accessMap = new Map();
fileIds.forEach((fileId) => accessMap.set(fileId, false));
@@ -45,10 +56,19 @@ const hasAccessToFilesViaAgent = async ({ userId, role, fileIds, agentId, isDele
}
const attachedFileIds = getAttachedFileIds(agent);
-
- if (agent.author.toString() === userId.toString()) {
+ const agentAuthorId = agent.author?.toString();
+ const filesById =
+ files != null
+ ? getFilesById(files)
+ : getFilesById(
+ await getFiles({ file_id: { $in: fileIds } }, null, { file_id: 1, user: 1 }),
+ );
+ const canInheritFromAgent = (fileId) =>
+ attachedFileIds.has(fileId) && filesById.get(fileId)?.user?.toString() === agentAuthorId;
+
+ if (agentAuthorId === userId.toString()) {
fileIds.forEach((fileId) => {
- if (attachedFileIds.has(fileId)) {
+ if (canInheritFromAgent(fileId)) {
accessMap.set(fileId, true);
}
});
@@ -82,7 +102,7 @@ const hasAccessToFilesViaAgent = async ({ userId, role, fileIds, agentId, isDele
}
fileIds.forEach((fileId) => {
- if (attachedFileIds.has(fileId)) {
+ if (canInheritFromAgent(fileId)) {
accessMap.set(fileId, true);
}
});
@@ -126,7 +146,13 @@ const filterFilesByAgentAccess = async ({ files, userId, role, agentId }) => {
// Batch check access for all non-owned files
const fileIds = filesToCheck.map((f) => f.file_id);
- const accessMap = await hasAccessToFilesViaAgent({ userId, role, fileIds, agentId });
+ const accessMap = await hasAccessToFilesViaAgent({
+ userId,
+ role,
+ fileIds,
+ agentId,
+ files: filesToCheck,
+ });
// Filter files based on access
const accessibleFiles = filesToCheck.filter((file) => accessMap.get(file.file_id));
diff --git a/api/server/services/Files/permissions.spec.js b/api/server/services/Files/permissions.spec.js
index c926e83464..83a0e4835d 100644
--- a/api/server/services/Files/permissions.spec.js
+++ b/api/server/services/Files/permissions.spec.js
@@ -8,12 +8,13 @@ jest.mock('~/server/services/PermissionService', () => ({
jest.mock('~/models', () => ({
getAgent: jest.fn(),
+ getFiles: jest.fn(),
}));
const { logger } = require('@librechat/data-schemas');
const { Constants, PermissionBits, ResourceType } = require('librechat-data-provider');
const { checkPermission } = require('~/server/services/PermissionService');
-const { getAgent } = require('~/models');
+const { getAgent, getFiles } = require('~/models');
const { filterFilesByAgentAccess, hasAccessToFilesViaAgent } = require('./permissions');
const AUTHOR_ID = 'author-user-id';
@@ -40,6 +41,12 @@ function makeAgent(overrides = {}) {
beforeEach(() => {
jest.clearAllMocks();
+ getFiles.mockResolvedValue([
+ makeFile('attached-1', AUTHOR_ID),
+ makeFile('attached-2', AUTHOR_ID),
+ makeFile('attached-3', AUTHOR_ID),
+ makeFile('not-attached', AUTHOR_ID),
+ ]);
});
describe('filterFilesByAgentAccess', () => {
@@ -151,6 +158,20 @@ describe('filterFilesByAgentAccess', () => {
expect(result.map((f) => f.file_id)).not.toContain('not-attached');
});
+ it('should not return a file referenced from an agent that is not authored by the file owner', async () => {
+ getAgent.mockResolvedValue(makeAgent({ author: USER_ID }));
+ checkPermission.mockResolvedValue(true);
+
+ const result = await filterFilesByAgentAccess({
+ files: [sharedFile],
+ userId: USER_ID,
+ role: 'USER',
+ agentId: AGENT_ID,
+ });
+
+ expect(result).toEqual([]);
+ });
+
it('should return only owned files when user lacks VIEW permission', async () => {
getAgent.mockResolvedValue(makeAgent());
checkPermission.mockResolvedValue(false);
@@ -192,7 +213,7 @@ describe('filterFilesByAgentAccess', () => {
});
describe('file with no user field', () => {
- it('should treat file as non-owned and run through access check', async () => {
+ it('should exclude the file even when attached to the agent', async () => {
const noUserFile = makeFile('attached-1', undefined);
getAgent.mockResolvedValue(makeAgent());
checkPermission.mockResolvedValue(true);
@@ -205,7 +226,7 @@ describe('filterFilesByAgentAccess', () => {
});
expect(getAgent).toHaveBeenCalled();
- expect(result).toEqual([noUserFile]);
+ expect(result).toEqual([]);
});
it('should exclude file with no user field when not attached to agent', async () => {
@@ -299,6 +320,19 @@ describe('hasAccessToFilesViaAgent', () => {
expect(result.get('not-attached')).toBe(false);
expect(checkPermission).not.toHaveBeenCalled();
});
+
+ it('should deny attached files not owned by the agent author', async () => {
+ getAgent.mockResolvedValue(makeAgent({ author: USER_ID }));
+ getFiles.mockResolvedValue([makeFile('attached-1', AUTHOR_ID)]);
+
+ const result = await hasAccessToFilesViaAgent({
+ userId: USER_ID,
+ fileIds: ['attached-1'],
+ agentId: AGENT_ID,
+ });
+
+ expect(result.get('attached-1')).toBe(false);
+ });
});
describe('VIEW permission path', () => {