nullbind/cryptit.cs

## cryptit.cs
using System;
using System.IO;
using System.Text;
using System.Security.Cryptography;
using System.Runtime.InteropServices;
using System.Collections.Generic;

// -------------------------------------------------------------------------
// Instructions for compiling DLL and using via PowerShell on the fly
// -------------------------------------------------------------------------
// C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /r:System.Runtime.InteropServices.dll /target:library /out:CryptIt.dll CryptIt.cs
// Examples of Calling Functions from PowerShell
// [System.Reflection.Assembly]::LoadFile("C:\temp\CryptIt.dll")
// [CryptIt.EncryptionFunctions]::EncryptStringAES("Encrypt this!","MyPassword")
// EAAAAO/kwWaRfvX6MtvpNx/5HkJg4tqB2AZhs34IKkJUvJzU
// [CryptIt.EncryptionFunctions]::DecryptStringAES("EAAAAO/kwWaRfvX6MtvpNx/5HkJg4tqB2AZhs34IKkJUvJzU","MyPassword")
// Encrypt this!
// $Runner = [CryptIt.EncryptionFunctions]::new()
// $Runner.CryptFilesRecusive("c:\\temp\\enc","MyPassword123",".enc","Yes",10,"1")
// $Runner.CryptFilesRecusive("c:\\temp\\enc","MyPassword123",".enc","No",10,"0")
// $Runner = [CryptIt.EncryptionFunctions]::new()
// $Runner.Main()
// -------------------------------------------------------------------------

namespace CryptIt
{
    public class EncryptionFunctions
    {
        static void Main()
        {

            //-------------------------------------------------------------------
            // Encrypt/Decrypt file with AES password recusively
            //-------------------------------------------------------------------

            // syntax
            //CryptFilesRecusive(string targetFilepath, string aesPassword, string fileExt, string genFiles, int Filenumb, string cryptMode)

            // Run encryption
           CryptFilesRecusive("c:\\temp","MyPassword123",".enc","Yes",1000,"1");

            // Run decryptions
            // CryptFilesRecusive("c:\\temp", "MyPassword123", ".enc", "No", 1000, "0");

            //-------------------------------------------------------------------
            // Encrypt/Decrypt file with cert example
            //-------------------------------------------------------------------

	    // Create a mock AES key file
	    Console.WriteLine("Creating mock aeskeyfile.txt");
            string path = "c:\\temp\\aeskeyfile.txt";
            using (FileStream fs = File.Create(path))
            {
            	byte[] info = new System.Text.UTF8Encoding(true).GetBytes("EAAAAO/kwWaRfvX6MtvpNx/5HkJg4tqB2AZhs34IKkJUvJzU");

                fs.Write(info, 0, info.Length);
            }

            // Generate new public/private key pair
            Console.WriteLine("Creating public/private key pair");
            GenerateKeys("c:\\temp\\public.key","c:\\temp\\private.key");

            // Encrypt file with public key
	    //Encrypt(string publicKeyFileName, string plainFileName, string encryptedFileName)
	    Console.WriteLine("Encrypting a file with a public key");
            EncryptWithKey("c:\\temp\\public.key","c:\\temp\\aeskeyfile.txt","c:\\temp\\aeskeyfile.txt.enc");

            // Decrypt file with private key
	    // Decrypt(string privateKeyFileName, string encryptedFileName, string plainFileName)
	    Console.WriteLine("Decrypting a file with a private key");
 	    DecryptWithKey("c:\\temp\\private.key","c:\\temp\\aeskeyfile.txt.enc","c:\\temp\\aeskeyfile.txt.dec");

            //-------------------------------------------------------------------
            // Encrypt/Decrypt data with AES password example
            //-------------------------------------------------------------------

            Console.WriteLine("Encrypting string: Encrypt this string.");
            var enctext = EncryptStringAES("Encrypt this string.", "mypassword");
            Console.WriteLine(enctext);

	    Console.WriteLine("Decrypting string: {0}", enctext);
            var dectext = DecryptStringAES(enctext, "mypassword");
            Console.WriteLine(dectext);
        }


        //-------------------------------------------------------------------
        // STATIC SALT FOR DATA ENCRYPT/DECRYPT
        //-------------------------------------------------------------------
        public static byte[] _salt = Encoding.Unicode.GetBytes("CaptainSalty");

        //-------------------------------------------------------------------
        // FUNCTION: DATA ENCRYPTION
        //-------------------------------------------------------------------
        public static string EncryptStringAES(string plainText, string sharedSecret)
        {
            if (string.IsNullOrEmpty(plainText))
                throw new ArgumentNullException("plainText");
            if (string.IsNullOrEmpty(sharedSecret))
                throw new ArgumentNullException("sharedSecret");

            string outStr = null;                       // Encrypted string to return
            RijndaelManaged aesAlg = null;              // RijndaelManaged object used to encrypt the data.

            try
            {
                // generate the key from the shared secret and the salt
                Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                // Create a RijndaelManaged object
                aesAlg = new RijndaelManaged();
                aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                aesAlg.Mode = CipherMode.ECB;

                // Create a decryptor to perform the stream transform.
                ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

                // Create the streams used for encryption.
                using (MemoryStream msEncrypt = new MemoryStream())
                {
                    // prepend the IV
                    msEncrypt.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, sizeof(int));
                    msEncrypt.Write(aesAlg.IV, 0, aesAlg.IV.Length);
                    using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
                    {
                        using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
                        {
                            //Write all data to the stream.
                            swEncrypt.Write(plainText);
                        }
                    }
                    outStr = Convert.ToBase64String(msEncrypt.ToArray());
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                if (aesAlg != null)
                    aesAlg.Clear();
            }

            // Return the encrypted bytes from the memory stream.
            return outStr;
        }

