Вход, владение, роли, лимиты

проект≈ 22 минут

Здесь будет встроен видео-разбор темы (5–7 минут, YouTube / RuTube / VK Видео) — тем, кто лучше воспринимает на слух, текст ниже не обязателен.

Проект дошёл до двери. Прошлая статья собрала домен целиком — репозиторий, сервис, процедуры, — но номер читателя приезжал в роутер параметром, и взять его было неоткуда: кто пришёл, приложение не знало. Теперь узнает. Всё, чем это делается, уже написано вашими руками: PBKDF2 и строка хеша, HMAC и подпись токена, страж личности с перепроверкой в таблице, правило про чужой черновик, ограничитель частоты. Новых механизмов здесь нет ни одного — есть четыре решения о том, где каждый из них стоит: где берут личность, где читают уровень доступа, где проверяют владение и где стучится ограничитель. Проверяется каждое из них не вызовом, который защитили, а тем, что случается с вызовом, о котором забыли.

Разделы темы:·

В таблице users из прошлой статьи две строки, и в обеих на месте пароля стоит заглушка: домену было довольно того, что у заметки есть автор. Входу нужен настоящий хеш. Обе процедуры входа — регистрация и вход — гостевые: токена они не требуют, потому что их и зовут затем, чтобы токен получить.

Регистрация делает три вещи, и порядок у них не любой: сначала хеш — строка PHC, которая помнит свою стоимость, — потом вставка, и только потом токен. Занятость почты при этом не проверяется отдельным запросом: её проверяет уникальный индекс, а почему проверка перед вставкой не спасает, разобрано там же, где этот индекс заведён. Отказ приезжает кодом 23505 с именем ограничения, и сервис переводит его в доменный код одной строкой.

У входа своя тонкость, и она не про криптографию. Отказать можно двумя разными словами: «такой почты нет» и «пароль не тот». Два слова — это два ответа, а два ответа на один вопрос превращают форму входа в список зарегистрированных: подробный отказ тому, кому нельзя, — это утечка. Поэтому ответ один. И одинаковым он обязан быть не только на словах: если неизвестной почте отвечать сразу, а известной — после PBKDF2, разницу видно по часам. Отсюда хеш-пустышка — соль и хеш из нулей при той же стоимости, — и до предела то же правило доводит форма восстановления пароля, где одинаковым обязан быть и ответ, и время ответа.

Заодно у сервиса учёток появляется вторая обязанность — быть единственной дверью к таблице пользователей: транспорту сейчас понадобится искать человека по номеру из токена, и ходить в таблицу мимо сервиса он не будет.

И последнее перед прогнозом. Новых кодов отказа в статье четыре, и все четыре — строки в таблице, которую завела глава про свой конвейер: перевод кода в статус живёт в одном месте, и код доступа дописывается туда, а не заводит второго перевода рядом.

Прогноз: восемь строк. Регистрация Веры, потом та же почта второй раз и почта Ани из прошлой статьи, потом три входа — верным паролем, чужим паролем и по почте, которой в таблице нет. Дальше строка хеша из таблицы. Последняя строка — сколько раз за эти шесть попыток сервер посчитал PBKDF2; её стоит предсказать точным числом, она понадобится в четвёртом разделе.

// Каркас и доменные коды главы 6, схемы главы 6, таблица главы 9, проект
// прошлой статьи, PBKDF2 и подпись токена главы 10 — в подложке; здесь их типы
type Role = "user" | "admin";
type Status = "draft" | "published";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type Res = { status: number; body: string };
declare class Table<Row> {
  insert(values: object): Row;
  where(match: (row: Row) => boolean): Row[];
  find(indexName: string, value: unknown): Row[];
}
declare class DbError extends Error {
  readonly code: string;
  readonly constraint: string;
}
declare class Db {
  users: Table<UserRow>;
}
declare class NotesRepo {
  constructor(db: Db);
}
declare class NotesService {
  constructor(repo: NotesRepo);
  page(viewer: number, n: number): NoteOut[];
  byId(viewer: number, id: number): NoteOut;
  create(authorId: number, input: { title: string; body: string }): NoteOut;
  publish(viewer: number, id: number): NoteOut;
}
declare const SECRET: string;
declare const STATUS_OF: Record<string, number>;
declare function fail(code: string, detail?: string): never;
declare function toResponse(error: unknown): Res;
declare function hashPassword(password: string): Promise<string>;
declare function verifyPassword(password: string, stored: string): Promise<boolean>;
declare function signToken(secret: string, claims: object): Promise<string>;
declare function fromBase64(part: string): Uint8Array;

// Часы примера: сроку токена нужна точка отсчёта, а не настоящее «сейчас»
const NOW = 1790000000;
const DAY = 24 * 60 * 60;

// Четыре кода доступа — строки той же таблицы, что завела глава 6. В проекте
// они стоят прямо в ней; здесь таблица приезжает подложкой, поэтому дописываются
Object.assign(STATUS_OF, {
  NOT_AUTHENTICATED: 401,
  INVALID_CREDENTIALS: 401,
  WRONG_ROLE: 403,
  TOO_MANY_REQUESTS: 429,
});

// Соль и хеш из нулей: под такую строку не подходит ни один пароль,
// а стоит проверка ровно столько же, сколько настоящая
const NOBODY = `$pbkdf2-sha256$i=100000$${"A".repeat(22)}$${"A".repeat(43)}`;

// Самая дорогая работа входа — PBKDF2; считаем, сколько раз её завели
let hashes = 0;

class AuthService {
  #db: Db;

  constructor(db: Db) {
    this.#db = db;
  }

  // Роль клиент не присылает: регистрация заводит только обычного читателя
  async register(email: string, password: string, name: string): Promise<{ id: number; token: string }> {
    hashes += 1;
    const passwordHash = await hashPassword(password);
    try {
      const row = this.#db.users.insert({ email, passwordHash, name, role: "user" });
      return { id: row.id, token: await this.issue(row) };
    } catch (error) {
      // уникальный индекс отказывает так же, как база: 23505 и имя ограничения
      if (error instanceof DbError && error.code === "23505") fail("EMAIL_TAKEN", email);
      throw error;
    }
  }

  async login(email: string, password: string): Promise<{ token: string }> {
    const [row] = this.#db.users.find("users_email_key", email);
    hashes += 1;
    const ok = await verifyPassword(password, row?.passwordHash ?? NOBODY);
    if (row === undefined || !ok) fail("INVALID_CREDENTIALS", email);
    return { token: await this.issue(row) };
  }

  // Одна дверь к учёткам: в таблицу пользователей мимо сервиса никто не ходит
  byId(id: number): UserRow | null {
    const [row] = this.#db.users.where((item) => item.id === id);
    return row ?? null;
  }

  issue(row: UserRow): Promise<string> {
    return signToken(SECRET, { sub: String(row.id), role: row.role, exp: NOW + 30 * DAY });
  }
}

// Проект прошлой статьи целиком: таблицы, репозиторий, сервис заметок — и рядом
// сервис учёток. Контейнер и модули разобраны там же и здесь только мешали бы
const db = new Db();
const notes = new NotesService(new NotesRepo(db));
const auth = new AuthService(db);

// Отказ становится ответом в одном месте — как во всём проекте
const ответ = async (действие: () => Promise<unknown>): Promise<string> => {
  try {
    await действие();
    return "200";
  } catch (error) {
    const res = toResponse(error);
    return `${res.status} ${res.body}`;
  }
};

async function main(): Promise<void> {
  const вера = await auth.register("Вера@example.com", "правильная-лошадь-батарейка", "Вера");
  console.log("регистрация:", `id ${вера.id}, частей в токене ${вера.token.split(".").length}`);

  const попытки: [string, () => Promise<unknown>][] = [
    ["та же почта второй раз   ", () => auth.register("Вера@example.com", "другой-пароль", "Вера")],
    ["почта Ани из проекта     ", () => auth.register("Аня@example.com", "другой-пароль", "Аня")],
    ["вход верным паролем      ", () => auth.login("Вера@example.com", "правильная-лошадь-батарейка")],
    ["вход чужим паролем       ", () => auth.login("Вера@example.com", "правильная-лошадь")],
    ["вход по неизвестной почте", () => auth.login("никого@example.com", "правильная-лошадь-батарейка")],
  ];
  for (const [что, действие] of попытки) console.log(что, await ответ(действие));

  const [row] = db.users.find("users_email_key", "Вера@example.com");
  const части = row.passwordHash.split("$");
  console.log("хеш в таблице:", части[1], части[2], `соль ${fromBase64(части[3]).length} и хеш ${fromBase64(части[4]).length} байт`);
  console.log("проверок пароля:", hashes);
}

main();

// Каркас и доменные коды главы 6, схемы главы 6, таблица главы 9, проект
// прошлой статьи, PBKDF2 и подпись токена главы 10 — в подложке; здесь их типы
type Role = "user" | "admin";
type Status = "draft" | "published";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type Res = { status: number; body: string };
declare class Table<Row> {
  insert(values: object): Row;
  where(match: (row: Row) => boolean): Row[];
  find(indexName: string, value: unknown): Row[];
}
declare class DbError extends Error {
  readonly code: string;
  readonly constraint: string;
}
declare class Db {
  users: Table<UserRow>;
}
declare class NotesRepo {
  constructor(db: Db);
}
declare class NotesService {
  constructor(repo: NotesRepo);
  page(viewer: number, n: number): NoteOut[];
  byId(viewer: number, id: number): NoteOut;
  create(authorId: number, input: { title: string; body: string }): NoteOut;
  publish(viewer: number, id: number): NoteOut;
}
declare const SECRET: string;
declare const STATUS_OF: Record<string, number>;
declare function fail(code: string, detail?: string): never;
declare function toResponse(error: unknown): Res;
declare function hashPassword(password: string): Promise<string>;
declare function verifyPassword(password: string, stored: string): Promise<boolean>;
declare function signToken(secret: string, claims: object): Promise<string>;
declare function fromBase64(part: string): Uint8Array;

