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

Confiança Zero é uma estratégia de segurança. Não é um produto ou serviço, mas uma abordagem para projetar e implementar o seguinte conjunto de princípios de segurança.

Com o Zero Trust, você se afasta de uma perspectiva de confiança por padrão para uma abordagem de confiança por exceção. Uma funcionalidade integrada para gerenciar automaticamente essas exceções e alertas é importante. Você pode detectar ameaças com mais facilidade, responder a ameaças e impedir ou bloquear eventos indesejados em toda a sua organização.

A rede de nuvem do Azure foi 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 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 de confiança zero

O Modelo de Maturidade de Confiança Zero (ZTMM) da CISA (Cybersecurity &Infrastructure Security Agency) é criado com base em cinco pilares que abrangem funções para aprimorar as áreas de proteção de Confiança Zero. Para obter mais informações, consulte Configurar os serviços de nuvem da Microsoft para o Modelo de Maturidade Zero Trust da CISA

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

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

• Tradicional
• Inicial
• Avançado
• Ideal

Os quatro estágios se aplicam ao pilar Redes da seguinte maneira:

Como você pode usar a análise de tráfego para obter segurança de Confiança Zero?

A Análise de Tráfego fornece insights sobre fluxos de tráfego de rede em 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 então enriquecidos com informações geográficas, de segurança e de topologia e armazenados em um workspace do Log Analytics.

Os padrões de tráfego são visualizados usando painéis internos, com flexibilidade para personalizar insights de tráfego usando 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.

• Monitorar 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 insights sobre padrões de comunicação, uso de largura de banda e fluxos de tráfego entre cargas de trabalho.

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

• Visualizações perspicazes: Use visualizações internas e personalizáveis na análise de tráfego para explorar padrões de tráfego e detectar anomalias com mais eficiência.

• Detectar 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 ZTS (Segmentação de Confiança Zero) com a Análise de Tráfego?

Como primeira etapa crítica para implantar a Segmentação de Confiança Zero em implantações do Azure existentes ou novas, o usuário precisa

• Observe os padrões por meio da Análise de Tráfego: analise logs de fluxo para identificar os padrões de tráfego essenciais para sua carga de trabalho.

• Comece com a postura de negação padrão: isso começa com a remoção ou desabilitaçã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 a implementação de regras explícitas de bloqueio para o tráfego de entrada e saída.

• Criar regras de permissão seletivas: com base em insights da Análise de Tráfego, defina regras que permitem explicitamente apenas o tráfego observado e necessário. Essa abordagem garante que somente o tráfego validado e necessário seja permitido, alinhando-se ao princípio de Confiança Zero de Verificar explicitamente.

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 princípios de Confiança Zero no Azure.

Cenário 1: detectar o tráfego fluindo por regiões arriscadas ou restritas

Use a análise de tráfego para detectar o 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 confidenciais 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: Obter 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 geral 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. Esses insights ajudam você a entender as dependências de serviço, detectar padrões de tráfego inesperados ou anômalos e impor políticas de segurança mais granulares por meio da micro segmentaçã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 raio de explosão em caso de violação de 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 VM (máquina virtual 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ção de dados e limitar o raio de explosão.

A consulta a seguir identifica todos os endereços IP diretos e indiretos interagindo com fluxos mal-intencionados 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 assinatura

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