diff --git a/.gitea/workflows/stage-test-principal.yml b/.gitea/workflows/stage-test-principal.yml new file mode 100644 index 00000000..d4041fb4 --- /dev/null +++ b/.gitea/workflows/stage-test-principal.yml @@ -0,0 +1,41 @@ +name: Owner authorized Stage test principal +on: + workflow_dispatch: + inputs: + approval: + required: true + description: "Exact owner grant: owner-authorized-stage-editorial" + session: + required: true + description: "Unique session (8-64 lowercase letters/digits/hyphens)" + ttl: + required: true + description: "Bounded session TTL, 60-3600 seconds" + action: + required: true + description: "open or close" +jobs: + principal: + if: github.ref == 'refs/heads/develop' + runs-on: canina + steps: + - name: Explicit authenticated Stage CI seed authority + shell: bash + env: + BRANCH: ${{ github.ref_name }} + DEPLOY_SHA: ${{ github.sha }} + DEPLOY_KEY: ${{ secrets.DEPLOY_KEY }} + DEPLOY_KNOWN_HOSTS: ${{ secrets.DEPLOY_KNOWN_HOSTS }} + STAGE_TEST_APPROVAL: ${{ inputs.approval }} + STAGE_TEST_SESSION: ${{ inputs.session }} + STAGE_TEST_TTL_SECONDS: ${{ inputs.ttl }} + STAGE_TEST_ACTION: ${{ inputs.action }} + run: | + set -euo pipefail + set +x + [[ "$DEPLOY_SHA" =~ ^[a-f0-9]{40}$ ]] || exit 2 + umask 077 + script=$(mktemp) + trap 'rm -f "$script"' EXIT + wget --no-proxy -qO "$script" "https://git.parsaaghayi.ir/parsa/canina/raw/commit/$DEPLOY_SHA/scripts/ci-stage-test-principal.sh" + bash "$script" diff --git a/backend/Dockerfile b/backend/Dockerfile index ae6384d9..960a62a6 100644 --- a/backend/Dockerfile +++ b/backend/Dockerfile @@ -32,8 +32,10 @@ RUN http_proxy=http://172.17.0.1:8888 https_proxy=http://172.17.0.1:8888 \ FROM node:20-alpine USER root RUN http_proxy=http://172.17.0.1:8888 https_proxy=http://172.17.0.1:8888 apk add --no-cache openssl || apk add --no-cache openssl || true -RUN mkdir -p /app/uploads && chown node:node /app/uploads +RUN mkdir -p /app/uploads /app/private-stage-test && chmod 700 /app/private-stage-test && chown node:node /app/uploads /app/private-stage-test WORKDIR /app +ARG STAGE_TEST_ARTIFACT_SHA=disabled +RUN printf "%s" "$STAGE_TEST_ARTIFACT_SHA" > /app/STAGE_TEST_ARTIFACT_SHA ENV PRISMA_HIDE_UPDATE_MESSAGE=true COPY --chown=node:node --from=builder /app/package*.json ./ COPY --chown=node:node --from=builder /app/tsconfig.json ./tsconfig.json diff --git a/backend/prisma/migrations/20261024090000_stage_test_principal/migration.sql b/backend/prisma/migrations/20261024090000_stage_test_principal/migration.sql new file mode 100644 index 00000000..e950ee4d --- /dev/null +++ b/backend/prisma/migrations/20261024090000_stage_test_principal/migration.sql @@ -0,0 +1 @@ +ALTER TABLE "users" ADD COLUMN "auth_expires_at" TIMESTAMPTZ, ADD COLUMN "stage_test_session" VARCHAR(64); diff --git a/backend/prisma/schema.prisma b/backend/prisma/schema.prisma index 39e8dc9d..004262c8 100644 --- a/backend/prisma/schema.prisma +++ b/backend/prisma/schema.prisma @@ -16,6 +16,8 @@ model User { mobile String @unique @db.VarChar(15) password String? @db.VarChar(255) role String @default("User_PetOwner") @db.VarChar(30) + authExpiresAt DateTime? @map("auth_expires_at") @db.Timestamptz() + stageTestSession String? @map("stage_test_session") @db.VarChar(64) walletBalance Decimal @default(0.00) @map("wallet_balance") @db.Decimal(15, 2) charityDonationTotal Decimal @default(0.00) @map("charity_donation_total") @db.Decimal(15, 2) createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz() diff --git a/backend/src/admin/admin.service.ts b/backend/src/admin/admin.service.ts index 487adeb2..f30da005 100644 --- a/backend/src/admin/admin.service.ts +++ b/backend/src/admin/admin.service.ts @@ -63,6 +63,7 @@ export class CouponInput { import { ALLOWED_USER_ROLES, assertUserMutationAllowed } from "./user-role-policy"; import type { UserAdminActor } from "./user-role-policy"; +import { authorizeStageSession, STAGE_TEST_ID, STAGE_TEST_EMAIL, STAGE_TEST_MOBILE } from "../auth/stage-test-principal"; @Injectable() export class AdminService { @@ -237,6 +238,10 @@ export class AdminService { async createUser(dto: CreateUserDto, actor?: UserAdminActor) { assertUserMutationAllowed(actor, undefined, dto.role); + return this.persistUser(dto); + } + + private async persistUser(dto: CreateUserDto, stage?: { session: string; expiresAt: Date }) { const mobile = normalizeMobile(dto.mobile); const existingMobile = await this.prisma.user.findUnique({ where: { mobile }, @@ -269,6 +274,7 @@ export class AdminService { return this.prisma.user.create({ data: { + ...(stage ? { id: STAGE_TEST_ID, stageTestSession: stage.session, authExpiresAt: stage.expiresAt } : {}), firstName: dto.firstName.trim(), lastName: dto.lastName.trim(), mobile, @@ -283,6 +289,28 @@ export class AdminService { }); } + // Explicit CI seed authority, NOT a fabricated SUPER_ADMIN actor. Not controller-exposed. + async provisionStageTestPrincipal(env: NodeJS.ProcessEnv, sha: string, password: string) { + const grant = authorizeStageSession(env, sha); + const existing = await this.prisma.user.findFirst({where:{OR:[{id:STAGE_TEST_ID},{email:STAGE_TEST_EMAIL},{mobile:STAGE_TEST_MOBILE}]}}); + if (existing) { + if (existing.id !== STAGE_TEST_ID || existing.email !== STAGE_TEST_EMAIL || existing.mobile !== STAGE_TEST_MOBILE || existing.stageTestSession !== grant.session || existing.role !== 'SUPER_ADMIN' || !existing.authExpiresAt || existing.authExpiresAt.getTime() <= Date.now() || !await bcrypt.compare(password, existing.password || '')) throw new Error('Refusing existing or unowned principal'); + return existing; // Never renew TTL on retry. + } + if (password.length < 32) throw new Error('Server generated secret required'); + return this.persistUser({firstName:'Stage',lastName:'CI independent reviewer',email:STAGE_TEST_EMAIL,mobile:STAGE_TEST_MOBILE,role:'SUPER_ADMIN',password}, {session:grant.session,expiresAt:new Date(Date.now()+grant.ttl*1000)}); + } + + async cleanupStageTestPrincipal(env: NodeJS.ProcessEnv, sha: string) { + const grant = authorizeStageSession(env, sha); + const existing = await this.prisma.user.findUnique({where:{id:STAGE_TEST_ID}}); + if (!existing) return; + if (existing.email !== STAGE_TEST_EMAIL || existing.mobile !== STAGE_TEST_MOBILE || existing.stageTestSession !== grant.session || !existing.authExpiresAt) throw new Error('Refusing unowned principal cleanup'); + // Revoke before relational cleanup; failed cleanup cannot leave valid tokens. + await this.prisma.user.update({where:{id:STAGE_TEST_ID},data:{authExpiresAt:new Date(0),password:''}}); + return this.deleteUserRecords(STAGE_TEST_ID); + } + async updateUser(id: string, dto: UpdateUserDto, actor?: UserAdminActor) { if (id === "12345678-1234-1234-1234-123456789012") { throw new BadRequestException( @@ -367,6 +395,10 @@ export class AdminService { assertUserMutationAllowed(actor, user.role); + return this.deleteUserRecords(id); + } + + private async deleteUserRecords(id: string) { return this.prisma.$transaction(async (tx) => { await tx.userAddress.deleteMany({ where: { userId: id } }); await tx.walletTransaction.deleteMany({ where: { userId: id } }); diff --git a/backend/src/auth/auth.service.ts b/backend/src/auth/auth.service.ts index 36364b39..39bd1e9d 100644 --- a/backend/src/auth/auth.service.ts +++ b/backend/src/auth/auth.service.ts @@ -14,6 +14,7 @@ import { SmsService } from "../common/services/sms.service"; import * as bcrypt from "bcryptjs"; import * as crypto from "crypto"; import { normalizeMobile } from "../common/utils/phone.utils"; +import { assertPrincipalActive } from "./stage-test-principal"; import { getJwtRefreshSecret } from "./auth.constants"; export class RegisterInput { @@ -200,6 +201,7 @@ export class AuthService { }); } + assertPrincipalActive(user); const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role }; const tokens = await this.generateTokens(payload); @@ -257,6 +259,7 @@ export class AuthService { }, }); + assertPrincipalActive(user); const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role }; const tokens = await this.generateTokens(payload); @@ -300,6 +303,7 @@ export class AuthService { }); } + assertPrincipalActive(user); const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role }; const tokens = await this.generateTokens(payload); @@ -326,6 +330,7 @@ export class AuthService { if (dbAdmin && dbAdmin.password && body.password) { const isMatch = await bcrypt.compare(body.password, dbAdmin.password); if (isMatch) { + assertPrincipalActive(dbAdmin); const payload = { sub: dbAdmin.id, email: dbAdmin.email, @@ -443,6 +448,7 @@ export class AuthService { const user = await this.prisma.user.findUnique({ where: { id: userId } }); if (user) { + assertPrincipalActive(user); userPayload = { sub: user.id, email: user.email, diff --git a/backend/src/auth/jwt.strategy.ts b/backend/src/auth/jwt.strategy.ts index 6465305c..d42a91ce 100644 --- a/backend/src/auth/jwt.strategy.ts +++ b/backend/src/auth/jwt.strategy.ts @@ -2,6 +2,7 @@ import { ExtractJwt, Strategy } from "passport-jwt"; import { PassportStrategy } from "@nestjs/passport"; import { Injectable, UnauthorizedException } from "@nestjs/common"; import { UsersService } from "../users/users.service"; +import { assertPrincipalActive } from "./stage-test-principal"; import { getJwtSecret } from "./auth.constants"; import { RedisService } from "../redis/redis.service"; @@ -59,6 +60,12 @@ export class JwtStrategy extends PassportStrategy(Strategy) { if (!user) { throw new UnauthorizedException("کاربر یافت نشد"); } + try { assertPrincipalActive(user); } catch { throw new UnauthorizedException("Principal expired"); } + if (user.stageTestSession) { + const path = req.originalUrl?.split('?')[0] || ''; + const allowed = req.method === 'GET' && /^\/api\/admin\/orchestration\/tasks(?:\/[a-f0-9-]+)?$/.test(path) || req.method === 'POST' && (/^\/api\/admin\/orchestration\/tasks$/.test(path) || /^\/api\/admin\/orchestration\/tasks\/[a-f0-9-]+\/(?:gates\/1\/decide|editorial-failure)$/.test(path)); + if (!allowed) throw new UnauthorizedException('Stage test scope denied'); + } return user; } } diff --git a/backend/src/auth/stage-test-principal.cli.ts b/backend/src/auth/stage-test-principal.cli.ts new file mode 100644 index 00000000..381c37f0 --- /dev/null +++ b/backend/src/auth/stage-test-principal.cli.ts @@ -0,0 +1,67 @@ +import 'reflect-metadata'; +import { PrismaClient } from '@prisma/client'; +import { randomBytes } from 'crypto'; +import { mkdirSync, openSync, writeFileSync, closeSync, readFileSync, statSync, unlinkSync, constants } from 'fs'; +import { AdminService } from '../admin/admin.service'; +import { authorizeStageSession, STAGE_TEST_EMAIL } from './stage-test-principal'; + +// CI-only internal seed command; deliberately not registered in AppModule. +async function main() { + const sha = readFileSync('/app/STAGE_TEST_ARTIFACT_SHA', 'utf8').trim(); + const grant = authorizeStageSession(process.env, sha); + const action = process.argv[2]; + if (!['open','close'].includes(action)) throw new Error('Unknown command'); + const root = '/app/private-stage-test'; + mkdirSync(root,{recursive:true,mode:0o700}); + const st = statSync(root); + if (st.uid !== process.getuid!() || (st.mode & 0o777) !== 0o700) throw new Error('Unsafe private directory'); + const handle = `${root}/${grant.session}.json`; + const audit = (event:string) => { + const fd = openSync(`${root}/audit.jsonl`, constants.O_WRONLY|constants.O_CREAT|constants.O_APPEND|constants.O_NOFOLLOW,0o600); + try { writeFileSync(fd,JSON.stringify({event,sha,session:grant.session,at:new Date().toISOString()})+'\n'); } finally {closeSync(fd);} + }; + const db = new PrismaClient({log:[]}); + const service = new AdminService(db as any,undefined as any,undefined as any); + try { + audit(`${action}-requested`); + if(action === 'close') { + await service.cleanupStageTestPrincipal(process.env,sha); + try {unlinkSync(handle);} catch(e:any) {if(e.code !== 'ENOENT') throw e;} + audit('revoked-and-deleted'); + return; + } + let fd:number; + let password:string; + try { + fd = openSync(handle,constants.O_WRONLY|constants.O_CREAT|constants.O_EXCL|constants.O_NOFOLLOW,0o600); + password = randomBytes(48).toString('base64url'); + try {writeFileSync(fd,JSON.stringify({password}));} finally {closeSync(fd);} + } catch(e:any) { + if(e.code !== 'EEXIST') throw e; + fd = openSync(handle,constants.O_RDONLY|constants.O_NOFOLLOW); + try { + const {fstatSync} = await import('fs'); const s=fstatSync(fd); + if(!s.isFile() || s.uid !== process.getuid!() || (s.mode & 0o777) !== 0o600) throw new Error('Unsafe handle'); + password=JSON.parse(readFileSync(fd,'utf8')).password; + } finally {closeSync(fd);} + } + const user=await service.provisionStageTestPrincipal(process.env,sha,password); + // Use deployed persisted-account HTTP login, never sign tokens here. + const response=await fetch('http://127.0.0.1:3000/api/auth/admin-login',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({email:STAGE_TEST_EMAIL,password}),signal:AbortSignal.timeout(15000)}); + if(!response.ok) throw new Error('Persisted login failed'); + const result:any=await response.json(); + if(result.data?.user?.id !== user.id || result.data?.user?.role !== 'SUPER_ADMIN' || !result.data?.accessToken) throw new Error('Persisted login mismatch'); + fd=openSync(handle,constants.O_WRONLY|constants.O_TRUNC|constants.O_NOFOLLOW); + try {writeFileSync(fd,JSON.stringify({password,...result.data,expiresAt:user.authExpiresAt}));} finally {closeSync(fd);} + audit('created-and-login-verified'); + // Only an opaque local path is public. Never upload this file as a CI artifact. + process.stdout.write(`Stage credential handle: ${handle}\n`); + } catch { + audit('failed'); + // Leave only a revoked account if relational cleanup fails. + await service.cleanupStageTestPrincipal(process.env,sha).catch(()=>undefined); + try {unlinkSync(handle);} catch { /* no credential content in error */ } + throw new Error('Stage test principal operation failed; inspect private audit'); + } finally {await db.$disconnect();} +} +main().catch(()=>{process.stderr.write('Stage test principal denied or failed\n');process.exitCode=1;}); diff --git a/backend/src/auth/stage-test-principal.integration.spec.ts b/backend/src/auth/stage-test-principal.integration.spec.ts new file mode 100644 index 00000000..c8a76926 --- /dev/null +++ b/backend/src/auth/stage-test-principal.integration.spec.ts @@ -0,0 +1,52 @@ +import { PrismaClient } from '@prisma/client'; +import { randomBytes } from 'crypto'; +import { JwtService } from '@nestjs/jwt'; +import { AdminService } from '../admin/admin.service'; +import { AuthService } from './auth.service'; +import { UsersService } from '../users/users.service'; +import { JwtStrategy } from './jwt.strategy'; +import { RedisService } from '../redis/redis.service'; +import { STAGE_TEST_ID, STAGE_TEST_EMAIL, STAGE_TEST_MOBILE } from './stage-test-principal'; +const enabled=process.env.STAGE_PRINCIPAL_DISPOSABLE_TEST === 'true'; +(enabled ? describe : describe.skip)('disposable persisted Stage principal lifecycle',()=>{ + const sha='a'.repeat(40), grant={APP_ENV:'stage',CI:'true',STAGE_TEST_PRINCIPAL_ENABLED:'true',STAGE_TEST_APPROVAL:'owner-authorized-stage-editorial',STAGE_TEST_SHA:sha,STAGE_TEST_SESSION:'integration-session',STAGE_TEST_TTL_SECONDS:'600'}; + const db=new PrismaClient({log:[]}); const redis=new RedisService(); + let admin:AdminService,auth:AuthService,strategy:JwtStrategy,password:string; + beforeAll(async()=>{ + // Deliberately require a disposable database name; never point this suite at Stage. + if(!process.env.DATABASE_URL?.endsWith('/principal_disposable')) throw new Error('Disposable database required'); + redis.onModuleInit(); password=randomBytes(48).toString('base64url'); + admin=new AdminService(db as any,redis,undefined as any); + auth=new AuthService(db as any,new JwtService({secret:process.env.JWT_SECRET,signOptions:{expiresIn:'2h'}}),redis,undefined as any); + strategy=new JwtStrategy(new UsersService(db as any),redis); + }); + afterAll(async()=>{await admin.cleanupStageTestPrincipal(grant,sha); await db.$disconnect();redis.onModuleDestroy();}); + it('rejects unowned collision and never changes it',async()=>{ + const collision=await db.user.create({data:{firstName:'Unowned',lastName:'Account',email:STAGE_TEST_EMAIL,mobile:STAGE_TEST_MOBILE}}); + try { + await expect(admin.provisionStageTestPrincipal(grant,sha,password)).rejects.toThrow('Refusing'); + expect((await db.user.findUnique({where:{id:collision.id}}))?.role).toBe('User_PetOwner'); + } finally {await db.user.delete({where:{id:collision.id}});} + }); + it('creates through account service, logs in, verifies signed tokens, never renews retry TTL',async()=>{ + const u=await admin.provisionStageTestPrincipal(grant,sha,password); + expect(u.id).toBe(STAGE_TEST_ID); expect(u.role).toBe('SUPER_ADMIN'); expect(u.password).not.toBe(password); + const retry=await admin.provisionStageTestPrincipal(grant,sha,password); expect(retry.authExpiresAt).toEqual(u.authExpiresAt); + await expect(admin.provisionStageTestPrincipal({...grant,STAGE_TEST_SESSION:'different-session'},sha,password)).rejects.toThrow('Refusing'); + const login=await auth.adminLogin({email:STAGE_TEST_EMAIL,password}); + const jwt=new JwtService({secret:process.env.JWT_SECRET}); + const payload=jwt.verify(login.data.accessToken); expect(payload.sub).toBe(u.id);expect(payload.role).toBe('SUPER_ADMIN'); + const req:any={method:'GET',originalUrl:'/api/admin/orchestration/tasks',headers:{authorization:`Bearer ${login.data.accessToken}`}}; + expect((await strategy.validate(req,payload)).id).toBe(u.id); + await expect(strategy.validate({...req,originalUrl:'/api/admin/users'},payload)).rejects.toThrow('scope denied'); + await expect(strategy.validate({...req,method:'POST',originalUrl:'/api/admin/orchestration/tasks/abcd/gates/2/decide'},payload)).rejects.toThrow('scope denied'); + // Fixture time travel: persisted expiry is enforced independently of the long-lived signed token. + await db.user.update({where:{id:u.id},data:{authExpiresAt:new Date(0)}}); + await expect(strategy.validate(req,payload)).rejects.toThrow(); + await expect(auth.adminLogin({email:STAGE_TEST_EMAIL,password})).rejects.toThrow(); + await expect(auth.refreshToken(login.data.refreshToken)).rejects.toThrow(); + await admin.cleanupStageTestPrincipal(grant,sha); + await expect(strategy.validate(req,payload)).rejects.toThrow(); + expect(await db.user.findUnique({where:{id:u.id}})).toBeNull(); + }); +}); diff --git a/backend/src/auth/stage-test-principal.spec.ts b/backend/src/auth/stage-test-principal.spec.ts new file mode 100644 index 00000000..8cbecb89 --- /dev/null +++ b/backend/src/auth/stage-test-principal.spec.ts @@ -0,0 +1,13 @@ +import { assertPrincipalActive, authorizeStageSession } from './stage-test-principal'; +const sha = 'a'.repeat(40); +const valid = { APP_ENV: 'stage', STAGE_TEST_PRINCIPAL_ENABLED: 'true', CI: 'true', STAGE_TEST_APPROVAL: 'owner-authorized-stage-editorial', STAGE_TEST_SHA: sha, STAGE_TEST_SESSION: 'editorial-20261024', STAGE_TEST_TTL_SECONDS: '600' }; +describe('Stage CI authority', () => { + it('denies by default and in Production despite opt in', () => { + expect(() => authorizeStageSession({}, sha)).toThrow(); + expect(() => authorizeStageSession({...valid, APP_ENV:'production'}, sha)).toThrow(); + }); + it('requires immutable matching SHA and bounded explicit authorization', () => { + expect(authorizeStageSession(valid, sha).ttl).toBe(600); + for(const patch of [{STAGE_TEST_SHA:'main'}, {STAGE_TEST_SHA:'b'.repeat(40)}, {STAGE_TEST_TTL_SECONDS:'3601'}, {STAGE_TEST_TTL_SECONDS:'0'}, {STAGE_TEST_APPROVAL:''}, {CI:''}]) expect(() => authorizeStageSession({...valid,...patch},sha)).toThrow(); + }); +}); diff --git a/backend/src/auth/stage-test-principal.ts b/backend/src/auth/stage-test-principal.ts new file mode 100644 index 00000000..850f7010 --- /dev/null +++ b/backend/src/auth/stage-test-principal.ts @@ -0,0 +1,13 @@ +// Internal seed authority only. No controller, JWT actor, or owner impersonation. +export const STAGE_TEST_ID = 'e876e7a0-738f-4e59-b6db-e270512ababc'; +export const STAGE_TEST_EMAIL = 'stage-editorial-reviewer@ci.canina.invalid'; +export const STAGE_TEST_MOBILE = '09999999071'; +export function authorizeStageSession(env: NodeJS.ProcessEnv, artifactSha: string) { + if (env.APP_ENV !== 'stage' || env.STAGE_TEST_PRINCIPAL_ENABLED !== 'true' || env.CI !== 'true' || env.STAGE_TEST_APPROVAL !== 'owner-authorized-stage-editorial' || !/^[a-f0-9]{40}$/.test(artifactSha) || env.STAGE_TEST_SHA !== artifactSha || !/^[a-z0-9-]{8,64}$/.test(env.STAGE_TEST_SESSION || '')) throw new Error('Stage CI authority denied'); + const ttl = Number(env.STAGE_TEST_TTL_SECONDS); + if (!Number.isInteger(ttl) || ttl < 60 || ttl > 3600) throw new Error('Bounded TTL required'); + return {ttl, session:env.STAGE_TEST_SESSION!, sha:artifactSha}; +} +export function assertPrincipalActive(user: { authExpiresAt?: Date | null }, now = Date.now()) { + if (user.authExpiresAt && user.authExpiresAt.getTime() <= now) throw new Error('Principal expired'); +} diff --git a/docs/stage-test-principal.md b/docs/stage-test-principal.md new file mode 100644 index 00000000..f56a5f7b --- /dev/null +++ b/docs/stage-test-principal.md @@ -0,0 +1,52 @@ +# Temporary Stage editorial reviewer (disabled by default) + +Authority: repository write/CI-dispatch permission plus the existing authenticated, +pinned Stage deployment SSH boundary. This is a narrowly scoped seed operation, +not an API-key actor, owner JWT, or a public bootstrap endpoint. The destructive +legacy seed is not used. `AdminService` shares its normal hashing/persistence and +relational cleanup implementation with the internal command; normal user mutation +role checks remain unchanged. The canonical default administrator is untouched. + +## Activation after independent review + +1. Promote this commit through the normal Git/CI Stage deployment. Do not run the + seed command against an old image: the embedded immutable SHA must match. + Apply the additive migration through the existing migration deployment step. +2. Dispatch **Owner authorized Stage test principal** on develop with `approval` + exactly `owner-authorized-stage-editorial`, unique `session` such as + `editorial-20261024-a`, `ttl` explicitly 600 (maximum 3600), and `action=open`. + The workflow uses existing DEPLOY_KEY / pinned DEPLOY_KNOWN_HOSTS only. +3. CI reports only `/app/private-stage-test/.json` inside + `canino_backend_stage`. This mode-0600 file in a mode-0700 directory contains + the process-generated password and real persisted-account login tokens. + Consume it only from an approved in-container CI HTTP process; never print, + download, publish as an artifact, or type it into a browser. No owner secret is + needed. Audit records contain events, session and SHA, never credentials. +4. Use this independent reviewer for Gate1 only; the proposer/PMO must be a + distinct actor. Existing self-review checks are not changed. This session does + NOT authorize Gate2, publication, release, general admin APIs, worker identity + replacement, or budget increases. Approve a separate explicit bounded test + budget before running inference; unknown prior reservations remain retained. +5. Dispatch the same workflow/session/ttl with `action=close` immediately after + tests. This revokes persisted authentication BEFORE relational deletion and + removes the private credential file. Close is idempotent when absent. + +A host systemd timer is armed before creation for independent TTL cleanup even +if CI disappears. Persisted expiry is checked at login, refresh, and every JWT +request, so killing the timer cannot extend access. Failed cleanup leaves revoked +credentials. Cleanup timer is pinned to the creation SHA: finish/close before +redeploy; if redeployed, use the approved CI recovery session with its recorded +ownership rather than changing an unrelated account. A collision with the exact +ID, email or mobile fails closed; an owned retry with the same secret cannot +extend expiry. The test principal is limited in JWT strategy to task reads, +proposal creation, Gate1 decisions and editorial failure. All other paths deny. + +## Verification + +Unit guards and existing independent self-review/role tests run with Jest. +`stage-test-principal.integration.spec.ts` is opt-in via +`STAGE_PRINCIPAL_DISPOSABLE_TEST=true` and requires a database URL ending in +`/principal_disposable`; use a new isolated Postgres and Redis, then remove both. +It verifies real account persistence/hash, signed access/refresh login tokens, +collision refusal, nonrenewing retries, request scope, expiry, deletion/revocation. +Never run it against Stage or Production. diff --git a/scripts/ci-stage-test-principal.sh b/scripts/ci-stage-test-principal.sh new file mode 100644 index 00000000..7e6ab227 --- /dev/null +++ b/scripts/ci-stage-test-principal.sh @@ -0,0 +1,22 @@ +#!/usr/bin/env bash +# CI job side only. Never execute host deploy logic in the runner filesystem. +set -euo pipefail +set +x +fail() { printf 'ERROR: %s\n' "$1" >&2; exit 2; } +[[ ${GITHUB_ACTIONS:-${GITEA_ACTIONS:-}} == true && ${BRANCH:-} == develop && $# == 0 ]] || fail 'CI-only Stage deployment; Production is blocked' +[[ ${DEPLOY_SHA:-} =~ ^[0-9a-f]{40}$ ]] || fail 'immutable DEPLOY_SHA required' +# Repository secret DEPLOY_KEY is the historical approved devops SSH credential. +# Never fall back to baked-in runner keys, agent forwarding or docker.sock. +[[ -n ${DEPLOY_KNOWN_HOSTS:-} ]] || fail 'provision DEPLOY_KNOWN_HOSTS: independently verified [87.248.133.138]:2234 host key; never use ssh-keyscan trust-on-first-use' +[[ -n ${DEPLOY_KEY:-} ]] || fail 'provision existing approved DEPLOY_KEY for devops@87.248.133.138:2234' +for tool in ssh ssh-keygen mktemp; do command -v "$tool" >/dev/null || fail "job context missing $tool"; done +umask 077 +scratch=$(mktemp -d) +trap 'rm -rf "$scratch"' EXIT +printf '%s\n' "$DEPLOY_KNOWN_HOSTS" > "$scratch/known_hosts" +printf '%s\n' "$DEPLOY_KEY" > "$scratch/key" +unset DEPLOY_KEY DEPLOY_KNOWN_HOSTS +ssh-keygen -F '[87.248.133.138]:2234' -f "$scratch/known_hosts" >/dev/null || fail 'DEPLOY_KNOWN_HOSTS has no pinned deployment endpoint' +[[ ${STAGE_TEST_SESSION:-} =~ ^[a-z0-9-]{8,64}$ && ${STAGE_TEST_TTL_SECONDS:-} =~ ^[0-9]+$ && ${STAGE_TEST_ACTION:-} =~ ^(open|close)$ && ${STAGE_TEST_APPROVAL:-} == owner-authorized-stage-editorial ]] || fail 'explicit owner Stage test grant required' +[[ $STAGE_TEST_TTL_SECONDS -ge 60 && $STAGE_TEST_TTL_SECONDS -le 3600 ]] || exit 2 +ssh -F /dev/null -T -p 2234 -i "$scratch/key" -o BatchMode=yes -o IdentitiesOnly=yes -o IdentityAgent=none -o StrictHostKeyChecking=yes -o UserKnownHostsFile="$scratch/known_hosts" -o GlobalKnownHostsFile=/dev/null -o ConnectTimeout=15 devops@87.248.133.138 "sudo -n env CI=true STAGE_TEST_APPROVAL=owner-authorized-stage-editorial bash /opt/services/canina/releases/$DEPLOY_SHA/scripts/stage-test-principal-host.sh $DEPLOY_SHA $STAGE_TEST_SESSION $STAGE_TEST_TTL_SECONDS $STAGE_TEST_ACTION" diff --git a/scripts/deploy.sh b/scripts/deploy.sh index 3720f1bc..d7613833 100644 --- a/scripts/deploy.sh +++ b/scripts/deploy.sh @@ -88,6 +88,8 @@ for key, name in expected.items(): if config['networks']['traefik_public'].get('name') != 'traefik_public' or not config['networks']['traefik_public'].get('external'): raise SystemExit('ERROR: Stage network identity mismatch') backend = config['services']['backend_stage'] +import os +backend['build'].setdefault('args', {})['STAGE_TEST_ARTIFACT_SHA'] = os.environ['DEPLOY_SHA'] if backend['container_name'] != 'canino_backend_stage' or config['services']['frontend_stage']['container_name'] != 'canino_frontend_stage': raise SystemExit('ERROR: Stage container identity mismatch') mounts = backend.get('volumes', []) diff --git a/scripts/stage-test-principal-host.sh b/scripts/stage-test-principal-host.sh new file mode 100644 index 00000000..6080ecfd --- /dev/null +++ b/scripts/stage-test-principal-host.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash +# Authenticated CI host-side command only. No production argument or dynamic container name. +set -euo pipefail +set +x +[[ $# == 4 && $1 =~ ^[0-9a-f]{40}$ && $2 =~ ^[a-z0-9-]{8,64}$ && $3 =~ ^[0-9]+$ && $4 =~ ^(open|close)$ ]] || exit 2 +[[ $3 -ge 60 && $3 -le 3600 && ${STAGE_TEST_APPROVAL:-} == owner-authorized-stage-editorial && ${CI:-} == true ]] || exit 2 +sha=$1 session=$2 ttl=$3 action=$4 +[[ ! -e /.dockerenv && $(id -u) == 0 ]] || exit 2 +exec 9>/opt/services/canina/stage-test-principal.lock +flock -n 9 || exit 2 +[[ $(docker exec canino_backend_stage cat /app/STAGE_TEST_ARTIFACT_SHA) == "$sha" ]] || exit 2 +[[ $(docker inspect canino_backend_stage --format '{{.Name}}') == /canino_backend_stage ]] || exit 2 +run() { + docker exec -e APP_ENV=stage -e CI=true -e STAGE_TEST_PRINCIPAL_ENABLED=true \ + -e STAGE_TEST_APPROVAL=owner-authorized-stage-editorial -e STAGE_TEST_SHA="$sha" \ + -e STAGE_TEST_SESSION="$session" -e STAGE_TEST_TTL_SECONDS="$ttl" \ + canino_backend_stage node dist/auth/stage-test-principal.cli.js "$1" +} +if [[ $action == open ]]; then + # Arm cleanup BEFORE creating the account. systemd keeps this independent of CI loss. + script="/opt/services/canina/releases/$sha/scripts/stage-test-principal-host.sh" + [[ -f $script && ! -L $script ]] || exit 2 + systemd-run --quiet --unit="canina-stage-principal-$session" --on-active="${ttl}s" \ + --setenv=CI=true --setenv=STAGE_TEST_APPROVAL=owner-authorized-stage-editorial \ + /bin/bash "$script" "$sha" "$session" "$ttl" close +fi +run "$action"