Ausschlusslisten für die Web Application Firewall

Artikel
10/19/2023

Die Web Application Firewall (WAF) von Azure Application Gateway bietet Schutz für Webanwendungen. In diesem Artikel wird die Konfiguration für WAF-Ausschlusslisten beschrieben. Diese Einstellungen befinden sich in der WAF-Richtlinie, die Ihrer Application Gateway-Instanz zugeordnet ist. Weitere Informationen zu WAF-Richtlinien finden Sie unter Azure Web Application Firewall auf Azure Application Gateway und Erstellen von Web Application Firewall-Richtlinien für Application Gateway.

Manchmal blockiert WAF eine Anforderung, die Sie für Ihre Anwendung zulassen möchten. Mit WAF-Ausschlusslisten können Sie bestimmte Anforderungsattribute in einer WAF-Auswertung weglassen. Der Rest der Anforderung wird wie gewohnt ausgewertet.

Beispielsweise fügt Active Directory Token ein, die für die Authentifizierung verwendet werden. Bei Verwendung in einem Anforderungsheader können diese Token Sonderzeichen enthalten, die falsch positive Funde von den WAF-Regeln auslösen können. Durch Hinzufügen des Headers zu einer Ausschlussliste können Sie die WAF so konfigurieren, dass der Header ignoriert wird. Die WAF wertet jedoch weiterhin den Rest der Anforderung aus.

Sie können Ausschlüsse so konfigurieren, dass sie bei Auswertung bestimmter WAF-Regeln oder global auf die Auswertung aller WAF-Regeln angewendet werden. Ausschlussregeln gelten für Ihre gesamte Webanwendung.

Identifizieren von Anforderungsattributen, die ausgeschlossen werden sollen

Wenn Sie einen WAF-Ausschluss konfigurieren, müssen Sie die Attribute der Anforderung angeben, die aus der WAF-Auswertung ausgeschlossen werden soll. Sie können einen WAF-Ausschluss für die folgenden Anforderungsattribute konfigurieren:

Anforderungsheader
Anforderungscookies
Ein Anforderungsattributname (Argument) kann als Ausschlusselement hinzugefügt werden. Beispiele hierfür sind:
- Name des Formularfelds
- JSON-Entität
- URL-Abfragezeichenfolgenargument

Sie können eine exakte Übereinstimmung für Anforderungsheader, Test, Cookies oder Abfragezeichenfolgenattribute angeben. Oder Sie können teilweise Übereinstimmungen angeben. Verwenden Sie die folgenden Operatoren, um den Ausschluss zu konfigurieren:

Equals: Dieser Operator wird für eine exakte Übereinstimmung verwendet. Verwenden Sie beispielsweise zum Auswählen eines Headers namens bearerToken den Operator „equals“ mit dem Selektor bearerToken.
Starts with (Beginnt mit): Dieser Operator gleicht alle Felder ab, die mit dem angegebenen Selektorwert beginnen.
Ends with: Dieser Operator findet alle Anfragefelder, die mit dem angegebenen Selektorwert enden.
Contains (Enthält): Dieser Operator gleicht alle Anforderungsfelder ab, die den angegebenen Selektorwert enthalten.
Gleich beliebige: Dieser Operator entspricht allen angeforderten Feldern. * wird zum Selektorwert. Sie verwenden diesen Operator beispielsweise, wenn Sie die genauen Werte für eine bestimmte Übereinstimmungsvariable nicht kennen, aber sicherstellen möchten, dass der Anforderungsdatenverkehr weiterhin von der Regelauswertung ausgeschlossen wird.

Bei der Verarbeitung von Ausschlüssen führt die WAF-Engine basierend auf der folgenden Tabelle eine Übereinstimmung in Bezug auf die Berücksichtigung oder Nichtberücksichtigung der Groß-/Kleinschreibung durch. Darüber hinaus sind reguläre Ausdrücke nicht zulässig, da Selektoren und XML-Anforderungstexte nicht unterstützt werden.

