noise

app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt

@@ -226,8 +226,16 @@ class BluetoothMeshService(private val context: Context) {
                 peerManager.updatePeerLastSeen(peerID)
             }
             
-            override fun handleKeyExchange(routed: RoutedPacket): Boolean {
-                return runBlocking { securityManager.handleKeyExchange(routed) }
+            override fun handleNoiseHandshake(routed: RoutedPacket, step: Int): Boolean {
+                return runBlocking { securityManager.handleNoiseHandshake(routed, step) }
+            }
+            
+            override fun handleNoiseEncrypted(routed: RoutedPacket) {
+                serviceScope.launch { messageHandler.handleNoiseEncrypted(routed) }
+            }
+            
+            override fun handleNoiseIdentityAnnouncement(routed: RoutedPacket) {
+                serviceScope.launch { messageHandler.handleNoiseIdentityAnnouncement(routed) }
             }
             
             override fun handleAnnounce(routed: RoutedPacket) {
@@ -493,7 +501,7 @@ class BluetoothMeshService(private val context: Context) {
     private fun sendKeyExchangeToDevice() {
         val publicKeyData = securityManager.getCombinedPublicKeyData()
         val packet = BitchatPacket(
-            type = MessageType.KEY_EXCHANGE.value,
+            type = MessageType.NOISE_HANDSHAKE_INIT.value,
             ttl = 1u,
             senderID = myPeerID,
             payload = publicKeyData

app/src/main/java/com/bitchat/android/mesh/MessageHandler.kt

@@ -28,6 +28,30 @@ class MessageHandler(private val myPeerID: String) {
     // Coroutines
     private val handlerScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
     
+    /**
+     * Handle Noise encrypted transport message (temporarily stubbed)
+     */
+    suspend fun handleNoiseEncrypted(routed: RoutedPacket) {
+        val packet = routed.packet
+        val peerID = routed.peerID ?: "unknown"
+        
+        Log.d(TAG, "TODO: Handle Noise encrypted message from $peerID (${packet.payload.size} bytes)")
+        
+        // For now, just log it - this will be implemented with actual Noise protocol handling
+    }
+    
+    /**
+     * Handle Noise identity announcement (temporarily stubbed)
+     */
+    suspend fun handleNoiseIdentityAnnouncement(routed: RoutedPacket) {
+        val packet = routed.packet
+        val peerID = routed.peerID ?: "unknown"
+        
+        Log.d(TAG, "TODO: Handle Noise identity announcement from $peerID (${packet.payload.size} bytes)")
+        
+        // For now, just log it - this will be implemented with peer ID rotation handling
+    }
+    
     /**
      * Handle announce message
      */

app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt

@@ -51,7 +51,10 @@ class PacketProcessor(private val myPeerID: String) {
         
         // Process based on message type (exact same logic as iOS)
         when (MessageType.fromValue(packet.type)) {
-            MessageType.KEY_EXCHANGE -> handleKeyExchange(routed)
+            MessageType.NOISE_HANDSHAKE_INIT -> handleNoiseHandshake(routed, 1)
+            MessageType.NOISE_HANDSHAKE_RESP -> handleNoiseHandshake(routed, 2)
+            MessageType.NOISE_ENCRYPTED -> handleNoiseEncrypted(routed)
+            MessageType.NOISE_IDENTITY_ANNOUNCE -> handleNoiseIdentityAnnouncement(routed)
             MessageType.ANNOUNCE -> handleAnnounce(routed)
             MessageType.MESSAGE -> handleMessage(routed)
             MessageType.LEAVE -> handleLeave(routed)
@@ -67,16 +70,17 @@ class PacketProcessor(private val myPeerID: String) {
     }
     
     /**
-     * Handle key exchange message
+     * Handle Noise handshake message
      */
-    private suspend fun handleKeyExchange(routed: RoutedPacket) {
+    private suspend fun handleNoiseHandshake(routed: RoutedPacket, step: Int) {
         val peerID = routed.peerID ?: "unknown"
-        Log.d(TAG, "Processing key exchange from $peerID")
+        Log.d(TAG, "Processing Noise handshake step $step from $peerID")
         
-        val success = delegate?.handleKeyExchange(routed) ?: false
+        val success = delegate?.handleNoiseHandshake(routed, step) ?: false
         
         if (success) {
-            // Key exchange successful, send announce and cached messages
+            // Handshake successful, may need to send announce and cached messages
+            // This will be determined by the Noise implementation when session is established
             delay(100)
             delegate?.sendAnnouncementToPeer(peerID)
             
@@ -85,6 +89,24 @@ class PacketProcessor(private val myPeerID: String) {
         }
     }
     
+    /**
+     * Handle Noise encrypted transport message
+     */
+    private suspend fun handleNoiseEncrypted(routed: RoutedPacket) {
+        val peerID = routed.peerID ?: "unknown"
+        Log.d(TAG, "Processing Noise encrypted message from $peerID")
+        delegate?.handleNoiseEncrypted(routed)
+    }
+    
+    /**
+     * Handle Noise identity announcement (after peer ID rotation)
+     */
+    private suspend fun handleNoiseIdentityAnnouncement(routed: RoutedPacket) {
+        val peerID = routed.peerID ?: "unknown"
+        Log.d(TAG, "Processing Noise identity announcement from $peerID")
+        delegate?.handleNoiseIdentityAnnouncement(routed)
+    }
+    
     /**
      * Handle announce message
      */
@@ -174,7 +196,9 @@ interface PacketProcessorDelegate {
     fun updatePeerLastSeen(peerID: String)
     
     // Message type handlers
-    fun handleKeyExchange(routed: RoutedPacket): Boolean
+    fun handleNoiseHandshake(routed: RoutedPacket, step: Int): Boolean
+    fun handleNoiseEncrypted(routed: RoutedPacket)
+    fun handleNoiseIdentityAnnouncement(routed: RoutedPacket)
     fun handleAnnounce(routed: RoutedPacket)
     fun handleMessage(routed: RoutedPacket)
     fun handleLeave(routed: RoutedPacket)

app/src/main/java/com/bitchat/android/mesh/SecurityManager.kt

@@ -86,6 +86,19 @@ class SecurityManager(private val encryptionService: EncryptionService, private
         return true
     }
     
+    /**
+     * Handle Noise handshake packet (temporarily stubbed for basic build)
+     */
+    suspend fun handleNoiseHandshake(routed: RoutedPacket, step: Int): Boolean {
+        val packet = routed.packet
+        val peerID = routed.peerID ?: "unknown"
+
+        Log.d(TAG, "TODO: Handle Noise handshake step $step from $peerID (${packet.payload.size} bytes)")
+        
+        // For now, just treat it as a key exchange for compatibility
+        return handleKeyExchange(routed)
+    }
+    
     /**
      * Handle key exchange packet
      */

app/src/main/java/com/bitchat/android/mesh/StoreForwardManager.kt

@@ -53,7 +53,10 @@ class StoreForwardManager {
      */
     fun cacheMessage(packet: BitchatPacket, messageID: String) {
         // Skip certain message types (same as iOS)
-        if (packet.type == MessageType.KEY_EXCHANGE.value ||
+        if (packet.type == MessageType.NOISE_HANDSHAKE_INIT.value ||
+            packet.type == MessageType.NOISE_HANDSHAKE_RESP.value ||
+            packet.type == MessageType.NOISE_ENCRYPTED.value ||
+            packet.type == MessageType.NOISE_IDENTITY_ANNOUNCE.value ||
             packet.type == MessageType.ANNOUNCE.value ||
             packet.type == MessageType.LEAVE.value) {
             Log.d(TAG, "Skipping cache for message type: ${packet.type}")