golang gin base64Captcha生成验证码后通过redis存储 以及安全验证思路

  在学习过程中，我遇到了一个场景：用户使用邮箱进行登录注册，此时需要向对应邮箱发送验证码。之后用户输入验证码后，我们需要对验证码进行校验。这里我选择使用第三方包base64Captcha生成验证码，并且使用redis作为验证码池进行存储，代码如下：

  1.创建一个redis验证码池，确保你已经配置了redis环境，这里必须实现以下base64Captcha中的Store接口

type Store interface {
	// Set sets the digits for the captcha id.
    //验证码存入验证码池的方法，id为键，验证码为值
	Set(id string, value string) error

	// Get returns stored digits for the captcha id. Clear indicates
	// whether the captcha must be deleted from the store.
    //获取验证码的方法
	Get(id string, clear bool) string

	//Verify captcha's answer directly
    //校验验证码的方法
	Verify(id, answer string, clear bool) bool
}

  对这个接口的实现方法如下

//自定义一个验证码池
//以redis作为验证码池

var ctx = context.Background()

const CAPTCHA = "captcha:"

type RedisStore struct {
}

// Set sets the digits for the captcha id.
func (r RedisStore) Set(id string, value string) error {
	key := CAPTCHA + id
	err := global.RedisDb.Set(ctx, key, value, time.Minute*2).Err()
	if err != nil {
		log.Println(err.Error())
	}
	return err
}

// Get returns stored digits for the captcha id. Clear indicates
// whether the captcha must be deleted from the store.
func (r RedisStore) Get(id string, clear bool) string {
	key := CAPTCHA + id
	val, err := global.RedisDb.Get(ctx, key).Result()
	if err != nil {
		fmt.Println(err)
		return ""
	}
	if clear {
		err := global.RedisDb.Del(ctx, key).Err()
		if err != nil {
			fmt.Println(err)
			return ""
		}
	}
	return val
}

// Verify captcha's answer directly
func (r RedisStore) Verify(id, answer string, clear bool) bool {
	v := RedisStore{}.Get(id, clear)
	//fmt.Println("key:"+id+";value:"+v+";answer:"+answer)
	return v == answer
}

  2.创建一个用于发送验证码到邮箱的utils工具（具体的邮箱配置忽略）

package utils

import (
	"context"
	"fmt"
	"github.com/jordan-wright/email"
	"github.com/mojocn/base64Captcha"
	"net/smtp"
)

// 发送邮箱验证码
func SendEmailValidate(em []string, myType int) (string, error) {
	e := email.NewEmail()
	e.From = fmt.Sprintf("发件人邮箱")
	e.To = em
	// 生成6位随机验证码
	driver := base64Captcha.NewDriverDigit(80, 240, 5, 0.7, 80)

    //这里在生成验证码对象时，就使用了redis作为验证码池
	cp := base64Captcha.NewCaptcha(driver, cache.RedisStore{})

	id, _, anwser, err := cp.Generate()
	fmt.Println("id", id)
	fmt.Println("anwser", anwser)
	if err != nil {
		fmt.Println("err")
		return "", err
	}
	ems := em[0]

	//为id添加验证码类型，1为注册，2为登录
	if myType == 1 {
		id = fmt.Sprintf("%s&amp%s", id, "emailtoregister")
	} else if myType == 2 {
		id = fmt.Sprintf("%s&amp%s", id, "emailtologin")
	} else {
		id = fmt.Sprintf("%s&amp%s", id, "emailtoforgetpassword")
	}
	cmd := global.RedisDb.Set(context.Background(), ems, id, 2*time.Minute)
	if cmd.Err() != nil {
		log.Fatal(cmd.Err())
		return "", cmd.Err()
	}
	//设置文件发送的内容
	content := fmt.Sprintf(`
	<div>
		<div>
			您好！
		</div>
		<div style="padding: 8px 40px 8px 50px;">
			<p>您提交的邮箱验证，本次验证码为<u><strong>%s</strong></u>，为了保证账号安全，验证码有效期为5分钟。请确认为本人操作，切勿向他人泄露，感谢您的理解与使用。</p>
		</div>
		<div>
			<p>此邮箱为系统邮箱，请勿回复。</p>
		</div>
	</div>
	`, anwser)
	e.Text = []byte(content)
	//设置服务器相关的配置
	err = e.Send("smtp.qq.com:25", smtp.PlainAuth("", "发件人邮箱", "发件人的密钥", "smtp.qq.com"))
	fmt.Println("to", e.To)
	return anwser, err
}

  3.gin框架发送验证码的路由

