Aggiornare la versione del set di regole CRS o DRS

Si applica a: ✔️ Gateway di applicazione V2

Il Set di regole predefinito gestito da Azure nel Web application firewall (WAF) di gateway applicazione di Azure protegge le applicazioni web dalle vulnerabilità e dagli exploit più comuni, inclusi i 10 principali tipi di attacco OWASP. Il gruppo di regole predefinito incorpora anche le regole di Raccolta di Microsoft Threat Intelligence. Eseguire sempre la versione più recente del set di regole, che include gli aggiornamenti della sicurezza più recenti, i miglioramenti delle regole e le correzioni.

Il set di regole predefinito gestito da Azure è la generazione più recente di set di regole in Azure WAF, sostituendo tutte le versioni precedenti di Core Rule Set (CRS). Tra le versioni di DRS, usare sempre la versione più recente disponibile (DRS 2.2) per assicurarsi di avere le protezioni più up-to-date.

Questo articolo fornisce esempi di PowerShell per l'aggiornamento dei criteri WAF Azure a DRS 2.2 da CRS 3.0, CRS 3.1, CRS 3.2 o DRS 2.1.

Annotazioni

I frammenti di codice di PowerShell sono solo esempi. Sostituire tutti i segnaposto con i valori dal tuo ambiente.

Prerequisiti

Un account Azure con una sottoscrizione attiva. Creare un account gratuito.
Un criterio WAF di Azure esistente con un set di regole di base (CRS) o un set di regole predefinito applicato. Se non si dispone ancora di un criterio di WAF, vedere Creare criteri del Web application firewall per il gateway applicazione.
Versione più recente di Azure PowerShell installata in locale. Questo articolo richiede il modulo Az.Network.

Considerazioni principali per l'aggiornamento

Quando si aggiorna la versione del set di regole waf di Azure, assicurarsi di:

Mantenere le personalizzazioni esistenti: conservare le modifiche alle azioni delle regole, lo stato delle regole (abilitato o disabilitato) e le esclusioni.
Elimina personalizzazioni per le regole rimosse: non eseguire sostituzioni o esclusioni per le regole che non esistono più in DRS 2.2. Il mantenimento di un override per una regola non contenuta in DRS 2.2 fa sì che l'aggiornamento dei criteri non riesca, con un errore come The override Rule '<id>' is unknown for RuleGroup '<group>'.
Considera la configurazione di base del livello di paranoia: DRS 2.2 opera al livello di paranoia 1 (PL1) per impostazione predefinita e tutte le regole del PL2 sono disattivate per impostazione predefinita. In CRS 3.2 e DRS 2.1 le regole PL2 erano attive. Tutte le regole PL2 personalizzate in precedenza vengono disabilitate per impostazione predefinita in DRS 2.2 fino a quando non vengono riabilitate esplicitamente.
Convalidare le nuove regole in modo sicuro: le nuove regole aggiunte abilitate per impostazione predefinita (PL1) vengono inizialmente impostate sulla modalità di registrazione, in modo da monitorarne l'impatto e ottimizzarle prima di abilitare il blocco.

Preparate l'ambiente e le variabili.

Impostare il contesto per la sottoscrizione, il gruppo di risorse e il criterio WAF di Azure selezionati.

Import-Module Az.Network
Set-AzContext -SubscriptionId "<subscription_id>"
$resourceGroupName = "<resource_group>"
$wafPolicyName = "<policy_name>"

Ottenere l'oggetto criteri di WAF e recuperarne le definizioni. Il set di regole gestite corrente può essere un tipo CRS (OWASP) o DRS (Microsoft_DefaultRuleSet).

$wafPolicy = Get-AzApplicationGatewayFirewallPolicy `
    -Name $wafPolicyName `
    -ResourceGroupName $resourceGroupName

$currentExclusions = $wafPolicy.ManagedRules.Exclusions
$currentManagedRuleset = $wafPolicy.ManagedRules.ManagedRuleSets |
    Where-Object { $_.RuleSetType -eq "OWASP" -or $_.RuleSetType -eq "Microsoft_DefaultRuleSet" }
$currentVersion = $currentManagedRuleset.RuleSetVersion

Mantenere le personalizzazioni esistenti

Mantenere un override o un'esclusione solo se la regola esiste ancora in DRS 2.2. La funzione seguente convalida un ID di regola rispetto all'insieme completo di regole DRS 2.2 e restituisce $true per ogni regola rimossa (incluse le regole legacy e inattive come 920460, 942130 e 920250). L'uso di un elenco di ID regola validi evita la manutenzione per regola e impedisce l'esito negativo dell'aggiornamento dei criteri in una regola sconosciuta.

