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

protected void Application_BeginRequest()
{
  // Защита от XSS
  Response.Headers.Add("X-XSS-Protection", "1; mode=block");
  
  // Защита от кликджекинга
  Response.Headers.Add("X-Frame-Options", "DENY");
  
  // Защита от MIME-сниффинга
  Response.Headers.Add("X-Content-Type-Options", "nosniff");
  
  // Content Security Policy
  Response.Headers.Add("Content-Security-Policy", "default-src 'self'; script-src 'self'; connect-src 'self'");
}

public ActionResult IssueTokens(User user)
{
  var accessToken = _tokenService.GenerateAccessToken(user);
  var refreshToken = _tokenService.GenerateRefreshToken(user);
  
  // Устанавливаем refresh-токен в защищенную куку
  Response.Cookies.Append("refresh_token", refreshToken, new CookieOptions
  {
      HttpOnly = true,
      Secure = true,
      SameSite = SameSiteMode.Strict,
      Expires = DateTimeOffset.Now.AddDays(30)
  });
  
  // Возвращаем только access-токен
  return Json(new { accessToken = accessToken });
}

// В контроллере
[ValidateAntiForgeryToken]
[HttpPost]
public ActionResult ChangePassword(PasswordChangeModel model)
{
    // Логика смены пароля
}

public void ConfigureServices(IServiceCollection services)
{
  services.AddAntiforgery(options => 
  {
      options.HeaderName = "X-XSRF-TOKEN";
      options.Cookie.Name = "XSRF-TOKEN";
      options.Cookie.HttpOnly = false; // Важно! JavaScript должен иметь доступ к этой куке
      options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
  });
}

var user = db.Users.Where(x => x.Email.Equals(obj.Email) && 
                            x.Password.Equals(obj.Password)).FirstOrDefault();

public class UserService
{
    private readonly UserManager<ApplicationUser> _userManager;
    
    public UserService(UserManager<ApplicationUser> userManager)
    {
        _userManager = userManager;
    }
    
    public async Task<bool> ValidateUserAsync(string email, string password)
    {
        var user = await _userManager.FindByEmailAsync(email);
        if (user == null)
            return false;
            
        return await _userManager.CheckPasswordAsync(user, password);
    }
    
    public async Task<IdentityResult> CreateUserAsync(string email, string password)
    {
        var user = new ApplicationUser { UserName = email, Email = email };
        return await _userManager.CreateAsync(user, password);
    }
}

public static class PasswordHasher
{
    // Генерация хеша с солью
    public static string HashPassword(string password)
    {
        byte[] salt = new byte[16];
        using (var rng = new RNGCryptoServiceProvider())
        {
            rng.GetBytes(salt);
        }
        
        var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 10000);
        byte[] hash = pbkdf2.GetBytes(20);
        
        byte[] hashBytes = new byte[36];
        Array.Copy(salt, 0, hashBytes, 0, 16);
        Array.Copy(hash, 0, hashBytes, 16, 20);
        
        return Convert.ToBase64String(hashBytes);
    }
    
    // Проверка пароля
    public static bool VerifyPassword(string password, string hashedPassword)
    {
        byte[] hashBytes = Convert.FromBase64String(hashedPassword);
        
        byte[] salt = new byte[16];
        Array.Copy(hashBytes, 0, salt, 0, 16);
        
        var pbkdf2 = new Rfc2898DeriveBytes(password, salt, 10000);
        byte[] hash = pbkdf2.GetBytes(20);
        
        for (int i = 0; i < 20; i++)
        {
            if (hashBytes[i + 16] != hash[i])
                return false;
        }
        
        return true;
    }
}

// В Startup.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddAntiforgery(options => 
    {
        options.HeaderName = "X-XSRF-TOKEN";
        options.Cookie.Name = "XSRF-TOKEN";
        options.Cookie.HttpOnly = false; // JavaScript должен иметь доступ к куке
        options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    });
}

