Как сделать SSO (Single Sign-On) в C# приложении

public void ConfigureServices(IServiceCollection services)
{
    services.AddAuthentication(options =>
    {
        options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = "OAuth";
    })
    .AddCookie()
    .AddOAuth("OAuth", options =>
    {
        options.ClientId = Configuration["OAuth:ClientId"];
        options.ClientSecret = Configuration["OAuth:ClientSecret"];
        options.CallbackPath = new PathString("/signin-oauth");
        // Дополнительные настройки
    });
}

services.AddAuthentication(options =>
{
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
})
.AddCookie()
.AddOpenIdConnect(options =>
{
    options.Authority = "https://your-identity-provider.com";
    options.ClientId = "your-client-id";
    options.ClientSecret = "your-client-secret";
    options.ResponseType = "code";
    options.GetClaimsFromUserInfoEndpoint = true;
    options.SaveTokens = true;
});

public class JwtTokenGenerator
{
    private readonly string _secretKey;
    private readonly string _issuer;
    private readonly string _audience;
 
    public JwtTokenGenerator(string secretKey, string issuer, string audience)
    {
        _secretKey = secretKey;
        _issuer = issuer;
        _audience = audience;
    }
 
    public string GenerateToken(string userId, IEnumerable<string> roles, TimeSpan expiry)
    {
        var claims = new List<Claim>
        {
            new Claim(JwtRegisteredClaimNames.Sub, userId),
            new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
        };
 
        foreach (var role in roles)
        {
            claims.Add(new Claim(ClaimTypes.Role, role));
        }
 
        var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_secretKey));
        var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
 
        var token = new JwtSecurityToken(
            issuer: _issuer,
            audience: _audience,
            claims: claims,
            expires: DateTime.Now.Add(expiry),
            signingCredentials: creds);
 
        return new JwtSecurityTokenHandler().WriteToken(token);
    }
}

services.AddAuthentication(options =>
{
    options.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
}).AddJwtBearer(options =>
{
    options.Authority = $"https://{Configuration["Auth0:Domain"]}";
    options.Audience = Configuration["Auth0:Audience"];
});

services.AddIdentityServer()
    .AddDeveloperSigningCredential()  // Только для разработки!
    .AddInMemoryApiResources(Config.GetApiResources())
    .AddInMemoryClients(Config.GetClients())
    .AddInMemoryIdentityResources(Config.GetIdentityResources())
    .AddTestUsers(Config.GetUsers());

public class GatewayAuthenticationHandler : DelegatingHandler
{
    private readonly ITokenStore _tokenStore;
    
    public GatewayAuthenticationHandler(ITokenStore tokenStore)
    {
        _tokenStore = tokenStore;
    }
    
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        // Получаем токен для сервиса, к которому обращаемся
        var token = await _tokenStore.GetTokenForServiceAsync(request.RequestUri.Host);
        
        // Добавляем токен в заголовок запроса
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", token);
        
        // Передаем запрос дальше
        return await base.SendAsync(request, cancellationToken);
    }
}

public class RedisTokenCache : ITokenCache
{
    private readonly IDistributedCache _cache;
    
    public RedisTokenCache(IDistributedCache cache)
    {
        _cache = cache;
    }
    
    public async Task<TokenValidationResult> ValidateTokenAsync(string token)
    {
        // Пытаемся получить результат валидации из кэша
        var cachedResult = await _cache.GetStringAsync(token);
        if (cachedResult != null)
        {
            return JsonSerializer.Deserialize<TokenValidationResult>(cachedResult);
        }
        
        // Если в кэше нет, проверяем через IdP
        var result = await ValidateTokenWithIdPAsync(token);
        
        // Сохраняем результат в кэш с временем жизни чуть меньше, чем время жизни токена
        await _cache.SetStringAsync(token, 
            JsonSerializer.Serialize(result), 
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(55) // Для часового токена
            });
            
        return result;
    }
    
    private async Task<TokenValidationResult> ValidateTokenWithIdPAsync(string token)
    {
        // Логика проверки токена через IdP
        // ...
    }
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>();
            webBuilder.UseKestrel(options => 
            {
                options.Listen(IPAddress.Loopback, 5001, listenOptions =>
                {
                    listenOptions.UseHttps(httpsOptions =>
                    {
                        var localhostCert = CertificateLoader.LoadFromStoreCert(
                            "localhost", "My", StoreLocation.CurrentUser,
                            allowInvalid: true);
                        httpsOptions.ServerCertificate = localhostCert;
                    });
                });
            });
        });

public Startup(IWebHostEnvironment env)
{
    var builder = new ConfigurationBuilder()
        .SetBasePath(env.ContentRootPath)
        .AddJsonFile("appsettings.json")
        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
        .AddUserSecrets<Startup>() // Для разработки
        .AddEnvironmentVariables();
    
    if (env.IsProduction())
    {
        builder.AddAzureKeyVault(
            $"https://{Configuration["KeyVault:Name"]}.vault.azure.net/",
            Configuration["KeyVault:ClientId"],
            Configuration["KeyVault:ClientSecret"]);
    }
    
    Configuration = builder.Build();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // Сначала обработка исключений
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }
 
    app.UseHttpsRedirection();
    app.UseStaticFiles();
    app.UseRouting();
    
    // Authentication должен быть перед Authorization!
    app.UseAuthentication();
    app.UseAuthorization();
    
    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

public void ConfigureServices(IServiceCollection services)
{
    services.AddLogging(builder =>
    {
        builder.AddFilter("Microsoft.AspNetCore.Authentication", LogLevel.Debug);
        builder.AddFilter("Microsoft.AspNetCore.Authorization", LogLevel.Debug);
        builder.AddConsole();
        builder.AddDebug();
    });
    
    // Другие сервисы
}

public class AuthenticationLogger
{
    private readonly ILogger<AuthenticationLogger> _logger;
 
    public AuthenticationLogger(ILogger<AuthenticationLogger> logger)
    {
        _logger = logger;
    }
 
