java非對稱加密演算法

『壹』 非對稱加密演算法

非對稱加密演算法是一種密鑰的保密方法。

非對稱加密演算法需要兩個密鑰:公開密鑰(publickey:簡稱公鑰)和私有密鑰(privatekey:簡稱私鑰)。公鑰與私鑰是一對，如果用公鑰對數據進行加密，只有用對應的私鑰才能解密。因為加密和解密使用的是兩個不同的密鑰，所以這種演算法叫作非對稱加密演算法。

非對稱加密演算法實現機密信息交換的基本過程是:甲方生成一對密鑰並將公鑰公開，需要向甲方發送信息的其他角色(乙方)使用該密鑰(甲方的公鑰)對機密信息進行加密後再發送給甲方;甲方再用自己私鑰對加密後的信息進行解密。甲方想要回復乙方時正好相反，使用乙方的公鑰對數據進行加密，同理，乙方使用自己的私鑰來進行解密。

另一方面，甲方可以使用自己的私鑰對機密信息進行簽名後再發送給乙方;乙方再用甲方的公鑰對甲方發送回來的數據進行驗簽。

甲方只能用其私鑰解密由其公鑰加密後的任何信息。 非對稱加密演算法的保密性比較好，它消除了最終用戶交換密鑰的需要。

非對稱密碼體制的特點:演算法強度復雜、安全性依賴於演算法與密鑰但是由於其演算法復雜，而使得加密解密速度沒有對稱加密解密的速度快。對稱密碼體制中只有一種密鑰，並且是非公開的，如果要解密就得讓對方知道密鑰。

所以保證其安全性就是保證密鑰的安全，而非對稱密鑰體制有兩種密鑰，其中一個是公開的，這樣就可以不需要像對稱密碼那樣傳輸對方的密鑰了。這樣安全性就大了很多。

『貳』 使用非對稱加密及解密的過程詳解

前面我們知道對稱加密是對一份文件進行加密，且對應的只有一個密碼？例如：A有一份文件，她使用對稱加密演算法加密後希望發給B，那麼密碼肯定也要一起交給B！這中間就會出現安全隱患，如果密碼被第三方L嗅探到並截取，那麼加密的文件就赤裸裸的出現在L的面前。

如果A有很多文件需要加密並發送給很多人！那麼就會生成很多的密鑰，這么多的密鑰保管就成了一個很棘手的問題，況且還要把密鑰發給不同的人！這無疑增添了很多的風險！

如何能改善這種安全性不高的加密演算法，數學家們發現了另一種加密方式。稱之為《非對稱加密》asymmetric encryption。非對稱加密演算法需要兩個密鑰【公開密鑰】（publickey）和【私有密鑰】（privatekey）。下面簡稱【公匙】、【私匙】

【公鑰】與【私鑰】是一對，如果使用公開密匙對數據進行加密，那麼只有對應的私有密匙才能解密；相反，如果使用私有密匙對數據進行加密，那麼只有對應的公開密匙進行解密。因加密解密使用的是兩種不同的密匙，所以這種演算法稱之為【非對稱加密演算法】。

在使用非對稱加密前，A和B先各自生成一對公匙和私匙，然後把各自的公匙交給對方，並把自己的私匙妥善保管！如圖所示：

在A給B發送信息之前，首先使用B發給A的公匙對信息進行加密處理，然後發送給B，B在收到密文之後，使用自己的私匙解密；B在給A回復信息時，先使用A發來的公匙對回復信息加密，然後發出，A收到密文後使用自己的私匙解密即可！如圖所示：

『叄』 java中RSA的方式如何實現非對稱加密的示例

代碼如下，需要依賴一個jar包commons-codec-1.9.jar，用於Base64轉換，請自行下載。

importorg.apache.commons.codec.binary.Base64;

importjavax.crypto.BadPaddingException;
importjavax.crypto.Cipher;
importjavax.crypto.IllegalBlockSizeException;
importjava.io.ByteArrayOutputStream;
importjava.io.UnsupportedEncodingException;
importjava.security.*;
importjava.security.interfaces.RSAPrivateKey;
importjava.security.interfaces.RSAPublicKey;
importjava.security.spec.PKCS8EncodedKeySpec;
importjava.security.spec.X509EncodedKeySpec;

