Passkey в ASP.NET Core identity

public class PasskeyController : Controller
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;
 
    // Генерируем опции для создания нового Passkey
    [HttpPost]
    public async Task<IActionResult> CreatePasskeyOptions()
    {
        var user = await _userManager.GetUserAsync(User);
        if (user == null) return Unauthorized();
 
        // Создаем сущность пользователя для Passkey
        var userId = await _userManager.GetUserIdAsync(user);
        var userName = await _userManager.GetUserNameAsync(user) ?? "Unknown";
        
        var passkeyUser = new PasskeyUserEntity(
            userId, 
            userName, 
            displayName: userName
        );
 
        var args = new PasskeyCreationArgs(passkeyUser);
        
        // Генерируем опции и сохраняем их в cookie
        var options = await _signInManager.MakePasskeyCreationOptionsAsync(args);
        
        // Возвращаем JSON для клиента
        return Content(options.AsJson(), "application/json");
    }
}

[HttpPost]
public async Task<IActionResult> RegisterPasskey([FromForm] PasskeyRegistrationInput input)
{
    var user = await _userManager.GetUserAsync(User);
    if (user == null) return Unauthorized();
 
    // Достаем опции из cookie, которые сохранили ранее
    var options = await _signInManager.RetrievePasskeyCreationOptionsAsync();
    if (options == null) 
        return BadRequest("Опции регистрации не найдены или истекли");
 
    // Проверяем корректность полученных credentials
    var result = await _signInManager.PerformPasskeyAttestationAsync(
        input.CredentialJson, 
        options
    );
 
    if (!result.Succeeded)
        return BadRequest($"Ошибка валидации: {result.Failure?.Message}");
 
    // Сохраняем Passkey в аккаунт пользователя
    var setResult = await _userManager.SetPasskeyAsync(user, result.Passkey);
    if (!setResult.Succeeded)
        return BadRequest("Не удалось сохранить Passkey");
 
    return Ok();
}

migrationBuilder.CreateTable(
    name: "AspNetUserPasskeys",
    columns: table => new
    {
        CredentialId = table.Column<byte[]>(maxLength: 1024, nullable: false),
        UserId = table.Column<string>(nullable: false),
        Data = table.Column<string>(nullable: false)
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_AspNetUserPasskeys", x => x.CredentialId);
        table.ForeignKey(
            name: "FK_AspNetUserPasskeys_AspNetUsers_UserId",
            column: x => x.UserId,
            principalTable: "AspNetUsers",
            principalColumn: "Id",
            onDelete: ReferentialAction.Cascade);
    });

// Получить все Passkey пользователя
var passkeys = await _userManager.GetPasskeysAsync(user);
 
// Удалить конкретный Passkey
await _userManager.RemovePasskeyAsync(user, credentialId);
 
// Переименовать Passkey (да, есть и такое)
await _userManager.SetPasskeyNameAsync(user, credentialId, newName);

services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
    // Эти настройки влияют и на Passkey тоже
    options.SignIn.RequireConfirmedAccount = true;
    options.User.RequireUniqueEmail = true;
})
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders();

public class PasskeyService
{
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly ILogger<PasskeyService> _logger;
 
    public async Task<(bool Success, string? Error)> VerifyPasskeyAsync(
        string credentialJson, 
        PasskeyCreationOptions options)
    {
        try
        {
            var result = await _signInManager.PerformPasskeyAttestationAsync(
                credentialJson, 
                options
            );
 
            if (!result.Succeeded)
            {
                // Детально логируем причину провала
                _logger.LogWarning(
                    "Passkey verification failed: {Reason}. Credential: {Cred}", 
                    result.Failure?.Message,
                    credentialJson.Substring(0, Math.Min(100, credentialJson.Length))
                );
                return (false, result.Failure?.Message ?? "Unknown error");
            }
 
            return (true, null);
        }
        catch (Exception ex)
        {
            // Перехватываем исключения, которые Identity может выкинуть
            _logger.LogError(ex, "Exception during Passkey verification");
            return (false, "Internal verification error");
        }
    }
}

