using System;

using System.Text;

using System.Security.Cryptography;

using System.IO;

​

public class Program

{

    public static void Main()

    {        

        Console.WriteLine("This fiddle will generate a hashed password. Then you should use it in your dbo.users table in SolidCP database for the user you want (e.g. serveradmin)");

        Console.WriteLine("P.S. it should work for MSPControl as well, however, it is not tested");

        Console.WriteLine(@"Please enter your SolidCP.CryptoKey (find it in C:\SolidCP\Enterprise Server\web.config):");

        String UserInputCryptoKey = Console.ReadLine();

        Console.WriteLine(@"Please enter your desired password:");

        String UserInputPassword = Console.ReadLine();

        Console.WriteLine(@"Your hashed password is:");

        Console.WriteLine(CryptoUtils.Encrypt(UserInputPassword, UserInputCryptoKey));

​

        Console.WriteLine(@"Run again if you need more hashed passwords.");

    }

}

​

/// <summary>

/// Summary description for CryptoUtils.

/// </summary>

public static class CryptoUtils

{

    static string EnterpriseServerRegistryPath = "SOFTWARE\\SolidCP\\EnterpriseServer";

    public static string CryptoKey

    {

        get

        {

            // default CryptoKey

            return "dt52z07ehjw421tmt";

        }

    }

​

    public static bool EncryptionEnabled

    {

        get

        {

            return true;

        }

    }

​

    public static string Encrypt(string InputText, string InputCryptoKey = "")

    {

        string Password = "";

        if (string.IsNullOrEmpty(InputCryptoKey)) {

            Password = CryptoKey;

        } else {

            Password = InputCryptoKey;

        }

        if (!EncryptionEnabled)

            return InputText;

        if (InputText == null)

            return InputText;

        // We are now going to create an instance of the 

        // Rihndael class.

        RijndaelManaged RijndaelCipher = new RijndaelManaged();

        // First we need to turn the input strings into a byte array.

        byte[] PlainText = System.Text.Encoding.Unicode.GetBytes(InputText);

        // We are using salt to make it harder to guess our key

        // using a dictionary attack.

        byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString());

        // The (Secret Key) will be generated from the specified 

        // password and salt.

        PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt);

        // Create a encryptor from the existing SecretKey bytes.

        // We use 32 bytes for the secret key 

        // (the default Rijndael key length is 256 bit = 32 bytes) and

        // then 16 bytes for the IV (initialization vector),

        // (the default Rijndael IV length is 128 bit = 16 bytes)

        ICryptoTransform Encryptor = RijndaelCipher.CreateEncryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16));

        // Create a MemoryStream that is going to hold the encrypted bytes 

        MemoryStream memoryStream = new MemoryStream();

        // Create a CryptoStream through which we are going to be processing our data. 

        // CryptoStreamMode.Write means that we are going to be writing data 

        // to the stream and the output will be written in the MemoryStream

        // we have provided. (always use write mode for encryption)

        CryptoStream cryptoStream = new CryptoStream(memoryStream, Encryptor, CryptoStreamMode.Write);

        // Start the encryption process.

        cryptoStream.Write(PlainText, 0, PlainText.Length);

        // Finish encrypting.

        cryptoStream.FlushFinalBlock();

        // Convert our encrypted data from a memoryStream into a byte array.

        byte[] CipherBytes = memoryStream.ToArray();

        // Close both streams.

        memoryStream.Close();

        cryptoStream.Close();

        // Convert encrypted data into a base64-encoded string.

        // A common mistake would be to use an Encoding class for that. 

        // It does not work, because not all byte values can be

        // represented by characters. We are going to be using Base64 encoding

        // That is designed exactly for what we are trying to do. 

        string EncryptedData = Convert.ToBase64String(CipherBytes);

        // Return encrypted string.

        return EncryptedData;

    }

​

    public static string Decrypt(string InputText)

    {

        try

        {

            if (!EncryptionEnabled)

                return InputText;

            if (InputText == null || InputText == "")

                return InputText;

            string Password = CryptoKey;

            RijndaelManaged RijndaelCipher = new RijndaelManaged();

            byte[] EncryptedData = Convert.FromBase64String(InputText);

            byte[] Salt = Encoding.ASCII.GetBytes(Password.Length.ToString());

            PasswordDeriveBytes SecretKey = new PasswordDeriveBytes(Password, Salt);

            // Create a decryptor from the existing SecretKey bytes.

            ICryptoTransform Decryptor = RijndaelCipher.CreateDecryptor(SecretKey.GetBytes(32), SecretKey.GetBytes(16));

            MemoryStream memoryStream = new MemoryStream(EncryptedData);

            // Create a CryptoStream. (always use Read mode for decryption).

            CryptoStream cryptoStream = new CryptoStream(memoryStream, Decryptor, CryptoStreamMode.Read);

            // Since at this point we don't know what the size of decrypted data

            // will be, allocate the buffer long enough to hold EncryptedData;

            // DecryptedData is never longer than EncryptedData.

            byte[] PlainText = new byte[EncryptedData.Length];

            // Start decrypting.

            int DecryptedCount = cryptoStream.Read(PlainText, 0, PlainText.Length);

            memoryStream.Close();

            cryptoStream.Close();

            // Convert decrypted data into a string. 

            string DecryptedData = Encoding.Unicode.GetString(PlainText, 0, DecryptedCount);

            // Return decrypted string.   

            return DecryptedData;

        }

        catch

        {

            return "";

        }

    }

​

    public static string SHA1(string plainText)

    {

        // Convert plain text into a byte array.

        byte[] plainTextBytes = Encoding.UTF8.GetBytes(plainText);

        HashAlgorithm hash = new SHA1Managed();

        ;

        // Compute hash value of our plain text with appended salt.

        byte[] hashBytes = hash.ComputeHash(plainTextBytes);

        // Return the result.

        return Convert.ToBase64String(hashBytes);

    }

}