Wie schließe ich bestimmte URIs von der XSS- oder SQLi-Inspektion für HTTP-Anfragen in AWS WAF aus?

Lesedauer: 5 Minute
0

Wenn ich AWS WAF verwende, erhalte ich bei bestimmten HTTP-Anfragen Falschmeldungen für SQL-Injection (SQLi) oder Cross-Site Scripting (XSS). Ich möchte bestimmte URIs von der XSS- oder SQLi-Inspektion für HTTP-Anfragen ausschließen.

Kurzbeschreibung

False Positives treten manchmal während der Überprüfung von XSS- und SQLi-Regeln für AWS Managed Rules und benutzerdefinierte Regeln auf. Um Fehlalarme zu vermeiden, schließen Sie bestimmte URI-Pfade von der XSS- und SQLi-Inspektion aus. Verwenden Sie dazu verschachtelte Anweisungen, um eine Sperrregel mit Ausnahmen zu schreiben, sodass AWS WAF die Anfrage anhand aller anderen Regeln bewertet.

Auflösung

Beispiel für eine HTTP- oder HTTPS-Anfrage

http://www.amazon.com/path/string1?xss=%3Cscript%3E%3Cscript%3E&sql=UNION%20ALL%20SELECT%201

In dieser Anfrage lautet der URI-Pfad /path/string1. Die Zeichenfolge, die auf das Fragezeichen folgt (?) ist die Abfragezeichenfolge. In diesem Beispiel lautet die Abfragezeichenfolge xss=%3cscript%3e%3cscript%3E&sql=Union%20All%20Select%201.

Beispielregeln zum Zulassen bestimmter URIs aus der XSS- oder SQLi-Überprüfung

Hinweis: Die folgenden Beispielregelkonfigurationen dienen nur als Referenz. Passen Sie diese Regeln für Positionsbeschränkung, Suchbegriff, TextTransformationen usw. an. Sie können eine ähnliche Logik verwenden, um bestimmte Header, Abfrageparameter usw. zuzulassen.

Fall 1: Verwenden von AWS Managed Rules

Die von AWS verwaltete Regelgruppe GemeinsamerRegelsatzfürAWS-verwalteteRegeln enthält die folgenden Regeln:

  • CrossSiteScripting_COOKIE
  • CrossSiteScripting_ABFRAGEARGUMENTE
  • CrossSiteScripting_BODY
  • CrossSiteScripting_URIPATH

Die Regelgruppe GemeinsamerRegelsatzfürAWS-verwalteteRegeln verfügt über eine BLOCK-Aktion, die im entsprechenden Teil der Anforderung nach einer XSS-Angriffszeichenfolge sucht. Weitere Informationen finden Sie unter Verwaltete Regelgruppe mit Kernregelsatz (CRS).

In ähnlicher Weise verfügt die Regelgruppe GemeinsamerRegelsatzfürAWS-verwalteteRegeln über Regeln zur Überprüfung von Abfrageparametern, dem Hauptteil, dem URI-Pfad und einem Cookie für ein SQLi-Injection-Angriffsmuster. Weitere Informationen finden Sie unter Anwendungsfallspezifische Regelgruppen.

Wenn eine Anfrage diesen Regeln entspricht, generiert AWS WAF die entsprechenden Labels. Anschließend kann Ihre benutzerdefinierte Regel in der WEB-ACL diese Labels für verwaltete AWS-Regeln verwenden, um bestimmte Anfragen selektiv von übereinstimmenden Regelsignaturen auszuschließen.

Gehen Sie wie folgt vor, um bestimmte URIs zuzulassen:

1. Behalten Sie die folgenden Regeln aus der Regelgruppe GemeinsamerRegelsatzfürAWS-verwalteteRegeln im Zählen-Modus bei:

  • CrossSiteScripting_COOKIE
  • CrossSiteScripting_ABFRAGEARGUMENTE
  • CrossSiteScripting_BODY
  • CrossSiteScripting_URIPATH

2. Erstellen Sie eine Regel mit einer Blockaktion mit Ausnahmen für URI-Pfade. Konfigurieren Sie die Regel mit einer niedrigeren Priorität als die Priorität von GemeinsamerRegelsatzfürAWS-verwalteteRegeln. Um eine niedrigere Priorität in der AWS-WAF-Konsole zu konfigurieren, platzieren Sie die Regel weiter unten in der Liste. Um eine niedrigere Priorität in JSON zu konfigurieren, verwenden Sie einen größeren Priorität-Wert.

Die Regel verwendet die folgende Logik:

(XSS\ _URIPATH oder XSS\ _Cookie oder XSS\ _Body oder XSS\ _QueryArguments) UND (NICHT zugelassener URIString) = BLOCK

Verwenden Sie die folgende Konfiguration:

{
  "Name": "whitelist-xss",
  "Priority": 10,
  "Statement": {
    "AndStatement": {
      "Statements": \[
        {
          "OrStatement": {
            "Statements": \[
              {
                "LabelMatchStatement": {
                  "Scope": "LABEL",
                  "Key": "awswaf:managed:aws:core-rule-set:CrossSiteScripting\_URIPath"
                }
              },
              {
                "LabelMatchStatement": {
                  "Scope": "LABEL",
                  "Key": "awswaf:managed:aws:core-rule-set:CrossSiteScripting\_Cookie"
                }
              },
              {
                "LabelMatchStatement": {
                  "Scope": "LABEL",
                  "Key": "awswaf:managed:aws:core-rule-set:CrossSiteScripting\_Body"
                }
              },
              {
                "LabelMatchStatement": {
                  "Scope": "LABEL",
                  "Key": "awswaf:managed:aws:core-rule-set:CrossSiteScripting\_QueryArguments"
                }
              }
            \]
          }
        },
        {
          "NotStatement": {
            "Statement": {
              "ByteMatchStatement": {
                "SearchString": "/path/string1",
                "FieldToMatch": {
                  "UriPath": {}
                },
                "TextTransformations": \[
                  {
                    "Priority": 0,
                    "Type": "NONE"
                  }
                \],
                "PositionalConstraint": "CONTAINS"
              }
            }
          }
        }
      \]
    }
  },
  "Action": {
    "Block": {}
  },
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "whitelist-xss"
  }
}