[HttpPost]
[ValidateAntiForgeryToken]
public ActionResult VerifyUser(UserModel model)
{
    // Логика проверки пользователя
}

[Route("api/csrf/token")]
public IActionResult GetAntiforgeryToken()
{
    var tokens = _antiforgery.GetAndStoreTokens(HttpContext);
    Response.Cookies.Append("XSRF-TOKEN", tokens.RequestToken, 
        new CookieOptions { HttpOnly = false, Secure = true });
    
    return Ok();
}

public class AntiforgeryMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IAntiforgery _antiforgery;
    
    public AntiforgeryMiddleware(RequestDelegate next, IAntiforgery antiforgery)
    {
        _next = next;
        _antiforgery = antiforgery;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        if (context.Request.Method == "GET" && 
            context.Request.Path.Value.StartsWith("/api"))
        {
            // Для API-запросов генерируем токен
            var tokens = _antiforgery.GetAndStoreTokens(context);
            context.Response.Cookies.Append("XSRF-TOKEN", tokens.RequestToken, 
                new CookieOptions { HttpOnly = false, Secure = true });
        }
        
        await _next(context);
    }
}

public class RateLimitMiddleware
{
    private static readonly Dictionary<string, Queue<DateTime>> _requestStore = 
        new Dictionary<string, Queue<DateTime>>();
    private readonly RequestDelegate _next;
    private readonly int _maxRequests;
    private readonly TimeSpan _interval;
    
    public RateLimitMiddleware(RequestDelegate next, int maxRequests = 3, int intervalInSeconds = 60)
    {
        _next = next;
        _maxRequests = maxRequests;
        _interval = TimeSpan.FromSeconds(intervalInSeconds);
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        var endpoint = context.GetEndpoint()?.DisplayName;
        
        // Применяем только к эндпоинтам авторизации
        if (endpoint != null && endpoint.Contains("auth"))
        {
            var key = GetClientKey(context);
            var now = DateTime.UtcNow;
            
            // Очистка устаревших записей
            CleanupRequests(key, now);
            
            // Проверка лимита
            if (IsRateLimited(key, now))
            {
                context.Response.StatusCode = 429; // Too Many Requests
                context.Response.Headers.Add("Retry-After", _interval.TotalSeconds.ToString());
                await context.Response.WriteAsync("Слишком много запросов. Попробуйте позже.");
                return;
            }
            
            // Регистрация запроса
            RegisterRequest(key, now);
        }
        
        await _next(context);
    }
    
    private string GetClientKey(HttpContext context)
    {
        // Используем IP-адрес + путь запроса как ключ
        return $"{context.Connection.RemoteIpAddress}_{context.Request.Path}";
    }
    
    private void CleanupRequests(string key, DateTime now)
    {
        if (!_requestStore.ContainsKey(key))
        {
            _requestStore[key] = new Queue<DateTime>();
            return;
        }
        
        while (_requestStore[key].Count > 0 && now - _requestStore[key].Peek() > _interval)
        {
            _requestStore[key].Dequeue();
        }
    }
    
    private bool IsRateLimited(string key, DateTime now)
    {
        return _requestStore.ContainsKey(key) && _requestStore[key].Count >= _maxRequests;
    }
    
    private void RegisterRequest(string key, DateTime now)
    {
        if (!_requestStore.ContainsKey(key))
        {
            _requestStore[key] = new Queue<DateTime>();
        }
        
        _requestStore[key].Enqueue(now);
    }
}

public void Configure(IApplicationBuilder app)
{
    // Другие middleware...
    
    // Ограничиваем запросы к API авторизации: 5 запросов в минуту
    app.UseMiddleware<RateLimitMiddleware>(5, 60);
    
    // Rest of the pipeline...
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy("AuthCorsPolicy", builder =>
        {
            builder.WithOrigins("https://ваш-фронтенд-домен.com")
                   .AllowCredentials()
                   .WithMethods("GET", "POST")
                   .WithHeaders("Content-Type", "Authorization", "X-XSRF-TOKEN");
        });
    });
    
    // Другие сервисы...
}
 
