GiteaAdmin/go-lcg
1
0
Fork 0
mirror of https://github.com/Direct-Dev-Ru/go-lcg.git synced 2025-11-16 01:29:55 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merged main into release while building v.2.0.21

Browse Source
This commit is contained in:
Кузнецов Антон (aka Direct-dev.ru)
2025-11-09 15:01:31 +06:00
parent 1428e0bd5c 7b7142a5c3
commit fbf8e0408c
10 changed files with 97 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Dockerfiles/OllamaServer/entrypoint.sh
View File

@@ -65,6 +65,11 @@ export LCG_CONFIG_FOLDER="${LCG_CONFIG_FOLDER:-/app/data/config}"
export LCG_SERVER_HOST="${LCG_SERVER_HOST:-0.0.0.0}"
export LCG_SERVER_PORT="${LCG_SERVER_PORT:-8080}"
export LCG_SERVER_ALLOW_HTTP="${LCG_SERVER_ALLOW_HTTP:-false}"
export LCG_FORCE_NO_CSRF="${LCG_FORCE_NO_CSRF:-true}"
if [ "$LCG_FORCE_NO_CSRF" = "true" ]; then
info "CSRF проверка отключена через LCG_FORCE_NO_CSRF"
fi
log "=========================================="
log "Запуск LCG с Ollama сервером"

2
VERSION.txt
View File

@@ -1 +1 @@
v.2.0.20
v.2.0.21

11
config/config.go
View File

