接收消息

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/hmac"
	"crypto/md5"
	"crypto/sha256"
	"encoding/base64"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"

	"github.com/gin-gonic/gin"
)

type Event struct {
	Topic         string `json:"topic"`
	Operation     string `json:"operation"`
	Time          int64  `json:"time"`
	Nonce         string `json:"nonce"`
	Signature     string `json:"signature"`
	EncryptedData string `json:"encrypted_data"`
}

type ChatInfo struct {
	ID   string `json:"id"`
	Type string `json:"type"`
}

type Identity struct {
	ID   string `json:"id"`
	Type string `json:"type"`
}

type Mention struct {
	ID       string    `json:"id"`
	Type     string    `json:"type"`
	Identity *Identity `json:"identity,omitempty"`
}

type MessageInfo struct {
	ID         string    `json:"id"`
	Type       string    `json:"type"`
	Content    any       `json:"content"`
	Mentions   []Mention `json:"mentions,omitempty"`
	QuoteMsgID *string   `json:"quote_msg_id,omitempty"`
}

type AppChatMessageCreateData struct {
	CompanyID string      `json:"company_id"`
	Chat      ChatInfo    `json:"chat"`
	Sender    Identity    `json:"sender"`
	SendTime  int64       `json:"send_time"`
	Message   MessageInfo `json:"message"`
}

const (
	accessKey = "your_access_key"
	secretKey = "your_secret_key"
)

func Decrypt(encryptedData, cipherKey, nonce string) (string, error) {
	data, err := base64.StdEncoding.DecodeString(encryptedData)
	if err != nil {
		return "", err
	}
	rawData, err := AESCBCPKCS7Decrypt(data, []byte(cipherKey), []byte(nonce))
	if err != nil {
		return "", err
	}
	return string(rawData), nil
}

func AESCBCPKCS7Decrypt(encryptData, key, nonce []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	blockSize := block.BlockSize()
	if len(encryptData) < blockSize {
		return nil, errors.New("cipher text too short")
	}
	if len(encryptData)%blockSize != 0 {
		return nil, errors.New("cipher text is not a multiple of the block size")
	}

	iv := nonce[:blockSize]
	mode := cipher.NewCBCDecrypter(block, iv)
	mode.CryptBlocks(encryptData, encryptData)

	length := len(encryptData)
	unPadding := int(encryptData[length-1])
	return encryptData[:(length - unPadding)], nil
}

func Md5Hex(s string) string {
	h := md5.New()
	h.Write([]byte(s))
	return hex.EncodeToString(h.Sum(nil))
}

func HmacSha256(message, secret string) string {
	h := hmac.New(sha256.New, []byte(secret))
	h.Write([]byte(message))
	return base64.RawURLEncoding.EncodeToString(h.Sum(nil))
}

func main() {
	router := gin.Default()

	router.POST("/open/receive", func(c *gin.Context) {
		event := &Event{}
		if err := c.ShouldBindJSON(event); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}

		content := fmt.Sprintf("%s:%s:%s:%d:%s",
			accessKey, event.Topic, event.Nonce, event.Time, event.EncryptedData)
		signature := HmacSha256(content, secretKey)
		if signature != event.Signature {
			c.JSON(http.StatusBadRequest, gin.H{"error": "signature check failed"})
			return
		}

		cipherKey := Md5Hex(secretKey)
		decryptedData, err := Decrypt(event.EncryptedData, cipherKey, event.Nonce)
		if err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}

		data := &AppChatMessageCreateData{}
		if err = json.Unmarshal([]byte(decryptedData), data); err != nil {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}

		// TODO 处理业务逻辑
		fmt.Printf("事件内容: %+v\n", data)

		c.JSON(http.StatusOK, gin.H{"code": 0})
	})

	_ = router.Run()
}