Tokens | C# Online Compiler

Tokens by Matt Pavey

using System;
using System.Web;
using System.Linq;
using System.Collections.Specialized;
using System.Security.Cryptography;
using System.IO;
using System.Collections.Generic;

public class Program
{
	public static void Main()
	{
		// dates
		DateTime MyDate = DateTime.Now;
		Console.WriteLine(DateTime.Now);
		Console.WriteLine(DateTime.UtcNow);
		Console.WriteLine(MyDate.ToUniversalTime());
		Console.WriteLine();
		// you said you had these already
		DateTime utc = new DateTime(2014, 6, 4, 12, 34, 0);
		TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
		// it's a simple one-liner
		DateTime pacific = TimeZoneInfo.ConvertTimeFromUtc(utc, tzi);
		Console.WriteLine(utc);
		Console.WriteLine(pacific);
		Console.WriteLine(utc.ToUniversalTime());
		Console.WriteLine(pacific.ToUniversalTime());
		Console.WriteLine();
		//create an encrypted token
		string TokenValue = HttpUtility.UrlDecode(Tokens.CreateToken(Type: "sso", UserName: "salplem", FirstName: "Sally", LastName: "Testing", CryptographyKey: "mykey"));
		Console.WriteLine("CreateToken");
		Console.WriteLine(TokenValue);
		Console.WriteLine();
		//get an encrypted token for testing
		Model.Token TokenObj = Tokens.GetToken(Value: TokenValue, CryptographyKey: "mykey");
		Console.WriteLine("GetToken");
		Console.WriteLine(TokenObj.Serialize());
	}
}

public static class Model
{
	public class Token
	{
		//constructor
		public Token()
		{
			Type = string.Empty;
			UserName = string.Empty;
			Password = string.Empty;
			FirstName = string.Empty;
			LastName = string.Empty;
			Redirect = string.Empty;
			DateCreated = DateTime.MinValue.ToUniversalTime();
			DateExpired = DateTime.MinValue.ToUniversalTime();
		}

		//public properties
		public string Type
		{
			get;
			set;
		}

		public string UserName
		{
			get;
			set;
		}

		public string Password
		{
			get;
			set;
		}

		public string FirstName
		{
			get;
			set;
		}

		public string LastName
		{
			get;
			set;
		}

		public string Redirect
		{
			get;
			set;
		}

		public DateTime DateCreated
		{
			get;
			set;
		}

		public DateTime DateExpired
		{
			get;
			set;
		}

		//derived properties
		public double ElapsedSeconds
		{
			get
			{
				return ((TimeSpan)(DateTime.UtcNow - DateCreated)).TotalSeconds;
			}

			set
			{
			}
		}

		public double ElapsedMinutes
		{
			get
			{
				return ((TimeSpan)(DateTime.UtcNow - DateCreated)).TotalMinutes;
			}

			set
			{
			}
		}

		public double ElapsedHours
		{
			get
			{
				return ((TimeSpan)(DateTime.UtcNow - DateCreated)).TotalHours;
			}

			set
			{
			}
		}

		public bool Valid
		{
			get
			{
				return Type.HasValue() && UserName.HasValue() && !DateCreated.Equals(DateTime.MinValue);
			}

			set
			{
			}
		}

		public bool Expired
		{
			get
			{
				return !DateExpired.Equals(DateTime.MinValue) && DateExpired <= DateTime.UtcNow;
			}

			set
			{
			}
		}
	}
}

public static class Extensions
{
	public static bool IsBlank(this string Value)
	{
		bool ReturnValue = true;
		if (Value != null)
		{
			ReturnValue = Value.Trim().Length == 0;
		}

		return ReturnValue;
	}

	public static bool HasValue(this string Value)
	{
		return !Value.IsBlank();
	}

	public static bool IsEqual(this string Value, string CompareValue)
	{
		bool ReturnValue = false;
		if (Value != null && CompareValue != null)
		{
			ReturnValue = string.Compare(Value.Trim(), CompareValue.Trim(), StringComparison.OrdinalIgnoreCase) == 0;
		}

		return ReturnValue;
	}

