Partially implement SSK group creation

src/org/thoughtcrime/securesms/database/DatabaseFactory.java

@@ -37,6 +37,7 @@ import org.thoughtcrime.securesms.loki.database.LokiPreKeyBundleDatabase;
 import org.thoughtcrime.securesms.loki.database.LokiPreKeyRecordDatabase;
 import org.thoughtcrime.securesms.loki.database.LokiThreadDatabase;
 import org.thoughtcrime.securesms.loki.database.LokiUserDatabase;
+import org.thoughtcrime.securesms.loki.database.SharedSenderKeysDatabase;
 import org.thoughtcrime.securesms.util.TextSecurePreferences;
 
 public class DatabaseFactory {
@@ -73,6 +74,7 @@ public class DatabaseFactory {
   private final LokiMessageDatabase lokiMessageDatabase;
   private final LokiThreadDatabase lokiThreadDatabase;
   private final LokiUserDatabase lokiUserDatabase;
+  private final SharedSenderKeysDatabase sskDatabase;
 
   public static DatabaseFactory getInstance(Context context) {
     synchronized (lock) {
@@ -187,6 +189,10 @@ public class DatabaseFactory {
   public static LokiUserDatabase getLokiUserDatabase(Context context) {
     return getInstance(context).lokiUserDatabase;
   }
+
+  public static SharedSenderKeysDatabase getSSKDatabase(Context context) {
+    return getInstance(context).sskDatabase;
+  }
   // endregion
 
   public static void upgradeRestored(Context context, SQLiteDatabase database){
@@ -226,6 +232,7 @@ public class DatabaseFactory {
     this.lokiMessageDatabase       = new LokiMessageDatabase(context, databaseHelper);
     this.lokiThreadDatabase        = new LokiThreadDatabase(context, databaseHelper);
     this.lokiUserDatabase          = new LokiUserDatabase(context, databaseHelper);
+    this.sskDatabase               = new SharedSenderKeysDatabase(context, databaseHelper);
   }
 
   public void onApplicationLevelUpgrade(@NonNull Context context, @NonNull MasterSecret masterSecret,

src/org/thoughtcrime/securesms/loki/protocol/ClosedGroupsProtocol.kt

@@ -1,30 +1,56 @@
 package org.thoughtcrime.securesms.loki.protocol
 
 import android.content.Context
-import android.util.Log
 import nl.komponents.kovenant.Promise
-import nl.komponents.kovenant.functional.map
 import org.thoughtcrime.securesms.ApplicationContext
-import org.thoughtcrime.securesms.crypto.storage.TextSecureSessionStore
 import org.thoughtcrime.securesms.database.Address
 import org.thoughtcrime.securesms.database.DatabaseFactory
 import org.thoughtcrime.securesms.loki.utilities.recipient
-import org.thoughtcrime.securesms.loki.utilities.timeout
 import org.thoughtcrime.securesms.recipients.Recipient
 import org.thoughtcrime.securesms.sms.MessageSender
+import org.thoughtcrime.securesms.sms.OutgoingTextMessage
 import org.thoughtcrime.securesms.util.GroupUtil
+import org.thoughtcrime.securesms.util.Hex
 import org.thoughtcrime.securesms.util.TextSecurePreferences
-import org.whispersystems.libsignal.SignalProtocolAddress
-import org.whispersystems.signalservice.api.messages.SignalServiceContent
-import org.whispersystems.signalservice.api.messages.SignalServiceGroup
-import org.whispersystems.signalservice.api.push.SignalServiceAddress
-import org.whispersystems.signalservice.loki.api.SnodeAPI
-import org.whispersystems.signalservice.loki.api.fileserver.FileServerAPI
-import org.whispersystems.signalservice.loki.protocol.shelved.multidevice.MultiDeviceProtocol
+import org.whispersystems.libsignal.ecc.Curve
+import org.whispersystems.signalservice.loki.protocol.closedgroups.ClosedGroupSenderKey
+import org.whispersystems.signalservice.loki.protocol.closedgroups.SharedSenderKeysImplementation
+import org.whispersystems.signalservice.loki.utilities.hexEncodedPrivateKey
+import org.whispersystems.signalservice.loki.utilities.hexEncodedPublicKey
 import java.util.*
 
 object ClosedGroupsProtocol {
 
+    public fun createClosedGroup(context: Context, name: String, members: Collection<String>): Promise<Unit, Exception> {
+        // Prepare
+        val userPublicKey = TextSecurePreferences.getLocalNumber(context)
+        // Generate a key pair for the group
+        val groupKeyPair = Curve.generateKeyPair()
+        val groupPublicKey = groupKeyPair.hexEncodedPublicKey // Includes the "05" prefix
+        val membersAsData = members.map { Hex.fromStringCondensed(it) }
+        // Create ratchets for all members
+        val senderKeys: List<ClosedGroupSenderKey> = members.map { publicKey ->
+            val ratchet = SharedSenderKeysImplementation.shared.generateRatchet(groupPublicKey, publicKey)
+            ClosedGroupSenderKey(Hex.fromStringCondensed(ratchet.chainKey), ratchet.keyIndex, Hex.fromStringCondensed(publicKey))
+        }
+        // Create the group
+        val groupID = GroupUtil.getEncodedId(Hex.fromStringCondensed(groupPublicKey), false);
+        val admins = setOf( Address.fromSerialized(userPublicKey) )
+        DatabaseFactory.getGroupDatabase(context).create(groupID, name, LinkedList<Address>(members.map { Address.fromSerialized(it) }),
+            null, null, LinkedList<Address>(admins))
+        DatabaseFactory.getRecipientDatabase(context).setProfileSharing(Recipient.from(context, Address.fromSerialized(groupID), false), true)
+        // Establish sessions if needed
+        establishSessionsWithMembersIfNeeded(context, members)
+        // Send a closed group update message to all members using established channels
+        // TODO
+        // Add the group to the user's set of public keys to poll for
+        DatabaseFactory.getSSKDatabase(context).setClosedGroupPrivateKey(groupPublicKey, groupKeyPair.hexEncodedPrivateKey)
+        // Notify the user
+        // TODO
+        // Return
+        return Promise.of(Unit)
+    }
+
     @JvmStatic
     fun shouldIgnoreContentMessage(context: Context, address: Address, groupID: String?, senderPublicKey: String): Boolean {
         if (!address.isClosedGroup || groupID == null) { return false }
@@ -84,7 +110,7 @@ object ClosedGroupsProtocol {
     }
 
     @JvmStatic
-    fun establishSessionsWithMembersIfNeeded(context: Context, members: List<String>) {
+    fun establishSessionsWithMembersIfNeeded(context: Context, members: Collection<String>) {
         @Suppress("NAME_SHADOWING") val members = members.toMutableSet()
         /*
         val allDevices = members.flatMap { member ->