    public void LogToken(string token)
    {
        try
        {
            var handler = new JwtSecurityTokenHandler();
            var jwtToken = handler.ReadJwtToken(token);
 
            _logger.LogInformation("Token subject: {Subject}", jwtToken.Subject);
            _logger.LogInformation("Token issuer: {Issuer}", jwtToken.Issuer);
            _logger.LogInformation("Token valid from: {ValidFrom}", jwtToken.ValidFrom);
            _logger.LogInformation("Token valid to: {ValidTo}", jwtToken.ValidTo);
            
            foreach (var claim in jwtToken.Claims)
            {
                _logger.LogInformation("Claim: {Type} = {Value}", claim.Type, claim.Value);
            }
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "Failed to parse JWT token");
        }
    }
}

public void ConfigureServices(IServiceCollection services)
{
    // Добавляем аутентификацию
    services.AddAuthentication(options =>
    {
        options.DefaultAuthenticateScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        options.DefaultSignInScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
    })
    .AddCookie()
    .AddOpenIdConnect(options =>
    {
        // Основные настройки
        options.Authority = $"https://{Configuration["Auth0:Domain"]}";
        options.ClientId = Configuration["Auth0:ClientId"];
        options.ClientSecret = Configuration["Auth0:ClientSecret"];
        options.ResponseType = "code";
        
        // Указываем, что хотим получить токен доступа и id_token
        options.Scope.Clear();
        options.Scope.Add("openid");
        options.Scope.Add("profile");
        options.Scope.Add("email");
        
        // Сохраняем токены для дальнейшего использования
        options.SaveTokens = true;
        
        // Настраиваем маппинг claims
        options.TokenValidationParameters = new TokenValidationParameters
        {
            NameClaimType = "name",
            RoleClaimType = "https://myapp.com/roles"
        };
        
        // Обрабатываем события аутентификации
        options.Events = new OpenIdConnectEvents
        {
            OnTokenValidated = async ctx => 
            {
                // Дополнительная логика после валидации токена
                var email = ctx.Principal.FindFirstValue(ClaimTypes.Email);
                // Например, можно найти пользователя в локальной БД
            },
            OnRedirectToIdentityProviderForSignOut = async ctx =>
            {
                // Настройки для выхода из системы
                var logoutUri = $"https://{Configuration["Auth0:Domain"]}/v2/logout?client_id={Configuration["Auth0:ClientId"]}";
                ctx.ProtocolMessage.IssuerAddress = logoutUri;
            }
        };
    });
 
    services.AddControllersWithViews();
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ... другие middleware
 
    app.UseAuthentication();
    app.UseAuthorization();
 
    app.UseEndpoints(endpoints =>
    {
        // Защищаем нужные маршруты
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}")
            .RequireAuthorization();  // Или используйте атрибуты [Authorize]
    });
}

[Authorize]
public class DashboardController : Controller
{
    public IActionResult Index()
    {
        return View();
    }
    
    [Authorize(Roles = "Admin")]
    public IActionResult AdminPanel()
    {
        return View();
    }
}

public IActionResult Login(string returnUrl = "/")
{
    return Challenge(new AuthenticationProperties { RedirectUri = returnUrl },
        OpenIdConnectDefaults.AuthenticationScheme);
}

public class SecuredApiController : Controller
{
    private readonly IHttpClientFactory _clientFactory;
    
    public SecuredApiController(IHttpClientFactory clientFactory)
    {
        _clientFactory = clientFactory;
    }
    
    [Authorize]
    public async Task<IActionResult> GetProtectedData()
    {
        // Получаем токен доступа из HttpContext
        var accessToken = await HttpContext.GetTokenAsync("access_token");
        
        // Используем токен для вызова защищенного API
        var client = _clientFactory.CreateClient();
        client.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", accessToken);
            
        var response = await client.GetAsync("https://api.example.com/protected-data");
        
        if (response.IsSuccessStatusCode)
        {
            var content = await response.Content.ReadAsStringAsync();
            return Json(content);
        }
        
        return StatusCode(500);
    }
}

public class TokenService
{
    private readonly HttpClient _httpClient;
    private readonly IOptions<Auth0Settings> _options;
    
    public TokenService(HttpClient httpClient, IOptions<Auth0Settings> options)
    {
        _httpClient = httpClient;
        _options = options;
    }
    
    public async Task<TokenResponse> RefreshTokenAsync(string refreshToken)
    {
        var tokenEndpoint = $"https://{_options.Value.Domain}/oauth/token";
        
        var parameters = new Dictionary<string, string>
        {
            ["grant_type"] = "refresh_token",
            ["client_id"] = _options.Value.ClientId,
            ["client_secret"] = _options.Value.ClientSecret,
            ["refresh_token"] = refreshToken
        };
        
        var content = new FormUrlEncodedContent(parameters);
        var response = await _httpClient.PostAsync(tokenEndpoint, content);
        
        if (!response.IsSuccessStatusCode)
        {
            throw new Exception("Failed to refresh token");
        }
        
        var responseContent = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<TokenResponse>(responseContent);
    }
}

public class TokenRefreshHandler : DelegatingHandler
{
    private readonly TokenService _tokenService;
    private readonly ITokenStore _tokenStore;
    
    public TokenRefreshHandler(TokenService tokenService, ITokenStore tokenStore)
    {
        _tokenService = tokenService;
        _tokenStore = tokenStore;
    }
    
    protected override async Task<HttpResponseMessage> SendAsync(
        HttpRequestMessage request, CancellationToken cancellationToken)
    {
        var userId = GetCurrentUserId(); // Получение текущего пользователя
        
        // Пробуем отправить запрос с текущим токеном
        var accessToken = await _tokenStore.GetAccessTokenAsync(userId);
        request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
        
        var response = await base.SendAsync(request, cancellationToken);
        
        // Если токен истек, пробуем обновить и повторить запрос
        if (response.StatusCode == HttpStatusCode.Unauthorized)
        {
            var refreshToken = await _tokenStore.GetRefreshTokenAsync(userId);
            if (!string.IsNullOrEmpty(refreshToken))
            {
                var tokens = await _tokenService.RefreshTokenAsync(refreshToken);
                
                // Сохраняем новые токены
                await _tokenStore.SaveTokensAsync(userId, tokens.AccessToken, tokens.RefreshToken);
                
                // Повторяем запрос с новым токеном
                request = CopyRequest(request); // Копируем оригинальный запрос
                request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", tokens.AccessToken);
                
                return await base.SendAsync(request, cancellationToken);
            }
        }
        
        return response;
    }
    
