github.com/status-im/status-go@v1.1.0/server/pairing/server.go

package pairing

import (
	"crypto/ecdsa"
	"crypto/elliptic"
	"crypto/rand"
	"encoding/json"
	"net"
	"runtime"
	"time"

	"github.com/ethereum/go-ethereum/log"

	"go.uber.org/zap"

	"github.com/status-im/status-go/timesource"

	"github.com/status-im/status-go/api"
	"github.com/status-im/status-go/logutils"
	"github.com/status-im/status-go/server"
)

/*
|--------------------------------------------------------------------------
| type BaseServer struct {
|--------------------------------------------------------------------------
|
|
|
*/

type BaseServer struct {
	server.Server
	challengeGiver *ChallengeGiver

	config ServerConfig
}

// NewBaseServer returns a *BaseServer init from the given *SenderServerConfig
func NewBaseServer(logger *zap.Logger, e *PayloadEncryptor, config *ServerConfig) (*BaseServer, error) {
	cg, err := NewChallengeGiver(e, logger)
	if err != nil {
		return nil, err
	}

	bs := &BaseServer{
		Server: server.NewServer(
			config.Cert,
			config.ListenIP.String(),
			nil,
			logger,
		),
		challengeGiver: cg,
		config:         *config,
	}
	bs.SetTimeout(config.Timeout)
	return bs, nil
}

// MakeConnectionParams generates a *ConnectionParams based on the Server's current state
func (s *BaseServer) MakeConnectionParams() (*ConnectionParams, error) {
	return NewConnectionParams(s.config.IPAddresses, s.MustGetPort(), s.config.PK, s.config.EK, s.config.InstallationID, s.config.KeyUID), nil
}

func MakeServerConfig(config *ServerConfig) error {
	tlsKey, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
	if err != nil {
		return err
	}

	AESKey := make([]byte, 32)
	_, err = rand.Read(AESKey)
	if err != nil {
		return err
	}

	ips, err := server.GetLocalAddressesForPairingServer()
	if err != nil {
		return err
	}

	now := timesource.GetCurrentTime()
	log.Debug("pairing server generate cert", "system time", time.Now().String(), "timesource time", now.String())
	tlsCert, _, err := GenerateCertFromKey(tlsKey, now, ips, []string{})
	if err != nil {
		return err
	}

	config.PK = &tlsKey.PublicKey
	config.EK = AESKey
	config.Cert = &tlsCert
	config.IPAddresses = ips
	config.ListenIP = net.IPv4zero

	return nil
}

/*
|--------------------------------------------------------------------------
| type SenderServer struct {
|--------------------------------------------------------------------------
|
| With AccountPayloadMounter, RawMessagePayloadMounter and InstallationPayloadMounterReceiver
|
*/

type SenderServer struct {
	*BaseServer
	accountMounter      PayloadMounter
	rawMessageMounter   PayloadMounter
	installationMounter PayloadMounterReceiver
	backend             *api.GethStatusBackend
}

// NewSenderServer returns a *SenderServer init from the given *SenderServerConfig
func NewSenderServer(backend *api.GethStatusBackend, config *SenderServerConfig) (*SenderServer, error) {
	logger := logutils.ZapLogger().Named("SenderServer")
	e := NewPayloadEncryptor(config.ServerConfig.EK)

	bs, err := NewBaseServer(logger, e, config.ServerConfig)
	if err != nil {
		return nil, err
	}

	am, rmm, imr, err := NewPayloadMounters(logger, e, backend, config.SenderConfig)
	if err != nil {
		return nil, err
	}

	return &SenderServer{
		BaseServer:          bs,
		accountMounter:      am,
		rawMessageMounter:   rmm,
		installationMounter: imr,
		backend:             backend,
	}, nil
}

func (s *SenderServer) startSendingData() error {
	logger := s.GetLogger()
	beforeSending := func() {
		if s.backend != nil {
			err := s.backend.LocalPairingStarted()
			if err != nil {
				logger.Error("startSendingData backend.LocalPairingStarted()", zap.Error(err))
			}
		}
	}
	s.SetHandlers(server.HandlerPatternMap{
		pairingChallenge:      handlePairingChallenge(s.challengeGiver),
		pairingSendAccount:    middlewareChallenge(s.challengeGiver, handleSendAccount(logger, s.accountMounter, beforeSending)),
		pairingSendSyncDevice: middlewareChallenge(s.challengeGiver, handlePairingSyncDeviceSend(logger, s.rawMessageMounter, beforeSending)),
		// TODO implement refactor of installation data exchange to follow the send/receive pattern of
		//  the other handlers.
		//  https://github.com/status-im/status-go/issues/3304
		// receive installation data from receiver
		pairingReceiveInstallation: middlewareChallenge(s.challengeGiver, handleReceiveInstallation(s.GetLogger(), s.installationMounter)),
	})
	return s.Start()
}

