switch to ascon + refactor

Author: liquidraver

examples/companion_radio/DataStore.cpp

@@ -276,9 +276,9 @@ File file = openRead(_getContactsChannelsFS(), "/contacts3");
         ContactInfo c;
         memset(&c, 0, sizeof(c));  // Zero-initialize to prevent garbage in new fields
         c.shared_secret_valid = false;
-        c.supports_chacha = false;
+        c.supports_ascon = false;
         uint8_t pub_key[32];
-        uint8_t crypto_flags;  // was 'unused'; bit 0 = supports_chacha
+        uint8_t crypto_flags;  // was 'unused'; bit 0 = supports_ascon
 
         bool success = (file.read(pub_key, 32) == 32);
         success = success && (file.read((uint8_t *)&c.name, 32) == 32);
@@ -295,7 +295,7 @@ File file = openRead(_getContactsChannelsFS(), "/contacts3");
 
         if (!success) break; // EOF
 
-        c.supports_chacha = (crypto_flags & 0x01) != 0;  // bit 0; old files have 0 here (backwards compatible)
+        c.supports_ascon = (crypto_flags & 0x01) != 0;  // bit 0; old files have 0 here (backwards compatible)
         c.id = mesh::Identity(pub_key);
         if (!host->onContactLoaded(c)) full = true;
       }
@@ -310,7 +310,7 @@ void DataStore::saveContacts(DataStoreHost* host) {
     ContactInfo c;
 
     while (host->getContactForSave(idx, c)) {
-      uint8_t crypto_flags = c.supports_chacha ? 0x01 : 0x00;  // bit 0 = supports_chacha
+      uint8_t crypto_flags = c.supports_ascon ? 0x01 : 0x00;  // bit 0 = supports_ascon
       bool success = (file.write(c.id.pub_key, 32) == 32);
       success = success && (file.write((uint8_t *)&c.name, 32) == 32);
       success = success && (file.write(&c.type, 1) == 1);

examples/simple_repeater/MyMesh.cpp

@@ -506,7 +506,7 @@ bool MyMesh::filterRecvFloodPacket(mesh::Packet* pkt) {
 }
 
 void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const mesh::Identity &sender,
-                            uint8_t *data, size_t len, bool decrypted_with_chacha) {
+                            uint8_t *data, size_t len, bool was_ascon) {
   if (packet->getPayloadType() == PAYLOAD_TYPE_ANON_REQ) { // received an initial request by a possible admin
                                                            // client (unknown at this stage)
     uint32_t timestamp;
@@ -530,20 +530,17 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
 
     if (reply_len == 0) return;   // invalid request
 
-    // Mark peer as ChaCha-capable if we decoded their packet with ChaCha
-    if (decrypted_with_chacha) setPeerSupportsCHACHA(&sender, -1);
-
-    bool use_chacha = peerSupportsCHACHA(sender);
+    // Reply with same encryption the sender used
     if (packet->isRouteFlood()) {
       // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
       mesh::Packet* path = createPathReturn(sender, secret, packet->path, packet->path_len,
-                                            PAYLOAD_TYPE_RESPONSE, reply_data, reply_len, use_chacha);
+                                            PAYLOAD_TYPE_RESPONSE, reply_data, reply_len, was_ascon);
       if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
     } else if (reply_path_len < 0) {
-      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len, use_chacha);
+      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len, was_ascon);
       if (reply) sendFlood(reply, SERVER_RESPONSE_DELAY);
     } else {
-      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len, use_chacha);
+      mesh::Packet* reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, secret, reply_data, reply_len, was_ascon);
       if (reply) sendDirect(reply, reply_path, reply_path_len, SERVER_RESPONSE_DELAY);
     }
   }
@@ -569,35 +566,13 @@ void MyMesh::getPeerSharedSecret(uint8_t *dest_secret, int peer_idx) {
   }
 }
 
