From aadf28dde246ee7ff22cd3589ca2233b00f39702 Mon Sep 17 00:00:00 2001
From: Tnze <cjd001113@outlook.com>
Date: Thu, 1 Dec 2022 01:42:28 +0800
Subject: [PATCH] add Hash for Chat Header

---
 bot/msg/chat.go     |  9 ++++---
 chat/sign/sign.go   | 59 +++++++++++++++++++++++++++++----------------
 net/packet/types.go | 12 +++++----
 3 files changed, 51 insertions(+), 29 deletions(-)

diff --git a/bot/msg/chat.go b/bot/msg/chat.go
index 78689bf..9a1923a 100644
--- a/bot/msg/chat.go
+++ b/bot/msg/chat.go
@@ -44,10 +44,13 @@ func attachPlayerMsg(c *bot.Client, p *basic.Player, handler func(msg chat.Messa
 				}
 
 				var content chat.Message
-				if message.MessageBody.Message != nil {
-					content = *message.MessageBody.Message
+				if message.MessageBody.DecoratedMsg != nil {
+					data, _ := message.MessageBody.DecoratedMsg.MarshalJSON()
+					if err := content.UnmarshalJSON(data); err != nil {
+						return err
+					}
 				} else {
-					content = chat.Text(message.MessageBody.PlainMessage)
+					content = chat.Text(message.MessageBody.PlainMsg)
 				}
 
 				ct := p.WorldInfo.RegistryCodec.ChatType.FindByID(chatType.ID)
diff --git a/chat/sign/sign.go b/chat/sign/sign.go
index 9e722d5..220ba36 100644
--- a/chat/sign/sign.go
+++ b/chat/sign/sign.go
@@ -2,7 +2,9 @@ package sign
 
 import (
 	"crypto/rand"
+	"crypto/sha256"
 	"encoding/binary"
+	"encoding/json"
 	"io"
 	"time"
 
@@ -12,18 +14,18 @@ import (
 )
 
 type MessageHeader struct {
-	Signature []byte
-	Sender    uuid.UUID
+	PrevSignature []byte
+	Sender        uuid.UUID
 }
 
 func (m *MessageHeader) WriteTo(w io.Writer) (n int64, err error) {
-	hasSignature := pk.Boolean(len(m.Signature) > 0)
+	hasSignature := pk.Boolean(len(m.PrevSignature) > 0)
 	n, err = hasSignature.WriteTo(w)
 	if err != nil {
 		return
 	}
 	if hasSignature {
-		n2, err := pk.ByteArray(m.Signature).WriteTo(w)
+		n2, err := pk.ByteArray(m.PrevSignature).WriteTo(w)
 		n += n2
 		if err != nil {
 			return n, err
@@ -40,7 +42,7 @@ func (m *MessageHeader) ReadFrom(r io.Reader) (n int64, err error) {
 		return
 	}
 	if hasSignature {
-		n2, err := (*pk.ByteArray)(&m.Signature).ReadFrom(r)
+		n2, err := (*pk.ByteArray)(&m.PrevSignature).ReadFrom(r)
 		n += n2
 		if err != nil {
 			return n, err
@@ -51,8 +53,8 @@ func (m *MessageHeader) ReadFrom(r io.Reader) (n int64, err error) {
 }
 
 type MessageBody struct {
-	PlainMessage string
-	Message      *chat.Message
+	PlainMsg     string
+	DecoratedMsg json.RawMessage
 	Timestamp    time.Time
 	Salt         int64
 	History      []HistoryMessage
@@ -60,11 +62,11 @@ type MessageBody struct {
 
 func (m *MessageBody) WriteTo(w io.Writer) (n int64, err error) {
 	return pk.Tuple{
-		pk.String(m.PlainMessage),
-		pk.Boolean(m.Message != nil),
+		pk.String(m.PlainMsg),
+		pk.Boolean(m.DecoratedMsg != nil),
 		pk.Opt{
-			Has:   m.Message != nil,
-			Field: m.Message,
+			Has:   m.DecoratedMsg != nil,
+			Field: m.DecoratedMsg,
 		},
 		pk.Long(m.Timestamp.UnixMilli()),
 		pk.Long(m.Salt),
@@ -76,14 +78,11 @@ func (m *MessageBody) ReadFrom(r io.Reader) (n int64, err error) {
 	var hasContent pk.Boolean
 	var timestamp pk.Long
 	n, err = pk.Tuple{
-		(*pk.String)(&m.PlainMessage),
+		(*pk.String)(&m.PlainMsg),
 		&hasContent,
 		pk.Opt{
-			Has: &hasContent,
-			Field: func() pk.FieldDecoder {
-				m.Message = new(chat.Message)
-				return m.Message
-			},
+			Has:   &hasContent,
+			Field: (*pk.ByteArray)(&m.DecoratedMsg),
 		},
 		&timestamp,
 		(*pk.Long)(&m.Salt),
@@ -93,6 +92,24 @@ func (m *MessageBody) ReadFrom(r io.Reader) (n int64, err error) {
 	return
 }
 
+func (m *MessageBody) Hash() []byte {
+	hash := sha256.New()
+	binary.Write(hash, binary.BigEndian, m.Salt)
+	binary.Write(hash, binary.BigEndian, m.Timestamp.Second())
+	hash.Write([]byte(m.PlainMsg))
+	hash.Write([]byte{70})
+	if m.DecoratedMsg != nil {
+		decorated, _ := m.DecoratedMsg.MarshalJSON()
+		hash.Write(decorated)
+	}
+	for _, v := range m.History {
+		hash.Write([]byte{70})
+		hash.Write(v.Sender[:])
+		hash.Write(v.Signature)
+	}
+	return hash.Sum(nil)
+}
+
 type FilterMask struct {
 	Type byte
 	Mask pk.BitSet
@@ -176,13 +193,13 @@ func genSalt() (salt int64) {
 func Unsigned(id uuid.UUID, plain string, content *chat.Message) (msg PlayerMessage) {
 	return PlayerMessage{
 		MessageHeader: MessageHeader{
-			Signature: nil,
-			Sender:    id,
+			PrevSignature: nil,
+			Sender:        id,
 		},
 		MessageSignature: []byte{},
 		MessageBody: MessageBody{
-			PlainMessage: plain,
-			Message:      nil,
+			PlainMsg:     plain,
+			DecoratedMsg: nil,
 			Timestamp:    time.Now(),
 			Salt:         genSalt(),
 			History:      nil,
diff --git a/net/packet/types.go b/net/packet/types.go
index 7e9717a..4d522f1 100644
--- a/net/packet/types.go
+++ b/net/packet/types.go
@@ -460,11 +460,13 @@ func (b *ByteArray) ReadFrom(r io.Reader) (n int64, err error) {
 	if err != nil {
 		return n1, err
 	}
-	buf := bytes.NewBuffer(*b)
-	buf.Reset()
-	n2, err := io.CopyN(buf, r, int64(Len))
-	*b = buf.Bytes()
-	return n1 + n2, err
+	if cap(*b) < int(Len) {
+		*b = make(ByteArray, Len)
+	} else {
+		*b = (*b)[:Len]
+	}
+	n2, err := io.ReadFull(r, *b)
+	return n1 + int64(n2), err
 }
 
 func (u UUID) WriteTo(w io.Writer) (n int64, err error) {