深圳幻海软件技术有限公司 欢迎您！
更多

构建一个即时消息应用（二）：OAuth

2023-02-27

http user err
上一篇：模式。在这篇帖子中，我们将会通过为应用添加社交登录功能进入后端开发。社交登录的工作方式十分简单：用户点击链接，然后重定向到GitHub授权页面。当用户授予我们对他的个人信息的访问权限之后，就会重定向回登录页面。下一次尝试登录时，系统将不会再次请求授权，也就是说，我们的应用已经记住了这个用户。

上一篇：模式。

在这篇帖子中，我们将会通过为应用添加社交登录功能进入后端开发。

社交登录的工作方式十分简单：用户点击链接，然后重定向到 GitHub 授权页面。当用户授予我们对他的个人信息的访问权限之后，就会重定向回登录页面。下一次尝试登录时，系统将不会再次请求授权，也就是说，我们的应用已经记住了这个用户。这使得整个登录流程看起来就和你用鼠标单击一样快。

如果进一步考虑其内部实现的话，过程就会变得复杂起来。首先，我们需要注册一个新的 GitHub OAuth 应用。

这一步中，比较重要的是回调 URL。我们将它设置为 http://localhost:3000/api/oauth/github/callback。这是因为，在开发过程中，我们总是在本地主机上工作。一旦你要将应用交付生产，请使用正确的回调 URL 注册一个新的应用。

注册以后，你将会收到“客户端 id”和“安全密钥”。安全起见，请不要与任何人分享他们 👀

顺便让我们开始写一些代码吧。现在，创建一个 main.go 文件：

  1. package main
  2.  
  3. import (
  4.     "database/sql"
  5.     "fmt"
  6.     "log"
  7.     "net/http"
  8.     "net/url"
  9.     "os"
  10.     "strconv"
  11.  
  12.     "github.com/gorilla/securecookie"
  13.     "github.com/joho/godotenv"
  14.     "github.com/knq/jwt"
  15.     _ "github.com/lib/pq"
  16.     "github.com/matryer/way"
  17.     "golang.org/x/oauth2"
  18.     "golang.org/x/oauth2/github"
  19. )
  20.  
  21. var origin *url.URL
  22. var db *sql.DB
  23. var githubOAuthConfig *oauth2.Config
  24. var cookieSigner *securecookie.SecureCookie
  25. var jwtSigner jwt.Signer
  26.  
  27. func main() {
  28.     godotenv.Load()
  29.  
  30.     port := intEnv("PORT", 3000)
  31.     originString := env("ORIGIN", fmt.Sprintf("http://localhost:%d/", port))
  32.     databaseURL := env("DATABASE_URL", "postgresql://root@127.0.0.1:26257/messenger?sslmode=disable")
  33.     githubClientID := os.Getenv("GITHUB_CLIENT_ID")
  34.     githubClientSecret := os.Getenv("GITHUB_CLIENT_SECRET")
  35.     hashKey := env("HASH_KEY", "secret")
  36.     jwtKey := env("JWT_KEY", "secret")
  37.  
  38.     var err error
  39.     if origin, err = url.Parse(originString); err != nil || !origin.IsAbs() {
  40.         log.Fatal("invalid origin")
  41.         return
  42.     }
  43.  
  44.     if i, err := strconv.Atoi(origin.Port()); err == nil {
  45.         port = i
  46.     }
  47.  
  48.     if githubClientID == "" || githubClientSecret == "" {
  49.         log.Fatalf("remember to set both $GITHUB_CLIENT_ID and $GITHUB_CLIENT_SECRET")
  50.         return
  51.     }
  52.  
  53.     if db, err = sql.Open("postgres", databaseURL); err != nil {
  54.         log.Fatalf("could not open database connection: %v\n", err)
  55.         return
  56.     }
  57.     defer db.Close()
  58.     if err = db.Ping(); err != nil {
  59.         log.Fatalf("could not ping to db: %v\n", err)
  60.         return
  61.     }
  62.  
  63.     githubRedirectURL := *origin
  64.     githubRedirectURL.Path = "/api/oauth/github/callback"
  65.     githubOAuthConfig = &oauth2.Config{
  66.         ClientID:     githubClientID,
  67.         ClientSecret: githubClientSecret,
  68.         Endpoint:     github.Endpoint,
  69.         RedirectURL:  githubRedirectURL.String(),
  70.         Scopes:       []string{"read:user"},
  71.     }
  72.  
  73.     cookieSigner = securecookie.New([]byte(hashKey), nil).MaxAge(0)
  74.  
  75.     jwtSigner, err = jwt.HS256.New([]byte(jwtKey))
  76.     if err != nil {
  77.         log.Fatalf("could not create JWT signer: %v\n", err)
  78.         return
  79.     }
  80.  
  81.     router := way.NewRouter()
  82.     router.HandleFunc("GET", "/api/oauth/github", githubOAuthStart)
  83.     router.HandleFunc("GET", "/api/oauth/github/callback", githubOAuthCallback)
  84.     router.HandleFunc("GET", "/api/auth_user", guard(getAuthUser))
  85.  
  86.     log.Printf("accepting connections on port %d\n", port)
  87.     log.Printf("starting server at %s\n", origin.String())
  88.     addr := fmt.Sprintf(":%d", port)
  89.     if err = http.ListenAndServe(addr, router); err != nil {
  90.         log.Fatalf("could not start server: %v\n", err)
  91.     }
  92. }
  93.  
  94. func env(key, fallbackValue string) string {
  95.     v, ok := os.LookupEnv(key)
  96.     if !ok {
  97.         return fallbackValue
  98.     }
  99.     return v
  100. }
  101.  
  102. func intEnv(key string, fallbackValue int) int {
  103.     v, ok := os.LookupEnv(key)
  104.     if !ok {
  105.         return fallbackValue
  106.     }
  107.     i, err := strconv.Atoi(v)
  108.     if err != nil {
  109.         return fallbackValue
  110.     }
  111.     return i
  112. }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.
  • 101.
  • 102.
  • 103.
  • 104.
  • 105.
  • 106.
  • 107.
  • 108.
  • 109.
  • 110.
  • 111.
  • 112.

