Системы нулевого доверия на C#

builder.Services.AddAuthentication(options =>
{
    options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(options =>
{
    options.Authority = "https://login.microsoftonline.com/{tenantId}/v2.0";
    options.Audience = "api://your-api-client-id";
    options.TokenValidationParameters = new TokenValidationParameters
    {
        ValidateIssuer = true,
        ValidateAudience = true,
        ValidateLifetime = true,
        ValidateIssuerSigningKey = true
    };
});

builder.Services.AddAuthorization(options =>
{
    options.AddPolicy("FinanceReportsReader", policy =>
        policy.RequireRole("Finance")
              .RequireClaim("Department", "Accounting")
              .RequireClaim("DataAccessLevel", "Confidential"));
});

[Authorize(Policy = "FinanceReportsReader")]
public IActionResult GetFinancialReport(int quarter)
{
    // Доступ только для финансистов с нужным уровнем доступа
    return Ok(_reportService.GetQuarterlyReport(quarter));
}

public static IHostBuilder CreateHostBuilder(string[] args) =>
    Host.CreateDefaultBuilder(args)
        .ConfigureWebHostDefaults(webBuilder =>
        {
            webBuilder.UseStartup<Startup>()
                .ConfigureKestrel(options =>
                {
                    options.ConfigureHttpsDefaults(https =>
                    {
                        https.ClientCertificateMode = ClientCertificateMode.RequireCertificate;
                        https.CheckCertificateRevocation = true;
                    });
                });
        });

app.Use(async (context, next) =>
{
    if (!context.Connection.ClientCertificate?.Verify() ?? false)
    {
        context.Response.StatusCode = 403;
        await context.Response.WriteAsync("Invalid client certificate");
        return;
    }
    
    await next();
});

// Настройка защиты данных
services.AddDataProtection()
    .PersistKeysToAzureKeyVault(new Uri("https://myvault.vault.azure.net/keys/dataprotection"))
    .ProtectKeysWithAzureKeyVault("<keyIdentifier>", "<clientId>", "<clientSecret>");

public class SecureServiceClient : IServiceClient
{
    private readonly HttpClient _httpClient;
    private readonly ITokenProvider _tokenProvider;
    private readonly ILogger _logger;
 
    public SecureServiceClient(HttpClient httpClient, ITokenProvider tokenProvider, ILogger logger)
    {
        _httpClient = httpClient;
        _tokenProvider = tokenProvider;
        _logger = logger;
    }
 
    public async Task<TResponse> SendAsync<TRequest, TResponse>(string endpoint, TRequest request)
    {
        // Получаем токен для конкретного вызова
        var token = await _tokenProvider.GetTokenForServiceAsync(endpoint);
        
        // Добавляем контекст безопасности
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
        _httpClient.DefaultRequestHeaders.Add("X-Request-ID", Guid.NewGuid().ToString());
        _httpClient.DefaultRequestHeaders.Add("X-Calling-Service", Assembly.GetEntryAssembly().GetName().Name);
        
        // Логируем вызов для отслеживания цепочки запросов
        _logger.LogInformation("Calling service {Endpoint} with request ID {RequestId}", 
            endpoint, _httpClient.DefaultRequestHeaders.GetValues("X-Request-ID").First());
        
        var response = await _httpClient.PostAsJsonAsync(endpoint, request);
        response.EnsureSuccessStatusCode();
        
        return await response.Content.ReadFromJsonAsync<TResponse>();
    }
}

public class SecureOrderService : IOrderService
{
    private readonly IOrderRepository _repository;
    private readonly IAuthorizationService _authService;
    private readonly IUserContextProvider _userProvider;
 
    // ... конструктор опущен для краткости
 
    public async Task<OrderDetails> GetOrderAsync(int orderId)
    {
        var user = _userProvider.GetCurrentUser();
        var order = await _repository.GetByIdAsync(orderId);
        
        // Проверка на уровне бизнес-логики
        if (order == null)
            throw new NotFoundException("Order not found");
            
        // Многоуровневая авторизация
        var authResult = await _authService.AuthorizeAsync(user, order, Operations.View);
        if (!authResult.Succeeded)
        {
            _logger.LogWarning("Access denied to order {OrderId} for user {UserId}", 
                orderId, user.Id);
            throw new ForbiddenException("You don't have permission to view this order");
        }
        
        // Даже после авторизации фильтруем конфиденциальные данные
        return SanitizeOrderDetails(order, user);
    }
    
    private OrderDetails SanitizeOrderDetails(Order order, ClaimsPrincipal user)
    {
        var details = new OrderDetails
        {
            Id = order.Id,
            Status = order.Status,
            CreatedAt = order.CreatedAt,
            // Базовая информация доступна всем
        };
        
        // Финансовые данные видны только с правильными правами
        if (user.HasClaim("Permission", "ViewFinancialData"))
        {
            details.TotalAmount = order.TotalAmount;
            details.PaymentDetails = order.PaymentDetails;
        }
        
        return details;
    }
}

public interface ISecurityValidator
{
    Task<ValidationResult> ValidateAsync(HttpContext context, Func<Task<ValidationResult>> next);
}
 
public class RateLimitValidator : ISecurityValidator
{
    public async Task<ValidationResult> ValidateAsync(HttpContext context, Func<Task<ValidationResult>> next)
    {
        var clientIp = context.Connection.RemoteIpAddress.ToString();
        var endpoint = context.Request.Path;
        
        // Проверяем лимиты запросов
        if (!await _rateLimiter.CheckLimitAsync(clientIp, endpoint))
        {
            return ValidationResult.Fail("Rate limit exceeded");
        }
        
        // Передаем эстафету следующему валидатору
        return await next();
    }
}
 
public class JwtValidator : ISecurityValidator
{
    public async Task<ValidationResult> ValidateAsync(HttpContext context, Func<Task<ValidationResult>> next)
    {
        // Проверка JWT токена
        if (!context.Request.Headers.TryGetValue("Authorization", out var authHeader))
        {
            return ValidationResult.Fail("Missing authentication token");
        }
        
        try
        {
            var token = authHeader.ToString().Replace("Bearer ", "");
            var principal = _jwtService.ValidateToken(token);
            context.User = principal;
            
            // Проверяем не в черном ли списке токен
            if (await _tokenBlacklist.IsBlacklistedAsync(token))
            {
                return ValidationResult.Fail("Token has been revoked");
            }
        }
        catch (Exception ex)
        {
            return ValidationResult.Fail($"Invalid token: {ex.Message}");
        }
        
        return await next();
    }
}

public interface ISecurityEventPublisher
{
    Task PublishAsync(SecurityEvent securityEvent);
}
 
public class SecurityEventHandler : INotificationHandler<EntityModifiedEvent>
{
    private readonly ISecurityEventPublisher _publisher;
    private readonly IUserContext _userContext;
    
    // ... конструктор
    
    public async Task Handle(EntityModifiedEvent notification, CancellationToken cancellationToken)
    {
        var user = _userContext.CurrentUser;
        
        await _publisher.PublishAsync(new SecurityEvent
        {
            EventType = SecurityEventType.EntityModified,
            ResourceType = notification.Entity.GetType().Name,
            ResourceId = notification.Entity.Id.ToString(),
            UserId = user?.Id,
            UserName = user?.Name,
            IpAddress = _userContext.IpAddress,
            Timestamp = DateTime.UtcNow,
            Details = JsonSerializer.Serialize(new
            {
                OldValues = notification.OldValues,
                NewValues = notification.NewValues,
                ChangedProperties = notification.ChangedProperties
            })
        });
    }
}

public class ProofOfCallMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IServiceSignatureValidator _validator;
 
    public ProofOfCallMiddleware(RequestDelegate next, IServiceSignatureValidator validator)
    {
        _next = next;
        _validator = validator;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        // Извлекаем сигнатуру вызова
        context.Request.Headers.TryGetValue("X-Service-Signature", out var signature);
        context.Request.Headers.TryGetValue("X-Calling-Service", out var callerService);
        context.Request.Headers.TryGetValue("X-Timestamp", out var timestamp);
 
        // Проверяем подлинность запроса
        var requestBody = await GetRequestBodyAsync(context);
        var isValid = await _validator.ValidateAsync(callerService, requestBody, timestamp, signature);
 
        if (!isValid)
        {
            context.Response.StatusCode = StatusCodes.Status403Forbidden;
            await context.Response.WriteAsync("Invalid service signature");
            return;
        }
 
        await _next(context);
    }
 
    // Метод для чтения тела запроса опущен
}

// Класс определяет изолированный контекст безопасности для сервиса
public class ServiceSecurityContext
{
    public string ServiceId { get; }
    public X509Certificate2 ServiceCertificate { get; }
    public string[] AllowedCallers { get; }
    public Dictionary<string, string[]> ResourcePermissions { get; }
    
    // Полная изоляция контекста безопасности
    public ServiceSecurityContext(ISecurityConfigProvider configProvider)
    {
        var config = configProvider.GetSecurityConfig();
        ServiceId = config.ServiceId;
        ServiceCertificate = new X509Certificate2(config.CertificatePath, config.CertificatePassword);
        AllowedCallers = config.AllowedCallers;
        ResourcePermissions = config.ResourcePermissions;
    }
}

// Традиционный подход - проверка по IP-адресу или внутренней сети
app.UseMiddleware<IntranetOnlyMiddleware>();
 
public class IntranetOnlyMiddleware
{
    private readonly RequestDelegate _next;
    private readonly string[] _allowedNetworks = { "10.0.0.0/8", "172.16.0.0/12", "192.168.0.0/16" };
 
    public IntranetOnlyMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var ipAddress = context.Connection.RemoteIpAddress;
        var isAllowed = _allowedNetworks.Any(network => IsInNetwork(ipAddress, network));
 
        if (!isAllowed)
        {
            context.Response.StatusCode = 403;
            await context.Response.WriteAsync("Access denied: outside corporate network");
            return;
        }
 
        // Если IP проверку прошли, доверяем полностью
        await _next(context);
    }
 
    // Метод проверки принадлежности к подсети опущен
}

