using System;
using System.Collections.Generic;
using System.Text;
using System.Security.Cryptography;
using System.IO;

namespace Server
{
    public class DataCryption
    {
        public static byte[] PolyAESEncrypt(byte[] plainText, string Key)
        {
            byte[] salt;
            SymmetricAlgorithm algo = new RijndaelManaged();
            RNGCryptoServiceProvider rngAlgo = new RNGCryptoServiceProvider();
            algo.Mode = CipherMode.CBC;
            byte[] key = System.Text.Encoding.ASCII.GetBytes(Key);

            algo.GenerateIV();
            salt = new byte[32];
            rngAlgo.GetBytes(salt);
            Rfc2898DeriveBytes pwDeriveAlg = new Rfc2898DeriveBytes(key, salt, 2000);
            algo.Key = pwDeriveAlg.GetBytes(32);

            ICryptoTransform encTransform = algo.CreateEncryptor();

            byte[] enced = encTransform.TransformFinalBlock(plainText, 0, plainText.Length);

            int origLength = enced.Length;
            Array.Resize(ref enced, enced.Length + salt.Length);
            Buffer.BlockCopy(salt, 0, enced, origLength, salt.Length);

            origLength = enced.Length;
            Array.Resize(ref enced, enced.Length + algo.IV.Length);
            Buffer.BlockCopy(algo.IV, 0, enced, origLength, algo.IV.Length);

            return enced;
        }
        public static byte[] PolyAESDecrypt(byte[] cipherText, string Key)
        {
            try
            {
                byte[] salt;
                SymmetricAlgorithm algo = new RijndaelManaged();
                algo.Mode = CipherMode.CBC;
                RNGCryptoServiceProvider rngAlgo = new RNGCryptoServiceProvider();
                byte[] key = System.Text.Encoding.ASCII.GetBytes(Key);
                byte[] cipherTextWithSalt = new byte[1];
                byte[] encSalt = new byte[1];
                byte[] origCipherText = new byte[1];
                byte[] encIv = new byte[1];

                Array.Resize(ref encIv, 16);
                Buffer.BlockCopy(cipherText, (int)(cipherText.Length - 16), encIv, 0, 16);
                Array.Resize(ref cipherTextWithSalt, (int)(cipherText.Length - 16));
                Buffer.BlockCopy(cipherText, 0, cipherTextWithSalt, 0, (int)(cipherText.Length - 16));

                Array.Resize(ref encSalt, 32);
                Buffer.BlockCopy(cipherTextWithSalt, (int)(cipherTextWithSalt.Length - 32), encSalt, 0, 32);
                Array.Resize(ref origCipherText, (int)(cipherTextWithSalt.Length - 32));
                Buffer.BlockCopy(cipherTextWithSalt, 0, origCipherText, 0, (int)(cipherTextWithSalt.Length - 32));

                algo.IV = encIv;
                salt = encSalt;
                Rfc2898DeriveBytes pwDeriveAlg = new Rfc2898DeriveBytes(key, salt, 2000);
                algo.Key = pwDeriveAlg.GetBytes(32);

                ICryptoTransform decTransform = algo.CreateDecryptor();
                byte[] plainText = decTransform.TransformFinalBlock(origCipherText, 0, origCipherText.Length);
                return plainText;
            }
            catch (CryptographicException e)
            {
                throw e;
            }
        }

