本文实例讲述了Java编程实现非对称加密的方法。分享给大家供大家参考，具体如下：
对称加密算法在加密和解密时使用的是同一个秘钥；而非对称加密算法需要两个密钥来进行加密和解密，这两个秘钥是公开密钥(public key，简称公钥)和私有密钥(private key，简称私钥)。
是一种 高级的双保险加密方式，一般的实现加密方式有DH密钥交换算法，RSA基于因子分解算法，ElGamal离散对数算法及ECC椭圆曲线加密等。
DH加密解密
/**
* 非对称加密之：DH加密
* 非对称DH，是安全性基于在有限域中计算离散对数的难度的一种加密算法。
* 可用于密钥分发，但不能用于加/解密报文。DH即Diffie-Hellman算法的简写，也缩写为D-H算法。
* D-H加密算法的核心思想就是大素数不可分解质因数的数学理论方法。
* @description：
* @date 2015-10-29 上午9:08:14
*/
public class EncryptDH {
private static String dhStr = "encrypt test by DH";
public static void main(String[] args) {
jdkDh();
}
private static void jdkDh() {
try {
// 初始化发送方密钥
KeyPairGenerator senderKeyPairGenerator = KeyPairGenerator.getInstance("DH");
senderKeyPairGenerator.initialize(512);
KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded();// 发送方的公钥，发送给接受方，发送方式多种，比如文件，网络等
// 初始化接受方密钥
KeyFactory receiverKeyFactory = KeyFactory.getInstance("DH");
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(senderPublicKeyEnc);
PublicKey receiverPublicKey = receiverKeyFactory.generatePublic(x509EncodedKeySpec);
DHParameterSpec dhParameterSpec = ((DHPublicKey) receiverPublicKey).getParams();
KeyPairGenerator receiverKeyPairGenerator = KeyPairGenerator.getInstance("DH");
receiverKeyPairGenerator.initialize(dhParameterSpec);
KeyPair receiveKeyPair = receiverKeyPairGenerator.generateKeyPair();
PrivateKey receiverPrivateKey = receiveKeyPair.getPrivate();
byte[] receiverPublicKeyEnc = receiveKeyPair.getPublic().getEncoded();
// 密钥构建
KeyAgreement receiverKeyAgreement = KeyAgreement.getInstance("DH");
receiverKeyAgreement.init(receiverPrivateKey);
receiverKeyAgreement.doPhase(receiverPublicKey, true);
SecretKey receiverSecretKey = receiverKeyAgreement.generateSecret("DES");
KeyFactory senderKeyFactory = KeyFactory.getInstance("DH");
x509EncodedKeySpec = new X509EncodedKeySpec(receiverPublicKeyEnc);
PublicKey senderPublicKey = senderKeyFactory.generatePublic(x509EncodedKeySpec);
KeyAgreement senderKeyAgreement = KeyAgreement.getInstance("DH");
senderKeyAgreement.init(senderKeyPair.getPrivate());
senderKeyAgreement.doPhase(senderPublicKey, true);
SecretKey snederSecretKey = senderKeyAgreement.generateSecret("DES");
if (Objects.equals(receiverSecretKey, snederSecretKey)) {
System.out.println("双方密钥相同");
}
// 加密
Cipher cipher = Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, snederSecretKey);
byte[] result = cipher.doFinal(dhStr.getBytes());
System.out.println("DH加密后为：" + Base64.encode(result));
// 解密
cipher.init(Cipher.DECRYPT_MODE, receiverSecretKey);
result = cipher.doFinal(result);
System.out.println("DH解密后为：" + new String(result));
}
catch (Exception e) {
e.printStackTrace();
}
}
}
RSA加密解密
/**
* 非对称加密之：RSA加密
* @description：
* RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest)、阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的。
* 1987年首次公布，当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。
* RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。
* 今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。
* 但在分布式计算和量子计算机理论日趋成熟的今天，RSA加密安全性受到了挑战。
* RSA算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。
* @date 2015-10-29 上午9:08:14
*/
public class EncryptRSA {
private static String rsaStr = "encrypt test by ElGamal";
public static void main(String[] args) {
jdkRSA();
}
private static void jdkRSA() {
try {
// 初始化密钥
KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
keyPairGenerator.initialize(512);
KeyPair keyPair = keyPairGenerator.generateKeyPair();
RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
System.out.println("RSA公钥：" + Base64.encode(rsaPublicKey.getEncoded()));
System.out.println("RSA私钥：" + Base64.encode(rsaPrivateKey.getEncoded()));
// 私钥加密，公钥解密--加密
PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
KeyFactory keyFactory = KeyFactory.getInstance("RSA");
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
byte[] result = cipher.doFinal(rsaStr.getBytes());
System.out.println("RSA私钥加密，公钥解密--加密：" + Base64.encode(result));
// 私钥加密，公钥解密--解密
X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
PublicKey publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, publicKey);
result = cipher.doFinal(result);
System.out.println("RSA私钥加密，公钥解密--解密：" + new String(result));
// 公钥加密，私钥解密--加密
x509EncodedKeySpec = new X509EncodedKeySpec(rsaPublicKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
publicKey = keyFactory.generatePublic(x509EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
result = cipher.doFinal(rsaStr.getBytes());
System.out.println("公钥加密，私钥解密--加密：" + Base64.encode(result));
// 公钥加密，私钥解密--解密
pkcs8EncodedKeySpec=new PKCS8EncodedKeySpec(rsaPrivateKey.getEncoded());
keyFactory = KeyFactory.getInstance("RSA");
privateKey= keyFactory.generatePrivate(pkcs8EncodedKeySpec);
cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
result = cipher.doFinal(result);
System.out.println("公钥加密，私钥解密--解密：" + new String(result));
}
catch (Exception e) {
e.printStackTrace();
}
}
}
ElGamal加密
/**
* 非对称加密之：ElGamal加密
* @description：
* ElGamal算法，是一种较为常见的加密算法，它是基于1984年提出的公钥密码体制和椭圆曲线加密体系。
* 既能用于数据加密也能用于数字签名，其安全性依赖于计算有限域上离散对数这一难题。
* 在加密过程中，生成的密文长度是明文的两倍，且每次加密后都会在密文中生成一个随机数K，
* 在密码中主要应用离散对数问题的几个性质：求解离散对数(可能)是困难的，而其逆运算指数运算可以应用平方-乘的方法有效地计算。
* 也就是说，在适当的群G中，指数函数是单向函数。
* @date 2015-10-29 上午9:08:14
*/
public class EncrypElGamal {
private static String rsaStr = "encrypt test by ElGamal";
public static void main(String[] args) {
jdkRSA();
}
private static void jdkRSA() {
try {
// 公钥加密，私钥解密
// Security.addProvider(new BouncyCastleProvider());//需要添加bouncycastleprovider jar
//初始化密钥
AlgorithmParameterGenerator algorithmParameterGenerator=AlgorithmParameterGenerator.getInstance("ElGamal");
algorithmParameterGenerator.init(256);
AlgorithmParameters algorithmParameters=algorithmParameterGenerator.generateParameters();
DHParameterSpec dhParameterSpec=algorithmParameters.getParameterSpec(DHParameterSpec.class);
KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("ElGamal");
keyPairGenerator.initialize(dhParameterSpec,new SecureRandom());
KeyPair keyPair=keyPairGenerator.generateKeyPair();
PublicKey publicKey=keyPair.getPublic();
PrivateKey privateKey=keyPair.getPrivate();
System.out.println("ElGamal加密公钥："+Base64.encode(publicKey.getEncoded()));
System.out.println("ElGamal加密私钥："+Base64.encode(privateKey.getEncoded()));
//加密解密同Rsa是一样的
}
catch (Exception e) {
e.printStackTrace();
}
}
}
Ecc加密可以参考：http://www.pediy.com/kssd/pediy06/pediy6014.htm等。
PS：关于加密解密感兴趣的朋友还可以参考本站在线工具：
在线MD5/hash/SHA-1/SHA-2/SHA-256/SHA-512/SHA-3/RIPEMD-160加密工具：http://tools.jb51.net/password/hash_md5_sha
希望本文所述对大家java程序设计有所帮助。

1.1 为什么要对API接口进行加密？


因为http协议是明文传输，它是不够安全的，比如进行get请求的时候，请求参数会直接附加在URL后边，即使是post请求其实也是不够安全的，如果用户连接了不安全的网络，这个时候黑客可能可以通过抓包工具直接获取请求信息，并且黑客可能对请求参数进行非法篡改，所以API接口加密就显得至关重要了！
1.2 常见的接口加密方式有哪些？
使用https协议（相比较与http协议，https协议加入了ssl证书，并且https是基于ssl的密文传输方式）、参数加密使用对称加密或非对称加密。
1.3 URL特殊字符转码
1.3.1 什么是URL特殊字符?使用这些字符在请求参数中会照成什么问题？
比如\、?、+、#等一些特殊字符都是URL特殊字符，当这些字符用在请求参数中，可能会导致后端获取到的请求参数与原始值不一致。



如上图中，请求参数userName是1+1,后端参数接收实际上为1 1(1空格1)。
1.3.2 在Java中如何实现URL特殊字符转码与解码？
在Java中要实现URL的转码特别简单，可以直接使用javax.net包中的,URLEncoder进行编码,使用URLDeCoder可以实现URL特殊编码的解码，当然也可以借助其他第三方的解码类库。
1.3.2.1 使用javax.net.URLEncoder进行URL特殊字符编码
@Test
public void urlEncoderTest(){    
    String userName="xiao+ming";    
    System.out.println("编码前："+userName);    
    try {        
        userName=URLEncoder.encode(userName,"utf-8");        
        System.out.println("编码后："+userName);    
    } catch (UnsupportedEncodingException e) {        
    e.printStackTrace();    }
}



控制台输出结果：


1.3.2.2 使用javax.net.URLDecoder进行URL特殊字符解码
    public void urlEncoderTest(){
        String userName="xiao+ming";

        System.out.println("编码前："+userName);

        try {
            userName=URLEncoder.encode(userName,"utf-8");

            System.out.println("编码后："+userName);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }

        try {
            userName= URLDecoder.decode(userName,"utf-8");

            System.out.println("解码后："+userName);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
    }

控制台打印结果：

1.4 什么是对称加密？
对称加密指的是，加密与解密的密钥是一致的，也就是说通过什么密钥进行加密就使用什么密钥解密，常见的对称加密算法有AES、DES。


1.4.1 对称加密的使用场景
服务端与服务端的通信可以采用对称加密，因为这种场景相对安全，不会将密钥保存在客户端所以其他人无法对数据进行解密，也就无法非法获取数据。
1.4.2 对称加密的缺点
不适合用于，客户端与服务器端交互的加密，因为他人可能通过反编译客户端源码的方式获取到加密密钥。
1.5 什么是非对称加密？
非对称加密，指的就是加密使用的密钥与解密使用的密钥是不一致的，也就是我们常说的公钥与私钥，非对称加密的典型算法是RSA。


1.5.1 通过工具类生成公钥和私钥
package com.muzili.demo.demo0628.util;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import javax.crypto.Cipher;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**
 * RSA加密，支持分片加密
 * <pre>
 * BCD码（Binary-Coded Decimal）亦称二进码十进数或二-十进制代码。
 * 用4位二进制数来表示1位十进制数中的0~9这10个数码。
 * 是一种二进制的数字编码形式，用二进制编码的十进制代码。
 * 注：日常所说的BCD码大都是指8421BCD码形式
 * @author muzili
 * 
 */
public class RSAUtil {
	/** 指定加密算法为RSA */
	private static String ALGORITHM = "RSA";
	/** 指定key的大小 */
	private static int KEYSIZE = 1024;
	/** 指定公钥存放文件 */
	private static String PUBLIC_KEY_FILE = "PublicKey.key";
	/** 指定私钥存放文件 */
	private static String PRIVATE_KEY_FILE = "PrivateKey.key";
 
	public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
 
	/**
	 * 生成密钥对
	 */
	public static void generateKeyPair() throws Exception {
		if (getpublickey() == null || getprivatekey() == null) {
			/** RSA算法要求有一个可信任的随机数源 */
			SecureRandom sr = new SecureRandom();
			/** 为RSA算法创建一个KeyPairGenerator对象 */
			KeyPairGenerator kpg = KeyPairGenerator.getInstance(ALGORITHM);
			/** 利用上面的随机数据源初始化这个KeyPairGenerator对象 */
			kpg.initialize(KEYSIZE, sr);
			/** 生成密匙对 */
			KeyPair kp = kpg.generateKeyPair();
			/** 得到公钥 */
			Key publicKey = kp.getPublic();
			/** 得到私钥 */
			Key privateKey = kp.getPrivate();

			System.out.println("公钥："+encryptBASE64(publicKey.getEncoded()));
			System.out.println("私钥："+encryptBASE64(privateKey.getEncoded()));

			/** 用对象流将生成的密钥写入文件 */
			ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream(PUBLIC_KEY_FILE));
			ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream(PRIVATE_KEY_FILE));
			oos1.writeObject(publicKey);
			oos2.writeObject(privateKey);
			/** 清空缓存，关闭文件输出流 */
			oos1.close();
			oos2.close();
		}
 
	}
 
