void *crack_crc32(void *arg){
PTHREAD_PARAMTERS pthread_paramters = 0;
int current_length = 0;
unsigned int crc32 = 0;
pthread_paramters = arg;
crc32 = crack_thread_info.check_crc32;
for (int i = pthread_paramters->calc_length;i >= 0;i--)
{
for (int j = 0;j <= i;j++)
{
current_length = i;
crc32Init(&crc32);
crc32Update(&crc32,(char*)((long)crack_thread_info.szDat + j),current_length - j);
crc32Finish(&crc32);
sleep(1);
if (crc32 == 0 || crc32 == 0xFFFFFFFF)
{
continue;
}
printf("ThreadCount: %08x\tOffset: %08x\tLength: %08x\tCrc32: %08x\tCrc32Check: %08x\r\n", \
crack_thread_info.thread_count,j,current_length - j,crc32,0xFFFFFFFF ^ crc32);
if (crack_thread_info.check_crc32 == ((long)0xFFFFFFFF ^ crc32))
{
printf("Finder,Start Offset: %08x\t\t,End Offset: %08x\r\n",j,i);
}
}
}
return 0;
}
int GetTitleHash(CLIP_INFO* ci)
{
unsigned long val;
crc32Init(&val);
crc32Update(&val, ci->title, strlen(ci->title));
crc32Finish(&val);
return val % 10000;
}
int HashFinishCRC(HASH *Hash, char **HashStr)
{
unsigned long crc;
int len;
len=sizeof(unsigned long);
crc32Finish((unsigned long *) Hash->Ctx);
crc=htonl(* (unsigned long *) Hash->Ctx);
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,&crc,len);
return(len);
}
int HashFinishCRC(THash *Hash, int Encoding, char **HashStr)
{
unsigned long crc;
int len;
len=sizeof(unsigned long);
crc32Finish((unsigned long *) Hash->Ctx);
//crc=htonl((unsigned long *) Hash->Ctx);
free(Hash->Ctx);
if (Encoding > 0)
{
*HashStr=EncodeBytes(*HashStr, (char *) &crc, len, Encoding);
return(StrLen(*HashStr));
}
else
{
*HashStr=SetStrLen(*HashStr,len);
memcpy(*HashStr,&crc,len);
return(len);
}
}
extern "C" DLL_EXPORT int getFileVerify(std::vector<std::string> &infile, std::vector<Result> &outre)
{
__int64 finishedSize = 0;
std::vector<__int64> fSizes(infile.size());
std::string strFileSize;
std::string strFileMD5;
std::string strFileSHA1;
std::string strFileSHA256;
std::string strFileCRC32;
//开始计算,循环处理每个文件
for (int i = 0; i < infile.size(); i++)
{
// Declaration for calculator
char* path = const_cast<char*>(infile[i].c_str());
__int64 fsize = 0;
finishedSize = 0;
DataBuffer databuf;
MD5_CTX mdContext; // MD5 context
CSHA1 sha1; // SHA1 object
char strSHA1[256];
SHA256_CTX sha256Ctx; // SHA256 context
std::string strSHA256 ="";
unsigned long ulCRC32; // CRC32 context
ResultData result;
result.strPath = infile[i];
//打开文件
FILE *fp = fopen(infile[i].c_str(), "rb+");
if (fp != NULL)
{
//成功打开文件
MD5Init(&mdContext, 0); // MD5开始
sha1.Reset(); // SHA1开始
sha256_init(&sha256Ctx); // SHA256开始
crc32Init(&ulCRC32); // CRC32开始
//获取文件信息
std::string lastModifiedTime;
struct _stat64 info;
_wstat64(AnsiToUnicode(infile[i].c_str()), &info);
fsize = info.st_size;
API_TimeToStringEX(lastModifiedTime, info.st_mtime);
do
{
//读取文件
databuf.datalen = fread(databuf.data, 1, DataBuffer::preflen, fp);
MD5Update(&mdContext, databuf.data, databuf.datalen); // MD5更新
sha1.Update(databuf.data, databuf.datalen); // SHA1更新
sha256_update(&sha256Ctx, databuf.data, databuf.datalen); // SHA256更新
crc32Update(&ulCRC32, databuf.data, databuf.datalen); // CRC32更新
finishedSize += databuf.datalen;
//设置偏移
if (databuf.datalen >= DataBuffer::preflen)
_fseeki64(fp, finishedSize, SEEK_SET);
} while (databuf.datalen >= DataBuffer::preflen);
fclose(fp);//关闭文件
MD5Final(&mdContext); // MD5完成
sha1.Final(); // SHA1完成
sha256_final(&sha256Ctx); // SHA256完成
crc32Finish(&ulCRC32); //CRC32完成
//格式化校验码
char _tempmd5[256] = { '\0' };
sprintf(_tempmd5, "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
mdContext.digest[0],
mdContext.digest[1],
mdContext.digest[2],
mdContext.digest[3],
mdContext.digest[4],
mdContext.digest[5],
mdContext.digest[6],
mdContext.digest[7],
mdContext.digest[8],
mdContext.digest[9],
mdContext.digest[10],
mdContext.digest[11],
mdContext.digest[12],
mdContext.digest[13],
mdContext.digest[14],
mdContext.digest[15]);
strFileMD5 = _tempmd5;
sha1.ReportHash(strSHA1, CSHA1::REPORT_HEX);
strFileSHA1 = (strSHA1);
sha256_digest(&sha256Ctx, &strSHA256);
strFileSHA256 = strSHA256;
//strFileCRC32.Format(_T("%08X"), ulCRC32);
char _tempcrc[128] = { '\0' };
sprintf(_tempcrc, "%08X", ulCRC32);
strFileCRC32 = _tempcrc;
result.bDone = TRUE;
result.strPath = infile[i];
result.ulSize = fsize;
result.strMDate = lastModifiedTime;
// 在没做转换前，结果都是大写的
result.strMD5 = strFileMD5;
result.strSHA1 = strFileSHA1;
result.strSHA256 = strFileSHA256;
result.strCRC32 = strFileCRC32;
//转换大小写
}
else
{
result.bDone = FALSE;
result.strError = "Open file error";
}
outre.push_back(result);
}
return 0;
}
int CHashManager::HashFile(char *pszFile)
{
FILE *fp = NULL;
unsigned char pBuf[SIZE_HASH_BUFFER];
unsigned long uRead = 0;
unsigned char pTemp[256];
char szTemp[RH_MAX_BUFFER];
int i = 0;
printf("File: <");
printf(pszFile);
printf(">");
printf(CPS_NEWLINE);
fp = fopen(pszFile, "rb");
if(fp == NULL) return RH_CANNOT_OPEN_FILE;
if(m_bAlgorithm[HASHID_CRC16]) crc16_init(&m_crc16);
if(m_bAlgorithm[HASHID_CRC16CCITT]) crc16ccitt_init(&m_crc16ccitt);
if(m_bAlgorithm[HASHID_CRC32]) crc32Init(&m_crc32);
if(m_bAlgorithm[HASHID_FCS_16]) fcs16_init(&m_fcs16);
if(m_bAlgorithm[HASHID_FCS_32]) fcs32_init(&m_fcs32);
if(m_bAlgorithm[HASHID_GHASH_32_3] || m_bAlgorithm[HASHID_GHASH_32_5]) m_ghash.Init();
if(m_bAlgorithm[HASHID_GOST]) gosthash_reset(&m_gost);
if(m_bAlgorithm[HASHID_HAVAL]) haval_start(&m_haval);
if(m_bAlgorithm[HASHID_MD2]) m_md2.Init();
if(m_bAlgorithm[HASHID_MD4]) MD4Init(&m_md4);
if(m_bAlgorithm[HASHID_MD5]) MD5Init(&m_md5, 0);
if(m_bAlgorithm[HASHID_SHA1]) sha1_begin(&m_sha1);
if(m_bAlgorithm[HASHID_SHA2_256]) sha256_begin(&m_sha256);
if(m_bAlgorithm[HASHID_SHA2_384]) sha384_begin(&m_sha384);
if(m_bAlgorithm[HASHID_SHA2_512]) sha512_begin(&m_sha512);
if(m_bAlgorithm[HASHID_SIZE_32]) sizehash32_begin(&m_uSizeHash32);
if(m_bAlgorithm[HASHID_TIGER]) tiger_init(&m_tiger);
while(1)
{
uRead = fread(pBuf, 1, SIZE_HASH_BUFFER, fp);
if(uRead != 0)
{
if(m_bAlgorithm[HASHID_CRC16])
crc16_update(&m_crc16, pBuf, uRead);
if(m_bAlgorithm[HASHID_CRC16CCITT])
crc16ccitt_update(&m_crc16ccitt, pBuf, uRead);
if(m_bAlgorithm[HASHID_CRC32])
crc32Update(&m_crc32, pBuf, uRead);
if(m_bAlgorithm[HASHID_FCS_16])
fcs16_update(&m_fcs16, pBuf, uRead);
if(m_bAlgorithm[HASHID_FCS_32])
fcs32_update(&m_fcs32, pBuf, uRead);
if(m_bAlgorithm[HASHID_GHASH_32_3] || m_bAlgorithm[HASHID_GHASH_32_5])
m_ghash.Update(pBuf, uRead);
if(m_bAlgorithm[HASHID_GOST])
gosthash_update(&m_gost, pBuf, uRead);
if(m_bAlgorithm[HASHID_HAVAL])
haval_hash(&m_haval, pBuf, uRead);
if(m_bAlgorithm[HASHID_MD2])
m_md2.Update(pBuf, uRead);
if(m_bAlgorithm[HASHID_MD4])
MD4Update(&m_md4, pBuf, uRead);
if(m_bAlgorithm[HASHID_MD5])
MD5Update(&m_md5, pBuf, uRead);
if(m_bAlgorithm[HASHID_SHA1])
sha1_hash(pBuf, uRead, &m_sha1);
if(m_bAlgorithm[HASHID_SHA2_256])
sha256_hash(pBuf, uRead, &m_sha256);
if(m_bAlgorithm[HASHID_SHA2_384])
sha384_hash(pBuf, uRead, &m_sha384);
if(m_bAlgorithm[HASHID_SHA2_512])
sha512_hash(pBuf, uRead, &m_sha512);
if(m_bAlgorithm[HASHID_SIZE_32])
sizehash32_hash(&m_uSizeHash32, uRead);
if(m_bAlgorithm[HASHID_TIGER])
tiger_process(&m_tiger, pBuf, uRead);
}
if(uRead != SIZE_HASH_BUFFER) break;
}
fclose(fp); fp = NULL;
// SizeHash-32 is the first hash, because it's the simplest one,
// the fastest, and most widely used one. ;-)
if(m_bAlgorithm[HASHID_SIZE_32])
{
sizehash32_end(&m_uSizeHash32);
printf(SZ_SIZEHASH_32);
printf(SZ_HASHPRE);
printf("%08X", m_uSizeHash32);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_CRC16])
{
crc16_final(&m_crc16);
printf(SZ_CRC16);
printf(SZ_HASHPRE);
printf("%04X", m_crc16);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_CRC16CCITT])
{
crc16ccitt_final(&m_crc16ccitt);
printf(SZ_CRC16CCITT);
printf(SZ_HASHPRE);
printf("%04X", m_crc16ccitt);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_CRC32])
{
crc32Finish(&m_crc32);
printf(SZ_CRC32);
printf(SZ_HASHPRE);
printf("%08X", m_crc32);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_FCS_16])
{
fcs16_final(&m_fcs16);
printf(SZ_FCS_16);
printf(SZ_HASHPRE);
printf("%04X", m_fcs16);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_FCS_32])
{
fcs32_final(&m_fcs32);
printf(SZ_FCS_32);
printf(SZ_HASHPRE);
printf("%08X", m_fcs32);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_GHASH_32_3])
{
m_ghash.FinalToStr(szTemp, 3);
printf(SZ_GHASH_32_3);
printf(SZ_HASHPRE);
printf(szTemp);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_GHASH_32_5])
{
m_ghash.FinalToStr(szTemp, 5);
printf(SZ_GHASH_32_5);
printf(SZ_HASHPRE);
printf(szTemp);
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_GOST])
{
gosthash_final(&m_gost, pTemp);
printf(SZ_GOST);
printf(SZ_HASHPRE);
for(i = 0; i < 32; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_HAVAL])
{
haval_end(&m_haval, pTemp);
printf(SZ_HAVAL);
printf(SZ_HASHPRE);
for(i = 0; i < 32; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_MD2])
{
m_md2.TruncatedFinal(pTemp, 16);
printf(SZ_MD2);
printf(SZ_HASHPRE);
for(i = 0; i < 16; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_MD4])
{
MD4Final(pTemp, &m_md4);
printf(SZ_MD4);
printf(SZ_HASHPRE);
for(i = 0; i < 16; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_MD5])
{
MD5Final(&m_md5);
printf(SZ_MD5);
printf(SZ_HASHPRE);
for(i = 0; i < 16; i++)
{
fmtFixHashOutput(i);
printf("%02X", m_md5.digest[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA1])
{
sha1_end(pTemp, &m_sha1);
printf(SZ_SHA1);
printf(SZ_HASHPRE);
for(i = 0; i < 20; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA2_256])
{
sha256_end(pTemp, &m_sha256);
printf(SZ_SHA2_256);
printf(SZ_HASHPRE);
for(i = 0; i < 32; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA2_384])
{
sha384_end(pTemp, &m_sha384);
printf(SZ_SHA2_384);
printf(SZ_HASHPRE);
for(i = 0; i < 48; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_SHA2_512])
{
sha512_end(pTemp, &m_sha512);
printf(SZ_SHA2_512);
printf(SZ_HASHPRE);
for(i = 0; i < 64; i++)
{
fmtFixHashOutput(i);
printf("%02X", pTemp[i]);
}
printf(CPS_NEWLINE);
}
if(m_bAlgorithm[HASHID_TIGER])
{
tiger_done(&m_tiger, pTemp);
printf(SZ_TIGER);
printf(SZ_HASHPRE);
for(i = 0; i < 8; i++) { fmtFixHashOutput(i); printf("%02X", pTemp[7-i]); }
for(i = 8; i < 16; i++) { fmtFixHashOutput(i); printf("%02X", pTemp[23-i]); }
for(i = 16; i < 24; i++) { fmtFixHashOutput(i); printf("%02X", pTemp[39-i]); }
printf(CPS_NEWLINE);
}
return RH_SUCCESS;
}