// Часы примера: сроку токена нужна точка отсчёта, а не настоящее «сейчас»
const NOW = 1790000000;
const DAY = 24 * 60 * 60;

// Четыре кода доступа — строки той же таблицы, что завела глава 6. В проекте
// они стоят прямо в ней; здесь таблица приезжает подложкой, поэтому дописываются
Object.assign(STATUS_OF, {
  NOT_AUTHENTICATED: 401,
  INVALID_CREDENTIALS: 401,
  WRONG_ROLE: 403,
  TOO_MANY_REQUESTS: 429,
});

// Соль и хеш из нулей: под такую строку не подходит ни один пароль,
// а стоит проверка ровно столько же, сколько настоящая
const NOBODY = `$pbkdf2-sha256$i=100000$${"A".repeat(22)}$${"A".repeat(43)}`;

// Самая дорогая работа входа — PBKDF2; считаем, сколько раз её завели
let hashes = 0;

class AuthService {
  #db: Db;

constructor(db: Db) {
    this.#db = db;
  }

// Роль клиент не присылает: регистрация заводит только обычного читателя
  async register(email: string, password: string, name: string): Promise<{ id: number; token: string }> {
    hashes += 1;
    const passwordHash = await hashPassword(password);
    try {
      const row = this.#db.users.insert({ email, passwordHash, name, role: "user" });
      return { id: row.id, token: await this.issue(row) };
    } catch (error) {
      // уникальный индекс отказывает так же, как база: 23505 и имя ограничения
      if (error instanceof DbError && error.code === "23505") fail("EMAIL_TAKEN", email);
      throw error;
    }
  }

async login(email: string, password: string): Promise<{ token: string }> {
    const [row] = this.#db.users.find("users_email_key", email);
    hashes += 1;
    const ok = await verifyPassword(password, row?.passwordHash ?? NOBODY);
    if (row === undefined || !ok) fail("INVALID_CREDENTIALS", email);
    return { token: await this.issue(row) };
  }

// Одна дверь к учёткам: в таблицу пользователей мимо сервиса никто не ходит
  byId(id: number): UserRow | null {
    const [row] = this.#db.users.where((item) => item.id === id);
    return row ?? null;
  }

issue(row: UserRow): Promise<string> {
    return signToken(SECRET, { sub: String(row.id), role: row.role, exp: NOW + 30 * DAY });
  }
}

// Проект прошлой статьи целиком: таблицы, репозиторий, сервис заметок — и рядом
// сервис учёток. Контейнер и модули разобраны там же и здесь только мешали бы
const db = new Db();
const notes = new NotesService(new NotesRepo(db));
const auth = new AuthService(db);

// Отказ становится ответом в одном месте — как во всём проекте
const ответ = async (действие: () => Promise<unknown>): Promise<string> => {
  try {
    await действие();
    return "200";
  } catch (error) {
    const res = toResponse(error);
    return `${res.status} ${res.body}`;
  }
};

async function main(): Promise<void> {
  const вера = await auth.register("Вера@example.com", "правильная-лошадь-батарейка", "Вера");
  console.log("регистрация:", `id ${вера.id}, частей в токене ${вера.token.split(".").length}`);

const попытки: [string, () => Promise<unknown>][] = [
    ["та же почта второй раз   ", () => auth.register("Вера@example.com", "другой-пароль", "Вера")],
    ["почта Ани из проекта     ", () => auth.register("Аня@example.com", "другой-пароль", "Аня")],
    ["вход верным паролем      ", () => auth.login("Вера@example.com", "правильная-лошадь-батарейка")],
    ["вход чужим паролем       ", () => auth.login("Вера@example.com", "правильная-лошадь")],
    ["вход по неизвестной почте", () => auth.login("никого@example.com", "правильная-лошадь-батарейка")],
  ];
  for (const [что, действие] of попытки) console.log(что, await ответ(действие));

const [row] = db.users.find("users_email_key", "Вера@example.com");
  const части = row.passwordHash.split("$");
  console.log("хеш в таблице:", части[1], части[2], `соль ${fromBase64(части[3]).length} и хеш ${fromBase64(части[4]).length} байт`);
  console.log("проверок пароля:", hashes);
}

main();

страница примера

Сначала предположите, что выведет код

Регистрация прошла, и Вере достался третий номер: две строки в таблице уже были. Обе повторные регистрации получили 409 с одним и тем же кодом, и почта Ани попала под то же правило — индексу нет разницы, кто и когда её занял. Вход верным паролем ответил 200, оба неверных — 401 и одним словом, по которому не догадаться, что именно не сошлось.

Строка хеша в таблице настоящая: имя алгоритма, стоимость, шестнадцать байт соли и тридцать два байта хеша — всё в одном поле. Пустышка устроена так же, поэтому неизвестная почта стоит ровно столько же: та же функция и те же сто тысяч итераций.

А последняя строка — счёт, из-за которого в проекте вообще появится ограничитель. Шесть попыток — шесть PBKDF2, причём две из них потрачены на регистрации, которые всё равно отказали: хеш считается до вставки, потому что до вставки его надо положить в строку. Значит, перебор почт стоит столько же, сколько перебор паролей, и закрывать надо обе процедуры, а не одну.

Одинаковый ответ на неизвестную почту и на неверный пароль — не вежливость, а требование. Одинаковый по времени — то же требование, только про него забывают.

Личность есть — осталось её спросить. Спрашивать будет транспорт, и спрашивать по договору: первая статья главы положила рядом со схемой входа поле access, и в собранном приложении его до сих пор никто не читал. Прочитать его — вся работа этого раздела.

Договор в проекте — единственный список процедур, и это не красивая фраза, а проверяемое свойство: обработчик, которого в договоре нет, недоступен никому. В роутере ниже есть notes.remove; он написан и работает, а в договоре его нет. Что ответят на него админу, стоит предсказать отдельно.

Сама проверка личности — два разных вопроса, и в проекте они разъезжаются по двум функциям. Первый: наш ли это токен — подпись и срок, чистый счёт, ни одного обращения к таблице. Второй: правда ли то, что в нём написано, — роль в токене это прошлое, и сверить её можно только со строкой. Разделены они не для красоты: между ними встанет ограничитель, и в четвёртом разделе будет видно, почему именно там.

Токена нет вовсе — это не отказ. Гостю открыты список и карточка, и, чтобы их отдать, опознавать некого. А вот если токен прислан, но негоден, отвечать гостевой лентой нельзя: человек с истёкшим токеном увидел бы ленту без своих черновиков и решил, что заметки пропали. Опознать и не пустить — два разных действия, и первое бывает нужно без второго.

Отказов у уровня доступа два. 401 — «предъявите удостоверение»: личности нет или она больше не описывает действительность, и новый токен поможет. 403 — «удостоверение годное, а права не те», и новый токен не поможет.

Прогноз: шесть строк. Сначала три человека — гость, Вера с честным токеном и модератор — против четырёх процедур: открытый список, создание заметки, служебная ручка со списком учёток и та самая notes.remove, которой нет в договоре. Потом два негодных токена: у первого подделана подпись, у второго учётку успели удалить. Последняя строка — что вообще отдаёт служебная ручка.

// В подложке всё, что уже написано: каркас и доменные коды главы 6, схемы и
// процедуры главы 6, таблица главы 9, проект и сервис учёток из разделов выше
type Role = "user" | "admin";
type Status = "draft" | "published";
type Access = "guest" | "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type Claims = { sub: string; role: Role; exp: number };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare class Table<Row> {
  insert(values: object): Row;
  where(match: (row: Row) => boolean): Row[];
}
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function procedure<S extends Schema<unknown>, O>(input: S, run: (input: Infer<S>) => O): { input: S; run: (input: Infer<S>) => O };
declare function call(router: object, path: string, raw: unknown): unknown;
declare class HttpError extends Error {
  constructor(status: number, message: string);
}
declare function fail(code: string, detail?: string): never;
declare function toResponse(error: unknown): Res;
declare const SECRET: string;
declare const NOW: number;
declare const DAY: number;
declare const NOBODY: string;
declare function hashPassword(password: string): Promise<string>;
declare function verifyToken(secret: string, token: string, now: number): Promise<Claims | null>;
declare const db: { users: Table<UserRow> };
declare const auth: {
  register(email: string, password: string, name: string): Promise<{ id: number; token: string }>;
  login(email: string, password: string): Promise<{ token: string }>;
  byId(id: number): UserRow | null;
  issue(row: UserRow): Promise<string>;
};
declare const notes: {
  page(viewer: number, n: number): NoteOut[];
  byId(viewer: number, id: number): NoteOut;
  create(authorId: number, input: { title: string; body: string }): NoteOut;
  publish(viewer: number, id: number): NoteOut;
};

// Договор проекта: имя процедуры, схема входа и кому она открыта.
// Список процедур приложения — здесь и больше нигде
const CONTRACT = {
  "auth.register": { input: object({ email: text, password: text, name: text }), access: "guest" },
  "auth.login": { input: object({ email: text, password: text }), access: "guest" },
  "notes.list": { input: object({ page: int }), access: "guest" },
  "notes.byId": { input: object({ id: int }), access: "guest" },
  "notes.create": { input: object({ title: text, body: text }), access: "user" },
  "notes.publish": { input: object({ id: int }), access: "user" },
  "admin.users": { input: object({}), access: "admin" },
} as const;

