Bugfixing - Debugging 2025

[luka-0614]

Since no one has been interested in updating this port for a long time and the original repository on the python2 is poorly developed I decided to use the "pytest" tool to fix bugs here and update outdated features like for example: OpenSSL.
Everything was adapted to python 3.13

Update code - Py3Bitmesage 2025-12-07

src/bitmsghash/bitmsghash.cpp - fix error with OpenSSL in python3.11+

(18.0) - Replace this:

#include "openssl/sha.h" 

on this:

#include <openssl/evp.h> 

(45.0) - Replace this:

SHA512_CTX sha;

on this:

EVP_MD_CTX *ctx = NULL;
const EVP_MD *sha512 = EVP_sha512();

(60.0) - Replace this:

SHA512_Init(&sha);
SHA512_Update(&sha, buf, HASH_SIZE + sizeof(uint64_t));
SHA512_Final(output, &sha);
SHA512_Init(&sha);
SHA512_Update(&sha, output, HASH_SIZE);
SHA512_Final(output, &sha);

on this:

ctx = EVP_MD_CTX_new();
EVP_DigestInit_ex(ctx, sha512, NULL);
EVP_DigestUpdate(ctx, buf, HASH_SIZE + sizeof(uint64_t));
EVP_DigestFinal_ex(ctx, output, NULL);
EVP_MD_CTX_reset(ctx); 
EVP_DigestInit_ex(ctx, sha512, NULL); 
EVP_DigestUpdate(ctx, output, HASH_SIZE);
EVP_DigestFinal_ex(ctx, output, NULL);
EVP_MD_CTX_free(ctx);

And in bitmsghash folder
$ make clean && make

src/depends.py - old entries

(220.0) - remove this line:

logger.info('sqlite3 Module Version: %s', sqlite3.version)

plugins/plugin.py - Replace the entire script for newer requirements. Removal of obsolete pkg

# -*- coding: utf-8 -*-
"""
Operating with plugins
"""
import sys
import importlib
from types import ModuleType
from typing import Iterable, Callable, Any

try:
    import importlib.metadata as importlib_metadata
except ImportError:
    import importlib_metadata

def get_plugins(group: str, name: str = None) -> Iterable[tuple[str, Callable]]:
    entry_point_group = f'bitmessage.{group}'

    if sys.version_info >= (3, 10):
        eps = importlib_metadata.entry_points(group=entry_point_group)
    else:
        eps = importlib_metadata.entry_points().get(entry_point_group, [])

    for ep in eps:
        if name is None or ep.name == name:
            try:
                plugin = ep.load()
                yield ep.name, plugin
            except Exception as e:
                print(f"Problem while loading {ep.name}: {e}")

def get_plugin_version() -> str:
    try:
        return importlib_metadata.version("pybitmessage")
    except importlib_metadata.PackageNotFoundError:
        return "unknown"


__version__ = get_plugin_version()

src/bitmessageqt/settings.py - Residues of pkg_resources

(66.0) - Replace this:

try:
            import pkg_resources
        except ImportError:
            pass
        else:
            # Append proxy types defined in plugins
            # FIXME: this should be a function in mod:`plugin`
            for ep in pkg_resources.iter_entry_points(
                    'bitmessage.proxyconfig'):
                try:
                    ep.load()
                except Exception: # it should add only functional plugins
                    # many possible exceptions, which are don't matter
                    pass
                else:
                    self.comboBoxProxyType.addItem(ep.name)

On this:

try:
            import importlib.metadata as importlib_metadata
        except ImportError:
            import importlib_metadata

        if sys.version_info >= (3, 10):
            eps = importlib_metadata.entry_points(group='bitmessage.proxyconfig')
        else:
            eps = importlib_metadata.entry_points().get('bitmessage.proxyconfig', [])

        for ep in eps:
            try:
                ep.load()
            except Exception:
                pass
            else:
                self.comboBoxProxyType.addItem(ep.name)

src/bitmessageqt/init.py - Fixing the sound-related function error and solving the "pybitmessageqt.conf" file that additionally caused delay.

