К содержимому
Войти

Node.js Road Map

🔐 Аутентификация и авторизация

Аутентификация отвечает на вопрос «кто ты», авторизация — на вопрос «что тебе можно». Первую почти всегда собирают из готовых частей: сессия в cookie, JWT, вход через OAuth-провайдера, а вторую каждая команда пишет сама, и дыры чаще всего там. На собеседовании просят сравнить сессии и JWT, рассказать, как отозвать токен, где хранить его в браузере, как устроен OAuth 2.0 и как хранить пароли. В нашем срезе тему называют в 8–9% вакансий Go-мидлов и примерно в каждой пятой вакансии Node.js-мидла, но с ней сталкивается любой сервис, у которого есть пользователи

🧠 Как это устроено

Пароли

Сервер не хранит пароль, он хранит его хэш. И не любой: SHA-256 от короткой строки на M1 Pro считается за 54 наносекунды, это хорошо для проверки файлов и плохо для паролей. Чем быстрее считается хэш, тем быстрее его перебирают по словарю утёкших паролей, когда база уходит наружу. Поэтому для паролей берут функции, которые нарочно медленные и требуют много памяти, чтобы перебор на видеокартах стоил дорого

Минимальные параметры по рекомендациям OWASP:

АлгоритмПараметрыКогда брать
Argon2id19 МиБ памяти, 2 прохода, 1 потокпо умолчанию для нового кода
scryptN = 2^17, r = 8, p = 1если Argon2id нет под рукой
bcryptcost от 10, пароль не длиннее 72 байтв старых системах
PBKDF2-HMAC-SHA256600 000 итерацийкогда нужен сертифицированный FIPS-140 алгоритм

На M1 Pro Argon2id с минимальными параметрами считается за 25 мс, bcrypt с cost 10 за 65 мс, с cost 12 за 260 мс. Для входа это незаметно. А тому, кто перебирает украденную базу, одно ядро даёт около 40 попыток Argon2id в секунду против 18 миллионов попыток SHA-256

К каждому паролю добавляется своя случайная соль, она хранится рядом с хэшем. Два пользователя с паролем qwerty123 получают разные хэши, и заранее посчитанные таблицы хэшей становятся бесполезны. Параметры алгоритма тоже пишут в строку хэша: $argon2id$v=19$m=19456,t=2,p=1$<соль>$<хэш>. Тогда параметры можно поднять для новых паролей, а старые продолжат проверяться

У bcrypt есть ловушка: он смотрит только на первые 72 байта. 37 русских букв в UTF-8 уже 74 байта. Пакет golang.org/x/crypto/bcrypt с версии v0.5.0 в таком случае возвращает ErrPasswordTooLong, а классическая реализация bcrypt молча обрезает хвост, и пароли, которые отличаются после 72-го байта, совпадают. Поэтому длину проверяют до хэширования

Сессии

После входа сервер генерирует случайный идентификатор сессии и кладёт запись в Redis или в базу: user_id, когда создана, когда истекает. Браузеру уходит только идентификатор в cookie:

Set-Cookie: __Host-sid=k3Jx9...; Path=/; Secure; HttpOnly; SameSite=Lax; Max-Age=86400

На каждый запрос сервер достаёт запись по идентификатору. Выход — удаление записи, и с этой секунды cookie ничего не стоит. Отзыв мгновенный, в этом главное достоинство сессий. Платишь за это походом в хранилище на каждый запрос, а при недоступном Redis не работает вход

Что значат атрибуты cookie:

  • HttpOnly — JavaScript не видит cookie через document.cookie, значит XSS не украдёт её. Браузер при этом продолжает отправлять cookie с каждым запросом
  • Secure — только по HTTPS
  • SameSite=Lax — браузер не отправит cookie с POST-запросом, который пришёл с чужого сайта. Strict не отправит её и при переходе по ссылке с другого сайта
  • префикс __Host- — браузер примет такую cookie только с Secure, Path=/ и без Domain, поэтому поддомен не сможет её подменить

Идентификатор должен быть непредсказуемым: OWASP требует минимум 64 бита энтропии, на практике берут 128 бит из crypto/rand. И его меняют после входа. Иначе работает фиксация сессии: злоумышленник подсовывает жертве свой идентификатор, жертва логинится, и сессия с этим идентификатором становится авторизованной у обоих

JWT

JWT — три части через точку: заголовок, полезная нагрузка и подпись, каждая в base64url. Нагрузка — JSON с полями (claims): sub (кто это), exp (когда истекает), iss (кто выдал), aud (для какого сервиса), iat (когда выдан), jti (идентификатор токена). Подпись считается от первых двух частей ключом сервера

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