public void Configure(IApplicationBuilder app)
{
    // Другие middleware...
    
    app.UseCors("AuthCorsPolicy");
    
    // Остальной конвейер...
}

public void ConfigureServices(IServiceCollection services)
{
    var allowedOrigins = Configuration.GetSection("AllowedOrigins").Get<string[]>();
    
    services.AddCors(options =>
    {
        options.AddPolicy("AuthCorsPolicy", builder =>
        {
            builder.WithOrigins(allowedOrigins)
                   .AllowCredentials()
                   .WithMethods("GET", "POST")
                   .WithHeaders("Content-Type", "Authorization", "X-XSRF-TOKEN");
        });
    });
}

public class JwtService
{
    private readonly string _secret;
    private readonly string _issuer;
    private readonly string _audience;
    private readonly int _expirationMinutes;
 
    public JwtService(IConfiguration configuration)
    {
        _secret = configuration["Jwt:Secret"];
        _issuer = configuration["Jwt:Issuer"];
        _audience = configuration["Jwt:Audience"];
        _expirationMinutes = int.Parse(configuration["Jwt:ExpirationMinutes"]);
    }
 
    public string GenerateToken(User user)
    {
        var securityKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_secret));
        var credentials = new SigningCredentials(securityKey, SecurityAlgorithms.HmacSha256);
 
        var claims = new[]
        {
            new Claim(JwtRegisteredClaimNames.Sub, user.Id.ToString()),
            new Claim(JwtRegisteredClaimNames.Email, user.Email),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString())
        };
 
        var token = new JwtSecurityToken(
            issuer: _issuer,
            audience: _audience,
            claims: claims,
            expires: DateTime.Now.AddMinutes(_expirationMinutes),
            signingCredentials: credentials
        );
 
        return new JwtSecurityTokenHandler().WriteToken(token);
    }
 
    public ClaimsPrincipal ValidateToken(string token)
    {
        var tokenHandler = new JwtSecurityTokenHandler();
        var key = Encoding.UTF8.GetBytes(_secret);
        
        var validationParameters = new TokenValidationParameters
        {
            ValidateIssuerSigningKey = true,
            IssuerSigningKey = new SymmetricSecurityKey(key),
            ValidateIssuer = true,
            ValidIssuer = _issuer,
            ValidateAudience = true,
            ValidAudience = _audience,
            ValidateLifetime = true,
            ClockSkew = TimeSpan.Zero
        };
 
        SecurityToken validatedToken;
        return tokenHandler.ValidateToken(token, validationParameters, out validatedToken);
    }
}

public class RefreshTokenService
{
    private readonly ApplicationDbContext _context;
    private readonly JwtService _jwtService;
    private readonly IConfiguration _configuration;
 
    public RefreshTokenService(ApplicationDbContext context, JwtService jwtService, IConfiguration configuration)
    {
        _context = context;
        _jwtService = jwtService;
        _configuration = configuration;
    }
 
    public async Task<string> GenerateRefreshToken(User user)
    {
        var randomNumber = new byte[32];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(randomNumber);
        }
        
        var refreshToken = Convert.ToBase64String(randomNumber);
        
        // Сохраняем токен в базе с привязкой к пользователю
        _context.RefreshTokens.Add(new RefreshToken
        {
            Token = refreshToken,
            UserId = user.Id,
            ExpiryDate = DateTime.Now.AddDays(30), // 30 дней на рефреш
            IssuedDate = DateTime.Now,
            IsRevoked = false
        });
        
        await _context.SaveChangesAsync();
        
