///////////////////////////////////////////////////////////////////////////////////////////////
//
//    This File is Part of the CallButler Open Source PBX (http://www.codeplex.com/callbutler
//
//    Copyright (c) 2005-2008, Jim Heising
//    All rights reserved.
//
//    Redistribution and use in source and binary forms, with or without modification,
//    are permitted provided that the following conditions are met:
//
//    * Redistributions of source code must retain the above copyright notice,
//      this list of conditions and the following disclaimer.
//
//    * Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions and the following disclaimer in the documentation and/or
//      other materials provided with the distribution.
//
//    * Neither the name of Jim Heising nor the names of its contributors may be
//      used to endorse or promote products derived from this software without specific prior
//      written permission.
//
//    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
//    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
//    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
//    IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
//    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
//    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
//    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
//    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
//    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
//    POSSIBILITY OF SUCH DAMAGE.
//
///////////////////////////////////////////////////////////////////////////////////////////////

using System;
using System.Security.Cryptography;
using System.Text;
using System.Globalization;
using System.IO;

namespace WOSI.Utilities
{
  /// <summary>
  /// Summary description for CryptoUtils.
  /// </summary>
  public class CryptoUtils
  {
    public static byte[] Encrypt(byte[] clearData, byte[] Key, byte[] IV) 
    { 
      // Create a MemoryStream to accept the encrypted bytes 
      MemoryStream ms = new MemoryStream(); 

      // Create a symmetric algorithm. 
      // We are going to use Rijndael because it is strong and
      // available on all platforms. 
      // You can use other algorithms, to do so substitute the
      // next line with something like 
      //      TripleDES alg = TripleDES.Create(); 
      Rijndael alg = Rijndael.Create(); 

      // Now set the key and the IV. 
      // We need the IV (Initialization Vector) because
      // the algorithm is operating in its default 
      // mode called CBC (Cipher Block Chaining).
      // The IV is XORed with the first block (8 byte) 
      // of the data before it is encrypted, and then each
      // encrypted block is XORed with the 
      // following block of plaintext.
      // This is done to make encryption more secure. 

      // There is also a mode called ECB which does not need an IV,
      // but it is much less secure. 
      alg.Key = Key; 
      alg.IV = IV; 

      // Create a CryptoStream through which we are going to be
      // pumping our data. 
      // CryptoStreamMode.Write means that we are going to be
      // writing data to the stream and the output will be written
      // in the MemoryStream we have provided. 
      CryptoStream cs = new CryptoStream(ms, 
        alg.CreateEncryptor(), CryptoStreamMode.Write); 

      // Write the data and make it do the encryption 
      cs.Write(clearData, 0, clearData.Length); 

      // Close the crypto stream (or do FlushFinalBlock). 
      // This will tell it that we have done our encryption and
      // there is no more data coming in, 
      // and it is now a good time to apply the padding and
      // finalize the encryption process. 
      cs.Close(); 

      // Now get the encrypted data from the MemoryStream.
      // Some people make a mistake of using GetBuffer() here,
      // which is not the right way. 
      byte[] encryptedData = ms.ToArray();

      return encryptedData; 
    } 


    // Encrypt a string into a string using a password 
    //    Uses Encrypt(byte[], byte[], byte[]) 

    public static string Encrypt(string clearText, string Password) 
    { 
      // First we need to turn the input string into a byte array. 
      byte[] clearBytes = 
        System.Text.Encoding.Unicode.GetBytes(clearText); 

      // Then, we need to turn the password into Key and IV 
      // We are using salt to make it harder to guess our key
      // using a dictionary attack - 
      // trying to guess a password by enumerating all possible words. 
      PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password, 
        new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 
                 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); 

      // Now get the key/IV and do the encryption using the
      // function that accepts byte arrays. 
      // Using PasswordDeriveBytes object we are first getting
      // 32 bytes for the Key 
      // (the default Rijndael key length is 256bit = 32bytes)
      // and then 16 bytes for the IV. 
      // IV should always be the block size, which is by default
      // 16 bytes (128 bit) for Rijndael. 
      // If you are using DES/TripleDES/RC2 the block size is
      // 8 bytes and so should be the IV size. 
      // You can also read KeySize/BlockSize properties off
      // the algorithm to find out the sizes. 
      byte[] encryptedData = Encrypt(clearBytes, 
        pdb.GetBytes(32), pdb.GetBytes(16)); 

