Навигация

Безопасность Node API

Безопасность бэкенда начинается не с библиотеки, а с ответа на вопрос: что сервис считает доверенным. Почти все дыры в Node API — это либо недоверенные данные, попавшие в код или в запрос, либо конфигурация, открытая шире, чем нужно по умолчанию. Разберём обвязку Express-приложения от заголовков и CORS до SSRF и supply chain, а OWASP API Top 10 используем как чеклист, а не как список страшилок.

Содержание

  1. Модель угроз и OWASP API Top 10
  2. Security-заголовки и helmet
  3. CORS: точечная настройка
  4. Rate limiting и брутфорс
  5. Инъекции: SQL, NoSQL и команды
  6. SSRF: сервер ходит по чужим адресам
  7. Path traversal и файлы
  8. Небезопасная десериализация
  9. Секреты, зависимости и supply chain
  10. Практика: TaskFlow
  11. Частые ошибки
  12. Ключевые тезисы для интервью
  13. Заключение
  14. Полезные ссылки

Модель угроз и OWASP API Top 10

Доверенного в HTTP-запросе мало: метод, путь и, с оговорками, заголовки, которые ставит инфраструктура. Всё остальное — тело, query, cookie, x-forwarded-*, имена файлов, ответы внешних API — приходит от клиента или из сети и доверия не заслуживает. Отдельно стоит запомнить: «внутренняя сеть» — не признак доверия. Запрос с вашего сервера к соседнему сервису выглядит легитимным именно потому, что его отправили вы.

Отсюда три принципа, на которых держится всё остальное:

  • Данные остаются данными. Значение из запроса не должно становиться частью SQL, shell-команды или имени файла без явного преобразования.
  • Отказ по умолчанию. Неизвестный origin, неизвестный адрес исходящего запроса, неизвестное поле в теле — это отказ, а не «пропустим и посмотрим».
  • Наружу — минимум. Клиенту не нужны стек, текст ошибки драйвера и passwordHash; атакующему они нужны.

OWASP API Security Top 10 — удобная карта, чтобы не изобретать таксономию заново. Пункты стоит примерить к своему сервису и вычеркнуть те, которых нет; слепое копирование чеклиста даёт ложное чувство закрытости.

ПунктСутьГде смотреть в Node
API1: BOLAдоступ к чужому объекту по подобранному idownerId в where, а не проверка после выборки — «Аутентификация в API»
API2: Broken Authenticationслабые токены, отсутствие отзыва, перебор«Аутентификация в API», раздел про rate limit ниже
API3: BOPLAmass assignment и лишние поля в ответеstrict-схемы и DTO — «Конфигурация и валидация»
API4: Unrestricted Resource Consumptionнеограниченное тело, пагинация и загрузкилимиты тела и запросов, таймауты
API5: BFLAвызов админской функции обычным пользователемrequirePermission на каждом маршруте
API6: Sensitive Business Flowsавтомат на сценарии вроде заказа или регистрациилимиты по бизнес-действию, а не по URL
API7: SSRFсервер ходит по адресу, который дал клиентраздел про SSRF
API8: MisconfigurationCORS, заголовки, дефолтные учётки, стек в ответеразделы про helmet и CORS
API9: Inventoryзабытые /v1, /debug, открытый Swaggerреестр маршрутов и версий
API10: Unsafe Consumptionбезоговорочное доверие ответу чужого APIпарсить как unknown, ставить таймауты

Два пункта из таблицы легко недооценить. API3 — это не только «клиент передал role», но и обратное: res.json(user) отдаёт всю строку из базы вместе с passwordHash и внутренними флагами. Лечится тем же ответом, что и mass assignment: явная форма ответа, а не «что достали, то и отдали». API6 — про то, что лимит «300 запросов в минуту» не мешает создать миллион аккаунтов за час, если каждый шаг укладывается в лимит.

Общая теория атак и клиентская сторона — в разделе «Безопасность». Здесь — серверная реализация в Node.


Security-заголовки и helmet

Заголовки безопасности — это инструкции браузеру, а не серверу. curl и мобильный клиент их проигнорируют, поэтому защитой от подбора пароля или SSRF они не являются. Зато там, где ответ читает браузер — JSON API с cookie, отдача файлов, Swagger UI, HTML-страницы ошибок, — они закрывают целый класс атак.

helmet собирает разумный набор в одном middleware:

// src/app.js
import helmet from 'helmet';

