Форма логина на AngularJS с ASP.NET, часть 4

public void ConfigureAuth(IAppBuilder app)
{
    // Основные настройки аутентификации
    app.UseCookieAuthentication(new CookieAuthenticationOptions
    {
        AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
        LoginPath = new PathString("/Account/Login"),
        Provider = new CookieAuthenticationProvider
        {
            OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
                validateInterval: TimeSpan.FromMinutes(30),
                regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
        }
    });
    
    // Настройка Google-аутентификации
    app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
    {
        ClientId = ConfigurationManager.AppSettings["Google:ClientId"],
        ClientSecret = ConfigurationManager.AppSettings["Google:ClientSecret"],
        CallbackPath = new PathString("/signin-google"),
        Provider = new GoogleOAuth2AuthenticationProvider
        {
            OnAuthenticated = context =>
            {
                // Сохраняем access token для использования в API-запросах
                context.Identity.AddClaim(new Claim("GoogleAccessToken", context.AccessToken));
                return Task.FromResult(0);
            }
        }
    });
    
    // Аналогично для Facebook, GitHub, Microsoft и других провайдеров
}

[AllowAnonymous]
public class AccountController : Controller
{
    private ApplicationSignInManager _signInManager;
    private ApplicationUserManager _userManager;
    
    // Конструктор и свойства опущены для краткости
    
    // Инициирует OAuth-аутентификацию
    [HttpPost]
    [AllowAnonymous]
    public ActionResult ExternalLogin(string provider, string returnUrl)
    {
        // Запрашиваем редирект на внешний провайдер
        return new ChallengeResult(provider, 
            Url.Action("ExternalLoginCallback", "Account", new { ReturnUrl = returnUrl }));
    }
    
    // Обрабатывает ответ от внешнего провайдера
    [AllowAnonymous]
    public async Task<ActionResult> ExternalLoginCallback(string returnUrl)
    {
        var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
        if (loginInfo == null)
        {
            return RedirectToAction("Login");
        }
        
        // Пытаемся войти с внешними учетными данными
        var result = await _signInManager.ExternalSignInAsync(loginInfo, isPersistent: false);
        switch (result)
        {
            case SignInStatus.Success:
                return RedirectToLocal(returnUrl);
            case SignInStatus.LockedOut:
                return View("Lockout");
            case SignInStatus.RequiresVerification:
                return RedirectToAction("SendCode", new { ReturnUrl = returnUrl });
            default:
                // Если пользователь не имеет аккаунта, предлагаем создать его
                ViewBag.ReturnUrl = returnUrl;
                ViewBag.LoginProvider = loginInfo.Login.LoginProvider;
                return View("ExternalLoginConfirmation", 
                    new ExternalLoginConfirmationViewModel { Email = loginInfo.Email });
        }
    }
    
    // Другие методы опущены для краткости
}

private class ChallengeResult : HttpUnauthorizedResult
{
    public ChallengeResult(string provider, string redirectUri)
    {
        LoginProvider = provider;
        RedirectUri = redirectUri;
    }
    
    public string LoginProvider { get; set; }
    public string RedirectUri { get; set; }
    
    public override void ExecuteResult(ControllerContext context)
    {
        var properties = new AuthenticationProperties { RedirectUri = RedirectUri };
        context.HttpContext.GetOwinContext().Authentication.Challenge(properties, LoginProvider);
    }
}

[HttpPost("link-account")]
public async Task<IActionResult> LinkExternalAccount([FromBody] LinkAccountModel model)
{
    var user = await _userManager.FindByNameAsync(model.Email);
    if (user == null)
    {
        return BadRequest(new { Message = "Пользователь не найден" });
    }
    
    // Проверяем пароль
    var isPasswordValid = await _userManager.CheckPasswordAsync(user, model.Password);
    if (!isPasswordValid)
    {
        return BadRequest(new { Message = "Неверный пароль" });
    }
    
    // Получаем информацию о внешнем логине из сессии
    var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync();
    if (loginInfo == null)
    {
        return BadRequest(new { Message = "Информация о внешнем логине не найдена" });
    }
    
    // Связываем аккаунты
    var result = await _userManager.AddLoginAsync(user.Id, loginInfo.Login);
    if (!result.Succeeded)
    {
        return BadRequest(new { Message = "Не удалось связать аккаунты", Errors = result.Errors });
    }
    
    // Выполняем вход
    await _signInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
    
    return Ok(new { Success = true });
}