      // Now we need to turn the resulting byte array into a string. 
      // A common mistake would be to use an Encoding class for that.
      //It does not work because not all byte values can be
      // represented by characters. 
      // We are going to be using Base64 encoding that is designed
      //exactly for what we are trying to do. 
      return Convert.ToBase64String(encryptedData); 

    }

    // Encrypt bytes into bytes using a password 
    //    Uses Encrypt(byte[], byte[], byte[]) 

    public static byte[] Encrypt(byte[] clearData, string Password) 
    { 
      // We need to turn the password into Key and IV. 
      // We are using salt to make it harder to guess our key
      // using a dictionary attack - 
      // trying to guess a password by enumerating all possible words. 
      PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password, 
        new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 
                 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); 

      // Now get the key/IV and do the encryption using the function
      // that accepts byte arrays. 
      // Using PasswordDeriveBytes object we are first getting
      // 32 bytes for the Key 
      // (the default Rijndael key length is 256bit = 32bytes)
      // and then 16 bytes for the IV. 
      // IV should always be the block size, which is by default
      // 16 bytes (128 bit) for Rijndael. 
      // If you are using DES/TripleDES/RC2 the block size is 8
      // bytes and so should be the IV size. 
      // You can also read KeySize/BlockSize properties off the
      // algorithm to find out the sizes. 
      return Encrypt(clearData, pdb.GetBytes(32), pdb.GetBytes(16)); 

    }

    // Encrypt a file into another file using a password 
    public static void Encrypt(string fileIn, 
      string fileOut, string Password) 
    { 

      // First we are going to open the file streams 
      FileStream fsIn = new FileStream(fileIn, 
        FileMode.Open, FileAccess.Read); 
      FileStream fsOut = new FileStream(fileOut, 
        FileMode.OpenOrCreate, FileAccess.Write); 

      // Then we are going to derive a Key and an IV from the
      // Password and create an algorithm 
      PasswordDeriveBytes pdb = new PasswordDeriveBytes(Password, 
        new byte[] {0x49, 0x76, 0x61, 0x6e, 0x20, 0x4d, 
                 0x65, 0x64, 0x76, 0x65, 0x64, 0x65, 0x76}); 

      Rijndael alg = Rijndael.Create(); 
      alg.Key = pdb.GetBytes(32); 
      alg.IV = pdb.GetBytes(16); 

      // Now create a crypto stream through which we are going
      // to be pumping data. 
      // Our fileOut is going to be receiving the encrypted bytes. 
      CryptoStream cs = new CryptoStream(fsOut, 
        alg.CreateEncryptor(), CryptoStreamMode.Write); 

      // Now will will initialize a buffer and will be processing
      // the input file in chunks. 
      // This is done to avoid reading the whole file (which can
      // be huge) into memory. 
      int bufferLen = 4096; 
      byte[] buffer = new byte[bufferLen]; 
      int bytesRead; 

      do 
      { 
        // read a chunk of data from the input file 
        bytesRead = fsIn.Read(buffer, 0, bufferLen); 

        // encrypt it 
        cs.Write(buffer, 0, bytesRead); 
      } while(bytesRead != 0); 

      // close everything 

      // this will also close the unrelying fsOut stream
      cs.Close(); 
      fsIn.Close();     
    } 
    }
}    

   
     

   
 
