¿Cómo puedo excluir URI específicas de la inspección XSS o SQLi para solicitudes HTTP cuando se utiliza AWS WAF?

Descripción corta

A veces se producen falsos positivos durante la inspección de reglas XSS y SQLi en el caso de las reglas administradas de AWS y las reglas personalizadas. Se pueden excluir rutas URI específicas de la inspección XSS y SQLi para evitar falsos positivos. Para ello, utilice instrucciones anidadas para escribir la regla de permitir (allow) de manera que la solicitud se evalúe con respecto a todas las demás reglas.

Resolución

Ejemplo de solicitud HTTP o HTTPS

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

En la solicitud anterior, la ruta del URI es “/path/string1”. Cualquier cadena que siga a “?” se denomina cadena de consulta, como “  abc=123&xyz=567” en el ejemplo anterior. En la cadena de consulta, “abc” y “xyz” son los parámetros de consulta con valores “123” y “567”, respectivamente.

Ejemplos de reglas para permitir URI específicos de la inspección XSS o SQLi

Nota: Los siguientes ejemplos de configuraciones de reglas son únicamente de referencia. Debe personalizar estas reglas para PositionalConstraint, SearchString, TextTransformations, etc. Puede utilizar una lógica similar para permitir encabezados específicos, parámetros de consulta, etc.

Caso 1: utilizar reglas administradas de AWS

El grupo de reglas administradas de AWS AWSManagedRulesCommonRuleSet contiene las siguientes reglas:

• CrossSiteScripting_COOKIE
• CrossSiteScripting_QUERYARGUMENTS
• CrossSiteScripting_BODY
• CrossSiteScripting_URIPATH

El grupo de reglas AWSManagedRulesCommonRuleSet contiene la acción BLOCK, que realiza una inspección en busca de una cadena de ataque XSS en la parte correspondiente de la solicitud. Para obtener más información, consulte Grupo de reglas administradas del conjunto de reglas principales (CRS).

Del mismo modo, el grupo de reglas AWSManagedRulesSQLiRuleSet contiene reglas para inspeccionar los parámetros de la consulta, el cuerpo y una cookie en busca de un patrón de ataque de inyección de código SQLi. Para obtener más información, consulte Grupos de reglas específicas para cada caso de uso.

Cuando una solicitud coincide con las reglas anteriores, AWS WAF genera las etiquetas correspondientes. Las etiquetas se utilizan en la regla definida posteriormente en la lista de control de acceso (ACL) web para excluir selectivamente solicitudes específicas (según el URI, en este ejemplo).

Para permitir URI específicos, siga los siguientes pasos:

1.    Mantenga las siguientes reglas del grupo de reglas AWSManagedRulesCommonRuleSet en modo de recuento:

• CrossSiteScripting_COOKIE
• CrossSiteScripting_QUERYARGUMENTS
• CrossSiteScripting_BODY
• CrossSiteScripting_URIPATH

2.    Cree una regla de permiso (allow) configurada con una prioridad inferior a la de AWSManagedRulesCommonRuleSet.

La lógica de la regla es la siguiente:

(XSS_URIPATH o XSS_Cookie o XSS_Body o XSS_QueryArguments) Y (URIString no incluida en la lista blanca) = BLOCK

Utilice la siguiente configuración:

{
  "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"
  }
}

Siga los pasos anteriores en el caso de AWSManagedRulesSQLiRuleSet al sustituir las etiquetas por las que genera AWSManagedRulesSQLiRuleSet.

Caso 2: uso de reglas XSS y SQLi personalizadas

La lógica de la regla es la siguiente:

(XSS_URIPATH o XSS_Cookie o XSS_Body o XSS_QueryArguments) Y (URIString no incluida en la lista blanca) = BLOCK

Utilice la siguiente configuración para que la regla inspeccione las cadenas de ataque XSS para la solicitud mientras excluye selectivamente una URI_PATH específica:

{
  "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
                  }
                ]
              }
            }
          }
        }
      ]
    }
  }
}

Siga el procedimiento anterior al utilizar las instrucciones SQLi.

Nota: No es una práctica recomendada tener una regla con mayor prioridad que permita únicamente el URI. Esta acción no permite que la solicitud con la URI_PATH permitida sea evaluada con respecto a todas las demás reglas definidas en la lista de control de acceso (ACL) web.

---

Información relacionada

Instrucciones de reglas de AWS WAF

Instrucción de la regla de ataque por secuencias de comandos entre sitios

Instrucción de la regla de ataque de inyección de código SQL