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"