sha1加密出现概率性错误问题
这2天有个项目，涉及到要将数据进行sha1加密后发送给客户的服务器上，但是经常会概率性出现加密生成的密文和客户的匹配不上（因为客户服务端也会将接收到的数据进行加密匹配）。经过分析，是公用的sha1的实现出了问题，对要加密的字符串太长时，sha1加会出现错误。加密生成的验证可以找在线的sha1进行比较。
然后把sha1的重要实现的部分换成了string类型，这样就不会出现这样的错误的了。
代码的实现如下：
(1) .h的文件如下：
class SS_SHA1
{
public:
SS_SHA1();
virtual ~SS_SHA1();
void Reset();
bool Result(unsigned *message_digest_array);
std::string & GetResult(std::string &szSHA1);
void Input(const unsigned char *message_array,unsigned length);
void Input(const char *message_array,unsigned length);
void Input(unsigned char message_element);
void Input(char message_element);
SS_SHA1& operator<<(const char *message_array);
SS_SHA1& operator<<(const unsigned char *message_array);
SS_SHA1& operator<<(const char message_element);
SS_SHA1& operator<<(const unsigned char message_element);
private:
void ProcessMessageBlock();
void PadMessage();
inline unsigned CircularShift(int bits, unsigned word);
unsigned H[5]; // Message digest buffers
unsigned Length_Low; // Message length in bits
unsigned Length_High; // Message length in bits
unsigned char Message_Block[64]; // 512-bit message blocks
int Message_Block_Index; // Index into message block array
bool Computed; // Is the digest computed?
bool Corrupted; // Is the message digest corruped?
};
（2） .cpp的实现如下：
SS_SHA1::SS_SHA1()
{
Reset();
}
SS_SHA1::~SS_SHA1()
{
// The destructor does nothing
}
void SS_SHA1::Reset()
{
Length_Low = 0;
Length_High = 0;
Message_Block_Index = 0;
H[0] = 0x67452301;
H[1] = 0xEFCDAB89;
H[2] = 0x98BADCFE;
H[3] = 0x10325476;
H[4] = 0xC3D2E1F0;
Computed = false;
Corrupted = false;
}
bool SS_SHA1::Result(unsigned *message_digest_array)
{
int i; // Counter
if (Corrupted)
{
return false;
}
if (!Computed)
{
PadMessage();
Computed = true;
}
for (i = 0; i < 5; i++)
{
message_digest_array[i] = H[i];
}
return true;
}
std::string& SS_SHA1::GetResult(std::string &szSHA1)
{
unsigned int un32Digest[5];
SS_SHA1::Result(un32Digest);
szSHA1 = cstr::format("%08x%08x%08x%08x%08x", un32Digest[0], un32Digest[1], un32Digest[2], un32Digest[3], un32Digest[4]);
#if 0
char sDigest[24] = "";
char sSHA1[64] = "";
unsigned char ub = 0;;
*((unsigned int*)sDigest) = htonl(un32Digest[0]);
*((unsigned int*)(sDigest + 4)) = htonl(un32Digest[1]);
*((unsigned int*)(sDigest + 8)) = htonl(un32Digest[2]);
*((unsigned int*)(sDigest + 12)) = htonl(un32Digest[3]);
*((unsigned int*)(sDigest + 16)) = htonl(un32Digest[4]);
for (int i = 0, j = 0; i < 20; i++, j += 2)
{
ub = *((unsigned char*)(sDigest + i));
sSHA1[j] = CGlobal::NumToHex((ub) >> 4);/*高4位*/;
sSHA1[j + 1] = CGlobal::NumToHex((ub)& 0x0f);/*低4位*/;
}
szSHA1 = sSHA1;
#endif
return szSHA1;
}
void SS_SHA1::Input(const unsigned char *message_array,unsigned length)
{
if (!length)
{
return;
}
if (Computed || Corrupted)
{
Corrupted = true;
return;
}
while (length-- && !Corrupted)
{
Message_Block[Message_Block_Index++] = (*message_array & 0xFF);
Length_Low += 8;
Length_Low &= 0xFFFFFFFF; // Force it to 32 bits
if (Length_Low == 0)
{
Length_High++;
Length_High &= 0xFFFFFFFF; // Force it to 32 bits
if (Length_High == 0)
{
Corrupted = true; // Message is too long
}
}
if (Message_Block_Index == 64)
{
ProcessMessageBlock();
}
message_array++;
}
}
void SS_SHA1::Input(const char *message_array,
unsigned length)
{
Input((unsigned char *)message_array, length);
}
void SS_SHA1::Input(unsigned char message_element)
{
Input(&message_element, 1);
}
void SS_SHA1::Input(char message_element)
{
Input((unsigned char *)&message_element, 1);
}
SS_SHA1& SS_SHA1::operator<<(const char *message_array)
{
const char *p = message_array;
while (*p)
{
Input(*p);
p++;
}
return *this;
}
SS_SHA1& SS_SHA1::operator<<(const unsigned char *message_array)
{
const unsigned char *p = message_array;
while (*p)
{
Input(*p);
p++;
}
return *this;
}
SS_SHA1& SS_SHA1::operator<<(const char message_element)
{
Input((unsigned char *)&message_element, 1);
return *this;
}
SS_SHA1& SS_SHA1::operator<<(const unsigned char message_element)
{
Input(&message_element, 1);
return *this;
}
void SS_SHA1::ProcessMessageBlock()
{
const unsigned K[] = { // Constants defined for SHA-1
0x5A827999,
0x6ED9EBA1,
0x8F1BBCDC,
0xCA62C1D6
};
int t; // Loop counter
unsigned temp; // Temporary word value
unsigned W[80]; // Word sequence
unsigned A, B, C, D, E; // Word buffers
for (t = 0; t < 16; t++)
{
W[t] = ((unsigned)Message_Block[t * 4]) << 24;
W[t] |= ((unsigned)Message_Block[t * 4 + 1]) << 16;
W[t] |= ((unsigned)Message_Block[t * 4 + 2]) << 8;
W[t] |= ((unsigned)Message_Block[t * 4 + 3]);
}
for (t = 16; t < 80; t++)
{
W[t] = CircularShift(1, W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16]);
}
A = H[0];
B = H[1];
C = H[2];
D = H[3];
E = H[4];
for (t = 0; t < 20; t++)
{
temp = CircularShift(5, A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = CircularShift(30, B);
B = A;
A = temp;
}
for (t = 20; t < 40; t++)
{
temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[1];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = CircularShift(30, B);
B = A;
A = temp;
}
for (t = 40; t < 60; t++)
{
temp = CircularShift(5, A) +
((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = CircularShift(30, B);
B = A;
A = temp;
}
for (t = 60; t < 80; t++)
{
temp = CircularShift(5, A) + (B ^ C ^ D) + E + W[t] + K[3];
temp &= 0xFFFFFFFF;
E = D;
D = C;
C = CircularShift(30, B);
B = A;
A = temp;
}
H[0] = (H[0] + A) & 0xFFFFFFFF;
H[1] = (H[1] + B) & 0xFFFFFFFF;
H[2] = (H[2] + C) & 0xFFFFFFFF;
H[3] = (H[3] + D) & 0xFFFFFFFF;
H[4] = (H[4] + E) & 0xFFFFFFFF;
Message_Block_Index = 0;
}
unsigned SS_SHA1::CircularShift(int bits, unsigned word)
{
return ((word << bits) & 0xFFFFFFFF) | ((word & 0xFFFFFFFF) >> (32 - bits));
}
void SS_SHA1::PadMessage()
{
if (Message_Block_Index > 55)
{
Message_Block[Message_Block_Index++] = 0x80;
while (Message_Block_Index < 64)
{
Message_Block[Message_Block_Index++] = 0;
}
ProcessMessageBlock();
while (Message_Block_Index < 56)
{
Message_Block[Message_Block_Index++] = 0;
}
}
else
{
Message_Block[Message_Block_Index++] = 0x80;
while (Message_Block_Index < 56)
{
Message_Block[Message_Block_Index++] = 0;
}
Message_Block[56] = (Length_High >> 24) & 0xFF;
Message_Block[57] = (Length_High >> 16) & 0xFF;
Message_Block[58] = (Length_High >> 8) & 0xFF;
Message_Block[59] = (Length_High)& 0xFF;
Message_Block[60] = (Length_Low >> 24) & 0xFF;
Message_Block[61] = (Length_Low >> 16) & 0xFF;
Message_Block[62] = (Length_Low >> 8) & 0xFF;
Message_Block[63] = (Length_Low)& 0xFF;
ProcessMessageBlock();
}
（３）使用的方法如下：
SS_SHA1 c_sha;
c_sha.Reset();
c_sha << pTmpMt->szPhoneList;
c_sha.GetResult(szSHA1);
解析：szPhoneList 表示 要加密的字符串，GetResult得到的是sha1加密后的值。加必出现概率性错误的就是GetResult这块，换成string的取值来实现后就不会出现这种情况的了。。