publicclassRSAUtils{

//加密方式
="RSA";
//簽名演算法
_ALGORITHM="SHA1WithRSA";
//創建密鑰對初始長度
privatestaticfinalintKEY_SIZE=512;
//字元編碼格式
="UTF-8";
//RSA最大加密明文大小
privatestaticfinalintMAX_ENCRYPT_BLOCK=117;
//RSA最大解密密文大小
privatestaticfinalintMAX_DECRYPT_BLOCK=128;

privateKeyFactorykeyFactory;

publicRSAUtils(){
keyFactory=KeyFactory.getInstance(ALGORITHM);
}

/**
*私鑰加密
*
*@paramcontent待加密字元串
*@paramprivateKey私鑰
*@return加密後字元串（BASE64編碼）
*/
(Stringcontent,StringprivateKey)throwsException{
Stringresult;

try(ByteArrayOutputStreamout=newByteArrayOutputStream()){
byte[]keyBytes=newBase64().decode(privateKey);
=newPKCS8EncodedKeySpec(keyBytes);
PrivateKeypKey=keyFactory.generatePrivate(pkcs8KeySpec);
Ciphercipher=Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE,pKey);

byte[]data=content.getBytes(CHARSET);
write2Stream(cipher,data,out);
byte[]resultBytes=out.toByteArray();

result=Base64.encodeBase64String(resultBytes);
}catch(Exceptione){
thrownewException(e);
}

returnresult;
}

/**
*公鑰解密
*
*@paramcontent已加密字元串（BASE64加密）
*@parampublicKey公鑰
*@return
*/
(Stringcontent,StringpublicKey)throwsException{
Stringresult="";

try(ByteArrayOutputStreamout=newByteArrayOutputStream()){
byte[]keyBytes=newBase64().decode(publicKey);
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
PublicKeypKey=keyFactory.generatePublic(x509KeySpec);
Ciphercipher=Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE,pKey);

byte[]data=Base64.decodeBase64(content);
write2Stream(cipher,data,out);
byte[]resultBytes=out.toByteArray();

result=newString(resultBytes);
}catch(Exceptione){
thrownewException(e);
}

returnresult;
}

/**
*公鑰加密
*
*@paramcontent待加密字元串
*@parampublicKey公鑰
*@return加密後字元串（BASE64編碼）
*/
(Stringcontent,StringpublicKey)throwsException{
Stringresult="";

try(ByteArrayOutputStreamout=newByteArrayOutputStream()){
byte[]keyBytes=newBase64().decode(publicKey);
X509EncodedKeySpecx509KeySpec=newX509EncodedKeySpec(keyBytes);
PublicKeypKey=keyFactory.generatePublic(x509KeySpec);
Ciphercipher=Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE,pKey);

byte[]data=content.getBytes(CHARSET);
write2Stream(cipher,
data,out);
byte[]resultBytes=out.toByteArray();
result=Base64.encodeBase64String(resultBytes);
}catch(Exceptione){
thrownewException(e);
}

returnresult;
}

/**
*私鑰解密
*
*@paramcontent已加密字元串
*@paramprivateKey私鑰
*@return解密後字元串
*/
(Stringcontent,StringprivateKey)throwsException{
Stringresult="";

try(ByteArrayOutputStreamout=newByteArrayOutputStream()){
byte[]keyBytes=newBase64().decode(privateKey);
=newPKCS8EncodedKeySpec(keyBytes);
PrivateKeypKey=keyFactory.generatePrivate(pkcs8KeySpec);
Ciphercipher=Cipher.getInstance(ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE,pKey);

byte[]data=Base64.decodeBase64(content);
write2Stream(cipher,data,out);
byte[]resultBytes=out.toByteArray();
result=newString(resultBytes);
}catch(Exceptione){
thrownewException(e);
}

returnresult;
}

privatestaticvoidwrite2Stream(Ciphercipher,byte[]data,ByteArrayOutputStreamout)throws
BadPaddingException,IllegalBlockSizeException{
intdataLen=data.length;
intoffSet=0;
byte[]cache;
inti=0;
//對數據分段解密
while(dataLen-offSet>0){
if(dataLen-offSet>MAX_DECRYPT_BLOCK){
cache=cipher.doFinal(data,offSet,MAX_DECRYPT_BLOCK);
}else{
cache=cipher.doFinal(data,offSet,dataLen-offSet);
}
out.write(cache,0,cache.length);
i++;
offSet=i*MAX_DECRYPT_BLOCK;
}
}

