Ⅰ 如何用C語言來使用openssl rsa進行公鑰加密，已有公鑰和明文
1. 本程序使用2048位密鑰對,每次加密時,原始數據的最大長度為245位元組,加密後的密文長度為256位元組.(採用打PADDING 的加密方式)
2. 如果所加密數據長度大於245位元組,請分多次加密,後將密文按順序存儲;解密時,每次讀取256位元組,進行解密,將解密後的數據依次按順序存儲,即可還原原始數據.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>
#define OPENSSLKEY "test.key"
#define PUBLICKEY "test_pub.key"
#define BUFFSIZE 1024
char *my_encrypt(char *str, char *path_key); //加密
char *my_decrypt(char *str, char *path_key); //解密
int main(void)
{
char *source = "i like dancing !!!";
char *ptf_en, *ptf_de;
printf("source is :%s\n", source);
//1.加密
ptf_en = my_encrypt(source, PUBLICKEY);
if (ptf_en == NULL){
return 0;
}else{
printf("ptf_en is :%s\n", ptf_en);
}
//2.解密
ptf_de = my_decrypt(ptf_en, OPENSSLKEY);
if (ptf_de == NULL){
return 0;
}else{
printf("ptf_de is :%s\n", ptf_de);
}
if(ptf_en) free(ptf_en);
if(ptf_de) free(ptf_de);
return 0;
}
//加密
char *my_encrypt(char *str, char *path_key)
{
char *p_en = NULL;
RSA *p_rsa = NULL;
FILE *file = NULL;
int lenth = 0; //flen為源文件長度， rsa_len為秘鑰長度
//1.打開秘鑰文件
if((file = fopen(path_key, "rb")) == NULL)
{
perror("fopen() error 111111111 ");
goto End;
}
//2.從公鑰中獲取 加密的秘鑰
if((p_rsa = PEM_read_RSA_PUBKEY(file, NULL,NULL,NULL )) == NULL)
{
ERR_print_errors_fp(stdout);
goto End;
}
lenth = strlen(str);
p_en = (char *)malloc(256);
if(!p_en)
{
perror("malloc() error 2222222222");
goto End;
}
memset(p_en, 0, 256);
//5.對內容進行加密
if(RSA_public_encrypt(lenth, (unsigned char*)str, (unsigned char*)p_en, p_rsa, RSA_PKCS1_PADDING) < 0)
{
perror("RSA_public_encrypt() error 2222222222");
goto End;
}
End:
//6.釋放秘鑰空間， 關閉文件
if(p_rsa) RSA_free(p_rsa);
if(file) fclose(file);
return p_en;
}
//解密
char *my_decrypt(char *str, char *path_key)
{
char *p_de = NULL;
RSA *p_rsa = NULL;
FILE *file = NULL;
//1.打開秘鑰文件
file = fopen(path_key, "rb");
if(!file)
{
perror("fopen() error 22222222222");
goto End;
}
//2.從私鑰中獲取 解密的秘鑰
if((p_rsa = PEM_read_RSAPrivateKey(file, NULL,NULL,NULL )) == NULL)
{
ERR_print_errors_fp(stdout);
goto End;
}
p_de = (char *)malloc(245);
if(!p_de)
{
perror("malloc() error ");
goto End;
}
memset(p_de, 0, 245);
//5.對內容進行加密
if(RSA_private_decrypt(256, (unsigned char*)str, (unsigned char*)p_de, p_rsa, RSA_PKCS1_PADDING) < 0)
{
perror("RSA_public_encrypt() error ");
goto End;
}
End:
//6.釋放秘鑰空間， 關閉文件
if(p_rsa) RSA_free(p_rsa);
if(file) fclose(file);
return p_de;
}
Ⅱ 怎麼在ios進行rsa公鑰加密，java做rsa私鑰解密
1、用公鑰加密，用私鑰解密。
2、給別人發信息，就從伺服器上拉下來別人的公鑰，加密後發給他。
3、對方拿到信息後用自己的私鑰解密。
4、這樣，公鑰加密後除了私鑰持有人，別人都看不到信息。
5、若是用私鑰加密，那麼公鑰都能解密，還有何安全性可言？
6、私鑰加密的場合只有一個，那就是數字簽名，用來表明這個信息來源於你。
Ⅲ 如何使用16進制編碼的RSA公鑰進行RSA加密
我們來回顧一下RSA的加密演算法。我們從公鑰加密演算法和簽名演算法的定義出發，用比較規范的語言來描述這一演算法。RSA公鑰加密體制包含如下3個演算法：KeyGen（密鑰生成演算法），Encrypt（加密演算法）以及Decrypt（解密演算法）。(PK,SK)\leftarrowKeyGen(\lambda)。密鑰生成演算法以安全常數\lambda作為輸入，輸出一個公鑰PK，和一個私鑰SK。安全常數用於確定這個加密演算法的安全性有多高，一般以加密演算法使用的質數p的大小有關。\lambda越大，質數p一般越大，保證體制有更高的安全性。在RSA中，密鑰生成演算法如下：演算法首先隨機產生兩個不同大質數p和q，計算N=pq。隨後，演算法計算歐拉函數\varphi(N)=(p-1)(q-1)。接下來，演算法隨機選擇一個小於\varphi(N)的整數e，並計算e關於\varphi(N)的模反元素d。最後，公鑰為PK=(N,e)，私鑰為SK=（N,d）。CT\leftarrowEncrypt(PK,M)。加密演算法以公鑰PK和待加密的消息M作為輸入，輸出密文CT。在RSA中，加密演算法如下：演算法直接輸出密文為CT=M^e\mod\varphi(N)M\leftarrowDecrypt(SK,CT)。解密演算法以私鑰SK和密文CT作為輸入，輸出消息M。在RSA中，解密演算法如下：演算法直接輸出明文為M=CT^d\mod\varphi(N)。由於e和d在\varphi(N)下互逆，因此我們有：CT^d=M^{ed}=M\mod\varphi(N)所以，從演算法描述中我們也可以看出：公鑰用於對數據進行加密，私鑰用於對數據進行解密。當然了，這個也可以很直觀的理解：公鑰就是公開的密鑰，其公開了大家才能用它來加密數據。私鑰是私有的密鑰，誰有這個密鑰才能夠解密密文。否則大家都能看到私鑰，就都能解密，那不就亂套了。=================分割線=================我們再來回顧一下RSA簽名體制。簽名體制同樣包含3個演算法：KeyGen（密鑰生成演算法），Sign（簽名演算法），Verify（驗證演算法）。(PK,SK)\leftarrowKeyGen(\lambda)。密鑰生成演算法同樣以安全常數\lambda作為輸入，輸出一個公鑰PK和一個私鑰SK。在RSA簽名中，密鑰生成演算法與加密演算法完全相同。\sigma\leftarrowSign(SK,M)。簽名演算法以私鑰SK和待簽名的消息M作為輸入，輸出簽名\sigma。在RSA簽名中，簽名演算法直接輸出簽名為\sigma=M^d\mod\varphi(N)。注意，簽名演算法和RSA加密體制中的解密演算法非常像。b\leftarrowVerify(PK,\sigma,M)。驗證演算法以公鑰PK，簽名\sigma以及消息M作為輸入，輸出一個比特值b。b=1意味著驗證通過。b=0意味著驗證不通過。在RSA簽名中，驗證演算法首先計算M'=\sigma^e\mod\varphi(N)，隨後對比M'與M，如果相等，則輸出b=1，否則輸出b=0。注意：驗證演算法和RSA加密體制中的加密演算法非常像。所以，在簽名演算法中，私鑰用於對數據進行簽名，公鑰用於對簽名進行驗證。這也可以直觀地進行理解：對一個文件簽名，當然要用私鑰，因為我們希望只有自己才能完成簽字。驗證過程當然希望所有人都能夠執行，大家看到簽名都能通過驗證證明確實是我自己簽的。=================分割線=================那麼，為什麼題主問這么一個問題呢？我們可以看到，RSA的加密/驗證，解密/簽字過程太像了。同時，RSA體制本身就是對稱的：如果我們反過來把e看成私鑰，d看成公鑰，這個體制也能很好的執行。我想正是由於這個原因，題主在學習RSA體制的時候才會出現這種混亂。那麼解決方法是什麼呢？建議題主可以學習一下其他的公鑰加密體制以及簽名體制。其他的體制是沒有這種對稱性質的。舉例來說，公鑰加密體制的話可以看一看ElGamal加密，以及更安全的Cramer-Shoup加密。簽名體制的話可以進一步看看ElGamal簽名，甚至是BLS簽名，這些體制可能能夠幫助題主更好的弄清加密和簽名之間的區別和潛在的聯系。至於題主問的加密和簽名是怎麼結合的。這種體制叫做簽密方案（SignCrypt），RSA中，這種簽密方案看起來特別特別像，很容易引起混亂。在此我不太想詳細介紹RSA中的加密與簽字結合的方案。我想提醒題主的是，加密與簽字結合時，兩套公私鑰是不同的。
Ⅳ 如何使用16進制編碼的RSA公鑰進行RSA加密
java加密方法如下：
Java code
String modeHex = "";
String exponentHex = "10001";
KeyFactory factory = KeyFactory.getInstance("RSA");
BigInteger n = new BigInteger(modeHex, 16);
BigInteger e = new BigInteger(exponentHex, 16);
RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
RSAPublicKey pub = (RSAPublicKey) factory.generatePublic(spec);
Cipher enc = Cipher.getInstance("RSA");
enc.init(Cipher.ENCRYPT_MODE, pub);
byte[] encryptedContentKey = enc.doFinal(messageg.getBytes("GB2312"));
String result = new String(Hex.encodeHex(encryptedContentKey));java加密方法如下：
Java code
String modeHex = "";
String exponentHex = "10001";
KeyFactory factory = KeyFactory.getInstance("RSA");
BigInteger n = new BigInteger(modeHex, 16);
BigInteger e = new BigInteger(exponentHex, 16);
RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
RSAPublicKey pub = (RSAPublicKey) factory.generatePublic(spec);
Cipher enc = Cipher.getInstance("RSA");
enc.init(Cipher.ENCRYPT_MODE, pub);
byte[] encryptedContentKey = enc.doFinal(messageg.getBytes("GB2312"));
String result = new String(Hex.encodeHex(encryptedContentKey));java加密方法如下：java加密方法如下：
Java code
String modeHex = "";
String exponentHex = "10001";
KeyFactory factory = KeyFactory.getInstance("RSA");
BigInteger n = new BigInteger(modeHex, 16);
BigInteger e = new BigInteger(exponentHex, 16);
RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
RSAPublicKey pub = (RSAPublicKey) factory.generatePublic(spec);
Cipher enc = Cipher.getInstance("RSA");
enc.init(Cipher.ENCRYPT_MODE, pub);
byte[] encryptedContentKey = enc.doFinal(messageg.getBytes("GB2312"));
String result = new String(Hex.encodeHex(encryptedContentKey));
Java code
String modeHex = "";
String exponentHex = "10001";
KeyFactory factory = KeyFactory.getInstance("RSA");
BigInteger n = new BigInteger(modeHex, 16);
BigInteger e = new BigInteger(exponentHex, 16);
RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
RSAPublicKey pub = (RSAPublicKey) factory.generatePublic(spec);
Cipher enc = Cipher.getInstance("RSA");
enc.init(Cipher.ENCRYPT_MODE, pub);
byte[] encryptedContentKey = enc.doFinal(messageg.getBytes("GB2312"));
String result = new String(Hex.encodeHex(encryptedContentKey));java加密方法如下：
Java code
String modeHex = "";
String exponentHex = "10001";
KeyFactory factory = KeyFactory.getInstance("RSA");
BigInteger n = new BigInteger(modeHex, 16);
BigInteger e = new BigInteger(exponentHex, 16);
RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
RSAPublicKey pub = (RSAPublicKey) factory.generatePublic(spec);
Cipher enc = Cipher.getInstance("RSA");
enc.init(Cipher.ENCRYPT_MODE, pub);
byte[] encryptedContentKey = enc.doFinal(messageg.getBytes("GB2312"));
String result = new String(Hex.encodeHex(encryptedContentKey));java加密方法如下：
Java code
String modeHex = "";
String exponentHex = "10001";
KeyFactory factory = KeyFactory.getInstance("RSA");
BigInteger n = new BigInteger(modeHex, 16);
BigInteger e = new BigInteger(exponentHex, 16);
RSAPublicKeySpec spec = new RSAPublicKeySpec(n, e);
RSAPublicKey pub = (RSAPublicKey) factory.generatePublic(spec);
Cipher enc = Cipher.getInstance("RSA");
enc.init(Cipher.ENCRYPT_MODE, pub);
byte[] encryptedContentKey = enc.doFinal(messageg.getBytes("GB2312"));
String result = new String(Hex.encodeHex(encryptedContentKey));
Ⅳ RSA公鑰加密是什麼意思
RSA公鑰密碼是1977年由Ron Rivest、Adi Shamirh和LenAdleman在MIT(美國麻省理工學院〉開發的,1978年首次公布[RIVE78]。它是目前最有影響的公鑰加密演算法,它能夠抵抗到目前為止已知的所有密碼攻擊。目前它已被ISO推薦為公鑰數據加密標准。RSA演算法基於一個十分簡單的數論事實:將兩個大素數相乘十分容易,但是想分解它們的乘積卻極端困難,因此可以將乘積公開作為加密密鑰。
RSA的演算法結構相當簡單,整個演算法可以描述如下:
(1)選取兩個大素數p和q(保密)；
(2)計算n=pq(公開),γ=(p一1〉(q-1)(保密)；
(3)隨機選取整數e(公開,加密密鑰),使得ed(ear)=1
(4)計算d(保密,私人密鑰),使得ed≡1(mod r),即d=e-1(mod r);
（5)加密:c=me mod n
(6)解密:m=cd mod n。
利用RSA對被加密的信息m (長度小於log2n的整數)進行加密得到相應的密文c=me mod n;解密演算法則是計算m=cd modn RSA的優點是不需要密鑰分配,但缺點是速度慢。
Ⅵ 公鑰密碼系統及RSA公鑰演算法
公鑰密碼系統及RSA公鑰演算法
本文簡單介紹了公開密鑰密碼系統的思想和特點，並具體介紹了RSA演算法的理論基礎，工作原理和具體實現過程，並通過一個簡單例子說明了該演算法是如何實現。在本文的最後，概括說明了RSA演算法目前存在的一些缺點和解決方法。
關鍵詞：公鑰密碼體制 ， 公鑰 ，私鑰 ，RSA
§1引言
隨著計算機聯網的逐步實現，Internet前景越來越美好，全球經濟發展正在進入信息經濟時代，知識經濟初見端倪。計算機信息的保密問題顯得越來越重要，無論是個人信息通信還是電子商務發展，都迫切需要保證Internet網上信息傳輸的安全，需要保證信息安全。信息安全技術是一門綜合學科，它涉及資訊理論、計算機科學和密碼學等多方面知識，它的主要任務是研究計算機系統和通信網路內信息的保護方法以實現系統內信息的安全、保密、真實和完整。其中，信息安全的核心是密碼技術。密碼技術是集數學、計算機科學、電子與通信等諸多學科於一身的交叉學科。它不僅能夠保證機密性信息的加密，而且能夠實現數字簽名、身份驗證、系統安全等功能。是現代化發展的重要科學之一。本文將對公鑰密碼系統及該系統中目前最廣泛流行的RSA演算法做一些簡單介紹。
§2公鑰密碼系統
要說明公鑰密碼系統，首先來了解一下不同的加密演算法：目前的加密演算法按密鑰方式可分為單鑰密碼演算法和公鑰密碼演算法。
2.1.單鑰密碼
又稱對稱式密碼，是一種比較傳統的加密方式，其加密運算、解密運算使用的是同樣的密鑰，信息的發送者和信息的接收者在進行信息的傳輸與處理時，必須共同持有該密碼（稱為對稱密碼）。因此，通信雙方都必須獲得這把鑰匙，並保持鑰匙的秘密。
單鑰密碼系統的安全性依賴於以下兩個因素：第一，加密演算法必須是足夠強的，僅僅基於密文本身去解密信息在實踐上是不可能的；第二，加密方法的安全性依賴於密鑰的秘密性，而不是演算法的秘密性，因此，我們沒有必要確保演算法的秘密性（事實上，現實中使用的很多單鑰密碼系統的演算法都是公開的），但是我們一定要保證密鑰的秘密性。
從單鑰密碼的這些特點我們容易看出它的主要問題有兩點：第一，密鑰量問題。在單鑰密碼系統中，每一對通信者就需要一對密鑰，當用戶增加時，必然會帶來密鑰量的成倍增長，因此在網路通信中，大量密鑰的產生﹑存放和分配將是一個難以解決的問題。第二，密鑰分發問題。單鑰密碼系統中，加密的安全性完全依賴於對密鑰的保護，但是由於通信雙方使用的是相同的密鑰，人們又不得不相互交流密鑰，所以為了保證安全，人們必須使用一些另外的安全信道來分發密鑰，例如用專門的信使來傳送密鑰，這種做法的代價是相當大的，甚至可以說是非常不現實的，尤其在計算機網路環境下，人們使用網路傳送加密的文件，卻需要另外的安全信道來分發密鑰，顯而易見，這是非常不智是甚至是荒謬可笑的。
2.2公鑰密碼
正因為單鑰密碼系統存在如此難以解決的缺點，發展一種新的﹑更有效﹑更先進的密碼體制顯得更為迫切和必要。在這種情況下，出現了一種新的公鑰密碼體制，它突破性地解決了困擾著無數科學家的密鑰分發問題，事實上，在這種體制中，人們甚至不用分發需要嚴格保密的密鑰，這次突破同時也被認為是密碼史上兩千年來自單碼替代密碼發明以後最偉大的成就。
這一全新的思想是本世紀70年代，美國斯坦福大學的兩名學者Diffie和Hellman提出的，該體制與單鑰密碼最大的不同是：
在公鑰密碼系統中，加密和解密使用的是不同的密鑰（相對於對稱密鑰，人們把它叫做非對稱密鑰），這兩個密鑰之間存在著相互依存關系：即用其中任一個密鑰加密的信息只能用另一個密鑰進行解密。這使得通信雙方無需事先交換密鑰就可進行保密通信。其中加密密鑰和演算法是對外公開的，人人都可以通過這個密鑰加密文件然後發給收信者，這個加密密鑰又稱為公鑰；而收信者收到加密文件後,它可以使用他的解密密鑰解密，這個密鑰是由他自己私人掌管的，並不需要分發，因此又成稱為私鑰，這就解決了密鑰分發的問題。
為了說明這一思想,我們可以考慮如下的類比：
兩個在不安全信道中通信的人，假設為Alice（收信者）和Bob（發信者），他們希望能夠安全的通信而不被他們的敵手Oscar破壞。Alice想到了一種辦法，她使用了一種鎖（相當於公鑰），這種鎖任何人只要輕輕一按就可以鎖上，但是只有Alice的鑰匙（相當於私鑰）才能夠打開。然後Alice對外發送無數把這樣的鎖，任何人比如Bob想給她寄信時，只需找到一個箱子，然後用一把Alice的鎖將其鎖上再寄給Alice，這時候任何人（包括Bob自己）除了擁有鑰匙的Alice，都不能再打開箱子，這樣即使Oscar能找到Alice的鎖，即使Oscar能在通信過程中截獲這個箱子，沒有Alice的鑰匙他也不可能打開箱子，而Alice的鑰匙並不需要分發，這樣Oscar也就無法得到這把「私人密鑰」。
從以上的介紹可以看出，公鑰密碼體制的思想並不復雜，而實現它的關鍵問題是如何確定公鑰和私鑰及加/解密的演算法，也就是說如何找到「Alice的鎖和鑰匙」的問題。我們假設在這種體制中, PK是公開信息，用作加密密鑰，而SK需要由用戶自己保密，用作解密密鑰。加密演算法E和解密演算法D也都是公開的。雖然SK與PK是成對出現，但卻不能根據PK計算出SK。它們須滿足條件：
①加密密鑰PK對明文X加密後，再用解密密鑰SK解密，即可恢復出明文，或寫為：DSK（EPK（X））=X
②加密密鑰不能用來解密，即DPK（EPK（X））≠X
③在計算機上可以容易地產生成對的PK和SK。
④從已知的PK實際上不可能推導出SK。
⑤加密和解密的運算可以對調，即：EPK（DSK（X））=X
從上述條件可看出，公開密鑰密碼體制下，加密密鑰不等於解密密鑰。加密密鑰可對外公開，使任何用戶都可將傳送給此用戶的信息用公開密鑰加密發送，而該用戶唯一保存的私人密鑰是保密的，也只有它能將密文復原、解密。雖然解密密鑰理論上可由加密密鑰推算出來，但這種演算法設計在實際上是不可能的，或者雖然能夠推算出，但要花費很長的時間而成為不可行的。所以將加密密鑰公開也不會危害密鑰的安全。
這種體制思想是簡單的，但是，如何找到一個適合的演算法來實現這個系統卻是一個真正困擾密碼學家們的難題，因為既然Pk和SK是一對存在著相互關系的密鑰，那麼從其中一個推導出另一個就是很有可能的，如果敵手Oscar能夠從PK推導出SK，那麼這個系統就不再安全了。因此如何找到一個合適的演算法生成合適的Pk和SK，並且使得從PK不可能推導出SK，正是迫切需要密碼學家們解決的一道難題。這個難題甚至使得公鑰密碼系統的發展停滯了很長一段時間。
為了解決這個問題，密碼學家們考慮了數學上的陷門單向函數，下面，我們可以給出它的非正式定義：
Alice的公開加密函數應該是容易計算的，而計算其逆函數（即解密函數）應該是困難的（對於除Alice以外的人）。許多形式為Y=f（x）的函數，對於給定的自變數x值，很容易計算出函數Y的值；而由給定的Y值，在很多情況下依照函數關系f (x)計算x值十分困難。這樣容易計算但難於求逆的函數，通常稱為單向函數。在加密過程中，我們希望加密函數E為一個單項的單射函數，以便可以解密。雖然目前還沒有一個函數能被證明是單向的，但是有很多單射函數被認為是單向的。
例如，有如下一個函數被認為是單向的，假定n為兩個大素數p和q的乘積，b為一個正整數，那麼定義f：
f (x )= x b mod n
(如果gcd（b,φ（n））=1，那麼事實上這就是我們以下要說的RSA加密函數)
如果我們要構造一個公鑰密碼體制，僅給出一個單向的單射函數是不夠的。從Alice的觀點來看，並不需要E是單向的，因為它需要用有效的方式解密所收到的信息。因此，Alice應該擁有一個陷門，其中包含容易求出E的你函數的秘密信息。也就是說，Alice可以有效解密，因為它有額外的秘密知識，即SK，能夠提供給你解密函數D。因此，我們稱一個函數為一個陷門單向函數，如果它是一個單向函數，並在具有特定陷門的知識後容易求出其逆。
考慮上面的函數f (x) = xb mod n。我們能夠知道其逆函數f -1有類似的形式f (x ) = xa mod n，對於合適的取值a。陷門就是利用n的因子分解，有效的算出正確的指數a（對於給定的b）。
為方便起見，我們把特定的某類陷門單向函數計為?。那麼隨機選取一個函數f屬於?，作為公開加密函數；其逆函數f-1是秘密解密函數。那麼公鑰密碼體制就能夠實現了。
根據以上關於陷門單向函數的思想,學者們提出了許多種公鑰加密的方法，它們的安全性都是基於復雜的數學難題。根據所基於的數學難題，至少有以下三類系統目前被認為是安全和有效的：大整數因子分解系統(代表性的有RSA)、橢園曲線離散對數系統(ECC)和離散對數系統(代表性的有DSA)。
§3 RSA演算法
3.1簡介
當前最著名、應用最廣泛的公鑰系統RSA是在1978年，由美國麻省理工學院(MIT)的Rivest、Shamir和Adleman在題為《獲得數字簽名和公開鑰密碼系統的方法》的論文中提出的。它是一個基於數論的非對稱(公開鑰)密碼體制，是一種分組密碼體制。其名稱來自於三個發明者的姓名首字母。它的安全性是基於大整數素因子分解的困難性，而大整數因子分解問題是數學上的著名難題，至今沒有有效的方法予以解決，因此可以確保RSA演算法的安全性。RSA系統是公鑰系統的最具有典型意義的方法，大多數使用公鑰密碼進行加密和數字簽名的產品和標准使用的都是RSA演算法。
RSA演算法是第一個既能用於數據加密也能用於數字簽名的演算法，因此它為公用網路上信息的加密和鑒別提供了一種基本的方法。它通常是先生成一對RSA密鑰，其中之一是保密密鑰，由用戶保存；另一個為公開密鑰，可對外公開，甚至可在網路伺服器中注冊，人們用公鑰加密文件發送給個人，個人就可以用私鑰解密接受。為提高保密強度，RSA密鑰至少為500位長，一般推薦使用1024位。
該演算法基於下面的兩個事實,這些事實保證了RSA演算法的安全有效性：
1)已有確定一個數是不是質數的快速演算法；
2)尚未找到確定一個合數的質因子的快速演算法。
3.2工作原理
1)任意選取兩個不同的大質數p和q，計算乘積r=p*q；
2)任意選取一個大整數e，e與(p-1)*(q-1)互質，整數e用做加密密鑰。注意：e的選取是很容易的，例如，所有大於p和q的質數都可用。
3)確定解密密鑰d：d * e = 1 molo（p - 1）*（q - 1） 根據e、p和q可以容易地計算出d。
4)公開整數r和e，但是不公開d；
5)將明文P (假設P是一個小於r的整數)加密為密文C，計算方法為：
C = Pe molo r
6)將密文C解密為明文P，計算方法為：
P = Cd molo r
然而只根據r和e（不是p和q）要計算出d是不可能的。因此，任何人都可對明文進行加密，但只有授權用戶（知道d）才可對密文解密。
3.3簡單實例
為了說明該演算法的工作過程,我們下面給出一個簡單例子,顯然我們在這只能取很小的數字，但是如上所述，為了保證安全，在實際應用上我們所用的數字要大的多得多。
例：選取p=3, q=5，則r=15，（p-1）*（q-1）=8。選取e=11（大於p和q的質數），通過d * 11 = 1 molo 8，計算出d =3。
假定明文為整數13。則密文C為
C = Pe molo r
= 1311 molo 15
= 1,792,160,394,037 molo 15
= 7
復原明文P為：
P = Cd molo r
= 73 molo 15
= 343 molo 15
= 13
因為e和d互逆，公開密鑰加密方法也允許採用這樣的方式對加密信息進行"簽名"，以便接收方能確定簽名不是偽造的。
假設A和B希望通過公開密鑰加密方法進行數據傳輸，A和B分別公開加密演算法和相應的密鑰，但不公開解密演算法和相應的密鑰。A和B的加密演算法分別是ECA和ECB，解密演算法分別是DCA和DCB，ECA和DCA互逆，ECB和DCB互逆。 若A要向B發送明文P，不是簡單地發送ECB（P），而是先對P施以其解密演算法DCA，再用加密演算法ECB對結果加密後發送出去。
密文C為：
C = ECB（DCA（P））
B收到C後，先後施以其解密演算法DCB和加密演算法ECA，得到明文P：
ECA（DCB（C））
= ECA（DCB（ECB（DCA（P））））
= ECA（DCA（P））/*DCB和ECB相互抵消*/
=
P /*DCB和ECB相互抵消*/
這樣B就確定報文確實是從A發出的，因為只有當加密過程利用了DCA演算法，用ECA才能獲得P，只有A才知道DCA演算法，沒 有人，即使是B也不能偽造A的簽名。
3.4優缺點
3.4.1優點
RSA演算法是第一個能同時用於加密和數字簽名的演算法，也易於理解和操作。RSA是被研究得最廣泛的公鑰演算法，從提出到現在已近二十年，經歷了各種攻擊的考驗，逐漸為人們接受，普遍認為是目前最優秀的公鑰方案之一。該演算法的加密密鑰和加密演算法分開，使得密鑰分配更為方便。它特別符合計算機網路環境。對於網上的大量用戶，可以將加密密鑰用電話簿的方式印出。如果某用戶想與另一用戶進行保密通信，只需從公鑰簿上查出對方的加密密鑰，用它對所傳送的信息加密發出即可。對方收到信息後，用僅為自己所知的解密密鑰將信息脫密，了解報文的內容。由此可看出，RSA演算法解決了大量網路用戶密鑰管理的難題，這是公鑰密碼系統相對於對稱密碼系統最突出的優點。
3.4.2缺點
1)產生密鑰很麻煩，受到素數產生技術的限制，因而難以做到一次一密。
2)安全性, RSA的安全性依賴於大數的因子分解，但並沒有從理論上證明破譯RSA的難度與大數分解難度等價，而且密碼學界多數人士傾向於因子分解不是NPC問題。目前，人們已能分解140多個十進制位的大素數，這就要求使用更長的密鑰，速度更慢；另外，目前人們正在積極尋找攻擊RSA的方法，如選擇密文攻擊，一般攻擊者是將某一信息作一下偽裝(Blind)，讓擁有私鑰的實體簽署。然後，經過計算就可得到它所想要的信息。實際上，攻擊利用的都是同一個弱點，即存在這樣一個事實：乘冪保留了輸入的乘法結構：
( XM )d = Xd *Md mod n
前面已經提到，這個固有的問題來自於公鑰密碼系統的最有用的特徵--每個人都能使用公鑰。但從演算法上無法解決這一問題，主要措施有兩條：一條是採用好的公鑰協議，保證工作過程中實體不對其他實體任意產生的信息解密，不對自己一無所知的信息簽名；另一條是決不對陌生人送來的隨機文檔簽名，簽名時首先使用One-Way Hash Function對文檔作HASH處理，或同時使用不同的簽名演算法。除了利用公共模數，人們還嘗試一些利用解密指數或φ（n）等等攻擊.
3)速度太慢,由於RSA的分組長度太大，為保證安全性，n至少也要600 bitx以上，使運算代價很高，尤其是速度較慢，較對稱密碼演算法慢幾個數量級；且隨著大數分解技術的發展，這個長度還在增加，不利於數據格式的標准化。目前，SET(Secure Electronic Transaction)協議中要求CA採用2048比特長的密鑰，其他實體使用1024比特的密鑰。為了速度問題,目前人們廣泛使用單,公鑰密碼結合使用的方法,優缺點互補:單鑰密碼加密速度快,人們用它來加密較長的文件,然後用RSA來給文件密鑰加密,極好的解決了單鑰密碼的密鑰分發問題。
§4結束語
目前，日益激增的電子商務和其它網際網路應用需求使公鑰體系得以普及，這些需求量主要包括對伺服器資源的訪問控制和對電子商務交易的保護，以及權利保護、個人隱私、無線交易和內容完整性（如保證新聞報道或股票行情的真實性）等方面。公鑰技術發展到今天，在市場上明顯的發展趨勢就是PKI與操作系統的集成，PKI是「Public
Key Infrastructure」的縮寫，意為「公鑰基礎設施」。公鑰體制廣泛地用於CA認證、數字簽名和密鑰交換等領域。
公鑰加密演算法中使用最廣的是RSA。RSA演算法研製的最初理念與目標是努力使互聯網安全可靠，旨在解決DES演算法秘密密鑰的利用公開信道傳輸分發的難題。而實際結果不但很好地解決了這個難題；還可利用RSA來完成對電文的數字簽名以抗對電文的否認與抵賴；同時還可以利用數字簽名較容易地發現攻擊者對電文的非法篡改，以保護數據信息的完整性。目前為止，很多種加密技術採用了RSA演算法，該演算法也已經在互聯網的許多方面得以廣泛應用，包括在安全介面層（SSL）標准（該標準是網路瀏覽器建立安全的互聯網連接時必須用到的）方面的應用。此外，RSA加密系統還可應用於智能IC卡和網路安全產品。
但目前RSA演算法的專利期限即將結束，取而代之的是基於橢圓曲線的密碼方案（ECC演算法）。較之於RSA演算法，ECC有其相對優點，這使得ECC的特性更適合當今電子商務需要快速反應的發展潮流。此外，一種全新的量子密碼也正在發展中。
至於在實際應用中應該採用何種加密演算法則要結合具體應用環境和系統，不能簡單地根據其加密強度來做出判斷。因為除了加密演算法本身之外，密鑰合理分配、加密效率與現有系統的結合性以及投入產出分析都應在實際環境中具體考慮。加密技術隨著網路的發展更新，將有更安全更易於實現的演算法不斷產生，為信息安全提供更有力的保障。今後，加密技術會何去何從，我們將拭目以待。
參考文獻：
[1] Douglas R.Stinson.《密碼學原理與實踐》.北京:電子工業出版社,2003,2:131-132
[2]西蒙.辛格.《密碼故事》.海口:海南出版社,2001,1:271-272
[3]嬴政天下.加密演算法之RSA演算法.http://soft.winzheng.com/infoView/Article_296.htm，2003
[4]加密與數字簽名.http://www.njt.cn/yumdq/dzsw/a2.htm
[5]黑客中級教程系列之十.http://www.qqorg.i-p.com/jiaocheng/10.html
Ⅶ Java 第三方公鑰 RSA加密求助
下面是RSA加譽春密代碼。
/**
* RSA演算法，實現數據的加密解密。
* @author ShaoJiang
*
*/
public class RSAUtil {
private static Cipher cipher;
static{
try {
cipher = Cipher.getInstance("RSA");
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
}
}
/**
* 生成密鑰對
* @param filePath 生成密鑰做含的路徑
* @return
*/
public static Map<String,String> generateKeyPair(String filePath){
try {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
// 密鑰位數
keyPairGen.initialize(1024);
// 密鑰對
KeyPair keyPair = keyPairGen.generateKeyPair();
// 公鑰
PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
// 私鑰
PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
//得到公鑰字元串
String publicKeyString = getKeyString(publicKey);
//得到私鑰字元串
String privateKeyString = getKeyString(privateKey);
FileWriter pubfw = new FileWriter(filePath+"/publicKey.keystore"純虛笑);
FileWriter prifw = new FileWriter(filePath+"/privateKey.keystore");
BufferedWriter pubbw = new BufferedWriter(pubfw);
BufferedWriter pribw = new BufferedWriter(prifw);
pubbw.write(publicKeyString);
pribw.write(privateKeyString);
pubbw.flush();
pubbw.close();
pubfw.close();
pribw.flush();
pribw.close();
prifw.close();
//將生成的密鑰對返回
Map<String,String> map = new HashMap<String,String>();
map.put("publicKey",publicKeyString);
map.put("privateKey",privateKeyString);
return map;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 得到公鑰
*
* @param key
* 密鑰字元串（經過base64編碼）
* @throws Exception
*/
public static PublicKey getPublicKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}
/**
* 得到私鑰
*
* @param key
* 密鑰字元串（經過base64編碼）
* @throws Exception
*/
public static PrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
/**
* 得到密鑰字元串（經過base64編碼）
*
* @return
*/
public static String getKeyString(Key key) throws Exception {
byte[] keyBytes = key.getEncoded();
String s = (new BASE64Encoder()).encode(keyBytes);
return s;
}
/**
* 使用公鑰對明文進行加密，返回BASE64編碼的字元串
* @param publicKey
* @param plainText
* @return
*/
public static String encrypt(PublicKey publicKey,String plainText){
try {
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
byte[] enBytes = cipher.doFinal(plainText.getBytes());
return (new BASE64Encoder()).encode(enBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
/**
* 使用keystore對明文進行加密
* @param publicKeystore 公鑰文件路徑
* @param plainText 明文
* @return
*/
public static String encrypt(String publicKeystore,String plainText){
try {
FileReader fr = new FileReader(publicKeystore);
BufferedReader br = new BufferedReader(fr);
String publicKeyString="";
String str;
while((str=br.readLine())!=null){
publicKeyString+=str;
}
br.close();
fr.close();
cipher.init(Cipher.ENCRYPT_MODE,getPublicKey(publicKeyString));
byte[] enBytes = cipher.doFinal(plainText.getBytes());
return (new BASE64Encoder()).encode(enBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 使用私鑰對明文密文進行解密
* @param privateKey
* @param enStr
* @return
*/
public static String decrypt(PrivateKey privateKey,String enStr){
try {
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
return new String(deBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 使用keystore對密文進行解密
* @param privateKeystore 私鑰路徑
* @param enStr 密文
* @return
*/
public static String decrypt(String privateKeystore,String enStr){
try {
FileReader fr = new FileReader(privateKeystore);
BufferedReader br = new BufferedReader(fr);
String privateKeyString="";
String str;
while((str=br.readLine())!=null){
privateKeyString+=str;
}
br.close();
fr.close();
cipher.init(Cipher.DECRYPT_MODE, getPrivateKey(privateKeyString));
byte[] deBytes = cipher.doFinal((new BASE64Decoder()).decodeBuffer(enStr));
return new String(deBytes);
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
Ⅷ 計算機網路中公鑰加密技術如何實現RSA演算法的
模數n=p*q，密文c=m^e
mod
n=25
phi(n)=(p-1)*(q-1),e*d
mod
phi(n)=1，簡單方法試一下就能求出d=37，正規方法用擴展歐幾里德演算法求e的模逆d。