// Подход Zero Trust - проверка каждого запроса вне зависимости от источника
app.UseAuthentication();
app.UseAuthorization();
 
// Дополнительно проверяем контекст каждого запроса
app.Use(async (context, next) =>
{
    // Проверяем аутентификацию
    if (!context.User.Identity.IsAuthenticated)
    {
        context.Response.StatusCode = 401;
        return;
    }
 
    // Проверяем легитимность устройства
    if (!await IsDeviceTrustedAsync(context))
    {
        context.Response.StatusCode = 403;
        await context.Response.WriteAsync("Unregistered device");
        return;
    }
 
    // Проверяем местоположение и время
    if (!IsAccessTimeValid(context) || !IsLocationAllowed(context))
    {
        context.Response.StatusCode = 403;
        await context.Response.WriteAsync("Access restricted based on time or location");
        return;
    }
 
    await next();
});

// Традиционный подход: проверка роли один раз при входе
[Authorize(Roles = "Admin")]
public class AdminController : ControllerBase
{
    // Все методы доступны любому админу без дополнительных проверок
    public IActionResult GetSensitiveData()
    {
        return Ok(_repository.GetAllSensitiveData());
    }
}

// Zero Trust подход: детальная проверка на уровне методов
public class SecureAdminController : ControllerBase
{
    private readonly IAuthorizationService _authService;
 