/* --------------------------------------------------------------------------
 *
 * License
 *
 * The contents of this file are subject to the Jabber Open Source License
 * Version 1.0 (the "License").  You may not copy or use this file, in either
 * source code or executable form, except in compliance with the License.  You
 * may obtain a copy of the License at http://www.jabber.com/license/ or at
 * http://www.opensource.org/.  
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * Copyrights
 * 
 * Portions created by or assigned to Cursive Systems, Inc. are 
 * Copyright (c) 2002 Cursive Systems, Inc.  All Rights Reserved.  Contact
 * information for Cursive Systems, Inc. is available at http://www.cursive.net/.
 *
 * Portions Copyright (c) 2002 Joe Hildebrand.
 * 
 * Acknowledgements
 * 
 * Special thanks to the Jabber Open Source Contributors for their
 * suggestions and support of Jabber.
 * 
 * --------------------------------------------------------------------------*/
using System;
using System.Security.Cryptography;
namespace bedrock.util
{
    /// <summary>
    /// Do CRC32 hashing.  Note: just use SHA1, or MD5, from System.Security.Cryptography.
    /// </summary>
    public class CRC32
    {
        private const int   WIDTH   = 32;
        private const ulong POLY    = 0x04C11DB7;
        private const ulong INIT    = 0xFFFFFFFF;
        private const ulong XOROUT  = 0xFFFFFFFF;
        private static readonly uint[] crctable = 
        {
            0x00000000,     0x77073096,     0xEE0E612C,     0x990951BA, 
            0x076DC419,     0x706AF48F,     0xE963A535,     0x9E6495A3, 
            0x0EDB8832,     0x79DCB8A4,     0xE0D5E91E,     0x97D2D988, 
            0x09B64C2B,     0x7EB17CBD,     0xE7B82D07,     0x90BF1D91, 
            0x1DB71064,     0x6AB020F2,     0xF3B97148,     0x84BE41DE, 
            0x1ADAD47D,     0x6DDDE4EB,     0xF4D4B551,     0x83D385C7, 
            0x136C9856,     0x646BA8C0,     0xFD62F97A,     0x8A65C9EC, 
            0x14015C4F,     0x63066CD9,     0xFA0F3D63,     0x8D080DF5, 
            0x3B6E20C8,     0x4C69105E,     0xD56041E4,     0xA2677172, 
            0x3C03E4D1,     0x4B04D447,     0xD20D85FD,     0xA50AB56B, 
            0x35B5A8FA,     0x42B2986C,     0xDBBBC9D6,     0xACBCF940, 
            0x32D86CE3,     0x45DF5C75,     0xDCD60DCF,     0xABD13D59, 
            0x26D930AC,     0x51DE003A,     0xC8D75180,     0xBFD06116, 
            0x21B4F4B5,     0x56B3C423,     0xCFBA9599,     0xB8BDA50F, 
            0x2802B89E,     0x5F058808,     0xC60CD9B2,     0xB10BE924, 
            0x2F6F7C87,     0x58684C11,     0xC1611DAB,     0xB6662D3D, 
            0x76DC4190,     0x01DB7106,     0x98D220BC,     0xEFD5102A, 
            0x71B18589,     0x06B6B51F,     0x9FBFE4A5,     0xE8B8D433, 
            0x7807C9A2,     0x0F00F934,     0x9609A88E,     0xE10E9818, 
            0x7F6A0DBB,     0x086D3D2D,     0x91646C97,     0xE6635C01, 
            0x6B6B51F4,     0x1C6C6162,     0x856530D8,     0xF262004E, 
            0x6C0695ED,     0x1B01A57B,     0x8208F4C1,     0xF50FC457, 
            0x65B0D9C6,     0x12B7E950,     0x8BBEB8EA,     0xFCB9887C, 
            0x62DD1DDF,     0x15DA2D49,     0x8CD37CF3,     0xFBD44C65, 
            0x4DB26158,     0x3AB551CE,     0xA3BC0074,     0xD4BB30E2, 
            0x4ADFA541,     0x3DD895D7,     0xA4D1C46D,     0xD3D6F4FB, 
            0x4369E96A,     0x346ED9FC,     0xAD678846,     0xDA60B8D0, 
            0x44042D73,     0x33031DE5,     0xAA0A4C5F,     0xDD0D7CC9, 
            0x5005713C,     0x270241AA,     0xBE0B1010,     0xC90C2086, 
            0x5768B525,     0x206F85B3,     0xB966D409,     0xCE61E49F, 
            0x5EDEF90E,     0x29D9C998,     0xB0D09822,     0xC7D7A8B4, 
            0x59B33D17,     0x2EB40D81,     0xB7BD5C3B,     0xC0BA6CAD, 
            0xEDB88320,     0x9ABFB3B6,     0x03B6E20C,     0x74B1D29A, 
            0xEAD54739,     0x9DD277AF,     0x04DB2615,     0x73DC1683, 
            0xE3630B12,     0x94643B84,     0x0D6D6A3E,     0x7A6A5AA8, 
            0xE40ECF0B,     0x9309FF9D,     0x0A00AE27,     0x7D079EB1, 
            0xF00F9344,     0x8708A3D2,     0x1E01F268,     0x6906C2FE, 
            0xF762575D,     0x806567CB,     0x196C3671,     0x6E6B06E7, 
            0xFED41B76,     0x89D32BE0,     0x10DA7A5A,     0x67DD4ACC, 
            0xF9B9DF6F,     0x8EBEEFF9,     0x17B7BE43,     0x60B08ED5, 
            0xD6D6A3E8,     0xA1D1937E,     0x38D8C2C4,     0x4FDFF252, 
            0xD1BB67F1,     0xA6BC5767,     0x3FB506DD,     0x48B2364B, 
            0xD80D2BDA,     0xAF0A1B4C,     0x36034AF6,     0x41047A60, 
            0xDF60EFC3,     0xA867DF55,     0x316E8EEF,     0x4669BE79, 
            0xCB61B38C,     0xBC66831A,     0x256FD2A0,     0x5268E236, 
            0xCC0C7795,     0xBB0B4703,     0x220216B9,     0x5505262F, 
            0xC5BA3BBE,     0xB2BD0B28,     0x2BB45A92,     0x5CB36A04, 
            0xC2D7FFA7,     0xB5D0CF31,     0x2CD99E8B,     0x5BDEAE1D, 
            0x9B64C2B0,     0xEC63F226,     0x756AA39C,     0x026D930A, 
            0x9C0906A9,     0xEB0E363F,     0x72076785,     0x05005713, 
            0x95BF4A82,     0xE2B87A14,     0x7BB12BAE,     0x0CB61B38, 
            0x92D28E9B,     0xE5D5BE0D,     0x7CDCEFB7,     0x0BDBDF21, 
            0x86D3D2D4,     0xF1D4E242,     0x68DDB3F8,     0x1FDA836E, 
            0x81BE16CD,     0xF6B9265B,     0x6FB077E1,     0x18B74777, 
            0x88085AE6,     0xFF0F6A70,     0x66063BCA,     0x11010B5C, 
            0x8F659EFF,     0xF862AE69,     0x616BFFD3,     0x166CCF45, 
            0xA00AE278,     0xD70DD2EE,     0x4E048354,     0x3903B3C2, 
            0xA7672661,     0xD06016F7,     0x4969474D,     0x3E6E77DB, 
            0xAED16A4A,     0xD9D65ADC,     0x40DF0B66,     0x37D83BF0, 
            0xA9BCAE53,     0xDEBB9EC5,     0x47B2CF7F,     0x30B5FFE9, 
            0xBDBDF21C,     0xCABAC28A,     0x53B39330,     0x24B4A3A6, 
            0xBAD03605,     0xCDD70693,     0x54DE5729,     0x23D967BF, 
            0xB3667A2E,     0xC4614AB8,     0x5D681B02,     0x2A6F2B94, 
            0xB40BBE37,     0xC30C8EA1,     0x5A05DF1B,     0x2D02EF8D
        };
        
