Implementando el middleware

Clase 16 de 26 • Curso de Go Avanzado: REST y WebSockets

Contenido del curso

Introducción

REST

WebSockets

Cierre

Tomar examen

Comentarios

Christian Gonzalo Espinoza Cadillo

student•

La solución que hace casi al final de la clase, la de modificar el fichero auth.go y enviar una referencia al models.AppClaims, también debe hacerse a la función de MeHandler

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		tokenString := strings.TrimSpace(r.Header.Get("Authorization"))

		token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
			return []byte(s.Config().JWTSecret), nil
		})
		if err != nil {
			http.Error(w, err.Error(), http.StatusUnauthorized)
			return
		}

		if claims, ok := token.Claims.(*models.AppClaims); ok && token.Valid {
			user, err := repository.GetUserById(r.Context(), claims.UserId)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(user)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

Jonathan Stiven Colorado Largo

student•

Gracias me ayudo ese recordatorio

NELSON ARLEY USUGA MONCADA

student•

👍

Carlos Nexans

student•

La interface de la librería debería contemplar este problema en forma de chequeo de tipos y, especificar, que se debe recibir una referencia estrictamente. De esta forma el compilador te avisaría sobre este error en lugar de recibirlo cuando pruebas la aplicación.

Victor Baruch Pazaran Jaimes

student•

Exacto, si no lo hubiera notado el profesor estaría dificil de debuggear ese error, por que a simple vista no se sabe bien donde se está originando

Àlex Grau Roca

student•

Para la abstracción de código he creado una carpeta llamada helpers y en ella un fichero llamado jwtHelper.go, el cual contiene la siguiente función:

func GetJWTAuthorizationInfo(s server.Server, w http.ResponseWriter, r *http.Request) (*jwt.Token, error) {
	tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
	token, err := jwt.ParseWithClaims(tokenString, models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(s.Config().JWTSecret), nil
	})

	if err != nil {
		http.Error(w, err.Error(), http.StatusUnauthorized)
	}

	return token, err
}

Los códigos que realizan la llamada la pueden utilizar tal que así:

		token, err := helpers.GetJWTAuthorizationInfo(s, w, r)

		if err != nil {
			return
		}

Àlex Grau Roca

student•

Le falta añadir la referencia de models.AppClaims{}

Edwin García

student•

Ya para no duplicar el código del middleware de autorización lo que hice fue extraer ahí mismo el userId del token e insertarlo en los headers. Entonces cuando llega al MeHandler puedo extraer del los headers el userId. No se si esté bien, me gustaría que alguien me diera su opinión Este es el middleware

Este es el handler

Matias Niz

student•

No se si es la respuesta correcta, pero tambien podes usar el context.

en la funcion CheckAuthMiddleware:

if claims, ok := token.Claims.(*models.AppClaims); ok && token.Valid {
				ctx := r.WithContext(context.WithValue(r.Context(), "userId", claims.UserId))
				next.ServeHTTP(w, ctx)
				return
			}

en MeHandler:

result, ok := r.Context().Value("userId").(string)
		if ok {
			println(result)
		}

Heiner Ríos Rodríguez

student•

Les comparto una opción para no repetir el código de verificación del token . En el middleware, al verificar el token podemos obtener el UserId y lo guardamos en el contexto de ejecución; posteriormente en el handler podemos recuperarlo y traer la data del usuario.

middleware/auth.go

func CheckAuthMiddleware(s server.Server) func(h http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if !shouldCheckToken(r.URL.Host) {
				next.ServeHTTP(w, r)
				return
			}
			tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
			token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(t *jwt.Token) (interface{}, error) {
				return []byte(s.Config().JWTSecret), nil
			})
			if err != nil {
				http.Error(w, err.Error(), http.StatusUnauthorized)
				return
			}

			claims, ok := token.Claims.(*models.AppClaims)
			if ok && token.Valid {
				log.Printf("User ID: %s", claims.UserId)
				ctx := context.WithValue(r.Context(), ContextUserID, claims.UserId)
				r = r.WithContext(ctx)
			}// 

			next.ServeHTTP(w, r)
		})
	}
}

