package pairing import ( "context" "encoding/json" "errors" "fmt" "os" "path/filepath" "reflect" "strings" "testing" "time" "go.uber.org/zap" "github.com/status-im/status-go/common/dbsetup" "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/protocol" "github.com/status-im/status-go/protocol/encryption/multidevice" "github.com/status-im/status-go/protocol/tt" "github.com/google/uuid" "github.com/stretchr/testify/require" "github.com/stretchr/testify/suite" "github.com/status-im/status-go/account/generator" "github.com/status-im/status-go/api" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/multiaccounts" "github.com/status-im/status-go/multiaccounts/accounts" "github.com/status-im/status-go/multiaccounts/settings" "github.com/status-im/status-go/params" "github.com/status-im/status-go/protocol/common" "github.com/status-im/status-go/protocol/identity/alias" "github.com/status-im/status-go/protocol/protobuf" "github.com/status-im/status-go/protocol/requests" accservice "github.com/status-im/status-go/services/accounts" "github.com/status-im/status-go/services/browsers" ) const ( pathWalletRoot = "m/44'/60'/0'/0" pathEIP1581 = "m/43'/60'/1581'" pathDefaultChat = pathEIP1581 + "/0'/0" pathDefaultWallet = pathWalletRoot + "/0" currentNetwork = "mainnet_rpc" socialLinkURL = "https://github.com/status-im" ensUsername = "bob.stateofus.eth" ensChainID = 1 publicChatID = "localpairtest" profileKeypairMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon" seedKeypairMnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about" profileKeypairMnemonic1 = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about about" seedKeypairMnemonic1 = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about abandon" path0 = "m/44'/60'/0'/0/0" path1 = "m/44'/60'/0'/0/1" expectedKDFIterations = 1024 ) var paths = []string{pathWalletRoot, pathEIP1581, pathDefaultChat, pathDefaultWallet} func TestSyncDeviceSuite(t *testing.T) { suite.Run(t, new(SyncDeviceSuite)) } type SyncDeviceSuite struct { suite.Suite logger *zap.Logger password string tmpdir string } func (s *SyncDeviceSuite) SetupTest() { s.logger = tt.MustCreateTestLogger() s.password = "password" s.tmpdir = s.T().TempDir() } func (s *SyncDeviceSuite) prepareBackendWithAccount(mnemonic, tmpdir string) *api.GethStatusBackend { backend := s.prepareBackendWithoutAccount(tmpdir) accountManager := backend.AccountManager() accGenerator := accountManager.AccountsGenerator() var ( generatedAccountInfo generator.GeneratedAndDerivedAccountInfo err error ) if len(mnemonic) > 0 { generatedAccountInfo.GeneratedAccountInfo, err = accGenerator.ImportMnemonic(mnemonic, "") require.NoError(s.T(), err) generatedAccountInfo.Derived, err = accGenerator.DeriveAddresses(generatedAccountInfo.ID, paths) require.NoError(s.T(), err) } else { generatedAccountInfos, err := accGenerator.GenerateAndDeriveAddresses(12, 1, "", paths) require.NoError(s.T(), err) generatedAccountInfo = generatedAccountInfos[0] } account := multiaccounts.Account{ KeyUID: generatedAccountInfo.KeyUID, KDFIterations: dbsetup.ReducedKDFIterationsNumber, } err = accountManager.InitKeystore(filepath.Join(tmpdir, keystoreDir, account.KeyUID)) require.NoError(s.T(), err) err = backend.OpenAccounts() require.NoError(s.T(), err) derivedAddresses := generatedAccountInfo.Derived _, err = accGenerator.StoreDerivedAccounts(generatedAccountInfo.ID, s.password, paths) require.NoError(s.T(), err) settings, err := defaultSettings(generatedAccountInfo.GeneratedAccountInfo, derivedAddresses, nil) require.NoError(s.T(), err) account.Name = settings.Name nodeConfig, err := nodeConfigForLocalPairSync(settings.InstallationID, account.KeyUID, tmpdir) nodeConfig.RootDataDir = tmpdir require.NoError(s.T(), err) require.NoError(s.T(), setDefaultNodeConfig(nodeConfig)) walletDerivedAccount := derivedAddresses[pathDefaultWallet] walletAccount := &accounts.Account{ PublicKey: types.Hex2Bytes(walletDerivedAccount.PublicKey), KeyUID: generatedAccountInfo.KeyUID, Address: types.HexToAddress(walletDerivedAccount.Address), ColorID: "", Wallet: true, Path: pathDefaultWallet, Name: "Ethereum account", } chatDerivedAccount := derivedAddresses[pathDefaultChat] chatAccount := &accounts.Account{ PublicKey: types.Hex2Bytes(chatDerivedAccount.PublicKey), KeyUID: generatedAccountInfo.KeyUID, Address: types.HexToAddress(chatDerivedAccount.Address), Name: settings.Name, Chat: true, Path: pathDefaultChat, } accounts := []*accounts.Account{walletAccount, chatAccount} err = backend.StartNodeWithAccountAndInitialConfig(account, s.password, *settings, nodeConfig, accounts, nil) require.NoError(s.T(), err) multiaccounts, err := backend.GetAccounts() require.NoError(s.T(), err) require.NotEmpty(s.T(), multiaccounts[0].ColorHash) return backend } func (s *SyncDeviceSuite) prepareBackendWithoutAccount(tmpdir string) *api.GethStatusBackend { backend := api.NewGethStatusBackend() backend.UpdateRootDataDir(tmpdir) return backend } func (s *SyncDeviceSuite) pairAccounts(serverBackend *api.GethStatusBackend, serverDir string, clientBackend *api.GethStatusBackend, clientDir string) { // Start sender server serverActiveAccount, err := serverBackend.GetActiveAccount() require.NoError(s.T(), err) serverKeystorePath := filepath.Join(serverDir, keystoreDir, serverActiveAccount.KeyUID) serverConfig := &SenderServerConfig{ SenderConfig: &SenderConfig{ KeystorePath: serverKeystorePath, DeviceType: "desktop", KeyUID: serverActiveAccount.KeyUID, Password: s.password, }, ServerConfig: new(ServerConfig), } configBytes, err := json.Marshal(serverConfig) require.NoError(s.T(), err) connectionString, err := StartUpSenderServer(serverBackend, string(configBytes)) require.NoError(s.T(), err) // Start receiving client err = clientBackend.AccountManager().InitKeystore(filepath.Join(clientDir, keystoreDir)) require.NoError(s.T(), err) err = clientBackend.OpenAccounts() require.NoError(s.T(), err) clientNodeConfig, err := nodeConfigForLocalPairSync(uuid.New().String(), "", clientDir) require.NoError(s.T(), err) clientKeystoreDir := filepath.Join(clientDir, keystoreDir) clientPayloadSourceConfig := ReceiverClientConfig{ ReceiverConfig: &ReceiverConfig{ KeystorePath: clientKeystoreDir, DeviceType: "desktop", KDFIterations: expectedKDFIterations, NodeConfig: clientNodeConfig, SettingCurrentNetwork: currentNetwork, }, ClientConfig: new(ClientConfig), } clientNodeConfig.RootDataDir = clientDir clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) require.NoError(s.T(), err) err = StartUpReceivingClient(clientBackend, connectionString, string(clientConfigBytes)) require.NoError(s.T(), err) require.True(s.T(), serverBackend.Messenger().HasPairedDevices()) require.True(s.T(), clientBackend.Messenger().HasPairedDevices()) } func (s *SyncDeviceSuite) sendContactRequest(request *requests.SendContactRequest, messenger *protocol.Messenger) { senderPublicKey := common.PubkeyToHex(messenger.IdentityPublicKey()) s.logger.Info("sendContactRequest", zap.String("sender", senderPublicKey), zap.String("receiver", request.ID)) resp, err := messenger.SendContactRequest(context.Background(), request) s.Require().NoError(err) s.Require().NotNil(resp) } func (s *SyncDeviceSuite) receiveContactRequest(messageText string, messenger *protocol.Messenger) *common.Message { receiverPublicKey := types.EncodeHex(crypto.FromECDSAPub(messenger.IdentityPublicKey())) s.logger.Info("receiveContactRequest", zap.String("receiver", receiverPublicKey)) // Wait for the message to reach its destination resp, err := protocol.WaitOnMessengerResponse( messenger, func(r *protocol.MessengerResponse) bool { return len(r.Contacts) == 1 && len(r.Messages()) == 2 && len(r.ActivityCenterNotifications()) == 1 }, "no messages", ) s.Require().NoError(err) s.Require().NotNil(resp) contactRequest := protocol.FindFirstByContentType(resp.Messages(), protobuf.ChatMessage_CONTACT_REQUEST) s.Require().NotNil(contactRequest) return contactRequest } func (s *SyncDeviceSuite) acceptContactRequest(contactRequest *common.Message, sender *protocol.Messenger, receiver *protocol.Messenger) { senderPublicKey := types.EncodeHex(crypto.FromECDSAPub(sender.IdentityPublicKey())) receiverPublicKey := types.EncodeHex(crypto.FromECDSAPub(receiver.IdentityPublicKey())) s.logger.Info("acceptContactRequest", zap.String("sender", senderPublicKey), zap.String("receiver", receiverPublicKey)) _, err := receiver.AcceptContactRequest(context.Background(), &requests.AcceptContactRequest{ID: types.Hex2Bytes(contactRequest.ID)}) s.Require().NoError(err) // Wait for the message to reach its destination resp, err := protocol.WaitOnMessengerResponse( sender, func(r *protocol.MessengerResponse) bool { return len(r.Contacts) == 1 && len(r.Messages()) == 2 && len(r.ActivityCenterNotifications()) == 1 }, "no messages", ) s.Require().NoError(err) s.Require().NotNil(resp) } func (s *SyncDeviceSuite) checkMutualContact(backend *api.GethStatusBackend, contactPublicKey string) { messenger := backend.Messenger() contacts := messenger.MutualContacts() s.Require().Len(contacts, 1) contact := contacts[0] s.Require().Equal(contactPublicKey, contact.ID) s.Require().Equal(protocol.ContactRequestStateSent, contact.ContactRequestLocalState) s.Require().Equal(protocol.ContactRequestStateReceived, contact.ContactRequestRemoteState) s.Require().NotNil(contact.DisplayName) } func (s *SyncDeviceSuite) TestPairingSyncDeviceClientAsSender() { clientTmpDir := filepath.Join(s.tmpdir, "client") clientBackend := s.prepareBackendWithAccount("", clientTmpDir) serverTmpDir := filepath.Join(s.tmpdir, "server") serverBackend := s.prepareBackendWithoutAccount(serverTmpDir) defer func() { require.NoError(s.T(), serverBackend.Logout()) require.NoError(s.T(), clientBackend.Logout()) }() ctx := context.TODO() err := serverBackend.AccountManager().InitKeystore(filepath.Join(serverTmpDir, keystoreDir)) require.NoError(s.T(), err) err = serverBackend.OpenAccounts() require.NoError(s.T(), err) serverNodeConfig, err := nodeConfigForLocalPairSync(uuid.New().String(), "", serverTmpDir) require.NoError(s.T(), err) serverKeystoreDir := filepath.Join(serverTmpDir, keystoreDir) serverPayloadSourceConfig := &ReceiverServerConfig{ ReceiverConfig: &ReceiverConfig{ NodeConfig: serverNodeConfig, KeystorePath: serverKeystoreDir, DeviceType: "desktop", KDFIterations: expectedKDFIterations, SettingCurrentNetwork: currentNetwork, }, ServerConfig: new(ServerConfig), } serverNodeConfig.RootDataDir = serverTmpDir serverConfigBytes, err := json.Marshal(serverPayloadSourceConfig) require.NoError(s.T(), err) cs, err := StartUpReceiverServer(serverBackend, string(serverConfigBytes)) require.NoError(s.T(), err) // generate some data for the client // generate bookmark clientBrowserAPI := clientBackend.StatusNode().BrowserService().APIs()[0].Service.(*browsers.API) _, err = clientBrowserAPI.StoreBookmark(ctx, browsers.Bookmark{ Name: "status.im", URL: "https://status.im", }) require.NoError(s.T(), err) // generate ens username err = clientBackend.StatusNode().EnsService().API().Add(ctx, ensChainID, ensUsername) require.NoError(s.T(), err) // generate profile showcase preferences profileShowcasePreferences := protocol.DummyProfileShowcasePreferences(false) err = clientBackend.Messenger().SetProfileShowcasePreferences(profileShowcasePreferences, false) require.NoError(s.T(), err) // startup sending client clientActiveAccount, err := clientBackend.GetActiveAccount() require.NoError(s.T(), err) clientKeystorePath := filepath.Join(clientTmpDir, keystoreDir, clientActiveAccount.KeyUID) clientPayloadSourceConfig := SenderClientConfig{ SenderConfig: &SenderConfig{ KeystorePath: clientKeystorePath, DeviceType: "android", KeyUID: clientActiveAccount.KeyUID, Password: s.password, }, ClientConfig: new(ClientConfig), } clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) require.NoError(s.T(), err) err = StartUpSendingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) // check that the server has the same data as the client serverBrowserAPI := serverBackend.StatusNode().BrowserService().APIs()[0].Service.(*browsers.API) bookmarks, err := serverBrowserAPI.GetBookmarks(ctx) require.NoError(s.T(), err) require.Equal(s.T(), 1, len(bookmarks)) require.Equal(s.T(), "status.im", bookmarks[0].Name) uds, err := serverBackend.StatusNode().EnsService().API().GetEnsUsernames(ctx) require.NoError(s.T(), err) require.Equal(s.T(), 1, len(uds)) require.Equal(s.T(), ensUsername, uds[0].Username) require.Equal(s.T(), uint64(ensChainID), uds[0].ChainID) require.False(s.T(), uds[0].Removed) require.Greater(s.T(), uds[0].Clock, uint64(0)) serverProfileShowcasePreferences, err := serverBackend.Messenger().GetProfileShowcasePreferences() require.NoError(s.T(), err) require.True(s.T(), reflect.DeepEqual(profileShowcasePreferences, serverProfileShowcasePreferences)) serverActiveAccount, err := serverBackend.GetActiveAccount() require.NoError(s.T(), err) require.Equal(s.T(), serverActiveAccount.Name, clientActiveAccount.Name) require.Equal(s.T(), serverActiveAccount.KDFIterations, expectedKDFIterations) serverMessenger := serverBackend.Messenger() clientMessenger := clientBackend.Messenger() require.True(s.T(), serverMessenger.HasPairedDevices()) require.True(s.T(), clientMessenger.HasPairedDevices()) err = clientMessenger.DisableInstallation(serverNodeConfig.ShhextConfig.InstallationID) require.NoError(s.T(), err) require.False(s.T(), clientMessenger.HasPairedDevices()) clientNodeConfig, err := clientBackend.GetNodeConfig() require.NoError(s.T(), err) err = serverMessenger.DisableInstallation(clientNodeConfig.ShhextConfig.InstallationID) require.NoError(s.T(), err) require.False(s.T(), serverMessenger.HasPairedDevices()) // repeat local pairing, we should expect no error after receiver logged in cs, err = StartUpReceiverServer(serverBackend, string(serverConfigBytes)) require.NoError(s.T(), err) err = StartUpSendingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) require.True(s.T(), clientMessenger.HasPairedDevices()) require.True(s.T(), serverMessenger.HasPairedDevices()) // test if it's okay when account already exist but not logged in require.NoError(s.T(), serverBackend.Logout()) cs, err = StartUpReceiverServer(serverBackend, string(serverConfigBytes)) require.NoError(s.T(), err) err = StartUpSendingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) } func (s *SyncDeviceSuite) TestPairingSyncDeviceClientAsReceiver() { clientTmpDir := filepath.Join(s.tmpdir, "client") clientBackend := s.prepareBackendWithoutAccount(clientTmpDir) ctx := context.TODO() serverTmpDir := filepath.Join(s.tmpdir, "server") serverBackend := s.prepareBackendWithAccount("", serverTmpDir) defer func() { require.NoError(s.T(), clientBackend.Logout()) require.NoError(s.T(), serverBackend.Logout()) }() serverActiveAccount, err := serverBackend.GetActiveAccount() require.NoError(s.T(), err) serverKeystorePath := filepath.Join(serverTmpDir, keystoreDir, serverActiveAccount.KeyUID) var config = &SenderServerConfig{ SenderConfig: &SenderConfig{ KeystorePath: serverKeystorePath, DeviceType: "desktop", KeyUID: serverActiveAccount.KeyUID, Password: s.password, }, ServerConfig: new(ServerConfig), } configBytes, err := json.Marshal(config) require.NoError(s.T(), err) cs, err := StartUpSenderServer(serverBackend, string(configBytes)) require.NoError(s.T(), err) // generate some data for the server // generate bookmark serverBrowserAPI := serverBackend.StatusNode().BrowserService().APIs()[0].Service.(*browsers.API) _, err = serverBrowserAPI.StoreBookmark(ctx, browsers.Bookmark{ Name: "status.im", URL: "https://status.im", }) require.NoError(s.T(), err) serverMessenger := serverBackend.Messenger() // generate ens username err = serverBackend.StatusNode().EnsService().API().Add(ctx, ensChainID, ensUsername) require.NoError(s.T(), err) // generate profile showcase preferences profileShowcasePreferences := protocol.DummyProfileShowcasePreferences(false) err = serverMessenger.SetProfileShowcasePreferences(profileShowcasePreferences, false) require.NoError(s.T(), err) // generate local deleted message _, err = serverMessenger.CreatePublicChat(&requests.CreatePublicChat{ID: publicChatID}) require.NoError(s.T(), err) serverChat := serverMessenger.Chat(publicChatID) serverMessage := buildTestMessage(serverChat) serverMessengerResponse, err := serverMessenger.SendChatMessage(ctx, serverMessage) require.NoError(s.T(), err) require.Equal(s.T(), 1, len(serverMessengerResponse.Messages())) serverMessageID := serverMessengerResponse.Messages()[0].ID _, err = serverMessenger.DeleteMessageForMeAndSync(ctx, publicChatID, serverMessageID) require.NoError(s.T(), err) err = clientBackend.AccountManager().InitKeystore(filepath.Join(clientTmpDir, keystoreDir)) require.NoError(s.T(), err) err = clientBackend.OpenAccounts() require.NoError(s.T(), err) clientNodeConfig, err := nodeConfigForLocalPairSync(uuid.New().String(), "", clientTmpDir) require.NoError(s.T(), err) clientKeystoreDir := filepath.Join(clientTmpDir, keystoreDir) clientPayloadSourceConfig := ReceiverClientConfig{ ReceiverConfig: &ReceiverConfig{ KeystorePath: clientKeystoreDir, DeviceType: "iphone", KDFIterations: expectedKDFIterations, NodeConfig: clientNodeConfig, SettingCurrentNetwork: currentNetwork, }, ClientConfig: new(ClientConfig), } clientNodeConfig.RootDataDir = clientTmpDir clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) require.NoError(s.T(), err) err = StartUpReceivingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) // check that the client has the same data as the server clientMessenger := clientBackend.Messenger() clientBrowserAPI := clientBackend.StatusNode().BrowserService().APIs()[0].Service.(*browsers.API) bookmarks, err := clientBrowserAPI.GetBookmarks(ctx) require.NoError(s.T(), err) require.Equal(s.T(), 1, len(bookmarks)) require.Equal(s.T(), "status.im", bookmarks[0].Name) clientProfileShowcasePreferences, err := clientMessenger.GetProfileShowcasePreferences() require.NoError(s.T(), err) require.True(s.T(), reflect.DeepEqual(profileShowcasePreferences, clientProfileShowcasePreferences)) uds, err := clientBackend.StatusNode().EnsService().API().GetEnsUsernames(ctx) require.NoError(s.T(), err) require.Equal(s.T(), 1, len(uds)) require.Equal(s.T(), ensUsername, uds[0].Username) require.Equal(s.T(), uint64(ensChainID), uds[0].ChainID) deleteForMeMessages, err := clientMessenger.GetDeleteForMeMessages() require.NoError(s.T(), err) require.Equal(s.T(), 1, len(deleteForMeMessages)) clientActiveAccount, err := clientBackend.GetActiveAccount() require.NoError(s.T(), err) require.Equal(s.T(), serverActiveAccount.Name, clientActiveAccount.Name) require.Equal(s.T(), clientActiveAccount.KDFIterations, expectedKDFIterations) require.True(s.T(), serverMessenger.HasPairedDevices()) require.True(s.T(), clientMessenger.HasPairedDevices()) err = serverMessenger.DisableInstallation(clientNodeConfig.ShhextConfig.InstallationID) require.NoError(s.T(), err) require.False(s.T(), serverMessenger.HasPairedDevices()) serverNodeConfig, err := serverBackend.GetNodeConfig() require.NoError(s.T(), err) err = clientMessenger.DisableInstallation(serverNodeConfig.ShhextConfig.InstallationID) require.NoError(s.T(), err) require.False(s.T(), clientMessenger.HasPairedDevices()) // repeat local pairing, we should expect no error after receiver logged in cs, err = StartUpSenderServer(serverBackend, string(configBytes)) require.NoError(s.T(), err) err = StartUpReceivingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) require.True(s.T(), serverMessenger.HasPairedDevices()) require.True(s.T(), clientMessenger.HasPairedDevices()) // test if it's okay when account already exist but not logged in require.NoError(s.T(), clientBackend.Logout()) cs, err = StartUpSenderServer(serverBackend, string(configBytes)) require.NoError(s.T(), err) err = StartUpReceivingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) } func (s *SyncDeviceSuite) TestPairingThreeDevices() { bobTmpDir := filepath.Join(s.tmpdir, "bob") bobBackend := s.prepareBackendWithAccount("", bobTmpDir) bobMessenger := bobBackend.Messenger() _, err := bobMessenger.Start() s.Require().NoError(err) alice1TmpDir := filepath.Join(s.tmpdir, "alice1") alice1Backend := s.prepareBackendWithAccount("", alice1TmpDir) alice1Messenger := alice1Backend.Messenger() _, err = alice1Messenger.Start() s.Require().NoError(err) alice2TmpDir := filepath.Join(s.tmpdir, "alice2") alice2Backend := s.prepareBackendWithoutAccount(alice2TmpDir) alice3TmpDir := filepath.Join(s.tmpdir, "alice3") alice3Backend := s.prepareBackendWithoutAccount(alice3TmpDir) defer func() { require.NoError(s.T(), bobBackend.Logout()) require.NoError(s.T(), alice1Backend.Logout()) require.NoError(s.T(), alice2Backend.Logout()) require.NoError(s.T(), alice3Backend.Logout()) }() // Make Alice and Bob mutual contacts bobPublicKey := bobMessenger.GetSelfContact().ID request := &requests.SendContactRequest{ ID: bobPublicKey, Message: protocol.RandomLettersString(5), } s.sendContactRequest(request, alice1Messenger) contactRequest := s.receiveContactRequest(request.Message, bobMessenger) s.acceptContactRequest(contactRequest, alice1Messenger, bobMessenger) s.checkMutualContact(alice1Backend, bobPublicKey) // We shouldn't sync ourselves as a contact, so we check there's only Bob // https://github.com/status-im/status-go/issues/3667 s.Require().Equal(1, len(alice1Backend.Messenger().Contacts())) // Pair alice-1 <-> alice-2 s.logger.Info("pairing Alice-1 and Alice-2") s.pairAccounts(alice1Backend, alice1TmpDir, alice2Backend, alice2TmpDir) s.checkMutualContact(alice2Backend, bobPublicKey) s.Require().Equal(1, len(alice2Backend.Messenger().Contacts())) // Pair Alice-2 <-> ALice-3 s.logger.Info("pairing Alice-2 and Alice-3") s.pairAccounts(alice2Backend, alice2TmpDir, alice3Backend, alice3TmpDir) s.checkMutualContact(alice3Backend, bobPublicKey) s.Require().Equal(1, len(alice3Backend.Messenger().Contacts())) } func (s *SyncDeviceSuite) createUser(name string) (*api.GethStatusBackend, string) { tmpDir := filepath.Join(s.tmpdir, name) backend := s.prepareBackendWithAccount("", tmpDir) _, err := backend.Messenger().Start() s.Require().NoError(err) return backend, tmpDir } func (s *SyncDeviceSuite) TestPairPendingContactRequest() { bobBackend, _ := s.createUser("bob") defer func() { s.Require().NoError(bobBackend.Logout()) }() alice1Backend, alice1TmpDir := s.createUser("alice1") defer func() { s.Require().NoError(alice1Backend.Logout()) }() // Create a pending CR from alice to bob bobPublicKey := bobBackend.Messenger().IdentityPublicKeyString() alicePublicKey := alice1Backend.Messenger().IdentityPublicKeyString() request := &requests.SendContactRequest{ ID: alicePublicKey, Message: protocol.RandomLettersString(5), } s.sendContactRequest(request, bobBackend.Messenger()) contactRequest := s.receiveContactRequest(request.Message, alice1Backend.Messenger()) s.Require().Equal(request.Message, contactRequest.Text) alice2TmpDir := filepath.Join(s.tmpdir, "alice2") alice2Backend := s.prepareBackendWithoutAccount(alice2TmpDir) defer func() { s.Require().NoError(alice2Backend.Logout()) }() // Pair alice-1 <-> alice-2 s.logger.Info("pairing Alice-1 and Alice-2") s.pairAccounts(alice1Backend, alice1TmpDir, alice2Backend, alice2TmpDir) s.logger.Debug("public keys", zap.String("alice", alice1Backend.Messenger().IdentityPublicKeyString()), zap.String("bob", bobBackend.Messenger().IdentityPublicKeyString()), ) ensurePendingContact := func(m *protocol.Messenger) { contacts := m.Contacts() s.Require().Len(contacts, 1) c := contacts[0] s.Require().Equal(bobPublicKey, c.ID) s.Require().Equal(protocol.ContactRequestStateReceived, c.ContactRequestRemoteState) s.Require().Equal(protocol.ContactRequestStateNone, c.ContactRequestLocalState) acRequest := protocol.ActivityCenterNotificationsRequest{ ActivityTypes: []protocol.ActivityCenterType{ protocol.ActivityCenterNotificationTypeContactRequest, }, ReadType: protocol.ActivityCenterQueryParamsReadAll, Limit: 10, } r, err := m.ActivityCenterNotifications(acRequest) s.Require().NoError(err) s.Require().Len(r.Notifications, 1) } // Ensure both devices have the pending Bob contact ensurePendingContact(alice1Backend.Messenger()) ensurePendingContact(alice2Backend.Messenger()) } type contactRequestAction func(messenger *protocol.Messenger, contactRequestID string) (*protocol.MessengerResponse, error) type notificationValidateFunc func(r *protocol.ActivityCenterPaginationResponse) func (s *SyncDeviceSuite) testPairContactRequest(requestAction contactRequestAction, validateFunc notificationValidateFunc) { bobBackend, _ := s.createUser("bob") defer func() { s.Require().NoError(bobBackend.Logout()) }() alice1Backend, alice1TmpDir := s.createUser("alice1") defer func() { s.Require().NoError(alice1Backend.Logout()) }() alicePublicKey := alice1Backend.Messenger().IdentityPublicKeyString() request := &requests.SendContactRequest{ ID: alicePublicKey, Message: protocol.RandomLettersString(5), } s.sendContactRequest(request, bobBackend.Messenger()) contactRequest := s.receiveContactRequest(request.Message, alice1Backend.Messenger()) s.Require().Equal(request.Message, contactRequest.Text) _, err := requestAction(alice1Backend.Messenger(), contactRequest.ID) s.Require().NoError(err) alice2TmpDir := filepath.Join(s.tmpdir, "alice2") alice2Backend := s.prepareBackendWithoutAccount(alice2TmpDir) defer func() { s.Require().NoError(alice2Backend.Logout()) }() s.pairAccounts(alice1Backend, alice1TmpDir, alice2Backend, alice2TmpDir) internalNotificationValidateFunc := func(m *protocol.Messenger) { acRequest := protocol.ActivityCenterNotificationsRequest{ ActivityTypes: []protocol.ActivityCenterType{ protocol.ActivityCenterNotificationTypeContactRequest, }, ReadType: protocol.ActivityCenterQueryParamsReadAll, Limit: 10, } r, err := m.ActivityCenterNotifications(acRequest) s.Require().NoError(err) validateFunc(r) } internalNotificationValidateFunc(alice1Backend.Messenger()) internalNotificationValidateFunc(alice2Backend.Messenger()) } func (s *SyncDeviceSuite) TestPairDeclineContactRequest() { declineContactRequest := func(messenger *protocol.Messenger, contactRequestID string) (*protocol.MessengerResponse, error) { return messenger.DeclineContactRequest(context.Background(), &requests.DeclineContactRequest{ID: types.Hex2Bytes(contactRequestID)}) } s.testPairContactRequest(declineContactRequest, func(r *protocol.ActivityCenterPaginationResponse) { s.Require().Len(r.Notifications, 1) s.Require().False(r.Notifications[0].Accepted) s.Require().True(r.Notifications[0].Dismissed) s.Require().True(r.Notifications[0].Read) }) } func (s *SyncDeviceSuite) TestPairAcceptContactRequest() { acceptContactRequest := func(messenger *protocol.Messenger, contactRequestID string) (*protocol.MessengerResponse, error) { return messenger.AcceptContactRequest(context.Background(), &requests.AcceptContactRequest{ID: types.Hex2Bytes(contactRequestID)}) } s.testPairContactRequest(acceptContactRequest, func(r *protocol.ActivityCenterPaginationResponse) { s.Require().Len(r.Notifications, 1) s.Require().True(r.Notifications[0].Accepted) s.Require().False(r.Notifications[0].Dismissed) s.Require().True(r.Notifications[0].Read) }) } func defaultSettings(generatedAccountInfo generator.GeneratedAccountInfo, derivedAddresses map[string]generator.AccountInfo, mnemonic *string) (*settings.Settings, error) { chatKeyString := derivedAddresses[pathDefaultChat].PublicKey syncSettings := &settings.Settings{} syncSettings.KeyUID = generatedAccountInfo.KeyUID syncSettings.Address = types.HexToAddress(generatedAccountInfo.Address) syncSettings.WalletRootAddress = types.HexToAddress(derivedAddresses[pathWalletRoot].Address) // Set chat key & name name, err := alias.GenerateFromPublicKeyString(chatKeyString) if err != nil { return nil, err } syncSettings.Name = name syncSettings.PublicKey = chatKeyString syncSettings.DappsAddress = types.HexToAddress(derivedAddresses[pathDefaultWallet].Address) syncSettings.EIP1581Address = types.HexToAddress(derivedAddresses[pathEIP1581].Address) syncSettings.Mnemonic = mnemonic syncSettings.SigningPhrase = "balabala" syncSettings.SendPushNotifications = true syncSettings.InstallationID = uuid.New().String() syncSettings.UseMailservers = true syncSettings.PreviewPrivacy = true syncSettings.Currency = "usd" syncSettings.ProfilePicturesVisibility = 1 syncSettings.LinkPreviewRequestEnabled = true visibleTokens := make(map[string][]string) visibleTokens["mainnet"] = []string{"SNT"} visibleTokensJSON, err := json.Marshal(visibleTokens) if err != nil { return nil, err } visibleTokenJSONRaw := json.RawMessage(visibleTokensJSON) syncSettings.WalletVisibleTokens = &visibleTokenJSONRaw networks := `[{"id":"goerli_rpc","chain-explorer-link":"https://goerli.etherscan.io/address/","name":"Goerli with upstream RPC","config":{"NetworkId":5,"DataDir":"/ethereum/goerli_rpc","UpstreamConfig":{"Enabled":true,"URL":"https://goerli-archival.rpc.grove.city/v1/3ef2018191814b7e1009b8d9"}}},{"id":"mainnet_rpc","chain-explorer-link":"https://etherscan.io/address/","name":"Mainnet with upstream RPC","config":{"NetworkId":1,"DataDir":"/ethereum/mainnet_rpc","UpstreamConfig":{"Enabled":true,"URL":"https://eth-archival.rpc.grove.city/v1/3ef2018191814b7e1009b8d9"}}}]` var networksRawMessage json.RawMessage = []byte(networks) syncSettings.Networks = &networksRawMessage syncSettings.CurrentNetwork = currentNetwork return syncSettings, nil } func nodeConfigForLocalPairSync(installationID, keyUID, tmpDir string) (*params.NodeConfig, error) { // Set mainnet nodeConfig := ¶ms.NodeConfig{} nodeConfig.LogEnabled = true nodeConfig.LogLevel = "DEBUG" nodeConfig.LogDir = tmpDir nodeConfig.KeyStoreDir = filepath.Join(keystoreDir, keyUID) nodeConfig.KeycardPairingDataFile = filepath.Join("keycard", "pairings.json") nodeConfig.ShhextConfig = params.ShhextConfig{ InstallationID: installationID, } // need specify cluster config here, otherwise TestPairingThreeDevices will fail due to no messages(CR) received // TODO(frank) need to figure out why above happen clusterConfig, err := params.LoadClusterConfigFromFleet(params.FleetProd) if err != nil { return nil, err } nodeConfig.ClusterConfig = *clusterConfig return nodeConfig, nil } type testTimeSource struct{} func (t *testTimeSource) GetCurrentTime() uint64 { return uint64(time.Now().Unix()) } func buildTestMessage(chat *protocol.Chat) *common.Message { clock, timestamp := chat.NextClockAndTimestamp(&testTimeSource{}) message := common.NewMessage() message.Text = "text-input-message" message.ChatId = chat.ID message.Clock = clock message.Timestamp = timestamp message.WhisperTimestamp = clock message.LocalChatID = chat.ID message.ContentType = protobuf.ChatMessage_TEXT_PLAIN switch chat.ChatType { case protocol.ChatTypePublic, protocol.ChatTypeProfile: message.MessageType = protobuf.MessageType_PUBLIC_GROUP case protocol.ChatTypeOneToOne: message.MessageType = protobuf.MessageType_ONE_TO_ONE case protocol.ChatTypePrivateGroupChat: message.MessageType = protobuf.MessageType_PRIVATE_GROUP } return message } func (s *SyncDeviceSuite) getSeedPhraseKeypairForTest(backend *api.GethStatusBackend, mnemonic string, server bool) *accounts.Keypair { generatedAccount, err := backend.AccountManager().AccountsGenerator().ImportMnemonic(mnemonic, "") require.NoError(s.T(), err) generatedDerivedAccs, err := backend.AccountManager().AccountsGenerator().DeriveAddresses(generatedAccount.ID, []string{path0, path1}) require.NoError(s.T(), err) seedPhraseKp := &accounts.Keypair{ KeyUID: generatedAccount.KeyUID, Name: "SeedPhraseImported", Type: accounts.KeypairTypeSeed, DerivedFrom: generatedAccount.Address, } i := 0 for path, ga := range generatedDerivedAccs { acc := &accounts.Account{ Address: types.HexToAddress(ga.Address), KeyUID: generatedAccount.KeyUID, Wallet: false, Chat: false, Type: accounts.AccountTypeSeed, Path: path, PublicKey: types.HexBytes(ga.PublicKey), Name: fmt.Sprintf("Acc_%d", i), Operable: accounts.AccountFullyOperable, Emoji: fmt.Sprintf("Emoji_%d", i), ColorID: "blue", } if !server { acc.Operable = accounts.AccountNonOperable } seedPhraseKp.Accounts = append(seedPhraseKp.Accounts, acc) i++ } return seedPhraseKp } func containsKeystoreFile(directory, key string) bool { files, err := os.ReadDir(directory) if err != nil { return false } for _, file := range files { if strings.Contains(file.Name(), strings.ToLower(key)) { return true } } return false } func (s *SyncDeviceSuite) TestTransferringKeystoreFiles() { ctx := context.TODO() serverTmpDir := filepath.Join(s.tmpdir, "server") serverBackend := s.prepareBackendWithAccount(profileKeypairMnemonic, serverTmpDir) clientTmpDir := filepath.Join(s.tmpdir, "client") clientBackend := s.prepareBackendWithAccount(profileKeypairMnemonic, clientTmpDir) defer func() { require.NoError(s.T(), clientBackend.Logout()) require.NoError(s.T(), serverBackend.Logout()) }() serverBackend.Messenger().SetLocalPairing(true) clientBackend.Messenger().SetLocalPairing(true) serverActiveAccount, err := serverBackend.GetActiveAccount() require.NoError(s.T(), err) clientActiveAccount, err := clientBackend.GetActiveAccount() require.NoError(s.T(), err) require.True(s.T(), serverActiveAccount.KeyUID == clientActiveAccount.KeyUID) serverSeedPhraseKp := s.getSeedPhraseKeypairForTest(serverBackend, seedKeypairMnemonic, true) serverAccountsAPI := serverBackend.StatusNode().AccountService().APIs()[1].Service.(*accservice.API) err = serverAccountsAPI.ImportMnemonic(ctx, seedKeypairMnemonic, s.password) require.NoError(s.T(), err, "importing mnemonic for new keypair on server") err = serverAccountsAPI.AddKeypair(ctx, s.password, serverSeedPhraseKp) require.NoError(s.T(), err, "saving seed phrase keypair on server with keystore files created") clientSeedPhraseKp := s.getSeedPhraseKeypairForTest(serverBackend, seedKeypairMnemonic, true) clientAccountsAPI := clientBackend.StatusNode().AccountService().APIs()[1].Service.(*accservice.API) err = clientAccountsAPI.SaveKeypair(ctx, clientSeedPhraseKp) require.NoError(s.T(), err, "saving seed phrase keypair on client without keystore files") // check server - server should contain keystore files for imported seed phrase serverKeystorePath := filepath.Join(serverTmpDir, keystoreDir, serverActiveAccount.KeyUID) require.True(s.T(), containsKeystoreFile(serverKeystorePath, serverSeedPhraseKp.DerivedFrom[2:])) for _, acc := range serverSeedPhraseKp.Accounts { require.True(s.T(), containsKeystoreFile(serverKeystorePath, acc.Address.String()[2:])) } // check client - client should not contain keystore files for imported seed phrase clientKeystorePath := filepath.Join(clientTmpDir, keystoreDir, clientActiveAccount.KeyUID) require.False(s.T(), containsKeystoreFile(clientKeystorePath, clientSeedPhraseKp.DerivedFrom[2:])) for _, acc := range clientSeedPhraseKp.Accounts { require.False(s.T(), containsKeystoreFile(clientKeystorePath, acc.Address.String()[2:])) } // prepare sender var config = KeystoreFilesSenderServerConfig{ SenderConfig: &KeystoreFilesSenderConfig{ KeystoreFilesConfig: KeystoreFilesConfig{ KeystorePath: serverKeystorePath, LoggedInKeyUID: serverActiveAccount.KeyUID, Password: s.password, }, KeypairsToExport: []string{serverSeedPhraseKp.KeyUID}, }, ServerConfig: new(ServerConfig), } configBytes, err := json.Marshal(config) require.NoError(s.T(), err) cs, err := StartUpKeystoreFilesSenderServer(serverBackend, string(configBytes)) require.NoError(s.T(), err) // prepare receiver clientPayloadSourceConfig := KeystoreFilesReceiverClientConfig{ ReceiverConfig: &KeystoreFilesReceiverConfig{ KeystoreFilesConfig: KeystoreFilesConfig{ KeystorePath: clientKeystorePath, LoggedInKeyUID: clientActiveAccount.KeyUID, Password: s.password, }, KeypairsToImport: []string{serverSeedPhraseKp.KeyUID}, }, ClientConfig: new(ClientConfig), } clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) require.NoError(s.T(), err) err = StartUpKeystoreFilesReceivingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) // check client - client should contain keystore files for imported seed phrase accountManager := clientBackend.AccountManager() accGenerator := accountManager.AccountsGenerator() require.True(s.T(), containsKeystoreFile(clientKeystorePath, clientSeedPhraseKp.DerivedFrom[2:])) for _, acc := range clientSeedPhraseKp.Accounts { require.True(s.T(), containsKeystoreFile(clientKeystorePath, acc.Address.String()[2:])) } // reinit keystore on client require.NoError(s.T(), accountManager.InitKeystore(clientKeystorePath)) // check keystore on client genAccInfo, err := accGenerator.LoadAccount(clientSeedPhraseKp.DerivedFrom, s.password) require.NoError(s.T(), err) require.Equal(s.T(), clientSeedPhraseKp.KeyUID, genAccInfo.KeyUID) for _, acc := range clientSeedPhraseKp.Accounts { genAccInfo, err := accGenerator.LoadAccount(acc.Address.String(), s.password) require.NoError(s.T(), err) require.Equal(s.T(), acc.Address.String(), genAccInfo.Address) } } func (s *SyncDeviceSuite) TestTransferringKeystoreFilesAfterStopUisngKeycard() { s.T().Skip("flaky test") ctx := context.TODO() // Prepare server serverTmpDir := filepath.Join(s.tmpdir, "server") serverBackend := s.prepareBackendWithAccount(profileKeypairMnemonic1, serverTmpDir) serverMessenger := serverBackend.Messenger() serverAccountsAPI := serverBackend.StatusNode().AccountService().APIs()[1].Service.(*accservice.API) // Prepare client clientTmpDir := filepath.Join(s.tmpdir, "client") clientBackend := s.prepareBackendWithAccount(profileKeypairMnemonic1, clientTmpDir) clientMessenger := clientBackend.Messenger() clientAccountsAPI := clientBackend.StatusNode().AccountService().APIs()[1].Service.(*accservice.API) defer func() { require.NoError(s.T(), clientBackend.Logout()) require.NoError(s.T(), serverBackend.Logout()) }() // Pair server and client im1 := &multidevice.InstallationMetadata{ Name: "client-device", DeviceType: "client-device-type", } settings, err := clientBackend.GetSettings() s.Require().NoError(err) err = clientMessenger.SetInstallationMetadata(settings.InstallationID, im1) s.Require().NoError(err) response, err := clientMessenger.SendPairInstallation(context.Background(), nil) s.Require().NoError(err) s.Require().NotNil(response) s.Require().Len(response.Chats(), 1) s.Require().False(response.Chats()[0].Active) response, err = protocol.WaitOnMessengerResponse( serverMessenger, func(r *protocol.MessengerResponse) bool { for _, i := range r.Installations { if i.ID == settings.InstallationID { return true } } return false }, "installation not received", ) s.Require().NoError(err) found := false for _, i := range response.Installations { found = i.ID == settings.InstallationID && i.InstallationMetadata != nil && i.InstallationMetadata.Name == im1.Name && i.InstallationMetadata.DeviceType == im1.DeviceType if found { break } } s.Require().True(found) err = serverMessenger.EnableInstallation(settings.InstallationID) s.Require().NoError(err) // Check if the logged in account is the same on server and client serverActiveAccount, err := serverBackend.GetActiveAccount() require.NoError(s.T(), err) clientActiveAccount, err := clientBackend.GetActiveAccount() require.NoError(s.T(), err) require.True(s.T(), serverActiveAccount.KeyUID == clientActiveAccount.KeyUID) ////////////////////////////////////////////////////////////////////////////// // From this point this test is trying to simulate the following scenario: // - add a new seed phrase keypair on server // - sync it to client // - convert it to a keycard keypair on server // - sync it to client // - stop using keycard on server // - sync it to client // - try to transfer keystore files from server to client ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// // Add new seed phrase keypair to server and sync it to client ////////////////////////////////////////////////////////////////////////////// serverSeedPhraseKp := s.getSeedPhraseKeypairForTest(serverBackend, seedKeypairMnemonic1, true) err = serverAccountsAPI.ImportMnemonic(ctx, seedKeypairMnemonic1, s.password) require.NoError(s.T(), err, "importing mnemonic for new keypair on server") err = serverAccountsAPI.AddKeypair(ctx, s.password, serverSeedPhraseKp) require.NoError(s.T(), err, "saving seed phrase keypair on server with keystore files created") // Wait for sync messages to be received on client err = tt.RetryWithBackOff(func() error { response, err := clientMessenger.RetrieveAll() if err != nil { return err } for _, kp := range response.Keypairs { if kp.KeyUID == serverSeedPhraseKp.KeyUID { return nil } } return errors.New("no sync keypair received") }) s.Require().NoError(err) // Check if the keypair saved on client is the same as the one on server serverKp, err := serverAccountsAPI.GetKeypairByKeyUID(ctx, serverSeedPhraseKp.KeyUID) s.Require().NoError(err) clientKp, err := clientAccountsAPI.GetKeypairByKeyUID(ctx, serverSeedPhraseKp.KeyUID) s.Require().NoError(err) s.Require().True(serverKp.KeyUID == clientKp.KeyUID && serverKp.Name == clientKp.Name && serverKp.Type == clientKp.Type && serverKp.DerivedFrom == clientKp.DerivedFrom && serverKp.LastUsedDerivationIndex == clientKp.LastUsedDerivationIndex && serverKp.Clock == clientKp.Clock && len(serverKp.Accounts) == len(clientKp.Accounts) && len(serverKp.Keycards) == len(clientKp.Keycards)) // Check server - server should contain keystore files for imported seed phrase serverKeystorePath := filepath.Join(serverTmpDir, keystoreDir, serverActiveAccount.KeyUID) require.True(s.T(), containsKeystoreFile(serverKeystorePath, serverKp.DerivedFrom[2:])) for _, acc := range serverKp.Accounts { require.True(s.T(), containsKeystoreFile(serverKeystorePath, acc.Address.String()[2:])) } // Check client - client should not contain keystore files for imported seed phrase clientKeystorePath := filepath.Join(clientTmpDir, keystoreDir, clientActiveAccount.KeyUID) require.False(s.T(), containsKeystoreFile(clientKeystorePath, clientKp.DerivedFrom[2:])) for _, acc := range clientKp.Accounts { require.False(s.T(), containsKeystoreFile(clientKeystorePath, acc.Address.String()[2:])) } ////////////////////////////////////////////////////////////////////////////// // Convert it to a keycard keypair on server and sync it to client ////////////////////////////////////////////////////////////////////////////// err = serverAccountsAPI.SaveOrUpdateKeycard(ctx, &accounts.Keycard{ KeycardUID: "1234", KeycardName: "new-keycard", KeyUID: serverKp.KeyUID, AccountsAddresses: []types.Address{serverKp.Accounts[0].Address, serverKp.Accounts[1].Address}, }, false) s.Require().NoError(err) // Wait for sync messages to be received on client err = tt.RetryWithBackOff(func() error { response, err := clientMessenger.RetrieveAll() if err != nil { return err } for _, kp := range response.Keypairs { if kp.KeyUID == serverKp.KeyUID { return nil } } return errors.New("no sync keypair received") }) s.Require().NoError(err) // Check if the keypair saved on client is the same as the one on server serverKp, err = serverAccountsAPI.GetKeypairByKeyUID(ctx, serverSeedPhraseKp.KeyUID) s.Require().NoError(err) clientKp, err = clientAccountsAPI.GetKeypairByKeyUID(ctx, serverSeedPhraseKp.KeyUID) s.Require().NoError(err) s.Require().True(serverKp.KeyUID == clientKp.KeyUID && serverKp.Name == clientKp.Name && serverKp.Type == clientKp.Type && serverKp.DerivedFrom == clientKp.DerivedFrom && serverKp.LastUsedDerivationIndex == clientKp.LastUsedDerivationIndex && serverKp.Clock == clientKp.Clock && len(serverKp.Accounts) == len(clientKp.Accounts) && len(serverKp.Keycards) == len(clientKp.Keycards) && len(serverKp.Keycards) == 1) // Check server - server should not contain keystore files for imported seed phrase require.False(s.T(), containsKeystoreFile(serverKeystorePath, serverKp.DerivedFrom[2:])) for _, acc := range serverKp.Accounts { require.False(s.T(), containsKeystoreFile(serverKeystorePath, acc.Address.String()[2:])) } // Check client - client should not contain keystore files for imported seed phrase require.False(s.T(), containsKeystoreFile(clientKeystorePath, clientKp.DerivedFrom[2:])) for _, acc := range clientKp.Accounts { require.False(s.T(), containsKeystoreFile(clientKeystorePath, acc.Address.String()[2:])) } ////////////////////////////////////////////////////////////////////////////// // Stop using keycard on server and sync it to client ////////////////////////////////////////////////////////////////////////////// err = serverAccountsAPI.MigrateNonProfileKeycardKeypairToApp(ctx, seedKeypairMnemonic1, s.password) s.Require().NoError(err) // Wait for sync messages to be received on client err = tt.RetryWithBackOff(func() error { response, err := clientMessenger.RetrieveAll() if err != nil { return err } for _, kp := range response.Keypairs { if kp.KeyUID == serverKp.KeyUID { return nil } } return errors.New("no sync keypair received") }) s.Require().NoError(err) // Check if the keypair saved on client is the same as the one on server serverKp, err = serverAccountsAPI.GetKeypairByKeyUID(ctx, serverSeedPhraseKp.KeyUID) s.Require().NoError(err) clientKp, err = clientAccountsAPI.GetKeypairByKeyUID(ctx, serverSeedPhraseKp.KeyUID) s.Require().NoError(err) s.Require().True(serverKp.KeyUID == clientKp.KeyUID && serverKp.Name == clientKp.Name && serverKp.Type == clientKp.Type && serverKp.DerivedFrom == clientKp.DerivedFrom && serverKp.LastUsedDerivationIndex == clientKp.LastUsedDerivationIndex && serverKp.Clock == clientKp.Clock && len(serverKp.Accounts) == len(clientKp.Accounts) && len(serverKp.Keycards) == len(clientKp.Keycards) && len(serverKp.Keycards) == 0) // Check server - server should contain keystore files for imported seed phrase require.True(s.T(), containsKeystoreFile(serverKeystorePath, serverKp.DerivedFrom[2:])) for _, acc := range serverKp.Accounts { require.True(s.T(), containsKeystoreFile(serverKeystorePath, acc.Address.String()[2:])) } // Check client - client should not contain keystore files for imported seed phrase require.False(s.T(), containsKeystoreFile(clientKeystorePath, clientKp.DerivedFrom[2:])) for _, acc := range clientKp.Accounts { require.False(s.T(), containsKeystoreFile(clientKeystorePath, acc.Address.String()[2:])) } ////////////////////////////////////////////////////////////////////////////// // Try to transfer keystore files from server to client ////////////////////////////////////////////////////////////////////////////// serverMessenger.SetLocalPairing(true) clientMessenger.SetLocalPairing(true) // prepare sender var config = KeystoreFilesSenderServerConfig{ SenderConfig: &KeystoreFilesSenderConfig{ KeystoreFilesConfig: KeystoreFilesConfig{ KeystorePath: serverKeystorePath, LoggedInKeyUID: serverActiveAccount.KeyUID, Password: s.password, }, KeypairsToExport: []string{serverKp.KeyUID}, }, ServerConfig: new(ServerConfig), } configBytes, err := json.Marshal(config) require.NoError(s.T(), err) cs, err := StartUpKeystoreFilesSenderServer(serverBackend, string(configBytes)) require.NoError(s.T(), err) // prepare receiver clientPayloadSourceConfig := KeystoreFilesReceiverClientConfig{ ReceiverConfig: &KeystoreFilesReceiverConfig{ KeystoreFilesConfig: KeystoreFilesConfig{ KeystorePath: clientKeystorePath, LoggedInKeyUID: clientActiveAccount.KeyUID, Password: s.password, }, KeypairsToImport: []string{clientKp.KeyUID}, }, ClientConfig: new(ClientConfig), } clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) require.NoError(s.T(), err) err = StartUpKeystoreFilesReceivingClient(clientBackend, cs, string(clientConfigBytes)) require.NoError(s.T(), err) // Check server - server should contain keystore files for imported seed phrase require.True(s.T(), containsKeystoreFile(serverKeystorePath, serverKp.DerivedFrom[2:])) for _, acc := range serverKp.Accounts { require.True(s.T(), containsKeystoreFile(serverKeystorePath, acc.Address.String()[2:])) } // Check client - client should contain keystore files for imported seed phrase require.True(s.T(), containsKeystoreFile(clientKeystorePath, clientKp.DerivedFrom[2:])) for _, acc := range clientKp.Accounts { require.True(s.T(), containsKeystoreFile(clientKeystorePath, acc.Address.String()[2:])) } } func (s *SyncDeviceSuite) TestPreventLoggedInAccountLocalPairingClientAsReceiver() { clientTmpDir := filepath.Join(s.tmpdir, "client") clientBackend := s.prepareBackendWithAccount("", clientTmpDir) serverTmpDir := filepath.Join(s.tmpdir, "server") serverBackend := s.prepareBackendWithAccount("", serverTmpDir) defer func() { s.NoError(serverBackend.Logout()) s.NoError(clientBackend.Logout()) }() serverActiveAccount, err := serverBackend.GetActiveAccount() s.NoError(err) serverKeystorePath := filepath.Join(serverTmpDir, keystoreDir, serverActiveAccount.KeyUID) var config = &SenderServerConfig{ SenderConfig: &SenderConfig{ KeystorePath: serverKeystorePath, DeviceType: "desktop", KeyUID: serverActiveAccount.KeyUID, Password: s.password, }, ServerConfig: new(ServerConfig), } configBytes, err := json.Marshal(config) s.NoError(err) cs, err := StartUpSenderServer(serverBackend, string(configBytes)) s.NoError(err) clientKeystoreDir := filepath.Join(clientTmpDir, keystoreDir) clientNodeConfig, err := nodeConfigForLocalPairSync(uuid.New().String(), "", clientTmpDir) s.NoError(err) clientPayloadSourceConfig := ReceiverClientConfig{ ReceiverConfig: &ReceiverConfig{ KeystorePath: clientKeystoreDir, DeviceType: "iphone", KDFIterations: expectedKDFIterations, NodeConfig: clientNodeConfig, SettingCurrentNetwork: currentNetwork, }, ClientConfig: new(ClientConfig), } clientNodeConfig.RootDataDir = clientTmpDir clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) s.NoError(err) err = StartUpReceivingClient(clientBackend, cs, string(clientConfigBytes)) s.ErrorIs(err, ErrLoggedInKeyUIDConflict) } func (s *SyncDeviceSuite) TestPreventLoggedInAccountLocalPairingClientAsSender() { clientTmpDir := filepath.Join(s.tmpdir, "client") clientBackend := s.prepareBackendWithAccount("", clientTmpDir) serverTmpDir := filepath.Join(s.tmpdir, "server") serverBackend := s.prepareBackendWithAccount("", serverTmpDir) defer func() { s.NoError(serverBackend.Logout()) s.NoError(clientBackend.Logout()) }() serverNodeConfig, err := nodeConfigForLocalPairSync(uuid.New().String(), "", serverTmpDir) s.NoError(err) serverKeystoreDir := filepath.Join(serverTmpDir, keystoreDir) serverPayloadSourceConfig := &ReceiverServerConfig{ ReceiverConfig: &ReceiverConfig{ NodeConfig: serverNodeConfig, KeystorePath: serverKeystoreDir, DeviceType: "desktop", KDFIterations: expectedKDFIterations, SettingCurrentNetwork: currentNetwork, }, ServerConfig: new(ServerConfig), } serverNodeConfig.RootDataDir = serverTmpDir serverConfigBytes, err := json.Marshal(serverPayloadSourceConfig) s.NoError(err) cs, err := StartUpReceiverServer(serverBackend, string(serverConfigBytes)) s.NoError(err) clientActiveAccount, err := clientBackend.GetActiveAccount() s.NoError(err) clientKeystorePath := filepath.Join(clientTmpDir, keystoreDir, clientActiveAccount.KeyUID) clientPayloadSourceConfig := SenderClientConfig{ SenderConfig: &SenderConfig{ KeystorePath: clientKeystorePath, DeviceType: "android", KeyUID: clientActiveAccount.KeyUID, Password: s.password, }, ClientConfig: new(ClientConfig), } clientConfigBytes, err := json.Marshal(clientPayloadSourceConfig) s.NoError(err) err = StartUpSendingClient(clientBackend, cs, string(clientConfigBytes)) s.ErrorContains(err, "[client] status not ok when sending account data, received '500 Internal Server Error'") }