public string CreateReference(int size)
        {
            const int byteSize = 0x100;
            var chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890".ToCharArray();
            var allowedCharSet = new HashSet<char>(chars).ToArray();

            using (var cryptoProvider = new RNGCryptoServiceProvider())
            {
                var result = new StringBuilder();
                var buffer = new byte[128];

                while (result.Length < size)
                {
                    cryptoProvider.GetBytes(buffer);

                    for (var i = 0; i < buffer.Length && result.Length < size; ++i)
                    {
                        var outOfRangeStart = byteSize - (byteSize % allowedCharSet.Length);

                        if (outOfRangeStart <= buffer[i])
                        {
                            continue;
                        }

                        result.Append(allowedCharSet[buffer[i] % allowedCharSet.Length]);
                    }
                }
                return result.ToString();
            }
        }

 public static string CreateRandomSalt()
 {
     var saltBytes = new Byte[4];
     var rng = new RNGCryptoServiceProvider();
     rng.GetBytes(saltBytes);
     return Convert.ToBase64String(saltBytes);
 }

 public static int NextInt32(int max)
 {
     byte[] bytes = new byte[sizeof(int)];
     RNGCryptoServiceProvider Gen = new RNGCryptoServiceProvider();
     Gen.GetBytes(bytes);
     return Math.Abs(BitConverter.ToInt32(bytes, 0) % max);
 }

        /// <summary>
        /// Generate Password Salt Int to add to password
        /// </summary>
        /// <returns>Salt Int</returns>

        internal string GenerateSalt()
        {
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            byte[] buff = new byte[32];
            rng.GetBytes(buff);
            return Convert.ToBase64String(buff);
        }

 public static Int64 NextInt64()
 {
     var bytes = new byte[sizeof(Int64)];
        RNGCryptoServiceProvider Gen = new RNGCryptoServiceProvider();
        Gen.GetBytes(bytes);
        return BitConverter.ToInt64(bytes , 0);
 }

        /// <summary>
        /// CreateHashedText
        /// </summary>
        /// <param name="plainText"></param>
        /// <param name="useSalt"></param>
        /// <returns></returns>
        public static KeyValuePair<string, string> CreateHashedText(string plainText,bool useSalt)
        {
            var plainTextBytes = Encoding.Unicode.GetBytes(plainText);

            string salt = string.Empty;
            string hashedText = string.Empty;
            if (useSalt)
            {
                var saltBytes = new byte[0x10];
                using (var random = new RNGCryptoServiceProvider())
                {
                    random.GetBytes(saltBytes);
                }

                salt = Convert.ToBase64String(saltBytes);
                plainTextBytes=saltBytes.Concat(plainTextBytes).ToArray();
            }

            byte[] hashBytes;
            using (var hashAlgorithm = HashAlgorithm.Create())
            {
                hashBytes = hashAlgorithm.ComputeHash(plainTextBytes);
            }

            hashedText = Convert.ToBase64String(hashBytes);

            return new KeyValuePair<string, string>(hashedText, salt);
        }

 /// <summary>
 /// Creates a key based on the indicated size.
 /// </summary>
 /// <param name="numBytes">size of the key.</param>
 /// <returns>Generated key of the specified length.</returns>
 public static string CreateKey(int numBytes)
 {
     RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
     byte[] buff = new byte[numBytes];
     rng.GetBytes(buff);
     return BytesToHexString(buff);
 }

        /// <summary>
        /// Generate a random string of characters
        /// </summary>
        /// <param name="length">length of string</param>
        /// <param name="type">type of string to be generated</param>
        /// <returns></returns>
        public static string GenerateRandomString(int length, StringType type)
        {
            switch (type)
            {
                case StringType.AlphaNumeric:
                    string allowedChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789";
                    char[] chars = new char[length];
                    Random rd = new Random();

                    for (int i = 0; i < length; i++)
                    {
                        chars[i] = allowedChars[rd.Next(0, allowedChars.Length)];
                    }

                    return new string(chars);
                    break;

                case StringType.AlphaNumericSymbol:
                    //Generate a cryptographic random number.
                    var rng = new RNGCryptoServiceProvider();
                    var buff = new byte[length];
                    rng.GetBytes(buff);

                    rng.Dispose();

                    // Return a Base64 string representation of the random number.
                    return Convert.ToBase64String(buff);
                    break;
                default:
                    throw new ArgumentException("Type not supported");
            }
        }

        public static string Generate(int length, string allowedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
        {
            if (length < 0) throw new ArgumentOutOfRangeException("length", "length cannot be less than zero.");
            if (string.IsNullOrEmpty(allowedChars)) throw new ArgumentException("allowedChars may not be empty.");

            const int byteSize = 0x100;
            var allowedCharSet = new HashSet<char>(allowedChars).ToArray();
            if (byteSize < allowedCharSet.Length) throw new ArgumentException(String.Format("allowedChars may contain no more than {0} characters.", byteSize));

            // Guid.NewGuid and System.Random are not particularly random. By using a
            // cryptographically-secure random number generator, the caller is always
            // protected, regardless of use.
            using (var rng = new RNGCryptoServiceProvider())
            {
                var result = new StringBuilder();
                var buf = new byte[128];
                while (result.Length < length)
                {
                    rng.GetBytes(buf);
                    for (var i = 0; i < buf.Length && result.Length < length; ++i)
                    {
                        // Divide the byte into allowedCharSet-sized groups. If the
                        // random value falls into the last group and the last group is
                        // too small to choose from the entire allowedCharSet, ignore
                        // the value in order to avoid biasing the result.
                        var outOfRangeStart = byteSize - (byteSize % allowedCharSet.Length);
                        if (outOfRangeStart <= buf[i]) continue;
                        result.Append(allowedCharSet[buf[i] % allowedCharSet.Length]);
                    }
                }
                return result.ToString();
            }
        }

 public string GetSalt(int saltLength)
 {
     var rng = new RNGCryptoServiceProvider();
     var saltBytes = new byte[saltLength];
     rng.GetNonZeroBytes(saltBytes);
     return BitConverter.ToString(saltBytes).Replace("-", "");
 }

 /// <summary>
 /// Returns a random 64 character hex string (256 bits)
 /// </summary>
 /// <returns>The random string</returns>
 private static string GetRandomSalt()
 {
     RNGCryptoServiceProvider random = new RNGCryptoServiceProvider();
     byte[] salt = new byte[32]; // 256 bits
     random.GetBytes(salt);
     return BytesToHex(salt);
 }

        //
        // internal static methods
        //

        // CMS TripleDES KeyWrap as described in "http://www.w3.org/2001/04/xmlenc#kw-tripledes"
        internal static byte[] TripleDESKeyWrapEncrypt (byte[] rgbKey, byte[] rgbWrappedKeyData) {
            // checksum the key
            SHA1CryptoServiceProvider sha = new SHA1CryptoServiceProvider();
            byte[] rgbCKS = sha.ComputeHash(rgbWrappedKeyData);

            // generate a random IV
            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
            byte[] rgbIV = new byte[8];
            rng.GetBytes(rgbIV);

            // rgbWKCS = rgbWrappedKeyData | (first 8 bytes of the hash)
            byte[] rgbWKCKS = new byte[rgbWrappedKeyData.Length + 8];
            TripleDESCryptoServiceProvider tripleDES = new TripleDESCryptoServiceProvider();
            // Don't add padding, use CBC mode: for example, a 192 bits key will yield 40 bytes of encrypted data
            tripleDES.Padding = PaddingMode.None;
            ICryptoTransform enc1 = tripleDES.CreateEncryptor(rgbKey, rgbIV);
            Buffer.BlockCopy(rgbWrappedKeyData, 0, rgbWKCKS, 0, rgbWrappedKeyData.Length);
            Buffer.BlockCopy(rgbCKS, 0, rgbWKCKS, rgbWrappedKeyData.Length, 8);
            byte[] temp1 = enc1.TransformFinalBlock(rgbWKCKS, 0, rgbWKCKS.Length);
            byte[] temp2 = new byte[rgbIV.Length + temp1.Length];
            Buffer.BlockCopy(rgbIV, 0, temp2, 0, rgbIV.Length);
            Buffer.BlockCopy(temp1, 0, temp2, rgbIV.Length, temp1.Length);
            // temp2 = REV (rgbIV | E_k(rgbWrappedKeyData | rgbCKS))
            Array.Reverse(temp2);

            ICryptoTransform enc2 = tripleDES.CreateEncryptor(rgbKey, s_rgbTripleDES_KW_IV);
            return enc2.TransformFinalBlock(temp2, 0, temp2.Length);
        }

 public static string GenerateRandomSalt()
 {
     RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
     byte[] bytes = new byte[10];
     provider.GetBytes(bytes);
     return Convert.ToBase64String(bytes);
 }

 private byte[] GetRandomSaltValue()
 {
     var rcsp = new RNGCryptoServiceProvider();
     var bSalt = new byte[16];
     rcsp.GetBytes(bSalt);
     return bSalt;
 }

 public static string GenerateToken()
 {
     RNGCryptoServiceProvider r = new RNGCryptoServiceProvider();
     byte[] buffer = new byte[39];
     r.GetNonZeroBytes(buffer);
     return Convert.ToBase64String(buffer);
 }

 public string GenerateSalt() {
 var data = new byte[0x10];
 using (var cryptoServiceProvider = new RNGCryptoServiceProvider()) {
 cryptoServiceProvider.GetBytes(data);
 return Convert.ToBase64String(data);
 }
 }

 public string GenerateSalt()
 {
     var random = new RNGCryptoServiceProvider();
     var salt = new Byte[8];
     random.GetBytes(salt);
     return Convert.ToBase64String(salt);
 }

		/// <summary>
		/// http://www.codeproject.com/Articles/14403/Generating-Unique-Keys-in-Net
		/// </summary>
		/// <returns></returns>
		public static string GetUniqueNumber()
		{
			//string result = DateTime.Now.Year.ToString() + Guid.NewGuid().ToString().GetHashCode().ToString("x");
			//return result;

			int maxSize = 8;
			char[] chars = new char[62];
			string a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
			chars = a.ToCharArray();
			int size = maxSize;
			byte[] data = new byte[1];

			var crypto = new RNGCryptoServiceProvider();
			crypto.GetNonZeroBytes(data);
			data = new byte[size];
			crypto.GetNonZeroBytes(data);
			var result = new StringBuilder(size);

			foreach (byte b in data)
			{
				result.Append(chars[b % (chars.Length - 1)]);
			}

			return "CS" + result.ToString();

		}

        public static Stack<int> CreateCardsValues([NotNull] GameStage stage)
        {
            Contract.Requires(stage != null);

            var totalNumberOfCards = stage.CardsRows.Sum();
            var numberOfDifferentCards = totalNumberOfCards / stage.CardsInGroup;

            var cardsValues = new List<int>();

            for (int i = 0; i < numberOfDifferentCards; i++)
            {
                cardsValues.AddRange(Enumerable.Repeat(i, stage.CardsInGroup));
            }

            using (var rndGen = new RNGCryptoServiceProvider())
            {
                byte[] bytes = new byte[cardsValues.Count];
                rndGen.GetBytes(bytes);

                int[] ints = bytes.Select(b => b - byte.MaxValue / 2).ToArray();

                var rnd = new Random((int)DateTime.UtcNow.Ticks);

                cardsValues.Sort((c1, c2) => ints[rnd.Next(0, ints.Length)]);
            }

            return new Stack<int>(cardsValues);
        }

 public static byte[] GetBuffer(int length)
 {
     RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
     byte[] output = new byte[length];
     rng.GetBytes(output);
     return output;
 }