Menjaga API Go Anda dengan Pengesahan JWT

Baiklah, mari kita lihat keadaan sebenar seketika. Keselamatan adalah masalah besar, dan jika anda membina API, anda tidak boleh membiarkan sesiapa sahaja masuk dan mula mengacaukan data anda. Di situlah JWT (Token Web JSON) datang untuk menyelamatkan hari ini. Hari ini, kami sedang meningkatkan Go API kami dengan menambahkan pengesahan berasaskan JWT.

Makluman Pantas ?

Jika anda telah menggunakan pakej github.com/dgrijalva/jwt-go lama, sudah tiba masanya untuk naik taraf. Piawaian baharu ialah github.com/golang-jwt/jwt/v4.

Kenapa suis?

• Pengarang asal menyerahkan tampuk, dan penyelenggara baharu sibuk membuat penambahbaikan dan membetulkan isu keselamatan.
• Bermula dari versi 4.0.0, mereka menambah sokongan modul Go dan memperbaik pengesahan token.
• Lihat MIGRATION_GUIDE.md mereka jika anda masih menggunakan pakej lama.

Sekarang, mari mulakan dengan perpustakaan JWT baharu kami yang mewah!

Apa itu JWT Lagi? ?

Untuk mereka yang baru menggunakan JWT:

• Ia seperti slip kebenaran yang ditandatangani untuk mengakses API anda.
• API menjana token, menandatanganinya dan pelanggan (pengguna, apl, dll.) menyertakan token itu dalam setiap permintaan.
• Pelayan menyemak token dan berkata, "Ya, anda sah."

Sekarang anda sudah bersedia, mari kita selami kod!

Menyediakan Projek

Kami meneruskan dari tempat kami berhenti dalam siaran lepas. Mari kemas kini modul Go kami dan pasang pakej yang diperlukan:

1. Tambah pakej JWT dan penghala mux:

   go get github.com/golang-jwt/jwt/v4
   go get github.com/gorilla/mux

1. Buka fail main.go anda, dan mari dapatkan pengekodan!

Langkah 1: Jana Token JWT

Pertama, kami akan mencipta fungsi yang menjana token JWT apabila pengguna log masuk. Token ini akan mengandungi nama pengguna dan akan ditandatangani menggunakan kunci rahsia.

var jwtKey = []byte("my_secret_key")

type Credentials struct {
    Username string `json:"username"`
    Password string `json:"password"`
}

type Claims struct {
    Username string `json:"username"`
    jwt.RegisteredClaims
}

func generateToken(username string) (string, error) {
    expirationTime := time.Now().Add(5 * time.Minute)

    claims := &Claims{
        Username: username,
        RegisteredClaims: jwt.RegisteredClaims{
            ExpiresAt: jwt.NewNumericDate(expirationTime),
        },
    }

    token := jwt.NewWithClaims(jwt.SigningMethodHS256, claims)
    tokenString, err := token.SignedString(jwtKey)
    return tokenString, err
}

Fungsi ini menjana token yang tamat tempoh selepas 5 minit, ditandatangani menggunakan algoritma HS256.

Langkah 2: Buat Titik Akhir Log Masuk

Seterusnya, kami akan membina titik akhir log masuk tempat pengguna menghantar bukti kelayakan mereka. Jika maklumat log masuk keluar, kami akan menjana JWT dan menghantarnya semula dalam kuki.

func login(w http.ResponseWriter, r *http.Request) {
    var creds Credentials
    err := json.NewDecoder(r.Body).Decode(&creds)
    if err != nil {
        w.WriteHeader(http.StatusBadRequest)
        return
    }

    if creds.Username != "admin" || creds.Password != "password" {
        w.WriteHeader(http.StatusUnauthorized)
        return
    }

    token, err := generateToken(creds.Username)
    if err != nil {
        w.WriteHeader(http.StatusInternalServerError)
        return
    }

    http.SetCookie(w, &http.Cookie{
        Name:    "token",
        Value:   token,
        Expires: time.Now().Add(5 * time.Minute),
    })
}

Langkah 3: Middleware untuk Pengesahan JWT

Kini, kami memerlukan fungsi middleware untuk mengesahkan token JWT sebelum membenarkan akses kepada laluan yang dilindungi.

func authenticate(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        c, err := r.Cookie("token")
        if err != nil {
            if err == http.ErrNoCookie {
                w.WriteHeader(http.StatusUnauthorized)
                return
            }
            w.WriteHeader(http.StatusBadRequest)
            return
        }

        tokenStr := c.Value
        claims := &Claims{}

        tkn, err := jwt.ParseWithClaims(tokenStr, claims, func(token *jwt.Token) (interface{}, error) {
            return jwtKey, nil
        })

        if err != nil || !tkn.Valid {
            w.WriteHeader(http.StatusUnauthorized)
            return
        }

        next.ServeHTTP(w, r)
    })
}

Perisian tengah ini menyemak sama ada permintaan mempunyai token JWT yang sah. Jika tidak, ia mengembalikan respons yang tidak dibenarkan.

Langkah 4: Melindungi Laluan

Sekarang, mari gunakan middleware sahih kami untuk melindungi laluan /books:

func main() {
    r := mux.NewRouter()

    r.HandleFunc("/login", login).Methods("POST")
    r.Handle("/books", authenticate(http.HandlerFunc(getBooks))).Methods("GET")

    fmt.Println("Server started on port :8000")
    log.Fatal(http.ListenAndServe(":8000", r))
}

Menguji API

1. Log masuk untuk menjana token:

   curl -X POST http://localhost:8000/login -d '{"username":"admin", "password":"password"}' -H "Content-Type: application/json"

1. Akses titik akhir /books yang dilindungi:

   curl --cookie "token=<your_token>" http://localhost:8000/books

Jika token itu sah, anda akan mendapat akses. Jika tidak, anda akan mendapat "401 Tanpa Kebenaran".

Apa Seterusnya?

Lain kali, kami akan menyambungkan API kami ke pangkalan data untuk mengurus bukti kelayakan pengguna dan menyimpan data. Nantikan lebih lanjut!

Atas ialah kandungan terperinci Menjaga API Go Anda dengan Pengesahan JWT. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!