/// <summary>
/// Processes logon.
/// </summary>
/// <param name="sessionID">Unique session key (created on client side)</param>
/// <param name="credentials">Logon credentials</param>
public void Logon(Guid sessionID, Hashtable credentials)
{
if (sessionID == Guid.Empty)
{
throw new ArgumentException(LanguageResource.ArgumentException_EmptySessionIDIsNotAllowed, "sessionID");
}
if (!_host.SessionManager.ExistSession(sessionID))
{
// reset current session before authentication is complete
ServerSession.CurrentSession = null;
AuthResponseMessage authResponse = _host.Authenticate(new AuthRequestMessage()
{
Credentials = credentials
});
if (!authResponse.Success)
{
var exception = authResponse.Exception ?? new SecurityException(authResponse.ErrorMessage);
throw exception.PreserveStackTrace();
}
var sessionVariableAdapter = new SessionVariableAdapter(_host.SessionManager, sessionID);
var session = new ServerSession(sessionID, authResponse.AuthenticatedIdentity, sessionVariableAdapter);
_host.SessionManager.StoreSession(session);
ServerSession.CurrentSession = session;
PutClientAddressToCurrentSession();
_host.OnClientLoggedOn(new LoginEventArgs(LoginEventType.Logon, session.Identity, session.ClientAddress, session.Timestamp));
}
}
public void AuthResponseMessageTest()
{
// try setting value with constructor
var message = new AuthResponseMessage
{
success = true,
message = "abc"
};
Assert.That(message.success, Is.EqualTo(true));
Assert.That(message.message, Is.EqualTo("abc"));
// serialize
var writer = new NetworkWriter(1300);
writer.Write(message);
// try deserialize
var reader = new NetworkReader();
reader.Reset(writer.ToArraySegment());
AuthResponseMessage fresh = reader.Read <AuthResponseMessage>();
Assert.That(fresh.success, Is.EqualTo(true));
Assert.That(fresh.message, Is.EqualTo("abc"));
reader.Dispose();
}
public void AuthResponseMessageTest()
{
// try setting value with constructor
AuthResponseMessage message = new AuthResponseMessage
{
code = 123,
message = "abc"
};
Assert.That(message.code, Is.EqualTo(123));
Assert.That(message.message, Is.EqualTo("abc"));
// serialize
NetworkWriter writer = new NetworkWriter();
message.Serialize(writer);
byte[] writerData = writer.ToArray();
// try deserialize
AuthResponseMessage fresh = new AuthResponseMessage();
fresh.Deserialize(new NetworkReader(writerData));
Assert.That(fresh.code, Is.EqualTo(123));
Assert.That(fresh.message, Is.EqualTo("abc"));
}
public void OnAuthRequestMessage(INetworkConnection conn, AuthRequestMessage msg)
{
logger.LogFormat(LogType.Log, "Authentication Request: {0} {1}", msg.AuthUsername, msg.AuthPassword);
// check the credentials by calling your web server, database table, playfab api, or any method appropriate.
if (msg.AuthUsername == Username && msg.AuthPassword == Password)
{
// create and send msg to client so it knows to proceed
var authResponseMessage = new AuthResponseMessage
{
Code = 100,
Message = "Success"
};
conn.Send(authResponseMessage);
// Invoke the event to complete a successful authentication
base.OnServerAuthenticate(conn);
}
else
{
// create and send msg to client so it knows to disconnect
var authResponseMessage = new AuthResponseMessage
{
Code = 200,
Message = "Invalid Credentials"
};
conn.Send(authResponseMessage);
// disconnect the client after 1 second so that response message gets delivered
StartCoroutine(DelayedDisconnect(conn, 1));
}
}
public void AuthResponseMessageTest()
{
// try setting value with constructor
var message = new AuthResponseMessage
{
code = 123,
message = "abc"
};
Assert.That(message.code, Is.EqualTo(123));
Assert.That(message.message, Is.EqualTo("abc"));
// serialize
var writer = new NetworkWriter();
writer.Write(message);
byte[] writerData = writer.ToArray();
// try deserialize
var reader = new NetworkReader(writerData);
AuthResponseMessage fresh = reader.Read <AuthResponseMessage>();
Assert.That(fresh.code, Is.EqualTo(123));
Assert.That(fresh.message, Is.EqualTo("abc"));
}
private void OnValidateAuthTicketResponse(SteamId steamId, SteamId ownerId, AuthResponse status)
{
foreach (KeyValuePair <int, SteamTransport.NetworkPlayer> client in SteamTransport.instance.Server.clients)
{
if (client.Value.info.Identity.SteamId == steamId)
{
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Authentication Request: {0} {1}", steamId, status);
}
NetworkConnection conn = NetworkServer.connections[client.Key];
if (status == AuthResponse.OK)
{
AuthResponseMessage authResponseMessage = new AuthResponseMessage();
conn.Send(authResponseMessage);
// Invoke the event to complete a successful authentication
OnServerAuthenticated.Invoke(conn);
return;
}
else
{
AuthResponseMessage authResponseMessage = new AuthResponseMessage();
conn.Send(authResponseMessage);
// must set NetworkConnection isAuthenticated = false
conn.isAuthenticated = false;
// disconnect the client after 1 second so that response message gets delivered
StartCoroutine(DelayedDisconnect(conn, 1));
return;
}
}
}
}
private async Task SendAuthResponse(User user)
{
var msg = new AuthResponseMessage {
name = user?.name, success = user != null
};
await SendMessage(msg);
}
/// <summary>
/// Called on server when the client's AuthRequestMessage arrives
/// </summary>
/// <param name="conn">Connection to client.</param>
/// <param name="msg">The message payload</param>
public void OnAuthRequestMessage(NetworkConnection conn, AuthRequestMessage msg)
{
AuthResponseMessage authResponseMessage = new AuthResponseMessage();
conn.Send(authResponseMessage);
// Accept the successful authentication
ServerAccept(conn);
}
private AuthResponseMessage ResponseStep2(string serverSessionProof, ISrpAccount account)
{
var result = new AuthResponseMessage {
Completed = true, Success = true
};
result.AddParameter(SrpProtocolConstants.SRP_SERVER_SESSION_PROOF, serverSessionProof);
result.AuthenticatedIdentity = AuthRepository.GetIdentity(account);
return(result);
}
private AuthResponseMessage ResponseStep1(string salt, string serverPublicEphemeral)
{
var result = new AuthResponseMessage {
Completed = false, Success = true
};
result.AddParameter(SrpProtocolConstants.SRP_SALT, salt);
result.AddParameter(SrpProtocolConstants.SRP_SERVER_PUBLIC_EPHEMERAL, serverPublicEphemeral);
return(result);
}
public void OnClientReceiveLoginResponseMessage(NetworkConnection conn, AuthResponseMessage message)
{
if (message.success)
{
RpcEnterLobby(message.PlayerID);
}
else
{
ShowErrors(message.errors);
}
}
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 100)
{
ClientAccept(conn);
}
else
{
Debug.LogError($"Authentication Response: {msg.message}");
ClientReject(conn);
}
}
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 200)
{
OnClientAuthenticated.Invoke(conn);
}
else
{
conn.isAuthenticated = false;
conn.Disconnect();
}
}
/// <summary>
/// Called on server when the client's AuthRequestMessage arrives
/// </summary>
/// <param name="conn">Connection to client.</param>
/// <param name="msg">The message payload</param>
public void OnAuthRequestMessage(NetworkConnectionToClient conn, AuthRequestMessage msg)
{
Debug.Log($"Authentication Request: {msg.authUsername}");
if (connectionsPendingDisconnect.Contains(conn))
{
return;
}
// check the credentials by calling your web server, database table, playfab api, or any method appropriate.
if (!Player.playerNames.Contains(msg.authUsername))
{
// Add the name to the HashSet
Player.playerNames.Add(msg.authUsername);
// Store username in authenticationData
// This will be read in Player.OnStartServer
// to set the playerName SyncVar.
conn.authenticationData = msg.authUsername;
// create and send msg to client so it knows to proceed
AuthResponseMessage authResponseMessage = new AuthResponseMessage
{
code = 100,
message = "Success"
};
conn.Send(authResponseMessage);
// Accept the successful authentication
ServerAccept(conn);
}
else
{
connectionsPendingDisconnect.Add(conn);
// create and send msg to client so it knows to disconnect
AuthResponseMessage authResponseMessage = new AuthResponseMessage
{
code = 200,
message = "Username already in use...try again"
};
conn.Send(authResponseMessage);
// must set NetworkConnection isAuthenticated = false
conn.isAuthenticated = false;
// disconnect the client after 1 second so that response message gets delivered
StartCoroutine(DelayedDisconnect(conn, 1f));
}
}
private void AuthReceivedFromServer(NetworkConnection connection, AuthResponseMessage msg)
{
if (!msg.success)
{
Debug.Log($"Authentication failure: {msg.errorMessage}");
authFailed.Invoke(msg.errorMessage);
NetworkManager.singleton.StopClient();
return;
}
Debug.Log($"Authentication succeeded");
base.OnClientAuthenticated.Invoke(connection);
}
public IEnumerator DelayedDisconnect(NetworkConnection conn, string message)
{
// create and send msg to client so it knows to disconnect
AuthResponseMessage authResponseMessage = new AuthResponseMessage {
code = 401,
message = message
};
conn.Send(authResponseMessage);
conn.isAuthenticated = false;
yield return(new WaitForSeconds(1f));
conn.Disconnect();
}
public void OnAuthResponseMessage2(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 100)
{
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Authentication Response: {0}", msg.message);
}
helpText.text = "Logging in!";
if (File.Exists(charStreamPath + msg.username + ".json"))
{
Character character;
using (StreamReader stream = new StreamReader(charStreamPath + msg.username + ".json"))
{
string json = stream.ReadToEnd();
character = JsonUtility.FromJson <Character>(json);
}
List <string> m_DropOptions = new List <string> {
character.name
};
Debug.Log(character.name);
string n = character.name;
loginUI.GetComponent <UILogin>().characterSelectUI.SetActive(true);
loginUI.GetComponent <UILogin>().characterList.AddOptions(m_DropOptions);
}
else
{
Debug.Log("No Character for account");
characterUI.SetActive(true);
}
Debug.Log("Success Login");
}
else
{
// logger.LogFormat(LogType.Error, "Authentication Response: {0}", msg.message);
helpText.text = "Wrong Password!";
// Set this on the client for local reference
conn.isAuthenticated = false;
// disconnect the client
conn.Disconnect();
}
}
private void OnAuthResponseMessage(INetworkPlayer player, AuthResponseMessage msg)
{
if (msg.success)
{
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Authentication Success: {0}", msg.message);
}
ClientAccept(player);
}
else
{
logger.LogFormat(LogType.Error, "Authentication Fail: {0}", msg.message);
ClientReject(player);
}
}
/// <summary>
/// Called on client when the server's AuthResponseMessage arrives
/// </summary>
/// <param name="msg">The message payload</param>
public void OnAuthResponseMessage(AuthResponseMessage msg)
{
if (msg.code == 100)
{
// Debug.LogFormat(LogType.Log, "Authentication Response: {0}", msg.message);
// Authentication has been accepted
ClientAccept();
}
else
{
Debug.LogError($"Authentication Response: {msg.message}");
// Authentication has been rejected
ClientReject();
}
}
public void OnAuthResponseMessage(INetworkConnection conn, AuthResponseMessage msg)
{
if (msg.Code == 100)
{
logger.LogFormat(LogType.Log, "Authentication Response: {0}", msg.Message);
// Invoke the event to complete a successful authentication
base.OnClientAuthenticate(conn);
}
else
{
logger.LogFormat(LogType.Error, "Authentication Response: {0}", msg.Message);
// disconnect the client
conn.Disconnect();
}
}
private void RequestAuthForClient(NetworkConnection connection, AuthRequestMessage msg)
{
PruneDisconnected();
AuthResponseMessage errorResponse = null;
if (msg.nickname.Length == 0)
{
errorResponse = new AuthResponseMessage {
success = false, errorMessage = $"Nickname cannot be empty"
};
}
else if (nicknames.ContainsValue(msg.nickname))
{
errorResponse = new AuthResponseMessage {
success = false, errorMessage = $"Nickname \"{msg.nickname}\" is already taken on this server"
};
}
else if (nicknames.ContainsKey(connection.connectionId))
{
errorResponse = new AuthResponseMessage {
success = false, errorMessage = $"Client already connected!"
};
}
if (errorResponse != null)
{
Debug.Log($"Rejecting attempted auth for \"{msg.nickname}\": {errorResponse.errorMessage}");
connection.Send(errorResponse);
return;
}
var authData = new MercAuthenticationData {
nickname = msg.nickname
};
Debug.Log($"\"{authData.nickname}\" connected (running version {msg.clientVersion})");
nicknames.Add(connection.connectionId, authData.nickname);
connection.authenticationData = authData;
connection.Send(new AuthResponseMessage {
success = true
});
base.OnServerAuthenticated.Invoke(connection);
}
// -------------------------------------------------------------------------------
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 100)
{
base.OnClientAuthenticated.Invoke(conn);
ClientScene.Ready(conn);
conn.Send(new LoginMessage {
authUsername = username, authPassword = GenerateHash()
});
//UIModalConfirm.singleton.Show(msg.message);
}
else
{
conn.isAuthenticated = false;
conn.Disconnect();
UIModalConfirm.singleton.Show(msg.message);
}
}
/// <summary>
/// Called on server when the client's AuthRequestMessage arrives
/// </summary>
/// <param name="conn">Connection to client.</param>
/// <param name="msg">The message payload</param>
public void OnAuthRequestMessage(NetworkConnection conn, AuthRequestMessage msg)
{
// Debug.LogFormat(LogType.Log, "Authentication Request: {0} {1}", msg.authUsername, msg.authPassword);
if (connectionsPendingDisconnect.Contains(conn))
{
return;
}
// check the credentials by calling your web server, database table, playfab api, or any method appropriate.
if (msg.authUsername == serverUsername && msg.authPassword == serverPassword)
{
// create and send msg to client so it knows to proceed
AuthResponseMessage authResponseMessage = new AuthResponseMessage
{
code = 100,
message = "Success"
};
conn.Send(authResponseMessage);
// Accept the successful authentication
ServerAccept(conn);
}
else
{
connectionsPendingDisconnect.Add(conn);
// create and send msg to client so it knows to disconnect
AuthResponseMessage authResponseMessage = new AuthResponseMessage
{
code = 200,
message = "Invalid Credentials"
};
conn.Send(authResponseMessage);
// must set NetworkConnection isAuthenticated = false
conn.isAuthenticated = false;
// disconnect the client after 1 second so that response message gets delivered
StartCoroutine(DelayedDisconnect(conn, 1));
}
}
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
AuthResponse authResponse = (AuthResponse)msg.status;
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Authentication Response: {0}", authResponse.ToString());
}
if (authResponse == AuthResponse.OK)
{
// Invoke the event to complete a successful authentication
OnClientAuthenticated.Invoke(conn);
}
else
{
conn.isAuthenticated = false;
conn.Disconnect();
}
}
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 100)
{
Debug.LogFormat("Authentication Response: {0}", msg.message);
// Invoke the event to complete a successful authentication
base.OnClientAuthenticated.Invoke(conn);
}
else
{
Debug.LogErrorFormat("Authentication Response: {0}", msg.message);
// Set this on the client for local reference
conn.isAuthenticated = false;
// disconnect the client
conn.Disconnect();
}
}
/// <summary>
/// Called on client when the server's AuthResponseMessage arrives
/// </summary>
/// <param name="conn">Connection to client.</param>
/// <param name="msg">The message payload</param>
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 100)
{
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Info, "Authentication Response: {0}", msg.message);
}
// Authentication has been accepted
ClientAccept(conn);
}
else
{
logger.LogFormat(LogType.Error, "Authentication Response: {0}", msg.message);
// Authentication has been rejected
ClientReject(conn);
}
}
// -------------------------------------------------------------------------------
public void OnAuthRequestMessage(NetworkConnection conn, AuthRequestMessage msg)
{
int nErrors = 0;
AuthResponseMessage authResponseMessage = new AuthResponseMessage
{
code = 100,
message = "Success"
};
if ((msg.authAction == "REGISTER" || msg.authAction == "BOTH") && Database.singleton.TryRegister(msg.authUsername, msg.authPassword))
{
manager.CreatePlayer(msg.authUsername);
}
else if (msg.authAction == "REGISTER")
{
nErrors++;
}
if ((msg.authAction == "LOGIN" || msg.authAction == "BOTH") && !Database.singleton.TryLogin(msg.authUsername, msg.authPassword))
{
nErrors++;
}
if (nErrors > 0)
{
authResponseMessage.code = 200;
authResponseMessage.message = "Invalid Credentials";
}
else
{
base.OnServerAuthenticated.Invoke(conn);
conn.Send(authResponseMessage);
}
if (nErrors > 0)
{
conn.isAuthenticated = false;
Invoke(nameof(conn.Disconnect), 1);
}
}
/// <summary>
/// Called on client when the server's AuthResponseMessage arrives
/// </summary>
/// <param name="msg">The message payload</param>
public void OnAuthResponseMessage(AuthResponseMessage msg)
{
if (msg.code == 100)
{
Debug.Log($"Authentication Response: {msg.message}");
// Authentication has been accepted
ClientAccept();
}
else
{
Debug.LogError($"Authentication Response: {msg.message}");
// Authentication has been rejected
// StopHost works for both host client and remote clients
NetworkManager.singleton.StopHost();
// Do this AFTER StopHost so it doesn't get cleared / hidden by OnClientDisconnect
LoginUI.instance.errorText.text = msg.message;
LoginUI.instance.errorText.gameObject.SetActive(true);
}
}
public void OnAuthResponseMessage(NetworkConnection conn, AuthResponseMessage msg)
{
if (msg.code == 100)
{
if (logger.LogEnabled())
{
logger.LogFormat(LogType.Log, "Authentication Response: {0}", msg.message);
}
clientStatus = "Ticket accepted";
// Invoke the event to complete a successful authentication
OnClientAuthenticated.Invoke(conn);
}
else
{
logger.LogFormat(LogType.Error, "Authentication Response: {0}", msg.message);
clientStatus = String.Format("Ticket rejected ({0})", msg.message);
// Set this on the client for local reference
conn.isAuthenticated = false;
// disconnect the client
conn.Disconnect();
// debug/test...
if (!String.IsNullOrEmpty(getServerKey()))
{
TimedTicket t = new TimedTicket();
try {
t.Parse(ticketString);
t.Sign(getServerKey());
string ts = t.ToString();
logger.LogFormat(LogType.Error, "Self-sign ticket: {0}", ts);
} catch (FormatException e) {
logger.LogFormat(LogType.Error, "problem making self-sign ticket: {0}", e);
}
}
}
}
public async void OnAuthRequestMessage(NetworkConnection conn, AuthRequestMessage msg)
{
bool isValid = await loginService.Validate(msg.accessToken);
if (!isValid)
{
StartCoroutine(DelayedDisconnect(conn, "Invalid access token."));
return;
}
Jwt jwt = new Jwt(msg.accessToken);
string[] allowedUserIds = GameState.singleton.gameServerModel.allowedUserIds;
if (allowedUserIds.Length > 0 && !allowedUserIds.Contains(jwt.payload.user._id))
{
StartCoroutine(DelayedDisconnect(conn, "User not allowed."));
return;
}
Debug.Log("User is allowed.");
// Set authenticationData for other scripts to use.
GroupModel groupModel = await GetGroupModel(msg.groupId, jwt.payload.user._id);
conn.authenticationData = new AuthenticationData {
groupModel = groupModel,
userModel = jwt.payload.user
};
// Create and send msg to client so it knows to proceed.
AuthResponseMessage authResponseMessage = new AuthResponseMessage {
code = 200,
message = "Success"
};
conn.Send(authResponseMessage);
OnServerAuthenticated.Invoke(conn);
}
