Meilleures pratiques en matière de limitation du débit
Les sections suivantes traitent des configurations types de limitation de débit pour les cas d'utilisation courants. Vous pouvez combiner les exemples de règles fournis et les adapter à votre propre scénario.
Les principaux cas d'utilisation de la limitation de débit sont les suivants :
- Appliquez un contrôle d'accès granulaire aux ressources, qui inclut le contrôle d'accès basé sur des critères tels que l'agent utilisateur, l'adresse IP, le référent, l'hôte, le pays et la région du monde.
- Protégez-vous contre les attaques par credential stuffing et les prises de contrôle de compte.
- Limiter le nombre d'opérations effectuées par chaque client. Comprend la prévention du scraping par les robots, l'accès aux données sensibles, la création massive de nouveaux comptes et les achats programmatiques sur les plateformes de commerce électronique.
- Protéger les API REST contre l'épuisement des ressources (attaques DDoS ciblées) et les ressources contre les abus en général.
- Protégez GraphQL les API en empêchant la surcharge des serveurs et en limitant le nombre d'opérations.
Application d'un contrôle d'accès granulaire
Vous pouvez utiliser la limitation du débit pour contrôler la manière dont les utilisateurs et les applications accèdent à vos ressources. La limitation du débit permet de protéger votre application contre les abus en restreignant le trafic en fonction d'attributs tels que l'agent utilisateur, l'adresse IP, le référent ou l'hôte.
Chacun des exemples suivants montre comment configurer une règle de limitation de débit pour un scénario de contrôle d'accès spécifique.
Limitation des requêtes par agent utilisateur
Vous pouvez limiter le nombre de requêtes autorisées pour un agent utilisateur spécifique. L'exemple de règle suivant permet aux utilisateurs d'applications mobiles d'effectuer jusqu'à 100 requêtes toutes les 10 minutes. Vous pouvez également créer une règle distincte limitant le débit pour les navigateurs de bureau.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Agent utilisateur égal à MobileApp |
| Expression | http.user_agent eq "MobileApp" |
| Caractéristiques de comptage | IP |
| Taux (demandes/période) | 100 requêtes / 10 minutes |
| Action | Demande d'authentification gérée |
Autorisation d'adresses IP ou d'ASN spécifiques
Contrôlez l'accès en incluant ou en excluant certaines adresses IP ou certains numéros de système autonome (ASN) d'une règle de limitation de débit.
L'exemple de règle de limitation de débit suivant autorise jusqu'à 10 requêtes par minute provenant de la même adresse IP et effectuant une GET requête vers le /status chemin, à condition que l'adresse IP ne figure
pas dans la liste d'adresses IP intitulée partner_ips.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le chemin URI est égal à /status et la méthode de requête est égale à GET et l'adresse IP source ne figure pas dans la liste. partner_ips |
| Expression | http.request.uri.path eq "/status" and http.request.method eq "GET" and not ip.src in $partner_ips |
| Caractéristiques de comptage | IP |
| Taux (demandes/période) | 10 requêtes / 1 minute |
| Action | Demande d'authentification gérée |
Limitation des requêtes par référent
Vous pouvez limiter les requêtes provenant de pages référentes, telles que des publicités tierces ou des sites Web externes. Ce cas d'utilisation permet de réduire le risque d'attaques par déni de service indirect (DDoS DDoS ) et vous aide à gérer les quotas de requêtes.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Chemin URI égal à /status et méthode de requête égale à GET |
| Expression | http.request.uri.path eq "/status" and http.request.method eq "GET" |
| Caractéristiques de comptage | En-tête (Referrer). Le nom HTTP de l'en-tête utilise une orthographe erronée de referrer. |
| Taux (demandes/période) | 100 requêtes / 10 minutes |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit.
Protection contre le credential stuffing
Vous pouvez utiliser la limitation de débit pour protéger les points de terminaison de connexion contre les attaques par credential stuffing. Le credential stuffing se produit lorsque des pirates utilisent des scripts automatisés pour tester plusieurs combinaisons de noms d'utilisateur et de mots de passe sur un formulaire de connexion. La limitation du débit permet d'atténuer ces attaques en restreignant les tentatives de connexion répétées à partir d'une même adresse IP.
Les exemples suivants montrent trois règles de limitation de débit qui augmentent les restrictions et les pénalités en fonction du nombre de tentatives de connexion infructueuses.
Règle n° 1 : Seuil de protection initial
La règle 1 autorise jusqu'à quatre tentatives de connexion infructueuses par minute. Lorsque la limite est dépassée, le système déclenche un défi géré. Cette configuration aide les utilisateurs légitimes à se remettre d'erreurs de connexion occasionnelles tout en décourageant les robots automatisés.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le nom d'hôte est égal à example.com et le chemin URI est égal à /login et la méthode de requête est égale à POST |
| Expression | http.host eq "example.com" and http.request.uri.path eq "/login" and http.request.method eq "POST" |
| Caractéristiques de comptage | IP |
| Incrémenter le compteur lorsque | Le chemin URI est égal à /login et la méthode est égale à POST et le code de réponse est compris entre (401, 403) |
| Expression de comptage | http.request.uri.path eq "/login" and http.request.method eq "POST" and http.response.code in {401 403} |
| Taux (demandes/période) | 4 demandes / 1 minute |
| Action | Demande d'authentification gérée |
Règle 2 : Seuil de protection intermédiaire
Si les utilisateurs légitimes réussissent le défi lorsqu'ils atteignent la limite de la règle 1, la règle 2 applique une protection supplémentaire pour les clients qui continuent à faire des tentatives de connexion infructueuses. Il autorise jusqu'à 10 tentatives infructueuses en 10 minutes avant de déclencher un nouveau défi géré.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le nom d'hôte est égal à example.com et le chemin URI est égal à /login et la méthode de requête est égale à POST |
| Expression | http.host eq "example.com" and http.request.uri.path eq "/login" and http.request.method eq "POST" |
| Caractéristiques de comptage | IP |
| Incrémenter le compteur lorsque | Le chemin URI est égal à /login et la méthode de requête est égale à POST et le code d'état de la réponse est compris entre (401, 403) |
| Expression de comptage | http.request.uri.path eq "/login" and http.request.method eq "POST" and http.response.code in {401 403} |
| Taux (demandes/période) | 10 demandes / 10 minutes |
| Action | Demande d'authentification gérée |
Règle n° 3 : Seuil de protection strict
La règle 3 impose une sanction plus sévère aux clients qui dépassent le seuil fixé par la règle 2 en bloquant une adresse IP pendant une journée après 20 tentatives de connexion infructueuses en une heure. Cette règle offre une défense ultime contre les tentatives d'attaques persistantes.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Hôte égal example.com |
| Expression | http.host eq "example.com" |
| Caractéristiques de comptage | IP |
| Incrémenter le compteur lorsque | Le chemin URI est égal à /login et la méthode de requête est égale à POST et le code d'état de la réponse est compris entre (401, 403) |
| Expression de comptage | http.request.uri.path eq "/login" and http.request.method eq "POST" and http.response.code in {401 403} |
| Taux (demandes/période) | 20 demandes / 1 heure |
| Action | Bloquer pendant 1 jour |
Toutes ces règles d'exemple nécessitent un for Business ou supérieur.
Ces trois règles ont une expression de comptage distincte de l'expression de règle (également appelée expression d'atténuation). Lorsque vous configurez une expression de comptage distincte, les critères de correspondance sont utilisés lorsqu'une action est déclenchée. Dans l'expression de comptage, vous pouvez inclure des conditions basées sur le code HTTP d'état de réponse et les HTTP en-têtes de réponse afin d'intégrer la limitation de débit à votre logique backend.
Vous pouvez également choisir d'utiliser deux expressions différentes : une expression de comptage et une expression de règle/atténuation — pour définir :
- Les requêtes utilisées pour calculer le taux.
- Les demandes effectivement traitées.
Par exemple, l'exemple de la règle 3 calcule le taux en tenant compte POST des requêtes qui /login ont renvoyé un code 401 d'état 403HTTP ou. Cependant, lorsque la limite de débit est dépassée,
CIS bloque toutes les requêtes vers example.com l'hôte générées par la même adresse IP.
Limiter le nombre d'opérations
Vous pouvez utiliser la limitation du débit pour contrôler le nombre d'opérations qu'un client effectue au cours d'une période donnée. Les règles que vous configurez dépendent du comportement et du profil de risque de votre application.
Les exemples suivants montrent comment empêcher le scraping de contenu et les activités automatisées susceptibles de surcharger votre système ou d'utiliser vos données à mauvais escient. Par exemple, limiter les requêtes par chaîne de requête, paramètres JSON ou caractéristiques des robots.
Empêcher le scraping de contenu à l'aide d'une chaîne de requête
Dans cet exemple, les clients effectuent des opérations (telles que la recherche de prix ou l'ajout d'articles à un panier) sur un site Web de commerce électronique à l'aide de paramètres de chaîne de requête. Par exemple, une requête type envoyée par un client pourrait ressembler à ceci :
GET https://store.com/merchant?action=lookup_price&product_id=215
Cookie: session_id=12345
Votre équipe de sécurité pourrait envisager de limiter le nombre de fois qu'un client peut consulter les prix afin d'empêcher les robots, qui auraient pu échapper à la gestion CIS des robots, de récupérer l'intégralité du catalogue du magasin.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le chemin URI est égal à /merchant et la chaîne de requête URI contient action=lookup_price |
| Expression | http.request.uri.path eq "/merchant" and http.request.uri.query contains "action=lookup_price" |
| Caractéristiques de comptage | IP |
| Taux (demandes/période) | 10 demandes / 2 minutes |
| Action | Demande d'authentification gérée |
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le chemin URI est égal à /merchant et la chaîne de requête URI contient action=lookup_price |
| Expression | http.request.uri.path eq "/merchant" and http.request.uri.query contains "action=lookup_price" |
| Caractéristiques de comptage | IP |
| Taux (demandes/période) | 20 demandes / 5 minutes |
| Action | Bloc |
Ces deux règles de limitation de débit correspondent aux demandes effectuant une action sélectionnée (recherche de prix, dans cet exemple) et utilisent IP comme caractéristique de comptage. De manière similaire à l 'exemple /login, les deux règles permettent de réduire les faux positifs dans le cas de visiteurs persistants (mais légitimes).
Vous pouvez limiter la recherche d'un élément spécifique product_id à l'aide d'un paramètre de chaîne de requête. En ajoutant un paramètre de requête comme caractéristique de comptage, le taux est calculé pour toutes les requêtes,
quel que soit le client.
L'exemple suivant limite le nombre de recherches pour chaque product_id à 50 requêtes en 10 secondes.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Chemin URI égal à /merchant |
| Expression | http.request.uri.path eq "/merchant" |
| Caractéristiques de comptage | Requête (product_id) |
| Taux (demandes/période) | 20 requêtes / 10 secondes |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit.
Vous pouvez suivre le même modèle de règles de limitation de débit pour protéger les applications qui gèrent les réservations.
Empêcher le scraping de contenu à l'aide du corps de la requête
Considérons une application qui gère l'opération et ses paramètres via le corps de la requête au format JSON. Par exemple, l'opération lookup_price pourrait se présenter comme suit :
POST https://api.store.com/merchant
Cookie: session_id=12345
Body:
{
"action": "lookup_price",
"product_id": 215
}
Dans ce scénario, vous pouvez créer une règle suivante pour limiter le nombre d'actions à partir de sessions individuelles :
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Chemin URI égal à /merchant et chaîne JSON action égale à lookup_price |
| Expression | http.request.uri.path eq "/merchant" and lookup_json_string(http.request.body.raw, "action") eq "lookup_price" |
| Caractéristiques de comptage | Cookie (session_id) |
| Taux (demandes/période) | 10 demandes / 2 minutes |
| Action | Demande d'authentification gérée |
Cette règle d'exemple nécessite la limitation avancée du débit et l'inspection de la charge utile.
Vous pouvez également limiter le nombre de recherches pour chaque, quel product_id que soit le client à l'origine des requêtes, en déployant une règle telle que celle-ci :
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Chemin URI égal à /merchant et champ JSON action égal à lookup_price |
| Expression | http.request.uri.path eq "/merchant" and lookup_json_string(http.request.body.raw, "action") eq "lookup_price" |
| Caractéristiques de comptage | Champ JSON (product_id) |
| Taux (demandes/période) | 50 requêtes / 10 secondes |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit et l'inspection de la charge utile.
Si le corps de la requête n'est pas au format JSON, vous pouvez utiliser le http.request.body.raw champ et des expressions régulières (avec l 'opérateur matches) pour obtenir le même résultat.
Limiter les requêtes provenant de robots
Vous pouvez utiliser la limitation du débit pour contrôler le trafic automatisé provenant des robots. Une approche courante consiste à surveiller les requêtes qui renvoient un nombre élevé de codes d'état 403 de 404 réponse ou, qui indiquent souvent une activité de scraping automatisée.
Dans cette situation, vous pouvez configurer une règle similaire à celle-ci :
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le nom d'hôte est égal à example.com |
| Expression | http.host eq "example.com" |
| Caractéristiques de comptage | IP |
| Incrémenter le compteur lorsque | Le code d'état de réponse est compris entre (401, 403) |
| Expression de comptage | http.response.code in {401 403} |
| Taux (demandes/période) | 5 demandes / 3 minutes |
| Action | Demande d'authentification gérée |
Cette règle d'exemple nécessite un forfait Business ou supérieur.
Pour contrôler la fréquence des actions effectuées par des sources automatisées, envisagez d'utiliser des règles de limitation de fréquence en association avec la gestion des bots.
Avec Bot Management, vous pouvez utiliser le score des bots comme critère de correspondance afin d'appliquer la règle uniquement au trafic automatisé ou susceptible
d'être automatisé. Par exemple, vous pouvez utiliser un score maximal (ou seuil) de 30 pour le trafic probablement automatisé et 10 pour le trafic automatisé.
Vous pouvez renforcer la protection en combinant la limitation du débit avec la gestion des bots. Avec Bot Management, vous pouvez utiliser le score des bots comme critère de correspondance afin d'appliquer la règle uniquement au trafic automatisé ou susceptible d'être automatisé.
Exemple :
- Un score inférieur à
30indique probablement un trafic automatisé. - Un score inférieur à
10indique un trafic automatisé confirmé.
Limitation des requêtes par session
Si votre application utilise des cookies de session, utilisez le cookie comme caractéristique de comptage. Cette méthode regroupe les requêtes provenant de différentes adresses IP au sein d'une même session, ce qui est utile pour détecter les attaques distribuées par des bots.
Règle 1
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Score du bot inférieur à 30 et chaîne de requête URI contenant action=delete |
| Expression | cis.bot_management.score lt 30 and http.request.uri.query contains "action=delete" |
| Caractéristiques de comptage | Cookie (session_id) |
| Taux (demandes/période) | 10 requêtes / 1 minute |
| Action | Demande d'authentification gérée |
Règle 2
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Score du bot inférieur à 10 et chaîne de requête URI contenant action=delete |
| Expression | cis.bot_management.score lt 10 and http.request.uri.query contains "action=delete" |
| Caractéristiques de comptage | Cookie (session_id) |
| Taux (demandes/période) | 20 demandes / 5 minutes |
| Action | Bloc |
Ces exemples de règles nécessitent la limitation avancée du débit et la gestion des bots.
Utilisation JA3 des empreintes digitales
Si l'application n'utilise pas de cookie de session, vous pouvez utiliser JA3 les empreintes digitales pour identifier les clients individuels. Une JA3 empreinte digitale est un identifiant unique, disponible pour les clients disposant de Bot Management, qui permet CIS d'identifier les demandes provenant du même client. Tous les clients ont une empreinte digitale associée, qu'ils soient automatisés ou non.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Chemin URI égal à /merchant et score du bot inférieur à 10 |
| Expression | http.request.uri.path eq "/merchant" and cf.bot_management.score lt 10 |
| Caractéristiques de comptage | JA3 Empreinte digitale |
| Taux (demandes/période) | 10 requêtes / 1 minute |
| Action | Demande d'authentification gérée |
Cette règle nécessite la limitation avancée du débit et la gestion des bots.
Protection des API REST
Les API REST peuvent générer une charge importante sur les systèmes backend, car les requêtes API nécessitent souvent un traitement intensif ou des recherches de données volumineuses. Un accès non contrôlé à l'API peut entraîner une dégradation des performances, voire des temps d'arrêt. Utilisez la limitation avancée du débit pour prévenir les abus, atténuer les attaques volumétriques et protéger les ressources critiques.
Protection des ressources
Même GET les requêtes peuvent solliciter l'application ou consommer de la bande passante lorsqu'elles sont utilisées pour des téléchargements de données volumineuses, telles que des fichiers ou des images.
Prenons par exemple le point final suivant :
GET https://api.store.com/files/<FILE_ID>
Header: x-api-key=9375
Pour empêcher les abus tout en autorisant les téléchargements légitimes, vous pouvez définir une règle qui limite les demandes de fichiers sans avoir à écrire des règles distinctes pour chaque fichier.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le nom d'hôte est égal à api.example.com et la méthode de requête est égale à GET |
| Expression | http.host eq "api.example.com" and http.request.method eq "GET" |
| Caractéristiques de comptage | Voie |
| Taux (demandes/période) | Comme suggéré par API Discovery ou évalué en analysant le trafic passé. |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit.
Cette règle limite les téléchargements à 10 requêtes toutes les 10 minutes par fichier sous https://api.store.com/files/*. En utilisant Path comme caractéristique de comptage, vous pouvez éviter de créer de nouvelles règles pour
chaque nouveau <FILE_ID>. Le tarif est calculé par fichier, indépendamment de l'adresse IP du client ou de l'identifiant de session.
Vous pouvez renforcer davantage la protection en combinant Path avec un identifiant client tel que x-api-key ou IP. Cette approche vous permet de limiter le nombre de téléchargements qu'un client spécifique
peut effectuer pour un fichier donné.
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le nom d'hôte est égal à api.store.com et la méthode de requête est égale à GET |
| Expression | http.host eq "api.example.com" and http.request.method eq "GET" |
| Caractéristiques de comptage | Chemin et en-tête (x-api-key) |
| Taux (demandes/période) | Comme suggéré par API Discovery ou évalué en analysant le trafic passé. |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit.
Protection GraphQL des API
La prévention de la surcharge des serveurs pour GraphQL les API peut être différente de la prévention de la surcharge pour les API RESTful. L'un des plus grands défis posés par les applications construites sur GraphQL est qu'un seul chemin gère
toutes les requêtes vers le serveur, et chaque requête est généralement une POST opération. Cela évite de créer différentes limites de débit pour différentes API en fonction de la HTTP méthode et du chemin URI.
Cependant, au lieu d'utiliser la méthode et le chemin comme une API RESTful, l'objet de la requête est généralement intégré dans le corps, qui contient des informations sur les données que le client souhaite récupérer ou modifier (selon GraphQL's la terminologie utilisée pour la modification des données côté serveur), ainsi que toutes les données supplémentaires nécessaires à l'exécution de l'action.
Pour éviter la surcharge du serveur, envisagez les approches suivantes :
- Limiter le nombre de fois qu'un utilisateur particulier peut appeler le même nom GraphQL d'opération.
- Limiter la complexité totale des requêtes qu'un utilisateur donné est autorisé à demander.
- Limitez la complexité des requêtes individuelles.
Les exemples suivants sont basés sur une application qui accepte les critiques de films.
POST https://moviereviews.example.com/graphql
Cookie: session_id=12345
Body:
{
"data": {
"createReview": {
"stars": 5,
"commentary": "This is a great movie!"
}
}
}
Limiter le nombre d'opérations
Pour limiter le taux d'actions, créez la règle suivante :
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le chemin URI est égal à /graphql et le corps contient createReview |
| Expression | http.request.uri.path eq "/graphql" and http.request.body.raw contains "createReview" |
| Caractéristiques de comptage | Cookie (session_id) |
| Taux (demandes/période) | 5 demandes / 1 heure |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit et l'inspection de la charge utile.
Limiter la complexité totale des requêtes
La complexité du traitement d'une GraphQL demande peut varier considérablement. Comme l'API utilise un seul point de terminaison, il peut être difficile de déterminer la complexité de chaque requête avant son traitement.
Pour éviter l'épuisement des ressources sur le serveur d'origine, limitez la complexité totale des requêtes par client au fil du temps, plutôt que de limiter le nombre de requêtes. CIS La limitation du débit vous permet de créer des règles qui suivent la complexité au fil du temps et bloquent les requêtes qui dépassent un budget de complexité défini.
Cette méthode nécessite que le serveur d'origine attribue un score de complexité à chaque requête et inclue ce score dans l'en-tête HTTP de réponse. Le mécanisme de limitation du débit utilise ensuite les informations relatives au score pour mettre à jour le budget de complexité pour ce client spécifique.
L'exemple suivant définit un budget de complexité total de 1 000 par heure :
| Paramètre | Valeur |
|---|---|
| Critères de correspondance | Le chemin URI contient /graphql |
| Expression | http.request.uri.path eq "/graphql" |
| Caractéristiques de comptage | Cookie (session_id) |
| Score par période | 1 000 |
| Period | 1 heure |
| Nom de l'en-tête de réponse | score |
| Action | Bloc |
Cette règle d'exemple nécessite la limitation avancée du débit et l'inspection de la charge utile.
Lorsque le serveur d'origine traite une requête, il ajoute un scoreHTTP en-tête à la réponse avec une valeur qui indique la quantité de travail effectuée par l'origine pour la traiter. Par exemple, 100. Au cours de
l'heure suivante, le même client peut effectuer des demandes jusqu'à un budget supplémentaire de 900. Dès que ce budget est dépassé, les demandes ultérieures sont bloquées jusqu'à l'expiration du délai.
Limiter la complexité de chaque requête individuelle
Les clients API Shield peuvent utiliser la protection contre GraphQL les requêtes malveillantes pour protéger leurs GraphQL API. Cette fonctionnalité analyse le trafic GraphQL entrant à la recherche de requêtes susceptibles de surcharger le serveur d'origine et de provoquer un déni de service.
Vous pouvez créer des règles pour limiter la profondeur et la taille des requêtes GraphQL entrantes. Ces règles permettent de bloquer les requêtes suspectes ou excessivement complexes avant qu'elles n'affectent les performances.