Go 实现自己的授权认证系统 go-oauth2

原创 fliyu 邂逅Go语言

01 前言

这篇文章，让我们来学习如何创建自己的授权认证系统吧！在使用 Go 语言时，我们可以借助一个叫做 go-oauth2 的开源框架来快速实现这个目标。

一种开放协议，允许以简单和标准的方法从 Web、移动和桌面应用程序进行安全授权。
https://github.com/go-oauth2/oauth2

02 什么是OAuth 2.0 呢？

OAuth2.0 （Open Authorization 2.0）是一种开放标准的授权协议，用于在不共享密码的情况下，让用户授权第三方应用访问他们在另外一个服务提供商的受保护资源。OAuth 2.0 广泛应用于各种互联网服务，包括社交媒体平台、API 提供商、云服务等。

在传统的身份验证方式中，用户需要提供用户名和密码来授权第三方应用访问他们的账户。但是，这种方式存在一些安全风险，因为用户需要将密码直接提供给第三方应用，可能导致密码泄露或滥用。

OAuth 2.0 的工作原理如下：

用户访问第三方应用并请求访问某个受保护资源。
第三方应用将重定向用户到授权服务器（身份提供者），要求用户进行身份验证。
用户提供身份验证信息（例如用户名和密码）给授权服务器。
授权服务器验证用户身份，并向用户显示请求的权限范围（例如访问用户信息）。
用户授权第三方应用访问请求的权限。
授权服务器生成一个访问令牌（access token）并将其发送给第三方应用。
第三方应用使用访问令牌来向资源服务器（服务提供商）请求访问受保护的资源。
资源服务器验证访问令牌的有效性，并根据授权范围决定是否授权访问请求的资源。

通过 OAuth 2.0，用户不再直接将密码提供给第三方应用，而是通过授权服务器生成的访问令牌来访问资源。这种方式更安全，因为访问令牌具有一定的有效性，且不包含用户的密码信息。

03 如何设计呢？

下面，我们试图询问一下 ChatGPT，看看它给出什么建议，用好 AI 很重要。

04 大厂如何做呢？

前面我们了解完 OAuth 2.0 的原理以及该如何做之后，我们基本知道一个大致的流程了。

下面，我们以微信网页授权为例子，看看微信这边是如何设计的。

网页授权 | 微信开发文档
https://developers.weixin.qq.com/doc/offiaccount/OA_Web_Apps/Wechat_webpage_authorization.html

网页授权流程分为四步：

引导用户进入授权页面同意授权，获取code。
通过code换取网页授权access_token（与基础支持中的access_token不同）。
如果需要，开发者可以刷新网页授权access_token，避免过期。
通过网页授权access_token和openid获取用户基本信息（支持UnionID机制）。

第一步：用户同意授权，获取 code。

在这一步，使用 GET 请求访问 /oauth2/authorize 接口，携带 app_id，redirect_uri，response_type，scope及state等。当用户同意授权，页面将跳转至 redirect_uri/?code=CODE&state=STATE。进而获取到 code 值。

第二步：通过 code 获取网页授权 access_token。

通过上一步获取到的 code，使用 GET 请求访问 /oauth2/access_token 接口，携带 app_id，secret，code及grant_type=authorization_code等。最终获取到 access_token 及 refresh_token 。

第三步：刷新 access_token （如果需要）。

一般情况，获取的 access_toekn 拥有较短的有效期，而 refresh_token 的有效期则较长（例如：30天），因此可以通过 refresh_token 进行刷新。

在微信开发平台中，其通过 GET 请求访问 /oauth2/refresh_token 接口，携带 app_id，grant_type=refresh_token 及 refresh_token 刷新 access_token。

一些其他的大厂的做法将刷新 access_token 的接口与获取 access_token 的接口做为同一个接口，通过 grant_type 类型值作区分。

第四步：通过 access_token 访问其他接口。

在 access_token 有效期内，就可以通过 access_token 去访问其他接口啦。

其他大厂开放平台借鉴

Google开发平台：https://developers.google.com/identity/protocols/oauth2/web-server?hl=zh-cn#httprest_1