// 发送注册验证码
func GetValidateCode(c *gin.Context) {
	// 获取目的邮箱
	ems := c.Param("email")
	temp := strings.Split(ems, "@")
	if len(temp) < 2 {
		c.JSON(http.StatusBadRequest, gin.H{
			"msg":  "请输入正确邮箱",
			"code": 400,
			"data": nil,
		})
		return
	}
	em := []string{ems}

	fmt.Println(ems)
	fmt.Println(em)

	//发送验证码，并将验证码id和email存入redis
	_, err := utils.SendEmailValidate(em, 1)
	if err != nil {
		log.Println(err)
		c.JSON(http.StatusBadRequest, gin.H{
			"status":           400,
			"msg":              "验证码发送失败",
			"ERROR-CONTROLLER": err.Error(),
		})
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"msg":    "验证码发送成功",
		"status": 200,
	})
	return
}

  代码部分到此结束，接下来我要讲解以下验证码的校验思路，来看两个问题：

    1.假定，现在恶意攻击者准备用别人的邮箱以爆破的方式登入别人的账号时，如果我们只是简单的对验证码做存储和校验会遇到什么问题呢？

            1）验证码池冗余：可以预见的一个问题是，如果攻击者不断向我们的后端发起请求验证码的请求，即便我们设置了过期时间，但是在大量请求的情况下验证码池还是会冗余大量的验证码。而在我们底层，只有base64Captcha自动生成的id和验证码做绑定。即便id的生成是随机的，但这也无疑增加了爆破成功的概率。

                  为了解决这个问题，我们可以在id为键，存贮验证码的基础上再加一层，即邮箱为键，绑定id。这样一来，无论请求方如何请求我们的验证码，因为邮箱是不变的，且对于id来说是唯一的的，所以每次请求都会把上一次存储的id覆盖，也就意味着上一次请求的验证码是无效的。

            2）验证码越权：第二个问题，在上述问题中，我们使用了邮箱和id进行绑定。但是依旧存在问题，假设现在，一个用户在邮箱注册处获得了一个验证码，结果他用这个验证码去进行登录。这在业务上极其不合理，但是按照底层逻辑来说这是能实现的。因为邮箱是不变的，无论登录和注册，我获取验证码都是通过这一个邮箱号。

                    为了解决这个问题，我选择的方法是：在原生的id后拼接标识符，以达到标识这个验证码对应的是哪一个接口的目的。也即id + 分隔符 + 标识符。这样一来，我只要通过分隔符切分，取到数组的最后一个，再在对应路由中，判断这个验证码是否为对应功能即可。具体验证方法如下：

// ValidateEmailCode
// @Title ValidateEmailCode
// @Description  验证邮箱验证码，并注册用户。
// @Author hyy 2022-03-05 18:19:18
// @Param c type description
func ValidateEmailCode(c *gin.Context) {

	//检验邮箱是否合法
	var user forms.CreateUserByEmail

	err := c.ShouldBindJSON(&user)
	fmt.Println(user)
	if err != nil {
		log.Println(err.Error())
		c.JSON(http.StatusBadRequest, gin.H{
			"status":           400,
			"msg":              "注册失败，json解析失败",
			"ERROR-CONTROLLER": err.Error(),
		})
		return
	}
	myEmail := user.Email
	// 默认用户权限为2
	if user.RoleId == 0 {
		user.RoleId = 3
	}



	// 通过邮箱获取在redis中绑定的id
	id, err := global.RedisDb.Get(context.Background(), myEmail).Result()


    //分隔符切分
	myResp := strings.Split(id, "&amp")


	if len(myResp) < 2 {
		c.JSON(http.StatusInternalServerError, gin.H{
			"msg":  "验证码失效",
			"code": 500,
			"data": nil,
		})
		return
	}


    //判断接口是否对应
	if myResp[1] != "emailtoregister" {
		c.JSON(http.StatusBadRequest, gin.H{
			"msg":  "验证码失效",
			"data": nil,
			"code": 400,
		})
		return
	}



	id = myResp[0]
	if err != nil {
		log.Println(err.Error())
		c.JSON(http.StatusBadRequest, gin.H{
			"status":           400,
			"msg":              "Redis获取vCode失败",
			"ERROR-CONTROLLER": err.Error(),
		})
		return
	}