        /// <summary>
        /// Hash a block of bytes.
        /// </summary>
        /// <param name="block"></param>
        /// <returns></returns>
        public static uint compute(byte[] block)
        {
            ulong c = INIT;
            int len = block.Length;
            int i = 0;
            while (len-- > 0)
            {
                c = crctable[(c ^ block[i++]) &amp; 0xFFL] ^ (c >> 8);
            }
            return (uint)(c ^ XOROUT);
        }
        /// <summary>
        /// Hash a string
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        public static uint compute(string s)
        {
            return compute(System.Text.Encoding.ASCII.GetBytes(s));
        }
    }
}

   
     

   
 
  
// Crc32.cs
//
// 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 computer CRC
// and another time to compress.
//
//
// Thu, 30 Mar 2006  13:58
// 

using System;

namespace ionic.utils.zip
{
  /// <summary>
  /// Calculates a 32bit Cyclic Redundancy Checksum (CRC) using the
  /// same polynomial used by Zip.
  /// </summary>
  public class CRC32
  {
    private UInt32[] crc32Table;
    private const int BUFFER_SIZE = 8192;

    private Int32 _TotalBytesRead = 0;
    public Int32 TotalBytesRead
    {
      get
      {
        return _TotalBytesRead;
      }
    }

    /// <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(System.IO.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(System.IO.Stream input, System.IO.Stream output)
    {
      unchecked
      {
        UInt32 crc32Result;
        crc32Result = 0xFFFFFFFF;
        byte[] 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)
        {
          for (int i = 0; i < count; i++)
          {
            crc32Result = ((crc32Result) >> 8) ^ crc32Table[(buffer[i]) ^ ((crc32Result) &amp; 0x000000FF)];
          }
          count = input.Read(buffer, 0, readSize);
          if (output != null) output.Write(buffer, 0, count);
          _TotalBytesRead += count;

        }

        return ~crc32Result;
      }
    }


