00001
00002
00003
00004
00005
00006 #include "vmsHash.h"
00007 #include "md5.h"
00008 #include "crc32.h"
00009 #include "sha1.h"
00010 #include "sha2.h"
00011 #include "vmsFile.h"
00012
00013 vmsHash::vmsHash()
00014 {
00015 m_pEvents = NULL;
00016 m_nSHA2Strength = 256;
00017 }
00018
00019 vmsHash::~vmsHash()
00020 {
00021
00022 }
00023
00024 std::string vmsHash::Hash(LPCSTR pszFile, vmsHashAlgorithm enHA)
00025 {
00026 switch (enHA) {
00027 case HA_MD5:
00028 return Hash_MD5 (pszFile);
00029
00030 case HA_CRC32:
00031 return Hash_CRC32 (pszFile);
00032
00033 case HA_SHA1:
00034 return Hash_SHA1 (pszFile);
00035
00036 case HA_SHA2:
00037 return Hash_SHA2 (pszFile);
00038
00039 default:
00040 return "";
00041 }
00042 }
00043
00044 std::string vmsHash::Hash_MD5(LPCSTR pszFile)
00045 {
00046 MD5_CTX md5;
00047 if (0 == Hash_MD5_File (pszFile, 0, &md5))
00048 return "";
00049 return Hash_ResultToStr (md5.digest, 16);
00050 }
00051
00052 UINT64 vmsHash::Hash_MD5_File(const char *fn, unsigned long seed, void *pvContext)
00053 {
00054 MD5_CTX *mdContext = (MD5_CTX*) pvContext;
00055 vmsFile file;
00056 __int64 trb = 0;
00057
00058 try {
00059
00060 file.Open (fn, TRUE);
00061
00062 __int64 uSize;
00063 uSize = file.get_Size ();
00064
00065 MD5Init (mdContext , seed);
00066
00067 char buf [2048];
00068 for (;;) {
00069 int rb = (int) file.Read (buf, 2048);
00070 trb += rb;
00071 MD5Update (mdContext, (unsigned char *) buf, rb);
00072
00073 if (m_pEvents)
00074 {
00075 double f = (double)trb / uSize * 100;
00076 if (false == m_pEvents->OnProgressChanged (f)) {
00077 trb = 0;
00078 break;
00079 }
00080 }
00081
00082 if (rb < 2048)
00083 break;
00084 }
00085
00086 MD5Final (mdContext);
00087
00088 }catch (...) {return 0;}
00089
00090 return trb ;
00091 }
00092
00093 std::string vmsHash::Hash_ResultToStr(unsigned char *pHR, int nSize)
00094 {
00095 std::string str;
00096
00097 for (int i = 0; i < nSize; i++)
00098 {
00099 char sz [3];
00100 itoa (*pHR++, sz, 16);
00101 if (sz [1] == 0) {
00102 sz [1] = sz [0];
00103 sz [2] = 0;
00104 sz [0] = '0';
00105 }
00106
00107 str += sz;
00108 }
00109
00110 return str;
00111 }
00112
00113 void vmsHash::set_EventsHandler(vmsHashEvents *pEvents)
00114 {
00115 m_pEvents = pEvents;
00116 }
00117
00118 std::string vmsHash::Hash_CRC32(LPCSTR pszFile)
00119 {
00120 DWORD dwCrc32;
00121 CCrc32Static crc32;
00122
00123 DWORD dwErrorCode = NO_ERROR;
00124 vmsFile file;
00125
00126 dwCrc32 = 0xFFFFFFFF;
00127
00128 try
00129 {
00130
00131 file.Open (pszFile, TRUE);
00132 __int64 uSize = file.get_Size ();
00133 __int64 trb = 0;
00134
00135 char buffer [MAX_BUFFER_SIZE];
00136 int nCount;
00137 while (nCount = file.Read (buffer, sizeof(buffer)))
00138 {
00139 for(int nLoop = 0; nLoop < nCount; nLoop++)
00140 crc32.CalcCrc32 (buffer [nLoop], dwCrc32);
00141 trb += nCount;
00142
00143 if (m_pEvents)
00144 {
00145 double f = (double)trb / uSize * 100;
00146 if (false == m_pEvents->OnProgressChanged (f)) {
00147 trb = 0;
00148 break;
00149 }
00150 }
00151 }
00152
00153 }
00154 catch(...) {return "";}
00155
00156 dwCrc32 = ~dwCrc32;
00157
00158 char sz [100];
00159 sprintf (sz, "%08x", dwCrc32);
00160 return sz;
00161 }
00162
00163 std::string vmsHash::Hash_SHA1(LPCSTR pszFile)
00164 {
00165 sha1_ctx sha1;
00166 vmsFile file;
00167 __int64 trb = 0;
00168 BYTE abBuf [16000];
00169
00170 sha1_begin (&sha1);
00171
00172 try {
00173
00174 file.Open (pszFile, TRUE);
00175 __int64 uSize = file.get_Size ();
00176 DWORD dwRead;
00177 while (dwRead = file.Read (abBuf, sizeof (abBuf)))
00178 {
00179 sha1_hash (abBuf, dwRead, &sha1);
00180 trb += dwRead;
00181 if (m_pEvents)
00182 {
00183 double f = (double)trb / uSize * 100;
00184 if (false == m_pEvents->OnProgressChanged (f)) {
00185 trb = 0;
00186 break;
00187 }
00188 }
00189 }
00190
00191 BYTE abRes [256];
00192 sha1_end (abRes, &sha1);
00193
00194 if (trb == 0 && uSize != 0)
00195 return "";
00196
00197 return Hash_ResultToStr (abRes, 20);
00198
00199 }catch (...) {return "";}
00200 }
00201
00202 std::string vmsHash::Hash_SHA2(LPCSTR pszFile)
00203 {
00204 sha2_ctx sha2;
00205 vmsFile file;
00206 __int64 trb = 0;
00207 BYTE abBuf [16000];
00208
00209 sha2_begin (m_nSHA2Strength, &sha2);
00210
00211 try {
00212
00213 file.Open (pszFile, TRUE);
00214 __int64 uSize = file.get_Size ();
00215 DWORD dwRead;
00216 while (dwRead = file.Read (abBuf, sizeof (abBuf)))
00217 {
00218 sha2_hash (abBuf, dwRead, &sha2);
00219 trb += dwRead;
00220 if (m_pEvents)
00221 {
00222 double f = (double)trb / uSize * 100;
00223 if (false == m_pEvents->OnProgressChanged (f)) {
00224 trb = 0;
00225 break;
00226 }
00227 }
00228 }
00229
00230 BYTE abRes [256];
00231 sha2_end (abRes, &sha2);
00232
00233 if (trb == 0 && uSize != 0)
00234 return "";
00235
00236 return Hash_ResultToStr (abRes, m_nSHA2Strength / 8);
00237
00238 }catch (...) {return "";}
00239 }
00240
00241 void vmsHash::set_SHA2Strength(vmsHash_SHA2Strength en)
00242 {
00243 switch (en) {
00244 case HSHA2S_256: m_nSHA2Strength = 256; break;
00245 case HSHA2S_384: m_nSHA2Strength = 384; break;
00246 case HSHA2S_512: m_nSHA2Strength = 512; break;
00247 }
00248 }