【Go语言Web开发】使用 JWT 保护您的 Go REST API

注意 - 本教程的完整源代码可以在这里找到：TutorialEdge/go-jwt-tutorial

JWT，或者更正式地称为 JSON Web 令牌，是一种紧凑的、URL 安全的方式，用于表示要在两方之间传输的声明。这本质上是一种令人困惑的说法，即 JWT 允许您以无状态但安全的方式将信息从客户端传输到服务器。

先决条件

在您阅读本文之前，您将需要以下内容：

• 您需要在开发机器上安装 Go 版本 1.11+。

介绍

JWT 标准使用 HMAC 算法的密钥或使用 RSA 或 ECDSA 的公钥/私钥对。

注意 - 如果您对 JWT 的正式定义感兴趣，那么我建议您查看 RFC：RFC-7519

这些在单页应用程序 (SPA) 中被大量用作安全通信的手段，因为它们允许我们做两件关键的事情：

• 身份验证 - 最常用的做法。一旦用户登录到您的应用程序或以某种方式进行身份验证，然后代表用户从客户端发送的每个请求都将包含 JWT。
• 信息交换——JWT 的第二个用途是在不同系统之间安全地传输信息。这些 JWT 可以使用公钥/私钥对进行签名，因此您可以以安全的方式验证此事务中的每个系统，并且 JWT 包含防篡改机制，因为它们是基于标头和有效负载进行签名的。

因此，如果您现在还没有猜到，在本教程中，我们将确切了解构建使用 JSON Web 令牌进行通信的基于 Go 的安全 REST API 需要什么！

视频教程

本教程以视频格式提供，如果您想支持我和我的工作，请随时点赞并订阅我的频道以获取我的内容！

https://youtu.be/-Scg9INymBs

一个简单的 REST API

因此，我们将使用我的另一篇文章中的代码，在 Go 中创建一个简单的 REST API，让我们开始。这将具有一个非常简单的 Hello World 风格的端点，它将在端口 8081 上运行。

package main

import (
    "fmt"
    "log"
    "net/http"
)

func homePage(w http.ResponseWriter, r *http.Request){
    fmt.Fprintf(w, "Hello World")
    fmt.Println("Endpoint Hit: homePage")
}

func handleRequests() {
    http.HandleFunc("/", homePage)
    log.Fatal(http.ListenAndServe(":8081", nil))
}

func main() {
    handleRequests()
}

当我们尝试访问我们的主页时，在 http://localhost:8081/ 上运行，我们应该在浏览器中看到消息 Hello World。

JWT 认证

所以，既然我们有了一个简单的 API，我们现在可以使用签名的 JWT 令牌来保护它，让我们构建一个客户端 API，它将尝试从这个原始 API 请求数据。

为此，我们可以使用已使用安全密钥签名的 JWT，我们的客户端和服务器都将知道该密钥。让我们来看看它是如何工作的：

• 我们的客户将根据我们的共享密码生成一个签名的 JWT。
• 当我们的客户端访问我们的服务器 API 时，它将包含这个 JWT 作为请求的一部分。
• 我们的服务器将能够读取此 JWT 并使用相同的密码验证令牌。
• 如果 JWT 有效，则将高度机密的 hello world 消息返回给客户端，否则将返回未授权。

我们的架构图最终看起来有点像这样：

架构图

 

我们的服务器

所以，让我们看看这个，让我们创建一个非常简单的服务器：

package main

import (
    "fmt"
    "log"
    "net/http"

    jwt "github.com/dgrijalva/jwt-go"
)

var mySigningKey = []byte("captainjacksparrowsayshi")

func homePage(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello World")
    fmt.Println("Endpoint Hit: homePage")

}

func isAuthorized(endpoint func(http.ResponseWriter, *http.Request)) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {

        if r.Header["Token"] != nil {

            token, err := jwt.Parse(r.Header["Token"][0], func(token *jwt.Token) (interface{}, error) {
                if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
                    return nil, fmt.Errorf("There was an error")
                }
                return mySigningKey, nil
            })

            if err != nil {
                fmt.Fprintf(w, err.Error())
            }

            if token.Valid {
                endpoint(w, r)
            }
        } else {

            fmt.Fprintf(w, "Not Authorized")
        }
    })
}

func handleRequests() {
    http.Handle("/", isAuthorized(homePage))
    log.Fatal(http.ListenAndServe(":9000", nil))
}

func main() {
    handleRequests()
}

让我们分解一下。 我们创建了一个非常简单的 API，它具有一个单独的端点，它受到我们的 isAuthorized 中间件装饰器的保护。 在这个 isAuthorized 函数中，我们检查传入请求是否包含请求中的 Token 标头，然后我们随后根据我们的私有 mySigningKey 检查令牌是否有效。

如果这是一个有效的令牌，我们就会为受保护的端点提供服务。

注意 - 这个例子使用了装饰器，如果你对 Go 中装饰器的概念不满意，那么我建议你在这里查看我的另一篇文章：Go 中的装饰器入门

我们的客户

现在我们有了一个具有 JWT 安全端点的服务器，让我们构建一些可以与之交互的东西。

我们将构建一个简单的客户端应用程序，它将尝试调用我们服务器的 / 端点。

package main

import (
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
    "time"

    jwt "github.com/dgrijalva/jwt-go"
)

var mySigningKey = []byte("captainjacksparrowsayshi")

func homePage(w http.ResponseWriter, r *http.Request) {
    validToken, err := GenerateJWT()
    if err != nil {
        fmt.Println("Failed to generate token")
    }

    client := &http.Client{}
    req, _ := http.NewRequest("GET", "http://localhost:9000/", nil)
    req.Header.Set("Token", validToken)
    res, err := client.Do(req)
    if err != nil {
        fmt.Fprintf(w, "Error: %s", err.Error())
    }

    body, err := ioutil.ReadAll(res.Body)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Fprintf(w, string(body))
}

func GenerateJWT() (string, error) {
    token := jwt.New(jwt.SigningMethodHS256)

    claims := token.Claims.(jwt.MapClaims)

    claims["authorized"] = true
    claims["client"] = "Elliot Forbes"
    claims["exp"] = time.Now().Add(time.Minute * 30).Unix()

    tokenString, err := token.SignedString(mySigningKey)

    if err != nil {
        fmt.Errorf("Something Went Wrong: %s", err.Error())
        return "", err
    }

    return tokenString, nil
}

func handleRequests() {
    http.HandleFunc("/", homePage)

    log.Fatal(http.ListenAndServe(":9001", nil))
}

func main() {
    handleRequests()
}

让我们分解上面代码中发生的事情。 同样，我们定义了一个非常简单的 API，它具有单个端点。 该端点在触发时会使用我们的安全 mySigningKey 生成一个新的 JWT，然后它会创建一个新的 http 客户端并将 Token 标头设置为我们刚刚生成的 JWT 字符串。

然后它会尝试使用这个签名的 JWT 令牌访问我们在 http://localhost:9000 上运行的服务器应用程序。 然后，我们的服务器验证我们在客户端生成的令牌，并继续为我们提供超级机密的 Hello World 消息。

结论

希望本教程有助于揭开使用 JSON Web 令牌保护 Go 应用程序和 REST API 的神秘面纱。 写这篇文章很有趣，我希望它对你的 Go 开发之旅有所帮助。

如果您喜欢本教程，请在下面的评论部分告诉我，或者在社交媒体上分享这篇文章，它真的对我和我的网站有帮助！