    // Проверка доступа для каждой операции индивидуально
    public async Task<IActionResult> GetSensitiveData([FromQuery] string dataId)
    {
        // Проверяем базовую аутентификацию
        if (!User.Identity.IsAuthenticated)
            return Unauthorized();
        
        // Проверяем авторизацию для конкретной операции с конкретными данными
        var authResult = await _authService.AuthorizeAsync(User, dataId, Operations.Read);
        if (!authResult.Succeeded)
            return Forbid();
        
        // Проверяем, соответствует ли контекст доступа политике
        if (Request.Headers.TryGetValue("X-Device-Id", out var deviceId))
        {
            var isDeviceTrusted = await _deviceVerifier.IsTrustedAsync(deviceId);
            if (!isDeviceTrusted)
                return Forbid("Untrusted device");
        }
        
        // Только после всех проверок предоставляем доступ
        var data = await _repository.GetSensitiveDataByIdAsync(dataId);
        
        // И даже тут может быть дополнительная фильтрация
        return Ok(_sanitizer.SanitizeForUser(data, User));
    }
}

// Настройка MFA с использованием ASP.NET Core Identity
services.AddIdentity<ApplicationUser, IdentityRole>(options =>
{
    // Требуем подтвержденный email
    options.SignIn.RequireConfirmedEmail = true;
    
    // Настройка двухфакторной аутентификации
    options.Tokens.AuthenticatorTokenProvider = TokenOptions.DefaultAuthenticatorProvider;
    options.Lockout.MaxFailedAccessAttempts = 5;
})
.AddEntityFrameworkStores<ApplicationDbContext>()
.AddDefaultTokenProviders()
.AddTokenProvider<AuthenticatorTokenProvider<ApplicationUser>>(TokenOptions.DefaultAuthenticatorProvider);