    private HttpRequestMessage CopyRequest(HttpRequestMessage request)
    {
        var copy = new HttpRequestMessage(request.Method, request.RequestUri);
        
        foreach (var header in request.Headers)
        {
            copy.Headers.TryAddWithoutValidation(header.Key, header.Value);
        }
        
        if (request.Content != null)
        {
            copy.Content = new StreamContent(request.Content.ReadAsStreamAsync().Result);
            foreach (var header in request.Content.Headers)
            {
                copy.Content.Headers.TryAddWithoutValidation(header.Key, header.Value);
            }
        }
        
        copy.Properties.Clear();
        foreach (var prop in request.Properties)
        {
            copy.Properties.Add(prop);
        }
        
        return copy;
    }
}

public class DynamicClientRegistrationService
{
    private readonly HttpClient _httpClient;
    private readonly string _registrationEndpoint;
    
    public DynamicClientRegistrationService(HttpClient httpClient, string registrationEndpoint)
    {
        _httpClient = httpClient;
        _registrationEndpoint = registrationEndpoint;
    }
    
    public async Task<ClientRegistrationResponse> RegisterClientAsync(ClientRegistrationRequest request)
    {
        var content = new StringContent(
            JsonSerializer.Serialize(request),
            Encoding.UTF8,
            "application/json");
            
        var response = await _httpClient.PostAsync(_registrationEndpoint, content);
        
        if (!response.IsSuccessStatusCode)
        {
            var error = await response.Content.ReadAsStringAsync();
            throw new Exception($"Failed to register client: {error}");
        }
        
        var responseContent = await response.Content.ReadAsStringAsync();
        return JsonSerializer.Deserialize<ClientRegistrationResponse>(responseContent);
    }
}

var request = new ClientRegistrationRequest
{
    ClientName = "New Tenant App",
    RedirectUris = new[] { "https://tenant1.myapp.com/callback" },
    GrantTypes = new[] { "authorization_code" },
    ResponseTypes = new[] { "code" },
    TokenEndpointAuthMethod = "client_secret_basic"
};
 
var client = await _registrationService.RegisterClientAsync(request);
 
// Сохраняем полученные client_id и client_secret
_tenantRepository.SaveClientCredentials(tenantId, client.ClientId, client.ClientSecret);

public class ServiceToServiceAuthClient
{
    private readonly HttpClient _httpClient;
    private readonly string _tokenEndpoint;
    private readonly string _clientId;
    private readonly string _clientSecret;
    private readonly string _audience;
    private string _cachedToken;
    private DateTime _tokenExpiry;
    
    public ServiceToServiceAuthClient(
        HttpClient httpClient,
        string tokenEndpoint,
        string clientId,
        string clientSecret,
        string audience)
    {
        _httpClient = httpClient;
        _tokenEndpoint = tokenEndpoint;
        _clientId = clientId;
        _clientSecret = clientSecret;
        _audience = audience;
    }
    
    public async Task<string> GetAccessTokenAsync()
    {
        // Проверяем, не истек ли токен
        if (!string.IsNullOrEmpty(_cachedToken) && DateTime.UtcNow < _tokenExpiry)
        {
            return _cachedToken;
        }
        
        // Запрашиваем новый токен
        var parameters = new Dictionary<string, string>
        {
            ["grant_type"] = "client_credentials",
            ["client_id"] = _clientId,
            ["client_secret"] = _clientSecret,
            ["audience"] = _audience
        };
        
        var content = new FormUrlEncodedContent(parameters);
        var response = await _httpClient.PostAsync(_tokenEndpoint, content);
        
        if (!response.IsSuccessStatusCode)
        {
            throw new Exception("Failed to obtain service-to-service access token");
        }
        
        var responseContent = await response.Content.ReadAsStringAsync();
        var tokenResponse = JsonSerializer.Deserialize<TokenResponse>(responseContent);
        
        // Кэшируем токен
        _cachedToken = tokenResponse.AccessToken;
        _tokenExpiry = DateTime.UtcNow.AddSeconds(tokenResponse.ExpiresIn - 60); // Небольшой запас
        
        return _cachedToken;
    }
}

services.AddHttpClient<ServiceToServiceAuthClient>(client =>
{
    client.BaseAddress = new Uri("https://api.example.com");
})
.AddTransientHttpErrorPolicy(policy => policy.RetryAsync(3));
 
services.AddSingleton<ServiceToServiceAuthClient>(sp =>
{
    var httpClient = sp.GetRequiredService<IHttpClientFactory>()
        .CreateClient(nameof(ServiceToServiceAuthClient));
    return new ServiceToServiceAuthClient(
        httpClient,
        Configuration["Auth:TokenEndpoint"],
        Configuration["Auth:ClientId"],
        Configuration["Auth:ClientSecret"],
        Configuration["Auth:Audience"]);
});

public class EncryptedTokenStore : ITokenStore
{
    private readonly IDataProtector _protector;
    private readonly IDistributedCache _cache;
    
    public EncryptedTokenStore(
        IDataProtectionProvider dataProtectionProvider,
        IDistributedCache cache)
    {
        _protector = dataProtectionProvider.CreateProtector("TokenStore");
        _cache = cache;
    }
    
    public async Task SaveTokensAsync(string userId, string accessToken, string refreshToken)
    {
        // Шифруем токены перед сохранением
        var encryptedAccessToken = _protector.Protect(accessToken);
        var encryptedRefreshToken = _protector.Protect(refreshToken);
        
        await _cache.SetStringAsync($"AccessToken:{userId}", encryptedAccessToken, 
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(55) // Чуть меньше часа
            });
            
        await _cache.SetStringAsync($"RefreshToken:{userId}", encryptedRefreshToken,
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(14) // Обычно 2 недели
            });
    }
    
    public async Task<string> GetAccessTokenAsync(string userId)
    {
        var encryptedToken = await _cache.GetStringAsync($"AccessToken:{userId}");
        if (string.IsNullOrEmpty(encryptedToken))
        {
            return null;
        }
        
        return _protector.Unprotect(encryptedToken);
    }
    
    public async Task<string> GetRefreshTokenAsync(string userId)
    {
        var encryptedToken = await _cache.GetStringAsync($"RefreshToken:{userId}");
        if (string.IsNullOrEmpty(encryptedToken))
        {
            return null;
        }
        
        return _protector.Unprotect(encryptedToken);
    }
}

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

