Implementierung der JWT-Authentifizierung in der Go-API

JWT (JSON Web Token) ist eine äußerst effektive Methode zum Sichern von APIs durch tokenbasierte Authentifizierung und stellt sicher, dass nur authentifizierte Benutzer auf Ihre API-Endpunkte zugreifen können. Im Gegensatz zu herkömmlichen sitzungsbasierten Ansätzen ist JWT zustandslos, sodass keine serverseitige Sitzungsspeicherung erforderlich ist, was es ideal für skalierbare und leistungsstarke Anwendungen macht. In diesem Leitfaden führen wir Sie durch die Implementierung der JWT-Authentifizierung in einer Go-API, von der Generierung von Tokens bei der Benutzeranmeldung bis hin zur Sicherung Ihrer Endpunkte durch Validierung dieser Tokens, um letztendlich die Sicherheit und Robustheit der Daten und Ressourcen Ihrer Anwendung zu verbessern.

Voraussetzungen

• Gehen Sie 1,21

Setup-Projekt

go mod init app
go get github.com/gin-gonic/gin@v1.5.0
go get github.com/golang-jwt/jwt
go get github.com/joho/godotenv 

Projektstruktur

├─ .env
├─ main.go
├─ middleware
│  └─ authenticate.go
└─ public
   ├─ index.html
   └─ login.html

Projektdateien

.env

jwt_secret = b0WciedNJvFCqFRbB2A1QhZoCDnutAOen5g1FEDO0HsLTwGINp04GXh2OXVpTqQL

Diese .env-Datei enthält eine einzelne Umgebungsvariable jwt_secret, die einen geheimen Schlüssel enthält, der zum Signieren und Überprüfen von JWT-Tokens in der Anwendung verwendet wird.

Authenticate.go

package middleware

import (
    "net/http"
    "os"
    "strings"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt"
)

type Claims struct {
    Id int `json:"id"`
    Name string `json:"name"`
    jwt.StandardClaims
}

func Authenticate() gin.HandlerFunc {
    return func(c *gin.Context) {
        if c.Request.URL.Path == "/" || c.Request.URL.Path == "/login" {
            c.Next()
            return
        }
        authHeader := c.GetHeader("Authorization")
        if authHeader == "" {
            c.Status(http.StatusUnauthorized)
            c.Abort()
            return
        }
        tokenString := strings.TrimPrefix(authHeader, "Bearer ")
        token, err := jwt.ParseWithClaims(tokenString, &Claims{}, func(token *jwt.Token) (interface{}, error) {
            return []byte(os.Getenv("jwt_secret")), nil
        })
        if err != nil || !token.Valid {
            c.Status(http.StatusUnauthorized)
            c.Abort()
            return
        }
        if claims, ok := token.Claims.(*Claims); ok {
            c.Set("user", claims)
        } else {
            c.Status(http.StatusUnauthorized)
            c.Abort()
            return
        }
        c.Next()
    }
}

Die Authenticate.go-Middleware definiert eine Funktion für die JWT-Authentifizierung in einer Go-API unter Verwendung des Gin-Frameworks. Es prüft, ob die Anforderung für die Pfade / oder /login gilt. In diesem Fall ist keine Authentifizierung erforderlich. Für andere Routen ruft es den Authorization-Header ab und erwartet ein Bearer-Token. Das Token wird mithilfe des JWT-Pakets und eines geheimen Schlüssels aus Umgebungsvariablen analysiert und validiert. Wenn das Token ungültig ist oder fehlt, wird die Anfrage mit dem Status „401 Nicht autorisiert“ abgebrochen. Wenn sie gültig sind, werden die Benutzeransprüche (z. B. ID und Name) extrahiert und dem Gin-Kontext hinzugefügt, wodurch der Zugriff auf geschützte Routen ermöglicht wird.

main.go

package main

import (
    "app/middleware"
    "net/http"
    "os"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/golang-jwt/jwt"
    "github.com/joho/godotenv"
)