type Name = keyof typeof CONTRACT;

// Роутер собирается на каждый запрос: личность входит в него замыканием,
// а схему каждая процедура берёт из договора — второго списка схем нет
const routerFor = (who: UserRow | null) => {
  // ноль — это гость: заметок с таким автором в таблице проекта нет
  const viewer = who?.id ?? 0;
  return {
    auth: {
      register: procedure(CONTRACT["auth.register"].input, (i) => auth.register(i.email, i.password, i.name)),
      login: procedure(CONTRACT["auth.login"].input, (i) => auth.login(i.email, i.password)),
    },
    notes: {
      list: procedure(CONTRACT["notes.list"].input, (i) => notes.page(viewer, i.page)),
      byId: procedure(CONTRACT["notes.byId"].input, (i) => notes.byId(viewer, i.id)),
      create: procedure(CONTRACT["notes.create"].input, (i) => notes.create(viewer, i)),
      publish: procedure(CONTRACT["notes.publish"].input, (i) => notes.publish(viewer, i.id)),
      // обработчик написан, а в договоре его нет
      remove: procedure(CONTRACT["notes.byId"].input, (i) => `удалил ${i.id}`),
    },
    admin: {
      users: procedure(CONTRACT["admin.users"].input, () => db.users.where(() => true).map((row) => `${row.name}:${row.role}`)),
    },
  };
};

// Первый вопрос — наш ли это токен: подпись и срок, и ни одного запроса к базе.
// Токена нет вовсе — это не отказ, а гость: опознать и не пустить — разные дела
async function claimsOf(request: Req): Promise<Claims | null> {
  const header = request.headers.authorization ?? "";
  if (!header.startsWith("Bearer ")) return null;
  const claims = await verifyToken(SECRET, header.slice(7), NOW);
  if (claims === null) fail("NOT_AUTHENTICATED", "подпись или срок");
  return claims;
}

// Второй вопрос — правда ли написанное в нём: за тридцать дней роль понижают,
// а учётку стирают, и токен об этом не узнаёт
function identityOf(claims: Claims): UserRow {
  const row = auth.byId(Number(claims.sub));
  if (row === null) fail("NOT_AUTHENTICATED", "учётки больше нет");
  if (row.role !== claims.role) fail("NOT_AUTHENTICATED", "роль изменилась");
  return row;
}

// Уровень доступа — свойство процедуры, и отказа у него два разных.
// Роль берётся из таблицы: в токене она только что сверена со строкой
function allow(access: Access, who: UserRow | null): void {
  if (access === "guest") return;
  if (who === null) fail("NOT_AUTHENTICATED", "нужен вход");
  if (access === "admin" && who.role !== "admin") fail("WRONG_ROLE", who.role);
}

// Три человека проекта: новая читательница и модератор. Пароли Ани и Боба
// заведены прошлой статьёй заглушкой, войти по-настоящему им нечем
async function сцена(): Promise<{ вера: string; мод: string }> {
  const вера = await auth.register("Вера@example.com", "правильная-лошадь-батарейка", "Вера");
  // роль администратора регистрацией не выдаётся: её ставят миграцией или рукой
  const мод = db.users.insert({ email: "мод@example.com", passwordHash: await hashPassword("модератор-тоже-человек"), name: "Мод", role: "admin" });
  return { вера: вера.token, мод: await auth.issue(мод) };
}

// Единственное место, где отказ становится ответом
async function answer(request: Req): Promise<Res> {
  try {
    const record = CONTRACT[request.procedure as Name];
    // договор — единственный список процедур, и транспорт спрашивает его первым
    if (record === undefined) throw new HttpError(404, request.procedure);
    const claims = await claimsOf(request);
    const who = claims === null ? null : identityOf(claims);
    allow(record.access, who);
    return { status: 200, body: JSON.stringify(await call(routerFor(who), request.procedure, request.input)) };
  } catch (error) {
    // схема отказывает TypeError — это неправ клиент, а не программа
    return toResponse(error instanceof TypeError ? new HttpError(400, error.message) : error);
  }
}

async function main(): Promise<void> {
  const токены = await сцена();
  const запрос = (процедура: string, вход: unknown, токен: string): Req => ({
    procedure: процедура,
    input: вход,
    headers: токен === "" ? {} : { authorization: `Bearer ${токен}` },
    ip: "10.0.0.1",
  });

  const процедуры: [string, unknown][] = [
    ["notes.list", { page: 0 }],
    ["notes.create", { title: "Черновик", body: "текст" }],
    ["admin.users", {}],
    ["notes.remove", { id: 1 }],
  ];
  for (const [имя, токен] of [["гость", ""], ["Вера", токены.вера], ["Мод", токены.мод]] as [string, string][]) {
    const строки: string[] = [];
    for (const [процедура, вход] of процедуры) {
      const res = await answer(запрос(процедура, вход, токен));
      строки.push(`${процедура} ${res.status}`);
    }
    console.log(`${имя.padEnd(5)} ${строки.join(", ")}`);
  }

  const подделка = токены.вера.slice(0, -1) + (токены.вера.endsWith("A") ? "B" : "A");
  const призрак = await auth.issue({ id: 99, email: "", passwordHash: "", name: "", role: "user" });
  for (const [что, токен] of [["подпись подделана", подделка], ["учётки нет", призрак]] as [string, string][]) {
    const res = await answer(запрос("notes.create", { title: "Черновик", body: "текст" }, токен));
    console.log(`${что}: ${res.status} ${res.body}`);
  }
  console.log("ответ админу:", (await answer(запрос("admin.users", {}, токены.мод))).body);
}

main();

// В подложке всё, что уже написано: каркас и доменные коды главы 6, схемы и
// процедуры главы 6, таблица главы 9, проект и сервис учёток из разделов выше
type Role = "user" | "admin";
type Status = "draft" | "published";
type Access = "guest" | "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type Claims = { sub: string; role: Role; exp: number };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare class Table<Row> {
  insert(values: object): Row;
  where(match: (row: Row) => boolean): Row[];
}
declare const text: Schema<string>;
declare const int: Schema<number>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function procedure<S extends Schema<unknown>, O>(input: S, run: (input: Infer<S>) => O): { input: S; run: (input: Infer<S>) => O };
declare function call(router: object, path: string, raw: unknown): unknown;
declare class HttpError extends Error {
  constructor(status: number, message: string);
}
declare function fail(code: string, detail?: string): never;
declare function toResponse(error: unknown): Res;
declare const SECRET: string;
declare const NOW: number;
declare const DAY: number;
declare const NOBODY: string;
declare function hashPassword(password: string): Promise<string>;
declare function verifyToken(secret: string, token: string, now: number): Promise<Claims | null>;
declare const db: { users: Table<UserRow> };
declare const auth: {
  register(email: string, password: string, name: string): Promise<{ id: number; token: string }>;
  login(email: string, password: string): Promise<{ token: string }>;
  byId(id: number): UserRow | null;
  issue(row: UserRow): Promise<string>;
};
declare const notes: {
  page(viewer: number, n: number): NoteOut[];
  byId(viewer: number, id: number): NoteOut;
  create(authorId: number, input: { title: string; body: string }): NoteOut;
  publish(viewer: number, id: number): NoteOut;
};

// Договор проекта: имя процедуры, схема входа и кому она открыта.
// Список процедур приложения — здесь и больше нигде
const CONTRACT = {
  "auth.register": { input: object({ email: text, password: text, name: text }), access: "guest" },
  "auth.login": { input: object({ email: text, password: text }), access: "guest" },
  "notes.list": { input: object({ page: int }), access: "guest" },
  "notes.byId": { input: object({ id: int }), access: "guest" },
  "notes.create": { input: object({ title: text, body: text }), access: "user" },
  "notes.publish": { input: object({ id: int }), access: "user" },
  "admin.users": { input: object({}), access: "admin" },
} as const;

type Name = keyof typeof CONTRACT;

// Роутер собирается на каждый запрос: личность входит в него замыканием,
// а схему каждая процедура берёт из договора — второго списка схем нет
const routerFor = (who: UserRow | null) => {
  // ноль — это гость: заметок с таким автором в таблице проекта нет
  const viewer = who?.id ?? 0;
  return {
    auth: {
      register: procedure(CONTRACT["auth.register"].input, (i) => auth.register(i.email, i.password, i.name)),
      login: procedure(CONTRACT["auth.login"].input, (i) => auth.login(i.email, i.password)),
    },
    notes: {
      list: procedure(CONTRACT["notes.list"].input, (i) => notes.page(viewer, i.page)),
      byId: procedure(CONTRACT["notes.byId"].input, (i) => notes.byId(viewer, i.id)),
      create: procedure(CONTRACT["notes.create"].input, (i) => notes.create(viewer, i)),
      publish: procedure(CONTRACT["notes.publish"].input, (i) => notes.publish(viewer, i.id)),
      // обработчик написан, а в договоре его нет
      remove: procedure(CONTRACT["notes.byId"].input, (i) => `удалил ${i.id}`),
    },
    admin: {
      users: procedure(CONTRACT["admin.users"].input, () => db.users.where(() => true).map((row) => `${row.name}:${row.role}`)),
    },
  };
};