@@ -58,6 +58,7 @@ type ServerConfig struct {
CookieSecure bool
CookiePath string
CookieTTLHours int
ForceNoCSRF bool
}
type ValidationConfig struct {
@@ -166,6 +167,7 @@ func Load() Config {
BasePath: getEnv("LCG_BASE_URL", "/lcg"),
HealthUrl: getEnv("LCG_HEALTH_URL", "/api/v1/protected/sberchat/health"),
ProxyUrl: getEnv("LCG_PROXY_URL", "/api/v1/protected/sberchat/chat"),
ForceNoCSRF: isForceNoCSRF(),
},
Validation: ValidationConfig{
MaxSystemPromptLength: getEnvInt("LCG_MAX_SYSTEM_PROMPT_LENGTH", 2000),
@@ -214,6 +216,15 @@ func isCookieSecure() bool {
return vLower == "1" || vLower == "true"
}
func isForceNoCSRF() bool {
v := strings.TrimSpace(getEnv("LCG_FORCE_NO_CSRF", ""))
if v == "" {
return false
}
vLower := strings.ToLower(v)
return vLower == "1" || vLower == "true"
}
var AppConfig Config
func init() {

2
deploy/VERSION.txt
View File

@@ -1 +1 @@
v.2.0.20
v.2.0.21

2
kustomize/configmap.yaml
View File

@@ -5,7 +5,7 @@ metadata:
namespace: lcg
data:
# Основные настройки
LCG_VERSION: "v.2.0.20"
LCG_VERSION: "v.2.0.21"
LCG_BASE_PATH: "/lcg"
LCG_SERVER_HOST: "0.0.0.0"
LCG_SERVER_PORT: "8080"

4
kustomize/deployment.yaml
View File

@@ -5,7 +5,7 @@ metadata:
namespace: lcg
labels:
app: lcg
version: v.2.0.20
version: v.2.0.21
spec:
replicas: 1
selector:
@@ -18,7 +18,7 @@ spec:
spec:
containers:
- name: lcg
image: kuznetcovay/lcg:v.2.0.20
image: kuznetcovay/lcg:v.2.0.21
imagePullPolicy: Always
ports:
- containerPort: 8080

4
kustomize/kustomization.yaml
View File

@@ -15,11 +15,11 @@ resources:
# Common labels
# commonLabels:
# app: lcg
# version: v.2.0.20
# version: v.2.0.21
# managed-by: kustomize
# Images
# images:
# - name: lcg
# newName: kuznetcovay/lcg
# newTag: v.2.0.20
# newTag: v.2.0.21

67
serve/csrf.go
View File

@@ -20,6 +20,13 @@ const (
CSRFTokenLifetimeSeconds = CSRFTokenLifetimeHours * 60 * 60
)
// csrfDebugPrint выводит отладочную информацию только если включен debug режим
func csrfDebugPrint(format string, args ...interface{}) {
if config.AppConfig.MainFlags.Debug {
fmt.Printf(format, args...)
}
}
// CSRFManager управляет CSRF токенами
type CSRFManager struct {
secretKey []byte
@@ -75,7 +82,7 @@ func getCSRFSecretKey() ([]byte, error) {
// GenerateToken генерирует CSRF токен для пользователя
func (c *CSRFManager) GenerateToken(userID string) (string, error) {
fmt.Printf("[CSRF DEBUG] Генерация нового токена для UserID: %s\n", userID)
csrfDebugPrint("[CSRF DEBUG] Генерация нового токена для UserID: %s\n", userID)
// Создаем данные токена
data := CSRFData{
@@ -84,85 +91,85 @@ func (c *CSRFManager) GenerateToken(userID string) (string, error) {
UserID: userID,
}
fmt.Printf("[CSRF DEBUG] Созданные данные токена: Token (первые 20 символов): %s..., Timestamp: %d, UserID: %s\n",
csrfDebugPrint("[CSRF DEBUG] Созданные данные токена: Token (первые 20 символов): %s..., Timestamp: %d, UserID: %s\n",
safeSubstring(data.Token, 0, 20), data.Timestamp, data.UserID)
// Создаем подпись
signature := c.createSignature(data)
fmt.Printf("[CSRF DEBUG] Созданная подпись (первые 20 символов): %s...\n", safeSubstring(signature, 0, 20))
csrfDebugPrint("[CSRF DEBUG] Созданная подпись (первые 20 символов): %s...\n", safeSubstring(signature, 0, 20))
// Кодируем данные в base64
encodedData := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%d:%s", data.Token, data.Timestamp, data.UserID)))
fmt.Printf("[CSRF DEBUG] Закодированные данные (первые 30 символов): %s...\n", safeSubstring(encodedData, 0, 30))
csrfDebugPrint("[CSRF DEBUG] Закодированные данные (первые 30 символов): %s...\n", safeSubstring(encodedData, 0, 30))
token := fmt.Sprintf("%s.%s", encodedData, signature)
fmt.Printf("[CSRF DEBUG] Итоговый токен сгенерирован (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
csrfDebugPrint("[CSRF DEBUG] Итоговый токен сгенерирован (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
return token, nil
}
// ValidateToken проверяет CSRF токен
func (c *CSRFManager) ValidateToken(token, userID string) bool {
fmt.Printf("[CSRF DEBUG] Начало валидации токена. UserID из запроса: %s\n", userID)
fmt.Printf("[CSRF DEBUG] Токен (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
csrfDebugPrint("[CSRF DEBUG] Начало валидации токена. UserID из запроса: %s\n", userID)
csrfDebugPrint("[CSRF DEBUG] Токен (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
// Разделяем токен на данные и подпись
parts := splitToken(token)
if len(parts) != 2 {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: Токен не может быть разделен на 2 части. Получено частей: %d\n", len(parts))
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Токен не может быть разделен на 2 части. Получено частей: %d\n", len(parts))
return false
}
encodedData, signature := parts[0], parts[1]
fmt.Printf("[CSRF DEBUG] Токен разделен на encodedData (первые 30 символов): %s... и signature (первые 20 символов): %s...\n",
csrfDebugPrint("[CSRF DEBUG] Токен разделен на encodedData (первые 30 символов): %s... и signature (первые 20 символов): %s...\n",
safeSubstring(encodedData, 0, 30), safeSubstring(signature, 0, 20))
// Декодируем данные
dataBytes, err := base64.StdEncoding.DecodeString(encodedData)
if err != nil {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: Не удалось декодировать base64 данные: %v\n", err)
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Не удалось декодировать base64 данные: %v\n", err)
return false
}
fmt.Printf("[CSRF DEBUG] Данные декодированы. Длина: %d байт\n", len(dataBytes))
csrfDebugPrint("[CSRF DEBUG] Данные декодированы. Длина: %d байт\n", len(dataBytes))
// Парсим данные
dataParts := splitString(string(dataBytes), ":")
if len(dataParts) != 3 {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: Данные не могут быть разделены на 3 части. Получено частей: %d. Данные: %s\n", len(dataParts), string(dataBytes))
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Данные не могут быть разделены на 3 части. Получено частей: %d. Данные: %s\n", len(dataParts), string(dataBytes))
return false
}
tokenValue, timestampStr, tokenUserID := dataParts[0], dataParts[1], dataParts[2]
fmt.Printf("[CSRF DEBUG] Распарсены данные: tokenValue (первые 20 символов): %s..., timestamp: %s, tokenUserID: %s\n",
csrfDebugPrint("[CSRF DEBUG] Распарсены данные: tokenValue (первые 20 символов): %s..., timestamp: %s, tokenUserID: %s\n",
safeSubstring(tokenValue, 0, 20), timestampStr, tokenUserID)
// Проверяем пользователя
if tokenUserID != userID {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: UserID не совпадает! Ожидался: '%s', получен из токена: '%s'\n", userID, tokenUserID)
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: UserID не совпадает! Ожидался: '%s', получен из токена: '%s'\n", userID, tokenUserID)
return false
}
fmt.Printf("[CSRF DEBUG] ✅ UserID совпадает: %s\n", userID)
csrfDebugPrint("[CSRF DEBUG] ✅ UserID совпадает: %s\n", userID)
// Проверяем время жизни токена (минимум 12 часов)
timestamp, err := parseInt64(timestampStr)
if err != nil {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: Не удалось распарсить timestamp '%s': %v\n", timestampStr, err)
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Не удалось распарсить timestamp '%s': %v\n", timestampStr, err)
return false
}
now := time.Now().Unix()
age := now - timestamp
ageHours := float64(age) / 3600.0
fmt.Printf("[CSRF DEBUG] Текущее время: %d, timestamp токена: %d, возраст токена: %d сек (%.2f часов)\n", now, timestamp, age, ageHours)
csrfDebugPrint("[CSRF DEBUG] Текущее время: %d, timestamp токена: %d, возраст токена: %d сек (%.2f часов)\n", now, timestamp, age, ageHours)
// Минимальное время жизни токена: 12 часов (не менее 12 часов согласно требованиям)
if age > CSRFTokenLifetimeSeconds {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: Токен устарел! Возраст: %d сек (%.2f часов), максимум: %d сек (%.2f часов)\n",
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Токен устарел! Возраст: %d сек (%.2f часов), максимум: %d сек (%.2f часов)\n",
age, ageHours, CSRFTokenLifetimeSeconds, float64(CSRFTokenLifetimeSeconds)/3600.0)
return false
}
fmt.Printf("[CSRF DEBUG] ✅ Токен не устарел (возраст в пределах лимита)\n")
csrfDebugPrint("[CSRF DEBUG] ✅ Токен не устарел (возраст в пределах лимита)\n")
// Создаем данные для проверки подписи
data := CSRFData{
@@ -175,15 +182,15 @@ func (c *CSRFManager) ValidateToken(token, userID string) bool {
expectedSignature := c.createSignature(data)
signatureMatch := signature == expectedSignature
if !signatureMatch {
fmt.Printf("[CSRF DEBUG] ❌ ОШИБКА: Подпись не совпадает!\n")
fmt.Printf("[CSRF DEBUG] Ожидаемая подпись (первые 20 символов): %s...\n", safeSubstring(expectedSignature, 0, 20))
fmt.Printf("[CSRF DEBUG] Полученная подпись (первые 20 символов): %s...\n", safeSubstring(signature, 0, 20))
fmt.Printf("[CSRF DEBUG] Данные для подписи: Token=%s (первые 20), Timestamp=%d, UserID=%s\n",
csrfDebugPrint("[CSRF DEBUG] ❌ ОШИБКА: Подпись не совпадает!\n")
csrfDebugPrint("[CSRF DEBUG] Ожидаемая подпись (первые 20 символов): %s...\n", safeSubstring(expectedSignature, 0, 20))
csrfDebugPrint("[CSRF DEBUG] Полученная подпись (первые 20 символов): %s...\n", safeSubstring(signature, 0, 20))
csrfDebugPrint("[CSRF DEBUG] Данные для подписи: Token=%s (первые 20), Timestamp=%d, UserID=%s\n",
safeSubstring(tokenValue, 0, 20), timestamp, tokenUserID)
} else {
fmt.Printf("[CSRF DEBUG] ✅ Подпись совпадает\n")
csrfDebugPrint("[CSRF DEBUG] ✅ Подпись совпадает\n")
}
fmt.Printf("[CSRF DEBUG] Результат валидации: %t\n", signatureMatch)
csrfDebugPrint("[CSRF DEBUG] Результат валидации: %t\n", signatureMatch)
return signatureMatch
}
@@ -217,8 +224,8 @@ func GetCSRFTokenFromCookie(r *http.Request) string {
// setCSRFCookie устанавливает CSRF токен в cookie
func setCSRFCookie(w http.ResponseWriter, token string) {
fmt.Printf("[CSRF DEBUG] Установка CSRF cookie. Токен (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
fmt.Printf("[CSRF DEBUG] Cookie настройки: Path=%s, Secure=%t, Domain=%s, MaxAge=%d сек\n",
csrfDebugPrint("[CSRF DEBUG] Установка CSRF cookie. Токен (первые 50 символов): %s...\n", safeSubstring(token, 0, 50))
csrfDebugPrint("[CSRF DEBUG] Cookie настройки: Path=%s, Secure=%t, Domain=%s, MaxAge=%d сек\n",
config.AppConfig.Server.CookiePath,
config.AppConfig.Server.CookieSecure,
config.AppConfig.Server.Domain,
@@ -238,13 +245,13 @@ func setCSRFCookie(w http.ResponseWriter, token string) {
// Добавляем домен если указан
if config.AppConfig.Server.Domain != "" {
cookie.Domain = config.AppConfig.Server.Domain
fmt.Printf("[CSRF DEBUG] Cookie Domain установлен: %s\n", cookie.Domain)
csrfDebugPrint("[CSRF DEBUG] Cookie Domain установлен: %s\n", cookie.Domain)
} else {
fmt.Printf("[CSRF DEBUG] Cookie Domain не установлен (пустой)\n")
csrfDebugPrint("[CSRF DEBUG] Cookie Domain не установлен (пустой)\n")
}
http.SetCookie(w, cookie)
fmt.Printf("[CSRF DEBUG] ✅ CSRF cookie установлен: Name=%s, Path=%s, Domain=%s, Secure=%t, HttpOnly=%t, SameSite=%v, MaxAge=%d\n",
csrfDebugPrint("[CSRF DEBUG] ✅ CSRF cookie установлен: Name=%s, Path=%s, Domain=%s, Secure=%t, HttpOnly=%t, SameSite=%v, MaxAge=%d\n",
cookie.Name, cookie.Path, cookie.Domain, cookie.Secure, cookie.HttpOnly, cookie.SameSite, cookie.MaxAge)
}

7
serve/login.go
View File

@@ -3,7 +3,6 @@ package serve
import (
"crypto/sha256"
"encoding/hex"
"fmt"
"html/template"
"net/http"
@@ -93,7 +92,7 @@ func RenderLoginPage(w http.ResponseWriter, data LoginPageData) error {
func getSessionID(r *http.Request) string {
// Пытаемся получить из cookie
if cookie, err := r.Cookie("session_id"); err == nil {
fmt.Printf("[CSRF DEBUG] SessionID получен из cookie: %s\n", cookie.Value)
csrfDebugPrint("[CSRF DEBUG] SessionID получен из cookie: %s\n", cookie.Value)
return cookie.Value
}
@@ -101,12 +100,12 @@ func getSessionID(r *http.Request) string {
ip := r.RemoteAddr
userAgent := r.Header.Get("User-Agent")
fmt.Printf("[CSRF DEBUG] SessionID не найден в cookie. Генерация нового на основе IP=%s, User-Agent (первые 50 символов): %s...\n",
csrfDebugPrint("[CSRF DEBUG] SessionID не найден в cookie. Генерация нового на основе IP=%s, User-Agent (первые 50 символов): %s...\n",
ip, safeSubstring(userAgent, 0, 50))
// Создаем простой хеш для сессии
hash := sha256.Sum256([]byte(ip + userAgent))
sessionID := hex.EncodeToString(hash[:])[:16]
fmt.Printf("[CSRF DEBUG] Сгенерирован SessionID: %s\n", sessionID)
csrfDebugPrint("[CSRF DEBUG] Сгенерирован SessionID: %s\n", sessionID)
return sessionID
}

62
serve/middleware.go
View File

@@ -1,7 +1,6 @@
package serve
import (
"fmt"
"net/http"
"strings"
@@ -46,29 +45,36 @@ func AuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
// CSRFMiddleware проверяет CSRF токены для POST/PUT/DELETE запросов
func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
fmt.Printf("\n[CSRF MIDDLEWARE] ==========================================\n")
fmt.Printf("[CSRF MIDDLEWARE] Обработка запроса: %s %s\n", r.Method, r.URL.Path)
fmt.Printf("[CSRF MIDDLEWARE] RemoteAddr: %s\n", r.RemoteAddr)
fmt.Printf("[CSRF MIDDLEWARE] Host: %s\n", r.Host)
// Проверяем, нужно ли пропустить CSRF проверку
if config.AppConfig.Server.ForceNoCSRF {
csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️ CSRF проверка отключена через LCG_FORCE_NO_CSRF\n")
next(w, r)
return
}
csrfDebugPrint("\n[CSRF MIDDLEWARE] ==========================================\n")
csrfDebugPrint("[CSRF MIDDLEWARE] Обработка запроса: %s %s\n", r.Method, r.URL.Path)
csrfDebugPrint("[CSRF MIDDLEWARE] RemoteAddr: %s\n", r.RemoteAddr)
csrfDebugPrint("[CSRF MIDDLEWARE] Host: %s\n", r.Host)
// Выводим все заголовки
fmt.Printf("[CSRF MIDDLEWARE] Заголовки:\n")
csrfDebugPrint("[CSRF MIDDLEWARE] Заголовки:\n")
for name, values := range r.Header {
if name == "Cookie" {
// Cookie выводим отдельно, разбирая их
fmt.Printf("[CSRF MIDDLEWARE] %s: %s\n", name, strings.Join(values, "; "))
csrfDebugPrint("[CSRF MIDDLEWARE] %s: %s\n", name, strings.Join(values, "; "))
} else {
fmt.Printf("[CSRF MIDDLEWARE] %s: %s\n", name, strings.Join(values, ", "))
csrfDebugPrint("[CSRF MIDDLEWARE] %s: %s\n", name, strings.Join(values, ", "))
}
}
// Выводим все cookies
fmt.Printf("[CSRF MIDDLEWARE] Все cookies:\n")
csrfDebugPrint("[CSRF MIDDLEWARE] Все cookies:\n")
if len(r.Cookies()) == 0 {
fmt.Printf("[CSRF MIDDLEWARE] (нет cookies)\n")
csrfDebugPrint("[CSRF MIDDLEWARE] (нет cookies)\n")
} else {
for _, cookie := range r.Cookies() {
fmt.Printf("[CSRF MIDDLEWARE] %s = %s (Path: %s, Domain: %s, Secure: %t, HttpOnly: %t, SameSite: %v, MaxAge: %d)\n",
csrfDebugPrint("[CSRF MIDDLEWARE] %s = %s (Path: %s, Domain: %s, Secure: %t, HttpOnly: %t, SameSite: %v, MaxAge: %d)\n",
cookie.Name,
safeSubstring(cookie.Value, 0, 50),
cookie.Path,
@@ -82,14 +88,14 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
// Проверяем только изменяющие запросы
if r.Method == "GET" || r.Method == "HEAD" || r.Method == "OPTIONS" {
fmt.Printf("[CSRF MIDDLEWARE] Пропускаем проверку CSRF для метода %s\n", r.Method)
csrfDebugPrint("[CSRF MIDDLEWARE] Пропускаем проверку CSRF для метода %s\n", r.Method)
next(w, r)
return
}
// Исключаем некоторые API endpoints (с учетом BasePath)
if r.URL.Path == makePath("/api/login") || r.URL.Path == makePath("/api/logout") {
fmt.Printf("[CSRF MIDDLEWARE] Пропускаем проверку CSRF для пути %s\n", r.URL.Path)
csrfDebugPrint("[CSRF MIDDLEWARE] Пропускаем проверку CSRF для пути %s\n", r.URL.Path)
next(w, r)
return
}
@@ -98,9 +104,9 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
csrfTokenFromHeader := r.Header.Get("X-CSRF-Token")
csrfTokenFromForm := r.FormValue("csrf_token")
fmt.Printf("[CSRF MIDDLEWARE] CSRF токен из заголовка X-CSRF-Token: %s\n",
csrfDebugPrint("[CSRF MIDDLEWARE] CSRF токен из заголовка X-CSRF-Token: %s\n",
safeSubstring(csrfTokenFromHeader, 0, 50))
fmt.Printf("[CSRF MIDDLEWARE] CSRF токен из формы csrf_token: %s\n",
csrfDebugPrint("[CSRF MIDDLEWARE] CSRF токен из формы csrf_token: %s\n",
safeSubstring(csrfTokenFromForm, 0, 50))
csrfToken := csrfTokenFromHeader
@@ -109,7 +115,7 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
}
if csrfToken == "" {
fmt.Printf("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF токен не найден ни в заголовке, ни в форме!\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF токен не найден ни в заголовке, ни в форме!\n")
// Для API запросов возвращаем JSON ошибку
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json")
@@ -123,31 +129,31 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
return
}
fmt.Printf("[CSRF MIDDLEWARE] Используемый CSRF токен (первые 50 символов): %s...\n",
csrfDebugPrint("[CSRF MIDDLEWARE] Используемый CSRF токен (первые 50 символов): %s...\n",
safeSubstring(csrfToken, 0, 50))
// Получаем сессионный ID
sessionID := getSessionID(r)
fmt.Printf("[CSRF MIDDLEWARE] SessionID: %s\n", sessionID)
csrfDebugPrint("[CSRF MIDDLEWARE] SessionID: %s\n", sessionID)
// Получаем CSRF токен из cookie для сравнения
csrfTokenFromCookie := GetCSRFTokenFromCookie(r)
if csrfTokenFromCookie != "" {
fmt.Printf("[CSRF MIDDLEWARE] CSRF токен из cookie (первые 50 символов): %s...\n",
csrfDebugPrint("[CSRF MIDDLEWARE] CSRF токен из cookie (первые 50 символов): %s...\n",
safeSubstring(csrfTokenFromCookie, 0, 50))
if csrfTokenFromCookie != csrfToken {
fmt.Printf("[CSRF MIDDLEWARE] ⚠️ ВНИМАНИЕ: Токен из cookie отличается от токена в запросе!\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️ ВНИМАНИЕ: Токен из cookie отличается от токена в запросе!\n")
} else {
fmt.Printf("[CSRF MIDDLEWARE] ✅ Токен из cookie совпадает с токеном в запросе\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ✅ Токен из cookie совпадает с токеном в запросе\n")
}
} else {
fmt.Printf("[CSRF MIDDLEWARE] ⚠️ ВНИМАНИЕ: CSRF токен не найден в cookie!\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️ ВНИМАНИЕ: CSRF токен не найден в cookie!\n")
}
// Проверяем CSRF токен
csrfManager := GetCSRFManager()
if csrfManager == nil {
fmt.Printf("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF менеджер не инициализирован!\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: CSRF менеджер не инициализирован!\n")
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusForbidden)
@@ -158,12 +164,12 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
return
}
fmt.Printf("[CSRF MIDDLEWARE] Вызов ValidateToken с токеном и sessionID: %s\n", sessionID)
csrfDebugPrint("[CSRF MIDDLEWARE] Вызов ValidateToken с токеном и sessionID: %s\n", sessionID)
valid := csrfManager.ValidateToken(csrfToken, sessionID)
fmt.Printf("[CSRF MIDDLEWARE] Результат ValidateToken: %t\n", valid)
csrfDebugPrint("[CSRF MIDDLEWARE] Результат ValidateToken: %t\n", valid)
if !valid {
fmt.Printf("[CSRF MIDDLEWARE] ❌ ОШИБКА: Валидация CSRF токена не прошла!\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: Валидация CSRF токена не прошла!\n")
// Для API запросов возвращаем JSON ошибку
if isAPIRequest(r) {
w.Header().Set("Content-Type", "application/json")
@@ -177,8 +183,8 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
return
}
fmt.Printf("[CSRF MIDDLEWARE] ✅ CSRF токен валиден, продолжаем обработку запроса\n")
fmt.Printf("[CSRF MIDDLEWARE] ==========================================\n\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ✅ CSRF токен валиден, продолжаем обработку запроса\n")
csrfDebugPrint("[CSRF MIDDLEWARE] ==========================================\n\n")
// CSRF токен валиден, продолжаем
next(w, r)
}