(1375) - Replace the entire "PlaySound" function:

    def playSound(self, category, label=None):
        if not config.safeGetBoolean('bitmessagesettings', 'playsounds'):
            return

        if not sound.is_connection_sound(category):
            if (datetime.now() - self.lastSoundTime).total_seconds() < self.maxSoundFrequencySec:
                return

        try:
            from PyQt5.QtMultimedia import QSound
        except ImportError:
            return

        if label:
            user_sound = os.path.join(state.appdata, 'sounds', label)
            for ext in ('.wav', '.ogg', '.mp3'):
                if os.path.isfile(user_sound + ext):
                    QSound.play(user_sound + ext)
                    if not sound.is_connection_sound(category):
                        self.lastSoundTime = datetime.now()
                    return

        base_path = os.path.join(paths.lookupResourceFolder(), 'sounds')
        sound_files = {
            sound.SOUND_CONNECTED: 'connected',
            sound.SOUND_CONNECTION_GREEN: 'green',
            sound.SOUND_DISCONNECTED: 'disconnected',
            sound.SOUND_MESSAGE: 'newmessage',
            sound.SOUND_KNOWN: 'known',
            sound.SOUND_UNKNOWN: 'unknown',
            sound.SOUND_SCREENSHOT: 'screenshot',
        }

        filename = sound_files.get(category)
        if not filename:
            return

        for ext in ('.wav', '.ogg', '.mp3'):
            full_path = os.path.join(base_path, filename + ext)
            if os.path.isfile(full_path):
                QSound.play(full_path)
                if not sound.is_connection_sound(category):
                    self.lastSoundTime = datetime.now()
                return

(4329.0) - Replace this:

QtCore.QCoreApplication.setOrganizationName("PyBitmessage")
QtCore.QCoreApplication.setOrganizationDomain("bitmessage.org")
QtCore.QCoreApplication.setApplicationName("pybitmessageqt")

on this:

        QtCore.QSettings.setPath(
            QtCore.QSettings.IniFormat,
            QtCore.QSettings.UserScope,
            "/dev/null" if not is_windows else "NUL"
        )

These changes will result in no errors with:
$ pytest pybitmessage/bitmessagemain.py
$ python3 pybitmessage/bitmessagemain.py

It also proposes to delete the old file "start.sh" which contains commands to run bitmessage in the old python 2 and the file "py3start.py" to change to "start_linux.sh".
Qt5 of python3 looks great compared to Qt4 (python2). In addition, python3 works much faster and has greater security when performing cryptographic functions and the entire code.
Additional proposal is to change the default settings in "keys.dat" that is, by default, disabled support to namecoin which currently does not work. It's not about the removal, it's about shutting down the entire code.

After my tests I conclude full compatibility with peers on python 2. But I will continue to try to fix things if they occur and introduce newer mechanics and optimize the code. Long live Bitmessage!.

I also think that if my changes are introduced in the official PyBitmessage-py3 repository and the community considers the code to be stable, it can be considered to be an entry into the new version of the program which proposes "0.7" compared to the latest snapshot of the official version "0.63.2". If the main developer of the original "Peter Surda" repository were interested in implementing the update, the whole could be moved to the new repository by ceasing improvements over pybitmessage python2 and classifying it as obsolete.

That's all for now. I'm going to sit by the code, and I'm going to be here publishing more updates. If anyone finds anything, I invite you to discuss it.

[luka-0614]

src/network/dandelion.py - Fix Connection Error

(195.0) - Replace this:

    def reRandomiseStems(self):
        """Re-shuffle stem mapping (parent <-> child pairs)"""
        assert self.pool is not None
        if self.refresh > time():
            return

        with self.lock:
            try:
                # random two connections
                self.stem = sample(
                    sorted(self.pool.outboundConnections.values()), MAX_STEMS)
            # not enough stems available
            except ValueError:
                self.stem = list(self.pool.outboundConnections.values())
            self.nodeMap = {}
            # hashMap stays to cater for pending stems
        self.refresh = time() + REASSIGN_INTERVAL

