diff --git a/app/src/debug/java/com/bitchat/android/testhook/TestHookDriver.kt b/app/src/debug/java/com/bitchat/android/testhook/TestHookDriver.kt
index 7379b5ef..4bdc2701 100644
--- a/app/src/debug/java/com/bitchat/android/testhook/TestHookDriver.kt
+++ b/app/src/debug/java/com/bitchat/android/testhook/TestHookDriver.kt
@@ -1,6 +1,7 @@
package com.bitchat.android.testhook
import android.content.Context
+import android.content.ContextWrapper
import android.content.Intent
import android.util.Log
import com.bitchat.android.favorites.FavoritesPersistenceService
@@ -15,7 +16,10 @@ import com.bitchat.android.identity.SecureIdentityStateManager
import com.bitchat.android.mesh.MeshService
import com.bitchat.android.mesh.PrivateMediaPreparation
import com.bitchat.android.mesh.TransferProgressManager
+import com.bitchat.android.mesh.CourierDepositTier
+import com.bitchat.android.mesh.CourierStore
import com.bitchat.android.model.BitchatFilePacket
+import com.bitchat.android.model.CourierEnvelope
import com.bitchat.android.model.RoutedPacket
import com.bitchat.android.noise.NoiseSession
import com.bitchat.android.protocol.BitchatPacket
@@ -23,8 +27,11 @@ import com.bitchat.android.service.MeshForegroundService
import com.bitchat.android.service.MeshServiceHolder
import com.bitchat.android.service.TransportBridgeService
import com.bitchat.android.services.AppStateStore
+import com.bitchat.android.services.ConversationStorageCipher
+import com.bitchat.android.services.MessageRouter
import com.bitchat.android.ui.DataManager
import com.bitchat.android.ui.PrivateMediaRecipientResolver
+import com.bitchat.android.ui.debug.DebugSettingsManager
import com.bitchat.android.util.AppConstants
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.async
@@ -69,6 +76,13 @@ object TestHookDriver {
"announce" -> announce(context)
"broadcast_msg" -> broadcastMsg(context, intent.requiredString("content"), intent.getStringExtra("channel"))
"dm_send" -> dmSend(context, intent.requiredString("peer"), intent.requiredString("content"), intent.getStringExtra("msg_id"))
+ "router_private_send" -> routerPrivateSend(
+ context,
+ intent.requiredString("peer"),
+ intent.requiredString("content"),
+ intent.getStringExtra("msg_id")
+ )
+ "router_resume" -> routerResume(context)
"dm_recv" -> dmRecv(context, intent)
"msg_recv" -> msgRecv(context, intent)
"favorite_set" -> favoriteSet(
@@ -89,7 +103,11 @@ object TestHookDriver {
"ptt_send" -> pttSend(context, intent)
"ptt_recv" -> pttRecv(context, intent)
"raw_send" -> rawSend(context, intent)
+ "courier_contract" -> courierContract(context)
+ "cache_peer_identity" -> cachePeerIdentity(context, intent.requiredString("peer"))
+ "sync_request" -> syncRequest(intent.requiredString("peer"))
"ble" -> setBle(intent.getBooleanExtra("enabled", true))
+ "wifi_aware" -> setWifiAware(intent.getBooleanExtra("enabled", true))
"inject_peers" -> injectPeers(intent.getStringExtra("peers"))
"state" -> state(context)
"clear_results" -> clearResults(context)
@@ -243,6 +261,27 @@ object TestHookDriver {
return ok("dm_send").put("peer", peerID).put("msg_id", id)
}
+ /**
+ * Drives the same durable outbox/router path used by private-chat sends instead of the
+ * lower-level direct mesh API that backs `dm_send`.
+ */
+ private fun routerPrivateSend(context: Context, peerID: String, content: String, msgID: String?): JSONObject {
+ val mesh = mesh(context)
+ val nickname = mesh.getPeerNicknames()[peerID] ?: peerID
+ val id = msgID ?: "testhook-router-${System.currentTimeMillis()}"
+ val route = MessageRouter.getInstance(context, mesh).sendPrivate(content, peerID, nickname, id)
+ return ok("router_private_send")
+ .put("peer", peerID)
+ .put("msg_id", id)
+ .put("route", route.name)
+ }
+
+ /** Recreates the durable router after a process restart without adding another message. */
+ private fun routerResume(context: Context): JSONObject {
+ MessageRouter.getInstance(context, mesh(context))
+ return ok("router_resume")
+ }
+
private suspend fun dmRecv(context: Context, intent: Intent): JSONObject {
val timeoutMs = intent.getLongExtra("timeout_ms", DEFAULT_RECV_TIMEOUT_MS)
val fromPeer = intent.getStringExtra("peer")
@@ -276,10 +315,11 @@ object TestHookDriver {
val timeoutMs = intent.getLongExtra("timeout_ms", DEFAULT_RECV_TIMEOUT_MS)
val contains = intent.getStringExtra("contains")
val channel = intent.getStringExtra("channel")
+ val includeExisting = intent.getBooleanExtra("include_existing", false)
val startTime = System.currentTimeMillis()
val mesh = mesh(context)
val matches: (com.bitchat.android.model.BitchatMessage) -> Boolean = { msg ->
- msg.timestamp.time >= startTime &&
+ (includeExisting || msg.timestamp.time >= startTime) &&
msg.senderPeerID != mesh.myPeerID &&
(contains == null || msg.content.contains(contains)) &&
(channel == null || msg.channel == channel)
@@ -653,6 +693,128 @@ object TestHookDriver {
.put("peer", peerID)
}
+ /**
+ * Exercises the real courier wire/store implementation on a physical debug build.
+ * This is intentionally local: the two-phone harness has no third identity to act as
+ * both recipient and an independent courier, so transport scenarios cannot observe the
+ * spray budget without weakening the assertion.
+ */
+ private fun courierContract(context: Context): JSONObject {
+ val filesDir = File(context.cacheDir, "testhook/courier-contract-files")
+ filesDir.deleteRecursively()
+ filesDir.mkdirs()
+ val labContext = LabStorageContext(context, filesDir)
+ val cipher = LabCipher(0x5a)
+ val now = System.currentTimeMillis()
+ val recipientKey = ByteArray(32) { 7 }
+ val depositorKey = ByteArray(32) { 8 }
+ val firstCourier = ByteArray(32) { 11 }
+ val secondCourier = ByteArray(32) { 12 }
+ val thirdCourier = ByteArray(32) { 13 }
+ val fourthCourier = ByteArray(32) { 14 }
+ val tag = CourierEnvelope.recipientTag(recipientKey, CourierEnvelope.epochDay(now))
+ val store = CourierStore(labContext, cipher) { now }
+ try {
+ val firstEnvelope = CourierEnvelope(
+ recipientTag = tag,
+ expiry = (now + CourierEnvelope.MAX_LIFETIME_MS).toULong(),
+ ciphertext = ByteArray(32) { (it + 1).toByte() },
+ copies = 4u,
+ prekeyID = 0x11223344u
+ )
+ require(store.deposit(firstEnvelope, depositorKey, CourierDepositTier.VERIFIED))
+ val wire = requireNotNull(firstEnvelope.encode())
+ val decoded = requireNotNull(CourierEnvelope.decode(wire))
+ val first = store.sprayCopiesFor(firstCourier).single()
+ val second = store.sprayCopiesFor(secondCourier).single()
+ val sameCourierEmpty = store.sprayCopiesFor(firstCourier).isEmpty()
+ val secondCommitted = store.commitSpray(second, secondCourier)
+ val firstCommitted = store.commitSpray(first, firstCourier)
+ val thirdCourierEmpty = store.sprayCopiesFor(thirdCourier).isEmpty()
+
+ val secondEnvelope = firstEnvelope.copy(ciphertext = ByteArray(32) { (it + 65).toByte() })
+ require(store.deposit(secondEnvelope, depositorKey, CourierDepositTier.VERIFIED))
+ val cancelledPreview = store.sprayCopiesFor(fourthCourier).single()
+ val cancelled = store.cancelSpray(cancelledPreview, fourthCourier)
+ val retry = store.sprayCopiesFor(fourthCourier).single()
+ val retryCommitted = store.commitSpray(retry, fourthCourier)
+
+ val reloaded = CourierStore(labContext, LabCipher(0x5a)) { now }
+ val persistedSprayHistory = reloaded.sprayCopiesFor(fourthCourier)
+ .none { it.ciphertext.contentEquals(secondEnvelope.ciphertext) }
+ val remainingCopies = reloaded.sprayCopiesFor(thirdCourier)
+ .firstOrNull { it.ciphertext.contentEquals(secondEnvelope.ciphertext) }
+ ?.copies
+ ?.toInt()
+ reloaded.wipe()
+
+ require(decoded.prekeyID == firstEnvelope.prekeyID)
+ require(decoded.encode()?.contentEquals(wire) == true)
+ require(first.prekeyID == firstEnvelope.prekeyID)
+ require(first.copies == 2u.toUByte())
+ require(second.copies == 1u.toUByte())
+ require(sameCourierEmpty)
+ require(secondCommitted && firstCommitted && thirdCourierEmpty)
+ require(cancelled && retry.copies == 2u.toUByte() && retryCommitted)
+ require(persistedSprayHistory && remainingCopies == 1)
+
+ return ok("courier_contract")
+ .put("wire_prekey_id_preserved", true)
+ .put("stored_prekey_id_preserved", true)
+ .put("first_reserved_copies", first.copies.toInt())
+ .put("second_reserved_copies", second.copies.toInt())
+ .put("same_courier_second_reservation_empty", sameCourierEmpty)
+ .put("reverse_order_commits", true)
+ .put("cancel_restored_eligibility", cancelled)
+ .put("persisted_spray_history", persistedSprayHistory)
+ .put("remaining_copies_after_restart", remainingCopies)
+ } finally {
+ store.wipe()
+ filesDir.deleteRecursively()
+ }
+ }
+
+ /** Persist the currently authenticated peer key exactly as the normal UI session observer does. */
+ private fun cachePeerIdentity(context: Context, peerID: String): JSONObject {
+ val info = mesh(context).getPeerInfo(peerID)
+ ?: return err("cache_peer_identity", "peer is not known")
+ val noiseKey = info.noisePublicKey
+ ?: return err("cache_peer_identity", "peer Noise key is unavailable")
+ val noiseKeyHex = noiseKey.toHex()
+ val identityManager = SecureIdentityStateManager(context)
+ identityManager.cachePeerNoiseKey(peerID, noiseKeyHex)
+ identityManager.cacheNoiseFingerprint(noiseKeyHex, com.bitchat.android.services.ContactIdentityResolver.fingerprintHex(noiseKey))
+ info.nickname.takeIf { it.isNotBlank() }?.let { nickname ->
+ identityManager.cacheFingerprintNickname(
+ com.bitchat.android.services.ContactIdentityResolver.fingerprintHex(noiseKey),
+ nickname
+ )
+ }
+ return ok("cache_peer_identity").put("peer", peerID)
+ }
+
+ private fun syncRequest(peerID: String): JSONObject {
+ val manager = MeshServiceHolder.sharedGossipSyncManager
+ ?: return err("sync_request", "gossip sync manager is unavailable")
+ manager.scheduleInitialSyncToPeer(peerID, 0)
+ return ok("sync_request").put("peer", peerID)
+ }
+
+ private class LabStorageContext(base: Context, private val labFilesDir: File) : ContextWrapper(base) {
+ override fun getApplicationContext(): Context = this
+ override fun getFilesDir(): File = labFilesDir
+ }
+
+ private class LabCipher(private val mask: Int) : ConversationStorageCipher {
+ override fun encrypt(plaintext: ByteArray, associatedData: ByteArray): ByteArray =
+ plaintext.map { (it.toInt() xor mask).toByte() }.toByteArray()
+
+ override fun decrypt(envelope: ByteArray, associatedData: ByteArray): ByteArray =
+ encrypt(envelope, associatedData)
+
+ override fun destroyKey() = Unit
+ }
+
// MARK: - Transport / state
private fun setBle(enabled: Boolean): JSONObject {
@@ -661,6 +823,14 @@ object TestHookDriver {
return ok("ble").put("enabled", enabled)
}
+ private fun setWifiAware(enabled: Boolean): JSONObject {
+ val previous = com.bitchat.android.wifiaware.WifiAwareController.enabled.value
+ DebugSettingsManager.getInstance().setWifiAwareEnabled(enabled)
+ return ok("wifi_aware")
+ .put("enabled", enabled)
+ .put("previous_enabled", previous)
+ }
+
private fun state(context: Context): JSONObject {
val mesh = mesh(context)
val peersJson = peerInfosJson(mesh, AppStateStore.peers.value)
diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml
index 1f9a8c49..9599ecf8 100644
--- a/app/src/main/AndroidManifest.xml
+++ b/app/src/main/AndroidManifest.xml
@@ -126,6 +126,12 @@
+
+
+
+
+
+
diff --git a/app/src/main/java/com/bitchat/android/BitchatApplication.kt b/app/src/main/java/com/bitchat/android/BitchatApplication.kt
index 7b5926ef..2493e3a3 100644
--- a/app/src/main/java/com/bitchat/android/BitchatApplication.kt
+++ b/app/src/main/java/com/bitchat/android/BitchatApplication.kt
@@ -73,6 +73,20 @@ class BitchatApplication : Application() {
// Initialize mesh service preferences
try { com.bitchat.android.service.MeshServicePreferences.init(this) } catch (_: Exception) { }
+ // Bridge policy is process-scoped so rendezvous and courier delivery
+ // continue while the activity is backgrounded.
+ try {
+ com.bitchat.android.services.bridge.MeshBridgeService.initialize(this)
+ com.bitchat.android.mesh.BridgeMeshPort.install(
+ com.bitchat.android.services.bridge.MeshBridgeService
+ )
+ } catch (_: Exception) { }
+
+ com.bitchat.android.services.bridge.MeshGatewayService.initialize(this)
+ com.bitchat.android.groups.GroupRuntime.getInstance(this)
+ com.bitchat.android.services.PrivateMediaOutbox.initialize(this)
+ com.bitchat.android.model.PeerCapabilities.setPhoneFeaturesEnabled(true)
+
// Proactively start the foreground service to keep mesh alive
try { com.bitchat.android.service.MeshForegroundService.start(this) } catch (_: Exception) { }
diff --git a/app/src/main/java/com/bitchat/android/MainActivity.kt b/app/src/main/java/com/bitchat/android/MainActivity.kt
index 6f80052a..d73d9341 100644
--- a/app/src/main/java/com/bitchat/android/MainActivity.kt
+++ b/app/src/main/java/com/bitchat/android/MainActivity.kt
@@ -705,6 +705,7 @@ class MainActivity : OrientationAwareActivity() {
// Handle any notification intent
handleNotificationIntent(intent)
handleVerificationIntent(intent)
+ handleShareIntent(intent)
// Small delay to ensure mesh service is fully initialized
delay(500)
@@ -734,6 +735,7 @@ class MainActivity : OrientationAwareActivity() {
if (mainViewModel.onboardingState.value == OnboardingState.COMPLETE) {
handleNotificationIntent(intent)
handleVerificationIntent(intent)
+ handleShareIntent(intent)
}
}
@@ -848,6 +850,21 @@ class MainActivity : OrientationAwareActivity() {
}
}
+ private fun handleShareIntent(intent: Intent) {
+ if (intent.action == Intent.ACTION_SEND && intent.type?.startsWith("text/") == true) {
+ intent.getCharSequenceExtra(Intent.EXTRA_TEXT)?.toString()?.takeIf { it.isNotBlank() }?.let {
+ chatViewModel.receiveSharedText(it)
+ intent.removeExtra(Intent.EXTRA_TEXT)
+ }
+ }
+ if (intent.action == Intent.ACTION_VIEW) {
+ val cell = intent.data?.toString()?.let(com.bitchat.android.services.ChannelInvitation::decode) ?: return
+ val channel = com.bitchat.android.ui.channelForManualGeohash(cell) ?: return
+ LocationChannelManager.getInstance(applicationContext).selectManual(channel)
+ intent.data = null
+ }
+ }
+
private fun handleVerificationIntent(intent: Intent) {
val uri = intent.data ?: return
if (uri.scheme != "bitchat" || uri.host != "verify") return
diff --git a/app/src/main/java/com/bitchat/android/board/BoardManager.kt b/app/src/main/java/com/bitchat/android/board/BoardManager.kt
new file mode 100644
index 00000000..93288c32
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/board/BoardManager.kt
@@ -0,0 +1,212 @@
+package com.bitchat.android.board
+
+import com.bitchat.android.mesh.MeshService
+import com.bitchat.android.nostr.LocationNotesManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import java.security.SecureRandom
+
+/**
+ * Creates and removes signed board entries while keeping UI-only state out of
+ * the transport layer.
+ */
+class BoardManager(
+ private val store: BoardStore,
+ private val scope: CoroutineScope,
+ private val meshProvider: () -> MeshService,
+ private val geoIdentityProvider: (String) -> BoardSigningIdentity? = { null },
+ private val notesManager: LocationNotesManager = LocationNotesManager.getInstance(),
+ private val nowMs: () -> ULong = { System.currentTimeMillis().coerceAtLeast(0).toULong() },
+ private val random: SecureRandom = SecureRandom(),
+ private val onUrgentPosts: (geohash: String, posts: List) -> Unit = { _, _ -> }
+) {
+ private val _unseenScopes = MutableStateFlow>(emptySet())
+ private val bridgedEventIDs = mutableMapOf()
+ private val handledPostIDs = mutableSetOf()
+ private val pendingUrgent = mutableMapOf>()
+ private var alertFlushJob: Job? = null
+
+ val posts: StateFlow> = store.postsSnapshot
+ val unseenScopes: StateFlow> = _unseenScopes.asStateFlow()
+
+ init {
+ scope.launch {
+ store.postArrivals.collect { post ->
+ handleArrival(post)
+ }
+ }
+ }
+
+ fun posts(geohash: String): List = store.posts(geohash.lowercase())
+
+ fun isOwnPost(post: BoardPostPacket): Boolean =
+ signingIdentityFor(post.geohash)
+ ?.publicKey
+ ?.contentEquals(post.authorSigningKey) == true
+
+ fun createPost(
+ content: String,
+ geohash: String,
+ nickname: String?,
+ urgent: Boolean,
+ expiryDays: Int
+ ): Boolean {
+ val trimmed = content.trim()
+ val contentBytes = trimmed.toByteArray(Charsets.UTF_8)
+ val normalizedGeohash = geohash.lowercase()
+ if (contentBytes.size !in 1..BoardWireConstants.CONTENT_MAX_BYTES ||
+ expiryDays !in 1..7 ||
+ !isValidGeohash(normalizedGeohash)
+ ) {
+ return false
+ }
+
+ val mesh = meshProvider()
+ val identity = signingIdentityFor(normalizedGeohash) ?: return false
+ val signingKey = identity.publicKey.copyOf()
+ val postID = ByteArray(BoardWireConstants.POST_ID_LENGTH).also(random::nextBytes)
+ val createdAt = nowMs()
+ val expiresAt = createdAt + expiryDays.toULong() * DAY_MS
+ val authorNickname = truncateUtf8(nickname.orEmpty(), BoardWireConstants.NICKNAME_MAX_BYTES)
+ val flags: UByte = if (urgent) BoardPostPacket.URGENT_FLAG else 0u
+ val signingBytes = BoardPostPacket.signingBytes(
+ postID = postID,
+ geohash = normalizedGeohash,
+ content = trimmed,
+ authorSigningKey = signingKey,
+ authorNickname = authorNickname,
+ createdAt = createdAt,
+ expiresAt = expiresAt,
+ flags = flags
+ )
+ val signature = identity.sign(signingBytes)
+ ?.takeIf { it.size == BoardWireConstants.SIGNATURE_LENGTH }
+ ?: return false
+ val post = BoardPostPacket(
+ postID = postID,
+ geohash = normalizedGeohash,
+ content = trimmed,
+ authorSigningKey = signingKey,
+ authorNickname = authorNickname,
+ createdAt = createdAt,
+ expiresAt = expiresAt,
+ flags = flags,
+ signature = signature
+ )
+ mesh.sendBoardPayload(BoardWireCodec.encode(BoardWire.Post(post)))
+
+ if (normalizedGeohash.isNotEmpty()) {
+ notesManager.publishBoardBridge(
+ content = trimmed,
+ geohash = normalizedGeohash,
+ nickname = authorNickname,
+ expiresAtSeconds = (expiresAt / 1_000u).coerceAtMost(Int.MAX_VALUE.toULong()).toInt(),
+ urgent = urgent
+ ) { eventID ->
+ synchronized(bridgedEventIDs) {
+ bridgedEventIDs[post.identityKey()] = eventID
+ }
+ }
+ }
+ return true
+ }
+
+ fun deletePost(post: BoardPostPacket): Boolean {
+ val identity = signingIdentityFor(post.geohash)
+ ?.takeIf { it.publicKey.contentEquals(post.authorSigningKey) }
+ ?: return false
+ val deletedAt = nowMs()
+ val signature = identity.sign(
+ BoardTombstonePacket.signingBytes(post.postID, deletedAt)
+ )?.takeIf { it.size == BoardWireConstants.SIGNATURE_LENGTH } ?: return false
+ val tombstone = BoardTombstonePacket(
+ postID = post.postID,
+ authorSigningKey = post.authorSigningKey,
+ deletedAt = deletedAt,
+ signature = signature
+ )
+ meshProvider().sendBoardPayload(BoardWireCodec.encode(BoardWire.Tombstone(tombstone)))
+
+ if (post.geohash.isNotEmpty()) {
+ val eventID = synchronized(bridgedEventIDs) {
+ bridgedEventIDs.remove(post.identityKey())
+ }
+ if (eventID != null) notesManager.deleteEvent(eventID, post.geohash)
+ }
+ return true
+ }
+
+ fun markSeen(scopes: Set) {
+ if (scopes.isEmpty()) return
+ _unseenScopes.value = _unseenScopes.value - scopes
+ }
+
+ fun clearTransientState() {
+ _unseenScopes.value = emptySet()
+ synchronized(bridgedEventIDs) { bridgedEventIDs.clear() }
+ handledPostIDs.clear()
+ pendingUrgent.clear()
+ alertFlushJob?.cancel()
+ alertFlushJob = null
+ }
+
+ private fun handleArrival(post: BoardPostPacket) {
+ if (!handledPostIDs.add(post.identityKey()) || isOwnPost(post)) return
+ _unseenScopes.value = _unseenScopes.value + post.geohash
+ val age = nowMs().toLong() -
+ post.createdAt.coerceAtMost(Long.MAX_VALUE.toULong()).toLong()
+ if (!post.isUrgent || age > URGENT_RECENCY_MS) return
+
+ pendingUrgent.getOrPut(post.geohash) { mutableListOf() } += post
+ if (alertFlushJob == null) {
+ alertFlushJob = scope.launch {
+ delay(ALERT_COLLAPSE_MS)
+ val pending = pendingUrgent.mapValues { it.value.toList() }
+ pendingUrgent.clear()
+ alertFlushJob = null
+ pending.forEach { (geohash, posts) -> onUrgentPosts(geohash, posts) }
+ }
+ }
+ }
+
+ private fun isValidGeohash(value: String): Boolean =
+ value.isEmpty() ||
+ (value.length <= BoardWireConstants.GEOHASH_MAX_LENGTH &&
+ value.all { it in BoardWireConstants.GEOHASH_ALPHABET })
+
+ private fun truncateUtf8(value: String, maxBytes: Int): String {
+ var result = value
+ while (result.toByteArray(Charsets.UTF_8).size > maxBytes && result.isNotEmpty()) {
+ result = result.dropLast(1)
+ }
+ return result
+ }
+
+ private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+
+ private fun BoardPostPacket.identityKey(): String =
+ "${authorSigningKey.toHex()}:${postID.toHex()}"
+
+ private fun signingIdentityFor(geohash: String): BoardSigningIdentity? {
+ if (geohash.isNotEmpty()) {
+ // Never fall back to the stable mesh identity for a location scope.
+ return runCatching { geoIdentityProvider(geohash) }.getOrNull()
+ }
+ val mesh = meshProvider()
+ val publicKey = mesh.getSigningPublicKey()
+ ?.takeIf { it.size == BoardWireConstants.SIGNING_KEY_LENGTH }
+ ?: return null
+ return BoardSigningIdentity(publicKey, mesh::signData)
+ }
+
+ private companion object {
+ const val DAY_MS: ULong = 86_400_000uL
+ const val URGENT_RECENCY_MS = 30 * 60 * 1_000L
+ const val ALERT_COLLAPSE_MS = 4_000L
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/board/BoardPackets.kt b/app/src/main/java/com/bitchat/android/board/BoardPackets.kt
new file mode 100644
index 00000000..62ba7464
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/board/BoardPackets.kt
@@ -0,0 +1,402 @@
+package com.bitchat.android.board
+
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters
+import org.bouncycastle.crypto.signers.Ed25519Signer
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.charset.CodingErrorAction
+import java.security.MessageDigest
+
+object BoardWireConstants {
+ const val POST_ID_LENGTH = 16
+ const val SIGNING_KEY_LENGTH = 32
+ const val SIGNATURE_LENGTH = 64
+ const val TRANSPORT_SENDER_ID_LENGTH = 8
+ const val CONTENT_MAX_BYTES = 512
+ const val NICKNAME_MAX_BYTES = 64
+ const val GEOHASH_MAX_LENGTH = 12
+ const val MAX_LIFETIME_MS: ULong = 604_800_000uL
+ const val POST_SIGNING_CONTEXT = "bitchat-board-v1"
+ const val TOMBSTONE_SIGNING_CONTEXT = "bitchat-board-del-v1"
+ const val GEOHASH_ALPHABET = "0123456789bcdefghjkmnpqrstuvwxyz"
+}
+
+class BoardPostPacket(
+ val postID: ByteArray,
+ val geohash: String,
+ val content: String,
+ val authorSigningKey: ByteArray,
+ val authorNickname: String,
+ val createdAt: ULong,
+ val expiresAt: ULong,
+ val flags: UByte,
+ val signature: ByteArray
+) {
+ val isUrgent: Boolean
+ get() = (flags.toInt() and URGENT_FLAG.toInt()) != 0
+
+ val signingBytes: ByteArray
+ get() = signingBytes(
+ postID = postID,
+ geohash = geohash,
+ content = content,
+ authorSigningKey = authorSigningKey,
+ authorNickname = authorNickname,
+ createdAt = createdAt,
+ expiresAt = expiresAt,
+ flags = flags
+ )
+
+ fun verifySignature(): Boolean =
+ BoardWireCodec.verify(signature, signingBytes, authorSigningKey)
+
+ override fun equals(other: Any?): Boolean =
+ other is BoardPostPacket &&
+ postID.contentEquals(other.postID) &&
+ geohash == other.geohash &&
+ content == other.content &&
+ authorSigningKey.contentEquals(other.authorSigningKey) &&
+ authorNickname == other.authorNickname &&
+ createdAt == other.createdAt &&
+ expiresAt == other.expiresAt &&
+ flags == other.flags &&
+ signature.contentEquals(other.signature)
+
+ override fun hashCode(): Int {
+ var result = postID.contentHashCode()
+ result = 31 * result + geohash.hashCode()
+ result = 31 * result + content.hashCode()
+ result = 31 * result + authorSigningKey.contentHashCode()
+ result = 31 * result + authorNickname.hashCode()
+ result = 31 * result + createdAt.hashCode()
+ result = 31 * result + expiresAt.hashCode()
+ result = 31 * result + flags.hashCode()
+ return 31 * result + signature.contentHashCode()
+ }
+
+ companion object {
+ const val URGENT_FLAG: UByte = 0x01u
+
+ fun signingBytes(
+ postID: ByteArray,
+ geohash: String,
+ content: String,
+ authorSigningKey: ByteArray,
+ authorNickname: String,
+ createdAt: ULong,
+ expiresAt: ULong,
+ flags: UByte
+ ): ByteArray = ByteArrayOutputStream().apply {
+ appendContext(BoardWireConstants.POST_SIGNING_CONTEXT)
+ write(postID)
+ appendLengthPrefixed(geohash.toByteArray(Charsets.UTF_8))
+ appendLengthPrefixed(content.toByteArray(Charsets.UTF_8))
+ write(authorSigningKey)
+ appendLengthPrefixed(authorNickname.toByteArray(Charsets.UTF_8))
+ appendULong(createdAt)
+ appendULong(expiresAt)
+ write(flags.toInt())
+ }.toByteArray()
+ }
+}
+
+class BoardTombstonePacket(
+ val postID: ByteArray,
+ val authorSigningKey: ByteArray,
+ val deletedAt: ULong,
+ val signature: ByteArray
+) {
+ val signingBytes: ByteArray
+ get() = signingBytes(postID, deletedAt)
+
+ fun verifySignature(): Boolean =
+ BoardWireCodec.verify(signature, signingBytes, authorSigningKey)
+
+ override fun equals(other: Any?): Boolean =
+ other is BoardTombstonePacket &&
+ postID.contentEquals(other.postID) &&
+ authorSigningKey.contentEquals(other.authorSigningKey) &&
+ deletedAt == other.deletedAt &&
+ signature.contentEquals(other.signature)
+
+ override fun hashCode(): Int {
+ var result = postID.contentHashCode()
+ result = 31 * result + authorSigningKey.contentHashCode()
+ result = 31 * result + deletedAt.hashCode()
+ return 31 * result + signature.contentHashCode()
+ }
+
+ companion object {
+ fun signingBytes(postID: ByteArray, deletedAt: ULong): ByteArray =
+ ByteArrayOutputStream().apply {
+ appendContext(BoardWireConstants.TOMBSTONE_SIGNING_CONTEXT)
+ write(postID)
+ appendULong(deletedAt)
+ }.toByteArray()
+ }
+}
+
+sealed interface BoardWire {
+ data class Post(val packet: BoardPostPacket) : BoardWire
+ data class Tombstone(val packet: BoardTombstonePacket) : BoardWire
+
+ fun verifySignature(): Boolean = when (this) {
+ is Post -> packet.verifySignature()
+ is Tombstone -> packet.verifySignature()
+ }
+}
+
+/**
+ * Board payloads authenticate their embedded author key, so their outer mesh
+ * sender must not expose the device's stable peer ID. The pseudonym remains
+ * stable only for one board signing identity.
+ */
+fun BoardWire.transportSenderID(): ByteArray {
+ val authorKey = when (this) {
+ is BoardWire.Post -> packet.authorSigningKey
+ is BoardWire.Tombstone -> packet.authorSigningKey
+ }
+ return MessageDigest.getInstance("SHA-256")
+ .digest(authorKey)
+ .copyOf(BoardWireConstants.TRANSPORT_SENDER_ID_LENGTH)
+}
+
+object BoardWireCodec {
+ private const val TLV_KIND = 0x01
+ private const val TLV_POST_ID = 0x02
+ private const val TLV_GEOHASH = 0x03
+ private const val TLV_CONTENT = 0x04
+ private const val TLV_AUTHOR_SIGNING_KEY = 0x05
+ private const val TLV_AUTHOR_NICKNAME = 0x06
+ private const val TLV_CREATED_AT = 0x07
+ private const val TLV_EXPIRES_AT = 0x08
+ private const val TLV_FLAGS = 0x09
+ private const val TLV_SIGNATURE = 0x0A
+ private const val TLV_DELETED_AT = 0x0B
+ private const val KIND_POST = 0x01
+ private const val KIND_TOMBSTONE = 0x02
+
+ fun encode(wire: BoardWire): ByteArray = ByteArrayOutputStream().apply {
+ when (wire) {
+ is BoardWire.Post -> with(wire.packet) {
+ appendTlv(TLV_KIND, byteArrayOf(KIND_POST.toByte()))
+ appendTlv(TLV_POST_ID, postID)
+ appendTlv(TLV_GEOHASH, geohash.toByteArray(Charsets.UTF_8))
+ appendTlv(TLV_CONTENT, content.toByteArray(Charsets.UTF_8))
+ appendTlv(TLV_AUTHOR_SIGNING_KEY, authorSigningKey)
+ appendTlv(TLV_AUTHOR_NICKNAME, authorNickname.toByteArray(Charsets.UTF_8))
+ appendTlv(TLV_CREATED_AT, createdAt.toBigEndianBytes())
+ appendTlv(TLV_EXPIRES_AT, expiresAt.toBigEndianBytes())
+ appendTlv(TLV_FLAGS, byteArrayOf(flags.toByte()))
+ appendTlv(TLV_SIGNATURE, signature)
+ }
+
+ is BoardWire.Tombstone -> with(wire.packet) {
+ appendTlv(TLV_KIND, byteArrayOf(KIND_TOMBSTONE.toByte()))
+ appendTlv(TLV_POST_ID, postID)
+ appendTlv(TLV_AUTHOR_SIGNING_KEY, authorSigningKey)
+ appendTlv(TLV_DELETED_AT, deletedAt.toBigEndianBytes())
+ appendTlv(TLV_SIGNATURE, signature)
+ }
+ }
+ }.toByteArray()
+
+ fun decode(data: ByteArray): BoardWire? {
+ var offset = 0
+ var kind: Int? = null
+ var postID: ByteArray? = null
+ var geohash: String? = null
+ var content: String? = null
+ var contentBytes = 0
+ var authorSigningKey: ByteArray? = null
+ var authorNickname: String? = null
+ var nicknameBytes = 0
+ var createdAt: ULong? = null
+ var expiresAt: ULong? = null
+ var flags: UByte? = null
+ var signature: ByteArray? = null
+ var deletedAt: ULong? = null
+
+ while (offset + 3 <= data.size) {
+ val type = data[offset].toInt() and 0xFF
+ offset += 1
+ val length =
+ ((data[offset].toInt() and 0xFF) shl 8) or (data[offset + 1].toInt() and 0xFF)
+ offset += 2
+ if (length > data.size - offset) return null
+ val value = data.copyOfRange(offset, offset + length)
+ offset += length
+
+ when (type) {
+ TLV_KIND -> {
+ if (value.size != 1) return null
+ kind = value[0].toInt() and 0xFF
+ }
+ TLV_POST_ID -> {
+ if (value.size != BoardWireConstants.POST_ID_LENGTH) return null
+ postID = value
+ }
+ TLV_GEOHASH -> {
+ if (value.size > BoardWireConstants.GEOHASH_MAX_LENGTH) return null
+ geohash = decodeUtf8(value) ?: return null
+ }
+ TLV_CONTENT -> {
+ if (value.size > BoardWireConstants.CONTENT_MAX_BYTES) return null
+ contentBytes = value.size
+ content = decodeUtf8(value) ?: return null
+ }
+ TLV_AUTHOR_SIGNING_KEY -> {
+ if (value.size != BoardWireConstants.SIGNING_KEY_LENGTH) return null
+ authorSigningKey = value
+ }
+ TLV_AUTHOR_NICKNAME -> {
+ if (value.size > BoardWireConstants.NICKNAME_MAX_BYTES) return null
+ nicknameBytes = value.size
+ authorNickname = decodeUtf8(value) ?: return null
+ }
+ TLV_CREATED_AT -> createdAt = value.toULongBigEndian() ?: return null
+ TLV_EXPIRES_AT -> expiresAt = value.toULongBigEndian() ?: return null
+ TLV_FLAGS -> {
+ if (value.size != 1) return null
+ flags = value[0].toUByte()
+ }
+ TLV_SIGNATURE -> {
+ if (value.size != BoardWireConstants.SIGNATURE_LENGTH) return null
+ signature = value
+ }
+ TLV_DELETED_AT -> deletedAt = value.toULongBigEndian() ?: return null
+ }
+ }
+
+ val requiredPostID = postID ?: return null
+ val requiredKey = authorSigningKey ?: return null
+ val requiredSignature = signature ?: return null
+ return when (kind) {
+ KIND_POST -> {
+ val requiredGeohash = geohash ?: return null
+ val requiredContent = content ?: return null
+ val requiredNickname = authorNickname ?: return null
+ val requiredCreatedAt = createdAt ?: return null
+ val requiredExpiresAt = expiresAt ?: return null
+ val requiredFlags = flags ?: return null
+ if (contentBytes !in 1..BoardWireConstants.CONTENT_MAX_BYTES) return null
+ if (nicknameBytes > BoardWireConstants.NICKNAME_MAX_BYTES) return null
+ if (!isValidGeohash(requiredGeohash)) return null
+ if (requiredExpiresAt <= requiredCreatedAt) return null
+ if (requiredExpiresAt - requiredCreatedAt > BoardWireConstants.MAX_LIFETIME_MS) return null
+ BoardWire.Post(
+ BoardPostPacket(
+ postID = requiredPostID,
+ geohash = requiredGeohash,
+ content = requiredContent,
+ authorSigningKey = requiredKey,
+ authorNickname = requiredNickname,
+ createdAt = requiredCreatedAt,
+ expiresAt = requiredExpiresAt,
+ flags = requiredFlags,
+ signature = requiredSignature
+ )
+ )
+ }
+
+ KIND_TOMBSTONE -> BoardWire.Tombstone(
+ BoardTombstonePacket(
+ postID = requiredPostID,
+ authorSigningKey = requiredKey,
+ deletedAt = deletedAt ?: return null,
+ signature = requiredSignature
+ )
+ )
+
+ else -> null
+ }
+ }
+
+ fun urgentFlag(data: ByteArray): Boolean {
+ var offset = 0
+ while (offset + 3 <= data.size) {
+ val type = data[offset].toInt() and 0xFF
+ offset += 1
+ val length =
+ ((data[offset].toInt() and 0xFF) shl 8) or (data[offset + 1].toInt() and 0xFF)
+ offset += 2
+ if (length > data.size - offset) return false
+ if (type == TLV_FLAGS && length == 1) {
+ return (data[offset].toInt() and BoardPostPacket.URGENT_FLAG.toInt()) != 0
+ }
+ offset += length
+ }
+ return false
+ }
+
+ internal fun verify(signature: ByteArray, message: ByteArray, publicKey: ByteArray): Boolean =
+ try {
+ if (signature.size != BoardWireConstants.SIGNATURE_LENGTH ||
+ publicKey.size != BoardWireConstants.SIGNING_KEY_LENGTH
+ ) {
+ false
+ } else {
+ Ed25519Signer().run {
+ init(false, Ed25519PublicKeyParameters(publicKey, 0))
+ update(message, 0, message.size)
+ verifySignature(signature)
+ }
+ }
+ } catch (_: Exception) {
+ false
+ }
+
+ private fun isValidGeohash(value: String): Boolean =
+ value.isEmpty() ||
+ (value.length <= BoardWireConstants.GEOHASH_MAX_LENGTH &&
+ value.all { it in BoardWireConstants.GEOHASH_ALPHABET })
+
+ private fun decodeUtf8(value: ByteArray): String? =
+ try {
+ Charsets.UTF_8.newDecoder()
+ .onMalformedInput(CodingErrorAction.REPORT)
+ .onUnmappableCharacter(CodingErrorAction.REPORT)
+ .decode(ByteBuffer.wrap(value))
+ .toString()
+ } catch (_: Exception) {
+ null
+ }
+}
+
+private fun ByteArrayOutputStream.appendTlv(type: Int, value: ByteArray) {
+ require(value.size <= 0xFFFF)
+ write(type)
+ write((value.size ushr 8) and 0xFF)
+ write(value.size and 0xFF)
+ write(value)
+}
+
+private fun ByteArrayOutputStream.appendContext(context: String) {
+ val value = context.toByteArray(Charsets.UTF_8).take(255).toByteArray()
+ write(value.size)
+ write(value)
+}
+
+private fun ByteArrayOutputStream.appendLengthPrefixed(value: ByteArray) {
+ val limited = value.take(0xFFFF).toByteArray()
+ write((limited.size ushr 8) and 0xFF)
+ write(limited.size and 0xFF)
+ write(limited)
+}
+
+private fun ByteArrayOutputStream.appendULong(value: ULong) {
+ write(value.toBigEndianBytes())
+}
+
+private fun ULong.toBigEndianBytes(): ByteArray =
+ ByteArray(8) { index -> (this shr ((7 - index) * 8)).toByte() }
+
+private fun ByteArray.toULongBigEndian(): ULong? {
+ if (size != 8) return null
+ var value = 0uL
+ for (byte in this) {
+ value = (value shl 8) or (byte.toULong() and 0xFFuL)
+ }
+ return value
+}
diff --git a/app/src/main/java/com/bitchat/android/board/BoardSigningIdentity.kt b/app/src/main/java/com/bitchat/android/board/BoardSigningIdentity.kt
new file mode 100644
index 00000000..a9ab35d1
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/board/BoardSigningIdentity.kt
@@ -0,0 +1,59 @@
+package com.bitchat.android.board
+
+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters
+import org.bouncycastle.crypto.signers.Ed25519Signer
+import java.security.MessageDigest
+
+/**
+ * Signing identity used by board payloads.
+ *
+ * Location boards use a key derived from the already-unlinkable per-geohash
+ * Nostr secret. Domain separation keeps the board Ed25519 identity distinct
+ * from the secp256k1 identity used on relays.
+ */
+class BoardSigningIdentity(
+ publicKey: ByteArray,
+ private val signer: (ByteArray) -> ByteArray?
+) {
+ val publicKey: ByteArray = publicKey.copyOf()
+
+ init {
+ require(publicKey.size == BoardWireConstants.SIGNING_KEY_LENGTH)
+ }
+
+ fun sign(message: ByteArray): ByteArray? = signer(message)?.copyOf()
+
+ companion object {
+ private const val GEO_IDENTITY_CONTEXT = "bitchat-board-geo-identity-v1"
+
+ fun fromNostrPrivateKeyHex(privateKeyHex: String): BoardSigningIdentity? =
+ runCatching {
+ val nostrSecret = privateKeyHex.hexToByteArray()
+ .takeIf { it.size == BoardWireConstants.SIGNING_KEY_LENGTH }
+ ?: return@runCatching null
+ val digest = MessageDigest.getInstance("SHA-256")
+ digest.update(GEO_IDENTITY_CONTEXT.toByteArray(Charsets.UTF_8))
+ digest.update(nostrSecret)
+ fromEd25519Seed(digest.digest())
+ }.getOrNull()
+
+ fun fromEd25519Seed(seed: ByteArray): BoardSigningIdentity {
+ require(seed.size == BoardWireConstants.SIGNING_KEY_LENGTH)
+ val privateKey = Ed25519PrivateKeyParameters(seed.copyOf(), 0)
+ return BoardSigningIdentity(privateKey.generatePublicKey().encoded) { message ->
+ Ed25519Signer().run {
+ init(true, privateKey)
+ update(message, 0, message.size)
+ generateSignature()
+ }
+ }
+ }
+
+ private fun String.hexToByteArray(): ByteArray {
+ require(length % 2 == 0)
+ return ByteArray(length / 2) { index ->
+ substring(index * 2, index * 2 + 2).toInt(16).toByte()
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/board/BoardStore.kt b/app/src/main/java/com/bitchat/android/board/BoardStore.kt
new file mode 100644
index 00000000..19bfc1a5
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/board/BoardStore.kt
@@ -0,0 +1,382 @@
+package com.bitchat.android.board
+
+import android.content.Context
+import android.util.Log
+import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.protocol.MessageType
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+import java.io.File
+import java.util.Base64
+
+enum class BoardIngestResult {
+ ACCEPTED,
+ DUPLICATE,
+ REJECTED
+}
+
+enum class BoardIngestSource {
+ REMOTE,
+ LOCAL,
+ RESTORE
+}
+
+class BoardStore(
+ private val file: File? = null,
+ private val nowMs: () -> ULong = { System.currentTimeMillis().coerceAtLeast(0).toULong() }
+) {
+ object Limits {
+ const val MAX_POSTS = 200
+ const val MAX_POSTS_PER_AUTHOR = 5
+ const val MAX_ORPHAN_TOMBSTONES = 100
+ const val MAX_ORPHAN_TOMBSTONES_PER_AUTHOR = 5
+ const val CLOCK_SKEW_MS: ULong = 3_600_000uL
+ const val ORPHAN_TOMBSTONE_LIFETIME_MS: ULong = BoardWireConstants.MAX_LIFETIME_MS
+ }
+
+ private data class StoredPost(
+ val post: BoardPostPacket,
+ val packet: BitchatPacket,
+ val rawPacket: ByteArray
+ )
+
+ private data class StoredTombstone(
+ val tombstone: BoardTombstonePacket,
+ val packet: BitchatPacket,
+ val rawPacket: ByteArray,
+ val retainUntil: ULong,
+ val isOrphan: Boolean
+ )
+
+ private data class PersistedEntry(
+ val packet: String,
+ val retainUntil: String?
+ )
+
+ private val lock = Any()
+ private val posts = mutableListOf()
+ private val tombstones = mutableListOf()
+ private val _postsSnapshot = MutableStateFlow>(emptyList())
+ private val _postArrivals = MutableSharedFlow(extraBufferCapacity = 64)
+
+ val postsSnapshot: StateFlow> = _postsSnapshot.asStateFlow()
+ val postArrivals: SharedFlow = _postArrivals.asSharedFlow()
+
+ init {
+ loadFromDisk()
+ }
+
+ fun ingest(
+ wire: BoardWire,
+ packet: BitchatPacket,
+ source: BoardIngestSource = BoardIngestSource.REMOTE
+ ): BoardIngestResult {
+ if (packet.type != MessageType.BOARD_POST.value || !wire.verifySignature()) {
+ return BoardIngestResult.REJECTED
+ }
+ val rawPacket = packet.toBinaryData(padding = false) ?: return BoardIngestResult.REJECTED
+ val now = nowMs()
+ var arrival: BoardPostPacket? = null
+ val result = synchronized(lock) {
+ val outcome = ingestLocked(
+ wire = wire,
+ packet = packet,
+ rawPacket = rawPacket,
+ now = now,
+ retainUntilOverride = null
+ )
+ if (outcome == BoardIngestResult.ACCEPTED && source != BoardIngestSource.RESTORE) {
+ persistLocked()
+ }
+ if (outcome == BoardIngestResult.ACCEPTED &&
+ source == BoardIngestSource.REMOTE &&
+ wire is BoardWire.Post
+ ) {
+ arrival = wire.packet
+ }
+ outcome
+ }
+ arrival?.let(_postArrivals::tryEmit)
+ return result
+ }
+
+ /**
+ * Ingests a packet received from the mesh and reports whether this exact
+ * arrival may continue through the live relay path.
+ *
+ * A duplicate board payload must not relay again: the payload signature
+ * does not authenticate mutable outer packet fields such as timestamp, so
+ * accepting duplicates for relay would let one captured notice be wrapped
+ * in infinitely many distinct outer packets.
+ */
+ fun ingestRemoteForRelay(wire: BoardWire, packet: BitchatPacket): Boolean =
+ ingest(wire, packet, BoardIngestSource.REMOTE) == BoardIngestResult.ACCEPTED
+
+ fun posts(forGeohash: String): List = synchronized(lock) {
+ pruneExpiredLocked(nowMs())
+ posts.asSequence()
+ .map { it.post }
+ .filter { it.geohash == forGeohash }
+ .sortedWith(
+ compareByDescending { it.isUrgent }
+ .thenByDescending { it.createdAt }
+ )
+ .toList()
+ }
+
+ fun syncCandidates(): List = synchronized(lock) {
+ pruneExpiredLocked(nowMs())
+ posts.map { it.packet } + tombstones.map { it.packet }
+ }
+
+ fun pruneExpired() = synchronized(lock) {
+ val changed = pruneExpiredLocked(nowMs())
+ if (changed) persistLocked()
+ }
+
+ fun wipe() = synchronized(lock) {
+ posts.clear()
+ tombstones.clear()
+ file?.let { check(!it.exists() || it.delete()) }
+ publishSnapshotLocked()
+ }
+
+ private fun ingestLocked(
+ wire: BoardWire,
+ packet: BitchatPacket,
+ rawPacket: ByteArray,
+ now: ULong,
+ retainUntilOverride: ULong?
+ ): BoardIngestResult {
+ pruneExpiredLocked(now)
+ return when (wire) {
+ is BoardWire.Post -> ingestPostLocked(wire.packet, packet, rawPacket, now)
+ is BoardWire.Tombstone -> ingestTombstoneLocked(
+ wire.packet,
+ packet,
+ rawPacket,
+ now,
+ retainUntilOverride
+ )
+ }
+ }
+
+ private fun ingestPostLocked(
+ post: BoardPostPacket,
+ packet: BitchatPacket,
+ rawPacket: ByteArray,
+ now: ULong
+ ): BoardIngestResult {
+ if (post.expiresAt <= now) return BoardIngestResult.REJECTED
+ if (post.createdAt > now.saturatedAdd(Limits.CLOCK_SKEW_MS)) {
+ return BoardIngestResult.REJECTED
+ }
+ if (post.expiresAt > now.saturatedAdd(BoardWireConstants.MAX_LIFETIME_MS)
+ .saturatedAdd(Limits.CLOCK_SKEW_MS)
+ ) {
+ return BoardIngestResult.REJECTED
+ }
+ if (tombstones.any {
+ it.tombstone.postID.contentEquals(post.postID) &&
+ it.tombstone.authorSigningKey.contentEquals(post.authorSigningKey)
+ }
+ ) {
+ return BoardIngestResult.REJECTED
+ }
+ if (posts.any {
+ it.post.postID.contentEquals(post.postID) &&
+ it.post.authorSigningKey.contentEquals(post.authorSigningKey)
+ }
+ ) {
+ return BoardIngestResult.DUPLICATE
+ }
+
+ posts += StoredPost(post, packet, rawPacket)
+ enforcePostCapsLocked(post.authorSigningKey)
+ publishSnapshotLocked()
+ return BoardIngestResult.ACCEPTED
+ }
+
+ private fun ingestTombstoneLocked(
+ tombstone: BoardTombstonePacket,
+ packet: BitchatPacket,
+ rawPacket: ByteArray,
+ now: ULong,
+ retainUntilOverride: ULong?
+ ): BoardIngestResult {
+ if (tombstones.any {
+ it.tombstone.postID.contentEquals(tombstone.postID) &&
+ it.tombstone.authorSigningKey.contentEquals(tombstone.authorSigningKey)
+ }
+ ) {
+ return BoardIngestResult.DUPLICATE
+ }
+
+ val maxRetain = minOf(
+ tombstone.deletedAt.saturatedAdd(Limits.ORPHAN_TOMBSTONE_LIFETIME_MS),
+ now.saturatedAdd(Limits.ORPHAN_TOMBSTONE_LIFETIME_MS)
+ .saturatedAdd(Limits.CLOCK_SKEW_MS)
+ )
+ val matchingPostIndex = posts.indexOfFirst {
+ it.post.postID.contentEquals(tombstone.postID) &&
+ it.post.authorSigningKey.contentEquals(tombstone.authorSigningKey)
+ }
+ val retainUntil: ULong
+ val isOrphan: Boolean
+ if (matchingPostIndex >= 0) {
+ val target = posts[matchingPostIndex].post
+ retainUntil = target.expiresAt
+ isOrphan = false
+ posts.removeAt(matchingPostIndex)
+ publishSnapshotLocked()
+ } else if (retainUntilOverride != null) {
+ retainUntil = minOf(retainUntilOverride, maxRetain)
+ isOrphan = false
+ } else {
+ retainUntil = maxRetain
+ isOrphan = true
+ }
+ if (retainUntil <= now) return BoardIngestResult.REJECTED
+
+ tombstones += StoredTombstone(
+ tombstone = tombstone,
+ packet = packet,
+ rawPacket = rawPacket,
+ retainUntil = retainUntil,
+ isOrphan = isOrphan
+ )
+ if (isOrphan) enforceOrphanTombstoneCapsLocked(tombstone.authorSigningKey)
+ return BoardIngestResult.ACCEPTED
+ }
+
+ private fun enforcePostCapsLocked(author: ByteArray) {
+ val authorPosts = posts.filter { it.post.authorSigningKey.contentEquals(author) }
+ evictOldestPostsLocked(authorPosts, Limits.MAX_POSTS_PER_AUTHOR)
+ evictOldestPostsLocked(posts.toList(), Limits.MAX_POSTS)
+ }
+
+ private fun evictOldestPostsLocked(candidates: List, keep: Int) {
+ val victims = candidates.sortedBy { it.post.createdAt }
+ .take((candidates.size - keep).coerceAtLeast(0))
+ if (victims.isNotEmpty()) {
+ posts.removeAll { stored -> victims.any { it === stored } }
+ }
+ }
+
+ private fun enforceOrphanTombstoneCapsLocked(author: ByteArray) {
+ val authorOrphans = tombstones.filter {
+ it.isOrphan && it.tombstone.authorSigningKey.contentEquals(author)
+ }
+ removeOldestTombstonesLocked(
+ authorOrphans,
+ authorOrphans.size - Limits.MAX_ORPHAN_TOMBSTONES_PER_AUTHOR
+ )
+ val allOrphans = tombstones.filter { it.isOrphan }
+ removeOldestTombstonesLocked(
+ allOrphans,
+ allOrphans.size - Limits.MAX_ORPHAN_TOMBSTONES
+ )
+ }
+
+ private fun removeOldestTombstonesLocked(
+ candidates: List,
+ count: Int
+ ) {
+ if (count <= 0) return
+ val victims = candidates.take(count)
+ tombstones.removeAll { stored -> victims.any { it === stored } }
+ }
+
+ private fun pruneExpiredLocked(now: ULong): Boolean {
+ val postsBefore = posts.size
+ val tombstonesBefore = tombstones.size
+ posts.removeAll { it.post.expiresAt <= now }
+ tombstones.removeAll { it.retainUntil <= now }
+ if (posts.size != postsBefore) publishSnapshotLocked()
+ return posts.size != postsBefore || tombstones.size != tombstonesBefore
+ }
+
+ private fun publishSnapshotLocked() {
+ _postsSnapshot.value = posts.map { it.post }
+ }
+
+ private fun persistLocked() {
+ val target = file ?: return
+ val entries = posts.map {
+ PersistedEntry(
+ packet = Base64.getEncoder().encodeToString(it.rawPacket),
+ retainUntil = null
+ )
+ } + tombstones.map {
+ PersistedEntry(
+ packet = Base64.getEncoder().encodeToString(it.rawPacket),
+ retainUntil = it.retainUntil.toString()
+ )
+ }
+ runCatching {
+ if (entries.isEmpty()) {
+ if (target.exists()) target.delete()
+ return
+ }
+ target.parentFile?.mkdirs()
+ val temporary = File(target.parentFile, "${target.name}.tmp")
+ temporary.writeText(Gson().toJson(entries))
+ if (!temporary.renameTo(target)) {
+ temporary.copyTo(target, overwrite = true)
+ temporary.delete()
+ }
+ }.onFailure {
+ Log.e(TAG, "Failed to persist board store: ${it.message}")
+ }
+ }
+
+ private fun loadFromDisk() {
+ val target = file ?: return
+ if (!target.isFile) return
+ val entries = runCatching {
+ val type = object : TypeToken>() {}.type
+ Gson().fromJson>(target.readText(), type)
+ }.getOrNull() ?: return
+ val now = nowMs()
+ synchronized(lock) {
+ for (entry in entries) {
+ val raw = runCatching { Base64.getDecoder().decode(entry.packet) }.getOrNull() ?: continue
+ val packet = BitchatPacket.fromBinaryData(raw) ?: continue
+ if (packet.type != MessageType.BOARD_POST.value) continue
+ val wire = BoardWireCodec.decode(packet.payload) ?: continue
+ if (!wire.verifySignature()) continue
+ ingestLocked(
+ wire = wire,
+ packet = packet,
+ rawPacket = raw,
+ now = now,
+ retainUntilOverride = entry.retainUntil?.toULongOrNull()
+ )
+ }
+ publishSnapshotLocked()
+ }
+ }
+
+ companion object {
+ private const val TAG = "BoardStore"
+
+ @Volatile
+ private var instance: BoardStore? = null
+
+ fun getInstance(context: Context): BoardStore =
+ instance ?: synchronized(this) {
+ instance ?: BoardStore(
+ File(context.applicationContext.filesDir, "board/posts.json")
+ ).also { instance = it }
+ }
+ }
+}
+
+private fun ULong.saturatedAdd(other: ULong): ULong =
+ if (ULong.MAX_VALUE - this < other) ULong.MAX_VALUE else this + other
diff --git a/app/src/main/java/com/bitchat/android/board/UnifiedNotices.kt b/app/src/main/java/com/bitchat/android/board/UnifiedNotices.kt
new file mode 100644
index 00000000..c91b127b
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/board/UnifiedNotices.kt
@@ -0,0 +1,87 @@
+package com.bitchat.android.board
+
+import com.bitchat.android.nostr.LocationNotesManager
+import kotlin.math.abs
+
+enum class NoticeSource {
+ MESH,
+ NOSTR
+}
+
+data class UnifiedNotice(
+ val id: String,
+ val content: String,
+ val nickname: String,
+ val createdAtMs: Long,
+ val geohash: String,
+ val urgent: Boolean,
+ val expiresAtMs: Long?,
+ val source: NoticeSource,
+ val boardPost: BoardPostPacket? = null,
+ val nostrNote: LocationNotesManager.Note? = null
+)
+
+object UnifiedNotices {
+ private const val DEDUPLICATION_WINDOW_MS = 15 * 60 * 1_000L
+
+ /**
+ * Combines exact-scope mesh board posts with relay notes. When a relay
+ * bridge copy matches a board post, the signed board copy is authoritative.
+ */
+ fun merge(
+ geohash: String,
+ boardPosts: List,
+ relayNotes: List
+ ): List {
+ val normalized = geohash.lowercase()
+ val scopedPosts = boardPosts.filter { it.geohash == normalized }
+ val boardNotices = scopedPosts.map { post ->
+ UnifiedNotice(
+ id = "mesh:${post.authorSigningKey.toHex()}:${post.postID.toHex()}",
+ content = post.content,
+ nickname = post.authorNickname,
+ createdAtMs = post.createdAt.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(),
+ geohash = post.geohash,
+ urgent = post.isUrgent,
+ expiresAtMs = post.expiresAt.coerceAtMost(Long.MAX_VALUE.toULong()).toLong(),
+ source = NoticeSource.MESH,
+ boardPost = post
+ )
+ }
+ val relayNotices = relayNotes.asSequence()
+ .filterNot { note ->
+ scopedPosts.any { post ->
+ post.geohash == note.geohash.lowercase() &&
+ post.content == note.content &&
+ post.authorNickname.ifBlank { "anon" } ==
+ note.nickname?.trim()?.takeIf { it.isNotEmpty() }.orEmpty()
+ .ifEmpty { "anon" } &&
+ abs(
+ post.createdAt.coerceAtMost(Long.MAX_VALUE.toULong()).toLong() -
+ note.createdAt.toLong() * 1_000L
+ ) <= DEDUPLICATION_WINDOW_MS
+ }
+ }
+ .map { note ->
+ UnifiedNotice(
+ id = "nostr:${note.id}",
+ content = note.content,
+ nickname = note.nickname.orEmpty(),
+ createdAtMs = note.createdAt.toLong() * 1_000L,
+ geohash = note.geohash.lowercase(),
+ urgent = note.isUrgent,
+ expiresAtMs = note.expiresAt?.toLong()?.times(1_000L),
+ source = NoticeSource.NOSTR,
+ nostrNote = note
+ )
+ }
+ .toList()
+
+ return (boardNotices + relayNotices).sortedWith(
+ compareByDescending { it.urgent }
+ .thenByDescending { it.createdAtMs }
+ )
+ }
+
+ private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+}
diff --git a/app/src/main/java/com/bitchat/android/crypto/EncryptionService.kt b/app/src/main/java/com/bitchat/android/crypto/EncryptionService.kt
index b15a6254..8f078a3d 100644
--- a/app/src/main/java/com/bitchat/android/crypto/EncryptionService.kt
+++ b/app/src/main/java/com/bitchat/android/crypto/EncryptionService.kt
@@ -112,6 +112,12 @@ open class EncryptionService(private val context: Context) {
fun getStaticPublicKey(): ByteArray? {
return noiseService.getStaticPublicKeyData()
}
+
+ fun sealCourierPayload(payload: ByteArray, recipientStaticKey: ByteArray): ByteArray =
+ noiseService.sealCourierPayload(payload, recipientStaticKey)
+
+ fun openCourierPayload(ciphertext: ByteArray): Pair =
+ noiseService.openCourierPayload(ciphertext)
/**
* Get our signing public key for Ed25519 signatures (for identity announcements)
diff --git a/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt b/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt
index da6898e8..2d8c04ea 100644
--- a/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt
+++ b/app/src/main/java/com/bitchat/android/features/file/FileUtils.kt
@@ -280,7 +280,7 @@ object FileUtils {
* Recursively delete all media files (incoming and outgoing)
* Used for Panic Mode cleanup
*/
- fun clearAllMedia(context: Context) {
+ fun clearAllMedia(context: Context): Boolean {
try {
// Clear files dir subdirectories (legacy storage and outgoing)
val filesDir = context.filesDir
@@ -295,7 +295,7 @@ object FileUtils {
dirsToClear.forEach { subDir ->
val dir = File(filesDir, subDir)
if (dir.exists()) {
- dir.deleteRecursively()
+ check(dir.deleteRecursively())
Log.d(TAG, "Deleted media directory from filesDir: $subDir")
}
}
@@ -312,17 +312,19 @@ object FileUtils {
cacheDirsToClear.forEach { subDir ->
val dir = File(cacheDir, subDir)
if (dir.exists()) {
- dir.deleteRecursively()
+ check(dir.deleteRecursively())
Log.d(TAG, "Deleted media directory from cacheDir: $subDir")
}
}
// Also clear entire cache dir as a catch-all
- context.cacheDir.deleteRecursively()
+ check(!context.cacheDir.exists() || context.cacheDir.deleteRecursively())
Log.d(TAG, "Cleared entire cache directory")
+ return true
} catch (e: Exception) {
Log.e(TAG, "Failed to clear media files", e)
+ return false
}
}
diff --git a/app/src/main/java/com/bitchat/android/features/voice/LiveVoiceManager.kt b/app/src/main/java/com/bitchat/android/features/voice/LiveVoiceManager.kt
index 05223b48..ce6bc273 100644
--- a/app/src/main/java/com/bitchat/android/features/voice/LiveVoiceManager.kt
+++ b/app/src/main/java/com/bitchat/android/features/voice/LiveVoiceManager.kt
@@ -252,14 +252,22 @@ class LiveVoiceManager private constructor(private val context: Context) {
} ?: return false
val finished = entry.value
val replacement = message.copy(
- id = finished.messageID,
+ id = if (message.isPrivate && com.bitchat.android.model.PrivateMediaMessageIdentity.isStableID(message.id)) message.id else finished.messageID,
timestamp = finished.timestamp,
sender = finished.nickname,
senderPeerID = peerID,
isPrivate = messageScope == LiveVoiceScope.DIRECT_MESSAGE
)
if (messageScope == LiveVoiceScope.DIRECT_MESSAGE) {
- AppStateStore.upsertPrivateMessage(peerID, replacement, isVisible(messageScope, peerID))
+ if (replacement.id != finished.messageID) {
+ val saved = kotlinx.coroutines.runBlocking {
+ AppStateStore.addPrivateMessageDurably(peerID, replacement, isVisible(messageScope, peerID))
+ }
+ if (!saved) return false
+ AppStateStore.removePrivateMessage(finished.messageID)
+ } else {
+ AppStateStore.upsertPrivateMessage(peerID, replacement, isVisible(messageScope, peerID))
+ }
} else {
AppStateStore.upsertPublicMessage(replacement)
}
diff --git a/app/src/main/java/com/bitchat/android/geohash/LocationChannelManager.kt b/app/src/main/java/com/bitchat/android/geohash/LocationChannelManager.kt
index 46f05950..c793c163 100644
--- a/app/src/main/java/com/bitchat/android/geohash/LocationChannelManager.kt
+++ b/app/src/main/java/com/bitchat/android/geohash/LocationChannelManager.kt
@@ -162,9 +162,12 @@ class LocationChannelManager private constructor(private val context: Context) {
/**
* Refresh available channels from current location
*/
- fun refreshChannels() {
+ fun refreshChannels(
+ forceFresh: Boolean = false,
+ updatePlaceNames: Boolean = true
+ ) {
if (syncPermissionState() == PermissionState.AUTHORIZED && isLocationServicesEnabled()) {
- requestOneShotLocation()
+ requestOneShotLocation(forceFresh, updatePlaceNames)
}
}
@@ -355,7 +358,10 @@ class LocationChannelManager private constructor(private val context: Context) {
// MARK: - Location Operations
- private fun requestOneShotLocation() {
+ private fun requestOneShotLocation(
+ forceFresh: Boolean = false,
+ updatePlaceNames: Boolean = true
+ ) {
if (!isLocationServicesEnabled() ||
syncPermissionState() != PermissionState.AUTHORIZED
) {
@@ -367,37 +373,53 @@ class LocationChannelManager private constructor(private val context: Context) {
val token = LiveLocationPrivacyGate.captureToken() ?: return
_isLoadingLocation.value = true
+ if (forceFresh) {
+ requestFreshLocation(token, updatePlaceNames)
+ return
+ }
+
val started = LiveLocationPrivacyGate.runIfAllowed(token) {
locationProvider.getLastKnownLocation { cached ->
if (!canUseLiveLocation(token)) return@getLastKnownLocation
if (cached != null) {
- onLocationUpdated(cached, token)
+ onLocationUpdated(cached, token, updatePlaceNames)
} else {
- LiveLocationPrivacyGate.runIfAllowed(token) {
- locationProvider.requestFreshLocation { fresh ->
- if (!canUseLiveLocation(token)) return@requestFreshLocation
-
- if (fresh != null) {
- onLocationUpdated(fresh, token)
- } else {
- Log.w(TAG, "Failed to get fresh location")
- _isLoadingLocation.value = false
- }
- }
- }
+ requestFreshLocation(token, updatePlaceNames)
}
}
}
if (!started) _isLoadingLocation.value = false
}
- private fun onLocationUpdated(location: Location, token: Long) {
+ private fun requestFreshLocation(
+ token: Long,
+ updatePlaceNames: Boolean
+ ) {
+ val started = LiveLocationPrivacyGate.runIfAllowed(token) {
+ locationProvider.requestFreshLocation { fresh ->
+ if (!canUseLiveLocation(token)) return@requestFreshLocation
+ if (fresh != null) {
+ onLocationUpdated(fresh, token, updatePlaceNames)
+ } else {
+ Log.w(TAG, "Failed to get fresh location")
+ _isLoadingLocation.value = false
+ }
+ }
+ }
+ if (!started) _isLoadingLocation.value = false
+ }
+
+ private fun onLocationUpdated(
+ location: Location,
+ token: Long,
+ updatePlaceNames: Boolean = true
+ ) {
LiveLocationPrivacyGate.runIfAllowed(token) {
if (!_systemLocationEnabled.value || !hasRuntimeLocationPermission()) return@runIfAllowed
_isLoadingLocation.value = false
computeChannels(location, token)
- reverseGeocodeIfNeeded(location, token)
+ if (updatePlaceNames) reverseGeocodeIfNeeded(location, token)
}
}
@@ -652,6 +674,12 @@ class LocationChannelManager private constructor(private val context: Context) {
_teleported.value = false
}
+ /** Remove exact/transient location state without destroying the singleton. */
+ fun panicReset() {
+ clearLiveLocationState()
+ clearPersistedChannel()
+ }
+
// MARK: - Location Services State Persistence
/**
diff --git a/app/src/main/java/com/bitchat/android/groups/GroupCoordinator.kt b/app/src/main/java/com/bitchat/android/groups/GroupCoordinator.kt
new file mode 100644
index 00000000..c914cf82
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/groups/GroupCoordinator.kt
@@ -0,0 +1,715 @@
+package com.bitchat.android.groups
+
+import com.bitchat.android.model.BitchatMessage
+import com.bitchat.android.model.DeliveryStatus
+import com.bitchat.android.model.PeerCapabilities
+import java.util.ArrayDeque
+import java.util.Date
+import java.util.UUID
+
+data class GroupPeerIdentity(
+ val fingerprint: String,
+ val signingKey: ByteArray
+)
+
+data class GroupCommandResult(
+ val success: Boolean,
+ val message: String
+)
+
+enum class PeerGroupCapability {
+ SUPPORTED,
+ UNSUPPORTED,
+ UNKNOWN;
+
+ companion object {
+ fun fromPeerState(
+ capabilities: PeerCapabilities?,
+ hasVerifiedAnnouncement: Boolean
+ ): PeerGroupCapability = when {
+ capabilities?.contains(PeerCapabilities.GROUPS) == true -> SUPPORTED
+ capabilities != null || hasVerifiedAnnouncement -> UNSUPPORTED
+ else -> UNKNOWN
+ }
+ }
+}
+
+interface GroupCoordinatorContext {
+ val groupStore: GroupStore
+ val nickname: String
+ val myPeerID: String
+ val selectedConversationID: String?
+
+ fun myNoiseFingerprint(): String
+ fun mySigningPublicKey(): ByteArray?
+ fun sign(data: ByteArray): ByteArray?
+
+ fun peerIDsForNickname(nickname: String): List
+ fun isPeerConnected(peerID: String): Boolean
+ fun peerGroupCapability(peerID: String): PeerGroupCapability
+ fun peerNickname(peerID: String): String?
+ fun peerIdentity(peerID: String): GroupPeerIdentity?
+ fun connectedPeerID(fingerprint: String): String?
+ fun isFingerprintBlocked(fingerprint: String): Boolean
+
+ fun sendGroupInvite(payload: ByteArray, peerID: String)
+ fun sendGroupKeyUpdate(payload: ByteArray, peerID: String)
+ fun broadcastGroupMessage(payload: ByteArray)
+
+ fun appendGroupMessage(groupPeerID: String, message: BitchatMessage): Boolean
+ fun markGroupUnread(groupPeerID: String)
+ fun removeGroupConversation(groupPeerID: String)
+ fun openGroupConversation(groupPeerID: String)
+ fun closeGroupConversation()
+ fun addSystemMessage(message: String)
+ fun addGroupSystemMessage(groupPeerID: String, message: String)
+ fun notifyGroupMessage(groupPeerID: String, sender: String, message: String)
+}
+
+/**
+ * Creator-managed private-group state machine matching iOS v1.
+ */
+class GroupCoordinator(private val context: GroupCoordinatorContext) {
+ private data class MemberSelector(
+ val nickname: String,
+ val identitySuffix: String?
+ )
+
+ private sealed class PendingEvent {
+ data class Invite(
+ val peerID: String,
+ val authenticatedRemoteStaticKey: ByteArray,
+ val payload: ByteArray
+ ) : PendingEvent()
+
+ data class KeyUpdate(
+ val peerID: String,
+ val authenticatedRemoteStaticKey: ByteArray,
+ val payload: ByteArray
+ ) : PendingEvent()
+
+ data class Message(
+ val payload: ByteArray,
+ val receivedAtMs: Long
+ ) : PendingEvent()
+
+ data class PeerAuthenticated(val peerID: String) : PendingEvent()
+ }
+
+ private data class FutureMessage(
+ val groupID: ByteArray,
+ val epoch: Long,
+ val payload: ByteArray,
+ val queuedAtMs: Long
+ )
+
+ private val lifecycleLock = Any()
+ private val pendingLock = Any()
+ private val pendingEvents = ArrayDeque()
+ private val futureMessages = ArrayDeque()
+ @Volatile
+ private var acceptsInboundEvents = true
+ @Volatile
+ private var inboundGeneration = 0L
+
+ @Synchronized
+ fun createGroup(rawName: String): GroupCommandResult {
+ if (!acceptsInboundEvents) return error("private groups are paused")
+ if (!context.groupStore.isReady) return loadingError()
+ val name = rawName.trim()
+ if (name.isEmpty()) return error("usage: /group create ")
+ if (name.codePointCount(0, name.length) > MAX_GROUP_NAME_LENGTH) {
+ return error("group name must be $MAX_GROUP_NAME_LENGTH characters or fewer")
+ }
+ val fingerprint = context.myNoiseFingerprint()
+ val signingKey = context.mySigningPublicKey()
+ if (!FINGERPRINT.matches(fingerprint) || signingKey?.size != 32) {
+ return error("your cryptographic identity is not ready")
+ }
+ val creator = GroupMember(fingerprint, signingKey, context.nickname)
+ val group = context.groupStore.createGroup(name, creator)
+ ?: return error("could not create group")
+ context.openGroupConversation(group.peerID)
+ return success("created private group #${group.name}")
+ }
+
+ @Synchronized
+ fun inviteMember(rawNickname: String): GroupCommandResult {
+ if (!acceptsInboundEvents) return error("private groups are paused")
+ if (!context.groupStore.isReady) return loadingError()
+ val selector = parseMemberSelector(rawNickname)
+ ?: return error("usage: /group invite [#identity-suffix]")
+ val nickname = selector.nickname
+ val group = selectedGroup() ?: return error("open a private group first")
+ if (!isCreator(group)) return error("only the group creator can change members")
+ val peerID = resolvePeer(selector) ?: return ambiguousPeerError(selector)
+ if (!context.isPeerConnected(peerID)) return error("$nickname is not connected")
+ when (context.peerGroupCapability(peerID)) {
+ PeerGroupCapability.SUPPORTED -> Unit
+ PeerGroupCapability.UNSUPPORTED ->
+ return error("$nickname does not support private groups")
+ PeerGroupCapability.UNKNOWN ->
+ return error("private-group support for $nickname is not confirmed yet; try again")
+ }
+ val identity = context.peerIdentity(peerID)
+ ?: return error("$nickname does not have a verified mesh identity")
+ if (group.isMember(identity.fingerprint)) return error("$nickname is already a member")
+ if (group.members.size >= BitchatGroup.MAX_MEMBERS) {
+ return error("groups are limited to ${BitchatGroup.MAX_MEMBERS} members")
+ }
+
+ val member = GroupMember(
+ identity.fingerprint,
+ identity.signingKey,
+ context.peerNickname(peerID) ?: nickname
+ )
+ val (updated, key) = context.groupStore.rotateKey(
+ group.groupID,
+ group.members + member
+ ) ?: return error("could not rotate the group key")
+ val payload = signedStatePayload(updated, key)
+ ?: return error("could not sign the group invite")
+
+ context.sendGroupInvite(payload, peerID)
+ distributeState(payload, updated, setOf(identity.fingerprint))
+ return success("invited $nickname to #${updated.name}")
+ }
+
+ @Synchronized
+ fun removeMember(rawNickname: String): GroupCommandResult {
+ if (!acceptsInboundEvents) return error("private groups are paused")
+ if (!context.groupStore.isReady) return loadingError()
+ val selector = parseMemberSelector(rawNickname)
+ ?: return error("usage: /group remove [#identity-suffix]")
+ val nickname = selector.nickname
+ val group = selectedGroup() ?: return error("open a private group first")
+ if (!isCreator(group)) return error("only the group creator can change members")
+ val matchingMembers = group.members.filter {
+ it.nickname.equals(nickname, ignoreCase = true)
+ }.let { members ->
+ selector.identitySuffix?.let { suffix ->
+ members.filter { it.fingerprint.endsWith(suffix, ignoreCase = true) }
+ } ?: members
+ }
+ val member = matchingMembers.singleOrNull() ?: return when {
+ matchingMembers.isEmpty() -> error("$nickname is not in this group")
+ else -> error(
+ "multiple members are named '$nickname'; use ${memberChoices(matchingMembers)}"
+ )
+ }
+ if (member.fingerprint == group.creatorFingerprint) {
+ return error("the creator cannot remove themselves")
+ }
+
+ val remaining = group.members.filterNot { it.fingerprint == member.fingerprint }
+ val (rotated, key) = context.groupStore.rotateKey(group.groupID, remaining)
+ ?: return error("could not rotate the group key")
+ val payload = signedStatePayload(rotated, key)
+ ?: return error("could not sign the group update")
+ distributeState(payload, rotated, emptySet())
+ notifyRemovedMember(member, rotated)
+ return success("removed ${member.nickname} and rotated the group key")
+ }
+
+ @Synchronized
+ fun leaveGroup(): GroupCommandResult {
+ if (!acceptsInboundEvents) return error("private groups are paused")
+ if (!context.groupStore.isReady) return loadingError()
+ val group = selectedGroup() ?: return error("open a private group first")
+ if (isCreator(group) && group.members.size > 1) {
+ return error("remove all other members before leaving this group")
+ }
+ val removed = if (isCreator(group)) {
+ context.groupStore.removeGroup(group.groupID)
+ } else {
+ context.groupStore.departGroup(group.groupID, group.epoch)
+ }
+ if (!removed) return error("could not leave group")
+ synchronized(lifecycleLock) {
+ dropFutureMessages(group.groupID)
+ }
+ context.closeGroupConversation()
+ context.removeGroupConversation(group.peerID)
+ return success("left #${group.name}")
+ }
+
+ @Synchronized
+ fun listGroups(): GroupCommandResult {
+ if (!context.groupStore.isReady) return loadingError()
+ val groups = context.groupStore.groups.value
+ if (groups.isEmpty()) return success("you are not in any private groups")
+ val fingerprint = context.myNoiseFingerprint()
+ val lines = groups.joinToString("\n") { group ->
+ val role = if (group.creatorFingerprint == fingerprint) " (creator)" else ""
+ "#${group.name}$role — ${group.members.size}/${BitchatGroup.MAX_MEMBERS}"
+ }
+ return success("private groups:\n$lines")
+ }
+
+ @Synchronized
+ fun sendMessage(content: String, groupPeerID: String): Boolean {
+ if (!acceptsInboundEvents) return false
+ if (!context.groupStore.isReady) {
+ context.addGroupSystemMessage(groupPeerID, "private groups are still loading")
+ return false
+ }
+ if (content.isEmpty() ||
+ content.codePointCount(0, content.length) > MAX_MESSAGE_LENGTH
+ ) {
+ return false
+ }
+ val group = context.groupStore.group(groupPeerID)
+ val key = group?.let { context.groupStore.key(it.groupID) }
+ if (group == null || key == null) {
+ context.addGroupSystemMessage(groupPeerID, "this private group is unavailable")
+ return false
+ }
+ val signingKey = context.mySigningPublicKey()
+ if (signingKey?.size != 32) {
+ context.addGroupSystemMessage(groupPeerID, "your signing identity is unavailable")
+ return false
+ }
+
+ val messageID = UUID.randomUUID().toString()
+ val timestamp = System.currentTimeMillis()
+ val payload = try {
+ GroupCrypto.sealMessage(
+ content = content,
+ messageID = messageID,
+ senderNickname = context.nickname,
+ senderSigningKey = signingKey,
+ timestampMs = timestamp,
+ groupID = group.groupID,
+ epoch = group.epoch,
+ key = key,
+ sign = context::sign
+ )
+ } catch (_: Exception) {
+ context.addGroupSystemMessage(groupPeerID, "could not encrypt group message")
+ return false
+ }
+
+ val stored = context.appendGroupMessage(
+ groupPeerID,
+ BitchatMessage(
+ id = messageID,
+ sender = context.nickname,
+ content = content,
+ timestamp = Date(timestamp),
+ isPrivate = true,
+ recipientNickname = group.name,
+ senderPeerID = context.myPeerID,
+ deliveryStatus = DeliveryStatus.Sent
+ )
+ )
+ if (!stored) return false
+ context.broadcastGroupMessage(payload)
+ return true
+ }
+
+ @Synchronized
+ fun handleMessage(payload: ByteArray, receivedAtMs: Long) {
+ val generation = inboundGeneration
+ if (!acceptsInboundEvents) return
+ synchronized(lifecycleLock) {
+ if (!acceptsInboundEvents || generation != inboundGeneration) return
+ if (deferIfLoading(PendingEvent.Message(payload.copyOf(), receivedAtMs))) return
+ processMessage(payload)
+ }
+ }
+
+ private fun processMessage(payload: ByteArray, queueFutureEpoch: Boolean = true) {
+ val envelope = GroupMessageEnvelope.decode(payload) ?: return
+ val group = context.groupStore.group(envelope.groupID) ?: return
+ if (envelope.epoch != group.epoch) {
+ if (queueFutureEpoch && envelope.epoch > group.epoch) {
+ queueFutureMessage(envelope, payload)
+ }
+ return
+ }
+ val key = context.groupStore.key(group.groupID) ?: return
+ val plaintext = try {
+ GroupCrypto.openMessage(envelope, key)
+ } catch (_: Exception) {
+ return
+ }
+ val member = group.memberWithSigningKey(plaintext.senderSigningKey) ?: return
+ val ownSigningKey = context.mySigningPublicKey()
+ if (ownSigningKey != null && plaintext.senderSigningKey.contentEquals(ownSigningKey)) return
+ if (context.isFingerprintBlocked(member.fingerprint)) return
+
+ val now = System.currentTimeMillis()
+ val timestamp = plaintext.timestampMs.coerceIn(0, now)
+ val sender = member.nickname.ifBlank { plaintext.senderNickname }
+ val message = BitchatMessage(
+ id = plaintext.messageID,
+ sender = sender,
+ content = plaintext.content,
+ timestamp = Date(timestamp),
+ isPrivate = true,
+ recipientNickname = group.name,
+ senderPeerID = member.fingerprint.take(16)
+ )
+ if (!context.appendGroupMessage(group.peerID, message)) return
+
+ if (context.selectedConversationID != group.peerID) {
+ context.markGroupUnread(group.peerID)
+ if (now - timestamp < RECENT_NOTIFICATION_WINDOW_MS) {
+ context.notifyGroupMessage(group.peerID, "$sender @ ${group.name}", plaintext.content)
+ }
+ }
+ }
+
+ @Synchronized
+ fun handleInvite(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ val generation = inboundGeneration
+ if (!acceptsInboundEvents) return
+ synchronized(lifecycleLock) {
+ if (!acceptsInboundEvents || generation != inboundGeneration) return
+ if (
+ deferIfLoading(
+ PendingEvent.Invite(
+ peerID,
+ authenticatedRemoteStaticKey.copyOf(),
+ payload.copyOf()
+ )
+ )
+ ) {
+ return
+ }
+ applyState(peerID, authenticatedRemoteStaticKey, payload, isInvite = true)
+ }
+ }
+
+ @Synchronized
+ fun handleKeyUpdate(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ val generation = inboundGeneration
+ if (!acceptsInboundEvents) return
+ synchronized(lifecycleLock) {
+ if (!acceptsInboundEvents || generation != inboundGeneration) return
+ if (
+ deferIfLoading(
+ PendingEvent.KeyUpdate(
+ peerID,
+ authenticatedRemoteStaticKey.copyOf(),
+ payload.copyOf()
+ )
+ )
+ ) {
+ return
+ }
+ applyState(peerID, authenticatedRemoteStaticKey, payload, isInvite = false)
+ }
+ }
+
+ /**
+ * Replays the current creator-signed state after an authenticated peer
+ * reconnects. This uses the existing iOS GROUP_KEY_UPDATE payload and
+ * repairs updates that could not be delivered while the member was offline.
+ */
+ @Synchronized
+ fun handlePeerAuthenticated(peerID: String) {
+ val generation = inboundGeneration
+ if (!acceptsInboundEvents) return
+ synchronized(lifecycleLock) {
+ if (!acceptsInboundEvents || generation != inboundGeneration) return
+ if (deferIfLoading(PendingEvent.PeerAuthenticated(peerID))) return
+ if (!context.isPeerConnected(peerID)) return
+ if (context.peerGroupCapability(peerID) != PeerGroupCapability.SUPPORTED) return
+ val identity = context.peerIdentity(peerID) ?: return
+ val ownFingerprint = context.myNoiseFingerprint()
+ context.groupStore.groups.value.forEach { group ->
+ if (group.creatorFingerprint != ownFingerprint ||
+ !group.isMember(identity.fingerprint)
+ ) {
+ return@forEach
+ }
+ val key = context.groupStore.key(group.groupID) ?: return@forEach
+ val payload = signedStatePayload(group, key) ?: return@forEach
+ context.sendGroupKeyUpdate(payload, peerID)
+ }
+ }
+ }
+
+ /**
+ * Drains packets received during asynchronous store initialization.
+ */
+ @Synchronized
+ fun onStoreReady() {
+ val generation = inboundGeneration
+ if (!acceptsInboundEvents) return
+ synchronized(lifecycleLock) {
+ if (!acceptsInboundEvents ||
+ generation != inboundGeneration ||
+ !context.groupStore.isReady
+ ) {
+ return
+ }
+ while (true) {
+ val event = synchronized(pendingLock) {
+ pendingEvents.pollFirst()
+ } ?: return
+ when (event) {
+ is PendingEvent.Invite -> applyState(
+ event.peerID,
+ event.authenticatedRemoteStaticKey,
+ event.payload,
+ isInvite = true
+ )
+ is PendingEvent.KeyUpdate -> applyState(
+ event.peerID,
+ event.authenticatedRemoteStaticKey,
+ event.payload,
+ isInvite = false
+ )
+ is PendingEvent.Message -> processMessage(event.payload)
+ is PendingEvent.PeerAuthenticated ->
+ handlePeerAuthenticated(event.peerID)
+ }
+ }
+ }
+ }
+
+ @Synchronized
+ fun suspendForPanic() {
+ synchronized(lifecycleLock) {
+ acceptsInboundEvents = false
+ inboundGeneration += 1
+ synchronized(pendingLock) {
+ pendingEvents.clear()
+ }
+ futureMessages.clear()
+ }
+ }
+
+ @Synchronized
+ fun resumeAfterPanic() {
+ synchronized(lifecycleLock) {
+ acceptsInboundEvents = true
+ }
+ }
+
+ private fun applyState(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray,
+ isInvite: Boolean
+ ) {
+ val state = GroupStatePayload.decode(payload) ?: return
+ val senderFingerprint = sha256(authenticatedRemoteStaticKey).toHex()
+ if (senderFingerprint != state.creatorFingerprint) return
+ if (!state.verifyCreatorSignature()) return
+
+ val ownFingerprint = context.myNoiseFingerprint()
+ val existing = context.groupStore.group(state.groupID)
+ // Reject stale state before interpreting a missing-self roster as a
+ // removal. Otherwise an old, valid removal notice could delete a
+ // membership restored by a later creator-signed re-invite.
+ if (existing != null && state.epoch < existing.epoch) return
+ val departureEpoch = context.groupStore.departureEpoch(state.groupID)
+ if (departureEpoch != null &&
+ (!isInvite || state.epoch <= departureEpoch)
+ ) {
+ return
+ }
+ if (state.members.none { it.fingerprint == ownFingerprint }) {
+ val removed = context.groupStore.removeGroupForState(state.groupID, state.epoch)
+ ?: return
+ dropFutureMessages(removed.groupID)
+ if (context.selectedConversationID == removed.peerID) {
+ context.closeGroupConversation()
+ }
+ context.removeGroupConversation(removed.peerID)
+ context.addSystemMessage("you were removed from #${removed.name}")
+ return
+ }
+ val stored = if (isInvite && departureEpoch != null) {
+ context.groupStore.acceptInvite(state.asGroup(), state.key)
+ } else {
+ context.groupStore.upsert(state.asGroup(), state.key)
+ }
+ if (!stored) return
+ retryFutureMessages(state.groupID)
+
+ if (existing == null) {
+ val inviter = state.members.firstOrNull {
+ it.fingerprint == state.creatorFingerprint
+ }?.nickname ?: context.peerNickname(peerID) ?: "unknown"
+ val notice = "joined #${state.name}, invited by $inviter"
+ context.addSystemMessage(notice)
+ context.markGroupUnread(state.asGroup().peerID)
+ context.notifyGroupMessage(state.asGroup().peerID, inviter, notice)
+ }
+ }
+
+ private fun signedStatePayload(group: BitchatGroup, key: ByteArray): ByteArray? =
+ GroupStatePayload.makeSigned(group, key, context::sign)?.encode()
+
+ private fun distributeState(
+ payload: ByteArray,
+ group: BitchatGroup,
+ excludedFingerprints: Set
+ ) {
+ val ownFingerprint = context.myNoiseFingerprint()
+ group.members.forEach { member ->
+ if (member.fingerprint == ownFingerprint ||
+ member.fingerprint in excludedFingerprints
+ ) {
+ return@forEach
+ }
+ context.connectedPeerID(member.fingerprint)?.let { peerID ->
+ context.sendGroupKeyUpdate(payload, peerID)
+ }
+ }
+ }
+
+ private fun notifyRemovedMember(member: GroupMember, rotated: BitchatGroup) {
+ val peerID = context.connectedPeerID(member.fingerprint) ?: return
+ val payload = signedStatePayload(rotated, ByteArray(BitchatGroup.KEY_LENGTH)) ?: return
+ context.sendGroupKeyUpdate(payload, peerID)
+ }
+
+ private fun selectedGroup(): BitchatGroup? =
+ context.selectedConversationID?.let(context.groupStore::group)
+
+ private fun isCreator(group: BitchatGroup): Boolean =
+ group.creatorFingerprint == context.myNoiseFingerprint()
+
+ private fun parseMemberSelector(raw: String): MemberSelector? {
+ val normalized = raw.trim().removePrefix("@")
+ if (normalized.isEmpty()) return null
+ val separator = normalized.lastIndexOf('#')
+ if (separator < 0) return MemberSelector(normalized, null)
+ if (separator == 0 || separator == normalized.lastIndex) return null
+ val suffix = normalized.substring(separator + 1)
+ if (!IDENTITY_SUFFIX.matches(suffix)) return null
+ return MemberSelector(
+ nickname = normalized.substring(0, separator),
+ identitySuffix = suffix.lowercase()
+ )
+ }
+
+ private fun resolvePeer(selector: MemberSelector): String? {
+ val matches = context.peerIDsForNickname(selector.nickname).distinct()
+ val narrowed = selector.identitySuffix?.let { suffix ->
+ matches.filter { peerID ->
+ peerID.endsWith(suffix, ignoreCase = true) ||
+ context.peerIdentity(peerID)
+ ?.fingerprint
+ ?.endsWith(suffix, ignoreCase = true) == true
+ }
+ } ?: matches
+ return narrowed.singleOrNull()
+ }
+
+ private fun ambiguousPeerError(selector: MemberSelector): GroupCommandResult {
+ val matches = context.peerIDsForNickname(selector.nickname).distinct()
+ if (matches.isEmpty() || selector.identitySuffix != null) {
+ return error("user '${selector.nickname}' was not found")
+ }
+ return error(
+ "multiple users are named '${selector.nickname}'; use " +
+ matches.joinToString(" or ") { peerID ->
+ val suffix = context.peerIdentity(peerID)
+ ?.fingerprint
+ ?.takeLast(8)
+ ?: peerID.takeLast(8)
+ "@${selector.nickname}#$suffix"
+ }
+ )
+ }
+
+ private fun memberChoices(members: List): String =
+ members.joinToString(" or ") { "@${it.nickname}#${it.fingerprint.takeLast(8)}" }
+
+ private fun queueFutureMessage(envelope: GroupMessageEnvelope, payload: ByteArray) {
+ val now = System.currentTimeMillis()
+ pruneExpiredFutureMessages(now)
+ if (futureMessages.any {
+ it.epoch == envelope.epoch &&
+ it.groupID.contentEquals(envelope.groupID) &&
+ it.payload.contentEquals(payload)
+ }
+ ) {
+ return
+ }
+ if (futureMessages.size >= MAX_FUTURE_MESSAGES) futureMessages.pollFirst()
+ futureMessages.addLast(
+ FutureMessage(
+ envelope.groupID.copyOf(),
+ envelope.epoch,
+ payload.copyOf(),
+ now
+ )
+ )
+ }
+
+ private fun retryFutureMessages(groupID: ByteArray) {
+ val current = context.groupStore.group(groupID) ?: return
+ val now = System.currentTimeMillis()
+ val ready = mutableListOf()
+ val iterator = futureMessages.iterator()
+ while (iterator.hasNext()) {
+ val message = iterator.next()
+ if (now - message.queuedAtMs > FUTURE_MESSAGE_TTL_MS) {
+ iterator.remove()
+ } else if (message.groupID.contentEquals(groupID) &&
+ message.epoch <= current.epoch
+ ) {
+ iterator.remove()
+ if (message.epoch == current.epoch) ready += message.payload
+ }
+ }
+ ready.forEach { processMessage(it, queueFutureEpoch = false) }
+ }
+
+ private fun dropFutureMessages(groupID: ByteArray) {
+ val iterator = futureMessages.iterator()
+ while (iterator.hasNext()) {
+ if (iterator.next().groupID.contentEquals(groupID)) iterator.remove()
+ }
+ }
+
+ private fun pruneExpiredFutureMessages(now: Long) {
+ val iterator = futureMessages.iterator()
+ while (iterator.hasNext()) {
+ if (now - iterator.next().queuedAtMs > FUTURE_MESSAGE_TTL_MS) iterator.remove()
+ }
+ }
+
+ private fun deferIfLoading(event: PendingEvent): Boolean =
+ synchronized(pendingLock) {
+ if (context.groupStore.isReady) return@synchronized false
+ if (pendingEvents.size >= MAX_PENDING_EVENTS) pendingEvents.pollFirst()
+ pendingEvents.addLast(event)
+ true
+ }
+
+ private fun loadingError() =
+ error("private groups are still loading; try again")
+
+ private fun success(message: String) = GroupCommandResult(true, message)
+ private fun error(message: String) = GroupCommandResult(false, message)
+
+ private fun ByteArray.toHex(): String =
+ joinToString("") { "%02x".format(it) }
+
+ companion object {
+ private const val MAX_GROUP_NAME_LENGTH = 40
+ private const val MAX_MESSAGE_LENGTH = 60_000
+ private const val RECENT_NOTIFICATION_WINDOW_MS = 30_000L
+ private const val MAX_PENDING_EVENTS = 64
+ private const val MAX_FUTURE_MESSAGES = 32
+ private const val FUTURE_MESSAGE_TTL_MS = 2 * 60_000L
+ private val FINGERPRINT = Regex("^[0-9a-fA-F]{64}$")
+ private val IDENTITY_SUFFIX = Regex("^[0-9a-fA-F]{4,64}$")
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/groups/GroupProtocol.kt b/app/src/main/java/com/bitchat/android/groups/GroupProtocol.kt
new file mode 100644
index 00000000..2f8a25de
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/groups/GroupProtocol.kt
@@ -0,0 +1,663 @@
+package com.bitchat.android.groups
+
+import com.bitchat.android.util.dataFromHexString
+import com.bitchat.android.util.hexEncodedString
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.nio.charset.CodingErrorAction
+import java.security.MessageDigest
+import java.security.SecureRandom
+import java.util.Arrays
+import java.util.UUID
+import org.bouncycastle.crypto.InvalidCipherTextException
+import org.bouncycastle.crypto.modes.ChaCha20Poly1305
+import org.bouncycastle.crypto.params.AEADParameters
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters
+import org.bouncycastle.crypto.params.KeyParameter
+import org.bouncycastle.crypto.signers.Ed25519Signer
+
+data class GroupMember(
+ val fingerprint: String,
+ val signingKey: ByteArray,
+ val nickname: String
+) {
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is GroupMember &&
+ fingerprint == other.fingerprint &&
+ signingKey.contentEquals(other.signingKey) &&
+ nickname == other.nickname)
+
+ override fun hashCode(): Int =
+ 31 * (31 * fingerprint.hashCode() + signingKey.contentHashCode()) + nickname.hashCode()
+}
+
+data class BitchatGroup(
+ val groupID: ByteArray,
+ val name: String,
+ val epoch: Long,
+ val members: List,
+ val creatorFingerprint: String
+) {
+ val peerID: String get() = GroupIds.peerID(groupID)
+ val creator: GroupMember? get() = members.firstOrNull { it.fingerprint == creatorFingerprint }
+
+ fun isMember(fingerprint: String): Boolean =
+ members.any { it.fingerprint == fingerprint }
+
+ fun memberWithSigningKey(signingKey: ByteArray): GroupMember? =
+ members.firstOrNull { it.signingKey.contentEquals(signingKey) }
+
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is BitchatGroup &&
+ groupID.contentEquals(other.groupID) &&
+ name == other.name &&
+ epoch == other.epoch &&
+ members == other.members &&
+ creatorFingerprint == other.creatorFingerprint)
+
+ override fun hashCode(): Int {
+ var result = groupID.contentHashCode()
+ result = 31 * result + name.hashCode()
+ result = 31 * result + epoch.hashCode()
+ result = 31 * result + members.hashCode()
+ result = 31 * result + creatorFingerprint.hashCode()
+ return result
+ }
+
+ companion object {
+ const val MAX_MEMBERS = 16
+ const val GROUP_ID_LENGTH = 16
+ const val KEY_LENGTH = 32
+ const val MAX_EPOCH = 0xffff_ffffL
+ }
+}
+
+object GroupIds {
+ private const val PREFIX = "group_"
+ private val pattern = Regex("^group_[0-9a-f]{32}$")
+
+ fun peerID(groupID: ByteArray): String {
+ require(groupID.size == BitchatGroup.GROUP_ID_LENGTH)
+ return PREFIX + groupID.hexEncodedString()
+ }
+
+ fun groupID(peerID: String): ByteArray? {
+ val normalized = peerID.lowercase()
+ if (!pattern.matches(normalized)) return null
+ return normalized.removePrefix(PREFIX).dataFromHexString()
+ }
+
+ fun isGroup(peerID: String?): Boolean =
+ peerID != null && pattern.matches(peerID.lowercase())
+}
+
+class GroupTlvValueTooLongException : IllegalArgumentException("group TLV value exceeds UInt16")
+
+internal object GroupTLV {
+ data class Field(val type: Int, val value: ByteArray)
+
+ fun put(type: Int, value: ByteArray, output: ByteArrayOutputStream) {
+ if (value.size > 0xffff) throw GroupTlvValueTooLongException()
+ output.write(type and 0xff)
+ output.write((value.size ushr 8) and 0xff)
+ output.write(value.size and 0xff)
+ output.write(value)
+ }
+
+ fun encode(vararg fields: Pair): ByteArray {
+ val output = ByteArrayOutputStream()
+ fields.forEach { (type, value) -> put(type, value, output) }
+ return output.toByteArray()
+ }
+
+ fun parse(data: ByteArray): List? {
+ val fields = mutableListOf()
+ var offset = 0
+ while (offset < data.size) {
+ if (offset + 3 > data.size) return null
+ val type = data[offset].toInt() and 0xff
+ val length =
+ ((data[offset + 1].toInt() and 0xff) shl 8) or
+ (data[offset + 2].toInt() and 0xff)
+ offset += 3
+ if (offset + length > data.size) return null
+ fields += Field(type, data.copyOfRange(offset, offset + length))
+ offset += length
+ }
+ return fields
+ }
+
+ fun epochData(epoch: Long): ByteArray {
+ require(epoch in 0..BitchatGroup.MAX_EPOCH)
+ return ByteBuffer.allocate(Int.SIZE_BYTES)
+ .order(ByteOrder.BIG_ENDIAN)
+ .putInt(epoch.toInt())
+ .array()
+ }
+
+ fun epoch(data: ByteArray): Long? {
+ if (data.size != Int.SIZE_BYTES) return null
+ return ByteBuffer.wrap(data).order(ByteOrder.BIG_ENDIAN).int.toLong() and 0xffff_ffffL
+ }
+
+ fun timestampData(timestampMs: Long): ByteArray =
+ ByteBuffer.allocate(Long.SIZE_BYTES)
+ .order(ByteOrder.BIG_ENDIAN)
+ .putLong(timestampMs)
+ .array()
+
+ fun timestamp(data: ByteArray): Long? {
+ if (data.size != Long.SIZE_BYTES) return null
+ return ByteBuffer.wrap(data).order(ByteOrder.BIG_ENDIAN).long
+ }
+
+ fun strictUtf8(data: ByteArray): String? = try {
+ Charsets.UTF_8.newDecoder()
+ .onMalformedInput(CodingErrorAction.REPORT)
+ .onUnmappableCharacter(CodingErrorAction.REPORT)
+ .decode(ByteBuffer.wrap(data))
+ .toString()
+ } catch (_: Exception) {
+ null
+ }
+}
+
+object GroupRosterCoding {
+ private const val FINGERPRINT_LENGTH = 32
+ private const val SIGNING_KEY_LENGTH = 32
+ private const val MAX_NICKNAME_BYTES = 64
+
+ fun encode(members: List): ByteArray? {
+ if (members.size > BitchatGroup.MAX_MEMBERS) return null
+ val output = ByteArrayOutputStream()
+ output.write(members.size)
+ members.forEach { member ->
+ val fingerprint = member.fingerprint.dataFromHexString()
+ if (fingerprint?.size != FINGERPRINT_LENGTH ||
+ member.signingKey.size != SIGNING_KEY_LENGTH
+ ) {
+ return null
+ }
+ output.write(fingerprint)
+ output.write(member.signingKey)
+ val nickname = truncatedNicknameBytes(member.nickname)
+ output.write(nickname.size)
+ output.write(nickname)
+ }
+ return output.toByteArray()
+ }
+
+ fun decode(data: ByteArray): List? {
+ if (data.isEmpty()) return null
+ val count = data[0].toInt() and 0xff
+ if (count > BitchatGroup.MAX_MEMBERS) return null
+ val members = mutableListOf()
+ var offset = 1
+ repeat(count) {
+ val fixedLength = FINGERPRINT_LENGTH + SIGNING_KEY_LENGTH + 1
+ if (offset + fixedLength > data.size) return null
+ val fingerprint =
+ data.copyOfRange(offset, offset + FINGERPRINT_LENGTH).hexEncodedString()
+ offset += FINGERPRINT_LENGTH
+ val signingKey = data.copyOfRange(offset, offset + SIGNING_KEY_LENGTH)
+ offset += SIGNING_KEY_LENGTH
+ val nicknameLength = data[offset].toInt() and 0xff
+ offset += 1
+ if (offset + nicknameLength > data.size) return null
+ val nickname = GroupTLV.strictUtf8(
+ data.copyOfRange(offset, offset + nicknameLength)
+ ) ?: return null
+ offset += nicknameLength
+ members += GroupMember(fingerprint, signingKey, nickname)
+ }
+ if (offset != data.size) return null
+ return members
+ }
+
+ private fun truncatedNicknameBytes(nickname: String): ByteArray {
+ val output = StringBuilder()
+ var offset = 0
+ while (offset < nickname.length) {
+ val codePoint = nickname.codePointAt(offset)
+ val candidate = output.toString() + String(Character.toChars(codePoint))
+ if (candidate.toByteArray(Charsets.UTF_8).size > MAX_NICKNAME_BYTES) break
+ output.appendCodePoint(codePoint)
+ offset += Character.charCount(codePoint)
+ }
+ return output.toString().toByteArray(Charsets.UTF_8)
+ }
+}
+
+class GroupStatePayload(
+ val groupID: ByteArray,
+ val name: String,
+ val key: ByteArray,
+ val epoch: Long,
+ val members: List,
+ val creatorFingerprint: String,
+ val signature: ByteArray
+) {
+ fun encode(): ByteArray? {
+ val roster = GroupRosterCoding.encode(members) ?: return null
+ val creator = creatorFingerprint.dataFromHexString()
+ if (creator?.size != 32) return null
+ return try {
+ GroupTLV.encode(
+ FIELD_GROUP_ID to groupID,
+ FIELD_NAME to name.toByteArray(Charsets.UTF_8),
+ FIELD_KEY to key,
+ FIELD_EPOCH to GroupTLV.epochData(epoch),
+ FIELD_ROSTER to roster,
+ FIELD_CREATOR_FINGERPRINT to creator,
+ FIELD_SIGNATURE to signature
+ )
+ } catch (_: GroupTlvValueTooLongException) {
+ null
+ }
+ }
+
+ fun verifyCreatorSignature(): Boolean {
+ if (members.size > BitchatGroup.MAX_MEMBERS) return false
+ val creator = members.firstOrNull { it.fingerprint == creatorFingerprint } ?: return false
+ val roster = GroupRosterCoding.encode(members) ?: return false
+ return GroupCrypto.verify(
+ signature,
+ signingContent(groupID, epoch, key, roster, name),
+ creator.signingKey
+ )
+ }
+
+ fun asGroup(): BitchatGroup =
+ BitchatGroup(groupID, name, epoch, members, creatorFingerprint)
+
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is GroupStatePayload &&
+ groupID.contentEquals(other.groupID) &&
+ name == other.name &&
+ key.contentEquals(other.key) &&
+ epoch == other.epoch &&
+ members == other.members &&
+ creatorFingerprint == other.creatorFingerprint &&
+ signature.contentEquals(other.signature))
+
+ override fun hashCode(): Int {
+ var result = Arrays.hashCode(groupID)
+ result = 31 * result + name.hashCode()
+ result = 31 * result + Arrays.hashCode(key)
+ result = 31 * result + epoch.hashCode()
+ result = 31 * result + members.hashCode()
+ result = 31 * result + creatorFingerprint.hashCode()
+ result = 31 * result + Arrays.hashCode(signature)
+ return result
+ }
+
+ companion object {
+ private const val FIELD_GROUP_ID = 0x01
+ private const val FIELD_NAME = 0x02
+ private const val FIELD_KEY = 0x03
+ private const val FIELD_EPOCH = 0x04
+ private const val FIELD_ROSTER = 0x05
+ private const val FIELD_CREATOR_FINGERPRINT = 0x06
+ private const val FIELD_SIGNATURE = 0x07
+ private val SIGNING_DOMAIN = "bitchat-group-v1".toByteArray(Charsets.UTF_8)
+
+ fun signingContent(
+ groupID: ByteArray,
+ epoch: Long,
+ key: ByteArray,
+ rosterBlob: ByteArray,
+ name: String
+ ): ByteArray = concat(
+ SIGNING_DOMAIN,
+ groupID,
+ GroupTLV.epochData(epoch),
+ sha256(key),
+ sha256(rosterBlob),
+ sha256(name.toByteArray(Charsets.UTF_8))
+ )
+
+ fun makeSigned(
+ group: BitchatGroup,
+ key: ByteArray,
+ sign: (ByteArray) -> ByteArray?
+ ): GroupStatePayload? {
+ val roster = GroupRosterCoding.encode(group.members) ?: return null
+ val signature = sign(
+ signingContent(group.groupID, group.epoch, key, roster, group.name)
+ ) ?: return null
+ if (signature.size != 64) return null
+ return GroupStatePayload(
+ group.groupID,
+ group.name,
+ key,
+ group.epoch,
+ group.members,
+ group.creatorFingerprint,
+ signature
+ )
+ }
+
+ fun decode(data: ByteArray): GroupStatePayload? {
+ val fields = GroupTLV.parse(data) ?: return null
+ var groupID: ByteArray? = null
+ var name: String? = null
+ var key: ByteArray? = null
+ var epoch: Long? = null
+ var members: List? = null
+ var creatorFingerprint: String? = null
+ var signature: ByteArray? = null
+ fields.forEach { field ->
+ when (field.type) {
+ FIELD_GROUP_ID ->
+ if (field.value.size == BitchatGroup.GROUP_ID_LENGTH) groupID = field.value
+ FIELD_NAME -> name = GroupTLV.strictUtf8(field.value)
+ FIELD_KEY ->
+ if (field.value.size == BitchatGroup.KEY_LENGTH) key = field.value
+ FIELD_EPOCH -> epoch = GroupTLV.epoch(field.value)
+ FIELD_ROSTER -> members = GroupRosterCoding.decode(field.value)
+ FIELD_CREATOR_FINGERPRINT ->
+ if (field.value.size == 32) creatorFingerprint = field.value.hexEncodedString()
+ FIELD_SIGNATURE -> if (field.value.size == 64) signature = field.value
+ }
+ }
+ val decodedMembers = members ?: return null
+ if (decodedMembers.isEmpty()) return null
+ return GroupStatePayload(
+ groupID ?: return null,
+ name ?: return null,
+ key ?: return null,
+ epoch ?: return null,
+ decodedMembers,
+ creatorFingerprint ?: return null,
+ signature ?: return null
+ )
+ }
+ }
+}
+
+class GroupMessageEnvelope(
+ val groupID: ByteArray,
+ val epoch: Long,
+ val nonce: ByteArray,
+ val ciphertext: ByteArray
+) {
+ fun encode(): ByteArray = GroupTLV.encode(
+ FIELD_GROUP_ID to groupID,
+ FIELD_EPOCH to GroupTLV.epochData(epoch),
+ FIELD_NONCE to nonce,
+ FIELD_CIPHERTEXT to ciphertext
+ )
+
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is GroupMessageEnvelope &&
+ groupID.contentEquals(other.groupID) &&
+ epoch == other.epoch &&
+ nonce.contentEquals(other.nonce) &&
+ ciphertext.contentEquals(other.ciphertext))
+
+ override fun hashCode(): Int {
+ var result = groupID.contentHashCode()
+ result = 31 * result + epoch.hashCode()
+ result = 31 * result + nonce.contentHashCode()
+ result = 31 * result + ciphertext.contentHashCode()
+ return result
+ }
+
+ companion object {
+ private const val FIELD_GROUP_ID = 0x01
+ private const val FIELD_EPOCH = 0x02
+ private const val FIELD_NONCE = 0x03
+ private const val FIELD_CIPHERTEXT = 0x04
+
+ fun decode(data: ByteArray): GroupMessageEnvelope? {
+ val fields = GroupTLV.parse(data) ?: return null
+ var groupID: ByteArray? = null
+ var epoch: Long? = null
+ var nonce: ByteArray? = null
+ var ciphertext: ByteArray? = null
+ fields.forEach { field ->
+ when (field.type) {
+ FIELD_GROUP_ID ->
+ if (field.value.size == BitchatGroup.GROUP_ID_LENGTH) groupID = field.value
+ FIELD_EPOCH -> epoch = GroupTLV.epoch(field.value)
+ FIELD_NONCE -> if (field.value.size == 12) nonce = field.value
+ FIELD_CIPHERTEXT -> if (field.value.isNotEmpty()) ciphertext = field.value
+ }
+ }
+ return GroupMessageEnvelope(
+ groupID ?: return null,
+ epoch ?: return null,
+ nonce ?: return null,
+ ciphertext ?: return null
+ )
+ }
+ }
+}
+
+data class GroupMessagePlaintext(
+ val messageID: String,
+ val senderSigningKey: ByteArray,
+ val senderNickname: String,
+ val timestampMs: Long,
+ val content: String
+) {
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is GroupMessagePlaintext &&
+ messageID == other.messageID &&
+ senderSigningKey.contentEquals(other.senderSigningKey) &&
+ senderNickname == other.senderNickname &&
+ timestampMs == other.timestampMs &&
+ content == other.content)
+
+ override fun hashCode(): Int {
+ var result = messageID.hashCode()
+ result = 31 * result + senderSigningKey.contentHashCode()
+ result = 31 * result + senderNickname.hashCode()
+ result = 31 * result + timestampMs.hashCode()
+ result = 31 * result + content.hashCode()
+ return result
+ }
+}
+
+sealed class GroupCryptoException(message: String) : Exception(message) {
+ class MalformedPayload : GroupCryptoException("malformed group payload")
+ class SigningFailed : GroupCryptoException("group message signing failed")
+ class SealFailed : GroupCryptoException("group message sealing failed")
+ class DecryptionFailed : GroupCryptoException("group message decryption failed")
+ class BadSenderSignature : GroupCryptoException("bad group sender signature")
+}
+
+object GroupCrypto {
+ private const val FIELD_MESSAGE_ID = 0x01
+ private const val FIELD_SENDER_SIGNING_KEY = 0x02
+ private const val FIELD_SENDER_NICKNAME = 0x03
+ private const val FIELD_TIMESTAMP = 0x04
+ private const val FIELD_CONTENT = 0x05
+ private const val FIELD_SIGNATURE = 0x06
+ private val MESSAGE_SIGNING_DOMAIN =
+ "bitchat-group-msg-v1".toByteArray(Charsets.UTF_8)
+ private val random = SecureRandom()
+
+ fun messageSigningContent(
+ groupID: ByteArray,
+ epoch: Long,
+ messageID: String,
+ timestampMs: Long,
+ content: String
+ ): ByteArray = concat(
+ MESSAGE_SIGNING_DOMAIN,
+ groupID,
+ GroupTLV.epochData(epoch),
+ messageID.toByteArray(Charsets.UTF_8),
+ GroupTLV.timestampData(timestampMs),
+ content.toByteArray(Charsets.UTF_8)
+ )
+
+ fun verify(signature: ByteArray, data: ByteArray, publicKey: ByteArray): Boolean {
+ if (signature.size != 64 || publicKey.size != 32) return false
+ return try {
+ val verifier = Ed25519Signer()
+ verifier.init(false, Ed25519PublicKeyParameters(publicKey, 0))
+ verifier.update(data, 0, data.size)
+ verifier.verifySignature(signature)
+ } catch (_: Exception) {
+ false
+ }
+ }
+
+ @Throws(GroupCryptoException::class, GroupTlvValueTooLongException::class)
+ fun sealMessage(
+ content: String,
+ messageID: String,
+ senderNickname: String,
+ senderSigningKey: ByteArray,
+ timestampMs: Long,
+ groupID: ByteArray,
+ epoch: Long,
+ key: ByteArray,
+ sign: (ByteArray) -> ByteArray?
+ ): ByteArray {
+ if (!isCanonicalMessageID(messageID)) {
+ throw GroupCryptoException.MalformedPayload()
+ }
+ val signature = sign(
+ messageSigningContent(groupID, epoch, messageID, timestampMs, content)
+ )
+ if (signature?.size != 64) throw GroupCryptoException.SigningFailed()
+
+ val inner = GroupTLV.encode(
+ FIELD_MESSAGE_ID to messageID.toByteArray(Charsets.UTF_8),
+ FIELD_SENDER_SIGNING_KEY to senderSigningKey,
+ FIELD_SENDER_NICKNAME to senderNickname.toByteArray(Charsets.UTF_8),
+ FIELD_TIMESTAMP to GroupTLV.timestampData(timestampMs),
+ FIELD_CONTENT to content.toByteArray(Charsets.UTF_8),
+ FIELD_SIGNATURE to signature
+ )
+ if (key.size != BitchatGroup.KEY_LENGTH ||
+ groupID.size != BitchatGroup.GROUP_ID_LENGTH
+ ) {
+ throw GroupCryptoException.SealFailed()
+ }
+
+ return try {
+ val nonce = ByteArray(12).also(random::nextBytes)
+ val aad = concat(groupID, GroupTLV.epochData(epoch))
+ val ciphertext = crypt(encrypt = true, key, nonce, aad, inner)
+ GroupMessageEnvelope(groupID, epoch, nonce, ciphertext).encode()
+ } catch (error: GroupTlvValueTooLongException) {
+ throw error
+ } catch (_: Exception) {
+ throw GroupCryptoException.SealFailed()
+ }
+ }
+
+ @Throws(GroupCryptoException::class)
+ fun openMessage(envelope: GroupMessageEnvelope, key: ByteArray): GroupMessagePlaintext {
+ if (key.size != BitchatGroup.KEY_LENGTH || envelope.ciphertext.size <= 16) {
+ throw GroupCryptoException.DecryptionFailed()
+ }
+ val inner = try {
+ crypt(
+ encrypt = false,
+ key,
+ envelope.nonce,
+ concat(envelope.groupID, GroupTLV.epochData(envelope.epoch)),
+ envelope.ciphertext
+ )
+ } catch (_: Exception) {
+ throw GroupCryptoException.DecryptionFailed()
+ }
+
+ val fields = GroupTLV.parse(inner) ?: throw GroupCryptoException.MalformedPayload()
+ var messageID: String? = null
+ var senderSigningKey: ByteArray? = null
+ var senderNickname: String? = null
+ var timestampMs: Long? = null
+ var content: String? = null
+ var signature: ByteArray? = null
+ fields.forEach { field ->
+ when (field.type) {
+ FIELD_MESSAGE_ID -> messageID = GroupTLV.strictUtf8(field.value)
+ FIELD_SENDER_SIGNING_KEY ->
+ if (field.value.size == 32) senderSigningKey = field.value
+ FIELD_SENDER_NICKNAME -> senderNickname = GroupTLV.strictUtf8(field.value)
+ FIELD_TIMESTAMP -> timestampMs = GroupTLV.timestamp(field.value)
+ FIELD_CONTENT -> content = GroupTLV.strictUtf8(field.value)
+ FIELD_SIGNATURE -> if (field.value.size == 64) signature = field.value
+ }
+ }
+ val decodedMessageID = messageID?.takeIf(::isCanonicalMessageID)
+ ?: throw GroupCryptoException.MalformedPayload()
+ val decodedSigningKey = senderSigningKey ?: throw GroupCryptoException.MalformedPayload()
+ val decodedNickname = senderNickname ?: throw GroupCryptoException.MalformedPayload()
+ val decodedTimestamp = timestampMs ?: throw GroupCryptoException.MalformedPayload()
+ val decodedContent = content ?: throw GroupCryptoException.MalformedPayload()
+ val decodedSignature = signature ?: throw GroupCryptoException.MalformedPayload()
+
+ val signingContent = messageSigningContent(
+ envelope.groupID,
+ envelope.epoch,
+ decodedMessageID,
+ decodedTimestamp,
+ decodedContent
+ )
+ if (!verify(decodedSignature, signingContent, decodedSigningKey)) {
+ throw GroupCryptoException.BadSenderSignature()
+ }
+ return GroupMessagePlaintext(
+ decodedMessageID,
+ decodedSigningKey,
+ decodedNickname,
+ decodedTimestamp,
+ decodedContent
+ )
+ }
+
+ private fun isCanonicalMessageID(messageID: String): Boolean {
+ val encoded = messageID.toByteArray(Charsets.UTF_8)
+ if (encoded.size != UUID_TEXT_LENGTH || !UUID_PATTERN.matches(messageID)) return false
+ return try {
+ UUID.fromString(messageID)
+ true
+ } catch (_: IllegalArgumentException) {
+ false
+ }
+ }
+
+ @Throws(InvalidCipherTextException::class)
+ private fun crypt(
+ encrypt: Boolean,
+ key: ByteArray,
+ nonce: ByteArray,
+ aad: ByteArray,
+ input: ByteArray
+ ): ByteArray {
+ val cipher = ChaCha20Poly1305()
+ cipher.init(encrypt, AEADParameters(KeyParameter(key), 128, nonce, aad))
+ val output = ByteArray(cipher.getOutputSize(input.size))
+ var length = cipher.processBytes(input, 0, input.size, output, 0)
+ length += cipher.doFinal(output, length)
+ return output.copyOf(length)
+ }
+
+ private const val UUID_TEXT_LENGTH = 36
+ private val UUID_PATTERN = Regex(
+ "^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-" +
+ "[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$"
+ )
+}
+
+internal fun sha256(data: ByteArray): ByteArray =
+ MessageDigest.getInstance("SHA-256").digest(data)
+
+internal fun concat(vararg arrays: ByteArray): ByteArray {
+ val output = ByteArrayOutputStream(arrays.sumOf(ByteArray::size))
+ arrays.forEach(output::write)
+ return output.toByteArray()
+}
diff --git a/app/src/main/java/com/bitchat/android/groups/GroupRuntime.kt b/app/src/main/java/com/bitchat/android/groups/GroupRuntime.kt
new file mode 100644
index 00000000..d0622531
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/groups/GroupRuntime.kt
@@ -0,0 +1,96 @@
+package com.bitchat.android.groups
+
+import android.content.Context
+import androidx.core.app.NotificationManagerCompat
+import com.bitchat.android.mesh.GroupMessagePort
+import com.bitchat.android.mesh.GroupMessageReceiver
+import com.bitchat.android.model.BitchatMessage
+import com.bitchat.android.service.MeshServiceHolder
+import com.bitchat.android.services.AppStateStore
+import com.bitchat.android.services.ContactIdentityResolver
+import com.bitchat.android.ui.DataManager
+import java.lang.ref.WeakReference
+import java.util.Date
+import kotlinx.coroutines.*
+
+interface GroupUiDelegate {
+ val nickname: String
+ fun markGroupUnread(groupPeerID: String)
+ fun openGroupConversation(groupPeerID: String)
+ fun closeGroupConversation()
+}
+
+/** Keeps group membership, decryption, and durable delivery alive when the Activity closes. */
+class GroupRuntime private constructor(private val application: Context) : GroupMessageReceiver {
+ val store = GroupStore(application)
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+ @Volatile private var ui = WeakReference(null)
+ private val mesh get() = MeshServiceHolder.unifiedMeshService
+ private val notifications = com.bitchat.android.ui.NotificationManager(application, NotificationManagerCompat.from(application))
+
+ val coordinator = GroupCoordinator(object : GroupCoordinatorContext {
+ override val groupStore get() = store
+ override val nickname get() = ui.get()?.nickname ?: AppStateStore.nickname.value
+ override val myPeerID get() = mesh?.myPeerID.orEmpty()
+ override val selectedConversationID get() = AppStateStore.selectedPrivateChatPeer.value
+ override fun myNoiseFingerprint() = mesh?.getIdentityFingerprint().orEmpty()
+ override fun mySigningPublicKey() = mesh?.getSigningPublicKey()
+ override fun sign(data: ByteArray) = mesh?.signData(data)
+ override fun peerIDsForNickname(nickname: String) = mesh?.getPeerNicknames().orEmpty()
+ .filterValues { it.equals(nickname, ignoreCase = true) }.keys.toList()
+ override fun isPeerConnected(peerID: String) = mesh?.getPeerInfo(peerID)?.isConnected == true && mesh?.hasEstablishedSession(peerID) == true
+ override fun peerGroupCapability(peerID: String): PeerGroupCapability {
+ val peer = mesh?.getPeerInfo(peerID) ?: return PeerGroupCapability.UNKNOWN
+ return PeerGroupCapability.fromPeerState(peer.capabilities, peer.hasVerifiedAnnouncement)
+ }
+ override fun peerNickname(peerID: String) = mesh?.getPeerNicknames()?.get(peerID)
+ override fun peerIdentity(peerID: String): GroupPeerIdentity? {
+ val info = mesh?.getPeerInfo(peerID) ?: return null
+ val signing = info.signingPublicKey?.takeIf { it.size == 32 } ?: return null
+ val key = info.noisePublicKey ?: return null
+ val fingerprint = ContactIdentityResolver.fingerprintHex(key)
+ if (!fingerprint.equals(mesh?.getPeerFingerprint(peerID), ignoreCase = true)) return null
+ return GroupPeerIdentity(fingerprint, signing.copyOf())
+ }
+ override fun connectedPeerID(fingerprint: String) = mesh?.getPeerNicknames()?.keys?.firstOrNull {
+ isPeerConnected(it) && fingerprint.equals(mesh?.getPeerFingerprint(it), ignoreCase = true)
+ }
+ override fun isFingerprintBlocked(fingerprint: String) = DataManager.isFingerprintBlocked(application, fingerprint)
+ override fun sendGroupInvite(payload: ByteArray, peerID: String) { mesh?.sendGroupInvite(payload, peerID) }
+ override fun sendGroupKeyUpdate(payload: ByteArray, peerID: String) { mesh?.sendGroupKeyUpdate(payload, peerID) }
+ override fun broadcastGroupMessage(payload: ByteArray) { mesh?.broadcastGroupMessage(payload) }
+ override fun appendGroupMessage(groupPeerID: String, message: BitchatMessage): Boolean = runBlocking {
+ AppStateStore.addPrivateMessageDurably(groupPeerID, message, selectedConversationID == groupPeerID || message.senderPeerID == myPeerID)
+ }
+ override fun markGroupUnread(groupPeerID: String) { ui.get()?.markGroupUnread(groupPeerID) }
+ override fun removeGroupConversation(groupPeerID: String) { AppStateStore.deletePrivateConversation(groupPeerID) }
+ override fun openGroupConversation(groupPeerID: String) { scope.launch(Dispatchers.Main) { ui.get()?.openGroupConversation(groupPeerID) } }
+ override fun closeGroupConversation() { scope.launch(Dispatchers.Main) { ui.get()?.closeGroupConversation() } }
+ override fun addSystemMessage(message: String) { AppStateStore.addPublicMessage(BitchatMessage(sender = "system", content = message, timestamp = Date())) }
+ override fun addGroupSystemMessage(groupPeerID: String, message: String) {
+ appendGroupMessage(groupPeerID, BitchatMessage(sender = "system", content = message, timestamp = Date(), isPrivate = true))
+ }
+ override fun notifyGroupMessage(groupPeerID: String, sender: String, message: String) {
+ notifications.showPrivateMessageNotification(groupPeerID, sender, message)
+ }
+ })
+
+ init {
+ GroupMessagePort.receiver = this
+ scope.launch { if (store.initialize()) coordinator.onStoreReady() }
+ }
+
+ fun attach(context: GroupUiDelegate) { ui = WeakReference(context) }
+ fun detach(context: GroupUiDelegate) { if (ui.get() === context) ui.clear() }
+ override fun invite(peerID: String, authenticatedKey: ByteArray, payload: ByteArray) = coordinator.handleInvite(peerID, authenticatedKey, payload)
+ override fun keyUpdate(peerID: String, authenticatedKey: ByteArray, payload: ByteArray) = coordinator.handleKeyUpdate(peerID, authenticatedKey, payload)
+ override fun message(payload: ByteArray, timestampMs: Long) = coordinator.handleMessage(payload, timestampMs)
+ override fun peerAuthenticated(peerID: String) { scope.launch { coordinator.handlePeerAuthenticated(peerID) } }
+
+ companion object {
+ @Volatile private var instance: GroupRuntime? = null
+ fun getInstance(context: Context): GroupRuntime = instance ?: synchronized(this) {
+ instance ?: GroupRuntime(context.applicationContext).also { instance = it }
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/groups/GroupStore.kt b/app/src/main/java/com/bitchat/android/groups/GroupStore.kt
new file mode 100644
index 00000000..0f63ee9a
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/groups/GroupStore.kt
@@ -0,0 +1,552 @@
+package com.bitchat.android.groups
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.Base64
+import android.util.Log
+import androidx.security.crypto.EncryptedSharedPreferences
+import androidx.security.crypto.MasterKey
+import com.bitchat.android.util.hexEncodedString
+import com.google.gson.Gson
+import com.google.gson.JsonParser
+import com.google.gson.reflect.TypeToken
+import java.io.File
+import java.io.FileOutputStream
+import java.nio.file.AtomicMoveNotSupportedException
+import java.nio.file.Files
+import java.nio.file.StandardCopyOption
+import java.security.SecureRandom
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+internal interface GroupKeyStorage {
+ fun get(key: String): ByteArray?
+ fun put(key: String, value: ByteArray): Boolean
+ fun remove(key: String): Boolean
+ fun clear(): Boolean
+}
+
+internal interface GroupMetadataStorage {
+ fun read(): String?
+ fun write(contents: String): Boolean
+ fun delete(): Boolean
+}
+
+@SuppressLint("ApplySharedPref", "UseKtx")
+private class EncryptedPreferencesGroupKeyStorage(context: Context) : GroupKeyStorage {
+ private val preferences: SharedPreferences
+
+ init {
+ val masterKey = MasterKey.Builder(context, MasterKey.DEFAULT_MASTER_KEY_ALIAS)
+ .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+ .build()
+ preferences = EncryptedSharedPreferences.create(
+ context,
+ "bitchat_private_groups",
+ masterKey,
+ EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+ EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+ )
+ }
+
+ override fun get(key: String): ByteArray? = try {
+ preferences.getString(key, null)?.let {
+ Base64.decode(it, Base64.NO_WRAP)
+ }
+ } catch (_: Exception) {
+ null
+ }
+
+ override fun put(key: String, value: ByteArray): Boolean = try {
+ // The metadata must not advance unless the epoch key is durably stored.
+ preferences.edit()
+ .putString(key, Base64.encodeToString(value, Base64.NO_WRAP))
+ .commit()
+ } catch (_: Exception) {
+ false
+ }
+
+ override fun remove(key: String): Boolean = try {
+ // Removal is a security boundary, so report the synchronous result.
+ preferences.edit().remove(key).commit()
+ } catch (_: Exception) {
+ false
+ }
+
+ override fun clear(): Boolean = try {
+ preferences.edit().clear().commit() && preferences.all.isEmpty()
+ } catch (_: Exception) {
+ false
+ }
+}
+
+private class FileGroupMetadataStorage(private val file: File) : GroupMetadataStorage {
+ override fun read(): String? = try {
+ file.takeIf(File::exists)?.readText(Charsets.UTF_8)
+ } catch (_: Exception) {
+ null
+ }
+
+ override fun write(contents: String): Boolean {
+ var temporary: File? = null
+ return try {
+ val parent = file.parentFile
+ if (parent != null && !parent.exists() && !parent.mkdirs()) return false
+ temporary = File(parent, "${file.name}.tmp")
+ FileOutputStream(temporary).use { output ->
+ output.write(contents.toByteArray(Charsets.UTF_8))
+ output.fd.sync()
+ }
+ try {
+ Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.ATOMIC_MOVE,
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ } catch (_: AtomicMoveNotSupportedException) {
+ Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ }
+ true
+ } catch (_: Exception) {
+ temporary?.delete()
+ false
+ }
+ }
+
+ override fun delete(): Boolean = try {
+ val deleted = !file.exists() || file.delete()
+ if (deleted) {
+ file.parentFile
+ ?.takeIf { it.listFiles().isNullOrEmpty() }
+ ?.delete()
+ }
+ deleted
+ } catch (_: Exception) {
+ false
+ }
+}
+
+/**
+ * Persistent private-group metadata and epoch keys.
+ *
+ * Metadata is kept in app-private no-backup storage. Symmetric group keys are
+ * stored separately in EncryptedSharedPreferences backed by Android Keystore.
+ *
+ * The Android constructor is intentionally inert. [initialize] performs
+ * Keystore and disk access and must be called from a background dispatcher.
+ */
+class GroupStore private constructor(
+ private val keyStorageFactory: () -> GroupKeyStorage,
+ private val metadataStorageFactory: () -> GroupMetadataStorage?,
+ autoInitialize: Boolean
+) {
+ private data class StoredMember(
+ val fingerprint: String,
+ val signingKey: String,
+ val nickname: String
+ )
+
+ private data class StoredGroup(
+ val groupID: String,
+ val name: String,
+ val epoch: Long,
+ val members: List,
+ val creatorFingerprint: String
+ )
+
+ private data class StoredState(
+ val version: Int = 1,
+ val groups: List,
+ val departures: Map
+ )
+
+ private val lock = Any()
+ private val gson = Gson()
+ private val random by lazy(LazyThreadSafetyMode.SYNCHRONIZED) { SecureRandom() }
+ private val _groups = MutableStateFlow>(emptyList())
+ private val departures = mutableMapOf()
+ private var keyStorage: GroupKeyStorage? = null
+ private var metadataStorage: GroupMetadataStorage? = null
+
+ @Volatile
+ private var initialized = false
+
+ val groups: StateFlow> = _groups.asStateFlow()
+ val isReady: Boolean
+ get() = initialized
+
+ constructor(context: Context) : this(
+ keyStorageFactory = {
+ EncryptedPreferencesGroupKeyStorage(context.applicationContext)
+ },
+ metadataStorageFactory = {
+ FileGroupMetadataStorage(
+ File(context.applicationContext.noBackupFilesDir, "groups/groups.json")
+ )
+ },
+ autoInitialize = false
+ )
+
+ internal constructor(
+ keyStorage: GroupKeyStorage,
+ metadataFile: File? = null,
+ testOnly: Boolean,
+ autoInitialize: Boolean = true
+ ) : this(
+ keyStorageFactory = { keyStorage },
+ metadataStorageFactory = {
+ metadataFile?.let(::FileGroupMetadataStorage)
+ },
+ autoInitialize = autoInitialize
+ ) {
+ require(testOnly)
+ }
+
+ internal constructor(
+ keyStorage: GroupKeyStorage,
+ metadataStorage: GroupMetadataStorage,
+ testOnly: Boolean,
+ autoInitialize: Boolean = true
+ ) : this(
+ keyStorageFactory = { keyStorage },
+ metadataStorageFactory = { metadataStorage },
+ autoInitialize = autoInitialize
+ ) {
+ require(testOnly)
+ }
+
+ init {
+ if (autoInitialize) initialize()
+ }
+
+ /**
+ * Initializes encrypted key storage and loads metadata. Callers using the
+ * Android constructor must invoke this away from the main thread.
+ */
+ fun initialize(): Boolean = synchronized(lock) {
+ if (initialized) return@synchronized true
+ val keys = try {
+ keyStorageFactory()
+ } catch (error: Exception) {
+ Log.e(TAG, "Failed to initialize private-group key storage", error)
+ return@synchronized false
+ }
+ val metadata = try {
+ metadataStorageFactory()
+ } catch (error: Exception) {
+ Log.e(TAG, "Failed to initialize private-group metadata storage", error)
+ return@synchronized false
+ }
+ keyStorage = keys
+ metadataStorage = metadata
+ loadLocked(keys, metadata)
+ initialized = true
+ true
+ }
+
+ fun group(groupID: ByteArray): BitchatGroup? = synchronized(lock) {
+ _groups.value.firstOrNull { it.groupID.contentEquals(groupID) }?.deepCopy()
+ }
+
+ fun group(peerID: String): BitchatGroup? =
+ GroupIds.groupID(peerID)?.let(::group)
+
+ fun key(groupID: ByteArray): ByteArray? = synchronized(lock) {
+ keyStorage
+ ?.get(keyName(groupID))
+ ?.takeIf { it.size == BitchatGroup.KEY_LENGTH }
+ ?.copyOf()
+ }
+
+ fun departureEpoch(groupID: ByteArray): Long? = synchronized(lock) {
+ departures[groupID.hexEncodedString()]
+ }
+
+ fun createGroup(name: String, creator: GroupMember): BitchatGroup? {
+ if (!isReady) return null
+ val groupID = ByteArray(BitchatGroup.GROUP_ID_LENGTH).also(random::nextBytes)
+ val key = ByteArray(BitchatGroup.KEY_LENGTH).also(random::nextBytes)
+ val group = BitchatGroup(
+ groupID = groupID,
+ name = name,
+ epoch = 1,
+ members = listOf(creator),
+ creatorFingerprint = creator.fingerprint
+ )
+ return group.takeIf { upsert(it, key) }
+ }
+
+ fun upsert(group: BitchatGroup, key: ByteArray): Boolean = synchronized(lock) {
+ upsertLocked(group, key, clearDeparture = false)
+ }
+
+ fun acceptInvite(group: BitchatGroup, key: ByteArray): Boolean = synchronized(lock) {
+ upsertLocked(group, key, clearDeparture = true)
+ }
+
+ fun rotateKey(
+ groupID: ByteArray,
+ members: List
+ ): Pair? = synchronized(lock) {
+ if (!initialized) return@synchronized null
+ val existing = _groups.value.firstOrNull { it.groupID.contentEquals(groupID) }
+ ?: return@synchronized null
+ val newKey = ByteArray(BitchatGroup.KEY_LENGTH).also(random::nextBytes)
+ val rotated = existing.copy(
+ epoch = (existing.epoch + 1) and BitchatGroup.MAX_EPOCH,
+ members = members.map { it.deepCopy() }
+ )
+ if (!upsertLocked(rotated, newKey, clearDeparture = false)) {
+ return@synchronized null
+ }
+ rotated.deepCopy() to newKey.copyOf()
+ }
+
+ fun removeGroup(groupID: ByteArray): Boolean = synchronized(lock) {
+ removeLocked(groupID, departureEpoch = null)
+ }
+
+ fun removeGroupForState(groupID: ByteArray, stateEpoch: Long): BitchatGroup? =
+ synchronized(lock) {
+ if (stateEpoch !in 0..BitchatGroup.MAX_EPOCH) return@synchronized null
+ val existing = _groups.value.firstOrNull { it.groupID.contentEquals(groupID) }
+ ?: return@synchronized null
+ if (stateEpoch < existing.epoch) return@synchronized null
+ if (!removeLocked(groupID, departureEpoch = null)) return@synchronized null
+ existing.deepCopy()
+ }
+
+ fun departGroup(groupID: ByteArray, epoch: Long): Boolean = synchronized(lock) {
+ if (epoch !in 0..BitchatGroup.MAX_EPOCH) return@synchronized false
+ removeLocked(groupID, departureEpoch = epoch)
+ }
+
+ fun wipe(): Boolean = synchronized(lock) {
+ if (!initialized && !initialize()) return@synchronized false
+ val keys = keyStorage ?: return@synchronized false
+ val keysCleared = keys.clear()
+ val metadataDeleted = metadataStorage?.delete() ?: true
+ _groups.value = emptyList()
+ departures.clear()
+ keysCleared && metadataDeleted
+ }
+
+ private fun upsertLocked(
+ group: BitchatGroup,
+ key: ByteArray,
+ clearDeparture: Boolean
+ ): Boolean {
+ val keys = keyStorage ?: return false
+ if (!initialized || !isValid(group, key)) return false
+
+ val updatedGroups = _groups.value.toMutableList()
+ val index = updatedGroups.indexOfFirst { it.groupID.contentEquals(group.groupID) }
+ if (index >= 0 && group.epoch < updatedGroups[index].epoch) return false
+
+ if (index >= 0) {
+ updatedGroups[index] = group.deepCopy()
+ } else {
+ updatedGroups += group.deepCopy()
+ }
+ val updatedDepartures = departures.toMutableMap()
+ val groupID = group.groupID.hexEncodedString()
+ val departureEpoch = updatedDepartures[groupID]
+ if (clearDeparture) {
+ if (departureEpoch != null && group.epoch <= departureEpoch) return false
+ updatedDepartures.remove(groupID)
+ } else if (departureEpoch != null) {
+ return false
+ }
+
+ val name = keyName(group.groupID)
+ val previousKey = keys.get(name)?.copyOf()
+ if (!keys.put(name, key.copyOf())) {
+ Log.e(TAG, "Failed to store private-group epoch key")
+ return false
+ }
+ if (!persistLocked(updatedGroups, updatedDepartures)) {
+ restoreKey(keys, name, previousKey)
+ return false
+ }
+
+ departures.clear()
+ departures.putAll(updatedDepartures)
+ _groups.value = updatedGroups.map { it.deepCopy() }
+ return true
+ }
+
+ private fun removeLocked(groupID: ByteArray, departureEpoch: Long?): Boolean {
+ val keys = keyStorage ?: return false
+ if (!initialized) return false
+
+ val updatedGroups = _groups.value.filterNot { it.groupID.contentEquals(groupID) }
+ val updatedDepartures = departures.toMutableMap()
+ if (departureEpoch != null) {
+ val id = groupID.hexEncodedString()
+ updatedDepartures[id] = maxOf(updatedDepartures[id] ?: -1, departureEpoch)
+ }
+
+ val name = keyName(groupID)
+ val previousKey = keys.get(name)?.copyOf()
+ if (previousKey != null && !keys.remove(name)) {
+ Log.e(TAG, "Failed to remove private-group epoch key")
+ return false
+ }
+ if (!persistLocked(updatedGroups, updatedDepartures)) {
+ restoreKey(keys, name, previousKey)
+ return false
+ }
+
+ departures.clear()
+ departures.putAll(updatedDepartures)
+ _groups.value = updatedGroups.map { it.deepCopy() }
+ return true
+ }
+
+ private fun restoreKey(
+ storage: GroupKeyStorage,
+ name: String,
+ previousKey: ByteArray?
+ ) {
+ val restored = if (previousKey == null) {
+ storage.remove(name)
+ } else {
+ storage.put(name, previousKey)
+ }
+ if (!restored && previousKey != null) {
+ Log.e(TAG, "Failed to restore private-group epoch key after metadata failure")
+ }
+ }
+
+ private fun isValid(group: BitchatGroup, key: ByteArray): Boolean =
+ group.groupID.size == BitchatGroup.GROUP_ID_LENGTH &&
+ key.size == BitchatGroup.KEY_LENGTH &&
+ group.epoch in 0..BitchatGroup.MAX_EPOCH &&
+ group.members.isNotEmpty() &&
+ group.members.size <= BitchatGroup.MAX_MEMBERS &&
+ group.creator != null &&
+ group.members.all {
+ it.fingerprint.matches(Regex("^[0-9a-fA-F]{64}$")) &&
+ it.signingKey.size == 32
+ }
+
+ private fun persistLocked(
+ groups: List,
+ departures: Map
+ ): Boolean {
+ val storage = metadataStorage ?: return true
+ if (groups.isEmpty() && departures.isEmpty()) return storage.delete()
+
+ val state = StoredState(
+ groups = groups.map { group ->
+ StoredGroup(
+ groupID = Base64.encodeToString(group.groupID, Base64.NO_WRAP),
+ name = group.name,
+ epoch = group.epoch,
+ members = group.members.map { member ->
+ StoredMember(
+ fingerprint = member.fingerprint,
+ signingKey = Base64.encodeToString(
+ member.signingKey,
+ Base64.NO_WRAP
+ ),
+ nickname = member.nickname
+ )
+ },
+ creatorFingerprint = group.creatorFingerprint
+ )
+ },
+ departures = departures.toSortedMap()
+ )
+ val persisted = storage.write(gson.toJson(state))
+ if (!persisted) Log.e(TAG, "Failed to persist private-group metadata")
+ return persisted
+ }
+
+ private fun loadLocked(
+ keys: GroupKeyStorage,
+ metadata: GroupMetadataStorage?
+ ) {
+ val raw = metadata?.read() ?: return
+ val parsed = try {
+ val json = JsonParser.parseString(raw)
+ if (json.isJsonArray) {
+ val type = object : TypeToken>() {}.type
+ StoredState(groups = gson.fromJson(json, type), departures = emptyMap())
+ } else {
+ val objectValue = json.asJsonObject
+ val groupType = object : TypeToken>() {}.type
+ val departureType = object : TypeToken>() {}.type
+ StoredState(
+ version = objectValue.get("version")?.asInt ?: 1,
+ groups = objectValue.get("groups")?.let {
+ gson.fromJson(it, groupType)
+ } ?: emptyList(),
+ departures = objectValue.get("departures")?.let {
+ gson.fromJson(it, departureType)
+ } ?: emptyMap()
+ )
+ }
+ } catch (_: Exception) {
+ null
+ } ?: return
+
+ departures.clear()
+ parsed.departures.forEach { (groupID, epoch) ->
+ if (GROUP_ID_HEX.matches(groupID) && epoch in 0..BitchatGroup.MAX_EPOCH) {
+ departures[groupID.lowercase()] = epoch
+ }
+ }
+
+ _groups.value = parsed.groups.mapNotNull { item ->
+ try {
+ val group = BitchatGroup(
+ groupID = Base64.decode(item.groupID, Base64.NO_WRAP),
+ name = item.name,
+ epoch = item.epoch,
+ members = item.members.map { member ->
+ GroupMember(
+ member.fingerprint,
+ Base64.decode(member.signingKey, Base64.NO_WRAP),
+ member.nickname
+ )
+ },
+ creatorFingerprint = item.creatorFingerprint
+ )
+ if (departures.containsKey(group.groupID.hexEncodedString())) {
+ keys.remove(keyName(group.groupID))
+ return@mapNotNull null
+ }
+ val storedKey = keys.get(keyName(group.groupID))
+ ?.takeIf { it.size == BitchatGroup.KEY_LENGTH }
+ ?: return@mapNotNull null
+ group.takeIf { isValid(it, storedKey) }?.deepCopy()
+ } catch (_: Exception) {
+ null
+ }
+ }
+ }
+
+ private fun keyName(groupID: ByteArray): String =
+ "groupKey-${groupID.hexEncodedString()}"
+
+ private fun BitchatGroup.deepCopy(): BitchatGroup = copy(
+ groupID = groupID.copyOf(),
+ members = members.map { it.deepCopy() }
+ )
+
+ private fun GroupMember.deepCopy(): GroupMember =
+ copy(signingKey = signingKey.copyOf())
+
+ companion object {
+ private const val TAG = "GroupStore"
+ private val GROUP_ID_HEX = Regex("^[0-9a-fA-F]{32}$")
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt b/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt
index 1efa87a2..574fea68 100644
--- a/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt
+++ b/app/src/main/java/com/bitchat/android/identity/SecureIdentityStateManager.kt
@@ -10,8 +10,11 @@ import android.util.Base64
import android.util.Log
import com.bitchat.android.model.AuthenticatedPeerState
import com.bitchat.android.model.PeerCapabilities
+import com.bitchat.android.model.VouchAttestation
import com.bitchat.android.util.hexEncodedString
import androidx.core.content.edit
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.asSharedFlow
/**
* Manages persistent identity storage and peer ID rotation - 100% compatible with iOS implementation
@@ -37,22 +40,38 @@ class SecureIdentityStateManager {
private const val KEY_CACHED_FINGERPRINT_NICKNAMES = "cached_fingerprint_nicknames"
private const val KEY_PRIVATE_MEDIA_CAPABILITY_PINS = "private_media_capability_pins_v1"
private const val KEY_AUTHENTICATED_PEER_STATES = "authenticated_peer_states_v1"
+ private const val KEY_VOUCH_RECORDS = "vouch_records_v1"
+ private const val KEY_VOUCH_BATCH_SENT_AT = "vouch_batch_sent_at_v1"
+ private const val KEY_VERIFIED_AT = "verified_at_v1"
+ const val MAX_VOUCHERS_PER_VOUCHEE = 8
+ private const val VOUCH_RECORD_FIELD_COUNT = 4
+ private const val RECORD_SEPARATOR = ':'
+ private const val RECORD_SEPARATOR_LENGTH = 1
+ private const val VOUCHEE_FIELD_INDEX = 0
+ private const val VOUCHER_FIELD_INDEX = 1
+ private const val VOUCHEE_SIGNING_KEY_FIELD_INDEX = 2
+ private const val INDEX_NOT_FOUND = -1
+ private const val IDENTITY_EVENT_BUFFER_CAPACITY = 1
+ private const val EXPIRY_TRANSITION_OFFSET_MS = 1L
// BLE, Wi-Fi Aware, and Noise services each hold their own manager
// instance over the same encrypted preferences. Serialize pin updates
// process-wide so concurrent promotions cannot lose one another or
// race a panic wipe.
- private val privateMediaPinsLock = Any()
- private var privateMediaPinsEpoch = 0L
+ private val identityPersistenceLock = Any()
+ private var identityPersistenceEpoch = 0L
+ private val identityChanges =
+ MutableSharedFlow(extraBufferCapacity = IDENTITY_EVENT_BUFFER_CAPACITY)
+ val changes = identityChanges.asSharedFlow()
}
private val prefs: SharedPreferences
private val lock = Any()
- private var privateMediaPinsEpochAtCreation: Long
+ private var identityPersistenceEpochAtCreation: Long
constructor(context: Context) {
- privateMediaPinsEpochAtCreation = synchronized(privateMediaPinsLock) {
- privateMediaPinsEpoch
+ identityPersistenceEpochAtCreation = synchronized(identityPersistenceLock) {
+ identityPersistenceEpoch
}
// Create master key for encryption
val masterKey = MasterKey.Builder(context, MasterKey.DEFAULT_MASTER_KEY_ALIAS)
@@ -72,8 +91,8 @@ class SecureIdentityStateManager {
/** Test-only storage injection; production always uses encrypted prefs. */
internal constructor(prefs: SharedPreferences, testOnly: Boolean) {
require(testOnly) { "Plain SharedPreferences are test-only" }
- privateMediaPinsEpochAtCreation = synchronized(privateMediaPinsLock) {
- privateMediaPinsEpoch
+ identityPersistenceEpochAtCreation = synchronized(identityPersistenceLock) {
+ identityPersistenceEpoch
}
this.prefs = prefs
}
@@ -223,19 +242,197 @@ class SecureIdentityStateManager {
return getVerifiedFingerprints().contains(fingerprint)
}
+ @SuppressLint("UseKtx")
fun setVerifiedFingerprint(fingerprint: String, verified: Boolean) {
if (!isValidFingerprint(fingerprint)) return
- synchronized(lock) {
- val current = prefs.getStringSet(KEY_VERIFIED_FINGERPRINTS, emptySet())?.toMutableSet() ?: mutableSetOf()
+ val normalizedFingerprint = fingerprint.lowercase()
+ synchronized(identityPersistenceLock) {
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) return
+ val current = prefs.getStringSet(KEY_VERIFIED_FINGERPRINTS, emptySet())
+ ?.mapTo(mutableSetOf()) { it.lowercase() } ?: mutableSetOf()
if (verified) {
- current.add(fingerprint)
+ current.add(normalizedFingerprint)
} else {
- current.remove(fingerprint)
+ current.remove(normalizedFingerprint)
}
- prefs.edit { putStringSet(KEY_VERIFIED_FINGERPRINTS, current) }
+ val verifiedAt = readTimestampMap(KEY_VERIFIED_AT).toMutableMap()
+ if (verified) verifiedAt[normalizedFingerprint] = System.currentTimeMillis()
+ else verifiedAt.remove(normalizedFingerprint)
+ val committed = prefs.edit()
+ .putStringSet(KEY_VERIFIED_FINGERPRINTS, current)
+ .putStringSet(KEY_VERIFIED_AT, encodeTimestampMap(verifiedAt))
+ .commit()
+ if (!committed) return
+ identityChanges.tryEmit(Unit)
}
}
+ data class VouchRecord(
+ val voucherFingerprint: String,
+ val voucheeSigningKeyHex: String,
+ val timestampMs: Long
+ )
+
+ @SuppressLint("UseKtx")
+ fun recordVouch(
+ voucheeFingerprint: String,
+ voucherFingerprint: String,
+ voucheeSigningKey: ByteArray,
+ timestampMs: Long,
+ nowMs: Long = System.currentTimeMillis()
+ ): Boolean {
+ val vouchee = voucheeFingerprint.lowercase()
+ val voucher = voucherFingerprint.lowercase()
+ if (!isValidFingerprint(vouchee) || !isValidFingerprint(voucher) ||
+ voucheeSigningKey.size != VouchAttestation.SIGNING_KEY_SIZE
+ ) return false
+ synchronized(identityPersistenceLock) {
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) return false
+ val verified = getVerifiedFingerprints().mapTo(mutableSetOf()) { it.lowercase() }
+ val age = nowMs - timestampMs
+ if (vouchee == voucher || voucher !in verified || vouchee in verified ||
+ age > VouchAttestation.MAX_AGE_MS ||
+ age < -VouchAttestation.MAX_CLOCK_SKEW_MS
+ ) return false
+
+ val all = readVouchRecords().toMutableMap()
+ val records = all[vouchee].orEmpty().toMutableList()
+ val existing = records.indexOfFirst { it.voucherFingerprint == voucher }
+ val proposed = VouchRecord(
+ voucherFingerprint = voucher,
+ voucheeSigningKeyHex = voucheeSigningKey.hexEncodedString(),
+ timestampMs = timestampMs
+ )
+ val record = records.getOrNull(existing)
+ ?.takeIf { it.timestampMs >= timestampMs }
+ ?: proposed
+ if (existing > INDEX_NOT_FOUND) records[existing] = record else records += record
+ val capped = records.sortedByDescending { it.timestampMs }.take(MAX_VOUCHERS_PER_VOUCHEE)
+ if (capped.none { it.voucherFingerprint == voucher }) return false
+ all[vouchee] = capped
+ val committed = prefs.edit()
+ .putStringSet(KEY_VOUCH_RECORDS, encodeVouchRecords(all))
+ .commit()
+ if (!committed) return false
+ identityChanges.tryEmit(Unit)
+ return true
+ }
+ }
+
+ fun validVouchers(
+ fingerprint: String,
+ nowMs: Long = System.currentTimeMillis()
+ ): List {
+ val normalized = fingerprint.lowercase()
+ if (!isValidFingerprint(normalized)) return emptyList()
+ synchronized(identityPersistenceLock) {
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) return emptyList()
+ val verified = getVerifiedFingerprints().mapTo(mutableSetOf()) { it.lowercase() }
+ val authenticatedSigningKeyHex = getAuthenticatedSigningKey(normalized)
+ ?.hexEncodedString() ?: return emptyList()
+ return readVouchRecords()[normalized].orEmpty().filter {
+ it.voucherFingerprint != normalized &&
+ it.voucherFingerprint in verified &&
+ it.voucheeSigningKeyHex == authenticatedSigningKeyHex &&
+ nowMs - it.timestampMs <= VouchAttestation.MAX_AGE_MS &&
+ nowMs - it.timestampMs >= -VouchAttestation.MAX_CLOCK_SKEW_MS
+ }
+ }
+ }
+
+ fun isVouched(fingerprint: String, nowMs: Long = System.currentTimeMillis()): Boolean {
+ val normalized = fingerprint.lowercase()
+ val isExplicitlyVerified = getVerifiedFingerprints().any {
+ it.equals(normalized, ignoreCase = true)
+ }
+ return !isExplicitlyVerified && validVouchers(normalized, nowMs).isNotEmpty()
+ }
+
+ fun getVouchedFingerprints(nowMs: Long = System.currentTimeMillis()): Set =
+ synchronized(identityPersistenceLock) {
+ readVouchRecords().keys.filterTo(mutableSetOf()) { isVouched(it, nowMs) }
+ }
+
+ fun nextVouchExpiryMs(nowMs: Long = System.currentTimeMillis()): Long? =
+ synchronized(identityPersistenceLock) {
+ readVouchRecords().keys
+ .flatMap { validVouchers(it, nowMs) }
+ .minOfOrNull {
+ it.timestampMs +
+ VouchAttestation.MAX_AGE_MS +
+ EXPIRY_TRANSITION_OFFSET_MS
+ }
+ }
+
+ fun mostRecentlyVerifiedFingerprints(limit: Int, excluding: String): List {
+ return synchronized(identityPersistenceLock) {
+ val verifiedAt = readTimestampMap(KEY_VERIFIED_AT)
+ getVerifiedFingerprints()
+ .map { it.lowercase() }
+ .filterNot { it == excluding.lowercase() }
+ .sortedWith(compareByDescending { verifiedAt[it] ?: Long.MIN_VALUE }.thenByDescending { it })
+ .take(limit)
+ }
+ }
+
+ fun lastVouchBatchSent(fingerprint: String): Long? =
+ synchronized(identityPersistenceLock) {
+ readTimestampMap(KEY_VOUCH_BATCH_SENT_AT)[fingerprint.lowercase()]
+ }
+
+ @SuppressLint("UseKtx")
+ fun markVouchBatchSent(fingerprint: String, timestampMs: Long) {
+ synchronized(identityPersistenceLock) {
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) return
+ val sent = readTimestampMap(KEY_VOUCH_BATCH_SENT_AT).toMutableMap()
+ sent[fingerprint.lowercase()] = timestampMs
+ if (!prefs.edit()
+ .putStringSet(KEY_VOUCH_BATCH_SENT_AT, encodeTimestampMap(sent))
+ .commit()
+ ) {
+ Log.e(TAG, "Vouch batch timestamp could not be committed")
+ }
+ }
+ }
+
+ private fun readTimestampMap(key: String): Map =
+ prefs.getStringSet(key, emptySet()).orEmpty().mapNotNull { entry ->
+ val split = entry.lastIndexOf(RECORD_SEPARATOR)
+ if (split <= VOUCHEE_FIELD_INDEX) {
+ null
+ } else {
+ entry.substring(split + RECORD_SEPARATOR_LENGTH).toLongOrNull()?.let {
+ entry.substring(VOUCHEE_FIELD_INDEX, split) to it
+ }
+ }
+ }.toMap()
+
+ private fun encodeTimestampMap(values: Map): Set =
+ values.mapTo(mutableSetOf()) { (fingerprint, timestamp) ->
+ "$fingerprint$RECORD_SEPARATOR$timestamp"
+ }
+
+ private fun readVouchRecords(): Map> =
+ prefs.getStringSet(KEY_VOUCH_RECORDS, emptySet()).orEmpty().mapNotNull { entry ->
+ val fields = entry.split(RECORD_SEPARATOR)
+ if (fields.size != VOUCH_RECORD_FIELD_COUNT) null else fields.last().toLongOrNull()?.let {
+ fields[VOUCHEE_FIELD_INDEX] to VouchRecord(
+ voucherFingerprint = fields[VOUCHER_FIELD_INDEX],
+ voucheeSigningKeyHex = fields[VOUCHEE_SIGNING_KEY_FIELD_INDEX],
+ timestampMs = it
+ )
+ }
+ }.groupBy({ it.first }, { it.second })
+
+ private fun encodeVouchRecords(values: Map>): Set =
+ values.flatMapTo(mutableSetOf()) { (vouchee, records) ->
+ records.map {
+ "$vouchee$RECORD_SEPARATOR${it.voucherFingerprint}" +
+ "$RECORD_SEPARATOR${it.voucheeSigningKeyHex}" +
+ "$RECORD_SEPARATOR${it.timestampMs}"
+ }
+ }
+
fun getCachedPeerFingerprint(peerID: String): String? {
val pid = peerID.lowercase()
// Reading is safe without lock for SharedPreferences, but synchronizing ensures memory visibility
@@ -323,8 +520,8 @@ class SecureIdentityStateManager {
fun isPrivateMediaCapable(fingerprint: String): Boolean {
if (!isValidFingerprint(fingerprint)) return false
- return synchronized(privateMediaPinsLock) {
- if (privateMediaPinsEpochAtCreation != privateMediaPinsEpoch) {
+ return synchronized(identityPersistenceLock) {
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) {
return@synchronized false
}
prefs.getStringSet(KEY_PRIVATE_MEDIA_CAPABILITY_PINS, emptySet())
@@ -339,11 +536,13 @@ class SecureIdentityStateManager {
state: AuthenticatedPeerState,
onCommitted: () -> Unit = {}
): Boolean {
- if (!isValidFingerprint(fingerprint) || state.signingPublicKey.size != 32) return false
+ if (!isValidFingerprint(fingerprint) ||
+ state.signingPublicKey.size != VouchAttestation.SIGNING_KEY_SIZE
+ ) return false
val normalizedFingerprint = fingerprint.lowercase()
- return synchronized(privateMediaPinsLock) {
+ return synchronized(identityPersistenceLock) {
// A controller that survived panic must not republish pre-wipe proof state.
- if (privateMediaPinsEpochAtCreation != privateMediaPinsEpoch) return@synchronized false
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) return@synchronized false
val records = prefs.getStringSet(KEY_AUTHENTICATED_PEER_STATES, emptySet())
?.toMutableSet() ?: mutableSetOf()
records.removeAll { it.startsWith("$normalizedFingerprint:") }
@@ -362,15 +561,18 @@ class SecureIdentityStateManager {
// This result is a security boundary: do not publish the Ed key in memory unless the
// encrypted identity record and its HSTS pin were durably committed together.
editor.commit().also { committed ->
- if (committed) onCommitted()
+ if (committed) {
+ identityChanges.tryEmit(Unit)
+ onCommitted()
+ }
}
}
}
fun getAuthenticatedPeerState(fingerprint: String): AuthenticatedPeerState? {
if (!isValidFingerprint(fingerprint)) return null
- return synchronized(privateMediaPinsLock) {
- if (privateMediaPinsEpochAtCreation != privateMediaPinsEpoch) return@synchronized null
+ return synchronized(identityPersistenceLock) {
+ if (identityPersistenceEpochAtCreation != identityPersistenceEpoch) return@synchronized null
val prefix = "${fingerprint.lowercase()}:"
val record = prefs.getStringSet(KEY_AUTHENTICATED_PEER_STATES, emptySet())
?.firstOrNull { it.startsWith(prefix) } ?: return@synchronized null
@@ -466,21 +668,18 @@ class SecureIdentityStateManager {
* Clear all identity data (for panic mode)
*/
@SuppressLint("UseKtx")
- fun clearIdentityData() {
- try {
- synchronized(privateMediaPinsLock) {
- privateMediaPinsEpoch += 1
- privateMediaPinsEpochAtCreation = privateMediaPinsEpoch
- if (!prefs.edit().clear().commit()) {
- Log.e(TAG, "Identity preference wipe could not be committed")
- }
- }
- Log.w(TAG, "All identity data cleared")
- } catch (e: Exception) {
- Log.e(TAG, "Failed to clear identity data: ${e.message}")
+ fun clearIdentityData(): Boolean = try {
+ synchronized(identityPersistenceLock) {
+ identityPersistenceEpoch += 1
+ identityPersistenceEpochAtCreation = identityPersistenceEpoch
+ check(prefs.edit().clear().commit()) { "Identity preference wipe could not be committed" }
+ identityChanges.tryEmit(Unit)
}
+ true
+ } catch (_: Exception) {
+ false
}
-
+
/**
* Check if identity data exists
*/
@@ -493,6 +692,10 @@ class SecureIdentityStateManager {
/**
* Store a string value in secure preferences
*/
+ /** Persist keys and consumption state before making their use observable. */
+ fun storeSecureValueSynchronously(key: String, value: String): Boolean =
+ prefs.edit().putString(key, value).commit()
+
fun storeSecureValue(key: String, value: String) {
prefs.edit().putString(key, value).apply()
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/BLEPacketPaddingPolicy.kt b/app/src/main/java/com/bitchat/android/mesh/BLEPacketPaddingPolicy.kt
index 279fe527..d9276151 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BLEPacketPaddingPolicy.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BLEPacketPaddingPolicy.kt
@@ -11,7 +11,7 @@ import com.bitchat.android.protocol.MessageType
object BLEPacketPaddingPolicy {
fun shouldPadForBLE(type: UByte): Boolean {
return when (MessageType.fromValue(type)) {
- MessageType.NOISE_ENCRYPTED, MessageType.NOISE_HANDSHAKE -> true
+ MessageType.NOISE_ENCRYPTED, MessageType.NOISE_HANDSHAKE, MessageType.COURIER_ENVELOPE -> true
else -> false
}
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt
index 0e4f29af..81e80b68 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothConnectionManager.kt
@@ -367,6 +367,26 @@ class BluetoothConnectionManager(
)
}
+ suspend fun sendToPeerAndAwaitAcceptance(peerID: String, routed: RoutedPacket): Boolean {
+ if (!isActive || !isBleTransportEnabled()) return false
+ return packetBroadcaster.sendPacketToPeerAndAwaitAcceptance(
+ routed,
+ peerID,
+ serverManager.getGattServer(),
+ serverManager.getCharacteristic()
+ )
+ }
+
+ suspend fun sendToPeerAndAwaitCompletion(peerID: String, routed: RoutedPacket): Boolean {
+ if (!isActive || !isBleTransportEnabled()) return false
+ return packetBroadcaster.sendPacketToPeerAndAwaitCompletion(
+ routed,
+ peerID,
+ serverManager.getGattServer(),
+ serverManager.getCharacteristic()
+ )
+ }
+
fun cancelTransfer(transferId: String): Boolean {
return packetBroadcaster.cancelTransfer(transferId)
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
index 22f17867..6b7f1557 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
@@ -2,13 +2,13 @@ package com.bitchat.android.mesh
import android.content.Context
import android.util.Log
+import com.bitchat.android.board.transportSenderID
import com.bitchat.android.crypto.EncryptionService
import com.bitchat.android.model.BitchatMessage
import com.bitchat.android.model.AuthenticatedPeerState
import com.bitchat.android.model.PeerCapabilities
import com.bitchat.android.protocol.MessagePadding
import com.bitchat.android.model.RoutedPacket
-import com.bitchat.android.model.IdentityAnnouncement
import com.bitchat.android.model.NoisePayload
import com.bitchat.android.model.NoisePayloadType
import com.bitchat.android.protocol.BitchatPacket
@@ -19,6 +19,8 @@ import com.bitchat.android.sync.GossipSyncManager
import com.bitchat.android.util.toHexString
import com.bitchat.android.services.VerificationService
import com.bitchat.android.service.TransportBridgeService
+import com.bitchat.android.identity.SecureIdentityStateManager
+import com.bitchat.android.services.bridge.BridgeProtocolPacketFactory
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.Channel
import java.util.*
@@ -49,10 +51,17 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
// Core components - each handling specific responsibilities
private val encryptionService = EncryptionService(context)
+ private val courierStore = CourierStore(context)
+ private val bridgeCourierService by lazy {
+ com.bitchat.android.nostr.BridgeCourierService(context, encryptionService) { envelope ->
+ handleLocalCourierEnvelope(envelope)
+ }
+ }
// My peer identification - derived from persisted Noise identity fingerprint (first 16 hex chars)
val myPeerID: String = encryptionService.getIdentityFingerprint().take(16)
private val peerManager = PeerManager()
+ private val identityState = SecureIdentityStateManager(context.applicationContext)
private val fragmentManager = FragmentManager()
private val serviceScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
private val readReceiptRetrySender = RetryingControlPacketSender(serviceScope)
@@ -65,13 +74,14 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
store = authenticatedPeerStateStore,
localStateProvider = {
AuthenticatedPeerState(
- PeerCapabilities.LOCAL_SUPPORTED,
+ PeerCapabilities.localSupported(),
requireNotNull(encryptionService.getSigningPublicKey())
)
},
applyAuthenticatedState = peerManager::applyAuthenticatedPeerState,
sendState = ::sendAuthenticatedPeerState,
- onResolution = { peerID -> delegate?.didResolvePrivateMediaPolicy(peerID) }
+ onResolution = { peerID -> GroupMessagePort.receiver?.peerAuthenticated(peerID)
+ delegate?.didResolvePrivateMediaPolicy(peerID) }
)
}
private val privateMediaSecurity by lazy { PrivateMediaSecurityController(
@@ -109,11 +119,15 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
private val securityManager = SecurityManager(encryptionService, myPeerID)
private val storeForwardManager = StoreForwardManager()
+ private val boardStore = com.bitchat.android.board.BoardStore.getInstance(context)
private val messageHandler = MessageHandler(myPeerID, context.applicationContext)
internal val connectionManager = BluetoothConnectionManager(context, myPeerID, fragmentManager) // Made internal for access
private val packetProcessor = PacketProcessor(myPeerID)
private data class VoiceFrameRequest(val recipientPeerID: String?, val payload: ByteArray)
private val voiceFrameQueue = Channel(capacity = 128)
+ private val meshPingManager = MeshPingManager(myPeerID, serviceScope) { packet ->
+ broadcastRoutedPacket(RoutedPacket(packet))
+ }
private lateinit var gossipSyncManager: GossipSyncManager
// Service-level notification manager for background (no-UI) DMs
private val serviceNotificationManager = com.bitchat.android.ui.NotificationManager(
@@ -130,6 +144,20 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
// Coroutines
// Tracks whether this instance has been terminated via stopServices()
private var terminated = false
+ private val vouchCoordinator by lazy {
+ VouchCoordinator(
+ scope = serviceScope,
+ identity = identityState,
+ connectedPeerIDs = peerManager::getActivePeerIDs,
+ fingerprintForPeer = peerManager::getFingerprintForPeer,
+ peerInfo = peerManager::getPeerInfo,
+ signingKeyForFingerprint = ::signingKeyForFingerprint,
+ hasEstablishedSession = encryptionService::hasEstablishedSession,
+ sign = encryptionService::signData,
+ verify = encryptionService::verifyEd25519Signature,
+ send = ::sendVouchPayload
+ )
+ }
init {
serviceScope.launch {
@@ -156,10 +184,11 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
gossipSyncManager = GossipSyncManager(
myPeerID = myPeerID,
scope = serviceScope,
+ context = context,
configProvider = object : GossipSyncManager.ConfigProvider {
override fun seenCapacity(): Int = try {
- com.bitchat.android.ui.debug.DebugPreferenceManager.getSeenPacketCapacity(500)
- } catch (_: Exception) { 500 }
+ com.bitchat.android.ui.debug.DebugPreferenceManager.getSeenPacketCapacity(1000)
+ } catch (_: Exception) { 1000 }
override fun gcsMaxBytes(): Int = try {
com.bitchat.android.ui.debug.DebugPreferenceManager.getGcsMaxFilterBytes(400)
@@ -170,6 +199,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
} catch (_: Exception) { 0.01 }
}
)
+ gossipSyncManager.boardPacketsProvider = boardStore::syncCandidates
com.bitchat.android.service.MeshServiceHolder.setGossipManager(gossipSyncManager) { packet ->
signPacketBeforeBroadcast(packet)
@@ -177,6 +207,11 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
if (isBleTransportEnabled()) {
TransportBridgeService.register("BLE", this)
}
+ serviceScope.launch {
+ com.bitchat.android.services.bridge.MeshBridgeService.isEnabled.collect { enabled ->
+ if (enabled) bridgeCourierService.start() else bridgeCourierService.stop()
+ }
+ }
// Inject dynamic direct connection check into PeerManager
// Matches iOS logic: checks if we have an active hardware mapping for this peer
@@ -200,6 +235,11 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
connectionManager.sendPacketToPeer(peerID, packet)
}
+ override fun sendToPeerAndReport(peerID: String, packet: BitchatPacket): Boolean {
+ if (!isBleTransportEnabled()) return false
+ return connectionManager.sendPacketToPeer(peerID, packet)
+ }
+
private fun broadcastRoutedPacket(routed: RoutedPacket): Boolean {
if (!isBleTransportEnabled()) return false
val queued = connectionManager.broadcastPacket(routed)
@@ -259,6 +299,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
override fun onPeerListUpdated(peerIDs: List) {
// Update process-wide state first
try { com.bitchat.android.services.AppStateStore.setTransportPeers("BLE", peerIDs) } catch (_: Exception) { }
+ vouchCoordinator.peersUpdated(peerIDs)
// Then notify UI delegate if attached
delegate?.didUpdatePeerList(peerIDs)
}
@@ -291,6 +332,10 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
authenticatedRemoteStaticKey,
authenticatedSessionToken
)
+ vouchCoordinator.peerAuthenticated(
+ peerID,
+ identityState.generateFingerprint(authenticatedRemoteStaticKey)
+ )
// Send announcement and cached messages after key exchange
serviceScope.launch {
delay(100)
@@ -396,7 +441,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
override fun getBroadcastRecipient(): ByteArray {
return SpecialRecipients.BROADCAST
}
-
+
// Cryptographic operations
override fun verifySignature(packet: BitchatPacket, peerID: String): Boolean {
return securityManager.verifySignature(packet, peerID)
@@ -514,6 +559,8 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
override fun onDeliveryAckReceived(messageID: String, peerID: String) {
+ com.bitchat.android.services.PrivateMediaOutbox.tryGetInstance()?.acknowledge(messageID, peerID)
+ try { com.bitchat.android.services.MessageRouter.tryGetInstance()?.onMessageAcknowledged(messageID, peerID) } catch (_: Exception) { }
// Status events can arrive while MainActivity has detached the UI delegate.
// Persist first so the next UI collector observes the advancement.
try {
@@ -526,6 +573,8 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
override fun onReadReceiptReceived(messageID: String, peerID: String) {
+ com.bitchat.android.services.PrivateMediaOutbox.tryGetInstance()?.acknowledge(messageID, peerID)
+ try { com.bitchat.android.services.MessageRouter.tryGetInstance()?.onMessageAcknowledged(messageID, peerID) } catch (_: Exception) { }
try {
com.bitchat.android.services.AppStateStore.updatePrivateMessageStatus(
messageID,
@@ -542,6 +591,30 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
override fun onVerifyResponseReceived(peerID: String, payload: ByteArray, timestampMs: Long) {
delegate?.didReceiveVerifyResponse(peerID, payload, timestampMs)
}
+
+ override fun onGroupInviteReceived(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ GroupMessagePort.receiver?.invite(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun onGroupKeyUpdateReceived(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ GroupMessagePort.receiver?.keyUpdate(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun onGroupMessageReceived(payload: ByteArray, timestampMs: Long) {
+ GroupMessagePort.receiver?.message(payload, timestampMs)
+ }
+
+ override fun onVouchPayloadReceived(peerID: String, payload: ByteArray) {
+ vouchCoordinator.handlePayload(peerID, payload)
+ }
}
// PacketProcessor delegates
@@ -566,6 +639,9 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
override fun getBroadcastRecipient(): ByteArray {
return SpecialRecipients.BROADCAST
}
+
+ override fun isPeerDirectlyConnected(peerID: String): Boolean =
+ peerManager.getPeerInfo(peerID)?.isDirectConnection == true
override fun handleNoiseHandshake(routed: RoutedPacket): Boolean {
return runBlocking { securityManager.handleNoiseHandshake(routed) }
@@ -574,6 +650,10 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
override fun handleNoiseEncrypted(routed: RoutedPacket): Boolean {
return runBlocking { messageHandler.handleNoiseEncrypted(routed) }
}
+
+ override fun handleCourierEnvelope(routed: RoutedPacket): Boolean {
+ return handleCourierEnvelopePacket(routed)
+ }
override suspend fun handleAnnounce(routed: RoutedPacket): Boolean {
val result = messageHandler.handleAnnounceWithResult(routed)
@@ -599,6 +679,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
}
try { gossipSyncManager.onPublicPacketSeen(routed.packet) } catch (_: Exception) { }
+ handleCourierAnnounce(routed)
return true
}
@@ -608,7 +689,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
try {
val pkt = routed.packet
val isBroadcast = (pkt.recipientID == null || pkt.recipientID.contentEquals(SpecialRecipients.BROADCAST))
- if (isBroadcast && pkt.type == MessageType.MESSAGE.value) {
+ if (isBroadcast && pkt.type in setOf(MessageType.MESSAGE.value, MessageType.FILE_TRANSFER.value)) {
gossipSyncManager.onPublicPacketSeen(pkt)
}
} catch (_: Exception) { }
@@ -616,6 +697,10 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
override fun handleVoiceFrame(routed: RoutedPacket): Boolean =
messageHandler.handlePublicVoiceFrame(routed)
+ override fun handleGroupMessage(routed: RoutedPacket) {
+ messageHandler.handleGroupMessage(routed)
+ try { gossipSyncManager.onPublicPacketSeen(routed.packet) } catch (_: Exception) { }
+ }
override fun handleLeave(routed: RoutedPacket) {
serviceScope.launch { messageHandler.handleLeave(routed) }
@@ -656,6 +741,15 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
val req = RequestSyncPacket.decode(routed.packet.payload) ?: return
gossipSyncManager.handleRequestSync(fromPeer, req)
}
+
+ override fun handleBoardPost(routed: RoutedPacket): Boolean {
+ val wire = com.bitchat.android.board.BoardWireCodec.decode(routed.packet.payload)
+ ?: return false
+ return boardStore.ingestRemoteForRelay(wire, routed.packet)
+ }
+ override fun handlePing(routed: RoutedPacket) = meshPingManager.handlePing(routed)
+
+ override fun handlePong(routed: RoutedPacket) = meshPingManager.handlePong(routed)
}
// BluetoothConnectionManager delegates
@@ -746,6 +840,10 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
}
+ fun sendMeshPing(peerID: String, callback: (MeshPingResult?) -> Unit) {
+ meshPingManager.ping(peerID, callback)
+ }
+
/**
* Start the mesh service
*/
@@ -809,6 +907,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
* Stop all mesh services
*/
fun stopServices() {
+ if (bridgeCourierService.isStarted) bridgeCourierService.stop()
if (!isActive) {
Log.w(TAG, "Mesh service not active, ignoring stop request")
return
@@ -857,6 +956,7 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
*/
fun sendMessage(content: String, mentions: List = emptyList(), channel: String? = null) {
if (content.isEmpty()) return
+ val bridgePolicyAtSend = BridgeMeshPort.outboundPolicy()
serviceScope.launch {
val packet = BitchatPacket(
@@ -875,6 +975,84 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
broadcastRoutedPacket(RoutedPacket(signedPacket))
// Track our own broadcast message for sync
try { gossipSyncManager.onPublicPacketSeen(signedPacket) } catch (_: Exception) { }
+ if (channel == null) {
+ val nickname = runCatching {
+ com.bitchat.android.services.NicknameProvider.getNickname(context, myPeerID)
+ }.getOrNull()
+ BridgeMeshPort.bridgeOutgoing(
+ content,
+ myPeerID,
+ packet.timestamp.toLong(),
+ nickname,
+ bridgePolicyAtSend
+ )
+ }
+ }
+ }
+
+ fun sendNostrCarrier(payload: ByteArray, recipientPeerID: String?) {
+ sendRawProtocolPacket(MessageType.NOSTR_CARRIER, payload, recipientPeerID, sign = true)
+ }
+
+ fun sendCourierEnvelope(payload: ByteArray, recipientPeerID: String) {
+ sendRawProtocolPacket(MessageType.COURIER_ENVELOPE, payload, recipientPeerID, sign = true)
+ }
+
+ fun sendPrekeyBundle(payload: ByteArray) {
+ sendRawProtocolPacket(MessageType.PREKEY_BUNDLE, payload, null, sign = true)
+ }
+
+ private fun sendRawProtocolPacket(
+ type: MessageType,
+ payload: ByteArray,
+ recipientPeerID: String?,
+ sign: Boolean
+ ) {
+ if (payload.isEmpty()) return
+ serviceScope.launch {
+ val packet = BridgeProtocolPacketFactory.protocolPacket(
+ type = type,
+ payload = payload,
+ senderPeerId = myPeerID,
+ recipientPeerId = recipientPeerID,
+ ttl = MAX_TTL
+ ) ?: return@launch
+ val outgoing = if (sign) signPacketBeforeBroadcast(packet) else packet
+ if (sign &&
+ type != MessageType.COURIER_ENVELOPE &&
+ outgoing.signature?.size != 64
+ ) {
+ return@launch
+ }
+ gossipSyncManager.onPublicPacketSeen(outgoing)
+ broadcastRoutedPacket(RoutedPacket(outgoing))
+ }
+ }
+
+
+
+ fun sendBoardPayload(payload: ByteArray) {
+ val wire = com.bitchat.android.board.BoardWireCodec.decode(payload) ?: return
+ if (!wire.verifySignature()) return
+ serviceScope.launch {
+ // The inner board signature is authoritative. A stable outer
+ // sender/signature would re-link otherwise isolated location scopes.
+ val packet = BitchatPacket(
+ version = 1u,
+ type = MessageType.BOARD_POST.value,
+ senderID = wire.transportSenderID(),
+ recipientID = null,
+ timestamp = System.currentTimeMillis().coerceAtLeast(0).toULong(),
+ payload = payload,
+ signature = null,
+ ttl = MAX_TTL
+ )
+ boardStore.ingest(
+ wire,
+ packet,
+ com.bitchat.android.board.BoardIngestSource.LOCAL
+ )
+ broadcastRoutedPacket(RoutedPacket(packet))
}
}
@@ -907,6 +1085,31 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
return true
}
+ private fun signingKeyForFingerprint(fingerprint: String): ByteArray? {
+ identityState.getAuthenticatedSigningKey(fingerprint)?.let { return it }
+ return peerManager.getActivePeerIDs().firstNotNullOfOrNull { peerID ->
+ val peerFingerprint = peerManager.getFingerprintForPeer(peerID)
+ peerManager.getPeerInfo(peerID)?.signingPublicKey
+ ?.takeIf { peerFingerprint.equals(fingerprint, ignoreCase = true) }
+ }
+ }
+
+ private fun sendVouchPayload(peerID: String, payload: ByteArray): Boolean {
+ val plaintext = NoisePayload(NoisePayloadType.VOUCH, payload).encode()
+ val encrypted = securityManager.encryptForPeer(plaintext, peerID) ?: return false
+ val packet = BitchatPacket(
+ version = VouchCoordinator.NOISE_PACKET_VERSION,
+ type = MessageType.NOISE_ENCRYPTED.value,
+ senderID = hexStringToByteArray(myPeerID),
+ recipientID = hexStringToByteArray(peerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = encrypted,
+ ttl = MAX_TTL
+ )
+ broadcastRoutedPacket(RoutedPacket(signPacketBeforeBroadcast(packet)))
+ return true
+ }
+
fun sendFileBroadcast(file: com.bitchat.android.model.BitchatFilePacket) {
try {
val payload = file.encode()
@@ -937,6 +1140,12 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
/** Safe non-interactive entry point: encrypted sends commit; legacy sends require UI consent. */
+ fun supportsPrivateMediaReceipts(peerID: String): Boolean {
+ val session = encryptionService.getAuthenticatedSession(peerID) ?: return false
+ val proof = authenticatedPeerState.status(peerID, session) as? AuthenticatedPeerStateStatus.Proven ?: return false
+ return proof.state.capabilities.contains(com.bitchat.android.model.PeerCapabilities.PRIVATE_MEDIA_RECEIPTS)
+ }
+
fun sendFilePrivate(recipientPeerID: String, file: com.bitchat.android.model.BitchatFilePacket) {
val payload = file.encode() ?: return
when (val prepared = prepareFilePrivate(
@@ -1206,6 +1415,42 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
sendNoisePayloadToPeer(payload, peerID, "verify response")
}
+ fun sendGroupInvite(payload: ByteArray, recipientPeerID: String) {
+ sendNoisePayloadToPeer(
+ NoisePayload(NoisePayloadType.GROUP_INVITE, payload),
+ recipientPeerID,
+ "group invite"
+ )
+ }
+
+ fun sendGroupKeyUpdate(payload: ByteArray, recipientPeerID: String) {
+ sendNoisePayloadToPeer(
+ NoisePayload(NoisePayloadType.GROUP_KEY_UPDATE, payload),
+ recipientPeerID,
+ "group key update"
+ )
+ }
+
+ fun broadcastGroupMessage(payload: ByteArray) {
+ if (payload.isEmpty()) return
+ serviceScope.launch {
+ val packet = BitchatPacket(
+ version = if (payload.size > 0xffff) 2u else 1u,
+ type = MessageType.GROUP_MESSAGE.value,
+ senderID = hexStringToByteArray(myPeerID),
+ recipientID = SpecialRecipients.BROADCAST,
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = payload,
+ signature = null,
+ ttl = MAX_TTL
+ )
+ // The outer packet is intentionally unsigned. Authenticity is
+ // verified from the Ed25519 signature inside the ciphertext.
+ broadcastRoutedPacket(RoutedPacket(packet))
+ try { gossipSyncManager.onPublicPacketSeen(packet) } catch (_: Exception) { }
+ }
+ }
+
private fun sendNoisePayloadToPeer(payload: NoisePayload, recipientPeerID: String, label: String) {
serviceScope.launch {
try {
@@ -1251,7 +1496,11 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
// Create iOS-compatible IdentityAnnouncement with TLV encoding
- val announcement = IdentityAnnouncement.forLocalPeer(nickname, staticKey, signingKey)
+ val announcement = BridgeProtocolPacketFactory.identityAnnouncement(
+ nickname,
+ staticKey,
+ signingKey
+ )
var tlvPayload = announcement.encode()
if (tlvPayload == null) {
Log.e(TAG, "Failed to encode announcement as TLV")
@@ -1313,7 +1562,11 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
}
// Create iOS-compatible IdentityAnnouncement with TLV encoding
- val announcement = IdentityAnnouncement.forLocalPeer(nickname, staticKey, signingKey)
+ val announcement = BridgeProtocolPacketFactory.identityAnnouncement(
+ nickname,
+ staticKey,
+ signingKey
+ )
var tlvPayload = announcement.encode()
if (tlvPayload == null) {
Log.e(TAG, "Failed to encode peer announcement as TLV")
@@ -1442,6 +1695,218 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
return peerManager.getPeerInfo(peerID)
}
+ fun getPeerInfos(): List = peerManager.getAllPeerNicknames().keys.mapNotNull(peerManager::getPeerInfo)
+
+ fun sendCourierMessage(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ courierPeerIDs: List
+ ): List {
+ val privateMessage = com.bitchat.android.model.PrivateMessagePacket(messageID, content).encode() ?: return emptyList()
+ val typedPayload = com.bitchat.android.model.NoisePayload(
+ com.bitchat.android.model.NoisePayloadType.PRIVATE_MESSAGE,
+ privateMessage
+ ).encode()
+ val sealed = try { com.bitchat.android.services.bridge.PrekeyManager.getInstance(context).seal(typedPayload, messageID, recipientNoiseKey, true) } catch (_: Exception) { return emptyList() }
+ val now = System.currentTimeMillis()
+ val couriers = courierPeerIDs.distinct().take(4)
+ if (couriers.isEmpty()) return emptyList()
+ return couriers.filter { courierID ->
+ val envelope = com.bitchat.android.model.CourierEnvelope(
+ recipientTag = com.bitchat.android.model.CourierEnvelope.recipientTag(
+ recipientNoiseKey,
+ com.bitchat.android.model.CourierEnvelope.epochDay(now)
+ ),
+ expiry = (now + com.bitchat.android.model.CourierEnvelope.MAX_LIFETIME_MS).toULong(),
+ ciphertext = sealed.ciphertext,
+ prekeyID = sealed.prekeyId?.toUInt(),
+ copies = 4u
+ )
+ val payload = envelope.encode() ?: return@filter false
+ val packet = BitchatPacket(
+ type = MessageType.COURIER_ENVELOPE.value,
+ senderID = hexStringToByteArray(myPeerID),
+ recipientID = hexStringToByteArray(courierID),
+ timestamp = now.toULong(),
+ payload = payload,
+ ttl = MAX_TTL
+ )
+ TransportBridgeService.sendToPeerFromLocalAndReport(courierID, signPacketBeforeBroadcast(packet))
+ }
+ }
+
+ fun sendBridgeCourierMessage(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ onAccepted: () -> Unit = {}
+ ): Boolean = bridgeCourierService.deposit(content, messageID, recipientNoiseKey, onAccepted)
+
+ private fun handleLocalCourierEnvelope(envelope: com.bitchat.android.model.CourierEnvelope) {
+ val packet = BitchatPacket(
+ type = MessageType.COURIER_ENVELOPE.value,
+ senderID = ByteArray(8),
+ recipientID = hexStringToByteArray(myPeerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = envelope.encode() ?: return,
+ ttl = MAX_TTL
+ )
+ handleCourierEnvelopePacket(RoutedPacket(packet, peerID = "bridge"))
+ }
+
+ private fun handleCourierEnvelopePacket(routed: RoutedPacket): Boolean {
+ val envelope = com.bitchat.android.model.CourierEnvelope.decode(routed.packet.payload) ?: return false
+ val now = System.currentTimeMillis()
+ if (envelope.expiry.toLong() <= now) return false
+ val localKey = encryptionService.getStaticPublicKey() ?: return false
+ if (envelope.matchesRecipient(localKey, now)) {
+ val opened = try {
+ com.bitchat.android.services.bridge.PrekeyManager.getInstance(context)
+ .open(envelope.ciphertext, envelope.prekeyID?.toLong())
+ } catch (_: Exception) { return false }
+ val senderKey = opened.senderStaticKey
+ val typedPayload = opened.payload
+ if (opened.consumedPrekey) {
+ com.bitchat.android.services.bridge.MeshBridgeService.refreshPrekeys()
+ }
+ val noisePayload = com.bitchat.android.model.NoisePayload.decode(typedPayload) ?: return false
+ if (noisePayload.type !in setOf(
+ com.bitchat.android.model.NoisePayloadType.PRIVATE_MESSAGE,
+ com.bitchat.android.model.NoisePayloadType.DELIVERED
+ )
+ ) return false
+ val senderPeerID = com.bitchat.android.services.ContactIdentityResolver.peerIdForNoiseKey(senderKey)
+ val synthetic = routed.copy(
+ packet = routed.packet.copy(
+ type = MessageType.NOISE_ENCRYPTED.value,
+ senderID = hexStringToByteArray(senderPeerID),
+ payload = typedPayload,
+ timestamp = System.currentTimeMillis().toULong()
+ ),
+ peerID = senderPeerID
+ )
+ val delivered = runBlocking { messageHandler.handleOpenedCourierPayload(synthetic) }
+ if (delivered && noisePayload.type == com.bitchat.android.model.NoisePayloadType.PRIVATE_MESSAGE) {
+ val messageID = com.bitchat.android.model.PrivateMessagePacket.decode(noisePayload.data)?.messageID
+ if (messageID != null) sendCourierDeliveryAck(messageID, senderKey, routed)
+ }
+ return delivered
+ }
+ val peerID = routed.peerID ?: return false
+ if (!DirectCourierDepositPolicy.accepts(
+ routed,
+ MAX_TTL,
+ connectionManager::getCurrentLinkID,
+ connectionManager.addressPeerMap::get
+ )
+ ) return false
+ val depositor = peerManager.getPeerInfo(peerID) ?: return false
+ val key = depositor.noisePublicKey ?: return false
+ val favorite = try {
+ com.bitchat.android.favorites.FavoritesPersistenceService.shared.getFavoriteStatus(key)?.isMutual == true
+ } catch (_: Exception) { false }
+ val tier = if (favorite) CourierDepositTier.FAVORITE
+ else if (depositor.hasVerifiedAnnouncement) CourierDepositTier.VERIFIED
+ else return false
+ return courierStore.deposit(envelope, key, tier)
+ }
+
+ private fun sendCourierDeliveryAck(messageID: String, senderNoiseKey: ByteArray, ingress: RoutedPacket) {
+ val typedPayload = com.bitchat.android.model.NoisePayload(
+ com.bitchat.android.model.NoisePayloadType.DELIVERED,
+ messageID.toByteArray(Charsets.UTF_8)
+ ).encode()
+ if (ingress.peerID == "bridge") {
+ bridgeCourierService.depositPayload(typedPayload, senderNoiseKey)
+ return
+ }
+ val courierPeerID = ingress.peerID ?: return
+ val now = System.currentTimeMillis()
+ val sealed = try { encryptionService.sealCourierPayload(typedPayload, senderNoiseKey) } catch (_: Exception) { return }
+ val envelope = com.bitchat.android.model.CourierEnvelope(
+ recipientTag = com.bitchat.android.model.CourierEnvelope.recipientTag(
+ senderNoiseKey,
+ com.bitchat.android.model.CourierEnvelope.epochDay(now)
+ ),
+ expiry = (now + com.bitchat.android.model.CourierEnvelope.MAX_LIFETIME_MS).toULong(),
+ ciphertext = sealed,
+ copies = 4u
+ )
+ val packet = BitchatPacket(
+ type = MessageType.COURIER_ENVELOPE.value,
+ senderID = hexStringToByteArray(myPeerID),
+ recipientID = hexStringToByteArray(courierPeerID),
+ timestamp = now.toULong(),
+ payload = envelope.encode() ?: return,
+ ttl = MAX_TTL
+ )
+ TransportBridgeService.sendToPeerFromLocalAndReport(courierPeerID, signPacketBeforeBroadcast(packet))
+ }
+
+ private fun handleCourierAnnounce(routed: RoutedPacket) {
+ val peerID = routed.peerID ?: return
+ val info = peerManager.getPeerInfo(peerID) ?: return
+ val noiseKey = info.noisePublicKey ?: return
+ val direct = routed.packet.ttl >= MAX_TTL
+ val envelopes = if (direct) courierStore.copiesForRecipient(noiseKey) else courierStore.copiesForRemoteHandover(noiseKey)
+ envelopes.forEach { envelope ->
+ val packet = BitchatPacket(
+ type = MessageType.COURIER_ENVELOPE.value,
+ senderID = hexStringToByteArray(myPeerID),
+ recipientID = hexStringToByteArray(peerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = envelope.encode() ?: return@forEach,
+ ttl = MAX_TTL
+ )
+ if (direct) {
+ serviceScope.launch {
+ if (connectionManager.sendToPeerAndAwaitCompletion(
+ peerID,
+ RoutedPacket(signPacketBeforeBroadcast(packet))
+ )
+ ) {
+ courierStore.remove(envelope)
+ }
+ }
+ } else TransportBridgeService.broadcastFromLocal(RoutedPacket(signPacketBeforeBroadcast(packet)))
+ }
+ if (direct) {
+ courierStore.sprayCopiesFor(noiseKey).forEach { envelope ->
+ val payload = envelope.encode()
+ if (payload == null) {
+ courierStore.cancelSpray(envelope, noiseKey)
+ return@forEach
+ }
+ val packet = BitchatPacket(
+ type = MessageType.COURIER_ENVELOPE.value,
+ senderID = hexStringToByteArray(myPeerID),
+ recipientID = hexStringToByteArray(peerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = payload,
+ ttl = MAX_TTL
+ )
+ serviceScope.launch {
+ var committed = false
+ try {
+ if (connectionManager.sendToPeerAndAwaitCompletion(
+ peerID,
+ RoutedPacket(signPacketBeforeBroadcast(packet))
+ )
+ ) {
+ committed = courierStore.commitSpray(envelope, noiseKey)
+ }
+ } finally {
+ if (!committed) courierStore.cancelSpray(envelope, noiseKey)
+ }
+ }.invokeOnCompletion {
+ // A coroutine cancelled before its body starts never reaches finally.
+ courierStore.cancelSpray(envelope, noiseKey)
+ }
+ }
+ }
+ }
+
/**
* Update peer information with verification data
*/
@@ -1465,6 +1930,12 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
fun getStaticNoisePublicKey(): ByteArray? {
return encryptionService.getStaticPublicKey()
}
+
+ fun getSigningPublicKey(): ByteArray? =
+ encryptionService.getSigningPublicKey()?.copyOf()
+
+ fun signData(data: ByteArray): ByteArray? =
+ encryptionService.signData(data)
/**
* Check if encryption icon should be shown for a peer
@@ -1620,20 +2091,23 @@ class BluetoothMeshService(private val context: Context) : TransportBridgeServic
*/
fun clearAllInternalData() {
Log.w(TAG, "Clearing all mesh service internal data")
- try {
- // Stop services to cease broadcasting old ID immediately
- stopServices()
-
- // Clear all managers
- fragmentManager.clearAllFragments()
- storeForwardManager.clearAllCache()
- securityManager.clearAllData()
- peerManager.clearAllPeers()
- peerManager.clearAllFingerprints()
- try { gossipSyncManager.clear() } catch (_: Exception) { }
- } catch (e: Exception) {
- Log.e(TAG, "Error clearing mesh service internal data: ${e.message}")
+ val operations = listOf<() -> Unit>(
+ ::stopServices,
+ fragmentManager::clearAllFragments,
+ storeForwardManager::clearAllCache,
+ securityManager::clearAllData,
+ peerManager::clearAllPeers,
+ peerManager::clearAllFingerprints,
+ courierStore::wipe,
+ { boardStore.wipe() },
+ bridgeCourierService::stop,
+ gossipSyncManager::clear
+ )
+ var failure: Exception? = null
+ operations.forEach { operation ->
+ try { operation() } catch (error: Exception) { failure = error }
}
+ failure?.let { throw IllegalStateException("Mesh data wipe incomplete", it) }
}
/**
diff --git a/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt b/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt
index 9ff9856d..a8fb804c 100644
--- a/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/BluetoothPacketBroadcaster.kt
@@ -22,6 +22,7 @@ import kotlinx.coroutines.cancel
import kotlinx.coroutines.delay
import kotlinx.coroutines.isActive
import kotlinx.coroutines.launch
+import kotlinx.coroutines.withTimeoutOrNull
import kotlinx.coroutines.channels.actor
import java.util.ArrayDeque
@@ -55,6 +56,7 @@ class BluetoothPacketBroadcaster(
private const val MAX_PENDING_BYTES_PER_LINK = 1_048_576
private const val SEND_RETRY_DELAY_MS = 15L
private const val MAX_CALLBACK_RETRIES = 3
+ private const val SEND_COMPLETION_TIMEOUT_MS = 30_000L
}
// Optional nickname resolver injected by higher layer (peerID -> nickname?)
@@ -140,6 +142,7 @@ class BluetoothPacketBroadcaster(
val gatt: BluetoothGatt? = null,
val gattServer: BluetoothGattServer? = null,
val characteristic: BluetoothGattCharacteristic,
+ val completion: CompletableDeferred? = null,
var callbackFailures: Int = 0
)
@@ -204,6 +207,30 @@ class BluetoothPacketBroadcaster(
}
}
+ suspend fun sendPacketToPeerAndAwaitAcceptance(
+ routed: RoutedPacket,
+ targetPeerID: String,
+ gattServer: BluetoothGattServer?,
+ characteristic: BluetoothGattCharacteristic?
+ ): Boolean {
+ if (!hasPeerConnection(targetPeerID)) return false
+ return fragmentingSender.sendAndAwaitAcceptance(routed, "BLE peer ${targetPeerID.take(8)}") { packet ->
+ sendSinglePacketToPeer(packet, targetPeerID, gattServer, characteristic)
+ }
+ }
+
+ suspend fun sendPacketToPeerAndAwaitCompletion(
+ routed: RoutedPacket,
+ targetPeerID: String,
+ gattServer: BluetoothGattServer?,
+ characteristic: BluetoothGattCharacteristic?
+ ): Boolean {
+ if (!hasPeerConnection(targetPeerID)) return false
+ return fragmentingSender.sendAndAwaitAcceptance(routed, "BLE peer ${targetPeerID.take(8)}") { packet ->
+ sendSinglePacketToPeerAndAwaitCompletion(packet, targetPeerID, gattServer, characteristic)
+ }
+ }
+
fun sendPacketToLink(
routed: RoutedPacket,
deviceAddress: String,
@@ -267,6 +294,35 @@ class BluetoothPacketBroadcaster(
return false
}
+ private suspend fun sendSinglePacketToPeerAndAwaitCompletion(
+ routed: RoutedPacket,
+ targetPeerID: String,
+ gattServer: BluetoothGattServer?,
+ characteristic: BluetoothGattCharacteristic?
+ ): Boolean {
+ val packet = routed.packet
+ val data = packet.toBinaryData(
+ padding = BLEPacketPaddingPolicy.shouldPadForBLE(packet.type)
+ ) ?: return false
+ val completion = CompletableDeferred()
+
+ val serverTarget = connectionTracker.getSubscribedDevices()
+ .firstOrNull { connectionTracker.addressPeerMap[it.address] == targetPeerID }
+ val queuedOnServer = serverTarget != null &&
+ notifyDevice(serverTarget, data, gattServer, characteristic, completion)
+ val queued = if (queuedOnServer) {
+ true
+ } else {
+ val clientTarget = connectionTracker.getConnectedDevices().values
+ .firstOrNull { connectionTracker.addressPeerMap[it.device.address] == targetPeerID }
+ ?: return false
+ writeToDeviceConn(clientTarget, data, completion)
+ }
+ if (!queued) return false
+
+ return withTimeoutOrNull(SEND_COMPLETION_TIMEOUT_MS) { completion.await() } ?: false
+ }
+
/**
* Public entry point for broadcasting - submits request to actor for serialization
@@ -474,7 +530,8 @@ class BluetoothPacketBroadcaster(
device: BluetoothDevice,
data: ByteArray,
gattServer: BluetoothGattServer?,
- characteristic: BluetoothGattCharacteristic?
+ characteristic: BluetoothGattCharacteristic?,
+ completion: CompletableDeferred? = null
): Boolean {
val server = gattServer ?: return false
val char = characteristic ?: return false
@@ -484,7 +541,13 @@ class BluetoothPacketBroadcaster(
?: return false
return enqueueSend(
SendKey(device.address, linkID, SendDirection.SERVER_NOTIFICATION),
- PendingSend(data.copyOf(), device, gattServer = server, characteristic = char)
+ PendingSend(
+ data.copyOf(),
+ device,
+ gattServer = server,
+ characteristic = char,
+ completion = completion
+ )
)
}
@@ -493,13 +556,20 @@ class BluetoothPacketBroadcaster(
*/
private fun writeToDeviceConn(
deviceConn: BluetoothConnectionTracker.DeviceConnection,
- data: ByteArray
+ data: ByteArray,
+ completion: CompletableDeferred? = null
): Boolean {
val gatt = deviceConn.gatt ?: return false
val char = deviceConn.characteristic ?: return false
return enqueueSend(
SendKey(deviceConn.device.address, deviceConn.linkID, SendDirection.CLIENT_WRITE),
- PendingSend(data.copyOf(), deviceConn.device, gatt = gatt, characteristic = char)
+ PendingSend(
+ data.copyOf(),
+ deviceConn.device,
+ gatt = gatt,
+ characteristic = char,
+ completion = completion
+ )
)
}
@@ -631,6 +701,7 @@ class BluetoothPacketBroadcaster(
}
state.pending.removeFirst()
state.pendingBytes -= head.data.size
+ head.completion?.complete(status == BluetoothGatt.GATT_SUCCESS)
if (state.pending.isEmpty()) {
sendStates.remove(key)
false
@@ -645,8 +716,13 @@ class BluetoothPacketBroadcaster(
fun onLinkDisconnected(deviceAddress: String, linkID: String?) {
synchronized(sendLock) {
- sendStates.keys.removeAll { key ->
- key.deviceAddress == deviceAddress && (linkID == null || key.linkID == linkID)
+ val iterator = sendStates.entries.iterator()
+ while (iterator.hasNext()) {
+ val (key, state) = iterator.next()
+ if (key.deviceAddress == deviceAddress && (linkID == null || key.linkID == linkID)) {
+ state.pending.forEach { it.completion?.complete(false) }
+ iterator.remove()
+ }
}
}
}
@@ -667,7 +743,12 @@ class BluetoothPacketBroadcaster(
* Shutdown the broadcaster actor gracefully
*/
fun shutdown() {
- synchronized(sendLock) { sendStates.clear() }
+ synchronized(sendLock) {
+ sendStates.values.forEach { state ->
+ state.pending.forEach { it.completion?.complete(false) }
+ }
+ sendStates.clear()
+ }
// Close the actor gracefully
broadcasterActor.close()
diff --git a/app/src/main/java/com/bitchat/android/mesh/BridgeMeshPort.kt b/app/src/main/java/com/bitchat/android/mesh/BridgeMeshPort.kt
new file mode 100644
index 00000000..f803aeef
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/mesh/BridgeMeshPort.kt
@@ -0,0 +1,98 @@
+package com.bitchat.android.mesh
+
+import com.bitchat.android.model.IdentityAnnouncement
+import com.bitchat.android.protocol.BitchatPacket
+
+/**
+ * Immutable privacy decision captured when a public message is accepted.
+ *
+ * A later opt-in must not authorize a message that was composed while
+ * bridging was disabled or nearby-only. Publication therefore requires both
+ * this send-time decision and the current policy to allow bridging.
+ */
+class BridgeOutboundPolicy internal constructor(
+ internal val enabled: Boolean,
+ internal val nearbyOnly: Boolean
+) {
+ val allowsBridging: Boolean
+ get() = enabled && !nearbyOnly
+
+ fun permitsPublication(current: BridgeOutboundPolicy): Boolean =
+ allowsBridging && current.allowsBridging
+
+ companion object {
+ val Denied = BridgeOutboundPolicy(enabled = false, nearbyOnly = false)
+
+ internal fun capture(enabled: Boolean, nearbyOnly: Boolean): BridgeOutboundPolicy =
+ BridgeOutboundPolicy(enabled = enabled, nearbyOnly = nearbyOnly)
+ }
+}
+
+/**
+ * Transport-facing bridge boundary.
+ *
+ * BLE/Wi-Fi packet code depends only on this protocol surface; application
+ * bootstrap installs the process bridge controller. Tests can install a fake
+ * without constructing relay or persistence infrastructure.
+ */
+interface BridgeMeshDelegate {
+ fun advertisedCell(): String?
+ fun outboundPolicy(): BridgeOutboundPolicy
+
+ fun bridgeOutgoing(
+ content: String,
+ senderPeerId: String,
+ timestampMs: Long,
+ nickname: String?,
+ policyAtSend: BridgeOutboundPolicy
+ )
+
+ fun handleAuthenticatedRadioMessage(messageId: String)
+ fun handleVerifiedAnnouncement(peerId: String, announcement: IdentityAnnouncement)
+ fun handlePrekeyPacket(packet: BitchatPacket)
+ fun handleCarrier(payload: ByteArray, fromPeerId: String, directedToUs: Boolean)
+}
+
+object BridgeMeshPort : BridgeMeshDelegate {
+ @Volatile
+ private var delegate: BridgeMeshDelegate? = null
+
+ fun install(delegate: BridgeMeshDelegate) {
+ this.delegate = delegate
+ }
+
+ override fun advertisedCell(): String? = delegate?.advertisedCell()
+
+ override fun outboundPolicy(): BridgeOutboundPolicy =
+ delegate?.outboundPolicy() ?: BridgeOutboundPolicy.Denied
+
+ override fun bridgeOutgoing(
+ content: String,
+ senderPeerId: String,
+ timestampMs: Long,
+ nickname: String?,
+ policyAtSend: BridgeOutboundPolicy
+ ) {
+ delegate?.bridgeOutgoing(content, senderPeerId, timestampMs, nickname, policyAtSend)
+ }
+
+ override fun handleAuthenticatedRadioMessage(messageId: String) {
+ delegate?.handleAuthenticatedRadioMessage(messageId)
+ }
+
+ override fun handleVerifiedAnnouncement(
+ peerId: String,
+ announcement: IdentityAnnouncement
+ ) {
+ delegate?.handleVerifiedAnnouncement(peerId, announcement)
+ }
+
+ override fun handlePrekeyPacket(packet: BitchatPacket) {
+ delegate?.handlePrekeyPacket(packet)
+ }
+
+ override fun handleCarrier(payload: ByteArray, fromPeerId: String, directedToUs: Boolean) {
+ delegate?.handleCarrier(payload, fromPeerId, directedToUs)
+ }
+
+}
diff --git a/app/src/main/java/com/bitchat/android/mesh/CourierStore.kt b/app/src/main/java/com/bitchat/android/mesh/CourierStore.kt
new file mode 100644
index 00000000..d15d40ed
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/mesh/CourierStore.kt
@@ -0,0 +1,241 @@
+package com.bitchat.android.mesh
+
+import android.content.Context
+import com.bitchat.android.model.CourierEnvelope
+import com.bitchat.android.services.AndroidConversationStorageCipher
+import com.bitchat.android.services.ConversationStorageCipher
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import java.io.File
+import java.util.Base64
+import java.nio.file.StandardCopyOption
+
+enum class CourierDepositTier { FAVORITE, VERIFIED }
+
+/** Bounded persistent mailbag for opaque envelopes deposited by other peers. */
+internal class CourierStore(
+ context: Context,
+ private val cipher: ConversationStorageCipher = AndroidConversationStorageCipher(KEY_ALIAS),
+ private val now: () -> Long = System::currentTimeMillis
+) {
+ private data class Stored(
+ val encoded: String,
+ val depositorKey: String,
+ val tier: CourierDepositTier,
+ var copies: Int,
+ val sprayedTo: MutableSet = mutableSetOf(),
+ var lastRemoteHandoverAtMs: Long = 0
+ )
+
+ private data class SprayReservation(
+ val envelopeKey: String,
+ val courierKey: String,
+ val copies: Int
+ )
+
+ companion object {
+ private const val KEY_ALIAS = "bitchat_courier_store_v1"
+ private val AAD = "bitchat-courier-store-v1".toByteArray(Charsets.UTF_8)
+ private const val MAX_ENVELOPES = 40
+ private const val MAX_VERIFIED_ENVELOPES = 20
+ private const val MAX_PER_FAVORITE = 5
+ private const val MAX_PER_VERIFIED = 2
+ private const val EXPIRY_SLACK_MS = 60 * 60 * 1000L
+ private const val REMOTE_HANDOVER_COOLDOWN_MS = 10 * 60 * 1000L
+ }
+
+ private val gson = Gson()
+ private val file = File(context.applicationContext.filesDir, "courier-store.sealed")
+ private val stored = load()
+ private val sprayReservations = mutableListOf()
+
+ @Synchronized
+ fun deposit(envelope: CourierEnvelope, depositorNoiseKey: ByteArray, tier: CourierDepositTier): Boolean {
+ pruneExpired()
+ val nowMs = now()
+ if (envelope.expiry.toLong() <= nowMs ||
+ envelope.expiry.toLong() > nowMs + CourierEnvelope.MAX_LIFETIME_MS + EXPIRY_SLACK_MS
+ ) return false
+ val encodedBytes = envelope.encode() ?: return false
+ val encoded = Base64.getEncoder().encodeToString(encodedBytes)
+ if (stored.any { it.envelope()?.ciphertext?.contentEquals(envelope.ciphertext) == true }) return true
+ val depositor = depositorNoiseKey.toHex()
+ val perDepositor = if (tier == CourierDepositTier.FAVORITE) MAX_PER_FAVORITE else MAX_PER_VERIFIED
+ if (stored.count { it.depositorKey == depositor && it.tier == tier } >= perDepositor) return false
+ if (tier == CourierDepositTier.VERIFIED && stored.count { it.tier == tier } >= MAX_VERIFIED_ENVELOPES) {
+ stored.removeAt(stored.indexOfFirst { it.tier == CourierDepositTier.VERIFIED })
+ }
+ if (stored.size >= MAX_ENVELOPES) {
+ val verifiedIndex = stored.indexOfFirst { it.tier == CourierDepositTier.VERIFIED }
+ if (tier == CourierDepositTier.VERIFIED && verifiedIndex < 0) return false
+ val index = verifiedIndex.takeIf { it >= 0 } ?: 0
+ stored.removeAt(index)
+ }
+ stored += Stored(encoded, depositor, tier, envelope.copies.toInt())
+ persist()
+ return true
+ }
+
+ @Synchronized
+ fun copiesForRecipient(recipientNoiseKey: ByteArray): List {
+ pruneExpired()
+ val nowMs = now()
+ return stored.mapNotNull { record ->
+ record.envelope()
+ ?.takeIf { it.matchesRecipient(recipientNoiseKey, nowMs) }
+ ?.copy(copies = 1u)
+ }
+ }
+
+ @Synchronized
+ fun remove(envelope: CourierEnvelope): Boolean {
+ val envelopeKey = envelope.ciphertext.storageKey()
+ val removed = stored.removeAll {
+ it.envelope()?.ciphertext?.contentEquals(envelope.ciphertext) == true
+ }
+ if (removed) {
+ sprayReservations.removeAll { it.envelopeKey == envelopeKey }
+ persist()
+ }
+ return removed
+ }
+
+ @Synchronized
+ fun copiesForRemoteHandover(recipientNoiseKey: ByteArray): List {
+ pruneExpired()
+ val nowMs = now()
+ val result = mutableListOf()
+ stored.forEach { record ->
+ val envelope = record.envelope() ?: return@forEach
+ if (envelope.matchesRecipient(recipientNoiseKey, nowMs) &&
+ nowMs - record.lastRemoteHandoverAtMs >= REMOTE_HANDOVER_COOLDOWN_MS
+ ) {
+ record.lastRemoteHandoverAtMs = nowMs
+ result += envelope.copy(copies = 1u)
+ }
+ }
+ if (result.isNotEmpty()) persist()
+ return result
+ }
+
+ @Synchronized
+ fun sprayCopiesFor(courierNoiseKey: ByteArray): List {
+ pruneExpired()
+ val key = courierNoiseKey.toHex()
+ val nowMs = now()
+ val courierTags = listOf(-1, 0, 1).map {
+ CourierEnvelope.recipientTag(courierNoiseKey, CourierEnvelope.epochDay(nowMs) + it.toUInt())
+ }
+ val result = mutableListOf()
+ stored.forEach { record ->
+ val envelope = record.envelope() ?: return@forEach
+ val envelopeKey = envelope.ciphertext.storageKey()
+ if (record.copies <= 1 || record.depositorKey == key || key in record.sprayedTo ||
+ sprayReservations.any { it.envelopeKey == envelopeKey && it.courierKey == key } ||
+ courierTags.any { it.contentEquals(envelope.recipientTag) }
+ ) return@forEach
+ val reserved = sprayReservations
+ .filter { it.envelopeKey == envelopeKey }
+ .sumOf { it.copies }
+ val available = record.copies - reserved
+ if (available <= 1) return@forEach
+ val given = available / 2
+ sprayReservations += SprayReservation(envelopeKey, key, given)
+ result += envelope.copy(copies = given.toUByte())
+ }
+ return result
+ }
+
+ @Synchronized
+ fun commitSpray(envelope: CourierEnvelope, courierNoiseKey: ByteArray): Boolean {
+ val key = courierNoiseKey.toHex()
+ val envelopeKey = envelope.ciphertext.storageKey()
+ val reservationIndex = sprayReservations.indexOfFirst {
+ it.envelopeKey == envelopeKey && it.courierKey == key && it.copies == envelope.copies.toInt()
+ }
+ if (reservationIndex < 0) return false
+ val reservation = sprayReservations[reservationIndex]
+ val record = stored.firstOrNull {
+ it.envelope()?.ciphertext?.contentEquals(envelope.ciphertext) == true
+ }
+ val otherReservedCopies = sprayReservations.withIndex()
+ .filter { (index, candidate) -> index != reservationIndex && candidate.envelopeKey == envelopeKey }
+ .sumOf { it.value.copies }
+ if (record == null || key in record.sprayedTo ||
+ record.copies - otherReservedCopies <= reservation.copies
+ ) {
+ sprayReservations.removeAt(reservationIndex)
+ return false
+ }
+ record.copies -= reservation.copies
+ record.sprayedTo += key
+ sprayReservations.removeAt(reservationIndex)
+ persist()
+ return true
+ }
+
+ @Synchronized
+ fun cancelSpray(envelope: CourierEnvelope, courierNoiseKey: ByteArray): Boolean {
+ val envelopeKey = envelope.ciphertext.storageKey()
+ val courierKey = courierNoiseKey.toHex()
+ return sprayReservations.removeAll {
+ it.envelopeKey == envelopeKey && it.courierKey == courierKey && it.copies == envelope.copies.toInt()
+ }
+ }
+
+ @Synchronized
+ fun wipe() {
+ stored.clear()
+ sprayReservations.clear()
+ file.delete()
+ cipher.destroyKey()
+ }
+
+ private fun pruneExpired() {
+ val nowMs = now().toULong()
+ if (stored.removeAll { (it.envelope()?.expiry ?: 0u) <= nowMs }) {
+ val retainedEnvelopeKeys = stored.mapNotNull { it.envelope()?.ciphertext?.storageKey() }.toSet()
+ sprayReservations.removeAll { it.envelopeKey !in retainedEnvelopeKeys }
+ persist()
+ }
+ }
+
+ private fun Stored.envelope(): CourierEnvelope? = try {
+ CourierEnvelope.decode(Base64.getDecoder().decode(encoded))
+ } catch (_: Exception) { null }
+
+ private fun load(): MutableList = try {
+ if (!file.exists()) return mutableListOf()
+ val plaintext = cipher.decrypt(file.readBytes(), AAD)
+ val type = object : TypeToken>() {}.type
+ gson.fromJson>(plaintext.toString(Charsets.UTF_8), type) ?: mutableListOf()
+ } catch (_: Exception) { mutableListOf() }
+
+ private fun persist() {
+ if (stored.isEmpty()) {
+ file.delete()
+ return
+ }
+ val encrypted = cipher.encrypt(gson.toJson(stored).toByteArray(Charsets.UTF_8), AAD)
+ val temporary = File(file.parentFile, "${file.name}.tmp")
+ temporary.writeBytes(encrypted)
+ try {
+ java.nio.file.Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.ATOMIC_MOVE,
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ } catch (_: Exception) {
+ java.nio.file.Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ }
+ }
+
+ private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+
+ private fun ByteArray.storageKey(): String = Base64.getEncoder().encodeToString(this)
+}
diff --git a/app/src/main/java/com/bitchat/android/mesh/DirectCourierDepositPolicy.kt b/app/src/main/java/com/bitchat/android/mesh/DirectCourierDepositPolicy.kt
new file mode 100644
index 00000000..188872b9
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/mesh/DirectCourierDepositPolicy.kt
@@ -0,0 +1,20 @@
+package com.bitchat.android.mesh
+
+import com.bitchat.android.model.RoutedPacket
+
+/** Accepts courier custody only from the authenticated peer on the current direct link. */
+internal object DirectCourierDepositPolicy {
+ fun accepts(
+ routed: RoutedPacket,
+ maxTtl: UByte,
+ currentLinkID: (String) -> String?,
+ peerForAddress: (String) -> String?
+ ): Boolean {
+ val peerID = routed.peerID ?: return false
+ val relayAddress = routed.relayAddress ?: return false
+ val ingressLinkID = routed.ingressLinkID ?: return false
+ return routed.packet.ttl == maxTtl &&
+ currentLinkID(relayAddress) == ingressLinkID &&
+ peerForAddress(relayAddress) == peerID
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/mesh/FragmentingPacketSender.kt b/app/src/main/java/com/bitchat/android/mesh/FragmentingPacketSender.kt
index 9c6bd15e..adac55c2 100644
--- a/app/src/main/java/com/bitchat/android/mesh/FragmentingPacketSender.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/FragmentingPacketSender.kt
@@ -112,6 +112,23 @@ class FragmentingPacketSender(
return true
}
+ suspend fun sendAndAwaitAcceptance(
+ routed: RoutedPacket,
+ description: String,
+ sendSingle: suspend (RoutedPacket) -> Boolean
+ ): Boolean {
+ val packets = packetsForTransport(routed) ?: return false
+ Log.d(logTag, "Sending ${packets.size} packet(s) for $description")
+ for ((index, packet) in packets.withIndex()) {
+ val accepted = sendSingle(
+ routed.copy(packet = packet, transferId = null, preparedPackets = null)
+ )
+ if (!accepted) return false
+ if (index < packets.lastIndex) delay(interFragmentDelayMs)
+ }
+ return true
+ }
+
fun cancelTransfer(transferId: String): Boolean {
val job = transferJobs.remove(transferId) ?: return false
job.cancel()
diff --git a/app/src/main/java/com/bitchat/android/mesh/GroupMessagePort.kt b/app/src/main/java/com/bitchat/android/mesh/GroupMessagePort.kt
new file mode 100644
index 00000000..2ce93a20
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/mesh/GroupMessagePort.kt
@@ -0,0 +1,13 @@
+package com.bitchat.android.mesh
+
+/** Process-level group ingress, independent of Activity and transport lifetimes. */
+interface GroupMessageReceiver {
+ fun invite(peerID: String, authenticatedKey: ByteArray, payload: ByteArray)
+ fun keyUpdate(peerID: String, authenticatedKey: ByteArray, payload: ByteArray)
+ fun message(payload: ByteArray, timestampMs: Long)
+ fun peerAuthenticated(peerID: String)
+}
+
+object GroupMessagePort {
+ @Volatile var receiver: GroupMessageReceiver? = null
+}
diff --git a/app/src/main/java/com/bitchat/android/mesh/MeshCore.kt b/app/src/main/java/com/bitchat/android/mesh/MeshCore.kt
index 28cd3d02..d4a934ff 100644
--- a/app/src/main/java/com/bitchat/android/mesh/MeshCore.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/MeshCore.kt
@@ -2,6 +2,7 @@ package com.bitchat.android.mesh
import android.content.Context
import android.util.Log
+import com.bitchat.android.board.transportSenderID
import com.bitchat.android.crypto.EncryptionService
import com.bitchat.android.model.BitchatMessage
import com.bitchat.android.model.BitchatFilePacket
@@ -16,7 +17,9 @@ import com.bitchat.android.model.RoutedPacket
import com.bitchat.android.protocol.BitchatPacket
import com.bitchat.android.protocol.MessageType
import com.bitchat.android.protocol.SpecialRecipients
+import com.bitchat.android.identity.SecureIdentityStateManager
import com.bitchat.android.service.TransportBridgeService
+import com.bitchat.android.services.bridge.BridgeProtocolPacketFactory
import com.bitchat.android.sync.GossipSyncManager
import com.bitchat.android.util.toHexString
import kotlinx.coroutines.CoroutineScope
@@ -47,6 +50,7 @@ class MeshCore(
* Return false to suppress all downstream effects for a rejected message.
*/
val onMessageReceived: ((BitchatMessage) -> Boolean)? = null,
+ val onDeliveryReceipt: ((String, String) -> Unit)? = null,
val onAnnounceProcessed: ((RoutedPacket, Boolean) -> Unit)? = null,
val readReceiptInterceptor: ((String, String) -> Boolean)? = null,
val onReadReceiptSent: ((String) -> Unit)? = null,
@@ -55,6 +59,7 @@ class MeshCore(
)
private val peerManager = PeerManager()
+ private val identityState = SecureIdentityStateManager(context.applicationContext)
val fragmentManager = FragmentManager()
private val readReceiptRetrySender = RetryingControlPacketSender(scope)
private val authenticatedPeerStateStore = SecureAuthenticatedPeerStateStore(context)
@@ -66,13 +71,14 @@ class MeshCore(
store = authenticatedPeerStateStore,
localStateProvider = {
AuthenticatedPeerState(
- PeerCapabilities.LOCAL_SUPPORTED,
+ PeerCapabilities.localSupported(),
requireNotNull(encryptionService.getSigningPublicKey())
)
},
applyAuthenticatedState = peerManager::applyAuthenticatedPeerState,
sendState = ::sendAuthenticatedPeerState,
- onResolution = { peerID -> delegate?.didResolvePrivateMediaPolicy(peerID) }
+ onResolution = { peerID -> GroupMessagePort.receiver?.peerAuthenticated(peerID)
+ delegate?.didResolvePrivateMediaPolicy(peerID) }
)
}
private val privateMediaSecurity by lazy { PrivateMediaSecurityController(
@@ -110,11 +116,27 @@ class MeshCore(
}
private val securityManager = SecurityManager(encryptionService, myPeerID)
private val storeForwardManager = StoreForwardManager()
+ private val boardStore = com.bitchat.android.board.BoardStore.getInstance(context)
private val messageHandler = MessageHandler(myPeerID, context.applicationContext)
private val packetProcessor = PacketProcessor(myPeerID)
private data class VoiceFrameRequest(val recipientPeerID: String?, val payload: ByteArray)
private val voiceFrameQueue = Channel(capacity = 128)
private val directPeers = ConcurrentHashMap.newKeySet()
+ private val vouchCoordinator by lazy {
+ VouchCoordinator(
+ scope = scope,
+ identity = identityState,
+ connectedPeerIDs = peerManager::getActivePeerIDs,
+ fingerprintForPeer = peerManager::getFingerprintForPeer,
+ peerInfo = peerManager::getPeerInfo,
+ signingKeyForFingerprint = ::signingKeyForFingerprint,
+ hasEstablishedSession = encryptionService::hasEstablishedSession,
+ sign = encryptionService::signData,
+ verify = encryptionService::verifyEd25519Signature,
+ send = ::sendVouchPayload
+ )
+ }
+ private val meshPingManager = MeshPingManager(myPeerID, scope, ::dispatchUnsignedDiagnostic)
val gossipSyncManager: GossipSyncManager =
sharedGossipManager ?: GossipSyncManager(myPeerID = myPeerID, scope = scope, configProvider = gossipConfigProvider)
@@ -129,6 +151,7 @@ class MeshCore(
for (request in voiceFrameQueue) dispatchVoiceFrame(request)
}
messageHandler.packetProcessor = packetProcessor
+ gossipSyncManager.boardPacketsProvider = boardStore::syncCandidates
peerManager.isPeerDirectlyConnected = { peerID -> directPeers.contains(peerID) }
setupDelegates()
@@ -217,6 +240,7 @@ class MeshCore(
peerManager.delegate = object : PeerManagerDelegate {
override fun onPeerListUpdated(peerIDs: List) {
try { com.bitchat.android.services.AppStateStore.setTransportPeers(transport.id, peerIDs) } catch (_: Exception) { }
+ vouchCoordinator.peersUpdated(peerIDs)
delegate?.didUpdatePeerList(peerIDs)
}
@@ -242,6 +266,10 @@ class MeshCore(
authenticatedRemoteStaticKey,
authenticatedSessionToken
)
+ vouchCoordinator.peerAuthenticated(
+ peerID,
+ identityState.generateFingerprint(authenticatedRemoteStaticKey)
+ )
scope.launch {
delay(100)
sendAnnouncementToPeer(peerID)
@@ -411,6 +439,7 @@ class MeshCore(
}
override fun onDeliveryAckReceived(messageID: String, peerID: String) {
+ hooks.onDeliveryReceipt?.invoke(messageID, peerID)
try {
com.bitchat.android.services.AppStateStore.updatePrivateMessageStatus(
messageID,
@@ -421,6 +450,7 @@ class MeshCore(
}
override fun onReadReceiptReceived(messageID: String, peerID: String) {
+ hooks.onDeliveryReceipt?.invoke(messageID, peerID)
try {
com.bitchat.android.services.AppStateStore.updatePrivateMessageStatus(
messageID,
@@ -437,6 +467,30 @@ class MeshCore(
override fun onVerifyResponseReceived(peerID: String, payload: ByteArray, timestampMs: Long) {
delegate?.didReceiveVerifyResponse(peerID, payload, timestampMs)
}
+
+ override fun onGroupInviteReceived(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ GroupMessagePort.receiver?.invite(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun onGroupKeyUpdateReceived(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ GroupMessagePort.receiver?.keyUpdate(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun onGroupMessageReceived(payload: ByteArray, timestampMs: Long) {
+ GroupMessagePort.receiver?.message(payload, timestampMs)
+ }
+
+ override fun onVouchPayloadReceived(peerID: String, payload: ByteArray) {
+ vouchCoordinator.handlePayload(peerID, payload)
+ }
}
packetProcessor.delegate = object : PacketProcessorDelegate {
@@ -460,6 +514,9 @@ class MeshCore(
return SpecialRecipients.BROADCAST
}
+ override fun isPeerDirectlyConnected(peerID: String): Boolean =
+ peerManager.getPeerInfo(peerID)?.isDirectConnection == true
+
override fun handleNoiseHandshake(routed: RoutedPacket): Boolean {
return runBlocking { securityManager.handleNoiseHandshake(routed) }
}
@@ -468,6 +525,8 @@ class MeshCore(
return runBlocking { messageHandler.handleNoiseEncrypted(routed) }
}
+ override fun handleCourierEnvelope(routed: RoutedPacket): Boolean = false
+
override suspend fun handleAnnounce(routed: RoutedPacket): Boolean {
val result = messageHandler.handleAnnounceWithResult(routed)
if (result !is AnnounceHandlingResult.Accepted) return false
@@ -481,7 +540,7 @@ class MeshCore(
try {
val pkt = routed.packet
val isBroadcast = (pkt.recipientID == null || pkt.recipientID.contentEquals(SpecialRecipients.BROADCAST))
- if (isBroadcast && pkt.type == MessageType.MESSAGE.value) {
+ if (isBroadcast && pkt.type in setOf(MessageType.MESSAGE.value, MessageType.FILE_TRANSFER.value)) {
gossipSyncManager.onPublicPacketSeen(pkt)
}
} catch (_: Exception) { }
@@ -489,6 +548,10 @@ class MeshCore(
override fun handleVoiceFrame(routed: RoutedPacket): Boolean =
messageHandler.handlePublicVoiceFrame(routed)
+ override fun handleGroupMessage(routed: RoutedPacket) {
+ messageHandler.handleGroupMessage(routed)
+ try { gossipSyncManager.onPublicPacketSeen(routed.packet) } catch (_: Exception) { }
+ }
override fun handleLeave(routed: RoutedPacket) {
scope.launch { messageHandler.handleLeave(routed) }
@@ -527,11 +590,29 @@ class MeshCore(
val req = RequestSyncPacket.decode(routed.packet.payload) ?: return
gossipSyncManager.handleRequestSync(fromPeer, req)
}
+
+ override fun handleBoardPost(routed: RoutedPacket): Boolean {
+ val wire = com.bitchat.android.board.BoardWireCodec.decode(routed.packet.payload)
+ ?: return false
+ return boardStore.ingestRemoteForRelay(wire, routed.packet)
+ }
+ override fun handlePing(routed: RoutedPacket) = meshPingManager.handlePing(routed)
+
+ override fun handlePong(routed: RoutedPacket) = meshPingManager.handlePong(routed)
}
}
+ private fun dispatchUnsignedDiagnostic(packet: BitchatPacket) {
+ dispatchGlobal(RoutedPacket(packet))
+ }
+
+ fun sendMeshPing(peerID: String, callback: (MeshPingResult?) -> Unit) {
+ meshPingManager.ping(peerID, callback)
+ }
+
fun sendMessage(content: String, mentions: List = emptyList(), channel: String? = null) {
if (content.isEmpty()) return
+ val bridgePolicyAtSend = BridgeMeshPort.outboundPolicy()
scope.launch {
val packet = BitchatPacket(
version = 1u,
@@ -546,6 +627,97 @@ class MeshCore(
val signedPacket = signPacketBeforeBroadcast(packet)
dispatchGlobal(RoutedPacket(signedPacket))
try { gossipSyncManager.onPublicPacketSeen(signedPacket) } catch (_: Exception) { }
+ if (channel == null) {
+ val nickname = hooks.announcementNicknameProvider?.invoke()
+ ?: delegate?.getNickname()
+ BridgeMeshPort.bridgeOutgoing(
+ content,
+ myPeerID,
+ packet.timestamp.toLong(),
+ nickname,
+ bridgePolicyAtSend
+ )
+ }
+ }
+ }
+
+ fun sendNostrCarrier(payload: ByteArray, recipientPeerID: String? = null) {
+ sendRawProtocolPacket(
+ type = MessageType.NOSTR_CARRIER,
+ payload = payload,
+ recipientPeerID = recipientPeerID,
+ sign = true
+ )
+ }
+
+ fun sendCourierEnvelope(payload: ByteArray, recipientPeerID: String) {
+ sendRawProtocolPacket(
+ type = MessageType.COURIER_ENVELOPE,
+ payload = payload,
+ recipientPeerID = recipientPeerID,
+ sign = true
+ )
+ }
+
+ fun sendPrekeyBundle(payload: ByteArray) {
+ sendRawProtocolPacket(
+ type = MessageType.PREKEY_BUNDLE,
+ payload = payload,
+ recipientPeerID = null,
+ sign = true
+ )
+ }
+
+ private fun sendRawProtocolPacket(
+ type: MessageType,
+ payload: ByteArray,
+ recipientPeerID: String?,
+ sign: Boolean
+ ) {
+ if (payload.isEmpty()) return
+ scope.launch {
+ val packet = BridgeProtocolPacketFactory.protocolPacket(
+ type = type,
+ payload = payload,
+ senderPeerId = myPeerID,
+ recipientPeerId = recipientPeerID,
+ ttl = maxTtl
+ ) ?: return@launch
+ val outgoing = if (sign) signPacketBeforeBroadcast(packet) else packet
+ if (sign &&
+ type != MessageType.COURIER_ENVELOPE &&
+ outgoing.signature?.size != 64
+ ) {
+ return@launch
+ }
+ dispatchGlobal(RoutedPacket(outgoing))
+ }
+ }
+
+
+
+ fun sendBoardPayload(payload: ByteArray) {
+ val wire = com.bitchat.android.board.BoardWireCodec.decode(payload) ?: return
+ if (!wire.verifySignature()) return
+ scope.launch {
+ // The inner board signature is authoritative. A stable outer
+ // sender/signature would re-link otherwise isolated location scopes.
+ val packet = BitchatPacket(
+ version = 1u,
+ type = MessageType.BOARD_POST.value,
+ senderID = wire.transportSenderID(),
+ recipientID = null,
+ timestamp = System.currentTimeMillis().coerceAtLeast(0).toULong(),
+ payload = payload,
+ signature = null,
+ ttl = maxTtl
+ )
+ boardStore.ingest(
+ wire,
+ packet,
+ com.bitchat.android.board.BoardIngestSource.LOCAL
+ )
+ dispatchGlobal(RoutedPacket(packet))
}
}
@@ -575,6 +747,31 @@ class MeshCore(
return true
}
+ private fun signingKeyForFingerprint(fingerprint: String): ByteArray? {
+ identityState.getAuthenticatedSigningKey(fingerprint)?.let { return it }
+ return peerManager.getActivePeerIDs().firstNotNullOfOrNull { peerID ->
+ val peerFingerprint = peerManager.getFingerprintForPeer(peerID)
+ peerManager.getPeerInfo(peerID)?.signingPublicKey
+ ?.takeIf { peerFingerprint.equals(fingerprint, ignoreCase = true) }
+ }
+ }
+
+ private fun sendVouchPayload(peerID: String, payload: ByteArray): Boolean {
+ val plaintext = NoisePayload(NoisePayloadType.VOUCH, payload).encode()
+ val encrypted = securityManager.encryptForPeer(plaintext, peerID) ?: return false
+ val packet = BitchatPacket(
+ version = VouchCoordinator.NOISE_PACKET_VERSION,
+ type = MessageType.NOISE_ENCRYPTED.value,
+ senderID = MeshPacketUtils.hexStringToByteArray(myPeerID),
+ recipientID = MeshPacketUtils.hexStringToByteArray(peerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = encrypted,
+ ttl = maxTtl
+ )
+ dispatchGlobal(RoutedPacket(signPacketBeforeBroadcast(packet)))
+ return true
+ }
+
fun sendFileBroadcast(file: BitchatFilePacket) {
try {
val payload = file.encode() ?: return
@@ -658,6 +855,12 @@ class MeshCore(
}
}
+ fun supportsPrivateMediaReceipts(peerID: String): Boolean {
+ val session = encryptionService.getAuthenticatedSession(peerID) ?: return false
+ val proof = authenticatedPeerState.status(peerID, session) as? AuthenticatedPeerStateStatus.Proven ?: return false
+ return proof.state.capabilities.contains(com.bitchat.android.model.PeerCapabilities.PRIVATE_MEDIA_RECEIPTS)
+ }
+
fun prepareFilePrivate(
recipientPeerID: String,
file: BitchatFilePacket,
@@ -798,6 +1001,38 @@ class MeshCore(
sendNoisePayloadToPeer(payload, peerID)
}
+ fun sendGroupInvite(payload: ByteArray, recipientPeerID: String) {
+ sendNoisePayloadToPeer(
+ NoisePayload(NoisePayloadType.GROUP_INVITE, payload),
+ recipientPeerID
+ )
+ }
+
+ fun sendGroupKeyUpdate(payload: ByteArray, recipientPeerID: String) {
+ sendNoisePayloadToPeer(
+ NoisePayload(NoisePayloadType.GROUP_KEY_UPDATE, payload),
+ recipientPeerID
+ )
+ }
+
+ fun broadcastGroupMessage(payload: ByteArray) {
+ if (payload.isEmpty()) return
+ scope.launch {
+ val packet = BitchatPacket(
+ version = if (payload.size > 0xffff) 2u else 1u,
+ type = MessageType.GROUP_MESSAGE.value,
+ senderID = MeshPacketUtils.hexStringToByteArray(myPeerID),
+ recipientID = SpecialRecipients.BROADCAST,
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = payload,
+ signature = null,
+ ttl = maxTtl
+ )
+ dispatchGlobal(RoutedPacket(packet))
+ try { gossipSyncManager.onPublicPacketSeen(packet) } catch (_: Exception) { }
+ }
+ }
+
private fun sendNoisePayloadToPeer(payload: NoisePayload, recipientPeerID: String) {
scope.launch {
try {
@@ -832,7 +1067,11 @@ class MeshCore(
Log.e("MeshCore", "No signing public key available for announcement")
return@launch
}
- val announcement = IdentityAnnouncement.forLocalPeer(nickname, staticKey, signingKey)
+ val announcement = BridgeProtocolPacketFactory.identityAnnouncement(
+ nickname,
+ staticKey,
+ signingKey
+ )
val tlvPayload = buildAnnouncementPayload(announcement, nickname) ?: return@launch
val announcePacket = BitchatPacket(
type = MessageType.ANNOUNCE.value,
@@ -853,7 +1092,11 @@ class MeshCore(
?: myPeerID
val staticKey = encryptionService.getStaticPublicKey() ?: return
val signingKey = encryptionService.getSigningPublicKey() ?: return
- val announcement = IdentityAnnouncement.forLocalPeer(nickname, staticKey, signingKey)
+ val announcement = BridgeProtocolPacketFactory.identityAnnouncement(
+ nickname,
+ staticKey,
+ signingKey
+ )
val tlvPayload = buildAnnouncementPayload(announcement, nickname) ?: return
val packet = BitchatPacket(
type = MessageType.ANNOUNCE.value,
@@ -991,6 +1234,12 @@ class MeshCore(
fun getStaticNoisePublicKey(): ByteArray? = encryptionService.getStaticPublicKey()
+ fun getSigningPublicKey(): ByteArray? =
+ encryptionService.getSigningPublicKey()?.copyOf()
+
+ fun signData(data: ByteArray): ByteArray? =
+ encryptionService.signData(data)
+
fun shouldShowEncryptionIcon(peerID: String): Boolean = encryptionService.hasEstablishedSession(peerID)
fun getEncryptedPeers(): List = emptyList()
@@ -1035,6 +1284,7 @@ class MeshCore(
peerManager.clearAllPeers()
peerManager.clearAllFingerprints()
try { gossipSyncManager.clear() } catch (_: Exception) { }
+ boardStore.wipe()
}
fun clearAllEncryptionData() {
diff --git a/app/src/main/java/com/bitchat/android/mesh/MeshDelegate.kt b/app/src/main/java/com/bitchat/android/mesh/MeshDelegate.kt
index b54b1152..ebd3b74a 100644
--- a/app/src/main/java/com/bitchat/android/mesh/MeshDelegate.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/MeshDelegate.kt
@@ -13,6 +13,17 @@ interface MeshDelegate {
fun didReceiveReadReceipt(messageID: String, recipientPeerID: String)
fun didReceiveVerifyChallenge(peerID: String, payload: ByteArray, timestampMs: Long) {}
fun didReceiveVerifyResponse(peerID: String, payload: ByteArray, timestampMs: Long) {}
+ fun didReceiveGroupInvite(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {}
+ fun didReceiveGroupKeyUpdate(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {}
+ fun didReceiveGroupMessage(payload: ByteArray, timestampMs: Long) {}
/** Current Noise generation either proved peer state or exhausted its 5-second watchdog. */
fun didResolvePrivateMediaPolicy(peerID: String) {}
fun decryptChannelMessage(encryptedContent: ByteArray, channel: String): String?
diff --git a/app/src/main/java/com/bitchat/android/mesh/MeshPingManager.kt b/app/src/main/java/com/bitchat/android/mesh/MeshPingManager.kt
new file mode 100644
index 00000000..11e0a48f
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/mesh/MeshPingManager.kt
@@ -0,0 +1,111 @@
+package com.bitchat.android.mesh
+
+import com.bitchat.android.model.RoutedPacket
+import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.protocol.MeshDiagnosticsConstants
+import com.bitchat.android.protocol.MeshPingPayload
+import com.bitchat.android.protocol.MessageType
+import com.bitchat.android.util.toHexString
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import java.util.concurrent.ConcurrentHashMap
+
+data class MeshPingResult(val rttMillis: Long, val hopCount: Int)
+
+internal class MeshPingManager(
+ private val myPeerID: String,
+ private val scope: CoroutineScope,
+ private val send: (BitchatPacket) -> Unit,
+) {
+ companion object {
+ /**
+ * BLE and Wi-Fi Aware have separate manager instances, but a reply can return over either
+ * transport. Pending probes therefore live at process scope and are namespaced by the
+ * local identity.
+ */
+ private val pending = ConcurrentHashMap()
+ }
+
+ private data class Pending(
+ val peerID: String,
+ val startedNanos: Long,
+ val callback: (MeshPingResult?) -> Unit,
+ val timeout: Job,
+ )
+
+ private val inboundByLink = ConcurrentHashMap>()
+
+ fun ping(peerID: String, callback: (MeshPingResult?) -> Unit) {
+ if (pending.size >= 64) { callback(null); return }
+ val payload = MeshPingPayload.create(MeshDiagnosticsConstants.TTL)
+ val key = pendingKey(payload)
+ val timeout = scope.launch {
+ delay(MeshDiagnosticsConstants.TIMEOUT_MILLIS)
+ pending.remove(key)?.callback?.invoke(null)
+ }
+ pending[key] = Pending(peerID, System.nanoTime(), callback, timeout)
+ send(packet(MessageType.PING, peerID, payload))
+ }
+
+ fun handlePing(routed: RoutedPacket) {
+ val packet = routed.packet
+ val payload = MeshPingPayload.decode(packet.payload) ?: return
+ val sender = packet.senderID.toHexString()
+ val ingress = routed.ingressLinkID ?: routed.relayAddress ?: routed.peerID ?: return
+ if (!consumeInboundBudget(ingress)) return
+ send(packet(MessageType.PONG, sender, payload))
+ }
+
+ fun handlePong(routed: RoutedPacket) {
+ val payload = MeshPingPayload.decode(routed.packet.payload) ?: return
+ val key = pendingKey(payload)
+ val candidate = pending[key] ?: return
+ if (routed.packet.senderID.toHexString() != candidate.peerID) return
+ if (!pending.remove(key, candidate)) return
+ candidate.timeout.cancel()
+ val elapsed = (System.nanoTime() - candidate.startedNanos) / 1_000_000
+ candidate.callback(MeshPingResult(elapsed, payload.hopCount(routed.packet.ttl)))
+ }
+
+ private fun pendingKey(payload: MeshPingPayload): String =
+ "$myPeerID:${payload.nonce.toHexString()}"
+
+ private fun consumeInboundBudget(link: String): Boolean {
+ val now = System.currentTimeMillis()
+ synchronized(inboundByLink) {
+ inboundByLink.entries.removeAll { (_, times) ->
+ synchronized(times) {
+ times.lastOrNull()?.let { now - it >= MeshDiagnosticsConstants.INBOUND_RATE_WINDOW_MILLIS } != false
+ }
+ }
+ if (inboundByLink.size >= 256 && !inboundByLink.containsKey(link)) return false
+ inboundByLink.putIfAbsent(link, ArrayDeque())
+ }
+ val timestamps = inboundByLink[link] ?: return false
+ synchronized(timestamps) {
+ while (timestamps.firstOrNull()?.let {
+ now - it >= MeshDiagnosticsConstants.INBOUND_RATE_WINDOW_MILLIS
+ } == true
+ ) {
+ timestamps.removeFirst()
+ }
+ if (timestamps.size >= MeshDiagnosticsConstants.INBOUND_RATE_LIMIT) return false
+ timestamps.addLast(now)
+ return true
+ }
+ }
+
+ private fun packet(type: MessageType, recipientPeerID: String, payload: MeshPingPayload) =
+ BitchatPacket(
+ version = 1u,
+ type = type.value,
+ senderID = MeshPacketUtils.hexStringToByteArray(myPeerID),
+ recipientID = MeshPacketUtils.hexStringToByteArray(recipientPeerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = payload.encode(),
+ signature = null,
+ ttl = MeshDiagnosticsConstants.TTL,
+ )
+}
diff --git a/app/src/main/java/com/bitchat/android/mesh/MeshService.kt b/app/src/main/java/com/bitchat/android/mesh/MeshService.kt
index 7b357149..f7c1f32d 100644
--- a/app/src/main/java/com/bitchat/android/mesh/MeshService.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/MeshService.kt
@@ -13,15 +13,24 @@ interface MeshService {
fun stopServices()
fun sendMessage(content: String, mentions: List = emptyList(), channel: String? = null)
+ fun sendNostrCarrier(payload: ByteArray, recipientPeerID: String? = null)
+ fun sendCourierEnvelope(payload: ByteArray, recipientPeerID: String)
+ fun sendPrekeyBundle(payload: ByteArray)
fun sendPrivateMessage(content: String, recipientPeerID: String, recipientNickname: String, messageID: String? = null)
+ fun supportsPrivateMediaReceipts(peerID: String): Boolean = false
+
fun sendReadReceipt(messageID: String, recipientPeerID: String, readerNickname: String)
fun sendDeliveryAck(messageID: String, recipientPeerID: String) {}
fun sendFavoriteNotification(peerID: String, isFavorite: Boolean) {}
fun sendVerifyChallenge(peerID: String, noiseKeyHex: String, nonceA: ByteArray)
fun sendVerifyResponse(peerID: String, noiseKeyHex: String, nonceA: ByteArray)
+ fun sendGroupInvite(payload: ByteArray, recipientPeerID: String)
+ fun sendGroupKeyUpdate(payload: ByteArray, recipientPeerID: String)
+ fun broadcastGroupMessage(payload: ByteArray)
fun sendFileBroadcast(file: BitchatFilePacket)
fun sendFilePrivate(recipientPeerID: String, file: BitchatFilePacket)
fun sendVoiceFrame(recipientPeerID: String?, payload: ByteArray)
+ fun sendBoardPayload(payload: ByteArray) {}
fun prepareFilePrivate(
recipientPeerID: String,
file: BitchatFilePacket,
@@ -32,6 +41,7 @@ interface MeshService {
fun sendBroadcastAnnounce()
fun sendAnnouncementToPeer(peerID: String)
+ fun sendMeshPing(peerID: String, callback: (MeshPingResult?) -> Unit)
fun getPeerNicknames(): Map
fun getPeerRSSI(): Map
@@ -41,6 +51,19 @@ interface MeshService {
fun initiateNoiseHandshake(peerID: String)
fun getPeerFingerprint(peerID: String): String?
fun getPeerInfo(peerID: String): PeerInfo?
+ fun getPeerInfos(): List = getPeerNicknames().keys.mapNotNull(::getPeerInfo)
+ fun sendCourierMessage(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ courierPeerIDs: List
+ ): List = emptyList()
+ fun sendBridgeCourierMessage(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ onAccepted: () -> Unit = {}
+ ): Boolean = false
fun updatePeerInfo(
peerID: String,
nickname: String,
@@ -50,11 +73,14 @@ interface MeshService {
): Boolean
fun getIdentityFingerprint(): String
fun getStaticNoisePublicKey(): ByteArray?
+ fun getSigningPublicKey(): ByteArray?
+ fun signData(data: ByteArray): ByteArray?
fun shouldShowEncryptionIcon(peerID: String): Boolean
fun getEncryptedPeers(): List
fun getDeviceAddressForPeer(peerID: String): String?
fun getDeviceAddressToPeerMapping(): Map
+ fun getDirectBlePeerIDs(): Set = emptySet()
fun printDeviceAddressesForPeers(): String
fun getDebugStatus(): String
diff --git a/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt b/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt
index 9434fc6e..ba106282 100644
--- a/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt
@@ -9,6 +9,7 @@ import com.bitchat.android.model.RoutedPacket
import com.bitchat.android.protocol.BitchatPacket
import com.bitchat.android.protocol.MessageType
import com.bitchat.android.sync.PacketIdUtil
+import com.bitchat.android.nostr.MeshMessageIdentity
import com.bitchat.android.util.toHexString
import com.bitchat.android.features.voice.LiveVoiceManager
import com.bitchat.android.features.voice.LiveVoiceScope
@@ -118,7 +119,8 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
// Notify delegate
delegate?.onMessageReceived(message)
- // Send delivery ACK exactly like iOS
+ // An ACK means durable admission, including a previously deleted duplicate.
+ if (!com.bitchat.android.services.AppStateStore.hasPrivateTextReceipt(message)) return false
sendDeliveryAck(privateMessage.messageID, peerID)
}
}
@@ -128,7 +130,19 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
val file = com.bitchat.android.model.BitchatFilePacket.decode(noisePayload.data)
if (file != null) {
Log.d(TAG, "Encrypted file from $peerID: ${file.fileSize} bytes")
- val uniqueMsgId = java.util.UUID.randomUUID().toString().uppercase()
+ val stableID = com.bitchat.android.model.PrivateMediaMessageIdentity.stableID(peerID, myPeerID, file.fileName)
+ if (stableID != null) {
+ when (com.bitchat.android.services.AppStateStore.privateMediaReceiptState(stableID)) {
+ com.bitchat.android.services.PrivateMediaReceiptState.ACCEPTED,
+ com.bitchat.android.services.PrivateMediaReceiptState.TOMBSTONED -> {
+ sendDeliveryAck(stableID, peerID)
+ return true
+ }
+ com.bitchat.android.services.PrivateMediaReceiptState.UNAVAILABLE -> return false
+ com.bitchat.android.services.PrivateMediaReceiptState.ABSENT -> Unit
+ }
+ }
+ val uniqueMsgId = stableID ?: java.util.UUID.randomUUID().toString().uppercase()
val savedPath = com.bitchat.android.features.file.FileUtils.saveIncomingFile(appContext, file)
val message = BitchatMessage(
id = uniqueMsgId,
@@ -146,8 +160,18 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
delegate?.onMessageReceived(message)
}
- // Send delivery ACK with generated message ID
- sendDeliveryAck(uniqueMsgId, peerID)
+ if (stableID == null) {
+ sendDeliveryAck(uniqueMsgId, peerID)
+ } else {
+ val receipt = com.bitchat.android.services.AppStateStore.privateMediaReceiptState(stableID)
+ if (receipt == com.bitchat.android.services.PrivateMediaReceiptState.ACCEPTED ||
+ receipt == com.bitchat.android.services.PrivateMediaReceiptState.TOMBSTONED) {
+ sendDeliveryAck(stableID, peerID)
+ } else {
+ com.bitchat.android.features.file.FileUtils.deleteStoredMediaPaths(appContext, listOf(savedPath))
+ return false
+ }
+ }
} else {
Log.w(TAG, "Failed to decode encrypted file transfer from $peerID")
}
@@ -199,6 +223,23 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
com.bitchat.android.model.NoisePayloadType.VERIFY_RESPONSE -> {
delegate?.onVerifyResponseReceived(peerID, noisePayload.data, packet.timestamp.toLong())
}
+ com.bitchat.android.model.NoisePayloadType.GROUP_INVITE -> {
+ delegate?.onGroupInviteReceived(
+ peerID,
+ decryption.authenticatedSession.remoteStaticKey.copyOf(),
+ noisePayload.data
+ )
+ }
+ com.bitchat.android.model.NoisePayloadType.GROUP_KEY_UPDATE -> {
+ delegate?.onGroupKeyUpdateReceived(
+ peerID,
+ decryption.authenticatedSession.remoteStaticKey.copyOf(),
+ noisePayload.data
+ )
+ }
+ com.bitchat.android.model.NoisePayloadType.VOUCH -> {
+ delegate?.onVouchPayloadReceived(peerID, noisePayload.data)
+ }
}
} catch (e: Exception) {
@@ -207,6 +248,32 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
return true
}
+ /** Admit an already authenticated Noise X payload through the normal private-message path. */
+ suspend fun handleOpenedCourierPayload(routed: RoutedPacket): Boolean {
+ val packet = routed.packet
+ val peerID = routed.peerID ?: return false
+ val noisePayload = com.bitchat.android.model.NoisePayload.decode(packet.payload) ?: return false
+ if (noisePayload.type == com.bitchat.android.model.NoisePayloadType.DELIVERED) {
+ val messageID = noisePayload.data.toString(Charsets.UTF_8)
+ if (messageID.isBlank()) return false
+ delegate?.onDeliveryAckReceived(messageID, peerID)
+ return true
+ }
+ if (noisePayload.type != com.bitchat.android.model.NoisePayloadType.PRIVATE_MESSAGE) return false
+ val privateMessage = com.bitchat.android.model.PrivateMessagePacket.decode(noisePayload.data) ?: return false
+ val message = BitchatMessage(
+ id = privateMessage.messageID,
+ sender = delegate?.getPeerNickname(peerID) ?: "Unknown",
+ content = privateMessage.content,
+ timestamp = Date(packet.timestamp.toLong()),
+ isPrivate = true,
+ recipientNickname = delegate?.getMyNickname(),
+ senderPeerID = peerID
+ )
+ delegate?.onMessageReceived(message)
+ return com.bitchat.android.services.AppStateStore.hasPrivateTextReceipt(message)
+ }
+
/**
* Count consecutive decrypt failures from a signature-verified peer that we still hold an
* established session for. After repeated failures the session is stale (the peer completed
@@ -230,6 +297,13 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
consecutiveDecryptFailures[peerID] = failures
}
}
+
+ fun handleGroupMessage(routed: RoutedPacket) {
+ delegate?.onGroupMessageReceived(
+ routed.packet.payload,
+ routed.packet.timestamp.toLong()
+ )
+ }
/**
* Send delivery ACK for a received private message - exactly like iOS
@@ -348,6 +422,11 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
capabilities = announcement.capabilities
) ?: false
+ BridgeMeshPort.handleVerifiedAnnouncement(
+ peerID,
+ announcement
+ )
+
// Update mesh graph from gossip neighbors (only if TLV present)
try {
val neighborsOrNull = com.bitchat.android.services.meshgraph.GossipTLV.decodeNeighborsFromAnnouncementPayload(packet.payload)
@@ -453,6 +532,12 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
private suspend fun handleBroadcastMessage(routed: RoutedPacket) {
val packet = routed.packet
val peerID = routed.peerID ?: "unknown"
+ if (packet.timestamp > Long.MAX_VALUE.toULong()) return
+ val ageMs = System.currentTimeMillis() - packet.timestamp.toLong()
+ if (ageMs !in
+ -com.bitchat.android.sync.GossipSyncManager.PUBLIC_PACKET_FUTURE_SKEW_MS..
+ com.bitchat.android.sync.GossipSyncManager.PUBLIC_MESSAGE_MAX_AGE_MS
+ ) return
// Enforce: only accept public messages from verified peers we know
val peerInfo = delegate?.getPeerInfo(peerID)
@@ -486,13 +571,18 @@ class MessageHandler(private val myPeerID: String, private val appContext: andro
// Fallback: plain text
val message = BitchatMessage(
- id = PacketIdUtil.computeIdHex(packet).uppercase(),
+ id = MeshMessageIdentity.stableId(
+ peerID,
+ packet.timestamp.toLong(),
+ String(packet.payload, Charsets.UTF_8)
+ ),
sender = delegate?.getPeerNickname(peerID) ?: "unknown",
content = String(packet.payload, Charsets.UTF_8),
senderPeerID = peerID,
timestamp = Date(packet.timestamp.toLong())
)
delegate?.onMessageReceived(message)
+ BridgeMeshPort.handleAuthenticatedRadioMessage(message.id)
} catch (e: Exception) {
Log.e(TAG, "Failed to process broadcast message: ${e.message}")
}
@@ -738,4 +828,16 @@ interface MessageHandlerDelegate {
fun onReadReceiptReceived(messageID: String, peerID: String)
fun onVerifyChallengeReceived(peerID: String, payload: ByteArray, timestampMs: Long)
fun onVerifyResponseReceived(peerID: String, payload: ByteArray, timestampMs: Long)
+ fun onGroupInviteReceived(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {}
+ fun onGroupKeyUpdateReceived(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {}
+ fun onGroupMessageReceived(payload: ByteArray, timestampMs: Long) {}
+ fun onVouchPayloadReceived(peerID: String, payload: ByteArray) {}
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt b/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt
index 37a295e8..8d175a06 100644
--- a/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt
@@ -122,6 +122,22 @@ class PacketProcessor(private val myPeerID: String) {
var validPacket = true
val messageType = MessageType.fromValue(packet.type)
+ val isBroadcast = packet.recipientID == null ||
+ packet.recipientID.contentEquals(com.bitchat.android.protocol.SpecialRecipients.BROADCAST)
+ if (isBroadcast && packet.timestamp <= Long.MAX_VALUE.toULong()) {
+ val ageMs = System.currentTimeMillis() - packet.timestamp.toLong()
+ val maxAgeMs = when (messageType) {
+ MessageType.MESSAGE -> com.bitchat.android.sync.GossipSyncManager.PUBLIC_MESSAGE_MAX_AGE_MS
+ MessageType.FRAGMENT, MessageType.FILE_TRANSFER ->
+ com.bitchat.android.sync.GossipSyncManager.FRAGMENT_MAX_AGE_MS
+ else -> null
+ }
+ if (maxAgeMs != null && ageMs !in
+ -com.bitchat.android.sync.GossipSyncManager.PUBLIC_PACKET_FUTURE_SKEW_MS..maxAgeMs
+ ) return
+ } else if (isBroadcast && packet.timestamp > Long.MAX_VALUE.toULong()) {
+ return
+ }
// Verbose logging to debug manager (and chat via ChatViewModel observer)
try {
val mt = messageType?.name ?: packet.type.toString()
@@ -137,15 +153,35 @@ class PacketProcessor(private val myPeerID: String) {
MessageType.MESSAGE -> handleMessage(routed)
MessageType.FILE_TRANSFER -> handleMessage(routed) // treat same routing path; parsing happens in handler
MessageType.VOICE_FRAME -> validPacket = delegate?.handleVoiceFrame(routed) ?: false
+ MessageType.GROUP_MESSAGE -> handleGroupMessage(routed)
+ MessageType.BOARD_POST -> validPacket = handleBoardPost(routed)
MessageType.LEAVE -> handleLeave(routed)
MessageType.FRAGMENT -> handleFragment(routed)
MessageType.REQUEST_SYNC -> handleRequestSync(routed)
+ MessageType.PREKEY_BUNDLE -> {
+ BridgeMeshPort.handlePrekeyPacket(packet)
+ }
+ MessageType.NOSTR_CARRIER -> {
+ val directedToUs = packetRelayManager.isPacketAddressedToMe(packet)
+ val isBroadcast = packet.recipientID == null ||
+ packet.recipientID.contentEquals(delegate?.getBroadcastRecipient())
+ if (directedToUs || isBroadcast) {
+ BridgeMeshPort.handleCarrier(
+ packet.payload,
+ peerID,
+ directedToUs
+ )
+ }
+ }
else -> {
// Handle private packet types (address check required)
if (packetRelayManager.isPacketAddressedToMe(packet)) {
when (messageType) {
MessageType.NOISE_HANDSHAKE -> validPacket = handleNoiseHandshake(routed)
MessageType.NOISE_ENCRYPTED -> validPacket = handleNoiseEncrypted(routed)
+ MessageType.COURIER_ENVELOPE -> validPacket = delegate?.handleCourierEnvelope(routed) ?: false
+ MessageType.PING -> delegate?.handlePing(routed)
+ MessageType.PONG -> delegate?.handlePong(routed)
MessageType.FILE_TRANSFER -> handleMessage(routed)
else -> {
validPacket = false
@@ -195,6 +231,12 @@ class PacketProcessor(private val myPeerID: String) {
private suspend fun handleMessage(routed: RoutedPacket) {
delegate?.handleMessage(routed)
}
+
+ private fun handleGroupMessage(routed: RoutedPacket) {
+ val peerID = routed.peerID ?: "unknown"
+ Log.d(TAG, "Processing private-group message from ${formatPeerForLog(peerID)}")
+ delegate?.handleGroupMessage(routed)
+ }
/**
* Handle leave message
@@ -226,8 +268,24 @@ class PacketProcessor(private val myPeerID: String) {
* Handle REQUEST_SYNC packets (public, TTL=1)
*/
private suspend fun handleRequestSync(routed: RoutedPacket) {
+ val peerID = routed.peerID ?: "unknown"
+ if (routed.packet.ttl != com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS) {
+ Log.w(TAG, "Dropping non-link-local REQUEST_SYNC from ${formatPeerForLog(peerID)}")
+ return
+ }
+ Log.d(TAG, "Processing REQUEST_SYNC from ${formatPeerForLog(peerID)}")
delegate?.handleRequestSync(routed)
}
+
+ /**
+ * Board packets are self-authenticating. The delegate verifies their
+ * embedded Ed25519 signature and returns false for anything that must not relay.
+ */
+ private fun handleBoardPost(routed: RoutedPacket): Boolean {
+ val peerID = routed.peerID ?: "unknown"
+ Log.d(TAG, "Processing board packet from ${formatPeerForLog(peerID)}")
+ return delegate?.handleBoardPost(routed) ?: false
+ }
/**
* Handle delivery acknowledgment
@@ -291,16 +349,22 @@ interface PacketProcessorDelegate {
// Network information
fun getNetworkSize(): Int
fun getBroadcastRecipient(): ByteArray
+ fun isPeerDirectlyConnected(peerID: String): Boolean = false
// Message type handlers
fun handleNoiseHandshake(routed: RoutedPacket): Boolean
fun handleNoiseEncrypted(routed: RoutedPacket): Boolean
+ fun handleCourierEnvelope(routed: RoutedPacket): Boolean = false
suspend fun handleAnnounce(routed: RoutedPacket): Boolean
fun handleMessage(routed: RoutedPacket)
fun handleVoiceFrame(routed: RoutedPacket): Boolean = false
+ fun handleGroupMessage(routed: RoutedPacket) {}
fun handleLeave(routed: RoutedPacket)
fun handleFragment(packet: BitchatPacket): BitchatPacket?
fun handleRequestSync(routed: RoutedPacket)
+ fun handleBoardPost(routed: RoutedPacket): Boolean = false
+ fun handlePing(routed: RoutedPacket) {}
+ fun handlePong(routed: RoutedPacket) {}
// Communication
fun sendAnnouncementToPeer(peerID: String)
diff --git a/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt b/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt
index 6b5c6d16..4d87366b 100644
--- a/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/PacketRelayManager.kt
@@ -4,8 +4,10 @@ import com.bitchat.android.protocol.MessageType
import android.util.Log
import com.bitchat.android.model.RoutedPacket
import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.protocol.MeshDiagnosticsConstants
import com.bitchat.android.util.toHexString
import kotlinx.coroutines.*
+import java.util.concurrent.ConcurrentHashMap
import kotlin.random.Random
/**
@@ -32,6 +34,7 @@ class PacketRelayManager(private val myPeerID: String) {
// Coroutines
private val relayScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+ private val diagnosticRelayTimestamps = ConcurrentHashMap>()
/**
* Main entry point for relay decisions
@@ -60,6 +63,13 @@ class PacketRelayManager(private val myPeerID: String) {
Log.d(TAG, "TTL expired, not relaying packet")
return
}
+
+ val isDiagnostic = MessageType.fromValue(packet.type) in
+ setOf(MessageType.PING, MessageType.PONG)
+ if (isDiagnostic && !consumeDiagnosticRelayBudget(routed, peerID)) {
+ Log.w(TAG, "Diagnostic relay budget exhausted for ingress link")
+ return
+ }
// Decrement TTL by 1
val networkSize = delegate?.getNetworkSize() ?: 1
@@ -108,11 +118,36 @@ class PacketRelayManager(private val myPeerID: String) {
// Apply relay logic based on packet type and debug switch
val shouldRelay = isRelayEnabled() && shouldRelayPacket(relayPacket, peerID)
if (shouldRelay) {
+ if (isDiagnostic) {
+ delay(
+ Random.nextLong(
+ MeshDiagnosticsConstants.RELAY_JITTER_MIN_MILLIS,
+ MeshDiagnosticsConstants.RELAY_JITTER_MAX_MILLIS + 1,
+ )
+ )
+ }
relayPacket(RoutedPacket(relayPacket, peerID, routed.relayAddress))
} else {
Log.d(TAG, "Relay decision: NOT relaying packet type ${packet.type}")
}
}
+
+ private fun consumeDiagnosticRelayBudget(routed: RoutedPacket, fallbackPeerID: String): Boolean {
+ val ingressKey = routed.ingressLinkID ?: routed.relayAddress ?: fallbackPeerID
+ val now = System.currentTimeMillis()
+ val timestamps = diagnosticRelayTimestamps.computeIfAbsent(ingressKey) { ArrayDeque() }
+ synchronized(timestamps) {
+ while (timestamps.firstOrNull()?.let {
+ now - it >= MeshDiagnosticsConstants.INBOUND_RATE_WINDOW_MILLIS
+ } == true
+ ) {
+ timestamps.removeFirst()
+ }
+ if (timestamps.size >= MeshDiagnosticsConstants.INBOUND_RATE_LIMIT) return false
+ timestamps.addLast(now)
+ return true
+ }
+ }
/**
* Check if a packet is specifically addressed to us
@@ -140,6 +175,9 @@ class PacketRelayManager(private val myPeerID: String) {
* Determine if we should relay this packet based on type and network conditions
*/
private fun shouldRelayPacket(packet: BitchatPacket, fromPeerID: String): Boolean {
+ if (MessageType.fromValue(packet.type) in setOf(MessageType.PING, MessageType.PONG)) {
+ return true
+ }
// Always relay if TTL is high enough (indicates important message)
if (packet.ttl >= 4u) {
Log.d(TAG, "High TTL (${packet.ttl}), relaying")
diff --git a/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt b/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt
index 6fab9f03..f3565005 100644
--- a/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt
@@ -89,8 +89,10 @@ class SecurityManager(private val encryptionService: EncryptionService, private
}
}
- // Enforce mandatory signature verification
- if (!verifyPacketSignature(packet, peerID)) {
+ // Mesh diagnostics are intentionally unsigned for iOS wire compatibility.
+ val isUnsignedDiagnostic =
+ messageType in setOf(MessageType.PING, MessageType.PONG) && packet.signature == null
+ if (!isUnsignedDiagnostic && !verifyPacketSignature(packet, peerID)) {
return false
}
@@ -257,8 +259,11 @@ class SecurityManager(private val encryptionService: EncryptionService, private
MessageType.ANNOUNCE,
MessageType.MESSAGE,
MessageType.FILE_TRANSFER,
+ MessageType.COURIER_ENVELOPE,
MessageType.VOICE_FRAME,
- MessageType.LEAVE
+ MessageType.LEAVE,
+ MessageType.REQUEST_SYNC,
+ MessageType.NOSTR_CARRIER
)) {
return true
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/UnifiedMeshService.kt b/app/src/main/java/com/bitchat/android/mesh/UnifiedMeshService.kt
index 3efe758d..eb7232c1 100644
--- a/app/src/main/java/com/bitchat/android/mesh/UnifiedMeshService.kt
+++ b/app/src/main/java/com/bitchat/android/mesh/UnifiedMeshService.kt
@@ -5,7 +5,9 @@ import android.util.Log
import com.bitchat.android.favorites.FavoriteControlMessage
import com.bitchat.android.model.BitchatFilePacket
import com.bitchat.android.model.BitchatMessage
+import com.bitchat.android.model.RoutedPacket
import com.bitchat.android.noise.NoiseSession
+import com.bitchat.android.service.TransportBridgeService
import com.bitchat.android.wifiaware.WifiAwareController
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
@@ -37,6 +39,10 @@ class UnifiedMeshService(
private val serviceScope = CoroutineScope(Dispatchers.Default + SupervisorJob())
private val powerManager = PowerManager.getInstance(context.applicationContext)
private var announcementJob: Job? = null
+ private val diagnosticsScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
+ private val meshPingManager = MeshPingManager(bluetooth.myPeerID, diagnosticsScope) { packet ->
+ TransportBridgeService.broadcastFromLocal(RoutedPacket(packet))
+ }
override val myPeerID: String
get() = bluetooth.myPeerID
@@ -101,6 +107,29 @@ class UnifiedMeshService(
}
}
+ override fun sendNostrCarrier(payload: ByteArray, recipientPeerID: String?) {
+ when {
+ isBleEnabled() -> bluetooth.sendNostrCarrier(payload, recipientPeerID)
+ else -> wifiService()?.sendNostrCarrier(payload, recipientPeerID)
+ }
+ }
+
+ override fun sendCourierEnvelope(payload: ByteArray, recipientPeerID: String) {
+ when {
+ isBleConnected(recipientPeerID) || (isBleEnabled() && !isWifiConnected(recipientPeerID)) ->
+ bluetooth.sendCourierEnvelope(payload, recipientPeerID)
+ else -> wifiService()?.sendCourierEnvelope(payload, recipientPeerID)
+ }
+ }
+
+ override fun sendPrekeyBundle(payload: ByteArray) {
+ if (isBleEnabled()) {
+ bluetooth.sendPrekeyBundle(payload)
+ } else {
+ wifiService()?.sendPrekeyBundle(payload)
+ }
+ }
+
override fun sendPrivateMessage(
content: String,
recipientPeerID: String,
@@ -116,6 +145,25 @@ class UnifiedMeshService(
}
}
+ override fun getPeerInfos(): List = bluetooth.getPeerInfos()
+
+ override fun sendCourierMessage(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ courierPeerIDs: List
+ ): List = bluetooth.sendCourierMessage(content, messageID, recipientNoiseKey, courierPeerIDs)
+
+ override fun sendBridgeCourierMessage(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ onAccepted: () -> Unit
+ ): Boolean = bluetooth.sendBridgeCourierMessage(content, messageID, recipientNoiseKey, onAccepted)
+
+ override fun supportsPrivateMediaReceipts(peerID: String): Boolean =
+ bluetooth.supportsPrivateMediaReceipts(peerID) || wifiService()?.supportsPrivateMediaReceipts(peerID) == true
+
override fun sendReadReceipt(messageID: String, recipientPeerID: String, readerNickname: String) {
when {
isBleReady(recipientPeerID) -> bluetooth.sendReadReceipt(messageID, recipientPeerID, readerNickname)
@@ -150,6 +198,30 @@ class UnifiedMeshService(
}
}
+ override fun sendGroupInvite(payload: ByteArray, recipientPeerID: String) {
+ when {
+ isBleReady(recipientPeerID) -> bluetooth.sendGroupInvite(payload, recipientPeerID)
+ isWifiReady(recipientPeerID) ->
+ wifiService()?.sendGroupInvite(payload, recipientPeerID)
+ }
+ }
+
+ override fun sendGroupKeyUpdate(payload: ByteArray, recipientPeerID: String) {
+ when {
+ isBleReady(recipientPeerID) ->
+ bluetooth.sendGroupKeyUpdate(payload, recipientPeerID)
+ isWifiReady(recipientPeerID) ->
+ wifiService()?.sendGroupKeyUpdate(payload, recipientPeerID)
+ }
+ }
+
+ override fun broadcastGroupMessage(payload: ByteArray) {
+ when {
+ isBleEnabled() -> bluetooth.broadcastGroupMessage(payload)
+ else -> wifiService()?.broadcastGroupMessage(payload)
+ }
+ }
+
override fun sendFileBroadcast(file: BitchatFilePacket) {
when {
isBleEnabled() -> bluetooth.sendFileBroadcast(file)
@@ -184,6 +256,15 @@ class UnifiedMeshService(
}
}
+ override fun sendBoardPayload(payload: ByteArray) {
+ when {
+ isBleEnabled() -> bluetooth.sendBoardPayload(payload)
+ else -> wifiService()?.sendBoardPayload(payload)
+ }
+ }
+
+
+
override fun prepareFilePrivate(
recipientPeerID: String,
file: BitchatFilePacket,
@@ -239,6 +320,10 @@ class UnifiedMeshService(
}
}
+ override fun sendMeshPing(peerID: String, callback: (MeshPingResult?) -> Unit) {
+ meshPingManager.ping(peerID, callback)
+ }
+
override fun getPeerNicknames(): Map {
val merged = linkedMapOf()
try { merged.putAll(wifiService()?.getPeerNicknames().orEmpty()) } catch (_: Exception) { }
@@ -327,6 +412,12 @@ class UnifiedMeshService(
return bluetooth.getStaticNoisePublicKey() ?: wifiService()?.getStaticNoisePublicKey()
}
+ override fun getSigningPublicKey(): ByteArray? =
+ bluetooth.getSigningPublicKey() ?: wifiService()?.getSigningPublicKey()
+
+ override fun signData(data: ByteArray): ByteArray? =
+ bluetooth.signData(data) ?: wifiService()?.signData(data)
+
override fun shouldShowEncryptionIcon(peerID: String): Boolean {
return hasEstablishedSession(peerID)
}
@@ -351,6 +442,13 @@ class UnifiedMeshService(
return merged
}
+ override fun getDirectBlePeerIDs(): Set =
+ try {
+ bluetooth.getDeviceAddressToPeerMapping().values.toSet()
+ } catch (_: Exception) {
+ emptySet()
+ }
+
override fun printDeviceAddressesForPeers(): String {
return buildString {
appendLine(bluetooth.printDeviceAddressesForPeers())
@@ -376,8 +474,10 @@ class UnifiedMeshService(
}
override fun clearAllInternalData() {
- try { bluetooth.clearAllInternalData() } catch (_: Exception) { }
- try { wifiService()?.clearAllInternalData() } catch (_: Exception) { }
+ val bluetoothResult = runCatching { bluetooth.clearAllInternalData() }
+ val wifiResult = runCatching { wifiService()?.clearAllInternalData() }
+ bluetoothResult.getOrThrow()
+ wifiResult.getOrThrow()
}
override fun clearAllEncryptionData() {
@@ -413,6 +513,26 @@ class UnifiedMeshService(
delegate?.didReceiveVerifyResponse(peerID, payload, timestampMs)
}
+ override fun didReceiveGroupInvite(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ delegate?.didReceiveGroupInvite(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun didReceiveGroupKeyUpdate(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ delegate?.didReceiveGroupKeyUpdate(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun didReceiveGroupMessage(payload: ByteArray, timestampMs: Long) {
+ delegate?.didReceiveGroupMessage(payload, timestampMs)
+ }
+
override fun didResolvePrivateMediaPolicy(peerID: String) {
delegate?.didResolvePrivateMediaPolicy(peerID)
}
diff --git a/app/src/main/java/com/bitchat/android/mesh/VouchCoordinator.kt b/app/src/main/java/com/bitchat/android/mesh/VouchCoordinator.kt
new file mode 100644
index 00000000..8e5d6fb0
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/mesh/VouchCoordinator.kt
@@ -0,0 +1,127 @@
+package com.bitchat.android.mesh
+
+import android.util.Log
+import com.bitchat.android.identity.SecureIdentityStateManager
+import com.bitchat.android.model.PeerCapabilities
+import com.bitchat.android.model.VouchAttestation
+import com.bitchat.android.util.dataFromHexString
+import com.bitchat.android.util.hexEncodedString
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.collect
+import kotlinx.coroutines.launch
+
+/**
+ * Transport-neutral exchange and acceptance policy for transitive verification.
+ *
+ * All payloads supplied to [handlePayload] have already been authenticated and
+ * decrypted by the Noise session for [peerID].
+ */
+class VouchCoordinator(
+ private val scope: CoroutineScope,
+ private val identity: SecureIdentityStateManager,
+ private val connectedPeerIDs: () -> Collection,
+ private val fingerprintForPeer: (String) -> String?,
+ private val peerInfo: (String) -> PeerInfo?,
+ private val signingKeyForFingerprint: (String) -> ByteArray?,
+ private val hasEstablishedSession: (String) -> Boolean,
+ private val sign: (ByteArray) -> ByteArray?,
+ private val verify: (ByteArray, ByteArray, ByteArray) -> Boolean,
+ private val send: (String, ByteArray) -> Boolean
+) {
+ init {
+ scope.launch {
+ SecureIdentityStateManager.changes.collect {
+ vouchToConnectedVerifiedPeers()
+ }
+ }
+ }
+
+ fun peerAuthenticated(peerID: String, fingerprint: String) {
+ attemptVouch(peerID, fingerprint)
+ }
+
+ fun peersUpdated(peerIDs: Collection) {
+ peerIDs.forEach { peerID ->
+ fingerprintForPeer(peerID)?.let { attemptVouch(peerID, it) }
+ }
+ }
+
+ fun vouchToConnectedVerifiedPeers(nowMs: Long = System.currentTimeMillis()) {
+ connectedPeerIDs().forEach { peerID ->
+ fingerprintForPeer(peerID)?.let { attemptVouch(peerID, it, nowMs) }
+ }
+ }
+
+ fun attemptVouch(
+ peerID: String,
+ peerFingerprint: String,
+ nowMs: Long = System.currentTimeMillis()
+ ): Boolean {
+ val normalizedPeerFingerprint = peerFingerprint.lowercase()
+ if (!hasEstablishedSession(peerID) ||
+ !identity.isVerifiedFingerprint(normalizedPeerFingerprint)
+ ) return false
+
+ val capabilities = peerInfo(peerID)?.capabilities
+ if (capabilities != null && capabilities != PeerCapabilities.NONE &&
+ !capabilities.contains(PeerCapabilities.VOUCH)
+ ) return false
+
+ val lastSent = identity.lastVouchBatchSent(normalizedPeerFingerprint)
+ if (lastSent != null && nowMs - lastSent < BATCH_INTERVAL_MS) return false
+
+ val attestations = identity.mostRecentlyVerifiedFingerprints(
+ VouchAttestation.MAX_BATCH_COUNT,
+ excluding = normalizedPeerFingerprint
+ ).mapNotNull { vouchee ->
+ val fingerprintBytes = vouchee.dataFromHexString() ?: return@mapNotNull null
+ val signingKey = signingKeyForFingerprint(vouchee) ?: return@mapNotNull null
+ VouchAttestation.build(fingerprintBytes, signingKey, nowMs, sign)
+ }
+ val payload = VouchAttestation.encodeList(attestations) ?: return false
+ if (!send(peerID, payload)) return false
+ identity.markVouchBatchSent(normalizedPeerFingerprint, nowMs)
+ Log.d(TAG, "Sent ${attestations.size} vouch(es) to ${peerID.take(LOG_FINGERPRINT_LENGTH)}")
+ return true
+ }
+
+ fun handlePayload(
+ peerID: String,
+ payload: ByteArray,
+ nowMs: Long = System.currentTimeMillis()
+ ) {
+ val senderFingerprint = fingerprintForPeer(peerID)?.lowercase() ?: return
+ if (!identity.isVerifiedFingerprint(senderFingerprint)) return
+ val senderSigningKey = signingKeyForFingerprint(senderFingerprint) ?: return
+
+ var accepted = INITIAL_ACCEPTED_COUNT
+ VouchAttestation.decodeList(payload).forEach { attestation ->
+ if (!attestation.isExpired(nowMs) &&
+ verify(attestation.signature, attestation.signableBytes(), senderSigningKey) &&
+ identity.recordVouch(
+ attestation.voucheeFingerprint.hexEncodedString(),
+ senderFingerprint,
+ attestation.voucheeSigningKey,
+ attestation.timestampMs,
+ nowMs
+ )
+ ) accepted++
+ }
+ if (accepted > INITIAL_ACCEPTED_COUNT) {
+ Log.i(TAG, "Accepted $accepted vouch(es) from ${peerID.take(LOG_FINGERPRINT_LENGTH)}")
+ }
+ }
+
+ companion object {
+ private const val TAG = "VouchCoordinator"
+ private const val INITIAL_ACCEPTED_COUNT = 0
+ private const val LOG_FINGERPRINT_LENGTH = 8
+ private const val HOURS_PER_DAY = 24L
+ private const val MINUTES_PER_HOUR = 60L
+ private const val SECONDS_PER_MINUTE = 60L
+ private const val MILLIS_PER_SECOND = 1000L
+ const val BATCH_INTERVAL_MS =
+ HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLIS_PER_SECOND
+ val NOISE_PACKET_VERSION: UByte = 1u
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt b/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt
index 528a269e..c0ebf74b 100644
--- a/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt
+++ b/app/src/main/java/com/bitchat/android/model/BitchatMessage.kt
@@ -22,6 +22,9 @@ sealed class DeliveryStatus : Parcelable {
@Parcelize
object Sending : DeliveryStatus()
+ @Parcelize
+ object Queued : DeliveryStatus()
+
@Parcelize
object Sent : DeliveryStatus()
@@ -40,6 +43,7 @@ sealed class DeliveryStatus : Parcelable {
fun getDisplayText(): String {
return when (this) {
is Sending -> "Sending..."
+ is Queued -> "Queued"
is Sent -> "Sent"
is Delivered -> "Delivered to ${this.to}"
is Read -> "Read by ${this.by}"
@@ -77,7 +81,15 @@ data class BitchatMessage(
* surfaces color the sender by the same stable key while [senderPeerID] remains available for
* mesh IDs and private-chat routing aliases.
*/
- val senderNostrPubkey: String? = null
+ val senderNostrPubkey: String? = null,
+ /** Rendered from a signed bridge rendezvous event rather than local radio. */
+ val isBridged: Boolean = false,
+ /**
+ * Untrusted radio-coordinate hint from the bridge event. It may merge a
+ * duplicate when the authenticated radio copy arrives, but never owns the
+ * bridge row's primary ID.
+ */
+ val bridgeRadioMessageIdHint: String? = null
) : Parcelable {
/**
@@ -362,4 +374,3 @@ data class BitchatMessage(
return result
}
}
-
diff --git a/app/src/main/java/com/bitchat/android/model/CourierEnvelope.kt b/app/src/main/java/com/bitchat/android/model/CourierEnvelope.kt
new file mode 100644
index 00000000..4765a273
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/model/CourierEnvelope.kt
@@ -0,0 +1,115 @@
+package com.bitchat.android.model
+
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
+
+/** Opaque store-and-forward envelope, wire-compatible with iOS CourierEnvelope. */
+data class CourierEnvelope(
+ val recipientTag: ByteArray,
+ val expiry: ULong,
+ val ciphertext: ByteArray,
+ val copies: UByte = 1u,
+ val prekeyID: UInt? = null
+) {
+ companion object {
+ const val TAG_LENGTH = 16
+ const val MAX_CIPHERTEXT_BYTES = 16 * 1024
+ const val MAX_LIFETIME_MS = 24 * 60 * 60 * 1000L
+ const val MAX_COPIES = 8
+ private val TAG_DOMAIN = "bitchat-courier-tag-v1".toByteArray(Charsets.UTF_8)
+
+ fun epochDay(nowMs: Long): UInt = Math.floorDiv(nowMs, 86_400_000L).toUInt()
+
+ fun recipientTag(noiseStaticKey: ByteArray, epochDay: UInt): ByteArray {
+ require(noiseStaticKey.size == 32)
+ val mac = Mac.getInstance("HmacSHA256")
+ mac.init(SecretKeySpec(noiseStaticKey, "HmacSHA256"))
+ mac.update(TAG_DOMAIN)
+ mac.update(ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(epochDay.toInt()).array())
+ return mac.doFinal().copyOf(TAG_LENGTH)
+ }
+
+ fun decode(data: ByteArray): CourierEnvelope? {
+ var offset = 0
+ var tag: ByteArray? = null
+ var expiry: ULong? = null
+ var ciphertext: ByteArray? = null
+ var copies: UByte = 1u
+ var prekeyID: UInt? = null
+ while (offset + 3 <= data.size) {
+ val type = data[offset].toUByte()
+ val length = ((data[offset + 1].toInt() and 0xff) shl 8) or
+ (data[offset + 2].toInt() and 0xff)
+ offset += 3
+ if (offset + length > data.size) return null
+ val value = data.copyOfRange(offset, offset + length)
+ offset += length
+ when (type.toInt()) {
+ 1 -> if (length == TAG_LENGTH && tag == null) tag = value else return null
+ 2 -> if (length == 8 && expiry == null) expiry = ByteBuffer.wrap(value).order(ByteOrder.BIG_ENDIAN).long.toULong() else return null
+ 3 -> if (ciphertext == null) ciphertext = value else return null
+ 4 -> {
+ if (length != 1 || copies != 1u.toUByte()) return null
+ copies = value[0].toUByte()
+ if (copies !in 2u.toUByte()..MAX_COPIES.toUByte()) return null
+ }
+ 5 -> if (length == 4 && prekeyID == null) {
+ prekeyID = ByteBuffer.wrap(value).order(ByteOrder.BIG_ENDIAN).int.toUInt()
+ } else {
+ return null
+ }
+ }
+ }
+ if (offset != data.size) return null
+ val requiredTag = tag ?: return null
+ val requiredExpiry = expiry ?: return null
+ val requiredCiphertext = ciphertext ?: return null
+ if (requiredCiphertext.isEmpty() || requiredCiphertext.size > MAX_CIPHERTEXT_BYTES) return null
+ return CourierEnvelope(requiredTag, requiredExpiry, requiredCiphertext, copies, prekeyID)
+ }
+ }
+
+ fun encode(): ByteArray? {
+ if (recipientTag.size != TAG_LENGTH || ciphertext.isEmpty() || ciphertext.size > MAX_CIPHERTEXT_BYTES ||
+ copies !in 1u.toUByte()..MAX_COPIES.toUByte()
+ ) return null
+ val fields = mutableListOf>()
+ fields += 1 to recipientTag
+ fields += 2 to ByteBuffer.allocate(8).order(ByteOrder.BIG_ENDIAN).putLong(expiry.toLong()).array()
+ fields += 3 to ciphertext
+ if (copies > 1u) fields += 4 to byteArrayOf(copies.toByte())
+ prekeyID?.let {
+ fields += 5 to ByteBuffer.allocate(4).order(ByteOrder.BIG_ENDIAN).putInt(it.toInt()).array()
+ }
+ val size = fields.sumOf { 3 + it.second.size }
+ val buffer = ByteBuffer.allocate(size).order(ByteOrder.BIG_ENDIAN)
+ fields.forEach { (type, value) ->
+ buffer.put(type.toByte())
+ buffer.putShort(value.size.toShort())
+ buffer.put(value)
+ }
+ return buffer.array()
+ }
+
+ fun matchesRecipient(noiseStaticKey: ByteArray, nowMs: Long): Boolean {
+ val day = epochDay(nowMs)
+ return listOf(day - 1u, day, day + 1u).any {
+ recipientTag.contentEquals(recipientTag(noiseStaticKey, it))
+ }
+ }
+
+ override fun equals(other: Any?): Boolean = other is CourierEnvelope &&
+ recipientTag.contentEquals(other.recipientTag) && expiry == other.expiry &&
+ ciphertext.contentEquals(other.ciphertext) && copies == other.copies && prekeyID == other.prekeyID
+
+ override fun hashCode(): Int {
+ var result = recipientTag.contentHashCode()
+ result = 31 * result + expiry.hashCode()
+ result = 31 * result + ciphertext.contentHashCode()
+ result = 31 * result + copies.hashCode()
+ result = 31 * result + (prekeyID?.hashCode() ?: 0)
+ return result
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/model/IdentityAnnouncement.kt b/app/src/main/java/com/bitchat/android/model/IdentityAnnouncement.kt
index c48bd6cc..21ccbc5e 100644
--- a/app/src/main/java/com/bitchat/android/model/IdentityAnnouncement.kt
+++ b/app/src/main/java/com/bitchat/android/model/IdentityAnnouncement.kt
@@ -13,7 +13,8 @@ data class IdentityAnnouncement(
val noisePublicKey: ByteArray, // Noise static public key (Curve25519.KeyAgreement)
val signingPublicKey: ByteArray, // Ed25519 public key for signing
val capabilities: PeerCapabilities? = null,
- val unknownTLVs: List = emptyList()
+ val unknownTLVs: List = emptyList(),
+ val bridgeGeohash: String? = null
) : Parcelable {
/**
@@ -23,7 +24,8 @@ data class IdentityAnnouncement(
NICKNAME(0x01u),
NOISE_PUBLIC_KEY(0x02u),
SIGNING_PUBLIC_KEY(0x03u), // NEW: Ed25519 signing public key
- CAPABILITIES(0x05u);
+ CAPABILITIES(0x05u),
+ BRIDGE_GEOHASH(0x06u);
companion object {
fun fromValue(value: UByte): TLVType? {
@@ -39,6 +41,9 @@ data class IdentityAnnouncement(
val nicknameData = nickname.toByteArray(Charsets.UTF_8)
// Check size limits
+ val bridgeGeohashData = bridgeGeohash
+ ?.toByteArray(Charsets.UTF_8)
+ ?.takeIf { it.size in 1..12 }
if (nicknameData.size > 255 || noisePublicKey.size > 255 || signingPublicKey.size > 255 ||
unknownTLVs.any { it.value.size > 255 }) {
return null
@@ -68,6 +73,12 @@ data class IdentityAnnouncement(
result.addAll(capabilityBytes.toList())
}
+ bridgeGeohashData?.let { geohash ->
+ result.add(TLVType.BRIDGE_GEOHASH.value.toByte())
+ result.add(geohash.size.toByte())
+ result.addAll(geohash.toList())
+ }
+
// Preserve extensions this build does not understand. This includes
// gossip TLV 0x04 when an announcement is decoded through this model.
unknownTLVs.forEach { tlv ->
@@ -92,6 +103,7 @@ data class IdentityAnnouncement(
var noisePublicKey: ByteArray? = null
var signingPublicKey: ByteArray? = null
var capabilities: PeerCapabilities? = null
+ var bridgeGeohash: String? = null
val unknownTLVs = mutableListOf()
while (offset + 2 <= dataCopy.size) {
@@ -125,6 +137,10 @@ data class IdentityAnnouncement(
TLVType.CAPABILITIES -> {
capabilities = PeerCapabilities.decode(value)
}
+ TLVType.BRIDGE_GEOHASH -> {
+ if (value.size !in 1..12) return null
+ bridgeGeohash = String(value, Charsets.UTF_8)
+ }
null -> {
// Retain unknown extensions so callers can forward or
// re-encode the announcement without erasing them.
@@ -135,7 +151,14 @@ data class IdentityAnnouncement(
// All three fields are required
return if (nickname != null && noisePublicKey != null && signingPublicKey != null) {
- IdentityAnnouncement(nickname, noisePublicKey, signingPublicKey, capabilities, unknownTLVs)
+ IdentityAnnouncement(
+ nickname,
+ noisePublicKey,
+ signingPublicKey,
+ capabilities,
+ unknownTLVs,
+ bridgeGeohash
+ )
} else {
null
}
@@ -145,12 +168,14 @@ data class IdentityAnnouncement(
fun forLocalPeer(
nickname: String,
noisePublicKey: ByteArray,
- signingPublicKey: ByteArray
+ signingPublicKey: ByteArray,
+ bridgeGeohash: String? = null
): IdentityAnnouncement = IdentityAnnouncement(
nickname = nickname,
noisePublicKey = noisePublicKey,
signingPublicKey = signingPublicKey,
- capabilities = PeerCapabilities.LOCAL_SUPPORTED
+ capabilities = PeerCapabilities.localSupported(),
+ bridgeGeohash = bridgeGeohash
)
}
@@ -166,6 +191,7 @@ data class IdentityAnnouncement(
if (!signingPublicKey.contentEquals(other.signingPublicKey)) return false
if (capabilities != other.capabilities) return false
if (unknownTLVs != other.unknownTLVs) return false
+ if (bridgeGeohash != other.bridgeGeohash) return false
return true
}
@@ -176,10 +202,11 @@ data class IdentityAnnouncement(
result = 31 * result + signingPublicKey.contentHashCode()
result = 31 * result + (capabilities?.hashCode() ?: 0)
result = 31 * result + unknownTLVs.hashCode()
+ result = 31 * result + (bridgeGeohash?.hashCode() ?: 0)
return result
}
override fun toString(): String {
- return "IdentityAnnouncement(nickname='$nickname', noisePublicKey=${noisePublicKey.joinToString("") { "%02x".format(it) }.take(16)}..., signingPublicKey=${signingPublicKey.joinToString("") { "%02x".format(it) }.take(16)}..., capabilities=${capabilities?.rawValue})"
+ return "IdentityAnnouncement(nickname='$nickname', noisePublicKey=${noisePublicKey.joinToString("") { "%02x".format(it) }.take(16)}..., signingPublicKey=${signingPublicKey.joinToString("") { "%02x".format(it) }.take(16)}..., capabilities=${capabilities?.rawValue}, bridgeGeohash=$bridgeGeohash)"
}
}
diff --git a/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt b/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt
index aacdafd4..7aa0e843 100644
--- a/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt
+++ b/app/src/main/java/com/bitchat/android/model/NoiseEncrypted.kt
@@ -22,8 +22,11 @@ enum class NoisePayloadType(val value: UByte) {
READ_RECEIPT(0x02u), // Message was read
DELIVERED(0x03u), // Message was delivered
VOICE_FRAME(0x08u), // Ephemeral live push-to-talk frame
+ GROUP_INVITE(0x06u), // Creator-signed private-group state
+ GROUP_KEY_UPDATE(0x07u), // Creator-signed roster/key rotation
VERIFY_CHALLENGE(0x10u), // Verification challenge
VERIFY_RESPONSE(0x11u), // Verification response
+ VOUCH(0x12u), // Transitive verification attestations
FILE_TRANSFER(0x20u),
/** Authenticated capabilities + Ed25519 binding for the current Noise generation. */
PEER_STATE(0x21u);
diff --git a/app/src/main/java/com/bitchat/android/model/NostrCarrierPacket.kt b/app/src/main/java/com/bitchat/android/model/NostrCarrierPacket.kt
new file mode 100644
index 00000000..3f6be5a7
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/model/NostrCarrierPacket.kt
@@ -0,0 +1,101 @@
+package com.bitchat.android.model
+
+import com.bitchat.android.nostr.NostrEvent
+
+/**
+ * Wire payload for MessageType.NOSTR_CARRIER (0x28).
+ *
+ * The TLV layout and limits intentionally match iOS. Lengths are unsigned
+ * 16-bit big-endian values and unknown TLVs are skipped.
+ */
+data class NostrCarrierPacket(
+ val direction: Direction,
+ val geohash: String,
+ val eventJson: ByteArray
+) {
+ enum class Direction(val value: Int) {
+ TO_GATEWAY(0x01),
+ FROM_GATEWAY(0x02),
+ TO_BRIDGE(0x03),
+ FROM_BRIDGE(0x04);
+
+ companion object {
+ fun fromValue(value: Int): Direction? = entries.firstOrNull { it.value == value }
+ }
+ }
+
+ init {
+ require(geohash.toByteArray(Charsets.UTF_8).size in 1..MAX_GEOHASH_LENGTH)
+ require(eventJson.size in 1..MAX_EVENT_JSON_BYTES)
+ }
+
+ fun event(): NostrEvent? =
+ NostrEvent.fromJsonString(String(eventJson, Charsets.UTF_8))
+
+ fun encode(): ByteArray {
+ return checkNotNull(
+ Tlv16Codec.encode(
+ Tlv16Codec.Field(TLV_DIRECTION, byteArrayOf(direction.value.toByte())),
+ Tlv16Codec.Field(TLV_GEOHASH, geohash.toByteArray(Charsets.UTF_8)),
+ Tlv16Codec.Field(TLV_EVENT_JSON, eventJson)
+ )
+ )
+ }
+
+ companion object {
+ const val MAX_EVENT_JSON_BYTES = 16 * 1024
+ const val MAX_GEOHASH_LENGTH = 12
+
+ private const val TLV_DIRECTION = 0x01
+ private const val TLV_GEOHASH = 0x02
+ private const val TLV_EVENT_JSON = 0x03
+
+ fun fromEvent(direction: Direction, geohash: String, event: NostrEvent): NostrCarrierPacket? =
+ runCatching {
+ NostrCarrierPacket(
+ direction = direction,
+ geohash = geohash,
+ eventJson = event.toJsonString().toByteArray(Charsets.UTF_8)
+ )
+ }.getOrNull()
+
+ fun decode(data: ByteArray): NostrCarrierPacket? {
+ var direction: Direction? = null
+ var geohash: String? = null
+ var eventJson: ByteArray? = null
+
+ Tlv16Codec.decode(data)?.forEach { field ->
+ when (field.type) {
+ TLV_DIRECTION -> {
+ if (field.value.size != 1) return null
+ direction =
+ Direction.fromValue(field.value[0].toInt() and 0xFF) ?: return null
+ }
+ TLV_GEOHASH -> {
+ geohash = field.value.toString(Charsets.UTF_8)
+ }
+ TLV_EVENT_JSON -> eventJson = field.value
+ }
+ } ?: return null
+
+ return runCatching {
+ NostrCarrierPacket(
+ direction = direction ?: return null,
+ geohash = geohash ?: return null,
+ eventJson = eventJson ?: return null
+ )
+ }.getOrNull()
+ }
+
+ }
+
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is NostrCarrierPacket &&
+ direction == other.direction &&
+ geohash == other.geohash &&
+ eventJson.contentEquals(other.eventJson))
+
+ override fun hashCode(): Int =
+ 31 * (31 * direction.hashCode() + geohash.hashCode()) + eventJson.contentHashCode()
+}
diff --git a/app/src/main/java/com/bitchat/android/model/PeerCapabilities.kt b/app/src/main/java/com/bitchat/android/model/PeerCapabilities.kt
index e64fc390..bf5fb4fe 100644
--- a/app/src/main/java/com/bitchat/android/model/PeerCapabilities.kt
+++ b/app/src/main/java/com/bitchat/android/model/PeerCapabilities.kt
@@ -1,6 +1,7 @@
package com.bitchat.android.model
import android.os.Parcelable
+import com.bitchat.android.protocol.MeshDiagnosticsConstants
import kotlinx.parcelize.Parcelize
/**
@@ -27,27 +28,57 @@ data class PeerCapabilities(val rawValue: Long) : Parcelable {
}
companion object {
+ private const val VOUCH_BIT_INDEX = 5
+ private const val PRIVATE_MEDIA_BIT_INDEX = 8
val NONE = PeerCapabilities(0)
- val PREKEYS = PeerCapabilities(1L shl 0)
val WIFI_BULK = PeerCapabilities(1L shl 1)
val GATEWAY = PeerCapabilities(1L shl 2)
val GROUPS = PeerCapabilities(1L shl 3)
val BOARD = PeerCapabilities(1L shl 4)
- val VOUCH = PeerCapabilities(1L shl 5)
val MESH_DIAGNOSTICS = PeerCapabilities(1L shl 6)
- val BRIDGE = PeerCapabilities(1L shl 7)
/** Noise-encrypted private BitchatFilePacket using payload type 0x20. */
- val PRIVATE_MEDIA = PeerCapabilities(1L shl 8)
+ val PRIVATE_MEDIA = PeerCapabilities(1L shl PRIVATE_MEDIA_BIT_INDEX)
+
+ /** Transitive verification attestations over authenticated Noise. */
+ val VOUCH = PeerCapabilities(1L shl VOUCH_BIT_INDEX)
val PRIVATE_MEDIA_RECEIPTS = PeerCapabilities(1L shl 9)
/** Reserved by iOS; decode it but do not advertise or act on it. */
val NON_DESTRUCTIVE_NOISE_REPLACEMENT = PeerCapabilities(1L shl 10)
+ /** Can bridge public mesh traffic through geohash rendezvous relays. */
+ val BRIDGE = PeerCapabilities(1L shl 7)
+
+ /** Publishes signed one-time prekeys for forward-secret courier mail. */
+ val PREKEYS = PeerCapabilities(1L shl 0)
+
+
/** Capabilities implemented by this Android build. */
- val LOCAL_SUPPORTED = PRIVATE_MEDIA
+ @Deprecated("Use localSupported() so runtime bridge state is included")
+ val LOCAL_SUPPORTED = PeerCapabilities(PRIVATE_MEDIA.rawValue or BOARD.rawValue or VOUCH.rawValue or MESH_DIAGNOSTICS.rawValue)
+
+ @Volatile
+ private var bridgeEnabled: Boolean = false
+ @Volatile private var gatewayEnabled: Boolean = false
+ fun setGatewayEnabled(enabled: Boolean) { gatewayEnabled = enabled }
+
+ @Volatile private var phoneFeaturesEnabled = false
+
+ fun setPhoneFeaturesEnabled(enabled: Boolean) { phoneFeaturesEnabled = enabled }
+
+ fun setBridgeEnabled(enabled: Boolean) {
+ bridgeEnabled = enabled
+ }
+
+ fun localSupported(): PeerCapabilities = PeerCapabilities(
+ LOCAL_SUPPORTED.rawValue or
+ (if (phoneFeaturesEnabled) PREKEYS.rawValue or GROUPS.rawValue or PRIVATE_MEDIA_RECEIPTS.rawValue else 0L) or
+ (if (bridgeEnabled) BRIDGE.rawValue else 0L) or
+ (if (gatewayEnabled) GATEWAY.rawValue else 0L)
+ )
/**
* Decode the low 64 bits and ignore any future extension bytes, which
diff --git a/app/src/main/java/com/bitchat/android/model/PrekeyBundle.kt b/app/src/main/java/com/bitchat/android/model/PrekeyBundle.kt
new file mode 100644
index 00000000..be5d7a81
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/model/PrekeyBundle.kt
@@ -0,0 +1,171 @@
+package com.bitchat.android.model
+
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * Signed batch of one-time Curve25519 keys carried by MessageType.PREKEY_BUNDLE (0x24).
+ *
+ * The canonical signing bytes and TLV representation intentionally match the
+ * iOS BitFoundation implementation byte-for-byte.
+ */
+data class PrekeyBundle(
+ val noiseStaticPublicKey: ByteArray,
+ val prekeys: List,
+ val generatedAt: Long,
+ val signature: ByteArray
+) {
+ data class Prekey(val id: Long, val publicKey: ByteArray) {
+ init {
+ require(id in 0..0xFFFF_FFFFL)
+ require(publicKey.size == KEY_LENGTH)
+ }
+
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is Prekey && id == other.id && publicKey.contentEquals(other.publicKey))
+
+ override fun hashCode(): Int = 31 * id.hashCode() + publicKey.contentHashCode()
+ }
+
+ fun signableBytes(): ByteArray {
+ val output = ByteArrayOutputStream(
+ 1 + SIGNING_CONTEXT.size + KEY_LENGTH + 1 + prekeys.size * PREKEY_ENTRY_LENGTH + Long.SIZE_BYTES
+ )
+ output.write(SIGNING_CONTEXT.size)
+ output.write(SIGNING_CONTEXT)
+ output.write(fixedKey(noiseStaticPublicKey))
+ output.write(prekeys.size.coerceAtMost(0xFF))
+ prekeys.take(0xFF).forEach { prekey ->
+ output.write(uint32Bytes(prekey.id))
+ output.write(fixedKey(prekey.publicKey))
+ }
+ output.write(uint64Bytes(generatedAt))
+ return output.toByteArray()
+ }
+
+ fun encode(): ByteArray? {
+ if (noiseStaticPublicKey.size != KEY_LENGTH ||
+ signature.size != SIGNATURE_LENGTH ||
+ prekeys.isEmpty() ||
+ prekeys.size > MAX_PREKEYS ||
+ prekeys.map { it.id }.distinct().size != prekeys.size
+ ) {
+ return null
+ }
+
+ val entries = ByteArrayOutputStream(prekeys.size * PREKEY_ENTRY_LENGTH)
+ prekeys.forEach { prekey ->
+ if (prekey.publicKey.size != KEY_LENGTH || prekey.id !in 0..0xFFFF_FFFFL) return null
+ entries.write(uint32Bytes(prekey.id))
+ entries.write(prekey.publicKey)
+ }
+
+ return Tlv16Codec.encode(
+ Tlv16Codec.Field(TLV_NOISE_STATIC_KEY, noiseStaticPublicKey),
+ Tlv16Codec.Field(TLV_PREKEYS, entries.toByteArray()),
+ Tlv16Codec.Field(TLV_GENERATED_AT, uint64Bytes(generatedAt)),
+ Tlv16Codec.Field(TLV_SIGNATURE, signature)
+ )
+ }
+
+ companion object {
+ const val KEY_LENGTH = 32
+ const val SIGNATURE_LENGTH = 64
+ const val MAX_PREKEYS = 8
+ private const val PREKEY_ENTRY_LENGTH = 4 + KEY_LENGTH
+
+ private val SIGNING_CONTEXT = "bitchat-prekey-bundle-v1".toByteArray(Charsets.UTF_8)
+ private const val TLV_NOISE_STATIC_KEY = 0x01
+ private const val TLV_PREKEYS = 0x02
+ private const val TLV_GENERATED_AT = 0x03
+ private const val TLV_SIGNATURE = 0x04
+
+ fun decode(data: ByteArray): PrekeyBundle? {
+ var noiseStaticKey: ByteArray? = null
+ var prekeys: List? = null
+ var generatedAt: Long? = null
+ var signature: ByteArray? = null
+
+ Tlv16Codec.decode(data)?.forEach { field ->
+ when (field.type) {
+ TLV_NOISE_STATIC_KEY -> {
+ if (field.value.size != KEY_LENGTH) return null
+ noiseStaticKey = field.value
+ }
+ TLV_PREKEYS -> {
+ if (field.value.isEmpty() ||
+ field.value.size % PREKEY_ENTRY_LENGTH != 0 ||
+ field.value.size / PREKEY_ENTRY_LENGTH > MAX_PREKEYS
+ ) {
+ return null
+ }
+ val parsed = mutableListOf()
+ var entryOffset = 0
+ while (entryOffset < field.value.size) {
+ val id = ByteBuffer.wrap(field.value, entryOffset, Int.SIZE_BYTES)
+ .order(ByteOrder.BIG_ENDIAN)
+ .int.toLong() and 0xFFFF_FFFFL
+ entryOffset += Int.SIZE_BYTES
+ val publicKey =
+ field.value.copyOfRange(entryOffset, entryOffset + KEY_LENGTH)
+ entryOffset += KEY_LENGTH
+ parsed += Prekey(id, publicKey)
+ }
+ if (parsed.map { it.id }.distinct().size != parsed.size) return null
+ prekeys = parsed
+ }
+ TLV_GENERATED_AT -> {
+ if (field.value.size != Long.SIZE_BYTES) return null
+ generatedAt = ByteBuffer.wrap(field.value).order(ByteOrder.BIG_ENDIAN).long
+ }
+ TLV_SIGNATURE -> {
+ if (field.value.size != SIGNATURE_LENGTH) return null
+ signature = field.value
+ }
+ }
+ } ?: return null
+
+ return runCatching {
+ PrekeyBundle(
+ noiseStaticPublicKey = noiseStaticKey ?: return null,
+ prekeys = prekeys?.takeIf { it.isNotEmpty() } ?: return null,
+ generatedAt = generatedAt ?: return null,
+ signature = signature ?: return null
+ )
+ }.getOrNull()
+ }
+
+ private fun uint32Bytes(value: Long): ByteArray =
+ ByteBuffer.allocate(Int.SIZE_BYTES)
+ .order(ByteOrder.BIG_ENDIAN)
+ .putInt(value.toInt())
+ .array()
+
+ private fun uint64Bytes(value: Long): ByteArray =
+ ByteBuffer.allocate(Long.SIZE_BYTES)
+ .order(ByteOrder.BIG_ENDIAN)
+ .putLong(value)
+ .array()
+
+ private fun fixedKey(key: ByteArray): ByteArray =
+ key.copyOf(KEY_LENGTH)
+ }
+
+ override fun equals(other: Any?): Boolean =
+ this === other ||
+ (other is PrekeyBundle &&
+ noiseStaticPublicKey.contentEquals(other.noiseStaticPublicKey) &&
+ prekeys == other.prekeys &&
+ generatedAt == other.generatedAt &&
+ signature.contentEquals(other.signature))
+
+ override fun hashCode(): Int {
+ var result = noiseStaticPublicKey.contentHashCode()
+ result = 31 * result + prekeys.hashCode()
+ result = 31 * result + generatedAt.hashCode()
+ result = 31 * result + signature.contentHashCode()
+ return result
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/model/PrivateMediaMessageIdentity.kt b/app/src/main/java/com/bitchat/android/model/PrivateMediaMessageIdentity.kt
new file mode 100644
index 00000000..5b2fdc6d
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/model/PrivateMediaMessageIdentity.kt
@@ -0,0 +1,38 @@
+package com.bitchat.android.model
+
+import java.io.ByteArrayOutputStream
+import java.nio.ByteBuffer
+import java.security.MessageDigest
+
+/** Stable, direction-bound IDs matching the iOS private-media receipt contract. */
+object PrivateMediaMessageIdentity {
+ private val stable = Regex("media-[0-9a-f]{32}")
+ private val uuid = Regex("[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}")
+ private val peer = Regex("[0-9a-f]{16}")
+
+ fun isStableID(value: String): Boolean = stable.matches(value)
+
+ fun stableID(senderPeerID: String, recipientPeerID: String, fileName: String?): String? {
+ if (fileName.isNullOrEmpty() || '/' in fileName || '\\' in fileName) return null
+ val sender = senderPeerID.lowercase()
+ val recipient = recipientPeerID.lowercase()
+ if (!peer.matches(sender) || !peer.matches(recipient)) return null
+ val stem = fileName.substringBeforeLast('.', fileName)
+ val extension = fileName.substringAfterLast('.', "").lowercase()
+ val isVoice = stem.startsWith("voice_") && extension == "m4a"
+ val isImage = stem.startsWith("img_") && extension in setOf("jpg", "jpeg")
+ if (!isVoice && !isImage) return null
+ val burst = stem.removePrefix("voice_")
+ if (!uuid.matches(stem.substringAfterLast('_')) &&
+ !(isVoice && Regex("[0-9a-fA-F]{16}").matches(burst))) return null
+ val input = ByteArrayOutputStream()
+ input.write("bitchat-private-media-message-v1".toByteArray(Charsets.UTF_8))
+ listOf(sender, recipient, fileName).forEach { field ->
+ val bytes = field.toByteArray(Charsets.UTF_8)
+ input.write(ByteBuffer.allocate(4).putInt(bytes.size).array())
+ input.write(bytes)
+ }
+ return "media-" + MessageDigest.getInstance("SHA-256").digest(input.toByteArray())
+ .take(16).joinToString("") { "%02x".format(it) }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt b/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt
index ab52f071..f7c448ba 100644
--- a/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt
+++ b/app/src/main/java/com/bitchat/android/model/RequestSyncPacket.kt
@@ -1,6 +1,8 @@
package com.bitchat.android.model
import com.bitchat.android.sync.SyncDefaults
+import com.bitchat.android.sync.GCSFilter
+import com.bitchat.android.sync.SyncTypeFlags
/**
* REQUEST_SYNC payload using GCS (Golomb-Coded Set) parameters.
@@ -8,11 +10,15 @@ import com.bitchat.android.sync.SyncDefaults
* - 0x01: P (uint8) — Golomb-Rice parameter
* - 0x02: M (uint32, big-endian) — hash range (N * 2^P)
* - 0x03: data (opaque) — GR bitstream bytes
+ * - 0x04: types (compact little-endian SyncTypeFlags) — packet types covered by the filter
+ * - 0x05: sinceTimestamp (uint64, big-endian) — oldest timestamp covered by the filter
*/
data class RequestSyncPacket(
val p: Int,
val m: Long,
- val data: ByteArray
+ val data: ByteArray,
+ val types: SyncTypeFlags? = null,
+ val sinceTimestamp: ULong? = null
) {
fun encode(): ByteArray {
val out = ArrayList()
@@ -38,6 +44,15 @@ data class RequestSyncPacket(
)
// data
putTLV(0x03, data)
+ types?.encode()?.let { putTLV(0x04, it) }
+ sinceTimestamp?.let { timestamp ->
+ putTLV(
+ 0x05,
+ ByteArray(8) { index ->
+ (timestamp shr ((7 - index) * 8) and 0xffu).toByte()
+ }
+ )
+ }
return out.toByteArray()
}
@@ -50,6 +65,8 @@ data class RequestSyncPacket(
var p: Int? = null
var m: Long? = null
var payload: ByteArray? = null
+ var types: SyncTypeFlags? = null
+ var sinceTimestamp: ULong? = null
while (off + 3 <= data.size) {
val t = (data[off].toInt() and 0xFF); off += 1
@@ -69,14 +86,20 @@ data class RequestSyncPacket(
if (v.size > MAX_ACCEPT_FILTER_BYTES) return null
payload = v
}
+ 0x04 -> SyncTypeFlags.decode(v)?.let { types = it }
+ 0x05 -> if (v.size == 8) {
+ var timestamp = 0uL
+ v.forEach { byte -> timestamp = (timestamp shl 8) or byte.toUByte().toULong() }
+ sinceTimestamp = timestamp
+ }
}
}
val pp = p ?: return null
val mm = m ?: return null
val dd = payload ?: return null
- if (pp < 1 || mm <= 0L) return null
- return RequestSyncPacket(pp, mm, dd)
+ if (pp !in 1..GCSFilter.MAX_P || mm <= 0L) return null
+ return RequestSyncPacket(pp, mm, dd, types, sinceTimestamp)
}
}
}
diff --git a/app/src/main/java/com/bitchat/android/model/Tlv16Codec.kt b/app/src/main/java/com/bitchat/android/model/Tlv16Codec.kt
new file mode 100644
index 00000000..4cc2783e
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/model/Tlv16Codec.kt
@@ -0,0 +1,47 @@
+package com.bitchat.android.model
+
+import java.io.ByteArrayOutputStream
+
+/**
+ * Minimal unsigned 16-bit big-endian TLV codec used by bridge wire models.
+ *
+ * Semantic validation intentionally remains in each model. This helper only
+ * owns framing so every decoder rejects truncated and trailing data the same
+ * way.
+ */
+internal object Tlv16Codec {
+ data class Field(val type: Int, val value: ByteArray)
+
+ fun encode(vararg fields: Field): ByteArray? {
+ val output = ByteArrayOutputStream(
+ fields.sumOf { HEADER_SIZE + it.value.size }
+ )
+ fields.forEach { field ->
+ if (field.type !in 0..0xFF || field.value.size > 0xFFFF) return null
+ output.write(field.type)
+ output.write((field.value.size ushr 8) and 0xFF)
+ output.write(field.value.size and 0xFF)
+ output.write(field.value)
+ }
+ return output.toByteArray()
+ }
+
+ fun decode(data: ByteArray): List? {
+ val fields = mutableListOf()
+ var offset = 0
+ while (offset < data.size) {
+ if (data.size - offset < HEADER_SIZE) return null
+ val type = data[offset].toInt() and 0xFF
+ val length =
+ ((data[offset + 1].toInt() and 0xFF) shl 8) or
+ (data[offset + 2].toInt() and 0xFF)
+ offset += HEADER_SIZE
+ if (length > data.size - offset) return null
+ fields += Field(type, data.copyOfRange(offset, offset + length))
+ offset += length
+ }
+ return fields
+ }
+
+ private const val HEADER_SIZE = 3
+}
diff --git a/app/src/main/java/com/bitchat/android/model/VouchAttestation.kt b/app/src/main/java/com/bitchat/android/model/VouchAttestation.kt
new file mode 100644
index 00000000..9987cc15
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/model/VouchAttestation.kt
@@ -0,0 +1,193 @@
+package com.bitchat.android.model
+
+import java.io.ByteArrayOutputStream
+
+/**
+ * An iOS-compatible, Ed25519-signed statement that the sender of the enclosing
+ * authenticated Noise payload verified [voucheeFingerprint].
+ */
+data class VouchAttestation(
+ val voucheeFingerprint: ByteArray,
+ val voucheeSigningKey: ByteArray,
+ val timestampMs: Long,
+ val signature: ByteArray
+) {
+ init {
+ require(voucheeFingerprint.size == FINGERPRINT_SIZE)
+ require(voucheeSigningKey.size == SIGNING_KEY_SIZE)
+ require(signature.size == SIGNATURE_SIZE)
+ }
+
+ fun signableBytes(): ByteArray = signableBytes(
+ voucheeFingerprint,
+ voucheeSigningKey,
+ timestampMs
+ )
+
+ fun isExpired(nowMs: Long = System.currentTimeMillis()): Boolean {
+ val age = nowMs - timestampMs
+ return age > MAX_AGE_MS || age < -MAX_CLOCK_SKEW_MS
+ }
+
+ fun encode(): ByteArray {
+ val output = ByteArrayOutputStream()
+ output.writeTlv(TYPE_FINGERPRINT, voucheeFingerprint)
+ output.writeTlv(TYPE_SIGNING_KEY, voucheeSigningKey)
+ output.writeTlv(TYPE_TIMESTAMP, timestampBytes(timestampMs))
+ output.writeTlv(TYPE_SIGNATURE, signature)
+ return output.toByteArray()
+ }
+
+ override fun equals(other: Any?): Boolean =
+ other is VouchAttestation &&
+ voucheeFingerprint.contentEquals(other.voucheeFingerprint) &&
+ voucheeSigningKey.contentEquals(other.voucheeSigningKey) &&
+ timestampMs == other.timestampMs &&
+ signature.contentEquals(other.signature)
+
+ override fun hashCode(): Int {
+ var result = voucheeFingerprint.contentHashCode()
+ result = HASH_MULTIPLIER * result + voucheeSigningKey.contentHashCode()
+ result = HASH_MULTIPLIER * result + timestampMs.hashCode()
+ return HASH_MULTIPLIER * result + signature.contentHashCode()
+ }
+
+ companion object {
+ const val MAX_BATCH_COUNT = 16
+ const val FINGERPRINT_SIZE = 32
+ const val SIGNING_KEY_SIZE = 32
+ const val SIGNATURE_SIZE = 64
+ private const val DAYS_VALID = 30L
+ private const val HOURS_PER_DAY = 24L
+ private const val MINUTES_PER_HOUR = 60L
+ private const val SECONDS_PER_MINUTE = 60L
+ private const val MILLIS_PER_SECOND = 1000L
+ const val MAX_AGE_MS =
+ DAYS_VALID * HOURS_PER_DAY * MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLIS_PER_SECOND
+ const val MAX_CLOCK_SKEW_MS =
+ MINUTES_PER_HOUR * SECONDS_PER_MINUTE * MILLIS_PER_SECOND
+
+ private const val SIGNING_CONTEXT = "bitchat-vouch-v1"
+ private const val TYPE_FINGERPRINT = 0x01
+ private const val TYPE_SIGNING_KEY = 0x02
+ private const val TYPE_TIMESTAMP = 0x03
+ private const val TYPE_SIGNATURE = 0x04
+ private const val TLV_HEADER_SIZE = 2
+ private const val TLV_LENGTH_SIZE = 1
+ private const val BATCH_COUNT_SIZE = 1
+ private const val BATCH_ENTRY_LENGTH_SIZE = 2
+ private const val BITS_PER_BYTE = 8
+ private const val BYTE_MASK = 0xFF
+ private const val UINT16_MAX = 0xFFFF
+ private const val INITIAL_OFFSET = 0
+ private const val INITIAL_TIMESTAMP = 0L
+ private const val MINIMUM_TIMESTAMP_MS = 0L
+ private const val INITIAL_ENTRY_COUNT = 0
+ private const val HASH_MULTIPLIER = 31
+ private const val TIMESTAMP_LENGTH = Long.SIZE_BYTES
+
+ fun build(
+ voucheeFingerprint: ByteArray,
+ voucheeSigningKey: ByteArray,
+ timestampMs: Long = System.currentTimeMillis(),
+ sign: (ByteArray) -> ByteArray?
+ ): VouchAttestation? {
+ if (voucheeFingerprint.size != FINGERPRINT_SIZE ||
+ voucheeSigningKey.size != SIGNING_KEY_SIZE
+ ) return null
+ val signature = sign(signableBytes(voucheeFingerprint, voucheeSigningKey, timestampMs))
+ ?: return null
+ if (signature.size != SIGNATURE_SIZE) return null
+ return VouchAttestation(voucheeFingerprint, voucheeSigningKey, timestampMs, signature)
+ }
+
+ fun signableBytes(
+ voucheeFingerprint: ByteArray,
+ voucheeSigningKey: ByteArray,
+ timestampMs: Long
+ ): ByteArray = SIGNING_CONTEXT.toByteArray(Charsets.UTF_8) +
+ voucheeFingerprint + voucheeSigningKey + timestampBytes(timestampMs)
+
+ fun decode(data: ByteArray): VouchAttestation? {
+ var offset = INITIAL_OFFSET
+ var fingerprint: ByteArray? = null
+ var signingKey: ByteArray? = null
+ var timestamp: Long? = null
+ var signature: ByteArray? = null
+ while (offset < data.size) {
+ if (offset + TLV_HEADER_SIZE > data.size) return null
+ val type = data[offset++].toInt() and BYTE_MASK
+ val length = data[offset++].toInt() and BYTE_MASK
+ if (offset + length > data.size) return null
+ val value = data.copyOfRange(offset, offset + length)
+ offset += length
+ when (type) {
+ TYPE_FINGERPRINT -> if (length == FINGERPRINT_SIZE) fingerprint = value else return null
+ TYPE_SIGNING_KEY -> if (length == SIGNING_KEY_SIZE) signingKey = value else return null
+ TYPE_TIMESTAMP -> if (length == TIMESTAMP_LENGTH) {
+ val decodedTimestamp = value.fold(INITIAL_TIMESTAMP) { result, byte ->
+ (result shl BITS_PER_BYTE) or (byte.toLong() and BYTE_MASK.toLong())
+ }
+ if (decodedTimestamp < MINIMUM_TIMESTAMP_MS) return null
+ timestamp = decodedTimestamp
+ } else return null
+ TYPE_SIGNATURE -> if (length == SIGNATURE_SIZE) signature = value else return null
+ }
+ }
+ return VouchAttestation(
+ fingerprint ?: return null,
+ signingKey ?: return null,
+ timestamp ?: return null,
+ signature ?: return null
+ )
+ }
+
+ fun encodeList(attestations: List): ByteArray? {
+ if (attestations.isEmpty() || attestations.size > MAX_BATCH_COUNT) return null
+ val output = ByteArrayOutputStream()
+ output.write(attestations.size)
+ attestations.forEach { attestation ->
+ val encoded = attestation.encode()
+ if (encoded.size > UINT16_MAX) return null
+ output.write(encoded.size ushr BITS_PER_BYTE)
+ output.write(encoded.size and BYTE_MASK)
+ output.write(encoded)
+ }
+ return output.toByteArray()
+ }
+
+ fun decodeList(data: ByteArray): List {
+ if (data.size <= BATCH_COUNT_SIZE) return emptyList()
+ val limit = minOf(data[0].toInt() and BYTE_MASK, MAX_BATCH_COUNT)
+ val decoded = mutableListOf()
+ var offset = BATCH_COUNT_SIZE
+ var entriesRead = INITIAL_ENTRY_COUNT
+ while (entriesRead < limit && offset < data.size) {
+ if (offset + BATCH_ENTRY_LENGTH_SIZE > data.size) break
+ val length = ((data[offset].toInt() and BYTE_MASK) shl BITS_PER_BYTE) or
+ (data[offset + TLV_LENGTH_SIZE].toInt() and BYTE_MASK)
+ offset += BATCH_ENTRY_LENGTH_SIZE
+ if (offset + length > data.size) break
+ decode(data.copyOfRange(offset, offset + length))?.let(decoded::add)
+ offset += length
+ entriesRead++
+ }
+ return decoded
+ }
+
+ private const val LAST_BYTE_INDEX_OFFSET = 1
+ private const val TIMESTAMP_HIGH_BIT_OFFSET =
+ (TIMESTAMP_LENGTH - LAST_BYTE_INDEX_OFFSET) * BITS_PER_BYTE
+
+ private fun timestampBytes(timestampMs: Long): ByteArray =
+ ByteArray(TIMESTAMP_LENGTH) { index ->
+ (timestampMs ushr (TIMESTAMP_HIGH_BIT_OFFSET - index * BITS_PER_BYTE)).toByte()
+ }
+
+ private fun ByteArrayOutputStream.writeTlv(type: Int, value: ByteArray) {
+ write(type)
+ write(value.size)
+ write(value)
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/noise/CourierNoiseCrypto.kt b/app/src/main/java/com/bitchat/android/noise/CourierNoiseCrypto.kt
new file mode 100644
index 00000000..f734cccc
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/noise/CourierNoiseCrypto.kt
@@ -0,0 +1,121 @@
+package com.bitchat.android.noise
+
+import com.bitchat.android.noise.southernstorm.protocol.HandshakeState
+import com.bitchat.android.noise.southernstorm.protocol.Noise
+
+/**
+ * One-message Noise X helper used by iOS-compatible courier envelopes.
+ *
+ * Protocol: Noise_X_25519_ChaChaPoly_SHA256
+ * Prologue: "bitchat-courier-v1"
+ */
+object CourierNoiseCrypto {
+ private const val PROTOCOL_NAME = "Noise_X_25519_ChaChaPoly_SHA256"
+ private val COURIER_PROLOGUE = "bitchat-courier-v1".toByteArray(Charsets.UTF_8)
+ private val PREKEY_PROLOGUE_PREFIX = "bitchat-prekey-v1".toByteArray(Charsets.UTF_8)
+ private const val X_OVERHEAD_BYTES = 32 + 48 + 16
+
+ data class Opened(val payload: ByteArray, val senderStaticKey: ByteArray)
+
+ fun seal(
+ payload: ByteArray,
+ senderStaticPrivateKey: ByteArray,
+ recipientStaticPublicKey: ByteArray
+ ): ByteArray = sealWithPrologue(
+ payload,
+ senderStaticPrivateKey,
+ recipientStaticPublicKey,
+ COURIER_PROLOGUE
+ )
+
+ fun sealToPrekey(
+ payload: ByteArray,
+ senderStaticPrivateKey: ByteArray,
+ recipientPrekey: com.bitchat.android.model.PrekeyBundle.Prekey
+ ): ByteArray = sealWithPrologue(
+ payload,
+ senderStaticPrivateKey,
+ recipientPrekey.publicKey,
+ prekeyPrologue(recipientPrekey.id)
+ )
+
+ private fun sealWithPrologue(
+ payload: ByteArray,
+ senderStaticPrivateKey: ByteArray,
+ recipientStaticPublicKey: ByteArray,
+ prologue: ByteArray
+ ): ByteArray {
+ require(senderStaticPrivateKey.size == 32)
+ require(recipientStaticPublicKey.size == 32)
+ val handshake = HandshakeState(PROTOCOL_NAME, HandshakeState.INITIATOR)
+ return try {
+ handshake.setPrologue(prologue, 0, prologue.size)
+ handshake.getLocalKeyPair().setPrivateKey(senderStaticPrivateKey, 0)
+ handshake.getRemotePublicKey().setPublicKey(recipientStaticPublicKey, 0)
+ handshake.start()
+ val message = ByteArray(payload.size + X_OVERHEAD_BYTES)
+ val length = handshake.writeMessage(message, 0, payload, 0, payload.size)
+ message.copyOf(length)
+ } finally {
+ handshake.destroy()
+ }
+ }
+
+ fun open(
+ ciphertext: ByteArray,
+ recipientStaticPrivateKey: ByteArray
+ ): Opened = openWithPrologue(ciphertext, recipientStaticPrivateKey, COURIER_PROLOGUE)
+
+ fun openWithPrekey(
+ ciphertext: ByteArray,
+ recipientPrekeyPrivateKey: ByteArray,
+ prekeyId: Long
+ ): Opened = openWithPrologue(
+ ciphertext,
+ recipientPrekeyPrivateKey,
+ prekeyPrologue(prekeyId)
+ )
+
+ private fun openWithPrologue(
+ ciphertext: ByteArray,
+ recipientStaticPrivateKey: ByteArray,
+ prologue: ByteArray
+ ): Opened {
+ require(recipientStaticPrivateKey.size == 32)
+ val handshake = HandshakeState(PROTOCOL_NAME, HandshakeState.RESPONDER)
+ return try {
+ handshake.setPrologue(prologue, 0, prologue.size)
+ handshake.getLocalKeyPair().setPrivateKey(recipientStaticPrivateKey, 0)
+ handshake.start()
+ val payload = ByteArray(ciphertext.size)
+ val length = handshake.readMessage(ciphertext, 0, ciphertext.size, payload, 0)
+ val senderKey = ByteArray(handshake.getRemotePublicKey().publicKeyLength)
+ handshake.getRemotePublicKey().getPublicKey(senderKey, 0)
+ Opened(payload.copyOf(length), senderKey)
+ } finally {
+ handshake.destroy()
+ }
+ }
+
+ /** Test/support helper that derives the X25519 public key used on the wire. */
+ fun publicKey(privateKey: ByteArray): ByteArray {
+ require(privateKey.size == 32)
+ val key = Noise.createDH("25519")
+ return try {
+ key.setPrivateKey(privateKey, 0)
+ ByteArray(key.publicKeyLength).also { key.getPublicKey(it, 0) }
+ } finally {
+ key.destroy()
+ }
+ }
+
+ private fun prekeyPrologue(prekeyId: Long): ByteArray {
+ require(prekeyId in 0..0xFFFF_FFFFL)
+ return PREKEY_PROLOGUE_PREFIX + byteArrayOf(
+ (prekeyId ushr 24).toByte(),
+ (prekeyId ushr 16).toByte(),
+ (prekeyId ushr 8).toByte(),
+ prekeyId.toByte()
+ )
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/noise/NoiseEncryptionService.kt b/app/src/main/java/com/bitchat/android/noise/NoiseEncryptionService.kt
index 909ca82b..254a7b62 100644
--- a/app/src/main/java/com/bitchat/android/noise/NoiseEncryptionService.kt
+++ b/app/src/main/java/com/bitchat/android/noise/NoiseEncryptionService.kt
@@ -5,6 +5,7 @@ import android.util.Log
import com.bitchat.android.identity.SecureIdentityStateManager
import com.bitchat.android.mesh.PeerFingerprintManager
import com.bitchat.android.noise.southernstorm.protocol.Noise
+import com.bitchat.android.noise.southernstorm.protocol.HandshakeState
import java.security.MessageDigest
import java.security.SecureRandom
import java.util.concurrent.ConcurrentHashMap
@@ -18,7 +19,10 @@ import java.util.concurrent.ConcurrentHashMap
* - Channel encryption using password-derived keys
* - Peer fingerprint mapping and identity persistence
*/
-class NoiseEncryptionService(private val context: Context) {
+class NoiseEncryptionService(
+ private val context: Context,
+ private val identityStateManager: SecureIdentityStateManager = SecureIdentityStateManager(context)
+) {
companion object {
private const val TAG = "NoiseEncryptionService"
@@ -42,9 +46,6 @@ class NoiseEncryptionService(private val context: Context) {
// Channel encryption for password-protected channels
private val channelEncryption = NoiseChannelEncryption()
- // Identity management for peer ID rotation support
- private val identityStateManager: SecureIdentityStateManager
-
// Centralized fingerprint management - NO LOCAL STORAGE
private val fingerprintManager = PeerFingerprintManager.getInstance()
@@ -53,9 +54,6 @@ class NoiseEncryptionService(private val context: Context) {
var onHandshakeRequired: ((String) -> Unit)? = null // peerID needs handshake
init {
- // Initialize identity state manager for persistent storage
- identityStateManager = SecureIdentityStateManager(context)
-
// Load or create keys - temporary placeholders
staticIdentityPrivateKey = ByteArray(32)
staticIdentityPublicKey = ByteArray(32)
@@ -147,6 +145,40 @@ class NoiseEncryptionService(private val context: Context) {
return sessionManager.getRemoteStaticKey(peerID)
}
+ fun sealCourierPayload(payload: ByteArray, recipientStaticKey: ByteArray): ByteArray {
+ require(recipientStaticKey.size == 32 && recipientStaticKey.any { it != 0.toByte() })
+ val state = HandshakeState("Noise_X_25519_ChaChaPoly_SHA256", HandshakeState.INITIATOR)
+ return try {
+ state.getLocalKeyPair().setPrivateKey(staticIdentityPrivateKey, 0)
+ state.getRemotePublicKey().setPublicKey(recipientStaticKey, 0)
+ val prologue = "bitchat-courier-v1".toByteArray(Charsets.UTF_8)
+ state.setPrologue(prologue, 0, prologue.size)
+ state.start()
+ val output = ByteArray(payload.size + 128)
+ output.copyOf(state.writeMessage(output, 0, payload, 0, payload.size))
+ } finally {
+ state.destroy()
+ }
+ }
+
+ fun openCourierPayload(ciphertext: ByteArray): Pair {
+ require(ciphertext.size >= 96)
+ val state = HandshakeState("Noise_X_25519_ChaChaPoly_SHA256", HandshakeState.RESPONDER)
+ return try {
+ state.getLocalKeyPair().setPrivateKey(staticIdentityPrivateKey, 0)
+ val prologue = "bitchat-courier-v1".toByteArray(Charsets.UTF_8)
+ state.setPrologue(prologue, 0, prologue.size)
+ state.start()
+ val payload = ByteArray(ciphertext.size)
+ val length = state.readMessage(ciphertext, 0, ciphertext.size, payload, 0)
+ val senderKey = ByteArray(32)
+ state.getRemotePublicKey().getPublicKey(senderKey, 0)
+ senderKey to payload.copyOf(length)
+ } finally {
+ state.destroy()
+ }
+ }
+
fun getAuthenticatedSession(peerID: String): AuthenticatedNoiseSession? =
sessionManager.getAuthenticatedSession(peerID)
diff --git a/app/src/main/java/com/bitchat/android/nostr/BridgeCourierService.kt b/app/src/main/java/com/bitchat/android/nostr/BridgeCourierService.kt
new file mode 100644
index 00000000..160ac30c
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/nostr/BridgeCourierService.kt
@@ -0,0 +1,253 @@
+package com.bitchat.android.nostr
+
+import android.content.Context
+import android.util.Base64
+import com.bitchat.android.crypto.EncryptionService
+import com.bitchat.android.model.CourierEnvelope
+import java.util.Collections
+import java.util.LinkedHashMap
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.isActive
+import kotlinx.coroutines.launch
+
+/**
+ * Minimal relay surface used by the bridge courier.
+ *
+ * Keeping this adapter boundary small lets the kind-1401 contract be exercised with a
+ * deterministic in-memory relay in unit tests, without opening a network connection.
+ */
+internal interface BridgeCourierRelay {
+ fun subscribe(
+ filter: NostrFilter,
+ id: String,
+ targetRelayUrls: List,
+ handler: (NostrEvent) -> Unit
+ )
+
+ fun unsubscribe(id: String)
+
+ fun hasConnectedRelay(relayUrls: Collection): Boolean
+
+ fun sendEvent(
+ event: NostrEvent,
+ relayUrls: List,
+ onAccepted: () -> Unit
+ ): Boolean
+}
+
+internal interface BridgeCourierCipher {
+ fun staticPublicKey(): ByteArray?
+
+ fun seal(payload: ByteArray, recipientNoiseKey: ByteArray): ByteArray
+
+ fun sealWithPrekey(payload: ByteArray, recipientNoiseKey: ByteArray): Pair =
+ seal(payload, recipientNoiseKey) to null
+}
+
+private class NostrBridgeCourierRelay(
+ private val relayManager: NostrRelayManager
+) : BridgeCourierRelay {
+ override fun subscribe(
+ filter: NostrFilter,
+ id: String,
+ targetRelayUrls: List,
+ handler: (NostrEvent) -> Unit
+ ) {
+ relayManager.subscribe(
+ filter = filter,
+ id = id,
+ targetRelayUrls = targetRelayUrls,
+ handler = handler
+ )
+ }
+
+ override fun unsubscribe(id: String) {
+ relayManager.unsubscribe(id)
+ }
+
+ override fun hasConnectedRelay(relayUrls: Collection): Boolean =
+ relayManager.hasConnectedRelay(relayUrls)
+
+ override fun sendEvent(
+ event: NostrEvent,
+ relayUrls: List,
+ onAccepted: () -> Unit
+ ): Boolean = relayManager.sendEvent(event, relayUrls, onAccepted = onAccepted,
+ publicationAllowed = com.bitchat.android.services.bridge.MeshBridgeService.publicationPermit())
+}
+
+private class EncryptionBridgeCourierCipher(
+ private val encryptionService: EncryptionService,
+ private val prekeys: com.bitchat.android.services.bridge.PrekeyManager
+) : BridgeCourierCipher {
+ override fun staticPublicKey(): ByteArray? = encryptionService.getStaticPublicKey()
+
+ override fun seal(payload: ByteArray, recipientNoiseKey: ByteArray): ByteArray =
+ encryptionService.sealCourierPayload(payload, recipientNoiseKey)
+
+ override fun sealWithPrekey(payload: ByteArray, recipientNoiseKey: ByteArray): Pair {
+ val id = java.security.MessageDigest.getInstance("SHA-256").digest(payload)
+ .joinToString("") { "%02x".format(it) }
+ val sealed = prekeys.seal(payload, id, recipientNoiseKey, recipientAdvertisesPrekeys = true)
+ return sealed.ciphertext to sealed.prekeyId?.toUInt()
+ }
+}
+
+/** Parks opaque courier envelopes on default Nostr relays using the iOS kind-1401 contract. */
+class BridgeCourierService internal constructor(
+ private val cipher: BridgeCourierCipher,
+ private val onEnvelope: (CourierEnvelope) -> Unit,
+ private val relayManager: BridgeCourierRelay,
+ private val relayUrls: List = NostrRelayManager.defaultRelays(),
+ private val clock: () -> Long = System::currentTimeMillis,
+ private val identityFactory: () -> NostrIdentity = NostrIdentity::generate,
+ private val enabled: () -> Boolean = { true }
+) {
+ constructor(
+ context: Context,
+ encryptionService: EncryptionService,
+ onEnvelope: (CourierEnvelope) -> Unit
+ ) : this(
+ cipher = EncryptionBridgeCourierCipher(encryptionService, com.bitchat.android.services.bridge.PrekeyManager.getInstance(context)),
+ onEnvelope = onEnvelope,
+ relayManager = NostrBridgeCourierRelay(
+ NostrRelayManager.getInstance(context.applicationContext)
+ ),
+ enabled = { com.bitchat.android.services.bridge.MeshBridgeService.isEnabled.value }
+ )
+
+ companion object {
+ private const val KIND = 1401
+ private const val MAX_ENCODED_BYTES = 20 * 1024
+ private const val TAG_REFRESH_INTERVAL_MS = 60 * 60 * 1000L
+ }
+
+ private val seenEvents = Collections.synchronizedMap(
+ object : LinkedHashMap(512, 0.75f, true) {
+ override fun removeEldestEntry(eldest: MutableMap.MutableEntry?) = size > 512
+ }
+ )
+ private val subscriptionID = "bridge-courier-drops-${System.identityHashCode(this)}"
+ @Volatile private var subscribedDay: UInt? = null
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+ private var refreshJob: Job? = null
+ val isStarted: Boolean get() = subscribedDay != null
+
+ @Synchronized
+ fun start() {
+ if (!enabled()) return
+ val localKey = cipher.staticPublicKey() ?: ByteArray(0)
+ if (localKey.size == 32) {
+ val now = clock()
+ val day = CourierEnvelope.epochDay(now)
+ if (subscribedDay == day) return
+ if (subscribedDay != null) relayManager.unsubscribe(subscriptionID)
+ val tags = listOf(day - 1u, day, day + 1u).map {
+ CourierEnvelope.recipientTag(localKey, it).toHex()
+ }
+ val filter = NostrFilter.Builder()
+ .kinds(KIND)
+ .since(now - CourierEnvelope.MAX_LIFETIME_MS)
+ .limit(100)
+ .tag("x", *tags.toTypedArray())
+ .build()
+ relayManager.subscribe(
+ filter = filter,
+ id = subscriptionID,
+ targetRelayUrls = relayUrls,
+ handler = ::handleEvent
+ )
+ subscribedDay = day
+ if (refreshJob?.isActive != true) {
+ refreshJob = scope.launch {
+ while (isActive) {
+ delay(TAG_REFRESH_INTERVAL_MS)
+ start()
+ }
+ }
+ }
+ }
+ }
+
+ fun deposit(
+ content: String,
+ messageID: String,
+ recipientNoiseKey: ByteArray,
+ onAccepted: () -> Unit = {}
+ ): Boolean {
+ val privateMessage = com.bitchat.android.model.PrivateMessagePacket(messageID, content).encode() ?: return false
+ val typed = com.bitchat.android.model.NoisePayload(
+ com.bitchat.android.model.NoisePayloadType.PRIVATE_MESSAGE,
+ privateMessage
+ ).encode()
+ return depositPayload(typed, recipientNoiseKey, onAccepted)
+ }
+
+ fun depositPayload(
+ typedPayload: ByteArray,
+ recipientNoiseKey: ByteArray,
+ onAccepted: () -> Unit = {}
+ ): Boolean {
+ if (!enabled()) return false
+ start()
+ if (!relayManager.hasConnectedRelay(relayUrls)) return false
+ val sealed = try { cipher.sealWithPrekey(typedPayload, recipientNoiseKey) } catch (_: Exception) { return false }
+ val now = clock()
+ val envelope = CourierEnvelope(
+ recipientTag = CourierEnvelope.recipientTag(recipientNoiseKey, CourierEnvelope.epochDay(now)),
+ expiry = (now + CourierEnvelope.MAX_LIFETIME_MS).toULong(),
+ ciphertext = sealed.first,
+ prekeyID = sealed.second,
+ copies = 1u
+ )
+ val encoded = envelope.encode() ?: return false
+ if (encoded.size > MAX_ENCODED_BYTES) return false
+ val identity = try { identityFactory() } catch (_: Exception) { return false }
+ val event = identity.signEvent(
+ NostrEvent(
+ pubkey = identity.publicKeyHex,
+ createdAt = (now / 1000).toInt(),
+ kind = KIND,
+ tags = listOf(
+ listOf("x", envelope.recipientTag.toHex()),
+ listOf("expiration", (envelope.expiry / 1000u).toString())
+ ),
+ content = Base64.encodeToString(encoded, Base64.NO_WRAP)
+ )
+ )
+ if (!enabled()) return false
+ return relayManager.sendEvent(event, relayUrls, onAccepted)
+ }
+
+ @Synchronized
+ fun stop() {
+ relayManager.unsubscribe(subscriptionID)
+ subscribedDay = null
+ refreshJob?.cancel()
+ refreshJob = null
+ }
+
+ private fun handleEvent(event: NostrEvent) {
+ if (!enabled()) return
+ if (event.kind != KIND || !event.isValidSignature()) return
+ synchronized(seenEvents) { if (seenEvents.put(event.id, Unit) != null) return }
+ if (event.content.length > ((MAX_ENCODED_BYTES + 2) / 3) * 4) return
+ val encoded = try { Base64.decode(event.content, Base64.DEFAULT) } catch (_: Exception) { return }
+ if (encoded.size > MAX_ENCODED_BYTES) return
+ val envelope = CourierEnvelope.decode(encoded) ?: return
+ val now = clock()
+ if (envelope.expiry.toLong() <= now || envelope.expiry.toLong() > now + CourierEnvelope.MAX_LIFETIME_MS + 60 * 60 * 1000L) return
+ val eventTag = event.tags.firstOrNull { it.size > 1 && it[0] == "x" }?.get(1) ?: return
+ val expiration = event.tags.firstOrNull { it.size > 1 && it[0] == "expiration" }?.get(1)?.toULongOrNull() ?: return
+ if (eventTag != envelope.recipientTag.toHex() || expiration != envelope.expiry / 1000u) return
+ val localKey = cipher.staticPublicKey() ?: return
+ if (!envelope.matchesRecipient(localKey, now)) return
+ onEnvelope(envelope)
+ }
+
+ private fun ByteArray.toHex() = joinToString("") { "%02x".format(it) }
+}
diff --git a/app/src/main/java/com/bitchat/android/nostr/CustomRelayUrl.kt b/app/src/main/java/com/bitchat/android/nostr/CustomRelayUrl.kt
new file mode 100644
index 00000000..a9c9b3d9
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/nostr/CustomRelayUrl.kt
@@ -0,0 +1,14 @@
+package com.bitchat.android.nostr
+
+import java.net.URI
+
+object CustomRelayUrl {
+ fun normalize(input: String): String? = runCatching {
+ val uri = URI(input.trim())
+ require(uri.scheme.equals("wss", ignoreCase = true))
+ require(!uri.host.isNullOrBlank() && uri.userInfo == null && uri.fragment == null && uri.query == null)
+ require(uri.port == -1 || uri.port in 1..65535)
+ URI("wss", null, uri.host.lowercase(), uri.port,
+ uri.path?.takeUnless { it == "/" }, null, null).toASCIIString()
+ }.getOrNull()
+}
diff --git a/app/src/main/java/com/bitchat/android/nostr/LocationNotesManager.kt b/app/src/main/java/com/bitchat/android/nostr/LocationNotesManager.kt
index 0edb1fca..4318f1df 100644
--- a/app/src/main/java/com/bitchat/android/nostr/LocationNotesManager.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/LocationNotesManager.kt
@@ -38,7 +38,10 @@ class LocationNotesManager private constructor() {
val pubkey: String,
val content: String,
val createdAt: Int,
- val nickname: String?
+ val nickname: String?,
+ val geohash: String,
+ val expiresAt: Int? = null,
+ val isUrgent: Boolean = false
) {
/**
* Display name for the note - matches iOS exactly
@@ -97,6 +100,15 @@ class LocationNotesManager private constructor() {
// Coroutine scope for background operations
private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
private var liveLocationToken: Long? = null
+
+ init {
+ scope.launch {
+ while (isActive) {
+ delay(60_000)
+ pruneExpiredNotes()
+ }
+ }
+ }
private var subscribeRetryJob: Job? = null
private var initialLoadJob: Job? = null
@@ -139,7 +151,7 @@ class LocationNotesManager private constructor() {
}
// Validate geohash (building-level precision: 8 chars) - matches iOS
- if (!isValidBuildingGeohash(normalized)) {
+ if (normalized.length != 8 || !isValidGeohash(normalized)) {
Log.w(TAG, "LocationNotesManager rejected an invalid building geohash")
return
}
@@ -172,8 +184,8 @@ class LocationNotesManager private constructor() {
/**
* Validate building-level geohash (precision 8) - matches iOS Geohash.isValidBuildingGeohash
*/
- private fun isValidBuildingGeohash(geohash: String): Boolean {
- if (geohash.length != 8) return false
+ private fun isValidGeohash(geohash: String): Boolean {
+ if (geohash.length !in 1..12) return false
val base32Chars = "0123456789bcdefghjkmnpqrstuvwxyz"
return geohash.all { it in base32Chars }
}
@@ -210,7 +222,7 @@ class LocationNotesManager private constructor() {
/**
* Send a new location note
*/
- fun send(content: String, nickname: String?) {
+ fun send(content: String, nickname: String?, expiresAt: Int? = null, urgent: Boolean = false) {
val token = LiveLocationPrivacyGate.captureToken() ?: run {
stop()
return
@@ -275,7 +287,9 @@ class LocationNotesManager private constructor() {
content = trimmed,
geohash = currentGeohash,
senderIdentity = preparedIdentity,
- nickname = nickname
+ nickname = nickname,
+ expiresAt = expiresAt,
+ urgent = urgent
)
}
if (!LiveLocationPrivacyGate.accepts(token)) return@launch
@@ -286,7 +300,10 @@ class LocationNotesManager private constructor() {
pubkey = preparedEvent.pubkey,
content = trimmed,
createdAt = preparedEvent.createdAt,
- nickname = nickname
+ nickname = nickname,
+ geohash = currentGeohash,
+ expiresAt = expiresAt,
+ isUrgent = urgent
)
if (!noteIDs.contains(preparedEvent.id)) {
@@ -301,7 +318,7 @@ class LocationNotesManager private constructor() {
}
// CRITICAL FIX: Send to geo-specific relays (matching iOS pattern)
- // iOS: dependencies.sendEvent(event, relays)
+ // iOS: dependencies.sendEvent(event, relays, token)
val sent = withContext(Dispatchers.IO) {
LiveLocationPrivacyGate.runIfAllowed(token) {
sendEventFunc?.invoke(preparedEvent, relays, token)
@@ -443,6 +460,16 @@ class LocationNotesManager private constructor() {
// Extract nickname from tags
val nicknameTag = event.tags.firstOrNull { it.size >= 2 && it[0] == "n" }
val nickname = nicknameTag?.get(1)
+ val expiresAt = event.tags
+ .firstOrNull { it.size >= 2 && it[0].equals("expiration", ignoreCase = true) }
+ ?.get(1)
+ ?.toIntOrNull()
+ if (expiresAt != null && expiresAt <= currentEpochSeconds()) return
+ val urgent = event.tags.any {
+ it.size >= 2 &&
+ it[0].equals("t", ignoreCase = true) &&
+ it[1].equals("urgent", ignoreCase = true)
+ }
// Create note
val note = Note(
@@ -450,7 +477,10 @@ class LocationNotesManager private constructor() {
pubkey = event.pubkey,
content = event.content,
createdAt = event.createdAt,
- nickname = nickname
+ nickname = nickname,
+ geohash = eventGeohash.lowercase(),
+ expiresAt = expiresAt,
+ isUrgent = urgent
)
// Add to collection
@@ -493,6 +523,89 @@ class LocationNotesManager private constructor() {
fun clearError() {
_errorMessage.value = null
}
+
+ fun isOwnNote(note: Note): Boolean {
+ val current = _geohash.value ?: return false
+ val deriveIdentity = deriveIdentityFunc ?: return false
+ return runCatching { deriveIdentity(current).publicKeyHex == note.pubkey }.getOrDefault(false)
+ }
+
+ fun delete(note: Note): Boolean {
+ if (!isOwnNote(note)) return false
+ return deleteEvent(note.id, note.geohash) {
+ _notes.value = _notes.value.filterNot { it.id == note.id }
+ }
+ }
+
+ /**
+ * Publishes the relay copy of a geohash board post without changing the
+ * active notes subscription. The callback lets BoardManager retract the
+ * copy with NIP-09 while the app remains alive.
+ */
+ fun publishBoardBridge(
+ content: String,
+ geohash: String,
+ nickname: String,
+ expiresAtSeconds: Int,
+ urgent: Boolean,
+ onPublished: (String) -> Unit
+ ) {
+ val token = LiveLocationPrivacyGate.captureToken() ?: return
+ val deriveIdentity = deriveIdentityFunc ?: return
+ val sendEvent = sendEventFunc ?: return
+ val relays = runCatching {
+ RelayDirectory.closestRelaysForGeohash(geohash, 5)
+ }.getOrDefault(emptyList())
+ if (relays.isEmpty()) return
+ scope.launch {
+ runCatching {
+ val identity = withContext(Dispatchers.IO) { deriveIdentity(geohash) }
+ val event = NostrProtocol.createGeohashTextNote(
+ content = content,
+ geohash = geohash,
+ senderIdentity = identity,
+ nickname = nickname,
+ expiresAt = expiresAtSeconds,
+ urgent = urgent
+ )
+ withContext(Dispatchers.IO) { sendEvent(event, relays, token) }
+ onPublished(event.id)
+ }.onFailure {
+ Log.e(TAG, "Failed to bridge board post to Nostr: ${it.message}")
+ }
+ }
+ }
+
+ fun deleteEvent(eventID: String, geohash: String, onDeleted: () -> Unit = {}): Boolean {
+ val token = LiveLocationPrivacyGate.captureToken() ?: return false
+ val deriveIdentity = deriveIdentityFunc ?: return false
+ val sendEvent = sendEventFunc ?: return false
+ val relays = runCatching {
+ RelayDirectory.closestRelaysForGeohash(geohash, 5)
+ }.getOrDefault(emptyList())
+ if (relays.isEmpty()) return false
+ scope.launch {
+ runCatching {
+ val identity = withContext(Dispatchers.IO) { deriveIdentity(geohash) }
+ val deletion = NostrProtocol.createDeleteEvent(eventID, identity)
+ withContext(Dispatchers.IO) { sendEvent(deletion, relays, token) }
+ onDeleted()
+ }.onFailure {
+ Log.e(TAG, "Failed to delete Nostr notice: ${it.message}")
+ }
+ }
+ return true
+ }
+
+ fun pruneExpiredNotes() {
+ val now = currentEpochSeconds()
+ _notes.value = _notes.value.filter { note ->
+ note.expiresAt?.let { it > now } ?: true
+ }
+ }
+
+ private fun currentEpochSeconds(): Int =
+ (System.currentTimeMillis() / 1_000L).coerceAtMost(Int.MAX_VALUE.toLong()).toInt()
/**
* Cancel subscription and clear state
diff --git a/app/src/main/java/com/bitchat/android/nostr/MeshMessageIdentity.kt b/app/src/main/java/com/bitchat/android/nostr/MeshMessageIdentity.kt
new file mode 100644
index 00000000..553da1de
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/nostr/MeshMessageIdentity.kt
@@ -0,0 +1,14 @@
+package com.bitchat.android.nostr
+
+import java.security.MessageDigest
+
+/** Cross-platform stable identity for a public mesh radio/bridge copy. */
+object MeshMessageIdentity {
+ fun stableId(senderIdHex: String, timestampMs: Long, content: String): String {
+ val input = "${senderIdHex.lowercase()}|$timestampMs|${content.trim()}"
+ return MessageDigest.getInstance("SHA-256")
+ .digest(input.toByteArray(Charsets.UTF_8))
+ .joinToString("") { "%02x".format(it) }
+ .take(32)
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrBackgroundRuntime.kt b/app/src/main/java/com/bitchat/android/nostr/NostrBackgroundRuntime.kt
index a895f612..758a0652 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrBackgroundRuntime.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrBackgroundRuntime.kt
@@ -92,6 +92,13 @@ object NostrBackgroundRuntime {
)
}
+ fun receiveGatewayEvent(event: NostrEvent, geohash: String) {
+ if (!initialized || activeGeohash != geohash) return
+ val selected = (locationChannels.selectedChannel.value as? ChannelID.Location)?.channel ?: return
+ if (selected.geohash != geohash || !locationChannels.canUseSelectedLocationChannel(selected)) return
+ eventProcessor.onGeohashMessage(event, geohash)
+ }
+
private fun subscribeAccountDm() {
val identity = NostrIdentityBridge.getCurrentNostrIdentity(application) ?: return
subscriptions.subscribeGiftWraps(
@@ -147,7 +154,10 @@ object NostrBackgroundRuntime {
sinceMs = System.currentTimeMillis() - 3_600_000L,
limit = 200,
id = "geohash-$geohash",
- handler = { event -> eventProcessor.onGeohashMessage(event, geohash) },
+ handler = { event ->
+ eventProcessor.onGeohashMessage(event, geohash)
+ com.bitchat.android.services.bridge.MeshGatewayService.rebroadcastRelayEvent(event, geohash, liveLocationToken)
+ },
liveLocationToken = liveLocationToken
)
subscribeGeohashDm(geohash, "geo-dm-$geohash", liveLocationToken)
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrClient.kt b/app/src/main/java/com/bitchat/android/nostr/NostrClient.kt
index 0257c756..c5385759 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrClient.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrClient.kt
@@ -241,10 +241,8 @@ class NostrClient private constructor(private val context: Context) {
giftWrap: NostrEvent,
handler: (content: String, senderNpub: String, timestamp: Int) -> Unit
) {
- // Age filtering (24h + 15min buffer for randomized timestamps)
- val messageAge = System.currentTimeMillis() / 1000 - giftWrap.createdAt
- if (messageAge > 173700) { // 48 hours + 15 minutes
- Log.v(TAG, "Ignoring old private message")
+ if (!NostrTimestampPolicy.isAcceptableGiftWrapTimestamp(giftWrap.createdAt)) {
+ Log.v(TAG, "Ignoring private message with implausible gift-wrap created_at")
return
}
@@ -254,6 +252,10 @@ class NostrClient private constructor(private val context: Context) {
val decryptResult = NostrProtocol.decryptPrivateMessage(giftWrap, identity)
if (decryptResult != null) {
val (content, senderPubkey, timestamp) = decryptResult
+ if (!NostrTimestampPolicy.isPlausibleRumorTimestamp(timestamp)) {
+ Log.w(TAG, "Dropping private message with implausible rumor timestamp")
+ return
+ }
// Convert sender pubkey to npub
val senderNpub = try {
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt b/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt
index 4125d5ca..b483ad75 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrDirectMessageHandler.kt
@@ -60,8 +60,10 @@ class NostrDirectMessageHandler(
try {
if (dedupe(giftWrap.id)) return@launch
- val messageAge = System.currentTimeMillis() / 1000 - giftWrap.createdAt
- if (messageAge > 173700) return@launch // 48 hours + 15 mins
+ if (!NostrTimestampPolicy.isAcceptableGiftWrapTimestamp(giftWrap.createdAt)) {
+ Log.v(TAG, "Ignoring gift wrap with implausible created_at")
+ return@launch
+ }
val decryptResult = NostrProtocol.decryptPrivateMessage(giftWrap, identity)
if (decryptResult == null) {
@@ -70,6 +72,10 @@ class NostrDirectMessageHandler(
}
val (content, rawSenderPubkey, rumorTimestamp) = decryptResult
+ if (!NostrTimestampPolicy.isPlausibleRumorTimestamp(rumorTimestamp)) {
+ Log.w(TAG, "Dropping Nostr DM with implausible rumor timestamp")
+ return@launch
+ }
val senderPubkey = rawSenderPubkey.lowercase()
// If sender is blocked for geohash contexts, drop any events from this pubkey
@@ -188,6 +194,7 @@ class NostrDirectMessageHandler(
}
NoisePayloadType.DELIVERED -> {
val messageId = String(payload.data, Charsets.UTF_8)
+ com.bitchat.android.services.MessageRouter.tryGetInstance()?.onMessageAcknowledged(messageId, conversationID)
withContext(Dispatchers.Main) {
updateDeliveryStatus(
messageId,
@@ -197,6 +204,7 @@ class NostrDirectMessageHandler(
}
NoisePayloadType.READ_RECEIPT -> {
val messageId = String(payload.data, Charsets.UTF_8)
+ com.bitchat.android.services.MessageRouter.tryGetInstance()?.onMessageAcknowledged(messageId, conversationID)
withContext(Dispatchers.Main) {
updateDeliveryStatus(
messageId,
@@ -243,6 +251,9 @@ class NostrDirectMessageHandler(
NoisePayloadType.VERIFY_CHALLENGE,
NoisePayloadType.VERIFY_RESPONSE,
NoisePayloadType.VOICE_FRAME,
+ NoisePayloadType.GROUP_INVITE,
+ NoisePayloadType.GROUP_KEY_UPDATE,
+ NoisePayloadType.VOUCH,
NoisePayloadType.PEER_STATE -> Unit // Peer state is bound to a live mesh Noise generation.
}
}
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrEvent.kt b/app/src/main/java/com/bitchat/android/nostr/NostrEvent.kt
index 92752b17..483eeb86 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrEvent.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrEvent.kt
@@ -210,10 +210,12 @@ data class NostrEvent(
object NostrKind {
const val METADATA = 0
const val TEXT_NOTE = 1
+ const val DELETION = 5
const val DIRECT_MESSAGE = 14 // NIP-17 direct message (unsigned)
const val FILE_MESSAGE = 15 // NIP-17 file message (unsigned)
const val SEAL = 13 // NIP-17 sealed event
const val GIFT_WRAP = 1059 // NIP-17 gift wrap
+ const val COURIER_DROP = 1401 // Opaque bridge courier envelope
const val EPHEMERAL_EVENT = 20000 // For geohash channels
const val GEOHASH_PRESENCE = 20001 // For geohash presence heartbeat
}
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrFilter.kt b/app/src/main/java/com/bitchat/android/nostr/NostrFilter.kt
index df67822f..ba7ebac0 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrFilter.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrFilter.kt
@@ -69,6 +69,28 @@ data class NostrFilter(
limit = limit
)
}
+
+ fun bridgeRendezvous(
+ cells: Collection,
+ since: Long? = null,
+ limit: Int = 200
+ ): NostrFilter = NostrFilter(
+ kinds = listOf(NostrKind.EPHEMERAL_EVENT, NostrKind.GEOHASH_PRESENCE),
+ since = since?.let { (it / 1000).toInt() },
+ tagFilters = mapOf("r" to cells.toList()),
+ limit = limit
+ )
+
+ fun courierDrops(
+ recipientTagsHex: Collection,
+ since: Long? = null,
+ limit: Int = 100
+ ): NostrFilter = NostrFilter(
+ kinds = listOf(NostrKind.COURIER_DROP),
+ since = since?.let { (it / 1000).toInt() },
+ tagFilters = mapOf("x" to recipientTagsHex.toList()),
+ limit = limit
+ )
/**
* Create filter for text notes from specific authors
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrIdentity.kt b/app/src/main/java/com/bitchat/android/nostr/NostrIdentity.kt
index 665bfd50..ebe32e74 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrIdentity.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrIdentity.kt
@@ -176,6 +176,39 @@ object NostrIdentityBridge {
Log.d(TAG, "Used fallback geohash identity derivation")
return fallbackIdentity
}
+
+ /**
+ * Derive the iOS-compatible bridge rendezvous identity. The domain label
+ * prevents linking it to geohash-chat identity and the iteration is
+ * encoded big-endian, matching CryptoKit's UInt32.bigEndian bytes.
+ */
+ fun deriveBridgeIdentity(cell: String, context: Context): NostrIdentity {
+ val label = "bridge|$cell"
+ geohashIdentityCache[label]?.let { return it }
+ val stateManager = SecureIdentityStateManager(context)
+ val seed = getOrCreateDeviceSeed(stateManager)
+ val message = label.toByteArray(Charsets.UTF_8)
+
+ for (iteration in 0 until 10) {
+ val input = message + byteArrayOf(
+ (iteration ushr 24).toByte(),
+ (iteration ushr 16).toByte(),
+ (iteration ushr 8).toByte(),
+ iteration.toByte()
+ )
+ val candidate = hmacSha256(seed, input).toHexStringLocal()
+ if (NostrCrypto.isValidPrivateKey(candidate)) {
+ return NostrIdentity.fromPrivateKey(candidate).also {
+ geohashIdentityCache[label] = it
+ }
+ }
+ }
+
+ val fallback = MessageDigest.getInstance("SHA-256").digest(seed + message)
+ return NostrIdentity.fromPrivateKey(fallback.toHexStringLocal()).also {
+ geohashIdentityCache[label] = it
+ }
+ }
/**
* Generate candidate key for a specific iteration (matches iOS implementation)
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrPendingEventQueue.kt b/app/src/main/java/com/bitchat/android/nostr/NostrPendingEventQueue.kt
index dd9e16d1..3c95a9c7 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrPendingEventQueue.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrPendingEventQueue.kt
@@ -16,14 +16,16 @@ internal class NostrPendingEventQueue(
data class Delivery(
val queueId: Long,
val event: NostrEvent,
- val liveLocationToken: Long?
+ val liveLocationToken: Long?,
+ val publicationAllowed: () -> Boolean
)
private data class Entry(
val queueId: Long,
val event: NostrEvent,
val pendingRelayUrls: MutableSet,
- val liveLocationToken: Long?
+ val liveLocationToken: Long?,
+ val publicationAllowed: () -> Boolean
)
private val lock = Any()
@@ -33,7 +35,8 @@ internal class NostrPendingEventQueue(
fun enqueue(
event: NostrEvent,
relayUrls: Collection,
- liveLocationToken: Long?
+ liveLocationToken: Long?,
+ publicationAllowed: () -> Boolean = { true }
): Long? {
val pendingRelays = relayUrls.filterTo(linkedSetOf()) { it.isNotBlank() }
if (pendingRelays.isEmpty()) return null
@@ -46,7 +49,8 @@ internal class NostrPendingEventQueue(
queueId = queueId,
event = event,
pendingRelayUrls = pendingRelays,
- liveLocationToken = liveLocationToken
+ liveLocationToken = liveLocationToken,
+ publicationAllowed = publicationAllowed
)
)
queueId
@@ -54,10 +58,11 @@ internal class NostrPendingEventQueue(
}
fun pendingForRelay(relayUrl: String): List = synchronized(lock) {
+ entries.removeAll { !it.publicationAllowed() }
entries
.asSequence()
.filter { relayUrl in it.pendingRelayUrls }
- .map { Delivery(it.queueId, it.event, it.liveLocationToken) }
+ .map { Delivery(it.queueId, it.event, it.liveLocationToken, it.publicationAllowed) }
.toList()
}
@@ -74,6 +79,11 @@ internal class NostrPendingEventQueue(
}
}
+ fun removeRelay(relayUrl: String) = synchronized(lock) {
+ entries.forEach { it.pendingRelayUrls.remove(relayUrl) }
+ entries.removeAll { it.pendingRelayUrls.isEmpty() }
+ }
+
fun removeLiveLocationEvents() {
synchronized(lock) {
entries.removeAll { it.liveLocationToken != null }
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrProtocol.kt b/app/src/main/java/com/bitchat/android/nostr/NostrProtocol.kt
index 7463a378..0124413a 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrProtocol.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrProtocol.kt
@@ -65,6 +65,12 @@ object NostrProtocol {
Log.v(TAG, "Starting decryption of gift wrap: ${giftWrap.id.take(16)}...")
return try {
+ val recipientTags = listOf(listOf("p", recipientIdentity.publicKeyHex))
+ if (giftWrap.content.toByteArray(Charsets.UTF_8).size > 64 * 1024 ||
+ giftWrap.kind != NostrKind.GIFT_WRAP || giftWrap.tags != recipientTags ||
+ !NostrTimestampPolicy.isAcceptableGiftWrapTimestamp(giftWrap.createdAt) ||
+ !giftWrap.isValidSignature()
+ ) return null
// 1. Unwrap the gift wrap
val seal = unwrapGiftWrap(giftWrap, recipientIdentity.privateKeyHex)
?: run {
@@ -74,7 +80,7 @@ object NostrProtocol {
Log.v(TAG, "Successfully unwrapped gift wrap from: ${seal.pubkey.take(16)}...")
- if (seal.kind != NostrKind.SEAL || !seal.isValidSignature()) {
+ if (seal.kind != NostrKind.SEAL || seal.tags.isNotEmpty() || !seal.isValidSignature()) {
Log.w(TAG, "❌ Invalid NIP-17 seal signature")
return null
}
@@ -86,7 +92,10 @@ object NostrProtocol {
return null
}
- if (seal.pubkey != rumor.pubkey) {
+ if (seal.pubkey != rumor.pubkey || rumor.kind != NostrKind.DIRECT_MESSAGE ||
+ (rumor.tags.isNotEmpty() && rumor.tags != recipientTags) || rumor.sig != null ||
+ !NostrTimestampPolicy.isPlausibleRumorTimestamp(rumor.createdAt)
+ ) {
Log.w(TAG, "❌ NIP-17 seal pubkey does not match rumor pubkey")
return null
}
@@ -108,7 +117,9 @@ object NostrProtocol {
content: String,
geohash: String,
senderIdentity: NostrIdentity,
- nickname: String? = null
+ nickname: String? = null,
+ expiresAt: Int? = null,
+ urgent: Boolean = false
): NostrEvent = withContext(Dispatchers.Default) {
val tags = mutableListOf>()
tags.add(listOf("g", geohash))
@@ -116,6 +127,12 @@ object NostrProtocol {
if (!nickname.isNullOrEmpty()) {
tags.add(listOf("n", nickname))
}
+ expiresAt?.let {
+ tags.add(listOf("expiration", it.toString()))
+ }
+ if (urgent) {
+ tags.add(listOf("t", "urgent"))
+ }
val event = NostrEvent(
pubkey = senderIdentity.publicKeyHex,
@@ -128,6 +145,21 @@ object NostrProtocol {
return@withContext senderIdentity.signEvent(event)
}
+ /** Create a NIP-09 deletion request signed by the original event identity. */
+ suspend fun createDeleteEvent(
+ eventID: String,
+ senderIdentity: NostrIdentity
+ ): NostrEvent = withContext(Dispatchers.Default) {
+ val event = NostrEvent(
+ pubkey = senderIdentity.publicKeyHex,
+ createdAt = (System.currentTimeMillis() / 1000).toInt(),
+ kind = NostrKind.DELETION,
+ tags = listOf(listOf("e", eventID)),
+ content = ""
+ )
+ senderIdentity.signEvent(event)
+ }
+
/**
* Create a geohash-scoped presence event (kind 20001)
* Has no content and no nickname, used for participant counting
@@ -212,6 +244,73 @@ object NostrProtocol {
return@withContext senderIdentity.signEvent(event)
}
+
+ /** iOS-compatible public mesh event on a bridge rendezvous cell. */
+ fun createBridgeMeshEvent(
+ content: String,
+ cell: String,
+ senderIdentity: NostrIdentity,
+ nickname: String? = null,
+ meshSenderId: String? = null,
+ meshTimestampMs: Long? = null
+ ): NostrEvent {
+ val tags = mutableListOf>(listOf("r", cell))
+ nickname?.trim()?.takeIf { it.isNotEmpty() }?.let { tags += listOf("n", it) }
+ val sender = meshSenderId?.trim()?.takeIf { it.isNotEmpty() }
+ if (sender != null && meshTimestampMs != null) {
+ tags += listOf(
+ "m",
+ MeshMessageIdentity.stableId(sender, meshTimestampMs, content),
+ sender,
+ meshTimestampMs.toString()
+ )
+ }
+ return senderIdentity.signEvent(
+ NostrEvent(
+ pubkey = senderIdentity.publicKeyHex,
+ createdAt = (System.currentTimeMillis() / 1000).toInt(),
+ kind = NostrKind.EPHEMERAL_EVENT,
+ tags = tags,
+ content = content
+ )
+ )
+ }
+
+ /** Empty bridge-presence heartbeat, deliberately separate from `#g` chat. */
+ fun createBridgePresenceEvent(
+ cell: String,
+ senderIdentity: NostrIdentity
+ ): NostrEvent = senderIdentity.signEvent(
+ NostrEvent(
+ pubkey = senderIdentity.publicKeyHex,
+ createdAt = (System.currentTimeMillis() / 1000).toInt(),
+ kind = NostrKind.GEOHASH_PRESENCE,
+ tags = listOf(listOf("r", cell)),
+ content = ""
+ )
+ )
+
+ /**
+ * Opaque relay drop. Callers use a throwaway identity so deposits cannot
+ * be linked by their Nostr publisher key.
+ */
+ fun createCourierDropEvent(
+ envelope: ByteArray,
+ recipientTagHex: String,
+ expiresAtMs: Long,
+ senderIdentity: NostrIdentity
+ ): NostrEvent = senderIdentity.signEvent(
+ NostrEvent(
+ pubkey = senderIdentity.publicKeyHex,
+ createdAt = (System.currentTimeMillis() / 1000).toInt(),
+ kind = NostrKind.COURIER_DROP,
+ tags = listOf(
+ listOf("x", recipientTagHex),
+ listOf("expiration", (expiresAtMs / 1000).toString())
+ ),
+ content = android.util.Base64.encodeToString(envelope, android.util.Base64.NO_WRAP)
+ )
+ )
// MARK: - Private Methods
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrRelayManager.kt b/app/src/main/java/com/bitchat/android/nostr/NostrRelayManager.kt
index 81c1cac6..534d4bbd 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrRelayManager.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrRelayManager.kt
@@ -35,6 +35,7 @@ class NostrRelayManager private constructor() {
*/
fun getInstance(context: android.content.Context): NostrRelayManager {
shared.appContext = context.applicationContext
+ shared.loadCustomRelays(context.applicationContext)
return shared
}
@@ -55,7 +56,7 @@ class NostrRelayManager private constructor() {
pendingGiftWrapIDs.add(id)
}
- fun defaultRelays(): List = DEFAULT_RELAYS
+ fun defaultRelays(): List = (DEFAULT_RELAYS + shared.customRelays.value).distinct()
}
/**
@@ -73,12 +74,82 @@ class NostrRelayManager private constructor() {
var nextReconnectTime: Long? = null
)
+ private val _customRelays = MutableStateFlow>(emptyList())
+ val customRelays: StateFlow> = _customRelays.asStateFlow()
+ private var customRelaysLoaded = false
+ private val removedCustomRelayUrls = java.util.concurrent.ConcurrentHashMap.newKeySet()
+
+ @Synchronized
+ private fun loadCustomRelays(context: android.content.Context) {
+ if (customRelaysLoaded) return
+ customRelaysLoaded = true
+ val urls = context.getSharedPreferences("nostr_custom_relays", android.content.Context.MODE_PRIVATE)
+ .getStringSet("urls", emptySet()).orEmpty().mapNotNull(CustomRelayUrl::normalize).distinct().take(20)
+ _customRelays.value = urls
+ nonLiveRelayUrls.addAll(urls)
+ ensureConnectionsFor(urls.toSet())
+ }
+
+ @Synchronized
+ fun addCustomRelay(input: String): Boolean {
+ val url = CustomRelayUrl.normalize(input) ?: return false
+ if (url in defaultRelays()) return true
+ if (_customRelays.value.size >= 20) return false
+ val previousDefaults = defaultRelays().toSet()
+ removedCustomRelayUrls.remove(url)
+ _customRelays.value = _customRelays.value + url
+ persistCustomRelays()
+ nonLiveRelayUrls.add(url)
+ activeSubscriptions.replaceAll { _, subscription ->
+ if (subscription.targetRelayUrls == previousDefaults) {
+ subscription.copy(targetRelayUrls = previousDefaults + url)
+ } else subscription
+ }
+ ensureConnectionsFor(setOf(url))
+ return true
+ }
+
+ @Synchronized
+ fun removeCustomRelay(url: String) {
+ if (url !in _customRelays.value) return
+ removedCustomRelayUrls.add(url)
+ messageQueue.removeRelay(url)
+ _customRelays.value = _customRelays.value - url
+ persistCustomRelays()
+ activeSubscriptions.replaceAll { _, subscription ->
+ subscription.copy(targetRelayUrls = subscription.targetRelayUrls?.minus(url))
+ }
+ reconnectJobs.remove(url)?.cancel()
+ connections.remove(url)?.close(1000, "Relay removed")
+ subscriptions.remove(url)
+ nonLiveRelayUrls.remove(url)
+ synchronized(relaysList) { relaysList.removeAll { it.url == url } }
+ updateRelaysList()
+ updateConnectionStatus()
+ }
+
+ fun clearCustomRelays() {
+ _customRelays.value.toList().forEach(::removeCustomRelay)
+ check(appContext?.getSharedPreferences("nostr_custom_relays", android.content.Context.MODE_PRIVATE)
+ ?.edit()?.clear()?.commit() != false)
+ }
+
+ private fun persistCustomRelays() {
+ appContext?.getSharedPreferences("nostr_custom_relays", android.content.Context.MODE_PRIVATE)
+ ?.edit()?.putStringSet("urls", _customRelays.value.toSet())?.apply()
+ }
+
// Published state
private val _relays = MutableStateFlow>(emptyList())
val relays: StateFlow> = _relays.asStateFlow()
private val _isConnected = MutableStateFlow(false)
val isConnected: StateFlow = _isConnected.asStateFlow()
+ private data class PendingAcceptance(
+ val callback: () -> Unit,
+ val pendingRelays: MutableSet
+ )
+ private val eventAcceptanceHandlers = java.util.concurrent.ConcurrentHashMap()
// Internal state
private val relaysList = mutableListOf()
@@ -226,23 +297,24 @@ class NostrRelayManager private constructor() {
geohash: String,
includeDefaults: Boolean = false,
nRelays: Int = 5,
- liveLocationToken: Long? = null
+ liveLocationToken: Long? = null,
+ publicationAllowed: () -> Boolean = { true }
) {
- if (!isNetworkActionAllowed(liveLocationToken)) return
+ if (!publicationAllowed() || !isNetworkActionAllowed(liveLocationToken)) return
ensureGeohashRelaysConnected(
geohash,
nRelays,
includeDefaults,
liveLocationToken
)
- if (!isNetworkActionAllowed(liveLocationToken)) return
+ if (!publicationAllowed() || !isNetworkActionAllowed(liveLocationToken)) return
val relayUrls = getRelaysForGeohash(geohash)
if (relayUrls.isEmpty()) {
Log.w(TAG, "No target relays for geohash event; falling back to defaults")
- sendEvent(event, Companion.defaultRelays(), liveLocationToken)
+ sendEvent(event, Companion.defaultRelays(), liveLocationToken, publicationAllowed = publicationAllowed)
return
}
- sendEvent(event, relayUrls, liveLocationToken)
+ sendEvent(event, relayUrls, liveLocationToken, publicationAllowed = publicationAllowed)
}
// --- Internal helpers ---
@@ -446,32 +518,49 @@ class NostrRelayManager private constructor() {
fun sendEvent(
event: NostrEvent,
relayUrls: List? = null,
- liveLocationToken: Long? = null
- ) {
+ liveLocationToken: Long? = null,
+ onAccepted: (() -> Unit)? = null,
+ publicationAllowed: () -> Boolean = { true }
+ ): Boolean {
+ if (!publicationAllowed()) return false
val targetRelays = (relayUrls ?: relaysList.map { it.url })
.filter { it.isNotBlank() }
.distinct()
- if (targetRelays.isEmpty()) return
+ if (targetRelays.isEmpty()) return false
+ var enqueued = false
val queued = runNetworkAction(liveLocationToken) {
val queueId = messageQueue.enqueue(
event = event,
relayUrls = targetRelays,
- liveLocationToken = liveLocationToken
+ liveLocationToken = liveLocationToken,
+ publicationAllowed = publicationAllowed
) ?: return@runNetworkAction
+ enqueued = true
+ if (onAccepted != null) {
+ eventAcceptanceHandlers[event.id] = PendingAcceptance(
+ onAccepted,
+ targetRelays.map { it.trim().trimEnd('/') }.toMutableSet()
+ )
+ }
scope.launch {
if (!isNetworkActionAllowed(liveLocationToken)) return@launch
targetRelays.forEach { relayUrl ->
val webSocket = connections[relayUrl]
if (webSocket != null) {
- if (sendToRelay(event, webSocket, relayUrl, liveLocationToken)) {
+ if (sendToRelay(event, webSocket, relayUrl, liveLocationToken, publicationAllowed)) {
messageQueue.markDelivered(queueId, relayUrl)
}
}
}
}
}
- if (!queued) return
+ return queued && enqueued
+ }
+
+ fun hasConnectedRelay(relayUrls: Collection): Boolean {
+ val targets = relayUrls.map { it.trim().trimEnd('/') }.toSet()
+ return relaysList.any { it.isConnected && it.url.trim().trimEnd('/') in targets }
}
/**
@@ -667,6 +756,7 @@ class NostrRelayManager private constructor() {
// Clear any queued messages waiting to be sent
messageQueue.clear()
+ eventAcceptanceHandlers.clear()
Log.i(TAG, "Cleared all Nostr subscriptions and routing caches")
} catch (e: Exception) {
@@ -838,7 +928,7 @@ class NostrRelayManager private constructor() {
urlString: String,
liveLocationToken: Long? = null
) {
- if (!desiredConnected.get()) return
+ if (!desiredConnected.get() || urlString in removedCustomRelayUrls) return
val connectionToken = liveLocationToken
?.takeIf { urlString !in nonLiveRelayUrls }
if (!isNetworkActionAllowed(connectionToken)) return
@@ -853,6 +943,7 @@ class NostrRelayManager private constructor() {
.build()
val started = runNetworkAction(connectionToken) {
+ if (urlString in removedCustomRelayUrls) return@runNetworkAction
val webSocket = httpClient.newWebSocket(
request,
RelayWebSocketListener(urlString, connectionToken)
@@ -860,7 +951,7 @@ class NostrRelayManager private constructor() {
val existing = connections.putIfAbsent(urlString, webSocket)
when {
existing != null -> webSocket.close(1000, "Duplicate connection")
- !desiredConnected.get() -> {
+ !desiredConnected.get() || urlString in removedCustomRelayUrls -> {
connections.remove(urlString, webSocket)
webSocket.close(1000, "Connection no longer desired")
}
@@ -878,16 +969,17 @@ class NostrRelayManager private constructor() {
event: NostrEvent,
webSocket: WebSocket,
relayUrl: String,
- liveLocationToken: Long? = null
+ liveLocationToken: Long? = null,
+ publicationAllowed: () -> Boolean = { true }
): Boolean {
- if (!isNetworkActionAllowed(liveLocationToken)) return false
+ if (!publicationAllowed() || relayUrl in removedCustomRelayUrls || !isNetworkActionAllowed(liveLocationToken)) return false
return try {
val request = NostrRequest.Event(event)
val message = gson.toJson(request, NostrRequest::class.java)
var success = false
runNetworkAction(liveLocationToken) {
- success = webSocket.send(message)
+ if (publicationAllowed() && relayUrl !in removedCustomRelayUrls) success = webSocket.send(message)
}
if (success) {
// Update relay stats
@@ -960,8 +1052,14 @@ class NostrRelayManager private constructor() {
is NostrResponse.Ok -> {
val wasGiftWrap = pendingGiftWrapIDs.remove(response.eventId)
if (!response.accepted) {
+ eventAcceptanceHandlers[response.eventId]?.let { pending ->
+ pending.pendingRelays.remove(relayUrl.trim().trimEnd('/'))
+ if (pending.pendingRelays.isEmpty()) eventAcceptanceHandlers.remove(response.eventId, pending)
+ }
val level = if (wasGiftWrap) Log.WARN else Log.ERROR
Log.println(level, TAG, "Event rejected by relay: ${response.message ?: "no reason"}")
+ } else {
+ eventAcceptanceHandlers.remove(response.eventId)?.callback?.invoke()
}
}
@@ -1118,7 +1216,7 @@ class NostrRelayManager private constructor() {
) : WebSocketListener() {
override fun onOpen(webSocket: WebSocket, response: Response) {
- if (!desiredConnected.get() ||
+ if (!desiredConnected.get() || relayUrl in removedCustomRelayUrls ||
connections[relayUrl] !== webSocket ||
!isNetworkActionAllowed(liveLocationToken)
) {
@@ -1140,7 +1238,8 @@ class NostrRelayManager private constructor() {
delivery.event,
webSocket,
relayUrl,
- delivery.liveLocationToken
+ delivery.liveLocationToken,
+ delivery.publicationAllowed
)
) {
messageQueue.markDelivered(delivery.queueId, relayUrl)
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrTimestampPolicy.kt b/app/src/main/java/com/bitchat/android/nostr/NostrTimestampPolicy.kt
new file mode 100644
index 00000000..1daca641
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrTimestampPolicy.kt
@@ -0,0 +1,42 @@
+package com.bitchat.android.nostr
+
+import com.bitchat.android.util.AppConstants
+
+/**
+ * Client-side timestamp windows for inbound Nostr DMs.
+ *
+ * Mirrors iOS `NostrInboundPipeline.isPlausibleRumorTimestamp`: a relay that
+ * ignores the subscription `since` filter — or replays archived events — must
+ * not inject stale or future-dated DMs. The inner rumor timestamp is the
+ * sender's true send time; only the outer gift wrap is NIP-17-randomized.
+ */
+object NostrTimestampPolicy {
+
+ /**
+ * Accept an inner rumor `created_at` inside
+ * `[now − lookback − skew, now + skew]`.
+ */
+ fun isPlausibleRumorTimestamp(
+ tsSeconds: Int,
+ nowSeconds: Long = System.currentTimeMillis() / 1000L
+ ): Boolean {
+ val age = nowSeconds - tsSeconds.toLong()
+ val skew = AppConstants.Nostr.DM_MAX_CLOCK_SKEW_SECONDS
+ val lookback = AppConstants.Nostr.DM_SUBSCRIBE_LOOKBACK_SECONDS
+ return age >= -skew && age <= lookback + skew
+ }
+
+ /**
+ * Accept an outer gift-wrap `created_at` that is not in the far future and
+ * not older than the NIP-17 randomization ceiling plus skew.
+ */
+ fun isAcceptableGiftWrapTimestamp(
+ createdAtSeconds: Int,
+ nowSeconds: Long = System.currentTimeMillis() / 1000L
+ ): Boolean {
+ val age = nowSeconds - createdAtSeconds.toLong()
+ val skew = AppConstants.Nostr.DM_MAX_CLOCK_SKEW_SECONDS
+ val maxAge = AppConstants.Nostr.DM_GIFT_WRAP_MAX_AGE_SECONDS
+ return age >= -skew && age <= maxAge
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt b/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt
index f39324fd..5dd1d49f 100644
--- a/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt
+++ b/app/src/main/java/com/bitchat/android/nostr/NostrTransport.kt
@@ -46,6 +46,11 @@ class NostrTransport(
// MARK: - Transport Interface Methods
val myPeerID: String get() = senderPeerID
+
+ fun canDeliverPromptly(): Boolean = try {
+ NostrRelayManager.getInstance(context)
+ .hasConnectedRelay(NostrRelayManager.defaultRelays())
+ } catch (_: Exception) { false }
fun sendPrivateMessage(
content: String,
diff --git a/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt b/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt
index 6a0445b0..9e08b49c 100644
--- a/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt
+++ b/app/src/main/java/com/bitchat/android/protocol/BinaryProtocol.kt
@@ -14,12 +14,19 @@ enum class MessageType(val value: UByte) {
ANNOUNCE(0x01u),
MESSAGE(0x02u), // All user messages (private and broadcast)
LEAVE(0x03u),
+ COURIER_ENVELOPE(0x04u), // Opaque Noise X store-and-forward envelope
NOISE_HANDSHAKE(0x10u), // Noise handshake
NOISE_ENCRYPTED(0x11u), // Noise encrypted transport message
FRAGMENT(0x20u), // Fragmentation for large packets
REQUEST_SYNC(0x21u), // GCS-based sync request
FILE_TRANSFER(0x22u), // New: File transfer packet (BLE voice notes, etc.)
- VOICE_FRAME(0x29u); // Ephemeral live push-to-talk frame; never added to gossip sync
+ VOICE_FRAME(0x29u), // Ephemeral live push-to-talk frame; never added to gossip sync
+ BOARD_POST(0x23u),
+ GROUP_MESSAGE(0x25u), // Opaque private-group ciphertext broadcast
+ PREKEY_BUNDLE(0x24u), // Signed batch of one-time courier prekeys
+ NOSTR_CARRIER(0x28u), // Signed bridge/gateway event carrier
+ PING(MeshDiagnosticsConstants.PING_TYPE),
+ PONG(MeshDiagnosticsConstants.PONG_TYPE);
companion object {
fun fromValue(value: UByte): MessageType? {
diff --git a/app/src/main/java/com/bitchat/android/protocol/MeshDiagnosticsConstants.kt b/app/src/main/java/com/bitchat/android/protocol/MeshDiagnosticsConstants.kt
new file mode 100644
index 00000000..62935dbd
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/protocol/MeshDiagnosticsConstants.kt
@@ -0,0 +1,15 @@
+package com.bitchat.android.protocol
+
+object MeshDiagnosticsConstants {
+ val PING_TYPE: UByte = 0x26u
+ val PONG_TYPE: UByte = 0x27u
+ val TTL: UByte = 7u
+ const val NONCE_SIZE = 8
+ const val PAYLOAD_SIZE = NONCE_SIZE + 1
+ const val TIMEOUT_MILLIS = 10_000L
+ const val INBOUND_RATE_LIMIT = 5
+ const val INBOUND_RATE_WINDOW_MILLIS = 10_000L
+ const val RELAY_JITTER_MIN_MILLIS = 20L
+ const val RELAY_JITTER_MAX_MILLIS = 60L
+ const val CAPABILITY_BIT = 6
+}
diff --git a/app/src/main/java/com/bitchat/android/protocol/MeshPingPayload.kt b/app/src/main/java/com/bitchat/android/protocol/MeshPingPayload.kt
new file mode 100644
index 00000000..1378dbb7
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/protocol/MeshPingPayload.kt
@@ -0,0 +1,46 @@
+package com.bitchat.android.protocol
+
+import java.security.SecureRandom
+
+/**
+ * iOS-compatible mesh diagnostics payload.
+ *
+ * Wire format: 8-byte nonce followed by the TTL used to launch the ping.
+ * Decoding deliberately accepts trailing bytes for forward compatibility.
+ */
+data class MeshPingPayload(
+ val nonce: ByteArray,
+ val originTtl: UByte,
+) {
+ init {
+ require(nonce.size == MeshDiagnosticsConstants.NONCE_SIZE) {
+ "Mesh ping nonce must be ${MeshDiagnosticsConstants.NONCE_SIZE} bytes"
+ }
+ }
+
+ fun encode(): ByteArray = nonce + byteArrayOf(originTtl.toByte())
+
+ fun hopCount(receivedTtl: UByte): Int =
+ (originTtl.toInt() - receivedTtl.toInt() + 1).coerceAtLeast(1)
+
+ override fun equals(other: Any?): Boolean =
+ other is MeshPingPayload && nonce.contentEquals(other.nonce) && originTtl == other.originTtl
+
+ override fun hashCode(): Int = 31 * nonce.contentHashCode() + originTtl.hashCode()
+
+ companion object {
+ fun create(originTtl: UByte): MeshPingPayload =
+ MeshPingPayload(
+ ByteArray(MeshDiagnosticsConstants.NONCE_SIZE).also(SecureRandom()::nextBytes),
+ originTtl,
+ )
+
+ fun decode(data: ByteArray): MeshPingPayload? {
+ if (data.size < MeshDiagnosticsConstants.PAYLOAD_SIZE) return null
+ return MeshPingPayload(
+ data.copyOfRange(0, MeshDiagnosticsConstants.NONCE_SIZE),
+ data[MeshDiagnosticsConstants.NONCE_SIZE].toUByte(),
+ )
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/service/TransportBridgeService.kt b/app/src/main/java/com/bitchat/android/service/TransportBridgeService.kt
index 67a7a1d8..ab0baeb6 100644
--- a/app/src/main/java/com/bitchat/android/service/TransportBridgeService.kt
+++ b/app/src/main/java/com/bitchat/android/service/TransportBridgeService.kt
@@ -44,6 +44,9 @@ object TransportBridgeService {
* Send a packet to a specific peer via this transport (optional).
*/
fun sendToPeer(peerID: String, packet: BitchatPacket) { }
+
+ /** Send directly and report whether the transport accepted the write. */
+ fun sendToPeerAndReport(peerID: String, packet: BitchatPacket): Boolean = false
}
private val transports = ConcurrentHashMap()
@@ -200,6 +203,19 @@ object TransportBridgeService {
}
}
+ fun sendToPeerFromLocalAndReport(peerID: String, packet: BitchatPacket): Boolean {
+ val targets = transports.toMap()
+ if (targets.isEmpty()) return false
+ return targets.values.fold(false) { accepted, layer ->
+ try {
+ layer.sendToPeerAndReport(peerID, packet) || accepted
+ } catch (e: Exception) {
+ Log.e(TAG, "Failed to send local peer packet: ${e.message}")
+ accepted
+ }
+ }
+ }
+
private fun prepareForwardedPacket(kind: String, packet: BitchatPacket): PreparedForward? {
if (packet.ttl == 0u.toUByte()) {
Log.d(TAG, "Dropping bridged packet type ${packet.type}: TTL expired")
diff --git a/app/src/main/java/com/bitchat/android/services/AppStateStore.kt b/app/src/main/java/com/bitchat/android/services/AppStateStore.kt
index c4f52675..86aa2f20 100644
--- a/app/src/main/java/com/bitchat/android/services/AppStateStore.kt
+++ b/app/src/main/java/com/bitchat/android/services/AppStateStore.kt
@@ -188,6 +188,11 @@ object AppStateStore {
fun addPublicMessage(msg: BitchatMessage) {
synchronized(this) {
+ if (!msg.isBridged) {
+ _publicMessages.value = _publicMessages.value.filterNot {
+ it.isBridged && it.bridgeRadioMessageIdHint == msg.id
+ }
+ }
val publicKey = publicMessageKey(msg)
if (seenMessageIds.contains(msg.id) || seenPublicMessageKeys.contains(publicKey)) return
seenMessageIds.add(msg.id)
@@ -196,6 +201,10 @@ object AppStateStore {
}
}
+ fun hasRadioPublicMessage(messageId: String): Boolean = synchronized(this) {
+ _publicMessages.value.any { !it.isBridged && it.id == messageId }
+ }
+
/** Replace a live media row by ID, or append it if the row was not admitted yet. */
fun upsertPublicMessage(msg: BitchatMessage) {
synchronized(this) {
@@ -263,6 +272,22 @@ object AppStateStore {
* Persists an incoming private message before it is admitted to UI, unread, haptic, or
* notification state. Transport callbacks invoke this from their background worker.
*/
+ suspend fun hasPrivateTextReceipt(message: BitchatMessage): Boolean {
+ val repository = synchronized(this) {
+ if (privateConversationWritesSuspended) return false
+ conversationRepository
+ } ?: return false
+ return repository.hasPrivateTextReceipt(message)
+ }
+
+ suspend fun privateMediaReceiptState(messageID: String): PrivateMediaReceiptState {
+ val repository = synchronized(this) {
+ if (privateConversationWritesSuspended) return PrivateMediaReceiptState.UNAVAILABLE
+ conversationRepository
+ } ?: return PrivateMediaReceiptState.UNAVAILABLE
+ return repository.privateMediaReceiptState(messageID)
+ }
+
suspend fun addPrivateMessageDurably(
peerID: String,
msg: BitchatMessage,
@@ -408,13 +433,27 @@ object AppStateStore {
messageID in seenMessageIds
}
+ fun removePrivateConversation(peerID: String) {
+ synchronized(this) {
+ val conversationID = ContactDirectory.canonicalConversationId(peerID)
+ val map = _privateMessages.value.toMutableMap()
+ val removedPeer = map.remove(peerID) != null
+ val removedConversation = map.remove(conversationID) != null
+ val changed = removedPeer || removedConversation
+ if (changed) {
+ _privateMessages.value = map
+ }
+ }
+ }
+
private fun statusPriority(status: DeliveryStatus?): Int = when (status) {
null -> 0
is DeliveryStatus.Sending -> 1
- is DeliveryStatus.Sent -> 2
- is DeliveryStatus.PartiallyDelivered -> 3
- is DeliveryStatus.Delivered -> 4
- is DeliveryStatus.Read -> 5
+ is DeliveryStatus.Queued -> 2
+ is DeliveryStatus.Sent -> 3
+ is DeliveryStatus.PartiallyDelivered -> 4
+ is DeliveryStatus.Delivered -> 5
+ is DeliveryStatus.Read -> 6
is DeliveryStatus.Failed -> 0
}
diff --git a/app/src/main/java/com/bitchat/android/services/ChannelInvitation.kt b/app/src/main/java/com/bitchat/android/services/ChannelInvitation.kt
new file mode 100644
index 00000000..f8c4e5bf
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/ChannelInvitation.kt
@@ -0,0 +1,15 @@
+package com.bitchat.android.services
+
+import java.net.URI
+
+/** Parses explicit channel invitations; never requests or infers device location. */
+object ChannelInvitation {
+ private val geohash = Regex("[0123456789bcdefghjkmnpqrstuvwxyz]{1,12}")
+ fun decode(link: String): String? = runCatching {
+ val uri = URI(link)
+ require(uri.scheme == "bitchat" && uri.host == "geohash" && uri.query == null && uri.fragment == null && uri.userInfo == null && uri.port == -1)
+ val cell = uri.path.removePrefix("/").lowercase()
+ cell.takeIf(geohash::matches)
+ }.getOrNull()
+ fun link(cell: String): String? = cell.lowercase().takeIf(geohash::matches)?.let { "bitchat://geohash/$it" }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/ContactDirectory.kt b/app/src/main/java/com/bitchat/android/services/ContactDirectory.kt
index 7c733958..a025c1b8 100644
--- a/app/src/main/java/com/bitchat/android/services/ContactDirectory.kt
+++ b/app/src/main/java/com/bitchat/android/services/ContactDirectory.kt
@@ -72,6 +72,9 @@ object ContactDirectory {
favorite != null -> favorite.peerNoisePublicKey
ContactIdentityResolver.isNoiseKeyHex(peerOrConversationID) ->
ContactIdentityResolver.bytesFromHex(peerOrConversationID)
+ contactFingerprint != null -> cachedNoiseKeyForFingerprint(contactFingerprint)
+ ContactIdentityResolver.isMeshPeerId(peerOrConversationID) ->
+ noiseKeyForAlias(peerOrConversationID)
else -> null
}
val liveMeshPeerID = contactFingerprint?.let { findLiveMeshPeerForFingerprint(it) }
@@ -156,6 +159,18 @@ object ContactDirectory {
}
}
+ /**
+ * A contact conversation ID contains the SHA-256 fingerprint of the Noise key, whose
+ * first 16 hex characters are the stable mesh peer ID. Recovering that cached key keeps
+ * offline routing viable after the outbox has canonicalized a peer ID to `contact_…`.
+ * Recompute the fingerprint before returning it so stale or mismatched cache entries cannot
+ * redirect a private message.
+ */
+ private fun cachedNoiseKeyForFingerprint(fingerprint: String): ByteArray? =
+ cachedNoiseKey(fingerprint.take(16))?.takeIf {
+ ContactIdentityResolver.fingerprintHex(it).equals(fingerprint, ignoreCase = true)
+ }
+
private fun cachedFingerprintNickname(fingerprint: String): String? {
val context = appContext ?: return null
return try {
diff --git a/app/src/main/java/com/bitchat/android/services/ConversationRepository.kt b/app/src/main/java/com/bitchat/android/services/ConversationRepository.kt
index bc474158..0b5ab27a 100644
--- a/app/src/main/java/com/bitchat/android/services/ConversationRepository.kt
+++ b/app/src/main/java/com/bitchat/android/services/ConversationRepository.kt
@@ -27,6 +27,8 @@ import java.util.Date
import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicBoolean
+enum class PrivateMediaReceiptState { ABSENT, ACCEPTED, TOMBSTONED, UNAVAILABLE }
+
/**
* Process-wide, serialized persistence for private conversations.
*
@@ -141,6 +143,16 @@ class ConversationRepository internal constructor(
}
}
+ suspend fun hasPrivateTextReceipt(message: BitchatMessage): Boolean = withContext(dispatcher) {
+ try { database.hasPrivateTextReceipt(message) } catch (_: Exception) { false }
+ }
+
+ suspend fun privateMediaReceiptState(messageID: String): PrivateMediaReceiptState = withContext(dispatcher) {
+ try { database.privateMediaReceiptState(messageID) } catch (_: Exception) {
+ PrivateMediaReceiptState.UNAVAILABLE
+ }
+ }
+
suspend fun upsertMessageAndWait(
conversationID: String,
aliases: Set,
@@ -743,6 +755,33 @@ internal class ConversationDatabase(
}
}
+ fun hasPrivateTextReceipt(incoming: BitchatMessage): Boolean {
+ if (!incoming.isPrivate || incoming.type != BitchatMessageType.Message) return false
+ if (isDeletedMessageLocked(readableDatabase, incoming.id)) return true
+ readableDatabase.query("private_messages", MESSAGE_COLUMNS, "message_id = ?",
+ arrayOf(incoming.id), null, null, null).use { cursor ->
+ if (!cursor.moveToFirst()) return false
+ val stored = cursor.toMessage()
+ return stored.type == BitchatMessageType.Message && stored.content == incoming.content &&
+ stored.senderPeerID == incoming.senderPeerID
+ }
+ }
+
+ fun privateMediaReceiptState(messageID: String): PrivateMediaReceiptState {
+ if (!com.bitchat.android.model.PrivateMediaMessageIdentity.isStableID(messageID)) {
+ return PrivateMediaReceiptState.UNAVAILABLE
+ }
+ if (isDeletedMessageLocked(readableDatabase, messageID)) return PrivateMediaReceiptState.TOMBSTONED
+ readableDatabase.query("private_messages", MESSAGE_COLUMNS, "message_id = ?",
+ arrayOf(messageID), null, null, null).use { cursor ->
+ if (!cursor.moveToFirst()) return PrivateMediaReceiptState.ABSENT
+ val message = cursor.toMessage()
+ return if (message.type != BitchatMessageType.Message && File(message.content).isFile) {
+ PrivateMediaReceiptState.ACCEPTED
+ } else PrivateMediaReceiptState.UNAVAILABLE
+ }
+ }
+
private fun loadDeletedMessageIDs(): Set {
readableDatabase.query(
"deleted_private_messages",
@@ -1684,6 +1723,7 @@ internal class ConversationDatabase(
null -> put("delivery_type", 0)
DeliveryStatus.Sending -> put("delivery_type", 1)
DeliveryStatus.Sent -> put("delivery_type", 2)
+ DeliveryStatus.Queued -> put("delivery_type", 7)
is DeliveryStatus.Delivered -> {
put("delivery_type", 3)
if (includeSensitiveText) put("delivery_text", status.to) else putNull("delivery_text")
@@ -1710,10 +1750,11 @@ internal class ConversationDatabase(
null -> 0
is DeliveryStatus.Failed -> 0
DeliveryStatus.Sending -> 1
- DeliveryStatus.Sent -> 2
- is DeliveryStatus.PartiallyDelivered -> 3
- is DeliveryStatus.Delivered -> 4
- is DeliveryStatus.Read -> 5
+ DeliveryStatus.Queued -> 2
+ DeliveryStatus.Sent -> 3
+ is DeliveryStatus.PartiallyDelivered -> 4
+ is DeliveryStatus.Delivered -> 5
+ is DeliveryStatus.Read -> 6
}
private fun Cursor.toMessage(): BitchatMessage {
@@ -1781,6 +1822,7 @@ internal class ConversationDatabase(
reached = nullableInt("delivery_reached") ?: 0,
total = nullableInt("delivery_total") ?: 0
)
+ 7 -> DeliveryStatus.Queued
else -> null
}
diff --git a/app/src/main/java/com/bitchat/android/services/MessageOutboxStore.kt b/app/src/main/java/com/bitchat/android/services/MessageOutboxStore.kt
new file mode 100644
index 00000000..687de6bc
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/MessageOutboxStore.kt
@@ -0,0 +1,73 @@
+package com.bitchat.android.services
+
+import android.content.Context
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+import java.io.File
+import java.nio.file.StandardCopyOption
+
+/** Keystore-sealed persistence for private messages awaiting final acknowledgement. */
+internal class MessageOutboxStore(
+ context: Context,
+ private val cipher: ConversationStorageCipher = AndroidConversationStorageCipher(KEY_ALIAS)
+) {
+ data class Entry(
+ val content: String,
+ val nickname: String,
+ val messageID: String,
+ val enqueuedAtMs: Long,
+ var sendAttempts: Int = 0,
+ var lastAttemptAtMs: Long = 0,
+ var bridgeDeposited: Boolean = false,
+ var lastBridgeAttemptAtMs: Long = 0,
+ val depositedCourierKeys: MutableSet = mutableSetOf()
+ )
+
+ companion object {
+ private const val KEY_ALIAS = "bitchat_message_outbox_v1"
+ private val AAD = "bitchat-message-outbox-v1".toByteArray(Charsets.UTF_8)
+ }
+
+ private val gson = Gson()
+ private val file = File(context.applicationContext.filesDir, "message-outbox.sealed")
+
+ @Synchronized
+ fun load(): MutableMap> = try {
+ if (!file.exists()) return mutableMapOf()
+ val plaintext = cipher.decrypt(file.readBytes(), AAD)
+ val type = object : TypeToken>>() {}.type
+ gson.fromJson>>(plaintext.toString(Charsets.UTF_8), type)
+ ?: mutableMapOf()
+ } catch (_: Exception) {
+ mutableMapOf()
+ }
+
+ @Synchronized
+ fun save(outbox: Map>) {
+ if (outbox.values.all { it.isEmpty() }) {
+ file.delete()
+ return
+ }
+ val plaintext = gson.toJson(outbox).toByteArray(Charsets.UTF_8)
+ val encrypted = cipher.encrypt(plaintext, AAD)
+ val temporary = File(file.parentFile, "${file.name}.tmp")
+ temporary.writeBytes(encrypted)
+ try {
+ java.nio.file.Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.ATOMIC_MOVE,
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ } catch (e: Exception) {
+ temporary.delete()
+ throw IllegalStateException("Failed to persist message outbox", e)
+ }
+ }
+
+ @Synchronized
+ fun wipe() {
+ file.delete()
+ cipher.destroyKey()
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/MessageRouter.kt b/app/src/main/java/com/bitchat/android/services/MessageRouter.kt
index dc6ad4d2..ee83cf07 100644
--- a/app/src/main/java/com/bitchat/android/services/MessageRouter.kt
+++ b/app/src/main/java/com/bitchat/android/services/MessageRouter.kt
@@ -31,13 +31,6 @@ class MessageRouter private constructor(
DROPPED
}
- private data class QueuedMessage(
- val content: String,
- val nickname: String,
- val messageID: String,
- val enqueuedAtMs: Long
- )
-
private data class ConversationRetry(
val handshakeAttempts: Int,
val nextHandshakeAttemptAtMs: Long
@@ -48,10 +41,15 @@ class MessageRouter private constructor(
private const val OUTBOX_TICK_MS = AppConstants.Router.OUTBOX_TICK_MS
private const val OUTBOX_MESSAGE_TTL_MS = AppConstants.Router.OUTBOX_MESSAGE_TTL_MS
private const val OUTBOX_MAX_PER_PEER = AppConstants.Router.OUTBOX_MAX_PER_PEER
+ private const val MAX_COURIERS_PER_MESSAGE = AppConstants.Router.MAX_COURIERS_PER_MESSAGE
+ private const val OUTBOX_MAX_TOTAL = 1_000
+ private const val OUTBOX_MAX_SEND_ATTEMPTS = 8
+ private const val BRIDGE_RETRY_COOLDOWN_MS = 30 * 60 * 1000L
private val HANDSHAKE_RETRY_BACKOFF_MS = AppConstants.Router.HANDSHAKE_RETRY_BACKOFF_MS
@Volatile private var INSTANCE: MessageRouter? = null
internal var disableSchedulerForTesting = false
+ internal var outboxStoreFactory: (Context) -> MessageOutboxStore = ::MessageOutboxStore
fun tryGetInstance(): MessageRouter? = INSTANCE
fun getInstance(context: Context, mesh: MeshService): MessageRouter {
val instance = INSTANCE ?: synchronized(this) {
@@ -78,10 +76,19 @@ class MessageRouter private constructor(
INSTANCE?.schedulerScope?.cancel()
INSTANCE = null
}
+
+ fun panicClear(context: Context) {
+ val instance = INSTANCE
+ if (instance != null) instance.clearAll()
+ else outboxStoreFactory(context.applicationContext).wipe()
+ }
}
// Outbox: conversationID -> queued messages, oldest first
- private val outbox = ConcurrentHashMap>()
+ private val outboxStore = outboxStoreFactory(context)
+ private val outbox = ConcurrentHashMap>().apply {
+ putAll(outboxStore.load())
+ }
// Per-conversation handshake retry state for queued messages
private val retryState = ConcurrentHashMap()
@@ -99,9 +106,13 @@ class MessageRouter private constructor(
startOutboxScheduler()
}
+ @Synchronized
fun clearAll() {
+ schedulerJob?.cancel()
+ schedulerJob = null
outbox.clear()
retryState.clear()
+ outboxStore.wipe()
Log.d(TAG, "Cleared all MessageRouter outbox messages and retry state")
}
@@ -134,17 +145,23 @@ class MessageRouter private constructor(
}
val hasMesh = meshTarget?.let { isConnected(mesh, it) } == true
+ val entry = MessageOutboxStore.Entry(content, recipientNickname, messageID, clock())
+ enqueue(conversationID, entry)
if (meshTarget != null && isReady(mesh, meshTarget)) {
Log.d(TAG, "Routing PM via mesh to ${meshTarget} msg_id=${messageID.take(8)}…")
mesh.sendPrivateMessage(content, meshTarget, recipientNickname, messageID)
+ markAttempt(conversationID, messageID)
return RouteResult.MESH
} else if (canSendViaNostr(nostrTarget)) {
Log.d(TAG, "Routing PM via Nostr to ${conversationID.take(32)}… msg_id=${messageID.take(8)}…")
nostr.sendPrivateMessage(content, nostrTarget, recipientNickname, messageID)
- return RouteResult.NOSTR
+ markAttempt(conversationID, messageID)
+ val prompt = canDeliverViaNostrPromptly()
+ if (!prompt) attemptCourierDeposit(conversationID, entry)
+ return if (prompt) RouteResult.NOSTR else RouteResult.QUEUED
} else {
Log.d(TAG, "Queued PM for ${conversationID} (no mesh, no Nostr mapping) msg_id=${messageID.take(8)}…")
- enqueue(conversationID, QueuedMessage(content, recipientNickname, messageID, clock()))
+ attemptCourierDeposit(conversationID, entry)
Log.d(TAG, "Initiating noise handshake after queueing PM for ${conversationID.take(16)}…")
if (hasMesh) meshTarget?.let { kickHandshake(conversationID, it, immediate = true) }
return RouteResult.QUEUED
@@ -209,12 +226,17 @@ class MessageRouter private constructor(
val resolution = ContactDirectory.resolve(conversationID)
val meshTarget = resolution.meshPeerID
val nostrTarget = resolution.noiseKeyHex ?: conversationID
+ if (clock() - entry.lastAttemptAtMs < retryDelay(entry.sendAttempts)) continue
+ if (entry.sendAttempts >= OUTBOX_MAX_SEND_ATTEMPTS) continue
if (meshTarget != null && isReady(mesh, meshTarget)) {
mesh.sendPrivateMessage(entry.content, meshTarget, entry.nickname, entry.messageID)
- iterator.remove()
+ entry.sendAttempts++
+ entry.lastAttemptAtMs = clock()
} else if (canSendViaNostr(nostrTarget)) {
nostr.sendPrivateMessage(entry.content, nostrTarget, entry.nickname, entry.messageID)
- iterator.remove()
+ entry.sendAttempts++
+ entry.lastAttemptAtMs = clock()
+ if (!canDeliverViaNostrPromptly()) attemptCourierDeposit(conversationID, entry)
}
}
if (queued.isEmpty()) {
@@ -223,6 +245,7 @@ class MessageRouter private constructor(
retryState.remove(conversationID)
retryState.remove(peerID)
}
+ persistOutbox()
}
// Flush everything (rarely used)
@@ -231,14 +254,120 @@ class MessageRouter private constructor(
}
@Synchronized
- private fun enqueue(conversationID: String, entry: QueuedMessage) {
+ private fun enqueue(conversationID: String, entry: MessageOutboxStore.Entry) {
val queue = outbox.getOrPut(conversationID) { mutableListOf() }
+ if (queue.any { it.messageID == entry.messageID }) return
queue.add(entry)
while (queue.size > OUTBOX_MAX_PER_PEER) {
val evicted = queue.removeAt(0)
Log.w(TAG, "Outbox full for ${conversationID.take(16)}…; evicting oldest msg_id=${evicted.messageID.take(8)}…")
notifyExpired(evicted.messageID)
}
+ while (outbox.values.sumOf { it.size } > OUTBOX_MAX_TOTAL) {
+ val oldest = outbox.entries
+ .flatMap { (id, entries) -> entries.map { id to it } }
+ .minByOrNull { it.second.enqueuedAtMs } ?: break
+ outbox[oldest.first]?.remove(oldest.second)
+ if (outbox[oldest.first].isNullOrEmpty()) outbox.remove(oldest.first)
+ notifyExpired(oldest.second.messageID)
+ }
+ persistOutbox()
+ }
+
+ @Synchronized
+ fun onMessageAcknowledged(messageID: String, peerID: String) {
+ val acknowledgedConversation = ContactDirectory.canonicalConversationId(peerID)
+ var changed = false
+ outbox.entries.toList().forEach { (conversationID, queue) ->
+ if (ContactDirectory.canonicalConversationId(conversationID) != acknowledgedConversation) return@forEach
+ changed = queue.removeAll { it.messageID == messageID } || changed
+ if (queue.isEmpty()) {
+ outbox.remove(conversationID, queue)
+ retryState.remove(conversationID)
+ }
+ }
+ if (changed) persistOutbox()
+ }
+
+ @Synchronized
+ private fun markAttempt(conversationID: String, messageID: String) {
+ outbox[conversationID]?.firstOrNull { it.messageID == messageID }?.sendAttempts =
+ (outbox[conversationID]?.firstOrNull { it.messageID == messageID }?.sendAttempts ?: 0) + 1
+ outbox[conversationID]?.firstOrNull { it.messageID == messageID }?.lastAttemptAtMs = clock()
+ persistOutbox()
+ }
+
+ private fun retryDelay(attempts: Int): Long = when (attempts) {
+ 0 -> 0L
+ 1 -> 30_000L
+ 2 -> 2 * 60_000L
+ else -> 10 * 60_000L
+ }
+
+ private fun attemptCourierDeposit(conversationID: String, entry: MessageOutboxStore.Entry) {
+ val resolution = ContactDirectory.resolve(conversationID)
+ val recipientKey = resolution.noiseKeyHex?.let(ContactIdentityResolver::bytesFromHex) ?: return
+ if (!entry.bridgeDeposited &&
+ (entry.lastBridgeAttemptAtMs == 0L || clock() - entry.lastBridgeAttemptAtMs >= BRIDGE_RETRY_COOLDOWN_MS)
+ ) {
+ val submitted = mesh.sendBridgeCourierMessage(entry.content, entry.messageID, recipientKey) {
+ synchronized(this) {
+ val current = outbox[conversationID]?.firstOrNull { it.messageID == entry.messageID }
+ if (current != null) {
+ current.bridgeDeposited = true
+ persistOutbox()
+ }
+ }
+ }
+ if (submitted) {
+ entry.lastBridgeAttemptAtMs = clock()
+ persistOutbox()
+ }
+ }
+ if (entry.depositedCourierKeys.size >= MAX_COURIERS_PER_MESSAGE) return
+ val candidates = mesh.getPeerInfos()
+ .asSequence()
+ .filter { it.isConnected && it.noisePublicKey != null && !it.noisePublicKey!!.contentEquals(recipientKey) }
+ .filter { peer ->
+ val favorite = try {
+ com.bitchat.android.favorites.FavoritesPersistenceService.shared
+ .getFavoriteStatus(peer.noisePublicKey!!)?.isMutual == true
+ } catch (_: Exception) { false }
+ favorite || peer.hasVerifiedAnnouncement
+ }
+ .map { peer ->
+ val favorite = try {
+ com.bitchat.android.favorites.FavoritesPersistenceService.shared
+ .getFavoriteStatus(peer.noisePublicKey!!)?.isMutual == true
+ } catch (_: Exception) { false }
+ peer to favorite
+ }
+ .filter { (peer, _) -> ContactIdentityResolver.noiseKeyHex(peer.noisePublicKey!!) !in entry.depositedCourierKeys }
+ .sortedByDescending { (_, favorite) -> favorite }
+ .take(MAX_COURIERS_PER_MESSAGE - entry.depositedCourierKeys.size)
+ .map { (peer, _) -> peer }
+ .toList()
+ if (candidates.isEmpty()) return
+ val accepted = mesh.sendCourierMessage(
+ entry.content,
+ entry.messageID,
+ recipientKey,
+ candidates.map { it.id }
+ ).toSet()
+ candidates.filter { it.id in accepted }.forEach {
+ entry.depositedCourierKeys += ContactIdentityResolver.noiseKeyHex(it.noisePublicKey!!)
+ }
+ if (accepted.isNotEmpty()) persistOutbox()
+ }
+
+ private fun canDeliverViaNostrPromptly(): Boolean = try {
+ nostr.canDeliverPromptly()
+ } catch (_: Exception) { false }
+
+ private fun persistOutbox() {
+ try { outboxStore.save(outbox) } catch (e: Exception) {
+ Log.e(TAG, "Failed to persist sealed outbox: ${e.message}")
+ }
}
private fun notifyExpired(messageID: String) {
@@ -286,6 +415,7 @@ class MessageRouter private constructor(
* follow the MeshForegroundService lifecycle; getInstance restarts the scheduler
* and rebinds the mesh reference when the service comes back.
*/
+ @Synchronized
fun stopOutboxScheduler() {
schedulerJob?.cancel()
schedulerJob = null
@@ -304,6 +434,7 @@ class MessageRouter private constructor(
expireOldEntries(conversationID, nowMs)
val queued = outbox[conversationID] ?: return@forEach
if (queued.isEmpty()) return@forEach
+ queued.forEach { attemptCourierDeposit(conversationID, it) }
val resolution = ContactDirectory.resolve(conversationID)
val meshTarget = resolution.meshPeerID
@@ -338,6 +469,7 @@ class MessageRouter private constructor(
outbox.remove(conversationID, queued)
retryState.remove(conversationID)
}
+ persistOutbox()
}
private fun canSendViaNostr(peerID: String): Boolean {
@@ -385,8 +517,18 @@ class MessageRouter private constructor(
} catch (_: Exception) { null }
noiseHex?.let {
kickHandshakeIfPending(it)
- flushOutboxFor(it)
+ if (ContactDirectory.canonicalConversationId(it) != ContactDirectory.canonicalConversationId(pid)) {
+ flushOutboxFor(it)
+ }
}
+ retryCourierDeposits()
+ }
+ }
+
+ @Synchronized
+ private fun retryCourierDeposits() {
+ outbox.forEach { (conversationID, entries) ->
+ entries.forEach { attemptCourierDeposit(conversationID, it) }
}
}
@@ -399,7 +541,9 @@ class MessageRouter private constructor(
} catch (_: Exception) { null }
noiseHex?.let {
resetRetry(it)
- flushOutboxFor(it)
+ if (ContactDirectory.canonicalConversationId(it) != ContactDirectory.canonicalConversationId(peerID)) {
+ flushOutboxFor(it)
+ }
}
}
diff --git a/app/src/main/java/com/bitchat/android/services/PrivateMediaOutbox.kt b/app/src/main/java/com/bitchat/android/services/PrivateMediaOutbox.kt
new file mode 100644
index 00000000..788a3a3c
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/PrivateMediaOutbox.kt
@@ -0,0 +1,190 @@
+package com.bitchat.android.services
+
+import android.content.Context
+import android.util.AtomicFile
+import android.util.Base64
+import com.bitchat.android.mesh.MeshService
+import com.bitchat.android.mesh.PrivateMediaPreparation
+import com.bitchat.android.model.BitchatFilePacket
+import com.bitchat.android.model.DeliveryStatus
+import com.bitchat.android.model.PrivateMediaMessageIdentity
+import com.google.gson.Gson
+import java.io.File
+import java.security.MessageDigest
+import kotlinx.coroutines.*
+import kotlinx.coroutines.sync.Mutex
+import kotlinx.coroutines.sync.withLock
+
+/** One encrypted atomic record per pending media message; no plaintext retransmission spool. */
+internal class PrivateMediaOutboxStore(
+ context: Context,
+ private val cipher: ConversationStorageCipher = AndroidConversationStorageCipher("bitchat_private_media_outbox_v1")
+) {
+ data class Entry(
+ val id: String,
+ val conversationID: String,
+ val recipientPeerID: String,
+ val encodedPacket: String,
+ val createdAt: Long,
+ val attempts: Int = 1,
+ val lastAttemptAt: Long = createdAt
+ )
+
+ private val directory = File(context.filesDir, "private-media-outbox")
+ private val gson = Gson()
+
+ fun load(): List {
+ if (!directory.exists()) return emptyList()
+ return checkNotNull(directory.listFiles()).filter { PrivateMediaMessageIdentity.isStableID(it.name) }
+ .take(MAX_ENTRIES).mapNotNull { file ->
+ // A corrupt record stays quarantined in place; it is never retransmitted.
+ runCatching {
+ require(file.length() <= MAX_RECORD_BYTES)
+ val plaintext = cipher.decrypt(AtomicFile(file).readFully(), file.name.toByteArray())
+ gson.fromJson(plaintext.toString(Charsets.UTF_8), Entry::class.java)
+ .also { require(it.id == file.name && it.attempts in 1..MAX_ATTEMPTS) }
+ }.getOrNull()
+ }
+ }
+
+ fun save(entry: Entry) {
+ require(PrivateMediaMessageIdentity.isStableID(entry.id))
+ check(directory.isDirectory || directory.mkdirs())
+ val files = checkNotNull(directory.listFiles())
+ val file = File(directory, entry.id)
+ check(file.exists() || files.size < MAX_ENTRIES)
+ val encrypted = cipher.encrypt(gson.toJson(entry).toByteArray(), entry.id.toByteArray())
+ require(encrypted.size <= MAX_RECORD_BYTES)
+ check(files.sumOf { it.length() } - file.length() + encrypted.size <= MAX_TOTAL_BYTES)
+ val atomic = AtomicFile(file)
+ val stream = atomic.startWrite()
+ try {
+ stream.write(encrypted)
+ atomic.finishWrite(stream)
+ } catch (error: Exception) {
+ atomic.failWrite(stream)
+ throw error
+ }
+ }
+
+ fun remove(id: String) {
+ require(PrivateMediaMessageIdentity.isStableID(id))
+ AtomicFile(File(directory, id)).delete()
+ check(!File(directory, id).exists())
+ }
+
+ fun wipe() {
+ cipher.destroyKey()
+ check(!directory.exists() || directory.deleteRecursively())
+ }
+
+ companion object {
+ const val MAX_ATTEMPTS = 8
+ private const val MAX_ENTRIES = 100
+ private const val MAX_RECORD_BYTES = 8 * 1024 * 1024L
+ private const val MAX_TOTAL_BYTES = 64 * 1024 * 1024L
+ }
+}
+
+/** Retries the original file and message identity until a matching recipient acknowledges it. */
+class PrivateMediaOutbox private constructor(context: Context) {
+ private val store = PrivateMediaOutboxStore(context)
+ private val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+ private val mutex = Mutex()
+ private var entries: MutableMap? = null
+ @Volatile private var paused = false
+
+ init {
+ scope.launch {
+ while (isActive) {
+ delay(15_000)
+ runCatching { retryPending() }
+ }
+ }
+ }
+
+ private fun loaded(): MutableMap =
+ entries ?: store.load().associateByTo(linkedMapOf()) { it.id }.also { entries = it }
+
+ suspend fun enqueue(id: String, conversationID: String, recipientPeerID: String, packet: BitchatFilePacket): Boolean =
+ withContext(Dispatchers.IO) {
+ mutex.withLock {
+ if (paused) return@withLock false
+ runCatching {
+ val encoded = checkNotNull(packet.encode())
+ val entry = PrivateMediaOutboxStore.Entry(id, conversationID, recipientPeerID,
+ Base64.encodeToString(encoded, Base64.NO_WRAP), System.currentTimeMillis())
+ store.save(entry)
+ loaded()[id] = entry
+ true
+ }.getOrDefault(false)
+ }
+ }
+
+ fun acknowledge(id: String, peerID: String) {
+ if (!PrivateMediaMessageIdentity.isStableID(id)) return
+ scope.launch {
+ mutex.withLock {
+ val entry = loaded()[id] ?: return@withLock
+ if (entry.recipientPeerID != peerID) return@withLock
+ runCatching { store.remove(id) }.onSuccess { loaded().remove(id) }
+ }
+ }
+ }
+
+ suspend fun wipe() {
+ paused = true
+ withContext(Dispatchers.IO) {
+ mutex.withLock {
+ store.wipe()
+ entries = linkedMapOf()
+ }
+ }
+ }
+
+ fun resume() { paused = false }
+
+ private suspend fun retryPending() = mutex.withLock {
+ if (paused) return@withLock
+ val mesh = com.bitchat.android.service.MeshServiceHolder.unifiedMeshService ?: return@withLock
+ val now = System.currentTimeMillis()
+ loaded().values.toList().forEach { entry ->
+ if (AppStateStore.privateMediaReceiptState(entry.id) == PrivateMediaReceiptState.TOMBSTONED) {
+ store.remove(entry.id)
+ loaded().remove(entry.id)
+ return@forEach
+ }
+ if (now - entry.createdAt > 24 * 60 * 60 * 1000L ||
+ (entry.attempts >= PrivateMediaOutboxStore.MAX_ATTEMPTS && now - entry.lastAttemptAt >= 300_000)) {
+ AppStateStore.updatePrivateMessageStatus(entry.id, DeliveryStatus.Failed("No delivery receipt received"))
+ store.remove(entry.id)
+ loaded().remove(entry.id)
+ return@forEach
+ }
+ if (entry.attempts >= PrivateMediaOutboxStore.MAX_ATTEMPTS) return@forEach
+ val interval = (30_000L shl (entry.attempts - 1).coerceAtMost(4)).coerceAtMost(300_000L)
+ if (now - entry.lastAttemptAt < interval) return@forEach
+ val recipient = ContactDirectory.resolve(entry.conversationID).meshPeerID ?: return@forEach
+ if (recipient != entry.recipientPeerID || !mesh.supportsPrivateMediaReceipts(recipient)) return@forEach
+ val encoded = Base64.decode(entry.encodedPacket, Base64.NO_WRAP)
+ val packet = BitchatFilePacket.decode(encoded) ?: return@forEach
+ if (PrivateMediaMessageIdentity.stableID(mesh.myPeerID, recipient, packet.fileName) != entry.id) return@forEach
+ val transferID = MessageDigest.getInstance("SHA-256").digest(encoded).joinToString("") { "%02x".format(it) }
+ val prepared = mesh.prepareFilePrivate(recipient, packet, transferID, allowLegacyFallback = false)
+ if (prepared is PrivateMediaPreparation.Ready) {
+ val attempted = entry.copy(attempts = entry.attempts + 1, lastAttemptAt = now)
+ store.save(attempted)
+ loaded()[entry.id] = attempted
+ if (prepared.transfer.commit()) AppStateStore.updatePrivateMessageStatus(entry.id, DeliveryStatus.Sent)
+ }
+ }
+ }
+
+ companion object {
+ @Volatile private var instance: PrivateMediaOutbox? = null
+ fun initialize(context: Context): PrivateMediaOutbox = instance ?: synchronized(this) {
+ instance ?: PrivateMediaOutbox(context.applicationContext).also { instance = it }
+ }
+ fun tryGetInstance(): PrivateMediaOutbox? = instance
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/VerificationService.kt b/app/src/main/java/com/bitchat/android/services/VerificationService.kt
index 06dcd6f3..21719bbe 100644
--- a/app/src/main/java/com/bitchat/android/services/VerificationService.kt
+++ b/app/src/main/java/com/bitchat/android/services/VerificationService.kt
@@ -146,7 +146,10 @@ object VerificationService {
val service = encryptionServiceRef?.get() ?: return null
val qr = VerificationQR.fromUrlString(urlString) ?: return null
val now = System.currentTimeMillis() / 1000L
- if (now - qr.ts > maxAgeSeconds) return null
+ // Freshness in both directions: a future-dated timestamp must not
+ // buy a QR a longer validity window than a fresh one gets. iOS uses
+ // the same abs() check in VerificationService.verifyScannedQR.
+ if (verificationTimestampSkewSeconds(now, qr.ts) > maxAgeSeconds) return null
val sig = qr.sigHex.dataFromHexString() ?: return null
val signKey = qr.signKeyHex.dataFromHexString() ?: return null
@@ -292,3 +295,10 @@ object VerificationService {
var last: CacheEntry? = null
}
}
+
+/** Absolute age of a verification QR timestamp, in seconds. */
+internal fun verificationTimestampSkewSeconds(nowSeconds: Long, qrTimestampSeconds: Long): Long {
+ if (nowSeconds < 0 || qrTimestampSeconds < 0) return Long.MAX_VALUE
+ return if (nowSeconds >= qrTimestampSeconds) nowSeconds - qrTimestampSeconds
+ else qrTimestampSeconds - nowSeconds
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/BridgeCollections.kt b/app/src/main/java/com/bitchat/android/services/bridge/BridgeCollections.kt
new file mode 100644
index 00000000..2ae7da18
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/BridgeCollections.kt
@@ -0,0 +1,47 @@
+package com.bitchat.android.services.bridge
+
+
+internal class BoundedIdSet(private val capacity: Int) {
+ private val values = LinkedHashSet()
+
+ fun add(id: String): Boolean {
+ if (!values.add(id)) return false
+ while (values.size > capacity) values.remove(values.first())
+ return true
+ }
+
+ fun contains(id: String): Boolean = id in values
+
+ fun clear() = values.clear()
+}
+
+/**
+ * Owns one logical relay subscription while assigning a distinct wire ID to
+ * every replacement. Relay CLOSE/REQ writes may execute out of order, but a
+ * delayed close can only affect the retired generation.
+ *
+ * Callers keep this object confined to their coordinator dispatcher.
+ */
+internal class RelaySubscriptionSlot(private val idPrefix: String) {
+ private var generation = 0L
+ private var activeId: String? = null
+
+ fun replace(close: (String) -> Unit, open: (String) -> Unit): String {
+ activeId?.let(close)
+ val replacementId = "$idPrefix-${++generation}"
+ activeId = replacementId
+ try {
+ open(replacementId)
+ } catch (error: Throwable) {
+ activeId = null
+ throw error
+ }
+ return replacementId
+ }
+
+ fun close(close: (String) -> Unit) {
+ val id = activeId ?: return
+ activeId = null
+ close(id)
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/BridgeModels.kt b/app/src/main/java/com/bitchat/android/services/bridge/BridgeModels.kt
new file mode 100644
index 00000000..8683241e
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/BridgeModels.kt
@@ -0,0 +1,29 @@
+package com.bitchat.android.services.bridge
+
+import com.bitchat.android.model.PeerCapabilities
+
+data class BridgedParticipant(
+ val pubkey: String,
+ val nickname: String?,
+ val lastSeenMs: Long
+) {
+ val displayName: String
+ get() = "${nickname?.trim()?.takeIf { it.isNotEmpty() } ?: "anon"}#${pubkey.takeLast(4)}"
+}
+
+data class BridgeUiState(
+ val enabled: Boolean = false,
+ val nearbyOnly: Boolean = false,
+ val participants: List = emptyList()
+)
+
+internal data class VerifiedBridgePeer(
+ val peerId: String,
+ val nickname: String,
+ val noiseKey: ByteArray,
+ val signingKey: ByteArray,
+ val isVerifiedNickname: Boolean,
+ val capabilities: PeerCapabilities?,
+ val bridgeCell: String?,
+ val lastSeenMs: Long
+)
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/BridgePacketSignatureVerifier.kt b/app/src/main/java/com/bitchat/android/services/bridge/BridgePacketSignatureVerifier.kt
new file mode 100644
index 00000000..dcc1f668
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/BridgePacketSignatureVerifier.kt
@@ -0,0 +1,40 @@
+package com.bitchat.android.services.bridge
+
+import com.bitchat.android.protocol.BitchatPacket
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters
+import org.bouncycastle.crypto.signers.Ed25519Signer
+
+/**
+ * Verifies bridge protocol packets against the signing key bound by the
+ * sender's authenticated announcement.
+ */
+internal object BridgePacketSignatureVerifier {
+ fun verify(packet: BitchatPacket, publicKey: ByteArray): Boolean {
+ val signature = packet.signature?.takeIf { it.size == 64 } ?: return false
+ val signingData = packet.toBinaryDataForSigning() ?: return false
+ if (publicKey.size != 32) return false
+ return runCatching {
+ Ed25519Signer().apply {
+ init(false, Ed25519PublicKeyParameters(publicKey, 0))
+ update(signingData, 0, signingData.size)
+ }.verifySignature(signature)
+ }.getOrDefault(false)
+ }
+}
+
+internal object CourierDepositAuthenticator {
+ fun authenticate(
+ packet: BitchatPacket,
+ fromPeerId: String,
+ directIngress: Boolean,
+ peers: List,
+ isTrusted: (VerifiedBridgePeer) -> Boolean
+ ): VerifiedBridgePeer? {
+ if (!directIngress || packet.senderID.toHex() != fromPeerId) return null
+ val peer = peers.firstOrNull { it.peerId == fromPeerId } ?: return null
+ if (!BridgePacketSignatureVerifier.verify(packet, peer.signingKey)) return null
+ return peer.takeIf(isTrusted)
+ }
+
+ private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/BridgeProtocolPacketFactory.kt b/app/src/main/java/com/bitchat/android/services/bridge/BridgeProtocolPacketFactory.kt
new file mode 100644
index 00000000..247d6a34
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/BridgeProtocolPacketFactory.kt
@@ -0,0 +1,46 @@
+package com.bitchat.android.services.bridge
+
+import com.bitchat.android.mesh.MeshPacketUtils
+import com.bitchat.android.mesh.BridgeMeshPort
+import com.bitchat.android.model.IdentityAnnouncement
+import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.protocol.MessageType
+
+/**
+ * Shared construction policy for bridge protocol packets emitted by BLE and
+ * Wi-Fi Aware mesh implementations.
+ */
+internal object BridgeProtocolPacketFactory {
+ fun protocolPacket(
+ type: MessageType,
+ payload: ByteArray,
+ senderPeerId: String,
+ recipientPeerId: String?,
+ ttl: UByte,
+ nowMs: Long = System.currentTimeMillis()
+ ): BitchatPacket? {
+ if (payload.isEmpty()) return null
+ return BitchatPacket(
+ version = if (payload.size > 0xFFFF) 2u else 1u,
+ type = type.value,
+ senderID = MeshPacketUtils.hexStringToByteArray(senderPeerId),
+ recipientID = recipientPeerId?.let(MeshPacketUtils::hexStringToByteArray),
+ timestamp = nowMs.toULong(),
+ payload = payload,
+ signature = null,
+ ttl = ttl
+ )
+ }
+
+ fun identityAnnouncement(
+ nickname: String,
+ noiseStaticKey: ByteArray,
+ signingKey: ByteArray
+ ): IdentityAnnouncement =
+ IdentityAnnouncement.forLocalPeer(
+ nickname,
+ noiseStaticKey,
+ signingKey,
+ BridgeMeshPort.advertisedCell()
+ )
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/MeshBridgeService.kt b/app/src/main/java/com/bitchat/android/services/bridge/MeshBridgeService.kt
new file mode 100644
index 00000000..3c40e6b7
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/MeshBridgeService.kt
@@ -0,0 +1,774 @@
+package com.bitchat.android.services.bridge
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.util.Log
+import androidx.core.content.edit
+import com.bitchat.android.favorites.FavoritesPersistenceService
+import com.bitchat.android.geohash.Geohash
+import com.bitchat.android.geohash.GeohashChannelLevel
+import com.bitchat.android.geohash.LocationChannelManager
+import com.bitchat.android.mesh.MeshService
+import com.bitchat.android.mesh.BridgeMeshDelegate
+import com.bitchat.android.mesh.BridgeOutboundPolicy
+import com.bitchat.android.model.BitchatMessage
+import com.bitchat.android.model.IdentityAnnouncement
+import com.bitchat.android.model.NostrCarrierPacket
+import com.bitchat.android.model.PeerCapabilities
+import com.bitchat.android.nostr.MeshMessageIdentity
+import com.bitchat.android.nostr.NostrEvent
+import com.bitchat.android.nostr.NostrFilter
+import com.bitchat.android.nostr.NostrIdentityBridge
+import com.bitchat.android.nostr.NostrKind
+import com.bitchat.android.nostr.NostrProtocol
+import com.bitchat.android.nostr.NostrRelayManager
+import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.services.AppStateStore
+import com.bitchat.android.services.ContactIdentityResolver
+import com.bitchat.android.ui.DataManager
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.distinctUntilChanged
+import kotlinx.coroutines.flow.map
+import kotlinx.coroutines.launch
+import java.util.Date
+import java.util.concurrent.atomic.AtomicReference
+import kotlin.math.abs
+
+/**
+ * Opt-in bridge policy shared by foreground transport and Compose UI.
+ *
+ * Outbound public traffic crosses the bridge only when the author opted in
+ * and did not mark the message nearby-only. Passive `fromBridge` reception is
+ * accepted regardless of the switch because it exposes no local traffic.
+ */
+object MeshBridgeService : BridgeMeshDelegate {
+ private data class PendingUplink(
+ val depositor: String,
+ val cell: String,
+ val event: NostrEvent
+ )
+
+ private data class PendingDownlink(
+ val cell: String,
+ val event: NostrEvent
+ )
+
+ private const val TAG = "MeshBridgeService"
+ private const val PREFS = "bitchat_bridge"
+ private const val KEY_ENABLED = "bridge_enabled_v1"
+ private const val CELL_PRECISION = 6
+ private const val MAX_EVENT_AGE_MS = 15L * 60 * 1000
+ private const val MAX_CONTENT_BYTES = 16_000
+ private const val MAX_TRACKED_IDS = 512
+ private const val MAX_PARTICIPANTS = 128
+ private const val PARTICIPANT_FRESH_MS = 10L * 60 * 1000
+ private const val PRESENCE_INTERVAL_MS = 4L * 60 * 1000
+ private const val MAX_QUEUED_UPLINKS = 20
+ private const val MAX_UPLINKS_PER_DEPOSITOR = 5
+ private const val UPLINKS_PER_MINUTE_PER_DEPOSITOR = 10
+ private const val MAX_PENDING_DOWNLINKS = 30
+ private const val DOWNLINKS_PER_MINUTE = 20
+ private const val INBOUND_PER_MINUTE = 600
+ private const val INBOUND_PER_SIGNER_PER_MINUTE = 120
+ private const val SIGNATURE_ATTEMPTS_PER_MINUTE = 720
+
+ private val dispatcher = Dispatchers.Default.limitedParallelism(1)
+ private val scope = CoroutineScope(SupervisorJob() + dispatcher)
+ private val _isEnabled = MutableStateFlow(false)
+ val isEnabled: StateFlow = _isEnabled.asStateFlow()
+ private val _nearbyOnly = MutableStateFlow(false)
+ val nearbyOnly: StateFlow = _nearbyOnly.asStateFlow()
+ private val _activeCell = MutableStateFlow(null)
+ val activeCell: StateFlow = _activeCell.asStateFlow()
+ private val _bridgedParticipants = MutableStateFlow>(emptyList())
+ val bridgedParticipants: StateFlow> = _bridgedParticipants.asStateFlow()
+ private val outboundPolicy = AtomicReference(BridgeOutboundPolicy.Denied)
+ private val rendezvousSubscription = RelaySubscriptionSlot("mesh-bridge-rendezvous")
+
+ @Volatile
+ private var appContext: Context? = null
+ private var relayManager: NostrRelayManager? = null
+ private var prekeyCoordinator: PrekeyCoordinator? = null
+ private var prefs: android.content.SharedPreferences? = null
+ @Volatile
+ private var meshProvider: () -> MeshService? = { null }
+ private var clock: () -> Long = System::currentTimeMillis
+ private var jitter: (Long, Long) -> Long = kotlin.random.Random::nextLong
+ private var localLocationCell: String? = null
+ private var subscribedCells: Set = emptySet()
+ private val verifiedPeers = linkedMapOf()
+ private val verifiedPeerSnapshot = AtomicReference>(emptyList())
+ private val publishedEventIds = BoundedIdSet(MAX_TRACKED_IDS)
+ private val receivedEventIds = BoundedIdSet(MAX_TRACKED_IDS)
+ private val meshBroadcastEventIds = BoundedIdSet(MAX_TRACKED_IDS)
+ private val rebroadcastEventIds = BoundedIdSet(MAX_TRACKED_IDS)
+ private val injectedEventIds = BoundedIdSet(MAX_TRACKED_IDS)
+ private val radioMessageIds = BoundedIdSet(MAX_TRACKED_IDS)
+ private val queuedUplinks = mutableListOf()
+ private val pendingDownlinks = mutableListOf()
+ private val participants = linkedMapOf()
+ private val uplinkTimes = mutableMapOf>()
+ private val inboundTimes = mutableListOf()
+ private val inboundTimesBySigner = mutableMapOf>()
+ private val downlinkTimes = mutableListOf()
+ private val signatureAttemptTimes = mutableListOf()
+ private var downlinkJob: Job? = null
+ private var presenceJob: Job? = null
+ @Volatile
+ private var suppressPrekeyBroadcasts = false
+ @Volatile
+ private var panicQuiesced = false
+
+ fun initialize(
+ context: Context,
+ meshProvider: () -> MeshService? = {
+ com.bitchat.android.service.MeshServiceHolder.unifiedMeshService
+ },
+ clock: () -> Long = System::currentTimeMillis,
+ jitter: (Long, Long) -> Long = kotlin.random.Random::nextLong
+ ) {
+ if (appContext != null) return
+ synchronized(this) {
+ if (appContext != null) return
+ val application = context.applicationContext
+ appContext = application
+ this.meshProvider = meshProvider
+ this.clock = clock
+ this.jitter = jitter
+ relayManager = NostrRelayManager.getInstance(application)
+ val prekeyManager = PrekeyManager.getInstance(application)
+ prefs = application.getSharedPreferences(PREFS, Context.MODE_PRIVATE)
+ val storedEnabled = loadEnabledWithMigration(prefs!!)
+ _isEnabled.value = storedEnabled && !panicQuiesced
+ if (panicQuiesced && storedEnabled) {
+ prefs?.edit { putBoolean(KEY_ENABLED, false) }
+ }
+ outboundPolicy.set(
+ BridgeOutboundPolicy.capture(
+ enabled = _isEnabled.value,
+ nearbyOnly = _nearbyOnly.value
+ )
+ )
+ PeerCapabilities.setBridgeEnabled(_isEnabled.value)
+ prekeyCoordinator = PrekeyCoordinator(
+ manager = prekeyManager,
+ meshProvider = ::currentMesh,
+ peersProvider = verifiedPeerSnapshot::get,
+ clock = clock
+ )
+
+ }
+
+ val location = LocationChannelManager.getInstance(context)
+ scope.launch {
+ location.availableChannels.collect { channels ->
+ if (!_isEnabled.value) {
+ localLocationCell = null
+ return@collect
+ }
+ localLocationCell = channels
+ .firstOrNull { it.level == GeohashChannelLevel.NEIGHBORHOOD }
+ ?.geohash
+ ?.take(CELL_PRECISION)
+ refreshRendezvous()
+ }
+ }
+ scope.launch {
+ relayManager?.isConnected?.collect { connected ->
+ if (connected) {
+ refreshRendezvous(forceSubscriptions = true)
+ flushQueuedUplinks()
+ publishPresence()
+ }
+ }
+ }
+ scope.launch {
+ if (_isEnabled.value) {
+ relayManager?.connect()
+ location.refreshChannels(
+ forceFresh = true,
+ updatePlaceNames = false
+ )
+ refreshRendezvous(forceSubscriptions = true)
+ }
+ if (_isEnabled.value) startPresenceLoop()
+ delay(2_000)
+ broadcastPrekeys(force = true)
+ }
+ }
+
+ private val publicationGeneration = java.util.concurrent.atomic.AtomicLong()
+ fun publicationPermit(): () -> Boolean {
+ val generation = publicationGeneration.get()
+ val enabledAtCapture = _isEnabled.value
+ return { enabledAtCapture && _isEnabled.value && generation == publicationGeneration.get() }
+ }
+
+ fun setEnabled(enabled: Boolean) {
+ if (outboundPolicy.get().enabled == enabled) return
+ if (enabled) {
+ panicQuiesced = false
+ suppressPrekeyBroadcasts = false
+ }
+ publicationGeneration.incrementAndGet()
+ outboundPolicy.set(BridgeOutboundPolicy.capture(enabled, nearbyOnly = false))
+ _isEnabled.value = enabled
+ prefs?.edit { putBoolean(KEY_ENABLED, enabled) }
+ PeerCapabilities.setBridgeEnabled(enabled)
+ _nearbyOnly.value = false
+ scope.launch {
+ if (!enabled) {
+ stopPresenceLoop()
+ closeSubscriptions()
+ queuedUplinks.clear()
+ pendingDownlinks.clear()
+ participants.clear()
+ publishParticipants()
+ localLocationCell = null
+ _activeCell.value = null
+ } else {
+ startPresenceLoop()
+ relayManager?.connect()
+ LocationChannelManager.getInstance(requireContext())
+ .refreshChannels(
+ forceFresh = true,
+ updatePlaceNames = false
+ )
+ refreshRendezvous(forceSubscriptions = true)
+ broadcastPrekeys(force = true)
+ }
+ currentMesh()?.sendBroadcastAnnounce()
+ }
+ }
+
+ fun setNearbyOnly(enabled: Boolean) {
+ outboundPolicy.updateAndGet { current ->
+ BridgeOutboundPolicy.capture(current.enabled, nearbyOnly = enabled)
+ }
+ _nearbyOnly.value = enabled
+ }
+
+ /** Cell included in announce TLV 0x06 while the bridge switch is on. */
+ override fun advertisedCell(): String? = _activeCell.value.takeIf { _isEnabled.value }
+
+ override fun outboundPolicy(): BridgeOutboundPolicy = outboundPolicy.get()
+
+ override fun bridgeOutgoing(
+ content: String,
+ senderPeerId: String,
+ timestampMs: Long,
+ nickname: String?,
+ policyAtSend: BridgeOutboundPolicy
+ ) {
+ scope.launch {
+ if (!policyAtSend.permitsPublication(outboundPolicy.get())) return@launch
+ val cell = _activeCell.value ?: currentCell() ?: return@launch
+ if (content.toByteArray(Charsets.UTF_8).size > MAX_CONTENT_BYTES) return@launch
+ val identity = NostrIdentityBridge.deriveBridgeIdentity(cell, requireContext())
+ val event = NostrProtocol.createBridgeMeshEvent(
+ content = content,
+ cell = cell,
+ senderIdentity = identity,
+ nickname = nickname,
+ meshSenderId = senderPeerId,
+ meshTimestampMs = timestampMs
+ )
+ if (!policyAtSend.permitsPublication(outboundPolicy.get())) return@launch
+ publishedEventIds.add(event.id)
+ injectedEventIds.add(event.id)
+ if (relayManager?.isConnected?.value == true) {
+ relayManager?.sendEventToGeohash(event, cell, publicationAllowed = publicationPermit())
+ } else {
+ val peer = availableBridgePeer() ?: return@launch
+ NostrCarrierPacket.fromEvent(
+ NostrCarrierPacket.Direction.TO_BRIDGE,
+ cell,
+ event
+ )?.encode()?.let { currentMesh()?.sendNostrCarrier(it, peer.peerId) }
+ }
+ }
+ }
+
+ /** Called only after a public radio packet's Ed25519 signature was accepted. */
+ override fun handleAuthenticatedRadioMessage(messageId: String) {
+ if (panicQuiesced || messageId.isBlank()) return
+ scope.launch {
+ radioMessageIds.add(messageId)
+ pendingDownlinks.removeAll { pending ->
+ classifyMessage(pending.event, pending.cell)?.bridgeRadioMessageIdHint == messageId
+ }
+ }
+ }
+
+ override fun handleVerifiedAnnouncement(peerId: String, announcement: IdentityAnnouncement) {
+ if (panicQuiesced) return
+ scope.launch {
+ val peer = VerifiedBridgePeer(
+ peerId = peerId,
+ nickname = announcement.nickname,
+ noiseKey = announcement.noisePublicKey.copyOf(),
+ signingKey = announcement.signingPublicKey.copyOf(),
+ isVerifiedNickname =
+ currentMesh()?.getPeerInfo(peerId)?.isVerifiedNickname == true,
+ capabilities = announcement.capabilities,
+ bridgeCell = announcement.bridgeGeohash?.takeIf(::isValidGeohash),
+ lastSeenMs = clock()
+ )
+ verifiedPeers[peerId] = peer
+ while (verifiedPeers.size > 200) verifiedPeers.remove(verifiedPeers.keys.first())
+ publishVerifiedPeerSnapshot()
+ prekeyCoordinator?.handlePeerVerified(peerId)
+ if (_isEnabled.value) {
+ refreshRendezvous()
+ }
+ broadcastPrekeys()
+ }
+ }
+
+ override fun handlePrekeyPacket(packet: BitchatPacket) {
+ if (panicQuiesced) return
+ scope.launch { prekeyCoordinator?.handlePacket(packet) }
+ }
+
+ override fun handleCarrier(payload: ByteArray, fromPeerId: String, directedToUs: Boolean) {
+ if (panicQuiesced) return
+ scope.launch {
+ val carrier = NostrCarrierPacket.decode(payload) ?: return@launch
+ when (carrier.direction) {
+ NostrCarrierPacket.Direction.TO_BRIDGE -> {
+ if (directedToUs) handleUplink(carrier, fromPeerId)
+ }
+ NostrCarrierPacket.Direction.FROM_BRIDGE -> {
+ if (!directedToUs) handleDownlink(carrier)
+ }
+ NostrCarrierPacket.Direction.TO_GATEWAY,
+ NostrCarrierPacket.Direction.FROM_GATEWAY -> MeshGatewayService.handleCarrier(carrier, fromPeerId, directedToUs)
+ }
+ }
+ }
+
+ @SuppressLint("ApplySharedPref", "UseKtx")
+ suspend fun wipe() {
+ // Revoke policy synchronously so no already-queued bridge work can be
+ // authorized by the pre-panic setting.
+ publicationGeneration.incrementAndGet()
+ outboundPolicy.set(BridgeOutboundPolicy.Denied)
+ panicQuiesced = true
+ suppressPrekeyBroadcasts = true
+ _isEnabled.value = false
+ _nearbyOnly.value = false
+ PeerCapabilities.setBridgeEnabled(false)
+ kotlinx.coroutines.withContext(dispatcher) {
+ prefs?.edit()?.putBoolean(KEY_ENABLED, false)?.commit()
+ stopPresenceLoop()
+ downlinkJob?.cancel()
+ downlinkJob = null
+ closeSubscriptions()
+ queuedUplinks.clear()
+ pendingDownlinks.clear()
+ localLocationCell = null
+ _activeCell.value = null
+ verifiedPeers.clear()
+ publishVerifiedPeerSnapshot()
+ participants.clear()
+ publishedEventIds.clear()
+ receivedEventIds.clear()
+ meshBroadcastEventIds.clear()
+ rebroadcastEventIds.clear()
+ injectedEventIds.clear()
+ radioMessageIds.clear()
+ uplinkTimes.clear()
+ inboundTimes.clear()
+ inboundTimesBySigner.clear()
+ downlinkTimes.clear()
+ signatureAttemptTimes.clear()
+ prekeyCoordinator?.wipe()
+ publishParticipants()
+ }
+ }
+
+ private fun publishVerifiedPeerSnapshot() {
+ verifiedPeerSnapshot.set(
+ verifiedPeers.values.map { peer ->
+ peer.copy(
+ noiseKey = peer.noiseKey.copyOf(),
+ signingKey = peer.signingKey.copyOf()
+ )
+ }
+ )
+ }
+
+ private suspend fun refreshRendezvous(forceSubscriptions: Boolean = false) {
+ if (!_isEnabled.value) return
+ val cell = currentCell()
+ val changed = cell != _activeCell.value
+ if (changed) {
+ _activeCell.value = cell
+ currentMesh()?.sendBroadcastAnnounce()
+ }
+ if (cell == null) return
+ val cells = linkedSetOf(cell).apply { addAll(Geohash.neighborsSamePrecision(cell)) }
+ if (changed || forceSubscriptions || cells != subscribedCells) {
+ val targets = linkedSetOf()
+ cells.forEach { subscribedCell ->
+ relayManager?.ensureGeohashRelaysConnected(subscribedCell)
+ targets += relayManager?.getRelaysForGeohash(subscribedCell).orEmpty()
+ }
+ relayManager?.let { manager ->
+ rendezvousSubscription.replace(
+ close = manager::unsubscribe,
+ open = { subscriptionId ->
+ manager.subscribe(
+ filter = NostrFilter.bridgeRendezvous(
+ cells,
+ since = clock() - MAX_EVENT_AGE_MS
+ ),
+ id = subscriptionId,
+ handler = { event -> scope.launch { handleRendezvousEvent(event) } },
+ targetRelayUrls = targets.toList()
+ )
+ }
+ )
+ subscribedCells = cells
+ }
+ publishPresence()
+ }
+ }
+
+ private fun currentCell(): String? {
+ localLocationCell?.takeIf(::isValidGeohash)?.let { return it.take(CELL_PRECISION) }
+ return availableBridgePeer()?.bridgeCell?.take(CELL_PRECISION)
+ }
+
+ private fun availableBridgePeer(): VerifiedBridgePeer? =
+ verifiedPeers.values.firstOrNull { peer ->
+ peer.capabilities?.contains(PeerCapabilities.BRIDGE) == true &&
+ peer.bridgeCell != null &&
+ currentMesh()?.getPeerInfo(peer.peerId)?.isConnected == true
+ }
+
+ private fun handleRendezvousEvent(event: NostrEvent) {
+ if (!_isEnabled.value) return
+ val cell = event.tagValue("r") ?: return
+ if (cell !in subscribedCells || publishedEventIds.contains(event.id)) return
+ if (isOwnEvent(event, cell)) {
+ publishedEventIds.add(event.id)
+ return
+ }
+ if (!allowSignatureAttempt() || !event.isValidSignature()) return
+ if (!receivedEventIds.add(event.id) || !allowInbound(event.pubkey)) return
+ if (!isFresh(event) || event.tagValue("r") != cell || !isValidGeohash(cell)) return
+
+ when (event.kind) {
+ NostrKind.GEOHASH_PRESENCE -> recordParticipant(event.pubkey, null)
+ NostrKind.EPHEMERAL_EVENT -> {
+ val message = classifyMessage(event, cell) ?: return
+ val localRadio = message.bridgeRadioMessageIdHint?.let(::radioCopyPresent) == true
+ if (!localRadio && injectBridgeMessage(message)) {
+ recordParticipant(event.pubkey, event.tagValue("n"))
+ }
+ if (!localRadio &&
+ !meshBroadcastEventIds.contains(event.id) &&
+ !rebroadcastEventIds.contains(event.id) &&
+ pendingDownlinks.none { it.event.id == event.id }
+ ) {
+ pendingDownlinks += PendingDownlink(cell, event)
+ while (pendingDownlinks.size > MAX_PENDING_DOWNLINKS) pendingDownlinks.removeAt(0)
+ scheduleDownlink(jitter = true)
+ }
+ }
+ }
+ }
+
+ private fun handleUplink(carrier: NostrCarrierPacket, depositor: String) {
+ if (!_isEnabled.value || !allowUplink(depositor)) return
+ val event = structurallyValidEvent(carrier) ?: return
+ if (meshBroadcastEventIds.contains(event.id) ||
+ publishedEventIds.contains(event.id) ||
+ queuedUplinks.any { it.event.id == event.id }
+ ) {
+ return
+ }
+ if (!allowSignatureAttempt() || !event.isValidSignature()) return
+ if (relayManager?.isConnected?.value == true) {
+ publishCarriedEvent(event, carrier.geohash)
+ } else {
+ if (queuedUplinks.count { it.depositor == depositor } >= MAX_UPLINKS_PER_DEPOSITOR) return
+ queuedUplinks += PendingUplink(depositor, carrier.geohash, event)
+ while (queuedUplinks.size > MAX_QUEUED_UPLINKS) queuedUplinks.removeAt(0)
+ }
+ }
+
+ private fun handleDownlink(carrier: NostrCarrierPacket) {
+ val event = structurallyValidEvent(carrier) ?: return
+ if (publishedEventIds.contains(event.id) || isOwnEvent(event, carrier.geohash)) return
+ if (!allowSignatureAttempt() || !event.isValidSignature()) return
+ val firstMesh = meshBroadcastEventIds.add(event.id)
+ if (!firstMesh || !receivedEventIds.add(event.id) || !allowInbound(event.pubkey)) return
+ val message = classifyMessage(event, carrier.geohash) ?: return
+ if (injectBridgeMessage(message)) recordParticipant(event.pubkey, event.tagValue("n"))
+ }
+
+ private fun structurallyValidEvent(carrier: NostrCarrierPacket): NostrEvent? {
+ if (!isValidGeohash(carrier.geohash) ||
+ carrier.eventJson.size > NostrCarrierPacket.MAX_EVENT_JSON_BYTES
+ ) {
+ return null
+ }
+ val event = carrier.event() ?: return null
+ if (!isFresh(event) || event.tagValue("r") != carrier.geohash) return null
+ return when (event.kind) {
+ NostrKind.GEOHASH_PRESENCE -> event
+ NostrKind.EPHEMERAL_EVENT ->
+ event.takeIf { classifyMessage(it, carrier.geohash) != null }
+ else -> null
+ }
+ }
+
+ private fun classifyMessage(event: NostrEvent, cell: String): BitchatMessage? {
+ if (event.kind != NostrKind.EPHEMERAL_EVENT ||
+ !isFresh(event) ||
+ event.tagValue("r") != cell ||
+ !isValidGeohash(cell)
+ ) {
+ return null
+ }
+ val content = event.content
+ if (content.isBlank() || content.toByteArray(Charsets.UTF_8).size > MAX_CONTENT_BYTES) return null
+ val nickname = event.tagValue("n")?.trim()?.takeIf { it.isNotEmpty() }
+ val m = event.tags.firstOrNull { it.size >= 4 && it[0] == "m" }
+ val radioHint = if (m != null &&
+ m[2].matches(Regex("^[0-9a-fA-F]{16}$"))
+ ) {
+ m[3].toLongOrNull()?.let { MeshMessageIdentity.stableId(m[2], it, content) }
+ } else {
+ null
+ }
+ return BitchatMessage(
+ id = event.id,
+ sender = "${nickname ?: "anon"}#${event.pubkey.takeLast(4)}",
+ content = content,
+ timestamp = Date(event.createdAt * 1000L),
+ senderPeerID = "bridge:${event.pubkey.take(16)}",
+ isBridged = true,
+ bridgeRadioMessageIdHint = radioHint
+ )
+ }
+
+ private fun injectBridgeMessage(message: BitchatMessage): Boolean {
+ if (!injectedEventIds.add(message.id)) return false
+ if (message.bridgeRadioMessageIdHint?.let(::radioCopyPresent) == true) return false
+ AppStateStore.addPublicMessage(message)
+ return true
+ }
+
+ private fun radioCopyPresent(messageId: String): Boolean =
+ radioMessageIds.contains(messageId) || AppStateStore.hasRadioPublicMessage(messageId)
+
+ private fun scheduleDownlink(jitter: Boolean) {
+ if (downlinkJob?.isActive == true || pendingDownlinks.isEmpty()) return
+ val now = clock()
+ downlinkTimes.removeAll { now - it >= 60_000 }
+ val waitMs = if (jitter) {
+ jitter(200, 1_501)
+ } else {
+ (downlinkTimes.minOrNull()?.plus(60_000)?.minus(now) ?: 50).coerceAtLeast(50)
+ }
+ downlinkJob = scope.launch {
+ delay(waitMs)
+ drainDownlinks()
+ }
+ }
+
+ private fun drainDownlinks() {
+ val now = clock()
+ downlinkTimes.removeAll { now - it >= 60_000 }
+ while (pendingDownlinks.isNotEmpty() && downlinkTimes.size < DOWNLINKS_PER_MINUTE) {
+ val item = pendingDownlinks.removeAt(0)
+ if (!isFresh(item.event) ||
+ meshBroadcastEventIds.contains(item.event.id) ||
+ rebroadcastEventIds.contains(item.event.id)
+ ) {
+ continue
+ }
+ val message = classifyMessage(item.event, item.cell)
+ if (message?.bridgeRadioMessageIdHint?.let(::radioCopyPresent) == true) continue
+ val payload = NostrCarrierPacket.fromEvent(
+ NostrCarrierPacket.Direction.FROM_BRIDGE,
+ item.cell,
+ item.event
+ )?.encode() ?: continue
+ currentMesh()?.sendNostrCarrier(payload)
+ rebroadcastEventIds.add(item.event.id)
+ downlinkTimes += clock()
+ }
+ if (pendingDownlinks.isNotEmpty()) scheduleDownlink(jitter = false)
+ }
+
+ private fun flushQueuedUplinks() {
+ if (!_isEnabled.value || relayManager?.isConnected?.value != true) return
+ val queued = queuedUplinks.toList()
+ queuedUplinks.clear()
+ queued.filterNot { publishedEventIds.contains(it.event.id) }
+ .forEach { publishCarriedEvent(it.event, it.cell) }
+ }
+
+ private fun publishCarriedEvent(event: NostrEvent, cell: String) {
+ publishedEventIds.add(event.id)
+ relayManager?.sendEventToGeohash(event, cell, publicationAllowed = publicationPermit())
+ }
+
+ private fun publishPresence() {
+ if (!_isEnabled.value || relayManager?.isConnected?.value != true) return
+ val cell = _activeCell.value ?: return
+ val identity = NostrIdentityBridge.deriveBridgeIdentity(cell, requireContext())
+ val event = NostrProtocol.createBridgePresenceEvent(cell, identity)
+ publishedEventIds.add(event.id)
+ relayManager?.sendEventToGeohash(event, cell, publicationAllowed = publicationPermit())
+ }
+
+ private fun startPresenceLoop() {
+ if (presenceJob?.isActive == true) return
+ presenceJob = scope.launch {
+ while (true) {
+ delay(PRESENCE_INTERVAL_MS)
+ pruneParticipants()
+ if (_isEnabled.value) {
+ LocationChannelManager.getInstance(requireContext())
+ .refreshChannels(
+ forceFresh = true,
+ updatePlaceNames = false
+ )
+ refreshRendezvous()
+ publishPresence()
+ broadcastPrekeys()
+ }
+ }
+ }
+ }
+
+ private fun stopPresenceLoop() {
+ presenceJob?.cancel()
+ presenceJob = null
+ }
+
+ fun resumeAfterPanic() {
+ panicQuiesced = false
+ suppressPrekeyBroadcasts = false
+ refreshPrekeys()
+ }
+
+ fun refreshPrekeys() {
+ scope.launch { broadcastPrekeys(force = true) }
+ }
+
+ private fun broadcastPrekeys(force: Boolean = false) {
+ if (suppressPrekeyBroadcasts) return
+ prekeyCoordinator?.broadcast(force)
+ }
+
+ private fun recordParticipant(pubkey: String, nickname: String?) {
+ val now = clock()
+ participants.entries.removeAll { now - it.value.lastSeenMs > PARTICIPANT_FRESH_MS }
+ if (pubkey !in participants && participants.size >= MAX_PARTICIPANTS) {
+ participants.minByOrNull { it.value.lastSeenMs }?.key?.let(participants::remove)
+ }
+ val previous = participants[pubkey]
+ participants[pubkey] = BridgedParticipant(
+ pubkey,
+ nickname?.trim()?.takeIf { it.isNotEmpty() } ?: previous?.nickname,
+ now
+ )
+ publishParticipants()
+ }
+
+ private fun pruneParticipants() {
+ val now = clock()
+ participants.entries.removeAll { now - it.value.lastSeenMs > PARTICIPANT_FRESH_MS }
+ publishParticipants()
+ }
+
+ private fun publishParticipants() {
+ _bridgedParticipants.value = participants.values.sortedByDescending { it.lastSeenMs }
+ }
+
+ private fun allowUplink(depositor: String): Boolean {
+ val now = clock()
+ val times = uplinkTimes.getOrPut(depositor) { mutableListOf() }
+ times.removeAll { now - it >= 60_000 }
+ if (times.size >= UPLINKS_PER_MINUTE_PER_DEPOSITOR) return false
+ times += now
+ return true
+ }
+
+ private fun allowInbound(signer: String): Boolean {
+ val now = clock()
+ inboundTimes.removeAll { now - it >= 60_000 }
+ if (inboundTimes.size >= INBOUND_PER_MINUTE) return false
+ val signerTimes = inboundTimesBySigner.getOrPut(signer) { mutableListOf() }
+ signerTimes.removeAll { now - it >= 60_000 }
+ if (signerTimes.size >= INBOUND_PER_SIGNER_PER_MINUTE) return false
+ inboundTimes += now
+ signerTimes += now
+ return true
+ }
+
+ private fun allowSignatureAttempt(): Boolean {
+ val now = clock()
+ signatureAttemptTimes.removeAll { now - it >= 60_000 }
+ if (signatureAttemptTimes.size >= SIGNATURE_ATTEMPTS_PER_MINUTE) return false
+ signatureAttemptTimes += now
+ return true
+ }
+
+ private fun closeSubscriptions() {
+ relayManager?.let { manager ->
+ rendezvousSubscription.close(manager::unsubscribe)
+ }
+ subscribedCells = emptySet()
+ }
+
+ private fun isOwnEvent(event: NostrEvent, cell: String): Boolean =
+ runCatching {
+ NostrIdentityBridge.deriveBridgeIdentity(cell, requireContext())
+ .publicKeyHex.equals(event.pubkey, ignoreCase = true)
+ }.getOrDefault(false)
+
+ private fun isFresh(event: NostrEvent): Boolean =
+ abs(clock() - event.createdAt * 1000L) <= MAX_EVENT_AGE_MS
+
+ private fun isValidGeohash(value: String): Boolean =
+ value.length in 1..12 &&
+ value.matches(Regex("^[0123456789bcdefghjkmnpqrstuvwxyz]+$", RegexOption.IGNORE_CASE))
+
+ private fun NostrEvent.tagValue(name: String): String? =
+ tags.firstOrNull { it.size >= 2 && it[0] == name }?.get(1)
+
+ private fun currentMesh(): MeshService? = meshProvider()
+
+ private fun requireContext(): Context =
+ checkNotNull(appContext) { "MeshBridgeService.initialize must be called first" }
+
+ private fun loadEnabledWithMigration(
+ preferences: android.content.SharedPreferences
+ ): Boolean {
+ if (preferences.contains(KEY_ENABLED)) return preferences.getBoolean(KEY_ENABLED, false)
+ val legacyKeys = listOf("gateway_user_enabled", "gateway_enabled", "gateway.userEnabled")
+ val migrated = legacyKeys.any { preferences.getBoolean(it, false) }
+ preferences.edit {
+ putBoolean(KEY_ENABLED, migrated)
+ legacyKeys.forEach(::remove)
+ }
+ return migrated
+ }
+
+ private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/MeshGatewayService.kt b/app/src/main/java/com/bitchat/android/services/bridge/MeshGatewayService.kt
new file mode 100644
index 00000000..073b42b4
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/MeshGatewayService.kt
@@ -0,0 +1,167 @@
+package com.bitchat.android.services.bridge
+
+import android.content.Context
+import com.bitchat.android.geohash.ChannelID
+import com.bitchat.android.geohash.LiveLocationPrivacyGate
+import com.bitchat.android.geohash.LocationChannelManager
+import com.bitchat.android.model.NostrCarrierPacket
+import com.bitchat.android.model.PeerCapabilities
+import com.bitchat.android.nostr.*
+import com.bitchat.android.service.MeshServiceHolder
+import java.util.concurrent.atomic.AtomicLong
+import kotlinx.coroutines.*
+import kotlinx.coroutines.flow.*
+
+internal object GatewayEventPolicy {
+ fun inspect(carrier: NostrCarrierPacket, nowSeconds: Long): NostrEvent? {
+ if (!Regex("[0123456789bcdefghjkmnpqrstuvwxyz]{1,12}").matches(carrier.geohash)) return null
+ val event = carrier.event() ?: return null
+ if (event.kind != NostrKind.EPHEMERAL_EVENT ||
+ event.tags.none { it.size >= 2 && it[0] == "g" && it[1] == carrier.geohash } ||
+ nowSeconds - event.createdAt.toLong() !in -900L..900L) return null
+ return event
+ }
+}
+
+/** Opt-in internet sharing for signed public geohash events (carrier directions 1 and 2). */
+object MeshGatewayService {
+ private val dispatcher = Dispatchers.IO.limitedParallelism(1)
+ private val scope = CoroutineScope(SupervisorJob() + dispatcher)
+ private val generation = AtomicLong()
+ private val _enabled = MutableStateFlow(false)
+ val enabled: StateFlow = _enabled.asStateFlow()
+ private var context: Context? = null
+ private val radioEvents = BoundedIdSet(512)
+ private val published = BoundedIdSet(512)
+ private val delivered = BoundedIdSet(512)
+ private val inboundTimes = ArrayDeque()
+ private val perPeer = linkedMapOf>()
+ private val downlinkTimes = ArrayDeque()
+ private val pending = linkedMapOf>()
+ private var drain: Job? = null
+ private val mesh get() = MeshServiceHolder.unifiedMeshService
+ private val relays get() = context?.let(NostrRelayManager::getInstance)
+
+ @Synchronized
+ fun initialize(application: Context) {
+ if (context != null) return
+ context = application.applicationContext
+ _enabled.value = application.getSharedPreferences("mesh_gateway", Context.MODE_PRIVATE).getBoolean("enabled", false)
+ PeerCapabilities.setGatewayEnabled(_enabled.value)
+ }
+
+ fun setEnabled(enabled: Boolean) {
+ generation.incrementAndGet()
+ _enabled.value = enabled
+ context?.getSharedPreferences("mesh_gateway", Context.MODE_PRIVATE)?.edit()?.putBoolean("enabled", enabled)?.apply()
+ PeerCapabilities.setGatewayEnabled(enabled)
+ if (!enabled) scope.launch { pending.clear(); drain?.cancel(); drain = null }
+ mesh?.sendBroadcastAnnounce()
+ }
+
+ suspend fun wipe() {
+ setEnabled(false)
+ withContext(dispatcher) {
+ pending.clear()
+ drain?.cancel()
+ drain = null
+ radioEvents.clear()
+ published.clear()
+ delivered.clear()
+ inboundTimes.clear()
+ perPeer.clear()
+ downlinkTimes.clear()
+ check(context?.getSharedPreferences("mesh_gateway", Context.MODE_PRIVATE)?.edit()?.clear()?.commit() != false)
+ }
+ }
+
+ private fun permit(): () -> Boolean {
+ val captured = generation.get()
+ val enabledAtSend = _enabled.value
+ return { enabledAtSend && _enabled.value && generation.get() == captured }
+ }
+
+ fun uplinkIfOffline(event: NostrEvent, cell: String, liveToken: Long?) {
+ val current = mesh ?: return
+ if (liveToken != null && !LiveLocationPrivacyGate.accepts(liveToken)) return
+ if (relays?.hasConnectedRelay(relays?.getRelaysForGeohash(cell).orEmpty()) == true) return
+ val gateway = current.getPeerNicknames().keys.firstOrNull { peer ->
+ current.getPeerInfo(peer)?.let { it.isConnected && it.hasVerifiedAnnouncement &&
+ it.capabilities?.contains(PeerCapabilities.GATEWAY) == true } == true
+ } ?: return
+ val carrier = NostrCarrierPacket.fromEvent(NostrCarrierPacket.Direction.TO_GATEWAY, cell, event) ?: return
+ scope.launch {
+ if (liveToken != null && !LiveLocationPrivacyGate.accepts(liveToken)) return@launch
+ radioEvents.add(event.id)
+ current.sendNostrCarrier(carrier.encode(), gateway)
+ }
+ }
+
+ fun handleCarrier(carrier: NostrCarrierPacket, peerID: String, directedToUs: Boolean) {
+ val application = context ?: return
+ val allowed = permit()
+ scope.launch {
+ val event = GatewayEventPolicy.inspect(carrier, System.currentTimeMillis() / 1000) ?: return@launch
+ if (carrier.direction == NostrCarrierPacket.Direction.TO_GATEWAY) {
+ if (!directedToUs || !allowed() || published.contains(event.id)) return@launch
+ if (mesh?.getPeerInfo(peerID)?.hasVerifiedAnnouncement != true || !allowInbound(peerID)) return@launch
+ if (!event.isValidSignature() || !allowed()) return@launch
+ radioEvents.add(event.id)
+ published.add(event.id)
+ relays?.sendEventToGeohash(event, carrier.geohash, publicationAllowed = allowed)
+ NostrBackgroundRuntime.receiveGatewayEvent(event, carrier.geohash)
+ } else if (carrier.direction == NostrCarrierPacket.Direction.FROM_GATEWAY) {
+ if (directedToUs || delivered.contains(event.id) || !allowInbound(peerID)) return@launch
+ val channelManager = LocationChannelManager.getInstance(application)
+ val selected = (channelManager.selectedChannel.value as? ChannelID.Location)?.channel ?: return@launch
+ if (selected.geohash != carrier.geohash || !channelManager.canUseSelectedLocationChannel(selected)) return@launch
+ if (!event.isValidSignature()) return@launch
+ radioEvents.add(event.id)
+ delivered.add(event.id)
+ NostrBackgroundRuntime.receiveGatewayEvent(event, carrier.geohash)
+ }
+ }
+ }
+
+ fun rebroadcastRelayEvent(event: NostrEvent, cell: String, liveToken: Long?) {
+ val allowed = permit()
+ if (!allowed()) return
+ val carrier = NostrCarrierPacket.fromEvent(NostrCarrierPacket.Direction.FROM_GATEWAY, cell, event) ?: return
+ scope.launch {
+ if (!allowed() || (liveToken != null && !LiveLocationPrivacyGate.accepts(liveToken)) ||
+ GatewayEventPolicy.inspect(carrier, System.currentTimeMillis() / 1000) == null ||
+ radioEvents.contains(event.id) || delivered.contains(event.id) || pending.containsKey(event.id)) return@launch
+ if (!event.isValidSignature() || pending.size >= 100) return@launch
+ pending[event.id] = carrier to liveToken
+ if (drain?.isActive != true) drain = scope.launch {
+ while (pending.isNotEmpty() && allowed()) {
+ delay(kotlin.random.Random.nextLong(200, 1501))
+ val now = System.currentTimeMillis()
+ while (downlinkTimes.firstOrNull()?.let { now - it >= 60_000 } == true) downlinkTimes.removeFirst()
+ if (downlinkTimes.size >= 30) { delay(1000); continue }
+ val next = pending.entries.first()
+ pending.remove(next.key)
+ val (outgoing, token) = next.value
+ if (!allowed() || (token != null && !LiveLocationPrivacyGate.accepts(token)) || radioEvents.contains(next.key) ||
+ GatewayEventPolicy.inspect(outgoing, now / 1000) == null) continue
+ mesh?.sendNostrCarrier(outgoing.encode())
+ delivered.add(next.key)
+ downlinkTimes.addLast(now)
+ }
+ }
+ }
+ }
+
+ private fun allowInbound(peerID: String): Boolean {
+ val now = System.currentTimeMillis()
+ while (inboundTimes.firstOrNull()?.let { now - it >= 60_000 } == true) inboundTimes.removeFirst()
+ perPeer.entries.removeAll { it.value.lastOrNull()?.let { now - it >= 60_000 } != false }
+ if (perPeer.size >= 200 && peerID !in perPeer) return false
+ val times = perPeer.getOrPut(peerID) { ArrayDeque() }
+ while (times.firstOrNull()?.let { now - it >= 60_000 } == true) times.removeFirst()
+ if (inboundTimes.size >= 20 || times.size >= 5) return false
+ inboundTimes.addLast(now)
+ times.addLast(now)
+ return true
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/PrekeyCoordinator.kt b/app/src/main/java/com/bitchat/android/services/bridge/PrekeyCoordinator.kt
new file mode 100644
index 00000000..38eaf147
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/PrekeyCoordinator.kt
@@ -0,0 +1,71 @@
+package com.bitchat.android.services.bridge
+
+import com.bitchat.android.mesh.MeshService
+import com.bitchat.android.model.PrekeyBundle
+import com.bitchat.android.protocol.BitchatPacket
+import com.bitchat.android.services.ContactIdentityResolver
+
+/**
+ * Coordinates authenticated prekey packets without owning cryptographic
+ * persistence. [PrekeyManager] remains the repository/crypto boundary.
+ */
+internal class PrekeyCoordinator(
+ private val manager: PrekeyManager,
+ private val meshProvider: () -> MeshService?,
+ private val peersProvider: () -> List,
+ private val clock: () -> Long = System::currentTimeMillis
+) {
+ private val pendingPackets = linkedMapOf()
+ private var lastBroadcastMs = 0L
+
+ fun handlePacket(packet: BitchatPacket) {
+ val bundle = PrekeyBundle.decode(packet.payload) ?: return
+ val owner = ContactIdentityResolver.peerIdForNoiseKey(bundle.noiseStaticPublicKey)
+ if (owner != packet.senderID.toHex()) return
+ val peer = peersProvider().firstOrNull { it.peerId == owner }
+ if (peer == null || !peer.noiseKey.contentEquals(bundle.noiseStaticPublicKey)) {
+ if (pendingPackets.size < MAX_PENDING_PACKETS || owner in pendingPackets) {
+ pendingPackets[owner] = packet
+ }
+ return
+ }
+ ingestVerified(packet, bundle, peer)
+ }
+
+ fun handlePeerVerified(peerId: String) {
+ pendingPackets.remove(peerId)?.let(::handlePacket)
+ }
+
+ fun broadcast(force: Boolean = false) {
+ val now = clock()
+ if (!force && now - lastBroadcastMs < REBROADCAST_INTERVAL_MS) return
+ val bundle = manager.currentSignedBundle(now) ?: return
+ val encoded = bundle.encode() ?: return
+ lastBroadcastMs = now
+ meshProvider()?.sendPrekeyBundle(encoded)
+ }
+
+ fun wipe() {
+ pendingPackets.clear()
+ lastBroadcastMs = 0L
+ manager.wipe()
+ }
+
+ private fun ingestVerified(
+ packet: BitchatPacket,
+ bundle: PrekeyBundle,
+ peer: VerifiedBridgePeer
+ ) {
+ if (!BridgePacketSignatureVerifier.verify(packet, peer.signingKey)) return
+ if (manager.verifyAndIngest(bundle, peer.noiseKey, peer.signingKey, clock())) {
+ com.bitchat.android.service.MeshServiceHolder.sharedGossipSyncManager?.onPublicPacketSeen(packet)
+ }
+ }
+
+ private fun ByteArray.toHex(): String = joinToString("") { "%02x".format(it) }
+
+ private companion object {
+ const val MAX_PENDING_PACKETS = 64
+ const val REBROADCAST_INTERVAL_MS = 60L * 60 * 1000
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/PrekeyManager.kt b/app/src/main/java/com/bitchat/android/services/bridge/PrekeyManager.kt
new file mode 100644
index 00000000..39c5ef97
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/PrekeyManager.kt
@@ -0,0 +1,331 @@
+package com.bitchat.android.services.bridge
+
+import android.content.Context
+import android.util.Base64
+import com.bitchat.android.identity.SecureIdentityStateManager
+import com.bitchat.android.model.PrekeyBundle
+import com.bitchat.android.noise.CourierNoiseCrypto
+import org.bouncycastle.crypto.params.Ed25519PrivateKeyParameters
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters
+import org.bouncycastle.crypto.signers.Ed25519Signer
+import java.security.SecureRandom
+
+/**
+ * Owns local one-time prekeys and verified peer bundles for courier v2.
+ *
+ * Local private keys use EncryptedSharedPreferences through
+ * [SecureIdentityStateManager]. Peer bundles contain public material only,
+ * but their consumption assignments are persisted so retries of one message
+ * never spend additional prekeys.
+ */
+class PrekeyManager internal constructor(
+ private val identity: PrekeyIdentity,
+ private val localStore: LocalPrekeyStore,
+ private val peerStore: PeerPrekeyStore,
+ private val randomBytes: () -> ByteArray
+) {
+ data class Sealed(
+ val ciphertext: ByteArray,
+ val prekeyId: Long?
+ )
+
+ data class Opened(
+ val payload: ByteArray,
+ val senderStaticKey: ByteArray,
+ val consumedPrekey: Boolean
+ )
+
+ private val lock = Any()
+ private var local: LocalPrekeyState? = null
+ private var peerBundles: MutableMap? = null
+
+ fun currentSignedBundle(nowMs: Long = System.currentTimeMillis()): PrekeyBundle? = synchronized(lock) {
+ val staticKey = identity.staticKey()?.second ?: return@synchronized null
+ val signingPrivateKey = identity.signingKey()?.first ?: return@synchronized null
+ val state = loadLocalLocked()
+ replenishLocked(state, nowMs)
+ val prekeys = state.records
+ .asSequence()
+ .filter { it.consumedAt == null }
+ .sortedBy { it.id }
+ .mapNotNull { record ->
+ decode(record.privateKey)?.let { privateKey ->
+ PrekeyBundle.Prekey(record.id, CourierNoiseCrypto.publicKey(privateKey))
+ }
+ }
+ .toList()
+ if (prekeys.isEmpty()) return@synchronized null
+
+ val unsigned = PrekeyBundle(
+ noiseStaticPublicKey = staticKey,
+ prekeys = prekeys,
+ generatedAt = state.generatedAt,
+ signature = ByteArray(PrekeyBundle.SIGNATURE_LENGTH)
+ )
+ val signature = signEd25519(unsigned.signableBytes(), signingPrivateKey) ?: return@synchronized null
+ unsigned.copy(signature = signature)
+ }
+
+ fun verifyAndIngest(
+ bundle: PrekeyBundle,
+ expectedNoiseKey: ByteArray,
+ announceBoundSigningKey: ByteArray,
+ nowMs: Long = System.currentTimeMillis()
+ ): Boolean {
+ if (!bundle.noiseStaticPublicKey.contentEquals(expectedNoiseKey) ||
+ announceBoundSigningKey.size != PrekeyBundle.KEY_LENGTH ||
+ !verifyEd25519(bundle.signature, bundle.signableBytes(), announceBoundSigningKey)
+ ) {
+ return false
+ }
+
+ synchronized(lock) {
+ val bundles = loadPeerBundlesLocked()
+ val key = encode(bundle.noiseStaticPublicKey)
+ val existing = bundles[key]
+ if (existing != null && existing.generatedAt >= bundle.generatedAt) return false
+
+ val freshIds = bundle.prekeys.map { it.id }.toSet()
+ bundles[key] = StoredPeerPrekeyBundle(
+ noiseKey = key,
+ generatedAt = bundle.generatedAt,
+ prekeyIds = bundle.prekeys.map { it.id },
+ prekeyPublicKeys = bundle.prekeys.map { encode(it.publicKey) },
+ usedIds = existing?.usedIds?.filterTo(mutableSetOf()) { it in freshIds } ?: mutableSetOf(),
+ assignments = existing?.assignments
+ ?.filterValues { it in freshIds }
+ ?.toMutableMap() ?: mutableMapOf(),
+ updatedAt = nowMs
+ )
+ while (bundles.size > MAX_PEERS) {
+ bundles.minByOrNull { it.value.updatedAt }?.key?.let(bundles::remove)
+ }
+ persistPeerBundlesLocked(bundles)
+ return true
+ }
+ }
+
+ fun seal(
+ payload: ByteArray,
+ messageId: String,
+ recipientNoiseKey: ByteArray,
+ recipientAdvertisesPrekeys: Boolean,
+ nowMs: Long = System.currentTimeMillis()
+ ): Sealed {
+ val senderPrivateKey = identity.staticKey()?.first
+ ?: throw IllegalStateException("Noise static identity is unavailable")
+ val assigned = if (recipientAdvertisesPrekeys) {
+ assignPrekey(messageId, recipientNoiseKey, nowMs)
+ } else {
+ null
+ }
+ return if (assigned != null) {
+ Sealed(
+ CourierNoiseCrypto.sealToPrekey(payload, senderPrivateKey, assigned),
+ assigned.id
+ )
+ } else {
+ Sealed(
+ CourierNoiseCrypto.seal(payload, senderPrivateKey, recipientNoiseKey),
+ null
+ )
+ }
+ }
+
+ fun open(
+ ciphertext: ByteArray,
+ prekeyId: Long?,
+ nowMs: Long = System.currentTimeMillis()
+ ): Opened {
+ if (prekeyId == null) {
+ val staticPrivateKey = identity.staticKey()?.first
+ ?: throw IllegalStateException("Noise static identity is unavailable")
+ val opened = CourierNoiseCrypto.open(ciphertext, staticPrivateKey)
+ return Opened(opened.payload, opened.senderStaticKey, false)
+ }
+
+ synchronized(lock) {
+ val state = loadLocalLocked()
+ pruneLocked(state, nowMs)
+ val record = state.records.firstOrNull { it.id == prekeyId }
+ ?: throw IllegalArgumentException("Unknown or expired courier prekey")
+ val consumedAt = record.consumedAt
+ if (consumedAt != null && nowMs - consumedAt > CONSUMED_GRACE_MS) {
+ throw IllegalArgumentException("Courier prekey grace window expired")
+ }
+ val privateKey = decode(record.privateKey)
+ ?: throw IllegalArgumentException("Invalid courier prekey")
+ val opened = CourierNoiseCrypto.openWithPrekey(ciphertext, privateKey, prekeyId)
+ val newlyConsumed = record.consumedAt == null
+ if (newlyConsumed) {
+ record.consumedAt = nowMs
+ advanceGeneratedAtLocked(state, nowMs)
+ replenishLocked(state, nowMs)
+ persistLocalLocked(state)
+ }
+ return Opened(opened.payload, opened.senderStaticKey, newlyConsumed)
+ }
+ }
+
+ fun hasUsableBundle(
+ recipientNoiseKey: ByteArray,
+ nowMs: Long = System.currentTimeMillis()
+ ): Boolean = synchronized(lock) {
+ val bundle = loadPeerBundlesLocked()[encode(recipientNoiseKey)] ?: return@synchronized false
+ isFresh(bundle, nowMs) && bundle.prekeyIds.any { it !in bundle.usedIds }
+ }
+
+ fun wipe() = synchronized(lock) {
+ local = LocalPrekeyState()
+ peerBundles = mutableMapOf()
+ localStore.clear()
+ peerStore.clear()
+ }
+
+ private fun assignPrekey(
+ messageId: String,
+ recipientNoiseKey: ByteArray,
+ nowMs: Long
+ ): PrekeyBundle.Prekey? = synchronized(lock) {
+ val bundles = loadPeerBundlesLocked()
+ val key = encode(recipientNoiseKey)
+ val bundle = bundles[key] ?: return@synchronized null
+ if (!isFresh(bundle, nowMs)) return@synchronized null
+
+ bundle.assignments[messageId]?.let { assigned ->
+ val index = bundle.prekeyIds.indexOf(assigned)
+ if (index >= 0) {
+ return@synchronized decode(bundle.prekeyPublicKeys[index])
+ ?.let { PrekeyBundle.Prekey(assigned, it) }
+ }
+ }
+
+ val index = bundle.prekeyIds.indices
+ .filter { bundle.prekeyIds[it] !in bundle.usedIds }
+ .minByOrNull { bundle.prekeyIds[it] }
+ ?: return@synchronized null
+ val id = bundle.prekeyIds[index]
+ val publicKey = decode(bundle.prekeyPublicKeys[index]) ?: return@synchronized null
+ bundle.usedIds += id
+ bundle.assignments[messageId] = id
+ bundle.updatedAt = nowMs
+ persistPeerBundlesLocked(bundles)
+ PrekeyBundle.Prekey(id, publicKey)
+ }
+
+ private fun replenishLocked(state: LocalPrekeyState, nowMs: Long): Boolean {
+ val beforeRecords = state.records.size
+ val beforeUnconsumed = state.records.count { it.consumedAt == null }
+ pruneLocked(state, nowMs)
+ val unconsumed = state.records.count { it.consumedAt == null }
+ var changed = unconsumed != beforeUnconsumed
+ if (unconsumed < REPLENISH_THRESHOLD) {
+ repeat(PrekeyBundle.MAX_PREKEYS - unconsumed) {
+ val privateKey = randomBytes()
+ require(privateKey.size == PrekeyBundle.KEY_LENGTH)
+ state.records += LocalPrekeyRecord(
+ id = state.nextId and 0xFFFF_FFFFL,
+ privateKey = encode(privateKey),
+ createdAt = nowMs
+ )
+ state.nextId = (state.nextId + 1) and 0xFFFF_FFFFL
+ }
+ advanceGeneratedAtLocked(state, nowMs)
+ changed = true
+ }
+ if (changed || state.records.size != beforeRecords) persistLocalLocked(state)
+ return changed
+ }
+
+ private fun pruneLocked(state: LocalPrekeyState, nowMs: Long) {
+ state.records.removeAll { record ->
+ record.consumedAt?.let { nowMs - it > CONSUMED_GRACE_MS }
+ ?: (nowMs - record.createdAt > UNCONSUMED_RETENTION_MS)
+ }
+ }
+
+ private fun advanceGeneratedAtLocked(state: LocalPrekeyState, nowMs: Long) {
+ state.generatedAt = maxOf(nowMs.coerceAtLeast(0), state.generatedAt + 1)
+ }
+
+ private fun loadLocalLocked(): LocalPrekeyState {
+ local?.let { return it }
+ val loaded = localStore.load()
+ local = loaded
+ return loaded
+ }
+
+ private fun persistLocalLocked(state: LocalPrekeyState) {
+ try { localStore.save(state) } catch (error: Exception) {
+ local = null
+ throw error
+ }
+ }
+
+ private fun loadPeerBundlesLocked(): MutableMap {
+ peerBundles?.let { return it }
+ return peerStore.load().also { peerBundles = it }
+ }
+
+ private fun persistPeerBundlesLocked(bundles: Map) {
+ try { peerStore.save(bundles) } catch (error: Exception) {
+ peerBundles = null
+ throw error
+ }
+ }
+
+ private fun isFresh(bundle: StoredPeerPrekeyBundle, nowMs: Long): Boolean =
+ nowMs - bundle.generatedAt <= MAX_BUNDLE_AGE_MS
+
+ private fun signEd25519(data: ByteArray, privateKey: ByteArray): ByteArray? = runCatching {
+ Ed25519Signer().apply {
+ init(true, Ed25519PrivateKeyParameters(privateKey, 0))
+ update(data, 0, data.size)
+ }.generateSignature()
+ }.getOrNull()
+
+ private fun verifyEd25519(signature: ByteArray, data: ByteArray, publicKey: ByteArray): Boolean =
+ runCatching {
+ Ed25519Signer().apply {
+ init(false, Ed25519PublicKeyParameters(publicKey, 0))
+ update(data, 0, data.size)
+ }.verifySignature(signature)
+ }.getOrDefault(false)
+
+ private fun encode(data: ByteArray): String =
+ Base64.encodeToString(data, Base64.NO_WRAP)
+
+ private fun decode(value: String): ByteArray? =
+ runCatching { Base64.decode(value, Base64.NO_WRAP) }.getOrNull()
+
+ companion object {
+ private const val PEER_PREFS = "bitchat_prekey_bundles"
+ private const val REPLENISH_THRESHOLD = 3
+ private const val CONSUMED_GRACE_MS = 48L * 60 * 60 * 1000
+ private const val UNCONSUMED_RETENTION_MS = 30L * 24 * 60 * 60 * 1000
+ private const val MAX_BUNDLE_AGE_MS = 7L * 24 * 60 * 60 * 1000
+ private const val MAX_PEERS = 200
+
+ @Volatile
+ private var instance: PrekeyManager? = null
+
+ fun getInstance(context: Context): PrekeyManager =
+ instance ?: synchronized(this) {
+ instance ?: run {
+ val application = context.applicationContext
+ val identityState = SecureIdentityStateManager(application)
+ val random = SecureRandom()
+ PrekeyManager(
+ identity = AndroidPrekeyIdentity(identityState),
+ localStore = SecureLocalPrekeyStore(identityState),
+ peerStore = SharedPreferencesPeerPrekeyStore(
+ application.getSharedPreferences(PEER_PREFS, Context.MODE_PRIVATE)
+ ),
+ randomBytes = {
+ ByteArray(PrekeyBundle.KEY_LENGTH).also(random::nextBytes)
+ }
+ ).also { instance = it }
+ }
+ }
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/bridge/PrekeyStores.kt b/app/src/main/java/com/bitchat/android/services/bridge/PrekeyStores.kt
new file mode 100644
index 00000000..d62e0e29
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/services/bridge/PrekeyStores.kt
@@ -0,0 +1,109 @@
+package com.bitchat.android.services.bridge
+
+import android.content.SharedPreferences
+import android.util.Log
+import androidx.core.content.edit
+import com.bitchat.android.identity.SecureIdentityStateManager
+import com.google.gson.Gson
+import com.google.gson.reflect.TypeToken
+
+internal data class LocalPrekeyRecord(
+ val id: Long,
+ val privateKey: String,
+ val createdAt: Long,
+ var consumedAt: Long? = null
+)
+
+internal data class LocalPrekeyState(
+ var records: MutableList = mutableListOf(),
+ var nextId: Long = 0,
+ var generatedAt: Long = 0
+)
+
+internal data class StoredPeerPrekeyBundle(
+ val noiseKey: String,
+ var generatedAt: Long,
+ var prekeyIds: List,
+ var prekeyPublicKeys: List,
+ var usedIds: MutableSet,
+ var assignments: MutableMap,
+ var updatedAt: Long
+)
+
+internal interface PrekeyIdentity {
+ fun staticKey(): Pair?
+ fun signingKey(): Pair?
+}
+
+internal interface LocalPrekeyStore {
+ fun load(): LocalPrekeyState
+ fun save(state: LocalPrekeyState)
+ fun clear()
+}
+
+internal interface PeerPrekeyStore {
+ fun load(): MutableMap
+ fun save(bundles: Map)
+ fun clear()
+}
+
+internal class AndroidPrekeyIdentity(
+ private val state: SecureIdentityStateManager
+) : PrekeyIdentity {
+ override fun staticKey(): Pair? = state.loadStaticKey()
+ override fun signingKey(): Pair? = state.loadSigningKey()
+}
+
+internal class SecureLocalPrekeyStore(
+ private val state: SecureIdentityStateManager,
+ private val gson: Gson = Gson()
+) : LocalPrekeyStore {
+ override fun load(): LocalPrekeyState =
+ runCatching {
+ state.getSecureValue(LOCAL_STORE_KEY)
+ ?.let { gson.fromJson(it, LocalPrekeyState::class.java) }
+ }.getOrNull() ?: LocalPrekeyState()
+
+ override fun save(state: LocalPrekeyState) {
+ check(this.state.storeSecureValueSynchronously(LOCAL_STORE_KEY, gson.toJson(state))) {
+ "Unable to persist courier prekeys"
+ }
+ }
+
+ override fun clear() {
+ check(state.clearSecureValuesSynchronously(LOCAL_STORE_KEY))
+ }
+
+ private companion object {
+ const val TAG = "LocalPrekeyStore"
+ const val LOCAL_STORE_KEY = "courier_prekeys_v1"
+ }
+}
+
+internal class SharedPreferencesPeerPrekeyStore(
+ private val preferences: SharedPreferences,
+ private val gson: Gson = Gson()
+) : PeerPrekeyStore {
+ override fun load(): MutableMap {
+ val type = object : TypeToken>() {}.type
+ val values: List = runCatching {
+ preferences.getString(PEER_BUNDLES_KEY, null)
+ ?.let { json -> gson.fromJson>(json, type) }
+ }.getOrNull() ?: emptyList()
+ return values
+ .filter { it.prekeyIds.size == it.prekeyPublicKeys.size }
+ .associateByTo(mutableMapOf()) { it.noiseKey }
+ }
+
+ override fun save(bundles: Map) {
+ check(preferences.edit().putString(PEER_BUNDLES_KEY, gson.toJson(bundles.values.toList())).commit())
+ }
+
+ override fun clear() {
+ check(preferences.edit().clear().commit())
+ }
+
+ private companion object {
+ const val PEER_BUNDLES_KEY = "bundles_v1"
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt b/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt
index 785c249d..013660fd 100644
--- a/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt
+++ b/app/src/main/java/com/bitchat/android/services/meshgraph/MeshGraphService.kt
@@ -76,6 +76,31 @@ class MeshGraphService private constructor() {
}
}
+ /**
+ * Returns a shortest path using only bidirectionally confirmed topology claims.
+ */
+ fun computeRoute(fromPeerID: String, toPeerID: String): List? {
+ if (fromPeerID == toPeerID) return listOf(fromPeerID)
+ val adjacency = mutableMapOf>()
+ graphState.value.edges.filter(GraphEdge::isConfirmed).forEach { edge ->
+ adjacency.getOrPut(edge.a) { mutableSetOf() }.add(edge.b)
+ adjacency.getOrPut(edge.b) { mutableSetOf() }.add(edge.a)
+ }
+ val queue = ArrayDeque>()
+ val visited = mutableSetOf(fromPeerID)
+ queue.add(listOf(fromPeerID))
+ while (queue.isNotEmpty()) {
+ val path = queue.removeFirst()
+ adjacency[path.last()].orEmpty().sorted().forEach { neighbor ->
+ if (!visited.add(neighbor)) return@forEach
+ val next = path + neighbor
+ if (neighbor == toPeerID) return next
+ queue.add(next)
+ }
+ }
+ return null
+ }
+
private fun publishSnapshot() {
// Collect all known nodes from nicknames and announcements
val allNodes = mutableSetOf()
diff --git a/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt b/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt
index 212def6a..9d5b9fa2 100644
--- a/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt
+++ b/app/src/main/java/com/bitchat/android/sync/GCSFilter.kt
@@ -21,9 +21,12 @@ object GCSFilter {
data class Params(
val p: Int, // Golomb-Rice parameter (>= 1)
val m: Long, // Range M = N * 2^P
- val data: ByteArray // Encoded GR bitstream
+ val data: ByteArray, // Encoded GR bitstream
+ val includedCount: Int // Number of newest-first input IDs actually encoded
)
+ const val MAX_P = 32
+
// Derive P from target FPR; FPR ~= 1 / 2^P
fun deriveP(targetFpr: Double): Int {
val f = targetFpr.coerceIn(0.000001, 0.25)
@@ -66,7 +69,12 @@ object GCSFilter {
encoded = encode(mapped, p)
}
- return Params(p = p, m = finalM, data = encoded)
+ return Params(
+ p = p,
+ m = finalM,
+ data = encoded,
+ includedCount = if (encoded.isEmpty()) 0 else trimmedN
+ )
}
fun decodeToSortedSet(p: Int, m: Long, data: ByteArray): LongArray {
@@ -196,4 +204,3 @@ object GCSFilter {
}
}
}
-
diff --git a/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt b/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt
index 42a10ceb..95f968e7 100644
--- a/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt
+++ b/app/src/main/java/com/bitchat/android/sync/GossipSyncManager.kt
@@ -8,6 +8,9 @@ import com.bitchat.android.protocol.MessageType
import com.bitchat.android.protocol.SpecialRecipients
import kotlinx.coroutines.*
import java.util.concurrent.ConcurrentHashMap
+import android.content.Context
+import java.io.File
+import java.nio.file.StandardCopyOption
/**
* Gossip-based synchronization manager using on-demand GCS filters.
@@ -17,7 +20,8 @@ import java.util.concurrent.ConcurrentHashMap
class GossipSyncManager(
private val myPeerID: String,
private val scope: CoroutineScope,
- private val configProvider: ConfigProvider
+ private val configProvider: ConfigProvider,
+ context: Context? = null
) {
interface Delegate {
fun sendPacket(packet: BitchatPacket)
@@ -33,8 +37,21 @@ class GossipSyncManager(
companion object {
private const val TAG = "GossipSyncManager"
+ const val PUBLIC_MESSAGE_MAX_AGE_MS = 6 * 60 * 60 * 1000L
+ const val FRAGMENT_MAX_AGE_MS = 15 * 60 * 1000L
+ const val PUBLIC_PACKET_FUTURE_SKEW_MS = 10 * 60 * 1000L
+ private const val ARCHIVE_FILE = "gossip-public-history.bin"
}
+ var boardPacketsProvider: (() -> List)? = null
+ private val responseTimesByPeer = ConcurrentHashMap>()
+ private val observedBoardSyncPeers = ConcurrentHashMap.newKeySet()
+ private fun peerSupportsBoard(peerID: String): Boolean =
+ peerID.lowercase() in observedBoardSyncPeers ||
+ latestAnnouncementByPeer[peerID.lowercase()]?.second?.payload?.let {
+ com.bitchat.android.model.IdentityAnnouncement.decode(it)?.capabilities
+ ?.contains(com.bitchat.android.model.PeerCapabilities.BOARD)
+ } == true
var delegate: Delegate? = null
// Defaults (configurable constants)
@@ -44,11 +61,16 @@ class GossipSyncManager(
// Stored packets for sync:
// - broadcast messages: keep up to seenCapacity() most recent, keyed by packetId
private val messages = LinkedHashMap()
+ private val groupMessages = LinkedHashMap()
+ private val fragments = LinkedHashMap()
+ private val archiveFile = context?.applicationContext?.filesDir?.let { File(it, ARCHIVE_FILE) }
+ private var restoringArchive = false
// - announcements: only keep latest per sender peerID
private val latestAnnouncementByPeer = ConcurrentHashMap>()
private var periodicJob: Job? = null
private var cleanupJob: Job? = null
+ init { restoreArchive() }
fun start() {
periodicJob?.cancel()
periodicJob = scope.launch(Dispatchers.IO) {
@@ -84,7 +106,12 @@ class GossipSyncManager(
synchronized(messages) {
messages.clear()
}
+ synchronized(fragments) { fragments.clear() }
+ synchronized(groupMessages) { groupMessages.clear() }
latestAnnouncementByPeer.clear()
+ responseTimesByPeer.clear()
+ observedBoardSyncPeers.clear()
+ archiveFile?.delete()
Log.d(TAG, "Cleared all gossip sync messages and announcements")
}
@@ -106,13 +133,33 @@ class GossipSyncManager(
// Only ANNOUNCE or broadcast MESSAGE
val mt = MessageType.fromValue(packet.type)
val isBroadcastMessage = (mt == MessageType.MESSAGE && (packet.recipientID == null || packet.recipientID.contentEquals(SpecialRecipients.BROADCAST)))
+ val isGroupMessage = mt in setOf(MessageType.GROUP_MESSAGE, MessageType.PREKEY_BUNDLE) &&
+ (packet.recipientID == null || packet.recipientID.contentEquals(SpecialRecipients.BROADCAST))
+ val isBroadcastFile = mt == MessageType.FILE_TRANSFER &&
+ (packet.recipientID == null || packet.recipientID.contentEquals(SpecialRecipients.BROADCAST))
val isAnnouncement = (mt == MessageType.ANNOUNCE)
- if (!isBroadcastMessage && !isAnnouncement) return
+ val isFragment = (mt == MessageType.FRAGMENT || isBroadcastFile) &&
+ (packet.recipientID == null || packet.recipientID.contentEquals(SpecialRecipients.BROADCAST))
+ if (!isBroadcastMessage && !isAnnouncement && !isFragment && !isGroupMessage) return
val idBytes = PacketIdUtil.computeIdBytes(packet)
val id = idBytes.joinToString("") { b -> "%02x".format(b) }
- if (isBroadcastMessage) {
+ if (isGroupMessage) {
+ val age = System.currentTimeMillis() - packet.timestamp.toLong()
+ if (age !in -PUBLIC_PACKET_FUTURE_SKEW_MS..PUBLIC_MESSAGE_MAX_AGE_MS) return
+ synchronized(groupMessages) {
+ val cacheKey = if (mt == MessageType.PREKEY_BUNDLE) "prekey-${packet.senderID.toHexString()}" else id
+ groupMessages[cacheKey] = packet
+ while (groupMessages.size > 200) {
+ val iterator = groupMessages.entries.iterator()
+ iterator.next(); iterator.remove()
+ }
+ }
+ } else if (isBroadcastMessage) {
+ val now = System.currentTimeMillis()
+ val age = now - packet.timestamp.toLong()
+ if (age !in -PUBLIC_PACKET_FUTURE_SKEW_MS..PUBLIC_MESSAGE_MAX_AGE_MS) return
synchronized(messages) {
messages[id] = packet
// Enforce capacity (remove oldest when exceeded)
@@ -122,6 +169,17 @@ class GossipSyncManager(
if (it.hasNext()) { it.next(); it.remove() } else break
}
}
+ if (!restoringArchive) persistArchive()
+ } else if (isFragment) {
+ val age = System.currentTimeMillis() - packet.timestamp.toLong()
+ if (age !in -PUBLIC_PACKET_FUTURE_SKEW_MS..FRAGMENT_MAX_AGE_MS) return
+ synchronized(fragments) {
+ fragments[id] = packet
+ while (fragments.size > configProvider.seenCapacity().coerceAtLeast(1)) {
+ val iterator = fragments.entries.iterator()
+ if (iterator.hasNext()) { iterator.next(); iterator.remove() } else break
+ }
+ }
} else if (isAnnouncement) {
// Ignore stale announcements older than STALE_PEER_TIMEOUT
val now = System.currentTimeMillis()
@@ -143,22 +201,35 @@ class GossipSyncManager(
}
private fun sendRequestSync() {
- val payload = buildGcsPayload()
-
- val packet = BitchatPacket(
- type = MessageType.REQUEST_SYNC.value,
- senderID = hexStringToByteArray(myPeerID),
- timestamp = System.currentTimeMillis().toULong(),
- payload = payload,
- ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS // neighbors only
- )
- // Sign and broadcast
- val signed = delegate?.signPacketForBroadcast(packet) ?: packet
- delegate?.sendPacket(signed)
+ listOf(
+ SyncTypeFlags.PUBLIC_MESSAGES,
+ SyncTypeFlags.FRAGMENT,
+ SyncTypeFlags.FILE_TRANSFER,
+ SyncTypeFlags.GROUP_MESSAGE.union(SyncTypeFlags.fromMessageTypes(MessageType.PREKEY_BUNDLE))
+ ).forEach { types ->
+ val payload = buildGcsPayload(types)
+ val packet = BitchatPacket(
+ type = MessageType.REQUEST_SYNC.value,
+ senderID = hexStringToByteArray(myPeerID),
+ timestamp = System.currentTimeMillis().toULong(),
+ payload = payload,
+ ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS // neighbors only
+ )
+ val signed = delegate?.signPacketForBroadcast(packet) ?: packet
+ delegate?.sendPacket(signed)
+ }
+ if (boardPacketsProvider != null) {
+ latestAnnouncementByPeer.keys.filter(::peerSupportsBoard).forEach {
+ sendRequestSyncToPeer(it, SyncTypeFlags.BOARD)
+ }
+ }
}
- private fun sendRequestSyncToPeer(peerID: String) {
- val payload = buildGcsPayload()
+ private fun sendRequestSyncToPeer(peerID: String, requestedTypes: SyncTypeFlags? = null) {
+ val types = requestedTypes ?: SyncTypeFlags.PUBLIC_MESSAGES.union(SyncTypeFlags.FRAGMENTS_AND_FILES)
+ .union(SyncTypeFlags.GROUP_MESSAGE).union(SyncTypeFlags.fromMessageTypes(MessageType.PREKEY_BUNDLE))
+ .let { if (boardPacketsProvider != null && peerSupportsBoard(peerID)) it.union(SyncTypeFlags.BOARD) else it }
+ val payload = buildGcsPayload(types)
val packet = BitchatPacket(
type = MessageType.REQUEST_SYNC.value,
@@ -175,6 +246,12 @@ class GossipSyncManager(
}
fun handleRequestSync(fromPeerID: String, request: RequestSyncPacket) {
+ val requestedTypes = request.types ?: SyncTypeFlags.PUBLIC_MESSAGES
+ if (requestedTypes.contains(MessageType.BOARD_POST) && latestAnnouncementByPeer.containsKey(fromPeerID.lowercase())) {
+ observedBoardSyncPeers.add(fromPeerID.lowercase())
+ }
+ if (!shouldRespondTo(fromPeerID)) return
+ val sinceTimestamp = request.sinceTimestamp
// Decode GCS into sorted set for membership checks
val sorted = GCSFilter.decodeToSortedSet(request.p, request.m, request.data)
fun mightContain(id: ByteArray): Boolean {
@@ -183,26 +260,85 @@ class GossipSyncManager(
return GCSFilter.contains(sorted, nonZeroV)
}
- // 1) Announcements: send latest per peerID if remote doesn't have them
- for ((_, pair) in latestAnnouncementByPeer.entries) {
- val (id, pkt) = pair
- val idBytes = hexToBytes(id)
- if (!mightContain(idBytes)) {
- // Send original packet unchanged to requester only (keep local TTL)
- val toSend = pkt.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS)
- delegate?.sendPacketToPeer(fromPeerID, toSend)
- Log.d(TAG, "Sent sync announce: Type ${toSend.type} from ${toSend.senderID.toHexString()} to $fromPeerID packet id ${idBytes.toHexString()}")
+ // Announcements are exempt from the cursor: only the latest per peer is retained,
+ // and peers need their signing keys before they can verify other sync responses.
+ if (requestedTypes.contains(MessageType.ANNOUNCE)) {
+ for ((_, pair) in latestAnnouncementByPeer.entries) {
+ val (id, pkt) = pair
+ val idBytes = hexToBytes(id)
+ if (!mightContain(idBytes)) {
+ val toSend = pkt.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS)
+ delegate?.sendPacketToPeer(fromPeerID, toSend)
+ Log.d(TAG, "Sent sync announce: Type ${toSend.type} from ${toSend.senderID.toHexString()} to $fromPeerID packet id ${idBytes.toHexString()}")
+ }
}
}
- // 2) Broadcast messages: send all they lack
- val toSendMsgs = synchronized(messages) { messages.values.toList() }
- for (pkt in toSendMsgs) {
+ if (requestedTypes.contains(MessageType.MESSAGE)) {
+ val toSendMsgs = synchronized(messages) { messages.values.toList() }
+ for (pkt in toSendMsgs) {
+ if (sinceTimestamp != null && pkt.timestamp < sinceTimestamp) continue
+ val idBytes = PacketIdUtil.computeIdBytes(pkt)
+ if (!mightContain(idBytes)) {
+ val toSend = pkt.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS)
+ delegate?.sendPacketToPeer(fromPeerID, toSend)
+ Log.d(TAG, "Sent sync message: Type ${toSend.type} to $fromPeerID packet id ${idBytes.toHexString()}")
+ }
+ }
+ }
+
+ if (requestedTypes.contains(MessageType.GROUP_MESSAGE) || requestedTypes.contains(MessageType.PREKEY_BUNDLE)) {
+ typedSyncCandidates(requestedTypes).forEach { packet ->
+ if ((sinceTimestamp == null || packet.timestamp >= sinceTimestamp) &&
+ !mightContain(PacketIdUtil.computeIdBytes(packet))) {
+ delegate?.sendPacketToPeer(fromPeerID, packet.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS))
+ }
+ }
+ }
+ if (requestedTypes.contains(MessageType.BOARD_POST)) {
+ boardPacketsProvider?.invoke().orEmpty().take(200).forEach { packet ->
+ if ((sinceTimestamp == null || packet.timestamp >= sinceTimestamp) &&
+ !mightContain(PacketIdUtil.computeIdBytes(packet))) {
+ delegate?.sendPacketToPeer(fromPeerID, packet.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS))
+ }
+ }
+ }
+ val toSendFragments = synchronized(fragments) { fragments.values.toList() }
+ for (pkt in toSendFragments) {
+ val type = MessageType.fromValue(pkt.type) ?: continue
+ if (!requestedTypes.contains(type)) continue
+ if (sinceTimestamp != null && pkt.timestamp < sinceTimestamp) continue
val idBytes = PacketIdUtil.computeIdBytes(pkt)
if (!mightContain(idBytes)) {
- val toSend = pkt.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS)
- delegate?.sendPacketToPeer(fromPeerID, toSend)
- Log.d(TAG, "Sent sync message: Type ${toSend.type} to $fromPeerID packet id ${idBytes.toHexString()}")
+ delegate?.sendPacketToPeer(fromPeerID, pkt.copy(ttl = com.bitchat.android.util.AppConstants.SYNC_TTL_HOPS))
+ }
+ }
+ }
+
+ private fun typedSyncCandidates(types: SyncTypeFlags): List = synchronized(groupMessages) {
+ val now = System.currentTimeMillis()
+ groupMessages.entries.removeAll { now - it.value.timestamp.toLong() > PUBLIC_MESSAGE_MAX_AGE_MS }
+ groupMessages.values.filter { packet ->
+ MessageType.fromValue(packet.type)?.let(types::contains) == true
+ }
+ }
+
+ private fun shouldRespondTo(peerID: String): Boolean {
+ val now = System.currentTimeMillis()
+ responseTimesByPeer.entries.removeIf { (_, times) ->
+ synchronized(times) { times.isEmpty() || now - times.last() >= 30_000L }
+ }
+ if (responseTimesByPeer.size >= 256 && !responseTimesByPeer.containsKey(peerID)) return false
+ val times = responseTimesByPeer.computeIfAbsent(peerID) { ArrayDeque() }
+ return synchronized(times) {
+ while (times.isNotEmpty() && now - times.first() >= 30_000L) {
+ times.removeFirst()
+ }
+ if (times.size >= 8) {
+ false
+ } else {
+ times.addLast(now)
+ true
}
}
}
@@ -232,16 +368,25 @@ class GossipSyncManager(
return out
}
- private fun buildGcsPayload(): ByteArray {
- // Collect candidates: latest announcement per peer + recent broadcast messages
+ internal fun buildGcsPayload(types: SyncTypeFlags): ByteArray {
+ // Collect only the packet types represented by this filter.
val list = ArrayList()
- // announcements
- for ((_, pair) in latestAnnouncementByPeer) {
- list.add(pair.second)
+ if (types.contains(MessageType.BOARD_POST)) list.addAll(boardPacketsProvider?.invoke().orEmpty().take(200))
+ list.addAll(typedSyncCandidates(types))
+ if (types.contains(MessageType.ANNOUNCE)) {
+ for ((_, pair) in latestAnnouncementByPeer) {
+ list.add(pair.second)
+ }
}
- // messages
- synchronized(messages) {
- list.addAll(messages.values)
+ if (types.contains(MessageType.MESSAGE)) {
+ synchronized(messages) {
+ list.addAll(messages.values)
+ }
+ }
+ synchronized(fragments) {
+ list.addAll(fragments.values.filter { packet ->
+ MessageType.fromValue(packet.type)?.let(types::contains) == true
+ })
}
// sort by timestamp desc, then take up to min(seenCapacity, fit capacity)
list.sortByDescending { it.timestamp.toLong() }
@@ -254,15 +399,24 @@ class GossipSyncManager(
val takeN = minOf(nMax, cap, list.size)
if (takeN <= 0) {
val p0 = GCSFilter.deriveP(fpr)
- return RequestSyncPacket(p = p0, m = 1, data = ByteArray(0)).encode()
+ return RequestSyncPacket(p = p0, m = 1, data = ByteArray(0), types = types).encode()
}
- val ids = list.take(takeN).map { pkt -> PacketIdUtil.computeIdBytes(pkt) }
+ val included = list.take(takeN)
+ val ids = included.map { pkt -> PacketIdUtil.computeIdBytes(pkt) }
val params = GCSFilter.buildFilter(ids, maxBytes, fpr)
val mVal = if (params.m <= 0L) 1 else params.m
- return RequestSyncPacket(p = params.p, m = mVal, data = params.data).encode()
+ val covered = params.includedCount
+ val sinceTimestamp = if (covered in 1 until list.size) included[covered - 1].timestamp else null
+ return RequestSyncPacket(
+ p = params.p,
+ m = mVal,
+ data = params.data,
+ types = types,
+ sinceTimestamp = sinceTimestamp
+ ).encode()
}
- // Periodically remove stale announcements and all their messages
+ // Announcements age out quickly; public history remains independently sync-able for six hours.
private fun pruneStaleAnnouncements() {
val now = System.currentTimeMillis()
val stalePeers = mutableListOf()
@@ -276,26 +430,17 @@ class GossipSyncManager(
}
}
- if (stalePeers.isEmpty()) return
-
- // Remove announcements and their messages
- var totalPrunedMsgs = 0
+ var changed = false
for (peerID in stalePeers) {
- // Count messages to be pruned for logging
- val toRemove = mutableListOf()
- synchronized(messages) {
- for ((id, message) in messages) {
- val sender = message.senderID.joinToString("") { b -> "%02x".format(b) }
- if (sender == peerID) toRemove.add(id)
- }
- }
- totalPrunedMsgs += toRemove.size
-
- // Reuse existing removal which also clears announcement entry
- removeAnnouncementForPeer(peerID)
+ changed = latestAnnouncementByPeer.remove(peerID) != null || changed
}
-
- Log.d(TAG, "Pruned ${stalePeers.size} stale announcements and $totalPrunedMsgs messages")
+ synchronized(messages) {
+ changed = messages.entries.removeAll { now - it.value.timestamp.toLong() > PUBLIC_MESSAGE_MAX_AGE_MS } || changed
+ }
+ synchronized(fragments) {
+ fragments.entries.removeAll { now - it.value.timestamp.toLong() > FRAGMENT_MAX_AGE_MS }
+ }
+ if (changed) persistArchive()
}
// Explicitly remove stored announcement for a given peer (hex ID)
@@ -305,26 +450,66 @@ class GossipSyncManager(
Log.d(TAG, "Removed stored announcement for peer $peerID")
}
- // Collect IDs to remove first to avoid modifying collection while iterating
- val idsToRemove = mutableListOf()
- synchronized(messages) {
- for ((id, message) in messages) {
- val sender = message.senderID.joinToString("") { b -> "%02x".format(b) }
- if (sender == key) {
- idsToRemove.add(id)
+ }
+
+ private fun restoreArchive() {
+ val file = archiveFile ?: return
+ if (!file.exists()) return
+ try {
+ restoringArchive = true
+ java.io.DataInputStream(file.inputStream().buffered()).use { input ->
+ val count = input.readInt()
+ require(count in 0..configProvider.seenCapacity())
+ repeat(count) {
+ val length = input.readInt()
+ require(length in 1..(com.bitchat.android.util.AppConstants.Protocol.MAX_PAYLOAD_LENGTH + 256))
+ val bytes = ByteArray(length)
+ input.readFully(bytes)
+ val packet = com.bitchat.android.protocol.BinaryProtocol.decode(bytes) ?: return@repeat
+ onPublicPacketSeen(packet)
}
}
- }
-
- // Now remove the collected IDs
- synchronized(messages) {
- for (id in idsToRemove) {
- messages.remove(id)
- }
- }
-
- if (idsToRemove.isNotEmpty()) {
- Log.d(TAG, "Pruned ${idsToRemove.size} messages with senders without announcements")
+ } catch (_: Exception) {
+ synchronized(messages) { messages.clear() }
+ } finally {
+ restoringArchive = false
}
}
+
+ @Synchronized
+ private fun persistArchive() {
+ val file = archiveFile ?: return
+ try {
+ val packets = synchronized(messages) { messages.values.toList() }
+ val temporary = File(file.parentFile, "${file.name}.tmp")
+ java.io.DataOutputStream(temporary.outputStream().buffered()).use { output ->
+ output.writeInt(packets.size)
+ packets.forEach { packet ->
+ val encoded = com.bitchat.android.protocol.BinaryProtocol.encode(packet, padding = false) ?: return@forEach
+ output.writeInt(encoded.size)
+ output.write(encoded)
+ }
+ }
+ try {
+ java.nio.file.Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.ATOMIC_MOVE,
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ } catch (_: Exception) {
+ // Some Android filesystems do not support ATOMIC_MOVE. Preserve the durable
+ // public-history guarantee with a regular replacement move before giving up.
+ try {
+ java.nio.file.Files.move(
+ temporary.toPath(),
+ file.toPath(),
+ StandardCopyOption.REPLACE_EXISTING
+ )
+ } catch (_: Exception) {
+ temporary.delete()
+ }
+ }
+ } catch (_: Exception) { }
+ }
}
diff --git a/app/src/main/java/com/bitchat/android/sync/SyncTypeFlags.kt b/app/src/main/java/com/bitchat/android/sync/SyncTypeFlags.kt
new file mode 100644
index 00000000..f7cf1504
--- /dev/null
+++ b/app/src/main/java/com/bitchat/android/sync/SyncTypeFlags.kt
@@ -0,0 +1,80 @@
+package com.bitchat.android.sync
+
+import com.bitchat.android.protocol.MessageType
+
+/** Compact little-endian bitfield matching iOS SyncTypeFlags. */
+@JvmInline
+value class SyncTypeFlags private constructor(val rawValue: ULong) {
+ companion object {
+ private const val KNOWN_TYPE_MASK: ULong = 0x7ffu
+
+ val BOARD = fromMessageTypes(MessageType.BOARD_POST)
+ val GROUP_MESSAGE = fromMessageTypes(MessageType.GROUP_MESSAGE)
+ fun of(vararg types: MessageType) = fromMessageTypes(*types)
+
+ val ANNOUNCE = fromMessageTypes(MessageType.ANNOUNCE)
+ val MESSAGE = fromMessageTypes(MessageType.MESSAGE)
+ val FRAGMENT = fromMessageTypes(MessageType.FRAGMENT)
+ val FILE_TRANSFER = fromMessageTypes(MessageType.FILE_TRANSFER)
+ val PUBLIC_MESSAGES = fromMessageTypes(MessageType.ANNOUNCE, MessageType.MESSAGE)
+ val FRAGMENTS_AND_FILES = fromMessageTypes(MessageType.FRAGMENT, MessageType.FILE_TRANSFER)
+
+ fun fromRawValue(rawValue: ULong): SyncTypeFlags = SyncTypeFlags(rawValue and KNOWN_TYPE_MASK)
+
+ fun fromMessageTypes(vararg types: MessageType): SyncTypeFlags {
+ var rawValue = 0uL
+ types.forEach { type ->
+ bitIndex(type)?.let { bit -> rawValue = rawValue or (1uL shl bit) }
+ }
+ return fromRawValue(rawValue)
+ }
+
+ fun decode(data: ByteArray): SyncTypeFlags? {
+ if (data.size !in 1..8) return null
+ var rawValue = 0uL
+ data.forEachIndexed { index, byte ->
+ rawValue = rawValue or (byte.toUByte().toULong() shl (index * 8))
+ }
+ return fromRawValue(rawValue)
+ }
+
+ private fun bitIndex(type: MessageType): Int? = when (type) {
+ MessageType.ANNOUNCE -> 0
+ MessageType.MESSAGE -> 1
+ MessageType.LEAVE -> 2
+ MessageType.NOISE_HANDSHAKE -> 3
+ MessageType.NOISE_ENCRYPTED -> 4
+ MessageType.FRAGMENT -> 5
+ MessageType.REQUEST_SYNC -> 6
+ MessageType.FILE_TRANSFER -> 7
+ MessageType.BOARD_POST -> 8
+ MessageType.PREKEY_BUNDLE -> 9
+ MessageType.GROUP_MESSAGE -> 10
+ MessageType.PING,
+ MessageType.PONG,
+ MessageType.NOSTR_CARRIER,
+ MessageType.COURIER_ENVELOPE,
+ MessageType.VOICE_FRAME -> null
+ }
+ }
+
+ fun contains(type: MessageType): Boolean {
+ val bit = bitIndex(type) ?: return false
+ return (rawValue and (1uL shl bit)) != 0uL
+ }
+
+ fun union(other: SyncTypeFlags): SyncTypeFlags = fromRawValue(rawValue or other.rawValue)
+
+ fun encoded(): ByteArray? = encode()
+
+ fun encode(): ByteArray? {
+ if (rawValue == 0uL) return null
+ var remaining = rawValue
+ val bytes = ArrayList(8)
+ while (remaining != 0uL && bytes.size < 8) {
+ bytes += (remaining and 0xffu).toByte()
+ remaining = remaining shr 8
+ }
+ return bytes.toByteArray()
+ }
+}
diff --git a/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt b/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt
index 54ab0318..573831fb 100644
--- a/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt
+++ b/app/src/main/java/com/bitchat/android/ui/AboutSheet.kt
@@ -303,11 +303,14 @@ private fun SettingsToggleRow(
fun AboutSheet(
isPresented: Boolean,
onDismiss: () -> Unit,
+ bridgeEnabled: Boolean,
+ onBridgeEnabledChange: (Boolean) -> Unit,
+ modifier: Modifier = Modifier,
onShowDebug: (() -> Unit)? = null,
- modifier: Modifier = Modifier
+ onShowMeshTopology: (() -> Unit)? = null
) {
val context = LocalContext.current
-
+
// Get version name from package info
val versionName = remember {
try {
@@ -445,6 +448,8 @@ fun AboutSheet(
}
}
+ item(key = "client_privacy") { ClientSettingsSection() }
+
item(key = "language") {
val selectedLanguageName = supportedLanguages
.firstOrNull { it.languageTag == selectedLanguageTag }
@@ -544,6 +549,19 @@ fun AboutSheet(
}
)
+ HorizontalDivider(
+ modifier = Modifier.padding(start = 56.dp),
+ color = colorScheme.outline.copy(alpha = 0.12f)
+ )
+
+ SettingsToggleRow(
+ icon = Icons.Filled.Public,
+ title = stringResource(R.string.mesh_bridge_title),
+ subtitle = stringResource(R.string.mesh_bridge_description),
+ checked = bridgeEnabled,
+ onCheckedChange = onBridgeEnabledChange
+ )
+
HorizontalDivider(
modifier = Modifier.padding(start = 54.dp),
thickness = 1.dp,
@@ -1256,6 +1274,16 @@ fun AboutSheet(
)
}
}
+ if (onShowMeshTopology != null) {
+ TextButton(onClick = onShowMeshTopology) {
+ Text(
+ text = "network → mesh topology",
+ fontSize = 13.sp,
+ fontFamily = BitchatFontFamily,
+ color = colorScheme.primary,
+ )
+ }
+ }
Text(
text = stringResource(R.string.about_footer),
fontSize = 11.sp,
@@ -1303,7 +1331,7 @@ fun PasswordPromptDialog(
) {
if (show && channelName != null) {
val colorScheme = MaterialTheme.colorScheme
-
+
AlertDialog(
onDismissRequest = onDismiss,
title = {
@@ -1321,7 +1349,7 @@ fun PasswordPromptDialog(
color = colorScheme.onSurface
)
Spacer(modifier = Modifier.height(8.dp))
-
+
OutlinedTextField(
value = passwordInput,
onValueChange = onPasswordChange,
diff --git a/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt b/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt
index aac5283c..a1e322ce 100644
--- a/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt
+++ b/app/src/main/java/com/bitchat/android/ui/ChatHeader.kt
@@ -355,9 +355,9 @@ fun NoiseSessionIcon(
)
}
- // Closed once the handshake resolves (success or failure); open while idle or in flight.
+ // A closed lock only represents an established encrypted session.
val lockIconRes = when {
- sessionState == "established" || sessionState?.startsWith("failed") == true ->
+ sessionState == "established" ->
R.drawable.ic_spec_lock
else -> R.drawable.ic_spec_lock_open
}
@@ -564,6 +564,7 @@ fun NicknameEditor(
@Composable
fun PeerCounter(
connectedPeers: List,
+ bridgedPeopleCount: Int = 0,
joinedChannels: Set,
hasUnreadChannels: Map,
isConnected: Boolean,
@@ -586,8 +587,8 @@ fun PeerCounter(
is com.bitchat.android.geohash.ChannelID.Mesh,
null -> {
// Mesh channel: show Bluetooth-connected peers (excluding self)
- val count = connectedPeers.size
- Pair(count, if (isConnected && count > 0) colorScheme.secondary else palette.textTertiary)
+ val count = connectedPeers.size + bridgedPeopleCount
+ Pair(count, if ((isConnected || bridgedPeopleCount > 0) && count > 0) colorScheme.secondary else palette.textTertiary)
}
}
@@ -727,6 +728,7 @@ private fun MainHeader(
val isConnected by viewModel.isConnected.collectAsStateWithLifecycle()
val selectedLocationChannel by viewModel.selectedLocationChannel.collectAsStateWithLifecycle()
val geohashPeople by viewModel.geohashPeople.collectAsStateWithLifecycle()
+ val bridgeUiState by viewModel.bridgeUiState.collectAsStateWithLifecycle()
BoxWithConstraints(modifier = Modifier.fillMaxWidth()) {
val crowdingMode = headerCrowdingMode(maxWidth)
@@ -809,6 +811,7 @@ private fun MainHeader(
PeerCounter(
connectedPeers = connectedPeers.filter { it != viewModel.myPeerID },
+ bridgedPeopleCount = bridgeUiState.participants.size,
joinedChannels = joinedChannels,
hasUnreadChannels = hasUnreadChannels,
isConnected = isConnected,
diff --git a/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt b/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt
index 1ae1c47f..40660cb3 100644
--- a/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt
+++ b/app/src/main/java/com/bitchat/android/ui/ChatScreen.kt
@@ -83,6 +83,10 @@ fun ChatScreen(viewModel: ChatViewModel) {
val showVerificationSheet by viewModel.showVerificationSheet.collectAsStateWithLifecycle()
val showSecurityVerificationSheet by viewModel.showSecurityVerificationSheet.collectAsStateWithLifecycle()
val legacyPrivateMediaConsent by viewModel.legacyPrivateMediaConsent.collectAsStateWithLifecycle()
+ val bridgeUiState by viewModel.bridgeUiState.collectAsStateWithLifecycle()
+
+ val panicWipeState by viewModel.panicWipeState.collectAsStateWithLifecycle()
+ PanicWipeDialog(panicWipeState, viewModel::panicClearAllData, viewModel::dismissPanicClear)
var messageText by remember { mutableStateOf(TextFieldValue("")) }
var showPasswordPrompt by remember { mutableStateOf(false) }
@@ -107,6 +111,15 @@ fun ChatScreen(viewModel: ChatViewModel) {
)
}
+ val sharedDraft by viewModel.sharedDraft.collectAsStateWithLifecycle()
+ LaunchedEffect(sharedDraft) {
+ sharedDraft?.let { shared ->
+ val combined = listOf(messageText.text, shared).filter { it.isNotBlank() }.joinToString("\n")
+ messageText = TextFieldValue(combined, androidx.compose.ui.text.TextRange(combined.length))
+ viewModel.consumeSharedText()
+ }
+ }
+
// Show password dialog when needed
LaunchedEffect(showPasswordPrompt) {
showPasswordDialog = showPasswordPrompt
@@ -307,7 +320,7 @@ fun ChatScreen(viewModel: ChatViewModel) {
conversationKey = conversationKey,
contentPadding = PaddingValues(
top = statusBarHeight + headerHeight +
- (if (showNotesStrip) notesStripHeight else 0.dp),
+ notesStripHeight,
bottom = composerHeight
),
forceScrollToBottom = forceScrollToBottom,
@@ -361,16 +374,13 @@ fun ChatScreen(viewModel: ChatViewModel) {
}
)
- if (showNotesStrip) {
- NearbyNotesStrip(
+ Column(modifier = Modifier.align(Alignment.TopCenter)
+ .padding(top = statusBarHeight + headerHeight)
+ .onSizeChanged { notesStripHeight = with(density) { it.height.toDp() } }) {
+ ConnectivityBanner()
+ if (showNotesStrip) NearbyNotesStrip(
noteCount = nearbyNotes.size,
- onClick = { showLocationNotesSheet = true },
- modifier = Modifier
- .align(Alignment.TopCenter)
- .padding(top = statusBarHeight + headerHeight)
- .onSizeChanged { size ->
- notesStripHeight = with(density) { size.height.toDp() }
- },
+ onClick = { showLocationNotesSheet = true }
)
}
@@ -443,7 +453,12 @@ fun ChatScreen(viewModel: ChatViewModel) {
currentChannel = currentChannel,
nickname = nickname,
colorScheme = colorScheme,
- showMediaButtons = showMediaButtons
+ showMediaButtons = showMediaButtons,
+ showBridgeControls = bridgeUiState.enabled &&
+ currentChannel == null &&
+ selectedLocationChannel !is com.bitchat.android.geohash.ChannelID.Location,
+ nearbyOnly = bridgeUiState.nearbyOnly,
+ onNearbyOnlyChange = viewModel::setBridgeNearbyOnly
)
}
}
@@ -457,7 +472,7 @@ fun ChatScreen(viewModel: ChatViewModel) {
colorScheme = colorScheme,
onSidebarToggle = { viewModel.showMeshPeerList() },
onShowAppInfo = { viewModel.showAppInfo() },
- onPanicClear = { viewModel.panicClearAllData() },
+ onPanicClear = { viewModel.requestPanicClear() },
onLocationChannelsClick = { showLocationChannelsSheet = true },
onLocationNotesClick = {
nearbyNotesController.reveal()
@@ -645,7 +660,10 @@ fun ChatInputSection(
colorScheme: ColorScheme,
showMediaButtons: Boolean,
recorderFactory: ((String?, String?) -> com.bitchat.android.features.voice.VoiceRecorder)? = null,
- modifier: Modifier = Modifier
+ modifier: Modifier = Modifier,
+ showBridgeControls: Boolean = false,
+ nearbyOnly: Boolean = false,
+ onNearbyOnlyChange: (Boolean) -> Unit = {}
) {
val context = androidx.compose.ui.platform.LocalContext.current
val activePublicTalker by remember(context) {
@@ -726,6 +744,9 @@ fun ChatInputSection(
currentChannel = currentChannel,
nickname = nickname,
showMediaButtons = showMediaButtons,
+ showBridgeControls = showBridgeControls,
+ nearbyOnly = nearbyOnly,
+ onNearbyOnlyChange = onNearbyOnlyChange,
mentionPeerIdentities = mentionPeerIdentities,
recorderFactory = recorderFactory,
activePublicTalker = activePublicTalker,
@@ -840,6 +861,7 @@ private fun ChatDialogs(
onMeshPeerListDismiss: () -> Unit,
) {
val privateChatSheetPeer by viewModel.privateChatSheetPeer.collectAsStateWithLifecycle()
+ val bridgeUiState by viewModel.bridgeUiState.collectAsStateWithLifecycle()
// Password dialog
PasswordPromptDialog(
@@ -853,10 +875,14 @@ private fun ChatDialogs(
// About sheet
var showDebugSheet by remember { mutableStateOf(false) }
+ var showMeshTopology by remember { mutableStateOf(false) }
AboutSheet(
isPresented = showAppInfo,
onDismiss = onAppInfoDismiss,
- onShowDebug = { showDebugSheet = true }
+ onShowDebug = { showDebugSheet = true },
+ bridgeEnabled = bridgeUiState.enabled,
+ onBridgeEnabledChange = viewModel::setBridgeEnabled,
+ onShowMeshTopology = { showMeshTopology = true },
)
if (showDebugSheet) {
com.bitchat.android.ui.debug.DebugSettingsSheet(
@@ -865,6 +891,11 @@ private fun ChatDialogs(
meshService = viewModel.meshService
)
}
+ MeshTopologySheet(
+ isPresented = showMeshTopology,
+ onDismiss = { showMeshTopology = false },
+ meshService = viewModel.meshServiceFacade,
+ )
// Location channels sheet
if (showLocationChannelsSheet) {
@@ -876,9 +907,9 @@ private fun ChatDialogs(
)
}
- // Location notes sheet (extracted to separate presenter)
+ // Unified mesh and geohash notices sheet.
if (showLocationNotesSheet) {
- LocationNotesSheetPresenter(
+ NoticesSheetPresenter(
viewModel = viewModel,
onDismiss = onLocationNotesSheetDismiss
)
diff --git a/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt b/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt
index f40549b6..c6aed279 100644
--- a/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt
+++ b/app/src/main/java/com/bitchat/android/ui/ChatViewModel.kt
@@ -2,6 +2,7 @@ package com.bitchat.android.ui
import android.app.Application
import android.util.Log
+import com.bitchat.android.R
import androidx.core.app.NotificationManagerCompat
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.viewModelScope
@@ -39,10 +40,25 @@ import com.bitchat.android.noise.NoiseSession
import com.bitchat.android.services.ContactDirectory
import com.bitchat.android.services.ContactIdentityResolver
import com.bitchat.android.util.hexEncodedString
+import com.bitchat.android.services.bridge.BridgeUiState
+import com.bitchat.android.services.bridge.MeshBridgeService
import com.bitchat.android.features.voice.LiveVoicePreferences
import com.bitchat.android.features.voice.LiveVoiceTarget
import com.bitchat.android.features.voice.VoiceRecorder
+import com.bitchat.android.groups.BitchatGroup
+import com.bitchat.android.groups.GroupCommandResult
+import com.bitchat.android.groups.GroupCoordinator
+import com.bitchat.android.groups.GroupCoordinatorContext
+import com.bitchat.android.groups.GroupIds
+import com.bitchat.android.groups.GroupPeerIdentity
+import com.bitchat.android.groups.GroupStore
+import com.bitchat.android.groups.PeerGroupCapability
+
+import com.bitchat.android.board.BoardManager
+import com.bitchat.android.board.BoardSigningIdentity
+import com.bitchat.android.board.BoardStore
+
private data class ConversationLiveIdentityState(
val connectedPeerIDs: List,
val peerNicknames: Map,
@@ -70,6 +86,9 @@ class ChatViewModel(
companion object {
private const val TAG = "ChatViewModel"
private const val CONVERSATION_DISCONNECT_GRACE_MS = 3_000L
+ private const val GROUP_COMMAND_USAGE =
+ "usage: /group create · invite @name[#identity] · " +
+ "remove @name[#identity] · leave · list"
}
fun sendVoiceNote(toPeerIDOrNull: String?, channelOrNull: String?, filePath: String) {
@@ -151,6 +170,10 @@ class ChatViewModel(
.select(com.bitchat.android.geohash.ChannelID.Mesh)
}
)
+ private val groupRuntime = com.bitchat.android.groups.GroupRuntime.getInstance(application)
+ private val groupStore = groupRuntime.store
+ private val groupCoordinator = groupRuntime.coordinator
+ val groups: StateFlow> = groupStore.groups
// Create Noise session delegate for clean dependency injection
private val noiseSessionDelegate = object : NoiseSessionDelegate {
@@ -178,11 +201,87 @@ class ChatViewModel(
privateChatManager,
viewModelScope
)
+ val boardManager = BoardManager(
+ store = BoardStore.getInstance(application.applicationContext),
+ scope = viewModelScope,
+ meshProvider = { mesh },
+ geoIdentityProvider = { geohash ->
+ runCatching {
+ NostrIdentityBridge.deriveIdentity(
+ forGeohash = geohash,
+ context = application.applicationContext
+ )
+ }.getOrNull()?.let { identity ->
+ BoardSigningIdentity.fromNostrPrivateKeyHex(identity.privateKeyHex)
+ }
+ },
+ onUrgentPosts = { geohash, posts ->
+ val text = if (posts.size == 1) {
+ val post = posts.single()
+ application.getString(
+ R.string.notices_alert_urgent_single,
+ post.authorNickname.trim().ifEmpty { "anon" },
+ post.content.truncateNoticeAlert()
+ )
+ } else {
+ application.getString(
+ R.string.notices_alert_urgent_collapsed,
+ posts.size
+ )
+ }
+ if (geohash.isEmpty()) {
+ messageManager.addSystemMessage(text)
+ } else {
+ messageManager.addChannelMessage(
+ "geo:$geohash",
+ BitchatMessage(
+ sender = "system",
+ content = text,
+ timestamp = Date(),
+ isRelay = false
+ )
+ )
+ }
+ }
+ )
private val notificationManager = NotificationManager(
application.applicationContext,
NotificationManagerCompat.from(application.applicationContext)
)
+ private val groupContext = object : com.bitchat.android.groups.GroupUiDelegate {
+ override val nickname get() = state.getNicknameValue()
+ override fun markGroupUnread(groupPeerID: String) {
+ state.setUnreadPrivateMessages(state.getUnreadPrivateMessagesValue() + groupPeerID)
+ }
+ override fun openGroupConversation(groupPeerID: String) {
+ privateChatManager.startPrivateChat(groupPeerID, mesh)
+ showPrivateChatSheet(groupPeerID)
+ }
+ override fun closeGroupConversation() { endPrivateChat() }
+ }
+
+ fun executeGroupCommand(arguments: List, onResult: (GroupCommandResult) -> Unit) {
+ viewModelScope.launch(Dispatchers.IO) {
+ val result = handleGroupCommand(arguments)
+ kotlinx.coroutines.withContext(Dispatchers.Main) { onResult(result) }
+ }
+ }
+
+ private fun handleGroupCommand(arguments: List): GroupCommandResult {
+ val subcommand = arguments.firstOrNull()?.lowercase()
+ ?: return GroupCommandResult(false, GROUP_COMMAND_USAGE)
+ val value = arguments.drop(1).joinToString(" ")
+ return when (subcommand) {
+ "create" -> groupCoordinator.createGroup(value)
+ "invite" -> groupCoordinator.inviteMember(value)
+ "remove" -> groupCoordinator.removeMember(value)
+ "leave" -> groupCoordinator.leaveGroup()
+ "list" -> groupCoordinator.listGroups()
+ else -> GroupCommandResult(false, GROUP_COMMAND_USAGE)
+ }
+ }
+
private val verificationHandler = VerificationHandler(
context = application.applicationContext,
scope = viewModelScope,
@@ -193,6 +292,7 @@ class ChatViewModel(
messageManager = messageManager
)
val verifiedFingerprints = verificationHandler.verifiedFingerprints
+ val vouchedFingerprints = verificationHandler.vouchedFingerprints
// Media file sending manager
private val mediaSendingManager = MediaSendingManager(
@@ -410,6 +510,21 @@ class ChatViewModel(
val geohashPeople: StateFlow> = state.geohashPeople
val teleportedGeo: StateFlow> = state.teleportedGeo
val geohashParticipantCounts: StateFlow> = state.geohashParticipantCounts
+ val bridgeUiState: StateFlow = combine(
+ MeshBridgeService.isEnabled,
+ MeshBridgeService.nearbyOnly,
+ MeshBridgeService.bridgedParticipants
+ ) { enabled, nearbyOnly, participants ->
+ BridgeUiState(enabled, nearbyOnly, participants)
+ }.stateIn(
+ scope = viewModelScope,
+ started = SharingStarted.Eagerly,
+ initialValue = BridgeUiState(
+ enabled = MeshBridgeService.isEnabled.value,
+ nearbyOnly = MeshBridgeService.nearbyOnly.value,
+ participants = MeshBridgeService.bridgedParticipants.value
+ )
+ )
val meshServiceFacade: MeshService
get() = mesh
val myPeerID: String
@@ -425,6 +540,7 @@ class ChatViewModel(
init {
observeConversationPresenceWithDisconnectGrace()
+ groupRuntime.attach(groupContext)
// Note: Mesh service delegate is now set by MainActivity
loadAndInitialize()
ContactDirectory.initialize(getApplication()) { mesh }
@@ -646,6 +762,7 @@ class ChatViewModel(
}
override fun onCleared() {
+ groupRuntime.detach(groupContext)
if (favoriteRelationshipListenerRegistered) {
runCatching {
FavoritesPersistenceService.shared.removeListener(
@@ -976,6 +1093,14 @@ class ChatViewModel(
val currentChannelValue = state.getCurrentChannelValue()
if (selectedPeer != null) {
+ if (GroupIds.isGroup(selectedPeer)) {
+ val groupPeer = selectedPeer
+ viewModelScope.launch(Dispatchers.IO) {
+ val accepted = groupCoordinator.sendMessage(content, groupPeer)
+ kotlinx.coroutines.withContext(Dispatchers.Main) { onAccepted(accepted) }
+ }
+ return
+ }
// If the selected peer is a temporary Nostr alias or a noise-hex identity, resolve to a canonical target
selectedPeer = ContactDirectory.canonicalConversationId(
com.bitchat.android.services.ConversationAliasResolver.resolveCanonicalPeerID(
@@ -1020,6 +1145,11 @@ class ChatViewModel(
messageId,
com.bitchat.android.model.DeliveryStatus.Sent
)
+ } else if (route == com.bitchat.android.services.MessageRouter.RouteResult.QUEUED) {
+ messageManager.updateMessageDeliveryStatus(
+ messageId,
+ com.bitchat.android.model.DeliveryStatus.Queued
+ )
}
}
onAccepted(accepted)
@@ -1269,6 +1399,20 @@ class ChatViewModel(
return verifiedFingerprints.contains(fingerprint)
}
+ fun isFingerprintVouched(fingerprint: String): Boolean =
+ verificationHandler.isFingerprintVouched(fingerprint)
+
+ fun isNoisePublicKeyVouched(noisePublicKey: ByteArray): Boolean =
+ verificationHandler.isFingerprintVouched(
+ verificationHandler.fingerprintFromNoiseBytes(noisePublicKey)
+ )
+
+ fun vouchersForFingerprint(fingerprint: String) =
+ verificationHandler.vouchersForFingerprint(fingerprint)
+
+ fun voucherNamesForFingerprint(fingerprint: String): List =
+ verificationHandler.voucherNamesForFingerprint(fingerprint)
+
fun unverifyFingerprint(peerID: String) {
verificationHandler.unverifyFingerprint(peerID)
}
@@ -1332,6 +1476,14 @@ class ChatViewModel(
state.setShowMeshPeerList(true)
}
+ fun setBridgeEnabled(enabled: Boolean) {
+ MeshBridgeService.setEnabled(enabled)
+ }
+
+ fun setBridgeNearbyOnly(enabled: Boolean) {
+ MeshBridgeService.setNearbyOnly(enabled)
+ }
+
fun hideMeshPeerList() {
state.setShowMeshPeerList(false)
}
@@ -1421,6 +1573,27 @@ class ChatViewModel(
override fun didResolvePrivateMediaPolicy(peerID: String) {
mediaSendingManager.retryPendingPrivateMedia(peerID)
+ groupCoordinator.handlePeerAuthenticated(peerID)
+ }
+
+ override fun didReceiveGroupInvite(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ groupCoordinator.handleInvite(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun didReceiveGroupKeyUpdate(
+ peerID: String,
+ authenticatedRemoteStaticKey: ByteArray,
+ payload: ByteArray
+ ) {
+ groupCoordinator.handleKeyUpdate(peerID, authenticatedRemoteStaticKey, payload)
+ }
+
+ override fun didReceiveGroupMessage(payload: ByteArray, timestampMs: Long) {
+ groupCoordinator.handleMessage(payload, timestampMs)
}
override fun decryptChannelMessage(encryptedContent: ByteArray, channel: String): String? {
@@ -1435,102 +1608,78 @@ class ChatViewModel(
return meshDelegateHandler.isFavorite(peerID)
}
+ private val _sharedDraft = MutableStateFlow