Безопасность Node API
Безопасность бэкенда начинается не с библиотеки, а с ответа на вопрос: что сервис считает доверенным. Почти все дыры в Node API — это либо недоверенные данные, попавшие в код или в запрос, либо конфигурация, открытая шире, чем нужно по умолчанию. Разберём обвязку Express-приложения от заголовков и CORS до SSRF и supply chain, а OWASP API Top 10 используем как чеклист, а не как список страшилок.
Содержание
- Модель угроз и OWASP API Top 10
- Security-заголовки и helmet
- CORS: точечная настройка
- Rate limiting и брутфорс
- Инъекции: SQL, NoSQL и команды
- SSRF: сервер ходит по чужим адресам
- Path traversal и файлы
- Небезопасная десериализация
- Секреты, зависимости и supply chain
- Практика: TaskFlow
- Частые ошибки
- Ключевые тезисы для интервью
- Заключение
- Полезные ссылки
Модель угроз и OWASP API Top 10
Доверенного в HTTP-запросе мало: метод, путь и, с оговорками, заголовки, которые ставит инфраструктура. Всё остальное — тело, query, cookie, x-forwarded-*, имена файлов, ответы внешних API — приходит от клиента или из сети и доверия не заслуживает. Отдельно стоит запомнить: «внутренняя сеть» — не признак доверия. Запрос с вашего сервера к соседнему сервису выглядит легитимным именно потому, что его отправили вы.
Отсюда три принципа, на которых держится всё остальное:
- Данные остаются данными. Значение из запроса не должно становиться частью SQL, shell-команды или имени файла без явного преобразования.
- Отказ по умолчанию. Неизвестный origin, неизвестный адрес исходящего запроса, неизвестное поле в теле — это отказ, а не «пропустим и посмотрим».
- Наружу — минимум. Клиенту не нужны стек, текст ошибки драйвера и
passwordHash; атакующему они нужны.
OWASP API Security Top 10 — удобная карта, чтобы не изобретать таксономию заново. Пункты стоит примерить к своему сервису и вычеркнуть те, которых нет; слепое копирование чеклиста даёт ложное чувство закрытости.
| Пункт | Суть | Где смотреть в Node |
|---|---|---|
| API1: BOLA | доступ к чужому объекту по подобранному id | ownerId в where, а не проверка после выборки — «Аутентификация в API» |
| API2: Broken Authentication | слабые токены, отсутствие отзыва, перебор | «Аутентификация в API», раздел про rate limit ниже |
| API3: BOPLA | mass assignment и лишние поля в ответе | strict-схемы и DTO — «Конфигурация и валидация» |
| API4: Unrestricted Resource Consumption | неограниченное тело, пагинация и загрузки | лимиты тела и запросов, таймауты |
| API5: BFLA | вызов админской функции обычным пользователем | requirePermission на каждом маршруте |
| API6: Sensitive Business Flows | автомат на сценарии вроде заказа или регистрации | лимиты по бизнес-действию, а не по URL |
| API7: SSRF | сервер ходит по адресу, который дал клиент | раздел про SSRF |
| API8: Misconfiguration | CORS, заголовки, дефолтные учётки, стек в ответе | разделы про 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: nosniff | MIME-sniffing при отдаче файлов | загрузкам, статике, JSON |
X-Frame-Options / frame-ancestors | встраивание ответа в iframe | HTML-страницам, 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/login | IP + email | 5 за 15 минут, с задержкой | fail-closed |
POST /api/auth/register | IP | 3 в час | fail-closed |
POST /api/auth/password-reset | email + IP | 3 в час | fail-closed |
GET /api/* | userId или IP | 300 в минуту | fail-open |
POST /api/uploads | userId | 10 в час | 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, а не экзотические атаки. Дальше логично заняться производительностью и памятью: нестабильный сервис под нагрузкой — тоже способ отказать в обслуживании, только без злого умысла.
Полезные ссылки
- OWASP API Security Top 10 — актуальный список рисков API с примерами
- OWASP: SSRF Prevention Cheat Sheet — allowlist, резолв адресов, редиректы
- OWASP: Input Validation Cheat Sheet — валидация на границе и allowlist
- helmet — набор security-заголовков и их настройка
- express-rate-limit — лимиты и внешние store для Express
- Node.js: Security Best Practices — официальный чеклист по коду и конфигурации
- npm audit — что именно проверяет аудит
- HTTP-заголовки безопасности — HSTS, COOP, COEP, CORP и остальные
- Безопасность зависимостей и supply chain — lockfile, provenance, SBOM
- Управление секретами — хранение, ротация, утечки в git