基于VHDL语言的抢答器

VHDL抢答器的设计
设计要求：
1.抢答器同时供N名选手，(此处假设4个)分别用4个按钮S0～ S3表示。

2.设置一个系统“开始复位”开关S，该开关由主持人控制（当主持人按下该开关后以前的状态复位并且开始计时抢答）。

3．抢答器具有锁存与显示功能。

即选手按动按钮，锁存相应的编号，并在LED数码管上显示，同时扬声器发出报警声响提示。

选手抢答实行优先锁存，优先抢答选手的编号一直保持到主持人将系统清除为止。

4. 抢答器具有定时抢答功能，且一次抢答的时间（0-99S）。

当主持人启动“开始复位”键后，定时器进行减计时。

5. 如果定时时间已到，无人抢答，本次抢答无效，系统报警并禁止抢答，定时显示器上显示00。

一、概述
抢答器的逻辑结构主要由抢答鉴别lock模块、定时模块、译码模块和报警器模块组成。

在整个抢答器中最关键的是如何实现抢答封锁，在控制键按下的同时计数器倒计时显示有效剩余时间。

除此之外，整个抢答器还需有一个“复位开始”信号，以便抢答器能实现清零和开始。

抢答器共有3个输出显示，选手代号、计数器的个位和十位，他们输出全都为BCD 码输出，这样便于和显示译码器连接。

当主持人按下控制键、选手按下抢答键蜂鸣器短暂响起。

二、方案设计与论证
嘿嘿！将该任务分成N个模块进行设计，分别为：抢答器鉴别模块、抢答器计时模块、译码模块、报警模块，最后是综合。

1. 抢答器鉴别模块：
在这个模块中主要实现抢答过程中的抢答功能，并且能实现当有一路抢答按键按下时，该路抢答信号将其余个绿抢答封锁的功能。

在这个模块输入端有WARN输入(以时间控制系统的WARN输出信号为信号源)、一个和“时间控制系统”公用的CLEAR端、4人抢答输入信号端S0,S1,S2,S3和有一个时钟信号端CLK，这个时钟信号是个高频信号，用以扫描S0，S1，S2，S3是否有信号输入。

输出端有对应于S0，S1，S2，S3编号的4个指示灯LED 和4线2进制输出端STATES（用于锁存当前的状态），还有一个STOP 端用于指示S0,S1,S2,S3按钮状态（控制计时器停止）。

在此模块中高频时钟信号一直作用，此时，若主持人按下CLEAR即为开始抢答信号，所有输出端都自动清零。

在有效时间范围（N秒）内只要有人抢答，STOP就有高电平输出至“时间控制系统”的STOP端以控制倒计时的停止，并且对应的LCD指示灯点亮，STATES锁存输出到译码显示模块，用以显示优先抢答人的组号，并锁定输入端S以阻止系统响应其他抢答者的信号。

当有效时间到了之后还没有人抢答，则记时模块发出报警信号，同时反馈回来给抢答鉴别模块，禁止选手在抢答。

2.译码模块：
将抢答过程中锁存的BCD码转换成7段码用于LED的显示。

3定时器模块：
这个模块的输入端有时钟信号CLK1、系统复位信号CLEAR和一个STOP输入信号；输出端有秒时间状态显示信号高位HIGH和低位LOW，无人抢答时计时中止警报信号WARN。

这个模块中主要实现抢答过程中的计时功能，在抢答开始后进行N秒的倒计时，并且在N 秒倒计时后无人抢答的情况下显示超时并输出信号至WARN报警，或者只要N秒内有人抢答，由抢答鉴别模块输出的STOP信号控制停止计时，并显示优先抢答者的抢答时刻，输出一个信号经WARN传至“抢答鉴别系统”，锁存不再让选手抢答。

4报警模块：
在这个模块中主要实现抢答过程中的报警功能，当主持人按下控制键，有限时间内（N秒内）有人抢答或是倒计时到了之后蜂鸣器开始报警，输出SOUND有效电平为高.
5.在这个模块中是对前4个模块的综合。

三．单元电路软件设计及仿真
1.抢答器鉴别模块VHDL程序及模块：
在这个模块中主要实现抢答过程中的抢答功能，并且能实现当有一路抢答按键按下时，该路抢答信号将其余个绿抢答封锁的功能。

