Skip to content

🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.

test(external-media-storage): cover tRPC SSRF and access-control negatives (#19185)

Tobias Wochinger0ab448271f61
diff --git a/packages/shared/src/server/services/externalMediaStorageEndpointValidation/externalMediaStorageEndpointValidation.test.ts b/packages/shared/src/server/services/externalMediaStorageEndpointValidation/externalMediaStorageEndpointValidation.test.ts
index 70ea741a1c..1d8ec5645c 100644
--- a/packages/shared/src/server/services/externalMediaStorageEndpointValidation/externalMediaStorageEndpointValidation.test.ts
+++ b/packages/shared/src/server/services/externalMediaStorageEndpointValidation/externalMediaStorageEndpointValidation.test.ts
@@ -1,5 +1,5 @@
-import { describe, expect, it, vi } from "vitest";
-import { OutboundUrlValidationError } from "../../outbound-url";
+import dns from "node:dns/promises";
+import { afterEach, describe, expect, it, vi } from "vitest";
import { validateExternalMediaStorageEndpoint } from "./externalMediaStorageEndpointValidation";
vi.mock("../../../env", () => ({
@@ -14,15 +14,40 @@ vi.mock("../../../env", () => ({
const strictWhitelist = { hosts: [], ips: [], ip_ranges: [] };
describe("validateExternalMediaStorageEndpoint", () => {
- it.each(["http://127.0.0.1", "http://169.254.169.254", "http://10.0.0.1"])(
+ afterEach(() => {
+ vi.restoreAllMocks();
+ });
+
+ it.each([
+ ["http://127.0.0.1", "blocked-ip"],
+ ["http://[::1]", "blocked-ip"],
+ ["http://169.254.169.254", "blocked-hostname"],
+ ["http://10.0.0.1", "blocked-ip"],
+ ])(
"rejects private endpoint %s without an allowlist",
- async (endpoint) => {
+ async (endpoint, code) => {
await expect(
validateExternalMediaStorageEndpoint(endpoint, strictWhitelist),
- ).rejects.toBeInstanceOf(OutboundUrlValidationError);
+ ).rejects.toMatchObject({ code });
},
);
+ it("rejects a hostname that resolves to a private address", async () => {
+ vi.spyOn(dns, "resolve4").mockResolvedValue(["10.0.0.5"]);
+ vi.spyOn(dns, "resolve6").mockRejectedValue(new Error("ENODATA"));
+ vi.spyOn(dns, "lookup").mockResolvedValue([
+ { address: "10.0.0.5", family: 4 },
+ ] as never);
+
+ await expect(
+ validateExternalMediaStorageEndpoint(
+ "https://storage.internal.example.com",
+ strictWhitelist,
+ ),
+ ).rejects.toMatchObject({ code: "blocked-ip" });
+ expect(dns.resolve4).toHaveBeenCalledWith("storage.internal.example.com");
+ });
+
it("rejects endpoints with embedded credentials", async () => {
await expect(
validateExternalMediaStorageEndpoint(
diff --git a/web/src/__tests__/server/external-media-storage-service.servertest.ts b/web/src/__tests__/server/external-media-storage-service.servertest.ts
index c74c92e543..5281c02d7d 100644
--- a/web/src/__tests__/server/external-media-storage-service.servertest.ts
+++ b/web/src/__tests__/server/external-media-storage-service.servertest.ts
@@ -1,6 +1,7 @@
import { randomUUID } from "crypto";
import type { Mock } from "vitest";
+import { InvalidRequestError } from "@langfuse/shared";
import { encrypt } from "@langfuse/shared/encryption";
import { prisma } from "@langfuse/shared/src/db";
import {
@@ -179,6 +180,25 @@ describe("external media storage service", () => {
expect(StorageServiceFactory.getInstance).not.toHaveBeenCalled();
});
+ it("reports a stored endpoint that fails validation as an invalid request", async () => {
+ const project = await prepareIntegration({ prefix: null });
+ await prisma.externalMediaStorageIntegration.update({
+ where: { projectId: project.id },
+ data: { type: "S3_COMPATIBLE", endpoint: "https://127.0.0.1:9000" },
+ });
+ const service = createExternalMediaStorageService(prisma);
+
+ for (const call of [service.testObject, service.resolveUrl]) {
+ const rejection = call({
+ projectId: project.id,
+ uri: "s3://media-bucket/image.png",
+ });
+ await expect(rejection).rejects.toBeInstanceOf(InvalidRequestError);
+ await expect(rejection).rejects.toThrow("Blocked IP address detected");
+ }
+ expect(StorageServiceFactory.getInstance).not.toHaveBeenCalled();
+ });
+
it("does not use another project's integration", async () => {
const configuredProject = await prepareIntegration({ prefix: null });
const { org, project: otherProject } = await createOrgProjectAndApiKey();
diff --git a/web/src/__tests__/server/external-media-storage-trpc.servertest.ts b/web/src/__tests__/server/external-media-storage-trpc.servertest.ts
new file mode 100644
index 0000000000..81b1f14593
--- /dev/null
+++ b/web/src/__tests__/server/external-media-storage-trpc.servertest.ts
@@ -0,0 +1,340 @@
+import dns from "node:dns/promises";
+import { randomUUID } from "crypto";
+import type { Mock } from "vitest";
+import type { Session } from "next-auth";
+
+import { testFeatureFlags } from "@/src/__tests__/fixtures/feature-flags";
+import { appRouter } from "@/src/server/api/root";
+import { createInnerTRPCContext } from "@/src/server/api/trpc";
+import { encrypt } from "@langfuse/shared/encryption";
+import { prisma, type Role } from "@langfuse/shared/src/db";
+import { env as sharedEnv } from "@langfuse/shared/src/env";
+import {
+ createOrgProjectAndApiKey,
+ StorageServiceFactory,
+} from "@langfuse/shared/src/server";
+
+vi.mock("@langfuse/shared/src/server", async () => {
+ const actual = await vi.importActual("@langfuse/shared/src/server");
+ return {
+ ...actual,
+ StorageServiceFactory: {
+ getInstance: vi.fn(),
+ },
+ };
+});
+
+const __orgIds: string[] = [];
+
+async function prepare({ projectRole = "ADMIN" }: { projectRole?: Role } = {}) {
+ const { project, org } = await createOrgProjectAndApiKey();
+ __orgIds.push(org.id);
+ await prisma.organization.update({
+ where: { id: org.id },
+ data: { featureFlagOrgDefaults: ["externalMediaStorage"] },
+ });
+
+ const session: Session = {
+ expires: "1",
+ user: {
+ id: "user-1",
+ canCreateOrganizations: false,
+ name: "Demo User",
+ admin: false,
+ organizations: [
+ {
+ id: org.id,
+ name: org.name,
+ role: "MEMBER",
+ plan: "cloud:hobby",
+ cloudConfig: undefined,
+ metadata: {},
+ aiFeaturesEnabled: false,
+ aiTelemetryEnabled: false,
+ projects: [
+ {
+ id: project.id,
+ role: projectRole,
+ retentionDays: 30,
+ deletedAt: null,
+ hasTraces: false,
+ name: project.name,
+ metadata: {},
+ createdAt: new Date().toISOString(),
+ },
+ ],
+ },
+ ],
+ featureFlags: testFeatureFlags(),
+ },
+ environment: {
+ enableExperimentalFeatures: false,
+ selfHostedInstancePlan: "cloud:hobby",
+ },
+ };
+
+ const ctx = createInnerTRPCContext({ session, headers: {} });
+ return { project, org, caller: appRouter.createCaller({ ...ctx, prisma }) };
+}
+
+async function createIntegration({
+ projectId,
+ prefix = "customer/",
+}: {
+ projectId: string;
+ prefix?: string | null;
+}) {
+ return prisma.externalMediaStorageIntegration.create({
+ data: {
+ projectId,
+ type: "S3",
+ bucketName: `media-${randomUUID()}`,
+ prefix,
+ accessKeyId: "test-access-key",
+ secretAccessKey: encrypt("test-secret-key"),
+ region: "us-east-1",
+ endpoint: null,
+ forcePathStyle: false,
+ },
+ });
+}
+
+function mockStorage() {
+ const getSignedUrl = vi.fn().mockResolvedValue("https://signed.example");
+ (StorageServiceFactory.getInstance as Mock).mockReturnValue({
+ getSignedUrl,
+ getObjectContentLength: vi.fn().mockResolvedValue(42),
+ });
+ return { getSignedUrl };
+}
+
+const s3CompatibleInput = (projectId: string, endpoint: string) => ({
+ projectId,
+ type: "S3_COMPATIBLE" as const,
+ bucketName: "media-bucket",
+ endpoint,
+ region: "us-east-1",
+ accessKeyId: "test-access-key",
+ secretAccessKey: "test-secret-key",
+ prefix: "",
+ forcePathStyle: true,
+});
+
+describe("externalMediaStorage tRPC", () => {
+ afterEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterAll(async () => {
+ await prisma.organization.deleteMany({ where: { id: { in: __orgIds } } });
+ });
+
+ describe("update endpoint validation", () => {
+ const original = {
+ region: sharedEnv.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION,
+ hosts:
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_HOST,
+ ips: sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IPS,
+ ipSegments:
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IP_SEGMENTS,
+ allowedHosts:
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_ALLOWED_HOSTS,
+ };
+
+ beforeEach(() => {
+ sharedEnv.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION = undefined;
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_HOST = [];
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IPS = [];
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IP_SEGMENTS =
+ [];
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_ALLOWED_HOSTS = [];
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ sharedEnv.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION = original.region;
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_HOST =
+ original.hosts;
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IPS =
+ original.ips;
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IP_SEGMENTS =
+ original.ipSegments;
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_ALLOWED_HOSTS =
+ original.allowedHosts;
+ });
+
+ it.each([
+ ["loopback IPv4", "http://127.0.0.1:9000", "Blocked IP address"],
+ ["loopback IPv6", "http://[::1]:9000", "Blocked IP address"],
+ ["cloud metadata", "http://169.254.169.254", "Blocked hostname"],
+ ["RFC1918", "http://10.0.0.1:9000", "Blocked IP address"],
+ [
+ "embedded credentials",
+ "https://user:[email protected]",
+ "URL credentials are not allowed",
+ ],
+ ])(
+ "rejects a %s endpoint without persisting it",
+ async (_case, endpoint, message) => {
+ const { project, caller } = await prepare();
+
+ await expect(
+ caller.externalMediaStorage.update(
+ s3CompatibleInput(project.id, endpoint),
+ ),
+ ).rejects.toMatchObject({
+ code: "BAD_REQUEST",
+ message: expect.stringContaining(message),
+ });
+ await expect(
+ prisma.externalMediaStorageIntegration.findUnique({
+ where: { projectId: project.id },
+ }),
+ ).resolves.toBeNull();
+ },
+ );
+
+ it("rejects a hostname that resolves to a private address", async () => {
+ vi.spyOn(dns, "resolve4").mockResolvedValue(["10.0.0.5"]);
+ vi.spyOn(dns, "resolve6").mockRejectedValue(new Error("ENODATA"));
+ vi.spyOn(dns, "lookup").mockResolvedValue([
+ { address: "10.0.0.5", family: 4 },
+ ] as never);
+ const { project, caller } = await prepare();
+
+ await expect(
+ caller.externalMediaStorage.update(
+ s3CompatibleInput(project.id, "https://storage.internal.example.com"),
+ ),
+ ).rejects.toMatchObject({
+ code: "BAD_REQUEST",
+ message: expect.stringContaining("Blocked IP address"),
+ });
+ expect(dns.resolve4).toHaveBeenCalledWith("storage.internal.example.com");
+ await expect(
+ prisma.externalMediaStorageIntegration.findUnique({
+ where: { projectId: project.id },
+ }),
+ ).resolves.toBeNull();
+ });
+
+ it("requires HTTPS and ignores the private-address exemptions on Langfuse Cloud", async () => {
+ sharedEnv.NEXT_PUBLIC_LANGFUSE_CLOUD_REGION = "EU";
+ sharedEnv.LANGFUSE_EXTERNAL_MEDIA_STORAGE_ENDPOINT_WHITELISTED_IPS = [
+ "127.0.0.1",
+ ];
+ const { project, caller } = await prepare();
+
+ await expect(
+ caller.externalMediaStorage.update(
+ s3CompatibleInput(project.id, "http://storage.example.com"),
+ ),
+ ).rejects.toMatchObject({
+ code: "BAD_REQUEST",
+ message: expect.stringContaining("Only HTTPS"),
+ });
+ await expect(
+ caller.externalMediaStorage.update(
+ s3CompatibleInput(project.id, "https://127.0.0.1:9000"),
+ ),
+ ).rejects.toMatchObject({
+ code: "BAD_REQUEST",
+ message: expect.stringContaining("Blocked IP address"),
+ });
+ });
+ });
+
+ describe("access control", () => {
+ it("forbids a VIEWER from reading, saving, deleting, or testing the configuration", async () => {
+ const { project, caller } = await prepare({ projectRole: "VIEWER" });
+ const integration = await createIntegration({ projectId: project.id });
+
+ await expect(
+ caller.externalMediaStorage.get({ projectId: project.id }),
+ ).rejects.toMatchObject({ code: "FORBIDDEN" });
+ await expect(
+ caller.externalMediaStorage.update(
+ s3CompatibleInput(project.id, "https://storage.example.com"),
+ ),
+ ).rejects.toMatchObject({ code: "FORBIDDEN" });
+ await expect(
+ caller.externalMediaStorage.delete({ projectId: project.id }),
+ ).rejects.toMatchObject({ code: "FORBIDDEN" });
+ await expect(
+ caller.externalMediaStorage.testObject({
+ projectId: project.id,
+ uri: `s3://${integration.bucketName}/customer/image.png`,
+ }),
+ ).rejects.toMatchObject({ code: "FORBIDDEN" });
+
+ await expect(
+ prisma.externalMediaStorageIntegration.findUniqueOrThrow({
+ where: { projectId: project.id },
+ select: { type: true, endpoint: true },
+ }),
+ ).resolves.toEqual({ type: "S3", endpoint: null });
+ expect(StorageServiceFactory.getInstance).not.toHaveBeenCalled();
+ });
+ });
+
+ describe("media.resolveExternalMedia", () => {
+ it("lets a VIEWER resolve an object within the configured prefix", async () => {
+ const { getSignedUrl } = mockStorage();
+ const { project, caller } = await prepare({ projectRole: "VIEWER" });
+ const integration = await createIntegration({ projectId: project.id });
+
+ await expect(
+ caller.media.resolveExternalMedia({
+ projectId: project.id,
+ uri: `s3://${integration.bucketName}/customer/image.png`,
+ }),
+ ).resolves.toMatchObject({ url: "https://signed.example" });
+ expect(getSignedUrl).toHaveBeenCalledWith(
+ "customer/image.png",
+ 300,
+ false,
+ );
+ });
+
+ it.each([
+ ["a key outside the prefix", "other/secret.png"],
+ ["a sibling prefix", "customer-other/secret.png"],
+ ])("does not sign %s for a VIEWER", async (_case, key) => {
+ mockStorage();
+ const { project, caller } = await prepare({ projectRole: "VIEWER" });
+ const integration = await createIntegration({ projectId: project.id });
+
+ await expect(
+ caller.media.resolveExternalMedia({
+ projectId: project.id,
+ uri: `s3://${integration.bucketName}/${key}`,
+ }),
+ ).rejects.toMatchObject({ code: "NOT_FOUND" });
+ expect(StorageServiceFactory.getInstance).not.toHaveBeenCalled();
+ });
+
+ it("does not resolve media through another tenant's project", async () => {
+ mockStorage();
+ const tenantA = await prepare();
+ const tenantB = await prepare();
+ const integrationA = await createIntegration({
+ projectId: tenantA.project.id,
+ });
+ const uri = `s3://${integrationA.bucketName}/customer/image.png`;
+
+ await expect(
+ tenantB.caller.media.resolveExternalMedia({
+ projectId: tenantA.project.id,
+ uri,
+ }),
+ ).rejects.toMatchObject({ code: "UNAUTHORIZED" });
+ await expect(
+ tenantB.caller.media.resolveExternalMedia({
+ projectId: tenantB.project.id,
+ uri,
+ }),
+ ).rejects.toMatchObject({ code: "NOT_FOUND" });
+ expect(StorageServiceFactory.getInstance).not.toHaveBeenCalled();
+ });
+ });
+});
diff --git a/web/src/__tests__/server/mcp-tools-write.servertest.ts b/web/src/__tests__/server/mcp-tools-write.servertest.ts
index eb0893b1dc..0e20be8855 100644
--- a/web/src/__tests__/server/mcp-tools-write.servertest.ts
+++ b/web/src/__tests__/server/mcp-tools-write.servertest.ts
@@ -2044,6 +2044,35 @@ describe("MCP Write Tools", () => {
}),
).resolves.toBeDefined();
});
+
+ it("rejects a loopback endpoint without persisting it", async () => {
+ const setup = await createMcpTestSetup();
+ await prisma.organization.update({
+ where: { id: setup.context.orgId },
+ data: { featureFlagOrgDefaults: ["externalMediaStorage"] },
+ });
+ // HTTPS passes Cloud's protocol check, so this pins the loopback block
+ // in both deployment modes.
+ await expect(
+ handleConfigureExternalMediaStorage(
+ {
+ type: "S3_COMPATIBLE",
+ bucketName: "media-bucket",
+ endpoint: "https://127.0.0.1:9000",
+ region: "us-east-1",
+ accessKeyId: "test-access-key",
+ secretAccessKey: "test-secret-key",
+ forcePathStyle: true,
+ },
+ setup.context,
+ ),
+ ).rejects.toThrow("Blocked IP address detected");
+ await expect(
+ prisma.externalMediaStorageIntegration.findUnique({
+ where: { projectId: setup.projectId },
+ }),
+ ).resolves.toBeNull();
+ });
});
describe("in-app-agent protected prompt labels", () => {
diff --git a/web/src/features/external-media-storage/server/service.ts b/web/src/features/external-media-storage/server/service.ts
index d789ee80fc..ac2452a44c 100644
--- a/web/src/features/external-media-storage/server/service.ts
+++ b/web/src/features/external-media-storage/server/service.ts
@@ -10,6 +10,7 @@ import {
import { decrypt, encrypt } from "@langfuse/shared/encryption";
import { type PrismaClient } from "@langfuse/shared/src/db";
import {
+ OutboundUrlValidationError,
StorageServiceFactory,
externalMediaStorageEndpointConnectionValidationOptions,
validateExternalMediaStorageEndpoint,
@@ -59,6 +60,17 @@ function isKeyWithinPrefix(key: string, prefix: string | null) {
return !normalizedPrefix || isS3KeyWithinPrefix(key, normalizedPrefix);
}
+async function validateEndpoint(endpoint: string) {
+ try {
+ await validateExternalMediaStorageEndpoint(endpoint);
+ } catch (error) {
+ if (error instanceof OutboundUrlValidationError) {
+ throw new InvalidRequestError(error.message);
+ }
+ throw error;
+ }
+}
+
function createStorageService(integration: ExternalMediaStorageRecord) {
return StorageServiceFactory.getInstance({
accessKeyId: integration.accessKeyId ?? undefined,
@@ -138,7 +150,7 @@ export function createExternalMediaStorageService(prisma: PrismaClient) {
);
}
if (endpoint) {
- await validateExternalMediaStorageEndpoint(endpoint);
+ await validateEndpoint(endpoint);
}
let region: string;
@@ -217,7 +229,7 @@ export function createExternalMediaStorageService(prisma: PrismaClient) {
}
if (integration.endpoint) {
- await validateExternalMediaStorageEndpoint(integration.endpoint);
+ await validateEndpoint(integration.endpoint);
}
const storageService = createStorageService(integration);
@@ -264,7 +276,7 @@ export function createExternalMediaStorageService(prisma: PrismaClient) {
}
if (integration.endpoint) {
- await validateExternalMediaStorageEndpoint(integration.endpoint);
+ await validateEndpoint(integration.endpoint);
}
const storageService = createStorageService(integration);