Как работать с куки в ASP.NET Core

// Через IHttpContextAccessor
string cookieValue = _httpContextAccessor.HttpContext.Request.Cookies["key"];
 
// Напрямую через Request в контроллере
string anotherCookieValue = Request.Cookies["anotherKey"];

Response.Cookies.Append("myKey", "myValue");

// Записать куки с основными параметрами
Response.Cookies.Append(key, value, options);
 
// Удалить куки
Response.Cookies.Delete(key);
 
// Удалить куки с дополнительными опциями
Response.Cookies.Delete(key, options);

CookieOptions options = new CookieOptions
{
    Domain = ".example.com",  // Домен куки
    Path = "/",               // Путь
    Expires = DateTime.Now.AddDays(1), // Срок действия
    HttpOnly = true,          // Недоступность для JavaScript
    Secure = true,            // Только по HTTPS
    SameSite = SameSiteMode.Strict // Защита от CSRF
};

// Примерный код из исходников ASP.NET Core (упрощен)
public class ResponseCookies : IResponseCookies
{
    private readonly IHeaderDictionary _headers;
    private readonly ICookieFactory _cookieFactory;
    
    public void Append(string key, string value, CookieOptions options)
    {
        var cookieValue = _cookieFactory.CreateCookieHeader(key, value, options);
        _headers.Append("Set-Cookie", cookieValue);
    }
    
    // Остальные методы
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddHttpContextAccessor();
    // Остальные сервисы
}

public class MyCookieService
{
    private readonly IHttpContextAccessor _contextAccessor;
    
    public MyCookieService(IHttpContextAccessor contextAccessor)
    {
        _contextAccessor = contextAccessor;
    }
    
    public string GetCookie(string key)
    {
        return _contextAccessor.HttpContext?.Request.Cookies[key];
    }
}

var cookieValues = Request.Headers["Cookie"]
    .SelectMany(header => header.Split(';'))
    .Where(cookie => cookie.TrimStart().StartsWith("myKey="))
    .Select(cookie => cookie.Split('=')[1]);

public void Configure(IApplicationBuilder app)
{
    // Этот middleware выполнится первым при запросе
    // и последним при ответе
    app.UseMiddleware<MyCookieMiddleware>();
    
    // Этот middleware выполнится после MyCookieMiddleware при запросе
    // и перед ним при ответе
    app.UseAuthentication();
    
    // Остальные middleware
}

public void SetObjectInCookie<T>(string key, T value, CookieOptions options = null)
{
    string serializedValue = JsonSerializer.Serialize(value);
    Response.Cookies.Append(key, serializedValue, options ?? new CookieOptions());
}
 
public T GetObjectFromCookie<T>(string key)
{
    string value = Request.Cookies[key];
    return value == null ? default : JsonSerializer.Deserialize<T>(value);
}

public void SetBase64InCookie<T>(string key, T value, CookieOptions options = null)
{
    var json = JsonSerializer.Serialize(value);
    var bytes = Encoding.UTF8.GetBytes(json);
    var base64 = Convert.ToBase64String(bytes);
    Response.Cookies.Append(key, base64, options ?? new CookieOptions());
}
 
public T GetBase64FromCookie<T>(string key)
{
    var base64 = Request.Cookies[key];
    if (string.IsNullOrEmpty(base64))
        return default;
        
    var bytes = Convert.FromBase64String(base64);
    var json = Encoding.UTF8.GetString(bytes);
    return JsonSerializer.Deserialize<T>(json);
}

public void SetMessagePackInCookie<T>(string key, T value, CookieOptions options = null)
{
    byte[] bytes = MessagePackSerializer.Serialize(value);
    string base64 = Convert.ToBase64String(bytes);
    Response.Cookies.Append(key, base64, options ?? new CookieOptions());
}
 
public T GetMessagePackFromCookie<T>(string key)
{
    string base64 = Request.Cookies[key];
    if (string.IsNullOrEmpty(base64))
        return default;
        
    byte[] bytes = Convert.FromBase64String(base64);
    return MessagePackSerializer.Deserialize<T>(bytes);
}

public void SetLargeObjectInCookies<T>(string keyPrefix, T value, int maxChunkSize = 3500)
{
    string json = JsonSerializer.Serialize(value);
    int chunksCount = (int)Math.Ceiling((double)json.Length / maxChunkSize);
    
    for (int i = 0; i < chunksCount; i++)
    {
        int startIndex = i * maxChunkSize;
        int length = Math.Min(maxChunkSize, json.Length - startIndex);
        string chunk = json.Substring(startIndex, length);
        
        Response.Cookies.Append($"{keyPrefix}_{i}", chunk, new CookieOptions
        {
            Expires = DateTime.Now.AddHours(1)
        });
    }
    
    // Сохраняем количество чанков в отдельной куки
    Response.Cookies.Append($"{keyPrefix}_count", chunksCount.ToString(), new CookieOptions
    {
        Expires = DateTime.Now.AddHours(1)
    });
}
 
public T GetLargeObjectFromCookies<T>(string keyPrefix)
{
    if (!Request.Cookies.TryGetValue($"{keyPrefix}_count", out string countStr) ||
        !int.TryParse(countStr, out int count))
        return default;
        
    StringBuilder jsonBuilder = new StringBuilder();
    
    for (int i = 0; i < count; i++)
    {
        if (!Request.Cookies.TryGetValue($"{keyPrefix}_{i}", out string chunk))
            return default;
            
        jsonBuilder.Append(chunk);
    }
    
    return JsonSerializer.Deserialize<T>(jsonBuilder.ToString());
}

public interface ICookieRepository
{
    void Set<T>(string key, T value, TimeSpan? expiration = null);
    T Get<T>(string key);
    void Remove(string key);
    bool Exists(string key);
}
 
