c语言对字符串进行sha1,一个关于sha1的程序~~

已结贴√

问题点数：20 回复次数：2

一个关于sha1的程序~~

高手帮我解释一下这个是个神马

怎么用他计算散列值？

#include "sha1.h"

// Define the SHA1 circular left shift macro

#define SHA1CircularShift(bits, word) (((word) << (bits)) | ((word) >> (32-(bits))))

// Local Function Prototyptes */

void SHA1PadMessage(SHA1Context *);

void SHA1ProcessMessageBlock(SHA1Context *);

int SHA1Reset(SHA1Context *c)

{

if (!c)

return shaNull;

c->Length_Low             = 0;

c->Length_High            = 0;

c->Message_Block_Index    = 0;

c->Intermediate_Hash[0]   = 0x67452301;

c->Intermediate_Hash[1]   = 0xEFCDAB89;

c->Intermediate_Hash[2]   = 0x98BADCFE;

c->Intermediate_Hash[3]   = 0x10325476;

c->Intermediate_Hash[4]   = 0xC3D2E1F0;

c->Computed   = 0;

c->Corrupted  = 0;

return shaSuccess;

}

int SHA1Result( SHA1Context *c, unsigned char Message_Digest[SHA1HashSize])

{

int i;

if (!c || !Message_Digest)

return shaNull;

if (c->Corrupted)

return c->Corrupted;

if (!c->Computed)

{

SHA1PadMessage(c);

for(i = 0; i<64; c->Message_Block[++i] = 0)

;

c->Length_Low = 0;    /**//* and clear length */

c->Length_High = 0;

c->Computed = 1;

}

for(i = 0; i < SHA1HashSize; ++i)

Message_Digest[i] = c->Intermediate_Hash[i>>2] >> 8 * (3 - (i & 0x03));

return shaSuccess;

}

int SHA1Input(SHA1Context *context, const unsigned char *message_array, unsigned length)

{

if (!length)

return shaSuccess;

if (!context || !message_array)

return shaNull;

if (context->Computed)

{

context->Corrupted = shaStateError;

return shaStateError;

}

if (context->Corrupted)

return context->Corrupted;

while(length-- && !context->Corrupted)

{

context->Message_Block[context->Message_Block_Index++] = (*message_array & 0xFF);

context->Length_Low += 8;

if (context->Length_Low == 0)

{

context->Length_High++;

if (context->Length_High == 0)

{

/**//* Message is too long */

context->Corrupted = 1;

}

}

if (context->Message_Block_Index == 64)

SHA1ProcessMessageBlock(context);

message_array++;

}

return shaSuccess;

}

void SHA1ProcessMessageBlock(SHA1Context *context)

{

const DWORD K[] =    ...{ 0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6 };

int   t;

DWORD temp;

DWORD W[80];

DWORD A, B, C, D, E;

/**//*

*  Initialize the first 16 words in the array W

*/

for(t = 0; t < 16; t++)

{

W[t]  = context->Message_Block[t * 4] << 24;

W[t] |= context->Message_Block[t * 4 + 1] << 16;

W[t] |= context->Message_Block[t * 4 + 2] << 8;

W[t] |= context->Message_Block[t * 4 + 3];

}

for(t = 16; t < 80; t++)

W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);

A = context->Intermediate_Hash[0];

B = context->Intermediate_Hash[1];

C = context->Intermediate_Hash[2];

D = context->Intermediate_Hash[3];

E = context->Intermediate_Hash[4];

for(t = 0; t < 20; t++)

{

temp =  SHA1CircularShift(5,A) +

((B & C) | ((~B) & D)) + E + W[t] + K[0];

E = D;

D = C;

C = SHA1CircularShift(30,B);

B = A;

A = temp;

}

for(t = 20; t < 40; t++)

{

temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];

E = D;

D = C;

C = SHA1CircularShift(30,B);

B = A;

A = temp;

}

for(t = 40; t < 60; t++)

{

temp = SHA1CircularShift(5,A) +

((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];

E = D;

D = C;

C = SHA1CircularShift(30,B);

B = A;

A = temp;

}

for(t = 60; t < 80; t++)

{

temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];

E = D;

D = C;

C = SHA1CircularShift(30,B);

B = A;

A = temp;

}

context->Intermediate_Hash[0] += A;

context->Intermediate_Hash[1] += B;

context->Intermediate_Hash[2] += C;

