Проверка личности на каждом запросе

// Каркас со стражами, таблица и криптография главы — в подложке
type Class = new (...args: any[]) => object;
type Identity = { sub: string; role: string };
type Claims = Identity & { exp: number };
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string; user?: Identity };
type Res = { status: number; body: string };
type Call = { params: Record<string, string>; query: URLSearchParams; body: string; user?: Identity };
type Ctx = { request: Req; params: Record<string, string>; query: URLSearchParams; controller: string; handler: string };
type Guard = (ctx: Ctx) => boolean | Promise<boolean>;
type Pipe = (call: Call, ctx: Ctx) => Call | Promise<Call>;
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
declare const SECRET: string;
declare function signToken(secret: string, claims: object): Promise<string>;
declare function verifyToken(secret: string, token: string, now: number): Promise<Claims | null>;
declare function Module(options: { controllers?: Class[] }): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Get(path?: string): MethodDeco;
declare function Delete(path?: string): MethodDeco;
declare function UseGuards(...guards: Guard[]): Deco & MethodDeco;
declare function UsePipes(...pipes: Pipe[]): Deco & MethodDeco;
declare function createApp(root: Class): { inject(request: Req): Promise<Res> };
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

// часы примера стоят: так токен успевает состариться за одну строку
const NOW = 1789462800;
const DAY = 24 * 60 * 60;

// «откуда взять» и «годится ли» — разные шаги: первый в статье ещё поменяется, второй нет
function bearerOf(request: Req): string | null {
  const header = request.headers?.authorization ?? "";
  return header.startsWith("Bearer ") ? header.slice(7) : null;
}

async function claimsOf(token: string | null): Promise<Claims> {
  if (token === null) throw new HttpError(401, "нужен токен");
  const claims = await verifyToken(SECRET, token, NOW);
  if (claims === null) throw new HttpError(401, "токен не годится");
  return claims;
}

// страж отвечает только «да» или «нет», поэтому найденную личность он кладёт в сам запрос
const identity: Guard = async (ctx) => {
  ctx.request.user = await claimsOf(bearerOf(ctx.request));
  return true;
};

// а донести её до обработчика — дело трубы: обработчик получает call, а не запрос
const whoAmI: Pipe = (call, ctx) => ({ ...call, user: ctx.request.user });

const admin: Guard = (ctx) => ctx.request.user?.role === "admin";

@UseGuards(identity)
@UsePipes(whoAmI)
@Controller("/notes")
class NotesController {
  @Get("/mine")
  mine(call: Call) {
    return `черновики ${call.user?.sub}, роль ${call.user?.role}`;
  }

  @UseGuards(admin)
  @Delete("/:id")
  remove(call: Call) {
    return `удалена ${call.params.id}`;
  }
}

@Module({ controllers: [NotesController] })
class AppModule {}

const app = createApp(AppModule);

async function main() {
  const fresh = await signToken(SECRET, { sub: "1", role: "user", exp: NOW + 30 * DAY });
  const stale = await signToken(SECRET, { sub: "1", role: "user", exp: NOW - 1 });
  const alien = await signToken("секрет-соседнего-сервиса", { sub: "1", role: "admin", exp: NOW + 30 * DAY });

  const tries: [string, string, string][] = [
    ["без заголовка", "", "GET /notes/mine"],
    ["не Bearer", "Basic dTE6MTIzNDU2", "GET /notes/mine"],
    ["обрывок строки", "Bearer eyJhbGciOiJIUzI1NiJ9", "GET /notes/mine"],
    ["подписан чужим секретом", `Bearer ${alien}`, "GET /notes/mine"],
    ["свой, но вчерашний", `Bearer ${stale}`, "GET /notes/mine"],
    ["свой и свежий", `Bearer ${fresh}`, "GET /notes/mine"],
    ["свой и свежий, удаление", `Bearer ${fresh}`, "DELETE /notes/7"],
  ];
  for (const [name, header, route] of tries) {
    const [method, target] = route.split(" ");
    const response = await app.inject({ method, target, headers: header ? { authorization: header } : {} });
    console.log(`${name}: ${response.status} ${response.body}`);
  }
}

main();