public class LoginAttempt
{
  public int Id { get; set; }
  
  public int? UserId { get; set; }  // null если пользователь не найден
  
  [Required]
  [MaxLength(256)]
  public string Email { get; set; }  // Введенный email
  
  public DateTime AttemptDate { get; set; }
  
  [Required]
  [MaxLength(50)]
  public string IpAddress { get; set; }
  
  [MaxLength(500)]
  public string UserAgent { get; set; }
  
  public bool Succeeded { get; set; }
  
  [MaxLength(50)]
  public string FailureReason { get; set; }  // Причина неудачи
  
  [MaxLength(100)]
  public string Country { get; set; }  // Страна по IP
  
  [MaxLength(100)]
  public string City { get; set; }  // Город по IP
  
  public User User { get; set; }  // Навигационное свойство
}

public interface ILoginAttemptService
{
  Task LogAttemptAsync(string email, string ipAddress, string userAgent, bool succeeded, string failureReason = null);
  Task<List<LoginAttempt>> GetRecentAttemptsForUserAsync(int userId, int count = 10);
  Task<List<LoginAttempt>> GetFailedAttemptsAsync(string ipAddress, TimeSpan period);
  Task<bool> ExceedsThresholdAsync(string ipAddress, int maxAttempts, TimeSpan period);
}
 
public class LoginAttemptService : ILoginAttemptService
{
  private readonly ApplicationDbContext _context;
  private readonly IUserService _userService;
  private readonly IGeoLocationService _geoLocationService;
  
  public LoginAttemptService(
      ApplicationDbContext context,
      IUserService userService,
      IGeoLocationService geoLocationService)
  {
      _context = context;
      _userService = userService;
      _geoLocationService = geoLocationService;
  }
  
  public async Task LogAttemptAsync(string email, string ipAddress, string userAgent, bool succeeded, string failureReason = null)
  {
      // Находим пользователя, если есть
      var user = await _userService.FindByEmailAsync(email);
      
      // Получаем геолокацию
      var geoInfo = await _geoLocationService.GetLocationAsync(ipAddress);
      
      var attempt = new LoginAttempt
      {
          UserId = user?.Id,
          Email = email,
          AttemptDate = DateTime.UtcNow,
          IpAddress = ipAddress,
          UserAgent = userAgent,
          Succeeded = succeeded,
          FailureReason = failureReason,
          Country = geoInfo?.Country,
          City = geoInfo?.City
      };
      
      _context.LoginAttempts.Add(attempt);
      await _context.SaveChangesAsync();
  }
  
  public async Task<List<LoginAttempt>> GetRecentAttemptsForUserAsync(int userId, int count = 10)
  {
      return await _context.LoginAttempts
          .Where(la => la.UserId == userId)
          .OrderByDescending(la => la.AttemptDate)
          .Take(count)
          .ToListAsync();
  }
  
  public async Task<List<LoginAttempt>> GetFailedAttemptsAsync(string ipAddress, TimeSpan period)
  {
      var cutoffTime = DateTime.UtcNow.Subtract(period);
      
      return await _context.LoginAttempts
          .Where(la => la.IpAddress == ipAddress && 
                      !la.Succeeded && 
                      la.AttemptDate >= cutoffTime)
          .OrderByDescending(la => la.AttemptDate)
          .ToListAsync();
  }
  
  public async Task<bool> ExceedsThresholdAsync(string ipAddress, int maxAttempts, TimeSpan period)
  {
      var attempts = await GetFailedAttemptsAsync(ipAddress, period);
      return attempts.Count >= maxAttempts;
  }
}

