Хеширование и соль паролей в веб-приложениях C#

// НЕ ИСПОЛЬЗУЙТЕ ЭТОТ КОД В РЕАЛЬНЫХ ПРОЕКТАХ!
using System.Security.Cryptography;
using System.Text;
 
public static string GetMd5Hash(string input)
{
    using (MD5 md5 = MD5.Create())
    {
        byte[] inputBytes = Encoding.ASCII.GetBytes(input);
        byte[] hashBytes = md5.ComputeHash(inputBytes);
        
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < hashBytes.Length; i++)
        {
            sb.Append(hashBytes[i].ToString("x2"));
        }
        return sb.ToString();
    }
}

public static string HashPasswordWithPbkdf2(string password, byte[] salt, int iterations = 10000)
{
    using (var pbkdf2 = new Rfc2898DeriveBytes(password, salt, iterations))
    {
        byte[] hash = pbkdf2.GetBytes(32); // 256 bits
        return Convert.ToBase64String(hash);
    }
}

// Установите пакет: Install-Package BCrypt.Net-Next
using BCrypt.Net;
 
public static string HashPasswordWithBcrypt(string password)
{
    // WorkFactor контролирует сложность и время вычисления
    return BCrypt.HashPassword(password, workFactor: 12);
}
 
public static bool VerifyBcryptPassword(string password, string hash)
{
    return BCrypt.Verify(password, hash);
}

// Установите пакет: Install-Package Konscious.Security.Cryptography.Argon2
using Konscious.Security.Cryptography;
using System.Text;
 
public static string HashPasswordWithArgon2id(string password, byte[] salt)
{
    using (var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password)))
    {
        argon2.Salt = salt;
        argon2.DegreeOfParallelism = 8; // Зависит от количества ядер CPU
        argon2.Iterations = 4;
        argon2.MemorySize = 1024 * 1024; // 1 GB в KB
        
        byte[] hash = argon2.GetBytes(32);
        return Convert.ToBase64String(hash);
    }
}

PBKDF2 с HMAC-SHA256, 128-bit соль, 256-bit ключ, 10000 итераций.
Формат: { 0x00, соль, итерации, хеш }

public class PasswordHasher
{
    // Версии алгоритмов
    private const byte PBKDF2_VERSION = 0x01;
    private const byte BCRYPT_VERSION = 0x02;
    private const byte ARGON2_VERSION = 0x03;
    
    // Текущий алгоритм по умолчанию
    private readonly byte _currentVersion = ARGON2_VERSION;
    
    public string HashPassword(string password)
    {
        // Используем текущую версию
        switch (_currentVersion)
        {
            case ARGON2_VERSION:
                return HashWithArgon2(password);
            // Другие случаи...
            default:
                throw new NotSupportedException();
        }
    }
    
    public bool VerifyPassword(string password, string hashedPassword)
    {
        // Определяем версию из хеша
        byte version = ExtractVersion(hashedPassword);
        
        // Вызываем соответствующий метод проверки
        switch (version)
        {
            case PBKDF2_VERSION:
                return VerifyPbkdf2(password, hashedPassword);
            // Другие случаи...
            default:
                return false;
        }
    }
    
    private byte ExtractVersion(string hashedPassword)
    {
        // Извлекаем версию из формата хеша
        byte[] hashBytes = Convert.FromBase64String(hashedPassword);
        return hashBytes[0];
    }
    
    // Методы для конкретных алгоритмов...
}

public async Task<string> HashPasswordAsync(string password)
{
    return await Task.Run(() => 
    {
        using (var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password)))
        {
            // Настройка параметров...
            return Convert.ToBase64String(argon2.GetBytes(32));
        }
    });
}

if (System.Runtime.Intrinsics.X86.Aes.IsSupported)
{
    // Используем аппаратно-ускоренный алгоритм
}
else
{
    // Используем программную реализацию
}

public bool VerifyAndUpdateIfNeeded(string password, ref string storedHash)
{
    // Проверяем пароль текущим методом
    if (!VerifyPassword(password, storedHash))
        return false;
        
    // Проверяем, нуждается ли хеш в обновлении
    if (NeedsUpgrade(storedHash))
    {
        // Если да, создаём новый хеш с современными параметрами
        storedHash = HashPassword(password);
        // Сохраняем обновлённый хеш в базу данных
        UpdateHashInDatabase(userId, storedHash);
    }
    
    return true;
}

public class HashCalibrator
{
    public static int CalibrateArgon2Parameters(TimeSpan targetTime)
    {
        int memorySize = 1024 * 64; // Начинаем с 64 MB
        int iterations = 3;
        
        while (true)
        {
            var sw = Stopwatch.StartNew();
            
            // Тестируем текущие параметры
            using (var argon2 = new Argon2id(Encoding.UTF8.GetBytes("calibration_test")))
            {
                argon2.Salt = new byte[16]; // Фиктивная соль
                argon2.DegreeOfParallelism = Environment.ProcessorCount;
                argon2.Iterations = iterations;
                argon2.MemorySize = memorySize;
                argon2.GetBytes(32);
            }
            
            sw.Stop();
            
            // Если близко к целевому времени, возвращаем параметры
            if (sw.Elapsed > targetTime * 0.8 && sw.Elapsed < targetTime * 1.2)
                return memorySize;
                
            // Корректируем параметры
            if (sw.Elapsed < targetTime / 2)
                memorySize *= 2;
            else if (sw.Elapsed < targetTime)
                memorySize = (int)(memorySize * 1.5);
            else if (sw.Elapsed > targetTime * 2)
                memorySize /= 2;
            else
                memorySize = (int)(memorySize * 0.8);
                
            // Страховка от бесконечного цикла
            if (memorySize < 1024)
                return 1024 * 64; // Возвращаем дефолтное значение
        }
    }
}