        static string strRC2Encryption(string strInput, string strKey, string strIV)
        {
            try
            {
                byte[] byteInput = Encoding.UTF8.GetBytes(strInput);
                byte[] byteKey = Encoding.ASCII.GetBytes(strKey);
                byte[] byteIV = Encoding.ASCII.GetBytes(strIV);
                MemoryStream MS = new MemoryStream();
                RC2CryptoServiceProvider CryptoMethod = new RC2CryptoServiceProvider();
                CryptoStream CS = new CryptoStream(MS, CryptoMethod.CreateEncryptor(byteKey, byteIV), CryptoStreamMode.Write);
                CS.Write(byteInput, 0, byteInput.Length);
                CS.FlushFinalBlock();
                return Convert.ToBase64String(MS.ToArray());
            }
            catch (Exception up)
            {
                throw up; //YUCK! ;D
            }
        }
        static string strRC2Decryption(string strInput, string strKey, string strIV)
        {
            try
            {
                byte[] byteInput = Convert.FromBase64String(strInput);
                byte[] byteKey = Encoding.ASCII.GetBytes(strKey);
                byte[] byteIV = Encoding.ASCII.GetBytes(strIV);
                MemoryStream MS = new MemoryStream();
                RC2CryptoServiceProvider RC2 = new RC2CryptoServiceProvider();
                CryptoStream CS = new CryptoStream(MS, RC2.CreateDecryptor(byteKey, byteIV), CryptoStreamMode.Write);
                CS.Write(byteInput, 0, byteInput.Length);
                CS.FlushFinalBlock();
                return Encoding.UTF8.GetString(MS.ToArray());
            }
            catch (Exception up)
            {
                throw up; //YUCK! ;D
            }
        }

        public static byte[] EncryptFromByte(byte[] plainByte, string Key, string IV)
        {
            //KEY AND IV MUST BE 8CHARS (1Byte
            if ((Key.Length + IV.Length) == 16)
            {
                //Van string na bytes, dan een randompass generate geencrypt in RC2
                //met de Client/Server Pass&IV. Encryptie van pass en van AES DATA
                //encrypt na een base dan weer na bytes om daarna te kunnen worden
                //gesplit in Decrypt().
                string plainPass = RandomPassword.Generate(32);
                string encPass = strRC2Encryption(plainPass, Key, IV);
                string encByte = Convert.ToBase64String(PolyAESEncrypt(plainByte, plainPass));

                return Encoding.Default.GetBytes(encByte + "$" + encPass);
            }
            else
                throw new Exception("Error in IV or Key Size.");
        }

        public static byte[] DecryptToByte(byte[] encData, string Key, string IV)
        {
            //Data is samengevoegd met een $, AES = 0, PASS =  1.
            string[] splitData = Encoding.Default.GetString(encData).Split('$');
            string plainPass = strRC2Decryption(splitData[1], Key, IV);
            byte[] aesData = Convert.FromBase64String(splitData[0]);
            byte[] plainByte = PolyAESDecrypt(aesData, plainPass);
            return plainByte;
        }

        public static byte[] EncryptFromText(string plainTxt, string Key, string IV)
        {
            //KEY AND IV MUST BE 8CHARS (1Byte
            if ((Key.Length + IV.Length) == 16)
            {
                //Van string na bytes, dan een randompass generate geencrypt in RC2
                //met de Client/Server Pass&IV. Encryptie van pass en van AES DATA
                //encrypt na een base dan weer na bytes om daarna te kunnen worden
                //gesplit in Decrypt().
                byte[] plainByte = Encoding.Default.GetBytes(plainTxt);
                string plainPass = RandomPassword.Generate(32);
                string encPass = strRC2Encryption(plainPass, Key, IV);
                string encByte = Convert.ToBase64String(PolyAESEncrypt(plainByte, plainPass));

                return Encoding.Default.GetBytes(encByte + "$" + encPass);
            }
            else
                throw new Exception("Error in IV or Key Size.");
        }

        public static string DecryptToString(byte[] encData, string Key, string IV)
        {
            //Data is samengevoegd met een $, AES = 0, PASS =  1.
            string[] splitData = Encoding.Default.GetString(encData).Split('$');
            string plainPass = strRC2Decryption(splitData[1], Key, IV);
            byte[] aesData = Convert.FromBase64String(splitData[0]);
            byte[] plainByte = PolyAESDecrypt(aesData, plainPass);
            return Encoding.Default.GetString(plainByte);
        }