[HttpPost("login")]
public async Task<IActionResult> Login([FromBody] LoginModel model)
{
  try
  {
      // Получаем IP-адрес и User-Agent
      var ipAddress = HttpContext.Connection.RemoteIpAddress.ToString();
      var userAgent = HttpContext.Request.Headers["User-Agent"].ToString();
      
      // Проверяем, не превышен ли лимит попыток
      if (await _loginAttemptService.ExceedsThresholdAsync(ipAddress, 5, TimeSpan.FromMinutes(15)))
      {
          await _loginAttemptService.LogAttemptAsync(
              model.Email, ipAddress, userAgent, false, "Rate limit exceeded");
              
          return StatusCode(429, new { Message = "Слишком много попыток входа. Попробуйте позже." });
      }
      
      // Пытаемся аутентифицировать пользователя
      var result = await _userService.AuthenticateAsync(model.Email, model.Password);
      
      if (result.Succeeded)
      {
          // Логируем успешную попытку
          await _loginAttemptService.LogAttemptAsync(
              model.Email, ipAddress, userAgent, true);
              
          // Генерируем токены и возвращаем результат
          // ...
      }
      else
      {
          // Логируем неудачную попытку
          await _loginAttemptService.LogAttemptAsync(
              model.Email, ipAddress, userAgent, false, result.FailureReason);
              
          return Unauthorized(new { Message = "Неверные учетные данные" });
      }
  }
  catch (Exception ex)
  {
      _logger.LogError(ex, "Ошибка при обработке запроса на вход");
      return StatusCode(500, new { Message = "Внутренняя ошибка сервера" });
  }
}

public class LoginSecurityMonitor : BackgroundService
{
  private readonly IServiceProvider _serviceProvider;
  private readonly ILogger<LoginSecurityMonitor> _logger;
  
  public LoginSecurityMonitor(
      IServiceProvider serviceProvider,
      ILogger<LoginSecurityMonitor> logger)
  {
      _serviceProvider = serviceProvider;
      _logger = logger;
  }
  
  protected override async Task ExecuteAsync(CancellationToken stoppingToken)
  {
      while (!stoppingToken.IsCancellationRequested)
      {
          try
          {
              using (var scope = _serviceProvider.CreateScope())
              {
                  var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
                  var notificationService = scope.ServiceProvider.GetRequiredService<INotificationService>();
                  
                  // Проверяем подозрительные IP-адреса с множественными неудачными попытками
                  await CheckBruteForceAttacksAsync(dbContext, notificationService);
                  
                  // Проверяем необычную активность для пользователей
                  await CheckUnusualActivityAsync(dbContext, notificationService);
              }
          }
          catch (Exception ex)
          {
              _logger.LogError(ex, "Ошибка при мониторинге безопасности входа");
          }
          
          // Запускаем проверку каждые 5 минут
          await Task.Delay(TimeSpan.FromMinutes(5), stoppingToken);
      }
  }
  
  private async Task CheckBruteForceAttacksAsync(
      ApplicationDbContext dbContext, 
      INotificationService notificationService)
  {
      // Группируем неудачные попытки по IP и считаем их
      var suspiciousIps = await dbContext.LoginAttempts
          .Where(la => !la.Succeeded && la.AttemptDate >= DateTime.UtcNow.AddHours(-1))
          .GroupBy(la => la.IpAddress)
          .Select(g => new { IpAddress = g.Key, Count = g.Count() })
          .Where(x => x.Count >= 10) // Порог: 10 попыток в час
          .ToListAsync();
          
      foreach (var ip in suspiciousIps)
      {
          _logger.LogWarning($"Обнаружена возможная брутфорс-атака с IP {ip.IpAddress}, {ip.Count} попыток за последний час");
          
          // Отправляем уведомление администратору
          await notificationService.NotifyAdminsAsync(
              "Обнаружена подозрительная активность", 
              $"Возможная брутфорс-атака с IP {ip.IpAddress}, {ip.Count} неудачных попыток за последний час.");
              
          // Здесь можно добавить автоматическую блокировку IP
      }
  }
  
