HTTP 鉴权方法详解:Basic vs Bearer 及其他常见认证方式

package main

import (
    "encoding/base64"
    "fmt"
    "net/http"
)

func basicAuth(username， password string) string {
    auth := username + ":" + password
    return base64.StdEncoding.EncodeToString([]byte(auth))
}

func main() {
    username := "admin"
    password := "123456"
    
    // 生成 Basic 认证凭证
    credentials := basicAuth(username， password)
    fmt.Println("Authorization：Basic"， credentials)
    // 输出：Authorization：Basic YWRtaW46MTIzNDU2
    
    // 发送请求
    req， _ := http.NewRequest("GET"， "https://api.example.com/data"， nil)
    req.Header.Set("Authorization"， "Basic "+credentials)
    
    client := &http.Client{}
    resp， err := client.Do(req)
    if err != nil {
        fmt.Println("请求失败:"， err)
        return
    }
    defer resp.Body.Close()
    
    fmt.Println("状态码:"， resp.StatusCode)
}

func parseBasicAuth(authHeader string) (username， password string， ok bool) {
    // Authorization：Basic YWRtaW46MTIzNDU2
    const prefix = "Basic "
    if !strings.HasPrefix(authHeader， prefix) {
        return ""， ""， false
    }
    
    // 提取 Base64 部分
    encoded := authHeader[len(prefix):]
    decoded， err := base64.StdEncoding.DecodeString(encoded)
    if err != nil {
        return ""， ""， false
    }
    
    // 拆分用户名和密码
    credentials := string(decoded)
    parts := strings.SplitN(credentials， ":"， 2)
    if len(parts) != 2 {
        return ""， ""， false
    }
    
    return parts[0]， parts[1]， true
}

func authMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter， r *http.Request) {
        authHeader := r.Header.Get("Authorization")
        username， password， ok := parseBasicAuth(authHeader)
        
        if !ok {
            w.Header().Set("WWW-Authenticate"， `Basic realm="Restricted"`)
            http.Error(w， "Unauthorized"， http.StatusUnauthorized)
            return
        }
        
        // 验证用户名密码(这里简化处理，实际要查数据库)
        if username != "admin" || password != "123456" {
            http.Error(w， "Invalid credentials"， http.StatusUnauthorized)
            return
        }
        
        next(w， r)
    }
}

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

var secretKey = []byte("your-secret-key")

// 生成 JWT Token
func generateJWT(userID string) (string， error) {
    claims := jwt.MapClaims{
        "user_id"：userID，
        "exp"：    time.Now().Add(time.Hour * 24).Unix()， // 24 小时过期
        "iat"：    time.Now().Unix()，
    }
    
    token := jwt.NewWithClaims(jwt.SigningMethodHS256， claims)
    return token.SignedString(secretKey)
}

// 验证 JWT Token
func validateJWT(tokenString string) (*jwt.MapClaims， error) {
    token， err := jwt.Parse(tokenString， func(token *jwt.Token) (interface{}， error) {
        return secretKey， nil
    })
    
    if err != nil {
        return nil， err
    }
    
    if claims， ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return &claims， nil
    }
    
    return nil， fmt.Errorf("invalid token")
}

func requestWithBearer(token string) {
    req， _ := http.NewRequest("GET"， "https://api.example.com/data"， nil)
    req.Header.Set("Authorization"， "Bearer "+token)
    
    client := &http.Client{}
    resp， _ := client.Do(req)
    defer resp.Body.Close()
    
    fmt.Println("状态码:"， resp.StatusCode)
}

func main() {
    // 假设已经登录拿到 Token
    token := "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
    requestWithBearer(token)
}

func bearerAuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter， r *http.Request) {
        authHeader := r.Header.Get("Authorization")
        
        // 检查 Bearer 前缀
        const prefix = "Bearer "
        if !strings.HasPrefix(authHeader， prefix) {
            http.Error(w， "Missing or invalid token"， http.StatusUnauthorized)
            return
        }
        
        // 提取 Token
        tokenString := authHeader[len(prefix):]
        
        // 验证 JWT
        claims， err := validateJWT(tokenString)
        if err != nil {
            http.Error(w， "Invalid token"， http.StatusUnauthorized)
            return
        }
        
        // 可以把用户信息存到上下文
        userID := (*claims)["user_id"].(string)
        fmt.Println("认证成功，用户 ID:"， userID)
        
        next(w， r)
    }
}