base64Captcha Documentation

To use etcd as a distributed store for captcha answers, you can wrap the base64Captcha.DriverString in a custom struct. This allows you to persist captcha answers in etcd with a TTL (Time To Live), ensuring that answers expire automatically after a set duration.

Implementation Steps:

1. Define a custom struct: Embed *base64Captcha.DriverString and include your etcd client.
2. Constructor: Use base64Captcha.NewDriverString to initialize the base driver, then wrap it in your custom struct.
3. Generate with Persistence: In your generation method, call GenerateIdQuestionAnswer() to get the ID and answer, then use etcd.Grant to create a lease and etcd.Put to store the answer associated with the captcha ID.
4. Verify against Etcd: In your verification method, retrieve the value from etcd using the captcha ID and compare it with the user's provided answer.

// CaptchaEtcd base64 captcha with etcd
type CaptchaEtcd struct {
	*base64Captcha.DriverString
	store *etcd.Client
}

// NewClientEtcd constructor
func NewClientEtcd(height, width int, store *etcd.Client) *CaptchaEtcd {
	d := base64Captcha.NewDriverString(height, width, 0, 0, 4, "%#=qwe23456789rtyupasdfghjkzxcvbnm", &color.RGBA{0, 0, 0, 0}, []string{"wqy-microhei.ttc"})
	cli := &CaptchaEtcd{store: store}
	cli.DriverString = d
	return cli
}

// GenerateIdAndImage creates image and stores answer in etcd
func (c *CaptchaEtcd) GenerateIdAndImage() (id, b64s, ans string, err error) {
	id, content, answer := c.GenerateIdQuestionAnswer()
	item, err := c.DrawCaptcha(content)
	if err != nil {
		return "", "", "", err
	}
	// expire in 120s
	grantResp, err := c.store.Grant(context.TODO(), 120)
	if err != nil {
		return "", "", "", err
	}
	ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
	_, err = c.store.Put(ctx, captchaPrefix+id, answer, clientv3.WithLease(grantResp.ID))
	cancel()
	if err != nil {
		return "", "", "", err
	}
	b64s = item.EncodeB64string()
	return id, b64s, answer, nil
}

// Verify checks captcha answer against etcd
func (c *CaptchaEtcd) Verify(id, answer string) (match bool, err error) {
	ctx, cancel := context.WithTimeout(context.Background(), requestTimeout)
	key := captchaPrefix + id
	resp, err := c.store.Get(ctx, key)
	cancel()
	if err != nil {
		return false, err
	}

	for _, ev := range resp.Kvs {
		if string(ev.Value) == answer {
			return true, nil
		}
	}
	return false, nil
}

This example demonstrates how to integrate base64Captcha into a net/http server. It includes endpoints to generate different types of captchas (audio, string, math, chinese, digit) and an endpoint to verify the user's answer.

Note that for drivers like DriverString, DriverMath, and DriverChinese, you should call .ConvertFonts() to prepare the driver for use.

package main

import (
	"encoding/json"
	"fmt"
	"github.com/mojocn/base64Captcha"
	"log"
	"net/http"
)

//configJsonBody json request body.
type configJsonBody struct {
	Id            string
	CaptchaType   string
	VerifyValue   string
	DriverAudio   *base64Captcha.DriverAudio
	DriverString  *base64Captcha.DriverString
	DriverChinese *base64Captcha.DriverChinese
	DriverMath    *base64Captcha.DriverMath
	DriverDigit   *base64Captcha.DriverDigit
}

var store = base64Captcha.DefaultMemStore

//base64Captcha create http handler
func generateCaptchaHandler(w http.ResponseWriter, r *http.Request) {
	//parse request parameters
	decoder := json.NewDecoder(r.Body)
	var param configJsonBody
	err := decoder.Decode(&param)
	if err != nil {
		log.Println(err)
	}
	defer r.Body.Close()
	var driver base64Captcha.Driver

	//create base64 encoding captcha
	switch param.CaptchaType {
	case "audio":
		driver = param.DriverAudio
	case "string":
		driver = param.DriverString.ConvertFonts()
	case "math":
		driver = param.DriverMath.ConvertFonts()
	case "chinese":
		driver = param.DriverChinese.ConvertFonts()
	default:
		driver = param.DriverDigit
	}
	c := base64Captcha.NewCaptcha(driver, store)
	id, b64s, err := c.Generate()
	body := map[string]interface{}{"code": 1, "data": b64s, "captchaId": id, "msg": "success"}
	if err != nil {
		body = map[string]interface{}{"code": 0, "msg": err.Error()}
	}
	w.Header().Set("Content-Type", "application/json; charset=utf-8")
	json.NewEncoder(w).Encode(body)
}

//base64Captcha verify http handler
func captchaVerifyHandle(w http.ResponseWriter, r *http.Request) {

	//parse request json body
	decoder := json.NewDecoder(r.Body)
	var param configJsonBody
	err := decoder.Decode(&param)
	if err != nil {
		log.Println(err)
	}
	defer r.Body.Close()
	//verify the captcha
	body := map[string]interface{}{"code": 0, "msg": "failed"}
	if store.Verify(param.Id, param.VerifyValue, true) {
		body = map[string]interface{}{"code": 1, "msg": "ok"}
	}

	//set json response
	w.Header().Set("Content-Type", "application/json; charset=utf-8")

	json.NewEncoder(w).Encode(body)
}

//start a net/http server
func main() {
	//serve Vuejs+ElementUI+Axios Web Application
	http.Handle("/", http.FileServer(http.Dir("./static")))

	//api for create captcha
	http.HandleFunc("/api/getCaptcha", generateCaptchaHandler)

	//api for verify captcha
	http.HandleFunc("/api/verifyCaptcha", captchaVerifyHandle)

	fmt.Println("Server is at :8777")
	if err := http.ListenAndServe(":8777", nil); err != nil {
		log.Fatal(err)
	}
}

The Store interface is responsible for persisting captcha answers associated with a unique ID. You can use the built-in DefaultMemStore for in-memory storage or implement your own (e.g., using Etcd or Redis) to support distributed systems.

Required methods:

• Set(id string, value string): Sets the answer for a specific captcha ID.
• Get(id string, clear bool) string: Retrieves the answer. If clear is true, the entry should be deleted from the store.
• Verify(id, answer string, clear bool) bool: Directly verifies the answer and optionally clears it.

type Store interface {
	// Set sets the digits for the captcha id.
	Set(id string, value string)

	// 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
}