Merge branch 'main' of github.com:Direct-Dev-Ru/go-lcg into main

Dockerfiles/OllamaServer/Dockerfile

@@ -1,6 +1,10 @@
 # Используем готовый образ Ollama
 FROM localhost/ollama_packed:latest
 
+RUN apt-get update && apt-get install -y --no-install-recommends bash && apt-get install -y --no-install-recommends curl \
+&& apt-get install -y --no-install-recommends jq && apt-get install -y --no-install-recommends wget 
+
+
 # Устанавливаем bash если его нет (базовый образ ollama может быть на разных дистрибутивах)
 RUN if ! command -v bash >/dev/null 2>&1; then \
         if command -v apk >/dev/null 2>&1; then \
@@ -72,6 +76,8 @@ ENV LCG_SERVER_HOST=0.0.0.0
 ENV LCG_SERVER_PORT=8080
 ENV LCG_DOMAIN="remote.ollama-server.ru"
 ENV LCG_COOKIE_PATH="/lcg"
+# ENV LCG_FORCE_NO_CSRF=true
+
 # ENV LCG_SERVER_ALLOW_HTTP=true
 # ENV OLLAMA_HOST=127.0.0.1
 # ENV OLLAMA_PORT=11434

Dockerfiles/OllamaServer/Makefile

@@ -52,7 +52,7 @@ run: ## Запустить контейнер (Docker)
 		-v lcg-results:/app/data/results \
 		-v lcg-prompts:/app/data/prompts \
 		-v lcg-config:/app/data/config \
-		${IMAGE_NAME}:${IMAGE_TAG}
+		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
 	@echo "Контейнер ${CONTAINER_NAME} запущен"
 
 run-podman: ## Запустить контейнер (Podman)
@@ -69,7 +69,7 @@ run-podman: ## Запустить контейнер (Podman)
 		-v lcg-results:/app/data/results \
 		-v lcg-prompts:/app/data/prompts \
 		-v lcg-config:/app/data/config \
-		${IMAGE_NAME}:${IMAGE_TAG}
+		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
 	@echo "Контейнер ${CONTAINER_NAME} запущен"
 
 run-podman-nodemon: ## Запустить контейнер (Podman) без -d
@@ -86,7 +86,7 @@ run-podman-nodemon: ## Запустить контейнер (Podman) без -d
 		-v lcg-results:/app/data/results \
 		-v lcg-prompts:/app/data/prompts \
 		-v lcg-config:/app/data/config \
-		${IMAGE_NAME}:${IMAGE_TAG}
+		${IMAGE_NAME}:${IMAGE_TAG} ollama serve
 	@echo "Контейнер ${CONTAINER_NAME} запущен"
 
 stop: ## Остановить контейнер (Docker)

Dockerfiles/OllamaServer/entrypoint.sh

@@ -65,6 +65,12 @@ 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:-false}"
+export LCG_CSRF_DEBUG_FILE="${LCG_CSRF_DEBUG_FILE:-/app/data/csrf-debug.log}"
+
+if [ "$LCG_FORCE_NO_CSRF" = "true" ]; then
+    info "CSRF проверка отключена через LCG_FORCE_NO_CSRF"
+fi
 
 log "=========================================="
 log "Запуск LCG с Ollama сервером"

VERSION.txt

@@ -1 +1 @@
-v.2.0.20
+v2.0.28

config/config.go