Сервер проверяет подпись и exp без похода в базу. Отсюда главный плюс: токен проверяет любой сервис, которому доступен ключ. С асимметричной подписью (RS256, ES256) сервис авторизации держит закрытый ключ, а остальные сервисы проверяют токены открытым ключом и даже не знают секрета

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

  1. Access token живёт минуты, например 15
  2. Вместе с ним выдают refresh token. Он длинный, хранится в базе и умеет только одно: получить новую пару токенов
  3. При каждом обмене refresh token меняется на новый, а старый становится недействительным. Если старый refresh приходит повторно, значит его украли: сервер отзывает всю цепочку, и войти заново придётся и вору, и владельцу

Если отозвать надо немедленно, jti отозванного токена кладут в Redis до его exp и проверяют на каждом запросе. Это работает, но тогда у тебя снова поход в хранилище на каждый запрос, как у сессий

СессияJWT
Где состояниев Redis или базев самом токене
Проверка запросапоход в хранилищепроверка подписи
Отзывудалить записьждать exp или вести список отозванных
Размер20–40 байтсотни байт в каждом запросе
Хорошо подходитвеб-приложение с одним бэкендомдоступ между сервисами, мобильные клиенты, внешний провайдер входа

Для обычного веб-приложения с одним бэкендом сессия в HttpOnly-cookie проще и безопаснее. JWT оправдан, когда токен проверяют несколько независимых сервисов или его выдаёт внешний провайдер

OAuth 2.0 и OpenID Connect

OAuth 2.0 — протокол делегирования доступа, а не входа. Он отвечает на вопрос, как приложению получить ограниченный доступ к твоим данным в другом сервисе, не узнав твоего пароля. Результат — access token для API провайдера. OpenID Connect надстраивается над OAuth 2.0 и добавляет вход: кроме access token клиент получает ID token. Это JWT про пользователя, и в его aud обязан стоять client_id приложения, которое запросило вход

Основной сценарий — Authorization Code с PKCE:

  1. Приложение генерирует случайную строку code_verifier и считает code_challenge = BASE64URL(SHA256(code_verifier))
  2. Отправляет браузер на страницу провайдера с client_id, redirect_uri, scope, state и code_challenge
  3. Пользователь входит у провайдера и соглашается дать доступ. Провайдер возвращает браузер на redirect_uri с одноразовым code
  4. Бэкенд приложения меняет code и code_verifier на токены у провайдера. Провайдер считает хэш от code_verifier и сверяет с code_challenge из шага 2

Перехваченный code без code_verifier бесполезен. Ради этого и придуман PKCE

Актуальные правила собраны в RFC 9700, который вышел в январе 2025. Implicit flow, где токен приходит прямо в URL, не использовать. Password grant, где приложение само принимает логин и пароль пользователя, запрещён. PKCE обязателен для публичных клиентов вроде SPA и мобильных приложений и рекомендован для всех остальных. redirect_uri сверяется с зарегистрированным посимвольно. Access token ограничивают одним сервисом через aud, а refresh token публичного клиента либо привязывают к клиенту, либо ротируют

Авторизация

Middleware аутентификации кладёт пользователя в context, а обработчик решает, можно ли ему это действие. Самая простая модель — роли (RBAC): admin может всё, support читает заказы, user работает со своими. Когда правила зависят от свойств объекта и пользователя, например «менеджер видит заказы своего региона», это уже проверка атрибутов (ABAC)

Самая частая дыра — проверить, что пользователь вошёл, и не проверить, что объект его. GET /orders/123 отдаёт чужой заказ, если перебрать id. В OWASP API Security Top 10 это первое место: Broken Object Level Authorization, BOLA. Лечится тем, что владелец входит в сам запрос к базе, а не проверяется где-то рядом

Чем 401 отличается от 403, разобрано на странице про HTTP. На чужой объект часто отвечают 404, а не 403, чтобы не подтверждать, что заказ 123 существует. RFC 9110 это разрешает

🛠️ На практике

Хэширование и проверка пароля через Argon2id из golang.org/x/crypto. Параметры кодируются в строку хэша, сравнение — за постоянное время:

Go · Argon2id: хэш и проверка пароля

package main

import (
	"crypto/rand"
	"crypto/subtle"
	"encoding/base64"
	"fmt"
	"strings"

	"golang.org/x/crypto/argon2"
	"golang.org/x/crypto/bcrypt"
)