private static ThreadLocal<HMACSHA256> _hmac = new ThreadLocal<HMACSHA256>(() => 
    new HMACSHA256(GetMasterKey()));
 
public static byte[] ComputeHmac(byte[] data)
{
    return _hmac.Value.ComputeHash(data);
}

// Вот как можно настроить Argon2 для максимального противодействия аппаратным атакам
public static string HardwareResistantHash(string password, byte[] salt)
{
    using (var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password)))
    {
        argon2.Salt = salt;
        argon2.DegreeOfParallelism = 1; // Важно! Меньше параллелизм = больше защита от GPU
        argon2.Iterations = 3;          // Минимальное значение, компенсируемое большим объемом памяти
        argon2.MemorySize = 1024 * 1024; // 1 GB - делает атаки на GPU экономически невыгодными
        
        return Convert.ToBase64String(argon2.GetBytes(32));
    }
}

public bool VerifyPasswordWithGradualUpgrade(string password, ref string storedHash)
{
    if (storedHash.StartsWith("$MD5$"))
    {
        // Извлекаем MD5 хеш
        string md5Hash = ExtractHash(storedHash);
        
        // Проверяем по старому алгоритму
        string computedMd5 = GetMd5Hash(password);
        if (md5Hash != computedMd5)
            return false;
            
        // Успех! Обновляем на современный алгоритм
        storedHash = HashWithArgon2(password);
        UpdateHashInDatabase(userId, storedHash);
        return true;
    }
    else if (storedHash.StartsWith("$PBKDF2$"))
    {
        // Аналогичная логика для PBKDF2
        // ...
    }
    else
    {
        // Современный алгоритм (Argon2)
        return VerifyArgon2(password, storedHash);
    }
}

// Интеграция с Azure Key Vault для безопасного хранения криптографических ключей
public async Task<byte[]> GetMasterKeyFromKeyVault()
{
    var keyVaultClient = new KeyVaultClient(GetTokenAsync);
    var secret = await keyVaultClient.GetSecretAsync("https://yourvault.vault.azure.net/secrets/MasterKey");
    return Convert.FromBase64String(secret.Value);
}

// Перец - секретное значение, общее для всего приложения
private static readonly byte[] _pepper = GetSecretPepper();
 
public static string HashWithPepper(string password, byte[] salt)
{
    // Комбинируем пароль с перцем перед хешированием
    byte[] pepperredPassword = CombinePasswordAndPepper(password, _pepper);
    
    // Далее обычное хеширование с солью
    using (var argon2 = new Argon2id(pepperredPassword))
    {
        argon2.Salt = salt;
        // ...остальные параметры...
        return Convert.ToBase64String(argon2.GetBytes(32));
    }
}

public static byte[] GenerateSecureSalt(int size = 16)
{
var salt = new byte[size];
using (var rng = RandomNumberGenerator.Create())
{
    rng.GetBytes(salt);
}
return salt;
}

// НЕ ДЕЛАЙТЕ ТАК НИКОГДА!
var random = new Random();
var salt = new byte[16];
random.NextBytes(salt);

{алгоритм}${параметры}${соль}${хеш}

public class SaltedPasswordHasher
{
public string HashPassword(string password)
{
    // Генерируем соль
    byte[] salt = GenerateSecureSalt();
    
    // Создаём экземпляр Argon2
    using (var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password)))
    {
        // Настраиваем параметры
        argon2.Salt = salt;
        argon2.DegreeOfParallelism = 8;
        argon2.Iterations = 4;
        argon2.MemorySize = 65536; // 64 MB
        
        // Получаем хеш
        byte[] hash = argon2.GetBytes(32);
        
        // Создаём составной результат: ALGONAME${параметры}${соль}${хеш}
        return FormatHashResult("ARGON2ID", new {
            Parallelism = 8,
            Iterations = 4,
            MemorySize = 65536
        }, salt, hash);
    }
}
 
public bool VerifyPassword(string password, string hashString)
{
    // Разбираем строку хеша
    var components = ParseHashString(hashString);
    
    // Извлекаем соль и параметры
    byte[] salt = components.Salt;
    var parameters = components.Parameters;
    
    // Повторяем процесс хеширования с той же солью и параметрами
    using (var argon2 = new Argon2id(Encoding.UTF8.GetBytes(password)))
    {
        argon2.Salt = salt;
        argon2.DegreeOfParallelism = parameters.Parallelism;
        argon2.Iterations = parameters.Iterations;
        argon2.MemorySize = parameters.MemorySize;
        
        byte[] computedHash = argon2.GetBytes(32);
        
        // Сравниваем вычисленный хеш с сохранённым
        return SlowEquals(computedHash, components.Hash);
    }
}
 
// Безопасное сравнение хешей с защитой от атак по времени
private bool SlowEquals(byte[] a, byte[] b)
{
    uint diff = (uint)a.Length ^ (uint)b.Length;
    for (int i = 0; i < a.Length && i < b.Length; i++)
        diff |= (uint)(a[i] ^ b[i]);
    return diff == 0;
}
 
