async def test_untrusted_curve_with_wrong_password(loop, unused_tcp_port):
from pseud import Client, Server
from pseud.interfaces import UnauthorizedError
from pseud.utils import register_rpc
client_id = b'john'
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{unused_tcp_port}'
server_public, server_secret = zmq.curve_keypair()
client_public, client_secret = zmq.curve_keypair()
security_plugin = 'untrusted_curve'
password = b's3cret!'
client = Client(server_id,
user_id=client_id,
security_plugin=security_plugin,
public_key=client_public,
secret_key=client_secret,
peer_public_key=server_public,
password=password,
loop=loop)
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
# configure manually authentication backend
server.auth_backend.user_map[client_id] = password + b'Looser'
register_rpc(name='string.lower')(str.lower)
async with server, client:
with pytest.raises(UnauthorizedError):
await client.string.lower(b'IMSCREAMING')
async def test_server_can_send_to_trustable_peer_identity(loop,
unused_tcp_port):
"""
Uses internal metadata of zmq.Frame.get() to fetch identity of sender
"""
from pseud import Client, Server
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{unused_tcp_port}'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id, security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
loop=loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
@server.register_rpc(with_identity=True)
def echo(peer_identity, message):
return peer_identity, message
async with server, client:
result = await client.echo(b'one')
if zmq.zmq_version_info() >= (4, 1, 0):
assert result == (b'bob', b'one')
else:
assert result == (b'', b'one')
async def test_client_can_reconnect(loop, unused_tcp_port_factory):
from pseud import Client, Server
port = unused_tcp_port_factory()
server_id = b'server'
endpoint = f'tcp://127.0.0.1:{port}'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id, security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
loop=loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
loop=loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
server.register_rpc(name='string.upper')(str.upper)
async with server, client:
result = await client.string.upper('hello')
assert result == 'HELLO'
client.disconnect(endpoint)
client.connect(endpoint)
await asyncio.sleep(.01)
result = await client.string.upper('hello2')
assert result == 'HELLO2'
def test_trusted_curve_with_wrong_peer_public_key(self):
from pseud import Client, Server
from pseud.utils import register_rpc
server_id = b'server'
endpoint = 'inproc://{}'.format(__name__).encode()
endpoint = b'tcp://127.0.0.1:8998'
server_public, server_secret = zmq.curve_keypair()
server = Server(server_id,
security_plugin='trusted_curve',
public_key=server_public,
secret_key=server_secret,
io_loop=self.io_loop)
server.bind(endpoint)
alice_public, alice_secret = \
server.auth_backend.known_identities[b'alice']
client = Client(server_id,
user_id=b'alice',
security_plugin='trusted_curve',
public_key=alice_public,
secret_key=alice_secret,
peer_public_key=z85.encode(b'R' * 32),
timeout=.5,
io_loop=self.io_loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
yield server.start()
yield client.start()
register_rpc(name='string.lower')(str.lower)
with pytest.raises(TimeoutError):
yield client.string.lower('BAR')
server.stop()
client.stop()
def test_trusted_curve(self):
from pseud import Client, Server
from pseud.utils import register_rpc
server_id = b'server'
endpoint = b'tcp://127.0.0.1:8998'
server_public, server_secret = zmq.curve_keypair()
security_plugin = 'trusted_curve'
server = Server(server_id,
security_plugin=security_plugin,
public_key=server_public,
secret_key=server_secret,
io_loop=self.io_loop)
server.bind(endpoint)
bob_public, bob_secret = server.auth_backend.known_identities[b'bob']
client = Client(server_id,
user_id=b'bob',
security_plugin=security_plugin,
public_key=bob_public,
secret_key=bob_secret,
peer_public_key=server_public,
io_loop=self.io_loop)
client.connect(endpoint)
assert server.socket.mechanism == zmq.CURVE
assert client.socket.mechanism == zmq.CURVE
yield server.start()
yield client.start()
register_rpc(name='string.lower')(str.lower)
result = yield client.string.lower('FOO')
assert result == 'foo'
server.stop()
client.stop()
def test_client_creation():
from pseud import Client
peer_routing_id = b'echo'
client = Client(peer_routing_id)
assert client.peer_routing_id == peer_routing_id
assert client.security_plugin == 'noop_auth_backend'