        //-------------------------------------------------------------------
        // FUNCTION: DATA DECRYPTION
        //-------------------------------------------------------------------
        public static string DecryptStringAES(string cipherText, string sharedSecret)
        {
            if (string.IsNullOrEmpty(cipherText))
                throw new ArgumentNullException("cipherText");
            if (string.IsNullOrEmpty(sharedSecret))
                throw new ArgumentNullException("sharedSecret");

            // Declare the RijndaelManaged object
            // used to decrypt the data.
            RijndaelManaged aesAlg = null;

            // Declare the string used to hold
            // the decrypted text.
            string plaintext = null;

            try
            {
                // generate the key from the shared secret and the salt
                Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

                // Create the streams used for decryption.
                byte[] bytes = Convert.FromBase64String(cipherText);
                using (MemoryStream msDecrypt = new MemoryStream(bytes))
                {
                    // Create a RijndaelManaged object
                    // with the specified key and IV.
                    aesAlg = new RijndaelManaged();
                    aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
                    aesAlg.Mode = CipherMode.ECB;

                    // Get the initialization vector from the encrypted stream
                    aesAlg.IV = ReadByteArray(msDecrypt);
                    // Create a decrytor to perform the stream transform.
                    ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
                    using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
                    {
                        using (StreamReader srDecrypt = new StreamReader(csDecrypt))

                            // Read the decrypted bytes from the decrypting stream
                            // and place them in a string.
                            plaintext = srDecrypt.ReadToEnd();
                    }
                }
            }
            finally
            {
                // Clear the RijndaelManaged object.
                if (aesAlg != null)
                    aesAlg.Clear();
            }
            return plaintext;
        }

        private static byte[] ReadByteArray(Stream s)
        {
            byte[] rawLength = new byte[sizeof(int)];
            if (s.Read(rawLength, 0, rawLength.Length) != rawLength.Length)
            {
                throw new SystemException("Stream did not contain properly formatted byte array");
            }

            byte[] buffer = new byte[BitConverter.ToInt32(rawLength, 0)];
            if (s.Read(buffer, 0, buffer.Length) != buffer.Length)
            {
                throw new SystemException("Did not read byte array properly");
            }

            return buffer;
        }


        //-------------------------------------------------------------------
        // FUNCTION: GenerateKeys
        //-------------------------------------------------------------------
        // https://www.sysadmins.lv/retired-msft-blogs/alejacma/how-to-generate-key-pairs-encrypt-and-decrypt-data-with-net-csharp.aspx

        public static void GenerateKeys(string publicKeyFileName, string privateKeyFileName)
        {
            // Variables
            CspParameters cspParams = null;
            RSACryptoServiceProvider rsaProvider = null;
            StreamWriter publicKeyFile = null;
            StreamWriter privateKeyFile = null;
            string publicKey = "";
            string privateKey = "";

            try
            {
                // Create a new key pair on target CSP
                cspParams = new CspParameters();
                cspParams.ProviderType = 1; // PROV_RSA_FULL

                //cspParams.ProviderName; // CSP name
                cspParams.Flags = CspProviderFlags.UseArchivableKey;
                cspParams.KeyNumber = (int)KeyNumber.Exchange;
                rsaProvider = new RSACryptoServiceProvider(cspParams);

                // Export public key
                publicKey = rsaProvider.ToXmlString(false);

                // Write public key to file
                publicKeyFile = File.CreateText(publicKeyFileName);

                publicKeyFile.Write(publicKey);

                // Export private/public key pair
                privateKey = rsaProvider.ToXmlString(true);

                // Write private/public key pair to file
                privateKeyFile = File.CreateText(privateKeyFileName);
                privateKeyFile.Write(privateKey);

            }
            catch (Exception ex)
            {
                // Any errors? Show them
                Console.WriteLine("Exception generating a new key pair! More info:");
                Console.WriteLine(ex.Message);
            }

            finally
            {
                // Do some clean up if needed
                if (publicKeyFile != null)
                {
                    publicKeyFile.Close();
                }

                if (privateKeyFile != null)
                {
                    privateKeyFile.Close();
                }
            }
        } // Keys


        //-------------------------------------------------------------------
        // FUNCTION: DECRYPT WITH PUBLIC KEY
        //-------------------------------------------------------------------
        // https://www.sysadmins.lv/retired-msft-blogs/alejacma/how-to-generate-key-pairs-encrypt-and-decrypt-data-with-net-csharp.aspx

        public static void EncryptWithKey(string publicKeyFileName, string plainFileName, string encryptedFileName)
        {
            // Variables
            CspParameters cspParams = null;
            RSACryptoServiceProvider rsaProvider = null;
            StreamReader publicKeyFile = null;
            StreamReader plainFile = null;
            FileStream encryptedFile = null;
            string publicKeyText = "";
            string plainText = "";
            byte[] plainBytes = null;
            byte[] encryptedBytes = null;

            try
            {
                // Select target CSP
                cspParams = new CspParameters();
                cspParams.ProviderType = 1; // PROV_RSA_FULL

                //cspParams.ProviderName; // CSP name
                rsaProvider = new RSACryptoServiceProvider(cspParams);

                // Read public key from file
                publicKeyFile = File.OpenText(publicKeyFileName);
                publicKeyText = publicKeyFile.ReadToEnd();

                // Import public key
                rsaProvider.FromXmlString(publicKeyText);

                // Read plain text from file
                plainFile = File.OpenText(plainFileName);
                plainText = plainFile.ReadToEnd();

                // Encrypt plain text
                plainBytes = Encoding.Unicode.GetBytes(plainText);
                encryptedBytes = rsaProvider.Encrypt(plainBytes, false);

                // Write encrypted text to file
                encryptedFile = File.Create(encryptedFileName);
                encryptedFile.Write(encryptedBytes, 0, encryptedBytes.Length);
            }
            catch (Exception ex)
            {
                // Any errors? Show them
                Console.WriteLine("Exception encrypting file! More info:");
                Console.WriteLine(ex.Message);
            }
            finally
            {
                // Do some clean up if needed
                if (publicKeyFile != null)
                {
                    publicKeyFile.Close();
                }

                if (plainFile != null)
                {
                    plainFile.Close();
                }

                if (encryptedFile != null)
                {
                    encryptedFile.Close();
                }
            }


        } // Encrypt