    /// <summary>
    /// Construct an instance of the CRC32 class, pre-initialising the table
    /// for speed of lookup.
    /// </summary>
    public CRC32()
    {
      unchecked
      {
        // This is the official polynomial used by CRC32 in PKZip.
        // Often the polynomial is shown reversed as 0x04C11DB7.
        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 &amp; 1) == 1)
            {
              dwCrc = (dwCrc >> 1) ^ dwPolynomial;
            }
            else
            {
              dwCrc >>= 1;
            }
          }
          crc32Table[i] = dwCrc;
        }
      }
    }
  }
}

   
     

   
 
  
// CRC32.cs - Computes CRC32 data checksum of a data stream
// Copyright (C) 2001 Mike Krueger
//
// This file was translated from java, it was part of the GNU Classpath
// Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
//
// Linking this library statically or dynamically with other modules is
// making a combined work based on this library.  Thus, the terms and
// conditions of the GNU General Public License cover the whole
// combination.
// 
// As a special exception, the copyright holders of this library give you
// permission to link this library with independent modules to produce an
// executable, regardless of the license terms of these independent
// modules, and to copy and distribute the resulting executable under
// terms of your choice, provided that you also meet, for each linked
// independent module, the terms and conditions of the license of that
// module.  An independent module is a module which is not derived from
// or based on this library.  If you modify this library, you may extend
// this exception to your version of the library, but you are not
// obligated to do so.  If you do not wish to do so, delete this
// exception statement from your version.

using System;

namespace ICSharpCode.SharpZipLib.Checksums 
{
  
  /// <summary>
  /// Generate a table for a byte-wise 32-bit CRC calculation on the polynomial:
  /// x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1.
  ///
  /// Polynomials over GF(2) are represented in binary, one bit per coefficient,
  /// with the lowest powers in the most significant bit.  Then adding polynomials
  /// is just exclusive-or, and multiplying a polynomial by x is a right shift by
  /// one.  If we call the above polynomial p, and represent a byte as the
  /// polynomial q, also with the lowest power in the most significant bit (so the
  /// byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p,
  /// where a mod b means the remainder after dividing a by b.
  ///
  /// This calculation is done using the shift-register method of multiplying and
  /// taking the remainder.  The register is initialized to zero, and for each
  /// incoming bit, x^32 is added mod p to the register if the bit is a one (where
  /// x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by
  /// x (which is shifting right by one and adding x^32 mod p if the bit shifted
  /// out is a one).  We start with the highest power (least significant bit) of
  /// q and repeat for all eight bits of q.
  ///
  /// The table is simply the CRC of all possible eight bit values.  This is all
  /// the information needed to generate CRC&#039;s on data a byte at a time for all
  /// combinations of CRC register values and incoming bytes.
  /// </summary>
  public sealed class Crc32
  {
    const uint CrcSeed = 0xFFFFFFFF;
    