-bool MyMesh::peerSupportsCHACHA(const mesh::Identity& dest) {
-  // Look up client by public key
-  ClientInfo* client = acl.getClient(dest.pub_key, PUB_KEY_SIZE);
-  if (client) {
-    return client->supports_chacha;
-  }
-  // Unknown peer - default to AES (safe fallback)
-  return false;
-}
-
-bool MyMesh::peerSupportsCHACHA(uint8_t src_hash, int peer_idx) {
-  // Use the peer index from searchPeersByHash() - no re-lookup needed
+void MyMesh::onPeerAsconCapabilityDetected(int peer_idx, bool supports_ascon) {
   int i = matching_peer_indexes[peer_idx];
   if (i >= 0 && i < acl.getNumClients()) {
-    return acl.getClientByIdx(i)->supports_chacha;
-  }
-  return false;
-}
-
-void MyMesh::setPeerSupportsCHACHA(const mesh::Identity* id, int peer_idx) {
-  if (peer_idx >= 0) {
-    int i = matching_peer_indexes[peer_idx];
-    if (i >= 0 && i < acl.getNumClients()) {
-      acl.getClientByIdx(i)->supports_chacha = true;
-    }
-  } else if (id != nullptr) {
-    ClientInfo* client = acl.getClient(id->pub_key, PUB_KEY_SIZE);
-    if (client) {
-      client->supports_chacha = true;
+    auto client = acl.getClientByIdx(i);
+    if (supports_ascon && !client->supports_ascon) {
+      client->supports_ascon = true;
+      MESH_DEBUG_PRINTLN("Auto-detected Ascon capability for client %d", i);
     }
   }
 }
@@ -615,10 +590,10 @@ void MyMesh::onAdvertRecv(mesh::Packet *packet, const mesh::Identity &id, uint32
 
   AdvertDataParser parser(app_data, app_data_len);
   if (parser.isValid()) {
-    // Update CHACHA capability for known clients (chat nodes that are in our ACL)
+    // Update Ascon encryption capability for known clients (chat nodes that are in our ACL)
     ClientInfo* client = acl.getClient(id.pub_key, PUB_KEY_SIZE);
     if (client) {
-      client->supports_chacha = (parser.getFeat1() & ADV_FEAT1_CHACHA_CAPABLE) != 0;
+      client->supports_ascon = (parser.getFeat1() & ADV_FEAT1_ASCON_CAPABLE) != 0;
     }
 
     // if this a zero hop advert (and not via 'Share'), add it to neighbours
@@ -650,15 +625,14 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
       client->last_timestamp = timestamp;
       client->last_activity = getRTCClock()->getCurrentTime();
 
-      bool use_chacha = client->supports_chacha;
       if (packet->isRouteFlood()) {
         // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
         mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len,
-                                              PAYLOAD_TYPE_RESPONSE, reply_data, reply_len, use_chacha);
+                                              PAYLOAD_TYPE_RESPONSE, reply_data, reply_len, client->supports_ascon);
         if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
       } else {
         mesh::Packet *reply =
-            createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len, use_chacha);
+            createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len, client->supports_ascon);
         if (reply) {
           if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
             sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
@@ -719,8 +693,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
         memcpy(temp, &timestamp, 4);        // mostly an extra blob to help make packet_hash unique
         temp[4] = (TXT_TYPE_CLI_DATA << 2); // NOTE: legacy was: TXT_TYPE_PLAIN
 
-        bool use_chacha = client->supports_chacha;
-        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len, use_chacha);
+        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len, client->supports_ascon);
         if (reply) {
           if (client->out_path_len < 0) {
             sendFlood(reply, CLI_REPLY_DELAY_MILLIS);

examples/simple_repeater/MyMesh.h

@@ -160,12 +160,10 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
 
   bool filterRecvFloodPacket(mesh::Packet* pkt) override;
 
-  void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len, bool decrypted_with_chacha = false) override;
+  void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len, bool was_ascon) override;
   int searchPeersByHash(const uint8_t* hash) override;
   void getPeerSharedSecret(uint8_t* dest_secret, int peer_idx) override;
-  bool peerSupportsCHACHA(const mesh::Identity& dest) override;
-  bool peerSupportsCHACHA(uint8_t src_hash, int peer_idx) override;
-  void setPeerSupportsCHACHA(const mesh::Identity* id, int peer_idx) override;
+  void onPeerAsconCapabilityDetected(int peer_idx, bool supports_ascon) override;
   void onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id, uint32_t timestamp, const uint8_t* app_data, size_t app_data_len) override;
   void onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_idx, const uint8_t* secret, uint8_t* data, size_t len) override;
   bool onPeerPathRecv(mesh::Packet* packet, int sender_idx, const uint8_t* secret, uint8_t* path, uint8_t path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) override;

examples/simple_room_server/MyMesh.cpp

