public unsafe void Hash128PtrOverloads()
{
ulong seed1 = 238929482;
ulong seed2 = 19384920392;
string testString = "This is a test string";
ulong hash1 = seed1;
ulong hash2 = seed2;
fixed(void *ptr = testString)
{
int len = testString.Length * 2;
SpookyHash.Hash128(ptr, len, ref hash1, ref hash2);
HashCode128 hc = new HashCode128(hash1, hash2);
Assert.Equal(hc, SpookyHash.Hash128((UIntPtr)ptr, len, seed1, seed2));
Assert.Equal(hc, SpookyHash.Hash128((UIntPtr)ptr, len, (long)seed1, (long)seed2));
Assert.Equal(hc, SpookyHash.Hash128((IntPtr)ptr, len, seed1, seed2));
Assert.Equal(hc, SpookyHash.Hash128((IntPtr)ptr, len, (long)seed1, (long)seed2));
}
SpookyHash.Hash128(default(void *), 50, ref hash1, ref hash2);
Assert.Equal(0UL, hash1);
Assert.Equal(0UL, hash2);
Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(UIntPtr.Zero, 50, seed1, seed2));
Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(UIntPtr.Zero, 50, (long)seed1, (long)seed2));
Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(IntPtr.Zero, 50, seed1, seed2));
Assert.Equal(HashCode128.Zero, SpookyHash.Hash128(IntPtr.Zero, 50, (long)seed1, (long)seed2));
}
private static void ParseStorageFile(StorageMetadata metadata, Stream storageStream, ulong?profileKey = null)
{
byte[] data = null;
using (BinaryReader reader = new BinaryReader(storageStream))
{
data = reader.ReadBytes((int)reader.BaseStream.Length);
}
var rawSha256 = new SHA256Managed().ComputeHash(data);
var sha256 = BitConverter.ToString(rawSha256).Replace("-", "");
if (sha256 != metadata.SHA256)
{
throw new InvalidDataException("Invalid storage file. Corrupt or wrong file?");
}
if (metadata.StorageVersion == STORAGE_VERSION_V1)
{
var key = GenerateKey(metadata, profileKey);
var decryptedData = XXTEA.Decrypt(data, key);
var output = Decompress(metadata, decryptedData);
// Verify data
SpookyHash sh = new SpookyHash(0x155af93ac304200, 0x8ac7230489e7ffff);
sh.Update(new SHA256Managed().ComputeHash(output));
sh.Update(output);
ulong hash1, hash2;
sh.Final(out hash1, out hash2);
ulong orig_hash1 = metadata.Key[0];
ulong orig_hash2 = metadata.Key[1];
if (orig_hash1 != hash1 || orig_hash2 != hash2)
{
throw new InvalidDataException("Invalid decrypted data. Wrong key?");
}
metadata.StorageRaw = output;
}
else
{
SpookyHash sh = new SpookyHash(0x155af93ac304200, 0x8ac7230489e7ffff);
sh.Update(rawSha256);
sh.Update(data);
ulong hash1, hash2;
sh.Final(out hash1, out hash2);
ulong orig_hash1 = metadata.Key[0];
ulong orig_hash2 = metadata.Key[1];
if (orig_hash1 != hash1 || orig_hash2 != hash2)
{
throw new InvalidDataException("Invalid decrypted data. Wrong key?");
}
metadata.StorageRaw = data;
}
}
public void FrameProtocol_RoundTripOfMultiFrames_Success()
{
// Arrange
GetChunkedFileRequestMessage request = CreateGetChunkedFileRequestMessage();
// Act
// Build a request stream from a message frame and a chunk frame
var builder = new FrameProtocolBuilder();
IBlob blob1 = new MemoryBlob(Encoding.UTF8.GetBytes("Blob1"));
IBlob blob2 = new MemoryBlob(Encoding.UTF8.GetBytes("Blob2"));
builder.AddFrame(request);
builder.AddFrame(blob1);
builder.AddFrame(blob2);
var inputStream = builder.CreateStream();
// Parse the request stream into multiple WopiFrame
List <Frame> frameList = FrameProtocolParser.ParseStream(inputStream);
// Assert
Assert.AreEqual(3, frameList.Count);
Assert.IsNotNull(frameList[0].Payload);
Assert.IsNull(frameList[0].ExtendedHeader);
Assert.IsNotNull(frameList[1].Payload);
Assert.IsNotNull(frameList[1].ExtendedHeader);
Assert.AreEqual(blob1.BlobId, System.Convert.ToBase64String(frameList[1].ExtendedHeader));
var spookyHash = new SpookyHash();
Assert.AreEqual(blob1.BlobId, spookyHash.CalculateHash(frameList[1].Payload));
Assert.IsNotNull(frameList[2].Payload);
Assert.IsNotNull(frameList[2].ExtendedHeader);
Assert.AreEqual(blob2.BlobId, System.Convert.ToBase64String(frameList[2].ExtendedHeader));
Assert.AreEqual(blob2.BlobId, spookyHash.CalculateHash(new MemoryStream(frameList[2].Payload)));
}
public void SequenceOfStrings()
{
SpookyHash sh = new SpookyHash();
sh.Update(MediumLengthSequence());
Assert.Equal(MediumLengthString.SpookyHash128(), sh.Final());
}
public static StorageMetadata CreateStorageFile(Stream dataStream, uint archiveNumber, ulong?profileKey)
{
StorageMetadata metadata = new StorageMetadata();
metadata.ArchiveNumber = archiveNumber + 2;
byte[] data = null;
using (BinaryReader reader = new BinaryReader(dataStream))
{
data = reader.ReadBytes((int)reader.BaseStream.Length);
}
Array.Resize(ref data, data.Length + 1); // 1 byte null padding
// Generate Spooky hash of data for later
SpookyHash sh = new SpookyHash(0x155af93ac304200, 0x8ac7230489e7ffff);
sh.Update(new SHA256Managed().ComputeHash(data));
sh.Update(data);
sh.Final(out metadata.Key[0], out metadata.Key[1]);
var compressedData = Compress(data);
var key = GenerateKey(metadata, profileKey, true);
metadata.StorageRaw = XXTEA.Encrypt(compressedData, key);
metadata.CompressedSize = (uint)compressedData.Length;
metadata.DecompressedSize = (uint)data.Length;
return(metadata);
}
public HashedStream(Stream stream, ulong readSeed0, ulong readSeed1, ulong writeSeed0, ulong writeSeed1)
{
ExceptionHelper.CheckNotNull(stream);
_backing = stream;
_read = new SpookyHash(readSeed0, readSeed1);
_written = new SpookyHash(writeSeed0, writeSeed1);
}
/// <summary>Initialises a new instance of the <see cref="SpookilySharp.HashedStream"/> class with a default
/// seed.</summary>
/// <param name="stream">The stream to read.</param>
public HashedStream(Stream stream)
{
ExceptionHelper.CheckNotNull(stream);
_backing = stream;
_read = new SpookyHash();
_written = new SpookyHash();
}
public void ConstructorsEquivalent()
{
ulong ui1 = 0xdeadcafe;
ulong ui2 = 0xbaceba11;
SpookyHash fromU = new SpookyHash(ui1, ui2);
SpookyHash fromZeroU = new SpookyHash();
fromZeroU.Init(ui1, ui2);
long l1 = unchecked ((long)ui1);
long l2 = unchecked ((long)ui2);
SpookyHash fromL = new SpookyHash(l1, l2);
SpookyHash fromZeroL = new SpookyHash();
fromZeroL.Init(l1, l2);
fromU.Update(MediumLengthString);
fromZeroU.Update(MediumLengthString);
fromL.Update(MediumLengthString);
fromZeroL.Update(MediumLengthString);
HashCode128 hash = fromU.Final();
Assert.Equal(hash, fromZeroU.Final());
Assert.Equal(hash, fromL.Final());
Assert.Equal(hash, fromZeroL.Final());
Assert.Equal(hash.ToString(), fromZeroL.Final().ToString());
}
public void FullFileChunkProcessor_StreamToBlobs_SucceedOnNonEmptyStream()
{
// Arrange
string alreadyExistingContent = "SomeRandomText";
byte[] bytes = Encoding.UTF8.GetBytes(alreadyExistingContent);
SpookyHash spookyHash = new SpookyHash();
string hashString = spookyHash.CalculateHash(bytes);
using (MemoryStream ms = new MemoryStream(bytes))
{
string[] blobIds;
IReadOnlyDictionary <string, IBlob> blobs = new Dictionary <string, IBlob>();
IChunkProcessor chunkProcessor = CreateFullFileChunkProcessor();
IBlobAllocator allocator = CreateBlobAllocator();
// Act
chunkProcessor.StreamToBlobs(ms, allocator, out blobIds, out blobs);
// Assert
Assert.AreEqual(1, blobIds.Length);
Assert.AreEqual(1, blobs.Count);
Assert.AreEqual((ulong)bytes.Length, blobs[blobIds[0]].Length);
Assert.AreEqual(hashString, blobs[blobIds[0]].BlobId);
}
}
private static unsafe HashCode128 SpookyHash128Unchecked(string message, int startIndex, int length, ulong seed0, ulong seed1)
{
fixed(char *ptr = message)
{
SpookyHash.Hash128(ptr + startIndex, length << 1, ref seed0, ref seed1);
}
return(new HashCode128(seed0, seed1));
}
public void StringExtension()
{
string testString;
using (Stream stm = GetStream())
using (StreamReader tr = new StreamReader(stm))
{
testString = tr.ReadToEnd();
}
SpookyHash sh = new SpookyHash();
sh.Update(testString);
HashCode128 h = sh.Final();
int len = testString.Length;
Assert.Equal(h, testString.SpookyHash128());
Assert.Equal(h, testString.SpookyHash128(0, len, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF));
Assert.Equal(
h,
unchecked (testString.SpookyHash128(0, len, (long)0xDEADBEEFDEADBEEF, (long)0xDEADBEEFDEADBEEF)));
Assert.Equal(h, testString.SpookyHash128(0, len));
HashCode128 hashSlice = testString.SpookyHash128(50, 100, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF);
Assert.NotEqual(h, hashSlice);
Assert.Equal(
hashSlice,
unchecked (testString.SpookyHash128(50, 100, (long)0xDEADBEEFDEADBEEF, (long)0xDEADBEEFDEADBEEF)));
long longHash = testString.SpookyHash64(0, len, unchecked ((long)0xDEADBEEFDEADBEEF));
Assert.Equal(longHash, testString.SpookyHash64(unchecked ((long)0xDEADBEEFDEADBEEF)));
Assert.Equal(longHash, testString.SpookyHash64(0, len));
Assert.Equal(longHash, testString.SpookyHash64());
int hash = testString.SpookyHash32(0, len, unchecked ((int)0xDEADBEEF));
Assert.Equal(hash, testString.SpookyHash32(unchecked ((int)0xDEADBEEF)));
Assert.Equal(hash, testString.SpookyHash32(0, len));
Assert.Equal(hash, testString.SpookyHash32());
Assert.Equal(HashCode128.Zero, default(string).SpookyHash128());
Assert.Equal(
HashCode128.Zero,
default(string).SpookyHash128(0, 200, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF));
Assert.Equal(
HashCode128.Zero,
unchecked (default(string).SpookyHash128(0, 200, (long)0xDEADBEEFDEADBEEF, (long)0xDEADBEEFDEADBEEF)));
Assert.Equal(HashCode128.Zero, default(string).SpookyHash128(0, 200));
Assert.Equal(
HashCode128.Zero,
default(string).SpookyHash128(50, 100, 0xDEADBEEFDEADBEEF, 0xDEADBEEFDEADBEEF));
Assert.Equal(0, default(string).SpookyHash64(0, 200, unchecked ((long)0xDEADBEEFDEADBEEF)));
Assert.Equal(0, default(string).SpookyHash64(unchecked ((long)0xDEADBEEFDEADBEEF)));
Assert.Equal(0, default(string).SpookyHash64(0, 200));
Assert.Equal(0, default(string).SpookyHash64());
Assert.Equal(0, default(string).SpookyHash32(0, 200, unchecked ((int)0xDEADBEEF)));
Assert.Equal(0, default(string).SpookyHash32(unchecked ((int)0xDEADBEEF)));
Assert.Equal(0, default(string).SpookyHash32(0, 200));
Assert.Equal(0, default(string).SpookyHash32());
}
public void CreateBlobWithInputBytes()
{
byte[] bytes = { 0, 1, 2, 3, 4 };
SpookyHash spookyHash = new SpookyHash();
BlobAllocator allocator = new BlobAllocator();
IBlob blob = allocator.CreateBlob(bytes);
Assert.AreEqual((ulong)5, blob.Length);
Assert.AreEqual(spookyHash.CalculateHash(bytes), blob.BlobId);
}
public unsafe void TestPieces()
{
byte[] bufArr = new byte[BufferSize];
for (int i = 0; i < BufferSize; ++i)
{
bufArr[i] = unchecked ((byte)i);
}
for (int i = 0; i < BufferSize; ++i)
{
ulong a, b, c, d, seed1 = 1, seed2 = 2;
SpookyHash state = new SpookyHash();
// all as one call
a = seed1;
b = seed2;
fixed(byte *buf = bufArr)
{
SpookyHash.Hash128(buf, i, ref a, ref b);
}
// all as one piece
c = 0xdeadbeefdeadbeef;
d = 0xbaceba11baceba11;
state.Init(seed1, seed2);
fixed(byte *buf = bufArr)
{
state.Update(buf, i);
}
state.Final(out c, out d);
Assert.Equal(a, c);
Assert.Equal(b, d);
for (int j = 0; j < i; ++j)
{
c = seed1;
d = seed2;
state.Init(c, d);
fixed(byte *buf = bufArr)
{
state.Update(buf, j);
state.Update(buf + j, i - j);
}
state.Final(out c, out d);
Assert.Equal(a, c);
Assert.Equal(b, d);
}
}
}
public void CreateBlobWithInputSubStream()
{
byte[] bytes = { 0, 1, 2, 3, 4 };
SpookyHash spookyHash = new SpookyHash();
using (MemoryStream ms = new MemoryStream(bytes))
{
BlobAllocator allocator = new BlobAllocator();
IBlob blob = allocator.CreateBlob(ms, 4);
Assert.AreEqual((ulong)4, blob.Length);
Assert.AreEqual(spookyHash.CalculateHash(new byte[] { 0, 1, 2, 3 }), blob.BlobId);
}
}
public void FinalsEquivalent()
{
SpookyHash sh = new SpookyHash();
sh.Update("abcdefg");
HashCode128 h128 = sh.Final();
sh.Final(out ulong u1, out ulong u2);
Assert.Equal(h128.UHash1, u1);
Assert.Equal(h128.UHash2, u2);
sh.Final(out long l1, out long l2);
Assert.Equal(h128.Hash1, l1);
Assert.Equal(h128.Hash2, l2);
}
public void Serialize()
{
SpookyHash sh = new SpookyHash();
sh.Update(MediumLengthString);
using (MemoryStream ms = new MemoryStream())
{
BinaryFormatter bf = new BinaryFormatter();
bf.Serialize(ms, sh);
ms.Seek(0, SeekOrigin.Begin);
SpookyHash copy = (SpookyHash)bf.Deserialize(ms);
Assert.Equal(sh.Final(), copy.Final());
}
}
public static Metadata BuildMeta(string saveFile)
{
byte[] raw = File.ReadAllBytes(saveFile);
var sha256 = ComputeHash(raw);
var spookyHash = new SpookyHash(96176015842230784UL, 9999999999999999999UL);
spookyHash.Update(sha256);
spookyHash.Update(raw);
spookyHash.Final(out ulong hash0, out ulong hash1);
return(new Metadata {
SHA256 = sha256, Hash = new ulong[] { hash0, hash1 }
});
}
public unsafe void RehashUInt()
{
foreach (uint seed in RandomUints(RandomCycleCount))
{
foreach (uint message in RandomUints(RandomCycleCount))
{
uint copy = message;
uint *p = ©
Assert.Equal(SpookyHash.Hash32(p, 4, seed), message.Rehash(seed));
}
}
foreach (uint message in RandomUints(RandomCycleCount))
{
uint copy = message;
uint *p = ©
Assert.Equal(SpookyHash.Hash32(p, 4, 0xDEADBEEF), message.Rehash());
}
}
public void SingleEmptyFileElement()
{
XElement definition = new XElement("Resources",
BuildFileElement(id: "ZeroByteFile", name: "ZeroByteFile.wopitest", filePath: "ZeroByteFile.wopitest")
);
IResourceManager resourceManager = new ResourceManagerFactory().GetResourceManager(definition);
SpookyHash spookyHash = new SpookyHash();
using (MemoryStream ms = new MemoryStream())
using (StreamWriter sw = new StreamWriter(ms))
{
sw.Write(String.Empty);
sw.Flush();
Assert.AreEqual(resourceManager.GetFileName("ZeroByteFile"), "ZeroByteFile.wopitest");
Assert.AreEqual(spookyHash.CalculateHash(resourceManager.GetContentStream("ZeroByteFile")), spookyHash.CalculateHash(ms));
}
}
public void SingleNonEmptyFileElement()
{
XElement definition = new XElement("Resources",
BuildFileElement(id: "WordBlankDocument", name: "WordBlankDocument.docx", filePath: "WordBlankDocument.docx")
);
IResourceManager resourceManager = new ResourceManagerFactory().GetResourceManager(definition);
SpookyHash spookyHash = new SpookyHash();
using (MemoryStream ms = new MemoryStream())
using (StreamWriter sw = new StreamWriter(ms))
{
sw.Write("WordBlankDocument" + "WordBlankDocument.docx" + "WordBlankDocument.docx");
sw.Flush();
Assert.AreEqual(resourceManager.GetFileName("WordBlankDocument"), "WordBlankDocument.docx");
Assert.AreEqual(spookyHash.CalculateHash(resourceManager.GetContentStream("WordBlankDocument")), spookyHash.CalculateHash(ms));
}
}
public unsafe void RehashULong()
{
foreach (ulong seed in RandomUlongs(RandomCycleCount))
{
foreach (ulong message in RandomUlongs(RandomCycleCount))
{
ulong copy = message;
ulong *p = ©
Assert.Equal(SpookyHash.Hash64(p, 8, seed), message.Rehash(seed));
}
}
foreach (ulong message in RandomUlongs(RandomCycleCount))
{
ulong copy = message;
ulong *p = ©
Assert.Equal(SpookyHash.Hash64(p, 8, 0xDEADBEEFDEADBEEF), message.Rehash());
}
}
public void CreateMemoryBlob_Succeed()
{
// Arrange
byte[] bytes = new byte[100000];
Random random = new Random((int)DateTime.Now.Millisecond);
random.NextBytes(bytes);
MemoryStream ms = new MemoryStream(bytes);
SpookyHash spookyHash = new SpookyHash();
// Act
MemoryBlob memoryBlob = new MemoryBlob(ms);
// Assert
Assert.IsNotNull(memoryBlob);
Assert.AreEqual((ulong)bytes.Length, memoryBlob.Length);
Assert.AreEqual(spookyHash.CalculateHash(ms), memoryBlob.BlobId);
ms.Dispose();
}
public void MemoryBlob_GetStream_Succeed()
{
// Arrange
byte[] bytes = new byte[1000];
Random random = new Random((int)DateTime.Now.Millisecond);
random.NextBytes(bytes);
MemoryStream ms = new MemoryStream(bytes);
SpookyHash spookyHash = new SpookyHash();
// Act
MemoryBlob memoryBlob = new MemoryBlob(ms);
Stream stream = memoryBlob.GetStream();
// Assert
Assert.IsNotNull(stream);
Assert.AreEqual(spookyHash.CalculateHash(bytes), spookyHash.CalculateHash(stream));
stream.Dispose();
ms.Dispose();
}
public unsafe void Hash32PtrOverloads()
{
uint seed = 238929482;
string testString = "This is a test string";
fixed(void *ptr = testString)
{
int len = testString.Length * 2;
uint hc = SpookyHash.Hash32(ptr, len, seed);
Assert.Equal(hc, SpookyHash.Hash32((UIntPtr)ptr, len, seed));
Assert.Equal((int)hc, SpookyHash.Hash32((UIntPtr)ptr, len, (int)seed));
Assert.Equal(hc, SpookyHash.Hash32((IntPtr)ptr, len, seed));
Assert.Equal((int)hc, SpookyHash.Hash32((IntPtr)ptr, len, (int)seed));
}
Assert.Equal(0U, SpookyHash.Hash32(UIntPtr.Zero, 50, seed));
Assert.Equal(0, SpookyHash.Hash32(UIntPtr.Zero, 50, (int)seed));
Assert.Equal(0U, SpookyHash.Hash32(IntPtr.Zero, 50, seed));
Assert.Equal(0, SpookyHash.Hash32(IntPtr.Zero, 50, (int)seed));
}
public unsafe void Hash64PtrOverloads()
{
ulong seed = 238929482;
string testString = "This is a test string";
fixed(void *ptr = testString)
{
int len = testString.Length * 2;
ulong hc = SpookyHash.Hash64(ptr, len, seed);
Assert.Equal(hc, SpookyHash.Hash64((UIntPtr)ptr, len, seed));
Assert.Equal((long)hc, SpookyHash.Hash64((UIntPtr)ptr, len, (long)seed));
Assert.Equal(hc, SpookyHash.Hash64((IntPtr)ptr, len, seed));
Assert.Equal((long)hc, SpookyHash.Hash64((IntPtr)ptr, len, (long)seed));
}
Assert.Equal(0UL, SpookyHash.Hash64(UIntPtr.Zero, 50, seed));
Assert.Equal(0L, SpookyHash.Hash64(UIntPtr.Zero, 50, (long)seed));
Assert.Equal(0UL, SpookyHash.Hash64(IntPtr.Zero, 50, seed));
Assert.Equal(0L, SpookyHash.Hash64(IntPtr.Zero, 50, (long)seed));
}
public static void TestHash(ref Metadata meta, string dataFile)
{
var data = File.ReadAllBytes(dataFile);
var dataSha256 = ComputeHash(data);
if (dataSha256 == null || meta.SHA256 == null || !meta.SHA256.SequenceEqual(dataSha256))
{
throw new Exception("Invalid SHA256 hash. Corrupt or wrong file?");
}
var spookyHash2 = new SpookyHash(96176015842230784UL, 9999999999999999999UL);
spookyHash2.Update(dataSha256);
spookyHash2.Update(data);
spookyHash2.Final(out ulong hash, out ulong hash2);
if (meta.Hash[0] != hash || meta.Hash[1] != hash2)
{
throw new Exception("Invalid SpookyHash. Corrupt or wrong file?");
}
}
public int GetHashCode(IList <T> list)
{
var hasher = new SpookyHash();//use methods with seeds if you need to prevent HashDos
foreach (var item in list)
{
hasher.Update(item.GetHashCode());//or relevant feeds of item, etc.
}
return(hasher.Final().GetHashCode());
/*
* int hash = list.Any()?0:9;
* unchecked
* {
* foreach (var o in list)
* {
* int code = o.ToInt32(CultureInfo.InvariantCulture);
* hash *= 251; // multiply by a prime number
* hash += code; // add next hash code
* }
* }
* return hash;
*/
}
public unsafe void RehashLong()
{
foreach (long seed in RandomLongs(RandomCycleCount))
{
foreach (long message in RandomLongs(RandomCycleCount))
{
long copy = message;
long *p = ©
unchecked
{
Assert.Equal((long)SpookyHash.Hash64(p, 8, (ulong)seed), message.Rehash(seed));
}
}
}
foreach (long message in RandomLongs(RandomCycleCount))
{
long copy = message;
long *p = ©
unchecked
{
Assert.Equal((long)SpookyHash.Hash64(p, 8, 0xDEADBEEFDEADBEEF), message.Rehash());
}
}
}
public unsafe void RehashInt()
{
foreach (int seed in RandomInts(RandomCycleCount))
{
foreach (int message in RandomInts(RandomCycleCount))
{
int copy = message;
int *p = ©
unchecked
{
Assert.Equal((int)SpookyHash.Hash32(p, 4, (uint)seed), message.Rehash(seed));
}
}
}
foreach (int message in RandomInts(RandomCycleCount))
{
int copy = message;
int *p = ©
unchecked
{
Assert.Equal((int)SpookyHash.Hash32(p, 4, 0xDEADBEEF), message.Rehash());
}
}
}
private BlockHasher(SpookyHash hasher)
{
_hasher = hasher;
}
