io.afu.utils.encryption.RSAEncodeUtils Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of utils Show documentation
Show all versions of utils Show documentation
RffanLAB Utils For Many Way use
//package io.afu.utils.encryption;
//
//import java.io.ByteArrayOutputStream;
//import java.io.IOException;
//import java.io.UnsupportedEncodingException;
//import java.security.InvalidKeyException;
//import java.security.KeyFactory;
//import java.security.KeyPair;
//import java.security.KeyPairGenerator;
//import java.security.MessageDigest;
//import java.security.NoSuchAlgorithmException;
//import java.security.PrivateKey;
//import java.security.PublicKey;
//import java.security.SecureRandom;
//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.HashMap;
//import java.util.Map;
//
//import javax.crypto.BadPaddingException;
//import javax.crypto.Cipher;
//import javax.crypto.IllegalBlockSizeException;
//import javax.crypto.NoSuchPaddingException;
//import javax.crypto.ShortBufferException;
//
//import org.apache.commons.codec.digest.DigestUtils;
//import org.apache.tomcat.util.codec.binary.Base64;
//import org.apache.tomcat.util.http.fileupload.IOUtils;
//import org.bouncycastle.jce.provider.BouncyCastleProvider;
//
//import com.aisino.aosplus.core.util.Base64Util;
//import com.aisino.feishui.front.service.impl.InvRecordServiceImpl;
//
///**
// * RSA签名与验签
// *
// * @author huangyujiao on 2018/2/9.
// * @version 1.0
// */
//public class RSAEncodeUtils {
// /**
// * 签名算法
// */
// private static final String SIGN_RSA = "RSA";
// private static BouncyCastleProvider bouncyCastleProvider = new BouncyCastleProvider();
//
// /**
// * 从字符串中加载公钥
// *
// * @param publicKeyStr
// * 公钥数据字符串
// * @throws Exception
// * 加载公钥时产生的异常
// */
// public static RSAPublicKey loadPublicKeyByStr(String publicKeyStr) throws Exception {
// try {
// byte[] buffer = Base64.decodeBase64(publicKeyStr.getBytes());
// KeyFactory keyFactory = KeyFactory.getInstance(SIGN_RSA);
// X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
// return (RSAPublicKey) keyFactory.generatePublic(keySpec);
// } catch (NoSuchAlgorithmException e) {
// throw new Exception("无此算法");
// } catch (InvalidKeySpecException e) {
// throw new Exception("公钥非法");
// } catch (NullPointerException e) {
// throw new Exception("公钥数据为空");
// }
// }
//
// /**
// * * 公钥加密 *
// *
// * @param publicKeyStr
// * 加密的密钥 *
// * @param data
// * 待加密的明文数据 *
// * @return 加密后的数据 *
// * @throws Exception
// */
// public static String encryptByPubK(String publicKeyStr, String data) throws Exception {
// try {
// byte[] value = data.getBytes();
// byte[] raw = en(publicKeyStr, value);
// String out = new String(Base64.encodeBase64(raw));
// return out;
// } catch (Exception e) {
// throw new Exception("加密失败");
// }
// }
//
// public static byte[] en(String publicKeyStr, byte[] value)
// throws Exception, NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
// ShortBufferException, IllegalBlockSizeException, BadPaddingException {
//
// PublicKey pk = loadPublicKeyByStr(publicKeyStr);
// Cipher cipher = Cipher.getInstance("RSA", bouncyCastleProvider);
// cipher.init(Cipher.ENCRYPT_MODE, pk);
// // 获得加密块大小，如：加密前数据为128个byte，而key_size=1024
// int blockSize = cipher.getBlockSize();
// // 加密块大小为127
// // byte,加密后为128个byte;因此共有2个加密块，第一个127
// // byte第二个为1个byte
// // 获得加密块加密后块大小
// int outputSize = cipher.getOutputSize(value.length);
// int leavedSize = value.length % blockSize;
// int blocksSize = leavedSize != 0 ? value.length / blockSize + 1 : value.length / blockSize;
// byte[] raw = new byte[outputSize * blocksSize];
// int i = 0;
// // 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
// // ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了
// // OutputSize所以只好用dofinal方法。
// while (value.length - i * blockSize > 0) {
// if (value.length - i * blockSize > blockSize) {
// cipher.doFinal(value, i * blockSize, blockSize, raw, i * outputSize);
// } else {
// cipher.doFinal(value, i * blockSize, value.length - i * blockSize, raw, i * outputSize);
// }
// i++;
// }
// return raw;
//
// }
//
// /**
// * 随机生成密钥对
// */
// public Map genKeyPair() {
// // KeyPairGenerator类用于生成公钥和私钥对，基于RSA算法生成对象
// KeyPairGenerator keyPairGen = null;
// try {
// keyPairGen = KeyPairGenerator.getInstance(SIGN_RSA);
// } catch (NoSuchAlgorithmException e) {
// // TODO Auto-generated catch block
// e.printStackTrace();
// }
// // 初始化密钥对生成器，密钥大小为96-1024位
// keyPairGen.initialize(1024, new SecureRandom());
// // 生成一个密钥对，保存在keyPair中
// KeyPair keyPair = keyPairGen.generateKeyPair();
// // 得到私钥
// RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
// // 得到公钥
// RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
//
// // 得到公钥字符串
// String publicKeyString = new EncryptionKey().byteArrayToString(Base64.encodeBase64(publicKey.getEncoded()));
// // 得到私钥字符串
// String privateKeyString = new EncryptionKey().byteArrayToString(Base64.encodeBase64(privateKey.getEncoded()));
//
// Map map = new HashMap();
// map.put("publicKey", publicKeyString);
// map.put("privateKey", privateKeyString);
// return map;
// }
//
// public static void main(String[] args) throws UnsupportedEncodingException, Exception {
// String pk = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKOKT2pVD/6CNglsnhzoAJoHygrujP8yOUsnV4UmG2kHmMb36xfE4I+LMr49HbPGtu3r9PO4tAPmMhpEqLAYfbi+WRqgx1dqRNRFiqOQ+wZwZZvmHR24oN3hKY1dBSc6EfLLwr/tOilBCFTX+V9/2f8x+dffzWX9+9eKBvp4aMIJAgMBAAECgYBS21xpDzfPRsGB/NoO4yyK3a9r4njlQtjsTr5041231PV+uVUO8dykXW4UHHrT/rXnzUiJwubRout3i5m7vmzTQaUn/ojXWLVPTcT15SLpvX46sFZOJ04X/ohP28Q2PM/B66gBlWTSZY04tjG9CGbkINGvJEabbv+FZx4qE9CXQQJBAM6gBOlAzu5UDTV0KE54UHGHXiJEsRJpvJDdEA4M3aW6oaLysRaPsd3OPi7vFRexwg7J3i76owijwG2XIeAehE0CQQDKnqSBw/tpXriLYfrEAAVnkao9OP65bTKMV1uB8oFEmu1lzHiTscbnn99uVVw/HDUPSCdpK1XV1YMXWgiBI8KtAkADbVYHhGKqQ0ygyVdtzcMPzv35tYf2VTiicng0s3PtrsXFjR7wz9tUYXpYjvCbnwAn/KMpxlBz8Ttc1ffi3r61AkEAszmUpjwm/NOORaxLVmf2X+BXR4RMvNQ8bCsxhEZv1bF84Bj3Zx1Ppb6iskPLLv/SZ0wZoEt2x4jvRg6biy+ImQJALfaZl2zO/Hnvh3MvlVzhiKzlyK7orBWx+udYBmN5lYDBE13sxrasmXujLDYEUhpLkwhs/e7qjRV32vtlH8EMRg==";
// String pkPu = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCjik9qVQ/+gjYJbJ4c6ACaB8oK7oz/MjlLJ1eFJhtpB5jG9+sXxOCPizK+PR2zxrbt6/TzuLQD5jIaRKiwGH24vlkaoMdXakTURYqjkPsGcGWb5h0duKDd4SmNXQUnOhHyy8K/7TopQQhU1/lff9n/MfnX381l/fvXigb6eGjCCQIDAQAB";
// String input = "B7/x5+dAoRbkyISJdw3XeQ7oWI/+Vn+5/wVXz9N3IKYfMxDPZVCwvV5QQtAEmIlIQnLXjWDyPQJWLJ23XHDD0YL7QE/5x+PU5EJTfh8zpf4dNXfpSKiYB65p01G3KueIUENy8hVAvVJNQIylJvo3bDp9e8NlFUHCfqHyyc8tHX4=";
// String urlParam = new InvRecordServiceImpl().UrlParam(input);
//// String var = "{\"billState\":\"3\",\"holdingUnitCode\":\"971804\",\"orderNum\":\"GH5840771-1\",\"paramtype\":\"1\"}";
//// String pub = new String(RSAEncodeUtils.encryptByPubK(pkPu, var));
//// String priva = new String(RSADecodeUtils.decryptByPPK(pk, var));
// byte[] deCodeByteArr = Base64Util.getdeBASE64inCodec(urlParam);
// String deCodeStr = new String(RSADecodeUtils.de(pk, deCodeByteArr), "UTF8");
//
// System.out.println(deCodeStr);
//// System.out.println(pub);
//// System.out.println(priva);
// }
//
//}
//
//class EncryptionKey {
//
// private static final Logger LOGGER = LoggerFactory.getLogger(EncryptionKey.class);
// /**
// * 签名算法
// */
// public final String SIGN_ALGORITHMS = "SHA1WithRSA";
// public static final String SIGN_RSA = "RSA";
//
// /**
// * 从字符串中加载公钥
// *
// * @param publicKeyStr
// * 公钥数据字符串
// * @throws Exception
// * 加载公钥时产生的异常
// */
// public RSAPublicKey loadPublicKeyByStr(String publicKeyStr) throws Exception {
// try {
// byte[] buffer = Base64.decodeBase64(publicKeyStr.getBytes());
// KeyFactory keyFactory = KeyFactory.getInstance(SIGN_RSA);
// X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
// return (RSAPublicKey) keyFactory.generatePublic(keySpec);
// } catch (NoSuchAlgorithmException e) {
// throw new Exception("无此算法");
// } catch (InvalidKeySpecException e) {
// throw new Exception("公钥非法");
// } catch (NullPointerException e) {
// throw new Exception("公钥数据为空");
// }
// }
//
// /**
// * 从字符串中加载私钥
// *
// * @param privateKeyStr
// * 公钥数据字符串
// * @throws Exception
// * 加载公钥时产生的异常
// */
// public static RSAPrivateKey loadPrivateKeyByStr(String privateKeyStr) throws Exception {
//
// byte[] buffer = Base64.decodeBase64(privateKeyStr.getBytes("ISO-8859-1"));
// PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
// KeyFactory keyFactory = KeyFactory.getInstance(SIGN_RSA);
// PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
// buffer = null;
// keySpec = null;
// return (RSAPrivateKey) privateKey;
//
// }
//
// /**
// * 字节数据转十六进制字符串
// *
// * @param data
// * 输入数据
// * @return 十六进制内容
// */
// public static String byteArrayToString(byte[] data) {
// String s = new String(data);
// return s;
//
// }
//
// // MD5加密
// public static String EncoderByMd5(String str) throws NoSuchAlgorithmException, IOException {
// String newstr = "";
//
// // 确定计算方法
// MessageDigest md5 = MessageDigest.getInstance("MD5");
// // 加密后的字符串
// newstr = Base64.encodeBase64String(md5.digest(str.getBytes("utf-8")));
//
// return newstr;
// }
//
// /**
// * * 公钥加密 *
// *
// * @param pk
// * 加密的密钥 *
// * @param data
// * 待加密的明文数据 *
// * @return 加密后的数据 *
// * @throws Exception
// */
// public String encrypt(PublicKey pk, byte[] data) throws Exception {
// try {
// Cipher cipher = Cipher.getInstance("RSA", bouncyCastleProvider);
// cipher.init(Cipher.ENCRYPT_MODE, pk);
// int blockSize = cipher.getBlockSize();// 获得加密块大小，如：加密前数据为128个byte，而key_size=1024
// // 加密块大小为127
// // byte,加密后为128个byte;因此共有2个加密块，第一个127
// // byte第二个为1个byte
// int outputSize = cipher.getOutputSize(data.length);// 获得加密块加密后块大小
// int leavedSize = data.length % blockSize;
// int blocksSize = leavedSize != 0 ? data.length / blockSize + 1 : data.length / blockSize;
// byte[] raw = new byte[outputSize * blocksSize];
// int i = 0;
// while (data.length - i * blockSize > 0) {
// if (data.length - i * blockSize > blockSize)
// cipher.doFinal(data, i * blockSize, blockSize, raw, i * outputSize);
// else
// cipher.doFinal(data, i * blockSize, data.length - i * blockSize, raw, i * outputSize);
// // 这里面doUpdate方法不可用，查看源代码后发现每次doUpdate后并没有什么实际动作除了把byte[]放到
// // ByteArrayOutputStream中，而最后doFinal的时候才将所有的byte[]进行加密，可是到了此时加密块大小很可能已经超出了
// // OutputSize所以只好用dofinal方法。
//
// i++;
// }
// String out = new String(Base64.encodeBase64(raw));
// return out;
// } catch (Exception e) {
// throw new Exception(e.getMessage());
// }
// }
//
// private static BouncyCastleProvider bouncyCastleProvider = new BouncyCastleProvider();
//
// /**
// * * 私钥解密 *
// *
// * @param pk
// * 解密的密钥 *
// * @param data
// * 已经加密的数据 *
// * @return 解密后的明文 *
// * @throws Exception
// */
// public static String decryptByPPK(PrivateKey pk, String data) throws Exception {
// ByteArrayOutputStream bout = null;
// try {
// KeyFactory keyFactory = KeyFactory.getInstance("RSA");
// Cipher cipher = Cipher.getInstance("RSA", bouncyCastleProvider);
// cipher.init(Cipher.DECRYPT_MODE, pk);
// int blockSize = cipher.getBlockSize();
// bout = new ByteArrayOutputStream(64);
// int j = 0;
// byte[] raw = Base64.decodeBase64(data);
// while (raw.length - j * blockSize > 0) {
// bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
// j++;
// }
// raw = null;
// return bout.toString();
// } catch (Exception e) {
// if (bout != null) {
// IOUtils.closeQuietly(bout);
// }
// LOGGER.error("私钥解密失败:{}", e);
// throw e;
// } finally {
// IOUtils.closeQuietly(bout);
// }
// }
//
// /**
// * 前端MD5加密
// *
// * @param data
// * @return
// */
// public static String Md5Encode(String data) {
// String returnData = "";
// try {
// returnData = DigestUtils.md5Hex(data);
// return returnData;
// } catch (Exception e) {
// LOGGER.error("数据MD5加密失败:{}", e);
// throw e;
// }
// }
//
// /**
// * 前端私钥解密
// *
// * @param encryptedData
// * @param privateKey
// * @return
// * @throws Exception
// */
// public static String decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
// try {
//
// byte[] keyBytes = Base64.decodeBase64(privateKey);
// PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
// KeyFactory keyFactory = KeyFactory.getInstance("RSA");
// PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
// Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
// cipher.init(Cipher.DECRYPT_MODE, privateK);
// int inputLen = encryptedData.length;
// byte[] result = new byte[(encryptedData.length / 128 + 1) * 117];
// int offSet = 0;
// byte[] cache;
// int i = 0;
// int len = 0;
// // 对数据分段解密
// while (inputLen - offSet > 0) {
// if (inputLen - offSet > 128) {
// cache = cipher.doFinal(encryptedData, offSet, 128);
// } else {
// cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
// }
// i++;
// offSet = i * 128;
// for (byte b : cache) {
// result[len++] = b;
// }
// }
// return new String(result);
// } catch (Exception e) {
// LOGGER.error("私钥解密失败:{}", e);
// throw e;
// }
// }
//
//}