	/**
	 * 产生签名
	 * 
	 * @param data
	 * @param privateKey
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		// 解密由base64编码的私钥
		byte[] keyBytes = decryptBASE64(privateKey);
 
		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 
		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 
		// 取私钥对象
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
		// 用私钥对信息生成数字签名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(priKey);
		signature.update(data);
 
		return encryptBASE64(signature.sign());
	}
 
	/**
	 * 验证签名
	 * 
	 * @param data
	 * @param publicKey
	 * @param sign
	 * @return
	 * @throws Exception
	 */
	public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
 
		// 解密由base64编码的公钥
		byte[] keyBytes = decryptBASE64(publicKey);
 
		// 构造X509EncodedKeySpec对象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
 
		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 
		// 取公钥对象
		PublicKey pubKey = keyFactory.generatePublic(keySpec);
 
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initVerify(pubKey);
		signature.update(data);
 
		// 验证签名是否有效
		return signature.verify(decryptBASE64(sign));
	}
 
	/**
	 * BASE64解密
	 * 
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static byte[] decryptBASE64(String key) throws Exception {
		return (new BASE64Decoder()).decodeBuffer(key);
	}
 
	/**
	 * BASE64加密
	 * 
	 * @param key
	 * @return
	 * @throws Exception
	 */
	public static String encryptBASE64(byte[] key) throws Exception {
		return (new BASE64Encoder()).encodeBuffer(key);
	}
 
	/**
	 * 加密方法 source： 源数据
	 */
	public static String encrypt(String source) throws Exception {
		generateKeyPair();
		/** 将文件中的公钥对象读出 */
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
		Key key = (Key) ois.readObject();
		ois.close();
		/** 得到Cipher对象来实现对源数据的RSA加密 */
		Cipher cipher = Cipher.getInstance(ALGORITHM);
		cipher.init(Cipher.ENCRYPT_MODE, key);
		int MaxBlockSize = KEYSIZE / 8;
		int len = (MaxBlockSize - 11) / 8;
		String[] datas = splitString(source, len);
		StringBuffer mi = new StringBuffer();
		for (String s : datas) {
			mi.append(bcd2Str(cipher.doFinal(s.getBytes())));
		}
		return mi.toString();
 
	}
 
	/**
	 * 字符串分片
	 * 
	 * @param string
	 *            源字符串
	 * @param len
	 *            单片的长度（keysize/8）
	 * @return
	 */
	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;
	}
 
	/**
	 * bcd 转 Str
	 * 
	 * @param bytes
	 * @return
	 */
	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);
	}
 
	/**
	 * 解密
	 * 
	 * @param cryptograph
	 *            :密文
	 * @return 解密后的明文
	 * @throws Exception
	 */
	public static String decrypt(String cryptograph) throws Exception {
		generateKeyPair();
		/** 将文件中的私钥对象读出 */
		@SuppressWarnings("resource")
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
		Key key = (Key) ois.readObject();
		/** 得到Cipher对象对已用公钥加密的数据进行RSA解密 */
		Cipher cipher = Cipher.getInstance(ALGORITHM);
		cipher.init(Cipher.DECRYPT_MODE, key);
		int key_len = KEYSIZE / 8;
		byte[] bytes = cryptograph.getBytes();
		byte[] bcd = ASCII2BCD(bytes, bytes.length);
		StringBuffer sBuffer = new StringBuffer();
		byte[][] arrays = splitArray(bcd, key_len);
		for (byte[] arr : arrays) {
			sBuffer.append(new String(cipher.doFinal(arr)));
		}
		return sBuffer.toString();
	}
 
	/**
	 * ASCII 转 BCD
	 * 
	 * @param ascii
	 * @param asc_len
	 * @return
	 */
	public static byte[] ASCII2BCD(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] = asc2bcd(ascii[j++]);
			bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc2bcd(ascii[j++])) + (bcd[i] << 4));
		}
		return bcd;
	}
 
	/**
	 * asc转bcd
	 * 
	 * @param asc
	 * @return
	 */
	public static byte asc2bcd(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;
	}
 
	/**
	 * 字节数组分片
	 * 
	 * @param data
	 * @param len
	 * @return
	 */
	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 getpublickey() {
 
		try {
			@SuppressWarnings("resource")
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PUBLIC_KEY_FILE));
			Key key = (Key) ois.readObject();
			String publickey = encryptBASE64(key.getEncoded());
			return publickey;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
 
	/** 将文件中的私钥对象读出 */
	public static String getprivatekey() {
		try {
			@SuppressWarnings("resource")
			ObjectInputStream ois = new ObjectInputStream(new FileInputStream(PRIVATE_KEY_FILE));
			Key key = (Key) ois.readObject();
			String privatekey = encryptBASE64(key.getEncoded());
			return privatekey;
		} catch (Exception e) {
			e.printStackTrace();
		}
		return null;
	}
 
	public static void main(String[] args) {
		try {
			generateKeyPair();
		} catch (Exception e) {
			e.printStackTrace();
		}
		try {
			String s = encrypt("天天舞苑");
			System.out.println("加密："+s);
			System.out.println("解密："+decrypt(s));
 
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

控制台打印：

md5   base64  都不属于加密。

md5 叫做 信息摘要   简单来讲就是 一个 映射关系。

base64 是一种编码方式。

加密，解密的话，分为，对称加密，和非对称加密。

像 des,aes 就是对称加密 

非对称 RSA，DSA，等。

对称和非对称是指，加密和解密的时候，是不是需要同一个秘钥。非对称加密，使用私钥和公钥两种秘钥。

支付宝接口对接的时候，基本都是 使用的RSA 方式。

SSL 里，就得选择 用哪种加密方式。

引言
  某一天你认识了一个小姐姐，她没有给你联系方式，你只知道她的上班地址和姓名，回到家中你日思夜想，非常想念这位小姐姐，于是你就开始给她写信，那么写信有哪些问题？

  我在给她写信的时候，中间有一个邪恶的邮递员（超邪恶 ）他总想把我和小姐姐拆了，我们在讨论信息传送安全的问题，需要注意那些问题呢

    1.消息可能会被伪造（邪恶的邮递员用我的口吻给小姐姐写一封信：你一点也不漂亮，然后小姐姐从此再也不理我了

    2.消息可能被修改（邪恶的邮递员在我的信中随便改动）

    3.消息可能被监听（小姐姐能够成功看到信息，但是邮递员也看到了，他就可以通过一些信息对我进行诈骗、勒索）



  那么怎么解决这个问题？
对称加密算法
  于是你想到了在消息上面进行加密，你可以提前给小姐姐说好，我写的消息每个字母都会往后移动三位，比如你写   abc 那么它的实际内容就是 def，这样邮递员就看不懂我们写的什么内容了，这就是对称加密算法：对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法，就是你写信的时候不会写实际内容，而是写的实际内容加密后的内容，然后小姐姐通过你的加密方法反解出真实的内容。



常见的对称加密算法及对比

  1、DES 已破解，不再安全，基本没有企业在用了是对称加密算法的基石，具有学习价值密钥长度56（JDK）、56/64（BC）

  2、DESede（三重DES）早于AES出现来替代DES计算密钥时间太长、加密效率不高，所以也基本上不用密钥长度112/168（JDK）、128/192（BC）

  3、AES最常用的对称加密算法密钥建立时间短、灵敏性好、内存需求低（不管怎样，反正就是好）实际使用中，使用工作模式为CTR（最好用BC去实现），此工作模式需要引入IV参数（16位的字节数组）密钥长度128/192/256，其中192与256需要配置无政策限制权限文件（JDK6）填充模式最常用的两种PKCS5Padding和PKCS7Padding，其中后者只有BC独有。

  4、IDEA常用的电子邮件加密算法工作模式只有ECB密钥长度128位

  5、PBE综合了消息摘要算法和对称加密算法，最常见的是PBEWithMD5AndDES工作模式只有CBC（已丧失安全性，不推荐使用），所以PBE也不推荐使用了
非对称加密算法
但是邮递员可以对我们的内容进行修改，虽然我读不懂，但是就是想要搞你！！！！(就很棒），还有一个问题就是你如何让小姐姐知道你的加密方法，显然是不可能通过写信的方式告诉小姐姐，那么你就可以通过非对称加密来进行传输信息，非对称加密有一个口诀：公钥加密私钥解，私钥加密公钥解



A0通过公钥加密变成A1，A1通过私钥解密就可以还原A0
那么我怎么和小姐姐通信？我们可以先写一封信告诉小姐姐你的公钥是多少，小姐姐告诉了我她的公钥，我通过她的公钥进行加密我的信，然后小姐姐通过她的私钥就可以拿到我所写信的真实内容。



这就成功解决了被监听的问题，但是还是不能解决被伪造了问题，因为邮递员也拿到了小姐姐的公钥，他也可以通过这个公钥给小姐姐发送信息，说我每天都在撩其他小姐姐

之前说过，公钥加密私钥解，私钥加密公钥解，我可以先写一封信告诉小姐姐我的公钥是xx，然后小姐姐说好的我知道了，然后我通过我的私钥进行加密，然后发送给小姐姐，小姐姐也能正常的看到信息，因为邮递员没有我的私钥所以就避免了伪造，但是邮递员能知道我的公钥，那么他也能读取我的内容，好像单纯考非对称加密也解决不了问题。

聪明的你可能想到了你已经学过了对称加密算法

1.先给小姐姐写信问她的公钥

2.小姐姐告诉了你的公钥

3.使用公钥将对称加密算法psk进行加密（假设是：123456），并告诉小姐姐我们接下来要使用对称加密算法了

4.由于邮递员没有小姐姐的密钥，所以他看不到我写的内容，一旦我和小姐姐都有了psk的密钥，我们就可以通信了，这就有效的防止了监听、伪造、修改的所有问题。



当然还有一个最重要的问题还没有解决，就是如何确定写信的人是我，或者收信的人是小姐姐勒？



万一收信的是一个大胡子猛男怎么办，这就涉及到数字签名，聪明的你知道吗hhh