public string ReadEncrypted(Transceiver connection, string message)
{
Logger.log("Encryption hook is decrypting incoming message.", Logger.Verbosity.moderate);
byte[] bytes = System.Text.Encoding.Unicode.GetBytes(message);
byte[] decrypted = Decrypt(this._local_cryptor, bytes);
string final = System.Text.Encoding.Unicode.GetString(decrypted);
try
{
Message test_message = new Message(null, final);
Logger.log("THE MESSAGE: "+test_message.DumpMessage(), Logger.Verbosity.moderate);
Logger.log("Type of message is: "+test_message.StringType(), Logger.Verbosity.moderate);
if(test_message.type == Message.Type.UserToUser)
{
/** Test for encrypted middle **/
Logger.log("Attempting to scrape inner message.", Logger.Verbosity.moderate);
XmlDocument document = new XmlDocument();
document.LoadXml(final);
XmlNodeList list = document.GetElementsByTagName("Content");
XmlElement element = (XmlElement)list.Item(0);
string core = element.InnerText;
byte[] core_bytes = System.Text.Encoding.Unicode.GetBytes(core);
byte[] decrypted_bytes = this.Decrypt(this._local_cryptor, core_bytes);
string cdecrypted = System.Text.Encoding.Unicode.GetString(decrypted_bytes);
Logger.log("Decrypted inner message: "+cdecrypted, Logger.Verbosity.loud);
element.InnerXml = cdecrypted;
return document.InnerXml;
}
else
{
return final;
}
}
catch(Exception e)
{
Logger.log("Decryptor ERROR: "+e.Message+"\n"+e.StackTrace, Logger.Verbosity.moderate);
return final;
}
}
private bool SendAuthentication(string username, string password)
{
this.SendUINotice("Sending authentication information.");
Message message = new Message();
message.type = Message.Type.UserToServer;
message.creator_plugin_hash = this._hash_code;
message.destination_plugin_hash = this._user_manager_hash;
Command contents = new Command();
contents.ctype = "login";
contents.type = MessageContent.Type.Command;
contents.AddContent("username", username);
contents.AddContent("password", password);
message.content = contents;
this._controller.connection.Write(message.DumpMessage());
return true;
}
public string WriteFilter(Message message)
{
if(message.content.type == BasicContent.Type.Chat)
{
try
{
string key = (string)this._keys[message.destination_plugin_hash];
this._remote_cryptor.FromXmlString(key);
string basemsg = message.DumpMessage();
XmlDocument document = new XmlDocument();
document.LoadXml(basemsg);
XmlNodeList list = document.GetElementsByTagName("Content");
XmlElement element = (XmlElement)list.Item(0);
string full = element.InnerXml;
byte[] full_bytes = System.Text.Encoding.Unicode.GetBytes(full);
byte[] crypted_bytes = this.Encrypt(this._remote_cryptor, full_bytes);
string crypted = System.Text.Encoding.Unicode.GetString(crypted_bytes);
element.InnerText = crypted;
return document.InnerXml;
}
catch(Exception e)
{
Logger.log("Error filtering: "+e.Message, Logger.Verbosity.moderate);
return message.DumpMessage();
}
}
else
{
return message.DumpMessage();
}
}
public void Write(Message message)
{
try
{
try
{
string mod_message = this.filter_writer(message);
this._plugin_writers(this, mod_message);
}
catch
{
this._plugin_writers(this, message.DumpMessage());
}
}
catch
{
this._connection.Send(Encoding.Unicode.GetBytes(message.DumpMessage()));
}
}
private void Reader()
{
int buffer_size = 1024;
int received = 0;
byte[] buffer = new byte[buffer_size];
string message_string = "";
Message message = null;
IPEndPoint userinfo = null;
while(this._alive)
{
try
{
userinfo = (IPEndPoint)this._connection.RemoteEndPoint;
Logger.log("Connection alive from: " + userinfo.Address.ToString() +" Code: "+ this.GetHashCode(), Logger.Verbosity.loud);
}
catch(Exception e)
{
Logger.log("Connection is alive but not connected. Code: "+this.GetHashCode(), Logger.Verbosity.loud);
}
if(this._connection.Poll(-1, SelectMode.SelectRead))
{
message_string = "";
message = null;
received = 0;
if(this._connection.Available > 1)
{
while(received < this._connection.Available)
{
received += this._connection.Receive(buffer);
message_string += Encoding.Unicode.GetString(buffer);
}
try
{
message = new Message(this, this._plugin_readers(this, message_string));
}
catch(Exception e)
{
message = new Message(this, message_string);
}
try
{
Logger.log("Transceiver: Message received: "+message.DumpMessage(), Logger.Verbosity.moderate);
this._message_processor(message);
Logger.log("Transceiver: Received message and properly processed. ("+this.GetHashCode()+")", Logger.Verbosity.moderate);
}
catch(Exception e)
{
Logger.log("Failed to process received message. "+e.Message+"\n"+e.StackTrace+" "+message_string, Logger.Verbosity.moderate);
}
}
else
{
Logger.log("Connection to client lost. Code: "+this.GetHashCode(), Logger.Verbosity.moderate);
this._alive = false;
// Notification needs to be done using a thread so we
// don't end up in a deadlock.
(new Thread(new ThreadStart(this.NotifyDisconnection))).Start();
}
}
if(!this._connection.Connected)
{
Logger.log("Connection is no longer open.", Logger.Verbosity.moderate);
break;
}
}
}
private void SendKey(Transceiver connection, User request, string userPluginHash)
{
string publickey;
string username;
Message message = new Message();
message.creator_plugin_hash = this._hash_code;
message.type = Message.Type.ServerToUser;
if(request == null)
{
publickey = this._server_public_key;
username = "******";
}
else
{
publickey = (string)this._user_keys[request.connection];
username = request.username;
}
Response content = new Response();
message.content = content;
content.type = BasicContent.Type.Response;
content.rtype = "success";
content.AddContent("command", "publickey");
content.AddContent("username", username);
content.AddContent("publickey", publickey);
string mess = message.DumpMessage();
connection.Write(mess);
}
private void ProcessDirectedMessage(Message message)
{
try
{
Information content = (Information)message.content;
string xml = message.DumpMessage();
Logger.log(xml, Logger.Verbosity.moderate);
XmlDocument document = new XmlDocument();
document.LoadXml(xml);
XmlNodeList list = document.GetElementsByTagName("Value");
XmlElement element = (XmlElement)list.Item(0);
if(element.HasAttribute("name") && element.GetAttribute("name") == "publickey")
{
string key = element.InnerXml;
this._user_keys[message.origin] = key;
this.SendKey(message.origin, null, message.creator_plugin_hash);
Logger.log("Sending server public key to client.", Logger.Verbosity.moderate);
message.origin.plugin_writers += this.WriteEncryptedMessage;
message.origin.plugin_readers += this.ReadEncryptedMessage;
Logger.log("Encryption hooks have been added to transceiver.", Logger.Verbosity.moderate);
}
}
catch(Exception ex)
{
try
{
Command content = (Command)message.content;
if(content.ctype == "publickey" && content.Exists("username"))
{
this.PublicKeyRequest(message, content.GetContent("username"));
}
else
{
throw new Exception("User has not been logged in.");
}
}
catch(Exception e)
{
Logger.log("Message type received is not supported. Ignoring.: "+e.Message+" : "+e.StackTrace, Logger.Verbosity.moderate);
}
}
}
