diff --git a/src/bitmessagekivy/kivy_helper_search.py b/src/bitmessagekivy/kivy_helper_search.py index 9f740597..1c410df0 100644 --- a/src/bitmessagekivy/kivy_helper_search.py +++ b/src/bitmessagekivy/kivy_helper_search.py @@ -22,12 +22,16 @@ def search_sql( sqlStatementBase = '''SELECT label, address From addressbook ''' else: sqlStatementBase = ( - '''SELECT folder, msgid, toaddress, message, fromaddress,''' + '''SELECT folder, toaddress, message, fromaddress,''' ''' subject, received, read FROM inbox ''' ) sqlStatementParts = [] sqlArguments = [] if account is not None: + #xAddress = 'toaddress' + #where = ['subject', 'message'] + #what = None + #unreadOnly = False if xAddress == 'both': sqlStatementParts.append("(fromaddress = ? OR toaddress = ?)") sqlArguments.append(account) diff --git a/src/class_objectProcessor.py b/src/class_objectProcessor.py index fc87ce50..f7930dce 100644 --- a/src/class_objectProcessor.py +++ b/src/class_objectProcessor.py @@ -48,7 +48,7 @@ class objectProcessor(threading.Thread): def __init__(self): threading.Thread.__init__(self, name="objectProcessor") random.seed() - # It may be the case that the last time Bitmessage was running, + # It may be the case that the last time Bitmes0sage was running, # the user closed it before it finished processing everything in the # objectProcessorQueue. Assuming that Bitmessage wasn't closed # forcefully, it should have saved the data in the queue into the @@ -69,9 +69,7 @@ class objectProcessor(threading.Thread): """Process the objects from `.queues.objectProcessorQueue`""" while True: objectType, data = queues.objectProcessorQueue.get() - self.checkackdata(data) - try: if objectType == protocol.OBJECT_GETPUBKEY: self.processgetpubkey(data) @@ -236,8 +234,9 @@ class objectProcessor(threading.Thread): logger.debug( 'the tag requested in this getpubkey request is: %s', hexlify(requestedTag)) + # import pdb;pdb.set_trace() if bytes(requestedTag) in shared.myAddressesByTag: - myAddress = shared.myAddressesByTag[requestedTag] + myAddress = shared.myAddressesByTag[bytes(requestedTag)] if myAddress == '': logger.info('This getpubkey request is not for any of my keys.') @@ -436,18 +435,21 @@ class objectProcessor(threading.Thread): return tag = data[readPosition:readPosition + 32] - if tag not in bytes(state.neededPubkeys): + if bytes(tag) not in state.neededPubkeys: logger.info( 'We don\'t need this v4 pubkey. We didn\'t ask for it.') return # Let us try to decrypt the pubkey - toAddress, _ = state.neededPubkeys[tag] - if protocol.decryptAndCheckPubkeyPayload(data, toAddress) == \ + print("TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT#################################################", tag) + toAddress, _ = state.neededPubkeys[bytes(tag)] #check with py2 + # import pdb;pdb.set_trace() + if protocol.decryptAndCheckPubkeyPayload(bytes(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. + print("decryptAndCheckPubkeyPayload completed#########################################################") self.possibleNewPubkey(toAddress) # Display timing data diff --git a/src/class_singleWorker.py b/src/class_singleWorker.py index 7c0b5842..486308d7 100644 --- a/src/class_singleWorker.py +++ b/src/class_singleWorker.py @@ -679,6 +679,7 @@ class singleWorker(StoppableThread): """Send a message-type object (assemble the object, perform PoW and put it to the inv announcement queue)""" # pylint: disable=too-many-nested-blocks # Reset just in case + # import pdb;pdb.set_trace() sqlExecute( '''UPDATE sent SET status='msgqueued' ''' ''' WHERE status IN ('doingpubkeypow', 'doingmsgpow')''') @@ -689,6 +690,7 @@ class singleWorker(StoppableThread): ''' and folder LIKE '%sent%' ''') # while we have a msg that needs some work for row in queryreturn: + print(row, "rowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowrowv") toaddress, fromaddress, subject, message, \ ackdata, status, TTL, retryNumber, encoding = row # toStatus @@ -730,6 +732,7 @@ class singleWorker(StoppableThread): toaddress ) # If we have the needed pubkey in the pubkey table already, + print("sendmsg line no 734#####################################################################") if queryreturn != []: # set the status of this msg to doingmsgpow sqlExecute( @@ -750,6 +753,7 @@ class singleWorker(StoppableThread): ) # We don't have the needed pubkey in the pubkeys table already. else: + print("sendmsg line no 756#####################################################################") if toAddressVersionNumber <= 3: toTag = '' else: @@ -759,14 +763,16 @@ class singleWorker(StoppableThread): ).digest()).digest()[32:] if toaddress in state.neededPubkeys or \ toTag in state.neededPubkeys: + print("sendmsg line no 766#####################################################################") # 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, + int(10), toaddress ) + print("sendmsg line no 774#####################################################################") queues.UISignalQueue.put(( 'updateSentItemStatusByToAddress', ( toaddress, @@ -774,9 +780,11 @@ class singleWorker(StoppableThread): "MainWindow", "Encryption key was requested earlier.")) )) + print("sendmsg line no 783#####################################################################") # on with the next msg on which we can do some work continue else: + print("sendmsg line no 785#####################################################################") # We have not yet sent a request for the pubkey needToRequestPubkey = True # If we are trying to send to address @@ -850,19 +858,19 @@ class singleWorker(StoppableThread): self.requestPubKey(toaddress) # on with the next msg on which we can do some work continue - + print("sendmsg line no 856#####################################################################") # 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) - + print("sendmsg line no 870#####################################################################") # if we aren't sending this to ourselves or a chan if not BMConfigParser().has_section(toaddress): + print("sendmsg line no 873#####################################################################") shared.ackdataForWhichImWatching[ackdata] = 0 queues.UISignalQueue.put(( 'updateSentItemStatusByAckdata', ( @@ -1047,6 +1055,7 @@ class singleWorker(StoppableThread): l10n.formatTimestamp())))) continue else: # if we are sending a message to ourselves or a chan.. + print("sendmsg line no 1058#####################################################################") self.logger.info('Sending a message.') self.logger.debug( 'First 150 characters of message: %r', message[:150]) @@ -1088,7 +1097,7 @@ class singleWorker(StoppableThread): "MainWindow", "Doing work necessary to send message.")) )) - + print("sendmsg line no 1093#####################################################################") # Now we can start to assemble our message. payload = encodeVarint(fromAddressVersionNumber) payload += encodeVarint(fromStreamNumber) @@ -1096,9 +1105,10 @@ class singleWorker(StoppableThread): # that can be expected from me. (See # https://bitmessage.org/wiki/Protocol_specification#Pubkey_bitfield_features) payload += protocol.getBitfield(fromaddress) - + print("sendmsg line no 1101#####################################################################") # We need to convert our private keys to public keys in order # to include them. + # import pdb; pdb.set_trace() try: privSigningKeyHex, privEncryptionKeyHex, \ pubSigningKey, pubEncryptionKey = self._getKeysForAddress( @@ -1113,7 +1123,7 @@ class singleWorker(StoppableThread): " (your address) in the keys.dat file.")) )) continue - + print("sendmsg line no 1119#####################################################################") payload += pubSigningKey + pubEncryptionKey if fromAddressVersionNumber >= 3: @@ -1128,16 +1138,17 @@ class singleWorker(StoppableThread): payload += encodeVarint( defaults.networkDefaultPayloadLengthExtraBytes) else: - payload += encodeVarint(BMConfigParser().getint( - fromaddress, 'noncetrialsperbyte')) - payload += encodeVarint(BMConfigParser().getint( - fromaddress, 'payloadlengthextrabytes')) - + payload += encodeVarint(int(BMConfigParser().get( + fromaddress, 'noncetrialsperbyte'))) + payload += encodeVarint(int(BMConfigParser().get( + fromaddress, 'payloadlengthextrabytes'))) + print('@@@@@@@@@@@@@@ before payload creating@@@@@@@@@@@@@@@@') # 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 + # import pdb;pdb.set_trace() encodedMessage = helper_msgcoding.MsgEncode( {"subject": subject, "body": message}, encoding ) @@ -1163,8 +1174,8 @@ class singleWorker(StoppableThread): fullAckPayload = self.generateFullAckMessage( ackdata, toStreamNumber, TTL) payload += encodeVarint(len(fullAckPayload)) - payload += fullAckPayload - dataToSign = pack('>Q', embeddedTime) + '\x00\x00\x00\x02' + \ + payload += fullAckPayload.encode() + dataToSign = pack('>Q', embeddedTime) + '\x00\x00\x00\x02'.encode() + \ encodeVarint(1) + encodeVarint(toStreamNumber) + payload signature = highlevelcrypto.sign(dataToSign, privSigningKeyHex) payload += encodeVarint(len(signature)) @@ -1173,7 +1184,7 @@ class singleWorker(StoppableThread): # We have assembled the data that will be encrypted. try: encrypted = highlevelcrypto.encrypt( - payload, "04" + hexlify(pubEncryptionKeyBase256) + payload, "04".encode() + hexlify(pubEncryptionKeyBase256) ) except: sqlExecute( @@ -1190,9 +1201,9 @@ class singleWorker(StoppableThread): ).arg(l10n.formatTimestamp())) )) continue - + print('@@@@@@@@@@@@@@ before encryptedPayload creating@@@@@@@@@@@@@@@@') encryptedPayload = pack('>Q', embeddedTime) - encryptedPayload += '\x00\x00\x00\x02' # object type: msg + encryptedPayload += '\x00\x00\x00\x02'.encode() # object type: msg encryptedPayload += encodeVarint(1) # msg version encryptedPayload += encodeVarint(toStreamNumber) + encrypted target = 2 ** 64 / ( @@ -1206,15 +1217,17 @@ class singleWorker(StoppableThread): )) self.logger.info( '(For msg message) Doing proof of work. Total required' - ' difficulty: %f. Required small message difficulty: %f.', - float(requiredAverageProofOfWorkNonceTrialsPerByte) / + ' difficulty: {}. Required small message difficulty: {}.'.format + (float(requiredAverageProofOfWorkNonceTrialsPerByte) / defaults.networkDefaultProofOfWorkNonceTrialsPerByte, float(requiredPayloadLengthExtraBytes) / - defaults.networkDefaultPayloadLengthExtraBytes + defaults.networkDefaultPayloadLengthExtraBytes) ) powStartTime = time.time() initialHash = hashlib.sha512(encryptedPayload).digest() + # import pdb; pdb.set_trace() + trialValue, nonce = proofofwork.run(target, initialHash) print("nonce calculated value#############################", nonce) self.logger.info( @@ -1229,7 +1242,8 @@ class singleWorker(StoppableThread): ) except: pass - + print("line no 1234#########################################") + # import pdb; pdb.set_trace() encryptedPayload = pack('>Q', nonce) + encryptedPayload # Sanity check. The encryptedPayload size should never be @@ -1243,11 +1257,18 @@ class singleWorker(StoppableThread): len(encryptedPayload) ) continue - + print("line no 1248#########################################") inventoryHash = calculateInventoryHash(encryptedPayload) + print("line no 1250248#########################################") objectType = 2 - Inventory()[inventoryHash] = ( - objectType, toStreamNumber, encryptedPayload, embeddedTime, '') + print("line no 1252#########################################") + # import pdb; pdb.set_trace() + inventoryHashlist = ( + objectType, toStreamNumber,encryptedPayload, embeddedTime, '') + print("line no 1255#########################################") + # import pdb; pdb.set_trace() + Inventory()[inventoryHashlist] + print("line no 1257#########################################") if BMConfigParser().has_section(toaddress) or \ not protocol.checkBitfield(behaviorBitfield, protocol.BITFIELD_DOESACK): queues.UISignalQueue.put(( @@ -1255,7 +1276,7 @@ class singleWorker(StoppableThread): ackdata, tr._translate( "MainWindow", - "Message sent. Sent at %1" + "Mobileessage sent. Sent at %1" ).arg(l10n.formatTimestamp())))) else: # not sending to a chan or one of my addresses @@ -1268,14 +1289,15 @@ class singleWorker(StoppableThread): " Sent on %1" ).arg(l10n.formatTimestamp())) )) + print("line no 1282#########################################") self.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. + print("line no 1290#########################################") if BMConfigParser().has_section(toaddress) or \ not protocol.checkBitfield(behaviorBitfield, protocol.BITFIELD_DOESACK): newStatus = 'msgsentnoackexpected' @@ -1289,9 +1311,9 @@ class singleWorker(StoppableThread): 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. + print("line no 1306#########################################") if BMConfigParser().has_section(toaddress): # Used to detect and ignore duplicate messages in our inbox sigHash = hashlib.sha512(hashlib.sha512( @@ -1318,6 +1340,7 @@ class singleWorker(StoppableThread): def requestPubKey(self, toAddress): """Send a getpubkey object""" + # import pdb;pdb.set_trace() toStatus, addressVersionNumber, streamNumber, ripe = decodeAddress( toAddress) if toStatus != 'success': @@ -1378,7 +1401,7 @@ class singleWorker(StoppableThread): 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 += '\x00\x00\x00\x00'.encode() # object type: getpubkey payload += encodeVarint(addressVersionNumber) payload += encodeVarint(streamNumber) if addressVersionNumber <= 3: @@ -1406,8 +1429,9 @@ class singleWorker(StoppableThread): inventoryHash = calculateInventoryHash(payload) objectType = 1 - Inventory()[inventoryHash] = ( + inventoryHashlist = ( objectType, streamNumber, payload, embeddedTime, '') + Inventory()[inventoryHashlist] self.logger.info('sending inv (for the getpubkey message)') queues.invQueue.put((streamNumber, inventoryHash)) @@ -1437,7 +1461,7 @@ class singleWorker(StoppableThread): ).arg(l10n.formatTimestamp())) )) - def generateFullAckMessage(self, ackdata, _, TTL): + def generateFullAckMessage(self, ackdata, _, 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 diff --git a/src/class_sqlThread.py b/src/class_sqlThread.py index d7bb158f..c655439c 100644 --- a/src/class_sqlThread.py +++ b/src/class_sqlThread.py @@ -573,6 +573,8 @@ class sqlThread(threading.Thread): rowcount = 0 # print 'item', item # print 'parameters', parameters + # if 'inbox' in item: + # import pdb; pdb.set_trace() try: self.cur.execute(item, parameters) rowcount = self.cur.rowcount diff --git a/src/highlevelcrypto.py b/src/highlevelcrypto.py index 03e2d1d3..ad073e47 100644 --- a/src/highlevelcrypto.py +++ b/src/highlevelcrypto.py @@ -54,6 +54,7 @@ def encrypt(msg, hexPubkey): def decrypt(msg, hexPrivkey): + print("SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS#################################################") """Decrypts message with hex private key""" return makeCryptor(hexPrivkey).decrypt(msg) diff --git a/src/inventory.py b/src/inventory.py index fc06e455..e1566db5 100644 --- a/src/inventory.py +++ b/src/inventory.py @@ -24,6 +24,8 @@ class Inventory(): # cheap inheritance copied from asyncore def __getattr__(self, attr): + # attr = '__contains__' + print('$$$$$$$$$$$$$ inside the __getattr__ item $$$$$$$$$$$$$$$$') if attr == "__contains__": self.numberOfInventoryLookupsPerformed += 1 try: @@ -38,4 +40,5 @@ class Inventory(): # hint for pylint: this is dictionary like object def __getitem__(self, key): + print('@@@@@@@@@@@@@@@@@@ inside the __getitem__ item @@@@@@@@@@@@@@@') return self._realInventory[key] diff --git a/src/l10n.py b/src/l10n.py index bf727244..59c53cc2 100644 --- a/src/l10n.py +++ b/src/l10n.py @@ -123,7 +123,8 @@ def formatTimestamp(timestamp=None, as_unicode=True): timestring = time.strftime(time_format) if as_unicode: - return unicode(timestring, encoding) + return (timestring.encode('utf-8')) + # return unicode(timestring, encoding) return timestring diff --git a/src/network/bmproto.py b/src/network/bmproto.py index adca21f5..4e89fdfe 100644 --- a/src/network/bmproto.py +++ b/src/network/bmproto.py @@ -364,7 +364,7 @@ class BMProto(AdvancedDispatcher, ObjectTracker): if now < self.skipUntil: return True for i in items: - self.pendingUpload[str(i)] = now + self.pendingUpload[bytes(i)] = now return True def _command_inv(self, dandelion=False): @@ -380,6 +380,7 @@ class BMProto(AdvancedDispatcher, ObjectTracker): return True for i in map(bytes, items): + import pdb;pdb.set_trace() if i in Inventory() and not Dandelion().hasHash(i): continue if dandelion and not Dandelion().hasHash(i): @@ -443,13 +444,26 @@ class BMProto(AdvancedDispatcher, ObjectTracker): if self.object.inventoryHash in Inventory() and Dandelion().hasHash(self.object.inventoryHash): Dandelion().removeHash(self.object.inventoryHash, "cycle detection") - [self.object.inventoryHash] = ( + # import pdb; pdb.set_trace() - self.object.objectType, self.object.streamNumber, + inventoryHash_list = [self.object.objectType, self.object.streamNumber, memoryview(self.payload[objectOffset:]), self.object.expiresTime, - memoryview(self.object.tag) - ) - Inventory()[self.object.inventoryHash] + memoryview(self.object.tag)] + # [self.object.inventoryHash] = ( + + # self.object.objectType, self.object.streamNumber, + # memoryview(self.payload[objectOffset:]), self.object.expiresTime, + # memoryview(self.object.tag) + # ) + + + + # Inventory()[self.object.inventoryHash] = (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(( diff --git a/src/network/invthread.py b/src/network/invthread.py index fa38e7c3..a4edb8a2 100644 --- a/src/network/invthread.py +++ b/src/network/invthread.py @@ -87,19 +87,19 @@ class InvThread(StoppableThread): fluffs.append(inv[1]) except KeyError: fluffs.append(inv[1]) - if fluffs: + # import pdb; pdb.set_trace() random.shuffle(fluffs) connection.append_write_buf(protocol.CreatePacket( 'inv', addresses.encodeVarint( - len(fluffs)) + ''.join(fluffs))) + len(fluffs)) + ('').encode().join([x for x in fluffs]))) #compare result with python2 if stems: random.shuffle(stems) connection.append_write_buf(protocol.CreatePacket( 'dinv', addresses.encodeVarint( - len(stems)) + ''.join(stems))) + len(stems)) + ('').encode().join([x for x in stems]))) #compare result with python2 invQueue.iterate() for _ in range(len(chunk)): diff --git a/src/network/tcp.py b/src/network/tcp.py index 47553751..8e5c92f4 100644 --- a/src/network/tcp.py +++ b/src/network/tcp.py @@ -211,6 +211,7 @@ class TCPConnection(BMProto, TLSDispatcher): # may lock for a long time, but I think it's better than # thousands of small locks with self.objectsNewToThemLock: + # import pdb;pdb.set_trace() for objHash in Inventory().unexpired_hashes_by_stream(stream): # don't advertise stem objects on bigInv if Dandelion().hasHash(objHash): @@ -220,18 +221,18 @@ class TCPConnection(BMProto, TLSDispatcher): payload = bytes() # Now let us start appending all of these hashes together. They will be # sent out in a big inv message to our new peer. + if len(bigInvList) is not 0: + for obj_hash, _ in bigInvList.items(): + payload += obj_hash + objectCount += 1 - for obj_hash, _ in bigInvList.items(): - payload += obj_hash - objectCount += 1 - - # Remove -1 below when sufficient time has passed for users to - # upgrade to versions of PyBitmessage that accept inv with 50,000 - # items - if objectCount >= MAX_OBJECT_COUNT - 1: - sendChunk() - payload = b'' - objectCount = 0 + # Remove -1 below when sufficient time has passed for users to + # upgrade to versions of PyBitmessage that accept inv with 50,000 + # items + if objectCount >= MAX_OBJECT_COUNT - 1: + sendChunk() + payload = b'' + objectCount = 0 # flush sendChunk() diff --git a/src/network/uploadthread.py b/src/network/uploadthread.py index 33daf525..2fcf039d 100644 --- a/src/network/uploadthread.py +++ b/src/network/uploadthread.py @@ -45,6 +45,7 @@ class UploadThread(StoppableThread): if Dandelion().hasHash(chunk) and \ i != Dandelion().objectChildStem(chunk): i.antiIntersectionDelay() + print self.logger.info( '%s asked for a stem object we didn\'t offer to it.', i.destination) diff --git a/src/proofofwork.py b/src/proofofwork.py index 18d8f332..8c2abff0 100644 --- a/src/proofofwork.py +++ b/src/proofofwork.py @@ -108,13 +108,13 @@ def _doFastPoW(target, initialHash): logger.debug("Fast PoW done") return result[0], result[1] time.sleep(0.2) + def _doCPoW(target, initialHash): - h = initialHash - m = target - out_h = ctypes.pointer(ctypes.create_string_buffer(h, 64)) - out_m = ctypes.c_ulonglong(m) + # import pdb; pdb.set_trace() + out_h = ctypes.pointer(ctypes.create_string_buffer(initialHash, 64)) + out_m = ctypes.c_ulonglong(target) logger.debug("C PoW start") nonce = bmpow(out_h, out_m) trialValue, = unpack('>Q', hashlib.sha512(hashlib.sha512(pack('>Q', nonce) + initialHash).digest()).digest()[0:8]) @@ -241,7 +241,6 @@ def buildCPoW(): def run(target, initialHash): """Run the proof of work thread""" - if state.shutdown != 0: raise # pylint: disable=misplaced-bare-raise target = int(target) @@ -254,6 +253,7 @@ def run(target, initialHash): pass # fallback if bmpow: try: + print('-------------inside the proofofwork-----------------') return _doCPoW(target, initialHash) except StopIteration: raise @@ -294,6 +294,8 @@ def init(): openclpow.initCL() if sys.platform == "win32": + print('@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@') + print('inside the sys.platform == "win32"') if ctypes.sizeof(ctypes.c_voidp) == 4: bitmsglib = 'bitmsghash32.dll' else: @@ -326,13 +328,16 @@ def init(): bso = None else: + # import pdb; pdb.set_trace() + print('####################################') + print('else else else eles else ') try: bso = ctypes.CDLL(os.path.join(paths.codePath(), "bitmsghash", bitmsglib)) except OSError: import glob try: bso = ctypes.CDLL(glob.glob(os.path.join( - paths.codePath(), "bitmsghash", "bitmsghash*.so" + paths.codePath(), " ", "bitmsghash*.so" ))[0]) except (OSError, IndexError): bso = None @@ -349,4 +354,6 @@ def init(): else: bmpow = None if bmpow is None: + print('$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$') + print('intailed the bmpow') buildCPoW() diff --git a/src/protocol.py b/src/protocol.py index 6f84236e..029205a9 100644 --- a/src/protocol.py +++ b/src/protocol.py @@ -431,7 +431,7 @@ def decryptAndCheckPubkeyPayload(data, address): encryptedData = data[readPosition:] # Let us try to decrypt the pubkey - toAddress, cryptorObject = state.neededPubkeys[tag] + toAddress, cryptorObject = state.neededPubkeys[bytes(tag)] if toAddress != address: logger.critical( 'decryptAndCheckPubkeyPayload failed due to toAddress' @@ -444,6 +444,7 @@ def decryptAndCheckPubkeyPayload(data, address): # That sort of address-malleability should have been caught # by the UI or API and an error given to the user. return 'failed' + print("WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW#################################################") try: decryptedData = cryptorObject.decrypt(encryptedData) except: @@ -451,13 +452,13 @@ def decryptAndCheckPubkeyPayload(data, address): # 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] + print("working fine till here#################################################################") + publicSigningKey = '\x04'.encode() + decryptedData[readPosition:readPosition + 64] readPosition += 64 - publicEncryptionKey = '\x04' + decryptedData[readPosition:readPosition + 64] + publicEncryptionKey = '\x04'.encode() + decryptedData[readPosition:readPosition + 64] readPosition += 64 specifiedNonceTrialsPerByteLength = decodeVarint( decryptedData[readPosition:readPosition + 10])[1] @@ -471,7 +472,6 @@ def decryptAndCheckPubkeyPayload(data, address): decryptedData[readPosition:readPosition + 10]) readPosition += signatureLengthLength signature = decryptedData[readPosition:readPosition + signatureLength] - if not highlevelcrypto.verify( signedData, signature, hexlify(publicSigningKey)): logger.info( @@ -480,11 +480,9 @@ def decryptAndCheckPubkeyPayload(data, address): logger.info( 'ECDSA verify passed (within decryptAndCheckPubkeyPayload)') - sha = hashlib.new('sha512') sha.update(publicSigningKey + publicEncryptionKey) embeddedRipe = RIPEMD160Hash(sha.digest()).digest() - if embeddedRipe != ripe: # Although this pubkey object had the tag were were looking for # and was encrypted with the correct encryption key, @@ -503,9 +501,9 @@ def decryptAndCheckPubkeyPayload(data, address): addressVersion, streamNumber, hexlify(ripe), hexlify(publicSigningKey), hexlify(publicEncryptionKey) ) - t = (address, addressVersion, storedData, int(time.time()), 'yes') sqlExecute('''INSERT INTO pubkeys VALUES (?,?,?,?,?)''', *t) + print("successful Insertion of pubkey hurray#################################################") return 'successful' except varintDecodeError: logger.info( diff --git a/src/storage/sqlite.py b/src/storage/sqlite.py index e0eea823..37bb75a1 100644 --- a/src/storage/sqlite.py +++ b/src/storage/sqlite.py @@ -13,6 +13,7 @@ from storage.storage import InventoryStorage, InventoryItem class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors """Inventory using SQLite""" def __init__(self): + # import pdb;pdb.set_trace() super(SqliteInventory, self).__init__() # of objects (like msg payloads and pubkey payloads) # Does not include protocol headers (the first 24 bytes of each packet). @@ -29,7 +30,8 @@ class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors self.lock = RLock() def __contains__(self, hash_): - print('----------contains------------------') + print('__contains__(self, hash_)__contains__(self, hash_)__contains__(self, hash_) ',hash_) + hash_ = str(hash_).encode() if type(hash_) == int else hash_ with self.lock: if hash_ in self._objects: return True @@ -41,23 +43,38 @@ class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors self._objects[hash_] = rows[0][0] return True + # def __getitem__(self, hash_): + # raw = [None] + # # some think broke + # if hash_ == 0: + # hash_ = bytes() + # with self.lock: + # try: + # if hash_ in self._inventory: + # return self._inventory[hash_] + # rows = sqlQuery( + # 'SELECT objecttype, streamnumber, payload, expirestime, tag FROM inventory WHERE hash=?', + # sqlite3.Binary(hash_)) + # if not rows: + # # raise KeyError(hash_) + # pass + # except: + # rows = [hash_] + # return InventoryItem(*rows[0]) + def __getitem__(self, hash_): - if hash_ == 0: - hash_ = bytes() + # import pdb;pdb.set_trace() with self.lock: - try: - if hash_ in self._inventory: - return self._inventory[hash_] - rows = sqlQuery( - 'SELECT objecttype, streamnumber, payload, expirestime, tag FROM inventory WHERE hash=?', - sqlite3.Binary(hash_)) - if not rows: - pass - # raise KeyError(hash_) - except: - pass + if hash_ in self._inventory: + return self._inventory[hash_] + rows = sqlQuery( + 'SELECT objecttype, streamnumber, payload, expirestime, tag' + ' FROM inventory WHERE hash=?', sqlite3.Binary(bytes(hash_))) + if not rows: + raise KeyError(hash_) return InventoryItem(*rows[0]) + def __setitem__(self, hash_, value): print('----------__setitem__------------------') with self.lock: @@ -95,13 +112,17 @@ class SqliteInventory(InventoryStorage): # pylint: disable=too-many-ancestors def unexpired_hashes_by_stream(self, stream): """Return unexpired inventory vectors filtered by stream""" + # print ('self._inventory.items() self._inventory.items() self._inventory.items()' ,self._inventory.items()) + # import pdb;pdb.set_trace() with self.lock: t = int(time.time()) hashes = [x for x, value in self._inventory.items() if value.stream == stream and value.expires > t] - hashes += (str(payload) for payload, in sqlQuery( + # print ('hasheshasheshasheshasheshasheshasheshasheshashes',hashes) + hashes += (payload for payload, in sqlQuery( 'SELECT hash FROM inventory WHERE streamnumber=?' ' AND expirestime>?', stream, t)) + # print ('hasheshasheshasheshasheshasheshasheshasheshashes aaaaaaaaffter',hashes) return hashes def flush(self):