一.RSACoder
package com.landray.kmss.cmb.oasso.util;
import java.net.URLDecoder;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import com.landray.kmss.util.DateUtil;
import org.apache.commons.ssl.Base64;
import com.landray.kmss.util.MD5Util;
import com.landray.kmss.util.StringUtil;
public class RSACoder {
//非对称密钥算法
public static final String KEY_ALGORITHM = "RSA";
/**
* 密钥长度，DH算法的默认密钥长度是1024
* 密钥长度必须是64的倍数，在512到65536位之间
*/
private static final int KEY_SIZE = 512;
//公钥
private static final String PUBLIC_KEY = "RSAPublicKey";
//私钥
private static final String PRIVATE_KEY = "RSAPrivateKey";
/**
* 初始化密钥对
*
* @return Map 甲方密钥的Map
*/
public static Map<String, Object> initKey() throws Exception {
//实例化密钥生成器
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中
Map<String, Object> keyMap = new HashMap<String, Object>();
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 私钥加密
*
* @param data 待加密数据
* @param key 密钥
* @return byte[] 加密数据
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {
//取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
//数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 公钥加密
*
* @param data 待加密数据
* @param key 密钥
* @return byte[] 加密数据
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {
//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
//产生公钥
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, pubKey);
return cipher.doFinal(data);
}
/**
* 私钥解密
*
* @param data 待解密数据
* @param key 密钥
* @return byte[] 解密数据
*/
public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
//取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
//数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 公钥解密
*
* @param data 待解密数据
* @param key 密钥
* @return byte[] 解密数据
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {
//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
//产生公钥
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, pubKey);
return cipher.doFinal(data);
}
/**
* 取得私钥
*
* @param keyMap 密钥map
* @return byte[] 私钥
*/
public static byte[] getPrivateKey(Map<String, Object> keyMap) {
Key key = (Key) keyMap.get(PRIVATE_KEY);
return key.getEncoded();
}
/**
* 取得公钥
*
* @param keyMap 密钥map
* @return byte[] 公钥
*/
public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get(PUBLIC_KEY);
return key.getEncoded();
}
/**
* @param args
* @throws Exception
*/
public static void main(String[] args) throws Exception {
//初始化密钥
//生成密钥对
// Map<String, Object> keyMap = RSACoder.initKey();
// //公钥
// byte[] publicKey = RSACoder.getPublicKey(keyMap);
//
// //私钥
// byte[] privateKey = RSACoder.getPrivateKey(keyMap);
// String publicKeyString =Base64.encodeBase64String(publicKey);
// System.out.println("公钥："+publicKeyString);
// String privateKeyString = Base64.encodeBase64String(privateKey);
// System.out.println("私钥:"+privateKeyString);
//
// System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");
// String str = "test";
// System.out.println("/n===========甲方向乙方发送加密数据==============");
// System.out.println("原文:" + str);
// //甲方进行数据的加密
// byte[] code1 = RSACoder.encryptByPrivateKey(str.getBytes(), Base64.decodeBase64(privateKeyString));
// String mw=Base64.encodeBase64String(code1);
//
// String[] mws=new String[6];
// for (int i = 0; i < mws.length; i++) {
// str="dsadsadsadaseqweq大师大师法示范法"+new Random().nextInt(1000);
// byte[] temp = RSACoder.encryptByPrivateKey(str.getBytes(), Base64.decodeBase64(privateKeyString));
// mws[i]=Base64.encodeBase64String(temp);
// }
//
// System.out.println("批量解密=====start=====");
// for (int i = 0; i < mws.length; i++) {
// byte[] decode1=RSACoder.decryptByPublicKey(Base64.decodeBase64(mws[i]), publicKey);
// System.out.println("乙方解密后的数据：" + new String(decode1) + "/n/n");
// }
// System.out.println("批量解密===end=======");
//
//
// System.out.println("加密后的数据：" +mw );
// System.out.println("===========乙方使用甲方提供的公钥对数据进行解密==============");
// //乙方进行数据的解密
// byte[] decode1 = RSACoder.decryptByPublicKey(Base64.decodeBase64(mw), publicKey);
// System.out.println("乙方解密后的数据：" + new String(decode1) + "/n/n");
//
// System.out.println("===========反向进行操作，乙方向甲方发送数据==============/n/n");
//
// str = "乙方向甲方发送数据RSA算法";
//
// System.out.println("原文:" + str);
//
// //乙方使用公钥对数据进行加密
// byte[] code2 = RSACoder.encryptByPublicKey(str.getBytes(), Base64.decodeBase64(publicKeyString));
// System.out.println("===========乙方使用公钥对数据进行加密==============");
// System.out.println("加密后的数据：" + Base64.encodeBase64String(code2));
//
// System.out.println("=============乙方将数据传送给甲方======================");
// System.out.println("===========甲方使用私钥对数据进行解密==============");
//
// //甲方使用私钥对数据进行解密
// byte[] decode2 = RSACoder.decryptByPrivateKey(code2, privateKey);
//
// System.out.println("甲方解密后的数据：" + new String(decode2));
//AutoLoginHelper autoLoginHelper=(AutoLoginHelper)SpringBeanUtil.getBean("autoLoginHelper");
//autoLoginHelper.doAutoLogin("loginName", request.getSession());
//测试部分
// System.out.println("华南密文测试开始");
// String hnmw ="n2cMCsOsFvBdF1D9oe0P3xlUVWl4rvVKEc2H5XKEiS02WFU92vNdEmqhzqtO1wspxqQz89EllHDMzqcSSCS/kw==";
// String publicKeyString1 ="MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAN0f9HrUbrzzgyvMz9aq3eqX1+F0MS8H2sKKevl0dtMaGZrmepwFulJgxr8C+Dy+BCAXzO9YjVZr/YVsgvWdVzsCAwEAAQ==";//公钥
//
// System.out.println("=========:"+hnmw.length());
// byte[] decodehnmw = RSACoder.decryptByPublicKey(Base64.decodeBase64(hnmw), Base64.decodeBase64(publicKeyString1));
//
// System.out.println("解密后数据："+new String(decodehnmw));
//
// //
// System.out.println("华南密文测试结束");
// System.out.println("1587443377980%E8%91%A3%E9%81%93%E6%B8%85");
// System.out.println(URLDecoder.decode("1587443377980%E8%91%A3%E9%81%93%E6%B8%85"
// + "", "UTF-8"));
//
// String urls="192.168.*;192.167.*";
// String[] url=urls.split(";");
// System.out.println(isPrivateUrl("192.168.;192.167.","192.167.2.158"));
//
String publicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVJBcD21z+h5qOHyoqGlBeNkzmbscSdLCv6mJLlj6N8FxgzG85qxCNeN/XuzIbcERKJkfuaw/1oOA9yNrzEtV5x6axG99AG3+McfGM88A8AEJm3EWQR2OXGeuzMdGWNCrO1LTRuDcbRoJiSMMByztUCtXcqaFgTs8DqQAs+KsAuQIDAQAB";
String privateKey="MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJUkFwPbXP6Hmo4fKioaUF42TOZuxxJ0sK/qYkuWPo3wXGDMbzmrEI1439e7MhtwREomR+5rD/Wg4D3I2vMS1XnHprEb30Abf4xx8YzzwDwAQmbcRZBHY5cZ67Mx0ZY0Ks7UtNG4NxtGgmJIwwHLO1QK1dypoWBOzwOpACz4qwC5AgMBAAECgYAY81S2XHiOTHla1XPkX0qauFLdKiM7vzHf/EI9iwEkFdYei5T//NJkGJi6KqMTXBDQpt7Z0Cd3XFanf3bBu6Di4L6Ukxyu0smyBpTAwI+1k8UFfQpEF4FlhE4B17aIAbgIOpI41bBqzASmm+6RktsFhJvGIV+S8Q8jtgbC9LtMAQJBAN+WkBJiWZpVjGF4zrf91N/kAK+n1MZPebR9tSFTXuqsNZdOOyf2pAcdof8L3SXeEKd/EQ0kSB/1h1tLARk38aECQQCqwsQRZbFfzzMlU931JAu0D7rWOuR2xSu9U7KnOfMaDFRAnMWjLp2fmtwbRRIexBWJ+Z1yU7Zhy6UXMyPyK2gZAkEA1mIwfGAvGCuE8gT6+TJ6hb7B5atf+lJEGQsbvPuKnCtJK24IjLYR6vy/0qQWhPObNm9A8z/hpDsxcRjG0d5xYQJAbaG19+VuR7DjiWea7TRDP0uKDNiqrYZRWrBN1wdhiKu5u/HrAaWAFWR7RBbIV3BU08yqxSfxxD/WslpnDafIoQJBALFKNuTMBnZvV6tD5Bp+PapkNEkKrznBKwfKblSg33tK0dcmJlXPM17VTVBMnXg0TBZ3+9o6U5S07kgqUhl7qoo=";
String loginname="274674";
byte[] code2 = RSACoder.encryptByPublicKey(loginname.getBytes(), Base64.decodeBase64(publicKey));
System.out.println("加密后的数据：" + Base64.encodeBase64String(code2));
String miwen=Base64.encodeBase64String(code2);
byte[] decodehnmw = RSACoder.decryptByPrivateKey(Base64.decodeBase64(miwen), Base64.decodeBase64(privateKey));
System.out.println("解密后数据："+new String(decodehnmw));
//私钥
// String privateKeyString = "YYYYYXX28JHKLNGYJ";
// String str = "oauser2021-03-10YYYYYXX28JHKLNGYJ";
//
// String ss=MD5Util.getMD5String(str);
// System.out.println(ss);
//http://10.30.70.2/icore
//http://10.30.70.2/icore/sso/login?ssou=oauser&ssomd5=47831ff5e6067b71a5d14ba4c86a2650&&ssol=zh_CN&ssourl=/mdm/home.html#/dashboard
Long time = new Date().getTime();
String str = "1791c468c7f0a9a8253145a5f259f634"+time;
String tmpToken = MD5Util.getMD5String(str);
System.out.println("signature:"+tmpToken);
System.out.println("timestamp:"+time);
}
public static Boolean isPrivateUrl(String privateUrls,String url){
Boolean result = false;
String[] urls=privateUrls.split(";");
if(urls.length>0){
for(int i = 0;i<urls.length;i++){
if(StringUtil.isNotNull(urls[i])&& urls[i].contains("*")&&url.contains(urls[i].replace("*", ""))){
result =true;
}else if(StringUtil.isNotNull(urls[i]) &&urls[i].contains("*") ==false&& url.equals(urls[i]) ){
result = true;
}
else
;
}
}
return result;
}
}
二.RSAUtils
pem格式文件 转换成公钥对象需要 去除页头和页尾
package com.landray.kmss.nysh.rent.util;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.io.IOUtils;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.security.*;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.X509EncodedKeySpec;
import java.util.Date;
public class RSAUtils {
public static final String CHARSET = "UTF-8";
public static final String RSA_ALGORITHM = "RSA";
/**
* 公钥加密
* @param data
* @param publicKey
* @return
*/
public static String publicEncrypt(String data, RSAPublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
return Base64.encodeBase64String (rsaSplitCodec(cipher,
Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
} catch (Exception e) {
throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
}
}
//rsa切割解码 , ENCRYPT_MODE,加密数据 ,DECRYPT_MODE,解密数据
private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize) {
int maxBlock = 0; //最大块
if (opmode == Cipher.DECRYPT_MODE) {
maxBlock = keySize / 8;
} else {
maxBlock = keySize / 8 - 11;
}
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] buff;
int i = 0;
try {
while (datas.length > offSet) {
if (datas.length - offSet > maxBlock) {
//可以调用以下的doFinal（）方法完成加密或解密数据：
buff = cipher.doFinal(datas, offSet, maxBlock);
} else {
buff = cipher.doFinal(datas, offSet, datas.length - offSet);
}
out.write(buff, 0, buff.length);
i++;
offSet = i * maxBlock;
}
} catch (Exception e) {
throw new RuntimeException("加解密阀值为[" + maxBlock + "]的数据时发生异常", e);
}
byte[] resultDatas = out.toByteArray();
IOUtils.closeQuietly(out);
return resultDatas;
}
public static RSAPublicKey readPublicKey(File file) throws Exception {
String key = new String(Files.readAllBytes(file.toPath()), Charset.defaultCharset());
String publicKeyPEM = key
.replace("-----BEGIN PUBLIC KEY-----", "")
.replaceAll(System.lineSeparator(), "")
.replace("-----END PUBLIC KEY-----", "");
byte[] encoded = org.apache.commons.codec.binary.Base64.decodeBase64(publicKeyPEM);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(encoded);
return (RSAPublicKey) keyFactory.generatePublic(keySpec);
}
// 简单测试____________
public static void main(String[] args) throws Exception {
String tenStr = "kjaatoalxx";//十位随机数
String tenTime = String.valueOf(new Date().getTime()/1000);
String daiJiaMi = tenStr + tenTime + "bus-eip";
System.out.println(daiJiaMi);
String encodedData = RSAUtils.publicEncrypt(daiJiaMi, readPublicKey(new File("F:\\rsa_public_key_2048.pub"))); //传入明文和公钥加密,得到密文
System.out.print("密文" + encodedData);
}
}