services.AddAuthentication(options =>
{
    options.DefaultScheme = "Cookies";
    options.DefaultChallengeScheme = "OIDC";
})
.AddCookie("Cookies")
.AddOpenIdConnect("OIDC", options =>
{
    options.Authority = "https://login.microsoftonline.com/tenant-id/v2.0";
    options.ClientId = "client-id";
    options.ClientSecret = "client-secret";
    options.ResponseType = "code";
    options.Scope.Add("openid");
    options.Scope.Add("profile");
    options.Scope.Add("api://resource-id/access");
    options.SaveTokens = true;
    
    // Запрашиваем MFA при каждом логине
    options.Events = new OpenIdConnectEvents
    {
        OnRedirectToIdentityProvider = context =>
        {
            // Требуем MFA
            context.ProtocolMessage.SetParameter("amr_values", "mfa");
            return Task.CompletedTask;
        }
    };
});

public class DeviceAwareAuthorizationHandler : AuthorizationHandler<DeviceRequirement>
{
private readonly IDeviceRepository _deviceRepository;
private readonly IHttpContextAccessor _httpContextAccessor;
 
public DeviceAwareAuthorizationHandler(
    IDeviceRepository deviceRepository,
    IHttpContextAccessor httpContextAccessor)
{
    _deviceRepository = deviceRepository;
    _httpContextAccessor = httpContextAccessor;
}
 
protected override async Task HandleRequirementAsync(
    AuthorizationHandlerContext context,
    DeviceRequirement requirement)
{
    var httpContext = _httpContextAccessor.HttpContext;
    if (httpContext == null)
    {
        return;
    }
 
    // Получаем Device ID из заголовков или куки
    var deviceId = httpContext.Request.Headers["X-Device-ID"].FirstOrDefault() ??
                  httpContext.Request.Cookies["DeviceID"];
                  
    if (string.IsNullOrEmpty(deviceId))
    {
        return; // Устройство не идентифицировано
    }
    
    var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
    var device = await _deviceRepository.GetDeviceAsync(deviceId);
    
    // Проверяем, зарегистрировано ли устройство для этого пользователя
    if (device != null && device.UserId == userId && device.IsVerified)
    {
        // Дополнительно проверяем "свежесть" верификации устройства
        if (device.LastVerificationDate > DateTime.UtcNow.AddDays(-30))
        {
            context.Succeed(requirement);
        }
    }
}
}

services.AddAuthorization(options =>
{
options.AddPolicy("RequireVerifiedDevice", policy =>
    policy.RequireAuthenticatedUser()
          .AddRequirements(new DeviceRequirement()));
});
 
services.AddScoped<IAuthorizationHandler, DeviceAwareAuthorizationHandler>();