抖音开发平台：https://developer.open-douyin.com/docs/resource/zh-CN/dop/develop/openapi/account-permission/get-access-token/

05 协议

至此，在了解完所有知识之后，接下来将来设计我们需要的接口。

1. 登录页面，提供用户名和密码输入。

2. 登录接口，用于校验用户名和密码。

3. 授权页面，提供允许用户授权的按钮。

4. 授权接口，当用户允许授权时，回调到 redirect_uri 接口，获取code。

5. 获取 access_token 接口，通过上一步获取到 code 换取 access_token。

6. 刷新 access_token 接口，通过上一步获取到的 refresh_token，用于刷新 access_token。

以上就是我们的接口设计了，下面是部分代码，后续我一个个讲解下handler。

func main() {  mux := http.NewServeMux()  mux.HandleFunc("/oauth/authorize", authorizeHandler)  mux.HandleFunc("/login", loginHandler)  mux.HandleFunc("/oauth/access_token", accessTokenHandler)  mux.HandleFunc("/oauth/refresh_token", refreshTokenHandler)
  mux.HandleFunc(oauth2.DefaultLoginPageUrl, loginPageHandler)  mux.HandleFunc(oauth2.DefaultAuthPageUrl, authPageHandler)  server := http.Server{    Addr:    ":8088",    Handler: mux,  }  fmt.Println("Start server at http://localhost:8088/")  server.ListenAndServe()}

登录页面：

<!DOCTYPE html><html lang="en">
<head>    <meta charset="UTF-8">    <title>Login</title>    <link rel="stylesheet" href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css">    <script src="//code.jquery.com/jquery-2.2.4.min.js"></script>    <script src="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script></head>
<body>    <div class="container">        <h1>Login In</h1>        <form action="/login" method="POST">            <div class="form-group">                <label for="username">User Name</label>                <input type="text" class="form-control" name="username" required placeholder="Please enter your user name">            </div>            <div class="form-group">                <label for="password">Password</label>                <input type="password" class="form-control" name="password" placeholder="Please enter your password">            </div>            <button type="submit" class="btn btn-success">Login</button>        </form>    </div></body>
</html>

授权页面

<!DOCTYPE html><html lang="en">  <head>    <meta charset="UTF-8" />    <title>Auth</title>    <link      rel="stylesheet"      href="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css"    />    <script src="//code.jquery.com/jquery-2.2.4.min.js"></script>    <script src="//maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js"></script>  </head>
  <body>    <div class="container">      <div class="jumbotron">        <form action="/oauth/authorize" method="POST">          <h1>Authorize</h1>          <p>The client would like to perform actions on your behalf.</p>          <p>            <button              type="submit"              class="btn btn-primary btn-lg"              style="width:200px;"            >              Allow            </button>          </p>        </form>      </div>    </div>  </body></html>

06 go-oauth2 使用

讲了这么多，下面来简单介绍一下 go-oauth2，其目录结构如下：

其核心分为了 manage、server 以及 store。

manage：授权管理实例
server：提供授权服务器
store：客户端信息存储及 token 存储

manage 提供了以下很多方法：

下面，我简单介绍一下将会使用到的几个方法。

NewDefaultManager：创建一个默认的授权管理实例。
SetAuthorizeCodeTokenCfg：设置授权code的token配置参数。
SetRefreshTokenCfg：设置刷新token的配置参数。
MapTokenStorage：配置token的存储，例如使用redis。
MapAccessGenerate：配置生成 access_token 的实例。
MapClientStorage：配置客户端的存储实例。

同样的 server 也提供了以下很多属性和方法：

下面，我简单介绍一下将会使用到的几个方法。

NewServer：创建一个默认的授权服务器。
SetPasswordAuthorizationHandler：通过 username 和 password 获取 user_id。
SetUserAuthorizationHandler：从请求授权中获取用户id。
SetClientInfoHandler：从请求授权中获取client。

store 存储

NewClientStore：初始化客户端配置信息，即 client_id、secret等。

