Comment arrêter les attaques DDoS en Go avec la limitation de débit

La limitation de débit est l'une des techniques les plus efficaces pour atténuer les attaques DDoS. Parmi ses variantes, la limitation du débit par IP se distingue par son approche ciblée : elle applique les limites de requêtes individuellement pour chaque client, en fonction de son adresse IP. Cela empêche un utilisateur unique de surcharger le serveur tout en maintenant un niveau d'accès équitable pour les utilisateurs légitimes.

Dans cet article, nous expliquerons comment fonctionne la limitation de débit par IP, pourquoi il s'agit de l'une des meilleures stratégies pour arrêter les attaques DDoS et comment la mettre en œuvre dans Go à l'aide du package tarifaire.

Pourquoi limiter le débit

La limitation de débit est largement utilisée car elle équilibre sécurité et convivialité. Voici pourquoi c’est une approche privilégiée :

1. Gestion efficace des ressources : En limitant le nombre de requêtes de chaque client, les serveurs peuvent éviter d'être submergés, même lors d'une attaque.
2. Équité : Les utilisateurs légitimes peuvent continuer à accéder au serveur pendant que les clients malveillants sont limités.
3. Personnalisable : Les limites de débit peuvent être ajustées en fonction des cas d'utilisation, tels que des limites différentes pour les API publiques et les services privés.
4. Évolutivité : Les mécanismes de limitation de débit s'adaptent bien aux infrastructures modernes, en particulier lorsqu'ils sont combinés avec des équilibreurs de charge ou des proxys inverses.

Comment cela se compare-t-il à d'autres techniques

1. Règles de pare-feu : Bloquez le trafic au niveau du réseau en fonction de règles prédéfinies. Bien qu’efficace pour le filtrage à grande échelle, il est moins flexible et peut bloquer les utilisateurs légitimes en cas de faux positifs.
2. Réseaux de diffusion de contenu (CDN) : Répartissez le trafic sur plusieurs serveurs. Bien qu’ils soient parfaits pour réduire l’impact des DDoS, les CDN ne traitent pas le trafic abusif au niveau des applications.
3. Preuve de travail (PoW) : Nécessite que les clients résolvent des énigmes informatiques avant d'accéder au serveur. Efficace mais ajoute de la latence pour les utilisateurs légitimes et peut nécessiter beaucoup de ressources pour les clients.
4. Limitation du taux : Offre un contrôle précis, évolue bien et n’ajoute pas de surcharge significative. Il s’agit souvent du meilleur choix pour protéger les points de terminaison au niveau des applications.

Mise en œuvre

Dans la limitation de débit par IP, un limiteur distinct est maintenu pour chaque IP client. Voici comment l'implémenter à l'aide du package golang.org/x/time/rate.

Étape 1 : Installer le package requis

Le forfait tarifaire fait partie des modules étendus de Go. Installez-le avec :

bash

allez chercher golang.org/x/time/rate

Étape 2 : Coder le limiteur de débit par IP

aller

paquet principal

importer (

`"fmt"`

`"net/http"`

`"sync"`

`"time"`

`"golang.org/x/time/rate"`

)

var (

`mu       sync.Mutex`

`visitors = make(map[string]*rate.Limiter)`

)

// getVisitor récupère le limiteur de débit pour une IP donnée, en en créant un s'il n'existe pas.

func getVisitor(chaîne ip) *rate.Limiter {

`mu.Lock()`

`defer mu.Unlock()`

`limiter, exists := visitors[ip]`

`if !exists {`

    `limiter = rate.NewLimiter(1, 5) // 1 request/second, burst of 5`

    `visitors[ip] = limiter`

    `// Clean up limiter after 1 minute of inactivity`

    `go func() {`

        `time.Sleep(1 * time.Minute)`

        `mu.Lock()`

        `delete(visitors, ip)`

        `mu.Unlock()`

    `}()`

`}`

`return limiter`

}

//rateLimitedHandler applique la limite de débit par IP

func rateLimitedHandler(w http.ResponseWriter, r *http.Request) {

`ip := r.RemoteAddr`

`limiter := getVisitor(ip)`

`if !limiter.Allow() {`

    `http.Error(w, "Too many requests. Please try again later.", http.StatusTooManyRequests)`

    `return`

`}`

`fmt.Fprintln(w, "Request successful.")`

}

func main() {

`http.HandleFunc("/", rateLimitedHandler)`

`fmt.Println("Starting server on :8080")`

`http.ListenAndServe(":8080", nil)`

}

Explication

1. Carte des visiteurs : Maintient un rate.Limiter pour chaque adresse IP. La carte des visiteurs contient ces limiteurs, classés par adresses IP (r.RemoteAddr). Lorsqu'une requête arrive, la fonction getVisitor vérifie si un limiteur existe déjà pour l'IP.
2. Création du limiteur : Chaque limiteur autorise 1 requête par seconde avec une capacité de rafale de 5. Un nouveau limiteur est créé avec des règles spécifiques (1 requête par seconde avec une capacité de rafale de 5) s'il n'en existe pas. Le limiteur autorise une certaine rafale initiale de requêtes mais impose un débit constant par la suite.
3. Nettoyage automatique : Une goroutine nettoie les limiteurs d'inactivité après 1 minute pour économiser de la mémoire. Pour éviter la croissance de la mémoire, le code inclut un mécanisme de nettoyage. Une goroutine est démarrée à chaque fois qu'un nouveau limiteur est créé, et elle attend 1 minute d'inactivité avant de supprimer l'entrée correspondante de la carte des visiteurs. Cela garantit que les limiteurs ne sont conservés que pour les clients actifs.
4. Logique de limitation de débit : Le gestionnaire vérifie si le limiteur autorise la demande. Si la requête dépasse la limite définie, elle répond par une erreur 429 Too Many Requests ; sinon, il traite la demande.

La limitation du débit par IP dans Go est un excellent moyen d'atténuer les attaques DDoS au niveau des applications. Il offre un contrôle précis du trafic, garantissant que les utilisateurs légitimes peuvent accéder à votre service tandis que les utilisateurs malveillants sont efficacement limités.

Cette approche limite efficacement les adresses IP abusives sans affecter les utilisateurs légitimes, offrant ainsi une solution évolutive et économe en mémoire pour atténuer les attaques DDoS.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!