四种加密算法之SHA1源代码-C++

SHA1.h文件：

[cpp] view plaincopyprint?

1. //! SHA1 动态链接库实现   H文件  
2. /*！ 
3.  @author 朱孟斌 
4.  @e-mail  [e-mail] 
5.  @version 1.0 
6.  @date 2011-03 
7.  @{ 
8. */  
9. #ifndef SHA1_H  
10. #define SHA1_H  
11.   
12. #include "stdint.h"  
13. //! #定义SHA 中的返回ENUM  
14. /*！ 
15.    @see enum 
16. */  
17. #ifndef _SHA_enum_  
18. #define _SHA_enum_  
19. enum  
20. {  
21.     shaSuccess = 0,  
22.     /*! <空指示参量 */  
23.     shaNull,              
24.     /*! < 输入数据太长提示 */  
25.     shaInputTooLong,  
26.      /*! <called Input after Result --以输入结果命名之 */  
27.     shaStateError        
28. };  
29. #endif  
30. //! SHA1HashSize定义的是SHA1哈希表的大小  
31. #define SHA1HashSize 20  
32. //!   #能够进行动态链接库编译的SHA1类  
33.  /*!   
34.        @see class _declspec(dllexport) SHA_1 
35.        将SHA1算法写成动态链接库的形式方便调用，生成消息使用 
36.  */  
37. class _declspec(dllexport) SHA_1  
38. {  
39. public:  
40.     //! #定义数据结构控制上下文消息 SHA1Context  
41.     /*! 
42.         以下这种结构将会控制上下文消息 for the SHA-1 
43.         hashing operation 
44.         @see struct SHA1Context 
45.     */  
46.     typedef struct SHA1Context  
47.     {  
48.         uint32_t Intermediate_Hash[SHA1HashSize/4]; /*! <Message Digest  */  
49.   
50.         uint32_t Length_Low;            /*! <Message length in bits      */  
51.         uint32_t Length_High;           /*! <Message length in bits      */  
52.   
53.         /*! <Index into message block array   */  
54.         int_least16_t Message_Block_Index;  
55.         uint8_t Message_Block[64];      /*! <512-bit message blocks      */  
56.   
57.         int Computed;               /*! <Is the digest computed?         */  
58.         int Corrupted;             /*! <Is the message digest corrupted? */  
59.     } SHA1Context;  
60.   
61. public:  
62.     //! #SHA_1 的构造函数  
63.     /*! 
64.      @see SHA_1() 
65.       其中应该对SHA_1类中的一些变量进行相应的初始化 
66.     */  
67.     SHA_1();  
68.     //! #SHA_1的析构函数  
69.     /*! 
70.     @see ~SHA_1() 
71.       释放内存 
72.     */  
73.     ~SHA_1(void);  
74.   
75.     /*----------------------------------函数原型----------------------------------*/  
76.     //! #SHA1算法中的数据填充模块  
77.     /*! 
78.       @see void SHA1PadMessage(SHA1Context *); 
79.       @param[SHA1Context*  定义填充信息指针 
80.       @return[void] 不返回任何值 
81.     */  
82.     void SHA1PadMessage(SHA1Context *);    /*  定义填充信息指针  */  
83.     //! #SHA1的消息块描述函数  
84.     /*! 
85.       @see void SHA1ProcessMessageBlock(SHA1Context *); 
86.       @param[SHA1Context*  定义填充信息指针 
87.       @param[in] 消息块长度为固定之512比特 
88.       @return[void] 不返回任何值 
89.     */  
90.     void SHA1ProcessMessageBlock(SHA1Context *);  
91.     //! #SHA1的数据初始化操作函数  
92.     /*! 
93.       @see int SHA1Reset(  SHA1Context *); 
94.       @param[SHA1Context*  定义填充信息指针 
95.       @return[int] 成功返回shaNull，失败返回shaSuccess 
96.       @see SHA1 enum 
97.     */  
98.     int SHA1Reset(  SHA1Context *);  
99.     //! #SHA1的输入描述函数  
100.     /*! 
101.       @see int SHA1Input(  SHA1Context *, const uint8_t *, unsigned int); 
102.       @param[SHA1Context*  定义填充信息指针 
103.       @param[uint8_t 接收单位长度为8字节倍数的消息 
104.       @return[enum] 成功返回shaNull，失败返回shaSuccess，错误返回shaStateError 
105.       @see SHA1 enum 
106.     */  
107.     int SHA1Input(  SHA1Context *, const uint8_t *, unsigned int);  
108.     //! #SHA1的结果描述函数  
109.     /*! 
110.       @see int SHA1Result( SHA1Context *, uint8_t Message_Digest[SHA1HashSize]); 
111.       @param[SHA1Context*  定义填充信息指针 
112.       @param[uint8_t 160比特的消息摘要队列 
113.       @attention 返回一个160比特的消息摘要队列 
114.       @return[enum] 成功返回shaNull，失败返回shaSuccess，错误返回shaStateError 
115.       @see SHA1 enum 
116.     */  
117.     int SHA1Result( SHA1Context *, uint8_t Message_Digest[SHA1HashSize]);  
118.   
119. private:  
120. };  
121.   
122. #endif // SHA1_H  