        static public string EncodeTo64(string toEncode)
        {
            byte[] toEncodeAsBytes = Encoding.Default.GetBytes(toEncode);
            return Convert.ToBase64String(toEncodeAsBytes);
        }

        static public string DecodeFrom64(string encodedData)
        {
            byte[] encodedDataAsBytes = Convert.FromBase64String(encodedData);
            return Encoding.Default.GetString(encodedDataAsBytes);
        }

        public class RandomPassword
        {
            // Define default min and max password lengths.
            private static int DEFAULT_MIN_PASSWORD_LENGTH = 8;
            private static int DEFAULT_MAX_PASSWORD_LENGTH = 10;

            // Define supported password characters divided into groups.
            // You can add (or remove) characters to (from) these groups.
            private static string PASSWORD_CHARS_LCASE = "abcdefgijkmnopqrstwxyz";
            private static string PASSWORD_CHARS_UCASE = "ABCDEFGHJKLMNPQRSTWXYZ";
            private static string PASSWORD_CHARS_NUMERIC = "23456789";
            private static string PASSWORD_CHARS_SPECIAL = "*-+?_&=!%{}/";

            /// <summary>
            /// Generates a random password.
            /// </summary>
            /// <returns>
            /// Randomly generated password.
            /// </returns>
            /// <remarks>
            /// The length of the generated password will be determined at
            /// random. It will be no shorter than the minimum default and
            /// no longer than maximum default.
            /// </remarks>
            public static string Generate()
            {
                return Generate(DEFAULT_MIN_PASSWORD_LENGTH,
                                DEFAULT_MAX_PASSWORD_LENGTH);
            }

            /// <summary>
            /// Generates a random password of the exact length.
            /// </summary>
            /// <param name="length">
            /// Exact password length.
            /// </param>
            /// <returns>
            /// Randomly generated password.
            /// </returns>
            public static string Generate(int length)
            {
                return Generate(length, length);
            }

