第一种情况：生成密钥对，并进行加解密测试。需要两个类Base64Utils及MyRSA，如下
package rsatest;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Base64;
/**
* Created by Administrator on 2017/1/13.
*/
public class Base64Utils {
/**
* 文件读取缓冲区大小
*/
private static final int CACHE_SIZE = 1024;
/**
* <p>
* BASE64字符串解码为二进制数据
* </p>
*
* @param base64
* @return
* @throws Exception
*/
public static byte[] decode(String base64) throws Exception {
Base64.getDecoder().decode(base64.getBytes());
return Base64.getDecoder().decode(base64.getBytes());
}
/**
* <p>
* 二进制数据编码为BASE64字符串
* </p>
*
* @param bytes
* @return
* @throws Exception
*/
public static String encode(byte[] bytes) throws Exception {
return new String(Base64.getEncoder().encode(bytes));
}
/**
* <p>
* 将文件编码为BASE64字符串
* </p>
* <p>
* 大文件慎用，可能会导致内存溢出
* </p>
*
* @param filePath 文件绝对路径
* @return
* @throws Exception
*/
public static String encodeFile(String filePath) throws Exception {
byte[] bytes = fileToByte(filePath);
return encode(bytes);
}
/**
* <p>
* BASE64字符串转回文件
* </p>
*
* @param filePath 文件绝对路径
* @param base64 编码字符串
* @throws Exception
*/
public static void decodeToFile(String filePath, String base64) throws Exception {
byte[] bytes = decode(base64);
byteArrayToFile(bytes, filePath);
}
/**
* <p>
* 文件转换为二进制数组
* </p>
*
* @param filePath 文件路径
* @return
* @throws Exception
*/
public static byte[] fileToByte(String filePath) throws Exception {
byte[] data = new byte[0];
File file = new File(filePath);
if (file.exists()) {
FileInputStream in = new FileInputStream(file);
ByteArrayOutputStream out = new ByteArrayOutputStream(2048);
byte[] cache = new byte[CACHE_SIZE];
int nRead = 0;
while ((nRead = in.read(cache)) != -1) {
out.write(cache, 0, nRead);
out.flush();
}
out.close();
in.close();
data = out.toByteArray();
}
return data;
}
/**
* <p>
* 二进制数据写文件
* </p>
*
* @param bytes 二进制数据
* @param filePath 文件生成目录
*/
public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {
InputStream in = new ByteArrayInputStream(bytes);
File destFile = new File(filePath);
if (!destFile.getParentFile().exists()) {
destFile.getParentFile().mkdirs();
}
destFile.createNewFile();
OutputStream out = new FileOutputStream(destFile);
byte[] cache = new byte[CACHE_SIZE];
int nRead = 0;
while ((nRead = in.read(cache)) != -1) {
out.write(cache, 0, nRead);
out.flush();
}
out.close();
in.close();
}
}
package rsatest;
import java.security.InvalidKeyException;
import java.security.Key;
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.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
public class MyRSA {
public static final String KEY_ALGORITHM = "RSA";
public static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";
public static final String PUBLIC_KEY = "publicKey";
public static final String PRIVATE_KEY = "privateKey";
/** RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024 */
public static final int KEY_SIZE = 2048;
public static final String PLAIN_TEXT = "你好，2017";
public static void main(String[] args) throws Exception {
//生成密钥对
Map<String, byte[]> keyMap = generateKeyBytes();
PublicKey publicKey = restorePublicKey(keyMap.get(PUBLIC_KEY));
PrivateKey privateKey = restorePrivateKey(keyMap.get(PRIVATE_KEY));
// 用公钥加密
byte[] encodedText = RSAEncode(publicKey, PLAIN_TEXT.getBytes());
System.out.println("加密结果: " + Base64Utils.encode(encodedText));
//用私钥解密
System.out.println("解密结果: " + RSADecode(privateKey, encodedText));
}
/**
* 生成密钥对。注意这里是生成密钥对KeyPair，再由密钥对获取公私钥
*
* @return
*/
public static Map<String, byte[]> generateKeyBytes() {
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGenerator.initialize(KEY_SIZE);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
Map<String, byte[]> keyMap = new HashMap<String, byte[]>();
keyMap.put(PUBLIC_KEY, publicKey.getEncoded());
keyMap.put(PRIVATE_KEY, privateKey.getEncoded());
return keyMap;
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 还原公钥，X509EncodedKeySpec 用于构建公钥的规范
*
* @param keyBytes
* @return
*/
public static PublicKey restorePublicKey(byte[] keyBytes) {
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
try {
KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey publicKey = factory.generatePublic(x509EncodedKeySpec);
return publicKey;
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 还原私钥，PKCS8EncodedKeySpec 用于构建私钥的规范
*
* @param keyBytes
* @return
*/
public static PrivateKey restorePrivateKey(byte[] keyBytes) {
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
try {
KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateKey = factory.generatePrivate(pkcs8EncodedKeySpec);
return privateKey;
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 加密，三步走。
*
* @param key
* @param plainText
* @return
*/
public static byte[] RSAEncode(PublicKey key, byte[] plainText) {
try {
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
return cipher.doFinal(plainText);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
| BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
*
*
* @param key
* @param encodedText
* @return
*/
public static String RSADecode(PrivateKey key, byte[] encodedText) {
try {
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
return new String(cipher.doFinal(encodedText));
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
| BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
}通过上面两个类可以进行测试。
第二种情况：在平时开发中，往往是用只需要用公钥加密或者是用私钥解密，公私钥和密文是String类型的，下面测试一下用私钥来解密一串密文。
package rsatest;
import java.security.InvalidKeyException;
import java.security.Key;
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.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
public class MyRSA {
public static final String KEY_ALGORITHM = "RSA";
public static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";
public static final String PUBLIC_KEY = "publicKey";
public static final String PRIVATE_KEY = "privateKey";
/** RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024 */
public static final int KEY_SIZE = 2048;
public static final String PLAIN_TEXT = "你好，2017";
// 以下是一对RSA公私钥，result是一串用公钥加密后的密文
private static String private_key_string = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDIIi9czQIjXg2A"
+ "BzmVTsW1kg71/OIOveeIJgngf4+7m53P6e6sRjRP5ZUU807qoVK0QuOUZgXN4SFl"
+ "f+TN5ydRq+zACBL9pVH1rxjI0pUvLyYLhj46a5fH+TWoSrqA8XfEgsybGtFhp5Xp"
+ "jJVXuIfEk5hGqCCqLH12p1a2enJzQtTLNrGGzFIbS9lxsqG4DeaF5RkEpwrFHGR6"
+ "4KHo3qdEAlRnQsmzO17pK8epG6PqilZ0RckAl9mAwijq9W5szdojWF/zxlbWOAYS"
+ "LiVQouEYYHxh0bRM2P6wqXKc5FpYHuIiM731gbb9WjCuZmE+/UXrJsNMDjf0KIwR"
+ "VFyRYUHJAgMBAAECggEBAJnFgmSodFMeafsMEheBnfGj1vD0q/Ctw19d8srW2GZK"
+ "7FebI7Kkgn89JG4jgGhRKc2tc1VLinwk1dc6DGCUkiZzlgX6bjULuEywi7eJ7eyC"
+ "KpZCQD/8+XNCLRMwz9pRLjgEVBd85JJHBK2dQgZTl6XXzfHELszyQDhR3RN6Q8QA"
+ "orGbOFfLflteIt3fQzpfrYsKRlsL+Hqv5oiMLCF7zpUfv/TgbQgFfY9wn/0IUqSs"
+ "PzaxsRggcZpX3PpCAzs5JX/9V00cwR1ZcHFeTe/rQhKcKDtTMkXnW82uRoVM+lxi"
+ "ciddQVG8DyUbFYQk1bUOxTnNwDg0lZ29lcmC9S41IjECgYEA6FqJy/m741gDCpca"
+ "ge8hhGvkURPH9Sv1Da/fzOTO/jIf8U/mvtdXkWH6mfQfWMiLRiIHQOdwy35gaCPw"
+ "qAsGwcJ1xaOS6yLYoamBV7R8mT/FAfscUFEkdYvDNISFM/00fBCdVYoYXHcY8iKg"
+ "LBoYLBY/nyOdflaK6PTDvxz3GH0CgYEA3IA47t6oFwAGPkccCSSbYwnXnVioXRcA"
+ "+D2BIt9dqZVsb1xQ0AKutrjYfNb1rQdKiO6e3M6j3vv5SEH8+UaU/VtYMnT82qA3"
+ "/4PDajFtXnHa+hYKQhqD+xg1paQn+yPeOu16xK/56kAqv/2/np7UdwWTiUwhXcDC"
+ "gMEKaWZZ3D0CgYAfc3npgVFccaJfwZpV8i+ARDZwfxP27M9L3f2WN3aJU/Gc8WrT"
+ "dESnKjMIudGwa9zmTl7a+zj6Yo3cKtk9ddihS5gze3O8nkfighY+7/BZshcRsJLh"
+ "kEo2Gwf+SN3a7rA3Buy1Em8/vONEi0lRDusstIpCGUkNO9urss34RYxw5QKBgHsY"
+ "MbBYKGo+nz2hIOuRvhU55151offl4aqzWyYGoBkNy60XUh3tgW+MHX8D2b6wdVGg"
+ "NJt72EuhSvalr/3RA1e06LWyTX4XN2uzOSJNWYsB8IbwSuXAO7GvQDOqQo+W5Hbt"
+ "ID4xJ0k4bSUlGRYKAP445LYfA/l8pJiQK6nPc5bZAoGBAOfss9Hr9OsgRuei1KkO"
+ "ud9u4nguyjtn6NMgX8UzWi6fE62vpneazDE9uAjrTRO/i00Df2khbqtzrCXY9Ym1"
+ "Q3U8Yn8OXwtVnousBZbfEYf7mSWiGLv5+LzfVi+58/dna7KN6rwBqPswa3ocFhdn"
+ "0mAgZ/Mb3VA4wZj217dKNTyZ";
private static String public_key_string = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyCIvXM0CI14NgAc5lU7F"
+ "tZIO9fziDr3niCYJ4H+Pu5udz+nurEY0T+WVFPNO6qFStELjlGYFzeEhZX/kzecn"
+ "UavswAgS/aVR9a8YyNKVLy8mC4Y+OmuXx/k1qEq6gPF3xILMmxrRYaeV6YyVV7iH"
+ "xJOYRqggqix9dqdWtnpyc0LUyzaxhsxSG0vZcbKhuA3mheUZBKcKxRxkeuCh6N6n"
+ "RAJUZ0LJszte6SvHqRuj6opWdEXJAJfZgMIo6vVubM3aI1hf88ZW1jgGEi4lUKLh"
+ "GGB8YdG0TNj+sKlynORaWB7iIjO99YG2/VowrmZhPv1F6ybDTA439CiMEVRckWFB"
+ "yQIDAQAB";
private static String result = "";
public static void main(String[] args) throws Exception {
}
/**
* 生成密钥对。注意这里是生成密钥对KeyPair，再由密钥对获取公私钥
*
* @return
*/
public static Map<String, byte[]> generateKeyBytes() {
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGenerator.initialize(KEY_SIZE);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
Map<String, byte[]> keyMap = new HashMap<String, byte[]>();
keyMap.put(PUBLIC_KEY, publicKey.getEncoded());
keyMap.put(PRIVATE_KEY, privateKey.getEncoded());
return keyMap;
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 还原公钥，X509EncodedKeySpec 用于构建公钥的规范
*
* @param keyBytes
* @return
*/
public static PublicKey restorePublicKey(byte[] keyBytes) {
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
try {
KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey publicKey = factory.generatePublic(x509EncodedKeySpec);
return publicKey;
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 还原私钥，PKCS8EncodedKeySpec 用于构建私钥的规范
*
* @param keyBytes
* @return
*/
public static PrivateKey restorePrivateKey(byte[] keyBytes) {
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
try {
KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateKey = factory.generatePrivate(pkcs8EncodedKeySpec);
return privateKey;
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 加密，三步走。
*
* @param key
* @param plainText
* @return
*/
public static byte[] RSAEncode(PublicKey key, byte[] plainText) {
try {
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
return cipher.doFinal(plainText);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
| BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
*
*
* @param key
* @param encodedText
* @return
*/
public static String RSADecode(PrivateKey key, byte[] encodedText) {
try {
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
return new String(cipher.doFinal(encodedText));
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
| BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 解密
*
* @param cipherText
* 密文
* @param privateKey
* 私钥
* @throws Exception
* 异常
*/
private static String decryptByPrivateKey(String privateKey, String cipherText) {
try {
byte[] keyBytes = Base64Utils.decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
return RSADecode(privateK, Base64Utils.decode(cipherText));
} catch (Exception e) {
e.printStackTrace();
return "";
}
}
}第三种情况：已经有成对的公私钥字符串，测试加解密
package rsatest;
import java.security.InvalidKeyException;
import java.security.Key;
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.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
public class MyRSA {
public static final String KEY_ALGORITHM = "RSA";
public static final String CIPHER_ALGORITHM = "RSA/ECB/PKCS1Padding";
public static final String PUBLIC_KEY = "publicKey";
public static final String PRIVATE_KEY = "privateKey";
/** RSA密钥长度必须是64的倍数，在512~65536之间。默认是1024 */
public static final int KEY_SIZE = 2048;
public static final String PLAIN_TEXT = "你好，2017";
// 以下是一对RSA公私钥，result是一串用公钥加密后的密文
private static String private_key_string = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDIIi9czQIjXg2A"
+ "BzmVTsW1kg71/OIOveeIJgngf4+7m53P6e6sRjRP5ZUU807qoVK0QuOUZgXN4SFl"
+ "f+TN5ydRq+zACBL9pVH1rxjI0pUvLyYLhj46a5fH+TWoSrqA8XfEgsybGtFhp5Xp"
+ "jJVXuIfEk5hGqCCqLH12p1a2enJzQtTLNrGGzFIbS9lxsqG4DeaF5RkEpwrFHGR6"
+ "4KHo3qdEAlRnQsmzO17pK8epG6PqilZ0RckAl9mAwijq9W5szdojWF/zxlbWOAYS"
+ "LiVQouEYYHxh0bRM2P6wqXKc5FpYHuIiM731gbb9WjCuZmE+/UXrJsNMDjf0KIwR"
+ "VFyRYUHJAgMBAAECggEBAJnFgmSodFMeafsMEheBnfGj1vD0q/Ctw19d8srW2GZK"
+ "7FebI7Kkgn89JG4jgGhRKc2tc1VLinwk1dc6DGCUkiZzlgX6bjULuEywi7eJ7eyC"
+ "KpZCQD/8+XNCLRMwz9pRLjgEVBd85JJHBK2dQgZTl6XXzfHELszyQDhR3RN6Q8QA"
+ "orGbOFfLflteIt3fQzpfrYsKRlsL+Hqv5oiMLCF7zpUfv/TgbQgFfY9wn/0IUqSs"
+ "PzaxsRggcZpX3PpCAzs5JX/9V00cwR1ZcHFeTe/rQhKcKDtTMkXnW82uRoVM+lxi"
+ "ciddQVG8DyUbFYQk1bUOxTnNwDg0lZ29lcmC9S41IjECgYEA6FqJy/m741gDCpca"
+ "ge8hhGvkURPH9Sv1Da/fzOTO/jIf8U/mvtdXkWH6mfQfWMiLRiIHQOdwy35gaCPw"
+ "qAsGwcJ1xaOS6yLYoamBV7R8mT/FAfscUFEkdYvDNISFM/00fBCdVYoYXHcY8iKg"
+ "LBoYLBY/nyOdflaK6PTDvxz3GH0CgYEA3IA47t6oFwAGPkccCSSbYwnXnVioXRcA"
+ "+D2BIt9dqZVsb1xQ0AKutrjYfNb1rQdKiO6e3M6j3vv5SEH8+UaU/VtYMnT82qA3"
+ "/4PDajFtXnHa+hYKQhqD+xg1paQn+yPeOu16xK/56kAqv/2/np7UdwWTiUwhXcDC"
+ "gMEKaWZZ3D0CgYAfc3npgVFccaJfwZpV8i+ARDZwfxP27M9L3f2WN3aJU/Gc8WrT"
+ "dESnKjMIudGwa9zmTl7a+zj6Yo3cKtk9ddihS5gze3O8nkfighY+7/BZshcRsJLh"
+ "kEo2Gwf+SN3a7rA3Buy1Em8/vONEi0lRDusstIpCGUkNO9urss34RYxw5QKBgHsY"
+ "MbBYKGo+nz2hIOuRvhU55151offl4aqzWyYGoBkNy60XUh3tgW+MHX8D2b6wdVGg"
+ "NJt72EuhSvalr/3RA1e06LWyTX4XN2uzOSJNWYsB8IbwSuXAO7GvQDOqQo+W5Hbt"
+ "ID4xJ0k4bSUlGRYKAP445LYfA/l8pJiQK6nPc5bZAoGBAOfss9Hr9OsgRuei1KkO"
+ "ud9u4nguyjtn6NMgX8UzWi6fE62vpneazDE9uAjrTRO/i00Df2khbqtzrCXY9Ym1"
+ "Q3U8Yn8OXwtVnousBZbfEYf7mSWiGLv5+LzfVi+58/dna7KN6rwBqPswa3ocFhdn"
+ "0mAgZ/Mb3VA4wZj217dKNTyZ";
private static String public_key_string = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAyCIvXM0CI14NgAc5lU7F"
+ "tZIO9fziDr3niCYJ4H+Pu5udz+nurEY0T+WVFPNO6qFStELjlGYFzeEhZX/kzecn"
+ "UavswAgS/aVR9a8YyNKVLy8mC4Y+OmuXx/k1qEq6gPF3xILMmxrRYaeV6YyVV7iH"
+ "xJOYRqggqix9dqdWtnpyc0LUyzaxhsxSG0vZcbKhuA3mheUZBKcKxRxkeuCh6N6n"
+ "RAJUZ0LJszte6SvHqRuj6opWdEXJAJfZgMIo6vVubM3aI1hf88ZW1jgGEi4lUKLh"
+ "GGB8YdG0TNj+sKlynORaWB7iIjO99YG2/VowrmZhPv1F6ybDTA439CiMEVRckWFB"
+ "yQIDAQAB";
private static String result = "TsIqMqig553DTsmbuXEKar0wIF7eAMogR/ojM4K0YsQ8VCYu1h"
+ "AqwPAOL2nrxMTcrynHHVlPMroc89cyRyvMFsfbsM/hBqbuNNoQ9uPCYFLwCHbaUTmlay8je"
+ "QOE9fheVF51tXy6OiNVllvmhq/JJMJ6tVzclFfP5k5np6Hebphb1PDTy6NzCL9GCl28lwxq"
+ "KSY4pzr6+dNx/tfdazyuuLnhNfNASmey3coae9KTKG4UVp78QVaxacs9pIVuJRXBxqKp6Sm"
+ "ofTczCmK0yyMxghn5o0/Dnwqs8YUM2P7FR7dmvjBkUaDe7SunaT/FnNlh269u6D8i8bK2TC"
+ "dmclyj/Q==";
public static void main(String[] args) throws Exception {
PublicKey pubKey=restorePublicKey(Base64Utils.decode(public_key_string));
PrivateKey priKey=restorePrivateKey(Base64Utils.decode(private_key_string));
//1.用公钥加密
byte[] encodeBytes=RSAEncode(pubKey, PLAIN_TEXT.getBytes());
System.out.println("-----加密结果----\n"+Base64Utils.encode(encodeBytes));
//1.用私钥解密
String decodeResult=RSADecode(priKey, encodeBytes);
System.out.println("-----解密结果----\n"+decodeResult);
}
/**
* 生成密钥对。注意这里是生成密钥对KeyPair，再由密钥对获取公私钥
*
* @return
*/
public static Map<String, byte[]> generateKeyBytes() {
try {
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGenerator.initialize(KEY_SIZE);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
Map<String, byte[]> keyMap = new HashMap<String, byte[]>();
keyMap.put(PUBLIC_KEY, publicKey.getEncoded());
keyMap.put(PRIVATE_KEY, privateKey.getEncoded());
return keyMap;
} catch (NoSuchAlgorithmException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 还原公钥，X509EncodedKeySpec 用于构建公钥的规范
*
* @param keyBytes
* @return
*/
public static PublicKey restorePublicKey(byte[] keyBytes) {
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
try {
KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
PublicKey publicKey = factory.generatePublic(x509EncodedKeySpec);
return publicKey;
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 还原私钥，PKCS8EncodedKeySpec 用于构建私钥的规范
*
* @param keyBytes
* @return
*/
public static PrivateKey restorePrivateKey(byte[] keyBytes) {
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
try {
KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateKey = factory.generatePrivate(pkcs8EncodedKeySpec);
return privateKey;
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 加密，三步走。
*
* @param key
* @param plainText
* @return
*/
public static byte[] RSAEncode(PublicKey key, byte[] plainText) {
try {
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, key);
return cipher.doFinal(plainText);
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
| BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
*
*
* @param key
* @param encodedText
* @return
*/
public static String RSADecode(PrivateKey key, byte[] encodedText) {
try {
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
cipher.init(Cipher.DECRYPT_MODE, key);
return new String(cipher.doFinal(encodedText));
} catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException
| BadPaddingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return null;
}
/**
* 解密
*
* @param cipherText
* 密文
* @param privateKey
* 私钥
* @throws Exception
* 异常
*/
private static String decryptByPrivateKey(String privateKey, String cipherText) {
try {
byte[] keyBytes = Base64Utils.decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
return RSADecode(privateK, Base64Utils.decode(cipherText));
} catch (Exception e) {
e.printStackTrace();
return "";
}
}
}
130
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