services.AddAuthentication(options =>
{
    // ... базовые настройки
})
.AddOpenIdConnect(options =>
{
    // ... другие настройки
    options.Events = new OpenIdConnectEvents
    {
        OnRemoteFailure = context =>
        {
            // Обрабатываем ошибку аутентификации
            context.HandleResponse();
            
            // Анализируем тип ошибки
            var error = context.Failure?.Message ?? context.ProtocolMessage.Error;
            
            if (error == "access_denied")
            {
                // Пользователь отменил вход - перенаправляем на страницу входа
                context.Response.Redirect("/Account/Login");
                return Task.CompletedTask;
            }
            
            if (error == "invalid_grant")
            {
                // Возможно, токен устарел - перенаправляем на страницу входа
                context.Response.Redirect("/Account/Login?expired=true");
                return Task.CompletedTask;
            }
            
            // Для остальных ошибок показываем страницу ошибки
            context.Response.Redirect($"/Error?message={Uri.EscapeDataString(error)}");
            return Task.CompletedTask;
        },
        OnAuthenticationFailed = context =>
        {
            // Логируем ошибку аутентификации
            var logger = context.HttpContext.RequestServices
                .GetRequiredService<ILogger<Startup>>();
            logger.LogError(context.Exception, "Authentication failed");
            
            // Если это проблема с сертификатом, возможно IdP использует 
            // самоподписанный сертификат в dev-среде
            if (context.Exception is SecurityTokenSignatureKeyNotFoundException)
            {
                context.SkipHandler();
                return Task.CompletedTask;
            }
            
            return Task.CompletedTask;
        }
    };
});

public class AuthErrorController : Controller
{
    private readonly ILogger<AuthErrorController> _logger;
    
    public AuthErrorController(ILogger<AuthErrorController> logger)
    {
        _logger = logger;
    }
    
    [AllowAnonymous]
    public IActionResult Index(string error)
    {
        _logger.LogWarning("Authentication error: {Error}", error);
        
        var viewModel = new AuthErrorViewModel
        {
            ErrorCode = error,
            UserFriendlyMessage = GetUserFriendlyMessage(error),
            SupportReference = GenerateSupportReference()
        };
        
        return View(viewModel);
    }
    
    private string GetUserFriendlyMessage(string errorCode)
    {
        return errorCode switch
        {
            "login_required" => "Вам необходимо войти в систему.",
            "invalid_request" => "Возникла техническая проблема при входе. Попробуйте позже.",
            "invalid_grant" => "Срок действия вашей сессии истек. Пожалуйста, войдите снова.",
            "insufficient_scope" => "У вас нет доступа к этому ресурсу.",
            "server_error" => "Сервер авторизации временно недоступен. Пожалуйста, повторите попытку позже.",
            _ => "Произошла ошибка при аутентификации. Пожалуйста, повторите попытку."
        };
    }
    
    private string GenerateSupportReference()
    {
        // Генерируем уникальный код для обращения в поддержку
        return $"AUTH-{DateTime.UtcNow:yyyyMMdd}-{Guid.NewGuid().ToString().Substring(0, 8)}";
    }
}

public class AccountController : Controller
{
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Logout()
    {
        // Локальный выход
        await HttpContext.SignOutAsync(CookieAuthenticationDefaults.AuthenticationScheme);
        
        // Выход из IdP
        return SignOut(
            new AuthenticationProperties { 
                RedirectUri = Url.Action("Index", "Home") 
            },
            OpenIdConnectDefaults.AuthenticationScheme);
    }
}

public class SignOutPublisher
{
    private readonly IMessageBroker _messageBroker;
    
    public SignOutPublisher(IMessageBroker messageBroker)
    {
        _messageBroker = messageBroker;
    }
    
    public async Task PublishSignOutEventAsync(string userId)
    {
        var signOutEvent = new SignOutEvent
        {
            UserId = userId,
            Timestamp = DateTimeOffset.UtcNow
        };
        
        await _messageBroker.PublishAsync("auth.signout", signOutEvent);
    }
}

public class SignOutEventHandler : IMessageHandler<SignOutEvent>
{
    private readonly ISessionStore _sessionStore;
    
    public SignOutEventHandler(ISessionStore sessionStore)
    {
        _sessionStore = sessionStore;
    }
    
    public async Task HandleAsync(SignOutEvent message)
    {
        // Инвалидируем сессию пользователя в этом сервисе
        await _sessionStore.InvalidateSessionsForUserAsync(message.UserId);
    }
}

public class OpenIdConnectConfigurer
{
    public static void Configure(OpenIdConnectOptions options)
    {
        // ... другие настройки
        
        // Добавляем обработчик для front-channel logout
        options.Events.OnSignedOutCallbackRedirect = context =>
        {
            context.HttpContext.Response.StatusCode = 200;
            return Task.CompletedTask;
        };
        
        options.Events.OnRedirectToIdentityProviderForSignOut = context =>
        {
            // Настраиваем URL для выхода из IdP
            var logoutUri = $"{context.ProtocolMessage.IssuerAddress}?id_token_hint={context.ProtocolMessage.IdTokenHint}";
            
            // Добавляем post_logout_redirect_uri если нужно
            var postLogoutUri = context.Properties.RedirectUri;
            if (!string.IsNullOrEmpty(postLogoutUri))
            {
                logoutUri += $"&post_logout_redirect_uri={Uri.EscapeDataString(postLogoutUri)}";
            }
            
            context.Response.Redirect(logoutUri);
            context.HandleResponse();
            
            return Task.CompletedTask;
        };
    }
}

public class SensitiveOperationsController : Controller
{
  [Authorize]
  public IActionResult TransferFunds()
  {
      // Проверяем, прошел ли пользователь MFA
      var identity = User.Identity as ClaimsIdentity;
      var amrClaim = identity?.FindFirst("amr");
      
      bool hasMfa = amrClaim?.Value.Contains("mfa") ?? false;
      
      if (!hasMfa)
      {
          // Если нет, запрашиваем MFA
          return Challenge(new AuthenticationProperties
          {
              RedirectUri = Url.Action(nameof(TransferFunds)),
              Items = 
              {
                  {"prompt", "login"},
                  {"acr_values", "mfa"}
              }
          }, OpenIdConnectDefaults.AuthenticationScheme);
      }
      
      // Пользователь прошел MFA, продолжаем операцию
      return View();
  }
}

