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

apaas.dev

5 November 2022

SEO Title

Securing Your Go REST APIs With JWTs

注意 - 本教程的完整源代码可以在这里找到：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 消息返回给客户端，否则将返回未授权。

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

架构图

architecture-diagram

我们的服务器

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

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 开发之旅有所帮助。

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

文章链接

https://pgmr.cloud/securing-your-go-rest-apis-jwts

引用

https://tools.ietf.org/html/rfc7519

https://jwt.io/introduction/

登录发表评论

Search