var args = new PasskeyCreationArgs(passkeyUser)
{
    AuthenticatorSelection = new AuthenticatorSelectionCriteria
    {
        // Требуем только external устройства
        AuthenticatorAttachment = AuthenticatorAttachment.CrossPlatform,
        // Обязательна верификация пользователя (биометрия/PIN)
        UserVerification = UserVerificationRequirement.Required,
        // Требуем создание resident key
        ResidentKey = ResidentKeyRequirement.Required
    }
};

// Получаем все существующие Passkey пользователя
var existingPasskeys = await _userManager.GetPasskeysAsync(user);
 
var args = new PasskeyCreationArgs(passkeyUser)
{
    ExcludeCredentials = existingPasskeys
        .Select(pk => new PublicKeyCredentialDescriptor
        {
            Type = PublicKeyCredentialType.PublicKey,
            Id = pk.CredentialId,
            Transports = pk.Transports // USB, NFC, BLE, internal
        })
        .ToList()
};

attestationObject = {
    "fmt": "packed",  // Формат аттестации
    "attStmt": {      // Attestation statement
        "alg": -7,    // ES256
        "sig": <signature bytes>,
        "x5c": [<cert chain>]  // Опционально
    },
    "authData": <authenticator data bytes>
}

[HttpPost]
public async Task<IActionResult> PasskeyRequestOptions([FromQuery] string? username)
{
    ApplicationUser? user = null;
    
    // Если username предоставлен, находим пользователя
    if (!string.IsNullOrEmpty(username))
    {
        user = await _userManager.FindByNameAsync(username);
    }
    
    var args = new PasskeyRequestArgs<ApplicationUser>
    {
        User = user
    };
    
    // Генерируем опции и сохраняем challenge в cookie
    var options = await _signInManager.ConfigurePasskeyRequestOptionsAsync(args);
    
    return Content(options.AsJson(), "application/json");
}

[HttpPost]
public async Task<IActionResult> PasskeyLogin([FromForm] PasskeyLoginInput input)
{
    try
    {
        // Достаем сохраненные опции из cookie
        var options = await _signInManager.RetrievePasskeyRequestOptionsAsync();
        if (options == null)
        {
            return BadRequest("Опции аутентификации не найдены или истекли");
        }
        
        // Валидируем credential и выполняем вход
        var result = await _signInManager.PasskeySignInAsync(
            input.CredentialJson,
            options
        );
        
        if (result.Succeeded)
        {
            _logger.LogInformation("Успешный вход через Passkey");
            return LocalRedirect("/");
        }
        
        if (result.IsLockedOut)
        {
            return RedirectToPage("/Account/Lockout");
        }
        
        return BadRequest("Не удалось войти через Passkey");
        
    }
    catch (Exception ex)
    {
        _logger.LogError(ex, "Ошибка при входе через Passkey");
        return StatusCode(500, "Внутренняя ошибка сервера");
    }
}

// Псевдокод внутренней логики проверки счетчика
var storedCounter = await GetStoredSignCountAsync(credentialId);
var receivedCounter = ExtractCounterFromAuthData(authenticatorData);
 
if (receivedCounter > 0 && receivedCounter <= storedCounter)
{
    // Возможное клонирование ключа!
    _logger.LogWarning(
        "Подозрительный счетчик подписей. Credential: {Id}, Stored: {Stored}, Received: {Received}",
        credentialId, storedCounter, receivedCounter
    );
    
    // Можно заблокировать credential или послать алерт админам
    await DisableCredentialAsync(credentialId);
    return SignInResult.Failed;
}
 
// Обновляем сохраненный счетчик
await UpdateSignCountAsync(credentialId, receivedCounter);