/**
*用私鑰對信息生成數字簽名
*
*@paramdata已加密數據
*@paramprivateKey私鑰(BASE64編碼)
*@returnsign
*/
publicStringsign(Stringdata,StringprivateKey)throwsException{
Stringresult="";
try{
byte[]keyBytes=newBase64().decode(privateKey);
=newPKCS8EncodedKeySpec(keyBytes);
PrivateKeyprivateK=keyFactory.generatePrivate(pkcs8KeySpec);
Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(privateK);
signature.update(parse2HexStr(data).getBytes(CHARSET));

result=newBase64().encodeToString(signature.sign());
}catch(Exceptione){
thrownewException(e);
}
returnresult;
}

/**
*校驗數字簽名
*
*@paramdata已加密數據
*@parampublicKey公鑰(BASE64編碼)
*@paramsign數字簽名
*@return
*@throwsException
*/
publicbooleanverify(Stringdata,StringpublicKey,Stringsign)throwsException{
booleanresult;

try{
byte[]keyBytes=newBase64().decode(publicKey);
X509EncodedKeySpeckeySpec=newX509EncodedKeySpec(keyBytes);
PublicKeypublicK=keyFactory.generatePublic(keySpec);
Signaturesignature=Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(publicK);
signature.update(parse2HexStr(data).getBytes(CHARSET));
result=signature.verify(newBase64().decode(sign));
}catch(Exceptione){
thrownewException(e);
}
returnresult;
}

/**
*將二進制轉換成16進制
*
*@paramdata
*@return
*/
(Stringdata)throwsException{
Stringresult="";
try{
byte[]buf=data.getBytes(CHARSET);

StringBuffersb=newStringBuffer();
for(inti=0;i<buf.length;i++){
Stringhex=Integer.toHexString(buf[i]&0xFF);
if(hex.length()==1){
hex='0'+hex;
}
sb.append(hex.toUpperCase());
}
result=sb.toString();
}catch(UnsupportedEncodingExceptione){
thrownewException(e);
}
returnresult;
}

/**
*生成公鑰與私鑰
*/
publicstaticvoidcreateKey()throwsException{
try{
=KeyPairGenerator.getInstance(ALGORITHM);
keyPairGenerator.initialize(KEY_SIZE);
KeyPairkeyPair=keyPairGenerator.generateKeyPair();
RSAPublicKeyrsaPublicKey=(RSAPublicKey)keyPair.getPublic();
RSAPrivateKeyrsaPrivateKey=(RSAPrivateKey)keyPair.getPrivate();

StringpublicKey=Base64.encodeBase64String(rsaPublicKey.getEncoded());
StringprivateKey=Base64.encodeBase64String(rsaPrivateKey.getEncoded());

System.out.println("publicKey="+publicKey+"
privateKey="+privateKey);
}catch(NoSuchAlgorithmExceptione){
thrownewException(e);
}
}

publicstaticvoidmain(String[]args)throwsException{

StringPRIVATE_KEY="+m+/fNs1bmgfJhI8lhr/o/Hy8EFB/I/DDyLcCcU4bCLtxpki8edC+KJR2WvyYfnVmWEe//++W5C+lesEOAqdO5nahRZsL8BIDoxTEn2j+DSa///1qX+t8f5wD8i/8GU702PeCwkGI5ymrARq+/+/nkefTq0SNpUDVbGxVpJi9/FOUf";
StringPUBLIC_KEY="+lc///NfOvKvQndzDH60DzLGOMdE0NBrTn/5zEjGwJbVdlvCfOiHwIDAQAB";

RSAUtilsrsaUtil=newRSAUtils();
StringencryptByPublicKey=rsaUtil.encryptByPublicKey("你好！",PUBLIC_KEY);
System.out.println(encryptByPublicKey);
StringdecryptByPrivateKey=rsaUtil.decryptByPrivateKey(encryptByPublicKey,PRIVATE_KEY);
System.out.println(decryptByPrivateKey);
StringencryptByPrivateKey=rsaUtil.encryptByPrivateKey("你好！",PRIVATE_KEY);
System.out.println(encryptByPrivateKey);
StringdecryptByPublicKey=rsaUtil.decryptByPublicKey(encryptByPrivateKey,PUBLIC_KEY);
System.out.println(decryptByPublicKey);
Stringsign=rsaUtil.sign("1234",PRIVATE_KEY);
System.out.println("sign:"+sign);
System.out.println(rsaUtil.verify("1234",PUBLIC_KEY,sign));
}
}

『肆』 非對稱加密解密RSA的實現例子