// Первый вопрос — наш ли это токен: подпись и срок, и ни одного запроса к базе.
// Токена нет вовсе — это не отказ, а гость: опознать и не пустить — разные дела
async function claimsOf(request: Req): Promise<Claims | null> {
  const header = request.headers.authorization ?? "";
  if (!header.startsWith("Bearer ")) return null;
  const claims = await verifyToken(SECRET, header.slice(7), NOW);
  if (claims === null) fail("NOT_AUTHENTICATED", "подпись или срок");
  return claims;
}

// Второй вопрос — правда ли написанное в нём: за тридцать дней роль понижают,
// а учётку стирают, и токен об этом не узнаёт
function identityOf(claims: Claims): UserRow {
  const row = auth.byId(Number(claims.sub));
  if (row === null) fail("NOT_AUTHENTICATED", "учётки больше нет");
  if (row.role !== claims.role) fail("NOT_AUTHENTICATED", "роль изменилась");
  return row;
}

// Уровень доступа — свойство процедуры, и отказа у него два разных.
// Роль берётся из таблицы: в токене она только что сверена со строкой
function allow(access: Access, who: UserRow | null): void {
  if (access === "guest") return;
  if (who === null) fail("NOT_AUTHENTICATED", "нужен вход");
  if (access === "admin" && who.role !== "admin") fail("WRONG_ROLE", who.role);
}

// Три человека проекта: новая читательница и модератор. Пароли Ани и Боба
// заведены прошлой статьёй заглушкой, войти по-настоящему им нечем
async function сцена(): Promise<{ вера: string; мод: string }> {
  const вера = await auth.register("Вера@example.com", "правильная-лошадь-батарейка", "Вера");
  // роль администратора регистрацией не выдаётся: её ставят миграцией или рукой
  const мод = db.users.insert({ email: "мод@example.com", passwordHash: await hashPassword("модератор-тоже-человек"), name: "Мод", role: "admin" });
  return { вера: вера.token, мод: await auth.issue(мод) };
}

// Единственное место, где отказ становится ответом
async function answer(request: Req): Promise<Res> {
  try {
    const record = CONTRACT[request.procedure as Name];
    // договор — единственный список процедур, и транспорт спрашивает его первым
    if (record === undefined) throw new HttpError(404, request.procedure);
    const claims = await claimsOf(request);
    const who = claims === null ? null : identityOf(claims);
    allow(record.access, who);
    return { status: 200, body: JSON.stringify(await call(routerFor(who), request.procedure, request.input)) };
  } catch (error) {
    // схема отказывает TypeError — это неправ клиент, а не программа
    return toResponse(error instanceof TypeError ? new HttpError(400, error.message) : error);
  }
}

async function main(): Promise<void> {
  const токены = await сцена();
  const запрос = (процедура: string, вход: unknown, токен: string): Req => ({
    procedure: процедура,
    input: вход,
    headers: токен === "" ? {} : { authorization: `Bearer ${токен}` },
    ip: "10.0.0.1",
  });

const процедуры: [string, unknown][] = [
    ["notes.list", { page: 0 }],
    ["notes.create", { title: "Черновик", body: "текст" }],
    ["admin.users", {}],
    ["notes.remove", { id: 1 }],
  ];
  for (const [имя, токен] of [["гость", ""], ["Вера", токены.вера], ["Мод", токены.мод]] as [string, string][]) {
    const строки: string[] = [];
    for (const [процедура, вход] of процедуры) {
      const res = await answer(запрос(процедура, вход, токен));
      строки.push(`${процедура} ${res.status}`);
    }
    console.log(`${имя.padEnd(5)} ${строки.join(", ")}`);
  }

const подделка = токены.вера.slice(0, -1) + (токены.вера.endsWith("A") ? "B" : "A");
  const призрак = await auth.issue({ id: 99, email: "", passwordHash: "", name: "", role: "user" });
  for (const [что, токен] of [["подпись подделана", подделка], ["учётки нет", призрак]] as [string, string][]) {
    const res = await answer(запрос("notes.create", { title: "Черновик", body: "текст" }, токен));
    console.log(`${что}: ${res.status} ${res.body}`);
  }
  console.log("ответ админу:", (await answer(запрос("admin.users", {}, токены.мод))).body);
}

main();

страница примера

Сначала предположите, что выведет код

Матрица собралась из одного поля договора, и ни одного if о правах в обработчиках нет. Гость получил 401 и на создании, и на служебной ручке — в обоих случаях его не опознали. Вера на служебной ручке получила 403: опознали, но роль не та. А notes.remove ответила 404 всем троим, включая админа: обработчик есть, договор о нём молчит, и для транспорта такой процедуры не существует.

Это и есть «закрыто по умолчанию», только у процедур оно достаётся почти бесплатно. В каркасе с контроллерами ради него заводили свой декоратор вместо @Controller, чтобы стража нельзя было забыть; здесь забыть можно только запись в договоре — а без неё процедуры просто нет.

Оба негодных токена ответили 401 и одним кодом. Разными их делать незачем: клиенту в обоих случаях нужно войти заново, а «учётки больше нет» рядом с «подпись не сошлась» рассказывало бы подбирателю, какие номера в таблице заняты.

И про роутер. Собирается он на каждый запрос по прежней причине — ради замыкания с номером читателя, разобранного прошлой статьёй. Новое здесь одно: схему каждая процедура берёт из договора — процедура как значение тем и удобна, что схема лежит рядом с обработчиком, а в проекте это «рядом» указывает в договор.

Потому что читателей у него четыре, и обработчик — не главный. Транспорт решает, пускать ли. Клиент по тому же полю прячет кнопку, которую всё равно не дадут нажать. Описание API ставит по нему пометку о токене. А человек, который смотрит, что открыто наружу, читает один объект вместо сорока обработчиков — притом что обработчик правят чаще всего, и правило, живущее в его теле, переживает эти правки до первой невнимательной.

Список процедур в приложении должен быть один. Второй список — это дверь, о которой забудут.

Роль теперь спрашивается, и половина работы сделана. Вторая половина — про строки. Правило о чужом черновике и чужой опубликованной заметке в проекте уже написано, и написал его сервис заметок прошлой статьи: не видно на чтение — NOT_FOUND, видно — NOT_YOUR_NOTE. Здесь важно другое: роль его не отменяет.

Соблазн выглядит так: модератор на то и модератор, чтобы править чужое. В проекте учебника это неверно намеренно. Роль admin открывает процедуры, у которых строк с авторами нет вовсе: список учёток, журнал, выгрузка. Как только роль начинает обходить владение, правило «править может только автор» превращается в «может автор, а ещё вот эти», и второй список растёт сам собой.

Отсюда и разделение, которое видно в коде транспорта. Уровень доступа решает, пустят ли к процедуре, и решает это транспорт — до всякого чтения. Владение решает, пустят ли к строке, и решает это сервис — сразу после того, как строка прочитана. Сложить их в одно место нельзя физически: у транспорта на своём шаге строки ещё нет.

Второй сюжет раздела — цена перепроверки. Токен живёт тридцать дней и всё это время предъявляет прошлое, подписанное настоящим секретом. О понижении роли знает только строка в таблице, поэтому её и спрашивают на каждом запросе.

Прогноз: шесть строк. Сначала Вера и модератор делают одно и то же: читают чужой черновик, читают чужую опубликованную заметку, пробуют её опубликовать и стучатся в служебную ручку. Потом модератора выводят из модераторов — прямо в таблице, как это и бывает, — и он повторяет служебную ручку и открытый список тем же токеном. Где их ответы совпадут, а где разойдутся?

// В подложке проект, сервис учёток, договор и сборка ответа из разделов выше
type Role = "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare class Table<Row> {
  update(id: number, patch: object): Row | null;
  find(indexName: string, value: unknown): Row[];
}
declare const db: { users: Table<UserRow> };
declare function сцена(): Promise<{ вера: string; мод: string }>;
declare function answer(request: Req): Promise<Res>;

// Ответ коротко: статус и доменный код, если он есть
const код = async (токен: string, процедура: string, вход: unknown): Promise<string> => {
  const res = await answer({
    procedure: процедура,
    input: вход,
    headers: { authorization: `Bearer ${токен}` },
    ip: "10.0.0.1",
  });
  const тело = JSON.parse(res.body) as { code?: string };
  return тело.code === undefined ? String(res.status) : `${res.status} ${тело.code}`;
};

async function main(): Promise<void> {
  const токены = await сцена();

  // Заметки из проекта: у Ани черновик «План побега» и опубликованный «Хлеб и молоко»
  const дела: [string, string, unknown][] = [
    ["чужой черновик     ", "notes.byId", { id: 2 }],
    ["чужая опубликованная", "notes.byId", { id: 1 }],
    ["опубликовать чужую ", "notes.publish", { id: 1 }],
    ["служебная ручка    ", "admin.users", {}],
  ];
  for (const [что, процедура, вход] of дела) {
    console.log(`${что} Вера ${await код(токены.вера, процедура, вход)}, Мод ${await код(токены.мод, процедура, вход)}`);
  }

  // Модератора вывели из модераторов — прямо в таблице, как это и бывает
  const [мод] = db.users.find("users_email_key", "мод@example.com");
  db.users.update(мод.id, { role: "user" });
  console.log("после понижения, служебная ручка:", await код(токены.мод, "admin.users", {}));
  console.log("после понижения, открытый список:", await код(токены.мод, "notes.list", { page: 0 }));
}

main();

// В подложке проект, сервис учёток, договор и сборка ответа из разделов выше
type Role = "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare class Table<Row> {
  update(id: number, patch: object): Row | null;
  find(indexName: string, value: unknown): Row[];
}
declare const db: { users: Table<UserRow> };
declare function сцена(): Promise<{ вера: string; мод: string }>;
declare function answer(request: Req): Promise<Res>;

