下载文档原格式
c++的sh1算法
SHA-1（Secure Hash Algorithm 1）是一种密码学哈希函数，属于SHA系列算法之一。
它接受一个输入消息，并生成一个160位的哈希值作为输出。
SHA-1广泛应用于数字签名、消息认证和数据完整性校验等领域。
SHA-1算法的具体步骤如下：
1. 数据填充，将输入消息进行填充，使其长度满足512位的倍数，并在消息末尾添加一个64位的表示原始消息长度的二进制数。
2. 初始化，初始化5个32位的寄存器（A、B、C、D、E）为固定的常量。
3. 消息分组，将填充后的消息分割成若干个512位的消息块。
4. 哈希计算，对每个消息块进行哈希计算。
对于每个消息块，进行80轮的迭代运算，更新寄存器的值。
5. 输出，将最终的寄存器值按顺序连接起来，得到160位的哈
希值。
SHA-1算法的安全性已经受到了一定程度的破坏，因为它存在一些安全漏洞。
例如，SHA-1算法的碰撞攻击已经被成功实现，使得不同的输入消息可以生成相同的哈希值。
因此，在一些对安全性要求较高的应用中，建议使用更安全的哈希算法，如SHA-256或SHA-3。
总结起来，SHA-1是一种广泛应用的哈希算法，用于生成160位的哈希值。
它通过多轮的迭代运算，将输入消息转换为固定长度的哈希值。
然而，由于安全性方面的问题，建议在需要更高安全性的场景中使用其他更强大的哈希算法。
SHA1算法原理SHA-1（Secure Hash Algorithm 1）是一种密码学安全散列算法，用于为消息生成一个160位的哈希值（也称为摘要）。
它是公认的替代品MD5算法的一种选择。
SHA-1使用了一系列的逻辑运算和位操作，将输入消息不论其长度多长，都转换为一个固定长度的哈希值。
这个过程包括以下几个步骤。
1.数据填充：SHA-1算法首先将输入消息进行填充，使其长度能够被512位整除。
填充方式为在消息末尾添加1位"1"，接着填充0直到消息长度满足要求。
2.填充长度：SHA-1算法还需要将原始消息长度添加到填充后的消息末尾，以确保消息的完整性。
原始消息的长度是以二进制形式表示的。
通常情况下，这个长度值是64位的。
3.初始化变量：SHA-1算法使用了一个160位的初始化变量数组，也被称为缓冲区。
这个数组被SHA-1算法设计为预定义的常量。
4.消息分块：填充后的消息将被分成固定长度的512位块。
每个块会按顺序被处理。
5.压缩函数：SHA-1算法中的压缩函数是算法的核心部分。
它将每个块和当前的缓冲区作为输入，并经过一系列的逻辑运算和位操作，产生一个新的缓冲区。
6.迭代：SHA-1算法会迭代地处理每个块，依次将其与当前的缓冲区作为输入，生成新的缓冲区。
这个过程会不断重复，直到所有的块都被处理完毕。
7.输出：SHA-1算法的最终输出是压缩函数最后一个迭代得到的缓冲区。
这个缓冲区会被转换为一个160位的哈希值，作为算法的输出。
SHA-1算法的核心思想是将一个任意长度的消息映射为一个固定长度的哈希值，使得任意较小的输入变化都会导致输出哈希值的变化。
这样可以确保消息的完整性和不可逆性。
然而，由于SHA-1算法的安全性有所不足，它已被广泛认为是不安全的。
随着计算能力的提高和密码学攻击技术的发展，SHA-1算法存在被暴力破解和碰撞攻击的风险。
因此，现在通常建议使用更强大的哈希算法，如SHA-256、SHA-384或SHA-512，以提供更高的安全性。
SHA1算法源代码SHA-1（Secure Hash Algorithm 1）是一种常见的哈希算法，用于生成哈希值，常用于密码学和安全领域。
下面是SHA-1算法的详细源代码：```pythonimport struct#初始化常数h1=0xEFCDAB89h2=0x98BADCFEh4=0xC3D2E1F0def sha1(message):"""输入：字符串message输出：字符串的SHA-1哈希值"""#补位original_length = len(message) * 8message += b'\x80'while (len(message) + 8) % 64 != 0:message += b'\x00'message += struct.pack('>Q', original_length)#分组blocks = []for i in range(0, len(message), 64):block = message[i:i+64]blocks.append(block)#处理每个分组for block in blocks:w = list(struct.unpack('>16I', block))#扩展消息for i in range(16, 80):w.append(left_rotate((w[i-3] ^ w[i-8] ^ w[i-14] ^ w[i-16]), 1))#初始化哈希值a=h0b=h1c=h2d=h3e=h4#执行80轮循环for i in range(0, 80):if 0 <= i < 20:f=(b&c)，((~b)&d)elif 20 <= i < 40:f=b^c^dk=0x6ED9EBA1elif 40 <= i < 60:f=(b&c)，(b&d)，(c&d)k=0x8F1BBCDCelse:f=b^c^dk=0xCA62C1D6temp = (left_rotate(a, 5) + f + e + k + w[i]) & 0xffffffff e=dd=cc = left_rotate(b, 30)b=aa = temp#更新哈希值h0 = (h0 + a) & 0xffffffffh1 = (h1 + b) & 0xffffffffh2 = (h2 + c) & 0xffffffffh3 = (h3 + d) & 0xffffffffh4 = (h4 + e) & 0xffffffff#输出哈希值digest = struct.pack('>5I', h0, h1, h2, h3, h4)return digest.hexdef left_rotate(n, b):"""左旋转n"""return ((n << b) ， (n >> (32 - b))) & 0xffffffff```上面的代码实现了SHA-1算法的核心部分。
sha1prng算法原理SHA1PRNG算法原理是指安全哈希算法随机数生成器，是Java中一种常用的伪随机数生成器。
它采用SHA-1算法，结合Java密码安全的特性，生成一个伪随机数序列。
下面就来详细介绍SHA1PRNG算法原理。
1. SHA-1算法SHA-1算法是一种密码安全哈希函数，能够将数据压缩为固定长度的哈希值。
SHA-1算法的原理是将信息块进行消息扩展、填充、划分、迭代压缩，得到一个160位的消息摘要。
SHA-1算法的强度比MD5算法更高，输出的消息摘要长度也更长。
2. PRNG算法PRNG算法是伪随机数生成器，通过数学计算得到一系列看起来随机的数列。
PRNG算法有两种：线性同余发生器和梅森旋转算法。
线性同余发生器采用线性方程来计算，易于实现，但随机性不是非常好。
梅森旋转算法采用组合逆置位操作，极大增强了随机性。
3. SHA1PRNG算法SHA1PRNG算法将SHA-1算法和PRNG算法结合，生成伪随机数。
具体步骤如下：（1）计算熵值。
熵值是随机性的度量，取自系统时间、内存使用情况等信息。
计算熵值的目的是为了增加随机性。
（2）使用SHA-1算法生成哈希值。
将熵值作为SHA-1算法中的密钥，再加上一个计数器作为消息，生成哈希值。
（3）使用梅森旋转算法生成伪随机数。
梅森旋转算法需要一个初始向量，将哈希值作为初始向量，通过迭代来生成一序列随机数。
SHA1PRNG算法每生成一个随机数，就更新一次哈希值。
（4）初始化计数器。
计数器是用于防止攻击者通过短时间内的暴力攻击得到相同的随机数。
SHA1PRNG算法会记录生成的随机数的计数器值，每次重新初始化时，计数器值也一并重新初始化。
4. SHA1PRNG算法的应用SHA1PRNG算法被广泛应用于Java中的随机数生成和加密功能中。
例如，Java中的SecureRandom类，就是基于SHA1PRNG算法实现的。
SecureRandom类可以生成高质量的随机数，并且可以快速地生成大量的随机数序列。
Python实现常见的⼏种加密算法（MD5，SHA-1，HMAC，DESAES，RSA和ECC）⽣活中我们经常会遇到⼀些加密算法，今天我们就聊聊这些加密算法的Python实现。
部分常⽤的加密⽅法基本都有对应的Python库，基本不再需要我们⽤代码实现具体算法。
MD5加密全称：MD5消息摘要算法(英语：MD5 Message-Digest Algorithm)，⼀种被⼴泛使⽤的密码散列函数，可以产⽣出⼀个128位(16字节)的散列值(hash value)，⽤于确保信息传输完整⼀致。
md5加密算法是不可逆的，所以解密⼀般都是通过暴⼒穷举⽅法，通过⽹站的接⼝实现解密。
Python代码：import hashlibm = hashlib.md5()m.update(str.encode("utf8"))print(m.hexdigest())SHA1加密全称：安全哈希算法(Secure Hash Algorithm)主要适⽤于数字签名标准(Digital Signature Standard DSS)⾥⾯定义的数字签名算法(Digital Signature Algorithm DSA)，SHA1⽐MD5的安全性更强。
对于长度⼩于2^ 64位的消息，SHA1会产⽣⼀个160位的消息摘要。
Python代码： import hashlibsha1 = hashlib.sha1()data = '2333333'sha1.update(data.encode('utf-8'))sha1_data = sha1.hexdigest()print(sha1_data)HMAC加密全称：散列消息鉴别码(Hash Message Authentication Code)， HMAC加密算法是⼀种安全的基于加密hash函数和共享密钥的消息认证协议。
实现原理是⽤公开函数和密钥产⽣⼀个固定长度的值作为认证标识，⽤这个标识鉴别消息的完整性。
WINRAR加密中SHA1算法原理及其密钥产生过程
SHA1（Secure Hash Algorithm，安全哈希算法）算法是一种以160
位（20字节）的消息摘要（Message Digest）输出来验证文本或二进制
数据完整性的算法。
SHA1算法是一种单向散列算法，也叫哈希（Hash）
算法，可以将任意大小的数据（尤其是文本、图片等）转换成固定长度的“指纹”消息摘要，即使原始数据有微小的变化，消息摘要也完全不同。
SHA1算法的密钥产生过程主要包括以下几个步骤：
1.首先，产生一个固定长度的随机密钥，并将其转换成一个SHA1哈
希值；
2.然后，这个哈希值会按照一定的格式，被重新排列；
3.然后，使用这个SHA1哈希值，用户可以将文件加密，只有获得这
个密钥，才能对文件解密；
4.最后，SHA1算法提供的密钥是由SHA1哈希值（有着复杂的数学运算）的一个部分，最终密钥实际上是基于随机密钥生成的一个复杂的算法，所以SHA1算法的密钥比较安全。
SHA1算法是一种可靠的单向哈希算法，它是以20字节的消息摘要来
验证文件或二进制数据完整性的算法。
只要文件数据没有被改动，SHA1
算法应用的密钥和生成消息摘要的结果是一致的。
SHA1算法的签名验证
也是普遍被使用的，能够有效地验证消息的完整性和可靠性，并可以防止
消息被篡改和伪造。
SHA1算法实现及详解1 SHA1算法简介安全哈希算法（Secure Hash Algorithm）主要适⽤于数字签名标准（Digital Signature Standard DSS）⾥⾯定义的数字签名算法（Digital Signature Algorithm DSA）。
对于长度⼩于2^64位的消息，SHA1会产⽣⼀个160位的消息摘要。
当接收到消息的时候，这个消息摘要可以⽤来验证数据的完整性。
在传输的过程中，数据很可能会发⽣变化，那么这时候就会产⽣不同的消息摘要。
SHA1有如下特性：不可以从消息摘要中复原信息；两个不同的消息不会产⽣同样的消息摘要。
2 术语和概念2.1位(Bit)，字节（Byte）和字（Word）SHA1始终把消息当成⼀个位（bit）字符串来处理。
本⽂中，⼀个“字”（Word）是32位，⽽⼀个“字节”（Byte）是8位。
⽐如，字符串“abc”可以被转换成⼀个位字符串：01100001 01100010 01100011。
它也可以被表⽰成16进制字符串: 0x616263.2.2 运算符和符号下⾯的逻辑运算符都被运⽤于“字”（Word）X^Y = X， Y逻辑与X \/ Y = X， Y逻辑或X XOR Y= X， Y逻辑异或~X = X逻辑取反X+Y定义如下：字 X 和 Y 代表两个整数 x 和y, 其中 0 <= x < 2^32 且 0 <= y < 2^32. 令整数z = (x + y) mod 2^32. 这时候 0 <= z < 2^32. 将z转换成字Z, 那么就是 Z = X + Y.循环左移位操作符Sn(X)。
X是⼀个字，n是⼀个整数，0<=n<=32。
Sn(X) = (X<<n)OR(X>>32-n)X<<n定义如下：抛弃最左边的n位数字，将各个位依次向左移动n位，然后⽤0填补右边的n位（最后结果还是32位）。
SHA-1加密算法原理详解1. 引言SHA-1（Secure Hash Algorithm 1）是一种广泛使用的密码散列函数，用于对数据进行加密和验证。
它是由美国国家安全局（NSA）设计，并于1995年发布。
SHA-1算法通过将输入数据转换为固定长度的哈希值，以实现数据的完整性保护和数字签名验证。
本文将详细介绍SHA-1加密算法的基本原理和过程。
2. 基本原理SHA-1算法的基本原理是将输入数据分块处理，并对每个数据块进行一系列的位运算和逻辑运算，最终生成160位（20字节）的哈希值。
这个哈希值具有以下特点：•哈希值长度固定，不论输入数据的长度如何，SHA-1生成的哈希值始终为160位。
•对于不同的输入数据，SHA-1生成的哈希值几乎是唯一的，即使输入数据的一个比特发生变化，生成的哈希值也会有较大差异。
•无法从哈希值反推出原始数据，即使输入数据只有微小的变化，生成的哈希值也会有较大差异，因此SHA-1算法是一种不可逆的加密算法。
SHA-1算法的核心步骤包括：填充、分组、初始化、迭代和输出。
下面将详细介绍每个步骤的具体过程。
3. 填充（Padding）SHA-1算法要求输入数据的长度必须是512位的倍数，因此在进行加密之前，需要对输入数据进行填充。
填充的规则如下：•首先，将输入数据的位数n转换为二进制，并补充一个1。
•然后，补充k个0，使得n + 1 + k ≡ 448 mod 512。
•最后，将输入数据的原始位数n，以64位二进制形式追加到填充后的数据末尾。
填充后的数据长度为512位的倍数，可以开始分组处理。
4. 分组（Chunking）填充后的数据被划分为多个512位（64字节）的数据块，每个数据块被称为一个分组。
如果输入数据长度超过512位，就会生成多个分组。
每个分组又被划分为16个32位的字（Word），共有80个字。
5. 初始化（Initialization）SHA-1算法使用5个32位的寄存器作为初始值，这些寄存器分别被称为A、B、C、D和E。
SHA-1（安全哈希算法实现）如题，不知道sha-1的自己百度吧。
1 #include <iostream>2 #include <vector>//定义vector数组3 #include <string>//记录消息4usingnamespace std;56constint NUM = 8; //一个字由32比特(或者8个16进制数) 7constint BIT = 512; //消息认证码要以512比特一组89//字常量10string H0 = "67452301";11string H1 = "EFCDAB89";12string H2 = "98BADCFE";13string H3 = "10325476";14string H4 = "C3D2E1F0";1516//定义SHA1(安全哈希算法)类17class SHA118 {19public:20//将一个字符串形式的字转化为vector数组21 vector<int> hex_into_dec(string word);2223//将vector转化为string字符串形式24string num_into_message(vector<int> A);2526//两个字X和Y的逻辑"和"27 vector<int> word_AND(vector<int> A,vector<int> B); 2829//两个字X和Y的逻辑"或"30 vector<int> word_OR(vector<int> A,vector<int> B); 3132//两个字X和Y的逻辑"异或"33 vector<int> word_XOR(vector<int> A,vector<int> B); 3435//两个字X和Y的逻辑"补"36 vector<int> word_COMPLEMENT(vector<int> A);3738//两个字X和Y的摸2^32整数加39 vector<int> word_ADD(vector<int> A,vector<int> B); 4041//将字X循环左移s个位置42 vector<int> ROTL(vector<int> A,int s);4344//SHA-1的填充方案,我们设定msg由ASCII码组成45 vector<vector<int>> SHA_1_PAD(string msg);4647//将SHA-1压成以字为单位48 vector<vector<vector<int>>> compress(vector<vector<int>> result);4950//定义ft函数，每个ft函数都有B,C,D三个字作为输入，并产生一个字作为输出51 vector<int> Ft(int t,vector<int> B,vector<int> C,vector<int>D);5253//定义字常数K54 vector<int> K(int t);5556//开始进行SHA-1(安全Hash算法)的加密57 vector<vector<int>> SHA_1(string msg);5859 };6061//将vector转化为string字符串形式62string SHA1::num_into_message(vector<int> A)63 {64int i;65string msg = "";66for(i = 0;i < A.size();i++)67 {68if(A[i] >= 0&& A[i] <= 9)69 msg += '0' + A[i];70elseif(A[i] >= 10&& A[i] <= 15)71 msg += 'A' + (A[i] - 10);72 }73return msg;74 }7576//将一个字符串形式的字转化为vector数组77 vector<int> SHA1::hex_into_dec(string word)78 {79int i;80 vector<int> result(NUM,0);81for(i = 0;i < NUM;i++)82 {83if(word[i] >= '0'&& word[i] <= '9')84 {85 result[i] = word[i] - '0';86 }87elseif(word[i] >= 'A'&& word[i] <= 'F')88 {89 result[i] = 10 + word[i] - 'A';90 }91 }92return result;93 }9495//两个字X和Y的逻辑"和"96 vector<int> SHA1::word_AND(vector<int> A,vector<int> B)97 {98 vector<int> result(NUM,0);99int i;100for(i = 0;i < NUM;i++)101 {102 result[i] = A[i] & B[i];103 }104return result;105 }106107//两个字X和Y的逻辑"或"108 vector<int> SHA1::word_OR(vector<int> A,vector<int> B) 109 {110 vector<int> result(NUM,0);111int i;112for(i = 0;i < NUM;i++)113 {114 result[i] = A[i] | B[i];115 }116return result;117 }118119//两个字X和Y的逻辑"异或"120 vector<int> SHA1::word_XOR(vector<int> A,vector<int> B) 121 {122 vector<int> result(NUM,0);123int i;124for(i = 0;i < NUM;i++)125 {126 result[i] = A[i] ^ B[i];127 }128return result;129 }130131//两个字X和Y的逻辑"补"132 vector<int> SHA1::word_COMPLEMENT(vector<int> A)133 {134 vector<int> result(NUM,0);135int i;136for(i = 0;i < NUM;i++)137 {138 result[i] = 15 - A[i];139 }140return result;141 }142143//两个字X和Y的摸2^32整数加144 vector<int> SHA1::word_ADD(vector<int> A,vector<int> B) 145 {146 vector<int> result(NUM,0);147int i;148for(i = NUM - 1;i >= 0;i--)149 {150 result[i] = A[i] + B[i];151if(i != 0)152 {153int temp = result[i] / 16;154 result[i-1] += temp;155 }156 result[i] %= 16;157 }158return result;159 }160161//将字X循环左移s个位置162 vector<int> SHA1::ROTL(vector<int> A,int s)163 {164 vector<int> result = A;165 vector<int> temp(NUM,0);166int i,j;167for(i = 0;i < s;i++)168 {169for(j = NUM - 1;j >= 0;j--)171if(result[j] / 8>= 1)172 {173 temp[j] = 1;174 result[j] <<= 1;175 result[j] %= 16;176if(j < NUM - 1)177 result[j] += temp[j + 1];178 }179elseif(result[j] / 8 == 0)180 {181 temp[j] = 0;182 result[j] <<= 1;183 result[j] %= 16;184 }185 }186 result[NUM - 1] += temp[0];187 }188return result;189 }190191//SHA-1的填充方案,我们设定msg由ASCII码组成192 vector<vector<int>> SHA1::SHA_1_PAD(string msg)193 {194int len = msg.length();195int bit_num = len * 8;196int i,j;197int num,lest = bit_num % 512;198if(lest != 0) //看消息长度是否超过512字节，我们需要将它补成512的倍数199 num = bit_num / 512 + 1;200else201 num = bit_num / 512;202//首先我们以8位字节为一组保存到vector里面，512比特为一组，即一组里面有64位元素203 vector<vector<int>> result;204 result.resize(num);205for(i = 0;i < num;i++)206 {207 result[i].resize(64);208 }209for(i = 0;i < num;i++)210 {211for(j = 0;j <64&& i * 64 + j < len;j++)213 result[i][j] = msg[i * 64 + j];214 }215 }216//下面开始为未够512比特的消息分组进行补长度操作217if(lest != 0){218int x = num - 1,last_len = lest / 8;219 result[x][last_len] = 128; //先补一个"1"220for(i = last_len + 1;i <56;i++)221 {222 result[x][i] = 0;223 }224int last_l = lest;225 j = 63;226while(j >= 56)227 {228 result[x][j] = last_l % 128;229 last_l /= 128;230 j--;231 }232 }233return result;234 }235236//将SHA-1压成以字为单位(三维数组有点复杂)237 vector<vector<vector<int>>> SHA1::compress(vector<vector<int>> result)238 {239 vector<vector<int>> rr;240 rr.resize(result.size());241int i,j;242for(i = 0;i < rr.size();i++)243 {244 rr[i].resize(128);245 }246for(i = 0;i < result.size();i++)247 {248for(j = 0;j < result[i].size();j++)249 {250 rr[i][2 * j] = result[i][j] / 16;251 rr[i][2 * j + 1] = result[i][j] % 16;252 }253 }254 vector<vector<vector<int>>> rrr;255 rrr.resize(result.size());256for(i = 0;i < rrr.size();i++)257 {258 rrr[i].resize(16);259 }260for(i = 0;i < rrr.size();i++)261 {262for(j = 0;j <16;j++)263 {264 rrr[i][j].resize(8);265 }266 }267for(i = 0;i < rr.size();i++)268 {269for(j = 0;j < rr[i].size();j++)270 {271 rrr[i][j / 8][j % 8] = rr[i][j];272 }273 }274return rrr;275 }276277//定义ft函数，每个ft函数都有B,C,D三个字作为输入，并产生一个字作为输出278 vector<int> SHA1::Ft(int t,vector<int> B,vector<int> C,vector<int> D)279 {280 vector<int> result;281if(t >= 0&& t <= 19)282 {283 vector<int> a1 = word_AND(B,C);284 vector<int> a2 = word_AND(word_COMPLEMENT(B),D);285 result = word_OR(a1,a2);286 }287elseif((t >= 20&& t <= 39) || (t >= 60&& t <= 79))288 {289 vector<int> a1 = word_XOR(B,C);290 result = word_XOR(a1,D);291 }292elseif(t >= 40&& t <= 59)293 {294 vector<int> a1 = word_AND(B,C);295 vector<int> a2 = word_AND(B,D);296 vector<int> a3 = word_AND(C,D);297 vector<int> a4 = word_OR(a1,a2);298 result = word_OR(a4,a3);299 }300return result;301 }302303//定义字常数K304 vector<int> SHA1::K(int t)305 {306 vector<int> result;307if(t >= 0&& t <= 19)308 {309 result = hex_into_dec("5A827999");310 }311elseif(t >= 20&& t <= 39)312 {313 result = hex_into_dec("6ED9EBA1");314 }315elseif(t >= 40&& t <= 59)316 {317 result = hex_into_dec("8F1BBCDC");318 }319elseif(t >= 60&& t <= 79)320 {321 result = hex_into_dec("CA62C1D6");322 }323return result;324 }325326//开始进行SHA-1(安全Hash算法)的加密327 vector<vector<int>> SHA1::SHA_1(string msg)328 {329 vector<int> h0 = hex_into_dec(H0);330 vector<int> h1 = hex_into_dec(H1);331 vector<int> h2 = hex_into_dec(H2);332 vector<int> h3 = hex_into_dec(H3);333 vector<int> h4 = hex_into_dec(H4);334335 vector<vector<int>> result1 = SHA_1_PAD(msg);336 vector<vector<vector<int>>> result2 = compress(result1); 337int n = result2.size();338int i,j;339for(i = 0;i < n;i++)340 {342 W.resize(80);343for(j = 0;j <16;j++)344 {345 W[j] = result2[i][j];346 }347for(j = 16;j <80;j++)348 {349 vector<int> a1 = word_XOR(W[j-3],W[j-8]); 350 vector<int> a2 = word_XOR(a1,W[j-14]); 351 vector<int> a3 = word_XOR(a2,W[j-16]); 352 W[j] = ROTL(a3,1);353 }354355//将string转化为vector数组356 vector<int> A = hex_into_dec(H0);357 vector<int> B = hex_into_dec(H1);358 vector<int> C = hex_into_dec(H2);359 vector<int> D = hex_into_dec(H3);360 vector<int> E = hex_into_dec(H4);361362for(j = 0;j <80;j++)363 {364 vector<int> a1 = ROTL(A,5);365 vector<int> a2 = Ft(j,B,C,D);366 vector<int> a3 = word_ADD(a1,a2);367 vector<int> a4 = word_ADD(a3,E);368 vector<int> a5 = word_ADD(a4,W[j]);369 vector<int> temp = word_ADD(a5,K(j));370 E = D;371 D = C;372 C = ROTL(B,30);373 B = A;374 A = temp;375 }376377 h0 = word_ADD(h0,A);378 h1 = word_ADD(h1,B);379 h2 = word_ADD(h2,C);380 h3 = word_ADD(h3,D);381 h4 = word_ADD(h4,E);382 }383384//返回结果(H0||H1||H2||H3||H4)386 result.push_back(h0);387 result.push_back(h1);388 result.push_back(h2);389 result.push_back(h3);390 result.push_back(h4);391392return result;393 }394395int main()396 {397 SHA1 sha1; //定义SHA1算法类398string message = "cryptographyisthepracticeandstudyoftechniquesforsecurecommunicationi nthepresenceofthirdpartiesmoregenerallyitisaboutconstructingandanalyz ingprotocolsthatovercometheinfluenceofadversariesandwhicharerelatedto variousaspectsininformationsecuritysuchasdataconfidentialitydatainteg rityauthenticationandnonrepudiationmoderncryptographyintersectsthedis ciplinesofmathematicscomputerscienceandelectricalengineeringapplicati onsofcryptographyincludeATMcardscomputerpasswordsandelectroniccommerc e";399 vector<vector<int>> result;400 result = sha1.SHA_1(message);401 cout <<"消息为:"<< endl << message << endl;402 cout <<"利用填充方案SHA-1-PAD给出对消息的填充,得出SHA-1(x)得:"<< endl;403int i;404for(i = 0;i < result.size();i++)405 {406 cout << sha1.num_into_message(result[i]);407 }408 cout << endl;409return0;410 }。
