Golang implémente JWT

Dans le développement d'applications Internet d'aujourd'hui, la sécurité retient de plus en plus l'attention. Les jetons Web JSON (JWT) sont devenus l'un des systèmes d'authentification et d'autorisation courants dans la plupart des conceptions d'API Web. JWT est une norme ouverte (RFC 7519) qui définit un moyen compact et autonome de communiquer des informations en toute sécurité entre les parties.

Le langage Go est un langage de programmation côté serveur très puissant, et il est très simple d'implémenter JWT facilement. Dans cet article, nous présenterons comment implémenter JWT dans Golang.

1.Introduire les dépendances

Tout d'abord, vous devez introduire les bibliothèques suivantes :

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

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

• crypto/rsa : contient le RSA clé publique et fonctions pour la génération et l'analyse de clés privées.
• crypto/x509 : Contient des fonctions de certificat au format PKIX
• encoding/base64 : Utilisé pour encoder et décoder des parties du JWT
• encoding / pem : utilisé pour extraire et stocker les certificats au format PEM
• errors : utilisé pour gérer les messages d'erreur renvoyés
• fmt : fonction de formatage standard
• time : Standard fonction time
• github.com/dgrijalva/jwt-go : dépendance principale de JWT

2 Créez un fichier de clé#🎜🎜 #

Premier. , vous devez créer un fichier de clé privée. Utilisez la commande suivante pour générer un fichier de clé privée :

openssl genrsa -out app.rsa 1024

Cela générera une clé RSA de 1024 bits nommée

. Nous utiliserons cette clé pour générer le JWT. app.rsa

Générer le jeton JWT

Maintenant, nous pouvons créer le jeton JWT en utilisant le code suivant :

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
}

Le La fonction crée un jeton JWT à l'aide de l'algorithme HS256. Tout d’abord, nous créons un nouvel objet jeton JWT. Nous ajoutons ensuite la déclaration à ses affirmations. Dans cet exemple, nous déclarons que « Autorisation » est définie sur « True », que l'utilisateur est défini sur « user@example.com » et que l'heure d'expiration du JWT est définie sur 1 heure plus tard. Enfin, nous signons le JWT en utilisant le « secret » fourni (« secret » dans cet exemple) et renvoyons cette chaîne.

Analyser le jeton JWT

Nous pouvons utiliser le code suivant pour analyser le jeton 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")
}

La fonction accepte une chaîne de jeton JWT, puis tente d'analyser le JWT. Ici, nous utilisons l'algorithme HS256 pour décrypter jwt. Tout d’abord, nous devons vérifier si le jeton est signé à l’aide de l’algorithme HMAC, sinon une erreur sera renvoyée. Ensuite, nous renvoyons une clé de chiffrement (« secrète » dans cet exemple). Lorsque l'analyse réussit, la fonction renvoie une réclamation vérifiée et non expirée. Si l'analyse échoue, la fonction renvoie un message d'erreur.

Méthodes de cryptage plus avancées

En plus de l'algorithme HS256, il existe de nombreux autres algorithmes de cryptage que vous pouvez utiliser pour crypter la charge utile JWT. Par exemple, un JWT signé à l'aide de l'algorithme RSA est plus sécurisé que l'utilisation de l'algorithme HS256. Voici une manière de générer un token JWT à l'aide de l'algorithme 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
}

Ici, nous générons d'abord une clé privée RSA de 2048 bits. Nous signons ensuite le token JWT en utilisant l'algorithme RS256. Enfin, nous signons le token JWT à l'aide de la clé privée.

Une approche différente est également requise lors de l'analyse du jeton 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")
}

Dans cette fonction, nous devons d'abord extraire la clé publique RSA, puis la transmettre au jwt .Parse fonction. Lors de l'analyse du jeton, la bibliothèque jwt-go utilisera automatiquement la clé publique pour la vérification. Notez que la clé publique utilisée ici est fournie au format PKIX. Vous pouvez utiliser un outil comme OpenSSL pour exporter la clé publique PEM au format PKIX.

6. Résumé

Dans cet article, nous avons présenté comment créer et analyser des jetons JWT dans Golang à l'aide des algorithmes HS256 et RS256. Il s'agit d'un schéma d'authentification et d'autorisation courant que vous pourrez utiliser dans les futures applications Web. J'espère que cet article vous sera utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!