// Минимум OWASP для argon2id: 19 МиБ памяти, 2 прохода, 1 поток
const (
	memKiB  = 19 * 1024
	passes  = 2
	threads = 1
)

func hash(password string) string {
	salt := make([]byte, 16)
	rand.Read(salt) // своя соль у каждого пароля
	key := argon2.IDKey([]byte(password), salt, passes, memKiB, threads, 32)
	b64 := base64.RawStdEncoding.EncodeToString
	// Параметры хранятся рядом с хэшем: их можно поднять, не ломая старые записи
	return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%s$%s",
		memKiB, passes, threads, b64(salt), b64(key))
}

func verify(password, encoded string) bool {
	var m, t uint32
	var p uint8
	parts := strings.Split(encoded, "$")
	fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &m, &t, &p)
	salt, _ := base64.RawStdEncoding.DecodeString(parts[4])
	want, _ := base64.RawStdEncoding.DecodeString(parts[5])
	got := argon2.IDKey([]byte(password), salt, t, m, p, uint32(len(want)))
	// == на срезах сравнивал бы до первого отличия, и по времени ответа можно подбирать хэш
	return subtle.ConstantTimeCompare(got, want) == 1
}

func main() {
	h := hash("correct horse")
	fmt.Println(h[:31] + "...")
	fmt.Println("верный пароль:", verify("correct horse", h))
	fmt.Println("неверный:", verify("correct horse!", h))
	fmt.Println("тот же пароль, другой хэш:", hash("correct horse") != h)

	_, err := bcrypt.GenerateFromPassword([]byte(strings.Repeat("я", 37)), bcrypt.DefaultCost)
	fmt.Println("bcrypt, 37 русских букв:", err)
}
$argon2id$v=19$m=19456,t=2,p=1$...
верный пароль: true
неверный: false
тот же пароль, другой хэш: true
bcrypt, 37 русских букв: bcrypt: password length exceeds 72 bytes

Как устроена подпись JWT, без библиотек. Пример показывает две вещи: содержимое токена читается без ключа, а подмена роли ломает подпись:

Go · Подпись JWT HS256 вручную

package main

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
	"strings"
)

var b64 = base64.RawURLEncoding

func sign(data string, key []byte) string {
	m := hmac.New(sha256.New, key)
	m.Write([]byte(data))
	return b64.EncodeToString(m.Sum(nil))
}

func main() {
	key := []byte("секрет-из-хранилища-не-короче-32-байт")
	header := b64.EncodeToString([]byte(`{"alg":"HS256","typ":"JWT"}`))
	payload := b64.EncodeToString([]byte(`{"sub":"42","role":"user","exp":1767225600}`))
	token := header + "." + payload + "." + sign(header+"."+payload, key)

	// Payload не зашифрован: прочитать его может любой, у кого есть токен
	p, _ := b64.DecodeString(strings.Split(token, ".")[1])
	fmt.Println(string(p))

	// Подменили роль, подпись оставили старую
	forged := b64.EncodeToString([]byte(`{"sub":"42","role":"admin","exp":1767225600}`))
	parts := strings.Split(token, ".")
	for _, body := range []string{parts[1], forged} {
		ok := hmac.Equal([]byte(sign(parts[0]+"."+body, key)), []byte(parts[2]))
		fmt.Println("подпись верна:", ok)
	}
}
{"sub":"42","role":"user","exp":1767225600}
подпись верна: true
подпись верна: false

В рабочем коде подпись проверяет библиотека, чаще всего github.com/golang-jwt/jwt/v5. Главное в ней — опции парсера. Без WithExpirationRequired токен без поля exp пройдёт проверку и будет действовать вечно: в v5 срок проверяется, только если он есть в токене

claims := &jwt.RegisteredClaims{}
_, err := jwt.ParseWithClaims(raw, claims,
	func(t *jwt.Token) (any, error) { return key, nil },
	jwt.WithValidMethods([]string{"HS256"}), // alg из заголовка не решает, чем проверять
	jwt.WithIssuer("https://auth.example.com"),
	jwt.WithAudience("orders-api"),
	jwt.WithExpirationRequired(),
	jwt.WithLeeway(30*time.Second), // запас на расхождение часов
)

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

err := db.QueryRowContext(ctx,
	`SELECT id, total FROM orders WHERE id = $1 AND user_id = $2`,
	orderID, userID, // userID берётся из сессии или токена, а не из запроса
).Scan(&o.ID, &o.Total)
if errors.Is(err, sql.ErrNoRows) {
	http.NotFound(w, r)
	return
}

