private byte[] GetRandomSaltValue()
{
var rcsp = new RNGCryptoServiceProvider();
var bSalt = new byte[16];
rcsp.GetBytes(bSalt);
return bSalt;
}
public byte[] GenerateSalt()
{
var rng = new RNGCryptoServiceProvider();
var salt = new byte[256];
rng.GetBytes(salt);
return salt;
}
public bool AddUser(string userPassword, UsersDTO user)
{
try
{
var userentity = user.ToUser();
var salt = new Byte[32];
using (var provider = new System.Security.Cryptography.RNGCryptoServiceProvider())
{
provider.GetBytes(salt); // Generated salt
}
var pbkdf2 = new System.Security.Cryptography.Rfc2898DeriveBytes(userPassword, salt);
pbkdf2.IterationCount = 1000;
byte[] hash = pbkdf2.GetBytes(32); // Hashed and salted password
userentity.Salt = salt;
userentity.EncPassword = hash;
operationalDataContext.Users.Add(userentity);
return(operationalDataContext.SaveChanges() > 0);
}
catch (Exception ex)
{
return(false);
}
}
private string GetBase32UniqueId(int length, char[] allowedCharSet)
{
if (length < 0)
{
throw new ArgumentOutOfRangeException("length", "length cannot be less than zero.");
}
if (_byteSize < allowedCharSet.Length)
{
throw new ArgumentException(String.Format("allowedChars may contain no more than {0} characters.", _byteSize));
}
using (var rng = new System.Security.Cryptography.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)
{
var outOfRangeStart = _byteSize - (_byteSize % allowedCharSet.Length);
if (outOfRangeStart <= buf[i])
{
continue;
}
result.Append(allowedCharSet[buf[i] % allowedCharSet.Length]);
}
}
return(result.ToString());
}
}
public static string GenerateRandomSalt()
{
RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
byte[] bytes = new byte[10];
provider.GetBytes(bytes);
return Convert.ToBase64String(bytes);
}
/// <summary>
/// Initializes an implementation of HMACSHA1
/// </summary>
public override void Initialize()
{
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
byte[] key = new byte[64];
rng.GetBytes(key);
//_key = OpenNETCF.Security.Cryptography.Internal.Rand.GetRandomBytes(64);
}
private int[] 親からランダムな交叉(int[] geneA, int[] geneB, int パラメータ数)
{
//Int32と同じサイズのバイト配列にランダムな値を設定する
//byte[] bs = new byte[sizeof(int)];
byte[] bs = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bs);
//Int32に変換する
int seed = System.BitConverter.ToInt32(bs, 0);
// そのseedを基にRandomを作る
var r = new Random(seed++);
int[] gene = new int[パラメータ数 + 他の要素];
for (int i = 0; i < パラメータ数; i++)
{
if (r.Next(2) == 1)
{
gene[i] = geneA[i];
}
else
{
gene[i] = geneB[i];
}
}
bs = null;
rng.Dispose();
r = null;
return(gene);
}
/// <summary>
/// Returns the given number of seed bytes generated for the first running of a new instance
/// of the random number generator.
/// </summary>
/// <param name="numberOfBytes">Number of seed bytes to generate.</param>
/// <returns>Seed bytes generated</returns>
public static byte[] GetSeed(int numberOfBytes)
{
RNGCryptoServiceProvider generatedSeed = new RNGCryptoServiceProvider();
byte[] seeds = new byte[numberOfBytes];
generatedSeed.GetBytes(seeds);
return seeds;
}
private int[] ランダムに遺伝子1つ作成(int[,] パラメータ)
{
int パラメータ数 = パラメータ.Length / 2;
//Int32と同じサイズのバイト配列にランダムな値を設定する
//byte[] bs = new byte[sizeof(int)];
byte[] bs = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bs);
//Int32に変換する
int seed = System.BitConverter.ToInt32(bs, 0);
// そのseedを基にRandomを作る
var r = new Random(seed++);
int[] gene = new int[パラメータ数 + 他の要素];
for (int i = 0; i < パラメータ数; i++)
{
gene[i] = r.Next(パラメータ[i, 0], パラメータ[i, 1] + 1);
}
bs = null;
rng.Dispose();
r = null;
return(gene);
}
public static string GenerateUID()
{
try
{
int maxSize = 15;
int minSize = 10;
char[] chars = new char[63];
string a;
a = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
chars = a.ToCharArray();
int size = maxSize;
byte[] data = new byte[2];
System.Security.Cryptography.RNGCryptoServiceProvider crypto = new System.Security.Cryptography.RNGCryptoServiceProvider();
crypto.GetNonZeroBytes(data);
size = maxSize;
data = new byte[size + 1];
crypto.GetNonZeroBytes(data);
StringBuilder result = new StringBuilder(size);
foreach (byte b in data)
{
result.Append(chars[b % (chars.Length - 1)]);
}
return(result.ToString().Trim());
}
catch (Exception ex)
{
return("");
}
}
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 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>
/// This function stores user credentials using the Windows Data Protection API
/// </summary>
/// <param name="userName"></param>
/// <param name="password"></param>
public static void StorePerUserCredentials(string userName, SecureString password, string fileName, string keyName)
{
// Generate additional entropy (will be used as the Initialization vector)
// This is basically the (2048-bit) encryption key used to encrypt the credentials
// The encryption key changes everytime the credentials get stored for increased security (everytime someone logs in with "Remember Me" ticked)
byte[] entropy = new byte[256];
using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
rng.GetBytes(entropy);
}
var currentUserRegistry = Registry.CurrentUser.OpenSubKey("Software\\SystemsUnitedNavy", true);
if (currentUserRegistry == null)
currentUserRegistry = Registry.CurrentUser.CreateSubKey("Software\\SystemsUnitedNavy", RegistryKeyPermissionCheck.Default);
currentUserRegistry.SetValue(keyName, entropy);
var data = ProtectedData.Protect(StringToByteArray(string.Format("{0};#{1}",
userName, SecureStringUtility.SecureStringToString(password))),
entropy,
DataProtectionScope.CurrentUser);
File.WriteAllBytes(fileName, data);
}
/// <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);
}
public void TestCryptoRandom()
{
using (var random = new System.Security.Cryptography.RNGCryptoServiceProvider())
{
this.TestRandom(random.AsRandom());
}
}
/// <summary>
/// Creates an array of bytes with a cryptographically strong sequence of random values.
/// </summary>
/// <param name="length">Length of array to create.</param>
/// <returns>An array of bytes filled with a cryptographically strong sequence of random values.</returns>
public static byte[] GetRandomBytes(int length)
{
byte[] randomBytes = new byte[length];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
rng.GetBytes(randomBytes);
return randomBytes;
}
/// <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>
/// Creates a new and initialized instance of the TripleSec RNG (no parameters).
/// </summary>
public RNGV4()
{
// sure, the .NET RNG is pretty good, but lets make an attacker's life miserable
// and also guard against a compromised RNG
SSC.RNGCryptoServiceProvider rng = new SSC.RNGCryptoServiceProvider();
byte[] tempKey = new byte[512];
byte[] tempSalt = new byte[512];
rng.GetBytes(tempKey);
rng.GetBytes(tempSalt);
byte[] interim = new SSC.Rfc2898DeriveBytes(tempKey, tempSalt, 64).GetBytes(1024);
rng.GetBytes(tempSalt);
byte[] final = new SSC.Rfc2898DeriveBytes(interim, tempSalt, 64).GetBytes(56);
tempKey.Wipe();
tempSalt.Wipe();
interim.Wipe(); // DON'T LEAK!!
_salt = new byte[16];
_aesIV = new byte[16];
_xsalsa20IV = new byte[24];
Buffer.BlockCopy(final, 0, _salt, 0, _salt.Length);
Buffer.BlockCopy(final, 16, _aesIV, 0, _aesIV.Length);
Buffer.BlockCopy(final, 16 + 16, _xsalsa20IV, 0, _xsalsa20IV.Length);
_ready = true;
//#if DEBUG
// System.Diagnostics.Debug.Print("RNGV4:-------------------------------------");
// System.Diagnostics.Debug.Print("salt: " + BitConverter.ToString(_salt).Replace("-", "").ToLowerInvariant());
// System.Diagnostics.Debug.Print("aesIV: " + BitConverter.ToString(_salt).Replace("-", "").ToLowerInvariant());
// System.Diagnostics.Debug.Print("xsalsa20IV: " + BitConverter.ToString(_salt).Replace("-", "").ToLowerInvariant());
// System.Diagnostics.Debug.Print("final array: " + BitConverter.ToString(final).Replace("-", "").ToLowerInvariant());
//#endif
final.Wipe(); // DON'T LEAVE COPIES LAYING AROUND!
}
public string GetSalt(int saltLength)
{
var rng = new RNGCryptoServiceProvider();
var saltBytes = new byte[saltLength];
rng.GetNonZeroBytes(saltBytes);
return BitConverter.ToString(saltBytes).Replace("-", "");
}
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);
}
private byte[] GenerateSalt(int size)
{
byte[] data = new byte[size];
System.Security.Cryptography.RNGCryptoServiceProvider provider = new System.Security.Cryptography.RNGCryptoServiceProvider();
provider.GetBytes(data);
return(data);
}
public static byte[] generateSalt()
{
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
byte[] salt = new byte[256];
rng.GetBytes(salt);
return salt;
}
public string GenerateSalt()
{
var random = new RNGCryptoServiceProvider();
var salt = new Byte[8];
random.GetBytes(salt);
return Convert.ToBase64String(salt);
}
public static byte[] GetBuffer(int length)
{
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
byte[] output = new byte[length];
rng.GetBytes(output);
return output;
}
private void CompareBlocks(int BlockSize)
{
using (RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider())
{
byte[] key = new byte[32];
byte[] iv = new byte[BlockSize];
byte[] data = new byte[1600];
rng.GetBytes(key);
rng.GetBytes(iv);
rng.GetBytes(data);
byte[] enc1 = EncryptRDX(key, iv, data);
byte[] enc2 = EncryptManaged(key, iv, data);
if (Compare.AreEqual(enc1, enc2) == false)
throw new Exception("Encrypted output is not equal!");
byte[] dec1 = DecryptRDX(key, iv, data);
byte[] dec2 = DecryptManaged(key, iv, data);
if (Compare.AreEqual(dec2, dec1) == false)
throw new Exception("Decrypted output is not equal to input data!");
}
}
static int GetRandomSeed()
{
byte[] bytes = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bytes);
return BitConverter.ToInt32(bytes, 0);
}
public string GenerateSalt() {
var data = new byte[0x10];
using (var cryptoServiceProvider = new RNGCryptoServiceProvider()) {
cryptoServiceProvider.GetBytes(data);
return Convert.ToBase64String(data);
}
}
public static int GetRandomSeed()
{
byte[] bytes = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bytes);
return(BitConverter.ToInt32(bytes, 0));
}
public static string CreateSalt()
{
byte[] bytSalt = new byte[9];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bytSalt);
return(Convert.ToBase64String(bytSalt));
}
/// <summary>
/// 生成随机数的种子
/// </summary>
/// <returns></returns>
private static int getNewSeed()
{
byte[] rndBytes = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(rndBytes);
return(BitConverter.ToInt32(rndBytes, 0));
}
static byte[] GenerateSaltedHash(string input, int size)
{
var rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
byte[] salt = new byte[size];
rng.GetBytes(salt);
byte[] plainText = Encoding.UTF8.GetBytes(input);
HashAlgorithm algorithm = new SHA256Managed();
byte[] plainTextWithSaltBytes =
new byte[plainText.Length + salt.Length];
for (int i = 0; i < plainText.Length; i++)
{
plainTextWithSaltBytes[i] = plainText[i];
}
for (int i = 0; i < salt.Length; i++)
{
plainTextWithSaltBytes[plainText.Length + i] = salt[i];
}
return(algorithm.ComputeHash(plainTextWithSaltBytes));
}
public static byte[] getNewRandomSeed(int seed_len)
{
byte[] entropy = new byte[seed_len];
System.Security.Cryptography.RNGCryptoServiceProvider rngCSP = new System.Security.Cryptography.RNGCryptoServiceProvider();
rngCSP.GetBytes(entropy);
return(entropy);
}
/// <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 CreateRandomSalt()
{
var saltBytes = new Byte[4];
var rng = new RNGCryptoServiceProvider();
rng.GetBytes(saltBytes);
return Convert.ToBase64String(saltBytes);
}
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 CreateSalt()
{
byte[] array = new byte[8];
System.Security.Cryptography.RNGCryptoServiceProvider rNGCryptoServiceProvider = new System.Security.Cryptography.RNGCryptoServiceProvider();
rNGCryptoServiceProvider.GetBytes(array);
return(System.Convert.ToBase64String(array));
}
/// <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 string GetUniqueIndentifier(int length)
{
if (length <= 0)
{
return(string.Empty);
}
int maxSize = length;
char[] chars = new char[62];
string a = "abcdefghijklmnopqrstuvwxyz1234567890";
chars = a.ToCharArray();
int size = maxSize;
byte[] data = new byte[1];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetNonZeroBytes(data);
size = maxSize;
data = new byte[size];
rng.GetNonZeroBytes(data);
StringBuilder result = new StringBuilder();
foreach (byte b in data)
{
result.Append(chars[b % (chars.Length - 1)]);
}
if (result[0] >= '0' && result[0] <= '9')
{
return(GetUniqueIndentifier(length));
}
return(result.ToString());
}
public static string GenerateSalt(int saltSize)
{
RNGCryptoServiceProvider rngCryptoServiceProvider = new RNGCryptoServiceProvider();
byte[] byteArray = new Byte[saltSize];
rngCryptoServiceProvider.GetBytes(byteArray);
return Convert.ToBase64String(byteArray);
}
public static byte[] CreateSalt(int size = 16)
{
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
byte[] buff = new byte[size];
rng.GetBytes(buff);
return buff;
}
public void Performance_tests()
{
// random write.
var gen = new RNGCryptoServiceProvider();
var bytes = 1024;
var data = new byte[bytes];
gen.GetNonZeroBytes(data);
var stopwatch = Stopwatch.StartNew();
var records = 200;
var total = records * bytes;
Console.WriteLine("Data is {0} records of {1} bytes == {2} bytes or {3} MB", records, bytes, total, total / 1024 / 1024);
for (int i = 0; i < records; i++)
{
_stream.TryAppend(data);
}
var timeSpan = stopwatch.Elapsed;
Console.WriteLine("Writing one by one in {0}", timeSpan.TotalSeconds);
int counter = 0;
var reading = Stopwatch.StartNew();
foreach (var tapeRecord in _stream.ReadRecords(0, int.MaxValue))
{
counter += tapeRecord.Data.Length;
}
Console.WriteLine("Reading in {0} seconds", reading.Elapsed.TotalSeconds);
Console.WriteLine("Read {0} bytes of raw data", counter);
}
//
// 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 GenerateToken()
{
RNGCryptoServiceProvider r = new RNGCryptoServiceProvider();
byte[] buffer = new byte[39];
r.GetNonZeroBytes(buffer);
return Convert.ToBase64String(buffer);
}
/// <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>
/// 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);
}
private int GetRandomSeed()
{
byte[] bytes = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bytes);
Console.WriteLine(BitConverter.ToInt32(bytes, 0));
return(BitConverter.ToInt32(bytes, 0));
}
/// <summary>
/// 获取随机数种子
/// </summary>
/// <returns></returns>
public static int GetRandomSeed()
{
byte[] bytes = new byte[4];
//使用加密服务提供程序 (CSP)提供的实现来实现加密随机数生成器 (RNG)。无法继承此类。
System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
rng.GetBytes(bytes);//用经过加密的强随机值序列填充字节数组。
return BitConverter.ToInt32(bytes, 0);
}
public static String KrijoSalt(int madhesia)
{
var nrRastesishem = new System.Security.Cryptography.RNGCryptoServiceProvider();
var baferi = new byte[madhesia];
nrRastesishem.GetBytes(baferi);
return(Convert.ToBase64String(baferi));
}
public string CreateSalt(int SaltSize)
{
var rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
byte[] Salt = new byte[SaltSize];
rng.GetBytes(Salt);
return(Convert.ToBase64String(Salt));
}
/// <summary>
/// serialization of password
/// </summary>
/// <param name="size">password split size</param>
/// <returns></returns>
public string CreateSalt(int size)
{
byte[] bytedata = new byte[size];
var rngProvider = new System.Security.Cryptography.RNGCryptoServiceProvider();
rngProvider.GetBytes(bytedata);
return(Convert.ToBase64String(bytedata));
}
public static string CreateSalt(int size)
{
var rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
var buff = new byte[size];
rng.GetBytes(buff);
return(Convert.ToBase64String(buff));
}
private String CreateSalt(int size)
{
RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider();
byte[] buffer = new byte[size];
rng.GetBytes(buffer);
return(Convert.ToBase64String(buffer));
}
/// <summary>
/// Return random string by specific length.
/// </summary>
/// <param name="length">String length.</param>
/// <param name="NumbersOnly">Numbers only flag.</param>
/// <returns>String with specified length.</returns>
public static string RandomString(int length, bool NumbersOnly = false)
{
string allowedChars;
if (NumbersOnly)
{
allowedChars = "0123456789";
}
else
{
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 = allowedChars.ToCharArray();
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 System.Security.Cryptography.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 byte[] generateIV()
{
using (System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider())
{
byte[] nonce = new byte[16];
rng.GetBytes(nonce);
return(nonce);
}
}
public string GetSecretKey()
{
System.Security.Cryptography.RandomNumberGenerator cryptoRandomDataGenerator = new System.Security.Cryptography.RNGCryptoServiceProvider();
byte[] buffer = new byte[48];
cryptoRandomDataGenerator.GetBytes(buffer);
string secretkey = Convert.ToBase64String(buffer);
return(secretkey);
}
protected void GenerateRandomDataButton_Click(object sender, EventArgs e)
{
// Generate random 10 byte array.
var rnd = new System.Security.Cryptography.RNGCryptoServiceProvider();
var bytes = new System.Byte[10];
rnd.GetNonZeroBytes(bytes);
DataTextBox.Text = string.Join("", bytes.Select(x => x.ToString("X2")));
}
/****************************************************
* Util
****************************************************/
private static byte[] GetRandomData(int length)
{
using (var rngCsp = new System.Security.Cryptography.RNGCryptoServiceProvider())
{
var randomData = new byte[length];
rngCsp.GetBytes(randomData);
return(randomData);
}
}
private static string getPP()
{
var randomNumberGenerator = new System.Security.Cryptography.RNGCryptoServiceProvider();
var tokenData = new byte[32];
randomNumberGenerator.GetBytes(tokenData);
return(Convert.ToBase64String(tokenData.Concat(Guid.NewGuid().ToByteArray()).ToArray())
.Replace('/', '_')
.Replace('+', '-'));
}
private static Random GetRandom()
{
//产生随机数 参考代码：https://www.cnblogs.com/xiaowie/p/8759837.html
byte[] randomBytes = new byte[4];
System.Security.Cryptography.RNGCryptoServiceProvider rngServiceProivider = new System.Security.Cryptography.RNGCryptoServiceProvider();
rngServiceProivider.GetBytes(randomBytes);
int iSeed = BitConverter.ToInt32(randomBytes, 0);
return(new Random(iSeed));
}
