Add shared SecureRandom instance

libsession/src/main/java/org/session/libsession/messaging/jobs/RetrieveProfileAvatarJob.kt

@@ -12,11 +12,11 @@ import org.session.libsession.utilities.Util.equals
 import org.session.libsession.utilities.recipients.Recipient
 import org.session.libsignal.streams.ProfileCipherInputStream
 import org.session.libsignal.utilities.Log
+import org.session.libsignal.utilities.Util.SECURE_RANDOM
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.io.InputStream
-import java.security.SecureRandom
 import java.util.concurrent.ConcurrentSkipListSet
 
 class RetrieveProfileAvatarJob(private val profileAvatar: String?, val recipientAddress: Address): Job {
@@ -64,7 +64,7 @@ class RetrieveProfileAvatarJob(private val profileAvatar: String?, val recipient
             Log.w(TAG, "Removing profile avatar for: " + recipient.address.serialize())
 
             if (recipient.isLocalNumber) {
-                setProfileAvatarId(context, SecureRandom().nextInt())
+                setProfileAvatarId(context, SECURE_RANDOM.nextInt())
                 setProfilePictureURL(context, null)
             }
 
@@ -83,7 +83,7 @@ class RetrieveProfileAvatarJob(private val profileAvatar: String?, val recipient
             decryptDestination.renameTo(AvatarHelper.getAvatarFile(context, recipient.address))
 
             if (recipient.isLocalNumber) {
-                setProfileAvatarId(context, SecureRandom().nextInt())
+                setProfileAvatarId(context, SECURE_RANDOM.nextInt())
                 setProfilePictureURL(context, profileAvatar)
             }
 

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/pollers/ClosedGroupPollerV2.kt

@@ -10,7 +10,7 @@ import org.session.libsession.messaging.jobs.JobQueue
 import org.session.libsession.messaging.jobs.MessageReceiveParameters
 import org.session.libsession.snode.SnodeAPI
 import org.session.libsession.utilities.GroupUtil
-import org.session.libsignal.crypto.getRandomElementOrNull
+import org.session.libsignal.crypto.secureRandomOrNull
 import org.session.libsignal.utilities.Log
 import org.session.libsignal.utilities.Namespace
 import org.session.libsignal.utilities.defaultRequiresAuth
@@ -104,7 +104,7 @@ class ClosedGroupPollerV2 {
     fun poll(groupPublicKey: String): Promise<Unit, Exception> {
         if (!isPolling(groupPublicKey)) { return Promise.of(Unit) }
         val promise = SnodeAPI.getSwarm(groupPublicKey).bind { swarm ->
-            val snode = swarm.getRandomElementOrNull() ?: throw InsufficientSnodesException() // Should be cryptographically secure
+            val snode = swarm.secureRandomOrNull() ?: throw InsufficientSnodesException() // Should be cryptographically secure
             if (!isPolling(groupPublicKey)) { throw PollingCanceledException() }
             val currentForkInfo = SnodeAPI.forkInfo
             when {

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/pollers/Poller.kt

@@ -19,8 +19,6 @@ import org.session.libsession.messaging.MessagingModuleConfiguration
 import org.session.libsession.messaging.jobs.BatchMessageReceiveJob
 import org.session.libsession.messaging.jobs.JobQueue
 import org.session.libsession.messaging.jobs.MessageReceiveParameters
-import org.session.libsession.messaging.messages.control.SharedConfigurationMessage
-import org.session.libsession.messaging.sending_receiving.MessageReceiver
 import org.session.libsession.snode.RawResponse
 import org.session.libsession.snode.SnodeAPI
 import org.session.libsession.snode.SnodeModule
@@ -29,7 +27,7 @@ import org.session.libsignal.utilities.Base64
 import org.session.libsignal.utilities.Log
 import org.session.libsignal.utilities.Namespace
 import org.session.libsignal.utilities.Snode
-import java.security.SecureRandom
+import org.session.libsignal.utilities.Util.SECURE_RANDOM
 import java.util.Timer
 import java.util.TimerTask
 import kotlin.time.Duration.Companion.days
@@ -106,7 +104,7 @@ class Poller(private val configFactory: ConfigFactoryProtocol, debounceTimer: Ti
         val swarm = SnodeModule.shared.storage.getSwarm(userPublicKey) ?: setOf()
         val unusedSnodes = swarm.subtract(usedSnodes)
         if (unusedSnodes.isNotEmpty()) {
-            val index = SecureRandom().nextInt(unusedSnodes.size)
+            val index = SECURE_RANDOM.nextInt(unusedSnodes.size)
             val nextSnode = unusedSnodes.elementAt(index)
             usedSnodes.add(nextSnode)
             Log.d(TAG, "Polling $nextSnode.")

libsession/src/main/java/org/session/libsession/messaging/utilities/MessageWrapper.kt

@@ -28,7 +28,7 @@ object MessageWrapper {
             val webSocketMessage = createWebSocketMessage(envelope)
             return webSocketMessage.toByteArray()
         } catch (e: Exception) {
-            throw if (e is Error) { e } else { Error.FailedToWrapData }
+            throw if (e is Error) e else Error.FailedToWrapData
         }
     }
 
@@ -49,15 +49,15 @@ object MessageWrapper {
 
     private fun createWebSocketMessage(envelope: Envelope): WebSocketMessage {
         try {
-            val requestBuilder = WebSocketRequestMessage.newBuilder()
-            requestBuilder.verb = "PUT"
-            requestBuilder.path = "/api/v1/message"
-            requestBuilder.id = SecureRandom.getInstance("SHA1PRNG").nextLong()
-            requestBuilder.body = envelope.toByteString()
-            val messageBuilder = WebSocketMessage.newBuilder()
-            messageBuilder.request = requestBuilder.build()
-            messageBuilder.type = WebSocketMessage.Type.REQUEST
-            return messageBuilder.build()
+            return WebSocketMessage.newBuilder().apply {
+                request = WebSocketRequestMessage.newBuilder().apply {
+                    verb = "PUT"
+                    path = "/api/v1/message"
+                    id = SecureRandom.getInstance("SHA1PRNG").nextLong()
+                    body = envelope.toByteString()
+                }.build()
+                type = WebSocketMessage.Type.REQUEST
+            }.build()
         } catch (e: Exception) {
             Log.d("Loki", "Failed to wrap envelope in web socket message: ${e.message}.")
             throw Error.FailedToWrapEnvelopeInWebSocketMessage

libsession/src/main/java/org/session/libsession/snode/OnionRequestAPI.kt

@@ -10,11 +10,10 @@ import okhttp3.Request
 import org.session.libsession.messaging.file_server.FileServerApi
 import org.session.libsession.utilities.AESGCM
 import org.session.libsession.utilities.AESGCM.EncryptionResult
-import org.session.libsession.utilities.Util
 import org.session.libsession.utilities.getBodyForOnionRequest
 import org.session.libsession.utilities.getHeadersForOnionRequest
-import org.session.libsignal.crypto.getRandomElement
-import org.session.libsignal.crypto.getRandomElementOrNull
+import org.session.libsignal.crypto.secureRandom
+import org.session.libsignal.crypto.secureRandomOrNull
 import org.session.libsignal.database.LokiAPIDatabaseProtocol
 import org.session.libsignal.utilities.Base64
 import org.session.libsignal.utilities.Broadcaster
@@ -149,7 +148,7 @@ object OnionRequestAPI {
                 val reusableGuardSnodeCount = reusableGuardSnodes.count()
                 if (unusedSnodes.count() < (targetGuardSnodeCount - reusableGuardSnodeCount)) { throw InsufficientSnodesException() }
                 fun getGuardSnode(): Promise<Snode, Exception> {
-                    val candidate = unusedSnodes.getRandomElementOrNull()
+                    val candidate = unusedSnodes.secureRandomOrNull()
                         ?: return Promise.ofFail(InsufficientSnodesException())
                     unusedSnodes = unusedSnodes.minus(candidate)
                     Log.d("Loki", "Testing guard snode: $candidate.")
@@ -191,7 +190,7 @@ object OnionRequestAPI {
                 // Don't test path snodes as this would reveal the user's IP to them
                 guardSnodes.minus(reusableGuardSnodes).map { guardSnode ->
                     val result = listOf( guardSnode ) + (0 until (pathSize - 1)).mapIndexed() { index, _ ->
-                        var pathSnode = unusedSnodes.getRandomElement()
+                        var pathSnode = unusedSnodes.secureRandom()
 
                         // remove the snode from the unused list and return it
                         unusedSnodes = unusedSnodes.minus(pathSnode)
@@ -228,9 +227,9 @@ object OnionRequestAPI {
         OnionRequestAPI.guardSnodes = guardSnodes
         fun getPath(paths: List<Path>): Path {
             return if (snodeToExclude != null) {
-                paths.filter { !it.contains(snodeToExclude) }.getRandomElement()
+                paths.filter { !it.contains(snodeToExclude) }.secureRandom()
             } else {
-                paths.getRandomElement()
+                paths.secureRandom()
             }
         }
         when {
@@ -273,7 +272,7 @@ object OnionRequestAPI {
         path.removeAt(snodeIndex)
         val unusedSnodes = SnodeAPI.snodePool.minus(oldPaths.flatten())
         if (unusedSnodes.isEmpty()) { throw InsufficientSnodesException() }
-        path.add(unusedSnodes.getRandomElement())
+        path.add(unusedSnodes.secureRandom())
         // Don't test the new snode as this would reveal the user's IP
         oldPaths.removeAt(pathIndex)
         val newPaths = oldPaths + listOf( path )

libsession/src/main/java/org/session/libsession/snode/SnodeAPI.kt

@@ -18,7 +18,8 @@ import nl.komponents.kovenant.task
 import org.session.libsession.messaging.MessagingModuleConfiguration
 import org.session.libsession.messaging.utilities.MessageWrapper
 import org.session.libsession.messaging.utilities.SodiumUtilities.sodium
-import org.session.libsignal.crypto.getRandomElement
+import org.session.libsignal.crypto.secureRandom
+import org.session.libsignal.crypto.shuffledRandom
 import org.session.libsignal.database.LokiAPIDatabaseProtocol
 import org.session.libsignal.protos.SignalServiceProtos
 import org.session.libsignal.utilities.Base64
@@ -30,6 +31,7 @@ import org.session.libsignal.utilities.Log
 import org.session.libsignal.utilities.Namespace
 import org.session.libsignal.utilities.Snode
 import org.session.libsignal.utilities.ThreadUtils
+import org.session.libsignal.utilities.Util.SECURE_RANDOM
 import org.session.libsignal.utilities.prettifiedDescription
 import org.session.libsignal.utilities.retryIfNeeded
 import java.security.SecureRandom
@@ -209,7 +211,7 @@ object SnodeAPI {
                         Log.d("Loki", "Persisting snode pool to database.")
                         this.snodePool = snodePool
                         try {
-                            deferred.resolve(snodePool.getRandomElement())
+                            deferred.resolve(snodePool.secureRandom())
                         } catch (exception: Exception) {
                             Log.d("Loki", "Got an empty snode pool from: $target.")
                             deferred.reject(SnodeAPI.Error.Generic)
@@ -224,7 +226,7 @@ object SnodeAPI {
             }
             return deferred.promise
         } else {
-            return Promise.of(snodePool.getRandomElement())
+            return Promise.of(snodePool.secureRandom())
         }
     }
 
@@ -241,8 +243,8 @@ object SnodeAPI {
     }
 
     internal fun getSingleTargetSnode(publicKey: String): Promise<Snode, Exception> {
-        // SecureRandom() should be cryptographically secure
-        return getSwarm(publicKey).map { it.shuffled(SecureRandom()).random() }
+        // SecureRandom should be cryptographically secure
+        return getSwarm(publicKey).map { it.shuffledRandom().random() }
     }
 
     // Public API

libsession/src/main/java/org/session/libsession/utilities/Util.kt

@@ -13,6 +13,7 @@ import android.text.TextUtils
 import android.text.style.StyleSpan
 import org.session.libsignal.utilities.Log
 import org.session.libsignal.utilities.Base64
+import org.session.libsignal.utilities.Util.SECURE_RANDOM
 import java.io.*
 import java.nio.charset.StandardCharsets
 import java.security.SecureRandom
@@ -292,15 +293,10 @@ object Util {
     @JvmStatic
     fun getSecretBytes(size: Int): ByteArray {
         val secret = ByteArray(size)
-        getSecureRandom().nextBytes(secret)
+        SECURE_RANDOM.nextBytes(secret)
         return secret
     }
 
-    @JvmStatic
-    fun getSecureRandom(): SecureRandom {
-        return SecureRandom()
-    }
-
     @JvmStatic
     fun getFirstNonEmpty(vararg values: String?): String? {
         for (value in values) {
@@ -317,18 +313,14 @@ object Util {
     }
 
     @JvmStatic
-    fun <T> getRandomElement(elements: Array<T>): T {
-        return elements[SecureRandom().nextInt(elements.size)]
-    }
+    fun <T> getRandomElement(elements: Array<T>): T = elements[SECURE_RANDOM.nextInt(elements.size)]
 
     @JvmStatic
     fun getBoldedString(value: String?): CharSequence {
         if (value.isNullOrEmpty()) { return "" }
-        val spanned = SpannableString(value)
-        spanned.setSpan(StyleSpan(Typeface.BOLD), 0,
-                spanned.length,
-                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
-        return spanned
+        return SpannableString(value).also {
+            it.setSpan(StyleSpan(Typeface.BOLD), 0, it.length, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+        }
     }
 
     @JvmStatic