Authentifizierung und Autorisierung in Go (Golang) |…

Authentifizierung und Autorisierung in Go (Golang)

Die Sicherheit von Webanwendungen in Go beginnt mit der korrekten Implementierung von Authentifizierungsmechanismen (Überprüfung "wer Sie sind") und Autorisierungsmechanismen (Überprüfung "was Sie tun dürfen"). In diesem Artikel werden wir drei grundlegende Ansätze behandeln: JWT (JSON Web Tokens), OAuth2 und Session-basierte Authentifizierung. Jeder hat seine eigenen Anwendungsszenarien, Vorteile und Nachteile.

1. Authentifizierung mit JWT (JSON Web Token)

JWT ist eine kompakte und eigenständige Methode zur Übertragung von Informationen zwischen Parteien als JSON-Objekt. In Go wird für die Arbeit mit JWT am häufigsten die Bibliothek github.com/golang-jwt/jwt/v5 verwendet.

Installation:

go get github.com/golang-jwt/jwt/v5

Beispiel für die Erstellung und Überprüfung von JWT:

package main

import (\t"fmt"\t"time"\t"github.com/golang-jwt/jwt/v5")

var jwtSecret = []byte("my_secret_key")

// Token erstellenfunc createToken(userID string) (string, error) {\tclaims := jwt.MapClaims{\t\t"user_id": userID,\t\t"exp":     time.Now().Add(24 * time.Hour).Unix(),\t}\ttoken := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)\treturn token.SignedString(jwtSecret)}

// Token überprüfenfunc validateToken(tokenString string) (string, error) {\ttoken, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {\t\tif _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {\t\t\treturn nil, fmt.Errorf("ungültige Signaturmethode")\t\t}\t\treturn jwtSecret, nil\t})

\tif err != nil {\t\treturn "", err\t}

\tif claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {\t\treturn claims["user_id"].(string), nil\t}\treturn "", fmt.Errorf("ungültiger Token")}

func main() {\ttoken, _ := createToken("user123")\tfmt.Println("Token:", token)

\tuserID, err := validateToken(token)\tif err != nil {\t\tfmt.Println("Fehler:", err)\t} else {\t\tfmt.Println("Benutzer:", userID)\t}}

2. Authentifizierung über OAuth2

OAuth2 ist ein Protokoll für delegierten Zugriff, das es Benutzern ermöglicht, sich über Drittanbieterdienste (Google, GitHub, VK usw.) anzumelden. In Go ist die Bibliothek golang.org/x/oauth2 beliebt.

Installation:

go get golang.org/x/oauth2

Beispiel für OAuth2 mit Google:

package main

import (\t"context"\t"encoding/json"\t"fmt"\t"net/http"\t"golang.org/x/oauth2"\t"golang.org/x/oauth2/google")

var googleOauthConfig = &oauth2.Config{\tRedirectURL:  "http://localhost:8080/callback",\tClientID:     "your-client-id",\tClientSecret: "your-client-secret",\tScopes:       []string{"https://www.googleapis.com/auth/userinfo.email"},\tEndpoint:     google.Endpoint,}

func handleGoogleLogin(w http.ResponseWriter, r *http.Request) {\turl := googleOauthConfig.AuthCodeURL("state-token")\thttp.Redirect(w, r, url, http.StatusTemporaryRedirect)}

func handleCallback(w http.ResponseWriter, r *http.Request) {\tcode := r.URL.Query().Get("code")\ttoken, err := googleOauthConfig.Exchange(context.Background(), code)\tif err != nil {\t\thttp.Error(w, "Fehler beim Token-Austausch", http.StatusInternalServerError)\t\treturn\t}

\t// Benutzerdaten abrufen\tclient := googleOauthConfig.Client(context.Background(), token)\tresp, _ := client.Get("https://www.googleapis.com/oauth2/v2/userinfo")\tdefer resp.Body.Close()

\tvar userInfo map[string]interface{}\tjson.NewDecoder(resp.Body).Decode(&userInfo)\tfmt.Fprintf(w, "E-Mail: %v", userInfo["email"])}

func main() {\thttp.HandleFunc("/auth/google", handleGoogleLogin)\thttp.HandleFunc("/callback", handleCallback)\thttp.ListenAndServe(":8080", nil)}