最近有接觸到加密相關的內容，本期以非對稱加密為例子，做個簡單的總結和記錄。首先了解下非對稱加密，簡單來說非對稱指的是加密和解密用不同的秘鑰，典型的RSA，這個演算法名稱是基於三個發明人的名字首字母取的；辯含碧而對稱加密必須要在加解密使用相同的秘鑰攜舉，典型的AES。這里細節不多展開闡述，涉及到很多數學原理，如大數的質因數分解等，感興趣的可以找找李永樂等網上比較優秀的科普。這篇文章只是java原生實現的加解密例子。至於其他的如md5,hash等，如果從主觀可讀的角度來說，也可以稱為加密。

如下的示例是使用Java原生實現RSA的加密解密，包括用公鑰加密，然後私鑰解密；或者使用私鑰加密，然後公鑰解密。注意不同key大小，限制的解密內容大小也不一樣，感老備興趣的同學可以試試修改key大小和加密內容長度來試試。還有要注意的是RSA加密有一定的性能損耗。

想了解原理相關的內容可以看如下的參考內容。
[1]. RSA原理

『伍』 非對稱加密演算法 (RSA、DSA、ECC、DH)

非對稱加密需要兩個密鑰：公鑰(publickey) 和私鑰 (privatekey)。公鑰和私鑰是一對，如果用公鑰對數據加密，那麼只能用對應的私鑰解密。如果用私鑰對數據加密，只能用對應的公鑰進行解密。因為加密和解密用的是不同的密鑰，所以稱為非對稱加密。

非對稱加密演算法的保密性好，它消除了最終用戶交換密鑰的需要。但是加解密速度要遠遠慢於對稱加密，在某些極端情況下，甚至能比對稱加密慢上1000倍。

演算法強度復雜、安全性依賴於演算法與密鑰但是由於其演算法復雜，而使得加密解密速度沒有對稱加密解密的速度快。對稱密碼體制中只有一種密鑰，並且是非公開的，如果要解密就得讓對方知道密鑰。所以保證其安全性就是保證密鑰的安全，而非對稱密鑰體制有兩種密鑰，其中一個是公開的，這樣就可以不需要像對稱密碼那樣傳輸對方的密鑰了。這樣安全性就大了很多。

RSA、Elgamal、背包演算法、Rabin、D-H、ECC (橢圓曲線加密演算法)。使用最廣泛的是 RSA 演算法，Elgamal 是另一種常用的非對稱加密演算法。

收信者是唯一能夠解開加密信息的人，因此收信者手裡的必須是私鑰。發信者手裡的是公鑰，其它人知道公鑰沒有關系，因為其它人發來的信息對收信者沒有意義。

客戶端需要將認證標識傳送給伺服器，此認證標識 (可能是一個隨機數) 其它客戶端可以知道，因此需要用私鑰加密，客戶端保存的是私鑰。伺服器端保存的是公鑰，其它伺服器知道公鑰沒有關系，因為客戶端不需要登錄其它伺服器。

數字簽名是為了表明信息沒有受到偽造，確實是信息擁有者發出來的，附在信息原文的後面。就像手寫的簽名一樣，具有不可抵賴性和簡潔性。

簡潔性：對信息原文做哈希運算，得到消息摘要，信息越短加密的耗時越少。

不可抵賴性：信息擁有者要保證簽名的唯一性，必須是唯一能夠加密消息摘要的人，因此必須用私鑰加密 (就像字跡他人無法學會一樣)，得到簽名。如果用公鑰，那每個人都可以偽造簽名了。

問題起源：對1和3，發信者怎麼知道從網上獲取的公鑰就是真的？沒有遭受中間人攻擊？

這樣就需要第三方機構來保證公鑰的合法性，這個第三方機構就是 CA (Certificate Authority)，證書中心。

CA 用自己的私鑰對信息原文所有者發布的公鑰和相關信息進行加密，得出的內容就是數字證書。

信息原文的所有者以後發布信息時，除了帶上自己的簽名，還帶上數字證書，就可以保證信息不被篡改了。信息的接收者先用 CA給的公鑰解出信息所有者的公鑰，這樣可以保證信息所有者的公鑰是真正的公鑰，然後就能通過該公鑰證明數字簽名是否真實了。

RSA 是目前最有影響力的公鑰加密演算法，該演算法基於一個十分簡單的數論事實：將兩個大素數相乘十分容易，但想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作為加密密鑰，即公鑰，而兩個大素數組合成私鑰。公鑰是可發布的供任何人使用，私鑰則為自己所有，供解密之用。

