2019-11-21 16:19:22 +00:00
|
|
|
package protocol
|
2019-07-17 22:25:42 +00:00
|
|
|
|
|
|
|
import (
|
|
|
|
"bytes"
|
|
|
|
"crypto/ecdsa"
|
|
|
|
"encoding/hex"
|
|
|
|
"encoding/json"
|
2019-08-06 21:50:13 +00:00
|
|
|
"strings"
|
2019-07-26 07:17:29 +00:00
|
|
|
"time"
|
|
|
|
|
2019-07-17 22:25:42 +00:00
|
|
|
"github.com/golang/protobuf/proto"
|
2019-08-06 21:50:13 +00:00
|
|
|
"github.com/pkg/errors"
|
2019-11-23 17:57:05 +00:00
|
|
|
"github.com/status-im/status-go/eth-node/crypto"
|
|
|
|
"github.com/status-im/status-go/eth-node/types"
|
2019-07-17 22:25:42 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
|
|
|
// ContentTypeTextPlain means that the message contains plain text.
|
|
|
|
ContentTypeTextPlain = "text/plain"
|
|
|
|
)
|
|
|
|
|
|
|
|
// Message types.
|
|
|
|
const (
|
|
|
|
MessageTypePublicGroup = "public-group-user-message"
|
|
|
|
MessageTypePrivate = "user-message"
|
|
|
|
MessageTypePrivateGroup = "group-user-message"
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
// ErrInvalidDecodedValue means that the decoded message is of wrong type.
|
|
|
|
// This might mean that the status message serialization tag changed.
|
|
|
|
ErrInvalidDecodedValue = errors.New("invalid decoded value type")
|
|
|
|
)
|
|
|
|
|
|
|
|
// TimestampInMs is a timestamp in milliseconds.
|
|
|
|
type TimestampInMs int64
|
|
|
|
|
|
|
|
// Time returns a time.Time instance.
|
|
|
|
func (t TimestampInMs) Time() time.Time {
|
|
|
|
ts := int64(t)
|
|
|
|
seconds := ts / 1000
|
|
|
|
return time.Unix(seconds, (ts%1000)*int64(time.Millisecond))
|
|
|
|
}
|
|
|
|
|
|
|
|
// TimestampInMsFromTime returns a TimestampInMs from a time.Time instance.
|
|
|
|
func TimestampInMsFromTime(t time.Time) TimestampInMs {
|
|
|
|
return TimestampInMs(t.UnixNano() / int64(time.Millisecond))
|
|
|
|
}
|
|
|
|
|
|
|
|
// Flags define various boolean properties of a message.
|
|
|
|
type Flags uint64
|
|
|
|
|
|
|
|
func (f *Flags) Set(val Flags) { *f = *f | val }
|
|
|
|
func (f *Flags) Clear(val Flags) { *f = *f &^ val }
|
|
|
|
func (f *Flags) Toggle(val Flags) { *f = *f ^ val }
|
|
|
|
func (f Flags) Has(val Flags) bool { return f&val != 0 }
|
|
|
|
|
|
|
|
// A list of Message flags. By default, a message is unread.
|
|
|
|
const (
|
|
|
|
MessageRead Flags = 1 << iota
|
|
|
|
)
|
|
|
|
|
|
|
|
// Message is a chat message sent by an user.
|
|
|
|
type Message struct {
|
|
|
|
Text string `json:"text"` // TODO: why is this duplicated?
|
|
|
|
ContentT string `json:"content_type"`
|
|
|
|
MessageT string `json:"message_type"`
|
|
|
|
Clock int64 `json:"clock"` // lamport timestamp; see CalcMessageClock for more details
|
|
|
|
Timestamp TimestampInMs `json:"timestamp"`
|
|
|
|
Content Content `json:"content"`
|
|
|
|
|
|
|
|
Flags Flags `json:"-"`
|
|
|
|
ID []byte `json:"-"`
|
|
|
|
SigPubKey *ecdsa.PublicKey `json:"-"`
|
2019-09-26 07:01:17 +00:00
|
|
|
ChatID string `json:"-"` // reference to Chat.ID; not connected to Content.ChatID which is set by sender
|
2019-07-17 22:25:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *Message) MarshalJSON() ([]byte, error) {
|
|
|
|
type MessageAlias Message
|
|
|
|
item := struct {
|
|
|
|
*MessageAlias
|
|
|
|
ID string `json:"id"`
|
|
|
|
}{
|
|
|
|
MessageAlias: (*MessageAlias)(m),
|
|
|
|
ID: "0x" + hex.EncodeToString(m.ID),
|
|
|
|
}
|
|
|
|
|
|
|
|
return json.Marshal(item)
|
|
|
|
}
|
|
|
|
|
|
|
|
// createTextMessage creates a Message.
|
|
|
|
func createTextMessage(data []byte, lastClock int64, chatID, messageType string) Message {
|
|
|
|
text := strings.TrimSpace(string(data))
|
|
|
|
ts := TimestampInMsFromTime(time.Now())
|
|
|
|
clock := CalcMessageClock(lastClock, ts)
|
|
|
|
|
|
|
|
return Message{
|
|
|
|
Text: text,
|
|
|
|
ContentT: ContentTypeTextPlain,
|
|
|
|
MessageT: messageType,
|
|
|
|
Clock: clock,
|
|
|
|
Timestamp: ts,
|
|
|
|
Content: Content{ChatID: chatID, Text: text},
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// CreatePublicTextMessage creates a public text Message.
|
|
|
|
func CreatePublicTextMessage(data []byte, lastClock int64, chatID string) Message {
|
2019-09-26 07:01:17 +00:00
|
|
|
m := createTextMessage(data, lastClock, chatID, MessageTypePublicGroup)
|
|
|
|
return m
|
2019-07-17 22:25:42 +00:00
|
|
|
}
|
|
|
|
|
2019-09-26 07:01:17 +00:00
|
|
|
// CreatePrivateTextMessage creates a one-to-one message.
|
2019-07-17 22:25:42 +00:00
|
|
|
func CreatePrivateTextMessage(data []byte, lastClock int64, chatID string) Message {
|
|
|
|
return createTextMessage(data, lastClock, chatID, MessageTypePrivate)
|
|
|
|
}
|
|
|
|
|
2019-09-26 07:01:17 +00:00
|
|
|
// CreatePrivateGroupTextMessage creates a group message.
|
|
|
|
func CreatePrivateGroupTextMessage(data []byte, lastClock int64, chatID string) Message {
|
|
|
|
return createTextMessage(data, lastClock, chatID, MessageTypePrivateGroup)
|
|
|
|
}
|
|
|
|
|
2019-07-26 07:17:29 +00:00
|
|
|
func decodeTransitMessage(originalPayload []byte) (interface{}, error) {
|
|
|
|
payload := make([]byte, len(originalPayload))
|
|
|
|
copy(payload, originalPayload)
|
|
|
|
// This modifies the payload
|
|
|
|
buf := bytes.NewBuffer(payload)
|
2019-07-17 22:25:42 +00:00
|
|
|
|
|
|
|
decoder := NewMessageDecoder(buf)
|
|
|
|
value, err := decoder.Decode()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return value, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// EncodeMessage encodes a Message using Transit serialization.
|
|
|
|
func EncodeMessage(value Message) ([]byte, error) {
|
|
|
|
var buf bytes.Buffer
|
|
|
|
encoder := NewMessageEncoder(&buf)
|
|
|
|
if err := encoder.Encode(value); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return buf.Bytes(), nil
|
|
|
|
}
|
|
|
|
|
2019-08-06 21:50:13 +00:00
|
|
|
// MessageID calculates the messageID from author's compressed public key
|
|
|
|
// and not encrypted but encoded payload.
|
2019-11-23 17:57:05 +00:00
|
|
|
func MessageID(author *ecdsa.PublicKey, data []byte) types.HexBytes {
|
2019-08-09 07:03:10 +00:00
|
|
|
keyBytes := crypto.FromECDSAPub(author)
|
2019-07-17 22:25:42 +00:00
|
|
|
return crypto.Keccak256(append(keyBytes, data...))
|
|
|
|
}
|
|
|
|
|
|
|
|
// WrapMessageV1 wraps a payload into a protobuf message and signs it if an identity is provided
|
|
|
|
func WrapMessageV1(payload []byte, identity *ecdsa.PrivateKey) ([]byte, error) {
|
|
|
|
var signature []byte
|
|
|
|
if identity != nil {
|
|
|
|
var err error
|
|
|
|
signature, err = crypto.Sign(crypto.Keccak256(payload), identity)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
message := &StatusProtocolMessage{
|
|
|
|
Signature: signature,
|
|
|
|
Payload: payload,
|
|
|
|
}
|
|
|
|
return proto.Marshal(message)
|
|
|
|
}
|