	public static bool ContainsKey(this NameValueCollection @this, string key)
	{
		return @this.Get(key) != null || @this.Keys.Cast<string>().Contains(key, StringComparer.OrdinalIgnoreCase);
	}

	public static string Serialize<T>(this T obj)
	{
		// Json.NET (Newtonsoft.Json)
		// https://www.nuget.org/packages/Newtonsoft.Json
		return Newtonsoft.Json.JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented);
	}

	public static T Deserialize<T>(string data)where T : new ()
	{
		// Json.NET (Newtonsoft.Json)
		// https://www.nuget.org/packages/Newtonsoft.Json
		return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(data);
	}
}

public static class Tokens
{
	public static Model.Token GetToken(string Value, string CryptographyKey)
	{
		// variables
		Model.Token Token = new Model.Token();
		NameValueCollection QueryString = new NameValueCollection();
		string TokenValue = Value.HasValue() ? Value : string.Empty;
		// if there was no value stop processing
		if (TokenValue.IsBlank())
		{
			return Token;
		}

		// try decrypting querystring
		try
		{
			QueryString = HttpUtility.ParseQueryString(new Cryptography(CryptographyKey: CryptographyKey).Decrypt(TokenValue));
		}
		catch
		{
			QueryString = new NameValueCollection();
		}

		// get token values
		try
		{
			if (QueryString.HasKeys())
			{
				if (QueryString.ContainsKey("Type"))
				{
					Token.Type = QueryString["Type"];
				}

				if (QueryString.ContainsKey("UserName"))
				{
					Token.UserName = QueryString["UserName"];
				}

				if (QueryString.ContainsKey("Password"))
				{
					Token.Password = QueryString["Password"];
				}

				if (QueryString.ContainsKey("FirstName"))
				{
					Token.FirstName = QueryString["FirstName"];
				}

				if (QueryString.ContainsKey("LastName"))
				{
					Token.LastName = QueryString["LastName"];
				}

				if (QueryString.ContainsKey("Redirect"))
				{
					Token.Redirect = QueryString["Redirect"];
				}

				if (QueryString.ContainsKey("DateCreated"))
				{
					DateTime DateCreated = DateTime.MinValue;
					DateTime.TryParse(QueryString["DateCreated"], out DateCreated);
					Token.DateCreated = DateCreated;
				}

				if (QueryString.ContainsKey("DateExpired"))
				{
					DateTime DateExpired = DateTime.MinValue;
					DateTime.TryParse(QueryString["DateExpired"], out DateExpired);
					Token.DateExpired = DateExpired;
				}
			}
		}
		catch
		{
			return Token;
		}

		//return token
		return Token;
	}

	public static string CreateToken(string Type, string UserName, string FirstName = "", string LastName = "", DateTime? DateExpired = null, string Redirect = "", string CryptographyKey = "", string Password = "")
	{
		// build querystring
		NameValueCollection QueryString = new NameValueCollection();
		// Action
		if (Type.HasValue())
		{
			QueryString.Add("Type", Type);
		}

		// UserName
		if (UserName.HasValue())
		{
			QueryString.Add("UserName", UserName);
		}

		// Password
		if (Password.HasValue())
		{
			QueryString.Add("Password", Password);
		}

		// FirstName
		if (FirstName.HasValue())
		{
			QueryString.Add("FirstName", FirstName);
		}

		// LastName
		if (LastName.HasValue())
		{
			QueryString.Add("LastName", LastName);
		}

		// DateCreated
		QueryString.Add("DateCreated", DateTime.UtcNow.ToString());
		// DateExpired
		if (DateExpired.HasValue)
		{
			QueryString.Add("DateExpired", DateExpired.Value.ToUniversalTime().ToString());
		}

		// Redirect
		if (Redirect.HasValue())
		{
			QueryString.Add("Redirect", Redirect);
		}

		// construct querystring (plain text)
		string q = ConstructQueryString(QueryString);
		
		// encrypt querystring
		q = new Cryptography(CryptographyKey: CryptographyKey).Encrypt(q);

		// url encode querystring
		q = HttpUtility.UrlEncode(q);
		// return value
		return q;
	}

