rsa簽名加密順序

❶ 求正確的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簽名演算法，有一種專門針對先加密後簽名的攻擊。為了防止這種攻擊，推薦採用先簽名後加密。
這種攻擊方法為：
假設簽名者A用先加密後簽名的方法把消息x發給B，他是先用B的公鑰eb對x加密，然後用自己的私鑰da簽名，設A的模數為na，B的為nb，那麼，A發給B的密文為： (x^eb mod nb)^da mod na
如果B不誠實，那麼B可能偽造A的簽名。謊稱收到的是x1.因為nb是B的模數，所以B知道nb的分解，於是可以計算模nb的離散對數。 （x1）^k=x mod nb
之後，B再公布他的新公鑰。然後宣布收到的是x1不是x。

❸ RSA為什麼先簽名後加密

簽名是用私鑰來計算的。所以簽名不能隨便簽。對明文簽名可以理解。對密文簽名，你並不知道密文的內容，一旦對密文簽名，就可能出現這樣一種情況。有人想破譯一段發給你的密文，他把這段密文偽裝成需要你來簽名的內容，你簽名後就是明文了。

❹ rsa加密解密演算法

1978年就出現了這種演算法，它是第一個既能用於數據加密
也能用於數字簽名的演算法。它易於理解和操作，也很流行。算
法的名字以發明者的名字命名：Ron Rivest, AdiShamir 和
Leonard Adleman。但RSA的安全性一直未能得到理論上的證明。

RSA的安全性依賴於大數分解。公鑰和私鑰都是兩個大素數
（ 大於 100個十進制位）的函數。據猜測，從一個密鑰和密文
推斷出明文的難度等同於分解兩個大素數的積。

密鑰對的產生:選擇兩個大素數，p 和q 。計算：
n = p * q
然後隨機選擇加密密鑰e，要求 e 和 ( p - 1 ) * ( q - 1 )
互質。最後，利用Euclid 演算法計算解密密鑰d, 滿足

e * d = 1 ( mod ( p - 1 ) * ( q - 1 ) )

其中n和d也要互質。數e和
n是公鑰，d是私鑰。兩個素數p和q不再需要，應該丟棄，不要讓任
何人知道。 加密信息 m（二進製表示）時，首先把m分成等長數據
塊 m1 ,m2,..., mi ，塊長s，其中 2^s <= n, s 盡可能的大。對
應的密文是：

ci = mi^e ( mod n ) ( a )

解密時作如下計算：

mi = ci^d ( mod n ) ( b )

RSA 可用於數字簽名，方案是用 ( a ) 式簽名， ( b )
式驗證。具體操作時考慮到安全性和 m信息量較大等因素，一般是先
作 HASH 運算。

RSA 的安全性。
RSA的安全性依賴於大數分解，但是否等同於大數分解一直未能得到理
論上的證明，因為沒有證明破解RSA就一定需要作大數分解。假設存在
一種無須分解大數的演算法，那它肯定可以修改成為大數分解演算法。目前，
RSA的一些變種演算法已被證明等價於大數分解。不管怎樣，分解n是最顯
然的攻擊方法。現在，人們已能分解140多個十進制位的大素數。因此，
模數n必須選大一些，因具體適用情況而定。

RSA的速度:
由於進行的都是大數計算，使得RSA最快的情況也比DES慢上100倍，無論
是軟體還是硬體實現。速度一直是RSA的缺陷。一般來說只用於少量數據
加密。

RSA的選擇密文攻擊:
RSA在選擇密文攻擊面前很脆弱。一般攻擊者是將某一信息作一下偽裝
(Blind)，讓擁有私鑰的實體簽署。然後，經過計算就可得到它所想要的信
息。實際上，攻擊利用的都是同一個弱點，即存在這樣一個事實：乘冪保
留了輸入的乘法結構：

( XM )^d = X^d *M^d mod n