context->Intermediate_Hash[3] += D;

context->Intermediate_Hash[4] += E;

context->Message_Block_Index = 0;

}

void SHA1PadMessage(SHA1Context *context)

{

if (context->Message_Block_Index > 55)

{

context->Message_Block[context->Message_Block_Index++] = 0x80;

while(context->Message_Block_Index < 64)

context->Message_Block[context->Message_Block_Index++] = 0;

SHA1ProcessMessageBlock(context);

while(context->Message_Block_Index < 56)

context->Message_Block[context->Message_Block_Index++] = 0;

}

else

{

context->Message_Block[context->Message_Block_Index++] = 0x80;

while(context->Message_Block_Index < 56)

context->Message_Block[context->Message_Block_Index++] = 0;

}

/**//*

*  Store the message length as the last 8 octets

*/

context->Message_Block[56] = context->Length_High >> 24;

context->Message_Block[57] = context->Length_High >> 16;

context->Message_Block[58] = context->Length_High >> 8;

context->Message_Block[59] = context->Length_High;

context->Message_Block[60] = context->Length_Low >> 24;

context->Message_Block[61] = context->Length_Low >> 16;

context->Message_Block[62] = context->Length_Low >> 8;

context->Message_Block[63] = context->Length_Low;

SHA1ProcessMessageBlock(context);

}

// Convert 5 Bytes to 8 Bytes Base32

void _Sha1toBase32(unsigned char *out, const unsigned char *in)

{

const char *Table = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";

out[0] = Table[((in[0] >> 3)               ) & 0x1F];

out[1] = Table[((in[0] << 2) | (in[1] >> 6)) & 0x1F];

out[2] = Table[((in[1] >> 1)               ) & 0x1F];

out[3] = Table[((in[1] << 4) | (in[2] >> 4)) & 0x1F];

out[4] = Table[((in[2] << 1) | (in[3] >> 7)) & 0x1F];

out[5] = Table[((in[3] >> 2)               ) & 0x1F];

out[6] = Table[((in[3] << 3) | (in[4] >> 5)) & 0x1F];

out[7] = Table[((in[4]     )               ) & 0x1F];

}

// Return a base32 representation of a sha1 hash

CString Sha1toBase32(const unsigned char *Sha1)

{

char Base32[32];

CString ret;

_Sha1toBase32((unsigned char *)Base32, Sha1);

_Sha1toBase32((unsigned char *)Base32 + 8, Sha1 + 5);

_Sha1toBase32((unsigned char *)Base32 + 16, Sha1 + 10);

_Sha1toBase32((unsigned char *)Base32 + 24, Sha1 + 15);

ret = CString(Base32, 32);

return ret;

}

CString GetSHA1String(CString sSource)

{

SHA1Context context;

unsigned char digest[20];

CString sTmp, sRet;

SHA1Reset(&context);

SHA1Input(&context, (const BYTE*)sSource.GetBuffer(0), sSource.GetLength());

SHA1Result(&context,digest);

for (int i = 0; i < 20; i++) ...{

sTmp.Format("%02X", digest[i]);

sRet += sTmp;

}

return sRet;

}

我是分隔符~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

sha1.h

#ifndef _SHA1_H_

#define _SHA1_H_

/**//* sha1.h */

#ifndef _SHA_enum_

#define _SHA_enum_

enum

{

shaSuccess = 0,

shaNull,            /**//* Null pointer parameter */

shaInputTooLong,    /**//* input data too long */

shaStateError       /**//* called Input after Result */

};

#endif

#define SHA1HashSize 20

typedef struct SHA1Context

{

DWORD Intermediate_Hash[SHA1HashSize/4]; // Message Digest

DWORD Length_Low;            // Message length in bits

DWORD Length_High;            // Message length in bits

int Message_Block_Index;    // Index into message block array

unsigned char Message_Block[64];    // 512-bit message blocks

int Computed;                // Is the digest computed?

int Corrupted;                // Is the message digest corrupted?

} SHA1Context;

// Function Prototypes

CString GetSHA1String(CString sSource);

int SHA1Reset(SHA1Context *);

int SHA1Input(SHA1Context *, const unsigned char *, unsigned int);

int SHA1Result(SHA1Context *, unsigned char Message_Digest[SHA1HashSize]);

CString Sha1toBase32(const unsigned char *);

#endif

搜索更多相关主题的帖子:

return　神马　word