def _do_start_ssl_proxy(port: int, target: PortOrUrl, target_ssl=False): import pproxy from localstack.services.generic_proxy import GenericProxy if ":" not in str(target): target = "127.0.0.1:%s" % target LOG.debug("Starting SSL proxy server %s -> %s", port, target) # create server and remote connection server = pproxy.Server("secure+tunnel://0.0.0.0:%s" % port) target_proto = "ssl+tunnel" if target_ssl else "tunnel" remote = pproxy.Connection("%s://%s" % (target_proto, target)) args = dict(rserver=[remote], verbose=print) # set SSL contexts _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert() for context in pproxy.server.sslcontexts: context.load_cert_chain(cert_file_name, key_file_name) loop = ensure_event_loop() handler = loop.run_until_complete(server.start_server(args)) try: loop.run_forever() except KeyboardInterrupt: print("exit!") handler.close() loop.run_until_complete(handler.wait_closed()) loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
def start_ssl_proxy(port, target, target_ssl=False): import pproxy from localstack.services.generic_proxy import GenericProxy if ':' not in str(target): target = '127.0.0.1:%s' % target print('Starting SSL proxy server %s -> %s' % (port, target)) # create server and remote connection server = pproxy.Server('secure+tunnel://0.0.0.0:%s' % port) target_proto = 'secure+tunnel' if target_ssl else 'tunnel' remote = pproxy.Connection('%s://%s' % (target_proto, target)) args = dict(rserver=[remote], verbose=print) # set SSL contexts _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert() for context in pproxy.server.sslcontexts: context.load_cert_chain(cert_file_name, key_file_name) loop = asyncio.get_event_loop() handler = loop.run_until_complete(server.start_server(args)) try: loop.run_forever() except KeyboardInterrupt: print('exit!') handler.close() loop.run_until_complete(handler.wait_closed()) loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
def __init__(self, callback_class): super().__init__() self._callback = callback_class self._callback.protocol = self self.is_ipv6 = None if self.socks_proxy: self._socks_conn = pproxy.Connection(self.socks_proxy) self._socks_addr = (self._socks_conn.host_name, self._socks_conn.port)
def _do_start_ssl_proxy( port: int, target: PortOrUrl, target_ssl=False, client_cert_key: Tuple[str, str] = None, bind_address: str = "0.0.0.0", ): """ Starts a tcp proxy (with tls) on the specified port :param port: Port the proxy should bind to :param target: Target of the proxy. If a port, it will connect to localhost: :param target_ssl: Specify if the proxy should connect to the target using SSL/TLS :param client_cert_key: Client certificate for the target connection. Only set if target_ssl=True :param bind_address: Bind address of the proxy server """ import pproxy from localstack.services.generic_proxy import GenericProxy if ":" not in str(target): target = f"127.0.0.1:{target}" LOG.debug("Starting SSL proxy server %s -> %s", port, target) # create server and remote connection server = pproxy.Server(f"secure+tunnel://{bind_address}:{port}") target_proto = "ssl+tunnel" if target_ssl else "tunnel" remote = pproxy.Connection(f"{target_proto}://{target}") if client_cert_key: # TODO verify client certs server side? LOG.debug("Configuring ssl proxy to use client certs") cert_file, key_file = _save_cert_keys(client_cert_key=client_cert_key) remote.sslclient.load_cert_chain(certfile=cert_file, keyfile=key_file) args = dict(rserver=[remote]) # set SSL contexts _, cert_file_name, key_file_name = GenericProxy.create_ssl_cert() for context in pproxy.server.sslcontexts: context.load_cert_chain(cert_file_name, key_file_name) loop = ensure_event_loop() handler = loop.run_until_complete(server.start_server(args)) try: loop.run_forever() except KeyboardInterrupt: print("exit!") handler.close() loop.run_until_complete(handler.wait_closed()) loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
async def build(self, lifetime: int = 0) -> None: self.build_time = datetime.now() if lifetime > 0: self.destroy_time = self.build_time + timedelta(seconds=lifetime) self.__destroy_task = asyncio.create_task( self.run_destruction_timer()) server = pproxy.Server(f'http+socks4+socks5://0.0.0.0:{self.port}') connection = pproxy.Connection( f'{self.inner_proxy.url}__{self.outer_proxy.url}') try: self.server = await server.start_server({ 'rserver': [connection], 'verbose': self.verbose_func }) except OSError: self.port = utils.get_ephemeral_port() await self.build(lifetime)
def run_pproxy(socks: int, haproxy_port: int, socks_port: int): server = pproxy.Server(f'http://0.0.0.0:{haproxy_port}') num_of_socks = range(socks) remotes: list = [] for i in num_of_socks: remotes.append(pproxy.Connection(f'socks5://localhost:{socks_port + i}')) args = dict(rserver=remotes, verbose=print, salgorithm="rr") loop = asyncio.get_event_loop() handler = loop.run_until_complete(server.start_server(args)) try: loop.run_forever() except KeyboardInterrupt: print('exit!') handler.close() loop.run_until_complete(handler.wait_closed()) loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
) else: print(f'IPv4 ICMP -> {dst_name} Data={ip_body}') else: print( f'IPv4 {enums.IpProto(proto).name} -> {dst_name} Data={data}' ) else: print( f'{enums.IpProto(header).name} Unhandled Protocol. Data={data}' ) else: print('unknown packet', data, addr) DIRECT = pproxy.Connection('direct://') def main(): parser = argparse.ArgumentParser(description=__description__, epilog=f'Online help: <{__url__}>') parser.add_argument('-r', dest='rserver', default=DIRECT, type=pproxy.Connection, help='tcp remote server uri (default: direct)') parser.add_argument('-ur', dest='urserver', default=DIRECT, type=pproxy.Connection, help='udp remote server uri (default: direct)')
def main(): parser = argparse.ArgumentParser(description=__description__, epilog=f'Online help: <{__url__}>') parser.add_argument('-r', dest='rserver', default=[], action='append', type=pproxy.Connection, help='tcp remote server uri (default: direct)') parser.add_argument('-ur', dest='urserver', default=[], action='append', type=pproxy.Connection, help='udp remote server uri (default: direct)') parser.add_argument('-s', dest='salgorithm', default='fa', choices=('fa', 'rr', 'rc', 'lc'), help='scheduling algorithm (default: first_available)') parser.add_argument('-p', dest='passwd', default='test', help='password (default: test)') parser.add_argument('-dns', dest='dns', default='1.1.1.1', help='dns server (default: 1.1.1.1)') parser.add_argument('-nc', dest='nocache', default=None, action='store_true', help='do not cache dns (default: off)') parser.add_argument('-v', dest='v', action='count', help='print verbose output') parser.add_argument('--version', action='version', version=f'{__title__} {__version__}') args = parser.parse_args() args.DIRECT = pproxy.Connection('direct://') loop = asyncio.get_event_loop() sessions = {} # transport1, _ = loop.run_until_complete(loop.create_datagram_endpoint(lambda: IKE_500(args, sessions), ('0.0.0.0', 500))) # transport2, _ = loop.run_until_complete(loop.create_datagram_endpoint(lambda: SPE_4500(args, sessions), ('0.0.0.0', 4500))) # print('Serving on UDP :500 :4500...') transport1, _ = loop.run_until_complete( loop.create_datagram_endpoint(lambda: IKE_500(args, sessions), ('0.0.0.0', 10502))) transport2, _ = loop.run_until_complete( loop.create_datagram_endpoint(lambda: SPE_4500(args, sessions), ('0.0.0.0', 14502))) print('Serving on UDP :10502 :14502...') try: loop.run_forever() except KeyboardInterrupt: print('exit') for task in asyncio.Task.all_tasks(): task.cancel() transport1.close() transport2.close() loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()
async def test_tcp(): conn = pproxy.Connection('ss://*****:*****@127.0.0.1:12345') reader, writer = await conn.tcp_connect('google.com', 80) writer.write(b'GET / HTTP/1.1\r\n\r\n') data = await reader.read(1024 * 16) print(data.decode())
async def test_udp(): conn = pproxy.Connection('ss://*****:*****@127.0.0.1:12345') answer = asyncio.Future() await conn.udp_sendto('8.8.8.8', 53, b'hello', answer.set_result) await answer print(answer.result())
import asyncio import pproxy server = pproxy.Server('ss://0.0.0.0:1234') remote = pproxy.Connection('ss://1.2.3.4:5678') args = dict(rserver=[remote], verbose=print) loop = asyncio.get_event_loop() handler = loop.run_until_complete(server.start_server(args)) try: loop.run_forever() except KeyboardInterrupt: print('exit!') handler.close() loop.run_until_complete(handler.wait_closed()) loop.run_until_complete(loop.shutdown_asyncgens()) loop.close()