前面已經提到，這個固有的問題來自於公鑰密碼系統的最有用的特徵
--每個人都能使用公鑰。但從演算法上無法解決這一問題，主要措施有
兩條：一條是採用好的公鑰協議，保證工作過程中實體不對其他實體
任意產生的信息解密，不對自己一無所知的信息簽名；另一條是決不
對陌生人送來的隨機文檔簽名，簽名時首先使用One-Way HashFunction
對文檔作HASH處理，或同時使用不同的簽名演算法。在中提到了幾種不
同類型的攻擊方法。

RSA的公共模數攻擊。
若系統中共有一個模數，只是不同的人擁有不同的e和d，系統將是危險
的。最普遍的情況是同一信息用不同的公鑰加密，這些公鑰共模而且互
質，那末該信息無需私鑰就可得到恢復。設P為信息明文，兩個加密密鑰
為e1和e2，公共模數是n，則：

C1 = P^e1 mod n

C2 = P^e2 mod n

密碼分析者知道n、e1、e2、C1和C2，就能得到P。

因為e1和e2互質，故用Euclidean演算法能找到r和s，滿足：

r * e1 + s * e2 = 1

假設r為負數，需再用Euclidean演算法計算C1^(-1)，則

( C1^(-1) )^(-r) * C2^s = P mod n

另外，還有其它幾種利用公共模數攻擊的方法。總之，如果知道給定模數
的一對e和d，一是有利於攻擊者分解模數，一是有利於攻擊者計算出其它
成對的e』和d』，而無需分解模數。解決辦法只有一個，那就是不要共享
模數n。

RSA的小指數攻擊。 有一種提高
RSA速度的建議是使公鑰e取較小的值，這樣會使加密變得易於實現，速度
有所提高。但這樣作是不安全的，對付辦法就是e和d都取較大的值。

RSA演算法是第一個能同時用於加密和數字簽名的演算法，也易於理解和操作。
RSA是被研究得最廣泛的公鑰演算法，從提出到現在已近二十年，經歷了各
種攻擊的考驗，逐漸為人們接受，普遍認為是目前最優秀的公鑰方案之一。
RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難
度與大數分解難度等價。即RSA的重大缺陷是無法從理論上把握它的保密性
能如何，而且密碼學界多數人士傾向於因子分解不是NPC問題。

RSA的缺點主要有：
A)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次
一密。B)分組長度太大，為保證安全性，n 至少也要 600 bits
以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；
且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。
目前，SET(Secure Electronic Transaction)協議中要求CA採用2048比特長
的密鑰，其他實體使用1024比特的密鑰。

❺ 如何使用RSA簽名給給信息加密和解密

java">{
publicstaticfinalStringKEY_ALGORITHM="RSA";
_ALGORITHM="MD5withRSA";

_KEY="RSAPublicKey";
_KEY="RSAPrivateKey";

/**
*用私鑰對信息生成數字簽名
*
*@paramdata
*加密數據
*@paramprivateKey
*私鑰
*
*@return
*@throwsException
*/
publicstaticStringsign(byte[]data,StringprivateKey)throwsException{
//解密由base64編碼的私鑰
byte[]keyBytes=decryptBASE64(privateKey);

//構造PKCS8EncodedKeySpec對象
=newPKCS8EncodedKeySpec(keyBytes);

//KEY_ALGORITHM指定的加密演算法
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);

//取私鑰匙對象
PrivateKeypriKey=keyFactory.generatePrivate(pkcs8KeySpec);

//用私鑰對信息生成數字簽名
Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(priKey);
signature.update(data);

returnencryptBASE64(signature.sign());
}

/**
*校驗數字簽名
*
*@paramdata
*加密數據
*@parampublicKey
*公鑰
*@paramsign
*數字簽名
*
*@return校驗成功返回true失敗返回false
*@throwsException
*
*/
publicstaticbooleanverify(byte[]data,StringpublicKey,Stringsign)
throwsException{

//解密由base64編碼的公鑰
byte[]keyBytes=decryptBASE64(publicKey);

//構造X509EncodedKeySpec對象
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(keyBytes);

//KEY_ALGORITHM指定的加密演算法
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);

