VK Cloud

OAuth 2.0 простым языком: токены, flows и безопасная авторизация

15 ноября 2026 г.
Александр Иванов
Автор статьи
_blog_head_1.png

Кнопка «Войти через Google» — это OAuth 2.0 в действии. Протокол решает одну задачу: дать стороннему приложению ограниченный доступ к данным пользователя, не передавая ему пароль. Фреймворк описан в RFC 6749, опубликованном IETF в октябре 2012 года, и остаётся базой авторизации для веб-приложений, мобильных клиентов и API. Ниже разберём, как устроен протокол, какие сценарии (flows) существуют и где чаще всего ошибаются при реализации.

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

OAuth 2.0 строит такую же схему для данных:

  • пароль пользователя — основная связка ключей, стороннему приложению она не передаётся никогда;
  • access token — парковочный ключ: ограниченный доступ к конкретным ресурсам и на ограниченное время;
  • scope — границы этого ключа: только чтение почты, только список контактов;
  • resource server — отель, который хранит машину и проверяет ключ на входе.

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

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

[Resource Owner] → [Client App] → [Authorization Server] → [Resource Server] (пользователь) (ваше приложение) (Google/GitHub/VK) (API с данными)

Resource Owner — пользователь, которому принадлежат данные. Он проходит аутентификацию на стороне Authorization Server и даёт явное согласие (consent) на запрошенный объём прав. Учётные данные пользователя приложение не видит.

Client — приложение, которое запрашивает доступ. Спецификация делит клиентов на confidential (серверная часть, способная хранить секрет) и public (SPA, то есть одностраничное приложение, мобильный или десктопный клиент). От типа клиента зависит выбор сценария.

Authorization Server — сервер, который аутентифицирует пользователя, собирает его согласие и выпускает токены. В этой роли выступают публичные провайдеры вроде Google и GitHub или собственный Identity Provider внутри периметра компании.

Resource Server — API, которое хранит защищённые ресурсы и принимает access token как основание для выполнения запроса. Пароля пользователя он не знает и работает только с токеном и его правами.

Протокол разводит два токена по назначению: одним ходят в API, вторым продлевают доступ. Третий сюжет здесь — формат, в котором токен выпускается.

Access token

Access token — короткоживущий токен доступа. Разумный TTL (время жизни токена) для большинства сценариев находится в диапазоне от 15 минут до часа. Токен передаётся в каждом запросе к Resource Server в HTTP-заголовке:

GET /api/user/profile HTTP/1.1 Host: api.example.com Authorization: Bearer ya29.A0ARrdaM...

Схема Bearer описана в RFC 6750 и означает буквально «предъявитель»: доступ получает любая сторона, которая показала токен, без дополнительных доказательств владения. Отсюда требование защищённого транспорта: все запросы с токеном идут по TLS. Перехваченный в открытом канале Bearer-токен равен выданному доступу.

Refresh token

Refresh token живёт долго (дни, недели, месяцы) и имеет ровно одно назначение: получить новый access token, когда прежний истёк. В запросы к API он не передаётся никогда.

Client → Authorization Server: grant_type=refresh_token, refresh_token=... Authorization Server → Client: новый access_token (+ при ротации новый refresh_token)

Хранится refresh token в месте, недоступном коду страницы: httpOnly-cookie для веба, защищённое хранилище операционной системы для мобильных приложений. Его компрометация опаснее утечки access token, потому что продлевает доступ сама по себе.

JWT как формат токена

Access token часто реализуют как JWT. Формат определён в RFC 7519: три части, закодированные Base64URL и разделённые точками, то есть header с алгоритмом подписи, payload с набором claims и signature.

eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9 ← header .eyJzdWIiOiIxMjM0NTYiLCJzY29wZSI6InJlYWQ6ZW1haWwiLCJleHAiOjE3MDAwMDAwMDB9 ← payload (sub, scope, exp) .SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c ← signature

Практический смысл формата в том, что Resource Server проверяет подпись локально по публичному ключу и читает claims прямо из токена, не обращаясь к Authorization Server на каждый запрос. Непрозрачный (opaque) токен такой возможности не даёт: его приходится валидировать запросом к серверу авторизации. Обратная сторона JWT: токен действителен до exp даже после логаута, если не выстроен отдельный механизм отзыва.

Authorization Code Grant описан в разделе 4.1 RFC 6749 и остаётся основным сценарием для приложений с серверной частью. Ключевая идея: через браузер пользователя проходит не токен, а одноразовый код, который бесполезен без серверного секрета.

Шаг 1. Редирект на Authorization Server.

https://accounts.google.com/o/oauth2/auth? response_type=code &client_id=YOUR_CLIENT_ID &redirect_uri=https://myapp.com/callback &scope=read:email+read:profile &state=random_csrf_token_abc123

