Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

fix(web): validate processing source keys against the video

Richie McIlroy98e4b8cf612e
diff --git a/apps/web/__tests__/unit/agent-upload-entitlement.test.ts b/apps/web/__tests__/unit/agent-upload-entitlement.test.ts
index bc0adfdb5..70afdaf6a 100644
--- a/apps/web/__tests__/unit/agent-upload-entitlement.test.ts
+++ b/apps/web/__tests__/unit/agent-upload-entitlement.test.ts
@@ -136,6 +136,32 @@ describe("agent upload entitlement", () => {
expect(accept).toBeLessThan(processing);
});
+ it("checks the accepted upload key against the video before processing", () => {
+ const source = readFileSync(
+ join(process.cwd(), "app/api/v1/[...route]/route.ts"),
+ "utf8",
+ );
+ const completionSource = source.slice(
+ source.indexOf('.handle("completeUpload"'),
+ source.indexOf('.handle("importLoomCap"'),
+ );
+ const acceptedKeyCheck = completionSource.search(
+ /isVideoStorageKey\(\s*\{ id: path\.id, ownerId: principal\.id \},\s*acceptedRawFileKey,/,
+ );
+ const stateKeyCheck = completionSource.search(
+ /isVideoStorageKey\(\s*\{ id: state\.id, ownerId: state\.ownerId \},\s*state\.rawFileKey,/,
+ );
+
+ expect(acceptedKeyCheck).toBeGreaterThan(-1);
+ expect(stateKeyCheck).toBeGreaterThan(-1);
+ expect(acceptedKeyCheck).toBeLessThan(
+ completionSource.indexOf("runAgentMutation"),
+ );
+ expect(stateKeyCheck).toBeLessThan(
+ completionSource.indexOf("startVideoProcessingWorkflow"),
+ );
+ });
+
it("durably rejects only marked agent uploads and cleans storage first", () => {
const source = readFileSync(
join(process.cwd(), "app/api/v1/[...route]/route.ts"),
diff --git a/apps/web/__tests__/unit/video-storage-key.test.ts b/apps/web/__tests__/unit/video-storage-key.test.ts
new file mode 100644
index 000000000..9487d4599
--- /dev/null
+++ b/apps/web/__tests__/unit/video-storage-key.test.ts
@@ -0,0 +1,258 @@
+import { Video } from "@cap/web-domain";
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { isVideoStorageKey } from "@/lib/video-storage-key";
+
+const mocks = vi.hoisted(() => ({
+ db: vi.fn(),
+ getCurrentUser: vi.fn(),
+ getAccessForVideo: vi.fn(),
+ headObject: vi.fn(),
+ startVideoProcessingWorkflow: vi.fn(),
+ selectWhere: vi.fn(),
+ updateSet: vi.fn(),
+}));
+
+vi.mock("@cap/database", () => ({
+ db: mocks.db,
+}));
+
+vi.mock("@cap/database/auth/session", () => ({
+ getCurrentUser: mocks.getCurrentUser,
+}));
+
+vi.mock("@cap/database/schema", () => ({
+ videos: { id: "videos.id" },
+}));
+
+vi.mock("@cap/web-backend", () => ({
+ Storage: {
+ getAccessForVideo: mocks.getAccessForVideo,
+ },
+}));
+
+vi.mock("drizzle-orm", () => ({
+ eq: (field: unknown, value: unknown) => ({ field, value }),
+}));
+
+vi.mock("@/lib/server", () => ({
+ runPromise: vi.fn(),
+}));
+
+vi.mock("@/lib/video-storage", () => ({
+ decodeStorageVideo: (video: unknown) => video,
+}));
+
+vi.mock("@/lib/video-processing", () => ({
+ startVideoProcessingWorkflow: mocks.startVideoProcessingWorkflow,
+}));
+
+const ownerId = "user_owner1";
+const videoId = Video.VideoId.make("video_abc123");
+const video = { id: videoId, ownerId };
+
+beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.getCurrentUser.mockResolvedValue({ id: ownerId });
+ mocks.headObject.mockReturnValue({
+ pipe: () => Promise.resolve({ ContentLength: 1024 }),
+ });
+ mocks.getAccessForVideo.mockReturnValue({
+ pipe: () => Promise.resolve([{ headObject: mocks.headObject }]),
+ });
+ mocks.startVideoProcessingWorkflow.mockResolvedValue("started");
+ mocks.updateSet.mockReturnValue({ where: vi.fn().mockResolvedValue([]) });
+ mocks.db.mockReturnValue({
+ select: () => ({
+ from: () => ({
+ where: mocks.selectWhere,
+ }),
+ }),
+ update: () => ({
+ set: mocks.updateSet,
+ }),
+ });
+});
+
+describe("isVideoStorageKey", () => {
+ it("accepts the upload paths the server issues for a video", () => {
+ for (const subpath of [
+ "raw-upload.mp4",
+ "raw-upload.webm",
+ "raw-upload.mov",
+ "agent-upload.mp4",
+ "verified-upload-AbC_123-xyz.mp4",
+ "result.mp4",
+ ".recording/sources/source-1.mp4",
+ ]) {
+ expect(isVideoStorageKey(video, `${ownerId}/${videoId}/${subpath}`)).toBe(
+ true,
+ );
+ }
+ });
+
+ it("rejects keys outside the video's upload path", () => {
+ for (const key of [
+ `other_user/${videoId}/raw-upload.mp4`,
+ `${ownerId}/other_video/raw-upload.mp4`,
+ `${ownerId}/${videoId}-extra/raw-upload.mp4`,
+ `${ownerId}/${videoId}/`,
+ `${ownerId}/${videoId}`,
+ "raw-upload.mp4",
+ "",
+ ]) {
+ expect(isVideoStorageKey(video, key)).toBe(false);
+ }
+ });
+
+ it("rejects relative segments, leading slashes and backslashes", () => {
+ for (const key of [
+ `${ownerId}/${videoId}/../../other_user/other_video/raw-upload.mp4`,
+ `${ownerId}/${videoId}/./raw-upload.mp4`,
+ `${ownerId}/${videoId}//raw-upload.mp4`,
+ `/${ownerId}/${videoId}/raw-upload.mp4`,
+ `${ownerId}/${videoId}/..\\raw-upload.mp4`,
+ `${ownerId}/${videoId}/sub\\raw-upload.mp4`,
+ ]) {
+ expect(isVideoStorageKey(video, key)).toBe(false);
+ }
+ expect(
+ isVideoStorageKey({ id: videoId, ownerId: "" }, `/${videoId}/raw.mp4`),
+ ).toBe(false);
+ });
+});
+
+describe("triggerVideoProcessing", () => {
+ const loadAction = async () =>
+ (await import("@/actions/video/trigger-processing")).triggerVideoProcessing;
+
+ it("starts processing for the video's own upload in the default bucket", async () => {
+ mocks.selectWhere.mockResolvedValue([{ ...video, bucket: null }]);
+ const triggerVideoProcessing = await loadAction();
+
+ await expect(
+ triggerVideoProcessing({
+ videoId,
+ rawFileKey: `${ownerId}/${videoId}/raw-upload.mp4`,
+ bucketId: null,
+ }),
+ ).resolves.toEqual({ success: true });
+ expect(mocks.headObject).toHaveBeenCalledWith(
+ `${ownerId}/${videoId}/raw-upload.mp4`,
+ );
+ expect(mocks.startVideoProcessingWorkflow).toHaveBeenCalledWith(
+ expect.objectContaining({
+ rawFileKey: `${ownerId}/${videoId}/raw-upload.mp4`,
+ bucketId: null,
+ }),
+ );
+ });
+
+ it("starts processing for the video's own upload in a custom bucket", async () => {
+ mocks.selectWhere.mockResolvedValue([{ ...video, bucket: "bucket_1" }]);
+ const triggerVideoProcessing = await loadAction();
+
+ await expect(
+ triggerVideoProcessing({
+ videoId,
+ rawFileKey: `${ownerId}/${videoId}/raw-upload.mp4`,
+ bucketId: "bucket_1",
+ }),
+ ).resolves.toEqual({ success: true });
+ expect(mocks.startVideoProcessingWorkflow).toHaveBeenCalledOnce();
+ });
+
+ it("rejects keys outside the video's upload path", async () => {
+ mocks.selectWhere.mockResolvedValue([{ ...video, bucket: null }]);
+ const triggerVideoProcessing = await loadAction();
+
+ for (const rawFileKey of [
+ "other_user/other_video/raw-upload.mp4",
+ `${ownerId}/other_video/raw-upload.mp4`,
+ `${ownerId}/${videoId}/../../other_user/other_video/raw-upload.mp4`,
+ `/${ownerId}/${videoId}/raw-upload.mp4`,
+ ]) {
+ await expect(
+ triggerVideoProcessing({ videoId, rawFileKey, bucketId: null }),
+ ).rejects.toThrow("Upload file does not belong to this video");
+ }
+ expect(mocks.headObject).not.toHaveBeenCalled();
+ expect(mocks.startVideoProcessingWorkflow).not.toHaveBeenCalled();
+ });
+
+ it("rejects a bucket that does not match the video", async () => {
+ const triggerVideoProcessing = await loadAction();
+ const rawFileKey = `${ownerId}/${videoId}/raw-upload.mp4`;
+
+ mocks.selectWhere.mockResolvedValue([{ ...video, bucket: null }]);
+ await expect(
+ triggerVideoProcessing({ videoId, rawFileKey, bucketId: "bucket_1" }),
+ ).rejects.toThrow("Upload bucket does not match this video");
+
+ mocks.selectWhere.mockResolvedValue([{ ...video, bucket: "bucket_1" }]);
+ await expect(
+ triggerVideoProcessing({ videoId, rawFileKey, bucketId: null }),
+ ).rejects.toThrow("Upload bucket does not match this video");
+ await expect(
+ triggerVideoProcessing({ videoId, rawFileKey, bucketId: "bucket_2" }),
+ ).rejects.toThrow("Upload bucket does not match this video");
+
+ expect(mocks.headObject).not.toHaveBeenCalled();
+ expect(mocks.startVideoProcessingWorkflow).not.toHaveBeenCalled();
+ });
+});
+
+describe("video metadata route", () => {
+ const put = async (metadata: unknown) => {
+ const { PUT } = await import("@/app/api/video/metadata/route");
+ return PUT(
+ new NextRequest("http://localhost:3000/api/video/metadata", {
+ method: "PUT",
+ body: JSON.stringify({ videoId, metadata }),
+ }),
+ );
+ };
+
+ it("keeps the stored agent upload state when updating metadata", async () => {
+ const agentUpload = {
+ state: "accepted",
+ rawFileKey: `${ownerId}/${videoId}/verified-upload-abc.mp4`,
+ };
+ mocks.selectWhere.mockResolvedValue([
+ { ...video, metadata: { sourceName: "a.mp4", agentUpload } },
+ ]);
+
+ const response = await put({
+ sourceName: "b.mp4",
+ agentUpload: { state: "accepted", rawFileKey: "other/key.mp4" },
+ });
+
+ expect(response.status).toBe(200);
+ expect(mocks.updateSet).toHaveBeenCalledWith({
+ metadata: { sourceName: "b.mp4", agentUpload },
+ });
+ });
+
+ it("does not add an agent upload state from the request", async () => {
+ mocks.selectWhere.mockResolvedValue([{ ...video, metadata: null }]);
+
+ const response = await put({
+ customCreatedAt: "2026-01-01T00:00:00.000Z",
+ agentUpload: { state: "accepted", rawFileKey: "other/key.mp4" },
+ });
+
+ expect(response.status).toBe(200);
+ expect(mocks.updateSet).toHaveBeenCalledWith({
+ metadata: { customCreatedAt: "2026-01-01T00:00:00.000Z" },
+ });
+ });
+
+ it("rejects metadata that is not an object", async () => {
+ mocks.selectWhere.mockResolvedValue([{ ...video, metadata: null }]);
+
+ const response = await put(["not", "an", "object"]);
+
+ expect(response.status).toBe(400);
+ expect(mocks.updateSet).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/web/actions/video/trigger-processing.ts b/apps/web/actions/video/trigger-processing.ts
index ed6ed5df9..ca48badff 100644
--- a/apps/web/actions/video/trigger-processing.ts
+++ b/apps/web/actions/video/trigger-processing.ts
@@ -10,6 +10,7 @@ import { Effect, Schedule } from "effect";
import { runPromise } from "@/lib/server";
import { startVideoProcessingWorkflow } from "@/lib/video-processing";
import { decodeStorageVideo } from "@/lib/video-storage";
+import { isVideoStorageKey } from "@/lib/video-storage-key";
async function verifyRawFileUploaded(
video: typeof videos.$inferSelect,
@@ -49,6 +50,12 @@ export async function triggerVideoProcessing({
if (!video) throw new Error("Video not found");
if (video.ownerId !== user.id) throw new Error("Unauthorized");
+ if (!isVideoStorageKey(video, rawFileKey)) {
+ throw new Error("Upload file does not belong to this video");
+ }
+ if ((video.bucket ?? null) !== (bucketId ?? null)) {
+ throw new Error("Upload bucket does not match this video");
+ }
await verifyRawFileUploaded(video, rawFileKey);
diff --git a/apps/web/app/api/v1/[...route]/route.ts b/apps/web/app/api/v1/[...route]/route.ts
index 5e889e3c4..aa3ccf2aa 100644
--- a/apps/web/app/api/v1/[...route]/route.ts
+++ b/apps/web/app/api/v1/[...route]/route.ts
@@ -128,6 +128,7 @@ import { normalizePlaybackSpeed } from "@/lib/playback-speed";
import { isRateLimited, RATE_LIMIT_IDS } from "@/lib/rate-limit";
import { transcribeVideo } from "@/lib/transcribe";
import { startVideoProcessingWorkflow } from "@/lib/video-processing";
+import { isVideoStorageKey } from "@/lib/video-storage-key";
import { isAiGenerationEnabled } from "@/utils/flags";
import {
calculateProSeats,
@@ -7038,6 +7039,17 @@ const AgentManagementHandlersLive = HttpApiBuilder.group(
"The upload completion state is unavailable",
);
}
+ if (
+ !isVideoStorageKey(
+ { id: path.id, ownerId: principal.id },
+ acceptedRawFileKey,
+ )
+ ) {
+ return yield* badRequest(
+ requestId,
+ "Upload completion is invalid",
+ );
+ }
if (payload.rawFileKey !== acceptedRawFileKey) {
yield* deleteStoredKeyIfPresent(payload.rawFileKey);
}
@@ -7094,6 +7106,17 @@ const AgentManagementHandlersLive = HttpApiBuilder.group(
};
},
});
+ if (
+ !isVideoStorageKey(
+ { id: state.id, ownerId: state.ownerId },
+ state.rawFileKey,
+ )
+ ) {
+ return yield* badRequest(
+ requestId,
+ "Upload completion is invalid",
+ );
+ }
const processing = yield* Effect.tryPromise(() =>
startVideoProcessingWorkflow({
videoId: state.id,
diff --git a/apps/web/app/api/video/metadata/route.ts b/apps/web/app/api/video/metadata/route.ts
index 38c5ae9be..1c9506674 100644
--- a/apps/web/app/api/video/metadata/route.ts
+++ b/apps/web/app/api/video/metadata/route.ts
@@ -30,10 +30,19 @@ export async function PUT(request: NextRequest) {
return Response.json({ error: true }, { status: 401 });
}
+ if (typeof metadata !== "object" || Array.isArray(metadata)) {
+ return Response.json({ error: true }, { status: 400 });
+ }
+
+ const { agentUpload: _agentUpload, ...clientMetadata } = metadata;
+ const storedAgentUpload = result.metadata?.agentUpload;
+
await db()
.update(videos)
.set({
- metadata: metadata,
+ metadata: storedAgentUpload
+ ? { ...clientMetadata, agentUpload: storedAgentUpload }
+ : clientMetadata,
})
.where(eq(videos.id, videoId));
diff --git a/apps/web/lib/video-storage-key.ts b/apps/web/lib/video-storage-key.ts
new file mode 100644
index 000000000..6d22be47d
--- /dev/null
+++ b/apps/web/lib/video-storage-key.ts
@@ -0,0 +1,12 @@
+export function isVideoStorageKey(
+ video: { id: string; ownerId: string },
+ key: string,
+) {
+ return (
+ key.startsWith(`${video.ownerId}/${video.id}/`) &&
+ !key.includes("\\") &&
+ key
+ .split("/")
+ .every((part) => part.length > 0 && part !== "." && part !== "..")
+ );
+}