2PC released

internal/api/rate_limiter.go

@@ -0,0 +1,204 @@
+/*
+ * Copyright 2026 Safronov Grigorii
+ *
+ * Licensed under the CDDL, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ *
+ * You may obtain a copy of the License at
+ * https://opensource.org/licenses/CDDL-1.0
+ */
+
+// Файл: internal/api/rate_limiter.go (НОВЫЙ ФАЙЛ)
+// Назначение: Rate limiting для API
+
+package api
+
+import (
+    "fmt"
+    "net/http"
+    "sync"
+    "sync/atomic"
+    "time"
+)
+
+// RateLimiterConfig содержит конфигурацию rate limiter'а
+type RateLimiterConfig struct {
+    RequestsPerSecond int
+    BurstSize         int
+    CleanupInterval   time.Duration
+    MaxEntries        int
+}
+
+// DefaultRateLimiterConfig возвращает конфигурацию по умолчанию
+func DefaultRateLimiterConfig() *RateLimiterConfig {
+    return &RateLimiterConfig{
+        RequestsPerSecond: 100,
+        BurstSize:         20,
+        CleanupInterval:   5 * time.Minute,
+        MaxEntries:        10000,
+    }
+}
+
+// TokenBucket реализует алгоритм token bucket
+type TokenBucket struct {
+    tokens        float64
+    maxTokens     float64
+    refillRate    float64
+    lastRefill    time.Time
+    mu            sync.Mutex
+}
+
+// NewTokenBucket создаёт новый token bucket
+func NewTokenBucket(ratePerSecond float64, burst int) *TokenBucket {
+    return &TokenBucket{
+        tokens:     float64(burst),
+        maxTokens:  float64(burst),
+        refillRate: ratePerSecond,
+        lastRefill: time.Now(),
+    }
+}
+
+// Allow проверяет, разрешён ли запрос
+func (tb *TokenBucket) Allow() bool {
+    tb.mu.Lock()
+    defer tb.mu.Unlock()
+    
+    now := time.Now()
+    elapsed := now.Sub(tb.lastRefill).Seconds()
+    tb.tokens += elapsed * tb.refillRate
+    if tb.tokens > tb.maxTokens {
+        tb.tokens = tb.maxTokens
+    }
+    tb.lastRefill = now
+    
+    if tb.tokens >= 1.0 {
+        tb.tokens -= 1.0
+        return true
+    }
+    return false
+}
+
+// RateLimiter управляет rate limiting для API
+type RateLimiter struct {
+    config      *RateLimiterConfig
+    limiters    sync.Map
+    rejected    atomic.Uint64
+    allowed     atomic.Uint64
+    stopChan    chan struct{}
+    wg          sync.WaitGroup
+}
+
+// NewRateLimiter создаёт новый rate limiter
+func NewRateLimiter(config *RateLimiterConfig) *RateLimiter {
+    if config == nil {
+        config = DefaultRateLimiterConfig()
+    }
+    
+    rl := &RateLimiter{
+        config:   config,
+        stopChan: make(chan struct{}),
+    }
+    
+    rl.wg.Add(1)
+    go rl.cleanupLoop()
+    
+    return rl
+}
+
+// getLimiter возвращает или создаёт лимитер для ключа
+func (rl *RateLimiter) getLimiter(key string) *TokenBucket {
+    if val, ok := rl.limiters.Load(key); ok {
+        return val.(*TokenBucket)
+    }
+    
+    limiter := NewTokenBucket(float64(rl.config.RequestsPerSecond), rl.config.BurstSize)
+    actual, _ := rl.limiters.LoadOrStore(key, limiter)
+    return actual.(*TokenBucket)
+}
+
+// Allow проверяет, разрешён ли запрос для ключа
+func (rl *RateLimiter) Allow(key string) bool {
+    limiter := rl.getLimiter(key)
+    allowed := limiter.Allow()
+    
+    if allowed {
+        rl.allowed.Add(1)
+    } else {
+        rl.rejected.Add(1)
+    }
+    
+    return allowed
+}
+
+// Middleware возвращает middleware для HTTP
+func (rl *RateLimiter) Middleware(next http.HandlerFunc) http.HandlerFunc {
+    return func(w http.ResponseWriter, r *http.Request) {
+        // Используем IP + User-Agent как ключ
+        key := r.RemoteAddr
+        if forwarded := r.Header.Get("X-Forwarded-For"); forwarded != "" {
+            key = forwarded
+        }
+        
+        if !rl.Allow(key) {
+            w.Header().Set("X-RateLimit-Limit", fmt.Sprintf("%d", rl.config.RequestsPerSecond))
+            w.Header().Set("X-RateLimit-Remaining", "0")
+            w.Header().Set("Retry-After", "1")
+            http.Error(w, "Rate limit exceeded. Please try again later.", http.StatusTooManyRequests)
+            return
+        }
+        
+        next(w, r)
+    }
+}
+
+// cleanupLoop периодически очищает старые лимитеры
+func (rl *RateLimiter) cleanupLoop() {
+    defer rl.wg.Done()
+    
+    ticker := time.NewTicker(rl.config.CleanupInterval)
+    defer ticker.Stop()
+    
+    for {
+        select {
+        case <-ticker.C:
+            rl.cleanup()
+        case <-rl.stopChan:
+            return
+        }
+    }
+}
+
+// cleanup удаляет старые лимитеры
+func (rl *RateLimiter) cleanup() {
+    count := 0
+    rl.limiters.Range(func(key, value interface{}) bool {
+        count++
+        if count > rl.config.MaxEntries {
+            rl.limiters.Delete(key)
+        }
+        return true
+    })
+}
+
+// GetStats возвращает статистику rate limiter'а
+func (rl *RateLimiter) GetStats() map[string]interface{} {
+    count := 0
+    rl.limiters.Range(func(key, value interface{}) bool {
+        count++
+        return true
+    })
+    
+    return map[string]interface{}{
+        "active_limiters": count,
+        "allowed_requests": rl.allowed.Load(),
+        "rejected_requests": rl.rejected.Load(),
+        "requests_per_second": rl.config.RequestsPerSecond,
+        "burst_size": rl.config.BurstSize,
+    }
+}
+
+// Stop останавливает rate limiter
+func (rl *RateLimiter) Stop() {
+    close(rl.stopChan)
+    rl.wg.Wait()
+}

