refactor: убрать вход через внешние провайдеры (OAuth) полностью
Решение владельца 27.09.2026 (D-084): сервис ставится на сервер конкретного человека, и ему всё равно нужен свой OAuth у провайдера — поддержка общего входа только создаёт трение (регистрация приложений, redirect URI, модерация, чужие ключи в конфиге). Способы входа остаются: пароль + 2FA и ключи доступа (WebAuthn). Удалено: - сервер: internal/auth/oauth.go, internal/server/oauth.go, internal/store/oauth.go и их тесты; поля и методы конфига OAuth*; oauthLimiter и регистрация ручек; отображение ошибок oauth.*; features.oauth_enabled/oauth_providers в /meta; - клиент: web/src/api/oauth.ts, раздел «Вход через внешние сервисы», кнопки провайдеров на странице входа, ключи i18n (ru/en), тесты и фикстуры; - установщик: переменные OAUTH_* из .env, .env.example и шаблона (хелпер чтения существующих значений переименован в existing_value — он остался нужен для VAPID_SUBJECT); - зависимость golang.org/x/oauth2 (go mod tidy). Схема: миграция 00027 удаляет таблицу oauth_accounts (00019 не переписываем — она применена на стендах). Откат миграции возвращает структуру; тест TestOAuthRemovalMigration проверяет накат, откат и повторный накат. AGENT.md (локальный) помечает пункты про OAuth как отменённые.
This commit is contained in:
@@ -1,877 +0,0 @@
|
||||
package auth
|
||||
|
||||
import (
|
||||
"context"
|
||||
"crypto/hmac"
|
||||
"crypto/sha256"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"fmt"
|
||||
"io"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/url"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"golang.org/x/oauth2"
|
||||
|
||||
"glchat/internal/config"
|
||||
"glchat/internal/crypto"
|
||||
"glchat/internal/store"
|
||||
)
|
||||
|
||||
// OAuth-вход (AGENT.md 7.1): провайдеры включаются переменными окружения,
|
||||
// привязка внешнего аккаунта идёт по подтверждённому email через blind index.
|
||||
// Токены провайдера не сохраняются: они нужны только на время обмена кода.
|
||||
const (
|
||||
// oauthStateTTL — срок жизни подписанного state (защита от CSRF).
|
||||
oauthStateTTL = 10 * time.Minute
|
||||
// oauthHTTPTimeout ограничивает запросы к провайдеру.
|
||||
oauthHTTPTimeout = 10 * time.Second
|
||||
)
|
||||
|
||||
var (
|
||||
// ErrOAuthNotConfigured — провайдер выключен (нет client id/secret).
|
||||
ErrOAuthNotConfigured = errors.New("oauth.provider_not_configured")
|
||||
// ErrOAuthUnknownProvider — неизвестное имя провайдера.
|
||||
ErrOAuthUnknownProvider = errors.New("oauth.provider_unknown")
|
||||
// ErrOAuthState — state не прошёл проверку подписи или истёк.
|
||||
ErrOAuthState = errors.New("oauth.state_invalid")
|
||||
// ErrOAuthExchange — обмен кода или запрос профиля не удался.
|
||||
ErrOAuthExchange = errors.New("oauth.exchange_failed")
|
||||
// ErrOAuthEmailUnverified — провайдер не подтвердил email.
|
||||
ErrOAuthEmailUnverified = errors.New("oauth.email_unverified")
|
||||
// ErrOAuthEmailMissing — провайдер не отдал email.
|
||||
ErrOAuthEmailMissing = errors.New("oauth.email_missing")
|
||||
)
|
||||
|
||||
// oauthProvider — описание провайдера: всё, что нужно для входа.
|
||||
type oauthProvider struct {
|
||||
ID string
|
||||
Name string
|
||||
Endpoint oauth2.Endpoint
|
||||
Scopes []string
|
||||
// PKCE включает code_challenge/code_verifier (RFC 7636). Требуется VK ID:
|
||||
// верификатор выводится из подписанного state, хранить его не нужно.
|
||||
PKCE bool
|
||||
// DeviceIDParam — имя query-параметра, который провайдер возвращает вместе с
|
||||
// кодом и требует при обмене кода на токен (у VK ID это device_id).
|
||||
DeviceIDParam string
|
||||
// SecretOptional — провайдер работает и без секрета (публичное приложение
|
||||
// VK ID: обмен защищён PKCE, сервисный ключ нужен только конфиденциальным).
|
||||
SecretOptional bool
|
||||
// TokenSecretParam — имя POST-параметра для секрета при обмене кода.
|
||||
// Пусто — секрет уходит обычной Basic-авторизацией (как у GitHub/Google).
|
||||
// У VK ID это service_token: он нужен конфиденциальным приложениям, а
|
||||
// client_secret в запросе не передаётся вовсе.
|
||||
TokenSecretParam string
|
||||
// FetchProfile получает профиль по токену: email, признак подтверждения,
|
||||
// внешний идентификатор и логин. clientID нужен провайдерам, которые
|
||||
// запрашивают данные пользователя вместе с идентификатором приложения (VK ID).
|
||||
FetchProfile func(ctx context.Context, client *http.Client, token *oauth2.Token, clientID string) (oauthProfile, error)
|
||||
}
|
||||
|
||||
// oauthProfile — нормализованный профиль внешнего аккаунта.
|
||||
type oauthProfile struct {
|
||||
Subject string
|
||||
Email string
|
||||
EmailVerified bool
|
||||
Login string
|
||||
// DisplayName — имя из профиля провайдера (VK ID и Яндекс отдают его
|
||||
// отдельно от логина). Пусто — берётся Login.
|
||||
DisplayName string
|
||||
}
|
||||
|
||||
// OAuthProviderInfo — описание включённого провайдера для клиента.
|
||||
type OAuthProviderInfo struct {
|
||||
ID string `json:"id"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
|
||||
// oauthProviderSet — каталог провайдеров. Переменная, а не функция, чтобы
|
||||
// тесты подменяли адреса провайдеров на httptest-сервер (в бою — значения по
|
||||
// умолчанию, см. defaultOAuthProviders).
|
||||
var oauthProviderSet = defaultOAuthProviders()
|
||||
|
||||
// oauthProviders возвращает каталог поддерживаемых провайдеров (AGENT.md 7.1:
|
||||
// Google, GitHub, Discord). Новый провайдер добавляется одной записью.
|
||||
func oauthProviders() map[string]oauthProvider { return oauthProviderSet }
|
||||
|
||||
//nolint:gosec // G101: здесь публичные адреса провайдеров, а не учётные данные
|
||||
func defaultOAuthProviders() map[string]oauthProvider {
|
||||
return map[string]oauthProvider{
|
||||
"vk": {
|
||||
ID: "vk",
|
||||
Name: "VK ID",
|
||||
Endpoint: oauth2.Endpoint{
|
||||
AuthURL: "https://id.vk.ru/authorize",
|
||||
// Обмен кода: POST с параметрами в теле (client_id, code_verifier,
|
||||
// device_id, state, service_token) — Basic-авторизацию VK не ждёт.
|
||||
TokenURL: "https://id.vk.ru/oauth2/auth",
|
||||
AuthStyle: oauth2.AuthStyleInParams,
|
||||
},
|
||||
Scopes: []string{"email", "vkid.personal_info"},
|
||||
// VK ID без PKCE не работает: code_challenge обязателен в запросе
|
||||
// авторизации, device_id возвращается в callback и нужен при обмене.
|
||||
PKCE: true,
|
||||
SecretOptional: true,
|
||||
DeviceIDParam: "device_id",
|
||||
TokenSecretParam: "service_token",
|
||||
FetchProfile: fetchVKProfile,
|
||||
},
|
||||
"yandex": {
|
||||
ID: "yandex",
|
||||
Name: "Яндекс",
|
||||
Endpoint: oauth2.Endpoint{
|
||||
AuthURL: "https://oauth.yandex.ru/authorize",
|
||||
TokenURL: "https://oauth.yandex.ru/token",
|
||||
// Яндекс принимает и Basic, и параметры в теле; выбираем тело —
|
||||
// так поведение не зависит от того, как прокси переписывает
|
||||
// заголовок Authorization.
|
||||
AuthStyle: oauth2.AuthStyleInParams,
|
||||
},
|
||||
Scopes: []string{"login:email", "login:info"},
|
||||
FetchProfile: fetchYandexProfile,
|
||||
},
|
||||
"github": {
|
||||
ID: "github",
|
||||
Name: "GitHub",
|
||||
Endpoint: oauth2.Endpoint{
|
||||
AuthURL: "https://github.com/login/oauth/authorize",
|
||||
TokenURL: "https://github.com/login/oauth/access_token",
|
||||
},
|
||||
Scopes: []string{"read:user", "user:email"},
|
||||
FetchProfile: fetchGitHubProfile,
|
||||
},
|
||||
"google": {
|
||||
ID: "google",
|
||||
Name: "Google",
|
||||
Endpoint: oauth2.Endpoint{
|
||||
AuthURL: "https://accounts.google.com/o/oauth2/v2/auth",
|
||||
TokenURL: "https://oauth2.googleapis.com/token",
|
||||
},
|
||||
Scopes: []string{"openid", "email", "profile"},
|
||||
FetchProfile: fetchGoogleProfile,
|
||||
},
|
||||
"discord": {
|
||||
ID: "discord",
|
||||
Name: "Discord",
|
||||
Endpoint: oauth2.Endpoint{
|
||||
AuthURL: "https://discord.com/oauth2/authorize",
|
||||
TokenURL: "https://discord.com/api/oauth2/token",
|
||||
},
|
||||
Scopes: []string{"identify", "email"},
|
||||
FetchProfile: fetchDiscordProfile,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
// oauthConfigs — включённые провайдеры: id → параметры клиента.
|
||||
func (s *Service) oauthConfigs() map[string]oauthProvider {
|
||||
providers := oauthProviders()
|
||||
enabled := make(map[string]oauthProvider, len(providers))
|
||||
for id, provider := range providers {
|
||||
credentials, ok := s.oauth[id]
|
||||
if !ok || credentials.clientID == "" {
|
||||
continue
|
||||
}
|
||||
if credentials.clientSecret == "" && !provider.SecretOptional {
|
||||
continue
|
||||
}
|
||||
provider.Scopes = append([]string{}, provider.Scopes...)
|
||||
enabled[id] = provider
|
||||
if id == "google" {
|
||||
// Google требует offline-доступ только при необходимости refresh;
|
||||
// нам достаточно одноразового обмена кода.
|
||||
enabled[id] = provider
|
||||
}
|
||||
}
|
||||
return enabled
|
||||
}
|
||||
|
||||
// OAuthProviders перечисляет включённые провайдеры для клиента.
|
||||
func (s *Service) OAuthProviders() []OAuthProviderInfo {
|
||||
configs := s.oauthConfigs()
|
||||
// Порядок стабилен, чтобы клиент не переставлял кнопки между запросами.
|
||||
// VK ID и Яндекс — первыми: инстанс рассчитан на русскоязычных пользователей.
|
||||
order := []string{"vk", "yandex", "github", "google", "discord"}
|
||||
infos := make([]OAuthProviderInfo, 0, len(configs))
|
||||
for _, id := range order {
|
||||
if provider, ok := configs[id]; ok {
|
||||
infos = append(infos, OAuthProviderInfo{ID: provider.ID, Name: provider.Name})
|
||||
}
|
||||
}
|
||||
return infos
|
||||
}
|
||||
|
||||
// OAuthEnabled сообщает, настроен ли хотя бы один провайдер.
|
||||
func (s *Service) OAuthEnabled() bool { return len(s.oauthConfigs()) > 0 }
|
||||
|
||||
// oauthClientCredentials — client id/secret конкретного провайдера.
|
||||
type oauthClientCredentials struct {
|
||||
clientID string
|
||||
clientSecret string
|
||||
}
|
||||
|
||||
// OAuthAuthorizeURL строит ссылку на провайдера с подписанным state.
|
||||
// redirect — куда вернуть пользователя внутри клиента после входа.
|
||||
func (s *Service) OAuthAuthorizeURL(providerID, redirect string) (string, error) {
|
||||
configs := s.oauthConfigs()
|
||||
provider, ok := configs[strings.ToLower(strings.TrimSpace(providerID))]
|
||||
if !ok {
|
||||
if _, known := oauthProviders()[strings.ToLower(strings.TrimSpace(providerID))]; known {
|
||||
return "", ErrOAuthNotConfigured
|
||||
}
|
||||
return "", ErrOAuthUnknownProvider
|
||||
}
|
||||
state, err := s.signOAuthState(provider.ID, redirect)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
oauthConfig := s.oauthConfig(provider)
|
||||
options := make([]oauth2.AuthCodeOption, 0, 2)
|
||||
options = append(options, oauth2.AccessTypeOnline)
|
||||
options = append(options, s.oauthAuthOptions(provider, state)...)
|
||||
return oauthConfig.AuthCodeURL(state, options...), nil
|
||||
}
|
||||
|
||||
// oauthPKCEVerifier выводит code_verifier из подписанного state: хранить его
|
||||
// отдельно не нужно, а подпись гарантирует, что верификатор не подменит
|
||||
// посторонний (RFC 7636 требует 43–128 символов из a-z, A-Z, 0-9, «_», «-» —
|
||||
// base64url без padding даёт ровно это).
|
||||
func (s *Service) oauthPKCEVerifier(state string) string {
|
||||
mac := hmac.New(sha256.New, []byte(s.stateKey))
|
||||
mac.Write([]byte("oauth-pkce:" + state))
|
||||
return base64.RawURLEncoding.EncodeToString(mac.Sum(nil))[:43]
|
||||
}
|
||||
|
||||
// oauthAuthOptions — дополнительные параметры запроса авторизации.
|
||||
func (s *Service) oauthAuthOptions(provider oauthProvider, state string) []oauth2.AuthCodeOption {
|
||||
if !provider.PKCE {
|
||||
return nil
|
||||
}
|
||||
return []oauth2.AuthCodeOption{oauth2.S256ChallengeOption(s.oauthPKCEVerifier(state))}
|
||||
}
|
||||
|
||||
// oauthExchangeOptions — дополнительные параметры обмена кода на токен:
|
||||
// PKCE-верификатор, идентификатор устройства из callback (VK ID) и секрет под
|
||||
// именем, которое ждёт провайдер (у VK ID — service_token вместо client_secret).
|
||||
func (s *Service) oauthExchangeOptions(provider oauthProvider, state string, callback url.Values, credentials oauthClientCredentials) []oauth2.AuthCodeOption {
|
||||
var options []oauth2.AuthCodeOption
|
||||
if provider.PKCE {
|
||||
options = append(options,
|
||||
oauth2.VerifierOption(s.oauthPKCEVerifier(state)),
|
||||
// VK ID сверяет state и при обмене кода тоже.
|
||||
oauth2.SetAuthURLParam("state", state),
|
||||
)
|
||||
}
|
||||
if provider.DeviceIDParam != "" {
|
||||
if device := strings.TrimSpace(callback.Get(provider.DeviceIDParam)); device != "" {
|
||||
options = append(options, oauth2.SetAuthURLParam(provider.DeviceIDParam, device))
|
||||
}
|
||||
}
|
||||
if provider.TokenSecretParam != "" && credentials.clientSecret != "" {
|
||||
options = append(options, oauth2.SetAuthURLParam(provider.TokenSecretParam, credentials.clientSecret))
|
||||
}
|
||||
return options
|
||||
}
|
||||
|
||||
// OAuthCallback обменивает код на профиль, находит или создаёт аккаунт и
|
||||
// выдаёт сессию. Возвращает также признак «аккаунт создан впервые».
|
||||
// callback — query-параметры, которые провайдер вернул вместе с кодом: VK ID
|
||||
// кладёт туда device_id, без которого обмен не пройдёт.
|
||||
func (s *Service) OAuthCallback(ctx context.Context, providerID, code, state string, callback url.Values, ip, userAgent string) (*store.User, string, *store.Session, string, error) {
|
||||
if strings.TrimSpace(code) == "" {
|
||||
return nil, "", nil, "", fmt.Errorf("%w: empty code", ErrOAuthExchange)
|
||||
}
|
||||
redirect, err := s.verifyOAuthState(providerID, state)
|
||||
if err != nil {
|
||||
return nil, "", nil, "", err
|
||||
}
|
||||
configs := s.oauthConfigs()
|
||||
provider, ok := configs[strings.ToLower(strings.TrimSpace(providerID))]
|
||||
if !ok {
|
||||
if _, known := oauthProviders()[strings.ToLower(strings.TrimSpace(providerID))]; known {
|
||||
return nil, "", nil, "", ErrOAuthNotConfigured
|
||||
}
|
||||
return nil, "", nil, "", ErrOAuthUnknownProvider
|
||||
}
|
||||
oauthConfig := s.oauthConfig(provider)
|
||||
client := &http.Client{Timeout: oauthHTTPTimeout}
|
||||
credentials := s.oauth[provider.ID]
|
||||
token, err := oauthConfig.Exchange(ctx, code,
|
||||
s.oauthExchangeOptions(provider, state, callback, credentials)...)
|
||||
if err != nil {
|
||||
return nil, "", nil, "", fmt.Errorf("%w: exchange: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
profile, err := provider.FetchProfile(ctx, client, token, credentials.clientID)
|
||||
if err != nil {
|
||||
return nil, "", nil, "", err
|
||||
}
|
||||
if profile.Email == "" {
|
||||
return nil, "", nil, "", ErrOAuthEmailMissing
|
||||
}
|
||||
if !profile.EmailVerified {
|
||||
return nil, "", nil, "", ErrOAuthEmailUnverified
|
||||
}
|
||||
email := crypto.NormalizeEmail(profile.Email)
|
||||
emailIndex := s.masterKey.BlindIndex(email)
|
||||
subjectIndex := s.masterKey.BlindIndex(provider.ID + ":" + profile.Subject)
|
||||
|
||||
// 1. Уже привязанный внешний аккаунт — вход без создания новых записей.
|
||||
if account, lookupErr := s.store.OAuthAccountBySubject(ctx, provider.ID, subjectIndex); lookupErr == nil {
|
||||
user, userErr := s.store.GetUser(ctx, account.UserID)
|
||||
if userErr != nil {
|
||||
return nil, "", nil, "", userErr
|
||||
}
|
||||
if err := s.oauthBanCheck(ctx, user, ip, userAgent); err != nil {
|
||||
return nil, "", nil, "", err
|
||||
}
|
||||
if err := s.store.TouchOAuthAccount(ctx, account.ID); err != nil {
|
||||
s.logger.WarnContext(ctx, "не удалось обновить время входа OAuth-аккаунта", slog.Any("error", err))
|
||||
}
|
||||
sessionToken, session, loginErr := s.finishOAuthLogin(ctx, user, ip, userAgent, "oauth_login")
|
||||
return user, sessionToken, session, redirect, loginErr
|
||||
} else if !errors.Is(lookupErr, store.ErrNotFound) {
|
||||
return nil, "", nil, "", lookupErr
|
||||
}
|
||||
|
||||
// 2. Аккаунт с таким email — привязываем провайдера к нему.
|
||||
if user, lookupErr := s.store.GetUserByEmailIndex(ctx, emailIndex); lookupErr == nil {
|
||||
if err := s.oauthBanCheck(ctx, user, ip, userAgent); err != nil {
|
||||
return nil, "", nil, "", err
|
||||
}
|
||||
account, linkErr := s.store.LinkOAuthAccount(ctx, user.ID, provider.ID, subjectIndex, emailIndex)
|
||||
if linkErr != nil {
|
||||
return nil, "", nil, "", linkErr
|
||||
}
|
||||
if err := s.store.TouchOAuthAccount(ctx, account.ID); err != nil {
|
||||
s.logger.WarnContext(ctx, "не удалось обновить время входа OAuth-аккаунта", slog.Any("error", err))
|
||||
}
|
||||
_ = s.store.RecordSecurityEvent(ctx, &user.ID, "oauth_linked", ip, userAgent,
|
||||
`{"provider":`+quoteJSON(provider.ID)+`}`)
|
||||
if err := s.store.RecordAudit(ctx, store.AuditParams{
|
||||
ActorID: &user.ID,
|
||||
Action: "user.oauth_link",
|
||||
TargetType: "user",
|
||||
TargetID: &user.ID,
|
||||
Changes: map[string]any{"provider": provider.ID},
|
||||
}); err != nil {
|
||||
s.logger.WarnContext(ctx, "не удалось записать привязку OAuth в аудит", slog.Any("error", err))
|
||||
}
|
||||
sessionToken, session, loginErr := s.finishOAuthLogin(ctx, user, ip, userAgent, "oauth_linked")
|
||||
return user, sessionToken, session, redirect, loginErr
|
||||
} else if !errors.Is(lookupErr, store.ErrNotFound) {
|
||||
return nil, "", nil, "", lookupErr
|
||||
}
|
||||
|
||||
// 3. Новый аккаунт: регистрация должна быть разрешена (флаг инстанса).
|
||||
settings, err := s.settings.InstanceSettings(ctx)
|
||||
if err != nil {
|
||||
return nil, "", nil, "", fmt.Errorf("load instance settings: %w", err)
|
||||
}
|
||||
if !settings.RegistrationEnabled {
|
||||
return nil, "", nil, "", ErrRegistrationOff
|
||||
}
|
||||
user, err := s.createOAuthUser(ctx, email, emailIndex, profile, ip, userAgent)
|
||||
if err != nil {
|
||||
return nil, "", nil, "", err
|
||||
}
|
||||
if _, err := s.store.LinkOAuthAccount(ctx, user.ID, provider.ID, subjectIndex, emailIndex); err != nil {
|
||||
return nil, "", nil, "", err
|
||||
}
|
||||
sessionToken, session, err := s.finishOAuthLogin(ctx, user, ip, userAgent, "oauth_register")
|
||||
return user, sessionToken, session, redirect, err
|
||||
}
|
||||
|
||||
// finishOAuthLogin создаёт сессию и пишет событие безопасности.
|
||||
func (s *Service) finishOAuthLogin(ctx context.Context, user *store.User, ip, userAgent, event string) (string, *store.Session, error) {
|
||||
token, session, err := s.createSession(ctx, user.ID, userAgent, ip)
|
||||
if err != nil {
|
||||
return "", nil, err
|
||||
}
|
||||
_ = s.store.RecordSecurityEvent(ctx, &user.ID, event, ip, userAgent, "")
|
||||
return token, session, nil
|
||||
}
|
||||
|
||||
// oauthBanCheck проверяет глобальный бан инстанса до выдачи сессии (7.18).
|
||||
func (s *Service) oauthBanCheck(ctx context.Context, user *store.User, ip, userAgent string) error {
|
||||
banned, err := s.store.IsInstanceBanned(ctx, user.ID)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if banned {
|
||||
_ = s.store.RecordSecurityEvent(ctx, &user.ID, "login_banned", ip, userAgent, `{"method":"oauth"}`)
|
||||
return ErrUserBanned
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// createOAuthUser заводит аккаунт по данным провайдера: логин из профиля,
|
||||
// пароль — случайный (вход только через провайдера), email шифруется.
|
||||
func (s *Service) createOAuthUser(ctx context.Context, email, emailIndex string, profile oauthProfile, ip, userAgent string) (*store.User, error) {
|
||||
username, err := s.uniqueUsername(ctx, profile.Login, email)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
randomPassword, _, err := crypto.NewSessionToken()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
passwordHash, err := s.hasher.Hash(randomPassword)
|
||||
if err != nil {
|
||||
return nil, fmt.Errorf("hash password: %w", err)
|
||||
}
|
||||
userID := s.store.NextID()
|
||||
encrypted, err := s.encryptEmail(userID, email)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
displayName := strings.TrimSpace(profile.DisplayName)
|
||||
if displayName == "" {
|
||||
displayName = strings.TrimSpace(profile.Login)
|
||||
}
|
||||
if displayName == "" {
|
||||
displayName = username
|
||||
}
|
||||
user, err := s.store.CreateUser(ctx, store.CreateUserParams{
|
||||
ID: userID,
|
||||
Username: username,
|
||||
DisplayName: defaultDisplayName(displayName, username),
|
||||
EmailEnc: encrypted,
|
||||
EmailIndex: emailIndex,
|
||||
PasswordHash: passwordHash,
|
||||
Locale: "ru",
|
||||
})
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
_ = s.store.RecordSecurityEvent(ctx, &user.ID, "oauth_register", ip, userAgent, "")
|
||||
return user, nil
|
||||
}
|
||||
|
||||
// uniqueUsername подбирает свободный username: из логина провайдера, иначе из
|
||||
// локальной части email; суффикс добавляется только при конфликте.
|
||||
func (s *Service) uniqueUsername(ctx context.Context, login, email string) (string, error) {
|
||||
candidate := sanitizeUsername(login)
|
||||
if candidate == "" {
|
||||
local := email
|
||||
if at := strings.Index(email, "@"); at > 0 {
|
||||
local = email[:at]
|
||||
}
|
||||
candidate = sanitizeUsername(local)
|
||||
}
|
||||
if candidate == "" {
|
||||
candidate = "user"
|
||||
}
|
||||
for attempt := 0; attempt < 20; attempt++ {
|
||||
value := candidate
|
||||
if attempt > 0 {
|
||||
suffix := strconv.Itoa(attempt + 1)
|
||||
limit := 32 - len(suffix)
|
||||
if len(value) > limit {
|
||||
value = value[:limit]
|
||||
}
|
||||
value += suffix
|
||||
}
|
||||
if _, err := s.store.GetUserByUsername(ctx, value); errors.Is(err, store.ErrNotFound) {
|
||||
return value, nil
|
||||
} else if err != nil {
|
||||
return "", err
|
||||
}
|
||||
}
|
||||
return "", fmt.Errorf("cannot pick a free username for oauth account")
|
||||
}
|
||||
|
||||
// signOAuthState подписывает state ключом сессий: хранить его в БД не нужно,
|
||||
// подпись защищает от подмены (AGENT.md 9.2).
|
||||
func (s *Service) signOAuthState(providerID, redirect string) (string, error) {
|
||||
payload, err := json.Marshal(map[string]string{
|
||||
"provider": providerID,
|
||||
"redirect": safeRedirect(redirect),
|
||||
"issued": strconv.FormatInt(time.Now().UTC().Unix(), 10),
|
||||
"nonce": crypto.HashToken(strconv.FormatInt(time.Now().UTC().UnixNano(), 10))[:16],
|
||||
})
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
encoded := base64.RawURLEncoding.EncodeToString(payload)
|
||||
return encoded + "." + s.signStatePayload(encoded), nil
|
||||
}
|
||||
|
||||
// verifyOAuthState проверяет подпись, срок и провайдера, возвращая redirect.
|
||||
func (s *Service) verifyOAuthState(providerID, state string) (string, error) {
|
||||
parts := strings.Split(state, ".")
|
||||
if len(parts) != 2 || parts[0] == "" || parts[1] == "" {
|
||||
return "", ErrOAuthState
|
||||
}
|
||||
expected := s.signStatePayload(parts[0])
|
||||
if !hmac.Equal([]byte(expected), []byte(parts[1])) {
|
||||
return "", ErrOAuthState
|
||||
}
|
||||
payload, err := base64.RawURLEncoding.DecodeString(parts[0])
|
||||
if err != nil {
|
||||
return "", ErrOAuthState
|
||||
}
|
||||
var values map[string]string
|
||||
if err := json.Unmarshal(payload, &values); err != nil {
|
||||
return "", ErrOAuthState
|
||||
}
|
||||
if !strings.EqualFold(values["provider"], providerID) {
|
||||
return "", ErrOAuthState
|
||||
}
|
||||
issued, err := strconv.ParseInt(values["issued"], 10, 64)
|
||||
if err != nil || time.Since(time.Unix(issued, 0).UTC()) > oauthStateTTL {
|
||||
return "", ErrOAuthState
|
||||
}
|
||||
return safeRedirect(values["redirect"]), nil
|
||||
}
|
||||
|
||||
func (s *Service) signStatePayload(encoded string) string {
|
||||
mac := hmac.New(sha256.New, []byte(s.stateKey))
|
||||
mac.Write([]byte("oauth-state:" + encoded))
|
||||
return base64.RawURLEncoding.EncodeToString(mac.Sum(nil))
|
||||
}
|
||||
|
||||
// oauthConfig собирает oauth2.Config провайдера с адресом возврата.
|
||||
func (s *Service) oauthConfig(provider oauthProvider) *oauth2.Config {
|
||||
credentials := s.oauth[provider.ID]
|
||||
config := &oauth2.Config{
|
||||
ClientID: credentials.clientID,
|
||||
ClientSecret: credentials.clientSecret,
|
||||
Endpoint: provider.Endpoint,
|
||||
RedirectURL: strings.TrimRight(s.oauthRedirectBase, "/") + "/api/v1/auth/oauth/" + provider.ID + "/callback",
|
||||
Scopes: provider.Scopes,
|
||||
}
|
||||
if provider.TokenSecretParam != "" {
|
||||
// Секрет уходит отдельным параметром (у VK ID — service_token):
|
||||
// библиотека не должна добавлять его как client_secret.
|
||||
config.ClientSecret = ""
|
||||
}
|
||||
if provider.PKCE {
|
||||
// auth-код с PKCE: без code_verifier провайдер отклонит обмен.
|
||||
config.Endpoint.AuthStyle = oauth2.AuthStyleInParams
|
||||
}
|
||||
return config
|
||||
}
|
||||
|
||||
// OAuthRedirectURL возвращает адрес возврата: его оператор прописывает в
|
||||
// настройках приложения у провайдера.
|
||||
func (s *Service) OAuthRedirectURL() string {
|
||||
return s.oauthRedirectBase + "/api/v1/auth/oauth/{provider}/callback"
|
||||
}
|
||||
|
||||
// safeRedirect пропускает только внутренние пути клиента: открытый редирект
|
||||
// после входа недопустим (AGENT.md 9.7).
|
||||
func safeRedirect(value string) string {
|
||||
if value == "" || !strings.HasPrefix(value, "/") {
|
||||
return "/app"
|
||||
}
|
||||
// `//host` и `/\host` браузеры понимают как чужой хост: оставляем только
|
||||
// внутренние пути клиента (AGENT.md 9.7).
|
||||
if strings.HasPrefix(value, "//") || strings.ContainsAny(value, "\\") {
|
||||
return "/app"
|
||||
}
|
||||
return value
|
||||
}
|
||||
|
||||
// sanitizeUsername приводит логин провайдера к правилам glchat (7.1).
|
||||
func sanitizeUsername(value string) string {
|
||||
value = strings.ToLower(strings.TrimSpace(value))
|
||||
var builder strings.Builder
|
||||
for _, r := range value {
|
||||
switch {
|
||||
case r >= 'a' && r <= 'z', r >= '0' && r <= '9', r == '_', r == '.':
|
||||
builder.WriteRune(r)
|
||||
case r == '-' || r == ' ':
|
||||
builder.WriteByte('_')
|
||||
}
|
||||
if builder.Len() >= 32 {
|
||||
break
|
||||
}
|
||||
}
|
||||
result := strings.Trim(builder.String(), "._")
|
||||
if len(result) < 2 {
|
||||
return ""
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// --- провайдеры: получение нормализованного профиля ---
|
||||
|
||||
// Адреса методов «профиль пользователя» — переменные, чтобы тесты подменяли их
|
||||
// на httptest-сервер (в бою значения по умолчанию).
|
||||
var (
|
||||
vkUserInfoURL = "https://id.vk.ru/oauth2/user_info"
|
||||
yandexInfoURL = "https://login.yandex.ru/info?format=json"
|
||||
)
|
||||
|
||||
// fetchVKProfile получает данные пользователя VK ID: метод API ожидает POST с
|
||||
// client_id и access_token в теле (id.vk.ru/oauth2/user_info). Ответ приходит
|
||||
// как {"user": {...}}, но встречается и плоский вариант — разбираем оба.
|
||||
func fetchVKProfile(ctx context.Context, client *http.Client, token *oauth2.Token, clientID string) (oauthProfile, error) {
|
||||
form := url.Values{
|
||||
"client_id": {clientID},
|
||||
"access_token": {token.AccessToken},
|
||||
}
|
||||
request, err := http.NewRequestWithContext(ctx, http.MethodPost,
|
||||
vkUserInfoURL, strings.NewReader(form.Encode()))
|
||||
if err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: build request: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||||
request.Header.Set("Accept", "application/json")
|
||||
request.Header.Set("User-Agent", "glchat")
|
||||
response, err := client.Do(request)
|
||||
if err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: request: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
defer func() { _ = response.Body.Close() }()
|
||||
if response.StatusCode != http.StatusOK {
|
||||
return oauthProfile{}, fmt.Errorf("%w: provider returned %d", ErrOAuthExchange, response.StatusCode)
|
||||
}
|
||||
body, err := io.ReadAll(io.LimitReader(response.Body, 1<<20))
|
||||
if err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: read body: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
var payload struct {
|
||||
User *vkUser `json:"user"`
|
||||
vkUser
|
||||
}
|
||||
if err := json.Unmarshal(body, &payload); err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: decode profile: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
user := payload.vkUser
|
||||
if payload.User != nil {
|
||||
user = *payload.User
|
||||
}
|
||||
if user.UserID == 0 {
|
||||
return oauthProfile{}, fmt.Errorf("%w: пустой user_id в ответе VK ID", ErrOAuthExchange)
|
||||
}
|
||||
profile := oauthProfile{
|
||||
Subject: strconv.FormatInt(user.UserID, 10),
|
||||
Login: user.Login(),
|
||||
DisplayName: user.Login(),
|
||||
Email: strings.TrimSpace(user.Email),
|
||||
}
|
||||
// VK ID отдаёт почту только по праву `email` и только если адрес
|
||||
// подтверждён на стороне VK: отдельного флага в ответе нет, поэтому
|
||||
// наличие адреса считаем подтверждением (см. D-083).
|
||||
profile.EmailVerified = profile.Email != ""
|
||||
return profile, nil
|
||||
}
|
||||
|
||||
// vkUser — данные пользователя VK ID.
|
||||
type vkUser struct {
|
||||
UserID int64 `json:"user_id"`
|
||||
FirstName string `json:"first_name"`
|
||||
LastName string `json:"last_name"`
|
||||
Email string `json:"email"`
|
||||
Phone string `json:"phone"`
|
||||
}
|
||||
|
||||
// Login собирает логин из имени: VK ID не отдаёт публичный screen_name в
|
||||
// базовых правах.
|
||||
func (u vkUser) Login() string {
|
||||
return strings.TrimSpace(u.FirstName + " " + u.LastName)
|
||||
}
|
||||
|
||||
// fetchYandexProfile получает данные пользователя Яндекс ID. Особенность:
|
||||
// метод /info ждёт заголовок `Authorization: OAuth <токен>` (не Bearer),
|
||||
// поэтому запрос собирается вручную, а не через oauth2-клиент.
|
||||
func fetchYandexProfile(ctx context.Context, client *http.Client, token *oauth2.Token, _ string) (oauthProfile, error) {
|
||||
request, err := http.NewRequestWithContext(ctx, http.MethodGet, yandexInfoURL, nil)
|
||||
if err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: build request: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
request.Header.Set("Accept", "application/json")
|
||||
request.Header.Set("User-Agent", "glchat")
|
||||
request.Header.Set("Authorization", "OAuth "+token.AccessToken)
|
||||
response, err := client.Do(request)
|
||||
if err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: request: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
defer func() { _ = response.Body.Close() }()
|
||||
if response.StatusCode != http.StatusOK {
|
||||
return oauthProfile{}, fmt.Errorf("%w: provider returned %d", ErrOAuthExchange, response.StatusCode)
|
||||
}
|
||||
body, err := io.ReadAll(io.LimitReader(response.Body, 1<<20))
|
||||
if err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: read body: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
var user struct {
|
||||
ID string `json:"id"`
|
||||
Login string `json:"login"`
|
||||
DefaultEmail string `json:"default_email"`
|
||||
Emails []string `json:"emails"`
|
||||
RealName string `json:"real_name"`
|
||||
DisplayName string `json:"display_name"`
|
||||
}
|
||||
if err := json.Unmarshal(body, &user); err != nil {
|
||||
return oauthProfile{}, fmt.Errorf("%w: decode profile: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
if user.ID == "" {
|
||||
return oauthProfile{}, fmt.Errorf("%w: пустой id в ответе Яндекс ID", ErrOAuthExchange)
|
||||
}
|
||||
email := strings.TrimSpace(user.DefaultEmail)
|
||||
if email == "" && len(user.Emails) > 0 {
|
||||
email = strings.TrimSpace(user.Emails[0])
|
||||
}
|
||||
displayName := user.RealName
|
||||
if displayName == "" {
|
||||
displayName = user.DisplayName
|
||||
}
|
||||
return oauthProfile{
|
||||
Subject: user.ID,
|
||||
Login: user.Login,
|
||||
DisplayName: strings.TrimSpace(displayName),
|
||||
Email: email,
|
||||
// Почта приходит по праву `login:email` и принадлежит аккаунту
|
||||
// Яндекса, поэтому считаем её подтверждённой (см. D-083).
|
||||
EmailVerified: email != "",
|
||||
}, nil
|
||||
}
|
||||
|
||||
func fetchGitHubProfile(ctx context.Context, client *http.Client, token *oauth2.Token, _ string) (oauthProfile, error) {
|
||||
var user struct {
|
||||
ID int64 `json:"id"`
|
||||
Login string `json:"login"`
|
||||
Email string `json:"email"`
|
||||
}
|
||||
if err := oauthGetJSON(ctx, client, token, "https://api.github.com/user", &user); err != nil {
|
||||
return oauthProfile{}, err
|
||||
}
|
||||
var emails []struct {
|
||||
Email string `json:"email"`
|
||||
Primary bool `json:"primary"`
|
||||
Verified bool `json:"verified"`
|
||||
}
|
||||
if err := oauthGetJSON(ctx, client, token, "https://api.github.com/user/emails", &emails); err != nil {
|
||||
return oauthProfile{}, err
|
||||
}
|
||||
profile := oauthProfile{Subject: strconv.FormatInt(user.ID, 10), Login: user.Login}
|
||||
for _, candidate := range emails {
|
||||
// Берём только подтверждённый адрес: иначе чужой email в профиле GitHub
|
||||
// позволил бы войти в чужой аккаунт glchat.
|
||||
if candidate.Primary && candidate.Verified && candidate.Email != "" {
|
||||
profile.Email = candidate.Email
|
||||
profile.EmailVerified = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if profile.Email == "" {
|
||||
for _, candidate := range emails {
|
||||
if candidate.Verified && candidate.Email != "" {
|
||||
profile.Email = candidate.Email
|
||||
profile.EmailVerified = true
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if profile.Email == "" && user.Email != "" {
|
||||
// Публичный email из профиля GitHub подтверждённым не считаем.
|
||||
profile.Email = user.Email
|
||||
}
|
||||
return profile, nil
|
||||
}
|
||||
|
||||
func fetchGoogleProfile(ctx context.Context, client *http.Client, token *oauth2.Token, _ string) (oauthProfile, error) {
|
||||
var user struct {
|
||||
Sub string `json:"sub"`
|
||||
Email string `json:"email"`
|
||||
EmailVerified bool `json:"email_verified"`
|
||||
Name string `json:"name"`
|
||||
}
|
||||
if err := oauthGetJSON(ctx, client, token, "https://openidconnect.googleapis.com/v1/userinfo", &user); err != nil {
|
||||
return oauthProfile{}, err
|
||||
}
|
||||
return oauthProfile{
|
||||
Subject: user.Sub,
|
||||
Email: user.Email,
|
||||
EmailVerified: user.EmailVerified,
|
||||
Login: user.Name,
|
||||
}, nil
|
||||
}
|
||||
|
||||
func fetchDiscordProfile(ctx context.Context, client *http.Client, token *oauth2.Token, _ string) (oauthProfile, error) {
|
||||
var user struct {
|
||||
ID string `json:"id"`
|
||||
Username string `json:"username"`
|
||||
GlobalName string `json:"global_name"`
|
||||
Email string `json:"email"`
|
||||
Verified bool `json:"verified"`
|
||||
EmailVerified bool `json:"email_verified"`
|
||||
}
|
||||
if err := oauthGetJSON(ctx, client, token, "https://discord.com/api/users/@me", &user); err != nil {
|
||||
return oauthProfile{}, err
|
||||
}
|
||||
login := user.GlobalName
|
||||
if login == "" {
|
||||
login = user.Username
|
||||
}
|
||||
return oauthProfile{
|
||||
Subject: user.ID,
|
||||
Email: user.Email,
|
||||
EmailVerified: user.Verified || user.EmailVerified,
|
||||
Login: login,
|
||||
}, nil
|
||||
}
|
||||
|
||||
// oauthGetJSON выполняет GET к API провайдера с токеном доступа.
|
||||
func oauthGetJSON(ctx context.Context, client *http.Client, token *oauth2.Token, endpoint string, dst any) error {
|
||||
if _, err := url.Parse(endpoint); err != nil {
|
||||
return fmt.Errorf("%w: bad endpoint", ErrOAuthExchange)
|
||||
}
|
||||
request, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
|
||||
if err != nil {
|
||||
return fmt.Errorf("%w: build request: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
request.Header.Set("Accept", "application/json")
|
||||
request.Header.Set("User-Agent", "glchat")
|
||||
token.SetAuthHeader(request)
|
||||
response, err := client.Do(request)
|
||||
if err != nil {
|
||||
return fmt.Errorf("%w: request: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
defer func() { _ = response.Body.Close() }()
|
||||
if response.StatusCode != http.StatusOK {
|
||||
return fmt.Errorf("%w: provider returned %d", ErrOAuthExchange, response.StatusCode)
|
||||
}
|
||||
body, err := io.ReadAll(io.LimitReader(response.Body, 1<<20))
|
||||
if err != nil {
|
||||
return fmt.Errorf("%w: read body: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
if err := json.Unmarshal(body, dst); err != nil {
|
||||
return fmt.Errorf("%w: decode profile: %w", ErrOAuthExchange, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// oauthFromConfig собирает включённые провайдеры из конфигурации инстанса.
|
||||
func oauthFromConfig(cfg config.Config, baseURL string) (map[string]oauthClientCredentials, string) {
|
||||
credentials := map[string]oauthClientCredentials{}
|
||||
add := func(id, clientID, clientSecret string) {
|
||||
provider, known := oauthProviders()[id]
|
||||
if clientID == "" {
|
||||
return
|
||||
}
|
||||
// Публичному приложению VK ID секрет не нужен: обмен защищает PKCE.
|
||||
if clientSecret == "" && (!known || !provider.SecretOptional) {
|
||||
return
|
||||
}
|
||||
credentials[id] = oauthClientCredentials{clientID: clientID, clientSecret: clientSecret}
|
||||
}
|
||||
add("vk", cfg.OAuthVKClientID, cfg.OAuthVKClientSecret)
|
||||
add("yandex", cfg.OAuthYandexClientID, cfg.OAuthYandexClientSecret)
|
||||
add("github", cfg.OAuthGitHubClientID, cfg.OAuthGitHubClientSecret)
|
||||
add("google", cfg.OAuthGoogleClientID, cfg.OAuthGoogleClientSecret)
|
||||
add("discord", cfg.OAuthDiscordClientID, cfg.OAuthDiscordClientSecret)
|
||||
redirectBase := strings.TrimSpace(cfg.OAuthRedirectBase)
|
||||
if redirectBase == "" {
|
||||
redirectBase = baseURL
|
||||
}
|
||||
return credentials, redirectBase
|
||||
}
|
||||
@@ -1,725 +0,0 @@
|
||||
package auth
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"context"
|
||||
"encoding/base64"
|
||||
"encoding/json"
|
||||
"errors"
|
||||
"log/slog"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"net/url"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
"time"
|
||||
|
||||
"golang.org/x/oauth2"
|
||||
|
||||
"glchat/internal/config"
|
||||
"glchat/internal/crypto"
|
||||
"glchat/internal/database"
|
||||
"glchat/internal/store"
|
||||
)
|
||||
|
||||
// oauthTestConfig — конфиг тестового сервиса с включённым GitHub-провайдером.
|
||||
func oauthTestConfig() config.Config {
|
||||
return config.Config{
|
||||
Domain: "gl.mhspx.su",
|
||||
InstanceName: "glchat",
|
||||
SessionPepper: "unit-test-session-pepper",
|
||||
MasterKey: "00112233445566778899aabbccddeeff00112233445566778899aabbccddeeff",
|
||||
TOTPEncryptionKey: "unit-test-totp-key",
|
||||
SessionTTLHours: 24,
|
||||
// Низкие параметры Argon2id: тесты не должны работать секундами.
|
||||
Argon2MemoryKiB: 1024,
|
||||
Argon2Iterations: 1,
|
||||
Argon2Parallelism: 1,
|
||||
OAuthGitHubClientID: "client-id",
|
||||
OAuthGitHubClientSecret: "client-secret",
|
||||
}
|
||||
}
|
||||
|
||||
// oauthTestBaseConfig — конфиг без OAuth: проверяем выключенные провайдеры.
|
||||
func oauthTestBaseConfig() config.Config {
|
||||
cfg := oauthTestConfig()
|
||||
cfg.OAuthGitHubClientID = ""
|
||||
cfg.OAuthGitHubClientSecret = ""
|
||||
return cfg
|
||||
}
|
||||
|
||||
// oauthTestServer поднимает фальшивого провайдера: обмен кода на токен и
|
||||
// профиль. Адреса подставляются в каталог провайдеров на время теста.
|
||||
func oauthTestServer(t *testing.T, profile oauthProfile) *httptest.Server {
|
||||
t.Helper()
|
||||
mux := http.NewServeMux()
|
||||
mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
|
||||
if err := r.ParseForm(); err != nil {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if r.Form.Get("code") != "good-code" {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
_, _ = w.Write([]byte(`{"error":"invalid_grant"}`))
|
||||
return
|
||||
}
|
||||
// Провайдер отвечает JSON: так же ведёт себя GitHub при
|
||||
// `Accept: application/json`, который ставит golang.org/x/oauth2.
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"access_token": "test-access-token",
|
||||
"token_type": "bearer",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/profile", func(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Header.Get("Authorization") != "Bearer test-access-token" {
|
||||
w.WriteHeader(http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{"ok": true})
|
||||
})
|
||||
server := httptest.NewServer(mux)
|
||||
t.Cleanup(server.Close)
|
||||
|
||||
original := oauthProviderSet
|
||||
oauthProviderSet = map[string]oauthProvider{
|
||||
"github": {
|
||||
ID: "github",
|
||||
Name: "GitHub",
|
||||
Endpoint: oauth2.Endpoint{
|
||||
AuthURL: server.URL + "/authorize",
|
||||
TokenURL: server.URL + "/token",
|
||||
},
|
||||
Scopes: []string{"user:email"},
|
||||
FetchProfile: func(ctx context.Context, _ *http.Client, token *oauth2.Token, _ string) (oauthProfile, error) {
|
||||
// Провайдер получает токен так же, как в бою: через oauth2-клиент.
|
||||
authorized := oauth2.NewClient(ctx, oauth2.StaticTokenSource(token))
|
||||
request, err := http.NewRequestWithContext(ctx, http.MethodGet, server.URL+"/profile", nil)
|
||||
if err != nil {
|
||||
return oauthProfile{}, err
|
||||
}
|
||||
response, err := authorized.Do(request)
|
||||
if err != nil {
|
||||
return oauthProfile{}, err
|
||||
}
|
||||
defer func() { _ = response.Body.Close() }()
|
||||
if response.StatusCode != http.StatusOK {
|
||||
return oauthProfile{}, errors.New("profile request failed")
|
||||
}
|
||||
return profile, nil
|
||||
},
|
||||
},
|
||||
}
|
||||
t.Cleanup(func() { oauthProviderSet = original })
|
||||
return server
|
||||
}
|
||||
|
||||
func oauthTestService(t *testing.T, cfg config.Config) (*Service, *store.Store) {
|
||||
t.Helper()
|
||||
ctx := context.Background()
|
||||
db, err := database.Open(ctx, database.Options{
|
||||
Path: filepath.Join(t.TempDir(), "glchat.db"),
|
||||
ReadPool: 2,
|
||||
Migrate: true,
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("open database: %v", err)
|
||||
}
|
||||
t.Cleanup(func() { _ = db.Close() })
|
||||
st := store.New(db)
|
||||
service, err := New(ctx, cfg, st, slog.New(slog.DiscardHandler))
|
||||
if err != nil {
|
||||
t.Fatalf("auth.New: %v", err)
|
||||
}
|
||||
return service, st
|
||||
}
|
||||
|
||||
// TestOAuthNotConfigured — без клиентских id ручки отвечают понятной ошибкой,
|
||||
// а не пытаются увести пользователя к провайдеру (AGENT.md 7.1).
|
||||
func TestOAuthNotConfigured(t *testing.T) {
|
||||
service, _ := oauthTestService(t, oauthTestBaseConfig())
|
||||
if service.OAuthEnabled() {
|
||||
t.Fatal("oauth must be disabled without client credentials")
|
||||
}
|
||||
if _, err := service.OAuthAuthorizeURL("github", "/app"); !errors.Is(err, ErrOAuthNotConfigured) {
|
||||
t.Fatalf("authorize url without config: err = %v, want ErrOAuthNotConfigured", err)
|
||||
}
|
||||
if _, err := service.OAuthAuthorizeURL("ok", "/app"); !errors.Is(err, ErrOAuthUnknownProvider) {
|
||||
t.Fatalf("unknown provider: err = %v, want ErrOAuthUnknownProvider", err)
|
||||
}
|
||||
// VK и Яндекс в каталоге есть, но без ключей отвечают «не настроен».
|
||||
for _, provider := range []string{"vk", "yandex"} {
|
||||
if _, err := service.OAuthAuthorizeURL(provider, "/app"); !errors.Is(err, ErrOAuthNotConfigured) {
|
||||
t.Fatalf("%s without config: err = %v, want ErrOAuthNotConfigured", provider, err)
|
||||
}
|
||||
}
|
||||
if len(service.OAuthProviders()) != 0 {
|
||||
t.Fatalf("providers = %v, want empty", service.OAuthProviders())
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthAuthorizeURL — ссылка ведёт к провайдеру и несёт подписанный state.
|
||||
func TestOAuthAuthorizeURL(t *testing.T) {
|
||||
oauthTestServer(t, oauthProfile{Subject: "1", Email: "user@example.com", EmailVerified: true})
|
||||
service, _ := oauthTestService(t, oauthTestConfig())
|
||||
|
||||
providers := service.OAuthProviders()
|
||||
if len(providers) != 1 || providers[0].ID != "github" {
|
||||
t.Fatalf("providers = %v, want [github]", providers)
|
||||
}
|
||||
authorizeURL, err := service.OAuthAuthorizeURL("github", "/app/invite/abc")
|
||||
if err != nil {
|
||||
t.Fatalf("authorize url: %v", err)
|
||||
}
|
||||
if !strings.HasPrefix(authorizeURL, "http") || !strings.Contains(authorizeURL, "client_id=client-id") {
|
||||
t.Fatalf("unexpected authorize url: %s", authorizeURL)
|
||||
}
|
||||
parsed, err := url.Parse(authorizeURL)
|
||||
if err != nil {
|
||||
t.Fatalf("parse authorize url: %v", err)
|
||||
}
|
||||
state := parsed.Query().Get("state")
|
||||
if state == "" || !strings.Contains(state, ".") {
|
||||
t.Fatalf("state is not signed: %q", state)
|
||||
}
|
||||
redirect, err := service.verifyOAuthState("github", state)
|
||||
if err != nil {
|
||||
t.Fatalf("verify state: %v", err)
|
||||
}
|
||||
if redirect != "/app/invite/abc" {
|
||||
t.Fatalf("redirect = %q", redirect)
|
||||
}
|
||||
// Подмена state и чужой провайдер отклоняются.
|
||||
if _, err := service.verifyOAuthState("google", state); !errors.Is(err, ErrOAuthState) {
|
||||
t.Fatalf("state for another provider must fail, got %v", err)
|
||||
}
|
||||
if _, err := service.verifyOAuthState("github", state+"x"); !errors.Is(err, ErrOAuthState) {
|
||||
t.Fatalf("tampered state must fail, got %v", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthCallbackCreatesAndLinksAccounts — вход новым аккаунтом, привязка к
|
||||
// существующему по email, повторный вход и запрет для забаненного инстанса.
|
||||
func TestOAuthCallbackCreatesAndLinksAccounts(t *testing.T) {
|
||||
oauthTestServer(t, oauthProfile{Subject: "42", Email: "OAuth@Example.com", EmailVerified: true, Login: "Octo Cat"})
|
||||
service, st := oauthTestService(t, oauthTestConfig())
|
||||
ctx := context.Background()
|
||||
|
||||
state, err := service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
user, token, session, redirect, err := service.OAuthCallback(ctx, "github", "good-code", state, url.Values{}, "127.0.0.1", "test-agent")
|
||||
if err != nil {
|
||||
t.Fatalf("oauth callback: %v", err)
|
||||
}
|
||||
if redirect != "/app" || token == "" || session == nil {
|
||||
t.Fatalf("unexpected callback result: redirect=%q token=%q", redirect, token)
|
||||
}
|
||||
if user.Username != "octo_cat" {
|
||||
t.Fatalf("username = %q, want octo_cat", user.Username)
|
||||
}
|
||||
// Email зашифрован, наружу не отдаётся, но расшифровывается сервисом.
|
||||
email, err := service.Email(ctx, user.ID)
|
||||
if err != nil || email != "oauth@example.com" {
|
||||
t.Fatalf("email = %q, err = %v", email, err)
|
||||
}
|
||||
accounts, err := st.ListOAuthAccounts(ctx, user.ID)
|
||||
if err != nil || len(accounts) != 1 {
|
||||
t.Fatalf("oauth accounts = %v, err = %v", accounts, err)
|
||||
}
|
||||
if accounts[0].SubjectIndex == "" || strings.Contains(accounts[0].SubjectIndex, "42") {
|
||||
t.Fatalf("subject must be stored as blind index: %q", accounts[0].SubjectIndex)
|
||||
}
|
||||
|
||||
// Повторный вход тем же аккаунтом: новой записи не появляется.
|
||||
state, err = service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
again, _, _, _, err := service.OAuthCallback(ctx, "github", "good-code", state, url.Values{}, "127.0.0.1", "test-agent")
|
||||
if err != nil {
|
||||
t.Fatalf("second oauth callback: %v", err)
|
||||
}
|
||||
if again.ID != user.ID {
|
||||
t.Fatalf("second login created another account: %d != %d", again.ID, user.ID)
|
||||
}
|
||||
|
||||
// Бан инстанса запрещает вход через провайдера.
|
||||
if err := st.BanInstanceUser(ctx, user.ID, user.ID, "тест"); err != nil {
|
||||
t.Fatalf("ban user: %v", err)
|
||||
}
|
||||
state, err = service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
if _, _, _, _, err := service.OAuthCallback(ctx, "github", "good-code", state, url.Values{}, "127.0.0.1", "test-agent"); !errors.Is(err, ErrUserBanned) {
|
||||
t.Fatalf("banned oauth login: err = %v, want ErrUserBanned", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthCallbackLinksExistingAccountByEmail — провайдер привязывается к
|
||||
// уже существующему аккаунту с тем же подтверждённым email (blind index).
|
||||
func TestOAuthCallbackLinksExistingAccountByEmail(t *testing.T) {
|
||||
oauthTestServer(t, oauthProfile{Subject: "777", Email: "existing@example.com", EmailVerified: true, Login: "existing"})
|
||||
service, st := oauthTestService(t, oauthTestConfig())
|
||||
ctx := context.Background()
|
||||
|
||||
if _, _, _, err := service.Register(ctx, RegisterInput{
|
||||
Username: "existing", Email: "existing@example.com", Password: "correct-horse-battery",
|
||||
}); err != nil {
|
||||
t.Fatalf("register: %v", err)
|
||||
}
|
||||
existing, err := service.UserByEmail(ctx, "existing@example.com")
|
||||
if err != nil {
|
||||
t.Fatalf("find user: %v", err)
|
||||
}
|
||||
|
||||
state, err := service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
user, _, _, _, err := service.OAuthCallback(ctx, "github", "good-code", state, url.Values{}, "127.0.0.1", "agent")
|
||||
if err != nil {
|
||||
t.Fatalf("oauth callback: %v", err)
|
||||
}
|
||||
if user.ID != existing.ID {
|
||||
t.Fatalf("oauth login must reuse the account: %d != %d", user.ID, existing.ID)
|
||||
}
|
||||
accounts, err := st.ListOAuthAccounts(ctx, user.ID)
|
||||
if err != nil || len(accounts) != 1 {
|
||||
t.Fatalf("link was not created: %v, err = %v", accounts, err)
|
||||
}
|
||||
events, err := st.ListSecurityEvents(ctx, user.ID, 20)
|
||||
if err != nil {
|
||||
t.Fatalf("list security events: %v", err)
|
||||
}
|
||||
found := false
|
||||
for _, event := range events {
|
||||
if event.Type == "oauth_linked" {
|
||||
found = true
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Fatal("security events have no oauth_linked")
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthCallbackRejectsUnverifiedEmail — неподтверждённый email не даёт
|
||||
// войти: иначе чужой адрес в профиле провайдера уводил бы в чужой аккаунт.
|
||||
func TestOAuthCallbackRejectsUnverifiedEmail(t *testing.T) {
|
||||
oauthTestServer(t, oauthProfile{Subject: "5", Email: "unverified@example.com", EmailVerified: false})
|
||||
service, _ := oauthTestService(t, oauthTestConfig())
|
||||
|
||||
state, err := service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
if _, _, _, _, err := service.OAuthCallback(context.Background(), "github", "good-code", state, url.Values{}, "127.0.0.1", "agent"); !errors.Is(err, ErrOAuthEmailUnverified) {
|
||||
t.Fatalf("unverified email: err = %v, want ErrOAuthEmailUnverified", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthCallbackStateAndCodeErrors — неверный state и код отклоняются.
|
||||
func TestOAuthCallbackStateAndCodeErrors(t *testing.T) {
|
||||
oauthTestServer(t, oauthProfile{Subject: "6", Email: "user@example.com", EmailVerified: true})
|
||||
service, _ := oauthTestService(t, oauthTestConfig())
|
||||
ctx := context.Background()
|
||||
|
||||
if _, _, _, _, err := service.OAuthCallback(ctx, "github", "good-code", "broken", url.Values{}, "127.0.0.1", "agent"); !errors.Is(err, ErrOAuthState) {
|
||||
t.Fatalf("bad state: err = %v, want ErrOAuthState", err)
|
||||
}
|
||||
state, err := service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
if _, _, _, _, err := service.OAuthCallback(ctx, "github", "", state, url.Values{}, "127.0.0.1", "agent"); !errors.Is(err, ErrOAuthExchange) {
|
||||
t.Fatalf("empty code: err = %v, want ErrOAuthExchange", err)
|
||||
}
|
||||
if _, _, _, _, err := service.OAuthCallback(ctx, "github", "bad-code", state, url.Values{}, "127.0.0.1", "agent"); !errors.Is(err, ErrOAuthExchange) {
|
||||
t.Fatalf("bad code: err = %v, want ErrOAuthExchange", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthRegistrationDisabledBlocksNewAccounts — существующие аккаунты
|
||||
// входят, новые не создаются при выключенной регистрации (7.1).
|
||||
func TestOAuthRegistrationDisabledBlocksNewAccounts(t *testing.T) {
|
||||
oauthTestServer(t, oauthProfile{Subject: "8", Email: "new@example.com", EmailVerified: true, Login: "new"})
|
||||
service, st := oauthTestService(t, oauthTestConfig())
|
||||
ctx := context.Background()
|
||||
if err := st.SetInstanceSetting(ctx, "registration_enabled", "false"); err != nil {
|
||||
t.Fatalf("disable registration: %v", err)
|
||||
}
|
||||
state, err := service.signOAuthState("github", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
if _, _, _, _, err := service.OAuthCallback(ctx, "github", "good-code", state, url.Values{}, "127.0.0.1", "agent"); !errors.Is(err, ErrRegistrationOff) {
|
||||
t.Fatalf("registration disabled: err = %v, want ErrRegistrationOff", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthStateExpires — state старше окна не принимается, даже если подпись
|
||||
// верна: иначе ссылку можно было бы использовать неограниченно долго.
|
||||
func TestOAuthStateExpires(t *testing.T) {
|
||||
service, _ := oauthTestService(t, oauthTestConfig())
|
||||
payload, err := json.Marshal(map[string]string{
|
||||
"provider": "github",
|
||||
"redirect": "/app",
|
||||
"issued": strconv.FormatInt(time.Now().UTC().Add(-time.Hour).Unix(), 10),
|
||||
"nonce": "deadbeefdeadbeef",
|
||||
})
|
||||
if err != nil {
|
||||
t.Fatalf("marshal payload: %v", err)
|
||||
}
|
||||
encoded := base64.RawURLEncoding.EncodeToString(payload)
|
||||
expired := encoded + "." + service.signStatePayload(encoded)
|
||||
if _, err := service.verifyOAuthState("github", expired); !errors.Is(err, ErrOAuthState) {
|
||||
t.Fatalf("expired state: err = %v, want ErrOAuthState", err)
|
||||
}
|
||||
}
|
||||
|
||||
// TestPasskeyHandleStableAndOpaque — user handle не раскрывает id аккаунта и
|
||||
// стабилен между вызовами.
|
||||
func TestPasskeyHandleStableAndOpaque(t *testing.T) {
|
||||
service, _ := oauthTestService(t, oauthTestBaseConfig())
|
||||
first := service.passkeyHandle(12345)
|
||||
second := service.passkeyHandle(12345)
|
||||
if len(first) != 16 || !bytes.Equal(first, second) {
|
||||
t.Fatalf("handle must be 16 stable bytes: %v / %v", first, second)
|
||||
}
|
||||
if strings.Contains(string(first), "12345") {
|
||||
t.Fatal("handle must not contain the account id")
|
||||
}
|
||||
if bytes.Equal(service.passkeyHandle(12346), first) {
|
||||
t.Fatal("handles of different accounts must differ")
|
||||
}
|
||||
}
|
||||
|
||||
// TestPasskeyCeremonyStoreIsOneTime — церемония выдаётся один раз и по TTL.
|
||||
func TestPasskeyCeremonyStoreIsOneTime(t *testing.T) {
|
||||
store := newCeremonyStore()
|
||||
now := time.Now().UTC()
|
||||
store.now = func() time.Time { return now }
|
||||
store.put("token", ceremony{userID: 1, expiresAt: now.Add(time.Minute)})
|
||||
if _, ok := store.take("token"); !ok {
|
||||
t.Fatal("ceremony must be available once")
|
||||
}
|
||||
if _, ok := store.take("token"); ok {
|
||||
t.Fatal("ceremony must not be reusable")
|
||||
}
|
||||
store.put("expired", ceremony{userID: 1, expiresAt: now.Add(-time.Second)})
|
||||
if _, ok := store.take("expired"); ok {
|
||||
t.Fatal("expired ceremony must not be usable")
|
||||
}
|
||||
}
|
||||
|
||||
// TestSanitizeUsername — логин провайдера приводится к правилам glchat.
|
||||
func TestSanitizeUsername(t *testing.T) {
|
||||
cases := map[string]string{
|
||||
"Octo-Cat": "octo_cat",
|
||||
" John Doe ": "john_doe",
|
||||
"ю": "",
|
||||
"a": "",
|
||||
"user.name": "user.name",
|
||||
"UPPER": "upper",
|
||||
}
|
||||
for input, expected := range cases {
|
||||
if got := sanitizeUsername(input); got != expected {
|
||||
t.Errorf("sanitizeUsername(%q) = %q, want %q", input, got, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestSafeRedirect — открытый редирект невозможен.
|
||||
func TestSafeRedirect(t *testing.T) {
|
||||
if safeRedirect("//evil.example") != "/app" || safeRedirect("https://evil.example") != "/app" {
|
||||
t.Fatal("external redirects must be rejected")
|
||||
}
|
||||
if safeRedirect("/app/invite/x") != "/app/invite/x" || safeRedirect("") != "/app" {
|
||||
t.Fatal("internal redirects must be preserved")
|
||||
}
|
||||
}
|
||||
|
||||
// проверяем, что ключ blind index провайдера не совпадает с email-индексом.
|
||||
func TestOAuthSubjectIndexDiffersFromEmail(t *testing.T) {
|
||||
key, err := crypto.ParseMasterKey(oauthTestConfig().MasterKey)
|
||||
if err != nil {
|
||||
t.Fatalf("parse master key: %v", err)
|
||||
}
|
||||
subject := key.BlindIndex("github:42")
|
||||
email := key.BlindIndex("user@example.com")
|
||||
if subject == email || len(subject) != len(email) {
|
||||
t.Fatal("blind indexes must be independent")
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthVKIDFlow — вход через VK ID: PKCE (code_challenge в запросе
|
||||
// авторизации и code_verifier при обмене), device_id из callback и сервисный
|
||||
// ключ отдельным параметром service_token (VK ID не ждёт client_secret),
|
||||
// профиль забирается методом /oauth2/user_info с client_id в теле.
|
||||
func TestOAuthVKIDFlow(t *testing.T) {
|
||||
mux := http.NewServeMux()
|
||||
var tokenForm url.Values
|
||||
mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
|
||||
if err := r.ParseForm(); err != nil {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
tokenForm = r.PostForm
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"access_token": "vk-access-token",
|
||||
"token_type": "Bearer",
|
||||
"expires_in": 3600,
|
||||
"user_id": 42,
|
||||
})
|
||||
})
|
||||
var infoForm url.Values
|
||||
mux.HandleFunc("/user_info", func(w http.ResponseWriter, r *http.Request) {
|
||||
if err := r.ParseForm(); err != nil {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
infoForm = r.PostForm
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"user": map[string]any{
|
||||
"user_id": 42,
|
||||
"first_name": "Иван",
|
||||
"last_name": "Петров",
|
||||
"email": "ivan@example.com",
|
||||
},
|
||||
})
|
||||
})
|
||||
server := httptest.NewServer(mux)
|
||||
t.Cleanup(server.Close)
|
||||
|
||||
originalProviders := oauthProviderSet
|
||||
originalInfoURL := vkUserInfoURL
|
||||
providers := defaultOAuthProviders()
|
||||
vk := providers["vk"]
|
||||
vk.Endpoint.AuthURL = server.URL + "/authorize"
|
||||
vk.Endpoint.TokenURL = server.URL + "/token"
|
||||
providers["vk"] = vk
|
||||
oauthProviderSet = providers
|
||||
vkUserInfoURL = server.URL + "/user_info"
|
||||
t.Cleanup(func() {
|
||||
oauthProviderSet = originalProviders
|
||||
vkUserInfoURL = originalInfoURL
|
||||
})
|
||||
|
||||
cfg := oauthTestConfig()
|
||||
cfg.OAuthVKClientID = "vk-client"
|
||||
cfg.OAuthVKClientSecret = "vk-service-token"
|
||||
service, _ := oauthTestService(t, cfg)
|
||||
if providers := service.OAuthProviders(); len(providers) != 2 || providers[0].ID != "vk" {
|
||||
t.Fatalf("providers = %v, want vk первым", providers)
|
||||
}
|
||||
|
||||
authorizeURL, err := service.OAuthAuthorizeURL("vk", "/app/friends")
|
||||
if err != nil {
|
||||
t.Fatalf("authorize url: %v", err)
|
||||
}
|
||||
parsed, err := url.Parse(authorizeURL)
|
||||
if err != nil {
|
||||
t.Fatalf("parse authorize url: %v", err)
|
||||
}
|
||||
query := parsed.Query()
|
||||
if query.Get("code_challenge") == "" || query.Get("code_challenge_method") != "S256" {
|
||||
t.Fatalf("в ссылке нет PKCE: %s", authorizeURL)
|
||||
}
|
||||
if query.Get("client_id") != "vk-client" {
|
||||
t.Fatalf("client_id = %q", query.Get("client_id"))
|
||||
}
|
||||
if !strings.Contains(query.Get("scope"), "email") {
|
||||
t.Fatalf("scope = %q, want email", query.Get("scope"))
|
||||
}
|
||||
state := query.Get("state")
|
||||
if state == "" {
|
||||
t.Fatal("в ссылке нет state")
|
||||
}
|
||||
|
||||
ctx := context.Background()
|
||||
user, token, session, redirect, err := service.OAuthCallback(ctx, "vk",
|
||||
"vk-code", state, url.Values{"device_id": {"device-123"}}, "127.0.0.1", "agent")
|
||||
if err != nil {
|
||||
t.Fatalf("OAuthCallback: %v", err)
|
||||
}
|
||||
if token == "" || session == nil {
|
||||
t.Fatalf("token=%q session=%v", token, session)
|
||||
}
|
||||
// Email зашифрован: наружу его отдаёт только сервис.
|
||||
email, err := service.Email(ctx, user.ID)
|
||||
if err != nil || email != "ivan@example.com" {
|
||||
t.Fatalf("email = %q, err = %v", email, err)
|
||||
}
|
||||
if redirect != "/app/friends" {
|
||||
t.Fatalf("redirect = %q", redirect)
|
||||
}
|
||||
// Обмен кода: PKCE-верификатор (43 символа), device_id и service_token.
|
||||
if len(tokenForm.Get("code_verifier")) != 43 {
|
||||
t.Fatalf("code_verifier = %q (len %d), want 43", tokenForm.Get("code_verifier"), len(tokenForm.Get("code_verifier")))
|
||||
}
|
||||
if tokenForm.Get("device_id") != "device-123" {
|
||||
t.Fatalf("device_id = %q", tokenForm.Get("device_id"))
|
||||
}
|
||||
if tokenForm.Get("service_token") != "vk-service-token" {
|
||||
t.Fatalf("service_token = %q", tokenForm.Get("service_token"))
|
||||
}
|
||||
if tokenForm.Get("client_secret") != "" {
|
||||
t.Fatalf("client_secret не должен уходить в VK: %q", tokenForm.Get("client_secret"))
|
||||
}
|
||||
if tokenForm.Get("state") != state {
|
||||
t.Fatalf("state в обмене = %q, want %q", tokenForm.Get("state"), state)
|
||||
}
|
||||
// Профиль: POST с client_id и токеном.
|
||||
if infoForm.Get("client_id") != "vk-client" || infoForm.Get("access_token") != "vk-access-token" {
|
||||
t.Fatalf("user_info form = %v", infoForm)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthYandexFlow — вход через Яндекс ID: обмен кода с client_id/secret в
|
||||
// теле запроса и профиль по заголовку `Authorization: OAuth <токен>`.
|
||||
func TestOAuthYandexFlow(t *testing.T) {
|
||||
mux := http.NewServeMux()
|
||||
var infoAuth string
|
||||
mux.HandleFunc("/token", func(w http.ResponseWriter, r *http.Request) {
|
||||
if err := r.ParseForm(); err != nil {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if r.PostForm.Get("client_id") != "ya-client" || r.PostForm.Get("client_secret") != "ya-secret" {
|
||||
w.WriteHeader(http.StatusUnauthorized)
|
||||
return
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"access_token": "ya-access-token",
|
||||
"token_type": "bearer",
|
||||
"expires_in": 3600,
|
||||
})
|
||||
})
|
||||
mux.HandleFunc("/info", func(w http.ResponseWriter, r *http.Request) {
|
||||
infoAuth = r.Header.Get("Authorization")
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"id": "1000034426",
|
||||
"login": "ivan",
|
||||
"default_email": "ivan@yandex.ru",
|
||||
"emails": []string{"ivan@yandex.ru"},
|
||||
"real_name": "Иван Петров",
|
||||
})
|
||||
})
|
||||
server := httptest.NewServer(mux)
|
||||
t.Cleanup(server.Close)
|
||||
|
||||
originalProviders := oauthProviderSet
|
||||
originalInfoURL := yandexInfoURL
|
||||
providers := defaultOAuthProviders()
|
||||
yandex := providers["yandex"]
|
||||
yandex.Endpoint.AuthURL = server.URL + "/authorize"
|
||||
yandex.Endpoint.TokenURL = server.URL + "/token"
|
||||
providers["yandex"] = yandex
|
||||
oauthProviderSet = providers
|
||||
yandexInfoURL = server.URL + "/info"
|
||||
t.Cleanup(func() {
|
||||
oauthProviderSet = originalProviders
|
||||
yandexInfoURL = originalInfoURL
|
||||
})
|
||||
|
||||
cfg := oauthTestConfig()
|
||||
cfg.OAuthYandexClientID = "ya-client"
|
||||
cfg.OAuthYandexClientSecret = "ya-secret"
|
||||
service, _ := oauthTestService(t, cfg)
|
||||
|
||||
authorizeURL, err := service.OAuthAuthorizeURL("yandex", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("authorize url: %v", err)
|
||||
}
|
||||
parsed, err := url.Parse(authorizeURL)
|
||||
if err != nil {
|
||||
t.Fatalf("parse authorize url: %v", err)
|
||||
}
|
||||
if parsed.Query().Get("code_challenge") != "" {
|
||||
t.Fatal("Яндекс не требует PKCE: code_challenge не нужен")
|
||||
}
|
||||
state := parsed.Query().Get("state")
|
||||
|
||||
ctx := context.Background()
|
||||
user, _, _, _, err := service.OAuthCallback(ctx, "yandex",
|
||||
"ya-code", state, url.Values{}, "127.0.0.1", "agent")
|
||||
if err != nil {
|
||||
t.Fatalf("OAuthCallback: %v", err)
|
||||
}
|
||||
email, err := service.Email(ctx, user.ID)
|
||||
if err != nil || email != "ivan@yandex.ru" {
|
||||
t.Fatalf("email = %q, err = %v", email, err)
|
||||
}
|
||||
if user.Username != "ivan" {
|
||||
t.Fatalf("username = %q, want логин Яндекса", user.Username)
|
||||
}
|
||||
if infoAuth != "OAuth ya-access-token" {
|
||||
t.Fatalf("Authorization = %q, want `OAuth …`", infoAuth)
|
||||
}
|
||||
}
|
||||
|
||||
// TestOAuthVKPublicAppWithoutSecret — публичному приложению VK ID сервисный
|
||||
// ключ не нужен: вход включается по одному client_id, а запрос обмена не несёт
|
||||
// ни client_secret, ни service_token (защиту даёт PKCE).
|
||||
func TestOAuthVKPublicAppWithoutSecret(t *testing.T) {
|
||||
originalProviders := oauthProviderSet
|
||||
originalInfoURL := vkUserInfoURL
|
||||
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
||||
if err := r.ParseForm(); err != nil {
|
||||
w.WriteHeader(http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
if r.PostForm.Get("service_token") != "" || r.PostForm.Get("client_secret") != "" {
|
||||
t.Errorf("публичное приложение не должно отправлять секрет: %v", r.PostForm)
|
||||
}
|
||||
w.Header().Set("Content-Type", "application/json")
|
||||
if strings.HasSuffix(r.URL.Path, "/user_info") {
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{
|
||||
"user": map[string]any{"user_id": 7, "first_name": "Пётр", "email": "petr@example.com"},
|
||||
})
|
||||
return
|
||||
}
|
||||
_ = json.NewEncoder(w).Encode(map[string]any{"access_token": "vk-token", "token_type": "Bearer"})
|
||||
}))
|
||||
t.Cleanup(server.Close)
|
||||
|
||||
providers := defaultOAuthProviders()
|
||||
vk := providers["vk"]
|
||||
vk.Endpoint.TokenURL = server.URL + "/token"
|
||||
providers["vk"] = vk
|
||||
oauthProviderSet = providers
|
||||
vkUserInfoURL = server.URL + "/user_info"
|
||||
t.Cleanup(func() {
|
||||
oauthProviderSet = originalProviders
|
||||
vkUserInfoURL = originalInfoURL
|
||||
})
|
||||
|
||||
cfg := oauthTestConfig()
|
||||
cfg.OAuthVKClientID = "vk-public"
|
||||
cfg.OAuthVKClientSecret = ""
|
||||
service, _ := oauthTestService(t, cfg)
|
||||
if !service.OAuthEnabled() {
|
||||
t.Fatal("вход через VK должен работать без сервисного ключа")
|
||||
}
|
||||
state, err := service.signOAuthState("vk", "/app")
|
||||
if err != nil {
|
||||
t.Fatalf("sign state: %v", err)
|
||||
}
|
||||
ctx := context.Background()
|
||||
user, _, _, _, err := service.OAuthCallback(ctx, "vk", "code", state,
|
||||
url.Values{"device_id": {"device-1"}}, "127.0.0.1", "agent")
|
||||
if err != nil {
|
||||
t.Fatalf("OAuthCallback: %v", err)
|
||||
}
|
||||
email, err := service.Email(ctx, user.ID)
|
||||
if err != nil || email != "petr@example.com" {
|
||||
t.Fatalf("email = %q, err = %v", email, err)
|
||||
}
|
||||
}
|
||||
@@ -60,11 +60,8 @@ type Service struct {
|
||||
webauthn *webauthn.WebAuthn
|
||||
// ceremonies — начатые церемонии WebAuthn (в памяти, одноразовые).
|
||||
ceremonies *ceremonyStore
|
||||
// oauth — включённые провайдеры (client id/secret из env), oauthRedirectBase —
|
||||
// внешний адрес инстанса для redirect_uri, stateKey — ключ подписи state.
|
||||
oauth map[string]oauthClientCredentials
|
||||
oauthRedirectBase string
|
||||
stateKey string
|
||||
stateKey string
|
||||
}
|
||||
|
||||
type instanceSettings interface {
|
||||
@@ -113,9 +110,8 @@ func New(ctx context.Context, cfg config.Config, st *store.Store, logger *slog.L
|
||||
sessionTTL = store.SessionTTL
|
||||
}
|
||||
|
||||
// OAuth-провайдеры и RP-конфигурация passkeys: включаются конфигом, при
|
||||
// RP-конфигурация passkeys: включается конфигом, при
|
||||
// отсутствии настроек соответствующие ручки отвечают понятной ошибкой.
|
||||
oauthClients, oauthRedirectBase := oauthFromConfig(cfg, cfg.BaseURL())
|
||||
|
||||
service := &Service{
|
||||
store: st,
|
||||
@@ -126,11 +122,8 @@ func New(ctx context.Context, cfg config.Config, st *store.Store, logger *slog.L
|
||||
policy: policy,
|
||||
cfg: Config{SessionTTL: sessionTTL, MaxLoginFails: 5, LockoutWindow: 15 * time.Minute},
|
||||
logger: logger,
|
||||
// state OAuth подписывается секретом сессий: отдельного секрета не нужно.
|
||||
oauth: oauthClients,
|
||||
oauthRedirectBase: oauthRedirectBase,
|
||||
stateKey: cfg.SessionPepper,
|
||||
ceremonies: newCeremonyStore(),
|
||||
stateKey: cfg.SessionPepper,
|
||||
ceremonies: newCeremonyStore(),
|
||||
}
|
||||
// Passkeys требуют корректного RP ID: для IP-адреса (стенд без домена)
|
||||
// браузеры WebAuthn не работают, поэтому такой инстанс просто живёт без них.
|
||||
|
||||
Reference in New Issue
Block a user