在这个模块输入端有WARN输入(以时间控制系统的WARN输出信号为信号源)、一个和“时间控制系统”公用的CLEAR端、4人抢答输入信号端S0,S1,S2,S3和有一个时钟信号端CLK，这个时钟信号是个高频信号，用以扫描S0，S1，S2，S3是否有信号输入。

输出端有对应于S0，S1，S2，S3编号的4个指示灯LED 和4线2进制输出端STATES （用于锁存当前的状态），还有一个STOP 端用于指示S0,S1,S2,S3按钮状态（控制计时器停止）。

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY LOCK IS
PORT( CLK,CLEAR:IN STD_LOGIC;
WARN:IN STD_LOGIC;
S0,S1,S2,S3:IN STD_LOGIC;
STATES:OUT STD_LOGIC_VECTOR(3 DOWNTO 0);
STOP:OUT STD_LOGIC;
LED:OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
END LOCK;
ARCHITECTURE ONE OF LOCK IS
SIGNAL G:STD_LOGIC_VECTOR(3 DOWNTO 0);
BEGIN
PROCESS(CLEAR,CLK,S0,S1,S2,S3)
BEGIN
IF CLEAR='1' THEN G<="0000";LED<="0000";STOP<='0';
ELSIF CLK'EVENT AND CLK='1' THEN
IF WARN='0' THEN
IF( S3='1')AND NOT(G(0)='1' OR G(1)='1' OR G(2)='1') THEN
G(3)<='1';LED(3)<='1';
ELSIF( S2='1')AND NOT(G(0)='1' OR G(1)='1' OR G(3)='1') THEN
G(2)<='1';LED(2)<='1';
ELSIF( S1='1')AND NOT(G(0)='1' OR G(2)='1' OR G(3)='1') THEN
G(1)<='1';LED(2)<='1';
ELSIF( S0='1')AND NOT(G(1)='1' OR G(2)='1' OR G(3)='1') THEN
G(0)<='1';LED(3)<='1';
END IF;
STOP<=G(0) OR G(1) OR G(2) OR G(3);
END IF;
END IF;
CASE G IS
WHEN "0001"=>STATES<="0001";
WHEN "0010"=>STATES<="0010";
WHEN "0100"=>STATES<="0011";
WHEN "1000"=>STATES<="0100";
WHEN OTHERS=>STATES<="0000";
END CASE;
END PROCESS;
END ARCHITECTURE ONE;
2.译码模块VHDL程序及模块：
将抢答过程中锁存的BCD码转换成7段码用于LED的显示。

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY CODE IS
PORT(INSTATES: IN STD_LOGIC_VECTOR(3 DOWNTO 0);
QOUT: OUT STD_LOGIC_VECTOR(6 DOWNTO 0)); END CODE;
ARCHITECTURE TWO OF CODE IS
BEGIN
PROCESS(INSTA TES)
BEGIN
CASE INSTATES IS
WHEN "0000"=>QOUT<="0111111";
WHEN "0001"=>QOUT<="0000110";
WHEN "0010"=>QOUT<="1011011";
WHEN "0011"=>QOUT<="1001111";
WHEN "0100"=>QOUT<="1100110";
WHEN "0101"=>QOUT<="1101101";
WHEN "0110"=>QOUT<="1111101";
WHEN "0111"=>QOUT<="0000111";
WHEN "1000"=>QOUT<="1111111";
WHEN "1001"=>QOUT<="1101111";
WHEN OTHERS=>QOUT<="0000000";
END CASE;
END PROCESS;
END ARCHITECTURE TWO;
3.定时模块VHDL程序及模块：
这个模块的输入端有时钟信号CLK、系统复位信号CLEAR和一个STOP输入信号；输出端有秒时间状态显示信号高位HIGH和低位LOW，无人抢答时计时中止警报信号WARN。

这个模块中主要实现抢答过程中的计时功能，在抢答开始后进行N秒的倒计时，并且在N 秒倒计时后无人抢答的情况下显示超时并输出信号至WARN报警，或者只要N秒内有人抢答，由抢答鉴别模块输出的STOP信号控制停止计时，并显示优先抢答者的抢答时刻，输出一个信号经WARN传至“抢答鉴别系统”，锁存不再让选手抢答。

USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.STD_LOGIC_UNSIGNED.ALL;
ENTITY COUNT IS
PORT(CLK,CLEAR,STOP:IN STD_LOGIC;
WARN:OUT STD_LOGIC;
HIGH,LOW:OUT STD_LOGIC_VECTOR(3 DOWNTO 0));
END COUNT;
ARCHITECTURE THREE OF COUNT IS
SIGNAL HS:STD_LOGIC_VECTOR(3 DOWNTO 0);
SIGNAL LS:STD_LOGIC_VECTOR(3 DOWNTO 0);
BEGIN
PROCESS(CLK)
BEGIN
IF CLEAR='1' THEN
HS<="1001";LS<="1001";WARN<='0';
ELSIF CLK'EVENT AND CLK='1' THEN
LS<=LS-1;
IF LS="0000" THEN
LS<="1001";HS<=HS-1;
IF HS="0000" AND LS="0000" THEN
WARN<='1';HS<="0000";LS<="0000";
IF STOP='1' THEN
HS<=HS;
LS<=LS;
WARN<='1';
END IF;
END IF;
END IF;
END IF;
HIGH<=HS;LOW<=LS;
END PROCESS;
END ARCHITECTURE THREE;
4报警模块VHDL：
在这个模块中主要实现抢答过程中的报警功能，当主持人按下控制键，有限时间内（N秒内）有人抢答或是倒计时到了之后蜂鸣器开始报警，输出SOUND有效电平为高.
USE IEEE.STD_LOGIC_1164.ALL;
ENTITY ALARM IS
PORT(CLEAR,WARN:IN STD_LOGIC;
SOUND:OUT STD_LOGIC); END ;
ARCHITECTURE FOUR OF ALARM IS
BEGIN
PROCESS(WARN,CLEAR)
BEGIN
IF CLEAR='1' THEN SOUND<='0';
ELSIF WARN='1' THEN
SOUND<='1';
ELSE SOUND<='0';
END IF;
END PROCESS;
END ;
三、设计电路的仿真波形图
1抢答鉴别模块仿真图：
2．译码模块仿真图：
3记时模块仿真图：
部分仿真图（1）：
部分仿真图（2）：
4报警模块仿真图：
五主电路连线图：
主电路仿真图：
六、心得与体会
经过三个星期的EDA课程设计，通过不懈努力，成功地设计出了数字式四路竞赛抢答器。

回首这几周，虽然因为初次涉及EDA技术及MAX_PLUSⅡ软件，对相关知识知之甚少，我们也遇到了很多困难，但是我们在这次实习的过程中都受益匪浅，收获颇丰，甚为欣慰。

在这次课程设计的前期，我们先系统地学习了EDA概论，VHDL描述语言和设计应用方面的基础知识，使得能够较熟练地使用MAX_PLUSⅡ软件进行设计开发，用原理图输入及VHDL语言等设计输入并编译仿真，同时我们对以往学过的理论知识有了更加透彻的理解。

我们的课题为数字式四路竞赛抢答器，根据电路的特点，我们采用层次化结构化设计，将此项设计任务分成若干模块，规定每一模块的功能和各模块之间的接口，然后再将各模块合起来调试。

在设计的过程中，遇到问题我们先独立思考，查找资料。

到自己不能解决的时候就和其他组研究讨论，向指导老师请教。

这样既提高了我们独立发现问题、分析问题、解决问题的能力，又很好地培养了交流合作的精神。

但是最后的成品却不一定与仿真时完全一样，因为，再实际接线中有着各种各样的条件制约着。

而且，在仿真中无法成功的电路接法，在实际中因为芯片本身的特性而能够成功。

所以，在设计时应考虑两者的差异，从中找出最适合的设计方法。

本实验通过EDA软件muxlus2的实现，让我对VHDL语言有了大概的了解，所以说，坐而言不如立而行，对于这些电路还是应该自己动手实际操作才会有深刻理解。

通过这次设计，进一步加深了对EDA的了解，让我对它有了更加浓厚的兴趣。

特别是当每一个子模块编写调试成功时，心里特别的高兴。

通过这次课程设计使我懂得了理论与实际相结合是很重要的，只有理论知识是远远不够的，只有把所学的理论知识与实践相结合起来，从理论中得出结论，才能真正为社会服务，从而提高自己的实际动手能力和独立思考的能力。

在设计的过程中遇到问题，可以说得是困难重重，这毕竟第一次做的，难免会遇到过各种各样的问题，同时在设计的过程中发现了自己的不足之处，对以前所学过的知识理解得不够深刻，掌握得不够牢固。

总的来说，这次设计的抢答器还是比较成功的，在设计中遇到了很多问题，最后在老师的辛勤的指导下，终于迎刃而解，有点小小的成就感，终于觉得平时所学的知识有了实用
的价值，达到了理论与实际相结合的目的，不仅学到了不少知识，而且锻炼了自己的能力，使自己对以后的路有了更加清楚的认识，同时，对未来有了更多的信心。

经历数日的课设眼看尘埃落定，感觉忍不住要长出一口气。

结果怎样已然不再重要，在这几日里，我们经历了阶段性成功的狂喜、测试失败后的绝望、陷入困境时的不知所措，重新投入的振作。

这已经就足够了！嘿嘿！
八、参考文献
[1] 、李国洪，沈明山：《可编程逻辑器件EDA技术与实践》，机械工业出版社
[2]、江国强：《EDA技术习题与实验》，电子工业出版社
[3]、曹昕燕，周风臣，聂春燕：《EDA技术试验与课程设计》，清华大学出版社
[4]、黄仁欣：《EDA技术实用教程》，清华大学出版社
附录资料：不需要的可以自行删除
SHA算法的实现
C语言程序：
#include <iostream>
#include <vector> //定义vector数组
#include <string> //记录消息
using namespace std;
const int NUM = 8; //一个字由32比特(或者8个16进制数)
const int BIT = 512; //消息认证码要以512比特一组
//字常量
string H0 = "67452301";
string H1 = "EFCDAB89";
string H2 = "98BADCFE";
string H3 = "10325476";
string H4 = "C3D2E1F0";
//定义SHA1(安全哈希算法)类
class SHA1
{
public:
//将一个字符串形式的字转化为vector数组
vector<int> hex_into_dec(string word);
//将vector转化为string字符串形式
string num_into_message(vector<int> A);
//两个字X和Y的逻辑"和"
vector<int> word_AND(vector<int> A,vector<int> B);
//两个字X和Y的逻辑"或"
vector<int> word_OR(vector<int> A,vector<int> B);
//两个字X和Y的逻辑"异或"
vector<int> word_XOR(vector<int> A,vector<int> B);
//两个字X和Y的逻辑"补"
vector<int> word_COMPLEMENT(vector<int> A);
//两个字X和Y的摸2^32整数加
vector<int> word_ADD(vector<int> A,vector<int> B);
//将字X循环左移s个位置
vector<int> ROTL(vector<int> A,int s);
//SHA-1的填充方案,我们设定msg由ASCII码组成
vector<vector<int> > SHA_1_PAD(string msg);
//将SHA-1压成以字为单位
vector<vector<vector<int> > > compress(vector<vector<int> > result);
//定义ft函数，每个ft函数都有B,C,D三个字作为输入，并产生一个字作为输出
vector<int> Ft(int t,vector<int> B,vector<int> C,vector<int> D);
//定义字常数K
vector<int> K(int t);
//开始进行SHA-1(安全Hash算法)的加密
vector<vector<int> > SHA_1(string msg);
};
//将vector转化为string字符串形式
string SHA1::num_into_message(vector<int> A)
{
int i;
string msg = "";
for(i = 0;i < A.size();i++)
if(A[i] >= 0 && A[i] <= 9)
msg += '0' + A[i];
else if(A[i] >= 10 && A[i] <= 15)
msg += 'A' + (A[i] - 10);
}
return msg;
}
//将一个字符串形式的字转化为vector数组
vector<int> SHA1::hex_into_dec(string word)
{
int i;
vector<int> result(NUM,0);
for(i = 0;i < NUM;i++)
{
if(word[i] >= '0' && word[i] <= '9')
{
result[i] = word[i] - '0';
}
else if(word[i] >= 'A' && word[i] <= 'F')
{
result[i] = 10 + word[i] - 'A';
}
}
return result;
}
//两个字X和Y的逻辑"和"
vector<int> SHA1::word_AND(vector<int> A,vector<int> B) {
vector<int> result(NUM,0);
int i;
for(i = 0;i < NUM;i++)
{
result[i] = A[i] & B[i];
}
return result;
}
//两个字X和Y的逻辑"或"
vector<int> SHA1::word_OR(vector<int> A,vector<int> B) {
vector<int> result(NUM,0);
for(i = 0;i < NUM;i++)
{
result[i] = A[i] | B[i];
}
return result;
}
//两个字X和Y的逻辑"异或"
vector<int> SHA1::word_XOR(vector<int> A,vector<int> B) {
vector<int> result(NUM,0);
int i;
for(i = 0;i < NUM;i++)
{
result[i] = A[i] ^ B[i];
}
return result;
}
//两个字X和Y的逻辑"补"
vector<int> SHA1::word_COMPLEMENT(vector<int> A) {
vector<int> result(NUM,0);
int i;
for(i = 0;i < NUM;i++)
{
result[i] = 15 - A[i];
}
return result;
}
//两个字X和Y的摸2^32整数加
vector<int> SHA1::word_ADD(vector<int> A,vector<int> B) {
vector<int> result(NUM,0);
int i;
for(i = NUM - 1;i >= 0;i--)
{
result[i] = A[i] + B[i];
if(i != 0)
{
int temp = result[i] / 16;
result[i-1] += temp;
result[i] %= 16;
}
return result;
}
//将字X循环左移s个位置
vector<int> SHA1::ROTL(vector<int> A,int s)
{
vector<int> result = A;
vector<int> temp(NUM,0);
int i,j;
for(i = 0;i < s;i++)
{
for(j = NUM - 1;j >= 0;j--)
{
if(result[j] / 8 >= 1)
{
temp[j] = 1;
result[j] <<= 1;
result[j] %= 16;
if(j < NUM - 1)
result[j] += temp[j + 1];
}
else if(result[j] / 8 == 0)
{
temp[j] = 0;
result[j] <<= 1;
result[j] %= 16;
}
}
result[NUM - 1] += temp[0];
}
return result;
}
//SHA-1的填充方案,我们设定msg由ASCII码组成
vector<vector<int> > SHA1::SHA_1_PAD(string msg)
{
int len = msg.length();
int bit_num = len * 8;
int i,j;
int num,lest = bit_num % 512;
if(lest != 0) //看消息长度是否超过512字节，我们需要将它补成512的倍
数
num = bit_num / 512 + 1;
else
num = bit_num / 512;
//首先我们以8位字节为一组保存到vector里面，512比特为一组，即一组里面有64位元素
vector<vector<int> > result;
result.resize(num);
for(i = 0;i < num;i++)
{
result[i].resize(64);
}
for(i = 0;i < num;i++)
{
for(j = 0;j < 64 && i * 64 + j < len;j++)
{
result[i][j] = msg[i * 64 + j];
}
}
//下面开始为未够512比特的消息分组进行补长度操作
if(lest != 0){
int x = num - 1,last_len = lest / 8;
result[x][last_len] = 128; //先补一个"1"
for(i = last_len + 1;i < 56;i++)
{
result[x][i] = 0;
}
int last_l = lest;
j = 63;
while(j >= 56)
{
result[x][j] = last_l % 128;
last_l /= 128;
j--;
}
}
return result;
}
//将SHA-1压成以字为单位(三维数组有点复杂)
vector<vector<vector<int> > > SHA1::compress(vector<vector<int> > result)
{
vector<vector<int> > rr;
rr.resize(result.size());
int i,j;
for(i = 0;i < rr.size();i++)
{
rr[i].resize(128);
}
for(i = 0;i < result.size();i++)
{
for(j = 0;j < result[i].size();j++)
{
rr[i][2 * j] = result[i][j] / 16;
rr[i][2 * j + 1] = result[i][j] % 16;
}
}
vector<vector<vector<int> > > rrr;
rrr.resize(result.size());
for(i = 0;i < rrr.size();i++)
{
rrr[i].resize(16);
}
for(i = 0;i < rrr.size();i++)
{
for(j = 0;j < 16;j++)
{
rrr[i][j].resize(8);
}
}
for(i = 0;i < rr.size();i++)
{
for(j = 0;j < rr[i].size();j++)
{
rrr[i][j / 8][j % 8] = rr[i][j];
}
}
return rrr;
}
//定义ft函数，每个ft函数都有B,C,D三个字作为输入，并产生一个字作为输出
vector<int> SHA1::Ft(int t,vector<int> B,vector<int> C,vector<int> D)
{
vector<int> result;
if(t >= 0 && t <= 19)
{
vector<int> a1 = word_AND(B,C);
vector<int> a2 = word_AND(word_COMPLEMENT(B),D);
result = word_OR(a1,a2);
}
else if((t >= 20 && t <= 39) || (t >= 60 && t <= 79))
{
vector<int> a1 = word_XOR(B,C);
result = word_XOR(a1,D);
}
else if(t >= 40 && t <= 59)
{
vector<int> a1 = word_AND(B,C);
vector<int> a2 = word_AND(B,D);
vector<int> a3 = word_AND(C,D);
vector<int> a4 = word_OR(a1,a2);
result = word_OR(a4,a3);
}
return result;
}
//定义字常数K
vector<int> SHA1::K(int t)
{
vector<int> result;
if(t >= 0 && t <= 19)
{
result = hex_into_dec("5A827999");
}
else if(t >= 20 && t <= 39)
{
result = hex_into_dec("6ED9EBA1");
}
else if(t >= 40 && t <= 59)
{
result = hex_into_dec("8F1BBCDC");
}
else if(t >= 60 && t <= 79)
{
result = hex_into_dec("CA62C1D6");
}
return result;
}
//开始进行SHA-1(安全Hash算法)的加密
vector<vector<int> > SHA1::SHA_1(string msg)
{
vector<int> h0 = hex_into_dec(H0);
vector<int> h1 = hex_into_dec(H1);
vector<int> h2 = hex_into_dec(H2);
vector<int> h3 = hex_into_dec(H3);
vector<int> h4 = hex_into_dec(H4);
vector<vector<int> > result1 = SHA_1_PAD(msg);
vector<vector<vector<int> > > result2 = compress(result1);
int n = result2.size();
int i,j;
for(i = 0;i < n;i++)
{
vector<vector<int> > W;
W.resize(80);
for(j = 0;j < 16;j++)
{
W[j] = result2[i][j];
}
for(j = 16;j < 80;j++)
{
vector<int> a1 = word_XOR(W[j-3],W[j-8]);
vector<int> a2 = word_XOR(a1,W[j-14]);
vector<int> a3 = word_XOR(a2,W[j-16]);
W[j] = ROTL(a3,1);
}
//将string转化为vector数组
vector<int> A = hex_into_dec(H0);
vector<int> B = hex_into_dec(H1);
vector<int> C = hex_into_dec(H2);
vector<int> D = hex_into_dec(H3);
vector<int> E = hex_into_dec(H4);
for(j = 0;j < 80;j++)
{
vector<int> a1 = ROTL(A,5);
vector<int> a2 = Ft(j,B,C,D);
vector<int> a3 = word_ADD(a1,a2);
vector<int> a4 = word_ADD(a3,E);
vector<int> a5 = word_ADD(a4,W[j]);
vector<int> temp = word_ADD(a5,K(j));
E = D;
D = C;
C = ROTL(B,30);
B = A;
A = temp;
}
h0 = word_ADD(h0,A);
h1 = word_ADD(h1,B);
h2 = word_ADD(h2,C);
h3 = word_ADD(h3,D);
h4 = word_ADD(h4,E);
}
//返回结果(H0||H1||H2||H3||H4)
vector<vector<int> > result;
result.push_back(h0);
result.push_back(h1);
result.push_back(h2);
result.push_back(h3);
result.push_back(h4);
return result;
}
int main()
{
SHA1 sha1; //定义SHA1算法类
string message = "cryptographyisthepracticeandstudyoftechniquesforsecurecommunicationintheprese nceofthirdpartiesmoregenerallyitisaboutconstructingandanalyzingprotocolsthatoverc ometheinfluenceofadversariesandwhicharerelatedtovariousaspectsininformationsec uritysuchasdataconfidentialitydataintegrityauthenticationandnonrepudiationmodern cryptographyintersectsthedisciplinesofmathematicscomputerscienceandelectricaleng ineeringapplicationsofcryptographyincludeATMcardscomputerpasswordsandelectron iccommerce";
vector<vector<int> > result;
result = sha1.SHA_1(message);
cout << "消息为:" << endl << message << endl;
cout << "利用填充方案SHA-1-PAD给出对消息的填充,得出SHA-1(x)得:" << endl;
int i;
for(i = 0;i < result.size();i++)
{
cout << sha1.num_into_message(result[i]);
}
cout << endl;
return 0; }
程序运行结果：。