Что означают параметры:

  • response_type=code — запрашивается код, а не токен напрямую;
  • scope — объём прав, который приложение просит у пользователя;
  • state — случайная строка, которую клиент сохраняет в сессии и сверяет при возврате. RFC 6749 вводит этот параметр как защиту от межсайтовой подделки запроса (CSRF).

Шаг 2. Аутентификация и согласие. Пользователь входит в свой аккаунт на стороне провайдера и видит экран согласия: «Приложение X запрашивает доступ к вашей почте и профилю». Приложение в этот момент не участвует и пароля не видит.

Шаг 3. Редирект обратно с кодом.

https://myapp.com/callback? code=4/P7q7W91azfyFcGaoszup9q... &state=random_csrf_token_abc123

Первое, что делает обработчик callback, — сверяет state с сохранённым значением. Не совпало, значит запрос отклоняется без дальнейшей обработки.

Шаг 4. Обмен кода на токены на серверной стороне.

POST https://oauth2.googleapis.com/token Content-Type: application/x-www-form-urlencoded grant_type=authorization_code &code=4/P7q7W91... &redirect_uri=https://myapp.com/callback &client_id=YOUR_CLIENT_ID &client_secret=YOUR_CLIENT_SECRET

Ответ:

{ "access_token": "ya29.A0ARrdaM...", "expires_in": 3599, "refresh_token": "1//0gLd...", "scope": "read:email read:profile", "token_type": "Bearer" }

Код одноразовый и живёт секунды. Обмен выполняет бэкенд приложения, поэтому client_secret ходит только между сервером клиента и Authorization Server и в браузер не попадает. Этим сценарий и отличается от устаревшего Implicit Grant (раздел 4.2 RFC 6749), где access token возвращался сразу во фрагменте URL редиректа.

У публичного клиента нет безопасного места для client_secret: код SPA читается в браузере, мобильное приложение распаковывается и анализируется. Ответ на эту проблему — PKCE (Proof Key for Code Exchange), описанный в RFC 7636 и опубликованный IETF в сентябре 2015 года.

Механизм заменяет статический секрет на одноразовый, сгенерированный под конкретный запрос:

  1. клиент генерирует случайный code_verifier;
  2. вычисляет code_challenge методом S256, то есть BASE64URL-кодирование SHA-256 от verifier;
  3. передаёт code_challenge и code_challenge_method=S256 в запросе авторизации;
  4. при обмене кода на токен отправляет исходный code_verifier;
  5. Authorization Server сверяет хеш присланного verifier с сохранённым challenge и только при совпадении выдаёт токен.

Перехваченный authorization code без verifier бесполезен: атакующий видел лишь хеш. В январе 2025 года IETF опубликовал RFC 9700 «OAuth 2.0 Security Best Current Practice», где PKCE рекомендован для всех типов клиентов, включая confidential, а не только для публичных. То есть PKCE сейчас базовая настройка, а не опция для мобильной разработки.

RFC 6749 определяет четыре базовых способа получения токена: Authorization Code, Implicit, Resource Owner Password Credentials и Client Credentials. Позже к ним добавился Device Authorization Grant из RFC 8628. Выбор сводится к двум вопросам: какой у вас тип клиента и есть ли в сценарии живой пользователь.

Grant typeКогда использоватьСтатус
Authorization Code + PKCEВеб-приложения, SPA, мобильные клиентыРекомендуется (RFC 9700)
Client CredentialsСервис-к-сервису (M2M), пользователя нетШтатный вариант для API-интеграций
Device AuthorizationSmart TV, CLI, устройства с ограниченным вводомНишевый, по RFC 8628
ImplicitSPA по старым руководствамОтказаться (RFC 9700)
Resource Owner PasswordLegacy-интеграцииОтказаться (RFC 9700)

RFC 9700 прямо рекомендует отказаться и от Implicit Grant, и от Resource Owner Password Credentials Grant в пользу Authorization Code с PKCE. Логика понятна: первый отдаёт токен через URL, второй требует передать клиентскому приложению логин и пароль пользователя напрямую, что противоречит исходной цели протокола.

Client Credentials на практике. Микросервис A запрашивает данные у микросервиса B: пользователя в этом сценарии нет, экран согласия показывать некому. Клиент получает токен под собственной учётной записью:

POST /token Content-Type: application/x-www-form-urlencoded grant_type=client_credentials &client_id=service_a &client_secret=SERVICE_A_SECRET &scope=read:orders

Дальше токен используется так же, как пользовательский, но права в нём принадлежат сервису, а не человеку. Разные scope для разных вызывающих сервисов дают понятную модель: видно, кто и к каким методам API ходит.


Два протокола путают постоянно, хотя они отвечают на разные вопросы.

OAuth 2.0 — протокол авторизации. Он описывает, какой доступ есть у предъявленного токена.

OpenID Connect (OIDC) — слой аутентификации поверх OAuth 2.0, описанный спецификацией OpenID Connect Core 1.0 от OpenID Foundation. Он отвечает на вопрос, кто именно этот пользователь.