        //-------------------------------------------------------------------
        // FUNCTION: DECRYPT WITH PRIVATE KEY
        //-------------------------------------------------------------------
        // https://www.sysadmins.lv/retired-msft-blogs/alejacma/how-to-generate-key-pairs-encrypt-and-decrypt-data-with-net-csharp.aspx

        public static void DecryptWithKey(string privateKeyFileName, string encryptedFileName, string plainFileName)
        {
            // Variables
            CspParameters cspParams = null;
            RSACryptoServiceProvider rsaProvider = null;
            StreamReader privateKeyFile = null;
            FileStream encryptedFile = null;
            StreamWriter plainFile = null;
            string privateKeyText = "";
            string plainText = "";
            byte[] encryptedBytes = null;
            byte[] plainBytes = null;

            try
            {
                // Select target CSP
                cspParams = new CspParameters();
                cspParams.ProviderType = 1; // PROV_RSA_FULL

                //cspParams.ProviderName; // CSP name
                rsaProvider = new RSACryptoServiceProvider(cspParams);

                // Read private/public key pair from file
                privateKeyFile = File.OpenText(privateKeyFileName);
                privateKeyText = privateKeyFile.ReadToEnd();

                // Import private/public key pair
                rsaProvider.FromXmlString(privateKeyText);

                // Read encrypted text from file
                encryptedFile = File.OpenRead(encryptedFileName);
                encryptedBytes = new byte[encryptedFile.Length];
                encryptedFile.Read(encryptedBytes, 0, (int)encryptedFile.Length);

                // Decrypt text
                plainBytes = rsaProvider.Decrypt(encryptedBytes, false);

                // Write decrypted text to file
                plainFile = File.CreateText(plainFileName);
                plainText = Encoding.Unicode.GetString(plainBytes);
                plainFile.Write(plainText);
            }
            catch (Exception ex)
            {
                // Any errors? Show them
                Console.WriteLine("Exception decrypting file! More info:");
                Console.WriteLine(ex.Message);
            }
            finally
            {
                // Do some clean up if needed
                if (privateKeyFile != null)
                {
                    privateKeyFile.Close();
                }

                if (encryptedFile != null)
                {
                    encryptedFile.Close();
                }

                if (plainFile != null)
                {
                    plainFile.Close();
                }
            }
        } // Decrypt


        //-------------------------------------------------------------------
        // Recursive Directory Listing
        //-------------------------------------------------------------------
        // https://stackoverflow.com/questions/929276/how-to-recursively-list-all-the-files-in-a-directory-in-c

        static IEnumerable<string> GetFiles(string path)
        {
            Queue<string> queue = new Queue<string>();
            queue.Enqueue(path);
            while (queue.Count > 0)
            {
                path = queue.Dequeue();
                try
                {
                    foreach (string subDir in Directory.GetDirectories(path))
                    {
                        queue.Enqueue(subDir);
                    }
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine(ex);
                }
                string[] files = null;
                try
                {
                    files = Directory.GetFiles(path);
                }
                catch (Exception ex)
                {
                    Console.Error.WriteLine(ex);
                }
                if (files != null)
                {
                    for (int i = 0; i < files.Length; i++)
                    {
                        yield return files[i];
                    }
                }
            }
        }


        //-------------------------------------------------------------------
        // DYNAMIC SALT FOR AES FILE ENCRYPTION
        //-------------------------------------------------------------------
        // https://ourcodeworld.com/articles/read/471/how-to-encrypt-and-decrypt-files-using-the-aes-encryption-algorithm-in-c-sharp

        public static byte[] GenerateRandomSalt()
        {
            byte[] data = new byte[32];

            using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
            {
                for (int i = 0; i < 10; i++)
                {
                    // Fille the buffer with the generated data
                    rng.GetBytes(data);
                }
            }

            return data;
        }

        //-------------------------------------------------------------------
        // FUNCTION: ENCRYPT FILE WITH AES PASSWORD
        //-------------------------------------------------------------------
        // https://ourcodeworld.com/articles/read/471/how-to-encrypt-and-decrypt-files-using-the-aes-encryption-algorithm-in-c-sharp

        public void FileEncrypt(string inputFile, string password, string fileExt)
        {
            //http://stackoverflow.com/questions/27645527/aes-encryption-on-large-files

            //generate random salt
            byte[] salt = GenerateRandomSalt();

            //create output file name
            FileStream fsCrypt = new FileStream(inputFile + fileExt, FileMode.Create);

            //convert password string to byte arrray
            byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);

            //Set Rijndael symmetric encryption algorithm
            RijndaelManaged AES = new RijndaelManaged();
            AES.KeySize = 256;
            AES.BlockSize = 128;
            AES.Padding = PaddingMode.PKCS7;

            //http://stackoverflow.com/questions/2659214/why-do-i-need-to-use-the-rfc2898derivebytes-class-in-net-instead-of-directly
            //"What it does is repeatedly hash the user password along with the salt." High iteration counts.
            var key = new Rfc2898DeriveBytes(passwordBytes, salt, 50000);
            AES.Key = key.GetBytes(AES.KeySize / 8);
            AES.IV = key.GetBytes(AES.BlockSize / 8);

