抖音支付回调验签 go 版本

序言

最近在做抖音小程序支付，由于抖音开放平台的文档写的较为简陋，让人踩了不少坑，在这里整理一下做小程序支付的整个过程，以通用交易系统为例子。

准备条件

1）申请小程序，开通支付功能

这里需要明确你小程序所在的行业，服务范围，这个会影响到后续生成预支付订单所需要的参数

开通支付功能，如果你还希望你的小程序在唤起抖音收银台时，能够选择微信或者支付宝支付，那就在额外开通这块，大概半天就能完成审核，开通完后的截图如下：

除此之外，在解决方案处，还需要将对应的能力开通上，截图如下，默认全都开，可参考这个文档用来检查：https://developer.open-douyin.com/docs/resource/zh-CN/mini-app/open-capacity/trade-system/guide/general/basicapi#9389672b

2）生成并上传密钥

在小程序控制台 【开发】->【开发配置】-> 【密钥管理】生成密钥，如果没有可以先借助工具先生成。

应用公钥和私钥的生成方式可参考：(或使用 在线RSA加密解密,RSA2加密解密(SHA256WithRSA)-BeJSON.com 在线生成)

$ openssl
OpenSSL> genrsa -out private_key.pem 2048
Generating RSA private key, 2048 bit long modulus
....................+++
...........................................................................+++
e is 65537 (0x10001)
OpenSSL> rsa -in private_key.pem -pubout -out public_key.pem
writing RSA key
OpenSSL> exit
$ ls
private_key.pem public_key.pem

上传密钥

3）了解工作流程

1. 小程序调用后端【订单接口】，生成一个订单数据
2. 小程序调用后端【抖音支付接口】，后端返回 data 和 byteAuthorization 两个参数，供前端想抖音发起下单操作使用（细节一会展开说）
3. 小程序拿到两个参数后，调用 tt.requestOrder 组件完成预下单的动作
4. 完成预下单后，小程序调用 tt.getOrderPayment 组件，拉起收银台，此时用户就能够看到支付页面
5. 用户完成支付或者取消支付，抖音就会调用事先配置的【回调接口】，后端验签，解析抖音回调的参数后，可根据结果，更新订单状态
6. 小程序轮询后端【查询订单支付接口】，刷新页面，告知用户。

流程也可以参考如下的时序图：

以上就是整体的流程，下面重点讲述与后端有关的   【抖音支付接口】和 【回调接口】     

抖音支付接口

这一个接口是生成 data 和 byteAuthorization 参数，返回给前端。

第一步：确认产品的商品类型和标签

我所做的是 虚拟产品的会员费用，所以我的 商品类型和标签如下：

// 商品类型
type = 301
// 标签
tag = "tag_group_7272625659888058380"

 其他的，可参考以下文档：

https://developer.open-douyin.com/docs/resource/zh-CN/mini-app/open-capacity/trade-system/guide/general/basicrules#6a1682c4

第二步：参数填写，这里只需要填以下参数即可，给出完整代码如下：

结合官方的文档，再理解代码：使用流程__抖音开放平台

type RequestOrderData struct {
	SkuList          []*SkuItem       `json:"skuList"`
	OutOrderNo       string           `json:"outOrderNo"`
	TotalAmount      int32            `json:"totalAmount"`
	PayExpireSeconds int32            `json:"payExpireSeconds"`
	OrderEntrySchema OrderEntrySchema `json:"orderEntrySchema"`
	PayNotifyUrl     string           `json:"payNotifyUrl"`
	LimitPayWayList  []int            `json:"limitPayWayList"`
}

type SkuItem struct {
	SkuId      string   `json:"skuId"`
	Price      int      `json:"price"`
	Quantity   int      `json:"quantity"`
	Title      string   `json:"title"`
	ImageList  []string `json:"imageList"`
	Type       int      `json:"type"`
	TagGroupId string   `json:"tagGroupId"`
}

type OrderEntrySchema struct {
	Path   string `json:"path"`
	Params string `json:"params"`
}


func DyPay () {
    // 构建参数
    payAmount := 100 // 单位是分
	requestData := &common.RequestOrderData{
		SkuList:          make([]*common.SkuItem, 0),
		OutOrderNo:       "业务系统订单号",
		TotalAmount:      int32(payAmount),
		PayExpireSeconds: 3600,
		PayNotifyUrl:     “”, // 后端的回调地址，不填会默认使用在抖音开放平台后台配置的域名
		OrderEntrySchema: common.OrderEntrySchema{
			Path:   "pages/pay/index", // 小程序页面地址，找前端提供
			Params: "",
		},
		LimitPayWayList: []int{}, // 如果需要屏蔽微信和支付宝支付渠道，就填入 1, 2
	}
	skuItem := &common.SkuItem{
		Title:      goodsModel.Name,
		Price:      int(payAmount.IntPart()),
		Quantity:   1,
		SkuId:      "商品id，业务系统自己补充",
		TagGroupId: "tag_group_7272625659888058380", // 固定
		ImageList: []string{
			"" // 商品图片，必填,
		},
		Type: 301, // 固定
	}
	requestData.SkuList = append(requestData.SkuList, skuItem)
    
    // 生成签名
    data, authorization := s.getByteAuthorizationAndData(requestData)
    // 打印 或其他操作，就不补充了
}