	public static string ConstructQueryString(NameValueCollection parameters)
	{
		List<string> items = new List<string>();
		foreach (string name in parameters)
		{
			items.Add(string.Concat(name, "=", parameters[name]));
		}

		return string.Join("&", items.ToArray());
	}
}

public class Cryptography
{
	//public properties
	public string CryptographyKey
	{
		get;
		set;
	}

	//constructor
	public Cryptography(string CryptographyKey)
	{
		this.CryptographyKey = CryptographyKey;
	}

	private enum CryptographyMode
	{
		Encrypt = 1,
		Decrypt = 2
	}

	public string Encrypt(string PlainText)
	{
		try
		{
			return EncryptDecrypt(PlainText, CryptographyMode.Encrypt);
		}
		catch
		{
			return string.Empty;
		}
	}

	public string Decrypt(string EncryptedText)
	{
		try
		{
			return EncryptDecrypt(EncryptedText, CryptographyMode.Decrypt);
		}
		catch
		{
			return string.Empty;
		}
	}

	private string EncryptDecrypt(string Text, CryptographyMode Mode)
	{
		//Convert the input string into a byte array
		byte[] BytesArray = null;
		switch (Mode)
		{
			case CryptographyMode.Encrypt:
				BytesArray = System.Text.Encoding.Unicode.GetBytes(Text);
				break;
			case CryptographyMode.Decrypt:
				BytesArray = Convert.FromBase64String(Text);
				break;
		}

		//We are using salt to make it harder to guess our key using a dictionary attack (trying to guess a password by enumerating all possible words)
		//PasswordDeriveBytes pdb = new PasswordDeriveBytes(CryptographyKey, new byte[] {0x49,0x76,0x61,0x6e,0x20,0x4d,0x65,0x64,0x76,0x65,0x64,0x65,0x76});
		DeriveBytes pdb;
		// if this is being encrypted for the extranet we need to use Rfc2898DeriveBytes for backwards compatibility
		pdb = new PasswordDeriveBytes(CryptographyKey, new byte[]{0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76});
		//Convert the EncryptionPassword into Key and IV
		//First 32 bytes is the Key (key length is 256bit = 32bytes)
		//Second 32 bytes is the IV (block size is 256bit = 32bytes)
		//IV should always be the block size (block size is 256bit = 32bytes)
		byte[] Key = pdb.GetBytes(32);
		byte[] IV = pdb.GetBytes(32);
		//We are going to use Rijndael because it is strong and available on all platforms
		Rijndael alg = Rijndael.Create();
		//CBC, the .NET default, is the most secure cipher mode. CBC performs an XOR operation on each block of cleartext with the previous cipher block before enciphering it. It also requires an Initialization Vector (IV), a random block of the same length as the algorithm's block size. The IV is used as a stand-in to perform Cipher Block Chaining on the first block of cleartext, since at that point there is no previous block. The IV ensures that repetition in the first block of cleartext does not result in similar repetition of the first block of ciphertext when the same key is used
		alg.Mode = CipherMode.CBC;
		//Since a given message's length may not be an exact multiple of the algorithm's block size, you have to pad the end of the message to fill the last block
		//PKCS7 pads the last block with integers, each of which is the number of bytes used to pad the message
		alg.Padding = PaddingMode.PKCS7;
		//Longer keys are generally more secure because brute-force attacks on them are less likely to be successful. Rijndael allows for keys of sizes 128, 192, and 256 bits. The key size is independent from the block size
		alg.KeySize = 256;
		//With Rijndael, the block sizes can be 128, 192, and 256 bits.
		//Note that Rijndael can be used with all nine permutations of block and key sizes; however, the IV size must be the same as the chosen block size. There is an advantage to using larger block sizes because Rijndael may use from 10 to 14 rounds internally during encryption, with a larger number of rounds for larger block and key sizes. Thus, the more rounds that Rijndael uses internally, the more resistant the cipher is to cryptanalysis
		alg.BlockSize = 256;
		//Set the key and the IV
		//We need the IV (Initialization Vector) because the algorithm is operating in CBC (Cipher Block Chaining) mode
		alg.Key = Key;
		alg.IV = IV;
		//Create a MemoryStream that is going to accept the encrypted/decrypted bytes
		MemoryStream ms = new MemoryStream();
		//Create a CryptoStream through which we are going to be pumping 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
		CryptoStream cs = null;
		switch (Mode)
		{
			case CryptographyMode.Encrypt:
				cs = new CryptoStream(ms, alg.CreateEncryptor(), CryptoStreamMode.Write);
				break;
			case CryptographyMode.Decrypt:
				cs = new CryptoStream(ms, alg.CreateDecryptor(), CryptoStreamMode.Write);
				break;
		}

		//Write the data and make it do the encryption/decryption
		cs.Write(BytesArray, 0, BytesArray.Length);
		//Close the crypto stream (or do FlushFinalBlock)
		//This will tell it that we have done our encryption/decryption and there is no more data coming in, and it is now a good time to apply the padding and finalize the process
		cs.Close();
		//Now get the data from the MemoryStream
		//Some people make a mistake of using GetBuffer() here, which is not the right way
		byte[] ResultingData = ms.ToArray();
		//Now we need to turn the resulting byte array into a 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 ReturnValue = "";
		switch (Mode)
		{
			case CryptographyMode.Encrypt:
				ReturnValue = Convert.ToBase64String(ResultingData);
				break;
			case CryptographyMode.Decrypt:
				ReturnValue = System.Text.Encoding.Unicode.GetString(ResultingData);
				break;
		}

		//Result
		return ReturnValue;
	}
}