安装依赖项：

  1. go get -u github.com/gorilla/securecookie
  2. go get -u github.com/joho/godotenv
  3. go get -u github.com/knq/jwt
  4. go get -u github.com/lib/pq
  5. ge get -u github.com/matoous/go-nanoid
  6. go get -u github.com/matryer/way
  7. go get -u golang.org/x/oauth2
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.

我们将会使用 .env 文件来保存密钥和其他配置。请创建这个文件，并保证里面至少包含以下内容：

  1. GITHUB_CLIENT_ID=your_github_client_id
  2. GITHUB_CLIENT_SECRET=your_github_client_secret
  • 1.
  • 2.

我们还要用到的其他环境变量有：

  • PORT：服务器运行的端口，默认值是 3000。
  • ORIGIN：你的域名，默认值是 http://localhost:3000/。我们也可以在这里指定端口。
  • DATABASE_URL：Cockroach 数据库的地址。默认值是 postgresql://root@127.0.0.1:26257/messenger?sslmode=disable。
  • HASH_KEY：用于为 cookie 签名的密钥。没错，我们会使用已签名的 cookie 来确保安全。
  • JWT_KEY：用于签署 JSON 网络令牌Web Token的密钥。

因为代码中已经设定了默认值，所以你也不用把它们写到 .env 文件中。

在读取配置并连接到数据库之后，我们会创建一个 OAuth 配置。我们会使用 ORIGIN 信息来构建回调 URL（就和我们在 GitHub 页面上注册的一样）。我们的数据范围设置为 “read:user”。这会允许我们读取公开的用户信息，这里我们只需要他的用户名和头像就够了。然后我们会初始化 cookie 和 JWT 签名器。定义一些端点并启动服务器。

在实现 HTTP 处理程序之前，让我们编写一些函数来发送 HTTP 响应。

  1. func respond(w http.ResponseWriter, v interface{}, statusCode int) {
  2.     b, err := json.Marshal(v)
  3.     if err != nil {
  4.         respondError(w, fmt.Errorf("could not marshal response: %v", err))
  5.         return
  6.     }
  7.     w.Header().Set("Content-Type", "application/json; charset=utf-8")
  8.     w.WriteHeader(statusCode)
  9.     w.Write(b)
  10. }
  11.  
  12. func respondError(w http.ResponseWriter, err error) {
  13.     log.Println(err)
  14.     http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
  15. }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.

