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()