Вирусоустойчивость. Проверка CRC суммы программы.

unsigned int CRC16(int Count,char *Ptr)
{
unsigned int Data;
int CRC=0xffff;
 
while(Count)
  {  
  Data=*Ptr;
  CRC^=Data;
  for(int j=0;j<8;j++) // побитная обработка
     {
      if(CRC&1)
         {
         CRC>>=1;
         CRC^=0xa001;
         }
      else CRC>>=1;
     }
Ptr++;
Count--;
   }
return CRC;
}

/****************************************************************************
CRC_32.h : header file for the CRC_32 class
written by PJ Arends
[email]pja@telus.net[/email]
 
based on the CRC-32 code found at
[url]http://www.createwindow.com/programming/crc32/crcfile.htm[/url]
 
For updates check [url]http://www3.telus.net/pja/crc32.htm[/url]
 
-----------------------------------------------------------------------------
This code is provided as is, with no warranty as to it's suitability or usefulness
in any application in which it may be used. This code has not been tested for
UNICODE builds, nor has it been tested on a network ( with UNC paths ).
 
This code may be used in any way you desire. This file may be redistributed by any
means as long as it is not sold for profit, and providing that this notice and the
authors name are included.
 
If any bugs are found and fixed, a note to the author explaining the problem and
fix would be nice.
-----------------------------------------------------------------------------
*************************************************************************** */
 
#ifndef _CRC_32_H_EA6C0EE0_BC30_11d5_B625_A58C4DF45B22_INCLUDED
#define _CRC_32_H_EA6C0EE0_BC30_11d5_B625_A58C4DF45B22_INCLUDED
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
#ifndef _WINDOWS_
#include <windows.h>
#endif // _WINDOWS_
 
#define WM_CRC_THREAD_DONE WM_APP + 0x2DB1
 
class CRC_32
{
    typedef struct tag_CRCStruct
    {
        CRC_32 *pCRC_32;
        TCHAR FileName[_MAX_PATH];
        LPBYTE pByte;
        UINT size;
        HWND hWnd;
        HANDLE Thread;
    } CRCStruct, *LPCRCStruct;
 
public:
    CRC_32();
    DWORD CalcCRC(LPCTSTR FileName, HWND ProgressWnd = NULL);
    DWORD CalcCRC(LPVOID buffer, UINT size, HWND ProgressWnd = NULL);
 
private:
    static DWORD WINAPI CRC32ThreadProc(LPVOID lpVoid);
    void Calculate (const LPBYTE buffer, UINT size, ULONG &crc);
    ULONG Reflect(ULONG ref, char ch);
    ULONG Table[256];
};
 
#endif // _CRC_32_H_EA6C0EE0_BC30_11d5_B625_A58C4DF45B22_INCLUDED
 