app.disable('x-powered-by');
app.use(helmet({
  contentSecurityPolicy: false,                       // JSON API: HTML не отдаём
  crossOriginResourcePolicy: { policy: 'same-site' }, // файлы и картинки API
  hsts: { maxAge: 15_552_000, includeSubDomains: true },
}));
ЗаголовокЧто запрещаетКому важен
Strict-Transport-Securityработу по HTTP после первого HTTPS, downgradeвсем, кто на HTTPS
X-Content-Type-Options: nosniffMIME-sniffing при отдаче файловзагрузкам, статике, JSON
X-Frame-Options / frame-ancestorsвстраивание ответа в iframeHTML-страницам, docs
Referrer-Policyутечку полного URL в чужой Refererвсем
Content-Security-Policyисполнение скриптов с чужих источниковтолько HTML
Cross-Origin-Resource-Policyчтение ответа с чужого originфайлам и картинкам
Permissions-Policyкамеру, геолокацию, микрофон во фреймеHTML

Три уточнения, которые чаще всего путают:

  • HSTS включают только когда весь домен уже на HTTPS. Браузер запоминает заголовок на maxAge секунд и перестаёт пускать по HTTP; с includeSubDomains это касается и поддоменов, которые могут быть не готовы. preload почти необратим — домен попадает в список, поставляемый с браузером.
  • CSP для JSON-ответов бесполезна. Она срабатывает при разборе HTML. Если сервис отдаёт только JSON, её отключают; если рядом живёт Swagger UI или страница ошибки — настраивают для них отдельно.
  • x-powered-by — утечка, а не украшение. Заголовок сообщает, что за сервер и какой фреймворк; это первый шаг к подбору известной уязвимости версии. app.disable('x-powered-by') убирает его, но Server от nginx всё равно стоит скрыть в конфиге прокси.

Заголовки — гигиена, а не защита. Приложение без HSTS, но с параметризованными запросами безопаснее, чем приложение с идеальным helmet и конкатенацией SQL. Подробный разбор каждого заголовка — в статье «HTTP-заголовки безопасности».


CORS: точечная настройка

CORS — механизм браузера, который ослабляет same-origin policy: сервер говорит, каким origin разрешено прочитать его ответ. Ключевое слово — прочитать. Запрос уходит и выполняется на сервере в любом случае; без разрешающих заголовков браузер просто не отдаст ответ скрипту. Поэтому CORS не защищает API: curl, мобильное приложение и чужой бэкенд заголовки игнорируют.

Отсюда главная ошибка — считать CORS защитой. Вторая по частоте — конфигурация «на всякий случай пошире»:

// плохо: любой сайт читает ответы с cookie пользователя
app.use(cors({ origin: true, credentials: true }));

origin: true отражает присланный Origin обратно в Access-Control-Allow-Origin. Вместе с credentials: true это значит, что браузер приложит cookie и разрешит скрипту прочитать ответ. Достаточно, чтобы пользователь открыл чужую страницу, — и она получит его задачи через ваш API. Без CORS-заголовков вообще такой сценарий не работал бы: ответ остался бы непрочитанным.

Правильная настройка — allowlist с точным сравнением:

// src/app.js
import cors from 'cors';
import { config } from './config.js';

app.use(cors({
  origin(origin, callback) {
    // нет Origin: curl, серверные клиенты, same-origin GET — CORS не нужен
    if (!origin) return callback(null, false);
    callback(null, config.CORS_ORIGINS.includes(origin));
  },
  credentials: true,
  methods: ['GET', 'POST', 'PATCH', 'DELETE'],
  allowedHeaders: ['content-type', 'authorization'],
  maxAge: 600,
}));

Что здесь важно:

  • Список — из конфига, а не из запроса. config.CORS_ORIGINS валидируется на старте вместе с остальным конфигом; попасть туда через req.headers.origin нельзя.
  • credentials: true только если действительно нужны cookie. С Authorization: Bearer он не нужен, и тогда поверхность уже. Access-Control-Allow-Origin: * с credentials браузер всё равно отклонит.
  • Preflight не требует аутентификации. Браузер шлёт OPTIONS без cookie и без Authorization; если authenticate стоит раньше cors, preflight получит 401, и настоящий запрос не уйдёт. Порядок слоёв — часть конфигурации безопасности.
  • Vary: Origin обязателен. Иначе кеш на CDN отдаст ответ с одним Allow-Origin клиенту с другим origin. Пакет cors ставит его сам, когда origin не *, но при ручной реализации про него забывают.
  • Same-site развёртывание не требует CORS вовсе. Если фронтенд и API живут на одном origin, cross-origin запросов нет, и любой cors() — лишняя поверхность.

CORS не заменяет ни CSRF-защиту, ни авторизацию. Cookie-сессии остаются уязвимы к CSRF независимо от CORS: форма с чужого сайта отправит запрос, даже если ответ не прочитает. Механика — в статье «Аутентификация в API» и «CSRF: как браузер становится оружием».


Rate limiting и брутфорс

Лимиты решают две разные задачи, и путать их дорого. Защита ресурсов ограничивает нагрузку: сколько запросов в минуту, какого размера тело, сколько страниц можно запросить. Защита от перебора ограничивает попытки угадать секрет: пароль, OTP, токен сброса, промокод. Ключи и режимы отказа у них разные.

Атомарный счётчик на Redis и Lua-скрипт разобраны в статье «Redis и фоновые задачи»; здесь — где ставить лимит и что он должен защищать:

МаршрутКлючЛимитРежим отказа
POST /api/auth/loginIP + email5 за 15 минут, с задержкойfail-closed
POST /api/auth/registerIP3 в часfail-closed
POST /api/auth/password-resetemail + IP3 в часfail-closed
GET /api/*userId или IP300 в минутуfail-open
POST /api/uploadsuserId10 в часfail-closed

Логика в каждой строке своя:

  • Логин считается по двум ключам сразу. Лимит только по IP обходится ботнетом: сто адресов по одной попытке в лимит не попадут. Лимит только по email позволяет с одного IP перебирать тысячи аккаунтов. Счётчик IP + email ловит оба сценария, а глобальный лимит по IP остаётся вторым слоем.
  • Режим отказа выбирают по цене пропуска. Если Redis недоступен, обычные чтения лучше пропустить: иначе падение кеша превращается в падение API. Для логина наоборот: пропуск означает «перебора нет ограничений», поэтому запрос отклоняют с 503, а не пропускают.
  • Лимит по пользователю, а не по URL. Счётчик на маршрут наказывает всех клиентов за одного; счётчик на userId изолирует нарушителя. Для неаутентифицированных остаётся IP, но он должен быть настоящим.

Про req.ip отдельно: за балансировщиком он равен адресу прокси, если не настроен trust proxy. Тогда все клиенты делят один счётчик, а честный лимит превращается в глобальный. Сколько прокси доверять — фиксированное число хопов, а не true: иначе клиент подставит x-forwarded-for и обойдёт лимит сам (подробнее — в статье «Express и middleware»).

Rate limit — только первый слой защиты от брутфорса. Поверх него:

  • Прогрессивная задержка. После нескольких неудач ответ замедляется — это дороже для перебора, чем 429, и не блокирует аккаунт навсегда.
  • Счётчик попыток на аккаунт с уведомлением. Пользователь узнаёт о подозрительной активности раньше, чем её заметит поддержка.
  • Одинаковые ответы на «нет пользователя» и «неверный пароль» плюс проверка dummy-хеша — иначе лимит не мешает перечислять зарегистрированные адреса («Аутентификация в API»).
  • Защита от lockout-DoS. Постоянная блокировка аккаунта после N попыток позволяет злоумышленнику закрыть доступ владельцу. Лучше временное окно и CAPTCHA, чем «заблокирован до звонка в поддержку».

Второй вид лимитов — на потребление ресурсов. Тело запроса ограничивает express.json({ limit: '100kb' }); пагинацию — серверный максимум limit, а не значение из query; загрузки — размер файла и число файлов; тяжёлые запросы — statement_timeout в базе («Доступ к базам данных»). Отдельно ставят таймаут на весь запрос: без него медленный клиент держит соединение и память, пока сам не решит уйти.

429 — ожидаемый ответ, а не сбой: его не логируют как error, но считают в метриках вместе с 401. Всплеск 401 на логине — первый признак перебора.


Инъекции: SQL, NoSQL и команды

Инъекция — это ситуация, когда данные становятся кодом в чужом интерпретаторе: SQL-парсере, движке запросов Mongo, shell, шаблонизаторе, LDAP. Механизм везде один: строка собирается конкатенацией, и граница между синтаксисом и значением исчезает.

SQL. В pg значение передаётся параметром, а не подставляется в текст: $1 идёт отдельным сообщением протокола, и ' or 1=1 -- остаётся строкой. Имя таблицы, колонки и направление сортировки параметром передать нельзя — их берут из allowlist-словаря. Подробно, с примерами и ловушкой ilike, — в статье «Доступ к базам данных».

NoSQL. Здесь ловушка другая: в запрос попадает не строка, а объект целиком.

// плохо: тело запроса уходит в запрос как есть
const user = await db.collection('users').findOne({
  email: req.body.email,
  password: req.body.password,
});

Тело {"email": {"$ne": null}, "password": {"$ne": null}} превращает условие в «любой пользователь, у которого есть email и пароль» — вход без пароля. Лечится на границе: схема требует z.string().email(), а в запрос попадают только явно перечисленные поля. Дополнительно запрещают операторы вроде $where (исполнение JS на стороне Mongo) и ключи, начинающиеся с $ или содержащие точку, если объект всё же приходит извне.

Команды. exec запускает строку через shell, поэтому ;, $() и обратные кавычки в аргументе — это уже код. execFile и spawn без shell: true передают аргументы массивом, и shell их не разбирает:

import { execFile } from 'node:child_process';
import { promisify } from 'node:util';

const run = promisify(execFile);

// плохо: shell разберёт строку, и ввод станет командой
await run(`pdftoppm -png ${req.file.path} ${outDir}/page`);

// хорошо: бинарь и аргументы разделены
await run('pdftoppm', ['-png', req.file.path, `${outDir}/page`], {
  timeout: 10_000,
  maxBuffer: 1024 * 1024,
});

Три правила для внешних процессов: бинарь выбирается из фиксированного списка, а не из запроса; shell: true с пользовательским вводом не используется никогда; у процесса есть таймаут и лимит вывода, иначе «безопасная» команда становится способом съесть память.

Прочие интерпретаторы. Серверные шаблонизаторы экранируют вывод по умолчанию, но {{{ }}} в Handlebars и !{} в Pug экранирование отключают — их применяют только к доверенным данным. HTML-письма собираются с экранированием имени пользователя, иначе письмо становится фишингом от вашего домена. Заголовки ответа Node валидирует сам и бросает ERR_INVALID_CHAR на перевод строки, но res.redirect(req.query.next) — это open redirect, и next проверяют как относительный путь из allowlist.

Валидация и инъекции связаны, но не заменяют друг друга. Схема гарантирует, что email — строка, а sort — одно из трёх значений; параметризация гарантирует, что эта строка не станет синтаксисом. Первое без второго оставляет дыру в динамическом SQL, второе без первого — мусор в базе и 500 вместо 422.


SSRF: сервер ходит по чужим адресам

SSRF (server-side request forgery) возникает там, где URL приходит от пользователя, а запрос делает сервер: вебхуки, импорт по ссылке, аватар по URL, генерация PDF или скриншота, предпросмотр ссылок, прокси-эндпоинт. Клиент не может достучаться до внутренней сети — а ваш сервер может, и именно от его имени уходит запрос.

Поэтому SSRF опаснее XSS для бэкенда. XSS исполняется в браузере жертвы и ограничен origin; SSRF исполняется из доверенной сети и достаёт то, что снаружи не видно:

  • http://169.254.169.254/ — metadata-эндпоинт облака, откуда утекают токены роли инстанса;
  • http://localhost:6379 и другие внутренние сервисы без аутентификации;
  • админки, k8s API, Docker socket, базы и очереди;
  • внутренние health- и debug-эндпоинты, меняющие состояние по GET.

Даже без ответа клиенту (blind SSRF) атака работает: достаточно, чтобы запрос дошёл.

Держать только blocklist частных диапазонов недостаточно: он перечисляет то, чего нельзя, а обходы догоняют его — DNS rebinding, IPv6, IPv4-mapped адреса вида ::ffff:127.0.0.1, decimal-IP 2130706433, редирект с разрешённого хоста на внутренний. Там, где адрес можно ограничить, берут allowlist доменов: вебхук подписывается на конкретный хост интеграции, а не на произвольный URL. Если адрес действительно произвольный, остаётся проверка резолвнутого адреса по запрещённым диапазонам — второй слой, а не единственная защита:

// src/lib/outbound.js
import { lookup } from 'node:dns/promises';
import { BlockList } from 'node:net';

const blocked = new BlockList();
blocked.addSubnet('0.0.0.0', 8, 'ipv4');
blocked.addSubnet('10.0.0.0', 8, 'ipv4');
blocked.addSubnet('127.0.0.0', 8, 'ipv4');
blocked.addSubnet('169.254.0.0', 16, 'ipv4');
blocked.addSubnet('172.16.0.0', 12, 'ipv4');
blocked.addSubnet('192.168.0.0', 16, 'ipv4');
blocked.addSubnet('::1', 128, 'ipv6');
blocked.addSubnet('fc00::', 7, 'ipv6');
blocked.addSubnet('fe80::', 10, 'ipv6');

export async function assertPublicUrl(raw) {
  const url = new URL(raw);

  if (url.protocol !== 'http:' && url.protocol !== 'https:') {
    throw new HttpError(422, 'unsupported protocol');
  }

  const { address, family } = await lookup(url.hostname);
  if (blocked.check(address, family === 6 ? 'ipv6' : 'ipv4')) {
    throw new HttpError(422, 'destination not allowed');
  }

  return url;
}

Проверять нужно резолвнутый адрес, а не строку хоста: internal.example.com может указывать на 10.0.0.5, а BlockList нормализует IPv4-mapped IPv6, которые строковое сравнение пропускает. Дальше запрос собирают так, чтобы проверка не разошлась с реальностью:

export async function safeFetch(rawUrl, { timeoutMs = 3000, maxBytes = 1_000_000, ...init } = {}) {
  const url = await assertPublicUrl(rawUrl);

  const response = await fetch(url, {
    ...init,
    redirect: 'manual', // адрес из Location не проверен — по нему не идём
    signal: AbortSignal.timeout(timeoutMs),
    headers: { 'user-agent': 'taskflow-webhook/1.0', ...init.headers },
  });

  if (response.status >= 300 && response.status < 400) {
    throw new HttpError(422, 'redirects are not allowed');
  }

  // content-length не обязателен: при chunked его нет
  const length = Number(response.headers.get('content-length') ?? 0);
  if (length > maxBytes) throw new HttpError(502, 'response too large');

  return { status: response.status, body: await response.text() };
}

Две вещи этот код закрывает лишь частично. DNS rebinding: между lookup и фактическим соединением fetch резолвит имя заново, и второй ответ может указывать внутрь. Надёжные варианты — allowlist доменов (для вебхуков он и так нужен), egress-proxy с собственными правилами или пиннинг уже проверенного адреса через connect.lookup в undici-агенте. Размер ответа: content-length — только подсказка, а text() буферизует тело целиком, поэтому жёсткий лимит ставят на потоке — читают порциями и рвут соединение при превышении — либо на egress-proxy.

Во внутреннюю сеть исходящий трафик вообще не должен ходить по умолчанию: network policy «наружу только через прокси» делает SSRF бессмысленным, даже если проверка URL где-то забыта.


Path traversal и файлы

Работа с файлами даёт две классические ошибки: выход за пределы каталога и доверие тому, что загрузили. Первая начинается с безобидного join:

// плохо: join нормализует путь, но не ограничивает каталог
const file = path.join('storage/uploads', req.params.name);
res.sendFile(file); // name = '../../.env'

path.join склеивает и схлопывает сегменты ..; результат вполне корректно указывает на файл вне uploads. Ограничение появляется только при проверке итогового абсолютного пути:

// src/lib/files.js
import path from 'node:path';
import { realpath } from 'node:fs/promises';

const UPLOADS = path.resolve('storage/uploads');

export async function resolveUpload(userPath) {
  const target = path.resolve(UPLOADS, userPath);

  if (!target.startsWith(UPLOADS + path.sep)) {
    throw new HttpError(400, 'invalid path');
  }

  // символическая ссылка внутри uploads может вести наружу
  const real = await realpath(target);
  if (!real.startsWith(UPLOADS + path.sep)) {
    throw new HttpError(400, 'invalid path');
  }

  return real;
}

realpath разрешает символические ссылки: без него достаточно положить в uploads ссылку на /etc, чтобы проверка префикса прошла. Если файла нет, realpath бросает ENOENT — это 404, а не 500.

Надёжнее вообще не принимать имя файла от клиента. Сервер генерирует идентификатор (UUID), хранит в базе исходное имя и владельца, а отдаёт файл через контроллер, который проверяет права: тогда traversal невозможен по конструкции, а не по проверке. Для публичной статики работает express.static, но res.sendFile и res.download с пользовательским путём — нет.

Загрузки требуют отдельной гигиены:

  • Тип проверяют по содержимому, а не по content-type и расширению: первые байты файла (magic bytes) надёжнее заголовка от клиента.
  • Файл не исполняется и не отдаётся из webroot. Хранилище вне корня статики, отдача — через контроллер или отдельный домен.
  • Отдача с Content-Disposition: attachment и nosniff. Иначе загруженный HTML или SVG откроется в вашем origin и получит доступ к cookie.
  • Архивы проверяют на zip-slip и zip-bomb. Каждая запись распаковки проходит ту же проверку пути, а суммарный распакованный размер ограничен — иначе десять килобайт архива разворачиваются в гигабайты.
  • Изображения перекодируют перед публикацией: EXIF и GPS в метаданных утекают, а парсер изображений — частая цель.

Небезопасная десериализация

Десериализация — превращение байтов в объект. В Node это почти всегда JSON.parse, и сам по себе он безопасен: не исполняет код и не создаёт функции. Опасность в том, что происходит с результатом дальше: его передают в Object.assign, в merge настроек, в ORM или в проверку прав, ожидая конкретную форму.

Mass assignment. Тело запроса попадает в обновление сущности целиком:

// плохо: клиент присвоит role, ownerId и всё остальное
await users.update(req.params.id, req.body);

// хорошо: разрешённые поля перечислены явно
const patch = UpdateProfileSchema.parse(req.body); // z.strictObject
await users.update(req.params.id, { displayName: patch.displayName });

Схема решает две задачи: отбрасывает неизвестные ключи и не даёт подставить поле, которого нет в DTO. Дополнительно идентификаторы берут из проверенного контекста, а не из тела, — иначе клиент назначает себя владельцем чужой задачи («Аутентификация в API»).

Prototype pollution. JSON.parse('{"__proto__":{"isAdmin":true}}') создаёт объект с собственным свойством __proto__ — само по себе это безвредно. Проблема начинается в Object.assign и рекурсивных merge: они вызывают одноимённый сеттер, и прототип цели подменяется. Неаккуратный deep merge может дойти до Object.prototype, после чего if (user.isAdmin) истинно у любого объекта в процессе.

const evil = JSON.parse('{"__proto__":{"isAdmin":true}}');
const user = Object.assign({}, evil);

console.log(user.isAdmin); // true — свойство пришло из прототипа

Защита складывается из трёх вещей: входящие объекты разбирают strict-схемой, а не мержат как есть; словари по пользовательским ключам держат в Map или Object.create(null); при возможности запускают Node с --disable-proto=throw, чтобы обращение к __proto__ падало. Проверять Object.prototype в тестах полезно: загрязнение легко пропустить и трудно заметить в проде.

Исполнение кода. eval, new Function и node:vm не являются песочницей — документация vm прямо говорит, что модуль не предназначен для изоляции недоверенного кода. Пакеты вроде node-serialize, разбирающие функции из строки, дают прямой RCE. YAML-парсеры с небезопасными тегами и !!js/function — тот же класс. Правило простое: десериализуйте данные, а не поведение; если нужен плагин-исполнитель, выносите его в отдельный процесс с ограниченными правами.

Отдельно — cookie и токены. JSON в cookie недоверенный, даже если cookie «внутренняя»: значение проверяют подписью и схемой. JWT — подписанный, но читаемый формат; проверка подписи, alg, iss и aud обязательна («Аутентификация в API»).


Секреты, зависимости и supply chain

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

Правила, которые закрывают большую часть инцидентов:

  • Источник — secret store платформы (Vault, Kubernetes Secrets, менеджер облака), а не файл в репозитории. .env — локальный инструмент разработчика, он в .gitignore, а рядом лежит .env.example без значений («Конфигурация и валидация»).
  • Секреты разные по средам. Продовый JWT_SECRET не должен совпадать со стендовым: иначе утечка стенда открывает прод.
  • Права минимальны. Пользователь базы для приложения не делает DDL; для миграций — отдельный. Ключ, которым подписывают сессию, не подписывает платежи.
  • Логи редактируются. authorization, cookie, set-cookie, токены и пароли вырезаются redaction’ом до записи («Логирование и наблюдаемость»).
  • Ротация — не разовое мероприятие. Секрет, который никто не менял три года, уже, вероятно, где-то скопирован. Ротация должна быть процедурой, а не героическим усилием.
  • Утечка в git не лечится удалением коммита. История, форки и кеши GitHub сохраняют объекты; единственный надёжный шаг — считать секрет скомпрометированным и отозвать его. Секрет-сканер в CI ловит это до пуша.

Вторая половина раздела — зависимости. node_modules — это код, который вы исполняете с полными правами процесса, и он обновляется без вашего участия. Поэтому:

  • Lockfile в git. package-lock.json (или pnpm-lock.yaml) фиксирует точное дерево. Без него две сборки одного коммита дают разные версии.
  • npm ci вместо npm install в CI. Установка идёт строго по lockfile, а расхождение с package.json — ошибка сборки, а не тихое обновление. В pnpm то же самое делает --frozen-lockfile.
  • npm audit — нижняя граница, а не гарантия. Он знает опубликованные CVE в известных пакетах и не видит вредоносный код, typosquatting и логический бэкдор. Его запускают с --omit=dev, чтобы шум dev-зависимостей не убивал сигнал, и разбирают результат, а не глушат audit fix --force.
  • Минимум зависимостей. Каждый пакет — это его автор, его транзитивные зависимости и его postinstall. Пакет на 40 строк иногда дешевле написать самому.
  • Postinstall-скрипты — вектор. ignore-scripts=true или allowlist вроде @lavamoat/allow-scripts там, где не нужны postinstall-шаги нативных пакетов; для остальных список доверенных фиксируют явно.
  • Provenance и подписи. npm audit signatures проверяет подписи registry, а публикация с provenance привязывает пакет к конкретному коммиту и CI. Это не спасает от злонамеренного мейнтейнера, но делает подмену заметнее.
  • Обновления ревьюят, а не автомержат. Dependabot и Renovate экономят время, но мажор и новый пакет — повод посмотреть diff, а не нажать merge.

Ставить @latest в продакшене, ставить пакеты по имени из чата и копировать curl | bash из README — три способа получить чужой код в процессе. Подробнее про экосистему и lockfile — в статье «npm и экосистема пакетов», про атаки на цепочку поставок — в разделе «Безопасность зависимостей и supply chain».


Практика: TaskFlow

Соберём security-обвязку для API из статей «Express и middleware», «Аутентификация в API» и «Доступ к базам данных».

1. Порядок middleware. Он и есть конфигурация безопасности: заголовки и CORS раньше маршрутов, лимит по IP — до разбора тела, error middleware — последним.

// src/app.js
import express from 'express';
import helmet from 'helmet';
import cors from 'cors';
import { rateLimit } from './lib/rate-limit.js';
import { errorHandler } from './middleware/error.js';
import { config } from './config.js';
import { authRouter } from './routes/auth.js';
import { tasksRouter } from './routes/tasks.js';

export const app = express();

app.disable('x-powered-by');
app.set('trust proxy', config.TRUST_PROXY_HOPS);

app.use(helmet({
  contentSecurityPolicy: false,
  crossOriginResourcePolicy: { policy: 'same-site' },
  hsts: { maxAge: 15_552_000, includeSubDomains: true },
}));

app.use(cors({
  origin: (origin, callback) => callback(null, !origin || config.CORS_ORIGINS.includes(origin)),
  credentials: true,
  allowedHeaders: ['content-type', 'authorization'],
  methods: ['GET', 'POST', 'PATCH', 'DELETE'],
  maxAge: 600,
}));

// Лимит по адресу — до парсера: отклоняем запрос, не читая тело
app.use('/api', rateLimit({
  limit: 300,
  windowMs: 60_000,
  key: (req) => req.ip,
}));

app.use(express.json({ limit: '100kb', strict: true }));

app.use('/api/auth', authRouter);
app.use('/api/tasks', tasksRouter);

app.use(errorHandler);

2. Лимит на логин. Здесь ключ включает email, поэтому middleware стоит после парсера тела — внутри роутера, а не в app.js.

// src/routes/auth.js
authRouter.post('/login',
  rateLimit({
    limit: 5,
    windowMs: 15 * 60_000,
    key: (req) => `${req.ip}:${req.body?.email ?? ''}`,
    failClosed: true, // Redis недоступен — логин отклоняем
  }),
  validate({ body: CredentialsSchema }),
  login,
);

3. Исходящие запросы. Единственная точка, через которую сервис ходит по внешним адресам, — иначе проверка неизбежно забывается в одном из обработчиков.

// src/services/webhooks.js
import { safeFetch } from '../lib/outbound.js';

export async function deliverWebhook(endpoint, event) {
  const { status } = await safeFetch(endpoint.url, {
    timeoutMs: 3000,
    method: 'POST',
    headers: { 'content-type': 'application/json' },
    body: JSON.stringify(event),
  });

  if (status >= 500) throw new RetryableError(`webhook ${endpoint.id} failed`);
}

4. Файлы. Скачивание вложения проверяет владельца и путь, а не только существование файла.

// src/routes/attachments.js
router.get('/:id', async (req, res) => {
  const attachment = await attachments.findOwned(req.params.id, req.user.id);
  if (!attachment) throw new HttpError(404, 'attachment not found');

  const file = await resolveUpload(attachment.storagePath);
  const name = attachment.originalName.replace(/["\\\r\n]/g, '_');

  res.setHeader('x-content-type-options', 'nosniff');
  res.setHeader('content-disposition', `attachment; filename="${name}"`);
  res.sendFile(file);
});

5. CI. Lockfile, аудит и сборка без dev-зависимостей.

- run: npm ci
- run: npm audit --omit=dev --audit-level=high

npm ci упадёт, если package-lock.json разошёлся с package.json, — это и есть защита от «локально работало».

Что закрыто: заголовки и CORS настроены точечно; лимиты стоят на логине и на API, с разными режимами отказа; тело ограничено; исходящие запросы проходят через проверку адреса; файлы отдаются только владельцу и только из uploads; зависимости ставятся по lockfile и проверяются на известные CVE.

Что добавляют в проде: egress-proxy с сетевыми правилами, WAF и защита от ботов на публичных формах, CSP для Swagger UI, пентест перед крупными релизами, ротация секретов по расписанию, mTLS между внутренними сервисами и алерты на всплеск 401/429. Следующий шаг — статья «Производительность и память»: часть security-инцидентов приходит не из атаки, а из утечки памяти и падения под нагрузкой.


Частые ошибки

  • cors() по умолчанию на приватном API. Access-Control-Allow-Origin: * для данных, которые не публичны.
  • origin: true вместе с credentials: true. Любой сайт читает ответы от имени пользователя.
  • CORS считают защитой API. Запрос всё равно выполняется; curl заголовки не читает.
  • authenticate раньше cors. Preflight получает 401, и браузер не отправляет настоящий запрос.
  • trust proxy не настроен. req.ip — адрес прокси, лимит общий, а x-forwarded-for подделывается клиентом.
  • rateLimit в памяти процесса. За балансировщиком лимит умножается на число инстансов; нужен общий счётчик.
  • Fail-open на логине. Падение Redis снимает защиту от перебора ровно тогда, когда она нужна.
  • Ввод в SQL-строке. Конкатенация значений открывает инъекцию; $1 — нет.
  • req.body целиком в findOne или update. $ne и role: 'admin' приходят от клиента.
  • exec со склейкой строки. Shell разбирает ввод как команду; нужен execFile с массивом аргументов.
  • path.join вместо проверки resolve + realpath. Выход из каталога и символическая ссылка наружу.
  • res.redirect(req.query.next). Open redirect на своём домене — удобная ступень для фишинга.
  • Object.assign или deep merge тела запроса. Prototype pollution, после которой проверка прав проходит у всех.
  • res.json(user) из строки базы. passwordHash и внутренние поля уходят клиенту.
  • eval, vm и node-serialize на недоверенных данных. Песочницы там нет, есть исполнение кода.
  • Секрет в .env в git или в Dockerfile. Утечка переживает удаление файла; секрет нужно ротировать.
  • npm install в CI и lockfile в .gitignore. Сборки перестают быть воспроизводимыми, версии дрейфуют.
  • npm audit fix --force без разбора. Мажорные обновления ломают приложение, а вывод аудита не читается.

Ключевые тезисы для интервью

  • Граница доверия проходит по данным: тело, query, cookie и ответы чужих API недоверенные, а «внутренняя сеть» — не признак легитимности, поэтому SSRF обходит периметр.
  • helmet и CORS закрывают разные вещи: заголовки — гигиену браузерных сценариев, CORS — только чтение ответа скриптом с чужого origin; ни то, ни другое не защищает сам API.
  • Лимиты нужны двух видов — на ресурсы и на перебор; ключ выбирают по смыслу (IP + аккаунт, пользователь, действие), а режим отказа — по цене пропуска: логин fail-closed, чтения fail-open.
  • Инъекция — это превращение данных в код: параметры SQL, allowlist идентификаторов, типы против $ne, execFile/spawn без shell; валидация сужает вход, но не заменяет способ передачи.
  • SSRF закрывают allowlist и проверкой резолвнутого адреса, а не blocklist; path traversal — проверкой итогового resolve/realpath или отказом от пользовательских имён файлов в пользу серверных идентификаторов.
  • JSON.parse безопасен как парсер, но его результат — нет: strict-схемы против mass assignment, Map и Object.create(null) против prototype pollution, --disable-proto=throw как страховка.
  • Supply chain — это lockfile, npm ci, минимум зависимостей, контроль postinstall и понимание пределов npm audit; секреты живут в secret store, ротируются и вырезаются из логов.

Заключение

Безопасность Node API — это набор границ, а не список библиотек. Данные отделяются от кода параметризацией и allowlist’ами, браузерные сценарии — заголовками и точным CORS, ресурсы — лимитами с осознанным режимом отказа, а исходящие запросы — проверкой адреса и сетевыми правилами. OWASP API Top 10 полезен как карта: он напоминает, что самые частые инциденты — это BOLA, сломанная аутентификация и mass assignment, а не экзотические атаки. Дальше логично заняться производительностью и памятью: нестабильный сервис под нагрузкой — тоже способ отказать в обслуживании, только без злого умысла.

Полезные ссылки