golang melaksanakan jwt

Dalam pembangunan aplikasi Internet hari ini, keselamatan semakin mendapat perhatian. Token Web JSON (JWT) telah menjadi salah satu daripada skim pengesahan dan kebenaran biasa dalam kebanyakan reka bentuk API web. JWT ialah standard terbuka (RFC 7519) yang mentakrifkan cara yang padat dan serba lengkap untuk menyampaikan maklumat dengan selamat antara pihak.

Bahasa Go ialah bahasa pengaturcaraan bahagian pelayan yang sangat berkuasa, dan sangat mudah untuk melaksanakan JWT dengan mudah. Dalam artikel ini, kami akan memperkenalkan cara melaksanakan JWT di Golang.

1. Perkenalkan kebergantungan

Pertama, anda perlu memperkenalkan perpustakaan berikut:

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/base64"
    "encoding/pem"
    "errors"
    "fmt"
    "time"

    "github.com/dgrijalva/jwt-go"
)

• crypto/rsa: Mengandungi fungsi untuk menjana dan menghurai RSA awam dan peribadi kunci .
• crypto/x509: Mengandungi fungsi sijil dalam format PKIX
• pengekodan/base64: digunakan untuk mengekod dan menyahkod bahagian JWT
• pengekodan/pem: digunakan untuk mengekstrak dan Menyimpan sijil dalam format PEM
• ralat: digunakan untuk mengendalikan maklumat ralat yang dikembalikan
• fmt: fungsi pemformatan standard
• masa: fungsi masa standard
• github .com/ dgrijalva/jwt-go: Kebergantungan utama JWT

2. Cipta fail kunci

Pertama, anda perlu mencipta fail kunci peribadi. Gunakan arahan berikut untuk menjana fail kunci peribadi:

openssl genrsa -out app.rsa 1024

Ini akan menjana kunci RSA 1024-bit bernama app.rsa. Kami akan menggunakan kunci ini untuk menjana JWT.

3. Jana Token JWT

Sekarang, kita boleh mencipta token JWT menggunakan kod berikut:

func GenerateJWT() (string, error) {
    token := jwt.New(jwt.SigningMethodHS256)
    claims := token.Claims.(jwt.MapClaims)

    claims["authorized"] = true
    claims["user"] = "user@example.com"
    claims["exp"] = time.Now().Add(time.Hour * 1).Unix()

    tokenString, err := token.SignedString([]byte("secret"))
    if err != nil {
        return "", err
    }

    return tokenString, nil
}

Fungsi ini mencipta token JWT menggunakan HS256 algoritma . Pertama, kami mencipta objek token JWT baharu. Kami kemudian menambah kenyataan itu kepada tuntutannya. Dalam contoh ini, kami mengisytiharkan bahawa "Kebenaran" ditetapkan kepada "Benar", pengguna ditetapkan kepada "pengguna@example.com", dan masa tamat tempoh JWT ditetapkan kepada 1 jam kemudian. Akhir sekali, kami menandatangani JWT menggunakan "rahsia" yang disediakan ("rahsia" dalam contoh ini) dan mengembalikan rentetan itu.

4. Menghuraikan token JWT

Kita boleh menggunakan kod berikut untuk menghuraikan token JWT:

func ParseJWT(tokenString string) (jwt.MapClaims, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
        }

        return []byte("secret"), nil
    })

    if err != nil {
        return nil, err
    }

    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return claims, nil
    }

    return nil, errors.New("invalid token")
}

Fungsi ini menerima rentetan token JWT dan kemudian Cuba menghuraikan JWT. Di sini kami menggunakan algoritma HS256 untuk menyahsulit jwt. Pertama, kita perlu mengesahkan sama ada Token ditandatangani menggunakan algoritma HMAC, jika tidak ralat akan dikembalikan. Seterusnya, kami mengembalikan kunci penyulitan ("rahsia" dalam contoh ini). Apabila penghuraian berjaya, fungsi mengembalikan tuntutan yang disahkan dan belum tamat tempoh. Jika penghuraian gagal, fungsi mengembalikan mesej ralat.

5. Kaedah penyulitan yang lebih maju

Selain algoritma HS256, terdapat banyak algoritma penyulitan lain yang boleh anda gunakan untuk menyulitkan muatan JWT. Sebagai contoh, JWT yang ditandatangani menggunakan algoritma RSA adalah lebih selamat daripada menggunakan algoritma HS256. Berikut ialah cara untuk menjana token JWT menggunakan algoritma RSA:

func GenerateJWT() (string, error) {
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        return "", err
    }

    token := jwt.NewWithClaims(jwt.SigningMethodRS256, jwt.MapClaims{
        "authorized": true,
        "user":       "user@example.com",
        "exp":        time.Now().Add(time.Hour * 1).Unix(),
    })

    tokenString, err := token.SignedString(privateKey)
    if err != nil {
        return "", err
    }

    return tokenString, nil
}

Di sini, kami mula-mula menjana kunci peribadi RSA 2048-bit. Kami kemudian menandatangani token JWT menggunakan algoritma RS256. Akhir sekali, kami menandatangani token JWT menggunakan kunci persendirian.

Pendekatan berbeza juga diperlukan semasa menghuraikan token JWT:

func ParseJWT(tokenString string) (jwt.MapClaims, error) {
    publicKey := `
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArtpZKxF+1MDwcJ61KeJt
GjHYiAL46jEewsjF9oBz59J2y5/v/tE/RQjJjOtGvLQ5LfPYBK+j+Z6QIwU1ZzCJ
I0MT5mn81znZCsy7zcZI7+kRPG8Fk5JzKM2ug7RAuYqnOjArL8+V+uS4Moh2RWdN
yZizvjajzKtbH5zLC49Dd3X/SrjzPQpzt8HY4Z7YxYej8/Akl3nxdx9Q/OPG2NYP
xtflmpLLJc7roqkfVwwMQeC1apHr/klI3FHPvK/pzBoUCUOpTfnyvHg8O1+PyMKJ
CldHEhuzUsTR5jM5fXv0M4+vL36QO8k1WhO4gcQTD6X7fIWqFhfrRM/jreG+bv8c
7wIDAQAB
-----END PUBLIC KEY-----
`

    block, _ := pem.Decode([]byte(publicKey))
    if block == nil {
        return nil, errors.New("failed to decode PEM block containing public key")
    }

    pub, err := x509.ParsePKIXPublicKey(block.Bytes)
    if err != nil {
        return nil, err
    }

    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
            return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
        }

        return pub, nil
    })

    if err != nil {
        return nil, err
    }

    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        return claims, nil
    }

    return nil, errors.New("invalid token")
}

Dalam fungsi ini kita perlu mengekstrak kunci awam RSA dahulu dan kemudian menghantarnya ke fungsi jwt.Parse. Apabila menghuraikan token, perpustakaan jwt-go secara automatik akan menggunakan kunci awam untuk pengesahan. Ambil perhatian bahawa kunci awam yang digunakan di sini disediakan dalam format PKIX. Anda boleh menggunakan alat seperti OpenSSL untuk mengeksport kunci awam PEM kepada format PKIX.

6. Ringkasan

Dalam artikel ini, kami memperkenalkan cara mencipta dan menghuraikan token JWT di Golang menggunakan algoritma HS256 dan RS256. Ini ialah skim pengesahan dan kebenaran biasa yang boleh anda gunakan dalam aplikasi web masa hadapan. Semoga artikel ini bermanfaat kepada anda.

Atas ialah kandungan terperinci golang melaksanakan jwt. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!