Fixes

- Qt six import was broken
- variable in Qt support interface rename incomplete
- objectProcessor wasn't handling memoryview correctly
- inventory data corruption fix

Author: PeterSurda

src/bitmessageqt/__init__.py

@@ -56,8 +56,7 @@
 import bitmessage_icons_rc  # noqa:F401 pylint: disable=unused-import
 import helper_sent
 
-from six.moves import iteritems, itervalues, range as xrange
-from six import text_type
+from six import iteritems, itervalues, text_type
 
 try:
     from plugins.plugin import get_plugin, get_plugins

src/bitmessageqt/support.py

@@ -141,7 +141,7 @@ def createSupportMessage(myapp):
     if paths.frozen:
         frozen = paths.frozen
     portablemode = "True" if state.appdata == paths.lookupExeFolder() else "False"
-    cpow = "True" if proofofwork.bmpow else "False"
+    cpow = "True" if proofofwork.BMPOW else "False"
     openclpow = str(
         config.safeGet('bitmessagesettings', 'opencl')
     ) if openclEnabled() else "None"

src/class_objectProcessor.py

@@ -141,15 +141,19 @@ def checkackdata(data):
         # bypass nonce and time, retain object type/version/stream + body
         readPosition = 16
 
-        if data[readPosition:] in state.ackdataForWhichImWatching:
+        # data may be a memoryview, which is not hashable and thus
+        # cannot be used as a dictionary key; convert the slice to bytes.
+        ackcheckdata = bytes(data[readPosition:])
+
+        if ackcheckdata in state.ackdataForWhichImWatching:
             logger.info('This object is an acknowledgement bound for me.')