function Test-RuleIsRemovedFromDRS22 {
    param (
        [string]$RuleId,
        [string]$CurrentRulesetVersion  # Retained for compatibility; not used
    )

    # Complete set of rule IDs that exist in DRS 2.2.
    # Any override or exclusion for a rule NOT in this set is dropped during migration.
    $drs22RuleIds = @(
        "200002","200003",
        "911100",
        "920100","920120","920121","920160","920170","920171","920180","920181","920190","920200","920201","920210","920220","920230","920240","920260","920270","920271","920280","920290","920300","920310","920311","920320","920330","920340","920341","920350","920420","920430","920440","920450","920470","920480","920500","920530","920620",
        "921110","921120","921130","921140","921150","921151","921160","921190","921200","921422",
        "930100","930110","930120","930130",
        "931100","931110","931120","931130",
        "932100","932105","932110","932115","932120","932130","932140","932150","932160","932170","932171","932180",
        "933100","933110","933120","933130","933140","933150","933151","933160","933170","933180","933200","933210",
        "934100",
        "941100","941101","941110","941120","941130","941140","941150","941160","941170","941180","941190","941200","941210","941220","941230","941240","941250","941260","941270","941280","941290","941300","941310","941320","941330","941340","941350","941360","941370","941380",
        "942100","942110","942120","942140","942150","942160","942170","942180","942190","942200","942210","942220","942230","942240","942250","942260","942270","942280","942290","942300","942310","942320","942330","942340","942350","942360","942361","942370","942380","942390","942400","942410","942430","942440","942450","942470","942480","942500","942510",
        "943100","943110","943120",
        "944100","944110","944120","944130","944200","944210","944240","944250",
        "99005002","99005003","99005004","99005005","99005006",
        "99030001","99030002","99030003","99030004","99030005","99030006",
        "99031001","99031002","99031003","99031004","99031005","99031006",
        "99001001","99001002","99001003","99001004","99001005","99001006","99001007","99001008","99001009","99001010","99001011","99001012","99001013","99001014","99001015","99001016","99001017","99001018",
        "99032001","99032002"
    )

    return -not ($drs22RuleIds -contains $RuleId)
}

