/// <summary>
/// Authenticates the specified credentials and returns whether the authentication was successful or not.
/// </summary>
/// <param name="credentials">Credentials to be used for authentication</param>
/// <param name="authenticatedIdentity">Authenticated identity (null when authentication fails)</param>
/// <returns>True when authentication was successful, otherwise false</returns>
public bool Authenticate(Credential[] credentials, out RemotingIdentity authenticatedIdentity)
{
if (_config.AuthenticationProvider == null)
{
authenticatedIdentity = null;
return(false);
}
return(_config.AuthenticationProvider.Authenticate(credentials, out authenticatedIdentity));
}
/// <summary>
/// Processes a wire message that contains a authentication request message, which is sent from a client to request authentication of a set of credentials.
/// </summary>
/// <param name="request">Wire message from client</param>
private void ProcessAuthenticationRequestMessage(WireMessage request)
{
if (_isAuthenticated)
{
return;
}
Identity = null;
var sharedSecret =
MessageEncryption
? SessionId.ToByteArray()
: null;
var authRequestMessage =
_server.Serializer
.Deserialize <AuthenticationRequestMessage>(
_server.MessageEncryptionManager.GetDecryptedMessageData(
message: request,
serializer: _server.Serializer,
sharedSecret: sharedSecret,
sendersPublicKeyBlob: _clientPublicKeyBlob,
sendersPublicKeySize: _keyPair?.KeySize ?? 0));
_isAuthenticated = _server.Authenticate(authRequestMessage.Credentials, out var authenticatedIdentity);
if (_isAuthenticated)
{
Identity = authenticatedIdentity;
}
var authResponseMessage =
new AuthenticationResponseMessage
{
IsAuthenticated = _isAuthenticated,
AuthenticatedIdentity = authenticatedIdentity
};
var serializedAuthResponse = _server.Serializer.Serialize(authResponseMessage);
var wireMessage =
_server.MessageEncryptionManager.CreateWireMessage(
serializedMessage: serializedAuthResponse,
serializer: _server.Serializer,
sharedSecret: sharedSecret,
keyPair: _keyPair,
messageType: "auth_response");
_rawMessageTransport.SendMessage(
_server.Serializer.Serialize(wireMessage));
}
public bool Authenticate(Credential[] credentials, out RemotingIdentity authenticatedIdentity)
{
var success = AuthenticateFake(credentials);
authenticatedIdentity =
new RemotingIdentity()
{
AuthenticationType = "Fake",
Domain = "domain",
IsAuthenticated = success,
Name = credentials[0].Value,
Roles = new[] { "Test" }
};
return(success);
}
/// <summary>
/// Disconnects from the server. The server is actively notified about disconnection.
/// </summary>
public void Disconnect()
{
if (_channel != null && HasSession)
{
if (_keepSessionAliveTimer != null)
{
_keepSessionAliveTimer.Stop();
_keepSessionAliveTimer.Dispose();
_keepSessionAliveTimer = null;
}
byte[] sharedSecret =
MessageEncryption
? _sessionId.ToByteArray()
: null;
var goodbyeMessage =
new GoodbyeMessage()
{
SessionId = _sessionId
};
var wireMessage =
MessageEncryptionManager.CreateWireMessage(
messageType: "goodbye",
serializer: Serializer,
serializedMessage: Serializer.Serialize(goodbyeMessage),
keyPair: _keyPair,
sharedSecret: sharedSecret);
byte[] rawData = Serializer.Serialize(wireMessage);
_goodbyeCompletedWaitHandle.Reset();
_channel.RawMessageTransport.SendMessage(rawData);
_goodbyeCompletedWaitHandle.Wait(10000);
}
_channel?.Disconnect();
_handshakeCompletedWaitHandle?.Reset();
_authenticationCompletedWaitHandle?.Reset();
Identity = null;
}
/// <summary>
/// Processes a authentication response message from server.
/// </summary>
/// <param name="message">Deserialized WireMessage that contains a AuthenticationResponseMessage</param>
private void ProcessAuthenticationResponseMessage(WireMessage message)
{
byte[] sharedSecret =
MessageEncryption
? _sessionId.ToByteArray()
: null;
var authResponseMessage =
Serializer
.Deserialize <AuthenticationResponseMessage>(
MessageEncryptionManager.GetDecryptedMessageData(
message: message,
serializer: Serializer,
sharedSecret: sharedSecret,
sendersPublicKeyBlob: _serverPublicKeyBlob,
sendersPublicKeySize: _keyPair?.KeySize ?? 0));
_isAuthenticated = authResponseMessage.IsAuthenticated;
Identity = _isAuthenticated ? authResponseMessage.AuthenticatedIdentity : null;
_authenticationCompletedWaitHandle.Set();
}
