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

最新推荐文章于 2024-09-04 00:42:56 发布
最新推荐文章于 2024-09-04 00:42:56 发布
阅读量3.4k 收藏 5
点赞数 1
分类专栏： c/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;  
  300. } 
kynge136
关注
专栏目录
SHA1散列算法及其C++实现
FlushHip
09-19 9441
这里重点说一下SHA1算法的实现步骤与代码，由于本人水平有限，不过多讨论SHA1的数学原理以及应用场景。 SHA1简介 In cryptography, SHA-1 (Secure Hash Algorithm 1) is a cryptographic hash function which takes an input and produces a 160-bit (20-byte) has...
密码学--SHA-1算法（C++实现+详细注释+测试）
0k-ok
07-01 8707
源码： #include<bits/stdc++.h> #define H_NUM 8 //一个字32bite也就是8个十六进制数(4bite) #define BINARY 16 //16进制 #define GROUP_BIT 512 //消息认证码一组512bite using namespace std; //文件中的数据 string s; //5个寄存器的初始值 string A0 = "67452301"; string B0 = "EFCDAB89"; stri.
SHA-1【安全散列算法】
最新发布
IT_WEH_coder的博客
09-04 549
SHA-1算法是由美国国家安全局（NSA）设计的，于1995年发布。它是MD4、MD5的后继者，MD4、MD5是具有相似功能的算法。SHA-1算法在设计上旨在提供安全性，并抵抗弱碰撞（找到两个具有相同哈希值的不同输入）和强碰撞（找到具有相同哈希值的任意两个输入）的能力。然而，随着时间的推移和计算能力的提升，SHA-1算法被发现存在一些漏洞，例如，2017年研究人员成功实现了SHA-1的碰撞攻击。因此，现在不推荐使用SHA-1算法进行敏感数据的加密，而是使用更强大的安全散列算法，例如SHA-256、SHA-3
C++实现SHA-1加密
renshy5的博客
11-06 3901
C++ 实现SHA-1加密实验目的实验原理1、增加1000 0000串2、拓展字符串3、实现SHA-1循环实验代码完成测试注意事项 实验目的 实现SHA-1加密 实验原理 1、增加1000 0000串 建立一个pad数组，储存增加的串，不管原来的字符串有多长，都先增加一个1000 000串，也就是pad[0]=128。 2、拓展字符串 如果字符串长度l%512!=448，那就进行拓展，补充0000...
SHA1步骤详解及C++实现
kidding10086的博客
01-23 1557
将数据按512比特一块进行分块，得到n块数据，记作M1M2⋯MnM1M2⋯Mn一些操作和常量如下对于整数t，和三个32位字B，C，D，有f(t;f(t;f(t;将M(i)分为16个字W(0),W(1),...,W(15),其中W(0)是最左侧的字;E = D;D = C;B = A;A = TEMP;输出H0H1H2H3H4的160比特串，即为消息摘要。
300种加密解密算法c源代码，加解密算法大全合集
10-13
除了这两种主要类型，还有哈希函数（如MD5、SHA-1、SHA-256）和消息认证码（MAC，如HMAC），它们在数据完整性验证和数字签名中发挥重要作用。 C语言源代码的集合可能涵盖了以下内容： - 基础加密算法：例如简单的...
SHA常用算法实现（SHA-1, SHA256, SHA384, SHA512）
11-06
本文将详细介绍SHA-1、SHA-256、SHA-384以及SHA-512这四种算法，并结合C语言实现进行讲解。 1. SHA-1算法： SHA-1是SHA家族的最早成员，由美国国家安全局（NSA）设计，于1993年发布。它对任意长度的信息进行处理，...
asn的C++加密算法实现代码.zip
04-10
1. `asn.cpp`：这是C++源代码文件，实现了ASN.1编码和解码的功能，以及可能的加密算法接口。它可能包括解析和构建ASN.1结构的函数，以及与加密相关的操作。 2. `asn.h`：这是一个头文件，声明了asn.cpp中定义的类和...
HMAC-SHA-1算法C++实现
04-09
在"**HMACSHA1CP**"这个压缩包中，可能包含了实现HMAC-SHA-1算法的C++源代码，包括相关的头文件、源文件和可能的测试用例。你可以通过查看这些文件，了解具体实现细节和使用方法。通过学习和理解这个实现，不仅可以...
SHA1加密算法的c++实现
04-22
标准SHA1算法的C++实现，讲解了该算法的计算原理，并对难懂代码进行解释和具体的使用方法。拿来就能用。
SHA-1算法C++实现
03-10
主要使用c++将SHA-1算法的加密过程进行了实现。 清晰的算法逻辑结构，详细的注释和测试，清晰易懂。
VC++ SHA1加密算法
01-17
非常好用的VC++ SHA1加密算法！OKOK!
sha1算法实现（收集网络中好的代码）
kevinwangshilin的博客
08-28 252
【代码】sha1算法实现（收集网络中好的代码）
SHA-1算法详解和C++实现
sinat_35794373的博客
10-01 2065
SHA-1算法详解和C++实现 背景介绍 SHA-1算法也称安全散列算法1，可以将一个最大264−12^{64}-1264−1的数据生成一个160位的数据摘要。尽管SHA-1算法已经被认为不再安全，但仍有部分应用使用SHA-1算法验证文件。 算法原理 类型定义 在介绍算法原理之前，有必要定义一些数据类型，有助于我们脱离具体编程语言分析这个算法。我这里使用C++的定义方式，不会C++也没有问题，我会解释代码的意义。 typedef __UINT8_TYPE__ BYTE; typedef __UINT32_T
密码学------SHA_1加密的python实现
qq_51048845的博客
04-26 2770
1.算法介绍 SHA-1（英语：Secure Hash Algorithm 1，中文名：安全散列算法1）是一种密码散列函数，美国国家安全局设计，并由美国国家标准技术研究所（NIST）发布为联邦数据处理标准（FIPS）。SHA-1可以生成一个被称为消息摘要的160位（20字节）散列值，散列值通常的呈现形式为40个十六进制数 2.源码 import math # 异或算法 def xor_func(a, b): a = bin(a)[2:] b = bin(b)[2:] while l
sha1 函数 C 语言使用示例及总结
m0_47696151的博客
07-30 2124
库的安装及使用 安装相应库 sudo apt install libssl-dev 代码中需要引入头文件 #include <openssl/sha.h> 编译时需要指定库 -lcrypto gcc sha1_test.c -lcrypto 使用方法 如果数据可以一次性获得 size_t len = strlen(data); unsigned char sha1[SHA_DIGEST_LENGTH]; SHA1(data, len, sha1); 如果数据分批获得 SHA_CTX c
SHA-1代码python语言和操作运行
m0_72529534的博客
06-23 193
只有加密
VC++实现HMAC-SHA512加密算法的源代码解析
- Salt_SHA512_PBKDF2.cpp: 这个文件可能包含了使用SHA-512和PBKDF2（Password-Based Key Derivation Function 2）算法的源代码。 - HMac_SHA512.cpp: 这个文件包含了用C++实现的HMAC算法，以SHA-512作为底层哈希...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值