第詳解RSA加密算法的原理與Java實(shí)現(xiàn)目錄對(duì)稱加密和非對(duì)稱加密RSA加密是什么RSA的加密過(guò)程前幾天阿粉剛剛說(shuō)了這個(gè)MD5加密的前世今生，因?yàn)镸D5也確實(shí)用的人不是很多了，阿粉就不再繼續(xù)的一一贅述了，今天阿粉想給大家分享的，是非對(duì)稱加密中的一種，那就是RSA加密算法。

對(duì)稱加密和非對(duì)稱加密

在說(shuō)RSA之前，我們得先來(lái)說(shuō)說(shuō)這個(gè)什么事對(duì)稱加密，什么又是非對(duì)稱加密？

對(duì)稱加密指的就是加密和解密使用同一個(gè)秘鑰，所以叫對(duì)稱加密。對(duì)稱加密只有一個(gè)秘鑰，作為私鑰。

非對(duì)稱加密指的是：加密和解密使用不同的秘鑰，一把作為公開(kāi)的公鑰，另一把作為私鑰。公鑰加密的信息，只有私鑰才能解密。

那么對(duì)稱加密和非對(duì)稱加密之間又有什么區(qū)別呢？

對(duì)稱加密中加密和解密使用的秘鑰是同一個(gè)；非對(duì)稱加密中采用兩個(gè)密鑰，一般使用公鑰進(jìn)行加密，私鑰進(jìn)行解密。對(duì)稱加密解密的速度比較快，非對(duì)稱加密和解密花費(fèi)的時(shí)間長(zhǎng)、速度相對(duì)較慢。對(duì)稱加密的安全性相對(duì)較低，非對(duì)稱加密的安全性較高。

今天我們來(lái)講的就是非對(duì)稱加密中的RSA加密。

RSA加密是什么

RSA加密是一種非對(duì)稱加密。可以在不直接傳遞密鑰的情況下，完成解密。這能夠確保信息的安全性，避免了直接傳遞密鑰所造成的被破解的風(fēng)險(xiǎn)。是由一對(duì)密鑰來(lái)進(jìn)行加解密的過(guò)程，分別稱為公鑰和私鑰。

通常情況下個(gè)人保存私鑰，公鑰是公開(kāi)的（可能同時(shí)多人持有）。

雖然私鑰是根據(jù)公鑰決定的，但是，我們是沒(méi)有辦法根據(jù)公鑰來(lái)推算出私鑰來(lái)的。

為提高保密強(qiáng)度，RSA密鑰至少為500位長(zhǎng)。這就使加密的計(jì)算量很大。為減少計(jì)算量，在傳送信息時(shí)，常采用傳統(tǒng)加密方法與公開(kāi)密鑰加密方法相結(jié)合的方式，即信息采用改進(jìn)的DES或IDEA對(duì)話密鑰加密，然后使用RSA密鑰加密對(duì)話密鑰和信息摘要。對(duì)方收到信息后，用不同的密鑰解密并可核對(duì)信息摘要

RSA的加密過(guò)程

RSA的加密過(guò)程其實(shí)并不復(fù)雜，

（1）A生成一對(duì)密鑰（公鑰和私鑰），私鑰不公開(kāi)，A自己保留。公鑰為公開(kāi)的，任何人可以獲取。

（2）A傳遞自己的公鑰給B，B用A的公鑰對(duì)消息進(jìn)行加密。

（3）A接收到B加密的消息，利用A自己的私鑰對(duì)消息進(jìn)行解密。

在這個(gè)過(guò)程中，只有2次傳遞過(guò)程，第一次是A傳遞公鑰給B，第二次是B傳遞加密消息給A，即使都被其他人截獲，也沒(méi)有危險(xiǎn)性，因?yàn)橹挥蠥的私鑰才能對(duì)消息進(jìn)行解密，防止了消息內(nèi)容的泄露。

但是大家有沒(méi)有想過(guò)，如果我們的消息被截獲了，雖然沒(méi)有被解密出來(lái)，但是如果說(shuō)我們的公鑰被攔截，然后將假指令進(jìn)行加密，然后傳遞給A，這不就涼涼了？那數(shù)據(jù)是不是就不能稱之為安全了？

不，RSA還有簽名的過(guò)程。

簽名過(guò)程如下：

