Aplicar os princípios do Zero Trust para segmentar a rede do Azure por meio da análise de tráfego

O Zero Trust é uma estratégia de segurança. Não é um produto ou um serviço, mas uma abordagem na conceção e implementação do seguinte conjunto de princípios de segurança.

Com o Zero Trust, você se afasta de uma perspetiva de confiança por padrão para uma perspetiva de confiança por exceção. É importante uma capacidade integrada para gerir automaticamente essas exceções e alertas. Pode detetar mais facilmente ameaças, responder a ameaças e prevenir ou bloquear eventos indesejados na sua organização.

A rede de nuvem do Azure é projetada com várias camadas de segmentação que podem atuar como limites ou zonas de confiança. Para obter mais informações sobre como segmentar sua rede baseada no Azure usando os princípios de Confiança Zero, consulte Aplicar princípios de Confiança Zero à segmentação da comunicação de rede baseada no Azure.

Modelo de Maturidade Zero Trust

O Modelo de Maturidade Zero Trust (ZTMM) da Cybersecurity & Infrastructure Security Agency (CISA) é construído sobre cinco pilares que englobam funções para melhorar as áreas de proteção Zero Trust. Para obter mais informações, consulte Configurar serviços de nuvem da Microsoft para o modelo de maturidade CISA Zero Trust

• Identidade
• Dispositivos
• Redes
• Aplicativos e cargas de trabalho
• Dados

Os pilares abrangem os quatro estágios da jornada ZTMM. Para obter mais informações, consulte Estágios de jornada do ZTMM.

• Tradicional
• Inicial
• Avançado
• Ótimo

As quatro fases aplicam-se ao pilar «Redes » do seguinte modo:

Como você pode usar a análise de tráfego para alcançar a segurança Zero Trust?

A Análise de Tráfego fornece informações sobre os fluxos de tráfego de rede no seu ambiente do Azure. Ele usa logs de fluxo de rede virtual e executa a agregação para reduzir o volume de dados, preservando os principais padrões de tráfego. Os logs agregados são enriquecidos com informações geográficas, de segurança e de topologia e armazenados em um espaço de trabalho do Log Analytics.

Os padrões de tráfego são visualizados usando painéis internos, com flexibilidade para personalizar informações de tráfego usando as Pastas de Trabalho do Azure. O painel de análise de tráfego também permite configurar alertas e iniciar investigações em resposta a possíveis violações de segurança.

• Monitore o tráfego de rede: Capture o tráfego de entrada e saída usando logs de fluxo e use a análise de tráfego para processar e visualizar esses dados. Obtenha informações sobre padrões de comunicação, uso de largura de banda e fluxos de tráfego entre cargas de trabalho.

• Identifique padrões de comunicação de carga de trabalho: Analise os dados de análise de tráfego para entender como os recursos se comunicam dentro e entre locatários, regiões de assinatura, redes virtuais, sub-redes, protocolos, grupos baseados em segurança, serviços e aplicativos. Identificar padrões de tráfego desnecessários ou anómalos que possam indicar potenciais riscos de segurança.

• Visualizações perspicazes: Utilize visualizações incorporadas e personalizáveis na análise de tráfego para explorar padrões de tráfego e detetar anomalias de forma mais eficaz.

• Detetar IPs/recursos comprometidos: Use a análise de tráfego para identificar endereços IP ou recursos potencialmente comprometidos, ajudando a fortalecer a segurança e manter o desempenho.

Como implantar a segmentação Zero Trust (ZTS) com o Traffic Analytics?

Como um primeiro passo crítico para implantar a Segmentação Zero Trust sobre a implantação existente ou nova do Azure, o usuário precisa

• Observe os padrões através do Traffic Analytics: Analise os logs de fluxo para identificar os padrões de tráfego que são essenciais para sua carga de trabalho.

• Comece com a postura de negação padrão: Começa com a remoção ou desativação de todas as regras de entrada e saída existentes que permitem o tráfego de forma ampla (por exemplo, Permitir Tudo, Permitir) e adicionar regras de negação explícitas para o tráfego de entrada e de saída

• Crie regras de permissão seletivas: com base nas informações do Traffic Analytics, defina regras que permitam explicitamente apenas o tráfego observado e necessário. Essa abordagem garante que apenas o tráfego necessário validado seja permitido, alinhando-se com o princípio Zero Trust de Verificação explícita.

As seções a seguir destacam os principais cenários em que a análise de tráfego dá suporte à segmentação para ajudar a implementar os princípios de Confiança Zero no Azure.

Cenário 1: Detetar o tráfego que flui através de regiões de risco ou restritas

