import binascii import collections import hashlib import os.path import struct import threading import time import addresses import bmconfigparser import debug import defaults import helper_msgcoding import helper_sql import helper_random import helper_threading import highlevelcrypto import inventory import l10n import paths import protocol import shared import state import tr import queues import workprover # Message status flow: # # +----------------------------------------------------------------------------------------+ # v | # +-> msgqueued -+---------------------------------------->+-+-> doingmsgpow -+-> msgsent -+-> ackreceived # ^ | ^ | | # | +-> awaitingpubkey -+-> doingpubkeypow -+ | | +-> msgsentnoackexpected # | ^ v | | | | # +--------------+-------------------+-------------------+ | | +-> badkey # | | # | +-> toodifficult --> forcepow -+ # | | # +--------------------------------+ # Broadcast status flow: # # broadcastqueued --> doingbroadcastpow --> broadcastsent # TODO: queued pubkey messages are not saved to the database, they disappear when the client is closed AddressProperties = collections.namedtuple("AddressProperties", [ "version", "stream", "ripe", "own", "chan", "bitfield", "byteDifficulty", "lengthExtension", "secretSigningKey", "secretEncryptionKey", "publicSigningKey", "publicEncryptionKey" ]) def getMyAddressProperties(address, defaultDifficulty = False): status, version, stream, ripe = addresses.decodeAddress(address) if defaultDifficulty: byteDifficulty = defaults.networkDefaultProofOfWorkNonceTrialsPerByte lengthExtension = defaults.networkDefaultPayloadLengthExtraBytes else: byteDifficulty = bmconfigparser.BMConfigParser().safeGetInt(address, "noncetrialsperbyte", None) lengthExtension = bmconfigparser.BMConfigParser().safeGetInt(address, "payloadlengthextrabytes", None) chan = bmconfigparser.BMConfigParser().safeGetBoolean(address, "chan") bitfield = 0 if not bmconfigparser.BMConfigParser().safeGetBoolean(address, "dontsendack"): bitfield |= protocol.BITFIELD_DOESACK secretSigningKeyBase58 = bmconfigparser.BMConfigParser().get(address, "privsigningkey") secretEncryptionKeyBase58 = bmconfigparser.BMConfigParser().get(address, "privencryptionkey") secretSigningKey = shared.decodeWalletImportFormat(secretSigningKeyBase58) secretEncryptionKey = shared.decodeWalletImportFormat(secretEncryptionKeyBase58) publicSigningKey = binascii.unhexlify(highlevelcrypto.privToPub(binascii.hexlify(secretSigningKey))) publicEncryptionKey = binascii.unhexlify(highlevelcrypto.privToPub(binascii.hexlify(secretEncryptionKey))) return AddressProperties( version, stream, ripe, True, chan, bitfield, byteDifficulty, lengthExtension, secretSigningKey, secretEncryptionKey, publicSigningKey, publicEncryptionKey ) def parsePubkeyMessage(encoded): readPosition = 0 version, readLength = addresses.decodeVarint(encoded[readPosition: readPosition + 9]) readPosition += readLength stream, readLength = addresses.decodeVarint(encoded[readPosition: readPosition + 9]) readPosition += readLength bitfield, = struct.unpack(">I", encoded[readPosition: readPosition + 4]) readPosition += 4 publicSigningKey = "\x04" + encoded[readPosition: readPosition + 64] readPosition += 64 publicEncryptionKey = "\x04" + encoded[readPosition: readPosition + 64] readPosition += 64 ripe = protocol.calculateRipeHash(publicSigningKey + publicEncryptionKey) if version < 3: byteDifficulty = defaults.networkDefaultProofOfWorkNonceTrialsPerByte lengthExtension = defaults.networkDefaultPayloadLengthExtraBytes else: byteDifficulty, readLength = addresses.decodeVarint(encoded[readPosition: readPosition + 9]) readPosition += readLength lengthExtension, readLength = addresses.decodeVarint(encoded[readPosition: readPosition + 9]) readPosition += readLength byteDifficulty = max(defaults.networkDefaultProofOfWorkNonceTrialsPerByte, byteDifficulty) lengthExtension = max(defaults.networkDefaultPayloadLengthExtraBytes, lengthExtension) return AddressProperties( version, stream, ripe, False, False, bitfield, byteDifficulty, lengthExtension, None, None, publicSigningKey, publicEncryptionKey ) def getDestinationAddressProperties(address): # Search own and chan addresses try: return getMyAddressProperties(address, True) except: pass # Search the "pubkeys" table in the database status, version, stream, ripe = addresses.decodeAddress(address) if version == 4: secretEncryptionKey, tag = protocol.calculateAddressTag(version, stream, ripe) cryptor = highlevelcrypto.makeCryptor(binascii.hexlify(secretEncryptionKey)) alreadyNeeded = tag in state.neededPubkeys state.neededPubkeys[tag] = address, cryptor else: alreadyNeeded = address in state.neededPubkeys state.neededPubkeys[address] = None helper_sql.sqlExecute("""UPDATE "pubkeys" SET "usedpersonally" = 'yes' WHERE "address" == ?;""", address) encodedPubkeys = helper_sql.sqlQuery("""SELECT "transmitdata" FROM "pubkeys" WHERE "address" == ?;""", address) result = None if len(encodedPubkeys) != 0: result = parsePubkeyMessage(encodedPubkeys[-1][0]) # Search the inventory for encrypted keys if result is None and version == 4: for i in inventory.Inventory().by_type_and_tag(1, tag): encodedPubkey = protocol.decryptAndCheckV4Pubkey(i.payload, address, cryptor) if encodedPubkey is None: continue helper_sql.sqlExecute(""" INSERT INTO "pubkeys" ("address", "addressversion", "transmitdata", "time", "usedpersonally") VALUES (?, 4, ?, ?, 'yes'); """, address, encodedPubkey, int(time.time())) result = parsePubkeyMessage(encodedPubkey) break if result is not None: if version == 4: state.neededPubkeys.pop(tag, None) else: state.neededPubkeys.pop(address, None) helper_sql.sqlExecute(""" UPDATE "sent" SET "status" = 'msgqueued' WHERE "status" IN ('doingpubkeypow', 'awaitingpubkey') AND "toaddress" == ? AND "folder" == 'sent'; """, address) if alreadyNeeded: queues.workerQueue.put(("sendmessage", )) queued = helper_sql.sqlQuery(""" SELECT "ackdata" FROM "sent" WHERE "status" == 'msgqueued' AND "toaddress" == ? AND "folder" == 'sent'; """, address) for i, in queued: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( i, tr._translate( "MainWindow", "Queued." ) ))) return result return None def randomizeTTL(TTL): return TTL + helper_random.randomrandrange(-300, 300) def disseminateObject(nonce, expiryTime, headlessPayload, objectType, stream, tag): payload = nonce + struct.pack(">Q", expiryTime) + headlessPayload inventoryHash = protocol.calculateDoubleHash(payload)[: 32] inventory.Inventory()[inventoryHash] = objectType, stream, payload, expiryTime, buffer(tag) queues.invQueue.put((stream, inventoryHash)) debug.logger.info("Broadcasting inventory object with hash: %s", binascii.hexlify(inventoryHash)) return inventoryHash, payload class singleWorker(threading.Thread, helper_threading.StoppableThread): name = "singleWorker" def __init__(self): super(self.__class__, self).__init__() self.initStop() def stopThread(self): queues.workerQueue.put(("stopThread", "data")) super(self.__class__, self).stopThread() def run(self): GPUVendor = bmconfigparser.BMConfigParser().safeGet("bitmessagesettings", "opencl") self.workProver = workprover.WorkProver( os.path.join(paths.codePath(), "workprover"), GPUVendor, helper_random.randomBytes(32), lambda status: queues.UISignalQueue.put(("updateWorkProverStatus", status)), queues.workerQueue ) self.workProver.start() parallelism = bmconfigparser.BMConfigParser().safeGetInt("bitmessagesettings", "maxcores") if parallelism < 1: parallelism = self.workProver.defaultParallelism debug.logger.info("Availabe solvers: %s", str(self.workProver.availableSolvers.keys())) if "gpu" in self.workProver.availableSolvers and GPUVendor is not None: self.workProver.commandsQueue.put(("setSolver", "gpu", None)) elif "fast" in self.workProver.availableSolvers: self.workProver.commandsQueue.put(("setSolver", "fast", parallelism)) elif "forking" in self.workProver.availableSolvers: self.workProver.commandsQueue.put(("setSolver", "forking", parallelism)) else: self.workProver.commandsQueue.put(("setSolver", "dumb", None)) if "fast" not in self.workProver.availableSolvers: queues.UISignalQueue.put(("updateStatusBar", ( tr._translate( "proofofwork", "C PoW module unavailable. Please build it." ), 1 ))) self.startedWorks = {} # Give some time for the GUI to start # TODO: use a condition variable self.stop.wait(10) queues.workerQueue.put(("sendmessage", )) queues.workerQueue.put(("sendbroadcast", )) while state.shutdown == 0: queueItem = queues.workerQueue.get() command, arguments = queueItem[0], queueItem[1: ] if command == "sendmessage": self.sendMessages() elif command == "sendbroadcast": self.sendBroadcasts() elif command == "sendMyPubkey": self.sendMyPubkey(*arguments) elif command == "requestPubkey": self.requestPubkey(*arguments) elif command == "resetPoW": pass elif command == "taskDone": self.workDone(*arguments) elif command == "stopThread": self.workProver.commandsQueue.put(("shutdown", )) self.workProver.join() break debug.logger.info("Quitting...") def startWork(self, ID, headlessPayload, TTL, expiryTime, byteDifficulty, lengthExtension, logPrefix, callback): debug.logger.info( "%s Starting work %s, payload length = %s, TTL = %s", logPrefix, ID, 8 + 8 + len(headlessPayload), TTL ) self.startedWorks[ID] = callback self.workProver.commandsQueue.put(( "addTask", ID, headlessPayload, TTL, expiryTime, byteDifficulty, lengthExtension )) def workDone(self, ID, nonce, expiryTime): debug.logger.info("Found proof of work %s", ID) self.startedWorks[ID](nonce, expiryTime) del self.startedWorks[ID] def sendMyPubkey(self, address): ID = "pubkey", address if ID in self.startedWorks: return try: addressProperties = getMyAddressProperties(address) except Exception as exception: debug.logger.error("Could not get the properties of a requested address %s\n", exception) return if addressProperties.chan: debug.logger.info("This is a chan address. Not sending pubkey") return if addressProperties.version == 4: secretEncryptionKey, tag = protocol.calculateAddressTag( addressProperties.version, addressProperties.stream, addressProperties.ripe ) publicEncryptionKey = highlevelcrypto.pointMult(secretEncryptionKey) else: tag = "" debug.logger.info("Sending pubkey of %s", address) TTL = randomizeTTL(28 * 24 * 60 * 60) expiryTime = int(time.time() + TTL) headlessPayload = struct.pack(">I", 1) headlessPayload += addresses.encodeVarint(addressProperties.version) headlessPayload += addresses.encodeVarint(addressProperties.stream) inventoryTagPosition = len(headlessPayload) headlessPayload += tag if addressProperties.version == 4: plaintext = struct.pack(">I", addressProperties.bitfield) plaintext += addressProperties.publicSigningKey[1: ] plaintext += addressProperties.publicEncryptionKey[1: ] plaintext += addresses.encodeVarint(addressProperties.byteDifficulty) plaintext += addresses.encodeVarint(addressProperties.lengthExtension) signature = highlevelcrypto.sign( struct.pack(">Q", expiryTime) + headlessPayload + plaintext, binascii.hexlify(addressProperties.secretSigningKey) ) plaintext += addresses.encodeVarint(len(signature)) plaintext += signature headlessPayload += highlevelcrypto.encrypt(plaintext, binascii.hexlify(publicEncryptionKey)) else: headlessPayload += struct.pack(">I", addressProperties.bitfield) headlessPayload += addressProperties.publicSigningKey[1: ] headlessPayload += addressProperties.publicEncryptionKey[1: ] if addressProperties.version == 3: headlessPayload += addresses.encodeVarint(addressProperties.byteDifficulty) headlessPayload += addresses.encodeVarint(addressProperties.lengthExtension) signature = highlevelcrypto.sign( struct.pack(">Q", expiryTime) + headlessPayload, binascii.hexlify(addressProperties.secretSigningKey) ) headlessPayload += addresses.encodeVarint(len(signature)) headlessPayload += signature def workDone(nonce, expiryTime): inventoryTag = headlessPayload[inventoryTagPosition: inventoryTagPosition + 32] disseminateObject(nonce, expiryTime, headlessPayload, 1, addressProperties.stream, inventoryTag) # TODO: not atomic with the addition to the inventory, the "lastpubkeysendtime" property should be removed # Instead check if the pubkey is present in the inventory try: bmconfigparser.BMConfigParser().set(address, "lastpubkeysendtime", str(int(time.time()))) bmconfigparser.BMConfigParser().save() except: pass queues.UISignalQueue.put(("updateStatusBar", "")) self.startWork( ID, headlessPayload, TTL, expiryTime, defaults.networkDefaultProofOfWorkNonceTrialsPerByte, defaults.networkDefaultPayloadLengthExtraBytes, "(For pubkey version {} message)".format(addressProperties.version), workDone ) def processBroadcast(self, address, subject, body, ackData, TTL, encoding): ID = "broadcast", ackData try: addressProperties = getMyAddressProperties(address) except: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Error! Could not find sender address (your address) in the keys.dat file." ) ))) return if addressProperties.version < 2: debug.logger.error("Address version unsupported for broadcasts") return debug.logger.info("Sending broadcast from %s", address) if addressProperties.version == 4: secretEncryptionKey, tag = protocol.calculateAddressTag( addressProperties.version, addressProperties.stream, addressProperties.ripe ) else: secretEncryptionKey = hashlib.sha512( addresses.encodeVarint(addressProperties.version) + addresses.encodeVarint(addressProperties.stream) + addressProperties.ripe ).digest()[: 32] tag = "" publicEncryptionKey = highlevelcrypto.pointMult(secretEncryptionKey) TTL = min(28 * 24 * 60 * 60, TTL) TTL = max(60 * 60, TTL) TTL = randomizeTTL(TTL) expiryTime = int(time.time() + TTL) headlessPayload = struct.pack(">I", 3) if addressProperties.version == 4: headlessPayload += addresses.encodeVarint(5) else: headlessPayload += addresses.encodeVarint(4) headlessPayload += addresses.encodeVarint(addressProperties.stream) inventoryTagPosition = len(headlessPayload) headlessPayload += tag plaintext = addresses.encodeVarint(addressProperties.version) plaintext += addresses.encodeVarint(addressProperties.stream) plaintext += struct.pack(">I", addressProperties.bitfield) plaintext += addressProperties.publicSigningKey[1: ] plaintext += addressProperties.publicEncryptionKey[1: ] if addressProperties.version >= 3: plaintext += addresses.encodeVarint(addressProperties.byteDifficulty) plaintext += addresses.encodeVarint(addressProperties.lengthExtension) encodedMessage = helper_msgcoding.MsgEncode({"subject": subject, "body": body}, encoding) plaintext += addresses.encodeVarint(encoding) plaintext += addresses.encodeVarint(encodedMessage.length) plaintext += encodedMessage.data signature = highlevelcrypto.sign( struct.pack(">Q", expiryTime) + headlessPayload + plaintext, binascii.hexlify(addressProperties.secretSigningKey) ) plaintext += addresses.encodeVarint(len(signature)) plaintext += signature headlessPayload += highlevelcrypto.encrypt(plaintext, binascii.hexlify(publicEncryptionKey)) if len(headlessPayload) > 2 ** 18 - (8 + 8): # 256 kiB debug.logger.critical( "This broadcast object is too large to send. This should never happen. Object size: %s", len(headlessPayload) ) return def workDone(nonce, expiryTime): inventoryTag = headlessPayload[inventoryTagPosition: inventoryTagPosition + 32] # TODO: adding to the inventory, adding to inbox and setting the sent status should be within a single SQL transaction inventoryHash, payload = disseminateObject( nonce, expiryTime, headlessPayload, 3, addressProperties.stream, inventoryTag ) helper_sql.sqlExecute(""" UPDATE "sent" SET "msgid" = ?, "status" = 'broadcastsent', "lastactiontime" = ? WHERE "ackdata" == ?; """, inventoryHash, int(time.time()), ackData) queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate("MainWindow", "Broadcast sent on %1").arg(l10n.formatTimestamp()) ))) # Add to own inbox if addressProperties.version == 4: if tag in shared.MyECSubscriptionCryptorObjects: queues.objectProcessorQueue.put((3, payload)) else: if addressProperties.ripe in shared.MyECSubscriptionCryptorObjects: queues.objectProcessorQueue.put((3, payload)) helper_sql.sqlExecute("""UPDATE "sent" SET "status" = 'doingbroadcastpow' WHERE "ackdata" == ?;""", ackData) queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Doing work necessary to send broadcast." ) ))) self.startWork( ID, headlessPayload, TTL, expiryTime, defaults.networkDefaultProofOfWorkNonceTrialsPerByte, defaults.networkDefaultPayloadLengthExtraBytes, "(For broadcast message)", workDone ) def sendBroadcasts(self): queued = helper_sql.sqlQuery(""" SELECT "fromaddress", "subject", "message", "ackdata", "ttl", "encodingtype" FROM "sent" WHERE "status" == 'broadcastqueued' AND "folder" == 'sent'; """) for i in queued: # Must be in a separate function because of the nested callback self.processBroadcast(*i) def generateAckMessage(self, ackData, stream, TTL, callback): ID = "ack", ackData # It might be perfectly fine to just use the same TTL for # the ackdata that we use for the message. But I would rather # it be more difficult for attackers to associate ackData with # the associated msg object. However, users would want the TTL # of the acknowledgement to be about the same as they set # for the message itself. So let's set the TTL of the # acknowledgement to be in one of three 'buckets': 1 hour, 7 # days, or 28 days, whichever is relatively close to what the # user specified. if TTL < 24 * 60 * 60: TTL = 24 * 60 * 60 elif TTL < 7 * 24 * 60 * 60: TTL = 7 * 24 * 60 * 60 else: TTL = 28 * 24 * 60 * 60 TTL = randomizeTTL(TTL) expiryTime = int(time.time() + TTL) def workDone(nonce, expiryTime): payload = nonce + struct.pack(">Q", expiryTime) + ackData callback(protocol.CreatePacket("object", payload)) self.startWork( ID, ackData, TTL, expiryTime, defaults.networkDefaultProofOfWorkNonceTrialsPerByte, defaults.networkDefaultPayloadLengthExtraBytes, "(For ack message)", workDone ) def processMessage(self, status, destination, source, subject, body, ackData, TTL, retryNumber, encoding): ID = "message", ackData helper_sql.sqlExecute("""UPDATE "sent" SET "status" = 'awaitingpubkey' WHERE "ackdata" == ?;""", ackData) destinationProperties = getDestinationAddressProperties(destination) if destinationProperties is None: queues.workerQueue.put(("requestPubkey", destination)) queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Waiting for their encryption key. Will request it again soon." ) ))) return try: defaultDifficulty = shared.isAddressInMyAddressBookSubscriptionsListOrWhitelist(destination) if destinationProperties.own: defaultDifficulty = True sourceProperties = getMyAddressProperties(source, defaultDifficulty) except: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Error! Could not find sender address (your address) in the keys.dat file." ) ))) return relativeByteDifficulty = ( float(destinationProperties.byteDifficulty) / defaults.networkDefaultProofOfWorkNonceTrialsPerByte ) relativeLengthExtension = ( float(destinationProperties.lengthExtension) / defaults.networkDefaultPayloadLengthExtraBytes ) if status != "forcepow": maximumByteDifficulty = bmconfigparser.BMConfigParser().getint( "bitmessagesettings", "maxacceptablenoncetrialsperbyte" ) maximumLengthExtension = bmconfigparser.BMConfigParser().getint( "bitmessagesettings", "maxacceptablepayloadlengthextrabytes" ) if ( maximumByteDifficulty != 0 and destinationProperties.byteDifficulty > maximumLengthExtension or maximumLengthExtension != 0 and destinationProperties.lengthExtension > maximumLengthExtension ): helper_sql.sqlExecute("""UPDATE "sent" SET "status" = 'toodifficult' WHERE "ackdata" == ?;""", ackData) queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Problem: The work demanded by the recipient (%1 and %2) is " "more difficult than you are willing to do. %3" ).arg(str(relativeByteDifficulty)).arg(str(relativeLengthExtension)).arg(l10n.formatTimestamp()) ))) return debug.logger.info("Sending message from %s to %s", source, destination) TTL *= 2 ** retryNumber TTL = min(28 * 24 * 60 * 60, TTL) TTL = max(60 * 60, TTL) TTL = randomizeTTL(TTL) expiryTime = int(time.time() + TTL) def ackMessageGenerated(ackMessage): headlessPayload = struct.pack(">I", 2) headlessPayload += addresses.encodeVarint(1) headlessPayload += addresses.encodeVarint(destinationProperties.stream) plaintext = addresses.encodeVarint(sourceProperties.version) plaintext += addresses.encodeVarint(sourceProperties.stream) plaintext += struct.pack(">I", sourceProperties.bitfield) plaintext += sourceProperties.publicSigningKey[1: ] plaintext += sourceProperties.publicEncryptionKey[1: ] if sourceProperties.version >= 3: plaintext += addresses.encodeVarint(sourceProperties.byteDifficulty) plaintext += addresses.encodeVarint(sourceProperties.lengthExtension) plaintext += destinationProperties.ripe # To prevent resending a signed message to a different reciever encodedMessage = helper_msgcoding.MsgEncode({"subject": subject, "body": body}, encoding) plaintext += addresses.encodeVarint(encoding) plaintext += addresses.encodeVarint(encodedMessage.length) plaintext += encodedMessage.data if ackMessage is None: plaintext += addresses.encodeVarint(0) else: plaintext += addresses.encodeVarint(len(ackMessage)) plaintext += ackMessage signature = highlevelcrypto.sign( struct.pack(">Q", expiryTime) + headlessPayload + plaintext, binascii.hexlify(sourceProperties.secretSigningKey) ) plaintext += addresses.encodeVarint(len(signature)) plaintext += signature try: ciphertext = highlevelcrypto.encrypt( plaintext, binascii.hexlify(destinationProperties.publicEncryptionKey) ) except: helper_sql.sqlExecute("""UPDATE "sent" SET "status" = 'badkey' WHERE "ackdata" == ?;""", ackData) queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Problem: The recipient's encryption key is no good. Could not encrypt message. %1" ).arg(l10n.formatTimestamp()) ))) return headlessPayload += ciphertext inventoryTag = ciphertext[: 32] if len(headlessPayload) > 2 ** 18 - (8 + 8): # 256 kiB debug.logger.critical( "This message object is too large to send. This should never happen. Object size: %s", len(headlessPayload) ) return def workDone(nonce, expiryTime): if ackMessage is not None: state.watchedAckData.add(ackData) #TODO: adding to the inventory, adding to inbox and setting the sent status should be within a single SQL transaction inventoryHash, payload = disseminateObject( nonce, expiryTime, headlessPayload, 2, destinationProperties.stream, inventoryTag ) if ackMessage is None: newStatus = "msgsentnoackexpected" sleepTill = 0 else: newStatus = "msgsent" sleepTill = int(time.time() + TTL * 1.1) helper_sql.sqlExecute(""" UPDATE "sent" SET "msgid" = ?, "status" = ?, "retrynumber" = ?, "sleeptill" = ?, "lastactiontime" = ? WHERE "status" == 'doingmsgpow' AND "ackdata" == ?; """, inventoryHash, newStatus, retryNumber + 1, sleepTill, int(time.time()), ackData) # Add to own inbox if destinationProperties.own: queues.objectProcessorQueue.put((2, payload)) if ackMessage is None: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Message sent. Sent at %1" ).arg(l10n.formatTimestamp()) ))) else: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Message sent. Waiting for acknowledgement. Sent on %1" ).arg(l10n.formatTimestamp()) ))) self.startWork( ID, headlessPayload, TTL, expiryTime, destinationProperties.byteDifficulty, destinationProperties.lengthExtension, "(For message)", workDone ) helper_sql.sqlExecute("""UPDATE "sent" SET "status" = 'doingmsgpow' WHERE "ackdata" == ?;""", ackData) if relativeByteDifficulty != 1 or relativeLengthExtension != 1: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Doing work necessary to send message.\nReceiver's required difficulty: %1 and %2" ).arg(str(relativeByteDifficulty)).arg(str(relativeLengthExtension)) ))) else: queues.UISignalQueue.put(("updateSentItemStatusByAckdata", ( ackData, tr._translate( "MainWindow", "Doing work necessary to send message." ) ))) if destinationProperties.own: debug.logger.info("Not bothering to include ack data because we are sending to ourselves or a chan") ackMessageGenerated(None) elif destinationProperties.bitfield & protocol.BITFIELD_DOESACK == 0: debug.logger.info("Not bothering to include ack data because the receiver said that they won't relay it anyway") ackMessageGenerated(None) else: self.generateAckMessage(ackData, destinationProperties.stream, TTL, ackMessageGenerated) def sendMessages(self): queued = helper_sql.sqlQuery(""" SELECT "status", "toaddress", "fromaddress", "subject", "message", "ackdata", "ttl", "retrynumber", "encodingtype" FROM "sent" WHERE "status" IN ('msgqueued', 'forcepow') AND "folder" == 'sent'; """) for i in queued: # Must be in a separate function because of the nested callback self.processMessage(*i) def requestPubkey(self, address): ID = "getpubkey", address if ID in self.startedWorks: return status, version, stream, ripe = addresses.decodeAddress(address) # Check if a request is already in the inventory if version == 4: secretEncryptionKey, tag = protocol.calculateAddressTag(version, stream, ripe) else: tag = ripe currentExpiryTime = None for i in inventory.Inventory().by_type_and_tag(0, tag): if currentExpiryTime is None: currentExpiryTime = i.expires else: currentExpiryTime = max(currentExpiryTime, i.expires) if currentExpiryTime is not None: helper_sql.sqlExecute(""" UPDATE "sent" SET "status" = 'awaitingpubkey', "sleeptill" = ? WHERE "status" IN ('doingpubkeypow', 'awaitingpubkey') AND "toaddress" == ? AND "folder" == 'sent'; """, currentExpiryTime, address) queues.UISignalQueue.put(("updateSentItemStatusByToAddress", ( address, tr._translate( "MainWindow", "Waiting for their encryption key. Will request it again soon." ) ))) return debug.logger.info("Making request for version %s pubkey with tag: %s", version, binascii.hexlify(tag)) TTL = randomizeTTL(28 * 24 * 60 * 60) expiryTime = int(time.time() + TTL) headlessPayload = struct.pack(">I", 0) headlessPayload += addresses.encodeVarint(version) headlessPayload += addresses.encodeVarint(stream) headlessPayload += tag def workDone(nonce, expiryTime): # TODO: adding to the inventory and setting the sent status should be within a single SQL transaction disseminateObject(nonce, expiryTime, headlessPayload, 0, stream, tag) sleepTill = int(time.time() + TTL * 1.1) helper_sql.sqlExecute(""" UPDATE "sent" SET "status" = 'awaitingpubkey', "sleeptill" = ?, "lastactiontime" = ? WHERE "status" IN ('doingpubkeypow', 'awaitingpubkey') AND "toaddress" == ? AND "folder" == 'sent'; """, sleepTill, int(time.time()), address) queues.UISignalQueue.put(("updateSentItemStatusByToAddress", ( address, tr._translate( "MainWindow", "Sending public key request. Waiting for reply. Requested at %1" ).arg(l10n.formatTimestamp()) ))) helper_sql.sqlExecute(""" UPDATE "sent" SET "status" = 'doingpubkeypow' WHERE "status" == 'awaitingpubkey' AND "toaddress" == ? AND "folder" == 'sent'; """, address) queues.UISignalQueue.put(("updateSentItemStatusByToAddress", ( address, tr._translate( "MainWindow", "Doing work necessary to request encryption key." ) ))) self.startWork( ID, headlessPayload, TTL, expiryTime, defaults.networkDefaultProofOfWorkNonceTrialsPerByte, defaults.networkDefaultPayloadLengthExtraBytes, "(For getpubkey message)".format(version), workDone )