public void OutgoingMessage(ref Message_Private OutgoingMessage, ref bool ContinueToSend)
 {
     if (this.EnabledMenu.Checked)
     {
         //ENCRYPT THE MESSAGE WITH THE KEYS WE HAVE BEEN PROVIDED
         EncryptedWrapper tmpMessage = EncryptedWrapper.EncryptMessage(OutgoingMessage.Message, this.PublicKeys);
         OutgoingMessage.Message = Convert.ToBase64String(EncryptedWrapper.Serialize(tmpMessage));
     }
 }
            public static string DecryptMessage(EncryptedWrapper Message, byte[] PrivateKey)
            {
                byte[] MessageKey = null;
                byte[] MessageIV  = null;

                using (RSACryptoServiceProvider tmpRSA = new RSACryptoServiceProvider())
                {
                    tmpRSA.ImportCspBlob(PrivateKey);
                    foreach (byte[] tmpKey in Message.Keys)
                    {
                        try
                        {
                            MessageKey = tmpRSA.Decrypt(tmpKey, false);
                            break;
                        }
                        catch
                        {
                        }
                    }
                    foreach (byte[] tmpIV in Message.IVs)
                    {
                        try
                        {
                            MessageIV = tmpRSA.Decrypt(tmpIV, false);
                            break;
                        }
                        catch
                        {
                        }
                    }
                }

                using (MemoryStream tmpStream = new MemoryStream(Message.Message))
                {
                    using (TripleDESCryptoServiceProvider tmpDes = new TripleDESCryptoServiceProvider())
                    {
                        tmpDes.Key = MessageKey;
                        tmpDes.IV  = MessageIV;

                        using (CryptoStream cryptStream = new CryptoStream(tmpStream, tmpDes.CreateDecryptor(), CryptoStreamMode.Read))
                        {
                            int           ReadLength;
                            byte[]        buffer    = new byte[1024];
                            StringBuilder tmpReturn = new StringBuilder();

                            while ((ReadLength = cryptStream.Read(buffer, 0, buffer.Length)) != 0)
                            {
                                tmpReturn.Append(System.Text.ASCIIEncoding.ASCII.GetChars(buffer), 0, ReadLength);
                            }

                            return(tmpReturn.ToString());
                        }
                    }
                }
            }
        public void IncomingMessage(ref Message_Private IncomingMessage, ref bool DisplayMessage)
        {
            //IF THERE IS A DEBUG WINDOW THEN UPDATE THE TEXT
            if (DebugWindow != null)
            {
                DebugWindow.txtMessages.Text += string.Format("Incoming Message: {0} - {1}\n\n", IncomingMessage.TimeStamp.ToString("m/d/yy HH:mm:ss"), IncomingMessage.Message);
            }

            //TODO: CHECK TO SEE IF THE MESSAGE WHICH JUST CAME IN WAS A SECURITY KEY AND IF SO PARSE IT AND USE IT
            if (IncomingMessage.Message.Contains("Begin Key ---->"))
            {
                //GET THE KEY VIA REGEX
                EnabledMenu.Checked = true;
                string Key = Regex.Match(IncomingMessage.Message, "Begin Key ---->(?<Key>.*)<---- End Key", RegexOptions.IgnoreCase).Groups["Key"].Value;

                //ADD THE KEY TO THE LIST OF PUBLIC KEYS
                if (!PublicKeys.Keys.Contains(IncomingMessage.SenderID))
                {
                    PublicKeys.Add(IncomingMessage.SenderID, Convert.FromBase64String(Key));
                }

                //IF THIS MESSAGE CAME FROM US THEN JUST LET THE USER KNOW IT WORKED OTHERWISE TELL THE USER WE RECEIVED A KEY
                if (IncomingMessage.SenderID != this.Connection.UserID)
                {
                    this.EnabledMenu.Checked = true;
                    IncomingMessage.Message  = string.Format("Public Key Received From {0}", IncomingMessage.Sender);
                    IncomingMessage.Sender   = this.Name;
                }
                else
                {
                    //LET THE USER KNOW THE KEY WAS SUCCEFULLY PLACED IN THE CONVERSATION BECAUSE WE GOT OUR MESSAGE BACK
                    IncomingMessage.Message = "Key sent successfully!";
                    IncomingMessage.Sender  = this.Name;
                }
            }
            else
            {
                if (EnabledMenu.Checked)
                {
                    try
                    {
                        EncryptedWrapper tmpMessage = EncryptedWrapper.Deserialize(Convert.FromBase64String(IncomingMessage.Message));
                        IncomingMessage.Message = EncryptedWrapper.DecryptMessage(tmpMessage, this.MyPrivateKey);
                    }
                    catch
                    {
                        //DO NOTHING BECAUSE IT MUST BE VALID
                    }
                }
            }
        }
            public static EncryptedWrapper EncryptMessage(string Message, Dictionary <string, byte[]> PublicKeys)
            {
                using (TripleDESCryptoServiceProvider tmpDes = new TripleDESCryptoServiceProvider())
                {
                    tmpDes.GenerateIV();
                    tmpDes.GenerateKey();
                    using (MemoryStream tmpStream = new MemoryStream())
                    {
                        using (CryptoStream cryptStream = new CryptoStream(tmpStream, tmpDes.CreateEncryptor(), CryptoStreamMode.Write))
                        {
                            cryptStream.Write(System.Text.ASCIIEncoding.ASCII.GetBytes(Message), 0, Message.Length);
                            cryptStream.Flush();
                            cryptStream.Close();

                            EncryptedWrapper tmpReturn = new EncryptedWrapper();
                            List <byte[]>    encKeys   = new List <byte[]>();
                            List <byte[]>    encIVs    = new List <byte[]>();

                            foreach (byte[] PubKey in PublicKeys.Values)
                            {
                                using (RSACryptoServiceProvider tmpRSA = new RSACryptoServiceProvider())
                                {
                                    tmpRSA.ImportCspBlob(PubKey);
                                    encKeys.Add(tmpRSA.Encrypt(tmpDes.Key, false));
                                    encIVs.Add(tmpRSA.Encrypt(tmpDes.IV, false));
                                }
                            }
                            tmpReturn.IVs     = encIVs.ToArray();
                            tmpReturn.Keys    = encKeys.ToArray();
                            tmpReturn.Message = tmpStream.ToArray();

                            return(tmpReturn);
                        }
                    }
                }
            }