public class AdaptiveAuthenticationMiddleware
{
private readonly RequestDelegate _next;
private readonly IRiskScoreCalculator _riskCalculator;
private readonly IAdditionalFactorProvider _factorProvider;
 
public AdaptiveAuthenticationMiddleware(
    RequestDelegate next,
    IRiskScoreCalculator riskCalculator,
    IAdditionalFactorProvider factorProvider)
{
    _next = next;
    _riskCalculator = riskCalculator;
    _factorProvider = factorProvider;
}
 
public async Task InvokeAsync(HttpContext context)
{
    if (context.User.Identity?.IsAuthenticated == true)
    {
        // Оцениваем риск на основе IP, времени, устройства, запрашиваемого ресурса
        var riskScore = await _riskCalculator.CalculateRiskScoreAsync(context);
        
        // Высокий риск - требуем дополнительную аутентификацию
        if (riskScore > 0.7)
        {
            var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
            
            // Проверяем, была ли недавно выполнена дополнительная проверка
            if (!await _factorProvider.HasRecentAdditionalFactorAuthenticationAsync(userId))
            {
                // Сохраняем исходный URL для редиректа после аутентификации
                context.Response.Redirect($"/AdditionalAuth?returnUrl={context.Request.Path}");
                return;
            }
        }
    }
    
    await _next(context);
}
}

public class RiskScoreCalculator : IRiskScoreCalculator
{
private readonly IUserBehaviorRepository _behaviorRepository;
private readonly IGeolocationService _geolocationService;
 
public async Task<double> CalculateRiskScoreAsync(HttpContext context)
{
    var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
    var currentIp = context.Connection.RemoteIpAddress.ToString();
    var deviceId = context.Request.Headers["X-Device-ID"].FirstOrDefault();
    var resource = context.Request.Path;
    
    double score = 0;
    
    // Проверяем, использовал ли пользователь это IP раньше
    var knownIps = await _behaviorRepository.GetKnownIpAddressesAsync(userId);
    if (!knownIps.Contains(currentIp))
    {
        score += 0.4; // Новый IP - повышенный риск
        
        // Проверяем геолокацию
        var geo = await _geolocationService.GetGeolocationAsync(currentIp);
        var lastGeo = await _behaviorRepository.GetLastGeolocationAsync(userId);
        
        if (lastGeo != null && CalculateDistance(geo, lastGeo) > 500)
        {
            score += 0.3; // Большое расстояние от последней активности
        }
    }
    
    // Проверяем время доступа
    var now = DateTime.UtcNow;
    var typicalLoginTimes = await _behaviorRepository.GetTypicalLoginTimesAsync(userId);
    var isTypicalTime = typicalLoginTimes.Any(t => 
        Math.Abs((now.TimeOfDay - t).TotalHours) < 2);
    
    if (!isTypicalTime)
    {
        score += 0.2; // Необычное время доступа
    }
    
    // Анализируем чувствительность запрашиваемого ресурса
    if (resource.ToString().Contains("/admin/") || resource.ToString().Contains("/payments/"))
    {
        score += 0.1; // Чувствительный ресурс
    }
    
    return Math.Min(score, 1.0); // Максимальная оценка - 1.0
}
 
// Метод расчета расстояния между координатами опущен
}

public class AdaptiveAuthenticationHandler
{
    // Конструктор и зависимости опущены для краткости
    
    public async Task HandleRiskAsync(double riskScore, HttpContext context)
    {
        var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
        
        if (riskScore < 0.3)
        {
            // Низкий риск - пропускаем без дополнительных проверок
            return;
        }
        else if (riskScore < 0.6)
        {
            // Средний риск - запрашиваем "мягкий" фактор
            // Например, подтверждение по email или push-уведомление
            await _factorProvider.RequestSoftFactorVerificationAsync(userId);
            
            // Записываем в БД, что для этой сессии запрошена доп. проверка
            await _sessionManager.MarkSessionAsRequiringVerificationAsync(context);
        }
        else
        {
            // Высокий риск - требуем "жесткий" фактор (например, TOTP)
            // и блокируем доступ к ресурсу до проверки
            await _factorProvider.RequireHardFactorVerificationAsync(userId);
            context.Response.Redirect("/StrictAuth?returnUrl=" + context.Request.Path);
        }
    }
}

