def main():
now = datetime.datetime.now()
timestamp_str = now.strftime("%Y%m%d-%H%M%S")
results_path = timestamp_str + '_tag'
os.mkdir(results_path)
shutil.copy('infohashes.dat', results_path)
shutil.copy('conductor.py', results_path)
shutil.copy('conductor_spy.py', results_path)
shutil.copy('parser.py', results_path)
shutil.copy('plotter.py', results_path)
shutil.copytree('parsers', os.path.join(results_path, 'parsers'))
shutil.copytree('plotters', os.path.join(results_path, 'plotters'))
captures_path = os.path.abspath(
os.path.join(results_path, timestamp_str + '.pcap'))
print 'Now, you need to start capturing netwok traffic'
print 'Windows:\nWinDump.exe -C 500 -s 0 -w %s udp' % (captures_path)
print 'Linux:\nsudo tcpdump -C 500 -s 0 -w %s udp' % (captures_path)
print '-' * 70
print 'Press ENTER to continue'
sys.stdout.flush()
#sys.stdin.readline()
time.sleep(60)
nodes = []
for mod, addr, node_name, r_mod, l_mod, node_id in _randompopper(CONFIG):
# Create infohash generator
print 'Starting %s %r, %r %r %r...' % (node_name, addr, r_mod.__file__,
l_mod.__file__, node_id),
sys.stdout.flush()
node_path = os.path.join(results_path, node_name)
os.mkdir(node_path)
node = mod.Pymdht(addr, node_path, r_mod, l_mod, None, logs_level,
node_id)
nodes.append((node_name, node))
print 'DONE'
time.sleep(STARTUP_DELAY)
#Leave them some time to bootstrap
time.sleep(BOOTSTRAP_DELAY)
running = True
try:
while 1:
time.sleep(10000)
except KeyboardInterrupt:
pass
for node_name, node in nodes:
node.stop()
print 'Stopping %s ...' % node_name,
sys.stdout.flush()
time.sleep(STOPPING_DELAY)
print 'DONE'
print '-' * 70
print 'Now, stop the network capturing with Ctr-C'
def main(options, args):
port = int(options.port)
my_addr = (options.ip, port)
if not os.path.isdir(options.path):
if os.path.exists(options.path):
print 'FATAL:', options.path, 'must be a directory'
return
print options.path, 'does not exist. Creating directory...'
os.mkdir(options.path)
logs_path = options.path
logs_level = options.logs_level or default_logs_level
logging_conf.setup(logs_path, logs_level)
print 'Using the following plug-ins:'
print '*', options.routing_m_file
print '*', options.lookup_m_file
print 'Path:', options.path
print 'Private DHT name:', options.private_dht_name
routing_m_name = '.'.join(os.path.split(options.routing_m_file))[:-3]
routing_m_mod = __import__(routing_m_name, fromlist=[''])
lookup_m_name = '.'.join(os.path.split(options.lookup_m_file))[:-3]
lookup_m_mod = __import__(lookup_m_name, fromlist=[''])
exp_m_name = '.'.join(os.path.split(options.exp_m_file))[:-3]
exp_m_mod = __import__(exp_m_name, fromlist=[''])
global dht
dht = pymdht.Pymdht(my_addr, logs_path,
routing_m_mod,
lookup_m_mod,
exp_m_mod,
options.private_dht_name,
logs_level)
random_lookup_delay = options.random_lookup_delay
while random_lookup_delay > 0:
time.sleep(float(random_lookup_delay))
target = identifier.RandomId()
dht.get_peers(None, target, None, 0)
global geo_score
if options.geoip_mode:
try:
import geo
geo_score = geo.Geo(local_ip)
except:
print "---------------------------------------"
print "Geo module FAILED: you cannot use --geo"
print "---------------------------------------"
raise
else:
geo_score = None
global server
server = SocketServer.TCPServer(('', port), SessionHandler)
while not stop_server:
server.handle_request()
def main(options, args):
id_str, ip, port_str = args
port = int(port_str)
node_to_extract = Node((ip, port), Id(id_str))
table_extractor = TableExtractor(node_to_extract)
logs_path = os.path.join(os.path.expanduser("~"), ".pymdht")
logging_conf.setup(logs_path, logging.DEBUG)
reactor = minitwisted.ThreadedReactor(table_extractor.main_loop, 7000, table_extractor.on_datagram_received)
reactor.start()
time.sleep(30)
def main(options, args):
id_str, ip, port_str = args
port = int(port_str)
node_to_extract = Node((ip, port), Id(id_str))
table_extractor = TableExtractor(node_to_extract)
logs_path = os.path.join(os.path.expanduser('~'), '.pymdht')
logging_conf.setup(logs_path, logging.DEBUG)
reactor = minitwisted.ThreadedReactor(table_extractor.main_loop, 7000,
table_extractor.on_datagram_received)
reactor.start()
time.sleep(30)
def main(options, args):
ip, port_str = args
port = int(port_str)
bootstrap_node = Node((ip, port), RandomId())
mcrawler = MultiCrawler(bootstrap_node)
logs_path = '.'# os.path.join(os.path.expanduser('~'), '.pymdht')
logging_conf.setup(logs_path, logging.DEBUG)
reactor = minitwisted.ThreadedReactor(
mcrawler.main_loop, 7005,
mcrawler.on_datagram_received,
task_interval=.005)
reactor.start()
try:
time.sleep(20000)
except:
pass
def main(options, args):
if not os.path.isdir(options.path):
if os.path.exists(options.path):
print >> sys.stderr, "FATAL:", options.path, "must be a directory"
return
print >> sys.stderr, options.path, "does not exist. Creating directory..."
os.mkdir(options.path)
logs_path = options.path
if options.lookup_delay and not options.daemon:
print >> sys.stderr, "Switching to DAEMON mode (no user interface)"
if options.lookup_delay or options.daemon:
# redirect output
stdout_file = os.path.join(options.path, "pymdht.stdout")
stderr_file = os.path.join(options.path, "pymdht.stderr")
print >> sys.stderr, "Redirecting output to %s and %s" % (stdout_file, stderr_file)
sys.stdout = open(stdout_file, "w")
sys.stderr = open(stderr_file, "w")
my_addr = (options.ip, int(options.port))
my_id = None
if options.node_id:
base_id = identifier.Id(options.node_id)
my_id = base_id.generate_close_id(options.log_distance)
my_node = node.Node(my_addr, my_id, version=pymdht.VERSION_LABEL)
if options.debug:
logs_level = logging.DEBUG # This generates HUGE (and useful) logs
else:
# logs_level = logging.INFO # This generates some (useful) logs
logs_level = logging.WARNING # This generates warning and error logs
print "Using the following plug-ins:"
print "*", options.routing_m_file
print "*", options.lookup_m_file
print "*", options.experimental_m_file
print "Path:", options.path
print "Private DHT name:", options.private_dht_name
print "debug mode:", options.debug
print "auto_bootstrap:", options.auto_bootstrap
print "bootstrap mode:", options.bootstrap_mode
print "Swift tracker port:", options.swift_port
routing_m_name = ".".join(os.path.split(options.routing_m_file))[:-3]
routing_m_mod = __import__(routing_m_name, fromlist=[""])
lookup_m_name = ".".join(os.path.split(options.lookup_m_file))[:-3]
lookup_m_mod = __import__(lookup_m_name, fromlist=[""])
experimental_m_name = ".".join(os.path.split(options.experimental_m_file))[:-3]
experimental_m_mod = __import__(experimental_m_name, fromlist=[""])
dht = pymdht.Pymdht(
my_node,
logs_path,
routing_m_mod,
lookup_m_mod,
experimental_m_mod,
options.private_dht_name,
logs_level,
auto_bootstrap=options.auto_bootstrap,
bootstrap_mode=options.bootstrap_mode,
swift_port=options.swift_port,
)
if options.lookup_delay:
loop_forever = not options.num_lookups
remaining_lookups = options.num_lookups
while loop_forever or remaining_lookups:
time.sleep(options.lookup_delay)
if options.lookup_target:
target = identifier.Id(options.lookup_target)
else:
target = identifier.RandomId()
print "lookup", target
dht.get_peers(None, target, None, options.announce_port)
remaining_lookups = remaining_lookups - 1
time.sleep(options.stop_delay)
dht.stop()
elif options.ttl:
stop_timestamp = time.time() + int(options.ttl)
while time.time() < stop_timestamp:
time.sleep(1)
dht.stop()
elif options.daemon:
# Just loop for ever
while 1:
time.sleep(10)
elif options.gui:
import wx
import ui.gui
app = wx.PySimpleApp()
frame = ui.gui.Interactive_GUI(None, "Interactive Look@MDHT", None, (1440, 900), dht, logs_path)
frame.Show(True)
app.MainLoop()
elif options.telnet_port:
import ui.telnet
telnet_ui = ui.telnet.Telnet(dht, options.telnet_port)
telnet_ui.start()
elif options.cli:
import ui.cli
ui.cli.command_user_interface(dht)
def __init__(self, filename):
self._lock = threading.Lock()
self._is_done = False
self._pinged_ips = set()
self._pinged_addrs = set()
self._ok_addrs = set()
self._file = open(filename)
self.reactor = ThreadedReactor(
self._main_loop,
PORT, self._on_datagram_received)
self.reactor.start()
def is_done(self):
with self._lock:
done = self._is_done
return done
def stop_and_get_result(self):
self.reactor.stop()
return sorted(list(self._ok_addrs))
if __name__ == '__main__':
logging_conf.setup('.', logging.DEBUG)
bc = BootstrapChecker(sys.argv[1])
while not bc.is_done():
time.sleep(1)
time.sleep(3)
result = bc.stop_and_get_result()
for addr in result:
print addr[0], addr[1]
def main(options, args):
if not os.path.isdir(options.path):
if os.path.exists(options.path):
print >>sys.stderr, 'FATAL:', options.path, 'must be a directory'
return
print >>sys.stderr, options.path, 'does not exist. Creating directory...'
os.mkdir(options.path)
logs_path = options.path
if options.lookup_delay and not options.daemon:
print >>sys.stderr, 'Switching to DAEMON mode (no user interface)'
if options.lookup_delay or options.daemon:
# redirect output
stdout_file = os.path.join(options.path, 'pymdht.stdout')
stderr_file = os.path.join(options.path, 'pymdht.stderr')
print >>sys.stderr, 'Redirecting output to %s and %s' % (
stdout_file, stderr_file)
sys.stdout = open(stdout_file, 'w')
sys.stderr = open(stderr_file, 'w')
my_addr = (options.ip, int(options.port))
my_id = None
if options.node_id:
base_id = identifier.Id(options.node_id)
my_id = base_id.generate_close_id(options.log_distance)
my_node = node.Node(my_addr, my_id)
if options.debug:
logs_level = logging.DEBUG # This generates HUGE (and useful) logs
else:
#logs_level = logging.INFO # This generates some (useful) logs
logs_level = logging.WARNING # This generates warning and error logs
print 'Using the following plug-ins:'
print '*', options.routing_m_file
print '*', options.lookup_m_file
print '*', options.experimental_m_file
print 'Path:', options.path
print 'Private DHT name:', options.private_dht_name
print 'debug mode:', options.debug
routing_m_name = '.'.join(os.path.split(options.routing_m_file))[:-3]
routing_m_mod = __import__(routing_m_name, fromlist=[''])
lookup_m_name = '.'.join(os.path.split(options.lookup_m_file))[:-3]
lookup_m_mod = __import__(lookup_m_name, fromlist=[''])
experimental_m_name = '.'.join(os.path.split(options.experimental_m_file))[:-3]
experimental_m_mod = __import__(experimental_m_name, fromlist=[''])
dht = pymdht.Pymdht(my_node, logs_path,
routing_m_mod,
lookup_m_mod,
experimental_m_mod,
options.private_dht_name,
logs_level)
if options.lookup_delay:
loop_forever = not options.num_lookups
remaining_lookups = options.num_lookups
while loop_forever or remaining_lookups:
time.sleep(options.lookup_delay)
if options.lookup_target:
target = identifier.Id(options.lookup_target)
else:
target = identifier.RandomId()
print 'lookup', target
dht.get_peers(None, target, None, options.announce_port)
remaining_lookups = remaining_lookups - 1
time.sleep(options.stop_delay)
dht.stop()
elif options.ttl:
stop_timestamp = time.time() + int(options.ttl)
while time.time() < stop_timestamp:
time.sleep(1)
dht.stop()
elif options.daemon:
# Just loop for ever
while 1:
time.sleep(10)
elif options.gui:
import wx
import ui.gui
app = wx.PySimpleApp()
frame = ui.gui.Interactive_GUI(
None, "Interactive DHT . . .", None,(1440,900),
dht, logs_path)
frame.Show(True)
app.MainLoop()
elif options.cli:
import ui.cli
ui.cli.command_user_interface(dht)
def main():
now = datetime.datetime.now()
timestamp_str = now.strftime("%Y%m%d-%H%M%S")
results_path = timestamp_str + '_tag'
os.mkdir(results_path)
shutil.copy('infohashes.dat', results_path)
shutil.copy('conductor.py', results_path)
shutil.copy('conductor_spy.py', results_path)
shutil.copy('parser.py', results_path)
shutil.copy('plotter.py', results_path)
shutil.copytree('parsers', os.path.join(results_path, 'parsers'))
shutil.copytree('plotters', os.path.join(results_path, 'plotters'))
captures_path = os.path.abspath(os.path.join(results_path, timestamp_str + '.pcap'))
print 'Now, you need to start capturing netwok traffic'
print 'Windows:\nWinDump.exe -C 500 -s 0 -w %s udp' % (captures_path)
print 'Linux:\nsudo tcpdump -C 500 -s 0 -w %s udp' % (captures_path)
print '-' * 70
print 'Press ENTER to continue'
sys.stdout.flush()
#sys.stdin.readline()
time.sleep(60)
nodes = []
for mod, addr, node_name, r_mod, l_mod, node_id in _randompopper(CONFIG):
# Create infohash generator
print 'Starting %s %r, %r %r %r...' % (node_name, addr,
r_mod.__file__,
l_mod.__file__,
node_id),
sys.stdout.flush ()
node_path = os.path.join(results_path, node_name)
os.mkdir(node_path)
node = mod.Pymdht(addr, node_path, r_mod, l_mod, None,
logs_level, node_id)
nodes.append((node_name, node))
print 'DONE'
time.sleep(STARTUP_DELAY)
#Leave them some time to bootstrap
time.sleep(BOOTSTRAP_DELAY)
running = True
try:
while 1:
time.sleep(10000)
except KeyboardInterrupt:
pass
for node_name, node in nodes:
node.stop()
print 'Stopping %s ...' % node_name,
sys.stdout.flush()
time.sleep(STOPPING_DELAY)
print 'DONE'
print '-' * 70
print 'Now, stop the network capturing with Ctr-C'
def main(options, args):
if not os.path.isdir(options.path):
if os.path.exists(options.path):
print >> sys.stderr, 'FATAL:', options.path, 'must be a directory'
return
print >> sys.stderr, options.path, 'does not exist. Creating directory...'
os.mkdir(options.path)
logs_path = options.path
if options.lookup_delay and not options.daemon:
print >> sys.stderr, 'Switching to DAEMON mode (no user interface)'
if options.lookup_delay or options.daemon:
# redirect output
stdout_file = os.path.join(options.path, 'pymdht.stdout')
stderr_file = os.path.join(options.path, 'pymdht.stderr')
print >> sys.stderr, 'Redirecting output to %s and %s' % (stdout_file,
stderr_file)
sys.stdout = open(stdout_file, 'w')
sys.stderr = open(stderr_file, 'w')
my_addr = (options.ip, int(options.port))
my_id = None
if options.node_id:
base_id = identifier.Id(options.node_id)
my_id = base_id.generate_close_id(options.log_distance)
my_node = node.Node(my_addr, my_id, version=pymdht.VERSION_LABEL)
if options.debug:
logs_level = logging.DEBUG # This generates HUGE (and useful) logs
else:
# logs_level = logging.INFO # This generates some (useful) logs
logs_level = logging.WARNING # This generates warning and error logs
print 'Using the following plug-ins:'
print '*', options.routing_m_file
print '*', options.lookup_m_file
print '*', options.experimental_m_file
print 'Path:', options.path
print 'Private DHT name:', options.private_dht_name
print 'debug mode:', options.debug
print 'bootstrap mode:', options.bootstrap_mode
print 'Swift tracker port:', options.swift_port
routing_m_name = '.'.join(os.path.split(options.routing_m_file))[:-3]
routing_m_mod = __import__(routing_m_name, fromlist=[''])
lookup_m_name = '.'.join(os.path.split(options.lookup_m_file))[:-3]
lookup_m_mod = __import__(lookup_m_name, fromlist=[''])
experimental_m_name = '.'.join(os.path.split(
options.experimental_m_file))[:-3]
experimental_m_mod = __import__(experimental_m_name, fromlist=[''])
dht = pymdht.Pymdht(my_node, logs_path, routing_m_mod, lookup_m_mod,
experimental_m_mod, options.private_dht_name,
logs_level, options.bootstrap_mode, options.swift_port)
if options.lookup_delay:
loop_forever = not options.num_lookups
remaining_lookups = options.num_lookups
while loop_forever or remaining_lookups:
time.sleep(options.lookup_delay)
if options.lookup_target:
target = identifier.Id(options.lookup_target)
else:
target = identifier.RandomId()
print 'lookup', target
dht.get_peers(None, target, None, options.announce_port)
remaining_lookups = remaining_lookups - 1
time.sleep(options.stop_delay)
dht.stop()
elif options.ttl:
stop_timestamp = time.time() + int(options.ttl)
while time.time() < stop_timestamp:
time.sleep(1)
dht.stop()
elif options.daemon:
# Just loop for ever
while True:
time.sleep(10)
elif options.gui:
import wx
import ui.gui
app = wx.PySimpleApp()
frame = ui.gui.Interactive_GUI(None, "Interactive Look@MDHT", None,
(1440, 900), dht, logs_path)
frame.Show(True)
app.MainLoop()
elif options.telnet_port:
import ui.telnet
telnet_ui = ui.telnet.Telnet(dht, options.telnet_port)
telnet_ui.start()
elif options.cli:
import ui.cli
ui.cli.command_user_interface(dht)
def main():
now = datetime.datetime.now()
timestamp_str = now.strftime("%Y%m%d-%H%M%S")
results_path = timestamp_str + '_tag'
os.mkdir(results_path)
shutil.copy('infohashes.dat', results_path)
shutil.copy('conductor.py', results_path)
shutil.copy('parser.py', results_path)
shutil.copy('plotter.py', results_path)
shutil.copytree('parsers', os.path.join(results_path, 'parsers'))
shutil.copytree('plotters', os.path.join(results_path, 'plotters'))
captures_path = os.path.abspath(
os.path.join(results_path, timestamp_str + '.pcap'))
print 'Now, you need to start capturing netwok traffic'
print 'Windows:\nWinDump.exe -C 500 -s 0 -w %s udp' % (captures_path)
print 'Linux:\nsudo tcpdump -C 500 -s 0 -w %s udp' % (captures_path)
print '-' * 70
print 'Press ENTER to continue'
sys.stdin.readline()
nodes = []
for mod, addr, node_name, r_mod, l_mod in _randompopper(CONFIG):
# Create infohash generator
infohash_gen = _randompopper(INFOHASHES)
print 'Starting %s %r, %r %r...' % (node_name, addr, r_mod.__file__,
l_mod.__file__),
sys.stdout.flush()
node_path = os.path.join(results_path, node_name)
os.mkdir(node_path)
node = mod.Pymdht(addr, node_path, r_mod, l_mod, None, logs_level)
nodes.append((node_name, node, infohash_gen))
print 'DONE'
time.sleep(STARTUP_DELAY)
#Leave them some time to bootstrap
time.sleep(BOOTSTRAP_DELAY)
running = True
for round_number in xrange(len(INFOHASHES)):
# In every round, DHT nodes are randomly ordered
for node_name, node, infohash_gen in _randompopper(nodes):
# Every DHT node performs a lookup
infohash = identifier.Id(infohash_gen.next())
print '%d %s getting peers for info_hash %r' % (
round_number, node_name, infohash)
node.get_peers((node_name, time.time()), infohash, _on_peers_found,
0)
time.sleep(REMOVE_TORRENT_DELAY)
try:
remove_torrent_f = node.remove_torrent
except:
pass
else:
remove_torrent_f(infohash)
time.sleep(LOOKUP_DELAY - REMOVE_TORRENT_DELAY)
time.sleep(ROUND_DELAY)
for node_name, node, _ in nodes:
node.stop()
print 'Stopping %s ...' % node_name,
sys.stdout.flush()
time.sleep(STOPPING_DELAY)
print 'DONE'
print '-' * 70
print 'Now, stop the network capturing with Ctr-C'
def main():
now = datetime.datetime.now()
timestamp_str = now.strftime("%Y%m%d-%H%M%S")
results_path = timestamp_str + '_tag'
os.mkdir(results_path)
shutil.copy('infohashes.dat', results_path)
shutil.copy('conductor.py', results_path)
shutil.copy('parser.py', results_path)
shutil.copy('plotter.py', results_path)
shutil.copytree('parsers', os.path.join(results_path, 'parsers'))
shutil.copytree('plotters', os.path.join(results_path, 'plotters'))
captures_path = os.path.abspath(os.path.join(results_path, timestamp_str + '.pcap'))
print 'Now, you need to start capturing netwok traffic'
print 'Windows:\nWinDump.exe -C 500 -s 0 -w %s udp' % (captures_path)
print 'Linux:\nsudo tcpdump -C 500 -s 0 -w %s udp' % (captures_path)
print '-' * 70
print 'Press ENTER to continue'
sys.stdin.readline()
nodes = []
for mod, addr, node_name, r_mod, l_mod in _randompopper(CONFIG):
# Create infohash generator
infohash_gen = _randompopper(INFOHASHES)
print 'Starting %s %r, %r %r...' % (node_name, addr,
r_mod.__file__, l_mod.__file__),
sys.stdout.flush ()
node_path = os.path.join(results_path, node_name)
os.mkdir(node_path)
node = mod.Pymdht(addr, node_path, r_mod, l_mod, None, logs_level)
nodes.append((node_name, node, infohash_gen))
print 'DONE'
time.sleep(STARTUP_DELAY)
#Leave them some time to bootstrap
time.sleep(BOOTSTRAP_DELAY)
running = True
for round_number in xrange(len(INFOHASHES)):
# In every round, DHT nodes are randomly ordered
for node_name, node, infohash_gen in _randompopper(nodes):
# Every DHT node performs a lookup
infohash = identifier.Id(infohash_gen.next())
print '%d %s getting peers for info_hash %r' % (
round_number, node_name, infohash)
node.get_peers((node_name, time.time()),
infohash, _on_peers_found, 0)
time.sleep(REMOVE_TORRENT_DELAY)
try:
remove_torrent_f = node.remove_torrent
except:
pass
else:
remove_torrent_f(infohash)
time.sleep(LOOKUP_DELAY - REMOVE_TORRENT_DELAY)
time.sleep(ROUND_DELAY)
for node_name, node, _ in nodes:
node.stop()
print 'Stopping %s ...' % node_name,
sys.stdout.flush()
time.sleep(STOPPING_DELAY)
print 'DONE'
print '-' * 70
print 'Now, stop the network capturing with Ctr-C'
if addr in self._pinged_addrs:
self._pinged_addrs.remove(addr)
self._ok_addrs.add(addr)
return TIMEOUT, []
def is_done(self):
with self._lock:
done = self._is_done
return done
def stop_and_get_result(self):
self.reactor.stop()
return sorted(list(self._ok_addrs))
if __name__ == '__main__':
logging_conf.setup('.', logging.DEBUG)
if len(sys.argv) > 1:
input_filename = sys.argv[1]
else:
input_filename = INPUT_FILE
output_filename = 'bootstrap.backup.release-%d.%d.%d' % (PYMDHT_VERSION)
bc = BootstrapChecker(input_filename)
while not bc.is_done():
time.sleep(1)
time.sleep(3)
result = bc.stop_and_get_result()
output_file = open(output_filename, 'w')
for addr in result:
print >> output_file, addr[0], addr[1]