public class MfaController : Controller
{
  private readonly IMfaService _mfaService;
  
  public MfaController(IMfaService mfaService)
  {
      _mfaService = mfaService;
  }
  
  [HttpGet]
  public IActionResult VerifyCode()
  {
      return View();
  }
  
  [HttpPost]
  public async Task<IActionResult> VerifyCode(VerifyCodeViewModel model)
  {
      if (!ModelState.IsValid)
      {
          return View(model);
      }
      
      var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
      
      if (string.IsNullOrEmpty(userId))
      {
          return RedirectToAction("Login", "Account");
      }
      
      var isValid = await _mfaService.ValidateCodeAsync(userId, model.Code);
      
      if (!isValid)
      {
          ModelState.AddModelError("", "Неверный код подтверждения.");
          return View(model);
      }
      
      // Добавляем claim о прохождении MFA
      var identity = User.Identity as ClaimsIdentity;
      identity?.AddClaim(new Claim("amr", "mfa"));
      
      // Обновляем аутентификационный тикет
      await HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, User);
      
      // Перенаправляем на защищенный ресурс
      return RedirectToAction("Index", "Dashboard");
  }
}

public class TotpMfaService : IMfaService
{
  private readonly IDataProtector _dataProtector;
  private readonly IUserRepository _userRepository;
  
  public TotpMfaService(
      IDataProtectionProvider dataProtectionProvider,
      IUserRepository userRepository)
  {
      _dataProtector = dataProtectionProvider.CreateProtector("Mfa.Totp");
      _userRepository = userRepository;
  }
  
  public async Task<bool> ValidateCodeAsync(string userId, string code)
  {
      var user = await _userRepository.GetUserByIdAsync(userId);
      if (user == null || string.IsNullOrEmpty(user.MfaSecretKey))
      {
          return false;
      }
      
      // Расшифровываем секретный ключ
      var secretKey = _dataProtector.Unprotect(user.MfaSecretKey);
      
      // Создаем TOTP на основе секретного ключа
      var totp = new Totp(Base32Encoding.ToBytes(secretKey));
      
      // Проверяем код
      return totp.VerifyTotp(code, out _, new VerificationWindow(2, 2));
  }
  
  public async Task<string> GenerateQrCodeUriAsync(string userId, string email)
  {
      // Генерируем секретный ключ для пользователя
      var secretKey = KeyGeneration.GenerateRandomKey(20);
      var base32Secret = Base32Encoding.ToString(secretKey);
      
      // Шифруем и сохраняем
      var protectedSecret = _dataProtector.Protect(base32Secret);
      await _userRepository.SetMfaSecretKeyAsync(userId, protectedSecret);
      
      // Генерируем URI для QR-кода
      var issuer = "MyApplication";
      var totp = new Totp(secretKey);
      return totp.GenerateQrCodeUri(issuer, email);
  }
}

public class Startup
{
  public Startup(IConfiguration configuration, IHostEnvironment environment)
  {
      // Базовая конфигурация
      var builder = new ConfigurationBuilder()
          .SetBasePath(environment.ContentRootPath)
          .AddJsonFile("appsettings.json")
          .AddJsonFile($"appsettings.{environment.EnvironmentName}.json", optional: true)
          .AddEnvironmentVariables();
      
      if (environment.IsProduction())
      {
          // Добавляем Azure Key Vault как источник секретов
          var builtConfig = builder.Build();
          var keyVaultEndpoint = $"https://{builtConfig["KeyVault:Name"]}.vault.azure.net/";
          
          builder.AddAzureKeyVault(keyVaultEndpoint, new DefaultAzureCredential());
      }
      
      Configuration = builder.Build();
  }
  
  // ... остальная часть Startup
}

public class UserRepository : IUserRepository
{
  private readonly ApplicationDbContext _context;
  private readonly IDataProtector _protector;
  
  public UserRepository(
      ApplicationDbContext context,
      IDataProtectionProvider dataProtectionProvider)
  {
      _context = context;
      _protector = dataProtectionProvider.CreateProtector("UserSecrets");
  }
  
  public async Task<User> GetUserByIdAsync(string userId)
  {
      var user = await _context.Users.FindAsync(userId);
      if (user == null)
      {
          return null;
      }
      
      // Расшифровываем чувствительные данные
      if (!string.IsNullOrEmpty(user.EncryptedApiKey))
      {
          user.ApiKey = _protector.Unprotect(user.EncryptedApiKey);
      }
      
      return user;
  }
  
  public async Task SaveApiKeyAsync(string userId, string apiKey)
  {
      var user = await _context.Users.FindAsync(userId);
      if (user == null)
      {
          throw new KeyNotFoundException($"User with ID {userId} not found");
      }
      
      // Шифруем перед сохранением
      user.EncryptedApiKey = _protector.Protect(apiKey);
      user.ApiKey = null; // Не храним в памяти
      
      await _context.SaveChangesAsync();
  }
}

services.AddAuthentication()
  .AddJwtBearer(options =>
  {
      // ... другие настройки
      
      // Настраиваем кэширование
      options.ConfigurationManager = new ConfigurationManager<OpenIdConnectConfiguration>(
          options.MetadataAddress,
          new OpenIdConnectConfigurationRetriever(),
          new HttpDocumentRetriever { RequireHttps = true })
      {
          AutomaticRefreshInterval = TimeSpan.FromHours(24),
          RefreshInterval = TimeSpan.FromHours(12)
      };
  });

public class LocalTokenValidator
{
  private readonly IMemoryCache _cache;
  private readonly HttpClient _httpClient;
  private readonly string _issuer;
  
  public LocalTokenValidator(
      IMemoryCache cache,
      HttpClient httpClient,
      string issuer)
  {
      _cache = cache;
      _httpClient = httpClient;
      _issuer = issuer;
  }
  
  public async Task<ClaimsPrincipal> ValidateTokenAsync(string token)
  {
      var jwks = await GetJwksAsync();
      var handler = new JwtSecurityTokenHandler();
      
      var validationParameters = new TokenValidationParameters
      {
          ValidateIssuer = true,
          ValidIssuer = _issuer,
          ValidateAudience = true,
          ValidAudience = "myapi",
          IssuerSigningKeys = jwks.Keys,
          ValidateLifetime = true,
          ClockSkew = TimeSpan.FromMinutes(5)
      };
      
      return handler.ValidateToken(token, validationParameters, out _);
  }
  
