0
0

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

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

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

  1. type Store interface {
  2.     // Set sets the digits for the captcha id.
  3.     //验证码存入验证码池的方法，id为键，验证码为值
  4.     Set(id string, value string) error
  6.     // Get returns stored digits for the captcha id. Clear indicates
  7.     // whether the captcha must be deleted from the store.
  8.     //获取验证码的方法
  9.     Get(id string, clear bool) string
  11.     //Verify captcha's answer directly
  12.     //校验验证码的方法
  13.     Verify(id, answer string, clear bool) bool
  14. }

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

  2. //自定义一个验证码池
  3. //以redis作为验证码池
  5. var ctx = context.Background()
  7. const CAPTCHA = "captcha:"
  9. type RedisStore struct {
  10. }
  12. // Set sets the digits for the captcha id.
  13. func (r RedisStore) Set(id string, value string) error {
  14.     key := CAPTCHA + id
  15.     err := global.RedisDb.Set(ctx, key, value, time.Minute*2).Err()
  16.     if err != nil {
  17.         log.Println(err.Error())
  18.     }
  19.     return err
  20. }
  22. // Get returns stored digits for the captcha id. Clear indicates
  23. // whether the captcha must be deleted from the store.
  24. func (r RedisStore) Get(id string, clear bool) string {
  25.     key := CAPTCHA + id
  26.     val, err := global.RedisDb.Get(ctx, key).Result()
  27.     if err != nil {
  28.         fmt.Println(err)
  29.         return ""
  30.     }
  31.     if clear {
  32.         err := global.RedisDb.Del(ctx, key).Err()
  33.         if err != nil {
  34.             fmt.Println(err)
  35.             return ""
  36.         }
  37.     }
  38.     return val
  39. }
  41. // Verify captcha's answer directly
  42. func (r RedisStore) Verify(id, answer string, clear bool) bool {
  43.     v := RedisStore{}.Get(id, clear)
  44.     //fmt.Println("key:"+id+";value:"+v+";answer:"+answer)
  45.     return v == answer
  46. }

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

  1. package utils
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "github.com/jordan-wright/email"
  7.     "github.com/mojocn/base64Captcha"
  8.     "net/smtp"
  9. )
  11. // 发送邮箱验证码
  12. func SendEmailValidate(em []string, myType int) (string, error) {
  13.     e := email.NewEmail()
  14.     e.From = fmt.Sprintf("发件人邮箱")
  15.     e.To = em
  16.     // 生成6位随机验证码
  17.     driver := base64Captcha.NewDriverDigit(80, 240, 5, 0.7, 80)
  19.     //这里在生成验证码对象时，就使用了redis作为验证码池
  20.     cp := base64Captcha.NewCaptcha(driver, cache.RedisStore{})
  22.     id, _, anwser, err := cp.Generate()
  23.     fmt.Println("id", id)
  24.     fmt.Println("anwser", anwser)
  25.     if err != nil {
  26.         fmt.Println("err")
  27.         return "", err
  28.     }
  29.     ems := em[0]
  31.     //为id添加验证码类型，1为注册，2为登录
  32.     if myType == 1 {
  33.         id = fmt.Sprintf("%s&amp%s", id, "emailtoregister")
  34.     } else if myType == 2 {
  35.         id = fmt.Sprintf("%s&amp%s", id, "emailtologin")
  36.     } else {
  37.         id = fmt.Sprintf("%s&amp%s", id, "emailtoforgetpassword")
  38.     }
  39.     cmd := global.RedisDb.Set(context.Background(), ems, id, 2*time.Minute)
  40.     if cmd.Err() != nil {
  41.         log.Fatal(cmd.Err())
  42.         return "", cmd.Err()
  43.     }
  44.     //设置文件发送的内容
  45.     content := fmt.Sprintf(`
  46.     <div>
  47.         <div>
  48.             您好！
  49.         </div>
  50.         <div style="padding: 8px 40px 8px 50px;">
  51.             <p>您提交的邮箱验证，本次验证码为<u><strong>%s</strong></u>，为了保证账号安全，验证码有效期为5分钟。请确认为本人操作，切勿向他人泄露，感谢您的理解与使用。</p>
  52.         </div>
  53.         <div>
  54.             <p>此邮箱为系统邮箱，请勿回复。</p>
  55.         </div>
  56.     </div>
  57.     `, anwser)
  58.     e.Text = []byte(content)
  59.     //设置服务器相关的配置
  60.     err = e.Send("smtp.qq.com:25", smtp.PlainAuth("", "发件人邮箱", "发件人的密钥", "smtp.qq.com"))
  61.     fmt.Println("to", e.To)
  62.     return anwser, err
  63. }

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

  1. // 发送注册验证码
  2. func GetValidateCode(c *gin.Context) {
  3.     // 获取目的邮箱
  4.     ems := c.Param("email")
  5.     temp := strings.Split(ems, "@")
  6.     if len(temp) < 2 {
  7.         c.JSON(http.StatusBadRequest, gin.H{
  8.             "msg":  "请输入正确邮箱",
  9.             "code": 400,
  10.             "data": nil,
  11.         })
  12.         return
  13.     }
  14.     em := []string{ems}
  16.     fmt.Println(ems)
  17.     fmt.Println(em)
  19.     //发送验证码，并将验证码id和email存入redis
  20.     _, err := utils.SendEmailValidate(em, 1)
  21.     if err != nil {
  22.         log.Println(err)
  23.         c.JSON(http.StatusBadRequest, gin.H{
  24.             "status":           400,
  25.             "msg":              "验证码发送失败",
  26.             "ERROR-CONTROLLER": err.Error(),
  27.         })
  28.         return
  29.     }
  31.     c.JSON(http.StatusOK, gin.H{
  32.         "msg":    "验证码发送成功",
  33.         "status": 200,
  34.     })
  35.     return
  36. }

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

  1. 1.假定，现在恶意攻击者准备用别人的邮箱以爆破的方式登入别人的账号时，如果我们只是简单的对验证码做存储和校验会遇到什么问题呢？
  3.         1）验证码池冗余：可以预见的一个问题是，如果攻击者不断向我们的后端发起请求验证码的请求，即便我们设置了过期时间，但是在大量请求的情况下验证码池还是会冗余大量的验证码。而在我们底层，只有base64Captcha自动生成的id和验证码做绑定。即便id的生成是随机的，但这也无疑增加了爆破成功的概率。
  5.               为了解决这个问题，我们可以在id为键，存贮验证码的基础上再加一层，即邮箱为键，绑定id。这样一来，无论请求方如何请求我们的验证码，因为邮箱是不变的，且对于id来说是唯一的的，所以每次请求都会把上一次存储的id覆盖，也就意味着上一次请求的验证码是无效的。
  7.         2）验证码越权：第二个问题，在上述问题中，我们使用了邮箱和id进行绑定。但是依旧存在问题，假设现在，一个用户在邮箱注册处获得了一个验证码，结果他用这个验证码去进行登录。这在业务上极其不合理，但是按照底层逻辑来说这是能实现的。因为邮箱是不变的，无论登录和注册，我获取验证码都是通过这一个邮箱号。
  9.                 为了解决这个问题，我选择的方法是：在原生的id后拼接标识符，以达到标识这个验证码对应的是哪一个接口的目的。也即id + 分隔符 + 标识符。这样一来，我只要通过分隔符切分，取到数组的最后一个，再在对应路由中，判断这个验证码是否为对应功能即可。具体验证方法如下：
  1. // ValidateEmailCode
  2. // @Title ValidateEmailCode
  3. // @Description  验证邮箱验证码，并注册用户。
  4. // @Author hyy 2022-03-05 18:19:18
  5. // @Param c type description
  6. func ValidateEmailCode(c *gin.Context) {
  8.     //检验邮箱是否合法
  9.     var user forms.CreateUserByEmail
  11.     err := c.ShouldBindJSON(&user)
  12.     fmt.Println(user)
  13.     if err != nil {
  14.         log.Println(err.Error())
  15.         c.JSON(http.StatusBadRequest, gin.H{
  16.             "status":           400,
  17.             "msg":              "注册失败，json解析失败",
  18.             "ERROR-CONTROLLER": err.Error(),
  19.         })
  20.         return
  21.     }
  22.     myEmail := user.Email
  23.     // 默认用户权限为2
  24.     if user.RoleId == 0 {
  25.         user.RoleId = 3
  26.     }
  28.     // 通过邮箱获取在redis中绑定的id
  29.     id, err := global.RedisDb.Get(context.Background(), myEmail).Result()
  31.     //分隔符切分
  32.     myResp := strings.Split(id, "&amp")
  34.     if len(myResp) < 2 {
  35.         c.JSON(http.StatusInternalServerError, gin.H{
  36.             "msg":  "验证码失效",
  37.             "code": 500,
  38.             "data": nil,
  39.         })
  40.         return
  41.     }
  43.     //判断接口是否对应
  44.     if myResp[1] != "emailtoregister" {
  45.         c.JSON(http.StatusBadRequest, gin.H{
  46.             "msg":  "验证码失效",
  47.             "data": nil,
  48.             "code": 400,
  49.         })
  50.         return
  51.     }
  53.     id = myResp[0]
  54.     if err != nil {
  55.         log.Println(err.Error())
  56.         c.JSON(http.StatusBadRequest, gin.H{
  57.             "status":           400,
  58.             "msg":              "Redis获取vCode失败",
  59.             "ERROR-CONTROLLER": err.Error(),
  60.         })
  61.         return
  62.     }
标签： 安全
本文转载自: https://blog.csdn.net/qq_62906402/article/details/139880144
版权归原作者 桐生战兔868 所有， 如有侵权，请联系我们删除。
登录后发布评论

“golang gin base64Captcha生成验证码后通过redis存储 以及安全验证思路”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航
没有找到文章内容分段。。。