Merge 99cf848f82 into 0952007805

src/mesh/Channels.cpp

@@ -423,6 +423,32 @@ bool Channels::decryptForHash(ChannelIndex chIndex, ChannelHash channelHash)
     }
 }
 
+bool Channels::setDefaultPresetCryptoForHash(ChannelHash channelHash)
+{
+    // Iterate all known presets
+    for (int preset = _meshtastic_Config_LoRaConfig_ModemPreset_MIN; preset <= _meshtastic_Config_LoRaConfig_ModemPreset_MAX;
+         ++preset) {
+        const char *name = DisplayFormatters::getModemPresetDisplayName((meshtastic_Config_LoRaConfig_ModemPreset)preset, false);
+        if (!name)
+            continue;
+        if (strcmp(name, "Invalid") == 0)
+            continue; // skip invalid placeholder
+        uint8_t h = xorHash((const uint8_t *)name, strlen(name));
+        // Expand default PSK alias 1 to actual bytes and xor into hash
+        uint8_t tmp = h ^ xorHash(defaultpsk, sizeof(defaultpsk));
+        if (tmp == channelHash) {
+            // Set crypto to defaultpsk and report success
+            CryptoKey k;
+            memcpy(k.bytes, defaultpsk, sizeof(defaultpsk));
+            k.length = sizeof(defaultpsk);
+            crypto->setKey(k);
+            LOG_INFO("Matched default preset '%s' for hash 0x%x; set default PSK", name, channelHash);
+            return true;
+        }
+    }
+    return false;
+}
+
 /** Given a channel index setup crypto for encoding that channel (or the primary channel if that channel is unsecured)
  *
  * This method is called before encoding outbound packets

src/mesh/Channels.h

@@ -94,6 +94,8 @@ class Channels
 
     bool ensureLicensedOperation();
 
+    bool setDefaultPresetCryptoForHash(ChannelHash channelHash);
+
   private:
     /** Given a channel index, change to use the crypto key specified by that index
      *

src/mesh/Router.cpp

@@ -416,6 +416,36 @@ DecodeState perhapsDecode(meshtastic_MeshPacket *p)
             }
         }
     }
+
+#if HAS_UDP_MULTICAST
+    // Fallback: for UDP multicast, try default preset names with default PSK if normal channel match failed
+    if (!decrypted && p->transport_mechanism == meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP) {
+        if (channels.setDefaultPresetCryptoForHash(p->channel)) {
+            memcpy(bytes, p->encrypted.bytes, rawSize);
+            crypto->decrypt(p->from, p->id, rawSize, bytes);
+
+            meshtastic_Data decodedtmp;
+            memset(&decodedtmp, 0, sizeof(decodedtmp));
+            if (pb_decode_from_bytes(bytes, rawSize, &meshtastic_Data_msg, &decodedtmp) &&
+                decodedtmp.portnum != meshtastic_PortNum_UNKNOWN_APP) {
+                p->decoded = decodedtmp;
+                p->which_payload_variant = meshtastic_MeshPacket_decoded_tag;
+                // Map to our local default channel index (name+PSK default), not necessarily primary
+                ChannelIndex defaultIndex = channels.getPrimaryIndex();
+                for (ChannelIndex i = 0; i < channels.getNumChannels(); ++i) {
+                    if (channels.isDefaultChannel(i)) {
+                        defaultIndex = i;
+                        break;
+                    }
+                }
+                chIndex = defaultIndex;
+                decrypted = true;
+            } else {
+                LOG_WARN("UDP fallback decode attempted but failed for hash 0x%x", p->channel);
+            }
+        }
+    }
+#endif
     if (decrypted) {
         // parsing was successful
         p->channel = chIndex; // change to store the index instead of the hash

src/mesh/udp/UdpMulticastHandler.h

@@ -50,10 +50,10 @@ class UdpMulticastHandler final
         LOG_DEBUG("UDP broadcast from: %s, len=%u", packet.remoteIP().toString().c_str(), packetLength);
 #endif
         meshtastic_MeshPacket mp;
-        mp.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP;
         LOG_DEBUG("Decoding MeshPacket from UDP len=%u", packetLength);
         bool isPacketDecoded = pb_decode_from_bytes(packet.data(), packetLength, &meshtastic_MeshPacket_msg, &mp);
         if (isPacketDecoded && router && mp.which_payload_variant == meshtastic_MeshPacket_encrypted_tag) {
+            mp.transport_mechanism = meshtastic_MeshPacket_TransportMechanism_TRANSPORT_MULTICAST_UDP;
             mp.pki_encrypted = false;
             mp.public_key.size = 0;
             memset(mp.public_key.bytes, 0, sizeof(mp.public_key.bytes));

variants/esp32s3/t-deck-pro/variant.h

@@ -100,4 +100,3 @@
 #define MODEM_DTR 8
 #define MODEM_RX 10
 #define MODEM_TX 11
-