Pembelajaran Golang Pengesahan dan kebenaran pelayan web

Golang ialah bahasa baru muncul, terutamanya sesuai untuk melaksanakan perkhidmatan web. Dalam perkhidmatan Web, pengesahan dan kebenaran adalah mekanisme keselamatan yang sangat penting. Artikel ini akan memperkenalkan cara melaksanakan pengesahan dan kebenaran pelayan Web di Golang.

Pengesahan merujuk kepada mengesahkan identiti pengguna dan menentukan sama ada dia mempunyai hak untuk mengakses sumber. Kaedah pengesahan biasa termasuk nama pengguna dan kata laluan, token, dsb. Keizinan merujuk kepada menentukan sama ada pengguna mempunyai kebenaran untuk mengakses sumber. Biasanya termasuk kaedah kawalan capaian berasaskan peranan dan kaedah kebenaran kawalan capaian berasaskan sumber.

Pelbagai rangka kerja dan perpustakaan boleh digunakan di Golang untuk melaksanakan pengesahan dan kebenaran perkhidmatan web. Artikel ini mengambil rangka kerja Gin sebagai contoh untuk memperkenalkan cara melaksanakan pengesahan berasaskan token dan kebenaran berasaskan peranan.

1. Pengesahan berasaskan Token

Dalam rangka kerja Gin, JWT (Json Web Token) boleh digunakan untuk melaksanakan pengesahan berasaskan token. JWT ialah standard terbuka yang mentakrifkan cara ringkas dan serba lengkap untuk menghantar maklumat dengan selamat melalui web. JWT terdiri daripada tiga bahagian: Pengepala, Muatan dan Tandatangan. Pengepala

digunakan untuk menerangkan jenis token dan algoritma tandatangan, contohnya:

{"alg": "HS256", "typ": "JWT"}

Muatan digunakan untuk menyimpan maklumat yang perlu dihantar, seperti nama pengguna, peranan, dsb., contohnya:

{"sub": "123456789", "name": "John Doe", "iat": 1516239022}

Tandatangan digunakan untuk mengelakkan maklumat daripada diganggu dan kunci peribadi perlu digunakan untuk tandatangan, contohnya:

HMACSHA256(
base64UrlEncode(header) + "." +
base64UrlEncode(payload),
secret)

Di Golang, anda boleh menggunakan perpustakaan github.com/dgrijalva/jwt-go untuk mencapai penjanaan JWT dan pengesahan. Sebagai contoh:

// Cipta objek token baharu, nyatakan kaedah menandatangani dan tuntutan yang anda mahukan.
token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{

"sub": "1234567890",
"name": "John Doe",
"iat": 1516239022,

})

// Tandatangani dan dapatkan token yang dikodkan lengkap sebagai rentetan menggunakan rahsia
tokenString, err := token.SignedString([]byte("secret"))

// Parse token untuk mengesahkan kesahihannya dan ekstrak tuntutan
token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, func(token *jwt.Token) (antara muka{}, ralat ) {

return []byte("secret"), nil

})

Dalam rangka kerja Gin, anda boleh menggunakan perpustakaan gin-jwt untuk membina mekanisme pengesahan berasaskan JWT dengan cepat. Contohnya:

// Cipta perisian tengah JWT baharu dengan kunci tandatangan yang ditentukan
perisian tengah := jwtmiddleware.New(jwtmiddleware.Options{

SigningMethod:   jwt.SigningMethodHS256,
Claims:          &CustomClaims{},
KeyFunc: func(token *jwt.Token) (interface{}, error) {
    // Check the signing method and return the key for verifying the signature
    if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
        return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
    }
    return []byte("secret"), nil
},

})

// Gunakan middleware dalam laluan Gin untuk melindungi sumber
router.GET("/protected", middleware.MiddlewareFunc(), func(c *gin.Context) {

claims := jwtmiddleware.ExtractClaims(c)
user := claims["user"].(string)
c.JSON(200, gin.H{
    "user": user,
    "message": "Hello, World!",
})

})

2. Keizinan berasaskan peranan

Dalam rangka kerja Gin, kebenaran berasaskan peranan boleh digunakan untuk menyekat akses pengguna kepada sumber. Sebagai contoh, dalam aplikasi blog, peranan digunakan untuk membezakan pengguna biasa dan pentadbir. Pentadbir boleh mengakses semua sumber Blog, manakala pengguna biasa hanya boleh mengakses sumber Blog yang diterbitkan oleh mereka sendiri.

Anda boleh menggunakan perpustakaan gin-authz untuk melaksanakan kebenaran berasaskan peranan. Contohnya:

// Tentukan perisian tengah keizinan untuk menguatkuasakan akses berasaskan peranan
authMiddleware := authz.NewAuthorizer(authz.BuiltinRolebased())

// Tentukan peranan- dasar berasaskan untuk memberikan akses peranan "admin" kepada semua sumber
peranan pentadbir := authz.NewRole("admin", []string{"*"})
policy := authz.NewPolicy()
policy .AddRole(adminRole)

// Gunakan perisian tengah dasar dalam laluan Gin untuk menguatkuasakan kawalan akses berasaskan peranan
router.GET("/blogs", authMiddleware.CheckPermission(policy, "admin " ), func(c *gin.Context) {

// Return the list of all blogs

})

router.GET("/blog/:id", authMiddleware.CheckPermission(dasar, "baca"), func (c *gin.Context) {

// Return the specified blog

})

router.POST("/blog", authMiddleware.CheckPermission(dasar, "write"), func(c *gin. Konteks ) {

// Create a new blog

})

Dalam kod di atas, peranan bernama "admin" ditakrifkan, yang mempunyai akses kepada semua sumber ("*"). Kemudian, dalam setiap laluan, semak sama ada peranan pengguna mempunyai akses kepada sumber dengan menggunakan fungsi authMiddleware.CheckPermission.

Ringkasan

Artikel ini memperkenalkan cara melaksanakan pengesahan dan kebenaran pelayan Web di Golang. Dengan menggunakan rangka kerja Gin dan perpustakaan yang berkaitan, kami boleh membina perkhidmatan web yang selamat dan boleh dipercayai dengan cepat.

Atas ialah kandungan terperinci Pembelajaran Golang Pengesahan dan kebenaran pelayan web. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!