// Каркас, таблица и криптография — в подложке; здесь их типы и новое
type Class = new (...args: any[]) => object;
type Identity = { sub: string; role: string };
type Claims = Identity & { exp: number };
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string; user?: Identity };
type Res = { status: number; body: string };
type Call = { params: Record<string, string>; query: URLSearchParams; body: string; user?: Identity };
type Ctx = { request: Req; params: Record<string, string>; query: URLSearchParams; controller: string; handler: string };
type Guard = (ctx: Ctx) => boolean | Promise<boolean>;
type Pipe = (call: Call, ctx: Ctx) => Call | Promise<Call>;
type Row = Record<string, unknown> & { id: number };
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
declare const SECRET: string;
declare function signToken(secret: string, claims: object): Promise<string>;
declare function verifyToken(secret: string, token: string, now: number): Promise<Claims | null>;
declare class Table {
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  update(id: number, patch: Record<string, unknown>): Row | null;
  remove(id: number): boolean;
  find(indexName: string, value: unknown): Row[];
}
declare function Module(options: { controllers?: Class[] }): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Delete(path?: string): MethodDeco;
declare function UseGuards(...guards: Guard[]): Deco & MethodDeco;
declare function UsePipes(...pipes: Pipe[]): Deco & MethodDeco;
declare function createApp(root: Class): { inject(request: Req): Promise<Res> };
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

const NOW = 1789462800;
const DAY = 24 * 60 * 60;

// Из прошлого раздела: достать токен, проверить подпись со сроком
function bearerOf(request: Req): string | null {
  const header = request.headers?.authorization ?? "";
  return header.startsWith("Bearer ") ? header.slice(7) : null;
}

async function claimsOf(token: string | null): Promise<Claims> {
  if (token === null) throw new HttpError(401, "нужен токен");
  const claims = await verifyToken(SECRET, token, NOW);
  if (claims === null) throw new HttpError(401, "токен не годится");
  return claims;
}

const identity: Guard = async (ctx) => {
  ctx.request.user = await claimsOf(bearerOf(ctx.request));
  return true;
};

const whoAmI: Pipe = (call, ctx) => ({ ...call, user: ctx.request.user });

// Таблица пользователей — та же, что в главе 9, с уникальным индексом по id
const users = new Table().index("users_pk", "id", { unique: true });
const ada = users.insert({ email: "ada@example.com", role: "admin" });
const bob = users.insert({ email: "bob@example.com", role: "user" });
const eve = users.insert({ email: "eve@example.com", role: "admin" });

let lookups = 0;

// То же, что identity, плюс два вопроса к таблице: есть ли ещё такой, та ли роль
const authenticate: Guard = async (ctx) => {
  const claims = await claimsOf(bearerOf(ctx.request));
  lookups += 1;
  const [row] = users.find("users_pk", Number(claims.sub));
  if (row === undefined) throw new HttpError(401, "учётки больше нет");
  if (row.role !== claims.role) throw new HttpError(401, "роль изменилась");
  ctx.request.user = claims;
  return true;
};

const admin: Guard = (ctx) => ctx.request.user?.role === "admin";

@UsePipes(whoAmI)
@Controller("/notes")
class NotesController {
  // два маршрута с одним телом; разница только в первом страже
  @UseGuards(identity, admin)
  @Delete("/by-token/:id")
  removeByToken(call: Call) {
    return `удалил ${call.user?.sub}`;
  }

  @UseGuards(authenticate, admin)
  @Delete("/by-table/:id")
  removeByTable(call: Call) {
    return `удалил ${call.user?.sub}`;
  }
}

@Module({ controllers: [NotesController] })
class AppModule {}

const app = createApp(AppModule);

async function main() {
  // токены выданы 29 дней назад на 30 дней: подпись верна, срок не истёк
  const issued = NOW - 29 * DAY;
  const tokens: [string, string][] = [
    ["ada", await signToken(SECRET, { sub: String(ada.id), role: "admin", exp: issued + 30 * DAY })],
    ["bob", await signToken(SECRET, { sub: String(bob.id), role: "user", exp: issued + 30 * DAY })],
    ["eve", await signToken(SECRET, { sub: String(eve.id), role: "admin", exp: issued + 30 * DAY })],
  ];

  // за эти четыре недели админа понизили, а учётку уволенного стёрли
  users.update(ada.id, { role: "user" });
  users.remove(eve.id);

  for (const [name, token] of tokens) {
    for (const route of ["by-token", "by-table"]) {
      const response = await app.inject({
        method: "DELETE",
        target: `/notes/${route}/7`,
        headers: { authorization: `Bearer ${token}` },
      });
      console.log(`${name} → ${route}: ${response.status} ${response.body}`);
    }
  }
  console.log("походов в таблицу:", lookups);
}

main();