        return refreshToken;
    }
 
    public async Task<(string accessToken, string refreshToken)> RefreshTokens(string refreshToken)
    {
        var storedToken = await _context.RefreshTokens
            .Include(r => r.User)
            .FirstOrDefaultAsync(r => r.Token == refreshToken && !r.IsRevoked);
        
        if (storedToken == null || storedToken.ExpiryDate < DateTime.Now)
        {
            throw new SecurityException("Invalid or expired refresh token");
        }
        
        // Генерируем новый access token
        var accessToken = _jwtService.GenerateToken(storedToken.User);
        
        // Опционально: выпускаем новый refresh token и отзываем старый
        var newRefreshToken = await GenerateRefreshToken(storedToken.User);
        storedToken.IsRevoked = true;
        await _context.SaveChangesAsync();
        
        return (accessToken, newRefreshToken);
    }
}

public class RememberMeService
{
    private readonly ApplicationDbContext _context;
    private readonly IConfiguration _config;
    
    public RememberMeService(ApplicationDbContext context, IConfiguration config)
    {
        _context = context;
        _config = config;
    }
    
    public string GenerateRememberMeToken(int userId)
    {
        var tokenBytes = new byte[64];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(tokenBytes);
        }
        
        var token = Convert.ToBase64String(tokenBytes);
        var selector = Guid.NewGuid().ToString();
        
        // Хешируем токен перед сохранением в базе
        var hashedToken = HashToken(token);
        
        // Сохраняем запись в базе данных
        _context.RememberMeTokens.Add(new RememberMeToken
        {
            Selector = selector,
            HashedToken = hashedToken,
            UserId = userId,
            ExpiryDate = DateTime.UtcNow.AddMonths(3) // Срок действия 3 месяца
        });
        
        _context.SaveChanges();
        
        // Возвращаем комбинацию селектора и токена
        return $"{selector}:{token}";
    }
    
    public int? ValidateRememberMeToken(string tokenString)
    {
        if (string.IsNullOrEmpty(tokenString) || !tokenString.Contains(":"))
            return null;
            
        var parts = tokenString.Split(':');
        var selector = parts[0];
        var token = parts[1];
        
        var storedToken = _context.RememberMeTokens
            .FirstOrDefault(t => t.Selector == selector && t.ExpiryDate > DateTime.UtcNow);
            
        if (storedToken == null)
            return null;
            
        // Проверяем токен
        if (VerifyToken(token, storedToken.HashedToken))
            return storedToken.UserId;
            
        return null;
    }
    
    private string HashToken(string token)
    {
        using (var sha256 = SHA256.Create())
        {
            var bytes = Encoding.UTF8.GetBytes(token + _config["RememberMeSecret"]);
            var hash = sha256.ComputeHash(bytes);
            return Convert.ToBase64String(hash);
        }
    }
    
    private bool VerifyToken(string token, string hashedToken)
    {
        return HashToken(token) == hashedToken;
    }
}

[HttpPost("login")]
public IActionResult Login([FromBody] LoginModel model)
{
    // Аутентификация...
    
    if (model.RememberMe)
    {
        var token = _rememberMeService.GenerateRememberMeToken(user.Id);
        
        Response.Cookies.Append("remember_me", token, new CookieOptions
        {
            HttpOnly = true,  // JavaScript не сможет прочитать
            Secure = true,    // Только по HTTPS
            SameSite = SameSiteMode.Strict,  // Защита от CSRF
            Expires = DateTimeOffset.UtcNow.AddMonths(3)
        });
    }
    
    // Дальнейшая логика...
}

public class TokenRotationService
{
    private readonly ApplicationDbContext _context;
    private readonly JwtService _jwtService;
    
    public TokenRotationService(ApplicationDbContext context, JwtService jwtService)
    {
        _context = context;
        _jwtService = jwtService;
    }
    