//! SHA1 动态链接库实现   H文件/*！ @author 朱孟斌 @e-mail  [e-mail] @version 1.0 @date 2011-03 @{*/#ifndef SHA1_H#define SHA1_H#include "stdint.h"//! #定义SHA 中的返回ENUM/*！   @see enum*/#ifndef _SHA_enum_#define _SHA_enum_enum{shaSuccess = 0,/*! <空指示参量 */shaNull,            /*! < 输入数据太长提示 */shaInputTooLong, /*! <called Input after Result --以输入结果命名之 */shaStateError      };#endif//! SHA1HashSize定义的是SHA1哈希表的大小#define SHA1HashSize 20//!   #能够进行动态链接库编译的SHA1类 /*!         @see class _declspec(dllexport) SHA_1       将SHA1算法写成动态链接库的形式方便调用，生成消息使用 */class _declspec(dllexport) SHA_1{public://! #定义数据结构控制上下文消息 SHA1Context/*!    以下这种结构将会控制上下文消息 for the SHA-1    hashing operation@see struct SHA1Context*/typedef struct SHA1Context{uint32_t Intermediate_Hash[SHA1HashSize/4]; /*! <Message Digest  */uint32_t Length_Low;            /*! <Message length in bits      */uint32_t Length_High;           /*! <Message length in bits      *//*! <Index into message block array   */int_least16_t Message_Block_Index;uint8_t Message_Block[64];      /*! <512-bit message blocks      */int Computed;               /*! <Is the digest computed?         */int Corrupted;             /*! <Is the message digest corrupted? */} SHA1Context;public:    //! #SHA_1 的构造函数    /*! @see SHA_1()      其中应该对SHA_1类中的一些变量进行相应的初始化    */SHA_1();//! #SHA_1的析构函数    /*!@see ~SHA_1()      释放内存    */~SHA_1(void);/*----------------------------------函数原型----------------------------------*///! #SHA1算法中的数据填充模块    /*!  @see void SHA1PadMessage(SHA1Context *);  @param[SHA1Context*  定义填充信息指针  @return[void] 不返回任何值    */void SHA1PadMessage(SHA1Context *);    /*  定义填充信息指针  */    //! #SHA1的消息块描述函数    /*!  @see void SHA1ProcessMessageBlock(SHA1Context *);  @param[SHA1Context*  定义填充信息指针  @param[in] 消息块长度为固定之512比特  @return[void] 不返回任何值    */void SHA1ProcessMessageBlock(SHA1Context *);//! #SHA1的数据初始化操作函数    /*!  @see int SHA1Reset(  SHA1Context *);  @param[SHA1Context*  定义填充信息指针  @return[int] 成功返回shaNull，失败返回shaSuccess  @see SHA1 enum    */int SHA1Reset(  SHA1Context *);//! #SHA1的输入描述函数    /*!  @see int SHA1Input(  SHA1Context *, const uint8_t *, unsigned int);  @param[SHA1Context*  定义填充信息指针      @param[uint8_t 接收单位长度为8字节倍数的消息  @return[enum] 成功返回shaNull，失败返回shaSuccess，错误返回shaStateError  @see SHA1 enum    */int SHA1Input(  SHA1Context *, const uint8_t *, unsigned int);//! #SHA1的结果描述函数    /*!  @see int SHA1Result( SHA1Context *, uint8_t Message_Digest[SHA1HashSize]);  @param[SHA1Context*  定义填充信息指针      @param[uint8_t 160比特的消息摘要队列  @attention 返回一个160比特的消息摘要队列  @return[enum] 成功返回shaNull，失败返回shaSuccess，错误返回shaStateError  @see SHA1 enum    */int SHA1Result( SHA1Context *, uint8_t Message_Digest[SHA1HashSize]);private:};#endif // SHA1_H

SHA1.cpp文件：

[cpp] view plaincopyprint?