Hinweis: In diesem Beispiel schließt die OR-Anweisung bestimmte URIs aus allen Labels und Teilen der Webanforderung aus: Hauptteil, Header, URI-Pfad und Abfrageargumente. In diesem Beispiel wird davon ausgegangen, dass Sie in allen Teilen der Webanforderung auf ein falsch positives Ergebnis für denselben URI gestoßen sind. Möglicherweise stoßen Sie jedoch nur in einem Teil der Webanforderung auf ein falsch positives Ergebnis, z. B. in Abfrageargumenten. In diesem Fall ist es eine bewährte Sicherheitsmethode, eine separate Regel nur für einen Teil der Webanforderung und das entsprechende Label zu erstellen. Schließen Sie für diese separate Regel den spezifischen URI-Pfad nicht aus allen Teilen der Webanforderung aus.

Verwenden Sie für GemeinsamerRegelsatzfürAWS-verwalteteRegeln dieselben Schritte, ersetzen Sie jedoch die Beschriftungen durch von GemeinsamerRegelsatzfürAWS-verwalteteRegeln generierte Labels.

Wenn Sie mehrere URIs haben, die Sie von der Inspektion ausschließen möchten, verwenden Sie OR-Anweisung innerhalb von ** Nicht-Anweisung**. Um beispielsweise /path/string1 und /path/string2 auszuschließen, verwenden Sie die folgende Nicht-Anweisung:

{
  "NotStatement": {
    "Statement": {
      "OrStatement": {
        "Statements": \[
          {
            "ByteMatchStatement": {
              "SearchString": "/path/string1",
              "FieldToMatch": {
                "UriPath": {}
              },
              "TextTransformations": \[
                {
                  "Priority": 0,
                  "Type": "NONE"
                }
              \],
              "PositionalConstraint": "CONTAINS"
            }
          },
          {
            "ByteMatchStatement": {
              "SearchString": "/path/string2",
              "FieldToMatch": {
                "UriPath": {}
              },
              "TextTransformations": \[
                {
                  "Priority": 0,
                  "Type": "NONE"
                }
              \],
              "PositionalConstraint": "CONTAINS"
            }
          }
        \]
      }
    }
  }
}

Fall 2: Verwenden Sie benutzerdefinierte XSS- und SQLi-Regeln

Die Regel verwendet die folgende Logik:

(XSS\ _URIPATH oder XSS\ _Cookie oder XSS\ _Body oder XSS\ _QueryArguments) UND (NICHT zugelassener URIString) = BLOCK

Verwenden Sie die folgende Regelkonfiguration, um XSS-Angriffszeichenfolgen für die Anfrage zu überprüfen, aber auch selektiv einen bestimmten URI_PATH auszuschließen:

{
  "Name": "xss-URI",
  "Priority": 10,
  "Action": {
    "Block": {}
  },
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "xss-URI"
  },
  "Statement": {
    "AndStatement": {
      "Statements": \[
        {
          "OrStatement": {
            "Statements": \[
              {
                "XssMatchStatement": {
                  "FieldToMatch": {
                    "UriPath": {}
                  },
                  "TextTransformations": \[
                    {
                      "Priority": 0,
                      "Type": "NONE"
                    }
                  \]
                }
              },
              {
                "XssMatchStatement": {
                  "FieldToMatch": {
                    "Cookies": {
                      "MatchPattern": {
                        "All": {}
                      },
                      "MatchScope": "ALL",
                      "OversizeHandling": "CONTINUE"
                    }
                  },
                  "TextTransformations": \[
                    {
                      "Priority": 0,
                      "Type": "NONE"
                    }
                  \]
                }
              },
              {
                "XssMatchStatement": {
                  "FieldToMatch": {
                    "Body": {
                      "OversizeHandling": "CONTINUE"
                    }
                  },
                  "TextTransformations": \[
                    {
                      "Priority": 0,
                      "Type": "NONE"
                    }
                  \]
                }
              },
              {
                "XssMatchStatement": {
                  "FieldToMatch": {
                    "AllQueryArguments": {}
                  },
                  "TextTransformations": \[
                    {
                      "Priority": 0,
                      "Type": "NONE"
                    }
                  \]
                }
              }
            \]
          }
        },
        {
          "NotStatement": {
            "Statement": {
              "ByteMatchStatement": {
                "FieldToMatch": {
                  "UriPath": {}
                },
                "PositionalConstraint": "CONTAINS",
                "SearchString": "/path/string1",
                "TextTransformations": \[
                  {
                    "Type": "NONE",
                    "Priority": 0
                  }
                \]
              }
            }
          }
        }
      \]
    }
  }
}

Gehen Sie wie folgt vor, wenn Sie SQLi-Anweisungen verwenden.

Hinweis: Es ist keine bewährte Methode, eine Regel mit höherer Priorität zu haben, die nur den URI zulässt. Dadurch wird verhindert, dass die Anfrage mit dem zulässigen URI_PATH anhand aller anderen in der Web-ACL definierten Regeln bewertet wird.

Ähnliche Informationen

Grundlagen der Regelerklärung

Regelerklärung für Cross-Site-Scripting-Angriffe

Regelanweisung für SQL-Injection-Angriffe

AWS OFFICIAL
AWS OFFICIALAktualisiert vor 8 Monaten