// MakeFullSenderServer generates a fully configured and randomly seeded SenderServer
func MakeFullSenderServer(backend *api.GethStatusBackend, config *SenderServerConfig) (*SenderServer, error) {
	config.ServerConfig.InstallationID = backend.InstallationID()
	config.ServerConfig.KeyUID = backend.KeyUID()
	err := MakeServerConfig(config.ServerConfig)
	if err != nil {
		return nil, err
	}

	config.SenderConfig.DB = backend.GetMultiaccountDB()
	return NewSenderServer(backend, config)
}

// StartUpSenderServer generates a SenderServer, starts the sending server
// and returns the ConnectionParams string to allow a ReceiverClient to make a successful connection.
func StartUpSenderServer(backend *api.GethStatusBackend, configJSON string) (string, error) {
	conf := NewSenderServerConfig()
	err := json.Unmarshal([]byte(configJSON), conf)
	if err != nil {
		return "", err
	}
	if len(conf.SenderConfig.ChatKey) == 0 {
		err = validateAndVerifyPassword(conf, conf.SenderConfig)
		if err != nil {
			return "", err
		}
	}

	ps, err := MakeFullSenderServer(backend, conf)
	if err != nil {
		return "", err
	}

	err = ps.startSendingData()
	if err != nil {
		return "", err
	}

	cp, err := ps.MakeConnectionParams()
	if err != nil {
		return "", err
	}

	return cp.ToString(), nil
}

/*
|--------------------------------------------------------------------------
| ReceiverServer
|--------------------------------------------------------------------------
|
| With AccountPayloadReceiver, RawMessagePayloadReceiver, InstallationPayloadMounterReceiver
|
*/

type ReceiverServer struct {
	*BaseServer
	accountReceiver      PayloadReceiver
	rawMessageReceiver   PayloadReceiver
	installationReceiver PayloadMounterReceiver
	backend              *api.GethStatusBackend
}

// NewReceiverServer returns a *SenderServer init from the given *ReceiverServerConfig
func NewReceiverServer(backend *api.GethStatusBackend, config *ReceiverServerConfig) (*ReceiverServer, error) {
	logger := logutils.ZapLogger().Named("SenderServer")
	e := NewPayloadEncryptor(config.ServerConfig.EK)

	bs, err := NewBaseServer(logger, e, config.ServerConfig)
	if err != nil {
		return nil, err
	}

	ar, rmr, imr, err := NewPayloadReceivers(logger, e, backend, config.ReceiverConfig)
	if err != nil {
		return nil, err
	}

	return &ReceiverServer{
		BaseServer:           bs,
		accountReceiver:      ar,
		rawMessageReceiver:   rmr,
		installationReceiver: imr,
		backend:              backend,
	}, nil
}

func (s *ReceiverServer) startReceivingData() error {
	logger := s.GetLogger()
	beforeSending := func() {
		if s.backend != nil {
			err := s.backend.LocalPairingStarted()
			if err != nil {
				logger.Error("startSendingData backend.LocalPairingStarted()", zap.Error(err))
			}
		}
	}
	s.SetHandlers(server.HandlerPatternMap{
		pairingChallenge:         handlePairingChallenge(s.challengeGiver),
		pairingReceiveAccount:    handleReceiveAccount(logger, s.accountReceiver),
		pairingReceiveSyncDevice: handleParingSyncDeviceReceive(logger, s.rawMessageReceiver),
		// TODO implement refactor of installation data exchange to follow the send/receive pattern of
		//  the other handlers.
		//  https://github.com/status-im/status-go/issues/3304
		// send installation data back to sender
		pairingSendInstallation: middlewareChallenge(s.challengeGiver, handleSendInstallation(logger, s.installationReceiver, beforeSending)),
	})
	return s.Start()
}

// MakeFullReceiverServer generates a fully configured and randomly seeded ReceiverServer
func MakeFullReceiverServer(backend *api.GethStatusBackend, config *ReceiverServerConfig) (*ReceiverServer, error) {
	config.ServerConfig.InstallationID = backend.InstallationID()
	config.ServerConfig.KeyUID = backend.KeyUID()

	err := MakeServerConfig(config.ServerConfig)
	if err != nil {
		return nil, err
	}

	// ignore err because we allow no active account here
	activeAccount, _ := backend.GetActiveAccount()
	if activeAccount != nil {
		config.ReceiverConfig.LoggedInKeyUID = activeAccount.KeyUID
	}
	config.ReceiverConfig.DB = backend.GetMultiaccountDB()

	return NewReceiverServer(backend, config)
}

