meshcore 2.2.20__tar.gz → 2.2.22__tar.gz

{meshcore-2.2.20 → meshcore-2.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.2.20
+Version: 2.2.22
 Summary: Base classes for communicating with meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore_py
 Project-URL: Issues, https://github.com/fdlamotte/meshcore_py/issues

{meshcore-2.2.20 → meshcore-2.2.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore"
-version = "2.2.20"
+version = "2.2.22"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
   { name="Alex Wolden", email="awolden@gmail.com" },

{meshcore-2.2.20 → meshcore-2.2.22}/src/meshcore/reader.py

@@ -29,7 +29,7 @@ class MessageReader:
         # Track pending binary requests by tag for proper response parsing
         self.pending_binary_requests: Dict[str, Dict[str, Any]] = {}  # tag -> {request_type, expires_at}
 
-        self.channels = [{} for _ in range(20)] # keep our own copy of channels, 20 elements by default
+        self.channels = [{} for _ in range(40)] # keep our own copy of channels, 40 elements by default
         self.decrypt_channels = True
         self.channels_log = [] # stores the channel msg events
 
@@ -219,12 +219,12 @@ class MessageReader:
             res["channel_idx"] = dbuf.read(1)[0]
             res["path_len"] = dbuf.read(1)[0]
             res["txt_type"] = dbuf.read(1)[0]
-            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little")
+            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little", signed=False)
             text = dbuf.read().strip(b"\0")
             res["text"] = text.decode("utf-8", "ignore")
 
             # search for text in log_channels
-            txt_hash = int.from_bytes(SHA256.new(text).digest()[0:4], "little", signed=False)
+            txt_hash = int.from_bytes(SHA256.new(res["sender_timestamp"].to_bytes(4, "little", signed=False)+text).digest()[0:4], "little", signed=False)
             if self.decrypt_channels:
                 logged = next((l for l in reversed(self.channels_log) if 'msg_hash' in l and l['msg_hash'] == txt_hash), None)
                 if not logged is None:
@@ -232,6 +232,7 @@ class MessageReader:
                     res["RSSI"] = logged["rssi"]    
                     res["SNR"] = logged["snr"]
                     res["recv_time"] = logged["recv_time"]
+                    res["attempt"] = logged["attempt"]
 
             attributes = {
                 "channel_idx": res["channel_idx"],
@@ -250,12 +251,12 @@ class MessageReader:
             res["channel_idx"] = dbuf.read(1)[0]
             res["path_len"] = dbuf.read(1)[0]
             res["txt_type"] = dbuf.read(1)[0]
-            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little")
+            res["sender_timestamp"] = int.from_bytes(dbuf.read(4), byteorder="little", signed=False)
             text = dbuf.read()
             res["text"] = text.decode("utf-8", "ignore")
 
             # search for text in log_channels
-            txt_hash = int.from_bytes(SHA256.new(text).digest()[0:4], "little", signed=False)
+            txt_hash = int.from_bytes(SHA256.new(res["sender_timestamp"].to_bytes(4, "little", signed=False)+text).digest()[0:4], "little", signed=False)
             res["txt_hash"] = txt_hash
             logged = next((l for l in reversed(self.channels_log) if 'msg_hash' in l and l['msg_hash'] == txt_hash), None)
 
@@ -264,6 +265,7 @@ class MessageReader:
                     res["path"] = logged["path"]
                     res["RSSI"] = logged["rssi"]    
                     res["recv_time"] = logged["recv_time"]
+                    res["attempt"] = logged["attempt"]
 
             attributes = {
                 "channel_idx": res["channel_idx"],
@@ -428,9 +430,8 @@ class MessageReader:
             idx = dbuf.read(1)[0]
             res["channel_idx"] = idx
 
-            if idx >= len(self.channels):
-                self.channels = self.channels.extend(
-                    [{} for _ in range(idx - len(self.channels) + 1)])
+            if len(self.channels) <= idx:
+                self.channels.extend([{} for _ in range(1 + idx - len(self.channels))])
 
             # Channel name is null-terminated, so find the first null byte
             name_bytes = dbuf.read(32)
@@ -653,14 +654,24 @@ class MessageReader:
                         # not found: decrypt the text and hash it
                         aes_key = channel["channel_secret"]
                         cipher = AES.new(aes_key, AES.MODE_ECB)
-                        message = cipher.decrypt(msg)[5:].strip(b"\0")
-                        msg_hash = int.from_bytes(SHA256.new(message).digest()[0:4], "little", signed=False)
+                        uncrypted = cipher.decrypt(msg)
+                        timestamp = int.from_bytes(uncrypted[0:4], "little", signed=False)
+                        attempt = uncrypted[4] & 3
+                        txt_type = int.from_bytes(uncrypted[4:4], "little", signed=False) >> 2
+                        message = uncrypted[5:].strip(b"\0")
+                        msg_hash = int.from_bytes(SHA256.new(timestamp.to_bytes(4, "little", signed=False) + message).digest()[0:4], "little", signed=False)
                         log_data["message"] = message.decode("utf-8", "ignore")
                         log_data["msg_hash"] = msg_hash
+                        log_data["sender_timestamp"] = timestamp
+                        log_data["attempt"] = attempt
+                        log_data["txt_type"] = txt_type
                     else:
                         # found: copy
                         log_data["message"] = logged["message"]
                         log_data["msg_hash"] = logged["msg_hash"]
+                        log_data["sender_timestamp"] = logged["sender_timestamp"]
+                        log_data["attempt"] = logged["attempt"]
+                        log_data["txt_type"] = logged["txt_type"]
 
                 self.channels_log.append(log_data)
                 if len(self.channels_log) > 100: