272 lines
9.5 KiB
Go
272 lines
9.5 KiB
Go
package mmtls
|
|
|
|
import (
|
|
"xiawan/wx/clientsdk/baseutils"
|
|
)
|
|
|
|
// RecordHeadSerialize 序列化RecordHead
|
|
func RecordHeadSerialize(recordHead *RecordHead) []byte {
|
|
retBytes := make([]byte, 0)
|
|
// Type
|
|
retBytes = append(retBytes, recordHead.Type)
|
|
// Tag
|
|
retBytes = append(retBytes, baseutils.Int16ToBytesBigEndian(recordHead.Tag)[0:]...)
|
|
// size
|
|
retBytes = append(retBytes, baseutils.Int16ToBytesBigEndian(recordHead.Size)[0:]...)
|
|
|
|
return retBytes
|
|
}
|
|
|
|
// ClientHelloSerialize 序列化ClientHello
|
|
func ClientHelloSerialize(clientHello *ClientHello) []byte {
|
|
bodyData := make([]byte, 0)
|
|
// Type
|
|
bodyData = append(bodyData, ClientHelloType)
|
|
// Version
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesLittleEndian(clientHello.Version)[0:]...)
|
|
// suiteCount
|
|
suiteCount := byte(len(clientHello.CipherSuiteList))
|
|
bodyData = append(bodyData, suiteCount)
|
|
// suiteList
|
|
suiteList := clientHello.CipherSuiteList
|
|
for index := 0; index < int(suiteCount); index++ {
|
|
// suiteCode
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(suiteList[index].SuiteCode)[0:]...)
|
|
}
|
|
// RandomBytes
|
|
bodyData = append(bodyData, clientHello.RandomBytes[0:]...)
|
|
// ClientGmtTime
|
|
bodyData = append(bodyData, baseutils.Int32ToBytes(clientHello.ClientGmtTime)[0:]...)
|
|
// Extensions
|
|
extensionsData := ExtensionsSerialize(clientHello.ExtensionList)
|
|
bodyData = append(bodyData, extensionsData[0:]...)
|
|
|
|
// 返回数据
|
|
retBytes := make([]byte, 0)
|
|
totalLength := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(totalLength)[0:]...)
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
return retBytes
|
|
}
|
|
|
|
// ExtensionsSerialize 序列化Extensions
|
|
func ExtensionsSerialize(extensionList []*Extension) []byte {
|
|
retBytes := make([]byte, 0)
|
|
|
|
// bodyData
|
|
bodyData := make([]byte, 0)
|
|
// MapSize
|
|
extensionCount := byte(len(extensionList))
|
|
bodyData = append(bodyData, extensionCount)
|
|
for index := 0; index < int(extensionCount); index++ {
|
|
// Extension TotalLength
|
|
extensionLength := uint32(len(extensionList[index].ExtensionData))
|
|
bodyData = append(bodyData, baseutils.Int32ToBytes(extensionLength)[0:]...)
|
|
// extensionData
|
|
bodyData = append(bodyData, extensionList[index].ExtensionData[0:]...)
|
|
}
|
|
|
|
// Extensions Size
|
|
extensionsSize := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(extensionsSize)[0:]...)
|
|
|
|
// ExtensionsData
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
return retBytes
|
|
}
|
|
|
|
// PskSerialize 序列化Psk
|
|
func PskSerialize(psk *Psk) []byte {
|
|
// BodyData
|
|
bodyData := make([]byte, 0)
|
|
// Type
|
|
bodyData = append(bodyData, psk.Type)
|
|
// TicketLifeTimeHint
|
|
bodyData = append(bodyData, baseutils.Int32ToBytes(psk.TicketKLifeTimeHint)[0:]...)
|
|
// MacValue
|
|
macValueLen := uint16(len(psk.MacValue))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(macValueLen)[0:]...)
|
|
bodyData = append(bodyData, psk.MacValue[0:]...)
|
|
// KeyVersion
|
|
bodyData = append(bodyData, baseutils.Int32ToBytes(psk.KeyVersion)[0:]...)
|
|
// IV
|
|
ivLen := uint16(len(psk.Iv))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(ivLen)[0:]...)
|
|
bodyData = append(bodyData, psk.Iv[0:]...)
|
|
// EncryptTicket
|
|
encryptTicketLen := uint16(len(psk.EncryptedTicket))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(encryptTicketLen)[0:]...)
|
|
bodyData = append(bodyData, psk.EncryptedTicket[0:]...)
|
|
|
|
// 返回数据
|
|
retBytes := make([]byte, 0)
|
|
bodyLen := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(bodyLen)[0:]...)
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
|
|
return retBytes
|
|
}
|
|
|
|
// ClientKeyOfferSerialize 序列化ClientKeyOffer
|
|
func ClientKeyOfferSerialize(clientKeyOffer *ClientKeyOffer) []byte {
|
|
// BodyData
|
|
bodyData := make([]byte, 0)
|
|
// Version
|
|
bodyData = append(bodyData, baseutils.Int32ToBytes(clientKeyOffer.Version)[0:]...)
|
|
// PublicValue
|
|
publicValueLen := uint16(len(clientKeyOffer.PublicValue))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(publicValueLen)[0:]...)
|
|
if publicValueLen > 0 {
|
|
bodyData = append(bodyData, clientKeyOffer.PublicValue[0:]...)
|
|
}
|
|
|
|
// 返回数据
|
|
retBytes := make([]byte, 0)
|
|
bodyDataLen := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(bodyDataLen)[0:]...)
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
return retBytes
|
|
}
|
|
|
|
// EncryptedExtensionsSerialize 序列化EncryptedExtensions
|
|
func EncryptedExtensionsSerialize(encryptedExtensions *EncryptedExtensions) []byte {
|
|
bodyData := make([]byte, 0)
|
|
// Type
|
|
bodyData = append(bodyData, EncryptedExtensionsType)
|
|
// ExtensionList
|
|
extensionsData := ExtensionsSerialize(encryptedExtensions.ExtensionList)
|
|
bodyData = append(bodyData, extensionsData[0:]...)
|
|
|
|
// 返回数据
|
|
retBytes := make([]byte, 0)
|
|
bodyDataLen := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(bodyDataLen)[0:]...)
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
return retBytes
|
|
}
|
|
|
|
// HTTPHandlerSerialize 序列化HTTPHandler
|
|
func HTTPHandlerSerialize(httpHandler *HTTPHandler) []byte {
|
|
bodyData := make([]byte, 0)
|
|
// URL
|
|
urlLength := uint16(len(httpHandler.URL))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(urlLength)[0:]...)
|
|
bodyData = append(bodyData, []byte(httpHandler.URL)[0:]...)
|
|
|
|
// Host
|
|
hostLength := uint16(len(httpHandler.Host))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(hostLength)[0:]...)
|
|
bodyData = append(bodyData, []byte(httpHandler.Host)[0:]...)
|
|
|
|
// MMPkg
|
|
mmpkgLength := uint32(len(httpHandler.MMPkg))
|
|
bodyData = append(bodyData, baseutils.Int32ToBytes(mmpkgLength)[0:]...)
|
|
bodyData = append(bodyData, httpHandler.MMPkg[0:]...)
|
|
|
|
// 返回数据
|
|
retBytes := make([]byte, 0)
|
|
bodyDataLen := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(bodyDataLen)[0:]...)
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
return retBytes
|
|
}
|
|
|
|
// FinishedSerialize 序列化Finished包
|
|
func FinishedSerialize(finished *Finished) []byte {
|
|
bodyData := make([]byte, 0)
|
|
// Type
|
|
bodyData = append(bodyData, FinishedType)
|
|
// VerifyData
|
|
verifyDataLen := uint16(uint32(len(finished.VerifyData)))
|
|
bodyData = append(bodyData, baseutils.Int16ToBytesBigEndian(verifyDataLen)[0:]...)
|
|
bodyData = append(bodyData, finished.VerifyData[0:]...)
|
|
|
|
// 返回数据
|
|
retBytes := make([]byte, 0)
|
|
bodyDataLen := uint32(len(bodyData))
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(bodyDataLen)[0:]...)
|
|
retBytes = append(retBytes, bodyData[0:]...)
|
|
return retBytes
|
|
}
|
|
|
|
// --------------- 各类Extension的序列化 ---------------
|
|
|
|
// PreSharedKeyExtensionSerialize 序列化PreSharedKeyExtension
|
|
func PreSharedKeyExtensionSerialize(preSharedKeyExtension *PreSharedKeyExtension) *Extension {
|
|
// ExtensionBytes
|
|
extensionBytes := make([]byte, 0)
|
|
// PreSharedKeyExtensionType
|
|
extensionBytes = append(extensionBytes, baseutils.Int16ToBytesBigEndian(PreSharedKeyExtensionType)[0:]...)
|
|
// pskCount
|
|
pskCount := byte(len(preSharedKeyExtension.PskList))
|
|
extensionBytes = append(extensionBytes, pskCount)
|
|
// PskList
|
|
for index := 0; index < int(pskCount); index++ {
|
|
psk := preSharedKeyExtension.PskList[index]
|
|
pskData := PskSerialize(psk)
|
|
extensionBytes = append(extensionBytes, pskData[0:]...)
|
|
}
|
|
|
|
// 返回数据
|
|
retExtension := &Extension{}
|
|
retExtension.ExtensionType = PreSharedKeyExtensionType
|
|
retExtension.ExtensionData = extensionBytes
|
|
return retExtension
|
|
}
|
|
|
|
// ClientKeyShareExtensionSerialize 序列化ClientKeyShareExtension
|
|
func ClientKeyShareExtensionSerialize(clientKeyShareExtension *ClientKeyShareExtension) *Extension {
|
|
// ExtensionBytes
|
|
extensionBytes := make([]byte, 0)
|
|
// ClientKeyShareType
|
|
extensionBytes = append(extensionBytes, baseutils.Int16ToBytesBigEndian(ClientKeyShareType)[0:]...)
|
|
// KeyOfferCount
|
|
keyOfferCount := byte(len(clientKeyShareExtension.ClientKeyOfferList))
|
|
extensionBytes = append(extensionBytes, keyOfferCount)
|
|
// KeyOfferList
|
|
for index := 0; index < int(keyOfferCount); index++ {
|
|
keyOffer := clientKeyShareExtension.ClientKeyOfferList[index]
|
|
keyOfferData := ClientKeyOfferSerialize(keyOffer)
|
|
extensionBytes = append(extensionBytes, keyOfferData[0:]...)
|
|
}
|
|
// CertificateVersion
|
|
extensionBytes = append(extensionBytes, baseutils.Int32ToBytes(clientKeyShareExtension.CertificateVersion)[0:]...)
|
|
|
|
// 返回数据
|
|
retExtension := &Extension{}
|
|
retExtension.ExtensionType = ClientKeyShareType
|
|
retExtension.ExtensionData = extensionBytes
|
|
return retExtension
|
|
}
|
|
|
|
// EarlyEncryptDataExtensionSerialize 序列化EarlyEncryptDataExtension
|
|
func EarlyEncryptDataExtensionSerialize(earlyEncryptDataExtension *EarlyEncryptDataExtension) *Extension {
|
|
// ExtensionBytes
|
|
extensionBytes := make([]byte, 0)
|
|
// ClientKeyShareType
|
|
extensionBytes = append(extensionBytes, baseutils.Int16ToBytesBigEndian(EarlyEncryptDataType)[0:]...)
|
|
// ClientGmtTime
|
|
extensionBytes = append(extensionBytes, baseutils.Int32ToBytes(earlyEncryptDataExtension.ClientGmtTime)[0:]...)
|
|
|
|
// 返回数据
|
|
retExtension := &Extension{}
|
|
retExtension.ExtensionType = EarlyEncryptDataType
|
|
retExtension.ExtensionData = extensionBytes
|
|
return retExtension
|
|
}
|
|
|
|
// LongPackHeaderInfoSerialize 序列化LongPackHeaderInfo
|
|
func LongPackHeaderInfoSerialize(packTagInfo *LongPackHeaderInfo) []byte {
|
|
retBytes := make([]byte, 0)
|
|
// Type
|
|
retBytes = append(retBytes, baseutils.Int16ToBytesBigEndian(packTagInfo.HeaderLen)[0:]...)
|
|
// Version
|
|
retBytes = append(retBytes, baseutils.Int16ToBytesBigEndian(packTagInfo.Version)[0:]...)
|
|
// Operation
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(packTagInfo.Operation)[0:]...)
|
|
// SequenceNumber
|
|
retBytes = append(retBytes, baseutils.Int32ToBytes(packTagInfo.SequenceNumber)[0:]...)
|
|
|
|
return retBytes
|
|
}
|