internal/api/webui_credentials.go

@@ -0,0 +1,425 @@
+/*
+ * Copyright 2026 Safronov Grigorii
+ *
+ * Licensed under the CDDL, Version 1.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ *
+ * You may obtain a copy of the License at
+ * https://opensource.org/licenses/CDDL-1.0
+ */
+
+// Файл: internal/api/webui_credentials.go
+// Назначение: Управление учётными данными для веб-интерфейса
+// Хранит логин/пароль в скрытом файле .credentials в директории futriis
+// Поддерживает множественных пользователей-администраторов
+
+package api
+
+import (
+    "crypto/sha256"
+    "encoding/base64"
+    "encoding/json"
+    "fmt"
+    "os"
+    "path/filepath"
+    "sync"
+    "time"
+)
+
+// UserCredential представляет учётные данные одного пользователя
+type UserCredential struct {
+    Password  string `json:"password"`           // хранится в виде хеша
+    Avatar    string `json:"avatar,omitempty"`   // base64 encoded avatar
+    IsAdmin   bool   `json:"is_admin"`           // является ли администратором
+    CreatedAt int64  `json:"created_at"`         // время создания
+    LastLogin int64  `json:"last_login,omitempty"` // время последнего входа
+}
+
+// Credentials структура для хранения всех учётных данных
+type Credentials struct {
+    Users    map[string]*UserCredential `json:"users"`
+    Settings map[string]interface{}     `json:"settings,omitempty"`
+}
+
+// CredentialManager управляет учётными данными веб-интерфейса
+type CredentialManager struct {
+    mu          sync.RWMutex
+    credentials *Credentials
+    credFile    string
+    currentUser string
+}
+
+// NewCredentialManager создаёт новый менеджер учётных данных
+func NewCredentialManager() *CredentialManager {
+    // Определяем путь к директории futriis
+    execPath, err := os.Executable()
+    if err != nil {
+        execPath = "."
+    }
+    futriisDir := filepath.Dir(execPath)
+    
+    // Ищем директорию futriis (поднимаемся вверх, если нужно)
+    for {
+        if _, err := os.Stat(filepath.Join(futriisDir, "futriis")); err == nil {
+            futriisDir = filepath.Join(futriisDir, "futriis")
+            break
+        }
+        parent := filepath.Dir(futriisDir)
+        if parent == futriisDir {
+            // Не нашли директорию futriis, создаём в текущей
+            futriisDir = filepath.Join(execPath, "futriis")
+            os.MkdirAll(futriisDir, 0700)
+            break
+        }
+        futriisDir = parent
+    }
+    
+    credFile := filepath.Join(futriisDir, ".credentials")
+    
+    return &CredentialManager{
+        credentials: &Credentials{
+            Users:    make(map[string]*UserCredential),
+            Settings: make(map[string]interface{}),
+        },
+        credFile: credFile,
+    }
+}
+
+// hashPassword создаёт хеш пароля
+func (cm *CredentialManager) hashPassword(password string) string {
+    hash := sha256.Sum256([]byte(password))
+    return base64.StdEncoding.EncodeToString(hash[:])
+}
+
+// Load загружает учётные данные из файла
+func (cm *CredentialManager) Load() error {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    data, err := os.ReadFile(cm.credFile)
+    if err != nil {
+        if os.IsNotExist(err) {
+            return cm.createDefaultFile()
+        }
+        return err
+    }
+    
+    var creds Credentials
+    if err := json.Unmarshal(data, &creds); err != nil {
+        return err
+    }
+    
+    cm.credentials = &creds
+    if cm.credentials.Users == nil {
+        cm.credentials.Users = make(map[string]*UserCredential)
+    }
+    if cm.credentials.Settings == nil {
+        cm.credentials.Settings = make(map[string]interface{})
+    }
+    
+    return nil
+}
+
+// createDefaultFile создаёт файл с учётными данными по умолчанию
+func (cm *CredentialManager) createDefaultFile() error {
+    // Создаём пользователя admin по умолчанию
+    cm.credentials.Users["admin"] = &UserCredential{
+        Password:  cm.hashPassword("admin"),
+        IsAdmin:   true,
+        CreatedAt: time.Now().Unix(),
+    }
+    cm.credentials.Settings["version"] = "1.0"
+    
+    return cm.save()
+}
+
+// CreateDefault создаёт учётные данные по умолчанию (если файл не существует)
+func (cm *CredentialManager) CreateDefault() error {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    // Проверяем, существует ли файл
+    if _, err := os.Stat(cm.credFile); err == nil {
+        return nil // файл уже существует
+    }
+    
+    cm.credentials.Users["admin"] = &UserCredential{
+        Password:  cm.hashPassword("admin"),
+        IsAdmin:   true,
+        CreatedAt: time.Now().Unix(),
+    }
+    cm.credentials.Settings["version"] = "1.0"
+    
+    return cm.save()
+}
+
+// save сохраняет учётные данные в файл
+func (cm *CredentialManager) save() error {
+    data, err := json.MarshalIndent(cm.credentials, "", "  ")
+    if err != nil {
+        return err
+    }
+    
+    // Устанавливаем права доступа 0600 (только владелец может читать/писать)
+    return os.WriteFile(cm.credFile, data, 0600)
+}
+
+// Validate проверяет учётные данные
+func (cm *CredentialManager) Validate(username, password string) bool {
+    cm.mu.RLock()
+    defer cm.mu.RUnlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return false
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return false
+    }
+    
+    return user.Password == cm.hashPassword(password)
+}
+
+// IsAdmin проверяет, является ли пользователь администратором
+func (cm *CredentialManager) IsAdmin(username string) bool {
+    cm.mu.RLock()
+    defer cm.mu.RUnlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return false
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return false
+    }
+    
+    return user.IsAdmin
+}
+
+// CreateUser создаёт нового пользователя (только для администраторов)
+func (cm *CredentialManager) CreateUser(username, password string, isAdmin bool) error {
+    if username == "" {
+        return fmt.Errorf("username cannot be empty")
+    }
+    
+    if len(password) < 4 {
+        return fmt.Errorf("password must be at least 4 characters")
+    }
+    
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil {
+        cm.credentials = &Credentials{
+            Users:    make(map[string]*UserCredential),
+            Settings: make(map[string]interface{}),
+        }
+    }
+    
+    if _, exists := cm.credentials.Users[username]; exists {
+        return fmt.Errorf("user %s already exists", username)
+    }
+    
+    cm.credentials.Users[username] = &UserCredential{
+        Password:  cm.hashPassword(password),
+        IsAdmin:   isAdmin,
+        CreatedAt: time.Now().Unix(),
+    }
+    
+    return cm.save()
+}
+
+// DeleteUser удаляет пользователя (только для администраторов)
+func (cm *CredentialManager) DeleteUser(username string) error {
+    if username == "admin" {
+        return fmt.Errorf("cannot delete default admin user")
+    }
+    
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return fmt.Errorf("no users found")
+    }
+    
+    if _, exists := cm.credentials.Users[username]; !exists {
+        return fmt.Errorf("user %s not found", username)
+    }
+    
+    delete(cm.credentials.Users, username)
+    return cm.save()
+}
+
+// ListUsers возвращает список всех пользователей (только для администраторов)
+func (cm *CredentialManager) ListUsers() []map[string]interface{} {
+    cm.mu.RLock()
+    defer cm.mu.RUnlock()
+    
+    users := make([]map[string]interface{}, 0)
+    
+    for username, user := range cm.credentials.Users {
+        users = append(users, map[string]interface{}{
+            "username":   username,
+            "is_admin":   user.IsAdmin,
+            "created_at": user.CreatedAt,
+            "last_login": user.LastLogin,
+            "has_avatar": user.Avatar != "",
+        })
+    }
+    
+    return users
+}
+
+// ChangePassword изменяет пароль пользователя
+func (cm *CredentialManager) ChangePassword(username, currentPassword, newPassword string) error {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return fmt.Errorf("credentials not loaded")
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return fmt.Errorf("user not found")
+    }
+    
+    if user.Password != cm.hashPassword(currentPassword) {
+        return fmt.Errorf("current password is incorrect")
+    }
+    
+    if len(newPassword) < 4 {
+        return fmt.Errorf("new password must be at least 4 characters")
+    }
+    
+    user.Password = cm.hashPassword(newPassword)
+    
+    return cm.save()
+}
+
+// AdminChangePassword изменяет пароль пользователя (без проверки старого, только для админов)
+func (cm *CredentialManager) AdminChangePassword(username, newPassword string) error {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return fmt.Errorf("credentials not loaded")
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return fmt.Errorf("user not found")
+    }
+    
+    if len(newPassword) < 4 {
+        return fmt.Errorf("password must be at least 4 characters")
+    }
+    
+    user.Password = cm.hashPassword(newPassword)
+    
+    return cm.save()
+}
+
+// SetAvatar устанавливает аватар для пользователя
+func (cm *CredentialManager) SetAvatar(username, avatarBase64 string) error {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return fmt.Errorf("credentials not loaded")
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return fmt.Errorf("user not found")
+    }
+    
+    user.Avatar = avatarBase64
+    
+    return cm.save()
+}
+
+// GetAvatar возвращает аватар пользователя
+func (cm *CredentialManager) GetAvatar(username string) (string, error) {
+    cm.mu.RLock()
+    defer cm.mu.RUnlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return "", fmt.Errorf("credentials not loaded")
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return "", fmt.Errorf("user not found")
+    }
+    
+    return user.Avatar, nil
+}
+
+// DeleteAvatar удаляет аватар пользователя
+func (cm *CredentialManager) DeleteAvatar(username string) error {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return fmt.Errorf("credentials not loaded")
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return fmt.Errorf("user not found")
+    }
+    
+    user.Avatar = ""
+    
+    return cm.save()
+}
+
+// UpdateLastLogin обновляет время последнего входа пользователя
+func (cm *CredentialManager) UpdateLastLogin(username string) {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    
+    if cm.credentials == nil || cm.credentials.Users == nil {
+        return
+    }
+    
+    user, exists := cm.credentials.Users[username]
+    if !exists {
+        return
+    }
+    
+    user.LastLogin = time.Now().Unix()
+    cm.save() // игнорируем ошибку, т.к. это не критично
+}
+
+// GetCurrentUsername возвращает имя текущего пользователя
+func (cm *CredentialManager) GetCurrentUsername() string {
+    cm.mu.RLock()
+    defer cm.mu.RUnlock()
+    
+    if cm.credentials == nil {
+        return ""
+    }
+    
+    // Возвращаем последнего вошедшего пользователя или admin по умолчанию
+    if cm.currentUser != "" {
+        return cm.currentUser
+    }
+    
+    return "admin"
+}
+
+// SetCurrentUsername устанавливает имя текущего пользователя
+func (cm *CredentialManager) SetCurrentUsername(username string) {
+    cm.mu.Lock()
+    defer cm.mu.Unlock()
+    cm.currentUser = username
+}
+
+// GetCredentialsFile возвращает путь к файлу с учётными данными
+func (cm *CredentialManager) GetCredentialsFile() string {
+    return cm.credFile
+}