// Каркас, таблица, криптография и страж authenticate из прошлых разделов — в подложке
type Class = new (...args: any[]) => object;
type Identity = { sub: string; role: string };
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string; user?: Identity };
type Res = { status: number; body: string };
type Call = { params: Record<string, string>; query: URLSearchParams; body: string; user?: Identity };
type Ctx = { request: Req; params: Record<string, string>; query: URLSearchParams; controller: string; handler: string };
type Guard = (ctx: Ctx) => boolean | Promise<boolean>;
type Pipe = (call: Call, ctx: Ctx) => Call | Promise<Call>;
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
declare const SECRET: string;
declare const NOW: number;
declare const DAY: number;
declare const bob: { id: number };
declare const authenticate: Guard;
declare const whoAmI: Pipe;
declare function signToken(secret: string, claims: object): Promise<string>;
declare function Module(options: { controllers?: Class[] }): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Get(path?: string): MethodDeco;
declare function UseGuards(...guards: Guard[]): Deco & MethodDeco;
declare function UsePipes(...pipes: Pipe[]): Deco & MethodDeco;
declare function createApp(root: Class): { inject(request: Req): Promise<Res> };

// Один декоратор вместо трёх: @Controller, страж личности и труба сразу.
// Открытые маршруты перечисляются здесь же, рядом с объявлением контроллера
function Secured(prefix: string, options: { open?: string[]; deps?: Class[] } = {}): Deco {
  const open = new Set(options.open ?? []);
  const gate: Guard = (ctx) => open.has(ctx.handler) || authenticate(ctx);
  return function (value: Class, context: ClassDecoratorContext) {
    Controller(prefix, { deps: options.deps })(value, context);
    UseGuards(gate)(value, context);
    UsePipes(whoAmI)(value, context);
  };
}

@Secured("/notes", { open: ["published"] })
class NotesController {
  @Get("/published")
  published() {
    return "опубликованные заметки";
  }

  @Get("/mine")
  mine(call: Call) {
    return `черновики ${call.user?.sub}`;
  }
}

// Контроллер, который написали через неделю после стража: @UseGuards забыли
@Controller("/export")
class ExportController {
  @Get("/all")
  all() {
    return "выгрузка всех заметок";
  }
}

// Тот же контроллер, объявленный новым способом
@Secured("/report")
class ReportController {
  @Get("/month")
  month() {
    return "сводка за месяц";
  }
}

@Module({ controllers: [NotesController, ExportController, ReportController] })
class AppModule {}

const app = createApp(AppModule);

async function main() {
  const token = await signToken(SECRET, { sub: String(bob.id), role: "user", exp: NOW + DAY });
  const routes = ["/notes/published", "/notes/mine", "/export/all", "/report/month"];
  for (const target of routes) {
    const guest = await app.inject({ method: "GET", target });
    const owner = await app.inject({ method: "GET", target, headers: { authorization: `Bearer ${token}` } });
    console.log(`${target}: гость ${guest.status}, с токеном ${owner.status} ${owner.body}`);
  }
}

main();

// Каркас, таблица пользователей и страж authenticate из прошлых разделов — в подложке
type Class = new (...args: any[]) => object;
type Identity = { sub: string; role: string };
type Claims = Identity & { exp: number };
type Req = { method: string; target: string; headers?: Record<string, string>; body?: string; user?: Identity };
type Res = { status: number; body: string };
type Call = { params: Record<string, string>; query: URLSearchParams; body: string; user?: Identity };
type Ctx = { request: Req; params: Record<string, string>; query: URLSearchParams; controller: string; handler: string };
type Guard = (ctx: Ctx) => boolean | Promise<boolean>;
type Pipe = (call: Call, ctx: Ctx) => Call | Promise<Call>;
type Row = Record<string, unknown> & { id: number };
type Deco = (value: Class, context: ClassDecoratorContext) => void;
type MethodDeco = (handler: Function, context: ClassMethodDecoratorContext) => void;
declare const SECRET: string;
declare const NOW: number;
declare const DAY: number;
declare const ada: { id: number };
declare const bob: { id: number };
declare const users: {
  find(indexName: string, value: unknown): Row[];
};
declare function bearerOf(request: Req): string | null;
declare function claimsOf(token: string | null): Promise<Claims>;
declare const whoAmI: Pipe;
declare function signToken(secret: string, claims: object): Promise<string>;
declare class Table {
  index(name: string, column: string, options?: { unique?: boolean }): Table;
  insert(values: Record<string, unknown>): Row;
  find(indexName: string, value: unknown): Row[];
}
declare function Module(options: { controllers?: Class[] }): Deco;
declare function Controller(prefix: string, options?: { deps?: Class[] }): Deco;
declare function Get(path?: string): MethodDeco;
declare function UseGuards(...guards: Guard[]): Deco & MethodDeco;
declare function UsePipes(...pipes: Pipe[]): Deco & MethodDeco;
declare function createApp(root: Class): { inject(request: Req): Promise<Res> };
declare class HttpError extends Error {
  constructor(status: number, message: string);
  readonly status: number;
}

