Sichern Sie Ihre Go-API mit JWT-Authentifizierung

Okay, lasst uns für eine Sekunde real werden. Sicherheit ist eine große Sache, und wenn Sie APIs erstellen, können Sie nicht einfach zulassen, dass jemand hereinspaziert und anfängt, mit Ihren Daten herumzuspielen. Hier kommen JWT (JSON Web Tokens) ins Spiel, um den Tag zu retten. Heute verbessern wir unsere Go-API, indem wir eine JWT-basierte Authentifizierung hinzufügen.

Ein kurzes Heads-Up?

Wenn Sie das alte Paket github.com/dgrijalva/jwt-go verwendet haben, ist es Zeit für ein Upgrade. Der neue Standard ist github.com/golang-jwt/jwt/v4.

Warum der Wechsel?

• Der ursprüngliche Autor hat die Zügel übergeben und die neuen Betreuer waren damit beschäftigt, Verbesserungen vorzunehmen und Sicherheitsprobleme zu beheben.
• Ab Version 4.0.0 wurde die Go-Modulunterstützung hinzugefügt und die Token-Validierung verbessert.
• Schauen Sie sich deren MIGRATION_GUIDE.md an, wenn Sie noch das alte Paket verwenden.

Jetzt fangen wir mit unserer schicken neuen JWT-Bibliothek an!

Was ist nochmal JWT? ?

Für diejenigen, die neu bei JWT sind:

• Es ist wie ein unterschriebener Erlaubniszettel für den Zugriff auf Ihre API.
• Die API generiert ein Token, signiert es und der Client (Benutzer, App usw.) fügt dieses Token in jede Anfrage ein.
• Der Server überprüft das Token und sagt: „Ja, Sie sind echt.“

Jetzt, da Sie auf dem Laufenden sind, tauchen wir in den Code ein!

Einrichten des Projekts

Wir machen dort weiter, wo wir im letzten Beitrag aufgehört haben. Aktualisieren wir unser Go-Modul und installieren die erforderlichen Pakete:

1. Fügen Sie das JWT-Paket und den Mux-Router hinzu:

   go get github.com/golang-jwt/jwt/v4
   go get github.com/gorilla/mux

1. Öffnen Sie Ihre main.go-Datei und beginnen Sie mit dem Codieren!

Schritt 1: Generieren Sie ein JWT-Token

Zuerst erstellen wir eine Funktion, die ein JWT-Token generiert, wenn sich ein Benutzer anmeldet. Dieses Token enthält den Benutzernamen und wird mit einem geheimen Schlüssel signiert.

var jwtKey = []byte("my_secret_key")

type Credentials struct {
    Username string `json:"username"`
    Password string `json:"password"`
}

type Claims struct {
    Username string `json:"username"`
    jwt.RegisteredClaims
}

func generateToken(username string) (string, error) {
    expirationTime := time.Now().Add(5 * time.Minute)

    claims := &Claims{
        Username: username,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(expirationTime),
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString(jwtKey)
    return tokenString, err
}

Diese Funktion generiert ein Token, das nach 5 Minuten abläuft und mit dem HS256-Algorithmus signiert ist.

Schritt 2: Erstellen Sie den Anmeldeendpunkt

Als nächstes erstellen wir einen Anmeldeendpunkt, an den Benutzer ihre Anmeldeinformationen senden. Wenn die Anmeldeinformationen ausgecheckt werden, generieren wir ein JWT und senden es in einem Cookie zurück.

func login(w http.ResponseWriter, r *http.Request) {
    var creds Credentials
    err := json.NewDecoder(r.Body).Decode(&creds)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    if creds.Username != "admin" || creds.Password != "password" {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }

    token, err := generateToken(creds.Username)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    http.SetCookie(w, &http.Cookie{
        Name:    "token",
        Value:   token,
        Expires: time.Now().Add(5 * time.Minute),
    })
}

Schritt 3: Middleware für die JWT-Validierung

Jetzt benötigen wir eine Middleware-Funktion, um JWT-Tokens zu validieren, bevor wir den Zugriff auf geschützte Routen erlauben.

func authenticate(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        c, err := r.Cookie("token")
        if err != nil {
            if err == http.ErrNoCookie {
                w.WriteHeader(http.StatusUnauthorized)
                return
            }
            w.WriteHeader(http.StatusBadRequest)
            return
        }

        tokenStr := c.Value
        claims := &Claims{}

        tkn, err := jwt.ParseWithClaims(tokenStr, claims, func(token *jwt.Token) (interface{}, error) {
            return jwtKey, nil
        })

        if err != nil || !tkn.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }

        next.ServeHTTP(w, r)
    })
}

Diese Middleware prüft, ob die Anfrage über ein gültiges JWT-Token verfügt. Wenn nicht, wird eine nicht autorisierte Antwort zurückgegeben.

Schritt 4: Routen schützen

Nun wenden wir unsere Authentifizierungs-Middleware an, um die /books-Route zu schützen:

func main() {
    r := mux.NewRouter()

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Testen der API

1. Anmelden, um ein Token zu generieren:

   curl -X POST http://localhost:8000/login -d '{"username":"admin", "password":"password"}' -H "Content-Type: application/json"

1. Greifen Sie auf den geschützten /books-Endpunkt zu:

   curl --cookie "token=<your_token>" http://localhost:8000/books

Wenn der Token gültig ist, erhalten Sie Zugriff. Wenn nicht, erhalten Sie die Meldung „401 nicht autorisiert“.

Was kommt als nächstes?

Nächstes Mal verbinden wir unsere API mit einer Datenbank, um Benutzeranmeldeinformationen zu verwalten und Daten zu speichern. Bleiben Sie dran für mehr!

Das obige ist der detaillierte Inhalt vonSichern Sie Ihre Go-API mit JWT-Authentifizierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!