  private async Task<JsonWebKeySet> GetJwksAsync()
  {
      // Пытаемся получить JWKS из кэша
      if (!_cache.TryGetValue("jwks", out JsonWebKeySet jwks))
      {
          // Если в кэше нет, загружаем с сервера
          var response = await _httpClient.GetStringAsync($"{_issuer}/.well-known/jwks.json");
          jwks = JsonConvert.DeserializeObject<JsonWebKeySet>(response);
          
          // Сохраняем в кэш
          _cache.Set("jwks", jwks, TimeSpan.FromHours(24));
      }
      
      return jwks;
  }
}

public class OptimizedAuthenticationHandler : AuthenticationHandler<JwtBearerOptions>
{
  public OptimizedAuthenticationHandler(
      IOptionsMonitor<JwtBearerOptions> options,
      ILoggerFactory logger,
      UrlEncoder encoder,
      ISystemClock clock)
      : base(options, logger, encoder, clock)
  {
  }
  
  protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
  {
      // Асинхронно получаем токен из заголовка
      var token = GetTokenFromHeader();
      if (token == null)
      {
          return AuthenticateResult.NoResult();
      }
      
      try
      {
          // Асинхронно валидируем токен
          var principal = await ValidateTokenAsync(token);
          var ticket = new AuthenticationTicket(principal, Scheme.Name);
          return AuthenticateResult.Success(ticket);
      }
      catch (Exception ex)
      {
          return AuthenticateResult.Fail(ex);
      }
  }
  
  private async Task<ClaimsPrincipal> ValidateTokenAsync(string token)
  {
      // Асинхронная валидация токена
      // ...
  }
}

public class ActiveDirectoryAuthService
{
  private readonly string _ldapServer;
  private readonly string _domain;
  
  public ActiveDirectoryAuthService(string ldapServer, string domain)
  {
      _ldapServer = ldapServer;
      _domain = domain;
  }
  
  public async Task<bool> ValidateCredentialsAsync(string username, string password)
  {
      return await Task.Run(() =>
      {
          try
          {
              using var connection = new LdapConnection(new LdapDirectoryIdentifier(_ldapServer));
              connection.SessionOptions.ProtocolVersion = 3;
              
              // Формируем имя пользователя в формате UPN
              var userPrincipalName = $"{username}@{_domain}";
              
              // Пытаемся выполнить bind с учетными данными пользователя
              connection.Bind(new NetworkCredential(userPrincipalName, password));
              
              return true;
          }
          catch (LdapException)
          {
              return false;
          }
      });
  }
  
  public async Task<UserInfo> GetUserInfoAsync(string username)
  {
      return await Task.Run(() =>
      {
          using var connection = new LdapConnection(new LdapDirectoryIdentifier(_ldapServer));
          connection.SessionOptions.ProtocolVersion = 3;
          
          // Подключаемся с сервисной учетной записью
          connection.Bind(new NetworkCredential(
              "serviceAccount",
              "servicePassword", 
              _domain));
          
          // Ищем пользователя
          var request = new SearchRequest(
              $"DC={string.Join(",DC=", _domain.Split('.'))}",
              $"(sAMAccountName={username})",
              SearchScope.Subtree,
              new string[] { "givenName", "sn", "mail", "memberOf" });
              
          var response = (SearchResponse)connection.SendRequest(request);
          
          if (response.Entries.Count == 0)
          {
              return null;
          }
          
          var entry = response.Entries[0];
          
          return new UserInfo
          {
              FirstName = entry.GetAttribute("givenName")?.StringValue,
              LastName = entry.GetAttribute("sn")?.StringValue,
              Email = entry.GetAttribute("mail")?.StringValue,
              Groups = GetGroups(entry.GetAttribute("memberOf"))
          };
      });
  }
  
  private List<string> GetGroups(DirectoryAttribute memberOf)
  {
      if (memberOf == null)
      {
          return new List<string>();
      }
      
      var groups = new List<string>();
      
      foreach (var group in memberOf.GetValues(typeof(string)))
      {
          // Извлекаем имя группы из DN
          var match = Regex.Match(group.ToString(), "CN=([^,]+)");
          if (match.Success)
          {
              groups.Add(match.Groups[1].Value);
          }
      }
      
      return groups;
  }
}

public class ActiveDirectoryResourceOwnerPasswordValidator : IResourceOwnerPasswordValidator
{
  private readonly ActiveDirectoryAuthService _adAuthService;
  private readonly IUserRepository _userRepository;
  
  public ActiveDirectoryResourceOwnerPasswordValidator(
      ActiveDirectoryAuthService adAuthService,
      IUserRepository userRepository)
  {
      _adAuthService = adAuthService;
      _userRepository = userRepository;
  }
  
  public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
  {
      // Проверяем учетные данные в Active Directory
      var isValid = await _adAuthService.ValidateCredentialsAsync(
          context.UserName, context.Password);
          
      if (!isValid)
      {
          context.Result = new GrantValidationResult(
              TokenRequestErrors.InvalidGrant,
              "Invalid username or password");
          return;
      }
      
      // Получаем информацию о пользователе
      var userInfo = await _adAuthService.GetUserInfoAsync(context.UserName);
      
      if (userInfo == null)
      {
          context.Result = new GrantValidationResult(
              TokenRequestErrors.InvalidGrant,
              "User not found in directory");
          return;
      }
      
      // Проверяем, есть ли пользователь в нашей базе
      var user = await _userRepository.GetUserByUsernameAsync(context.UserName);
      
      if (user == null)
      {
          // Создаем нового пользователя
          user = new User
          {
              Username = context.UserName,
              Email = userInfo.Email,
              FirstName = userInfo.FirstName,
              LastName = userInfo.LastName
          };
          
          await _userRepository.CreateUserAsync(user);
      }
      
      // Успешная аутентификация
      var claims = new List<Claim>
      {
          new Claim(JwtClaimTypes.Subject, user.Id),
          new Claim(JwtClaimTypes.Name, $"{userInfo.FirstName} {userInfo.LastName}"),
          new Claim(JwtClaimTypes.Email, userInfo.Email)
      };
      
      // Добавляем роли из групп Active Directory
      foreach (var group in userInfo.Groups)
      {
          claims.Add(new Claim(JwtClaimTypes.Role, group));
      }
      
      context.Result = new GrantValidationResult(
          user.Id, "ad", claims);
  }
}

