encrypt & decrypt with session protocol

libsession/src/main/java/org/session/libsession/messaging/MessagingConfiguration.kt

@@ -5,6 +5,7 @@ import org.session.libsession.database.MessageDataProvider
 import org.session.libsignal.libsignal.loki.SessionResetProtocol
 import org.session.libsignal.libsignal.state.*
 import org.session.libsignal.metadata.certificate.CertificateValidator
+import org.session.libsignal.service.loki.api.crypto.SessionProtocol
 import org.session.libsignal.service.loki.protocol.closedgroups.SharedSenderKeysDatabaseProtocol
 
 class MessagingConfiguration(
@@ -14,6 +15,7 @@ class MessagingConfiguration(
         val sskDatabase: SharedSenderKeysDatabaseProtocol,
         val messageDataProvider: MessageDataProvider,
         val sessionResetImp: SessionResetProtocol,
+        val sessionProtocol: SessionProtocol,
         val certificateValidator: CertificateValidator)
 {
     companion object {
@@ -25,10 +27,11 @@ class MessagingConfiguration(
                       sskDatabase: SharedSenderKeysDatabaseProtocol,
                       messageDataProvider: MessageDataProvider,
                       sessionResetImp: SessionResetProtocol,
+                      sessionProtocol: SessionProtocol,
                       certificateValidator: CertificateValidator
         ) {
             if (Companion::shared.isInitialized) { return }
-            shared = MessagingConfiguration(context, storage, signalStorage, sskDatabase, messageDataProvider, sessionResetImp, certificateValidator)
+            shared = MessagingConfiguration(context, storage, signalStorage, sskDatabase, messageDataProvider, sessionResetImp, sessionProtocol, certificateValidator)
         }
     }
 }

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/MessageReceiver.kt

@@ -56,14 +56,14 @@ object MessageReceiver {
         } else {
             when (envelope.type) {
                 SignalServiceProtos.Envelope.Type.UNIDENTIFIED_SENDER -> {
-                    val decryptionResult = MessageReceiverDecryption.decryptWithSignalProtocol(envelope)
-                    plaintext = decryptionResult.first()
-                    sender = decryptionResult.second()
+                    val decryptionResult = MessageReceiverDecryption.decryptWithSessionProtocol(envelope)
+                    plaintext = decryptionResult.first
+                    sender = decryptionResult.second
                 }
                 SignalServiceProtos.Envelope.Type.CLOSED_GROUP_CIPHERTEXT -> {
                     val decryptionResult = MessageReceiverDecryption.decryptWithSharedSenderKeys(envelope)
-                    plaintext = decryptionResult.first()
-                    sender = decryptionResult.second()
+                    plaintext = decryptionResult.first
+                    sender = decryptionResult.second
                 }
                 else -> throw Error.UnknownEnvelopeType
             }

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/MessageReceiverDecryption.kt

@@ -7,10 +7,7 @@ import org.session.libsession.utilities.AESGCM
 import org.whispersystems.curve25519.Curve25519
 
 import org.session.libsignal.libsignal.loki.ClosedGroupCiphertextMessage
-import org.session.libsignal.libsignal.util.Pair
-import org.session.libsignal.service.api.crypto.SignalServiceCipher
 import org.session.libsignal.service.api.messages.SignalServiceEnvelope
-import org.session.libsignal.service.api.push.SignalServiceAddress
 import org.session.libsignal.service.internal.push.SignalServiceProtos
 import org.session.libsignal.service.loki.protocol.closedgroups.SharedSenderKeysImplementation
 import org.session.libsignal.service.loki.utilities.toHexString
@@ -20,7 +17,7 @@ import javax.crypto.spec.SecretKeySpec
 
 object MessageReceiverDecryption {
 
-    internal fun decryptWithSignalProtocol(envelope: SignalServiceProtos.Envelope): Pair<ByteArray, String> {
+    /*internal fun decryptWithSignalProtocol(envelope: SignalServiceProtos.Envelope): Pair<ByteArray, String> {
         val storage = MessagingConfiguration.shared.signalStorage
         val sskDatabase = MessagingConfiguration.shared.sskDatabase
         val sessionResetImp = MessagingConfiguration.shared.sessionResetImp
@@ -32,6 +29,10 @@ object MessageReceiverDecryption {
         val cipher = SignalServiceCipher(localAddress, storage, sskDatabase, sessionResetImp, certificateValidator)
         val result = cipher.decrypt(SignalServiceEnvelope(envelope))
         return Pair(ByteArray(1), result.sender) // TODO: Return real plaintext
+    }*/
+
+    internal fun decryptWithSessionProtocol(envelope: SignalServiceProtos.Envelope): Pair<ByteArray, String> {
+        return MessagingConfiguration.shared.sessionProtocol.decrypt(SignalServiceEnvelope(envelope))
     }
 
     internal fun decryptWithSharedSenderKeys(envelope: SignalServiceProtos.Envelope): Pair<ByteArray, String> {

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/MessageSender.kt

@@ -116,7 +116,7 @@ object MessageSender {
             }
             val ciphertext: ByteArray
             when (destination) {
-                is Destination.Contact -> ciphertext = MessageSenderEncryption.encryptWithSignalProtocol(plaintext, message, destination.publicKey)
+                is Destination.Contact -> ciphertext = MessageSenderEncryption.encryptWithSessionProtocol(plaintext, destination.publicKey)
                 is Destination.ClosedGroup -> ciphertext = MessageSenderEncryption.encryptWithSharedSenderKeys(plaintext, destination.groupPublicKey)
                 is Destination.OpenGroup -> throw preconditionFailure
             }

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/MessageSenderEncryption.kt

@@ -20,7 +20,7 @@ import org.session.libsignal.service.loki.utilities.removing05PrefixIfNeeded
 
 object MessageSenderEncryption {
 
-    internal fun encryptWithSignalProtocol(plaintext: ByteArray, message: Message, recipientPublicKey: String): ByteArray{
+    /*internal fun encryptWithSignalProtocol(plaintext: ByteArray, message: Message, recipientPublicKey: String): ByteArray{
         val storage = MessagingConfiguration.shared.signalStorage
         val sskDatabase = MessagingConfiguration.shared.sskDatabase
         val sessionResetImp = MessagingConfiguration.shared.sessionResetImp
@@ -32,6 +32,10 @@ object MessageSenderEncryption {
         val unidentifiedAccess = if (unidentifiedAccessPair != null) unidentifiedAccessPair.targetUnidentifiedAccess else Optional.absent()
         val encryptedMessage = cipher.encrypt(signalProtocolAddress, unidentifiedAccess, plaintext)
         return Base64.decode(encryptedMessage.content)
+    }*/
+
+    internal fun encryptWithSessionProtocol(plaintext: ByteArray, recipientPublicKey: String): ByteArray{
+        return MessagingConfiguration.shared.sessionProtocol.encrypt(plaintext, recipientPublicKey)
     }
 
     internal fun encryptWithSharedSenderKeys(plaintext: ByteArray, groupPublicKey: String): ByteArray {