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!

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

Demasiado Largo; Para Leer

Company Mentioned

Coin Mentioned

Aswin G

About Author

ETIQUETAS

Languages

ESTE ARTÍCULO FUE PRESENTADO EN...