            //Cipher modes: http://security.stackexchange.com/questions/52665/which-is-the-best-cipher-mode-and-padding-mode-for-aes-encryption
            AES.Mode = CipherMode.CFB;

            // write salt to the begining of the output file, so in this case can be random every time
            fsCrypt.Write(salt, 0, salt.Length);

            CryptoStream cs = new CryptoStream(fsCrypt, AES.CreateEncryptor(), CryptoStreamMode.Write);

            FileStream fsIn = new FileStream(inputFile, FileMode.Open);

            //create a buffer (1mb) so only this amount will allocate in the memory and not the whole file
            byte[] buffer = new byte[1048576];
            int read;

            try
            {
                while ((read = fsIn.Read(buffer, 0, buffer.Length)) > 0)
                {
                    cs.Write(buffer, 0, read);
                }

                // Close up
                fsIn.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }
            finally
            {
                cs.Close();
                fsCrypt.Close();
            }
        }


        //-------------------------------------------------------------------
        // FUNCTION: DECRYPT FILE WITH AES PASSWORD
        //-------------------------------------------------------------------
        // https://ourcodeworld.com/articles/read/471/how-to-encrypt-and-decrypt-files-using-the-aes-encryption-algorithm-in-c-sharp

        public void FileDecrypt(string inputFile, string outputFile, string password)
        {
            byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);
            byte[] salt = new byte[32];

            FileStream fsCrypt = new FileStream(inputFile, FileMode.Open);
            fsCrypt.Read(salt, 0, salt.Length);

            RijndaelManaged AES = new RijndaelManaged();
            AES.KeySize = 256;
            AES.BlockSize = 128;
            var key = new Rfc2898DeriveBytes(passwordBytes, salt, 50000);
            AES.Key = key.GetBytes(AES.KeySize / 8);
            AES.IV = key.GetBytes(AES.BlockSize / 8);
            AES.Padding = PaddingMode.PKCS7;
            AES.Mode = CipherMode.CFB;

            CryptoStream cs = new CryptoStream(fsCrypt, AES.CreateDecryptor(), CryptoStreamMode.Read);

            FileStream fsOut = new FileStream(outputFile, FileMode.Create);

            int read;
            byte[] buffer = new byte[1048576];

            try
            {
                while ((read = cs.Read(buffer, 0, buffer.Length)) > 0)
                {
                    fsOut.Write(buffer, 0, read);
                }
            }
            catch (CryptographicException ex_CryptographicException)
            {
                Console.WriteLine("CryptographicException error: " + ex_CryptographicException.Message);
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error: " + ex.Message);
            }