A 要把信息發給 B 為例，確定角色：A 為加密者，B 為解密者。首先由 B 隨機確定一個 KEY，稱之為私鑰，將這個 KEY 始終保存在機器 B 中而不發出來；然後，由這個 KEY 計算出另一個 KEY，稱之為公鑰。這個公鑰的特性是幾乎不可能通過它自身計算出生成它的私鑰。接下來通過網路把這個公鑰傳給 A，A 收到公鑰後，利用公鑰對信息加密，並把密文通過網路發送到 B，最後 B 利用已知的私鑰，就能對密文進行解碼了。以上就是 RSA 演算法的工作流程。

由於進行的都是大數計算，使得 RSA 最快的情況也比 DES 慢上好幾倍，無論是軟體還是硬體實現。速度一直是 RSA 的缺陷。一般來說只用於少量數據加密。RSA 的速度是對應同樣安全級別的對稱密碼演算法的1/1000左右。

比起 DES 和其它對稱演算法來說，RSA 要慢得多。實際上一般使用一種對稱演算法來加密信息，然後用 RSA 來加密比較短的公鑰，然後將用 RSA 加密的公鑰和用對稱演算法加密的消息發送給接收方。

這樣一來對隨機數的要求就更高了，尤其對產生對稱密碼的要求非常高，否則的話可以越過 RSA 來直接攻擊對稱密碼。

和其它加密過程一樣，對 RSA 來說分配公鑰的過程是非常重要的。分配公鑰的過程必須能夠抵擋中間人攻擊。假設 A 交給 B 一個公鑰，並使 B 相信這是A 的公鑰，並且 C 可以截下 A 和 B 之間的信息傳遞，那麼 C 可以將自己的公鑰傳給 B，B 以為這是 A 的公鑰。C 可以將所有 B 傳遞給 A 的消息截下來，將這個消息用自己的密鑰解密，讀這個消息，然後將這個消息再用 A 的公鑰加密後傳給 A。理論上 A 和 B 都不會發現 C 在偷聽它們的消息，今天人們一般用數字認證來防止這樣的攻擊。

(1) 針對 RSA 最流行的攻擊一般是基於大數因數分解。1999年，RSA-155 (512 bits) 被成功分解，花了五個月時間（約8000 MIPS 年）和224 CPU hours 在一台有3.2G 中央內存的 Cray C916計算機上完成。

RSA-158 表示如下：

2009年12月12日，編號為 RSA-768 (768 bits, 232 digits) 數也被成功分解。這一事件威脅了現通行的1024-bit 密鑰的安全性，普遍認為用戶應盡快升級到2048-bit 或以上。

RSA-768表示如下：

(2) 秀爾演算法
量子計算里的秀爾演算法能使窮舉的效率大大的提高。由於 RSA 演算法是基於大數分解 (無法抵抗窮舉攻擊)，因此在未來量子計算能對 RSA 演算法構成較大的威脅。一個擁有 N 量子位的量子計算機，每次可進行2^N 次運算，理論上講，密鑰為1024位長的 RSA 演算法，用一台512量子比特位的量子計算機在1秒內即可破解。

DSA (Digital Signature Algorithm) 是 Schnorr 和 ElGamal 簽名演算法的變種，被美國 NIST 作為 DSS (DigitalSignature Standard)。 DSA 是基於整數有限域離散對數難題的。

簡單的說，這是一種更高級的驗證方式，用作數字簽名。不單單只有公鑰、私鑰，還有數字簽名。私鑰加密生成數字簽名，公鑰驗證數據及簽名，如果數據和簽名不匹配則認為驗證失敗。數字簽名的作用就是校驗數據在傳輸過程中不被修改，數字簽名，是單向加密的升級。

橢圓加密演算法（ECC）是一種公鑰加密演算法，最初由 Koblitz 和 Miller 兩人於1985年提出，其數學基礎是利用橢圓曲線上的有理點構成 Abel 加法群上橢圓離散對數的計算困難性。公鑰密碼體制根據其所依據的難題一般分為三類：大整數分解問題類、離散對數問題類、橢圓曲線類。有時也把橢圓曲線類歸為離散對數類。