Anforderungstextteil	CRS 3.1 und früher	CRS 3.2 und später
Header*	Keine Beachtung von Groß-/Kleinschreibung	Keine Beachtung von Groß-/Kleinschreibung
Cookie*	Keine Beachtung von Groß-/Kleinschreibung	Groß-/Kleinschreibung
Abfragezeichenfolge*	Keine Beachtung von Groß-/Kleinschreibung	Groß-/Kleinschreibung
URL-codierter Text	Keine Beachtung von Groß-/Kleinschreibung	Groß-/Kleinschreibung
JSON-Text	Keine Beachtung von Groß-/Kleinschreibung	Groß-/Kleinschreibung
XML-Text	Nicht unterstützt	Nicht unterstützt
Mehrteiliger Text	Keine Beachtung von Groß-/Kleinschreibung	Groß-/Kleinschreibung

*Abhängig von Ihrer Anwendung kann bei Namen und Werten Ihrer Header, Cookies und Abfrageargumente zwischen Groß-/Kleinschreibung unterschieden oder nicht unterschieden werden.

Hinweis

Weitere Informationen und Hilfe zum Troubleshooting finden Sie unter Problembehandlung für die Web Application Firewall (WAF) für Azure Application Gateway.

Anfordern von Attributen nach Schlüsseln und Werten

Wenn Sie einen Ausschluss konfigurieren, müssen Sie ermitteln, ob Sie den Schlüssel oder den Wert aus der WAF-Auswertung ausschließen möchten.

Angenommen, Ihre Anforderungen enthalten diesen Header:

My-Header: 1=1

Der Wert des Headers (1=1) kann durch die WAF als Angriff erkannt werden. Wenn Sie jedoch wissen, dass es sich um einen legitimen Wert für Ihr Szenario handelt, können Sie einen Ausschluss für den Wert des Headers konfigurieren. Dazu verwenden Sie die Vergleichsvariable RequestHeaderValues, den Operator contains und den Selektor (My-Header). Diese Konfiguration beendet die Auswertung aller Werte für den Header My-Header.

Hinweis

Anforderungsattribute nach Schlüsseln und Werten sind nur in CRS 3.2 oder höher und in Bot Manager 1.0 oder höher verfügbar.

Anforderungsattribute nach Namen funktionieren genauso wie Anforderungsattribute nach Werten und sind für die Abwärtskompatibilität mit CRS 3.1 und früheren Versionen enthalten. Es wird empfohlen, Anforderungsattribute nach Werten anstelle von Anforderungsattributen nach Namen zu verwenden. Verwenden Sie beispielsweise RequestHeaderValues anstelle von RequestHeaderNames.

Wenn Ihre WAF hingegen den Namen des Headers (My-Header) als Angriff erkennt, können Sie einen Ausschluss für den Headerschlüssel mithilfe des Anforderungsattributs RequestHeaderKeys konfigurieren. Das Attribut RequestHeaderKeys ist nur in CRS 3.2 oder höher und in Bot Manager 1.0 oder höher verfügbar.

Beispiele für Anforderungsattribute

Die folgende Tabelle enthält einige Beispiele dafür, wie Sie den Ausschluss für eine bestimmte Übereinstimmungsvariable strukturieren können.

