PyBitmessage-2021-04-27/src/class_singleWorker.py

1419 lines
63 KiB
Python
Raw Normal View History

2015-01-21 18:38:25 +01:00
from __future__ import division
import time
2017-09-21 17:24:51 +02:00
import threading
import hashlib
from struct import pack
# used when the API must execute an outside program
2018-05-02 17:29:55 +02:00
from subprocess import call # nosec
2017-09-21 17:24:51 +02:00
from binascii import hexlify, unhexlify
import tr
import l10n
import protocol
import queues
import state
2017-09-21 17:24:51 +02:00
import shared
import defaults
import highlevelcrypto
import proofofwork
import helper_inbox
import helper_random
2017-09-21 17:24:51 +02:00
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'):
2017-09-21 17:24:51 +02:00
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)
2017-09-21 17:24:51 +02:00
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
2017-09-21 17:24:51 +02:00
2015-03-09 07:35:32 +01:00
# Initialize the neededPubkeys dictionary.
2013-08-29 13:27:30 +02:00
queryreturn = sqlQuery(
2017-09-21 17:24:51 +02:00
'''SELECT DISTINCT toaddress FROM sent'''
''' WHERE (status='awaitingpubkey' AND folder='sent')''')
for row in queryreturn:
2014-08-27 09:14:32 +02:00
toAddress, = row
2018-03-22 12:23:36 +01:00
# toStatus
_, toAddressVersionNumber, toStreamNumber, toRipe = \
2017-09-21 17:24:51 +02:00
decodeAddress(toAddress)
if toAddressVersionNumber <= 3:
state.neededPubkeys[toAddress] = 0
elif toAddressVersionNumber >= 4:
2017-09-21 17:24:51 +02:00
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]
2013-09-15 03:06:26 +02:00
tag = doubleHashOfAddressData[32:]
2017-09-21 17:24:51 +02:00
# 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))
)
2014-08-27 09:14:32 +02:00
# Initialize the shared.ackdataForWhichImWatching data structure
2013-08-29 13:27:30 +02:00
queryreturn = sqlQuery(
'''SELECT ackdata FROM sent WHERE status = 'msgsent' ''')
for row in queryreturn:
ackdata, = row
2016-03-23 23:26:57 +01:00
logger.info('Watching for ackdata ' + hexlify(ackdata))
shared.ackdataForWhichImWatching[ackdata] = 0
2017-09-30 11:19:44 +02:00
# Fix legacy (headerless) watched ackdata to include header
for oldack in shared.ackdataForWhichImWatching.keys():
2017-09-21 17:24:51 +02:00
if (len(oldack) == 32):
2017-09-30 11:19:44 +02:00
# attach legacy header, always constant (msg/1/1)
newack = '\x00\x00\x00\x02\x01\x01' + oldack
shared.ackdataForWhichImWatching[newack] = 0
2017-09-21 17:24:51 +02:00
sqlExecute(
'UPDATE sent SET ackdata=? WHERE ackdata=?',
newack, oldack
)
2017-09-30 11:19:44 +02:00
del shared.ackdataForWhichImWatching[oldack]
2017-09-21 17:24:51 +02:00
# give some time for the GUI to start
# before we start on existing POW tasks.
self.stop.wait(10)
2015-03-09 07:35:32 +01:00
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
2013-07-22 07:10:22 +02:00
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:
2017-09-21 17:24:51 +02:00
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
2017-09-21 17:24:51 +02:00
# This function also broadcasts out the pubkey message
# once it is done with the POW
2018-05-02 17:29:55 +02:00
def doPOWForMyV2Pubkey(self, adressHash):
# Look up my stream number based on my address hash
"""configSections = shared.config.addresses()
for addressInKeysFile in configSections:
2017-09-21 17:24:51 +02:00
if addressInKeysFile != 'bitmessagesettings':
status, addressVersionNumber, streamNumber, \
hashFromThisParticularAddress = \
decodeAddress(addressInKeysFile)
if hash == hashFromThisParticularAddress:
myAddress = addressInKeysFile
break"""
2018-05-02 17:29:55 +02:00
myAddress = shared.myAddressesByHash[adressHash]
2018-03-22 12:23:36 +01:00
# status
2018-05-02 17:29:55 +02:00
_, addressVersionNumber, streamNumber, adressHash = decodeAddress(myAddress)
2017-09-21 17:24:51 +02:00
# 28 days from now plus or minus five minutes
TTL = int(28 * 24 * 60 * 60 + helper_random.randomrandrange(-300, 300))
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
2014-08-27 09:14:32 +02:00
payload = pack('>Q', (embeddedTime))
2017-09-21 17:24:51 +02:00
payload += '\x00\x00\x00\x01' # object type: pubkey
payload += encodeVarint(addressVersionNumber) # Address version number
payload += encodeVarint(streamNumber)
2017-09-21 17:24:51 +02:00
# 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:
2017-09-21 17:24:51 +02:00
logger.error(
'Error within doPOWForMyV2Pubkey. Could not read'
' the keys from the keys.dat file for a requested'
' address. %s\n', err
2017-09-21 17:24:51 +02:00
)
return
payload += pubSigningKey + pubEncryptionKey
# Do the POW for this pubkey message
payload = self._doPOWDefaults(
payload, TTL, log_prefix='(For pubkey message)')
inventoryHash = calculateInventoryHash(payload)
2014-08-27 09:14:32 +02:00
objectType = 1
Inventory()[inventoryHash] = (
2017-09-21 17:24:51 +02:00
objectType, streamNumber, payload, embeddedTime, '')
2017-09-21 17:24:51 +02:00
logger.info('broadcasting inv with hash: %s', hexlify(inventoryHash))
queues.invQueue.put((streamNumber, inventoryHash))
queues.UISignalQueue.put(('updateStatusBar', ''))
2013-11-07 05:38:19 +01:00
try:
BMConfigParser().set(
2013-11-07 05:38:19 +01:00
myAddress, 'lastpubkeysendtime', str(int(time.time())))
BMConfigParser().save()
2013-11-07 05:38:19 +01:00
except:
2017-09-21 17:24:51 +02:00
# The user deleted the address out of the keys.dat file
# before this finished.
2013-11-07 05:38:19 +01:00
pass
2013-07-22 07:10:22 +02:00
# 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".
2018-05-02 17:29:55 +02:00
def sendOutOrStoreMyV3Pubkey(self, adressHash):
2013-11-07 05:38:19 +01:00
try:
2018-05-02 17:29:55 +02:00
myAddress = shared.myAddressesByHash[adressHash]
2013-11-07 05:38:19 +01:00
except:
2017-09-21 17:24:51 +02:00
# The address has been deleted.
2013-11-07 05:38:19 +01:00
return
if BMConfigParser().safeGetBoolean(myAddress, 'chan'):
logger.info('This is a chan address. Not sending pubkey.')
2013-09-30 01:24:27 +02:00
return
2018-05-02 17:29:55 +02:00
_, addressVersionNumber, streamNumber, adressHash = decodeAddress(
myAddress)
# 28 days from now plus or minus five minutes
2017-09-21 17:24:51 +02:00
TTL = int(28 * 24 * 60 * 60 + helper_random.randomrandrange(-300, 300))
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
2018-05-02 17:29:55 +02:00
2017-09-21 17:24:51 +02:00
# signedTimeForProtocolV2 = embeddedTime - TTL
2018-05-02 17:29:55 +02:00
# 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.
2014-08-27 09:14:32 +02:00
payload = pack('>Q', (embeddedTime))
2017-09-21 17:24:51 +02:00
payload += '\x00\x00\x00\x01' # object type: pubkey
payload += encodeVarint(addressVersionNumber) # Address version number
payload += encodeVarint(streamNumber)
2017-09-21 17:24:51 +02:00
# bitfield of features supported by me (see the wiki).
payload += protocol.getBitfield(myAddress)
try:
2018-03-22 12:23:36 +01:00
# , privEncryptionKeyHex
privSigningKeyHex, _, pubSigningKey, pubEncryptionKey = \
self._getKeysForAddress(myAddress)
except Exception as err:
2017-09-21 17:24:51 +02:00
logger.error(
'Error within sendOutOrStoreMyV3Pubkey. Could not read'
' the keys from the keys.dat file for a requested'
' address. %s\n', err
2017-09-21 17:24:51 +02:00
)
return
payload += pubSigningKey + pubEncryptionKey
payload += encodeVarint(BMConfigParser().getint(
myAddress, 'noncetrialsperbyte'))
payload += encodeVarint(BMConfigParser().getint(
myAddress, 'payloadlengthextrabytes'))
2017-09-21 17:24:51 +02:00
2014-12-25 09:57:34 +01:00
signature = highlevelcrypto.sign(payload, privSigningKeyHex)
payload += encodeVarint(len(signature))
payload += signature
2013-09-30 01:24:27 +02:00
# Do the POW for this pubkey message
payload = self._doPOWDefaults(
payload, TTL, log_prefix='(For pubkey message)')
2013-09-30 01:24:27 +02:00
inventoryHash = calculateInventoryHash(payload)
2014-08-27 09:14:32 +02:00
objectType = 1
Inventory()[inventoryHash] = (
2017-09-21 17:24:51 +02:00
objectType, streamNumber, payload, embeddedTime, '')
2016-03-23 23:26:57 +01:00
logger.info('broadcasting inv with hash: ' + hexlify(inventoryHash))
queues.invQueue.put((streamNumber, inventoryHash))
queues.UISignalQueue.put(('updateStatusBar', ''))
2013-11-07 05:38:19 +01:00
try:
BMConfigParser().set(
2013-11-07 05:38:19 +01:00
myAddress, 'lastpubkeysendtime', str(int(time.time())))
BMConfigParser().save()
2013-11-07 05:38:19 +01:00
except:
# The user deleted the address out of the keys.dat file
# before this finished.
2013-11-07 05:38:19 +01:00
pass
2017-09-21 17:24:51 +02:00
# 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):
2017-09-21 17:24:51 +02:00
# The address has been deleted.
2013-11-07 05:38:19 +01:00
return
if shared.BMConfigParser().safeGetBoolean(myAddress, 'chan'):
logger.info('This is a chan address. Not sending pubkey.')
2013-09-30 01:24:27 +02:00
return
2018-05-02 17:29:55 +02:00
_, addressVersionNumber, streamNumber, addressHash = decodeAddress(
myAddress)
2017-09-21 17:24:51 +02:00
# 28 days from now plus or minus five minutes
2017-09-21 17:24:51 +02:00
TTL = int(28 * 24 * 60 * 60 + helper_random.randomrandrange(-300, 300))
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
payload = pack('>Q', (embeddedTime))
2017-09-21 17:24:51 +02:00
payload += '\x00\x00\x00\x01' # object type: pubkey
payload += encodeVarint(addressVersionNumber) # Address version number
payload += encodeVarint(streamNumber)
dataToEncrypt = protocol.getBitfield(myAddress)
try:
2018-03-22 12:48:07 +01:00
# , privEncryptionKeyHex
privSigningKeyHex, _, pubSigningKey, pubEncryptionKey = \
self._getKeysForAddress(myAddress)
except Exception as err:
2017-09-21 17:24:51 +02:00
logger.error(
'Error within sendOutOrStoreMyV4Pubkey. Could not read'
' the keys from the keys.dat file for a requested'
' address. %s\n', err
2017-09-21 17:24:51 +02:00
)
return
dataToEncrypt += pubSigningKey + pubEncryptionKey
dataToEncrypt += encodeVarint(BMConfigParser().getint(
myAddress, 'noncetrialsperbyte'))
dataToEncrypt += encodeVarint(BMConfigParser().getint(
myAddress, 'payloadlengthextrabytes'))
2017-09-21 17:24:51 +02:00
2014-08-27 09:14:32 +02:00
# When we encrypt, we'll use a hash of the data
2017-09-21 17:24:51 +02:00
# 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) +
2018-05-02 17:29:55 +02:00
encodeVarint(streamNumber) + addressHash
2017-09-21 17:24:51 +02:00
).digest()).digest()
payload += doubleHashOfAddressData[32:] # the tag
signature = highlevelcrypto.sign(
payload + dataToEncrypt, privSigningKeyHex
)
2014-08-27 09:14:32 +02:00
dataToEncrypt += encodeVarint(len(signature))
dataToEncrypt += signature
2017-09-21 17:24:51 +02:00
2013-09-30 01:24:27 +02:00
privEncryptionKey = doubleHashOfAddressData[:32]
pubEncryptionKey = highlevelcrypto.pointMult(privEncryptionKey)
2013-09-30 01:24:27 +02:00
payload += highlevelcrypto.encrypt(
2016-03-23 23:26:57 +01:00
dataToEncrypt, hexlify(pubEncryptionKey))
2013-09-18 06:04:01 +02:00
2013-09-30 01:24:27 +02:00
# Do the POW for this pubkey message
payload = self._doPOWDefaults(
payload, TTL, log_prefix='(For pubkey message)')
2013-09-30 01:24:27 +02:00
inventoryHash = calculateInventoryHash(payload)
2014-08-27 09:14:32 +02:00
objectType = 1
Inventory()[inventoryHash] = (
2017-09-21 17:24:51 +02:00
objectType, streamNumber, payload, embeddedTime,
doubleHashOfAddressData[32:]
)
2016-03-23 23:26:57 +01:00
logger.info('broadcasting inv with hash: ' + hexlify(inventoryHash))
2013-09-18 06:04:01 +02:00
queues.invQueue.put((streamNumber, inventoryHash))
queues.UISignalQueue.put(('updateStatusBar', ''))
try:
BMConfigParser().set(
myAddress, 'lastpubkeysendtime', str(int(time.time())))
BMConfigParser().save()
except Exception as err:
2017-09-21 17:24:51 +02:00
logger.error(
'Error: Couldn\'t add the lastpubkeysendtime'
' to the keys.dat file. Error message: %s', err
2017-09-21 17:24:51 +02:00
)
def sendBroadcast(self):
# Reset just in case
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET status='broadcastqueued' '''
2018-05-02 17:29:55 +02:00
2017-09-21 17:24:51 +02:00
'''WHERE status = 'doingbroadcastpow' ''')
2013-08-29 13:27:30 +02:00
queryreturn = sqlQuery(
2017-09-21 17:24:51 +02:00
'''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
2018-03-22 12:23:36 +01:00
# status
_, addressVersionNumber, streamNumber, ripe = \
2017-09-21 17:24:51 +02:00
decodeAddress(fromaddress)
if addressVersionNumber <= 1:
2017-09-21 17:24:51 +02:00
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:
2018-03-22 12:48:07 +01:00
# , privEncryptionKeyHex
privSigningKeyHex, _, pubSigningKey, pubEncryptionKey = \
self._getKeysForAddress(fromaddress)
except:
2017-09-21 17:24:51 +02:00
queues.UISignalQueue.put((
'updateSentItemStatusByAckdata', (
ackdata,
tr._translate(
"MainWindow",
"Error! Could not find sender address"
" (your address) in the keys.dat file."))
))
continue
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET status='doingbroadcastpow' '''
''' WHERE ackdata=? AND status='broadcastqueued' ''',
ackdata)
2017-09-21 17:24:51 +02:00
# 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')
2015-03-09 07:35:32 +01:00
if TTL > 28 * 24 * 60 * 60:
TTL = 28 * 24 * 60 * 60
2017-09-21 17:24:51 +02:00
if TTL < 60 * 60:
TTL = 60 * 60
# add some randomness to the TTL
2017-09-21 17:24:51 +02:00
TTL = int(TTL + helper_random.randomrandrange(-300, 300))
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
2014-08-27 09:14:32 +02:00
payload = pack('>Q', embeddedTime)
2017-09-21 17:24:51 +02:00
payload += '\x00\x00\x00\x03' # object type: broadcast
2014-12-25 09:57:34 +01:00
if addressVersionNumber <= 3:
payload += encodeVarint(4) # broadcast version
else:
payload += encodeVarint(5) # broadcast version
2017-09-21 17:24:51 +02:00
payload += encodeVarint(streamNumber)
2013-09-15 03:06:26 +02:00
if addressVersionNumber >= 4:
2017-09-21 17:24:51 +02:00
doubleHashOfAddressData = hashlib.sha512(hashlib.sha512(
encodeVarint(addressVersionNumber) +
encodeVarint(streamNumber) + ripe
).digest()).digest()
tag = doubleHashOfAddressData[32:]
payload += tag
else:
tag = ''
2014-12-25 09:57:34 +01:00
dataToEncrypt = encodeVarint(addressVersionNumber)
dataToEncrypt += encodeVarint(streamNumber)
2017-09-21 17:24:51 +02:00
# behavior bitfield
dataToEncrypt += protocol.getBitfield(fromaddress)
dataToEncrypt += pubSigningKey + pubEncryptionKey
if addressVersionNumber >= 3:
2017-09-21 17:24:51 +02:00
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
2014-12-25 09:57:34 +01:00
dataToSign = payload + dataToEncrypt
2017-09-21 17:24:51 +02:00
signature = highlevelcrypto.sign(
2014-08-27 09:14:32 +02:00
dataToSign, privSigningKeyHex)
dataToEncrypt += encodeVarint(len(signature))
dataToEncrypt += signature
2017-09-21 17:24:51 +02:00
# 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.
2013-09-15 03:06:26 +02:00
if addressVersionNumber <= 3:
2017-09-21 17:24:51 +02:00
privEncryptionKey = hashlib.sha512(
encodeVarint(addressVersionNumber) +
encodeVarint(streamNumber) + ripe
).digest()[:32]
2013-09-15 03:06:26 +02:00
else:
privEncryptionKey = doubleHashOfAddressData[:32]
pubEncryptionKey = highlevelcrypto.pointMult(privEncryptionKey)
payload += highlevelcrypto.encrypt(
2016-03-23 23:26:57 +01:00
dataToEncrypt, hexlify(pubEncryptionKey))
2017-09-21 17:24:51 +02:00
queues.UISignalQueue.put((
'updateSentItemStatusByAckdata', (
ackdata,
tr._translate(
"MainWindow",
"Doing work necessary to send broadcast..."))
))
payload = self._doPOWDefaults(
payload, TTL, log_prefix='(For broadcast message)')
2017-09-21 17:24:51 +02:00
# 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)
)
2014-08-27 09:14:32 +02:00
continue
inventoryHash = calculateInventoryHash(payload)
2014-08-27 09:14:32 +02:00
objectType = 3
Inventory()[inventoryHash] = (
2014-08-27 09:14:32 +02:00
objectType, streamNumber, payload, embeddedTime, tag)
2017-09-21 17:24:51 +02:00
logger.info(
'sending inv (within sendBroadcast function)'
' for object: %s',
hexlify(inventoryHash)
)
queues.invQueue.put((streamNumber, inventoryHash))
2017-09-21 17:24:51 +02:00
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
2013-08-29 13:27:30 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'UPDATE sent SET msgid=?, status=?, lastactiontime=?'
' WHERE ackdata=?',
inventoryHash, 'broadcastsent', int(time.time()), ackdata
)
def sendMsg(self):
# Reset just in case
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET status='msgqueued' '''
''' WHERE status IN ('doingpubkeypow', 'doingmsgpow')''')
queryreturn = sqlQuery(
2017-09-21 17:24:51 +02:00
'''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
2018-03-22 12:48:07 +01:00
# toStatus
_, toAddressVersionNumber, toStreamNumber, toRipe = \
2017-09-21 17:24:51 +02:00
decodeAddress(toaddress)
2018-03-22 12:23:36 +01:00
# fromStatus, , ,fromRipe
_, fromAddressVersionNumber, fromStreamNumber, _ = \
decodeAddress(fromaddress)
2017-09-21 17:24:51 +02:00
# We may or may not already have the pubkey
# for this toAddress. Let's check.
2014-08-27 09:14:32 +02:00
if status == 'forcepow':
2017-09-21 17:24:51 +02:00
# 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.
2014-08-27 09:14:32 +02:00
pass
2015-03-09 07:35:32 +01:00
elif status == 'doingmsgpow':
2017-09-21 17:24:51 +02:00
# 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.
2015-03-09 07:35:32 +01:00
pass
2017-09-21 17:24:51 +02:00
# 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):
2013-08-29 13:27:30 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET status='doingmsgpow' '''
''' WHERE toaddress=? AND status='msgqueued' ''',
toaddress
)
status = 'doingmsgpow'
2015-03-09 07:35:32 +01:00
elif status == 'msgqueued':
2014-08-27 09:14:32 +02:00
# Let's see if we already have the pubkey in our pubkeys table
queryreturn = sqlQuery(
2017-09-21 17:24:51 +02:00
'''SELECT address FROM pubkeys WHERE address=?''',
toaddress
)
# If we have the needed pubkey in the pubkey table already,
if queryreturn != []:
2014-08-27 09:14:32 +02:00
# set the status of this msg to doingmsgpow
2013-08-29 13:27:30 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET status='doingmsgpow' '''
''' WHERE toaddress=? AND status='msgqueued' ''',
toaddress
)
2014-08-27 09:14:32 +02:00
status = 'doingmsgpow'
2017-09-21 17:24:51 +02:00
# 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
2015-03-09 07:35:32 +01:00
# usedpersonally v4 pubkeys in the pubkeys table.
2014-08-27 09:14:32 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE pubkeys SET usedpersonally='yes' '''
''' WHERE address=?''',
toaddress
)
# We don't have the needed pubkey in the pubkeys table already.
else:
2014-08-27 09:14:32 +02:00
if toAddressVersionNumber <= 3:
toTag = ''
else:
2017-09-21 17:24:51 +02:00
toTag = hashlib.sha512(hashlib.sha512(
encodeVarint(toAddressVersionNumber) +
encodeVarint(toStreamNumber) + toRipe
).digest()).digest()[32:]
if toaddress in state.neededPubkeys or \
toTag in state.neededPubkeys:
2014-08-27 09:14:32 +02:00
# We already sent a request for the pubkey
2013-09-15 03:06:26 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'''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
2014-08-27 09:14:32 +02:00
else:
# We have not yet sent a request for the pubkey
needToRequestPubkey = True
2017-09-21 17:24:51 +02:00
# 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))
)
2016-03-18 02:01:59 +01:00
for value in Inventory().by_type_and_tag(1, toTag):
2017-09-21 17:24:51 +02:00
# if valid, this function also puts it
# in the pubkeys table.
if shared.decryptAndCheckPubkeyPayload(
value.payload, toaddress
) == 'successful':
2016-03-18 02:01:59 +01:00
needToRequestPubkey = False
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET '''
''' status='doingmsgpow', '''
''' retrynumber=0 WHERE '''
''' toaddress=? AND '''
''' (status='msgqueued' or '''
''' status='awaitingpubkey' or '''
''' status='doingpubkeypow')''',
2016-03-18 02:01:59 +01:00
toaddress)
del state.neededPubkeys[tag]
2016-03-18 02:01:59 +01:00
break
2017-09-21 17:24:51 +02:00
# 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.
2014-08-27 09:14:32 +02:00
if needToRequestPubkey:
sqlExecute(
2017-09-21 17:24:51 +02:00
'''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."))
))
2014-08-27 09:14:32 +02:00
self.requestPubKey(toaddress)
2017-09-21 17:24:51 +02:00
# on with the next msg on which we can do some work
continue
2017-09-21 17:24:51 +02:00
# 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
2017-09-21 17:24:51 +02:00
TTL = int(TTL + helper_random.randomrandrange(-300, 300))
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
2017-09-21 17:24:51 +02:00
# if we aren't sending this to ourselves or a chan
if not BMConfigParser().has_section(toaddress):
2013-09-30 01:24:27 +02:00
shared.ackdataForWhichImWatching[ackdata] = 0
2017-09-21 17:24:51 +02:00
queues.UISignalQueue.put((
'updateSentItemStatusByAckdata', (
ackdata,
tr._translate(
"MainWindow",
"Looking up the receiver\'s public key"))
))
logger.info('Sending a message.')
2017-09-21 17:24:51 +02:00
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.
2013-09-30 01:24:27 +02:00
queryreturn = sqlQuery(
2015-03-09 07:35:32 +01:00
'SELECT transmitdata FROM pubkeys WHERE address=?',
toaddress)
2013-09-30 01:24:27 +02:00
for row in queryreturn:
pubkeyPayload, = row
2017-09-21 17:24:51 +02:00
# The pubkey message is stored with the following items
# all appended:
2014-12-25 09:57:34 +01:00
# -address version
# -stream number
# -behavior bitfield
# -pub signing key
# -pub encryption key
2017-09-21 17:24:51 +02:00
# -nonce trials per byte (if address version is >= 3)
2014-12-25 09:57:34 +01:00
# -length extra bytes (if address version is >= 3)
2017-09-21 17:24:51 +02:00
# to bypass the address version whose length is definitely 1
readPosition = 1
2018-05-02 17:29:55 +02:00
_, streamNumberLength = decodeVarint(
pubkeyPayload[readPosition:readPosition + 10])
2013-09-30 01:24:27 +02:00
readPosition += streamNumberLength
behaviorBitfield = pubkeyPayload[readPosition:readPosition + 4]
2017-09-21 17:24:51 +02:00
# 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
2013-09-30 01:24:27 +02:00
# in the settings menu to allow it.
2017-09-21 17:24:51 +02:00
# 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.
2013-09-30 01:24:27 +02:00
continue
readPosition += 4 # to bypass the bitfield of behaviors
2017-09-21 17:24:51 +02:00
# We don't use this key for anything here.
# pubSigningKeyBase256 =
# pubkeyPayload[readPosition:readPosition+64]
2013-09-30 01:24:27 +02:00
readPosition += 64
pubEncryptionKeyBase256 = pubkeyPayload[
readPosition:readPosition + 64]
readPosition += 64
# Let us fetch the amount of work required by the recipient.
if toAddressVersionNumber == 2:
2017-09-21 17:24:51 +02:00
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."))
))
2013-09-30 01:24:27 +02:00
elif toAddressVersionNumber >= 3:
2017-09-21 17:24:51 +02:00
requiredAverageProofOfWorkNonceTrialsPerByte, \
varintLength = decodeVarint(
pubkeyPayload[readPosition:readPosition + 10])
2013-09-30 01:24:27 +02:00
readPosition += varintLength
2017-09-21 17:24:51 +02:00
requiredPayloadLengthExtraBytes, varintLength = \
decodeVarint(
pubkeyPayload[readPosition:readPosition + 10])
2013-09-30 01:24:27 +02:00
readPosition += varintLength
2017-09-21 17:24:51 +02:00
# 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 < \
2018-05-02 17:29:55 +02:00
defaults.networkDefaultProofOfWorkNonceTrialsPerByte:
2017-09-21 17:24:51 +02:00
requiredAverageProofOfWorkNonceTrialsPerByte = \
defaults.networkDefaultProofOfWorkNonceTrialsPerByte
if requiredPayloadLengthExtraBytes < \
defaults.networkDefaultPayloadLengthExtraBytes:
requiredPayloadLengthExtraBytes = \
defaults.networkDefaultPayloadLengthExtraBytes
logger.debug(
'Using averageProofOfWorkNonceTrialsPerByte: %s'
' and payloadLengthExtraBytes: %s.',
requiredAverageProofOfWorkNonceTrialsPerByte,
requiredPayloadLengthExtraBytes
)
2017-09-21 17:24:51 +02:00
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
)))))
2013-09-30 01:24:27 +02:00
if status != 'forcepow':
2017-09-21 17:24:51 +02:00
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.
2013-09-30 01:24:27 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'''UPDATE sent SET status='toodifficult' '''
''' WHERE ackdata=? ''',
2013-09-30 01:24:27 +02:00
ackdata)
2017-09-21 17:24:51 +02:00
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()))
))
2013-09-30 01:24:27 +02:00
continue
2017-09-21 17:24:51 +02:00
else: # if we are sending a message to ourselves or a chan..
logger.info('Sending a message.')
2017-09-21 17:24:51 +02:00
logger.debug(
'First 150 characters of message: %r', message[:150])
behaviorBitfield = protocol.getBitfield(fromaddress)
2013-09-30 01:24:27 +02:00
try:
privEncryptionKeyBase58 = BMConfigParser().get(
2013-09-30 01:24:27 +02:00
toaddress, 'privencryptionkey')
except Exception as err:
2017-09-21 17:24:51 +02:00
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()))
))
2017-09-21 17:24:51 +02:00
logger.error(
'Error within sendMsg. Could not read the keys'
' from the keys.dat file for our own address. %s\n',
err)
2013-09-30 01:24:27 +02:00
continue
2016-03-23 23:26:57 +01:00
privEncryptionKeyHex = hexlify(shared.decodeWalletImportFormat(
privEncryptionKeyBase58))
pubEncryptionKeyBase256 = unhexlify(highlevelcrypto.privToPub(
privEncryptionKeyHex))[1:]
2017-09-21 17:24:51 +02:00
requiredAverageProofOfWorkNonceTrialsPerByte = \
defaults.networkDefaultProofOfWorkNonceTrialsPerByte
requiredPayloadLengthExtraBytes = \
defaults.networkDefaultPayloadLengthExtraBytes
queues.UISignalQueue.put((
'updateSentItemStatusByAckdata', (
ackdata,
tr._translate(
"MainWindow",
"Doing work necessary to send message."))
))
2014-12-25 09:57:34 +01:00
# Now we can start to assemble our message.
payload = encodeVarint(fromAddressVersionNumber)
payload += encodeVarint(fromStreamNumber)
2017-09-21 17:24:51 +02:00
# 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)
2014-12-25 09:57:34 +01:00
# We need to convert our private keys to public keys in order
# to include them.
try:
privSigningKeyHex, privEncryptionKeyHex, \
pubSigningKey, pubEncryptionKey = self._getKeysForAddress(
fromaddress)
2014-12-25 09:57:34 +01:00
except:
2017-09-21 17:24:51 +02:00
queues.UISignalQueue.put((
'updateSentItemStatusByAckdata', (
ackdata,
tr._translate(
"MainWindow",
"Error! Could not find sender address"
" (your address) in the keys.dat file."))
))
2014-12-25 09:57:34 +01:00
continue
payload += pubSigningKey + pubEncryptionKey
2014-12-25 09:57:34 +01:00
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.
2017-09-21 17:24:51 +02:00
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'))
2017-09-21 17:24:51 +02:00
# 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):
2017-09-21 17:24:51 +02:00
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.'
)
2014-12-25 09:57:34 +01:00
fullAckPayload = ''
else:
2017-09-21 17:24:51 +02:00
# 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.
2014-12-25 09:57:34 +01:00
fullAckPayload = self.generateFullAckMessage(
2017-09-21 17:24:51 +02:00
ackdata, toStreamNumber, TTL)
2014-12-25 09:57:34 +01:00
payload += encodeVarint(len(fullAckPayload))
payload += fullAckPayload
2017-09-21 17:24:51 +02:00
dataToSign = pack('>Q', embeddedTime) + '\x00\x00\x00\x02' + \
encodeVarint(1) + encodeVarint(toStreamNumber) + payload
2014-12-25 09:57:34 +01:00
signature = highlevelcrypto.sign(dataToSign, privSigningKeyHex)
payload += encodeVarint(len(signature))
payload += signature
# We have assembled the data that will be encrypted.
try:
2017-09-21 17:24:51 +02:00
encrypted = highlevelcrypto.encrypt(
payload, "04" + hexlify(pubEncryptionKeyBase256)
)
except:
2017-09-21 17:24:51 +02:00
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
2017-09-21 17:24:51 +02:00
2014-08-27 09:14:32 +02:00
encryptedPayload = pack('>Q', embeddedTime)
2017-09-21 17:24:51 +02:00
encryptedPayload += '\x00\x00\x00\x02' # object type: msg
encryptedPayload += encodeVarint(1) # msg version
2014-08-27 09:14:32 +02:00
encryptedPayload += encodeVarint(toStreamNumber) + encrypted
2017-09-21 17:24:51 +02:00
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)
2017-09-21 17:24:51 +02:00
logger.info(
'(For msg message) Found proof of work %s Nonce: %s',
trialValue, nonce
)
try:
2017-09-21 17:24:51 +02:00
logger.info(
'PoW took %.1f seconds, speed %s.',
time.time() - powStartTime,
sizeof_fmt(nonce / (time.time() - powStartTime))
)
except:
pass
encryptedPayload = pack('>Q', nonce) + encryptedPayload
2017-09-21 17:24:51 +02:00
# 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)
)
2014-08-27 09:14:32 +02:00
continue
inventoryHash = calculateInventoryHash(encryptedPayload)
2014-08-27 09:14:32 +02:00
objectType = 2
Inventory()[inventoryHash] = (
2014-08-27 09:14:32 +02:00
objectType, toStreamNumber, encryptedPayload, embeddedTime, '')
2017-09-21 17:24:51 +02:00
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()))
))
2013-07-22 07:10:22 +02:00
else:
2013-09-30 01:24:27 +02:00
# not sending to a chan or one of my addresses
2017-09-21 17:24:51 +02:00
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))
2017-09-21 17:24:51 +02:00
# 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):
2013-07-22 07:10:22 +02:00
newStatus = 'msgsentnoackexpected'
else:
newStatus = 'msgsent'
# wait 10% past expiration
sleepTill = int(time.time() + TTL * 1.1)
2017-09-21 17:24:51 +02:00
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):
2017-09-21 17:24:51 +02:00
# Used to detect and ignore duplicate messages in our inbox
sigHash = hashlib.sha512(hashlib.sha512(
signature).digest()).digest()[32:]
2013-09-30 05:01:56 +02:00
t = (inventoryHash, toaddress, fromaddress, subject, int(
time.time()), message, 'inbox', encoding, 0, sigHash)
2013-09-30 05:01:56 +02:00
helper_inbox.insert(t)
queues.UISignalQueue.put(('displayNewInboxMessage', (
2013-09-30 05:01:56 +02:00
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.
2017-09-21 17:24:51 +02:00
if BMConfigParser().safeGetBoolean(
'bitmessagesettings', 'apienabled'):
2013-09-30 05:01:56 +02:00
try:
apiNotifyPath = BMConfigParser().get(
2013-09-30 05:01:56 +02:00
'bitmessagesettings', 'apinotifypath')
except:
apiNotifyPath = ''
if apiNotifyPath != '':
2018-05-08 13:53:58 +02:00
call([apiNotifyPath, "newMessage"])
2013-09-30 05:01:56 +02:00
def requestPubKey(self, toAddress):
toStatus, addressVersionNumber, streamNumber, ripe = decodeAddress(
toAddress)
if toStatus != 'success':
2017-09-21 17:24:51 +02:00
logger.error(
'Very abnormal error occurred in requestPubKey.'
' toAddress is: %r. Please report this error to Atheros.',
toAddress
)
return
2017-09-21 17:24:51 +02:00
2015-03-09 07:35:32 +01:00
queryReturn = sqlQuery(
2017-09-21 17:24:51 +02:00
'''SELECT retrynumber FROM sent WHERE toaddress=? '''
''' AND (status='doingpubkeypow' OR status='awaitingpubkey') '''
''' LIMIT 1''',
toAddress
)
2015-03-09 07:35:32 +01:00
if len(queryReturn) == 0:
2017-09-21 17:24:51 +02:00
logger.critical(
'BUG: Why are we requesting the pubkey for %s'
' if there are no messages in the sent folder'
' to that address?', toAddress
)
2015-03-09 07:35:32 +01:00
return
retryNumber = queryReturn[0][0]
if addressVersionNumber <= 3:
state.neededPubkeys[toAddress] = 0
elif addressVersionNumber >= 4:
2017-09-21 17:24:51 +02:00
# 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:
2017-09-21 17:24:51 +02:00
# 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)
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
2014-08-27 09:14:32 +02:00
payload = pack('>Q', embeddedTime)
2017-09-21 17:24:51 +02:00
payload += '\x00\x00\x00\x00' # object type: getpubkey
payload += encodeVarint(addressVersionNumber)
payload += encodeVarint(streamNumber)
if addressVersionNumber <= 3:
payload += ripe
2017-09-21 17:24:51 +02:00
logger.info(
'making request for pubkey with ripe: %s', hexlify(ripe))
else:
2013-09-15 03:06:26 +02:00
payload += tag
2017-09-21 17:24:51 +02:00
logger.info(
'making request for v4 pubkey with tag: %s', hexlify(tag))
# print 'trial value', trialValue
2017-09-21 17:24:51 +02:00
statusbar = 'Doing the computations necessary to request' +\
' the recipient\'s public key.'
queues.UISignalQueue.put(('updateStatusBar', statusbar))
2017-09-21 17:24:51 +02:00
queues.UISignalQueue.put((
'updateSentItemStatusByToAddress', (
toAddress,
tr._translate(
"MainWindow",
"Doing work necessary to request encryption key."))
))
payload = self._doPOWDefaults(payload, TTL)
inventoryHash = calculateInventoryHash(payload)
2014-08-27 09:14:32 +02:00
objectType = 1
Inventory()[inventoryHash] = (
2014-08-27 09:14:32 +02:00
objectType, streamNumber, payload, embeddedTime, '')
logger.info('sending inv (for the getpubkey message)')
queues.invQueue.put((streamNumber, inventoryHash))
2017-09-21 17:24:51 +02:00
# wait 10% past expiration
sleeptill = int(time.time() + TTL * 1.1)
2013-08-29 13:27:30 +02:00
sqlExecute(
2017-09-21 17:24:51 +02:00
'''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((
2017-09-21 17:24:51 +02:00
'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()))
))
2015-03-09 07:35:32 +01:00
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
2017-09-21 17:24:51 +02:00
# it be more difficult for attackers to associate ackData with
2015-03-09 07:35:32 +01:00
# the associated msg object. However, users would want the TTL
# of the acknowledgement to be about the same as they set
2017-09-21 17:24:51 +02:00
# 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
2015-03-09 07:35:32 +01:00
# user specified.
2017-09-21 17:24:51 +02:00
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
2015-03-09 07:35:32 +01:00
else:
2017-09-21 17:24:51 +02:00
TTL = 28 * 24 * 60 * 60 # 4 weeks
# Add some randomness to the TTL
2017-09-21 17:24:51 +02:00
TTL = int(TTL + helper_random.randomrandrange(-300, 300))
2014-11-13 22:32:31 +01:00
embeddedTime = int(time.time() + TTL)
2017-09-30 11:19:44 +02:00
2017-09-21 17:24:51 +02:00
# type/version/stream already included
2017-09-30 11:19:44 +02:00
payload = pack('>Q', (embeddedTime)) + ackdata
payload = self._doPOWDefaults(
payload, TTL, log_prefix='(For ack message)', log_time=True)
return protocol.CreatePacket('object', payload)