​x
 
using System;
using System.Web;
using System.Linq;
using System.Collections.Specialized;
using System.Security.Cryptography;
using System.IO;
using System.Collections.Generic;
​
public class Program
{
    public static void Main()
    {
        // dates
        DateTime MyDate = DateTime.Now;
        Console.WriteLine(DateTime.Now);
        Console.WriteLine(DateTime.UtcNow);
        Console.WriteLine(MyDate.ToUniversalTime());
        Console.WriteLine();
        // you said you had these already
        DateTime utc = new DateTime(2014, 6, 4, 12, 34, 0);
        TimeZoneInfo tzi = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
        // it's a simple one-liner
        DateTime pacific = TimeZoneInfo.ConvertTimeFromUtc(utc, tzi);
        Console.WriteLine(utc);
        Console.WriteLine(pacific);
        Console.WriteLine(utc.ToUniversalTime());
        Console.WriteLine(pacific.ToUniversalTime());
        Console.WriteLine();
        //create an encrypted token
        string TokenValue = HttpUtility.UrlDecode(Tokens.CreateToken(Type: "sso", UserName: "salplem", FirstName: "Sally", LastName: "Testing", CryptographyKey: "mykey"));
        Console.WriteLine("CreateToken");
        Console.WriteLine(TokenValue);
        Console.WriteLine();
        //get an encrypted token for testing
        Model.Token TokenObj = Tokens.GetToken(Value: TokenValue, CryptographyKey: "mykey");
        Console.WriteLine("GetToken");
        Console.WriteLine(TokenObj.Serialize());
    }
}
​
public static class Model
{
    public class Token
    {
        //constructor
        public Token()
        {
            Type = string.Empty;
            UserName = string.Empty;
            Password = string.Empty;
            FirstName = string.Empty;
            LastName = string.Empty;
            Redirect = string.Empty;
            DateCreated = DateTime.MinValue.ToUniversalTime();
            DateExpired = DateTime.MinValue.ToUniversalTime();
        }
​
        //public properties
        public string Type
        {
            get;
            set;
        }
​
        public string UserName
        {
            get;
            set;
        }
​
        public string Password
        {
            get;
            set;
        }
​
        public string FirstName
        {
            get;
            set;
        }
​
        public string LastName
        {
            get;
            set;
        }
​
        public string Redirect
        {
            get;
            set;
        }
​
        public DateTime DateCreated
        {
            get;
            set;
        }
​
        public DateTime DateExpired
        {
            get;
            set;
        }
​
        //derived properties
        public double ElapsedSeconds
        {
            get
            {
                return ((TimeSpan)(DateTime.UtcNow - DateCreated)).TotalSeconds;
            }
​
            set
            {
            }
        }
​
        public double ElapsedMinutes
        {
            get
            {
                return ((TimeSpan)(DateTime.UtcNow - DateCreated)).TotalMinutes;
            }
​
            set
            {
            }
        }
​
        public double ElapsedHours
        {
            get
            {
                return ((TimeSpan)(DateTime.UtcNow - DateCreated)).TotalHours;
            }
​
            set
            {
            }
        }
​
        public bool Valid
        {
            get
            {
                return Type.HasValue() && UserName.HasValue() && !DateCreated.Equals(DateTime.MinValue);
            }
​
            set
            {
            }
        }
​
        public bool Expired
        {
            get
            {
                return !DateExpired.Equals(DateTime.MinValue) && DateExpired <= DateTime.UtcNow;
            }
​
            set
            {
            }
        }
    }
}
​
public static class Extensions
{
    public static bool IsBlank(this string Value)
    {
        bool ReturnValue = true;
        if (Value != null)
        {
            ReturnValue = Value.Trim().Length == 0;
        }
​
        return ReturnValue;
    }
​
    public static bool HasValue(this string Value)
    {
        return !Value.IsBlank();
    }
​
    public static bool IsEqual(this string Value, string CompareValue)
    {
        bool ReturnValue = false;
        if (Value != null && CompareValue != null)
        {
            ReturnValue = string.Compare(Value.Trim(), CompareValue.Trim(), StringComparison.OrdinalIgnoreCase) == 0;
        }
​
        return ReturnValue;
    }
​
    public static bool ContainsKey(this NameValueCollection @this, string key)
    {
        return @this.Get(key) != null || @this.Keys.Cast<string>().Contains(key, StringComparer.OrdinalIgnoreCase);
    }
​
    public static string Serialize<T>(this T obj)
    {
        // Json.NET (Newtonsoft.Json)
        // https://www.nuget.org/packages/Newtonsoft.Json
        return Newtonsoft.Json.JsonConvert.SerializeObject(obj, Newtonsoft.Json.Formatting.Indented);
    }
​
    public static T Deserialize<T>(string data)where T : new ()
    {
        // Json.NET (Newtonsoft.Json)
        // https://www.nuget.org/packages/Newtonsoft.Json
        return Newtonsoft.Json.JsonConvert.DeserializeObject<T>(data);
    }
}
​
public static class Tokens
{
    public static Model.Token GetToken(string Value, string CryptographyKey)
    {
        // variables
        Model.Token Token = new Model.Token();
        NameValueCollection QueryString = new NameValueCollection();
        string TokenValue = Value.HasValue() ? Value : string.Empty;
        // if there was no value stop processing
        if (TokenValue.IsBlank())
        {
            return Token;
        }
​
        // try decrypting querystring
        try
        {
            QueryString = HttpUtility.ParseQueryString(new Cryptography(CryptographyKey: CryptographyKey).Decrypt(TokenValue));
        }
        catch
        {
            QueryString = new NameValueCollection();
        }
​
        // get token values
        try
        {
            if (QueryString.HasKeys())
            {
                if (QueryString.ContainsKey("Type"))
                {
                    Token.Type = QueryString["Type"];
                }
​
                if (QueryString.ContainsKey("UserName"))
                {
                    Token.UserName = QueryString["UserName"];
                }
​
                if (QueryString.ContainsKey("Password"))
                {
                    Token.Password = QueryString["Password"];
                }
​
                if (QueryString.ContainsKey("FirstName"))
                {
                    Token.FirstName = QueryString["FirstName"];
                }
​
                if (QueryString.ContainsKey("LastName"))
                {
                    Token.LastName = QueryString["LastName"];
                }
​
                if (QueryString.ContainsKey("Redirect"))
                {
                    Token.Redirect = QueryString["Redirect"];
                }
​
                if (QueryString.ContainsKey("DateCreated"))
                {
                    DateTime DateCreated = DateTime.MinValue;
                    DateTime.TryParse(QueryString["DateCreated"], out DateCreated);
                    Token.DateCreated = DateCreated;
                }
​
                if (QueryString.ContainsKey("DateExpired"))
                {
                    DateTime DateExpired = DateTime.MinValue;
                    DateTime.TryParse(QueryString["DateExpired"], out DateExpired);
                    Token.DateExpired = DateExpired;
                }
            }
        }
        catch
        {
            return Token;
        }
​
        //return token
        return Token;
    }
​
    public static string CreateToken(string Type, string UserName, string FirstName = "", string LastName = "", DateTime? DateExpired = null, string Redirect = "", string CryptographyKey = "", string Password = "")
    {
        // build querystring
        NameValueCollection QueryString = new NameValueCollection();
        // Action
        if (Type.HasValue())
        {
            QueryString.Add("Type", Type);
        }
​
        // UserName
        if (UserName.HasValue())
        {
            QueryString.Add("UserName", UserName);
        }
​
        // Password
        if (Password.HasValue())
        {
            QueryString.Add("Password", Password);
        }
​
        // FirstName
        if (FirstName.HasValue())
        {
            QueryString.Add("FirstName", FirstName);
        }
​
        // LastName
        if (LastName.HasValue())
        {
            QueryString.Add("LastName", LastName);
        }
​
        // DateCreated
        QueryString.Add("DateCreated", DateTime.UtcNow.ToString());
        // DateExpired
        if (DateExpired.HasValue)
        {
            QueryString.Add("DateExpired", DateExpired.Value.ToUniversalTime().ToString());
        }
​
        // Redirect
        if (Redirect.HasValue())
        {
            QueryString.Add("Redirect", Redirect);
        }
​
        // construct querystring (plain text)
        string q = ConstructQueryString(QueryString);
        
        // encrypt querystring
        q = new Cryptography(CryptographyKey: CryptographyKey).Encrypt(q);
​
        // url encode querystring
        q = HttpUtility.UrlEncode(q);
        // return value
        return q;
    }
​
    public static string ConstructQueryString(NameValueCollection parameters)
    {
        List<string> items = new List<string>();
        foreach (string name in parameters)
        {
            items.Add(string.Concat(name, "=", parameters[name]));
        }
​
        return string.Join("&", items.ToArray());
    }
}
​
public class Cryptography
{
    //public properties
    public string CryptographyKey
    {
        get;
        set;
    }
​
    //constructor
    public Cryptography(string CryptographyKey)
    {
        this.CryptographyKey = CryptographyKey;
    }
​
    private enum CryptographyMode
    {
        Encrypt = 1,
        Decrypt = 2
    }
​
    public string Encrypt(string PlainText)
    {
        try
        {
            return EncryptDecrypt(PlainText, CryptographyMode.Encrypt);
        }
        catch
        {
            return string.Empty;
        }
    }
​
    public string Decrypt(string EncryptedText)
    {
        try
        {
            return EncryptDecrypt(EncryptedText, CryptographyMode.Decrypt);
        }
        catch
        {
            return string.Empty;
        }
    }
​
    private string EncryptDecrypt(string Text, CryptographyMode Mode)
    {
        //Convert the input string into a byte array
        byte[] BytesArray = null;
        switch (Mode)
        {
            case CryptographyMode.Encrypt:
                BytesArray = System.Text.Encoding.Unicode.GetBytes(Text);
                break;
            case CryptographyMode.Decrypt:
                BytesArray = Convert.FromBase64String(Text);
                break;
        }
​
        //We are using salt to make it harder to guess our key using a dictionary attack (trying to guess a password by enumerating all possible words)
        //PasswordDeriveBytes pdb = new PasswordDeriveBytes(CryptographyKey, new byte[] {0x49,0x76,0x61,0x6e,0x20,0x4d,0x65,0x64,0x76,0x65,0x64,0x65,0x76});
        DeriveBytes pdb;
        // if this is being encrypted for the extranet we need to use Rfc2898DeriveBytes for backwards compatibility
        pdb = new PasswordDeriveBytes(CryptographyKey, new byte[]{0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76});
        //Convert the EncryptionPassword into Key and IV
        //First 32 bytes is the Key (key length is 256bit = 32bytes)
        //Second 32 bytes is the IV (block size is 256bit = 32bytes)
        //IV should always be the block size (block size is 256bit = 32bytes)
        byte[] Key = pdb.GetBytes(32);
        byte[] IV = pdb.GetBytes(32);
        //We are going to use Rijndael because it is strong and available on all platforms
        Rijndael alg = Rijndael.Create();
        //CBC, the .NET default, is the most secure cipher mode. CBC performs an XOR operation on each block of cleartext with the previous cipher block before enciphering it. It also requires an Initialization Vector (IV), a random block of the same length as the algorithm's block size. The IV is used as a stand-in to perform Cipher Block Chaining on the first block of cleartext, since at that point there is no previous block. The IV ensures that repetition in the first block of cleartext does not result in similar repetition of the first block of ciphertext when the same key is used
        alg.Mode = CipherMode.CBC;
        //Since a given message's length may not be an exact multiple of the algorithm's block size, you have to pad the end of the message to fill the last block
        //PKCS7 pads the last block with integers, each of which is the number of bytes used to pad the message
        alg.Padding = PaddingMode.PKCS7;
        //Longer keys are generally more secure because brute-force attacks on them are less likely to be successful. Rijndael allows for keys of sizes 128, 192, and 256 bits. The key size is independent from the block size
        alg.KeySize = 256;
        //With Rijndael, the block sizes can be 128, 192, and 256 bits.
        //Note that Rijndael can be used with all nine permutations of block and key sizes; however, the IV size must be the same as the chosen block size. There is an advantage to using larger block sizes because Rijndael may use from 10 to 14 rounds internally during encryption, with a larger number of rounds for larger block and key sizes. Thus, the more rounds that Rijndael uses internally, the more resistant the cipher is to cryptanalysis
        alg.BlockSize = 256;
        //Set the key and the IV
        //We need the IV (Initialization Vector) because the algorithm is operating in CBC (Cipher Block Chaining) mode
        alg.Key = Key;
        alg.IV = IV;
        //Create a MemoryStream that is going to accept the encrypted/decrypted bytes
        MemoryStream ms = new MemoryStream();
        //Create a CryptoStream through which we are going to be pumping 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
        CryptoStream cs = null;
        switch (Mode)
        {
            case CryptographyMode.Encrypt:
                cs = new CryptoStream(ms, alg.CreateEncryptor(), CryptoStreamMode.Write);
                break;
            case CryptographyMode.Decrypt:
                cs = new CryptoStream(ms, alg.CreateDecryptor(), CryptoStreamMode.Write);
                break;
        }
​
        //Write the data and make it do the encryption/decryption
        cs.Write(BytesArray, 0, BytesArray.Length);
        //Close the crypto stream (or do FlushFinalBlock)
        //This will tell it that we have done our encryption/decryption and there is no more data coming in, and it is now a good time to apply the padding and finalize the process
        cs.Close();
        //Now get the data from the MemoryStream
        //Some people make a mistake of using GetBuffer() here, which is not the right way
        byte[] ResultingData = ms.ToArray();
        //Now we need to turn the resulting byte array into a 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 ReturnValue = "";
        switch (Mode)
        {
            case CryptographyMode.Encrypt:
                ReturnValue = Convert.ToBase64String(ResultingData);
                break;
            case CryptographyMode.Decrypt:
                ReturnValue = System.Text.Encoding.Unicode.GetString(ResultingData);
                break;
        }
​
        //Result
        return ReturnValue;
    }
}

Enter a number:

Cached Result
Last Run:	11:10:24 am
Compile:	0.125s
Execute:	0s
Memory:	32kb
CPU:	0s

View IL Code