// Вспомогательные методы...
}

public class UserService
{
private readonly IPasswordHasher _passwordHasher;
private readonly IUserRepository _userRepository;
 
public UserService(IPasswordHasher passwordHasher, IUserRepository userRepository)
{
    _passwordHasher = passwordHasher;
    _userRepository = userRepository;
}
 
public async Task<bool> RegisterUserAsync(string username, string password)
{
    // Проверяем, что пользователь не существует
    if (await _userRepository.ExistsByUsernameAsync(username))
        return false;
        
    // Хешируем пароль (включая генерацию соли)
    string hashedPassword = _passwordHasher.HashPassword(password);
    
    // Создаём нового пользователя
    var user = new User
    {
        Username = username,
        PasswordHash = hashedPassword,
        CreatedAt = DateTime.UtcNow
    };
    
    // Сохраняем в базу
    await _userRepository.CreateAsync(user);
    return true;
}
 
public async Task<bool> AuthenticateAsync(string username, string password)
{
    // Находим пользователя
    User user = await _userRepository.GetByUsernameAsync(username);
    if (user == null)
        return false;
        
    // Проверяем пароль
    bool isValid = _passwordHasher.VerifyPassword(password, user.PasswordHash);
    
    // Обновляем хеш, если алгоритм устарел
    if (isValid && _passwordHasher.NeedsUpgrade(user.PasswordHash))
    {
        user.PasswordHash = _passwordHasher.HashPassword(password);
        await _userRepository.UpdateAsync(user);
    }
    
    return isValid;
}
}

// Класс для работы с "поперченными" паролями
public class PepperedPasswordHasher
{
    // Перец хранится в конфигурации или секретном хранилище, а не в базе данных
    private readonly byte[] _pepper;
    
    public PepperedPasswordHasher(ISecretManager secretManager)
    {
        _pepper = secretManager.GetSecret("PASSWORD_PEPPER");
    }
    
    public string HashPassword(string password)
    {
        // Генерируем соль
        byte[] salt = GenerateSecureSalt();
        
        // Комбинируем пароль с перцем перед хешированием
        string pepperedPassword = ApplyPepper(password, _pepper);
        
        // Далее хешируем уже "поперченный" пароль с солью
        return HashWithSalt(pepperedPassword, salt);
    }
    
    private string ApplyPepper(string password, byte[] pepper)
    {
        // Один из способов применения перца - HMAC
        using (var hmac = new HMACSHA256(pepper))
        {
            byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
            byte[] pepperedBytes = hmac.ComputeHash(passwordBytes);
            return Convert.ToBase64String(pepperedBytes);
        }
    }
    
    // Остальные методы...
}

public bool VerifyPassword(string password, User user)
{
    bool isValid = false;
    bool needsUpgrade = false;
    
    switch (user.HashAlgorithm)
    {
        case "MD5":
            isValid = VerifyMd5(password, user.PasswordHash);
            needsUpgrade = true;
            break;
        case "PBKDF2":
            isValid = VerifyPbkdf2(password, user.PasswordHash, user.Salt);
            // Обновляем только если количество итераций устарело
            needsUpgrade = user.Iterations < _currentMinIterations;
            break;
        case "ARGON2ID":
            isValid = VerifyArgon2id(password, user.PasswordHash, user.Salt);
            break;
        default:
            throw new NotSupportedException($"Алгоритм {user.HashAlgorithm} не поддерживается");
    }
    
    // Обновляем хеш, если необходимо
    if (isValid && needsUpgrade)
    {
        UpgradePasswordHash(user, password);
    }
    
    return isValid;
}

// Модель пользователя
public class User
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    public string PasswordHash { get; set; }
    public DateTime CreatedAt { get; set; }
    public DateTime? LastLogin { get; set; }
}
 
// Интерфейс для сервиса паролей
public interface IPasswordService
{
    string HashPassword(string password);
    bool VerifyPassword(string password, string hash);
    bool NeedsRehash(string hash);
}
 
// Реализация на базе Argon2
public class Argon2PasswordService : IPasswordService
{
    private readonly IConfiguration _config;
    private readonly byte[] _pepper;
    
    public Argon2PasswordService(IConfiguration config, ISecretProvider secretProvider)
    {
        _config = config;
        _pepper = secretProvider.GetSecret("AUTH_PEPPER");
    }
    
    public string HashPassword(string password)
    {
        // Генерируем соль
        byte[] salt = new byte[16];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(salt);
        }
        
        // Применяем "перец" к паролю
        byte[] passwordBytes = Encoding.UTF8.GetBytes(password);
        byte[] pepperedPassword;
        using (var hmac = new HMACSHA256(_pepper))
        {
            pepperedPassword = hmac.ComputeHash(passwordBytes);
        }
        
        // Хешируем с Argon2id
        using (var argon2 = new Argon2id(pepperedPassword))
        {
            argon2.Salt = salt;
            argon2.DegreeOfParallelism = _config.GetValue<int>("PasswordSecurity:Parallelism");
            argon2.Iterations = _config.GetValue<int>("PasswordSecurity:Iterations");
            argon2.MemorySize = _config.GetValue<int>("PasswordSecurity:MemorySize");
            
            byte[] hash = argon2.GetBytes(32);
            
            // Формат: версия|параметры|соль|хеш
            return FormatHashString(1, argon2, salt, hash);
        }
    }
    
    // Остальные методы...
}