  private async Task CheckUnusualActivityAsync(
      ApplicationDbContext dbContext, 
      INotificationService notificationService)
  {
      // Ищем успешные входы из необычных мест
      var suspiciousLogins = await dbContext.LoginAttempts
          .Where(la => la.Succeeded && la.AttemptDate >= DateTime.UtcNow.AddDays(-1))
          .Join(
              dbContext.Users,
              la => la.UserId,
              u => u.Id,
              (la, u) => new { LoginAttempt = la, User = u }
          )
          .Where(x => x.User.LastLoginCountry != null && 
                      x.User.LastLoginCountry != x.LoginAttempt.Country)
          .ToListAsync();
          
      foreach (var login in suspiciousLogins)
      {
          _logger.LogWarning(
              $"Необычный вход для пользователя {login.User.Email}: " +
              $"обычная страна {login.User.LastLoginCountry}, " +
              $"текущий вход из {login.LoginAttempt.Country}"
          );
          
          // Уведомляем пользователя
          await notificationService.NotifyUserAsync(
              login.User.Id,
              "Обнаружен вход из необычного места",
              $"Мы заметили вход в ваш аккаунт из {login.LoginAttempt.Country}. Если это были не вы, немедленно смените пароль."
          );
      }
  }
}

public interface INotificationService
{
    Task NotifyUserAsync(int userId, string subject, string message);
    Task NotifyAdminsAsync(string subject, string message);
    Task NotifySecurityTeamAsync(string subject, string message, AlertLevel level);
}
 
public enum AlertLevel
{
    Low,
    Medium,
    High,
    Critical
}

public class NotificationService : INotificationService
{
    private readonly ApplicationDbContext _context;
    private readonly IEmailService _emailService;
    private readonly ISmsService _smsService;
    private readonly IWebPushService _pushService;
    private readonly ILogger<NotificationService> _logger;
    
    public NotificationService(
        ApplicationDbContext context,
        IEmailService emailService,
        ISmsService smsService,
        IWebPushService pushService,
        ILogger<NotificationService> logger)
    {
        _context = context;
        _emailService = emailService;
        _smsService = smsService;
        _pushService = pushService;
        _logger = logger;
    }
    
    public async Task NotifyUserAsync(int userId, string subject, string message)
    {
        var user = await _context.Users.FindAsync(userId);
        if (user == null)
        {
            _logger.LogWarning($"Попытка уведомить несуществующего пользователя: {userId}");
            return;
        }
        
        // Сохраняем уведомление в базе
        var notification = new UserNotification
        {
            UserId = userId,
            Subject = subject,
            Message = message,
            CreatedAt = DateTime.UtcNow,
            IsRead = false
        };
        
        _context.UserNotifications.Add(notification);
        await _context.SaveChangesAsync();
        
        // Отправляем email
        if (!string.IsNullOrEmpty(user.Email))
        {
            await _emailService.SendAsync(user.Email, subject, message);
        }
        
        // Отправляем SMS для критичных уведомлений
        if (!string.IsNullOrEmpty(user.PhoneNumber) && subject.Contains("Подозрительный вход"))
        {
            await _smsService.SendAsync(user.PhoneNumber, $"Обнаружена подозрительная активность в вашем аккаунте. Проверьте почту для деталей.");
        }
        
        // Отправляем push-уведомление, если пользователь подписан
        if (user.PushSubscription != null)
        {
            await _pushService.SendAsync(user.PushSubscription, subject, message);
        }
    }
    
    // Реализация других методов опущена для краткости
}

