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

wip fixes for noise

Browse Source
This commit is contained in:
callebtc
2025-07-17 13:21:53 +02:00
parent 03ac7ba09b
commit 176ceab044
2 changed files with 193 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/src/main/java/com/bitchat/android/noise/NoiseSession.kt
+90 -14
View File
@@ -24,6 +24,14 @@ class NoiseSession(
// Rekey thresholds (same as iOS)
private const val REKEY_TIME_LIMIT = 3600000L // 1 hour
private const val REKEY_MESSAGE_LIMIT = 10000L // 10k messages
// XX Pattern Message Sizes (exactly matching iOS implementation)
private const val XX_MESSAGE_1_SIZE = 32 // -> e (ephemeral key only)
private const val XX_MESSAGE_2_SIZE = 80 // <- e, ee, s, es (32 + 48)
private const val XX_MESSAGE_3_SIZE = 48 // -> s, se (encrypted static key)
// Maximum payload size for safety
private const val MAX_PAYLOAD_SIZE = 256
}
// Real Noise Protocol objects
@@ -39,6 +47,9 @@ class NoiseSession(
private var messagesSent = 0L
private var messagesReceived = 0L
// Handshake message counter to track XX pattern steps
private var handshakeMessageCount = 0
// Remote peer information
private var remoteStaticPublicKey: ByteArray? = null
private var handshakeHash: ByteArray? = null
@@ -79,19 +90,22 @@ class NoiseSession(
/**
* Initialize the real Noise handshake state using noise-java
* Fixed to match iOS static key handling exactly
*/
private fun initializeNoiseHandshake() {
val role = if (isInitiator) HandshakeState.INITIATOR else HandshakeState.RESPONDER
handshakeState = HandshakeState(PROTOCOL_NAME, role)
// Set up local static key pair properly
if (handshakeState?.needsLocalKeyPair() == true) {
val localKeyPair = handshakeState?.getLocalKeyPair()
if (localKeyPair != null) {
// Set the static private key we loaded/generated
localKeyPair.setPrivateKey(localStaticPrivateKey, 0)
Log.d(TAG, "Set local static key for handshake state")
}
// CRITICAL FIX: Proper static key setup to match iOS implementation
// The static key needs to be set BEFORE starting the handshake
val localKeyPair = handshakeState?.getLocalKeyPair()
if (localKeyPair != null) {
// Set both private and public keys properly
localKeyPair.setPrivateKey(localStaticPrivateKey, 0)
localKeyPair.setPublicKey(localStaticPublicKey, 0)
Log.d(TAG, "Set local static key pair for handshake state")
} else {
Log.w(TAG, "Warning: Could not get local key pair from handshake state")
}
// Start the handshake
@@ -104,7 +118,7 @@ class NoiseSession(
/**
* Start handshake (initiator only) using real Noise Protocol
* Returns the first handshake message for XX pattern
* Returns the first handshake message for XX pattern (32 bytes exactly)
*/
@Synchronized
fun startHandshake(): ByteArray {
@@ -120,12 +134,19 @@ class NoiseSession(
try {
state = NoiseSessionState.Handshaking
handshakeMessageCount = 1
val messageBuffer = ByteArray(512) // Increased buffer size for XX pattern
// CRITICAL FIX: Use exact buffer size for XX message 1 (32 bytes)
val messageBuffer = ByteArray(XX_MESSAGE_1_SIZE + MAX_PAYLOAD_SIZE) // Extra space for safety
val handshakeStateLocal = handshakeState ?: throw IllegalStateException("Handshake state is null")
val messageLength = handshakeStateLocal.writeMessage(ByteArray(0), 0, messageBuffer, 0, 0)
val firstMessage = messageBuffer.copyOf(messageLength)
// Validate message size matches XX pattern expectations
if (firstMessage.size != XX_MESSAGE_1_SIZE) {
Log.w(TAG, "Warning: XX message 1 size ${firstMessage.size} != expected $XX_MESSAGE_1_SIZE")
}
Log.d(TAG, "Sent real XX handshake message 1 to $peerID (${firstMessage.size} bytes)")
return firstMessage
} catch (e: Exception) {
@@ -138,6 +159,7 @@ class NoiseSession(
/**
* Process incoming handshake message using real Noise Protocol
* Returns response message if needed, null if handshake complete
* FIXED: Proper message size validation and buffer handling
*/
@Synchronized
fun processHandshakeMessage(message: ByteArray): ByteArray? {
@@ -147,6 +169,7 @@ class NoiseSession(
// Initialize as responder if receiving first message
if (state == NoiseSessionState.Uninitialized && !isInitiator) {
state = NoiseSessionState.Handshaking
handshakeMessageCount = 1
Log.d(TAG, "Initialized as responder for real XX handshake with $peerID")
}
@@ -154,7 +177,10 @@ class NoiseSession(
throw IllegalStateException("Invalid state for handshake: $state")
}
val payloadBuffer = ByteArray(256) // Buffer for any payload data
// CRITICAL FIX: Validate message size based on XX pattern step
validateHandshakeMessageSize(message, handshakeMessageCount, isInitiator)
val payloadBuffer = ByteArray(MAX_PAYLOAD_SIZE) // Buffer for any payload data
val handshakeStateLocal = handshakeState ?: throw IllegalStateException("Handshake state is null")
// Read the incoming message
@@ -168,11 +194,19 @@ class NoiseSession(
return when (action) {
HandshakeState.WRITE_MESSAGE -> {
// Need to send a response
val responseBuffer = ByteArray(512) // Increased buffer size for XX pattern message 2
handshakeMessageCount++
val expectedSize = getExpectedResponseSize(handshakeMessageCount, isInitiator)
val responseBuffer = ByteArray(expectedSize + MAX_PAYLOAD_SIZE) // Use proper size
val responseLength = handshakeStateLocal.writeMessage(ByteArray(0), 0, responseBuffer, 0, 0)
responseBuffer.copyOf(responseLength).also {
Log.d(TAG, "Generated handshake response: ${it.size} bytes")
val response = responseBuffer.copyOf(responseLength)
// Validate response size
if (response.size != expectedSize) {
Log.w(TAG, "Warning: XX response size ${response.size} != expected $expectedSize")
}
Log.d(TAG, "Generated handshake response: ${response.size} bytes")
response
}
HandshakeState.SPLIT -> {
@@ -199,6 +233,47 @@ class NoiseSession(
}
}
/**
* Validate handshake message size based on XX pattern and step
*/
private fun validateHandshakeMessageSize(message: ByteArray, step: Int, isInitiator: Boolean) {
val expectedSize = when {
// Receiving as responder from initiator
step == 1 && !isInitiator -> XX_MESSAGE_1_SIZE // Message 1: -> e
// Receiving as initiator from responder
step == 2 && isInitiator -> XX_MESSAGE_2_SIZE // Message 2: <- e, ee, s, es
// Receiving as responder from initiator
step == 3 && !isInitiator -> XX_MESSAGE_3_SIZE // Message 3: -> s, se
else -> {
Log.w(TAG, "Unknown handshake step $step for ${if (isInitiator) "initiator" else "responder"}")
return // Don't validate unknown steps
}
}
if (message.size != expectedSize) {
Log.w(TAG, "Handshake message size mismatch: got ${message.size}, expected $expectedSize for step $step")
// Don't throw here, let the underlying Noise implementation handle it
} else {
Log.d(TAG, "Handshake message size validated: ${message.size} bytes for step $step")
}
}
/**
* Get expected response size based on XX pattern and step
*/
private fun getExpectedResponseSize(step: Int, isInitiator: Boolean): Int {
return when {
// Responding as responder to message 1
step == 2 && !isInitiator -> XX_MESSAGE_2_SIZE // Response: <- e, ee, s, es
// Responding as initiator to message 2
step == 3 && isInitiator -> XX_MESSAGE_3_SIZE // Response: -> s, se
else -> {
Log.w(TAG, "Unknown response step $step for ${if (isInitiator) "initiator" else "responder"}")
200 // Default fallback
}
}
}
/**
* Complete handshake and derive real transport keys
*/
@@ -357,6 +432,7 @@ class NoiseSession(
state = NoiseSessionState.Uninitialized
messagesSent = 0
messagesReceived = 0
handshakeMessageCount = 0
remoteStaticPublicKey = null
handshakeHash = null
} catch (e: Exception) {
app/src/main/java/com/bitchat/android/noise/NoiseSessionManager.kt
+103 -7
View File
@@ -146,9 +146,17 @@ class NoiseSessionManager(
/**
* Handle incoming handshake message
* Supports both initiating and responding to handshakes
* FIXED: Added comprehensive message validation
*/
fun handleIncomingHandshake(peerID: String, message: ByteArray): ByteArray? {
return sessionLock.write {
// CRITICAL FIX: Validate handshake message before processing
if (!validateHandshakeMessage(message, peerID)) {
Log.w(TAG, "Invalid handshake message from $peerID, ignoring")
return@write null
}
var shouldCreateNew = false
var existingSession: NoiseSession? = null
@@ -236,6 +244,53 @@ class NoiseSessionManager(
}
}
/**
* Validate handshake message format and size
* ADDED: Comprehensive validation for XX pattern messages
*/
private fun validateHandshakeMessage(message: ByteArray, peerID: String): Boolean {
// Basic size validation
if (message.isEmpty()) {
Log.w(TAG, "Empty handshake message from $peerID")
return false
}
// Check for reasonable size limits
if (message.size > 200) {
Log.w(TAG, "Handshake message too large from $peerID: ${message.size} bytes")
return false
}
// Validate against known XX pattern message sizes
when (message.size) {
32 -> {
// First message: -> e
Log.d(TAG, "Received XX pattern message 1 from $peerID (32 bytes)")
return true
}
80 -> {
// Second message: <- e, ee, s, es
Log.d(TAG, "Received XX pattern message 2 from $peerID (80 bytes)")
return true
}
48 -> {
// Third message: -> s, se
Log.d(TAG, "Received XX pattern message 3 from $peerID (48 bytes)")
return true
}
else -> {
// Allow some flexibility for payload or different implementations
if (message.size >= 32 && message.size <= 100) {
Log.d(TAG, "Received handshake message from $peerID with size ${message.size} (non-standard but acceptable)")
return true
} else {
Log.w(TAG, "Invalid handshake message size from $peerID: ${message.size} bytes")
return false
}
}
}
}
// MARK: - Encryption/Decryption
/**
@@ -353,22 +408,63 @@ class NoiseSessionManager(
/**
* Tie-breaker mechanism to prevent handshake storms
* Same logic as iOS implementation
* FIXED: Exactly matching iOS implementation logic
*/
private fun resolveTieBreaker(peerID: String): Boolean {
// Convert peer IDs to comparable format and compare
// The peer with lexicographically smaller ID should initiate
val myIDString = localStaticPublicKey.joinToString("") { "%02x".format(it) }
val peerIDString = peerID.padEnd(myIDString.length, '0')
// Convert our static public key and peer ID to comparable hex strings
val myPublicKeyHex = localStaticPublicKey.joinToString("") { "%02x".format(it) }
return myIDString < peerIDString
// For peer ID comparison, we need to ensure consistent format
// iOS likely uses a consistent peer ID format (hex string)
val normalizedPeerID = if (peerID.length == 64) {
// Already a hex string, use as-is
peerID.lowercase()
} else {
// Convert to consistent format - pad or hash if needed
if (peerID.length < 64) {
peerID.padEnd(64, '0').lowercase()
} else {
// Hash if too long to get consistent 64-char representation
val digest = java.security.MessageDigest.getInstance("SHA-256")
val hash = digest.digest(peerID.toByteArray())
hash.joinToString("") { "%02x".format(it) }
}
}
// The peer with lexicographically smaller static public key should initiate
// This ensures consistent behavior across iOS and Android
val shouldInitiate = myPublicKeyHex < normalizedPeerID
Log.d(TAG, "Tie-breaker: myKey=${myPublicKeyHex.take(16)}..., peerID=${normalizedPeerID.take(16)}..., shouldInitiate=$shouldInitiate")
return shouldInitiate
}
/**
* Check if message is the first handshake message (32 bytes for XX pattern)
* FIXED: More robust detection for XX pattern message 1
*/
private fun isFirstHandshakeMessage(message: ByteArray): Boolean {
return message.size == 32 // First message in XX pattern is just the ephemeral key
// XX pattern message 1 is exactly 32 bytes (ephemeral key only)
// This is the most reliable way to detect the first message
if (message.size != 32) {
return false
}
// Additional validation: check that it's not all zeros (invalid ephemeral key)
if (message.all { it == 0.toByte() }) {
Log.w(TAG, "Detected all-zero message, not a valid first handshake message")
return false
}
// Additional validation: check it's not all 0xFF (also invalid)
if (message.all { it == 0xFF.toByte() }) {
Log.w(TAG, "Detected all-0xFF message, not a valid first handshake message")
return false
}
Log.d(TAG, "Detected valid first handshake message (32 bytes)")
return true
}
/**