Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $
You can buy this project and download/modify it how often you want.
io.afu.utils.encryption.RSAEncodeUtils Maven / Gradle / Ivy
//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;
// }
// }
//
//}
