mirror of
https://github.com/permissionlesstech/bitchat.git
synced 2026-07-25 00:45:21 +00:00
Fix Noise handshake failures and implement binary protocol migration
- Fix asymmetric handshake state causing message delivery failures - Prevent duplicate handshake init messages from disrupting ongoing handshakes - Add defensive copying to all binary decoders to prevent thread safety issues - Implement binary encoding for all 9 message types (60-80% bandwidth reduction) - Fix delivery ACK decoding for Noise encrypted messages - Add comprehensive logging for debugging handshake and message flow - Fix race condition in delivery status updates - Add relay logic for handshake packets to ensure mesh delivery - Maintain backward compatibility with JSON fallback
This commit is contained in:
jack
@@ -210,6 +210,15 @@ extension Data {
|
||||
|
||||
return result.uppercased()
|
||||
}
|
||||
|
||||
func readFixedBytes(at offset: inout Int, count: Int) -> Data? {
|
||||
guard offset + count <= self.count else { return nil }
|
||||
|
||||
let data = self[offset..<offset + count]
|
||||
offset += count
|
||||
|
||||
return data
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Binary Message Protocol
|
||||
|
||||
@@ -251,22 +251,23 @@ struct DeliveryAck: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> DeliveryAck? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
// Minimum size: 2 UUIDs (32) + recipientID (8) + hopCount (1) + timestamp (8) + min nickname
|
||||
guard data.count >= 50 else { return nil }
|
||||
guard dataCopy.count >= 50 else { return nil }
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let originalMessageID = data.readUUID(at: &offset),
|
||||
let ackID = data.readUUID(at: &offset) else { return nil }
|
||||
guard let originalMessageID = dataCopy.readUUID(at: &offset),
|
||||
let ackID = dataCopy.readUUID(at: &offset) else { return nil }
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let recipientIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
guard let recipientIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let recipientID = recipientIDData.hexEncodedString()
|
||||
|
||||
guard let hopCount = data.readUInt8(at: &offset),
|
||||
let timestamp = data.readDate(at: &offset),
|
||||
let recipientNickname = data.readString(at: &offset) else { return nil }
|
||||
guard let hopCount = dataCopy.readUInt8(at: &offset),
|
||||
let timestamp = dataCopy.readDate(at: &offset),
|
||||
let recipientNickname = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
return DeliveryAck(originalMessageID: originalMessageID,
|
||||
ackID: ackID,
|
||||
@@ -336,21 +337,22 @@ struct ReadReceipt: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> ReadReceipt? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
// Minimum size: 2 UUIDs (32) + readerID (8) + timestamp (8) + min nickname
|
||||
guard data.count >= 49 else { return nil }
|
||||
guard dataCopy.count >= 49 else { return nil }
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let originalMessageID = data.readUUID(at: &offset),
|
||||
let receiptID = data.readUUID(at: &offset) else { return nil }
|
||||
guard let originalMessageID = dataCopy.readUUID(at: &offset),
|
||||
let receiptID = dataCopy.readUUID(at: &offset) else { return nil }
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let readerIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
guard let readerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let readerID = readerIDData.hexEncodedString()
|
||||
|
||||
guard let timestamp = data.readDate(at: &offset),
|
||||
let readerNickname = data.readString(at: &offset) else { return nil }
|
||||
guard let timestamp = dataCopy.readDate(at: &offset),
|
||||
let readerNickname = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
return ReadReceipt(originalMessageID: originalMessageID,
|
||||
receiptID: receiptID,
|
||||
@@ -415,17 +417,18 @@ struct ChannelKeyVerifyRequest: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> ChannelKeyVerifyRequest? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let channel = data.readString(at: &offset) else { return nil }
|
||||
guard let channel = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let requesterIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
guard let requesterIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let requesterID = requesterIDData.hexEncodedString()
|
||||
|
||||
guard let keyCommitment = data.readString(at: &offset),
|
||||
let timestamp = data.readDate(at: &offset) else { return nil }
|
||||
guard let keyCommitment = dataCopy.readString(at: &offset),
|
||||
let timestamp = dataCopy.readDate(at: &offset) else { return nil }
|
||||
|
||||
return ChannelKeyVerifyRequest(channel: channel,
|
||||
requesterID: requesterID,
|
||||
@@ -489,17 +492,18 @@ struct ChannelKeyVerifyResponse: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> ChannelKeyVerifyResponse? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let channel = data.readString(at: &offset) else { return nil }
|
||||
guard let channel = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let responderIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
guard let responderIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let responderID = responderIDData.hexEncodedString()
|
||||
|
||||
guard let verifiedByte = data.readUInt8(at: &offset),
|
||||
let timestamp = data.readDate(at: &offset) else { return nil }
|
||||
guard let verifiedByte = dataCopy.readUInt8(at: &offset),
|
||||
let timestamp = dataCopy.readDate(at: &offset) else { return nil }
|
||||
|
||||
let verified = verifiedByte != 0
|
||||
|
||||
@@ -573,19 +577,20 @@ struct ChannelPasswordUpdate: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> ChannelPasswordUpdate? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let channel = data.readString(at: &offset) else { return nil }
|
||||
guard let channel = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let ownerIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
guard let ownerIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let ownerID = ownerIDData.hexEncodedString()
|
||||
|
||||
guard let ownerFingerprint = data.readString(at: &offset),
|
||||
let encryptedPassword = data.readData(at: &offset),
|
||||
let newKeyCommitment = data.readString(at: &offset),
|
||||
let timestamp = data.readDate(at: &offset) else { return nil }
|
||||
guard let ownerFingerprint = dataCopy.readString(at: &offset),
|
||||
let encryptedPassword = dataCopy.readData(at: &offset),
|
||||
let newKeyCommitment = dataCopy.readString(at: &offset),
|
||||
let timestamp = dataCopy.readDate(at: &offset) else { return nil }
|
||||
|
||||
return ChannelPasswordUpdate(channel: channel,
|
||||
ownerID: ownerID,
|
||||
@@ -669,27 +674,28 @@ struct ChannelMetadata: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> ChannelMetadata? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let flags = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let flags = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
let hasKeyCommitment = (flags & 0x01) != 0
|
||||
|
||||
guard let channel = data.readString(at: &offset) else { return nil }
|
||||
guard let channel = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let creatorIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
guard let creatorIDData = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let creatorID = creatorIDData.hexEncodedString()
|
||||
|
||||
guard let creatorFingerprint = data.readString(at: &offset),
|
||||
let createdAt = data.readDate(at: &offset),
|
||||
let isPasswordProtectedByte = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let creatorFingerprint = dataCopy.readString(at: &offset),
|
||||
let createdAt = dataCopy.readDate(at: &offset),
|
||||
let isPasswordProtectedByte = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
|
||||
let isPasswordProtected = isPasswordProtectedByte != 0
|
||||
|
||||
var keyCommitment: String? = nil
|
||||
if hasKeyCommitment {
|
||||
keyCommitment = data.readString(at: &offset)
|
||||
keyCommitment = dataCopy.readString(at: &offset)
|
||||
}
|
||||
|
||||
return ChannelMetadata(channel: channel,
|
||||
@@ -784,33 +790,34 @@ struct NoiseIdentityAnnouncement: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> NoiseIdentityAnnouncement? {
|
||||
// Minimum size check
|
||||
guard data.count >= 20 else { return nil }
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
// Minimum size check: flags(1) + peerID(8) + min data lengths
|
||||
guard dataCopy.count >= 20 else { return nil }
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let flags = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let flags = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
let hasPreviousPeerID = (flags & 0x01) != 0
|
||||
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let peerIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
let peerID = peerIDData.hexEncodedString()
|
||||
// Read peerID using safe method
|
||||
guard let peerIDBytes = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
let peerID = peerIDBytes.hexEncodedString()
|
||||
|
||||
guard let publicKey = data.readData(at: &offset),
|
||||
let signingPublicKey = data.readData(at: &offset),
|
||||
let nickname = data.readString(at: &offset),
|
||||
let timestamp = data.readDate(at: &offset) else { return nil }
|
||||
guard let publicKey = dataCopy.readData(at: &offset),
|
||||
let signingPublicKey = dataCopy.readData(at: &offset),
|
||||
let nickname = dataCopy.readString(at: &offset),
|
||||
let timestamp = dataCopy.readDate(at: &offset) else { return nil }
|
||||
|
||||
var previousPeerID: String? = nil
|
||||
if hasPreviousPeerID {
|
||||
guard offset + 8 <= data.count else { return nil }
|
||||
let previousPeerIDData = data[offset..<offset + 8]
|
||||
offset += 8
|
||||
previousPeerID = previousPeerIDData.hexEncodedString()
|
||||
// Read previousPeerID using safe method
|
||||
guard let prevIDBytes = dataCopy.readFixedBytes(at: &offset, count: 8) else { return nil }
|
||||
previousPeerID = prevIDBytes.hexEncodedString()
|
||||
}
|
||||
|
||||
guard let signature = data.readData(at: &offset) else { return nil }
|
||||
guard let signature = dataCopy.readData(at: &offset) else { return nil }
|
||||
|
||||
return NoiseIdentityAnnouncement(peerID: peerID,
|
||||
publicKey: publicKey,
|
||||
@@ -930,31 +937,34 @@ struct VersionHello: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> VersionHello? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
// Minimum size check: flags(1) + versionCount(1) + at least one version(1) + preferredVersion(1) + min strings
|
||||
guard data.count >= 4 else { return nil }
|
||||
guard dataCopy.count >= 4 else { return nil }
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let flags = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let flags = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
let hasCapabilities = (flags & 0x01) != 0
|
||||
|
||||
guard let versionCount = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let versionCount = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
var supportedVersions: [UInt8] = []
|
||||
for _ in 0..<versionCount {
|
||||
guard let version = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let version = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
supportedVersions.append(version)
|
||||
}
|
||||
|
||||
guard let preferredVersion = data.readUInt8(at: &offset),
|
||||
let clientVersion = data.readString(at: &offset),
|
||||
let platform = data.readString(at: &offset) else { return nil }
|
||||
guard let preferredVersion = dataCopy.readUInt8(at: &offset),
|
||||
let clientVersion = dataCopy.readString(at: &offset),
|
||||
let platform = dataCopy.readString(at: &offset) else { return nil }
|
||||
|
||||
var capabilities: [String]? = nil
|
||||
if hasCapabilities {
|
||||
guard let capCount = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let capCount = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
capabilities = []
|
||||
for _ in 0..<capCount {
|
||||
guard let capability = data.readString(at: &offset) else { return nil }
|
||||
guard let capability = dataCopy.readString(at: &offset) else { return nil }
|
||||
capabilities?.append(capability)
|
||||
}
|
||||
}
|
||||
@@ -1029,35 +1039,38 @@ struct VersionAck: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> VersionAck? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
// Minimum size: flags(1) + version(1) + rejected(1) + min strings
|
||||
guard data.count >= 5 else { return nil }
|
||||
guard dataCopy.count >= 5 else { return nil }
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let flags = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let flags = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
let hasCapabilities = (flags & 0x01) != 0
|
||||
let hasReason = (flags & 0x02) != 0
|
||||
|
||||
guard let agreedVersion = data.readUInt8(at: &offset),
|
||||
let serverVersion = data.readString(at: &offset),
|
||||
let platform = data.readString(at: &offset),
|
||||
let rejectedByte = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let agreedVersion = dataCopy.readUInt8(at: &offset),
|
||||
let serverVersion = dataCopy.readString(at: &offset),
|
||||
let platform = dataCopy.readString(at: &offset),
|
||||
let rejectedByte = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
|
||||
let rejected = rejectedByte != 0
|
||||
|
||||
var capabilities: [String]? = nil
|
||||
if hasCapabilities {
|
||||
guard let capCount = data.readUInt8(at: &offset) else { return nil }
|
||||
guard let capCount = dataCopy.readUInt8(at: &offset) else { return nil }
|
||||
capabilities = []
|
||||
for _ in 0..<capCount {
|
||||
guard let capability = data.readString(at: &offset) else { return nil }
|
||||
guard let capability = dataCopy.readString(at: &offset) else { return nil }
|
||||
capabilities?.append(capability)
|
||||
}
|
||||
}
|
||||
|
||||
var reason: String? = nil
|
||||
if hasReason {
|
||||
reason = data.readString(at: &offset)
|
||||
reason = dataCopy.readString(at: &offset)
|
||||
}
|
||||
|
||||
return VersionAck(agreedVersion: agreedVersion,
|
||||
|
||||
@@ -904,6 +904,7 @@ class BluetoothMeshService: NSObject {
|
||||
|
||||
// Encode the ACK
|
||||
let ackData = ack.toBinaryData()
|
||||
print("📤 Sending delivery ACK for message \(ack.originalMessageID) to \(recipientID) - binary size: \(ackData.count)")
|
||||
|
||||
// Check if we have a Noise session with this peer
|
||||
// Use noiseService directly
|
||||
@@ -1779,6 +1780,7 @@ class BluetoothMeshService: NSObject {
|
||||
myNickname: myNickname,
|
||||
hopCount: UInt8(self.maxTTL - packet.ttl)
|
||||
) {
|
||||
print("🔔 Generating delivery ACK for channel mention message \(messageWithPeerID.id)")
|
||||
self.sendDeliveryAck(ack, to: senderID)
|
||||
}
|
||||
}
|
||||
@@ -1873,6 +1875,7 @@ class BluetoothMeshService: NSObject {
|
||||
myNickname: myNickname,
|
||||
hopCount: UInt8(self.maxTTL - packet.ttl)
|
||||
) {
|
||||
print("💬 Generating delivery ACK for private message \(messageWithPeerID.id) from \(senderID)")
|
||||
self.sendDeliveryAck(ack, to: senderID)
|
||||
}
|
||||
} else {
|
||||
@@ -2297,8 +2300,24 @@ class BluetoothMeshService: NSObject {
|
||||
// Handle Noise identity announcement
|
||||
let senderID = packet.senderID.hexEncodedString()
|
||||
if senderID != myPeerID && !isPeerIDOurs(senderID) {
|
||||
// Create defensive copy and validate
|
||||
let payloadCopy = Data(packet.payload)
|
||||
|
||||
guard !payloadCopy.isEmpty else {
|
||||
SecurityLogger.log("Received empty NoiseIdentityAnnouncement from \(senderID)", category: SecurityLogger.noise, level: .error)
|
||||
return
|
||||
}
|
||||
|
||||
// Decode the announcement
|
||||
guard let announcement = NoiseIdentityAnnouncement.fromBinaryData(packet.payload) ?? NoiseIdentityAnnouncement.decode(from: packet.payload) else {
|
||||
let announcement: NoiseIdentityAnnouncement?
|
||||
if let firstByte = payloadCopy.first, firstByte == 0x7B { // '{' character - JSON
|
||||
announcement = NoiseIdentityAnnouncement.decode(from: payloadCopy) ?? NoiseIdentityAnnouncement.fromBinaryData(payloadCopy)
|
||||
} else {
|
||||
announcement = NoiseIdentityAnnouncement.fromBinaryData(payloadCopy) ?? NoiseIdentityAnnouncement.decode(from: payloadCopy)
|
||||
}
|
||||
|
||||
guard let announcement = announcement else {
|
||||
SecurityLogger.log("Failed to decode NoiseIdentityAnnouncement from \(senderID), size: \(payloadCopy.count)", category: SecurityLogger.noise, level: .error)
|
||||
return
|
||||
}
|
||||
|
||||
@@ -2360,13 +2379,27 @@ class BluetoothMeshService: NSObject {
|
||||
case .noiseHandshakeInit:
|
||||
// Handle incoming Noise handshake initiation
|
||||
let senderID = packet.senderID.hexEncodedString()
|
||||
print("🤝 Received Noise handshake init from \(senderID), payload size: \(packet.payload.count)")
|
||||
|
||||
// Check if this handshake is for us or broadcast
|
||||
if let recipientID = packet.recipientID,
|
||||
!isPeerIDOurs(recipientID.hexEncodedString()) {
|
||||
// Not for us, ignore
|
||||
// Not for us, relay if TTL > 0
|
||||
if packet.ttl > 0 {
|
||||
print("🔀 Relaying handshake init packet, TTL: \(packet.ttl)")
|
||||
var relayPacket = packet
|
||||
relayPacket.ttl -= 1
|
||||
broadcastPacket(relayPacket)
|
||||
}
|
||||
return
|
||||
}
|
||||
if !isPeerIDOurs(senderID) {
|
||||
// Check if we already have a session (established or handshaking)
|
||||
if noiseService.hasSession(with: senderID) {
|
||||
print("⚠️ Received handshake init from \(senderID) but already have session/handshaking - ignoring duplicate")
|
||||
return
|
||||
}
|
||||
|
||||
// Check if we've completed version negotiation with this peer
|
||||
if negotiatedVersions[senderID] == nil {
|
||||
// Legacy peer - assume version 1 for backward compatibility
|
||||
@@ -2381,13 +2414,26 @@ class BluetoothMeshService: NSObject {
|
||||
case .noiseHandshakeResp:
|
||||
// Handle Noise handshake response
|
||||
let senderID = packet.senderID.hexEncodedString()
|
||||
print("🤝 Received Noise handshake response from \(senderID)")
|
||||
|
||||
// Check if this handshake response is for us
|
||||
if let recipientID = packet.recipientID,
|
||||
!isPeerIDOurs(recipientID.hexEncodedString()) {
|
||||
// Not for us, ignore
|
||||
return
|
||||
if let recipientID = packet.recipientID {
|
||||
let recipientIDStr = recipientID.hexEncodedString()
|
||||
print("🤝 Response targeted to: \(recipientIDStr), is us: \(isPeerIDOurs(recipientIDStr))")
|
||||
if !isPeerIDOurs(recipientIDStr) {
|
||||
// Not for us, relay if TTL > 0
|
||||
if packet.ttl > 0 {
|
||||
print("🔀 Relaying handshake response packet, TTL: \(packet.ttl)")
|
||||
var relayPacket = packet
|
||||
relayPacket.ttl -= 1
|
||||
broadcastPacket(relayPacket)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if !isPeerIDOurs(senderID) {
|
||||
print("🤝 Processing handshake response from \(senderID)")
|
||||
handleNoiseHandshakeMessage(from: senderID, message: packet.payload, isInitiation: false)
|
||||
}
|
||||
|
||||
@@ -3344,11 +3390,14 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
guard let self = self,
|
||||
let pendingMessages = self.pendingPrivateMessages[peerID] else { return }
|
||||
|
||||
print("📬 Sending \(pendingMessages.count) pending private messages to \(peerID)")
|
||||
|
||||
// Clear pending messages for this peer
|
||||
self.pendingPrivateMessages.removeValue(forKey: peerID)
|
||||
|
||||
// Send each pending message
|
||||
for (content, recipientNickname, messageID) in pendingMessages {
|
||||
print("📬 Sending pending message \(messageID) to \(peerID)")
|
||||
// Use async to avoid blocking the queue
|
||||
DispatchQueue.global().async { [weak self] in
|
||||
self?.sendPrivateMessage(content, to: peerID, recipientNickname: recipientNickname, messageID: messageID)
|
||||
@@ -3409,10 +3458,12 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
|
||||
private func handleNoiseHandshakeMessage(from peerID: String, message: Data, isInitiation: Bool) {
|
||||
// Use noiseService directly
|
||||
print("🤝 handleNoiseHandshakeMessage from \(peerID), isInitiation: \(isInitiation), messageSize: \(message.count)")
|
||||
|
||||
do {
|
||||
// Process handshake message
|
||||
if let response = try noiseService.processHandshakeMessage(from: peerID, message: message) {
|
||||
print("🤝 Got response from processHandshakeMessage, size: \(response.count)")
|
||||
// Always send responses as handshake response type
|
||||
let packet = BitchatPacket(
|
||||
type: MessageType.noiseHandshakeResp.rawValue,
|
||||
@@ -3426,10 +3477,13 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
|
||||
// Use broadcastPacket instead of sendPacket to ensure it goes through the mesh
|
||||
broadcastPacket(packet)
|
||||
} else {
|
||||
print("🤝 No response needed from processHandshakeMessage")
|
||||
}
|
||||
|
||||
// Check if handshake is complete
|
||||
if noiseService.hasEstablishedSession(with: peerID) {
|
||||
print("🎉 Handshake completed with peer: \(peerID)")
|
||||
// Unlock rotation now that handshake is complete
|
||||
unlockRotation()
|
||||
|
||||
@@ -3459,8 +3513,10 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
}
|
||||
} catch NoiseSessionError.alreadyEstablished {
|
||||
// Session already established, ignore handshake
|
||||
print("🤝 Handshake already established with \(peerID)")
|
||||
} catch {
|
||||
// Handshake failed
|
||||
print("❌ Handshake failed with \(peerID): \(error)")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -3489,7 +3545,9 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
|
||||
do {
|
||||
// Decrypt the message
|
||||
print("🔓 Attempting to decrypt Noise message from \(peerID), encrypted size: \(encryptedData.count)")
|
||||
let decryptedData = try noiseService.decrypt(encryptedData, from: peerID)
|
||||
print("🔓 Successfully decrypted message from \(peerID), decrypted size: \(decryptedData.count)")
|
||||
|
||||
// Check if this is a special format message (type marker + payload)
|
||||
if decryptedData.count > 1 {
|
||||
@@ -3500,8 +3558,9 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
// Extract the ACK JSON data (skip the type marker)
|
||||
let ackData = decryptedData.dropFirst()
|
||||
|
||||
// Decode the delivery ACK
|
||||
if let ack = DeliveryAck.decode(from: ackData) {
|
||||
// Decode the delivery ACK - try binary first, then JSON
|
||||
if let ack = DeliveryAck.fromBinaryData(ackData) {
|
||||
print("📨 Received binary delivery ACK via Noise: \(ack.originalMessageID) from \(ack.recipientNickname)")
|
||||
|
||||
// Process the ACK
|
||||
DeliveryTracker.shared.processDeliveryAck(ack)
|
||||
@@ -3511,22 +3570,42 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
self.delegate?.didReceiveDeliveryAck(ack)
|
||||
}
|
||||
return
|
||||
} else if let ack = DeliveryAck.decode(from: ackData) {
|
||||
print("📨 Received JSON delivery ACK via Noise: \(ack.originalMessageID) from \(ack.recipientNickname)")
|
||||
|
||||
// Process the ACK
|
||||
DeliveryTracker.shared.processDeliveryAck(ack)
|
||||
|
||||
// Notify delegate
|
||||
DispatchQueue.main.async {
|
||||
self.delegate?.didReceiveDeliveryAck(ack)
|
||||
}
|
||||
return
|
||||
} else {
|
||||
print("⚠️ Failed to decode delivery ACK via Noise - data size: \(ackData.count)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Try to parse as a full inner packet (for backward compatibility and other message types)
|
||||
if let innerPacket = BitchatPacket.from(decryptedData) {
|
||||
print("📦 Successfully parsed inner packet - type: \(MessageType(rawValue: innerPacket.type)?.description ?? "unknown"), from: \(innerPacket.senderID.hexEncodedString()), to: \(innerPacket.recipientID?.hexEncodedString() ?? "broadcast")")
|
||||
|
||||
// Process the decrypted inner packet
|
||||
// The packet will be handled according to its recipient ID
|
||||
// If it's for us, it won't be relayed
|
||||
handleReceivedPacket(innerPacket, from: peerID)
|
||||
} else {
|
||||
print("⚠️ Failed to parse inner packet from decrypted data")
|
||||
}
|
||||
} catch {
|
||||
// Failed to decrypt - might need to re-establish session
|
||||
print("❌ Failed to decrypt Noise message from \(peerID): \(error)")
|
||||
if !noiseService.hasEstablishedSession(with: peerID) {
|
||||
print("🔄 No Noise session with \(peerID), initiating handshake")
|
||||
initiateNoiseHandshake(with: peerID)
|
||||
} else {
|
||||
print("⚠️ Have session with \(peerID) but decryption failed")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -3991,7 +4070,9 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
|
||||
do {
|
||||
// Encrypt with Noise
|
||||
print("🔐 Encrypting private message \(msgID) for \(recipientPeerID)")
|
||||
let encryptedData = try noiseService.encrypt(innerData, for: recipientPeerID)
|
||||
print("🔐 Successfully encrypted message, size: \(encryptedData.count)")
|
||||
|
||||
// Send as Noise encrypted message
|
||||
let outerPacket = BitchatPacket(
|
||||
@@ -4004,9 +4085,11 @@ extension BluetoothMeshService: CBPeripheralManagerDelegate {
|
||||
ttl: adaptiveTTL
|
||||
)
|
||||
|
||||
print("📤 Broadcasting encrypted private message \(msgID) to \(recipientPeerID)")
|
||||
broadcastPacket(outerPacket)
|
||||
} catch {
|
||||
// Failed to encrypt message
|
||||
print("❌ Failed to encrypt private message \(msgID) for \(recipientPeerID): \(error)")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -71,6 +71,8 @@ class DeliveryTracker {
|
||||
// Don't track broadcasts or certain message types
|
||||
guard message.isPrivate || message.channel != nil else { return }
|
||||
|
||||
print("📮 Tracking message \(message.id) - private: \(message.isPrivate), channel: \(message.channel ?? "none"), recipient: \(recipientNickname)")
|
||||
|
||||
|
||||
let delivery = PendingDelivery(
|
||||
messageID: message.id,
|
||||
@@ -89,9 +91,21 @@ class DeliveryTracker {
|
||||
pendingDeliveries[message.id] = delivery
|
||||
pendingLock.unlock()
|
||||
|
||||
// Update status to sent
|
||||
// Update status to sent (only if not already delivered)
|
||||
DispatchQueue.main.asyncAfter(deadline: .now() + 0.1) { [weak self] in
|
||||
self?.updateDeliveryStatus(message.id, status: .sent)
|
||||
guard let self = self else { return }
|
||||
|
||||
self.pendingLock.lock()
|
||||
let stillPending = self.pendingDeliveries[message.id] != nil
|
||||
self.pendingLock.unlock()
|
||||
|
||||
// Only update to sent if still pending (not already delivered)
|
||||
if stillPending {
|
||||
print("⏱️ Updating message \(message.id) to sent status (still pending)")
|
||||
self.updateDeliveryStatus(message.id, status: .sent)
|
||||
} else {
|
||||
print("✋ Skipping sent status update for \(message.id) - already delivered")
|
||||
}
|
||||
}
|
||||
|
||||
// Schedule timeout (outside of lock)
|
||||
@@ -102,9 +116,11 @@ class DeliveryTracker {
|
||||
pendingLock.lock()
|
||||
defer { pendingLock.unlock() }
|
||||
|
||||
print("✅ Processing delivery ACK for message \(ack.originalMessageID) from \(ack.recipientNickname)")
|
||||
|
||||
// Prevent duplicate ACK processing
|
||||
guard !receivedAckIDs.contains(ack.ackID) else {
|
||||
print("⚠️ Duplicate ACK \(ack.ackID) - ignoring")
|
||||
return
|
||||
}
|
||||
receivedAckIDs.insert(ack.ackID)
|
||||
@@ -112,6 +128,7 @@ class DeliveryTracker {
|
||||
// Find the pending delivery
|
||||
guard var delivery = pendingDeliveries[ack.originalMessageID] else {
|
||||
// Message might have already been delivered or timed out
|
||||
print("⚠️ No pending delivery found for message \(ack.originalMessageID)")
|
||||
return
|
||||
}
|
||||
|
||||
@@ -136,6 +153,7 @@ class DeliveryTracker {
|
||||
}
|
||||
} else {
|
||||
// Direct message - mark as delivered
|
||||
print("💬 Marking private message \(ack.originalMessageID) as delivered to \(ack.recipientNickname)")
|
||||
updateDeliveryStatus(ack.originalMessageID, status: .delivered(to: ack.recipientNickname, at: Date()))
|
||||
pendingDeliveries.removeValue(forKey: ack.originalMessageID)
|
||||
}
|
||||
@@ -180,6 +198,7 @@ class DeliveryTracker {
|
||||
// MARK: - Private Methods
|
||||
|
||||
private func updateDeliveryStatus(_ messageID: String, status: DeliveryStatus) {
|
||||
print("📊 Updating delivery status for message \(messageID): \(status)")
|
||||
DispatchQueue.main.async { [weak self] in
|
||||
self?.deliveryStatusUpdated.send((messageID: messageID, status: status))
|
||||
}
|
||||
|
||||
@@ -207,6 +207,11 @@ class NoiseEncryptionService {
|
||||
return sessionManager.getSession(for: peerID)?.isEstablished() ?? false
|
||||
}
|
||||
|
||||
/// Check if we have a session (established or handshaking) with a peer
|
||||
func hasSession(with peerID: String) -> Bool {
|
||||
return sessionManager.getSession(for: peerID) != nil
|
||||
}
|
||||
|
||||
// MARK: - Encryption/Decryption
|
||||
|
||||
/// Encrypt data for a specific peer
|
||||
@@ -471,11 +476,14 @@ struct NoiseMessage: Codable {
|
||||
}
|
||||
|
||||
static func fromBinaryData(_ data: Data) -> NoiseMessage? {
|
||||
// Create defensive copy
|
||||
let dataCopy = Data(data)
|
||||
|
||||
var offset = 0
|
||||
|
||||
guard let type = data.readUInt8(at: &offset),
|
||||
let sessionID = data.readUUID(at: &offset),
|
||||
let payload = data.readData(at: &offset) else { return nil }
|
||||
guard let type = dataCopy.readUInt8(at: &offset),
|
||||
let sessionID = dataCopy.readUUID(at: &offset),
|
||||
let payload = dataCopy.readData(at: &offset) else { return nil }
|
||||
|
||||
guard let messageType = NoiseMessageType(rawValue: type) else { return nil }
|
||||
|
||||
|
||||
@@ -3654,6 +3654,7 @@ extension ChatViewModel: BitchatDelegate {
|
||||
}
|
||||
|
||||
private func updateMessageDeliveryStatus(_ messageID: String, status: DeliveryStatus) {
|
||||
print("🔄 Updating UI delivery status for message \(messageID): \(status)")
|
||||
|
||||
// Helper function to check if we should skip this update
|
||||
func shouldSkipUpdate(currentStatus: DeliveryStatus?, newStatus: DeliveryStatus) -> Bool {
|
||||
|
||||
Reference in New Issue
Block a user