[Route("account")]
public class AccountController : Controller
{
    private readonly IPasswordService _passwordService;
    private readonly IUserRepository _userRepository;
    private readonly ILogger<AccountController> _logger;
    
    // ... конструктор с DI ...
    
    [HttpPost("register")]
    public async Task<IActionResult> Register(RegisterViewModel model)
    {
        if (!ModelState.IsValid)
            return View(model);
            
        // Проверяем, не существует ли пользователь
        if (await _userRepository.ExistsByEmailAsync(model.Email))
        {
            ModelState.AddModelError("Email", "Этот email уже зарегистрирован");
            return View(model);
        }
        
        // Создаём пользователя с хешированным паролем
        var user = new User
        {
            Username = model.Username,
            Email = model.Email,
            PasswordHash = _passwordService.HashPassword(model.Password),
            CreatedAt = DateTime.UtcNow
        };
        
        await _userRepository.CreateAsync(user);
        
        // Логируем событие (без чувствительных данных!)
        _logger.LogInformation("User registered: {Username}", user.Username);
        
        return RedirectToAction("Login");
    }
    
    [HttpPost("login")]
    public async Task<IActionResult> Login(LoginViewModel model)
    {
        if (!ModelState.IsValid)
            return View(model);
            
        var user = await _userRepository.GetByEmailAsync(model.Email);
        if (user == null)
        {
            // Важно! Одинаковое сообщение независимо от причины ошибки
            ModelState.AddModelError("", "Неверный email или пароль");
            return View(model);
        }
        
        // Проверяем пароль
        if (!_passwordService.VerifyPassword(model.Password, user.PasswordHash))
        {
            // Замедляем ответ для защиты от timing-атак
            await Task.Delay(Random.Shared.Next(100, 200));
            
            ModelState.AddModelError("", "Неверный email или пароль");
            return View(model);
        }
        
        // Проверяем, нужно ли обновить хеш до более современного
        if (_passwordService.NeedsRehash(user.PasswordHash))
        {
            user.PasswordHash = _passwordService.HashPassword(model.Password);
            await _userRepository.UpdateAsync(user);
        }
        
        // Обновляем время последнего входа
        user.LastLogin = DateTime.UtcNow;
        await _userRepository.UpdateAsync(user);
        
        // Аутентифицируем пользователя...
        // ...
        
        return RedirectToAction("Index", "Home");
    }
}

public class CustomPasswordHasher<TUser> : IPasswordHasher<TUser> where TUser : class
{
    private readonly IPasswordService _passwordService;
 
    public CustomPasswordHasher(IPasswordService passwordService)
    {
        _passwordService = passwordService;
    }
 
    public string HashPassword(TUser user, string password)
    {
        return _passwordService.HashPassword(password);
    }
 
    public PasswordVerificationResult VerifyHashedPassword(TUser user, string hashedPassword, string providedPassword)
    {
        if (_passwordService.VerifyPassword(providedPassword, hashedPassword))
        {
            return _passwordService.NeedsRehash(hashedPassword)
                ? PasswordVerificationResult.SuccessRehashNeeded
                : PasswordVerificationResult.Success;
        }
        
        return PasswordVerificationResult.Failed;
    }
}

public class BruteForceDetectionMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IMemoryCache _cache;
    private readonly ILogger<BruteForceDetectionMiddleware> _logger;
 
    public BruteForceDetectionMiddleware(RequestDelegate next, IMemoryCache cache, 
        ILogger<BruteForceDetectionMiddleware> logger)
    {
        _next = next;
        _cache = cache;
        _logger = logger;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Если это не POST-запрос на логин, пропускаем
        if (!IsLoginAttempt(context))
        {
            await _next(context);
            return;
        }
 
        string ipAddress = GetIpAddress(context);
        string cacheKey = $"login_attempts:{ipAddress}";
 
        // Получаем количество попыток для этого IP
        if (!_cache.TryGetValue(cacheKey, out int attempts))
            attempts = 0;
 
        // Проверяем, не превышен ли лимит
        if (attempts >= 5) // 5 попыток за 15 минут
        {
            _logger.LogWarning("Возможная брутфорс-атака с IP {IP}, {Attempts} попыток", ipAddress, attempts);
            
            // Можно также уведомить админа или заблокировать IP
            context.Response.StatusCode = 429; // Too Many Requests
            return;
        }
 
        // Сохраняем исходный body для восстановления
        var originalBody = context.Response.Body;
        
        try
        {
            // Создаём новый body для анализа ответа
            using var memStream = new MemoryStream();
            context.Response.Body = memStream;
 
            // Продолжаем выполнение запроса
            await _next(context);
 
            // Проверяем статус ответа
            if (IsFailedLoginResponse(context))
            {
                // Увеличиваем счётчик попыток
                _cache.Set(cacheKey, attempts + 1, TimeSpan.FromMinutes(15));
            }
            else if (IsSuccessfulLoginResponse(context))
            {
                // Сбрасываем счётчик при успешном логине
                _cache.Remove(cacheKey);
            }
 
            // Восстанавливаем тело ответа
            memStream.Position = 0;
            await memStream.CopyToAsync(originalBody);
        }
        finally
        {
            context.Response.Body = originalBody;
        }
    }
 
    // Вспомогательные методы...
}

public class SchnorrZkpAuthenticator
{
    private readonly ECDsa _serverKey;
    private readonly IUserRepository _userRepository;
    
