Comment mettre en œuvre l'interdiction des accès IP fréquents à Golang

Dans le développement d'applications, interdire les accès fréquents est une mesure de sécurité clé qui peut vous aider à prévenir diverses attaques, telles que les attaques DDOS. Cet article explique comment utiliser Golang pour écrire un programme simple permettant d'interdire les accès fréquents aux adresses IP.

Idée de mise en œuvre

La méthode de mise en œuvre consistant à interdire les accès fréquents par adresses IP est principalement réalisée en limitant le nombre d'accès pour chaque adresse IP. L'idée spécifique est la suivante :

1. Créer une carte pour enregistrer le nombre de visites sur chaque adresse IP.
2. Lorsqu'une adresse IP accède à notre application, augmentez la valeur du compteur de l'adresse IP dans la carte.
3. Si nous constatons que le compteur de l'adresse IP a dépassé les délais limites spécifiés, nous mettrons l'adresse IP sur liste noire et interdirons l'accès à notre application.
4. Vous pouvez définir le délai d'expiration du compteur pour vous assurer que la liste noire des adresses IP ne dure pas trop longtemps.

Implémentation du code

Ce qui suit est un exemple de code qui utilise Golang pour implémenter l'idée ci-dessus :

package main

import (
    "fmt"
    "net"
    "sync"
    "time"
)

const (
    MaxRequestsPerIP = 10      // 每个IP最大请求数
    BlacklistTimeout = 60 * 5  // 黑名单超时时间(秒)
)

type IPRequests struct {
    Requests   int       // 请求计数器
    LastAccess time.Time // 最后一次访问时间
}

var (
    lock         sync.RWMutex
    ipRequestMap = make(map[string]*IPRequests)
    blacklist    = make(map[string]time.Time)
)

// 判断IP是否在黑名单内
func isBlacklisted(ip string) bool {
    lock.RLock()
    defer lock.RUnlock()
    if blacklistedTime, ok := blacklist[ip]; ok {
        if time.Since(blacklistedTime) < time.Second*BlacklistTimeout {
            return true
        } else {
            // 超时，从黑名单中删除 
            lock.Lock()
            delete(blacklist, ip)
            lock.Unlock()
        }
    }
    return false
}

// 记录IP访问次数
func recordIPRequest(ip string) {
    lock.Lock()
    defer lock.Unlock()
    req, ok := ipRequestMap[ip]
    if !ok {
        req = &IPRequests{}
        ipRequestMap[ip] = req
    }
    req.Requests++
    req.LastAccess = time.Now()
    // 如果IP访问次数过多，将其列入黑名单
    if req.Requests > MaxRequestsPerIP {
        blacklist[ip] = time.Now()
    }
}

// 启动HTTP服务器
func StartHttpServer() {
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        ip, _, _ := net.SplitHostPort(r.RemoteAddr)
        // 如果IP地址在黑名单内，则拒绝访问
        if isBlacklisted(ip) {
            http.Error(w, http.StatusText(http.StatusForbidden), http.StatusForbidden)
            return
        }
        // 记录IP地址的访问次数
        recordIPRequest(ip)
        // 处理请求
        fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
    })
    http.ListenAndServe(":8080", nil)
}

func main() {
    StartHttpServer()
}

Dans le code ci-dessus, nous utilisons une carte (ipRequestMap) pour enregistrer le nombre de visites à chaque adresse IP, et un mapper (liste noire) pour stocker les informations de la liste noire. Lorsqu'une adresse IP accède à notre application, nous vérifions d'abord si l'adresse IP est dans la liste noire, et si c'est le cas, renvoyons 403 Access Forbidden. Sinon, enregistrez le nombre de visites sur l'adresse IP. Lorsque le nombre de visites sur une adresse IP dépasse le seuil spécifié (MaxRequestsPerIP), nous mettons l'adresse IP sur liste noire et interdisons l'accès à notre application.

Dans la fonction isBlacklisted(), nous déterminons si une IP est dans la liste noire. Si tel est le cas, renvoyez true, indiquant à la fonction StartHttpServer() que nous devons rejeter les demandes de cette IP. Dans le même temps, si l'IP a dépassé le délai d'expiration de la liste noire (BlacklistTimeout), elle sera supprimée de la liste noire.

Dans la fonction recordIPRequest(), nous utilisons RWMutex (RW mutex lock) pour garantir la sécurité de la concurrence. Cette fonction est utilisée pour enregistrer le nombre de fois qu'une adresse IP est accédée. Si l'adresse IP atteint la limite que nous avons fixée, elle sera mise sur liste noire.

Résumé

La méthode pour utiliser Golang pour interdire les accès IP fréquents est très simple. Il suffit de mettre en place un compteur et une liste noire. Mais en pratique, nous devons fixer des seuils appropriés en fonction de nos propres besoins. Dans l'exemple de cet article, nous utilisons deux seuils : le nombre maximum de requêtes (MaxRequestsPerIP) et le timeout de la liste noire (BlacklistTimeout). En pratique, vous pouvez fixer un seuil plus approprié en fonction de la situation spécifique.

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!