go-oauth 支持使用多种存储方式，例如memory、redis等。在本篇文章中，将使用 go-session 方式配置存储：Go 一个高效、安全且易于使用的 Go 会话库。

07 oauth server

定义参数配置信息：

package oauth2
import (  "github.com/go-oauth2/oauth2/v4/manage"  "time")
var (  // ClusterType means redis cluster.  ClusterType = "cluster"  // NodeType means redis node.  NodeType = "node"
  // DefaultAuthorizeCodeTokenCfg is the default authorization code grant token config.  DefaultAuthorizeCodeTokenCfg = &manage.Config{AccessTokenExp: time.Hour * 2, RefreshTokenExp: time.Hour * 24 * 30, IsGenerateRefresh: true}  // DefaultRefreshTokenCfg is the default refresh token config.  DefaultRefreshTokenCfg = &manage.RefreshingConfig{IsGenerateRefresh: false, IsRemoveAccess: false, IsRemoveRefreshing: false}
  // DefaultTokenStoragePrefixKey is the default token storage prefix key.  DefaultTokenStoragePrefixKey = "oauth2:token:"
  // DefaultRedisStorePrefixKey is the default session redis prefix key.  DefaultRedisStorePrefixKey = "oauth2:store:"
  // DefaultAuthorizeForm is the default authorization form.  DefaultAuthorizeForm = "DefaultAuthorizeForm"  // DefaultLoginUserId is the default login user id.  DefaultLoginUserId = "DefaultLoginUserId"
  DefaultLoginPageUrl = "/page/login"  DefaultAuthPageUrl  = "/page/auth")
// RedisConf defines the redis configuration.type RedisConf struct {  Addrs []string `json:"addrs"`  Pass  string   `json:"pass,optional"`  Type  string   `json:"type,default=node"`}

DefaultAuthorizeCodeTokenCfg：配置 access_token 的有效期为2个小时，refresh_token 的有效期为30天，且自动生成 refresh_token.

DefaultRefreshTokenCfg：配置不自动更新 refresh_token，不移除 access_token 和 refresh_token。

其他是自定义的变量名。

创建属于自己的 oauth2 server

