1028人阅读
随想&&感想（101）
C++（150）
Linux开发（3）
结合学校的crc校验的基础知识，直接使用zlib/crc32函数应该一点门槛都没有。。下面是zlib.h中自带的示例和讲解：
Update a running CRC-32 with the bytes buf[0..len-1] and return the
updated CRC-32. If buf is NULL, this function returns the required initial
value for the for the crc. Pre- and post-conditioning (one's complement) is
performed within this function so it shouldn't be done by the application.
Usage example:
uLong crc = crc32(0L, Z_NULL, 0);
while (read_buffer(buffer, length) != EOF) {
crc = crc32(crc, buffer, length);
if (crc != original_crc) error();
crc校验支持两种方式：
原始buffer，传入crc32生成校验码，然后将校验码追加到buffer尾部发送或者写文件。读取时分别解析原始buffer和校验码，再次做crc32.，看结果与接收到的校验码是否一致，来判断buffer是否完好无损。原始buffer，crc32做校验，然后将校验码取反追加到buffer尾部发送或者写文件。读取到整个内容（buffer+crcReverseCode)，做crc校验看结果是否是0xFFFFFFFF。
方式1操作起来有点呆板，我们一般采用方式2，既然比对目标是0xFFFFFFFF，那么说明crc32处理的一定是32位的数字。
今天再次看到这段代码，不由地有个疑问，crc32的32既然是32位的意思，为何要用uLong呢，（uLong的定义为typedef unsigned long uLong），uLong明显不具有跨平台性，具体参见：&&这尼玛不明摆着坑人么。带着这个疑问，于是我在64位linux上做了下面的测试：
// g++ crc_test.cpp -o exec_crc_test
-L /usr/lib64/ -lz
#include &stdio.h&
#include &stdlib.h&
#include &zlib.h&
#include &string.h&
void CRC_Partial_Check_Test();
template&class Type& void CRC_Full_Check_Test();
// crc32 use uLong, typedef unsigned long uL
typedef uLong ulong_t; // 32bit, 64bit.
int main()
CRC_Partial_Check_Test();
CRC_Full_Check_Test&unsigned int&();
CRC_Full_Check_Test&ulong_t&();
printf(&any key pressed to exit...\n&);
getchar();
typedef union
unsigned char buf[sizeof(ulong_t)];
} trans_un_t;
void CRC_Partial_Check_Test()
printf(&=============================&&CRC_Partial_ChecK_Test\n&);
char* buffer = &hello world, i am renyafei&;
int buffer_sz = strlen(buffer);
FILE* fp = fopen(&crc.dat&, &wb&);
fwrite(buffer, 1, buffer_sz, fp);
ulong_t crc_code = crc32(0, (const Bytef*)buffer, buffer_sz);
printf(&crc_code : %lu\n&, crc_code);
fwrite(&crc_code, 1, sizeof(ulong_t), fp);
fflush(fp);
fclose(fp);
FILE* fp = fopen(&crc.dat&, &rb&);
unsigned char content[1024] = {0};
int read_bytes = fread(content, 1, buffer_sz+sizeof(ulong_t), fp);
ulong_t crc_code = 0;
// get crc code
unsigned char* pch = content + buffer_
for(int k=0; k&sizeof(ulong_t); k++)
printf(&%d &, pch[k]);
trans.buf[k] = pch[k];
} printf(&\n&);
printf(&crc_code : %lu\n&, trans.val);
crc_code = trans.
if ( crc32(0, content, buffer_sz) != crc_code )
printf(&ERROR content.\n&);
printf(&Good Content.\n&);
fclose(fp);
template&class Type&
void CRC_Full_Check_Test()
printf(&=============================&&CRC_Full_ChecK_Test\n&);
char* buffer = &hello world, i am renyafei&;
int buffer_sz = strlen(buffer);
typedef Type dest_t;
FILE* fp = fopen(&crc.dat&, &wb&);
fwrite(buffer, 1, buffer_sz, fp);
ulong_t crc = crc32(0, (const Bytef*)buffer, buffer_sz);
dest_t rever_crc = (dest_t)~
printf(&crc = %lu, reverse_crc_code : %lu\n&, crc, rever_crc);
fwrite(&rever_crc, 1, sizeof(dest_t), fp);
fflush(fp);
fclose(fp);
FILE* fp = fopen(&crc.dat&, &rb&);
unsigned char content[1024] = {0};
int read_bytes = fread(content, 1, buffer_sz+sizeof(dest_t), fp);
// get crc code
unsigned char* pch = content + buffer_
memcpy(trans.buf, pch, sizeof(ulong_t));
printf(&reverse_crc_code : %lu\n&, trans.val);
ulong_t res = crc32(0, content, read_bytes); printf(&res = %lu\n&, res);
if ( res != 0xFFFFFFFF && res != 0xFFFFFFFFFFFFFFFF )
printf(&ERROR content.\n&);
printf(&Good Content.\n&);
fclose(fp);
CRC_Partial_Check_Test为上文中的方式1，CRC_Full_Check_Test为方式2。
函数中第一块对一个字符串做校验，将字符串和校验码写入二进制文件，然后第二段从二进制文件中读取出字符串和校验码，进行crc校验判断字符串是否正确。
程序输出结果：
=============================&&CRC_Partial_ChecK_Test
crc_code :
8 190 65 252 0 0 0 0
crc_code :
Good Content.
=============================&&CRC_Full_ChecK_Test
crc = , reverse_crc_code :
reverse_crc_code :
Good Content.
=============================&&CRC_Full_ChecK_Test
crc = , reverse_crc_code :
reverse_crc_code :
ERROR content.
CRC_Partial_Check_Test 即使使用uLong也没有问题。为毛？crc32校验码为unsigned int类型，写文件时提升成unsigned long 64位，即从低到高八个字节为：8 190 65 252 0 0 0 0，然后从文件读取，最后比较都是uLong类型，不影响结果。
CRC_Full_Check_Test&unsigned int&()就是我们正常使用的方式， CRC_Full_Check_Test&uLong&调用时crc校验失败，问题出在crcCode取反操作上，提升成uLong以后取反结果非常大。再次对整个buffer做crc校验失败~_~。
诡异的移位结果
在测试过程中发现了一个移位的坑：
ulong_t code = 0xfc && 24;
unsigned int ui_code = 0xfc && 24;
printf(&ulong_res = %lu, uint_res = %lu\n&, code, ui_code);
code = 0xfc && 8;
ui_code = 0xfc && 8;
printf(&ulong_res = %lu, uint_res = %lu\n&, code, ui_code);输出结果如下：
ulong_res = , uint_res =
ulong_res = 64512, uint_res = 64512第一行uLong_res输出结果很奇怪。通过dump_val_hex函数输出一个数字的16进制形式：
template&class Type& void dump_val_hex_recur(Type val)
if (val == 0)
unsigned char byte = val & 0xFF;
dump_val_hex_recur(val && 8);
printf(&%02x &, byte);
template &class Type& void dump_val_hex(Type val) // 0xfc000000 =& printf : fc 00 00 00
if (val == 0)
printf(&%02x\n&, 0);
dump_val_hex_recur(val); printf(&\n&);
对应的16进制形式为ff ff ff ff fc 00 00 00 。诡异的移位结果，居然高位被1填充。但是0xfc && 8 的结果确实高位被0填充。
在vs2013上面做类似的尝试，也有同样的结果：
unsigned long long val = 0xfc && 24;
dword ptr [val],0FC000000h
dword ptr [ebp-68h],0FFFFFFFFh
val = 0xfc && 8;
dword ptr [val],0FC00h
dword ptr [ebp-68h],0
结果非常诡异，暂时想不通原因，总之小心为好。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：576838次
积分：8059
积分：8059
排名：第1683名
原创：210篇
转载：11篇
评论：212条
文章：34篇
阅读：112070
(1)(1)(1)(3)(1)(1)(1)(2)(3)(2)(1)(1)(4)(2)(2)(2)(1)(4)(3)(3)(4)(1)(5)(2)(4)(4)(1)(5)(2)(4)(3)(5)(1)(2)(5)(2)(1)(3)(3)(3)(1)(1)(3)(8)(4)(7)(4)(1)(5)(7)(8)(1)(1)(2)(1)(5)(10)(4)(2)(2)(7)(5)(3)(2)(1)(1)(7)(13)(1)(1)(2)(8)(4)
有偿解决各种OpenGL疑难杂症
扣扣号：五四六九五二七二零，验证写明意图！你的位置： &
& 再试RAR密码破解(CRC32)
这篇文章只不过是之前
的高级应用，原理是一样的。
问题背景和之前也类似，就是稍微复杂一些。某bbs发布小型的彩票，论坛用户用自己的论坛货币购买压住，然后压中获奖。
总共五组号码，五组号码由数字1～12中产生，前四个号码不重复，第五个号码可以与前四个号码重复。
剩下的我想你如果看过之前的文章，我想你明白了，论坛发布彩票的管理员，将实现设置好的数字保存于txt文件中，加密压缩，等开奖的时候再公布密码。
因为涉及到一个还算有意思的排列组合，所以才写的这个，而这个实话说我自己没写出来，找人代劳了。
一段C代码，实现生成所有排列组合的文件，注意一定要生成到一个指定的文件夹，到桌面或者根目录，你电脑一定会卡死的。
#include &stdio.h&
#include &string.h&
#define N 200 //输出数 最大11880
int Check(int* numList)
for (i = 0; i & 4; i++)
for (j = 0; j & 4; j++)
if (i == j)
if (numList[i] == numList[j])
int main()
char* list[12] = {&01&, &02&, &03&, &04&,
&05&, &06&, &07&, &08&,
&09&, &10&, &11&, &12&};
char filePreName[100];
char fileName[100];
char filePreCon[200];
char fileCon[200];
int numList[5];
memset(numList, 0, sizeof(numList));
for (i = 0; i & N; i++)
memset(filePreName, 0, sizeof(filePreName));
memset(fileName, 0, sizeof(fileName));
memset(filePreCon, 0, sizeof(filePreCon));
memset(fileCon, 0, sizeof(fileCon));
while (!Check(numList))
numList[0]++;
for (j = 0; j & 4; j++)
if (numList[j] & 11)
numList[j] = 0;
numList[j+1]++;
for (j = 3; j &= 0; j--)
strcat(filePreName, list[numList[j]]);
strcat(filePreCon, list[numList[j]]);
strcat(filePreCon, &,&);
for (k = 0; k & 12; k++)
strcpy(fileName, filePreName);
strcat(fileName, list[k]);
strcat(fileName, &.txt&);
strcpy(fileCon, filePreCon);
strcat(fileCon, &+&);
strcat(fileCon, list[k]);
freopen(fileName, &w&, stdout);
printf(&%s\n&, fileCon);
numList[0]++;
for (j = 0; j & 4; j++)
if (numList[j] & 11)
numList[j] = 0;
numList[j+1]++;
生成的文档内容为XX、XX、XX、XX+XX，然后文件名为XXXXXXXXXX.txt，也就是内容部分去掉标点和符号。
剩下的任务，当然少不了微软提供的利器： ，具体用法就不说了 for命令用好，将结果输出到一个txt文件中，可能校核稍微时间长了点(前面那个写一万多个文件的速度也不快)。
再用校核得到的CRC32的值与winrar中显示的数值做对比就可以得到最终结果。
转载请注明： >>
与本文相关的文章crc32和crc16分别程序实现_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
crc32和crc16分别程序实现
上传于||文档简介
&&c​r​c2​和​c​r​c6​分​别​程​序​实​现​ ​测​试​通​过​,
阅读已结束，如果下载本文需要使用2下载券
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩4页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢1977人阅读
算法/数据结构/设计模式（1）
CRC : Cyclic redundancy Check&循环冗余校验
概述参见wiki百科：http://en.wikipedia.org/wiki/Cyclic_redundancy_check
原理及精辟讲解参见：http://www.repairfaq.org/filipg/LINK/F_crc_v3.html
原理我也只是大致懂了，感觉还不是很透彻，岁数大了又不是搞数学的，吃力啊。不过有一些理解上的心得，对与不对说一下。另外提供封装好的源码。
1、关于原理
& & CRC的算法是那么规定的，所以不要太过于纠结它的模2除法、多项式除法，也不要硬扯着熟悉的算术除法说事。异或一直是处理bit的一个很神奇的玩意。这样说并不是不负责任，不管是CRC还是什么加密算法之类的，算法规定该怎么弄了，人家有完备的数学推理及某些前提，除非你也钻研相关算法，否则想不透彻我觉得反倒正常，网上很多写博客的人说的好像那么回事，但是感觉也是东抄西抄，然后牵强附会。最起码我觉得我不够透彻，连A^B^C
= A^(B^C)我也不知道为什么，其实A+B+C = A+(B+C)我也证明不出来。
2、关于模式
算法了解了，那么就应该关心它的模式了。毕竟CRC是校验用的，就会涉及到两端，就需要约定。因此，标准的或者通用的或者流行的模式最好了解的透彻些。比较常用的模式有CRC16/CRC16-CCITT/CRC32这三种。更多的模式及模式应用的领域在wiki百科里有个表，可以对照着看下。
//////////////////////////////////////////////////////////////////////////
// Hold the information about the crc model.
typedef struct _CRCMODEL
szModelName[32];// Indicate one exclusive model
dwW // The width of crc value in bits
// The top bit(leftmost) of the poly should be omitted.
// TRUE : LSB
,FALSE : MSB
bRefO // Almost same as bRefIn
// Using this static table when checking by byte.
}CRCMODEL,*PCRCMODEL;
受开头推荐的那篇文章影响，定义了以上的一个结构，用于表示不同的模式。那么模式的主要内容也就是以上那么多项了。
dwPoly：16进制表示的多项式，注意此值未包含多项式的top bit，严格意义上讲多项式是指包含top bit的，但鉴于top bit必须是1，而做模除时1^1一定消掉，所以不显示的表示也无不可之处。另外我定义的是32位的无符号整型，容纳不下33位。
// CRC-16(SDLC) :
X16 + X15 + X2 + X0
#define POLY_16
// CRC-ITU(CCITT、HDLC) :
X16 + X12 + X5 + X0
#define POLY_16_CCITT
(ZIP,RAR,Ethernet)
// X32 + X26+ X23 + X22 + X16 +X12 + X11 + X10 + X8 + X7 +X5+X4+X2+X1+X0
#define POLY_32
0X04C11DB7这里值得一提的是颠倒多项式：因为颠倒多项式是指将整个多项式的值（包含top bit）做位颠倒。那么在参与计算时直接将dwPoly颠倒会否出问题？答案是不会的，因为颠倒的多项式用于颠倒求crc算法，这时，颠倒多项式的top bit就是最右一bit。
dwInit：寄存器的初值，或者说用此值来与字节串开始的W位做异或，一般是全FF。这样可以避免开头多个0的串crc值相同的情况。（Hpmbcalc软件）
切记在颠倒算法中，此值也要做颠倒，开头推荐文章里也如此讲解，我也认同。但我发现Hpmbcalc未颠倒。后文我会拿出我认为的证据证明应该将初值颠倒。
bRefIn:这是个BOOL值，表示字符串是否进行了字节颠倒。某些硬件传输时使用LSB模式，即先传输低位的bit，这样使用MSB模式收到的字节就是颠倒的。我的理解是假如A传输的是，但是底层硬件传输时按照的顺序传给B，B的传输模式是MSB，即认为接收的第一个bit是高位bit。那么本来应该是0x80，但是B却认为它接收的是0x01.
对于这种情况，在做crc之前把每一个字节颠倒过来就好了。但是这么做将浪费大量时间和工作量，于是出现了颠倒crc算法，即除了源串字节不进行颠倒以外，初始值、poly、进寄存器方向、最后的crc结果都进行颠倒。这样与费时费事的颠倒每个字节计算的结果完全一致。
我觉得这个就是为了颠倒crc算法准备的，因为上文提到了，颠倒crc算法最后的crc结果也要进行颠倒，那么如果传输端将本来crc结果进行了颠倒，那么接收端使用颠倒crc算法得到的crc结果就可以心安理得的不进行颠倒了。
dwXorOut:最后的crc值与此值做异或，为啥用不是很了解。。。但是它是最后最后的一步了，它是对crc结果的再处理，我认为处理后的已经不能算是crc值了，Hpmbcalc界面展示时也对经过dwXorOut后的值叫做After &Final XOR.这个我倒不是迎合Hpmbcalc，而是按理说接收方对于包含crc值的源串按同样poly进行CRC校验结果应该是0，但是如果对方传递的是经过了final xor的值那么别想得到0.除非你将收到的所谓crc值先做XOR然后再去校验整个串才能得到0.
3、一些验证
1、使用标准CRC16、CRC16-CCITT、CRC32进行验证，与HPMBCALC软件比较：
2、使用标准CRC32model进行验证，与winrar比较：
3、假如发送端发送的是0x01，但是硬件传输时使用的是LSB，而接收端是MSB，那么接收端接收的应该是0x80。
& & a、在Initial value是0、Finial Xor也是0、发送端Crc结果不进行颠倒的情况下，使用Hpmbcalc计算结果和我的封装函数结果如下：
& & b、在Initial value是0x、Finial Xor是0、发送端Crc结果不进行颠倒的情况下，使用Hpmbcalc计算结果和我的封装函数结果如下：
4、实现源码
.c文件中提供了一些进行crc校验的函数，例如位颠倒函数、按bit计算crc、按字节计算crc、生成驱动表、按照自定义模式计算crc值、颠倒crc算法。
.h中提供了封装的导出函数，对字符串和文件计算crc值，对于字符串可以按bit和按字节计算，默认按照字节，对于文件默认按字节，以及定义了三种标准的CRCMODEL并提供函数直接使用。
代码方面，虽然是windows下的c，但是相信移植也不会很难，用到的库函数极少，类型已经宏定义。此份代码对于32及以内宽度的crc校验码可用，但对于非16bit和32bit未进行充分测试(hpmbcalc不提供对于非此两种的poly的支持，因此不好进行比对，但代码中已经对非此两种bit进行了处理)。
* @file CrcFunction.h
* @brief The header file that contains the declarations we exported.
* @details We provide some interfaces for you to calculate the CRC value of
* some bytes or a file.You can define the model you like and use our function
* to calculate the crc.Also,we provide the implementation for 3 standard model.
* @author XiaoJiu
* @date Commenced at
#pragma once
#ifdef __cplusplus
extern &C& {
* @brief Hold the information about the crc model.
* @details There 're 2 ways to check the crc value on the received end:
* 1.Calculate the new crc value of all bytes received, 0 means ok.
* 2.Calculate the crc value of received message without last several bytes
* placed crc value in,then compare the two crc value.
Using a model whose bRefOut is not FALSE or dwXorOut is not 0,we should
* check crc the second way,because the &crc value& placed at the end of
* message is not the real crc value.
typedef struct _CRCMODEL
szModelName[32]; ///& Indicate one exclusive model
///& The width of crc value in bits
///& The top bit(leftmost) of the poly should be omitted.
///& TRUE : LSB
,FALSE : MSB
///& Almost same as bRefIn
///& Using this static table when checking by byte.
}CRCMODEL,*PCRCMODEL;
/// CRC16 model defined as{&CRC-16&,16,POLY_16,0X0000,TRUE,TRUE,0X0000,TABLE16}
extern const CRCMODEL Model_Crc16;
/// CRC32 model defined as {&CRC-32&,32,POLY_32,0XFFFFFFFF,TRUE,TRUE,0XFFFFFFFF,TABLE32}
extern const CRCMODEL Model_Crc32;
/// CRC16-CCITT model defined as{&CRC-16&,16,POLY_16_CCITT,0XFFFF,FALSE,FALSE,0X0000,TABLE16_CCITT}
extern const CRCMODEL Model_Crc16_CCITT;
* @brief Reflect a hex number by bit.
* @param [in] dwToRef The hex number to be reflected.
* @param [in] dwNumsFromRight The number of bits to be reflected counting from right.
* @return The reflected number.
DWORD CrcReflectBits(DWORD dwToRef,DWORD dwNumsFromRight);
* @brief Calculate CRC value for some bytes with 8 bit as a unit.
* @param [in] pBuffer The pointer to a buffer contains bytes to be calculated.
* @param [in] dwLen The length of the buffer.
* @param [in] pModel The model how we calculate the CRC value.
* @return The CRC value.
DWORD CrcMessageByByte(UCHAR* pBuffer,DWORD dwLen,const CRCMODEL* pModel);
/// Calculate CRC value for some bytes with 1 bit as a unit.
DWORD CrcMessageByBit(UCHAR* pBuffer,DWORD dwLen,const CRCMODEL* pModel);
* @brief Calculate CRC value for a file.
* @param [in] pszFileName The file name with path.
* @param [in] pModel The model how we calculate the CRC value.
* @return The CRC value.
DWORD CrcFile(CHAR* pszFileName,const CRCMODEL* pModel);
/// Calculate CRC value with 8 bits as a unit by default.
#define CrcMessage
CrcMessageByByte
/// Use CRC-16 model we defined already.
#define CalculateCrc16(pBuffer,dwLen)
CrcMessage(pBuffer,dwLen,&Model_Crc16)
/// Use CRC-16-CCITT model we defined already.
#define CalculateCrc16CCITT(pBuffer,dwLen)
CrcMessage(pBuffer,dwLen,&Model_Crc16_CCITT)
/// Use CRC-32 model we defined already.
#define CalculateCrc32(pBuffer,dwLen)
CrcMessage(pBuffer,dwLen,&Model_Crc32)
/// Use CRC-32 model we defined already.
#define CalculateFileCrc32(fileName)
CrcFile(fileName,&Model_Crc32)
#ifdef __cplusplus
CrcFunction.c
* @brief The file contains implementation of crc functions.
* @author XiaoJiu
* @date Commenced at
typedef unsigned long
typedef int
typedef char
typedef unsigned char
typedef void
#define TRUE
#define FALSE
#define NULL
#define BUFFERSIZE
#include &stdio.h& // Use the functions about file operation only.
void * __cdecl malloc( unsigned int _Size);
__cdecl free( void * _Memory);
__cdecl memcmp(const void * _Buf1,const void * _Buf2, unsigned int _Size);
#include &CrcFunction.h&
/// Poly(X16 + X15 + X2 + X0) used by model CRC-16 (SDLC)
#define POLY_16
/// Poly(X16 + X12 + X5 + X0) used by model CRC-ITU (CCITT/HDLC)
#define POLY_16_CCITT
//! @brief Poly(X32 + X26+ X23+X22+X16+X12+X11+X10+X8+X7+X5+X4+X2+X1+X0)
//! used by CRC-32 (ZIP/RAR/Ethernet)
#define POLY_32
0X04C11DB7
extern DWORD TABLE16[256];
extern DWORD TABLE32[256];
extern DWORD TABLE16_CCITT[256];
const CRCMODEL Model_Crc16 = {&CRC-16& , 16 , POLY_16
, 0X0000 , TRUE , TRUE , 0X0000 ,TABLE16};
const CRCMODEL Model_Crc32 = {&CRC-32& , 32 , POLY_32 , 0XFFFFFFFF , TRUE , TRUE , 0XFFFFFFFF ,TABLE32};
const CRCMODEL Model_Crc16_CCITT = {&CRC-16/CCITT&,16,POLY_16_CCITT,0XFFFF,FALSE,FALSE,0X0000,TABLE16_CCITT};
//Internal Functions///////////////////////////////////////////////////////
DWORD CrcByBitUnRef(UCHAR* pBuffer,DWORD dwLen,DWORD dwInit,DWORD dwWidth,DWORD dwPoly)
DWORD dwCrc = dwInit,dwTop = 0x01;
dwTop &&= dwWidth - 1;
while (dwLen --)
for (i = 0x80;i != 0;i &&= 1)
if (dwCrc & dwTop)
dwCrc &&= 1;
dwCrc = dwCrc ^ (dwTop && 1) ^ dwP
dwCrc &&= 1;
if (*pBuffer & i)
dwCrc ^= dwP
return dwC
DWORD CrcByByteUnRef(UCHAR* pBuffer,DWORD dwLen,DWORD dwInit,DWORD dwWidth,DWORD* pTable)
DWORD dwCrc = dwInit,dwRightMove = dwWidth - 8;
UCHAR ucHi8 = 0;
while (dwLen --)
ucHi8 = (dwCrc && dwRightMove) & 0xFF;
dwCrc &&= 8;
dwCrc &&= 32 - dwW
dwCrc &&= 32 - dwW
dwCrc ^= pTable[*pBuffer++ ^ ucHi8] ;
return dwC
/** @brief Using the reflect algorithm.
@details If data was transferred in LSB pattern,we should reflect every byte first,then
* calculate the crc value.However,it will take too much work and a lot of time.
* Some genius suggest that we leave the input message still and reverse the
* Poly Init and the crc result.The reflect algorithm comes.
* About reversing the poly:
* 1.Reversed poly is the entire poly that is being reversed,including the top bit.
* Therefore,the top bit is the leftmost in poly while is the rightmost in reversed poly.
* 2.The top bit of the poly or reversed poly is omitted.
DWORD CrcByBitRef(UCHAR* pBuffer,DWORD dwLen,DWORD dwInit,DWORD dwPolyRef)
DWORD dwCrc = dwI
while(dwLen --)
for(i = 0x01; i !=0; i&&= 1)
if (dwCrc & 0x01)
dwCrc &&= 1;
dwCrc ^= dwPolyR
dwCrc &&= 1;
if(*pBuffer & i)
dwCrc ^= dwPolyR
return dwC
/// Using the reflect algorithm.
DWORD CrcByByteRef(UCHAR* pBuffer,DWORD dwLen,DWORD dwInit,DWORD* pTable)
DWORD dwCrc = dwI
while (dwLen --)
dwCrc = pTable[*pBuffer++ ^ (dwCrc & 0xFF)] ^ (dwCrc && 8);
return dwC
/// After finish to calculate crc,we process the result as model defined.
DWORD CrcFinalProcess(DWORD dwCrc,BOOL bRefIn,BOOL bRefOut,DWORD dwWidth,DWORD dwXorOut)
if (bRefIn ^ bRefOut)
dwCrc = CrcReflectBits(dwCrc,dwWidth);
return dwCrc ^ dwXorO
/// Create a driven-table which can make calculate faster.
VOID CrcCreateTableUnRef(DWORD* pTable,DWORD dwWidth,DWORD dwPoly)
DWORD dwIndex = 0, dwCrc =0, dwTop = 0x01;
dwTop &&= (dwWidth - 1);
for( ;dwIndex & 256; ++dwIndex)
dwCrc = 0;
for (i = 0x80;i != 0;i &&= 1)
if (dwCrc & dwTop)
dwCrc &&= 1;
dwCrc = dwCrc ^ (dwTop && 1) ^ dwP
dwCrc &&= 1;
if (dwIndex & i)
dwCrc ^= dwP
pTable[dwIndex] = dwC
/// Create a driven-table which can make calculate faster,and used by the reflect algorithm.
VOID CrcCreateTableRef(DWORD* pTable,DWORD dwPolyRef)
DWORD dwIndex = 0, dwCrc = 0;
for( ;dwIndex & 256; ++dwIndex)
dwCrc = 0;
for(i = 0x01; i !=0; i &&= 1)
if (dwCrc & 0x01)
dwCrc &&= 1;
dwCrc ^= dwPolyR
dwCrc &&= 1;
if(dwIndex & i)
dwCrc ^= dwPolyR
pTable[dwIndex] = dwC
/// A function to check the static driven-table.
BOOL CrcCheckTable(const CRCMODEL* pModel)
DWORD CrcTableCreate[256] = {0};
if (!pModel-&pTable)
return FALSE;
if (pModel-&bRefIn)
CrcCreateTableRef(CrcTableCreate,CrcReflectBits(pModel-&dwPoly,pModel-&dwWidth));
CrcCreateTableUnRef(CrcTableCreate,pModel-&dwWidth,pModel-&dwPoly);
return(!memcmp(CrcTableCreate,pModel-&pTable,sizeof(DWORD) * 256 ));
//Export Function////////////////////////////////////////////////////////
DWORD CrcReflectBits(DWORD dwToRef,DWORD dwNumsFromRight)
DWORD dwReturn = 0,dwIndex = 0x01;
int i = 0;
for (;i & dwNumsFromR++i, dwIndex &&= 1)
if (dwToRef & dwIndex)
dwReturn |= 0x01 && (dwNumsFromRight - 1 - i);
return dwR
DWORD CrcMessageByByte(UCHAR* pBuffer,DWORD dwLen,const CRCMODEL* pModel)
DWORD *CrcTable = NULL, dwCrc = pModel-&dwI
// prepare the right table
if (!pModel-&pTable)
CrcTable = (DWORD*)malloc(256 * sizeof(DWORD));
if(!CrcTable)
if (pModel-&bRefIn)
CrcCreateTableRef(CrcTable,CrcReflectBits(pModel-&dwPoly,pModel-&dwWidth));
CrcCreateTableUnRef(CrcTable,pModel-&dwWidth,pModel-&dwPoly);
CrcTable = pModel-&pT
// calculate the crc value
if (pModel-&bRefIn)
dwCrc = CrcReflectBits(pModel-&dwInit,pModel-&dwWidth);
dwCrc = CrcByByteRef(pBuffer,dwLen,dwCrc,CrcTable);
dwCrc = pModel-&dwI
dwCrc = CrcByByteUnRef(pBuffer,dwLen,dwCrc,pModel-&dwWidth,CrcTable);
// finally,process the crc value.
dwCrc = CrcFinalProcess(dwCrc,pModel-&bRefIn,pModel-&bRefOut,pModel-&dwWidth,pModel-&dwXorOut);
if(!pModel-&pTable)
free(CrcTable);
return dwC
DWORD CrcMessageByBit(UCHAR* pBuffer,DWORD dwLen,const CRCMODEL* pModel)
DWORD dwCrc = 0,dwPolyRef = 0;
if (pModel-&bRefIn)
dwCrc = CrcReflectBits(pModel-&dwInit,pModel-&dwWidth);
dwPolyRef = CrcReflectBits(pModel-&dwPoly,pModel-&dwWidth);
dwCrc = CrcByBitRef(pBuffer,dwLen,dwCrc,dwPolyRef);
dwCrc = pModel-&dwI
dwCrc = CrcByBitUnRef(pBuffer,dwLen,dwCrc,pModel-&dwWidth,pModel-&dwPoly);
return CrcFinalProcess(dwCrc,pModel-&bRefIn,pModel-&bRefOut,pModel-&dwWidth,pModel-&dwXorOut);
DWORD CrcFile(CHAR* pszFileName,const CRCMODEL* pModel)
FILE* hFile = NULL;
UCHAR szBuffer[BUFFERSIZE] = {0};
DWORD dwReadBytes = 0;
DWORD *CrcTable = NULL, dwCrc = 0;
fopen_s(&hFile,pszFileName,&rb&);
if(!hFile)
// prepare the right table
if (!pModel-&pTable)
CrcTable = (DWORD*)malloc(256 * sizeof(DWORD));
if(!CrcTable)
if (pModel-&bRefIn)
CrcCreateTableRef(CrcTable,CrcReflectBits(pModel-&dwPoly,pModel-&dwWidth));
CrcCreateTableUnRef(CrcTable,pModel-&dwWidth,pModel-&dwPoly);
CrcTable = pModel-&pT
// calculate the crc value
if (pModel-&bRefIn)
dwCrc = CrcReflectBits(pModel-&dwInit,pModel-&dwWidth);
while(dwReadBytes = fread(szBuffer,1,BUFFERSIZE,hFile))
dwCrc = CrcByByteRef(szBuffer,dwReadBytes,dwCrc,CrcTable);
dwCrc = pModel-&dwI
while(dwReadBytes = fread(szBuffer,1,BUFFERSIZE,hFile))
dwCrc = CrcByByteUnRef(szBuffer,dwReadBytes,dwCrc,pModel-&dwWidth,CrcTable);
// finally,process the crc value.
dwCrc = CrcFinalProcess(dwCrc,pModel-&bRefIn,pModel-&bRefOut,pModel-&dwWidth,pModel-&dwXorOut);
if(!pModel-&pTable)
free(CrcTable);
fclose(hFile);
return dwC
/// Driven table fit the standards model CRC16.
DWORD TABLE16[256] =
0xc1, 0xc181, 0x1, 0x03c0, 0x1, 0xc601, 0x06c0,
0x1, 0xc1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41,
0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0,
0x1, 0xd801, 0x18c0, 0x1, 0x1b00, 0xdbc1, 0xda81, 0x1a40,
0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0xc1,
0xd581, 0x1, 0x17c0, 0x1, 0xd201, 0x12c0, 0x1,
0xc1, 0xd081, 0x1, 0x30c0, 0x1, 0xc1,
0xf281, 0x0, 0xf6c1, 0xf781, 0x1, 0x35c0, 0x1,
0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0,
0x3b80, 0xfb41, 0xc1, 0xf881, 0x0, 0xe8c1, 0xe981, 0x2940,
0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1,
0xec81, 0x2c40, 0xe401, 0x24c0, 0x1, 0xc1, 0xe681, 0x2640,
0xc1, 0xe381, 0x1, 0x21c0, 0x1, 0xa001, 0x60c0,
0x1, 0xc1, 0xa281, 0x0, 0xa6c1, 0xa781, 0x6740,
0xa501, 0x65c0, 0x1, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0,
0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0xc1, 0xa881, 0x6840,
0xc1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0,
0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x1,
0xc1, 0xb681, 0x0, 0xb2c1, 0xb381, 0x1, 0x71c0,
0x1, 0xc1, 0x0, 0xc0, 0x1,
0xc0, 0x1, 0xc1, 0x0, 0x9c01, 0x5cc0,
0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40,
0xc0, 0x1, 0xc0, 0x1, 0x4b00, 0x8bc1,
0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41,
0xc1, 0x0, 0xc0, 0x1, 0xc0,
0x1, 0xc1, 0x0
/// Driven table fit the standards model CRC32.
DWORD TABLE32[256] =
0xxxee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3,
0x0edbdcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91,
0x1db7ab020f2, 0xf3b9be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7,
0x136cba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x6xfa0f3d63, 0x8d080df5,
0x3b6e20c8, 0x4c69105e, 0xdxax3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59,
0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd0b4f4b5, 0x56b3c423, 0xcfbabda50f,
0x2802b89e, 0x5fxc60cd9b2, 0xb10be924, 0x2f6f7c87, 0xxc1611dab, 0xb6662d3d,
0x76dcdbd220bc, 0xefd5102a, 0x71b1b6b51f, 0x9fbfe4a5, 0xe8b8d433,
0x, 0x0f00f934, 0x9609a88e, 0xe10ef6a0dbb, 0x086d3d2d, 0xxe6635c01,
0x6b6b51f4, 0x1c6c530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x, 0xf50fc457,
0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65,
0x4db2ab551ce, 0xa3bcbb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb,
0x4369e96a, 0x346ed9fc, 0xadxda60b8d0, 0xx3xaa0a4c5f, 0xdd0d7cc9,
0x5005713c, 0x270241aa, 0xbe0bc8b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
0x5edef90e, 0x29d9c998, 0xb0d0d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad,
0xedb8abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead5dd277af, 0x04dbdc1683,
0xexx0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1,
0xf00f8a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196ce6b06e7,
0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bcfb506dd, 0x48b2364b,
0xd80d2bda, 0xaf0a1b4c, 0x3xxdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79,
0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0xxcc0c7795, 0xbb0b216b9, 0x5505262f,
0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d,
0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9cxeb0e363f, 0xx,
0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21,
0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777,
0x8xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45,
0xa00ae278, 0xd70dd2ee, 0x4ex, 0xaxdx4969474d, 0x3e6e77db,
0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
0xbdbdf21c, 0xcabac28a, 0x53b3b4a3a6, 0xbad03605, 0xcdd7ded967bf,
0xb3667a2e, 0xcx5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d
/// Driven table fit the standards model CRC16-CCITT.
DWORD TABLE16_CCITT[256] =
0x1, 0x3, 0xa5, 0x60c6, 0x70e7, 0x9,
0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x0, 0x2,
0x52b5, 0xf7, 0x62d6, 0x8, 0xb37b, 0xa35a, 0xd3bd, 0xc39c,
0xf3ff, 0xe3de, 0x3, 0x1, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x9, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x2,
0x0, 0x76d7, 0x66f6, 0xb4, 0xb75b, 0xa77a, 0x8,
0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0xa7, 0x1,
0x3, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x9, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc,
0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5,
0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b,
0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0xa9,
0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0xa1, 0x30c2, 0x20e3,
0x5, 0x7, 0x83b9, 0xfb, 0xb3da, 0xc33d, 0xd31c,
0xe37f, 0xf35e, 0x02b1, 0xf3, 0x32d2, 0x4, 0x6,
0xb5ea, 0xa5cb, 0x95a8, 0xe, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3,
0x14a0, 0x6, 0x4, 0xdb, 0xb7fa, 0xb8,
0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0xb0, 0x6,
0x4, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5, 0x7, 0x18c0, 0x08e1, 0xa3, 0xcb7d, 0xdb5c,
0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16,
0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b,
0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36,
0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：25334次
排名：千里之外
原创：17篇
(2)(1)(1)(1)(1)(1)(1)(2)(4)(1)(5)