// Deserialize received message and invoke callback that should process the message
protected override void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
var token = (HostAsyncUserToken)e.UserToken;
// decrypt message data
var decryptedMsgData = EncryptionAdapter.Decrypt(token.RecievedMsgData);
Logger.WriteStr(" Dectypted message: " + utf8.GetString(decryptedMsgData));
// deserialize to object
Message message = null;
try
{
message = WoxalizerAdapter.DeserializeFromXml(decryptedMsgData);
}
catch (Exception ex)
{
// it can be garbage or DoS attack, so better to close connection
Logger.WriteStr("ERROR: Cannot deserialize recieved message (" + ex.Message + "). Aborting connection.");
CloseConnection(e);
return;
}
var args = new HostCustomEventArgs(e.SocketError, message)
{
Token = token
};
if (token.Callback != null)
{
token.Callback.Invoke(args);
}
}
protected override void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
var token = (AsyncUserTokenBase)e.UserToken;
// decrypt message data
var decryptedMsgData = EncryptionAdapter.Decrypt(token.RecievedMsgData);
Logger.WriteStr(" Recieved message was decrypted as xml: " + utf8.GetString(decryptedMsgData));
// deserialize to object
Message message = null;
try
{
message = WoxalizerAdapter.DeserializeFromXml(decryptedMsgData);
}
catch (Exception ex)
{
Logger.WriteStr("ERROR: Cannot deserialize recieved message (" + ex.Message + "). Aborting connection.");
CloseConnection(e);
}
if (message is RequestMessage)
{
ProcessReceivedMessageRequest(e, (RequestMessage)message);
}
else if (message is ResponseMessage)
{
ProcessReceivedMessageResponse(e, (ResponseMessage)message);
}
else
{
throw new ArgumentException("Cannot determinate Message type!");
}
}
private static readonly object AutoSaveLock = new object(); // for handeling "agent list autosave" from different threads
public void Run()
{
if (ReadConfigFile())
{
Logger.CreateLogFile("logs", _logFilenamePattern); // creates "logs" directory in binaries folder and set log filename
Logger.WriteStr("Started");
Console.WriteLine("Server started. You can minimize this window (but DON'T CLOSE). ");
AppDomain currentDomain = AppDomain.CurrentDomain;
currentDomain.UnhandledException += ExceptionHandler;
EncryptionAdapter.SetEncryption(_secretKey);
_agents = new Dictionary <int, HostAsyncUserToken>();
// Try to load agents database (xml file)
LoadAgentsList();
_server = new TcpServerListenerAdv(_listenPort, _maxNumConnections, ReceiveBufferSize);
_server.Start(OnReceiveCompleted);
// Pause here
Console.WriteLine("Press any key to terminate the server process....");
Console.ReadKey();
Logger.WriteStr("TCP terminated.");
}
}
// Start sending single message to client which token belongs to.
public void Send(Message message, HostAsyncUserToken token)
{
byte[] messageToSend = WoxalizerAdapter.SerializeToXml(message);
Logger.WriteStr(" The message to be send: " + utf8.GetString(messageToSend));
// encrypt message
byte[] encryptedMsgData = EncryptionAdapter.Encrypt(messageToSend);
SendMessage(token, encryptedMsgData);
}
private void AgentStarterThread()
{
// Read configuration from file
if (!SettingsManager.ReadConfigFile())
{
_notifyIconComponent.ShowNotifiction("Error while reading configuration file.");
return;
}
if (_newServerEndPoint != null)
{
SettingsManager.ServerEndPoint = _newServerEndPoint; //override configuration file
}
EncryptionAdapter.SetEncryption(SettingsManager.SecretKey);
Logger.CreateLogFile("logs", SettingsManager.LogFilenamePattern); // creates "logs" directory in binaries folder and set log filename
Logger.WriteStr("+++ Starting Agent by user request... +++");
AgentStarted = true;
_retryIntervalCurrent = RetryIntervalInitial; //set to initial value
while (true) // always reconnect untill canceled
{
_client = new GeneralSocketClient();
_client.Connect(SettingsManager.ServerEndPoint, OnConnectToServerCompleted);
// pause here untill disconnected from server
_clientDisconnected.Reset();
_clientDisconnected.WaitOne();
if (AgentStarted)
{
Logger.WriteStr("Should be running so will try to reconnect to server in " + _retryIntervalCurrent + "seconds...");
_notifyIconComponent.ShowNotifiction("Will reconnect in " + _retryIntervalCurrent + "sec...");
Thread.Sleep(_retryIntervalCurrent * 1000);
//increase interval between reconnects up to retryIntervalMaximum value.
// it needed in case of frequent disconnects / when server is unreacheble
if (_retryIntervalCurrent < RetryIntervalMaximum)
{
_retryIntervalCurrent += 5;
}
}
else
{
break; //exit loop
}
}
Logger.WriteStr("Client terminated");
}
private void ConnectToServer()
{
// Read configuration from file
if (!SettingsManager.ReadConfigFile())
{
return; //TODO: add some message box?
}
// Initialize some global settings
Logger.CreateLogFile("logs", SettingsManager.LogFilenamePattern);
EncryptionAdapter.SetEncryption(SettingsManager.SecretKey);
// Process to connect
var messageClient = _container.Resolve <IMessageClient>();
messageClient.Connect(SettingsManager.ServerEndPoint, OnConnectToServerCompleted);
}
/// <summary>
/// This method protects data that the taxonomy marks as High Impact.
/// </summary>
/// <param name="key">The key of the data, must be validated by the caller.</param>
/// <param name="value">The value to protect, must be validated by the caller.</param>
/// <returns>The original value, or an adapter around the encrypted serialized version of the data.</returns>
/// <remarks>Data that is not serializable remains unencrypted, any failure to serialize or encrypt the data returns the data as is.
/// When considering in-memory protection, Unknown classification results in no encryption so we rely mostly on PE classifications for determining HBI.</remarks>
private object ProtectData(string key, object value)
{
// key cannot be null, empty or whitespaces, verified in calling context, no need for arg validation
// value cannot be null, verified in calling context, no need for arg validation
if (!value.GetType().IsSerializable)
{
// cannot serialize this type of data, do not attempt to encrypt, return as is
// This is a shallow test (could be aggregating non-serializable data), in this case, we will get exception below
return(value);
}
// getting the classification from the taxonomy chain informs whether or not we encrypt in-memory
switch (TaxonomyChain.AuthoritativeInstance.GetClassification(key))
{
case TaxonomyClassification.HighImpact:
// processing below switch block
break;
// For Internal and LowImpact data, we return the data directly
case TaxonomyClassification.Internal:
case TaxonomyClassification.LowImpact:
case TaxonomyClassification.Unknown:
default:
return(value);
}
try
{
// Convert the key to upper case since entropy generation depends on the key casing, and workflow context keys are case insensitive
return(BinarySerializationAdapter.CreateAdapter(data => EncryptionAdapter.CreateAdapter(this.Encryptor, key.ToUpperInvariant(), data), value));
}
catch (SerializationException)
{
// nothing to log, nothing to do (checked with Muhammad)
}
catch (CryptographicException)
{
// nothing to log, nothing to do (checked with Muhammad)
}
catch (SecurityException)
{
// nothing to log, nothing to do (checked with Muhammad)
}
// serialization or encryption failed, returning original data
return(value);
}
public void Send(Message message, Action <CustomEventArgs> callback)
{
if (!_isConnected)
{
return;
}
//TODO: check if exception needed: throw new SocketException((int)SocketError.NotConnected);
_userToken.Callback = callback;
byte[] messageToSend = WoxalizerAdapter.SerializeToXml(message);
Logger.WriteStr(" The message (xml) to be sent: " + utf8.GetString(messageToSend));
// encrypt message
byte[] encryptedMsgData = EncryptionAdapter.Encrypt(messageToSend);
SendMessage(_userToken, encryptedMsgData);
}
protected override void ProcessReceivedMessage(SocketAsyncEventArgs e)
{
// decrypt message
byte[] decryptedMsgData = EncryptionAdapter.Decrypt(_userToken.RecievedMsgData);
Logger.WriteStr(" Recieved message was decrypted as xml: " + utf8.GetString(decryptedMsgData));
// deserialize to object
Message message = null;
try
{
message = WoxalizerAdapter.DeserializeFromXml(decryptedMsgData);
}
catch (Exception ex)
{
Logger.WriteStr("ERROR: Cannot deserialize recieved message (" + ex.Message + "). Aborting connection.");
CloseConnection(e);
}
if (_userToken.Callback != null)
{
_userToken.Callback.Invoke(new CustomEventArgs(e.SocketError, message));
}
}