    public async Task<TokenResponse> RotateTokensAsync(string refreshToken)
    {
        // Проверяем, существует ли токен в базе
        var storedToken = await _context.RefreshTokens
            .Include(rt => rt.User)
            .FirstOrDefaultAsync(rt => rt.Token == refreshToken && !rt.IsRevoked);
        
        if (storedToken == null)
            throw new SecurityException("Недействительный refresh токен");
            
        if (storedToken.ExpiryDate < DateTime.UtcNow)
            throw new SecurityException("Истекший refresh токен");
        
        // Отзываем старый токен
        storedToken.IsRevoked = true;
        
        // Создаем новый refresh токен
        var newRefreshToken = await CreateRefreshTokenAsync(storedToken.User);
        
        // Создаем новый access токен
        var accessToken = _jwtService.GenerateToken(storedToken.User);
        
        await _context.SaveChangesAsync();
        
        return new TokenResponse
        {
            AccessToken = accessToken,
            RefreshToken = newRefreshToken.Token,
            ExpiresIn = 900 // 15 минут в секундах
        };
    }
    
    private async Task<RefreshToken> CreateRefreshTokenAsync(User user)
    {
        var token = new RefreshToken
        {
            Token = GenerateUniqueToken(),
            User = user,
            IssuedAt = DateTime.UtcNow,
            ExpiryDate = DateTime.UtcNow.AddDays(30),
            IsRevoked = false
        };
        
        _context.RefreshTokens.Add(token);
        
        return token;
    }
    
    private string GenerateUniqueToken()
    {
        // Генерируем случайный токен, пока не найдем уникальный
        while (true)
        {
            var tokenBytes = new byte[64];
            using (var rng = RandomNumberGenerator.Create())
            {
                rng.GetBytes(tokenBytes);
            }
            
            var token = Convert.ToBase64String(tokenBytes);
            
            if (!_context.RefreshTokens.Any(rt => rt.Token == token))
                return token;
        }
    }
}

public async Task<TokenResponse> RotateTokensAsync(string refreshToken, string ipAddress)
{
    var storedToken = await _context.RefreshTokens
        .FirstOrDefaultAsync(rt => rt.Token == refreshToken);
        
    // Проверяем IP-адрес, если он сохранен
    if (storedToken.IpAddress != null && storedToken.IpAddress != ipAddress)
    {
        // Возможная кража токена! Отзываем все токены пользователя
        await RevokeAllUserTokensAsync(storedToken.UserId);
        throw new SecurityException("Подозрительная активность. Все сессии завершены.");
    }
    
    // Остальная логика...
}

public async Task RevokeTokenFamilyAsync(string refreshToken)
{
    var token = await _context.RefreshTokens
        .FirstOrDefaultAsync(rt => rt.Token == refreshToken);
        
    if (token == null) return;
    
    // Отзываем все токены с тем же FamilyId
    var familyTokens = await _context.RefreshTokens
        .Where(rt => rt.FamilyId == token.FamilyId)
        .ToListAsync();
        
    foreach (var familyToken in familyTokens)
    {
        familyToken.IsRevoked = true;
    }
    
    await _context.SaveChangesAsync();
}

public class TwoFactorSettings
{
    public int UserId { get; set; }
    public bool IsEnabled { get; set; }
    public string SecretKey { get; set; }  // Секретный ключ для TOTP
    public string RecoveryCodesJson { get; set; }  // Резервные коды в JSON
    public DateTime LastUpdated { get; set; }
    
    // Навигационное свойство
    public User User { get; set; }
}

public class TwoFactorService
{
    private readonly ApplicationDbContext _context;
    private readonly UserManager<User> _userManager;
    
    public TwoFactorService(ApplicationDbContext context, UserManager<User> userManager)
    {
        _context = context;
        _userManager = userManager;
    }
    
    public async Task<string> GenerateSecretKeyAsync(int userId)
    {
        // Генерируем случайный секретный ключ
        byte[] secretBytes = new byte[20];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(secretBytes);
        }
        
        var secretKey = Base32Encode(secretBytes);
        
        // Сохраняем в базе
        var settings = await _context.TwoFactorSettings.FirstOrDefaultAsync(s => s.UserId == userId);
        if (settings == null)
        {
            settings = new TwoFactorSettings
            {
                UserId = userId,
                IsEnabled = false,
                SecretKey = secretKey,
                LastUpdated = DateTime.UtcNow
            };
            _context.TwoFactorSettings.Add(settings);
        }
        else
        {
            settings.SecretKey = secretKey;
            settings.LastUpdated = DateTime.UtcNow;
        }
        
