1、DES（Data Encryption Standard）：对称算法，数据加密标准，速度较快，适用于加密大量数据的场合；
2、3DES（Triple DES）：是基于DES的对称算法，对一块数据用三个不同的密钥进行三次加密，强度更高；
3、RC2和RC4：对称算法，用变长密钥对大量数据进行加密，比 DES 快；
4、IDEA（International Data Encryption Algorithm）国际数据加密算法，使用 128 位密钥提供非常强的安全性；
5、RSA：由 RSA 公司发明，是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的，非对称算法；
6、DSA（Digital Signature Algorithm）：数字签名算法，是一种标准的 DSS（数字签名标准），严格来说不算加密算法；
7、AES（Advanced Encryption Standard）：高级加密标准，对称算法，是下一代的加密算法标准，速度快，安全级别高，在21世纪AES 标准的一个实现是 Rijndael 算法；
8、BLOWFISH，它使用变长的密钥，长度可达448位，运行速度很快；
9、MD5：严格来说不算加密算法，只能说是摘要算法；
10、PKCS:The Public-Key Cryptography Standards (PKCS)是由美国RSA数据安全公司及其合作伙伴制定的一组公钥密码学标准，其中包括证书申请、证书更新、证书作废表发布、扩展证书内容以及数字签名、数字信封的格式等方面的一系列相关协议。
11、SSF33，SSF28，SCB2(SM1)：国家密码局的隐蔽不公开的商用算法，在国内民用和商用的，除这些都不容许使用外，其他的都可以使用；
12、ECC（Elliptic Curves Cryptography）：椭圆曲线密码编码学。
13、TEA(Tiny Encryption Algorithm)简单高效的加密算法，加密解密速度快，实现简单。但安全性不如DES，QQ一直用tea加密
关于加密、解密的使用及比较可参阅微博：
https://www.cnblogs.com/sunxuchu/p/5483956.html
---------------------------------------------------------
加密、解密可参阅博文：
https://www.cnblogs.com/lz2017/p/6917049.html
https://www.cnblogs.com/jianyungsun/p/6803597.html
----------------------------
package com.org.cn;
import java.io.IOException;
import java.security.AlgorithmParameterGenerator;
import java.security.AlgorithmParameters;
import java.security.Key;
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.Security;
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 java.util.Objects;
import javax.crypto.Cipher;
import javax.crypto.KeyAgreement;
import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.interfaces.DHPublicKey;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.DESedeKeySpec;
import javax.crypto.spec.DHParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.Hex;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.junit.Test;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
/**
* 如基本的单向加密算法：
BASE64 严格地说，属于编码格式，而非加密算法
MD5(Message Digest algorithm 5，信息摘要算法)
SHA(Secure Hash Algorithm，安全散列算法)
HMAC(Hash Message Authentication Code，散列消息鉴别码)
复杂的对称加密（DES、PBE）、非对称加密算法：
DES(Data Encryption Standard，数据加密算法)
PBE(Password-based encryption，基于密码验证)
RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)
DH(Diffie-Hellman算法，密钥一致协议)
DSA(Digital Signature Algorithm，数字签名)
ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)
* @author Administrator
*
*/
public class Test1 {
//要进行加密的数据
private static String base="Hello Base64";
private static String md5="Hello MD";
private static String sha="Hello SHA";
private static String des="Hello DES";
private static String three3des="Hello 3DES";
private static String aes="Hello AES";
private static String pbe="Hello PBE";
private static String dh="Hello DH";
private static String rsa="Hello RSA";
/**
* 密钥长度，DH算法的默认密钥长度是1024
* 密钥长度必须是8的倍数，在160到16384位之间
* */
//非对称密钥算法
public static final String KEY_ALGORITHM="ElGamal";
private static final int KEY_SIZE=256;
//公钥
private static final String PUBLIC_KEY="ElGamalPublicKey";
//私钥
private static final String PRIVATE_KEY="ElGamalPrivateKey";
//Base64加密解密 需要将jre/lib/的rt.jar包导入进来 准确来说Base64是一种编码方式
@Test
public void useBase64(){
try {
//加密
BASE64Encoder encoder = new BASE64Encoder();
String encode = encoder.encode(base.getBytes());
System.out.println("encode: " + encode);
BASE64Decoder decoder = new BASE64Decoder();
//解密
String decode = new String(decoder.decodeBuffer(encode));
System.out.println("decode: " + decode);
} catch (IOException e) {
e.printStackTrace();
}
}
//不可逆的摘要信息加密算法 单向加密 MD5、SHA1、Hmac 数字签名一般用到 SHA比MD5安全性较高
@Test
public void useMD5(){
try {
MessageDigest md=MessageDigest.getInstance("MD5");
byte[] digest = md.digest(md5.getBytes());
System.out.println("JDK MD5: "+digest);//一般单向加密存在数据库中的密码也为加密后得到的数据，实际中加密一般会在进行一道转化，即再用Base64进行加密
BASE64Encoder base64Encoder=new BASE64Encoder();
String encode = base64Encoder.encode(digest);//二次加密
System.out.println("JDK MD5:" + encode);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
@Test
public void useSHA(){
try {
MessageDigest sha = MessageDigest.getInstance("SHA");
byte[] digest = sha.digest();
System.out.println("JDK SHA1:"+digest);//一般单向加密存在数据库中的密码也为加密后得到的数据
BASE64Encoder base64Encoder=new BASE64Encoder();
String encode = base64Encoder.encode(digest);//二次加密
System.out.println("JDK MD5:" + encode);
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
@Test
public void useHmac(){
KeyGenerator keyGenerator;
try {
keyGenerator = KeyGenerator.getInstance("HmacMD5");//初始化密钥
SecretKey secretKey = keyGenerator.generateKey();
byte[] encode = secretKey.getEncoded();//先转化为字节数组
BASE64Encoder encoder = new BASE64Encoder();//在通过BASE64进行加密生成最终的密钥
String encode1 = encoder.encode(encode);
System.out.println("密钥为: " + encode1);
//拿到密钥后将密钥与所要加密的文字一起组合进行加密，等到最后的一个密码
SecretKey secretKey1 = new SecretKeySpec(encode,"HmacMD5");
Mac mac = Mac.getInstance(secretKey1.getAlgorithm());
mac.init(secretKey1);
byte[] hmac = mac.doFinal(sha.getBytes());
System.out.println("JDK Hmac:"+hmac);
// System.out.println("JDK Hmac 字符串:"+new String(hmac));
} catch (Exception e) {
e.printStackTrace();
}
return;
}
/**
* 严格意义上的加密算法，分为对称和非对称加密算法，所谓对称是说发送方和接收方的密钥是一样的，而非对称我们后面再说。因为密钥一样所以安全性跟非对称比较来说就不太安全了对称加密算法主要分为:DES , 3DES(3重DES) , AES(想要替代DES) , PBE(基于口令的对称算法)
*/
@Test
public void useDES(){
try {
//生成key
KeyGenerator keyGenerator=KeyGenerator.getInstance("DES");
keyGenerator.init(56); //指定key长度，同时也是密钥长度(56位)
SecretKey secretKey = keyGenerator.generateKey(); //生成key的材料
byte[] key = secretKey.getEncoded(); //生成key
//key转换成密钥
DESKeySpec desKeySpec=new DESKeySpec(key);
SecretKeyFactory factory=SecretKeyFactory.getInstance("DES");
SecretKey key2 = factory.generateSecret(desKeySpec); //转换后的密钥
//加密
Cipher cipher=Cipher.getInstance("DES/ECB/PKCS5Padding"); //算法类型/工作方式/填充方式
cipher.init(Cipher.ENCRYPT_MODE, key2); //指定为加密模式
byte[] result=cipher.doFinal(des.getBytes());
System.out.println("jdkDES加密: "+result); //转换为十六进制
//解密
cipher.init(Cipher.DECRYPT_MODE,key2); //相同密钥，指定为解密模式
result = cipher.doFinal(result); //根据加密内容解密
System.out.println("jdkDES解密: "+new String(result)); //转换字符串
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void use3DES(){
try {
// 生成key
KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede");
// keyGenerator.init(112); //3DES需要112 or 168位
keyGenerator.init(new SecureRandom()); // 或者使用这种方式默认长度，无需指定长度
SecretKey secretKey = keyGenerator.generateKey(); // 生成key的材料
byte[] key = secretKey.getEncoded(); // 生成key
// key转换成密钥
DESedeKeySpec desKeySpec = new DESedeKeySpec(key);
SecretKeyFactory factory = SecretKeyFactory.getInstance("DESede");
SecretKey key2 = factory.generateSecret(desKeySpec); // 转换后的密钥
// 加密
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding"); // 算法类型/工作方式/填充方式
cipher.init(Cipher.ENCRYPT_MODE, key2); // 指定为加密模式
byte[] result = cipher.doFinal(three3des.getBytes());
System.out.println("jdk3DES加密: " + result); // 转换为十六进制
// 解密
cipher.init(Cipher.DECRYPT_MODE, key2); // 相同密钥，指定为解密模式
result = cipher.doFinal(result); // 根据加密内容解密
System.out.println("jdk3DES解密: " + new String(result)); // 转换字符串
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 基本实现和DES类似，只不过在实现该算法的时候，设置密钥长度大于128会出现错误：Illegal key size or default parameters，这是因为美国的出口限制，Sun通过权限文件（local_policy.jar、US_export_policy.jar）做了相应限制，Oracle在其官方网站上提供了无政策限制权限文件（Unlimited Strength Jurisdiction Policy Files），我们只需要将其部署在JRE环境中，就可以解决限制问题
JDK8的无政策限制权限文件（http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html）将下载的local_policy.jar和US_export_policy.jar替换JDK的JRE环境中，或者是JRE环境中上述两个jar文件即可非对称的ELGamal加密算法算法也有该问题，解决方法相同
*/
@Test
public void useAES(){
try {
//生成key
KeyGenerator keyGenerator=KeyGenerator.getInstance("AES");
keyGenerator.init(new SecureRandom());
SecretKey secretKey = keyGenerator.generateKey();
byte[] key1 = secretKey.getEncoded();
//key转换为密钥
Key key2 = new SecretKeySpec(key1, "AES");
//加密
Cipher cipher=Cipher.getInstance("AES/ECB/PKCS5padding");
cipher.init(Cipher.ENCRYPT_MODE, key2);
byte[] result = cipher.doFinal(aes.getBytes());
System.out.println("jdkAES加密: "+Hex.encodeHexString(result)); //转换为十六进制
//解密
cipher.init(Cipher.DECRYPT_MODE, key2);
result = cipher.doFinal(result);
System.out.println("jdkAES解密: "+new String(result)); //转换字符串
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 基于口令的对称加密算法（它其实是对之前的算法的包装，比如说MD5和DES，我这里就是的是对MD5和DES包装的PBE算法，还有其他类型的PBE），口令就是我们俗话说的密码，PBE中有一个salt（盐）的概念，盐就是干扰码
*/
@Test
public void usePBE(){
try {
//初始化盐
SecureRandom random=new SecureRandom();
byte[] salt = random.generateSeed(8); //指定为8位的盐 （盐就是干扰码，通过添加干扰码增加安全）
//口令和密钥
String password="lynu"; //口令
PBEKeySpec pbeKeySpec=new PBEKeySpec(password.toCharArray());
SecretKeyFactory factory=SecretKeyFactory.getInstance("PBEWITHMD5andDES");
Key key=factory.generateSecret(pbeKeySpec); //密钥
//加密
PBEParameterSpec pbeParameterSpec=new PBEParameterSpec(salt, 100); //参数规范，第一个参数是盐，第二个是迭代次数（经过散列函数多次迭代）
Cipher cipher=Cipher.getInstance("PBEWITHMD5andDES");
cipher.init(Cipher.ENCRYPT_MODE, key,pbeParameterSpec);
byte[] result = cipher.doFinal(pbe.getBytes());
System.out.println("jdk PBE加密: "+Base64.encodeBase64String(result));
//解密
cipher.init(Cipher.DECRYPT_MODE, key,pbeParameterSpec);
result = cipher.doFinal(result);
System.out.println("jdk PBE解密: "+new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 非对称算法就是发送方和接收方的密钥是不一样的，非对称相对于对称来说，有公钥和私钥的概念，基本上公钥是公开的，比如会在网络上传输，而私钥安全性要求就要高很多了，因为私钥是要保密的基本的非对称算法有DH，RSA，ELGamal算法
DH：基于交换密钥的非对称算法，接收方需要得到接收方的key构建本地密钥，而接收方也需要得到发送方的key构建自己本地的密钥。只有JDK的实现
*/
@Test
public void useDH(){
try {
//初始化发送方密钥
KeyPairGenerator senderKeyPairGenerator=KeyPairGenerator.getInstance("DH");
senderKeyPairGenerator.initialize(512); //密钥长度
KeyPair senderKeyPair = senderKeyPairGenerator.generateKeyPair();
byte[] senderPublicKeyEnc = senderKeyPair.getPublic().getEncoded(); //发送方key,需传递给接收方（网络，文件）
//初始化接收方密钥
KeyFactory factory=KeyFactory.getInstance("DH");
X509EncodedKeySpec x509EncodedKeySpec=new X509EncodedKeySpec(senderPublicKeyEnc); //根据从发送方得到的key解析
PublicKey receiverPublicKey=factory.generatePublic(x509EncodedKeySpec);
DHParameterSpec dhParameterSpec=((DHPublicKey)receiverPublicKey).getParams();
KeyPairGenerator receiverKeyPairGenerator=KeyPairGenerator.getInstance("DH");
receiverKeyPairGenerator.initialize(dhParameterSpec);
KeyPair receiverKeyPair = receiverKeyPairGenerator.generateKeyPair();
PrivateKey receiverPrivateKey = receiverKeyPair.getPrivate();
byte[] receiverPublicKeyEnc = receiverKeyPair.getPublic().getEncoded();
//密钥构建
KeyAgreement receiverKeyAgreement=KeyAgreement.getInstance("DH");
receiverKeyAgreement.init(receiverPrivateKey);
receiverKeyAgreement.doPhase(receiverPublicKey, true);
SecretKey receiverDESKey=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 senderDESKey=senderKeyAgreement.generateSecret("DES"); //接收方密钥(私钥)
if(Objects.equals(receiverDESKey, senderDESKey)){
System.out.println("双方密钥相同");
}
//加密
Cipher cipher=Cipher.getInstance("DES");
cipher.init(Cipher.ENCRYPT_MODE, senderDESKey);
byte[] result = cipher.doFinal(dh.getBytes());
System.out.println("jdk DH加密: "+org.apache.commons.codec.binary.Base64.encodeBase64String(result));
//解密
cipher.init(Cipher.DECRYPT_MODE, receiverDESKey);
result=cipher.doFinal(result);
System.out.println("jdk DH解密: "+new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}
/*
* RSA相较于DH算法的实现简单，适用范围较广，公钥和私钥的创建较简单，而且支持公钥加密，私钥解密或者是私钥加密，公钥解密两种方式要加密的数据：
*/
@Test
public void useRSA(){
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("public key:"+Base64.encodeBase64String(rsaPublicKey.getEncoded()));
System.out.println("private key:"+Base64.encodeBase64String(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(rsa.getBytes());
System.out.println("RSA私钥加密，公钥解密--加密:"+Base64.encodeBase64String(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(rsa.getBytes());
System.out.println("RSA公钥加密，私钥解密--加密:"+Base64.encodeBase64String(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("RSA公钥加密，私钥解密--解密:"+new String(result));
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* ELGamal算法的和AES一样存在密钥长度的限制，解决方法和AES一致。不过ELGamal只支持公钥加密，私钥解密这种方式。只有bc的实现方式要加密的数据：
*/
/**
* 初始化密钥对
* @return Map 甲方密钥的Map
* */
public static Map<String,Object> initKey() throws Exception{
//加入对BouncyCastle支持
Security.addProvider(new BouncyCastleProvider());
AlgorithmParameterGenerator apg=AlgorithmParameterGenerator.getInstance(KEY_ALGORITHM);
//初始化参数生成器
apg.init(KEY_SIZE);
//生成算法参数
AlgorithmParameters params=apg.generateParameters();
//构建参数材料
DHParameterSpec elParams=(DHParameterSpec)params.getParameterSpec(DHParameterSpec.class);
//实例化密钥生成器
KeyPairGenerator kpg=KeyPairGenerator.getInstance(KEY_ALGORITHM) ;
//初始化密钥对生成器
kpg.initialize(elParams,new SecureRandom());
KeyPair keyPair=kpg.generateKeyPair();
//甲方公钥
PublicKey publicKey= keyPair.getPublic();
//甲方私钥
PrivateKey privateKey= keyPair.getPrivate();
//将密钥存储在map中
Map<String,Object> keyMap=new HashMap<String,Object>();
keyMap.put(PUBLIC_KEY, publicKey);
keyMap.put(PRIVATE_KEY, privateKey);
return keyMap;
}
/**
* 公钥加密
* @param data待加密数据
* @param key 密钥
* @return byte[] 加密数据
* */
public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
//实例化密钥工厂
KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
//产生公钥
Key pubKey=keyFactory.generatePublic(x509KeySpec);
//数据加密
Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
SecureRandom paramSecureRandom = new SecureRandom();
cipher.init(Cipher.ENCRYPT_MODE,pubKey,paramSecureRandom);
return cipher.doFinal(data);
}
/**
* 私钥解密
* @param data 待解密数据
* @param key 密钥
* @return byte[] 解密数据
* */
public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
//取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
//数据解密
Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(data);
}
/**
* 取得私钥
* @param keyMap 密钥map
* @return byte[] 私钥
* */
public static byte[] getPrivateKey(Map<String,Object> keyMap){
Key key=(Key)keyMap.get(PRIVATE_KEY);
return key.getEncoded();
}
/**
* 取得公钥
* @param keyMap 密钥map
* @return byte[] 公钥
* */
public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
Key key=(Key) keyMap.get(PUBLIC_KEY);
return key.getEncoded();
}
/**
* @param args
* @throws Exception
*/
public void main(String[] args) throws Exception {
//初始化密钥
//生成密钥对
Map<String,Object> keyMap=Test1.initKey();
//公钥
byte[] publicKey=Test1.getPublicKey(keyMap);
//私钥
byte[] privateKey=Test1.getPrivateKey(keyMap);
System.out.println("公钥：/n"+Base64.encodeBase64String(publicKey));
System.out.println("私钥：/n"+Base64.encodeBase64String(privateKey));
System.out.println("================密钥对构造完毕,甲方将公钥公布给乙方，开始进行加密数据的传输=============");
String str="Hello ELGamal";
System.out.println("/n===========甲方向乙方发送加密数据==============");
System.out.println("原文:"+str);
//乙方使用公钥对数据进行加密
byte[] code2=Test1.encryptByPublicKey(str.getBytes(), publicKey);
System.out.println("===========乙方使用公钥对数据进行加密==============");
System.out.println("加密后的数据："+Base64.encodeBase64String(code2));
//甲方使用私钥对数据进行解密
byte[] decode2=Test1.decryptByPrivateKey(code2, privateKey);
System.out.println("甲方解密后的数据："+new String(decode2));
}
}
-----------------
需要用到的jar包：
http://download.csdn.net/download/qq_35255384/10227321