async def test_snitun_single_runner():
"""Test SniTunSingle Server runner object."""
peer_messages = []
peer_address = []
server = SniTunServerSingle(FERNET_TOKENS, host="127.0.0.1")
await server.start()
reader_peer, writer_peer = await asyncio.open_connection(host="127.0.0.1",
port="443")
valid = datetime.utcnow() + timedelta(days=1)
aes_key = os.urandom(32)
aes_iv = os.urandom(16)
hostname = "localhost"
fernet_token = create_peer_config(valid.timestamp(), hostname, aes_key,
aes_iv)
crypto = CryptoTransport(aes_key, aes_iv)
writer_peer.write(fernet_token)
await writer_peer.drain()
token = await reader_peer.readexactly(32)
token = hashlib.sha256(crypto.decrypt(token)).digest()
writer_peer.write(crypto.encrypt(token))
await writer_peer.drain()
await asyncio.sleep(0.1)
assert server.peers.peer_available(hostname)
async def mock_new_channel(multiplexer, channel):
"""Mock new channel."""
while True:
message = await channel.read()
peer_messages.append(message)
peer_address.append(channel.ip_address)
_, writer_ssl = await asyncio.open_connection(host="127.0.0.1", port="443")
multiplexer = Multiplexer(crypto, reader_peer, writer_peer,
mock_new_channel)
writer_ssl.write(TLS_1_2)
await writer_ssl.drain()
await asyncio.sleep(0.1)
assert peer_messages
assert peer_messages[0] == TLS_1_2
assert peer_address
assert peer_address[0] == IP_ADDR
multiplexer.shutdown()
await multiplexer.wait()
await asyncio.sleep(0.1)
assert not server.peers.peer_available(hostname)
await server.stop()
async def test_init_multiplexer_client(test_client, crypto_transport):
"""Test to create a new Multiplexer from client socket."""
multiplexer = Multiplexer(crypto_transport, test_client.reader,
test_client.writer)
assert multiplexer.is_connected
assert multiplexer._throttling is None
multiplexer.shutdown()
async def test_init_multiplexer_server(test_server, test_client,
crypto_transport):
"""Test to create a new Multiplexer from server socket."""
client = test_server[0]
multiplexer = Multiplexer(crypto_transport, client.reader, client.writer)
assert multiplexer.is_connected
assert multiplexer._throttling is None
multiplexer.shutdown()
client.close.set()
async def multiplexer_client(test_client, crypto_transport):
"""Create a multiplexer client from server."""
async def mock_new_channel(multiplexer, channel):
"""Mock new channel."""
multiplexer = Multiplexer(crypto_transport, test_client.reader,
test_client.writer, mock_new_channel)
yield multiplexer
multiplexer.shutdown()
async def test_server_full(
peer_manager, peer_listener, test_client_peer, sni_proxy, test_client_ssl
):
"""Run a full flow of with a peer after that disconnect."""
peer_messages = []
peer_address = []
valid = datetime.utcnow() + timedelta(days=1)
aes_key = os.urandom(32)
aes_iv = os.urandom(16)
hostname = "localhost"
fernet_token = create_peer_config(valid.timestamp(), hostname, aes_key, aes_iv)
crypto = CryptoTransport(aes_key, aes_iv)
test_client_peer.writer.write(fernet_token)
await test_client_peer.writer.drain()
token = await test_client_peer.reader.readexactly(32)
token = hashlib.sha256(crypto.decrypt(token)).digest()
test_client_peer.writer.write(crypto.encrypt(token))
await test_client_peer.writer.drain()
await asyncio.sleep(0.1)
assert peer_manager.peer_available(hostname)
async def mock_new_channel(multiplexer, channel):
"""Mock new channel."""
while True:
message = await channel.read()
peer_messages.append(message)
peer_address.append(channel.ip_address)
multiplexer = Multiplexer(
crypto, test_client_peer.reader, test_client_peer.writer, mock_new_channel
)
test_client_ssl.writer.write(TLS_1_2)
await test_client_ssl.writer.drain()
await asyncio.sleep(0.1)
assert peer_messages
assert peer_messages[0] == TLS_1_2
assert peer_address
assert peer_address[0] == IP_ADDR
multiplexer.shutdown()
await multiplexer.wait()
await asyncio.sleep(0.1)
assert not peer_manager.peer_available(hostname)