MD5,RSA与springCode的加解密方法
1：使用MD5加密：
String passwordMD5 = MD5Util.MD5Encode(password, "utf-8");
生成的密文格式有：
| 字符串 | 123456 |
| 16位 小写 | 49ba59abbe56e057 |
| 16位 大写 | 49BA59ABBE56E057 |
| 32位 小写 | e10adc3949ba59abbe56e057f20f883e |
| 32位 大写 | E10ADC3949BA59ABBE56E057F20F883E |
实例：
2，使用spring-security-core-3.2.7.RELEASE.jar包里的加密方法：
String password11="123456";
对password11进行加密：
String passwordMs=passwordEncoder.encode(password11); //passwordEncoder是jar包里方法
passwordMs=1d2532956c63d55922e465915de6678f80db72a2755a9ea624ed9b3019826cb4e33ee691ec9fdf65 //是64位，比之MD5安全
验证输入密码password22是否正确
String password22="123456";
passwordEncoder.matches(password22,passwordMs);//结果是boolean类型 返回true是密码验证一致 false 是不一致
3：使用RSA加解密方式：
对称加密算法在加密和解密时使用的是同一个秘钥，加解密双方必须使用同一个**才能进行正常的沟通，例如简单的MD5等。而非对称加密则不然，非对称加密算法需要两个**来进行加密和解密，分别是公钥和私钥，就是RSA了。需要注意的一点，这个公钥和私钥必须是一对的，如果用公钥对数据进行加密，那么只有使用对应的私钥才能解密，反之亦然。由于加密和解密使用的是两个不同的**，因此，这种算法叫做非对称加密算法。
RSA的工具类源码：
/*** Eclipse Class Decompiler plugin, copyright (c) 2016 Chen Chao ([email protected]) ***/
package org.alqframework.security;
import java.io.ByteArrayOutputStream;
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.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import org.alqframework.encode.EncodeUtils;
public class RSAUtils {
public static final String KEY_ALGORITHM = "RSA";
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
private static final String PUBLIC_KEY = "RSAPublicKey";
private static final String PRIVATE_KEY = "RSAPrivateKey";
private static final int MAX_ENCRYPT_BLOCK = 117;
private static final int MAX_DECRYPT_BLOCK = 128;
public static Map<String, Object> genKeyPair() throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
HashMap keyMap = new HashMap(2);
keyMap.put("RSAPublicKey", publicKey);
keyMap.put("RSAPrivateKey", privateKey);
return keyMap;
}
public static String sign(byte[] data, String privateKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(privateK);
signature.update(data);
return EncodeUtils.base64Encode(signature.sign());
}
public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(publicKey);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicK = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initVerify(publicK);
signature.update(data);
return signature.verify(EncodeUtils.base64Decode(sign));
}
public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(2, privateK);
int inputLen = encryptedData.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 128) {
byte[] cache;
if (inputLen - offSet > 128) {
cache = cipher.doFinal(encryptedData, offSet, 128);
} else {
cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;
}
public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicK = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(2, publicK);
int inputLen = encryptedData.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 128) {
byte[] cache;
if (inputLen - offSet > 128) {
cache = cipher.doFinal(encryptedData, offSet, 128);
} else {
cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;
}
public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicK = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(1, publicK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 117) {
byte[] cache;
if (inputLen - offSet > 117) {
cache = cipher.doFinal(data, offSet, 117);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(1, privateK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 117) {
byte[] cache;
if (inputLen - offSet > 117) {
cache = cipher.doFinal(data, offSet, 117);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get("RSAPrivateKey");
return EncodeUtils.base64Encode(key.getEncoded());
}
public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get("RSAPublicKey");
return EncodeUtils.base64Encode(key.getEncoded());
}
}
package org.alqframework.security;
import java.io.ByteArrayOutputStream;
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.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;
import javax.crypto.Cipher;
import org.alqframework.encode.EncodeUtils;
public class RSAUtils {
public static final String KEY_ALGORITHM = "RSA";
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
private static final String PUBLIC_KEY = "RSAPublicKey";
private static final String PRIVATE_KEY = "RSAPrivateKey";
private static final int MAX_ENCRYPT_BLOCK = 117;
private static final int MAX_DECRYPT_BLOCK = 128;
public static Map<String, Object> genKeyPair() throws Exception {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
HashMap keyMap = new HashMap(2);
keyMap.put("RSAPublicKey", publicKey);
keyMap.put("RSAPrivateKey", privateKey);
return keyMap;
}
public static String sign(byte[] data, String privateKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initSign(privateK);
signature.update(data);
return EncodeUtils.base64Encode(signature.sign());
}
public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(publicKey);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicK = keyFactory.generatePublic(keySpec);
Signature signature = Signature.getInstance("MD5withRSA");
signature.initVerify(publicK);
signature.update(data);
return signature.verify(EncodeUtils.base64Decode(sign));
}
public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(2, privateK);
int inputLen = encryptedData.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 128) {
byte[] cache;
if (inputLen - offSet > 128) {
cache = cipher.doFinal(encryptedData, offSet, 128);
} else {
cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;
}
public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicK = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(2, publicK);
int inputLen = encryptedData.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 128) {
byte[] cache;
if (inputLen - offSet > 128) {
cache = cipher.doFinal(encryptedData, offSet, 128);
} else {
cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] decryptedData = out.toByteArray();
out.close();
return decryptedData;
}
public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicK = keyFactory.generatePublic(x509KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(1, publicK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 117) {
byte[] cache;
if (inputLen - offSet > 117) {
cache = cipher.doFinal(data, offSet, 117);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
byte[] keyBytes = EncodeUtils.base64Decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(1, privateK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
for (int i = 0; inputLen - offSet > 0; offSet = i * 117) {
byte[] cache;
if (inputLen - offSet > 117) {
cache = cipher.doFinal(data, offSet, 117);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
++i;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get("RSAPrivateKey");
return EncodeUtils.base64Encode(key.getEncoded());
}
public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
Key key = (Key) keyMap.get("RSAPublicKey");
return EncodeUtils.base64Encode(key.getEncoded());
}
}
编写自己的工具类：
package com.alqsoft.utils;
import java.io.UnsupportedEncodingException;
import java.util.Map;
import org.alqframework.security.RSAUtils;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
* @author sunhuijie
*
* @date 2017年3月30日
*
*/
public class RSACommonUtils {
private static Logger logger = LoggerFactory.getLogger(RSACommonUtils.class);
private static String publicKey = ""; //需要生成自己的一对公私钥
private static String privateKey = "";
public static enum CharSet {
UTF8 {
public String getName() {
return "UTF-8";
}
};
public abstract String getName();
}
/**
* 创建公钥 私钥
* @return
*/
public static Map<String, Object> createRSAKey() {
Map<String, Object> keyMap = null;
try {
keyMap = RSAUtils.genKeyPair();
logger.info("公钥-->"+RSAUtils.getPublicKey(keyMap));
logger.info("私钥-->"+RSAUtils.getPrivateKey(keyMap));
} catch (Exception e) {
// TODO Auto-generated catch block
logger.info("获取公私钥失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return keyMap;
}
/**
* 根据公钥加密
* @param content 需加密内容
* @param charSet 字符集编码格式
* @return
*/
public static String encryptByPublicKey(String content, CharSet charSet) {
byte[] b=null;
try {
b = encrypt(content.getBytes(charSet.getName()),true);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return bytesToString(b);
}
/**
* 根据私钥加密
* @param content
* @param charSet
* @return
*/
public static String encryptByPrivateKey(String content, CharSet charSet) {
byte[] b=null;
try {
b = encrypt(content.getBytes(charSet.getName()),false);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return bytesToString(b);
}
/**
* 根据私钥解密字符串
* @param content 学解密内容
* @param charSet 字符集编码格式
* @return
*/
public static String decryptByPrivateKey(String content, CharSet charSet) {
byte[] b = decrypt(stringToBytes(content),false);
try {
return new String(b, charSet.getName());
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return null;
}
/**
* 根据公钥解密字符串
* @param content
* @param charSet
* @return
*/
public static String decryptByPublicKey(String content, CharSet charSet) {
byte[] b = decrypt(stringToBytes(content),true);
try {
return new String(b, charSet.getName());
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return null;
}
/**
* 字符串转换成为字节数组
* @param decrytString
* @return
*/
private static byte[] stringToBytes(String decrytString) {
char[] charHex=decrytString.toCharArray();
byte[] clone=null;
try {
clone = Hex.decodeHex(charHex);
} catch (DecoderException e) {
// TODO Auto-generated catch block
logger.info("字符串转换字节数组失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return clone;
}
/**
* 字节数组转换为字符串
* @param decrytString
* @return
*/
private static String bytesToString(byte[] encrytpByte) {
char[] charHex=Hex.encodeHex(encrytpByte);
return new String(charHex);
}
/**
* 加密
* @param data
* @return
*/
private static byte[] encrypt(byte[] data,boolean isPublicKey) {
try {
if(isPublicKey){
return RSAUtils.encryptByPublicKey(data, publicKey);
}
return RSAUtils.encryptByPrivateKey(data, privateKey);
} catch (Exception e) {
// TODO Auto-generated catch block
logger.info("加密失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return null;
}
/**
* 解密
* @param data
* @return
*/
private static byte[] decrypt(byte[] data,boolean isPublicKey) {
try {
if(isPublicKey){
return RSAUtils.decryptByPublicKey(data, publicKey);
}
return RSAUtils.decryptByPrivateKey(data, privateKey);
} catch (Exception e) {
// TODO Auto-generated catch block
logger.info("私钥解密失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return null;
}
public static void main(String[] args) throws Exception {
/**
* RSAUtilsLieTouToPuHui.createRSAKey();
*/
/*测试信息*/
String kk= RSACommonUtils.encryptByPrivateKey("18822119676", RSACommonUtils.CharSet.UTF8) ;
System.out.println(kk );
System.out.println(RSACommonUtils.decryptByPublicKey(kk, RSACommonUtils.CharSet.UTF8));
}
}
import java.io.UnsupportedEncodingException;
import java.util.Map;
import org.alqframework.security.RSAUtils;
import org.apache.commons.codec.DecoderException;
import org.apache.commons.codec.binary.Hex;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
* @author sunhuijie
*
* @date 2017年3月30日
*
*/
public class RSACommonUtils {
private static Logger logger = LoggerFactory.getLogger(RSACommonUtils.class);
private static String publicKey = ""; //需要生成自己的一对公私钥
private static String privateKey = "";
public static enum CharSet {
UTF8 {
public String getName() {
return "UTF-8";
}
};
public abstract String getName();
}
/**
* 创建公钥 私钥
* @return
*/
public static Map<String, Object> createRSAKey() {
Map<String, Object> keyMap = null;
try {
keyMap = RSAUtils.genKeyPair();
logger.info("公钥-->"+RSAUtils.getPublicKey(keyMap));
logger.info("私钥-->"+RSAUtils.getPrivateKey(keyMap));
} catch (Exception e) {
// TODO Auto-generated catch block
logger.info("获取公私钥失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return keyMap;
}
/**
* 根据公钥加密
* @param content 需加密内容
* @param charSet 字符集编码格式
* @return
*/
public static String encryptByPublicKey(String content, CharSet charSet) {
byte[] b=null;
try {
b = encrypt(content.getBytes(charSet.getName()),true);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return bytesToString(b);
}
/**
* 根据私钥加密
* @param content
* @param charSet
* @return
*/
public static String encryptByPrivateKey(String content, CharSet charSet) {
byte[] b=null;
try {
b = encrypt(content.getBytes(charSet.getName()),false);
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return bytesToString(b);
}
/**
* 根据私钥解密字符串
* @param content 学解密内容
* @param charSet 字符集编码格式
* @return
*/
public static String decryptByPrivateKey(String content, CharSet charSet) {
byte[] b = decrypt(stringToBytes(content),false);
try {
return new String(b, charSet.getName());
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return null;
}
/**
* 根据公钥解密字符串
* @param content
* @param charSet
* @return
*/
public static String decryptByPublicKey(String content, CharSet charSet) {
byte[] b = decrypt(stringToBytes(content),true);
try {
return new String(b, charSet.getName());
} catch (UnsupportedEncodingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
logger.info("不支持的编码格式，错误信息"+e.getMessage());
}
return null;
}
/**
* 字符串转换成为字节数组
* @param decrytString
* @return
*/
private static byte[] stringToBytes(String decrytString) {
char[] charHex=decrytString.toCharArray();
byte[] clone=null;
try {
clone = Hex.decodeHex(charHex);
} catch (DecoderException e) {
// TODO Auto-generated catch block
logger.info("字符串转换字节数组失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return clone;
}
/**
* 字节数组转换为字符串
* @param decrytString
* @return
*/
private static String bytesToString(byte[] encrytpByte) {
char[] charHex=Hex.encodeHex(encrytpByte);
return new String(charHex);
}
/**
* 加密
* @param data
* @return
*/
private static byte[] encrypt(byte[] data,boolean isPublicKey) {
try {
if(isPublicKey){
return RSAUtils.encryptByPublicKey(data, publicKey);
}
return RSAUtils.encryptByPrivateKey(data, privateKey);
} catch (Exception e) {
// TODO Auto-generated catch block
logger.info("加密失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return null;
}
/**
* 解密
* @param data
* @return
*/
private static byte[] decrypt(byte[] data,boolean isPublicKey) {
try {
if(isPublicKey){
return RSAUtils.decryptByPublicKey(data, publicKey);
}
return RSAUtils.decryptByPrivateKey(data, privateKey);
} catch (Exception e) {
// TODO Auto-generated catch block
logger.info("私钥解密失败，错误信息"+e.getMessage());
e.printStackTrace();
}
return null;
}
public static void main(String[] args) throws Exception {
/**
* RSAUtilsLieTouToPuHui.createRSAKey();
*/
/*测试信息*/
String kk= RSACommonUtils.encryptByPrivateKey("18822119676", RSACommonUtils.CharSet.UTF8) ;
System.out.println(kk );
System.out.println(RSACommonUtils.decryptByPublicKey(kk, RSACommonUtils.CharSet.UTF8));
}
}