Auszuschließendes Attribut	matchVariable	selectorMatchOperator	Beispielselektor	Beispielanforderung	Was ausgeschlossen wird
Abfragezeichenfolge	RequestArgKeys	Equals	`/etc/passwd`	URI: `http://localhost:8080/?/etc/passwd=test`	`/etc/passwd`
Abfragezeichenfolge	RequestArgKeys	EqualsAny	Nicht zutreffend	URI: `http://localhost:8080/?/etc/passwd=test&.htaccess=test2`	`/etc/passwd` und `.htaccess`
Abfragezeichenfolge	RequestArgNames	Equals	`text`	URI: `http://localhost:8080/?text=/etc/passwd`	`/etc/passwd`
Abfragezeichenfolge	RequestArgNames	EqualsAny	Nicht zutreffend	URI: `http://localhost:8080/?text=/etc/passwd&text2=.cshrc`	`/etc/passwd` und `.cshrc`
Abfragezeichenfolge	RequestArgValues	Equals	`text`	URI: `http://localhost:8080/?text=/etc/passwd`	`/etc/passwd`
Abfragezeichenfolge	RequestArgValues	EqualsAny	Nicht zutreffend	URI: `http://localhost:8080/?text=/etc/passwd&text2=.cshrc`	`/etc/passwd` und `.cshrc`
Anforderungstext	RequestArgKeys	Enthält	`sleep`	Anforderungstext: `{"sleep(5)": "test"}`	`sleep(5)`
Anforderungstext	RequestArgKeys	EqualsAny	Nicht zutreffend	Anforderungstext: `{".zshrc": "value", "sleep(5)":"value2"}`	`.zshrc` und `sleep(5)`
Anforderungstext	RequestArgNames	Equals	`test`	Anforderungstext: `{"test": ".zshrc"}`	`.zshrc`
Anforderungstext	RequestArgNames	EqualsAny	Nicht zutreffend	Anforderungstext: `{"key1": ".zshrc", "key2":"sleep(5)"}`	`.zshrc` und `sleep(5)`
Anforderungstext	RequestArgValues	Equals	`test`	Anforderungstext: `{"test": ".zshrc"}`	`.zshrc`
Anforderungstext	RequestArgValues	EqualsAny	Nicht zutreffend	Anforderungstext: `{"key1": ".zshrc", "key2":"sleep(5)"}`	`.zshrc` und `sleep(5)`
Header	RequestHeaderKeys	Equals	`X-Scanner`	Header: `{"X-Scanner": "test"}`	`X-scanner`
Header	RequestHeaderKeys	EqualsAny	Nicht zutreffend	Header: `{"X-Scanner": "test", "x-ratproxy-loop": "value"}`	`X-Scanner` und `x-ratproxy-loop`
Header	RequestHeaderNames	Equals	`head1`	Header: `{"head1": "X-Scanner"}`	`X-scanner`
Header	RequestHeaderNames	EqualsAny	Nicht zutreffend	Header: `{"head1": "myvar=1234", "User-Agent": "(hydra)"}`	`myvar=1234` und `(hydra)`
Header	RequestHeaderValues	Equals	`head1`	Header: `{"head1": "X-Scanner"}`	`X-scanner`
Header	RequestHeaderValues	EqualsAny	Nicht zutreffend	Header: `{"head1": "myvar=1234", "User-Agent": "(hydra)"}`	`myvar=1234` und `(hydra)`
Cookie	RequestCookieKeys	Enthält	`/etc/passwd`	Header: `{"Cookie": "/etc/passwdtest=hello1"}`	`/etc/passwdtest`
Cookie	RequestCookieKeys	EqualsAny	Nicht zutreffend	Header: `{"Cookie": "/etc/passwdtest=hello1", "Cookie": ".htaccess=test1"}`	`/etc/passwdtest` und `.htaccess`
Cookie	RequestCookieNames	Equals	`arg1`	Header: `{"Cookie": "arg1=/etc/passwd"}`	`/etc/passwd`
Cookie	RequestCookieNames	EqualsAny	Nicht zutreffend	Header: `{"Cookie": "arg1=/etc/passwd", "Cookie": "arg1=.cshrc"}`	`/etc/passwd` und `.cshrc`
Cookie	RequestCookieValues	Equals	`arg1`	Header: `{"Cookie": "arg1=/etc/passwd"}`	`/etc/passwd`
Cookie	RequestCookieValues	EqualsAny	Nicht zutreffend	Header: `{"Cookie": "arg1=/etc/passwd", "Cookie": "arg1=.cshrc"}`	`/etc/passwd` und `.cshrc`

Hinweis

Wenn Sie einen Ausschluss mithilfe des selectorMatchOperator-Werts EqualsAny erstellen, wird alles, was Sie in das Auswahlfeld einfügen, vom Back-End in „*“ konvertiert, wenn der Ausschluss erstellt wird.

Ausschlussbereiche

Ausschlüsse können so konfiguriert werden, dass sie auf einen bestimmten Satz von WAF-Regeln, auf bestimmte Regelsätze oder global auf alle Regeln angewendet werden.

Tipp

Es empfiehlt sich, Ausschlüsse so eng und spezifisch wie möglich zu formulieren, um zu vermeiden, dass Angreifern versehentlich Raum gelassen wird, um Ihr System auszunutzen. Wenn Sie eine Ausschlussregel hinzufügen müssen, verwenden Sie nach Möglichkeit Ausschlüsse pro Regel.

Ausschlüsse pro Regel

Sie können einen Ausschluss für eine bestimmte Regel, eine bestimmte Regelgruppe oder einen bestimmten Regelsatz konfigurieren. Sie müssen die Regel oder Regeln angeben, für die der Ausschluss gilt. Sie müssen auch das Anforderungsattribut angeben, das aus der WAF-Auswertung ausgeschlossen werden soll. Zum vollständigen Ausschließen einer Gruppe von Regeln geben Sie nur den ruleGroupName-Parameter an. Der Parameter rules ist nur nützlich, wenn Sie den Ausschluss auf bestimmte Regeln einer Gruppe beschränken möchten.