Что OIDC добавляет к OAuth 2.0:

  • ID Token — JWT с набором claims о пользователе: sub, email, name;
  • эндпоинт UserInfo — получение данных профиля по access token;
  • стандартные scope openid, profile, email для запроса этих данных.
«Может ли этот токен читать почту?» → OAuth 2.0 «Кто владелец этого токена?» → OpenID Connect

Реальный сценарий «войти через Google» обычно использует оба протокола одновременно: OAuth 2.0 выдаёт доступ к API, OIDC поверх него отдаёт профиль пользователя и факт состоявшейся аутентификации. Если вы строите единый вход, вам нужен именно OIDC: один OAuth 2.0 не определяет формат ответа о личности пользователя.

Не проверять state

Параметр введён как защита от CSRF, но работает только при сверке. Значение из callback не совпало с сохранённым в сессии, запрос отклоняется.

Хранить токены в localStorage

Любой скрипт на странице читает это хранилище, поэтому XSS (межсайтовый скриптинг) превращается в кражу доступа. Access token для SPA держат в памяти приложения, refresh token — в httpOnly-cookie.

Не валидировать redirect_uri

В Authorization Server регистрируется точный адрес обратного редиректа. Шаблоны с wildcard расширяют поверхность атаки: код уходит на подконтрольный злоумышленнику адрес.

Использовать Implicit Flow

Токен приезжает во фрагменте URL и оседает в истории браузера, в заголовках Referer и в логах промежуточных узлов. Замена — Authorization Code с PKCE.

Выдавать долгоживущие access token

Утёкший Bearer-токен действует до истечения срока. TTL в 15–60 минут с обновлением через refresh token сужает окно компрометации.

Не реализовать отзыв токенов

RFC 7009 описывает эндпоинт revocation, через который клиент сообщает серверу, что ранее выданный токен больше не нужен и должен быть аннулирован. Без него логаут остаётся косметическим: токен продолжает работать.

Частые вопросы про OAuth 2.0

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

OAuth 1.0 (RFC 5849) требовал криптографически подписывать каждый запрос на стороне клиента, что усложняло реализацию и отладку. OAuth 2.0 передал задачу защиты транспортному уровню, то есть TLS, и упростил сам протокол. В новых системах OAuth 1.0 практически не встречается.

Реализовывать Authorization Server самостоятельно или брать готовый?

Для продакшна разумнее готовое решение: self-hosted Identity Provider с открытым кодом (например, Keycloak под лицензией Apache 2.0) или управляемый облачный Identity Provider. Самостоятельная реализация сервера авторизации требует корректной работы с криптографией, хранением и отзывом токенов, валидацией редиректов, и ошибка здесь стоит дорого. Писать своими руками стоит клиентскую часть: получение, хранение и использование токенов.

Как работает SSO на базе OAuth и OIDC?

SSO (единый вход) строится на одном Authorization Server для нескольких приложений. Пользователь входит один раз, сервер заводит сессию и выдаёт токены, включая ID Token с данными о пользователе. При переходе во второе приложение оно редиректит пользователя на тот же сервер, тот видит активную сессию и выдаёт токен без повторного ввода пароля.

Нужен ли OAuth для внутреннего API без внешних пользователей?

Для сценария сервис-к-сервису подходит Client Credentials Grant: клиент получает токен под собственной учётной записью, согласие пользователя не требуется. Альтернатива в виде статических API-ключей проще на старте, но хуже масштабируется: ключи сложно отзывать и разграничивать. При четырёх и более взаимодействующих сервисах централизованная выдача токенов, аудит и разные scope обычно окупаются.

Сложность OAuth 2.0 кажущаяся: она рассыпается, как только разведены четыре роли и выбран правильный flow. Если у вас пользовательское приложение любого типа, берите Authorization Code с PKCE; если межсервисное взаимодействие, берите Client Credentials. Остальные сценарии либо нишевые (Device Authorization для устройств без браузера), либо прямо не рекомендованы в RFC 9700. Проверьте в своей реализации три вещи: сверку state, точную регистрацию redirect_uri и наличие отзыва токенов.

Identity Provider и защищённые им API удобно держать в собственном периметре. Развернуть Keycloak и бэкенд за ним можно на Cloud Servers VK Cloud: гибкие конфигурации виртуальных машин, загрузка собственных образов, управление через Terraform, CLI и API, SLA 99,95% с финансовыми гарантиями.

Оставьте заявку, чтобы получить консультацию

Наши специалисты свяжутся с вами в ближайшее время и ответят на все вопросы.

            Узнавайте о выходе новых статей в блоге первыми!

            Будем держать в курсе новостей и облачных трендов

            section-subscribe_2x.png
              section-subscribe_2x.png
              Теги: OAuth 2.0, авторизация, OpenID Connect, PKCE, VK Cloud
              Ссылка скопирована
              Поделиться

              Почитать по теме

              _blog_head_7.png
              24 сентября

              Критическая информационная инфраструктура простыми словами

              40+ готовых сервисов