private async Task CheckUnusualLocationAsync(
    ApplicationDbContext dbContext, 
    INotificationService notificationService)
{
    var lastDay = DateTime.UtcNow.AddDays(-1);
    
    // Находим входы из необычных локаций
    var unusualLogins = await dbContext.LoginAttempts
        .Where(la => la.Succeeded && la.AttemptDate >= lastDay)
        .Join(dbContext.Users, la => la.UserId, u => u.Id, (la, u) => new { LoginAttempt = la, User = u })
        .Where(x => x.User.LastLoginCountry != null && 
                    x.User.LastLoginCountry != x.LoginAttempt.Country)
        .ToListAsync();
    
    foreach (var item in unusualLogins)
    {
        // Уведомляем пользователя
        await notificationService.NotifyUserAsync(
            item.User.Id,
            "Подозрительный вход в ваш аккаунт",
            $"Мы обнаружили вход в ваш аккаунт из необычного места: {item.LoginAttempt.Country}, {item.LoginAttempt.City}. " +
            $"Если это были не вы, немедленно смените пароль и обратитесь в службу поддержки."
        );
        
        // Уведомляем службу безопасности
        await notificationService.NotifySecurityTeamAsync(
            "Вход из необычной локации",
            $"Пользователь {item.User.Email} вошел из необычного места: {item.LoginAttempt.Country}, {item.LoginAttempt.City}. " +
            $"Обычная локация: {item.User.LastLoginCountry}.",
            AlertLevel.Medium
        );
    }
}

[HttpPost("login")]
public async Task<IActionResult> Login([FromBody] LoginModel model)
{
    try
    {
        // Валидация модели
        if (!ModelState.IsValid)
        {
            return BadRequest(new ApiErrorResponse
            {
                ErrorType = "ValidationError",
                Message = "Данные формы содержат ошибки",
                Details = ModelState.GetErrorMessages() // Вспомогательный метод для сбора всех ошибок
            });
        }
        
        // Проверка на блокировку по IP
        if (await _securityService.IsIpBlockedAsync(HttpContext.Connection.RemoteIpAddress.ToString()))
        {
            return StatusCode(429, new ApiErrorResponse
            {
                ErrorType = "RateLimitExceeded",
                Message = "Слишком много попыток входа. Попробуйте позже.",
                Details = new { RetryAfter = 15 } // Минут до снятия блокировки
            });
        }
        
        // Попытка аутентификации
        var result = await _authService.AuthenticateAsync(model.Email, model.Password);
        
        if (!result.Succeeded)
        {
            // Разные сообщения в зависимости от причины ошибки
            switch (result.FailureReason)
            {
                case AuthFailureReason.InvalidCredentials:
                    return Unauthorized(new ApiErrorResponse
                    {
                        ErrorType = "InvalidCredentials",
                        Message = "Неверный email или пароль"
                    });
                    
                case AuthFailureReason.AccountLocked:
                    return Forbidden(new ApiErrorResponse
                    {
                        ErrorType = "AccountLocked",
                        Message = "Ваш аккаунт временно заблокирован",
                        Details = new { UnlockTime = result.AccountUnlockTime }
                    });
                    
                case AuthFailureReason.EmailNotConfirmed:
                    // Переотправляем ссылку подтверждения
                    await _emailService.SendConfirmationAsync(model.Email);
                    
                    return Unauthorized(new ApiErrorResponse
                    {
                        ErrorType = "EmailNotConfirmed",
                        Message = "Необходимо подтвердить email. Мы отправили новую ссылку для подтверждения."
                    });
                    
                default:
                    return Unauthorized(new ApiErrorResponse
                    {
                        ErrorType = "AuthenticationFailed",
                        Message = "Не удалось выполнить вход"
                    });
            }
        }
        
        // Успешная аутентификация - генерируем токены и т.д.
        // ...
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Ошибка при обработке запроса на вход");
        
        return StatusCode(500, new ApiErrorResponse
        {
            ErrorType = "ServerError",
            Message = "Произошла внутренняя ошибка сервера"
        });
    }
}

// В AuthService
public async Task<AuthResult> AuthenticateAsync(string email, string password)
{
    try
    {
        _logger.LogInformation("Начало аутентификации для {Email}", email);
        
        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
        {
            _logger.LogWarning("Пользователь не найден: {Email}", email);
            return AuthResult.Failed(AuthFailureReason.InvalidCredentials);
        }
        
        // Другие проверки с логированием
        // ...
        
        _logger.LogInformation("Успешная аутентификация: {Email} (UserId: {UserId})", email, user.Id);
        return AuthResult.Success(user);
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Ошибка при аутентификации {Email}", email);
        throw;
    }
}