// 获取签名
func getByteAuthorizationAndData(data *RequestOrderData) (string, string) {
	// 请求时间戳
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	appId := "" // 获取小程序的 appid 
	// 随机字符串
	nonceStr := randStr(10)
	// 应用公钥版本,每次重新上传公钥后需要更新,可通过「开发管理-开发设置-密钥设置」处获取
	keyVersion := "1" // 对应后台的版本设置，
	// 应用私钥,用于加签 重要：1.测试时请修改为开发者自行生成的私钥;2.请勿将示例密钥用于生产环境;3.建议开发者不要将私钥文本写在代码中
	privateKeyStr := ""
	// 生成好的data json
	dataStr, _ := json.Marshal(data)
	authorization, _ := s.dyPayGetByteAuthorization(privateKeyStr, string(dataStr), appId, nonceStr, timestamp, keyVersion)

	return string(dataStr), authorization
}


// 向抖音发起获取签名接口
func dyPayGetByteAuthorization(privateKeyStr, data, appId, nonceStr, timestamp, keyVersion string) (string, error) {
	var byteAuthorization string
	// 读取私钥
	key, err := base64.StdEncoding.DecodeString(strings.ReplaceAll(privateKeyStr, "\n", ""))
	if err != nil {
		return "", err
	}
	privateKey, err := x509.ParsePKCS1PrivateKey(key)
	if err != nil {
		return "", err
	}
	// 生成签名
	signature, err := s.dyPayGetSignature("POST", "/requestOrder", timestamp, nonceStr, data, privateKey)
	if err != nil {
		return "", err
	}
	// 构造byteAuthorization
	byteAuthorization = fmt.Sprintf("SHA256-RSA2048 appid=%s,nonce_str=%s,timestamp=%s,key_version=%s,signature=%s", appId, nonceStr, timestamp, keyVersion, signature)
	return byteAuthorization, nil
}


// 拼签名
func dyPayGetSignature(method, url, timestamp, nonce, data string, privateKey *rsa.PrivateKey) (string, error) {
	fmt.Printf("method:%s\n url:%s\n timestamp:%s\n nonce:%s\n data:%s", method, url, timestamp, nonce, data)
	targetStr := method + "\n" + url + "\n" + timestamp + "\n" + nonce + "\n" + data + "\n"
	h := sha256.New()
	h.Write([]byte(targetStr))
	digestBytes := h.Sum(nil)

	signBytes, err := rsa.SignPKCS1v15(rand.Reader, privateKey, crypto.SHA256, digestBytes)
	if err != nil {
		return "", err
	}
	sign := base64.StdEncoding.EncodeToString(signBytes)

	return sign, nil
}

func randStr(length int) string {
	b := make([]byte, length)
	_, err := rand.Read(b)
	if err != nil {
		panic(err)
	}
	return base64.StdEncoding.EncodeToString(b)
}

在此小程序所需要的参数就已经生成好了，同时你也可以借助抖音签名验证工具（API调试台）进行验证。你也可以阅读抖音的官方文档，了解他们写的签名算法：

https://developer.open-douyin.com/docs/resource/zh-CN/mini-app/develop/server/signature-algorithm#%E7%AD%BE%E5%90%8D%E9%AA%8C%E8%AF%81

抖音支付回调

官方文档：功能概述__抖音开放平台

• 由于网络波动等原因，可能会产生重复的通知消息，接入方需要做好幂等，正确处理。​

• •​回调可能存在延时，若实时性要求高，开发者可以通过主动请求查询订单信息，确认支付结果。​

• •​支付回调一定要做验签处理，防止收到假通知，可参考下文验签示例代码。​

• •​在开发者服务端收到回调且处理成功后，需要按以下正常返回示例返回并且 HTTP 响应状态码设为 200，否则会认为通知失败进行重试。重试频率为 15s/30s/1m/2m/4m/8m/16m/32m/64m/128m - 总共4小时12m。​

• •​JS API 下单 有 payNotifyUrl 字段，如果在下单传了该字段，则会优先使用下单的 payNotifyUrl 回调地址，否则使用解决方案配置的回调地址。​

先看官方文档，核心就在验签，这里最容易出错的，其实就是 request body 的获取，一定是要直接原格式获取的，不要进行其他加工