// Ответ коротко: статус и доменный код, если он есть
const код = async (токен: string, процедура: string, вход: unknown): Promise<string> => {
  const res = await answer({
    procedure: процедура,
    input: вход,
    headers: { authorization: `Bearer ${токен}` },
    ip: "10.0.0.1",
  });
  const тело = JSON.parse(res.body) as { code?: string };
  return тело.code === undefined ? String(res.status) : `${res.status} ${тело.code}`;
};

async function main(): Promise<void> {
  const токены = await сцена();

// Заметки из проекта: у Ани черновик «План побега» и опубликованный «Хлеб и молоко»
  const дела: [string, string, unknown][] = [
    ["чужой черновик     ", "notes.byId", { id: 2 }],
    ["чужая опубликованная", "notes.byId", { id: 1 }],
    ["опубликовать чужую ", "notes.publish", { id: 1 }],
    ["служебная ручка    ", "admin.users", {}],
  ];
  for (const [что, процедура, вход] of дела) {
    console.log(`${что} Вера ${await код(токены.вера, процедура, вход)}, Мод ${await код(токены.мод, процедура, вход)}`);
  }

// Модератора вывели из модераторов — прямо в таблице, как это и бывает
  const [мод] = db.users.find("users_email_key", "мод@example.com");
  db.users.update(мод.id, { role: "user" });
  console.log("после понижения, служебная ручка:", await код(токены.мод, "admin.users", {}));
  console.log("после понижения, открытый список:", await код(токены.мод, "notes.list", { page: 0 }));
}

main();

страница примера

Сначала предположите, что выведет код

Первые три строки у Веры и у модератора совпали до кода: чужой черновик — 404, чужая опубликованная — 200 на чтение и 403 на публикацию. Роль не дала модератору ничего, потому что владение про неё не спрашивает. Разошлись они на четвёртой строке — на процедуре, у которой строк с авторами нет.

Две последние строки — про понижение. Служебная ручка ответила 401, и это ожидаемо: роль в токене больше не совпадает со строкой. А вот открытый список ответил тем же 401, хотя гостю он открыт. Дело в том, что гость — это отсутствие токена, а не негодный токен: модератор токен прислал, и на нём споткнулась перепроверка. Плата за такой выбор видна сразу — понизили роль, и человек на следующем же запросе оказывается на экране входа, пока клиент не сходит за новым токеном.

Тогда это не обход владения, а отдельная процедура: не notes.publish от чужого имени, а своя — со своим входом, своим доменным кодом и своей записью в журнал. Разница не формальная. У обычной правки нет места, куда записать, что правку сделал не автор, и заводить его незачем: автору такая запись не нужна. У процедуры модерации это место есть по условию, и отвечает за неё роль, а не владение.

Роль открывает процедуру, а не строку. Как только роль начинает открывать строки, правило владения кончилось.

Ограничитель в проекте нужнее всего одной паре процедур — гостевым. Вход и регистрация токена не требуют, а стоят дорого: PBKDF2 дорог намеренно, и счёт из первого раздела это показал. Устройство ограничителя — ключ, окно и пауза — уже разобрано, и числа здесь те же: десять вызовов, окно в минуту, пауза в минуту. Новых вопросов два: где он стоит и что считает.

Место у него единственное. После подписи — потому что из подписи читается ключ. До похода в таблицу — потому что иначе перебор оплачивался бы запросами к базе, то есть тем самым, что ограничитель и защищает. Между двумя вопросами о личности оказалась ровно та щель, для которой их и разделили.

Ключ выбирает уровень доступа. Гостевую процедуру считают по адресу: человека у неё нет по определению. Процедуру с личностью — по человеку, и адрес на её счёт не влияет вовсе. У процедур синхронизации так и сделано: за одним NAT адрес общий, и предел делился бы там на всех. Числа у синхронизации тоже свои — многостраничная выдача упирается в потолок из десяти вызовов на одиннадцатой странице, — а в проекте потолок один на все процедуры.

Имя процедуры входит в ключ в обоих случаях, и это не мелочь: на общем ключе перебор пароля закрыл бы и восстановление пароля — единственную дверь, через которую жертва могла бы вернуться. Это и есть третья задача статьи.

И оговорка, без которой ограничитель — украшение: адрес берётся из запроса, а настоящий адрес клиента там оказывается только если сервер настроен верить заголовку обратного прокси. Где проходит эта граница — в главе про выкладку; без доверия сюда приедет адрес контейнера прокси, один на весь интернет.

Прогноз: семь строк. Двенадцать попыток входа подряд с одного адреса — строкой статусы, потом сколько PBKDF2 за них посчитано и что лежит в теле последнего ответа. Дальше тот же вход с другого адреса, открытый список с первого адреса и вход через две минуты модельных часов. Последняя строка — одиннадцать созданий заметки одним токеном, но с двух разных адресов поочерёдно.

// В подложке проект, сервис учёток, договор и сборка ответа из разделов выше
type Role = "user" | "admin";
type Access = "guest" | "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Claims = { sub: string; role: Role; exp: number };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
type Name = "auth.register" | "auth.login" | "notes.list" | "notes.byId" | "notes.create" | "notes.publish" | "admin.users";
declare const CONTRACT: Record<Name, { input: Schema<unknown>; access: Access }>;
declare function routerFor(who: UserRow | null): object;
declare function claimsOf(request: Req): Promise<Claims | null>;
declare function identityOf(claims: Claims): UserRow;
declare function allow(access: Access, who: UserRow | null): void;
declare function сцена(): Promise<{ вера: string; мод: string }>;
declare function call(router: object, path: string, raw: unknown): unknown;
declare class HttpError extends Error {
  constructor(status: number, message: string);
}
declare function fail(code: string, detail?: string): never;
declare function toResponse(error: unknown): Res;
declare let hashes: number;

// Ограничитель частоты: ключ, окно и пауза — те же три вещи, что у звена tRPC.
// Новое здесь одно: какой ключ выбрать, решает уровень доступа из договора
const LIMIT = 10;
const WINDOW = 60_000;
const BLOCK = 60_000;

type Counter = { hits: number; expiresAt: number; blockedUntil: number };
const counters = new Map<string, Counter>();

// Часы ограничителя модельные: с настоящими вывод зависел бы от скорости машины
let clock = 0;

// Гостевую процедуру считают по адресу, процедуру с личностью — по человеку:
// за одним NAT адрес общий, и предел делился бы там на всех сразу. Человека
// берём из подписанного токена, до всякого похода в таблицу
const keyFor = (request: Req, claims: Claims | null): string =>
  `${request.procedure}:${claims === null ? request.ip : `u${claims.sub}`}`;

function hit(key: string): void {
  const known = counters.get(key);
  const counter = known !== undefined && clock < known.expiresAt ? known : { hits: 0, expiresAt: clock + WINDOW, blockedUntil: 0 };
  counters.set(key, counter);
  // стук в паузу не считается: иначе пауза продлевала бы сама себя
  if (clock < counter.blockedUntil) fail("TOO_MANY_REQUESTS", key);
  counter.hits += 1;
  if (counter.hits > LIMIT) {
    counter.blockedUntil = clock + BLOCK;
    fail("TOO_MANY_REQUESTS", key);
  }
}

// Та же сборка ответа, и в ней одна новая строка. Место у неё единственное:
// после подписи, потому что ключ читается из неё, и до похода в таблицу
async function answer(request: Req): Promise<Res> {
  try {
    const record = CONTRACT[request.procedure as Name];
    if (record === undefined) throw new HttpError(404, request.procedure);
    const claims = await claimsOf(request);
    hit(keyFor(request, claims));
    const who = claims === null ? null : identityOf(claims);
    allow(record.access, who);
    return { status: 200, body: JSON.stringify(await call(routerFor(who), request.procedure, request.input)) };
  } catch (error) {
    return toResponse(error instanceof TypeError ? new HttpError(400, error.message) : error);
  }
}

async function main(): Promise<void> {
  const токены = await сцена();
  const запрос = (процедура: string, вход: unknown, ip: string, токен = ""): Req => ({
    procedure: процедура,
    input: вход,
    headers: токен === "" ? {} : { authorization: `Bearer ${токен}` },
    ip,
  });
  const вход = (ip: string) => запрос("auth.login", { email: "Вера@example.com", password: "не тот пароль" }, ip);

  const было = hashes;
  const ответы: Res[] = [];
  for (let i = 0; i < 12; i += 1) ответы.push(await answer(вход("10.0.0.1")));
  console.log("двенадцать попыток входа:", ответы.map((res) => res.status).join(" "));
  console.log("хешей посчитано за них:", hashes - было);
  console.log("тело последнего ответа:", ответы[11].body);

  console.log("тот же вход с другого адреса:", (await answer(вход("10.0.0.2"))).status);
  console.log("список с первого адреса:", (await answer(запрос("notes.list", { page: 0 }, "10.0.0.1"))).status);

  clock += WINDOW + BLOCK;
  console.log("через две минуты:", (await answer(вход("10.0.0.1"))).status);

  // у процедуры с личностью ключ другой, и адрес на него не влияет
  const создания: number[] = [];
  for (let i = 0; i < 11; i += 1) {
    const ip = i % 2 === 0 ? "10.0.0.1" : "10.0.0.9";
    создания.push((await answer(запрос("notes.create", { title: "Ещё заметка", body: "текст" }, ip, токены.вера))).status);
  }
  console.log("одиннадцать созданий с двух адресов:", создания.join(" "));
}