public class EncryptedField<T>
{
    private readonly IEncryptionService _encryptionService;
    private string _encryptedValue;
    
    // Шифрование/дешифрование "на лету"
    public T Value
    {
        get
        {
            if (string.IsNullOrEmpty(_encryptedValue))
                return default;
                
            var decryptedJson = _encryptionService.Decrypt(_encryptedValue);
            return JsonSerializer.Deserialize<T>(decryptedJson);
        }
        set
        {
            var json = JsonSerializer.Serialize(value);
            _encryptedValue = _encryptionService.Encrypt(json);
        }
    }
}
 
// Использование в модели
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    
    // Конфиденциальные поля зашифрованы
    public EncryptedField<string> TaxId { get; set; }
    public EncryptedField<CreditCardInfo> PaymentInfo { get; set; }
}

// Структурированное логирование с Serilog
Log.Logger = new LoggerConfiguration()
    .MinimumLevel.Information()
    .MinimumLevel.Override("Microsoft", LogEventLevel.Warning)
    .Enrich.FromLogContext()
    .Enrich.WithMachineName()
    .Enrich.WithEnvironmentUserName()
    .Enrich.WithThreadId()
    .Enrich.WithClientIp()
    .WriteTo.Console(new JsonFormatter())
    .WriteTo.Elasticsearch(new ElasticsearchSinkOptions(new Uri("http://elasticsearch:9200"))
    {
        IndexFormat = "app-logs-{0:yyyy.MM}",
        AutoRegisterTemplate = true
    })
    .CreateLogger();

public class CorrelationMiddleware
{
    private readonly RequestDelegate _next;
 
    public CorrelationMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context)
    {
        var correlationId = context.Request.Headers["X-Correlation-ID"].FirstOrDefault() ?? Guid.NewGuid().ToString();
        context.Response.Headers.Add("X-Correlation-ID", correlationId);
        
        using (LogContext.PushProperty("CorrelationId", correlationId))
        {
            // Обогащаем все логи внутри этого вызова
            await _next(context);
        }
    }
}

public class AuthenticationAnomalyDetector
{
    private readonly IEventRepository _eventRepository;
    private readonly IAlertService _alertService;
    
    // Порог для срабатывания оповещения
    private const int FailedLoginThreshold = 5;
    
    public async Task DetectAnomaliesAsync()
    {
        // Группируем неудачные попытки входа по IP
        var suspiciousIps = await _eventRepository.GetEventsAsync(
            eventType: "FailedLogin",
            timeFrame: TimeSpan.FromMinutes(10),
            groupBy: "IpAddress",
            havingCount: FailedLoginThreshold
        );
        
        foreach (var ip in suspiciousIps)
        {
            await _alertService.RaiseAlertAsync(new SecurityAlert
            {
                Severity = AlertSeverity.High,
                Type = AlertType.BruteForceAttempt,
                SourceIp = ip.Key,
                Count = ip.Count,
                Timestamp = DateTime.UtcNow,
                Details = $"Обнаружено {ip.Count} неудачных попыток входа с IP {ip.Key}"
            });
            
            // Можно автоматически блокировать IP
            await _firewallService.BlockIpTemporaryAsync(ip.Key, TimeSpan.FromHours(1));
        }
    }
}

public class SentinelEventSender
{
    private readonly HttpClient _httpClient;
    private readonly string _workspaceId;
    private readonly string _sharedKey;
    private readonly string _logType;
    
    // Конструктор и настройка опущены
    