public class CookieRepository : ICookieRepository
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    
    public CookieRepository(IHttpContextAccessor httpContextAccessor)
    {
        _httpContextAccessor = httpContextAccessor;
    }
    
    public void Set<T>(string key, T value, TimeSpan? expiration = null)
    {
        CookieOptions options = new CookieOptions();
        
        if (expiration.HasValue)
            options.Expires = DateTime.Now.Add(expiration.Value);
            
        string serializedValue = JsonSerializer.Serialize(value);
        _httpContextAccessor.HttpContext.Response.Cookies.Append(key, serializedValue, options);
    }
    
    public T Get<T>(string key)
    {
        string value = _httpContextAccessor.HttpContext.Request.Cookies[key];
        
        if (string.IsNullOrEmpty(value))
            return default;
            
        return JsonSerializer.Deserialize<T>(value);
    }
    
    public void Remove(string key)
    {
        _httpContextAccessor.HttpContext.Response.Cookies.Delete(key);
    }
    
    public bool Exists(string key)
    {
        return _httpContextAccessor.HttpContext.Request.Cookies.ContainsKey(key);
    }
}

services.AddSingleton<ICookieRepository, CookieRepository>();

public class UserService
{
    private readonly ICookieRepository _cookieRepository;
    
    public UserService(ICookieRepository cookieRepository)
    {
        _cookieRepository = cookieRepository;
    }
    
    public void SaveUserPreferences(UserPreferences preferences)
    {
        _cookieRepository.Set("user_preferences", preferences, TimeSpan.FromDays(30));
    }
    
    public UserPreferences GetUserPreferences()
    {
        return _cookieRepository.Get<UserPreferences>("user_preferences") ?? new UserPreferences();
    }
}

public string SignData(string data, string secretKey)
{
    using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey)))
    {
        byte[] dataBytes = Encoding.UTF8.GetBytes(data);
        byte[] hashBytes = hmac.ComputeHash(dataBytes);
        string hash = Convert.ToBase64String(hashBytes);
        return $"{data}.{hash}";
    }
}
 
public bool VerifySignedData(string signedData, string secretKey)
{
    var parts = signedData.Split('.');
    if (parts.Length != 2)
        return false;
        
    string data = parts[0];
    string providedHash = parts[1];
    
    using (var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(secretKey)))
    {
        byte[] dataBytes = Encoding.UTF8.GetBytes(data);
        byte[] computedHashBytes = hmac.ComputeHash(dataBytes);
        string computedHash = Convert.ToBase64String(computedHashBytes);
        
        return providedHash == computedHash;
    }
}

public string CompressAndEncode(string input)
{
    if (string.IsNullOrEmpty(input))
        return input;
 
    using (var memoryStream = new MemoryStream())
    {
        using (var gzipStream = new GZipStream(memoryStream, CompressionLevel.Optimal))
        {
            using (var writer = new StreamWriter(gzipStream))
            {
                writer.Write(input);
            }
        }
        
        return Convert.ToBase64String(memoryStream.ToArray());
    }
}
 
public string DecodeAndDecompress(string compressedInput)
{
    if (string.IsNullOrEmpty(compressedInput))
        return compressedInput;
        
    byte[] bytes = Convert.FromBase64String(compressedInput);
    
    using (var memoryStream = new MemoryStream(bytes))
    {
        using (var gzipStream = new GZipStream(memoryStream, CompressionMode.Decompress))
        {
            using (var reader = new StreamReader(gzipStream))
            {
                return reader.ReadToEnd();
            }
        }
    }
}

public void SetVersionedObject<T>(string key, T value, int version, CookieOptions options = null)
{
    var wrapper = new VersionedObject<T>
    {
        Version = version,
        Data = value
    };
    
    string json = JsonSerializer.Serialize(wrapper);
    Response.Cookies.Append(key, json, options ?? new CookieOptions());
}
 
public T GetVersionedObject<T>(string key, int currentVersion)
{
    string json = Request.Cookies[key];
    if (string.IsNullOrEmpty(json))
        return default;
        
    VersionedObject<T> wrapper = JsonSerializer.Deserialize<VersionedObject<T>>(json);
    
    // Если версия устарела, конвертируем или возвращаем значение по умолчанию
    if (wrapper.Version < currentVersion)
    {
        // Здесь может быть логика миграции данных между версиями
        return default;
    }
    
    return wrapper.Data;
}
 
private class VersionedObject<T>
{
    public int Version { get; set; }
    public T Data { get; set; }
}

options.IsEssential = true; // Куки будет установлен даже если пользователь не дал согласие на необязательные куки

public string EncodeForCookie(string value)
{
    return HttpUtility.UrlEncode(value);
}
 
public string DecodeFromCookie(string value)
{
    return HttpUtility.UrlDecode(value);
}

options.HttpOnly = false; // Куки будет доступен из JavaScript

// Установка идентификатора в куки
string sessionId = Guid.NewGuid().ToString();
Response.Cookies.Append("session_id", sessionId);
 
// Сохранение данных в кэше на сервере
_cache.Set(sessionId, largeObject, TimeSpan.FromHours(1));
 
// Контроллер для получения данных
[HttpGet("api/user-data")]
public ActionResult<T> GetUserData()
{
    string sessionId = Request.Cookies["session_id"];
    if (string.IsNullOrEmpty(sessionId))
        return Unauthorized();
        
    if (_cache.TryGetValue(sessionId, out T data))
        return data;
        
    return NotFound();
}

public T GetObjectSafely<T>(string key) where T : class
{
    try
    {
        string value = Request.Cookies[key];
        if (string.IsNullOrEmpty(value))
            return default;
            
        // Установка лимита на глубину вложенности и размер строк
        var options = new JsonSerializerOptions
        {
            MaxDepth = 10,
            // В System.Text.Json нет прямого ограничения на размер,
            // но можно реализовать собственный JsonConverter
        };
        
        T result = JsonSerializer.Deserialize<T>(value, options);
        
        // Дополнительная валидация объекта
        if (!IsValid(result))
            return default;
            
        return result;
    }
    catch
    {
        // Логирование ошибки
        return default;
    }
}
 
private bool IsValid<T>(T obj) where T : class
{
    if (obj == null)
        return false;
        
    // Здесь может быть специфичная для типа валидация
    return true;
}