第一个函数用来发送 JSON，而第二个将错误记录到控制台并返回一个 500 Internal Server Error 错误信息。

OAuth 开始

所以，用户点击写着 “Access with GitHub” 的链接。该链接指向 /api/oauth/github，这将会把用户重定向到 github。

  1. func githubOAuthStart(w http.ResponseWriter, r *http.Request) {
  2.     state, err := gonanoid.Nanoid()
  3.     if err != nil {
  4.         respondError(w, fmt.Errorf("could not generte state: %v", err))
  5.         return
  6.     }
  7.  
  8.     stateCookieValue, err := cookieSigner.Encode("state", state)
  9.     if err != nil {
  10.         respondError(w, fmt.Errorf("could not encode state cookie: %v", err))
  11.         return
  12.     }
  13.  
  14.     http.SetCookie(w, &http.Cookie{
  15.         Name:     "state",
  16.         Value:    stateCookieValue,
  17.         Path:     "/api/oauth/github",
  18.         HttpOnly: true,
  19.     })
  20.     http.Redirect(w, r, githubOAuthConfig.AuthCodeURL(state), http.StatusTemporaryRedirect)
  21. }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.

OAuth2 使用一种机制来防止 CSRF ，因此它需要一个“状态”（state）。我们使用 Nanoid() 来创建一个随机字符串，并用这个字符串作为状态。我们也把它保存为一个 cookie。

OAuth 回调

