private void ListenForEvents()
{
_eventClient = new System.Net.Sockets.TcpClient();
_eventClient.Connect(_host, _eventPort);
_eventStream = OnPrepareStream(_eventClient.GetStream());
while (_listenForEvents)
{
var rawMessage = TcpProtocolHelper.Read(_eventStream);
if (rawMessage == null)
{
break;
}
var message = TcpMessage.FromRaw(rawMessage);
foreach (var handler in _eventHandlers)
{
if (handler(message))
{
break;
}
}
}
}
private TcpMessage HandleUniqueItemQuery(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.UniqueItemQuery))
{
return(null);
}
if (!IsAuthenticated(host))
{
throw AuthException.NotLoggedIn();
}
var request = new ParamTcpMessage(message);
var response = new ObjectTcpMessage <DbItem>(TcpRequestType.List);
if (request.HasParam("id"))
{
var id = request.GetParamAsNullableInt("id");
if (id != null)
{
var item = _dataService.GetItem(id.Value);
response.Add(item);
return(response);
}
}
return(TcpMessage.Error("Missing or badly formatted query parameters"));
}
private void Init(string serverPublicKey = null)
{
_asyncServerCryptographyHandler = new RSACryptographyHandler();
_asyncClientCryptographyHandler = new RSACryptographyHandler { IsReady = true };
_syncCryptographyHandler = new AESCryptographyHandler();
// Send client's RSA public key and request the server's RSA public key
var request = new TcpMessage("rsakey") { Content = _asyncClientCryptographyHandler.PublicKey };
var response = SendAndReceive(request);
if (response.HasType("rsakey"))
{
var key = response.Content;
if (!string.IsNullOrEmpty(serverPublicKey) && !serverPublicKey.Equals(key))
throw new Exception("Server did not return correct public key");
_asyncServerCryptographyHandler.PublicKey = key;
}
// Request the AES key from the server
request = new TcpMessage("aeskey");
response = SendAndReceive(request);
if (response.HasType("aeskey"))
_syncCryptographyHandler.KeyAsString = response.Content;
// Request the AES initialization vector from the server
request = new TcpMessage("aesiv");
response = SendAndReceive(request);
if (response.HasType("aesiv"))
_syncCryptographyHandler.InitializationVectorAsString = response.Content;
}
private TcpMessage HandleInsertItem(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.InsertItem))
{
return(null);
}
if (!IsAuthenticated(host))
{
throw AuthException.NotLoggedIn();
}
var request = new ObjectTcpMessage <DbItem>(message);
var response = new ObjectTcpMessage <DbItem>(TcpRequestType.List);
var item = request.Item;
if (item != null)
{
_dataService.Insert(item);
response.Add(item); // Send the item back to report assigned Id
}
return(response);
}
private TcpMessage HandleMultiRelationQuery(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.MultiRelationQuery))
{
return(null);
}
if (!IsAuthenticated(host))
{
throw AuthException.NotLoggedIn();
}
var request = new ParamTcpMessage(message);
var response = new ObjectTcpMessage <DbRelation>(TcpRequestType.List);
if (request.HasParam("from_id"))
{
var fromId = request.GetParamAsNullableInt("from_id");
var items = _dataService.GetRelations(fromId);
response.Add(items);
return(response);
}
return(TcpMessage.Error("Missing or badly formatted query parameters"));
}
public static TcpMessage FromRaw(string rawContent)
{
var message = new TcpMessage();
message.SetRaw(rawContent);
return(message);
}
private TcpMessage HandleLoginRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("loginbasic"))
{
return(null);
}
var request = new ParamTcpMessage(message);
var username = request.GetParam("username");
var password = request.GetParam("password");
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
var userItem = _dataService.GetItemByRelation(UsersParentId, username);
if (userItem == null)
{
if (!AutoRegisterUsers)
{
return(TcpMessage.Error("User not found. Automatic registering of users is currently disabled."));
}
// Register
userItem = new DbItem(username);
_dataService.Insert(userItem);
_dataService.Insert(new DbRelation(UsersParentId, username, userItem.Id));
var saltItem = new DbItem(HashHelper.CreateSaltString(10));
_dataService.Insert(saltItem);
_dataService.Insert(new DbRelation(userItem.Id, "salt", saltItem.Id));
var passwordItem = new DbItem(HashHelper.GenerateSaltedHash(password, saltItem.Value));
_dataService.Insert(passwordItem);
_dataService.Insert(new DbRelation(userItem.Id, "password", passwordItem.Id));
}
else
{
// Login
var saltItem = _dataService.GetItemByRelation(userItem.Id, "salt");
var passwordItem = _dataService.GetItemByRelation(userItem.Id, "password");
if (saltItem == null || saltItem.Value == null || passwordItem == null || passwordItem.Value == null || !HashHelper.ConfirmPassword(passwordItem.Value, password, saltItem.Value))
{
return(TcpMessage.Error("Login failed. Wrong password."));
}
}
_hostUsers[host] = userItem;
var response = new ObjectTcpMessage <DbItem>(TcpRequestType.Ok);
response.Add(userItem);
return(response);
}
return(TcpMessage.Error("Missing or badly formatted login parameters"));
}
public void Add(TcpMessage message)
{
if (message == null)
return;
lock (_messages)
{
_messages.AddLast(message);
}
_eventListener.Set();
}
public void Add(TcpMessage message)
{
if (message == null)
{
return;
}
lock (_messages)
{
_messages.AddLast(message);
}
_eventListener.Set();
}
private bool HandleItemChanged(TcpMessage request)
{
if (!request.HasType(TcpRequestType.List))
{
return(false);
}
var items = new ObjectTcpMessage <ItemChangeEvent>(request).Items;
if (items != null)
{
OnItemsChanged(items.Select(i => i.Id).ToList());
}
return(true);
}
private TcpMessage HandleAESKeyExchangeRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("aeskey"))
{
return(null);
}
var client = GetClient(host);
client.AESHandler.GenerateKey();
return(new TcpMessage("aeskey")
{
Content = client.AESHandler.KeyAsString
});
}
private bool HandleRelationRemoved(TcpMessage request)
{
if (!request.HasType(TcpRequestType.DeleteRelation))
{
return(false);
}
var relation = new ObjectTcpMessage <DbRelation>(request).Item;
if (relation != null)
{
OnRelationRemoved(relation);
}
return(true);
}
private TcpMessage HandleRSAKeyExchangeRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("rsakey"))
{
return(null);
}
var client = GetClient(host);
client.RSAHandler.PublicKey = message.Content;
client.EncryptNextMessageAsync = false;
return(new TcpMessage("rsakey")
{
Content = _serverCryptographyHandler.PublicKey
});
}
private TcpMessage HandleDeleteItem(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.DeleteItem))
return null;
if (!IsAuthenticated(host))
throw AuthException.NotLoggedIn();
var request = new ObjectTcpMessage<DbItem>(message);
var item = request.Item;
if (item != null)
{
_dataService.Delete(item);
}
return new TcpMessage(TcpRequestType.Ok);
}
private void Init(string serverPublicKey = null)
{
_asyncServerCryptographyHandler = new RSACryptographyHandler();
_asyncClientCryptographyHandler = new RSACryptographyHandler {
IsReady = true
};
_syncCryptographyHandler = new AESCryptographyHandler();
// Send client's RSA public key and request the server's RSA public key
var request = new TcpMessage("rsakey")
{
Content = _asyncClientCryptographyHandler.PublicKey
};
var response = SendAndReceive(request);
if (response.HasType("rsakey"))
{
var key = response.Content;
if (!string.IsNullOrEmpty(serverPublicKey) && !serverPublicKey.Equals(key))
{
throw new Exception("Server did not return correct public key");
}
_asyncServerCryptographyHandler.PublicKey = key;
}
// Request the AES key from the server
request = new TcpMessage("aeskey");
response = SendAndReceive(request);
if (response.HasType("aeskey"))
{
_syncCryptographyHandler.KeyAsString = response.Content;
}
// Request the AES initialization vector from the server
request = new TcpMessage("aesiv");
response = SendAndReceive(request);
if (response.HasType("aesiv"))
{
_syncCryptographyHandler.InitializationVectorAsString = response.Content;
}
}
private TcpMessage HandleDeleteItem(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.DeleteItem))
{
return(null);
}
if (!IsAuthenticated(host))
{
throw AuthException.NotLoggedIn();
}
var request = new ObjectTcpMessage <DbItem>(message);
var item = request.Item;
if (item != null)
{
_dataService.Delete(item);
}
return(new TcpMessage(TcpRequestType.Ok));
}
private TcpMessage HandleAESKeyExchangeRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("aeskey"))
return null;
var client = GetClient(host);
client.AESHandler.GenerateKey();
return new TcpMessage("aeskey") { Content = client.AESHandler.KeyAsString };
}
private bool HandleRelationRemoved(TcpMessage request)
{
if (!request.HasType(TcpRequestType.DeleteRelation))
return false;
var relation = new ObjectTcpMessage<DbRelation>(request).Item;
if (relation != null)
OnRelationRemoved(relation);
return true;
}
private TcpMessage HandleRSAKeyExchangeRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("rsakey"))
return null;
var client = GetClient(host);
client.RSAHandler.PublicKey = message.Content;
client.EncryptNextMessageAsync = false;
return new TcpMessage("rsakey") { Content = _serverCryptographyHandler.PublicKey };
}
private TcpMessage HandleLoginRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("loginbasic"))
return null;
var request = new ParamTcpMessage(message);
var username = request.GetParam("username");
var password = request.GetParam("password");
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
var userItem = _dataService.GetItemByRelation(UsersParentId, username);
if (userItem == null)
{
if (!AutoRegisterUsers)
return TcpMessage.Error("User not found. Automatic registering of users is currently disabled.");
// Register
userItem = new DbItem(username);
_dataService.Insert(userItem);
_dataService.Insert(new DbRelation(UsersParentId, username, userItem.Id));
var saltItem = new DbItem(HashHelper.CreateSaltString(10));
_dataService.Insert(saltItem);
_dataService.Insert(new DbRelation(userItem.Id, "salt", saltItem.Id));
var passwordItem = new DbItem(HashHelper.GenerateSaltedHash(password, saltItem.Value));
_dataService.Insert(passwordItem);
_dataService.Insert(new DbRelation(userItem.Id, "password", passwordItem.Id));
}
else
{
// Login
var saltItem = _dataService.GetItemByRelation(userItem.Id, "salt");
var passwordItem = _dataService.GetItemByRelation(userItem.Id, "password");
if (saltItem == null || saltItem.Value == null || passwordItem == null || passwordItem.Value == null || !HashHelper.ConfirmPassword(passwordItem.Value, password, saltItem.Value))
return TcpMessage.Error("Login failed. Wrong password.");
}
_hostUsers[host] = userItem;
var response = new ObjectTcpMessage<DbItem>(TcpRequestType.Ok);
response.Add(userItem);
return response;
}
return TcpMessage.Error("Missing or badly formatted login parameters");
}
private bool HandleItemChanged(TcpMessage request)
{
if (!request.HasType(TcpRequestType.List))
return false;
var items = new ObjectTcpMessage<ItemChangeEvent>(request).Items;
if (items != null)
OnItemsChanged(items.Select(i => i.Id).ToList());
return true;
}
public ObjectTcpMessage <T> SendAndReceive <T>(TcpMessage request) where T : class
{
return(new ObjectTcpMessage <T>(SendAndReceive(request)));
}
private TcpMessage HandleUniqueItemQuery(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.UniqueItemQuery))
return null;
if (!IsAuthenticated(host))
throw AuthException.NotLoggedIn();
var request = new ParamTcpMessage(message);
var response = new ObjectTcpMessage<DbItem>(TcpRequestType.List);
if (request.HasParam("id"))
{
var id = request.GetParamAsNullableInt("id");
if (id != null)
{
var item = _dataService.GetItem(id.Value);
response.Add(item);
return response;
}
}
return TcpMessage.Error("Missing or badly formatted query parameters");
}
public static bool Write(Stream stream, TcpMessage message)
{
return(Write(stream, message.ToString()));
}
public static TcpMessage FromRaw(string rawContent)
{
var message = new TcpMessage();
message.SetRaw(rawContent);
return message;
}
private TcpMessage HandleAESInitializationVectorExchangeRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("aesiv"))
return null;
var client = GetClient(host);
client.AESHandler.GenerateInitializationVector();
client.EncryptNextMessageSync = false;
return new TcpMessage("aesiv") { Content = client.AESHandler.InitializationVectorAsString };
}
public ParamTcpMessage(TcpMessage message)
: base(message.RequestType)
{
SetByContent(message.Content);
}
private TcpMessage HandleInsertRelation(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.InsertRelation))
return null;
if (!IsAuthenticated(host))
throw AuthException.NotLoggedIn();
var request = new ObjectTcpMessage<DbRelation>(message);
var response = new ObjectTcpMessage<DbRelation>(TcpRequestType.List);
var relation = request.Item;
if (relation != null)
{
_dataService.Insert(relation);
response.Add(relation); // Send the item back to report assigned Id
}
return response;
}
public static bool Write(Stream stream, TcpMessage message)
{
return Write(stream, message.ToString());
}
private void HandleDataClientComm(object client)
{
var tcpClient = (System.Net.Sockets.TcpClient)client;
var addressSplits = tcpClient.Client.RemoteEndPoint.ToString().Split(':');
var host = new TcpConnectedHost
{
TcpClient = tcpClient,
IPAddress = addressSplits[0]
};
if (!IsAllowed(host.IPAddress))
{
Debug.WriteLine("Client refused access to data channel. IP: " + host.IPAddress);
tcpClient.Close();
return;
}
Debug.WriteLine("Client connected to data channel. IP: " + host.IPAddress);
var stream = OnPrepareStream(host.TcpClient.GetStream());
_connectedDataClients.AddLast(host);
while (true)
{
var rawRequest = TcpProtocolHelper.Read(stream);
if (rawRequest == null)
{
break;
}
rawRequest = PrepareIncommingMessage(host, rawRequest);
Debug.WriteLine(DateTime.Now.ToLongTimeString() + " [R] " + rawRequest);
TcpMessage response = null;
var request = TcpMessage.FromRaw(rawRequest);
foreach (var handler in _dataRequestHandlers)
{
try
{
response = handler.Invoke(host, request);
if (response != null)
{
break;
}
}
catch (Exception e)
{
response = TcpMessage.Error(e.ToString());
break;
}
}
if (response == null)
{
response = TcpMessage.Error("Could not handle request");
}
var responseMessage = response.ToString();
Debug.WriteLine(DateTime.Now.ToLongTimeString() + " [S] " + responseMessage);
responseMessage = PrepareOutgoingMessage(host, responseMessage);
var success = TcpProtocolHelper.Write(stream, responseMessage);
if (!success)
{
break;
}
}
Debug.WriteLine("Client disconnected from data channel. IP: " + host.IPAddress);
tcpClient.Close();
}
public ObjectTcpMessage(TcpMessage message)
: this(message.RequestType)
{
SetByContent(message.Content);
}
private TcpMessage HandleUniqueRelationQuery(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType(TcpRequestType.UniqueRelationQuery))
return null;
if (!IsAuthenticated(host))
throw AuthException.NotLoggedIn();
var request = new ParamTcpMessage(message);
var response = new ObjectTcpMessage<DbRelation>(TcpRequestType.List);
if (request.HasParam("from_id") && request.HasParam("identifier"))
{
var fromId = request.GetParamAsNullableInt("from_id");
var identifier = request.GetParam("identifier");
var relation = _dataService.GetRelation(fromId, identifier);
response.Add(relation);
return response;
}
return TcpMessage.Error("Missing or badly formatted query parameters");
}
public void Enqueue(TcpMessage message)
{
DoOnQueues(q => q.Add(message));
}
public TcpMessage SendAndReceive(TcpMessage request)
{
return(TcpMessage.FromRaw(SendAndReceive(request.ToString())));
}
private TcpMessage HandleAESInitializationVectorExchangeRequest(TcpConnectedHost host, TcpMessage message)
{
if (!message.HasType("aesiv"))
{
return(null);
}
var client = GetClient(host);
client.AESHandler.GenerateInitializationVector();
client.EncryptNextMessageSync = false;
return(new TcpMessage("aesiv")
{
Content = client.AESHandler.InitializationVectorAsString
});
}
public ParamTcpMessage(TcpMessage message)
: base(message.RequestType)
{
SetByContent(message.Content);
}