private async Task LogPasskeyAuthentication(
  string userId,
  byte[] credentialId, 
  bool success,
  string? failureReason = null)
{
  var logEntry = new PasskeyAuthLog
  {
      Timestamp = DateTime.UtcNow,
      UserId = userId,
      CredentialId = Convert.ToBase64String(credentialId),
      IpAddress = HttpContext.Connection.RemoteIpAddress?.ToString(),
      UserAgent = HttpContext.Request.Headers["User-Agent"].ToString(),
      Success = success,
      FailureReason = failureReason
  };
  
  await _auditLogRepository.AddAsync(logEntry);
  
  // Дополнительно отправляем в SIEM если доступен
  if (_siemService != null)
  {
      await _siemService.SendEventAsync("passkey_auth", logEntry);
  }
}

SecureAuthPortal/
├── Components/
│   ├── Account/
│   │   ├── Pages/
│   │   │   ├── Login.razor           // Форма входа с Passkey
│   │   │   ├── Register.razor        // Регистрация аккаунта
│   │   │   └── PasskeyManager.razor  // Управление ключами
│   │   └── Shared/
│   │       ├── PasskeyButton.razor   // Переиспользуемая кнопка
│   │       └── PasskeyStatus.razor   // Индикатор статуса
│   └── Layout/
│       └── MainLayout.razor
├── Services/
│   ├── PasskeyService.cs             // Обертка над Identity
│   ├── AuditLogger.cs                // Логирование аутентификации
│   └── PasskeyAnalytics.cs           // Метрики использования
├── Data/
│   ├── ApplicationDbContext.cs
│   ├── Migrations/
│   └── Entities/
│       └── PasskeyAuditLog.cs
└── wwwroot/
    └── js/
        └── passkey-client.js         // Клиентская логика WebAuthn

public class PasskeyService
{
    private readonly UserManager<ApplicationUser> _userManager;
    private readonly SignInManager<ApplicationUser> _signInManager;
    private readonly AuditLogger _auditLogger;
    
    public async Task<PasskeyRegistrationResult> RegisterPasskeyAsync(
        ApplicationUser user, 
        string credentialJson)
    {
        // Получаем сохраненные опции из cookie
        var options = await _signInManager.RetrievePasskeyCreationOptionsAsync();
        if (options == null)
        {
            return PasskeyRegistrationResult.Failed("Опции регистрации истекли");
        }
        
        // Валидируем credential
        var attestation = await _signInManager.PerformPasskeyAttestationAsync(
            credentialJson, 
            options
        );
        
        if (!attestation.Succeeded)
        {
            await _auditLogger.LogFailedRegistrationAsync(
                user.Id, 
                attestation.Failure?.Message
            );
            return PasskeyRegistrationResult.Failed(
                attestation.Failure?.Message ?? "Ошибка валидации"
            );
        }
        
        // Проверяем лимит ключей на пользователя
        var existingKeys = await _userManager.GetPasskeysAsync(user);
        if (existingKeys.Count >= 10)
        {
            return PasskeyRegistrationResult.Failed(
                "Достигнут лимит ключей на аккаунт"
            );
        }
        
        // Сохраняем в базу
        var result = await _userManager.SetPasskeyAsync(user, attestation.Passkey);
        if (!result.Succeeded)
        {
            return PasskeyRegistrationResult.Failed("Не удалось сохранить ключ");
        }
        
        // Логируем успех
        await _auditLogger.LogSuccessfulRegistrationAsync(
            user.Id,
            attestation.Passkey.CredentialId
        );
        
        return PasskeyRegistrationResult.Success(attestation.Passkey);
    }
    
