Какие писал способы аутентификации?

Методы аутентификации в веб-приложениях на Go

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

1. Аутентификация на основе сессий (Session-based)

Это классический подход, где состояние аутентификации хранится на сервере.

Реализация с использованием стандартной библиотеки и файлового хранилища:

package main

import (
    "net/http"
    "github.com/gorilla/sessions"
)

var store = sessions.NewCookieStore([]byte("secret-key"))

func loginHandler(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "session-name")
    session.Values["authenticated"] = true
    session.Save(r, w)
    w.Write([]byte("Logged in"))
}

func protectedHandler(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "session-name")
    if auth, ok := session.Values["authenticated"].(bool); ok && auth {
        w.Write([]byte("Protected content"))
        return
    }
    http.Error(w, "Unauthorized", http.StatusUnauthorized)
}

Для более масштабных приложений использовал распределенные хранилища сессий, например Redis:

import (
    "github.com/go-redis/redis"
    "github.com/gorilla/sessions"
    "github.com/boj/redistore"
)

func createRedisStore() *redistore.RediStore {
    client := redis.NewClient(&redis.Options{Addr: "localhost:6379"})
    store, err := redistore.NewRediStoreWithClient(client, []byte("secret-key"))
    if err != nil {
        panic(err)
    }
    return store
}

2. Токен-ориентированная аутентификация (Token-based)

Этот метод стал основным в современных RESTful API и микросервисных архитектурах.

JWT (JSON Web Tokens)

Генерация и валидация JWT токенов:

import (
    "time"
    "github.com/golang-jwt/jwt/v5"
)

type Claims struct {
    Username string `json:"username"`
    jwt.RegisteredClaims
}

func generateJWT(username string) (string, error) {
    claims := &Claims{
        Username: username,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(time.Now().Add(24 * time.Hour)),
            Issuer:    "myapp",
        },
    }
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    return token.SignedString([]byte("secret-key"))
}

func validateJWT(tokenString string) (*Claims, error) {
    claims := &Claims{}
    token, err := jwt.ParseWithClaims(tokenString, claims, 
        func(token *jwt.Token) (interface{}, error) {
            return []byte("secret-key"), nil
        })
    if err != nil || !token.Valid {
        return nil, err
    }
    return claims, nil
}

Для защиты API добавлял middleware для проверки JWT:

func jwtMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        token := r.Header.Get("Authorization")
        if token == "" {
            http.Error(w, "Missing token", http.StatusUnauthorized)
            return
        }
        claims, err := validateJWT(token[7:]) // Убираем "Bearer "
        if err != nil {
            http.Error(w, "Invalid token", http.StatusUnauthorized)
            return
        }
        r = r.WithContext(context.WithValue(r.Context(), "username", claims.Username))
        next(w, r)
    }
}

OAuth2 и API ключи

Для интеграции с внешними сервисами реализовывал OAuth2 flow с использованием библиотеки golang.org/x/oauth2. Также использовал простые API ключи для сервисной аутентификации между микросервисами.

3. Специализированные протоколы и подходы

• OpenID Connect: Комбинировал с JWT для идентификации пользователей через внешние провайдеры.
• Basic Authentication: Для простых внутренних сервисов или административных интерфейсов.
• HMAC-based authentication: Для веб-хуков и callback API, где проверялась цифровая подпись запросов.
• Мультифакторная аутентификация (MFA): Добавлял второй фактор через временные коды (TOTP) или биометрию.

Ключевые практики безопасности

При реализации любой аутентификации обязательно соблюдал следующие принципы:

• Хранение секретов: Ключи для JWT или сессий никогда хранил в коде, использовал переменные окружения или специализированные сервисы (Vault, KMS).
• Защита транспорта: Всегда использовал HTTPS для передачи токенов и сессионных данных.
• Валидация и санация: Проверял все входные данные, особенно в процессах регистрации и логина.
• Логирование и мониторинг: Добавлял аудит попыток аутентификации для выявления аномальной активности.

Выбор конкретного метода всегда зависит от контекста: сессии хороши для традиционных веб-приложений с SSR, JWT идеальны для SPA и API, а OAuth2 необходим при интеграциях. В современных проектах чаще всего использую гибридный подход: JWT для основного API и сессии для административных интерфейсов.