1. //! SHA1 动态链接库实现   CPP文件  
2. /*！ 
3.  @author 朱孟斌 
4.  @e-mail  [e-mail] 
5.  @version 1.0 
6.  @date 2011-03 
7.  @{ 
8. */  
9. #include "SHA1.h"  
10. /*！以下所用各种参量名称皆为sha-1在出版物上所用之公用名称  */  
11. /* 
12.  *  以下是为 SHA1 向左环形移位宏 之定义 
13.  */  
14. #define SHA1CircularShift(bits,word) \  
15.                 (((word) << (bits)) | ((word) >> (32-(bits))))  
16.   
17. SHA_1::SHA_1()  
18. {  
19. }  
20.   
21. SHA_1::~SHA_1(void)  
22. {  
23. }  
24.   
25. /* 
26.  *  以下为sha-1消息块描述： 
27.  *  消息块长度为固定之512比特 
28.  */  
29. void SHA_1::SHA1ProcessMessageBlock(SHA1Context *context)  
30. {  
31.     const uint32_t K[] =    {       /* Constants defined in SHA-1   */  
32.                             0x5A827999,  
33.                             0x6ED9EBA1,  
34.                             0x8F1BBCDC,  
35.                             0xCA62C1D6  
36.                             };  
37.     int               t;                 /* 循环计数 */  
38.     uint32_t      temp;              /* 临时缓存 */  
39.     uint32_t      W[80];             /* 字顺序   */  
40.     uint32_t      A, B, C, D, E;     /* 设置系统磁盘缓存块 */  
41.   
42.     /* 
43.      *  以下为初始化在W队列中的头16字数据 
44.      */  
45.     for(t = 0; t < 16; t++)  
46.     {  
47.         W[t] = context->Message_Block[t * 4] << 24;  
48.         W[t] |= context->Message_Block[t * 4 + 1] << 16;  
49.         W[t] |= context->Message_Block[t * 4 + 2] << 8;  
50.         W[t] |= context->Message_Block[t * 4 + 3];  
51.     }  
52.   
53.     for(t = 16; t < 80; t++)  
54.     {  
55.        W[t] = SHA1CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);  
56.     }  
57.   
58.     A = context->Intermediate_Hash[0];  
59.     B = context->Intermediate_Hash[1];  
60.     C = context->Intermediate_Hash[2];  
61.     D = context->Intermediate_Hash[3];  
62.     E = context->Intermediate_Hash[4];  
63.     /*   
64.      *  以下为定义算法所用之数学函数及其迭代算法描述   
65.      */  
66.     for(t = 0; t < 20; t++)  
67.     {  
68.         temp =  SHA1CircularShift(5,A) +  
69.             ((B & C) | ((~B) & D)) + E + W[t] + K[0];  
70.         E = D;  
71.         D = C;  
72.         C = SHA1CircularShift(30,B);  
73.         B = A;  
74.         A = temp;  
75.     }  
76.   
77.     for(t = 20; t < 40; t++)  
78.     {  
79.         temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];  
80.         E = D;  
81.         D = C;  
82.         C = SHA1CircularShift(30,B);  
83.         B = A;  
84.         A = temp;  
85.     }  
86.   
87.     for(t = 40; t < 60; t++)  
88.     {  
89.         temp = SHA1CircularShift(5,A) +  
90.                ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];  
91.         E = D;  
92.         D = C;  
93.         C = SHA1CircularShift(30,B);  
94.         B = A;  
95.         A = temp;  
96.     }  
97.   
98.     for(t = 60; t < 80; t++)  
99.     {  
100.         temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];  
101.         E = D;  
102.         D = C;  
103.         C = SHA1CircularShift(30,B);  
104.         B = A;  
105.         A = temp;  
106.     }  
107.     /*   
108.      *  以下为迭代算法第80步（最后一步）描述 
109.      */  
110.     context->Intermediate_Hash[0] += A;  
111.     context->Intermediate_Hash[1] += B;  
112.     context->Intermediate_Hash[2] += C;  
113.     context->Intermediate_Hash[3] += D;  
114.     context->Intermediate_Hash[4] += E;  
115.   
116.     context->Message_Block_Index = 0;  
117. }  
118.   
119.   
120. /* 
121.  *  SHA1PadMessage 
122.  *  数据填充模块 
123.  */  
124.   
125. void SHA_1::SHA1PadMessage(SHA1Context *context)  
126. {  
127.   
128.     if (context->Message_Block_Index > 55)  
129.     {  
130.         context->Message_Block[context->Message_Block_Index++] = 0x80;  
131.         while(context->Message_Block_Index < 64)  
132.         {  
133.             context->Message_Block[context->Message_Block_Index++] = 0;  
134.         }  
135.   
136.         SHA1ProcessMessageBlock(context);  
137.   
138.         while(context->Message_Block_Index < 56)  
139.         {  
140.             context->Message_Block[context->Message_Block_Index++] = 0;  
141.         }  
142.     }  
143.     else  
144.     {  
145.         context->Message_Block[context->Message_Block_Index++] = 0x80;  
146.         while(context->Message_Block_Index < 56)  
147.         {  
148.             context->Message_Block[context->Message_Block_Index++] = 0;  
149.         }  
150.     }  
151.   
152.     /* 
153.      *  把最后64位保存为数据长度 
154.      */  
155.     context->Message_Block[56] = context->Length_High >> 24;  
156.     context->Message_Block[57] = context->Length_High >> 16;  
157.     context->Message_Block[58] = context->Length_High >> 8;  
158.     context->Message_Block[59] = context->Length_High;  
159.     context->Message_Block[60] = context->Length_Low >> 24;  
160.     context->Message_Block[61] = context->Length_Low >> 16;  
161.     context->Message_Block[62] = context->Length_Low >> 8;  
162.     context->Message_Block[63] = context->Length_Low;  
163.   
164.     SHA1ProcessMessageBlock(context);  
165. }  
166.   
167. /* 
168.  *  SHA1Reset 
169.  *   
170.  *  以下为数据初始化之操作 
171.  *  Parameters:（参数设置） 
172.  *  context: [in/out] 
173.  *  The context to reset. 
174.  * 
175.  */  
176. int SHA_1::SHA1Reset(SHA1Context *context)  
177. {  
178.     if (!context)  
179.     {  
180.         return shaNull;  
181.     }  
182.   
183.     context->Length_Low             = 0;  
184.     context->Length_High            = 0;  
185.     context->Message_Block_Index    = 0;  
186.   
187.     context->Intermediate_Hash[0]   = 0x67452301;  
188.     context->Intermediate_Hash[1]   = 0xEFCDAB89;  
189.     context->Intermediate_Hash[2]   = 0x98BADCFE;  
190.     context->Intermediate_Hash[3]   = 0x10325476;  
191.     context->Intermediate_Hash[4]   = 0xC3D2E1F0;  
192.   
193.     context->Computed   = 0;  
194.     context->Corrupted  = 0;  
195.     return shaSuccess;  
196. }  
197.   
198. /* 
199.  *  SHA1Result 
200.  * 
201.  *  以下为sha-1结果描述： 
202.  *: 
203.  *  该算法将会返回一个160比特的消息摘要队列 
204.  * 
205.  *  或者输出计算错误 
206.  * 
207.  */  
208. int SHA_1::SHA1Result( SHA1Context *context,  
209.                 uint8_t Message_Digest[SHA1HashSize])  
210. {  
211.     int i;  
212.   
213.     if (!context || !Message_Digest)  
214.     {  
215.         return shaNull;  
216.     }  
217.   
218.     if (context->Corrupted)  
219.     {  
220.         return context->Corrupted;  
221.     }  
222.   
223.     if (!context->Computed)  
224.     {  
225.         SHA1PadMessage(context);  
226.         for(i=0; i<64; ++i)  
227.         {  
228.             /* 消息清零 */  
229.             context->Message_Block[i] = 0;  
230.         }  
231.         context->Length_Low = 0;    /* 长度清零 */  
232.         context->Length_High = 0;  
233.         context->Computed = 1;  
234.     }  
235.   
236.     for(i = 0; i < SHA1HashSize; ++i)  
237.     {  
238.         Message_Digest[i] = context->Intermediate_Hash[i>>2]  
239.                             >> 8 * ( 3 - ( i & 0x03 ) );  
240.     }  
241.   
242.     return shaSuccess;  
243. }  
244.   
245. /* 
246.  *  以下为sha-1输入描述： 
247.  * 
248.  *  接收单位长度为8字节倍数的消息 
249.  * 
250.  */  
251. int SHA_1::SHA1Input(    SHA1Context    *context,  
252.                   const uint8_t  *message_array,  
253.                   unsigned       length)  
254. {  
255.     if (!length)  
256.     {  
257.         return shaSuccess;  
258.     }  
259.   
260.     if (!context || !message_array)  
261.     {  
262.         return shaNull;  
263.     }  
264.   
265.     if (context->Computed)  
266.     {  
267.         context->Corrupted = shaStateError;  
268.         return shaStateError;  
269.     }  
270.   
271.     if (context->Corrupted)  
272.     {  
273.          return context->Corrupted;  
274.     }  
275.     while(length-- && !context->Corrupted)  
276.     {  
277.     context->Message_Block[context->Message_Block_Index++] =  
278.                     (*message_array & 0xFF);  
279.   
280.     context->Length_Low += 8;  
281.     if (context->Length_Low == 0)  
282.     {  
283.         context->Length_High++;  
284.         if (context->Length_High == 0)  
285.         {  
286.             /* Message is too long */  
287.             context->Corrupted = 1;  
288.         }  
289.     }  
290.   
291.     if (context->Message_Block_Index == 64)  
292.     {  
293.         SHA1ProcessMessageBlock(context);  
294.     }  
295.   
296.     message_array++;  
297.     }  
298.   
299.     return shaSuccess;  
300. }