main();

// В подложке проект, сервис учёток, договор и сборка ответа из разделов выше
type Role = "user" | "admin";
type Access = "guest" | "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Claims = { sub: string; role: Role; exp: number };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
type Name = "auth.register" | "auth.login" | "notes.list" | "notes.byId" | "notes.create" | "notes.publish" | "admin.users";
declare const CONTRACT: Record<Name, { input: Schema<unknown>; access: Access }>;
declare function routerFor(who: UserRow | null): object;
declare function claimsOf(request: Req): Promise<Claims | null>;
declare function identityOf(claims: Claims): UserRow;
declare function allow(access: Access, who: UserRow | null): void;
declare function сцена(): Promise<{ вера: string; мод: string }>;
declare function call(router: object, path: string, raw: unknown): unknown;
declare class HttpError extends Error {
  constructor(status: number, message: string);
}
declare function fail(code: string, detail?: string): never;
declare function toResponse(error: unknown): Res;
declare let hashes: number;

// Ограничитель частоты: ключ, окно и пауза — те же три вещи, что у звена tRPC.
// Новое здесь одно: какой ключ выбрать, решает уровень доступа из договора
const LIMIT = 10;
const WINDOW = 60_000;
const BLOCK = 60_000;

type Counter = { hits: number; expiresAt: number; blockedUntil: number };
const counters = new Map<string, Counter>();

// Часы ограничителя модельные: с настоящими вывод зависел бы от скорости машины
let clock = 0;

// Гостевую процедуру считают по адресу, процедуру с личностью — по человеку:
// за одним NAT адрес общий, и предел делился бы там на всех сразу. Человека
// берём из подписанного токена, до всякого похода в таблицу
const keyFor = (request: Req, claims: Claims | null): string =>
  `${request.procedure}:${claims === null ? request.ip : `u${claims.sub}`}`;

// Та же сборка ответа, и в ней одна новая строка. Место у неё единственное:
// после подписи, потому что ключ читается из неё, и до похода в таблицу
async function answer(request: Req): Promise<Res> {
  try {
    const record = CONTRACT[request.procedure as Name];
    if (record === undefined) throw new HttpError(404, request.procedure);
    const claims = await claimsOf(request);
    hit(keyFor(request, claims));
    const who = claims === null ? null : identityOf(claims);
    allow(record.access, who);
    return { status: 200, body: JSON.stringify(await call(routerFor(who), request.procedure, request.input)) };
  } catch (error) {
    return toResponse(error instanceof TypeError ? new HttpError(400, error.message) : error);
  }
}

async function main(): Promise<void> {
  const токены = await сцена();
  const запрос = (процедура: string, вход: unknown, ip: string, токен = ""): Req => ({
    procedure: процедура,
    input: вход,
    headers: токен === "" ? {} : { authorization: `Bearer ${токен}` },
    ip,
  });
  const вход = (ip: string) => запрос("auth.login", { email: "Вера@example.com", password: "не тот пароль" }, ip);

const было = hashes;
  const ответы: Res[] = [];
  for (let i = 0; i < 12; i += 1) ответы.push(await answer(вход("10.0.0.1")));
  console.log("двенадцать попыток входа:", ответы.map((res) => res.status).join(" "));
  console.log("хешей посчитано за них:", hashes - было);
  console.log("тело последнего ответа:", ответы[11].body);

console.log("тот же вход с другого адреса:", (await answer(вход("10.0.0.2"))).status);
  console.log("список с первого адреса:", (await answer(запрос("notes.list", { page: 0 }, "10.0.0.1"))).status);

clock += WINDOW + BLOCK;
  console.log("через две минуты:", (await answer(вход("10.0.0.1"))).status);

// у процедуры с личностью ключ другой, и адрес на него не влияет
  const создания: number[] = [];
  for (let i = 0; i < 11; i += 1) {
    const ip = i % 2 === 0 ? "10.0.0.1" : "10.0.0.9";
    создания.push((await answer(запрос("notes.create", { title: "Ещё заметка", body: "текст" }, ip, токены.вера))).status);
  }
  console.log("одиннадцать созданий с двух адресов:", создания.join(" "));
}

main();

страница примера

Сначала предположите, что выведет код

Десять попыток отказали по паролю, одиннадцатая — по частоте, двенадцатая попала уже в паузу и до счётчика не дошла: считать её значило бы продлевать паузу стуком в неё. PBKDF2 за эти двенадцать попыток посчитан десять раз — два последних запроса обошлись без хеша вовсе, и ровно ради этого ограничитель стоит там, где стоит.

Следующие три строки — про первую половину ключа. Тот же вход с другого адреса начинает со своего первого вызова. Открытый список с уже наказанного адреса проходит: имя процедуры входит в ключ, и перебор пароля не закрыл ничего, кроме входа. А через две минуты модельных часов истекли и пауза, и окно, и вход снова отвечает по паролю.

Последняя строка — про вторую половину. Одиннадцать созданий ушли с двух адресов поочерёдно, а предел сработал так, будто адрес один: у процедуры с личностью его в ключе нет. То же свойство читается и в обратную сторону — двое за одним адресом не делят предел, — и именно из-за этого ключ у гостевых и негостевых процедур разный.

Край окна у проекта остался таким же дырявым, каким его посчитала глава 8: окно открывается первым вызовом и живёт ровно минуту, поэтому девять вызовов в конце одного окна и десять в начале следующего проходят подряд. Скользящее окно и корзина с пополнением проекту дороже своей пользы.

Ограничитель, поставленный после похода в базу, защищает не базу, а обработчик. Перебор всё равно оплачивается запросами, просто платит за них не тот, кто перебирает.

Всё собрано. Соберём и сценарий — последовательность запросов, какую делает живой клиент: гость приходит на пустом месте, получает ленту, натыкается на отказ, регистрируется под именем Веры, входит, работает со своими и чужими заметками, а в конце с чужого адреса начинают подбирать её пароль.

Одну строку стоит предсказать отдельно, и она не про доступ. Вера регистрируется и тут же входит тем же паролем. Токен, выданный при регистрации, и токен, полученный при входе, — это одна строка или две?

Прогноз: двенадцать строк. Что ответит гость на создании заметки, что увидит Вера в списке после того, как заведёт свою, что ответит чужой черновик и на какой по счёту попытке подбор пароля получит отказ.

// Проект целиком — в подложке: таблицы и сервисы прошлой статьи, сервис учёток,
// договор, личность, уровень доступа и ограничитель из разделов выше
type Status = "draft" | "published";
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare function answer(request: Req): Promise<Res>;

// Тело ответа коротко: список — заголовками, отказ — кодом, выдача токена — числом частей
const кратко = (body: string): string => {
  const value: unknown = JSON.parse(body);
  if (Array.isArray(value)) return (value as NoteOut[]).map((row) => row.title).join(" | ");
  const запись = value as { code?: string; token?: string; id?: number; title?: string; status?: string };
  if (запись.code !== undefined) return запись.code;
  if (запись.token !== undefined) return `${запись.id === undefined ? "" : `id ${запись.id}, `}токен из ${запись.token.split(".").length} частей`;
  if (запись.title !== undefined) return `${запись.title} (${запись.status})`;
  return body;
};

const шаг = async (кто: string, токен: string, процедура: string, вход: unknown, ip = "10.0.0.1"): Promise<string> => {
  const res = await answer({
    procedure: процедура,
    input: вход,
    headers: токен === "" ? {} : { authorization: `Bearer ${токен}` },
    ip,
  });
  console.log(`${кто.padEnd(5)} ${процедура.padEnd(13)} ${res.status} ${кратко(res.body)}`);
  return res.body;
};

const токенИз = (body: string): string => (JSON.parse(body) as { token: string }).token;

async function main(): Promise<void> {
  await шаг("гость", "", "notes.list", { page: 0 });
  await шаг("гость", "", "notes.create", { title: "Список покупок", body: "молоко" });

  const выдан = токенИз(await шаг("гость", "", "auth.register", { email: "Вера@example.com", password: "правильная-лошадь-батарейка", name: "Вера" }));
  await шаг("Вера", "", "auth.login", { email: "Вера@example.com", password: "правильная-лошадь" });
  const токен = токенИз(await шаг("Вера", "", "auth.login", { email: "Вера@example.com", password: "правильная-лошадь-батарейка" }));
  console.log("токен входа и токен регистрации:", токен === выдан ? "одна строка" : "разные строки");

  await шаг("Вера", токен, "notes.byId", { id: 2 });
  await шаг("Вера", токен, "notes.create", { title: " Список покупок ", body: "молоко" });
  await шаг("Вера", токен, "notes.publish", { id: 6 });
  await шаг("Вера", токен, "notes.list", { page: 0 });

  // с чужого адреса подбирают пароль Веры
  const коды: number[] = [];
  for (let i = 0; i < 11; i += 1) {
    const res = await answer({ procedure: "auth.login", input: { email: "Вера@example.com", password: `подбор-${i}` }, headers: {}, ip: "203.0.113.7" });
    коды.push(res.status);
  }
  console.log(`${"чужой".padEnd(5)} ${"auth.login×11".padEnd(13)} ${коды.join(" ")}`);
  await шаг("Вера", "", "auth.login", { email: "Вера@example.com", password: "правильная-лошадь-батарейка" });
}

main();

// Проект целиком — в подложке: таблицы и сервисы прошлой статьи, сервис учёток,
// договор, личность, уровень доступа и ограничитель из разделов выше
type Status = "draft" | "published";
type NoteOut = { id: number; title: string; body: string; status: Status; author: string };
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare function answer(request: Req): Promise<Res>;

