🪢 Open source agent evals & observability: Trace, evaluate, and improve LLM applications with one open platform.
TypeScript analyticsautogenevaluationlangchainlarge-language-modelsllama-indexllmllm-evaluationllm-observabilityllmopsmonitoringobservabilityopen-sourceopenaiplaygroundprompt-engineeringprompt-managementself-hostedycombinator
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.tsindex 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.tsindex 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.tsnew file mode 100644index 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.tsindex 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.tsindex 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);