RSA是当前最流行的非对称加密方式，使用公钥加密使用密钥解密，如何妥善的保管密钥就成了关键。

动态生成密钥

工具类

package com.yitong.utils;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

import java.security.NoSuchAlgorithmException;

import java.security.PrivateKey;

import java.security.PublicKey;

import java.security.spec.PKCS8EncodedKeySpec;

import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

/**

* RSA工具类

*/

public class RSAUtil {

/**

* @description: 随机生成RSA密钥对(密钥默认长度为1024)

* @params:

* @return:

*/

public static KeyPair getRSAKeyPair() {

try {

KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");

kpg.initialize(1024);

return kpg.genKeyPair();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

return null;

}

/**

* @description: 随机生成RSA密钥对

* @params:

* @return:

*/

public static KeyPair getRSAKeyPair(int length) {

try {

KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");

kpg.initialize(length);

return kpg.genKeyPair();

} catch (NoSuchAlgorithmException e) {

e.printStackTrace();

}

return null;

}

/**

* @description: 用公钥加密

* @params:

* @return: String

*/

public static String encryptData(String data, PublicKey publicKey) {

try {

Cipher cipher = Cipher.getInstance("RSA");

cipher.init(Cipher.ENCRYPT_MODE, publicKey);

return HexUtil.encode(cipher.doFinal(data.getBytes()));

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* @description: 用私钥解密

* @params:

* @return: String

*/

public static String decryptData(String encryptedData, PrivateKey privateKey) {

try {

Cipher cipher = Cipher.getInstance("RSA");

cipher.init(Cipher.DECRYPT_MODE, privateKey);

return new String(cipher.doFinal(HexUtil.decode(encryptedData)));

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* @description: 字符串还原公钥

* @params:

* @return: PublicKey

*/

public static PublicKey getPublicKey(String key) {

try {

byte[] keyBytes;

keyBytes = Base64Util.decode(key);

X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

KeyFactory keyFactory = null;

keyFactory = KeyFactory.getInstance("RSA");

PublicKey publicKey = keyFactory.generatePublic(keySpec);

return publicKey;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* @description: 字符串还原公钥Base64

* @params:

* @return: String

*/

public static String getPublicKey(PublicKey publicKey) {

return Base64Util.encode(publicKey.getEncoded());

}

/**

* @description: 字符串还原私钥

* @params:

* @return: PrivateKey

*/

public static PrivateKey getPrivateKey(String key) {

try {

byte[] keyBytes;

keyBytes = Base64Util.decode(key);

PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

KeyFactory keyFactory = null;

keyFactory = KeyFactory.getInstance("RSA");

PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

return privateKey;

} catch (Exception e) {

e.printStackTrace();

}

return null;

}

/**

* @description: 字符串还原私钥Base64

* @params:

* @return: String

*/

public static String getPrivateKey(PrivateKey privateKey) {

return Base64Util.encode(privateKey.getEncoded());

}

}

使用

static String plainText = "123456789123456789";// 明文

static String cipherText;// 密文

static PublicKey publicKey;

static PrivateKey privateKey;

private static void RSAEncrypt() {

if (null == publicKey) {

KeyPair aKey = RSAUtil.getRSAKeyPair();

publicKey = aKey.getPublic();

privateKey = aKey.getPrivate();

String pString = RSAUtil.getPublicKey(publicKey);

String pString2 = RSAUtil.getPrivateKey(privateKey);

System.out.println("公钥：" + pString + "\n私钥:" + pString2);

}

for (int i = 0; i < 5; i++) {

cipherText = RSAUtil.encryptData(plainText, publicKey);

System.out.println("加密密文：" + cipherText);

try {

System.out.println("解密明文：" + RSAUtil.decryptData(cipherText, privateKey));

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

这个是动态生成一对密钥的用法，这里存在一个问题，自己生成的一对密钥别人不知道，除了自己任何人都没有办法解密，我们一般都是自己加密给别人解密，这样就得想办法把私钥传给别人，但存在泄露的风险。

利用证书和keystore方式加解密

这种方式是为了解决传递密钥存在泄露风险的问题，keystore拥有完整的一对密钥，既包含公钥也包含私钥，证书只包含公钥，只能利用证书进行加密。

利用keytool生成证书

以win系统为例，打开cmd，输入：

keytool -genkey -alias 你的证书别名 -keyalg 密钥算法 -keystore 证书库文件保存的位置和文件名 -keysize 密钥长度 -validity 证书有效期天数

示例：

keytool -genkey -alias mykey -keyalg RSA -keystore D:/mk.keystore -keysize 1024 -validity 36500

然后按照提示输入密钥库的相关信息：

输入密钥库口令:

再次输入新口令:

您的名字与姓氏是什么?

[Unknown]: zhang

您的组织单位名称是什么?

[Unknown]: pc

您的组织名称是什么?

[Unknown]: pc

您所在的城市或区域名称是什么?

[Unknown]: shanghai

您所在的省/市/自治区名称是什么?

[Unknown]: shanghai

该单位的双字母国家/地区代码是什么?

[Unknown]: 86

CN=zhang, OU=yitong, O=pc, L=shanghai, ST=shanghai, C=86是否正确?

[否]: 是

输入 的密钥口令

(如果和密钥库口令相同, 按回车):

再次输入新口令:

Warning:

JKS 密钥库使用专用格式。建议使用 "keytool -importkeystore -srckeystore D:/mk.keystore -destkeystore D:/mk.keystore -deststoretype pkcs12" 迁移到行业标准格式 PKCS12。

这样就在D盘根目录下生成一个密钥库，这个密钥库相当重要一定要妥善保管，接下来就需要生成证书了：

keytool -export -alias mykey -keystore D:/mk.keystore -file D:/mk.cer

这样就能再D盘根目录下看到证书文件了，我们可以根据需要在原有的密钥库添加新的密钥。

加解密

直接上代码：

static String plainText = "123456789123456789";// 明文

static String cipherText;// 密文

static PublicKey publicKey;

static PrivateKey privateKey;

static String certificatePath = "D:/mk.cer";

static String keystorePath = "D:/mk.keystore";

private static void CerEncrypt() throws Exception {

// 加密

CertificateFactory cff = CertificateFactory.getInstance("X.509");

InputStream in = new FileInputStream(certificatePath);

Certificate cf = cff.generateCertificate(in);

PublicKey pString = cf.getPublicKey(); // 得到证书文件携带的公钥

System.out.println("公钥：" + Base64Util.encode(pString.getEncoded()));

cipherText = RSAUtil.encryptData(plainText, pString);

System.out.println("加密密文：" + cipherText);

// 解密

FileInputStream inputStream = new FileInputStream(keystorePath);

KeyStore ks = KeyStore.getInstance("JKS");

ks.load(inputStream, "000000".toCharArray());

inputStream.close();

String alias = "mykey";

String pswd = "000000";

Certificate cert = ks.getCertificate(alias);

PublicKey publicKey = cert.getPublicKey();

PrivateKey privateKey = (PrivateKey) ks.getKey(alias, pswd.toCharArray());

System.out.println("私钥：" + RSAUtil.getPrivateKey(privateKey) + "\n公钥：" + RSAUtil.getPublicKey(publicKey));

System.out.println(RSAUtil.decryptData(cipherText, privateKey));

}

应用

当我们的报文需要RSA加密的时候就可以将证书放在客户端，keystore放在服务端，这样客户端发送的报文就能自行加密，在服务端利用keystone文件获取私钥进行解密。