handlers/user.go

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID := r.Context().Value(middleware.ContextUserID)
		if userID == "" {
			http.Error(w, "Invalid credentials", http.StatusUnauthorized)
			return
		}

		user, err := repository.GetUserById(r.Context(), userID.(string))
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(user)
	}
}

Heiner Ríos Rodríguez

student•

El ContextUserID lo pueden definir así:

type ContextKey string

const ContextUserID ContextKey = "userid"

Carlos Eduardo Magallon Zepeda

student•

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
		token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
			return []byte(s.Config().JWTSecret), nil
		})
		if err != nil {
			http.Error(w, err.Error(), http.StatusUnauthorized)
			return
		}
		if claims, ok := token.Claims.(*models.AppClaims); ok && token.Valid {
			user, err := repository.GetUserById(r.Context(), claims.UserId)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(user)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

Luis Alfredo Hernández Duarte

student•

Cómo hago para enviar un Bearer token en vez del token solo?

Oscar Gómez Rodríguez

student•

En esta clase tenemos un problema ya que creamos el mdw pero replicamos todo el código dentro del un nuevo handler, lo unico que debimos hacer fue agregar en los routes este mdw de la siguiente forma:


func BindRoutes(s server.Server, r *mux.Router) {
	r.HandleFunc("/", handlers.HomeHandler(s)).Methods("GET")
	r.HandleFunc("/signup", handlers.SingUpHandler(s)).Methods("POST")
	r.HandleFunc("/login", handlers.LoginHandler(s)).Methods("POST")
	r.HandleFunc("/me", handlers.MeHandler(s)).Methods("GET")
	r.Use(middleware.CheckAuthMiddleware(s))
}
```func BindRoutes(s server.Server, r \*mux.Router) {    r.HandleFunc("/", handlers.HomeHandler(s)).Methods("GET")    r.HandleFunc("/signup", handlers.SingUpHandler(s)).Methods("POST")    r.HandleFunc("/login", handlers.LoginHandler(s)).Methods("POST")    r.HandleFunc("/me", handlers.MeHandler(s)).Methods("GET")    r.Use(middleware.CheckAuthMiddleware(s))}

Carlos Arturo Pimentel

student•

Una posible solución para el reto que nos plantea Nestor es la siguiente:

func ParseToken(hauth string, claims jwt.Claims) (jwt.Token, error) {
	// hauth: Autohorization Header
	// claims: Any type that implemnts jwt.Claims. AppClaims Does b/c jwt.StandardClaims does.
	strim := strings.TrimSpace(hauth)
	token, err := jwt.ParseWithClaims(strim, claims, func(t *jwt.Token) (interface{}, error) {
		return []byte(database.BuildConfig().JWTSecret), nil
	})
	return *token, err
}

el database.BuildConfig está apuntando al archivo de configuración,, que a propósito no estaría mal sacarlo de server.go y tenerlo en su propio archivo config.go., esto entre otras cosas ahorraría tener que pasar el servidor como parámetro en los los middlewares.

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		tokenString := strings.TrimSpace(r.Header.Get("Authorization"))

		token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
			return []byte(s.Config().JWTSecret), nil
		})
		if err != nil {
			http.Error(w, err.Error(), http.StatusUnauthorized)
			return
		}

		if claims, ok := token.Claims.(*models.AppClaims); ok && token.Valid {
			user, err := repository.GetUserById(r.Context(), claims.UserId)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(user)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func GetJWTAuthorizationInfo(s server.Server, w http.ResponseWriter, r *http.Request) (*jwt.Token, error) {
	tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
	token, err := jwt.ParseWithClaims(tokenString, models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
		return []byte(s.Config().JWTSecret), nil
	})

	if err != nil {
		http.Error(w, err.Error(), http.StatusUnauthorized)
	}

	return token, err
}

func CheckAuthMiddleware(s server.Server) func(h http.Handler) http.Handler {
	return func(next http.Handler) http.Handler {
		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			if !shouldCheckToken(r.URL.Host) {
				next.ServeHTTP(w, r)
				return
			}
			tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
			token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(t *jwt.Token) (interface{}, error) {
				return []byte(s.Config().JWTSecret), nil
			})
			if err != nil {
				http.Error(w, err.Error(), http.StatusUnauthorized)
				return
			}

			claims, ok := token.Claims.(*models.AppClaims)
			if ok && token.Valid {
				log.Printf("User ID: %s", claims.UserId)
				ctx := context.WithValue(r.Context(), ContextUserID, claims.UserId)
				r = r.WithContext(ctx)
			}// 

			next.ServeHTTP(w, r)
		})
	}
}

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		userID := r.Context().Value(middleware.ContextUserID)
		if userID == "" {
			http.Error(w, "Invalid credentials", http.StatusUnauthorized)
			return
		}

		user, err := repository.GetUserById(r.Context(), userID.(string))
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}

		w.Header().Set("Content-Type", "application/json")
		json.NewEncoder(w).Encode(user)
	}
}

func MeHandler(s server.Server) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		tokenString := strings.TrimSpace(r.Header.Get("Authorization"))
		token, err := jwt.ParseWithClaims(tokenString, &models.AppClaims{}, func(token *jwt.Token) (interface{}, error) {
			return []byte(s.Config().JWTSecret), nil
		})
		if err != nil {
			http.Error(w, err.Error(), http.StatusUnauthorized)
			return
		}
		if claims, ok := token.Claims.(*models.AppClaims); ok && token.Valid {
			user, err := repository.GetUserById(r.Context(), claims.UserId)
			if err != nil {
				http.Error(w, err.Error(), http.StatusInternalServerError)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			json.NewEncoder(w).Encode(user)
		} else {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
	}
}

func BindRoutes(s server.Server, r *mux.Router) {
	r.HandleFunc("/", handlers.HomeHandler(s)).Methods("GET")
	r.HandleFunc("/signup", handlers.SingUpHandler(s)).Methods("POST")
	r.HandleFunc("/login", handlers.LoginHandler(s)).Methods("POST")
	r.HandleFunc("/me", handlers.MeHandler(s)).Methods("GET")
	r.Use(middleware.CheckAuthMiddleware(s))
}
```func BindRoutes(s server.Server, r \*mux.Router) {    r.HandleFunc("/", handlers.HomeHandler(s)).Methods("GET")    r.HandleFunc("/signup", handlers.SingUpHandler(s)).Methods("POST")    r.HandleFunc("/login", handlers.LoginHandler(s)).Methods("POST")    r.HandleFunc("/me", handlers.MeHandler(s)).Methods("GET")    r.Use(middleware.CheckAuthMiddleware(s))}

func ParseToken(hauth string, claims jwt.Claims) (jwt.Token, error) {
	// hauth: Autohorization Header
	// claims: Any type that implemnts jwt.Claims. AppClaims Does b/c jwt.StandardClaims does.
	strim := strings.TrimSpace(hauth)
	token, err := jwt.ParseWithClaims(strim, claims, func(t *jwt.Token) (interface{}, error) {
		return []byte(database.BuildConfig().JWTSecret), nil
	})
	return *token, err
}

Implementando el middleware

Introducción

Introducción al curso

¿Qué estaremos construyendo?

HTTP y REST

CRUD

REST

Inicialización de módulo e instalación de dependencias

Struct Server

Nuestro primer endpoint

Definiendo el modelo de usuarios

Patrón repository

Registro de usuarios

Implementando el registro

Probando los registros

Autenticación de usuarios

Probando el login

Middleware de validación de autenticación