详解RSA加密算法的原理与Java实现

第详解RSA加密算法的原理与Java实现目录对称加密和非对称加密RSA加密是什么RSA的加密过程前几天阿粉刚刚说了这个MD5加密的前世今生，因为MD5也确实用的人不是很多了，阿粉就不再继续的一一赘述了，今天阿粉想给大家分享的，是非对称加密中的一种，那就是RSA加密算法。

对称加密和非对称加密

在说RSA之前，我们得先来说说这个什么事对称加密，什么又是非对称加密？

对称加密指的就是加密和解密使用同一个秘钥，所以叫对称加密。对称加密只有一个秘钥，作为私钥。

非对称加密指的是：加密和解密使用不同的秘钥，一把作为公开的公钥，另一把作为私钥。公钥加密的信息，只有私钥才能解密。

那么对称加密和非对称加密之间又有什么区别呢？

对称加密中加密和解密使用的秘钥是同一个；非对称加密中采用两个密钥，一般使用公钥进行加密，私钥进行解密。对称加密解密的速度比较快，非对称加密和解密花费的时间长、速度相对较慢。对称加密的安全性相对较低，非对称加密的安全性较高。

今天我们来讲的就是非对称加密中的RSA加密。

RSA加密是什么

RSA加密是一种非对称加密。可以在不直接传递密钥的情况下，完成解密。这能够确保信息的安全性，避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程，分别称为公钥和私钥。

通常情况下个人保存私钥，公钥是公开的（可能同时多人持有）。

虽然私钥是根据公钥决定的，但是，我们是没有办法根据公钥来推算出私钥来的。

为提高保密强度，RSA密钥至少为500位长。这就使加密的计算量很大。为减少计算量，在传送信息时，常采用传统加密方法与公开密钥加密方法相结合的方式，即信息采用改进的DES或IDEA对话密钥加密，然后使用RSA密钥加密对话密钥和信息摘要。对方收到信息后，用不同的密钥解密并可核对信息摘要

RSA的加密过程

RSA的加密过程其实并不复杂，

（1）A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。

（2）A传递自己的公钥给B，B用A的公钥对消息进行加密。

（3）A接收到B加密的消息，利用A自己的私钥对消息进行解密。

在这个过程中，只有2次传递过程，第一次是A传递公钥给B，第二次是B传递加密消息给A，即使都被其他人截获，也没有危险性，因为只有A的私钥才能对消息进行解密，防止了消息内容的泄露。

但是大家有没有想过，如果我们的消息被截获了，虽然没有被解密出来，但是如果说我们的公钥被拦截，然后将假指令进行加密，然后传递给A，这不就凉凉了？那数据是不是就不能称之为安全了？

不，RSA还有签名的过程。

签名过程如下：

（1）A生成一对密钥（公钥和私钥），私钥不公开，A自己保留。公钥为公开的，任何人可以获取。

（2）A用自己的私钥对消息加签，形成签名，并将加签的消息和消息本身一起传递给B。

（3）B收到消息后，在获取A的公钥进行验签，如果验签出来的内容与消息本身一致，证明消息是A回复的。

但是问题又来了，虽然截获的消息不能被篡改，但是消息的内容可以利用公钥验签来获得，并不能防止泄露。

那么应该怎么用呢？

其实这就显的并不是很好理解了我们是不是可以这么设计：

A和B都有一套自己的公钥和私钥，当A要给B发送消息时，先用B的公钥对消息加密，再对加密的消息使用A的私钥加签名，达到既不泄露也不被篡改，更能保证消息的安全性。

那么Java代码怎么实现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;

/**

*

获取密钥对

*

*

@return

密钥对

*/

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

待加密数据

*

@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;

//

对数据分段加密

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();

//

获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串

//

加密后的字符串

return

new

String(Base64.encodeBase64String(encryptedData));

}

/**

*

RSA解密

*

*

@param

data

待解密数据

*

@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;

//

对数据分段解密

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();

//

解密后的内容

return

new

String(decryptedData,

"UTF-8");

}

/**

*

签名

*

*

@param

data

待签名数据

*

@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()));

}

/**

*

验签

*

*

@param

srcData

原始字符串

*

@param

publicKey

公钥

*

@param

sign

签名

*

@return

是否验签通过

*/

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

{

//

生成密钥对

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

=

"待加密的文字内容";

String

encryptData

=

encrypt(data,

getPublicKey(publicKey));

System.out.println("加密后内容:"

+

encryptData);

//

RSA解密

String

decryptData

=

decrypt(encryptData,

getPrivateKey(privateKey));

System.out.println("解密后内容:"

+

decryptData);

//

RSA签名

String

sign

=

sign(data,

getPrivateKey(privateKey));

//

RSA验签

boolean

result

=

verify