ECC 的主要優勢是在某些情況下它比其他的方法使用更小的密鑰 (比如 RSA)，提供相當的或更高等級的安全。ECC 的另一個優勢是可以定義群之間的雙線性映射，基於 Weil 對或是 Tate 對；雙線性映射已經在密碼學中發現了大量的應用，例如基於身份的加密。不過一個缺點是加密和解密操作的實現比其他機制花費的時間長。

ECC 被廣泛認為是在給定密鑰長度的情況下，最強大的非對稱演算法，因此在對帶寬要求十分緊的連接中會十分有用。

比特幣錢包公鑰的生成使用了橢圓曲線演算法，通過橢圓曲線乘法可以從私鑰計算得到公鑰， 這是不可逆轉的過程。

https://github.com/esxgx/easy-ecc

Java 中 Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey 均不支持 ECC 演算法。

https://www.jianshu.com/p/58c1750c6f22

DH，全稱為"Diffie-Hellman"，它是一種確保共享 KEY 安全穿越不安全網路的方法，也就是常說的密鑰一致協議。由公開密鑰密碼體制的奠基人 Diffie 和 Hellman 所提出的一種思想。簡單的說就是允許兩名用戶在公開媒體上交換信息以生成"一致"的、可以共享的密鑰。也就是由甲方產出一對密鑰 (公鑰、私鑰)，乙方依照甲方公鑰產生乙方密鑰對 (公鑰、私鑰)。

以此為基線，作為數據傳輸保密基礎，同時雙方使用同一種對稱加密演算法構建本地密鑰 (SecretKey) 對數據加密。這樣，在互通了本地密鑰 (SecretKey) 演算法後，甲乙雙方公開自己的公鑰，使用對方的公鑰和剛才產生的私鑰加密數據，同時可以使用對方的公鑰和自己的私鑰對數據解密。不單單是甲乙雙方兩方，可以擴展為多方共享數據通訊，這樣就完成了網路交互數據的安全通訊。

具體例子可以移步到這篇文章： 非對稱密碼之DH密鑰交換演算法

參考：
https://blog.csdn.net/u014294681/article/details/86705999

https://www.cnblogs.com/wangzxblog/p/13667634.html

https://www.cnblogs.com/taoxw/p/15837729.html

https://www.cnblogs.com/fangfan/p/4086662.html

https://www.cnblogs.com/utank/p/7877761.html

https://blog.csdn.net/m0_59133441/article/details/122686815

https://www.cnblogs.com/muliu/p/10875633.html

https://www.cnblogs.com/wf-zhang/p/14923279.html

https://www.jianshu.com/p/7a927db713e4

https://blog.csdn.net/ljx1400052550/article/details/79587133

https://blog.csdn.net/yuanjian0814/article/details/109815473

『陸』 對稱加密演算法和非對稱加密演算法

常見的對稱加密演算法包括瑞士的國際數據加密演算法（International Data Encryption
Algorithm，IDEA）和美國的數據加密標准（Date Encryption Standard，DES）。
DES是一種迭代的分組密碼，明文和密文都是64位，使用一個56位的密鑰以及附加的8位奇偶校驗位。攻擊DES的主要技術是窮舉法，由於DES的密鑰長度較短，為了提高安全性，就出現了使用112位密鑰對數據進行三次加密的演算法（3DES），即用兩個56位的密鑰K1和K2，發送方用K1加密，K2解密，再使用K1加密；接收方則使用K1解密，K2加密，再使用K1解密，其效果相當於將密鑰長度加倍。
IDEA是在DES的基礎上發展起來的，類似於3DES。IDEA的明文和密文都是64位，密鑰長度為128位。

非對稱加密演算法也稱為公鑰加密演算法，是指加密密鑰和解密密鑰完全不同，其中一個為公鑰，另一個為私鑰，並且不可能從任何一個推導出另一個。它的優點在於可以適應開放性的使用環境，可以實現數字簽名與驗證。
最常見的非對稱加密演算法是RSA，該演算法的名字以發明者的名字命名：Ron Rivest，AdiShamir 和Leonard Adleman。RSA演算法的密鑰長度為512位。RSA演算法的保密性取決於數學上將一個大數分解為兩個素數的問題的難度，根據已有的數學方法，其計算量極大，破解很難。但是加密/解密時要進行大指數模運算，因此加密/解密速度很慢，主要用在數字簽名中。
用公鑰進行加密，用私鑰進行解密

『柒』 java非對稱加密的源代碼(RSA)