public class CookieManager
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly ILogger<CookieManager> _logger;
 
    public CookieManager(IHttpContextAccessor httpContextAccessor, ILogger<CookieManager> logger)
    {
        _httpContextAccessor = httpContextAccessor;
        _logger = logger;
    }
 
    public void Set(string key, string value, int? expirationMinutes = null)
    {
        try
        {
            var context = _httpContextAccessor.HttpContext;
            if (context == null)
            {
                _logger.LogWarning("Попытка установить куки без доступного HttpContext");
                return;
            }
 
            var options = new CookieOptions();
            if (expirationMinutes.HasValue)
            {
                options.Expires = DateTime.Now.AddMinutes(expirationMinutes.Value);
            }
 
            context.Response.Cookies.Append(key, value, options);
            _logger.LogDebug("Куки {Key} успешно установлен", key);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при установке куки {Key}", key);
            throw;
        }
    }
 
    public string Get(string key)
    {
        try
        {
            var context = _httpContextAccessor.HttpContext;
            if (context == null)
            {
                _logger.LogWarning("Попытка получить куки без доступного HttpContext");
                return null;
            }
 
            if (context.Request.Cookies.TryGetValue(key, out string value))
            {
                return value;
            }
 
            _logger.LogDebug("Куки {Key} не найден", key);
            return null;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при получении куки {Key}", key);
            return null;
        }
    }
 
    public void Remove(string key)
    {
        try
        {
            var context = _httpContextAccessor.HttpContext;
            if (context == null)
            {
                _logger.LogWarning("Попытка удалить куки без доступного HttpContext");
                return;
            }
 
            context.Response.Cookies.Delete(key);
            _logger.LogDebug("Куки {Key} успешно удален", key);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при удалении куки {Key}", key);
            throw;
        }
    }
}

public class ThemeService
{
    private const string ThemeCookieKey = "user_theme";
    private readonly CookieManager _cookieManager;
 
    public ThemeService(CookieManager cookieManager)
    {
        _cookieManager = cookieManager;
    }
 
    public void SetTheme(string theme)
    {
        if (string.IsNullOrWhiteSpace(theme))
        {
            throw new ArgumentException("Тема не может быть пустой", nameof(theme));
        }
 
        // Валидация допустимых значений
        if (!new[] { "light", "dark", "system" }.Contains(theme.ToLower()))
        {
            throw new ArgumentException("Недопустимая тема", nameof(theme));
        }
 
        // Сохраняем на год
        _cookieManager.Set(ThemeCookieKey, theme, 60 * 24 * 365);
    }
 
    public string GetTheme()
    {
        return _cookieManager.Get(ThemeCookieKey) ?? "system";
    }
}

public class LocalizationMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<LocalizationMiddleware> _logger;
 
    public LocalizationMiddleware(RequestDelegate next, ILogger<LocalizationMiddleware> logger)
    {
        _next = next;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            // Попытка получить язык из куки
            if (context.Request.Cookies.TryGetValue("culture", out string cultureName))
            {
                // Проверка на валидность культуры
                if (IsValidCulture(cultureName))
                {
                    var culture = new CultureInfo(cultureName);
                    Thread.CurrentThread.CurrentCulture = culture;
                    Thread.CurrentThread.CurrentUICulture = culture;
                    _logger.LogDebug("Установлена культура {Culture} из куки", cultureName);
                }
                else
                {
                    _logger.LogWarning("Обнаружена некорректная культура в куки: {Culture}", cultureName);
                }
            }
            // Если в куки нет, смотрим заголовок Accept-Language
            else if (context.Request.Headers.ContainsKey("Accept-Language"))
            {
                var headerValue = context.Request.Headers["Accept-Language"].ToString();
                var languages = headerValue.Split(',')
                    .Select(x => x.Split(';').First().Trim())
                    .ToList();
 
                foreach (var lang in languages)
                {
                    if (IsValidCulture(lang))
                    {
                        var culture = new CultureInfo(lang);
                        Thread.CurrentThread.CurrentCulture = culture;
                        Thread.CurrentThread.CurrentUICulture = culture;
 
                        // Сохраняем в куки для следующих запросов
                        context.Response.Cookies.Append("culture", lang, new CookieOptions
                        {
                            Expires = DateTime.Now.AddMonths(3),
                            IsEssential = true // Важно для GDPR
                        });
 
                        _logger.LogDebug("Установлена культура {Culture} из заголовка Accept-Language", lang);
                        break;
                    }
                }
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при обработке локализации");
            // Не прерываем конвейер запросов
        }
 
        await _next(context);
    }
 
    private bool IsValidCulture(string cultureName)
    {
        if (string.IsNullOrWhiteSpace(cultureName))
            return false;
 
        try
        {
            // Проверяем, что такая культура существует
            CultureInfo.GetCultureInfo(cultureName);
            return true;
        }
        catch (CultureNotFoundException)
        {
            return false;
        }
    }
}

public class CookieConsentService
{
    private const string ConsentCookieKey = "cookie_consent";
    private readonly CookieManager _cookieManager;
 
    public CookieConsentService(CookieManager cookieManager)
    {
        _cookieManager = cookieManager;
    }
 
    public bool HasConsent()
    {
        var consent = _cookieManager.Get(ConsentCookieKey);
        return !string.IsNullOrEmpty(consent) && consent.Equals("accepted", StringComparison.OrdinalIgnoreCase);
    }
 
    public void SetConsent(bool accepted)
    {
        // Сохраняем на год
        _cookieManager.Set(ConsentCookieKey, accepted ? "accepted" : "declined", 60 * 24 * 365);
    }
 
    public void ResetConsent()
    {
        _cookieManager.Remove(ConsentCookieKey);
    }
 
    public Dictionary<string, bool> GetDetailedConsent()
    {
        var detailedConsent = _cookieManager.Get("detailed_cookie_consent");
        
        if (string.IsNullOrEmpty(detailedConsent))
            return new Dictionary<string, bool>();
            
        try
        {
            return JsonSerializer.Deserialize<Dictionary<string, bool>>(detailedConsent);
        }
        catch
        {
            return new Dictionary<string, bool>();
        }
    }
 
    public void SetDetailedConsent(Dictionary<string, bool> consentOptions)
    {
        var json = JsonSerializer.Serialize(consentOptions);
        _cookieManager.Set("detailed_cookie_consent", json, 60 * 24 * 365);
    }
}