type DYResultCallBack struct {
	Version string `json:"version"`
	Msg     string `json:"msg"`
	Type    string `json:"type"`
}

type DYResultCallBackData struct {
	AppId          string `json:"app_id"`
	OutOrderNo     string `json:"out_order_no"`
	OrderId        string `json:"order_id"`
	Status         string `json:"status"`
	TotalAmount    int    `json:"total_amount"`
	EventTime      int64  `json:"event_time"`
	DiscountAmount int64  `json:"discount_amount"`
	PayChannel     int    `json:"pay_channel"`
	UserBillPayId  string `json:"user_bill_pay_id"`
	Message        string `json:"message"`
	Extra          string `json:"extra"`
}

func (c *DyPayController) DyMiniPayNotify(ctx *gin.Context) {
	// 参数赋值
	request := &pay.DYResultCallBack{}
	if err := ctx.ShouldBindJSON(request); err != nil {
		c.Fail(ctx, errorcode.BASE_STRUCT_TRANS_FAILED, "无效的参数")
		return
	}
	callbackMsg := &pay.DYResultCallBackData{}
	err := json.Unmarshal([]byte(request.Msg), callbackMsg)
	if err != nil {
		c.Fail(ctx, errorcode.BASE_STRUCT_TRANS_FAILED, "解析消息体失败")
		return
	}
	// 验签代码
	verifyInfoRequest := &verifyInfo{}
	verifyInfoRequest.Nonce = ctx.Request.Header.Get("Byte-Nonce-Str")
	verifyInfoRequest.Signature = ctx.Request.Header.Get("Byte-Signature")
	verifyInfoRequest.Timestamp = ctx.Request.Header.Get("Byte-Timestamp")
	bodyStr, _ := json.Marshal(request)
	verifyInfoRequest.Body = fmt.Sprintf("%s", bodyStr)

	valid, err := c.verifySignature(verifyInfoRequest)
	if err != nil {
		c.Fail(ctx, errorcode.BASE_STRUCT_TRANS_FAILED, "验签失败")
		return
	}
	if !valid {
		c.Fail(ctx, errorcode.BASE_STRUCT_TRANS_FAILED, "验签失败-1")
		return
	}
	// 处理支付信息
	if callbackMsg.Status != "SUCCESS" {
		c.Fail(ctx, errorcode.BASE_STRUCT_TRANS_FAILED, "支付失败")
		return
	}
    
    // todo 处理业务逻辑 

	c.Success(ctx)
}

// verifySignature 验证签名
func (c *DyPayController) verifySignature(reqInfo *verifyInfo) (bool, error) {
	// 打开 PEM 文件 平台的公钥
	data, err := os.ReadFile("./dy_platform_public_key.pem")
	if err != nil {
		return false, err
	}
	return c.CheckSign(reqInfo.Timestamp, reqInfo.Nonce, reqInfo.Body, reqInfo.Signature, string(data))
}

func (c *DyPayController) Fail(ctx *gin.Context, code int, msg string) {
	result := map[string]interface{}{
		"err_tips": msg,
		"err_no":   code,
	}
	ctx.JSON(http.StatusInternalServerError, result)
}

func (c *DyPayController) Success(ctx *gin.Context) {
	result := gin.H{
		"err_no":   0,
		"err_tips": "success",
	}
	ctx.JSON(http.StatusOK, result)
}

func (c *DyPayController) CheckSign(timestamp, nonce, body, signature, pubKeyStr string) (bool, error) {
	pubKey, err := c.PemToRSAPublicKey(pubKeyStr) // 注意验签时publicKey使用平台公钥而非应用公钥
	if err != nil {
		return false, err
	}

	hashed := sha256.Sum256([]byte(timestamp + "\n" + nonce + "\n" + body + "\n"))
	signBytes, err := base64.StdEncoding.DecodeString(signature)
	if err != nil {
		return false, err
	}
	err = rsa.VerifyPKCS1v15(pubKey, crypto.SHA256, hashed[:], signBytes)
	return err == nil, nil
}

func (c *DyPayController) PemToRSAPublicKey(pemKeyStr string) (*rsa.PublicKey, error) {
	block, _ := pem.Decode([]byte(pemKeyStr))
	if block == nil || len(block.Bytes) == 0 {
		return nil, fmt.Errorf("empty block in pem string")
	}
	key, err := x509.ParsePKIXPublicKey(block.Bytes)
	if err != nil {
		return nil, err
	}
	switch key := key.(type) {
	case *rsa.PublicKey:
		return key, nil
	default:
		return nil, fmt.Errorf("not rsa public key")
	}
}

总结

抖音文档会将大概的逻辑讲一下，但是在实操方面的补充会比较少，希望这篇文章能够帮助到，有问题，欢迎在评论区留言，我看到一定会马上回复。