public static Task <byte[]> Get32()
{
return(Task.Run(() =>
{
var entropy = GetLongsForDigest();
var digest = ByteArrayHelpers.LongsToDigestBytes(entropy.ToArray());
return digest;
}));
}
protected override Task <byte[]> GetInternalEntropyAsync(EntropyPriority priority)
{
// This reads details of all processes running on the system, and uses them as inputs to a hash for final result.
// Often, different properties or processes will throw exceptions.
// Given this isn't trivial work, we run in a separate threadpool task.
return(Task.Run(() =>
{
Log.Trace("Beginning to gather entropy.");
var ps = Process.GetProcesses(); // TODO: assert we can do this during initialisation?
Log.Trace("Found {0:N0} processes.", ps.Length);
var processStats = new long[ps.Length * _ItemsPerProcess];
// Read details from all processes.
// PERF: This takes several seconds, which isn't helped by the fact a large number of these will throw exceptions when not running as admin.
for (int i = 0; i < ps.Length; i++)
{
var p = ps[i];
processStats[(i * _ItemsPerProcess) + 0] = p.TryAndIgnoreException(x => x.Id);
processStats[(i * _ItemsPerProcess) + 1] = p.TryAndIgnoreException(x => x.MainWindowHandle.ToInt64());
processStats[(i * _ItemsPerProcess) + 2] = p.TryAndIgnoreException(x => x.MaxWorkingSet.ToInt64());
processStats[(i * _ItemsPerProcess) + 3] = p.TryAndIgnoreException(x => x.NonpagedSystemMemorySize64);
processStats[(i * _ItemsPerProcess) + 4] = p.TryAndIgnoreException(x => x.PagedMemorySize64);
processStats[(i * _ItemsPerProcess) + 5] = p.TryAndIgnoreException(x => x.PagedSystemMemorySize64);
processStats[(i * _ItemsPerProcess) + 6] = p.TryAndIgnoreException(x => x.PeakPagedMemorySize64);
processStats[(i * _ItemsPerProcess) + 7] = p.TryAndIgnoreException(x => x.PeakVirtualMemorySize64);
processStats[(i * _ItemsPerProcess) + 8] = p.TryAndIgnoreException(x => x.PeakWorkingSet64);
processStats[(i * _ItemsPerProcess) + 9] = p.TryAndIgnoreException(x => x.PrivateMemorySize64);
processStats[(i * _ItemsPerProcess) + 10] = p.TryAndIgnoreException(x => x.WorkingSet64);
processStats[(i * _ItemsPerProcess) + 11] = p.TryAndIgnoreException(x => x.VirtualMemorySize64);
processStats[(i * _ItemsPerProcess) + 12] = p.TryAndIgnoreException(x => x.UserProcessorTime.Ticks);
processStats[(i * _ItemsPerProcess) + 13] = p.TryAndIgnoreException(x => x.TotalProcessorTime.Ticks);
processStats[(i * _ItemsPerProcess) + 14] = p.TryAndIgnoreException(x => x.PrivilegedProcessorTime.Ticks);
processStats[(i * _ItemsPerProcess) + 15] = p.TryAndIgnoreException(x => x.StartTime.Ticks);
processStats[(i * _ItemsPerProcess) + 16] = p.TryAndIgnoreException(x => x.HandleCount);
}
// Remove all zero items (to prevent silly things like a mostly, or all, zero hash result).
var processStatsNoZero = processStats.Where(x => x != 0L).ToArray();
Log.Trace("Read {0:N0} non-zero stat items.", processStatsNoZero.Length);
if (LogRawStats)
{
Log.Trace("Raw stats: ", processStatsNoZero.LongsToHexString());
}
// Shuffle the details, so there isn't a repetition of similar stats.
processStatsNoZero.ShuffleInPlace(_Rng);
// Get digests of the stats to return.
var result = ByteArrayHelpers.LongsToDigestBytes(processStatsNoZero, _ItemsPerResultChunk);
Log.Trace("Converted stats to {0:N0} bytes of entropy.", result.Length);
return result;
}));
}
protected override Task <byte[]> GetInternalEntropyAsync(EntropyPriority priority)
{
// This reads details of all network interfaces running on the system, and uses them as inputs to a hash for final result.
// Given this isn't trivial work, we run in a separate threadpool task.
return(Task.Run(() =>
{
Log.Trace("Beginning to gather entropy.");
var ins = NetworkInterface.GetAllNetworkInterfaces();
Log.Trace("Found {0:N0} interfaces.", ins.Length);
// First result includes IP address, hardware address, etc.
var allStats = new List <long>();
if (!_HasRunOnce)
{
Log.Trace("Including static properties on first run.");
allStats.AddRange(GetNetworkInterfaceStaticProperties(ins));
_HasRunOnce = true;
}
// After that, its just the number of packets, etc.
foreach (var i in ins)
{
// Most of these will be zero.
// Note that these can throw on some platforms, so we do a bunch of exception wrapping.
var stats = i.GetIPStatistics();
if (!_BytesReceivedFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.BytesReceived)), ref _BytesReceivedFailed);
}
if (!_BytesSentFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.BytesSent)), ref _BytesSentFailed);
}
if (!_IncomingPacketsDiscardedFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.IncomingPacketsDiscarded)), ref _IncomingPacketsDiscardedFailed);
}
if (!_IncomingPacketsWithErrorsFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.IncomingPacketsWithErrors)), ref _IncomingPacketsWithErrorsFailed);
}
if (!_IncomingUnknownProtocolPacketsFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.IncomingUnknownProtocolPackets)), ref _IncomingUnknownProtocolPacketsFailed);
}
if (!_NonUnicastPacketsReceivedFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.NonUnicastPacketsReceived)), ref _NonUnicastPacketsReceivedFailed);
}
if (!_NonUnicastPacketsSentFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.NonUnicastPacketsSent)), ref _NonUnicastPacketsSentFailed);
}
if (!_OutgoingPacketsDiscardedFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.OutgoingPacketsDiscarded)), ref _OutgoingPacketsDiscardedFailed);
}
if (!_OutgoingPacketsWithErrorsFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.OutgoingPacketsWithErrors)), ref _OutgoingPacketsWithErrorsFailed);
}
if (!_OutputQueueLengthFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.OutputQueueLength)), ref _OutputQueueLengthFailed);
}
if (!_UnicastPacketsReceivedFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.UnicastPacketsReceived)), ref _UnicastPacketsReceivedFailed);
}
if (!_UnicastPacketsSentFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() => allStats.Add(stats.UnicastPacketsSent)), ref _UnicastPacketsSentFailed);
}
// Remaining lease duration.
if (!_AddressValidLifetimeFailed)
{
ExceptionHelper.TryAndIgnoreException(() => Uh.ToUnit(() =>
{
var props = i.GetIPProperties();
allStats.AddRange(props.UnicastAddresses.Select(x => x.AddressValidLifetime));
}), ref _AddressValidLifetimeFailed);
}
}
// Remove zeros and shuffle to prevent obvious correlations.
var statsNoZero = allStats.Where(x => x != 0L).ToArray();
Log.Trace("Read {0:N0} non-zero stat items.", statsNoZero.Length);
if (LogRawStats)
{
Log.Trace("Raw stats: ", statsNoZero.LongsToHexString());
}
// Shuffle the details, so there isn't a repetition of similar stats.
statsNoZero.ShuffleInPlace(_Rng);
// Convert to digest byte array to return.
var result = ByteArrayHelpers.LongsToDigestBytes(statsNoZero, _ItemsPerResultChunk);
Log.Trace("Converted stats to {0:N0} bytes of entropy.", result.Length);
return result;
}));
}