 ha sido un lenguaje popular en los últimos años conocido por su simplicidad y excelente soporte listo para usar para crear aplicaciones web y para el procesamiento pesado de concurrencia. Del mismo modo,   (JSON Web Tokens) se está convirtiendo en una forma cada vez más popular de autenticar a los usuarios. En esta publicación, repasaré cómo crear un middleware de autenticación para Golang que pueda restringir ciertas partes de su aplicación web para que requieran autenticación. Golang JWT  También puede aplicar este patrón para la creación de middlewares para hacer cualquier middleware que haga lo que quiera.  Si no está familiarizado con los JWT,   es un excelente recurso para familiarizarse con ellos. Básicamente, un JWT es un token incluido en el  El encabezado de una solicitud HTTP se puede usar para verificar al usuario que realiza la solicitud. Si bien la mayoría de las formas de autenticación de token requieren una lectura de la base de datos para verificar que el token pertenece a un usuario autenticado activo, al usar JWT, si el JWT se puede decodificar correctamente, eso garantiza que es un token válido, ya que tiene un campo de firma que se convertirá en no válido si algún dato en el token está dañado o manipulado. También puede decidir qué datos codificar en el cuerpo de JWT, lo que significa que al decodificar con éxito un JWT también puede obtener datos útiles, como el nombre de usuario o el correo electrónico de un usuario. https://jwt.io/   Authorization  El alcance de este artículo se limita a la creación de un middleware en Golang para verificar la validez de un JWT en una solicitud entrante. La generación de JWT es un proceso separado y no describiré cómo hacerlo aquí.  Configuración de la aplicación web  Estoy usando una aplicación web simple de Golang que proporciona un punto final de API único:  , que responde con "pong". No se han utilizado bibliotecas en el siguiente código.    /ping    main   (     )   { w.WriteHeader(http.StatusOK) w.Write([]   (   )) }   { http.Handle(   , http.HandlerFunc(pong)) log.Fatal(http.ListenAndServe(   ,   )) } package import "log" "net/http"     func pong (w http.ResponseWriter, r *http.Request) byte "pong"     func main () "/ping" ":8080" nil  Aquí hay un desglose rápido de lo que esto hace:  La función principal registra  como la función de controlador para el  punto final Luego inicia un servidor HTTP que se ejecuta en el puerto 8080. La función  simplemente responde con un estado de 200 (que significa "OK") y el texto "pong".  requiere que su segundo argumento sea un valor que implemente el  interfaz, por lo que  es una función de adaptador que hace precisamente eso. Más sobre esto más adelante.   pong   /ping   pong   Handle   Handler   HandlerFunc  Así que ahora si ejecutas esto con  (Suponiendo que el nombre del archivo es  ) y envíe una solicitud GET a  (Abrir este enlace en su navegador es una manera fácil) obtendrá el texto  .   go run main.go   main.go   http://localhost:8080/ping   pong  Ahora quiero proteger el  punto final para que solo las solicitudes entrantes que tengan un JWT válido puedan obtener la respuesta requerida. Si el JWT no está presente o está dañado, la aplicación debe devolver el código de estado HTTP 401: no autorizado.   /ping  Creación de un software intermedio  Un middleware para nuestro servidor HTTP debería ser una función que admita una función que implemente el  interfaz y devuelve una nueva función que implementa la  interfaz.   http.Handler   http.Handler  Este concepto debería ser familiar para cualquier persona que haya usado cierres de JavaScript, decoradores de Python o programación funcional de algún tipo. Pero esencialmente, es una función que toma una función y le agrega funcionalidad adicional.  Pero espera, la función de controlador que acabamos de escribir,  , no implementa esta interfaz. Así que tenemos que cuidar eso. Si miras en el integrado de Golang  paquete encontrará que el  interfaz solo especifica que el  debe implementarse el método para ese valor. De hecho, ni siquiera tenemos que implementar esto nosotros mismos para nuestra función de controlador.  también proporciona una práctica función auxiliar llamada  que acepta cualquier función que acepte  y  como parámetros, y lo convierte en una función que implementa el  interfaz.   pong   http   Handler   ServeHTTP   http   HandlerFunc   ResponseWriter   *Request   Handler  En este punto es fácil confundirse entre estas 4 cosas en el  paquete, así que permítanme aclararlos:   http  - Una interfaz con un solo miembro -  .   http.Handler   ServeHTTP  - Una función que se utiliza para convertir  (y cualquier otra función de controlador) a una función que implementa el  interfaz.   http.HandlerFunc   pong   Handler  - Una función utilizada para asociar un punto final con una función de controlador. Convierte automáticamente la función del controlador en una función que implementa la interfaz del controlador. No hemos usado esto aquí.   http.HandleFunc  - Igual que  , excepto que NO convierte la función del controlador en una función que implementa el  interfaz.   http.Handle   HandleFunc   Handler  Vamos a crear la estructura de un middleware básico:     {   http.HandlerFunc(   {   next.ServeHTTP(w, r) }) }        .  func middleware (next http.Handler) http Handler return   func (w http.ResponseWriter, r *http.Request) // Do stuff  Como puede ver, recibimos la solicitud y podemos hacer lo que queramos con ella antes de llamar a la función del controlador que creamos anteriormente, que se pasa a nuestro middleware como  . hacemos uso de  de nuevo para convertir la función volvemos a una función que implementa  interfaz.   next   HandlerFunc   Handler  Ahora puede hacer que su middleware haga lo que quiera con la solicitud entrante. Lo que quiero hacer es validar el JWT en el  encabezado de la solicitud, así que comenzaré con los siguientes cambios:    Authorization   authHeader := strings.Split(r.Header.Get(   ),   )     (authHeader) !=   { fmt.Println(   ) w.WriteHeader(http.StatusUnauthorized) w.Write([]   (   )) } "Authorization" "Bearer " if len 2 "Malformed token" byte "Malformed Token"  Esto toma el token JWT del  encabezamiento. Si el token no está presente, devuelve un estado no autorizado y nunca llama a nuestra función de controlador.   Authorization  El formato esperado del encabezado es  . Tenga en cuenta que puede pasar el JWT en la solicitud de la forma que desee, pero esta es la forma ampliamente aceptada de hacerlo.   Bearer <token>  Si el token está realmente presente, tendremos que decodificarlo. Para esto estoy usando el  biblioteca, que se puede instalar con     go-jwt   go get github.com/dgrijalva/jwt-go    { jwtToken := authHeader[   ] token, err := jwt.Parse(jwtToken,   {   _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {     , fmt.Errorf(   , token.Header[   ]) }   []   (SECRETKEY),   })   claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid { ctx := context.WithValue(r.Context(),   , claims)     next.ServeHTTP(w, r.WithContext(ctx)) }   { fmt.Println(err) w.WriteHeader(http.StatusUnauthorized) w.Write([]   (   )) } } else 1     func (token *jwt.Token) (   {}, error) interface if return nil "Unexpected signing method: %v" "alg" return byte nil if "props" // Access context values in handlers like this // props, _ := r.Context().Value("props").(jwt.MapClaims) else byte "Unauthorized"  Usamos  para decodificar nuestro token. El segundo argumento de esta función es una función que se utiliza para devolver la clave secreta utilizada para decodificar el token después de verificar si el método de firma del token es HMAC. Esto se debe a que JWT se puede codificar de muchas maneras, incluido el cifrado asimétrico con un par de claves públicas y privadas. Aquí estoy usando una clave secreta simple para decodificar el JWT. Esta debe ser la misma clave secreta utilizada para codificar el JWT por la entidad que generó el JWT. El método de firma no será HMAC si la clave se codificó de alguna otra manera, por lo que verificamos esto primero.   jwt.Parse  Tenga en cuenta que debe reemplazar el  variable con su clave secreta, que debe ser una cadena.   SECRETKEY  Luego obtenemos los reclamos del token. Los reclamos son los valores que se han codificado en el JWT. Si la decodificación falla, significa que el token se ha dañado o manipulado y devolvemos un estado no autorizado.  Si la decodificación fue exitosa, creamos una variable  para mantener estos reclamos y adjuntarlos a la instancia de solicitud a través de su  . Esto se hace para que podamos acceder a ellos en nuestra función de controlador (u otros middlewares si encadenamos varios middlewares) si es necesario, como se menciona en las líneas comentadas. "accesorios" aquí es una clave que utilicé, y se puede sustituir con cualquier valor de su elección siempre que use la misma clave mientras intenta obtener datos del contexto. Un caso de uso típico sería obtener el ID de usuario de las notificaciones en la función del controlador y usarlo para realizar una operación de base de datos para obtener información que corresponda a ese usuario.   ctx   Context  Finalmente, cambiamos nuestro código anterior para envolver la función del controlador en el middleware.    http.Handle(   , middleware(http.HandlerFunc(pong))) "/ping"  El código completo se ve así:     main   (             )   {   http.HandlerFunc(   { authHeader := strings.Split(r.Header.Get(   ),   )     (authHeader) !=   { fmt.Println(   ) w.WriteHeader(http.StatusUnauthorized) w.Write([]   (   )) }   { jwtToken := authHeader[   ] token, err := jwt.Parse(jwtToken,   {   _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {     , fmt.Errorf(   , token.Header[   ]) }   []   (SECRETKEY),   })   claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid { ctx := context.WithValue(r.Context(),   , claims)     next.ServeHTTP(w, r.WithContext(ctx)) }   { fmt.Println(err) w.WriteHeader(http.StatusUnauthorized) w.Write([]   (   )) } } }) }   { w.WriteHeader(http.StatusOK) w.Write([]   (   )) }   { http.Handle(   , middleware(http.HandlerFunc(pong))) log.Fatal(http.ListenAndServe(   ,   )) } package import "context" "fmt" "log" "net/http" "strings" "github.com/dgrijalva/jwt-go"        .  func middleware (next http.Handler) http Handler return   func (w http.ResponseWriter, r *http.Request) "Authorization" "Bearer " if len 2 "Malformed token" byte "Malformed Token" else 1     func (token *jwt.Token) (   {}, error) interface if return nil "Unexpected signing method: %v" "alg" return byte nil if "props" // Access context values in handlers like this // props, _ := r.Context().Value("props").(jwt.MapClaims) else byte "Unauthorized"     func pong (w http.ResponseWriter, r *http.Request) byte "pong"     func main () "/ping" ":8080" nil  Puede usar el mismo enfoque para crear varios middlewares y aplicarlos en los puntos finales que los necesitan.  Espero que hayas encontrado útil esta publicación.  Puedes encontrarme en   y   . Twitter LinkedIn

Chain

Twitter

Check out more of my work

Read My Stories

Este audio es producido en el idioma original de la historia!

Demasiado Largo; Para Leer

Make resilience your competitive advantage

Creación de un Middleware en Golang para autenticación basada en JWT

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Una breve introducción a la teoría del cerebro de Boltzmann

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

Una breve introducción a la teoría del cerebro de Boltzmann

Valhalla de Floki se une como patrocinador asociado de la gira de la India por Sri Lanka

Crecimiento de las criptomonedas: creación de perfiles de usuarios eficaces

Una guía del arquitecto para crear una arquitectura de referencia para un lago de datos de IA/ML

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps