常见的加密
加密：在网络传输中，如果我们传输明文，会被人给截取，从而数据泄露。我们可以对他们进行加密
加密分为2大类，对称加密和非对称加密。
对称加密：对称加密就是加密和解密公用一个密钥。
DES：对称加密，速度较快，适用于加密大型数据的场合。
public class DesUtil {
private final static String DES = "DES";
private final static String ENCODE = "UTF-8";
private final static byte[] ivByte= {1,2,3,4,5,6,7,8};
// 算法名称/加密模式/填充方式
public static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
//主要看填充方式 PKCS5Padding PKCS7Padding 还有其他的填充方式没用过
// public static final String CIPHER_ALGORITHM_CBC = "DES/CBC/ZerosPadding";
public static void main(String[] args) throws Exception {
String data="123456";
String timeSend="1536313412";
System.out.println(timeSend);
String apikey="5e29f483c48848";
String messageId="cdf5157133f64b409e69d60c4329bb72";
String key=Md5Util.md5Hex(apikey+timeSend+messageId);
try {
String encrypt = encrypt(data,key);//data是要加密的数据，key是密钥。
System.out.println(encrypt);
System.out.println(decrypt(encrypt,key));//encrypt这个是加密过的数据，Key是密钥。
} catch (Exception e) {
e.printStackTrace();
}
}
所以在传输过程中，我们需要把加密过后的数据和密钥一起传过去，只要是截取到密文和密钥，就可以轻松的把数据解密。
/**
* Description 根据键值进行加密
* @param data
* @param key 加密键byte数组
* @return
* @throws Exception
*/
public static String encrypt(String data, String key) throws Exception {
byte[] bt = encrypt(data.getBytes(ENCODE), key.getBytes(ENCODE));
return new String(Base64.getEncoder().encode(bt));
}
/**
* Description 根据键值进行解密
* @param data
* @param key 加密键byte数组
* @return
* @throws IOException
* @throws Exception
*/
public static String decrypt(String data, String key) throws IOException,
Exception {
if (data == null)
return null;
byte[] buf = Base64.getDecoder().decode(data);
byte[] bt = decrypt(buf, key.getBytes(ENCODE));
return new String(bt, ENCODE);
}
/**
* Description 根据键值进行加密
* @param data
* @param key 加密键byte数组
* @return
* @throws Exception
*/
private static byte[] encrypt(byte[] data, byte[] key) throws Exception {
// 初始化向量
IvParameterSpec iv = new IvParameterSpec(ivByte);
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey secureKey = keyFactory.generateSecret(dks);
// Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
// 用密钥初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, secureKey, iv);
return cipher.doFinal(data);
}
/**
* Description 根据键值进行解密
*
* @param data
* @param key 加密键byte数组
* @return
* @throws Exception
*/
private static byte[] decrypt(byte[] data, byte[] key) throws Exception {
// 初始化向量
IvParameterSpec iv = new IvParameterSpec(ivByte);
// 从原始密钥数据创建DESKeySpec对象
DESKeySpec dks = new DESKeySpec(key);
// 创建一个密钥工厂，然后用它把DESKeySpec转换成SecretKey对象
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(DES);
SecretKey secureKey = keyFactory.generateSecret(dks);
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
// 用密钥初始化Cipher对象
cipher.init(Cipher.DECRYPT_MODE, secureKey, iv);
return cipher.doFinal(data);
}
}
AES加密
public class AESUtil {
public static String PLAN_PASSWORD = "PLAN_PASSWORD";
public static String encrypt(String bef_aes, String password) {
byte[] byteContent = null;
try {
byteContent = bef_aes.getBytes("utf-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return encrypt(byteContent,password);
}
public static String encrypt(byte[] content, String password) {
try {
SecretKey secretKey = getKey(password);
byte[] enCodeFormat = secretKey.getEncoded();
SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
Cipher cipher = Cipher.getInstance("AES");// 创建密码器
cipher.init(Cipher.ENCRYPT_MODE, key);// 初始化
byte[] result = cipher.doFinal(content);
String aft_aes = parseByte2HexStr(result);
return aft_aes; // 加密
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
public static String decrypt(String aft_aes, String password) {
try {
byte[] content = parseHexStr2Byte(aft_aes);
SecretKey secretKey = getKey(password);
byte[] enCodeFormat = secretKey.getEncoded();
SecretKeySpec key = new SecretKeySpec(enCodeFormat, "AES");
Cipher cipher = Cipher.getInstance("AES");// 创建密码器
cipher.init(Cipher.DECRYPT_MODE, key);// 初始化
byte[] result = cipher.doFinal(content);
String bef_aes = new String(result);
return bef_aes; // 加密
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
} catch (NoSuchPaddingException e) {
e.printStackTrace();
} catch (InvalidKeyException e) {
e.printStackTrace();
} catch (IllegalBlockSizeException e) {
e.printStackTrace();
} catch (BadPaddingException e) {
e.printStackTrace();
}
return null;
}
public static String parseByte2HexStr(byte buf[]) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < buf.length; i++) {
String hex = Integer.toHexString(buf[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
sb.append(hex.toUpperCase());
}
return sb.toString();
}
public static byte[] parseHexStr2Byte(String hexStr) {
if (hexStr.length() < 1)
return null;
byte[] result = new byte[hexStr.length()/2];
for (int i = 0;i< hexStr.length()/2; i++) {
int value = Integer.parseInt(hexStr.substring(i*2, i*2+2), 16);
result[i] = (byte)value;
}
return result;
}
public static SecretKey getKey(String strKey) {
try {
KeyGenerator _generator = KeyGenerator.getInstance("AES");
SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
secureRandom.setSeed(strKey.getBytes());
_generator.init(128,secureRandom);
return _generator.generateKey();
} catch (Exception e) {
throw new RuntimeException("初始化密钥出现异常");
}
}
}
测试类：
String content = "9606b072a2d54f68a873684c288df9c9|10000002";
String password = "12345678";
// 加密
System.out.println("加密前：" + content);
String str = AESUtil.encrypt(content, AESUtil.PLAN_PASSWORD);
System.out.println("加密后："+str);
String s1 = AESUtil.decrypt(str, AESUtil.PLAN_PASSWORD);
System.out.println("解密后：" +s1);
MD5加密：
这个加密是不可逆转的
public final class Md5Util {
public static String md5Hex(String data) {
try {
StringBuffer sb = new StringBuffer();
MessageDigest digest = MessageDigest.getInstance("MD5");
digest.update(data.getBytes());
byte b[] = digest.digest();
int i;
for (int offset = 0; offset < b.length; offset++) {
i = b[offset];
if (i < 0)
i += 256;
if (i < 16)
sb.append("0");
sb.append(Integer.toHexString(i));
}
return sb.toString();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
return null;
}
}
非对称加密：就是加密和解密用到的不是同一个密钥，通常是用2个，一个是私钥一个是公钥必须配对使用，通常公钥是公开的，进行加密。私钥是不可公开
是用做解密的。
RSA加密，现在通常用的都是2048.
public class RSA2048Utils {
public static final String KEY_ALGORITHM = "RSA";
public static final String SIGNATURE_ALGORITHM = "SHA256withRSA";
public static final int KEY_SIZE = 2048;
public static String PUBLIC_KEY ="publicKey";
public static String PRIVATE_KEY = "privateKey";
private static final int MAX_ENCRYPT_BLOCK = 245;
private static final int MAX_DECRYPT_BLOCK = 256;
public RSA2048Utils() {
}
public static Map<String, Object> genKeyPair() throws Exception {//该方法是生成一对公私钥
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
keyPairGen.initialize(KEY_SIZE, new SecureRandom());
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey)keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey)keyPair.getPrivate();
Map<String, Object> keyMap = new HashMap(2);
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
public static String privateKeySign(String dataStr,String privateKey) throws Exception {
byte[] data = (new BASE64Decoder()).decodeBuffer(dataStr);
RSAPrivateKey privateKeyRsa = loadPrivateKey(privateKey);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(privateKeyRsa);
signature.update(data);
return (new BASE64Encoder()).encodeBuffer(signature.sign());
}
public static boolean publicKeyVerify(String dataStr, String sign,String publicKey) throws Exception {
byte[] data = (new BASE64Decoder()).decodeBuffer(dataStr);
RSAPublicKey publicKeyRsa = loadPublicKey(publicKey);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initVerify(publicKeyRsa);
signature.update(data);
return signature.verify((new BASE64Decoder()).decodeBuffer(sign));
}
public static byte[] decryptByPrivateKey(byte[] encryptedData, RSAPrivateKey privateKeyRsa) throws Exception {
if (privateKeyRsa == null) {
throw new Exception("解密私钥为空，请设置");
} else {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(2, privateKeyRsa);
return partitionAlgorithm(encryptedData, cipher, MAX_DECRYPT_BLOCK);
} catch (NoSuchAlgorithmException var3) {
throw new Exception("无此解密算法");
} catch (NoSuchPaddingException var4) {
var4.printStackTrace();
return null;
} catch (InvalidKeyException var5) {
throw new Exception("解密私钥非法,请检查");
} catch (IllegalBlockSizeException var6) {
throw new Exception("密文长度非法");
} catch (BadPaddingException var7) {
throw new Exception("密文数据已损坏");
}
}
}
public static byte[] decryptByPublicKey(byte[] encryptedData, RSAPublicKey publicKeyRsa) throws Exception {
if (publicKeyRsa == null) {
throw new Exception("解密公钥为空，请设置");
} else {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(2, publicKeyRsa);
return partitionAlgorithm(encryptedData, cipher, MAX_DECRYPT_BLOCK);
} catch (NoSuchAlgorithmException var3) {
throw new Exception("无此解密算法");
} catch (NoSuchPaddingException var4) {
var4.printStackTrace();
return null;
} catch (InvalidKeyException var5) {
throw new Exception("解密公钥非法,请检查");
} catch (IllegalBlockSizeException var6) {
throw new Exception("密文长度非法");
} catch (BadPaddingException var7) {
throw new Exception("密文数据已损坏");
}
}
}
public static byte[] encryptByPublicKey(byte[] data, RSAPublicKey publicKeyRsa) throws Exception {
if (publicKeyRsa == null) {
throw new Exception("加密公钥为空，请设置");
} else {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(1, publicKeyRsa);
return partitionAlgorithm(data, cipher, MAX_ENCRYPT_BLOCK);
} catch (NoSuchAlgorithmException var3) {
throw new Exception("无此加密算法");
} catch (NoSuchPaddingException var4) {
var4.printStackTrace();
return null;
} catch (InvalidKeyException var5) {
throw new Exception("加密公钥非法,请检查");
} catch (IllegalBlockSizeException var6) {
throw new Exception("明文长度非法");
} catch (BadPaddingException var7) {
throw new Exception("明文数据已损坏");
}
}
}
public static byte[] encryptByPrivateKey(byte[] data, RSAPrivateKey privateKeyRsa) throws Exception {
if (privateKeyRsa == null) {
throw new Exception("加密私钥为空，请设置");
} else {
try {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(1, privateKeyRsa);
return partitionAlgorithm(data, cipher, MAX_ENCRYPT_BLOCK);
} catch (NoSuchAlgorithmException var3) {
throw new Exception("无此加密算法");
} catch (NoSuchPaddingException var4) {
var4.printStackTrace();
return null;
} catch (InvalidKeyException var5) {
throw new Exception("加密私钥非法,请检查");
} catch (IllegalBlockSizeException var6) {
throw new Exception("明文长度非法");
} catch (BadPaddingException var7) {
throw new Exception("明文数据已损坏");
}
}
}
public static byte[] partitionAlgorithm(byte[] data, Cipher cipher, int maxBlock) throws IOException, BadPaddingException, IllegalBlockSizeException {
int inputLen = data.length;
try {
ByteArrayOutputStream out = new ByteArrayOutputStream();
Throwable var5 = null;
byte[] var10;
try {
int offSet = 0;
for(int i = 0; inputLen - offSet > 0; offSet = i * maxBlock) {
byte[] cache;
if (inputLen - offSet > maxBlock) {
cache = cipher.doFinal(data, offSet, maxBlock);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] encryptedData = out.toByteArray();
var10 = encryptedData;
} catch (Throwable var20) {
var5 = var20;
throw var20;
} finally {
if (out != null) {
if (var5 != null) {
try {
out.close();
} catch (Throwable var19) {
var5.addSuppressed(var19);
}
} else {
out.close();
}
}
}
return var10;
} catch (IllegalBlockSizeException | IOException | BadPaddingException var22) {
throw var22;
}
}
public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key)keyMap.get(PRIVATE_KEY);
return (new BASE64Encoder()).encodeBuffer(key.getEncoded());
}
public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key)keyMap.get(PUBLIC_KEY);
return (new BASE64Encoder()).encodeBuffer(key.getEncoded());
}
public static RSAPublicKey loadPublicKey(String publicKeyStr) throws Exception {
try {
BASE64Decoder base64Decoder = new BASE64Decoder();
byte[] buffer = base64Decoder.decodeBuffer(publicKeyStr);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
return (RSAPublicKey)keyFactory.generatePublic(keySpec);
} catch (NoSuchAlgorithmException var5) {
throw new Exception("无此算法");
} catch (InvalidKeySpecException var6) {
throw new Exception("公钥非法");
} catch (IOException var7) {
throw new Exception("公钥数据内容读取错误");
} catch (NullPointerException var8) {
throw new Exception("公钥数据为空");
}
}
public static RSAPrivateKey loadPrivateKey(String privateKeyStr) throws Exception {
try {
BASE64Decoder base64Decoder = new BASE64Decoder();
byte[] buffer = base64Decoder.decodeBuffer(privateKeyStr);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
return (RSAPrivateKey)keyFactory.generatePrivate(keySpec);
} catch (NoSuchAlgorithmException var5) {
throw new Exception("无此算法");
} catch (InvalidKeySpecException var6) {
var6.printStackTrace();
throw new Exception("私钥非法");
} catch (IOException var7) {
throw new Exception("私钥数据内容读取错误");
} catch (NullPointerException var8) {
throw new Exception("私钥数据为空");
}
}
public static String decryptPrivateWithBase64(String base64String,String privateKey) throws Exception {
RSAPrivateKey privateKeyRsa = loadPrivateKey(privateKey);
byte[] binaryData = decryptByPrivateKey((new BASE64Decoder()).decodeBuffer(base64String), privateKeyRsa);
String string = new String(binaryData);
return string;
}
public static String encryptPublicWithBase64(String string,String publicKey) throws Exception {
RSAPublicKey publicKeyRsa = loadPublicKey(publicKey);
byte[] binaryData = encryptByPublicKey(string.getBytes("utf-8"), publicKeyRsa);
String base64String = (new BASE64Encoder()).encodeBuffer(binaryData);
return base64String;
}
public static String decryptPublicWithBase64(String base64String,String publicKey) throws Exception {
RSAPublicKey publicKeyRsa = loadPublicKey(publicKey);
byte[] binaryData = decryptByPublicKey((new BASE64Decoder()).decodeBuffer(base64String), publicKeyRsa);
String string = new String(binaryData);
return string;
}
public static String encryptPrivateWithBase64(String string,String privateKey) throws Exception {
RSAPrivateKey privateKeyRsa = loadPrivateKey(privateKey);
byte[] binaryData = encryptByPrivateKey(string.getBytes("utf-8"), privateKeyRsa);
String base64String = (new BASE64Encoder()).encodeBuffer(binaryData);
return base64String;
}
public static void main(String[] args) throws Exception {
String publicKey = "XXXXXXXXXXXXXXXXXXXXXX";
String data = "xxxxxxxxxxxxxxxxxxxx";
encryptPublicWithBase64(data,publicKey);//进行公钥加密
String privateKey = "MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQCcVRBdx/3PbT4A3l+X3SvO39KLthjMI/QmN3yR0ON9eY+FeHUpA5DYea2/ziIR4SYaYcmSISTcCuTOJgByc/Ha1LNSwN8H7+MbZcG7+GKJCBlF7YSbSyiinRDTqEYnTwZ7gsUvEmRH/GDy27svuw9XeRgRGcjas8+dEj3RHuzyLCtVD3eXGIBZPI5/ERuC8vMCNFl8hDp1B4fgh2JZykaEHD8erYg4mBW+Sf8d1gn4mw5gMEyyzj7S3+otJ4+US3eENDVc7dIvrRz9K44dYpxTK/S1Rp+1nzx5M12ZsSS5tvqmbeiSwvA0nBwvVIvWcweI5hzqBBIIa6qAOLCe1BmFAgMBAAECggEBAJkhjaV/F7PN+vUY3aRBBf9fKLqnhUS5Vxb0NPYUGjG3GAmSQ5kIICKblcESpjbDRvKCpNKZ2qQbm6H+gWObBOXogTrnJ9B7fwdANnPsSoCVyUPA86q2BTi8B1Z8NzOb6eqj3ohMSKRmp4RcDdAkOFPjjtp5WlA3336o9ppX45sWdvPEPMjSholHvC6w1qAMhCz+/+oFfnem9GvtdoxENb8kjY3Y8GMzGDtWU2mBTIpSPBuo0+LTpkvTSxa2/YIApHi00CqTsdlonQiNktay50FBc0rlEtwMTYRG9jyUZWhjQdyedV8hRA2e02pV7aszPrTw/loKjDB0JmGX6LiZxSUCgYEAyNOtbXqkjhQPZrKUU+j03giM8DR6oLmFxM8yBI6Gpqovi0cYeMJYTYjb0vFO4g5TGGTYbpdP+OZ8TCS+Gnpb7l/dRYeaYTPjeUQ+JjqydI89IoEB1gPNzsByMbz76RoG584blSJ0izmSH+T+EflAv1Ttdr29hXQ9GxltV9GS+zsCgYEAx0gLfznfwKFXrRIt0rAuKqGU41dmq8XclLq3w8Gkdx4zC57+IqOQrYhCf6X1iRGUCQ1YOnOQEgcRyXfujQ9ycWWbi1iN/kTGgd9ylBb4R56iviLM6wdPF2oSiIurF4PBFbRs+QgkHE1xxOcJ+iL+/6jH1CUN0jDTxgAN3/rYcj8CgYBzuKYCo90WkbCeOOEHyQDwwHSWJWdUHhNa6RmlTouAlih3VSxgyXwgkXA6CRqvYBm5wMKGV2KZxhZxuephT4iRv2O9oPnwcPnu8sftN32FdNSBgV0ReXeqX3Jt/rwaAglgoX97XDNT1oTBJC7TJJGOrt12wrbmo6hiaTB8niLX6QKBgDnN+hfDb9XudwIq3cPZeuq+x/NR7OQylpNFvfw4dT5gMipSyiC+FT9g4Pkp6JkD0k714fvCfa3dAxnPghDExEuET6QR4c45oOMXL6MpLoeHymkgqxQZoKWIDSwyZ0SA4UcseNebtu3GwRN+ePRnplP+X0h4HxQzOZqbdWrc1l/9AoGBAJ4u1ASDy6Dgc7Vkf7Fr4mc+FpajA/1oU43z4VPFt9S65Q4pdy9uKBZspWEbSD+jZy54Pi6b+0qhxLmpRDM4nD4GeDSWbySBERSrI4yRTKc8eon4h18IeNfklbGT3dJ6llV/kJxFUKAcyct+IfW29LeTXUYNiq6dCA/Y8gZdF6Mj";
String resultData = "Y0JPwMJn1dVqnZNCxPouzHUiir8OOtuofa39Z5dqzv7IpHajbkH/eSB/R8qPJ+wjg4UlHEFuCJec0xUpiGnTB6AsNDOACsv6aS3DdXfw7FVeMFSqgjsk5NVm+YQNgldtf+tLWmlBcIu2ASvJ0B8rN5E1LxPhFC4cSN5752q+ObAeUDxZZkihqRmqsQkTZlDlLhvWtvZktbgvyjUcVqw001jiVYSczK1TlgCsBPvhAt/r3/xuTnlXzlnGFAxlwTESeIHzSUywPpllJkoGHpdXRhMhobRPSgYRxiHp/UGpk70M0xkI1DogIiJRoavIY5WGqkNS0X8VLkUgn2hqgvA/4oEKQsVVbiXhgK42DmBcaRSJJ48GrKH/1L8C3RHAJIAHaFEvFxwakt7ORFl9HAvJK/KNTDPPsAPqZPlAcxUtI5ffTD7hkewtmkmALkuacM/7R/Tpcm3NJcWZmhZi6iOgyr1I3xQibW3913ShvgT4AhWBRSwtiTJCVugOzb3RJFa1tYf6a+3LHiy4/oCfUdZ95cfqCCnVdRpfhWzpBYq6+xvl17+w5CTSeVzh4zL7RiSLPoXwB/iauy3AP+qj1rw/oEBGiNNdUOtqhtt5ma70pf6p/++EQZJH/pykqaFn94qToQX32wk5eZz4CnQHlYQGG/S5qdPHWPn880XaNe0ZqksBHXib6Uw9JOvNX6TPmjWQ3s/qfvsZz+9xa42T7jam7EtTMdHW4FdKZbBK+fcexq7PDHDbxoU+XyJLqZdjz9N2BYdX9R537psWhCgNA4NwH4kkjsq6nyl+wHlaHtdpexrZTa7jn2kkISjrvPdU71/jBp33ayyalPs3zjGrUi+Q9RLyDCV3+G5CvHgHEoEuE713fVZA0cGwzaYAOHDK/etGfBK0BO8uaOw3mIDNWcfKEmAIy+NrcxmVwSTAgKPAN49JTmjYLFQRrByaRxX2mum2peEfgjgRW05TiwZ6ySOa48hVS/oMEwA4BOmT4hVX5ajRHYjVvKIUxYh3kZah6+dOMqT01t/DzOion5cB+Y3wqGAG0jmozmxhsjMlt/8U3F3KD82ytCcA8iFAvHaRw5CPXZQaKIn7MU6yI69hln8QFWoUP9x0/XI2/uT6B4MxlzPag0yIkqQLLinKskQ/uVz1vODR5fZEqkya82/JMuhbYCmUFEUgJMFz95P+Mu8dI5Da1bXj2YDXHkVdHw4ymaBt8FXTs1tbmKsxJr/UW8n8X2HRtveeMzLSfcd/Mv4Mcfimax5CXGXEd106ZZu1DrB3MuMP/oBgYJ3ijl6s4/6JdvbVrN7VgzDdybC6WepD2GSBKG9aS8nt6K3jpsYTvCJhTLNsgCeAhLiI3zlRVB/TnGvBwaHQy9vks79FsW58eSHW8zNAAimjZp/zHCpL1rX/MLfZDwsTJwP1f3Ig+k5ZjMLjJ3WKaTmP9Lu4+9NYL2PwfJANF1X7Gs/slqpnMASczccubAB8EpNh4B2vpVPxWMo/WLGgT0o783FvHhpB2hiUJgWpmjYcTi72HL/R09XgdexJLXMbn4SS3v39m3LFPL+dlADFt5GMs/PlvgIjOwyV7EROf4JPGS9fQTPp/1xqidr+J/2Q+2IHM5Yy8b84esNSUyExyOYIg4Gp442yS8cCZKEBb/qX/E+6UJLSEhAvZXpospJDu9+***+PLPGtUspNf5U70I8MnM9YXhPXerI=";
System.out.println("-------->>>"+decryptPrivateWithBase64(resultData,privateKey));//进行私钥解密
}
}