public class RememberMeService
{
    private const string RememberTokenKey = "remember_token";
    private readonly CookieManager _cookieManager;
    private readonly IUserRepository _userRepository;
    private readonly ILogger<RememberMeService> _logger;
 
    public RememberMeService(
        CookieManager cookieManager,
        IUserRepository userRepository,
        ILogger<RememberMeService> logger)
    {
        _cookieManager = cookieManager;
        _userRepository = userRepository;
        _logger = logger;
    }
 
    public async Task CreateRememberMeTokenAsync(int userId)
    {
        try
        {
            // Генерируем случайный токен
            var token = GenerateSecureToken();
            
            // Хешируем для хранения в БД
            var hashedToken = HashToken(token);
            
            // Сохраняем в БД связку userId + hashedToken
            await _userRepository.SaveRememberTokenAsync(userId, hashedToken, DateTime.Now.AddMonths(1));
            
            // Создаем строку для куки: userId:token
            var cookieValue = $"{userId}:{token}";
            
            // Сохраняем в куки на месяц
            _cookieManager.Set(RememberTokenKey, cookieValue, 60 * 24 * 30);
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при создании токена 'запомнить меня' для пользователя {UserId}", userId);
            throw;
        }
    }
 
    public async Task<int?> ValidateRememberMeTokenAsync()
    {
        try
        {
            var cookieValue = _cookieManager.Get(RememberTokenKey);
            if (string.IsNullOrEmpty(cookieValue))
                return null;
                
            var parts = cookieValue.Split(':');
            if (parts.Length != 2 || !int.TryParse(parts[0], out int userId))
                return null;
                
            var token = parts[1];
            var hashedToken = HashToken(token);
            
            // Проверяем токен в БД
            var isValid = await _userRepository.ValidateRememberTokenAsync(userId, hashedToken);
            
            return isValid ? userId : null;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при проверке токена 'запомнить меня'");
            return null;
        }
    }
 
    public void ClearRememberMeToken()
    {
        _cookieManager.Remove(RememberTokenKey);
    }
 
    private string GenerateSecureToken()
    {
        using var rng = RandomNumberGenerator.Create();
        var tokenData = new byte[32]; // 256 bit
        rng.GetBytes(tokenData);
        return Convert.ToBase64String(tokenData);
    }
 
    private string HashToken(string token)
    {
        using var sha = SHA256.Create();
        var tokenBytes = Encoding.UTF8.GetBytes(token);
        var hashBytes = sha.ComputeHash(tokenBytes);
        return Convert.ToBase64String(hashBytes);
    }
}

public class CookieDebugMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<CookieDebugMiddleware> _logger;
    private readonly bool _isEnabled;
 
    public CookieDebugMiddleware(
        RequestDelegate next,
        ILogger<CookieDebugMiddleware> logger,
        IConfiguration configuration)
    {
        _next = next;
        _logger = logger;
        _isEnabled = configuration.GetValue<bool>("Debug:CookieLogging");
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        if (_isEnabled)
        {
            // Логируем все входящие куки
            var requestCookies = context.Request.Cookies;
            if (requestCookies.Count > 0)
            {
                var cookieInfo = new StringBuilder("Входящие куки: ");
                foreach (var cookie in requestCookies)
                {
                    // Не логируем полное содержимое чувствительных куки
                    var value = IsSensitiveCookie(cookie.Key) 
                        ? "[Скрыто для безопасности]" 
                        : cookie.Value.Substring(0, Math.Min(20, cookie.Value.Length)) + (cookie.Value.Length > 20 ? "..." : "");
                        
                    cookieInfo.Append($"{cookie.Key}={value}; ");
                }
                _logger.LogDebug(cookieInfo.ToString());
            }
            else
            {
                _logger.LogDebug("Запрос не содержит куки");
            }
 
            // Отслеживаем все куки, устанавливаемые в ответе
            var originalResponseCookies = context.Response.Cookies;
            var cookiesList = new List<(string Key, string Value, CookieOptions Options)>();
            
            // Заменяем стандартную реализацию на свою
            context.Response.Cookies = new CookieLoggingWrapper(originalResponseCookies, cookiesList);
 
            try
            {
                await _next(context);
            }
            finally
            {
                // Логируем все установленные куки
                if (cookiesList.Count > 0)
                {
                    var cookieInfo = new StringBuilder("Исходящие куки: ");
                    foreach (var (key, value, options) in cookiesList)
                    {
                        var valueToLog = IsSensitiveCookie(key) 
                            ? "[Скрыто для безопасности]" 
                            : value.Substring(0, Math.Min(20, value.Length)) + (value.Length > 20 ? "..." : "");
                            
                        cookieInfo.Append($"{key}={valueToLog} (Expires: {options.Expires}); ");
                    }
                    _logger.LogDebug(cookieInfo.ToString());
                }
            }
        }
        else
        {
            await _next(context);
        }
    }
 
    private bool IsSensitiveCookie(string key)
    {
        var sensitiveKeys = new[] { "auth", "token", "session", "remember" };
        return sensitiveKeys.Any(k => key.ToLower().Contains(k));
    }
 
    // Обертка для логирования куки
    private class CookieLoggingWrapper : IResponseCookies
    {
        private readonly IResponseCookies _originalCookies;
        private readonly List<(string Key, string Value, CookieOptions Options)> _cookiesList;
 
        public CookieLoggingWrapper(
            IResponseCookies originalCookies, 
            List<(string Key, string Value, CookieOptions Options)> cookiesList)
        {
            _originalCookies = originalCookies;
            _cookiesList = cookiesList;
        }
 
        public void Append(string key, string value, CookieOptions options)
        {
            _cookiesList.Add((key, value, options ?? new CookieOptions()));
            _originalCookies.Append(key, value, options);
        }
 
        public void Append(string key, string value)
        {
            var options = new CookieOptions();
            _cookiesList.Add((key, value, options));
            _originalCookies.Append(key, value);
        }
 
        public void Delete(string key, CookieOptions options)
        {
            _cookiesList.Add((key, "[Deleted]", options ?? new CookieOptions()));
            _originalCookies.Delete(key, options);
        }
 
        public void Delete(string key)
        {
            var options = new CookieOptions();
            _cookiesList.Add((key, "[Deleted]", options));
            _originalCookies.Delete(key);
        }
    }
}