    public async Task SendSecurityEventAsync(SecurityEvent securityEvent)
    {
        var json = JsonSerializer.Serialize(securityEvent);
        var dateString = DateTime.UtcNow.ToString("r");
        var signature = GenerateSignature(json, dateString);
        
        _httpClient.DefaultRequestHeaders.Clear();
        _httpClient.DefaultRequestHeaders.Add("Log-Type", _logType);
        _httpClient.DefaultRequestHeaders.Add("x-ms-date", dateString);
        _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("SharedKey", signature);
        
        var content = new StringContent(json, Encoding.UTF8, "application/json");
        var response = await _httpClient.PostAsync(
            $"https://{_workspaceId}.ods.opinsights.azure.com/api/logs?api-version=2016-04-01", 
            content);
            
        if (!response.IsSuccessStatusCode)
        {
            // Обработка ошибки отправки
        }
    }
    
    // Метод генерации подписи для Azure Sentinel опущен
}

// Метрики Prometheus для отслеживания событий безопасности
private readonly Counter _loginAttempts = Metrics
    .CreateCounter("app_login_attempts_total", "Total login attempts",
        new CounterConfiguration { LabelNames = new[] { "status", "user_type" } });
 
private readonly Histogram _loginDuration = Metrics
    .CreateHistogram("app_login_duration_seconds", "Login request duration",
        new HistogramConfiguration { Buckets = new[] { 0.1, 0.5, 1, 2, 5, 10 } });
 
public async Task<IActionResult> Login(LoginViewModel model)
{
    using var timer = _loginDuration.NewTimer();
    
    if (await _userService.AuthenticateAsync(model.Username, model.Password))
    {
        _loginAttempts.WithLabels("success", GetUserType(model.Username)).Inc();
        return RedirectToAction("Index", "Home");
    }
    
    _loginAttempts.WithLabels("failure", GetUserType(model.Username)).Inc();
    ModelState.AddModelError(string.Empty, "Invalid login attempt");
    return View(model);
}

public class SegmentedServiceClient : IServiceClient
{
    private readonly HttpClient _httpClient;
    private readonly ILogger _logger;
    private readonly Dictionary<string, string[]> _allowedEndpoints;
 
    public SegmentedServiceClient(
        HttpClient httpClient,
        ILogger<SegmentedServiceClient> logger,
        IConfiguration configuration)
    {
        _httpClient = httpClient;
        _logger = logger;
        
        // Загружаем разрешенные эндпоинты из конфигурации
        _allowedEndpoints = configuration
            .GetSection("ServiceSegmentation:AllowedEndpoints")
            .Get<Dictionary<string, string[]>>();
    }
 
    public async Task<HttpResponseMessage> SendRequestAsync(string serviceName, string endpoint, HttpMethod method, object payload = null)
    {
        // Проверяем, разрешен ли доступ к этому сервису и эндпоинту
        if (!_allowedEndpoints.TryGetValue(serviceName, out var allowedPaths) || 
            !allowedPaths.Any(path => endpoint.StartsWith(path)))
        {
            _logger.LogWarning("Attempted access to unauthorized service/endpoint: {Service}/{Endpoint}", 
                serviceName, endpoint);
            throw new UnauthorizedAccessException($"Access to {serviceName}/{endpoint} is not allowed");
        }
 
        // Создаем запрос
        var request = new HttpRequestMessage(method, $"https://{serviceName}/{endpoint}");
        
        if (payload != null && (method == HttpMethod.Post || method == HttpMethod.Put))
        {
            request.Content = new StringContent(
                JsonSerializer.Serialize(payload),
                Encoding.UTF8,
                "application/json");
        }
 
        return await _httpClient.SendAsync(request);
    }
}

using System;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Microsoft.AspNetCore.Authorization;
using Microsoft.Extensions.Configuration;
using System.Security.Claims;
 
namespace ZeroTrust.Core.Services
{
    // Определяем контракт сервиса
    public interface ISecureOrderService
    {
        Task<OrderResult> ProcessOrderAsync(OrderRequest request, ClaimsPrincipal user, CancellationToken cancellationToken);
        Task<OrderDetails> GetOrderDetailsAsync(string orderId, ClaimsPrincipal user, CancellationToken cancellationToken);
    }
 
