Files
0pt/tests/auth/workload-identity-dual-accept.test.ts
T

152 lines
6.7 KiB
TypeScript

/**
* Dual-accept workload identity: the machine routes accept EITHER the legacy
* shared `X-Internal-Token` (server-configured single-tenant scope) OR a
* verified CL0UD workload JWT (tenant + capabilities from verified claims
* only). These tests pin the security properties that make that safe:
*
* - a client-supplied `x-0pt-verified-*` header can never authorize
* anything (it is stripped before the handler sees it);
* - an ambiguous legacy scope is refused instead of silently widening;
* - a workload token for tenant A cannot write tenant B's facts;
* - a workload token without the required capability is denied.
*/
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { NextRequest } from 'next/server';
import { SignJWT, generateKeyPair } from 'jose';
import { middleware } from '../../middleware';
import { assertTenantMatchesVerified, assertWorkloadCapabilities } from '../../src/http/tenant-guard';
import { __resetWorkloadJwksCache, __setWorkloadKeyResolverForTests } from '../../src/auth/cl0ud-workload';
import { SERVICE_CAPABILITIES_HEADER, SERVICE_TENANT_SCOPE_HEADER } from '../../src/auth/internal-service-tenant';
const ISSUER = 'https://cl0ud.siax.io';
const TENANT_A = '379976258701823235';
const TENANT_B = '999999999999999999';
function req(path: string, headers: Record<string, string> = {}): NextRequest {
return new NextRequest(new URL(path, 'http://localhost'), { headers });
}
let privateKey: CryptoKey;
let publicKey: CryptoKey;
beforeEach(async () => {
const pair = await generateKeyPair('RS256');
privateKey = pair.privateKey as CryptoKey;
publicKey = pair.publicKey as CryptoKey;
__setWorkloadKeyResolverForTests(async () => publicKey);
});
afterEach(() => {
__resetWorkloadJwksCache();
for (const key of ['INTERNAL_TOKEN', 'INTERNAL_SERVICE_TENANTS', 'CL0UD_WORKLOAD_ISSUER', 'CL0UD_WORKLOAD_AUDIENCE', 'AUTH_ENFORCE']) {
delete process.env[key];
}
});
async function workloadToken(claims: Record<string, unknown>, audience = '0pt'): Promise<string> {
return await new SignJWT(claims)
.setProtectedHeader({ alg: 'RS256' })
.setIssuer(ISSUER)
.setAudience(audience)
.setSubject('svc-0pt-worker')
.setIssuedAt()
.setExpirationTime('5m')
.sign(privateKey);
}
describe('middleware: legacy internal token scope', () => {
beforeEach(() => {
process.env.INTERNAL_TOKEN = 'engine-shared-secret';
delete process.env.CL0UD_WORKLOAD_ISSUER;
});
it('single configured tenant becomes the verified tenant and the service scope', async () => {
process.env.INTERNAL_SERVICE_TENANTS = TENANT_A;
const res = await middleware(req('/api/0pt/canonical/facts', { 'x-internal-token': 'engine-shared-secret' }));
expect(res.status).toBe(200);
expect(res.headers.get('x-middleware-request-x-0pt-verified-tenant')).toBe(TENANT_A);
expect(res.headers.get(`x-middleware-request-${SERVICE_TENANT_SCOPE_HEADER}`)).toBe(TENANT_A);
});
it('an ambiguous multi-tenant scope is refused, not widened', async () => {
process.env.INTERNAL_SERVICE_TENANTS = `${TENANT_A},${TENANT_B}`;
const res = await middleware(req('/api/0pt/canonical/facts', { 'x-internal-token': 'engine-shared-secret' }));
expect(res.status).toBe(401);
expect((await res.json()).error).toBe('OPT_UNAUTHENTICATED');
});
it('forged client-supplied verified headers are stripped', async () => {
process.env.INTERNAL_SERVICE_TENANTS = TENANT_A;
const res = await middleware(
req('/api/0pt/canonical/facts', {
'x-internal-token': 'engine-shared-secret',
'x-0pt-verified-tenant': TENANT_B,
[SERVICE_TENANT_SCOPE_HEADER]: TENANT_B,
}),
);
expect(res.status).toBe(200);
expect(res.headers.get('x-middleware-request-x-0pt-verified-tenant')).toBe(TENANT_A);
expect(res.headers.get(`x-middleware-request-${SERVICE_TENANT_SCOPE_HEADER}`)).toBe(TENANT_A);
});
});
describe('middleware: CL0UD workload token (dual-accept)', () => {
beforeEach(() => {
process.env.CL0UD_WORKLOAD_ISSUER = ISSUER;
process.env.CL0UD_WORKLOAD_AUDIENCE = '0pt';
delete process.env.INTERNAL_TOKEN;
});
it('derives tenant and capabilities from verified claims', async () => {
const token = await workloadToken({ tenant_id: TENANT_A, capabilities: ['0pt.canonical.write'] });
const res = await middleware(req('/api/0pt/canonical/facts', { authorization: `Bearer ${token}` }));
expect(res.status).toBe(200);
expect(res.headers.get('x-middleware-request-x-0pt-verified-tenant')).toBe(TENANT_A);
expect(res.headers.get(`x-middleware-request-${SERVICE_CAPABILITIES_HEADER}`)).toBe('0pt.canonical.write');
});
it('rejects a token with the wrong audience', async () => {
const token = await workloadToken({ tenant_id: TENANT_A, capabilities: ['0pt.canonical.write'] }, 'n0d');
const res = await middleware(req('/api/0pt/canonical/facts', { authorization: `Bearer ${token}` }));
expect(res.status).toBe(401);
});
it('rejects a token that carries no tenant claim', async () => {
const token = await workloadToken({ capabilities: ['0pt.canonical.write'] });
const res = await middleware(req('/api/0pt/canonical/facts', { authorization: `Bearer ${token}` }));
expect(res.status).toBe(401);
});
it('ignores forged verified headers on the workload path too', async () => {
const token = await workloadToken({ tenant_id: TENANT_A, capabilities: ['0pt.canonical.write'] });
const res = await middleware(
req('/api/0pt/canonical/facts', {
authorization: `Bearer ${token}`,
'x-0pt-verified-tenant': TENANT_B,
}),
);
expect(res.headers.get('x-middleware-request-x-0pt-verified-tenant')).toBe(TENANT_A);
});
});
describe('tenant guard: scope and capability enforcement', () => {
it('denies a write for a tenant outside the service scope', () => {
const request = req('/api/0pt/canonical/facts', { [SERVICE_TENANT_SCOPE_HEADER]: TENANT_A });
expect(assertTenantMatchesVerified(request, TENANT_A)).toBeNull();
const denied = assertTenantMatchesVerified(request, TENANT_B);
expect(denied?.status).toBe(403);
});
it('denies a tenant that disagrees with a verified workload tenant', () => {
const request = req('/api/0pt/canonical/facts', { 'x-0pt-verified-tenant': TENANT_A });
expect(assertTenantMatchesVerified(request, TENANT_A)).toBeNull();
expect(assertTenantMatchesVerified(request, TENANT_B)?.status).toBe(403);
});
it('denies a missing capability on a capability-scoped principal', () => {
const request = req('/api/0pt/canonical/facts', { [SERVICE_CAPABILITIES_HEADER]: '0pt.canonical.read' });
expect(assertWorkloadCapabilities(request, ['0pt.canonical.write'])?.status).toBe(403);
expect(assertWorkloadCapabilities(request, ['0pt.canonical.read'])).toBeNull();
});
});