    // Конструктор и другие члены класса...
    
    public async Task<Challenge> GenerateChallenge(string username)
    {
        var user = await _userRepository.GetByUsernameAsync(username);
        if (user == null)
            return null;
            
        // Генерируем случайный вызов (challenge)
        var challenge = new byte[32];
        using (var rng = RandomNumberGenerator.Create())
            rng.GetBytes(challenge);
            
        // Сохраняем challenge в кеше для проверки ответа
        _challengeCache.Set(username, challenge, TimeSpan.FromMinutes(5));
        
        return new Challenge { Value = Convert.ToBase64String(challenge) };
    }
    
    public async Task<bool> VerifyResponse(string username, ZkpResponse response)
    {
        // Получаем сохранённый challenge
        if (!_challengeCache.TryGetValue(username, out byte[] challenge))
            return false;
            
        var user = await _userRepository.GetByUsernameAsync(username);
        if (user == null)
            return false;
            
        // Восстанавливаем публичный ключ пользователя
        ECDsa userPublicKey = ECDsa.Create();
        userPublicKey.ImportSubjectPublicKeyInfo(
            Convert.FromBase64String(user.PublicKeyDer), out _);
            
        // Проверяем подпись
        return VerifySchnorrSignature(
            userPublicKey, 
            challenge, 
            Convert.FromBase64String(response.Signature));
    }
}

public async Task<bool> LoginWithZkp(string username, string password)
{
    // Шаг 1: Запрашиваем challenge
    var challenge = await _api.GetChallenge(username);
    
    // Шаг 2: Генерируем ключ из пароля
    byte[] secretKey = DeriveKeyFromPassword(password, username);
    using var ecdsa = ECDsa.Create();
    ecdsa.ImportECPrivateKey(secretKey, out _);
    
    // Шаг 3: Подписываем challenge
    byte[] signature = ecdsa.SignData(
        Convert.FromBase64String(challenge.Value),
        HashAlgorithmName.SHA256);
        
    // Шаг 4: Отправляем ответ
    return await _api.VerifyZkpResponse(username, new ZkpResponse { 
        Signature = Convert.ToBase64String(signature) 
    });
}

// Установите пакет: Install-Package Fido2
public class Fido2Service
{
    private readonly IFido2 _fido2;
    private readonly IUserRepository _userRepository;
    
    public Fido2Service(IFido2 fido2, IUserRepository userRepository)
    {
        _fido2 = fido2;
        _userRepository = userRepository;
    }
    
    public async Task<CredentialCreateOptions> GetRegistrationOptionsAsync(string username)
    {
        var user = await _userRepository.GetByUsernameAsync(username);
        
        // Создаём опции для регистрации аутентификатора
        var options = _fido2.RequestNewCredential(
            new Fido2User
            {
                Id = Encoding.UTF8.GetBytes(user.Id.ToString()),
                Name = user.Username,
                DisplayName = user.DisplayName
            },
            user.ExistingCredentials?.Select(c => 
                new PublicKeyCredentialDescriptor(c.CredentialId)).ToList()
        );
        
        // Сохраняем challenge в сессии для верификации
        // ...
        
        return options;
    }
    
    // Методы для проверки ответа, аутентификации и т.д.
}

// Корневая структура проекта SecureAuthDemo
SecureAuthDemo/
├── Controllers/
│   ├── AccountController.cs
│   ├── HomeController.cs
│   └── SecurityController.cs
├── Models/
│   ├── UserModel.cs
│   ├── LoginViewModel.cs
│   └── RegisterViewModel.cs
├── Services/
│   ├── PasswordService.cs
│   ├── UserService.cs
│   ├── Fido2Service.cs
│   └── ZkpService.cs
├── Data/
│   ├── ApplicationDbContext.cs
│   └── Repositories/
│       └── UserRepository.cs
├── Security/
│   ├── AuthenticationHandler.cs
│   └── BruteForceProtection.cs
└── Program.cs

public class PasswordService : IPasswordService
{
    private readonly ISecretProvider _secretProvider;
    private readonly ILogger<PasswordService> _logger;
    private readonly IOptions<PasswordSecurityOptions> _options;
    
    // Версии алгоритмов хеширования
    private const byte PBKDF2_VERSION = 0x01;
    private const byte BCRYPT_VERSION = 0x02;
    private const byte ARGON2_VERSION = 0x03;
    
    // Текущий алгоритм хеширования
    private readonly byte _currentVersion;
    
    // Перец для дополнительной защиты
    private readonly byte[] _pepper;
    
    public PasswordService(
        ISecretProvider secretProvider,
        ILogger<PasswordService> logger,
        IOptions<PasswordSecurityOptions> options)
    {
        _secretProvider = secretProvider;
        _logger = logger;
        _options = options;
        
        // Определяем текущий алгоритм из конфигурации
        _currentVersion = (byte)_options.Value.DefaultAlgorithm;
        
        // Получаем перец из безопасного хранилища
        _pepper = _secretProvider.GetSecret("AUTH_PEPPER");
    }
    
    public string HashPassword(string password)
    {
        // Проверка входных данных
        if (string.IsNullOrEmpty(password))
            throw new ArgumentException("Пароль не может быть пустым", nameof(password));
        
        // Используем текущий алгоритм по умолчанию
        switch (_currentVersion)
        {
            case ARGON2_VERSION:
                return HashWithArgon2(password);
            case BCRYPT_VERSION:
                return HashWithBcrypt(password);
            case PBKDF2_VERSION:
                return HashWithPbkdf2(password);
            default:
                throw new NotSupportedException($"Алгоритм версии {_currentVersion} не поддерживается");
        }
    }
    
