Return a Manager from ProvisioningManager and RegistrationManager when finished

[signal-cli] / lib / src / main / java / org / asamk / signal / manager / RegistrationManager.java

diff --git a/lib/src/main/java/org/asamk/signal/manager/RegistrationManager.java b/lib/src/main/java/org/asamk/signal/manager/RegistrationManager.java
index 506948badde039f026bf58f94deb1445faaa2fa8..aad731a0a4f100460665b909e178feefa6eeddfc 100644 (file)
--- a/lib/src/main/java/org/asamk/signal/manager/RegistrationManager.java
+++ b/lib/src/main/java/org/asamk/signal/manager/RegistrationManager.java
@@ -16,23 +16,23 @@
  */
 package org.asamk.signal.manager;
 
+import org.asamk.signal.manager.config.ServiceConfig;
+import org.asamk.signal.manager.config.ServiceEnvironment;
+import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
 import org.asamk.signal.manager.helper.PinHelper;
 import org.asamk.signal.manager.storage.SignalAccount;
 import org.asamk.signal.manager.util.KeyUtils;
-import org.signal.zkgroup.profiles.ProfileKey;
-import org.whispersystems.libsignal.IdentityKeyPair;
 import org.whispersystems.libsignal.util.KeyHelper;
 import org.whispersystems.libsignal.util.guava.Optional;
-import org.whispersystems.signalservice.api.KbsPinData;
-import org.whispersystems.signalservice.api.KeyBackupService;
 import org.whispersystems.signalservice.api.KeyBackupServicePinException;
 import org.whispersystems.signalservice.api.KeyBackupSystemNoDataException;
 import org.whispersystems.signalservice.api.SignalServiceAccountManager;
+import org.whispersystems.signalservice.api.groupsv2.ClientZkOperations;
+import org.whispersystems.signalservice.api.groupsv2.GroupsV2Operations;
 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
 import org.whispersystems.signalservice.api.util.SleepTimer;
 import org.whispersystems.signalservice.api.util.UptimeSleepTimer;
 import org.whispersystems.signalservice.api.util.UuidUtil;
-import org.whispersystems.signalservice.internal.configuration.SignalServiceConfiguration;
 import org.whispersystems.signalservice.internal.push.LockedException;
 import org.whispersystems.signalservice.internal.push.VerifyAccountResponse;
 import org.whispersystems.signalservice.internal.util.DynamicCredentialsProvider;