Quando si creano nuovi oggetti di override, usare i nomi dei gruppi DRS 2.2. La funzione seguente associa i nomi dei gruppi CRS precedenti nei gruppi DRS. I nomi dei gruppi di origine DRS non inclusi nella mappa ( ad esempio, quando si esegue l'aggiornamento da DRS 2.1) vengono restituiti invariati:

function Get-DrsRuleGroupName {
    param (
        [Parameter(Mandatory = $true)]
        [string]$SourceGroupName
    )
    $groupMap = @{
        "REQUEST-930-APPLICATION-ATTACK-LFI"             = "LFI"
        "REQUEST-931-APPLICATION-ATTACK-RFI"             = "RFI"
        "REQUEST-932-APPLICATION-ATTACK-RCE"             = "RCE"
        "REQUEST-933-APPLICATION-ATTACK-PHP"             = "PHP"
        "REQUEST-941-APPLICATION-ATTACK-XSS"             = "XSS"
        "REQUEST-942-APPLICATION-ATTACK-SQLI"            = "SQLI"
        "REQUEST-943-APPLICATION-ATTACK-SESSION-FIXATION" = "FIX"
        "REQUEST-944-APPLICATION-ATTACK-JAVA"            = "JAVA"
        "REQUEST-921-PROTOCOL-ATTACK"                    = "PROTOCOL-ATTACK"
        "REQUEST-911-METHOD-ENFORCEMENT"                 = "METHOD-ENFORCEMENT"
        "REQUEST-920-PROTOCOL-ENFORCEMENT"               = "PROTOCOL-ENFORCEMENT"
        "REQUEST-913-SCANNER-DETECTION"                  = $null  # No direct mapping
        "Known-CVEs"                                     = "MS-ThreatIntel-CVEs"
        "General"                                        = "General"
    }
    if ($groupMap.ContainsKey($SourceGroupName)) {
        return $groupMap[$SourceGroupName]
    } else {
        return $SourceGroupName  # No known mapping; pass through (DRS source group names)
    }
}

Usare il codice di PowerShell seguente per definire le sostituzioni delle regole, duplicando le sostituzioni dalla versione del set di regole esistente:

$groupOverrides = @()
foreach ($group in $currentManagedRuleset.RuleGroupOverrides) {
    $mappedGroupName = Get-DrsRuleGroupName $group.RuleGroupName
    if (-not $mappedGroupName) { continue }  # Skip groups with no DRS equivalent
    foreach ($existingRule in $group.Rules) {
        if (-not (Test-RuleIsRemovedFromDRS22 $existingRule.RuleId $currentVersion)) {
            $existingGroup = $groupOverrides | Where-Object { $_.RuleGroupName -eq $mappedGroupName }
            if ($existingGroup) {
                if (-not ($existingGroup.Rules | Where-Object { $_.RuleId -eq $existingRule.RuleId })) {
                    $existingGroup.Rules.Add($existingRule)
                }
            } else {
                $newGroup = New-AzApplicationGatewayFirewallPolicyManagedRuleGroupOverride `
                    -RuleGroupName $mappedGroupName `
                    -Rule @($existingRule)
                $groupOverrides += $newGroup
            }
        }
    }
}

Usare il codice di PowerShell seguente per duplicare le esclusioni esistenti e applicarle in DRS 2.2:

# Create new exclusion objects
$newRuleSetExclusions = @()

if ($currentExclusions -ne $null -and $currentExclusions.Count -gt 0) {
    foreach ($exclusion in $currentExclusions) {
        $newExclusion = New-AzApplicationGatewayFirewallPolicyExclusion `
            -MatchVariable $exclusion.MatchVariable `
            -SelectorMatchOperator $exclusion.SelectorMatchOperator `
            -Selector $exclusion.Selector

        # Migrate scopes: RuleSet, RuleGroup, or individual Rules
        if ($exclusion.ExclusionManagedRuleSets) {
            foreach ($scope in $exclusion.ExclusionManagedRuleSets) {
                # Create RuleGroup objects from existing RuleGroups
                $ruleGroups = @()
                foreach ($group in $scope.RuleGroups) {
                    $drsGroupName = Get-DrsRuleGroupName $group.RuleGroupName
                    if ($drsGroupName) {
                        $exclusionRules = @()
                        foreach ($rule in $group.Rules) {
                            if (-not (Test-RuleIsRemovedFromDRS22 $rule.RuleId $currentVersion)) {
                                $exclusionRules += New-AzApplicationGatewayFirewallPolicyExclusionManagedRule `
                                    -RuleId $rule.RuleId
                            }
                        }
                        if ($exclusionRules -ne $null -and $exclusionRules.Count -gt 0) {
                            $ruleGroups += New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleGroup `
                                -Name $drsGroupName `
                                -Rule $exclusionRules
                        } else {
                            $ruleGroups += New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleGroup `
                                -Name $drsGroupName
                        }
                    }
                }

                # Create the ManagedRuleSet scope object with the updated RuleGroups
                if ($ruleGroups.Count -gt 0) {
                    $newRuleSetScope = New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleSet `
                        -Type "Microsoft_DefaultRuleSet" `
                        -Version "2.2" `
                        -RuleGroup $ruleGroups

                    # Add to the new exclusion object
                    $newExclusion.ExclusionManagedRuleSets += $newRuleSetScope
                }
            }
        }

        if (-not $newExclusion.ExclusionManagedRuleSets) {
            $newExclusion.ExclusionManagedRuleSets = @()
        }

        $newRuleSetExclusions += $newExclusion
    }
}

Convalidare le nuove regole in modo sicuro

Quando si esegue l'aggiornamento, le nuove regole drs 2.2 che appartengono al livello paranoia 1 sono abilitate per impostazione predefinita. Se il WAF è in modalità Prevenzione, imposta prima queste nuove regole in modalità log, così da poter controllare i log prima di abilitare il blocco.

Le regole che appartengono al livello Paranoia 2 sono disabilitate per impostazione predefinita in DRS 2.2 e non bloccano il traffico, quindi non richiedono questo passaggio. Se si vuole operare al livello Paranoia 2, abilitare le regole PL2 pertinenti in modo esplicito e seguire lo stesso approccio di convalida nel log.

Usare la definizione corrispondente alla versione da cui si sta eseguendo l'aggiornamento. Ogni definizione elenca le regole introdotte e abilitate per impostazione predefinita in DRS 2.2 rispetto a tale versione.

# Added and enabled by default in DRS 2.2 compared to CRS 3.0
$rulesAddedInThisVersionByGroup = @{
    "General"              = @("200002", "200003")
    "PROTOCOL-ENFORCEMENT" = @("920171", "920181", "920470", "920480", "920500", "920530", "920620")
    "PROTOCOL-ATTACK"      = @("921190", "921200")
    "RCE"                  = @("932180")
    "PHP"                  = @("933200", "933210")
    "NODEJS"               = @("934100")
    "XSS"                  = @("941360", "941370")
    "SQLI"                 = @("942500")
    "JAVA"                 = @("944100", "944110", "944120", "944130")
    "MS-ThreatIntel-CVEs"  = @("99001018")
    "MS-ThreatIntel-XSS"   = @("99032001")
}