Ausschlüsse pro Regel sind verfügbar, wenn Sie den Regelsatz von OWASP (CRS), Version 3.2 oder höher, oder den Regelsatz von Bot Manager, Version 1.0 oder höher, verwenden.

Beispiel

Angenommen, Sie möchten, dass die WAF den Wert des User-Agent-Anforderungsheaders ignoriert. Der Header User-Agent umfasst eine charakteristische Zeichenfolge, die es den Netzwerkprotokollpeers ermöglicht, den Anwendungstyp, das Betriebssystem, den Softwarehersteller oder die Softwareversion des anfordernden Softwarebenutzer-Agent zu ermitteln. Weitere Informationen finden Sie unter User-Agent (Benutzer-Agent).

Es gibt alle möglichen Gründe, die Auswertung dieses Headers zu deaktivieren. Die WAF könnte eine Zeichenfolge als schädlich einstufen. Beispielsweise kann der User-Agent-Header den klassischen Angriff der Einschleusung von SQL-Befehlen (x=x) in einer Zeichenfolge enthalten. In einigen Fällen kann dies berechtigter Datenverkehr sein. Sie müssen diesen Header daher möglicherweise von der WAF-Auswertung ausschließen.

Sie können die folgenden Ansätze verwenden, um den User-Agent-Header von der Auswertung durch alle Regeln bezüglich der Einschleusung von SQL-Befehlen auszuschließen:

Führen Sie die folgenden Schritte aus, um einen Ausschluss pro Regel mithilfe des Azure-Portals zu konfigurieren:

Navigieren Sie zur WAF-Richtlinie, und wählen Sie Verwaltete Regeln aus.
Wählen Sie Ausschlüsse hinzufügen aus.
Wählen Sie unter Gilt für den CRS-Regelsatz aus, auf den der Ausschluss angewendet werden soll, etwa OWASP_3.2.
Wählen Sie Regeln hinzufügen und dann die Regeln aus, auf die Ausschlüsse angewendet werden sollen.
Konfigurieren Sie die Übereinstimmungsvariable, den Operator und den Selektor. Klicken Sie dann auf Speichern.

Sie können mehrere Ausschlüsse konfigurieren.

$ruleGroupEntry = New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleGroup `
  -RuleGroupName 'REQUEST-942-APPLICATION-ATTACK-SQLI'

$exclusionManagedRuleSet = New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleSet `
  -RuleSetType 'OWASP' `
  -RuleSetVersion '3.2' `
  -RuleGroup $ruleGroupEntry

$exclusionEntry = New-AzApplicationGatewayFirewallPolicyExclusion `
  -MatchVariable "RequestHeaderValues" `
  -SelectorMatchOperator 'Equals' `
  -Selector 'User-Agent' `
  -ExclusionManagedRuleSet $exclusionManagedRuleSet

$wafPolicy = Get-AzApplicationGatewayFirewallPolicy `
  -Name $wafPolicyName `
  -ResourceGroupName $resourceGroupName
$wafPolicy.ManagedRules[0].Exclusions.Add($exclusionEntry)
$wafPolicy | Set-AzApplicationGatewayFirewallPolicy

az network application-gateway waf-policy managed-rule exclusion rule-set add \
  --resource-group $resourceGroupName \
  --policy-name $wafPolicyName \
  --type OWASP \
  --version 3.2 \
  --group-name 'REQUEST-942-APPLICATION-ATTACK-SQLI' \
  --match-variable 'RequestHeaderValues' \
  --match-operator 'Equals' \
  --selector 'User-Agent'