public class SecureCookieService
{
    private readonly CookieManager _cookieManager;
    private readonly string _validationKey;
 
    public SecureCookieService(CookieManager cookieManager, IConfiguration configuration)
    {
        _cookieManager = cookieManager;
        _validationKey = configuration["Security:CookieValidationKey"];
    }
 
    public void SetSecure(string key, string value, int? expirationMinutes = null)
    {
        // Добавляем метку времени и "канарейку" для защиты
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
        var data = $"{value}|{timestamp}|{ComputeCanary(value, timestamp)}";
        _cookieManager.Set(key, data, expirationMinutes);
    }
 
    public string GetSecure(string key, TimeSpan? maxAge = null)
    {
        var data = _cookieManager.Get(key);
        if (string.IsNullOrEmpty(data))
            return null;
            
        var parts = data.Split('|');
        if (parts.Length != 3)
            return null;
            
        var value = parts[0];
        var timestamp = long.Parse(parts[1]);
        var canary = parts[2];
        
        // Проверяем "канарейку"
        if (canary != ComputeCanary(value, timestamp))
            return null;
            
        // Проверяем срок годности, если указан
        if (maxAge.HasValue)
        {
            var age = DateTimeOffset.UtcNow.ToUnixTimeSeconds() - timestamp;
            if (age > maxAge.Value.TotalSeconds)
                return null;
        }
        
        return value;
    }
 
    private string ComputeCanary(string value, long timestamp)
    {
        using var hmac = new HMACSHA256(Encoding.UTF8.GetBytes(_validationKey));
        var data = Encoding.UTF8.GetBytes($"{value}|{timestamp}");
        var hash = hmac.ComputeHash(data);
        return Convert.ToBase64String(hash).Substring(0, 8); // Используем только часть хеша
    }
}

public class EncryptedCookieService
{
    private readonly CookieManager _cookieManager;
    private readonly IDataProtector _protector;
 
    public EncryptedCookieService(
        CookieManager cookieManager,
        IDataProtectionProvider dataProtectionProvider)
    {
        _cookieManager = cookieManager;
        // Создаем протектор с определенным назначением
        _protector = dataProtectionProvider.CreateProtector("EncryptedCookies");
    }
 
    public void SetEncrypted(string key, string value, int? expirationMinutes = null)
    {
        if (string.IsNullOrEmpty(value))
        {
            _cookieManager.Remove(key);
            return;
        }
 
        var encryptedValue = _protector.Protect(value);
        _cookieManager.Set(key, encryptedValue, expirationMinutes);
    }
 
    public string GetEncrypted(string key)
    {
        var encryptedValue = _cookieManager.Get(key);
        
        if (string.IsNullOrEmpty(encryptedValue))
            return null;
        
        try
        {
            return _protector.Unprotect(encryptedValue);
        }
        catch (CryptographicException)
        {
            // Невозможно расшифровать - возможно, ключи были изменены
            // или данные повреждены
            _cookieManager.Remove(key); // Удаляем поврежденную куки
            return null;
        }
    }
}

public class CheckoutStateService
{
    private const string CheckoutCookieKey = "checkout_state";
    private readonly EncryptedCookieService _cookieService;
 
    public CheckoutStateService(EncryptedCookieService cookieService)
    {
        _cookieService = cookieService;
    }
 
    public CheckoutState GetState()
    {
        var stateJson = _cookieService.GetEncrypted(CheckoutCookieKey);
        
        if (string.IsNullOrEmpty(stateJson))
            return new CheckoutState { CurrentStep = CheckoutStep.Cart };
        
        try
        {
            return JsonSerializer.Deserialize<CheckoutState>(stateJson);
        }
        catch
        {
            // При ошибке десериализации возвращаем состояние по умолчанию
            return new CheckoutState { CurrentStep = CheckoutStep.Cart };
        }
    }
 
    public void SaveState(CheckoutState state)
    {
        if (state == null)
        {
            _cookieService.SetEncrypted(CheckoutCookieKey, null);
            return;
        }
 
        // Устанавливаем время последнего обновления
        state.LastUpdated = DateTime.UtcNow;
        
        var stateJson = JsonSerializer.Serialize(state);
        _cookieService.SetEncrypted(CheckoutCookieKey, stateJson, 60); // Срок жизни 1 час
    }
    
    public void MoveToNextStep(CheckoutStep nextStep)
    {
        var state = GetState();
        state.CurrentStep = nextStep;
        state.StepHistory.Add(new CheckoutStepInfo 
        { 
            Step = nextStep, 
            Timestamp = DateTime.UtcNow 
        });
        SaveState(state);
    }
    
    public void ResetCheckout()
    {
        _cookieService.SetEncrypted(CheckoutCookieKey, null);
    }
}
 
public class CheckoutState
{
    public CheckoutStep CurrentStep { get; set; }
    public List<CheckoutStepInfo> StepHistory { get; set; } = new List<CheckoutStepInfo>();
    public DateTime LastUpdated { get; set; }
    // Другие поля состояния оформления заказа
}
 
public class CheckoutStepInfo
{
    public CheckoutStep Step { get; set; }
    public DateTime Timestamp { get; set; }
}
 
public enum CheckoutStep
{
    Cart,
    Address,
    Shipping,
    Payment,
    Review,
    Complete
}

public class CartService
{
    private const string CartCookieKey = "shopping_cart";
    private readonly EncryptedCookieService _cookieService;
    private readonly IProductRepository _productRepository;
 
    public CartService(
        EncryptedCookieService cookieService,
        IProductRepository productRepository)
    {
        _cookieService = cookieService;
        _productRepository = productRepository;
    }
 