一旦用户授权我们访问他的个人信息，他将会被重定向到这个端点。这个 URL 的查询字符串上将会包含状态（state）和授权码（code）： /api/oauth/github/callback?state=&code=。

  1. const jwtLifetime = time.Hour * 24 * 14
  2.  
  3. type GithubUser struct {
  4.     ID        int     `json:"id"`
  5.     Login     string  `json:"login"`
  6.     AvatarURL *string `json:"avatar_url,omitempty"`
  7. }
  8.  
  9. type User struct {
  10.     ID        string  `json:"id"`
  11.     Username  string  `json:"username"`
  12.     AvatarURL *string `json:"avatarUrl"`
  13. }
  14.  
  15. func githubOAuthCallback(w http.ResponseWriter, r *http.Request) {
  16.     stateCookie, err := r.Cookie("state")
  17.     if err != nil {
  18.         http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
  19.         return
  20.     }
  21.  
  22.     http.SetCookie(w, &http.Cookie{
  23.         Name:     "state",
  24.         Value:    "",
  25.         MaxAge:   -1,
  26.         HttpOnly: true,
  27.     })
  28.  
  29.     var state string
  30.     if err = cookieSigner.Decode("state", stateCookie.Value, &state); err != nil {
  31.         http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
  32.         return
  33.     }
  34.  
  35.     q := r.URL.Query()
  36.  
  37.     if state != q.Get("state") {
  38.         http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
  39.         return
  40.     }
  41.  
  42.     ctx := r.Context()
  43.  
  44.     t, err := githubOAuthConfig.Exchange(ctx, q.Get("code"))
  45.     if err != nil {
  46.         respondError(w, fmt.Errorf("could not fetch github token: %v", err))
  47.         return
  48.     }
  49.  
  50.     client := githubOAuthConfig.Client(ctx, t)
  51.     resp, err := client.Get("https://api.github.com/user")
  52.     if err != nil {
  53.         respondError(w, fmt.Errorf("could not fetch github user: %v", err))
  54.         return
  55.     }
  56.  
  57.     var githubUser GithubUser
  58.     if err = json.NewDecoder(resp.Body).Decode(&githubUser); err != nil {
  59.         respondError(w, fmt.Errorf("could not decode github user: %v", err))
  60.         return
  61.     }
  62.     defer resp.Body.Close()
  63.  
  64.     tx, err := db.BeginTx(ctx, nil)
  65.     if err != nil {
  66.         respondError(w, fmt.Errorf("could not begin tx: %v", err))
  67.         return
  68.     }
  69.  
  70.     var user User
  71.     if err = tx.QueryRowContext(ctx, `
  72.         SELECT id, username, avatar_url FROM users WHERE github_id = $1
  73.     `, githubUser.ID).Scan(&user.ID, &user.Username, &user.AvatarURL); err == sql.ErrNoRows {
  74.         if err = tx.QueryRowContext(ctx, `
  75.             INSERT INTO users (username, avatar_url, github_id) VALUES ($1, $2, $3)
  76.             RETURNING id
  77.         `, githubUser.Login, githubUser.AvatarURL, githubUser.ID).Scan(&user.ID); err != nil {
  78.             respondError(w, fmt.Errorf("could not insert user: %v", err))
  79.             return
  80.         }
  81.         user.Username = githubUser.Login
  82.         user.AvatarURL = githubUser.AvatarURL
  83.     } else if err != nil {
  84.         respondError(w, fmt.Errorf("could not query user by github ID: %v", err))
  85.         return
  86.     }
  87.  
  88.     if err = tx.Commit(); err != nil {
  89.         respondError(w, fmt.Errorf("could not commit to finish github oauth: %v", err))
  90.         return
  91.     }
  92.  
  93.     exp := time.Now().Add(jwtLifetime)
  94.     token, err := jwtSigner.Encode(jwt.Claims{
  95.         Subject:    user.ID,
  96.         Expiration: json.Number(strconv.FormatInt(exp.Unix(), 10)),
  97.     })
  98.     if err != nil {
  99.         respondError(w, fmt.Errorf("could not create token: %v", err))
  100.         return
  101.     }
  102.  
  103.     expiresAt, _ := exp.MarshalText()
  104.  
  105.     data := make(url.Values)
  106.     data.Set("token", string(token))
  107.     data.Set("expires_at", string(expiresAt))
  108.  
  109.     http.Redirect(w, r, "/callback?"+data.Encode(), http.StatusTemporaryRedirect)
  110. }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.
  • 31.
  • 32.
  • 33.
  • 34.
  • 35.
  • 36.
  • 37.
  • 38.
  • 39.
  • 40.
  • 41.
  • 42.
  • 43.
  • 44.
  • 45.
  • 46.
  • 47.
  • 48.
  • 49.
  • 50.
  • 51.
  • 52.
  • 53.
  • 54.
  • 55.
  • 56.
  • 57.
  • 58.
  • 59.
  • 60.
  • 61.
  • 62.
  • 63.
  • 64.
  • 65.
  • 66.
  • 67.
  • 68.
  • 69.
  • 70.
  • 71.
  • 72.
  • 73.
  • 74.
  • 75.
  • 76.
  • 77.
  • 78.
  • 79.
  • 80.
  • 81.
  • 82.
  • 83.
  • 84.
  • 85.
  • 86.
  • 87.
  • 88.
  • 89.
  • 90.
  • 91.
  • 92.
  • 93.
  • 94.
  • 95.
  • 96.
  • 97.
  • 98.
  • 99.
  • 100.
  • 101.
  • 102.
  • 103.
  • 104.
  • 105.
  • 106.
  • 107.
  • 108.
  • 109.
  • 110.

首先，我们会尝试使用之前保存的状态对 cookie 进行解码。并将其与查询字符串中的状态进行比较。如果它们不匹配，我们会返回一个 418 I'm teapot（未知来源）错误。

接着，我们使用授权码生成一个令牌。这个令牌被用于创建 HTTP 客户端来向 GitHub API 发出请求。所以最终我们会向 https://api.github.com/user 发送一个 GET 请求。这个端点将会以 JSON 格式向我们提供当前经过身份验证的用户信息。我们将会解码这些内容，一并获取用户的 ID、登录名（用户名）和头像 URL。

然后我们将会尝试在数据库上找到具有该 GitHub ID 的用户。如果没有找到，就使用该数据创建一个新的。

之后，对于新创建的用户，我们会发出一个将用户 ID 作为主题（Subject）的 JSON 网络令牌，并使用该令牌重定向到前端，查询字符串中一并包含该令牌的到期日（Expiration）。