    public bool VerifyPassword(string password, string hashedPassword)
    {
        if (string.IsNullOrEmpty(password) || string.IsNullOrEmpty(hashedPassword))
            return false;
        
        try
        {
            // Определяем версию алгоритма из хеша
            byte version = ExtractVersion(hashedPassword);
            
            // Проверяем с соответствующим алгоритмом
            switch (version)
            {
                case ARGON2_VERSION:
                    return VerifyArgon2(password, hashedPassword);
                case BCRYPT_VERSION:
                    return VerifyBcrypt(password, hashedPassword);
                case PBKDF2_VERSION:
                    return VerifyPbkdf2(password, hashedPassword);
                default:
                    _logger.LogWarning("Неподдерживаемая версия алгоритма: {Version}", version);
                    return false;
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при проверке пароля");
            return false;
        }
    }
    
    public bool NeedsRehash(string hashedPassword)
    {
        byte version = ExtractVersion(hashedPassword);
        
        // Если версия устарела, нужно обновить
        if (version < _currentVersion)
            return true;
            
        // Дополнительные проверки для конкретных алгоритмов
        if (version == PBKDF2_VERSION)
        {
            int iterations = ExtractPbkdf2Iterations(hashedPassword);
            return iterations < _options.Value.Pbkdf2MinIterations;
        }
        
        if (version == BCRYPT_VERSION)
        {
            int workFactor = ExtractBcryptWorkFactor(hashedPassword);
            return workFactor < _options.Value.BcryptMinWorkFactor;
        }
        
        return false;
    }
    
    // Реализация Argon2id хеширования
    private string HashWithArgon2(string password)
    {
        // Генерируем соль
        byte[] salt = GenerateSecureSalt(16);
        
        // Применяем перец к паролю через HMAC
        byte[] pepperedPassword;
        using (var hmac = new HMACSHA256(_pepper))
        {
            pepperedPassword = hmac.ComputeHash(Encoding.UTF8.GetBytes(password));
        }
        
        // Хешируем с Argon2id
        using (var argon2 = new Argon2id(pepperedPassword))
        {
            argon2.Salt = salt;
            argon2.DegreeOfParallelism = _options.Value.Argon2Parallelism;
            argon2.Iterations = _options.Value.Argon2Iterations;
            argon2.MemorySize = _options.Value.Argon2MemorySize;
            
            byte[] hash = argon2.GetBytes(32);
            
            // Формируем результат в формате, который включает все параметры
            var result = new byte[49 + salt.Length + hash.Length];
            result[0] = ARGON2_VERSION;
            
            // Записываем параметры (упрощенно)
            BitConverter.GetBytes(_options.Value.Argon2Parallelism).CopyTo(result, 1);
            BitConverter.GetBytes(_options.Value.Argon2Iterations).CopyTo(result, 5);
            BitConverter.GetBytes(_options.Value.Argon2MemorySize).CopyTo(result, 9);
            
            // Записываем соль и хеш
            salt.CopyTo(result, 13);
            hash.CopyTo(result, 13 + salt.Length);
            
            return Convert.ToBase64String(result);
        }
    }
    
    // Проверка Argon2id хеша
    private bool VerifyArgon2(string password, string hashedPassword)
    {
        try
        {
            byte[] hashBytes = Convert.FromBase64String(hashedPassword);
            
            // Извлекаем параметры
            int parallelism = BitConverter.ToInt32(hashBytes, 1);
            int iterations = BitConverter.ToInt32(hashBytes, 5);
            int memorySize = BitConverter.ToInt32(hashBytes, 9);
            
            // Извлекаем соль и хеш
            byte[] salt = new byte[16];
            Array.Copy(hashBytes, 13, salt, 0, 16);
            
            byte[] storedHash = new byte[32];
            Array.Copy(hashBytes, 29, storedHash, 0, 32);
            
            // Применяем перец
            byte[] pepperedPassword;
            using (var hmac = new HMACSHA256(_pepper))
            {
                pepperedPassword = hmac.ComputeHash(Encoding.UTF8.GetBytes(password));
            }
            
            // Вычисляем хеш с теми же параметрами
            using (var argon2 = new Argon2id(pepperedPassword))
            {
                argon2.Salt = salt;
                argon2.DegreeOfParallelism = parallelism;
                argon2.Iterations = iterations;
                argon2.MemorySize = memorySize;
                
                byte[] computedHash = argon2.GetBytes(32);
                
                // Сравниваем хеши безопасным способом
                return SlowEquals(computedHash, storedHash);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при проверке Argon2id хеша");
            return false;
        }
    }
    
    // Аналогичные методы для BCrypt и PBKDF2...
    
    // Безопасное сравнение хешей (защита от атак по времени)
    private bool SlowEquals(byte[] a, byte[] b)
    {
        uint diff = (uint)a.Length ^ (uint)b.Length;
        for (int i = 0; i < a.Length && i < b.Length; i++)
            diff |= (uint)(a[i] ^ b[i]);
        return diff == 0;
    }
    
    // Генерация криптостойкой соли
    private byte[] GenerateSecureSalt(int size)
    {
        var salt = new byte[size];
        using (var rng = RandomNumberGenerator.Create())
        {
            rng.GetBytes(salt);
        }
        return salt;
    }
    
    // Вспомогательные методы для извлечения версии и параметров
    private byte ExtractVersion(string hashedPassword)
    {
        byte[] hashBytes = Convert.FromBase64String(hashedPassword);
        return hashBytes[0];
    }
    
    private int ExtractPbkdf2Iterations(string hashedPassword)
    {
        byte[] hashBytes = Convert.FromBase64String(hashedPassword);
        return BitConverter.ToInt32(hashBytes, 1);
    }
    
    private int ExtractBcryptWorkFactor(string hashedPassword)
    {
        byte[] hashBytes = Convert.FromBase64String(hashedPassword);
        return hashBytes[1];
    }
}

public async Task<string> HashPasswordAsync(string password)
{
    return await Task.Run(() => HashPassword(password));
}
 
public async Task<bool> VerifyPasswordAsync(string password, string hashedPassword)
{
    return await Task.Run(() => VerifyPassword(password, hashedPassword));
}

[Route("api/[controller]")]
[ApiController]
public class AccountController : ControllerBase
{
    private readonly IUserService _userService;
    private readonly IPasswordService _passwordService;
    private readonly ITokenService _tokenService;
    private readonly ILogger<AccountController> _logger;
    
    public AccountController(
        IUserService userService,
        IPasswordService passwordService,
        ITokenService tokenService,
        ILogger<AccountController> logger)
    {
        _userService = userService;
        _passwordService = passwordService;
        _tokenService = tokenService;
        _logger = logger;
    }
    
    [HttpPost("register")]
    public async Task<IActionResult> Register([FromBody] RegisterViewModel model)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
            
        try
        {
            // Проверяем, существует ли пользователь
            if (await _userService.ExistsByEmailAsync(model.Email))
                return Conflict(new { message = "Пользователь с таким email уже существует" });
                
            // Хешируем пароль
            string hashedPassword = await _passwordService.HashPasswordAsync(model.Password);
            
            // Создаём нового пользователя
            var userId = await _userService.CreateUserAsync(model.Username, model.Email, hashedPassword);
            
            _logger.LogInformation("Зарегистрирован новый пользователь: {Username}", model.Username);
            
            return Ok(new { userId });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при регистрации пользователя");
            return StatusCode(500, new { message = "Внутренняя ошибка сервера" });
        }
    }
    
    [HttpPost("login")]
    public async Task<IActionResult> Login([FromBody] LoginViewModel model)
    {
        if (!ModelState.IsValid)
            return BadRequest(ModelState);
            
        try
        {
            // Находим пользователя
            var user = await _userService.GetByEmailAsync(model.Email);
            if (user == null)
            {
                // Добавляем небольшую задержку для защиты от атак перебором
                await Task.Delay(Random.Shared.Next(300, 500));
                return Unauthorized(new { message = "Неверный email или пароль" });
            }
            
            // Проверяем пароль
            if (!await _passwordService.VerifyPasswordAsync(model.Password, user.PasswordHash))
            {
                _logger.LogWarning("Неудачная попытка входа для пользователя: {Email}", model.Email);
                return Unauthorized(new { message = "Неверный email или пароль" });
            }
            
            // Проверяем, нужно ли обновить хеш
            if (_passwordService.NeedsRehash(user.PasswordHash))
            {
                user.PasswordHash = await _passwordService.HashPasswordAsync(model.Password);
                await _userService.UpdateUserAsync(user);
                _logger.LogInformation("Обновлён хеш пароля для пользователя: {Username}", user.Username);
            }
            
            // Создаём токен доступа
            var token = _tokenService.GenerateToken(user);
            
            _logger.LogInformation("Успешный вход пользователя: {Username}", user.Username);
            
            return Ok(new { token });
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Ошибка при попытке входа");
            return StatusCode(500, new { message = "Внутренняя ошибка сервера" });
        }
    }
}

public class BruteForceProtectionMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IDistributedCache _cache;
    private readonly ILogger<BruteForceProtectionMiddleware> _logger;
    private readonly BruteForceOptions _options;
    