package oauth2
import (  "context"  "github.com/bytedance/sonic"  "github.com/go-oauth2/oauth2/v4/errors"  "github.com/go-oauth2/oauth2/v4/generates"  "github.com/go-oauth2/oauth2/v4/manage"  "github.com/go-oauth2/oauth2/v4/models"  "github.com/go-oauth2/oauth2/v4/server"  "github.com/go-oauth2/oauth2/v4/store"  oredis "github.com/go-oauth2/redis/v4"  "github.com/go-redis/redis/v8"  sredis "github.com/go-session/redis/v3"  "github.com/go-session/session/v3"  "net/http")
type Server struct {  *manage.Manager  *server.Server}
// NewServer 创建oauth2 serverfunc NewServer(conf RedisConf) *Server {  initSession(conf)  // 1. create to default authorization management instance.  manager := manage.NewDefaultManager()  // 1.1 set the authorization code grant token config.  manager.SetAuthorizeCodeTokenCfg(DefaultAuthorizeCodeTokenCfg)  // 1.2 set the refresh token config.  manager.SetRefreshTokenCfg(DefaultRefreshTokenCfg)  // 1.3 mapping the token store interface, set token store (redis).  if conf.Type == ClusterType {    manager.MapTokenStorage(oredis.NewRedisClusterStore(&redis.ClusterOptions{Addrs: conf.Addrs, Password: conf.Pass}, DefaultTokenStoragePrefixKey))  } else {    manager.MapTokenStorage(oredis.NewRedisStore(&redis.Options{Addr: conf.Addrs[0], Password: conf.Pass}, DefaultTokenStoragePrefixKey))  }  // 1.4 mapping the access token generate interface, generate access_token.  manager.MapAccessGenerate(generates.NewAccessGenerate())  // 1.5 mapping the client store interface, set client store.  clientStore := store.NewClientStore()  clientId, clientSecret, domain := "123456", "abcdef", "localhost:8080"  clientStore.Set("123456", &models.Client{    ID:     clientId,    Secret: clientSecret,    Domain: domain,  })  manager.MapClientStorage(clientStore)
  // 2. create authorization server.  config := server.NewConfig()  config.AllowGetAccessRequest = true  server := server.NewServer(config, manager)
  // server needs to implement UserAuthorizationHandler and PasswordAuthorizationHandler.  // 2.1 set the password authorization handler(get user id from username and password).  server.SetPasswordAuthorizationHandler(func(ctx context.Context, clientID, username, password string) (userId string, err error) {    return "user_id", nil  })
  // 2.2 set the user authorization handler(get user id from request).  server.SetUserAuthorizationHandler(func(w http.ResponseWriter, r *http.Request) (userId string, err error) {    store, err := session.Start(r.Context(), w, r)    if err != nil {      return "", err    }
    // 2.3.1 it's from /oauth/authorize?client_id=xxx and need to redirect to /login.    if r.Method == "GET" {      marshal, err := sonic.Marshal(r.Form)      if err != nil {        return "", err      }      store.Set(DefaultAuthorizeForm, string(marshal))      store.Save()      w.Header().Set("Location", DefaultLoginPageUrl)      w.WriteHeader(http.StatusFound)      return "", nil    }
    // 2.3.2 it's allow auth and from /login redirect /oauth/authorize, will get code to redirect_uri.    if r.Method == "POST" {      if r.Form == nil {        err = r.ParseForm()        if err != nil {          return "", err        }      }
      userID, ok := store.Get(DefaultLoginUserId)      if !ok {        // not userID in session, redirect to /login.        w.Header().Set("Location", DefaultLoginPageUrl)        w.WriteHeader(http.StatusFound)        return      }      store.Delete(DefaultLoginUserId)      store.Save()
      return userID.(string), nil    }    return "", nil  })  // 2.3 set client info handler  server.SetClientInfoHandler(func(r *http.Request) (clientID, clientSecret string, err error) {    // 从请求头获取clientId、clientSecret等    clientID = r.FormValue("client_id")    if len(clientID) == 0 {      return "", "", errors.ErrInvalidRequest    }
    clientSecret = r.FormValue("client_secret")    if len(clientSecret) == 0 {      return "", "", errors.ErrInvalidRequest    }    return  })
  return &Server{Manager: manager, Server: server}}
// use redis as session manager.func initSession(conf RedisConf) {  var store session.ManagerStore  if conf.Type == ClusterType {    store = sredis.NewRedisClusterStore(&sredis.ClusterOptions{Addrs: conf.Addrs, Password: conf.Pass}, DefaultRedisStorePrefixKey)  } else {    store = sredis.NewRedisStore(&sredis.Options{Addr: conf.Addrs[0], Password: conf.Pass}, DefaultRedisStorePrefixKey)  }
  session.InitManager(session.SetStore(store))}

上面代码已经把整个流程都写清楚了，server 使用了很多 handler ，方便开发者自定义参数配置。通过 session 会话库，保存请求的跳转状态。同时，也使用到 redis 去存储 code、access_token、refresh_token等信息。

08 客户端调用

在前面，我们已经定义了要使用到的几个接口，下面看看接口的具体参数以及如何调用上一步封装好的 server。

请求参数和响应结果如下：

package types
// AuthorizeReq 用户授权请求，如果用户同意授权，页面将跳转至 redirect_uri/?code=CODE&state=STATE。type AuthorizeReq struct {  ClientId     string `query:"client_id"`  RedirectUri  string `query:"redirect_uri"`  ResponseType string `query:"response_type,default=code"`  Scope        string `query:"scope,default=scope"`  State        string `query:"state,optional"`}type AuthorizeResp struct {}
// LoginReq 登录请求type LoginReq struct {  Username string `form:"username"`  Password string `form:"password"`}type LoginResp struct {}
// AccessTokenReq 通过code换取access_tokentype AccessTokenReq struct {  ClientId     string `json:"client_id"`  ClientSecret string `json:"client_secret"`  Code         string `json:"code"`  GrantType    string `json:"grant_type,default=authorization_code"`  RedirectUri  string `json:"redirect_uri"`}type AccessTokenRsp struct {}
// RefreshTokenReq 刷新access_tokentype RefreshTokenReq struct {  ClientId     string `json:"client_id"`  ClientSecret string `json:"client_secret"`  RefreshToken string `json:"refresh_token"`  GrantType    string `json:"grant_type,default=refresh_token"`  RedirectUri  string `json:"redirect_uri"`}type RefreshTokenRsp struct {}