public class AuthControllerTests
{
  private readonly Mock<IUserService> _userServiceMock;
  private readonly Mock<IJwtService> _jwtServiceMock;
  private readonly Mock<ILogger<AuthController>> _loggerMock;
  private readonly AuthController _controller;
  
  public AuthControllerTests()
  {
    _userServiceMock = new Mock<IUserService>();
    _jwtServiceMock = new Mock<IJwtService>();
    _loggerMock = new Mock<ILogger<AuthController>>();
    
    _controller = new AuthController(
      _userServiceMock.Object,
      _jwtServiceMock.Object,
      _loggerMock.Object
    );
    
    // Настраиваем HttpContext для контроллера
    var httpContext = new DefaultHttpContext();
    httpContext.Connection.RemoteIpAddress = IPAddress.Parse("127.0.0.1");
    _controller.ControllerContext = new ControllerContext
    {
      HttpContext = httpContext
    };
  }
  
  [Fact]
  public async Task Login_WithValidCredentials_ReturnsToken()
  {
    // Arrange
    var model = new LoginModel
    {
      Email = "test@example.com",
      Password = "Password123!"
    };
    
    var user = new User { Id = 1, Email = model.Email, FullName = "Test User" };
    
    _userServiceMock
      .Setup(x => x.AuthenticateAsync(model.Email, model.Password))
      .ReturnsAsync(AuthResult.Success(user));
      
    _jwtServiceMock
      .Setup(x => x.GenerateToken(user))
      .Returns("fake-token");
    
    // Act
    var result = await _controller.Login(model) as OkObjectResult;
    
    // Assert
    Assert.NotNull(result);
    Assert.Equal(200, result.StatusCode);
    
    var value = result.Value as dynamic;
    Assert.Equal("fake-token", value.token);
    Assert.Equal("Test User", value.userName);
    
    // Проверяем, что логирование было вызвано
    _loggerMock.Verify(
      x => x.Log(
        LogLevel.Information,
        It.IsAny<EventId>(),
        It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("Успешная аутентификация")),
        null,
        It.IsAny<Func<It.IsAnyType, Exception, string>>()),
      Times.Once);
  }
  
  [Fact]
  public async Task Login_WithInvalidCredentials_ReturnsUnauthorized()
  {
    // Arrange
    var model = new LoginModel
    {
      Email = "test@example.com",
      Password = "WrongPassword"
    };
    
    _userServiceMock
      .Setup(x => x.AuthenticateAsync(model.Email, model.Password))
      .ReturnsAsync(AuthResult.Failed(AuthFailureReason.InvalidCredentials));
    
    // Act
    var result = await _controller.Login(model) as UnauthorizedObjectResult;
    
    // Assert
    Assert.NotNull(result);
    Assert.Equal(401, result.StatusCode);
    
    var value = result.Value as dynamic;
    Assert.Equal("InvalidCredentials", value.errorType);
    
    // Проверяем логирование
    _loggerMock.Verify(
      x => x.Log(
        LogLevel.Warning,
        It.IsAny<EventId>(),
        It.Is<It.IsAnyType>((v, t) => v.ToString().Contains("Неудачная попытка входа")),
        null,
        It.IsAny<Func<It.IsAnyType, Exception, string>>()),
      Times.Once);
  }
}

public class AuthIntegrationTests : IClassFixture<WebApplicationFactory<Startup>>
{
  private readonly WebApplicationFactory<Startup> _factory;
  private readonly HttpClient _client;
  
  public AuthIntegrationTests(WebApplicationFactory<Startup> factory)
  {
    _factory = factory.WithWebHostBuilder(builder =>
    {
      builder.ConfigureServices(services =>
      {
        // Заменяем реальные сервисы на тестовые реализации
        services.AddSingleton<IUserService, TestUserService>();
        services.AddSingleton<IJwtService, TestJwtService>();
      });
    });
    
    _client = _factory.CreateClient();
  }
  