    public BruteForceProtectionMiddleware(
        RequestDelegate next,
        IDistributedCache cache,
        ILogger<BruteForceProtectionMiddleware> logger,
        IOptions<BruteForceOptions> options)
    {
        _next = next;
        _cache = cache;
        _logger = logger;
        _options = options.Value;
    }
    
    public async Task InvokeAsync(HttpContext context)
    {
        // Проверяем, является ли запрос попыткой входа
        if (IsLoginEndpoint(context.Request))
        {
            string clientIp = GetClientIpAddress(context);
            string cacheKey = $"login_attempts:{clientIp}";
            
            // Получаем текущее количество попыток
            int attempts = await GetLoginAttemptsAsync(cacheKey);
            
            if (attempts >= _options.MaxAttempts)
            {
                _logger.LogWarning("Превышен лимит попыток входа для IP {IP}", clientIp);
                
                context.Response.StatusCode = StatusCodes.Status429TooManyRequests;
                await context.Response.WriteAsJsonAsync(new { 
                    error = "Слишком много попыток входа. Пожалуйста, попробуйте позже." 
                });
                
                // Увеличиваем время блокировки экспоненциально
                int blockMinutes = Math.Min(60, (int)Math.Pow(2, attempts - _options.MaxAttempts + 1));
                await _cache.SetStringAsync(cacheKey, (attempts + 1).ToString(), 
                    new DistributedCacheEntryOptions { 
                        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(blockMinutes) 
                    });
                
                return;
            }
            
            // Сохраняем оригинальный stream для тела ответа
            var originalBodyStream = context.Response.Body;
            
            try
            {
                // Создаём временный поток для чтения ответа
                using var memStream = new MemoryStream();
                context.Response.Body = memStream;
                
                // Продолжаем обработку запроса
                await _next(context);
                
                // Анализируем ответ
                memStream.Position = 0;
                var responseBody = await new StreamReader(memStream).ReadToEndAsync();
                
                // Если это неудачная попытка входа (401 Unauthorized)
                if (context.Response.StatusCode == StatusCodes.Status401Unauthorized)
                {
                    // Увеличиваем счётчик попыток
                    await IncrementLoginAttemptsAsync(cacheKey);
                }
                else if (context.Response.StatusCode == StatusCodes.Status200OK)
                {
                    // Сбрасываем счётчик при успешном входе
                    await _cache.RemoveAsync(cacheKey);
                }
                
                // Копируем тело ответа обратно в исходный поток
                memStream.Position = 0;
                await memStream.CopyToAsync(originalBodyStream);
            }
            finally
            {
                context.Response.Body = originalBodyStream;
            }
        }
        else
        {
            await _next(context);
        }
    }
    