//取公鑰匙對象
PublicKeypubKey=keyFactory.generatePublic(keySpec);

Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(pubKey);
signature.update(data);

//驗證簽名是否正常
returnsignature.verify(decryptBASE64(sign));
}

/**
*解密<br>
*用私鑰解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPrivateKey(byte[]data,Stringkey)
throwsException{
//對密鑰解密
byte[]keyBytes=decryptBASE64(key);

//取得私鑰
=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);

//對數據解密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,privateKey);

returncipher.doFinal(data);
}

/**
*解密<br>
*用私鑰解密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]decryptByPublicKey(byte[]data,Stringkey)
throwsException{
//對密鑰解密
byte[]keyBytes=decryptBASE64(key);

//取得公鑰
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeypublicKey=keyFactory.generatePublic(x509KeySpec);

//對數據解密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE,publicKey);

returncipher.doFinal(data);
}

/**
*加密<br>
*用公鑰加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPublicKey(byte[]data,Stringkey)
throwsException{
//對公鑰解密
byte[]keyBytes=decryptBASE64(key);

//取得公鑰
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeypublicKey=keyFactory.generatePublic(x509KeySpec);

//對數據加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,publicKey);

returncipher.doFinal(data);
}

/**
*加密<br>
*用私鑰加密
*
*@paramdata
*@paramkey
*@return
*@throwsException
*/
publicstaticbyte[]encryptByPrivateKey(byte[]data,Stringkey)
throwsException{
//對密鑰解密
byte[]keyBytes=decryptBASE64(key);

//取得私鑰
=newPKCS8EncodedKeySpec(keyBytes);
KeyFactorykeyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
KeyprivateKey=keyFactory.generatePrivate(pkcs8KeySpec);

//對數據加密
Ciphercipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE,privateKey);

returncipher.doFinal(data);
}

/**
*取得私鑰
*
*@paramkeyMap
*@return
*@throwsException
*/
(Map<String,Object>keyMap)
throwsException{
Keykey=(Key)keyMap.get(PRIVATE_KEY);

returnencryptBASE64(key.getEncoded());
}

/**
*取得公鑰
*
*@paramkeyMap
*@return
*@throwsException
*/
(Map<String,Object>keyMap)
throwsException{
Keykey=(Key)keyMap.get(PUBLIC_KEY);

returnencryptBASE64(key.getEncoded());
}

/**
*初始化密鑰
*
*@return
*@throwsException
*/
publicstaticMap<String,Object>initKey()throwsException{
KeyPairGeneratorkeyPairGen=KeyPairGenerator
.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(1024);

KeyPairkeyPair=keyPairGen.generateKeyPair();

//公鑰
RSAPublicKeypublicKey=(RSAPublicKey)keyPair.getPublic();

//私鑰
RSAPrivateKeyprivateKey=(RSAPrivateKey)keyPair.getPrivate();

Map<String,Object>keyMap=newHashMap<String,Object>(2);

keyMap.put(PUBLIC_KEY,publicKey);
keyMap.put(PRIVATE_KEY,privateKey);
returnkeyMap;
}
}

❻ RSA加密與對稱加密如何使用呢他們的混合應用又應該怎麼用呢

