Skip to content

Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure

TypeScript

fix(gfs): preserve upload authorization metadata

Alfredo Lopezcf2509b5964e
diff --git a/control-api/test/routes.externalGfs.test.ts b/control-api/test/routes.externalGfs.test.ts
index f6a2838a7..41f1eba7b 100644
--- a/control-api/test/routes.externalGfs.test.ts
+++ b/control-api/test/routes.externalGfs.test.ts
@@ -739,7 +739,6 @@ describe('indexed upload relay canonical drive', () => {
)
vi.stubGlobal('fetch', fetchMock)
const app = await buildApp()
- const nested = (app as any)._router?.stack?.find((layer: any) => layer.name === 'router')
const missing = await request(app)
.get('/external/gfs/capabilities')
@@ -749,7 +748,6 @@ describe('indexed upload relay canonical drive', () => {
.set('x-user-session-token', 'sess')
.send({ drive: 'main', operation: 'create' })
-
expect(missing.status).toBe(200)
expect(missing.body).toMatchObject({ upload: { resumableV2: { enabled: true } } })
expect(mismatched.status).toBe(400)
diff --git a/gfs-controller/src/api/serve.test.ts b/gfs-controller/src/api/serve.test.ts
index 81facc298..46ddf9b52 100644
--- a/gfs-controller/src/api/serve.test.ts
+++ b/gfs-controller/src/api/serve.test.ts
@@ -213,6 +213,70 @@ function uploadDeps(over: Partial<ServingDeps> = {}): ServingDeps {
}
describe("GFS Upload v2 route contract", () => {
+ it("preserves signed authority metadata for the upload service reauthorization", async () => {
+ const desktopUserId = "11111111-1111-4111-8111-111111111111";
+ const controlAdminId = "22222222-2222-4222-8222-222222222222";
+ const brokeredAuthority = {
+ desktopUserId,
+ controlAdminId,
+ authoritySource: "linked-admin" as const,
+ linkLineageId: "33333333-3333-4333-8333-333333333333",
+ linkGeneration: 2,
+ desktopUserGeneration: 4,
+ };
+ const claims: GfsVerifiedClaims = {
+ ...USER_WRITE_CLAIMS,
+ sub: controlAdminId,
+ authGeneration: 7,
+ principalType: "control-admin",
+ brokeredAuthority,
+ };
+ const context: AuthzContext = {
+ ...CTX,
+ primarySubject: controlAdminId,
+ effectiveControlAdminId: controlAdminId,
+ desktopUserId,
+ authoritySource: "linked-admin",
+ };
+ let received: Record<string, unknown> | undefined;
+ const service = {
+ ...uploadDeps().uploadService,
+ create: async (input: Record<string, unknown>) => {
+ received = input;
+ return { created: true, session: UPLOAD_SESSION };
+ },
+ } as ServingDeps["uploadService"];
+ const res = new FakeRes();
+ await run(
+ uploadDeps({
+ verifyToken: () => claims,
+ resolveContext: async () => context,
+ uploadService: service,
+ }),
+ reqBody("/v1/uploads", {
+ method: "POST",
+ auth: "Bearer t",
+ body: {
+ operation: "create",
+ parentRid: RID,
+ name: "payload.bin",
+ sizeBytes: 4,
+ idempotencyKey: UPLOAD_ID,
+ },
+ }),
+ res,
+ );
+ expect(res.statusCode).toBe(201);
+ expect(received).toMatchObject({
+ drive: "main",
+ ownerSubject: controlAdminId,
+ primarySubject: controlAdminId,
+ authGeneration: 7,
+ principalType: "control-admin",
+ brokeredAuthority,
+ });
+ });
+
it("creates a session with a Location and writer authorization", async () => {
const res = new FakeRes();
const authorize = async () => ({ allowed: true });
diff --git a/gfs-controller/src/api/serve.ts b/gfs-controller/src/api/serve.ts
index 4b9cd1537..cf66b13c0 100644
--- a/gfs-controller/src/api/serve.ts
+++ b/gfs-controller/src/api/serve.ts
@@ -383,7 +383,14 @@ export class GfsServingHandler {
): Promise<void> {
const service = this.deps.uploadService;
if (!service) throw new GfsError("not_mounted", "upload session service is unavailable");
- const principal: UploadPrincipal = { drive: claims.drive, ownerSubject: claims.sub, primarySubject: ctx.primarySubject };
+ const principal: UploadPrincipal = {
+ drive: claims.drive,
+ ownerSubject: claims.sub,
+ primarySubject: ctx.primarySubject,
+ ...(claims.authGeneration === undefined ? {} : { authGeneration: claims.authGeneration }),
+ ...(claims.principalType ? { principalType: claims.principalType } : {}),
+ ...(claims.brokeredAuthority ? { brokeredAuthority: claims.brokeredAuthority } : {}),
+ };
// Session DELETE is a cancel action, not deletion of the GFS resource; the
// session's original write authority governs it just like pause/resume.
const sessionPermission: GfsPermission = "write";
diff --git a/gfs-controller/src/index.ts b/gfs-controller/src/index.ts
index 5e2e80e81..58e38bc08 100644
--- a/gfs-controller/src/index.ts
+++ b/gfs-controller/src/index.ts
@@ -243,6 +243,13 @@ async function main(): Promise<void> {
const targetContext = await resolveAuthzContext(pool, {
sub: principal.ownerSubject,
drive: principal.drive,
+ ...(principal.authGeneration === undefined
+ ? {}
+ : { authGeneration: principal.authGeneration }),
+ ...(principal.principalType ? { principalType: principal.principalType } : {}),
+ ...(principal.brokeredAuthority
+ ? { brokeredAuthority: principal.brokeredAuthority }
+ : {}),
});
const decision = await permissions.authorize(targetContext, targetRid, "write");
if (!decision.allowed) throw new GfsError("forbidden", `not authorized to ${operation} upload`);
diff --git a/gfs-controller/src/upload/uploadFinalizer.ts b/gfs-controller/src/upload/uploadFinalizer.ts
index a25009c6f..772705968 100644
--- a/gfs-controller/src/upload/uploadFinalizer.ts
+++ b/gfs-controller/src/upload/uploadFinalizer.ts
@@ -9,7 +9,7 @@ import type { GfsResource } from '../api/read'
import type { DbAuditSink, PermissionClient } from '../authz/permissionClient'
import { resolveAuthzContext } from '../authz/subjectResolver'
import { GfsWriteService, type TxClient } from '../db/writeStore'
-import type { UploadPartRow, UploadSessionRow } from './uploadSession'
+import type { UploadPartRow, UploadPrincipal, UploadSessionRow } from './uploadSession'
function orderedUploadStream(
storageMountPath: string,
@@ -82,9 +82,10 @@ export function createGfsUploadFinalizer(
session: UploadSessionRow,
parts: UploadPartRow[],
signal?: AbortSignal,
- deadlineAtMs?: number
+ deadlineAtMs?: number,
+ principal?: UploadPrincipal
) => Promise<{ resourceId: string; version: number; sha256: string }> {
- return async (session, parts, signal, deadlineAtMs) => {
+ return async (session, parts, signal, deadlineAtMs, principal) => {
const capturedPermissionEpoch = deps.permissions.permissionEpoch()
const source = {
stream: orderedUploadStream(deps.storageMountPath, parts, signal),
@@ -118,9 +119,23 @@ export function createGfsUploadFinalizer(
}
const targetRid = session.operation === 'create' ? session.parentRid : session.resourceRid
if (!targetRid) throw new GfsError('path_invalid', 'upload target is required')
- const targetContext = await resolveAuthzContext(deps.pool, {
- sub: session.ownerSubject,
+ const reauthorizationPrincipal = principal ?? {
drive: session.drive,
+ ownerSubject: session.ownerSubject,
+ primarySubject: session.primarySubject,
+ }
+ const targetContext = await resolveAuthzContext(deps.pool, {
+ sub: reauthorizationPrincipal.ownerSubject,
+ drive: reauthorizationPrincipal.drive,
+ ...(reauthorizationPrincipal.authGeneration === undefined
+ ? {}
+ : { authGeneration: reauthorizationPrincipal.authGeneration }),
+ ...(reauthorizationPrincipal.principalType
+ ? { principalType: reauthorizationPrincipal.principalType }
+ : {}),
+ ...(reauthorizationPrincipal.brokeredAuthority
+ ? { brokeredAuthority: reauthorizationPrincipal.brokeredAuthority }
+ : {}),
})
const decision = await deps.permissions.authorize(targetContext, targetRid, 'write')
publicationSignal?.throwIfAborted()
diff --git a/gfs-controller/src/upload/uploadSession.ts b/gfs-controller/src/upload/uploadSession.ts
index 16763e625..d7b4a802f 100644
--- a/gfs-controller/src/upload/uploadSession.ts
+++ b/gfs-controller/src/upload/uploadSession.ts
@@ -11,6 +11,7 @@ import type { GfsUploadConfig } from '../config'
import { CommitOutcomeUnknownError, RollbackOutcomeUnknownError } from '../db/writeStore'
import type { BlobWriter, Transactor, TxClient } from '../db/writeStore'
import { PathError, normalizeResourceId } from '../storage/paths'
+import type { GfsBrokeredAuthority } from '../auth/verify'
import {
GFS_UPLOAD_V2_COMPLETE_BODY_MAX_BYTES,
GFS_UPLOAD_V2_METADATA_BODY_MAX_BYTES,
@@ -33,6 +34,10 @@ export interface UploadPrincipal {
drive: string
ownerSubject: string
primarySubject: string
+ /** Signed authority metadata must survive every check-time reauthorization. */
+ authGeneration?: number
+ principalType?: 'user' | 'control-admin'
+ brokeredAuthority?: GfsBrokeredAuthority
}
export interface CreateUploadSessionInput extends UploadPrincipal {
@@ -97,7 +102,8 @@ export interface UploadSessionServiceDeps {
session: UploadSessionRow,
parts: UploadPartRow[],
signal?: AbortSignal,
- deadlineAtMs?: number
+ deadlineAtMs?: number,
+ principal?: UploadPrincipal
) => Promise<{ resourceId: string; version: number; sha256: string }>
}
@@ -1644,7 +1650,8 @@ export class GfsUploadSessionService {
started,
started.parts,
finalizationAbort.signal,
- finalizationDeadlineAtMs
+ finalizationDeadlineAtMs,
+ principal
)
} catch (error) {
const failureCode = error instanceof GfsError ? error.code : 'finalization_failed'