status-go/server/pairing/server.go

408 lines
11 KiB
Go
Raw Normal View History

package pairing
import (
"crypto/ecdsa"
2022-08-31 11:44:12 +00:00
"crypto/elliptic"
2022-08-19 12:45:50 +00:00
"crypto/rand"
"encoding/json"
"net"
2022-08-31 11:44:12 +00:00
"time"
2022-08-19 12:45:50 +00:00
"github.com/ethereum/go-ethereum/log"
"go.uber.org/zap"
"github.com/status-im/status-go/timesource"
"github.com/status-im/status-go/api"
2022-10-21 12:15:39 +00:00
"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
}
2022-07-01 15:37:53 +00:00
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), 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
2023-03-30 10:00:32 +00:00
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)),
2022-08-19 12:45:50 +00:00
})
return s.Start()
}
2022-08-31 11:44:12 +00:00
// MakeFullSenderServer generates a fully configured and randomly seeded SenderServer
2023-03-21 13:08:28 +00:00
func MakeFullSenderServer(backend *api.GethStatusBackend, config *SenderServerConfig) (*SenderServer, error) {
err := MakeServerConfig(config.ServerConfig)
2022-08-31 11:44:12 +00:00
if err != nil {
return nil, err
}
config.SenderConfig.DB = backend.GetMultiaccountDB()
return NewSenderServer(backend, config)
}
2023-03-21 13:08:28 +00:00
// StartUpSenderServer generates a SenderServer, starts the sending server
// and returns the ConnectionParams string to allow a ReceiverClient to make a successful connection.
2023-03-21 13:08:28 +00:00
func StartUpSenderServer(backend *api.GethStatusBackend, configJSON string) (string, error) {
conf := NewSenderServerConfig()
err := json.Unmarshal([]byte(configJSON), conf)
2022-08-31 11:44:12 +00:00
if err != nil {
return "", err
2022-08-31 11:44:12 +00:00
}
if len(conf.SenderConfig.ChatKey) == 0 {
err = validateAndVerifyPassword(conf, conf.SenderConfig)
if err != nil {
return "", err
}
2023-03-29 15:51:01 +00:00
}
2022-08-31 11:44:12 +00:00
2023-03-21 13:08:28 +00:00
ps, err := MakeFullSenderServer(backend, conf)
2022-08-31 11:44:12 +00:00
if err != nil {
return "", err
2022-08-31 11:44:12 +00:00
}
err = ps.startSendingData()
2022-08-31 11:44:12 +00:00
if err != nil {
return "", err
2022-08-31 11:44:12 +00:00
}
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
}
2022-08-31 11:44:12 +00:00
return &ReceiverServer{
BaseServer: bs,
accountReceiver: ar,
rawMessageReceiver: rmr,
installationReceiver: imr,
backend: backend,
}, nil
}
2022-08-31 11:44:12 +00:00
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)),
2022-08-31 11:44:12 +00:00
})
return s.Start()
}
// MakeFullReceiverServer generates a fully configured and randomly seeded ReceiverServer
2023-03-21 13:08:28 +00:00
func MakeFullReceiverServer(backend *api.GethStatusBackend, config *ReceiverServerConfig) (*ReceiverServer, error) {
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)
2022-08-31 11:44:12 +00:00
}
2023-03-21 13:08:28 +00:00
// StartUpReceiverServer generates a ReceiverServer, starts the sending server
// and returns the ConnectionParams string to allow a SenderClient to make a successful connection.
2023-03-21 13:08:28 +00:00
func StartUpReceiverServer(backend *api.GethStatusBackend, configJSON string) (string, error) {
conf := NewReceiverServerConfig()
err := json.Unmarshal([]byte(configJSON), conf)
if err != nil {
return "", err
}
2023-03-29 15:51:01 +00:00
err = validateAndVerifyNodeConfig(conf, conf.ReceiverConfig)
if err != nil {
return "", err
}
2023-03-21 13:08:28 +00:00
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) {
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
}