New POW calculation module #1284
|
@ -918,7 +918,7 @@ def loadSent():
|
|||
# Set status string
|
||||
if status == "awaitingpubkey":
|
||||
statstr = "Waiting for their public key. Will request it again soon"
|
||||
elif status == "doingpowforpubkey":
|
||||
elif status == "doingpubkeypow":
|
||||
statstr = "Encryption key request queued"
|
||||
elif status == "msgqueued":
|
||||
statstr = "Message queued"
|
||||
|
|
|
@ -201,7 +201,6 @@ class Main:
|
|||
smtpServerThread = smtpServer()
|
||||
smtpServerThread.start()
|
||||
|
||||
# Start the thread that calculates POWs
|
||||
objectProcessorThread = objectProcessor()
|
||||
# DON'T close the main program even the thread remains.
|
||||
# This thread checks the shutdown variable after processing
|
||||
|
@ -430,7 +429,7 @@ if __name__ == "__main__":
|
|||
from class_sqlThread import sqlThread
|
||||
from class_singleCleaner import singleCleaner
|
||||
from class_objectProcessor import objectProcessor
|
||||
from class_singleWorker import singleWorker
|
||||
from singleworker import singleWorker
|
||||
from class_addressGenerator import addressGenerator
|
||||
from bmconfigparser import BMConfigParser
|
||||
|
||||
|
|
|
@ -44,7 +44,6 @@ from account import (
|
|||
getSortedAccounts, getSortedSubscriptions, accountClass, BMAccount,
|
||||
GatewayAccount, MailchuckAccount, AccountColor)
|
||||
import dialogs
|
||||
from helper_generic import powQueueSize
|
||||
from network.stats import pendingDownload, pendingUpload
|
||||
from uisignaler import UISignaler
|
||||
import knownnodes
|
||||
|
@ -760,6 +759,8 @@ class MyForm(settingsmixin.SMainWindow):
|
|||
"newVersionAvailable(PyQt_PyObject)"), self.newVersionAvailable)
|
||||
QtCore.QObject.connect(self.UISignalThread, QtCore.SIGNAL(
|
||||
"displayAlert(PyQt_PyObject,PyQt_PyObject,PyQt_PyObject)"), self.displayAlert)
|
||||
QtCore.QObject.connect(self.UISignalThread, QtCore.SIGNAL(
|
||||
"updateWorkProverStatus(PyQt_PyObject)"), self.updateWorkProverStatus)
|
||||
self.UISignalThread.start()
|
||||
|
||||
# Key press in tree view
|
||||
|
@ -809,6 +810,8 @@ class MyForm(settingsmixin.SMainWindow):
|
|||
' Fetch Namecoin ID button')
|
||||
self.ui.pushButtonFetchNamecoinID.hide()
|
||||
|
||||
self.POWTasksCount = 0
|
||||
|
||||
def updateTTL(self, sliderPosition):
|
||||
TTL = int(sliderPosition ** 3.199 + 3600)
|
||||
self.updateHumanFriendlyTTLDescription(TTL)
|
||||
|
@ -1036,7 +1039,7 @@ class MyForm(settingsmixin.SMainWindow):
|
|||
if status == 'awaitingpubkey':
|
||||
statusText = _translate(
|
||||
"MainWindow", "Waiting for their encryption key. Will request it again soon.")
|
||||
elif status == 'doingpowforpubkey':
|
||||
elif status == 'doingpubkeypow':
|
||||
statusText = _translate(
|
||||
"MainWindow", "Doing work necessary to request encryption key.")
|
||||
elif status == 'msgqueued':
|
||||
|
@ -1790,6 +1793,9 @@ class MyForm(settingsmixin.SMainWindow):
|
|||
if exitAfterUserClicksOk:
|
||||
os._exit(0)
|
||||
|
||||
def updateWorkProverStatus(self, status):
|
||||
self.POWTasksCount = status[3]
|
||||
|
||||
def rerenderMessagelistFromLabels(self):
|
||||
for messagelist in (self.ui.tableWidgetInbox, self.ui.tableWidgetInboxChans, self.ui.tableWidgetInboxSubscriptions):
|
||||
for i in range(messagelist.rowCount()):
|
||||
|
@ -2712,9 +2718,9 @@ class MyForm(settingsmixin.SMainWindow):
|
|||
waitForSync = False
|
||||
|
||||
# C PoW currently doesn't support interrupting and OpenCL is untested
|
||||
if getPowType() == "python" and (powQueueSize() > 0 or pendingUpload() > 0):
|
||||
if getPowType() == "python" and (self.POWTasksCount > 0 or pendingUpload() > 0):
|
||||
reply = QtGui.QMessageBox.question(self, _translate("MainWindow", "Proof of work pending"),
|
||||
_translate("MainWindow", "%n object(s) pending proof of work", None, QtCore.QCoreApplication.CodecForTr, powQueueSize()) + ", " +
|
||||
_translate("MainWindow", "%n object(s) pending proof of work", None, QtCore.QCoreApplication.CodecForTr, self.POWTasksCount) + ", " +
|
||||
_translate("MainWindow", "%n object(s) waiting to be distributed", None, QtCore.QCoreApplication.CodecForTr, pendingUpload()) + "\n\n" +
|
||||
_translate("MainWindow", "Wait until these tasks finish?"),
|
||||
QtGui.QMessageBox.Yes|QtGui.QMessageBox.No|QtGui.QMessageBox.Cancel, QtGui.QMessageBox.Cancel)
|
||||
|
@ -2770,10 +2776,10 @@ class MyForm(settingsmixin.SMainWindow):
|
|||
if waitForPow:
|
||||
# check if PoW queue empty
|
||||
maxWorkerQueue = 0
|
||||
curWorkerQueue = powQueueSize()
|
||||
curWorkerQueue = self.POWTasksCount
|
||||
while curWorkerQueue > 0:
|
||||
# worker queue size
|
||||
curWorkerQueue = powQueueSize()
|
||||
curWorkerQueue = self.POWTasksCount
|
||||
if curWorkerQueue > maxWorkerQueue:
|
||||
maxWorkerQueue = curWorkerQueue
|
||||
if curWorkerQueue > 0:
|
||||
|
|
|
@ -74,6 +74,8 @@ class UISignaler(QThread):
|
|||
elif command == 'alert':
|
||||
title, text, exitAfterUserClicksOk = data
|
||||
self.emit(SIGNAL("displayAlert(PyQt_PyObject, PyQt_PyObject, PyQt_PyObject)"), title, text, exitAfterUserClicksOk)
|
||||
elif command == "updateWorkProverStatus":
|
||||
self.emit(SIGNAL("updateWorkProverStatus(PyQt_PyObject)"), data)
|
||||
else:
|
||||
sys.stderr.write(
|
||||
'Command sent to UISignaler not recognized: %s\n' % command)
|
||||
|
|
|
@ -201,12 +201,10 @@ class addressGenerator(threading.Thread, StoppableThread):
|
|||
queues.UISignalQueue.put(('writeNewAddressToTable', (
|
||||
label, address, streamNumber)))
|
||||
shared.reloadMyAddressHashes()
|
||||
if addressVersionNumber == 3:
|
||||
queues.workerQueue.put((
|
||||
'sendOutOrStoreMyV3Pubkey', ripe.digest()))
|
||||
elif addressVersionNumber == 4:
|
||||
queues.workerQueue.put((
|
||||
'sendOutOrStoreMyV4Pubkey', address))
|
||||
|
||||
# If this is a chan address, the worker thread won't send out the pubkey over the network
|
||||
|
||||
queues.workerQueue.put(("sendMyPubkey", address))
|
||||
|
||||
elif command == 'createDeterministicAddresses' \
|
||||
or command == 'getDeterministicAddress' \
|
||||
|
@ -366,15 +364,11 @@ class addressGenerator(threading.Thread, StoppableThread):
|
|||
encodeVarint(streamNumber) + ripe.digest()
|
||||
).digest()).digest()[32:]
|
||||
shared.myAddressesByTag[tag] = address
|
||||
if addressVersionNumber == 3:
|
||||
# If this is a chan address,
|
||||
# the worker thread won't send out
|
||||
# the pubkey over the network.
|
||||
queues.workerQueue.put((
|
||||
'sendOutOrStoreMyV3Pubkey', ripe.digest()))
|
||||
elif addressVersionNumber == 4:
|
||||
queues.workerQueue.put((
|
||||
'sendOutOrStoreMyV4Pubkey', address))
|
||||
|
||||
# If this is a chan address, the worker thread won't send out the pubkey over the network
|
||||
|
||||
queues.workerQueue.put(("sendMyPubkey", address))
|
||||
|
||||
queues.UISignalQueue.put((
|
||||
'updateStatusBar',
|
||||
tr._translate(
|
||||
|
|
|
@ -114,30 +114,29 @@ class objectProcessor(threading.Thread):
|
|||
break
|
||||
|
||||
def checkackdata(self, data):
|
||||
# Let's check whether this is a message acknowledgement bound for us.
|
||||
if len(data) < 32:
|
||||
ackData = data[16: ]
|
||||
|
||||
if len(ackData) < 16 or ackData not in state.watchedAckData:
|
||||
logger.debug("This object is not an acknowledgement bound for us")
|
||||
|
||||
return
|
||||
|
||||
# bypass nonce and time, retain object type/version/stream + body
|
||||
readPosition = 16
|
||||
logger.info("This object is an acknowledgement bound for us")
|
||||
|
||||
if data[readPosition:] in shared.ackdataForWhichImWatching:
|
||||
logger.info('This object is an acknowledgement bound for me.')
|
||||
del shared.ackdataForWhichImWatching[data[readPosition:]]
|
||||
sqlExecute(
|
||||
'UPDATE sent SET status=?, lastactiontime=?'
|
||||
' WHERE ackdata=?',
|
||||
'ackreceived', int(time.time()), data[readPosition:])
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata',
|
||||
(data[readPosition:],
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Acknowledgement of the message received %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
else:
|
||||
logger.debug('This object is not an acknowledgement bound for me.')
|
||||
state.watchedAckData -= {ackData}
|
||||
|
||||
sqlExecute("""
|
||||
UPDATE "sent" SET "status" = 'ackreceived', "lastactiontime" = ?
|
||||
WHERE "status" IN ('doingmsgpow', 'msgsent') AND "ackdata" == ?;
|
||||
""", int(time.time()), ackData)
|
||||
|
||||
queues.UISignalQueue.put(("updateSentItemStatusByAckdata", (
|
||||
ackData,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Acknowledgement of the message received %1"
|
||||
).arg(l10n.formatTimestamp())
|
||||
)))
|
||||
|
||||
def processgetpubkey(self, data):
|
||||
if len(data) > 200:
|
||||
|
@ -237,12 +236,8 @@ class objectProcessor(threading.Thread):
|
|||
'Found getpubkey-requested-hash in my list of EC hashes.'
|
||||
' Telling Worker thread to do the POW for a pubkey message'
|
||||
' and send it out.')
|
||||
if requestedAddressVersionNumber == 2:
|
||||
queues.workerQueue.put(('doPOWForMyV2Pubkey', requestedHash))
|
||||
elif requestedAddressVersionNumber == 3:
|
||||
queues.workerQueue.put(('sendOutOrStoreMyV3Pubkey', requestedHash))
|
||||
elif requestedAddressVersionNumber == 4:
|
||||
queues.workerQueue.put(('sendOutOrStoreMyV4Pubkey', myAddress))
|
||||
|
||||
queues.workerQueue.put(("sendMyPubkey", myAddress))
|
||||
|
||||
def processpubkey(self, data):
|
||||
pubkeyProcessingStartTime = time.time()
|
||||
|
@ -396,20 +391,23 @@ class objectProcessor(threading.Thread):
|
|||
' Sanity check failed.')
|
||||
return
|
||||
|
||||
tag = data[readPosition:readPosition + 32]
|
||||
if tag not in state.neededPubkeys:
|
||||
logger.info(
|
||||
'We don\'t need this v4 pubkey. We didn\'t ask for it.')
|
||||
return
|
||||
tag = data[readPosition: readPosition + 32]
|
||||
attributes = state.neededPubkeys.get(tag, None)
|
||||
|
||||
# Let us try to decrypt the pubkey
|
||||
toAddress, _ = state.neededPubkeys[tag]
|
||||
if shared.decryptAndCheckPubkeyPayload(data, toAddress) == \
|
||||
'successful':
|
||||
# At this point we know that we have been waiting on this
|
||||
# pubkey. This function will command the workerThread
|
||||
# to start work on the messages that require it.
|
||||
self.possibleNewPubkey(toAddress)
|
||||
if attributes is None:
|
||||
logger.info("We don't need this v4 pubkey. We didn't ask for it")
|
||||
else:
|
||||
address, cryptor = attributes
|
||||
|
||||
storedData = protocol.decryptAndCheckV4Pubkey(data, address, cryptor)
|
||||
|
||||
if storedData is not None:
|
||||
sqlExecute("""
|
||||
INSERT INTO "pubkeys" ("address", "addressversion", "transmitdata", "time", "usedpersonally")
|
||||
VALUES (?, 4, ?, ?, 'yes');
|
||||
""", address, storedData, int(time.time()))
|
||||
|
||||
self.possibleNewPubkey(address)
|
||||
|
||||
# Display timing data
|
||||
timeRequiredToProcessPubkey = time.time(
|
||||
|
@ -608,7 +606,7 @@ class objectProcessor(threading.Thread):
|
|||
# If the toAddress version number is 3 or higher and not one of
|
||||
# my chan addresses:
|
||||
if decodeAddress(toAddress)[1] >= 3 \
|
||||
and not BMConfigParser().safeGetBoolean(toAddress, 'chan'):
|
||||
and not BMConfigParser().has_section(toAddress):
|
||||
# If I'm not friendly with this person:
|
||||
if not shared.isAddressInMyAddressBookSubscriptionsListOrWhitelist(fromAddress):
|
||||
requiredNonceTrialsPerByte = BMConfigParser().getint(
|
||||
|
@ -1015,42 +1013,42 @@ class objectProcessor(threading.Thread):
|
|||
have been waiting for. Let's check.
|
||||
"""
|
||||
|
||||
# For address versions <= 3, we wait on a key with the correct
|
||||
# address version, stream number and RIPE hash.
|
||||
_, addressVersion, streamNumber, ripe = decodeAddress(address)
|
||||
if addressVersion <= 3:
|
||||
if address in state.neededPubkeys:
|
||||
del state.neededPubkeys[address]
|
||||
self.sendMessages(address)
|
||||
else:
|
||||
logger.debug(
|
||||
'We don\'t need this pub key. We didn\'t ask for it.'
|
||||
' For address: %s', address)
|
||||
# For address versions >= 4, we wait on a pubkey with the correct tag.
|
||||
# Let us create the tag from the address and see if we were waiting
|
||||
# for it.
|
||||
elif addressVersion >= 4:
|
||||
tag = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(addressVersion) + encodeVarint(streamNumber)
|
||||
+ ripe).digest()
|
||||
).digest()[32:]
|
||||
if tag in state.neededPubkeys:
|
||||
del state.neededPubkeys[tag]
|
||||
self.sendMessages(address)
|
||||
status, version, stream, ripe = decodeAddress(address)
|
||||
|
||||
def sendMessages(self, address):
|
||||
"""
|
||||
This function is called by the possibleNewPubkey function when
|
||||
that function sees that we now have the necessary pubkey
|
||||
to send one or more messages.
|
||||
"""
|
||||
logger.info('We have been awaiting the arrival of this pubkey.')
|
||||
sqlExecute(
|
||||
"UPDATE sent SET status='doingmsgpow', retrynumber=0"
|
||||
" WHERE toaddress=?"
|
||||
" AND (status='awaitingpubkey' OR status='doingpubkeypow')"
|
||||
" AND folder='sent'", address)
|
||||
queues.workerQueue.put(('sendmessage', ''))
|
||||
if version <= 3:
|
||||
needed = address in state.neededPubkeys
|
||||
state.neededPubkeys.pop(address, None)
|
||||
elif version == 4:
|
||||
secretEncryptionKey, tag = protocol.calculateAddressTag(version, stream, ripe)
|
||||
|
||||
needed = tag in state.neededPubkeys
|
||||
state.neededPubkeys.pop(tag, None)
|
||||
|
||||
if needed:
|
||||
logger.info("We have been awaiting the arrival of this pubkey")
|
||||
|
||||
sqlExecute("""
|
||||
UPDATE "sent" SET "status" = 'msgqueued'
|
||||
WHERE "status" IN ('doingpubkeypow', 'awaitingpubkey') AND "toaddress" == ? AND "folder" == 'sent';
|
||||
""", address)
|
||||
|
||||
queues.workerQueue.put(("sendmessage", ))
|
||||
|
||||
queued = 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."
|
||||
)
|
||||
)))
|
||||
else:
|
||||
logger.debug("We don't need this pubkey, we didn't ask for it: %s", address)
|
||||
|
||||
def ackDataHasAValidHeader(self, ackData):
|
||||
if len(ackData) < protocol.Header.size:
|
||||
|
|
|
@ -35,6 +35,44 @@ import knownnodes
|
|||
import queues
|
||||
import state
|
||||
|
||||
def resendStaleMessages():
|
||||
staleMessages = sqlQuery("""
|
||||
SELECT "toaddress", "ackdata", "status" FROM "sent"
|
||||
|
||||
WHERE "status" IN ('awaitingpubkey', 'msgsent') AND "sleeptill" < ? AND "senttime" > ? AND "folder" == 'sent';
|
||||
""", int(time.time()), int(time.time()) - shared.maximumLengthOfTimeToBotherResendingMessages)
|
||||
|
||||
resendMessages = False
|
||||
|
||||
for destination, ackData, status in staleMessages:
|
||||
if status == "awaitingpubkey":
|
||||
logger.info("Retrying getpubkey request for %s", destination)
|
||||
|
||||
sqlExecute("""
|
||||
UPDATE "sent" SET "status" = 'msgqueued'
|
||||
WHERE "status" == 'awaitingpubkey' AND "ackdata" == ?;
|
||||
""", ackData)
|
||||
elif status == "msgsent":
|
||||
state.watchedAckData -= {ackData}
|
||||
|
||||
sqlExecute("""
|
||||
UPDATE "sent" SET "status" = 'msgqueued'
|
||||
WHERE "status" == 'msgsent' AND "ackdata" == ?;
|
||||
""", ackData)
|
||||
|
||||
queues.UISignalQueue.put(("updateSentItemStatusByAckdata", (
|
||||
ackData,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Queued."
|
||||
)
|
||||
)))
|
||||
|
||||
resendMessages = True
|
||||
|
||||
if resendMessages:
|
||||
logger.info("Resending old messages with undelivered acks or unknown pubkeys")
|
||||
|
||||
queues.workerQueue.put(("sendmessage", ))
|
||||
|
||||
class singleCleaner(threading.Thread, StoppableThread):
|
||||
cycleLength = 300
|
||||
|
@ -92,28 +130,8 @@ class singleCleaner(threading.Thread, StoppableThread):
|
|||
# Let us resend getpubkey objects if we have not yet heard
|
||||
# a pubkey, and also msg objects if we have not yet heard
|
||||
# an acknowledgement
|
||||
queryreturn = sqlQuery(
|
||||
"SELECT toaddress, ackdata, status FROM sent"
|
||||
" WHERE ((status='awaitingpubkey' OR status='msgsent')"
|
||||
" AND folder='sent' AND sleeptill<? AND senttime>?)",
|
||||
int(time.time()),
|
||||
int(time.time())
|
||||
- shared.maximumLengthOfTimeToBotherResendingMessages
|
||||
)
|
||||
for row in queryreturn:
|
||||
if len(row) < 2:
|
||||
logger.error(
|
||||
'Something went wrong in the singleCleaner thread:'
|
||||
' a query did not return the requested fields. %r',
|
||||
row
|
||||
)
|
||||
self.stop.wait(3)
|
||||
break
|
||||
toAddress, ackData, status = row
|
||||
if status == 'awaitingpubkey':
|
||||
resendPubkeyRequest(toAddress)
|
||||
elif status == 'msgsent':
|
||||
resendMsg(ackData)
|
||||
|
||||
resendStaleMessages()
|
||||
|
||||
# cleanup old nodes
|
||||
now = int(time.time())
|
||||
|
@ -189,41 +207,3 @@ class singleCleaner(threading.Thread, StoppableThread):
|
|||
|
||||
if state.shutdown == 0:
|
||||
self.stop.wait(singleCleaner.cycleLength)
|
||||
|
||||
|
||||
def resendPubkeyRequest(address):
|
||||
logger.debug(
|
||||
'It has been a long time and we haven\'t heard a response to our'
|
||||
' getpubkey request. Sending again.'
|
||||
)
|
||||
try:
|
||||
# We need to take this entry out of the neededPubkeys structure
|
||||
# because the queues.workerQueue checks to see whether the entry
|
||||
# is already present and will not do the POW and send the message
|
||||
# because it assumes that it has already done it recently.
|
||||
del state.neededPubkeys[address]
|
||||
except:
|
||||
pass
|
||||
|
||||
queues.UISignalQueue.put((
|
||||
'updateStatusBar',
|
||||
'Doing work necessary to again attempt to request a public key...'))
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='msgqueued' WHERE toaddress=?''',
|
||||
address)
|
||||
queues.workerQueue.put(('sendmessage', ''))
|
||||
|
||||
|
||||
def resendMsg(ackdata):
|
||||
logger.debug(
|
||||
'It has been a long time and we haven\'t heard an acknowledgement'
|
||||
' to our msg. Sending again.'
|
||||
)
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='msgqueued' WHERE ackdata=?''',
|
||||
ackdata)
|
||||
queues.workerQueue.put(('sendmessage', ''))
|
||||
queues.UISignalQueue.put((
|
||||
'updateStatusBar',
|
||||
'Doing work necessary to again attempt to deliver a message...'
|
||||
))
|
||||
|
|
|
@ -1,1418 +0,0 @@
|
|||
from __future__ import division
|
||||
|
||||
import time
|
||||
import threading
|
||||
import hashlib
|
||||
from struct import pack
|
||||
# used when the API must execute an outside program
|
||||
from subprocess import call # nosec
|
||||
from binascii import hexlify, unhexlify
|
||||
|
||||
import tr
|
||||
import l10n
|
||||
import protocol
|
||||
import queues
|
||||
import state
|
||||
import shared
|
||||
import defaults
|
||||
import highlevelcrypto
|
||||
import proofofwork
|
||||
import helper_inbox
|
||||
import helper_random
|
||||
import helper_msgcoding
|
||||
from bmconfigparser import BMConfigParser
|
||||
from debug import logger
|
||||
from inventory import Inventory
|
||||
from addresses import (
|
||||
decodeAddress, encodeVarint, decodeVarint, calculateInventoryHash
|
||||
)
|
||||
# from helper_generic import addDataPadding
|
||||
from helper_threading import StoppableThread
|
||||
from helper_sql import sqlQuery, sqlExecute
|
||||
|
||||
|
||||
# This thread, of which there is only one, does the heavy lifting:
|
||||
# calculating POWs.
|
||||
|
||||
def sizeof_fmt(num, suffix='h/s'):
|
||||
for unit in ['', 'k', 'M', 'G', 'T', 'P', 'E', 'Z']:
|
||||
if abs(num) < 1000.0:
|
||||
return "%3.1f%s%s" % (num, unit, suffix)
|
||||
num /= 1024.0
|
||||
return "%.1f%s%s" % (num, 'Yi', suffix)
|
||||
|
||||
|
||||
class singleWorker(threading.Thread, StoppableThread):
|
||||
|
||||
def __init__(self):
|
||||
# QThread.__init__(self, parent)
|
||||
threading.Thread.__init__(self, name="singleWorker")
|
||||
self.initStop()
|
||||
proofofwork.init()
|
||||
|
||||
def stopThread(self):
|
||||
try:
|
||||
queues.workerQueue.put(("stopThread", "data"))
|
||||
except:
|
||||
pass
|
||||
super(singleWorker, self).stopThread()
|
||||
|
||||
def run(self):
|
||||
|
||||
while not state.sqlReady and state.shutdown == 0:
|
||||
self.stop.wait(2)
|
||||
if state.shutdown > 0:
|
||||
return
|
||||
|
||||
# Initialize the neededPubkeys dictionary.
|
||||
queryreturn = sqlQuery(
|
||||
'''SELECT DISTINCT toaddress FROM sent'''
|
||||
''' WHERE (status='awaitingpubkey' AND folder='sent')''')
|
||||
for row in queryreturn:
|
||||
toAddress, = row
|
||||
# toStatus
|
||||
_, toAddressVersionNumber, toStreamNumber, toRipe = \
|
||||
decodeAddress(toAddress)
|
||||
if toAddressVersionNumber <= 3:
|
||||
state.neededPubkeys[toAddress] = 0
|
||||
elif toAddressVersionNumber >= 4:
|
||||
doubleHashOfAddressData = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(toAddressVersionNumber) +
|
||||
encodeVarint(toStreamNumber) + toRipe
|
||||
).digest()).digest()
|
||||
# Note that this is the first half of the sha512 hash.
|
||||
privEncryptionKey = doubleHashOfAddressData[:32]
|
||||
tag = doubleHashOfAddressData[32:]
|
||||
# We'll need this for when we receive a pubkey reply:
|
||||
# it will be encrypted and we'll need to decrypt it.
|
||||
state.neededPubkeys[tag] = (
|
||||
toAddress,
|
||||
highlevelcrypto.makeCryptor(
|
||||
hexlify(privEncryptionKey))
|
||||
)
|
||||
|
||||
# Initialize the shared.ackdataForWhichImWatching data structure
|
||||
queryreturn = sqlQuery(
|
||||
'''SELECT ackdata FROM sent WHERE status = 'msgsent' ''')
|
||||
for row in queryreturn:
|
||||
ackdata, = row
|
||||
logger.info('Watching for ackdata ' + hexlify(ackdata))
|
||||
shared.ackdataForWhichImWatching[ackdata] = 0
|
||||
|
||||
# Fix legacy (headerless) watched ackdata to include header
|
||||
for oldack in shared.ackdataForWhichImWatching.keys():
|
||||
if (len(oldack) == 32):
|
||||
# attach legacy header, always constant (msg/1/1)
|
||||
newack = '\x00\x00\x00\x02\x01\x01' + oldack
|
||||
shared.ackdataForWhichImWatching[newack] = 0
|
||||
sqlExecute(
|
||||
'UPDATE sent SET ackdata=? WHERE ackdata=?',
|
||||
newack, oldack
|
||||
)
|
||||
del shared.ackdataForWhichImWatching[oldack]
|
||||
|
||||
# give some time for the GUI to start
|
||||
# before we start on existing POW tasks.
|
||||
self.stop.wait(10)
|
||||
|
||||
if state.shutdown == 0:
|
||||
# just in case there are any pending tasks for msg
|
||||
# messages that have yet to be sent.
|
||||
queues.workerQueue.put(('sendmessage', ''))
|
||||
# just in case there are any tasks for Broadcasts
|
||||
# that have yet to be sent.
|
||||
queues.workerQueue.put(('sendbroadcast', ''))
|
||||
|
||||
while state.shutdown == 0:
|
||||
self.busy = 0
|
||||
command, data = queues.workerQueue.get()
|
||||
self.busy = 1
|
||||
if command == 'sendmessage':
|
||||
try:
|
||||
self.sendMsg()
|
||||
except:
|
||||
pass
|
||||
elif command == 'sendbroadcast':
|
||||
try:
|
||||
self.sendBroadcast()
|
||||
except:
|
||||
pass
|
||||
elif command == 'doPOWForMyV2Pubkey':
|
||||
try:
|
||||
self.doPOWForMyV2Pubkey(data)
|
||||
except:
|
||||
pass
|
||||
elif command == 'sendOutOrStoreMyV3Pubkey':
|
||||
try:
|
||||
self.sendOutOrStoreMyV3Pubkey(data)
|
||||
except:
|
||||
pass
|
||||
elif command == 'sendOutOrStoreMyV4Pubkey':
|
||||
try:
|
||||
self.sendOutOrStoreMyV4Pubkey(data)
|
||||
except:
|
||||
pass
|
||||
elif command == 'resetPoW':
|
||||
try:
|
||||
proofofwork.resetPoW()
|
||||
except:
|
||||
pass
|
||||
elif command == 'stopThread':
|
||||
self.busy = 0
|
||||
return
|
||||
else:
|
||||
logger.error(
|
||||
'Probable programming error: The command sent'
|
||||
' to the workerThread is weird. It is: %s\n',
|
||||
command
|
||||
)
|
||||
|
||||
queues.workerQueue.task_done()
|
||||
logger.info("Quitting...")
|
||||
|
||||
def _getKeysForAddress(self, address):
|
||||
privSigningKeyBase58 = BMConfigParser().get(
|
||||
address, 'privsigningkey')
|
||||
privEncryptionKeyBase58 = BMConfigParser().get(
|
||||
address, 'privencryptionkey')
|
||||
|
||||
privSigningKeyHex = hexlify(shared.decodeWalletImportFormat(
|
||||
privSigningKeyBase58))
|
||||
privEncryptionKeyHex = hexlify(shared.decodeWalletImportFormat(
|
||||
privEncryptionKeyBase58))
|
||||
|
||||
# The \x04 on the beginning of the public keys are not sent.
|
||||
# This way there is only one acceptable way to encode
|
||||
# and send a public key.
|
||||
pubSigningKey = unhexlify(highlevelcrypto.privToPub(
|
||||
privSigningKeyHex))[1:]
|
||||
pubEncryptionKey = unhexlify(highlevelcrypto.privToPub(
|
||||
privEncryptionKeyHex))[1:]
|
||||
|
||||
return privSigningKeyHex, privEncryptionKeyHex, \
|
||||
pubSigningKey, pubEncryptionKey
|
||||
|
||||
def _doPOWDefaults(self, payload, TTL,
|
||||
log_prefix='',
|
||||
log_time=False):
|
||||
target = 2 ** 64 / (
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte * (
|
||||
len(payload) + 8 +
|
||||
defaults.networkDefaultPayloadLengthExtraBytes + ((
|
||||
TTL * (
|
||||
len(payload) + 8 +
|
||||
defaults.networkDefaultPayloadLengthExtraBytes
|
||||
)) / (2 ** 16))
|
||||
))
|
||||
initialHash = hashlib.sha512(payload).digest()
|
||||
logger.info(
|
||||
'%s Doing proof of work... TTL set to %s', log_prefix, TTL)
|
||||
if log_time:
|
||||
start_time = time.time()
|
||||
trialValue, nonce = proofofwork.run(target, initialHash)
|
||||
logger.info(
|
||||
'%s Found proof of work %s Nonce: %s',
|
||||
log_prefix, trialValue, nonce
|
||||
)
|
||||
try:
|
||||
delta = time.time() - start_time
|
||||
logger.info(
|
||||
'PoW took %.1f seconds, speed %s.',
|
||||
delta, sizeof_fmt(nonce / delta)
|
||||
)
|
||||
except: # NameError
|
||||
pass
|
||||
payload = pack('>Q', nonce) + payload
|
||||
# inventoryHash = calculateInventoryHash(payload)
|
||||
return payload
|
||||
|
||||
# This function also broadcasts out the pubkey message
|
||||
# once it is done with the POW
|
||||
def doPOWForMyV2Pubkey(self, adressHash):
|
||||
# Look up my stream number based on my address hash
|
||||
"""configSections = shared.config.addresses()
|
||||
for addressInKeysFile in configSections:
|
||||
if addressInKeysFile != 'bitmessagesettings':
|
||||
status, addressVersionNumber, streamNumber, \
|
||||
hashFromThisParticularAddress = \
|
||||
decodeAddress(addressInKeysFile)
|
||||
if hash == hashFromThisParticularAddress:
|
||||
myAddress = addressInKeysFile
|
||||
break"""
|
||||
myAddress = shared.myAddressesByHash[adressHash]
|
||||
# status
|
||||
_, addressVersionNumber, streamNumber, adressHash = decodeAddress(myAddress)
|
||||
|
||||
# 28 days from now plus or minus five minutes
|
||||
TTL = int(28 * 24 * 60 * 60 + helper_random.randomrandrange(-300, 300))
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
payload = pack('>Q', (embeddedTime))
|
||||
payload += '\x00\x00\x00\x01' # object type: pubkey
|
||||
payload += encodeVarint(addressVersionNumber) # Address version number
|
||||
payload += encodeVarint(streamNumber)
|
||||
# bitfield of features supported by me (see the wiki).
|
||||
payload += protocol.getBitfield(myAddress)
|
||||
|
||||
try:
|
||||
# privSigningKeyHex, privEncryptionKeyHex
|
||||
_, _, pubSigningKey, pubEncryptionKey = \
|
||||
self._getKeysForAddress(myAddress)
|
||||
except Exception as err:
|
||||
logger.error(
|
||||
'Error within doPOWForMyV2Pubkey. Could not read'
|
||||
' the keys from the keys.dat file for a requested'
|
||||
' address. %s\n', err
|
||||
)
|
||||
return
|
||||
|
||||
payload += pubSigningKey + pubEncryptionKey
|
||||
|
||||
# Do the POW for this pubkey message
|
||||
payload = self._doPOWDefaults(
|
||||
payload, TTL, log_prefix='(For pubkey message)')
|
||||
|
||||
inventoryHash = calculateInventoryHash(payload)
|
||||
objectType = 1
|
||||
Inventory()[inventoryHash] = (
|
||||
objectType, streamNumber, payload, embeddedTime, '')
|
||||
|
||||
logger.info('broadcasting inv with hash: %s', hexlify(inventoryHash))
|
||||
|
||||
queues.invQueue.put((streamNumber, inventoryHash))
|
||||
queues.UISignalQueue.put(('updateStatusBar', ''))
|
||||
try:
|
||||
BMConfigParser().set(
|
||||
myAddress, 'lastpubkeysendtime', str(int(time.time())))
|
||||
BMConfigParser().save()
|
||||
except:
|
||||
# The user deleted the address out of the keys.dat file
|
||||
# before this finished.
|
||||
pass
|
||||
|
||||
# If this isn't a chan address, this function assembles the pubkey data,
|
||||
# does the necessary POW and sends it out. If it *is* a chan then it
|
||||
# assembles the pubkey and stores is in the pubkey table so that we can
|
||||
# send messages to "ourselves".
|
||||
def sendOutOrStoreMyV3Pubkey(self, adressHash):
|
||||
try:
|
||||
myAddress = shared.myAddressesByHash[adressHash]
|
||||
except:
|
||||
# The address has been deleted.
|
||||
return
|
||||
if BMConfigParser().safeGetBoolean(myAddress, 'chan'):
|
||||
logger.info('This is a chan address. Not sending pubkey.')
|
||||
return
|
||||
_, addressVersionNumber, streamNumber, adressHash = decodeAddress(
|
||||
myAddress)
|
||||
|
||||
# 28 days from now plus or minus five minutes
|
||||
TTL = int(28 * 24 * 60 * 60 + helper_random.randomrandrange(-300, 300))
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
|
||||
# signedTimeForProtocolV2 = embeddedTime - TTL
|
||||
# According to the protocol specification, the expiresTime
|
||||
# along with the pubkey information is signed. But to be
|
||||
# backwards compatible during the upgrade period, we shall sign
|
||||
# not the expiresTime but rather the current time. There must be
|
||||
# precisely a 28 day difference between the two. After the upgrade
|
||||
# period we'll switch to signing the whole payload with the
|
||||
# expiresTime time.
|
||||
|
||||
payload = pack('>Q', (embeddedTime))
|
||||
payload += '\x00\x00\x00\x01' # object type: pubkey
|
||||
payload += encodeVarint(addressVersionNumber) # Address version number
|
||||
payload += encodeVarint(streamNumber)
|
||||
# bitfield of features supported by me (see the wiki).
|
||||
payload += protocol.getBitfield(myAddress)
|
||||
|
||||
try:
|
||||
# , privEncryptionKeyHex
|
||||
privSigningKeyHex, _, pubSigningKey, pubEncryptionKey = \
|
||||
self._getKeysForAddress(myAddress)
|
||||
except Exception as err:
|
||||
logger.error(
|
||||
'Error within sendOutOrStoreMyV3Pubkey. Could not read'
|
||||
' the keys from the keys.dat file for a requested'
|
||||
' address. %s\n', err
|
||||
)
|
||||
return
|
||||
|
||||
payload += pubSigningKey + pubEncryptionKey
|
||||
|
||||
payload += encodeVarint(BMConfigParser().getint(
|
||||
myAddress, 'noncetrialsperbyte'))
|
||||
payload += encodeVarint(BMConfigParser().getint(
|
||||
myAddress, 'payloadlengthextrabytes'))
|
||||
|
||||
signature = highlevelcrypto.sign(payload, privSigningKeyHex)
|
||||
payload += encodeVarint(len(signature))
|
||||
payload += signature
|
||||
|
||||
# Do the POW for this pubkey message
|
||||
payload = self._doPOWDefaults(
|
||||
payload, TTL, log_prefix='(For pubkey message)')
|
||||
|
||||
inventoryHash = calculateInventoryHash(payload)
|
||||
objectType = 1
|
||||
Inventory()[inventoryHash] = (
|
||||
objectType, streamNumber, payload, embeddedTime, '')
|
||||
|
||||
logger.info('broadcasting inv with hash: ' + hexlify(inventoryHash))
|
||||
|
||||
queues.invQueue.put((streamNumber, inventoryHash))
|
||||
queues.UISignalQueue.put(('updateStatusBar', ''))
|
||||
try:
|
||||
BMConfigParser().set(
|
||||
myAddress, 'lastpubkeysendtime', str(int(time.time())))
|
||||
BMConfigParser().save()
|
||||
except:
|
||||
# The user deleted the address out of the keys.dat file
|
||||
# before this finished.
|
||||
pass
|
||||
|
||||
# If this isn't a chan address, this function assembles
|
||||
# the pubkey data, does the necessary POW and sends it out.
|
||||
def sendOutOrStoreMyV4Pubkey(self, myAddress):
|
||||
if not BMConfigParser().has_section(myAddress):
|
||||
# The address has been deleted.
|
||||
return
|
||||
if shared.BMConfigParser().safeGetBoolean(myAddress, 'chan'):
|
||||
logger.info('This is a chan address. Not sending pubkey.')
|
||||
return
|
||||
_, addressVersionNumber, streamNumber, addressHash = decodeAddress(
|
||||
myAddress)
|
||||
|
||||
# 28 days from now plus or minus five minutes
|
||||
TTL = int(28 * 24 * 60 * 60 + helper_random.randomrandrange(-300, 300))
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
payload = pack('>Q', (embeddedTime))
|
||||
payload += '\x00\x00\x00\x01' # object type: pubkey
|
||||
payload += encodeVarint(addressVersionNumber) # Address version number
|
||||
payload += encodeVarint(streamNumber)
|
||||
dataToEncrypt = protocol.getBitfield(myAddress)
|
||||
|
||||
try:
|
||||
# , privEncryptionKeyHex
|
||||
privSigningKeyHex, _, pubSigningKey, pubEncryptionKey = \
|
||||
self._getKeysForAddress(myAddress)
|
||||
except Exception as err:
|
||||
logger.error(
|
||||
'Error within sendOutOrStoreMyV4Pubkey. Could not read'
|
||||
' the keys from the keys.dat file for a requested'
|
||||
' address. %s\n', err
|
||||
)
|
||||
return
|
||||
|
||||
dataToEncrypt += pubSigningKey + pubEncryptionKey
|
||||
|
||||
dataToEncrypt += encodeVarint(BMConfigParser().getint(
|
||||
myAddress, 'noncetrialsperbyte'))
|
||||
dataToEncrypt += encodeVarint(BMConfigParser().getint(
|
||||
myAddress, 'payloadlengthextrabytes'))
|
||||
|
||||
# When we encrypt, we'll use a hash of the data
|
||||
# contained in an address as a decryption key. This way
|
||||
# in order to read the public keys in a pubkey message,
|
||||
# a node must know the address first. We'll also tag,
|
||||
# unencrypted, the pubkey with part of the hash so that nodes
|
||||
# know which pubkey object to try to decrypt
|
||||
# when they want to send a message.
|
||||
doubleHashOfAddressData = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(addressVersionNumber) +
|
||||
encodeVarint(streamNumber) + addressHash
|
||||
).digest()).digest()
|
||||
payload += doubleHashOfAddressData[32:] # the tag
|
||||
signature = highlevelcrypto.sign(
|
||||
payload + dataToEncrypt, privSigningKeyHex
|
||||
)
|
||||
dataToEncrypt += encodeVarint(len(signature))
|
||||
dataToEncrypt += signature
|
||||
|
||||
privEncryptionKey = doubleHashOfAddressData[:32]
|
||||
pubEncryptionKey = highlevelcrypto.pointMult(privEncryptionKey)
|
||||
payload += highlevelcrypto.encrypt(
|
||||
dataToEncrypt, hexlify(pubEncryptionKey))
|
||||
|
||||
# Do the POW for this pubkey message
|
||||
payload = self._doPOWDefaults(
|
||||
payload, TTL, log_prefix='(For pubkey message)')
|
||||
|
||||
inventoryHash = calculateInventoryHash(payload)
|
||||
objectType = 1
|
||||
Inventory()[inventoryHash] = (
|
||||
objectType, streamNumber, payload, embeddedTime,
|
||||
doubleHashOfAddressData[32:]
|
||||
)
|
||||
|
||||
logger.info('broadcasting inv with hash: ' + hexlify(inventoryHash))
|
||||
|
||||
queues.invQueue.put((streamNumber, inventoryHash))
|
||||
queues.UISignalQueue.put(('updateStatusBar', ''))
|
||||
try:
|
||||
BMConfigParser().set(
|
||||
myAddress, 'lastpubkeysendtime', str(int(time.time())))
|
||||
BMConfigParser().save()
|
||||
except Exception as err:
|
||||
logger.error(
|
||||
'Error: Couldn\'t add the lastpubkeysendtime'
|
||||
' to the keys.dat file. Error message: %s', err
|
||||
)
|
||||
|
||||
def sendBroadcast(self):
|
||||
# Reset just in case
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='broadcastqueued' '''
|
||||
|
||||
'''WHERE status = 'doingbroadcastpow' ''')
|
||||
queryreturn = sqlQuery(
|
||||
'''SELECT fromaddress, subject, message, '''
|
||||
''' ackdata, ttl, encodingtype FROM sent '''
|
||||
''' WHERE status=? and folder='sent' ''', 'broadcastqueued')
|
||||
|
||||
for row in queryreturn:
|
||||
fromaddress, subject, body, ackdata, TTL, encoding = row
|
||||
# status
|
||||
_, addressVersionNumber, streamNumber, ripe = \
|
||||
decodeAddress(fromaddress)
|
||||
if addressVersionNumber <= 1:
|
||||
logger.error(
|
||||
'Error: In the singleWorker thread, the '
|
||||
' sendBroadcast function doesn\'t understand'
|
||||
' the address version.\n')
|
||||
return
|
||||
# We need to convert our private keys to public keys in order
|
||||
# to include them.
|
||||
try:
|
||||
# , privEncryptionKeyHex
|
||||
privSigningKeyHex, _, pubSigningKey, pubEncryptionKey = \
|
||||
self._getKeysForAddress(fromaddress)
|
||||
except:
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Error! Could not find sender address"
|
||||
" (your address) in the keys.dat file."))
|
||||
))
|
||||
continue
|
||||
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='doingbroadcastpow' '''
|
||||
''' WHERE ackdata=? AND status='broadcastqueued' ''',
|
||||
ackdata)
|
||||
|
||||
# At this time these pubkeys are 65 bytes long
|
||||
# because they include the encoding byte which we won't
|
||||
# be sending in the broadcast message.
|
||||
# pubSigningKey = \
|
||||
# highlevelcrypto.privToPub(privSigningKeyHex).decode('hex')
|
||||
|
||||
if TTL > 28 * 24 * 60 * 60:
|
||||
TTL = 28 * 24 * 60 * 60
|
||||
if TTL < 60 * 60:
|
||||
TTL = 60 * 60
|
||||
# add some randomness to the TTL
|
||||
TTL = int(TTL + helper_random.randomrandrange(-300, 300))
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
payload = pack('>Q', embeddedTime)
|
||||
payload += '\x00\x00\x00\x03' # object type: broadcast
|
||||
|
||||
if addressVersionNumber <= 3:
|
||||
payload += encodeVarint(4) # broadcast version
|
||||
else:
|
||||
payload += encodeVarint(5) # broadcast version
|
||||
|
||||
payload += encodeVarint(streamNumber)
|
||||
if addressVersionNumber >= 4:
|
||||
doubleHashOfAddressData = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(addressVersionNumber) +
|
||||
encodeVarint(streamNumber) + ripe
|
||||
).digest()).digest()
|
||||
tag = doubleHashOfAddressData[32:]
|
||||
payload += tag
|
||||
else:
|
||||
tag = ''
|
||||
|
||||
dataToEncrypt = encodeVarint(addressVersionNumber)
|
||||
dataToEncrypt += encodeVarint(streamNumber)
|
||||
# behavior bitfield
|
||||
dataToEncrypt += protocol.getBitfield(fromaddress)
|
||||
dataToEncrypt += pubSigningKey + pubEncryptionKey
|
||||
if addressVersionNumber >= 3:
|
||||
dataToEncrypt += encodeVarint(BMConfigParser().getint(
|
||||
fromaddress, 'noncetrialsperbyte'))
|
||||
dataToEncrypt += encodeVarint(BMConfigParser().getint(
|
||||
fromaddress, 'payloadlengthextrabytes'))
|
||||
# message encoding type
|
||||
dataToEncrypt += encodeVarint(encoding)
|
||||
encodedMessage = helper_msgcoding.MsgEncode(
|
||||
{"subject": subject, "body": body}, encoding)
|
||||
dataToEncrypt += encodeVarint(encodedMessage.length)
|
||||
dataToEncrypt += encodedMessage.data
|
||||
dataToSign = payload + dataToEncrypt
|
||||
|
||||
signature = highlevelcrypto.sign(
|
||||
dataToSign, privSigningKeyHex)
|
||||
dataToEncrypt += encodeVarint(len(signature))
|
||||
dataToEncrypt += signature
|
||||
|
||||
# Encrypt the broadcast with the information
|
||||
# contained in the broadcaster's address.
|
||||
# Anyone who knows the address can generate
|
||||
# the private encryption key to decrypt the broadcast.
|
||||
# This provides virtually no privacy; its purpose is to keep
|
||||
# questionable and illegal content from flowing through the
|
||||
# Internet connections and being stored on the disk of 3rd parties.
|
||||
if addressVersionNumber <= 3:
|
||||
privEncryptionKey = hashlib.sha512(
|
||||
encodeVarint(addressVersionNumber) +
|
||||
encodeVarint(streamNumber) + ripe
|
||||
).digest()[:32]
|
||||
else:
|
||||
privEncryptionKey = doubleHashOfAddressData[:32]
|
||||
|
||||
pubEncryptionKey = highlevelcrypto.pointMult(privEncryptionKey)
|
||||
payload += highlevelcrypto.encrypt(
|
||||
dataToEncrypt, hexlify(pubEncryptionKey))
|
||||
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Doing work necessary to send broadcast..."))
|
||||
))
|
||||
payload = self._doPOWDefaults(
|
||||
payload, TTL, log_prefix='(For broadcast message)')
|
||||
|
||||
# Sanity check. The payload size should never be larger
|
||||
# than 256 KiB. There should be checks elsewhere in the code
|
||||
# to not let the user try to send a message this large
|
||||
# until we implement message continuation.
|
||||
if len(payload) > 2 ** 18: # 256 KiB
|
||||
logger.critical(
|
||||
'This broadcast object is too large to send.'
|
||||
' This should never happen. Object size: %s',
|
||||
len(payload)
|
||||
)
|
||||
continue
|
||||
|
||||
inventoryHash = calculateInventoryHash(payload)
|
||||
objectType = 3
|
||||
Inventory()[inventoryHash] = (
|
||||
objectType, streamNumber, payload, embeddedTime, tag)
|
||||
logger.info(
|
||||
'sending inv (within sendBroadcast function)'
|
||||
' for object: %s',
|
||||
hexlify(inventoryHash)
|
||||
)
|
||||
queues.invQueue.put((streamNumber, inventoryHash))
|
||||
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Broadcast sent on %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
|
||||
# Update the status of the message in the 'sent' table to have
|
||||
# a 'broadcastsent' status
|
||||
sqlExecute(
|
||||
'UPDATE sent SET msgid=?, status=?, lastactiontime=?'
|
||||
' WHERE ackdata=?',
|
||||
inventoryHash, 'broadcastsent', int(time.time()), ackdata
|
||||
)
|
||||
|
||||
def sendMsg(self):
|
||||
# Reset just in case
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='msgqueued' '''
|
||||
''' WHERE status IN ('doingpubkeypow', 'doingmsgpow')''')
|
||||
queryreturn = sqlQuery(
|
||||
'''SELECT toaddress, fromaddress, subject, message, '''
|
||||
''' ackdata, status, ttl, retrynumber, encodingtype FROM '''
|
||||
''' sent WHERE (status='msgqueued' or status='forcepow') '''
|
||||
''' and folder='sent' ''')
|
||||
# while we have a msg that needs some work
|
||||
for row in queryreturn:
|
||||
toaddress, fromaddress, subject, message, \
|
||||
ackdata, status, TTL, retryNumber, encoding = row
|
||||
# toStatus
|
||||
_, toAddressVersionNumber, toStreamNumber, toRipe = \
|
||||
decodeAddress(toaddress)
|
||||
# fromStatus, , ,fromRipe
|
||||
_, fromAddressVersionNumber, fromStreamNumber, _ = \
|
||||
decodeAddress(fromaddress)
|
||||
|
||||
# We may or may not already have the pubkey
|
||||
# for this toAddress. Let's check.
|
||||
if status == 'forcepow':
|
||||
# if the status of this msg is 'forcepow'
|
||||
# then clearly we have the pubkey already
|
||||
# because the user could not have overridden the message
|
||||
# about the POW being too difficult without knowing
|
||||
# the required difficulty.
|
||||
pass
|
||||
elif status == 'doingmsgpow':
|
||||
# We wouldn't have set the status to doingmsgpow
|
||||
# if we didn't already have the pubkey so let's assume
|
||||
# that we have it.
|
||||
pass
|
||||
# If we are sending a message to ourselves or a chan
|
||||
# then we won't need an entry in the pubkeys table;
|
||||
# we can calculate the needed pubkey using the private keys
|
||||
# in our keys.dat file.
|
||||
elif BMConfigParser().has_section(toaddress):
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='doingmsgpow' '''
|
||||
''' WHERE toaddress=? AND status='msgqueued' ''',
|
||||
toaddress
|
||||
)
|
||||
status = 'doingmsgpow'
|
||||
elif status == 'msgqueued':
|
||||
# Let's see if we already have the pubkey in our pubkeys table
|
||||
queryreturn = sqlQuery(
|
||||
'''SELECT address FROM pubkeys WHERE address=?''',
|
||||
toaddress
|
||||
)
|
||||
# If we have the needed pubkey in the pubkey table already,
|
||||
if queryreturn != []:
|
||||
# set the status of this msg to doingmsgpow
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='doingmsgpow' '''
|
||||
''' WHERE toaddress=? AND status='msgqueued' ''',
|
||||
toaddress
|
||||
)
|
||||
status = 'doingmsgpow'
|
||||
# mark the pubkey as 'usedpersonally' so that
|
||||
# we don't delete it later. If the pubkey version
|
||||
# is >= 4 then usedpersonally will already be set
|
||||
# to yes because we'll only ever have
|
||||
# usedpersonally v4 pubkeys in the pubkeys table.
|
||||
sqlExecute(
|
||||
'''UPDATE pubkeys SET usedpersonally='yes' '''
|
||||
''' WHERE address=?''',
|
||||
toaddress
|
||||
)
|
||||
# We don't have the needed pubkey in the pubkeys table already.
|
||||
else:
|
||||
if toAddressVersionNumber <= 3:
|
||||
toTag = ''
|
||||
else:
|
||||
toTag = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(toAddressVersionNumber) +
|
||||
encodeVarint(toStreamNumber) + toRipe
|
||||
).digest()).digest()[32:]
|
||||
if toaddress in state.neededPubkeys or \
|
||||
toTag in state.neededPubkeys:
|
||||
# We already sent a request for the pubkey
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET status='awaitingpubkey', '''
|
||||
''' sleeptill=? WHERE toaddress=? '''
|
||||
''' AND status='msgqueued' ''',
|
||||
int(time.time()) + 2.5 * 24 * 60 * 60,
|
||||
toaddress
|
||||
)
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByToAddress', (
|
||||
toaddress,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Encryption key was requested earlier."))
|
||||
))
|
||||
# on with the next msg on which we can do some work
|
||||
continue
|
||||
else:
|
||||
# We have not yet sent a request for the pubkey
|
||||
needToRequestPubkey = True
|
||||
# If we are trying to send to address
|
||||
# version >= 4 then the needed pubkey might be
|
||||
# encrypted in the inventory.
|
||||
# If we have it we'll need to decrypt it
|
||||
# and put it in the pubkeys table.
|
||||
|
||||
# The decryptAndCheckPubkeyPayload function
|
||||
# expects that the shared.neededPubkeys dictionary
|
||||
# already contains the toAddress and cryptor
|
||||
# object associated with the tag for this toAddress.
|
||||
if toAddressVersionNumber >= 4:
|
||||
doubleHashOfToAddressData = hashlib.sha512(
|
||||
hashlib.sha512(encodeVarint(
|
||||
toAddressVersionNumber) +
|
||||
encodeVarint(toStreamNumber) +
|
||||
toRipe
|
||||
).digest()
|
||||
).digest()
|
||||
# The first half of the sha512 hash.
|
||||
privEncryptionKey = doubleHashOfToAddressData[:32]
|
||||
# The second half of the sha512 hash.
|
||||
tag = doubleHashOfToAddressData[32:]
|
||||
state.neededPubkeys[tag] = (
|
||||
toaddress,
|
||||
highlevelcrypto.makeCryptor(
|
||||
hexlify(privEncryptionKey))
|
||||
)
|
||||
|
||||
for value in Inventory().by_type_and_tag(1, toTag):
|
||||
# if valid, this function also puts it
|
||||
# in the pubkeys table.
|
||||
if shared.decryptAndCheckPubkeyPayload(
|
||||
value.payload, toaddress
|
||||
) == 'successful':
|
||||
needToRequestPubkey = False
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET '''
|
||||
''' status='doingmsgpow', '''
|
||||
''' retrynumber=0 WHERE '''
|
||||
''' toaddress=? AND '''
|
||||
''' (status='msgqueued' or '''
|
||||
''' status='awaitingpubkey' or '''
|
||||
''' status='doingpubkeypow')''',
|
||||
toaddress)
|
||||
del state.neededPubkeys[tag]
|
||||
break
|
||||
# else:
|
||||
# There was something wrong with this
|
||||
# pubkey object even though it had
|
||||
# the correct tag- almost certainly
|
||||
# because of malicious behavior or
|
||||
# a badly programmed client. If there are
|
||||
# any other pubkeys in our inventory
|
||||
# with the correct tag then we'll try
|
||||
# to decrypt those.
|
||||
if needToRequestPubkey:
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET '''
|
||||
''' status='doingpubkeypow' WHERE '''
|
||||
''' toaddress=? AND status='msgqueued' ''',
|
||||
toaddress
|
||||
)
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByToAddress', (
|
||||
toaddress,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Sending a request for the"
|
||||
" recipient\'s encryption key."))
|
||||
))
|
||||
self.requestPubKey(toaddress)
|
||||
# on with the next msg on which we can do some work
|
||||
continue
|
||||
|
||||
# At this point we know that we have the necessary pubkey
|
||||
# in the pubkeys table.
|
||||
|
||||
TTL *= 2**retryNumber
|
||||
if TTL > 28 * 24 * 60 * 60:
|
||||
TTL = 28 * 24 * 60 * 60
|
||||
# add some randomness to the TTL
|
||||
TTL = int(TTL + helper_random.randomrandrange(-300, 300))
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
|
||||
# if we aren't sending this to ourselves or a chan
|
||||
if not BMConfigParser().has_section(toaddress):
|
||||
shared.ackdataForWhichImWatching[ackdata] = 0
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Looking up the receiver\'s public key"))
|
||||
))
|
||||
logger.info('Sending a message.')
|
||||
logger.debug(
|
||||
'First 150 characters of message: %s',
|
||||
repr(message[:150])
|
||||
)
|
||||
|
||||
# Let us fetch the recipient's public key out of
|
||||
# our database. If the required proof of work difficulty
|
||||
# is too hard then we'll abort.
|
||||
queryreturn = sqlQuery(
|
||||
'SELECT transmitdata FROM pubkeys WHERE address=?',
|
||||
toaddress)
|
||||
for row in queryreturn:
|
||||
pubkeyPayload, = row
|
||||
|
||||
# The pubkey message is stored with the following items
|
||||
# all appended:
|
||||
# -address version
|
||||
# -stream number
|
||||
# -behavior bitfield
|
||||
# -pub signing key
|
||||
# -pub encryption key
|
||||
# -nonce trials per byte (if address version is >= 3)
|
||||
# -length extra bytes (if address version is >= 3)
|
||||
|
||||
# to bypass the address version whose length is definitely 1
|
||||
readPosition = 1
|
||||
_, streamNumberLength = decodeVarint(
|
||||
pubkeyPayload[readPosition:readPosition + 10])
|
||||
readPosition += streamNumberLength
|
||||
behaviorBitfield = pubkeyPayload[readPosition:readPosition + 4]
|
||||
# Mobile users may ask us to include their address's
|
||||
# RIPE hash on a message unencrypted. Before we actually
|
||||
# do it the sending human must check a box
|
||||
# in the settings menu to allow it.
|
||||
|
||||
# if receiver is a mobile device who expects that their
|
||||
# address RIPE is included unencrypted on the front of
|
||||
# the message..
|
||||
if shared.isBitSetWithinBitfield(behaviorBitfield, 30):
|
||||
# if we are Not willing to include the receiver's
|
||||
# RIPE hash on the message..
|
||||
if not shared.BMConfigParser().safeGetBoolean(
|
||||
'bitmessagesettings', 'willinglysendtomobile'
|
||||
):
|
||||
logger.info(
|
||||
'The receiver is a mobile user but the'
|
||||
' sender (you) has not selected that you'
|
||||
' are willing to send to mobiles. Aborting'
|
||||
' send.'
|
||||
)
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Problem: Destination is a mobile"
|
||||
" device who requests that the"
|
||||
" destination be included in the"
|
||||
" message but this is disallowed in"
|
||||
" your settings. %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
# if the human changes their setting and then
|
||||
# sends another message or restarts their client,
|
||||
# this one will send at that time.
|
||||
continue
|
||||
readPosition += 4 # to bypass the bitfield of behaviors
|
||||
# We don't use this key for anything here.
|
||||
# pubSigningKeyBase256 =
|
||||
# pubkeyPayload[readPosition:readPosition+64]
|
||||
readPosition += 64
|
||||
pubEncryptionKeyBase256 = pubkeyPayload[
|
||||
readPosition:readPosition + 64]
|
||||
readPosition += 64
|
||||
|
||||
# Let us fetch the amount of work required by the recipient.
|
||||
if toAddressVersionNumber == 2:
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte = \
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte
|
||||
requiredPayloadLengthExtraBytes = \
|
||||
defaults.networkDefaultPayloadLengthExtraBytes
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Doing work necessary to send message.\n"
|
||||
"There is no required difficulty for"
|
||||
" version 2 addresses like this."))
|
||||
))
|
||||
elif toAddressVersionNumber >= 3:
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte, \
|
||||
varintLength = decodeVarint(
|
||||
pubkeyPayload[readPosition:readPosition + 10])
|
||||
readPosition += varintLength
|
||||
requiredPayloadLengthExtraBytes, varintLength = \
|
||||
decodeVarint(
|
||||
pubkeyPayload[readPosition:readPosition + 10])
|
||||
readPosition += varintLength
|
||||
# We still have to meet a minimum POW difficulty
|
||||
# regardless of what they say is allowed in order
|
||||
# to get our message to propagate through the network.
|
||||
if requiredAverageProofOfWorkNonceTrialsPerByte < \
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte:
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte = \
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte
|
||||
if requiredPayloadLengthExtraBytes < \
|
||||
defaults.networkDefaultPayloadLengthExtraBytes:
|
||||
requiredPayloadLengthExtraBytes = \
|
||||
defaults.networkDefaultPayloadLengthExtraBytes
|
||||
logger.debug(
|
||||
'Using averageProofOfWorkNonceTrialsPerByte: %s'
|
||||
' and payloadLengthExtraBytes: %s.',
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte,
|
||||
requiredPayloadLengthExtraBytes
|
||||
)
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Doing work necessary to send message.\n"
|
||||
"Receiver\'s required difficulty: %1"
|
||||
" and %2"
|
||||
).arg(str(float(
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte) /
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte
|
||||
)).arg(str(float(
|
||||
requiredPayloadLengthExtraBytes) /
|
||||
defaults.networkDefaultPayloadLengthExtraBytes
|
||||
)))))
|
||||
if status != 'forcepow':
|
||||
if (requiredAverageProofOfWorkNonceTrialsPerByte
|
||||
> BMConfigParser().getint(
|
||||
'bitmessagesettings',
|
||||
'maxacceptablenoncetrialsperbyte'
|
||||
) and
|
||||
BMConfigParser().getint(
|
||||
'bitmessagesettings',
|
||||
'maxacceptablenoncetrialsperbyte'
|
||||
) != 0) or (
|
||||
requiredPayloadLengthExtraBytes
|
||||
> BMConfigParser().getint(
|
||||
'bitmessagesettings',
|
||||
'maxacceptablepayloadlengthextrabytes'
|
||||
) and
|
||||
BMConfigParser().getint(
|
||||
'bitmessagesettings',
|
||||
'maxacceptablepayloadlengthextrabytes'
|
||||
) != 0):
|
||||
# The demanded difficulty is more than
|
||||
# we are willing to do.
|
||||
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(float(
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte)
|
||||
/ defaults.networkDefaultProofOfWorkNonceTrialsPerByte
|
||||
)).arg(str(float(
|
||||
requiredPayloadLengthExtraBytes)
|
||||
/ defaults.networkDefaultPayloadLengthExtraBytes
|
||||
)).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
continue
|
||||
else: # if we are sending a message to ourselves or a chan..
|
||||
logger.info('Sending a message.')
|
||||
logger.debug(
|
||||
'First 150 characters of message: %r', message[:150])
|
||||
behaviorBitfield = protocol.getBitfield(fromaddress)
|
||||
|
||||
try:
|
||||
privEncryptionKeyBase58 = BMConfigParser().get(
|
||||
toaddress, 'privencryptionkey')
|
||||
except Exception as err:
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Problem: You are trying to send a"
|
||||
" message to yourself or a chan but your"
|
||||
" encryption key could not be found in"
|
||||
" the keys.dat file. Could not encrypt"
|
||||
" message. %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
logger.error(
|
||||
'Error within sendMsg. Could not read the keys'
|
||||
' from the keys.dat file for our own address. %s\n',
|
||||
err)
|
||||
continue
|
||||
privEncryptionKeyHex = hexlify(shared.decodeWalletImportFormat(
|
||||
privEncryptionKeyBase58))
|
||||
pubEncryptionKeyBase256 = unhexlify(highlevelcrypto.privToPub(
|
||||
privEncryptionKeyHex))[1:]
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte = \
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte
|
||||
requiredPayloadLengthExtraBytes = \
|
||||
defaults.networkDefaultPayloadLengthExtraBytes
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Doing work necessary to send message."))
|
||||
))
|
||||
|
||||
# Now we can start to assemble our message.
|
||||
payload = encodeVarint(fromAddressVersionNumber)
|
||||
payload += encodeVarint(fromStreamNumber)
|
||||
# Bitfield of features and behaviors
|
||||
# that can be expected from me. (See
|
||||
# https://bitmessage.org/wiki/Protocol_specification#Pubkey_bitfield_features)
|
||||
payload += protocol.getBitfield(fromaddress)
|
||||
|
||||
# We need to convert our private keys to public keys in order
|
||||
# to include them.
|
||||
try:
|
||||
privSigningKeyHex, privEncryptionKeyHex, \
|
||||
pubSigningKey, pubEncryptionKey = self._getKeysForAddress(
|
||||
fromaddress)
|
||||
except:
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Error! Could not find sender address"
|
||||
" (your address) in the keys.dat file."))
|
||||
))
|
||||
continue
|
||||
|
||||
payload += pubSigningKey + pubEncryptionKey
|
||||
|
||||
if fromAddressVersionNumber >= 3:
|
||||
# If the receiver of our message is in our address book,
|
||||
# subscriptions list, or whitelist then we will allow them to
|
||||
# do the network-minimum proof of work. Let us check to see if
|
||||
# the receiver is in any of those lists.
|
||||
if shared.isAddressInMyAddressBookSubscriptionsListOrWhitelist(
|
||||
toaddress):
|
||||
payload += encodeVarint(
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte)
|
||||
payload += encodeVarint(
|
||||
defaults.networkDefaultPayloadLengthExtraBytes)
|
||||
else:
|
||||
payload += encodeVarint(BMConfigParser().getint(
|
||||
fromaddress, 'noncetrialsperbyte'))
|
||||
payload += encodeVarint(BMConfigParser().getint(
|
||||
fromaddress, 'payloadlengthextrabytes'))
|
||||
|
||||
# This hash will be checked by the receiver of the message
|
||||
# to verify that toRipe belongs to them. This prevents
|
||||
# a Surreptitious Forwarding Attack.
|
||||
payload += toRipe
|
||||
payload += encodeVarint(encoding) # message encoding type
|
||||
encodedMessage = helper_msgcoding.MsgEncode(
|
||||
{"subject": subject, "body": message}, encoding
|
||||
)
|
||||
payload += encodeVarint(encodedMessage.length)
|
||||
payload += encodedMessage.data
|
||||
if BMConfigParser().has_section(toaddress):
|
||||
logger.info(
|
||||
'Not bothering to include ackdata because we are'
|
||||
' sending to ourselves or a chan.'
|
||||
)
|
||||
fullAckPayload = ''
|
||||
elif not protocol.checkBitfield(
|
||||
behaviorBitfield, protocol.BITFIELD_DOESACK):
|
||||
logger.info(
|
||||
'Not bothering to include ackdata because'
|
||||
' the receiver said that they won\'t relay it anyway.'
|
||||
)
|
||||
fullAckPayload = ''
|
||||
else:
|
||||
# The fullAckPayload is a normal msg protocol message
|
||||
# with the proof of work already completed that the
|
||||
# receiver of this message can easily send out.
|
||||
fullAckPayload = self.generateFullAckMessage(
|
||||
ackdata, toStreamNumber, TTL)
|
||||
payload += encodeVarint(len(fullAckPayload))
|
||||
payload += fullAckPayload
|
||||
dataToSign = pack('>Q', embeddedTime) + '\x00\x00\x00\x02' + \
|
||||
encodeVarint(1) + encodeVarint(toStreamNumber) + payload
|
||||
signature = highlevelcrypto.sign(dataToSign, privSigningKeyHex)
|
||||
payload += encodeVarint(len(signature))
|
||||
payload += signature
|
||||
|
||||
# We have assembled the data that will be encrypted.
|
||||
try:
|
||||
encrypted = highlevelcrypto.encrypt(
|
||||
payload, "04" + hexlify(pubEncryptionKeyBase256)
|
||||
)
|
||||
except:
|
||||
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()))
|
||||
))
|
||||
continue
|
||||
|
||||
encryptedPayload = pack('>Q', embeddedTime)
|
||||
encryptedPayload += '\x00\x00\x00\x02' # object type: msg
|
||||
encryptedPayload += encodeVarint(1) # msg version
|
||||
encryptedPayload += encodeVarint(toStreamNumber) + encrypted
|
||||
target = 2 ** 64 / (
|
||||
requiredAverageProofOfWorkNonceTrialsPerByte * (
|
||||
len(encryptedPayload) + 8 +
|
||||
requiredPayloadLengthExtraBytes + ((
|
||||
TTL * (
|
||||
len(encryptedPayload) + 8 +
|
||||
requiredPayloadLengthExtraBytes
|
||||
)) / (2 ** 16))
|
||||
))
|
||||
logger.info(
|
||||
'(For msg message) Doing proof of work. Total required'
|
||||
' difficulty: %f. Required small message difficulty: %f.',
|
||||
float(requiredAverageProofOfWorkNonceTrialsPerByte) /
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte,
|
||||
float(requiredPayloadLengthExtraBytes) /
|
||||
defaults.networkDefaultPayloadLengthExtraBytes
|
||||
)
|
||||
|
||||
powStartTime = time.time()
|
||||
initialHash = hashlib.sha512(encryptedPayload).digest()
|
||||
trialValue, nonce = proofofwork.run(target, initialHash)
|
||||
logger.info(
|
||||
'(For msg message) Found proof of work %s Nonce: %s',
|
||||
trialValue, nonce
|
||||
)
|
||||
try:
|
||||
logger.info(
|
||||
'PoW took %.1f seconds, speed %s.',
|
||||
time.time() - powStartTime,
|
||||
sizeof_fmt(nonce / (time.time() - powStartTime))
|
||||
)
|
||||
except:
|
||||
pass
|
||||
|
||||
encryptedPayload = pack('>Q', nonce) + encryptedPayload
|
||||
|
||||
# Sanity check. The encryptedPayload size should never be
|
||||
# larger than 256 KiB. There should be checks elsewhere
|
||||
# in the code to not let the user try to send a message
|
||||
# this large until we implement message continuation.
|
||||
if len(encryptedPayload) > 2 ** 18: # 256 KiB
|
||||
logger.critical(
|
||||
'This msg object is too large to send. This should'
|
||||
' never happen. Object size: %i',
|
||||
len(encryptedPayload)
|
||||
)
|
||||
continue
|
||||
|
||||
inventoryHash = calculateInventoryHash(encryptedPayload)
|
||||
objectType = 2
|
||||
Inventory()[inventoryHash] = (
|
||||
objectType, toStreamNumber, encryptedPayload, embeddedTime, '')
|
||||
if BMConfigParser().has_section(toaddress) or \
|
||||
not protocol.checkBitfield(
|
||||
behaviorBitfield, protocol.BITFIELD_DOESACK):
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Message sent. Sent at %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
else:
|
||||
# not sending to a chan or one of my addresses
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByAckdata', (
|
||||
ackdata,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Message sent. Waiting for acknowledgement."
|
||||
" Sent on %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
logger.info(
|
||||
'Broadcasting inv for my msg(within sendmsg function): %s',
|
||||
hexlify(inventoryHash)
|
||||
)
|
||||
queues.invQueue.put((toStreamNumber, inventoryHash))
|
||||
|
||||
# Update the sent message in the sent table with the
|
||||
# necessary information.
|
||||
if BMConfigParser().has_section(toaddress) or \
|
||||
not protocol.checkBitfield(
|
||||
behaviorBitfield, protocol.BITFIELD_DOESACK):
|
||||
newStatus = 'msgsentnoackexpected'
|
||||
else:
|
||||
newStatus = 'msgsent'
|
||||
# wait 10% past expiration
|
||||
sleepTill = int(time.time() + TTL * 1.1)
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET msgid=?, status=?, retrynumber=?, '''
|
||||
''' sleeptill=?, lastactiontime=? WHERE ackdata=?''',
|
||||
inventoryHash, newStatus, retryNumber + 1,
|
||||
sleepTill, int(time.time()), ackdata
|
||||
)
|
||||
|
||||
# If we are sending to ourselves or a chan, let's put
|
||||
# the message in our own inbox.
|
||||
if BMConfigParser().has_section(toaddress):
|
||||
# Used to detect and ignore duplicate messages in our inbox
|
||||
sigHash = hashlib.sha512(hashlib.sha512(
|
||||
signature).digest()).digest()[32:]
|
||||
t = (inventoryHash, toaddress, fromaddress, subject, int(
|
||||
time.time()), message, 'inbox', encoding, 0, sigHash)
|
||||
helper_inbox.insert(t)
|
||||
|
||||
queues.UISignalQueue.put(('displayNewInboxMessage', (
|
||||
inventoryHash, toaddress, fromaddress, subject, message)))
|
||||
|
||||
# If we are behaving as an API then we might need to run an
|
||||
# outside command to let some program know that a new message
|
||||
# has arrived.
|
||||
if BMConfigParser().safeGetBoolean(
|
||||
'bitmessagesettings', 'apienabled'):
|
||||
try:
|
||||
apiNotifyPath = BMConfigParser().get(
|
||||
'bitmessagesettings', 'apinotifypath')
|
||||
except:
|
||||
apiNotifyPath = ''
|
||||
if apiNotifyPath != '':
|
||||
call([apiNotifyPath, "newMessage"])
|
||||
|
||||
def requestPubKey(self, toAddress):
|
||||
toStatus, addressVersionNumber, streamNumber, ripe = decodeAddress(
|
||||
toAddress)
|
||||
if toStatus != 'success':
|
||||
logger.error(
|
||||
'Very abnormal error occurred in requestPubKey.'
|
||||
' toAddress is: %r. Please report this error to Atheros.',
|
||||
toAddress
|
||||
)
|
||||
return
|
||||
|
||||
queryReturn = sqlQuery(
|
||||
'''SELECT retrynumber FROM sent WHERE toaddress=? '''
|
||||
''' AND (status='doingpubkeypow' OR status='awaitingpubkey') '''
|
||||
''' LIMIT 1''',
|
||||
toAddress
|
||||
)
|
||||
if len(queryReturn) == 0:
|
||||
logger.critical(
|
||||
'BUG: Why are we requesting the pubkey for %s'
|
||||
' if there are no messages in the sent folder'
|
||||
' to that address?', toAddress
|
||||
)
|
||||
return
|
||||
retryNumber = queryReturn[0][0]
|
||||
|
||||
if addressVersionNumber <= 3:
|
||||
state.neededPubkeys[toAddress] = 0
|
||||
elif addressVersionNumber >= 4:
|
||||
# If the user just clicked 'send' then the tag
|
||||
# (and other information) will already be in the
|
||||
# neededPubkeys dictionary. But if we are recovering
|
||||
# from a restart of the client then we have to put it in now.
|
||||
|
||||
# Note that this is the first half of the sha512 hash.
|
||||
privEncryptionKey = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(addressVersionNumber) +
|
||||
encodeVarint(streamNumber) + ripe
|
||||
).digest()).digest()[:32]
|
||||
# Note that this is the second half of the sha512 hash.
|
||||
tag = hashlib.sha512(hashlib.sha512(
|
||||
encodeVarint(addressVersionNumber) +
|
||||
encodeVarint(streamNumber) + ripe
|
||||
).digest()).digest()[32:]
|
||||
if tag not in state.neededPubkeys:
|
||||
# We'll need this for when we receive a pubkey reply:
|
||||
# it will be encrypted and we'll need to decrypt it.
|
||||
state.neededPubkeys[tag] = (
|
||||
toAddress,
|
||||
highlevelcrypto.makeCryptor(hexlify(privEncryptionKey))
|
||||
)
|
||||
|
||||
# 2.5 days. This was chosen fairly arbitrarily.
|
||||
TTL = 2.5 * 24 * 60 * 60
|
||||
TTL *= 2 ** retryNumber
|
||||
if TTL > 28 * 24 * 60 * 60:
|
||||
TTL = 28 * 24 * 60 * 60
|
||||
# add some randomness to the TTL
|
||||
TTL = TTL + helper_random.randomrandrange(-300, 300)
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
payload = pack('>Q', embeddedTime)
|
||||
payload += '\x00\x00\x00\x00' # object type: getpubkey
|
||||
payload += encodeVarint(addressVersionNumber)
|
||||
payload += encodeVarint(streamNumber)
|
||||
if addressVersionNumber <= 3:
|
||||
payload += ripe
|
||||
logger.info(
|
||||
'making request for pubkey with ripe: %s', hexlify(ripe))
|
||||
else:
|
||||
payload += tag
|
||||
logger.info(
|
||||
'making request for v4 pubkey with tag: %s', hexlify(tag))
|
||||
|
||||
# print 'trial value', trialValue
|
||||
statusbar = 'Doing the computations necessary to request' +\
|
||||
' the recipient\'s public key.'
|
||||
queues.UISignalQueue.put(('updateStatusBar', statusbar))
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByToAddress', (
|
||||
toAddress,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Doing work necessary to request encryption key."))
|
||||
))
|
||||
|
||||
payload = self._doPOWDefaults(payload, TTL)
|
||||
|
||||
inventoryHash = calculateInventoryHash(payload)
|
||||
objectType = 1
|
||||
Inventory()[inventoryHash] = (
|
||||
objectType, streamNumber, payload, embeddedTime, '')
|
||||
logger.info('sending inv (for the getpubkey message)')
|
||||
queues.invQueue.put((streamNumber, inventoryHash))
|
||||
|
||||
# wait 10% past expiration
|
||||
sleeptill = int(time.time() + TTL * 1.1)
|
||||
sqlExecute(
|
||||
'''UPDATE sent SET lastactiontime=?, '''
|
||||
''' status='awaitingpubkey', retrynumber=?, sleeptill=? '''
|
||||
''' WHERE toaddress=? AND (status='doingpubkeypow' OR '''
|
||||
''' status='awaitingpubkey') ''',
|
||||
int(time.time()), retryNumber + 1, sleeptill, toAddress)
|
||||
|
||||
queues.UISignalQueue.put((
|
||||
'updateStatusBar',
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Broadcasting the public key request. This program will"
|
||||
" auto-retry if they are offline.")
|
||||
))
|
||||
queues.UISignalQueue.put((
|
||||
'updateSentItemStatusByToAddress', (
|
||||
toAddress,
|
||||
tr._translate(
|
||||
"MainWindow",
|
||||
"Sending public key request. Waiting for reply."
|
||||
" Requested at %1"
|
||||
).arg(l10n.formatTimestamp()))
|
||||
))
|
||||
|
||||
def generateFullAckMessage(self, ackdata, toStreamNumber, TTL):
|
||||
# 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: # 1 day
|
||||
TTL = 24 * 60 * 60 # 1 day
|
||||
elif TTL < 7 * 24 * 60 * 60: # 1 week
|
||||
TTL = 7 * 24 * 60 * 60 # 1 week
|
||||
else:
|
||||
TTL = 28 * 24 * 60 * 60 # 4 weeks
|
||||
# Add some randomness to the TTL
|
||||
TTL = int(TTL + helper_random.randomrandrange(-300, 300))
|
||||
embeddedTime = int(time.time() + TTL)
|
||||
|
||||
# type/version/stream already included
|
||||
payload = pack('>Q', (embeddedTime)) + ackdata
|
||||
|
||||
payload = self._doPOWDefaults(
|
||||
payload, TTL, log_prefix='(For ack message)', log_time=True)
|
||||
|
||||
return protocol.CreatePacket('object', payload)
|
|
@ -14,6 +14,8 @@ import queues
|
|||
import state
|
||||
import tr#anslate
|
||||
import helper_random
|
||||
import addresses
|
||||
import binascii
|
||||
# This thread exists because SQLITE3 is so un-threadsafe that we must
|
||||
# submit queries to it and it puts results back in a different queue. They
|
||||
# won't let us just use locks.
|
||||
|
@ -165,16 +167,55 @@ class sqlThread(threading.Thread):
|
|||
logger.debug('Vacuuming message.dat. You might notice that the file size gets much smaller.')
|
||||
self.cur.execute( ''' VACUUM ''')
|
||||
|
||||
# After code refactoring, the possible status values for sent messages
|
||||
# have changed.
|
||||
self.cur.execute(
|
||||
'''update sent set status='doingmsgpow' where status='doingpow' ''')
|
||||
self.cur.execute(
|
||||
'''update sent set status='msgsent' where status='sentmessage' ''')
|
||||
self.cur.execute(
|
||||
'''update sent set status='doingpubkeypow' where status='findingpubkey' ''')
|
||||
self.cur.execute(
|
||||
'''update sent set status='broadcastqueued' where status='broadcastpending' ''')
|
||||
# Retry number now has no meaning for getpubkey messages
|
||||
|
||||
self.cur.execute("""
|
||||
UPDATE "sent" SET "retrynumber" = 0
|
||||
WHERE "status" IN (
|
||||
'doingpubkeypow', 'awaitingpubkey',
|
||||
'findingpubkey' -- Old name
|
||||
);
|
||||
""")
|
||||
|
||||
# Reset temporary message status values
|
||||
# TODO: stop writing them to the database, they should exist only in memory
|
||||
|
||||
self.cur.execute("""
|
||||
UPDATE "sent" SET "status" = 'broadcastqueued'
|
||||
WHERE "status" == 'doingbroadcastpow';
|
||||
""")
|
||||
|
||||
self.cur.execute("""
|
||||
UPDATE "sent" SET "status" = 'msgqueued'
|
||||
WHERE "status" IN (
|
||||
'doingmsgpow', 'doingpubkeypow', 'awaitingpubkey',
|
||||
'doingpow', 'findingpubkey' -- Old names
|
||||
);
|
||||
""")
|
||||
|
||||
# Update status values inherited from old versions
|
||||
|
||||
self.cur.execute("""UPDATE "sent" SET "status" = 'msgsent' WHERE "status" == 'sentmessage';""")
|
||||
pep8 validation here. pep8 validation here.
|
||||
self.cur.execute("""UPDATE "sent" SET "status" = 'broadcastqueued' WHERE "status" == 'broadcastpending';""")
|
||||
|
||||
# Add tags to all objects
|
||||
|
||||
self.cur.execute("""SELECT "hash", "payload" FROM "inventory" WHERE "tag" == '';""")
|
||||
updatingCursor = self.conn.cursor()
|
||||
|
||||
for ID, payload in self.cur:
|
||||
readPosition = 20
|
||||
|
||||
version, readLength = addresses.decodeVarint(payload[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
|
||||
stream, readLength = addresses.decodeVarint(payload[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
|
||||
tag = buffer(payload[readPosition: readPosition + 32]) # May be shorter than 32 bytes for getpubkeys
|
||||
|
||||
updatingCursor.execute("""UPDATE "inventory" SET "tag" = ? WHERE "hash" == ?;""", (tag, ID))
|
||||
|
||||
self.conn.commit()
|
||||
|
||||
if not BMConfigParser().has_option('bitmessagesettings', 'sockslisten'):
|
||||
|
@ -476,6 +517,24 @@ class sqlThread(threading.Thread):
|
|||
parameters = (int(time.time()),)
|
||||
self.cur.execute(item, parameters)
|
||||
|
||||
self.cur.execute("""SELECT "ackdata" FROM "sent" WHERE "status" == 'msgsent';""")
|
||||
legacyAckData = []
|
||||
|
||||
for ackData, in self.cur:
|
||||
logger.info("Watching for ack data: %s", binascii.hexlify(ackData))
|
||||
|
||||
if len(ackData) == 32:
|
||||
legacyAckData.append(ackData)
|
||||
else:
|
||||
state.watchedAckData.add(ackData)
|
||||
|
||||
for i in legacyAckData:
|
||||
ackData = "\x00\x00\x00\x02\x01\x01" + i
|
||||
|
||||
self.cur.execute("""UPDATE "sent" SET "ackdata" = ? WHERE "ackdata" == ?;""", (ackData, i))
|
||||
|
||||
state.watchedAckData.add(ackData)
|
||||
|
||||
state.sqlReady = True
|
||||
|
||||
while True:
|
||||
|
|
|
@ -18,18 +18,6 @@ import queues
|
|||
import shutdown
|
||||
from debug import logger
|
||||
|
||||
|
||||
def powQueueSize():
|
||||
curWorkerQueue = queues.workerQueue.qsize()
|
||||
for thread in threading.enumerate():
|
||||
try:
|
||||
if thread.name == "singleWorker":
|
||||
curWorkerQueue += thread.busy
|
||||
except Exception as err:
|
||||
logger.info('Thread error %s', err)
|
||||
return curWorkerQueue
|
||||
|
||||
|
||||
def convertIntToString(n):
|
||||
a = __builtins__.hex(n)
|
||||
if a[-1:] == 'L':
|
||||
|
|
|
@ -47,6 +47,7 @@ class BMObject(object):
|
|||
self.inventoryHash = calculateInventoryHash(data)
|
||||
# copy to avoid memory issues
|
||||
self.data = bytearray(data)
|
||||
# Doesn't matter if the payload is shorter, old version "getpubkey" objects must have 20-byte tags
|
||||
self.tag = self.data[payloadOffset:payloadOffset+32]
|
||||
|
||||
def checkProofOfWorkSufficient(self):
|
||||
|
|
|
@ -353,7 +353,6 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
|
|||
|
||||
try:
|
||||
self.object.checkObjectByType()
|
||||
objectProcessorQueue.put((self.object.objectType, buffer(self.object.data)))
|
||||
except BMObjectInvalidError as e:
|
||||
BMProto.stopDownloadingObject(self.object.inventoryHash, True)
|
||||
else:
|
||||
|
@ -369,6 +368,7 @@ class BMProto(AdvancedDispatcher, ObjectTracker):
|
|||
self.object.objectType, self.object.streamNumber, buffer(self.payload[objectOffset:]), self.object.expiresTime, buffer(self.object.tag))
|
||||
self.handleReceivedObject(self.object.streamNumber, self.object.inventoryHash)
|
||||
invQueue.put((self.object.streamNumber, self.object.inventoryHash, self.destination))
|
||||
objectProcessorQueue.put((self.object.objectType, buffer(self.object.data)))
|
||||
return True
|
||||
|
||||
def _decode_addr(self):
|
||||
|
|
213
src/protocol.py
|
@ -62,32 +62,20 @@ Header = Struct('!L12sL4s')
|
|||
|
||||
VersionPacket = Struct('>LqQ20s4s36sH')
|
||||
|
||||
# Bitfield
|
||||
def calculateDoubleHash(data):
|
||||
return hashlib.sha512(hashlib.sha512(data).digest()).digest()
|
||||
|
||||
def calculateRipeHash(data):
|
||||
return hashlib.new("ripemd160", hashlib.sha512(data).digest()).digest()
|
||||
|
||||
def getBitfield(address):
|
||||
"""Get a bitfield from an address"""
|
||||
# bitfield of features supported by me (see the wiki).
|
||||
bitfield = 0
|
||||
# send ack
|
||||
if not BMConfigParser().safeGetBoolean(address, 'dontsendack'):
|
||||
bitfield |= BITFIELD_DOESACK
|
||||
return pack('>I', bitfield)
|
||||
|
||||
|
||||
def checkBitfield(bitfieldBinary, flags):
|
||||
"""Check if a bitfield matches the given flags"""
|
||||
bitfield, = unpack('>I', bitfieldBinary)
|
||||
return (bitfield & flags) == flags
|
||||
|
||||
|
||||
def isBitSetWithinBitfield(fourByteString, n):
|
||||
"""Check if a particular bit is set in a bitfeld"""
|
||||
# Uses MSB 0 bit numbering across 4 bytes of data
|
||||
n = 31 - n
|
||||
x, = unpack('>L', fourByteString)
|
||||
return x & 2**n != 0
|
||||
def calculateAddressTag(version, stream, ripe):
|
||||
doubleHash = calculateDoubleHash(
|
||||
encodeVarint(version) +
|
||||
encodeVarint(stream) +
|
||||
ripe
|
||||
)
|
||||
|
||||
return doubleHash[: 32], doubleHash[32: ]
|
||||
|
||||
# ip addresses
|
||||
|
||||
|
@ -199,7 +187,6 @@ def checkSocksIP(host):
|
|||
state.socksIP = BMConfigParser().get("bitmessagesettings", "sockshostname")
|
||||
return state.socksIP == host
|
||||
|
||||
|
||||
def isProofOfWorkSufficient(data,
|
||||
nonceTrialsPerByte=0,
|
||||
payloadLengthExtraBytes=0,
|
||||
|
@ -320,122 +307,98 @@ def assembleErrorMessage(fatal=0, banTime=0, inventoryVector='', errorText=''):
|
|||
|
||||
# Packet decoding
|
||||
|
||||
def decryptAndCheckV4Pubkey(payload, address, cryptor):
|
||||
status, version, stream, ripe = decodeAddress(address)
|
||||
|
||||
readPosition = 20
|
||||
|
||||
def decryptAndCheckPubkeyPayload(data, address):
|
||||
"""
|
||||
Version 4 pubkeys are encrypted. This function is run when we already have the
|
||||
address to which we want to try to send a message. The 'data' may come either
|
||||
off of the wire or we might have had it already in our inventory when we tried
|
||||
to send a msg to this particular address.
|
||||
"""
|
||||
# pylint: disable=unused-variable
|
||||
try:
|
||||
status, addressVersion, streamNumber, ripe = decodeAddress(address)
|
||||
embeddedVersion, readLength = decodeVarint(payload[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
|
||||
readPosition = 20 # bypass the nonce, time, and object type
|
||||
embeddedAddressVersion, varintLength = decodeVarint(data[readPosition:readPosition + 10])
|
||||
readPosition += varintLength
|
||||
embeddedStreamNumber, varintLength = decodeVarint(data[readPosition:readPosition + 10])
|
||||
readPosition += varintLength
|
||||
# We'll store the address version and stream number (and some more) in the pubkeys table.
|
||||
storedData = data[20:readPosition]
|
||||
embeddedStream, readLength = decodeVarint(payload[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
except:
|
||||
return None
|
||||
|
||||
if addressVersion != embeddedAddressVersion:
|
||||
logger.info('Pubkey decryption was UNsuccessful due to address version mismatch.')
|
||||
return 'failed'
|
||||
if streamNumber != embeddedStreamNumber:
|
||||
logger.info('Pubkey decryption was UNsuccessful due to stream number mismatch.')
|
||||
return 'failed'
|
||||
if embeddedVersion != 4:
|
||||
logger.info("Pubkey decryption failed due to address version mismatch")
|
||||
|
||||
tag = data[readPosition:readPosition + 32]
|
||||
readPosition += 32
|
||||
# the time through the tag. More data is appended onto signedData below after the decryption.
|
||||
signedData = data[8:readPosition]
|
||||
encryptedData = data[readPosition:]
|
||||
return None
|
||||
|
||||
# Let us try to decrypt the pubkey
|
||||
toAddress, cryptorObject = state.neededPubkeys[tag]
|
||||
if toAddress != address:
|
||||
logger.critical(
|
||||
'decryptAndCheckPubkeyPayload failed due to toAddress mismatch.'
|
||||
' This is very peculiar. toAddress: %s, address %s',
|
||||
toAddress,
|
||||
address)
|
||||
# the only way I can think that this could happen is if someone encodes their address data two different
|
||||
# ways. That sort of address-malleability should have been caught by the UI or API and an error given to
|
||||
# the user.
|
||||
return 'failed'
|
||||
try:
|
||||
decryptedData = cryptorObject.decrypt(encryptedData)
|
||||
except:
|
||||
# Someone must have encrypted some data with a different key
|
||||
# but tagged it with a tag for which we are watching.
|
||||
logger.info('Pubkey decryption was unsuccessful.')
|
||||
return 'failed'
|
||||
if embeddedStream != stream:
|
||||
logger.info("Pubkey decryption failed due to stream number mismatch")
|
||||
|
||||
readPosition = 0
|
||||
bitfieldBehaviors = decryptedData[readPosition:readPosition + 4]
|
||||
return None
|
||||
|
||||
result = payload[20: readPosition]
|
||||
|
||||
tag = payload[readPosition: readPosition + 32]
|
||||
readPosition += 32
|
||||
|
||||
if len(tag) < 32:
|
||||
return None
|
||||
|
||||
signedData = payload[8: readPosition]
|
||||
ciphertext = payload[readPosition: ]
|
||||
|
||||
try:
|
||||
plaintext = cryptor.decrypt(ciphertext)
|
||||
except:
|
||||
logger.info("Pubkey decryption failed")
|
||||
|
||||
return None
|
||||
|
||||
readPosition = 0
|
||||
|
||||
try:
|
||||
bitfield = unpack(">I", plaintext[readPosition: readPosition + 4])
|
||||
readPosition += 4
|
||||
publicSigningKey = '\x04' + decryptedData[readPosition:readPosition + 64]
|
||||
readPosition += 64
|
||||
publicEncryptionKey = '\x04' + decryptedData[readPosition:readPosition + 64]
|
||||
readPosition += 64
|
||||
specifiedNonceTrialsPerByte, specifiedNonceTrialsPerByteLength = decodeVarint(
|
||||
decryptedData[readPosition:readPosition + 10])
|
||||
readPosition += specifiedNonceTrialsPerByteLength
|
||||
specifiedPayloadLengthExtraBytes, specifiedPayloadLengthExtraBytesLength = decodeVarint(
|
||||
decryptedData[readPosition:readPosition + 10])
|
||||
readPosition += specifiedPayloadLengthExtraBytesLength
|
||||
storedData += decryptedData[:readPosition]
|
||||
signedData += decryptedData[:readPosition]
|
||||
signatureLength, signatureLengthLength = decodeVarint(
|
||||
decryptedData[readPosition:readPosition + 10])
|
||||
readPosition += signatureLengthLength
|
||||
signature = decryptedData[readPosition:readPosition + signatureLength]
|
||||
except:
|
||||
return None
|
||||
|
||||
if highlevelcrypto.verify(signedData, signature, hexlify(publicSigningKey)):
|
||||
logger.info('ECDSA verify passed (within decryptAndCheckPubkeyPayload)')
|
||||
else:
|
||||
logger.info('ECDSA verify failed (within decryptAndCheckPubkeyPayload)')
|
||||
return 'failed'
|
||||
publicSigningKey = "\x04" + plaintext[readPosition: readPosition + 64]
|
||||
readPosition += 64
|
||||
|
||||
sha = hashlib.new('sha512')
|
||||
sha.update(publicSigningKey + publicEncryptionKey)
|
||||
ripeHasher = hashlib.new('ripemd160')
|
||||
ripeHasher.update(sha.digest())
|
||||
embeddedRipe = ripeHasher.digest()
|
||||
publicEncryptionKey = "\x04" + plaintext[readPosition: readPosition + 64]
|
||||
readPosition += 64
|
||||
|
||||
if embeddedRipe != ripe:
|
||||
# Although this pubkey object had the tag were were looking for and was
|
||||
# encrypted with the correct encryption key, it doesn't contain the
|
||||
# correct pubkeys. Someone is either being malicious or using buggy software.
|
||||
logger.info('Pubkey decryption was UNsuccessful due to RIPE mismatch.')
|
||||
return 'failed'
|
||||
if len(publicSigningKey) != 65 or len(publicEncryptionKey) != 65:
|
||||
return None
|
||||
|
||||
# Everything checked out. Insert it into the pubkeys table.
|
||||
embeddedRipe = calculateRipeHash(publicSigningKey + publicEncryptionKey)
|
||||
|
||||
logger.info(
|
||||
os.linesep.join([
|
||||
'within decryptAndCheckPubkeyPayload,'
|
||||
' addressVersion: %s, streamNumber: %s' % addressVersion, streamNumber,
|
||||
'ripe %s' % hexlify(ripe),
|
||||
'publicSigningKey in hex: %s' % hexlify(publicSigningKey),
|
||||
'publicEncryptionKey in hex: %s' % hexlify(publicEncryptionKey),
|
||||
])
|
||||
)
|
||||
if embeddedRipe != ripe:
|
||||
logger.info("Pubkey decryption failed due to RIPE mismatch")
|
||||
|
||||
t = (address, addressVersion, storedData, int(time.time()), 'yes')
|
||||
sqlExecute('''INSERT INTO pubkeys VALUES (?,?,?,?,?)''', *t)
|
||||
return 'successful'
|
||||
except varintDecodeError:
|
||||
logger.info('Pubkey decryption was UNsuccessful due to a malformed varint.')
|
||||
return 'failed'
|
||||
except Exception:
|
||||
logger.critical(
|
||||
'Pubkey decryption was UNsuccessful because of an unhandled exception! This is definitely a bug! \n%s',
|
||||
traceback.format_exc())
|
||||
return 'failed'
|
||||
return None
|
||||
|
||||
try:
|
||||
byteDifficulty, readLength = decodeVarint(plaintext[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
|
||||
lengthExtension, readLength = decodeVarint(plaintext[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
except:
|
||||
return None
|
||||
|
||||
result += plaintext[: readPosition]
|
||||
signedData += plaintext[: readPosition]
|
||||
|
||||
signatureLength, readLength = decodeVarint(plaintext[readPosition: readPosition + 9])
|
||||
readPosition += readLength
|
||||
|
||||
signature = plaintext[readPosition: readPosition + signatureLength]
|
||||
|
||||
if len(signature) != signatureLength:
|
||||
return None
|
||||
|
||||
if not highlevelcrypto.verify(signedData, signature, hexlify(publicSigningKey)):
|
||||
logger.info("Invalid signature on a pubkey")
|
||||
|
||||
return None
|
||||
|
||||
return result
|
||||
|
||||
def checkAndShareObjectWithPeers(data):
|
||||
"""
|
||||
|
|
145
src/shared.py
|
@ -68,7 +68,6 @@ alreadyAttemptedConnectionsListLock = threading.Lock()
|
|||
alreadyAttemptedConnectionsListResetTime = int(time.time())
|
||||
# A list of the amounts of time it took to successfully decrypt msg messages
|
||||
successfullyDecryptMessageTimings = []
|
||||
ackdataForWhichImWatching = {}
|
||||
# used by API command clientStatus
|
||||
clientHasReceivedIncomingConnections = False
|
||||
numberOfMessagesProcessed = 0
|
||||
|
@ -287,150 +286,6 @@ def fixSensitiveFilePermissions(filename, hasEnabledKeys):
|
|||
logger.exception('Keyfile permissions could not be fixed.')
|
||||
raise
|
||||
|
||||
|
||||
def isBitSetWithinBitfield(fourByteString, n):
|
||||
# Uses MSB 0 bit numbering across 4 bytes of data
|
||||
n = 31 - n
|
||||
x, = unpack('>L', fourByteString)
|
||||
return x & 2**n != 0
|
||||
|
||||
|
||||
def decryptAndCheckPubkeyPayload(data, address):
|
||||
"""
|
||||
Version 4 pubkeys are encrypted. This function is run when we
|
||||
already have the address to which we want to try to send a message.
|
||||
The 'data' may come either off of the wire or we might have had it
|
||||
already in our inventory when we tried to send a msg to this
|
||||
particular address.
|
||||
"""
|
||||
try:
|
||||
# status
|
||||
_, addressVersion, streamNumber, ripe = decodeAddress(address)
|
||||
|
||||
readPosition = 20 # bypass the nonce, time, and object type
|
||||
embeddedAddressVersion, varintLength = \
|
||||
decodeVarint(data[readPosition:readPosition + 10])
|
||||
readPosition += varintLength
|
||||
embeddedStreamNumber, varintLength = \
|
||||
decodeVarint(data[readPosition:readPosition + 10])
|
||||
readPosition += varintLength
|
||||
# We'll store the address version and stream number
|
||||
# (and some more) in the pubkeys table.
|
||||
storedData = data[20:readPosition]
|
||||
|
||||
if addressVersion != embeddedAddressVersion:
|
||||
logger.info(
|
||||
'Pubkey decryption was UNsuccessful'
|
||||
' due to address version mismatch.')
|
||||
return 'failed'
|
||||
if streamNumber != embeddedStreamNumber:
|
||||
logger.info(
|
||||
'Pubkey decryption was UNsuccessful'
|
||||
' due to stream number mismatch.')
|
||||
return 'failed'
|
||||
|
||||
tag = data[readPosition:readPosition + 32]
|
||||
readPosition += 32
|
||||
# the time through the tag. More data is appended onto
|
||||
# signedData below after the decryption.
|
||||
signedData = data[8:readPosition]
|
||||
encryptedData = data[readPosition:]
|
||||
|
||||
# Let us try to decrypt the pubkey
|
||||
toAddress, cryptorObject = state.neededPubkeys[tag]
|
||||
if toAddress != address:
|
||||
logger.critical(
|
||||
'decryptAndCheckPubkeyPayload failed due to toAddress'
|
||||
' mismatch. This is very peculiar.'
|
||||
' toAddress: %s, address %s',
|
||||
toAddress, address
|
||||
)
|
||||
# the only way I can think that this could happen
|
||||
# is if someone encodes their address data two different ways.
|
||||
# That sort of address-malleability should have been caught
|
||||
# by the UI or API and an error given to the user.
|
||||
return 'failed'
|
||||
try:
|
||||
decryptedData = cryptorObject.decrypt(encryptedData)
|
||||
except:
|
||||
# Someone must have encrypted some data with a different key
|
||||
# but tagged it with a tag for which we are watching.
|
||||
logger.info('Pubkey decryption was unsuccessful.')
|
||||
return 'failed'
|
||||
|
||||
readPosition = 0
|
||||
# bitfieldBehaviors = decryptedData[readPosition:readPosition + 4]
|
||||
readPosition += 4
|
||||
publicSigningKey = \
|
||||
'\x04' + decryptedData[readPosition:readPosition + 64]
|
||||
readPosition += 64
|
||||
publicEncryptionKey = \
|
||||
'\x04' + decryptedData[readPosition:readPosition + 64]
|
||||
readPosition += 64
|
||||
specifiedNonceTrialsPerByte, specifiedNonceTrialsPerByteLength = \
|
||||
decodeVarint(decryptedData[readPosition:readPosition + 10])
|
||||
readPosition += specifiedNonceTrialsPerByteLength
|
||||
specifiedPayloadLengthExtraBytes, \
|
||||
specifiedPayloadLengthExtraBytesLength = \
|
||||
decodeVarint(decryptedData[readPosition:readPosition + 10])
|
||||
readPosition += specifiedPayloadLengthExtraBytesLength
|
||||
storedData += decryptedData[:readPosition]
|
||||
signedData += decryptedData[:readPosition]
|
||||
signatureLength, signatureLengthLength = \
|
||||
decodeVarint(decryptedData[readPosition:readPosition + 10])
|
||||
readPosition += signatureLengthLength
|
||||
signature = decryptedData[readPosition:readPosition + signatureLength]
|
||||
|
||||
if not highlevelcrypto.verify(
|
||||
signedData, signature, hexlify(publicSigningKey)):
|
||||
logger.info(
|
||||
'ECDSA verify failed (within decryptAndCheckPubkeyPayload)')
|
||||
return 'failed'
|
||||
|
||||
logger.info(
|
||||
'ECDSA verify passed (within decryptAndCheckPubkeyPayload)')
|
||||
|
||||
sha = hashlib.new('sha512')
|
||||
sha.update(publicSigningKey + publicEncryptionKey)
|
||||
ripeHasher = hashlib.new('ripemd160')
|
||||
ripeHasher.update(sha.digest())
|
||||
embeddedRipe = ripeHasher.digest()
|
||||
|
||||
if embeddedRipe != ripe:
|
||||
# Although this pubkey object had the tag were were looking for
|
||||
# and was encrypted with the correct encryption key,
|
||||
# it doesn't contain the correct pubkeys. Someone is
|
||||
# either being malicious or using buggy software.
|
||||
logger.info(
|
||||
'Pubkey decryption was UNsuccessful due to RIPE mismatch.')
|
||||
return 'failed'
|
||||
|
||||
# Everything checked out. Insert it into the pubkeys table.
|
||||
|
||||
logger.info(
|
||||
'within decryptAndCheckPubkeyPayload, '
|
||||
'addressVersion: %s, streamNumber: %s\nripe %s\n'
|
||||
'publicSigningKey in hex: %s\npublicEncryptionKey in hex: %s',
|
||||
addressVersion, streamNumber, hexlify(ripe),
|
||||
hexlify(publicSigningKey), hexlify(publicEncryptionKey)
|
||||
)
|
||||
|
||||
t = (address, addressVersion, storedData, int(time.time()), 'yes')
|
||||
sqlExecute('''INSERT INTO pubkeys VALUES (?,?,?,?,?)''', *t)
|
||||
return 'successful'
|
||||
except varintDecodeError:
|
||||
logger.info(
|
||||
'Pubkey decryption was UNsuccessful due to a malformed varint.')
|
||||
return 'failed'
|
||||
except Exception:
|
||||
logger.critical(
|
||||
'Pubkey decryption was UNsuccessful because of'
|
||||
' an unhandled exception! This is definitely a bug! \n%s' %
|
||||
traceback.format_exc()
|
||||
)
|
||||
return 'failed'
|
||||
|
||||
|
||||
def checkAndShareObjectWithPeers(data):
|
||||
"""
|
||||
This function is called after either receiving an object
|
||||
|
|
942
src/singleworker.py
Normal file
|
@ -0,0 +1,942 @@
|
|||
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 is None:
|
||||
parallelism = self.workProver.defaultParallelism
|
||||
|
||||
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)
|
||||
|
||||
if addressProperties.version > 2:
|
||||
expiryTime = int(time.time() + TTL)
|
||||
else:
|
||||
expiryTime = None
|
||||
|
||||
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"
|
||||
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)
|
||||
|
||||
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, None,
|
||||
defaults.networkDefaultProofOfWorkNonceTrialsPerByte,
|
||||
defaults.networkDefaultPayloadLengthExtraBytes,
|
||||
"(For getpubkey message)".format(version),
|
||||
workDone
|
||||
)
|
|
@ -1,6 +1,11 @@
|
|||
import collections
|
||||
|
||||
# Single worker assumes, that object processor checks this dict only after a pubkey is added to the inventory or the "pubkeys" table
|
||||
# TODO: add locking?
|
||||
|
||||
neededPubkeys = {}
|
||||
watchedAckData = set()
|
||||
|
||||
streamsInWhichIAmParticipating = []
|
||||
sendDataQueues = [] # each sendData thread puts its queue in this list.
|
||||
|
||||
|
|
|
@ -28,7 +28,9 @@ class Task(object):
|
|||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not self.solver if not self.solver
if not name if not name
if not name if not name
doc string required here doc string required here
doc string required here doc string required here
docstring here docstring here
docstring here docstring here
pep8 validation pep8 validation
pep8 validation pep8 validation
docstring here please docstring here please
docstring here please docstring here please
if not self.tasks if not self.tasks
if not self.tasks if not self.tasks
pep8 validation pep8 validation
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if self.solver: if self.solver:
….
if name: if name:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
self.target = target
|
||||
|
||||
class WorkProver(threading.Thread):
|
||||
def __init__(self, codePath, GPUVendor, seed, statusUpdated):
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
# Seed must be 32 bytes
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
def __init__(self, codePath, GPUVendor, seed, statusUpdated, resultsQueue):
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
super(self.__class__, self).__init__()
|
||||
|
||||
self.availableSolvers = {
|
||||
|
@ -65,7 +67,11 @@ class WorkProver(threading.Thread):
|
|||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not self.solver if not self.solver
if not name if not name
if not name if not name
doc string required here doc string required here
doc string required here doc string required here
docstring here docstring here
docstring here docstring here
pep8 validation pep8 validation
pep8 validation pep8 validation
docstring here please docstring here please
docstring here please docstring here please
if not self.tasks if not self.tasks
if not self.tasks if not self.tasks
pep8 validation pep8 validation
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if self.solver: if self.solver:
….
if name: if name:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
self.statusUpdated = statusUpdated
|
||||
|
||||
self.commandsQueue = Queue.Queue()
|
||||
self.resultsQueue = Queue.Queue()
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
if resultsQueue is None:
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
self.resultsQueue = Queue.Queue()
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
else:
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
self.resultsQueue = resultsQueue
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
|
||||
self.solverName = None
|
||||
self.solver = None
|
||||
|
@ -86,7 +92,7 @@ class WorkProver(threading.Thread):
|
|||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not self.solver if not self.solver
if not name if not name
if not name if not name
doc string required here doc string required here
doc string required here doc string required here
docstring here docstring here
docstring here docstring here
pep8 validation pep8 validation
pep8 validation pep8 validation
docstring here please docstring here please
docstring here please docstring here please
if not self.tasks if not self.tasks
if not self.tasks if not self.tasks
pep8 validation pep8 validation
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if self.solver: if self.solver:
….
if name: if name:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
if self.solver is not None:
|
||||
status = self.solver.status
|
||||
if not self.statusUpdated: if not self.statusUpdated:
return
It's less acurate.
It's less acurate.
`self.statusUpdated` must be either a function or a `None`. If it's 0 or an empty string, it would be a programming error and further call would rise an exception making the error noticable.
|
||||
|
||||
self.statusUpdated((self.solverName, status, self.speed))
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
self.statusUpdated((self.solverName, status, self.speed, len(self.tasks)))
|
||||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not name if not name
doc string required here doc string required here
docstring here docstring here
pep8 validation pep8 validation
docstring here please docstring here please
if not self.tasks if not self.tasks
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
||||
|
||||
def setSolver(self, name, configuration):
|
||||
if name is None and self.solverName is None:
|
||||
|
|
|||
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
pass is the dangerous statement, please log it or please write a print statement atleast... pass is the dangerous statement, please log it or please write a print statement atleast...
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
parallelism = self.solver.parallelism if self.solver else 0 parallelism = self.solver.parallelism if self.solver else 0
if not name and not self.solverName if not name and not self.solverName
if not name and not self.solverName if not name and not self.solverName
logging is required for this functionality. logging is required for this functionality.
logging is required for this functionality. logging is required for this functionality.
if not self.solver if not self.solver
if not self.solver if not self.solver
if not name if not name
if not name if not name
doc string required here doc string required here
doc string required here doc string required here
docstring here docstring here
docstring here docstring here
pep8 validation pep8 validation
pep8 validation pep8 validation
docstring here please docstring here please
docstring here please docstring here please
if not self.tasks if not self.tasks
if not self.tasks if not self.tasks
pep8 validation pep8 validation
pep8 validation pep8 validation
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
@PeterSurda , I think we need optimization here. @PeterSurda , I think we need optimization here.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
`self.availableSolvers` is visible to the outside code, so it can log or print if `fast` is missing. It should show a message in GUI status bar like the current code does.
It's less readable. It's less readable.
It's less readable. It's less readable.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
It calls the It calls the `self.statusUpdated` callback and the outside code should log this and display in the GUI.
if not name and not self.solverName: if not name and not self.solverName:
pass
if not name and not self.solverName: if not name and not self.solverName:
pass
if self.solver: if self.solver:
….
if self.solver: if self.solver:
….
if name: if name:
….
if name: if name:
….
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
undefined name 'GPUSolverError' undefined name 'GPUSolverError'
|
|
@ -38,21 +38,24 @@ def threadFunction(local, remote, codePath, threadNumber):
|
|||
remove un necessary spaces remove un necessary spaces
remove un necessary spaces remove un necessary spaces
|
||||
solver = dumbsolver.DumbSolver(codePath)
|
||||
|
||||
while True:
|
||||
received = local.recv()
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
try:
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
received = local.recv()
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
|
||||
command = received[0]
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
arguments = received[1: ]
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
command = received[0]
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
arguments = received[1: ]
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
|
||||
if command == "search":
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
initialHash, target, seed, timeout = arguments
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
appendedSeed = seed + struct.pack(">Q", threadNumber)
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
if command == "search":
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
initialHash, target, seed, timeout = arguments
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
appendedSeed = seed + struct.pack(">Q", threadNumber)
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
|
||||
nonce, iterationsCount = solver.search(initialHash, target, appendedSeed, timeout)
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
nonce, iterationsCount = solver.search(initialHash, target, appendedSeed, timeout)
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
|
||||
local.send(("done", nonce, iterationsCount))
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
elif command == "shutdown":
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
local.close()
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
local.send(("done", nonce, iterationsCount))
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
elif command == "shutdown":
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
local.close()
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
|
||||
return
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
except (EOFError, IOError):
|
||||
remove un necessary spaces remove un necessary spaces
|
||||
return
|
||||
|
||||
class ForkingSolver(object):
|
||||
|
|
|||
remove un necessary spaces remove un necessary spaces
remove un necessary spaces remove un necessary spaces
|
|
@ -121,7 +121,7 @@ class TestGPUSolver(TestSolver):
|
|||
|
||||
class TestWorkProver(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.thread = __init__.WorkProver(codePath, None, seed, None)
|
||||
self.thread = __init__.WorkProver(codePath, None, seed, None, None)
|
||||
self.thread.start()
|
||||
|
||||
def checkTaskLinks(self):
|
||||
|
|
Pep8 validation here.