on this:

    def reRandomiseStems(self):
        """Re-shuffle stem mapping (parent <-> child pairs)"""
        assert self.pool is not None
        if self.refresh > time():
            return

        with self.lock:
            connections = list(self.pool.outboundConnections.values())

            if not connections:
                self.stem = []
                self.nodeMap = {}
                self.refresh = time() + REASSIGN_INTERVAL
                return

           

            try:
                self.stem = sample(connections, min(MAX_STEMS, len(connections)))
            except ValueError:
                self.stem = []

            self.nodeMap = {}

        self.refresh = time() + REASSIGN_INTERVAL

src/network/networkthread.py - Network thread repair

(22.0) - Replace this

    def stopThread(self):
        super(BMNetworkThread, self).stopThread()
        for i in connectionpool.pool.listeningSockets.values():
            try:
                i.close()
            except:  # nosec B110 # pylint:disable=bare-except
                pass
        for i in connectionpool.pool.outboundConnections.values():
            try:
                i.close()
            except:  # nosec B110 # pylint:disable=bare-except
                pass
        for i in connectionpool.pool.inboundConnections.values():
            try:
                i.close()
            except:  # nosec B110 # pylint:disable=bare-except
                pass

        # just in case
        asyncore.close_all()

on this:

    def stopThread(self):
        super(BMNetworkThread, self).stopThread()

        for sock in list(connectionpool.pool.listeningSockets.values()):
            try:
                sock.close()
            except Exception:
                pass

        for conn in list(connectionpool.pool.outboundConnections.values()):
            try:
                conn.close()
            except Exception:
                pass

        for conn in list(connectionpool.pool.inboundConnections.values()):
            try:
                conn.close()
            except Exception:
                pass

        asyncore.close_all()

[luka-0614]

src/network/asyncore_pollchoose.py - Asynchronous protocol error

(315.0) - Replace this:

def epoll_poller(timeout=0.0, map=None):
    """A poller which uses epoll(), supported on Linux 2.5.44 and newer."""

    if map is None:
        map = socket_map
    try:
        epoll_poller.pollster
    except AttributeError:
        epoll_poller.pollster = select.epoll()
    if map:
        for fd, obj in map.items():
            flags = newflags = 0
            if obj.readable():
                flags |= select.POLLIN | select.POLLPRI
                newflags |= OP_READ
            else:
                newflags &= ~ OP_READ
            # accepting sockets should not be writable
            if obj.writable() and not obj.accepting:
                flags |= select.POLLOUT
                newflags |= OP_WRITE
            else:
                newflags &= ~ OP_WRITE
            if newflags != obj.poller_flags:
                obj.poller_flags = newflags
                # Only check for exceptions if object was either readable
                # or writable.
                flags |= select.POLLERR | select.POLLHUP | select.POLLNVAL
                try:
                    if obj.poller_registered:
                        epoll_poller.pollster.modify(fd, flags)
                    else:
                        epoll_poller.pollster.register(fd, flags)
                        obj.poller_registered = True
                except IOError:
                    pass
        try:
            r = epoll_poller.pollster.poll(timeout)
        except IOError as e:
            if e.errno != EINTR:
                raise
            r = []
        except select.error as err:
            if err.args[0] != EINTR:
                raise
            r = []
        for fd, flags in random.sample(r, len(r)):
            obj = map.get(fd)
            if obj is None:
                continue
            readwrite(obj, flags)
    else:
        current_thread().stop.wait(timeout)

on this:

def epoll_poller(timeout=0.0, map=None):
    """A poller which uses epoll(), supported on Linux 2.5.44 and newer."""
    if map is None:
        map = socket_map

    try:
        epoll_poller.pollster
    except AttributeError:
        epoll_poller.pollster = select.epoll()

    if map:

        try:
            items_snapshot = list(map.items())
        except RuntimeError:
            items_snapshot = list(map.items())

        for fd, obj in items_snapshot:
            if fd not in map:
                continue

            flags = newflags = 0
            if obj.readable():
                flags |= select.POLLIN | select.POLLPRI
                newflags |= OP_READ
            else:
                newflags &= ~ OP_READ

            if obj.writable() and not obj.accepting:
                flags |= select.POLLOUT
                newflags |= OP_WRITE
            else:
                newflags &= ~ OP_WRITE

            if newflags != getattr(obj, 'poller_flags', 0):
                obj.poller_flags = newflags
                flags |= select.POLLERR | select.POLLHUP | select.POLLNVAL
                try:
                    if getattr(obj, 'poller_registered', False):
                        epoll_poller.pollster.modify(fd, flags)
                    else:
                        epoll_poller.pollster.register(fd, flags)
                        obj.poller_registered = True
                except (IOError, OSError):
                    pass

        try:
            r = epoll_poller.pollster.poll(timeout)
        except (IOError, select.error) as e:
            if e.args[0] != errno.EINTR:
                raise
            r = []

        for fd, flags in random.sample(r, len(r)):
            if fd not in map:
                continue
            obj = map[fd]
            try:
                readwrite(obj, flags)
            except Exception:
                if hasattr(obj, 'handle_error'):
                    obj.handle_error()
                else:
                    obj.close()
    else:
        current_thread().stop.wait(timeout)

[luka-0614]

src/bitmessageqt/networkstatus.py - problem with OverflowError

(60.0) - Replace this:

    @staticmethod
    def formatBytes(num):
        """Format bytes nicely (SI prefixes)"""
        for x in (
            _translate("networkstatus", "byte(s)", None, num),
            "kB", "MB", "GB"
        ):
            if num < 1000.0:
                return "%3.0f %s" % (num, x)
            num /= 1000.0
        return "%3.0f %s" % (num, "TB")

on this:

    @staticmethod
    def formatBytes(num):
        """Format bytes nicely (SI prefixes)"""
        original_num = num 
        units = ["byte(s)", "kB", "MB", "GB", "TB"]
        i = 0
        while num >= 1000.0 and i < len(units) - 1:
            num /= 1000.0
            i += 1
        if i == 0:

            unit = _translate("networkstatus", "byte(s)", None, original_num)
        else:
            unit = units[i]
        return "%3.0f %s" % (num, unit)

src/bitmessageqt/settings.py - Bad configuration save

(647.0) - Replace this:

            with open(paths.lookupExeFolder() + 'keys.dat', 'wb') as configfile:
                self.config.write(configfile)

on this:

            with open(paths.lookupExeFolder() + 'keys.dat', 'w', encoding='utf-8') as configfile:
                self.config.write(configfile, space_around_delimiters=False)

src/hightlevelcrypto.py - error when adding chans channel

(105.0) - Replace this:

def deterministic_keys(passphrase, nonce):
    """Generate keys from *passphrase* and *nonce* (encoded as varint)"""
    priv = hashlib.sha512(unic(passphrase).encode("utf-8", "replace") + nonce).digest()[:32]
    pub = pointMult(priv)
    return priv, pub

on this:

def deterministic_keys(passphrase, nonce):
    """Generate keys from *passphrase* and *nonce* (encoded as varint)"""
    p = passphrase.encode("utf-8") if isinstance(passphrase, str) else bytes(passphrase)
    n = nonce if isinstance(nonce, bytes) else bytes(nonce)
    priv = hashlib.sha512(p + n).digest()[:32]
    pub = pointMult(priv)
    return priv, pub

src/class_objectProcessor.py - error when switching off sqlite

(63.0) - Replace this:

            queues.objectProcessorQueue.put((objectType, data))

on this:

             if isinstance(data, memoryview):
                 data = bytes(data)
             queues.objectProcessorQueue.put((objectType, data))

(126.0) - Replace this:

                        sql.execute(
                            'INSERT INTO objectprocessorqueue VALUES (?,?)',
                            objectType, sqlite3.Binary(data))

on this:

                        data_bytes = data if isinstance(data, (bytes, bytearray)) else data.encode('latin-1')
                        sql.execute('INSERT INTO objectprocessorqueue VALUES (?,?)',
                            objectType, sqlite3.Binary(data_bytes))