Cara melaksanakan pengesahan dan kebenaran menggunakan Golang

Dengan pembangunan berterusan aplikasi Internet, pengesahan dan kebenaran pengguna menjadi semakin penting. Pengesahan ialah proses mengesahkan bahawa pengguna mempunyai kebenaran untuk mengakses sistem, manakala kebenaran ialah proses menentukan tindakan yang boleh dilakukan oleh pengguna. Dalam artikel ini, kita akan membincangkan cara melaksanakan pengesahan dan kebenaran menggunakan Golang.

1. Pengesahan menggunakan JWT

JWT (Token Web JSON) ialah cara padat dan serba lengkap untuk mewakili identiti pengguna. Ia mengandungi metadata dan tuntutan yang boleh disahkan dan dinyahkod. Secara umumnya, JWT mengandungi tiga bahagian: pengepala, muatan dan tandatangan.

Golang menyediakan banyak perpustakaan berguna untuk membantu kami melaksanakan JWT, seperti: jwt-go. Menjana, menyahkod dan mengesahkan JWT adalah mudah menggunakan perpustakaan jwt-go. Berikut ialah contoh kod yang menggunakan perpustakaan jwt-go untuk menjana JWT:

import (
    "time"
    "github.com/dgrijalva/jwt-go"
)
  
func CreateToken(userId string) (string, error) {
    token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
        "user_id": userId,
        "exp":     time.Now().Add(time.Hour * 24).Unix(),
    })
  
    return token.SignedString([]byte("your-secret"))
}

Dalam kod di atas, kami mencipta JWT yang mengandungi ID pengguna semasa dan masa tamat tempoh. Kemudian tandatangani JWT menggunakan kaedah jwt.SigningMethodHS256 dan kekunci "rahsia anda". Akhirnya, rentetan JWT dikembalikan kepada pemanggil.

Untuk setiap permintaan HTTP, kami boleh menggunakan JWT untuk pengesahan. Setelah pengguna berjaya log masuk, kami boleh mengembalikan JWT yang dijana kepada pelanggan. Pelanggan boleh menghantar JWT ke pelayan sebagai sebahagian daripada pengepala "Kebenaran" pada setiap permintaan berikutnya. Pelayan menyahkod JWT dan mengesahkan tandatangan untuk memastikan ia sah. Berikut ialah contoh kod untuk mengesahkan JWT menggunakan perpustakaan jwt-go:

import (
    "net/http"
    "github.com/dgrijalva/jwt-go"
)
  
func ValidateTokenMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenHeader := r.Header.Get("Authorization")
        if tokenHeader == "" {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
  
        token, err := jwt.Parse(tokenHeader, func(token *jwt.Token) (interface{}, error) {
            return []byte("your-secret"), nil
        })
  
        if err != nil || !token.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }
  
        next.ServeHTTP(w, r)
    })
}

Dalam kod di atas, kami telah menentukan perisian tengah yang dipanggil ValidateTokenMiddleware, yang bertanggungjawab untuk mengesahkan JWT. ValidateTokenMiddleware akan menyemak sama ada pengepala HTTP mengandungi token Kebenaran dan mengesahkannya. Jika JWT tidak sah, ia mengembalikan respons HTTP 401 Tidak dibenarkan. Jika tidak, ia akan meneruskan pemprosesan permintaan.

Menggunakan JWT untuk pengesahan memastikan permintaan itu datang daripada pengguna yang sah dan memberikan keselamatan yang lebih besar.

2. Gunakan peranan untuk kebenaran

Dalam aplikasi web moden, pengguna selalunya mesti mempunyai peranan dan kebenaran yang berbeza. Sebagai contoh, pentadbir mungkin mempunyai kebenaran untuk melaksanakan operasi peringkat lebih tinggi yang tidak dimiliki oleh pengguna biasa. Oleh itu, kami perlu membenarkan peranan pengguna yang berbeza secara berasingan.

Di Golang, pendekatan yang popular ialah menggunakan model kawalan akses berasaskan peranan (RBAC). Dalam model RBAC, setiap peranan diberikan kebenaran yang berbeza dan pengguna diberikan kepada satu atau lebih peranan. Kemudian, sebelum melakukan tindakan tertentu, sistem menyemak sama ada pengguna mempunyai kebenaran untuk melakukan tindakan tersebut.

Berikut ialah contoh kod menggunakan model kawalan akses berasaskan peranan:

type Role string
  
const (
    AdminRole  Role = "admin"
    UserRole   Role = "user"
)
  
type User struct {
    ID    string `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email"`
    Role  Role   `json:"role"`
}
  
// Check if the user has permission to access the resource based on the specified role.
func HasPermission(user *User, requiredRole Role) bool {
    return user.Role == requiredRole || user.Role == AdminRole
}

Dalam kod di atas, kami mentakrifkan jenis penghitungan yang dipanggil Peranan, yang mengandungi Senarai peranan yang digunakan dalam aplikasi . Dalam struktur Pengguna, kami menetapkan setiap pengguna kepada satu atau lebih peranan dan menggunakan fungsi HasPermission untuk menyemak sama ada pengguna mempunyai kebenaran untuk melaksanakan operasi tertentu. Dalam contoh ini, fungsi HasPermission akan kembali benar hanya jika peranan pengguna ialah AdminRole atau requiredRole.

Kami juga boleh menggunakan kaedah lain seperti menggunakan perisian tengah untuk menyemak peranan dan kebenaran pengguna. Berikut ialah contoh kod berdasarkan middleware:

func AdminOnlyMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        user, ok := r.Context().Value("user").(*User)
        if !ok || !HasPermission(user, AdminRole) {
            w.WriteHeader(http.StatusForbidden)
            return
        }
  
        next.ServeHTTP(w, r)
    })
}

Dalam kod di atas, kami mentakrifkan middleware yang dipanggil AdminOnlyMiddleware. Perisian tengah ini akan mendapat peranan pengguna daripada konteks permintaan HTTP dan menyemak sama ada pengguna mempunyai kebenaran yang diperlukan untuk melaksanakan tindakan tersebut. Jika pengguna tidak mempunyai kebenaran, ia akan mengembalikan respons HTTP 403 Forbidden.

Jika kami menggunakan aplikasi berasaskan rangka kerja web, kami boleh mendaftarkan middleware terus pada laluan. Contohnya, kami boleh mendaftarkan AdminOnlyMiddleware untuk titik akhir API yang memerlukan hak pentadbir:

router.Handle("/api/dashboard", AdminOnlyMiddleware(http.HandlerFunc(handler)))

Dalam kod di atas, hanya pengguna yang mempunyai hak pentadbir boleh mengakses titik akhir "/api/dashboard".

Ringkasan

Dalam artikel ini, kami memperkenalkan cara melaksanakan pengesahan dan kebenaran menggunakan Golang. Kami menggunakan JWT untuk mengesahkan bahawa pengguna mempunyai kebenaran untuk mengakses sistem dan model kawalan akses berasaskan peranan untuk menyemak sama ada pengguna mempunyai kebenaran untuk melakukan tindakan tertentu. Teknologi ini boleh membantu kami mencipta aplikasi web yang selamat, berskala dan mudah diselenggara.

Atas ialah kandungan terperinci Cara melaksanakan pengesahan dan kebenaran menggunakan Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!