客户端接口

下面我使用原生的 ServerMux 来演示，如果你使用 gin 框架或者 go-zero等框架，原理也一样。

package main
import (  "fmt"  "github.com/bytedance/sonic"  "github.com/go-session/session/v3"  "net/http"  "net/url"  "oauth2"  "oauth2/server/types"  "oauth2/server/utils"  "os")
var server *oauth2.Server
func init() {  server = oauth2.NewServer(oauth2.RedisConf{Addrs: []string{"127.0.0.1:6379"}})}
func main() {  mux := http.NewServeMux()  mux.HandleFunc("/oauth/authorize", authorizeHandler)  mux.HandleFunc("/login", loginHandler)  mux.HandleFunc("/oauth/access_token", accessTokenHandler)  mux.HandleFunc("/oauth/refresh_token", refreshTokenHandler)
  mux.HandleFunc(oauth2.DefaultLoginPageUrl, loginPageHandler)  mux.HandleFunc(oauth2.DefaultAuthPageUrl, authPageHandler)  server := http.Server{    Addr:    ":8088",    Handler: mux,  }  fmt.Println("Start server at http://localhost:8088/")  server.ListenAndServe()}
// 授权接口func authorizeHandler(w http.ResponseWriter, r *http.Request) {  // There will be two steps here, one is to enter through the /authorize interface,  // and the other is to enter when obtaining the code  store, err := session.Start(r.Context(), w, r)  if err != nil {    http.Error(w, err.Error(), http.StatusInternalServerError)    return  }
  var form url.Values  v, ok := store.Get(oauth2.DefaultAuthorizeForm)  if !ok {    // oauth2 access GET /oauth/authorize?client_id=123456&redirect_uri=http://localhost:8080/redirect.html&response_type=code&scope=scope    // Do some verification, such as client_id, redirect_uri, etc.    var req types.AuthorizeReq    err = utils.Parse(r, &req)    if err != nil {      return    }  } else {    // oauth2 access POST /oauth/authorize get code to redirect_uri    err = sonic.Unmarshal([]byte(v.(string)), &form)    if err != nil {      return    }  }  r.Form = form
  store.Delete(oauth2.DefaultAuthorizeForm)  store.Save()
  err = server.HandleAuthorizeRequest(w, r)  if err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)  }}
// 登录接口，校验用户名密码func loginHandler(w http.ResponseWriter, r *http.Request) {  var req types.LoginReq  err := utils.Parse(r, &req)  if err != nil {    return  }
  store, err := session.Start(r.Context(), w, r)  if err != nil {    http.Error(w, err.Error(), http.StatusInternalServerError)    return  }
  if r.Form == nil {    if err := r.ParseForm(); err != nil {      http.Error(w, err.Error(), http.StatusInternalServerError)      return    }  }
  if req.Username != "admin" || req.Password != "123456" {    w.WriteHeader(http.StatusForbidden)    return  }
  store.Set(oauth2.DefaultLoginUserId, r.Form.Get("username"))  store.Save()
  w.Header().Set("Location", oauth2.DefaultAuthPageUrl)  w.WriteHeader(http.StatusFound)}
// 获取access_tokenfunc accessTokenHandler(w http.ResponseWriter, r *http.Request) {  var req types.AccessTokenReq  err := utils.Parse(r, &req)  if err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)    return  }
  if err := r.ParseForm(); err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)    return  }
  form := url.Values{}  form.Set("client_id", req.ClientId)  form.Set("client_secret", req.ClientSecret)  form.Set("code", req.Code)  form.Set("grant_type", req.GrantType)  form.Set("redirect_uri", req.RedirectUri)  r.Form = form  err = server.HandleTokenRequest(w, r)  if err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)    return  }}
