Come si escludono URI specifici da ispezioni XSS o SQLi per le richieste HTTP quando si utilizza AWS WAF?

Breve descrizione

Talvolta si verificano falsi positivi durante l'ispezione delle regole XSS e SQLi per regole gestite AWS e per le regole personalizzate. Per evitare falsi positivi, è possibile escludere percorsi URI specifici dalle ispezioni XSS e SQLi. A tale scopo, utilizzare istruzioni annidate per scrivere la regola di autorizzazione, in modo che la richiesta venga valutata rispetto a tutte le altre regole.

Risoluzione

Esempio di richiesta HTTP o HTTPS

http://www.amazon.com/path/string1?abc=123&xyz=567

Nella richiesta precedente, il percorso URI è '/path/string1'. Qualsiasi stringa che segue '?' è denominata stringa di query, come ' abc=123&xyz=567' nell'esempio precedente. Nella stringa di query, 'abc' e 'xyz' sono i parametri di query, rispettivamente con valori '123' e '567'.

Regole di esempio per autorizzare URI specifici dalle ispezioni XSS o SQLi

Nota: le seguenti configurazioni di regole di esempio sono indicate solo come riferimento. È necessario personalizzare queste regole per PositionalConstraint, SearchString, TextTransformations e così via. È possibile utilizzare una logica simile per autorizzare intestazioni, parametri di query o altri elementi specifici.

Caso 1: utilizzo delle regole gestite AWS

Il gruppo di regole gestite AWS, AWSManagedRulesCommonRuleSet, contiene le seguenti regole:

• CrossSiteScripting_COOKIE
• CrossSiteScripting_QUERYARGUMENTS
• CrossSiteScripting_BODY
• CrossSiteScripting_URIPATH

Il gruppo di regole AwsManagedRulesCommonRuleSet dispone dell'azione BLOCK che esegue un'ispezione affinché una stringa di attacco XSS sia presente nella parte corrispondente della richiesta. Per ulteriori informazioni, consulta Core rule set (CRS) managed rule group.

Allo stesso modo, il gruppo di regole AWSManagedRulesSQLiRuleSet dispone di regole per ispezionare i parametri di query, il corpo e un cookie per un modello di attacco di iniezione SQLi. Per ulteriori informazioni, verifica i Gruppi di regole specifici per casi d'uso.

Quando una richiesta soddisfa le regole precedenti, AWS WAF genera le etichette corrispondenti. Le etichette vengono utilizzate nella regola definita successivamente nell'ACL Web per escludere selettivamente richieste specifiche (in questo esempio in base all'URI).

Per autorizzare URI specifici, effettua le seguenti operazioni:

1.    Mantieni le seguenti regole del gruppo di regole AWSManagedRulesCommonRulesSet in modalità Count (Conteggio):

• CrossSiteScripting_COOKIE
• CrossSiteScripting_QUERYARGUMENTS
• CrossSiteScripting_BODY
• CrossSiteScripting_URIPATH

2.    Crea una regola di autorizzazione configurata con priorità inferiore a quella di AWSManagedRulesCommonRuleSet.

La logica della regola è la seguente:

(XSS_URIPATH o XSS_Cookie or XSS_Body or XSS_QueryArguments) AND (NOT whitelisted URIString) = BLOCK

Utilizza la seguente configurazione:

{
  "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": "URI_SearchString",
                "FieldToMatch": {
                  "UriPath": {}
                },
                "TextTransformations": [
                  {
                    "Priority": 0,
                    "Type": "NONE"
                  }
                ],
                "PositionalConstraint": "CONTAINS"
              }
            }
          }
        }
      ]
    }
  },
  "Action": {
    "Block": {}
  },
  "VisibilityConfig": {
    "SampledRequestsEnabled": true,
    "CloudWatchMetricsEnabled": true,
    "MetricName": "whitelist-xss"
  }
}

Segui i passaggi precedenti per AWSManagedRulesSQLiRuleSet, sostituendo le etichette con quelle generate da AWSManagedRulesSQLiRuleSet.

Caso 2: utilizzo di regole XSS e SQLi personalizzate

La logica della regola è la seguente:

(XSS_URIPATH o XSS_Cookie or XSS_Body or XSS_QueryArguments) AND (NOT whitelisted URIString) = BLOCK

Utilizza la seguente configurazione della regola per ispezionare le stringhe di attacco XSS per la richiesta, escludendo selettivamente un URI_PATH specifico:

{
  "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": "URI_SearchString",
                "TextTransformations": [
                  {
                    "Type": "NONE",
                    "Priority": 0
                  }
                ]
              }
            }
          }
        }
      ]
    }
  }
}

Segui la procedura precedente quando si utilizzano istruzioni SQLi.

Nota: non è consigliabile avere una regola con priorità superiore che autorizzi solo l'URI. In questo modo non si permette di valutare la richiesta autorizzata URI_PATH rispetto a tutte le altre regole definite nell’ACL Web.

---

Informazioni correlate

Istruzioni delle regole AWS WAF

Istruzione della regola per attacco cross-site scripting

Istruzione della regola per attacco di iniezione SQL