    readonly static uint[] CrcTable = new uint[] {
      0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419,
      0x706AF48F, 0xE963A535, 0x9E6495A3, 0x0EDB8832, 0x79DCB8A4,
      0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07,
      0x90BF1D91, 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
      0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, 0x136C9856,
      0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9,
      0xFA0F3D63, 0x8D080DF5, 0x3B6E20C8, 0x4C69105E, 0xD56041E4,
      0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
      0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3,
      0x45DF5C75, 0xDCD60DCF, 0xABD13D59, 0x26D930AC, 0x51DE003A,
      0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599,
      0xB8BDA50F, 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
      0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, 0x76DC4190,
      0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F,
      0x9FBFE4A5, 0xE8B8D433, 0x7807C9A2, 0x0F00F934, 0x9609A88E,
      0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
      0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED,
      0x1B01A57B, 0x8208F4C1, 0xF50FC457, 0x65B0D9C6, 0x12B7E950,
      0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3,
      0xFBD44C65, 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
      0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, 0x4369E96A,
      0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5,
      0xAA0A4C5F, 0xDD0D7CC9, 0x5005713C, 0x270241AA, 0xBE0B1010,
      0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
      0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17,
      0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, 0xEDB88320, 0x9ABFB3B6,
      0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615,
      0x73DC1683, 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
      0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, 0xF00F9344,
      0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB,
      0x196C3671, 0x6E6B06E7, 0xFED41B76, 0x89D32BE0, 0x10DA7A5A,
      0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
      0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1,
      0xA6BC5767, 0x3FB506DD, 0x48B2364B, 0xD80D2BDA, 0xAF0A1B4C,
      0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF,
      0x4669BE79, 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
      0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, 0xC5BA3BBE,
      0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31,
      0x2CD99E8B, 0x5BDEAE1D, 0x9B64C2B0, 0xEC63F226, 0x756AA39C,
      0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
      0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B,
      0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, 0x86D3D2D4, 0xF1D4E242,
      0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1,
      0x18B74777, 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
      0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, 0xA00AE278,
      0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7,
      0x4969474D, 0x3E6E77DB, 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66,
      0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
      0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605,
      0xCDD70693, 0x54DE5729, 0x23D967BF, 0xB3667A2E, 0xC4614AB8,
      0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B,
      0x2D02EF8D
    };
    
    internal static uint ComputeCrc32(uint oldCrc, byte value)
    {
      return (uint)(Crc32.CrcTable[(oldCrc ^ value) &amp; 0xFF] ^ (oldCrc >> 8));
    }
    
    /// <summary>
    /// The crc data checksum so far.
    /// </summary>
    uint crc;
    
    /// <summary>
    /// Returns the CRC32 data checksum computed so far.
    /// </summary>
    public long Value {
      get {
        return (long)crc;
      }
      set {
        crc = (uint)value;
      }
    }
    
    /// <summary>
    /// Resets the CRC32 data checksum as if no update was ever called.
    /// </summary>
    public void Reset() 
    { 
      crc = 0; 
    }
    
    /// <summary>
    /// Updates the checksum with the int bval.
    /// </summary>
    /// <param name = "value">
    /// the byte is taken as the lower 8 bits of value
    /// </param>
    public void Update(int value)
    {
      crc ^= CrcSeed;
      crc  = CrcTable[(crc ^ value) &amp; 0xFF] ^ (crc >> 8);
      crc ^= CrcSeed;
    }
    
    /// <summary>
    /// Updates the checksum with the bytes taken from the array.
    /// </summary>
    /// <param name="buffer">
    /// buffer an array of bytes
    /// </param>
    public void Update(byte[] buffer)
    {
      if (buffer == null) {
        throw new ArgumentNullException("buffer");
      }
      
      Update(buffer, 0, buffer.Length);
    }
    