/////////////////////////////////////////////////////////////////////////////
//
//  End of CRC_32.h
//
/////////////////////////////////////////////////////////////////////////////

  /****************************************************************************
  CRC_32.cpp : implementation file for the CRC_32 class
  written by PJ Arends
  [email]pja@telus.net[/email]
  
  based on the CRC-32 code found at
  [url]http://www.createwindow.com/programming/crc32/crcfile.htm[/url]
  
  For updates check [url]http://www3.telus.net/pja/crc32.htm[/url]
  
  -----------------------------------------------------------------------------
  This code is provided as is, with no warranty as to it's suitability or usefulness
  in any application in which it may be used. This code has not been tested for
  UNICODE builds, nor has it been tested on a network ( with UNC paths ).
  
  This code may be used in any way you desire. This file may be redistributed by any
  means as long as it is not sold for profit, and providing that this notice and the
  authors name are included.
  
  If any bugs are found and fixed, a note to the author explaining the problem and
  fix would be nice.
  -----------------------------------------------------------------------------
  
  created : October 2001
        
  Revision History:
  
  October 11, 2001   - changed SendMessage to PostMessage in CRC32ThreadProc
  
  ****************************************************************************/
  
  #include "CRC_32.h"
  #include <io.h>         // _close(), _read()
  #include <fcntl.h>      // _O_* flags
  #include <share.h>      // _SH_DENYWR
  #include <tchar.h>      // UNICODE compatibility
  #include <commctrl.h>   // PBM_* progress bar messages
  
  // use a 100 KB buffer (a larger buffer does not seem to run
  // significantly faster, but takes more RAM)
  #define BUFFERSIZE 102400
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  CRC_32::CRC32ThreadProc  (static private member function)
  //    Calculates the CRC-32 value for a file or data buffer.
  //
  //  Parameters :
  //    lpVoid [in] : A pointer to a CRCStruct structure, type casted as a void pointer
  //
  //  Returns :
  //    The CRC-32 value of the supplied buffer or file
  //
  //  Note :
  //    If this function is started as a thread, it will send PBM_* messages to the supplied
  //    progress bar control. When the thread is finished, this function will send a 
  //    WM_CRC_THREAD_DONE message to the parent window of the progress bar. the WPARAM parameter
  //    will contain the HANDLE of the thread, and the LPARAM will contain the CRC-32 value
  //    of the supplied buffer or file.
  //
  /////////////////////////////////////////////////////////////////////////////
  
  DWORD WINAPI CRC_32::CRC32ThreadProc(LPVOID lpVoid)
  {
      LPCRCStruct pCRCSt = (LPCRCStruct)lpVoid;
      ULONG CRC = 0xFFFFFFFF;
      HWND Progress = NULL;
      if (::IsWindow(pCRCSt->hWnd))
      {   // setup the progress bar
          Progress = pCRCSt->hWnd;
          ::PostMessage(Progress, PBM_SETPOS, 0, 0);
          ::PostMessage(Progress, PBM_SETRANGE32, 0, 100);
      }
      if (pCRCSt->pByte)
      {   // calculate CRC for a buffer
          for (UINT offset = 0; offset < pCRCSt->size; offset += BUFFERSIZE)
          {
              pCRCSt->pCRC_32->Calculate(pCRCSt->pByte + offset,
                                         (pCRCSt->size - offset > BUFFERSIZE) ? BUFFERSIZE : (pCRCSt->size - offset),
                                         CRC);
              if(::IsWindow(Progress))
              {
                  int percent = offset > pCRCSt->size ? 100 : (int)(((double)offset / (double)pCRCSt->size) * 100);
                  ::PostMessage(Progress, PBM_SETPOS, percent, 0);
              }
          }
      }
      else if (pCRCSt->FileName)
      {   // calculate CRC for a file
          LONGLONG done = 0;
          UINT size = BUFFERSIZE;
          BYTE buffer[BUFFERSIZE];
  
          // Open the file
          int theFile = _tsopen(pCRCSt->FileName, _O_RDONLY | _O_SEQUENTIAL | _O_BINARY, _SH_DENYWR);
          if (theFile != -1)
          {   // Get the file size
              _lseeki64(theFile, 0L, SEEK_SET);
              LONGLONG length = _lseeki64(theFile, 0L, SEEK_END);
              _lseeki64(theFile, 0L, SEEK_SET);
          
              // process the file
              while (size == BUFFERSIZE)
              {
                  size = _read(theFile, buffer, BUFFERSIZE);
                  if (size)
                  {
                      pCRCSt->pCRC_32->Calculate(buffer, size, CRC);
                      if (::IsWindow(Progress))
                      {   // update the progress bar
                          done += size;
                          int percent = (int)(((long double)done / (long double)length) * 100);
                          ::PostMessage(Progress, PBM_SETPOS, percent, 0);
                      }
                  }
              }
              _close(theFile);
          }
      }
  
      CRC ^= 0xFFFFFFFF;
      
      if(IsWindow(Progress))
          // notify dialog that we are done
          ::PostMessage(::GetParent(Progress), WM_CRC_THREAD_DONE, (WPARAM)pCRCSt->Thread, CRC);
      
      // clean up
      // Known Problem : If the thread is prematurely terminated,
      // this cleanup code is never run, resulting in a memory leak.
      delete pCRCSt->pByte;
      delete pCRCSt;
  
      // return our CRC-32 value
      return CRC;
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  CRC_32 constructor  (public member function)
  //    Sets up the CRC-32 reference table
  //
  //  Parameters :
  //    None
  //
  //  Returns :
  //    Nothing
  //
  /////////////////////////////////////////////////////////////////////////////
  
  CRC_32::CRC_32()
  {
      // This is the official polynomial used by CRC-32 
      // in PKZip, WinZip and Ethernet. 
      ULONG ulPolynomial = 0x04C11DB7;
  
      // 256 values representing ASCII character codes.
      for (int i = 0; i <= 0xFF; i++)
      {
          Table[i] = Reflect(i, 8) << 24;
          for (int j = 0; j < 8; j++)
              Table[i] = (Table[i] << 1) ^ (Table[i] & (1 << 31) ? ulPolynomial : 0);
          Table[i] = Reflect(Table[i], 32);
      }
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  CRC_32::Reflect  (private member function)
  //    used by the constructor to help set up the CRC-32 reference table
  //
  //  Parameters :
  //    ref [in] : the value to be reflected
  //    ch  [in] : the number of bits to move
  //
  //  Returns :
  //    the new value
  //
  /////////////////////////////////////////////////////////////////////////////
  
  ULONG CRC_32::Reflect(ULONG ref, char ch)
  {
      ULONG value = 0;
  
      // Swap bit 0 for bit 7
      // bit 1 for bit 6, etc.
      for(int i = 1; i < (ch + 1); i++)
      {
          if (ref & 1)
              value |= 1 << (ch - i);
          ref >>= 1;
      }
      return value;
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  CRC_32::Calculate  (private member function)
  //    Calculates the CRC-32 value for the given buffer
  //
  //  Parameters :
  //    buffer [in] : pointer to the data bytes
  //    size   [in] : the size of the buffer
  //    CRC    [in] : the initial CRC-32 value
  //          [out] : the new CRC-32 value
  //
  //  Returns :
  //    Nothing
  //
  /////////////////////////////////////////////////////////////////////////////
  
  void CRC_32::Calculate(const LPBYTE buffer, UINT size, ULONG &CRC)
  {   // calculate the CRC
      LPBYTE pbyte = buffer;
  
      while (size--)
          CRC = (CRC >> 8) ^ Table[(CRC & 0xFF) ^ *pbyte++];
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  CRC_32::CalcCRC  (public member function)
  //    calculates the CRC-32 value for the given buffer
  //
  //  Parameters :
  //    buffer      [in] : a pointer to the data bytes
  //    size        [in] : the size of the buffer
  //    ProgressWnd [in] : the HWND of the progress bar
  //
  //  Returns :
  //    if ProgressWnd is not a window returns the CRC-32 value of the buffer
  //    if ProgressWnd is a window, returns the HANDLE of the created thread
  //    returns NULL if an error occurs
  //
  //  Note :
  //    ProgressWnd is passed through the IsWindow() API function. If IsWindow()
  //    returns zero, CalcCRC() will calculate the CRC-32 value directly. if IsWindow()
  //    returns nonzero, CalcCRC() will start a seperate thread. The thread will send 
  //    PBM_* progress bar messages to the ProgressWnd. When the thread is finished,
  //    the thread will send a WM_CRC_THREAD_DONE message to the parent window of the
  //    ProgressWnd. the WPARAM parameter will contain the HANDLE of the thread, and
  //    the LPARAM will contain the CRC-32 value of the buffer.
  //
  /////////////////////////////////////////////////////////////////////////////
  
  DWORD CRC_32::CalcCRC(LPVOID buffer, UINT size, HWND ProgressWnd/*= NULL*/)
  {   // check the validity of the data
      if (!buffer || !size)
          return 0;
  
      if (!IsWindow(ProgressWnd))
      {   // calculate CRC directly
          DWORD CRC = 0xFFFFFFFF;
          Calculate ((LPBYTE)buffer, size, CRC);
          return CRC ^ 0xFFFFFFFF;
      }
  
      // start the thread
      LPCRCStruct pCRCSt = new CRCStruct();
      DWORD ThreadID;
      HANDLE Handle = ::CreateThread(NULL, 0, CRC32ThreadProc, (LPVOID)pCRCSt, CREATE_SUSPENDED, &ThreadID);
      if (Handle)
      {   // thread successfully created
          pCRCSt->pCRC_32 = this;
          pCRCSt->FileName[0] = 0;
          pCRCSt->pByte = new BYTE[size];
          memcpy(pCRCSt->pByte, buffer, size);
          pCRCSt->size = size;
          pCRCSt->hWnd = ProgressWnd;
          pCRCSt->Thread = Handle;
          ::ResumeThread(Handle);
      }
      else // thread creation failed, clean up
          delete pCRCSt;
      return (DWORD)Handle;
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  CRC_32::CalcCRC  (public member function)
  //    calculates the CRC-32 value for the given buffer
  //
  //  Parameters :
  //    FileName    [in] : the complete path to the file
  //    ProgressWnd [in] : the HWND of the progress bar
  //
  //  Returns :
  //    if ProgressWnd is not a window returns the CRC-32 value of the file
  //    if ProgressWnd is a window, returns the HANDLE of the created thread
  //    returns NULL if an error occurs
  //
  //  Note :
  //    ProgressWnd is passed through the IsWindow() API function. If IsWindow()
  //    returns zero, CalcCRC() will calculate the CRC-32 value directly. if IsWindow()
  //    returns nonzero, CalcCRC() will start a seperate thread. The thread will send 
  //    PBM_* progress bar messages to the ProgressWnd. When the thread is finished,
  //    the thread will send a WM_CRC_THREAD_DONE message to the parent window of the
  //    ProgressWnd. the WPARAM parameter will contain the HANDLE of the thread, and
  //    the LPARAM will contain the CRC-32 value of the file.
  //
  /////////////////////////////////////////////////////////////////////////////
  
  DWORD CRC_32::CalcCRC(LPCTSTR FileName, HWND ProgressWnd/*= NULL*/)
  {   // make sure the file exists and is not a directory
      DWORD attrib = ::GetFileAttributes(FileName);
      if (attrib == 0xFFFFFFFF || attrib & FILE_ATTRIBUTE_DIRECTORY)
          return 0;
  
      // setup the CRCStruct
      LPCRCStruct pCRCSt = new CRCStruct();
      pCRCSt->pCRC_32 = this;
      _tcsncpy(pCRCSt->FileName, FileName, _MAX_PATH);
      pCRCSt->pByte = NULL;
      pCRCSt->size = 0;
      pCRCSt->hWnd = ProgressWnd;
      pCRCSt->Thread = NULL;
  
      if (!IsWindow(ProgressWnd))
      {   // calculate CRC directly
          return CRC32ThreadProc((LPVOID)pCRCSt);
      }
  
      // start the thread
      DWORD ThreadID;
      HANDLE Handle = ::CreateThread(NULL, 0, CRC32ThreadProc, (LPVOID)pCRCSt, CREATE_SUSPENDED, &ThreadID);
      if (Handle)
      {   // thread successfully created
          pCRCSt->Thread = Handle;
          ::ResumeThread(Handle);
      }
      else // thread creation failed, clean up
          delete pCRCSt;
      return (DWORD)Handle;
  }
  
  /////////////////////////////////////////////////////////////////////////////
  //
  //  End of CRC_32.cpp
  //
  /////////////////////////////////////////////////////////////////////////////

#define _O_SEQUENTIAL   0x0020   
#define _SH_DENYWR      0x20