123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293 |
- // Crc32.cs
- // ------------------------------------------------------------------
- //
- // Copyright (c) 2006-2009 Dino Chiesa and Microsoft Corporation.
- // All rights reserved.
- //
- // This code module is part of DotNetZip, a zipfile class library.
- //
- // ------------------------------------------------------------------
- //
- // This code is licensed under the Microsoft Public License.
- // See the file License.txt for the license details.
- // More info on: http://dotnetzip.codeplex.com
- //
- // ------------------------------------------------------------------
- //
- // last saved (in emacs):
- // Time-stamp: <2010-January-16 13:16:27>
- //
- // ------------------------------------------------------------------
- //
- // Implements the CRC algorithm, which is used in zip files. The zip format calls for
- // the zipfile to contain a CRC for the unencrypted byte stream of each file.
- //
- // It is based on example source code published at
- // http://www.vbaccelerator.com/home/net/code/libraries/CRC32/Crc32_zip_CRC32_CRC32_cs.asp
- //
- // This implementation adds a tweak of that code for use within zip creation. While
- // computing the CRC we also compress the byte stream, in the same read loop. This
- // avoids the need to read through the uncompressed stream twice - once to compute CRC
- // and another time to compress.
- //
- // ------------------------------------------------------------------
- using System;
- using System.IO;
- namespace SharpCompress.Compressors.Deflate
- {
- /// <summary>
- /// Calculates a 32bit Cyclic Redundancy Checksum (CRC) using the same polynomial
- /// used by Zip. This type is used internally by DotNetZip; it is generally not used
- /// directly by applications wishing to create, read, or manipulate zip archive
- /// files.
- /// </summary>
- internal class CRC32
- {
- private const int BUFFER_SIZE = 8192;
- private static readonly UInt32[] crc32Table;
- private UInt32 runningCrc32Result = 0xFFFFFFFF;
- static CRC32()
- {
- unchecked
- {
- // PKZip specifies CRC32 with a polynomial of 0xEDB88320;
- // This is also the CRC-32 polynomial used bby Ethernet, FDDI,
- // bzip2, gzip, and others.
- // Often the polynomial is shown reversed as 0x04C11DB7.
- // For more details, see http://en.wikipedia.org/wiki/Cyclic_redundancy_check
- UInt32 dwPolynomial = 0xEDB88320;
- UInt32 i, j;
- crc32Table = new UInt32[256];
- UInt32 dwCrc;
- for (i = 0; i < 256; i++)
- {
- dwCrc = i;
- for (j = 8; j > 0; j--)
- {
- if ((dwCrc & 1) == 1)
- {
- dwCrc = (dwCrc >> 1) ^ dwPolynomial;
- }
- else
- {
- dwCrc >>= 1;
- }
- }
- crc32Table[i] = dwCrc;
- }
- }
- }
- /// <summary>
- /// indicates the total number of bytes read on the CRC stream.
- /// This is used when writing the ZipDirEntry when compressing files.
- /// </summary>
- public Int64 TotalBytesRead { get; private set; }
- /// <summary>
- /// Indicates the current CRC for all blocks slurped in.
- /// </summary>
- public Int32 Crc32Result => unchecked((Int32)(~runningCrc32Result));
- /// <summary>
- /// Returns the CRC32 for the specified stream.
- /// </summary>
- /// <param name="input">The stream over which to calculate the CRC32</param>
- /// <returns>the CRC32 calculation</returns>
- public UInt32 GetCrc32(Stream input)
- {
- return GetCrc32AndCopy(input, null);
- }
- /// <summary>
- /// Returns the CRC32 for the specified stream, and writes the input into the
- /// output stream.
- /// </summary>
- /// <param name="input">The stream over which to calculate the CRC32</param>
- /// <param name="output">The stream into which to deflate the input</param>
- /// <returns>the CRC32 calculation</returns>
- public UInt32 GetCrc32AndCopy(Stream input, Stream output)
- {
- if (input == null)
- {
- throw new ZlibException("The input stream must not be null.");
- }
- unchecked
- {
- //UInt32 crc32Result;
- //crc32Result = 0xFFFFFFFF;
- var buffer = new byte[BUFFER_SIZE];
- int readSize = BUFFER_SIZE;
- TotalBytesRead = 0;
- int count = input.Read(buffer, 0, readSize);
- if (output != null)
- {
- output.Write(buffer, 0, count);
- }
- TotalBytesRead += count;
- while (count > 0)
- {
- SlurpBlock(buffer, 0, count);
- count = input.Read(buffer, 0, readSize);
- if (output != null)
- {
- output.Write(buffer, 0, count);
- }
- TotalBytesRead += count;
- }
- return ~runningCrc32Result;
- }
- }
- /// <summary>
- /// Get the CRC32 for the given (word,byte) combo. This is a computation
- /// defined by PKzip.
- /// </summary>
- /// <param name="W">The word to start with.</param>
- /// <param name="B">The byte to combine it with.</param>
- /// <returns>The CRC-ized result.</returns>
- public Int32 ComputeCrc32(Int32 W, byte B)
- {
- return _InternalComputeCrc32((UInt32)W, B);
- }
- internal Int32 _InternalComputeCrc32(UInt32 W, byte B)
- {
- return (Int32)(crc32Table[(W ^ B) & 0xFF] ^ (W >> 8));
- }
- /// <summary>
- /// Update the value for the running CRC32 using the given block of bytes.
- /// This is useful when using the CRC32() class in a Stream.
- /// </summary>
- /// <param name="block">block of bytes to slurp</param>
- /// <param name="offset">starting point in the block</param>
- /// <param name="count">how many bytes within the block to slurp</param>
- public void SlurpBlock(byte[] block, int offset, int count)
- {
- if (block == null)
- {
- throw new ZlibException("The data buffer must not be null.");
- }
- for (int i = 0; i < count; i++)
- {
- int x = offset + i;
- runningCrc32Result = ((runningCrc32Result) >> 8) ^
- crc32Table[(block[x]) ^ ((runningCrc32Result) & 0x000000FF)];
- }
- TotalBytesRead += count;
- }
- // pre-initialize the crc table for speed of lookup.
- private uint gf2_matrix_times(uint[] matrix, uint vec)
- {
- uint sum = 0;
- int i = 0;
- while (vec != 0)
- {
- if ((vec & 0x01) == 0x01)
- {
- sum ^= matrix[i];
- }
- vec >>= 1;
- i++;
- }
- return sum;
- }
- private void gf2_matrix_square(uint[] square, uint[] mat)
- {
- for (int i = 0; i < 32; i++)
- {
- square[i] = gf2_matrix_times(mat, mat[i]);
- }
- }
- /// <summary>
- /// Combines the given CRC32 value with the current running total.
- /// </summary>
- /// <remarks>
- /// This is useful when using a divide-and-conquer approach to calculating a CRC.
- /// Multiple threads can each calculate a CRC32 on a segment of the data, and then
- /// combine the individual CRC32 values at the end.
- /// </remarks>
- /// <param name="crc">the crc value to be combined with this one</param>
- /// <param name="length">the length of data the CRC value was calculated on</param>
- public void Combine(int crc, int length)
- {
- var even = new uint[32]; // even-power-of-two zeros operator
- var odd = new uint[32]; // odd-power-of-two zeros operator
- if (length == 0)
- {
- return;
- }
- uint crc1 = ~runningCrc32Result;
- var crc2 = (uint)crc;
- // put operator for one zero bit in odd
- odd[0] = 0xEDB88320; // the CRC-32 polynomial
- uint row = 1;
- for (int i = 1; i < 32; i++)
- {
- odd[i] = row;
- row <<= 1;
- }
- // put operator for two zero bits in even
- gf2_matrix_square(even, odd);
- // put operator for four zero bits in odd
- gf2_matrix_square(odd, even);
- var len2 = (uint)length;
- // apply len2 zeros to crc1 (first square will put the operator for one
- // zero byte, eight zero bits, in even)
- do
- {
- // apply zeros operator for this bit of len2
- gf2_matrix_square(even, odd);
- if ((len2 & 1) == 1)
- {
- crc1 = gf2_matrix_times(even, crc1);
- }
- len2 >>= 1;
- if (len2 == 0)
- {
- break;
- }
- // another iteration of the loop with odd and even swapped
- gf2_matrix_square(odd, even);
- if ((len2 & 1) == 1)
- {
- crc1 = gf2_matrix_times(odd, crc1);
- }
- len2 >>= 1;
- }
- while (len2 != 0);
- crc1 ^= crc2;
- runningCrc32Result = ~crc1;
- //return (int) crc1;
- }
- // private member vars
- }
- }
|