🔐 Аутентификация и авторизация
Аутентификация отвечает на вопрос «кто ты», авторизация — на вопрос «что тебе можно». Первую почти всегда собирают из готовых частей: сессия в cookie, JWT, вход через OAuth-провайдера, а вторую каждая команда пишет сама, и дыры чаще всего там. На собеседовании просят сравнить сессии и JWT, рассказать, как отозвать токен, где хранить его в браузере, как устроен OAuth 2.0 и как хранить пароли. В нашем срезе тему называют в 8–9% вакансий Go-мидлов и примерно в каждой пятой вакансии Node.js-мидла, но с ней сталкивается любой сервис, у которого есть пользователи
🧠 Как это устроено
Пароли
Сервер не хранит пароль, он хранит его хэш. И не любой: SHA-256 от короткой строки на M1 Pro считается за 54 наносекунды, это хорошо для проверки файлов и плохо для паролей. Чем быстрее считается хэш, тем быстрее его перебирают по словарю утёкших паролей, когда база уходит наружу. Поэтому для паролей берут функции, которые нарочно медленные и требуют много памяти, чтобы перебор на видеокартах стоил дорого
Минимальные параметры по рекомендациям OWASP:
| Алгоритм | Параметры | Когда брать |
|---|---|---|
| Argon2id | 19 МиБ памяти, 2 прохода, 1 поток | по умолчанию для нового кода |
| scrypt | N = 2^17, r = 8, p = 1 | если Argon2id нет под рукой |
| bcrypt | cost от 10, пароль не длиннее 72 байт | в старых системах |
| PBKDF2-HMAC-SHA256 | 600 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— только по HTTPSSameSite=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, даже если пользователь сменил пароль или его заблокировали. Обычно делают так:
- Access token живёт минуты, например 15
- Вместе с ним выдают refresh token. Он длинный, хранится в базе и умеет только одно: получить новую пару токенов
- При каждом обмене 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:
- Приложение генерирует случайную строку
code_verifierи считаетcode_challenge = BASE64URL(SHA256(code_verifier)) - Отправляет браузер на страницу провайдера с
client_id,redirect_uri,scope,stateиcode_challenge - Пользователь входит у провайдера и соглашается дать доступ. Провайдер возвращает браузер на
redirect_uriс одноразовымcode - Бэкенд приложения меняет
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 живёт до первого обмена у настоящего владельца
📚 Что почитать
- OWASP Password Storage Cheat Sheet — параметры Argon2id, scrypt, bcrypt и PBKDF2 и зачем нужен pepper
- OWASP Session Management Cheat Sheet — идентификаторы сессий, таймауты, атрибуты cookie и почему не
localStorage - RFC 9700, OAuth 2.0 Security Best Current Practice — что сейчас обязательно в OAuth: PKCE, запрет implicit и password grant, ротация refresh token
- OWASP API1:2023, Broken Object Level Authorization — примеры BOLA и как её не допустить