// 刷新access_tokenfunc refreshTokenHandler(w http.ResponseWriter, r *http.Request) {  var req types.RefreshTokenReq  err := utils.Parse(r, &req)  if err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)    return  }
  if err := r.ParseForm(); err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)    return  }
  form := url.Values{}  form.Set("client_id", req.ClientId)  form.Set("client_secret", req.ClientSecret)  form.Set("refresh_token", req.RefreshToken)  form.Set("grant_type", req.GrantType)  form.Set("redirect_uri", req.RedirectUri)  r.Form = form  err = server.HandleTokenRequest(w, r)  if err != nil {    http.Error(w, err.Error(), http.StatusBadRequest)    return  }}
// 登录页面func loginPageHandler(w http.ResponseWriter, r *http.Request) {  outputHTML(w, r, "static/login.html")}
// 授权页面func authPageHandler(w http.ResponseWriter, r *http.Request) {  outputHTML(w, r, "static/auth.html")}
func outputHTML(w http.ResponseWriter, req *http.Request, filename string) {  file, err := os.Open(filename)  if err != nil {    http.Error(w, err.Error(), 500)    return  }  defer file.Close()  fi, _ := file.Stat()  http.ServeContent(w, req, file.Name(), fi.ModTime(), file)}

使用方式：

1、浏览器访问授权接口：http://localhost:8088/oauth/authorize?client_id=123456&redirect_uri=http://localhost:8080/redirect.html&response_type=code&scope=scope，将会重定向到登录页面。

2、在登录页面输入用户名密码，代码中设定的是admin 和 123456。登录成功将会跳转向到授权页面。

3、在授权页面中允许授权，将会请求授权接口，并重定向到 redirect_uri 地址。

4、在重定向的地址，将获取到 code，例如：http://localhost:8080/redirect.html?code=ZDVMZGMWMJQTZTC0MI0ZOWJJLTG5ZTKTN2FKMJG1MJC1ODMY

5、通过 code 去获取 access_token。

curl --location --request GET 'http://localhost:8088/oauth/access_token' \--header 'Content-Type: application/json' \--data '{    "client_id": "123456",    "client_secret": "abcdef",    "code": "ZDVMZGMWMJQTZTC0MI0ZOWJJLTG5ZTKTN2FKMJG1MJC1ODMY",    "grant_type": "authorization_code",    "redirect_uri":"http://localhost:8080/redirect.html"}'

{    "access_token": "NJDKZGEZMJQTZMI2MC0ZY2VILTKYNWYTY2YXMGU3NDRMYZBJ",    "expires_in": 604800,    "refresh_token": "N2Q5NZCYZMMTOTVKZI01OWE3LTLIOTCTNMJHNMMWZWI2OTM5",    "scope": "scope",    "token_type": "Bearer"}

6、通过 refresh_token 去刷新 access_token。

curl --location --request GET 'http://localhost:8088/oauth/refresh_token' \--header 'Content-Type: application/json' \--data '{    "client_id": "123456",    "client_secret": "abcdef",    "refresh_token": "N2Q5NZCYZMMTOTVKZI01OWE3LTLIOTCTNMJHNMMWZWI2OTM5",    "grant_type": "refresh_token",    "redirect_uri":"http://localhost:8080/redirect.html"}'

{    "access_token": "YWMXZJDKMDMTNZVINS0ZOTJLLTG4OGUTN2FKYJG2NGU4NJGX",    "expires_in": 604800,    "scope": "scope",    "token_type": "Bearer"}

至此，完整的流程就结束了，希望对你有帮助，我把代码放在 github 上了，感兴趣的小伙伴可以查看，麻烦点个 star 支持一下：https://github.com/fliyu/oauth2

09 总结

感谢你看了这么长的一篇，希望对你有帮助，欢迎评论区跟我交谈，下篇再见。

推荐阅读

欢迎关注点赞分享与收藏，一起学习进步！

专注于 Go 语言领域工作学习经验分享，期待与您一同学习进步。学的不仅是技术，更是梦想！

继续滑动看下一个