**Présentation d'une nouvelle expérience de console pour AWS WAF**
Vous pouvez désormais utiliser l'expérience mise à jour pour accéder aux AWS WAF fonctionnalités n'importe où dans la console. Pour plus de détails, consultez la section [Utilisation de la console](https://docs.aws.amazon.com/waf/latest/developerguide/working-with-console.html).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# AWS WAF règles
Cette section explique ce qu'est une AWS WAF règle et comment elle fonctionne.
Une AWS WAF règle définit comment inspecter les requêtes Web HTTP (S) et les mesures à prendre pour traiter une demande lorsqu'elle répond aux critères d'inspection. Vous définissez des règles uniquement dans le contexte d'un groupe de règles ou d'un pack de protection (ACL Web).
Les règles n'existent pas AWS WAF en elles-mêmes. Ce ne sont pas AWS des ressources, et elles n'ont pas de noms de ressources Amazon (ARNs). Vous pouvez accéder à une règle par son nom dans le groupe de règles ou le pack de protection (ACL Web) dans lequel elle est définie. Vous pouvez gérer les règles et les copier dans d'autres packs de protection (Web ACLs) à l'aide de la vue JSON du groupe de règles ou du pack de protection (ACL Web) qui contient la règle. Vous pouvez également les gérer via le générateur de règles de AWS WAF console, disponible pour les packs de protection (Web ACLs) et les groupes de règles.
**Nom de la règle**
Chaque règle nécessite un nom. Évitez les noms commençant par `AWS` et ceux utilisés pour les groupes de règles ou les règles gérées pour vous par d'autres services. Consultez [Reconnaissance des groupes de règles fournis par d'autres services](waf-service-owned-rule-groups.md).
**Note**
Si vous modifiez le nom d'une règle et que vous souhaitez que le nom de la métrique de la règle reflète le changement, vous devez également mettre à jour le nom de la métrique. AWS WAF ne met pas automatiquement à jour le nom de la métrique d'une règle lorsque vous modifiez le nom de la règle. Vous pouvez modifier le nom de la métrique lorsque vous modifiez la règle dans la console, à l'aide de l'éditeur JSON de règles. Vous pouvez également modifier les deux noms via APIs et dans toute liste JSON que vous utilisez pour définir votre pack de protection (ACL Web) ou votre groupe de règles.
**Déclaration de règle**
Chaque règle nécessite également une déclaration de règle qui définit la manière dont la règle inspecte les requêtes Web. L'instruction de règle peut contenir d'autres instructions imbriquées à n'importe quelle profondeur, selon la règle et le type d'instruction. Certains énoncés de règles utilisent des ensembles de critères. Par exemple, vous pouvez spécifier jusqu'à 10 000 adresses IP ou plages d'adresses IP pour une règle de correspondance des ensembles d'adresses IP.
Vous pouvez définir des règles qui vérifient les critères suivants :
+ Les scripts qui sont susceptibles d'être malveillants. Les pirates intègrent des scripts qui peuvent exploiter les vulnérabilités des applications web. Il s'agit de scripts inter-sites.
+ Les adresses IP ou les plages d'adresses IP d'où proviennent les requêtes.
+ Pays ou emplacement géographique d'où proviennent les demandes.
+ Longueur d'une partie spécifiée de la demande, telle que la chaîne de requête.
+ Le code SQL susceptible d'être malveillants. Les pirates essaient d'extraire les données de votre base de données en intégrant un code SQL malveillant dans une requête web. Cette opération s'appelle injection SQL.
+ Les chaînes qui apparaissent dans la requête, par exemple, les valeurs qui apparaissent dans l'en-tête `User-Agent` ou les chaînes de texte qui apparaissent dans la chaîne de requête. Vous pouvez également utiliser des expressions régulières (regex) pour spécifier ces chaînes.
+ Étiquettes que les règles précédentes du pack de protection (ACL Web) ont ajoutées à la demande.
Outre les instructions comportant des critères d'inspection des requêtes Web, comme ceux de la liste précédente, prennent AWS WAF en charge les instructions logiques pour `AND``OR`, et `NOT` que vous pouvez utiliser pour combiner des instructions dans une règle.
Par exemple, sur la base des demandes récentes que vous avez reçues d'un attaquant, vous pouvez créer une règle avec une `AND` instruction logique qui combine les instructions imbriquées suivantes :
+ Les requêtes proviennent de 192.0.2.44.
+ Elles contiennent la valeur `BadBot` dans l'en-tête `User-Agent`.
+ Elles semblent inclure du code de type SQL dans la chaîne de requête.
Dans ce cas, la requête Web doit correspondre à toutes les instructions pour obtenir une correspondance pour le niveau supérieur`AND`.
**Topics**
+ [Utilisation des actions liées aux règles dans AWS WAF](waf-rule-action.md)
+ [Utilisation d'instructions de règle dans AWS WAF](waf-rule-statements.md)
+ [Utilisation des instructions de règles de correspondance dans AWS WAF](waf-rule-statements-match.md)
+ [Utilisation d'instructions de règles logiques dans AWS WAF](waf-rule-statements-logical.md)
+ [Utilisation d'instructions de règles basées sur le taux dans AWS WAF](waf-rule-statement-type-rate-based.md)
+ [Utilisation des déclarations de règles relatives aux groupes de règles dans AWS WAF](waf-rule-statements-rule-group.md)
# Utilisation des actions liées aux règles dans AWS WAF
Cette section explique le fonctionnement des actions relatives aux règles.
L'action de règle indique AWS WAF ce qu'il faut faire avec une requête Web lorsqu'elle correspond aux critères définis dans la règle. Vous pouvez éventuellement ajouter un comportement personnalisé à chaque action de règle.
**Note**
Les actions relatives aux règles peuvent être terminales ou non. Une action d'arrêt arrête l'évaluation de la demande par le pack de protection (ACL Web) et la laisse continuer vers votre application protégée ou la bloque.
Voici les options d'action de la règle :
+ **Allow**— AWS WAF permet à la demande d'être transmise à la AWS ressource protégée pour traitement et réponse. Il s'agit d'une action terminale. Dans les règles que vous définissez, vous pouvez insérer des en-têtes personnalisés dans la demande avant de la transmettre à la ressource protégée.
+ **Block**— AWS WAF bloque la demande. Il s'agit d'une action terminale. Par défaut, votre AWS ressource protégée répond par un code d'`403 (Forbidden)`état HTTP. Dans les règles que vous définissez, vous pouvez personnaliser la réponse. En cas de AWS WAF blocage d'une demande, les paramètres Block d'action déterminent la réponse que la ressource protégée renvoie au client.
+ **Count**— AWS WAF compte la demande mais ne détermine pas s'il faut l'autoriser ou la bloquer. Il s'agit d'une action sans fin. AWS WAF poursuit le traitement des règles restantes du pack de protection (ACL Web). Dans les règles que vous définissez, vous pouvez insérer des en-têtes personnalisés dans la demande et ajouter des libellés auxquels d'autres règles peuvent correspondre.
+ **CAPTCHAet Challenge** — AWS WAF utilise des puzzles CAPTCHA et des défis silencieux pour vérifier que la demande ne provient pas d'un bot, et AWS WAF utilise des jetons pour suivre les récentes réponses positives des clients.
Les puzzles CAPTCHA et les défis silencieux ne peuvent être exécutés que lorsque les navigateurs accèdent à des points de terminaison HTTPS. Les clients du navigateur doivent fonctionner dans des contextes sécurisés pour acquérir des jetons.
**Note**
Des frais supplémentaires vous sont facturés lorsque vous utilisez l'action CAPTCHA ou la Challenge règle dans l'une de vos règles ou en tant que dérogation d'action de règle dans un groupe de règles. Pour plus d’informations, consultez [Tarification d’AWS WAF](https://aws.amazon.com/waf/pricing/).
Ces actions de règles peuvent être terminales ou non, selon l'état du jeton dans la demande :
+ **Non résiliable pour un jeton valide et non expiré : si le jeton** est valide et non expiré conformément au CAPTCHA configuré ou à la durée d'immunité au défi, AWS WAF gère la demande de la même manière que l'action. Count AWS WAF continue d'inspecter la requête Web en fonction des règles restantes du pack de protection (ACL Web). Comme pour la Count configuration, dans les règles que vous définissez, vous pouvez éventuellement configurer ces actions avec des en-têtes personnalisés à insérer dans la demande, et vous pouvez ajouter des étiquettes auxquelles d'autres règles peuvent correspondre.
+ **Terminer par une demande bloquée pour un jeton non valide ou expiré** — Si le jeton n'est pas valide ou si l'horodatage indiqué est expiré, AWS WAF met fin à l'inspection de la requête Web et bloque la demande, comme dans le cas de l'action. Block AWS WAF répond ensuite au client avec un code de réponse personnalisé. En CAPTCHA effet, si le contenu de la demande indique que le navigateur client peut la gérer, AWS WAF envoie un casse-tête CAPTCHA dans un JavaScript interstitiel, conçu pour distinguer les clients humains des robots. Pour l'Challengeaction, AWS WAF envoie un JavaScript interstitiel avec un défi silencieux conçu pour distinguer les navigateurs normaux des sessions exécutées par des robots.
Pour plus d’informations, consultez [CAPTCHAet Challenge dans AWS WAF](waf-captcha-and-challenge.md).
Pour plus d'informations sur la personnalisation des demandes et des réponses, consultez[Demandes et réponses Web personnalisées dans AWS WAF](waf-custom-request-response.md).
Pour plus d'informations sur l'ajout d'étiquettes aux demandes correspondantes, consultez[Étiquetage des requêtes Web dans AWS WAF](waf-labels.md).
Pour plus d'informations sur la façon dont le pack de protection (ACL Web) et les paramètres des règles interagissent, consultez[Utilisation de packs de protection (Web ACLs) avec des règles et des groupes de règles dans AWS WAF](web-acl-processing.md).
# Utilisation d'instructions de règle dans AWS WAF
Cette section explique le fonctionnement des instructions de règles.
Les instructions de règle font partie d'une règle qui indique AWS WAF comment inspecter une requête Web. Lorsque AWS WAF les critères d'inspection sont trouvés dans une requête Web, nous disons que la requête Web correspond à la déclaration. Chaque instruction de règle spécifie ce qu'il faut rechercher et comment, selon le type d'instruction.
Chaque règle AWS WAF contient une seule instruction de règle de niveau supérieur, qui peut contenir d'autres instructions. Les déclarations de règle peuvent être très simples. Par exemple, vous pouvez avoir une instruction fournissant un ensemble de pays d'origine pour lesquels inspecter vos requêtes Web ou vous pouvez avoir une déclaration de règle dans un pack de protection (ACL Web) qui fait simplement référence à un groupe de règles. Les instructions de règle peuvent également être très complexes. Par exemple, vous pouvez avoir une instruction qui combine de nombreuses autres instructions avec des NOT instructions logiques ANDOR, et.
Pour la plupart des règles, vous pouvez ajouter un AWS WAF étiquetage personnalisé aux demandes correspondantes. Les règles des groupes de règles AWS gérées ajoutent des étiquettes aux demandes correspondantes. Les étiquettes ajoutées par une règle fournissent des informations sur la demande aux règles qui sont évaluées ultérieurement dans le pack de protection (ACL Web) ainsi que dans AWS WAF les journaux et les métriques. Pour plus d'informations sur l'étiquetage, reportez-vous [Étiquetage des requêtes Web dans AWS WAF](waf-labels.md) aux sections et[Déclaration relative à la règle de correspondance des étiquettes](waf-rule-statement-type-label-match.md).
**Instructions de règles d'imbrication**
AWS WAF prend en charge l'imbrication pour de nombreuses instructions de règles, mais pas pour toutes. Par exemple, vous ne pouvez pas imbriquer une instruction de groupe de règles dans une autre instruction. Vous devez utiliser l'imbrication pour certains scénarios, tels que les instructions scope-down et les instructions logiques. Les instructions de règles et les détails des règles qui suivent décrivent les capacités d'imbrication et les exigences pour chaque catégorie et règle.
L'éditeur visuel des règles de la console ne prend en charge qu'un seul niveau d'imbrication pour les instructions de règles. Par exemple, vous pouvez imbriquer de nombreux types d'instructions dans une logique AND ou une OR règle, mais vous ne pouvez pas en imbriquer une autreAND, car cela nécessite un deuxième niveau d'imbrication. OR Pour implémenter plusieurs niveaux d'imbrication, fournissez la définition de la règle au format JSON, soit par le biais de l'éditeur de règles JSON de la console, soit par le biais duAPIs.
**Topics**
+ [Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md)
+ [Utilisation d'instructions scope-down dans AWS WAF](waf-rule-scope-down-statements.md)
+ [Référencement d'entités réutilisables dans AWS WAF](waf-rule-statement-reusable-entities.md)
# Réglage des paramètres des instructions de règle dans AWS WAF
Cette section décrit les paramètres que vous pouvez spécifier dans les instructions de règle qui inspectent un composant de la requête Web. Pour plus d'informations sur l'utilisation, consultez les instructions de règles individuelles à l'adresse[Utilisation des instructions de règles de correspondance dans AWS WAF](waf-rule-statements-match.md).
Un sous-ensemble de ces composants de requête Web peut également être utilisé dans des règles basées sur le taux, sous forme de clés d'agrégation de demandes personnalisées. Pour plus d'informations, consultez [Agrégation des règles basées sur les taux dans AWS WAF](waf-rule-statement-type-rate-based-aggregation-options.md).
Pour les paramètres du composant de demande, vous spécifiez le type de composant lui-même, ainsi que toutes les options supplémentaires, en fonction du type de composant. Par exemple, lorsque vous inspectez un type de composant contenant du texte, vous pouvez lui appliquer des transformations de texte avant de l'inspecter.
**Note**
Sauf indication contraire, si une requête Web ne possède pas le composant de demande spécifié dans l'instruction de règle, la demande est AWS WAF évaluée comme ne correspondant pas aux critères de la règle.
**Contents**
+ [Demandez des composants dans AWS WAF](waf-rule-statement-fields-list.md)
+ [Méthode HTTP](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-http-method)
+ [En-tête seul](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-single-header)
+ [Tous les en-têtes](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-headers)
+ [Ordre des en-têtes](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-header-order)
+ [Cookies](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-cookies)
+ [fragment d'URI](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-uri-fragment)
+ [chemin de l'URI](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-uri-path)
+ [JA3 empreinte digitale](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-ja3-fingerprint)
+ [JA4 empreinte digitale](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-ja4-fingerprint)
+ [Chaîne de requête](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-query-string)
+ [Paramètre de requête unique](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-single-query-param)
+ [Tous les paramètres de requête](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-all-query-params)
+ [Corps de texte](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-body)
+ [corps JSON](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-json-body)
+ [Utilisation des adresses IP transférées dans AWS WAF](waf-rule-statement-forwarded-ip-address.md)
+ [Inspection des pseudo-en-têtes HTTP/2 dans AWS WAF](waf-rule-statement-request-components-for-http2-pseudo-headers.md)
+ [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md)
# Demandez des composants dans AWS WAF
Cette section décrit les composants de la requête Web que vous pouvez spécifier pour inspection. Vous spécifiez le composant de demande pour les instructions de règle de correspondance qui recherchent des modèles dans la requête Web. Ces types d'instructions incluent les instructions de correspondance de chaîne, de correspondance régulière, de contrainte de taille et d'attaque par injection SQL. Pour plus d'informations sur l'utilisation de ces paramètres de composant de requête, consultez les instructions de règle individuelles à l'adresse [Utilisation des instructions de règles de correspondance dans AWS WAF](waf-rule-statements-match.md)
Sauf indication contraire, si une requête Web ne possède pas le composant de demande spécifié dans l'instruction de règle, la demande est AWS WAF évaluée comme ne correspondant pas aux critères de la règle.
**Note**
Vous spécifiez un composant de demande unique pour chaque instruction de règle qui le requiert. Pour inspecter plusieurs composants d'une demande, créez une instruction de règle pour chacun d'eux.
La documentation de la AWS WAF console et de l'API fournit des conseils sur les paramètres des composants de demande aux emplacements suivants :
+ **Générateur de règles** sur la console : dans les paramètres de **déclaration** pour un type de règle normal, choisissez le composant que vous souhaitez inspecter dans la boîte de dialogue **Inspecter** sous **Composants de demande**.
+ **Contenu de la déclaration d'API** — `FieldToMatch`
Le reste de cette section décrit les options relatives à la partie de la requête Web à inspecter.
**Topics**
+ [Méthode HTTP](#waf-rule-statement-request-component-http-method)
+ [En-tête seul](#waf-rule-statement-request-component-single-header)
+ [Tous les en-têtes](#waf-rule-statement-request-component-headers)
+ [Ordre des en-têtes](#waf-rule-statement-request-component-header-order)
+ [Cookies](#waf-rule-statement-request-component-cookies)
+ [fragment d'URI](#waf-rule-statement-request-component-uri-fragment)
+ [chemin de l'URI](#waf-rule-statement-request-component-uri-path)
+ [JA3 empreinte digitale](#waf-rule-statement-request-component-ja3-fingerprint)
+ [JA4 empreinte digitale](#waf-rule-statement-request-component-ja4-fingerprint)
+ [Chaîne de requête](#waf-rule-statement-request-component-query-string)
+ [Paramètre de requête unique](#waf-rule-statement-request-component-single-query-param)
+ [Tous les paramètres de requête](#waf-rule-statement-request-component-all-query-params)
+ [Corps de texte](#waf-rule-statement-request-component-body)
+ [corps JSON](#waf-rule-statement-request-component-json-body)
## Méthode HTTP
Inspecte la méthode HTTP pour la demande. La méthode HTTP indique le type d'opération que la requête Web demande à votre ressource protégée d'effectuer, telle que `POST` ou`GET`.
## En-tête seul
Inspecte un seul en-tête nommé dans la demande.
Pour cette option, vous spécifiez le nom de l'en-tête, par exemple, `User-Agent` ou`Referer`. La correspondance de chaîne pour le nom ne fait pas la distinction majuscules/minuscules et est effectuée après avoir supprimé les espaces de début et de fin de l'en-tête de la demande et de la règle.
## Tous les en-têtes
Inspecte tous les en-têtes de demande, y compris les cookies. Vous pouvez appliquer un filtre pour inspecter un sous-ensemble de tous les en-têtes.
Pour cette option, vous devez fournir les spécifications suivantes :
+ **Modèles de correspondance** : filtre à utiliser pour obtenir un sous-ensemble d'en-têtes à inspecter. AWS WAF recherche ces modèles dans les touches d'en-tête.
Le paramètre des modèles de correspondance peut être l'un des suivants :
+ **Toutes** — Faites correspondre toutes les clés. Évaluez les critères d'inspection des règles pour tous les en-têtes.
+ **En-têtes exclus** : inspectez uniquement les en-têtes dont les clés ne correspondent à aucune des chaînes que vous spécifiez ici. La correspondance de chaîne pour une clé ne fait pas la distinction majuscules/minuscules. La correspondance est effectuée après avoir découpé les espaces de début et de fin de l'en-tête de la demande et de la règle de correspondance.
+ **En-têtes inclus** : inspectez uniquement les en-têtes dont la clé correspond à l'une des chaînes que vous spécifiez ici. La correspondance de chaîne pour une clé ne fait pas la distinction majuscules/minuscules. La correspondance est effectuée après avoir découpé les espaces de début et de fin de l'en-tête de la demande et de la règle de correspondance.
+ **Champ d'application du match** : parties des en-têtes qui AWS WAF doivent être inspectées selon les critères d'inspection des règles. Vous pouvez spécifier **des clés**, **des valeurs** ou **tout** pour inspecter à la fois les clés et les valeurs pour détecter une correspondance.
**Tout** ne nécessite pas qu'une correspondance soit trouvée dans les clés et qu'une correspondance soit trouvée dans les valeurs. Cela nécessite qu'une correspondance soit trouvée dans les clés ou les valeurs, ou dans les deux. Pour exiger une correspondance entre les clés et les valeurs, utilisez une `AND` instruction logique pour combiner deux règles de correspondance, l'une inspectant les clés et l'autre les valeurs.
+ **Gestion des données surdimensionnées** — AWS WAF Comment gérer les demandes dont les données d'en-tête sont supérieures à ce que AWS WAF vous pouvez inspecter ? AWS WAF peut inspecter au maximum les 8 premiers Ko (8 192 octets) des en-têtes de requête et au plus les 200 premiers en-têtes. Le contenu peut être consulté AWS WAF jusqu'à la première limite atteinte. Vous pouvez choisir de poursuivre l'inspection ou de sauter l'inspection et de marquer la demande comme correspondant ou non à la règle. Pour plus d'informations sur la gestion du contenu surdimensionné, consultez[Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md).
## Ordre des en-têtes
Inspectez une chaîne contenant la liste des noms d'en-tête de la demande, classés tels qu'ils apparaissent dans la demande Web qui est AWS WAF reçue pour inspection. AWS WAF génère la chaîne, puis l'utilise comme champ pour faire correspondre le composant lors de son inspection. AWS WAF sépare les noms des en-têtes dans la chaîne par des deux-points et sans espaces ajoutés, par exemple`host:user-agent:accept:authorization:referer`.
Pour cette option, vous devez fournir les spécifications suivantes :
+ **Gestion des données surdimensionnées** — Comment AWS WAF gérer les demandes dont les données d'en-tête sont plus nombreuses ou plus volumineuses que celles que l' AWS WAF on peut inspecter ? AWS WAF peut inspecter au maximum les 8 premiers Ko (8 192 octets) des en-têtes de requête et au plus les 200 premiers en-têtes. Le contenu peut être consulté AWS WAF jusqu'à la première limite atteinte. Vous pouvez choisir de continuer à inspecter les en-têtes disponibles ou d'ignorer l'inspection et de marquer la demande comme correspondant ou non à la règle. Pour plus d'informations sur la gestion du contenu surdimensionné, consultez[Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md).
## Cookies
Inspecte tous les cookies de demande. Vous pouvez appliquer un filtre pour inspecter un sous-ensemble de tous les cookies.
Pour cette option, vous devez fournir les spécifications suivantes :
+ **Modèles de correspondance** : filtre à utiliser pour obtenir un sous-ensemble de cookies à inspecter. AWS WAF recherche ces modèles dans les clés des cookies.
Le paramètre des modèles de correspondance peut être l'un des suivants :
+ **Toutes** — Faites correspondre toutes les clés. Évaluez les critères d'inspection des règles pour tous les cookies.
+ **Cookies exclus** : inspectez uniquement les cookies dont les clés ne correspondent à aucune des chaînes que vous spécifiez ici. La correspondance de chaîne pour une clé distingue les majuscules et minuscules et doit être exacte.
+ **Cookies inclus** : inspectez uniquement les cookies dont la clé correspond à l'une des chaînes que vous spécifiez ici. La correspondance de chaîne pour une clé distingue les majuscules et minuscules et doit être exacte.
+ **Champ d'application du match** : parties des cookies qui AWS WAF doivent être inspectées selon les critères d'inspection des règles. Vous pouvez spécifier **des clés**, **des valeurs** ou **tout pour les** clés et les valeurs.
**Tout** ne nécessite pas qu'une correspondance soit trouvée dans les clés et qu'une correspondance soit trouvée dans les valeurs. Cela nécessite qu'une correspondance soit trouvée dans les clés ou les valeurs, ou dans les deux. Pour exiger une correspondance entre les clés et les valeurs, utilisez une `AND` instruction logique pour combiner deux règles de correspondance, l'une inspectant les clés et l'autre les valeurs.
+ **Gestion des données surdimensionnées** — Comment AWS WAF gérer les demandes dont les données de cookies sont trop volumineuses pour AWS WAF être inspectées ? AWS WAF peut inspecter au maximum les 8 premiers Ko (8 192 octets) des cookies de demande et au plus les 200 premiers cookies. Le contenu peut être consulté AWS WAF jusqu'à la première limite atteinte. Vous pouvez choisir de poursuivre l'inspection ou de sauter l'inspection et de marquer la demande comme correspondant ou non à la règle. Pour plus d'informations sur la gestion du contenu surdimensionné, consultez[Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md).
## fragment d'URI
**Note**
L'inspection des fragments d'URI n'est disponible que pour les CloudFront distributions et les équilibreurs de charge d'application.
Inspecte la partie d'une URL qui suit le symbole « \$1 », fournissant des informations supplémentaires sur la ressource, par exemple, \$1section2. Pour plus d'informations, voir [Uniform Resource Identifier (URI) : syntaxe générique](https://tools.ietf.org/html/rfc3986#section-3).
Si vous n'utilisez pas de transformation de texte avec cette option, elle AWS WAF ne normalise pas le fragment d'URI et ne l'inspecte pas exactement tel qu'il le reçoit du client dans la demande. Pour plus d'informations sur les transformations de texte, consultez[Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
**Exigences relatives à l'énoncé des règles**
Vous devez fournir un comportement de remplacement pour cette déclaration de règle. Le comportement de remplacement est le statut de correspondance que vous souhaitez attribuer AWS WAF à la requête Web si l'URI manque le fragment ou si le service associé n'est pas Application Load CloudFront Balancer ou. Si vous choisissez de faire correspondre, AWS WAF traite la demande comme correspondant à l'instruction de règle et applique l'action de règle à la demande. Si vous choisissez de ne pas correspondre, AWS WAF traite la demande comme ne correspondant pas à l'instruction de règle.
## chemin de l'URI
Inspecte la partie d'une URL qui identifie une ressource, par exemple,`/images/daily-ad.jpg`. Pour plus d'informations, voir [Uniform Resource Identifier (URI) : syntaxe générique](https://tools.ietf.org/html/rfc3986#section-3).
Si vous n'utilisez pas de transformation de texte avec cette option, elle AWS WAF ne normalise pas l'URI et ne l'inspecte pas exactement telle qu'elle est reçue du client dans la demande. Pour plus d'informations sur les transformations de texte, consultez[Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
## JA3 empreinte digitale
Inspecte l' JA3 empreinte digitale de la demande.
**Note**
JA3 l'inspection des empreintes digitales n'est disponible que pour les CloudFront distributions Amazon et les équilibreurs de charge d'application.
L' JA3 empreinte digitale est un hachage de 32 caractères dérivé du client TLS Hello d'une demande entrante. Cette empreinte sert d'identifiant unique pour la configuration TLS du client. AWS WAF calcule et enregistre cette empreinte pour chaque demande contenant suffisamment d'informations TLS Client Hello pour le calcul. Presque toutes les demandes sur le Web incluent ces informations.
**Comment obtenir l' JA3 empreinte digitale d'un client**
Vous pouvez obtenir l' JA3 empreinte digitale des demandes d'un client à partir des journaux du pack de protection (ACL Web). S'il AWS WAF est capable de calculer l'empreinte digitale, il l'inclut dans les journaux. Pour plus d'informations sur les champs de journalisation, consultez[Champs de journal pour le trafic du pack de protection (ACL Web)](logging-fields.md).
**Exigences relatives à l'énoncé des règles**
Vous ne pouvez inspecter l' JA3 empreinte digitale que dans une instruction de correspondance de chaîne définie pour correspondre exactement à la chaîne que vous fournissez. Fournissez la chaîne JA3 d'empreinte issue des journaux dans votre spécification d'instruction de correspondance de chaîne, afin qu'elle corresponde à toute future demande ayant la même configuration TLS. Pour plus d'informations sur l'instruction de correspondance des chaînes, consultez[Instruction de correspondance de chaîne de règle](waf-rule-statement-type-string-match.md).
Vous devez fournir un comportement de remplacement pour cette déclaration de règle. Le comportement de remplacement est le statut de correspondance que vous souhaitez attribuer AWS WAF à la requête Web si AWS WAF vous ne parvenez pas à calculer l' JA3 empreinte digitale. Si vous choisissez de faire correspondre, AWS WAF traite la demande comme correspondant à l'instruction de règle et applique l'action de règle à la demande. Si vous choisissez de ne pas correspondre, AWS WAF traite la demande comme ne correspondant pas à l'instruction de règle.
Pour utiliser cette option de correspondance, vous devez enregistrer le trafic de votre pack de protection (ACL Web). Pour plus d'informations, consultez [Trafic du pack de AWS WAF protection de journalisation (ACL Web)](logging.md).
## JA4 empreinte digitale
Inspecte l' JA4 empreinte digitale de la demande.
**Note**
JA4 l'inspection des empreintes digitales n'est disponible que pour les CloudFront distributions Amazon et les équilibreurs de charge d'application.
L' JA4 empreinte digitale est un hachage de 36 caractères dérivé du client TLS Hello d'une demande entrante. Cette empreinte sert d'identifiant unique pour la configuration TLS du client. JA4 l'empreinte digitale est une extension de l' JA3 empreinte digitale qui peut réduire le nombre d'empreintes uniques pour certains navigateurs. AWS WAF calcule et enregistre cette empreinte pour chaque demande contenant suffisamment d'informations TLS Client Hello pour le calcul. Presque toutes les demandes sur le Web incluent ces informations.
**Comment obtenir l' JA4 empreinte digitale d'un client**
Vous pouvez obtenir l' JA4 empreinte digitale des demandes d'un client à partir des journaux du pack de protection (ACL Web). S'il AWS WAF est capable de calculer l'empreinte digitale, il l'inclut dans les journaux. Pour plus d'informations sur les champs de journalisation, consultez[Champs de journal pour le trafic du pack de protection (ACL Web)](logging-fields.md).
**Exigences relatives à l'énoncé des règles**
Vous ne pouvez inspecter l' JA4 empreinte digitale que dans une instruction de correspondance de chaîne définie pour correspondre exactement à la chaîne que vous fournissez. Fournissez la chaîne JA4 d'empreinte issue des journaux dans votre spécification d'instruction de correspondance de chaîne, afin qu'elle corresponde à toute future demande ayant la même configuration TLS. Pour plus d'informations sur l'instruction de correspondance des chaînes, consultez[Instruction de correspondance de chaîne de règle](waf-rule-statement-type-string-match.md).
Vous devez fournir un comportement de remplacement pour cette déclaration de règle. Le comportement de remplacement est le statut de correspondance que vous souhaitez attribuer AWS WAF à la requête Web si AWS WAF vous ne parvenez pas à calculer l' JA4 empreinte digitale. Si vous choisissez de faire correspondre, AWS WAF traite la demande comme correspondant à l'instruction de règle et applique l'action de règle à la demande. Si vous choisissez de ne pas correspondre, AWS WAF traite la demande comme ne correspondant pas à l'instruction de règle.
Pour utiliser cette option de correspondance, vous devez enregistrer le trafic de votre pack de protection (ACL Web). Pour plus d'informations, consultez [Trafic du pack de AWS WAF protection de journalisation (ACL Web)](logging.md).
## Chaîne de requête
Inspecte la partie de l'URL qui apparaît après un `?` caractère, le cas échéant.
**Note**
Pour les instructions de correspondance basées sur des scripts intersites, nous vous recommandons de choisir **Tous les paramètres de requête** au lieu de Chaîne de **requête**. La sélection de **tous les paramètres de requête** ajoute 10 % WCUs au coût de base.
## Paramètre de requête unique
Inspecte un seul paramètre de requête que vous avez défini dans le cadre de la chaîne de requête. AWS WAF inspecte la valeur du paramètre que vous spécifiez.
Pour cette option, vous devez également spécifier un **argument de requête**. Par exemple, si l'URL est`www.xyz.com?UserName=abc&SalesRegion=seattle`, vous pouvez spécifier `UserName` ou `SalesRegion` pour l'argument de requête. La longueur maximale du nom de l'argument est de 30 caractères. Le nom ne distingue pas les majuscules et minuscules. Ainsi, si vous le spécifiez`UserName`, il AWS WAF correspond à toutes les variantes de`UserName`, y compris `username` et`UsERName`.
Si la chaîne de requête contient plusieurs instances de l'argument de requête que vous avez spécifié, AWS WAF examine toutes les valeurs pour détecter une correspondance, en utilisant la OR logique. Par exemple, dans l'URL `www.xyz.com?SalesRegion=boston&SalesRegion=seattle`, AWS WAF évalue le nom que vous avez spécifié par rapport à `boston` et `seattle`. Si l'un ou l'autre est une correspondance, l'inspection est une correspondance.
## Tous les paramètres de requête
Inspecte tous les paramètres de requête contenus dans la demande. Cela est similaire au choix d'un composant de requête unique, mais AWS WAF inspecte les valeurs de tous les arguments de la chaîne de requête. Par exemple, si l'URL est `www.xyz.com?UserName=abc&SalesRegion=seattle`, AWS WAF déclenche une correspondance si la valeur de `UserName` ou `SalesRegion` correspond aux critères d'inspection.
Le choix de cette option ajoute 10 WCUs \$1 au coût de base.
## Corps de texte
Inspecte le corps de la demande, évalué sous forme de texte brut. Vous pouvez également évaluer le corps au format JSON à l'aide du type de JSON contenu.
Le corps de la demande est la partie de la demande qui suit immédiatement les en-têtes de la demande. Il contient toutes les données supplémentaires nécessaires à la requête Web, par exemple les données d'un formulaire.
+ Dans la console, sélectionnez cette option dans le **corps** de l'**option de demande**, en sélectionnant le **type de contenu** **Texte brut**.
+ Dans l'API, dans la `FieldToMatch` spécification de la règle, vous spécifiez `Body` d'inspecter le corps de la demande sous forme de texte brut.
Pour Application Load Balancer et AWS AppSync, AWS WAF peut inspecter les 8 premiers Ko du corps d'une requête. Par défaut CloudFront, API Gateway, Amazon Cognito, App Runner et Verified Access AWS WAF peuvent inspecter les 16 premiers Ko, et vous pouvez augmenter la limite jusqu'à 64 Ko dans la configuration de votre pack de protection (ACL Web). Pour de plus amples informations, veuillez consulter [Considérations relatives à la gestion de l'inspection corporelle dans AWS WAF](web-acl-setting-body-inspection-limit.md).
Vous devez spécifier la gestion des surdimensionnements pour ce type de composant. La gestion des données surdimensionnées définit le AWS WAF mode de traitement des demandes dont les données corporelles sont trop volumineuses pour AWS WAF être inspectées. Vous pouvez choisir de poursuivre l'inspection ou de sauter l'inspection et de marquer la demande comme correspondant ou non à la règle. Pour plus d'informations sur la gestion du contenu surdimensionné, consultez[Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md).
Vous pouvez également évaluer le corps sous forme de JSON analysé. Pour plus d'informations à ce sujet, consultez la section qui suit.
## corps JSON
Inspecte le corps de la demande, évalué au format JSON. Vous pouvez également évaluer le corps sous forme de texte brut.
Le corps de la demande est la partie de la demande qui suit immédiatement les en-têtes de la demande. Il contient toutes les données supplémentaires nécessaires à la requête Web, par exemple les données d'un formulaire.
+ Dans la console, vous pouvez le sélectionner dans le choix de l'**option de demande** **Body**, en sélectionnant le choix du **type de contenu** **JSON**.
+ Dans l'API, dans la `FieldToMatch` spécification de la règle, vous spécifiez`JsonBody`.
Pour Application Load Balancer et AWS AppSync, AWS WAF peut inspecter les 8 premiers Ko du corps d'une requête. Par défaut CloudFront, API Gateway, Amazon Cognito, App Runner et Verified Access AWS WAF peuvent inspecter les 16 premiers Ko, et vous pouvez augmenter la limite jusqu'à 64 Ko dans la configuration de votre pack de protection (ACL Web). Pour de plus amples informations, veuillez consulter [Considérations relatives à la gestion de l'inspection corporelle dans AWS WAF](web-acl-setting-body-inspection-limit.md).
Vous devez spécifier la gestion des surdimensionnements pour ce type de composant. La gestion des données surdimensionnées définit le AWS WAF mode de traitement des demandes dont les données corporelles sont trop volumineuses pour AWS WAF être inspectées. Vous pouvez choisir de poursuivre l'inspection ou de sauter l'inspection et de marquer la demande comme correspondant ou non à la règle. Pour plus d'informations sur la gestion du contenu surdimensionné, consultez[Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md).
Le choix de cette option double le coût de base du relevé de match WCUs. Par exemple, si le coût de base de l'instruction match est de 5 WCUs sans analyse JSON, l'utilisation de l'analyse JSON double le coût à 10. WCUs
Pour cette option, vous devez fournir des spécifications supplémentaires, comme décrit dans la section suivante.
**Comment AWS WAF gère l'inspection du corps JSON**
Lorsqu'il AWS WAF inspecte le corps de la requête Web au format JSON, il exécute des étapes pour analyser le corps et extraire les éléments JSON à des fins d'inspection. AWS WAF exécute ces étapes conformément à vos choix de configuration.
La liste suivante répertorie les étapes qui s' AWS WAF exécutent.
1. **Analyse le contenu du corps : AWS WAF analyse le contenu** du corps de la requête Web afin d'extraire les éléments JSON à des fins d'inspection. AWS WAF fait de son mieux pour analyser l'intégralité du contenu du corps, mais l'analyse peut échouer en raison de divers états d'erreur dans le contenu. Les exemples incluent les caractères non valides, les clés dupliquées, la troncature et le contenu dont le nœud racine n'est pas un objet ou un tableau.
L'option **Body parsing fallback behavior** détermine ce qui se passe si elle AWS WAF ne parvient pas à analyser complètement le corps JSON :
+ **Aucun (comportement par défaut)** : AWS WAF évalue le contenu uniquement jusqu'au point où il a rencontré une erreur d'analyse.
+ **Evaluer en tant que chaîne** - Inspectez le corps en tant que texte brut. AWS WAF applique les transformations de texte et les critères d'inspection que vous avez définis pour l'inspection JSON à la chaîne du corps du texte.
+ **Match** : traitez la requête Web comme correspondant à l'instruction de règle. AWS WAF applique l'action de règle à la demande.
+ **Aucune correspondance** : considérez la requête Web comme ne correspondant pas à l'instruction de règle.
**Note**
Ce comportement de secours ne se déclenche qu'en cas d' AWS WAF erreur lors de l'analyse de la chaîne JSON.
**L'analyse ne valide pas complètement le JSON**
AWS WAF l'analyse ne valide pas complètement la chaîne JSON d'entrée, de sorte que l'analyse peut réussir même pour un JSON non valide.
Par exemple, AWS WAF analyse le code JSON non valide suivant sans erreur :
+ Virgule manquante : `{"key1":"value1""key2":"value2"}`
+ Deux-points manquant : `{"key1":"value1","key2""value2"}`
+ Deux-points supplémentaire : `{"key1"::"value1","key2""value2"}`
Dans de tels cas où l'analyse réussit mais où le résultat n'est pas un JSON complètement valide, le résultat des étapes suivantes de l'évaluation peut varier. L'extraction peut omettre certains éléments ou l'évaluation des règles peut avoir des résultats inattendus. Nous vous recommandons de valider le JSON que vous recevez dans votre application et de gérer le JSON non valide selon les besoins.
1. **Extraire les éléments JSON** : AWS WAF identifie le sous-ensemble d'éléments JSON à inspecter en fonction de vos paramètres :
+ L'option **JSON match scope** indique les types d'éléments du JSON qui AWS WAF doivent être inspectés.
Vous pouvez spécifier **des clés**, **des valeurs** ou **tout pour les** clés et les valeurs.
**Tout** ne nécessite pas qu'une correspondance soit trouvée dans les clés et qu'une correspondance soit trouvée dans les valeurs. Cela nécessite qu'une correspondance soit trouvée dans les clés ou les valeurs, ou dans les deux. Pour exiger une correspondance entre les clés et les valeurs, utilisez une `AND` instruction logique pour combiner deux règles de correspondance, l'une inspectant les clés et l'autre les valeurs.
+ L'option **Contenu à inspecter** indique comment filtrer l'ensemble d'éléments en fonction du sous-ensemble que vous AWS WAF souhaitez inspecter.
Vous devez spécifier l'une des options suivantes :
+ **Contenu JSON complet** : évaluez tous les éléments.
+ **Éléments inclus uniquement** : évaluez uniquement les éléments dont les chemins correspondent aux critères de pointeur JSON que vous fournissez. N'utilisez pas cette option pour indiquer *tous les* chemins dans le JSON. Utilisez plutôt le **contenu JSON complet**.
Pour plus d'informations sur la syntaxe du pointeur JSON, consultez la documentation du pointeur [JSON (JavaScript Object Notation) de l'Internet Engineering Task Force (IETF)](https://tools.ietf.org/html/rfc6901).
Par exemple, dans la console, vous pouvez fournir les informations suivantes :
```
/dogs/0/name
/dogs/1/name
```
Dans l'API ou la CLI, vous pouvez fournir les éléments suivants :
```
"IncludedPaths": ["/dogs/0/name", "/dogs/1/name"]
```
Supposons, par exemple, que le paramètre **Contenu à inspecter** soit **Uniquement les éléments inclus** et que le paramètre Éléments inclus soit défini comme tel`/a/b`.
Pour l'exemple de corps JSON suivant :
```
{
"a":{
"c":"d",
"b":{
"e":{
"f":"g"
}
}
}
}
```
Les ensembles d'éléments qui AWS WAF vérifieraient chaque paramètre de **portée de correspondance JSON** sont répertoriés ci-dessous. Notez que la clé`b`, qui fait partie du chemin des éléments inclus, n'est pas évaluée.
+ **Tous** :`e`, `f,` et`g`.
+ **Clés** : `e` et`f`.
+ **Valeurs** :`g`.
1. **Inspectez le jeu d'éléments JSON** : AWS WAF applique les transformations de texte que vous avez spécifiées aux éléments JSON extraits, puis compare l'ensemble d'éléments obtenu aux critères de correspondance de l'instruction de règle. Il s'agit du même comportement de transformation et d'évaluation que pour les autres composants de requête Web. Si l'un des éléments JSON extraits correspond, la requête Web correspond à la règle.
# Utilisation des adresses IP transférées dans AWS WAF
Cette section s'applique aux instructions de règles qui utilisent l'adresse IP d'une requête Web. Par défaut, AWS WAF utilise l'adresse IP de l'origine de la requête Web. Toutefois, si une requête Web passe par un ou plusieurs proxys ou équilibreurs de charge, l'origine de la demande Web contiendra l'adresse du dernier proxy, et non l'adresse d'origine du client. Dans ce cas, l'adresse du client d'origine est généralement transmise dans un autre en-tête HTTP. Cet en-tête est généralement `X-Forwarded-For` (XFF), mais il peut être différent.
**Déclarations de règles utilisant des adresses IP**
Les instructions de règle qui utilisent les adresses IP sont les suivantes :
+ [Correspondance d'ensemble d'adresses IP](waf-rule-statement-type-ipset-match.md)- Vérifie si l'adresse IP correspond aux adresses définies dans un ensemble d'adresses IP.
+ [Correspondance géographique](waf-rule-statement-type-geo-match.md)- Utilise l'adresse IP pour déterminer le pays et la région d'origine et compare le pays d'origine à une liste de pays.
+ [ASN match](waf-rule-statement-type-asn-match.md)- Utilise l'adresse IP pour déterminer le numéro de système autonome (ASN) et compare l'ASN à une liste de. ASNs
+ [Utilisation d'instructions de règles basées sur les taux](waf-rule-statement-type-rate-based.md)- Peut agréger les demandes par adresse IP pour s'assurer qu'aucune adresse IP individuelle n'envoie de demandes à un rythme trop élevé. Vous pouvez utiliser l'agrégation d'adresses IP seule ou en combinaison avec d'autres clés d'agrégation.
Vous pouvez demander d' AWS WAF utiliser une adresse IP transférée pour chacune de ces instructions de règle, que ce soit à partir de l'`X-Forwarded-For`en-tête ou d'un autre en-tête HTTP, au lieu d'utiliser l'origine de la requête Web. Pour plus de détails sur la manière de fournir les spécifications, consultez les instructions relatives aux différents types d'instructions de règles.
**Note**
Si un en-tête est manquant, AWS WAF évalue toute instruction utilisant cet en-tête comme « Aucune correspondance ». Si vous utilisez une instruction NOT avec un résultat « Aucune correspondance », l'évaluation est AWS WAF convertie en « Correspondance ». Les en-têtes manquants ne déclenchent pas de comportement de repli, seules les valeurs d'en-tête non valides le font.
**Comportement de secours**
Lorsque vous utilisez l'adresse IP transférée, vous indiquez le statut de correspondance AWS WAF à attribuer à la requête Web si celle-ci ne possède pas d'adresse IP valide à la position spécifiée :
+ **MATCH** - Traitez la requête Web comme correspondant à l'instruction de règle. AWS WAF applique l'action de règle à la demande.
+ **AUCUNE CORRESPONDANCE** - Traitez la requête Web comme ne correspondant pas à l'instruction de règle.
**Adresses IP utilisées dans AWS WAF Bot Control**
Le groupe de règles géré par Bot Control vérifie les robots à l'aide des adresses IP de AWS WAF. Si vous utilisez Bot Control et que vous avez vérifié les bots qui acheminent via un proxy ou un équilibreur de charge, vous devez les autoriser explicitement à l'aide d'une règle personnalisée. Par exemple, vous pouvez configurer une règle personnalisée de correspondance des ensembles d'adresses IP qui utilise les adresses IP transférées pour détecter et autoriser vos robots vérifiés. Vous pouvez utiliser cette règle pour personnaliser la gestion de votre bot de différentes manières. Pour plus d'informations et d'exemples, consultez [AWS WAF Contrôle des robots](waf-bot-control.md).
**Considérations générales relatives à l'utilisation des adresses IP transférées**
Avant d'utiliser une adresse IP transférée, prenez note des mises en garde générales suivantes :
+ Un en-tête peut être modifié par des proxys en cours de route, et les proxys peuvent gérer l'en-tête de différentes manières.
+ Les attaquants peuvent modifier le contenu de l'en-tête pour tenter de contourner AWS WAF les inspections.
+ L'adresse IP contenue dans l'en-tête peut être mal formée ou non valide.
+ L'en-tête que vous spécifiez peut ne pas être présent du tout dans une demande.
**Considérations relatives à l'utilisation d'adresses IP transférées avec AWS WAF**
La liste suivante décrit les exigences et les mises en garde relatives à l'utilisation d'adresses IP transférées dans : AWS WAF
+ Pour chaque règle, vous pouvez spécifier un en-tête pour l'adresse IP transférée. La spécification de l'en-tête ne distingue pas les majuscules et minuscules.
+ Pour les instructions de règle basées sur le taux, les instructions de portée imbriquées n'héritent pas de la configuration IP transférée. Spécifiez la configuration de chaque instruction qui utilise une adresse IP transférée.
+ Pour la correspondance géographique, la correspondance ASN et les règles basées sur le taux, AWS WAF utilise la première adresse de l'en-tête. Par exemple, si un en-tête contient des `10.1.1.1, 127.0.0.0, 10.10.10.10` AWS WAF utilisations `10.1.1.1`
+ Pour la correspondance des ensembles d'adresses IP, vous indiquez s'il convient de faire correspondre la première, la dernière ou une adresse quelconque de l'en-tête. Si vous en spécifiez une, AWS WAF inspecte toutes les adresses de l'en-tête pour détecter une correspondance, jusqu'à 10 adresses. Si l'en-tête contient plus de 10 adresses, AWS WAF inspecte les 10 dernières.
+ Les en-têtes contenant plusieurs adresses doivent être séparées par des virgules. Si une demande utilise un séparateur autre qu'une virgule, AWS WAF considère que les adresses IP de l'en-tête sont mal formées.
+ Si les adresses IP contenues dans l'en-tête sont mal formées ou non valides, AWS WAF indique que la requête Web correspond à la règle ou ne correspond pas, selon le comportement de secours que vous spécifiez dans la configuration IP transférée.
+ Si l'en-tête que vous spécifiez n'est pas présent dans une demande, la règle AWS WAF n'y est pas du tout appliquée. Cela signifie que AWS WAF cela n'applique pas l'action de la règle et n'applique pas le comportement de repli.
+ Une instruction de règle qui utilise un en-tête IP transféré pour l'adresse IP n'utilisera pas l'adresse IP indiquée par l'origine de la requête Web.
**Bonnes pratiques d'utilisation des adresses IP transférées avec AWS WAF**
Lorsque vous utilisez des adresses IP transférées, suivez les bonnes pratiques suivantes :
+ Examinez attentivement tous les états possibles de vos en-têtes de demande avant d'activer la configuration IP transférée. Il se peut que vous deviez utiliser plusieurs règles pour obtenir le comportement souhaité.
+ Pour inspecter plusieurs en-têtes IP transférés ou pour inspecter l'origine de la requête Web et un en-tête IP transféré, utilisez une règle pour chaque source d'adresse IP.
+ Pour bloquer les requêtes Web dont l'en-tête n'est pas valide, définissez l'action de règle à bloquer et définissez le comportement de secours correspondant à la configuration IP transférée.
**Exemple de JSON pour les adresses IP transférées**
L'instruction de correspondance géographique suivante ne correspond que si l'`X-Forwarded-For`en-tête contient une adresse IP dont le pays d'origine est `US` :
```
{
"Name": "XFFTestGeo",
"Priority": 0,
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "XFFTestGeo"
},
"Statement": {
"GeoMatchStatement": {
"CountryCodes": [
"US"
],
"ForwardedIPConfig": {
"HeaderName": "x-forwarded-for",
"FallbackBehavior": "MATCH"
}
}
}
}
```
La règle basée sur le débit suivante agrège les demandes en fonction de la première adresse IP de l'`X-Forwarded-For`en-tête. La règle ne compte que les demandes correspondant à l'instruction de correspondance géographique imbriquée et bloque uniquement les demandes correspondant à l'instruction de correspondance géographique. L'instruction de correspondance géographique imbriquée utilise également l'`X-Forwarded-For`en-tête pour déterminer si l'adresse IP indique le pays d'origine de. `US` Si c'est le cas, ou si l'en-tête est présent mais mal formé, l'instruction geo match renvoie une correspondance.
```
{
"Name": "XFFTestRateGeo",
"Priority": 0,
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "XFFTestRateGeo"
},
"Statement": {
"RateBasedStatement": {
"Limit": "100",
"AggregateKeyType": "FORWARDED_IP",
"ScopeDownStatement": {
"GeoMatchStatement": {
"CountryCodes": [
"US"
],
"ForwardedIPConfig": {
"HeaderName": "x-forwarded-for",
"FallbackBehavior": "MATCH"
}
}
},
"ForwardedIPConfig": {
"HeaderName": "x-forwarded-for",
"FallbackBehavior": "MATCH"
}
}
}
}
```
# Inspection des pseudo-en-têtes HTTP/2 dans AWS WAF
Cette section explique comment inspecter les pseudo-en-têtes HTTP/2. AWS WAF
Les AWS ressources protégées qui prennent en charge le trafic HTTP/2 ne transmettent pas les pseudo-en-têtes HTTP/2 à des AWS WAF fins d'inspection, mais elles fournissent le contenu des pseudo-en-têtes dans les composants de requête Web qui inspectent. AWS WAF
Vous pouvez l'utiliser AWS WAF pour inspecter uniquement les pseudo-en-têtes répertoriés dans le tableau suivant.
**Le contenu du pseudo en-tête HTTP/2 est mappé aux composants de la requête Web**
| Pseudo-en-tête HTTP/2 | Composant de requête Web à inspecter | Documentation |
| --- | --- | --- |
| `:method` | Méthode HTTP | [Méthode HTTP](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-http-method) |
| `:authority` | En-tête `Host` | [En-tête seul](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-single-header) [Tous les en-têtes](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-headers) |
| `:path`chemin de l'URI | chemin de l'URI | [chemin de l'URI](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-uri-path) |
| `:path` query | Chaîne de requête | [Chaîne de requête](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-query-string) [Paramètre de requête unique](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-single-query-param) [Tous les paramètres de requête](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-all-query-params) |
# Utilisation de transformations de texte dans AWS WAF
Cette section explique comment fournir des transformations AWS WAF à appliquer avant d'inspecter la demande.
Dans les instructions qui recherchent des modèles ou définissent des contraintes, vous pouvez fournir des transformations AWS WAF à appliquer avant d'inspecter la demande. Les transformations de texte éliminent certaines mises en forme inhabituelles que les pirates informatiques utilisent afin de contourner AWS WAF.
Lorsque vous l'utilisez avec la sélection du composant de requête du corps de la requête JSON, AWS WAF applique vos transformations après avoir analysé et extrait les éléments à inspecter à partir du JSON. Pour de plus amples informations, veuillez consulter [corps JSON](waf-rule-statement-fields-list.md#waf-rule-statement-request-component-json-body).
Si vous fournissez plusieurs transformations, vous définissez également l'ordre que AWS WAF doit leur appliquer.
**WCUs**— Chaque transformation de texte vaut 10WCUs.
La documentation de la AWS WAF console et de l'API fournit également des instructions concernant ces paramètres aux emplacements suivants :
+ **Générateur de règles** sur la console — **Transformation de texte**. Cette option est disponible lorsque vous utilisez les composants de demande.
+ **Contenu de la déclaration d'API** — `TextTransformations`Options pour les transformations de texte
Chaque liste de transformation indique les spécifications de la console et de l'API suivies d'une description.
Base64 decode – `BASE64_DECODE`
AWS WAF décode une chaîne codée en Base64.
Base64 decode extension – `BASE64_DECODE_EXT`
AWS WAF décode une chaîne codée en Base64, mais utilise une implémentation indulgente qui ignore les caractères non valides.
Command line – `CMD_LINE`
Cette option limite les situations dans lesquelles des attaquants pourraient injecter une commande de ligne de commande du système d'exploitation et utiliser un formatage inhabituel pour masquer une partie ou la totalité de la commande.
Utilisez cette option pour exécuter les transformations suivantes :
+ Supprimer les caractères suivants : `\ " ' ^`
+ Supprimer les espaces avant les caractères suivants : `/ (`
+ Remplacer les caractères suivants par un espace : `, ;`
+ Remplacer plusieurs espaces par un espace
+ Convertir les lettres majuscules `A-Z`, en minuscules, `a-z`
Compress whitespace – `COMPRESS_WHITE_SPACE`
AWS WAF compresse les espaces blancs en remplaçant plusieurs espaces par un espace et en remplaçant les caractères suivants par un espace (ASCII 32) :
+ Formfeed (ASCII 12)
+ Onglet (ASCII 9)
+ Nouvelle ligne (ASCII 10)
+ Retour en calèche (ASCII 13)
+ Onglet vertical (ASCII 11)
+ Espace ininterrompu (ASCII 160)
CSS decode – `CSS_DECODE`
AWS WAF décode les caractères codés à l'aide des règles d'échappement CSS 2.x. `syndata.html#characters` Cette fonction utilise jusqu'à deux octets dans le processus de décodage. Elle peut donc contribuer à découvrir les caractères ASCII qui ont été codés à l'aide d'un codage CSS et qui ne serait généralement pas codés. Elle est également utile pour contrer l'évasion, qui est une combinaison d'une barre oblique inversée et de caractères non hexadécimaux. Par exemple, `ja\vascript` ou `javascript`.
Escape sequences decode – `ESCAPE_SEQ_DECODE`
AWS WAF décode les séquences d'échappement ANSI C suivantes :`\a`,,`\b`,`\f`,`\n`,`\r`,`\t`,`\v`, `\\` `\?``\'`, `\xHH` (hexadécimal)`\"`, `\0OOO` (octal). Les encodages qui ne sont pas valides restent dans la sortie.
Hex decode – `HEX_DECODE`
AWS WAF décode une chaîne de caractères hexadécimaux en binaire.
HTML entity decode – `HTML_ENTITY_DECODE`
AWS WAF remplace les caractères représentés au format hexadécimal `&#xhhhh;` ou au format décimal `&#nnnn;` par les caractères correspondants.
AWS WAF remplace les caractères codés HTML suivants par des caractères non codés. Cette liste utilise un codage HTML en minuscules, mais le traitement ne fait pas la distinction majuscules/minuscules, par exemple, `&QuOt;` et est traitée de la `"` même manière.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/waf/latest/developerguide/waf-rule-statement-transformation.html)
JS decode – `JS_DECODE`
AWS WAF décode les séquences JavaScript d'échappement. Si un `\uHHHH` code se situe dans la plage de code ASCII pleine largeur de`FF01-FF5E`, l'octet le plus élevé est utilisé pour détecter et ajuster l'octet inférieur. Dans le cas contraire, seul l'octet inférieur est utilisé et l'octet supérieur est mis à zéro, ce qui peut entraîner une perte d'informations.
Lowercase – `LOWERCASE`
AWS WAF convertit les lettres majuscules (A-Z) en minuscules (a-z).
MD5 – `MD5`
AWS WAF calcule un MD5 hachage à partir des données de l'entrée. Le hachage calculé est au format binaire brut.
None – `NONE`
AWS WAF inspecte la demande Web telle qu'elle a été reçue, sans aucune transformation de texte.
Normalize path – `NORMALIZE_PATH`
AWS WAF normalise la chaîne d'entrée en supprimant les barres obliques multiples, les références automatiques de répertoire et les références arrières de répertoire qui ne se trouvent pas au début de l'entrée.
Normalize path Windows – `NORMALIZE_PATH_WIN`
AWS WAF convertit les barres obliques inverses en barres obliques directes, puis traite la chaîne résultante à l'aide de la transformation. `NORMALIZE_PATH`
Remove nulls – `REMOVE_NULLS`
AWS WAF supprime tous les `NULL` octets de l'entrée.
Replace comments – `REPLACE_COMMENTS`
AWS WAF remplace chaque occurrence d'un commentaire de style C (/\$1... \$1/) par un seul espace. Il ne compresse pas plusieurs occurrences consécutives. Il remplace les commentaires non terminés par un espace (ASCII 0x20). Cela ne change rien à la fin autonome d'un commentaire (\$1/).
Replace nulls – `REPLACE_NULLS`
AWS WAF remplace chaque `NULL` octet de l'entrée par le caractère espace (ASCII 0x20).
SQL hex decode – `SQL_HEX_DECODE`
AWS WAF décode les données hexadécimales SQL. Par exemple, AWS WAF décode (`0x414243`) vers (`ABC`).
URL decode – `URL_DECODE`
AWS WAF décode une valeur codée en URL.
URL decode Unicode – `URL_DECODE_UNI`
Comme`URL_DECODE`, mais avec le support du codage spécifique à Microsoft. `%u` Si le code se trouve dans la plage de codes ASCII dans toute sa largeur de `FF01-FF5E`, l'octet supérieur est utilisé pour détecter et ajuster l'octet inférieur. Sinon, seul l'octet inférieur est utilisé et l'octet supérieur est mis à zéro.
UTF8 to Unicode – `UTF8_TO_UNICODE`
AWS WAF convertit toutes les séquences de caractères UTF-8 en Unicode. Cela permet de normaliser la saisie et de minimiser les faux positifs et les faux négatifs pour les langues autres que l'anglais.
# Utilisation d'instructions scope-down dans AWS WAF
Cette section explique ce qu'est une instruction scope-down et comment elle fonctionne.
Une instruction scope-down est une déclaration de règle imbriquable que vous ajoutez dans une déclaration de groupe de règles géré ou une instruction basée sur le taux afin de limiter l'ensemble de demandes évaluées par la règle correspondante. La règle contenante évalue uniquement les demandes qui correspondent en premier lieu à l'instruction scope-down.
+ **Déclaration de groupe de règles géré** : si vous ajoutez une instruction de portée réduite à une déclaration de groupe de règles géré, toute demande ne AWS WAF correspondant pas à l'instruction de portée réduite est considérée comme ne correspondant pas au groupe de règles. Seules les demandes correspondant à l'instruction scope-down sont évaluées par rapport au groupe de règles. Pour les groupes de règles gérés dont la tarification est basée sur le nombre de demandes évaluées, les instructions de délimitation peuvent aider à contenir les coûts.
Pour plus d'informations sur les instructions de groupes de règles gérés, consultez[Utilisation des instructions de groupes de règles gérés dans AWS WAF](waf-rule-statement-type-managed-rule-group.md).
+ Déclaration de **règle basée sur le taux — Une déclaration** de règle basée sur le taux sans indication de portée vers le bas limite toutes les demandes évaluées par la règle. Si vous souhaitez uniquement contrôler le taux pour une catégorie spécifique de demandes, ajoutez une instruction de portée réduite à la règle basée sur le taux. Par exemple, pour suivre et contrôler uniquement le taux de demandes provenant d'une zone géographique spécifique, vous pouvez spécifier cette zone géographique dans une déclaration de correspondance géographique et l'ajouter à votre règle basée sur les taux en tant que déclaration de délimitation.
Pour plus d'informations sur les instructions de règles basées sur les taux, consultez[Utilisation d'instructions de règles basées sur le taux dans AWS WAF](waf-rule-statement-type-rate-based.md).
Vous pouvez utiliser n'importe quelle règle imbriquable dans une instruction scope-down. Pour les relevés disponibles, voir [Utilisation des instructions de règles de correspondance dans AWS WAF](waf-rule-statements-match.md) et[Utilisation d'instructions de règles logiques dans AWS WAF](waf-rule-statements-logical.md). Les WCUs instructions for a scope-down sont WCUs obligatoires pour l'instruction de règle que vous y définissez. Il n'y a aucun coût supplémentaire pour l'utilisation d'une déclaration de portée réduite.
Vous pouvez configurer une instruction scope-down de la même manière que lorsque vous utilisez l'instruction dans une règle normale. Par exemple, vous pouvez appliquer des transformations de texte à un composant de requête Web que vous inspectez et vous pouvez spécifier une adresse IP transférée à utiliser comme adresse IP. Ces configurations s'appliquent uniquement à l'instruction scope-down et ne sont pas héritées par le groupe de règles géré ou l'instruction de règle basée sur le taux qui les contient.
Par exemple, si vous appliquez des transformations de texte à une chaîne de requête dans votre instruction scope-down, l'instruction scope-down inspecte la chaîne de requête après avoir appliqué les transformations. Si la demande répond aux critères de l'instruction scope-down, AWS WAF elle transmet la demande Web à la règle conteneur dans son état d'origine, sans les transformations de l'instruction scope-down. La règle qui contient l'instruction scope-down peut appliquer ses propres transformations de texte, mais elle n'hérite aucune de l'instruction scope-down.
Vous ne pouvez pas utiliser une instruction scope-down pour spécifier une configuration d'inspection des demandes pour l'instruction de règle qui la contient. Vous ne pouvez pas utiliser une instruction scope-down comme préprocesseur de requête Web pour l'instruction de règle qui la contient. Le seul rôle d'une instruction scope-down est de déterminer quelles demandes sont transmises à l'instruction de règle la contenant pour inspection.
# Référencement d'entités réutilisables dans AWS WAF
Cette section explique le fonctionnement des entités réutilisables dans AWS WAF.
Certaines règles utilisent des entités réutilisables et gérées en dehors de votre site WebACLs, soit par vous AWS, soit par un AWS Marketplace vendeur. Lorsque l'entité réutilisable est mise à jour, AWS WAF propage la mise à jour à votre règle. Par exemple, si vous utilisez un groupe de règles AWS gérées dans un pack de protection (ACL Web), lors de la AWS mise à jour du groupe de règles, la modification AWS est transmise à votre ACL Web afin de mettre à jour son comportement. Si vous utilisez une instruction IP set dans une règle, lorsque vous mettez à jour l'ensemble, la modification est AWS WAF répercutée sur toutes les règles qui y font référence, de sorte que tous les packs de protection (Web ACLs) utilisant ces règles sont conservés up-to-date avec vos modifications.
Voici les entités réutilisables que vous pouvez utiliser dans une instruction de règle.
+ **Ensembles d'adresses IP** — Vous créez et gérez vos propres ensembles d'adresses IP. Sur la console, vous pouvez y accéder à partir du volet de navigation. Pour de plus amples informations sur la gestion des jeux d'adresses IP, reportez-vous à la section [Ensembles d'adresses IP et ensembles de modèles regex dans AWS WAF](waf-referenced-set-managing.md).
+ **Sets de matchs regex** — Vous créez et gérez vos propres sets de matchs regex. Sur la console, vous pouvez y accéder à partir du volet de navigation. Pour de plus amples informations sur la gestion des ensembles de modèles regex, reportez-vous à la section [Ensembles d'adresses IP et ensembles de modèles regex dans AWS WAF](waf-referenced-set-managing.md).
+ **AWS Groupes de règles gérées** : AWS gère ces groupes de règles. Sur la console, vous pouvez les utiliser lorsque vous ajoutez un groupe de règles géré à votre pack de protection (ACL Web). Pour de plus amples informations, veuillez consulter [AWS Liste des groupes de règles gérées](aws-managed-rule-groups-list.md).
+ **AWS Marketplace groupes de règles gérés** : AWS Marketplace les vendeurs gèrent ces groupes de règles et vous pouvez vous y abonner pour les utiliser. Pour gérer vos abonnements, dans le volet de navigation de la console, sélectionnez **AWS Marketplace**. Les groupes de règles AWS Marketplace gérés sont répertoriés lorsque vous ajoutez un groupe de règles géré à votre pack de protection (ACL Web). Pour les groupes de règles auxquels vous n'êtes pas encore abonné, vous trouverez également un lien vers AWS Marketplace ces groupes sur cette page. Pour plus d'informations sur les groupes de règles gérés par le AWS Marketplace vendeur, consultez[AWS Marketplace groupes de règles](marketplace-rule-groups.md).
+ **Vos propres groupes de règles** : vous gérez vos propres groupes de règles, généralement lorsque vous avez besoin d'un comportement qui n'est pas disponible dans les groupes de règles gérés. Sur la console, vous pouvez y accéder à partir du volet de navigation. Pour de plus amples informations, veuillez consulter [Gestion de vos propres groupes de règles](waf-user-created-rule-groups.md).
**Suppression d'un jeu ou d'un groupe de règles référencé**
Lorsque vous supprimez une entité référencée AWS WAF , vérifiez si elle est actuellement utilisée dans un pack de protection (ACL Web). S'il AWS WAF découvre qu'il est en cours d'utilisation, il vous avertit. AWS WAF est presque toujours capable de déterminer si une entité est référencée par un pack de protection (ACL Web). Cependant, dans de rares cas, il pourrait ne pas être en mesure de le faire. Si vous devez vous assurer que l'entité que vous souhaitez supprimer n'est pas en cours d'utilisation, vérifiez-la sur votre site Web ACLs avant de la supprimer.
# Utilisation des instructions de règles de correspondance dans AWS WAF
Cette section explique ce qu'est une déclaration de match et comment elle fonctionne.
Les instructions Match comparent la demande Web ou son origine aux critères que vous fournissez. Pour de nombreuses instructions de ce type, AWS WAF compare un composant spécifique de la demande de contenu correspondant.
Les relevés de match sont imbriquables. Vous pouvez imbriquer n'importe laquelle de ces instructions dans des instructions de règles logiques et vous pouvez les utiliser dans des instructions de portée réduite. Pour plus d'informations sur les instructions de règles logiques, consultez[Utilisation d'instructions de règles logiques dans AWS WAF](waf-rule-statements-logical.md). Pour plus d'informations sur les instructions de portée réduite, consultez. [Utilisation d'instructions scope-down dans AWS WAF](waf-rule-scope-down-statements.md)
Ce tableau décrit les instructions de correspondance régulières que vous pouvez ajouter à une règle et fournit des directives pour calculer l'utilisation des unités de capacité (WCU) du pack de protection (ACL Web) pour chacune d'elles. Pour plus d'informations sur WCUs, voir[Unités de capacité Web ACL (WCUs) en AWS WAF](aws-waf-capacity-units.md).
| Déclaration de correspondance | Description | WCUs |
| --- | --- | --- |
| [Correspondance géographique](waf-rule-statement-type-geo-match.md) | Inspecte le pays d'origine de la demande et applique des étiquettes pour le pays et la région d'origine. | 1 |
| [ASN match](waf-rule-statement-type-asn-match.md) | Inspecte la demande par rapport à un ASN associé aux adresses IP et aux plages d'adresses. | 1 |
| [Correspondance d'ensemble d'adresses IP](waf-rule-statement-type-ipset-match.md) | Inspecte la demande par rapport à un ensemble d'adresses IP et de plages d'adresses. | 1 dans la plupart des cas. Si vous configurez l'instruction pour utiliser un en-tête avec des adresses IP transférées et que vous spécifiez une position dans l'en-tête deAny, augmentez la WCUs valeur de 4. |
| [Déclaration relative à la règle de correspondance des étiquettes](waf-rule-statement-type-label-match.md) | Inspecte la demande pour les étiquettes qui ont été ajoutées par d'autres règles dans le même pack de protection (ACL Web). | 1 |
| [Déclaration de règle de correspondance Regex](waf-rule-statement-type-regex-match.md) | Compare un modèle de regex avec un composant de requête spécifié. | 3, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs. |
| [Ensemble de modèles Regex](waf-rule-statement-type-regex-pattern-set-match.md) | Compare les modèles regex à un composant de requête spécifié. | 25 par jeu de modèles, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs. |
| [Contrainte de taille](waf-rule-statement-type-size-constraint-match.md) | Vérifie les contraintes de taille par rapport à un composant de demande spécifié. | 1, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs. |
| [SQLiattaque](waf-rule-statement-type-sqli-match.md) | Inspecte la présence de code SQL malveillant dans un composant de requête spécifié. | 20, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs. |
| [Correspondance de chaîne](waf-rule-statement-type-string-match.md) | Compare une chaîne à un composant de demande spécifié. | Le coût de base dépend du type de correspondance de chaîne et se situe entre 1 et 10. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs. |
| [Attaque par scripts XSS](waf-rule-statement-type-xss-match.md) | Inspecte les attaques de script intersite dans un composant de demande spécifié. | 40, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs. |
# Instruction de correspondance géographique de règle
Cette section explique ce qu'est une déclaration de correspondance géographique et comment elle fonctionne.
Utilisez des déclarations géographiques ou de correspondance géographique pour gérer les demandes Web en fonction du pays et de la région d'origine. Une déclaration de correspondance géographique ajoute aux requêtes Web des étiquettes indiquant le pays d'origine et la région d'origine. Il ajoute ces étiquettes, que les critères de l'énoncé correspondent ou non à la demande. Une instruction Geo Match effectue également une correspondance avec le pays d'origine de la demande.
## Comment utiliser la déclaration Geo Match
Vous pouvez utiliser l'instruction Geo Match pour faire correspondre un pays ou une région, comme suit :
+ **Pays** — Vous pouvez utiliser une règle de correspondance géographique à elle seule pour gérer les demandes uniquement en fonction de leur pays d'origine. L'énoncé de règle correspond aux codes de pays. Vous pouvez également suivre une règle de correspondance géographique avec une règle de correspondance d'étiquette qui correspond à l'étiquette du pays d'origine.
**Note**
Pour filtrer le trafic en provenance de Hong Kong, utilisez le code de pays ISO 3166-1 alpha-2 `HK` dans votre relevé de correspondance géographique.
+ **Région** : utilisez une règle de correspondance géographique suivie d'une règle de correspondance d'étiquettes pour gérer les demandes en fonction de leur région d'origine. Vous ne pouvez pas utiliser une règle de correspondance géographique uniquement pour établir une correspondance avec des codes de région.
Pour plus d'informations sur l'utilisation des règles de correspondance des étiquettes, reportez-vous aux [Déclaration relative à la règle de correspondance des étiquettes](waf-rule-statement-type-label-match.md) sections et[Étiquetage des requêtes Web dans AWS WAF](waf-labels.md).
## Comment fonctionne la déclaration Geo Match
Avec l'instruction geo match, AWS WAF gère chaque requête Web comme suit :
1. **Détermine les codes de pays et de région de la demande** : AWS WAF détermine le pays et la région d'une demande en fonction de son adresse IP. Par défaut, AWS WAF utilise l'adresse IP d'origine de la requête Web. Vous pouvez demander d' AWS WAF utiliser une adresse IP provenant d'un autre en-tête de demande`X-Forwarded-For`, par exemple en activant la configuration IP transférée dans les paramètres de l'instruction de règle.
AWS WAF détermine l'emplacement des demandes à l'aide des bases de MaxMind données GeoIP. MaxMind fait état d'une très grande précision de ses données au niveau des pays, bien que la précision varie en fonction de facteurs tels que le pays et le type de propriété intellectuelle. Pour plus d'informations MaxMind, consultez la section [Géolocalisation MaxMind IP](https://support.maxmind.com/hc/en-us/sections/4407519834267-IP-Geolocation). Si vous pensez que l'une des données GeoIP est incorrecte, vous pouvez envoyer une demande de correction à Maxmind à l'adresse [MaxMind Correct](https://support.maxmind.com/hc/en-us/articles/4408252036123-GeoIP-Correction) Geo Data. IP2
AWS WAF utilise les codes de pays et de région alpha-2 de la norme 3166 de l'Organisation internationale de normalisation (ISO). Vous pouvez trouver les codes aux endroits suivants :
+ Sur le site Web de l'ISO, vous pouvez rechercher les codes de pays sur la [plateforme de navigation en ligne ISO (OBP).](https://www.iso.org/obp/ui#home)
+ Sur Wikipédia, les codes de pays sont répertoriés [selon la norme ISO 3166-2](https://en.wikipedia.org/wiki/ISO_3166-2).
Les codes régionaux d'un pays sont répertoriés dans l'URL`https://en.wikipedia.org/wiki/ISO_3166-2:`. [Par exemple, les régions des États-Unis d'Amérique sont conformes à la norme ISO 3166-2:US et celles de l'Ukraine [à la norme ISO](https://en.wikipedia.org/wiki/ISO_3166-2:US) 3166-2:UA.](https://en.wikipedia.org/wiki/ISO_3166-2:UA)
1. **Détermine le libellé du pays et le libellé de la région à ajouter à la demande** : les étiquettes indiquent si l'instruction Geo Match utilise l'adresse IP d'origine ou une configuration IP transférée.
+ **IP d'origine**
L'étiquette du pays est`awswaf:clientip:geo:country:`. Exemple pour les États-Unis d'Amérique `awswaf:clientip:geo:country:US` :
L'étiquette de la région est`awswaf:clientip:geo:region:-`. Exemple pour l'Oregon aux États-Unis d'Amérique `awswaf:clientip:geo:region:US-OR` :
+ **IP transférée**
L'étiquette du pays est`awswaf:forwardedip:geo:country:`. Exemple pour les États-Unis d'Amérique `awswaf:forwardedip:geo:country:US` :
L'étiquette de la région est`awswaf:forwardedip:geo:region:-`. Exemple pour l'Oregon aux États-Unis d'Amérique `awswaf:forwardedip:geo:region:US-OR` :
Si le code de pays ou de région n'est pas disponible pour l'adresse IP spécifiée dans une demande, AWS WAF `XX` utilisez-le dans les libellés, à la place de la valeur. Par exemple, l'étiquette suivante est pour une adresse IP client dont le code de pays n'est pas disponible : `awswaf:clientip:geo:country:XX` et l'étiquette suivante est pour une adresse IP transférée dont le pays est les États-Unis d'Amérique, mais dont le code de région n'est pas disponible :. `awswaf:forwardedip:geo:region:US-XX`
1. **Évalue le code de pays de la demande par rapport aux critères de la règle**
L'instruction Geo Match ajoute des libellés de pays et de régions à toutes les demandes qu'elle inspecte, qu'elle trouve ou non une correspondance.
**Note**
AWS WAF ajoute des libellés à la fin de l'évaluation des requêtes Web d'une règle. Pour cette raison, toute étiquette que vous utilisez par rapport aux libellés d'une instruction de correspondance géographique doit être définie dans une règle distincte de celle qui contient l'instruction de correspondance géographique.
Si vous souhaitez inspecter uniquement les valeurs des régions, vous pouvez écrire une règle de correspondance géographique avec une Count action et une seule correspondance de code de pays, suivie d'une règle de correspondance d'étiquettes pour les étiquettes de région. Vous devez fournir un code de pays pour que la règle de correspondance géographique puisse être évaluée, même pour cette approche. Vous pouvez réduire les statistiques de journalisation et de comptage en spécifiant un pays qui est très peu susceptible d'être une source de trafic vers votre site.
## CloudFront les distributions et la CloudFront fonction de restriction géographique
Pour les CloudFront distributions, si vous utilisez la fonctionnalité CloudFront de restriction géographique, sachez que cette fonctionnalité ne transmet pas les demandes bloquées à AWS WAF. Il transmet les demandes autorisées à AWS WAF. Si vous souhaitez bloquer les demandes en fonction de la géographie et d'autres critères que vous pouvez spécifier AWS WAF, utilisez l'instruction AWS WAF de correspondance géographique et n'utilisez pas la fonctionnalité CloudFront de restriction géographique.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs **— 1 ECU
**Paramètres** — Cette instruction utilise les paramètres suivants :
+ **Codes de pays** : ensemble de codes de pays à comparer pour une correspondance géographique. Il doit s'agir de codes de pays à deux caractères issus des codes ISO de pays alpha-2 de la norme internationale ISO 3166, par exemple. `["US","CN"]`
+ **(Facultatif) Configuration IP transférée** — Par défaut, AWS WAF utilise l'adresse IP dans l'origine de la requête Web pour déterminer le pays d'origine. Vous pouvez également configurer la règle pour utiliser une adresse IP transférée dans un en-tête HTTP à la `X-Forwarded-For` place. AWS WAF utilise la première adresse IP de l'en-tête. Avec cette configuration, vous spécifiez également un comportement de secours à appliquer à une requête Web dont l'en-tête contient une adresse IP mal formée. Le comportement de remplacement définit le résultat correspondant à la demande, qu'il corresponde ou non. Pour de plus amples informations, veuillez consulter [Utilisation d'adresses IP transférées](waf-rule-statement-forwarded-ip-address.md).
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour l'**option Demande**, choisissez **Provient d'un pays de**.
+ **API** — [GeoMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_GeoMatchStatement.html)
## Exemples
Vous pouvez utiliser le relevé de correspondance géographique pour gérer les demandes provenant de pays ou de régions spécifiques. Par exemple, si vous souhaitez bloquer les demandes provenant de certains pays, tout en autorisant les demandes provenant d'un ensemble spécifique d'adresses IP dans ces pays, vous pouvez créer une règle avec l'action définie sur Block et les instructions imbriquées suivantes, affichées en pseudocode :
+ AND déclaration
+ Instruction de correspondance géographique répertoriant les pays que vous souhaitez bloquer
+ NOT déclaration
+ Instruction de jeu d'adresses IP qui spécifie les adresses IP via lesquelles vous souhaitez autoriser
Ou, si vous souhaitez bloquer certaines régions dans certains pays, tout en autorisant les demandes provenant d'autres régions de ces pays, vous pouvez d'abord définir une règle de correspondance géographique avec l'action définie sur. Count Définissez ensuite une règle de correspondance d'étiquettes qui correspond aux étiquettes de correspondance géographique ajoutées et gère les demandes selon vos besoins.
Le pseudo-code suivant décrit un exemple de cette approche :
1. Déclaration de correspondance géographique répertoriant les pays dont les régions que vous souhaitez bloquer, mais dont l'action est définie sur Compter. Cela étiquette chaque requête Web, quel que soit le statut de correspondance, et vous donne également des mesures de comptage pour les pays qui vous intéressent.
1. `AND`déclaration avec action de blocage
+ Déclaration de correspondance des libellés qui spécifie les libellés des pays que vous souhaitez bloquer
+ `NOT` déclaration
+ Déclaration de correspondance des étiquettes qui spécifie les libellés des régions des pays que vous souhaitez autoriser
La liste JSON suivante montre une implémentation des deux règles décrites dans le pseudocode précédent. Ces règles bloquent tout le trafic en provenance des États-Unis d'Amérique, à l'exception du trafic en provenance de l'Oregon et de Washington. La déclaration Geo Match ajoute des libellés de pays et de régions à toutes les demandes qu'elle inspecte. La règle de correspondance des libellés s'exécute après la règle de correspondance géographique, de sorte qu'elle peut correspondre aux étiquettes de pays et de régions que la règle de correspondance géographique vient d'ajouter. L'instruction Geo Match utilise une adresse IP transférée, de sorte que la correspondance d'étiquettes spécifie également les étiquettes IP transférées.
```
{
"Name": "geoMatchForLabels",
"Priority": 10,
"Statement": {
"GeoMatchStatement": {
"CountryCodes": [
"US"
],
"ForwardedIPConfig": {
"HeaderName": "X-Forwarded-For",
"FallbackBehavior": "MATCH"
}
}
},
"Action": {
"Count": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "geoMatchForLabels"
}
},
{
"Name": "blockUSButNotOROrWA",
"Priority": 11,
"Statement": {
"AndStatement": {
"Statements": [
{
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:forwardedip:geo:country:US"
}
},
{
"NotStatement": {
"Statement": {
"OrStatement": {
"Statements": [
{
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:forwardedip:geo:region:US-OR"
}
},
{
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:forwardedip:geo:region:US-WA"
}
}
]
}
}
}
}
]
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "blockUSButNotOROrWA"
}
}
```
Autre exemple, vous pouvez associer la géolocalisation à des règles basées sur les taux pour hiérarchiser les ressources destinées aux utilisateurs d'un pays ou d'une région en particulier. Vous créez un relevé tarifaire différent pour chaque relevé de correspondance géographique ou de correspondance d'étiquette que vous utilisez pour différencier vos utilisateurs. Définissez une limite de débit supérieure pour les utilisateurs du pays ou de la région de votre choix et définissez une limite de débit inférieure pour les autres utilisateurs.
La liste JSON suivante montre une règle de correspondance géographique suivie de règles basées sur le taux qui limitent le débit du trafic en provenance des États-Unis d'Amérique. Les règles permettent au trafic en provenance de l'Oregon d'entrer à un rythme plus élevé que le trafic en provenance de n'importe quel autre endroit du pays.
```
{
"Name": "geoMatchForLabels",
"Priority": 190,
"Statement": {
"GeoMatchStatement": {
"CountryCodes": [
"US"
]
}
},
"Action": {
"Count": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "geoMatchForLabels"
}
},
{
"Name": "rateLimitOregon",
"Priority": 195,
"Statement": {
"RateBasedStatement": {
"Limit": 3000,
"AggregateKeyType": "IP",
"ScopeDownStatement": {
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:clientip:geo:region:US-OR"
}
}
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "rateLimitOregon"
}
},
{
"Name": "rateLimitUSNotOR",
"Priority": 200,
"Statement": {
"RateBasedStatement": {
"Limit": 100,
"AggregateKeyType": "IP",
"ScopeDownStatement": {
"AndStatement": {
"Statements": [
{
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:clientip:geo:country:US"
}
},
{
"NotStatement": {
"Statement": {
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:clientip:geo:region:US-OR"
}
}
}
}
]
}
}
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "rateLimitUSNotOR"
}
}
```
# Instruction de correspondance d'ensemble d'adresses IP de règle
Cette section explique ce qu'est une instruction IP set match et comment elle fonctionne.
L'instruction IP set match inspecte l'adresse IP d'une requête Web par rapport à un ensemble d'adresses IP et de plages d'adresses. Utilisez cette option pour autoriser ou bloquer les demandes web basées sur les adresses IP d'origine des demandes. Par défaut, AWS WAF utilise l'adresse IP de l'origine de la requête Web, mais vous pouvez configurer la règle pour utiliser un en-tête HTTP à la `X-Forwarded-For` place.
AWS WAF prend en charge toutes IPv4 les plages IPv6 CIDR à l'exception de`/0`. Pour plus d'informations sur la notation CIDR, consultez l'article [Classless Inter-Domain Routing](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing) sur Wikipédia (en anglais). Un jeu d'adresses IP peut contenir jusqu'à 10 000 adresses IP ou plages d'adresses IP à vérifier.
**Note**
Chaque règle de correspondance de jeu d'adresses IP fait référence à un jeu d'adresses IP que vous créez et conservez indépendamment de vos règles. Vous pouvez utiliser un seul ensemble d'adresses IP dans plusieurs règles, et lorsque vous mettez à jour l'ensemble référencé, toutes les règles qui y font référence AWS WAF sont automatiquement mises à jour.
Pour plus d'informations sur la création et la gestion d'un ensemble d'adresses IP, consultez[Création et gestion d'une adresse IP définie dans AWS WAF](waf-ip-set-managing.md).
Lorsque vous ajoutez ou mettez à jour les règles dans votre groupe de règles ou votre pack de protection (ACL Web), choisissez l'option **IP set** et sélectionnez le nom de l'ensemble d'adresses IP que vous souhaitez utiliser.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 1 WCU pour la plupart. Si vous configurez l'instruction pour utiliser les adresses IP transférées et que vous spécifiez une position deANY, augmentez l'utilisation de la WCU de 4.
Cette instruction utilise les paramètres suivants :
+ **Spécification de l'ensemble** d'adresses IP — Choisissez l'ensemble d'adresses IP que vous souhaitez utiliser dans la liste ou créez-en un nouveau.
+ **(Facultatif) Configuration IP transférée** : nom d'en-tête IP transféré alternatif à utiliser à la place de l'origine de la demande. Vous spécifiez si la correspondance doit être faite avec la première, la dernière ou avec n'importe quelle adresse de l'en-tête. Vous spécifiez également un comportement de secours à appliquer à une requête Web dont l'adresse IP est mal formée dans l'en-tête spécifié. Le comportement de remplacement définit le résultat correspondant à la demande, qu'il corresponde ou non. Pour de plus amples informations, veuillez consulter [Utilisation d'adresses IP transférées](waf-rule-statement-forwarded-ip-address.md).
## Où trouver cette déclaration de règle
**Où trouver cette déclaration de règle**
+ **Générateur de règles** sur la console : pour l'**option Requête**, choisissez **Provient d'une adresse IP dans**.
+ **Ajouter mes propres règles et groupes** de règles sur la console — Choisissez l'option **IP set**.
+ **API** — [IPSetReferenceStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_IPSetReferenceStatement.html)
# Déclaration de règle de correspondance ASN (Autonomous System Number)
Une déclaration de règle de correspondance ASN vous AWS WAF permet d'inspecter le trafic Web en fonction du numéro de système autonome (ASN) associé à l'adresse IP de la demande. ASNs sont des identifiants uniques attribués à de grands réseaux Internet gérés par des organisations telles que des fournisseurs de services Internet, des entreprises, des universités ou des agences gouvernementales. En utilisant les instructions de correspondance ASN, vous pouvez autoriser ou bloquer le trafic provenant d'organisations de réseau spécifiques sans avoir à gérer des adresses IP individuelles. Cette approche offre un moyen plus stable et plus efficace de contrôler l'accès par rapport aux règles basées sur l'IP, car elles ASNs changent moins fréquemment que les plages d'adresses IP.
La correspondance ASN est particulièrement utile pour les scénarios tels que le blocage du trafic en provenance de réseaux problématiques connus ou l'autorisation d'accès uniquement à partir de réseaux partenaires fiables. L'instruction ASN match permet de déterminer avec flexibilité l'adresse IP du client grâce à une configuration IP transférée optionnelle, ce qui la rend compatible avec diverses configurations réseau, y compris celles utilisant des réseaux de diffusion de contenu (CDNs) ou des proxys inverses.
**Note**
La correspondance ASN complète, mais ne remplace pas, les contrôles d'authentification et d'autorisation standard. Nous vous recommandons de mettre en œuvre des mécanismes d'authentification et d'autorisation, tels que l'IAM, pour vérifier l'identité de toutes les demandes dans vos applications.
## Comment fonctionne le relevé de match de l'ASN
AWS WAF détermine l'ASN d'une demande en fonction de son adresse IP. Par défaut, AWS WAF utilise l'adresse IP d'origine de la requête Web. Vous pouvez configurer AWS WAF pour utiliser une adresse IP provenant d'un autre en-tête de demande`X-Forwarded-For`, par exemple en activant la configuration IP transférée dans les paramètres de l'énoncé de règle.
L'instruction ASN match compare l'ASN de la demande à la liste ASNs spécifiée dans la règle. Si l'ASN correspond à l'un des numéros de la liste, l'instruction est considérée comme vraie et l'action de règle associée est appliquée.
### Gestion des données non mappées ASNs
S'il AWS WAF n'est pas possible de déterminer un ASN pour une adresse IP valide, il attribue un ASN 0. Vous pouvez inclure l'ASN 0 dans votre règle pour traiter ces cas de manière explicite.
### Comportement de secours en cas d'adresses IP non valides
Lorsque vous configurez l'instruction ASN match pour utiliser des adresses IP transférées, vous pouvez définir un comportement de secours *Match ou *No match** pour les demandes dont les adresses IP sont invalides ou manquantes dans l'en-tête désigné.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 1 ECU
Cette instruction utilise les paramètres suivants :
+ **Liste ASN** : tableau de numéros ASN à comparer pour une correspondance ASN. Les valeurs valides sont comprises entre 0 et 4294967295. Vous pouvez spécifier jusqu'à 100 ASNs pour chaque règle.
+ **(Facultatif) Configuration IP transférée** — Par défaut, AWS WAF utilise l'adresse IP dans l'origine de la demande Web pour déterminer l'ASN. Vous pouvez également configurer la règle pour utiliser une adresse IP transférée dans un en-tête HTTP à la `X-Forwarded-For` place. Vous spécifiez si vous souhaitez utiliser la première, la dernière ou n'importe quelle adresse dans l'en-tête. Avec cette configuration, vous spécifiez également un comportement de secours à appliquer à une requête Web dont l'en-tête contient une adresse IP mal formée. Le comportement de remplacement définit le résultat correspondant à la demande, qu'il corresponde ou non. Pour plus d'informations, consultez la section [Utilisation d'adresses IP transférées](https://docs.aws.amazon.com/waf/latest/developerguide/waf-rule-statement-forwarded-ip-address.html).
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour l'**option Demande**, choisissez **Provient de l'ASN dans.**
+ **API** — [AsnMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_AsnMatchStatement.html)
## Exemples
Cet exemple bloque les demandes provenant de deux requêtes spécifiques ASNs dérivées d'un `X-Forwarded-For` en-tête. Si l'adresse IP dans l'en-tête est mal formée, le comportement de secours configuré est le suivant. `NO_MATCH`
```
{
"Action": {
"Block": {}
},
"Name": "AsnMatchStatementRule",
"Priority": 1,
"Statement": {
"AsnMatchStatement": {
"AsnList": [64496, 64500]
},
"ForwardedIPConfig": {
"FallbackBehavior": "NO_MATCH",
"HeaderName": "X-Forwarded-For"
}
},
"VisibilityConfig": {
"CloudWatchMetricsEnabled": true,
"MetricName": "AsnMatchRuleMetrics",
"SampledRequestsEnabled": true
}
},
"VisibilityConfig": {
"CloudWatchMetricsEnabled": true,
"MetricName": "WebAclMetrics",
"SampledRequestsEnabled": true
}
}
```
# Déclaration relative à la règle de correspondance des étiquettes
Cette section explique ce qu'est une déclaration de correspondance d'étiquettes et comment elle fonctionne.
L'instruction label match inspecte les étiquettes figurant sur la requête Web par rapport à une spécification de chaîne. Les étiquettes disponibles pour une règle à des fins d'inspection sont celles qui ont déjà été ajoutées à la requête Web par d'autres règles dans le cadre de la même évaluation du pack de protection (ACL Web).
Les étiquettes ne sont pas conservées en dehors de l'évaluation du pack de protection (ACL Web), mais vous pouvez accéder aux métriques des étiquettes CloudWatch et vous pouvez consulter des résumés des informations relatives aux étiquettes pour n'importe quel pack de protection (ACL Web) dans la AWS WAF console. Pour plus d’informations, consultez [Métriques et dimensions des étiquettes](waf-metrics.md#waf-metrics-label) et [Surveillance et réglage de vos AWS WAF protections](web-acl-testing-activities.md). Vous pouvez également voir les étiquettes dans les journaux. Pour plus d'informations, consultez [Champs de journal pour le trafic du pack de protection (ACL Web)](logging-fields.md).
**Note**
Une instruction de correspondance d'étiquettes ne peut voir que les libellés issus de règles évaluées précédemment dans le pack de protection (ACL Web). Pour plus d'informations sur le AWS WAF mode d'évaluation des règles et des groupes de règles dans un pack de protection (ACL Web), consultez[Définition de la priorité des règles](web-acl-processing-order.md).
Pour plus d'informations sur l'ajout et la mise en correspondance d'étiquettes, consultez[Étiquetage des requêtes Web dans AWS WAF](waf-labels.md).
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 1 ECU
Cette instruction utilise les paramètres suivants :
+ **Champ de correspondance** : définissez ce paramètre **sur Label** pour qu'il corresponde au nom de l'étiquette et, éventuellement, aux espaces de noms et au préfixe précédents. Définissez ce paramètre sur **Namespace** pour qu'il corresponde à certaines ou à toutes les spécifications de l'espace de noms et, éventuellement, au préfixe précédent.
+ **Clé** — La chaîne à laquelle vous souhaitez faire correspondre. Si vous spécifiez une étendue de correspondance d'espaces de noms, celle-ci ne doit spécifier que les espaces de noms et éventuellement le préfixe, avec deux points à la fin. Si vous spécifiez une étendue de correspondance d'étiquettes, celle-ci doit inclure le nom de l'étiquette et peut éventuellement inclure les espaces de noms et le préfixe précédents.
Pour plus d'informations sur ces paramètres, consultez [AWS WAF règles qui correspondent aux libellés](waf-rule-label-match.md) et [AWS WAF exemples de correspondance d'étiquettes](waf-rule-label-match-examples.md).
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour l'**option Demande**, choisissez **Has label**.
+ **API** — [LabelMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_LabelMatchStatement.html)
# Déclaration de règle de correspondance Regex
Cette section explique ce qu'est une instruction regex match et comment elle fonctionne.
Une instruction regex match indique de AWS WAF faire correspondre un composant de requête à une seule expression régulière (regex). Une requête Web correspond à l'instruction si le composant de demande correspond à l'expression régulière que vous spécifiez.
Ce type d'instruction constitue une bonne alternative [Instruction de correspondance d'ensemble de modèles d'expression régulière de règle](waf-rule-statement-type-regex-pattern-set-match.md) aux situations dans lesquelles vous souhaitez combiner vos critères de correspondance en utilisant la logique mathématique. Par exemple, si vous souhaitez qu'un composant de requête corresponde à certains modèles de regex et non à d'autres, vous pouvez combiner les instructions regex match en utilisant le [ANDdéclaration de règle](waf-rule-statement-type-and.md) et le. [NOTdéclaration de règle](waf-rule-statement-type-not.md)
AWS WAF prend en charge la syntaxe des modèles utilisée par la bibliothèque PCRE, `libpcre` à quelques exceptions près. La bibliothèque est documentée sur [PCRE - Perl Compatible Regular Expressions](http://www.pcre.org/). Pour plus d'informations sur AWS WAF le support, consultez[Syntaxe d'expression régulière prise en charge dans AWS WAF](waf-regex-pattern-support.md).
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 3 WCUs, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs.
Ce type d'instruction fonctionne sur un composant de requête Web et nécessite les paramètres de composant de demande suivants :
+ **Composant de demande** : partie de la requête Web destinée à inspecter, par exemple, une chaîne de requête ou le corps de la requête.
**Avertissement**
Si vous inspectez les composants de la requête **Body**, **JSON body**, **Headers** ou **Cookies, renseignez-vous** sur les limites relatives à [Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md) la quantité de contenu AWS WAF pouvant être inspectée.
Pour plus d'informations sur les composants des requêtes Web, consultez[Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md).
+ Transformations de **texte facultatives : transformations** que vous AWS WAF souhaitez effectuer sur le composant de demande avant de l'inspecter. Par exemple, vous pouvez passer en minuscules ou normaliser les espaces blancs. Si vous spécifiez plusieurs transformations, AWS WAF traitez-les dans l'ordre indiqué. Pour plus d'informations, consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour le **type Match**, choisissez **Correspond à une expression régulière**.
+ **API** — [RegexMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_RegexMatchStatement.html)
# Instruction de correspondance d'ensemble de modèles d'expression régulière de règle
Cette section explique ce qu'est une instruction regex pattern set match et comment elle fonctionne.
La correspondance de l'ensemble de modèles regex inspecte la partie de la demande web que vous spécifiez et recherche les modèles d'expression régulière que vous avez définis dans un ensemble de modèles regex.
AWS WAF prend en charge la syntaxe des modèles utilisée par la bibliothèque PCRE, `libpcre` à quelques exceptions près. La bibliothèque est documentée sur [PCRE - Perl Compatible Regular Expressions](http://www.pcre.org/). Pour plus d'informations sur AWS WAF le support, consultez[Syntaxe d'expression régulière prise en charge dans AWS WAF](waf-regex-pattern-support.md).
**Note**
Chaque règle de correspondance d'ensemble de modèles regex fait référence à un ensemble de modèlesregex, que vous créez et maintenez indépendamment de vos règles. Vous pouvez utiliser un seul ensemble de modèles regex dans plusieurs règles, et lorsque vous mettez à jour l'ensemble référencé, toutes les règles qui y font référence AWS WAF sont automatiquement mises à jour.
Pour de plus amples informations sur la création et la gestion d'un ensemble de modèles regex, reportez-vous à la section [Création et gestion d'un modèle regex défini dans AWS WAF](waf-regex-pattern-set-managing.md).
Une instruction regex pattern set match indique de AWS WAF rechercher l'un des modèles de l'ensemble dans le composant de requête que vous choisissez. Une demande web correspond à l'instruction de règle de l'ensemble de modèles si le composant de demande correspond à l'un des modèles de l'ensemble.
Si vous souhaitez combiner vos correspondances de modèles regex en utilisant la logique, par exemple pour les faire correspondre à certaines expressions régulières et non à d'autres, pensez à utiliser[Déclaration de règle de correspondance Regex](waf-rule-statement-type-regex-match.md).
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 25 WCUs, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs.
Ce type d'instruction fonctionne sur un composant de requête Web et nécessite les paramètres de composant de demande suivants :
+ **Composant de demande** : partie de la requête Web destinée à inspecter, par exemple, une chaîne de requête ou le corps de la requête.
**Avertissement**
Si vous inspectez les composants de la requête **Body**, **JSON body**, **Headers** ou **Cookies, renseignez-vous** sur les limites relatives à [Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md) la quantité de contenu AWS WAF pouvant être inspectée.
Pour plus d'informations sur les composants des requêtes Web, consultez[Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md).
+ Transformations de **texte facultatives : transformations** que vous AWS WAF souhaitez effectuer sur le composant de demande avant de l'inspecter. Par exemple, vous pouvez passer en minuscules ou normaliser les espaces blancs. Si vous spécifiez plusieurs transformations, AWS WAF traitez-les dans l'ordre indiqué. Pour plus d'informations, consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
Cette instruction nécessite les paramètres suivants :
+ Spécification du jeu de modèles Regex — Choisissez le jeu de modèles Regex que vous souhaitez utiliser dans la liste ou créez-en un nouveau.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour **Type de correspondance**, choisissez **Condition de correspondance de chaîne** > **Correspond au modèle du jeu d'expressions régulières**.
+ **API** — [RegexPatternSetReferenceStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_RegexPatternSetReferenceStatement.html)
# Instruction de contrainte de taille de règle
Cette section explique ce qu'est une instruction de contrainte de taille et comment elle fonctionne.
Une instruction de contrainte de taille compare le nombre d'octets AWS WAF reçus pour un composant de requête Web à un nombre que vous fournissez, et le correspond en fonction de vos critères de comparaison.
Le critère de comparaison est un opérateur tel que supérieur à (>) ou inférieur à (<). Par exemple, vous pouvez établir une correspondance sur des demandes dont la taille de la chaîne de requête est supérieure à 100 octets.
Si vous inspectez le chemin de l'URI, tout `/` élément du chemin compte pour un caractère. Par exemple, le chemin `/logo.jpg` de l'URI comporte neuf caractères.
**Note**
Cette instruction inspecte uniquement la taille du composant de requête Web. Il n'inspecte pas le contenu du composant.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 1 WCU, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs.
Ce type d'instruction fonctionne sur un composant de requête Web et nécessite les paramètres de composant de demande suivants :
+ **Composant de demande** : partie de la requête Web destinée à inspecter, par exemple, une chaîne de requête ou le corps de la requête. Pour plus d'informations sur les composants des requêtes Web, consultez[Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md).
Une instruction de contrainte de taille inspecte uniquement la taille du composant une fois les transformations appliquées. Il n'inspecte pas le contenu du composant.
+ Transformations de **texte facultatives : transformations** que vous AWS WAF souhaitez effectuer sur le composant de demande avant d'inspecter sa taille. Par exemple, vous pouvez compresser des espaces blancs ou décoder des entités HTML. Si vous spécifiez plusieurs transformations, AWS WAF traitez-les dans l'ordre indiqué. Pour plus d'informations, consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
En outre, cette instruction nécessite les paramètres suivants :
+ **Condition de correspondance de taille** : indique l'opérateur de comparaison numérique à utiliser pour comparer la taille que vous fournissez avec le composant de demande que vous avez choisi. Choisissez l'opérateur dans la liste.
+ **Taille** : paramètre de taille, en octets, à utiliser dans la comparaison.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour **Type de correspondance**, sous **Condition de correspondance de taille**, choisissez la condition que vous souhaitez utiliser.
+ **API** — [SizeConstraintStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_SizeConstraintStatement.html)
# Instruction d'attaque par injection SQL de règle
Cette section explique ce qu'est une instruction de règle d'injection SQL et comment elle fonctionne.
Une instruction de règle d'injection SQL permet de détecter la présence de code SQL malveillant. Les attaquants insèrent du code SQL malveillant dans les requêtes Web afin de modifier votre base de données ou d'en extraire des données.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— Le coût de base dépend du niveau de sensibilité défini pour l'énoncé de règle : Low coûts 20 et High coûts 30.
Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs.
Ce type d'instruction fonctionne sur un composant de requête Web et nécessite les paramètres de composant de demande suivants :
+ **Composant de demande** : partie de la requête Web destinée à inspecter, par exemple, une chaîne de requête ou le corps de la requête.
**Avertissement**
Si vous inspectez les composants de la requête **Body**, **JSON body**, **Headers** ou **Cookies, renseignez-vous** sur les limites relatives à [Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md) la quantité de contenu AWS WAF pouvant être inspectée.
Pour plus d'informations sur les composants des requêtes Web, consultez[Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md).
+ Transformations de **texte facultatives : transformations** que vous AWS WAF souhaitez effectuer sur le composant de demande avant de l'inspecter. Par exemple, vous pouvez passer en minuscules ou normaliser les espaces blancs. Si vous spécifiez plusieurs transformations, AWS WAF traitez-les dans l'ordre indiqué. Pour plus d'informations, consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
En outre, cette instruction nécessite le réglage suivant :
+ **Niveau de sensibilité** : ce paramètre ajuste la sensibilité des critères de correspondance par injection SQL. Les options sont LOW et HIGH. Le paramètre par défaut est LOW.
Le HIGH paramètre détecte un plus grand nombre d'attaques par injection SQL et est le paramètre recommandé. En raison de la sensibilité accrue, ce paramètre génère davantage de faux positifs, en particulier si vos requêtes Web contiennent généralement des chaînes inhabituelles. Au cours du test et du réglage de votre pack de protection (ACL Web), vous devrez peut-être redoubler d'efforts pour limiter les faux positifs. Pour plus d'informations, consultez [Tester et ajuster vos AWS WAF protections](web-acl-testing.md).
La valeur la plus faible permet une détection des injections SQL moins rigoureuse, ce qui réduit également le nombre de faux positifs. LOWpeut être un meilleur choix pour les ressources dotées d'autres protections contre les attaques par injection de code SQL ou présentant une faible tolérance aux faux positifs.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour **Type de match**, choisissez **Attack match condition** > **Contient des attaques par injection SQL**.
+ **API** — [SqliMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_SqliMatchStatement.html)
# Instruction de correspondance de chaîne de règle
Cette section explique ce qu'est une instruction de correspondance de chaîne et comment elle fonctionne.
Une instruction de correspondance de chaîne indique la chaîne que vous AWS WAF souhaitez rechercher dans une demande, son emplacement dans la demande et le mode de recherche. Par exemple, vous pouvez rechercher une chaîne spécifique au début de n'importe quelle chaîne de requête de la demande ou comme correspondance exacte pour l'en-tête `User-agent` de la demande. Généralement, la chaîne est composée de caractères ASCII affichables, mais vous pouvez spécifier n'importe quel caractère de valeur hexadécimale 0x00 à 0xFF (valeur décimale 0 à 255).
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— Le coût de base dépend du type d'allumette que vous utilisez.
+ **Correspond exactement à la chaîne** — 2
+ **Commence par une chaîne** — 2
+ **Se termine par une ficelle** — 2
+ **Contient une chaîne** — 10
+ **Contient le mot** — 10
Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs.
Ce type d'instruction fonctionne sur un composant de requête Web et nécessite les paramètres de composant de demande suivants :
+ **Composant de demande** : partie de la requête Web destinée à inspecter, par exemple, une chaîne de requête ou le corps de la requête.
**Avertissement**
Si vous inspectez les composants de la requête **Body**, **JSON body**, **Headers** ou **Cookies, renseignez-vous** sur les limites relatives à [Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md) la quantité de contenu AWS WAF pouvant être inspectée.
Pour plus d'informations sur les composants des requêtes Web, consultez[Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md).
+ Transformations de **texte facultatives : transformations** que vous AWS WAF souhaitez effectuer sur le composant de demande avant de l'inspecter. Par exemple, vous pouvez passer en minuscules ou normaliser les espaces blancs. Si vous spécifiez plusieurs transformations, AWS WAF traitez-les dans l'ordre indiqué. Pour plus d'informations, consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
En outre, cette instruction nécessite les paramètres suivants :
+ **Chaîne à correspondre** : il s'agit de la chaîne que vous AWS WAF souhaitez comparer au composant de demande spécifié. Généralement, la chaîne est composée de caractères ASCII affichables, mais vous pouvez spécifier n'importe quel caractère de valeur hexadécimale 0x00 à 0xFF (valeur décimale 0 à 255).
+ **Condition de correspondance des chaînes** : indique le type de recherche que vous AWS WAF souhaitez effectuer.
+ **Correspond exactement à la chaîne** — La chaîne et la valeur du composant de requête sont identiques.
+ **Commence par une** chaîne — La chaîne apparaît au début du composant de demande.
+ **Se termine par une chaîne** — La chaîne apparaît à la fin du composant de demande.
+ **Contient une chaîne** — La chaîne apparaît n'importe où dans le composant de demande.
+ **Contient un mot** : la chaîne que vous spécifiez doit apparaître dans le composant de demande.
Pour cette option, les chaînes que vous spécifiez doivent contenir uniquement des caractères alphanumériques ou un trait de soulignement (A-Z, a-z, 0-9 ou \$1).
L'un des éléments suivants doit être vrai pour que la demande corresponde :
+ La chaîne correspond exactement à la valeur du composant de demande, telle que la valeur d'un en-tête.
+ La chaîne est au début du composant de demande et est suivie par un caractère autre qu'un caractère alphanumérique ou un soulignement (\$1) : par exemple, `BadBot;`.
+ La chaîne est à la fin du composant de demande et est suivie par un caractère autre qu'un caractère alphanumérique ou un soulignement (\$1) : par exemple, `;BadBot`.
+ La chaîne est au milieu du composant de demande et est précédée et suivie de caractères autre que des caractères alphanumériques ou de soulignement (\$1) : par exemple, `-BadBot;`.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour le **type Match**, choisissez **String match condition**, puis renseignez les chaînes que vous souhaitez comparer.
+ **API** — [ByteMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_ByteMatchStatement.html)
# Instruction d'attaque par scripts inter-site de règle
Cette section explique ce qu'est une instruction d'attaque XSS (cross-site scripting) et comment elle fonctionne.
Une instruction d'attaque XSS détecte la présence de scripts malveillants dans un composant de requête Web. Lors d'une attaque XSS, l'attaquant utilise les vulnérabilités d'un site Web bénin pour injecter des scripts de site client malveillants dans d'autres navigateurs Web légitimes.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— 40 WCUs, comme coût de base. Si vous utilisez le composant de **requête Tous les paramètres de requête**, ajoutez 10 WCUs. Si vous utilisez le **corps JSON** du composant de requête, doublez le coût de base WCUs. Pour chaque **transformation de texte** que vous appliquez, ajoutez 10 WCUs.
Ce type d'instruction fonctionne sur un composant de requête Web et nécessite les paramètres de composant de demande suivants :
+ **Composant de demande** : partie de la requête Web destinée à inspecter, par exemple, une chaîne de requête ou le corps de la requête.
**Avertissement**
Si vous inspectez les composants de la requête **Body**, **JSON body**, **Headers** ou **Cookies, renseignez-vous** sur les limites relatives à [Composants de requête Web surdimensionnés dans AWS WAF](waf-oversize-request-components.md) la quantité de contenu AWS WAF pouvant être inspectée.
Pour plus d'informations sur les composants des requêtes Web, consultez[Réglage des paramètres des instructions de règle dans AWS WAF](waf-rule-statement-fields.md).
+ Transformations de **texte facultatives : transformations** que vous AWS WAF souhaitez effectuer sur le composant de demande avant de l'inspecter. Par exemple, vous pouvez passer en minuscules ou normaliser les espaces blancs. Si vous spécifiez plusieurs transformations, AWS WAF traitez-les dans l'ordre indiqué. Pour plus d'informations, consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur console : pour le **type de match**, choisissez **Condition de match d'attaque** > **Contient des attaques par injection XSS**.
+ **API** — [XssMatchStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_XssMatchStatement.html)
# Utilisation d'instructions de règles logiques dans AWS WAF
Cette section explique ce qu'est une déclaration de règle logique et comment elle fonctionne.
Utilisez des instructions de règles logiques pour combiner d'autres instructions ou annuler leurs résultats. Chaque instruction de règle logique prend au moins une instruction imbriquée.
Pour combiner ou annuler de manière logique les résultats des instructions de règle, vous imbriquez les instructions sous des instructions de règles logiques.
Les déclarations de règles logiques sont imbriquables. Vous pouvez les imbriquer dans d'autres instructions de règles logiques et les utiliser dans des instructions de portée réduite. Pour plus d'informations sur les instructions de portée réduite, consultez. [Utilisation d'instructions scope-down dans AWS WAF](waf-rule-scope-down-statements.md)
**Note**
L'éditeur visuel de la console prend en charge un niveau d'imbrication des instructions de règle, ce qui fonctionne pour de nombreux besoins. Pour imbriquer davantage de niveaux, modifiez la représentation JSON de la règle sur la console ou utilisez le APIs.
Ce tableau décrit les instructions de règles logiques et fournit des directives pour calculer l'utilisation des unités de capacité (WCU) du pack de protection (ACL Web) pour chacune d'elles. Pour plus d'informations sur WCUs, voir[Unités de capacité Web ACL (WCUs) en AWS WAF](aws-waf-capacity-units.md).
| Instruction logique | Description | WCUs |
| --- | --- | --- |
| [Logique AND](waf-rule-statement-type-and.md) | Combine des instructions imbriquées avec la AND logique. | Basé sur des instructions imbriquées |
| [Logique NOT](waf-rule-statement-type-not.md) | Annule les résultats d'une instruction imbriquée. | Basé sur une instruction imbriquée |
| [Logique OR](waf-rule-statement-type-or.md) | Combine des instructions imbriquées avec la OR logique. | Basé sur des instructions imbriquées |
# ANDdéclaration de règle
L'instruction de AND règle combine des instructions imbriquées avec une AND opération logique, de sorte que toutes les instructions imbriquées doivent correspondre pour que l'ANDinstruction corresponde. Cela nécessite au moins deux instructions imbriquées.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— Cela dépend des instructions imbriquées.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour **Si une demande**, choisissez **correspond à toutes les instructions (ET)**, puis complétez les instructions imbriquées.
+ **API** — [AndStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_AndStatement.html)
## Exemples
La liste suivante montre l'utilisation d'instructions AND de règles NOT logiques pour éliminer les faux positifs des correspondances pour une instruction d'attaque par injection SQL. Pour cet exemple, supposons que nous puissions écrire une instruction de correspondance d'un octet pour répondre aux demandes qui génèrent des faux positifs.
L'instruction AND correspond aux demandes qui ne correspondent pas à l'instruction de correspondance d'octets et qui correspondent à l'instruction d'attaque par injection SQL.
```
{
"Name": "SQLiExcludeFalsePositives",
"Priority": 0,
"Statement": {
"AndStatement": {
"Statements": [
{
"NotStatement": {
"Statement": {
"ByteMatchStatement": {
"SearchString": "string identifying a false positive",
"FieldToMatch": {
"Body": {
"OversizeHandling": "MATCH"
}
},
"TextTransformations": [
{
"Priority": 0,
"Type": "NONE"
}
],
"PositionalConstraint": "CONTAINS"
}
}
}
},
{
"SqliMatchStatement": {
"FieldToMatch": {
"Body": {
"OversizeHandling": "MATCH"
}
},
"TextTransformations": [
{
"Priority": 0,
"Type": "NONE"
}
]
}
}
]
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "SQLiExcludeFalsePositives"
}
}
```
À l'aide de l'éditeur visuel de règles de console, vous pouvez imbriquer une instruction non logique ou une NOT instruction sous une AND instruction OR or. L'imbrication de l'NOTinstruction est illustrée dans l'exemple précédent.
À l'aide de l'éditeur visuel de règles de console, vous pouvez imbriquer la plupart des instructions imbriquables dans une instruction de règle logique, telle que celle illustrée dans l'exemple précédent. Vous ne pouvez pas utiliser l'éditeur visuel pour imbriquer OR des AND instructions. Pour configurer ce type d'imbrication, vous devez fournir votre déclaration de règle au format JSON. Par exemple, la liste de règles JSON suivante inclut une OR instruction imbriquée dans une AND instruction.
```
{
"Name": "match_rule",
"Priority": 0,
"Statement": {
"AndStatement": {
"Statements": [
{
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:managed:aws:bot-control:bot:category:monitoring"
}
},
{
"NotStatement": {
"Statement": {
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:managed:aws:bot-control:bot:name:pingdom"
}
}
}
},
{
"OrStatement": {
"Statements": [
{
"GeoMatchStatement": {
"CountryCodes": [
"JM",
"JP"
]
}
},
{
"ByteMatchStatement": {
"SearchString": "JCountryString",
"FieldToMatch": {
"Body": {}
},
"TextTransformations": [
{
"Priority": 0,
"Type": "NONE"
}
],
"PositionalConstraint": "CONTAINS"
}
}
]
}
}
]
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "match_rule"
}
}
```
# NOTdéclaration de règle
L'instruction de NOT règle annule logiquement les résultats d'une seule instruction imbriquée, de sorte que les instructions imbriquées ne doivent pas correspondre pour que l'NOTinstruction corresponde, et vice versa. Cela nécessite une instruction imbriquée.
Par exemple, si vous souhaitez bloquer les demandes qui ne proviennent pas d'un pays spécifique, créez une NOT déclaration dont l'action est définie pour bloquer et imbriquez une déclaration de correspondance géographique spécifiant le pays.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— Cela dépend de l'instruction imbriquée.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour **Si une demande**, choisissez **ne correspond pas à l'instruction (NOT)**, puis renseignez l'instruction imbriquée.
+ **API** — [NotStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_NotStatement.html)
# ORdéclaration de règle
L'instruction de OR règle combine des instructions imbriquées avec de OR la logique, de sorte que l'une des instructions imbriquées doit correspondre pour que l'ORinstruction corresponde. Cela nécessite au moins deux instructions imbriquées.
Par exemple, si vous souhaitez bloquer les demandes provenant d'un pays spécifique ou contenant une chaîne de requête spécifique, vous pouvez créer une OR instruction et y imbriquer une instruction de correspondance géographique pour le pays et une instruction de correspondance de chaîne pour la chaîne de requête.
Si vous souhaitez plutôt bloquer les demandes qui *ne proviennent pas* d'un pays spécifique ou qui contiennent une chaîne de requête spécifique, vous devez modifier l'ORinstruction précédente pour imbriquer l'instruction de correspondance géographique un niveau plus bas, à l'intérieur d'une NOT instruction. Ce niveau d'imbrication nécessite que vous utilisiez le format JSON, car la console ne prend en charge qu'un seul niveau d'imbrication.
## Caractéristiques de l'énoncé des règles
**Imbriquable** : vous pouvez imbriquer ce type de déclaration.
**WCUs**— Cela dépend des instructions imbriquées.
## Où trouver cette déclaration de règle
+ **Générateur de règles** sur la console : pour **Si une demande**, choisissez **correspond à au moins une des instructions (OR)**, puis renseignez les instructions imbriquées.
+ **API** — [OrStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_OrStatement.html)
**Exemples**
La liste suivante montre l'utilisation de OR pour combiner deux autres instructions. L'ORinstruction correspond si l'une des instructions imbriquées correspond.
```
{
"Name": "neitherOfTwo",
"Priority": 1,
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "neitherOfTwo"
},
"Statement": {
"OrStatement": {
"Statements": [
{
"GeoMatchStatement": {
"CountryCodes": [
"CA"
]
}
},
{
"IPSetReferenceStatement": {
"ARN": "arn:aws:wafv2:us-east-1:111111111111:regional/ipset/test-ip-set-22222222/33333333-4444-5555-6666-777777777777"
}
}
]
}
}
}
```
À l'aide de l'éditeur visuel de règles de console, vous pouvez imbriquer la plupart des instructions imbriquables dans une instruction de règle logique, mais vous ne pouvez pas utiliser l'éditeur visuel pour imbriquer OR des AND instructions. Pour configurer ce type d'imbrication, vous devez fournir votre déclaration de règle au format JSON. Par exemple, la liste de règles JSON suivante inclut une OR instruction imbriquée dans une AND instruction.
```
{
"Name": "match_rule",
"Priority": 0,
"Statement": {
"AndStatement": {
"Statements": [
{
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:managed:aws:bot-control:bot:category:monitoring"
}
},
{
"NotStatement": {
"Statement": {
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:managed:aws:bot-control:bot:name:pingdom"
}
}
}
},
{
"OrStatement": {
"Statements": [
{
"GeoMatchStatement": {
"CountryCodes": [
"JM",
"JP"
]
}
},
{
"ByteMatchStatement": {
"SearchString": "JCountryString",
"FieldToMatch": {
"Body": {}
},
"TextTransformations": [
{
"Priority": 0,
"Type": "NONE"
}
],
"PositionalConstraint": "CONTAINS"
}
}
]
}
}
]
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "match_rule"
}
}
```
# Utilisation d'instructions de règles basées sur le taux dans AWS WAF
Cette section explique ce qu'est une déclaration de règle basée sur le taux et comment elle fonctionne.
Une règle basée sur le taux compte les demandes entrantes et limite le débit des demandes lorsqu'elles arrivent trop rapidement. La règle agrège les demandes en fonction de vos critères, et compte et limite le taux des groupements agrégés, en fonction de la fenêtre d'évaluation, de la limite de demandes et des paramètres d'action de la règle.
**Note**
Vous pouvez également limiter le débit des requêtes Web en utilisant le niveau de protection ciblé du groupe de règles AWS gérées par Bot Control. L'utilisation de ce groupe de règles géré entraîne des frais supplémentaires. Pour de plus amples informations, veuillez consulter [Options de limitation du débit dans les règles basées sur les taux et dans les règles de contrôle des bots ciblées](waf-rate-limiting-options.md).
AWS WAF suit et gère les requêtes Web séparément pour chaque instance d'une règle basée sur le taux que vous utilisez. Par exemple, si vous fournissez les mêmes paramètres de règle basés sur le taux sur deux sites WebACLs, chacune des deux instructions de règle représente une instance distincte de la règle basée sur le taux et chacune bénéficie de son propre suivi et de sa propre gestion par. AWS WAF Si vous définissez une règle basée sur les taux au sein d'un groupe de règles, puis que vous utilisez ce groupe de règles à plusieurs endroits, chaque utilisation crée une instance distincte de la règle basée sur les taux qui fait l'objet de son propre suivi et de sa propre gestion. AWS WAF
**Non imbriquable** : vous ne pouvez pas imbriquer ce type d'instruction dans d'autres instructions. Vous pouvez l'inclure directement dans un pack de protection (ACL Web) ou un groupe de règles.
Instruction de **portée réduite** : ce type de règle peut adopter une instruction de portée réduite, afin de réduire la portée des demandes suivies par la règle et les limites de débit. L'instruction scope-down peut être facultative ou obligatoire, en fonction de vos autres paramètres de configuration des règles. Les détails sont présentés dans cette section. Pour des informations générales sur les instructions de portée réduite, consultez. [Utilisation d'instructions scope-down dans AWS WAF](waf-rule-scope-down-statements.md)
**WCUs**— 2, comme coût de base. Pour chaque clé d'agrégation personnalisée que vous spécifiez, ajoutez 30 WCUs. Si vous utilisez une instruction scope-down dans la règle, calculez et ajoutez l' WCUs instruction correspondante.
**Où trouver cette déclaration de règle**
+ **Générateur de règles** dans votre pack de protection (ACL Web), sur la console : sous **Règle**, pour **Type**, choisissez **Règle basée sur le taux**.
+ **API** — [RateBasedStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_RateBasedStatement.html)
**Topics**
+ [Paramètres de haut niveau des règles basées sur le taux dans AWS WAF](waf-rule-statement-type-rate-based-high-level-settings.md)
+ [Mises en garde relatives aux règles basées sur les taux dans AWS WAF](waf-rule-statement-type-rate-based-caveats.md)
+ [Agrégation des règles basées sur les taux dans AWS WAF](waf-rule-statement-type-rate-based-aggregation-options.md)
+ [Instances et nombres d'agrégation de règles basés sur le taux](waf-rule-statement-type-rate-based-aggregation-instances.md)
+ [Appliquer une limite de débit aux demandes en AWS WAF](waf-rule-statement-type-rate-based-request-limiting.md)
+ [Exemples de règles basées sur le taux dans AWS WAF](waf-rule-statement-type-rate-based-examples.md)
+ [Répertorier les adresses IP dont le débit est limité par des règles basées sur le débit](listing-managed-ips.md)
# Paramètres de haut niveau des règles basées sur le taux dans AWS WAF
Une instruction de règle basée sur le taux utilise les paramètres de haut niveau suivants :
+ **Fenêtre d'évaluation** : durée, en secondes, à AWS WAF inclure dans le nombre de demandes, si l'on considère l'heure actuelle. Par exemple, pour un paramètre de 120, lorsque AWS WAF le taux est vérifié, il compte les demandes pendant les 2 minutes précédant immédiatement l'heure actuelle. Les paramètres valides sont 60 (1 minute), 120 (2 minutes), 300 (5 minutes) et 600 (10 minutes), et 300 (5 minutes) est la valeur par défaut.
Ce paramètre ne détermine pas la fréquence AWS WAF à laquelle le taux est vérifié, mais la distance parcourue à chaque vérification. AWS WAF vérifie le taux fréquemment, avec un calendrier indépendant du réglage de la fenêtre d'évaluation.
+ **Limite de taux** : nombre maximum de demandes correspondant à vos critères qui AWS WAF doivent être suivies pendant la période d'évaluation spécifiée. La limite minimale autorisée est 10. Lorsque cette limite est dépassée, AWS WAF applique le paramètre d'action de la règle aux demandes supplémentaires correspondant à vos critères.
AWS WAF applique une limite de débit proche de la limite que vous avez définie, mais ne garantit pas une correspondance exacte entre les limites. Pour de plus amples informations, veuillez consulter [Mises en garde relatives aux règles basées sur les taux](waf-rule-statement-type-rate-based-caveats.md).
+ **Agrégation des demandes** : les critères d'agrégation à utiliser sur le Web demandent que la règle basée sur le taux compte et limite le débit. La limite de débit que vous définissez s'applique à chaque instance d'agrégation. Pour plus d’informations, consultez [Agrégation des règles basées sur les taux](waf-rule-statement-type-rate-based-aggregation-options.md) et [Instances d'agrégation et nombres](waf-rule-statement-type-rate-based-aggregation-instances.md).
+ **Action : action** à effectuer en réponse aux demandes dont le taux est limité par la règle. Vous pouvez utiliser n'importe quelle action de règle, saufAllow. Ceci est défini au niveau de la règle, comme d'habitude, mais comporte certaines restrictions et certains comportements spécifiques aux règles basées sur les taux. Pour des informations générales sur les actions relatives aux règles, consultez[Utilisation des actions liées aux règles dans AWS WAF](waf-rule-action.md). Pour des informations spécifiques à la limitation du débit, consultez [Appliquer une limite de débit aux demandes en AWS WAF](waf-rule-statement-type-rate-based-request-limiting.md) cette section.
+ **Étendue de l'inspection et limitation du débit** : vous pouvez réduire la portée des demandes suivies par le relevé basé sur les taux et les limites de taux en ajoutant un relevé de portée inférieure. Si vous spécifiez une instruction scope-down, la règle agrège, compte et limite le débit uniquement les demandes qui correspondent à l'instruction scope-down. Si vous choisissez l'option d'agrégation des demandes **Count all**, l'instruction scope-down est requise. Pour plus d'informations sur les instructions de portée réduite, consultez. [Utilisation d'instructions de portée réduite](waf-rule-scope-down-statements.md)
+ **(Facultatif) Configuration IP transférée** : elle n'est utilisée que si vous spécifiez l'**adresse IP dans l'en-tête** de votre agrégation de demandes, soit seule, soit dans le cadre des paramètres de clés personnalisés. AWS WAF récupère la première adresse IP dans l'en-tête spécifié et l'utilise comme valeur d'agrégation. Un en-tête courant est utilisé à cette fin`X-Forwarded-For`, mais vous pouvez spécifier n'importe quel en-tête. Pour de plus amples informations, veuillez consulter [Utilisation d'adresses IP transférées](waf-rule-statement-forwarded-ip-address.md).
# Mises en garde relatives aux règles basées sur les taux dans AWS WAF
Cette section répertorie les mises en garde relatives à l'utilisation de règles basées sur les taux.
AWS WAF la limitation du débit est conçue pour contrôler les taux de demandes élevés et protéger la disponibilité de votre application de la manière la plus efficace possible. Il n'est pas destiné à une limitation précise du taux de demandes.
+ AWS WAF estime le taux de demandes actuel à l'aide d'un algorithme qui accorde plus d'importance aux demandes les plus récentes. Pour cette raison, AWS WAF appliquera une limite de taux proche de la limite que vous avez définie, mais cela ne garantit pas une correspondance exacte entre les limites.
+ Chaque fois que le taux de demandes est AWS WAF estimé, AWS WAF il revient sur le nombre de demandes reçues pendant la fenêtre d'évaluation configurée. En raison de cela et d'autres facteurs tels que les délais de propagation, il est possible que les demandes arrivent à un rythme trop élevé pendant plusieurs minutes avant de les AWS WAF détecter et de les limiter. De même, le taux de demandes peut être inférieur à la limite pendant un certain temps avant de AWS WAF détecter la diminution et d'interrompre l'action de limitation du débit. Ce délai est généralement inférieur à 30 secondes.
+ Si vous modifiez l'un des paramètres de limite de débit d'une règle en cours d'utilisation, la modification réinitialise le nombre de limites de débit de la règle. Cela peut suspendre les activités de limitation de débit prévues par la règle pendant une minute au maximum. Les paramètres de limite de débit sont la fenêtre d'évaluation, la limite de débit, les paramètres d'agrégation des demandes, la configuration IP transférée et l'étendue de l'inspection.
# Agrégation des règles basées sur les taux dans AWS WAF
Cette section explique les options qui s'offrent à vous pour agréger les demandes.
Par défaut, une règle basée sur le débit agrège et limite les demandes en fonction de l'adresse IP de la demande. Vous pouvez configurer la règle pour utiliser diverses autres clés d'agrégation et combinaisons de touches. Par exemple, vous pouvez agréger en fonction d'une adresse IP transférée, de la méthode HTTP ou d'un argument de requête. Vous pouvez également spécifier des combinaisons de clés d'agrégation, telles que l'adresse IP et la méthode HTTP, ou les valeurs de deux cookies différents.
**Note**
Tous les composants de demande que vous spécifiez dans la clé d'agrégation doivent être présents dans une requête Web pour que la demande soit évaluée ou que le taux soit limité par la règle.
Vous pouvez configurer votre règle basée sur le taux avec les options d'agrégation suivantes.
+ **Adresse IP source** : agrégée en utilisant uniquement l'adresse IP de l'origine de la requête Web.
L'adresse IP source peut ne pas contenir l'adresse du client d'origine. Si une requête Web passe par un ou plusieurs proxys ou équilibreurs de charge, celle-ci contiendra l'adresse du dernier proxy.
+ **Adresse IP dans l'en-tête** : agrégation en utilisant uniquement une adresse client dans un en-tête HTTP. Cette adresse est également appelée adresse IP transférée.
Avec cette configuration, vous spécifiez également un comportement de secours à appliquer à une requête Web dont l'en-tête contient une adresse IP mal formée. Le comportement de remplacement définit le résultat correspondant à la demande, qu'il corresponde ou non. En cas d'absence de correspondance, la règle basée sur le taux ne compte pas ou ne limite pas le taux de la demande. Pour la correspondance, la règle basée sur le taux regroupe la demande avec les autres demandes dont l'adresse IP est mal formée dans l'en-tête spécifié.
Soyez prudent avec cette option, car les en-têtes peuvent être gérés de manière incohérente par les proxys et ils peuvent également être modifiés pour contourner l'inspection. Pour plus d'informations et les meilleures pratiques, consultez[Utilisation des adresses IP transférées dans AWS WAF](waf-rule-statement-forwarded-ip-address.md).
+ **ASN** — Agrégation à l'aide d'un numéro de système autonome (ASN) associé à l'adresse IP source en tant que clé agrégée. Il ne s'agit peut-être pas de l'adresse du client d'origine. Si une requête Web passe par un ou plusieurs proxys ou équilibreurs de charge, celle-ci contient l'adresse du dernier proxy.
S'il n'est pas AWS WAF possible de dériver un ASN à partir de l'adresse IP, il compte l'ASN comme un ASN 0. Si vous ne souhaitez pas appliquer de limitation de débit aux applications non mappées ASNs, vous pouvez créer une règle de délimitation qui exclut les demandes dont l'ASN est 0.
+ **ASN dans l'en-tête** : agrégation à l'aide d'un ASN associé à l'adresse IP d'un client dans un en-tête HTTP. Cette adresse est également appelée adresse IP transférée. Avec cette configuration, vous spécifiez également un comportement de secours à appliquer à une requête Web dont l'adresse IP n'est pas valide ou est mal formée. Le comportement de remplacement définit le résultat correspondant à la demande, qu'il corresponde ou non. Si vous définissez le comportement de secours pour qu'il corresponde à la configuration IP transférée, AWS WAF traite l'adresse IP non valide comme une valeur correspondante. Cela permet AWS WAF de continuer à évaluer les parties restantes de la clé composite de votre règle basée sur les taux. En cas d'absence de correspondance, la règle basée sur le taux ne compte pas ou ne limite pas le taux de la demande.
Soyez prudent avec cette option, car les en-têtes peuvent être gérés de manière incohérente par les proxys et ils peuvent être modifiés pour contourner l'inspection. Pour plus d'informations et les meilleures pratiques, consultez[Utilisation des adresses IP transférées dans AWS WAF](waf-rule-statement-forwarded-ip-address.md).
+ **Tout compter** : comptez et limitez le débit de toutes les demandes qui correspondent à l'énoncé de portée réduite de la règle. Cette option nécessite une instruction scope-down. Ceci est généralement utilisé pour limiter le débit d'un ensemble spécifique de demandes, telles que toutes les demandes portant une étiquette spécifique ou toutes les demandes provenant d'une zone géographique spécifique.
+ **Clés personnalisées** : agrégation à l'aide d'une ou de plusieurs clés d'agrégation personnalisées. Pour combiner l'une des options d'adresse IP avec d'autres clés d'agrégation, définissez-les ici sous Clés personnalisées.
Les clés d'agrégation personnalisées sont un sous-ensemble des options des composants de demande Web décrites sur[Demandez des composants dans AWS WAF](waf-rule-statement-fields-list.md).
Les principales options sont les suivantes. Sauf indication contraire, vous pouvez utiliser une option plusieurs fois, par exemple deux en-têtes ou trois espaces de noms d'étiquettes.
+ **Espace de noms d'étiquettes** : utilisez un espace de noms d'étiquettes comme clé d'agrégation. Chaque nom d'étiquette complet distinct qui possède l'espace de noms d'étiquette spécifié contribue à l'instance d'agrégation. Si vous utilisez un seul espace de noms d'étiquette comme clé personnalisée, chaque nom d'étiquette définit entièrement une instance d'agrégation.
La règle basée sur le taux utilise uniquement les étiquettes qui ont été ajoutées à la demande par des règles préalablement évaluées dans le pack de protection (ACL Web).
Pour plus d'informations sur les espaces de noms et les noms d'étiquettes, consultez[Syntaxe des étiquettes et exigences de dénomination dans AWS WAF](waf-rule-label-requirements.md).
+ **En-tête** : utilisez un en-tête nommé comme clé d'agrégation. Chaque valeur distincte de l'en-tête contribue à l'instance d'agrégation.
L'en-tête nécessite une transformation de texte facultative. Consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
+ **Cookie** : utilisez un cookie nommé comme clé d'agrégation. Chaque valeur distincte du cookie contribue à l'instance d'agrégation.
Le cookie effectue une transformation de texte facultative. Consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
+ **Argument de requête** : utilisez un seul argument de requête dans la demande comme clé d'agrégation. Chaque valeur distincte pour l'argument de requête nommé contribue à l'instance d'agrégation.
L'argument Query accepte une transformation de texte facultative. Consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
+ **Chaîne de requête** : utilisez l'intégralité de la chaîne de requête de la demande comme clé agrégée. Chaque chaîne de requête distincte contribue à l'instance d'agrégation. Vous ne pouvez utiliser ce type de clé qu'une seule fois.
La chaîne de requête accepte une transformation de texte facultative. Consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
+ **Chemin de l'URI** — Utilisez le chemin de l'URI dans la demande comme clé agrégée. Chaque chemin d'URI distinct contribue à l'instance d'agrégation. Vous ne pouvez utiliser ce type de clé qu'une seule fois.
Le chemin de l'URI effectue une transformation de texte facultative. Consultez [Utilisation de transformations de texte dans AWS WAF](waf-rule-statement-transformation.md).
+ **JA3 empreinte digitale** — Utilisez l' JA3 empreinte digitale de la demande comme clé agrégée. Chaque JA3 empreinte digitale distincte contribue à l'instance d'agrégation. Vous ne pouvez utiliser ce type de clé qu'une seule fois.
+ **JA4 empreinte digitale** — Utilisez l' JA4 empreinte digitale de la demande comme clé agrégée. Chaque JA4 empreinte digitale distincte contribue à l'instance d'agrégation. Vous ne pouvez utiliser ce type de clé qu'une seule fois.
+ **Méthode HTTP** : utilisez la méthode HTTP de la demande comme clé d'agrégation. Chaque méthode HTTP distincte contribue à l'instance d'agrégation. Vous ne pouvez utiliser ce type de clé qu'une seule fois.
+ **Adresse IP** : agrégation à l'aide de l'adresse IP provenant de l'origine de la demande Web en combinaison avec d'autres clés.
Il se peut qu'il ne contienne pas l'adresse du client d'origine. Si une requête Web passe par un ou plusieurs proxys ou équilibreurs de charge, celle-ci contiendra l'adresse du dernier proxy.
+ **Adresse IP dans l'en-tête** — Agrégez en utilisant l'adresse du client dans un en-tête HTTP en combinaison avec d'autres clés. Cette adresse est également appelée adresse IP transférée.
Soyez prudent avec cette option, car les en-têtes peuvent être gérés de manière incohérente par les proxys et ils peuvent être modifiés pour contourner l'inspection. Pour plus d'informations et les meilleures pratiques, consultez[Utilisation des adresses IP transférées dans AWS WAF](waf-rule-statement-forwarded-ip-address.md).
# Instances et nombres d'agrégation de règles basés sur le taux
Cette section explique comment une règle basée sur le taux évalue les requêtes Web.
Lorsqu'une règle basée sur le taux évalue les requêtes Web à l'aide de vos critères d'agrégation, chaque ensemble unique de valeurs trouvé par la règle pour les clés d'agrégation spécifiées définit une instance d'*agrégation* unique.
+ **Clés multiples** : si vous avez défini plusieurs clés personnalisées, la valeur de chaque clé contribue à la définition de l'instance d'agrégation. Chaque combinaison unique de valeurs définit une instance d'agrégation.
+ **Clé unique** : si vous avez choisi une seule clé, soit dans les clés personnalisées, soit en sélectionnant l'une des adresses IP singleton, chaque valeur unique de la clé définit une instance d'agrégation.
+ **Tout compter, aucune clé** : si vous avez sélectionné l'option d'agrégation **Tout compter**, toutes les demandes évaluées par la règle appartiennent à une seule instance d'agrégation pour la règle. Ce choix nécessite une instruction scope-down.
Une règle basée sur le taux compte les requêtes Web séparément pour chaque instance d'agrégation qu'elle identifie.
Supposons, par exemple, qu'une règle basée sur le débit évalue les requêtes Web avec l'adresse IP et les valeurs de méthode HTTP suivantes :
+ Adresse IP 10.1.1.1, méthode HTTP POST
+ Adresse IP 10.1.1.1, méthode HTTP GET
+ Adresse IP 127.0.0.0, méthode HTTP POST
+ Adresse IP 10.1.1.1, méthode HTTP GET
La règle crée différentes instances d'agrégation en fonction de vos critères d'agrégation.
+ Si le critère d'agrégation est uniquement l'adresse IP, chaque adresse IP individuelle est une instance d'agrégation et AWS WAF compte les demandes séparément pour chacune d'entre elles. Dans notre exemple, les instances d'agrégation et le nombre de demandes seraient les suivants :
+ Adresse IP 10.1.1.1 : compte 3
+ Adresse IP 127.0.0.0 : compte 1
+ Si le critère d'agrégation est la méthode HTTP, chaque méthode HTTP individuelle est une instance d'agrégation. Dans notre exemple, les instances d'agrégation et le nombre de demandes seraient les suivants :
+ Méthode HTTP POST : compte 2
+ Méthode HTTP GET : count 2
+ Si les critères d'agrégation sont l'adresse IP et la méthode HTTP, chaque adresse IP et chaque méthode HTTP contribueront à l'instance d'agrégation combinée. Dans notre exemple, les instances d'agrégation et le nombre de demandes seraient les suivants :
+ Adresse IP 10.1.1.1, méthode HTTP POST : compte 1
+ Adresse IP 10.1.1.1, méthode HTTP GET : count 2
+ Adresse IP 127.0.0.0, méthode HTTP POST : compte 1
# Appliquer une limite de débit aux demandes en AWS WAF
Cette section explique comment fonctionne le comportement de limitation de débit pour les règles basées sur le débit.
Les critères AWS WAF utilisés pour limiter le débit des demandes pour une règle basée sur le taux sont les mêmes que ceux AWS WAF utilisés pour agréger les demandes relatives à la règle. Si vous définissez une instruction de portée réduite pour la règle, AWS WAF seuls les agrégats, les dénombrements et les demandes de limite de débit correspondent à l'instruction de portée réduite.
Les critères de correspondance qui amènent une règle basée sur le taux à appliquer ses paramètres d'action de règle à une requête Web spécifique sont les suivants :
+ La requête Web correspond à l'instruction scope-down de la règle, si une telle instruction est définie.
+ La requête Web appartient à une instance d'agrégation dont le nombre de demandes est actuellement supérieur à la limite fixée par la règle.
**Comment AWS WAF s'applique l'action de la règle**
Lorsqu'une règle basée sur le taux applique une limitation de débit à une demande, elle applique l'action de la règle et, si vous avez défini un traitement ou un étiquetage personnalisé dans votre spécification d'action, la règle les applique. Cette gestion des demandes est identique à la manière dont une règle de correspondance applique ses paramètres d'action aux requêtes Web correspondantes. Une règle basée sur le taux applique uniquement des libellés ou exécute d'autres actions sur les demandes pour lesquelles elle limite activement le débit.
Vous pouvez utiliser n'importe quelle action de règle, à l'exception deAllow. Pour des informations générales sur les actions relatives aux règles, consultez[Utilisation des actions liées aux règles dans AWS WAF](waf-rule-action.md).
La liste suivante décrit le fonctionnement de la limitation de débit pour chacune des actions.
+ **Block**— AWS WAF bloque la demande et applique tout comportement de blocage personnalisé que vous avez défini.
+ **Count**— AWS WAF compte la demande, applique les en-têtes ou étiquettes personnalisés que vous avez définis et poursuit l'évaluation de la demande par le pack de protection (ACL Web).
Cette action ne limite pas le nombre de demandes. Il ne compte que les demandes qui dépassent la limite.
+ **CAPTCHAor Challenge** — AWS WAF gère la demande comme a Block ou comme aCount, selon l'état du jeton de la demande.
Cette action ne limite pas le nombre de demandes contenant des jetons valides. Cela limite le taux de demandes dépassant la limite et pour lesquelles il manque également des jetons valides.
+ Si la demande ne contient pas de jeton valide et non expiré, l'action bloque la demande et renvoie le casse-tête CAPTCHA ou le défi du navigateur au client.
Si l'utilisateur final ou le navigateur du client répond correctement, le client reçoit un jeton valide et renvoie automatiquement la demande initiale. Si la limitation du débit pour l'instance d'agrégation est toujours en vigueur, l'action sera appliquée à cette nouvelle demande contenant le jeton valide et non expiré, comme décrit dans le point suivant de la bullet.
+ Si la demande contient un jeton valide et non expiré, l'Challengeaction CAPTCHA ou vérifie le jeton et n'entreprend aucune action sur la demande, de la même manière que l'Countaction. La règle basée sur le taux renvoie l'évaluation de la demande au pack de protection (ACL Web) sans prendre aucune mesure de résiliation, et le pack de protection (ACL Web) poursuit son évaluation de la demande.
Pour plus d’informations, consultez [CAPTCHAet Challenge dans AWS WAF](waf-captcha-and-challenge.md).
**Si vous limitez le débit uniquement à l'adresse IP ou à l'adresse IP transférée**
Lorsque vous configurez la règle pour limiter uniquement le débit de l'adresse IP pour l'adresse IP transférée, vous pouvez récupérer la liste des adresses IP pour lesquelles la règle limite actuellement le débit. Si vous utilisez une instruction scope-down, les demandes dont le débit est limité sont uniquement celles de la liste d'adresses IP qui correspondent à l'instruction scope-down. Pour plus d'informations sur la récupération de la liste d'adresses IP, consultez[Répertorier les adresses IP dont le débit est limité par des règles basées sur le débit](listing-managed-ips.md).
# Exemples de règles basées sur le taux dans AWS WAF
Cette section décrit des exemples de configuration pour divers cas d'utilisation courants de règles basées sur les taux.
Chaque exemple fournit une description du cas d'utilisation, puis montre la solution dans les listes JSON pour les règles configurées personnalisées.
**Note**
Les listes JSON présentées dans ces exemples ont été créées dans la console en configurant la règle, puis en la modifiant à l'aide de l'**éditeur Rule JSON**.
**Topics**
+ [Limiter le débit des demandes à une page de connexion](waf-rate-based-example-limit-login-page.md)
+ [Débit : limite les demandes adressées à une page de connexion à partir de n'importe quelle adresse IP ou paire d'agents utilisateurs](waf-rate-based-example-limit-login-page-keys.md)
+ [Limite de débit les demandes pour lesquelles il manque un en-tête spécifique](waf-rate-based-example-limit-missing-header.md)
+ [Débit : limitez les demandes avec des étiquettes spécifiques](waf-rate-based-example-limit-labels.md)
+ [Limite de débit les demandes d'étiquettes ayant un espace de noms d'étiquette spécifié](waf-rate-based-example-limit-label-aggregation.md)
+ [Débit : limitez les demandes avec des ASNs](waf-rate-based-example-limit-asn.md)
# Limiter le débit des demandes à une page de connexion
**Pour limiter le nombre de demandes adressées à la page de connexion de votre site Web sans affecter le trafic vers le reste de votre site, vous pouvez créer une règle basée sur le taux avec une instruction de délimitation qui fait correspondre les demandes à votre page de connexion et avec l'agrégation des demandes définie sur Tout compter.**
La règle basée sur le taux comptera toutes les demandes pour la page de connexion dans une seule instance d'agrégation et appliquera l'action de la règle à toutes les demandes correspondant à l'instruction scope-down lorsque les demandes dépassent la limite.
La liste JSON suivante montre un exemple de cette configuration de règle. L'option d'agrégation Count All est répertoriée dans le JSON en tant que paramètre`CONSTANT`. Cet exemple correspond aux pages de connexion qui commencent par`/login`.
```
{
"Name": "test-rbr",
"Priority": 0,
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-rbr"
},
"Statement": {
"RateBasedStatement": {
"Limit": 1000,
"EvaluationWindowSec": 300,
"AggregateKeyType": "CONSTANT",
"ScopeDownStatement": {
"ByteMatchStatement": {
"FieldToMatch": {
"UriPath": {}
},
"PositionalConstraint": "STARTS_WITH",
"SearchString": "/login",
"TextTransformations": [
{
"Type": "NONE",
"Priority": 0
}
]
}
}
}
}
}
```
# Débit : limite les demandes adressées à une page de connexion à partir de n'importe quelle adresse IP ou paire d'agents utilisateurs
Pour limiter le nombre de demandes d'adresse IP adressées à la page de connexion de votre site Web, définissez les paires d'agents utilisateurs qui dépassent votre limite, définissez l'agrégation des demandes **sur Clés personnalisées** et fournissez les critères d'agrégation.
La liste JSON suivante montre un exemple de cette configuration de règle. Dans cet exemple, nous avons fixé la limite à 100 demandes par période de cinq minutes par adresse IP, paire d'agents utilisateurs.
```
{
"Name": "test-rbr",
"Priority": 0,
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-rbr"
},
"Statement": {
"RateBasedStatement": {
"Limit": 100,
"EvaluationWindowSec": 300,
"AggregateKeyType": "CUSTOM_KEYS",
"CustomKeys": [
{
"Header": {
"Name": "User-Agent",
"TextTransformations": [
{
"Priority": 0,
"Type": "NONE"
}
]
}
},
{
"IP": {}
}
],
"ScopeDownStatement": {
"ByteMatchStatement": {
"FieldToMatch": {
"UriPath": {}
},
"PositionalConstraint": "STARTS_WITH",
"SearchString": "/login",
"TextTransformations": [
{
"Type": "NONE",
"Priority": 0
}
]
}
}
}
}
}
```
# Limite de débit les demandes pour lesquelles il manque un en-tête spécifique
Pour limiter le nombre de demandes auxquelles il manque un en-tête spécifique, vous pouvez utiliser l'option d'agrégation **Count all** avec une instruction scope-down. Configurez l'instruction scope-down avec une `NOT` instruction logique contenant une instruction qui renvoie true uniquement si l'en-tête existe et possède une valeur.
La liste JSON suivante montre un exemple de cette configuration de règle.
```
{
"Name": "test-rbr",
"Priority": 0,
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-rbr"
},
"Statement": {
"RateBasedStatement": {
"Limit": 1000,
"AggregateKeyType": "CONSTANT",
"EvaluationWindowSec": 300,
"ScopeDownStatement": {
"NotStatement": {
"Statement": {
"SizeConstraintStatement": {
"FieldToMatch": {
"SingleHeader": {
"Name": "user-agent"
}
},
"ComparisonOperator": "GT",
"Size": 0,
"TextTransformations": [
{
"Type": "NONE",
"Priority": 0
}
]
}
}
}
}
}
}
}
```
# Débit : limitez les demandes avec des étiquettes spécifiques
Pour limiter le nombre de demandes de différentes catégories, vous pouvez combiner la limitation de débit avec n'importe quelle règle ou groupe de règles qui ajoute des étiquettes aux demandes. Pour ce faire, configurez votre pack de protection (ACL Web) comme suit :
+ Ajoutez les règles ou les groupes de règles qui ajoutent des étiquettes, et configurez-les de manière à ce qu'ils ne bloquent pas ou n'autorisent pas les demandes pour lesquelles vous souhaitez limiter le débit. Si vous utilisez des groupes de règles gérés, vous devrez peut-être annuler certaines actions des règles des groupes de règles Count pour obtenir ce comportement.
+ Ajoutez une règle basée sur le taux à votre pack de protection (ACL Web) avec un paramètre de numéro de priorité supérieur aux règles d'étiquetage et aux groupes de règles. AWS WAF évalue les règles par ordre numérique, en commençant par le plus bas, afin que votre règle basée sur les taux soit exécutée après les règles d'étiquetage. Configurez votre limite de débit sur les étiquettes en combinant la correspondance des étiquettes dans l'énoncé de portée réduite de la règle et l'agrégation d'étiquettes.
L'exemple suivant utilise le groupe de règles AWS Managed Rules de la liste de réputation Amazon IP. La règle du groupe de règles `AWSManagedIPDDoSList` détecte et étiquette les demandes dont IPs on sait qu'elles participent activement à des activités DDo S. L'action de la règle est configurée Count dans la définition du groupe de règles. Pour plus d'informations sur le groupe de règles, consultez[Groupe de règles géré par Amazon IP Reputation](aws-managed-rule-groups-ip-rep.md#aws-managed-rule-groups-ip-rep-amazon).
La liste JSON du pack de protection (ACL Web) suivante utilise le groupe de règles de réputation IP suivi d'une règle basée sur le taux de correspondance des étiquettes. La règle basée sur le taux utilise une instruction scope-down pour filtrer les demandes qui ont été marquées par la règle du groupe de règles. L'énoncé de règle basé sur le taux agrège et limite le débit des demandes filtrées en fonction de leur adresse IP.
```
{
"Name": "test-web-acl",
"Id": ...
"ARN": ...
"DefaultAction": {
"Allow": {}
},
"Description": "",
"Rules": [
{
"Name": "AWS-AWSManagedRulesAmazonIpReputationList",
"Priority": 0,
"Statement": {
"ManagedRuleGroupStatement": {
"VendorName": "AWS",
"Name": "AWSManagedRulesAmazonIpReputationList"
}
},
"OverrideAction": {
"None": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "AWS-AWSManagedRulesAmazonIpReputationList"
}
},
{
"Name": "test-rbr",
"Priority": 1,
"Statement": {
"RateBasedStatement": {
"Limit": 100,
"EvaluationWindowSec": 300,
"AggregateKeyType": "IP",
"ScopeDownStatement": {
"LabelMatchStatement": {
"Scope": "LABEL",
"Key": "awswaf:managed:aws:amazon-ip-list:AWSManagedIPDDoSList"
}
}
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-rbr"
}
}
],
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-web-acl"
},
"Capacity": 28,
"ManagedByFirewallManager": false,
"RetrofittedByFirewallManager": false,
"LabelNamespace": "awswaf:0000000000:webacl:test-web-acl:"
}
```
# Limite de débit les demandes d'étiquettes ayant un espace de noms d'étiquette spécifié
**Note**
Les règles de niveau commun du groupe de règles gérées par Bot Control ajoutent des étiquettes pour les robots de différentes catégories, mais elles bloquent uniquement les demandes provenant de robots non vérifiés. Pour plus d'informations sur ces règles, consultez[Liste des règles de contrôle des bots](aws-managed-rule-groups-bot.md#aws-managed-rule-groups-bot-rules).
Si vous utilisez le groupe de règles géré par Bot Control, vous pouvez ajouter une limite de débit pour les demandes provenant de robots individuels vérifiés. Pour ce faire, vous ajoutez une règle basée sur le taux qui s'exécute après le groupe de règles Bot Control et agrège les demandes en fonction de leurs étiquettes de nom de bot. Vous spécifiez la clé d'agrégation de **l'espace de noms Label** et définissez la clé d'espace de noms sur. `awswaf:managed:aws:bot-control:bot:name:` Chaque étiquette unique avec l'espace de noms spécifié définira une instance d'agrégation. Par exemple, les étiquettes `awswaf:managed:aws:bot-control:bot:name:axios` et `awswaf:managed:aws:bot-control:bot:name:curl` chacune définissent une instance d'agrégation.
La liste JSON du pack de protection (ACL Web) suivante montre cette configuration. La règle décrite dans cet exemple limite les demandes pour une instance d'agrégation de robots uniques à 1 000 sur une période de deux minutes.
```
{
"Name": "test-web-acl",
"Id": ...
"ARN": ...
"DefaultAction": {
"Allow": {}
},
"Description": "",
"Rules": [
{
"Name": "AWS-AWSManagedRulesBotControlRuleSet",
"Priority": 0,
"Statement": {
"ManagedRuleGroupStatement": {
"VendorName": "AWS",
"Name": "AWSManagedRulesBotControlRuleSet",
"ManagedRuleGroupConfigs": [
{
"AWSManagedRulesBotControlRuleSet": {
"InspectionLevel": "COMMON"
}
}
]
}
},
"OverrideAction": {
"None": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "AWS-AWSManagedRulesBotControlRuleSet"
}
},
{
"Name": "test-rbr",
"Priority": 1,
"Statement": {
"RateBasedStatement": {
"Limit": 1000,
"EvaluationWindowSec": 120,
"AggregateKeyType": "CUSTOM_KEYS",
"CustomKeys": [
{
"LabelNamespace": {
"Namespace": "awswaf:managed:aws:bot-control:bot:name:"
}
}
]
}
},
"Action": {
"Block": {}
},
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-rbr"
}
}
],
"VisibilityConfig": {
"SampledRequestsEnabled": true,
"CloudWatchMetricsEnabled": true,
"MetricName": "test-web-acl"
},
"Capacity": 82,
"ManagedByFirewallManager": false,
"RetrofittedByFirewallManager": false,
"LabelNamespace": "awswaf:0000000000:webacl:test-web-acl:"
}
```
# Débit : limitez les demandes avec des ASNs
Pour limiter le nombre de demandes provenant de numéros de système autonome spécifiques (ASNs) en fonction de l'adresse IP des demandes, définissez l'agrégation des demandes sur des *clés personnalisées* et fournissez les critères d'agrégation.
Le JSON suivant montre un exemple d'agrégation de règles ASNs dérivée des adresses IP transférées trouvées dans l'`X-Forwarded-For`en-tête. S'il n'est pas AWS WAF possible de dériver un ASN parce que l'adresse IP est mal formée, le comportement de secours est défini sur. `MATCH`
```
{
"Name": "test-rbr",
"Priority": 0,
"Statement": {
"RateBasedStatement": {
"AggregateKeyType": "CUSTOM_KEYS",
"CustomKeys": [
{
"ASN": {}
},
{
"ForwardedIP": {}
}
],
"EvaluationWindowSec": 300,
"ForwardedIPConfig": {
"FallbackBehavior": "MATCH",
"HeaderName": "X-Forwarded-For"
},
"Limit": 2000
}
},
"VisibilityConfig": {
"CloudWatchMetricsEnabled": true,
"MetricName": "test-rbr",
"SampledRequestsEnabled": true
}
}
```
# Répertorier les adresses IP dont le débit est limité par des règles basées sur le débit
Cette section explique comment accéder à la liste des adresses IP actuellement limitées par une règle basée sur le débit à l'aide de la CLI, de l'API ou de l'un des. SDKs
Si votre règle basée sur le taux ne s'agrège que sur l'adresse IP ou l'adresse IP transférée, vous pouvez récupérer la liste des adresses IP pour lesquelles la règle limite actuellement le débit. AWS WAF stocke ces adresses IP dans la liste des clés gérées de la règle.
**Note**
Cette option n'est disponible que si vous regroupez uniquement l'adresse IP ou uniquement une adresse IP dans un en-tête. Si vous utilisez l'agrégation de demandes de clés personnalisées, vous ne pouvez pas récupérer une liste d'adresses IP à débit limité, même si vous utilisez l'une des spécifications d'adresse IP dans vos clés personnalisées.
Une règle basée sur le taux applique son action aux demandes de la liste des clés gérées de la règle qui correspondent à l'instruction scope-down de la règle. Lorsqu'une règle ne comporte aucune instruction de portée réduite, elle applique l'action à toutes les demandes provenant des adresses IP figurant dans la liste. L'action de règle est Block par défaut, mais il peut s'agir de n'importe quelle action de règle valide, à l'exception deAllow. Le nombre maximum d'adresses IP AWS WAF pouvant limiter le débit à l'aide d'une seule instance de règle basée sur le débit est de 10 000. Si plus de 10 000 adresses dépassent la limite de débit, AWS WAF limite celles présentant les taux les plus élevés.
Vous pouvez accéder à la liste des clés gérées d'une règle basée sur le taux à l'aide de la CLI, de l'API ou de l' SDKsun des. Cette rubrique couvre l'accès à l'aide de la CLI et APIs. La console ne permet pas d'accéder à la liste pour le moment.
Pour l' AWS WAF API, la commande est [GetRateBasedStatementManagedKeys](https://docs.aws.amazon.com/waf/latest/APIReference/API_GetRateBasedStatementManagedKeys.html).
Pour la AWS WAF CLI, la commande est [get-rate-based-statement-managed-keys](https://docs.aws.amazon.com/cli/latest/reference/wafv2/get-rate-based-statement-managed-keys.html).
Voici la syntaxe permettant de récupérer la liste des adresses IP à débit limité pour une règle basée sur le débit utilisée dans un pack de protection (ACL Web) sur une distribution Amazon CloudFront .
```
aws wafv2 get-rate-based-statement-managed-keys --scope=CLOUDFRONT --region=us-east-1 --web-acl-name=WebACLName --web-acl-id=WebACLId --rule-name=RuleName
```
Voici la syntaxe d'une application régionale, d'une API REST Amazon API Gateway, d'un Application Load Balancer, d'une API AWS AppSync GraphQL, d'un groupe d'utilisateurs Amazon Cognito, d'un AWS App Runner service ou d'une instance Verified Access AWS Amplify. AWS
```
aws wafv2 get-rate-based-statement-managed-keys --scope=REGIONAL --region=region --web-acl-name=WebACLName --web-acl-id=WebACLId --rule-name=RuleName
```
AWS WAF surveille les requêtes Web et gère les clés indépendamment pour chaque combinaison unique de pack de protection (ACL Web), de groupe de règles facultatif et de règle basée sur le taux. Par exemple, si vous définissez une règle basée sur le taux au sein d'un groupe de règles, puis que vous utilisez le groupe de règles dans un pack de protection (ACL Web), AWS WAF vous surveillez les requêtes Web et gérez les clés pour ce pack de protection (ACL Web), la déclaration de référence du groupe de règles et l'instance de règle basée sur le taux. Si vous utilisez le même groupe de règles dans un deuxième pack de protection (ACL Web), AWS WAF surveille les requêtes Web et gère les clés pour cette deuxième utilisation de manière totalement indépendante de la première.
Pour une règle basée sur le taux que vous avez définie au sein d'un groupe de règles, vous devez fournir le nom de la déclaration de référence du groupe de règles dans votre demande, en plus du nom du pack de protection (ACL Web) et du nom de la règle basée sur le taux au sein du groupe de règles. Voici la syntaxe d'une application régionale dans laquelle la règle basée sur le taux est définie au sein d'un groupe de règles et le groupe de règles est utilisé dans un pack de protection (ACL Web).
```
aws wafv2 get-rate-based-statement-managed-keys --scope=REGIONAL --region=region --web-acl-name=WebACLName --web-acl-id=WebACLId --rule-group-rule-name=RuleGroupRuleName --rule-name=RuleName
```
# Utilisation des déclarations de règles relatives aux groupes de règles dans AWS WAF
**Note**
Les déclarations de règles relatives aux groupes de règles ne sont pas imbriquables.
Cette section décrit les instructions de règles du groupe de règles que vous pouvez utiliser dans votre pack de protection (ACL Web). Les unités de capacité du pack de protection du groupe de règles (ACL WebWCUs) () sont définies par le propriétaire du groupe de règles au moment de sa création. Pour plus d'informations sur WCUs, voir[Unités de capacité Web ACL (WCUs) en AWS WAF](aws-waf-capacity-units.md).
| Instruction de groupe de règles | Description | WCUs |
| --- | --- | --- |
| [Utilisation d'instructions de groupes de règles gérés](waf-rule-statement-type-managed-rule-group.md) | Exécute les règles définies dans le groupe de règles gérées spécifié. Vous pouvez réduire la portée des demandes évaluées par le groupe de règles en ajoutant une instruction scope-down. Vous ne pouvez pas imbriquer une instruction de groupe de règles géré dans un autre type d'instruction. | Défini par le groupe de règles, plus toute instruction supplémentaire WCUs pour une instruction de portée réduite. |
| [Utilisation d'instructions de groupes de règles](waf-rule-statement-type-rule-group.md) | Exécute les règles définies dans un groupe de règles que vous gérez. Vous ne pouvez pas ajouter d'instruction de portée réduite à une déclaration de référence de groupe de règles pour votre propre groupe de règles. Vous ne pouvez pas imbriquer une instruction de groupe de règles dans un autre type d'instruction | Vous définissez la limite WCU pour le groupe de règles lorsque vous le créez. |
# Utilisation des instructions de groupes de règles gérés dans AWS WAF
Cette section explique le fonctionnement des instructions de règles des groupes de règles gérés.
L'instruction de règle du groupe de règles géré ajoute une référence à un groupe de règles géré dans la liste des règles de votre pack de protection (ACL Web). Cette option ne figure pas dans vos instructions de règle sur la console, mais lorsque vous utilisez le format JSON de votre ACL Web, tous les groupes de règles gérés que vous avez ajoutés apparaissent sous les règles du pack de protection (ACL Web) sous ce type.
Un groupe de règles géré est soit un groupe de règles AWS gérées, dont la plupart sont gratuites pour les AWS WAF clients, soit un groupe de règles AWS Marketplace géré. Vous vous abonnez automatiquement aux groupes de règles AWS Managed Rules payants lorsque vous les ajoutez à votre pack de protection (ACL Web). Vous pouvez vous abonner à des groupes de règles AWS Marketplace gérés via AWS Marketplace. Pour de plus amples informations, veuillez consulter [Utilisation de groupes de règles gérés dans AWS WAF](waf-managed-rule-groups.md).
Lorsque vous ajoutez un groupe de règles à un pack de protection (ACL Web), vous pouvez remplacer les actions des règles du groupe par Count ou par une autre action de règle. Pour de plus amples informations, veuillez consulter [Remplacer les actions du groupe de règles dans AWS WAF](web-acl-rule-group-override-options.md).
Vous pouvez réduire la portée des demandes AWS WAF évaluées à l'aide du groupe de règles. Pour ce faire, vous devez ajouter une instruction scope-down dans l'instruction du groupe de règles. Pour plus d'informations sur les instructions de portée réduite, voir. [Utilisation d'instructions scope-down dans AWS WAF](waf-rule-scope-down-statements.md) Cela peut vous aider à gérer l'impact du groupe de règles sur votre trafic et à contenir les coûts associés au volume de trafic lorsque vous utilisez le groupe de règles. Pour obtenir des informations et des exemples d'utilisation des instructions de portée réduite avec le groupe de règles géré par AWS WAF Bot Control, consultez. [AWS WAF Contrôle des robots](waf-bot-control.md)
## Caractéristiques de l'énoncé des règles
**Non imbriquable** : vous ne pouvez pas imbriquer ce type d'instruction dans d'autres instructions, ni l'inclure dans un groupe de règles. Vous pouvez l'inclure directement dans un pack de protection (ACL Web).
**(Facultatif) Instruction de portée réduite** : ce type de règle utilise une instruction de portée réduite facultative, afin de réduire la portée des demandes évaluées par le groupe de règles. Pour de plus amples informations, veuillez consulter [Utilisation d'instructions scope-down dans AWS WAF](waf-rule-scope-down-statements.md).
**WCUs**— Défini pour le groupe de règles lors de sa création.
## Où trouver cette déclaration de règle
+ **Console** — Au cours du processus de création d'un pack de protection (ACL Web), sur la page **Ajouter des règles et des groupes** de **règles, choisissez Ajouter des groupes de règles gérés**, puis recherchez et sélectionnez le groupe de règles que vous souhaitez utiliser.
+ **API** — [ManagedRuleGroupStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_ManagedRuleGroupStatement.html)
# Utilisation des instructions de groupe de règles dans AWS WAF
Cette section explique le fonctionnement des instructions de règles relatives aux groupes de règles.
L'instruction de règle du groupe de règles ajoute une référence à la liste des règles de votre pack de protection (ACL Web) à un groupe de règles que vous gérez. Cette option ne figure pas dans vos instructions de règles sur la console, mais lorsque vous utilisez le format JSON de votre pack de protection (ACL Web), tous les groupes de règles que vous avez ajoutés apparaissent sous les règles du pack de protection (ACL Web) sous ce type. Pour de plus amples informations sur l'utilisation de vos propres groupes de règles, reportez-vous à la section [Gestion de vos propres groupes de règles](waf-user-created-rule-groups.md).
Lorsque vous ajoutez un groupe de règles à un pack de protection (ACL Web), vous pouvez remplacer les actions des règles du groupe par Count ou par une autre action de règle. Pour de plus amples informations, veuillez consulter [Remplacer les actions du groupe de règles dans AWS WAF](web-acl-rule-group-override-options.md).
## Caractéristiques de l'énoncé des règles
**Non imbriquable** : vous ne pouvez pas imbriquer ce type d'instruction dans d'autres instructions, ni l'inclure dans un groupe de règles. Vous pouvez l'inclure directement dans un pack de protection (ACL Web).
**WCUs**— Défini pour le groupe de règles lors de sa création.
## Où trouver cette déclaration de règle
+ **Console** — Au cours du processus de création d'un pack de protection (ACL Web), sur la page **Ajouter des règles et des groupes** de règles, sélectionnez **Ajouter mes propres règles et groupes** de **règles, Groupe** de règles, puis ajoutez le groupe de règles que vous souhaitez utiliser.
+ **API** — [RuleGroupReferenceStatement](https://docs.aws.amazon.com/waf/latest/APIReference/API_RuleGroupReferenceStatement.html)