protected HashesTestBase() { m_creators = new List <Func <object> > { () => { return(m_random.NextByte()); }, () => { return(m_random.NextChar()); }, () => { return(m_random.NextShort()); }, () => { return(m_random.NextUShort()); }, () => { return(m_random.NextInt()); }, () => { return(m_random.NextUInt()); }, () => { return(m_random.NextLong()); }, () => { return(m_random.NextULong()); }, () => { return(m_random.NextFloatFull()); }, () => { return(m_random.NextDoubleFull()); }, () => { return(m_random.NextString(m_random.Next(0, 200))); }, () => { return(m_random.NextBytes(m_random.Next(0, 200))); }, () => { return(m_random.NextChars(m_random.Next(0, 200))); }, () => { return(m_random.NextShorts(m_random.Next(0, 200))); }, () => { return(m_random.NextUShorts(m_random.Next(0, 200))); }, () => { return(m_random.NextInts(m_random.Next(0, 200))); }, () => { return(m_random.NextUInts(m_random.Next(0, 200))); }, () => { return(m_random.NextLongs(m_random.Next(0, 200))); }, () => { return(m_random.NextULongs(m_random.Next(0, 200))); }, () => { return(m_random.NextFloatsFull(m_random.Next(0, 200))); }, () => { return(m_random.NextDoublesFull(m_random.Next(0, 200))); }, }.AsReadOnly(); }
private void Test(IHMAC a_base_hmac, IHMAC a_hmac) { Assert.AreEqual(a_base_hmac.HashSize, a_hmac.HashSize); Assert.AreEqual(a_base_hmac.BlockSize, a_hmac.BlockSize); List <int> keys_length = new List <int>() { 0, 1, 7, 51, 121, 512, 1023 }; keys_length.Add(a_hmac.BlockSize - 1); keys_length.Add(a_hmac.BlockSize); keys_length.Add(a_hmac.BlockSize + 1); List <int> msgs_length = new List <int>(); msgs_length.AddRange(keys_length); msgs_length.Add(a_hmac.BlockSize * 4 - 1); msgs_length.Add(a_hmac.BlockSize * 4); msgs_length.Add(a_hmac.BlockSize * 4 + 1); foreach (int key_length in keys_length) { byte[] key = m_random.NextBytes(key_length); a_base_hmac.Key = key; a_hmac.Key = key; foreach (int msg_length in msgs_length) { byte[] msg = m_random.NextBytes(msg_length); a_base_hmac.Initialize(); a_base_hmac.TransformBytes(msg); HashResult h1 = a_base_hmac.TransformFinal(); a_hmac.Initialize(); a_hmac.TransformBytes(msg); HashResult h2 = a_hmac.TransformFinal(); Assert.AreEqual(h1, h2, a_hmac.Name); h1 = a_base_hmac.ComputeString(BitConverter.ToString(msg)); h2 = a_hmac.ComputeString(BitConverter.ToString(msg)); Assert.AreEqual(h1, h2, a_hmac.Name); } } }
public static void QuickStart_MersenneTwister() { // MersenneTwister is a pseudo-random number generator. var mt = new MersenneTwister(42); var ul = mt.NextUInt64(); // [0, 2^64-1] var d = mt.NextDouble(); // [0,1) var bytes = new byte[10]; mt.NextBytes(bytes); }
public static void QuickStart_RandomVault() { // RandomVault is a random number pool. // It's thread-safe and faster than lock in most cases. var mt = new MersenneTwister(); // Create a random generator. var rv = new RandomVault(() => mt.NextUInt64(), x => mt.NextBytes(x)); // Specify NextULong() or NextBytes() or both delegates, and forget about mt. Console.WriteLine("RandomVault:"); Console.WriteLine(rv.NextInt64()); Console.WriteLine(rv.NextDouble()); }
public static void Main(string[] args) { CommandLineParser cmd = CommandLineParser.Parse(args); Log.CreateInstance(true); string keyText = null; if (cmd["key"] != null) { keyText = cmd["key"].Value; } else { keyText = PasswordPrompt.Get("Please enter the encryption key"); string keyText2 = PasswordPrompt.Get("Please confirm the encryption key"); if (keyText != keyText2) { Log.Instance.Write(Log_Severity.Fatal, "Keys did not match"); } } if (cmd["to"] == null || cmd["from"] == null) { Log.Instance.Write(Log_Severity.Fatal, "Need arguments 'to' and 'from'"); } ulong sender = ulong.Parse(cmd["from"].Value); ulong recipient = ulong.Parse(cmd["to"].Value); var mt = new MersenneTwister((uint)Guid.NewGuid().GetHashCode()); var key = Encoding.UTF8.GetBytes(keyText); if (sender == 0) { sender = mt.NextULong(); } if (recipient == 0) { recipient = mt.NextULong(); } var iv = mt.NextBytes(BLOCK_SIZE); var data = BitShifter.ToByte(sender).Concat(BitShifter.ToByte(recipient)).ToArray(); BufferedBlockCipher cipher = new CtsBlockCipher(new CbcBlockCipher(new AesEngine())); ICipherParameters keyParam = new ParametersWithIV(new KeyParameter(key), iv); cipher.Init(true, keyParam); Log.Instance.Write(iv.Concat(cipher.DoFinal(data, 0, data.Length)).ToArray().ToHex()); }
public void TestNextBytes() { MersenneTwister m = new MersenneTwister(42); try { m.NextBytes(new byte[] { 0x00 }); } catch (Exception e) { Assert.Fail(e.ToString()); } }
private void SaveLine(StreamWriter a_sw, int a_data_length) { byte[] data = m_random.NextBytes(a_data_length); byte[] hash = m_hash.ComputeBytes(data).GetBytes(); if (m_hash is IWithKey) { a_sw.WriteLine("Key: {0}", Converters.ConvertBytesToHexString((m_hash as IWithKey).Key, false)); } a_sw.WriteLine("Repeat: {0}", 1); a_sw.WriteLine("Messsage: {0}", Converters.ConvertBytesToHexString(data, false)); a_sw.WriteLine("Hash: {0}", Converters.ConvertBytesToHexString(hash, false)); a_sw.WriteLine(""); }
private void MeasureBytesPerCycle(SpeedTestDataSourceRow a_row) { Stopwatch sw = new Stopwatch(); IHash hash = a_row.HashFunction; MersenneTwister r = new MersenneTwister(); hash.Initialize(); var msg = r.NextBytes(BYTES_ARRAY_LENGTH_CYCLES_PER_SECOND); RDTSC.rdtsc(); hash.ComputeBytes(msg); int repeats = 0; ulong min_delta = UInt64.MaxValue; for (; ;) { HighPriority(); try { sw.Start(); ulong before = RDTSC.rdtsc(); hash.ComputeBytes(msg); ulong after = RDTSC.rdtsc(); sw.Stop(); ulong delta = after - before; min_delta = Math.Min(min_delta, delta); } finally { NormalPriority(); } repeats++; if (sw.ElapsedMilliseconds > MEASURE_TIME) { if (repeats > MIN_REPEATS) { break; } } } a_row.BytesPerCycle = ((double)min_delta / BYTES_ARRAY_LENGTH_CYCLES_PER_SECOND).ToString("F2"); }
public static void Test1() { var mt2 = new MersenneTwister(new ulong[] { 0x12345UL, 0x23456UL, 0x34567UL, 0x45678UL }); var poolSliding = new RandomVault(() => mt2.NextUInt64(), x => mt2.NextBytes(x)); Debug.Assert(poolSliding.NextUInt64() == 7266447313870364031UL); for (var i = 0; i < 20000; i++) { poolSliding.NextUInt64(); } var mt3 = new MersenneTwister(new ulong[] { 0x12345UL, 0x23456UL, 0x34567UL, 0x45678UL }); var poolConcurrentQueue = new RandomPoolConcurrentQueue(() => mt3.NextUInt64(), x => mt3.NextBytes(x)); Debug.Assert(poolConcurrentQueue.NextULong() == 7266447313870364031UL); for (var i = 0; i < 20000; i++) { poolConcurrentQueue.NextULong(); } }
public static string Encrypt(ulong sender, ulong recipient) { var mt = new MersenneTwister((uint)Guid.NewGuid().GetHashCode()); var key = Encoding.UTF8.GetBytes(((FusionBotConfig)Globals.Bot.Config).DonationPaymentIdKey); if (sender == 0) { sender = mt.NextULong(); } if (recipient == 0) { recipient = mt.NextULong(); } var iv = mt.NextBytes(BLOCK_SIZE); var data = BitShifter.ToByte(sender).Concat(BitShifter.ToByte(recipient)).ToArray(); BufferedBlockCipher cipher = new CtsBlockCipher(new CbcBlockCipher(new AesEngine())); ICipherParameters keyParam = new ParametersWithIV(new KeyParameter(key), iv); cipher.Init(true, keyParam); return(iv.Concat(cipher.DoFinal(data, 0, data.Length)).ToArray().ToHex()); }
private void Measure(SpeedTestDataSourceRow a_row) { MersenneTwister r = new MersenneTwister(); { var ar = r.NextBytes(BYTES_ARRAY_LENGTH); a_row.BytesSpeed = Measure(ar.Length, () => { a_row.HashFunction.ComputeBytes(ar); }); } IFastHash32 hash = a_row.HashFunction as IFastHash32; if (hash == null) return; { var ar = r.NextBytes(BYTES_ARRAY_LENGTH / SINGLE_ELEMENT_RATIO); a_row.ByteSpeed = Measure(ar.Length, () => { for (int i = 0; i < ar.Length; i++) hash.ComputeByteFast(ar[i]); }); } { var ar = r.NextChars(BYTES_ARRAY_LENGTH / sizeof(char)); a_row.CharsSpeed = Measure(ar.Length * sizeof(char), () => { hash.ComputeCharsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.CharSpeed = Measure(ar.Length * sizeof(char), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeCharFast(ar[i]); }); } { var ar = r.NextShorts(BYTES_ARRAY_LENGTH / sizeof(short)); a_row.ShortsSpeed = Measure(ar.Length * sizeof(short), () => { hash.ComputeShortsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.ShortSpeed = Measure(ar.Length * sizeof(short), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeShortFast(ar[i]); }); } { var ar = r.NextUShorts(BYTES_ARRAY_LENGTH / sizeof(ushort)); a_row.UShortsSpeed = Measure(ar.Length * sizeof(ushort), () => { hash.ComputeUShortsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.UShortSpeed = Measure(ar.Length * sizeof(ushort), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeUShortFast(ar[i]); }); } { var ar = r.NextInts(BYTES_ARRAY_LENGTH / sizeof(int)); a_row.IntsSpeed = Measure(ar.Length * sizeof(int), () => { hash.ComputeIntsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.IntSpeed = Measure(ar.Length * sizeof(int), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeIntFast(ar[i]); }); } { var ar = r.NextUInts(BYTES_ARRAY_LENGTH / sizeof(uint)); a_row.UIntsSpeed = Measure(ar.Length * sizeof(uint), () => { hash.ComputeUIntsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.UIntSpeed = Measure(ar.Length * sizeof(uint), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeUIntFast(ar[i]); }); } { var ar = r.NextLongs(BYTES_ARRAY_LENGTH / sizeof(long)); a_row.LongsSpeed = Measure(ar.Length * sizeof(long), () => { hash.ComputeLongsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.LongSpeed = Measure(ar.Length * sizeof(long), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeLongFast(ar[i]); }); } { var ar = r.NextULongs(BYTES_ARRAY_LENGTH / sizeof(ulong)); a_row.ULongsSpeed = Measure(ar.Length * sizeof(ulong), () => { hash.ComputeULongsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.ULongSpeed = Measure(ar.Length * sizeof(ulong), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeULongFast(ar[i]); }); } { var ar = r.NextFloatsFullSafe(BYTES_ARRAY_LENGTH / sizeof(float)); a_row.FloatsSpeed = Measure(ar.Length * sizeof(float), () => { hash.ComputeFloatsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.FloatSpeed = Measure(ar.Length * sizeof(float), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeFloatFast(ar[i]); }); } { var ar = r.NextDoublesFullSafe(BYTES_ARRAY_LENGTH / sizeof(double)); a_row.DoublesSpeed = Measure(ar.Length * sizeof(double), () => { hash.ComputeDoublesFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.DoubleSpeed = Measure(ar.Length * sizeof(double), () => { for (int i = 0; i < ar.Length; i++) hash.ComputeDoubleFast(ar[i]); }); } { var ar = r.NextString(BYTES_ARRAY_LENGTH / sizeof(char)); a_row.StringSpeed = Measure(ar.Length * sizeof(char), () => { hash.ComputeStringFast(ar); }); } }
private void MeasureBytesPerCycle(SpeedTestDataSourceRow a_row) { Stopwatch sw = new Stopwatch(); IHash hash = a_row.HashFunction; MersenneTwister r = new MersenneTwister(); hash.Initialize(); var msg = r.NextBytes(BYTES_ARRAY_LENGTH_CYCLES_PER_SECOND); RDTSC.rdtsc(); hash.ComputeBytes(msg); int repeats = 0; ulong min_delta = UInt64.MaxValue; for (; ; ) { HighPriority(); try { sw.Start(); ulong before = RDTSC.rdtsc(); hash.ComputeBytes(msg); ulong after = RDTSC.rdtsc(); sw.Stop(); ulong delta = after - before; min_delta = Math.Min(min_delta, delta); } finally { NormalPriority(); } repeats++; if (sw.ElapsedMilliseconds > MEASURE_TIME) if (repeats > MIN_REPEATS) break; } a_row.BytesPerCycle = ((double)min_delta / BYTES_ARRAY_LENGTH_CYCLES_PER_SECOND).ToString("F2"); }
public void Test1() { var init = new ulong[] { 0x12345UL, 0x23456UL, 0x34567UL, 0x45678UL }; var mt = new MersenneTwister(init); // NextULong test mt.NextUInt64().Is(7266447313870364031UL); mt.NextUInt64().Is(4946485549665804864UL); mt.NextUInt64().Is(16945909448695747420UL); mt.NextUInt64().Is(16394063075524226720UL); mt.NextUInt64().Is(4873882236456199058UL); for (var i = 0; i < 990; i++) { mt.NextUInt64(); } mt.NextUInt64().Is(10197035660403006684UL); mt.NextUInt64().Is(13004818533162292132UL); mt.NextUInt64().Is(9831652587047067687UL); mt.NextUInt64().Is(7619315254749630976UL); mt.NextUInt64().Is(994412663058993407UL); // NextDouble test DoubleToString(mt.NextDouble()).Is("0.35252031"); DoubleToString(mt.NextDouble()).Is("0.51052342"); DoubleToString(mt.NextDouble()).Is("0.79771733"); DoubleToString(mt.NextDouble()).Is("0.39300273"); DoubleToString(mt.NextDouble()).Is("0.27216673"); string DoubleToString(double d) => d.ToString("F8"); // Reset(byte[]) test var size = init.Length * sizeof(ulong); byte[] seed = new byte[size]; Buffer.BlockCopy(init, 0, seed, 0, size); mt.Reset(init); mt.NextUInt64().Is(7266447313870364031UL); mt.NextUInt64().Is(4946485549665804864UL); mt.NextUInt64().Is(16945909448695747420UL); mt.NextUInt64().Is(16394063075524226720UL); mt.NextUInt64().Is(4873882236456199058UL); // NextBytes test var bytes = new byte[24]; var bytes2 = new byte[24]; var span = bytes.AsSpan(); BitConverter.TryWriteBytes(span, 7266447313870364031UL); span = span.Slice(8); BitConverter.TryWriteBytes(span, 4946485549665804864UL); span = span.Slice(8); BitConverter.TryWriteBytes(span, 16945909448695747420UL); for (var i = 0; i <= 8; i++) { mt.Reset(init); var span2 = bytes2.AsSpan(0, 16 + i); mt.NextBytes(span2); span2.SequenceEqual(bytes.AsSpan().Slice(0, 16 + i)).IsTrue(); } }
public void AdaptersTest_All() { { IHash md5 = HashFactory.Crypto.CreateMD5(); for(int i = 0; i < 5; i++) { var v = new byte[16]; new Random().NextBytes(v); Assert.IsFalse(!md5.ComputeBytes(v.Take(1).ToArray()).GetBytes().SequenceEqual(md5.ComputeByte(v[0]).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(2).ToArray()).GetBytes().SequenceEqual(md5.ComputeChar(BitConverter.ToChar(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(2).ToArray()).GetBytes().SequenceEqual(md5.ComputeShort(BitConverter.ToInt16(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(2).ToArray()).GetBytes().SequenceEqual(md5.ComputeUShort(BitConverter.ToUInt16(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(4).ToArray()).GetBytes().SequenceEqual(md5.ComputeInt(BitConverter.ToInt32(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(4).ToArray()).GetBytes().SequenceEqual(md5.ComputeUInt(BitConverter.ToUInt32(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(8).ToArray()).GetBytes().SequenceEqual(md5.ComputeLong(BitConverter.ToInt64(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(8).ToArray()).GetBytes().SequenceEqual(md5.ComputeULong(BitConverter.ToUInt64(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(8).ToArray()).GetBytes().SequenceEqual(md5.ComputeDouble(BitConverter.ToDouble(v, 0)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v.Take(4).ToArray()).GetBytes().SequenceEqual(md5.ComputeFloat(Converters.ConvertBytesToFloat(v, 0)).GetBytes())); { string s = BitConverter.ToString(v); Assert.IsFalse(!md5.ComputeBytes(Converters.ConvertStringToBytes(s)).GetBytes().SequenceEqual(md5.ComputeString(s).GetBytes())); } Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeChars(Converters.ConvertBytesToChars(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeShorts(Converters.ConvertBytesToShorts(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeUShorts(Converters.ConvertBytesToUShorts(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeInts(Converters.ConvertBytesToInts(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeUInts(Converters.ConvertBytesToUInts(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeLongs(Converters.ConvertBytesToLongs(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeULongs(Converters.ConvertBytesToULongs(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeFloats(Converters.ConvertBytesToFloats(v)).GetBytes())); Assert.IsFalse(!md5.ComputeBytes(v).GetBytes().SequenceEqual(md5.ComputeDoubles(Converters.ConvertBytesToDoubles(v)).GetBytes())); } } { IHash murmur2 = HashFactory.Hash32.CreateMurmur2(); for(int i = 0; i < 5; i++) { var v = new byte[16]; new Random().NextBytes(v); Assert.IsFalse(murmur2.ComputeBytes(v.Take(1).ToArray()) != murmur2.ComputeByte(v[0])); Assert.IsFalse(murmur2.ComputeBytes(v.Take(2).ToArray()) != murmur2.ComputeChar(BitConverter.ToChar(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(2).ToArray()) != murmur2.ComputeShort(BitConverter.ToInt16(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(2).ToArray()) != murmur2.ComputeUShort(BitConverter.ToUInt16(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(4).ToArray()) != murmur2.ComputeInt(BitConverter.ToInt32(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(4).ToArray()) != murmur2.ComputeUInt(BitConverter.ToUInt32(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(8).ToArray()) != murmur2.ComputeLong(BitConverter.ToInt64(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(8).ToArray()) != murmur2.ComputeULong(BitConverter.ToUInt64(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(8).ToArray()) != murmur2.ComputeDouble(BitConverter.ToDouble(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(4).ToArray()) != murmur2.ComputeFloat(Converters.ConvertBytesToFloat(v, 0))); { string s = BitConverter.ToString(v); Assert.IsFalse(murmur2.ComputeBytes(Converters.ConvertStringToBytes(s)) != murmur2.ComputeString(s)); } Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeChars(Converters.ConvertBytesToChars(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeShorts(Converters.ConvertBytesToShorts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeUShorts(Converters.ConvertBytesToUShorts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeInts(Converters.ConvertBytesToInts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeUInts(Converters.ConvertBytesToUInts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeLongs(Converters.ConvertBytesToLongs(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeULongs(Converters.ConvertBytesToULongs(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeFloats(Converters.ConvertBytesToFloats(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeDoubles(Converters.ConvertBytesToDoubles(v))); } } { IHash murmur2 = HashFactory.Hash64.CreateMurmur2(); for(int i = 0; i < 5; i++) { var v = new byte[16]; new Random().NextBytes(v); Assert.IsFalse(murmur2.ComputeBytes(v.Take(1).ToArray()) != murmur2.ComputeByte(v[0])); Assert.IsFalse(murmur2.ComputeBytes(v.Take(2).ToArray()) != murmur2.ComputeChar(BitConverter.ToChar(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(2).ToArray()) != murmur2.ComputeShort(BitConverter.ToInt16(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(2).ToArray()) != murmur2.ComputeUShort(BitConverter.ToUInt16(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(4).ToArray()) != murmur2.ComputeInt(BitConverter.ToInt32(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(4).ToArray()) != murmur2.ComputeUInt(BitConverter.ToUInt32(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(8).ToArray()) != murmur2.ComputeLong(BitConverter.ToInt64(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(8).ToArray()) != murmur2.ComputeULong(BitConverter.ToUInt64(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(8).ToArray()) != murmur2.ComputeDouble(BitConverter.ToDouble(v, 0))); Assert.IsFalse(murmur2.ComputeBytes(v.Take(4).ToArray()) != murmur2.ComputeFloat(Converters.ConvertBytesToFloat(v, 0))); { string s = BitConverter.ToString(v); Assert.IsFalse(murmur2.ComputeBytes(Converters.ConvertStringToBytes(s)) != murmur2.ComputeString(s)); } Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeChars(Converters.ConvertBytesToChars(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeShorts(Converters.ConvertBytesToShorts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeUShorts(Converters.ConvertBytesToUShorts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeInts(Converters.ConvertBytesToInts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeUInts(Converters.ConvertBytesToUInts(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeLongs(Converters.ConvertBytesToLongs(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeULongs(Converters.ConvertBytesToULongs(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeFloats(Converters.ConvertBytesToFloats(v))); Assert.IsFalse(murmur2.ComputeBytes(v) != murmur2.ComputeDoubles(Converters.ConvertBytesToDoubles(v))); } } { // Adapters.TransformObjectHash() test IHash md5 = HashFactory.Crypto.CreateMD5(); var ms1 = new MersenneTwister(5566); var ms2 = new MersenneTwister(5566); Assert.AreEqual(md5.ComputeByte(ms1.NextByte()), md5.ComputeObject(ms2.NextByte())); Assert.AreEqual(md5.ComputeShort(ms1.NextShort()), md5.ComputeObject(ms2.NextShort())); Assert.AreEqual(md5.ComputeUShort(ms1.NextUShort()), md5.ComputeObject(ms2.NextUShort())); Assert.AreEqual(md5.ComputeChar(ms1.NextChar()), md5.ComputeObject(ms2.NextChar())); Assert.AreEqual(md5.ComputeInt(ms1.NextInt()), md5.ComputeObject(ms2.NextInt())); Assert.AreEqual(md5.ComputeUInt(ms1.NextUInt()), md5.ComputeObject(ms2.NextUInt())); Assert.AreEqual(md5.ComputeLong(ms1.NextLong()), md5.ComputeObject(ms2.NextLong())); Assert.AreEqual(md5.ComputeULong(ms1.NextULong()), md5.ComputeObject(ms2.NextULong())); Assert.AreEqual(md5.ComputeDouble(ms1.NextDoubleFull()), md5.ComputeObject(ms2.NextDoubleFull())); Assert.AreEqual(md5.ComputeFloat(ms1.NextFloatFull()), md5.ComputeObject(ms2.NextFloatFull())); Assert.AreEqual(md5.ComputeString(ms1.NextString(20)), md5.ComputeObject(ms2.NextString(20))); Assert.AreEqual(md5.ComputeBytes(ms1.NextBytes(20)), md5.ComputeObject(ms2.NextBytes(20))); Assert.AreEqual(md5.ComputeShorts(ms1.NextShorts(20)), md5.ComputeObject(ms2.NextShorts(20))); Assert.AreEqual(md5.ComputeUShorts(ms1.NextUShorts(20)), md5.ComputeObject(ms2.NextUShorts(20))); Assert.AreEqual(md5.ComputeChars(ms1.NextChars(20)), md5.ComputeObject(ms2.NextChars(20))); Assert.AreEqual(md5.ComputeInts(ms1.NextInts(20)), md5.ComputeObject(ms2.NextInts(20))); Assert.AreEqual(md5.ComputeUInts(ms1.NextUInts(20)), md5.ComputeObject(ms2.NextUInts(20))); Assert.AreEqual(md5.ComputeLongs(ms1.NextLongs(20)), md5.ComputeObject(ms2.NextLongs(20))); Assert.AreEqual(md5.ComputeULongs(ms1.NextULongs(20)), md5.ComputeObject(ms2.NextULongs(20))); Assert.AreEqual(md5.ComputeDoubles(ms1.NextDoublesFull(20)), md5.ComputeObject(ms2.NextDoublesFull(20))); Assert.AreEqual(md5.ComputeFloats(ms1.NextFloatsFull(20)), md5.ComputeObject(ms2.NextFloatsFull(20))); } { // Adapters.ComputeObjectHash() test IHash murmur2 = HashFactory.Hash32.CreateMurmur2(); var ms1 = new MersenneTwister(5566); var ms2 = new MersenneTwister(5566); Assert.AreEqual(murmur2.ComputeByte(ms1.NextByte()), murmur2.ComputeObject(ms2.NextByte())); Assert.AreEqual(murmur2.ComputeShort(ms1.NextShort()), murmur2.ComputeObject(ms2.NextShort())); Assert.AreEqual(murmur2.ComputeUShort(ms1.NextUShort()), murmur2.ComputeObject(ms2.NextUShort())); Assert.AreEqual(murmur2.ComputeChar(ms1.NextChar()), murmur2.ComputeObject(ms2.NextChar())); Assert.AreEqual(murmur2.ComputeInt(ms1.NextInt()), murmur2.ComputeObject(ms2.NextInt())); Assert.AreEqual(murmur2.ComputeUInt(ms1.NextUInt()), murmur2.ComputeObject(ms2.NextUInt())); Assert.AreEqual(murmur2.ComputeLong(ms1.NextLong()), murmur2.ComputeObject(ms2.NextLong())); Assert.AreEqual(murmur2.ComputeULong(ms1.NextULong()), murmur2.ComputeObject(ms2.NextULong())); Assert.AreEqual(murmur2.ComputeDouble(ms1.NextDoubleFull()), murmur2.ComputeObject(ms2.NextDoubleFull())); Assert.AreEqual(murmur2.ComputeFloat(ms1.NextFloatFull()), murmur2.ComputeObject(ms2.NextFloatFull())); Assert.AreEqual(murmur2.ComputeString(ms1.NextString(20)), murmur2.ComputeObject(ms2.NextString(20))); Assert.AreEqual(murmur2.ComputeBytes(ms1.NextBytes(20)), murmur2.ComputeObject(ms2.NextBytes(20))); Assert.AreEqual(murmur2.ComputeShorts(ms1.NextShorts(20)), murmur2.ComputeObject(ms2.NextShorts(20))); Assert.AreEqual(murmur2.ComputeUShorts(ms1.NextUShorts(20)), murmur2.ComputeObject(ms2.NextUShorts(20))); Assert.AreEqual(murmur2.ComputeChars(ms1.NextChars(20)), murmur2.ComputeObject(ms2.NextChars(20))); Assert.AreEqual(murmur2.ComputeInts(ms1.NextInts(20)), murmur2.ComputeObject(ms2.NextInts(20))); Assert.AreEqual(murmur2.ComputeUInts(ms1.NextUInts(20)), murmur2.ComputeObject(ms2.NextUInts(20))); Assert.AreEqual(murmur2.ComputeLongs(ms1.NextLongs(20)), murmur2.ComputeObject(ms2.NextLongs(20))); Assert.AreEqual(murmur2.ComputeULongs(ms1.NextULongs(20)), murmur2.ComputeObject(ms2.NextULongs(20))); Assert.AreEqual(murmur2.ComputeDoubles(ms1.NextDoublesFull(20)), murmur2.ComputeObject(ms2.NextDoublesFull(20))); Assert.AreEqual(murmur2.ComputeFloats(ms1.NextFloatsFull(20)), murmur2.ComputeObject(ms2.NextFloatsFull(20))); } int old = Hash.BUFFER_SIZE; Hash.BUFFER_SIZE = 26; { IHash md5 = HashFactory.Crypto.CreateMD5(); for(int i = 0; i < 10; i++) { var v = new byte[13 * i]; new Random().NextBytes(v); using(var ms = new MemoryStream(v)) { HashResult h1 = md5.ComputeBytes(v); HashResult h2 = md5.ComputeStream(ms); Assert.AreEqual(h1, h2); h1 = md5.ComputeBytes(v.SubArray(i, i * 7)); ms.Seek(i, SeekOrigin.Begin); h2 = md5.ComputeStream(ms, i * 7); Assert.AreEqual(h1, h2); h1 = md5.ComputeBytes(v); md5.Initialize(); md5.TransformBytes(v, 0, i * 3); ms.Seek(i * 3, SeekOrigin.Begin); md5.TransformStream(ms, i * 2); md5.TransformBytes(v, i * 5); h2 = md5.TransformFinal(); Assert.AreEqual(h1, h2); } } } { IHash murmur2 = HashFactory.Hash32.CreateMurmur2(); for(int i = 0; i < 10; i++) { var v = new byte[13 * i]; new Random().NextBytes(v); using(var ms = new MemoryStream(v)) { HashResult h1 = murmur2.ComputeBytes(v); HashResult h2 = murmur2.ComputeStream(ms); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v.SubArray(i, i * 7)); ms.Seek(i, SeekOrigin.Begin); h2 = murmur2.ComputeStream(ms, i * 7); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v); murmur2.Initialize(); murmur2.TransformBytes(v, 0, i * 3); ms.Seek(i * 3, SeekOrigin.Begin); murmur2.TransformStream(ms, i * 2); murmur2.TransformBytes(v, i * 5); h2 = murmur2.TransformFinal(); Assert.AreEqual(h1, h2); } } } { IHash murmur2 = HashFactory.Hash64.CreateMurmur2(); for(int i = 0; i < 10; i++) { var v = new byte[13 * i]; new Random().NextBytes(v); using(var ms = new MemoryStream(v)) { HashResult h1 = murmur2.ComputeBytes(v); HashResult h2 = murmur2.ComputeStream(ms); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v.SubArray(i, i * 7)); ms.Seek(i, SeekOrigin.Begin); h2 = murmur2.ComputeStream(ms, i * 7); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v); murmur2.Initialize(); murmur2.TransformBytes(v, 0, i * 3); ms.Seek(i * 3, SeekOrigin.Begin); murmur2.TransformStream(ms, i * 2); murmur2.TransformBytes(v, i * 5); h2 = murmur2.TransformFinal(); Assert.AreEqual(h1, h2); } } } Hash.BUFFER_SIZE = old; { IHash md5 = HashFactory.Crypto.CreateMD5(); for(int i = 0; i < 10; i++) { var v = new byte[13 * i]; new Random().NextBytes(v); string file_name = Path.GetTempFileName(); using(var fs = new FileStream(file_name, FileMode.Truncate)) { var bw = new BinaryWriter(fs); bw.Write(v); } HashResult h1 = md5.ComputeBytes(v); HashResult h2 = md5.ComputeFile(file_name); Assert.AreEqual(h1, h2); h1 = md5.ComputeBytes(v.SubArray(i, i * 7)); h2 = md5.ComputeFile(file_name, i, i * 7); Assert.AreEqual(h1, h2); h1 = md5.ComputeBytes(v); md5.Initialize(); md5.TransformBytes(v, 0, i * 3); md5.TransformFile(file_name, i * 3, i * 2); md5.TransformBytes(v, i * 5); h2 = md5.TransformFinal(); Assert.AreEqual(h1, h2); } } { IHash murmur2 = HashFactory.Hash32.CreateMurmur2(); for(int i = 0; i < 10; i++) { var v = new byte[13 * i]; new Random().NextBytes(v); string file_name = Path.GetTempFileName(); using(var fs = new FileStream(file_name, FileMode.Truncate)) { var bw = new BinaryWriter(fs); bw.Write(v); } HashResult h1 = murmur2.ComputeBytes(v); HashResult h2 = murmur2.ComputeFile(file_name); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v.SubArray(i, i * 7)); h2 = murmur2.ComputeFile(file_name, i, i * 7); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v); murmur2.Initialize(); murmur2.TransformBytes(v, 0, i * 3); murmur2.TransformFile(file_name, i * 3, i * 2); murmur2.TransformBytes(v, i * 5); h2 = murmur2.TransformFinal(); Assert.AreEqual(h1, h2); } } { IHash murmur2 = HashFactory.Hash64.CreateMurmur2(); for(int i = 0; i < 10; i++) { var v = new byte[13 * i]; new Random().NextBytes(v); string file_name = Path.GetTempFileName(); using(var fs = new FileStream(file_name, FileMode.Truncate)) { var bw = new BinaryWriter(fs); bw.Write(v); } HashResult h1 = murmur2.ComputeBytes(v); HashResult h2 = murmur2.ComputeFile(file_name); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v.SubArray(i, i * 7)); h2 = murmur2.ComputeFile(file_name, i, i * 7); Assert.AreEqual(h1, h2); h1 = murmur2.ComputeBytes(v); murmur2.Initialize(); murmur2.TransformBytes(v, 0, i * 3); murmur2.TransformFile(file_name, i * 3, i * 2); murmur2.TransformBytes(v, i * 5); h2 = murmur2.TransformFinal(); Assert.AreEqual(h1, h2); } } { new HashesTestBase().TestAgainstBaseImplementationArrayType( HashFactory.Crypto.CreateSHA1(), HashFactory.Wrappers.HashAlgorithmToHash( HashFactory.Wrappers.HashToHashAlgorithm( HashFactory.Crypto.CreateSHA1()), HashFactory.Crypto.CreateSHA1().BlockSize ) ); } }
private void Measure(SpeedTestDataSourceRow a_row) { MersenneTwister r = new MersenneTwister(); { var ar = r.NextBytes(BYTES_ARRAY_LENGTH); a_row.BytesSpeed = Measure(ar.Length, () => { a_row.HashFunction.ComputeBytes(ar); }); } IFastHash32 hash = a_row.HashFunction as IFastHash32; if (hash == null) { return; } { var ar = r.NextBytes(BYTES_ARRAY_LENGTH / SINGLE_ELEMENT_RATIO); a_row.ByteSpeed = Measure(ar.Length, () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeByteFast(ar[i]); } }); } { var ar = r.NextChars(BYTES_ARRAY_LENGTH / sizeof(char)); a_row.CharsSpeed = Measure(ar.Length * sizeof(char), () => { hash.ComputeCharsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.CharSpeed = Measure(ar.Length * sizeof(char), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeCharFast(ar[i]); } }); } { var ar = r.NextShorts(BYTES_ARRAY_LENGTH / sizeof(short)); a_row.ShortsSpeed = Measure(ar.Length * sizeof(short), () => { hash.ComputeShortsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.ShortSpeed = Measure(ar.Length * sizeof(short), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeShortFast(ar[i]); } }); } { var ar = r.NextUShorts(BYTES_ARRAY_LENGTH / sizeof(ushort)); a_row.UShortsSpeed = Measure(ar.Length * sizeof(ushort), () => { hash.ComputeUShortsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.UShortSpeed = Measure(ar.Length * sizeof(ushort), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeUShortFast(ar[i]); } }); } { var ar = r.NextInts(BYTES_ARRAY_LENGTH / sizeof(int)); a_row.IntsSpeed = Measure(ar.Length * sizeof(int), () => { hash.ComputeIntsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.IntSpeed = Measure(ar.Length * sizeof(int), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeIntFast(ar[i]); } }); } { var ar = r.NextUInts(BYTES_ARRAY_LENGTH / sizeof(uint)); a_row.UIntsSpeed = Measure(ar.Length * sizeof(uint), () => { hash.ComputeUIntsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.UIntSpeed = Measure(ar.Length * sizeof(uint), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeUIntFast(ar[i]); } }); } { var ar = r.NextLongs(BYTES_ARRAY_LENGTH / sizeof(long)); a_row.LongsSpeed = Measure(ar.Length * sizeof(long), () => { hash.ComputeLongsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.LongSpeed = Measure(ar.Length * sizeof(long), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeLongFast(ar[i]); } }); } { var ar = r.NextULongs(BYTES_ARRAY_LENGTH / sizeof(ulong)); a_row.ULongsSpeed = Measure(ar.Length * sizeof(ulong), () => { hash.ComputeULongsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.ULongSpeed = Measure(ar.Length * sizeof(ulong), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeULongFast(ar[i]); } }); } { var ar = r.NextFloatsFullSafe(BYTES_ARRAY_LENGTH / sizeof(float)); a_row.FloatsSpeed = Measure(ar.Length * sizeof(float), () => { hash.ComputeFloatsFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.FloatSpeed = Measure(ar.Length * sizeof(float), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeFloatFast(ar[i]); } }); } { var ar = r.NextDoublesFullSafe(BYTES_ARRAY_LENGTH / sizeof(double)); a_row.DoublesSpeed = Measure(ar.Length * sizeof(double), () => { hash.ComputeDoublesFast(ar); }); ar = ArrayExtensions.SubArray(ar, 0, ar.Length / SINGLE_ELEMENT_RATIO); a_row.DoubleSpeed = Measure(ar.Length * sizeof(double), () => { for (int i = 0; i < ar.Length; i++) { hash.ComputeDoubleFast(ar[i]); } }); } { var ar = r.NextString(BYTES_ARRAY_LENGTH / sizeof(char)); a_row.StringSpeed = Measure(ar.Length * sizeof(char), () => { hash.ComputeStringFast(ar); }); } }
public void Save() { var fs = new FileStream(GetFileName(), FileMode.Create); using(var sw = new StreamWriter(fs)) { var random = new MersenneTwister(4563487); for(int i = 0; i <= m_hash.BlockSize * 3 + 1; i++) { byte[] data = random.NextBytes(i); sw.Write(Convert.ToBase64String(data)); sw.Write("|"); sw.WriteLine(Convert.ToBase64String(m_hash.ComputeBytes(data).GetBytes())); } } }