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 需要什么！

一个简单的 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()
}

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

智威汤逊认证

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

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

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

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

我们的服务器

所以，让我们看看它的实际效果，让我们创建一个非常简单的服务器：

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标头，然后我们随后根据我们的 private 检查令牌是否有效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，它具有单个端点。此端点在触发时使用我们的 secure 生成一个新的 JWT mySigningKey，然后它创建一个新的 http 客户端并将Token标头设置为等于我们刚刚生成的 JWT 字符串。

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

结论

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

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

延伸阅读

如果您想阅读更多关于 JSON Web Tokens 及其使用方式的信息，那么我可以彻底推荐以下文章：

• RFC-7519 - https://tools.ietf.org/html/rfc7519
• JWT 介绍- https://jwt.io/introduction/