    private async Task<int> GetLoginAttemptsAsync(string cacheKey)
    {
        string attemptsStr = await _cache.GetStringAsync(cacheKey);
        return string.IsNullOrEmpty(attemptsStr) ? 0 : int.Parse(attemptsStr);
    }
    
    private async Task IncrementLoginAttemptsAsync(string cacheKey)
    {
        int attempts = await GetLoginAttemptsAsync(cacheKey);
        await _cache.SetStringAsync(cacheKey, (attempts + 1).ToString(), 
            new DistributedCacheEntryOptions { 
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(_options.LockoutMinutes) 
            });
    }
    
    private bool IsLoginEndpoint(HttpRequest request)
    {
        return request.Method == "POST" && 
               request.Path.StartsWithSegments("/api/account/login", StringComparison.OrdinalIgnoreCase);
    }
    
    private string GetClientIpAddress(HttpContext context)
    {
        // Получаем реальный IP клиента, учитывая проксирование
        string ip = context.Request.Headers["X-Forwarded-For"].FirstOrDefault() ??
                   context.Connection.RemoteIpAddress?.ToString();
        return ip ?? "unknown";
    }
}

// Регистрация опций
builder.Services.Configure<BruteForceOptions>(builder.Configuration.GetSection("BruteForceProtection"));
 
// Регистрация middleware в конвейере
app.UseMiddleware<BruteForceProtectionMiddleware>();

public class BruteForceOptions
{
    public int MaxAttempts { get; set; } = 5;
    public int LockoutMinutes { get; set; } = 15;
}

var builder = WebApplication.CreateBuilder(args);
 
// Добавляем сервисы
builder.Services.AddControllers();
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen();
 
// Добавляем БД контекст
builder.Services.AddDbContext<ApplicationDbContext>(options =>
    options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
 
// Регистрируем репозитории и сервисы
builder.Services.AddScoped<IUserRepository, UserRepository>();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddScoped<IPasswordService, PasswordService>();
builder.Services.AddScoped<ITokenService, JwtTokenService>();
builder.Services.AddScoped<ISecretProvider, AzureKeyVaultSecretProvider>();
builder.Services.AddScoped<IFido2Service, Fido2Service>();
builder.Services.AddScoped<IZkpService, ZkpService>();
 
// Добавляем кеширование для защиты от брутфорса
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "SecureAuthDemo:";
});
 
// Конфигурируем настройки безопасности
builder.Services.Configure<PasswordSecurityOptions>(
    builder.Configuration.GetSection("PasswordSecurity"));
builder.Services.Configure<BruteForceOptions>(
    builder.Configuration.GetSection("BruteForceProtection"));
builder.Services.Configure<JwtOptions>(
    builder.Configuration.GetSection("Jwt"));
 
// Добавляем аутентификацию и авторизацию
builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
    .AddJwtBearer(options =>
    {
        options.TokenValidationParameters = new TokenValidationParameters
        {
            ValidateIssuer = true,
            ValidateAudience = true,
            ValidateLifetime = true,
            ValidateIssuerSigningKey = true,
            ValidIssuer = builder.Configuration["Jwt:Issuer"],
            ValidAudience = builder.Configuration["Jwt:Audience"],
            IssuerSigningKey = new SymmetricSecurityKey(
                Encoding.UTF8.GetBytes(builder.Configuration["Jwt:Key"]))
        };
    });
 
builder.Services.AddAuthorization();
 
var app = builder.Build();
 
// Настраиваем конвейер запросов
if (app.Environment.IsDevelopment())
{
    app.UseSwagger();
    app.UseSwaggerUI();
}
 
app.UseHttpsRedirection();
 
// Добавляем защиту от брутфорса перед аутентификацией
app.UseMiddleware<BruteForceProtectionMiddleware>();
 
app.UseAuthentication();
app.UseAuthorization();
 
app.MapControllers();
 
// Применяем миграции при запуске
using (var scope = app.Services.CreateScope())
{
    var dbContext = scope.ServiceProvider.GetRequiredService<ApplicationDbContext>();
    dbContext.Database.Migrate();
}
 
app.Run();