permissionlesstech/bitchat-android
1
0
Fork 0
mirror of https://github.com/permissionlesstech/bitchat-android.git synced 2026-07-25 08:25:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor but untested

Browse Source
This commit is contained in:
callebtc
2025-07-21 23:35:23 +02:00
parent cdac892042
commit a6469a3d73
2 changed files with 96 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/src/main/java/com/bitchat/android/mesh/BluetoothMeshService.kt
+95 -62
View File
@@ -472,54 +472,46 @@ class BluetoothMeshService(private val context: Context) {
fun sendPrivateMessage(content: String, recipientPeerID: String, recipientNickname: String, messageID: String? = null) { fun sendPrivateMessage(content: String, recipientPeerID: String, recipientNickname: String, messageID: String? = null) {
if (content.isEmpty() || recipientPeerID.isEmpty() || recipientNickname.isEmpty()) return if (content.isEmpty() || recipientPeerID.isEmpty() || recipientNickname.isEmpty()) return
serviceScope.launch { val nickname = delegate?.getNickname() ?: myPeerID
val nickname = delegate?.getNickname() ?: myPeerID
val message = BitchatMessage(
val message = BitchatMessage( id = messageID ?: UUID.randomUUID().toString(),
id = messageID ?: UUID.randomUUID().toString(), sender = nickname,
sender = nickname, content = content,
content = content, timestamp = Date(),
timestamp = Date(), isRelay = false,
isRelay = false, isPrivate = true,
isPrivate = true, recipientNickname = recipientNickname,
recipientNickname = recipientNickname, senderPeerID = myPeerID
senderPeerID = myPeerID )
)
message.toBinaryPayload()?.let { messageData ->
message.toBinaryPayload()?.let { messageData -> try {
try { // Pad the message data
// Pad and encrypt val blockSize = MessagePadding.optimalBlockSize(messageData.size)
val blockSize = MessagePadding.optimalBlockSize(messageData.size) val paddedData = MessagePadding.pad(messageData, blockSize)
val paddedData = MessagePadding.pad(messageData, blockSize)
val encryptedPayload = securityManager.encryptForPeer(paddedData, recipientPeerID) // Create inner packet with the padded message data
val innerPacket = BitchatPacket(
if (encryptedPayload != null) { type = MessageType.MESSAGE.value,
// Sign senderID = hexStringToByteArray(myPeerID),
// val signature = securityManager.signPacket(encryptedPayload) recipientID = hexStringToByteArray(recipientPeerID),
timestamp = System.currentTimeMillis().toULong(),
val packet = BitchatPacket( payload = paddedData,
type = MessageType.NOISE_ENCRYPTED.value, signature = null,
senderID = hexStringToByteArray(myPeerID), ttl = MAX_TTL
recipientID = hexStringToByteArray(recipientPeerID), )
timestamp = System.currentTimeMillis().toULong(),
payload = encryptedPayload, // Cache for offline favorites
signature = null, if (storeForwardManager.shouldCacheForPeer(recipientPeerID)) {
ttl = MAX_TTL storeForwardManager.cacheMessage(innerPacket, messageID ?: message.id)
)
// Cache for offline favorites
if (storeForwardManager.shouldCacheForPeer(recipientPeerID)) {
storeForwardManager.cacheMessage(packet, messageID ?: message.id)
}
// Send with delay
delay(Random.nextLong(50, 500))
connectionManager.broadcastPacket(RoutedPacket(packet))
}
} catch (e: Exception) {
Log.e(TAG, "Failed to send private message: ${e.message}")
} }
// Use the new encrypt and broadcast function
encryptAndBroadcastNoisePacket(innerPacket, recipientPeerID)
} catch (e: Exception) {
Log.e(TAG, "Failed to send private message: ${e.message}")
} }
} }
} }
@@ -528,34 +520,75 @@ class BluetoothMeshService(private val context: Context) {
* Send delivery acknowledgment for a received private message * Send delivery acknowledgment for a received private message
*/ */
fun sendDeliveryAck(message: BitchatMessage, senderPeerID: String) { fun sendDeliveryAck(message: BitchatMessage, senderPeerID: String) {
serviceScope.launch { val nickname = delegate?.getNickname() ?: myPeerID
val nickname = delegate?.getNickname() ?: myPeerID val ack = DeliveryAck(
val ack = DeliveryAck( originalMessageID = message.id,
originalMessageID = message.id, recipientID = myPeerID,
recipientID = myPeerID, recipientNickname = nickname,
recipientNickname = nickname, hopCount = 0u // Will be calculated during relay
hopCount = 0u // Will be calculated during relay )
try {
val ackData = ack.encode() ?: return
// Create inner packet with the delivery ACK data
val innerPacket = BitchatPacket(
type = MessageType.DELIVERY_ACK.value,
senderID = hexStringToByteArray(myPeerID),
recipientID = hexStringToByteArray(senderPeerID),
timestamp = System.currentTimeMillis().toULong(),
payload = ackData,
signature = null,
ttl = 3u
) )
// Use the new encrypt and broadcast function
encryptAndBroadcastNoisePacket(innerPacket, senderPeerID)
} catch (e: Exception) {
Log.e(TAG, "Failed to send delivery ACK: ${e.message}")
}
}
/**
* Encrypt a BitchatPacket and broadcast it as a NOISE_ENCRYPTED message
* This is the correct protocol implementation - encrypt the entire packet, not just the payload
*/
private fun encryptAndBroadcastNoisePacket(innerPacket: BitchatPacket, recipientPeerID: String) {
serviceScope.launch {
try { try {
val ackData = ack.encode() ?: return@launch // Serialize the inner packet to binary data
val encryptedPayload = securityManager.encryptForPeer(ackData, senderPeerID) val innerPacketData = innerPacket.toBinaryData()
if (innerPacketData == null) {
Log.e(TAG, "Failed to serialize inner packet for encryption")
return@launch
}
// Encrypt the serialized packet using Noise encryption
val encryptedPayload = securityManager.encryptForPeer(innerPacketData, recipientPeerID)
if (encryptedPayload != null) { if (encryptedPayload != null) {
val packet = BitchatPacket( // Create the outer NOISE_ENCRYPTED packet
type = MessageType.DELIVERY_ACK.value, val outerPacket = BitchatPacket(
type = MessageType.NOISE_ENCRYPTED.value,
senderID = hexStringToByteArray(myPeerID), senderID = hexStringToByteArray(myPeerID),
recipientID = hexStringToByteArray(senderPeerID), recipientID = hexStringToByteArray(recipientPeerID),
timestamp = System.currentTimeMillis().toULong(), timestamp = System.currentTimeMillis().toULong(),
payload = encryptedPayload, payload = encryptedPayload,
signature = null, signature = null,
ttl = 3u ttl = MAX_TTL
) )
connectionManager.broadcastPacket(RoutedPacket(packet)) // Broadcast the encrypted packet
connectionManager.broadcastPacket(RoutedPacket(outerPacket))
Log.d(TAG, "Encrypted and sent packet type ${innerPacket.type} to $recipientPeerID (${encryptedPayload.size} bytes encrypted)")
} else {
Log.w(TAG, "Failed to encrypt packet for $recipientPeerID - no session available")
} }
} catch (e: Exception) { } catch (e: Exception) {
Log.e(TAG, "Failed to send delivery ACK: ${e.message}") Log.e(TAG, "Failed to encrypt and broadcast Noise packet to $recipientPeerID: ${e.message}")
} }
} }
} }
app/src/main/java/com/bitchat/android/mesh/PacketProcessor.kt
+1 -1
View File
@@ -39,7 +39,7 @@ class PacketProcessor(private val myPeerID: String) {
Log.d(TAG, "🎭 Created packet actor for peer: $peerID") Log.d(TAG, "🎭 Created packet actor for peer: $peerID")
try { try {
for (packet in channel) { for (packet in channel) {
Log.d(TAG, "Processing packet type ${packet.packet.type} from $peerID (serialized)") Log.d(TAG, "📦 Processing packet type ${packet.packet.type} from $peerID (serialized)")
handleReceivedPacket(packet) handleReceivedPacket(packet)
Log.d(TAG, "Completed packet type ${packet.packet.type} from $peerID") Log.d(TAG, "Completed packet type ${packet.packet.type} from $peerID")
} }