    /// <summary>
    /// Adds the byte array to the data checksum.
    /// </summary>
    /// <param name = "buffer">
    /// The buffer which contains the data
    /// </param>
    /// <param name = "offset">
    /// The offset in the buffer where the data starts
    /// </param>
    /// <param name = "count">
    /// The number of data bytes to update the CRC with.
    /// </param>
    public void Update(byte[] buffer, int offset, int count)
    {
      if (buffer == null) {
        throw new ArgumentNullException("buffer");
      }
      
      if ( count < 0 ) {
#if NETCF_1_0
        throw new ArgumentOutOfRangeException("count");
#else
        throw new ArgumentOutOfRangeException("count", "Count cannot be less than zero");
#endif        
      }
      
      if (offset < 0 || offset + count > buffer.Length) {
        throw new ArgumentOutOfRangeException("offset");
      }
      
      crc ^= CrcSeed;
      
      while (--count >= 0) {
        crc = CrcTable[(crc ^ buffer[offset++]) &amp; 0xFF] ^ (crc >> 8);
      }
      
      crc ^= CrcSeed;
    }
  }
}

   
     

   
 
// HtmlAgilityPack V1.0 - Simon Mourier <simon underscore mourier at hotmail dot com>
using System;
using System.IO;

namespace HtmlAgilityPack
{
  /// <summary>
  /// A utility class to compute CRC32.
  /// </summary>
  public class Crc32
  {
    private uint _crc32 = 0;
    static private uint[] crc_32_tab =  // CRC polynomial 0xedb88320 
      {
        0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f,
        0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988,
        0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2,
        0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
        0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
        0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172,
        0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c,
        0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
        0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423,
        0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
        0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106,
        0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433,
        0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d,
        0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e,
        0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
        0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
        0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7,
        0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0,
        0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa,
        0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
        0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81,
        0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a,
        0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84,
        0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
        0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
        0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc,
        0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e,
        0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b,
        0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55,
        0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
        0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28,
        0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
        0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f,
        0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38,
        0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
        0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
        0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69,
        0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2,
        0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc,
        0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
        0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693,
        0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94,
        0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d 
      };      

    static private uint UPDC32(byte octet, uint crc)
    {
      return (crc_32_tab[((crc)^((byte)octet)) &amp; 0xff] ^ ((crc) >> 8));
    }

    internal uint CheckSum
    {
      get
      {
        return _crc32;
      }
      set
      {
        _crc32 = value;
      }
    }

    internal uint AddToCRC32(int c)
    {
      return AddToCRC32((ushort)c);
    }

    internal uint AddToCRC32(ushort c)
    {
      byte lowByte, hiByte;
      lowByte = (byte)(c &amp; 0x00ff);
      hiByte = (byte)(c >> 8);
      _crc32 = UPDC32(hiByte, _crc32);
      _crc32 = UPDC32(lowByte, _crc32);
      return ~_crc32;
    }

    /// <summary>
    /// Compute a checksum for a given string.
    /// </summary>
    /// <param name="text">The string to compute the checksum for.</param>
    /// <returns>The computed checksum.</returns>
    static public uint CRC32String(string text)
    {
      uint oldcrc32;
      oldcrc32 = 0xFFFFFFFF;        
      int len = text.Length;
      ushort uCharVal;
      byte lowByte, hiByte;
        
      for ( int i=0; len>0; i++)
      {
        --len;
        uCharVal = text[len];
        unchecked
        {
          lowByte = (byte)(uCharVal &amp; 0x00ff);
          hiByte = (byte)(uCharVal >> 8);
        }
        oldcrc32 = UPDC32(hiByte, oldcrc32);
        oldcrc32 = UPDC32(lowByte, oldcrc32);
      }

      return ~oldcrc32;
    }

