feat(api,proxy,daemon,sdk): pre-signed file download/upload URLs with key rotation across all SDKs

Signed-off-by: MDzaja <mirkodzaja0@gmail.com>

Author: MDzaja

.vscode/settings.json

@@ -2,5 +2,7 @@
   "files.watcherExclude": {
     "**/libs/*api-client*/**": true,
     "**/node_modules/**": true
-  }
+  },
+  "python-envs.defaultEnvManager": "ms-python.python:poetry",
+  "python-envs.defaultPackageManager": "ms-python.python:poetry"
 }

apps/api/src/audit/enums/audit-action.enum.ts

@@ -31,6 +31,7 @@ export enum AuditAction {
   REPLACE_LABELS = 'replace_labels',
   CREATE_BACKUP = 'create_backup',
   UPDATE_PUBLIC_STATUS = 'update_public_status',
+  ROTATE_SIGNING_KEY = 'rotate_signing_key',
   SET_AUTO_STOP_INTERVAL = 'set_auto_stop_interval',
   SET_AUTO_ARCHIVE_INTERVAL = 'set_auto_archive_interval',
   SET_AUTO_DELETE_INTERVAL = 'set_auto_delete_interval',

apps/api/src/migrations/pre-deploy/1781308800000-migration.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: AGPL-3.0
+ */
+
+import { MigrationInterface, QueryRunner } from 'typeorm'
+
+export class Migration1781308800000 implements MigrationInterface {
+  name = 'Migration1781308800000'
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE "sandbox_metadata" ("sandboxId" character varying NOT NULL, "signingKey" character varying NOT NULL, CONSTRAINT "PK_sandbox_metadata" PRIMARY KEY ("sandboxId"))`,
+    )
+    await queryRunner.query(
+      `ALTER TABLE "sandbox_metadata" ADD CONSTRAINT "FK_sandbox_metadata_sandbox" FOREIGN KEY ("sandboxId") REFERENCES "sandbox"("id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    )
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "sandbox_metadata" DROP CONSTRAINT "FK_sandbox_metadata_sandbox"`)
+    await queryRunner.query(`DROP TABLE "sandbox_metadata"`)
+  }
+}

apps/api/src/sandbox/controllers/preview.controller.auth.spec.ts

@@ -47,4 +47,11 @@ describe('[AUTH] PreviewController', () => {
     expectArrayMatch(getAllowedAuthStrategies(PreviewController, methodName), [AuthStrategyType.API_KEY])
     expectArrayMatch(getAuthContextGuards(PreviewController, methodName), [ProxyAuthContextGuard])
   })
+
+  it('getSigningKey', () => {
+    const methodName = trackMethod('getSigningKey')
+    expect(isPublicEndpoint(PreviewController, methodName)).toBe(false)
+    expectArrayMatch(getAllowedAuthStrategies(PreviewController, methodName), [AuthStrategyType.API_KEY])
+    expectArrayMatch(getAuthContextGuards(PreviewController, methodName), [ProxyAuthContextGuard])
+  })
 })

apps/api/src/sandbox/controllers/preview.controller.ts

@@ -124,6 +124,27 @@ export class PreviewController {
     throw new NotFoundException(`Sandbox with ID ${sandboxId} not found`)
   }
 
+  @Get(':sandboxId/signing-key')
+  @ApiOperation({
+    summary: 'Get the signing key for a sandbox',
+    operationId: 'getSigningKey',
+  })
+  @ApiParam({
+    name: 'sandboxId',
+    description: 'ID of the sandbox',
+    type: 'string',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Signing key of the sandbox',
+    type: String,
+  })
+  @AuthStrategy(AuthStrategyType.API_KEY)
+  @UseGuards(ProxyAuthContextGuard)
+  async getSigningKey(@Param('sandboxId') sandboxId: string): Promise<string> {
+    return this.sandboxService.getSigningKey(sandboxId)
+  }
+
   @Get(':sandboxId/access')
   @ApiOperation({
     summary: 'Check if user has access to the sandbox',

apps/api/src/sandbox/controllers/sandbox.controller.auth.spec.ts

@@ -320,6 +320,34 @@ describe('[AUTH] SandboxController', () => {
     expect(getRequiredOrganizationResourcePermissions(SandboxController, methodName)).toBeUndefined()
   })
 
+  it('getSandboxSigningKey', () => {
+    const methodName = trackMethod('getSandboxSigningKey')
+    expect(isPublicEndpoint(SandboxController, methodName)).toBe(false)
+    expectArrayMatch(getAllowedAuthStrategies(SandboxController, methodName), [
+      AuthStrategyType.API_KEY,
+      AuthStrategyType.JWT,
+    ])
+    expectArrayMatch(getAuthContextGuards(SandboxController, methodName), [OrganizationAuthContextGuard])
+    expectArrayMatch(getResourceAccessGuards(SandboxController, methodName), [SandboxAccessGuard])
+    expect(getRequiredOrganizationMemberRole(SandboxController, methodName)).toBeUndefined()
+    expect(getRequiredOrganizationResourcePermissions(SandboxController, methodName)).toBeUndefined()
+  })
+
+  it('rotateSigningKey', () => {
+    const methodName = trackMethod('rotateSigningKey')
+    expect(isPublicEndpoint(SandboxController, methodName)).toBe(false)
+    expectArrayMatch(getAllowedAuthStrategies(SandboxController, methodName), [
+      AuthStrategyType.API_KEY,
+      AuthStrategyType.JWT,
+    ])
+    expectArrayMatch(getAuthContextGuards(SandboxController, methodName), [OrganizationAuthContextGuard])
+    expectArrayMatch(getResourceAccessGuards(SandboxController, methodName), [SandboxAccessGuard])
+    expect(getRequiredOrganizationMemberRole(SandboxController, methodName)).toBeUndefined()
+    expectArrayMatch(getRequiredOrganizationResourcePermissions(SandboxController, methodName), [
+      OrganizationResourcePermission.WRITE_SANDBOXES,
+    ])
+  })
+
   it('getSignedPortPreviewUrl', () => {
     const methodName = trackMethod('getSignedPortPreviewUrl')
     expect(isPublicEndpoint(SandboxController, methodName)).toBe(false)

apps/api/src/sandbox/controllers/sandbox.controller.ts

@@ -875,6 +875,52 @@ export class SandboxController {
     return this.sandboxService.toSandboxDto(sandbox)
   }
 
+  @Get(':sandboxId/signing-key')
+  @ApiOperation({
+    summary: 'Get the signing key for a sandbox',
+    operationId: 'getSandboxSigningKey',
+  })
+  @ApiParam({
+    name: 'sandboxId',
+    description: 'ID of the sandbox',
+    type: 'string',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Signing key of the sandbox',
+    type: String,
+  })
+  @UseGuards(OrganizationAuthContextGuard, SandboxAccessGuard)
+  async getSandboxSigningKey(@Param('sandboxId') sandboxId: string): Promise<string> {
+    return this.sandboxService.getSigningKey(sandboxId)
+  }
+
+  @Post(':sandboxId/signing-key/rotate')
+  @ApiOperation({
+    summary: 'Rotate the signing key, invalidating all previously signed URLs',
+    operationId: 'rotateSigningKey',
+  })
+  @ApiParam({
+    name: 'sandboxId',
+    description: 'ID of the sandbox',
+    type: 'string',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'New signing key',
+    type: String,
+  })
+  @UseGuards(OrganizationAuthContextGuard, SandboxAccessGuard)
+  @RequiredOrganizationResourcePermissions([OrganizationResourcePermission.WRITE_SANDBOXES])
+  @Audit({
+    action: AuditAction.ROTATE_SIGNING_KEY,
+    targetType: AuditTarget.SANDBOX,
+    targetIdFromRequest: (req) => req.params.sandboxId,
+  })
+  async rotateSigningKey(@Param('sandboxId') sandboxId: string): Promise<string> {
+    return this.sandboxService.rotateSigningKey(sandboxId)
+  }
+
   @Post(':sandboxId/last-activity')
   @ApiOperation({
     summary: 'Update sandbox last activity',

apps/api/src/sandbox/entities/sandbox-metadata.entity.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright Daytona Platforms Inc.
+ * SPDX-License-Identifier: AGPL-3.0
+ */
+
+import { Column, Entity, JoinColumn, OneToOne, PrimaryColumn } from 'typeorm'
+import { nanoid } from 'nanoid'
+import { Sandbox } from './sandbox.entity'
+
+@Entity('sandbox_metadata')
+export class SandboxMetadata {
+  @PrimaryColumn()
+  sandboxId: string
+
+  // General-purpose HMAC key for signed sandbox URLs (currently pre-signed file
+  // URLs). Stable across start/stop so signatures survive restarts; rotated only
+  // via the dedicated rotate endpoint, which invalidates every prior signature.
+  // Each signing purpose MUST use a distinct domain label in its canonical string
+  // (e.g. "v1:files:...") so signatures can never be replayed across purposes.
+  @Column({ type: 'character varying' })
+  signingKey: string = nanoid(32)
+
+  @OneToOne(() => Sandbox, { onDelete: 'CASCADE' })
+  @JoinColumn({ name: 'sandboxId' })
+  sandbox?: Sandbox
+}

apps/api/src/sandbox/sandbox.module.ts

@@ -58,6 +58,7 @@ import { ProxyAuthContextGuard } from './guards/proxy-auth-context.guard'
 import { SshGatewayAuthContextGuard } from './guards/ssh-gateway-auth-context.guard'
 import { EventEmitter2 } from '@nestjs/event-emitter'
 import { SandboxLastActivity } from './entities/sandbox-last-activity.entity'
+import { SandboxMetadata } from './entities/sandbox-metadata.entity'
 import { SandboxActivityService } from './services/sandbox-activity.service'
 import { OpensearchModule } from 'nestjs-opensearch'
 import { TypedConfigService } from '../config/typed-config.service'
@@ -84,6 +85,7 @@ import { SandboxSearchAdapterProvider } from './providers/sandbox-search.provide
       Job,
       SandboxLastActivity,
       SandboxFork,
+      SandboxMetadata,
     ]),
     OpensearchModule.forRootAsync({
       inject: [TypedConfigService],

apps/api/src/sandbox/services/sandbox.service.ts

@@ -17,6 +17,7 @@ import { InjectRepository } from '@nestjs/typeorm'
 import { Not, Repository, LessThan, In, JsonContains, FindOptionsWhere, ILike } from 'typeorm'
 import { Sandbox } from '../entities/sandbox.entity'
 import { SandboxFork } from '../entities/sandbox-fork.entity'
+import { SandboxMetadata } from '../entities/sandbox-metadata.entity'
 import { CreateSandboxDto } from '../dto/create-sandbox.dto'
 import { CreateSandboxSnapshotDto } from '../dto/create-sandbox-snapshot.dto'
 import { ForkSandboxDto } from '../dto/fork-sandbox.dto'
@@ -153,6 +154,8 @@ export class SandboxService {
     private readonly dockerRegistryService: DockerRegistryService,
     @InjectRepository(SandboxFork)
     private readonly sandboxForkRepository: Repository<SandboxFork>,
+    @InjectRepository(SandboxMetadata)
+    private readonly sandboxMetadataRepository: Repository<SandboxMetadata>,
     @Inject(SANDBOX_SEARCH_ADAPTER)
     private readonly sandboxSearchAdapter: SandboxSearchAdapter,
   ) {}
@@ -2615,6 +2618,51 @@ export class SandboxService {
     })
   }
 
+  private async ensureMetadata(sandboxId: string): Promise<SandboxMetadata> {
+    const existing = await this.sandboxMetadataRepository.findOne({ where: { sandboxId } })
+    if (existing) {
+      return existing
+    }
+
+    // ON CONFLICT do nothing to avoid race conditions on sandbox creation where multiple requests
+    // may attempt to create metadata for the same sandbox
+    await this.sandboxMetadataRepository
+      .createQueryBuilder()
+      .insert()
+      .into(SandboxMetadata)
+      .values({
+        sandboxId,
+        signingKey: nanoid(32),
+      })
+      .orIgnore()
+      .execute()
+
+    return this.sandboxMetadataRepository.findOneOrFail({ where: { sandboxId } })
+  }
+
+  async getSigningKey(sandboxId: string): Promise<string> {
+    const cacheKey = `signing-key:${sandboxId}`
+    const cached = await this.redis.get(cacheKey)
+    if (cached) {
+      return cached
+    }
+
+    const metadata = await this.ensureMetadata(sandboxId)
+    await this.redis.setex(cacheKey, 300, metadata.signingKey)
+    return metadata.signingKey
+  }
+
+  async rotateSigningKey(sandboxId: string): Promise<string> {
+    await this.ensureMetadata(sandboxId)
+    const newKey = nanoid(32)
+    await this.sandboxMetadataRepository.update(sandboxId, { signingKey: newKey })
+    // Write-through (not delete): a concurrent getSigningKey that read the old key from the
+    // DB before this update could otherwise re-cache it after a plain delete, pinning a stale
+    // key for the full TTL. Overwriting with the new key closes that rotation race window.
+    await this.redis.setex(`signing-key:${sandboxId}`, 300, newKey)
+    return newKey
+  }
+
   async updateLastActivityAt(sandboxId: string, lastActivityAt: Date): Promise<void> {
     await this.sandboxActivityService.updateLastActivityAt(sandboxId, lastActivityAt)
   }