def login(self, context, username):
print("User trying to log in:", username)
user = get_user_by_name(username)
if not user:
raise common.RMCError("RendezVous::InvalidUsername")
server = get_user_by_name(SECURE_SERVER)
url = common.StationURL(
address="127.0.0.1", port=1224,
PID = server.pid, CID = 1, type = 2,
sid = 1, stream = 10
)
conn_data = authentication.RVConnectionData()
conn_data.main_station = url
conn_data.special_protocols = []
conn_data.special_station = common.StationURL()
response = common.RMCResponse()
response.result = common.Result(0x10001) #Success
response.pid = user.pid
response.ticket = self.generate_ticket(user, server)
response.connection_data = conn_data
response.server_name = "Example server"
return response
async def login(self, client, username):
assert username == "username"
pid = 1001
stick = kerberos.ServerTicket()
stick.timestamp = common.DateTime.now()
stick.source = pid
stick.session_key = bytes(32)
ctick = kerberos.ClientTicket()
ctick.session_key = bytes(32)
ctick.target = 100
ctick.internal = stick.encrypt(b"testkey", self.settings)
kerb = kerberos.KeyDerivationOld(65000, 1024)
key = kerb.derive_key(b"password", pid)
connection_data = authentication.RVConnectionData()
connection_data.main_station = common.StationURL(address=HOST,
port=12346,
PID=100,
sid=1)
connection_data.special_protocols = []
connection_data.special_station = common.StationURL()
connection_data.server_time = common.DateTime.now()
response = rmc.RMCResponse()
response.result = common.Result.success()
response.pid = pid
response.ticket = ctick.encrypt(key, self.settings)
response.connection_data = connection_data
response.server_name = "server build name"
return response
def test_flags(self):
url = common.StationURL(type=3)
assert url.is_public()
assert url.is_behind_nat()
assert not url.is_global()
url = common.StationURL(type=2)
assert url.is_public()
assert not url.is_behind_nat()
assert url.is_global()
def test_station_location(): loc = types.StationLocation() assert isinstance(loc.public, types.StationAddress) assert isinstance(loc.local, types.StationAddress) assert isinstance(loc.relay, types.InetAddress) assert loc.pid == 0 assert loc.cid == 0 assert loc.rvcid == 0 assert loc.scheme == 0 assert loc.sid == 0 assert loc.stream_type == 0 assert loc.natm == 0 assert loc.natf == 0 assert loc.type == 3 assert loc.probeinit == 0 copy = loc.copy() loc.scheme = 3 loc.pid = 100 url = loc.get_station_url() assert url["PID"] == 100 assert url.scheme() == "udp" assert copy.scheme == 0 assert copy.pid == 0 url = common.StationURL(natm=1, natf=2, type=5) loc.set_station_url(url) assert loc.scheme == 1 assert loc.natm == 1 assert loc.natf == 2 assert loc.type == 5
async def register(self, client, urls):
address, port = client.remote_address()
response = rmc.RMCResponse()
response.result = common.Result.success()
response.connection_id = next(self.connection_id)
response.public_station = common.StationURL(scheme="prudp",
address=address,
port=port,
natf=0,
natm=0,
pmp=0,
upnp=0,
Tpt=2,
type=11,
sid=client.remote_sid())
self.clients.register(client)
return response
async def validate_and_request_ticket_with_param(self, client, param):
pid = next(self.pid)
key = secrets.token_bytes(16)
result = authentication.ValidateAndRequestTicketResult()
result.pid = pid
result.ticket = self.generate_ticket(pid, SERVER_PID, key, SERVER_KEY)
result.server_url = common.StationURL(scheme="prudps",
address="0.0.0.1",
port=1,
PID=SERVER_PID,
CID=1,
type=2,
sid=2,
stream=10)
result.server_time = common.DateTime.now()
result.server_name = "Super Mario Bros. 35"
result.source_key = key.hex()
return result
def get_station_url(self):
url = common.StationURL(self.url_schemes[self.scheme])
if self.type == 0:
url["address"] = self.local.inet.host
url["port"] = self.local.inet.port
else:
url["address"] = self.public.inet.host
url["port"] = self.public.inet.port
url["PID"] = self.pid
url["CID"] = self.cid
url["RVCID"] = self.rvcid
url["sid"] = self.sid
url["stream"] = self.stream_type
url["natm"] = self.natm
url["natf"] = self.natf
url["type"] = self.type
url["probeinit"] = self.probeinit
url["Rsa"] = self.relay.host
url["Rsp"] = self.relay.port
return url
def login(self, username, password, auth_info=None, login_data=None):
# Call login method on authentication protocol
if auth_info:
response = self.auth_proto.login_ex(username, auth_info)
else:
response = self.auth_proto.login(username)
# Check for errors
response.result.raise_if_error()
self.my_pid = response.pid
secure_station = response.connection_data.main_station
# Derive kerberos key from password
kerberos_key = self.key_derivation.derive_key(
password.encode("ascii"), response.pid
)
# Decrypt ticket from login response
ticket = kerberos.ClientTicket()
ticket.decrypt(response.ticket, kerberos_key, self.settings)
if ticket.target_pid != secure_station["PID"]:
# Request ticket for secure server
response = self.auth_proto.request_ticket(
self.my_pid, secure_station["PID"]
)
# Check for errors and decrypt ticket
response.result.raise_if_error()
ticket = kerberos.ClientTicket()
ticket.decrypt(response.ticket, kerberos_key, self.settings)
ticket.source_pid = self.my_pid
ticket.target_cid = secure_station["CID"]
# The secure server may reside at the same
# address as the authentication server
host = secure_station["address"]
port = secure_station["port"]
if host == "0.0.0.1":
host, port = self.auth_client.remote_address()
# Connect to secure server
server_sid = secure_station["sid"]
if not self.secure_client.connect(host, port, server_sid, ticket):
raise ConnectionError("Couldn't connect to secure server")
# Create a stationurl for our local client address
client_addr = self.secure_client.local_address()
self.local_station = common.StationURL(
address=client_addr[0], port=client_addr[1],
sid=self.secure_client.stream_id(),
natm=0, natf=0, upnp=0, pmp=0
)
# Register urls on secure server
if login_data:
response = self.secure_proto.register_ex([self.local_station], login_data)
else:
response = self.secure_proto.register([self.local_station])
# Check for errors and update urls
response.result.raise_if_error()
self.public_station = response.public_station
self.public_station["RVCID"] = response.connection_id
self.local_station["RVCID"] = response.connection_id
def test_repr(self):
url = common.StationURL(PID=12345)
assert repr(url) == "prudp:/PID=12345"
def test_stationurl(self):
stream = streams.StreamOut(settings.default())
stream.stationurl(common.StationURL("prudps", PID=1, CID=100))
assert stream.get() == b"\x16\0prudps:/PID=1;CID=100\0"