Use a análise de tráfego para detetar tráfego de entrada ou saída para regiões de alto risco, conforme definido pelas políticas da sua organização. Por exemplo, você pode identificar o tráfego que flui de ou para regiões consideradas sensíveis ou restritas com base nos requisitos de segurança e conformidade da sua organização.

let ExternalIps = NTAIpDetails 
    | where Location in ("country1", "country2") 
    | where FlowType in ("MaliciousFlow", "ExternalPublic")
        //and FlowIntervalStartTime between (datetime('{timeInterval') .. datetime('{timeInterval'))
    | project-away
        TimeGenerated,
        SubType,
        FaSchemaVersion,
        FlowIntervalEndTime,
        FlowIntervalStartTime,
        FlowType,
        Type 
    | distinct Ip, ThreatType, DnsDomain, ThreatDescription, Location, PublicIpDetails, Url;
    let ExternalFlows =  NTANetAnalytics 
    //| where FlowStartTime between (datetime('{timeInterval}') .. datetime('{timeInterval}'))
    | where SubType == "FlowLog" and FlowType in ("ExternalPublic", "MaliciousFlow")
    | extend PublicIP = SrcPublicIps
    | extend ExtractedIPs = split(PublicIP, " ") // Split IPs by spaces
    | mv-expand ExtractedIPs // Expand into multiple rows
    | extend IP = tostring(split(ExtractedIPs, "|")[0])
    | extend AllSrcIps = coalesce(SrcIp, IP)
    | project 
        AllSrcIps,
        DestIp,
        SrcVm,
        DestVm,
        SrcSubscription,
        DestSubscription,FlowType; 
let SrcMalicious = ExternalFlows 
    | lookup kind=inner ExternalIps on $left.AllSrcIps == $right.Ip
    | extend CompromisedVM = iff(isnotempty(DestVm),strcat("/subscriptions/",DestSubscription,"/resourceGroups/",tostring(split(DestVm,"/")[0]),"/providers/Microsoft.Compute/virtualMachines/",tostring(split(DestVm,"/")[1])),'')
    | project
        SrcExternalIp = strcat('🌐 ', AllSrcIps),      
        DestCompromisedIp = strcat('🖥️', DestIp),
        CompromisedVM,
        PublicIpDetails,
        FlowType,
        ThreatType,
        DnsDomain,
        ThreatDescription,
        Location,
        Url;
SrcMalicious
| summarize count() by SrcExternalIp ,DestCompromisedIp, CompromisedVM,
        PublicIpDetails,
        FlowType,
        ThreatType,
        DnsDomain,
        ThreatDescription,
        Location,
        Url

Cenário 2: Alcançar a segmentação de tráfego com base nas interações de serviço do Azure

Use a análise de tráfego para obter uma visão panorâmica de como diferentes cargas de trabalho interagem com os serviços do Azure. Por exemplo, as cargas de trabalho SAP podem se comunicar com a infraestrutura do Azure Arc, enquanto outras cargas de trabalho, como ambientes de desenvolvimento ou serviços de produtividade, interagem com o Azure Monitor. Essas informações ajudam você a entender as dependências do serviço, detetar padrões de tráfego inesperados ou anômalos e aplicar políticas de segurança mais granulares por meio da microssegmentação.

let SpecificServices = NTAIpDetails
| where FlowType == "AzurePublic"
| where FlowIntervalStartTime > ago(4h)
| project Ip, PublicIpDetails;
let PublicIPs = NTANetAnalytics
| where SubType == 'FlowLog'
| where FlowIntervalStartTime > ago(4h)
| where(isnotempty(SrcPublicIps) or isnotempty(DestPublicIps))
| extend PublicIP = coalesce(SrcPublicIps, DestPublicIps), Vnet = iff(isnotempty(SrcSubnet), strcat("/subscriptions/", SrcSubscription, "/resourceGroups/", tostring(split(SrcSubnet, "/")[0]), "/providers/Microsoft.Network/virtualNetworks/", tostring(split(SrcSubnet, "/")[1])), iff(isnotempty(DestSubnet), strcat("/subscriptions/", DestSubscription, "/resourceGroups/", tostring(split(DestSubnet, "/")[0]), "/providers/Microsoft.Network/virtualNetworks/", tostring(split(DestSubnet, "/")[1])),''))
| extend ExtractedIPs = split(PublicIP, " ") // Split IPs by spaces
| mv-expand ExtractedIPs // Expand into multiple rows
| extend IP = tostring(split(ExtractedIPs, "|")[0]) // Extract IP address
| lookup kind=inner SpecificServices on $left.IP == $right.Ip
| project Vnet, PublicIpDetails;
PublicIPs
| summarize CounterValue = count() by Vnet, PublicIpDetails
| top 100 by CounterValue desc

Cenário 3: Identificar o raio de explosão em caso de violação da rede