⚠️ Где ошибаются

  • JWT в localStorage. Любой скрипт на странице читает localStorage, и одна XSS-уязвимость, например в сторонней библиотеке аналитики, уносит токены всех, кто открыл страницу. OWASP советует не хранить там ни токены, ни идентификаторы сессий. Надёжнее HttpOnly-cookie или схема, где токены держит свой бэкенд для фронтенда, а браузер получает только cookie. С cookie появляется CSRF: SameSite закрывает его основную часть, для изменяющих запросов добавляют CSRF-токен
  • Долгоживущие токены без ротации. Access token на 30 дней, украденный из логов или с устройства, даёт 30 дней доступа, и отозвать его нечем. Короткий access token плюс ротация refresh token ограничивают ущерб минутами
  • Доверяют заголовку alg. Если библиотека проверяет подпись тем алгоритмом, который пришёл в токене, можно прислать "alg": "none" или подписать токен HMAC-ом с открытым RSA-ключом сервера в роли секрета. RFC 8725 требует задавать список допустимых алгоритмов на стороне сервера и использовать каждый ключ ровно с одним алгоритмом. Туда же отсутствие проверки aud: токен, который выпустили для одного сервиса, принимает другой
  • Проверяют вход, но не владельца. Обработчик видит, что токен валиден, и отдаёт /orders/123 по id из URL. Это BOLA. Чтобы её найти, хватает поменять цифру в адресе
  • Быстрый хэш для паролей. sha256(password) или MD5 с одной солью на всю базу. После утечки такая база вскрывается перебором по словарю, а одинаковые пароли видны сразу по одинаковым хэшам

🎯 Вопросы с собеседований

Чем аутентификация отличается от авторизации?

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

Сессия или JWT: что выбрать?

Сессия хранит состояние на сервере, в cookie только случайный идентификатор. Её легко отозвать, но каждый запрос идёт в хранилище. JWT несёт данные в себе и проверяется подписью без базы, зато его нельзя отозвать до истечения. Для веб-приложения с одним бэкендом я бы взял сессию в HttpOnly-cookie. JWT беру, когда токен проверяют несколько сервисов или его выдаёт внешний провайдер

Как отозвать JWT до истечения срока?

Напрямую никак: токен валиден, пока сходится подпись и не прошёл exp. Поэтому access token делают коротким, а отзыв переносят на refresh token в базе. Мгновенный отзыв — список отозванных jti в Redis или версия токенов у пользователя, которая растёт при смене пароля. Оба способа возвращают поход в хранилище на каждый запрос

Где хранить токен в браузере?

В cookie с HttpOnly, Secure и SameSite: скрипт на странице её не прочитает, а localStorage доступен любому JavaScript, и одна XSS уносит токен. За cookie платишь защитой от CSRF: SameSite=Lax или Strict и CSRF-токен на изменяющие запросы. Ещё надёжнее, когда токены держит свой бэкенд, а браузер получает только сессионную cookie

Как правильно хранить пароли и почему не SHA-256?

Хранить хэш медленной функции с солью: Argon2id, bcrypt или scrypt. SHA-256 считается за десятки наносекунд, и утёкшую базу перебирают со скоростью миллионов паролей в секунду на ядро. Argon2id берёт 19 МиБ памяти и десятки миллисекунд на хэш, перебор становится дорогим. Соль у каждого пароля своя, поэтому одинаковые пароли дают разные хэши. У bcrypt есть лимит в 72 байта, его надо проверять

Как работает OAuth 2.0 Authorization Code с PKCE?

Клиент генерирует случайный code_verifier и отправляет пользователя к провайдеру с его хэшем, code_challenge. Пользователь входит у провайдера, тот возвращает браузер на redirect_uri с одноразовым кодом. Бэкенд клиента меняет код и исходный code_verifier на токены, провайдер сверяет хэш. Перехваченный код без code_verifier бесполезен. По RFC 9700 PKCE обязателен для SPA и мобильных приложений и рекомендован для всех

Чем OAuth 2.0 отличается от OpenID Connect?

OAuth 2.0 про доступ: приложение получает access token, чтобы ходить в API от имени пользователя. Кто этот пользователь, протокол не говорит. OpenID Connect добавляет вход: ID token, это JWT с данными пользователя, и в его aud стоит client_id приложения. Кнопка «Войти через Google» работает на OpenID Connect. Доступ стороннего приложения к твоему календарю — это OAuth 2.0

Что такое ротация refresh token и как она ловит кражу?

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

📚 Что почитать