// StartUpReceiverServer generates a ReceiverServer, starts the sending server
// and returns the ConnectionParams string to allow a SenderClient to make a successful connection.
func StartUpReceiverServer(backend *api.GethStatusBackend, configJSON string) (string, error) {
	conf := NewReceiverServerConfig()
	err := json.Unmarshal([]byte(configJSON), conf)
	if err != nil {
		return "", err
	}

	// This is a temporal solution to allow clients not to pass DeviceType.
	// Check DeviceType deprecation reason for more info.
	conf.ReceiverConfig.DeviceType = runtime.GOOS

	err = validateReceiverConfig(conf, conf.ReceiverConfig)
	if err != nil {
		return "", err
	}

	ps, err := MakeFullReceiverServer(backend, conf)
	if err != nil {
		return "", err
	}

	err = ps.startReceivingData()
	if err != nil {
		return "", err
	}

	cp, err := ps.MakeConnectionParams()
	if err != nil {
		return "", err
	}

	return cp.ToString(), nil
}

/*
|--------------------------------------------------------------------------
| type KeystoreFilesSenderServer struct {
|--------------------------------------------------------------------------
*/

type KeystoreFilesSenderServer struct {
	*BaseServer
	keystoreFilesMounter PayloadMounter
	backend              *api.GethStatusBackend
}

func NewKeystoreFilesSenderServer(backend *api.GethStatusBackend, config *KeystoreFilesSenderServerConfig) (*KeystoreFilesSenderServer, error) {
	logger := logutils.ZapLogger().Named("SenderServer")
	e := NewPayloadEncryptor(config.ServerConfig.EK)

	bs, err := NewBaseServer(logger, e, config.ServerConfig)
	if err != nil {
		return nil, err
	}

	kfm, err := NewKeystoreFilesPayloadMounter(backend, e, config.SenderConfig, logger)
	if err != nil {
		return nil, err
	}

	return &KeystoreFilesSenderServer{
		BaseServer:           bs,
		keystoreFilesMounter: kfm,
		backend:              backend,
	}, nil
}

func (s *KeystoreFilesSenderServer) startSendingData() error {
	logger := s.GetLogger()
	beforeSending := func() {
		if s.backend != nil {
			err := s.backend.LocalPairingStarted()
			if err != nil {
				logger.Error("startSendingData backend.LocalPairingStarted()", zap.Error(err))
			}
		}
	}
	s.SetHandlers(server.HandlerPatternMap{
		pairingChallenge:   handlePairingChallenge(s.challengeGiver),
		pairingSendAccount: middlewareChallenge(s.challengeGiver, handleSendAccount(logger, s.keystoreFilesMounter, beforeSending)),
	})
	return s.Start()
}

// MakeFullSenderServer generates a fully configured and randomly seeded KeystoreFilesSenderServer
func MakeKeystoreFilesSenderServer(backend *api.GethStatusBackend, config *KeystoreFilesSenderServerConfig) (*KeystoreFilesSenderServer, error) {
	config.ServerConfig.InstallationID = backend.InstallationID()
	config.ServerConfig.KeyUID = backend.KeyUID()

	err := MakeServerConfig(config.ServerConfig)
	if err != nil {
		return nil, err
	}

	return NewKeystoreFilesSenderServer(backend, config)
}

// StartUpKeystoreFilesSenderServer generates a KeystoreFilesSenderServer, starts the sending server
// and returns the ConnectionParams string to allow a ReceiverClient to make a successful connection.
func StartUpKeystoreFilesSenderServer(backend *api.GethStatusBackend, configJSON string) (string, error) {
	conf := NewKeystoreFilesSenderServerConfig()
	err := json.Unmarshal([]byte(configJSON), conf)
	if err != nil {
		return "", err
	}

	err = validateKeystoreFilesConfig(backend, conf)
	if err != nil {
		return "", err
	}

	ps, err := MakeKeystoreFilesSenderServer(backend, conf)
	if err != nil {
		return "", err
	}

	err = ps.startSendingData()
	if err != nil {
		return "", err
	}

	cp, err := ps.MakeConnectionParams()
	if err != nil {
		return "", err
	}

	return cp.ToString(), nil
}