| public abstract GetBytes ( byte data ) : void | ||
| data | byte | |
| return | void | |
public void fill(byte[] foo, int start, int len)
{
while (len > tmp.Length)
{
rng.GetBytes(tmp);
Array.Copy(tmp, 0, foo, start, tmp.Length);
len -= tmp.Length;
start += tmp.Length;
}
rng.GetBytes(tmp);
Array.Copy(tmp, 0, foo, start, len);
}
public static byte[] Generate(int length)
{
if (length < 1)
{
throw new ArgumentOutOfRangeException("length");
}
var bytes = new byte[length];
_random.GetBytes(bytes);
return(bytes);
}
/// <summary>
/// Generate a random IV.
/// </summary>
/// <returns></returns>
private static byte[] IV()
{
byte[] data = new byte[IV_SIZE];
System.Security.Cryptography.RandomNumberGenerator rnd = System.Security.Cryptography.RandomNumberGenerator.Create();
rnd.GetBytes(data);
return(data);
}
public static string CreateHash(string password)
{
// Generate a random salt
byte[] salt = new byte[SALT_BYTES];
try {
using (System.Security.Cryptography.RandomNumberGenerator csprng = System.Security.Cryptography.RandomNumberGenerator.Create()) {
csprng.GetBytes(salt);
}
} catch (CryptographicException ex) {
throw new CannotPerformOperationException(
"Random number generator not available.",
ex
);
} catch (ArgumentNullException ex) {
throw new CannotPerformOperationException(
"Invalid argument given to random number generator.",
ex
);
}
byte[] hash = PBKDF2(password, salt, PBKDF2_ITERATIONS, HASH_BYTES);
// format: algorithm:iterations:hashSize:salt:hash
String parts = "sha1:" +
PBKDF2_ITERATIONS +
":" +
hash.Length +
":" +
Convert.ToBase64String(salt) +
":" +
Convert.ToBase64String(hash);
return(parts);
}
double NextDouble()
{
rand.GetBytes(random);
rng_ = BitConverter.ToUInt32(random, 0);
return((rng_ - min_) / (max_ - min_ + 1));
}
private static int GenerateRandomInt32Value(RandomNumberGenerator randomNumberGenerator)
{
var fourRandomBytes = new byte[4]; // 4 bytes = 32 bits = Int32
randomNumberGenerator.GetBytes(fourRandomBytes);
var randomInt32Value = BitConverter.ToInt32(fourRandomBytes, 0);
return randomInt32Value;
}
/**
* Return a random AHAddress initialized from the given rng
*/
public AHAddress(RandomNumberGenerator rng)
{
byte[] buffer = new byte[MemSize];
rng.GetBytes(buffer);
SetClass(buffer, this.Class);
_buffer = MemBlock.Reference(buffer, 0, MemSize);
_prefix = (uint)NumberSerializer.ReadInt(_buffer, 0);
}
public string CreateSalt()
{
using (_generator = _generatorInitializer())
{
var byteArr = new byte[32];
_generator.GetBytes(byteArr);
return Convert.ToBase64String(byteArr);
}
}
/// <summary>
/// Generate cryptographically random key of given bit size.
/// </summary>
/// <param name="size">The size.</param>
/// <returns> the key </returns>
private static string GenerateRandomKey(int size)
{
byte[] key = new byte[(int)size / 8];
#if FullNetFx
RNGCryptoServiceProvider crypto = new RNGCryptoServiceProvider();
#else
System.Security.Cryptography.RandomNumberGenerator crypto = System.Security.Cryptography.RandomNumberGenerator.Create();
#endif
crypto.GetBytes(key);
return(Convert.ToBase64String(key));
}
internal static string Create (RandomNumberGenerator rng)
{
if (rng == null)
throw new ArgumentNullException ("rng");
byte[] key = new byte [half_len];
lock (rng) {
rng.GetBytes (key);
}
return Encode (key);
}
public static bool IsProbablePrime(this BigInteger source, int certainty, RandomNumberGenerator random)
{
if (source == 2 || source == 3)
return true;
if (source < 2 || source % 2 == 0)
return false;
BigInteger d = source - 1;
int s = 0;
while (d % 2 == 0)
{
d /= 2;
s += 1;
}
if (random == null)
{
random = Randomizer.GetRandom();
}
byte[] bytes = new byte[(source.BitLength() + 7) / 8];
BigInteger a;
for (int i = 0; i < certainty; i++)
{
do
{
random.GetBytes(bytes);
//bytes[bytes.Length - 1] = 0;
a = new BigInteger(bytes);
}
while (a < 2 || a >= source - 2);
BigInteger x = BigInteger.ModPow(a, d, source);
if (x == 1 || x == source - 1)
continue;
for (int r = 1; r < s; r++)
{
x = BigInteger.ModPow(x, 2, source);
if (x == 1)
return false;
if (x == source - 1)
break;
}
if (x != source - 1)
return false;
}
return true;
}
/// <summary>
/// Gets the next available random integer using a Pseudo<see cref="RandomNumberGenerator"/> to generate random bytes
/// </summary>
/// <returns></returns>
public static int GetPrngInt()
{
byte[] buffer = new byte[System.Runtime.InteropServices.Marshal.SizeOf(typeof(int))];
byte[] buffer2 = new byte[buffer.Length];
prng.GetNonZeroBytes(buffer);
prng.GetBytes(buffer2);
for (int i = 0; i < buffer.Length; i++)
{
buffer[i] ^= buffer2[(buffer.Length - 1) - i];
}
return(System.BitConverter.ToInt32(buffer, 0));
}
private static int Random(byte[] fourBytes, RandomNumberGenerator rng, int min, int max) {
if (null == rng) throw new ArgumentNullException("rng");
var scale = uint.MaxValue;
while (scale == uint.MaxValue) {
// Get four random bytes.
rng.GetBytes(fourBytes);
// Convert that into an uint.
scale = BitConverter.ToUInt32(fourBytes, 0);
}
// Add min to the scaled difference between max and min.
return (int)(min + (max - min) * (scale / (double)uint.MaxValue));
}
public static BigInteger GeneratePseudoPrime(int bitLength, int certainty, RandomNumberGenerator random)
{
byte[] bytes = new byte[(bitLength + 7) / 8];
BigInteger result = 0;
do
{
random.GetBytes(bytes);
bytes[bytes.Length - 1] = 0;
result = new BigInteger(bytes);
}
while (result.IsProbablePrime(certainty, random));
return result;
}
private static byte[] HashPasswordV3(string password, RandomNumberGenerator rng, KeyDerivationPrf prf, int iterCount, int saltSize, int numBytesRequested) {
// Produce a version 3 (see comment above) text hash.
byte[] salt = new byte[saltSize];
rng.GetBytes(salt);
byte[] subkey = KeyDerivation.Pbkdf2(password, salt, prf, iterCount, numBytesRequested);
var outputBytes = new byte[13 + salt.Length + subkey.Length];
outputBytes[0] = 0x01; // format marker
WriteNetworkByteOrder(outputBytes, 1, (uint)prf);
WriteNetworkByteOrder(outputBytes, 5, (uint)iterCount);
WriteNetworkByteOrder(outputBytes, 9, (uint)saltSize);
Buffer.BlockCopy(salt, 0, outputBytes, 13, salt.Length);
Buffer.BlockCopy(subkey, 0, outputBytes, 13 + saltSize, subkey.Length);
return outputBytes;
}
private void btnselnumberchars_Click(object sender, EventArgs e)
{
R randgen = R.Create();
byte[] rand = new byte[10];
randgen.GetBytes(rand);
// Random Number between 0 - 255 --- we need between 0 - chars2generate
int startselection = (int)Math.Floor(rand[2] * (rtbseedgen.TextLength - cbbNumChars.SelectedIndex + 1) / 255.0);
if (startselection < 0)
{
startselection = 0;
}
rtbseedgen.Select(startselection, cbbNumChars.SelectedIndex + 1);
rtbseedgen.Focus();
}
public static string StrRandomNumber(int length)
{
System.Security.Cryptography.RandomNumberGenerator rng = System.Security.Cryptography.RandomNumberGenerator.Create();
byte[] buffer1 = new byte[length];
rng.GetBytes(buffer1);
rng = null;
string str = "0123456789";
StringBuilder s = new StringBuilder();
for (int i = 0; i < length; i++)
{
Random rnd = new Random(buffer1[i]);
int w = rnd.Next(0, str.Length);
s.Append(str.Substring(w, 1));
}
return(s.ToString());
}
/// <summary>Creates a new SymmetricEncryption handler for the passed in
/// SymmetricAlgorithm.</summary>
public SymmetricEncryption(SymmetricAlgorithm Algorithm)
{
if(Algorithm.Mode != CipherMode.CBC) {
throw new Exception("SymmetricEncryption requires the symmetric algorithm to use CBC.");
}
rng = new RNGCryptoServiceProvider();
_sa = Algorithm;
// We take care of PKCS7 padding here due to issues in the underlying implementations...
_sa.Padding = PaddingMode.None;
BlockSizeByte = _sa.BlockSize / 8;
// Match the same size as our Window size...
_decryptors = new Cache(64);
_enc_iv = new byte[BlockSizeByte];
rng.GetBytes(_enc_iv);
_enc = _sa.CreateEncryptor(_sa.Key, _enc_iv);
_temp = new byte[BlockSizeByte];
}
/// <summary>
/// Initializes a new instance of the <see cref="OneTimeToken"/> class.
/// Creates a new token for Verification
/// </summary>
/// <param name="key">The key.</param>
/// <exception cref="System.ArgumentNullException"></exception>
public OneTimeToken(byte[] key)
{
if (key != null || key.Length <= 0)
{
_hmacSha = new HMACSHA256(key);
TokenStamp = new byte[128];
_rng = System.Security.Cryptography.RandomNumberGenerator.Create();
_rng.GetBytes(TokenStamp);
_issueTime = DateTimeOffset.UtcNow;
}
else
{
throw new ArgumentNullException(nameof(key));
}
}
internal static BigInteger NextBigInteger(this System.Security.Cryptography.RandomNumberGenerator rng, int sizeInBits)
{
if (sizeInBits < 0)
{
throw new ArgumentException("sizeInBits must be non-negative");
}
if (sizeInBits == 0)
{
return(0);
}
byte[] b = new byte[sizeInBits / 8 + 1];
rng.GetBytes(b);
if (sizeInBits % 8 == 0)
{
b[b.Length - 1] = 0;
}
else
{
b[b.Length - 1] &= (byte)((1 << sizeInBits % 8) - 1);
}
return(new BigInteger(b));
}
void RandomExample()
{
{
Random rng = new Random();
Console.WriteLine(rng.Next().ToString());
Console.WriteLine(rng.Next().ToString());
Console.WriteLine(rng.Next().ToString());
}
Console.WriteLine();
for (int i = 0; i < 2; i++)
{
Random rngSeed = new Random(1); // Pro = reproducablility
Console.WriteLine(rngSeed.Next().ToString());
Console.WriteLine(rngSeed.Next().ToString());
Console.WriteLine("-");
}
Console.WriteLine();
for (int i = 0; i < 100; i++)
{ // Approx 10 ms between need Random seeds
Console.WriteLine(new Random().Next().ToString());
}
Console.WriteLine();
System.Security.Cryptography.RandomNumberGenerator rngPlusPlus
= System.Security.Cryptography.RandomNumberGenerator.Create();
byte[] randomData = new byte[4];
Console.WriteLine(randomData[0]);
rngPlusPlus.GetBytes(randomData);
Console.WriteLine(randomData[0]);
}
public override void GetBytes(byte[] data) => _impl.GetBytes(data);
// PKCS #1 v.2.1, Section 7.1.1
// RSAES-OAEP-ENCRYPT ((n, e), M, L)
public static byte[] Encrypt_OAEP (RSA rsa, HashAlgorithm hash, RandomNumberGenerator rng, byte[] M)
{
int size = rsa.KeySize / 8;
int hLen = hash.HashSize / 8;
if (M.Length > size - 2 * hLen - 2)
throw new CryptographicException ("message too long");
// empty label L SHA1 hash
byte[] lHash = GetEmptyHash (hash);
int PSLength = (size - M.Length - 2 * hLen - 2);
// DB = lHash || PS || 0x01 || M
byte[] DB = new byte [lHash.Length + PSLength + 1 + M.Length];
Buffer.BlockCopy (lHash, 0, DB, 0, lHash.Length);
DB [(lHash.Length + PSLength)] = 0x01;
Buffer.BlockCopy (M, 0, DB, (DB.Length - M.Length), M.Length);
byte[] seed = new byte [hLen];
rng.GetBytes (seed);
byte[] dbMask = MGF1 (hash, seed, size - hLen - 1);
byte[] maskedDB = xor (DB, dbMask);
byte[] seedMask = MGF1 (hash, maskedDB, hLen);
byte[] maskedSeed = xor (seed, seedMask);
// EM = 0x00 || maskedSeed || maskedDB
byte[] EM = new byte [maskedSeed.Length + maskedDB.Length + 1];
Buffer.BlockCopy (maskedSeed, 0, EM, 1, maskedSeed.Length);
Buffer.BlockCopy (maskedDB, 0, EM, maskedSeed.Length + 1, maskedDB.Length);
byte[] m = OS2IP (EM);
byte[] c = RSAEP (rsa, m);
return I2OSP (c, size);
}
public static void GetBytes(byte[] bytes)
{
LocalRandomNumberGenerator.GetBytes(bytes);
}
/// <include file='doc\RSAOAEPKeyExchangeFormatter.uex' path='docs/doc[@for="RSAOAEPKeyExchangeFormatter.CreateKeyExchange"]/*' />
public override byte[] CreateKeyExchange(byte[] rgbData)
{
byte[] rgbKeyEx;
if (_rsaKey is RSACryptoServiceProvider)
{
rgbKeyEx = ((RSACryptoServiceProvider)_rsaKey).Encrypt(rgbData, true);
}
else
{
int cb = _rsaKey.KeySize / 8;
int cbHash;
HashAlgorithm hash;
int i;
MaskGenerationMethod mgf;
byte[] rgbDB;
byte[] rgbIn;
byte[] rgbMask;
byte[] rgbSeed;
// Create the OAEP padding object.
// 1. Hash the parameters to get rgbPHash
hash = (HashAlgorithm)CryptoConfig.CreateFromName("SHA1"); // Create the default SHA1 object
cbHash = hash.HashSize / 8;
if ((rgbData.Length + 2 + 2 * cbHash) > cb)
{
throw new CryptographicException(String.Format(Environment.GetResourceString("Cryptography_Padding_EncDataTooBig"), cb - 2 - 2 * cbHash));
}
hash.ComputeHash(new byte[0]); // Use an empty octet string
// 2. Create DB object
rgbDB = new byte[cb - cbHash - 1];
// Structure is as follows:
// pHash || PS || 01 || M
// PS consists of all zeros
Buffer.InternalBlockCopy(hash.Hash, 0, rgbDB, 0, cbHash);
rgbDB[rgbDB.Length - rgbData.Length - 1] = 1;
Buffer.InternalBlockCopy(rgbData, 0, rgbDB, rgbDB.Length - rgbData.Length, rgbData.Length);
// 3. Create a random value of size hLen
if (RngValue == null)
{
RngValue = RandomNumberGenerator.Create();
}
rgbSeed = new byte[cbHash];
RngValue.GetBytes(rgbSeed);
// 4. Compute the mask value
mgf = new PKCS1MaskGenerationMethod();
rgbMask = mgf.GenerateMask(rgbSeed, rgbDB.Length);
// 5. Xor rgbMaskDB into rgbDB
for (i = 0; i < rgbDB.Length; i++)
{
rgbDB[i] = (byte)(rgbDB[i] ^ rgbMask[i]);
}
// 6. Compute seed mask value
rgbMask = mgf.GenerateMask(rgbDB, cbHash);
// 7. Xor rgbMask into rgbSeed
for (i = 0; i < rgbSeed.Length; i++)
{
rgbSeed[i] ^= rgbMask[i];
}
// 8. Concatenate rgbSeed and rgbDB to form value to encrypt
rgbIn = new byte[cb];
Buffer.InternalBlockCopy(rgbSeed, 0, rgbIn, 1, rgbSeed.Length);
Buffer.InternalBlockCopy(rgbDB, 0, rgbIn, rgbSeed.Length + 1, rgbDB.Length);
// 9. Now Encrypt it
rgbKeyEx = _rsaKey.EncryptValue(rgbIn);
}
return(rgbKeyEx);
}
/// <inheritdoc/>
public override void GetBytes(byte[] buffer)
{
RandomSource.GetBytes(buffer);
}
// The 'Number' base class has a static method 'Random' which only requires
// a 'numBits' argument (the random number generator is given as a private
// field of the class). Therefore, the following static method (which
// requires two arguments) is not seen as an override. Hence no 'new' keyword.
public static Number Random(int numBits, Random rnd)
{
// working out required number of bytes
// 0 bit -> 0 byte
// 1 bit -> 1 byte
// ...
// 8 bits -> 1 byte
// 9 bits -> 2 bytes
// ...
int len = (numBits + 7) / 8;
if(len == 0) return Number2.ZERO;
byte[] bytes = new byte[len];
rnd.GetBytes(bytes); // random number generation
// we may have generated too many bits. The leading bits of our big-endian
// representation needs to be set to 0 so as to reflect numBits exactly.
int diff = len * 8 - numBits; // number of leading bits set to 0
int mask = 0x7f; // 0111 1111 in binary
// we want to regard out 'bytes' array as a big-endian representation,
// so the leading byte is bytes[0], which is the one needing adjustment
while(diff > 0)
{
bytes[0] = (byte) (bytes[0] & mask); // setting leading byte to 0
mask = mask >> 1;
--diff;
}
return Number2.FromBytes(1, bytes);
}
internal static byte[] RsaOaepEncrypt(RSA rsa, HashAlgorithm hash, PKCS1MaskGenerationMethod mgf, RandomNumberGenerator rng, byte[] data)
{
int num = rsa.KeySize / 8;
int byteCount = hash.HashSize / 8;
if (((data.Length + 2) + (2 * byteCount)) > num)
{
throw new CryptographicException(string.Format(null, Environment.GetResourceString("Cryptography_Padding_EncDataTooBig"), new object[] { (num - 2) - (2 * byteCount) }));
}
hash.ComputeHash(new byte[0]);
byte[] dst = new byte[num - byteCount];
Buffer.InternalBlockCopy(hash.Hash, 0, dst, 0, byteCount);
dst[(dst.Length - data.Length) - 1] = 1;
Buffer.InternalBlockCopy(data, 0, dst, dst.Length - data.Length, data.Length);
byte[] buffer2 = new byte[byteCount];
rng.GetBytes(buffer2);
byte[] buffer3 = mgf.GenerateMask(buffer2, dst.Length);
for (int i = 0; i < dst.Length; i++)
{
dst[i] = (byte) (dst[i] ^ buffer3[i]);
}
buffer3 = mgf.GenerateMask(dst, byteCount);
for (int j = 0; j < buffer2.Length; j++)
{
buffer2[j] = (byte) (buffer2[j] ^ buffer3[j]);
}
byte[] buffer4 = new byte[num];
Buffer.InternalBlockCopy(buffer2, 0, buffer4, 0, buffer2.Length);
Buffer.InternalBlockCopy(dst, 0, buffer4, buffer2.Length, dst.Length);
return rsa.EncryptValue(buffer4);
}
[System.Security.SecurityCritical] // auto-generated
internal static byte[] RsaOaepEncrypt (RSA rsa, HashAlgorithm hash, PKCS1MaskGenerationMethod mgf, RandomNumberGenerator rng, byte[] data) {
int cb = rsa.KeySize / 8;
// 1. Hash the parameters to get PHash
int cbHash = hash.HashSize / 8;
if ((data.Length + 2 + 2*cbHash) > cb)
throw new CryptographicException(String.Format(null, Environment.GetResourceString("Cryptography_Padding_EncDataTooBig"), cb-2-2*cbHash));
hash.ComputeHash(EmptyArray<Byte>.Value); // Use an empty octet string
// 2. Create DB object
byte[] DB = new byte[cb - cbHash];
// Structure is as follows:
// pHash || PS || 01 || M
// PS consists of all zeros
Buffer.InternalBlockCopy(hash.Hash, 0, DB, 0, cbHash);
DB[DB.Length - data.Length - 1] = 1;
Buffer.InternalBlockCopy(data, 0, DB, DB.Length-data.Length, data.Length);
// 3. Create a random value of size hLen
byte[] seed = new byte[cbHash];
rng.GetBytes(seed);
// 4. Compute the mask value
byte[] mask = mgf.GenerateMask(seed, DB.Length);
// 5. Xor maskDB into DB
for (int i=0; i < DB.Length; i++) {
DB[i] = (byte) (DB[i] ^ mask[i]);
}
// 6. Compute seed mask value
mask = mgf.GenerateMask(DB, cbHash);
// 7. Xor mask into seed
for (int i=0; i < seed.Length; i++) {
seed[i] ^= mask[i];
}
// 8. Concatenate seed and DB to form value to encrypt
byte[] pad = new byte[cb];
Buffer.InternalBlockCopy(seed, 0, pad, 0, seed.Length);
Buffer.InternalBlockCopy(DB, 0, pad, seed.Length, DB.Length);
return rsa.EncryptValue(pad);
}
public sealed override void GenerateKey()
{
Key = RandomNumberGenerator.GetBytes(KeySize / BitsPerByte);
}
// Encrypt a value using a specified OAEP padding array.
// The array may be null to pad with zeroes.
internal byte[] EncryptOAEP(byte[] rgb, byte[] padding,
RandomNumberGenerator rng)
{
// Check the data against null.
if(rgb == null)
{
throw new ArgumentNullException("rgb");
}
// Make sure that we have sufficient RSA parameters.
if(rsaParams.Modulus == null)
{
throw new CryptographicException
(_("Crypto_RSAParamsNotSet"));
}
// Format the label, padding string, and rgb into a message.
int k = rsaParams.Modulus.Length;
if(rgb.Length > (k - 2 * 20 - 2))
{
throw new CryptographicException
(_("Crypto_RSAMessageTooLong"));
}
byte[] msg = new byte [k - 20 - 1];
int posn = 0;
Array.Copy(label, 0, msg, posn, 20);
posn += 20;
int padlen = k - rgb.Length - 2 * 20 - 2;
if(padlen > 0 && padding != null)
{
if(padding.Length <= padlen)
{
Array.Copy(padding, 0, msg, posn, padding.Length);
}
else
{
Array.Copy(padding, 0, msg, posn, padlen);
}
}
posn += padlen;
msg[posn++] = (byte)0x01;
Array.Copy(rgb, 0, msg, posn, rgb.Length);
// Acquire a mask generation method, based on SHA-1.
MaskGenerationMethod maskGen = new PKCS1MaskGenerationMethod();
// Generate a random seed to use to generate masks.
byte[] seed = new byte [20];
rng.GetBytes(seed);
// Generate a mask and encrypt the above message.
byte[] mask = maskGen.GenerateMask(seed, msg.Length);
int index;
for(index = 0; index < msg.Length; ++index)
{
msg[index] ^= mask[index];
}
// Generate another mask and encrypt the seed.
byte[] seedMask = maskGen.GenerateMask(msg, 20);
for(index = 0; index < 20; ++index)
{
seed[index] ^= seedMask[index];
}
// Build the value to be encrypted using RSA.
byte[] value = new byte [k];
Array.Copy(seed, 0, value, 1, 20);
Array.Copy(msg, 0, value, 21, msg.Length);
// Encrypt the value.
byte[] encrypted = ApplyPublic(value);
// Destroy sensitive data.
Array.Clear(msg, 0, msg.Length);
Array.Clear(seed, 0, seed.Length);
Array.Clear(mask, 0, mask.Length);
Array.Clear(seedMask, 0, seedMask.Length);
Array.Clear(value, 0, value.Length);
// Done.
return encrypted;
}
public override void GenerateIV()
{
IVValue = RandomNumberGenerator.GetBytes(8);
}
/// <summary>
/// Generate a salt for use with the BCrypt.HashPassword() method.
/// </summary>
/// <param name="logRounds">The log2 of the number of rounds of
/// hashing to apply. The work factor therefore increases as (2 **
/// logRounds).</param>
/// <param name="random">An instance of RandomNumberGenerator to use.</param>
/// <returns>An encoded salt value.</returns>
public static string GenerateSalt(int logRounds, RandomNumberGenerator random)
{
byte[] randomBytes = new byte[BCRYPT_SALT_LEN];
random.GetBytes(randomBytes);
StringBuilder rs = new StringBuilder((randomBytes.Length * 2) + 8);
rs.Append("$2a$");
if (logRounds < 10)
{
rs.Append('0');
}
rs.Append(logRounds);
rs.Append('$');
rs.Append(EncodeBase64(randomBytes, randomBytes.Length));
return rs.ToString();
}
public static uint RandomUInt32(this RandomNumberGenerator random)
{
byte[] buffer = new byte[4];
random.GetBytes(buffer);
return(BitConverter.ToUInt32(buffer, 0));
}
internal static string GenerateToken(RandomNumberGenerator generator)
{
var data = new byte[0x10];
generator.GetBytes(data);
return HttpServerUtility.UrlTokenEncode(data);
}
/// <summary>
/// When one Adds a key to a binomial sketch, a random bit among the subset of k that are currently 0 (false)
/// will be set to 1 (true).
/// To ensure roughly half the bits remain zero at all times, a random index from the subset of all k bits that
/// are currently 1 (true) will be set to 0 (false).
/// </summary>
/// <param name="key">The key to add to the set.</param>
/// <param name="rng">Optionally passing a RandomNumberGenerator should improve performance as it will
/// save the Observe operation from having to create one. (RandomNumberGenerators are not thread safe, and
/// should not be used between Tasks/Threads.)</param>
/// <returns>Of the bits at the indices for the given key, the number of bits that were set to 1 (true)
/// before the Observe operation. The maximum possible value to be returned, if all bits were already
/// set to 1 (true) would be NumberOfIndexes. If a key has not been seen before, the expected (average)
/// result is NumberOfIndexes/2, but will vary with the binomial distribution.</returns>
public int Observe(string key, RandomNumberGenerator rng = null)
{
// Get a list of indexes that are not yet set
List<int> indexesUnset = GetUnsetIndexesForKey(key).ToList();
// We can only update state to record the observation if there is an unset (0) index that we can set (to 1).
if (indexesUnset.Count > 0)
{
NumberOfObservations++;
// Create a random number generator if one was not provided by the caller.
rng = rng ?? RandomNumberGenerator.Create();
// We'll need the randomness to determine which bit to set and which to clear
byte[] randBytes = new byte[8];
rng.GetBytes(randBytes);
// First, pick a random index to set by appling the last of the universal hash functions
// to the random bytes
int indexToSet =
indexesUnset[ (int) ( _universalHashFunctions[_universalHashFunctions.Length - 1].Hash(randBytes) %
(uint) indexesUnset.Count ) ];
// Next, pick the index to clear by applying hash functions to the random bytes until we reach
// an index that is set. (For any reasonable sized number of indexes (e.g., >= 30), the probability
// that we would reach the last hash function used earlier, or run out of hash functions, is so small
// as to be something we can ignore.)
int indexToClear = 0;
foreach (var hashFunction in _universalHashFunctions)
{
indexToClear = (int) ( hashFunction.Hash(randBytes) % (uint) SizeInBits);
if (_sketch[indexToClear])
// We break when we've found an index to a bit that is set and so can be cleared to 0/false.
break;
}
_sketch[indexToClear] = false;
_sketch[indexToSet] = true;
}
// The number of bits set to 1/true is the number that were not 0/false.
return NumberOfIndexes - indexesUnset.Count;
}
public static ulong RandomUInt64(this RandomNumberGenerator random)
{
byte[] buffer = new byte[8];
random.GetBytes(buffer);
return(BitConverter.ToUInt64(buffer, 0));
}
public HMACSHA512()
: this(RandomNumberGenerator.GetBytes(BlockSize))
{
}
private static byte[] GetRandomBytes(RandomNumberGenerator rng, int byteCount)
{
byte[] bytes = new byte[byteCount];
rng.GetBytes(bytes);
return bytes;
}
internal static string GenerateToken(RandomNumberGenerator generator)
{
byte[] tokenBytes = new byte[TokenSizeInBytes];
generator.GetBytes(tokenBytes);
return HttpServerUtility.UrlTokenEncode(tokenBytes);
}
public BigInt GenPriv(RandomNumberGenerator rng)
{
EllipticCurve.BigInt priv = null;
do
{
if (priv != null)
priv.Clear();
var bytes = new byte[curveByteLen];
rng.GetBytes(bytes);
var byteMask = (1 << (curveLen & 7)) - 1;
if (byteMask != 0)
bytes[0] &= (byte)byteMask;
priv = new EllipticCurve.BigInt(bytes, 0, bytes.Length);
Utils.ClearArray(bytes);
} while (priv >= p || priv.IsZero());
return priv;
}
public override void GenerateIV()
{
IV = RandomNumberGenerator.GetBytes(BlockSize / BitsPerByte);
}
// Generates a new 80-bit security token
public static byte[] GenerateRandomKey()
{
byte[] bytes = new byte[20];
_rng.GetBytes(bytes);
return(bytes);
}
/// <summary>
/// Randomizes the bits in "this" from the specified RNG.
/// </summary>
/// <param name="rng">A RNG.</param>
public void Randomize(RandomNumberGenerator rng)
{
if (this == 0)
return;
int bits = BitCount();
int dwords = bits >> 5;
int remBits = bits & 0x1F;
if (remBits != 0)
dwords++;
var random = new byte[dwords << 2];
rng.GetBytes(random);
Buffer.BlockCopy(random, 0, data, 0, dwords << 2);
if (remBits != 0)
{
var mask = (uint)(0x01 << (remBits - 1));
data[dwords - 1] |= mask;
mask = 0xFFFFFFFF >> (32 - remBits);
data[dwords - 1] &= mask;
}
else
data[dwords - 1] |= 0x80000000;
Normalize();
}
/// <summary>
/// Generates a new, random BigInteger of the specified length.
/// </summary>
/// <param name="bits">The number of bits for the new number.</param>
/// <param name="rng">A random number generator to use to obtain the bits.</param>
/// <returns>A random number of the specified length.</returns>
public static BigInteger GenerateRandom(int bits, RandomNumberGenerator rng)
{
int dwords = bits >> 5;
int remBits = bits & 0x1F;
if (remBits != 0)
dwords++;
var ret = new BigInteger(Sign.Positive, (uint)dwords + 1);
var random = new byte[dwords << 2];
rng.GetBytes(random);
Buffer.BlockCopy(random, 0, ret.data, 0, dwords << 2);
if (remBits != 0)
{
var mask = (uint)(0x01 << (remBits - 1));
ret.data[dwords - 1] |= mask;
mask = 0xFFFFFFFF >> (32 - remBits);
ret.data[dwords - 1] &= mask;
}
else
ret.data[dwords - 1] |= 0x80000000;
ret.Normalize();
return ret;
}
// Encrypt a value using a specified OAEP padding array.
// The array may be null to pad with zeroes.
internal byte[] EncryptOAEP(byte[] rgb, byte[] padding,
RandomNumberGenerator rng)
{
// Check the data against null.
if (rgb == null)
{
throw new ArgumentNullException("rgb");
}
// Make sure that we have sufficient RSA parameters.
if (rsaParams.Modulus == null)
{
throw new CryptographicException
(_("Crypto_RSAParamsNotSet"));
}
// Format the label, padding string, and rgb into a message.
int k = rsaParams.Modulus.Length;
if (rgb.Length > (k - 2 * 20 - 2))
{
throw new CryptographicException
(_("Crypto_RSAMessageTooLong"));
}
byte[] msg = new byte [k - 20 - 1];
int posn = 0;
Array.Copy(label, 0, msg, posn, 20);
posn += 20;
int padlen = k - rgb.Length - 2 * 20 - 2;
if (padlen > 0 && padding != null)
{
if (padding.Length <= padlen)
{
Array.Copy(padding, 0, msg, posn, padding.Length);
}
else
{
Array.Copy(padding, 0, msg, posn, padlen);
}
}
posn += padlen;
msg[posn++] = (byte)0x01;
Array.Copy(rgb, 0, msg, posn, rgb.Length);
// Acquire a mask generation method, based on SHA-1.
MaskGenerationMethod maskGen = new PKCS1MaskGenerationMethod();
// Generate a random seed to use to generate masks.
byte[] seed = new byte [20];
rng.GetBytes(seed);
// Generate a mask and encrypt the above message.
byte[] mask = maskGen.GenerateMask(seed, msg.Length);
int index;
for (index = 0; index < msg.Length; ++index)
{
msg[index] ^= mask[index];
}
// Generate another mask and encrypt the seed.
byte[] seedMask = maskGen.GenerateMask(msg, 20);
for (index = 0; index < 20; ++index)
{
seed[index] ^= seedMask[index];
}
// Build the value to be encrypted using RSA.
byte[] value = new byte [k];
Array.Copy(seed, 0, value, 1, 20);
Array.Copy(msg, 0, value, 21, msg.Length);
// Encrypt the value.
byte[] encrypted = ApplyPublic(value);
// Destroy sensitive data.
Array.Clear(msg, 0, msg.Length);
Array.Clear(seed, 0, seed.Length);
Array.Clear(mask, 0, mask.Length);
Array.Clear(seedMask, 0, seedMask.Length);
Array.Clear(value, 0, value.Length);
// Done.
return(encrypted);
}
/**
* Return a random AHAddress initialized from the given rng
*/
public AHAddress(RandomNumberGenerator rng)
{
byte[] buffer = new byte[MemSize];
rng.GetBytes(buffer);
SetClass(buffer, this.Class);
_buffer = MemBlock.Reference(buffer, 0, MemSize);
}