async def run(self):
"""
"""
try:
wrap_ssl = False
if self.target.proto == LDAPProtocol.SSL:
wrap_ssl = True
self.out_queue = asyncio.Queue()
self.in_queue = asyncio.Queue()
self.proxy_in_queue = asyncio.Queue()
comms = SocksQueueComms(self.out_queue,
self.proxy_in_queue,
wrap_ssl=wrap_ssl)
self.target.proxy.target[
-1].endpoint_ip = self.target.host if self.target.serverip is None else self.target.serverip
self.target.proxy.target[-1].endpoint_port = int(self.target.port)
self.target.proxy.target[
-1].endpoint_timeout = None #TODO: maybe implement endpoint timeout?
self.target.proxy.target[-1].timeout = self.target.timeout
self.client = SOCKSClient(comms, self.target.proxy.target)
proxy_coro = await self.client.run(True)
self.proxy_task = asyncio.create_task(proxy_coro)
await self.client.proxy_running_evt.wait()
self.handle_in_task = asyncio.create_task(self.handle_in_q())
return True, None
except Exception as e:
traceback.print_exc()
return False, e
async def __gen_targets(self):
try:
for port_gen in self.port_gens:
ports = port_gen.run()
for port in ports:
self.ports[port] = 1
while True:
addr = await self.__addr_queue.get()
if addr is None:
break
print(addr)
for port in self.ports:
self.__total_targets += 1
credential = self.connection_url.get_creds()
target = self.connection_url.get_target()
target.endpoint_ip = addr
target.endpoint_port = port
target.timeout = None
target.only_open = True
in_q = asyncio.Queue()
out_q = asyncio.Queue()
comms = SocksQueueComms(in_q, out_q)
client = SOCKSClient(comms, target, credential)
await self.__target_queue.put((addr, port, client))
self.__target_gen_finished_evt.set()
except Exception as e:
print(e)
async def connect(self): try: self.out_queue = asyncio.Queue() self.in_queue = asyncio.Queue() comms = SocksQueueComms(self.out_queue, self.in_queue) self.target.proxy.target[-1].endpoint_ip = self.target.ip self.target.proxy.target[-1].endpoint_port = int(self.target.port) self.target.proxy.target[-1].endpoint_timeout = None #int(self.target.timeout) self.target.proxy.target[-1].timeout = int(self.target.timeout) if self.target.timeout is not None else None self.client = SOCKSClient(comms, self.target.proxy.target) proxy_coro = await self.client.run(True) self.proxy_task = asyncio.create_task(proxy_coro) await self.client.proxy_running_evt.wait() return True, None except Exception as e: return False, e
async def connect(self):
self.out_queue = asyncio.Queue()
self.in_queue = asyncio.Queue()
comms = SocksQueueComms(self.out_queue, self.in_queue)
self.target.proxy.target.endpoint_ip = self.target.ip
self.target.proxy.target.endpoint_port = int(self.target.port)
self.client = SOCKSClient(comms, self.target.proxy.target,
self.target.proxy.auth)
self.proxy_task = asyncio.create_task(self.client.run())
return
async def setup(self): try: if self.proxy is None: # no need for additional setup return None, None self.in_q = asyncio.Queue() self.out_q = asyncio.Queue() comms = SocksQueueComms(self.in_q, self.out_q) proxies = SocksClientURL.from_urls(self.proxy, self.server, self.port) self.proxyobj = SOCKSClient(comms, proxies) self.proxy_task = asyncio.create_task(self.proxyobj.run()) return None, None except Exception as e: return None, e
async def socks5_test_port(self, username = None, password = None, timeout = None, retries = -1):
"""
Tests if port binding is supported by the socks server
"""
try:
while retries != 0:
retries -= 1
target = SocksTarget()
target.version = SocksServerVersion.SOCKS5
target.server_ip = self.server_ip
target.server_port = self.server_port
target.is_bind = False
target.timeout = 10
target.buffer_size = 4096
target.ssl_ctx = self.server_sslctx
target.endpoint_ip = self.verify_host
target.endpoint_port = self.verify_port #random.randint(35000, 50000)
target.endpoint_timeout = None
target.only_open = True
credential = SocksCredential()
credential.username = username
credential.password = password
in_q = asyncio.Queue()
out_q = asyncio.Queue()
comms = SocksQueueComms(in_q, out_q)
channel_open_evt = asyncio.Event()
client = SOCKSClient(comms, target, credential, bind_evt = channel_open_evt)
#client_task = asyncio.create_task(client.run())
res, err = await client.handle_queue()
if err is not None:
if isinstance(err, SOCKS5ServerErrorReply):
if err.reply in [SOCKS5ReplyType.TTL_EXPIRED, SOCKS5ReplyType.CONN_REFUSED, SOCKS5ReplyType.HOST_UNREACHABLE, SOCKS5ReplyType.CONN_NOT_ALLOWED]:
return False, err
elif err.reply in [SOCKS5ReplyType.ADDRESS_TYPE_NOT_SUPPORTED]:
return None, err
continue
return True, None
return None, Exception('Max retries reached!')
except Exception as e:
return None, e
async def sendrecv(self, data):
self.out_queue = asyncio.Queue()
self.in_queue = asyncio.Queue()
comms = SocksQueueComms(self.out_queue, self.in_queue)
self.client = SOCKSClient(comms, self.target.proxy.target)
proxy_coro = await self.client.run(True)
self.proxy_task = asyncio.create_task(proxy_coro)
await self.client.proxy_running_evt.wait()
#self.proxy_task = asyncio.create_task(self.client.run())
length = len(data).to_bytes(4, byteorder='big', signed=False)
await self.out_queue.put(length + data)
resp_data = b''
resp_data_len = -1
while True:
data, err = await self.in_queue.get()
if data is None:
break
if err is not None:
raise err
resp_data += data
if resp_data_len == -1:
if len(resp_data) > 4:
resp_data_len = int.from_bytes(resp_data[:4],
byteorder='big',
signed=False)
if resp_data_len == 0:
raise Exception(
'Returned data length is 0! This means the server did not understand our message'
)
if resp_data_len != -1:
if len(resp_data) == resp_data_len + 4:
resp_data = resp_data[4:]
break
elif len(resp_data) > resp_data_len + 4:
raise Exception('Got too much data somehow')
else:
continue
await self.out_queue.put(None)
if resp_data == b'':
raise Exception('Connection returned no data!')
krb_message = KerberosResponse.load(resp_data)
return krb_message
async def connect(self):
try:
self.out_queue = asyncio.Queue()
self.in_queue = asyncio.Queue()
comms = SocksQueueComms(self.out_queue, self.in_queue)
self.target.proxy.target[-1].endpoint_ip = self.target.ip
self.target.proxy.target[-1].endpoint_port = int(self.target.port)
self.target.proxy.target[-1].endpoint_timeout = int(
self.target.timeout)
self.target.proxy.target[-1].timeout = int(self.target.timeout)
self.client = SOCKSClient(comms, self.target.proxy.target)
self.proxy_task = asyncio.create_task(self.client.run())
return True, None
except Exception as e:
return False, e
async def setup(self):
try:
try:
ipaddress.ip_address(self.server)
return None, None
except:
pass
self.in_q = asyncio.Queue()
self.out_q = asyncio.Queue()
su = SocksClientURL.from_params(self.server)
comms = SocksQueueComms(self.in_q, self.out_q)
self.proxy = SOCKSClient(comms, su)
self.proxy_task = asyncio.create_task(self.proxy.run())
return None, None
except Exception as e:
return None, e
async def run(self): """ """ try: self.out_queue = asyncio.Queue() self.in_queue = asyncio.Queue() self.proxy_in_queue = asyncio.Queue() comms = SocksQueueComms(self.out_queue, self.proxy_in_queue) self.target.proxy.target.endpoint_ip = self.target.host self.target.proxy.target.endpoint_port = int(self.target.port) self.client = SOCKSClient(comms, self.target.proxy.target, self.target.proxy.auth) self.proxy_task = asyncio.create_task(self.client.run()) self.handle_in_task = asyncio.create_task(self.handle_in_q()) return True, None except Exception as e: return False, e
async def socks5_bind(self, username = None, password = None, timeout = None): """ Tests if port binding is supported by the socks server """ try: target = SocksTarget() target.version = SocksServerVersion.SOCKS5 target.server_ip = self.server_ip target.server_port = self.server_port target.is_bind = True target.timeout = 10 target.buffer_size = 4096 target.ssl_ctx = self.server_sslctx target.endpoint_ip = '0.0.0.0' target.endpoint_port = random.randint(35000, 50000) target.endpoint_timeout = None target.only_bind = True credential = SocksCredential() credential.username = username credential.password = password in_q = asyncio.Queue() out_q = asyncio.Queue() comms = SocksQueueComms(in_q, out_q) client = SOCKSClient(comms, target, credential) res, err = await client.handle_queue() if err is None: return True, None if isinstance(err, SOCKS5ServerErrorReply): if err.reply == SOCKS5ReplyType.COMMAND_NOT_SUPPORTED: return False, None return res, err except Exception as e: return None, e
async def socks5_local(self, username = None, password = None, timeout = None): """ Tests if port binding is supported by the socks server """ try: target = SocksTarget() target.version = SocksServerVersion.SOCKS5 target.server_ip = self.server_ip target.server_port = self.server_port target.is_bind = False target.timeout = 10 target.buffer_size = 4096 target.ssl_ctx = self.server_sslctx target.endpoint_ip = self.server_ip target.endpoint_port = self.verify_port if self.verify_port is not None else 22 target.endpoint_timeout = None credential = SocksCredential() credential.username = username credential.password = password in_q = asyncio.Queue() out_q = asyncio.Queue() comms = SocksQueueComms(in_q, out_q) client = SOCKSClient(comms, target, credential) res, err = await client.handle_queue() if err is None: return True, None if isinstance(err, SOCKS5ServerErrorReply): if err.reply in [SOCKS5ReplyType.FAILURE, SOCKS5ReplyType.CONN_NOT_ALLOWED]: return False, None return res, err except Exception as e: return None, e
async def run(self):
"""
"""
try:
self.out_queue = asyncio.Queue()
self.in_queue = asyncio.Queue()
self.proxy_in_queue = asyncio.Queue()
comms = SocksQueueComms(self.out_queue, self.proxy_in_queue)
self.target.proxy.target[
-1].endpoint_ip = self.target.host if self.target.serverip is None else self.target.serverip
self.target.proxy.target[-1].endpoint_port = int(self.target.port)
self.target.proxy.target[
-1].endpoint_timeout = None #TODO: maybe implement endpoint timeout?
self.target.proxy.target[-1].timeout = self.target.timeout
self.client = SOCKSClient(comms, self.target.proxy.target)
self.proxy_task = asyncio.create_task(self.client.run())
self.handle_in_task = asyncio.create_task(self.handle_in_q())
return True, None
except Exception as e:
return False, e
async def main():
in_queue = asyncio.Queue()
out_queue = asyncio.Queue()
await out_queue.put(b'GET / HTTP/1.1\r\nHost: google.com\r\n\r\n')
target = SocksTarget()
#target.version = SocksServerVersion.SOCKS4
target.version = SocksServerVersion.SOCKS5
target.server_ip = '127.0.0.1'
target.server_port = 9050
target.is_bind = False
target.proto = SocksProtocol.TCP
target.timeout = 10
target.buffer_size = 4096
target.endpoint_ip = ipaddress.ip_address('216.239.32.117')
target.endpoint_port = 80
comms = SocksQueueComms(out_queue, in_queue)
t = asyncio.create_task(read_q(in_queue))
client = SOCKSClient(comms, target)
await client.run()
print('DONE!')
async def __gen_targets(self):
try:
while True:
password = await self.__passwords_queue.get()
if password is None:
break
self.passwords[password] = 1
while True:
user = await self.__users_queue.get()
if user is None:
break
for password in self.passwords:
self.__total_targets += 1
credential = SocksCredential()
credential.username = user
credential.password = password
target = self.connection_url.get_target()
target.only_open = True
target.only_auth = True
target.endpoint_ip = self.verify_target
target.endpoint_port = self.verify_port
in_q = asyncio.Queue()
out_q = asyncio.Queue()
comms = SocksQueueComms(in_q, out_q)
client = SOCKSClient(comms, target, credential)
await self.__target_queue.put((user, password, client))
self.__target_gen_finished_evt.set()
except Exception as e:
print(e)