// Program.cs
using Microsoft.AspNetCore.Authentication.Cookies;
using Microsoft.AspNetCore.Authentication.OpenIdConnect;
using Microsoft.IdentityModel.Protocols.OpenIdConnect;
using Microsoft.IdentityModel.Tokens;
using System.Security.Claims;
 
var builder = WebApplication.CreateBuilder(args);
 
// Добавляем services
builder.Services.AddControllersWithViews();
 
// Настройка аутентификации
builder.Services.AddAuthentication(options => {
    options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
    options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
})
.AddCookie(options => {
    options.Cookie.HttpOnly = true;
    options.Cookie.SecurePolicy = CookieSecurePolicy.Always;
    options.Cookie.SameSite = SameSiteMode.Strict;
})
.AddOpenIdConnect(options => {
    // Настройки Auth0
    options.Authority = $"https://{builder.Configuration["Auth0:Domain"]}";
    options.ClientId = builder.Configuration["Auth0:ClientId"];
    options.ClientSecret = builder.Configuration["Auth0:ClientSecret"];
    options.ResponseType = OpenIdConnectResponseType.Code;
    
    // Настройки области
    options.Scope.Clear();
    options.Scope.Add("openid");
    options.Scope.Add("profile");
    options.Scope.Add("email");
    
    // Настройки маппинга claims
    options.TokenValidationParameters = new TokenValidationParameters {
        NameClaimType = "name",
        RoleClaimType = "https://myapp.com/roles"
    };
    
    // Сохраняем токены
    options.SaveTokens = true;
    
    // Обработчики событий
    options.Events = new OpenIdConnectEvents {
        OnTokenValidated = async context => {
            // Здесь можно выполнять дополнительную валидацию или маппинг ролей
            var identity = context.Principal.Identity as ClaimsIdentity;
            
            // Получаем информацию о пользователе из токена
            var userId = context.SecurityToken.Subject;
            var email = identity.FindFirst(ClaimTypes.Email)?.Value;
            
            // Проверяем, существует ли пользователь в нашей БД
            var userService = context.HttpContext.RequestServices.GetRequiredService<IUserService>();
            var user = await userService.GetUserByExternalIdAsync(userId);
            
            if (user == null) {
                // Создаем пользователя, если его нет
                user = new User {
                    ExternalId = userId,
                    Email = email,
                    Name = identity.FindFirst(ClaimTypes.Name)?.Value ?? email
                };
                
                await userService.CreateUserAsync(user);
            }
            
            // Добавляем роли из нашей системы
            var roles = await userService.GetUserRolesAsync(user.Id);
            foreach (var role in roles) {
                identity.AddClaim(new Claim(context.Options.TokenValidationParameters.RoleClaimType, role));
            }
        },
        OnRedirectToIdentityProvider = context => {
            // Можно модифицировать запрос перед переадресацией к IdP
            return Task.CompletedTask;
        },
        OnRemoteFailure = context => {
            context.Response.Redirect("/Error/Auth");
            context.HandleResponse();
            return Task.CompletedTask;
        }
    };
});
 
// Добавляем пользовательские сервисы
builder.Services.AddHttpClient();
builder.Services.AddScoped<IUserService, UserService>();
builder.Services.AddScoped<ITokenService, TokenService>();
 
// Настройка авторизации
builder.Services.AddAuthorization(options => {
    options.AddPolicy("RequireAdminRole", policy => policy.RequireRole("Admin"));
    options.AddPolicy("RequireMfa", policy => 
        policy.RequireClaim("amr", "mfa"));
});
 
var app = builder.Build();
 
// Настройка middleware
if (app.Environment.IsDevelopment()) {
    app.UseDeveloperExceptionPage();
} else {
    app.UseExceptionHandler("/Home/Error");
    app.UseHsts();
}
 
app.UseHttpsRedirection();
app.UseStaticFiles();
app.UseRouting();
app.UseAuthentication();
app.UseAuthorization();
 
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
 
app.Run();

public void ConfigureServices(IServiceCollection services)
{
    services.AddCors(options =>
    {
        options.AddPolicy("SsoPolicy", builder =>
        {
            builder
                .WithOrigins(
                    "https://app1.example.com",
                    "https://app2.example.com")
                .AllowAnyMethod()
                .AllowAnyHeader()
                .AllowCredentials(); // Важно для передачи куки между доменами
        });
    });
    
    // Остальные сервисы
}
 
public void Configure(IApplicationBuilder app)
{
    // CORS должен быть настроен до маршрутизации
    app.UseCors("SsoPolicy");
    
    // Другие middleware
    app.UseAuthentication();
    app.UseAuthorization();
}

services.AddAuthentication()
    .AddOpenIdConnect("AzureAD", options =>
    {
        options.Authority = "https://login.microsoftonline.com/common";
        options.ClientId = Configuration["Authentication:AzureAd:ClientId"];
        options.CallbackPath = "/signin-azuread";
        // Другие настройки Azure AD
    })
    .AddOpenIdConnect("Auth0", options =>
    {
        options.Authority = $"https://{Configuration["Authentication:Auth0:Domain"]}";
        options.ClientId = Configuration["Authentication:Auth0:ClientId"];
        options.CallbackPath = "/signin-auth0";
        // Другие настройки Auth0
    });

public class AccountController : Controller
{
    public IActionResult Login(string returnUrl = "/")
    {
        return View(new LoginViewModel { ReturnUrl = returnUrl });
    }
    
    [HttpPost]
    public IActionResult ExternalLogin(string provider, string returnUrl = "/")
    {
        // Указываем, какой провайдер должен обрабатывать аутентификацию
        return Challenge(new AuthenticationProperties 
        { 
            RedirectUri = returnUrl 
        }, provider);
    }
}

public class SecurityTokenService
{
    private readonly IDistributedCache _cache;
    private readonly IDataProtector _protector;
    
    public SecurityTokenService(
        IDistributedCache cache,
        IDataProtectionProvider dataProtectionProvider)
    {
        _cache = cache;
        _protector = dataProtectionProvider.CreateProtector("SecurityTokens");
    }
    