# Added and enabled by default in DRS 2.2 compared to CRS 3.1
$rulesAddedInThisVersionByGroup = @{
    "General"              = @("200002", "200003")
    "PROTOCOL-ENFORCEMENT" = @("920181", "920500", "920530", "920620")
    "PROTOCOL-ATTACK"      = @("921190", "921200")
    "PHP"                  = @("933200", "933210")
    "NODEJS"               = @("934100")
    "XSS"                  = @("941360", "941370")
    "SQLI"                 = @("942500")
    "MS-ThreatIntel-CVEs"  = @("99001018")
    "MS-ThreatIntel-XSS"   = @("99032001")
}

# Added and enabled by default in DRS 2.2 compared to CRS 3.2
$rulesAddedInThisVersionByGroup = @{
    "PROTOCOL-ENFORCEMENT" = @("920181", "920500", "920530", "920620")
    "PROTOCOL-ATTACK"      = @("921190", "921200")
    "NODEJS"               = @("934100")
    "XSS"                  = @("941370")
    "MS-ThreatIntel-CVEs"  = @("99001018")
    "MS-ThreatIntel-XSS"   = @("99032001")
}

# Added and enabled by default in DRS 2.2 compared to DRS 2.1
$rulesAddedInThisVersionByGroup = @{
    "PROTOCOL-ENFORCEMENT" = @("920530", "920620")
    "MS-ThreatIntel-XSS"   = @("99032001")
}

Usare il codice di PowerShell seguente per aggiungere le nuove sostituzioni della regola all'oggetto esistente $groupOverrides definito in precedenza:

foreach ($groupName in $rulesAddedInThisVersionByGroup.Keys) {
    $ruleOverrides = @()
    foreach ($ruleId in $rulesAddedInThisVersionByGroup[$groupName]) {
        $existingGroup = $groupOverrides | Where-Object { $_.RuleGroupName -eq $groupName }
        $alreadyExists = $false
        if ($existingGroup) {
            $alreadyExists = $existingGroup.Rules | Where-Object { $_.RuleId -eq $ruleId }
        }
        if (-not $alreadyExists) {
            $ruleOverrides += New-AzApplicationGatewayFirewallPolicyManagedRuleOverride `
                -RuleId $ruleId `
                -Action "Log" `
                -State "Enabled"
        }
    }
    # Only create or update the group override if we added rules to it
    if ($ruleOverrides.Count -gt 0) {
        $existingGroup = $groupOverrides | Where-Object { $_.RuleGroupName -eq $groupName }
        if ($existingGroup) {
            foreach ($ruleOverride in $ruleOverrides) {
                $existingGroup.Rules.Add($ruleOverride)
            }
        } else {
            $groupOverrides += New-AzApplicationGatewayFirewallPolicyManagedRuleGroupOverride `
                -RuleGroupName $groupName `
                -Rule $ruleOverrides
        }
    }
}

Applicare personalizzazioni e aggiornamento

Definire l'oggetto criteri di WAF di Azure aggiornato, incorporando le sostituzioni e le esclusioni delle regole duplicate e aggiornate.

$managedRuleSet = New-AzApplicationGatewayFirewallPolicyManagedRuleSet `
    -RuleSetType "Microsoft_DefaultRuleSet" `
    -RuleSetVersion "2.2" `
    -RuleGroupOverride $groupOverrides

# Replace the existing CRS (OWASP) or DRS (Microsoft_DefaultRuleSet) managed rule set
for ($i = 0; $i -lt $wafPolicy.ManagedRules.ManagedRuleSets.Count; $i++) {
    if ($wafPolicy.ManagedRules.ManagedRuleSets[$i].RuleSetType -eq "OWASP" -or
        $wafPolicy.ManagedRules.ManagedRuleSets[$i].RuleSetType -eq "Microsoft_DefaultRuleSet") {
        $wafPolicy.ManagedRules.ManagedRuleSets[$i] = $managedRuleSet
        break
    }
}

# Assign the migrated exclusions to the policy
$wafPolicy.ManagedRules.Exclusions = $newRuleSetExclusions

# Apply the updated WAF policy
Set-AzApplicationGatewayFirewallPolicy -InputObject $wafPolicy

Commenti e suggerimenti

Questa pagina è stata utile?

Last updated on 2026-06-30