// Таблица сессий браузера: кука несёт только ключ, всё остальное — здесь
const sessions = new Table().index("sessions_key", "sid", { unique: true });
sessions.insert({ sid: "s-3f81c0", userId: bob.id, expires: NOW + 14 * DAY });
sessions.insert({ sid: "s-0ac7d9", userId: ada.id, expires: NOW - 1 });

function cookieOf(request: Req, name: string): string | null {
  const pair = (request.headers?.cookie ?? "").split("; ").find((item) => item.startsWith(`${name}=`));
  return pair === undefined ? null : pair.slice(name.length + 1);
}

// Два носителя, один ответ: кто пришёл. О роли кука не знает вовсе
async function whoIs(request: Req): Promise<{ sub: string; role?: string }> {
  const bearer = bearerOf(request);
  if (bearer !== null) return claimsOf(bearer);
  const sid = cookieOf(request, "sid");
  if (sid === null) throw new HttpError(401, "ни токена, ни куки");
  const [session] = sessions.find("sessions_key", sid);
  if (session === undefined || Number(session.expires) <= NOW) throw new HttpError(401, "сессия не годится");
  return { sub: String(session.userId) };
}

// Дальше — та же перепроверка в таблице, что и у стража с токеном
const gate: Guard = async (ctx) => {
  const who = await whoIs(ctx.request);
  const [row] = users.find("users_pk", Number(who.sub));
  if (row === undefined) throw new HttpError(401, "учётки больше нет");
  if (who.role !== undefined && row.role !== who.role) throw new HttpError(401, "роль изменилась");
  ctx.request.user = { sub: who.sub, role: String(row.role) };
  return true;
};

@UseGuards(gate)
@UsePipes(whoAmI)
@Controller("/notes")
class NotesController {
  @Get("/mine")
  mine(call: Call) {
    return `черновики ${call.user?.sub}, роль ${call.user?.role}`;
  }
}

@Module({ controllers: [NotesController] })
class AppModule {}

const app = createApp(AppModule);

async function main() {
  const phone = await signToken(SECRET, { sub: String(bob.id), role: "user", exp: NOW + DAY });
  const downgraded = await signToken(SECRET, { sub: String(ada.id), role: "admin", exp: NOW + DAY });

  const tries: [string, Record<string, string>][] = [
    ["телефон: Bearer", { authorization: `Bearer ${phone}` }],
    ["браузер: кука сессии", { cookie: "theme=dark; sid=s-3f81c0" }],
    ["браузер: кука с чужим ключом", { cookie: "sid=s-подобрал" }],
    ["браузер: кука вчерашней сессии", { cookie: "sid=s-0ac7d9" }],
    ["ни того, ни другого", {}],
    ["телефон: токен с прежней ролью", { authorization: `Bearer ${downgraded}` }],
  ];
  for (const [name, headers] of tries) {
    const response = await app.inject({ method: "GET", target: "/notes/mine", headers });
    console.log(`${name}: ${response.status} ${response.body}`);
  }
}

main();

// apps/api/src/configs/trpc/context.ts, выдержка
@Injectable()
export class AppContext implements TRPCContext {
  constructor(private readonly configService: ConfigService) {}

  // best-effort извлечение идентичности из JWT: невалидный или отсутствующий
  // токен НЕ отклоняет запрос — поля остаются undefined. Это нужно процедурам
  // с необязательным входом (notes.list, notes.byId): гость видит опубликованное,
  // а вошедший — ещё и свои черновики. Авторитетная проверка живёт в middleware'ах.
  async create({ req, res }: ContextOptions): Promise<Record<string, unknown>> {
    let userId: string | undefined;
    let role: string | undefined;
    try {
      const token = req.headers?.authorization;
      if (token) {
        const payload = verifyToken(this.configService, token);
        userId = payload.sub;
        role = payload.role;
      }
    } catch {
      // невалидный токен — идентичность пустая
    }
    return { req, res, userId, role };
  }
}

// apps/api/src/upload/jwt-auth.guard.ts, выдержка
/** REST-guard для не-tRPC ручек (upload): проверяет подпись Bearer-токена.
 * Отдельный от tRPC-middleware, потому что контроллеры Nest и процедуры
 * nestjs-trpc проходят по разным путям — общего слоя у них нет. */
@Injectable()
export class JwtAuthGuard implements CanActivate {
  constructor(private readonly configService: ConfigService) {}

  canActivate(context: ExecutionContext): boolean {
    const request = context.switchToHttp().getRequest<FastifyRequest>();
    try {
      verifyToken(this.configService, request.headers.authorization ?? '');
      return true;
    } catch {
      throw new UnauthorizedException('NOT_AUTHENTICATED');
    }
  }
}