Hola, en el artículo de hoy, te mostraré cómo puedes construir tu propio servidor OAuth2 como Google, Facebook, Github, etc.  Esto será muy útil si desea crear una API pública o privada lista para producción. Entonces empecemos.  ¿Qué es OAuth2?  La versión 2.0 de Open Authorization se conoce como OAuth2. Es un tipo de protocolo o marco para proteger los servicios web RESTful. OAuth2 es muy poderoso. Hoy en día, la mayoría de las API REST están protegidas con OAuth2 debido a su sólida seguridad.  OAuth2 tiene dos partes  01. Cliente  02. Servidor  Cliente OAuth2   Si estás familiarizado con esta pantalla, sabes de lo que estoy hablando. De todos modos, déjame explicarte la historia detrás de la imagen:  Está creando una aplicación orientada al usuario que funciona con los repositorios de github del usuario. Por ejemplo: herramientas de CI como TravisCI, CircleCI, Drone, etc.  Pero la cuenta de github del usuario está protegida y nadie puede acceder a ella si el propietario no lo desea. Entonces, ¿cómo acceden estas herramientas de CI a la cuenta y los repositorios de github del usuario?  Fácil.  Su aplicación le preguntará al usuario   “Para trabajar con nosotros, debe otorgar acceso de lectura a sus repositorios de github. ¿Estás de acuerdo?"  Entonces el usuario dirá   "Sí. Y haz lo que tengas que hacer”.  Luego, su aplicación se comunicará con la autoridad de github para otorgar acceso a la cuenta de github de ese usuario en particular. Github comprobará si es cierto y le pedirá al usuario que lo autorice. Luego, github emitirá un token efímero para el cliente.  Ahora, cuando su aplicación necesite acceder después de la autenticación y autorización, debe enviar el token de acceso con la solicitud para que github piense:   “Oh, el token de acceso parece familiar, puede ser que te lo hayamos dado. Ok, puedes acceder”  Esa es la larga historia. Los días han cambiado, ahora no necesitas ir físicamente a la autoridad de github cada vez (nunca tuvimos que hacer eso). Todo se puede hacer automáticamente.  ¿Pero cómo?   Este es un diagrama de secuencia UML de lo que he hablado hace un par de minutos. Solo representación gráfica.  De la imagen de arriba, encontramos algunas cosas importantes.   OAuth2 tiene 4 funciones:  01. Usuario: el usuario final que usará su aplicación  02. Cliente: la aplicación que está creando que usará la cuenta de github y el usuario usará  03. Servidor de autenticación: el servidor que se ocupa de las cosas principales de OAuth  04. Servidor de recursos: el servidor que tiene los recursos protegidos. Por ejemplo github  El cliente envía una solicitud OAuth2 al servidor de autenticación en nombre del usuario.  Crear un cliente OAuth2 no es fácil ni difícil. Suena divertido, ¿verdad? Lo haremos en la siguiente parte.  Pero en esta parte, nos iremos al otro lado del mundo. Construiremos nuestro propio servidor OAuth2. Que no es fácil pero sí jugoso.  ¿Listo? Vamos  Servidor OAuth2  puedes preguntarme   "Espera un minuto, Cyan, ¿por qué construir un servidor OAuth2?"  ¿Te olvidaste hombre? He dicho esto antes. Bien, déjame decirte de nuevo.  Imagínese, está creando una aplicación muy útil que brinda información meteorológica precisa (hay muchas API de este tipo). Ahora desea abrirlo para que el público pueda usarlo o quiere ganar dinero con él.  Sea cual sea el caso, debe proteger sus recursos de accesos no autorizados o ataques maliciosos. Para hacer eso, necesita asegurar sus recursos de API. Aquí viene la cosita de OAuth2. ¡Bingo!  En la imagen de arriba, podemos ver que necesitamos colocar un servidor de autenticación frente a nuestro servidor de recursos API REST. De eso estamos hablando. El servidor de autenticación se creará utilizando la especificación OAuth2. Entonces nos convertiremos en el github de la primera imagen, jajajaja es broma.  El objetivo principal del servidor OAuth2 es proporcionar un token de acceso al cliente. Es por eso que el servidor OAuth2 también se conoce como proveedor OAuth2, porque proporciona token.  Basta de hablar.   Hay cuatro tipos de servidores OAuth2 basados en el tipo Grant Flow:  01. Concesión de código de autorización  02. Concesión implícita  03. Otorgamiento de Credenciales de Cliente  04. Concesión de contraseña  Si desea obtener más información sobre OAuth2, consulte   increíble artículo. este  Para este artículo, usaremos   . Así que profundicemos el tipo de concesión de credenciales de cliente  Servidor basado en flujo de concesión de credenciales de cliente  Al implementar el servidor OAuth2 basado en flujo de otorgamiento de credenciales de cliente, necesitamos saber un par de cosas.  En este tipo de concesión, no hay interacción del usuario (es decir, registro, inicio de sesión). Se necesitan dos cosas, y son   y   . Con estas dos cosas, podemos obtener   . El cliente es la aplicación de terceros. Cuando necesita acceder al servidor de recursos sin el usuario o solo mediante la aplicación cliente, este tipo de concesión es simple y el más adecuado. client_id client_secret access_token  Aquí hay un diagrama de secuencia UML de la misma.   Codificación  Para construir esto, necesitamos confiar en un increíble paquete Go  En primer lugar, construyamos un servidor API simple como servidor de recursos    package main   (     ) func main() { http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(   )) }) log.Fatal(http.ListenAndServe(   , nil)) import "log" "net/http" "/protected" "Hello, I'm protected" ":9096"  Ejecute el servidor y envíe una solicitud de obtención a  http://localhost:9096/protected  Obtendrá respuesta.  ¿Qué tipo de servidor protegido es?  Aunque el nombre del punto final está protegido, cualquiera puede acceder a él. Entonces necesitamos protegerlo con OAuth2.  Ahora escribiremos nuestro servidor de autorizaciones  Rutas  01.   para emitir credenciales de cliente (client_id y client_secret) /credentials  03.   para emitir token con credenciales de cliente /token  Necesitamos implementar estas dos rutas.  Aquí está la configuración preliminar    package main   (                       ) func main() {   := manage.NewDefaultManager() manager.SetAuthorizeCodeTokenCfg(manage.DefaultAuthorizeCodeTokenCfg) manager.MustTokenStorage(store.NewMemoryTokenStore()) clientStore := store.NewClientStore() manager.MapClientStorage(clientStore) srv := server.NewDefaultServer(manager) srv.SetAllowGetAccessRequest(   ) srv.SetClientInfoHandler(server.ClientFormHandler) manager.SetRefreshTokenCfg(manage.DefaultRefreshTokenCfg) srv.SetInternalErrorHandler(func(err error) (re *errors.Response) { log.Println(   , err.Error())   }) srv.SetResponseErrorHandler(func(re *errors.Response) { log.Println(   , re.Error.Error()) }) http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(   )) }) log.Fatal(http.ListenAndServe(   , nil)) } import "encoding/json" "fmt" "github.com/google/uuid" "gopkg.in/oauth2.v3/models" "log" "net/http" "time" "gopkg.in/oauth2.v3/errors" "gopkg.in/oauth2.v3/manage" "gopkg.in/oauth2.v3/server" "gopkg.in/oauth2.v3/store" manager true "Internal Error:" return "Response Error:" "/protected" "Hello, I'm protected" ":9096"  Aquí creamos un administrador, una tienda de clientes y el propio servidor de autenticación.  Aquí está la ruta    /credenciales   http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) {   := uuid.New().String()[:   ] clientSecret := uuid.New().String()[:   ] err := clientStore.Set(clientId, &models.Client{   : clientId,   : clientSecret,   :   , })   err != nil { fmt.Println(err.Error()) } w.Header().Set(   ,   ) json.NewEncoder(w).Encode(map[string]string{   : clientId,   : clientSecret}) }) "/credentials" clientId 8 8 ID Secret Domain "http://localhost:9094" if "Content-Type" "application/json" "CLIENT_ID" "CLIENT_SECRET"  Crea dos cadenas aleatorias, una para client_id y otra para client_secret. Luego los guarda en la tienda del cliente. Y devolverlos como respuesta. Eso es todo. Usamos en el almacén de memoria, pero podemos almacenarlos en redis, mongodb, postgres, etc.  Aquí está la ruta   :  /token   http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) { srv.HandleTokenRequest(w, r) }) "/token"  Es muy simple. Pasa la solicitud y la respuesta al controlador apropiado para que el servidor pueda decodificar todos los datos necesarios de la carga útil de la solicitud.  Así que aquí está nuestro código general:    package main   (                       ) func main() {   := manage.NewDefaultManager() manager.SetAuthorizeCodeTokenCfg(manage.DefaultAuthorizeCodeTokenCfg) manager.MustTokenStorage(store.NewMemoryTokenStore()) clientStore := store.NewClientStore() manager.MapClientStorage(clientStore) srv := server.NewDefaultServer(manager) srv.SetAllowGetAccessRequest(   ) srv.SetClientInfoHandler(server.ClientFormHandler) manager.SetRefreshTokenCfg(manage.DefaultRefreshTokenCfg) srv.SetInternalErrorHandler(func(err error) (re *errors.Response) { log.Println(   , err.Error())   }) srv.SetResponseErrorHandler(func(re *errors.Response) { log.Println(   , re.Error.Error()) }) http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) { srv.HandleTokenRequest(w, r) }) http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) {   := uuid.New().String()[:   ] clientSecret := uuid.New().String()[:   ] err := clientStore.Set(clientId, &models.Client{   : clientId,   : clientSecret,   :   , })   err != nil { fmt.Println(err.Error()) } w.Header().Set(   ,   ) json.NewEncoder(w).Encode(map[string]string{   : clientId,   : clientSecret}) }) http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(   )) }) log.Fatal(http.ListenAndServe(   , nil)) } import "encoding/json" "fmt" "github.com/google/uuid" "gopkg.in/oauth2.v3/models" "log" "net/http" "time" "gopkg.in/oauth2.v3/errors" "gopkg.in/oauth2.v3/manage" "gopkg.in/oauth2.v3/server" "gopkg.in/oauth2.v3/store" manager true "Internal Error:" return "Response Error:" "/token" "/credentials" clientId 8 8 ID Secret Domain "http://localhost:9094" if "Content-Type" "application/json" "CLIENT_ID" "CLIENT_SECRET" "/protected" "Hello, I'm protected" ":9096"  Ejecute el código y vaya a la ruta   para registrarse y obtener client_id y client_secret http://localhost:9096/credentials  Ahora vaya a esta URL  http://localhost:9096/token?grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET&scope=all  Obtendrá el access_token con el tiempo de caducidad y alguna otra información.  Ahora tenemos nuestro access_token. Pero nuestra ruta /protected aún no está protegida. Necesitamos configurar una forma que verifique si existe un token válido con cada solicitud del cliente. En caso afirmativo, le damos acceso al cliente. De otra forma no.  Podemos hacer esto con un middleware.  Escribir middleware en go es muy divertido si sabes lo que estás haciendo. Aquí está el software intermedio:    func validateToken(f http.HandlerFunc, srv *server.Server) http.HandlerFunc {   http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _,   := srv.ValidationBearerToken(r)   err != nil { http.Error(w, err.Error(), http.StatusBadRequest)   } f.ServeHTTP(w, r) }) } return err if return  Esto verificará si se proporciona un token válido con la solicitud y tomará medidas en función de eso.  Ahora necesitamos colocar este middleware frente a nuestra ruta /protected usando el patrón de adaptador/decorador    http.HandleFunc(   , validateToken(func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(   )) }, srv)) "/protected" "Hello, I'm protected"  Ahora todo el código se ve así:    package main   (                       ) func main() {   := manage.NewDefaultManager() manager.SetAuthorizeCodeTokenCfg(manage.DefaultAuthorizeCodeTokenCfg)   manager.MustTokenStorage(store.NewMemoryTokenStore())   clientStore := store.NewClientStore() manager.MapClientStorage(clientStore) srv := server.NewDefaultServer(manager) srv.SetAllowGetAccessRequest(   ) srv.SetClientInfoHandler(server.ClientFormHandler) manager.SetRefreshTokenCfg(manage.DefaultRefreshTokenCfg) srv.SetInternalErrorHandler(func(err error) (re *errors.Response) { log.Println(   , err.Error())   }) srv.SetResponseErrorHandler(func(re *errors.Response) { log.Println(   , re.Error.Error()) }) http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) { srv.HandleTokenRequest(w, r) }) http.HandleFunc(   , func(w http.ResponseWriter, r *http.Request) {   := uuid.New().String()[:   ] clientSecret := uuid.New().String()[:   ] err := clientStore.Set(clientId, &models.Client{   : clientId,   : clientSecret,   :   , })   err != nil { fmt.Println(err.Error()) } w.Header().Set(   ,   ) json.NewEncoder(w).Encode(map[string]string{   : clientId,   : clientSecret}) }) http.HandleFunc(   , validateToken(func(w http.ResponseWriter, r *http.Request) { w.Write([]byte(   )) }, srv)) log.Fatal(http.ListenAndServe(   , nil)) } func validateToken(f http.HandlerFunc, srv *server.Server) http.HandlerFunc {   http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { _,   := srv.ValidationBearerToken(r)   err != nil { http.Error(w, err.Error(), http.StatusBadRequest)   } f.ServeHTTP(w, r) }) } import "encoding/json" "fmt" "github.com/google/uuid" "gopkg.in/oauth2.v3/models" "log" "net/http" "time" "gopkg.in/oauth2.v3/errors" "gopkg.in/oauth2.v3/manage" "gopkg.in/oauth2.v3/server" "gopkg.in/oauth2.v3/store" manager // token memory store // client memory store true "Internal Error:" return "Response Error:" "/token" "/credentials" clientId 8 8 ID Secret Domain "http://localhost:9094" if "Content-Type" "application/json" "CLIENT_ID" "CLIENT_SECRET" "/protected" "Hello, I'm protected" ":9096" return err if return  Ahora ejecute el servidor e intente acceder a   sin   como consulta de URL. Luego intente dar   incorrecto. De cualquier manera, el servidor de autenticación lo detendrá. /punto final protegido access_token access_token  Ahora obtenga las   y   nuevamente del servidor y envíe la solicitud al punto final protegido: credenciales access_token   http://localhost:9096/test?access_token=SU_TOKEN_ACCESO  ¡Bingo! Tendrás acceso a él.  Así que hemos aprendido a configurar nuestro propio servidor OAuth2 usando Go.  En la siguiente parte, construiremos nuestro cliente OAuth2 en Go. Y en la última parte, crearemos el   con el inicio de sesión y la autorización del usuario. servidor basado en el tipo de concesión de código de autorización

Flow

Facebook

Google

Read My Stories

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

Cree su propio servidor OAuth2 en Go

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

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

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

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

Liberando el poder de la IA. Una revisión sistemática de técnicas de vanguardia: resumen e introducción

De los foros a los feeds: cómo los algoritmos de las redes sociales influyen en la interacción digital

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

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps