def round(): global session, mygames, myinvite, rounds gc = GameCast.getInstance() gc_db = session.open_dbhandler(NTFY_GAMECAST) if not myinvite and len(mygames) < MAXBOTS: # Send out a new random game/invite game = {} game['game_id'] = gc_db.getNextGameID(0) game['owner_id'] = 0 game['winner_permid'] = '' game['moves'] = bencode([]) mycolour = random.choice(['black','white']) mypermid = bin2str(session.get_permid()) players = {mypermid:mycolour} game['players'] = bencode(players) game['gamename'] = 'chess' game['time'] = random.choice([10,20,30]) game['inc'] = random.choice([60,120,180]) game['is_finished'] = 0 game['lastmove_time'] = 0 game['creation_time'] = 0 gc_db.addGame(game) invite = {} invite['target_id'] = -1 invite['game_id'] = game['game_id'] invite['min_rating'] = 0 invite['max_rating'] = 9999 invite['time'] = game['time'] invite['inc'] = game['inc'] invite['gamename'] = 'chess' if mycolour == 'black': invite['colour'] = 'white' else: invite['colour'] = 'black' if DEBUG: print >> sys.stderr, 'chessbot: sending out invite for game (%d,%d)' % (0, game['game_id']) myinvite = gc._executeSeekOrMatch(invite) elif myinvite: # Check if the game related to our invite has started yet owner_id = myinvite['owner_id'] game_id = myinvite['game_id'] games = gc_db.getGames(game_id = game_id, owner_id = owner_id) if games and len(games) == 1: game = games[0] if game['creation_time']: # Game has started myinvite = None mygames.append((owner_id, game_id)) if DEBUG: print >> sys.stderr, 'chessbot: starting chessbot for game (%d,%d)' % (owner_id, game_id) func = lambda:launchchessbot(game) overlay_bridge.add_task(func, 0) else: # Game has not yet started, resend the invite if int(time()) > myinvite['creation_time']+INV_EXPIRE_TIME: myinvite = None elif (rounds % 5) == 0: gc.resendSeek(myinvite) else: myinvite = None
def create_bad_metadata_bad_torrent3(self): torrent = {'info':481} data = bencode(torrent) d = self.create_good_metadata_dict(data) d['metadata'] = data bd = bencode(d) return METADATA+bd
def create_bad_metadata_bad_torrent2(self): torrent = {} data = bencode(torrent) d = self.create_good_metadata_dict(data) d["metadata"] = data bd = bencode(d) return METADATA + bd
def create_good_simpleplustorrents_reply(self,id): d = self.create_good_simple_reply_dict(id) bmetainfo = bencode(self.tdef.get_metainfo()) d['a'][self.tdef.get_infohash()]['torrent_size'] = len(bmetainfo) d['a'][self.tdef.get_infohash()]['metatype'] = 'application/x-tribler-stream' d['a'][self.tdef.get_infohash()]['metadata'] = bmetainfo b = bencode(d) return QUERY_REPLY+b
def create_bad_metadata_bad_torrent3(self): torrent = {'info': 481} data = bencode(torrent) d = self.create_good_metadata_dict(data) d['metadata'] = data bd = bencode(d) return METADATA + bd
def save_torrent(self, torrent_data, source = ''): if 'info' in torrent_data: infohash = sha.sha(bencode(torrent_data['info'])).digest() if not self.torrent_db.hasTorrent(infohash): if DEBUG: print >>sys.stderr,"subscrip:Injecting", torrent_data["info"].get("name", infohash) hexinfohash = binascii.hexlify(infohash) if DEBUG: print >>sys.stderr,"subscript: Writing",hexinfohash filename = os.path.join(self.torrent_dir, hexinfohash+'.torrent' ) f = open(filename,"wb") f.write(bencode(torrent_data)) f.close() # Arno: hack, make sure these torrents are always good so they show up # in Torrent DBHandler.getTorrents() extra_info = {'status':'good'} extra_info['filename'] = filename torrentdef = TorrentDef.load_from_dict(torrent_data) self.torrent_db.addExternalTorrent(torrentdef,source=source,extra_info=extra_info) # perform all url-specific callbacks for feed, on_torrent_callback, callback in self.feeds: if feed.feed_url == source: if on_torrent_callback: if DEBUG: print >> sys.stderr , "ON TORRENT CALLBACK" on_torrent_callback(source, infohash, torrent_data) if callback: if DEBUG: print >> sys.stderr , "USER CALLBACK" callback(source, infohash, torrent_data) break # perform all non-url-specific callbacks self.lock.acquire() callbacks = self.callbacks[:] self.lock.release() for callback in callbacks: try: if DEBUG: print >> sys.stderr , "RSS CALLBACK" callback(source, infohash, torrent_data) except: traceback.print_exc()
def subtest_good_friendship_stats(self): """ Send a valid message-id from a registered crawler peer """ print >>sys.stderr, "-"*80, "\ntest: good friendship stats" s = OLConnection(self.my_keypair, "localhost", self.hisport) t = time.time() - 100.0 msg_dict = {'current time':int(t)} payload = bencode(msg_dict) self.send_crawler_request(s, CRAWLER_FRIENDSHIP_STATS, 0, 0, payload) error, payload = self.receive_crawler_reply(s, CRAWLER_FRIENDSHIP_STATS, 0) assert error == 0 d = bdecode(payload) if DEBUG: print >>sys.stderr, "test: Got FRIENDSHIPSTATISTICS",`d` stats = d['stats'] self.assert_(len(stats) == 1) record = d['stats'][0] self.assert_(record[0] == bin2str(self.his_permid)) # source_permid self.assert_(record[1] == bin2str(self.some_permid)) # target_permid self.assert_(record[2] == 0) # isForwarder time.sleep(1) s.close()
def olthread_proxy_unhave_connect_callback(self, exc, dns, permid, selversion, aggregated_string): """ Sends the proxy_unhave message on the connection with the doe Called by the overlay thread. @param exc: Peer reachable/unreachable information. None = peer reachable @param dns: @param permid: the permid of the doe @param selversion: selected Overlay protocol version @param aggregated_string: a bitstring of available pieces """ if exc is None: # Create message according to protocol version message = PROXY_HAVE + self.infohash + bencode(aggregated_string) if DEBUG: print >> sys.stderr, "proxy: olthread_proxy_unhave_connect_callback: Sending PROXY_UNHAVE to", show_permid_short( permid) # Connect using Tribler Ovrlay Swarm self.overlay_bridge.send(permid, message, self.olthread_proxy_unhave_send_callback) elif DEBUG: # The doe is unreachable print >> sys.stderr, "proxy: olthread_proxy_unhave_connect_callback: error connecting to", show_permid_short( permid), exc
def udpConnect(self, permid, request_id, holePunchingAddr): if DEBUG: print >> sys.stderr, "NatCheckMsgHandler: request UDP connection" mh_data = request_id + ":" + holePunchingAddr[0] + ":" + str( holePunchingAddr[1]) if DEBUG: print >> sys.stderr, "NatCheckMsgHandler: udpConnect message is", mh_data try: mh_msg = bencode(mh_data) except: print_exc() if DEBUG: print >> sys.stderr, "NatCheckMsgHandler: error mh_data:", mh_data return False # send the message self.crawler.send_request(permid, CRAWLER_NATTRAVERSAL, mh_msg, frequency=0, callback=self.udpConnectCallback) if DEBUG: print >> sys.stderr, "NatCheckMsgHandler: request for", show_permid_short( permid), "sent to crawler"
def test_createSingleResponseMessage(self): langUtil = LanguagesProvider.getLanguagesInstance() data = { 'permid' : testDestPermId, 'channel_id' : testChannelId, 'infohash' : testInfohash, 'subtitles' : {"eng" : "This is content 1", "nld": "This is content 2", "ita" : "This is content 3"}, 'selversion' : OLPROTO_VER_FOURTEENTH } langs = data['subtitles'].keys() bitmask = langUtil.langCodesToMask(langs) binaryBitmask = pack("!L", bitmask) expextedMessage = SUBS + \ bencode(( data['channel_id'], data['infohash'], binaryBitmask, [data['subtitles']['eng'], data['subtitles']['ita'], data['subtitles']['nld']] )) msg = self.underTest._createSingleResponseMessage(data) decoded = bdecode(msg[1:]) self.assertEquals(expextedMessage, msg)
def test_receivedSUBSOtherRequest(self): langUtil = LanguagesProvider.getLanguagesInstance() data = { 'permid' : testDestPermId, 'channel_id' : testChannelId, 'infohash' : testInfohash, 'subtitles' : {"eng" : "This is content 1", "nld": "This is content 2", "ita" : "This is content 3"}, 'selversion' : OLPROTO_VER_FOURTEENTH } langs = data['subtitles'].keys() bitmask = langUtil.langCodesToMask(langs) binaryBitmask = pack("!L", bitmask) expextedMessage = SUBS + \ bencode(( data['channel_id'], data['infohash'], binaryBitmask, [data['subtitles']['eng'], data['subtitles']['ita'], data['subtitles']['nld']] )) list = MockMsgListener() self.underTest.registerListener(list) #invalid bitmask self.underTest._addToRequestedSubtitles(testChannelId, testInfohash, int(0xFFFFFFFF & ~bitmask), None) val = self.underTest.handleMessage(testDestPermId, OLPROTO_VER_FOURTEENTH, expextedMessage) # never had a request for this message should be dropped self.assertFalse(val) self.assertEquals(0,list.subsCount)
def setUpPostSession(self): """ override TestAsServer """ TestAsServer.setUpPostSession(self) self.mypermid = str(self.my_keypair.pub().get_der()) self.hispermid = str(self.his_keypair.pub().get_der()) # Calculating the infohash for proxyservice.test.torrent self.torrentfile = os.path.join('extend_hs_dir','proxyservice.test.torrent') # Read torrentfile to calculate the infohash torrentfile_content = open(self.torrentfile, "rb") # Decode all the file metainfo = bdecode(torrentfile_content.read()) # Re-encode only the info section self.infohash = hashlib.sha1(bencode(metainfo['info'])).digest() # Close the torrentfile torrentfile_content.close() # Add us as friend, so he will accept the ASK_FOR_HELP if False: # TEMP friendsdb = FriendDBHandler.getInstance() friendsdb.addFriend(self.mypermid) else: self.session.set_overlay_request_policy(AllowAllRequestPolicy()) self.session.set_download_states_callback(self.states_callback)
def do_GET(self): print >> sys.stderr, "test: tracker: Got GET request", self.path p = [] p1 = { 'peer id': self.server.myid, 'ip': self.server.myip, 'port': self.server.myport } p.append(p1) d = {} d['interval'] = 1800 d['peers'] = p bd = bencode(d) size = len(bd) self.send_response(200) self.send_header("Content-Type", "application/octet-stream") self.send_header("Content-Length", size) self.end_headers() try: self.wfile.write(bd) except Exception, e: print_exc(file=sys.stderr)
def createAndSendChannelCastMessage(self, target_permid, selversion): """ Create and send a ChannelCast Message """ # ChannelCast feature starts from eleventh version; hence, do not send to lower version peers if selversion < OLPROTO_VER_ELEVENTH: if DEBUG: print >> sys.stderr, time.asctime(),'-', "Do not send to lower version peer:", selversion return channelcast_data = self.createChannelCastMessage() if channelcast_data is None or len(channelcast_data)==0: if DEBUG: print >>sys.stderr, time.asctime(),'-', "No channels there.. hence we do not send" #self.session.chquery_connected_peers('k:MFIwEAYHKoZIzj0CAQYFK4EEABoDPgAEAf3BkHsZ6UdIpuIX441wjU5Ybe0HPjTDvS+iacFZABH20It9N9uwkwtpkS3uEvVvfcTX50jcFNXOSCwq') return channelcast_msg = bencode(channelcast_data) if self.log: dns = self.dnsindb(target_permid) if dns: ip,port = dns MSG_ID = "CHANNELCAST" msg = repr(channelcast_data) self.overlay_log('SEND_MSG', ip, port, show_permid(target_permid), selversion, MSG_ID, msg) data = CHANNELCAST + channelcast_msg self.secure_overlay.send(target_permid, data, self.channelCastSendCallback) if DEBUG: print >> sys.stderr, time.asctime(),'-', "Sent channelcastmsg",repr(channelcast_msg)
def create_ohlist_wrong_no_hashes(self,chunkid): index,begin,length = chunkid ohlist = [ (0,'#' * 20),(1,'$' * 20)] # should contain 3 for file2.wmv: own, sibling and root bohlist = bencode(ohlist) chunk = '*' * (2 ** 14) payload = tobinary(index)+tobinary(begin)+tobinary(len(bohlist))+bohlist+chunk return EXTEND+HASHPIECE+payload
def ValueToString(self, value, typex): if typex == "boolean": if value: text = "1" else: text = "0" elif typex == "color": red = str(value.Red()) while len(red) < 3: red = "0" + red green = str(value.Green()) while len(green) < 3: green = "0" + green blue = str(value.Blue()) while len(blue) < 3: blue = "0" + blue text = str(red) + str(green) + str(blue) elif typex.startswith("bencode"): text = bencode(value) else: if type(value) is unicode: text = value else: text = str(value) return text
def createAndSendChannelCastMessage(self, target_permid, selversion): """ Create and send a ChannelCast Message """ # ChannelCast feature starts from eleventh version; hence, do not send to lower version peers # Arno, 2010-02-05: v12 uses a different on-the-wire format, ignore those. # Andrea, 2010-04-08: sending the "old-style" channelcast message to older # peers, and enriched channelcast messages to new versions, for full backward # compatibility if selversion < OLPROTO_VER_THIRTEENTH: if DEBUG: print >> sys.stderr, "channelcast: Do not send to lower version peer:", selversion return # 3/5/2010 Andrea: adding the destination parameters to createChannelCastMessage for # logging reasons only. When logging will be disabled, that parameter will # become useless channelcast_data = self.createChannelCastMessage(selversion, target_permid) if channelcast_data is None or len(channelcast_data)==0: if DEBUG: print >>sys.stderr, "channelcast: No channels there.. hence we do not send" return channelcast_msg = bencode(channelcast_data) if self.log: dns = self.dnsindb(target_permid) if dns: ip,port = dns MSG_ID = "CHANNELCAST" msg = repr(channelcast_data) self.overlay_log('SEND_MSG', ip, port, show_permid(target_permid), selversion, MSG_ID, msg) data = CHANNELCAST + channelcast_msg self.overlay_bridge.send(target_permid, data, self.channelCastSendCallback)
def check_response1(self, resp1_data, rB, myid): resp1 = bdecode(resp1_data) self.assert_(type(resp1) == DictType) self.assert_(resp1.has_key('certA')) self.assert_(resp1.has_key('rA')) self.assert_(resp1.has_key('B')) self.assert_(resp1.has_key('SA')) # show throw exception when key no good pubA = EC.pub_key_from_der(resp1['certA']) rA = resp1['rA'] self.assert_(type(rA) == StringType) self.assert_(len(rA) == random_size) B = resp1['B'] self.assert_(type(B) == StringType) self.assert_(B, myid) SA = resp1['SA'] self.assert_(type(SA) == StringType) # verify signature sig_list = [rA, rB, myid] sig_data = bencode(sig_list) sig_hash = sha.sha(sig_data).digest() self.assert_(pubA.verify_dsa_asn1(sig_hash, SA)) # Cannot resign the data with his keypair to double check. Signing # appears to yield different, supposedly valid sigs each time. return resp1
def create_added_f_too_big(self): d = {} d['added'] = '' d['added.f'] = '\x00' d['dropped'] = '' bd = bencode(d) return EXTEND+chr(1)+bd
def create_dropped_too_small(self): d = {} d['added'] = '' d['added.f'] = '' d['dropped'] = '\x82\x25\xc1\x40\x00' # should be 6 bytes bd = bencode(d) return EXTEND+chr(1)+bd
def create_good_nontribler_extend_hs(self): d = {} d['m'] = {'hallo': 12, 'dag': 255} d['p'] = self.mylistenport d['v'] = 'TestSweet 1.2.3.4' bd = bencode(d) return EXTEND + chr(0) + bd
def create_dropped_not_str(self): d = {} d['added'] = '' d['added.f'] = '' d['dropped'] = 481 bd = bencode(d) return EXTEND+chr(1)+bd
def create_good_tribler_extend_hs(self): d = {} d['m'] = {'Tr_OVERLAYSWARM': 253} d['p'] = self.mylistenport d['v'] = 'Tribler 3.5.1' bd = bencode(d) return EXTEND + chr(0) + bd
def create_good_ut_pex(self,pex_id=1): d = {} d['added'] = '' d['added.f'] = '' d['dropped'] = '' bd = bencode(d) return EXTEND+chr(pex_id)+bd
def create_dropped_too_small(self): d = {} d['added'] = '' d['added.f'] = '' d['dropped'] = '\x82\x25\xc1\x40\x00' # should be 6 bytes bd = bencode(d) return EXTEND + chr(1) + bd
def create_diff_ips(self, i): if self.NLISTENERS == 1: s = REPLY_IP else: s = '127.0.0.' + str(i) b = bencode(s) return DIALBACK_REPLY + b
def create_not_hashpiece(self,chunkid): index,begin,length = chunkid ohlist = [] bohlist = bencode(ohlist) chunk = self.read_chunk(index,begin,length) payload = tobinary(index)+tobinary(begin)+tobinary(len(bohlist))+bohlist+chunk return EXTEND+chr(231)+payload
def _create_poa_message(self, msg_id, nonce_a, nonce_b): """ Create the POA exchange message (messages 3 and 4). """ assert msg_id assert nonce_a assert nonce_b assert self.poa # Provide the certificate if not self.poa: raise MissingCertificateException("Missing certificate") msg = [msg_id] + self.poa.serialize_to_list() # Add signature lst = [nonce_a, nonce_b, self.poa.serialize()] b_list = bencode(lst) digest = permid.sha(b_list).digest() sig = self.my_keypair.sign_dsa_asn1(digest) msg.append(sig) return msg
def create_added_f_too_big(self): d = {} d['added'] = '' d['added.f'] = '\x00' d['dropped'] = '' bd = bencode(d) return EXTEND + chr(1) + bd
def create_ut_pex(addedconns,droppedconns,thisconn): #print >>sys.stderr,"ut_pex: create_ut_pex:",addedconns,droppedconns,thisconn #Niels: Force max 50 added/dropped connections #"Some clients may choose to enforce these limits and drop connections which don't obey these limits." #http://wiki.theory.org/BitTorrentPeerExchangeConventions addedconns = addedconns[:50] droppedconns = droppedconns[:50] d = {} compactedpeerstr = compact_connections(addedconns,thisconn) d['added'] = compactedpeerstr flags = '' for i in range(len(addedconns)): conn = addedconns[i] if conn == thisconn: continue flag = 0 if conn.get_extend_encryption(): flag |= 1 if conn.download is not None and conn.download.peer_is_complete(): flag |= 2 if conn.is_tribler_peer(): flag |= 4 #print >>sys.stderr,"ut_pex: create_ut_pex: add flag",`flag` flags += chr(flag) d['added.f'] = flags compactedpeerstr = compact_connections(droppedconns) d['dropped'] = compactedpeerstr return bencode(d)
def create_good_tribler_extend_hs(self): d = {} d['m'] = {'Tr_OVERLAYSWARM':253} d['p'] = self.mylistenport d['v'] = 'Tribler 3.5.1' bd = bencode(d) return EXTEND+chr(0)+bd
def create_bad_chunk(self,chunkid): index,begin,length = chunkid ohlist = self.tree.get_hashes_for_piece(index) bohlist = bencode(ohlist) chunk = '*' * length payload = tobinary(index)+tobinary(begin)+tobinary(len(bohlist))+bohlist+chunk return EXTEND+HASHPIECE+payload
def create_good_nontribler_extend_hs(self): d = {} d['m'] = {'hallo':12, 'dag':255 } d['p'] = self.mylistenport d['v'] = 'TestSweet 1.2.3.4' bd = bencode(d) return EXTEND+chr(0)+bd
def create_dropped_not_str(self): d = {} d['added'] = '' d['added.f'] = '' d['dropped'] = 481 bd = bencode(d) return EXTEND + chr(1) + bd
def get_default_torrent(self,filename,title,paths=None): metainfo = {} metainfo['announce'] = 'http://localhost:0/announce' metainfo['announce-list'] = [] metainfo['creation date'] = int(time.time()) metainfo['encoding'] = 'UTF-8' info = {} info['name'] = title.encode("UTF-8") info['piece length'] = 2 ** 16 info['pieces'] = '*' * 20 if paths is None: info['length'] = 481 else: d1 = {} d1['path'] = [paths[0].encode("UTF-8")] d1['length'] = 201 d2 = {} d2['path'] = [paths[1].encode("UTF-8")] d2['length'] = 280 info['files'] = [d1,d2] metainfo['info'] = info path = os.path.join(self.config.get_torrent_collecting_dir(),filename) tdef = TorrentDef.load_from_dict(metainfo) tdef.save(path) return tdef, bencode(metainfo)
def subtest_invalidRequest3(self): """ Trying to send an invalid message (valid for everythin except that there is one field more) The connection should be closed by the receiver """ print >> sys.stderr, "test: test_subtitles_msgs_invalid_request_3 ------------------" ol_conn = OLConnection(self.my_keypair,'localhost',self.hisport) bitmask = LanguagesProvider.getLanguagesInstance().langCodesToMask(['nld','eng']) binmask = utilities.uintToBinaryString(bitmask, length=4) request = GET_SUBS + \ bencode(( self.anotherpermid, self.testInfohash, binmask, 42 )) ol_conn.send(request) self.assertEquals(0, len(ol_conn.recv())) print >> sys.stderr, "test: test_subtitles_msgs_invalid_request_3: connection closed as expected" ol_conn.close() print >> sys.stderr, "End of test_subtitles_msgs_invalid_request_3 ------------------"
def createAndSendBarterCastMessage(self, target_permid, selversion, active=False): # for older versions of Tribler (non-BarterCast): do nothing if selversion <= OLPROTO_VER_FIFTH: return if DEBUG: print >> sys.stderr, "===========bartercast: Sending BarterCast msg to ", self.bartercastdb.getName( target_permid) # create a new bartercast message bartercast_data = self.createBarterCastMessage(target_permid) if LOG: self.logMsg(bartercast_data, target_permid, 'out', logfile=self.logfile) try: bartercast_msg = bencode(bartercast_data) except: print_exc() print >> sys.stderr, "error bartercast_data:", bartercast_data return # send the message self.overlay_bridge.send(target_permid, BARTERCAST + bartercast_msg, self.bartercastSendCallback) self.blockPeer(target_permid, self.send_block_list, self.block_interval)
def handle_crawler_request(self, permid, selversion, channel_id, message, reply_callback): """ Received a CRAWLER_FRIENDSHIP_QUERY request. @param permid The Crawler permid @param selversion The overlay protocol version @param channel_id Identifies a CRAWLER_REQUEST/CRAWLER_REPLY pair @param message The message payload @param reply_callback Call this function once to send the reply: reply_callback(payload [, error=123]) """ if DEBUG: print >> sys.stderr, "FriendshipCrawler: handle_friendship_crawler_database_query_request", message try: d = bdecode(message) stats = self.getStaticsFromFriendshipStatisticsTable( self.session.get_permid(), d['current time']) msg_dict = {'current time': d['current time'], 'stats': stats} msg = bencode(msg_dict) reply_callback(msg) except Exception, e: print_exc() reply_callback(str(e), 1)
def create_diff_ips(self,i): if self.NLISTENERS==1: s = REPLY_IP else: s = '127.0.0.'+str(i) b = bencode(s) return DIALBACK_REPLY+b
def create_ut_pex(addedconns, droppedconns, thisconn): #print >>sys.stderr,"ut_pex: create_ut_pex:",addedconns,droppedconns,thisconn #Niels: Force max 50 added/dropped connections #"Some clients may choose to enforce these limits and drop connections which don't obey these limits." #http://wiki.theory.org/BitTorrentPeerExchangeConventions addedconns = addedconns[:50] droppedconns = droppedconns[:50] d = {} compactedpeerstr = compact_connections(addedconns, thisconn) d['added'] = compactedpeerstr flags = '' for i in range(len(addedconns)): conn = addedconns[i] if conn == thisconn: continue flag = 0 if conn.get_extend_encryption(): flag |= 1 if conn.download is not None and conn.download.peer_is_complete(): flag |= 2 if conn.is_tribler_peer(): flag |= 4 #print >>sys.stderr,"ut_pex: create_ut_pex: add flag",`flag` flags += chr(flag) d['added.f'] = flags compactedpeerstr = compact_connections(droppedconns) d['dropped'] = compactedpeerstr return bencode(d)
def create_remote_query_reply(self,id,hits,selversion): getsize = os.path.getsize join = os.path.join d = {} d['id'] = id d2 = {} for torrent in hits: r = {} # NEWDBSTANDARD. Do not rename r's fields: they are part of the # rquery protocol spec. r['content_name'] = torrent['name'] # According to TorrentDBHandler.addExternalTorrentencoded this is the original encoded name, TODO: standardize on UTF-8 encoding. r['length'] = torrent['length'] r['leecher'] = torrent['num_leechers'] r['seeder'] = torrent['num_seeders'] # Arno: TODO: sending category doesn't make sense as that's user-defined # leaving it now because of time constraints r['category'] = torrent['category'] if selversion >= OLPROTO_VER_NINETH: r['torrent_size'] = getsize(join(self.torrent_dir, torrent['torrent_file_name'])) if selversion >= OLPROTO_VER_ELEVENTH: r['channel_permid'] = torrent['channel_permid'] r['channel_name'] = torrent['channel_name'] if selversion >= OLPROTO_VER_TWELFTH and 'metadata' in torrent: if DEBUG: print >>sys.stderr,time.asctime(),'-', "rqmh: create_query_reply: Adding torrent file" r['metatype'] = torrent['metatype'] r['metadata'] = torrent['metadata'] d2[torrent['infohash']] = r d['a'] = d2 return bencode(d)
def create_good_ut_pex(self, pex_id=1): d = {} d['added'] = '' d['added.f'] = '' d['dropped'] = '' bd = bencode(d) return EXTEND + chr(pex_id) + bd
def _packData(self): """ Creates a bencode binary representation of this metadata instance. This representation is the one that is sent with ChannelCast messages. """ if self.description is not None: assert isinstance(self.description, unicode) if self.description is None: self.description = u"" bitmask, checksums = self._getSubtitlesMaskAndChecksums() # The signature is taken over the bencoding of # binary representations of (channel,infohash,description,timestamp,bitmask) # that is the same message that is sent with channelcast tosign = (self.channel, self.infohash, self.description.encode("utf-8"), self.timestamp, pack("!L", bitmask), checksums ) bencoding = bencode(tosign) return bencoding
def _create(metainfo): # TODO: replace with constructor # raises ValueErrors if not good validTorrentFile(metainfo) t = TorrentDef() t.metainfo = metainfo t.metainfo_valid = True # copy stuff into self.input maketorrent.copy_metainfo_to_input(t.metainfo, t.input) # For testing EXISTING LIVE, or EXISTING MERKLE: DISABLE, i.e. keep true infohash if t.get_url_compat(): t.infohash = makeurl.metainfo2swarmid(t.metainfo) else: # Two places where infohash calculated, here and in maketorrent.py # Elsewhere: must use TorrentDef.get_infohash() to allow P2PURLs. t.infohash = sha(bencode(metainfo['info'])).digest() assert isinstance( t.infohash, str), "INFOHASH has invalid type: %s" % type(t.infohash) assert len( t.infohash ) == INFOHASH_LENGTH, "INFOHASH has invalid length: %d" % len( t.infohash) #print >>sys.stderr,"INFOHASH",`t.infohash` return t
def ValueToString(self, value, typex): if typex == "boolean": if value: text = "1" else: text = "0" elif typex == "color": red = str(value.Red()) while len(red) < 3: red = "0" + red green = str(value.Green()) while len(green) < 3: green = "0" + green blue = str(value.Blue()) while len(blue) < 3: blue = "0" + blue text = str(red) + str(green) + str(blue) elif typex.startswith("bencode"): text = bencode(value) else: if type(value) is unicode: text = value else: text = str(value) return text
def createAndSendBarterCastMessage(self, target_permid, selversion, active = False): # for older versions of Tribler (non-BarterCast): do nothing if selversion <= OLPROTO_VER_FIFTH: return if DEBUG: print >> sys.stderr, "===========bartercast: Sending BarterCast msg to ", self.bartercastdb.getName(target_permid) # create a new bartercast message bartercast_data = self.createBarterCastMessage(target_permid) if LOG: self.logMsg(bartercast_data, target_permid, 'out', logfile = self.logfile) try: bartercast_msg = bencode(bartercast_data) except: print_exc() print >> sys.stderr, "error bartercast_data:", bartercast_data return # send the message self.overlay_bridge.send(target_permid, BARTERCAST+bartercast_msg, self.bartercastSendCallback) self.blockPeer(target_permid, self.send_block_list, self.block_interval)
def createAndSendVoteCastMessage(self, target_permid, selversion): """ Creates and sends a VOTECAST message """ if selversion < OLPROTO_VER_ELEVENTH: if DEBUG: print >> sys.stderr, time.asctime(),'-', "Do not send to lower version peer:", selversion return votecast_data = self.createVoteCastMessage() if len(votecast_data) == 0: if DEBUG: print >>sys.stderr, time.asctime(),'-', "No votes there.. hence we do not send" return votecast_msg = bencode(votecast_data) if self.log: dns = self.dnsindb(target_permid) if dns: ip,port = dns MSG_ID = "VOTECAST" msg = voteCastReplyMsgToString(votecast_data) self.overlay_log('SEND_MSG', ip, port, show_permid(target_permid), selversion, MSG_ID, msg) if DEBUG: print >> sys.stderr, time.asctime(),'-', "Sending votecastmsg",voteCastMsgToString(votecast_data) data = VOTECAST+votecast_msg self.secure_overlay.send(target_permid, data, self.voteCastSendCallback)
def create_good_tribler_extend_hs(self, pex_id=1): d = {} d['m'] = {'Tr_OVERLAYSWARM': 253, 'ut_pex': pex_id} d['p'] = self.mylistenport d['v'] = 'Tribler 3.5.1' d['e'] = 0 bd = bencode(d) return EXTEND + chr(0) + bd
def send_overlap(self,permid,oldict): try: body = bencode(oldict) ## Optimization: we know we're currently connected self.overlay_bridge.send(permid, SOCIAL_OVERLAP + body,self.send_callback) except: if DEBUG: print_exc(file=sys.stderr)
def create_torrent_signature(response, keypairfilename): keypair = EC.load_key(keypairfilename) bresponse = bencode(response) digester = sha(bresponse[:]) digest = digester.digest() sigstr = keypair.sign_dsa_asn1(digest) response['signature'] = sigstr response['signer'] = str(keypair.pub().get_der())
def create_good_metadata(self): f = open(self.torrentfile, "rb") data = f.read() f.close() d = self.create_good_metadata_dict(data) bd = bencode(d) return METADATA + bd
def create_good_tribler_extend_hs_v2(self,g2g_id=G2G_ID): d = {} d['m'] = {'Tr_OVERLAYSWARM':253,'Tr_G2G_v2':g2g_id} d['p'] = self.mylistenport d['v'] = 'Tribler 4.2.0' d['e'] = 0 bd = bencode(d) return EXTEND+chr(0)+bd
def generate_response1(randomB, peeridB, keypairA): randomA = Rand.rand_bytes(num_random_bits / 8) response1 = {} response1['certA'] = str(keypairA.pub().get_der()) response1['rA'] = randomA response1['B'] = peeridB response1['SA'] = sign_response(randomA, randomB, peeridB, keypairA) return [randomA, bencode(response1)]
def serialize(self): """ Return a bencoded, serialized POA """ lst = [ self.torrent_id, self.torrent_pub_key, self.node_pub_key, self.expire_time, self.signature ] return bencode(lst)
def _createGETSUBSMessage(self, channel_id, infohash, bitmask): """ Bencodes a GET_SUBS message and adds the appropriate header. """ binaryBitmask = pack("!L", bitmask) body = bencode((channel_id, infohash, binaryBitmask)) head = GET_SUBS return head + body
def create_resp2_bad_cert(self, rB, resp1_dict, hisid): resp2 = {} resp2['certB'] = '\x00\x00\x00\x00\x00\x30\x00\x00' resp2['A'] = hisid sig_list = [rB, resp1_dict['rA'], hisid] sig_data = bencode(sig_list) sig_hash = sha.sha(sig_data).digest() sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash)) resp2['SB'] = sig_asn1 return self.create_response2_payload(resp2)
def create_resp2_wrong_randomA(self, rB, resp1_dict, hisid): resp2 = {} resp2['certB'] = str(self.my_keypair.pub().get_der()) resp2['A'] = hisid sig_list = [rB, "wrong".zfill(random_size), hisid] sig_data = bencode(sig_list) sig_hash = sha.sha(sig_data).digest() sig_asn1 = str(self.my_keypair.sign_dsa_asn1(sig_hash)) resp2['SB'] = sig_asn1 return self.create_response2_payload(resp2)
def create_resp2_sig_by_other_keypair(self, rB, resp1_dict, hisid): resp2 = {} resp2['certB'] = str(self.my_keypair.pub().get_der()) resp2['A'] = hisid sig_list = [rB, resp1_dict['rA'], hisid] sig_data = bencode(sig_list) sig_hash = sha.sha(sig_data).digest() sig_asn1 = str(self.his_keypair.sign_dsa_asn1(sig_hash)) resp2['SB'] = sig_asn1 return self.create_response2_payload(resp2)
def send_extend_handshake(self): d = {} d['m'] = self.connecter.EXTEND_HANDSHAKE_M_DICT d['p'] = self.connecter.mylistenport ver = version_short.replace('-', ' ', 1) d['v'] = ver d['e'] = 0 # Apparently this means we don't like uTorrent encryption self._send_message(EXTEND + EXTEND_MSG_HANDSHAKE_ID + bencode(d)) if DEBUG: print >> sys.stderr, 'connecter: sent extend: id=0+', d