@@ -46,7 +46,7 @@ public class RegistrationManager implements Closeable {
 
     private SignalAccount account;
     private final PathConfig pathConfig;
-    private final SignalServiceConfiguration serviceConfiguration;
+    private final ServiceEnvironmentConfig serviceEnvironmentConfig;
     private final String userAgent;
 
     private final SignalServiceAccountManager accountManager;
@@ -55,37 +55,49 @@ public class RegistrationManager implements Closeable {
     public RegistrationManager(
             SignalAccount account,
             PathConfig pathConfig,
-            SignalServiceConfiguration serviceConfiguration,
+            ServiceEnvironmentConfig serviceEnvironmentConfig,
             String userAgent
     ) {
         this.account = account;
         this.pathConfig = pathConfig;
-        this.serviceConfiguration = serviceConfiguration;
+        this.serviceEnvironmentConfig = serviceEnvironmentConfig;
         this.userAgent = userAgent;
 
         final SleepTimer timer = new UptimeSleepTimer();
-        this.accountManager = new SignalServiceAccountManager(serviceConfiguration, new DynamicCredentialsProvider(
-                // Using empty UUID, because registering doesn't work otherwise
-                null,
-                account.getUsername(),
-                account.getPassword(),
-                account.getSignalingKey(),
-                SignalServiceAddress.DEFAULT_DEVICE_ID), userAgent, null, ServiceConfig.AUTOMATIC_NETWORK_RETRY, timer);
-        final KeyBackupService keyBackupService = ServiceConfig.createKeyBackupService(accountManager);
+        GroupsV2Operations groupsV2Operations;
+        try {
+            groupsV2Operations = new GroupsV2Operations(ClientZkOperations.create(serviceEnvironmentConfig.getSignalServiceConfiguration()));
+        } catch (Throwable ignored) {
+            groupsV2Operations = null;
+        }
+        this.accountManager = new SignalServiceAccountManager(serviceEnvironmentConfig.getSignalServiceConfiguration(),
+                new DynamicCredentialsProvider(
+                        // Using empty UUID, because registering doesn't work otherwise
+                        null, account.getUsername(), account.getPassword(), SignalServiceAddress.DEFAULT_DEVICE_ID),
+                userAgent,
+                groupsV2Operations,
+                ServiceConfig.AUTOMATIC_NETWORK_RETRY,
+                timer);
+        final var keyBackupService = accountManager.getKeyBackupService(ServiceConfig.getIasKeyStore(),
+                serviceEnvironmentConfig.getKeyBackupConfig().getEnclaveName(),
+                serviceEnvironmentConfig.getKeyBackupConfig().getServiceId(),
+                serviceEnvironmentConfig.getKeyBackupConfig().getMrenclave(),
+                10);
         this.pinHelper = new PinHelper(keyBackupService);
     }
 
     public static RegistrationManager init(
-            String username, File settingsPath, SignalServiceConfiguration serviceConfiguration, String userAgent
+            String username, File settingsPath, ServiceEnvironment serviceEnvironment, String userAgent
     ) throws IOException {
-        PathConfig pathConfig = PathConfig.createDefault(settingsPath);
+        var pathConfig = PathConfig.createDefault(settingsPath);
 
+        final var serviceConfiguration = ServiceConfig.getServiceEnvironmentConfig(serviceEnvironment, userAgent);
         if (!SignalAccount.userExists(pathConfig.getDataPath(), username)) {
-            IdentityKeyPair identityKey = KeyUtils.generateIdentityKeyPair();
-            int registrationId = KeyHelper.generateRegistrationId(false);
+            var identityKey = KeyUtils.generateIdentityKeyPair();
+            var registrationId = KeyHelper.generateRegistrationId(false);
 
-            ProfileKey profileKey = KeyUtils.createProfileKey();
-            SignalAccount account = SignalAccount.create(pathConfig.getDataPath(),
+            var profileKey = KeyUtils.createProfileKey();
+            var account = SignalAccount.create(pathConfig.getDataPath(),
                     username,
                     identityKey,
                     registrationId,
@@ -95,7 +107,7 @@ public class RegistrationManager implements Closeable {
             return new RegistrationManager(account, pathConfig, serviceConfiguration, userAgent);
         }
 
-        SignalAccount account = SignalAccount.load(pathConfig.getDataPath(), username);
+        var account = SignalAccount.load(pathConfig.getDataPath(), username);
 
         return new RegistrationManager(account, pathConfig, serviceConfiguration, userAgent);
     }
@@ -116,13 +128,10 @@ public class RegistrationManager implements Closeable {
         account.save();
     }
 
-    public void verifyAccount(
+    public Manager verifyAccount(
             String verificationCode, String pin
     ) throws IOException, KeyBackupSystemNoDataException, KeyBackupServicePinException {
         verificationCode = verificationCode.replace("-", "");
-        if (account.getSignalingKey() == null) {
-            account.setSignalingKey(KeyUtils.createSignalingKey());
-        }
         VerifyAccountResponse response;
         try {
             response = verifyAccountWithCode(verificationCode, pin, null);
@@ -132,12 +141,12 @@ public class RegistrationManager implements Closeable {
                 throw e;
             }
 
-            KbsPinData registrationLockData = pinHelper.getRegistrationLockData(pin, e);
+            var registrationLockData = pinHelper.getRegistrationLockData(pin, e);
             if (registrationLockData == null) {
                 throw e;
             }
 
-            String registrationLock = registrationLockData.getMasterKey().deriveRegistrationLock();
+            var registrationLock = registrationLockData.getMasterKey().deriveRegistrationLock();
             try {
                 response = verifyAccountWithCode(verificationCode, null, registrationLock);
             } catch (LockedException _e) {
@@ -154,26 +163,37 @@ public class RegistrationManager implements Closeable {
         account.setRegistered(true);
         account.setUuid(UuidUtil.parseOrNull(response.getUuid()));
         account.setRegistrationLockPin(pin);
+        account.getSignalProtocolStore().archiveAllSessions();
         account.getSignalProtocolStore()
                 .saveIdentity(account.getSelfAddress(),
                         account.getSignalProtocolStore().getIdentityKeyPair().getPublicKey(),
                         TrustLevel.TRUSTED_VERIFIED);
 
-        try (Manager m = new Manager(account, pathConfig, serviceConfiguration, userAgent)) {
+        Manager m = null;
+        try {
+            m = new Manager(account, pathConfig, serviceEnvironmentConfig, userAgent);
 
             m.refreshPreKeys();
 
-            m.close(false);
-        }
+            account.save();
 
-        account.save();
+            final var result = m;
+            account = null;
+            m = null;
+
+            return result;
+        } finally {
+            if (m != null) {
+                m.close();
+            }
+        }
     }
 
     private VerifyAccountResponse verifyAccountWithCode(
             final String verificationCode, final String legacyPin, final String registrationLock
     ) throws IOException {
         return accountManager.verifyAccountWithCode(verificationCode,
-                account.getSignalingKey(),
+                null,
                 account.getSignalProtocolStore().getLocalRegistrationId(),
                 true,
                 legacyPin,