Crc32.cs

// Copyright (c) Damien Guard.  All rights reserved.
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. 
// You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
// Originally published at http://damieng.com/blog/2006/08/08/calculating_crc32_in_c_and_net
// Copied and adapted from Github https://github.com/damieng/DamienGKit/blob/master/CSharp/DamienG.Library/Security/Cryptography/Crc32.cs commit 3feb70c0ce

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;

namespace DamienG.Security.Cryptography
{
	/// <summary>
	/// Implements a 32-bit CRC hash algorithm compatible with Zip etc.
	/// </summary>
	/// <remarks>
	/// Crc32 should only be used for backward compatibility with older file formats
	/// and algorithms. It is not secure enough for new applications.
	/// If you need to call multiple times for the same data either use the HashAlgorithm
	/// interface or remember that the result of one Compute call needs to be ~ (XOR) before
	/// being passed in as the seed for the next Compute call.
	/// </remarks>
	public sealed class Crc32 : HashAlgorithm
	{
		public const uint DefaultPolynomial = 0xedb88320u;
		public const uint DefaultSeed = 0xffffffffu;

		private static uint[] _defaultTable;

		private readonly uint _seed;
		private readonly uint[] _table;
		private uint _hash;

		public Crc32()
			: this(DefaultPolynomial, DefaultSeed)
		{
		}

		public Crc32(uint polynomial, uint seed)
		{
			_table = InitializeTable(polynomial);
			this._seed = _hash = seed;
		}

		public override void Initialize()
		{
			_hash = _seed;
		}

		protected override void HashCore(byte[] array, int ibStart, int cbSize)
		{
			_hash = CalculateHash(_table, _hash, array, ibStart, cbSize);
		}

		protected override byte[] HashFinal()
		{
			var hashBuffer = UInt32ToBigEndianBytes(~_hash);
			return hashBuffer;
		}

		public override int HashSize { get { return 32; } }

		public static uint Compute(byte[] buffer)
		{
			return Compute(DefaultSeed, buffer);
		}

		public static uint Compute(uint seed, byte[] buffer)
		{
			return Compute(DefaultPolynomial, seed, buffer);
		}

		public static uint Compute(uint polynomial, uint seed, byte[] buffer)
		{
			return ~CalculateHash(InitializeTable(polynomial), seed, buffer, 0, buffer.Length);
		}

		private static uint[] InitializeTable(uint polynomial)
		{
			if (polynomial == DefaultPolynomial && _defaultTable != null)
			{
				return _defaultTable;
			}

			var createTable = new uint[256];
			for (var i = 0; i < 256; i++)
			{
				var entry = (uint)i;
				for (var j = 0; j < 8; j++)
				{
					entry = (entry & 1) == 1 ? (entry >> 1) ^ polynomial : entry >> 1;
				}
				createTable[i] = entry;
			}

			if (polynomial == DefaultPolynomial)
				_defaultTable = createTable;

			return createTable;
		}

		private static uint CalculateHash(uint[] table, uint seed, IList<byte> buffer, int start, int size)
		{
			var hash = seed;
			for (var i = start; i < start + size; i++)
				hash = (hash >> 8) ^ table[buffer[i] ^ hash & 0xff];
			return hash;
		}

		private static byte[] UInt32ToBigEndianBytes(uint uint32)
		{
			var result = BitConverter.GetBytes(uint32);

			if (BitConverter.IsLittleEndian)
				Array.Reverse(result);

			return result;
		}
	}
}