    // Реализация с принципами Zero Trust
    public class SecureOrderService : ISecureOrderService
    {
        private readonly ILogger<SecureOrderService> _logger;
        private readonly ISecureApiClient _apiClient;
        private readonly IContextValidator _contextValidator;
        private readonly IAuthorizationService _authService;
        private readonly IAnomalyDetector _anomalyDetector;
        private readonly string _serviceApiKey;
 
        public SecureOrderService(
            ILogger<SecureOrderService> logger,
            ISecureApiClient apiClient,
            IContextValidator contextValidator, 
            IAuthorizationService authService,
            IAnomalyDetector anomalyDetector,
            IConfiguration configuration)
        {
            _logger = logger;
            _apiClient = apiClient;
            _contextValidator = contextValidator;
            _authService = authService;
            _anomalyDetector = anomalyDetector;
            
            // Получаем чувствительную информацию из безопасного хранилища
            _serviceApiKey = configuration["SecureSettings:OrderApiKey"] 
                ?? throw new InvalidOperationException("API key not configured");
        }
 
        public async Task<OrderResult> ProcessOrderAsync(
            OrderRequest request, 
            ClaimsPrincipal user, 
            CancellationToken cancellationToken)
        {
            if (request == null || string.IsNullOrEmpty(request.ProductId))
                throw new ArgumentException("Invalid order request");
 
            var userId = user.FindFirstValue(ClaimTypes.NameIdentifier) 
                ?? throw new UnauthorizedAccessException("User not authenticated");
 
            _logger.LogInformation("Processing order for product {ProductId} by user {UserId}", 
                request.ProductId, userId);
 
            try
            {
                // 1. Проверяем контекст запроса (устройство, локацию, время)
                var contextValidation = await _contextValidator.ValidateRequestContextAsync(user);
                if (!contextValidation.IsValid)
                {
                    _logger.LogWarning("Context validation failed for user {UserId}: {Reason}", 
                        userId, contextValidation.FailureReason);
                    throw new SecurityException(contextValidation.FailureReason);
                }
 
                // 2. Проверяем авторизацию на конкретное действие
                var authResult = await _authService.AuthorizeAsync(user, request, Operations.CreateOrder);
                if (!authResult.Succeeded)
                {
                    _logger.LogWarning("Authorization failed for user {UserId} to create order", userId);
                    throw new ForbiddenException("Not authorized to create this order");
                }
 
                // 3. Проверяем на аномалии поведения
                var anomalyScore = await _anomalyDetector.CalculateAnomalyScoreAsync(user, "CreateOrder");
                if (anomalyScore > 0.7)
                {
                    _logger.LogWarning("High anomaly score {Score} detected for user {UserId}", 
                        anomalyScore, userId);
                    // Мы не блокируем, но помечаем заказ для ручной проверки
                    request.RequiresManualReview = true;
                }
 
                // 4. Безопасно вызываем внешний сервис с минимальными привилегиями
                var orderResult = await _apiClient.SendWithAuthAsync<OrderRequest, OrderResult>(
                    "orders/create", 
                    request, 
                    _serviceApiKey,
                    cancellationToken);
 
                _logger.LogInformation("Order {OrderId} processed successfully for user {UserId}", 
                    orderResult.OrderId, userId);
 
                return orderResult;
            }
            catch (OperationCanceledException)
            {
                _logger.LogInformation("Order processing cancelled for user {UserId}", userId);
                throw;
            }
            catch (Exception ex) when (ex is not UnauthorizedAccessException 
                                     && ex is not ForbiddenException
                                     && ex is not SecurityException)
            {
                _logger.LogError(ex, "Error processing order for user {UserId}", userId);
                throw new ServiceException("Order processing failed", ex);
            }
        }
 
        public async Task<OrderDetails> GetOrderDetailsAsync(
            string orderId, 
            ClaimsPrincipal user, 
            CancellationToken cancellationToken)
        {
            // Аналогичная логика для получения деталей заказа...
            // Опущено для краткости
            return new OrderDetails();
        }
    }
}