// Тело ответа коротко: список — заголовками, отказ — кодом, выдача токена — числом частей
const кратко = (body: string): string => {
  const value: unknown = JSON.parse(body);
  if (Array.isArray(value)) return (value as NoteOut[]).map((row) => row.title).join(" | ");
  const запись = value as { code?: string; token?: string; id?: number; title?: string; status?: string };
  if (запись.code !== undefined) return запись.code;
  if (запись.token !== undefined) return `${запись.id === undefined ? "" : `id ${запись.id}, `}токен из ${запись.token.split(".").length} частей`;
  if (запись.title !== undefined) return `${запись.title} (${запись.status})`;
  return body;
};

const шаг = async (кто: string, токен: string, процедура: string, вход: unknown, ip = "10.0.0.1"): Promise<string> => {
  const res = await answer({
    procedure: процедура,
    input: вход,
    headers: токен === "" ? {} : { authorization: `Bearer ${токен}` },
    ip,
  });
  console.log(`${кто.padEnd(5)} ${процедура.padEnd(13)} ${res.status} ${кратко(res.body)}`);
  return res.body;
};

const токенИз = (body: string): string => (JSON.parse(body) as { token: string }).token;

async function main(): Promise<void> {
  await шаг("гость", "", "notes.list", { page: 0 });
  await шаг("гость", "", "notes.create", { title: "Список покупок", body: "молоко" });

const выдан = токенИз(await шаг("гость", "", "auth.register", { email: "Вера@example.com", password: "правильная-лошадь-батарейка", name: "Вера" }));
  await шаг("Вера", "", "auth.login", { email: "Вера@example.com", password: "правильная-лошадь" });
  const токен = токенИз(await шаг("Вера", "", "auth.login", { email: "Вера@example.com", password: "правильная-лошадь-батарейка" }));
  console.log("токен входа и токен регистрации:", токен === выдан ? "одна строка" : "разные строки");

await шаг("Вера", токен, "notes.byId", { id: 2 });
  await шаг("Вера", токен, "notes.create", { title: " Список покупок ", body: "молоко" });
  await шаг("Вера", токен, "notes.publish", { id: 6 });
  await шаг("Вера", токен, "notes.list", { page: 0 });

// с чужого адреса подбирают пароль Веры
  const коды: number[] = [];
  for (let i = 0; i < 11; i += 1) {
    const res = await answer({ procedure: "auth.login", input: { email: "Вера@example.com", password: `подбор-${i}` }, headers: {}, ip: "203.0.113.7" });
    коды.push(res.status);
  }
  console.log(`${"чужой".padEnd(5)} ${"auth.login×11".padEnd(13)} ${коды.join(" ")}`);
  await шаг("Вера", "", "auth.login", { email: "Вера@example.com", password: "правильная-лошадь-батарейка" });
}

main();

страница примера

Сначала предположите, что выведет код

Токен оказался одной строкой, и это не совпадение: сервер не помнит выданных токенов, а строка — это подписанное значение полей, и при тех же полях и том же секрете она та же. Заодно видна и цена такого устройства: отозвать его нечем, и именно поэтому роль в нём перепроверяется на каждом запросе.

Остальное читается по журналу. Гостю на создании ответили 401, и дальше не работало ничто: ни разбор входа, ни обработчик, ни база. Чужой черновик ответил Вере 404 — тем же, чем ответил бы номер, которого никогда не было. Её заметка получила шестой номер и встала в списке первой, потому что новее остальных; гость её не увидит, пока она черновик. А перебор с чужого адреса отказал на одиннадцатой попытке и вход самой Веры не задел: адрес другой, и счёт у каждого свой.

Стоит заметить и то, чего в этом выводе нет: ни одного if про права в обработчиках, ни второго места, где отказ превращается в статус, ни одной проверки владения вне сервиса — и ни одной процедуры, которую можно позвать, не назвав в договоре. Ради последнего свойства договор и писался раньше кода.

На этом проект умеет всё, что обещал договор, и делает это на коде, написанном читателем от таблицы до подписи токена. Осталось довести его до адреса: последняя статья главы собирает образ, проводит миграции при выкате и разбирает первое падение.

Сценарий — это не тест. Тест проверяет одно место, сценарий показывает, что места сложились в порядок.

Регистрация считает хеш до вставки, а занятость почты проверяет уникальный индекс, а не отдельный запрос: отказ приезжает кодом 23505 и становится доменным EMAIL_TAKEN одной строкой.
Вход отвечает одним словом и на неизвестную почту, и на неверный пароль — и одинаково по времени: неизвестная почта сверяется с хешем-пустышкой той же стоимости. Два разных ответа превратили бы форму входа в список зарегистрированных.
Личность — два разных вопроса: наш ли токен (подпись и срок, без базы) и правда ли написанное в нём (строка в таблице). Между ними и встаёт ограничитель: ключ читается из подписи, а поход в таблицу перебором не оплачивается.
Уровень доступа — свойство процедуры и живёт в договоре, а договор — единственный список процедур приложения. Поэтому обработчик без записи в нём отвечает 404 даже админу.
Роль открывает процедуру, владение — строку. Модератор проходит уровень доступа и получает 403 на чужой заметке: правило «править может автор» роль не отменяет, а служебные ручки — это процедуры, у которых строк с авторами нет вовсе.
Ограничитель считает гостевые процедуры по адресу, а процедуры с личностью — по человеку, и имя процедуры входит в ключ в обоих случаях: на общем ключе перебор пароля закрыл бы и регистрацию, и восстановление.

1/4Вход отвечает одинаково и на неизвестную почту, и на неверный пароль. Зачем при неизвестной почте сервер всё равно считает PBKDF2 — по хешу-пустышке?

2/4Модератор с ролью admin получил 403 на попытке опубликовать чужую заметку. Что это значит?

3/4Модератора понизили до обычного читателя. Его прежний токен получает 401 даже на открытом списке, который отдают гостю. Почему?

4/4Процедура notes.remove написана в роутере и работает, но в договоре её нет. Что ответит транспорт админу, который её позвал?

Роль, присланная клиентом

Регистрацию написали в первый день, и в схеме её входа есть role: роль у пользователя есть, значит, её надо передать. Посмотрите, что после этого отвечает служебная ручка тому, кто только что зарегистрировался, и закройте дыру. Искать надо в схеме входа и в обработчике, а не в страже: страж здесь ни при чём, он ответил на свой вопрос верно.

type Role = "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare class Table<Row> {
  insert(values: object): Row;
}
declare const text: Schema<string>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function parse<T>(schema: Schema<T>, value: unknown, path: string): T;
declare function hashPassword(password: string): Promise<string>;
declare const db: { users: Table<UserRow> };
declare const auth: { issue(row: UserRow): Promise<string> };
declare function answer(request: Req): Promise<Res>;

// Регистрация, написанная в первый день: что прислали, то и записали
const входРегистрации = object({ email: text, password: text, name: text, role: oneOf("user", "admin") });

const зарегистрировать = async (raw: unknown): Promise<string> => {
  const вход = parse(входРегистрации, raw, "auth.register");
  const row = db.users.insert({
    email: вход.email,
    passwordHash: await hashPassword(вход.password),
    name: вход.name,
    role: вход.role,
  });
  return auth.issue(row);
};

async function main(): Promise<void> {
  const токен = await зарегистрировать({ email: "злой@example.com", password: "тоже-пароль", name: "Злой", role: "admin" });
  const res = await answer({
    procedure: "admin.users",
    input: {},
    headers: { authorization: `Bearer ${токен}` },
    ip: "10.0.0.1",
  });
  console.log("служебная ручка тому, кто только что зарегистрировался:", res.status, res.body);
}

main();

type Role = "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
type Infer<S> = S extends Schema<infer T> ? T : never;
type Res = { status: number; body: string };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare class Table<Row> {
  insert(values: object): Row;
}
declare const text: Schema<string>;
declare function oneOf<T extends string>(...allowed: T[]): Schema<T>;
declare function object<F extends Record<string, Schema<unknown>>>(fields: F): Schema<{ [K in keyof F]: Infer<F[K]> }>;
declare function parse<T>(schema: Schema<T>, value: unknown, path: string): T;
declare function hashPassword(password: string): Promise<string>;
declare const db: { users: Table<UserRow> };
declare const auth: { issue(row: UserRow): Promise<string> };
declare function answer(request: Req): Promise<Res>;

// Регистрация, написанная в первый день: что прислали, то и записали
const входРегистрации = object({ email: text, password: text, name: text, role: oneOf("user", "admin") });

const зарегистрировать = async (raw: unknown): Promise<string> => {
  const вход = parse(входРегистрации, raw, "auth.register");
  const row = db.users.insert({
    email: вход.email,
    passwordHash: await hashPassword(вход.password),
    name: вход.name,
    role: вход.role,
  });
  return auth.issue(row);
};

async function main(): Promise<void> {
  const токен = await зарегистрировать({ email: "злой@example.com", password: "тоже-пароль", name: "Злой", role: "admin" });
  const res = await answer({
    procedure: "admin.users",
    input: {},
    headers: { authorization: `Bearer ${токен}` },
    ip: "10.0.0.1",
  });
  console.log("служебная ручка тому, кто только что зарегистрировался:", res.status, res.body);
}

main();

страница примера

Сначала предположите, что выведет код

Роль — не поле ввода, и в схеме входа её быть не должно вовсе. Того, чего в схеме нет, object в разобранное значение не переносит — присланное клиентом role не доедет до обработчика даже случайно, и второй проверки «а можно ли тебе такую роль» не понадобится.

