././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8296292 asysocks-0.2.2/0000755000000000000000000000000014310720220012077 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/LICENSE0000664000000000000000000000205014136501636013121 0ustar00rootrootMIT License Copyright (c) 2020 skelsec Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8296292 asysocks-0.2.2/PKG-INFO0000644000000000000000000000053514310720220013177 0ustar00rootrootMetadata-Version: 2.1 Name: asysocks Version: 0.2.2 Home-page: https://github.com/skelsec/asysocks Author: Tamas Jos Author-email: info@skelsecprojects.com Classifier: Programming Language :: Python :: 3.6 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Requires-Python: >=3.6 License-File: LICENSE ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1643228920.0 asysocks-0.2.2/README.md0000664000000000000000000000700614174327370013404 0ustar00rootroot![Supported Python versions](https://img.shields.io/badge/python-3.7+-blue.svg) [![Twitter](https://img.shields.io/twitter/follow/skelsec?label=skelsec&style=social)](https://twitter.com/intent/follow?screen_name=skelsec) :triangular_flag_on_post: This is the public repository of aardwolf, for latest version and updates please consider supporting us through https://porchetta.industries/ # asysocks Asynchronous Socks5 / Socks4 / HTTP proxy client and server library in pure python. ## :triangular_flag_on_post: Sponsors If you want to sponsors this project and have the latest updates on this project, latest issues fixed, latest features, please support us on https://porchetta.industries/ ## Official Discord Channel Come hang out on Discord! [![Porchetta Industries](https://discordapp.com/api/guilds/736724457258745996/widget.png?style=banner3)](https://discord.gg/ycGXUxy) ## what is? The primary goal of this project to act as a universal proxy clinet/server library which you can use in your projects. Secondary goal is to have simple command-line tools to interact with socks proxyies or to start one yourself. See [tools](https://github.com/skelsec/asysocks#tools) ## how can I use this in my code? This library has three main components, [client](https://github.com/skelsec/asysocks#client) , [server](https://github.com/skelsec/asysocks#server), [security](https://github.com/skelsec/asysocks#security) ### client The proxy client code is implemented in the `SOCKSClient` class which can be used to set up a connection to a target `host:port` via `HTTP` / `SCOSK4` / `SOCKS5` proxy protocols. It has two modes of operation: `LISTENER` and `QUEUE` #### listener This mode helps proxy-unaware applications to use proxies when you can set the destination `host:port` and can't use `proxychains` and alike. It will create a TCP socket server on your localhost and each incoming client will be dispatched to the destination server via the specified proxy server. #### queue This mode can be used in your scripts to support proxies. The way it works is that you will not get a direct socket rather you can delegate two `asyncio.Queue` classes (one for data in, one for data out) ### server The proxy server is implemented in the `SOCKSServer` class. It supports `HTTP` / `SCOSK4` / `SOCKS5` protocols all on the same port. The server has basic paramteres most importantly the `listen_ip` and `listen_port` . It also comes with a clever way to deal with intercepting traffic, see the `ProxyMonitor` class and the server's `monitor_dispatch_q` variable. ### security TBD ## tools These are built-in examples showing the capabilities of the library and to be used as code snipplets on setting up classes. ### asysockstunnel Creates a listening server on localhost and tunnels all incoming connections to a pre-specified destination via a pre-defined proxy server. ### asysockssec SOCKS4/SOCKS5 server security tester ### asysocksbrute SOCKS5 authentication bruteforcer. ### asysocksportscan Quick port scaning via SOCKS4/SOCKS5/HTTP proxies ### asysocksproxy SOCKS4/SOCKS5/HTTP proxy server. Supports basic monitoring of traffic flow. ## Known issues/limitations The biggest limitation at the moment is the lack of SSL support on server side intercepting and the same issue exists on the client side when dealing with delegated queues. Reason is that I still can't find a way to wrap arbitarary data in/out streams with python's built-in `ssl` module. Hope this will change in the future. For more issues see [Issues](https://github.com/skelsec/asysocks/issues) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.7776291 asysocks-0.2.2/asysocks/0000755000000000000000000000000014310720220013736 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/__init__.py0000664000000000000000000000051414136501636016067 0ustar00rootroot#!/usr/bin/env python3 # # Author: # Tamas Jos (@skelsec) # import logging logger = logging.getLogger(__name__) handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279157.0 asysocks-0.2.2/asysocks/_version.py0000664000000000000000000000020214310720065016137 0ustar00rootroot __version__ = "0.2.2" __banner__ = \ """ # asysocks %s # Author: Tamas Jos @skelsec (info@skelsecprojects.com) """ % __version__././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1663279247.785629 asysocks-0.2.2/asysocks/authentication/0000755000000000000000000000000014310720220016755 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/authentication/__init__.py0000664000000000000000000000000014136501636021074 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285535.0 asysocks-0.2.2/asysocks/certmanager.py0000664000000000000000000002264714213712437016632 0ustar00rootroot import os import asyncio import datetime import uuid import glob import tempfile import logging import hashlib import ssl from cryptography import x509 from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import rsa from cryptography.hazmat.primitives import serialization from cryptography.x509.oid import NameOID logger = logging.getLogger('asysocks.certmanager') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) class CertManager: def __init__(self, ca_cert = None, ca_key = None, cache_dir = None, ca_cert_file = None, ca_key_file = None, ca_key_file_pw = None): self.ca_cert_file = ca_cert_file self.ca_cert = ca_cert self.ca_key = ca_key self.ca_key_file = ca_key_file self.ca_key_file_pw = ca_key_file_pw self.cache_dir = cache_dir self.ca = None self.setup() def setup(self): ca_cert_data = None ca_key_data = None if self.cache_dir is None: path = os.path.join(tempfile.gettempdir(), 'certstore') os.makedirs(path, exist_ok=True) self.cache_dir = path if self.ca_cert_file is None and self.ca_cert is None: self.ca_cert_file = os.path.join(self.cache_dir, 'cacert.pem') if self.ca_key_file is None and self.ca_key is None: self.ca_key_file = os.path.join(self.cache_dir, 'cakey.pem') if self.ca_cert_file is not None: try: with open(self.ca_cert_file, 'rb') as f: ca_cert_data = f.read() except: pass if self.ca_key_file is not None: try: with open(self.ca_key_file, 'rb') as f: ca_key_data = f.read() except: pass if ca_cert_data is None or ca_key_data is None: self.intialize_certstore() else: self.ca_cert = x509.load_pem_x509_certificate(ca_cert_data, default_backend()) self.ca_key = serialization.load_pem_private_key(ca_key_data, self.ca_key_file_pw, backend=default_backend()) def intialize_certstore(self, cn = 'asysocks', on = 'asysocks', ou = 'asysocks', key_exp = 65537, key_size = 2048): ca_cert, ca_key, err = CertManager.generate_ca(cn = cn, on = on, ou = ou, key_exp = key_exp, key_size = key_size) if err is not None: raise err cname = 'cacert.pem' kname = 'cakey.pem' with open(os.path.join(self.cache_dir, cname), 'wb') as f: f.write(ca_cert) with open(os.path.join(self.cache_dir, kname), 'wb') as f: f.write(ca_key) self.ca_cert = x509.load_pem_x509_certificate(ca_cert, default_backend()) self.ca_key = serialization.load_pem_private_key(ca_key, self.ca_key_file_pw, backend=default_backend()) def store_to_cache(self, new_cert, new_key, hostname = None): cert = x509.load_pem_x509_certificate(new_cert, default_backend()) if hostname is not None: bname = bname = '%s_%s' % (cert.serial_number, hostname) else: bname = '%s_%s' % (cert.serial_number, hashlib.sha1(cert.subject.rfc4514_string().encode()).hexdigest()) cname = '%s_%s.pem' % (bname, 'cert') kname = '%s_%s.pem' % (bname, 'key') with open(os.path.join(self.cache_dir, cname), 'wb') as f: f.write(new_cert) with open(os.path.join(self.cache_dir, kname), 'wb') as f: f.write(new_key) return os.path.join(self.cache_dir, cname), os.path.join(self.cache_dir, kname) def load_from_cache(self, hostname = None, cert_der_data = None, serial = None, subject = None, ret_file_path = True): cert_filename = None key_filename = None if cert_der_data is not None: cert = x509.load_der_x509_certificate(cert_der_data, default_backend()) serial = cert.serial_number for filename in glob.glob(os.path.join(self.cache_dir, '*.pem')): basename = os.path.basename(filename) if serial is not None and basename.startswith(str(serial)): if basename.endswith('_key.pem'): key_filename = filename elif basename.endswith('_cert.pem'): cert_filename = filename elif hostname is not None and basename.find('_%s_' % hostname) != -1: if basename.endswith('_key.pem'): key_filename = filename elif basename.endswith('_cert.pem'): cert_filename = filename if cert_filename is None or key_filename is None: return None, None if ret_file_path is True: return os.path.join(self.cache_dir, cert_filename), os.path.join(self.cache_dir, key_filename) with open(cert_filename, 'r') as f: certdata = f.read() with open(key_filename, 'r') as f: keydata = f.read() return certdata, keydata def resign_certificate(self, cert, is_binary = True): try: if is_binary is True: old_cert = x509.load_der_x509_certificate(cert, default_backend()) else: old_cert = x509.load_pem_x509_certificate(cert, default_backend()) # TODO: generate the same type of key with the same strength as the original cert has # https://cryptography.io/en/latest/_modules/cryptography/x509/base/#Certificate.public_key cert_key = rsa.generate_private_key( public_exponent=65537, key_size=2048, backend=default_backend() ) builder = x509.CertificateBuilder( subject_name=old_cert.subject, issuer_name=self.ca_cert.subject, public_key=cert_key.public_key(), serial_number=old_cert.serial_number, not_valid_before=old_cert.not_valid_before, not_valid_after=old_cert.not_valid_after, ) # TODO: add extensions as well maybe #for x in old_cert.extensions: # print(type(x)) # builder.add_extension(x, x.critical) new_cert_obj = builder.sign(self.ca_key, hashes.SHA256() ,default_backend()) new_cert = new_cert_obj.public_bytes(encoding=serialization.Encoding.PEM) new_key = cert_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.NoEncryption(), ) return new_cert, new_key, None except Exception as e: logger.exception('resign_certificate') return None, None, e async def get_cert_by_host(self, hostname, port = 443, ssl_ctx = None): try: certfile, keyfile = self.load_from_cache(hostname=hostname) if certfile is not None: logger.debug('Cache hit for %s' % hostname) return certfile, keyfile, None cert, err = await CertManager.fetch_remote_cert(hostname, port, ssl_ctx=ssl_ctx) if err is not None: raise err certfile, keyfile = self.load_from_cache(cert_der_data=cert) if certfile is not None: logger.debug('Cache hit for %s' % hostname) return certfile, keyfile, None logger.debug('Cache miss for %s' % hostname) new_cert, new_key, err = self.resign_certificate(cert) if err is not None: raise err certfile, keyfile = self.store_to_cache(new_cert, new_key) return certfile, keyfile, None except Exception as e: logger.exception('get_cert_by_host') return None, None, e @staticmethod async def fetch_remote_cert(hostname, port = 443, ssl_ctx = None, binary_form = True): writer = None try: if ssl_ctx is None: ssl_ctx = ssl.create_default_context() _, writer = await asyncio.open_connection(host=hostname, port=port, ssl=ssl_ctx, server_hostname = hostname) ssl_obj = writer.get_extra_info('ssl_object') cert = ssl_obj.getpeercert(binary_form=binary_form) return cert, None except Exception as e: logger.exception('fetch_remote_cert') return None, e finally: if writer is not None: writer.close() @staticmethod def generate_ca(cn = 'asysocks', on = '', ou = '', key_exp = 65537, key_size = 2048): try: logger.debug('Generating initial CA certificate') ca_cert = None ca_key = None one_day = datetime.timedelta(1, 0, 0) one_year = datetime.timedelta(365, 0, 0) private_key = rsa.generate_private_key( public_exponent=key_exp, key_size=key_size, backend=default_backend() ) public_key = private_key.public_key() builder = x509.CertificateBuilder() builder = builder.subject_name(x509.Name([ x509.NameAttribute(NameOID.COMMON_NAME, cn), x509.NameAttribute(NameOID.ORGANIZATION_NAME, on), x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, ou), ])) builder = builder.issuer_name(x509.Name([ x509.NameAttribute(NameOID.COMMON_NAME, cn), ])) builder = builder.not_valid_before(datetime.datetime.today() - one_day) builder = builder.not_valid_after(datetime.datetime.today() + one_year) builder = builder.serial_number(int(uuid.uuid4())) builder = builder.public_key(public_key) builder = builder.add_extension( x509.BasicConstraints(ca=True, path_length=None), critical=True, ) certificate = builder.sign( private_key=private_key, algorithm=hashes.SHA256(), backend=default_backend() ) ca_cert = certificate.public_bytes( encoding=serialization.Encoding.PEM, ) ca_key = private_key.private_bytes( encoding=serialization.Encoding.PEM, format=serialization.PrivateFormat.TraditionalOpenSSL, encryption_algorithm=serialization.NoEncryption() ) return ca_cert, ca_key, None except Exception as e: logger.exception('generate_ca') return None, None, e async def amain(): cert, err = await CertManager.fetch_remote_cert('444.hu') if err is not None: print(err) return print(cert) cm = CertManager() #a = cm.resign_certificate(cert) #print(a) while True: certfile, keyfile, err = await cm.get_cert_by_host('444.hu') if err is not None: print(err) return def main(): logger.setLevel(1) asyncio.run(amain()) if __name__ == '__main__': main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1652867051.0 asysocks-0.2.2/asysocks/client.py0000664000000000000000000006063414241137753015621 0ustar00rootroot import asyncio import base64 import traceback from asysocks import logger from asysocks.common.constants import SocksServerVersion, SocksCommsMode from asysocks.protocol.http import HTTPResponse, HTTPProxyAuthRequiredException, HTTPProxyAuthFailed from asysocks.protocol.socks4 import SOCKS4Request, SOCKS4Reply, SOCKS4CDCode from asysocks.protocol.socks4a import SOCKS4ARequest, SOCKS4AReply, SOCKS4ACDCode from asysocks.protocol.socks5 import SOCKS5Method, SOCKS5Nego, SOCKS5NegoReply, SOCKS5Request, SOCKS5Reply, SOCKS5ReplyType, SOCKS5PlainAuth, SOCKS5PlainAuthReply, SOCKS5ServerErrorReply, SOCKS5AuthFailed from asysocks.utils.sslwrapper import SSLWrapper class SocksTunnelError(Exception): def __init__(self, innerexception, message="Something failed setting up the tunnel! See innerexception for more details"): self.innerexception = innerexception self.message = message super().__init__(self.message) class SOCKSClient: def __init__(self, comms, proxies, bind_evt = None, channel_open_evt = None): self.proxies = proxies if isinstance(proxies, list) is False: self.proxies = [proxies] self.comms = comms self.server_task = None self.proxytask_in = None self.proxytask_out = None self.proxy_stopped_evt = None self.proxy_running_evt = None self.http_auth_ctx = None self.bind_progress_evt = bind_evt self.bind_port = None self.ssl_wrapper = None self.channel_open_evt = channel_open_evt async def terminate(self): if self.proxy_stopped_evt is not None: self.proxy_stopped_evt.set() if self.proxytask_in is not None: self.proxytask_in.cancel() if self.proxytask_out is not None: self.proxytask_out.cancel() def get_peercert(self): if self.ssl_wrapper is not None: return self.ssl_wrapper.get_server_cert() @staticmethod async def proxy_stream(in_stream, out_stream, proxy_stopped_evt, buffer_size = 4096, timeout = None): try: while True: read_task = asyncio.wait_for( in_stream.read(buffer_size), timeout = timeout ) finished_tasks, pending_tasks = await asyncio.wait([read_task, proxy_stopped_evt.wait()], return_when=asyncio.FIRST_COMPLETED) for task in finished_tasks: result = await task if result is True: try: for pt in pending_tasks: last_data = await asyncio.wait_for(pt, timeout = 0.5) except: pass else: if last_data != b'': out_stream.write(result) await out_stream.drain() logger.debug('other side disconnected!') return else: if result == b'': logger.debug('Stream channel broken!') return out_stream.write(result) await out_stream.drain() for pt in pending_tasks: pt.cancel() except asyncio.CancelledError: return except asyncio.TimeoutError: logger.debug('proxy_stream timeout! (timeout=%s)' % str(timeout)) except Exception as e: logger.debug('proxy_stream err: %s' % str(e)) finally: out_stream.close() proxy_stopped_evt.set() @staticmethod async def proxy_queue_in(in_queue, writer, proxy_stopped_evt, buffer_size = 4096): try: while not proxy_stopped_evt.is_set(): data = await in_queue.get() if data is None: logger.debug('proxy_queue_in client disconncted!') return writer.write(data) await writer.drain() except asyncio.CancelledError: return except Exception as e: logger.debug('proxy_queue_in err: %s' % str(e)) finally: proxy_stopped_evt.set() try: writer.close() except: pass @staticmethod async def proxy_queue_out(out_queue, reader, proxy_stopped_evt, buffer_size = 4096, timeout = None): try: is_wsnet = hasattr(reader, 'wsnet_reader_type') while True: if is_wsnet: data = await reader.read(buffer_size) else: data = await asyncio.wait_for( reader.read(buffer_size), timeout = timeout ) if data == b'': logger.debug('proxy_queue_out endpoint disconncted!') await out_queue.put((None, Exception('proxy_queue_out endpoint disconncted gracefully!'))) return await out_queue.put((data, None)) except asyncio.CancelledError: await out_queue.put((None, Exception('proxy_queue_out got cancelled!'))) return except Exception as e: logger.debug('proxy_queue_out exception %s' % e) try: await out_queue.put((None, e)) except: pass finally: proxy_stopped_evt.set() async def run_http(self, proxy, remote_reader, remote_writer, timeout = None, http_auth_ctx = None): try: logger.debug('[HTTP] Opening channel to %s:%s' % (proxy.endpoint_ip, proxy.endpoint_port)) connect_cmd = 'CONNECT %s:%s HTTP/1.1\r\nHost: %s:%s\r\n' % (proxy.endpoint_ip, proxy.endpoint_port, proxy.endpoint_ip, proxy.endpoint_port) connect_cmd = connect_cmd.encode() if http_auth_ctx is None: remote_writer.write(connect_cmd + b'\r\n') await asyncio.wait_for(remote_writer.drain(), timeout = timeout) resp, err = await HTTPResponse.from_streamreader(remote_reader, timeout=timeout) if err is not None: raise err if resp.status == 200: logger.debug('[HTTP] Server succsessfully connected!') return True, http_auth_ctx, None elif resp.status == 407: logger.debug('[HTTP] Server proxy auth required!') if proxy.credential is None: raise Exception('HTTP proxy auth required but no credential set!') auth_type = resp.headers_upper.get('PROXY-AUTHENTICATE', None) if auth_type is None: raise Exception('HTTP proxy requires authentication, but requested auth type could not be determined') auth_type, _ = auth_type.split(' ', 1) logger.debug('HTTP proxy requires %s auth' % auth_type) http_auth_ctx = auth_type.upper() return False, http_auth_ctx, HTTPProxyAuthRequiredException() elif http_auth_ctx == 'BASIC': auth_data = base64.b64encode(('%s:%s' % (proxy.credential.username, proxy.credential.password) ).encode() ) auth_connect = connect_cmd + b'Proxy-Authorization: Basic ' + auth_data + b'\r\n' remote_writer.write(auth_connect + b'\r\n') await asyncio.wait_for(remote_writer.drain(), timeout = timeout) resp, err = await HTTPResponse.from_streamreader(remote_reader, timeout=timeout) if err is not None: raise err if resp.status == 200: logger.debug('[HTTP] Server proxy auth succsess!') return True, http_auth_ctx, None else: raise HTTPProxyAuthFailed() #raise Exception('Proxy auth failed!') else: raise Exception('HTTP proxy requires %s authentication, but it\'s not implemented' % http_auth_ctx) except Exception as e: logger.debug('run_http') return False, None, e async def run_socks4(self, proxy, remote_reader, remote_writer, timeout = None): """ Does the intial "handshake" instructing the remote server to set up the connection to the endpoint """ try: logger.debug('[SOCKS4 %s:%s] Opening channel to %s:%s (target)' % (proxy.server_ip, proxy.server_port, proxy.endpoint_ip, proxy.endpoint_port)) req = SOCKS4Request.from_target(proxy) if proxy.credential is not None and proxy.credential.username is not None: req.USERID = proxy.credential.username remote_writer.write(req.to_bytes()) await asyncio.wait_for(remote_writer.drain(), timeout = timeout) rep, err = await asyncio.wait_for(SOCKS4Reply.from_streamreader(remote_reader), timeout = timeout) if err is not None: raise err if rep is None: raise Exception('Socks server failed to reply to CONNECT request!') if rep.CD != SOCKS4CDCode.REP_GRANTED: raise Exception('Socks server returned error on CONNECT! %s' % rep.CD.value) logger.debug('[SOCKS4] Channel opened') return True, None except Exception as e: logger.debug('run_socks4') return False, e async def run_socks4a(self, proxy, remote_reader, remote_writer, timeout = None): """ Does the intial "handshake" instructing the remote server to set up the connection to the endpoint """ try: logger.debug('[SOCKS4A %s:%s] Opening channel to %s:%s (target)' % (proxy.server_ip, proxy.server_port, proxy.endpoint_ip, proxy.endpoint_port)) req = SOCKS4ARequest.from_target(proxy) if proxy.credential is not None and proxy.credential.username is not None: req.USERID = proxy.credential.username remote_writer.write(req.to_bytes()) await asyncio.wait_for(remote_writer.drain(), timeout = timeout) rep, err = await asyncio.wait_for(SOCKS4AReply.from_streamreader(remote_reader), timeout = timeout) if err is not None: raise err if rep is None: raise Exception('Socks server failed to reply to CONNECT request!') if rep.CD != SOCKS4ACDCode.REP_GRANTED: raise Exception('Socks server returned error on CONNECT! %s' % rep.CD.value) logger.debug('[SOCKS4A] Channel opened') return True, None except Exception as e: logger.debug('run_socks4a') return False, e async def run_socks5(self, proxy, remote_reader, remote_writer, timeout = None): """ Does the intial "handshake" instructing the remote server to set up the connection to the endpoint """ sname = proxy.get_sname() tname = proxy.get_tname() methods = [SOCKS5Method.NOAUTH] if proxy.credential is not None and proxy.credential.username is not None and proxy.credential.password is not None: methods.append(SOCKS5Method.PLAIN) #methods = [SOCKS5Method.PLAIN] try: nego = SOCKS5Nego.from_methods(methods) logger.debug('[SOCKS5 %s][SETUP] Sending negotiation command to server' % sname) remote_writer.write(nego.to_bytes()) await asyncio.wait_for( remote_writer.drain(), timeout = timeout ) rep_nego = await asyncio.wait_for( SOCKS5NegoReply.from_streamreader(remote_reader), timeout = timeout ) logger.debug( '[SOCKS5 %s] Got negotiation reply! Server choosen auth type: %s' % (sname, rep_nego.METHOD.name) ) if rep_nego.METHOD == SOCKS5Method.PLAIN: if proxy.credential is None or proxy.credential.username is None or proxy.credential.password is None: raise Exception('SOCKS5 %s] server requires PLAIN authentication, but no credentials were supplied!' % sname) logger.debug('[SOCKS5 %s]Preforming plaintext auth' % sname) remote_writer.write( SOCKS5PlainAuth.construct( proxy.credential.username, proxy.credential.password ).to_bytes() ) await asyncio.wait_for( remote_writer.drain(), timeout=None ) rep_data = await asyncio.wait_for( remote_reader.read(2), timeout = timeout ) if rep_data == b'': raise SOCKS5AuthFailed() #raise Exception('Plaintext auth failed! Bad username or password') rep_nego = SOCKS5PlainAuthReply.from_bytes(rep_data) if rep_nego.STATUS != SOCKS5ReplyType.SUCCEEDED: raise SOCKS5AuthFailed() #raise Exception('Plaintext auth failed! Bad username or password') elif rep_nego.METHOD == SOCKS5Method.GSSAPI: raise Exception('[SOCKS5 %s] server requires GSSAPI authentication, but it\'s not supported at the moment' % sname) logger.debug('[SOCKS5 %s] Opening channel to %s' % (sname, tname)) if proxy.only_auth is True: return True, None remote_writer.write( SOCKS5Request.from_target( proxy ).to_bytes() ) await asyncio.wait_for( remote_writer.drain(), timeout=timeout ) rep = await asyncio.wait_for( SOCKS5Reply.from_streamreader(remote_reader), timeout=timeout ) if rep.REP != SOCKS5ReplyType.SUCCEEDED: logger.info('[SOCKS5 %s] remote end failed to connect to proxy! Reson: %s' % (sname, rep.REP.name)) raise SOCKS5ServerErrorReply(rep.REP) if proxy.is_bind is False: logger.debug('[SOCKS5 %s] Successfully set up the connection to the endpoint %s ' % (sname,tname)) return True, None logger.debug('[SOCKS5 %s] BIND first set completed, port %s available!' % (sname , rep.BIND_PORT)) #bind in progress, waiting for a second reply to notify us that the remote endpoint connected back. self.bind_port = rep.BIND_PORT self.bind_progress_evt.set() #notifying that the bind port is now available on the socks server to be used if proxy.only_bind is True: return True, None rep = await asyncio.wait_for( SOCKS5Reply.from_streamreader(remote_reader), timeout=timeout ) if rep.REP != SOCKS5ReplyType.SUCCEEDED: logger.info('[SOCKS5 %s] remote end failed to connect to proxy! Reson: %s' % (sname, rep.REP.name)) raise SOCKS5ServerErrorReply(rep.REP) return True, None except Exception as e: logger.debug('[SOCKS5 %s] Error in run_socks5 %s' % (sname, e)) return False, e async def handle_client(self, reader, writer): remote_writer = None remote_reader = None try: logger.debug('[handle_client] Client connected!') if len(self.proxies) > 1: logger.debug('Start chaining...') for _ in range(3, 0 , -1): #this is for HTTP auth... if remote_writer is not None: remote_writer.close() try: if self.proxies[0].version == SocksServerVersion.WSNET: from asysocks.network.wsnet import WSNETNetwork remote_reader, remote_writer = await WSNETNetwork.open_connection( self.proxies[0].endpoint_ip, self.proxies[0].endpoint_port, self.proxies[0].wsnet_reuse, ) elif self.proxies[0].version in [SocksServerVersion.WSNETWS, SocksServerVersion.WSNETWSS]: from asysocks.network.wsnetws import WSNETNetworkWS remote_reader, remote_writer = await WSNETNetworkWS.open_connection( self.proxies[0].endpoint_ip, self.proxies[0].endpoint_port, self.proxies[0].server_ip, self.proxies[0].server_port, self.proxies[0].version, self.proxies[0].agentid, self.proxies[0].timeout, ) if remote_reader is None: raise remote_writer else: remote_reader, remote_writer = await asyncio.wait_for( asyncio.open_connection( self.proxies[0].server_ip, self.proxies[0].server_port, ssl=self.proxies[0].ssl_ctx, ), timeout = self.proxies[0].timeout ) logger.debug('Connected to socks server!') except: logger.debug('Failed to connect to SOCKS server!') raise try: for i, proxy in enumerate(self.proxies): if proxy.version in [SocksServerVersion.SOCKS4, SocksServerVersion.SOCKS4S]: try: x = await asyncio.wait_for(self.run_socks4(proxy, remote_reader, remote_writer), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.SOCKS4A, SocksServerVersion.SOCKS4AS]: try: x = await asyncio.wait_for(self.run_socks4a(proxy, remote_reader, remote_writer), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.SOCKS5, SocksServerVersion.SOCKS5S]: try: x = await asyncio.wait_for(self.run_socks5(proxy, remote_reader, remote_writer), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.HTTP, SocksServerVersion.HTTPS]: try: x = await asyncio.wait_for(self.run_http(proxy, remote_reader, remote_writer, http_auth_ctx = self.http_auth_ctx), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, self.http_auth_ctx, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.WSNET, SocksServerVersion.WSNETWS, SocksServerVersion.WSNETWSS]: if i != 0: raise Exception("WSNET only supported as the first proxy in chain!") continue else: raise Exception('Unknown SOCKS version!') else: # no need to do more iterations because of HTTP at this point break except HTTPProxyAuthRequiredException: continue except: raise logger.debug('[handle_client] Starting proxy...') self.channel_open_evt.set() self.proxy_stopped_evt = asyncio.Event() self.proxytask_in = asyncio.create_task( SOCKSClient.proxy_stream( reader, remote_writer, self.proxy_stopped_evt , buffer_size = self.proxies[0].buffer_size, timeout = self.proxies[0].endpoint_timeout ) ) self.proxytask_out = asyncio.create_task( SOCKSClient.proxy_stream( remote_reader, writer, self.proxy_stopped_evt, buffer_size = self.proxies[0].buffer_size, timeout = self.proxies[0].endpoint_timeout ) ) logger.debug('[handle_client] Proxy started!') await self.proxy_stopped_evt.wait() logger.debug('[handle_client] Proxy stopped!') self.proxytask_in.cancel() self.proxytask_out.cancel() except Exception as e: logger.exception('[handle_client]') finally: if remote_writer is not None: remote_writer.close() async def handle_queue(self): logger.debug('[queue] Connecting to socks server...') remote_writer = None remote_reader = None if self.bind_progress_evt is None: self.bind_progress_evt = asyncio.Event() try: if len(self.proxies) > 1: logger.debug('Start chaining...') for _ in range(3, 0 , -1): if remote_writer is not None: remote_writer.close() try: if self.proxies[0].version == SocksServerVersion.WSNET: from asysocks.network.wsnet import WSNETNetwork remote_reader, remote_writer = await WSNETNetwork.open_connection( self.proxies[0].endpoint_ip, self.proxies[0].endpoint_port, self.proxies[0].wsnet_reuse, ) elif self.proxies[0].version in [SocksServerVersion.WSNETWS, SocksServerVersion.WSNETWSS]: from asysocks.network.wsnetws import WSNETNetworkWS remote_reader, remote_writer = await WSNETNetworkWS.open_connection( self.proxies[0].endpoint_ip, self.proxies[0].endpoint_port, self.proxies[0].server_ip, self.proxies[0].server_port, self.proxies[0].version, self.proxies[0].agentid, self.proxies[0].timeout, ) if remote_reader is None: raise remote_writer else: remote_reader, remote_writer = await asyncio.wait_for( asyncio.open_connection( self.proxies[0].server_ip, self.proxies[0].server_port ), timeout = self.proxies[0].timeout ) except: logger.debug('Failed to connect to SOCKS server!') raise logger.debug('[queue] Connected to socks server!') try: for i, proxy in enumerate(self.proxies): if proxy.version in [SocksServerVersion.SOCKS4, SocksServerVersion.SOCKS4S]: try: x = await asyncio.wait_for(self.run_socks4(proxy, remote_reader, remote_writer), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('SOCKS4 Connection establishment timeout') _, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.SOCKS4A, SocksServerVersion.SOCKS4S]: try: x = await asyncio.wait_for(self.run_socks4a(proxy, remote_reader, remote_writer), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('SOCKS4A Connection establishment timeout') _, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.SOCKS5, SocksServerVersion.SOCKS5S]: try: x = await asyncio.wait_for(self.run_socks5(proxy, remote_reader, remote_writer), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('SOCKS5 Connection establishment timeout') _, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.HTTP, SocksServerVersion.HTTPS]: try: x = await asyncio.wait_for(self.run_http(proxy, remote_reader, remote_writer, http_auth_ctx = self.http_auth_ctx), timeout=self.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('HTTP Connection establishment timeout') _, self.http_auth_ctx, err = x if err is not None: if len(self.proxies) > 1 and i != len(self.proxies)-1: raise SocksTunnelError(err) raise err continue elif proxy.version in [SocksServerVersion.WSNET, SocksServerVersion.WSNETWS, SocksServerVersion.WSNETWSS]: if i != 0: raise Exception("WSNET only supported as the first proxy in chain!") continue else: raise Exception('Unknown SOCKS version!') else: break except HTTPProxyAuthRequiredException: continue except: raise if self.proxies[-1].only_bind is True: return True, None if self.proxies[-1].only_open is True or self.proxies[-1].only_auth is True: # for auth guessing and connection testing return True, None if self.channel_open_evt is not None: self.channel_open_evt.set() logger.debug('[queue] Starting proxy...') self.proxy_stopped_evt = asyncio.Event() if self.comms.wrap_ssl is False: self.proxytask_in = asyncio.create_task( SOCKSClient.proxy_queue_in( self.comms.in_queue, remote_writer, self.proxy_stopped_evt, buffer_size = self.proxies[-1].buffer_size ) ) self.proxytask_out = asyncio.create_task( SOCKSClient.proxy_queue_out( self.comms.out_queue, remote_reader, self.proxy_stopped_evt, buffer_size = self.proxies[-1].buffer_size, timeout = self.proxies[-1].endpoint_timeout ) ) else: transport_in = asyncio.Queue() transport_out = asyncio.Queue() self.proxytask_in = asyncio.create_task( SOCKSClient.proxy_queue_in( transport_out, remote_writer, self.proxy_stopped_evt, buffer_size = self.proxies[-1].buffer_size ) ) self.proxytask_out = asyncio.create_task( SOCKSClient.proxy_queue_out( transport_in, remote_reader, self.proxy_stopped_evt, buffer_size = self.proxies[-1].buffer_size, timeout = self.proxies[-1].endpoint_timeout ) ) self.ssl_wrapper, err = await SSLWrapper.from_commsettings(self.comms, transport_in, transport_out) if err is not None: raise err await asyncio.wait_for(self.ssl_wrapper.handshake_done_evt.wait(), timeout = self.comms.handshake_timeout) self.proxy_running_evt.set() logger.debug('[queue] Proxy started!') await self.proxy_stopped_evt.wait() logger.debug('[queue] Proxy stopped!') self.proxytask_in.cancel() self.proxytask_out.cancel() return True, None except Exception as e: await self.comms.in_queue.put((None,e)) await self.comms.out_queue.put((None,e)) return False, e finally: self.proxy_running_evt.set() if remote_writer is not None: remote_writer.close() async def run(self, noblock = False): self.proxy_running_evt = asyncio.Event() if isinstance(self.proxies, list) is False and (self.proxies.is_bind is True and self.bind_progress_evt is None): self.bind_progress_evt = asyncio.Event() if self.channel_open_evt is None: self.channel_open_evt = asyncio.Event() if self.comms.mode == SocksCommsMode.LISTENER: server = await asyncio.start_server( self.handle_client, self.comms.listen_ip, self.comms.listen_port, ) logger.debug('[PROXY] Awaiting server task now...') self.proxy_running_evt.set() if noblock is False: await server.serve_forever() return server.serve_forever() else: if noblock is False: await self.handle_queue() else: return self.handle_queue() ././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1663279247.797629 asysocks-0.2.2/asysocks/common/0000755000000000000000000000000014310720220015226 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/common/__init__.py0000664000000000000000000000000014136501636017345 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/common/aiowrappers.py0000664000000000000000000000343414136501636020160 0ustar00rootrootimport asyncio async def readexactly_or_exc(reader, n, timeout = None): """ Helper function to read exactly N amount of data from the wire. :param reader: The reader object :type reader: asyncio.StreamReader :param n: The maximum amount of bytes to read. :type n: int :param timeout: Time in seconds to wait for the reader to return data :type timeout: int :return: bytearray """ temp = await asyncio.gather(*[asyncio.wait_for(reader.readexactly(n), timeout = timeout)], return_exceptions=True) if isinstance(temp[0], bytes): return temp[0] else: raise temp[0] async def read_or_exc(reader, n, timeout = None): """ Helper function to read N amount of data from the wire. :param reader: The reader object :type reader: asyncio.StreamReader :param n: The maximum amount of bytes to read. BEWARE: this only sets an upper limit of the data to be read :type n: int :param timeout: Time in seconds to wait for the reader to return data :type timeout: int :return: bytearray """ temp = await asyncio.gather(*[asyncio.wait_for(reader.read(n), timeout = timeout)], return_exceptions=True) if isinstance(temp[0], bytes): return temp[0] else: raise temp[0] async def readuntil_or_exc(reader, separator = b'\n', timeout = None): """ Helper function to read stream until separator is hit. :param reader: The reader object :type reader: asyncio.StreamReader :param n: The maximum amount of bytes to read. BEWARE: this only sets an upper limit of the data to be read :type n: int :param timeout: Time in seconds to wait for the reader to return data :type timeout: int :return: bytearray """ temp = await asyncio.gather(*[asyncio.wait_for(reader.readuntil(separator), timeout = timeout)], return_exceptions=True) if isinstance(temp[0], bytes): return temp[0] else: raise temp[0]././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285557.0 asysocks-0.2.2/asysocks/common/clienturl.py0000664000000000000000000001670214213712465017627 0ustar00rootroot from urllib.parse import urlparse, parse_qs import ssl from asysocks.common.credentials import SocksCredential from asysocks.common.constants import SocksServerVersion, SocksProtocol, SOCKS5Method from asysocks.common.target import SocksTarget def stru(x): return str(x).upper() clienturl_param2var = { 'type' : ('version', [stru, SocksServerVersion]), 'host' : ('server_ip', [str]), 'server' : ('server_ip', [str]), 'port' : ('server_port', [int]), 'bind' : ('is_bind', [bool]), 'proto': ('proto', [SocksProtocol]), 'timeout': ('timeout', [int]), 'etimeout' : ('endpoint_timeout', [int]), 'bsize' : ('buffer_size', [int]), 'user' : ('username', [str]), 'pass' : ('password', [str]), 'authtype' : ('authtype', [SOCKS5Method]), 'userid' : ('userid', [str]), 'agentid' : ('agentid', [str]), } clienturl_url2var = { 'isbind' : ('is_bind', bool), 'proto' : ('proto', SocksProtocol), 'timeout' : ('endpoint_timeout', int), 'buffersize' : ('buffer_size', int), 'userid' : ('userid', str), 'agentid' : ('agentid', str), } sockssslversions = { SocksServerVersion.SOCKS5S : 1, SocksServerVersion.SOCKS4S : 1, SocksServerVersion.HTTPS : 1, } class SocksClientURL: def __init__(self): self.version = None self.server_ip = None self.server_port = 1080 self.is_bind = False self.proto = SocksProtocol.TCP self.timeout = 10 self.buffer_size = 4096 self.ssl_ctx = None self.wsnet_reuse = False self.endpoint_ip = None self.endpoint_port = None self.endpoint_timeout = None self.username = None self.password = None self.agentid = None def get_creds(self): if self.username is None: return None creds = SocksCredential() creds.username = self.username creds.password = self.password return creds def get_target(self): target = SocksTarget() target.version = self.version target.server_ip = self.server_ip target.server_port = self.server_port target.is_bind = self.is_bind target.proto = self.proto target.timeout = self.timeout target.buffer_size = self.buffer_size target.endpoint_ip = self.endpoint_ip target.endpoint_port = self.endpoint_port target.endpoint_timeout = self.endpoint_timeout target.ssl_ctx = self.ssl_ctx target.credential = self.get_creds() target.agentid = self.agentid target.wsnet_reuse = self.wsnet_reuse return target def sanity_check(self): if self.version != SocksServerVersion.WSNET: if self.server_ip is None: raise Exception('SOCKS server IP is missing!') if self.server_port is None: raise Exception('SOCKS server port is missing!') if self.buffer_size <= 0: raise Exception('buffer_size is too low! %s' % self.buffer_size) if self.endpoint_ip is None: raise Exception('Endpoint IP address is missing!') #if self.endpoint_port is None: # raise Exception('Endpoint port is missing!') @staticmethod def from_urls(urls, endpoint_ip = None, endpoint_port = None): proxylist = [] first = True prevtarget = None for url in urls[::-1]: res = SocksClientURL.from_url(url).get_target() if first is True: res.endpoint_ip = endpoint_ip res.endpoint_port = endpoint_port first = False else: res.endpoint_ip = prevtarget.server_ip res.endpoint_port = prevtarget.server_port prevtarget = res proxylist.append(res) return proxylist[::-1] @staticmethod def from_url(url_str): res = SocksClientURL() url_e = urlparse(url_str) res.version = SocksServerVersion(url_e.scheme.upper()) res.server_ip = url_e.hostname if url_e.port is not None: res.server_port = int(url_e.port) elif res.version == SocksServerVersion.HTTP: res.server_port = 8080 elif res.version == SocksServerVersion.HTTPS: res.server_port = 8443 elif res.version == SocksServerVersion.SOCKS5: res.server_port = 1080 elif res.version == SocksServerVersion.SOCKS5S: res.server_port = 1080 elif res.version == SocksServerVersion.SOCKS4: res.server_port = 1080 elif res.version == SocksServerVersion.SOCKS4S: res.server_port = 1080 elif res.version == SocksServerVersion.SOCKS4A: res.server_port = 1080 elif res.version == SocksServerVersion.SOCKS4AS: res.server_port = 1080 elif res.version == SocksServerVersion.WSNET: res.server_port = None res.username = url_e.username res.password = url_e.password if res.version in sockssslversions: res.ssl_ctx = ssl.create_default_context() #print(url_e) if url_e.query is not None: query = parse_qs(url_e.query) for k in query: if k in clienturl_url2var: pname = clienturl_url2var[k][0] param = clienturl_url2var[k][1](query[k][0]) setattr(res, pname, param) return res @staticmethod def from_params(url_str): """ """ lastproxy = SocksClientURL() url = urlparse(url_str) lastproxy.endpoint_ip = url.hostname if url.port: lastproxy.endpoint_port = int(url.port) if url.query is not None: query = parse_qs(url.query) proxycounts = [0] proxynums = {'0' : None} for k in query: if k.startswith('proxy'): try: int(k[5]) if k[5] not in proxynums: proxynums[k[5]] = None proxycounts.append(int(k[5])) except Exception as e: #print(e) pass #print(proxynums) #print(proxycounts) if len(proxycounts) != len(proxynums): raise Exception('proxyies are not in sequential order! ERROR!') proxycounts.sort() firstiter = True prevproxy = lastproxy for i in proxycounts[::-1]: pdata = SocksClientURL() if firstiter is True: firstiter = False pdata = lastproxy else: pdata.endpoint_ip = prevproxy.server_ip pdata.endpoint_port = prevproxy.server_port prevproxy = pdata startstring = 'proxy%s' % i if i == 0: startstring = 'proxy' for k in query: if k.startswith(startstring): startpos = 6 if i == 0: startpos = 5 if k[startpos:] in clienturl_param2var: data = query[k][0] for c in clienturl_param2var[k[startpos:]][1]: #print(c) data = c(data) setattr( pdata, clienturl_param2var[k[startpos:]][0], data ) proxynums[str(i)] = pdata if len(proxynums) > 1: for k in proxynums: if proxynums[k].version in sockssslversions: raise Exception('SSL in proxy chaining not supported! That would be a lot of work...') else: if proxynums['0'].version in sockssslversions: proxynums['0'].ssl_ctx = ssl.create_default_context() for k in proxynums: proxynums[k].sanity_check() targets = [] for i in proxycounts: targets.append(proxynums[str(i)].get_target()) return targets if __name__ == '__main__': url = 'http://alma.com:80/haha?proxytype=socks5&proxyport=66&proxyhost=127.0.0.1' url = 'http://alma.com:80/haha?proxytype=socks5&proxyport=66&proxyhost=127.0.0.1&proxy1type=socks4&proxy1port=9876&proxy1host=255.255.0.0' #url = 'http://alma.com:80/haha?proxytype=socks5&proxyport=66&proxyhost=127.0.0.1&proxy2type=socks4&proxy2port=9876&proxy2host=255.255.0.0' #url = 'http://alma.com:80/haha?proxytype=socks5&proxyport=66&proxyhost=127.0.0.1&proxy2type=socks4&proxy2port=9876&proxy2host=255.255.0.0&proxy1type=socks5s&proxy1port=6666&proxy1host=127.255.0.0' url = 'http://alma.com:80/haha?proxytype=socks5&proxyport=66&proxyhost=127.0.0.1&proxy2type=socks4&proxy2port=9876&proxy2host=255.255.0.0&proxy1type=socks5&proxy1port=6666&proxy1host=127.255.0.0' o = urlparse(url) res = SocksClientURL.from_params(url) print('aaaaaaaaaaaaaaaaaaaa') for target in res: print(target.__dict__) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/common/comms.py0000664000000000000000000000126614136501636016743 0ustar00rootroot from asysocks.common.constants import SocksCommsMode class SocksComms: def __init__(self): self.mode = None class SocksQueueComms(SocksComms): def __init__(self, in_queue, out_queue, wrap_ssl = False, ssl_ctx = None, handshake_timeout = 10): super(SocksComms) self.mode = SocksCommsMode.QUEUE self.in_queue = in_queue self.out_queue = out_queue # wrap endpoint SSL connection self.wrap_ssl = wrap_ssl self.ssl_ctx = ssl_ctx self.handshake_timeout = handshake_timeout class SocksLitenerComms(SocksComms): def __init__(self, listen_ip, listen_port): super(SocksComms) self.mode = SocksCommsMode.LISTENER self.listen_ip = listen_ip self.listen_port = listen_port././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/common/constants.py0000664000000000000000000000110214136501636017626 0ustar00rootrootimport enum class SocksServerVersion(enum.Enum): SOCKS4 = 'SOCKS4' SOCKS4A = 'SOCKS4A' SOCKS4AS = 'SOCKS4AS' SOCKS5 = 'SOCKS5' SOCKS5S = 'SOCKS5S' SOCKS4S = 'SOCKS4S' HTTP = 'HTTP' HTTPS = 'HTTPS' WSNET = 'WSNET' WSNETWS = 'WSNETWS' WSNETWSS = 'WSNETWSS' class SocksProtocol(enum.Enum): TCP = 'TCP' UDP = 'UDP' class SocksCommsMode(enum.Enum): LISTENER = 'LISTENER' QUEUE = 'QUEUE' class SOCKS5Method(enum.Enum): NOAUTH = 0x00 GSSAPI = 0x01 PLAIN = 0x02 # IANA ASSIGNED X'03' to X'7F' # RESERVED FOR PRIVATE METHODS X'80' to X'FE' NOTACCEPTABLE = 0xFF././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/common/credentials.py0000664000000000000000000000013414136501636020113 0ustar00rootroot class SocksCredential: def __init__(self): self.username = None self.password = None././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1643396187.0 asysocks-0.2.2/asysocks/common/target.py0000664000000000000000000000213114175036133017101 0ustar00rootroot import os from urllib.parse import urlparse, parse_qs from asysocks.common.constants import SocksServerVersion, SocksProtocol class SocksTarget: def __init__(self): self.version = None self.server_ip = None self.server_port = None self.is_bind = False self.proto = SocksProtocol.TCP self.timeout = 10 #used to create the connection self.buffer_size = 4096 self.ssl_ctx = None self.userid = os.urandom(4).hex().encode('ascii') self.agentid = None self.wsnet_reuse = False self.endpoint_ip = None self.endpoint_port = None self.endpoint_timeout = None #used after the connection is made self.credential = None self.only_open = False #These params used for security testing only! self.only_auth = False #These params used for security testing only! self.only_bind = False #These params used for security testing only! def get_sname(self): return '%s:%s' % (self.server_ip, self.server_port) def get_tname(self): return '%s:%s' % (self.endpoint_ip, self.endpoint_port) def __repr__(self): return str(self.__dict__) def __str__(self): return repr(self) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/common/trafficlog.py0000664000000000000000000000144114136501636017740 0ustar00rootroot class TrafficLog: def __init__(self): self.client_ip = None self.client_port = None self.destination_ip = None self.destination_hostname = None self.destination_port = None self.session_id = None self.direction = None self.module = None self.srv_module = None self.is_ssl = False self.data = None def get_dst_hostname(self): if self.destination_hostname is None: return self.destination_ip return self.destination_hostname def get_header(self): return '[%s][%s][%s][%s:%s %s %s:%s] ' % ( self.srv_module, self.module, self.session_id, self.client_ip, self.client_port, '->' if self.direction.startswith('c2d') else '<-', self.get_dst_hostname(), self.destination_port ) def __str__(self): return self.get_header() + str(self.data)././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8096292 asysocks-0.2.2/asysocks/examples/0000755000000000000000000000000014310720220015554 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/examples/__init__.py0000664000000000000000000000000014136501636017673 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/examples/socksbrute.py0000664000000000000000000002124214136501636020333 0ustar00rootroot import asyncio import logging import traceback import copy from asysocks import logger from asysocks._version import __banner__ from asysocks.protocol.http import HTTPProxyAuthFailed from asysocks.protocol.socks5 import SOCKS5AuthFailed from asysocks.client import SOCKSClient, SocksTunnelError from asysocks.common.credentials import SocksCredential from asysocks.common.comms import SocksQueueComms from asysocks.protocol.socks5 import SOCKS5Method, SOCKS5Nego, SOCKS5NegoReply, SOCKS5Request, SOCKS5Reply, SOCKS5ReplyType, SOCKS5Command, SOCKS5PlainAuth, SOCKS5PlainAuthReply, SOCKS5ServerErrorReply from asysocks.common.clienturl import SocksClientURL class FileStringGen: """ Parses a file line by line """ def __init__(self, filename): self.filename = filename async def run(self, target_q): try: cnt = 0 with open(self.filename, 'r') as f: for line in f: line = line.strip() if line == '': continue await target_q.put(line) await asyncio.sleep(0) cnt += 1 return cnt, None except Exception as e: return cnt, e class ListStringGen: def __init__(self, targets): self.targets = targets async def run(self, target_q): try: cnt = 0 for target in self.targets: await target_q.put(target) await asyncio.sleep(0) cnt += 1 return cnt, None except Exception as e: return cnt, e class SOCKSBrute: def __init__(self, proxies): self.proxies = proxies self.user_gens = [] self.password_gens = [] self.passwords = {} self.worker_cnt = 100 self.timeout = 1 self.max_retries = 5 self.retries_sleep = 1 self.verify_target = '8.8.8.8' self.verify_port = 53 self.output_file = None self.only_positive = False self.__worker_tasks = [] self.__addr_queue = None self.__target_queue = None self.__result_queue = None self.__total_addrs = 0 self.__total_targets = 0 self.__total_finished = 0 async def __scanner(self): try: while True: try: temp = await self.__target_queue.get() if temp is None: return username, password, client = temp retries = self.max_retries while retries != 0: if retries != self.max_retries: await asyncio.sleep(self.retries_sleep) retries -= 1 _, err = await client.handle_queue() if err is not None: if isinstance(err, (HTTPProxyAuthFailed, SOCKS5AuthFailed)): await self.__result_queue.put((username, password, False, None)) break elif isinstance(err, SocksTunnelError): logger.debug('Tunnel setup failed!. Reason %s' % traceback.format_tb(err.__traceback__)) elif isinstance(err, OSError): logger.debug('Failed socket connection to initial proxy!. Reason %s' % traceback.format_tb(err.__traceback__)) continue await self.__result_queue.put((username, password, True, None)) break if retries == 0: await self.__result_queue.put((username, password, None, err)) except asyncio.CancelledError: return except Exception as e: pass except asyncio.CancelledError: return except Exception as e: print(e) 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 proxies = copy.deepcopy(self.proxies) proxies[-1].only_open = True proxies[-1].only_auth = True proxies[-1].endpoint_ip = self.verify_target proxies[-1].endpoint_port = self.verify_port proxies[-1].credential = credential in_q = asyncio.Queue() out_q = asyncio.Queue() comms = SocksQueueComms(in_q, out_q) client = SOCKSClient(comms, proxies) await self.__target_queue.put((user, password, client)) self.__target_gen_finished_evt.set() except Exception as e: print(e) async def __gen_users(self): try: for user_gen in self.user_gens: cnt, err = await user_gen.run(self.__users_queue) if err is not None: print(err) self.__total_addrs += cnt await self.__users_queue.put(None) except Exception as e: print(e) async def __gen_passwords(self): try: for password_gen in self.password_gens: cnt, err = await password_gen.run(self.__passwords_queue) if err is not None: print(err) self.__total_addrs += cnt await self.__passwords_queue.put(None) except Exception as e: print(e) async def run(self): try: self.__passwords_queue = asyncio.Queue() self.__users_queue = asyncio.Queue() self.__target_queue = asyncio.Queue(self.worker_cnt) self.__result_queue = asyncio.Queue() self.__target_gen_finished_evt = asyncio.Event() asyncio.create_task(self.__gen_passwords()) asyncio.create_task(self.__gen_users()) asyncio.create_task(self.__gen_targets()) for _ in range(self.worker_cnt): self.__worker_tasks.append(asyncio.create_task(self.__scanner())) outfile = None if self.output_file is not None: outfile = open(self.output_file, 'w', newline = '') while True: username, password, status, err = await self.__result_queue.get() self.__total_finished += 1 if err is not None: print(err) print(traceback.format_tb(err.__traceback__)) if err is None: if outfile is not None: outfile.write('%s:%s\r\n' % (username, password)) elif status is True: print('%s:%s -> %s' % (username, password, status)) elif self.only_positive is False: print('%s:%s -> %s' % (username, password, status)) else: if self.only_positive is False: print('%s:%s -> %s' % (username, password, status)) if self.__target_gen_finished_evt.is_set() is True: if self.__total_finished == self.__total_targets: break for _ in range(len(self.__worker_tasks)): await self.__target_queue.put(None) for worker in self.__worker_tasks: worker.cancel() return True, None except Exception as e: return False, e def main(): import argparse parser = argparse.ArgumentParser(description='SOCKS5 proxy auth bruteforcer') parser.add_argument('-u', '--users', action='append', help='User or users file with one user per line. can be stacked') parser.add_argument('-p', '--passwords', action='append', help='Password or password file with one password per line. can be stacked') parser.add_argument('-t', '--timeout', type = int, default = None, help='Brute retries sleep time') parser.add_argument('-w', '--worker-count', type = int, default = 1, help='Parallelism') parser.add_argument('-v', '--verbose', action='count', default=0, help='Verbosity') parser.add_argument('-s', '--silent', action='store_true', help = 'dont print banner') parser.add_argument('-o', '--out-file', help = 'output file') parser.add_argument('--positive', action='store_true', help = 'only show sucsessful results') parser.add_argument('proxies', nargs='*', help='connection string(s) of the target proxy. if you want a chain of proxies to use before reaching the target then supply the chain in order, the target must be the LAST OF THE URLS!!!') args = parser.parse_args() if args.silent is False: print(__banner__) logger.setLevel(100) if args.verbose >=1: logger.setLevel(logging.DEBUG) elif args.verbose > 2: logger.setLevel(1) proxychain = SocksClientURL.from_urls(args.proxies) brute = SOCKSBrute(proxychain) brute.timeout = args.timeout brute.worker_cnt = args.worker_count brute.output_file = args.out_file brute.only_positive = args.positive if args.users is None or args.passwords is None: print('Users "-u" and Passwords "-p" must be set! Exiting') return notfile = [] for target in args.users: try: f = open(target, 'r') f.close() brute.user_gens.append(FileStringGen(target)) except: notfile.append(target) if len(notfile) > 0: brute.user_gens.append(ListStringGen(notfile)) if len(brute.user_gens) == 0: print('[-] No suitable users were found!') return notfile = [] for target in args.passwords: try: f = open(target, 'r') f.close() brute.password_gens.append(FileStringGen(target)) except: notfile.append(target) if len(notfile) > 0: brute.password_gens.append(ListStringGen(notfile)) if len(brute.password_gens) == 0: print('[-] No suitable passwords were found!') return _, err = asyncio.run(brute.run()) if err is not None: print('Failed to perform bruting! Reason: %s' % err) return if args.silent is False: print('Done!') if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/examples/socksportscan.py0000664000000000000000000002121414136501636021042 0ustar00rootroot import asyncio import ipaddress import logging import copy from asysocks import logger from asysocks.client import SOCKSClient from asysocks.common.comms import SocksQueueComms from asysocks.protocol.socks5 import SOCKS5Method, SOCKS5Nego, SOCKS5NegoReply, SOCKS5Request, SOCKS5Reply, SOCKS5ReplyType, SOCKS5Command, SOCKS5PlainAuth, SOCKS5PlainAuthReply, SOCKS5ServerErrorReply from asysocks.common.clienturl import SocksClientURL class FileTargetPortGen: def __init__(self, filename): self.filename = filename async def run(self, target_q): try: cnt = 0 with open(self.filename, 'r') as f: for line in f: line = line.strip() if line == '': continue if line.find('-') != -1: start, end = line.split('-') for i in range(int(start), int(end)): await target_q.put(i) await asyncio.sleep(0) cnt += 1 else: try: line = int(line) await target_q.put(line) await asyncio.sleep(0) cnt += 1 except: pass return cnt, None except Exception as e: return cnt, e class FileTargetIPGen: """ Parses a file line by line looking for ip address or ipaddres range or hostname """ def __init__(self, filename): self.filename = filename async def run(self, target_q): try: cnt = 0 with open(self.filename, 'r') as f: for line in f: line = line.strip() if line == '': continue try: ipaddress.ip_address(line) await target_q.put(line) await asyncio.sleep(0) cnt += 1 continue except: pass try: for ipaddr in ipaddress.ip_network(line,strict=False): await target_q.put(str(ipaddr)) await asyncio.sleep(0) cnt += 1 continue except: pass await target_q.put(line) await asyncio.sleep(0) cnt += 1 return cnt, None except Exception as e: return cnt, e class ListTargetIPGen: def __init__(self, targets): self.targets = targets async def run(self, target_q): try: cnt = 0 for target in self.targets: try: ipaddress.ip_address(target) await target_q.put(target) await asyncio.sleep(0) cnt += 1 continue except: pass try: for ipaddr in ipaddress.ip_network(target,strict=False): await target_q.put(str(ipaddr)) await asyncio.sleep(0) cnt += 1 continue except: pass await target_q.put(target) await asyncio.sleep(0) cnt += 1 return cnt, None except Exception as e: return cnt, e class ListTargetPortGen: def __init__(self, targets): self.targets = targets self.ports = {} def run(self): try: for target in self.targets: if target.find('-') != -1: start, end = target.split('-') for i in range(int(start), int(end)): self.ports[i] = 1 else: try: target = int(target) self.ports[target] = 1 except: pass return self.ports except Exception as e: return e class SOCKSPortscan: def __init__(self, proxyies): self.proxyies = proxyies self.target_gens = [] self.port_gens = [] self.ports = {} self.worker_cnt = 10 self.max_retries = 1 self.retries_timeout = 1 self.__worker_tasks = [] self.__addr_queue = None self.__target_queue = None self.__result_queue = None self.__total_addrs = 0 self.__total_targets = 0 self.__total_finished = 0 self.__addr_gen_finished_evt = None async def __scanner(self): try: while True: try: temp = await self.__target_queue.get() if temp is None: return ip, port, client = temp retries = self.max_retries while retries != 0: if retries != self.max_retries: await asyncio.sleep(self.retries_timeout) retries -= 1 _, 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]: await self.__result_queue.put((ip, port, False, None)) elif err.reply in [SOCKS5ReplyType.ADDRESS_TYPE_NOT_SUPPORTED]: await self.__result_queue.put((ip, port, None, err)) break continue await self.__result_queue.put((ip, port, True, None)) break if retries == 0: await self.__result_queue.put((ip, port, None, Exception('Max tries reached!'))) except asyncio.CancelledError: return except Exception as e: print(e) pass except asyncio.CancelledError: return except Exception as e: print(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 for port in self.ports: self.__total_targets += 1 proxyies = copy.deepcopy(self.proxyies) proxyies[-1].endpoint_ip = addr proxyies[-1].endpoint_port = port proxyies[-1].timeout = None proxyies[-1].only_open = True in_q = asyncio.Queue() out_q = asyncio.Queue() comms = SocksQueueComms(in_q, out_q) client = SOCKSClient(comms, proxyies) await self.__target_queue.put((addr, port, client)) self.__target_gen_finished_evt.set() except Exception as e: print(e) async def __gen_addrs(self): try: for target_gen in self.target_gens: cnt, err = await target_gen.run(self.__addr_queue) if err is not None: print(err) self.__total_addrs += cnt await self.__addr_queue.put(None) self.__addr_gen_finished_evt.set() except Exception as e: print(e) async def run(self): try: self.__addr_queue = asyncio.Queue() self.__target_queue = asyncio.Queue() self.__result_queue = asyncio.Queue() self.__addr_gen_finished_evt = asyncio.Event() self.__target_gen_finished_evt = asyncio.Event() asyncio.create_task(self.__gen_addrs()) asyncio.create_task(self.__gen_targets()) for _ in range(self.worker_cnt): self.__worker_tasks.append(asyncio.create_task(self.__scanner())) while True: ip, port, status, err = await self.__result_queue.get() self.__total_finished += 1 if status is True: print('%s:%s -> %s' % (ip, port, status)) if self.__target_gen_finished_evt.is_set() is True: if self.__total_finished == self.__total_targets: print('END!') print(self.__total_finished) print(self.__total_targets) break for _ in range(len(self.__worker_tasks)): await self.__target_queue.put(None) for worker in self.__worker_tasks: worker.cancel() except Exception as e: print(e) def main(): import argparse parser = argparse.ArgumentParser(description='SOCKS/HTTP proxy port scanner') parser.add_argument('-p', '--port', action='append', required= True, help='port to scan / port range to scan / port range file. can be stacked') parser.add_argument('--timeout', type = int, default = None, help='Scan retries sleep time') parser.add_argument('-r', '--retries', type = int, default = 1, help='Retries for testing the port') parser.add_argument('-w', '--worker-count', type = int, default = 1, help='Parallelism') parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('-t', '--target', action='append', required=True, help='IP address / IP range (CDIR) / targets file') parser.add_argument('proxies', nargs='*', help='connection string(s) of the target proxy. if you want a chain of proxies') args = parser.parse_args() logger.setLevel(100) if args.verbose >=1: logger.setLevel(logging.DEBUG) elif args.verbose > 2: logger.setLevel(1) proxychain = SocksClientURL.from_urls(args.proxies) scanner = SOCKSPortscan(proxychain) scanner.max_retries = args.retries scanner.retries_timeout = args.timeout scanner.worker_cnt = args.worker_count notfile = [] for target in args.target: try: f = open(target, 'r') f.close() scanner.target_gens.append(FileTargetIPGen(target)) except: notfile.append(target) if len(notfile) > 0: scanner.target_gens.append(ListTargetIPGen(notfile)) if len(scanner.target_gens) == 0: print('[-] No suitable targets were found!') return notfile = [] for target in args.port: try: f = open(target, 'r') f.close() scanner.port_gens.append(FileTargetPortGen(target)) except: notfile.append(target) if len(notfile) > 0: scanner.port_gens.append(ListTargetPortGen(notfile)) if len(scanner.port_gens) == 0: print('[-] No suitable ports were found!') return asyncio.run(scanner.run()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285563.0 asysocks-0.2.2/asysocks/examples/socksproxy.py0000664000000000000000000000453714213712473020402 0ustar00rootroot import asyncio import logging import ssl from asysocks.server import SOCKSServer, srvlogger from asysocks._version import __banner__ async def amain(): try: import argparse parser = argparse.ArgumentParser(description='Universal proxy server (SOCKS4/5 and HTTP proxy') parser.add_argument('--listen-ip', default = '127.0.0.1', help='Listen IP') parser.add_argument('--listen-port', type = int, default = 1080, help='Listen port') parser.add_argument('--cert', help='SSL certificate file') parser.add_argument('--key', help='SSL key file') parser.add_argument('--client-timeout', type=int, default=10, help='How much time to wait ftill the client finishes initial handshake') parser.add_argument('--buffer-size', type=int, default=10240, help='Proxy buffer size') parser.add_argument('-m', '--monitor', action='store_true', help='Monitor mode.') parser.add_argument('-v', '--verbose', action='count', default=0, help='Verbosity') parser.add_argument('-s', '--silent', action='store_true', help = 'dont print banner') args = parser.parse_args() if args.silent is False: print(__banner__) if args.verbose >=1: srvlogger.setLevel(logging.DEBUG) ssl_ctx = None client_timeout = args.client_timeout buffer_size = args.buffer_size supported_protocols = ['SOCKS4','SOCKS5', 'HTTP'] monitor_dispatch_q = None if args.cert is not None: ssl_ctx = ssl.SSLContext() ssl_ctx.load_cert_chain(args.cert, keyfile=args.key) if args.monitor is True: from asysocks.intercepting.server import InterceptServer from asysocks.certmanager import CertManager certmanager = CertManager() log_queue = asyncio.Queue() server = SOCKSServer( args.listen_ip, args.listen_port, ssl_ctx, client_timeout = client_timeout, buffer_size = buffer_size, supported_protocols = supported_protocols ) if args.monitor is True: server = InterceptServer(server, certmanager, log_queue) asyncio.create_task(server.run()) if args.silent is False: print('Proxy server is up and running on %s:%s %s' % (args.listen_ip, args.listen_port, '' if ssl_ctx is None else '(SSL)')) if args.monitor is True: while True: trafficlog = await log_queue.get() print(str(trafficlog)) else: await server.run() except Exception as e: print(e) def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285570.0 asysocks-0.2.2/asysocks/examples/sockssec.py0000664000000000000000000000742514213712502017763 0ustar00rootroot import asyncio import logging import traceback import ssl from asysocks import logger from asysocks._version import __banner__ from asysocks.security import SocksSecurity def main(): import argparse parser = argparse.ArgumentParser(description='SOCKS5 proxy security tester') parser.add_argument('host', help='') parser.add_argument('port', help='') parser.add_argument('-t', '--timeout', type = int, default = None, help='Timeout') parser.add_argument('-v', '--verbose', action='count', default=0, help='Verbosity') parser.add_argument('--ssl', action='store_true', help='SSL') parser.add_argument('-s', '--silent', action='store_true', help='SSL') parser.add_argument('--verify-host', help='Destination host to test proxy on') parser.add_argument('--verify-port', type = int, help='Destination port to test proxy on') parser.add_argument('--verify-send', help='Data to send to destination to test the proxy') parser.add_argument('--verify-recv', help='Data expected to be recieved from the destination via proxy') parser.add_argument('-u', '--username', help='Username for proxy auth') parser.add_argument('-p', '--password', help='Password for proxy auth') args = parser.parse_args() if args.silent is False: print(__banner__) logger.setLevel(100) if args.verbose >=1: logger.setLevel(logging.DEBUG) elif args.verbose > 2: logger.setLevel(1) socsec = SocksSecurity() socsec.server_ip = args.host socsec.server_port = args.port socsec.server_sslctx = None if args.ssl is False else ssl.create_default_context() socsec.timeout = args.timeout socsec.verify_host = args.verify_host #endpoint ip/hostname to test the connection socsec.verify_port = args.verify_port #endpoint port socsec.verify_send = args.verify_send #data to be sent to the endpoint service upon succsessfull connection socsec.verify_recv = args.verify_recv #data expected from the endpoint service in response to verify_send supported, notsupported, errors = asyncio.run(socsec.socks5_authmethods()) for method, err in errors: print('[AUTHMETHOD][E] %s : %s' % (method.name, err)) for method in supported: print('[AUTHMETHOD][+] %s' % method.name) for method in notsupported: print('[AUTHMETHOD][-] %s' % method.name) res, err = asyncio.run(socsec.socks5_noauth()) if err is not None: print('[NOAUTH][E] Error while determining noauth. Reson: %s' % err) elif res is True: print('[NOAUTH][+] No authentication needed') elif res is False: print('[NOAUTH][-] Authentication needed') res, err = asyncio.run(socsec.socks5_bind(args.username, args.password)) if err is not None: print('[BIND][E] Error while determining BIND support. Reson: %s' % err) elif res is True: print('[BIND][+] Server supports BIND') elif res is False: print('[BIND][-] Server doesnt support BIND') res, err = asyncio.run(socsec.socks5_local(args.username, args.password)) if err is not None: print('[LOCALPORT][E] Error while determining local connect support. Reson: %s' % err) elif res is True: print('[LOCALPORT][+] Server supports connecting to localhost') elif res is False: print('[LOCALPORT][-] Server doesnt support connecting to localhost') if args.verify_host is not None and args.verify_port is not None: if args.username is not None: res, err = asyncio.run(socsec.socks5_login(args.username, args.password)) else: res, err = asyncio.run(socsec.socks5_noauth()) if err is not None: print('[CONNTEST][E] Error while performing connection test! Reason: %s' % err) elif res is True: print('[CONNTEST][+] Server sucsessfully connected to %s:%s' % (args.verify_host, args.verify_port)) elif res is False: print('[CONNTEST][-] Server failed to connect to %s:%s' % (args.verify_host, args.verify_port)) if args.silent is False: print('Done!') if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/examples/sockstunnel.py0000664000000000000000000000457514136501636020531 0ustar00rootroot import logging import asyncio from asysocks import logger from asysocks._version import __banner__ from asysocks.client import SOCKSClient from asysocks.common.clienturl import SocksClientURL from asysocks.common.comms import SocksLitenerComms def main(): import argparse parser = argparse.ArgumentParser(description='Transparent TCP tunnel for SOCKS unaware clients.') parser.add_argument('-l', '--listen-ip', default = '127.0.0.1', help='Listener IP address to bind to') parser.add_argument('-p', '--listen-port', type = int, default = 11111, help='Listener port number to bind to') parser.add_argument('-t', '--timeout', type = int, default = None, help='Endpoint timeout') parser.add_argument('-v', '--verbose', action='count', default=0) parser.add_argument('dst_ip', help='IP address of the desination server') parser.add_argument('dst_port', type = int, help='port number of the desination service') parser.add_argument('proxy_connection_strings', nargs='*', help='connection string(s) decribing the socks proxy server connection properties') args = parser.parse_args() if args.verbose >=1: logger.setLevel(logging.DEBUG) elif args.verbose > 2: logger.setLevel(1) comms = SocksLitenerComms(args.listen_ip, args.listen_port) prev_url = None proxies = [] for con_str in args.proxy_connection_strings[::-1]: url = SocksClientURL.from_url(con_str) if prev_url is None: url.endpoint_ip = args.dst_ip url.endpoint_port = args.dst_port url.endpoint_timeout = args.timeout else: prev_target = prev_url.get_target() url.endpoint_ip = prev_target.server_ip url.endpoint_port = prev_target.server_port url.endpoint_timeout = args.timeout prev_url = url proxies.append(url) proxies = proxies[::-1] targets = [ x.get_target() for x in proxies] credentials = None if args.verbose >=1: print(str(targets)) print(__banner__) tunnel = '' for target in targets: tunnel += "|--->| (%s) %s:%s " % (target.version.name.upper() ,target.server_ip, target.server_port) print(tunnel) layout = """Connection layout CLIENT --->| CLIENT --->|(LISTENER) %s:%s %s |--->| (FINAL DST) %s:%s CLIENT --->| """ % (args.listen_ip, args.listen_port, tunnel , args.dst_ip, args.dst_port) print(layout) client = SOCKSClient(comms, targets, credentials) print('Waiting for incoming connections') asyncio.run(client.run()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8096292 asysocks-0.2.2/asysocks/intercepting/0000755000000000000000000000000014310720220016431 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/intercepting/__init__.py0000664000000000000000000000000014136501636020550 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/intercepting/default_intercept_table.py0000664000000000000000000000061514136501636023675 0ustar00rootroot import json from asysocks.intercepting.target import InterceptTarget default_table_data = json.loads(""" [ { "dsthost" : ".*", "dstport" : 443, "proto" : "http", "ssl" : true }, { "dsthost" : ".*", "dstport" : 80, "proto" : "http", "ssl" : false } ] """) default_intercept_table = [] for x in default_table_data: default_intercept_table.append(InterceptTarget.from_dict(x))././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8136292 asysocks-0.2.2/asysocks/intercepting/monitors/0000755000000000000000000000000014310720220020303 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/intercepting/monitors/__init__.py0000664000000000000000000000044614136501636022440 0ustar00rootroot from asysocks.intercepting.monitors.base import BaseMonitor from asysocks.intercepting.monitors.sslbase import SSLBaseMonitor from asysocks.intercepting.monitors.rawlogging import RawLoggingMonitor prototable = { 'http' : RawLoggingMonitor, 'rawlog' : RawLoggingMonitor, 'ssllog' : None, }././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/intercepting/monitors/base.py0000664000000000000000000000505014136501636021607 0ustar00rootrootimport asyncio import logging from asysocks.common.trafficlog import TrafficLog srvlogger = logging.getLogger('asysocks.traffic.base') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) srvlogger.addHandler(handler) srvlogger.setLevel(logging.INFO) class BaseMonitor: """ Base class for monitoring traffic. This does not do monitoring just holds all the necessary data that enables monitoring for other classes """ def __init__(self, client_ip, client_port, dst_ip, dst_port, module, session_id): self.client_ip = client_ip self.client_port = client_port self.dst_ip = dst_ip self.dst_hostname = None self.dst_port = dst_port self.module = module self.session_id = session_id self.logline_c2d = '[%s][MONITOR][%s:%s -> %s:%s]' % (self.module, self.client_ip, self.client_port, self.dst_ip, self.dst_port) self.logline_d2c = '[%s][MONITOR][%s:%s -> %s:%s]' % (self.module, self.dst_ip, self.dst_port, self.client_ip, self.client_port) self.c2d_in = asyncio.Queue() self.c2d_out = asyncio.Queue() self.d2c_in = asyncio.Queue() self.d2c_out = asyncio.Queue() def get_trafficlog(self, data, direction, module_name = None): t = TrafficLog() t.module_name = module_name t.srv_module = self.module t.client_ip = self.client_ip t.client_port = self.client_port t.destination_ip = self.dst_ip t.destination_hostname = self.dst_hostname t.destination_port = self.dst_port t.session_id = self.session_id t.direction = direction t.data = data return t def get_dst_hostname(self): if self.dst_hostname is None: return self.dst_ip return self.dst_hostname def set_hostname(self, hostname): #for SNI support on SSL self.dst_hostname = hostname async def __proxy_c2d(self, stop_evt): try: while not stop_evt.is_set(): data = await self.c2d_in.get() await self.c2d_out.put(data) if data == b'': return except Exception as e: srvlogger.exception('__proxy_c2d') finally: stop_evt.set() async def __proxy_d2c(self, stop_evt): try: while not stop_evt.is_set(): data = await self.d2c_in.get() await self.d2c_out.put(data) if data == b'': return except Exception as e: srvlogger.exception('__proxy_d2c') finally: stop_evt.set() async def run(self): """ Only invoke this if no monitoring is required! """ stop_evt = asyncio.Event() asyncio.create_task(self.__proxy_c2d(stop_evt)) asyncio.create_task(self.__proxy_d2c(stop_evt)) await stop_evt.wait()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/intercepting/monitors/rawlogging.py0000664000000000000000000000302214136501636023032 0ustar00rootrootimport asyncio import logging srvlogger = logging.getLogger('asysocks.traffic.raw') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) srvlogger.addHandler(handler) srvlogger.setLevel(logging.INFO) class RawLoggingMonitor: """ Logs raw socket data, no SSL intercpetion or protocol reconstruction done """ def __init__(self, monitor, log_queue, c2d_in = None, c2d_out = None, d2c_in = None, d2c_out = None): self.monitor = monitor self.log_queue = log_queue self.module_name = 'RAWLOG' async def __justlog_c2d(self, stop_evt): try: while not stop_evt.is_set(): data = await self.monitor.c2d_in.get() await self.log_queue.put(self.monitor.get_trafficlog(data, 'c2d_in', self.module_name)) await self.monitor.c2d_out.put(data) if data == b'': return except Exception as e: srvlogger.exception('__justlog_c2d') finally: stop_evt.set() async def __justlog_d2c(self, stop_evt): try: while not stop_evt.is_set(): data = await self.monitor.d2c_in.get() await self.log_queue.put(self.monitor.get_trafficlog(data, 'd2c_in', self.module_name)) await self.monitor.d2c_out.put(data) if data == b'': return except Exception as e: srvlogger.exception('__justlog_d2c') finally: stop_evt.set() async def run(self): stop_evt = asyncio.Event() asyncio.create_task(self.__justlog_c2d(stop_evt)) asyncio.create_task(self.__justlog_d2c(stop_evt)) await stop_evt.wait() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285589.0 asysocks-0.2.2/asysocks/intercepting/monitors/sslbase.py0000664000000000000000000002001514213712525022324 0ustar00rootrootimport asyncio import ssl import logging srvlogger = logging.getLogger('asysocks.traffic.ssl') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) srvlogger.addHandler(handler) srvlogger.setLevel(logging.INFO) class SSLBaseMonitor: def __init__(self, monitor, client_ssl_ctx = None, destination_ssl_ctx = None): self.monitor = monitor self.client_ssl_ctx = client_ssl_ctx self.destination_ssl_ctx = destination_ssl_ctx self.stop_evt = asyncio.Event() self.client_ssl_ok_evt = asyncio.Event() self.destination_ssl_ok_evt = asyncio.Event() self.client_tls_obj = None self.client_tls_in_buff = None self.client_tls_out_buff = None self.destination_tls_obj = None self.destination_tls_in_buff = None self.destination_tls_out_buff = None self.__client_ssl_in_q = asyncio.Queue() self.__destination_ssl_in_q = asyncio.Queue() self.c2d_ssl_task = None self.d2c_ssl_task = None self.dest_task = None self.client_task = None self.c2d_in = asyncio.Queue() self.c2d_out = asyncio.Queue() self.d2c_in = asyncio.Queue() self.d2c_out = asyncio.Queue() def get_trafficlog(self, data, direction, module_name = None): t = self.monitor.get_trafficlog(data, direction, module_name = module_name) t.is_ssl = True return t async def __read_ssl_record(self, raw_in_q, ssl_in_q): try: buffer = b'' length = None while not self.stop_evt.is_set(): if length is None and len(buffer) >= 6: length = int.from_bytes(buffer[3:5], byteorder = 'big', signed = False) if length is not None and len(buffer) >= length + 5: #print('LB raw %s' % len(buffer[:length+5])) await ssl_in_q.put(buffer[:length+5]) buffer = buffer[length+5:] length = None continue data = await raw_in_q.get() if data == b'': await ssl_in_q.put(b'') return buffer+= data except asyncio.CancelledError: return except Exception as e: print('__read_ssl_record %s' % e) await ssl_in_q.put(b'') #finally: # self.stop_evt.set() async def __do_ssl_handshake_cli(self, ssl_ctx, in_q, out_q): try: tls_in_buff = ssl.MemoryBIO() tls_out_buff = ssl.MemoryBIO() tls_obj = ssl_ctx.wrap_bio(tls_in_buff, tls_out_buff, server_side=False, server_hostname = self.monitor.dst_hostname) #print('################## %s' % self.monitor.dst_ip) ctr = 0 while not self.stop_evt.is_set(): ctr += 1 #print('DST Performing handshake!') try: tls_obj.do_handshake() except ssl.SSLWantReadError: #print('DST want %s' % ctr) while True: client_hello = tls_out_buff.read() if client_hello != b'': #print('DST client_hello %s' % len(client_hello)) await out_q.put(client_hello) else: break #print('DST wating server hello %s' % ctr) server_hello = await in_q.get() #print('DST server_hello %s' % len(server_hello)) tls_in_buff.write(server_hello) continue except: raise else: #print('DST handshake ok %s' % ctr) #server_fin = tls_out_buff.read() #print('DST server_fin %s ' % server_fin) #await out_q.put(server_fin) break return tls_in_buff, tls_out_buff, tls_obj, None except Exception as e: print(e) return None, None, None, e async def __do_ssl_handshake_srv(self, ssl_ctx, in_q, out_q): try: tls_in_buff = ssl.MemoryBIO() tls_out_buff = ssl.MemoryBIO() tls_obj = ssl_ctx.wrap_bio(tls_in_buff, tls_out_buff, server_side=True) ctr = 0 while not self.stop_evt.is_set(): ctr += 1 #print('wating client hello %s' % ctr) client_hello = await in_q.get() #print('client_hello %s' % len(client_hello)) tls_in_buff.write(client_hello) #print('Performing handshake!') try: tls_obj.do_handshake() except ssl.SSLWantReadError: #print('want %s' % ctr) while True: server_hello = tls_out_buff.read() if server_hello != b'': #print('server_hello %s' % len(server_hello)) await out_q.put(server_hello) else: break continue except: raise else: #print('handshake ok %s' % ctr) while True: server_fin = tls_out_buff.read() if server_fin != b'': await out_q.put(server_fin) else: break break return tls_in_buff, tls_out_buff, tls_obj, None except Exception as e: #print(e) return None, None, None, e async def __read_dec(self, ssl_in_q, final_out_q, tls_in, tls_obj): try: while True: ssl_data = await ssl_in_q.get() if ssl_data == b'': await final_out_q.put(ssl_data) #print('Connection terminated') return tls_in.write(ssl_data) data_buff = b'' while True: try: data_buff += tls_obj.read() except ssl.SSLWantReadError: break #print('data_buff %s' % data_buff) if data_buff != b'': await final_out_q.put(data_buff) except Exception as e: print(e) async def __client_ssl_endpoint(self): try: self.client_tls_in_buff, self.client_tls_out_buff, self.client_tls_obj, err = await self.__do_ssl_handshake_srv(self.client_ssl_ctx, self.__client_ssl_in_q, self.monitor.d2c_out) if err is not None: raise err print('CLIENT Handshake OK!') self.client_ssl_ok_evt.set() await self.destination_ssl_ok_evt.wait() asyncio.create_task(self.__read_dec(self.__client_ssl_in_q, self.c2d_in, self.client_tls_in_buff, self.client_tls_obj)) while not self.stop_evt.is_set(): client_data_buff = await self.c2d_out.get() if client_data_buff == b'': await self.monitor.c2d_out.put(client_data_buff) break #print('client_data %s' % client_data_buff) self.destination_tls_obj.write(client_data_buff) while True: client_ssl_data = self.destination_tls_out_buff.read() if client_ssl_data == b'': break #print('client_ssl_data %s' % client_ssl_data) await self.monitor.c2d_out.put(client_ssl_data) except Exception as e: print('CLIENT error: %s' % e) return None, None, None, e finally: self.stop_evt.set() self.client_ssl_ok_evt.set() self.destination_ssl_ok_evt.set() await self.monitor.c2d_out.put(b'') self.c2d_ssl_task.cancel() self.d2c_ssl_task.cancel() self.dest_task.cancel() async def __destination_ssl_endpoint(self): try: self.destination_tls_in_buff, self.destination_tls_out_buff, self.destination_tls_obj, err = await self.__do_ssl_handshake_cli(self.client_ssl_ctx, self.__destination_ssl_in_q, self.monitor.c2d_out) if err is not None: raise err self.destination_ssl_ok_evt.set() await self.client_ssl_ok_evt.wait() print('DST Handshake OK!') asyncio.create_task(self.__read_dec(self.__destination_ssl_in_q, self.d2c_in, self.destination_tls_in_buff, self.destination_tls_obj)) while not self.stop_evt.is_set(): destination_data_buff = await self.d2c_out.get() if destination_data_buff == b'': await self.monitor.d2c_out.put(destination_data_buff) break print('destination_data %s' % destination_data_buff) self.client_tls_obj.write(destination_data_buff) while True: destination_ssl_data = self.client_tls_out_buff.read() if destination_ssl_data == b'': break await self.monitor.d2c_out.put(destination_ssl_data) except Exception as e: print(type(e)) print('DST error: %s' % e) return None, None, None, e finally: self.stop_evt.set() self.client_ssl_ok_evt.set() self.destination_ssl_ok_evt.set() await self.monitor.d2c_out.put(b'') self.c2d_ssl_task.cancel() self.d2c_ssl_task.cancel() self.client_task.cancel() async def run(self): self.c2d_ssl_task = asyncio.create_task(self.__read_ssl_record(self.monitor.c2d_in, self.__client_ssl_in_q)) self.d2c_ssl_task = asyncio.create_task(self.__read_ssl_record(self.monitor.d2c_in, self.__destination_ssl_in_q)) self.dest_task = asyncio.create_task(self.__destination_ssl_endpoint()) self.client_task = asyncio.create_task(self.__client_ssl_endpoint()) await self.stop_evt.wait()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285578.0 asysocks-0.2.2/asysocks/intercepting/server.py0000664000000000000000000000566314213712512020334 0ustar00rootroot import asyncio import logging import json import re import ssl from asysocks.intercepting.monitors import prototable from asysocks.intercepting.monitors.sslbase import SSLBaseMonitor from asysocks.intercepting.default_intercept_table import default_intercept_table logger = logging.getLogger('asysocks.intercept') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) class InterceptServer: def __init__(self, server, certmanager, log_queue, intercept_targets = None, protocol_load_table = None): self.server = server self.certmanager = certmanager self.log_queue = log_queue self.intercept_targets = intercept_targets self.protocol_load_table = protocol_load_table self.monitor_dispatch_q = asyncio.Queue() self.server_task = None self.processing_task = None self.setup() def setup(self): if self.protocol_load_table is None: self.protocol_load_table = prototable if self.intercept_targets is None: self.intercept_targets = default_intercept_table async def __lookup_monitor(self, monitor): try: selected_protocol = monitor for entry in self.intercept_targets: is_ssl, proto = entry.get_proto_for_monitor(monitor) if proto is not None: if is_ssl is True: client_ssl_ctx = ssl.create_default_context() client_ssl_ctx.check_hostname = False client_ssl_ctx.verify_mode = ssl.CERT_NONE fake_cert_file, fake_key_file, err = await self.certmanager.get_cert_by_host(monitor.get_dst_hostname(), port = monitor.dst_port) if err is not None: print(err) return monitor, err client_ssl_ctx.load_cert_chain(fake_cert_file, fake_key_file) destination_ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) destination_ssl_ctx.check_hostname = False destination_ssl_ctx.verify_mode = ssl.CERT_NONE monitor = SSLBaseMonitor(monitor, client_ssl_ctx = client_ssl_ctx, destination_ssl_ctx = destination_ssl_ctx) asyncio.create_task(monitor.run()) selected_protocol = self.protocol_load_table[proto](monitor, self.log_queue) break return selected_protocol, None except Exception as e: return None, e async def __process_monitors(self): try: print(2) while True: #each connection will give a monitor class monitor = await self.monitor_dispatch_q.get() print('monitor_in') monitor_protocol, err = await self.__lookup_monitor(monitor) if err is not None: print(err) raise err print(44) asyncio.create_task(monitor_protocol.run()) except Exception as e: logger.exception('__process_monitors') print(e) async def run(self): self.server.monitor_dispatch_q = self.monitor_dispatch_q self.server_task = asyncio.create_task(self.server.run()) await asyncio.sleep(0) await self.__process_monitors()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/intercepting/target.py0000664000000000000000000000314414136501636020313 0ustar00rootrootimport json import re class InterceptTarget: def __init__(self): self.dsthost = None self.dstport = None self.srchost = None self.srcport = None self.proto = None self.ssl = None def to_dict(self): return { 'dsthost' : self.dsthost.pattern if self.dsthost is not None else None, 'dstport' : self.dstport, 'srchost' : self.srchost.pattern if self.srchost is not None else None, 'srcport' : self.srcport, 'proto' : self.proto, 'ssl' : self.ssl, } @staticmethod def from_dict(d): it = InterceptTarget() it.dsthost = re.compile(d['dsthost']) if d.get('dsthost') is not None else None it.dstport = int(d['dstport']) if d.get('dstport') is not None else None it.srchost = re.compile(d['srchost']) if d.get('srchost') is not None else None it.srcport = int(d['srcport']) if d.get('srcport') is not None else None it.proto = d['proto'] it.ssl = d['ssl'] return it @staticmethod def from_json(jdata): return InterceptTarget.from_dict(json.loads(jdata)) def to_json(self): return json.dumps(self.to_dict()) def get_proto_for_monitor(self, monitor): if self.check_intercept(monitor) is True: return self.ssl, self.proto return None, None def check_intercept(self, monitor): if self.dsthost is not None: if self.dsthost.match(monitor.dst_ip) is None: return False if self.dstport is not None: if self.dstport != monitor.dst_port: return False if self.srchost is not None: if self.srchost.match(monitor.client_ip) is None: return False if self.srcport is not None: if self.srcport != monitor.client_port: return False return True././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8136292 asysocks-0.2.2/asysocks/network/0000755000000000000000000000000014310720220015427 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/network/__init__.py0000664000000000000000000000000014136501636017546 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/network/queue.py0000664000000000000000000000256414136501636017154 0ustar00rootroot class NetworkQueue: def __init__(self): self.in_queue = None self.out_queue = None self.buffer = b'' self.data_in_evt = None self.pipe_broken_evt = None async def run(self): try: pass except Exception as e: print(e) async def read(self, n = -1): try: if self.pipe_broken_evt.is_set(): return b'' while len(self.buffer) == 0: await self.data_in_evt.wait() if n == -1: temp = self.buffer self.buffer = b'' return temp temp = self.buffer[:n] self.buffer = self.buffer[n:] return temp except Exception as e: print(e) async def readexactly(self, n): try: if self.pipe_broken_evt.is_set(): raise Exception('Pipe broken!') if n < 1: raise Exception('Readexactly must be a positive integer!') while len(self.buffer) >= n: await self.data_in_evt.wait() temp = self.buffer[:n] self.buffer = self.buffer[n:] return temp except Exception as e: print(e) async def readuntil(self, pattern): try: if self.pipe_broken_evt.is_set(): raise Exception('Pipe broken!') while self.buffer.find(pattern) == -1: await self.data_in_evt.wait() end = self.buffer.find(pattern)+len(pattern) temp = self.buffer[:end] self.buffer = self.buffer[end:] return temp except Exception as e: print(e) async def readline(self): return await self.readuntil(b'\n') ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/network/tcp.py0000664000000000000000000000000014136501636016575 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661769866.0 asysocks-0.2.2/asysocks/network/wsnet.py0000664000000000000000000001040114303114212017137 0ustar00rootrootfrom wsnet.pyodide.client import WSNetworkTCP import asyncio # This code only works properly in the conditions met in this specific library. # If you want to copy it to your project please make sure that you # NEVER under any circumstances use the reader in multiple separate corutines at the same time # else you gonna have a bad time. # class WSNETNetworkTest: @staticmethod async def open_connection(host, port, wsnet_reuse = False): from asysocks.test.wsnettest import WSNetworkTCPTEST out_queue = asyncio.Queue() in_queue = asyncio.Queue() closed_event = asyncio.Event() client = WSNetworkTCPTEST(host, int(port), in_queue, out_queue, wsnet_reuse) _, err = await client.run() if err is not None: raise err writer = WSNETWriter(out_queue, closed_event) reader = WSNETReader(in_queue, closed_event) await writer.run() await reader.run() return reader, writer class WSNETNetwork: @staticmethod async def open_connection(host, port, wsnet_reuse = False): out_queue = asyncio.Queue() in_queue = asyncio.Queue() closed_event = asyncio.Event() client = WSNetworkTCP(host, int(port), in_queue, out_queue, wsnet_reuse) _, err = await client.run() if err is not None: raise err writer = WSNETWriter(out_queue, closed_event) reader = WSNETReader(in_queue, closed_event) await writer.run() await reader.run() return reader, writer class WSNETWriter: def __init__(self, out_queue, closed_event): self.out_queue = out_queue self.closed_event = closed_event def write(self, data): self.out_queue.put_nowait(data) def close(self): self.out_queue.put_nowait(None) self.closed_event.set() async def drain(self): await asyncio.sleep(0) return async def run(self): return class WSNETReader: def __init__(self, in_queue, closed_event): self.wsnet_reader_type = None self.in_queue = in_queue self.closed_event = closed_event self.buffer = b'' self.data_in_evt = asyncio.Event() self.err = None self.bufferlock = asyncio.Lock() async def __handle_in(self): while True: res, self.err = await self.in_queue.get() if self.err is not None: if res is not None and res != b'': self.buffer += res.data self.data_in_evt.set() self.closed_event.set() return self.buffer += res self.data_in_evt.set() if res == b'': break self.closed_event.set() async def run(self): self.handle_task = asyncio.create_task(self.__handle_in()) await asyncio.sleep(0) #making sure prev line fired async def read(self, n = -1): try: #print('read') if self.closed_event.is_set(): return b'' async with self.bufferlock: if n == -1: if len(self.buffer) == 0: self.data_in_evt.clear() await self.data_in_evt.wait() temp = self.buffer self.buffer = b'' else: if len(self.buffer) == 0: self.data_in_evt.clear() await self.data_in_evt.wait() temp = self.buffer[:n] self.buffer = self.buffer[n:] #print('read ret %s' % temp) return temp except Exception as e: #print(e) self.closed_event.set() raise async def readexactly(self, n): try: if self.closed_event.is_set(): raise Exception('Pipe broken!') if n < 1: raise Exception('Readexactly must be a positive integer!') async with self.bufferlock: while len(self.buffer) < n: self.data_in_evt.clear() await self.data_in_evt.wait() #print('self.buffer %s' % self.buffer) temp = self.buffer[:n] self.buffer = self.buffer[n:] #print('readexactly ret %s' % temp) return temp except Exception as e: #print(e) self.closed_event.set() raise async def readuntil(self, separator = b'\n'): try: if self.closed_event.is_set(): raise Exception('Pipe broken!') async with self.bufferlock: while self.buffer.find(separator) == -1: self.data_in_evt.clear() await self.data_in_evt.wait() end = self.buffer.find(separator)+len(separator) temp = self.buffer[:end] self.buffer = self.buffer[end:] #print('readuntil ret %s' % temp) return temp except Exception as e: #print(e) self.closed_event.set() raise async def readline(self): return await self.readuntil(b'\n') def at_eof(self): return self.closed_event.is_set() and len(self.buffer) == 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1643395574.0 asysocks-0.2.2/asysocks/network/wsnetws.py0000664000000000000000000001071014175034766017542 0ustar00rootrootfrom wsnet.operator.networkproxy import WSNetworkWS from asysocks.common.constants import SocksServerVersion import asyncio import traceback from asysocks import logger # This code only works properly in the conditions met in this specific library. # If you want to copy it to your project please make sure that you # NEVER under any circumstances use the reader in multiple separate corutines at the same time # else you gonna have a bad time. # class WSNETNetworkWS: @staticmethod async def open_connection(target_host, target_port, host, port, proto, agentid = None, timeout = None): try: out_queue = asyncio.Queue() in_queue = asyncio.Queue() closed_event = asyncio.Event() proto = 'ws' if proto == SocksServerVersion.WSNETWSS: proto = 'wss' url = '%s://%s:%s/' % (proto, host, port) logger.debug('WSNETNetworkWS URL: %s' % url) logger.debug('WSNETNetworkWS AGENTID: %s' % agentid) agentid = bytes.fromhex(agentid) client = WSNetworkWS(target_host, target_port, url, in_queue, out_queue, agentid) _, err = await asyncio.wait_for(client.run(), timeout) if err is not None: raise err writer = WSNETWriter(out_queue, closed_event, client) reader = WSNETReader(in_queue, closed_event) await writer.run() await reader.run() return reader, writer except Exception as e: print('W') traceback.print_exc() return None, e class WSNETWriter: def __init__(self, out_queue, closed_event, client): self.out_queue = out_queue self.closed_event = closed_event self.client = client def write(self, data): #print('THIS IS DATA: %s' % data) self.out_queue.put_nowait(data) def close(self): self.out_queue.put_nowait(None) self.closed_event.set() asyncio.create_task(self.client.terminate()) async def drain(self): await asyncio.sleep(0) return async def run(self): return class WSNETReader: def __init__(self, in_queue, closed_event): self.wsnet_reader_type = None self.in_queue = in_queue self.closed_event = closed_event self.buffer = b'' self.data_in_evt = [] self.err = None async def __handle_in(self): try: while True: res, self.err = await self.in_queue.get() if self.err is not None: if res is not None: self.buffer += res if len(self.data_in_evt) != 0: evt = self.data_in_evt.pop() evt.set() self.closed_event.set() return self.buffer += res if len(self.data_in_evt) != 0: evt = self.data_in_evt.pop() evt.set() except asyncio.CancelledError: return except Exception as e: raise e finally: self.closed_event.set() for evt in self.data_in_evt: evt.set() async def run(self): self.handle_task = asyncio.create_task(self.__handle_in()) await asyncio.sleep(0) #making sure prev line fired async def read(self, n = -1): try: #print('read') if self.closed_event.is_set(): data = self.buffer #print('read ret %s' % data) self.buffer = b'' return data if len(self.buffer) == 0: evt = asyncio.Event() self.data_in_evt.append(evt) await evt.wait() temp = self.buffer[:n] self.buffer = self.buffer[n:] #print('read ret %s' % temp) return temp except asyncio.CancelledError: return except Exception as e: #print(e) self.closed_event.set() raise async def readexactly(self, n): try: if self.closed_event.is_set(): raise Exception('Pipe broken!') if n < 1: raise Exception('Readexactly must be a positive integer!') while len(self.buffer) < n: #print('readexactly waiting...') evt = asyncio.Event() self.data_in_evt.append(evt) await evt.wait() #print('self.buffer %s' % self.buffer) temp = self.buffer[:n] self.buffer = self.buffer[n:] #print('readexactly ret %s' % temp) return temp except asyncio.CancelledError: return except Exception as e: #print(e) self.closed_event.set() raise async def readuntil(self, pattern): try: if self.closed_event.is_set(): raise Exception('Pipe broken!') while self.buffer.find(pattern) == -1: evt = asyncio.Event() self.data_in_evt.append(evt) await evt.wait() end = self.buffer.find(pattern)+len(pattern) temp = self.buffer[:end] self.buffer = self.buffer[end:] #print('readuntil ret %s' % temp) return temp except asyncio.CancelledError: return except Exception as e: #print(e) self.closed_event.set() raise async def readline(self): return await self.readuntil(b'\n') ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8136292 asysocks-0.2.2/asysocks/protocol/0000755000000000000000000000000014310720220015577 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/protocol/__init__.py0000664000000000000000000000000014136501636017716 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/protocol/http.py0000664000000000000000000000543514136501636017157 0ustar00rootrootimport asyncio import io class HTTPProxyAuthRequiredException(Exception): pass class HTTPProxyAuthFailed(Exception): pass class HTTPResponse: def __init__(self): self.version = None self.status = None self.reason = None self.headers = {} self.headers_upper = {} self.data = None @staticmethod async def from_streamreader(reader, timeout = None): try: resp = HTTPResponse() #reading headers temp = await asyncio.wait_for(reader.readuntil(b'\r\n\r\n'), timeout = timeout) temp = temp.split(b'\r\n')[:-1] version, status, reason = temp[0].split(b' ', 2) resp.version = version.decode() resp.status = int(status.decode()) resp.reason = reason.decode() for hdr_raw in temp[1:]: if hdr_raw.strip() == b'': continue key_raw, value_raw = hdr_raw.split(b': ', 1) key = key_raw.decode() value = value_raw.strip().decode() resp.headers[key] = value resp.headers_upper[key.upper()] = value if 'CONTENT-LENGTH' in resp.headers_upper: rem_len = int(resp.headers_upper['CONTENT-LENGTH']) resp.data = await asyncio.wait_for(reader.readexactly(rem_len), timeout = timeout) return resp, None except Exception as e: return None, e class HTTPRequest: def __init__(self): self.method = None self.uri = None self.version = None self.headers = {} self.headers_upper = {} self.data = None def __str__(self): t = '%s %s %s\r\n' % (self.method, self.uri, self.version) for x in self.headers: t += '%s: %s\r\n' % (x, self.headers[x]) t += '\r\n' if self.data is not None: t += '' return t def to_bytes(self): t = '%s %s %s\r\n' % (self.method, self.uri, self.version) for x in self.headers: t += '%s: %s\r\n' % (x, self.headers[x]) t += '\r\n' t = t.encode() if self.data is not None: t += self.data return t @staticmethod async def from_streamreader(reader, timeout = None, pre_data = None): try: req = HTTPRequest() #reading headers temp = await asyncio.wait_for(reader.readuntil(b'\r\n\r\n'), timeout = timeout) if pre_data is not None: temp = pre_data + temp temp = temp.split(b'\r\n')[:-1] method, uri, version = temp[0].split(b' ', 2) req.method = method.decode() req.uri = uri.decode() req.version = version.decode() for hdr_raw in temp[1:]: if hdr_raw.strip() == b'': continue key_raw, value_raw = hdr_raw.split(b': ', 1) key = key_raw.decode() value = value_raw.strip().decode() req.headers[key] = value req.headers_upper[key.upper()] = value if 'CONTENT-LENGTH' in req.headers_upper: rem_len = int(req.headers_upper['CONTENT-LENGTH']) req.data = await asyncio.wait_for(reader.readexactly(rem_len), timeout = timeout) return req, None except Exception as e: return None, e././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/protocol/socks4.py0000664000000000000000000000632214136501636017402 0ustar00rootroot # https://ftp.icm.edu.pl/packages/socks/socks4/SOCKS4.protocol import io import os import enum import ipaddress import socket import asyncio SOCKS4_USERID_MAC_LEN = 255 class SOCKS4CDCode(enum.Enum): REQ_CONNECT = 1 REQ_BIND = 2 REP_GRANTED = 90 #request granted REP_FAILED = 91 #request rejected or failed REP_FAILED_NOCONN = 92 #request rejected becasue SOCKS server cannot connect to identd on the client REP_FAILED_USRID_MISMATCH = 93 #request rejected because the client program and identd report different user-ids class SOCKS4Request: def __init__(self): self.VN = 4 self.CD = SOCKS4CDCode.REQ_CONNECT self.DSTPORT = None self.DSTIP = None self.USERID = None @staticmethod def from_bytes(data): return SOCKS4Request.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: t = await asyncio.wait_for(reader.readuntil(b'\x00'), timeout = timeout) return SOCKS4Request.from_bytes(t), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4Request() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4CDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) o.USERID = b'' for _ in range(SOCKS4_USERID_MAC_LEN): x = buff.read(1) if x == 0: break o.USERID += x return o @staticmethod def from_target(target): o = SOCKS4Request() if target.is_bind is True: SOCKS4CDCode.REQ_BIND o.DSTPORT = target.endpoint_port if isinstance(target.endpoint_ip, ipaddress.IPv4Address): o.DSTIP = target.endpoint_ip else: o.DSTIP = ipaddress.ip_address(target.endpoint_ip) o.USERID = target.userid if target.userid is None: o.USERID = os.urandom(4).hex().encode('ascii') return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed t += self.USERID t += b'\x00' #trailing for userid return t class SOCKS4Reply: def __init__(self): self.VN = 0 self.CD = None self.DSTPORT = None self.DSTIP = None @staticmethod def from_bytes(data): return SOCKS4Reply.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: t = await asyncio.wait_for(reader.readexactly(8), timeout = timeout) return SOCKS4Reply.from_bytes(t), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4Reply() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4CDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/protocol/socks4a.py0000664000000000000000000000751114136501636017544 0ustar00rootroot # https://www.openssh.com/txt/socks4a.protocol import io import os import enum import ipaddress import socket import asyncio SOCKS4_USERID_MAC_LEN = 255 class SOCKS4ACDCode(enum.Enum): REQ_CONNECT = 1 REQ_BIND = 2 REP_GRANTED = 90 #request granted REP_FAILED = 91 #request rejected or failed REP_FAILED_NOCONN = 92 #request rejected becasue SOCKS server cannot connect to identd on the client REP_FAILED_USRID_MISMATCH = 93 #request rejected because the client program and identd report different user-ids class SOCKS4ARequest: def __init__(self): self.VN = 4 self.CD = SOCKS4ACDCode.REQ_CONNECT self.DSTPORT = None self.DSTIP = None self.USERID = None self.DOMAIN = None @staticmethod def from_bytes(data): return SOCKS4ARequest.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: buff = b'' t = await asyncio.wait_for(reader.readexactly(4), timeout = timeout) buff += t t = await asyncio.wait_for(reader.readexactly(4), timeout = timeout) buff += t r = 1 if t[0:3] == b'\x00\x00\x00': r = 2 for _ in range(0,r): t = await asyncio.wait_for(reader.readuntil(b'\x00'), timeout = timeout) buff += t return SOCKS4ARequest.from_bytes(buff), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4ARequest() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4ACDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) o.USERID = b'' for _ in range(SOCKS4_USERID_MAC_LEN): x = buff.read(1) if x == 0: break o.USERID += x if str(o.DSTIP).startswith('0.0.0.'): for _ in range(SOCKS4_USERID_MAC_LEN): x = buff.read(1) if x == 0: break o.DOMAIN += x return o @staticmethod def from_target(target): o = SOCKS4ARequest() if target.is_bind is True: SOCKS4ACDCode.REQ_BIND o.DSTPORT = target.endpoint_port if isinstance(target.endpoint_ip, ipaddress.IPv4Address): o.DSTIP = target.endpoint_ip else: try: o.DSTIP = ipaddress.ip_address(target.endpoint_ip) except: o.DSTIP = ipaddress.ip_address('0.0.0.3') o.DOMAIN = str(target.endpoint_ip) o.USERID = target.userid if target.userid is None: o.USERID = os.urandom(4).hex().encode('ascii') return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed t += self.USERID t += b'\x00' #trailing for userid if self.DOMAIN is not None: t += self.DOMAIN.encode() t += b'\x00' return t class SOCKS4AReply: def __init__(self): self.VN = 0 self.CD = None self.DSTPORT = None self.DSTIP = None @staticmethod def from_bytes(data): return SOCKS4AReply.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: t = await asyncio.wait_for(reader.readexactly(8), timeout = timeout) return SOCKS4AReply.from_bytes(t), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4AReply() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4ACDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659730769.0 asysocks-0.2.2/asysocks/protocol/socks5.py0000664000000000000000000004761114273275521017414 0ustar00rootroot#https://www.ietf.org/rfc/rfc1928.txt #https://tools.ietf.org/html/rfc1929 #https://tools.ietf.org/html/rfc1961 import io import enum import ipaddress import socket import asyncio from asysocks.common.constants import SOCKS5Method class SOCKS5ServerState(enum.Enum): NEGOTIATION = 0 NOT_AUTHENTICATED = 1 REQUEST = 3 RELAYING = 4 class SOCKS5Command(enum.Enum): CONNECT = 0x01 BIND = 0x02 UDP_ASSOCIATE = 0x03 class SOCKS5AddressType(enum.Enum): IP_V4 = 0x01 DOMAINNAME = 0x03 IP_V6 = 0x04 class SOCKS5ReplyType(enum.Enum): SUCCEEDED = 0x00 # o X'00' succeeded FAILURE = 0x01 # o X'01' general SOCKS server failure CONN_NOT_ALLOWED = 0x02 # o X'02' connection not allowed by ruleset NETWORK_UNREACHABLE = 0x03 #o X'03' Network unreachable HOST_UNREACHABLE = 0x04 #o X'04' Host unreachable CONN_REFUSED = 0x05 #o X'05' Connection refused TTL_EXPIRED = 0x06 #o X'06' TTL expired COMMAND_NOT_SUPPORTED = 0x07 #o X'07' Command not supported ADDRESS_TYPE_NOT_SUPPORTED = 0x08 #o X'08' Address type not supported #o X'09' to X'FF' unassigned class SOCKS5ServerErrorReply(Exception): def __init__(self, reply): self.reply = reply def __str__(self): return self.reply.name class SOCKS5AuthFailed(Exception): pass class SOCKS5SocketParser: def __init__(self, protocol = socket.SOCK_STREAM): self.protocol = protocol def parse(self, soc, packet_type): return packet_type.from_bytes(self.read_soc(soc, packet_type.size)) def read_soc(self, soc, size): data = b'' while True: temp = soc.recv(4096) if temp == '': break data += temp if len(data) == size: break return data class SOCKS5CommandParser: # the reason we need this class is: SOCKS5 protocol messages doesn't have a type field, # the messages are parsed in context of the session itself. def __init__(self, protocol = socket.SOCK_STREAM): self.protocol = protocol #not used atm def parse(self, buff, session): if session.current_state == SOCKS5ServerState.NEGOTIATION: return SOCKS5Nego.from_buffer(buff) if session.current_state == SOCKS5ServerState.NOT_AUTHENTICATED: if session.mutual_auth_type == SOCKS5Method.PLAIN: return SOCKS5PlainAuth.from_buffer(buff) else: raise Exception('Not implemented!') if session.current_state == SOCKS5ServerState.REQUEST: return SOCKS5Request.from_buffer(buff) @staticmethod async def from_streamreader(reader, session, timeout = None): raise NotImplementedError() #if session.current_state == SOCKS5ServerState.NEGOTIATION: # t = await asyncio.wait_for(SOCKS5Nego.from_streamreader(reader), timeout = timeout) # return t # #if session.current_state == SOCKS5ServerState.NOT_AUTHENTICATED: # if session.mutual_auth_type == SOCKS5Method.PLAIN: # t = await asyncio.wait_for(SOCKS5PlainAuth.from_streamreader(reader), timeout = timeout) # return t # else: # raise Exception('Not implemented!') # #if session.current_state == SOCKS5ServerState.REQUEST: # t = await asyncio.wait_for(SOCKS5Request.from_streamreader(reader), timeout = timeout) # return t class SOCKS5AuthHandler: def __init__(self, authtype, creds = None): self.authtype = authtype self.creds = creds def do_AUTH(self, msg): if self.authtype == SOCKS5Method.PLAIN: if not isinstance(msg, SOCKS5PlainAuth): raise Exception('Wrong message/auth type!') if self.creds is None: return True, SOCKS5PlainCredentials(msg.UNAME, msg.PASSWD) else: if msg.UNAME in self.creds: if msg.PASSWD == self.creds[msg.UNAME]: return True, SOCKS5PlainCredentials(msg.UNAME, msg.PASSWD) return False, SOCKS5PlainCredentials(msg.UNAME, msg.PASSWD) elif self.authtype == SOCKS5Method.GSSAPI: raise Exception('Not implemented! yet') else: raise Exception('Not implemented!') class SOCKS5PlainCredentials: def __init__(self, username, password): self.username = username self.password = password class SOCKS5PlainAuthReply: def __init__(self): self.VER = None self.STATUS = None @staticmethod async def from_streamreader(reader): rep = SOCKS5PlainAuthReply() t = await reader.read(1) rep.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(1) rep.STATUS = SOCKS5ReplyType(int.from_bytes(t, byteorder = 'big', signed = False)) return rep @staticmethod def from_bytes(data): return SOCKS5PlainAuthReply.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): rep = SOCKS5PlainAuthReply() rep.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.STATUS = SOCKS5ReplyType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) return rep class SOCKS5PlainAuth: def __init__(self): self.VER = None self.ULEN = None self.UNAME = None self.PLEN = None self.PASSWD = None @staticmethod async def from_streamreader(reader): auth = SOCKS5PlainAuth() t = await reader.read(1) auth.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(1) auth.ULEN = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(auth.ULEN) auth.UNAME = t.decode() t = await reader.read(1) auth.PLEN = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(auth.PLEN) auth.PASSWD = t.decode() return auth @staticmethod def from_bytes(bbuff): return SOCKS5PlainAuth.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): auth = SOCKS5PlainAuth() auth.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) auth.ULEN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) auth.UNAME = buff.read(auth.ULEN).decode() auth.PLEN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) auth.PASSWD = buff.read(auth.PLEN).decode() return auth @staticmethod def construct(username, password): auth = SOCKS5PlainAuth() auth.VER = 1 auth.ULEN = len(username) auth.UNAME = username auth.PLEN = len(password) auth.PASSWD = password return auth def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.ULEN.to_bytes(1, byteorder = 'big', signed = False) t += self.UNAME.encode() t += self.PLEN.to_bytes(1, byteorder = 'big', signed = False) t += self.PASSWD.encode() return t class SOCKS5Nego: def __init__(self): self.VER = 5 self.NMETHODS = None self.METHODS = None @staticmethod async def from_streamreader(reader): nego = SOCKS5Nego() t = await reader.readexactly(1) nego.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) nego.NMETHODS = int.from_bytes(t, byteorder = 'big', signed = False) nego.METHODS = [] for _ in range(nego.NMETHODS): t = await reader.readexactly(1) nego.METHODS.append(SOCKS5Method(int.from_bytes(t, byteorder = 'big', signed = False))) return nego @staticmethod def from_bytes(bbuff): return SOCKS5Nego.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): nego = SOCKS5Nego() nego.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) nego.NMETHODS = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) nego.METHODS = [] for _ in range(nego.NMETHODS): nego.METHODS.append(SOCKS5Method(int.from_bytes(buff.read(1), byteorder = 'big', signed = False))) return nego @staticmethod def from_methods(methods): if not isinstance(methods, list): methods = [methods] nego = SOCKS5Nego() nego.NMETHODS = len(methods) nego.METHODS = methods return nego def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.NMETHODS.to_bytes(1, byteorder = 'big', signed = False) for method in self.METHODS: t += method.value.to_bytes(1, byteorder = 'big', signed = False) return t class SOCKS5NegoReply: def __init__(self): self.VER = 5 self.METHOD = None def __repr__(self): t = '== SOCKS5NegoReply ==\r\n' t += 'VER: %s\r\n' % self.VER t += 'METHOD: %s\r\n' % self.METHOD return t @staticmethod def from_socket(soc): data = b'' total_size = 2 while True: temp = soc.recv(1024) if temp == b'': break data += temp if len(data) >= total_size: break return SOCKS5NegoReply.from_bytes(data) @staticmethod async def from_streamreader(reader): rep = SOCKS5NegoReply() t = await reader.readexactly(1) rep.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.METHOD = SOCKS5Method(int.from_bytes(t, byteorder = 'big', signed = False)) return rep @staticmethod def from_bytes(bbuff): return SOCKS5NegoReply.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rep = SOCKS5NegoReply() rep.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.METHOD = SOCKS5Method(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) return rep @staticmethod def construct(method): rep = SOCKS5NegoReply() rep.VER = 5 rep.METHOD = method return rep @staticmethod def construct_auth(method, ver = 1): rep = SOCKS5NegoReply() rep.VER = ver rep.METHOD = method return rep def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.METHOD.value.to_bytes(1, byteorder = 'big', signed = False) return t class SOCKS5Request: def __init__(self): self.VER = 5 self.CMD = SOCKS5Command.CONNECT self.RSV = 0 self.ATYP = None self.DST_ADDR = None self.DST_PORT = None @staticmethod async def from_streamreader(reader): req = SOCKS5Request() t = await reader.readexactly(1) req.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) req.CMD = SOCKS5Command(int.from_bytes(t, byteorder = 'big', signed = False)) t = await reader.readexactly(1) req.RSV = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) req.ATYP = SOCKS5AddressType(int.from_bytes(t, byteorder = 'big', signed = False)) if req.ATYP == SOCKS5AddressType.IP_V4: t = await reader.readexactly(4) req.DST_ADDR = ipaddress.IPv4Address(t) elif req.ATYP == SOCKS5AddressType.IP_V6: t = await reader.readexactly(16) req.DST_ADDR = ipaddress.IPv6Address(t) elif req.ATYP == SOCKS5AddressType.DOMAINNAME: t = await reader.readexactly(1) length = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(length) req.DST_ADDR = t.decode() t = await reader.readexactly(2) req.DST_PORT = int.from_bytes(t, byteorder = 'big', signed = False) return req @staticmethod def from_bytes(bbuff): return SOCKS5Request.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): req = SOCKS5Request() req.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) req.CMD = SOCKS5Command(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) req.RSV = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) req.ATYP = SOCKS5AddressType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) if req.ATYP == SOCKS5AddressType.IP_V4: req.DST_ADDR = ipaddress.IPv4Address(buff.read(4)) elif req.ATYP == SOCKS5AddressType.IP_V6: req.DST_ADDR = ipaddress.IPv6Address(buff.read(16)) elif req.ATYP == SOCKS5AddressType.DOMAINNAME: length = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) req.DST_ADDR = buff.read(length).decode() req.DST_PORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) return req @staticmethod def from_target(target): req = SOCKS5Request() req.CMD = SOCKS5Command.CONNECT if target.is_bind is True: req.CMD = SOCKS5Command.BIND if isinstance(target.endpoint_ip, ipaddress.IPv4Address): req.ATYP = SOCKS5AddressType.IP_V4 req.DST_ADDR = target.endpoint_ip elif isinstance(target.endpoint_ip, ipaddress.IPv6Address): req.ATYP = SOCKS5AddressType.IP_V6 req.DST_ADDR = target.endpoint_ip elif isinstance(target.endpoint_ip, str): req.ATYP = SOCKS5AddressType.DOMAINNAME req.DST_ADDR = target.endpoint_ip req.DST_PORT = target.endpoint_port return req @staticmethod def construct(cmd, address, port): req = SOCKS5Request() req.VER = 5 req.CMD = cmd req.RSV = 0 if isinstance(address, ipaddress.IPv4Address): req.ATYP = SOCKS5AddressType.IP_V4 req.DST_ADDR = address elif isinstance(address, ipaddress.IPv6Address): req.ATYP = SOCKS5AddressType.IP_V6 req.DST_ADDR = address elif isinstance(address, str): req.ATYP = SOCKS5AddressType.DOMAINNAME req.DST_ADDR = address req.DST_PORT = port return req def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.CMD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.RSV.to_bytes(1, byteorder = 'big', signed = False) t += self.ATYP.value.to_bytes(1, byteorder = 'big', signed = False) if self.ATYP == SOCKS5AddressType.DOMAINNAME: t += len(self.DST_ADDR).to_bytes(1, byteorder = 'big', signed = False) t += self.DST_ADDR.encode() else: t += self.DST_ADDR.packed t += self.DST_PORT.to_bytes(2, byteorder = 'big', signed = False) return t class SOCKS5Reply: def __init__(self): self.VER = 5 self.REP = None self.RSV = 0 self.ATYP = None self.BIND_ADDR= None self.BIND_PORT= None @staticmethod def from_socket(soc): data = b'' total_size = 1024 while True: temp = soc.recv(1024) if temp == b'': break data += temp if len(data) > 4: rt = SOCKS5AddressType(data[3]) if rt == SOCKS5AddressType.IP_V4: total_size = 4 + 2 + 4 if rt == SOCKS5AddressType.IP_V6: total_size = 4 + 2 + 16 if rt == SOCKS5AddressType.DOMAINNAME: total_size = 4 + 2 + data[4] if len(data) >= total_size: break return SOCKS5Reply.from_bytes(data) @staticmethod async def from_streamreader(reader): rep = SOCKS5Reply() t = await reader.readexactly(1) rep.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.REP = SOCKS5ReplyType(int.from_bytes(t, byteorder = 'big', signed = False)) t = await reader.readexactly(1) rep.RSV = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.ATYP = SOCKS5AddressType(int.from_bytes(t, byteorder = 'big', signed = False)) if rep.ATYP == SOCKS5AddressType.IP_V4: t = await reader.readexactly(4) rep.BIND_ADDR = ipaddress.IPv4Address(t) elif rep.ATYP == SOCKS5AddressType.IP_V6: t = await reader.readexactly(16) rep.BIND_ADDR = ipaddress.IPv6Address(t) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: t = await reader.readexactly(1) length = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(length) rep.BIND_ADDR = t.decode() t = await reader.readexactly(2) rep.BIND_PORT = int.from_bytes(t, byteorder = 'big', signed = False) return rep @staticmethod def from_bytes(bbuff): return SOCKS5Reply.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rep = SOCKS5Reply() rep.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.REP = SOCKS5ReplyType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) rep.RSV = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.ATYP = SOCKS5AddressType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) if rep.ATYP == SOCKS5AddressType.IP_V4: rep.BIND_ADDR = ipaddress.IPv4Address(buff.read(4)) elif rep.ATYP == SOCKS5AddressType.IP_V6: rep.BIND_ADDR = ipaddress.IPv6Address(buff.read(16)) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: length = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.BIND_ADDR = buff.read(length).decode() rep.BIND_PORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) return rep @staticmethod def construct(reply, address, port): rep = SOCKS5Reply() rep.VER = 5 rep.REP = reply rep.RSV = 0 if isinstance(address, ipaddress.IPv4Address): rep.ATYP = SOCKS5AddressType.IP_V4 rep.DST_ADDR = address elif isinstance(address, ipaddress.IPv6Address): rep.ATYP = SOCKS5AddressType.IP_V6 rep.DST_ADDR = address elif isinstance(address, str): rep.ATYP = SOCKS5AddressType.DOMAINNAME rep.DST_ADDR = address rep.DST_PORT = port return rep def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.REP.value.to_bytes(1, byteorder = 'big', signed = False) t += self.RSV.to_bytes(1, byteorder = 'big', signed = False) t += self.ATYP.value.to_bytes(1, byteorder = 'big', signed = False) if self.ATYP == SOCKS5AddressType.DOMAINNAME: t += len(self.DST_ADDR).to_bytes(1, byteorder = 'big', signed = False) t += self.DST_ADDR.encode() else: t += self.DST_ADDR.packed t += self.DST_PORT.to_bytes(2, byteorder = 'big', signed = False) return t def __repr__(self): t = '== SOCKS5Reply ==\r\n' t += 'REP: %s\r\n' % repr(self.REP) t += 'ATYP: %s\r\n' % repr(self.ATYP) t += 'BIND_ADDR: %s\r\n' % repr(self.BIND_ADDR) t += 'BIND_PORT: %s\r\n' % repr(self.BIND_PORT) return t class SOCKS5UDP: def __init__(self): self.RSV = None self.FRAG = None self.ATYP = None self.DST_ADDR = None self.DST_PORT = None self.DATA = None @staticmethod async def from_streamreader(reader): rep = SOCKS5UDP() t = await reader.readexactly(2) rep.RSV = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.FRAG = SOCKS5ReplyType(int.from_bytes(t, byteorder = 'big', signed = False)) t = await reader.readexactly(1) rep.ATYP = SOCKS5AddressType(int.from_bytes(t, byteorder = 'big', signed = False)) if rep.ATYP == SOCKS5AddressType.IP_V4: t = await reader.readexactly(4) rep.DST_ADDR = ipaddress.IPv4Address(t) elif rep.ATYP == SOCKS5AddressType.IP_V6: t = await reader.readexactly(16) rep.DST_ADDR = ipaddress.IPv6Address(t) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: t = await reader.readexactly(1) length = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(length) rep.DST_ADDR = t.decode() t = await reader.readexactly(2) rep.DST_PORT = int.from_bytes(t, byteorder = 'big', signed = False) return rep @staticmethod def from_bytes(bbuff): return SOCKS5UDP.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rep = SOCKS5UDP() rep.RSV = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) rep.FRAG = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.ATYP = SOCKS5AddressType(buff.read(1), byteorder = 'big', signed = False) if rep.ATYP == SOCKS5AddressType.IP_V4: rep.DST_ADDR = ipaddress.IPv4Address(buff.read(4)) elif rep.ATYP == SOCKS5AddressType.IP_V6: rep.DST_ADDR = ipaddress.IPv6Address(buff.read(16)) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: length = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.DST_ADDR = buff.read(length).decode() rep.DST_PORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) #be careful, not data length is defined in the RFC!! rep.DATA = buff.read() @staticmethod def construct(address, port, data, frag = 0): req = SOCKS5Request() req.RSV = 0 req.FRAG = frag if isinstance(address, ipaddress.IPv4Address): req.ATYP = SOCKS5AddressType.IP_V4 req.DST_ADDR = address elif isinstance(address, ipaddress.IPv6Address): req.ATYP = SOCKS5AddressType.IP_V6 req.DST_ADDR = address elif isinstance(address, str): req.ATYP = SOCKS5AddressType.DOMAINNAME req.DST_ADDR = address req.DST_PORT = port req.DATA = data return req def to_bytes(self): t = self.RSV.to_bytes(2, byteorder = 'big', signed = False) t += self.FRAG.value.to_bytes(1, byteorder = 'big', signed = False) t += self.ATYP.value.to_bytes(1, byteorder = 'big', signed = False) if self.ATYP == SOCKS5AddressType.DOMAINNAME: t += len(self.DST_ADDR).to_bytes(1, byteorder = 'big', signed = False) t += self.DST_ADDR.encode() else: t += self.DST_ADDR.packed t += self.DST_PORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DATA return t././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/security.py0000664000000000000000000003103014136501636016174 0ustar00rootroot import asyncio import ipaddress import random from asysocks import logger from asysocks.common.constants import SocksServerVersion, SocksCommsMode from asysocks.protocol.socks4 import SOCKS4Request, SOCKS4Reply, SOCKS4CDCode from asysocks.protocol.socks5 import SOCKS5Method, SOCKS5Nego, SOCKS5NegoReply, SOCKS5Request, SOCKS5Reply, SOCKS5ReplyType, SOCKS5Command, SOCKS5PlainAuth, SOCKS5PlainAuthReply, SOCKS5ServerErrorReply from asysocks.common.target import SocksTarget from asysocks.common.credentials import SocksCredential from asysocks.common.comms import SocksQueueComms from asysocks.client import SOCKSClient class SocksSecurity: def __init__(self): self.server_ip = None self.server_port = None self.server_sslctx = None self.timeout = None self.verify_host = None #endpoint ip/hostname to test the connection self.verify_port = None #endpoint port self.verify_send = None #data to be sent to the endpoint service upon succsessfull connection self.verify_recv = None #data expected from the endpoint service in response to verify_send def socks4_noauth(self): pass async def socks5_authmethods(self, methods = [SOCKS5Method.NOAUTH, SOCKS5Method.PLAIN, SOCKS5Method.GSSAPI], timeout = None): """ Checks which auth methods are supported by the server """ supported = [] notsupported = [] errors = [] for method in methods: remote_reader = None remote_writer = None try: logger.debug('method %s' % method.name) try: remote_reader, remote_writer = await asyncio.wait_for( asyncio.open_connection( self.server_ip, self.server_port, ssl = self.server_sslctx, ), timeout = self.timeout ) logger.debug('Connected to socks server!') except Exception as e: logger.debug('Failed to connect to SOCKS server!') return None, None, e nego = SOCKS5Nego.from_methods([method]) logger.debug('[SOCKS5] Sending negotiation command to server @ %s:%d' % remote_writer.get_extra_info('peername')) remote_writer.write(nego.to_bytes()) await asyncio.wait_for( remote_writer.drain(), timeout = timeout ) rep_nego = await asyncio.wait_for( SOCKS5NegoReply.from_streamreader(remote_reader), timeout = timeout ) logger.debug( '[SOCKS5] Got negotiation reply from from %s! Server choosen auth type: %s' % (remote_writer.get_extra_info('peername'), rep_nego.METHOD.name) ) if rep_nego.METHOD == method: supported.append(method) else: notsupported.append(method) except Exception as e: logger.debug('Failed proto test for method %s. Reason: %s' % (method.name, e)) errors.append((method, e)) continue finally: if remote_writer is not None: remote_writer.close() return supported, notsupported, errors async def socks5_login(self, username, password, timeout = None): """ Tries to open connection to a remote endpoint using the socks proxy server using plaintext auth method with username and password """ try: remote_reader = None remote_writer = None try: remote_reader, remote_writer = await asyncio.wait_for( asyncio.open_connection( self.server_ip, self.server_port, ssl = self.server_sslctx, ), timeout = self.timeout ) logger.debug('Connected to socks server!') except Exception as e: logger.debug('Failed to connect to SOCKS server!') return None, e logger.debug('[SOCKS5] invoked') methods = [SOCKS5Method.PLAIN] nego = SOCKS5Nego.from_methods(methods) logger.debug('[SOCKS5] Sending negotiation command to server @ %s:%d' % remote_writer.get_extra_info('peername')) remote_writer.write(nego.to_bytes()) await asyncio.wait_for( remote_writer.drain(), timeout = timeout ) rep_nego = await asyncio.wait_for( SOCKS5NegoReply.from_streamreader(remote_reader), timeout = timeout ) logger.debug( '[SOCKS5] Got negotiation reply from from %s! Server choosen auth type: %s' % (remote_writer.get_extra_info('peername'), rep_nego.METHOD.name) ) if rep_nego.METHOD != SOCKS5Method.PLAIN: return False, None auth = SOCKS5PlainAuth.construct(username, password) remote_writer.write(auth.to_bytes()) await asyncio.wait_for( remote_writer.drain(), timeout = timeout ) rep_data = await asyncio.wait_for( remote_reader.read(2), timeout = timeout ) if rep_data == b'': return False, None rep_nego = SOCKS5PlainAuthReply.from_bytes(rep_data) if rep_nego.STATUS != SOCKS5ReplyType.SUCCEEDED: return False, None if self.verify_host is None: return True, None logger.debug('[SOCKS5] Opening channel to %s:%s' % (self.verify_host, self.verify_port)) logger.debug('[SOCKS5] Sending connect request to SOCKS server @ %s:%d' % remote_writer.get_extra_info('peername')) try: target = ipaddress.ip_address(self.verify_host) except: target = self.verify_host remote_writer.write( SOCKS5Request.construct( SOCKS5Command.CONNECT, target, int(self.verify_port) ).to_bytes() ) await asyncio.wait_for( remote_writer.drain(), timeout=timeout ) rep = await asyncio.wait_for( SOCKS5Reply.from_streamreader(remote_reader), timeout=timeout ) if rep.REP != SOCKS5ReplyType.SUCCEEDED: #logger.info('Failed to connect to proxy %s! Server replied: %s' % (self.proxy_writer.get_extra_info('peername'), repr(rep.REP))) return False, rep.REP.name logger.debug('[SOCKS5] Server @ %s:%d successfully set up the connection to the endpoint! ' % remote_writer.get_extra_info('peername')) if self.verify_send is None: return True, None remote_writer.write(self.verify_send) await asyncio.wait_for( remote_writer.drain(), timeout=timeout ) data = await remote_reader.read(4096) if data.find(self.verify_recv) == -1: return False, None return True, None except Exception as e: return None, e finally: if remote_writer is not None: remote_writer.close() async def socks5_noauth(self, timeout = None): """ Tries to open connection to a remote endpoint using the socks proxy server without authentication """ try: remote_reader = None remote_writer = None try: remote_reader, remote_writer = await asyncio.wait_for( asyncio.open_connection( self.server_ip, self.server_port, ssl = self.server_sslctx, ), timeout = self.timeout ) logger.debug('Connected to socks server!') except Exception as e: logger.debug('Failed to connect to SOCKS server!') return None, e logger.debug('[SOCKS5] invoked') methods = [SOCKS5Method.NOAUTH] nego = SOCKS5Nego.from_methods(methods) logger.debug('[SOCKS5] Sending negotiation command to server @ %s:%d' % remote_writer.get_extra_info('peername')) remote_writer.write(nego.to_bytes()) await asyncio.wait_for( remote_writer.drain(), timeout = timeout ) rep_nego = await asyncio.wait_for( SOCKS5NegoReply.from_streamreader(remote_reader), timeout = timeout ) logger.debug( '[SOCKS5] Got negotiation reply from from %s! Server choosen auth type: %s' % (remote_writer.get_extra_info('peername'), rep_nego.METHOD.name) ) if rep_nego.METHOD != SOCKS5Method.NOAUTH: return False, None if self.verify_host is None: return True, None logger.debug('[SOCKS5] Opening channel to %s:%s' % (self.verify_host, self.verify_port)) logger.debug('[SOCKS5] Sending connect request to SOCKS server @ %s:%d' % remote_writer.get_extra_info('peername')) try: target = ipaddress.ip_address(self.verify_host) except: target = self.verify_host remote_writer.write( SOCKS5Request.construct( SOCKS5Command.CONNECT, target, int(self.verify_port) ).to_bytes() ) await asyncio.wait_for( remote_writer.drain(), timeout=timeout ) rep = await asyncio.wait_for( SOCKS5Reply.from_streamreader(remote_reader), timeout=timeout ) if rep.REP != SOCKS5ReplyType.SUCCEEDED: #logger.info('Failed to connect to proxy %s! Server replied: %s' % (self.proxy_writer.get_extra_info('peername'), repr(rep.REP))) return False, rep.REP.name logger.debug('[SOCKS5] Server @ %s:%d successfully set up the connection to the endpoint! ' % remote_writer.get_extra_info('peername')) if self.verify_send is None: return True, None remote_writer.write(self.verify_send) await asyncio.wait_for( remote_writer.drain(), timeout=timeout ) data = await remote_reader.read(4096) if data.find(self.verify_recv) == -1: return False, None return True, None except Exception as e: return None, e finally: if remote_writer is not None: remote_writer.close() 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) 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 target.only_open = True credential = SocksCredential() credential.username = username credential.password = password target.credential = credential in_q = asyncio.Queue() out_q = asyncio.Queue() comms = SocksQueueComms(in_q, out_q) client = SOCKSClient(comms, target) 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 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 target.credential = credential in_q = asyncio.Queue() out_q = asyncio.Queue() comms = SocksQueueComms(in_q, out_q) channel_open_evt = asyncio.Event() client = SOCKSClient(comms, target, 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 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285547.0 asysocks-0.2.2/asysocks/server.py0000664000000000000000000004310114213712453015632 0ustar00rootroot import logging import asyncio import socket import copy import ipaddress from urllib.parse import urlparse import ssl from asysocks.common.constants import SocksServerVersion, SocksCommsMode from asysocks.protocol.http import HTTPRequest from asysocks.protocol.socks4 import SOCKS4Request, SOCKS4Reply, SOCKS4CDCode from asysocks.protocol.socks5 import SOCKS5Command, SOCKS5AddressType, SOCKS5Method, SOCKS5Nego, SOCKS5NegoReply, SOCKS5Request, SOCKS5Reply, SOCKS5ReplyType, SOCKS5PlainAuth, SOCKS5PlainAuthReply, SOCKS5ServerErrorReply, SOCKS5AuthFailed from asysocks.intercepting.monitors.base import BaseMonitor srvlogger = logging.getLogger('asysocks.proxyserver') handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) srvlogger.addHandler(handler) srvlogger.setLevel(logging.INFO) class SOCKSServer: def __init__(self, listen_ip, listen_port, ssl_ctx = None, client_timeout = 10, buffer_size = 10240, supported_protocols = ['SOCKS4', 'SOCKS5', 'HTTP'], monitor_dispatch_q = None): self.listen_ip = listen_ip self.listen_port = listen_port self.ssl_ctx = ssl_ctx self.client_timeout = client_timeout self.buffer_size = buffer_size self.supported_protocols = supported_protocols self.monitor_dispatch_q = monitor_dispatch_q self.session_id = 0 def get_session_id(self): t = self.session_id self.session_id += 1 return t async def __proxy(self, reader_a, writer_b, stop_evt, src_module, monitor_in_q = None, monitor_out_q = None): async def pi(reader, in_q, buffer_size): try: while not stop_evt.is_set(): data = await reader_a.read(buffer_size) if data == b'' or data is None: await in_q.put(data) return await in_q.put(data) except: return finally: stop_evt.set() try: if monitor_in_q is not None: asyncio.create_task(pi(reader_a, monitor_in_q, self.buffer_size)) while not stop_evt.is_set(): data = await monitor_out_q.get() #print('data_modded %s' % data) if data == b'' or data is None: return writer_b.write(data) await writer_b.drain() else: while not stop_evt.is_set(): data = await reader_a.read(self.buffer_size) if data == b'' or data is None: return writer_b.write(data) await writer_b.drain() except asyncio.CancelledError: return except Exception as e: srvlogger.debug('[%s][TCPPROXY] Connection ended. Reason: %s' % (src_module, e)) finally: writer_b.close() stop_evt.set() async def handle_socks4(self, init_cmd, reader, writer): try: if init_cmd.CD == SOCKS4CDCode.REQ_CONNECT: srvlogger.debug('[SOCKS4] Client wants to connect to: %s:%s' % (str(init_cmd.DSTIP), init_cmd.DSTPORT)) try: dst_reader, dst_writer = await asyncio.open_connection(str(init_cmd.DSTIP), init_cmd.DSTPORT) except Exception as e: srvlogger.debug('[SOCKS4] Could not connect to: %s:%s Reason: %s' % (str(init_cmd.DSTIP), init_cmd.DSTPORT, e)) reply = SOCKS4Reply() reply.CD = SOCKS4CDCode.REP_FAILED reply.DSTPORT = init_cmd.DSTPORT reply.DSTIP = init_cmd.DSTIP writer.write(reply.to_bytes()) await writer.drain() return else: srvlogger.debug('[SOCKS4] Sucsessfully connected to: %s:%s Starting TCP proxy' % (str(init_cmd.DSTIP), init_cmd.DSTPORT)) reply = SOCKS4Reply() reply.CD = SOCKS4CDCode.REP_GRANTED reply.DSTPORT = init_cmd.DSTPORT reply.DSTIP = init_cmd.DSTIP writer.write(reply.to_bytes()) await writer.drain() stop_evt = asyncio.Event() c2d_in = None c2d_out = None d2c_in = None d2c_out = None if self.monitor_dispatch_q is not None: rem_ip, rem_port = dst_writer.get_extra_info('peername') client_ip, client_port = writer.get_extra_info('peername') monitor = BaseMonitor(client_ip, client_port, rem_ip, rem_port, 'SOCKS4', self.get_session_id()) c2d_in = monitor.c2d_in c2d_out = monitor.c2d_out d2c_in = monitor.d2c_in d2c_out = monitor.d2c_out await self.monitor_dispatch_q.put(monitor) task_1 = asyncio.create_task(self.__proxy(reader, dst_writer, stop_evt, 'SOCKS4', c2d_in, c2d_out)) task_2 = asyncio.create_task(self.__proxy(dst_reader, writer, stop_evt, 'SOCKS4', d2c_in, d2c_out)) await stop_evt.wait() srvlogger.debug('[SOCKS4] Connection ended %s:%s' % (str(init_cmd.DSTIP), init_cmd.DSTPORT)) task_1.cancel() task_2.cancel() return elif init_cmd.CD == SOCKS4CDCode.REQ_BIND: async def __handle_remote(dst_reader, dst_writer): try: rem_ip, rem_port = dst_writer.get_extra_info('peername') reply = SOCKS4Reply() reply.CD = SOCKS4CDCode.REP_GRANTED reply.DSTPORT = rem_port reply.DSTIP = ipaddress.IPv4Address(rem_ip) writer.write(reply.to_bytes()) await writer.drain() stop_evt = asyncio.Event() task_1 = asyncio.create_task(self.__proxy(reader, dst_writer, stop_evt, 'SOCKS4')) task_2 = asyncio.create_task(self.__proxy(dst_reader, writer, stop_evt, 'SOCKS4')) await stop_evt.wait() print('Connection terminated') task_1.cancel() task_2.cancel() except Exception as e: print('__handle_remote %s' % e) try: serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) serversocket.bind((str(init_cmd.DSTIP), 0)) serversocket.listen(1) serversocket_ip, serversocket_port = serversocket.getsockname() reply = SOCKS4Reply() reply.CD = SOCKS4CDCode.REP_GRANTED reply.DSTPORT = serversocket_port reply.DSTIP = ipaddress.IPv4Address(serversocket_ip) writer.write(reply.to_bytes()) await writer.drain() await asyncio.start_server(__handle_remote, sock=serversocket, backlog = 1) #TODO: this will constantly server bc there is no way to terminate this FIX!!! except Exception as e: reply = SOCKS4Reply() reply.CD = SOCKS4CDCode.REP_FAILED reply.DSTPORT = init_cmd.DSTPORT reply.DSTIP = init_cmd.DSTIP writer.write(reply.to_bytes()) await writer.drain() return else: raise Exception('Unknown client request! %s' % init_cmd.CD) except Exception as e: import traceback traceback.print_exc() print('handle_socks4 %s' % e) async def handle_socks5(self, init_cmd, reader, writer): try: #TODO: currently no auth is supported, add auth functionality! srvlogger.debug('[SOCKS5] Authentication supported by the client %s' % (','.join([x.name for x in init_cmd.METHODS]))) if SOCKS5Method.NOAUTH not in init_cmd.METHODS: reply = SOCKS5NegoReply.construct(SOCKS5Method.NOTACCEPTABLE) writer.write(reply.to_bytes()) await writer.drain() return reply = SOCKS5NegoReply.construct(SOCKS5Method.NOAUTH) writer.write(reply.to_bytes()) await writer.drain() req = await asyncio.wait_for(SOCKS5Request.from_streamreader(reader), timeout = self.client_timeout) if req.CMD == SOCKS5Command.CONNECT: srvlogger.debug('[SOCKS5] Client wants to connect to: %s:%s' % (str(req.DST_ADDR), req.DST_PORT)) try: dst_reader, dst_writer = await asyncio.open_connection(str(req.DST_ADDR), req.DST_PORT) except Exception as e: srvlogger.debug('[SOCKS5] Could not connect to: %s:%s Reason: %s' % (str(req.DST_ADDR), req.DST_PORT, e)) reply = SOCKS5Reply.construct(SOCKS5ReplyType.FAILURE,req.DST_ADDR, req.DST_PORT) #TODO: support more error types to let the client know what exscatly went wrong writer.write(reply.to_bytes()) await writer.drain() return else: srvlogger.debug('[SOCKS5] Sucsessfully connected to: %s:%s Starting TCP proxy' % (str(req.DST_ADDR), req.DST_PORT)) reply = SOCKS5Reply.construct(SOCKS5ReplyType.SUCCEEDED, req.DST_ADDR, req.DST_PORT) writer.write(reply.to_bytes()) await writer.drain() stop_evt = asyncio.Event() c2d_in = None c2d_out = None d2c_in = None d2c_out = None if self.monitor_dispatch_q is not None: rem_ip, rem_port = dst_writer.get_extra_info('peername') client_ip, client_port = writer.get_extra_info('peername') monitor = BaseMonitor(client_ip, client_port, rem_ip, rem_port, 'SOCKS5', self.get_session_id()) if req.ATYP == SOCKS5AddressType.DOMAINNAME: monitor.set_hostname(str(req.DST_ADDR)) await self.monitor_dispatch_q.put(monitor) c2d_in = monitor.c2d_in c2d_out = monitor.c2d_out d2c_in = monitor.d2c_in d2c_out = monitor.d2c_out task_1 = asyncio.create_task(self.__proxy(reader, dst_writer, stop_evt, 'SOCKS5', c2d_in, c2d_out)) task_2 = asyncio.create_task(self.__proxy(dst_reader, writer, stop_evt, 'SOCKS5', d2c_in, d2c_out)) await stop_evt.wait() srvlogger.debug('[SOCKS5] Connection ended %s:%s' % (str(req.DST_ADDR), req.DST_PORT)) task_1.cancel() task_2.cancel() return elif req.CMD == SOCKS5Command.BIND: srvlogger.debug('[SOCKS5] Client wants to BIND to: %s:%s' % (str(req.DST_ADDR), req.DST_PORT)) async def __handle_remote(dst_reader, dst_writer): try: rem_ip, rem_port = dst_writer.get_extra_info('peername') srvlogger.debug('[SOCKS5] Client BIND server get a connection from: %s:%s Notifying client...' % (str(rem_ip), rem_port)) reply = SOCKS5Reply.construct(SOCKS5ReplyType.SUCCEEDED , ipaddress.ip_address(rem_ip), rem_port) writer.write(reply.to_bytes()) await writer.drain() srvlogger.debug('[SOCKS5] Client BIND starting TCP proxy %s:%s' % (str(rem_ip), rem_port)) stop_evt = asyncio.Event() task_1 = asyncio.create_task(self.__proxy(reader, dst_writer, stop_evt, 'SOCKS5')) task_2 = asyncio.create_task(self.__proxy(dst_reader, writer, stop_evt, 'SOCKS5')) await stop_evt.wait() srvlogger.debug('[SOCKS5] Client BIND connection ended %s:%s' % (str(rem_ip), rem_port)) task_1.cancel() task_2.cancel() except Exception as e: srvlogger.exception('[SOCKS5] Client BIND error') try: if req.ATYP == SOCKS5AddressType.IP_V4: serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) serversocket.bind((str(req.DST_ADDR), 0)) elif req.ATYP == SOCKS5AddressType.IP_V6: serversocket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM) serversocket.bind((str(req.DST_ADDR), 0)) elif req.ATYP == SOCKS5AddressType.DOMAINNAME: #not sure abt this... serversocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) serversocket.bind((str(req.DST_ADDR), 0)) serversocket.listen(1) serversocket_ip, serversocket_port = serversocket.getsockname() reply = SOCKS5Reply.construct(SOCKS5ReplyType.SUCCEEDED , ipaddress.ip_address(serversocket_ip), serversocket_port) writer.write(reply.to_bytes()) await writer.drain() await asyncio.start_server(__handle_remote, sock=serversocket, backlog = 1) #TODO: this will constantly server bc there is no way to terminate this FIX!!! except Exception as e: srvlogger.debug('[SOCKS5] Error! Could not bind to: %s:%s Reason: %s' % (str(req.DST_ADDR), req.DST_PORT, e)) reply = SOCKS5Reply.construct(SOCKS5ReplyType.FAILURE , req.DST_ADDR, req.port) writer.write(reply.to_bytes()) await writer.drain() return elif req.CMD == SOCKS5Command.UDP_ASSOCIATE: srvlogger.debug('[SOCKS5] Error! Client requested UDP Associate, but it is not implemented!') raise Exception('UDP assoc requested, but is not implemented!') else: raise Exception('Client requested something that was not understood. %s' % req.CMD) except Exception as e: srvlogger.exception('[SOCKS5] Generic error: %s' % (e)) #print('handle_socks5 %s' % e) async def handle_http_connect(self, init_cmd, reader, writer): try: #TODO: there is not authentication implemented currently, fix! #TODO: not intercepting SSL if init_cmd.method.upper() != 'CONNECT': raise Exception('Unknown request type! %s' % init_cmd.method) #URI should be in HOST:PORT format host, port = init_cmd.uri.split(':') port = int(port) srvlogger.debug('[HTTPCONNECT] Client wants to connect to: %s:%s' % (host, port)) try: dst_reader, dst_writer = await asyncio.open_connection(host, port) except Exception as e: srvlogger.debug('[HTTPCONNECT] Could not connect to %s:%s. Reason: %s' % (host, port, e)) fail = b'HTTP/1.1 500 Error\r\n\r\n' writer.write(fail) await writer.drain() return else: srvlogger.debug('[HTTPCONNECT] Sucsessfully connected to %s:%s. Starting tcp proxy.' % (host, port)) ok = b'HTTP/1.1 200 OK\r\n\r\n' writer.write(ok) await writer.drain() stop_evt = asyncio.Event() c2d_in = None c2d_out = None d2c_in = None d2c_out = None if self.monitor_dispatch_q is not None: rem_ip, rem_port = dst_writer.get_extra_info('peername') client_ip, client_port = writer.get_extra_info('peername') monitor = BaseMonitor(client_ip, client_port, rem_ip, rem_port, 'HTTPCONNECT', self.get_session_id()) monitor.set_hostname(host) await self.monitor_dispatch_q.put(monitor) c2d_in = monitor.c2d_in c2d_out = monitor.c2d_out d2c_in = monitor.d2c_in d2c_out = monitor.d2c_out task_1 = asyncio.create_task(self.__proxy(reader, dst_writer, stop_evt, 'HTTPCONNECT', c2d_in, c2d_out)) task_2 = asyncio.create_task(self.__proxy(dst_reader, writer, stop_evt, 'HTTPCONNECT', d2c_in, d2c_out)) await stop_evt.wait() srvlogger.debug('[HTTPCONNECT] Connection ended @ %s:%s.' % (host, port)) task_1.cancel() task_2.cancel() return except Exception as e: srvlogger.exception('[HTTP] Generic error: %s' % (e)) async def handle_http_generic(self, init_cmd, reader, writer): try: #TODO: there is not authentication implemented currently, fix! o = urlparse(init_cmd.uri) host = o.hostname port = o.port if port is None or port == '': port = 80 if o.scheme.lower() == 'http' else 443 try: dst_reader, dst_writer = await asyncio.open_connection(host, port) except Exception as e: srvlogger.debug('[HTTP] Could not connect to %s:%s. Reason: %s' % (host, port, e)) fail = b'HTTP/1.1 500 Error\r\n\r\n' writer.write(fail) await writer.drain() return c_cmd = copy.deepcopy(init_cmd) c_cmd.uri = o.path + o.query data = None monitor = None if self.monitor_dispatch_q is not None: rem_ip, rem_port = dst_writer.get_extra_info('peername') client_ip, client_port = writer.get_extra_info('peername') monitor = BaseMonitor(client_ip, client_port, rem_ip, rem_port, 'HTTPCONNECT', self.get_session_id()) monitor.set_hostname(host) await self.monitor_dispatch_q.put(monitor) await monitor.c2d_in.put(c_cmd.to_bytes()) data = await monitor.c2d_out.get() else: data = c_cmd.to_bytes() dst_writer.write(data) await dst_writer.drain() data = None reply, err = await HTTPRequest.from_streamreader(dst_reader, timeout = self.client_timeout) if err is not None: raise err if monitor is not None: await monitor.d2c_in.put(reply.to_bytes()) data = await monitor.d2c_out.get() else: data = reply.to_bytes() writer.write(data) await writer.drain() except Exception as e: srvlogger.exception('[HTTP] Generic error: %s' % (e)) async def handle_client(self, reader, writer): #checking what protocol the client uses try: try: temp = await asyncio.wait_for(reader.readexactly(1), timeout = self.client_timeout) except asyncio.exceptions.IncompleteReadError as err: srvlogger.debug('Client terminated the socket before socks/http proxy handshake') return if temp == b'\x04': if 'SOCKS4' not in self.supported_protocols: raise Exception('Client tried to use SOCKS4, but it is disabled on the server') temp2 = await asyncio.wait_for(reader.readexactly(7), timeout = self.client_timeout) rest = await asyncio.wait_for(reader.readuntil(b'\x00'), timeout = self.client_timeout) init_cmd = SOCKS4Request.from_bytes(temp + temp2+ rest) await self.handle_socks4(init_cmd, reader, writer) return elif temp == b'\x05': #socks5 if 'SOCKS5' not in self.supported_protocols: raise Exception('Client tried to use SOCKS5, but it is disabled on the server') nmethods = await asyncio.wait_for(reader.readexactly(1), timeout = self.client_timeout) t_nmethods = int.from_bytes(nmethods, byteorder = 'big', signed = False) methods = await asyncio.wait_for(reader.readexactly(t_nmethods), timeout = self.client_timeout) init_cmd = SOCKS5Nego.from_bytes(temp + nmethods + methods) await self.handle_socks5(init_cmd, reader, writer) return elif temp in [b'\x43', b'\x63']: if 'HTTP' not in self.supported_protocols: raise Exception('Client tried to use HTTP proxy, but it is disabled on the server') #HTTP CONNECT init_cmd, err = await HTTPRequest.from_streamreader(reader, timeout = self.client_timeout, pre_data = temp) if err is not None: raise err await self.handle_http_connect(init_cmd, reader, writer) return elif temp in [b'g', b'G', b'p', b'P', b'o', b'O']: if 'HTTP' not in self.supported_protocols: raise Exception('Client tried to use HTTP proxy, but it is disabled on the server') init_cmd, err = await HTTPRequest.from_streamreader(reader, timeout = self.client_timeout, pre_data = temp) if err is not None: raise err await self.handle_http_generic(init_cmd, reader, writer) else: raise Exception('Unknwon protocol used by the client! %s' % temp) except Exception as e: srvlogger.exception('handle_client') async def run(self): server = await asyncio.start_server(self.handle_client, self.listen_ip, self.listen_port, ssl=self.ssl_ctx) await server.wait_closed() ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8136292 asysocks-0.2.2/asysocks/test/0000755000000000000000000000000014310720220014715 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661769852.0 asysocks-0.2.2/asysocks/test/__init__.py0000664000000000000000000000000014303114174017025 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/test/listener_test.py0000664000000000000000000000155014136501636020174 0ustar00rootroot import ipaddress import logging import asyncio from asysocks.common.target import SocksTarget from asysocks.common.comms import SocksLitenerComms from asysocks.common.constants import * from asysocks.client import SOCKSClient from asysocks import logger logging.basicConfig(level=2) logger.setLevel(logging.DEBUG) async def main(): target = SocksTarget() target.version = SocksServerVersion.SOCKS4 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 = SocksLitenerComms('127.0.0.1', 9999) client = SOCKSClient(comms, target) await client.run() print('DONE!') if __name__ == '__main__': asyncio.run(main())././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/test/queue_test.py0000664000000000000000000000226014136501636017472 0ustar00rootroot import ipaddress import logging import asyncio from asysocks.common.target import SocksTarget from asysocks.common.comms import SocksQueueComms from asysocks.common.constants import * from asysocks.client import SOCKSClient from asysocks import logger logging.basicConfig(level=2) logger.setLevel(logging.DEBUG) async def read_q(in_queue): while True: data = await in_queue.get() print(data) 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!') if __name__ == '__main__': asyncio.run(main())././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285596.0 asysocks-0.2.2/asysocks/test/ssl_test.py0000664000000000000000000000627514213712534017156 0ustar00rootroot import asyncio import logging import ssl from asysocks.server import SOCKSServer, srvlogger, ProxyMonitorSSL from asysocks._version import __banner__ async def amain(): try: import argparse parser = argparse.ArgumentParser(description='Universal proxy server (SOCKS4/5 and HTTP proxy') parser.add_argument('--listen-ip', default = '127.0.0.1', help='Listen IP') parser.add_argument('--listen-port', type = int, default = 1080, help='Listen port') parser.add_argument('--cert', help='SSL certificate file') parser.add_argument('--key', help='SSL key file') parser.add_argument('--client-timeout', type=int, default=10, help='How much time to wait ftill the client finishes initial handshake') parser.add_argument('--buffer-size', type=int, default=10240, help='Proxy buffer size') parser.add_argument('-m', '--monitor', action='store_true', help='Monitor mode.') parser.add_argument('-v', '--verbose', action='count', default=0, help='Verbosity') parser.add_argument('-s', '--silent', action='store_true', help = 'dont print banner') args = parser.parse_args() #### #### fake_cert = 'asysocks/test/cert.pem' fake_key = 'asysocks/test/key.pem' fake_pass = 'testcert' #### if args.silent is False: print(__banner__) if args.verbose >=1: srvlogger.setLevel(logging.DEBUG) ssl_ctx = None client_timeout = args.client_timeout buffer_size = args.buffer_size supported_protocols = ['SOCKS4','SOCKS5', 'HTTP'] monitor_dispatch_q = None if args.cert is not None: ssl_ctx = ssl.SSLContext() ssl_ctx.load_cert_chain(args.cert, keyfile=args.key) if args.monitor is True: monitor_dispatch_q = asyncio.Queue() server = SOCKSServer( args.listen_ip, args.listen_port, ssl_ctx, client_timeout = client_timeout, buffer_size = buffer_size, supported_protocols = supported_protocols, monitor_dispatch_q=monitor_dispatch_q ) if args.silent is False: print('Proxy server is up and running on %s:%s %s' % (args.listen_ip, args.listen_port, '' if ssl_ctx is None else '(SSL)')) if monitor_dispatch_q is None: await server.run() else: server_task = asyncio.create_task(server.run()) while True: #each connection will give a monitor class monitor = await monitor_dispatch_q.get() if monitor.dst_port == 443: client_ssl_ctx = ssl.create_default_context() client_ssl_ctx.check_hostname = False client_ssl_ctx.verify_mode = ssl.CERT_NONE print(client_ssl_ctx.verify_mode) client_ssl_ctx.load_cert_chain(fake_cert, fake_key, password=fake_pass) destination_ssl_ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) destination_ssl_ctx.check_hostname = False destination_ssl_ctx.verify_mode = ssl.CERT_NONE destination_ssl_ctx.set_ciphers('DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:ECDHE-ECDSA-AES128-GCM-SHA256:TLS_AES_128_GCM_SHA256') ssl_monitor = ProxyMonitorSSL(monitor, client_ssl_ctx = client_ssl_ctx, destination_ssl_ctx = destination_ssl_ctx) asyncio.create_task(ssl_monitor.intercept()) else: asyncio.create_task(monitor.just_log()) server_task.cancel() except Exception as e: print(e) def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/test/test_url_param.py0000664000000000000000000000071414136501636020332 0ustar00rootrootimport logging from asysocks.common.clienturl import SocksClientURL from asysocks import logger logging.basicConfig(level=2) logger.setLevel(logging.DEBUG) def main(): url_1 = 'smb://10.10.10.2/?timeout=10&dc=10.10.10.2&proxytype=socks5&proxyserver=127.0.0.1&proxyuser=admin&proxypass=alma&dc=10.10.10.2&dns=8.8.8.8' cu = SocksClientURL.from_params(url_1) target = cu.get_target() print(repr(target)) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661770620.0 asysocks-0.2.2/asysocks/test/wsnettest.py0000664000000000000000000000574414303115574017357 0ustar00rootroot import asyncio import os import traceback from wsnet.protocol import * import websockets class WSNetworkTCPTEST: def __init__(self, ip, port, in_q, out_q, reuse_ws = False): self.ws_url = None self.ws = None self.ws_proxy = None self.ip = ip self.port = port self.in_q = in_q self.out_q = out_q self.reuse_ws = reuse_ws self.token = os.urandom(16) self.in_task = None self.out_task = None self.__internal_in_q = None async def terminate(self): if self.in_task is not None: self.in_task.cancel() if self.out_task is not None: self.out_task.cancel() if self.ws is not None: await self.ws.close() self.ws = None async def __handle_in(self): try: while self.ws.open: try: data = await self.ws.recv() cmd = CMD.from_bytes(bytearray(data)) #print('__handle_in %s' % cmd) if cmd.type == CMDType.OK: print('Remote end terminated the socket') raise Exception('Remote end terminated the socket') elif cmd.type == CMDType.ERR: print('Proxy sent error during data transmission. Killing the tunnel.') raise Exception('Proxy sent error during data transmission. Killing the tunnel.') await self.in_q.put((cmd.data, None)) except asyncio.CancelledError: return except Exception as e: traceback.print_exc() await self.in_q.put((None, e)) return except: traceback.print_exc() finally: await self.terminate() async def __handle_out(self): try: while self.ws.open: data = await self.out_q.get() #print('OUT %s' % data) if data is None or data == b'': return cmd = WSNSocketData(self.token, data) await self.ws.send(cmd.to_bytes()) except Exception as e: traceback.print_exc() return finally: try: cmd = WSNOK(self.token) await self.ws.send(cmd.to_bytes()) except: pass await self.terminate() async def connect(self): try: print('WSNETTEST connecting... %s:%s' % (self.ip, self.port)) cmd = WSNConnect(self.token, 'TCP', self.ip, self.port) await self.ws.send(cmd.to_bytes()) data = await self.ws.recv() cmd = CMD.from_bytes(bytearray(data)) print('WSNETTEST connect reply %s' % cmd) if cmd.type == CMDType.CONTINUE: return True, None if cmd.type == CMDType.ERR: raise Exception('Connection failed, proxy sent error. Err: %s' % cmd.reason) raise Exception('Connection failed, expected CONTINUE, got %s' % cmd.type.value) except Exception as e: traceback.print_exc() return False, e async def run(self): try: self.__internal_in_q = asyncio.Queue() self.ws_url = 'ws://127.0.0.1:8700' self.ws = await websockets.connect(self.ws_url) _, err = await self.connect() if err is not None: await self.in_q.put(None) return False, err self.in_task = asyncio.create_task(self.__handle_in()) self.out_task = asyncio.create_task(self.__handle_out()) return True, None except Exception as e: traceback.print_exc() await self.terminate() return False, e././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8136292 asysocks-0.2.2/asysocks/unicomm/0000755000000000000000000000000014310720220015405 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659647128.0 asysocks-0.2.2/asysocks/unicomm/__init__.py0000664000000000000000000000041614273032230017526 0ustar00rootrootimport logging logger = logging.getLogger(__name__) handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s %(name)-12s %(levelname)-8s %(message)s') handler.setFormatter(formatter) logger.addHandler(handler) logger.setLevel(logging.INFO) ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661770676.0 asysocks-0.2.2/asysocks/unicomm/client.py0000664000000000000000000003454614303115664017267 0ustar00rootrootimport asyncio import copy import ssl import base64 from asysocks.unicomm.protocol.http import HTTPProxyAuthRequiredException, HTTPResponse, HTTPProxyAuthFailed from asysocks.unicomm.protocol.socks4a import SOCKS4ARequest, SOCKS4AReply, SOCKS4ACDCode from asysocks.unicomm.protocol.socks5 import SOCKS5Method, SOCKS5Nego, SOCKS5NegoReply, SOCKS5PlainAuth, \ SOCKS5AuthFailed, SOCKS5PlainAuthReply, SOCKS5ReplyType, SOCKS5Request, SOCKS5Reply, \ SOCKS5ServerErrorReply from asysocks.unicomm.common.target import UniTarget, UniProto from asysocks.unicomm.common.proxy import UniProxyProto, UniProxyTarget from asysocks.unicomm.common.packetizers import Packetizer from asysocks.unicomm.common.packetizers.ssl import PacketizerSSL from asysocks.unicomm.common.connection import UniConnection from asysocks.unicomm import logger class ProxyChainError(Exception): def __init__(self, innerexception, message="Something failed setting up the proxy chain! See innerexception for more details"): self.innerexception = innerexception self.message = message super().__init__(self.message) class UniClient: def __init__(self, target:UniTarget, packetizer:Packetizer): self.target = target self.packetizer = packetizer self.bind_progress_evt = asyncio.Event() self.http_auth_ctx = None async def run_http(self, proxy:UniProxyTarget, remote_reader:asyncio.StreamReader, remote_writer:asyncio.StreamWriter, timeout:int = None, http_auth_ctx:str = None): try: logger.debug('[HTTP] Opening channel to %s:%s' % (proxy.endpoint_ip, proxy.endpoint_port)) connect_cmd = 'CONNECT %s:%s HTTP/1.1\r\nHost: %s:%s\r\n' % (proxy.endpoint_ip, proxy.endpoint_port, proxy.endpoint_ip, proxy.endpoint_port) connect_cmd = connect_cmd.encode() if http_auth_ctx is None: remote_writer.write(connect_cmd + b'\r\n') await asyncio.wait_for(remote_writer.drain(), timeout = timeout) resp, err = await HTTPResponse.from_streamreader(remote_reader, timeout=timeout) if err is not None: raise err if resp.status == 200: logger.debug('[HTTP] Server succsessfully connected!') return True, http_auth_ctx, None elif resp.status == 407: logger.debug('[HTTP] Server proxy auth required!') if proxy.credential is None: raise Exception('HTTP proxy auth required but no credential set!') auth_type = resp.headers_upper.get('PROXY-AUTHENTICATE', None) if auth_type is None: raise Exception('HTTP proxy requires authentication, but requested auth type could not be determined') auth_type, _ = auth_type.split(' ', 1) logger.debug('HTTP proxy requires %s auth' % auth_type) http_auth_ctx = auth_type.upper() return False, http_auth_ctx, HTTPProxyAuthRequiredException() elif http_auth_ctx == 'BASIC': auth_data = base64.b64encode(('%s:%s' % (proxy.credential.username, proxy.credential.password) ).encode() ) auth_connect = connect_cmd + b'Proxy-Authorization: Basic ' + auth_data + b'\r\n' remote_writer.write(auth_connect + b'\r\n') await asyncio.wait_for(remote_writer.drain(), timeout = timeout) resp, err = await HTTPResponse.from_streamreader(remote_reader, timeout=timeout) if err is not None: raise err if resp.status == 200: logger.debug('[HTTP] Server proxy auth succsess!') return True, http_auth_ctx, None else: raise HTTPProxyAuthFailed() #raise Exception('Proxy auth failed!') else: raise Exception('HTTP proxy requires %s authentication, but it\'s not implemented' % http_auth_ctx) except Exception as e: logger.debug('run_http') return False, None, e async def run_socks4a(self, proxy:UniProxyTarget, remote_reader:asyncio.StreamReader, remote_writer:asyncio.StreamWriter, timeout:int = None): """ Does the intial "handshake" instructing the remote server to set up the connection to the endpoint """ try: logger.debug('[SOCKS4A %s:%s] Opening channel to %s:%s (target)' % (proxy.server_ip, proxy.server_port, proxy.endpoint_ip, proxy.endpoint_port)) req = SOCKS4ARequest.from_target(proxy) if proxy.credential is not None and proxy.credential.username is not None: req.USERID = proxy.credential.username remote_writer.write(req.to_bytes()) await asyncio.wait_for(remote_writer.drain(), timeout = timeout) rep, err = await asyncio.wait_for(SOCKS4AReply.from_streamreader(remote_reader), timeout = timeout) if err is not None: raise err if rep is None: raise Exception('Socks server failed to reply to CONNECT request!') if rep.CD != SOCKS4ACDCode.REP_GRANTED: raise Exception('Socks server returned error on CONNECT! %s' % rep.CD.value) logger.debug('[SOCKS4A] Channel opened') return True, None except Exception as e: logger.debug('run_socks4a') return False, e async def run_socks5(self, proxy:UniProxyTarget, remote_reader:asyncio.StreamReader, remote_writer:asyncio.StreamWriter, timeout:int = None): """ Does the intial "handshake" instructing the remote server to set up the connection to the endpoint """ sname = proxy.get_sname() tname = proxy.get_tname() methods = [SOCKS5Method.NOAUTH] if proxy.credential is not None and proxy.credential.username is not None and proxy.credential.password is not None: methods.append(SOCKS5Method.PLAIN) #methods = [SOCKS5Method.PLAIN] try: nego = SOCKS5Nego.from_methods(methods) logger.debug('[SOCKS5 %s][SETUP] Sending negotiation command to server' % sname) remote_writer.write(nego.to_bytes()) await asyncio.wait_for( remote_writer.drain(), timeout = timeout ) rep_nego = await asyncio.wait_for( SOCKS5NegoReply.from_streamreader(remote_reader), timeout = timeout ) logger.debug( '[SOCKS5 %s] Got negotiation reply! Server choosen auth type: %s' % (sname, rep_nego.METHOD.name) ) if rep_nego.METHOD == SOCKS5Method.PLAIN: if proxy.credential is None or proxy.credential.username is None or proxy.credential.password is None: raise Exception('SOCKS5 %s] server requires PLAIN authentication, but no credentials were supplied!' % sname) logger.debug('[SOCKS5 %s]Preforming plaintext auth' % sname) remote_writer.write( SOCKS5PlainAuth.construct( proxy.credential.username, proxy.credential.password ).to_bytes() ) await asyncio.wait_for( remote_writer.drain(), timeout=None ) rep_data = await asyncio.wait_for( remote_reader.read(2), timeout = timeout ) if rep_data == b'': raise SOCKS5AuthFailed() #raise Exception('Plaintext auth failed! Bad username or password') rep_nego = SOCKS5PlainAuthReply.from_bytes(rep_data) if rep_nego.STATUS != SOCKS5ReplyType.SUCCEEDED: raise SOCKS5AuthFailed() #raise Exception('Plaintext auth failed! Bad username or password') elif rep_nego.METHOD == SOCKS5Method.GSSAPI: raise Exception('[SOCKS5 %s] server requires GSSAPI authentication, but it\'s not supported at the moment' % sname) logger.debug('[SOCKS5 %s] Opening channel to %s' % (sname, tname)) if proxy.only_auth is True: return True, None remote_writer.write( SOCKS5Request.from_target( proxy ).to_bytes() ) await asyncio.wait_for( remote_writer.drain(), timeout=timeout ) rep = await asyncio.wait_for( SOCKS5Reply.from_streamreader(remote_reader), timeout=timeout ) if rep.REP != SOCKS5ReplyType.SUCCEEDED: logger.info('[SOCKS5 %s] remote end failed to connect to proxy! Reson: %s' % (sname, rep.REP.name)) raise SOCKS5ServerErrorReply(rep.REP) if proxy.protocol.name.startswith('SERVER') is False: logger.debug('[SOCKS5 %s] Successfully set up the connection to the endpoint %s ' % (sname,tname)) return True, None logger.debug('[SOCKS5 %s] BIND first set completed, port %s available!' % (sname , rep.BIND_PORT)) #bind in progress, waiting for a second reply to notify us that the remote endpoint connected back. self.bind_port = rep.BIND_PORT self.bind_progress_evt.set() #notifying that the bind port is now available on the socks server to be used if proxy.only_bind is True: return True, None rep = await asyncio.wait_for( SOCKS5Reply.from_streamreader(remote_reader), timeout=timeout ) if rep.REP != SOCKS5ReplyType.SUCCEEDED: logger.info('[SOCKS5 %s] remote end failed to connect to proxy! Reson: %s' % (sname, rep.REP.name)) raise SOCKS5ServerErrorReply(rep.REP) return True, None except Exception as e: logger.debug('[SOCKS5 %s] Error in run_socks5 %s' % (sname, e)) return False, e async def create_link(self): remote_writer = None remote_reader = None try: logger.debug('[handle_client] Client connected!') if len(self.target.proxies) > 1: logger.debug('Start chaining...') for _ in range(3, 0 , -1): #this is for HTTP auth... if remote_writer is not None: remote_writer.close() try: proxy = copy.deepcopy(self.target.proxies[0]) if len(self.target.proxies) == 1: proxy.endpoint_ip = self.target.get_ip_or_hostname() proxy.endpoint_port = self.target.port if proxy.protocol == UniProxyProto.CLIENT_WSNET: from asysocks.network.wsnet import WSNETNetwork remote_reader, remote_writer = await WSNETNetwork.open_connection( proxy.endpoint_ip, proxy.endpoint_port, proxy.wsnet_reuse, ) elif proxy.protocol == UniProxyProto.CLIENT_WSNETTEST: from asysocks.network.wsnet import WSNETNetworkTest remote_reader, remote_writer = await WSNETNetworkTest.open_connection( proxy.endpoint_ip, proxy.endpoint_port, proxy.wsnet_reuse, ) elif proxy.protocol in [UniProxyProto.CLIENT_WSNETWS, UniProxyProto.CLIENT_SSL_WSNETWS]: from asysocks.network.wsnetws import WSNETNetworkWS remote_reader, remote_writer = await WSNETNetworkWS.open_connection( proxy.endpoint_ip, proxy.endpoint_port, proxy.server_ip, proxy.server_port, proxy.protocol, proxy.agentid, proxy.timeout, ) if remote_reader is None: raise remote_writer else: remote_reader, remote_writer = await asyncio.wait_for( asyncio.open_connection( proxy.server_ip, proxy.server_port, ssl=proxy.ssl_ctx, ), timeout = proxy.timeout ) logger.debug('Connected to socks server!') except: logger.debug('Failed to connect to SOCKS server!') raise try: for i, proxy in enumerate(self.target.proxies): proxy = copy.deepcopy(proxy) if i == len(self.target.proxies)-1: proxy.endpoint_ip = self.target.get_ip_or_hostname() proxy.endpoint_port = self.target.port if proxy.protocol in [UniProxyProto.CLIENT_SOCKS4, UniProxyProto.CLIENT_SSL_SOCKS4]: try: x = await asyncio.wait_for(self.run_socks4a(proxy, remote_reader, remote_writer), timeout=self.target.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, err = x if err is not None: if len(self.target.proxies) > 1 and i != len(self.target.proxies)-1: raise ProxyChainError(err) raise err continue elif proxy.protocol in [UniProxyProto.CLIENT_SOCKS5_TCP, UniProxyProto.CLIENT_SSL_SOCKS5_TCP]: try: x = await asyncio.wait_for(self.run_socks5(proxy, remote_reader, remote_writer), timeout=self.target.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, err = x if err is not None: if len(self.target.proxies) > 1 and i != len(self.target.proxies)-1: raise ProxyChainError(err) raise err continue elif proxy.protocol in [UniProxyProto.CLIENT_HTTP, UniProxyProto.CLIENT_SSL_HTTP]: try: x = await asyncio.wait_for(self.run_http(proxy, remote_reader, remote_writer, http_auth_ctx = self.http_auth_ctx), timeout=self.target.proxies[-1].timeout) except asyncio.TimeoutError: raise Exception('Proxy Connection establishment timeout') _, self.http_auth_ctx, err = x if err is not None: if len(self.target.proxies) > 1 and i != len(self.target.proxies)-1: raise ProxyChainError(err) raise err continue elif proxy.protocol in [UniProxyProto.CLIENT_WSNET, UniProxyProto.CLIENT_WSNETWS, UniProxyProto.CLIENT_SSL_WSNETWS, UniProxyProto.CLIENT_WSNETTEST]: if i != 0: raise Exception("WSNET only supported as the first proxy in chain!") continue else: raise Exception('Unknown SOCKS version! "%s"' % proxy.protocol) else: # no need to do more iterations because of HTTP at this point break except HTTPProxyAuthRequiredException: continue except: raise return remote_reader, remote_writer except Exception as e: logger.exception('[handle_client]') if remote_writer is not None: remote_writer.close() raise async def connect(self): packetizer = copy.deepcopy(self.packetizer) if len(self.target.proxies) > 0: reader, writer = await self.create_link() if self.target.protocol == UniProto.CLIENT_SSL_TCP: ssl_ctx = self.target.get_ssl_context() packetizer = PacketizerSSL(ssl_ctx, packetizer) await packetizer.do_handshake(reader, writer) else: if self.target.protocol == UniProto.CLIENT_TCP: reader, writer = await asyncio.open_connection(self.target.get_ip_or_hostname(), self.target.port) elif self.target.protocol == UniProto.CLIENT_SSL_TCP: reader, writer = await asyncio.open_connection(self.target.get_ip_or_hostname(), self.target.port) ssl_ctx = self.target.get_ssl_context() packetizer = PacketizerSSL(ssl_ctx, packetizer) await packetizer.do_handshake(reader, writer) else: raise Exception('Unknown protocol "%s"' % self.target.protocol) return UniConnection(reader, writer, packetizer) async def amain(): import logging logger.setLevel(logging.DEBUG) target = UniTarget() target.hostname = 'google.com' target.port = 443 target.protocol = UniProto.CLIENT_SSL_TCP target.timeout = 10 target.ssl_ctx = None packetizer = Packetizer() client = UniClient(target, packetizer) connection = await client.connect() await connection.write(b'GET / HTTP/1.1\r\nHost: google.com\r\n\r\n') async for data in connection.read(): print(data) def main(): asyncio.run(amain()) if __name__ == '__main__': main()././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8216293 asysocks-0.2.2/asysocks/unicomm/common/0000755000000000000000000000000014310720220016675 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659646241.0 asysocks-0.2.2/asysocks/unicomm/common/__init__.py0000664000000000000000000000000014273030441021005 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1662324077.0 asysocks-0.2.2/asysocks/unicomm/common/connection.py0000664000000000000000000000440614305206555021432 0ustar00rootrootimport ssl import asyncio from asysocks.unicomm.common.packetizers import Packetizer, StreamPacketizer from asysocks.unicomm.common.packetizers.ssl import PacketizerSSL class UniConnection: def __init__(self, reader:asyncio.StreamReader, writer:asyncio.StreamWriter, packetizer:Packetizer): self.reader = reader self.writer = writer self.packetizer = packetizer self.packetizer_task = None self.closing = False async def __aenter__(self): return self async def __aexit__(self, exc_type, exc, tb): await self.close() def get_peer_certificate(self): return self.packetizer.get_peer_certificate() def change_packetizer(self, packetizer): rem_data = self.packetizer.flush_buffer() if isinstance(self.packetizer, PacketizerSSL): self.packetizer.packetizer = packetizer else: self.packetizer = packetizer def packetizer_control(self, *args, **kw): return self.packetizer.packetizer_control(*args, **kw) async def wrap_ssl(self, ssl_ctx = None, packetizer = None): if packetizer is None: packetizer = self.packetizer if ssl_ctx is None: ssl_ctx = ssl.create_default_context() ssl_ctx.check_hostname = False ssl_ctx.verify_mode = ssl.CERT_NONE self.packetizer = PacketizerSSL(ssl_ctx, packetizer) await self.packetizer.do_handshake(self.reader, self.writer) async def close(self): self.closing = True if self.writer is not None: self.writer.close() async def drain(self): return async def write(self, data): async for packet in self.packetizer.data_out(data): self.writer.write(packet) await self.writer.drain() async def read_one(self): async for packet in self.read(): return packet async def read(self): try: data = None while self.closing is False: async for result in self.packetizer.data_in(data): if result is None: break yield result data = await self.reader.read(self.packetizer.buffer_size) if data == b'': break except Exception as e: yield None async def stream(self): if not isinstance(self.packetizer, StreamPacketizer): raise Exception('This function onaly available when StreamPacketizer is used!') while True: data = await self.reader.read(self.packetizer.buffer_size) await self.packetizer.data_in(data) if data == b'': break././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8216293 asysocks-0.2.2/asysocks/unicomm/common/packetizers/0000755000000000000000000000000014310720220021221 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1662211026.0 asysocks-0.2.2/asysocks/unicomm/common/packetizers/__init__.py0000664000000000000000000000501314304651722023350 0ustar00rootrootimport asyncio class Packetizer: def __init__(self, buffer_size = 65535): self.buffer_size = buffer_size def packetizer_control(self, *args, **kw): return None def flush_buffer(self): return b'' def set_buffersize(self, buffer_size:int): self.buffer_size = buffer_size async def data_out(self, data): yield data async def data_in(self, data): yield data class StreamPacketizer: def __init__(self, buffer_size = 65535): self.buffer_size = buffer_size self.buffer = b'' self.stream_ended = asyncio.Event() self.__read_lock = asyncio.Lock() self.data_incoming_evt = asyncio.Event() async def terminate(self): pass def packetizer_control(self, *args, **kw): return None def flush_buffer(self): return b'' def set_buffersize(self, buffer_size:int): self.buffer_size = buffer_size async def readuntil(self, end = b'\n'): if self.stream_ended.is_set(): raise Exception('Stream ended!') if self.__read_lock.locked(): raise Exception('A read operation is already in progress!') async with self.__read_lock: while self.buffer.find(end) == -1: await self.data_incoming_evt.wait() self.data_incoming_evt.clear() m = self.buffer.find(end) + len(end) res = self.buffer[:m] self.buffer = self.buffer[m:] return res async def readexactly(self, n): if self.stream_ended.is_set(): raise Exception('Stream ended!') if n < 0: raise Exception('N must be >0') if n == 0: return b'' if self.__read_lock.locked(): raise Exception('A read operation is already in progress!') async with self.__read_lock: while len(self.buffer) < n: await self.data_incoming_evt.wait() self.data_incoming_evt.clear() res = self.buffer[:n] self.buffer = self.buffer[n:] return res async def read(self, n = -1): if self.stream_ended.is_set(): raise Exception('Stream ended!') if self.__read_lock.locked(): raise Exception('A read operation is already in progress!') async with self.__read_lock: while len(self.buffer) == 0 or len(self.buffer) < n: await self.data_incoming_evt.wait() self.data_incoming_evt.clear() if n == -1: n = len(self.buffer) res = self.buffer[:n] self.buffer = self.buffer[n:] return res async def data_out(self, data): yield data async def data_in(self, data): if self.stream_ended.is_set() and data != b'': raise Exception('More data incoming after stream has ended!') if data == b'': self.stream_ended.set() else: self.buffer += data self.data_incoming_evt.set() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661771735.0 asysocks-0.2.2/asysocks/unicomm/common/packetizers/ssl.py0000664000000000000000000000502214303117727022413 0ustar00rootrootimport ssl from asysocks.unicomm.common.packetizers import Packetizer class PacketizerSSL(Packetizer): def __init__(self, ssl_ctx, packetizer:Packetizer): Packetizer.__init__(self, 16384) self.ssl_ctx:ssl.SSLContext = ssl_ctx self.packetizer = packetizer self.tls_in_buff:ssl.MemoryBIO = None self.tls_out_buff:ssl.MemoryBIO = None self.tls_obj:ssl.SSLObject = None def flush_buffer(self): return self.packetizer.flush_buffer() def set_buffersize(self, buffer_size:int): self.packetizer.set_buffersize(buffer_size) def get_peer_certificate(self): return self.tls_obj.getpeercert(binary_form=True) def packetizer_control(self, *args, **kwargs): self.packetizer.packetizer_control(*args, **kwargs) async def do_handshake(self, reader, writer): self.tls_in_buff = ssl.MemoryBIO() self.tls_out_buff = ssl.MemoryBIO() self.tls_obj = self.ssl_ctx.wrap_bio(self.tls_in_buff, self.tls_out_buff, server_side=False) # , server_hostname = self.monitor.dst_hostname ctr = 0 while True: ctr += 1 try: self.tls_obj.do_handshake() except ssl.SSLWantReadError: #print('DST want %s' % ctr) while True: client_hello = self.tls_out_buff.read() if client_hello != b'': #print('DST client_hello %s' % len(client_hello)) writer.write(client_hello) await writer.drain() else: break #print('DST wating server hello %s' % ctr) server_hello = await reader.read(self.buffer_size) #print('DST server_hello %s' % len(server_hello)) self.tls_in_buff.write(server_hello) continue except: raise else: #print('DST handshake ok %s' % ctr) server_fin = self.tls_out_buff.read() #print('DST server_fin %s ' % server_fin) if server_fin != b'': writer.write(server_fin) await writer.drain() break async def data_out(self, data:bytes): # TODO: ovbiously this is not sufficient for a reliable TLS connection, pls add necessary logic outdata = b'' async for packetraw in self.packetizer.data_out(data): outdata += packetraw self.tls_obj.write(outdata) while True: raw = self.tls_out_buff.read() if raw != b'': yield raw continue break async def data_in(self, encdata:bytes): # TODO: ovbiously this is not sufficient for a reliable TLS connection, pls add necessary logic if encdata is None: yield encdata self.tls_in_buff.write(encdata) while True: try: data = self.tls_obj.read() except ssl.SSLWantReadError: break async for packet in self.packetizer.data_in(data): yield packet././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661769959.0 asysocks-0.2.2/asysocks/unicomm/common/proxy.py0000664000000000000000000001535614303114347020455 0ustar00rootrootimport os import ssl import enum from typing import List from urllib.parse import urlparse, parse_qs def stru(x): return str(x).upper() class UniProxyProto(enum.Enum): CLIENT_SOCKS4 = 1 CLIENT_SSL_SOCKS4 = 2 CLIENT_SOCKS5_TCP = 3 CLIENT_SOCKS5_UDP = 4 CLIENT_SSL_SOCKS5_TCP = 5 CLIENT_SSL_SOCKS5_UDP = 6 CLIENT_HTTP = 7 CLIENT_SSL_HTTP = 8 CLIENT_WSNET = 9 CLIENT_WSNETTEST = 999 CLIENT_WSNETWS = 9 CLIENT_SSL_WSNETWS = 11 proxyshort_to_type = { 'SOCKS4' : UniProxyProto.CLIENT_SOCKS4, 'SOCKS4S' : UniProxyProto.CLIENT_SSL_SOCKS4, 'SOCKS5' : UniProxyProto.CLIENT_SOCKS5_TCP, 'SOCKS5U' : UniProxyProto.CLIENT_SOCKS5_UDP, 'SOCKS5S' : UniProxyProto.CLIENT_SSL_SOCKS5_TCP, 'HTTP' : UniProxyProto.CLIENT_HTTP, 'HTTPS' : UniProxyProto.CLIENT_SSL_HTTP, 'WSNET' : UniProxyProto.CLIENT_WSNET, 'WSNETTEST' : UniProxyProto.CLIENT_WSNETTEST, 'WSNETWS' : UniProxyProto.CLIENT_WSNETWS, 'WSNETWSS' : UniProxyProto.CLIENT_SSL_WSNETWS, } proxyshort_protocol_defport = { UniProxyProto.CLIENT_SOCKS4 : 1080, UniProxyProto.CLIENT_SSL_SOCKS4 : 1080, UniProxyProto.CLIENT_SOCKS5_TCP: 1080, UniProxyProto.CLIENT_SOCKS5_UDP: 1080, UniProxyProto.CLIENT_SSL_SOCKS5_TCP: 1080, UniProxyProto.CLIENT_HTTP : 8080, UniProxyProto.CLIENT_SSL_HTTP :8443, UniProxyProto.CLIENT_WSNET: 8700, UniProxyProto.CLIENT_WSNETTEST: 8700, UniProxyProto.CLIENT_WSNETWS:8700, UniProxyProto.CLIENT_SSL_WSNETWS:8765, } def urlparam_proto(x): return proxyshort_to_type[x.upper()] uniproxytarget_urlparams_param2var = { 'type' : ('protocol', [stru, urlparam_proto]), 'host' : ('server_ip', [str]), 'server' : ('server_ip', [str]), 'port' : ('server_port', [int]), 'bind' : ('is_bind', [bool]), 'timeout': ('timeout', [int]), 'etimeout' : ('endpoint_timeout', [int]), 'bsize' : ('buffer_size', [int]), 'user' : ('username', [str]), 'pass' : ('password', [str]), #'authtype' : ('authtype', [SOCKS5Method]), 'userid' : ('userid', [str]), 'agentid' : ('agentid', [str]), } class UniProxyTarget: def __init__(self): self.server_ip:str = None self.server_port:int = None self.agentid:str = None self.protocol:UniProxyProto = None self.timeout:int = 10 self.ssl_ctx:ssl.SSLContext = None self.credential = None self.endpoint_ip:str = None self.endpoint_port:int = None self.wsnet_reuse:bool = False self.userid = os.urandom(4).hex().encode('ascii') self.only_open = False #These params used for security testing only! self.only_auth = False #These params used for security testing only! self.only_bind = False #These params used for security testing only! def get_sname(self): return '%s:%s' % (self.server_ip, self.server_port) def get_tname(self): return '%s:%s' % (self.endpoint_ip, self.endpoint_port) def __repr__(self): return str(self.__dict__) def __str__(self): t = '==== UniProxyTarget ====\r\n' for k in self.__dict__: t += '%s: %s\r\n' % (k, self.__dict__[k]) return t @staticmethod def from_url_params(query, hostname, endpoint_port = None): lastproxy = UniProxyTarget() lastproxy.endpoint_ip = hostname lastproxy.endpoint_port = int(endpoint_port) if query is not None: proxycounts = [0] proxynums = {'0' : None} for k in query: if k.startswith('proxy'): try: int(k[5]) if k[5] not in proxynums: proxynums[k[5]] = None proxycounts.append(int(k[5])) except Exception as e: #print(e) pass #print(proxynums) #print(proxycounts) if len(proxycounts) != len(proxynums): raise Exception('proxyies are not in sequential order! ERROR!') proxycounts.sort() firstiter = True prevproxy = lastproxy for i in proxycounts[::-1]: pdata = UniProxyTarget() if firstiter is True: firstiter = False pdata = lastproxy else: pdata.endpoint_ip = prevproxy.server_ip pdata.endpoint_port = prevproxy.server_port prevproxy = pdata startstring = 'proxy%s' % i if i == 0: startstring = 'proxy' for k in query: if k.startswith(startstring): startpos = 6 if i == 0: startpos = 5 if k[startpos:] in uniproxytarget_urlparams_param2var: data = query[k][0] for c in uniproxytarget_urlparams_param2var[k[startpos:]][1]: #print(c) data = c(data) setattr( pdata, uniproxytarget_urlparams_param2var[k[startpos:]][0], data ) proxynums[str(i)] = pdata #if len(proxynums) > 1: # for k in proxynums: # if proxynums[k].version in sockssslversions: # raise Exception('SSL in proxy chaining not supported! That would be a lot of work...') #else: # if proxynums['0'].version in sockssslversions: # proxynums['0'].ssl_ctx = ssl.create_default_context() #for k in proxynums: # proxynums[k].sanity_check() targets = [] for i in proxycounts: targets.append(proxynums[str(i)]) return targets @staticmethod def from_url(url_str, endpoint_port = None): """ """ url = urlparse(url_str) endpoint_ip = url.hostname if url.port: endpoint_port = int(url.port) else: endpoint_port = int(endpoint_port) query = None if url.query is not None: query = parse_qs(url.query) return UniProxyTarget.from_url_params(query, endpoint_ip, endpoint_port) @staticmethod def from_url_full(url_str, endpoint_ip, endpoint_port): """socks5+password://TEST\\Administrator:Password!1@127.0.0.1""" result = [] if isinstance(url_str, list): for url in url_str[::-1]: res = UniProxyTarget.from_url_full(url, endpoint_ip, endpoint_port) result += res endpoint_ip = res[0].server_ip endpoint_port = res[0].server_port return result[::-1] url = urlparse(url_str) proto, auth = url.scheme.upper().split('+') protocol = proxyshort_to_type[proto] query = None if url.query is not None: query = parse_qs(url.query) params = {} for k in query: if k in uniproxytarget_urlparams_param2var: data = query[k][0] for c in uniproxytarget_urlparams_param2var[k][1]: data = c(data) params[k] = data credential = None if url.username is not None or url.password is not None: credential = (url.username, url.password) pt = UniProxyTarget() pt.server_ip = url.hostname pt.server_port = url.port if url.port is not None else proxyshort_protocol_defport[protocol] pt.protocol= protocol pt.endpoint_ip = endpoint_ip pt.endpoint_port = endpoint_port pt.credential = credential pt.agentid = params.get('agentid') pt.timeout = params.get('timeout', 10) return [pt] if __name__ == '__main__': a = "socks5+password://TEST\\Administrator:Password!1@127.0.0.1" b = "socks5+password://TEST\\Administrator:Password!1@127.0.0.1" c = "socks5+password://TEST\\Administrator:Password!1@127.0.0.1" res = UniProxyTarget.from_url_full([a,b,c], None, None) for r in res: print(r)././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8256292 asysocks-0.2.2/asysocks/unicomm/common/scanner/0000755000000000000000000000000014310720220020326 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660647434.0 asysocks-0.2.2/asysocks/unicomm/common/scanner/__init__.py0000664000000000000000000000000014276674012022451 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661125343.0 asysocks-0.2.2/asysocks/unicomm/common/scanner/common.py0000664000000000000000000000610114300541337022201 0ustar00rootrootimport enum import os import datetime import traceback class ScannerResultType(enum.Enum): STARTED = 'STARTED' ERROR = 'ERROR' DATA = 'DATA' PROGRESS = 'PROGRESS' FINISHED = 'FINISHED' INFO = 'INFO' class ScannerResult: def __init__(self, type, resid, data = None): self.type = type self.resid = str(resid) self.data = data def to_line(self, separator = '\t'): raise NotImplementedError() class ScannerStarted(ScannerResult): def __init__(self, scannername): ScannerResult.__init__( self, ScannerResultType.STARTED, scannername ) def to_line(self, separator = '\t'): return separator.join(['STARTED', '%s' % self.type]) class ScannerFinished(ScannerResult): def __init__(self, scannername): ScannerResult.__init__( self, ScannerResultType.FINISHED, scannername ) def to_line(self, separator = '\t'): return separator.join(['FINISHED','%s' % self.type]) class ScannerError(ScannerResult): def __init__(self, resid, error): ScannerResult.__init__( self, ScannerResultType.ERROR, resid, error ) self.traceback = None if isinstance(error, Exception) is True: self.traceback = error.__traceback__ self.data = repr(error) def to_line(self, separator = '\t'): return separator.join(['ERROR', str(self.resid), str(self.data)]) #.replace('\r','').replace('\n', '').replace('\t', ' ') def to_traceback(self): if self.traceback is not None: return ''.join(traceback.format_tb(self.traceback)) class ScannerData(ScannerResult): def __init__(self, resid, data): ScannerResult.__init__( self, ScannerResultType.DATA, resid, data ) def get_name(self): try: return self.data.get_name() except: return str(type(self.data).__name__) def get_fname(self): try: return self.data.get_fname() except: return 'scandata_%s_%s.bin' % (os.urandom(4).hex(), datetime.datetime.now().strftime("%Y%m%d_%H%M%S")) def get_fdata(self): try: return self.data.get_fdata() except: return None def __flatten_data(self): try: return self.data.to_line() except: return str(self.data) def to_line(self, separator = '\t'): res = '' for line in self.__flatten_data().split('\n'): line = line.strip() res += separator.join([str(self.resid), line])# + '\r\n' return res class ScannerProgress(ScannerResult): def __init__(self, scannername, total, current): ScannerResult.__init__( self, ScannerResultType.PROGRESS, scannername ) self.total = total self.current = current def to_percent(self): if self.total is None or self.total == 0: return 'x' return (self.current/self.total)*100 def to_line(self, separator = '\t'): return separator.join(['PROGRESS', '%s\\%s (%s%%)' % (self.total, self.current, self.to_percent())]) class ScannerInfo(ScannerResult): def __init__(self, resid, info): ScannerResult.__init__( self, ScannerResultType.INFO, resid, info ) def to_line(self, separator = '\t'): res = '' for line in str(self.data).split('\n'): line = line.strip() res += separator.join(['INFO', str(self.resid), line]) + '\r\n' return res././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661098977.0 asysocks-0.2.2/asysocks/unicomm/common/scanner/scanner.py0000664000000000000000000001207514300455741022354 0ustar00rootrootimport asyncio import traceback from tqdm import tqdm import datetime import sys from asysocks.unicomm.common.scanner.common import * class UniScannerExecutor: def __init__(self): pass async def run(self, targetid, target, out_queue): await out_queue.put(ScannerData(targetid, 'alma')) class UniScanner: def __init__(self, name, executors, target_generators, worker_count = 100, host_timeout = 5): self.name = name self.target_generators = target_generators self.worker_count = worker_count self.host_timeout = host_timeout self.__workers = [] self.__targetgen = None self.out_queue = asyncio.Queue() self.__total_items = 0 self.__finished_items = 0 self.scantime = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") self.executors = executors if isinstance(self.executors, list) is False: self.executors = [self.executors] if isinstance(self.target_generators, list) is False: self.target_generators = [self.target_generators] async def worker(self): while True: x = await self.__targetgen.__anext__() if x is None: return targetid, target = x for executor in self.executors: try: await asyncio.wait_for(executor.run(targetid, target, self.out_queue), self.host_timeout) except Exception as e: await self.out_queue.put(ScannerError(target, e)) self.__finished_items += 1 await self.out_queue.put(ScannerProgress(self.name, self.__total_items, self.__finished_items)) async def stop(self): for worker in self.__workers: worker.cancel() async def targets(self): for generator in self.target_generators: async for targetid, target in generator.run(): yield (targetid, target) while True: yield None async def scan(self): try: for generator in self.target_generators: self.__total_items += generator.get_total() self.__targetgen = self.targets() yield ScannerStarted(self.name) for _ in range(self.worker_count): self.__workers.append(asyncio.create_task(self.worker())) gather_coro = asyncio.gather(*self.__workers) while gather_coro.done() is False or self.out_queue.qsize() > 0: try: result = await asyncio.wait_for(self.out_queue.get(), timeout = 1) yield result except asyncio.TimeoutError: continue except: break except Exception as e: yield ScannerError('!SCANNER!', e) finally: await self.stop() yield ScannerFinished(self.name) async def scan_and_process(self, progress = True, out_file = None, include_errors = False): fhandles = {} try: def update_pbar(pbar, rtype): if len(pbar) == 0: return if rtype == ScannerResultType.ERROR: pbar['errors'].update() elif rtype == ScannerResultType.PROGRESS: pbar['targets'].update() elif rtype == ScannerResultType.FINISHED: for k in pbar: pbar[k].refresh() elif rtype == ScannerResultType.DATA: pbar['results'].update() pbar = {} if progress is True: if out_file is None: out_file = os.getcwd() for generator in self.target_generators: self.__total_items += generator.get_total() pbar['targets'] = tqdm(desc='Targets ', unit='', position=0, total=self.__total_items) pbar['results'] = tqdm(desc='Results ', unit='', position=1) pbar['errors'] = tqdm(desc='Errors ', unit='', position=2) async for result in self.scan(): update_pbar(pbar, result.type) if result.type == ScannerResultType.ERROR and include_errors is True: if 'error' not in fhandles: if out_file is None: fhandles['error'] = sys.stderr else: fhandles['error'] = open(os.path.join(out_file, '%s_error_%s.tsv' % (str(self.name), self.scantime)), 'w', newline = '') fhandles['error'].write(result.to_line()+'\r\n') elif result.type == ScannerResultType.DATA: filedata = result.get_fdata() if filedata is not None: with open(result.get_fname() ,'wb') as f: f.write(filedata) continue if filedata is None: rtype = result.get_name() if rtype not in fhandles: if out_file is None: fhandles[rtype] = sys.stdout else: fhandles[rtype] = open(os.path.join(out_file, '%s_%s%s' %(rtype, self.scantime,'.tsv')), 'w', newline = '') fhandles[rtype].write(result.to_line()+'\r\n') except Exception as e: print('SCANNER CRITICAL ERROR %s' % str(e)) finally: for k in fhandles: try: fhandles[k].close() except: pass async def amain(): try: executor = UniScannerExecutor() from asysocks.unicomm.common.scanner.targetgen import UniTargetGen from aiosmb.commons.connection.factory import SMBConnectionFactory connectionfactory = SMBConnectionFactory.from_url('smb2+kerberos-password://TEST.corp\\Administrator:Passw0rd!1@win2019ad.test.corp/') scanner = UniScanner('TEST', [executor]) scanner.target_generators.append(UniTargetGen.from_list(['10.10.10.2', '10.10.10.3'])) async for x in scanner.scan(): print(x) if x.type == ScannerResultType.ERROR: print(x.data) except Exception as e: traceback.print_exc() def main(): asyncio.run(amain()) if __name__ == '__main__': main() ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661113483.0 asysocks-0.2.2/asysocks/unicomm/common/scanner/targetgen.py0000664000000000000000000000770714300512213022675 0ustar00rootroot import asyncio import ipaddress import uuid class UniCredentialGen: def __init__(self): self.usernames = {} self.passwords = {} self.credentials = [] # fixed user,password pairs self.domain = None def add_credential(self, username, password): if password is None: password = '' self.credentials.append((username, password)) def add_credential_tuple(self, t): username, password = t.split(':') self.add_credential(username, password) def add_credential_file(self, fname): with open(fname, 'r') as f: for line in f: line=line.strip() self.add_credential_tuple(line) def add_users_file(self, fname): with open(fname, 'r') as f: for line in f: line=line.strip() self.add_username(line) def add_passwords_file(self, fname): with open(fname, 'r') as f: for line in f: line=line.strip() self.add_password(line) def add_username(self, username): self.usernames[username] = 1 def add_password(self, password): if password is None: password = '' self.passwords[password] = 1 def get_total(self): return len(self.credentials) + (len(self.usernames) * len(self.passwords)) async def run(self): for username in self.usernames: for password in self.passwords: yield(username, password) for username, password in self.credentials: yield(username, password) class UniTargetGen: def __init__(self): self.targets = [] @staticmethod def from_list(tl): targetgen = UniTargetGen() targetgen.add_list(tl) return targetgen def add_list(self, targetlist): for t in targetlist: try: self.add_ip(t) except: try: self.add_file(t) except: self.add_hostname(t) def add_ip(self, ip): uids = [] try: ipaddress.ip_address(ip) uid = str(uuid.uuid4()) uids.append(uid) self.targets.append((uid, ip)) except: for t in ipaddress.ip_network(ip,strict=False): uid = str(uuid.uuid4()) uids.append(uid) self.targets.append((uid, str(t))) return uids def add_file(self, fname): uids = [] with open(fname, 'r') as f: for line in f: line=line.strip() try: uids += self.add_ip(line) except: uids += self.add_hostname(line) return uids def add_hostname(self, hosntame): uid = str(uuid.uuid4()) self.targets.append((uid, str(hosntame))) return [uid] def get_total(self): return len(self.targets) async def run(self): for tid, target in self.targets: yield (tid, target) class UniTargetPortGen: def __init__(self): self.targets = [] self.ports = {} @staticmethod def from_list(tl): targetgen = UniTargetGen() targetgen.add_list(tl) return targetgen def add_port_list(self, portranges): def calc_range(x): if x.find('-') != -1: start,end = x.split('-') for i in range(int(start), int(end)): self.ports[int(i)] = None else: self.ports[int(x)] = None for prange in portranges: if prange.find(',') != -1: for port in prange.split(','): calc_range(port) else: calc_range(prange) def add_list(self, targetlist): for t in targetlist: try: self.add_ip(t) except: try: self.add_file(t) except: self.add_hostname(t) def add_ip(self, ip): uids = [] try: ipaddress.ip_address(ip) uid = str(uuid.uuid4()) uids.append(uid) self.targets.append((uid, ip)) except: for t in ipaddress.ip_network(ip,strict=False): uid = str(uuid.uuid4()) uids.append(uid) self.targets.append((uid, str(t))) return uids def add_file(self, fname): uids = [] with open(fname, 'r') as f: for line in f: line=line.strip() try: uids += self.add_ip(line) except: uids += self.add_hostname(line) return uids def add_hostname(self, hosntame): uid = str(uuid.uuid4()) self.targets.append((uid, str(hosntame))) return [uid] def get_total(self): return len(self.targets)*len(self.ports) async def run(self): for tid, target in self.targets: for port in self.ports: yield (tid, (target,port))././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1661328893.0 asysocks-0.2.2/asysocks/unicomm/common/target.py0000664000000000000000000000775714301356775020603 0ustar00rootrootfrom os import stat import ssl import copy import enum import ipaddress from typing import Callable, Dict, List from urllib.parse import urlparse, parse_qs from asysocks.unicomm.common.proxy import UniProxyTarget from asysocks.unicomm.utils.paramprocessor import str_one, int_one, bool_one class UniProto(enum.Enum): CLIENT_TCP = 1 CLIENT_SSL_TCP = 2 CLIENT_UDP = 3 CLIENT_DTLS = 4 CLIENT_QUIC = 5 unitarget_url_params = { 'dc' : str_one, 'timeout' : int_one, 'serverip' : str_one, 'dns' : str_one, } class UniTarget: def __init__(self, ip:str, port:int, protocol:UniProto, timeout:int=5, ssl_ctx:ssl.SSLContext=None, hostname:str = None, dc_ip:str = None, domain:str = None, proxies:List[UniProxyTarget] = None, dns:str = None): self.hostname = hostname self.port = port self.protocol = protocol self.timeout = timeout self.ssl_ctx = ssl_ctx self.dc_ip = dc_ip self.domain = domain self.dns = dns self.proxies = proxies if proxies is None: self.proxies = [] try: ipaddress.ip_address(ip) self.ip = ip except: if ip is not None: self.hostname = ip self.ip = None try: ipaddress.ip_address(hostname) self.ip = hostname except: if hostname is not None: self.hostname = hostname if ip is None and hostname is None: raise Exception('Both IP and Hostname can\'t be none!') self.__update_proxy() def __update_proxy(self): if len(self.proxies) == 0: return self.proxies[-1].endpoint_ip = self.get_hostname_or_ip() self.proxies[-1].endpoint_port = self.port def get_newtarget(self, ip, port, hostname = None): return UniTarget(ip, port, self.protocol, self.timeout, ssl_ctx = None, hostname = hostname, dc_ip = self.dc_ip, domain = self.domain, proxies=copy.deepcopy(self.proxies)) def get_ssl_context(self): if self.ssl_ctx is not None: return self.ssl_ctx ssl_ctx = ssl.create_default_context() ssl_ctx.check_hostname = False ssl_ctx.verify_mode = ssl.CERT_NONE return ssl_ctx def get_hostname(self): return self.hostname def set_hostname_or_ip(self, ip): try: self.ip = str(ipaddress.ip_address(ip)) except: self.hostname = ip self.ip = ip def get_ip_or_hostname(self): if self.ip is not None: return self.ip return self.hostname def get_hostname_or_ip(self): if self.hostname is not None: return self.hostname return self.ip @staticmethod def from_url(connection_url, protocol:UniProto, port:int = None, extraparams:Dict[str, Callable] = {}): url_e = urlparse(connection_url) domain = None if url_e.username is not None: if url_e.username.find('\\') != -1: domain, username = url_e.username.split('\\') if domain == '.': domain = None else: domain = None username = url_e.username ip = url_e.hostname if url_e.port is None and port is None: raise Exception('Port must be provided!') if url_e.port and port is None: port = url_e.port params = dict.fromkeys(unitarget_url_params.keys(),None) extra = dict.fromkeys(extraparams.keys(),None) proxy_present = False if url_e.query is not None: query = parse_qs(url_e.query) for k in query: if k.startswith('proxy') is True: proxy_present = True if k in unitarget_url_params: params[k] = unitarget_url_params[k](query[k]) if k in extraparams: extra[k] = extraparams[k](query[k]) hostname = None if ip is not None: try: ipaddress.ip_address(ip) except: hostname = ip ip = None if params['serverip'] is not None: ip = params['serverip'] proxies = None if proxy_present is True: proxies = UniProxyTarget.from_url(connection_url, endpoint_port=port) timeout = params['timeout'] if params['timeout'] is not None else 5 return UniTarget( ip, port, protocol, timeout = timeout, hostname = hostname, dc_ip = params['dc'], domain=domain, proxies=proxies, dns=params['dns'] ), extra def __str__(self): t = '==== UniTarget ====\r\n' for k in self.__dict__: t += '%s: %s\r\n' % (k, self.__dict__[k]) return t././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8256292 asysocks-0.2.2/asysocks/unicomm/protocol/0000755000000000000000000000000014310720220017246 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659730718.0 asysocks-0.2.2/asysocks/unicomm/protocol/__init__.py0000664000000000000000000000000014273275436021375 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659730718.0 asysocks-0.2.2/asysocks/unicomm/protocol/http.py0000664000000000000000000000543514273275436020636 0ustar00rootrootimport asyncio import io class HTTPProxyAuthRequiredException(Exception): pass class HTTPProxyAuthFailed(Exception): pass class HTTPResponse: def __init__(self): self.version = None self.status = None self.reason = None self.headers = {} self.headers_upper = {} self.data = None @staticmethod async def from_streamreader(reader, timeout = None): try: resp = HTTPResponse() #reading headers temp = await asyncio.wait_for(reader.readuntil(b'\r\n\r\n'), timeout = timeout) temp = temp.split(b'\r\n')[:-1] version, status, reason = temp[0].split(b' ', 2) resp.version = version.decode() resp.status = int(status.decode()) resp.reason = reason.decode() for hdr_raw in temp[1:]: if hdr_raw.strip() == b'': continue key_raw, value_raw = hdr_raw.split(b': ', 1) key = key_raw.decode() value = value_raw.strip().decode() resp.headers[key] = value resp.headers_upper[key.upper()] = value if 'CONTENT-LENGTH' in resp.headers_upper: rem_len = int(resp.headers_upper['CONTENT-LENGTH']) resp.data = await asyncio.wait_for(reader.readexactly(rem_len), timeout = timeout) return resp, None except Exception as e: return None, e class HTTPRequest: def __init__(self): self.method = None self.uri = None self.version = None self.headers = {} self.headers_upper = {} self.data = None def __str__(self): t = '%s %s %s\r\n' % (self.method, self.uri, self.version) for x in self.headers: t += '%s: %s\r\n' % (x, self.headers[x]) t += '\r\n' if self.data is not None: t += '' return t def to_bytes(self): t = '%s %s %s\r\n' % (self.method, self.uri, self.version) for x in self.headers: t += '%s: %s\r\n' % (x, self.headers[x]) t += '\r\n' t = t.encode() if self.data is not None: t += self.data return t @staticmethod async def from_streamreader(reader, timeout = None, pre_data = None): try: req = HTTPRequest() #reading headers temp = await asyncio.wait_for(reader.readuntil(b'\r\n\r\n'), timeout = timeout) if pre_data is not None: temp = pre_data + temp temp = temp.split(b'\r\n')[:-1] method, uri, version = temp[0].split(b' ', 2) req.method = method.decode() req.uri = uri.decode() req.version = version.decode() for hdr_raw in temp[1:]: if hdr_raw.strip() == b'': continue key_raw, value_raw = hdr_raw.split(b': ', 1) key = key_raw.decode() value = value_raw.strip().decode() req.headers[key] = value req.headers_upper[key.upper()] = value if 'CONTENT-LENGTH' in req.headers_upper: rem_len = int(req.headers_upper['CONTENT-LENGTH']) req.data = await asyncio.wait_for(reader.readexactly(rem_len), timeout = timeout) return req, None except Exception as e: return None, e././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660584081.0 asysocks-0.2.2/asysocks/unicomm/protocol/quic.py0000664000000000000000000000617614276500221020605 0ustar00rootrootimport enum import asyncio import ssl from asysocks.unicomm import logger from aioquic.asyncio.client import connect from aioquic.asyncio.protocol import QuicConnectionProtocol from aioquic.quic.configuration import QuicConfiguration from aioquic.quic.events import ConnectionTerminated, QuicEvent, StreamDataReceived from typing import Optional, cast class QuicTransportClient(QuicConnectionProtocol): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._ack_waiter: Optional[asyncio.Future[None]] = None self.in_queue: asyncio.Queue = None self.disconnected_evt = None self.stream_id = None def connection_made(self, transport: asyncio.BaseTransport) -> None: print('Connected!') return super().connection_made(transport) async def send(self, data:bytes) -> None: if self.stream_id is None: self.stream_id = self._quic.get_next_available_stream_id() #logger.debug(f"Stream ID: {self.stream_id}") #print('Sending -> %s' % data) end_stream = False self._quic.send_stream_data(self.stream_id, data, end_stream) self.transmit() def quic_event_received(self, event: QuicEvent) -> None: if isinstance(event, StreamDataReceived): self.in_queue.put_nowait( (event.data, None) ) if isinstance(event, ConnectionTerminated): self.in_queue.put_nowait( (None, None) ) class QUICSocket: """ Generic asynchronous TCP socket class, nothing SMB related. Creates the connection and channels incoming/outgoing bytes via asynchonous queues. """ def __init__(self, socket = None, target = None): self.settings = target self.socket = socket #for future, if we want a custom soscket self.out_queue = asyncio.Queue() self.in_queue = asyncio.Queue() self.disconnected_evt = asyncio.Event() async def disconnect(self): """ Disconnects from the socket. Stops the reader and writer streams. """ if self.disconnected.is_set(): return self.disconnected.set() async def run_inner(self): try: async with connect(self.settings.hostname, self.settings.port, configuration=self.configuration, create_protocol=QuicTransportClient) as client: client = cast(QuicTransportClient, client) client.in_queue = self.in_queue client.disconnected_evt = self.disconnected_evt while not self.disconnected.is_set(): data = await self.out_queue.get() await client.send(data) except asyncio.CancelledError: #the SMB connection is terminating return except Exception as e: logger.exception('[QUICSocket] handle_outgoing') await self.disconnect() #async def connect(self, settings): #not needed parameter because we have networkselector now... async def connect(self): """ Main function to be called, connects to the target specified in settings, and starts reading/writing. """ #self.settings = settings try: self.configuration = QuicConfiguration( alpn_protocols=['smb'], is_client=True, max_datagram_frame_size=65536, verify_mode = ssl.CERT_NONE, ) self.client = asyncio.create_task(self.run_inner()) return True, None except Exception as e: logger.exception('[QUICSocket] main') return False, e ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659809045.0 asysocks-0.2.2/asysocks/unicomm/protocol/socks4.py0000664000000000000000000000621014273526425021052 0ustar00rootroot # https://ftp.icm.edu.pl/packages/socks/socks4/SOCKS4.protocol import io import os import enum import ipaddress import socket import asyncio SOCKS4_USERID_MAC_LEN = 255 class SOCKS4CDCode(enum.Enum): REQ_CONNECT = 1 REQ_BIND = 2 REP_GRANTED = 90 #request granted REP_FAILED = 91 #request rejected or failed REP_FAILED_NOCONN = 92 #request rejected becasue SOCKS server cannot connect to identd on the client REP_FAILED_USRID_MISMATCH = 93 #request rejected because the client program and identd report different user-ids class SOCKS4Request: def __init__(self): self.VN = 4 self.CD = SOCKS4CDCode.REQ_CONNECT self.DSTPORT = None self.DSTIP = None self.USERID = None @staticmethod def from_bytes(data): return SOCKS4Request.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: t = await asyncio.wait_for(reader.readuntil(b'\x00'), timeout = timeout) return SOCKS4Request.from_bytes(t), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4Request() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4CDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) o.USERID = b'' for _ in range(SOCKS4_USERID_MAC_LEN): x = buff.read(1) if x == 0: break o.USERID += x return o @staticmethod def from_target(target): o = SOCKS4Request() if target.protocol.name.startswith('SERVER') is True: SOCKS4CDCode.REQ_BIND o.DSTPORT = target.endpoint_port o.DSTIP = ipaddress.ip_address(target.endpoint_ip) o.USERID = target.userid if target.userid is None: o.USERID = os.urandom(4).hex().encode('ascii') return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed t += self.USERID t += b'\x00' #trailing for userid return t class SOCKS4Reply: def __init__(self): self.VN = 0 self.CD = None self.DSTPORT = None self.DSTIP = None @staticmethod def from_bytes(data): return SOCKS4Reply.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: t = await asyncio.wait_for(reader.readexactly(8), timeout = timeout) return SOCKS4Reply.from_bytes(t), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4Reply() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4CDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659809248.0 asysocks-0.2.2/asysocks/unicomm/protocol/socks4a.py0000664000000000000000000000743014273526740021220 0ustar00rootroot # https://www.openssh.com/txt/socks4a.protocol import io import os import enum import ipaddress import socket import asyncio SOCKS4_USERID_MAC_LEN = 255 class SOCKS4ACDCode(enum.Enum): REQ_CONNECT = 1 REQ_BIND = 2 REP_GRANTED = 90 #request granted REP_FAILED = 91 #request rejected or failed REP_FAILED_NOCONN = 92 #request rejected becasue SOCKS server cannot connect to identd on the client REP_FAILED_USRID_MISMATCH = 93 #request rejected because the client program and identd report different user-ids class SOCKS4ARequest: def __init__(self): self.VN = 4 self.CD = SOCKS4ACDCode.REQ_CONNECT self.DSTPORT = None self.DSTIP = None self.USERID = None self.DOMAIN = None @staticmethod def from_bytes(data): return SOCKS4ARequest.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: buff = b'' t = await asyncio.wait_for(reader.readexactly(4), timeout = timeout) buff += t t = await asyncio.wait_for(reader.readexactly(4), timeout = timeout) buff += t r = 1 if t[0:3] == b'\x00\x00\x00': r = 2 for _ in range(0,r): t = await asyncio.wait_for(reader.readuntil(b'\x00'), timeout = timeout) buff += t return SOCKS4ARequest.from_bytes(buff), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4ARequest() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4ACDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) o.USERID = b'' for _ in range(SOCKS4_USERID_MAC_LEN): x = buff.read(1) if x == 0: break o.USERID += x if str(o.DSTIP).startswith('0.0.0.'): for _ in range(SOCKS4_USERID_MAC_LEN): x = buff.read(1) if x == 0: break o.DOMAIN += x return o @staticmethod def from_target(target): o = SOCKS4ARequest() if target.protocol.name.startswith('SERVER') is True: SOCKS4ACDCode.REQ_BIND o.DSTPORT = target.endpoint_port try: endpoint_ip = ipaddress.ip_address(target.endpoint_ip) o.DSTIP = endpoint_ip except: o.DSTIP = ipaddress.ip_address('0.0.0.3') o.DOMAIN = str(target.endpoint_ip) o.USERID = target.userid if target.userid is None: o.USERID = os.urandom(4).hex().encode('ascii') return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed t += self.USERID t += b'\x00' #trailing for userid if self.DOMAIN is not None: t += self.DOMAIN.encode() t += b'\x00' return t class SOCKS4AReply: def __init__(self): self.VN = 0 self.CD = None self.DSTPORT = None self.DSTIP = None @staticmethod def from_bytes(data): return SOCKS4AReply.from_buffer(io.BytesIO(data)) @staticmethod async def from_streamreader(reader, timeout = None): try: t = await asyncio.wait_for(reader.readexactly(8), timeout = timeout) return SOCKS4AReply.from_bytes(t), None except Exception as e: return None, e @staticmethod def from_buffer(buff): o = SOCKS4AReply() o.VN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) o.CD = SOCKS4ACDCode(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) o.DSTPORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) o.DSTIP = ipaddress.IPv4Address(buff.read(4)) return o def to_bytes(self): t = self.VN.to_bytes(1, byteorder = 'big', signed = False) t += self.CD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.DSTPORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DSTIP.packed return t ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1659874796.0 asysocks-0.2.2/asysocks/unicomm/protocol/socks5.py0000664000000000000000000004761014273726754021073 0ustar00rootroot#https://www.ietf.org/rfc/rfc1928.txt #https://tools.ietf.org/html/rfc1929 #https://tools.ietf.org/html/rfc1961 import io import enum import ipaddress import socket import asyncio from asysocks.common.constants import SOCKS5Method class SOCKS5ServerState(enum.Enum): NEGOTIATION = 0 NOT_AUTHENTICATED = 1 REQUEST = 3 RELAYING = 4 class SOCKS5Command(enum.Enum): CONNECT = 0x01 BIND = 0x02 UDP_ASSOCIATE = 0x03 class SOCKS5AddressType(enum.Enum): IP_V4 = 0x01 DOMAINNAME = 0x03 IP_V6 = 0x04 class SOCKS5ReplyType(enum.Enum): SUCCEEDED = 0x00 # o X'00' succeeded FAILURE = 0x01 # o X'01' general SOCKS server failure CONN_NOT_ALLOWED = 0x02 # o X'02' connection not allowed by ruleset NETWORK_UNREACHABLE = 0x03 #o X'03' Network unreachable HOST_UNREACHABLE = 0x04 #o X'04' Host unreachable CONN_REFUSED = 0x05 #o X'05' Connection refused TTL_EXPIRED = 0x06 #o X'06' TTL expired COMMAND_NOT_SUPPORTED = 0x07 #o X'07' Command not supported ADDRESS_TYPE_NOT_SUPPORTED = 0x08 #o X'08' Address type not supported #o X'09' to X'FF' unassigned class SOCKS5ServerErrorReply(Exception): def __init__(self, reply): self.reply = reply def __str__(self): return self.reply.name class SOCKS5AuthFailed(Exception): pass class SOCKS5SocketParser: def __init__(self, protocol = socket.SOCK_STREAM): self.protocol = protocol def parse(self, soc, packet_type): return packet_type.from_bytes(self.read_soc(soc, packet_type.size)) def read_soc(self, soc, size): data = b'' while True: temp = soc.recv(4096) if temp == '': break data += temp if len(data) == size: break return data class SOCKS5CommandParser: # the reason we need this class is: SOCKS5 protocol messages doesn't have a type field, # the messages are parsed in context of the session itself. def __init__(self, protocol = socket.SOCK_STREAM): self.protocol = protocol #not used atm def parse(self, buff, session): if session.current_state == SOCKS5ServerState.NEGOTIATION: return SOCKS5Nego.from_buffer(buff) if session.current_state == SOCKS5ServerState.NOT_AUTHENTICATED: if session.mutual_auth_type == SOCKS5Method.PLAIN: return SOCKS5PlainAuth.from_buffer(buff) else: raise Exception('Not implemented!') if session.current_state == SOCKS5ServerState.REQUEST: return SOCKS5Request.from_buffer(buff) @staticmethod async def from_streamreader(reader, session, timeout = None): raise NotImplementedError() #if session.current_state == SOCKS5ServerState.NEGOTIATION: # t = await asyncio.wait_for(SOCKS5Nego.from_streamreader(reader), timeout = timeout) # return t # #if session.current_state == SOCKS5ServerState.NOT_AUTHENTICATED: # if session.mutual_auth_type == SOCKS5Method.PLAIN: # t = await asyncio.wait_for(SOCKS5PlainAuth.from_streamreader(reader), timeout = timeout) # return t # else: # raise Exception('Not implemented!') # #if session.current_state == SOCKS5ServerState.REQUEST: # t = await asyncio.wait_for(SOCKS5Request.from_streamreader(reader), timeout = timeout) # return t class SOCKS5AuthHandler: def __init__(self, authtype, creds = None): self.authtype = authtype self.creds = creds def do_AUTH(self, msg): if self.authtype == SOCKS5Method.PLAIN: if not isinstance(msg, SOCKS5PlainAuth): raise Exception('Wrong message/auth type!') if self.creds is None: return True, SOCKS5PlainCredentials(msg.UNAME, msg.PASSWD) else: if msg.UNAME in self.creds: if msg.PASSWD == self.creds[msg.UNAME]: return True, SOCKS5PlainCredentials(msg.UNAME, msg.PASSWD) return False, SOCKS5PlainCredentials(msg.UNAME, msg.PASSWD) elif self.authtype == SOCKS5Method.GSSAPI: raise Exception('Not implemented! yet') else: raise Exception('Not implemented!') class SOCKS5PlainCredentials: def __init__(self, username, password): self.username = username self.password = password class SOCKS5PlainAuthReply: def __init__(self): self.VER = None self.STATUS = None @staticmethod async def from_streamreader(reader): rep = SOCKS5PlainAuthReply() t = await reader.read(1) rep.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(1) rep.STATUS = SOCKS5ReplyType(int.from_bytes(t, byteorder = 'big', signed = False)) return rep @staticmethod def from_bytes(data): return SOCKS5PlainAuthReply.from_buffer(io.BytesIO(data)) @staticmethod def from_buffer(buff): rep = SOCKS5PlainAuthReply() rep.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.STATUS = SOCKS5ReplyType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) return rep class SOCKS5PlainAuth: def __init__(self): self.VER = None self.ULEN = None self.UNAME = None self.PLEN = None self.PASSWD = None @staticmethod async def from_streamreader(reader): auth = SOCKS5PlainAuth() t = await reader.read(1) auth.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(1) auth.ULEN = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(auth.ULEN) auth.UNAME = t.decode() t = await reader.read(1) auth.PLEN = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.read(auth.PLEN) auth.PASSWD = t.decode() return auth @staticmethod def from_bytes(bbuff): return SOCKS5PlainAuth.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): auth = SOCKS5PlainAuth() auth.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) auth.ULEN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) auth.UNAME = buff.read(auth.ULEN).decode() auth.PLEN = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) auth.PASSWD = buff.read(auth.PLEN).decode() return auth @staticmethod def construct(username, password): auth = SOCKS5PlainAuth() auth.VER = 1 auth.ULEN = len(username) auth.UNAME = username auth.PLEN = len(password) auth.PASSWD = password return auth def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.ULEN.to_bytes(1, byteorder = 'big', signed = False) t += self.UNAME.encode() t += self.PLEN.to_bytes(1, byteorder = 'big', signed = False) t += self.PASSWD.encode() return t class SOCKS5Nego: def __init__(self): self.VER = 5 self.NMETHODS = None self.METHODS = None @staticmethod async def from_streamreader(reader): nego = SOCKS5Nego() t = await reader.readexactly(1) nego.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) nego.NMETHODS = int.from_bytes(t, byteorder = 'big', signed = False) nego.METHODS = [] for _ in range(nego.NMETHODS): t = await reader.readexactly(1) nego.METHODS.append(SOCKS5Method(int.from_bytes(t, byteorder = 'big', signed = False))) return nego @staticmethod def from_bytes(bbuff): return SOCKS5Nego.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): nego = SOCKS5Nego() nego.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) nego.NMETHODS = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) nego.METHODS = [] for _ in range(nego.NMETHODS): nego.METHODS.append(SOCKS5Method(int.from_bytes(buff.read(1), byteorder = 'big', signed = False))) return nego @staticmethod def from_methods(methods): if not isinstance(methods, list): methods = [methods] nego = SOCKS5Nego() nego.NMETHODS = len(methods) nego.METHODS = methods return nego def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.NMETHODS.to_bytes(1, byteorder = 'big', signed = False) for method in self.METHODS: t += method.value.to_bytes(1, byteorder = 'big', signed = False) return t class SOCKS5NegoReply: def __init__(self): self.VER = 5 self.METHOD = None def __repr__(self): t = '== SOCKS5NegoReply ==\r\n' t += 'VER: %s\r\n' % self.VER t += 'METHOD: %s\r\n' % self.METHOD return t @staticmethod def from_socket(soc): data = b'' total_size = 2 while True: temp = soc.recv(1024) if temp == b'': break data += temp if len(data) >= total_size: break return SOCKS5NegoReply.from_bytes(data) @staticmethod async def from_streamreader(reader): rep = SOCKS5NegoReply() t = await reader.readexactly(1) rep.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.METHOD = SOCKS5Method(int.from_bytes(t, byteorder = 'big', signed = False)) return rep @staticmethod def from_bytes(bbuff): return SOCKS5NegoReply.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rep = SOCKS5NegoReply() rep.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.METHOD = SOCKS5Method(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) return rep @staticmethod def construct(method): rep = SOCKS5NegoReply() rep.VER = 5 rep.METHOD = method return rep @staticmethod def construct_auth(method, ver = 1): rep = SOCKS5NegoReply() rep.VER = ver rep.METHOD = method return rep def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.METHOD.value.to_bytes(1, byteorder = 'big', signed = False) return t class SOCKS5Request: def __init__(self): self.VER = 5 self.CMD = SOCKS5Command.CONNECT self.RSV = 0 self.ATYP = None self.DST_ADDR = None self.DST_PORT = None @staticmethod async def from_streamreader(reader): req = SOCKS5Request() t = await reader.readexactly(1) req.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) req.CMD = SOCKS5Command(int.from_bytes(t, byteorder = 'big', signed = False)) t = await reader.readexactly(1) req.RSV = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) req.ATYP = SOCKS5AddressType(int.from_bytes(t, byteorder = 'big', signed = False)) if req.ATYP == SOCKS5AddressType.IP_V4: t = await reader.readexactly(4) req.DST_ADDR = ipaddress.IPv4Address(t) elif req.ATYP == SOCKS5AddressType.IP_V6: t = await reader.readexactly(16) req.DST_ADDR = ipaddress.IPv6Address(t) elif req.ATYP == SOCKS5AddressType.DOMAINNAME: t = await reader.readexactly(1) length = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(length) req.DST_ADDR = t.decode() t = await reader.readexactly(2) req.DST_PORT = int.from_bytes(t, byteorder = 'big', signed = False) return req @staticmethod def from_bytes(bbuff): return SOCKS5Request.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): req = SOCKS5Request() req.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) req.CMD = SOCKS5Command(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) req.RSV = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) req.ATYP = SOCKS5AddressType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) if req.ATYP == SOCKS5AddressType.IP_V4: req.DST_ADDR = ipaddress.IPv4Address(buff.read(4)) elif req.ATYP == SOCKS5AddressType.IP_V6: req.DST_ADDR = ipaddress.IPv6Address(buff.read(16)) elif req.ATYP == SOCKS5AddressType.DOMAINNAME: length = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) req.DST_ADDR = buff.read(length).decode() req.DST_PORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) return req @staticmethod def from_target(target): req = SOCKS5Request() req.CMD = SOCKS5Command.CONNECT if target.protocol.name.startswith('SERVER') is True: req.CMD = SOCKS5Command.BIND try: endpoint_ip = ipaddress.ip_address(target.endpoint_ip) if endpoint_ip.version == 4: req.ATYP = SOCKS5AddressType.IP_V4 req.DST_ADDR = endpoint_ip elif endpoint_ip.version == 6: req.ATYP = SOCKS5AddressType.IP_V6 req.DST_ADDR = endpoint_ip except: req.ATYP = SOCKS5AddressType.DOMAINNAME req.DST_ADDR = target.endpoint_ip req.DST_PORT = target.endpoint_port return req @staticmethod def construct(cmd, address, port): req = SOCKS5Request() req.VER = 5 req.CMD = cmd req.RSV = 0 try: endpoint_ip = ipaddress.ip_address(address) if endpoint_ip.version == 4: req.ATYP = SOCKS5AddressType.IP_V4 req.DST_ADDR = endpoint_ip elif endpoint_ip.version == 6: req.ATYP = SOCKS5AddressType.IP_V6 req.DST_ADDR = endpoint_ip except: req.ATYP = SOCKS5AddressType.DOMAINNAME req.DST_ADDR = address req.DST_PORT = port return req def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.CMD.value.to_bytes(1, byteorder = 'big', signed = False) t += self.RSV.to_bytes(1, byteorder = 'big', signed = False) t += self.ATYP.value.to_bytes(1, byteorder = 'big', signed = False) if self.ATYP == SOCKS5AddressType.DOMAINNAME: t += len(self.DST_ADDR).to_bytes(1, byteorder = 'big', signed = False) t += self.DST_ADDR.encode() else: t += self.DST_ADDR.packed t += self.DST_PORT.to_bytes(2, byteorder = 'big', signed = False) return t class SOCKS5Reply: def __init__(self): self.VER = 5 self.REP = None self.RSV = 0 self.ATYP = None self.BIND_ADDR= None self.BIND_PORT= None @staticmethod def from_socket(soc): data = b'' total_size = 1024 while True: temp = soc.recv(1024) if temp == b'': break data += temp if len(data) > 4: rt = SOCKS5AddressType(data[3]) if rt == SOCKS5AddressType.IP_V4: total_size = 4 + 2 + 4 if rt == SOCKS5AddressType.IP_V6: total_size = 4 + 2 + 16 if rt == SOCKS5AddressType.DOMAINNAME: total_size = 4 + 2 + data[4] if len(data) >= total_size: break return SOCKS5Reply.from_bytes(data) @staticmethod async def from_streamreader(reader): rep = SOCKS5Reply() t = await reader.readexactly(1) rep.VER = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.REP = SOCKS5ReplyType(int.from_bytes(t, byteorder = 'big', signed = False)) t = await reader.readexactly(1) rep.RSV = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.ATYP = SOCKS5AddressType(int.from_bytes(t, byteorder = 'big', signed = False)) if rep.ATYP == SOCKS5AddressType.IP_V4: t = await reader.readexactly(4) rep.BIND_ADDR = ipaddress.IPv4Address(t) elif rep.ATYP == SOCKS5AddressType.IP_V6: t = await reader.readexactly(16) rep.BIND_ADDR = ipaddress.IPv6Address(t) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: t = await reader.readexactly(1) length = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(length) rep.BIND_ADDR = t.decode() t = await reader.readexactly(2) rep.BIND_PORT = int.from_bytes(t, byteorder = 'big', signed = False) return rep @staticmethod def from_bytes(bbuff): return SOCKS5Reply.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rep = SOCKS5Reply() rep.VER = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.REP = SOCKS5ReplyType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) rep.RSV = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.ATYP = SOCKS5AddressType(int.from_bytes(buff.read(1), byteorder = 'big', signed = False)) if rep.ATYP == SOCKS5AddressType.IP_V4: rep.BIND_ADDR = ipaddress.IPv4Address(buff.read(4)) elif rep.ATYP == SOCKS5AddressType.IP_V6: rep.BIND_ADDR = ipaddress.IPv6Address(buff.read(16)) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: length = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.BIND_ADDR = buff.read(length).decode() rep.BIND_PORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) return rep @staticmethod def construct(reply, address, port): rep = SOCKS5Reply() rep.VER = 5 rep.REP = reply rep.RSV = 0 if isinstance(address, ipaddress.IPv4Address): rep.ATYP = SOCKS5AddressType.IP_V4 rep.DST_ADDR = address elif isinstance(address, ipaddress.IPv6Address): rep.ATYP = SOCKS5AddressType.IP_V6 rep.DST_ADDR = address elif isinstance(address, str): rep.ATYP = SOCKS5AddressType.DOMAINNAME rep.DST_ADDR = address rep.DST_PORT = port return rep def to_bytes(self): t = self.VER.to_bytes(1, byteorder = 'big', signed = False) t += self.REP.value.to_bytes(1, byteorder = 'big', signed = False) t += self.RSV.to_bytes(1, byteorder = 'big', signed = False) t += self.ATYP.value.to_bytes(1, byteorder = 'big', signed = False) if self.ATYP == SOCKS5AddressType.DOMAINNAME: t += len(self.DST_ADDR).to_bytes(1, byteorder = 'big', signed = False) t += self.DST_ADDR.encode() else: t += self.DST_ADDR.packed t += self.DST_PORT.to_bytes(2, byteorder = 'big', signed = False) return t def __repr__(self): t = '== SOCKS5Reply ==\r\n' t += 'REP: %s\r\n' % repr(self.REP) t += 'ATYP: %s\r\n' % repr(self.ATYP) t += 'BIND_ADDR: %s\r\n' % repr(self.BIND_ADDR) t += 'BIND_PORT: %s\r\n' % repr(self.BIND_PORT) return t class SOCKS5UDP: def __init__(self): self.RSV = None self.FRAG = None self.ATYP = None self.DST_ADDR = None self.DST_PORT = None self.DATA = None @staticmethod async def from_streamreader(reader): rep = SOCKS5UDP() t = await reader.readexactly(2) rep.RSV = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(1) rep.FRAG = SOCKS5ReplyType(int.from_bytes(t, byteorder = 'big', signed = False)) t = await reader.readexactly(1) rep.ATYP = SOCKS5AddressType(int.from_bytes(t, byteorder = 'big', signed = False)) if rep.ATYP == SOCKS5AddressType.IP_V4: t = await reader.readexactly(4) rep.DST_ADDR = ipaddress.IPv4Address(t) elif rep.ATYP == SOCKS5AddressType.IP_V6: t = await reader.readexactly(16) rep.DST_ADDR = ipaddress.IPv6Address(t) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: t = await reader.readexactly(1) length = int.from_bytes(t, byteorder = 'big', signed = False) t = await reader.readexactly(length) rep.DST_ADDR = t.decode() t = await reader.readexactly(2) rep.DST_PORT = int.from_bytes(t, byteorder = 'big', signed = False) return rep @staticmethod def from_bytes(bbuff): return SOCKS5UDP.from_buffer(io.BytesIO(bbuff)) @staticmethod def from_buffer(buff): rep = SOCKS5UDP() rep.RSV = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) rep.FRAG = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.ATYP = SOCKS5AddressType(buff.read(1), byteorder = 'big', signed = False) if rep.ATYP == SOCKS5AddressType.IP_V4: rep.DST_ADDR = ipaddress.IPv4Address(buff.read(4)) elif rep.ATYP == SOCKS5AddressType.IP_V6: rep.DST_ADDR = ipaddress.IPv6Address(buff.read(16)) elif rep.ATYP == SOCKS5AddressType.DOMAINNAME: length = int.from_bytes(buff.read(1), byteorder = 'big', signed = False) rep.DST_ADDR = buff.read(length).decode() rep.DST_PORT = int.from_bytes(buff.read(2), byteorder = 'big', signed = False) #be careful, not data length is defined in the RFC!! rep.DATA = buff.read() @staticmethod def construct(address, port, data, frag = 0): req = SOCKS5Request() req.RSV = 0 req.FRAG = frag if isinstance(address, ipaddress.IPv4Address): req.ATYP = SOCKS5AddressType.IP_V4 req.DST_ADDR = address elif isinstance(address, ipaddress.IPv6Address): req.ATYP = SOCKS5AddressType.IP_V6 req.DST_ADDR = address elif isinstance(address, str): req.ATYP = SOCKS5AddressType.DOMAINNAME req.DST_ADDR = address req.DST_PORT = port req.DATA = data return req def to_bytes(self): t = self.RSV.to_bytes(2, byteorder = 'big', signed = False) t += self.FRAG.value.to_bytes(1, byteorder = 'big', signed = False) t += self.ATYP.value.to_bytes(1, byteorder = 'big', signed = False) if self.ATYP == SOCKS5AddressType.DOMAINNAME: t += len(self.DST_ADDR).to_bytes(1, byteorder = 'big', signed = False) t += self.DST_ADDR.encode() else: t += self.DST_ADDR.packed t += self.DST_PORT.to_bytes(2, byteorder = 'big', signed = False) t += self.DATA return t././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8256292 asysocks-0.2.2/asysocks/unicomm/utils/0000755000000000000000000000000014310720220016545 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660590426.0 asysocks-0.2.2/asysocks/unicomm/utils/__init__.py0000664000000000000000000000000014276514532020670 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1660590391.0 asysocks-0.2.2/asysocks/unicomm/utils/paramprocessor.py0000664000000000000000000000016114276514467022210 0ustar00rootroot def str_one(x): return str(x[0]) def int_one(x): return int(x[0]) def bool_one(x): return bool(int_one(x)) ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8256292 asysocks-0.2.2/asysocks/utils/0000755000000000000000000000000014310720220015076 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/asysocks/utils/__init__.py0000664000000000000000000000000014136501636017215 0ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1646685457.0 asysocks-0.2.2/asysocks/utils/mbedtlswrapper.py0000664000000000000000000001436114211466421020524 0ustar00rootrootimport asyncio import platform import traceback import logging from mbedtls import tls from asn1crypto.x509 import Certificate class MBEDTLSWrapper: def __init__(self): self.comms = None self.transport_in = None self.transport_out = None self.ssl_ctx = None self.ssl_obj = None self.transport = None self.handshake_done_evt = None self.handshake_timeout = 10 self.__ssl_in_q = None self.stop_evt = None self.server_certificate = None self.__enc_task = None self.__dec_task = None self.__process_task = None async def disconnect(self): try: if self.__enc_task is not None: self.__enc_task.cancel() if self.__dec_task is not None: self.__dec_task.cancel() if self.__process_task is not None: self.__process_task.cancel() if self.transport is not None: self.transport_out.put_nowait(b'') await self.transport.disconnect() except Exception as e: pass async def get_server_pubkey(self): try: if self.server_certificate is None: return None cert = Certificate.load(self.server_certificate) return cert['tbs_certificate']['subject_public_key_info']['public_key'].dump()[5:] #why? except Exception as e: return e def get_server_cert(self): if self.server_certificate is not None: return self.server_certificate async def setup(self): try: self.handshake_done_evt = asyncio.Event() self.stop_evt = asyncio.Event() self.__ssl_in_q = asyncio.Queue() self.ssl_obj = self.ssl_ctx.wrap_buffers(None) _, err = await self.__do_handshake() if err is not None: raise err self.server_certificate = self.ssl_ctx.getpeercert(binary_form=True) print(self.server_certificate) self.__enc_task = asyncio.create_task(self.__encrypt_ssl_rec()) self.__dec_task = asyncio.create_task(self.__decrypt_ssl_rec()) self.__process_task = asyncio.create_task(self.__read_ssl_record()) return True, None except Exception as e: traceback.print_exc() return None, e async def __encrypt_ssl_rec(self): try: while True: try: raw_data = await self.comms.in_queue.get() if raw_data == b'': await self.comms.in_queue.put(None) return self.ssl_obj.write(raw_data) while True: try: enc_data = self.ssl_obj.peek_outgoing(16384) if enc_data == b'': break await self.transport_out.put(enc_data) self.ssl_obj.consume_outgoing(len(enc_data)) except Exception as e: raise e except Exception as e: raise e except asyncio.CancelledError: return except Exception as e: traceback.print_exc() print('__encrypt_ssl_rec %s' % e) logging.debug('__encrypt_ssl_rec %s' % e) async def __decrypt_ssl_rec(self): """ Decrypting the encrypted SSL records from the internal queue and putting them in the queue for the uppr layers to use """ try: while not self.stop_evt.is_set(): ssl_data = await self.__ssl_in_q.get() if ssl_data == b'': await self.comms.out_queue.put((ssl_data, None)) #print('Connection terminated') return self.ssl_obj.receive_from_network(ssl_data) data_buff = b'' while not self.stop_evt.is_set(): try: data_read = self.ssl_obj.read(16384) if data_read == b'': break data_buff += data_read except Exception as e: raise e #print('data_buff %s' % data_buff) if data_buff != b'': await self.comms.out_queue.put((data_buff, None)) except asyncio.CancelledError: return except Exception as e: traceback.print_exc() logging.debug('__decrypt_ssl_rec %s' % e) async def __read_ssl_record(self): try: """ buffering the incoming SSL (encrypted) recodrs and putting them in an internal queue one record at a time """ buffer = b'' length = None while not self.stop_evt.is_set(): if length is None and len(buffer) >= 6: length = int.from_bytes(buffer[3:5], byteorder = 'big', signed = False) if length is not None and len(buffer) >= length + 5: #print('LB raw %s' % len(buffer[:length+5])) await self.__ssl_in_q.put(buffer[:length+5]) buffer = buffer[length+5:] length = None continue data, err = await self.transport_in.get() if err is not None: raise err if data == b'': await self.__ssl_in_q.put(b'') return buffer+= data except asyncio.CancelledError: return except Exception as e: traceback.print_exc() logging.debug('__read_ssl_record %s' % e) await self.__ssl_in_q.put(b'') #finally: # self.stop_evt.set() async def __do_handshake(self): try: ctr = 0 while not self.stop_evt.is_set() and self.ssl_obj.context._state is not tls.HandshakeStep.HANDSHAKE_OVER: ctr += 1 if ctr == 1000: raise Exception('Handshake broke :(') print('DST Performing handshake!') try: self.ssl_obj.do_handshake() data = self.ssl_obj.peek_outgoing(1024) if len(data) == 0: continue await self.transport_out.put(data) self.ssl_obj.consume_outgoing(len(data)) except tls.WantReadError: print('WantReadError %s' % ctr) data = self.ssl_obj.peek_outgoing(1024) if len(data) == 0: continue await self.transport_out.put(data) self.ssl_obj.consume_outgoing(len(data)) continue except tls.WantWriteError: print('WantWriteError %s' % ctr) server_hello, err = await self.transport_in.get() if err is not None: raise err if server_hello == b'': raise Exception('Server closed the connection!') self.ssl_obj.receive_from_network(server_hello) continue except: raise self.handshake_done_evt.set() return True, None except Exception as e: traceback.print_exc() logging.debug('__do_handshake %s' % e) return None, e @staticmethod async def from_commsettings(comms, transport_in, transport_out): try: tunnel = MBEDTLSWrapper() tunnel.transport_in = transport_in tunnel.transport_out = transport_out tunnel.comms = comms tunnel.handshake_timeout = comms.handshake_timeout tunnel.ssl_ctx = tls.ClientContext(tls.TLSConfiguration( validate_certificates=False, )) _, err = await tunnel.setup() if err is not None: raise err return tunnel, None except Exception as e: traceback.print_exc() return None, e././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1647285612.0 asysocks-0.2.2/asysocks/utils/sslwrapper.py0000664000000000000000000001433114213712554017673 0ustar00rootrootimport asyncio import traceback import logging import ssl from asn1crypto.x509 import Certificate class SSLWrapper: def __init__(self): self.comms = None self.transport_in = None self.transport_out = None self.ssl_ctx = None self.transport = None self.ssl_in_buff = None self.ssl_out_buff = None self.ssl_obj = None self.handshake_done_evt = None self.handshake_timeout = 10 self.__ssl_in_q = None self.stop_evt = None self.server_certificate = None self.__enc_task = None self.__dec_task = None self.__process_task = None async def disconnect(self): try: if self.__enc_task is not None: self.__enc_task.cancel() if self.__dec_task is not None: self.__dec_task.cancel() if self.__process_task is not None: self.__process_task.cancel() if self.transport is not None: self.transport_out.put_nowait(b'') await self.transport.disconnect() except Exception as e: pass async def get_server_pubkey(self): try: if self.server_certificate is None: return None cert = Certificate.load(self.server_certificate) return cert['tbs_certificate']['subject_public_key_info']['public_key'].dump()[5:] #why? except Exception as e: return e def get_server_cert(self): if self.server_certificate is not None: return self.server_certificate async def setup(self): try: self.handshake_done_evt = asyncio.Event() self.stop_evt = asyncio.Event() self.__ssl_in_q = asyncio.Queue() self.ssl_in_buff = ssl.MemoryBIO() self.ssl_out_buff = ssl.MemoryBIO() self.ssl_obj = self.ssl_ctx.wrap_bio(self.ssl_in_buff, self.ssl_out_buff, server_side=False, server_hostname = None) _, err = await self.__do_handshake() if err is not None: raise err self.server_certificate = self.ssl_obj.getpeercert(binary_form=True) self.__enc_task = asyncio.create_task(self.__encrypt_ssl_rec()) self.__dec_task = asyncio.create_task(self.__decrypt_ssl_rec()) self.__process_task = asyncio.create_task(self.__read_ssl_record()) return True, None except Exception as e: return None, e async def __encrypt_ssl_rec(self): try: while True: try: raw_data = await self.comms.in_queue.get() if raw_data == b'': await self.comms.in_queue.put(None) return self.ssl_obj.write(raw_data) while True: try: enc_data = self.ssl_out_buff.read() if enc_data == b'': break await self.transport_out.put(enc_data) except Exception as e: raise e except Exception as e: raise e except asyncio.CancelledError: return except Exception as e: logging.debug('__encrypt_ssl_rec %s' % e) async def __decrypt_ssl_rec(self): """ Decrypting the encrypted SSL records from the internal queue and putting them in the queue for the uppr layers to use """ try: while not self.stop_evt.is_set(): ssl_data = await self.__ssl_in_q.get() if ssl_data == b'': await self.comms.out_queue.put((ssl_data, None)) #print('Connection terminated') return self.ssl_in_buff.write(ssl_data) data_buff = b'' while not self.stop_evt.is_set(): try: data_buff += self.ssl_obj.read() except ssl.SSLWantReadError: break except Exception as e: raise e #print('data_buff %s' % data_buff) if data_buff != b'': await self.comms.out_queue.put((data_buff, None)) except asyncio.CancelledError: return except Exception as e: logging.debug('__decrypt_ssl_rec %s' % e) async def __read_ssl_record(self): try: """ buffering the incoming SSL (encrypted) recodrs and putting them in an internal queue one record at a time """ buffer = b'' length = None while not self.stop_evt.is_set(): if length is None and len(buffer) >= 6: length = int.from_bytes(buffer[3:5], byteorder = 'big', signed = False) if length is not None and len(buffer) >= length + 5: #print('LB raw %s' % len(buffer[:length+5])) await self.__ssl_in_q.put(buffer[:length+5]) buffer = buffer[length+5:] length = None continue data, err = await self.transport_in.get() if err is not None: raise err if data == b'': await self.__ssl_in_q.put(b'') return buffer+= data except asyncio.CancelledError: return except Exception as e: logging.debug('__read_ssl_record %s' % e) await self.__ssl_in_q.put(b'') #finally: # self.stop_evt.set() async def __do_handshake(self): try: ctr = 0 while not self.stop_evt.is_set(): ctr += 1 #print('DST Performing handshake!') try: self.ssl_obj.do_handshake() except ssl.SSLWantReadError: #print('DST want %s' % ctr) while True: client_hello = self.ssl_out_buff.read() if client_hello != b'': #print('DST client_hello %s' % len(client_hello)) await self.transport_out.put(client_hello) else: break #print('DST wating server hello %s' % ctr) server_hello, err = await self.transport_in.get() if err is not None: raise err if server_hello == b'': raise Exception('Server closed the connection!') #print('DST server_hello %s' % len(server_hello)) self.ssl_in_buff.write(server_hello) continue except: raise else: #print('DST handshake ok %s' % ctr) #server_fin = tls_out_buff.read() #print('DST server_fin %s ' % server_fin) #await out_q.put(server_fin) break self.handshake_done_evt.set() return True, None except Exception as e: logging.debug('__do_handshake %s' % e) return None, e @staticmethod async def from_commsettings(comms, transport_in, transport_out): try: tunnel = SSLWrapper() tunnel.transport_in = transport_in tunnel.transport_out = transport_out tunnel.comms = comms tunnel.handshake_timeout = comms.handshake_timeout if comms.ssl_ctx is not None: tunnel.ssl_ctx = comms.ssl_ctx #elif comms.ssl_cert is not None: # raise NotImplementedError() else: tunnel.ssl_ctx = ssl.create_default_context() tunnel.ssl_ctx.check_hostname = False tunnel.ssl_ctx.verify_mode = ssl.CERT_NONE _, err = await tunnel.setup() if err is not None: raise err return tunnel, None except Exception as e: return None, e././@PaxHeader0000000000000000000000000000003300000000000010211 xustar0027 mtime=1663279247.785629 asysocks-0.2.2/asysocks.egg-info/0000755000000000000000000000000014310720220015430 5ustar00rootroot././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/PKG-INFO0000644000000000000000000000053514310720217016536 0ustar00rootrootMetadata-Version: 2.1 Name: asysocks Version: 0.2.2 Home-page: https://github.com/skelsec/asysocks Author: Tamas Jos Author-email: info@skelsecprojects.com Classifier: Programming Language :: Python :: 3.6 Classifier: License :: OSI Approved :: MIT License Classifier: Operating System :: OS Independent Requires-Python: >=3.6 License-File: LICENSE ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/SOURCES.txt0000644000000000000000000000457714310720217017337 0ustar00rootrootLICENSE README.md setup.py asysocks/__init__.py asysocks/_version.py asysocks/certmanager.py asysocks/client.py asysocks/security.py asysocks/server.py asysocks.egg-info/PKG-INFO asysocks.egg-info/SOURCES.txt asysocks.egg-info/dependency_links.txt asysocks.egg-info/entry_points.txt asysocks.egg-info/requires.txt asysocks.egg-info/top_level.txt asysocks.egg-info/zip-safe asysocks/authentication/__init__.py asysocks/common/__init__.py asysocks/common/aiowrappers.py asysocks/common/clienturl.py asysocks/common/comms.py asysocks/common/constants.py asysocks/common/credentials.py asysocks/common/target.py asysocks/common/trafficlog.py asysocks/examples/__init__.py asysocks/examples/socksbrute.py asysocks/examples/socksportscan.py asysocks/examples/socksproxy.py asysocks/examples/sockssec.py asysocks/examples/sockstunnel.py asysocks/intercepting/__init__.py asysocks/intercepting/default_intercept_table.py asysocks/intercepting/server.py asysocks/intercepting/target.py asysocks/intercepting/monitors/__init__.py asysocks/intercepting/monitors/base.py asysocks/intercepting/monitors/rawlogging.py asysocks/intercepting/monitors/sslbase.py asysocks/network/__init__.py asysocks/network/queue.py asysocks/network/tcp.py asysocks/network/wsnet.py asysocks/network/wsnetws.py asysocks/protocol/__init__.py asysocks/protocol/http.py asysocks/protocol/socks4.py asysocks/protocol/socks4a.py asysocks/protocol/socks5.py asysocks/test/__init__.py asysocks/test/listener_test.py asysocks/test/queue_test.py asysocks/test/ssl_test.py asysocks/test/test_url_param.py asysocks/test/wsnettest.py asysocks/unicomm/__init__.py asysocks/unicomm/client.py asysocks/unicomm/common/__init__.py asysocks/unicomm/common/connection.py asysocks/unicomm/common/proxy.py asysocks/unicomm/common/target.py asysocks/unicomm/common/packetizers/__init__.py asysocks/unicomm/common/packetizers/ssl.py asysocks/unicomm/common/scanner/__init__.py asysocks/unicomm/common/scanner/common.py asysocks/unicomm/common/scanner/scanner.py asysocks/unicomm/common/scanner/targetgen.py asysocks/unicomm/protocol/__init__.py asysocks/unicomm/protocol/http.py asysocks/unicomm/protocol/quic.py asysocks/unicomm/protocol/socks4.py asysocks/unicomm/protocol/socks4a.py asysocks/unicomm/protocol/socks5.py asysocks/unicomm/utils/__init__.py asysocks/unicomm/utils/paramprocessor.py asysocks/utils/__init__.py asysocks/utils/mbedtlswrapper.py asysocks/utils/sslwrapper.py././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/dependency_links.txt0000644000000000000000000000000114310720217021504 0ustar00rootroot ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/entry_points.txt0000644000000000000000000000042014310720217020730 0ustar00rootroot[console_scripts] asysocksbrute = asysocks.examples.socksbrute:main asysocksportscan = asysocks.examples.socksportscan:main asysocksproxy = asysocks.examples.socksproxy:main asysockssec = asysocks.examples.sockssec:main asysockstunnel = asysocks.examples.sockstunnel:main ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/requires.txt0000644000000000000000000000001314310720217020030 0ustar00rootrootasn1crypto ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/top_level.txt0000644000000000000000000000001114310720217020160 0ustar00rootrootasysocks ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1663279247.0 asysocks-0.2.2/asysocks.egg-info/zip-safe0000644000000000000000000000000114310720217017066 0ustar00rootroot ././@PaxHeader0000000000000000000000000000003400000000000010212 xustar0028 mtime=1663279247.8296292 asysocks-0.2.2/setup.cfg0000644000000000000000000000004614310720220013720 0ustar00rootroot[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000010213 xustar0022 mtime=1635419038.0 asysocks-0.2.2/setup.py0000664000000000000000000000254014136501636013632 0ustar00rootrootfrom setuptools import setup, find_packages import re VERSIONFILE="asysocks/_version.py" verstrline = open(VERSIONFILE, "rt").read() VSRE = r"^__version__ = ['\"]([^'\"]*)['\"]" mo = re.search(VSRE, verstrline, re.M) if mo: verstr = mo.group(1) else: raise RuntimeError("Unable to find version string in %s." % (VERSIONFILE,)) setup( # Application name: name="asysocks", # Version number (initial): version=verstr, # Application author details: author="Tamas Jos", author_email="info@skelsecprojects.com", # Packages packages=find_packages(), # Include additional files into the package include_package_data=True, # Details url="https://github.com/skelsec/asysocks", zip_safe = True, # # license="LICENSE.txt", description="", long_description="", # long_description=open("README.txt").read(), python_requires='>=3.6', classifiers=( "Programming Language :: Python :: 3.6", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ), install_requires=[ 'asn1crypto', ], entry_points={ 'console_scripts': [ 'asysockstunnel = asysocks.examples.sockstunnel:main', 'asysockssec = asysocks.examples.sockssec:main', 'asysocksbrute = asysocks.examples.socksbrute:main', 'asysocksportscan = asysocks.examples.socksportscan:main', 'asysocksproxy = asysocks.examples.socksproxy:main', ], } )