  [Fact]
  public async Task FullLoginFlow_WithValidCredentials_SucceedsAndAccessesProtectedResource()
  {
    // 1. Попытка доступа к защищенному ресурсу без аутентификации
    var unauthResponse = await _client.GetAsync("/api/protected-resource");
    Assert.Equal(HttpStatusCode.Unauthorized, unauthResponse.StatusCode);
    
    // 2. Успешный логин
    var loginResponse = await _client.PostAsJsonAsync("/api/auth/login", new
    {
      Email = "test@example.com",
      Password = "Password123!"
    });
    
    Assert.Equal(HttpStatusCode.OK, loginResponse.StatusCode);
    
    var loginResult = await loginResponse.Content.ReadFromJsonAsync<LoginResult>();
    Assert.NotNull(loginResult.Token);
    
    // 3. Доступ к защищенному ресурсу с токеном
    _client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", loginResult.Token);
    
    var authResponse = await _client.GetAsync("/api/protected-resource");
    Assert.Equal(HttpStatusCode.OK, authResponse.StatusCode);
    
    // 4. Проверяем, что ответ содержит ожидаемые данные
    var content = await authResponse.Content.ReadAsStringAsync();
    Assert.Contains("protected data", content.ToLower());
  }
}

public async Task<TokenResponse> RefreshTokensAsync(string refreshToken)
{
  _logger.LogInformation("Начало обновления токена: {RefreshToken}", refreshToken.Substring(0, 10) + "...");
  
  try
  {
    // Логика обновления
    
    _logger.LogInformation("Токен успешно обновлен");
    return tokenResponse;
  }
  catch (Exception ex)
  {
    _logger.LogError(ex, "Ошибка при обновлении токена");
    throw;
  }
}

/AuthApp
  /AuthApp.API        # ASP.NET Web API проект
    /Controllers      # API контроллеры
    /Models           # Модели данных
    /Services         # Сервисы для бизнес-логики
    /Infrastructure   # Middleware, конфигурация, вспомогательные классы
  
  /AuthApp.Web        # AngularJS SPA проект
    /app
      /auth           # Модуль аутентификации
        /controllers  # Контроллеры для форм логина/регистрации
        /services     # Сервисы для работы с API аутентификации
        /directives   # Директивы для форм и компонентов
        /views        # Представления (HTML-шаблоны)
      /dashboard      # Защищенная часть приложения
      /common         # Общие компоненты

public class User
{
    public int Id { get; set; }
    
    [Required, EmailAddress, MaxLength(100)]
    public string Email { get; set; }
    
    [Required]
    public string PasswordHash { get; set; }
    
    public string PasswordSalt { get; set; }
    
    [MaxLength(100)]
    public string FullName { get; set; }
    
    public bool IsActive { get; set; } = true;
    
    public DateTime CreatedAt { get; set; } = DateTime.UtcNow;
    
    public DateTime? LastLoginDate { get; set; }
}

[Route("api/auth")]
[ApiController]
public class AuthController : ControllerBase
{
    private readonly IUserService _userService;
    private readonly IJwtService _jwtService;
    private readonly ILoginAttemptService _loginAttemptService;
    private readonly ILogger<AuthController> _logger;
    
    public AuthController(
        IUserService userService,
        IJwtService jwtService,
        ILoginAttemptService loginAttemptService,
        ILogger<AuthController> logger)
    {
        _userService = userService;
        _jwtService = jwtService;
        _loginAttemptService = loginAttemptService;
        _logger = logger;
    }
    
    [HttpPost("login")]
    public async Task<IActionResult> Login(LoginModel model)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
            
        var ipAddress = HttpContext.Connection.RemoteIpAddress.ToString();
        var userAgent = Request.Headers["User-Agent"].ToString();
        
