// Won't be added till server admin verification is added
private bool editValue(ClientWorkObject workObject, string username, string password, string valueTitle, string valueString)
{
string returnedCheckedInformation = CheckUserInformation(username, password);
if (returnedCheckedInformation == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_EDITVALUE_USEREXIST"); return(true);
}
else if (returnedCheckedInformation == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_EDITVALUE_AUTHERROR"); return(true);
}
else if (returnedCheckedInformation == true.ToString())
{
if (CheckOP(username))
{
string ValueFileName = Path.Combine(globalSettingDirectories, valueTitle + ".dat");
File.WriteAllText(ValueFileName, Encrypt(valueString));
workObject.clientSender.Send(workObject, "USRDBS_EDITVALUE_TRUE");
}
else
{
workObject.clientSender.Send(workObject, "USRDBS_EDITVALUE_OPERROR"); return(true);
}
}
return(false);
}
private bool getUserSetting(ClientWorkObject workObject, string username, string password, string userSettingTitle)
{
string checkUserSetting = checkusersetting(username, password, userSettingTitle);
if (checkUserSetting == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_GETUSERSETTING_USEREXIST"); return(true);
}
else if (checkUserSetting == "AuthError")
{
workObject.clientSender.Send(workObject, "USRDBS_GETUSERSETTING_AUTHERROR"); return(true);
}
else if (checkUserSetting == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_GETUSERSETTING_SETTINGEXIST"); return(true);
}
else if (checkUserSetting == "unknownerror")
{
return(false);
}
else if (checkUserSetting == true.ToString())
{
string UserSettingFileDirectory = Path.Combine(getUserSettingsDirectory(username), userSettingTitle + ".dat");
workObject.clientSender.Send(workObject, Decrypt(File.ReadAllText(UserSettingFileDirectory))); return(true);
}
return(false);
}
private bool checkUserSetting(ClientWorkObject workObject, string username, string password, string userSettingTitle)
{
string checkUserSetting = checkusersetting(username, password, userSettingTitle);
if (checkUserSetting == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_CHECKUSERSETTING_USEREXIST"); return(true);
}
else if (checkUserSetting == "AuthError")
{
workObject.clientSender.Send(workObject, "USRDBS_CHECKUSERSETTING_AUTHERROR"); return(true);
}
else if (checkUserSetting == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_CHECKUSERSETTING_FALSE"); return(true);
}
else if (checkUserSetting == "unknownerror")
{
return(false);
}
else if (checkUserSetting == true.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_CHECKUSERSETTING_TRUE"); return(true);
}
return(false);
}
public static string[] bytesToStringArray(ClientWorkObject workObject, int bytesRead, AsynchronousSocketListener listener)
{
string[] returnStringArray = null;
//int bytesRead = workObject.clientSocket.EndReceive(result);
if (bytesRead > 0)
{
workObject.sb.Append(Encoding.ASCII.GetString(workObject.buffer, 0, bytesRead));
string content = workObject.sb.ToString();
if (content.IndexOf("<EOF>") > -1)
{
workObject.sb = new StringBuilder();
workObject.buffer = new byte[ClientWorkObject.BufferSize];
returnStringArray = content.Split(new string[] { "|SPLT|", "<EOF>" },
StringSplitOptions.RemoveEmptyEntries);
}
else
{
listener.ClientBeginReceive(workObject);
}
}
return(returnStringArray);
}
public bool ProcessUniversalPacketCommand(UniversalPacket universalPacket, ClientWorkObject client, AsynchronousSocketListener server)
{
bool sentClientData = false;
string[] commandArgs = ((string[])JsonConvert.DeserializeObject <string[]>(universalPacket.MessageData.Data));
//Process plugins
UniversalPlugin plugin = server.GetPlugin(commandArgs[0]);
if (plugin != null)
{
sentClientData = plugin.core.Invoke(client, commandArgs);
server.serverPluginLogger.AddToLog(ILogger.Levels.INFO, "Client [" + client.clientTracker.userID + "] has used command [" + plugin.core.Name + ".");
}
//Processes default commands
if (!sentClientData)
{
foreach (IUniversalCommand universalCommand in UniversalCommand.GetDefaultCommands())
{
if (universalCommand.GetNamespace().ToLower() == commandArgs[0].ToLower())
{
bool tmpbool = universalCommand.Invoke(commandArgs, universalPacket, client);
server.serverPluginLogger.AddToLog(ILogger.Levels.INFO, "Client [" + client.clientTracker.userID + "] has used command [" + universalCommand.GetNamespace() + ".");
if (tmpbool == true)
{
sentClientData = true; return(tmpbool);
}
}
}
}
return(sentClientData);
}
private bool changeUsername(ClientWorkObject workObject, string username, string password, string newUsername)
{
string returnedCheckedInformation = CheckUserInformation(username, password);
if (returnedCheckedInformation == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_CHANGEUSER_USEREXIST"); return(true);
}
else if (returnedCheckedInformation == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_CHANGEUSER_AUTHERROR"); return(true);
}
else if (returnedCheckedInformation == true.ToString())
{
string[] oldData = Decrypt(File.ReadAllText(getUserFile(username))).Split(':');
string Email = oldData[2]; bool Verified = bool.Parse(oldData[3]); password = sha512Encryption.Encrypt(password);
string userContent = newUsername + ":" + password + ":" + Email + ":" + Verified.ToString();
Directory.CreateDirectory(getUserDirectory(newUsername));
Directory.CreateDirectory(getUserSettingsDirectory(newUsername));
File.Create(getUserFile(newUsername)).Close();
File.WriteAllText(getUserFile(newUsername), Encrypt(userContent));
foreach (FileInfo fi in new DirectoryInfo(getUserSettingsDirectory(username)).GetFiles())
{
fi.CopyTo(Path.Combine(getUserSettingsDirectory(newUsername), fi.Name));
}
Directory.Delete(getUserDirectory(username), true);
workObject.clientSender.Send(workObject, "USRDBS_CHANGEUSER_TRUE"); return(true);
}
return(false);
}
private bool editUserSetting(ClientWorkObject workObject, string username, string password, string userSettingTitle, string userSettingValue)
{
string userInformation = CheckUserInformation(username, password);
if (userInformation == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_EDITUSERSETTING_USEREXIST"); return(true);
}
else if (userInformation == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_EDITUSERSETTING_AUTHERROR"); return(true);
}
else if (userInformation == true.ToString())
{
string UserSettingFileDirectory = Path.Combine(getUserSettingsDirectory(username), userSettingTitle + ".dat");
if (!File.Exists(UserSettingFileDirectory))
{
File.Create(UserSettingFileDirectory).Close();
}
File.WriteAllText(UserSettingFileDirectory, Encrypt(userSettingValue));
workObject.clientSender.Send(workObject, "USRDBS_EDITUSERSETTING_TRUE"); return(true);
}
return(false);
}
public bool Invoke(ClientWorkObject clientObject, string[] commandArgs)
{
try
{
if (commandArgs[1].ToUpper() == "ADDUSER")
{
return(addUser(clientObject, commandArgs[2], commandArgs[3], commandArgs[4]));
}
else if (commandArgs[1].ToUpper() == "DELETEUSER")
{
return(deleteUser(clientObject, commandArgs[2], commandArgs[3]));
}
else if (commandArgs[1].ToUpper() == "LOGINUSER")
{
return(loginUser(clientObject, commandArgs[2], commandArgs[3]));
}
else if (commandArgs[1].ToUpper() == "CHANGEUSER")
{
return(changeUsername(clientObject, commandArgs[2], commandArgs[3], commandArgs[4]));
}
else if (commandArgs[1].ToUpper() == "CHANGEPASSWORD")
{
return(changePassword(clientObject, commandArgs[2], commandArgs[3], commandArgs[4]));
}
else if (commandArgs[1].ToUpper() == "GETVALUE")
{
return(getValue(clientObject, commandArgs[2]));
}
else if (commandArgs[1].ToUpper() == "CHECKVALUE")
{
return(checkValue(clientObject, commandArgs[2]));
}
else if (commandArgs[1].ToUpper() == "EDITVALUE")
{
return(editValue(clientObject, commandArgs[2], commandArgs[3], commandArgs[4], commandArgs[5]));
}
else if (commandArgs[1].ToUpper() == "CHECKUSERSETTING")
{
return(checkUserSetting(clientObject, commandArgs[2], commandArgs[3], commandArgs[4]));
}
else if (commandArgs[1].ToUpper() == "GETUSERSETTING")
{
return(getUserSetting(clientObject, commandArgs[2], commandArgs[3], commandArgs[4]));
}
else if (commandArgs[1].ToUpper() == "EDITUSERSETTING")
{
return(editUserSetting(clientObject, commandArgs[2], commandArgs[3], commandArgs[4], commandArgs[5]));
}
}
catch (Exception e)
{
clientObject.clientSender.Send(clientObject, "USRDBS_ERROR");
ServerAPI.Log.AddToLog(ILogger.Levels.WARN, "Exception occurred in UserDatabase plugin.");
ServerAPI.Log.LogExceptions(e);
return(true);
}
return(false);
}
public void PostProcessPacket(UniversalGetPacket packet, ClientWorkObject client, AsynchronousSocketListener server)
{
if (Type.GetType(packet.MessageHeader.type) == typeof(string))
{
string messageData = (string)packet.MessageData.Data;
using (CommandManager commandManager = new CommandManager(server))
{
commandManager.ProcessUniversalGetPacketCommand(messageData, client, server);
}
}
}
private void onSocketAccepted(IAsyncResult result)
{
// This is the client socket, where you send/receive data from after accepting. Keep it in a List<Socket> collection if you need to.
Socket client = serverlistener.EndAccept(result);
ILogger.AddToLog("INFO", "Accepted client endpoint [" + client.RemoteEndPoint + "]");
ClientWorkObject workObject = new ClientWorkObject(client, this);
client.BeginReceive(workObject.buffer, 0, workObject.buffer.Length, SocketFlags.None, onDataReceived, workObject);
serverlistener.BeginAccept(onSocketAccepted, null);
}
public void Send(ClientWorkObject workObject, string data, bool useEncryption = true)
{
string header = useEncryption + "|";
if (useEncryption)
{
data = workObject.Encryption.Encrypt(data, workObject.Encryption.GetClientPublicKey());
}
data = header + data;
workObject.clientSocket.Send(Encoding.ASCII.GetBytes(data));
}
public bool Invoke(string[] CommandArgs, UniversalPacket universalPacket, ClientWorkObject client)
{
if (universalPacket.MessageHeader.status == UniversalPacket.HTTPSTATUS.POST)
{
client.Encryption.SetClientPrivateKey(CommandArgs[1]);
client.serverSocket.Send(client, true.ToString());
}
else
{
client.serverSocket.Send(client, Messages.PostStatusCodeRequiredErrorMessage);
}
return(true);
}
private void postProcessUniversalPacket(ClientWorkObject workObject, IUniversalPacket universalPacket)
{
UniversalPacket clientPacket = (UniversalPacket)universalPacket;
//Checks if the user ID is registered (IsLoggedIn)
//If the ID is not stored then stores the ID and
//the IP of the client for logging reasons.
if (!workObject.clientTracker.IsLoggedIn)
{
workObject.clientTracker.SetID(clientPacket.MessageSignature.clientId,
((IPEndPoint)workObject.clientSocket.RemoteEndPoint).Address.ToString(),
clientPacket.MessageSignature.clientIp);
}
clientPacket.MessageHeader.dateTime = DateTime.Now; //Sets the datetime if its null
string s = workObject.Encryption.GetServerPrivateKey();
//Decrypts the information
if (clientPacket.MessageData.IsEncrypted)
{
clientPacket.MessageData.Data = workObject.Encryption.Decrypt(clientPacket.MessageData.Data, workObject.Encryption.GetServerPrivateKey());
}
OnBeforeClientRequestEventArgs onBeforeRequest = new OnBeforeClientRequestEventArgs {
RawData = clientPacket.MessageData.Data, Client = workObject
};
parent.GetEventTracker().OnBeforeClientRequest(this, onBeforeRequest);
//Processes the command
bool sentClientData = false;
if (onBeforeRequest.CancelRequest == Model.Utility.MoonbyteCancelRequest.Continue)
{
using (CommandManager commandManager = new CommandManager(parent))
{
sentClientData = commandManager.ProcessUniversalPacketCommand(clientPacket, workObject, workObject.serverSocket);
}
}
else
{
workObject.serverSocket.Send(workObject, "Unauthorized", false);
}
//Sends data to client if false
if (!sentClientData)
{
workObject.serverSocket.Send(workObject, "UnknownCommand", false);
}
}
private bool checkValue(ClientWorkObject workObject, string valueTitle)
{
string CheckValue = checkglobalvalue(valueTitle);
if (CheckValue == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_CHECKVALUE_FALSE"); return(true);
}
else if (CheckValue == true.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_CHECKVALUE_TRUE"); return(true);
}
return(false);
}
private void onDataReceived(IAsyncResult result)
{
ClientWorkObject workObject = result.AsyncState as ClientWorkObject;
try
{
string[] dataReceived = bytesToStringArray(workObject, result);
networkDataProcessor.ProcessDataReceived(workObject, dataReceived);
}
catch (Exception e)
{
ILogger.LogExceptions(e);
workObject.Dispose();
}
}
private void postProcessUniversalPacket(ClientWorkObject workObject, IUniversalPacket universalPacket)
{
if (universalPacket.GetType() == typeof(UniversalGetPacket))
{
UniversalGetPacket packet = (UniversalGetPacket)universalPacket;
packet.ToString();
}
else if (universalPacket.GetType() == typeof(UniversalPacket))
{
UniversalPacket packet = (UniversalPacket)universalPacket;
}
else
{
//returns error
}
}
private bool getValue(ClientWorkObject workObject, string valueTitle)
{
string CheckValue = checkglobalvalue(valueTitle);
if (CheckValue == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_GETVALUE_VALUEEXIST"); return(true);
}
else if (CheckValue == true.ToString())
{
string ValueFileName = Path.Combine(globalSettingDirectories, valueTitle + ".dat");
workObject.clientSender.Send(workObject, Decrypt(File.ReadAllText(ValueFileName))); return(true);
}
return(false);
}
public bool Invoke(ClientWorkObject clientObject, string[] commandArgs)
{
if (commandArgs[1].ToUpper() == "TESTING")
{
return(clientObject.clientSender.Send(clientObject, "Testing command activated"));
}
if (commandArgs[1].ToUpper() == "FOO")
{
return(clientObject.clientSender.Send(clientObject, "Foo command activated"));
}
if (commandArgs[1].ToUpper() == "BAR")
{
return(clientObject.clientSender.Send(clientObject, "Bar command activated"));
}
return(false);
}
private bool deleteUser(ClientWorkObject workObject, string username, string password)
{
string returnedCheckedInformation = CheckUserInformation(username, password);
if (returnedCheckedInformation == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_DELETEUSER_USEREXIST"); return(true);
}
else if (returnedCheckedInformation == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_DELETEUSER_AUTHERROR"); return(true);
}
Directory.Delete(getUserDirectory(username), true);
workObject.clientSender.Send(workObject, "USRDBS_DELETEUSER_TRUE");
return(true);
}
private bool loginUser(ClientWorkObject workObject, string username, string password)
{
string returnedCheckedInformation = CheckUserInformation(username, password);
if (returnedCheckedInformation == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_LOGINUSER_USEREXIST"); return(true);
}
else if (returnedCheckedInformation == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_LOGINUSER_FALSE"); return(true);
}
else if (returnedCheckedInformation == true.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_LOGINUSER_TRUE"); return(true);
}
return(false);
}
private void onDataReceived(IAsyncResult result)
{
ClientWorkObject workObject = result.AsyncState as ClientWorkObject;
try
{
string[] dataReceived = Utility.bytesToStringArray(workObject, workObject.clientSocket.EndReceive(result), this);
if (dataReceived != null)
{
networkDataProcessor.ProcessDataReceived(workObject, dataReceived);
workObject.clientSocket.BeginReceive(workObject.buffer, 0, workObject.buffer.Length, SocketFlags.None, onDataReceived, workObject);
}
}
catch (Exception e)
{
ILogger.LogExceptions(e);
workObject.clientSender.Send(workObject, "error");
}
}
private bool addUser(ClientWorkObject workObject, string username, string password, string Email)
{
if (CheckUserInformation(username, password) != "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_USRADD_USEREXIST"); return(true);
}
password = sha512Encryption.Encrypt(password);
Directory.CreateDirectory(getUserDirectory(username));
Directory.CreateDirectory(getUserSettingsDirectory(username));
File.Create(getUserFile(username)).Close();
string userContent = username + ":" + password + ":" + Email + ":" + false.ToString();
File.WriteAllText(getUserFile(username), Encrypt(userContent));
workObject.clientSender.Send(workObject, "USRDBS_USRADD_TRUE");
return(true);
}
private bool checkInternalCommands(string rawCommand, ClientWorkObject workObject)
{
bool returnValue = false;
string[] args = rawCommand.Split(' ');
if (args[0].ToUpper() == "KEY_SERVERPUBLIC")
{
Send(workObject, workObject.Encryption.GetServerPublicKey(), false); returnValue = true;
}
if (args[0].ToUpper() == "KEY_CLIENTPUBLIC")
{
workObject.Encryption.SetClientPublicKey(workObject.Encryption.Decrypt(args[1], workObject.Encryption.GetServerPrivateKey())); Send(workObject, true.ToString(), false); returnValue = true;
}
if (args[0].ToUpper() == "KEY_CLIENTPRIVATE")
{
workObject.Encryption.SetClientPrivateKey(workObject.Encryption.Decrypt(args[1], workObject.Encryption.GetServerPrivateKey())); Send(workObject, true.ToString(), false); returnValue = true;
}
return(returnValue);
}
public void Send(ClientWorkObject workObject, string data, bool useEncryption = true)
{
try
{
UniversalServerPacket serverPacket = new UniversalServerPacket
{
Encrypted = useEncryption,
Message = data
};
if (useEncryption)
{
serverPacket.Message = workObject.Encryption.Encrypt(data, workObject.Encryption.GetClientPublicKey());
}
workObject.clientSocket.Send(Encoding.ASCII.GetBytes(JsonConvert.SerializeObject(serverPacket)));
}
catch (Exception e)
{
ILogger.LogExceptions(e);
workObject.Dispose();
}
}
private bool changePassword(ClientWorkObject workObject, string username, string password, string newPassword)
{
string returnedCheckedInformation = CheckUserInformation(username, password);
if (returnedCheckedInformation == "USERDOESNOTEXIST")
{
workObject.clientSender.Send(workObject, "USRDBS_CHANGEPASSWORD_USEREXIST"); return(true);
}
else if (returnedCheckedInformation == false.ToString())
{
workObject.clientSender.Send(workObject, "USRDBS_CHANGEPASSWORD_AUTHERROR"); return(true);
}
else if (returnedCheckedInformation == true.ToString())
{
string[] oldData = Decrypt(File.ReadAllText(getUserFile(username))).Split(':');
string Email = oldData[2]; bool Verified = bool.Parse(oldData[3]); newPassword = sha512Encryption.Encrypt(newPassword);
string userContent = username + ":" + newPassword + ":" + Email + ":" + Verified.ToString();
File.WriteAllText(getUserFile(username), Encrypt(userContent));
workObject.clientSender.Send(workObject, "USRDBS_CHANGEPASSWORD_TRUE"); return(true);
}
return(false);
}
public bool Invoke(string[] commandArgs, UniversalPacket universalPacket, ClientWorkObject client)
{
client.serverSocket.Send(client, client.Encryption.GetServerPublicKey(), false);
return(true);
}
public void ProcessUniversalGetPacketCommand(string messageData, ClientWorkObject client, AsynchronousSocketListener server)
{
server.Send(client, "Unsupported Request");
}
public void ProcessDataReceived(ClientWorkObject workObject, string[] dataReceived) => postProcessUniversalPacket(workObject, getUniversalPacket(dataReceived));
public void ClientBeginReceive(ClientWorkObject workObject) => workObject.clientSocket.BeginReceive(workObject.buffer, 0, workObject.buffer.Length, SocketFlags.None, onDataReceived, workObject);
public bool Send(ClientWorkObject WorkObject, string Data)
{
WorkObject.serverSocket.Send(WorkObject, Data); return(true);
}