    public async Task<Cart> GetCartAsync()
    {
        var cartJson = _cookieService.GetEncrypted(CartCookieKey);
        
        if (string.IsNullOrEmpty(cartJson))
            return new Cart();
        
        try
        {
            var cart = JsonSerializer.Deserialize<Cart>(cartJson);
            
            // Обновляем информацию о продуктах из базы данных
            await LoadProductDetailsAsync(cart);
            
            return cart;
        }
        catch
        {
            return new Cart();
        }
    }
 
    public async Task AddToCartAsync(int productId, int quantity = 1)
    {
        var cart = await GetCartAsync();
        
        var existingItem = cart.Items.FirstOrDefault(i => i.ProductId == productId);
        
        if (existingItem != null)
        {
            existingItem.Quantity += quantity;
        }
        else
        {
            // Получаем базовую информацию о продукте
            var product = await _productRepository.GetProductBasicInfoAsync(productId);
            
            if (product == null)
                throw new ArgumentException($"Продукт с ID {productId} не найден");
                
            cart.Items.Add(new CartItem
            {
                ProductId = productId,
                Quantity = quantity,
                ProductName = product.Name,
                UnitPrice = product.Price
            });
        }
        
        cart.LastUpdated = DateTime.UtcNow;
        SaveCart(cart);
    }
 
    public void SaveCart(Cart cart)
    {
        if (cart == null)
        {
            _cookieService.SetEncrypted(CartCookieKey, null);
            return;
        }
        
        var cartJson = JsonSerializer.Serialize(cart);
        // Сохраняем на 30 дней
        _cookieService.SetEncrypted(CartCookieKey, cartJson, 60 * 24 * 30);
    }
 
    private async Task LoadProductDetailsAsync(Cart cart)
    {
        // Получаем актуальные данные о продуктах
        var productIds = cart.Items.Select(i => i.ProductId).ToList();
        var products = await _productRepository.GetProductsBasicInfoAsync(productIds);
        
        foreach (var item in cart.Items)
        {
            var product = products.FirstOrDefault(p => p.Id == item.ProductId);
            if (product != null)
            {
                item.ProductName = product.Name;
                item.UnitPrice = product.Price;
                // Обновляем другие поля при необходимости
            }
        }
    }
}
 
public class Cart
{
    public List<CartItem> Items { get; set; } = new List<CartItem>();
    public DateTime LastUpdated { get; set; }
    
    public decimal TotalPrice => Items.Sum(i => i.TotalPrice);
    public int TotalItems => Items.Sum(i => i.Quantity);
}
 
public class CartItem
{
    public int ProductId { get; set; }
    public string ProductName { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    
    public decimal TotalPrice => UnitPrice * Quantity;
}

public class AbTestingService
{
    private const string AbTestCookieKeyPrefix = "ab_test_";
    private readonly CookieManager _cookieManager;
    private readonly Random _random = new Random();
 
    public AbTestingService(CookieManager cookieManager)
    {
        _cookieManager = cookieManager;
    }
 
    public string GetVariant(string experimentName, params string[] variants)
    {
        if (variants == null || variants.Length == 0)
            throw new ArgumentException("Необходимо указать варианты для эксперимента", nameof(variants));
 
        var cookieKey = $"{AbTestCookieKeyPrefix}{experimentName}";
        var existingVariant = _cookieManager.Get(cookieKey);
        
        // Если пользователь уже участвует в эксперименте, возвращаем его вариант
        if (!string.IsNullOrEmpty(existingVariant) && variants.Contains(existingVariant))
            return existingVariant;
            
        // Иначе случайно выбираем вариант
        var selectedVariant = variants[_random.Next(variants.Length)];
        
        // Сохраняем в куки на 30 дней
        _cookieManager.Set(cookieKey, selectedVariant, 60 * 24 * 30);
        
        return selectedVariant;
    }
 
    public void TrackConversion(string experimentName)
    {
        var cookieKey = $"{AbTestCookieKeyPrefix}{experimentName}";
        var variant = _cookieManager.Get(cookieKey);
        
        if (!string.IsNullOrEmpty(variant))
        {
            // Здесь может быть код для отправки события в аналитическую систему
            // или запись в базу данных
            
            // Например:
            // _analyticsService.TrackEvent($"ab_test_{experimentName}_conversion", new { variant });
        }
    }
}

var options = new CookieOptions
{
    HttpOnly = true,
    Secure = true,
    SameSite = SameSiteMode.Strict
};

services.ConfigureApplicationCookie(options =>
{
    options.Cookie.HttpOnly = true;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    options.Cookie.SameSite = SameSiteMode.Strict;
    
    // Другие настройки
    options.ExpireTimeSpan = TimeSpan.FromDays(30);
    options.SlidingExpiration = true;
    options.Cookie.Name = "MyApp.Auth";
});

services.AddAntiforgery(options =>
{
    options.HeaderName = "X-XSRF-TOKEN";
    options.Cookie.Name = "XSRF-TOKEN";
    options.Cookie.HttpOnly = false; // Важно: должен быть доступен для JavaScript
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    options.Cookie.SameSite = SameSiteMode.Strict;
});

[HttpPost]
[ValidateAntiForgeryToken]
public async Task<IActionResult> ProcessForm(FormModel model)
{
    // ...
}

public class ValidateAntiforgeryTokenMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IAntiforgery _antiforgery;
 
    public ValidateAntiforgeryTokenMiddleware(RequestDelegate next, IAntiforgery antiforgery)
    {
        _next = next;
        _antiforgery = antiforgery;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        if (HttpMethods.IsPost(context.Request.Method) ||
            HttpMethods.IsPut(context.Request.Method) ||
            HttpMethods.IsDelete(context.Request.Method))
        {
            await _antiforgery.ValidateRequestAsync(context);
        }
        else if (HttpMethods.IsGet(context.Request.Method))
        {
            // Генерируем токен для GET-запросов
            var tokens = _antiforgery.GetAndStoreTokens(context);
            context.Response.Cookies.Append("XSRF-TOKEN", tokens.RequestToken,
                new CookieOptions
                {
                    HttpOnly = false, // Должен быть доступен для JavaScript
                    Secure = true,
                    SameSite = SameSiteMode.Strict
                });
        }
 
        await _next(context);
    }
}