    public async Task<PasskeyAuthenticationResult> AuthenticateAsync(
        string credentialJson)
    {
        var options = await _signInManager.RetrievePasskeyRequestOptionsAsync();
        if (options == null)
        {
            return PasskeyAuthenticationResult.Failed("Опции аутентификации истекли");
        }
        
        var result = await _signInManager.PasskeySignInAsync(
            credentialJson,
            options
        );
        
        if (result.Succeeded)
        {
            // Получаем информацию о пользователе для логирования
            var principal = result.Principal;
            var userId = principal?.FindFirst(ClaimTypes.NameIdentifier)?.Value;
            
            if (userId != null)
            {
                await _auditLogger.LogSuccessfulLoginAsync(userId);
            }
            
            return PasskeyAuthenticationResult.Success(result);
        }
        
        return PasskeyAuthenticationResult.Failed("Аутентификация не удалась");
    }
}

public class PasskeyAuditLog
{
    public int Id { get; set; }
    public DateTime Timestamp { get; set; }
    public string UserId { get; set; }
    public string Operation { get; set; } // Register, Login, Delete
    public bool Success { get; set; }
    public string? CredentialId { get; set; }
    public string? IpAddress { get; set; }
    public string? UserAgent { get; set; }
    public string? ErrorMessage { get; set; }
}

public class PasskeyAnalytics
{
    private readonly ApplicationDbContext _context;
    
    public async Task<PasskeyStats> GetStatsAsync()
    {
        var logs = await _context.PasskeyAuditLogs
            .Where(l => l.Timestamp >= DateTime.UtcNow.AddDays(-30))
            .ToListAsync();
        
        return new PasskeyStats
        {
            TotalRegistrations = logs.Count(l => l.Operation == "Register" && l.Success),
            TotalLogins = logs.Count(l => l.Operation == "Login"),
            SuccessRate = CalculateSuccessRate(logs.Where(l => l.Operation == "Login")),
            MostActiveUsers = await GetMostActiveUsersAsync(),
            AverageKeysPerUser = await CalculateAverageKeysAsync()
        };
    }
    
    private double CalculateSuccessRate(IEnumerable<PasskeyAuditLog> loginLogs)
    {
        if (!loginLogs.Any()) return 0;
        
        var successful = loginLogs.Count(l => l.Success);
        return (double)successful / loginLogs.Count() * 100;
    }
}

[Fact]
public async Task CanRegisterPasskey_WithVirtualAuthenticator()
{
    await using var context = await Browser.NewContextAsync(new()
    {
        // Добавляем виртуальный аутентификатор
        HasWebAuthn = true
    });
    
    var page = await context.NewPageAsync();
    await page.GotoAsync("http://localhost:5000/Account/Register");
    
    // Регистрируем аккаунт
    await page.FillAsync("#Email", "test@example.com");
    await page.FillAsync("#Password", "Pass@word123");
    await page.ClickAsync("button[type=submit]");
    
    // Добавляем Passkey
    await page.WaitForURLAsync("**/Account/ManagePasskeys");
    await page.ClickAsync("text=Добавить Passkey");
    
    // Виртуальный аутентификатор автоматически подтверждает
    await page.WaitForSelectorAsync("text=Passkey успешно зарегистрирован");
    
    // Проверяем что ключ появился в списке
    var keysCount = await page.Locator("table tbody tr").CountAsync();
    Assert.Equal(1, keysCount);
}

public class PasskeyTelemetry
{
    private readonly TelemetryClient _telemetry;
    
    public void TrackPasskeyRegistration(bool success, TimeSpan duration)
    {
        _telemetry.TrackEvent("PasskeyRegistration", 
            properties: new Dictionary<string, string>
            {
                { "Success", success.ToString() },
                { "Duration", duration.TotalMilliseconds.ToString() }
            },
            metrics: new Dictionary<string, double>
            {
                { "RegistrationTime", duration.TotalMilliseconds }
            }
        );
    }
    
    public void TrackPasskeyLogin(bool success, string? errorReason = null)
    {
        var properties = new Dictionary<string, string>
        {
            { "Success", success.ToString() }
        };
        
        if (errorReason != null)
        {
            properties["ErrorReason"] = errorReason;
        }
        
        _telemetry.TrackEvent("PasskeyLogin", properties);
    }
}