「Go工具箱」go语言csrf库的使用方式和实现原理
source link: https://studygolang.com/articles/35927
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.
❝上帝只垂青主动的人 --- 吴军 《格局》
❞
大家好，我是渔夫子。本号新推出「Go工具箱」系列，意在给大家分享使用go语言编写的、实用的、好玩的工具。
今天给大家推荐的是web应用安全防护方面的一个包：csrf。该包为Go web应用中常见的跨站请求伪造（CSRF）攻击提供预防功能。
csrf小档案
| 「csrf小档案」 | |||
|---|---|---|---|
| star | 837 | used by | - |
| contributors | 25 | 作者 | Gorilla |
| 功能简介 | 为Go web应用程序和服务提供跨站点请求伪造（csrf）预防功能。可作为gin、echo等主流框架的中间件使用。 | ||
| 项目地址 | https://github.com/gorilla/csrf | ||
| 相关知识 | 跨站请求伪造（CSRF）、contex.Contex、异或操作 |
第一部分 CSRF相关知识
一、CSRF及其实现原理
CSRF是CROSS Site Request Forgy的缩写，即跨站请求伪造。我们看下他的攻击原理。如下图：
当用户访问一个网站的时候，第一次登录完成后，网站会将验证的相关信息保存在浏览器的cookie中。在对该网站的后续访问中，浏览器会自动携带该站点下的cookie信息，以便服务器校验认证信息。
因此，当服务器经过用户认证之后，服务器对后续的请求就只认cookie中的认证信息，不再区分请求的来源了。那么，攻击者就可以模拟一个正常的请求来做一些影响正常用户利益的事情（比如对于银行来说可以把用户的钱转账到攻击者账户中。或获取用户的敏感、重要的信息等）
❝相关知识：因为登录信息是基于session-cookie的。浏览器在访问网站时会自动发送该网站的cookie信息，网站只要能识别cookie中的信息，就会认为是认证已通过，而不会区分该请求的来源的。所以给攻击者创造了攻击的机会。
❞
CSRF攻击示例
假设有一个银行网站A，下面的是一个转给账户5000元的请求，使用Get方法
GET https://abank.com/transfer.do?account=RandPerson&amount=$5000 HTTP/1.1
然后，攻击者修改了该请求中的参数，将收款账户更改成了自己的，如下：
GET https://abank.com/transfer.do?account=SomeAttacker&amount=$5000 HTTP/1.1
然后，攻击者将该请求地址放入到一个标签中：
<a href="https://abank.com/transfer.do?account=SomeAttacker&amount=$5000">Click for more information</a>
当然，如果是post表单形式，那么攻击者会将伪造的链接放到form表达中，并用js的方法让表单自动发送：
<body onload="document.forms[0].submit()>
<form id=”csrf” action="https://abank.com/transfer.do" method="POST">
<input type="hidden" name="account" value="SomeAttacker"/>
<input type="hidden" name="amount" value="$5000"/>
</form>
</body>
<script>
document.getElementById('csrf').submit();
</script>
二、如何预防
一种是在网站中增加对请求来源的验证，比如在请求头中增加REFFER信息。一种是在浏览器中启用SameSite策略。该策略是告诉浏览器，只有请求来源是同网站的才能发送cookie，跨站的请求不要发送cookie。但这种也有漏洞，就是依赖于浏览器是否支持这种策略。一种是使用Token信息。由网站自己决定token的生成策略以及对token的验证。其中使用Token信息这种是三种方法中最安全的一种。接下来我们就看看今天要推荐的CSRF包是如何利用token进行预防的。
第二部分 CSRF包的使用及其实现原理
三、CSRF包的使用及实现原理
csrf包的安装
go get github.com/gorilla/csrf
该包的使用很简单。首先通过csrf.Protect函数生成一个中间件或请求处理器，然后在启动web server时对真实的请求处理器进行包装。
使用net/http包启动的服务
package main
import (
"fmt"
"github.com/gorilla/csrf"
"net/http"
)
func main() {
muxServer := http.NewServeMux()
muxServer.HandleFunc("/", IndexHandler)
CSRF := csrf.Protect([]byte("32-byte-long-auth-key"))
http.ListenAndServe(":8000", CSRF(muxServer))
}
func IndexHandler(w http.ResponseWriter, r http.Request) {
// 获取token值
token := csrf.Token(r)
// 将token写入到header中
w.Header().Set("X-CSRF-Token", token)
fmt.Fprintln(w, "hello world.Go")
}
echo框架下使用csrf包
package main
import (
"github.com/gorilla/csrf"
"net/http"
"github.com/labstack/echo"
)
func main() {
e := echo.New()
e.POST("/", func(c echo.Context) error {
return c.String(http.StatusOK, "Hello, World!")
})
// 使用自定义的CSRF中间件
e.Use(CSRFMiddle())
e.Logger.Fatal(e.Start(":8080"))
}
// 自定义CSRF中间件
func CSRFMiddle() echo.MiddlewareFunc {
csrfMiddleware := csrf.Protect([]byte("32-byte-long-auth-key"))
// 这里使用echo的WrapMiddleware函数将csrfMiddleware转换成echo的中间件返回值
return echo.WrapMiddleware(csrfMiddleware)
}
gin框架下使用csrf包
import (
"fmt"
"github.com/gin-gonic/gin"
"github.com/gorilla/csrf"
adapter "github.com/gwatts/gin-adapter"
)
// 定义中间件
func CSRFMiddle() gin.HandlerFunc {
csrfMiddleware := csrf.Protect([]byte("32-byte-long-auth-key"))
// 这里使用adpater包将csrfMiddleware转换成gin的中间件返回值
return adapter.Wrap(csrfMiddleware)
}
func main() {
r := gin.New()
// 在路由中使用中间件
r.Use(CSRFMiddle())
// 定义路由
r.POST("/", IndexHandler)
// 启动http服务
r.Run(":8080")
}
func IndexHandler(ctxgin.Context) {
ctx.String(200, "hello world")
}
beego框架下使用csrf包
package main
import (
"github.com/beego/beego"
"github.com/gorilla/csrf"
)
func main() {
beego.Router("/", &MainController{})
beego.RunWithMiddleWares(":8080", CSRFMiddle())
}
type MainController struct {
beego.Controller
}
func (this MainController) Get() {
this.Ctx.Output.Body([]byte("Hello World"))
}
func CSRFMiddle() beego.MiddleWare {
csrfMiddleware := csrf.Protect([]byte("32-byte-long-auth-key"))
// 这里使用adpater包将csrfMiddleware转换成gin的中间件返回值
return csrfMiddleware
}
实际上，要通过token预防CSRF主要做以下3件事情：每次生成一个唯一的token、将token写入到cookie同时下发给客户端、校验token。接下来我们就来看看csrf包是如何实现如上步骤的。
csrf结构体
type csrf struct {
h http.Handler
scsecurecookie.SecureCookie
st store
opts options
}
func (cs csrf) ServeHTTP(w http.ResponseWriter, r http.Request)
在Go中，我们知道ServeHTTP是在内建包net/http中定义的一个请求处理器的接口：
type Handler interface {
ServeHTTP(ResponseWriter, Request)
}
凡是实现了该接口的结构体就能作为请求的处理器。在go的所有web框架中，处理器本质上也都是基于该接口实现的。
「h」：是一个http.Handler,作为实际处理请求的处理器。该h的来源是经Protect函数返回值包装后的，即开始示例中CSRF(muxServer)中的muxServer。又因为csrf也是一个请求处理器，请求就会先执行csrf的ServeHTTP方法的逻辑，如果通过了，再执行h的ServeHTTP逻辑。「sc」：类型是securecookie.SecureCookie，第三方包，该包的作用是对cookie的值进行加密/解密。在调用csrf.Protect方法时，传递的第一个32字节长的参数就是用于该包进行对称加密用的秘钥。下一篇文章我们会详细介绍该包是如何实现对cookie内容进行/加解密的。「st」：类型是store，是csrf包中定义的一个接口类型。该属性的作用是将token存储在什么地方。默认是使用cookieStore类型。即将token存储在cookie中。「opts」：Options属性，用于设置csrf的选项的。比如token存储在cookie中的名字，token在表单中的名字等。csrf包的工作流程
在使用csrf的时候，首先要调用的就是Protect函数。Protect的定义如下：
func Protect(authKey []byte, opts ...Option) func(http.Handler) http.Handler
该函数接收一个秘钥和一个选项切片参数。返回值是一个函数类型：func(http.Handler) http.Handler。实际的执行逻辑是在返回的函数中。如下：
CSRF := csrf.Protect([]byte("32-byte-long-auth-key"))
http.ListenAndServe(":8000", CSRF(muxServer))
// Protect源码
func Protect(authKey []byte, opts ...Option) func(http.Handler) http.Handler {
return func(h http.Handler) http.Handler {
cs := parseOptions(h, opts...)
// Set the defaults if no options have been specified
if cs.opts.ErrorHandler == nil {
cs.opts.ErrorHandler = http.HandlerFunc(unauthorizedHandler)
}
if cs.opts.MaxAge < 0 {
// Default of 12 hours
cs.opts.MaxAge = defaultAge
}
if cs.opts.FieldName == "" {
cs.opts.FieldName = fieldName
}
if cs.opts.CookieName == "" {
cs.opts.CookieName = cookieName
}
if cs.opts.RequestHeader == "" {
cs.opts.RequestHeader = headerName
}
// Create an authenticated securecookie instance.
if cs.sc == nil {
cs.sc = securecookie.New(authKey, nil)
// Use JSON serialization (faster than one-off gob encoding)
cs.sc.SetSerializer(securecookie.JSONEncoder{})
// Set the MaxAge of the underlying securecookie.
cs.sc.MaxAge(cs.opts.MaxAge)
}
if cs.st == nil {
// Default to the cookieStore
cs.st = &cookieStore{
name: cs.opts.CookieName,
maxAge: cs.opts.MaxAge,
secure: cs.opts.Secure,
httpOnly: cs.opts.HttpOnly,
sameSite: cs.opts.SameSite,
path: cs.opts.Path,
domain: cs.opts.Domain,
sc: cs.sc,
}
}
return cs
}
}
当一个请求来了之后，先执行csrf结构体中的ServeHTTP方法，然后再执行实际的http.Handler。以最开始的请求为例，csrf包的工作流程如下：
大致了解了csrf的工作流程后，我们再来分析各个环节的实现。
「生成唯一的token」在该包中生成随机、唯一的token是通过随机数来生成的。主要生成逻辑如下：
func generateRandomBytes(n int) ([]byte, error) {
b := make([]byte, n)
_, err := rand.Read(b)
// err == nil only if len(b) == n
if err != nil {
return nil, err
}
return b, nil
}
realToken := generateRandomBytes(32)
//编码后，encodeToken是base64编码的字符串
encodeToken := json.Encode(realToken)
_gorilla_csrf。同时，通过cookieStore类型存储到cookie的值是经过加密的，加密使用的是securecookie.SecureCookie包一个是存储在请求的上下文中。存在这里的token是原始token经过转码的，会随着响应下发给客户端，以便下次请求时随请求体一起发送。该实现是通过context.ValueContext存储在请求的上下文中。
func mask(realToken []byte, r *http.Request) string {
otp, err := generateRandomBytes(tokenLength)
if err != nil {
return ""
}
// XOR the OTP with the real token to generate a masked token. Append the
// OTP to the front of the masked token to allow unmasking in the subsequent
// request.
return base64.StdEncoding.EncodeToString(append(otp, xorToken(otp, realToken)...))
}
这里我们看到，先生成一个和token一样长度的随机值otp，然后让实际的realToken和opt通过xorToken进行异或操作，将异或操作的结果放到随机值的末尾，然后再进行base64编码产生的。
「输出token」
这里利用了异或操作的原理来进行转码和解码。我们假设在上述我们已经知道经过异或操作对原始token进行了转码，我们叫做maskToken。该token要下发给客户端（HEADER、form或其他位置）。那么，客户端用什么字段来接收呢？
若在HEADER头中，则保存在名为 X-CSRF-Token 的字段中。若在form表单，则保存在名为 gorilla.csrf.Token 的input中。当然，我们在初始化csrf的实例时，可以指定保存的位置。例如，我们指定HEADER头中的字段名为 X-CSRF-Token-Request中，则可以使用如下代码：
csrf.Protect([]byte("32-byte-long-auth-key"),
RequestHeader("X-CSRF-Token-Request"))
RequestHeader选项函数：指定在HEADER中存储token的字段名称。
FieldName选项函数：指定form表中存储token的input的name
HttpOnly选项函数：指定cookie的值只能在服务端设置，禁止在客户端使用javascript修改
SameSite选项函数：指定cookie的SameSite属性
ErrorHandler选项函数：指定当token校验不通过或生成token失败时的错误响应的handler
为什么GET、HEAD、OPTIONS、TRACE的请求方法不需要token验证
// Idempotent (safe) methods as defined by RFC7231 section 4.2.2.
safeMethods = []string{"GET", "HEAD", "OPTIONS", "TRACE"}
if !contains(safeMethods, r.Method) {
//这里进行token的校验
}
所以，如果严格按照RFC的规定来开发的话，这些请求不应该修改数据，而只是获取数据。获取数据对于攻击者来说也没实际价值。
---特别推荐---
Recommend
About Joyk
Aggregate valuable and interesting links.
Joyk means Joy of geeK