func main() {
    godotenv.Load()
    router := gin.Default()
    router.Use(middleware.Authenticate())
    router.LoadHTMLFiles("public/index.html", "public/login.html")

    router.GET("/", func(c *gin.Context) {
        c.HTML(http.StatusOK, "index.html", nil)
    })

    router.GET("/login", func(c *gin.Context) {
        c.HTML(http.StatusOK, "login.html", nil)
    })

    router.GET("/user", func(c *gin.Context) {
        user, _ := c.Get("user")
        claims := user.(*middleware.Claims)
        c.JSON(http.StatusOK, gin.H{"name": claims.Name})
    })

    router.POST("/login", func(c *gin.Context) {
        var login map[string]string
        c.BindJSON(&login)
        if login["name"] == "admin" && login["password"] == "1234" {
            token := jwt.NewWithClaims(jwt.SigningMethodHS256, &middleware.Claims{
                Id: 1,
                Name: login["name"],
                StandardClaims: jwt.StandardClaims{
                    IssuedAt: time.Now().Unix(),
                    ExpiresAt: time.Now().Add(24 * time.Hour).Unix(),
                },
            })
            tokenString, _ := token.SignedString([]byte(os.Getenv("jwt_secret")))
            c.JSON(http.StatusOK, gin.H{"token": tokenString})
        } else {
            c.Status(http.StatusBadRequest)
        }
    })
    router.Run()
}

Die main.go-Datei richtet einen Go-Webserver mithilfe des Gin-Frameworks ein, um Routen mit JWT-basierter Authentifizierung zu verarbeiten. Zur Authentifizierung wird Middleware verwendet, die in Anfragen nach gültigen JWT-Tokens sucht. Der Server stellt zwei HTML-Seiten bereit: index.html und login.html, die über die Routen / und /login zugänglich sind.

Für die /user-Route ruft der Server den Namen des authentifizierten Benutzers aus den JWT-Ansprüchen ab und gibt ihn in der Antwort zurück. Für die POST-Route /login validiert der Server die Benutzeranmeldeinformationen (Name und Passwort) und generiert, falls gültig, ein JWT-Token, signiert es mit einem geheimen Schlüssel und sendet es an den Client zurück. Der Server ist so konfiguriert, dass er auf Anfragen wartet und auf dem Standardport ausgeführt wird.

index.html

    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/css/bootstrap.min.css" rel="stylesheet">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" rel="stylesheet">


    <div>



<p>The index.html is a simple web page that provides a user interface for displaying the login status of a user. It uses Bootstrap for styling and Font Awesome for icons. On page load, it checks the user's authentication status by sending a request to the server with a JWT token stored in localStorage. If the user is logged in, it shows a success message with the user's name and a logout button. If not logged in, it shows a message indicating the user is not logged in and redirects them to the login page after a few seconds.</p>

<h3>
  
  
  login.html
</h3>



<pre class="brush:php;toolbar:false">


    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width,initial-scale=1">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/bootstrap/5.3.3/css/bootstrap.min.css" rel="stylesheet">
    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.5.0/css/all.min.css" rel="stylesheet">


    <div>



<p>The login.html page provides a simple login form where users can input their username and password. It uses Bootstrap for styling and Font Awesome for icons. When the user submits the form, a JavaScript function login() sends a POST request to the /login endpoint with the entered credentials. If the login is successful, the server returns a JWT token, which is stored in localStorage. The page then redirects the user to the home page (/). If the login fails, an error message is displayed.</p>

<h2>
  
  
  Run project
</h2>



<pre class="brush:php;toolbar:false">go run main.go

Öffnen Sie den Webbrowser und gehen Sie zu http://localhost:8080

Sie finden diese Testseite.

Testen

Nach ein paar Sekunden werden Sie zur Anmeldeseite weitergeleitet.

Drücken Sie die Anmeldeschaltfläche und Sie werden auf der Startseite angemeldet, auf der der Name des angemeldeten Benutzers angezeigt wird.

Versuchen Sie, den Browser zu aktualisieren, und Sie werden sehen, dass Sie immer noch angemeldet sind. Klicken Sie dann auf die Schaltfläche „Abmelden“. Das JWT-Token wird entfernt und Sie werden erneut zur Anmeldeseite weitergeleitet.

Abschluss

Zusammenfassend lässt sich sagen, dass die Implementierung der JWT-Authentifizierung in einer Go-API einen sicheren und skalierbaren Ansatz für die Benutzerauthentifizierung bietet. Durch die Verwendung des Gin-Frameworks zusammen mit dem Paket golang-jwt/jwt können wir die tokenbasierte Authentifizierung problemlos in unsere Anwendung integrieren. JWT-Tokens werden während der Anmeldung generiert, um Benutzeranmeldeinformationen sicher zu validieren und Zugriff auf geschützte Routen zu gewähren. Die Middleware stellt sicher, dass nur authentifizierte Benutzer auf diese Routen zugreifen können, indem sie die Gültigkeit des Tokens überprüft. Dieser zustandslose Authentifizierungsmechanismus bietet verbesserte Leistung und Flexibilität und ist somit eine ideale Wahl für moderne API-Architekturen.

Quellcode: https://github.com/stackpuz/Example-JWT-Go

Erstellen Sie in wenigen Minuten eine CRUD-Web-App: https://stackpuz.com