RSA演算法是第一個能同時用於加密和數字簽名的演算法。RSA演算法能生成公私鑰對。
假設A、B要通信，那麼他們需要彼此知道對方的公鑰，如果a向b發送信息，a先用自己的私鑰對信息進行加密(即簽名)，然後用b的公鑰進行加密。當
b收到消息時，先用自己的私鑰進行解密，然後用a的公用進行解密(即驗證簽名)，即可看到a發送的明文信息。
若是用對稱密鑰進行加密，則雙方公用一個密鑰，這個密鑰需要絕對保密，不能讓別人知道。a在向b發送信息前，先用這個密鑰對信息進行加密，然後把加密的信息發送給b，之後再把密鑰通過另一通道發送給b(要保證密鑰傳輸的安全，不被其他人截獲)，b收到密文和密鑰後，再用這個密鑰進行解密，就可以得到原文。
若混合使用，假設還是a向b發送信息，a先用自己的私鑰進行簽名，然後再用雙方公用的對稱密鑰(即會話密鑰)進行加密，得到加密後的密文，然後用b的公鑰對雙方的會話密鑰進行加密，得到加密的會話密鑰，然後把加密的密文和加密的會話密鑰一起發給b，b收到後先用自己的私鑰對加密的會話密鑰進行解密，得到會話密鑰，再用會話密鑰對加密的密文進行解密，得到簽名的信息，然後用a的公鑰對簽名進行驗證，便可得到原始信息。

❼ RSA演算法加密

RSA加密演算法是一種典型的非對稱加密演算法，它基於大數的因式分解數學難題，它也是應用最廣泛的非對稱加密演算法，於1978年由美國麻省理工學院（MIT）的三位學著：Ron Rivest、Adi Shamir 和 Leonard Adleman 共同提出。

它的原理較為簡單，假設有消息發送方A和消息接收方B，通過下面的幾個步驟，就可以完成消息的加密傳遞：
消息發送方A在本地構建密鑰對，公鑰和私鑰；
消息發送方A將產生的公鑰發送給消息接收方B；
B向A發送數據時，通過公鑰進行加密，A接收到數據後通過私鑰進行解密，完成一次通信；
反之，A向B發送數據時，通過私鑰對數據進行加密，B接收到數據後通過公鑰進行解密。
由於公鑰是消息發送方A暴露給消息接收方B的，所以這種方式也存在一定的安全隱患，如果公鑰在數據傳輸過程中泄漏，則A通過私鑰加密的數據就可能被解密。
如果要建立更安全的加密消息傳遞模型，需要消息發送方和消息接收方各構建一套密鑰對，並分別將各自的公鑰暴露給對方，在進行消息傳遞時，A通過B的公鑰對數據加密，B接收到消息通過B的私鑰進行解密，反之，B通過A的公鑰進行加密，A接收到消息後通過A的私鑰進行解密。
當然，這種方式可能存在數據傳遞被模擬的隱患，但可以通過數字簽名等技術進行安全性的進一步提升。由於存在多次的非對稱加解密，這種方式帶來的效率問題也更加嚴重。

❽ 急！！！《密碼學》問題！ RSA數字簽名中為什麼不能先加密後簽名

用RSA給別人發送一則信息，首先要用私鑰加密簽名，然後再用對方的公鑰加密信息和簽名，把消息發送給對方。
如果先加密後簽名，那麼簽名在傳播途中被人為地篡改，我們可以做個形象的比喻，本來鮑勃要發送給對方一則信息給艾麗絲，可是途中卻被伊芙攔截，把簽名稍加修改就成了自己發出去的一則信息了，那麼鮑勃就不知道這是誰發出的信息了。

❾ 密碼學問題 為什麼RSA數字簽名一定要先簽名、後加密我是初學者，謝謝！！！

我是這么覺得：
簽名的一個目的是：防止簽名雙方抵賴。
如果先加密的話，到時候他有可能不認賬。
而且，特別是針對RSA簽名演算法，有一種專門針對先加密後簽名的攻擊。為了防止這種攻擊，推薦採用先簽名後加密。
這種攻擊方法為：
假設簽名者A用先加密後簽名的方法把消息x發給B，他是先用B的公鑰eb對x加密，然後用自己的私鑰da簽名，設A的模數為na，B的為nb，那麼，A發給B的密文為：
(x^eb
mod
nb)^da
mod
na
如果B不誠實，那麼B可能偽造A的簽名。謊稱收到的是x1.因為nb是B的模數，所以B知道nb的分解，於是可以計算模nb的離散對數。
（x1）^k=x
mod
nb
之後，B再公布他的新公鑰。然後宣布收到的是x1不是x。