app.Use(async (context, next) =>
{
    context.Response.Headers.Add("Content-Security-Policy", 
        "default-src 'self'; script-src 'self' https://trusted-cdn.com; " +
        "style-src 'self' https://trusted-cdn.com; " +
        "img-src 'self' data: https://trusted-cdn.com; " +
        "font-src 'self' https://trusted-cdn.com; " +
        "connect-src 'self' https://api.myapp.com; " +
        "frame-ancestors 'none'; " +
        "form-action 'self';");
        
    await next();
});

// В контроллере
public IActionResult DisplayUserContent(string userInput)
{
    ViewBag.SanitizedContent = System.Web.HttpUtility.HtmlEncode(userInput);
    return View();
}
 
// В представлении
@Html.Raw(ViewBag.SanitizedContent)

// После успешной аутентификации
HttpContext.Session.Clear();
HttpContext.Response.Cookies.Delete(".AspNetCore.Session");
HttpContext.Features.Set<ISessionFeature>(new SessionFeature());
HttpContext.Session = new DistributedSession(/* ... */);

public class SessionSecurityMiddleware
{
    private readonly RequestDelegate _next;
 
    public SessionSecurityMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        if (context.User.Identity.IsAuthenticated)
        {
            var currentIp = context.Connection.RemoteIpAddress?.ToString();
            var currentAgent = context.Request.Headers["User-Agent"].ToString();
            
            var sessionIp = context.Session.GetString("UserIP");
            var sessionAgent = context.Session.GetString("UserAgent");
            
            if (sessionIp != null && sessionAgent != null)
            {
                if (sessionIp != currentIp || sessionAgent != currentAgent)
                {
                    // Подозрительное изменение - возможно, перехват сессии
                    // Сбрасываем аутентификацию
                    await context.SignOutAsync();
                    context.Response.Redirect("/Account/Login?suspicious=true");
                    return;
                }
            }
            else
            {
                // Сохраняем данные для будущих проверок
                context.Session.SetString("UserIP", currentIp);
                context.Session.SetString("UserAgent", currentAgent);
            }
        }
 
        await _next(context);
    }
}

// При аутентификации
var securityToken = GenerateSecureToken();
_userRepository.SaveSecurityToken(userId, securityToken);
Response.Cookies.Append("X-Security-Check", securityToken, new CookieOptions
{
    HttpOnly = true,
    Secure = true,
    SameSite = SameSiteMode.Strict
});
 
// В middleware для проверки
if (context.User.Identity.IsAuthenticated)
{
    var userId = context.User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
    var securityToken = context.Request.Cookies["X-Security-Check"];
    
    if (string.IsNullOrEmpty(securityToken) || 
        !_userRepository.ValidateSecurityToken(userId, securityToken))
    {
        // Токен отсутствует или недействителен
        await context.SignOutAsync();
        context.Response.Redirect("/Account/Login");
        return;
    }
}

services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
    // Настройки пароля
    options.Password.RequireDigit = true;
    options.Password.RequireLowercase = true;
    options.Password.RequireUppercase = true;
    options.Password.RequireNonAlphanumeric = true;
    options.Password.RequiredLength = 12;
    
    // Настройки блокировки
    options.Lockout.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(15);
    options.Lockout.MaxFailedAccessAttempts = 5;
    
    // Настройки пользователей
    options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();
 
// Настройка аутентификационных куки
services.ConfigureApplicationCookie(options =>
{
    options.Cookie.Name = "MyApp.Identity";
    options.Cookie.HttpOnly = true;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    options.Cookie.SameSite = SameSiteMode.Strict;
    
    options.ExpireTimeSpan = TimeSpan.FromHours(1);
    options.SlidingExpiration = true;
    
    options.LoginPath = "/Identity/Account/Login";
    options.LogoutPath = "/Identity/Account/Logout";
    options.AccessDeniedPath = "/Identity/Account/AccessDenied";
});

services.AddAuthentication()
.AddGoogle(options =>
{
    options.ClientId = Configuration["Authentication:Google:ClientId"];
    options.ClientSecret = Configuration["Authentication:Google:ClientSecret"];
    options.SaveTokens = true; // Сохраняем токены для возможного использования API
    
    // Настройка куки для временного хранения состояния
    options.CorrelationCookie.SecurePolicy = CookieSecurePolicy.Always;
    options.CorrelationCookie.SameSite = SameSiteMode.Lax; // Нужен Lax для редиректов с внешних сайтов
})
.AddFacebook(options =>
{
    // Аналогичные настройки
});

services.AddDataProtection()
    .PersistKeysToAzureBlobStorage(new Uri("https://mystore.blob.core.windows.net/keys/"))
    .ProtectKeysWithAzureKeyVault("https://mykeyvault.vault.azure.net/keys/dataprotection/");

services.AddDataProtection()
    .PersistKeysToStackExchangeRedis(ConnectionMultiplexer.Connect("redis-connection-string"), "DataProtection-Keys");

public class SecurityAuditMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<SecurityAuditMiddleware> _logger;
    private readonly ISecurityEventService _securityService;
 
    public SecurityAuditMiddleware(
        RequestDelegate next,
        ILogger<SecurityAuditMiddleware> logger,
        ISecurityEventService securityService)
    {
        _next = next;
        _logger = logger;
        _securityService = securityService;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        try
        {
            // Проверка на подозрительные модификации куки
            if (IsSuspiciousCookieModification(context))
            {
                _logger.LogWarning("Обнаружена подозрительная модификация куки: {IP}", 
                    context.Connection.RemoteIpAddress);
                await _securityService.RecordSecurityEventAsync(
                    "suspicious_cookie_modification",
                    context.Connection.RemoteIpAddress.ToString());
            }
 
            await _next(context);
        }
        catch (Exception ex) when (ex is CryptographicException)
        {
            // Перехватываем исключения, связанные с расшифровкой куки
            _logger.LogWarning(ex, "Ошибка при расшифровке куки: {IP}", 
                context.Connection.RemoteIpAddress);
            await _securityService.RecordSecurityEventAsync(
                "cookie_decryption_failure",
                context.Connection.RemoteIpAddress.ToString());
            
            // Очищаем проблемные куки
            foreach (var key in context.Request.Cookies.Keys)
            {
                if (key.StartsWith(".AspNetCore.") || key.StartsWith("MyApp."))
                {
                    context.Response.Cookies.Delete(key);
                }
            }
            
            // Перенаправляем на страницу входа
            context.Response.Redirect("/Account/Login?securityIssue=true");
        }
    }
 
    private bool IsSuspiciousCookieModification(HttpContext context)
    {
        // Реализация проверки на подозрительные модификации
        // Например, анализ структуры куки, сравнение с ожидаемыми паттернами и т.д.
        return false; // Упрощенная версия
    }
}