@@ -27,6 +27,7 @@ type Config struct {
 	ResultHistory  string
 	NoHistoryEnv   string
 	AllowExecution bool
+	Think          bool
 	Query          string
 	MainFlags      MainFlags
 	Server         ServerConfig
@@ -58,6 +59,7 @@ type ServerConfig struct {
 	CookieSecure   bool
 	CookiePath     string
 	CookieTTLHours int
+	ForceNoCSRF    bool
 }
 
 type ValidationConfig struct {
@@ -166,6 +168,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 +217,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() {

deploy/VERSION.txt

@@ -1 +1 @@
-v.2.0.20
+v2.0.28

gpt/gpt.go

@@ -44,11 +44,19 @@ type Chat struct {
 
 type Gpt3Request struct {
 	Model    string      `json:"model"`
-	Stream   bool        `json:"stream"`
+	Stream   bool        `json:"stream"`	
 	Messages []Chat      `json:"messages"`
 	Options  Gpt3Options `json:"options"`
 }
 
+type Gpt3ThinkRequest struct {
+	Model  string `json:"model"`
+	Stream bool   `json:"stream"`
+	Think  bool   `json:"think"`
+	Messages []Chat `json:"messages"`
+	Options  Gpt3Options `json:"options"`
+}
+
 type Gpt3Options struct {
 	Temperature float64 `json:"temperature"`
 }

gpt/providers.go

@@ -200,12 +200,26 @@ func (p *ProxyAPIProvider) Health() error {
 
 // Chat для OllamaProvider
 func (o *OllamaProvider) Chat(messages []Chat) (string, error) {
-	payload := Gpt3Request{
+
+	think := config.AppConfig.Think
+	
+	var payload interface{}
+	if think {
+	payload = Gpt3Request{
 		Model:    o.Model,
 		Messages: messages,
-		Stream:   false,
+		Stream:   false,		
 		Options:  Gpt3Options{o.Temperature},
 	}
+	} else {
+		payload = Gpt3ThinkRequest{
+			Model:    o.Model,
+			Messages: messages,
+			Stream:   false,
+			Think:    false,
+			Options:  Gpt3Options{o.Temperature},
+		}
+	}
 
 	jsonData, err := json.Marshal(payload)
 	if err != nil {

kustomize/configmap.yaml

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

kustomize/deployment.yaml

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

kustomize/kustomization.yaml

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

main.go

@@ -109,6 +109,7 @@ lcg [опции] <описание команды>
   LCG_PROXY_URL           URL прокси для proxy провайдера (по умолчанию: /api/v1/protected/sberchat/chat)
   LCG_API_KEY_FILE        Файл с API ключом (по умолчанию: .openai_api_key)
   LCG_APP_NAME            Название приложения (по умолчанию: Linux Command GPT)
+  LCG_ALLOW_THINK         только для ollama: разрешить модели отправлять свои размышления ("1" или "true" = разрешено, пусто = запрещено). Имеет смысл для моделей, которые поддерживают эти действия: qwen3, deepseek.  
 
 Настройки истории и выполнения:
   LCG_NO_HISTORY          Отключить запись истории ("1" или "true" = отключено, пусто = включено)
@@ -163,12 +164,18 @@ lcg [опции] <описание команды>
 				Usage:   "Disable writing/updating command history (overrides LCG_NO_HISTORY)",
 				Value:   false,
 			},
+			&cli.BoolFlag{
+				Name:        "think",
+				Aliases:     []string{"T"},
+				Usage:       "Разрешить модели отправлять свои размышления",
+				Value:       false,				
+			},
 			&cli.StringFlag{
 				Name:        "query",
 				Aliases:     []string{"Q"},
 				Usage:       "Query to send to the model",
-				DefaultText: "Hello? what day is it today?",
-				Value:       "Hello? what day is it today?",
+				DefaultText: "Привет! Порадуй меня случайной Linux командой ...",
+				Value:       "Привет! Порадуй меня случайной Linux командой ...",
 			},
 			&cli.StringFlag{
 				Name:        "sys",
@@ -216,7 +223,10 @@ lcg [опции] <описание команды>
 			if c.IsSet("model") {
 				config.AppConfig.Model = model
 			}
-
+			config.AppConfig.Think = false
+			if c.IsSet("think") {
+				config.AppConfig.Think = c.Bool("think")
+			}
 			promptID := c.Int("prompt-id")
 			timeout := c.Int("timeout")
 
@@ -1018,7 +1028,7 @@ func printDebugInfo(file, system, commandInput string, timeout int) {
 	fmt.Printf("📁 Файл: %s\n", file)
 	fmt.Printf("🤖 Системный промпт: %s\n", system)
 	fmt.Printf("💬 Запрос: %s\n", commandInput)
-	fmt.Printf("⏱️  Таймаут: %d сек\n", timeout)
+	fmt.Printf("⏱️ Таймаут: %d сек\n", timeout)
 	fmt.Printf("🌐 Провайдер: %s\n", config.AppConfig.ProviderType)
 	fmt.Printf("🏠 Хост: %s\n", config.AppConfig.Host)
 	fmt.Printf("🧠 Модель: %s\n", config.AppConfig.Model)

serve/csrf.go

@@ -8,6 +8,8 @@ import (
 	"fmt"
 	"net/http"
 	"os"
+	"path/filepath"
+	"sync"
 	"time"
 
 	"github.com/direct-dev-ru/linux-command-gpt/config"
@@ -20,6 +22,75 @@ const (
 	CSRFTokenLifetimeSeconds = CSRFTokenLifetimeHours * 60 * 60
 )
 
+var (
+	// csrfDebugFile файл для отладочного вывода CSRF
+	csrfDebugFile *os.File
+	// csrfDebugFileMutex мьютекс для безопасной записи в файл
+	csrfDebugFileMutex sync.Mutex
+)
+
+// initCSRFDebugFile инициализирует файл для отладочного вывода CSRF
+func initCSRFDebugFile() error {
+	debugFile := os.Getenv("LCG_CSRF_DEBUG_FILE")
+	if debugFile == "" {
+		return nil // Файл не указан, ничего не делаем
+	}
+
+	// Создаем директорию для файла, если нужно
+	dir := filepath.Dir(debugFile)
+	if dir != "." && dir != "" {
+		if err := os.MkdirAll(dir, 0755); err != nil {
+			return fmt.Errorf("failed to create directory for CSRF debug file %s: %v", dir, err)
+		}
+	}
+
+	// Создаем/перезаписываем файл
+	file, err := os.Create(debugFile)
+	if err != nil {
+		return fmt.Errorf("failed to create CSRF debug file %s: %v", debugFile, err)
+	}
+
+	csrfDebugFileMutex.Lock()
+	// Закрываем старый файл, если был открыт
+	if csrfDebugFile != nil {
+		csrfDebugFile.Close()
+	}
+	csrfDebugFile = file
+	csrfDebugFileMutex.Unlock()
+
+	// Записываем заголовок
+	header := fmt.Sprintf("=== CSRF Debug Log Started at %s ===\n", time.Now().Format(time.RFC3339))
+	if _, err := csrfDebugFile.WriteString(header); err != nil {
+		return fmt.Errorf("failed to write header to CSRF debug file: %v", err)
+	}
+	if err := csrfDebugFile.Sync(); err != nil {
+		return fmt.Errorf("failed to sync CSRF debug file: %v", err)
+	}
+
+	return nil
+}
+
+// csrfDebugPrint выводит отладочную информацию
+// Если установлен LCG_CSRF_DEBUG_FILE - всегда пишет в файл (независимо от debug режима)
+// Если включен debug режим - также пишет в консоль
+func csrfDebugPrint(format string, args ...any) {
+	message := fmt.Sprintf(format, args...)
+
+	// Записываем в файл, если он установлен
+	csrfDebugFileMutex.Lock()
+	if csrfDebugFile != nil {
+		csrfDebugFile.WriteString(message)
+		// Синхронизируем сразу для отладки (может быть медленно, но гарантирует запись)
+		csrfDebugFile.Sync()
+	}
+	csrfDebugFileMutex.Unlock()
+
+	// Записываем в консоль, если включен debug режим
+	if config.AppConfig.MainFlags.Debug {
+		fmt.Print(message)
+	}
+}
+
 // CSRFManager управляет CSRF токенами
 type CSRFManager struct {
 	secretKey []byte
@@ -75,7 +146,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 +155,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 +246,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 +288,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 +309,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)
 }
 
@@ -329,6 +400,11 @@ var csrfManager *CSRFManager
 
 // InitCSRFManager инициализирует глобальный CSRF менеджер
 func InitCSRFManager() error {
+	// Инициализируем файл для отладки CSRF, если указан LCG_CSRF_DEBUG_FILE
+	if err := initCSRFDebugFile(); err != nil {
+		return fmt.Errorf("failed to initialize CSRF debug file: %v", err)
+	}
+
 	var err error
 	csrfManager, err = NewCSRFManager()
 	return err

serve/login.go

@@ -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
 }

serve/middleware.go

@@ -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,51 @@ 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)
+		valid := true
 		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")
+				valid = false
 			} else {
-				fmt.Printf("[CSRF MIDDLEWARE] ✅ Токен из cookie совпадает с токеном в запросе\n")
+				csrfDebugPrint("[CSRF MIDDLEWARE] ✅ Токен из cookie совпадает с токеном в запросе\n")
+				valid = true
 			}
 		} else {
-			fmt.Printf("[CSRF MIDDLEWARE] ⚠️  ВНИМАНИЕ: CSRF токен не найден в cookie!\n")
+			csrfDebugPrint("[CSRF MIDDLEWARE] ⚠️  ВНИМАНИЕ: CSRF токен не найден в cookie!\n")
+			valid = false
 		}
 
 		// Проверяем CSRF токен
+
+		if !valid {
+			csrfDebugPrint("[CSRF MIDDLEWARE] ❌ ОШИБКА: Валидация CSRF токена не прошла!\n")
+			// Для API запросов возвращаем JSON ошибку
+			if isAPIRequest(r) {
+				w.Header().Set("Content-Type", "application/json")
+				w.WriteHeader(http.StatusForbidden)
+				w.Write([]byte(`{"success": false, "error": "Invalid CSRF token"}`))
+				return
+			}
+
+			// Для веб-запросов возвращаем ошибку
+			http.Error(w, "Invalid OR Empty CSRF token", http.StatusForbidden)
+			return
+		}
+
 		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 +184,12 @@ func CSRFMiddleware(next http.HandlerFunc) http.HandlerFunc {
 			return
 		}
 
-		fmt.Printf("[CSRF MIDDLEWARE] Вызов ValidateToken с токеном и sessionID: %s\n", sessionID)
-		valid := csrfManager.ValidateToken(csrfToken, sessionID)
-		fmt.Printf("[CSRF MIDDLEWARE] Результат ValidateToken: %t\n", valid)
+		csrfDebugPrint("[CSRF MIDDLEWARE] Вызов ValidateToken с токеном и sessionID: %s\n", sessionID)
+		valid = csrfManager.ValidateToken(csrfToken, sessionID)
+		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 +203,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)
 	}