    public async Task<string> GenerateOperationTokenAsync(string userId, string operation)
    {
        // Создаем уникальный токен
        var tokenId = Guid.NewGuid().ToString();
        var tokenData = new OperationTokenData
        {
            UserId = userId,
            Operation = operation,
            CreatedAt = DateTime.UtcNow
        };
        
        // Шифруем данные токена
        var serializedData = JsonSerializer.Serialize(tokenData);
        var protectedData = _protector.Protect(serializedData);
        
        // Сохраняем в кэш с временем жизни
        await _cache.SetStringAsync(
            $"op_token:{tokenId}", 
            protectedData, 
            new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(15)
            });
        
        return tokenId;
    }
    
    public async Task<OperationTokenData> ValidateOperationTokenAsync(string tokenId)
    {
        var cacheKey = $"op_token:{tokenId}";
        var protectedData = await _cache.GetStringAsync(cacheKey);
        
        if (string.IsNullOrEmpty(protectedData))
        {
            return null; // Токен не найден или истек
        }
        
        try
        {
            // Расшифровываем и проверяем данные
            var serializedData = _protector.Unprotect(protectedData);
            var tokenData = JsonSerializer.Deserialize<OperationTokenData>(serializedData);
            
            // Одноразовый токен - удаляем после использования
            await _cache.RemoveAsync(cacheKey);
            
            return tokenData;
        }
        catch
        {
            return null; // Ошибка при расшифровке
        }
    }
}

[Authorize]
public class PaymentController : Controller
{
    private readonly SecurityTokenService _securityTokenService;
    
    // ... конструктор и внедрение зависимостей
    
    [HttpGet]
    public IActionResult Confirm(decimal amount, string recipientId)
    {
        // Сохраняем детали операции в сессии или TempData
        TempData["PaymentAmount"] = amount;
        TempData["RecipientId"] = recipientId;
        
        return View();
    }
    
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> Confirm(string confirmationCode)
    {
        // Получаем детали из TempData
        var amount = (decimal)TempData["PaymentAmount"];
        var recipientId = (string)TempData["RecipientId"];
        
        var userId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        
        // Генерируем токен для этой операции
        var operationToken = await _securityTokenService
            .GenerateOperationTokenAsync(userId, $"payment:{amount}:{recipientId}");
        
        // Отправляем пользователю код подтверждения (SMS, email и т.д.)
        await _notificationService.SendConfirmationCodeAsync(userId, operationToken);
        
        return RedirectToAction(nameof(ExecutePayment), new { token = operationToken });
    }
    
    [HttpPost]
    [ValidateAntiForgeryToken]
    public async Task<IActionResult> ExecutePayment(string token, string confirmationCode)
    {
        // Проверяем токен операции
        var tokenData = await _securityTokenService.ValidateOperationTokenAsync(token);
        
        if (tokenData == null)
        {
            return BadRequest("Invalid or expired operation token");
        }
        
        // Проверяем, что операция инициирована текущим пользователем
        var currentUserId = User.FindFirst(ClaimTypes.NameIdentifier)?.Value;
        if (currentUserId != tokenData.UserId)
        {
            return Unauthorized();
        }
        
        // Парсим информацию об операции
        var parts = tokenData.Operation.Split(':');
        if (parts.Length != 3 || parts[0] != "payment")
        {
            return BadRequest("Invalid operation");
        }
        
        var amount = decimal.Parse(parts[1]);
        var recipientId = parts[2];
        
        // Проверяем код подтверждения
        if (!await _verificationService.VerifyCodeAsync(currentUserId, token, confirmationCode))
        {
            ModelState.AddModelError("", "Неверный код подтверждения");
            return View();
        }
        
        // Выполняем платеж
        var result = await _paymentService.ExecutePaymentAsync(
            currentUserId, recipientId, amount);
        
        return RedirectToAction("Receipt", new { id = result.TransactionId });
    }
}

public class SecurityAuditService : ISecurityAuditService
{
    private readonly ApplicationDbContext _dbContext;
    private readonly IHttpContextAccessor _httpContextAccessor;
    
    public SecurityAuditService(
        ApplicationDbContext dbContext,
        IHttpContextAccessor httpContextAccessor)
    {
        _dbContext = dbContext;
        _httpContextAccessor = httpContextAccessor;
    }
    
    public async Task LogAuthenticationEventAsync(
        string userId, 
        string eventType,
        bool success,
        string details = null)
    {
        var auditEvent = new AuthenticationAuditEvent
        {
            UserId = userId,
            EventType = eventType,
            EventTime = DateTime.UtcNow,
            Success = success,
            Details = details,
            IpAddress = GetUserIpAddress(),
            UserAgent = GetUserAgent()
        };
        
        _dbContext.AuthenticationEvents.Add(auditEvent);
        await _dbContext.SaveChangesAsync();
    }
    
    private string GetUserIpAddress()
    {
        var httpContext = _httpContextAccessor.HttpContext;
        if (httpContext == null) return null;
        
        // Учитываем возможные прокси
        var forwardedFor = httpContext.Request.Headers["X-Forwarded-For"].FirstOrDefault();
        return !string.IsNullOrEmpty(forwardedFor) 
            ? forwardedFor.Split(',')[0].Trim() 
            : httpContext.Connection.RemoteIpAddress?.ToString();
    }
    
    private string GetUserAgent()
    {
        var httpContext = _httpContextAccessor.HttpContext;
        return httpContext?.Request.Headers["User-Agent"].ToString();
    }
}

services.AddAuthentication()
    .AddOpenIdConnect(options =>
    {
        // ... другие настройки
        
        options.Events = new OpenIdConnectEvents
        {
            OnTokenValidated = async context =>
            {
                var auditService = context.HttpContext.RequestServices
                    .GetRequiredService<ISecurityAuditService>();
                
                var userId = context.Principal.FindFirst(ClaimTypes.NameIdentifier)?.Value;
                
                await auditService.LogAuthenticationEventAsync(
                    userId,
                    "TokenValidated",
                    true,
                    $"Provider: {options.Authority}");
            },
            
            OnAuthenticationFailed = async context =>
            {
                var auditService = context.HttpContext.RequestServices
                    .GetRequiredService<ISecurityAuditService>();
                
                await auditService.LogAuthenticationEventAsync(
                    null, // UserId неизвестен при неудачной аутентификации
                    "AuthenticationFailed",
                    false,
                    $"Error: {context.Exception.Message}");
            },
            
            // Другие события...
        };
    });