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

SHA1.h文件:

[cpp]  view plain copy
  1. //! SHA1 动态链接库实现   H文件  
  2. /*! 
  3.  @author 朱孟斌 
  4.  @e-mail  zmb.tsubasa@gmail.com 
  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.cpp文件:

[cpp]  view plain copy
  1. //! SHA1 动态链接库实现   CPP文件  
  2. /*! 
  3.  @author 朱孟斌 
  4.  @e-mail  zmb.tsubasa@gmail.com 
  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;  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值