        await _context.SaveChangesAsync();
        return secretKey;
    }
    
    public async Task<bool> ValidateCodeAsync(int userId, string code)
    {
        var settings = await _context.TwoFactorSettings.FirstOrDefaultAsync(s => s.UserId == userId);
        if (settings == null || !settings.IsEnabled)
            return false;
            
        // Получаем пользователя
        var user = await _userManager.FindByIdAsync(userId.ToString());
        if (user == null)
            return false;
            
        return await _userManager.VerifyTwoFactorTokenAsync(
            user, 
            TokenOptions.DefaultAuthenticatorProvider, 
            code);
    }
    
    // Метод для создания резервных кодов
    public async Task<List<string>> GenerateRecoveryCodesAsync(int userId, int count = 8)
    {
        var codes = new List<string>();
        for (int i = 0; i < count; i++)
        {
            // Генерируем 8-символьный код
            var code = GenerateRandomCode(8);
            codes.Add(code);
        }
        
        var settings = await _context.TwoFactorSettings.FirstOrDefaultAsync(s => s.UserId == userId);
        if (settings != null)
        {
            settings.RecoveryCodesJson = JsonSerializer.Serialize(codes);
            await _context.SaveChangesAsync();
        }
        
        return codes;
    }
    
    private string Base32Encode(byte[] data)
    {
        // Реализация Base32 кодирования
        // (упрощено для краткости)
        return Convert.ToBase64String(data).Replace("=", "").Replace("/", "").Replace("+", "");
    }
    
    private string GenerateRandomCode(int length)
    {
        const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        var random = new Random();
        return new string(Enumerable.Repeat(chars, length)
            .Select(s => s[random.Next(s.Length)]).ToArray());
    }
}

[Route("api/auth/2fa")]
public class TwoFactorController : Controller
{
    private readonly TwoFactorService _twoFactorService;
    
    public TwoFactorController(TwoFactorService twoFactorService)
    {
        _twoFactorService = twoFactorService;
    }
    
    [HttpGet("setup")]
    [Authorize]
    public async Task<IActionResult> Setup()
    {
        var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
        var secretKey = await _twoFactorService.GenerateSecretKeyAsync(userId);
        
        return Ok(new
        {
            SecretKey = secretKey,
            QrCodeUrl = $"otpauth://totp/MyApp:{User.Identity.Name}?secret={secretKey}&issuer=MyApp"
        });
    }
    
    [HttpPost("verify")]
    [Authorize]
    public async Task<IActionResult> Verify([FromBody] VerifyTwoFactorModel model)
    {
        var userId = int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value);
        var isValid = await _twoFactorService.ValidateCodeAsync(userId, model.Code);
        
        if (!isValid)
            return BadRequest(new { Message = "Неверный код" });
            
        // Включаем 2FA для пользователя
        await _twoFactorService.EnableTwoFactorAsync(userId);
        
        // Генерируем резервные коды
        var recoveryCodes = await _twoFactorService.GenerateRecoveryCodesAsync(userId);
        
        return Ok(new
        {
            Success = true,
            RecoveryCodes = recoveryCodes
        });
    }
    
    [HttpPost("login")]
    public async Task<IActionResult> Login([FromBody] TwoFactorLoginModel model)
    {
        // Проверяем временный токен, полученный после первого этапа входа
        var userId = GetUserIdFromTemporaryToken(model.TempToken);
        if (!userId.HasValue)
            return Unauthorized();
            
        var isValid = await _twoFactorService.ValidateCodeAsync(userId.Value, model.Code);
        if (!isValid)
            return BadRequest(new { Message = "Неверный код аутентификации" });
            
        // Генерируем полноценные токены доступа и обновления
        var tokens = GenerateTokens(userId.Value);
        
        return Ok(tokens);
    }
    
    // Вспомогательные методы опущены для краткости
}