@@ -71,8 +71,7 @@ void MyMesh::pushPostToClient(ClientInfo *client, PostInfo &post) {
   mesh::Utils::sha256((uint8_t *)&client->extra.room.pending_ack, 4, reply_data, len, client->id.pub_key, PUB_KEY_SIZE);
   client->extra.room.push_post_timestamp = post.post_timestamp;
 
-  bool use_chacha = client->supports_chacha;
-  auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, client->shared_secret, reply_data, len, use_chacha);
+  auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, client->shared_secret, reply_data, len, client->supports_ascon);
   if (reply) {
     if (client->out_path_len < 0) {
       sendFlood(reply);
@@ -280,7 +279,7 @@ bool MyMesh::allowPacketForward(const mesh::Packet *packet) {
 }
 
 void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const mesh::Identity &sender,
-                            uint8_t *data, size_t len, bool decrypted_with_chacha) {
+                            uint8_t *data, size_t len, bool was_ascon) {
   if (packet->getPayloadType() == PAYLOAD_TYPE_ANON_REQ) { // received an initial request by a possible admin
                                                            // client (unknown at this stage)
     uint32_t sender_timestamp, sender_sync_since;
@@ -350,17 +349,13 @@ void MyMesh::onAnonDataRecv(mesh::Packet *packet, const uint8_t *secret, const m
 
     next_push = futureMillis(PUSH_NOTIFY_DELAY_MILLIS); // delay next push, give RESPONSE packet time to arrive first
 
-    // Mark peer as ChaCha-capable if we decoded their packet with ChaCha
-    if (decrypted_with_chacha) client->supports_chacha = true;
-
-    bool use_chacha = client->supports_chacha;
     if (packet->isRouteFlood()) {
       // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
       mesh::Packet *path = createPathReturn(sender, client->shared_secret, packet->path, packet->path_len,
-                                            PAYLOAD_TYPE_RESPONSE, reply_data, 13, use_chacha);
+                                            PAYLOAD_TYPE_RESPONSE, reply_data, 13, client->supports_ascon);
       if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
     } else {
-      mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->shared_secret, reply_data, 13, use_chacha);
+      mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, sender, client->shared_secret, reply_data, 13, client->supports_ascon);
       if (reply) {
         if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
           sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);
@@ -392,35 +387,13 @@ void MyMesh::getPeerSharedSecret(uint8_t *dest_secret, int peer_idx) {
   }
 }
 
-bool MyMesh::peerSupportsCHACHA(const mesh::Identity& dest) {
-  // Look up client by public key
-  ClientInfo* client = acl.getClient(dest.pub_key, PUB_KEY_SIZE);
-  if (client) {
-    return client->supports_chacha;
-  }
-  // Unknown peer - default to AES (safe fallback)
-  return false;
-}
-
-bool MyMesh::peerSupportsCHACHA(uint8_t src_hash, int peer_idx) {
-  // Use the peer index from searchPeersByHash() - no re-lookup needed
+void MyMesh::onPeerAsconCapabilityDetected(int peer_idx, bool supports_ascon) {
   int i = matching_peer_indexes[peer_idx];
   if (i >= 0 && i < acl.getNumClients()) {
-    return acl.getClientByIdx(i)->supports_chacha;
-  }
-  return false;
-}
-
-void MyMesh::setPeerSupportsCHACHA(const mesh::Identity* id, int peer_idx) {
-  if (peer_idx >= 0) {
-    int i = matching_peer_indexes[peer_idx];
-    if (i >= 0 && i < acl.getNumClients()) {
-      acl.getClientByIdx(i)->supports_chacha = true;
-    }
-  } else if (id != nullptr) {
-    ClientInfo* client = acl.getClient(id->pub_key, PUB_KEY_SIZE);
-    if (client) {
-      client->supports_chacha = true;
+    auto client = acl.getClientByIdx(i);
+    if (supports_ascon && !client->supports_ascon) {
+      client->supports_ascon = true;
+      MESH_DEBUG_PRINTLN("Auto-detected Ascon capability for client %d", i);
     }
   }
 }
@@ -429,12 +402,12 @@ void MyMesh::onAdvertRecv(mesh::Packet *packet, const mesh::Identity &id, uint32
                           const uint8_t *app_data, size_t app_data_len) {
   mesh::Mesh::onAdvertRecv(packet, id, timestamp, app_data, app_data_len); // chain to super impl
 
-  // Update CHACHA capability for known clients
+  // Update Ascon encryption capability for known clients
   AdvertDataParser parser(app_data, app_data_len);
   if (parser.isValid()) {
     ClientInfo* client = acl.getClient(id.pub_key, PUB_KEY_SIZE);
     if (client) {
-      client->supports_chacha = (parser.getFeat1() & ADV_FEAT1_CHACHA_CAPABLE) != 0;
+      client->supports_ascon = (parser.getFeat1() & ADV_FEAT1_ASCON_CAPABLE) != 0;
     }
   }
 }
@@ -532,8 +505,7 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
         // mesh::Utils::sha256((uint8_t *)&expected_ack_crc, 4, temp, 5 + text_len, self_id.pub_key,
         // PUB_KEY_SIZE);
 
-        bool use_chacha = client->supports_chacha;
-        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len, use_chacha);
+        auto reply = createDatagram(PAYLOAD_TYPE_TXT_MSG, client->id, secret, temp, 5 + text_len, client->supports_ascon);
         if (reply) {
           if (client->out_path_len < 0) {
             sendFlood(reply, delay_millis + SERVER_RESPONSE_DELAY);
@@ -587,14 +559,13 @@ void MyMesh::onPeerDataRecv(mesh::Packet *packet, uint8_t type, int sender_idx,
       } else {
         int reply_len = handleRequest(client, sender_timestamp, &data[4], len - 4);
         if (reply_len > 0) { // valid command
-          bool use_chacha = client->supports_chacha;
           if (packet->isRouteFlood()) {
             // let this sender know path TO here, so they can use sendDirect(), and ALSO encode the response
             mesh::Packet *path = createPathReturn(client->id, secret, packet->path, packet->path_len,
-                                                  PAYLOAD_TYPE_RESPONSE, reply_data, reply_len, use_chacha);
+                                                  PAYLOAD_TYPE_RESPONSE, reply_data, reply_len, client->supports_ascon);
             if (path) sendFlood(path, SERVER_RESPONSE_DELAY);
           } else {
-            mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len, use_chacha);
+            mesh::Packet *reply = createDatagram(PAYLOAD_TYPE_RESPONSE, client->id, secret, reply_data, reply_len, client->supports_ascon);
             if (reply) {
               if (client->out_path_len >= 0) { // we have an out_path, so send DIRECT
                 sendDirect(reply, client->out_path, client->out_path_len, SERVER_RESPONSE_DELAY);

examples/simple_room_server/MyMesh.h

@@ -145,12 +145,10 @@ class MyMesh : public mesh::Mesh, public CommonCLICallbacks {
   }
 
   bool allowPacketForward(const mesh::Packet* packet) override;
-  void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len, bool decrypted_with_chacha = false) override;
+  void onAnonDataRecv(mesh::Packet* packet, const uint8_t* secret, const mesh::Identity& sender, uint8_t* data, size_t len, bool was_ascon) override;
   int searchPeersByHash(const uint8_t* hash) override ;
   void getPeerSharedSecret(uint8_t* dest_secret, int peer_idx) override;
-  bool peerSupportsCHACHA(const mesh::Identity& dest) override;
-  bool peerSupportsCHACHA(uint8_t src_hash, int peer_idx) override;
-  void setPeerSupportsCHACHA(const mesh::Identity* id, int peer_idx) override;
+  void onPeerAsconCapabilityDetected(int peer_idx, bool supports_ascon) override;
   void onAdvertRecv(mesh::Packet* packet, const mesh::Identity& id, uint32_t timestamp, const uint8_t* app_data, size_t app_data_len) override;
   void onPeerDataRecv(mesh::Packet* packet, uint8_t type, int sender_idx, const uint8_t* secret, uint8_t* data, size_t len) override;
   bool onPeerPathRecv(mesh::Packet* packet, int sender_idx, const uint8_t* secret, uint8_t* path, uint8_t path_len, uint8_t extra_type, uint8_t* extra, uint8_t extra_len) override;

examples/simple_secure_chat/main.cpp

@@ -408,7 +408,9 @@ class MyMesh : public BaseChatMesh, ContactVisitor {
       temp[5 + MAX_TEXT_LEN] = 0;  // truncate if too long
 
       int len = strlen((char *) &temp[5]);
-      auto pkt = createGroupDatagram(PAYLOAD_TYPE_GRP_TXT, _public->channel, temp, 5 + len);
+      // Use Ascon if channel has the flag set, otherwise use legacy for backwards compatibility
+      bool use_ascon = (_public->channel.flags & CHANNEL_FLAG_ASCON) != 0;
+      auto pkt = createGroupDatagram(PAYLOAD_TYPE_GRP_TXT, _public->channel, temp, 5 + len, use_ascon);
       if (pkt) {
         sendFlood(pkt);
         Serial.println("   Sent.");