什么是非对称加密：
服务器生成两把钥匙，一把公钥，一把私钥，（私钥加密，公钥解密）或者（公钥加密，私钥解密）
服务器公钥：服务器生成，保存在数字证书里，用于解密私钥加密的数据，或者加密数据
服务器私钥：服务器生成，服务器安全保存，用于解密公钥加密的数据，或者加密数据
数字签名：将全部数据经过不可逆的加密后（MD5）生成的字符串，用于验证服务器数据有没有被篡改过
CA证书公钥：CA证书签发机构生成，保存在客户端，用于解密数字证书
CA证书私钥：CA证书签发机构生成，保存在CA证书签发机构服务器，用于加密服务器公钥
数字证书：CA证书签发机构生成通过服务器公钥生成，保存在服务器里，用于服务器发送给客户端获取服务器公钥
非对称加密流程：
1.服务器生成两把钥匙，公钥和私钥
2.再去CA证书签发机构，为服务器的公钥生成一个数字证书
3.服务器和客户端交互时，将签发机构生成的数字证书和签发机构的公钥一起发送给客户端
4.客户端拿着签发机构的公钥和数字证书，去签发机构获取服务器的公钥
5.客户端拿着服务器的公钥解密服务器的数据
服务器端代码：
public class RSAUtils {
public static void main(String[] args) throws Exception {
String publicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCapIG/XijKqbesb0LC9CdmcKbnzPJMIsa6tRbIwi1FKm3GSYkzYoJWQmHYq5WxVxDosc5aj2b0wBvhQ4WwLgaaNjyC5hcIfhSwAqMFD/bqi48LA4wBrTD62sxNFBzwiOb+q/8AYQPgD6jA/mrqUvUZSNrS3TI7x9zO1FGQi7nZ1wIDAQAB";
String privateKey ="MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAJqkgb9eKMqpt6xvQsL0J2ZwpufM8kwixrq1FsjCLUUqbcZJiTNiglZCYdirlbFXEOixzlqPZvTAG+FDhbAuBpo2PILmFwh+FLACowUP9uqLjwsDjAGtMPrazE0UHPCI5v6r/wBhA+APqMD+aupS9RlI2tLdMjvH3M7UUZCLudnXAgMBAAECgYB13Pg/AOcaP+yL8mjx6eC1xRqRBbWOrdrFpwvsi4KxerscLCP0FBq+3+1vlKeM+I0crZhXkYCo/lrBgBM+ynWgmHU5XjV+rBl+hHEEOsylUW6ari6r/3rae7RzVxjEzYoHb0ZKN5Hs6odVFXeblLUWNUicPTkzusXzoYTocrPdgQJBAMd2Ykc243FKOPSaCYRtbmH0OOEWPqkrOaPzMjQKFNKMbaYu+4E/+njHUptbbOWlsrktJIVvsmPW/BDsapDUCeECQQDGedswNZ32yGGPdQbsfVu9lokg2AJu6GCx7aQg4qwea5jwgPOCyNMgWG2ns/CJItvNPLxoMaT+qN84U8OcRAq3AkEAgskhD8jxwWsFhX0rGGYYpqnYUd6gH5R0KwhftreVh6kEjJ7p0on81gz8IVoFQV8wnTL4a3Yd5lEk3oPmLCicgQJARBX1XTpncAsZfK72qxXt7MHBVOUFIKrS0PbmwOlBhkX+9zIlVw4xbv0m0MrnjwPIR0W4lD3DjiC8QoRprCejTQJBAMTOGWYGaoJ9WlQUI2aoPpkPsDy7vfL2z0PxFl3ZkETLdmT9knSMQX4biZD4irXWicy9w1wD5vxYaAKyYofkLFE=";
//生成公私钥
//generateKeyStr();
//明文
String ming = "312313123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111113123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111312311111111111111111111111111111111111111111111111111111111111111111111131231111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111131231111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111131231111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111131231111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111";
//加密后的密文
String mi = encrypt(ming,publicKey);
System.err.println(mi);
//解密后的明文
//RSACoder.decryptByPrivateKey(mi.getBytes());
ming = decrypt(mi,privateKey);
System.err.println(ming);
}
public static void generateKeyStr() throws Exception{
HashMap<String, Object> map = RSAUtils.getKeys();
//生成公钥和私钥
RSAPublicKey publicKey = (RSAPublicKey) map.get("public");
RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private");
String publicKeyStr = getKeyString(publicKey);
String privateKeyStr = getKeyString(privateKey);
//System.out.println("publicKey:------------");
System.out.println(publicKeyStr);
//System.out.println("privateKey:-----------");
System.out.println(privateKeyStr);
}
/**
* 生成公钥和私钥
* @throws NoSuchAlgorithmException
*
*/
public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException {
HashMap<String, Object> map = new HashMap<String, Object>();
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");
keyPairGen.initialize(1024);
KeyPair keyPair = keyPairGen.generateKeyPair();
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
map.put("public", publicKey);
map.put("private", privateKey);
return map;
}
/**
* 得到公钥
*
* @param key
* 密钥字符串（经过base64编码）
* @throws Exception
*/
public static RSAPublicKey getPublicKey(String key) throws Exception {
byte[] keyBytes = (new BASE64Decoder()).decodeBuffer(key);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return (RSAPublicKey) keyFactory.generatePublic(keySpec);
}
/**
* 得到公钥
*
* @param key
* 密钥字符串（经过base64编码）
* @throws Exception
*/
public static RSAPrivateKey getPrivateKey(String key) throws Exception {
byte[] keyBytes;
keyBytes = (new BASE64Decoder()).decodeBuffer(key);
//X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
}
/**
* 使用模和指数生成RSA公钥
* 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA
* /None/NoPadding】
*
* @param modulus
* 模
* @param exponent
* 指数
* @return
*/
public static RSAPublicKey getPublicKey(String modulus, String exponent) {
try {
BigInteger b1 = new BigInteger(modulus);
BigInteger b2 = new BigInteger(exponent);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);
return (RSAPublicKey) keyFactory.generatePublic(keySpec);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 得到密钥字符串（经过base64编码）
*
* @return
*/
public static String getKeyString(Key key) throws Exception {
byte[] keyBytes = key.getEncoded();
String s = (new BASE64Encoder()).encode(keyBytes);
return s;
}
/**
* 使用模和指数生成RSA私钥
* 注意：【此代码用了默认补位方式，为RSA/None/PKCS1Padding，不同JDK默认的补位方式可能不同，如Android默认是RSA
* /None/NoPadding】
*
* @param modulus
* 模
* @param exponent
* 指数
* @return
*/
public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {
try {
BigInteger b1 = new BigInteger(modulus);
BigInteger b2 = new BigInteger(exponent);
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);
return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 公钥加密
*
* @param str
* @param publicKey
* @return
* @throws Exception
*/
public static String encryptByPublicKey(String str, RSAPublicKey publicKey)
throws Exception {
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// 分段加密
byte[] data = str.getBytes("UTF-8");
// 加密时超过117字节就报错。为此采用分段加密的办法来加密
byte[] enBytes = null;
for (int i = 0; i < data.length; i += 117) {
// 注意要使用2的倍数，否则会出现加密后的内容再解密时为乱码
byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + 117));
enBytes = ArrayUtils.addAll(enBytes, doFinal);
}
return Base64.encode(enBytes);
}
public static byte[] decryptByPrivateKey2(byte[] data, RSAPrivateKey privateKey)
throws Exception {
//RSA/ECB/PKCS1Padding
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] cipherText = cipher.doFinal(data);
return cipherText;
}
public static String decryptByPrivateKey(byte[] data, RSAPrivateKey privateKey)
throws Exception {
//RSA/ECB/PKCS1Padding
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
byte[] cipherText = cipher.doFinal(data);
String ming =new String(cipherText);
return ming;
}
/**
* 私钥解密
*
* @param str
* @param privateKey
* @return
* @throws Exception
*/
public static String decryptByPrivateKey(String str, RSAPrivateKey privateKey)
throws Exception {
//RSA/ECB/PKCS1Padding
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
// 分段解密
// 64位解码加密后的字符串
byte[] data = Base64.decode(str);
// 解密时超过字节报错。为此采用分段解密的办法来解密
StringBuilder sb = new StringBuilder();
for (int i = 0; i < data.length; i += 128) {
byte[] doFinal = cipher.doFinal(ArrayUtils.subarray(data, i, i + 128));
sb.append(new String(doFinal));
}
return sb.toString();
}
/**
* ASCII码转BCD码
*
*/
public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {
byte[] bcd = new byte[asc_len / 2];
int j = 0;
for (int i = 0; i < (asc_len + 1) / 2; i++) {
bcd[i] = asc_to_bcd(ascii[j++]);
bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));
}
return bcd;
}
public static byte asc_to_bcd(byte asc) {
byte bcd;
if ((asc >= '0') && (asc <= '9'))
bcd = (byte) (asc - '0');
else if ((asc >= 'A') && (asc <= 'F'))
bcd = (byte) (asc - 'A' + 10);
else if ((asc >= 'a') && (asc <= 'f'))
bcd = (byte) (asc - 'a' + 10);
else
bcd = (byte) (asc - 48);
return bcd;
}
/**
* BCD转字符串
*/
public static String bcd2Str(byte[] bytes) {
char temp[] = new char[bytes.length * 2], val;
for (int i = 0; i < bytes.length; i++) {
val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);
temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
val = (char) (bytes[i] & 0x0f);
temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');
}
return new String(temp);
}
/**
* 拆分字符串
*/
public static String[] splitString(String string, int len) {
int x = string.length() / len;
int y = string.length() % len;
int z = 0;
if (y != 0) {
z = 1;
}
String[] strings = new String[x + z];
String str = "";
for (int i=0; i<x+z; i++) {
if (i==x+z-1 && y!=0) {
str = string.substring(i*len, i*len+y);
}else{
str = string.substring(i*len, i*len+len);
}
strings[i] = str;
}
return strings;
}
/**
*拆分数组
*/
public static byte[][] splitArray(byte[] data,int len){
int x = data.length / len;
int y = data.length % len;
int z = 0;
if(y!=0){
z = 1;
}
byte[][] arrays = new byte[x+z][];
byte[] arr;
for(int i=0; i<x+z; i++){
arr = new byte[len];
if(i==x+z-1 && y!=0){
System.arraycopy(data, i*len, arr, 0, y);
}else{
System.arraycopy(data, i*len, arr, 0, len);
}
arrays[i] = arr;
}
return arrays;
}
public static String encrypt(String str,String publicKey) throws Exception{
RSAPublicKey pubKey = RSAUtils.getPublicKey(publicKey);
//加密后的密文
return RSAUtils.encryptByPublicKey(str, pubKey);
}
public static byte[] decrypt(byte[] mi,String privateKey)throws Exception{
RSAPrivateKey priKey = RSAUtils.getPrivateKey(privateKey);
//解密后的明文
return RSAUtils.decryptByPrivateKey2(mi, priKey);
}
public static String decrypt(String mi,String privateKey)throws Exception{
RSAPrivateKey priKey = RSAUtils.getPrivateKey(privateKey);
//解密后的明文
return RSAUtils.decryptByPrivateKey(mi, priKey);
}
}