            try
            {
                cs.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine("Error by closing CryptoStream: " + ex.Message);
            }
            finally
            {
                fsOut.Close();
                fsCrypt.Close();
            }
        }

        //-------------------------------------------------------------------
        // FUNCTION: ENCRYPT/DECRYPT FILES RECURISVELY WITH AES PASSWORD
        //-------------------------------------------------------------------

        public void CryptFilesRecusive(string targetFilepath, string aesPassword, string fileExt, string genFiles, int Filenumb, string cryptMode)
        {

            // Add check for all parameters

            // Set AES encryoption password
            string mypassword = aesPassword;
            Console.WriteLine("AES Encryption Password: {0}", mypassword);

            // Set file path
            string myfilepath = targetFilepath;
            Console.WriteLine("Target Directory: {0}", myfilepath);

            // Set crypto mode
            //string cryptmode = "0"; // 0=decryption 1=encryption

            // Set file generation settings
            string enableFileGen = genFiles; //yes or no
            int genFilenum = Filenumb; //default to 1000

            // Generating testing files
            if (enableFileGen == "Yes")
            {
                Console.WriteLine("Generating {0} test files in directory", genFilenum);
                for (int i = 0; i < genFilenum; i++)
                {
                    //Console.WriteLine("ITERATION: {0}", i);
                    string path = targetFilepath + "\\file" + i + ".txt";
                    // Create the file, or overwrite if the file exists.
                    using (FileStream fs = File.Create(path))
                    {
                        byte[] info = new System.Text.UTF8Encoding(true).GetBytes("This is some text in the file.");
                        // Add some information to the file.
                        fs.Write(info, 0, info.Length);
                        // Console.WriteLine("- Creating: {0}",path);
                    }
                }
            }

            // Search through taret directory recurisvely and encrypt files
            if (cryptMode == "1")
            {
                Console.WriteLine("Encrypting files...");
            }
            else
            {
                Console.WriteLine("Decrypting files...");
            }

            foreach (string file in GetFiles(myfilepath))
            {

                // Encrypt files
                if (cryptMode == "1")
                {
                    // Encrypt file
                    //Console.WriteLine("Encrypting {0}",file);
                    FileEncrypt(file, aesPassword, fileExt);

                    // Remove original file
                    // Console.WriteLine("Removing {0}",file);
                    File.Delete(file);
                }

                // Decrypt files
                if (cryptMode == "0")
                {
                    // Decrypt file
                    string newfilePath = file + ".decrypted.txt";
                    Console.WriteLine("Decrypting {0} to {1}", file, newfilePath);
                    FileDecrypt(file, newfilePath, aesPassword);
                    File.Delete(file);
                }
            }

            Console.WriteLine("Operation complete.");
        }
    }
}
	using System;
	using System.IO;
	using System.Text;
	using System.Security.Cryptography;
	using System.Runtime.InteropServices;
	using System.Collections.Generic;

	// -------------------------------------------------------------------------
	// Instructions for compiling DLL and using via PowerShell on the fly
	// -------------------------------------------------------------------------
	// C:\Windows\Microsoft.NET\Framework\v4.0.30319\csc.exe /r:System.Runtime.InteropServices.dll /target:library /out:CryptIt.dll CryptIt.cs
	// Examples of Calling Functions from PowerShell
	// [System.Reflection.Assembly]::LoadFile("C:\temp\CryptIt.dll")
	// [CryptIt.EncryptionFunctions]::EncryptStringAES("Encrypt this!","MyPassword")
	// EAAAAO/kwWaRfvX6MtvpNx/5HkJg4tqB2AZhs34IKkJUvJzU
	// [CryptIt.EncryptionFunctions]::DecryptStringAES("EAAAAO/kwWaRfvX6MtvpNx/5HkJg4tqB2AZhs34IKkJUvJzU","MyPassword")
	// Encrypt this!
	// $Runner = [CryptIt.EncryptionFunctions]::new()
	// $Runner.CryptFilesRecusive("c:\\temp\\enc","MyPassword123",".enc","Yes",10,"1")
	// $Runner.CryptFilesRecusive("c:\\temp\\enc","MyPassword123",".enc","No",10,"0")
	// $Runner = [CryptIt.EncryptionFunctions]::new()
	// $Runner.Main()
	// -------------------------------------------------------------------------

	namespace CryptIt
	{
	public class EncryptionFunctions
	{
	static void Main()
	{

	//-------------------------------------------------------------------
	// Encrypt/Decrypt file with AES password recusively
	//-------------------------------------------------------------------

	// syntax
	//CryptFilesRecusive(string targetFilepath, string aesPassword, string fileExt, string genFiles, int Filenumb, string cryptMode)

	// Run encryption
	CryptFilesRecusive("c:\\temp","MyPassword123",".enc","Yes",1000,"1");

	// Run decryptions
	// CryptFilesRecusive("c:\\temp", "MyPassword123", ".enc", "No", 1000, "0");

	//-------------------------------------------------------------------
	// Encrypt/Decrypt file with cert example
	//-------------------------------------------------------------------

	// Create a mock AES key file
	Console.WriteLine("Creating mock aeskeyfile.txt");
	string path = "c:\\temp\\aeskeyfile.txt";
	using (FileStream fs = File.Create(path))
	{
	byte[] info = new System.Text.UTF8Encoding(true).GetBytes("EAAAAO/kwWaRfvX6MtvpNx/5HkJg4tqB2AZhs34IKkJUvJzU");

	fs.Write(info, 0, info.Length);
	}

	// Generate new public/private key pair
	Console.WriteLine("Creating public/private key pair");
	GenerateKeys("c:\\temp\\public.key","c:\\temp\\private.key");

	// Encrypt file with public key
	//Encrypt(string publicKeyFileName, string plainFileName, string encryptedFileName)
	Console.WriteLine("Encrypting a file with a public key");
	EncryptWithKey("c:\\temp\\public.key","c:\\temp\\aeskeyfile.txt","c:\\temp\\aeskeyfile.txt.enc");

	// Decrypt file with private key
	// Decrypt(string privateKeyFileName, string encryptedFileName, string plainFileName)
	Console.WriteLine("Decrypting a file with a private key");
	DecryptWithKey("c:\\temp\\private.key","c:\\temp\\aeskeyfile.txt.enc","c:\\temp\\aeskeyfile.txt.dec");

	//-------------------------------------------------------------------
	// Encrypt/Decrypt data with AES password example
	//-------------------------------------------------------------------

	Console.WriteLine("Encrypting string: Encrypt this string.");
	var enctext = EncryptStringAES("Encrypt this string.", "mypassword");
	Console.WriteLine(enctext);

	Console.WriteLine("Decrypting string: {0}", enctext);
	var dectext = DecryptStringAES(enctext, "mypassword");
	Console.WriteLine(dectext);
	}


	//-------------------------------------------------------------------
	// STATIC SALT FOR DATA ENCRYPT/DECRYPT
	//-------------------------------------------------------------------
	public static byte[] _salt = Encoding.Unicode.GetBytes("CaptainSalty");

	//-------------------------------------------------------------------
	// FUNCTION: DATA ENCRYPTION
	//-------------------------------------------------------------------
	public static string EncryptStringAES(string plainText, string sharedSecret)
	{
	if (string.IsNullOrEmpty(plainText))
	throw new ArgumentNullException("plainText");
	if (string.IsNullOrEmpty(sharedSecret))
	throw new ArgumentNullException("sharedSecret");

	string outStr = null; // Encrypted string to return
	RijndaelManaged aesAlg = null; // RijndaelManaged object used to encrypt the data.

	try
	{
	// generate the key from the shared secret and the salt
	Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

	// Create a RijndaelManaged object
	aesAlg = new RijndaelManaged();
	aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
	aesAlg.Mode = CipherMode.ECB;

	// Create a decryptor to perform the stream transform.
	ICryptoTransform encryptor = aesAlg.CreateEncryptor(aesAlg.Key, aesAlg.IV);

	// Create the streams used for encryption.
	using (MemoryStream msEncrypt = new MemoryStream())
	{
	// prepend the IV
	msEncrypt.Write(BitConverter.GetBytes(aesAlg.IV.Length), 0, sizeof(int));
	msEncrypt.Write(aesAlg.IV, 0, aesAlg.IV.Length);
	using (CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write))
	{
	using (StreamWriter swEncrypt = new StreamWriter(csEncrypt))
	{
	//Write all data to the stream.
	swEncrypt.Write(plainText);
	}
	}
	outStr = Convert.ToBase64String(msEncrypt.ToArray());
	}
	}
	finally
	{
	// Clear the RijndaelManaged object.
	if (aesAlg != null)
	aesAlg.Clear();
	}

	// Return the encrypted bytes from the memory stream.
	return outStr;
	}

	//-------------------------------------------------------------------
	// FUNCTION: DATA DECRYPTION
	//-------------------------------------------------------------------
	public static string DecryptStringAES(string cipherText, string sharedSecret)
	{
	if (string.IsNullOrEmpty(cipherText))
	throw new ArgumentNullException("cipherText");
	if (string.IsNullOrEmpty(sharedSecret))
	throw new ArgumentNullException("sharedSecret");

	// Declare the RijndaelManaged object
	// used to decrypt the data.
	RijndaelManaged aesAlg = null;

	// Declare the string used to hold
	// the decrypted text.
	string plaintext = null;

	try
	{
	// generate the key from the shared secret and the salt
	Rfc2898DeriveBytes key = new Rfc2898DeriveBytes(sharedSecret, _salt);

	// Create the streams used for decryption.
	byte[] bytes = Convert.FromBase64String(cipherText);
	using (MemoryStream msDecrypt = new MemoryStream(bytes))
	{
	// Create a RijndaelManaged object
	// with the specified key and IV.
	aesAlg = new RijndaelManaged();
	aesAlg.Key = key.GetBytes(aesAlg.KeySize / 8);
	aesAlg.Mode = CipherMode.ECB;

	// Get the initialization vector from the encrypted stream
	aesAlg.IV = ReadByteArray(msDecrypt);
	// Create a decrytor to perform the stream transform.
	ICryptoTransform decryptor = aesAlg.CreateDecryptor(aesAlg.Key, aesAlg.IV);
	using (CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read))
	{
	using (StreamReader srDecrypt = new StreamReader(csDecrypt))

	// Read the decrypted bytes from the decrypting stream
	// and place them in a string.
	plaintext = srDecrypt.ReadToEnd();
	}
	}
	}
	finally
	{
	// Clear the RijndaelManaged object.
	if (aesAlg != null)
	aesAlg.Clear();
	}
	return plaintext;
	}

	private static byte[] ReadByteArray(Stream s)
	{
	byte[] rawLength = new byte[sizeof(int)];
	if (s.Read(rawLength, 0, rawLength.Length) != rawLength.Length)
	{
	throw new SystemException("Stream did not contain properly formatted byte array");
	}

	byte[] buffer = new byte[BitConverter.ToInt32(rawLength, 0)];
	if (s.Read(buffer, 0, buffer.Length) != buffer.Length)
	{
	throw new SystemException("Did not read byte array properly");
	}

	return buffer;
	}


	//-------------------------------------------------------------------
	// FUNCTION: GenerateKeys
	//-------------------------------------------------------------------
	// https://www.sysadmins.lv/retired-msft-blogs/alejacma/how-to-generate-key-pairs-encrypt-and-decrypt-data-with-net-csharp.aspx

	public static void GenerateKeys(string publicKeyFileName, string privateKeyFileName)
	{
	// Variables
	CspParameters cspParams = null;
	RSACryptoServiceProvider rsaProvider = null;
	StreamWriter publicKeyFile = null;
	StreamWriter privateKeyFile = null;
	string publicKey = "";
	string privateKey = "";

	try
	{
	// Create a new key pair on target CSP
	cspParams = new CspParameters();
	cspParams.ProviderType = 1; // PROV_RSA_FULL

	//cspParams.ProviderName; // CSP name
	cspParams.Flags = CspProviderFlags.UseArchivableKey;
	cspParams.KeyNumber = (int)KeyNumber.Exchange;
	rsaProvider = new RSACryptoServiceProvider(cspParams);

	// Export public key
	publicKey = rsaProvider.ToXmlString(false);

	// Write public key to file
	publicKeyFile = File.CreateText(publicKeyFileName);

	publicKeyFile.Write(publicKey);

	// Export private/public key pair
	privateKey = rsaProvider.ToXmlString(true);

	// Write private/public key pair to file
	privateKeyFile = File.CreateText(privateKeyFileName);
	privateKeyFile.Write(privateKey);

	}
	catch (Exception ex)
	{
	// Any errors? Show them
	Console.WriteLine("Exception generating a new key pair! More info:");
	Console.WriteLine(ex.Message);
	}

	finally
	{
	// Do some clean up if needed
	if (publicKeyFile != null)
	{
	publicKeyFile.Close();
	}

	if (privateKeyFile != null)
	{
	privateKeyFile.Close();
	}
	}
	} // Keys


	//-------------------------------------------------------------------
	// FUNCTION: DECRYPT WITH PUBLIC KEY
	//-------------------------------------------------------------------
	// https://www.sysadmins.lv/retired-msft-blogs/alejacma/how-to-generate-key-pairs-encrypt-and-decrypt-data-with-net-csharp.aspx

	public static void EncryptWithKey(string publicKeyFileName, string plainFileName, string encryptedFileName)
	{
	// Variables
	CspParameters cspParams = null;
	RSACryptoServiceProvider rsaProvider = null;
	StreamReader publicKeyFile = null;
	StreamReader plainFile = null;
	FileStream encryptedFile = null;
	string publicKeyText = "";
	string plainText = "";
	byte[] plainBytes = null;
	byte[] encryptedBytes = null;

	try
	{
	// Select target CSP
	cspParams = new CspParameters();
	cspParams.ProviderType = 1; // PROV_RSA_FULL

	//cspParams.ProviderName; // CSP name
	rsaProvider = new RSACryptoServiceProvider(cspParams);

	// Read public key from file
	publicKeyFile = File.OpenText(publicKeyFileName);
	publicKeyText = publicKeyFile.ReadToEnd();

	// Import public key
	rsaProvider.FromXmlString(publicKeyText);

	// Read plain text from file
	plainFile = File.OpenText(plainFileName);
	plainText = plainFile.ReadToEnd();

	// Encrypt plain text
	plainBytes = Encoding.Unicode.GetBytes(plainText);
	encryptedBytes = rsaProvider.Encrypt(plainBytes, false);

	// Write encrypted text to file
	encryptedFile = File.Create(encryptedFileName);
	encryptedFile.Write(encryptedBytes, 0, encryptedBytes.Length);
	}
	catch (Exception ex)
	{
	// Any errors? Show them
	Console.WriteLine("Exception encrypting file! More info:");
	Console.WriteLine(ex.Message);
	}
	finally
	{
	// Do some clean up if needed
	if (publicKeyFile != null)
	{
	publicKeyFile.Close();
	}

	if (plainFile != null)
	{
	plainFile.Close();
	}

	if (encryptedFile != null)
	{
	encryptedFile.Close();
	}
	}


	} // Encrypt


	//-------------------------------------------------------------------
	// FUNCTION: DECRYPT WITH PRIVATE KEY
	//-------------------------------------------------------------------
	// https://www.sysadmins.lv/retired-msft-blogs/alejacma/how-to-generate-key-pairs-encrypt-and-decrypt-data-with-net-csharp.aspx

	public static void DecryptWithKey(string privateKeyFileName, string encryptedFileName, string plainFileName)
	{
	// Variables
	CspParameters cspParams = null;
	RSACryptoServiceProvider rsaProvider = null;
	StreamReader privateKeyFile = null;
	FileStream encryptedFile = null;
	StreamWriter plainFile = null;
	string privateKeyText = "";
	string plainText = "";
	byte[] encryptedBytes = null;
	byte[] plainBytes = null;

	try
	{
	// Select target CSP
	cspParams = new CspParameters();
	cspParams.ProviderType = 1; // PROV_RSA_FULL

	//cspParams.ProviderName; // CSP name
	rsaProvider = new RSACryptoServiceProvider(cspParams);

	// Read private/public key pair from file
	privateKeyFile = File.OpenText(privateKeyFileName);
	privateKeyText = privateKeyFile.ReadToEnd();

	// Import private/public key pair
	rsaProvider.FromXmlString(privateKeyText);

	// Read encrypted text from file
	encryptedFile = File.OpenRead(encryptedFileName);
	encryptedBytes = new byte[encryptedFile.Length];
	encryptedFile.Read(encryptedBytes, 0, (int)encryptedFile.Length);

	// Decrypt text
	plainBytes = rsaProvider.Decrypt(encryptedBytes, false);

	// Write decrypted text to file
	plainFile = File.CreateText(plainFileName);
	plainText = Encoding.Unicode.GetString(plainBytes);
	plainFile.Write(plainText);
	}
	catch (Exception ex)
	{
	// Any errors? Show them
	Console.WriteLine("Exception decrypting file! More info:");
	Console.WriteLine(ex.Message);
	}
	finally
	{
	// Do some clean up if needed
	if (privateKeyFile != null)
	{
	privateKeyFile.Close();
	}

	if (encryptedFile != null)
	{
	encryptedFile.Close();
	}

	if (plainFile != null)
	{
	plainFile.Close();
	}
	}
	} // Decrypt


	//-------------------------------------------------------------------
	// Recursive Directory Listing
	//-------------------------------------------------------------------
	// https://stackoverflow.com/questions/929276/how-to-recursively-list-all-the-files-in-a-directory-in-c

	static IEnumerable<string> GetFiles(string path)
	{
	Queue<string> queue = new Queue<string>();
	queue.Enqueue(path);
	while (queue.Count > 0)
	{
	path = queue.Dequeue();
	try
	{
	foreach (string subDir in Directory.GetDirectories(path))
	{
	queue.Enqueue(subDir);
	}
	}
	catch (Exception ex)
	{
	Console.Error.WriteLine(ex);
	}
	string[] files = null;
	try
	{
	files = Directory.GetFiles(path);
	}
	catch (Exception ex)
	{
	Console.Error.WriteLine(ex);
	}
	if (files != null)
	{
	for (int i = 0; i < files.Length; i++)
	{
	yield return files[i];
	}
	}
	}
	}


	//-------------------------------------------------------------------
	// DYNAMIC SALT FOR AES FILE ENCRYPTION
	//-------------------------------------------------------------------
	// https://ourcodeworld.com/articles/read/471/how-to-encrypt-and-decrypt-files-using-the-aes-encryption-algorithm-in-c-sharp

	public static byte[] GenerateRandomSalt()
	{
	byte[] data = new byte[32];

	using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
	{
	for (int i = 0; i < 10; i++)
	{
	// Fille the buffer with the generated data
	rng.GetBytes(data);
	}
	}

	return data;
	}

	//-------------------------------------------------------------------
	// FUNCTION: ENCRYPT FILE WITH AES PASSWORD
	//-------------------------------------------------------------------
	// https://ourcodeworld.com/articles/read/471/how-to-encrypt-and-decrypt-files-using-the-aes-encryption-algorithm-in-c-sharp

	public void FileEncrypt(string inputFile, string password, string fileExt)
	{
	//http://stackoverflow.com/questions/27645527/aes-encryption-on-large-files

	//generate random salt
	byte[] salt = GenerateRandomSalt();

	//create output file name
	FileStream fsCrypt = new FileStream(inputFile + fileExt, FileMode.Create);

	//convert password string to byte arrray
	byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);

	//Set Rijndael symmetric encryption algorithm
	RijndaelManaged AES = new RijndaelManaged();
	AES.KeySize = 256;
	AES.BlockSize = 128;
	AES.Padding = PaddingMode.PKCS7;

	//http://stackoverflow.com/questions/2659214/why-do-i-need-to-use-the-rfc2898derivebytes-class-in-net-instead-of-directly
	//"What it does is repeatedly hash the user password along with the salt." High iteration counts.
	var key = new Rfc2898DeriveBytes(passwordBytes, salt, 50000);
	AES.Key = key.GetBytes(AES.KeySize / 8);
	AES.IV = key.GetBytes(AES.BlockSize / 8);

	//Cipher modes: http://security.stackexchange.com/questions/52665/which-is-the-best-cipher-mode-and-padding-mode-for-aes-encryption
	AES.Mode = CipherMode.CFB;

	// write salt to the begining of the output file, so in this case can be random every time
	fsCrypt.Write(salt, 0, salt.Length);

	CryptoStream cs = new CryptoStream(fsCrypt, AES.CreateEncryptor(), CryptoStreamMode.Write);

	FileStream fsIn = new FileStream(inputFile, FileMode.Open);

	//create a buffer (1mb) so only this amount will allocate in the memory and not the whole file
	byte[] buffer = new byte[1048576];
	int read;

	try
	{
	while ((read = fsIn.Read(buffer, 0, buffer.Length)) > 0)
	{
	cs.Write(buffer, 0, read);
	}

	// Close up
	fsIn.Close();
	}
	catch (Exception ex)
	{
	Console.WriteLine("Error: " + ex.Message);
	}
	finally
	{
	cs.Close();
	fsCrypt.Close();
	}
	}


	//-------------------------------------------------------------------
	// FUNCTION: DECRYPT FILE WITH AES PASSWORD
	//-------------------------------------------------------------------
	// https://ourcodeworld.com/articles/read/471/how-to-encrypt-and-decrypt-files-using-the-aes-encryption-algorithm-in-c-sharp

	public void FileDecrypt(string inputFile, string outputFile, string password)
	{
	byte[] passwordBytes = System.Text.Encoding.UTF8.GetBytes(password);
	byte[] salt = new byte[32];

	FileStream fsCrypt = new FileStream(inputFile, FileMode.Open);
	fsCrypt.Read(salt, 0, salt.Length);

	RijndaelManaged AES = new RijndaelManaged();
	AES.KeySize = 256;
	AES.BlockSize = 128;
	var key = new Rfc2898DeriveBytes(passwordBytes, salt, 50000);
	AES.Key = key.GetBytes(AES.KeySize / 8);
	AES.IV = key.GetBytes(AES.BlockSize / 8);
	AES.Padding = PaddingMode.PKCS7;
	AES.Mode = CipherMode.CFB;

	CryptoStream cs = new CryptoStream(fsCrypt, AES.CreateDecryptor(), CryptoStreamMode.Read);

	FileStream fsOut = new FileStream(outputFile, FileMode.Create);

	int read;
	byte[] buffer = new byte[1048576];

	try
	{
	while ((read = cs.Read(buffer, 0, buffer.Length)) > 0)
	{
	fsOut.Write(buffer, 0, read);
	}
	}
	catch (CryptographicException ex_CryptographicException)
	{
	Console.WriteLine("CryptographicException error: " + ex_CryptographicException.Message);
	}
	catch (Exception ex)
	{
	Console.WriteLine("Error: " + ex.Message);
	}

	try
	{
	cs.Close();
	}
	catch (Exception ex)
	{
	Console.WriteLine("Error by closing CryptoStream: " + ex.Message);
	}
	finally
	{
	fsOut.Close();
	fsCrypt.Close();
	}
	}

	//-------------------------------------------------------------------
	// FUNCTION: ENCRYPT/DECRYPT FILES RECURISVELY WITH AES PASSWORD
	//-------------------------------------------------------------------

	public void CryptFilesRecusive(string targetFilepath, string aesPassword, string fileExt, string genFiles, int Filenumb, string cryptMode)
	{

	// Add check for all parameters

	// Set AES encryoption password
	string mypassword = aesPassword;
	Console.WriteLine("AES Encryption Password: {0}", mypassword);

	// Set file path
	string myfilepath = targetFilepath;
	Console.WriteLine("Target Directory: {0}", myfilepath);

	// Set crypto mode
	//string cryptmode = "0"; // 0=decryption 1=encryption

	// Set file generation settings
	string enableFileGen = genFiles; //yes or no
	int genFilenum = Filenumb; //default to 1000

	// Generating testing files
	if (enableFileGen == "Yes")
	{
	Console.WriteLine("Generating {0} test files in directory", genFilenum);
	for (int i = 0; i < genFilenum; i++)
	{
	//Console.WriteLine("ITERATION: {0}", i);
	string path = targetFilepath + "\\file" + i + ".txt";
	// Create the file, or overwrite if the file exists.
	using (FileStream fs = File.Create(path))
	{
	byte[] info = new System.Text.UTF8Encoding(true).GetBytes("This is some text in the file.");
	// Add some information to the file.
	fs.Write(info, 0, info.Length);
	// Console.WriteLine("- Creating: {0}",path);
	}
	}
	}

	// Search through taret directory recurisvely and encrypt files
	if (cryptMode == "1")
	{
	Console.WriteLine("Encrypting files...");
	}
	else
	{
	Console.WriteLine("Decrypting files...");
	}

	foreach (string file in GetFiles(myfilepath))
	{

	// Encrypt files
	if (cryptMode == "1")
	{
	// Encrypt file
	//Console.WriteLine("Encrypting {0}",file);
	FileEncrypt(file, aesPassword, fileExt);

	// Remove original file
	// Console.WriteLine("Removing {0}",file);
	File.Delete(file);
	}

	// Decrypt files
	if (cryptMode == "0")
	{
	// Decrypt file
	string newfilePath = file + ".decrypted.txt";
	Console.WriteLine("Decrypting {0} to {1}", file, newfilePath);
	FileDecrypt(file, newfilePath, aesPassword);
	File.Delete(file);
	}
	}

	Console.WriteLine("Operation complete.");
	}
	}
	}