（1）A生成一對(duì)密鑰（公鑰和私鑰），私鑰不公開(kāi)，A自己保留。公鑰為公開(kāi)的，任何人可以獲取。

（2）A用自己的私鑰對(duì)消息加簽，形成簽名，并將加簽的消息和消息本身一起傳遞給B。

（3）B收到消息后，在獲取A的公鑰進(jìn)行驗(yàn)簽，如果驗(yàn)簽出來(lái)的內(nèi)容與消息本身一致，證明消息是A回復(fù)的。

但是問(wèn)題又來(lái)了，雖然截獲的消息不能被篡改，但是消息的內(nèi)容可以利用公鑰驗(yàn)簽來(lái)獲得，并不能防止泄露。

那么應(yīng)該怎么用呢？

其實(shí)這就顯的并不是很好理解了我們是不是可以這么設(shè)計(jì)：

A和B都有一套自己的公鑰和私鑰，當(dāng)A要給B發(fā)送消息時(shí)，先用B的公鑰對(duì)消息加密，再對(duì)加密的消息使用A的私鑰加簽名，達(dá)到既不泄露也不被篡改，更能保證消息的安全性。

那么Java代碼怎么實(shí)現(xiàn)RSA的呢？代碼如下：

import

java.io.ByteArrayOutputStream;

import

java.security.KeyFactory;

import

java.security.KeyPair;

import

java.security.KeyPairGenerator;

import

java.security.PrivateKey;

import

java.security.PublicKey;

import

java.security.Signature;

import

java.security.spec.PKCS8EncodedKeySpec;

import

java.security.spec.X509EncodedKeySpec;

import

javax.crypto.Cipher;

import

mons.codec.binary.Base64;

public

class

TestRSA