-            del state.ackdataForWhichImWatching[data[readPosition:]]
+            del state.ackdataForWhichImWatching[ackcheckdata]
             sqlExecute(
                 "UPDATE sent SET status='ackreceived', lastactiontime=?"
-                " WHERE ackdata=?", int(time.time()), data[readPosition:])
+                " WHERE ackdata=?", int(time.time()), ackcheckdata)
             queues.UISignalQueue.put((
                 'updateSentItemStatusByAckdata', (
-                    data[readPosition:],
+                    ackcheckdata,
                     _translate(
                         "MainWindow",
                         "Acknowledgement of the message received %1"
@@ -208,7 +212,9 @@ def processgetpubkey(data):
 
         myAddress = ''
         if requestedAddressVersionNumber <= 3:
-            requestedHash = data[readPosition:readPosition + 20]
+            # data may be a memoryview; convert slices to bytes so they
+            # are hashable and can be used as dictionary keys.
+            requestedHash = bytes(data[readPosition:readPosition + 20])
             if len(requestedHash) != 20:
                 return logger.debug(
                     'The length of the requested hash is not 20 bytes.'
@@ -220,7 +226,8 @@ def processgetpubkey(data):
             if requestedHash in shared.myAddressesByHash:
                 myAddress = shared.myAddressesByHash[requestedHash]
         elif requestedAddressVersionNumber >= 4:
-            requestedTag = data[readPosition:readPosition + 32]
+            # data may be a memoryview; convert to bytes for hashability.
+            requestedTag = bytes(data[readPosition:readPosition + 32])
             if len(requestedTag) != 32:
                 return logger.debug(
                     'The length of the requested tag is not 32 bytes.'
@@ -413,7 +420,8 @@ def processpubkey(self, data):
                     '(within processpubkey) payloadLength less than 350.'
                     ' Sanity check failed.')
 
-            tag = data[readPosition:readPosition + 32]
+            # data may be a memoryview; convert to bytes for hashability.
+            tag = bytes(data[readPosition:readPosition + 32])
             if tag not in state.neededPubkeys:
                 return logger.info(
                     'We don\'t need this v4 pubkey. We didn\'t ask for it.')
@@ -807,7 +815,8 @@ def processbroadcast(self, data):
                     ' v4 broadcast: %s seconds.',
                     time.time() - messageProcessingStartTime)
         elif broadcastVersion == 5:
-            embeddedTag = data[readPosition:readPosition + 32]
+            # data may be a memoryview; convert to bytes for hashability.
+            embeddedTag = bytes(data[readPosition:readPosition + 32])
             readPosition += 32
             if embeddedTag not in shared.MyECSubscriptionCryptorObjects:
                 logger.debug('We\'re not interested in this broadcast.')

src/storage/sqlite.py

@@ -9,6 +9,18 @@
 from .storage import InventoryItem, InventoryStorage
 
 
+def _to_blob(data):
+    """Coerce buffer-like *data* for sqlite3 BLOB binding.
+
+    In Python 2, sqlite3.Binary is buffer() which rejects memoryview;
+    bytes(memoryview) silently returns the repr string.  Use tobytes()
+    to get the actual content.
+    """
+    if isinstance(data, memoryview):
+        data = data.tobytes()
+    return sqlite3.Binary(data)
+
+
 class SqliteInventory(InventoryStorage):
     """Inventory using SQLite"""
     def __init__(self):
@@ -109,12 +121,12 @@ def flush(self):
                 for objectHash, value in self._inventory.items():
                     sql.execute(
                         'INSERT INTO inventory VALUES (?, ?, ?, ?, ?, ?)',
-                        sqlite3.Binary(objectHash),
+                        _to_blob(objectHash),
                         value.type,
                         value.stream,
-                        sqlite3.Binary(bytes(value.payload)),
+                        _to_blob(value.payload),
                         value.expires,
-                        sqlite3.Binary(bytes(value.tag)))
+                        _to_blob(value.tag))
                 self._inventory.clear()
 
     def clean(self):

src/tests/test_inventory_flush.py

@@ -84,44 +84,53 @@ def _make_hash(seed):
         """Return a 32-byte hash derived from *seed*."""
         return (b'\x00' * 31 + bytes([seed & 0xFF]))[-32:]
 
-    def _flush_and_check(self, obj_hash):
+    def _flush_and_check(self, obj_hash, expected_payload=None):
         """
-        Flush the inventory to the database, clear the _objects lookup
-        cache so that __contains__ is forced to hit sqlite, then verify
-        the hash is found via the normal inventory API.
+        Flush the inventory to the database, clear both in-memory
+        caches so that __contains__ and __getitem__ are forced to
+        hit sqlite, then verify the hash is found and (optionally)
+        that the payload content survived the round-trip.
         """
         self.inventory.flush()
         self.inventory._objects.clear()
         self.assertIn(obj_hash, self.inventory)
+        if expected_payload is not None:
+            value = self.inventory[obj_hash]
+            self.assertEqual(
+                bytes(value.payload), expected_payload,
+                "Payload content corrupted after flush")
 
     # -- test cases -------------------------------------------------------
 
     def test_flush_with_bytes_payload(self):
         """Baseline: payload and tag are plain bytes."""
         h = self._make_hash(1)
+        payload = b'\x80\x01' + os.urandom(64)
         self.inventory[h] = (
-            2, 1, b'\x80\x01' + os.urandom(64),
+            2, 1, payload,
             int(time.time()) + 3600, b'\xff' * 32)
-        self._flush_and_check(h)
+        self._flush_and_check(h, payload)
 
     def test_flush_with_memoryview_payload(self):
         """
         Reproduce the production crash: payload and tag as memoryview
         cause 'Error binding parameter 3 - probably unsupported type.'
         """
         h = self._make_hash(2)
+        payload = b'\x80\x02' + os.urandom(64)
         self.inventory[h] = (
-            2, 1, memoryview(b'\x80\x02' + os.urandom(64)),
+            2, 1, memoryview(payload),
             int(time.time()) + 3600, memoryview(b'\xee' * 32))
-        self._flush_and_check(h)
+        self._flush_and_check(h, payload)
 
     def test_flush_with_bytearray_payload(self):
         """bytearray is another bytes-like type that could trip sqlite3."""
         h = self._make_hash(3)
+        payload = b'\x80\x03' + os.urandom(64)
         self.inventory[h] = (
-            2, 1, bytearray(b'\x80\x03' + os.urandom(64)),
+            2, 1, bytearray(payload),
             int(time.time()) + 3600, bytearray(b'\xdd' * 32))
-        self._flush_and_check(h)
+        self._flush_and_check(h, payload)
 
     def test_flush_with_empty_tag(self):
         """Empty tag (b'') must not break the INSERT."""