meowlib/client/peer.go

package client

import (
	"fmt"
	"io"
	"os"
	"time"

	"forge.redroom.link/yves/meowlib"
	"github.com/google/uuid"
	"google.golang.org/protobuf/proto"
)

// Peer manages the peer messaging functions
//   - Building simple user messages
//   - Utility functions for packing/unpacking, encrypting/decrypting messages for peer communication
type Peer struct {
	Name     string `json:"name,omitempty"`
	MyName   string `json:"my_name,omitempty"`
	MyAvatar string `json:"my_avatar,omitempty"`
	//	Conversation        []InternalMessage `json:"conversation,omitempty"`
	// My own keys for that peer
	MyIdentity     meowlib.KeyPair      `json:"my_identity,omitempty"`
	MyEncryptionKp meowlib.KeyPair      `json:"my_encryption_kp,omitempty"`
	MyLookupKp     meowlib.KeyPair      `json:"my_lookup_kp,omitempty"`
	MyPullServers  []meowlib.ServerCard `json:"my_pull_servers,omitempty"`
	// Peer keys and infos
	Contact      meowlib.ContactCard `json:"contact,omitempty"`
	InvitationId string              `json:"invitation_id,omitempty"`
	// Internal management attributes
	Visible             bool      `json:"visible,omitempty"`
	VisiblePassword     string    `json:"visible_password,omitempty"`
	PasswordType        string    `json:"password_type,omitempty"`
	Blocked             bool      `json:"blocked,omitempty"`
	MessageNotification string    `json:"message_notification,omitempty"`
	OnionMode           bool      `json:"onion_mode,omitempty"`
	LastMessage         time.Time `json:"last_message,omitempty"`
	DbIds               []string  `json:"db_ids,omitempty"`
	AvatarUuid          string    `json:"avatar_uid,omitempty"`
	dbPassword          string
}

//
// Messages building
//

func (p *Peer) BuildSimpleUserMessage(message []byte) (*meowlib.UserMessage, error) {
	var msg meowlib.UserMessage
	msg.Destination = p.Contact.LookupPublicKey
	msg.From = p.MyIdentity.Public
	msg.Data = message
	msg.Type = "1"
	msg.Status = &meowlib.ConversationStatus{}
	msg.Status.LocalUuid = uuid.New().String()
	return &msg, nil
}

func (p *Peer) BuildSingleFileMessage(filename string, message []byte) ([]meowlib.UserMessage, error) {
	var msgs []meowlib.UserMessage
	fi, err := os.Stat(filename)
	if err != nil {
		return nil, err
	}
	file, err := os.Open(filename)
	if err != nil {
		return nil, err
	}
	defer file.Close()
	// declare chunk size
	maxSz := GetConfig().Chunksize
	// create buffer
	b := make([]byte, maxSz)
	chunk := 0
	for {
		// read content to buffer
		readTotal, err := file.Read(b)
		if err != nil {
			if err != io.EOF {
				return nil, err
			}
			break
		}
		var msg meowlib.UserMessage
		var file meowlib.File
		msg.Destination = p.Contact.LookupPublicKey
		msg.From = p.MyIdentity.Public
		file.Filename = fi.Name()
		file.Chunk = uint32(chunk)
		file.Data = b[:readTotal]
		file.Size = uint64(fi.Size())
		msg.Files = append(msg.Files, &file)
		msg.Type = "2"
		if chunk == 0 {
			msg.Status = &meowlib.ConversationStatus{}
			msg.Status.LocalUuid = uuid.New().String()
		}
		msgs = append(msgs, msg)
		chunk++
	}
	return msgs, nil
}

//
// Messages encryption and packaging
//

func (p *Peer) SerializeUserMessage(msg *meowlib.UserMessage) ([]byte, error) {
	out, err := proto.Marshal(msg)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (p *Peer) DeserializeUserMessage(data []byte) (*meowlib.UserMessage, error) {
	var msg meowlib.UserMessage
	err := proto.Unmarshal(data, &msg)
	if err != nil {
		return nil, err
	}
	return &msg, nil
}

// AsymEncryptMessage prepares a message to send to a specific peer contact
func (p *Peer) AsymEncryptMessage(Message []byte) (*meowlib.EncryptedMessage, error) {
	var enc *meowlib.EncryptedMessage
	enc, err := meowlib.AsymEncryptAndSign(p.Contact.EncryptionPublicKey, p.MyIdentity.Private, Message)
	if err != nil {
		fmt.Println(err.Error())
		return enc, err
	}
	return enc, err
}

// AsymDecryptMessage reads a message from a specific peer contact
func (p *Peer) AsymDecryptMessage(Message []byte, Signature []byte) (DecryptedMessage []byte, err error) {
	DecryptedMessage, err = meowlib.AsymDecryptAndCheck(p.MyEncryptionKp.Private, p.Contact.ContactPublicKey, Message, Signature)
	if err != nil {
		fmt.Println(err.Error())
		return nil, err
	}
	return DecryptedMessage, err
}

// PackUserMessage will package the previously encrypted message
func (p *Peer) PackUserMessage(message []byte, signature []byte) *meowlib.PackedUserMessage {
	var msg meowlib.PackedUserMessage
	msg.Destination = p.Contact.LookupPublicKey
	msg.Payload = message
	msg.Signature = signature
	return &msg
}

// UnPackUserMessage unpacks a user message
func (p *Peer) UnPackUserMessage(protoPackedMessage []byte) (payload []byte, signature []byte, err error) {
	msg := &meowlib.PackedServerMessage{}
	if err := proto.Unmarshal(protoPackedMessage, msg); err != nil {
		return nil, nil, err
	}
	return msg.Payload, msg.Signature, nil
}

func (p *Peer) GetConversationRequest() *meowlib.ConversationRequest {
	var cr meowlib.ConversationRequest
	return &cr
}

// ProcessOutboundUserMessage is a helper function that serializes, encrypts and packs a user message
func (p *Peer) ProcessOutboundUserMessage(usermessage *meowlib.UserMessage) (*meowlib.PackedUserMessage, error) {
	serializedMessage, err := p.SerializeUserMessage(usermessage)
	if err != nil {
		return nil, err
	}
	// Encrypting it
	enc, err := p.AsymEncryptMessage(serializedMessage)
	if err != nil {
		return nil, err
	}
	// Packing it
	packedMsg := p.PackUserMessage(enc.Data, enc.Signature)
	return packedMsg, nil
}

// ProcessInboundUserMessage is a helper function that decrypts and deserializes a user message
func (p *Peer) ProcessInboundUserMessage(message []byte, signature []byte) (*meowlib.UserMessage, error) {
	dec, err := p.AsymDecryptMessage(message, signature)
	if err != nil {
		return nil, err
	}
	msg, err := p.DeserializeUserMessage(dec)
	if err != nil {
		return nil, err
	}
	return msg, nil
}

//
// Messages database
//

// SetDbPassword sets a specific password for a hidden user, it won't be saved, but kept in memory only for the next operations
func (p *Peer) SetDbPassword(password string) {
	p.dbPassword = password
}

func (p *Peer) GetDbPassword() string {
	return p.dbPassword
}

func (p *Peer) StoreMessage(msg []byte) {

}

func (p *Peer) LoadMessage(uid string) {

}

func (p *Peer) LoadLastMessages(qty int) {

}

func (p *Peer) GetLastMessageUuid(msg []byte) {

}