636 lines
21 KiB
Go
636 lines
21 KiB
Go
package mmtls
|
|
|
|
import (
|
|
"crypto/elliptic"
|
|
"crypto/rand"
|
|
"errors"
|
|
"fmt"
|
|
"sync/atomic"
|
|
|
|
"golang.org/x/net/proxy"
|
|
|
|
"xiawan/wx/clientsdk/baseutils"
|
|
|
|
"github.com/micro/go-micro/util/log"
|
|
"github.com/wsddn/go-ecdh"
|
|
)
|
|
|
|
// CreateNewMMInfo 创建新的MMInfo
|
|
func CreateNewMMInfo() *MMInfo {
|
|
mmInfo := &MMInfo{}
|
|
mmInfo.ShortHost = "szshort.weixin.qq.com"
|
|
mmInfo.LongHost = "szlong.weixin.qq.com"
|
|
mmInfo.LONGPort = 8080
|
|
mmInfo.LONGClientSeq = 1
|
|
mmInfo.LONGServerSeq = 1
|
|
|
|
// 从全局配置设置代理配置
|
|
mmInfo.LongConnTimeout = GlobalProxyConfig.LongConnTimeout
|
|
mmInfo.LongConnReadTimeout = GlobalProxyConfig.LongConnReadTimeout
|
|
mmInfo.LongConnRetryTimes = GlobalProxyConfig.LongConnRetryTimes
|
|
mmInfo.LongConnRetryInterval = GlobalProxyConfig.LongConnRetryInterval
|
|
mmInfo.ShortConnTimeout = GlobalProxyConfig.ShortConnTimeout
|
|
mmInfo.AllowDirectOnProxyFail = GlobalProxyConfig.AllowDirectOnProxyFail
|
|
|
|
return mmInfo
|
|
}
|
|
|
|
// InitMMTLSInfoShort 如果使用MMTLS，每次登陆前都需要初始化MMTLSInfo信息
|
|
// pskList: 之前握手服务端返回的，要保存起来，后面握手时使用， 第一次握手传空数组即可
|
|
func InitMMTLSInfoShort(dialer proxy.Dialer, hostName string, pskList []*Psk) *MMInfo {
|
|
// 初始化MMInfo
|
|
mmInfo := CreateNewMMInfo()
|
|
mmInfo.ShortPskList = pskList
|
|
// 随机生成ClientEcdhKeys
|
|
mmInfo.ClientEcdhKeys = CreateClientEcdhKeys()
|
|
mmInfo.ShortHost = hostName
|
|
mmInfo.Dialer = dialer
|
|
// 握手
|
|
mmInfo, err := MMHandShakeByShortLink(mmInfo, hostName)
|
|
// 如果握手失败 就不使用MMTLS
|
|
if err != nil {
|
|
log.Info(err)
|
|
return nil
|
|
}
|
|
|
|
// 握手成功，设置好HOST 和 新的URL
|
|
shortURL := []byte("/mmtls/")
|
|
mmInfo.ShortHost = hostName
|
|
mmInfo.ShortURL = string(append(shortURL, []byte(baseutils.RandomSmallHexString(8))[0:]...))
|
|
|
|
return mmInfo
|
|
}
|
|
|
|
// CreateClientEcdhKeys 创建新的ClientEcdhKeys
|
|
func CreateClientEcdhKeys() *ClientEcdhKeys {
|
|
// 随机
|
|
clientEcdhKeys := &ClientEcdhKeys{}
|
|
e := ecdh.NewEllipticECDH(elliptic.P256())
|
|
priKey1, pubKey1, _ := e.GenerateKey(rand.Reader)
|
|
priKey2, pubKey2, _ := e.GenerateKey(rand.Reader)
|
|
clientEcdhKeys.PriKey1 = priKey1
|
|
clientEcdhKeys.PriKey2 = priKey2
|
|
clientEcdhKeys.PubKeyBuf1 = e.Marshal(pubKey1)
|
|
clientEcdhKeys.PubKeyBuf2 = e.Marshal(pubKey2)
|
|
|
|
return clientEcdhKeys
|
|
}
|
|
|
|
// MMHandShakeByShortLink 通过短链接握手
|
|
func MMHandShakeByShortLink(mmInfo *MMInfo, hostName string) (*MMInfo, error) {
|
|
shortURL := []byte("/mmtls/")
|
|
mmURL := append(shortURL, []byte(baseutils.RandomSmallHexString(8))[0:]...)
|
|
mmInfo.ShortURL = string(mmURL)
|
|
|
|
// 发送握手请求 - ClientHello
|
|
clientHelloData := CreateHandShakeClientHelloData(mmInfo)
|
|
sendData := CreateRecordData(ServerHandShakeType, clientHelloData)
|
|
retBytes, err := MMHTTPPost(mmInfo, sendData, "handshake")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 解析握手相应数据
|
|
retItems, err := ParserMMtlsResponseData(retBytes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
// 处理握手信息
|
|
clientFinishData, err := DealHandShakePackItems(mmInfo, retItems, clientHelloData)
|
|
_ = clientFinishData
|
|
|
|
return mmInfo, nil
|
|
}
|
|
|
|
// ParserMMtlsResponseData 解析mmtls响应数据
|
|
func ParserMMtlsResponseData(data []byte) ([]*PackItem, error) {
|
|
// RecodeHead *RecodeHead
|
|
retItems := make([]*PackItem, 0)
|
|
|
|
// 总数据大小
|
|
totalLength := uint32(len(data))
|
|
|
|
current := uint32(0)
|
|
// 解析所有包
|
|
for current < totalLength {
|
|
packItem := &PackItem{}
|
|
|
|
// recordHead
|
|
if current+5 > totalLength {
|
|
return retItems, errors.New("ParserMMtlsResponseData err: current+5 >= totalLength")
|
|
}
|
|
recordHead := RecordHeadDeSerialize(data[current:])
|
|
packItem.RecordHead = data[current : current+5]
|
|
current = current + 5
|
|
// PackData
|
|
// 判断数据是否有问题
|
|
if current+uint32(recordHead.Size) > totalLength {
|
|
return retItems, errors.New("ParserMMtlsResponseData err: current+uint32(recordHead.Size) >= totalLength")
|
|
}
|
|
packItem.PackData = data[current : current+uint32(recordHead.Size)]
|
|
|
|
// current
|
|
current = current + uint32(recordHead.Size)
|
|
retItems = append(retItems, packItem)
|
|
}
|
|
|
|
return retItems, nil
|
|
}
|
|
|
|
// DealHandShakePackItems 解密packItems
|
|
func DealHandShakePackItems(mmInfo *MMInfo, packItems []*PackItem, clientHelloReq []byte) ([]byte, error) {
|
|
retClientFinishData := make([]byte, 0)
|
|
|
|
// 先解析 ServerHello
|
|
secretKey, err := DealServerHello(mmInfo, packItems[0])
|
|
if err != nil {
|
|
return retClientFinishData, err
|
|
}
|
|
|
|
// 计算HashRet
|
|
hashData := make([]byte, 0)
|
|
hashData = append(hashData, clientHelloReq[0:]...)
|
|
hashData = append(hashData, packItems[0].PackData...)
|
|
hashRet := Sha256(hashData)
|
|
|
|
// 密钥扩展
|
|
message := []byte("handshake key expansion")
|
|
message = append(message, hashRet...)
|
|
aesKeyExpand := HkdfExpand(secretKey, message, 56)
|
|
gcmAesKey := aesKeyExpand[0x10:0x20]
|
|
oriNonce := aesKeyExpand[0x2c:]
|
|
|
|
// 解密后面的包
|
|
count := len(packItems)
|
|
for index := 1; index < count; index++ {
|
|
tmpPackItem := packItems[index]
|
|
|
|
// 解密数据
|
|
tmpNonce := GetNonce(oriNonce, uint32(index))
|
|
tmpAad := []byte{0x00, 0x00, 0x00, 0x00}
|
|
tmpAad = append(tmpAad, baseutils.Int32ToBytes(atomic.LoadUint32(&mmInfo.LONGServerSeq))...)
|
|
tmpAad = append(tmpAad, tmpPackItem.RecordHead...)
|
|
decodeData, err := AesGcmDecrypt(gcmAesKey, tmpNonce, tmpAad, tmpPackItem.PackData)
|
|
// 设置解密后的数据
|
|
tmpPackItem.PackData = decodeData
|
|
if err != nil {
|
|
return retClientFinishData, err
|
|
}
|
|
atomic.AddUint32(&mmInfo.LONGServerSeq, 1)
|
|
//mmInfo.LONGServerSeq++
|
|
|
|
// 处理CertificateVerifyType
|
|
tmpType := decodeData[4]
|
|
if tmpType == CertificateVerifyType {
|
|
// 校验服务器
|
|
flag, err := DealCertificateVerify(clientHelloReq, packItems[0].PackData, decodeData)
|
|
if err != nil {
|
|
return retClientFinishData, err
|
|
}
|
|
if !flag {
|
|
return retClientFinishData, errors.New("DealHandShakePackItems err: CertificateVerify failed")
|
|
}
|
|
}
|
|
|
|
// 处理NewSessionTicketType
|
|
if tmpType == NewSessionTicketType {
|
|
err := DealNewSessionTicket(mmInfo, decodeData)
|
|
if err != nil {
|
|
return retClientFinishData, err
|
|
}
|
|
|
|
}
|
|
|
|
// 处理Server FinishType
|
|
if tmpType == FinishedType {
|
|
// 第一步验证ServerFinished数据
|
|
tmpHashData := make([]byte, 0)
|
|
tmpHashData = append(tmpHashData, clientHelloReq[0:]...)
|
|
tmpHashData = append(tmpHashData, packItems[0].PackData[0:]...)
|
|
tmpHashData = append(tmpHashData, packItems[1].PackData[0:]...)
|
|
tmpHashData = append(tmpHashData, packItems[2].PackData[0:]...)
|
|
tmpHashValue := Sha256(tmpHashData)
|
|
serverFinished, err := FinishedDeSerialize(tmpPackItem.PackData[4:])
|
|
if err != nil {
|
|
return retClientFinishData, err
|
|
}
|
|
bSuccess := VerifyFinishedData(secretKey, tmpHashValue, serverFinished.VerifyData)
|
|
if !bSuccess {
|
|
return retClientFinishData, errors.New("DealHandShakePackItems err: Finished verify failed")
|
|
}
|
|
|
|
// 第二步生成ClientFinished数据，然后加密
|
|
hkdfClientFinish := HkdfExpand(secretKey, []byte("client finished"), 32)
|
|
hmacRet := HmacHash256(hkdfClientFinish, tmpHashValue)
|
|
aesGcmParam := &AesGcmParam{}
|
|
aesGcmParam.AesKey = aesKeyExpand[0x00:0x10]
|
|
aesGcmParam.Nonce = aesKeyExpand[0x20:0x2c]
|
|
// 创建Finished
|
|
finished := CreateFinished(hmacRet)
|
|
// 加密
|
|
finishedData := FinishedSerialize(finished)
|
|
clientSeq := atomic.AddUint32(&mmInfo.LONGClientSeq, 1) - 1
|
|
encodeData, err := EncryptedReqData(aesGcmParam, finishedData, ServerHandShakeType, clientSeq)
|
|
if err != nil {
|
|
return retClientFinishData, err
|
|
}
|
|
retClientFinishData = CreateRecordData(ServerHandShakeType, encodeData)
|
|
//mmInfo.LONGClientSeq++
|
|
//atomic.AddUint32(&mmInfo.LONGClientSeq, 1)
|
|
break
|
|
}
|
|
}
|
|
|
|
// 计算扩展出来的用于后续加密的Key
|
|
tmpExpandHashData := make([]byte, 0)
|
|
tmpExpandHashData = append(tmpExpandHashData, clientHelloReq[0:]...)
|
|
tmpExpandHashData = append(tmpExpandHashData, packItems[0].PackData[0:]...)
|
|
tmpExpandHashData = append(tmpExpandHashData, packItems[1].PackData[0:]...)
|
|
tmpExpandHashValue := Sha256(tmpExpandHashData)
|
|
|
|
// PskAccessKey 短连接MMTLS密钥
|
|
expandPskAccessData := []byte("PSK_ACCESS")
|
|
expandPskAccessData = append(expandPskAccessData, tmpExpandHashValue[0:]...)
|
|
mmInfo.PskAccessKey = HkdfExpand(secretKey, expandPskAccessData, 32)
|
|
|
|
// AppDataKeyExtension 长链接MMTLS密钥
|
|
tmpExpandHashData = append(tmpExpandHashData, packItems[2].PackData[0:]...)
|
|
tmpLongHashValue := Sha256(tmpExpandHashData)
|
|
expandedSecret := append([]byte("expanded secret"), tmpLongHashValue[0:]...)
|
|
retExpandSecret := HkdfExpand(secretKey, expandedSecret, 32)
|
|
appDataKeyData := append([]byte("application data key expansion"), tmpLongHashValue[0:]...)
|
|
appDataKeyExtension := HkdfExpand(retExpandSecret, appDataKeyData, 56)
|
|
mmInfo.LongHdkfKey = &HkdfKey56{}
|
|
mmInfo.LongHdkfKey.EncodeAesKey = appDataKeyExtension[0x00:0x10]
|
|
mmInfo.LongHdkfKey.DecodeAesKey = appDataKeyExtension[0x10:0x20]
|
|
mmInfo.LongHdkfKey.EncodeNonce = appDataKeyExtension[0x20:0x2c]
|
|
mmInfo.LongHdkfKey.DecodeNonce = appDataKeyExtension[0x2c:]
|
|
|
|
// 返回ClientFinishData
|
|
return retClientFinishData, nil
|
|
}
|
|
|
|
// DealServerHello 处理ServerHello
|
|
func DealServerHello(mmInfo *MMInfo, packItem *PackItem) ([]byte, error) {
|
|
// 解析ServerHello
|
|
serverHello, err := ServerHelloDeSerialize(packItem.PackData[4:])
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
|
|
// 解析ServerKeyShare
|
|
serverKeyShareExtension, err := ServerKeyShareExtensionDeSerialize(serverHello.ExtensionList[0].ExtensionData)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
|
|
// 解析ServerPublicKey
|
|
ecdhTool := ecdh.NewEllipticECDH(elliptic.P256())
|
|
serverPubKey, isOk := ecdhTool.Unmarshal(serverKeyShareExtension.PublicValue)
|
|
if !isOk {
|
|
return []byte{}, errors.New("DecodePackItems ecdhTool.Unmarshal(serverKeyShareExtension.PublicValue) failed")
|
|
}
|
|
|
|
// 根据NameGroup 决定使用哪个Privakey
|
|
ecdhPriKey := mmInfo.ClientEcdhKeys.PriKey1
|
|
if serverKeyShareExtension.KeyOfferNameGroup == 2 {
|
|
ecdhPriKey = mmInfo.ClientEcdhKeys.PriKey2
|
|
}
|
|
|
|
// 协商密钥
|
|
secretKey, err := ecdhTool.GenerateSharedSecret(ecdhPriKey, serverPubKey) //服务器公钥和本地第一个私钥协商出安全密钥
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
return Sha256(secretKey), nil
|
|
}
|
|
|
|
// DealCertificateVerify 处理CertificateVerify数据: 校验服务器-判断是不是微信服务器，请求返回数据有没有被串改
|
|
func DealCertificateVerify(clientHelloData []byte, serverHelloData []byte, data []byte) (bool, error) {
|
|
// 解析数据
|
|
totalSize := baseutils.BytesToInt32(data[0:4])
|
|
certificateVerify, err := CertificateVerifyDeSerialize(data[4 : 4+totalSize])
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
// 合并请求数据
|
|
message := make([]byte, 0)
|
|
message = append(message, clientHelloData[0:]...)
|
|
message = append(message, serverHelloData[0:]...)
|
|
message = Sha256(message)
|
|
|
|
// 校验数据
|
|
flag, err := ECDSAVerifyData(message, certificateVerify.Signature)
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
return flag, nil
|
|
}
|
|
|
|
// DealNewSessionTicket 处理NewSessionTicket数据
|
|
func DealNewSessionTicket(mmInfo *MMInfo, data []byte) error {
|
|
// 解析数据
|
|
totalSize := baseutils.BytesToInt32(data[0:4])
|
|
newSessionTicket, err := NewSessionTicketDeSerialize(data[4 : 4+totalSize])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
mmInfo.ShortPskList = newSessionTicket.PskList
|
|
|
|
return nil
|
|
}
|
|
|
|
// ----------- 上面是握手阶段 -----------
|
|
// ----------- 接下来是发送请求 -----------
|
|
|
|
// EncryptedReqData EncryptedReqData
|
|
func EncryptedReqData(aesGcmParam *AesGcmParam, data []byte, recordHeadType byte, clientSeq uint32) ([]byte, error) {
|
|
tmpNonce := GetNonce(aesGcmParam.Nonce, clientSeq)
|
|
tmpHead := GetRecordDataByLength(recordHeadType, uint16(len(data)+0x10))
|
|
tmpAad := []byte{0x00, 0x00, 0x00, 0x00}
|
|
tmpAad = append(tmpAad, baseutils.Int32ToBytes(clientSeq)...)
|
|
tmpAad = append(tmpAad, tmpHead[0:]...)
|
|
encodeData, err := AesGcmEncrypt(aesGcmParam.AesKey, tmpNonce, tmpAad, data)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
return encodeData, nil
|
|
}
|
|
|
|
// DecryptedRecvData 解析响应数据包
|
|
func DecryptedRecvData(aesGcmParam *AesGcmParam, recvItem *PackItem, serverSeq uint32) ([]byte, error) {
|
|
tmpNonce := GetNonce(aesGcmParam.Nonce, serverSeq)
|
|
tmpAad := []byte{0x00, 0x00, 0x00, 0x00}
|
|
tmpAad = append(tmpAad, baseutils.Int32ToBytes(serverSeq)...)
|
|
tmpAad = append(tmpAad, recvItem.RecordHead[0:]...)
|
|
encodeData, err := AesGcmDecrypt(aesGcmParam.AesKey, tmpNonce, tmpAad, recvItem.PackData)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
return encodeData, nil
|
|
}
|
|
|
|
// CreateSendPackItems 创建发送的请求项列表
|
|
func CreateSendPackItems(mmInfo *MMInfo, httpHandler *HTTPHandler) ([]*PackItem, error) {
|
|
retItems := make([]*PackItem, 0)
|
|
|
|
// ClientHelloItem
|
|
clientHelloItem := &PackItem{}
|
|
clientHello, err := CreateClientHelloData(mmInfo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
clientHelloData := ClientHelloSerialize(clientHello)
|
|
clientHelloItem.RecordHead = GetRecordDataByLength(ClientHandShakeType, uint16(len(clientHelloData)))
|
|
clientHelloItem.PackData = clientHelloData
|
|
|
|
// EncryptedExtensionsItem
|
|
encryptedExtensionsItem := &PackItem{}
|
|
encryptedExtensions := CreateEncryptedExtensions()
|
|
encryptedExtensionsData := EncryptedExtensionsSerialize(encryptedExtensions)
|
|
encryptedExtensionsItem.RecordHead = GetRecordDataByLength(ClientHandShakeType, uint16(len(encryptedExtensionsData)))
|
|
encryptedExtensionsItem.PackData = encryptedExtensionsData
|
|
|
|
// HTTPHandlerItem
|
|
httpHandlerItem := &PackItem{}
|
|
httpHandlerData := HTTPHandlerSerialize(httpHandler)
|
|
httpHandlerItem.RecordHead = GetRecordDataByLength(BodyType, uint16(len(httpHandlerData)))
|
|
httpHandlerItem.PackData = httpHandlerData
|
|
|
|
// AlertItem
|
|
alertItem := &PackItem{}
|
|
alertData := GetAlertData()
|
|
alertItem.RecordHead = GetRecordDataByLength(AlertType, uint16(len(alertData)))
|
|
alertItem.PackData = alertData
|
|
|
|
// 返回数据
|
|
retItems = append(retItems, clientHelloItem)
|
|
retItems = append(retItems, encryptedExtensionsItem)
|
|
retItems = append(retItems, httpHandlerItem)
|
|
retItems = append(retItems, alertItem)
|
|
return retItems, nil
|
|
}
|
|
|
|
// MMHTTPPackData MMPackData
|
|
func MMHTTPPackData(mmInfo *MMInfo, items []*PackItem) ([]byte, error) {
|
|
// 密钥扩展
|
|
sha256Value := Sha256(items[0].PackData)
|
|
expandSecretData := []byte("early data key expansion")
|
|
expandSecretData = append(expandSecretData, sha256Value[0:]...)
|
|
tmpHkdfValue := HkdfExpand(mmInfo.PskAccessKey, expandSecretData, 28)
|
|
aesGcmParam := &AesGcmParam{}
|
|
aesGcmParam.AesKey = tmpHkdfValue[0x00:0x10]
|
|
aesGcmParam.Nonce = tmpHkdfValue[0x10:0x1c]
|
|
|
|
// 加密EncryptedExtensions
|
|
encryptData, err := EncryptedReqData(aesGcmParam, items[1].PackData, ClientHandShakeType, 1)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
partData2 := CreateRecordData(ClientHandShakeType, encryptData)
|
|
|
|
// 加密HTTPHandler
|
|
httpHandlerEncryptData, err := EncryptedReqData(aesGcmParam, items[2].PackData, BodyType, 2)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
partData3 := CreateRecordData(BodyType, httpHandlerEncryptData)
|
|
|
|
// 加密Alert
|
|
alertDataEncryptData, err := EncryptedReqData(aesGcmParam, items[3].PackData, AlertType, 3)
|
|
if err != nil {
|
|
return []byte{}, err
|
|
}
|
|
partData4 := CreateRecordData(AlertType, alertDataEncryptData)
|
|
|
|
// 返回数据
|
|
retData := make([]byte, 0)
|
|
retData = append(retData, items[0].RecordHead[0:]...)
|
|
retData = append(retData, items[0].PackData[0:]...)
|
|
retData = append(retData, partData2[0:]...)
|
|
retData = append(retData, partData3[0:]...)
|
|
retData = append(retData, partData4[0:]...)
|
|
return retData, err
|
|
}
|
|
|
|
// MMDecodeResponseData 解码响应数据
|
|
// func MMDecodeResponseData(mmInfo *MMInfo, sendItems []*PackItem, respData []byte) ([]byte, error) {
|
|
// retData := make([]byte, 0)
|
|
|
|
// // 解析 对响应数据进行分包
|
|
// recvItems, err := ParserMMtlsResponseData(respData)
|
|
// if err != nil {
|
|
// return retData, err
|
|
// }
|
|
|
|
// if len(recvItems) < 4 {
|
|
// return retData, errors.New("MMDecodeResponseData err: recvItems Length < 4")
|
|
// }
|
|
|
|
// // 密钥扩展 用于后面的解密
|
|
// shaData := make([]byte, 0)
|
|
// shaData = append(shaData, sendItems[0].PackData[0:]...)
|
|
// shaData = append(shaData, sendItems[1].PackData[0:]...)
|
|
// shaData = append(shaData, recvItems[0].PackData[0:]...)
|
|
// sha256Value := Sha256(shaData)
|
|
// expandSecretData := []byte("handshake key expansion")
|
|
// expandSecretData = append(expandSecretData, sha256Value[0:]...)
|
|
// tmpHkdfValue := HkdfExpand(mmInfo.PskAccessKey, expandSecretData, 28)
|
|
// aesGcmParam := &AesGcmParam{}
|
|
// aesGcmParam.AesKey = tmpHkdfValue[0x00:0x10]
|
|
// aesGcmParam.Nonce = tmpHkdfValue[0x10:0x1c]
|
|
|
|
// // 解密剩下的包
|
|
// count := len(recvItems)
|
|
// for index := 1; index < count; index++ {
|
|
// // 解密Finished数据包
|
|
// decodeData, err := DecryptedRecvData(aesGcmParam, recvItems[index], uint32(index))
|
|
// if err != nil {
|
|
// return retData, err
|
|
// }
|
|
|
|
// // RecordHeadType
|
|
// recordHeadType := recvItems[index].RecordHead[0]
|
|
// // ServerHandShakeType 校验收到的数据是否完整，是否又被串改
|
|
// if recordHeadType == ServerHandShakeType {
|
|
// // 判断数据长度是否正常
|
|
// current := 0
|
|
// totalLength := int(baseutils.BytesToInt32(decodeData[current : current+4]))
|
|
// current = current + 4
|
|
// if totalLength < 0 {
|
|
// return retData, errors.New("MMDecodeResponseData err: totalLength < 0")
|
|
// }
|
|
|
|
// // ReceiveSubType
|
|
// subType := decodeData[current]
|
|
// // FinishedType 校验数据是否正常
|
|
// if subType == FinishedType {
|
|
// // 反序列化
|
|
// finished, err := FinishedDeSerialize(decodeData[current : current+totalLength])
|
|
// if err != nil {
|
|
// return retData, err
|
|
// }
|
|
// bSuccess := VerifyFinishedData(mmInfo.PskAccessKey, sha256Value, finished.VerifyData)
|
|
// if !bSuccess {
|
|
// return retData, errors.New("MMDecodeResponseData err: VerifyFinishedData failed")
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// // 解析响应数据
|
|
// if recordHeadType == BodyType {
|
|
// retData = append(retData, decodeData[0:]...)
|
|
// }
|
|
|
|
// // 解析AlertType
|
|
// if recordHeadType == AlertType {
|
|
// // 关闭连接的数据包(对长链接有用) 固定为0x00, 0x00, 0x00, 0x03, 0x00, 0x01, 0x01
|
|
// }
|
|
// }
|
|
|
|
// return retData, nil
|
|
// }
|
|
|
|
// MMDecodeResponseData 解码响应数据
|
|
func MMDecodeResponseData(mmInfo *MMInfo, sendItems []*PackItem, respData []byte) ([]byte, error) {
|
|
var retData []byte
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
fmt.Printf("Recovered from panic: %v\n", r)
|
|
// 这里可以记录日志或者执行其他的恢复操作
|
|
return
|
|
}
|
|
}()
|
|
|
|
// 解析响应数据
|
|
recvItems, err := ParserMMtlsResponseData(respData)
|
|
if err != nil {
|
|
return retData, fmt.Errorf("failed to parse response data: %w", err)
|
|
}
|
|
|
|
if len(recvItems) < 4 {
|
|
return retData, errors.New("MMDecodeResponseData err: recvItems Length < 4")
|
|
}
|
|
|
|
if len(sendItems) < 2 || sendItems[0] == nil || sendItems[1] == nil {
|
|
return retData, errors.New("MMDecodeResponseData err: sendItems Length < 2 or contains nil")
|
|
}
|
|
|
|
// 密钥扩展 用于后面的解密, 确保 sendItems 和 recvItems 有效
|
|
shaData := append(sendItems[0].PackData, sendItems[1].PackData...)
|
|
shaData = append(shaData, recvItems[0].PackData...)
|
|
|
|
sha256Value := Sha256(shaData)
|
|
expandSecretData := append([]byte("handshake key expansion"), sha256Value...)
|
|
tmpHkdfValue := HkdfExpand(mmInfo.PskAccessKey, expandSecretData, 28)
|
|
|
|
aesGcmParam := &AesGcmParam{
|
|
AesKey: tmpHkdfValue[:0x10],
|
|
Nonce: tmpHkdfValue[0x10:0x1c],
|
|
}
|
|
|
|
// 解密每个包
|
|
for index := 1; index < len(recvItems); index++ {
|
|
decodeData, err := DecryptedRecvData(aesGcmParam, recvItems[index], uint32(index))
|
|
if err != nil {
|
|
return retData, fmt.Errorf("error decrypting packet %d: %w", index, err)
|
|
}
|
|
|
|
recordHeadType := recvItems[index].RecordHead[0]
|
|
|
|
if recordHeadType == ServerHandShakeType {
|
|
if len(decodeData) < 4 {
|
|
return retData, errors.New("MMDecodeResponseData err: decodeData Length < 4")
|
|
}
|
|
current := 4
|
|
totalLength := int(baseutils.BytesToInt32(decodeData[:current]))
|
|
if totalLength < 0 || len(decodeData) < totalLength {
|
|
return retData, errors.New("MMDecodeResponseData err: invalid total length")
|
|
}
|
|
|
|
subType := decodeData[current]
|
|
if subType == FinishedType {
|
|
finished, err := FinishedDeSerialize(decodeData[current : current+totalLength])
|
|
if err != nil {
|
|
return retData, fmt.Errorf("failed to deserialize finished data: %w", err)
|
|
}
|
|
bSuccess := VerifyFinishedData(mmInfo.PskAccessKey, sha256Value, finished.VerifyData)
|
|
if !bSuccess {
|
|
return retData, errors.New("MMDecodeResponseData err: VerifyFinishedData failed")
|
|
}
|
|
}
|
|
}
|
|
|
|
if recordHeadType == BodyType {
|
|
retData = append(retData, decodeData...)
|
|
}
|
|
|
|
if recordHeadType == AlertType {
|
|
// 如果是告警数据包，可以在此处理
|
|
}
|
|
}
|
|
|
|
return retData, nil
|
|
}
|
|
|
|
// VerifyFinishedData 校验服务端返回数据是否正确
|
|
func VerifyFinishedData(aesKey []byte, shaValue []byte, finishedData []byte) bool {
|
|
count := len(finishedData)
|
|
message := []byte("server finished")
|
|
tmpHkdfValue := HkdfExpand(aesKey, message, count)
|
|
verifyData := HmacHash256(tmpHkdfValue, shaValue)
|
|
|
|
// 比对结果是否一致
|
|
for index := 0; index < count; index++ {
|
|
if verifyData[index] != finishedData[index] {
|
|
return false
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|