            /// <summary>
            /// Generates a random password.
            /// </summary>
            /// <param name="minLength">
            /// Minimum password length.
            /// </param>
            /// <param name="maxLength">
            /// Maximum password length.
            /// </param>
            /// <returns>
            /// Randomly generated password.
            /// </returns>
            /// <remarks>
            /// The length of the generated password will be determined at
            /// random and it will fall with the range determined by the
            /// function parameters.
            /// </remarks>
            public static string Generate(int minLength,
                                          int maxLength)
            {
                // Make sure that input parameters are valid.
                if (minLength <= 0 || maxLength <= 0 || minLength > maxLength)
                    return null;

                // Create a local array containing supported password characters
                // grouped by types. You can remove character groups from this
                // array, but doing so will weaken the password strength.
                char[][] charGroups = new char[][] 
        {
            PASSWORD_CHARS_LCASE.ToCharArray(),
            PASSWORD_CHARS_UCASE.ToCharArray(),
            PASSWORD_CHARS_NUMERIC.ToCharArray(),
            PASSWORD_CHARS_SPECIAL.ToCharArray()
        };

                // Use this array to track the number of unused characters in each
                // character group.
                int[] charsLeftInGroup = new int[charGroups.Length];

                // Initially, all characters in each group are not used.
                for (int i = 0; i < charsLeftInGroup.Length; i++)
                    charsLeftInGroup[i] = charGroups[i].Length;

                // Use this array to track (iterate through) unused character groups.
                int[] leftGroupsOrder = new int[charGroups.Length];

                // Initially, all character groups are not used.
                for (int i = 0; i < leftGroupsOrder.Length; i++)
                    leftGroupsOrder[i] = i;

                // Because we cannot use the default randomizer, which is based on the
                // current time (it will produce the same "random" number within a
                // second), we will use a random number generator to seed the
                // randomizer.

                // Use a 4-byte array to fill it with random bytes and convert it then
                // to an integer value.
                byte[] randomBytes = new byte[4];

                // Generate 4 random bytes.
                RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
                rng.GetBytes(randomBytes);

                // Convert 4 bytes into a 32-bit integer value.
                int seed = (randomBytes[0] & 0x7f) << 24 |
                            randomBytes[1] << 16 |
                            randomBytes[2] << 8 |
                            randomBytes[3];

                // Now, this is real randomization.
                Random random = new Random(seed);

                // This array will hold password characters.
                char[] password = null;

                // Allocate appropriate memory for the password.
                if (minLength < maxLength)
                    password = new char[random.Next(minLength, maxLength + 1)];
                else
                    password = new char[minLength];

                // Index of the next character to be added to password.
                int nextCharIdx;

                // Index of the next character group to be processed.
                int nextGroupIdx;

                // Index which will be used to track not processed character groups.
                int nextLeftGroupsOrderIdx;

                // Index of the last non-processed character in a group.
                int lastCharIdx;

                // Index of the last non-processed group.
                int lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;

                // Generate password characters one at a time.
                for (int i = 0; i < password.Length; i++)
                {
                    // If only one character group remained unprocessed, process it;
                    // otherwise, pick a random character group from the unprocessed
                    // group list. To allow a special character to appear in the
                    // first position, increment the second parameter of the Next
                    // function call by one, i.e. lastLeftGroupsOrderIdx + 1.
                    if (lastLeftGroupsOrderIdx == 0)
                        nextLeftGroupsOrderIdx = 0;
                    else
                        nextLeftGroupsOrderIdx = random.Next(0,
                                                             lastLeftGroupsOrderIdx);

                    // Get the actual index of the character group, from which we will
                    // pick the next character.
                    nextGroupIdx = leftGroupsOrder[nextLeftGroupsOrderIdx];

                    // Get the index of the last unprocessed characters in this group.
                    lastCharIdx = charsLeftInGroup[nextGroupIdx] - 1;

                    // If only one unprocessed character is left, pick it; otherwise,
                    // get a random character from the unused character list.
                    if (lastCharIdx == 0)
                        nextCharIdx = 0;
                    else
                        nextCharIdx = random.Next(0, lastCharIdx + 1);

                    // Add this character to the password.
                    password[i] = charGroups[nextGroupIdx][nextCharIdx];

                    // If we processed the last character in this group, start over.
                    if (lastCharIdx == 0)
                        charsLeftInGroup[nextGroupIdx] =
                                                  charGroups[nextGroupIdx].Length;
                    // There are more unprocessed characters left.
                    else
                    {
                        // Swap processed character with the last unprocessed character
                        // so that we don't pick it until we process all characters in
                        // this group.
                        if (lastCharIdx != nextCharIdx)
                        {
                            char temp = charGroups[nextGroupIdx][lastCharIdx];
                            charGroups[nextGroupIdx][lastCharIdx] =
                                        charGroups[nextGroupIdx][nextCharIdx];
                            charGroups[nextGroupIdx][nextCharIdx] = temp;
                        }
                        // Decrement the number of unprocessed characters in
                        // this group.
                        charsLeftInGroup[nextGroupIdx]--;
                    }

                    // If we processed the last group, start all over.
                    if (lastLeftGroupsOrderIdx == 0)
                        lastLeftGroupsOrderIdx = leftGroupsOrder.Length - 1;
                    // There are more unprocessed groups left.
                    else
                    {
                        // Swap processed group with the last unprocessed group
                        // so that we don't pick it until we process all groups.
                        if (lastLeftGroupsOrderIdx != nextLeftGroupsOrderIdx)
                        {
                            int temp = leftGroupsOrder[lastLeftGroupsOrderIdx];
                            leftGroupsOrder[lastLeftGroupsOrderIdx] =
                                        leftGroupsOrder[nextLeftGroupsOrderIdx];
                            leftGroupsOrder[nextLeftGroupsOrderIdx] = temp;
                        }
                        // Decrement the number of unprocessed groups.
                        lastLeftGroupsOrderIdx--;
                    }
                }

                // Convert password characters into a string and return the result.
                return new string(password);
            }
        }
    }
}