Compare commits

...
16 changed files with 386 additions and 4 deletions

No files matched your search

+41
View File
@@ -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"
+3 -1
View File
@@ -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
@@ -0,0 +1 @@
ALTER TABLE "users" ADD COLUMN "auth_expires_at" TIMESTAMPTZ, ADD COLUMN "stage_test_session" VARCHAR(64), ADD COLUMN "stage_test_generation" UUID;
+3
View File
@@ -16,6 +16,9 @@ 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()
stageTestGeneration String? @map("stage_test_generation") @db.Uuid
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()
+33
View File
@@ -63,6 +63,8 @@ export class CouponInput {
import { ALLOWED_USER_ROLES, assertUserMutationAllowed } from "./user-role-policy";
import type { UserAdminActor } from "./user-role-policy";
import { randomUUID } from "crypto";
import { authorizeStageSession, STAGE_TEST_ID, STAGE_TEST_EMAIL, STAGE_TEST_MOBILE } from "../auth/stage-test-principal";
@Injectable()
export class AdminService {
@@ -237,6 +239,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 +275,7 @@ export class AdminService {
return this.prisma.user.create({
data: {
...(stage ? { id: STAGE_TEST_ID, stageTestGeneration:randomUUID(), stageTestSession: stage.session, authExpiresAt: stage.expiresAt } : {}),
firstName: dto.firstName.trim(),
lastName: dto.lastName.trim(),
mobile,
@@ -283,6 +290,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 +396,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 } });
+15 -3
View File
@@ -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,7 +201,8 @@ export class AuthService {
});
}
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role };
assertPrincipalActive(user);
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role, ...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}) };
const tokens = await this.generateTokens(payload);
const { password: _p, ...safeUser } = user;
@@ -257,7 +259,8 @@ export class AuthService {
},
});
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role };
assertPrincipalActive(user);
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role, ...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}) };
const tokens = await this.generateTokens(payload);
const { password: _p, ...safeUser } = user;
@@ -300,7 +303,8 @@ export class AuthService {
});
}
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role };
assertPrincipalActive(user);
const payload = { sub: user.id, phoneNumber: user.mobile, role: user.role, ...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}) };
const tokens = await this.generateTokens(payload);
const { password: _pw, ...safeUser } = user;
@@ -326,10 +330,12 @@ 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,
role: dbAdmin.role,
...(dbAdmin.stageTestSession ? {stageTestSession:dbAdmin.stageTestSession, stageTestGeneration:dbAdmin.stageTestGeneration} : {}),
};
const tokens = await this.generateTokens(payload);
const { password: _p, ...safeUser } = dbAdmin;
@@ -443,11 +449,14 @@ export class AuthService {
const user = await this.prisma.user.findUnique({ where: { id: userId } });
if (user) {
assertPrincipalActive(user);
if (user.stageTestSession && (!user.stageTestGeneration || decoded.stageTestGeneration !== user.stageTestGeneration || decoded.stageTestSession !== user.stageTestSession)) throw new UnauthorizedException("Stage session revoked");
userPayload = {
sub: user.id,
email: user.email,
phoneNumber: user.mobile,
role: user.role,
...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}),
};
const { password: _p, ...restUser } = user;
safeUser = restUser;
@@ -487,12 +496,15 @@ export class AuthService {
email?: string;
role?: string;
mobile?: string;
stageTestSession?: string | null;
stageTestGeneration?: string | null;
}) {
const payload = {
sub: user.id,
email: user.email,
role: user.role,
phoneNumber: user.mobile,
...(user.stageTestSession ? {stageTestSession:user.stageTestSession, stageTestGeneration:user.stageTestGeneration} : {}),
};
const tokens = await this.generateTokens(payload);
return {
+10
View File
@@ -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";
@@ -12,6 +13,8 @@ export interface JwtPayload {
email?: string;
role?: string;
phoneNumber?: string;
stageTestSession?: string;
stageTestGeneration?: string;
}
@Injectable()
@@ -59,6 +62,13 @@ export class JwtStrategy extends PassportStrategy(Strategy) {
if (!user) {
throw new UnauthorizedException("کاربر یافت نشد");
}
try { assertPrincipalActive(user); } catch { throw new UnauthorizedException("Principal expired"); }
if (user.stageTestSession) {
if (!user.stageTestGeneration || payload.stageTestGeneration !== user.stageTestGeneration || payload.stageTestSession !== user.stageTestSession) throw new UnauthorizedException("Stage session revoked");
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;
}
}
@@ -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;});
@@ -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();
});
});
@@ -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();
});
});
+13
View File
@@ -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');
}
@@ -0,0 +1,32 @@
import { JwtService } from '@nestjs/jwt';
import { JwtStrategy } from './jwt.strategy';
import { AuthService } from './auth.service';
describe('Stage credentials remain fenced to their creation session', () => {
const id='e876e7a0-738f-4e59-b6db-e270512ababc';
const current={id, role:'SUPER_ADMIN', stageTestSession:'new-session', stageTestGeneration:'fresh-generation', authExpiresAt:new Date(Date.now()+600000)};
const redis:any={get:jest.fn(async()=> '1'),del:jest.fn(),set:jest.fn()};
beforeAll(()=> {process.env.JWT_SECRET='disposable-only-test-secret-at-least-32-characters';process.env.JWT_REFRESH_SECRET='disposable-only-refresh-secret-at-least-32-characters';});
it('rejects an old-session access token after fixed account ID is recreated',async()=>{
const strategy=new JwtStrategy({findById:async()=>current} as any,{get:async()=>null} as any);
const req:any={method:'GET',originalUrl:'/api/admin/orchestration/tasks',headers:{}};
await expect(strategy.validate(req,{sub:id,stageTestSession:'old-session'} as any)).rejects.toThrow();
await expect(strategy.validate(req,{sub:id})).rejects.toThrow();
await expect(strategy.validate(req,{sub:id,stageTestSession:'new-session',stageTestGeneration:'old-generation'} as any)).rejects.toThrow();
await expect(strategy.validate(req,{sub:id,stageTestSession:'new-session',stageTestGeneration:'fresh-generation'} as any)).resolves.toMatchObject({id});
});
it('rejects an old-session refresh token even while its Redis entry remains active',async()=>{
const jwt=new JwtService({secret:process.env.JWT_SECRET});
const auth=new AuthService({user:{findUnique:async()=>current}} as any,jwt,redis,undefined as any);
const token=jwt.sign({sub:id,jti:'old-refresh',role:'SUPER_ADMIN',stageTestSession:'old-session'},{secret:process.env.JWT_REFRESH_SECRET});
await expect(auth.refreshToken(token)).rejects.toThrow();
});
it('includes session fencing in newly issued credentials',async()=>{
const jwt=new JwtService({secret:process.env.JWT_SECRET});
const auth=new AuthService({} as any,jwt,redis,undefined as any);
const result=await auth.refresh(current);
expect(jwt.verify(result.data.accessToken).stageTestGeneration).toBe('fresh-generation');
expect(jwt.verify(result.data.accessToken).stageTestSession).toBe('new-session');
expect(jwt.verify(result.data.refreshToken,{secret:process.env.JWT_REFRESH_SECRET}).stageTestSession).toBe('new-session');
});
});
+52
View File
@@ -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/<session>.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.
+22
View File
@@ -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"
+2
View File
@@ -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', [])
+27
View File
@@ -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"