So implementieren Sie ein Verbot des häufigen IP-Zugriffs in Golang

Bei der Anwendungsentwicklung ist das Verbot häufigen Zugriffs eine wichtige Sicherheitsmaßnahme, die Ihnen helfen kann, verschiedene Angriffe, wie z. B. DDOS-Angriffe, zu verhindern. In diesem Artikel wird erläutert, wie Sie mit Golang ein einfaches Programm schreiben, um den häufigen Zugriff auf IP-Adressen zu verhindern.

Implementierungsidee

Die Implementierungsmethode zum Verhindern des häufigen Zugriffs durch IP-Adressen wird hauptsächlich durch die Begrenzung der Anzahl der Zugriffe für jede IP-Adresse erreicht. Die konkrete Idee lautet wie folgt:

1. Erstellen Sie eine Karte, um die Anzahl der Besuche jeder IP-Adresse aufzuzeichnen.
2. Wenn eine IP-Adresse auf unsere Anwendung zugreift, erhöhen Sie den Wert des Zählers der IP-Adresse in der Karte.
3. Wenn wir feststellen, dass der Zähler der IP-Adresse die angegebenen Grenzzeiten überschritten hat, werden wir die IP-Adresse auf die schwarze Liste setzen und den Zugriff auf unsere Anwendung verbieten.
4. Sie können den Timeout des Zählers einstellen, um sicherzustellen, dass die Blacklist der IP-Adressen nicht zu lange bestehen bleibt.

Code-Implementierung

Das Folgende ist ein Codebeispiel, das Golang verwendet, um die obige Idee zu implementieren:

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()
}

Im obigen Code verwenden wir eine Karte (ipRequestMap), um die Anzahl der Besuche an jeder IP-Adresse aufzuzeichnen, und a Karte (Blacklist) zum Speichern von Blacklist-Informationen. Wenn eine IP-Adresse auf unsere Anwendung zugreift, prüfen wir zunächst, ob die IP-Adresse auf der Blacklist steht und geben in diesem Fall 403 Access Forbidden zurück. Wenn nicht, erfassen Sie die Anzahl der Besuche der IP-Adresse. Wenn die Anzahl der Besuche einer IP-Adresse den angegebenen Schwellenwert (MaxRequestsPerIP) überschreitet, setzen wir die IP-Adresse auf die schwarze Liste und verbieten den Zugriff auf unsere Anwendung.

In der Funktion isBlacklisted() ermitteln wir, ob sich eine IP in der Blacklist befindet. Wenn ja, geben Sie true zurück und teilen Sie der StartHttpServer()-Funktion mit, dass wir Anfragen von dieser IP ablehnen sollen. Wenn die IP gleichzeitig das Blacklist-Timeout (BlacklistTimeout) überschritten hat, wird sie aus der Blacklist gelöscht.

In der Funktion recordIPRequest() verwenden wir RWMutex (RW-Mutex-Sperre), um die Sicherheit der Parallelität zu gewährleisten. Mit dieser Funktion wird die Anzahl der Zugriffe auf eine IP-Adresse aufgezeichnet. Wenn die IP das von uns festgelegte Limit erreicht, wird sie auf die schwarze Liste gesetzt.

Zusammenfassung

Die Methode, mit Golang häufigen IP-Zugriff zu verbieten, ist sehr einfach. Wir müssen lediglich einen Zähler und eine Blacklist implementieren. In der Praxis müssen wir jedoch geeignete Schwellenwerte entsprechend unseren eigenen Bedürfnissen festlegen. Im Beispiel dieses Artikels verwenden wir zwei Schwellenwerte: die maximale Anzahl von Anfragen (MaxRequestsPerIP) und das Blacklist-Timeout (BlacklistTimeout). In der Praxis können Sie je nach Situation einen geeigneteren Schwellenwert festlegen.

Das obige ist der detaillierte Inhalt vonSo implementieren Sie ein Verbot des häufigen IP-Zugriffs in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!