⑴ RSA算法的安全问题
当carcker知道了你的私钥，再加上公开的公钥。那么p和q就能很容易算出来。
而你现在不改变p和q(也就是不改变n)
。只改变e和d
也就是只改变e.因为d 是根据p.q.e计算出来的。
而e又是公开的。那么。。。
你改变e。也就是什么也没做。
⑵ 求正确的RSA加密解密算法C语言的，多谢。
//rsa.h
#include<stdio.h>
#defineMAX_NUM63001
#defineMAX_PRIME251
//!返回代码
#defineOK100
#defineERROR_NOEACHPRIME101
#defineERROR_NOPUBLICKEY102
#defineERROR_GENERROR103
unsignedintMakePrivatedKeyd(unsignedintuiP,unsignedintuiQ);
unsignedintGetPrivateKeyd(unsignedintiWhich);
unsignedintMakePairkey(unsignedintuiP,unsignedintuiQ,unsignedintuiD);
unsignedintGetPairKey(unsignedint&d,unsignedint&e);
voidrsa_encrypt(intn,inte,char*mw,intiLength,int*&cw);
voidrsa_decrypt(intn,intd,int*&cw,intcLength,char*mw);
voidoutputkey();
//rsa.c
#include"rsa.h"
//!保存私钥d集合
structpKeyset
{
unsignedintset[MAX_NUM];
unsignedintsize;
}pset;
//!保存公、私钥对
structpPairkey
{
unsignedintd;
unsignedinte;
unsignedintn;
}pairkey;
//名称：isPrime
//功能：判断两个数是否互质
//参数：m:数a;n:数b
//返回：m、n互质返回true;否则返回false
boolisPrime(unsignedintm,unsignedintn)
{
unsignedinti=0;
boolFlag=true;
if(m<2||n<2)
returnfalse;
unsignedinttem=(m>n)?n:m;
for(i=2;i<=tem&&Flag;i++)
{
boolmFlag=true;
boolnFlag=true;
if(m%i==0)
mFlag=false;
if(n%i==0)
nFlag=false;
if(!mFlag&&!nFlag)
Flag=false;
}
if(Flag)
returntrue;
else
returnfalse;
}
//名称：MakePrivatedKeyd
//功能：由素数Q、Q生成私钥d
//参数：uiP:素数P;uiQ:素数Q
//返回：私钥d
unsignedintMakePrivatedKeyd(unsignedintuiP,unsignedintuiQ)
{
unsignedinti=0;
//!得到所有与z互质的数(私钥d的集合)
unsignedintz=(uiP-1)*(uiQ-1);
pset.size=0;
for(i=0;i<z;i++)
{
if(isPrime(i,z))
{
pset.set[pset.size++]=i;
}
}
returnpset.size;
}
//名称：MakePairKey
//功能：生成RSA公、私钥对
//参数：uiP:素数P;uiQ:素数Q;uiD:私钥d
//返回：错误代码
unsignedintMakePairkey(unsignedintuiP,unsignedintuiQ,unsignedintuiD)
{
boolbFlag=true;
unsignedinti=0,e;
unsignedintz=(uiP-1)*(uiQ-1);
unsignedintd=pset.set[uiD];
//d=uiD;
if(!isPrime(z,d))
returnERROR_NOEACHPRIME;
for(i=2;i<z;i++)
{
if((i*d)%z==1)
{
e=i;
bFlag=false;
}
}
if(bFlag)
returnERROR_NOPUBLICKEY;
if((d*e)%z!=1)
ERROR_GENERROR;
pairkey.d=d;
pairkey.e=e;
pairkey.n=uiP*uiQ;
returnOK;
}
//名称：GetPairKey
//功能：对外提供接口，获得公、私钥对
//参数：uiP:素数P;uiQ:素数Q;uiD:私钥d
//返回：
unsignedintGetPairKey(unsignedint&d,unsignedint&e)
{
d=pairkey.d;
e=pairkey.e;
returnpairkey.n;
}
//名称：GetPrivateKeyd
//功能：对外提供接口，由用户选择ID得以私钥d
//参数：iWhich:用户选择私钥d的ID
//返回：私钥d值
unsignedintGetPrivateKeyd(unsignedintiWhich)
{
if(pset.size>=iWhich)
returnpset.set[iWhich];
else
return0;
}
//名称：rsa_encrypt
//功能：RSA加密运算
//参数：n:公钥n;e:公钥e;mw:加密明文;iLength:明文长度;cw:密文输出
//返回：无
voidrsa_encrypt(intn,inte,char*mw,intmLength,int*&cw)
{
inti=0,j=0;
__int64temInt=0;
for(i=0;i<mLength;i++)
{
temInt=mw[i];
if(e!=0)
{
for(j=1;j<e;j++)
{
temInt=(temInt*mw[i])%n;
}
}
else
{
temInt=1;
}
cw[i]=(int)temInt;
}
}
//名称：rsa_decrypt
//功能：RSA解密运算
//参数：n:私钥n;d:私钥d;cw:密文;cLength:密文长度;mw:明文输出
//返回：无
voidrsa_decrypt(intn,intd,int*&cw,intcLength,char*mw)
{
inti=0,j=-1;
__int64temInt=0;
for(i=0;i<cLength/4;++i)
{
mw[i]=0;
temInt=cw[i];
if(d!=0)
{
for(j=1;j<d;j++)
{
temInt=(__int64)(temInt*cw[i])%n;
}
}
else
{
temInt=1;
}
mw[i]=(char)temInt;
}
}
voidoutputkey()
{
printf("PublicKey(e,n):(%d,%d) ",pairkey.e,pairkey.n);
printf("PrivateKey(d,n):(%d,%d) ",pairkey.d,pairkey.n);
}
//main.c
//工程：RSA
//功能：RSA加、解密文件
//作者：jlcss|ExpNIS
#include<stdio.h>
#include<afxwin.h>
#include<math.h>
#include"rsa.h"
#defineDECRYPT_FILE"RSA加密密文.txt"
#defineENCRYPT_FILE"RSA解密明文.txt"
//!约束文件最大2M
#defineMAX_FILE1024*1024*2
//名称：usage
//功能：帮助信息
//参数：应用程序名称
//返回：提示信息
voidUsage(constchar*appname)
{
printf(" usage:rsa-k素数P素数Q ");
printf(" usage:rsa-e明文文件公钥e公钥n ");
printf(" usage:rsa-d密文文件私钥d私钥n ");
}
//名称：IsNumber
//功能：判断数字字符数组
//参数：strNumber:字符数组
//返回：数字字组数组返回true，否则返回false;
boolIsNumber(constchar*strNumber)
{
unsignedinti;
if(!strNumber)
returnfalse;
for(i=0;i<strlen(strNumber);i++)
{
if(strNumber[i]<'0'||strNumber[i]>'9')
returnfalse;
}
returntrue;
}
//名称：IsPrimeNumber
//功能：判断素数
//参数：num:输入整数
//返回：素数返回true，否则返回false;
boolIsPrimeNumber(unsignedintnum)
{
unsignedinti;
if(num<=1)
returnfalse;
unsignedintsqr=(unsignedint)sqrt((double)num);
for(i=2;i<=sqr;i++)
{
if(num%i==0)
returnfalse;
}
returntrue;
}
//名称：FileIn
//功能：读取磁盘文件到内存
//参数：strFile:文件名称；inBuff:指向文件内容缓冲区
//返回：实际读取内容大小(字节)
intFileIn(constchar*strFile,unsignedchar*&inBuff)
{
intiFileLen=0,iBuffLen=0;
//!打开密文文件
CFilefile(strFile,CFile::modeRead);
iFileLen=(int)file.GetLength();
if(iFileLen>MAX_FILE)
{
printf("文件长度不能大于%dM,! ",MAX_FILE/(1024*1024));
gotoout;
}
iBuffLen=iFileLen;
inBuff=newunsignedchar[iBuffLen];
if(!inBuff)
gotoout;
ZeroMemory(inBuff,iBuffLen);
file.Read(inBuff,iFileLen);
file.Close();
out:
returniBuffLen;
}
//名称：FileOut
//功能：加/解密结果输出到当前目录磁盘文件中
//参数：strOut指向输出字符缓冲区，输出大小len，strFile为输出文件
//返回：无
voidFileOut(constvoid*strOut,intlen,constchar*strFile)
{
//!输出到文件
CFileoutfile(strFile,CFile::modeCreate|CFile::modeWrite);
outfile.Write(strOut,len);
outfile.Close();
}
//名称：CheckParse
//功能：校验应用程序入口参数
//参数：argc等于main主函数argc参数，argv指向main主函数argv参数
//返回：若参数合法返回true，否则返回false
//备注：简单的入口参数校验
boolCheckParse(intargc,char**argv)
{
boolbRes=false;
if(argc!=4&&argc!=5)
gotoout;
if(argc==4&&argv[1][1]=='k')
{
//!生成公、私钥对
if(!IsNumber(argv[2])||
!IsNumber(argv[3])||
atoi(argv[2])>MAX_PRIME||
atoi(argv[3])>MAX_PRIME)
gotoout;
}
elseif((argc==5)&&(argv[1][1]=='e'||argv[1][1]=='d'))
{
//!加密、解密操作
if(!IsNumber(argv[3])||
!IsNumber(argv[4])||
atoi(argv[3])>MAX_NUM||
atoi(argv[4])>MAX_NUM)
gotoout;
}
else
Usage(*argv);
bRes=true;
out:
returnbRes;
}
//名称：kOption1
//功能：程序k选项操作：由素数P、Q生成私钥d集合
//参数：uiP:程序入口参数P;uiQ:程序入口参数Q
//返回：执行正确返回生成私钥数目，否则返回0
unsignedintkOption1(unsignedintuiP,unsignedintuiQ)
{
unsignedintuiRes=0;
if(!IsPrimeNumber(uiP))
{
printf("P输入错误，P必须为(0,%d]素数",MAX_PRIME);
returnuiRes;
}
if(!IsPrimeNumber(uiQ))
{
printf("Q输入错误，Q必须为(0,%d]素数",MAX_PRIME);
returnuiRes;
}
if(uiP==uiQ)
{
printf("素数P与素数Q相同，很容易根据公钥n开平方得出素数P和Q，这种加密不安全，请更换素数! ");
returnuiRes;
}
printf("正在生成私钥d集合...... ");
uiRes=MakePrivatedKeyd(uiP,uiQ);
returnuiRes;
}
//!程序主函数
intmain(intargc,char**argv)
{
unsignedintp,q,d,n,e;//twoprimep&q,publickey(n,e),privatekey(n,d)
CheckParse(argc,argv);
d=4828;//uid
if(argc==4)
{
p=atoi(argv[2]);
q=atoi(argv[3]);
MakePrivatedKeyd(p,q);
MakePairkey(p,q,d);
outputkey();
}
elseif(argc==5)
{
charFileName[20];
strcpy(FileName,argv[2]);
intlen;
if(argv[1][1]=='e')
{
unsignedchar*inBuffer=(unsignedchar*)malloc(MAX_FILE);//输入缓冲区
int*cw=(int*)malloc(MAX_FILE);
len=FileIn(FileName,inBuffer);
e=atoi(argv[3]);
n=atoi(argv[4]);
rsa_encrypt(n,e,(char*)inBuffer,len,cw);
FileOut(cw,4*len,DECRYPT_FILE);
}
elseif(argv[1][1]=='d')
{
char*Buffer=(char*)malloc(MAX_FILE);//输入缓冲区
int*cw=(int*)malloc(MAX_FILE);
len=FileIn(FileName,(unsignedchar*&)cw);
d=atoi(argv[3]);
n=atoi(argv[4]);
rsa_decrypt(n,d,cw,len,Buffer);
FileOut(Buffer,len/4,ENCRYPT_FILE);
}
}
return0;
}
⑶ 简述RSA算法中密钥的产生，数据加密和解密的过程，并简单说明RSA算法安全性的原理。
RSA算法的数学原理
RSA算法的数学原理:
先来找出三个数, p, q, r,
其中 p, q 是两个相异的质数, r 是与 (p-1)(q-1) 互质的数。
p, q, r 这三个数便是 private key。接着, 找出m, 使得 rm == 1 mod (p-1)(q-1)..... 这个 m 一定存在, 因为 r 与 (p-1)(q-1) 互质, 用辗转相除法就可以得到了..... 再来, 计算 n = pq....... m, n 这两个数便是 public key。
编码过程是, 若资料为 a, 将其看成是一个大整数, 假设 a < n.... 如果 a >= n 的话, 就将 a 表成 s 进位 (s <= n, 通常取 s = 2^t), 则每一位数均小于 n, 然后分段编码...... 接下来, 计算 b == a^m mod n, (0 <= b < n), b 就是编码后的资料...... 解码的过程是, 计算 c == b^r mod pq (0 <= c < pq), 于是乎, 解码完毕...... 等会会证明 c 和 a 其实是相等的 :) 如果第三者进行窃听时, 他会得到几个数: m, n(=pq), b...... 他如果要解码的话, 必须想办法得到 r...... 所以, 他必须先对 n 作质因数分解......... 要防止他分解, 最有效的方法是找两个非常的大质数 p, q, 使第三者作因数分解时发生困难......... <定理> 若 p, q 是相异质数, rm == 1 mod (p-1)(q-1), a 是任意一个正整数, b == a^m mod pq, c == b^r mod pq, 则 c == a mod pq 证明的过程, 会用到费马小定理, 叙述如下: m 是任一质数, n 是任一整数, 则 n^m == n mod m (换另一句话说, 如果 n 和 m 互质, 则 n^(m-1) == 1 mod m) 运用一些基本的群论的知识, 就可以很容易地证出费马小定理的........ <证明> 因为 rm == 1 mod (p-1)(q-1), 所以 rm = k(p-1)(q-1) + 1, 其中 k 是整数 因为在 molo 中是 preserve 乘法的 (x == y mod z and u == v mod z => xu == yv mod z), 所以, c == b^r == (a^m)^r == a^(rm) == a^(k(p-1)(q-1)+1) mod pq 1. 如果 a 不是 p 的倍数, 也不是 q 的倍数时, 则 a^(p-1) == 1 mod p (费马小定理) => a^(k(p-1)(q-1)) == 1 mod p a^(q-1) == 1 mod q (费马小定理) => a^(k(p-1)(q-1)) == 1 mod q 所以 p, q 均能整除 a^(k(p-1)(q-1)) - 1 => pq | a^(k(p-1)(q-1)) - 1 即 a^(k(p-1)(q-1)) == 1 mod pq => c == a^(k(p-1)(q-1)+1) == a mod pq 2. 如果 a 是 p 的倍数, 但不是 q 的倍数时, 则 a^(q-1) == 1 mod q (费马小定理) => a^(k(p-1)(q-1)) == 1 mod q => c == a^(k(p-1)(q-1)+1) == a mod q => q | c - a 因 p | a => c == a^(k(p-1)(q-1)+1) == 0 mod p => p | c - a 所以, pq | c - a => c == a mod pq 3. 如果 a 是 q 的倍数, 但不是 p 的倍数时, 证明同上 4. 如果 a 同时是 p 和 q 的倍数时, 则 pq | a => c == a^(k(p-1)(q-1)+1) == 0 mod pq => pq | c - a => c == a mod pq Q.E.D. 这个定理说明 a 经过编码为 b 再经过解码为 c 时, a == c mod n (n = pq).... 但我们在做编码解码时, 限制 0 <= a < n, 0 <= c < n, 所以这就是说 a 等于 c, 所以这个过程确实能做到编码解码的功能.....
⑷ RSA算法的原理及演算过程
RSA算法非常简单，概述如下：
找两素数p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一个数e,要求满足e<t并且e与t互素（就是最大公因数为1）
取d*e%t==1
这样最终得到三个数： n d e
设消息为数M (M <n)
设c=(M**d)%n就得到了加密后的消息c
设m=(c**e)%n则 m == M，从而完成对c的解密。
注：**表示次方,上面两式中的d和e可以互换。
在对称加密中：
n d两个数构成公钥，可以告诉别人；
n e两个数构成私钥，e自己保留，不让任何人知道。
给别人发送的信息使用e加密，只要别人能用d解开就证明信息是由你发送的，构成了签名机制。
别人给你发送信息时使用d加密，这样只有拥有e的你能够对其解密。
rsa的安全性在于对于一个大数n，没有有效的方法能够将其分解
从而在已知n d的情况下无法获得e；同样在已知n e的情况下无法
求得d。
RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，
最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用
RSA对刚才的加密密钥进行加密。
最后需要说明的是，当前小于1024位的N已经被证明是不安全的
自己使用中不要使用小于1024位的RSA，最好使用2048位的。
1、防火墙
网络防火墙技术是一种特殊的网络互联设备，用于加强网络间的访问控制，防止外网用户通过外网非法进入内网，访问内网资源，保护内网运行环境。它根据一定的安全策略，检查两个或多个网络之间传输的数据包，如链路模式，以决定网络之间的通信是否允许，并监控网络运行状态。
目前防火墙产品主要有堡垒主机、包过滤路由器、应用层网关(代理服务器)、电路层网关、屏蔽主机防火墙、双宿主机等。
2、杀毒软件技术
杀毒软件绝对是使用最广泛的安全技术解决方案，因为这种技术最容易实现，但是我们都知道杀毒软件的主要功能是杀毒，功能非常有限，不能完全满足网络安全的需求，这种方式可能还是能满足个人用户或者小企业的需求，但是如果个人或者企业有电子商务的需求，就不能完全满足。
幸运的是，随着反病毒软件技术的不断发展，目前主流的反病毒软件可以防止木马等黑客程序的入侵。其他杀毒软件开发商也提供软件防火墙，具有一定的防火墙功能，在一定程度上可以起到硬件防火墙的作用，比如KV300、金山防火墙、诺顿防火墙等等。
3、文件加密和数字签名技术
与防火墙结合使用的安全技术包括文件加密和数字签名技术，其目的是提高信息系统和数据的安全性和保密性。防止秘密数据被外界窃取、截获或破坏的主要技术手段之一。随着信息技术的发展，人们越来越关注网络安全和信息保密。
目前，各国除了在法律和管理上加强数据安全保护外，还分别在软件和硬件技术上采取了措施。它促进了数据加密技术和物理防范技术的不断发展。根据功能的不同，文件加密和数字签名技术主要分为数据传输、数据存储、数据完整性判别等。
(5)rsac网络安全盛会扩展阅读：
首届全VR线上网络安全大会举办
日前，DEF CON CHINA组委会正式官宣，历经20余月的漫长等待，DEF CON CHINA Party将于3月20日在线上举办。
根据DEF CON CHINA官方提供的信息，本次DEF CON CHINA Party将全程使用VR的方式在线上进行，这也是DEF CON历史上的首次“全VR”大会。为此，主办方构建了名为The DEF CONstruct的虚拟空间和赛博世界。在计算机语言中，Construct通常被译为结构体。
⑹ 一个漏洞就能让数百万辆车被黑客操控，智能汽车的安全谁来保障
文/Hanmeimei
而在智能汽车行业真正腾飞之前，必须系上这根“安全带”，因为安全永远应该跑在速度前面。从RSAC2020上释放的信息来看，如今车企与互联网安全企业的合作已经成为主流趋势，有360这样专业的安全企业保驾护航，风口上的智能汽车行业才能飞得更高、更远也更稳。
本文来源于汽车之家车家号作者，不代表汽车之家的观点立场。
⑺ 网络安全作业，会话密钥算法效率最高的是，有一题选RSA,另外一题问的一样，却选RC-5！求学霸帮忙
RC-5是对称密码体制，用的是轮询迭代，每次轮询和迭代算法很简单，几乎是计算机最基础的加法与移位运算，轮询迭代次数也是常数数量级。RSA是非对称密码体制，涉及到的是指数运算且每次参与运算的数都是大数，so
一般非对称密码体制用于建立会话，而会话中使用对称密码体制加密
⑻ RSA算法安全么
你用33当然很简单，rsa最低要求密钥1024比特，你可以试着分解一下。
⑼ rsa security是什么工作原理
Rivest-Shamir-Adleman(RSA)公钥加密广泛用户计算机行业中的身份验证和加密。Netscape已获得在起产品中好使用RSA Data Security Inc.的RSA公钥加密的许可，具体用途是身份验证。、 公钥加密是一种使用一对不对称密钥进行加密和解密的技术。每对密钥由一个公钥和一个私钥组成。档公钥被广泛分发时，它就变得公开了。私钥从不分发；它始终是保密的。 用公钥加密的数据只能用私钥解密。繁殖，用私钥加密的数据只能用公钥解密。正是这种不对称性使得公钥加密非常有用。 使用公钥加密进行身份验证 身份验证是验证身份以使一个实体可以确认另一个实体的身份的过程。 示例： 用户A 和用户B使用公钥加密验证用户B的身份。 key //表示项目已经用密钥加密法进行了加密或解密 //something是对加密项或解密项的描述,key是用来加密或解密该项的密钥 示例： 用户A想验证用户B的身份 用户B有一对密钥：一个公钥和一个私钥。用户B向用户A披露公钥。 用户A生成随机消息并将它发送给用户B，如下所示： A->B random_message 用户B使用私钥对随机数进行加密，并将加密后的版本返回给用户A： B->A User_B's_private_key 用户A收到此消息并使用B早先公开的公钥将它解密。 用户A将解密后的消息与其最初发送给用户B的消息进行比较；如果这两个消息匹配，则用户A就知道后来的消息来自用户B，因为冒名顶替者应该不会知道用户B的私钥，因此无法正确地对随机消息加密并发送给用户A。 注意事项：示例（更加安全性） 用户B没有对用户A发送的原始消息进行加密，而是创建了消息摘要并对消息摘要进行加密。消息摘要是从原始随机消息中派生的，具有以下两种属性： 摘要很难逆转。冒名顶替用户B的人无法根据摘要确定原始消息。 冒名顶替者很难找到一个能够计算出相同摘要值的不同消息。 用户B通过使用摘要而得到了保护。用户B计算用户A发送的随机消息的摘要，然后对结果进行加密。用户B将加密的摘要发挥给用户A。通过对用户B的消息进行解密并比较生成的值，用户A可以计算出相同的摘要并验证B的身份。 注意事项里介绍的技术称之为“数字签名” 生成用于身份验证的数据 此技术要求用户B对用户A生成的消息进行签名；对于用户B而言，这与对用户A生成的随机数值进行加密几乎是同样危险的。因此此示例身份验证协议需要再增加一个步骤以保证安全；用户B需要生成以下所示的一些（或所有）数据 A->B B->A hello,are you user B?UserA,This is User B {digest[User A , This is User B]}User_B's_private_key 当用B使用此协议时，他就会知道发送给用户A的是什么消息，因此就可以放心地对消息进行签名。用户B先发送未加密版本的消息，"User A , This is User B";然后再发送加密版本。用户A很容易验证用户B是否真是用户B，并且用户B不需要对任何不是由用户B生成的消息进行签名。 交付公钥 A->B B->A A->B B->A hello Hi,I'm User B, User_B's_public_key prove it UserA, This is User B{digest[User A ,This is User B]}User_B's_private_key 如果使用此协议，任何人都可以冒名顶替用户B。冒名顶替者需要的只是一个公钥和一个密钥而已。冒名顶替这可以对用户A说谎，并通过提供冒名顶替者自己的公钥，而不是B的公钥来冒名顶替用户B。然后使用冒名顶替者的私钥对内容进行加密，来“证明”冒名顶替者就是用户B,而用户A将看不出冒名顶替者并不是用户B。 为了解决这个问题，标准团体发明了成为证书的对象。证书包含下列含义： 证书颁发者的名称 证书颁发给的实体（也成为接收方） 接收方的公钥 一些时间戳 给证书签名时需要使用证书颁发者的私钥。每个人都知道证书颁发者的公钥（即，证书颁发者也有证书）。证书是将公钥绑定到姓名上的标准方法。 如果使用证书技术，每个人都可以检查用户B的证书，以查证书是不是伪造的。如果用户B严密控制着他的私钥，并且他确实获取了证书，则证书技术是安全的。 下面是采用此项技术修订后的协议： A->B B->A A->B B->A hello Hi,I'm User B,User_B's_certificate prove it User A,This is User B{digest[User A,This Is User B]}User_B's_private_key 当用户A收到用户B的第一个消息时，用户A可以查看证书，查看签名（如前面的示例所示，通过使用摘要和公钥解密），然后检查接收方（即用户B的姓名），看他是否确实是用户B。然后用户A可以相信公钥是用户B的公钥，并可以请求用户B提供身份证明。 通过设计消息摘要，然后用经过签名的的摘要版本相应用户A，用户B就可以执行签名示例中概括介绍的过程。用户A可以通过使用证书中的公钥并检查结果，来验证用户B的消息摘要。 想要干扰安全通信的人（此示例中为用户C）可创建下列方案来常识进行干扰 A->C C-A A->C C->A hello, Hi,I'm User B,User＿B's_certificateprove it??? 但是，用户C无法在最终消息中满足用户A的要求。用户C没有用户B的私钥，因此他无法创建一条消息使用户A相信该消息来自用户B。 交换机密信息 用户A验证完用户B的身份后，他可以向用户B发送只有用户B可以解码的消息，如下所示： A->B User_B's_public_key 这里，确定secret的唯一方法是用用户B的私密对上述消息进行解密。交换机密信息是又一种使用公钥加密方法的有效方式。即使用户A和用户B之间的通信收到监视，但除了用户B以外，任何其他人都无法确定机密信息的内容。 通过对机密信息用作另一个密钥，此技术增强了Internet的安全性；但是，这种情况下，此密钥是对称加密算算（例如数据加密标准(DES)、RC4或IDEA）的密钥。用户A知道机密信息，因为是用户A生成了机密信息并将其发送给了用户B。用户B也直到机密信息，因为用户B有私钥，因而可以对用户A的消息进行解密。由于用户A和用户B都直到此机密信息，所以他们可以启动对称密码算法，然后发送给对称密码算法加密的消息。下面采用此技术修订后的协议： A->B B->A A->B B->A A->B hello Hi,I'm User B,User_B's_certificate prove it User A,This is User B{digest[User A,This is User B]}User_B's_private_key ok User B,here is a secretUser_B's_public_key secret_key 用户计算secret_key的方法因定义的协议而异，但是secret_key可能仅仅是机密信息的一个副本 安全干扰 即使使用了上述技术，想要干扰安全通信的人（用户C）仍然有可能得逞。虽然用户C无法发现用户A和用户B交换机的机密信息，但是用户C可以通过重新排列机密信息的内容（或使内容发生错乱）来干扰他们的会话。比如，如果用户C正处于用户A和用户B之间，他就可以使大部分信息毫无变化的来回传递，并篡改某些消息（他很容易做到这一点，因为他知道用户A和用户B通信时使用的协议）： A->C C-> B B->C C->A A->C C->B B->C C->A A->C C->B B->C C->A hello hello Hi,I'm User B , User_B's_certificate Hi,I'm User B,User_B's_certificate prove it prove it User A,This is User B{digest[User A,This is User B]}User_B's_private_key User A,This is User B{digest[User A,This is User B]}User_B's_private key ok User B here is a secretUser_B's_public key ok User B here is a secretUser_B's_public_key secret_key Garble[secret_key] 在用户A和用户B共享机密信息之前，用户C移植传递未经修改的数据。然后用户C篡改用户B发送给用户的消息。此时用户A已经相信B，因此用户A可能会相信被篡改的消息并依据这些消息进行操作。注意，用户C不知道机密信息，他能做的就是破坏用密钥加密的数据。用户C可能无法生成有效消息，也可能会侥幸生成有效的消息，具体如何取决于协议。 为了阻止这种破坏行为，用户A和用户B可以在他们的协议中引入消息身份验证代码。消息身份验证代码是通过使用机密信息和传输的某些数据计算出来的一组数据。上面介绍的摘要算法正好具有那些用于构造消息身份验证代码功能（可以防御用户C）的特性： message_authentication_cod:=digest[some_message,secret] 由于用户C不知道机密信息，所以他无法计算正确的摘要值。即使用户C任意篡改消息，如果有大量的摘要数据，用计C成功的可能性也很小。例如，通过使用MD5(RSA开发的一种很好的加密摘要算法)，用户A和用户B可以在消息中发送128位消息身份雁阵个代码值。用户C猜中正确的消息身份雁阵个代码的可能性大约是1：18,446,744,073,709,551,616.实际上，用户C根本不可能猜中正确的消息身份验证代码。 以下是采用此技术在此修订的示例协议： A->B B->A A->B B->A hello Hi,I'm User B,User_B's_certificate prove it User A,This is User B{digest[User A,This is User B]}User_B's_private_key ok,User B,here is a secretUser_B's_public_keysecret_key 用户C可以尝试篡改消息，但消息身份验证代码计算过程会现实此消息不是来自用户B。用户A或用户B可以发现不正确的消息身份验证代码值并停止通信。这样，用户C就无法再冒名顶替用户B。