tsлистинг · не запускается

const входРегистрации = object({ email: text, password: text, name: text });

const зарегистрировать = async (raw: unknown): Promise<string> => {
  const вход = parse(входРегистрации, raw, "auth.register");
  const row = db.users.insert({
    email: вход.email,
    passwordHash: await hashPassword(вход.password),
    name: вход.name,
    role: "user",
  });
  return auth.issue(row);
};

const входРегистрации = object({ email: text, password: text, name: text });

const зарегистрировать = async (raw: unknown): Promise<string> => {
  const вход = parse(входРегистрации, raw, "auth.register");
  const row = db.users.insert({
    email: вход.email,
    passwordHash: await hashPassword(вход.password),
    name: вход.name,
    role: "user",
  });
  return auth.issue(row);
};

После правки та же попытка получает 403 с кодом WRONG_ROLE: учётка завелась, а роль у неё обычная. Повышение до модератора — отдельное действие с уровнем доступа admin или рука администратора в базе; в проекте такой процедуры нет намеренно.

В боевом API учебника то же самое сделано схемой таблицы: у колонки role стоит default('user'), регистрация её не присылает вовсе — репозиторий получает только почту, хеш и имя, — и на это есть отдельная проверка в тестах сервиса, которая смотрит роль свежей учётки.

Две учётки на одну почту

Вера зарегистрировалась, потом ввела свою почту с маленькой буквы и зарегистрировалась снова. Уникальный индекс не возразил. Посмотрите, сколько теперь в таблице строк с её почтой и что после этого отвечает вход, и сделайте так, чтобы второй регистрации не случилось. Индекс правьте последним: сначала решите, что вообще попадает в таблицу.

type Role = "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Res = { status: number; body: string };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
declare class Table<Row> {
  where(match: (row: Row) => boolean): Row[];
}
declare const text: Schema<string>;
declare function parse<T>(schema: Schema<T>, value: unknown, path: string): T;
declare function toResponse(error: unknown): Res;
declare const db: { users: Table<UserRow> };
declare const auth: {
  register(email: string, password: string, name: string): Promise<{ id: number; token: string }>;
  login(email: string, password: string): Promise<{ token: string }>;
};

const ответ = async (действие: () => Promise<unknown>): Promise<string> => {
  try {
    await действие();
    return "200";
  } catch (error) {
    const res = toResponse(error);
    return `${res.status} ${(JSON.parse(res.body) as { code: string }).code}`;
  }
};

async function main(): Promise<void> {
  console.log("Вера регистрируется:      ", await ответ(() => auth.register("Вера@example.com", "правильная-лошадь-батарейка", "Вера")));
  console.log("и ещё раз, с маленькой:   ", await ответ(() => auth.register("вера@example.com", "совсем другой пароль", "Вера")));
  console.log("строк с этой почтой:      ", db.users.where((row) => row.email.toLowerCase() === "вера@example.com").length);
  console.log("вход первым паролем:      ", await ответ(() => auth.login("Вера@example.com", "правильная-лошадь-батарейка")));
  console.log("тот же пароль, почта иначе:", await ответ(() => auth.login("вера@example.com", "правильная-лошадь-батарейка")));
}

main();

type Role = "user" | "admin";
type UserRow = { id: number; email: string; passwordHash: string; name: string; role: Role };
type Res = { status: number; body: string };
type Issue = { path: string; message: string };
type Result<T> = { ok: true; value: T } | { ok: false; issues: Issue[] };
interface Schema<T> {
  check(value: unknown, path: string): Result<T>;
}
declare class Table<Row> {
  where(match: (row: Row) => boolean): Row[];
}
declare const text: Schema<string>;
declare function parse<T>(schema: Schema<T>, value: unknown, path: string): T;
declare function toResponse(error: unknown): Res;
declare const db: { users: Table<UserRow> };
declare const auth: {
  register(email: string, password: string, name: string): Promise<{ id: number; token: string }>;
  login(email: string, password: string): Promise<{ token: string }>;
};

const ответ = async (действие: () => Promise<unknown>): Promise<string> => {
  try {
    await действие();
    return "200";
  } catch (error) {
    const res = toResponse(error);
    return `${res.status} ${(JSON.parse(res.body) as { code: string }).code}`;
  }
};

async function main(): Promise<void> {
  console.log("Вера регистрируется:      ", await ответ(() => auth.register("Вера@example.com", "правильная-лошадь-батарейка", "Вера")));
  console.log("и ещё раз, с маленькой:   ", await ответ(() => auth.register("вера@example.com", "совсем другой пароль", "Вера")));
  console.log("строк с этой почтой:      ", db.users.where((row) => row.email.toLowerCase() === "вера@example.com").length);
  console.log("вход первым паролем:      ", await ответ(() => auth.login("Вера@example.com", "правильная-лошадь-батарейка")));
  console.log("тот же пароль, почта иначе:", await ответ(() => auth.login("вера@example.com", "правильная-лошадь-батарейка")));
}

main();

страница примера

Сначала предположите, что выведет код

Уникальный индекс сравнивает то, что ему дали, и Вера@example.com с вера@example.com для него разные строки. Значит, приводить почту к одному виду надо до него — схемой, и той же схемой в обоих местах, где почта приходит от клиента: в регистрации и во входе. Исправить только регистрацию хуже, чем не исправить ничего: учётка будет одна, а войти по ней получится не всегда.

jsлистинг · не запускается

const email: Schema<string> = {
  check(value, path) {
    const result = text.check(value, path);
    return result.ok ? { ok: true, value: result.value.toLowerCase() } : result;
  },
};

const email: Schema<string> = {
  check(value, path) {
    const result = text.check(value, path);
    return result.ok ? { ok: true, value: result.value.toLowerCase() } : result;
  },
};

С ней вторая регистрация получает 409 и код EMAIL_TAKEN, строка с этой почтой в таблице одна, а вход принимает почту в любом написании. Схема при этом не отменяет ограничения в базе: правило живёт в таблице, а не в обработчике, и уникальность обязана держаться по тому же приведённому виду — иначе двойника заведёт первая же дверь, которую напишут мимо схемы.

В боевом API учебника это ровно так и написано: и регистрация, и вход приводят почту к нижнему регистру, а в комментарии рядом сказано, что того же требует ограничение в таблице — иначе Ivan@mail.ru и ivan@mail.ru стали бы разными учётными записями.

Ограничитель, у которого ключ — адрес

Ограничитель написан, окно и предел верные, а ключ — только адрес. Одиннадцать попыток входа с одного адреса выбирают предел; посмотрите, что после этого отвечает регистрация с того же адреса, и исправьте ключ, не поднимая предел.

type Role = "user" | "admin";
type Claims = { sub: string; role: Role; exp: number };
type Req = { procedure: string; input: unknown; headers: Record<string, string>; ip: string };
declare function hit(key: string): void;

// Ограничитель, у которого ключ — только адрес
const ключ = (request: Req): string => request.ip;

const стук = (процедура: string, ip: string): string => {
  try {
    hit(ключ({ procedure: процедура, input: null, headers: {}, ip }));
    return "пропуск";
  } catch {
    return "отказ";
  }
};

// Одиннадцать попыток входа с одного адреса — предел выбран
for (let i = 0; i < 11; i += 1) стук("auth.login", "10.0.0.1");

console.log("ещё один вход с того же адреса:", стук("auth.login", "10.0.0.1"));
console.log("регистрация с того же адреса: ", стук("auth.register", "10.0.0.1"));
console.log("вход с другого адреса:        ", стук("auth.login", "10.0.0.2"));

страница примера

Сначала предположите, что выведет код

В ключ входит имя процедуры, а у процедуры с личностью вместо адреса встаёт номер из подписанного токена: перебор входа тогда закрывает вход и только его, а люди за одним адресом не делят предел.

tsлистинг · не запускается

const ключ = (request: Req, claims: Claims | null): string =>
  `${request.procedure}:${claims === null ? request.ip : `u${claims.sub}`}`;

const ключ = (request: Req, claims: Claims | null): string =>
  `${request.procedure}:${claims === null ? request.ip : `u${claims.sub}`}`;

Проверять это надо не на входе, а на соседе: после одиннадцати попыток регистрация с того же адреса обязана пройти. Дыра, которую закрывает имя процедуры, на самой процедуре не видна вовсе — она видна только на второй.

В боевом API учебника у функции ключа в комментарии сказано, что общий на все процедуры ключ был бы хуже дважды: перебор входа закрывал бы восстановление пароля, то есть единственную дверь, через которую жертва могла бы вернуться, — а вдобавок хранилище счёта держит флаг блокировки на самом ключе, и снятие паузы у одного адреса задевало бы счётчики остальных.

Вход, владение, роли, лимиты

Видеоразбор темы за 5–7 минут

Регистрация и вход: один отказ на две причиныЗанятость почты проверяет индекс, а не отдельный запрос, и вход не рассказывает, какая половина пары не сошлась

Одна дверь: уровень доступа читает транспортЛичность приезжает токеном, список процедур лежит в договоре, и второго списка в приложении нет

Роль открывает процедуру, владение — строкуМодератор проходит уровень доступа и упирается в чужую заметку, а понижение роли выбрасывает его токен целиком

Одиннадцатая попытка входаОграничитель встаёт между подписью и таблицей, а ключ ему выбирает уровень доступа из договора

Итогошпаргалка по теме

Проверьте себявопросы по теме

Задачизадачи с решениями

Роль, присланная клиентом

Две учётки на одну почту

Ограничитель, у которого ключ — адрес