鑒於rsa加密的重要性和相關源代碼的匱乏 經過整理特此貼出 需要下載bcprov jdk jar import javax crypto Cipher;import java security *;import java security spec RSAPublicKeySpec;清納import java security spec RSAPrivateKeySpec;import java security spec InvalidKeySpecException;import java security interfaces RSAPrivateKey;import java security interfaces RSAPublicKey;import java io *;import java math BigInteger;/*** RSA 工具類 提供加密 解密 生成密鑰對等方法 * 需要到下載bcprov jdk jar **/public class RSAUtil {/*** 生成密鑰對* @return KeyPair* @throws EncryptException*/public static KeyPair generateKeyPair() throws EncryptException {try {槐碼KeyPairGenerator keyPairGen = KeyPairGenerator getInstance( RSA new bouncycastle jce provider BouncyCastleProvider());final int KEY_SIZE = ;//沒什麼好說的了 這個值關繫到塊加密的大小 可以更改 但是不要太大 否則效率會低keyPairGen initialize(KEY_SIZE new SecureRandom());KeyPair keyPair = keyPairGen genKeyPair();return keyPair;} catch (Exception e) {throw new EncryptException(e getMessage());}}/*** 生成公鑰* @param molus* @param publicExponent* @return RSAPublicKey* @throws EncryptException*/public static RSAPublicKey generateRSAPublicKey(byte[] molus byte[] publicExponent) throws EncryptException {KeyFactory keyFac = null;try {keyFac = KeyFactory getInstance( RSA new bouncycastle jce provider BouncyCastleProvider());} catch (NoSuchAlgorithmException ex) {throw new EncryptException(ex getMessage());}RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(molus) new BigInteger(publicExponent));try {return (RSAPublicKey) keyFac generatePublic(pubKeySpec);} catch (InvalidKeySpecException ex) {throw new EncryptException(ex getMessage());}}/*** 生成私鑰* @param molus鉛正哪* @param privateExponent* @return RSAPrivateKey* @throws EncryptException*/public static RSAPrivateKey generateRSAPrivateKey(byte[] molus byte[] privateExponent) throws EncryptException {KeyFactory keyFac = null;try {keyFac = KeyFactory getInstance( RSA new bouncycastle jce provider BouncyCastleProvider());} catch (NoSuchAlgorithmException ex) {throw new EncryptException(ex getMessage());}RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(molus) new BigInteger(privateExponent));try {return (RSAPrivateKey) keyFac generatePrivate(priKeySpec);} catch (InvalidKeySpecException ex) {throw new EncryptException(ex getMessage());}}/*** 加密* @param key 加密的密鑰* @param data 待加密的明文數據* @return 加密後的數據* @throws EncryptException*/public static byte[] encrypt(Key key byte[] data) throws EncryptException {try {Cipher cipher = Cipher getInstance( RSA new bouncycastle jce provider BouncyCastleProvider());cipher init(Cipher ENCRYPT_MODE key);int blockSize = cipher getBlockSize();//獲得加密塊大小 如 加密前數據為 個byte 而key_size= 加密塊大小為 byte 加密後為 個byte;因此共有 個加密塊 第一個 byte第二個為 個byteint outputSize = cipher getOutputSize(data length);//獲得加密塊加密後塊大小int leavedSize = data length % blockSize;int blocksSize = leavedSize != ? data length / blockSize + : data length / blockSize;byte[] raw = new byte[outputSize * blocksSize];int i = ;while (data length i * blockSize > ) {if (data length i * blockSize > blockSize)cipher doFinal(data i * blockSize blockSize raw i * outputSize);elsecipher doFinal(data i * blockSize data length i * blockSize raw i * outputSize);//這裡面doUpdate方法不可用 查看源代碼後發現每次doUpdate後並沒有什麼實際動作除了把byte[]放到ByteArrayOutputStream中 而最後doFinal的時候才將所有的byte[]進行加密 可是到了此時加密塊大小很可能已經超出了OutputSize所以只好用dofinal方法 i++;}return raw;} catch (Exception e) {throw new EncryptException(e getMessage());}}/*** 解密* @param key 解密的密鑰* @param raw 已經加密的數據* @return 解密後的明文* @throws EncryptException*/public static byte[] decrypt(Key key byte[] raw) throws EncryptException {try {Cipher cipher = Cipher getInstance( RSA new bouncycastle jce provider BouncyCastleProvider());cipher init(cipher DECRYPT_MODE key);int blockSize = cipher getBlockSize();ByteArrayOutputStream bout = new ByteArrayOutputStream( );int j = ;while (raw length j * blockSize > ) {bout write(cipher doFinal(raw j * blockSize blockSize));j++;}return bout toByteArray();} catch (Exception e) {throw new EncryptException(e getMessage());}}/**** @param args* @throws Exception*/public static void main(String[] args) throws Exception {File file = new File( l );FileInputStream in = new FileInputStream(file);ByteArrayOutputStream bout = new ByteArrayOutputStream();byte[] tmpbuf = new byte[ ];int count = ;while ((count = in read(tmpbuf)) != ) {bout write(tmpbuf count);tmpbuf = new byte[ ];}in close();byte[] Data = bout toByteArray();KeyPair keyPair = RSAUtil generateKeyPair();RSAPublicKey pubKey = (RSAPublicKey) keyPair getPublic();RSAPrivateKey priKey = (RSAPrivateKey) keyPair getPrivate();byte[] pubModBytes = pubKey getMolus() toByteArray();byte[] pubPubExpBytes = pubKey getPublicExponent() toByteArray();byte[] priModBytes = priKey getMolus() toByteArray();byte[] priPriExpBytes = priKey getPrivateExponent() toByteArray();RSAPublicKey recoveryPubKey = RSAUtil generateRSAPublicKey(pubModBytes pubPubExpBytes);RSAPrivateKey recoveryPriKey = RSAUtil generateRSAPrivateKey(priModBytes priPriExpBytes);byte[] raw = RSAUtil encrypt(priKey Data);file = new File( encrypt_result dat );OutputStream out = new FileOutputStream(file);out write(raw);out close();byte[] data = RSAUtil decrypt(recoveryPubKey raw);file = new File( l );out = new FileOutputStream(file);out write(data);out flush();out close();}}加密可以用公鑰 解密用私鑰 或者加密用私鑰 通常非對稱加密是非常消耗資源的 因此可以對大數據用對稱加密如 des（具體代碼可以看我以前發的貼子） 而對其對稱密鑰進行非對稱加密 這樣既保證了數據的安全 還能保證效率 lishixin/Article/program/Java/gj/201311/27391

『捌』 java加密的幾種方式

朋友你好，很高興為你作答。

首先，Java加密能夠應對的風險包括以下幾個：

1、核心技術竊取

2、核心業務破解

3、通信模塊破解

4、API介面暴露

本人正在使用幾維安全Java加密方式，很不錯，向你推薦，希望能夠幫助到你。

幾維安全Java2C針對DEX文件進行加密保護，將DEX文件中標記的Java代碼翻譯為C代碼，編譯成加固後的SO文件。默認情況只加密activity中的onCreate函數，如果開發者想加密其它類和方法，只需對相關類或函數添加標記代碼，在APK加密時會自動對標記的代碼進行加密處理。

與傳統的APP加固方案相比，不涉及到自定義修改DEX文件的載入方式，所以其兼容性非常好；其次Java函數被完全轉化為C函數，直接在Native層執行，不存在Java層解密執行的步驟，其性能和執行效率更優。

如果操作上有不明白的地方，可以聯系技術支持人員幫你完成Java加密。

希望以上解答能夠幫助到你。

『玖』 非對稱加密演算法包括哪些

以下是幾種常見的非對稱加密演算法：

1、RSA演算法：RSA演算法是最早被廣泛使用的非對稱加密演算法之一，它利用質數分解的困難性，通過生成公鑰和私鑰來實現加密和解密。

4、ElGamal演算法：ElGamal演算法是一種基於離散對兆豎數問題的加密演算法，它被廣泛應用於數字簽名和加密通信等領域。

這些演算法都是非對稱加密演算法的代表性演算法，它們在不同的場景下談族有著各自的優缺點，應根據實際需求選擇合適的族侍大演算法來進行數據加密和解密。

『拾』 非對稱加密技術是什麼

一般人們說的對稱加密就是使用同一個秘鑰對信息或數據進行加密或者解密。而非對稱加密演算法需要兩個密鑰：公開密鑰和私有密鑰。公開密鑰與私有密鑰是一對，如果用公開密鑰對數據進行加密，只有用對應的私有密鑰才能歷祥伏解密；如果用私有密鑰對數據進行加密，那麼只有用宴高對應的公開密鑰才能解密。因為加密和解密使用的是兩個不同的密鑰，所以這種演算法叫作非對肢攜稱加密演算法。