{

/**

*

RSA最大加密明文大小

*/

private

static

final

int

MAX_ENCRYPT_BLOCK

=

117;

/**

*

RSA最大解密密文大小

*/

private

static

final

int

MAX_DECRYPT_BLOCK

=

128;

/**

*

獲取密鑰對(duì)

*

*

@return

密鑰對(duì)

*/

public

static

KeyPair

getKeyPair()

throws

Exception

{

KeyPairGenerator

generator

=

KeyPairGenerator.getInstance("RSA");

generator.initialize(1024);

return

generator.generateKeyPair();

}

/**

*

獲取私鑰

*

*

@param

privateKey

私鑰字符串

*

@return

*/

public

static

PrivateKey

getPrivateKey(String

privateKey)

throws

Exception

{

KeyFactory

keyFactory

=

KeyFactory.getInstance("RSA");

byte[]

decodedKey

=

Base64.decodeBase64(privateKey.getBytes());

PKCS8EncodedKeySpec

keySpec

=

new

PKCS8EncodedKeySpec(decodedKey);

return

keyFactory.generatePrivate(keySpec);

}

/**

*

獲取公鑰

*

*

@param

publicKey

公鑰字符串

*

@return

*/

public

static

PublicKey

getPublicKey(String

publicKey)

throws

Exception

{

KeyFactory

keyFactory

=

KeyFactory.getInstance("RSA");

byte[]

decodedKey

=

Base64.decodeBase64(publicKey.getBytes());

X509EncodedKeySpec

keySpec

=

new

X509EncodedKeySpec(decodedKey);

return

keyFactory.generatePublic(keySpec);

}

/**

*

RSA加密

*

*

@param

data

待加密數(shù)據(jù)

*

@param

publicKey

公鑰

*

@return

*/

public

static

String

encrypt(String

data,

PublicKey

publicKey)

throws

Exception

{

Cipher

cipher

=

Cipher.getInstance("RSA");

cipher.init(Cipher.ENCRYPT_MODE,

publicKey);

int

inputLen

=

data.getBytes().length;

ByteArrayOutputStream

out

=

new

ByteArrayOutputStream();

int

offset

=

0;

byte[]

cache;

int

i

=

0;

//

對(duì)數(shù)據(jù)分段加密

while

(inputLen

-

offset

0)

{

if

(inputLen

-

offset

MAX_ENCRYPT_BLOCK)

{

cache

=

cipher.doFinal(data.getBytes(),

offset,

MAX_ENCRYPT_BLOCK);

}

else

{

cache

=

cipher.doFinal(data.getBytes(),

offset,

inputLen

-

offset);

}

out.write(cache,

0,

cache.length);

i++;

offset

=

i

*

MAX_ENCRYPT_BLOCK;

}

byte[]

encryptedData

=

out.toByteArray();

out.close();

//

獲取加密內(nèi)容使用base64進(jìn)行編碼,并以UTF-8為標(biāo)準(zhǔn)轉(zhuǎn)化成字符串

//

加密后的字符串

return

new

String(Base64.encodeBase64String(encryptedData));

}

/**

*

RSA解密

*

*

@param

data

待解密數(shù)據(jù)

*

@param

privateKey

私鑰

*

@return

*/

public

static

String

decrypt(String

data,

PrivateKey

privateKey)

throws

Exception

{

Cipher

cipher

=

Cipher.getInstance("RSA");

cipher.init(Cipher.DECRYPT_MODE,

privateKey);

byte[]

dataBytes

=

Base64.decodeBase64(data);

int

inputLen

=

dataBytes.length;

ByteArrayOutputStream

out

=

new

ByteArrayOutputStream();

int

offset

=

0;

byte[]

cache;

int

i

=

0;

//

對(duì)數(shù)據(jù)分段解密

while

(inputLen

-

offset

0)

{

if

(inputLen

-

offset

MAX_DECRYPT_BLOCK)

{

cache

=

cipher.doFinal(dataBytes,

offset,

MAX_DECRYPT_BLOCK);

}

else

{

cache

=

cipher.doFinal(dataBytes,

offset,

inputLen

-

offset);

}

out.write(cache,

0,

cache.length);

i++;

offset

=

i

*

MAX_DECRYPT_BLOCK;

}

byte[]

decryptedData

=

out.toByteArray();

out.close();

//

解密后的內(nèi)容

return

new

String(decryptedData,

"UTF-8");

}

/**

*

簽名

*

*

@param

data

待簽名數(shù)據(jù)

*

@param

privateKey

私鑰

*

@return

簽名

*/

public

static

String

sign(String

data,

PrivateKey

privateKey)

throws

Exception

{

byte[]

keyBytes

=

privateKey.getEncoded();

PKCS8EncodedKeySpec

keySpec

=

new

PKCS8EncodedKeySpec(keyBytes);

KeyFactory

keyFactory

=

KeyFactory.getInstance("RSA");

PrivateKey

key

=

keyFactory.generatePrivate(keySpec);

Signature

signature

=

Signature.getInstance("MD5withRSA");

signature.initSign(key);

signature.update(data.getBytes());

return

new

String(Base64.encodeBase64(signature.sign()));

}

/**

*

驗(yàn)簽

*

*

@param

srcData

原始字符串

*

@param

publicKey

公鑰

*

@param

sign

簽名

*

@return

是否驗(yàn)簽通過(guò)

*/

public

static

boolean

verify(String

srcData,

PublicKey

publicKey,

String

sign)

throws

Exception

{

byte[]

keyBytes

=

publicKey.getEncoded();

X509EncodedKeySpec

keySpec

=

new

X509EncodedKeySpec(keyBytes);

KeyFactory

keyFactory

=

KeyFactory.getInstance("RSA");

PublicKey

key

=

keyFactory.generatePublic(keySpec);

Signature

signature

=

Signature.getInstance("MD5withRSA");

signature.initVerify(key);

signature.update(srcData.getBytes());

return

signature.verify(Base64.decodeBase64(sign.getBytes()));

}

public

static

void

main(String[]

args)

{

try

{

//

生成密鑰對(duì)

KeyPair

keyPair

=

getKeyPair();

String

privateKey

=

new

String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));

String

publicKey

=

new

String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));

System.out.println("私鑰:"

+

privateKey);

System.out.println("公鑰:"

+

publicKey);

//

RSA加密

String

data

=

"待加密的文字內(nèi)容";

String

encryptData

=

encrypt(data,

getPublicKey(publicKey));

System.out.println("加密后內(nèi)容:"

+

encryptData);

//

RSA解密

String

decryptData

=

decrypt(encryptData,

getPrivateKey(privateKey));

System.out.println("解密后內(nèi)容:"

+

decryptData);

//

RSA簽名

String

sign

=

sign(data,

getPrivateKey(privateKey));

//

RSA驗(yàn)簽

boolean

result

=

verify