def __init__(self, previous=None): super(TriblerBandwidthTestBlock, self).__init__() crypto = ECCrypto() other = crypto.generate_key(u"curve25519").pub().key_to_bin() transaction = { 'up': random.randint(201, 220), 'down': random.randint(221, 240), 'total_up': 0, 'total_down': 0, 'type': 'tribler_bandwidth' } if previous: self.key = previous.key transaction['total_up'] = previous.transaction[ 'total_up'] + transaction['up'] transaction['total_down'] = previous.transaction[ 'total_down'] + transaction['down'] TriblerBandwidthBlock.__init__( self, ('tribler_bandwidth', encode(transaction), previous.public_key, previous.sequence_number + 1, other, 0, previous.hash, 0, 0, 0)) else: transaction['total_up'] = random.randint(241, 260) transaction['total_down'] = random.randint(261, 280) self.key = crypto.generate_key(u"curve25519") TriblerBandwidthBlock.__init__( self, ('tribler_bandwidth', encode(transaction), self.key.pub().key_to_bin(), random.randint(50, 100), other, 0, sha256(str(random.randint(0, 100000))).digest(), 0, 0, 0)) self.sign(self.key)
def _encode_torrent(self, message): files = message.payload.files trackers = list(message.payload.trackers) name = message.payload.name # Filter out invalid trackers for tracker in trackers: if not get_uniformed_tracker_url(tracker) or len(tracker) > 200: trackers.remove(tracker) # files is a tuple of tuples (actually a list in tuple form) max_len = self._community.dispersy_sync_bloom_filter_bits / 8 base_len = 20 + 8 + len(name) # infohash, timestamp, name tracker_len = sum([len(tracker) for tracker in trackers]) file_len = sum([len(f[0]) + 8 for f in files]) # file name, length # Check if the message fits in the bloomfilter if (base_len + tracker_len + file_len > max_len) and (len(trackers) > 10): # only use first 10 trackers, .torrents in the wild have been seen to have 1000+ trackers... trackers = trackers[:10] tracker_len = sum([len(tracker) for tracker in trackers]) if base_len + tracker_len + file_len > max_len: # reduce files by the amount we are currently to big reduce_by = max_len / (base_len + tracker_len + file_len * 1.0) nr_files_to_include = int(len(files) * reduce_by) files = sample(files, nr_files_to_include) normal_msg = (pack('!20sQ', message.payload.infohash, message.payload.timestamp), message.payload.name, tuple(files), tuple(trackers)) return zlib.compress(encode(normal_msg)),
def create_msg(): normal_msg = pack( '!20sQ', message.payload.infohash, message.payload.timestamp), message.payload.name, tuple( files), tuple(trackers) normal_msg = encode(normal_msg) return zlib.compress(normal_msg)
def create(cls, block_type, transaction, database, public_key, link=None, link_pk=None, additional_info=None): """ Create an empty next block. :param block_type: the type of the block to be created :param transaction: the transaction to use in this block :param database: the database to use as information source :param public_key: the public key to use for this block :param link: optionally create the block as a linked block to this block :param link_pk: the public key of the counterparty in this transaction :param additional_info: additional information, which has a higher priority than the transaction when link exists :return: A newly created block """ latest_bw_block = database.get_latest(public_key, block_type='tribler_bandwidth') latest_block = database.get_latest(public_key) ret = cls() if link: ret.type = link.type ret.transaction["up"] = link.transaction[ "down"] if "down" in link.transaction else 0 ret.transaction["down"] = link.transaction[ "up"] if "up" in link.transaction else 0 ret.link_public_key = link.public_key ret.link_sequence_number = link.sequence_number else: ret.type = block_type ret.transaction[ "up"] = transaction["up"] if "up" in transaction else 0 ret.transaction[ "down"] = transaction["down"] if "down" in transaction else 0 ret.link_public_key = link_pk if latest_bw_block: ret.transaction["total_up"] = latest_bw_block.transaction[ "total_up"] + ret.transaction["up"] ret.transaction["total_down"] = latest_bw_block.transaction[ "total_down"] + ret.transaction["down"] else: ret.transaction["total_up"] = ret.transaction["up"] ret.transaction["total_down"] = ret.transaction["down"] if latest_block: ret.sequence_number = latest_block.sequence_number + 1 ret.previous_hash = latest_block.hash ret._transaction = encode(ret.transaction) ret.public_key = public_key ret.signature = EMPTY_SIG ret.hash = ret.calculate_hash() return ret
def _encode_moderation(self, message): dict = {"text": message.payload.text, "timestamp": message.payload.timestamp, "severity": message.payload.severity} dict["cause-mid"] = message.payload.cause_mid dict["cause-global-time"] = message.payload.cause_global_time return encode(dict),
def _encode_search_request(self, message): packet = pack('!H', message.payload.identifier), message.payload.keywords if message.payload.bloom_filter: packet = packet + (message.payload.bloom_filter.functions, message.payload.bloom_filter.prefix, message.payload.bloom_filter.bytes) packet = encode(packet) return packet,
def __init__(self, previous=None): super(TriblerBandwidthTestBlock, self).__init__() crypto = ECCrypto() other = crypto.generate_key(u"curve25519").pub().key_to_bin() transaction = {'up': random.randint(201, 220), 'down': random.randint(221, 240), 'total_up': 0, 'total_down': 0, 'type': 'tribler_bandwidth'} if previous: self.key = previous.key transaction['total_up'] = previous.transaction['total_up'] + transaction['up'] transaction['total_down'] = previous.transaction['total_down'] + transaction['down'] TriblerBandwidthBlock.__init__(self, ('tribler_bandwidth', encode(transaction), previous.public_key, previous.sequence_number + 1, other, 0, previous.hash, 0, 0, 0)) else: transaction['total_up'] = random.randint(241, 260) transaction['total_down'] = random.randint(261, 280) self.key = crypto.generate_key(u"curve25519") TriblerBandwidthBlock.__init__(self, ( 'tribler_bandwidth', encode(transaction), self.key.pub().key_to_bin(), random.randint(50, 100), other, 0, sha256(str(random.randint(0, 100000))).digest(), 0, 0, 0)) self.sign(self.key)
def test_get_statistics(self): """ Testing whether the API returns the correct statistics """ block = TrustChainBlock() block.public_key = self.session.lm.trustchain_community.my_peer.public_key.key_to_bin( ) block.link_public_key = "deadbeef".decode("HEX") block.link_sequence_number = 21 block.type = 'tribler_bandwidth' block.transaction = { "up": 42, "down": 8, "total_up": 1024, "total_down": 2048, "type": "tribler_bandwidth" } block._transaction = encode(block.transaction) block.sequence_number = 3 block.previous_hash = "babecafe".decode("HEX") block.signature = "babebeef".decode("HEX") block.hash = block.calculate_hash() self.session.lm.trustchain_community.persistence.add_block(block) def verify_response(response): response_json = json.loads(response) self.assertTrue("statistics" in response_json) stats = response_json["statistics"] self.assertEqual( stats["id"], self.session.lm.trustchain_community.my_peer.public_key. key_to_bin().encode("HEX")) self.assertEqual(stats["total_blocks"], 3) self.assertEqual(stats["total_up"], 1024) self.assertEqual(stats["total_down"], 2048) self.assertEqual(stats["peers_that_pk_helped"], 1) self.assertEqual(stats["peers_that_helped_pk"], 1) self.assertIn("latest_block", stats) self.assertNotEqual(stats["latest_block"]["insert_time"], "") self.assertEqual(stats["latest_block"]["hash"], block.hash.encode("HEX")) self.assertEqual(stats["latest_block"]["link_public_key"], "deadbeef") self.assertEqual(stats["latest_block"]["link_sequence_number"], 21) self.assertEqual(stats["latest_block"]["up"], 42) self.assertEqual(stats["latest_block"]["down"], 8) self.should_check_equality = False return self.do_request('trustchain/statistics', expected_code=200).addCallback(verify_response)
def _encode_modification(self, message): modification_on = message.payload.modification_on.load_message() dict = {"modification-type": message.payload.modification_type, "modification-value": message.payload.modification_value, "timestamp": message.payload.timestamp, "modification-on-mid": modification_on.authentication.member.mid, "modification-on-global-time": modification_on.distribution.global_time} prev_modification = message.payload.prev_modification_packet if prev_modification: message = prev_modification.load_message() dict["prev-modification-mid"] = message.authentication.member.mid dict["prev-modification-global-time"] = message.distribution.global_time return encode(dict),
def test_get_bootstrap_identity_not_enough_tokens_2(self): """ Testing whether the API returns error 400 if bandwidth is to low when bootstrapping a new identity """ transaction = {'up': 0, 'down': 100, 'total_up': 0, 'total_down': 100} test_block = TrustChainBlock() test_block.type = 'tribler_bandwidth' test_block.transaction = transaction test_block._transaction = encode(transaction) test_block.public_key = self.session.lm.trustchain_community.my_peer.public_key.key_to_bin() test_block.hash = test_block.calculate_hash() self.session.lm.trustchain_community.persistence.add_block(test_block) self.should_check_equality = False return self.do_request('trustchain/bootstrap?amount=10', expected_code=400)
def test_decode_torrent(self): """ Test the decoding of a torrent message """ self.assertRaises(DropPacket, self.conversion._decode_torrent, None, 0, "abcd") self.assertRaises(DropPacket, self.conversion._decode_torrent, None, 0, zlib.compress("abcd")) # Test a successful decoding meta = self.channel_community.get_meta_message(u"torrent") msg = MockObject() msg.meta = meta torrent_msg = encode((pack('!20sQ', 'a' * 20, 12345), u'torrent', ((u'a', 1234),), ('http://track.er',))) _, msg = self.conversion._decode_torrent(msg, 0, zlib.compress(torrent_msg)) self.assertEqual(msg.infohash, 'a' * 20) self.assertEqual(msg.name, u'torrent')
def test_get_bootstrap_identity_not_enough_tokens_2(self): """ Testing whether the API returns error 400 if bandwidth is to low when bootstrapping a new identity """ transaction = {'up': 0, 'down': 100, 'total_up': 0, 'total_down': 100} test_block = TrustChainBlock() test_block.type = 'tribler_bandwidth' test_block.transaction = transaction test_block._transaction = encode(transaction) test_block.public_key = self.session.lm.trustchain_community.my_peer.public_key.key_to_bin( ) test_block.hash = test_block.calculate_hash() self.session.lm.trustchain_community.persistence.add_block(test_block) self.should_check_equality = False return self.do_request('trustchain/bootstrap?amount=10', expected_code=400)
def create(cls, block_type, transaction, database, public_key, link=None, link_pk=None, additional_info=None): """ Create an empty next block. :param block_type: the type of the block to be created :param transaction: the transaction to use in this block :param database: the database to use as information source :param public_key: the public key to use for this block :param link: optionally create the block as a linked block to this block :param link_pk: the public key of the counterparty in this transaction :param additional_info: additional information, which has a higher priority than the transaction when link exists :return: A newly created block """ latest_bw_block = database.get_latest(public_key, block_type=b'tribler_bandwidth') latest_block = database.get_latest(public_key) ret = cls() if link: ret.type = link.type ret.transaction["up"] = link.transaction["down"] if "down" in link.transaction else 0 ret.transaction["down"] = link.transaction["up"] if "up" in link.transaction else 0 ret.link_public_key = link.public_key ret.link_sequence_number = link.sequence_number else: ret.type = block_type ret.transaction["up"] = transaction["up"] if "up" in transaction else 0 ret.transaction["down"] = transaction["down"] if "down" in transaction else 0 ret.link_public_key = link_pk if latest_bw_block: ret.transaction["total_up"] = latest_bw_block.transaction["total_up"] + ret.transaction["up"] ret.transaction["total_down"] = latest_bw_block.transaction["total_down"] + ret.transaction["down"] else: ret.transaction["total_up"] = ret.transaction["up"] ret.transaction["total_down"] = ret.transaction["down"] if latest_block: ret.sequence_number = latest_block.sequence_number + 1 ret.previous_hash = latest_block.hash ret._transaction = encode(ret.transaction) ret.public_key = public_key ret.signature = EMPTY_SIG ret.hash = ret.calculate_hash() return ret
def test_get_bootstrap_identity_partial_tokens(self): """ Testing whether the API return partial available credit when argument is supplied """ transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0} transaction2 = {'up': 50, 'down': 0} def verify_response(response): response_json = json.loads(response) self.assertEqual(response_json['transaction'], transaction2) test_block = TrustChainBlock() test_block.type = 'tribler_bandwidth' test_block.transaction = transaction test_block._transaction = encode(transaction) test_block.public_key = self.session.lm.trustchain_community.my_peer.public_key.key_to_bin() test_block.hash = test_block.calculate_hash() self.session.lm.trustchain_community.persistence.add_block(test_block) self.should_check_equality = False return self.do_request('trustchain/bootstrap?amount=50', expected_code=200).addCallback(verify_response)
def test_get_statistics(self): """ Testing whether the API returns the correct statistics """ block = TrustChainBlock() block.public_key = self.session.lm.trustchain_community.my_peer.public_key.key_to_bin() block.link_public_key = "deadbeef".decode("HEX") block.link_sequence_number = 21 block.type = 'tribler_bandwidth' block.transaction = {"up": 42, "down": 8, "total_up": 1024, "total_down": 2048, "type": "tribler_bandwidth"} block._transaction = encode(block.transaction) block.sequence_number = 3 block.previous_hash = "babecafe".decode("HEX") block.signature = "babebeef".decode("HEX") block.hash = block.calculate_hash() self.session.lm.trustchain_community.persistence.add_block(block) def verify_response(response): response_json = json.loads(response) self.assertTrue("statistics" in response_json) stats = response_json["statistics"] self.assertEqual(stats["id"], self.session.lm.trustchain_community.my_peer. public_key.key_to_bin().encode("HEX")) self.assertEqual(stats["total_blocks"], 3) self.assertEqual(stats["total_up"], 1024) self.assertEqual(stats["total_down"], 2048) self.assertEqual(stats["peers_that_pk_helped"], 1) self.assertEqual(stats["peers_that_helped_pk"], 1) self.assertIn("latest_block", stats) self.assertNotEqual(stats["latest_block"]["insert_time"], "") self.assertEqual(stats["latest_block"]["hash"], block.hash.encode("HEX")) self.assertEqual(stats["latest_block"]["link_public_key"], "deadbeef") self.assertEqual(stats["latest_block"]["link_sequence_number"], 21) self.assertEqual(stats["latest_block"]["up"], 42) self.assertEqual(stats["latest_block"]["down"], 8) self.should_check_equality = False return self.do_request('trustchain/statistics', expected_code=200).addCallback(verify_response)
def test_get_bootstrap_identity_partial_tokens(self): """ Testing whether the API return partial available credit when argument is supplied """ transaction = {'up': 100, 'down': 0, 'total_up': 100, 'total_down': 0} transaction2 = {'up': 50, 'down': 0} def verify_response(response): response_json = json.loads(response) self.assertEqual(response_json['transaction'], transaction2) test_block = TrustChainBlock() test_block.type = 'tribler_bandwidth' test_block.transaction = transaction test_block._transaction = encode(transaction) test_block.public_key = self.session.lm.trustchain_community.my_peer.public_key.key_to_bin( ) test_block.hash = test_block.calculate_hash() self.session.lm.trustchain_community.persistence.add_block(test_block) self.should_check_equality = False return self.do_request('trustchain/bootstrap?amount=50', expected_code=200).addCallback(verify_response)
def _encode_comment(self, message): dict = {"text": message.payload.text, "timestamp": message.payload.timestamp} playlist_packet = message.payload.playlist_packet infohash = message.payload.infohash if message.payload.reply_to_mid: dict["reply-to-mid"] = message.payload.reply_to_mid dict["reply-to-global-time"] = message.payload.reply_to_global_time if message.payload.reply_after_mid: dict["reply-after-mid"] = message.payload.reply_after_mid dict["reply-after-global-time"] = message.payload.reply_after_global_time if playlist_packet: message = playlist_packet.load_message() dict["playlist-mid"] = message.authentication.member.mid dict["playlist-global-time"] = message.distribution.global_time if infohash: dict['infohash'] = infohash return encode(dict),
def _encode_channelsearch_response(self, message): packet = encode((message.payload.keywords, message.payload.torrents)) return packet,
def _encode_channelsearch(self, message): packet = encode(message.payload.keywords) return packet,
def create_msg(): return encode(message.payload.torrents)
def _encode_mark_torrent(self, message): dict = {"infohash": message.payload.infohash, "timestamp": message.payload.timestamp, "type": message.payload.type} return encode(dict),
def _encode_channel(self, message): return encode((message.payload.name, message.payload.description)),
def _encode_search_response(self, message): packet = pack('!H', message.payload.identifier), message.payload.results return encode(packet),