Go语言中实现HTTP基本访问认证（Basic Auth）

package main

import (
    "fmt"
    "net/http"
)

func handleBasicAuth(w http.ResponseWriter, r *http.Request) {
    username, password, ok := r.BasicAuth()

    if !ok {
        // 如果没有提供Basic Auth头部，或者格式不正确
        w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 在这里进行用户名和密码的验证
    // 实际应用中，这里应该查询数据库或配置进行验证
    if username == "admin" && password == "secret" {
        fmt.Fprintf(w, "Hello, %s! You are authenticated.", username)
    } else {
        w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
        http.Error(w, "Invalid credentials", http.StatusUnauthorized)
    }
}

func main() {
    http.HandleFunc("/", handleBasicAuth)
    fmt.Println("Server listening on :8080")
    http.ListenAndServe(":8080", nil)
}

package main

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

func handleManualBasicAuth(w http.ResponseWriter, r *http.Request) {
    authHeader := r.Header.Get("Authorization")
    if authHeader == "" {
        w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
        return
    }

    // 检查是否是Basic认证
    if !strings.HasPrefix(authHeader, "Basic ") {
        w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
        http.Error(w, "Unauthorized: Invalid auth scheme", http.StatusUnauthorized)
        return
    }

    // 提取Base64编码的凭证部分
    base64Creds := authHeader[len("Basic "):]

    // Base64解码
    decodedCreds, err := base64.StdEncoding.DecodeString(base64Creds)
    if err != nil {
        http.Error(w, "Unauthorized: Invalid Base64 encoding", http.StatusBadRequest)
        return
    }

    // 分割用户名和密码
    creds := strings.SplitN(string(decodedCreds), ":", 2)
    if len(creds) != 2 {
        http.Error(w, "Unauthorized: Invalid credentials format", http.StatusBadRequest)
        return
    }

    username := creds[0]
    password := creds[1]

    // 验证用户名和密码
    if username == "manual_user" && password == "manual_pass" {
        fmt.Fprintf(w, "Hello, %s! You are authenticated via manual parsing.", username)
    } else {
        w.Header().Set("WWW-Authenticate", `Basic realm="Restricted"`)
        http.Error(w, "Invalid credentials", http.StatusUnauthorized)
    }
}

func main() {
    http.HandleFunc("/manual", handleManualBasicAuth)
    fmt.Println("Manual Basic Auth server listening on :8081")
    http.ListenAndServe(":8081", nil)
}

package main

import (
    "fmt"
    "log"
    "net/http"
)

// authenticateMiddleware 是一个中间件，用于处理Basic Auth
func authenticateMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        username, password, ok := r.BasicAuth()

        // 假设的有效凭证
        const expectedUser = "myuser"
        const expectedPass = "mypassword"

        if !ok || username != expectedUser || password != expectedPass {
            // 设置WWW-Authenticate头部，提示客户端进行认证
            w.Header().Set("WWW-Authenticate", `Basic realm="Restricted Area"`)
            http.Error(w, "Unauthorized: Access Denied", http.StatusUnauthorized)
            log.Printf("Failed authentication attempt from %s for user %s", r.RemoteAddr, username)
            return
        }

        // 认证成功，继续处理请求
        log.Printf("User %s authenticated successfully from %s", username, r.RemoteAddr)
        next(w, r)
    }
}

// protectedHandler 是一个受保护的资源处理函数
func protectedHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the protected area! You are authenticated.")
}

func main() {
    // 将authenticateMiddleware应用于protectedHandler
    http.HandleFunc("/protected", authenticateMiddleware(protectedHandler))

    fmt.Println("Server started on :8080. Access /protected with Basic Auth.")
    log.Fatal(http.ListenAndServe(":8080", nil))
}