这一 Web 应用也会被用在其他帖子，但是重定向的链接会是 /callback?token=&expires_at=。在那里，我们将会利用 JavaScript 从 URL 中获取令牌和到期日，并通过 Authorization 标头中的令牌以 Bearer token_here 的形式对 /api/auth_user 进行 GET 请求，来获取已认证的身份用户并将其保存到 localStorage。

Guard 中间件

为了获取当前已经过身份验证的用户，我们设计了 Guard 中间件。这是因为在接下来的文章中，我们会有很多需要进行身份认证的端点，而中间件将会允许我们共享这一功能。

  1. type ContextKey struct {
  2.     Name string
  3. }
  4.  
  5. var keyAuthUserID = ContextKey{"auth_user_id"}
  6.  
  7. func guard(handler http.HandlerFunc) http.HandlerFunc {
  8.     return func(w http.ResponseWriter, r *http.Request) {
  9.         var token string
  10.         if a := r.Header.Get("Authorization"); strings.HasPrefix(a, "Bearer ") {
  11.             token = a[7:]
  12.         } else if t := r.URL.Query().Get("token"); t != "" {
  13.             token = t
  14.         } else {
  15.             http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
  16.             return
  17.         }
  18.  
  19.         var claims jwt.Claims
  20.         if err := jwtSigner.Decode([]byte(token), &claims); err != nil {
  21.             http.Error(w, http.StatusText(http.StatusUnauthorized), http.StatusUnauthorized)
  22.             return
  23.         }
  24.  
  25.         ctx := r.Context()
  26.         ctx = context.WithValue(ctx, keyAuthUserID, claims.Subject)
  27.  
  28.         handler(w, r.WithContext(ctx))
  29.     }
  30. }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.
  • 20.
  • 21.
  • 22.
  • 23.
  • 24.
  • 25.
  • 26.
  • 27.
  • 28.
  • 29.
  • 30.

首先，我们尝试从 Authorization 标头或者是 URL 查询字符串中的 token 字段中读取令牌。如果没有找到，我们需要返回 401 Unauthorized（未授权）错误。然后我们将会对令牌中的申明进行解码，并使用该主题作为当前已经过身份验证的用户 ID。

现在，我们可以用这一中间件来封装任何需要授权的 http.handlerFunc，并且在处理函数的上下文中保有已经过身份验证的用户 ID。

  1. var guarded = guard(func(w http.ResponseWriter, r *http.Request) {
  2.     authUserID := r.Context().Value(keyAuthUserID).(string)
  3. })
  • 1.
  • 2.
  • 3.

获取认证用户

  1. func getAuthUser(w http.ResponseWriter, r *http.Request) {
  2.     ctx := r.Context()
  3.     authUserID := ctx.Value(keyAuthUserID).(string)
  4.  
  5.     var user User
  6.     if err := db.QueryRowContext(ctx, `
  7.         SELECT username, avatar_url FROM users WHERE id = $1
  8.     `, authUserID).Scan(&user.Username, &user.AvatarURL); err == sql.ErrNoRows {
  9.         http.Error(w, http.StatusText(http.StatusTeapot), http.StatusTeapot)
  10.         return
  11.     } else if err != nil {
  12.         respondError(w, fmt.Errorf("could not query auth user: %v", err))
  13.         return
  14.     }
  15.  
  16.     user.ID = authUserID
  17.  
  18.     respond(w, user, http.StatusOK)
  19. }
  • 1.
  • 2.
  • 3.
  • 4.
  • 5.
  • 6.
  • 7.
  • 8.
  • 9.
  • 10.
  • 11.
  • 12.
  • 13.
  • 14.
  • 15.
  • 16.
  • 17.
  • 18.
  • 19.

我们使用 Guard 中间件来获取当前经过身份认证的用户 ID 并查询数据库。

这一部分涵盖了后端的 OAuth 流程。在下一篇帖子中，我们将会看到如何开始与其他用户的对话。

  • 源代码

 

如何两天时间上线一款AI应用？
用自己的编程语言实现了一个网站（增强版）