1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

// 这里我自己实现了一个基于Redis的Store存储驱动类

var store = captcha.NewRedisStore(db.GetRedisConn())

func GenCaptcha() (string, string) {

    // 设置验证码驱动类型，这里是数字运算类型的验证码

    // 例如会生成几个数的基本运算， 最后求运算结果作为验证码结果

    driver := base64Captcha.DriverMath{         

        Height:     50,

        Width:      200,

        NoiseCount: 0,

    }

    captchaObj := base64Captcha.NewCaptcha(&driver, store)

    captchaId, b64s, _, err := captchaObj.Generate()

    if err != nil {

        panic(err.Error())

    }

    return captchaId, b64s // 拿到验证码ID、验证码的base64字符串

}

1

2

3

func VerifyCaptcha(captchaId string, answer string) bool {

    return store.Verify(captchaId, answer, true)

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

package captcha

import (

    "context"

    "github.com/redis/go-redis/v9"

    "sync"

    "time"

)

const captchaKey = "string:captcha:"

var ctx = context.Background()

type RedisStore struct {

    redisClient *redis.Client

    mtx         sync.Mutex

}

func (r *RedisStore) Set(id string, value string) error {

    r.mtx.Lock()

    defer r.mtx.Unlock()

    key := captchaKey + id

    result := r.redisClient.SetNX(ctx, key, value, time.Second*60)

    if result.Err() != nil {

        return result.Err()

    }

    return nil

}

func (r *RedisStore) Get(id string, clear bool) string {

    r.mtx.Lock()

    defer r.mtx.Unlock()

    key := captchaKey + id

    result := r.redisClient.Get(ctx, key)

    if result.Err() != nil {

        return ""

    }

    if clear {

        go r.redisClient.Del(ctx, key)

    }

    return result.Val()

}

func (r *RedisStore) Verify(id, answer string, clear bool) bool {

    r.mtx.Lock()

    defer r.mtx.Unlock()

    key := captchaKey + id

    result := r.redisClient.Get(ctx, key)

    if result.Err() != nil {

        return false

    }

    storeAnswer := result.Val()

    if clear {

        go r.redisClient.Del(ctx, key)

    }

    return answer == storeAnswer

}

func NewRedisStore(redisClient *redis.Client) *RedisStore {

    return &RedisStore{

        redisClient: redisClient,

        mtx:         sync.Mutex{},

    }

}