        // Проверка на блокировку по превышению лимита попыток
        if (await _loginAttemptService.ExceedsThresholdAsync(ipAddress, 5, TimeSpan.FromMinutes(15)))
        {
            await _loginAttemptService.LogAttemptAsync(model.Email, ipAddress, userAgent, false, "Rate limit exceeded");
            return StatusCode(429, new { message = "Слишком много попыток входа. Попробуйте позже." });
        }
        
        // Аутентификация
        var result = await _userService.AuthenticateAsync(model.Email, model.Password);
        
        if (!result.Succeeded)
        {
            await _loginAttemptService.LogAttemptAsync(model.Email, ipAddress, userAgent, false, result.FailureReason.ToString());
            return Unauthorized(new { message = "Неверный email или пароль" });
        }
        
        // Создаем токены
        var token = _jwtService.GenerateToken(result.User);
        var refreshToken = await _jwtService.GenerateRefreshTokenAsync(result.User, ipAddress);
        
        // Обновляем информацию о входе
        result.User.LastLoginDate = DateTime.UtcNow;
        await _userService.UpdateUserAsync(result.User);
        
        // Логируем успешный вход
        await _loginAttemptService.LogAttemptAsync(model.Email, ipAddress, userAgent, true);
        
        // Устанавливаем refresh токен в HttpOnly cookie
        Response.Cookies.Append("refresh_token", refreshToken, new CookieOptions
        {
            HttpOnly = true,
            Secure = true,
            SameSite = SameSiteMode.Strict,
            Expires = DateTimeOffset.UtcNow.AddDays(30)
        });
        
        return Ok(new
        {
            token,
            user = new { id = result.User.Id, email = result.User.Email, fullName = result.User.FullName }
        });
    }
    
    [HttpPost("refresh")]
    public async Task<IActionResult> RefreshToken()
    {
        var refreshToken = Request.Cookies["refresh_token"];
        if (string.IsNullOrEmpty(refreshToken))
            return Unauthorized(new { message = "Отсутствует refresh токен" });
            
        var ipAddress = HttpContext.Connection.RemoteIpAddress.ToString();
        
        try
        {
            var result = await _jwtService.RefreshTokenAsync(refreshToken, ipAddress);
            
            // Устанавливаем новый refresh токен
            Response.Cookies.Append("refresh_token", result.RefreshToken, new CookieOptions
            {
                HttpOnly = true,
                Secure = true,
                SameSite = SameSiteMode.Strict,
                Expires = DateTimeOffset.UtcNow.AddDays(30)
            });
            
            return Ok(new { token = result.AccessToken });
        }
        catch (SecurityException ex)
        {
            _logger.LogWarning(ex, "Ошибка при обновлении токена");
            return Unauthorized(new { message = ex.Message });
        }
    }
    
    [HttpPost("logout")]
    [Authorize]
    public async Task<IActionResult> Logout()
    {
        var refreshToken = Request.Cookies["refresh_token"];
        if (!string.IsNullOrEmpty(refreshToken))
        {
            await _jwtService.RevokeRefreshTokenAsync(refreshToken);
        }
        
        Response.Cookies.Delete("refresh_token");
        
        return Ok(new { message = "Выход выполнен успешно" });
    }
}

// Кэширование проверенных токенов
public async Task<ClaimsPrincipal> ValidateTokenAsync(string token)
{
    // Сначала проверяем в кэше
    string cacheKey = $"ValidToken:{ComputeHash(token)}";
    
    if (_cache.TryGetValue(cacheKey, out ClaimsPrincipal principal))
    {
        return principal;
    }
    
    // Если в кэше нет, выполняем полную валидацию
    principal = await PerformFullValidationAsync(token);
    
    if (principal != null)
    {
        // Кэшируем результат на время меньше срока действия токена
        var tokenExpiryTime = GetTokenExpiryTime(principal);
        var cacheOptions = new MemoryCacheEntryOptions()
            .SetAbsoluteExpiration(tokenExpiryTime - DateTime.UtcNow - TimeSpan.FromMinutes(1));
            
        _cache.Set(cacheKey, principal, cacheOptions);
    }
    
    return principal;
}