Lo que vas a encontrar...
Los tokens web JSON (JWT) son un método popular para manejar la autenticación en línea y puede implementar la autenticación JWT en cualquier lenguaje de programación del lado del servidor.
Para una lectura básica sobre los JWT en general, recomiendo obtener más información sobre los JWT, las mejores prácticas y cómo proteger las API RESTful con JWT con estos artículos en el blog de LogRocket.
Este artículo tiene como objetivo ayudarlo a comenzar a implementar la autenticación JWT en sus aplicaciones web Go utilizando el paquete golang-jwt.
El paquete golang-jwt es el paquete más popular para implementar JWT en Go, debido a su funcionalidad y facilidad de uso. El paquete golang-jwt proporciona funcionalidad para generar y validar JWT.
condiciones previas
Deberá cumplir con estos requisitos básicos para aprovechar al máximo este tutorial.
- Ir 1.16 o superior instalado en su máquina (por razones de seguridad)
- Experiencia en la creación de aplicaciones web en Go o cualquier otro idioma (opcional)
Indice
Primeros pasos con el paquete Golang-JWT
Después de configurar su espacio de trabajo de Go e inicializar el archivo de módulos Go go.mod, ejecute este comando en su terminal en el directorio del espacio de trabajo para instalar el paquete golang-jwt:
|
1 |
go get github.com/golang-jwt/jwt |
Una vez que haya instalado golang-jwt, cree un archivo Go e importe estos paquetes y módulos.
|
1 2 3 4 5 6 7 |
import ( "log" "encoding/json" "github.com/golang-jwt/jwt" "net/http" "time" ) |
Utilizará estos paquetes en este tutorial para registrar errores, configurar un servidor y establecer el tiempo de vencimiento del token.
Configurar un servidor web en Go
Comencemos por crear un servidor web simple con un punto final que se protegerá con un JWT.
|
1 2 3 4 5 6 7 8 |
func main() { http.HandleFunc("/home", handlePage) err := http.ListenAndServe(":8080", nil) if err != nil { log.Println("There was an error listening on port :8080", err) } } |
La función principal configura el punto final de inicio con una función de controlador handlePage que usted configura. La función handlePage asegurará la página usando JWT. El servidor está configurado para escuchar en el puerto: 8080, pero puede usar cualquier puerto que desee.
La función del controlador handlePage devolverá el JSON codificado de la estructura del mensaje en respuesta al cliente si se permite la solicitud después de codificar el cuerpo de la solicitud.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
type Message struct { Status string `json:"status"` Info string `json:"info"` } func handlePage(writer http.ResponseWriter, request *http.Request) { writer.Header().Set("Content-Type", "application/json") var message Message err := json.NewDecoder(request.Body).Decode(&message) if err != nil { return } err = json.NewEncoder(writer).Encode(message) if err != nil { return } } |
La función handlePage, en este punto, no está autenticada y las solicitudes a la página funcionarán libremente. Aprenderá cómo agregar autenticación a sus funciones de controlador más adelante en este tutorial.
Generación de JWT para autenticación usando el paquete Golang-JWT
Necesitará una clave secreta para generar tokens JWT utilizando el paquete golang-jwt. Aquí hay un ejemplo de clave privada para este tutorial; sin embargo, debe usar una cadena criptográficamente segura para su clave secreta y cargarla desde un archivo de variables de entorno (.env).
Consulte este artículo para aprender a usar variables de entorno en sus aplicaciones Go.
|
1 |
var sampleSecretKey = []byte("SecretYouShouldHide") |
Tenga en cuenta que cualquier persona que tenga la clave secreta que utiliza para sus JWT puede autenticar a los usuarios de su aplicación. La variable sampleSecretKey contiene la clave privada en este caso.
Aquí hay una función para generar tokens JWT. La función debe devolver una cadena y un error. Si hay un error al generar el JWT, la función devuelve una cadena vacía y el error. Si no hay errores, la función devuelve la cadena JWT y escribe nil.
Más artículos interesantes de LogRocket:
|
1 2 3 |
func generateJWT() (string, error) { } |
Puede crear un token nuevo utilizando el método Nuevo del paquete JWT. El método New toma un método de firma (el algoritmo criptográfico para JWT) y devuelve un token JWT.
|
1 |
token := jwt.New(jwt.SigningMethodEdDSA) |
Si desea modificar el JWT, puede usar el método Claims del token.
|
1 2 3 4 |
claims := token.Claims.(jwt.MapClaims) claims["exp"] = time.Now().Add(10 * time.Minute) claims["authorized"] = true claims["user"] = "username" |
En este caso, establece un tiempo de caducidad para el JWT, que es de diez minutos, utilizando el módulo de tiempo y el nombre de usuario y el estado de autorización. Podrá recuperar las reclamaciones cuando intente verificar el JWT.
La última parte de generar un JWT es firmar la cadena con su clave secreta. Puede firmar su cadena de token utilizando el método SignedString del token. El método SignedString toma la clave secreta y devuelve una cadena de token firmada.
|
1 2 3 4 5 6 |
tokenString, err := token.SignedString(sampleSecretKey) if err != nil { return "", err } return tokenString, nil |
En los casos en que haya errores al firmar el token, puede devolver una cadena vacía y el error.
A diferencia de las cookies, no necesita almacenar JWT; todo lo que necesita es su clave de firma para verificar los tokens.
Verificación de tokens JWT
La forma convencional de verificar los JWT utiliza middleware (funciones de controlador que admiten otras funciones de controlador para operaciones). Aquí se explica cómo usar el middleware para verificar que una solicitud está autorizada.
|
1 2 3 |
func verifyJWT(endpointHandler func(writer http.ResponseWriter, request *http.Request)) http.HandlerFunc { } |
La función verificarJWT es un middleware que admite la función de controlador para la solicitud que desea verificar. La función del controlador usa el parámetro token del encabezado de la solicitud para verificar la solicitud y responder según el estado.
|
1 2 3 |
return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) { }) |
La función verificarJWT devuelve la función del controlador pasada como parámetro si la solicitud está autorizada.
El primer paso para verificar los JWT es inspeccionar el token en el encabezado de la solicitud.
|
1 2 3 |
if request.Header["Token"] != nil { } |
Si hay un token, puede proceder a verificar el token y verificar los reclamos.
Deberá analizar el token y puede analizarlo utilizando el método Parse del paquete jwt. El método parse toma el token y una función de decorador JWT y devuelve una interfaz y un error.
Debe usar el mismo método de firma que usó para firmar el token cuando lo generó para verificar la firma usando el método Method del token. En este caso, el método de firma fue el ECDSA método.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
token, err := jwt.Parse(request.Header\["Token"\][0], func(token *jwt.Token) (interface{}, error) { _, ok := token.Method.(*jwt.SigningMethodECDSA) if !ok { writer.WriteHeader(http.StatusUnauthorized) _, err := writer.Write([]byte("You're Unauthorized!")) if err != nil { return nil, err } } return "", nil }) |
Si la verificación de la firma falla (la función devuelve !ok), puede enviar un encabezado StatusUnauthorized al cliente.
|
1 2 3 4 5 6 7 |
if err != nil { writer.WriteHeader(http.StatusUnauthorized) _, err2 := writer.Write([]byte("You're Unauthorized due to error parsing the JWT")) if err2 != nil { return } } |
En el código anterior, se produjo un error al analizar el token. Por lo tanto, el usuario no está autorizado y puede escribir un mensaje y devolver un estado no autorizado.
Puede validar el token utilizando el método Valid del token.
|
1 2 3 4 5 6 7 8 9 |
if token.Valid { endpointHandler(writer, request) } else { writer.WriteHeader(http.StatusUnauthorized) _, err := writer.Write([]byte("You're Unauthorized due to invalid token")) if err != nil { return } } |
Si el token es válido, puede pasar el controlador de punto final con los parámetros de solicitud y escritura de la función del controlador para que la función de middleware devuelva el punto final.
Aquí está la declaración else para un caso en el que no hay token en el encabezado de la solicitud del cliente:
|
1 2 3 4 5 6 7 |
else { writer.WriteHeader(http.StatusUnauthorized) _, err := writer.Write([]byte("You're Unauthorized due to No token in the header")) if err != nil { return } } |
Dado que está utilizando middleware, la función de controlador en su declaración de ruta será el middleware de verificación JWT con la función de controlador para la ruta como argumento.
|
1 |
http.HandleFunc("/home", verifyJWT(handlePage)) |
Después de agregar su función de verificación a la ruta, el punto final se autentica.
En el lado del cliente, el cliente debe proporcionar un token emitido. Aquí hay una función que usa la función generateJWT para agregar tokens en las solicitudes.
|
1 2 3 4 5 6 7 8 9 10 11 |
func authPage(writer http.ResponseWriter, ) { token, err := generateJWT() if err != nil { return } client := &http.Client{} request, _ := http.NewRequest("POST", "<http://localhost:8080/>", nil) request.Header.Set("Token", token) _, _ = client.Do(request) } |
En la función authPage, la variable token contiene el token de la función generateJWT. Usando una referencia al tipo de cliente del paquete http, puede crear un nuevo cliente y realizar una solicitud al punto final. La variable de solicitud es la instancia de solicitud y con el método Set del método de encabezado de instancia de solicitud puede establecer el token en el encabezado de solicitud como se indicó anteriormente.
También puede optar por configurar el token como una cookie y recuperarlo para su verificación cada vez que un cliente realiza una solicitud al punto final autenticado.
Cuando genera un JWT, puede elegir incrustar información en el token. En la función generateJWT, agregó la variable de nombre de usuario al mapa de notificaciones.
Así es como puede extraer los reclamos, usando reclamos de nombre de usuario como ejemplo. Puede usar el middleware o agregar la funcionalidad a su función de verificación al verificar la firma del token.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
func extractClaims(_ http.ResponseWriter, request *http.Request) (string, error) { if request.Header["Token"] != nil { tokenString := request.Header\["Token"\][0] token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) { if _, ok := token.Method.(*jwt.SigningMethodECDSA); !ok { return nil, fmt.Errorf("there's an error with the signing method") } return sampleSecretKey, nil }) if err != nil { return "Error Parsing Token: ", err } } |
En las funciones extractClaims, el proceso es idéntico al de la función verificarJWT; extrajo el token del encabezado, analizó el token y verificó la firma.
|
1 2 3 4 5 6 7 8 |
claims, ok := token.Claims.(jwt.MapClaims) if ok && token.Valid { username := claims["username"].(string) return username, nil } } return "unable to extract claims", nil |
Mientras valida el token, puede recuperar los reclamos usando el método de reclamos y usar el mapa de reclamos para recuperar los datos en el JWT como se muestra arriba.
Conclusión
Este tutorial le enseñó cómo usar la autenticación JWT para autenticar su API y los puntos finales de la página web en Go con tokens web JSON usando el paquete golang-jwt. Puede encontrar el código completo en este tutorial como Github Gist.
Recuerde usar variables de entorno para sus claves secretas y no oculte datos confidenciales en JWT. ¡Hay muchos tutoriales de JWT en el blog de LogRocket que puede consultar para familiarizarse con cualquier lenguaje o marco que le interese!