resource wafPolicy 'Microsoft.Network/ApplicationGatewayWebApplicationFirewallPolicies@2021-08-01' = {
  name: wafPolicyName
  location: location
  properties: {
    managedRules: {
      managedRuleSets: [
        {
          ruleSetType: 'OWASP'
          ruleSetVersion: '3.2'
        }
      ]
      exclusions: [
        {
          matchVariable: 'RequestHeaderValues'
          selectorMatchOperator: 'Equals'
          selector: 'User-Agent'
          exclusionManagedRuleSets: [
            {
              ruleSetType: 'OWASP'
              ruleSetVersion: '3.2'
              ruleGroups: [
                {
                  ruleGroupName: 'REQUEST-942-APPLICATION-ATTACK-SQLI'
                  rules: [
                    {
                      ruleId: '942150'
                    }
                    {
                      ruleId: '942410'
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  }
}

{
  "type": "Microsoft.Network/ApplicationGatewayWebApplicationFirewallPolicies",
  "apiVersion": "2021-08-01",
  "name": "[parameters('wafPolicyName')]",
  "location": "[parameters('location')]",
  "properties": {
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "OWASP",
          "ruleSetVersion": "3.2"
        }
      ],
      "exclusions": [
        {
          "matchVariable": "RequestHeaderValues",
          "selectorMatchOperator": "Equals",
          "selector": "User-Agent",
          "exclusionManagedRuleSets": [
            {
              "ruleSetType": "OWASP",
              "ruleSetVersion": "3.2",
              "ruleGroups": [
                {
                  "ruleGroupName": "REQUEST-942-APPLICATION-ATTACK-SQLI",
                  "rules": [
                    {
                      "ruleId": "942150"
                    },
                    {
                      "ruleId": "942410"
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  }
}

Sie können die User-Agent-Kopfzeile auch direkt nach Regel 942270 von der Auswertung ausschließen :

Führen Sie die im vorherigen Beispiel beschriebenen Schritte aus, und wählen Sie die Regel 942270 in Schritt 4 aus.

$ruleEntry = New-AzApplicationGatewayFirewallPolicyExclusionManagedRule `
  -Rule '942270'

$ruleGroupEntry = New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleGroup `
  -RuleGroupName 'REQUEST-942-APPLICATION-ATTACK-SQLI' `
  -Rule $ruleEntry

$exclusionManagedRuleSet = New-AzApplicationGatewayFirewallPolicyExclusionManagedRuleSet `
  -RuleSetType 'OWASP' `
  -RuleSetVersion '3.2' `
  -RuleGroup $ruleGroupEntry

$exclusionEntry = New-AzApplicationGatewayFirewallPolicyExclusion `
  -MatchVariable "RequestHeaderValues" `
  -SelectorMatchOperator 'Equals' `
  -Selector 'User-Agent' `
  -ExclusionManagedRuleSet $exclusionManagedRuleSet

$wafPolicy = Get-AzApplicationGatewayFirewallPolicy `
  -Name $wafPolicyName `
  -ResourceGroupName $resourceGroupName
$wafPolicy.ManagedRules[0].Exclusions.Add($exclusionEntry)
$wafPolicy | Set-AzApplicationGatewayFirewallPolicy

az network application-gateway waf-policy managed-rule exclusion rule-set add \
  --resource-group $resourceGroupName \
  --policy-name $wafPolicyName \
  --type OWASP \
  --version 3.2 \
  --group-name 'REQUEST-942-APPLICATION-ATTACK-SQLI' \
  --rule-ids 942270 \
  --match-variable 'RequestHeaderValues' \
  --match-operator 'Equals' \
  --selector 'User-Agent'

resource wafPolicy 'Microsoft.Network/ApplicationGatewayWebApplicationFirewallPolicies@2021-08-01' = {
  name: wafPolicyName
  location: location
  properties: {
    managedRules: {
      managedRuleSets: [
        {
          ruleSetType: 'OWASP'
          ruleSetVersion: '3.2'
        }
      ]
      exclusions: [
        {
          matchVariable: 'RequestHeaderValues'
          selectorMatchOperator: 'Equals'
          selector: 'User-Agent'
          exclusionManagedRuleSets: [
            {
              ruleSetType: 'OWASP'
              ruleSetVersion: '3.2'
              ruleGroups: [
                {
                  ruleGroupName: 'REQUEST-942-APPLICATION-ATTACK-SQLI'
                  rules: [
                    {
                      ruleId: '942270'
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  }
}

{
  "type": "Microsoft.Network/ApplicationGatewayWebApplicationFirewallPolicies",
  "apiVersion": "2021-08-01",
  "name": "[parameters('wafPolicyName')]",
  "location": "[parameters('location')]",
  "properties": {
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "OWASP",
          "ruleSetVersion": "3.2"
        }
      ],
      "exclusions": [
        {
          "matchVariable": "RequestHeaderValues",
          "selectorMatchOperator": "Equals",
          "selector": "User-Agent",
          "exclusionManagedRuleSets": [
            {
              "ruleSetType": "OWASP",
              "ruleSetVersion": "3.2",
              "ruleGroups": [
                {
                  "ruleGroupName": "REQUEST-942-APPLICATION-ATTACK-SQLI",
                  "rules": [
                    {
                      "ruleId": "942270"
                    }
                  ]
                }
              ]
            }
          ]
        }
      ]
    }
  }
}

Globale Ausschlüsse

Sie können einen Ausschluss für alle WAF-Regeln konfigurieren.

Beispiel

Angenommen, Sie möchten den Wert im Parameter user ausschließen, der in der Anforderung über die URL übergeben wird. Angenommen, in Ihrer Umgebung enthält das Abfragezeichenfolgenargument user üblicherweise eine Zeichenfolge, die von der WAF als schädlich eingestuft und daher von dieser blockiert wird. Sie können alle Abfragezeichenfolgenargumente ausschließen, bei denen der Name mit dem Wort user beginnt, damit die WAF den Wert des Felds nicht auswertet.

Das folgende Beispiel zeigt, wie Sie das Abfragezeichenfolgenargument user aus der Auswertung ausschließen können:

Führen Sie die folgenden Schritte aus, um einen globalen Ausschluss mithilfe des Azure-Portals zu konfigurieren:

Navigieren Sie zur WAF-Richtlinie, und wählen Sie Verwaltete Regeln aus.
Wählen Sie Ausschlüsse hinzufügen aus.
Wählen Sie unter Gilt für die Option Global aus.
Konfigurieren Sie die Übereinstimmungsvariable, den Operator und den Selektor. Klicken Sie dann auf Speichern.

Sie können mehrere Ausschlüsse konfigurieren.

$exclusion = New-AzApplicationGatewayFirewallExclusionConfig `
   -MatchVariable 'RequestArgNames' `
   -SelectorMatchOperator 'StartsWith' `
   -Selector 'user'

az network application-gateway waf-policy managed-rule exclusion add \
  --resource-group $resourceGroupName \
  --policy-name $wafPolicyName \
  --match-variable 'RequestArgNames' \
  --selector-match-operator 'StartsWith' \
  --selector 'user'

resource wafPolicy 'Microsoft.Network/ApplicationGatewayWebApplicationFirewallPolicies@2021-08-01' = {
  name: wafPolicyName
  location: location
  properties: {
    managedRules: {
      managedRuleSets: [
        {
          ruleSetType: 'OWASP'
          ruleSetVersion: '3.2'
        }
      ]
      exclusions: [
        {
          matchVariable: 'RequestArgNames'
          selectorMatchOperator: 'StartsWith'
          selector: 'user'
        }
      ]
    }
  }
}

{
  "type": "Microsoft.Network/ApplicationGatewayWebApplicationFirewallPolicies",
  "apiVersion": "2021-08-01",
  "name": "[parameters('wafPolicyName')]",
  "location": "[parameters('location')]",
  "properties": {
    "managedRules": {
      "managedRuleSets": [
        {
          "ruleSetType": "OWASP",
          "ruleSetVersion": "3.2"
        }
      ],
      "exclusions": [
        {
          "matchVariable": "RequestArgNames",
          "selectorMatchOperator": "StartsWith",
          "selector": "user"
        }
      ]
    }
  }
}

Wenn also die URL http://www.contoso.com/?user%3c%3e=joe von der WAF gescannt wird, wird die Zeichenfolge joe nicht ausgewertet, der Parametername user%3c%3e dagegen schon.

Nächste Schritte

Nach dem Konfigurieren Ihrer WAF-Einstellungen können Sie sich darüber informieren, wie Sie WAF-Protokolle anzeigen. Weitere Informationen finden Sie unter Application Gateway-Diagnose.
Weitere Informationen zur Azure-Netzwerksicherheit

Freigeben über

Ausschlusslisten für die Web Application Firewall

Identifizieren von Anforderungsattributen, die ausgeschlossen werden sollen

Anfordern von Attributen nach Schlüsseln und Werten

Beispiele für Anforderungsattribute

Ausschlussbereiche

Ausschlüsse pro Regel

Beispiel

Globale Ausschlüsse

Beispiel

Nächste Schritte

Feedback

Zusätzliche Ressourcen