Use a análise de tráfego para rastrear o caminho de endereços IP potencialmente mal-intencionados que tentam se comunicar com seus recursos. No caso de uma máquina virtual (VM) comprometida, a análise de tráfego pode ajudar a mapear todas as comunicações iniciadas por essa VM nas últimas 24 horas, ajudando a identificar possíveis exfiltrações de dados e limitando o raio de explosão.

A consulta a seguir identifica todos os endereços IP diretos e indiretos que interagem com fluxos maliciosos de geografias de alto risco:

let MAliciousIps = NTAIpDetails 
| where FlowIntervalStartTime between (datetime('{timeInterval:startISO}') .. datetime('{timeInterval:endISO}'))
| where FlowType == "MaliciousFlow" 
| distinct Ip; 
let MaliciousFlows =  NTANetAnalytics 
| where FlowStartTime between (todatetime('{timeInterval:startISO}') .. todatetime('{timeInterval:endISO}'))
| where SubType == "FlowLog" and FlowType == "MaliciousFlow" 
| project SrcIp, DestIp, FlowLogResourceId, TargetResourceId; 
let SrcMalicious = MaliciousFlows 
| lookup kind=leftouter MAliciousIps on $left.SrcIp == $right.Ip 
| project SrcIp, DestIp; 
let DestMalicious = MaliciousFlows 
| lookup kind=leftouter MAliciousIps on $left.DestIp == $right.Ip 
| project SrcIp, DestIp; 
let MaliciousIps = SrcMalicious 
| union DestMalicious 
| distinct *; 
let SpecificCountryIPs = NTAIpDetails 
| where Location in ("country1", "country2") 
| project Ip; 
let SrcIpCountry = SpecificCountryIPs 
| join kind=inner NTANetAnalytics on $left.Ip == $right.SrcIp 
| project SrcIp, DestIp; 
let DestIpCountry = SpecificCountryIPs 
| join kind=inner NTANetAnalytics on $left.Ip == $right.DestIp 
| project SrcIp, DestIp; 
let SpecificCountryFlows = SrcIpCountry 
| union DestIpCountry; 
let MaliciousFlowsObserved = MaliciousIps 
| union SpecificCountryFlows 
| distinct SrcIp, DestIp; 
let MaliciousFlowsTransitive = MaliciousFlowsObserved 
| join kind=inner MaliciousFlowsObserved on $left.DestIp == $right.SrcIp 
| project SrcIp, DestIp = DestIp1 
| distinct SrcIp, DestIp; 
let MaliciousFlowsObserved1 = MaliciousFlowsObserved 
| union MaliciousFlowsTransitive 
| distinct SrcIp, DestIp; 
let MaliciousFlowsTransitive1 = MaliciousFlowsObserved1 
| join kind=inner MaliciousFlowsObserved1 on $left.DestIp == $right.SrcIp 
| project SrcIp, DestIp = DestIp1 
| distinct SrcIp, DestIp; 
let MaliciousFlowsObserved2 = MaliciousFlowsObserved1 
| union MaliciousFlowsTransitive1 
| distinct SrcIp, DestIp; 
MaliciousFlowsObserved2 
| project SrcIp = strcat('🖥️ ', SrcIp), DestIp = strcat('🖥️ ', DestIp)

Cenário 4: Impor limites de subscrição

Use a análise de tráfego para impor limites de assinatura e garantir que o tráfego entre diferentes assinaturas do Azure seja segmentado corretamente.

NTANetAnalytics 
| where SubType == "FlowLog"  and FlowType !in ("AzurePublic","ExternalPublic","Unknown","UnknownPrivate") // Filter to flows for which we know the Subscription Details
| where FlowStartTime between (start .. end) 
| where AclGroup !contains "Unspecified" 
|extend Dest = iff(isnotempty(DestSubnet),strcat("/subscriptions/",DestSubscription,"/resourceGroups/",tostring(split(DestSubnet,"/")[0]),"/providers/Microsoft.Network/virtualNetworks/",tostring(split(DestSubnet,"/")[1])),'')
| extend Src = iff(isnotempty(SrcSubnet),strcat("/subscriptions/",SrcSubscription,"/resourceGroups/",tostring(split(SrcSubnet,"/")[0]),"/providers/Microsoft.Network/virtualNetworks/",tostring(split(SrcSubnet,"/")[1])),'')
| extend SrcSubscription = strcat("/subscriptions/",SrcSubscription), DestSubscription = strcat("/subscriptions/",DestSubscription)
| where SrcSubscription != DestSubscription // Cross Subscription
| summarize Flows = sum(CompletedFlows) by Src, Dest, SrcSubscription, DestSubscription, AclGroup,AclRule, FlowType
//| top 10 by Flows