    /// <summary>
    /// Compute a checksum for a given array of bytes.
    /// </summary>
    /// <param name="bytes">The array of bytes to compute the checksum for.</param>
    /// <returns>The computed checksum.</returns>
    static public uint CRC32Bytes(byte[] bytes)
    {
      uint oldcrc32;
      oldcrc32 = 0xFFFFFFFF;        
      int len = bytes.Length;
        
      for ( int i=0; len>0; i++)
      {
        --len;
        oldcrc32 = UPDC32(bytes[len], oldcrc32);
      }
      return ~oldcrc32;
    }
  }
}

   
     

   
 
   
// --------------------------------------------------------------------------------------------------------------------
// <copyright file="Crc32.cs" company="kalkie">
//   Patrick Kalkman pkalkie@gmail.com
// </copyright>
// <summary>
//   This class is responsible for calculating the crc32 value of a byte
//   buffer and returning it as a hexadecimal string.
// </summary>
// --------------------------------------------------------------------------------------------------------------------

namespace BinarySeeder.Engine
{
   using System.Globalization;

   /// <summary>
   /// This class is responsible for calculating the crc32 value of a byte
   /// buffer and returning it as a hexadecimal string.
   /// </summary>
   internal class Crc32 
   {
      /// <summary>
      /// Crc32 lookup table generated with polynomial 0xEDB88320.
      /// </summary>
      private readonly uint[] crc32Table = new uint[] 
      {
         0x00000000, 
         0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 
         0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 
         0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 
         0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 
         0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 
         0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 
         0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 
         0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 
         0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 
         0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 
         0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 
         0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 
         0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 
         0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 
         0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 
         0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 
         0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 
         0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 
         0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 
         0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 
         0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 
         0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 
         0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 
         0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 
         0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 
         0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
      };

      /// <summary>
      /// Calculates the CRC32 value of the given buffer.
      /// </summary>
      /// <param name="buffer">The buffer of which the crc32 must be calculated.</param>
      /// <returns>The calculated crc32 value as a hex string.</returns>
      internal virtual string CalculateCrc32(byte[] buffer)
      {
         uint calculatedCrc = 0xFFFFFFFF;

         foreach (byte byteToCalculate in buffer)
         {
            calculatedCrc = (calculatedCrc >> 8) ^ crc32Table[byteToCalculate ^ (calculatedCrc &amp; 0x000000FF)];
         }

         return (~calculatedCrc).ToString("X8", CultureInfo.InvariantCulture);
      }
   }
}

   
     

   
 

// crudwork
// Copyright 2004 by Steve T. Pham (http://www.crudwork.com)
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with This program.  If not, see <http://www.gnu.org/licenses/>.

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace crudwork.Utilities
{
  /// <summary>
  /// Math Utility
  /// </summary>
  public static class MathUtil
  {
    /// <summary>
    /// Return the checksum of the buffer
    /// </summary>
    /// <param name="buffer"></param>
    /// <returns></returns>
    public static long ComputeChecksum(byte[] buffer)
    {
      return ComputeChecksum(buffer, 0);
    }

    /// <summary>
    /// Return the checksum of the buffer at the given offset
    /// </summary>
    /// <param name="buffer"></param>
    /// <param name="offset"></param>
    /// <returns></returns>
    public static long ComputeChecksum(byte[] buffer, int offset)
    {
      long sum = 0;
      for (int i = 0; i < buffer.Length; i++)
      {
        sum += buffer&#91;i&#93; * (i + 1 + offset);
      }
      return sum;
    }

    /// <summary>
    /// Return the checksum value of the given filename
    /// </summary>
    /// <param name="filename"></param>
    /// <returns></returns>
    public static long ComputeChecksum(string filename)
    {
      //byte[] buffer = FileUtil.ReadFile(filename, 4096);
      //return ComputeChecksum(buffer);

      long sum = 0;
      int bufSize = 4096;

      using (FileStream fs = new FileStream(filename, FileMode.Open, FileAccess.Read))
      using (BinaryReader r = new BinaryReader(fs))
      {
        byte[] readChar = null;
        int offset = 0;
        
        do
        {
          readChar = r.ReadBytes(bufSize);
          sum += ComputeChecksum(readChar, offset);
          offset += readChar.Length;
        } while ((readChar != null) &amp;&amp; (readChar.Length > 0));

        r.Close();
        //fs.Close();
      }

      return sum;
    }
  }
}