// Настройка для API, обслуживающего мобильные приложения
services.ConfigureApplicationCookie(options =>
{
    // Для мобильных приложений может потребоваться более гибкая настройка
    options.Cookie.SameSite = SameSiteMode.None;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    
    // Увеличенное время жизни для мобильных приложений
    options.ExpireTimeSpan = TimeSpan.FromDays(30);
    
    // Использование заголовка для передачи ошибок аутентификации
    options.Events.OnRedirectToLogin = context =>
    {
        context.Response.StatusCode = StatusCodes.Status401Unauthorized;
        return Task.CompletedTask;
    };
});

public interface ICookieFactory
{
    T Create<T>() where T : ICookieContainer, new();
}
 
public interface ICookieContainer
{
    string Key { get; }
    CookieCategory Category { get; }
}
 
public enum CookieCategory
{
    Essential,
    Functional,
    Analytics,
    Marketing
}
 
public class CookieFactory : ICookieFactory
{
    private readonly ICookieManager _cookieManager;
    private readonly ICookieConsentService _consentService;
 
    public CookieFactory(ICookieManager cookieManager, ICookieConsentService consentService)
    {
        _cookieManager = cookieManager;
        _consentService = consentService;
    }
 
    public T Create<T>() where T : ICookieContainer, new()
    {
        var container = new T();
        
        // Проверяем, что пользователь согласился на этот тип куки
        if (container.Category != CookieCategory.Essential && 
            !_consentService.HasConsentFor(container.Category))
        {
            throw new CookieConsentException($"Пользователь не давал согласие на куки категории {container.Category}");
        }
        
        return container;
    }
}

public class UserPreferencesContainer : ICookieContainer
{
    private readonly ICookieManager _cookieManager;
    
    public string Key => "user_preferences";
    public CookieCategory Category => CookieCategory.Functional;
    
    // Внедрение зависимостей через конструктор
    public UserPreferencesContainer(ICookieManager cookieManager)
    {
        _cookieManager = cookieManager;
    }
    
    public string Theme
    {
        get => _cookieManager.Get<string>($"{Key}.theme");
        set => _cookieManager.Set($"{Key}.theme", value);
    }
    
    public string Language
    {
        get => _cookieManager.Get<string>($"{Key}.language");
        set => _cookieManager.Set($"{Key}.language", value);
    }
}

public class UserPreferencesService
{
    private readonly ICookieFactory _cookieFactory;
    
    public UserPreferencesService(ICookieFactory cookieFactory)
    {
        _cookieFactory = cookieFactory;
    }
    
    public void SetTheme(string theme)
    {
        try
        {
            var preferences = _cookieFactory.Create<UserPreferencesContainer>();
            preferences.Theme = theme;
        }
        catch (CookieConsentException)
        {
            // Пользователь не дал согласие - используем настройки по умолчанию
        }
    }
}

public class AuthTokenContainer : ICookieContainer
{
    private readonly ICookieManager _cookieManager;
    private readonly ITokenValidator _tokenValidator;
    
    public string Key => "auth_tokens";
    public CookieCategory Category => CookieCategory.Essential;
    
    public AuthTokenContainer(ICookieManager cookieManager, ITokenValidator tokenValidator)
    {
        _cookieManager = cookieManager;
        _tokenValidator = tokenValidator;
    }
    
    public string AccessToken
    {
        get => _cookieManager.Get<string>($"{Key}.access");
        set => _cookieManager.Set($"{Key}.access", value, new CookieOptions { 
            HttpOnly = true, 
            Secure = true,
            SameSite = SameSiteMode.Strict,
            Expires = DateTime.Now.AddMinutes(30)
        });
    }
    
    public bool IsValid => _tokenValidator.ValidateToken(AccessToken);
}

public class CachedCookieManager : ICookieManager
{
    private readonly IHttpContextAccessor _httpContextAccessor;
    private readonly Dictionary<string, string> _cache = new Dictionary<string, string>();
    
    public string Get(string key)
    {
        if (_cache.TryGetValue(key, out string cachedValue))
            return cachedValue;
            
        var value = _httpContextAccessor.HttpContext?.Request.Cookies[key];
        _cache[key] = value;
        return value;
    }
    
    // Остальные методы...
}

public class Program
{
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
 
        // Регистрация основных сервисов
        builder.Services.AddControllersWithViews();
        builder.Services.AddHttpContextAccessor();
        
        // Регистрация сервисов для работы с куки
        builder.Services.AddSingleton<ICookieManager, CookieManager>();
        builder.Services.AddScoped<IEncryptedCookieService, EncryptedCookieService>();
        builder.Services.AddScoped<ICookieConsentService, CookieConsentService>();
        builder.Services.AddScoped<ICookieFactory, CookieFactory>();
        
        // Настройка Data Protection
        builder.Services.AddDataProtection()
            .SetApplicationName("MyCookieApp");
        
        var app = builder.Build();
 
        // Настройка middleware
        if (app.Environment.IsDevelopment())
        {
            app.UseDeveloperExceptionPage();
            app.UseMiddleware<CookieDebugMiddleware>();
        }
        else
        {
            app.UseExceptionHandler("/Home/Error");
            app.UseHsts();
        }
 
        app.UseHttpsRedirection();
        app.UseStaticFiles();
 
        // Middleware для безопасности
        app.UseMiddleware<SecurityAuditMiddleware>();
        app.UseMiddleware<LocalizationMiddleware>();
 
        app.UseRouting();
        app.UseAuthentication();
        app.UseAuthorization();
 
        app.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
 
        app.Run();
    }
}