Java加密算法-加密算法汇总

「爱情、让人受尽委屈。」 2023-10-15 15:12 66阅读 0赞

## Java加密算法-加密算法汇总 ##

如基本的单向加密算法：

*  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，椭圆曲线密码编码学)
    
    本篇内容简要介绍**BASE64**、**MD5**、**SHA**、**HMAC**几种方法。  
    **MD5**、**SHA**、**HMAC**这三种加密算法，可谓是非可逆加密，就是不可解密的加密方法。我们通常只把他们作为加密的基础。单纯的以上三种的加密并不可靠。

**BASE64**  
按 照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）  
常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。

![各种Java加密算法][Java]

通过java代码实现如下：

/**
         * 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);
        }

主要就是BASE64Encoder、BASE64Decoder两个类，我们只需要知道使用对应的方法即可。另，BASE加密后产生的字节位数是8的倍数，如果不够位数以\*\*=\*\*符号填充。

**MD5**  
MD5 – message-digest algorithm 5 （信息-摘要算法）缩写，广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD5后都能生成唯一的MD5值。好比现在的ISO校验，都 是MD5校验。怎么用？当然是把ISO经过MD5后产生MD5的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD5的串。就是用来验证文 件是否一致的。

![各种Java加密算法][Java 1]

通过java代码实现如下：

/**
         * MD5加密
         * 
         * @param data
         * @return
         * @throws Exception
         */
        public static byte[] encryptMD5(byte[] data) throws Exception {
        
     
            MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
            md5.update(data);
     
            return md5.digest();
     
        }

通常我们不直接使用上述MD5加密。通常将MD5产生的字节数组交给BASE64再加密一把，得到相应的字符串。

**SHA**  
SHA(Secure Hash Algorithm，安全散列算法），数字签名等密码学应用中重要的工具，被广泛地应用于电子商务等信息安全领域。虽然，SHA与MD5通过碰撞法都被破解了， 但是SHA仍然是公认的安全加密算法，较之MD5更为安全。

![各种Java加密算法][Java 2]

通过java代码实现如下：

/**
         * SHA加密
         * 
         * @param data
         * @return
         * @throws Exception
         */
        public static byte[] encryptSHA(byte[] data) throws Exception {
        
     
            MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
            sha.update(data);
     
            return sha.digest();
     
        }
    }

**HMAC**  
HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个 标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证 等。

![各种Java加密算法][Java 3]

通过java代码实现如下：

/**
         * 初始化HMAC密钥
         * 
         * @return
         * @throws Exception
         */
        public static String initMacKey() throws Exception {
        
            KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
     
            SecretKey secretKey = keyGenerator.generateKey();
            return encryptBASE64(secretKey.getEncoded());
        }
     
        /**
         * HMAC加密
         * 
         * @param data
         * @param key
         * @return
         * @throws Exception
         */
        public static byte[] encryptHMAC(byte[] data, String key) throws Exception {
        
     
            SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
            Mac mac = Mac.getInstance(secretKey.getAlgorithm());
            mac.init(secretKey);
     
            return mac.doFinal(data);
     
        }

给出一个完整类，如下：

import java.security.MessageDigest;
 
 import javax.crypto.KeyGenerator;
 import javax.crypto.Mac;
 import javax.crypto.SecretKey;
 
 import sun.misc.BASE64Decoder;
 import sun.misc.BASE64Encoder;
 
 /**
 * 基础加密组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public abstract class Coder {
 
 public static final String KEY_SHA = "SHA";
 public static final String KEY_MD5 = "MD5";
 
 /**
 * MAC算法可选以下多种算法
 * 
 * <pre>
 * HmacMD5 
 * HmacSHA1 
 * HmacSHA256 
 * HmacSHA384 
 * HmacSHA512
 * </pre>
 */
 public static final String KEY_MAC = "HmacMD5";
 
 /**
 * 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);
 }
 
 /**
 * MD5加密
 * 
 * @param data
 * @return
 * @throws Exception
 */
 public static byte[] encryptMD5(byte[] data) throws Exception {
 
 
 MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
 md5.update(data);
 
 return md5.digest();
 
 }
 
 /**
 * SHA加密
 * 
 * @param data
 * @return
 * @throws Exception
 */
 public static byte[] encryptSHA(byte[] data) throws Exception {
 
 
 MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
 sha.update(data);
 
 return sha.digest();
 
 }
 
 /**
 * 初始化HMAC密钥
 * 
 * @return
 * @throws Exception
 */
 public static String initMacKey() throws Exception {
 
 KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
 
 SecretKey secretKey = keyGenerator.generateKey();
 return encryptBASE64(secretKey.getEncoded());
 }
 
 /**
 * HMAC加密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] encryptHMAC(byte[] data, String key) throws Exception {
 
 
 SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);
 Mac mac = Mac.getInstance(secretKey.getAlgorithm());
 mac.init(secretKey);
 
 return mac.doFinal(data);
 
 }
 }

再给出一个测试类：

import static org.junit.Assert.*;
     
    import org.junit.Test;
     
    /**
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class CoderTest {
        
     
        @Test
        public void test() throws Exception {
        
            String inputStr = "简单加密";
            System.err.println("原文:\n" + inputStr);
     
            byte[] inputData = inputStr.getBytes();
            String code = Coder.encryptBASE64(inputData);
     
            System.err.println("BASE64加密后:\n" + code);
     
            byte[] output = Coder.decryptBASE64(code);
     
            String outputStr = new String(output);
     
            System.err.println("BASE64解密后:\n" + outputStr);
     
            // 验证BASE64加密解密一致性
            assertEquals(inputStr, outputStr);
     
            // 验证MD5对于同一内容加密是否一致
            assertArrayEquals(Coder.encryptMD5(inputData), Coder
                    .encryptMD5(inputData));
     
            // 验证SHA对于同一内容加密是否一致
            assertArrayEquals(Coder.encryptSHA(inputData), Coder
                    .encryptSHA(inputData));
     
            String key = Coder.initMacKey();
            System.err.println("Mac密钥:\n" + key);
     
            // 验证HMAC对于同一内容，同一密钥加密是否一致
            assertArrayEquals(Coder.encryptHMAC(inputData, key), Coder.encryptHMAC(
                    inputData, key));
     
            BigInteger md5 = new BigInteger(Coder.encryptMD5(inputData));
            System.err.println("MD5:\n" + md5.toString(16));
     
            BigInteger sha = new BigInteger(Coder.encryptSHA(inputData));
            System.err.println("SHA:\n" + sha.toString(32));
     
            BigInteger mac = new BigInteger(Coder.encryptHMAC(inputData, inputStr));
            System.err.println("HMAC:\n" + mac.toString(16));
        }
    }

控制台输出：

原文:
    简单加密
    BASE64加密后:
    566A5Y2V5Yqg5a+G
    
    BASE64解密后:
    简单加密
    Mac密钥:
    uGxdHC+6ylRDaik++leFtGwiMbuYUJ6mqHWyhSgF4trVkVBBSQvY/a22xU8XT1RUemdCWW155Bke
    pBIpkd7QHg==
    
    MD5:
    -550b4d90349ad4629462113e7934de56
    SHA:
    91k9vo7p400cjkgfhjh0ia9qthsjagfn
    HMAC:
    2287d192387e95694bdbba2fa941009a

注意  
编译时，可能会看到如下提示：

引用

警告：sun.misc.BASE64Decoder 是 Sun 的专用 API，可能会在未来版本中删除

import sun.misc.BASE64Decoder;  
^  
警告：sun.misc.BASE64Encoder 是 Sun 的专用 API，可能会在未来版本中删除

import sun.misc.BASE64Encoder;  
^

BASE64Encoder 和BASE64Decoder是非官方JDK实现类。虽然可以在JDK里能找到并使用，但是在API里查不到。JRE 中 sun 和 com.sun 开头包的类都是未被文档化的，他们属于 java, javax 类库的基础，其中的实现大多数与底层平台有关，一般来说是不推荐使用的。

BASE64的加密解密是双向的，可以求反解。  
MD5、SHA以及HMAC是单向加密，任何数据加密后只会产生唯一的一个加密串，通常用来校验数据在传输过程中是否被修改。其中HMAC算法有一个密钥，增强了数据传输过程中的安全性，强化了算法外的不可控因素。  
单向加密的用途主要是为了校验数据在传输过程中是否被修改。

接下来我们介绍对称加密算法，最常用的莫过于DES数据加密算法。  
**DES**  
DES-Data Encryption Standard,即数据加密算法。是IBM公司于1975年研究成功并公开发表的。DES算法的入口参数有三个:Key、Data、Mode。其中 Key为8个字节共64位,是DES算法的工作密钥;Data也为8个字节64位,是要被加密或被解密的数据;Mode为DES的工作方式,有两种:加密 或解密。  
DES算法把64位的明文输入块变为64位的密文输出块,它所使用的密钥也是64位。

通过java代码实现如下：**Coder类见**

import java.security.Key;
 import java.security.SecureRandom;
 
 import javax.crypto.Cipher;
 import javax.crypto.KeyGenerator;
 import javax.crypto.SecretKey;
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.DESKeySpec;
 
 
 /**
 * DES安全编码组件
 * 
 * <pre>
 * 支持 DES、DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)
 * DES key size must be equal to 56
 * DESede(TripleDES) key size must be equal to 112 or 168
 * AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
 * Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
 * RC2 key size must be between 40 and 1024 bits
 * RC4(ARCFOUR) key size must be between 40 and 1024 bits
 * 具体内容 需要关注 JDK Document http://.../docs/technotes/guides/security/SunProviders.html
 * </pre>
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public abstract class DESCoder extends Coder {
 
 /**
 * ALGORITHM 算法 
 * 可替换为以下任意一种算法，同时key值的size相应改变。
 * 
 * <pre>
 * DES key size must be equal to 56
 * DESede(TripleDES) key size must be equal to 112 or 168
 * AES key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
 * Blowfish key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
 * RC2 key size must be between 40 and 1024 bits
 * RC4(ARCFOUR) key size must be between 40 and 1024 bits
 * </pre>
 * 
 * 在Key toKey(byte[] key)方法中使用下述代码
 * <code>SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);</code> 替换
 * <code>
 * DESKeySpec dks = new DESKeySpec(key);
 * SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 * SecretKey secretKey = keyFactory.generateSecret(dks);
 * </code>
 */
 public static final String ALGORITHM = "DES";
 
 /**
 * 转换密钥 
 * 
 * @param key
 * @return
 * @throws Exception
 */
 private static Key toKey(byte[] key) throws Exception {
 
 DESKeySpec dks = new DESKeySpec(key);
 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 SecretKey secretKey = keyFactory.generateSecret(dks);
 
 // 当使用其他对称加密算法时，如AES、Blowfish等算法时，用下述代码替换上述三行代码
 // SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);
 
 return secretKey;
 }
 
 /**
 * 解密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, String key) throws Exception {
 
 Key k = toKey(decryptBASE64(key));
 
 Cipher cipher = Cipher.getInstance(ALGORITHM);
 cipher.init(Cipher.DECRYPT_MODE, k);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 加密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, String key) throws Exception {
 
 Key k = toKey(decryptBASE64(key));
 Cipher cipher = Cipher.getInstance(ALGORITHM);
 cipher.init(Cipher.ENCRYPT_MODE, k);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 生成密钥
 * 
 * @return
 * @throws Exception
 */
 public static String initKey() throws Exception {
 
 return initKey(null);
 }
 
 /**
 * 生成密钥
 * 
 * @param seed
 * @return
 * @throws Exception
 */
 public static String initKey(String seed) throws Exception {
 
 SecureRandom secureRandom = null;
 
 if (seed != null) {
 
 secureRandom = new SecureRandom(decryptBASE64(seed));
 } else {
 
 secureRandom = new SecureRandom();
 }
 
 KeyGenerator kg = KeyGenerator.getInstance(ALGORITHM);
 kg.init(secureRandom);
 
 SecretKey secretKey = kg.generateKey();
 
 return encryptBASE64(secretKey.getEncoded());
 }
 }

延续上一个类的实现，我们通过MD5以及SHA对字符串加密生成密钥，这是比较常见的密钥生成方式。  
再给出一个测试类：

import static org.junit.Assert.*;
     
     
    import org.junit.Test;
     
    /**
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class DESCoderTest {
        
     
        @Test
        public void test() throws Exception {
        
            String inputStr = "DES";
            String key = DESCoder.initKey();
            System.err.println("原文:\t" + inputStr);
     
            System.err.println("密钥:\t" + key);
     
            byte[] inputData = inputStr.getBytes();
            inputData = DESCoder.encrypt(inputData, key);
     
            System.err.println("加密后:\t" + DESCoder.encryptBASE64(inputData));
     
            byte[] outputData = DESCoder.decrypt(inputData, key);
            String outputStr = new String(outputData);
     
            System.err.println("解密后:\t" + outputStr);
     
            assertEquals(inputStr, outputStr);
        }
    }

得到的输出内容如下：

原文:	DES
    密钥:	f3wEtRrV6q0=
    
    加密后:	C6qe9oNIzRY=
    
    解密后:	DES

由控制台得到的输出，我们能够比对加密、解密后结果一致。这是一种简单的加密解密方式，只有一个密钥。  
其实DES有很多同胞兄弟，如DESede(TripleDES)、AES、Blowfish、RC2、RC4(ARCFOUR)。这里就不过多阐述了，大同小异，只要换掉ALGORITHM换成对应的值，同时做一个代码替换\*\*SecretKey secretKey = new SecretKeySpec(key, ALGORITHM);\*\*就可以了，此外就是密钥长度不同了。

/**
     * DES          key size must be equal to 56
     * DESede(TripleDES) key size must be equal to 112 or 168
     * AES          key size must be equal to 128, 192 or 256,but 192 and 256 bits may not be available
     * Blowfish     key size must be multiple of 8, and can only range from 32 to 448 (inclusive)
     * RC2          key size must be between 40 and 1024 bits
     * RC4(ARCFOUR) key size must be between 40 and 1024 bits
     **/

除了DES，我们还知道有DESede(TripleDES,就是3DES)、AES、Blowfish、RC2、RC4(ARCFOUR)等多种对称加密方式，其实现方式大同小异，这里介绍对称加密的另一个算法——PBE  
**PBE**  
PBE——Password-based encryption（基于密码加密）。其特点在于口令由用户自己掌管，不借助任何物理媒体；采用随机数（这里我们叫做盐）杂凑多重加密等方法保证数据的安全性。是一种简便的加密方式。  
通过java代码实现如下：**Coder类见**

import java.security.Key;
 import java.util.Random;
 
 import javax.crypto.Cipher;
 import javax.crypto.SecretKey;
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.spec.PBEKeySpec;
 import javax.crypto.spec.PBEParameterSpec;
 
 /**
 * PBE安全编码组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public abstract class PBECoder extends Coder {
 
 /**
 * 支持以下任意一种算法
 * 
 * <pre>
 * PBEWithMD5AndDES 
 * PBEWithMD5AndTripleDES 
 * PBEWithSHA1AndDESede
 * PBEWithSHA1AndRC2_40
 * </pre>
 */
 public static final String ALGORITHM = "PBEWITHMD5andDES";
 
 /**
 * 盐初始化
 * 
 * @return
 * @throws Exception
 */
 public static byte[] initSalt() throws Exception {
 
 byte[] salt = new byte[8];
 Random random = new Random();
 random.nextBytes(salt);
 return salt;
 }
 
 /**
 * 转换密钥 
 * 
 * @param password
 * @return
 * @throws Exception
 */
 private static Key toKey(String password) throws Exception {
 
 PBEKeySpec keySpec = new PBEKeySpec(password.toCharArray());
 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 SecretKey secretKey = keyFactory.generateSecret(keySpec);
 
 return secretKey;
 }
 
 /**
 * 加密
 * 
 * @param data 数据
 * @param password 密码
 * @param salt 盐
 * @return
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, String password, byte[] salt)
 throws Exception {
 
 
 Key key = toKey(password);
 
 PBEParameterSpec paramSpec = new PBEParameterSpec(salt, 100);
 Cipher cipher = Cipher.getInstance(ALGORITHM);
 cipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
 
 return cipher.doFinal(data);
 
 }
 
 /**
 * 解密
 * 
 * @param data 数据
 * @param password 密码
 * @param salt 盐
 * @return
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, String password, byte[] salt)
 throws Exception {
 
 
 Key key = toKey(password);
 
 PBEParameterSpec paramSpec = new PBEParameterSpec(salt, 100);
 Cipher cipher = Cipher.getInstance(ALGORITHM);
 cipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
 
 return cipher.doFinal(data);
 
 }
 }

再给出一个测试类：

import static org.junit.Assert.*;
      
    import org.junit.Test;
      
    /**
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class PBECoderTest {
        
      
        @Test
        public void test() throws Exception {
        
            String inputStr = "abc";
            System.err.println("原文: " + inputStr);
            byte[] input = inputStr.getBytes();
      
            String pwd = "efg";
            System.err.println("密码: " + pwd);
      
            byte[] salt = PBECoder.initSalt();
      
            byte[] data = PBECoder.encrypt(input, pwd, salt);
      
            System.err.println("加密后: " + PBECoder.encryptBASE64(data));
      
            byte[] output = PBECoder.decrypt(data, pwd, salt);
            String outputStr = new String(output);
      
            System.err.println("解密后: " + outputStr);
            assertEquals(inputStr, outputStr);
        }
      
    }

控制台输出：

原文: abc
    密码: efg
    加密后: iCZ0uRtaAhE=
     
    解密后: abc

后续我们会介绍非对称加密算法，如RSA、DSA、DH、ECC等。

接下来我们介绍典型的非对称加密算法——RSA

**RSA**  
这种算法1978年就出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman。  
这种加密算法的特点主要是密钥的变化，上文我们看到DES只有一个密钥。相当于只有一把钥匙，如果这把钥匙丢了，数据也就不安全了。RSA同时有两把钥 匙，公钥与私钥。同时支持数字签名。数字签名的意义在于，对传输过来的数据进行校验。确保数据在传输工程中不被修改。

**流程分析：**

1.  甲方构建密钥对儿，将公钥公布给乙方，将私钥保留。
2.  甲方使用私钥加密数据，然后用私钥对加密后的数据签名，发送给乙方签名以及加密后的数据；乙方使用公钥、签名来验证待解密数据是否有效，如果有效使用公钥对数据解密。
3.  乙方使用公钥加密数据，向甲方发送经过加密后的数据；甲方获得加密数据，通过私钥解密。

按如上步骤给出序列图，如下：

1.  ![各种Java加密算法][Java 4]
2.  ![各种Java加密算法][Java 5]
3.  ![各种Java加密算法][Java 6]

通过java代码实现如下：**Coder类见**

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;
 
 /**
 * RSA安全编码组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public abstract class RSACoder extends Coder {
 
 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";
 
 /**
 * 用私钥对信息生成数字签名
 * 
 * @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 校验成功返回true 失败返回false
 * @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));
 }
 
 /**
 * 解密 
 * 用私钥解密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] decryptByPrivateKey(byte[] data, String key)
 throws Exception {
 
 // 对密钥解密
 byte[] keyBytes = decryptBASE64(key);
 
 // 取得私钥
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
 // 对数据解密
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.DECRYPT_MODE, privateKey);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 解密 
 * 用私钥解密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] decryptByPublicKey(byte[] data, String key)
 throws Exception {
 
 // 对密钥解密
 byte[] keyBytes = decryptBASE64(key);
 
 // 取得公钥
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key publicKey = keyFactory.generatePublic(x509KeySpec);
 
 // 对数据解密
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.DECRYPT_MODE, publicKey);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 加密 
 * 用公钥加密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] encryptByPublicKey(byte[] data, String key)
 throws Exception {
 
 // 对公钥解密
 byte[] keyBytes = decryptBASE64(key);
 
 // 取得公钥
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key publicKey = keyFactory.generatePublic(x509KeySpec);
 
 // 对数据加密
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.ENCRYPT_MODE, publicKey);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 加密 
 * 用私钥加密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] encryptByPrivateKey(byte[] data, String key)
 throws Exception {
 
 // 对密钥解密
 byte[] keyBytes = decryptBASE64(key);
 
 // 取得私钥
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
 Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
 // 对数据加密
 Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
 cipher.init(Cipher.ENCRYPT_MODE, privateKey);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 取得私钥
 * 
 * @param keyMap
 * @return
 * @throws Exception
 */
 public static String getPrivateKey(Map<String, Object> keyMap)
 throws Exception {
 
 Key key = (Key) keyMap.get(PRIVATE_KEY);
 
 return encryptBASE64(key.getEncoded());
 }
 
 /**
 * 取得公钥
 * 
 * @param keyMap
 * @return
 * @throws Exception
 */
 public static String getPublicKey(Map<String, Object> keyMap)
 throws Exception {
 
 Key key = (Key) keyMap.get(PUBLIC_KEY);
 
 return encryptBASE64(key.getEncoded());
 }
 
 /**
 * 初始化密钥
 * 
 * @return
 * @throws Exception
 */
 public static Map<String, Object> initKey() throws Exception {
 
 KeyPairGenerator keyPairGen = KeyPairGenerator
 .getInstance(KEY_ALGORITHM);
 keyPairGen.initialize(1024);
 
 KeyPair keyPair = keyPairGen.generateKeyPair();
 
 // 公钥
 RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
 
 // 私钥
 RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
 
 Map<String, Object> keyMap = new HashMap<String, Object>(2);
 
 keyMap.put(PUBLIC_KEY, publicKey);
 keyMap.put(PRIVATE_KEY, privateKey);
 return keyMap;
 }
 }

再给出一个测试类：

import static org.junit.Assert.*;
 
 import org.junit.Before;
 import org.junit.Test;
 
 import java.util.Map;
 
 /**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public class RSACoderTest {
 
 private String publicKey;
 private String privateKey;
 
 @Before
 public void setUp() throws Exception {
 
 Map<String, Object> keyMap = RSACoder.initKey();
 
 publicKey = RSACoder.getPublicKey(keyMap);
 privateKey = RSACoder.getPrivateKey(keyMap);
 System.err.println("公钥: \n\r" + publicKey);
 System.err.println("私钥： \n\r" + privateKey);
 }
 
 @Test
 public void test() throws Exception {
 
 System.err.println("公钥加密——私钥解密");
 String inputStr = "abc";
 byte[] data = inputStr.getBytes();
 
 byte[] encodedData = RSACoder.encryptByPublicKey(data, publicKey);
 
 byte[] decodedData = RSACoder.decryptByPrivateKey(encodedData,
 privateKey);
 
 String outputStr = new String(decodedData);
 System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
 assertEquals(inputStr, outputStr);
 
 }
 
 @Test
 public void testSign() throws Exception {
 
 System.err.println("私钥加密——公钥解密");
 String inputStr = "sign";
 byte[] data = inputStr.getBytes();
 
 byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);
 
 byte[] decodedData = RSACoder
 .decryptByPublicKey(encodedData, publicKey);
 
 String outputStr = new String(decodedData);
 System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
 assertEquals(inputStr, outputStr);
 
 System.err.println("私钥签名——公钥验证签名");
 // 产生签名
 String sign = RSACoder.sign(encodedData, privateKey);
 System.err.println("签名:\r" + sign);
 
 // 验证签名
 boolean status = RSACoder.verify(encodedData, publicKey, sign);
 System.err.println("状态:\r" + status);
 assertTrue(status);
 
 }
 
 }

控制台输出：

公钥: 
    
    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCYU/+I0+z1aBl5X6DUUOHQ7FZpmBSDbKTtx89J
    EcB64jFCkunELT8qiKly7fzEqD03g8ALlu5XvX+bBqHFy7YPJJP0ekE2X3wjUnh2NxlqpH3/B/xm
    1ZdSlCwDIkbijhBVDjA/bu5BObhZqQmDwIxlQInL9oVz+o6FbAZCyHBd7wIDAQAB
    
    私钥： 
    
    MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAJhT/4jT7PVoGXlfoNRQ4dDsVmmY
    FINspO3Hz0kRwHriMUKS6cQtPyqIqXLt/MSoPTeDwAuW7le9f5sGocXLtg8kk/R6QTZffCNSeHY3
    GWqkff8H/GbVl1KULAMiRuKOEFUOMD9u7kE5uFmpCYPAjGVAicv2hXP6joVsBkLIcF3vAgMBAAEC
    gYBvZHWoZHmS2EZQqKqeuGr58eobG9hcZzWQoJ4nq/CarBAjw/VovUHE490uK3S9ht4FW7Yzg3LV
    /MB06Huifh6qf/X9NQA7SeZRRC8gnCQk6JuDIEVJOud5jU+9tyumJakDKodQ3Jf2zQtNr+5ZdEPl
    uwWgv9c4kmpjhAdyMuQmYQJBANn6pcgvyYaia52dnu+yBUsGkaFfwXkzFSExIbi0MXTkhEb/ER/D
    rLytukkUu5S5ecz/KBa8U4xIslZDYQbLz5ECQQCy5dutt7RsxN4+dxCWn0/1FrkWl2G329Ucewm3
    QU9CKu4D+7Kqdj+Ha3lXP8F0Etaaapi7+EfkRUpukn2ItZV/AkEAlk+I0iphxT1rCB0Q5CjWDY5S
    Df2B5JmdEG5Y2o0nLXwG2w44OLct/k2uD4cEcuITY5Dvi/4BftMCZwm/dnhEgQJACIktJSnJwxLV
    o9dchENPtlsCM9C/Sd2EWpqISSUlmfugZbJBwR5pQ5XeMUqKeXZYpP+HEBj1nS+tMH9u2/IGEwJA
    fL8mZiZXan/oBKrblAbplNcKWGRVD/3y65042PAEeghahlJMiYquV5DzZajuuT0wbJ5xQuZB01+X
    nfpFpBJ2dw==
    
    公钥加密——私钥解密
    加密前: abc
    
    解密后: abc
    公钥: 
    
    MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDdOj40yEB48XqWxmPILmJAc7UecIN7F32etSHF
    9rwbuEh3+iTPOGSxhoSQpOED0vOb0ZIMkBXZSgsxLaBSin2RZ09YKWRjtpCA0kDkiD11gj4tzTiM
    l9qq1kwSK7ZkGAgodEn3yIILVmQDuEImHOXFtulvJ71ka07u3LuwUNdB/wIDAQAB
    
    私钥： 
    
    MIICdwIBADANBgkqhkiG9w0BAQEFAASCAmEwggJdAgEAAoGBAN06PjTIQHjxepbGY8guYkBztR5w
    g3sXfZ61IcX2vBu4SHf6JM84ZLGGhJCk4QPS85vRkgyQFdlKCzEtoFKKfZFnT1gpZGO2kIDSQOSI
    PXWCPi3NOIyX2qrWTBIrtmQYCCh0SffIggtWZAO4QiYc5cW26W8nvWRrTu7cu7BQ10H/AgMBAAEC
    gYEAz2JWBizjI31bqhP4XiP9PuY5F3vqBW4T+L9cFbQiyumKJc58yzTWUAUGKIIn3enXLG7dNqGr
    mbJro4JeFIJ3CiVDpXR9+FluIgI4SXm7ioGKF2NOMA9LR5Fu82W+pLfpTN2y2SaLYWEDZyp53BxY
    j9gUxaxi1MQs+C1ZgDF2xmECQQDy70bQntbRfysP+ppCtd56YRnES1Tyekw0wryS2tr+ivQJl7JF
    gp5rPAOXpgrq36xHDwUspQ0sJ0vj0O7ywxr1AkEA6SAaLhrJJrYucC0jxwAhUYyaPN+aOsWymaRh
    9jA/Wc0wp29SbGTh5CcMuGpXm1g0M+FKW3dGiHgS3rVUKim4owJAbnxgapUzAgiiHxxMeDaavnHW
    9C2GrtjsO7qtZOTgYI/1uT8itvZW8lJTF+9OW8/qXE76fXl7ai9dFnl5kzMk2QJBALfHz/vCsArt
    mkRiwY6zApE4Z6tPl1V33ymSVovvUzHnOdD1SKQdD5t+UV/crb3QVi8ED0t2B0u0ZSPfDT/D7kMC
    QDpwdj9k2F5aokLHBHUNJPFDAp7a5QMaT64gv/d48ITJ68Co+v5WzLMpzJBYXK6PAtqIhxbuPEc2
    I2k1Afmrwyw=
    
    私钥加密——公钥解密
    加密前: sign
    
    解密后: sign
    私钥签名——公钥验证签名
    签名:
    ud1RsIwmSC1pN22I4IXteg1VD2FbiehKUfNxgVSHzvQNIK+d20FCkHCqh9djP3h94iWnIUY0ifU+
    mbJkhAl/i5krExOE0hknOnPMcEP+lZV1RbJI2zG2YooSp2XDleqrQk5e/QF2Mx0Zxt8Xsg7ucVpn
    i3wwbYWs9wSzIf0UjlM=
    
    状态:
    true

简要总结一下，使用公钥加密、私钥解密，完成了乙方到甲方的一次数据传递，通过私钥加密、公钥解密，同时通过私钥签名、公钥验证签名，完成了一次甲方到乙方的数据传递与验证，两次数据传递完成一整套的数据交互！

类似数字签名，数字信封是这样描述的：

**数字信封**  
数字信封用加密技术来保证只有特定的收信人才能阅读信的内容。  
流程：  
信息发送方采用对称密钥来加密信息，然后再用接收方的公钥来加密此对称密钥（这部分称为数字信封），再将它和信息一起发送给接收方；接收方先用相应的私钥打开数字信封，得到对称密钥，然后使用对称密钥再解开信息。

接下来我们分析DH加密算法，一种适基于密钥一致协议的加密算法。  
**DH**  
Diffie- Hellman算法(D-H算法)，密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用 户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。换句话说，就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私 钥）。以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（SecretKey）对数据加密。这样，在互通了本地密钥 （SecretKey）算法后，甲乙双方公开自己的公钥，使用对方的公钥和刚才产生的私钥加密数据，同时可以使用对方的公钥和自己的私钥对数据解密。不单 单是甲乙双方两方，可以扩展为多方共享数据通讯，这样就完成了网络交互数据的安全通讯！该算法源于中国的同余定理——中国馀数定理。

流程分析：

1.甲方构建密钥对儿，将公钥公布给乙方，将私钥保留；双方约定数据加密算法；乙方通过甲方公钥构建密钥对儿，将公钥公布给甲方，将私钥保留。  
2.甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给乙方加密后的数据；乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。  
3.乙方使用私钥、甲方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥加密数据，发送给甲方加密后的数据；甲方使用私钥、乙方公钥、约定数据加密算法构建本地密钥，然后通过本地密钥对数据解密。

1.  1.

![各种Java加密算法][Java 7]

1.  ![各种Java加密算法][Java 8]
2.  ![各种Java加密算法][Java 9]

通过java代码实现如下：**Coder类见**

import java.security.Key;
 import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.PublicKey;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.security.spec.X509EncodedKeySpec;
 import java.util.HashMap;
 import java.util.Map;
 
 import javax.crypto.Cipher;
 import javax.crypto.KeyAgreement;
 import javax.crypto.SecretKey;
 import javax.crypto.interfaces.DHPrivateKey;
 import javax.crypto.interfaces.DHPublicKey;
 import javax.crypto.spec.DHParameterSpec;
 
 /**
 * DH安全编码组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public abstract class DHCoder extends Coder {
 
 public static final String ALGORITHM = "DH";
 
 /**
 * 默认密钥字节数
 * 
 * <pre>
 * DH
 * Default Keysize 1024 
 * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
 * </pre>
 */
 private static final int KEY_SIZE = 1024;
 
 /**
 * DH加密下需要一种对称加密算法对数据加密，这里我们使用DES，也可以使用其他对称加密算法。
 */
 public static final String SECRET_ALGORITHM = "DES";
 private static final String PUBLIC_KEY = "DHPublicKey";
 private static final String PRIVATE_KEY = "DHPrivateKey";
 
 /**
 * 初始化甲方密钥
 * 
 * @return
 * @throws Exception
 */
 public static Map<String, Object> initKey() throws Exception {
 
 KeyPairGenerator keyPairGenerator = KeyPairGenerator
 .getInstance(ALGORITHM);
 keyPairGenerator.initialize(KEY_SIZE);
 
 KeyPair keyPair = keyPairGenerator.generateKeyPair();
 
 // 甲方公钥
 DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
 
 // 甲方私钥
 DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
 
 Map<String, Object> keyMap = new HashMap<String, Object>(2);
 
 keyMap.put(PUBLIC_KEY, publicKey);
 keyMap.put(PRIVATE_KEY, privateKey);
 return keyMap;
 }
 
 /**
 * 初始化乙方密钥
 * 
 * @param key
 * 甲方公钥
 * @return
 * @throws Exception
 */
 public static Map<String, Object> initKey(String key) throws Exception {
 
 // 解析甲方公钥
 byte[] keyBytes = decryptBASE64(key);
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
 PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
 
 // 由甲方公钥构建乙方密钥
 DHParameterSpec dhParamSpec = ((DHPublicKey) pubKey).getParams();
 
 KeyPairGenerator keyPairGenerator = KeyPairGenerator
 .getInstance(keyFactory.getAlgorithm());
 keyPairGenerator.initialize(dhParamSpec);
 
 KeyPair keyPair = keyPairGenerator.generateKeyPair();
 
 // 乙方公钥
 DHPublicKey publicKey = (DHPublicKey) keyPair.getPublic();
 
 // 乙方私钥
 DHPrivateKey privateKey = (DHPrivateKey) keyPair.getPrivate();
 
 Map<String, Object> keyMap = new HashMap<String, Object>(2);
 
 keyMap.put(PUBLIC_KEY, publicKey);
 keyMap.put(PRIVATE_KEY, privateKey);
 
 return keyMap;
 }
 
 /**
 * 加密 
 * 
 * @param data
 * 待加密数据
 * @param publicKey
 * 甲方公钥
 * @param privateKey
 * 乙方私钥
 * @return
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, String publicKey,
 String privateKey) throws Exception {
 
 
 // 生成本地密钥
 SecretKey secretKey = getSecretKey(publicKey, privateKey);
 
 // 数据加密
 Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
 cipher.init(Cipher.ENCRYPT_MODE, secretKey);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 解密 
 * 
 * @param data
 * 待解密数据
 * @param publicKey
 * 乙方公钥
 * @param privateKey
 * 乙方私钥
 * @return
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, String publicKey,
 String privateKey) throws Exception {
 
 
 // 生成本地密钥
 SecretKey secretKey = getSecretKey(publicKey, privateKey);
 // 数据解密
 Cipher cipher = Cipher.getInstance(secretKey.getAlgorithm());
 cipher.init(Cipher.DECRYPT_MODE, secretKey);
 
 return cipher.doFinal(data);
 }
 
 /**
 * 构建密钥
 * 
 * @param publicKey
 * 公钥
 * @param privateKey
 * 私钥
 * @return
 * @throws Exception
 */
 private static SecretKey getSecretKey(String publicKey, String privateKey)
 throws Exception {
 
 // 初始化公钥
 byte[] pubKeyBytes = decryptBASE64(publicKey);
 
 KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(pubKeyBytes);
 PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
 
 // 初始化私钥
 byte[] priKeyBytes = decryptBASE64(privateKey);
 
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(priKeyBytes);
 Key priKey = keyFactory.generatePrivate(pkcs8KeySpec);
 
 KeyAgreement keyAgree = KeyAgreement.getInstance(keyFactory
 .getAlgorithm());
 keyAgree.init(priKey);
 keyAgree.doPhase(pubKey, true);
 
 // 生成本地密钥
 SecretKey secretKey = keyAgree.generateSecret(SECRET_ALGORITHM);
 
 return secretKey;
 }
 
 /**
 * 取得私钥
 * 
 * @param keyMap
 * @return
 * @throws Exception
 */
 public static String getPrivateKey(Map<String, Object> keyMap)
 throws Exception {
 
 Key key = (Key) keyMap.get(PRIVATE_KEY);
 
 return encryptBASE64(key.getEncoded());
 }
 
 /**
 * 取得公钥
 * 
 * @param keyMap
 * @return
 * @throws Exception
 */
 public static String getPublicKey(Map<String, Object> keyMap)
 throws Exception {
 
 Key key = (Key) keyMap.get(PUBLIC_KEY);
 
 return encryptBASE64(key.getEncoded());
 }
 }

再给出一个测试类：

import static org.junit.Assert.*;
 
 import java.util.Map;
 
 import org.junit.Test;
 
 /**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public class DHCoderTest {
 
 
 @Test
 public void test() throws Exception {
 
 // 生成甲方密钥对儿
 Map<String, Object> aKeyMap = DHCoder.initKey();
 String aPublicKey = DHCoder.getPublicKey(aKeyMap);
 String aPrivateKey = DHCoder.getPrivateKey(aKeyMap);
 
 System.err.println("甲方公钥:\r" + aPublicKey);
 System.err.println("甲方私钥:\r" + aPrivateKey);
 
 // 由甲方公钥产生本地密钥对儿
 Map<String, Object> bKeyMap = DHCoder.initKey(aPublicKey);
 String bPublicKey = DHCoder.getPublicKey(bKeyMap);
 String bPrivateKey = DHCoder.getPrivateKey(bKeyMap);
 
 System.err.println("乙方公钥:\r" + bPublicKey);
 System.err.println("乙方私钥:\r" + bPrivateKey);
 
 String aInput = "abc ";
 System.err.println("原文: " + aInput);
 
 // 由甲方公钥，乙方私钥构建密文
 byte[] aCode = DHCoder.encrypt(aInput.getBytes(), aPublicKey,
 bPrivateKey);
 
 // 由乙方公钥，甲方私钥解密
 byte[] aDecode = DHCoder.decrypt(aCode, bPublicKey, aPrivateKey);
 String aOutput = (new String(aDecode));
 
 System.err.println("解密: " + aOutput);
 
 assertEquals(aInput, aOutput);
 
 System.err.println(" ===============反过来加密解密================== ");
 String bInput = "def ";
 System.err.println("原文: " + bInput);
 
 // 由乙方公钥，甲方私钥构建密文
 byte[] bCode = DHCoder.encrypt(bInput.getBytes(), bPublicKey,
 aPrivateKey);
 
 // 由甲方公钥，乙方私钥解密
 byte[] bDecode = DHCoder.decrypt(bCode, aPublicKey, bPrivateKey);
 String bOutput = (new String(bDecode));
 
 System.err.println("解密: " + bOutput);
 
 assertEquals(bInput, bOutput);
 }
 
 }

控制台输出：

甲方公钥:
    MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz
    W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG
    kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAdAWBVmIzqcko
    Ej6qFjLDL2+Y3FPq1iRbnOyOpDj71yKaK1K+FhTv04B0zy4DKcvAASV7/Gv0W+bgqdmffRkqrQ==
    
    甲方私钥:
    MIHRAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX
    rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD
    TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQyAjACJRfy1LyR
    eHyD+4Hfb+xR0uoIGR1oL9i9Nk6g2AAuaDPgEVWHn+QXID13yL/uDos=
    
    乙方公钥:
    MIHfMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYXrgHz
    W5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpDTWSG
    kx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgANDAAJAVEYSfBA+I9nr
    dWw3OBv475C+eBrWBBYqt0m6/eu4ptuDQHwV4MmUtKAC2wc2nNrdb1wmBhY1X8RnWkJ1XmdDbQ==
    
    乙方私钥:
    MIHSAgEAMIGXBgkqhkiG9w0BAwEwgYkCQQD8poLOjhLKuibvzPcRDlJtsHiwXt7LzR60ogjzrhYX
    rgHzW5Gkfm32NBPF4S7QiZvNEyrNUNmRUb3EPuc3WS4XAkBnhHGyepz0TukaScUUfbGpqvJE8FpD
    TWSGkx0tFCcbnjUDC3H9c9oXkGmzLik1Yw4cIGI1TQ2iCmxBblC+eUykAgIBgAQzAjEAqaZiCdXp
    2iNpdBlHRaO9ir70wo2n32xNlIzIX19VLSPCDdeUWkgRv4CEj/8k+/yd
    
    原文: abc 
    解密: abc 
     ===============反过来加密解密================== 
    原文: def 
    解密: def

如我所言，甲乙双方在获得对方公钥后可以对发送给对方的数据加密，同时也能对接收到的数据解密，达到了数据安全通信的目的！

接下来我们介绍DSA数字签名，非对称加密的另一种实现。  
**DSA**  
DSA-Digital Signature Algorithm 是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。简单的说，这是一种更高级的验证方式，用作数字签名。不单单只有公钥、私钥，还有数字签名。私钥加密生成数字签名，公钥验证数据及签 名。如果数据和签名不匹配则认为验证失败！数字签名的作用就是校验数据在传输过程中不被修改。数字签名，是单向加密的升级！

1.  ![各种Java加密算法][Java 10]
2.  ![各种Java加密算法][Java 11]

通过java代码实现如下：**Coder类见**

再给出一个测试类：

import static org.junit.Assert.*;
 
 import java.util.Map;
 
 import org.junit.Test;
 
 /**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public class DSACoderTest {
 
 
 @Test
 public void test() throws Exception {
 
 String inputStr = "abc";
 byte[] data = inputStr.getBytes();
 
 // 构建密钥
 Map<String, Object> keyMap = DSACoder.initKey();
 
 // 获得密钥
 String publicKey = DSACoder.getPublicKey(keyMap);
 String privateKey = DSACoder.getPrivateKey(keyMap);
 
 System.err.println("公钥:\r" + publicKey);
 System.err.println("私钥:\r" + privateKey);
 
 // 产生签名
 String sign = DSACoder.sign(data, privateKey);
 System.err.println("签名:\r" + sign);
 
 // 验证签名
 boolean status = DSACoder.verify(data, publicKey, sign);
 System.err.println("状态:\r" + status);
 assertTrue(status);
 
 }
 
 }

控制台输出：

公钥:
    MIIBtzCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZp
    RV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fn
    xqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuE
    C/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJ
    FnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImo
    g9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoDgYQAAoGAIu4RUlcQLp49PI0MrbssOY+3uySVnp0TULSv
    5T4VaHoKzsLHgGTrwOvsGA+V3yCNl2WDu3D84bSLF7liTWgOj+SMOEaPk4VyRTlLXZWGPsf1Mfd9
    21XAbMeVyKDSHHVGbMjBScajf3bXooYQMlyoHiOt/WrCo+mv7efstMM0PGo=
    
    私钥:
    MIIBTAIBADCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2
    USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4
    O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmC
    ouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCB
    gLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhR
    kImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoEFwIVAIegLUtmm2oQKQJTOiLugHTSjl/q
    
    签名:
    MC0CFQCMg0J/uZmF8GuRpr3TNq48w60nDwIUJCyYNah+HtbU6NcQfy8Ac6LeLQs=
    
    状态:
    true

注意状态为true，就验证成功！

**ECC**  
ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。  
当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的 资料，无论是官方还是非官方的解释，最终只有一种答案——ECC算法在jdk1.5后加入支持，目前仅仅只能完成密钥的生成与解析。 如果想要获得ECC算法实现，需要调用硬件完成加密/解密（ECC算法相当耗费资源，如果单纯使用CPU进行加密/解密，效率低下），涉及到Java Card领域，PKCS\#11。 其实，PKCS\#11配置很简单，但缺乏硬件设备，无法尝试！

尽管如此，我照旧提供相应的Java实现代码，以供大家参考。

通过java代码实现如下：**Coder类见**

import java.math.BigInteger;
 import java.security.Key;
 import java.security.KeyFactory;
 import java.security.interfaces.ECPrivateKey;
 import java.security.interfaces.ECPublicKey;
 import java.security.spec.ECFieldF2m;
 import java.security.spec.ECParameterSpec;
 import java.security.spec.ECPoint;
 import java.security.spec.ECPrivateKeySpec;
 import java.security.spec.ECPublicKeySpec;
 import java.security.spec.EllipticCurve;
 import java.security.spec.PKCS8EncodedKeySpec;
 import java.security.spec.X509EncodedKeySpec;
 import java.util.HashMap;
 import java.util.Map;
 
 import javax.crypto.Cipher;
 import javax.crypto.NullCipher;
 
 import sun.security.ec.ECKeyFactory;
 import sun.security.ec.ECPrivateKeyImpl;
 import sun.security.ec.ECPublicKeyImpl;
 
 /**
 * ECC安全编码组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public abstract class ECCCoder extends Coder {
 
 
 public static final String ALGORITHM = "EC";
 private static final String PUBLIC_KEY = "ECCPublicKey";
 private static final String PRIVATE_KEY = "ECCPrivateKey";
 
 /**
 * 解密 
 * 用私钥解密
 * 
 * @param data
 * @param key
 * @return
 * @throws Exception
 */
 public static byte[] decrypt(byte[] data, String key) throws Exception {
 
 // 对密钥解密
 byte[] keyBytes = decryptBASE64(key);
 
 // 取得私钥
 PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = ECKeyFactory.INSTANCE;
 
 ECPrivateKey priKey = (ECPrivateKey) keyFactory
 .generatePrivate(pkcs8KeySpec);
 
 ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),
 priKey.getParams());
 
 // 对数据解密
 // TODO Chipher不支持EC算法 未能实现
 Cipher cipher = new NullCipher();
 // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
 cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());
 
 return cipher.doFinal(data);
 }
 
 /**
 * 加密 
 * 用公钥加密
 * 
 * @param data
 * @param privateKey
 * @return
 * @throws Exception
 */
 public static byte[] encrypt(byte[] data, String privateKey)
 throws Exception {
 
 // 对公钥解密
 byte[] keyBytes = decryptBASE64(privateKey);
 
 // 取得公钥
 X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
 KeyFactory keyFactory = ECKeyFactory.INSTANCE;
 
 ECPublicKey pubKey = (ECPublicKey) keyFactory
 .generatePublic(x509KeySpec);
 
 ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),
 pubKey.getParams());
 
 // 对数据加密
 // TODO Chipher不支持EC算法 未能实现
 Cipher cipher = new NullCipher();
 // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
 cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());
 
 return cipher.doFinal(data);
 }
 
 /**
 * 取得私钥
 * 
 * @param keyMap
 * @return
 * @throws Exception
 */
 public static String getPrivateKey(Map<String, Object> keyMap)
 throws Exception {
 
 Key key = (Key) keyMap.get(PRIVATE_KEY);
 
 return encryptBASE64(key.getEncoded());
 }
 
 /**
 * 取得公钥
 * 
 * @param keyMap
 * @return
 * @throws Exception
 */
 public static String getPublicKey(Map<String, Object> keyMap)
 throws Exception {
 
 Key key = (Key) keyMap.get(PUBLIC_KEY);
 
 return encryptBASE64(key.getEncoded());
 }
 
 /**
 * 初始化密钥
 * 
 * @return
 * @throws Exception
 */
 public static Map<String, Object> initKey() throws Exception {
 
 BigInteger x1 = new BigInteger(
 "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);
 BigInteger x2 = new BigInteger(
 "289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);
 
 ECPoint g = new ECPoint(x1, x2);
 
 // the order of generator
 BigInteger n = new BigInteger(
 "5846006549323611672814741753598448348329118574063", 10);
 // the cofactor
 int h = 2;
 int m = 163;
 int[] ks = {
 7, 6, 3 };
 ECFieldF2m ecField = new ECFieldF2m(m, ks);
 // y^2+xy=x^3+x^2+1
 BigInteger a = new BigInteger("1", 2);
 BigInteger b = new BigInteger("1", 2);
 
 EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);
 
 ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,
 n, h);
 // 公钥
 ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);
 
 BigInteger s = new BigInteger(
 "1234006549323611672814741753598448348329118574063", 10);
 // 私钥
 ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);
 
 Map<String, Object> keyMap = new HashMap<String, Object>(2);
 
 keyMap.put(PUBLIC_KEY, publicKey);
 keyMap.put(PRIVATE_KEY, privateKey);
 
 return keyMap;
 }
 
 }

请注意上述代码中的**TODO**内容，再次提醒注意，Chipher不支持EC算法 ，以上代码仅供参考。Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey均不支持EC算法。为了确保程序能够正常执行，我们使用了NullCipher类，验证程序。

照旧提供一个测试类：

import static org.junit.Assert.*;
 
 import java.math.BigInteger;
 import java.security.spec.ECFieldF2m;
 import java.security.spec.ECParameterSpec;
 import java.security.spec.ECPoint;
 import java.security.spec.ECPrivateKeySpec;
 import java.security.spec.ECPublicKeySpec;
 import java.security.spec.EllipticCurve;
 import java.util.Map;
 
 import org.junit.Test;
 
 /**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
 public class ECCCoderTest {
 
 
 @Test
 public void test() throws Exception {
 
 String inputStr = "abc";
 byte[] data = inputStr.getBytes();
 
 Map<String, Object> keyMap = ECCCoder.initKey();
 
 String publicKey = ECCCoder.getPublicKey(keyMap);
 String privateKey = ECCCoder.getPrivateKey(keyMap);
 System.err.println("公钥: \n" + publicKey);
 System.err.println("私钥： \n" + privateKey);
 
 byte[] encodedData = ECCCoder.encrypt(data, publicKey);
 
 byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);
 
 String outputStr = new String(decodedData);
 System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
 assertEquals(inputStr, outputStr);
 }
 }

控制台输出：

公钥: 
    MEAwEAYHKoZIzj0CAQYFK4EEAAEDLAAEAv4TwFN7vBGsqgfXk95ObV5clO7oAokHD7BdOP9YMh8u
    gAU21TjM2qPZ
    
    私钥： 
    MDICAQAwEAYHKoZIzj0CAQYFK4EEAAEEGzAZAgEBBBTYJsR3BN7TFw7JHcAHFkwNmfil7w==
    
    加密前: abc
    
    解密后: abc

本篇的主要内容为Java证书体系的实现。

在构建Java代码实现前，我们需要完成证书的制作。  
1.生成keyStroe文件  
在命令行下执行以下命令：

keytool -genkey -validity 36000 -alias www.zlex.org -keyalg RSA -keystore d:\zlex.keystore

其中  
**-genkey**表示生成密钥  
**-validity**指定证书有效期，这里是**36000**天  
**-alias**指定别名，这里是**www.zlex.org**  
**-keyalg**指定算法，这里是**RSA**  
**-keystore**指定存储位置，这里是**d:\\zlex.keystore**

在这里我使用的密码为 **123456**

控制台输出：

输入keystore密码：
 再次输入新密码:
 您的名字与姓氏是什么？
 [Unknown]： www.zlex.org
 您的组织单位名称是什么？
 [Unknown]： zlex
 您的组织名称是什么？
 [Unknown]： zlex
 您所在的城市或区域名称是什么？
 [Unknown]： BJ
 您所在的州或省份名称是什么？
 [Unknown]： BJ
 该单位的两字母国家代码是什么
 [Unknown]： CN
 CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN 正确吗？
 [否]： Y
 
 输入<tomcat>的主密码
 （如果和 keystore 密码相同，按回车）：
 再次输入新密码:

这时，在D盘下会生成一个zlex.keystore的文件。

2.生成自签名证书  
光有keyStore文件是不够的，还需要证书文件，证书才是直接提供给外界使用的公钥凭证。  
导出证书：

keytool -export -keystore d:\zlex.keystore -alias www.zlex.org -file d:\zlex.cer -rfc

其中  
**-export**指定为导出操作  
**-keystore**指定**keystore文件**  
**-alias**指定导出**keystore文件中的别名**  
**-file**指向**导出路径**  
**-rfc**以文本格式输出，也就是以**BASE64编码**输出  
这里的密码是 **123456**

控制台输出：

输入keystore密码：
 保存在文件中的认证 <d:\zlex.cer>

当然，使用方是需要导入证书的！  
可以通过自签名证书完成CAS单点登录系统的构建！

Ok，准备工作完成，开始Java实现！

通过java代码实现如下：**Coder类见**

import java.io.FileInputStream;
    import java.security.KeyStore;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.Signature;
    import java.security.cert.Certificate;
    import java.security.cert.CertificateFactory;
    import java.security.cert.X509Certificate;
    import java.util.Date;
     
    import javax.crypto.Cipher;
     
    /**
     * 证书组件
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public abstract class CertificateCoder extends Coder {
        
     
     
        /**
         * Java密钥库(Java Key Store，JKS)KEY_STORE
         */
        public static final String KEY_STORE = "JKS";
     
        public static final String X509 = "X.509";
     
        /**
         * 由KeyStore获得私钥
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        private static PrivateKey getPrivateKey(String keyStorePath, String alias,
                String password) throws Exception {
        
            KeyStore ks = getKeyStore(keyStorePath, password);
            PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
            return key;
        }
     
        /**
         * 由Certificate获得公钥
         * 
         * @param certificatePath
         * @return
         * @throws Exception
         */
        private static PublicKey getPublicKey(String certificatePath)
                throws Exception {
        
            Certificate certificate = getCertificate(certificatePath);
            PublicKey key = certificate.getPublicKey();
            return key;
        }
     
        /**
         * 获得Certificate
         * 
         * @param certificatePath
         * @return
         * @throws Exception
         */
        private static Certificate getCertificate(String certificatePath)
                throws Exception {
        
            CertificateFactory certificateFactory = CertificateFactory
                    .getInstance(X509);
            FileInputStream in = new FileInputStream(certificatePath);
     
            Certificate certificate = certificateFactory.generateCertificate(in);
            in.close();
     
            return certificate;
        }
     
        /**
         * 获得Certificate
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        private static Certificate getCertificate(String keyStorePath,
                String alias, String password) throws Exception {
        
            KeyStore ks = getKeyStore(keyStorePath, password);
            Certificate certificate = ks.getCertificate(alias);
     
            return certificate;
        }
     
        /**
         * 获得KeyStore
         * 
         * @param keyStorePath
         * @param password
         * @return
         * @throws Exception
         */
        private static KeyStore getKeyStore(String keyStorePath, String password)
                throws Exception {
        
            FileInputStream is = new FileInputStream(keyStorePath);
            KeyStore ks = KeyStore.getInstance(KEY_STORE);
            ks.load(is, password.toCharArray());
            is.close();
            return ks;
        }
     
        /**
         * 私钥加密
         * 
         * @param data
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
                String alias, String password) throws Exception {
        
            // 取得私钥
            PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
     
            // 对数据加密
            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 私钥解密
         * 
         * @param data
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
                String alias, String password) throws Exception {
        
            // 取得私钥
            PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
     
            // 对数据加密
            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 公钥加密
         * 
         * @param data
         * @param certificatePath
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
                throws Exception {
        
     
            // 取得公钥
            PublicKey publicKey = getPublicKey(certificatePath);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 公钥解密
         * 
         * @param data
         * @param certificatePath
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
                throws Exception {
        
            // 取得公钥
            PublicKey publicKey = getPublicKey(certificatePath);
     
            // 对数据加密
            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 验证Certificate
         * 
         * @param certificatePath
         * @return
         */
        public static boolean verifyCertificate(String certificatePath) {
        
            return verifyCertificate(new Date(), certificatePath);
        }
     
        /**
         * 验证Certificate是否过期或无效
         * 
         * @param date
         * @param certificatePath
         * @return
         */
        public static boolean verifyCertificate(Date date, String certificatePath) {
        
            boolean status = true;
            try {
        
                // 取得证书
                Certificate certificate = getCertificate(certificatePath);
                // 验证证书是否过期或无效
                status = verifyCertificate(date, certificate);
            } catch (Exception e) {
        
                status = false;
            }
            return status;
        }
     
        /**
         * 验证证书是否过期或无效
         * 
         * @param date
         * @param certificate
         * @return
         */
        private static boolean verifyCertificate(Date date, Certificate certificate) {
        
            boolean status = true;
            try {
        
                X509Certificate x509Certificate = (X509Certificate) certificate;
                x509Certificate.checkValidity(date);
            } catch (Exception e) {
        
                status = false;
            }
            return status;
        }
     
        /**
         * 签名
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * 
         * @return
         * @throws Exception
         */
        public static String sign(byte[] sign, String keyStorePath, String alias,
                String password) throws Exception {
        
            // 获得证书
            X509Certificate x509Certificate = (X509Certificate) getCertificate(
                    keyStorePath, alias, password);
            // 获取私钥
            KeyStore ks = getKeyStore(keyStorePath, password);
            // 取得私钥
            PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password
                    .toCharArray());
     
            // 构建签名
            Signature signature = Signature.getInstance(x509Certificate
                    .getSigAlgName());
            signature.initSign(privateKey);
            signature.update(sign);
            return encryptBASE64(signature.sign());
        }
     
        /**
         * 验证签名
         * 
         * @param data
         * @param sign
         * @param certificatePath
         * @return
         * @throws Exception
         */
        public static boolean verify(byte[] data, String sign,
                String certificatePath) throws Exception {
        
            // 获得证书
            X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
            // 获得公钥
            PublicKey publicKey = x509Certificate.getPublicKey();
            // 构建签名
            Signature signature = Signature.getInstance(x509Certificate
                    .getSigAlgName());
            signature.initVerify(publicKey);
            signature.update(data);
     
            return signature.verify(decryptBASE64(sign));
     
        }
     
        /**
         * 验证Certificate
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         */
        public static boolean verifyCertificate(Date date, String keyStorePath,
                String alias, String password) {
        
            boolean status = true;
            try {
        
                Certificate certificate = getCertificate(keyStorePath, alias,
                        password);
                status = verifyCertificate(date, certificate);
            } catch (Exception e) {
        
                status = false;
            }
            return status;
        }
     
        /**
         * 验证Certificate
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         */
        public static boolean verifyCertificate(String keyStorePath, String alias,
                String password) {
        
            return verifyCertificate(new Date(), keyStorePath, alias, password);
        }
    }

再给出一个测试类：

import static org.junit.Assert.*;
     
    import org.junit.Test;
     
    /**
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class CertificateCoderTest {
        
        private String password = "123456";
        private String alias = "www.zlex.org";
        private String certificatePath = "d:/zlex.cer";
        private String keyStorePath = "d:/zlex.keystore";
     
        @Test
        public void test() throws Exception {
        
            System.err.println("公钥加密——私钥解密");
            String inputStr = "Ceritifcate";
            byte[] data = inputStr.getBytes();
     
            byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
                    certificatePath);
     
            byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
                    keyStorePath, alias, password);
            String outputStr = new String(decrypt);
     
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
     
            // 验证数据一致
            assertArrayEquals(data, decrypt);
     
            // 验证证书有效
            assertTrue(CertificateCoder.verifyCertificate(certificatePath));
     
        }
     
        @Test
        public void testSign() throws Exception {
        
            System.err.println("私钥加密——公钥解密");
     
            String inputStr = "sign";
            byte[] data = inputStr.getBytes();
     
            byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
                    keyStorePath, alias, password);
     
            byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
                    certificatePath);
     
            String outputStr = new String(decodedData);
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
            assertEquals(inputStr, outputStr);
     
            System.err.println("私钥签名——公钥验证签名");
            // 产生签名
            String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
                    password);
            System.err.println("签名:\r" + sign);
     
            // 验证签名
            boolean status = CertificateCoder.verify(encodedData, sign,
                    certificatePath);
            System.err.println("状态:\r" + status);
            assertTrue(status);
     
        }
    }

控制台输出：

公钥加密——私钥解密
    加密前: Ceritificate
    
    解密后: Ceritificate
    
    私钥加密——公钥解密
    加密前: sign
    
    解密后: sign
    私钥签名——公钥验证签名
    签名:
    pqBn5m6PJlfOjH0A6U2o2mUmBsfgyEY1NWCbiyA/I5Gc3gaVNVIdj/zkGNZRqTjhf3+J9a9z9EI7
    6F2eWYd7punHx5oh6hfNgcKbVb52EfItl4QEN+djbXiPynn07+Lbg1NOjULnpEd6ZhLP1YwrEAuM
    OfvX0e7/wplxLbySaKQ=
    
    状态:
    true

由此完成了证书验证体系！

同样，我们可以对代码做签名——代码签名！  
通过工具JarSigner可以完成代码签名。  
这里我们对tools.jar做代码签名，命令如下：

jarsigner -storetype jks -keystore zlex.keystore -verbose tools.jar www.zlex.org

控制台输出：

输入密钥库的口令短语：
     正在更新： META-INF/WWW_ZLEX.SF
     正在更新： META-INF/WWW_ZLEX.RSA
      正在签名： org/zlex/security/Security.class
      正在签名： org/zlex/tool/Main$1.class
      正在签名： org/zlex/tool/Main$2.class
      正在签名： org/zlex/tool/Main.class
    
    警告：
    签名者证书将在六个月内过期。

此时，我们可以对签名后的jar做验证！  
验证tools.jar，命令如下：

jarsigner -verify -verbose -certs tools.jar

控制台输出：

402 Sat Jun 20 16:25:14 CST 2009 META-INF/MANIFEST.MF
             532 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.SF
             889 Sat Jun 20 16:25:14 CST 2009 META-INF/WWW_ZLEX.RSA
    sm       590 Wed Dec 10 13:03:42 CST 2008 org/zlex/security/Security.class
    
          X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
          [证书将在 09-9-18 下午3:27 到期]
    
    sm       705 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$1.class
    
          X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
          [证书将在 09-9-18 下午3:27 到期]
    
    sm       779 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main$2.class
    
          X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
          [证书将在 09-9-18 下午3:27 到期]
    
    sm     12672 Tue Dec 16 18:00:56 CST 2008 org/zlex/tool/Main.class
    
          X.509, CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
          [证书将在 09-9-18 下午3:27 到期]
    
    
      s = 已验证签名
      m = 在清单中列出条目
      k = 在密钥库中至少找到了一个证书
      i = 在身份作用域内至少找到了一个证书
    
    jar 已验证。
    
    警告：
    此 jar 包含签名者证书将在六个月内过期的条目。

代码签名认证的用途主要是对发布的软件做验证，支持 Sun Java .jar (Java Applet) 文件(J2SE)和 J2ME MIDlet Suite 文件。

在中，我们模拟了一个基于RSA非对称加密网络的安全通信。现在我们深度了解一下现有的安全网络通信——SSL。  
我们需要构建一个由CA机构签发的有效证书，这里我们使用上文中生成的自签名证书**zlex.cer**  
这里，我们将证书导入到我们的密钥库。

keytool -import -alias www.zlex.org -file d:/zlex.cer -keystore d:/zlex.keystore

其中  
\-import表示**导入**  
\-alias指定别名，这里是**www.zlex.org**  
\-file指定算法，这里是**d:/zlex.cer**  
\-keystore指定存储位置，这里是**d:/zlex.keystore**  
在这里我使用的密码为**654321**

控制台输出：

输入keystore密码：
    再次输入新密码:
    所有者:CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
    签发人:CN=www.zlex.org, OU=zlex, O=zlex, L=BJ, ST=BJ, C=CN
    序列号:4a1e48df
    有效期: Thu May 28 16:18:39 CST 2009 至Wed Aug 26 16:18:39 CST 2009
    证书指纹:
             MD5:19:CA:E6:36:E2:DF:AD:96:31:97:2F:A9:AD:FC:37:6A
             SHA1:49:88:30:59:29:45:F1:69:CA:97:A9:6D:8A:CF:08:D2:C3:D5:C0:C4
             签名算法名称:SHA1withRSA
             版本: 3
    信任这个认证？ [否]：  y
    认证已添加至keystore中

OK，最复杂的准备工作已经完成。  
接下来我们将域名**www.zlex.org**定位到本机上。打开**C:\\Windows\\System32\\drivers\\etc\\hosts**文件，将**www.zlex.org**绑定在本机上。在文件末尾追加**127.0.0.1 www.zlex.org**。现在通过地址栏访问[http://www.zlex.org][http_www.zlex.org]，或者通过**ping**命令，如果能够定位到本机，域名映射就搞定了。  
现在，配置tomcat。先将**zlex.keystore**拷贝到tomcat的conf目录下，然后配置**server.xml**。将如下内容加入配置文件

注意**clientAuth="false"测试阶段，置为false**，正式使用时建议使用**true**。现在启动tomcat，访问https://www.zlex.org/。![各种Java加密算法][Java 12]  
显然，证书未能通过认证，这个时候你可以选择安装证书（上文中的**zlex.cer**文件就是证书），作为**受信任的根证书颁发机构**导入，再次重启浏览器（IE，其他浏览器对于域名www.zlex.org不支持本地方式访问），访问https://www.zlex.org/，你会看到地址栏中会有个小锁![各种Java加密算法][Java 13]，就说明安装成功。所有的浏览器联网操作已经在RSA加密解密系统的保护之下了。但似乎我们感受不到。  
这个时候很多人开始怀疑，如果我们要手工做一个这样的https的访问是不是需要把浏览器的这些个功能都实现呢？不需要！

接着上篇内容，给出如下代码实现：

import java.io.FileInputStream;
    import java.security.KeyStore;
    import java.security.PrivateKey;
    import java.security.PublicKey;
    import java.security.Signature;
    import java.security.cert.Certificate;
    import java.security.cert.CertificateFactory;
    import java.security.cert.X509Certificate;
    import java.util.Date;
     
    import javax.crypto.Cipher;
    import javax.net.ssl.HttpsURLConnection;
    import javax.net.ssl.KeyManagerFactory;
    import javax.net.ssl.SSLContext;
    import javax.net.ssl.SSLSocketFactory;
    import javax.net.ssl.TrustManagerFactory;
     
    /**
     * 证书组件
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public abstract class CertificateCoder extends Coder {
        
     
        /**
         * Java密钥库(Java Key Store，JKS)KEY_STORE
         */
        public static final String KEY_STORE = "JKS";
     
        public static final String X509 = "X.509";
        public static final String SunX509 = "SunX509";
        public static final String SSL = "SSL";
     
        /**
         * 由KeyStore获得私钥
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        private static PrivateKey getPrivateKey(String keyStorePath, String alias,
                String password) throws Exception {
        
            KeyStore ks = getKeyStore(keyStorePath, password);
            PrivateKey key = (PrivateKey) ks.getKey(alias, password.toCharArray());
            return key;
        }
     
        /**
         * 由Certificate获得公钥
         * 
         * @param certificatePath
         * @return
         * @throws Exception
         */
        private static PublicKey getPublicKey(String certificatePath)
                throws Exception {
        
            Certificate certificate = getCertificate(certificatePath);
            PublicKey key = certificate.getPublicKey();
            return key;
        }
     
        /**
         * 获得Certificate
         * 
         * @param certificatePath
         * @return
         * @throws Exception
         */
        private static Certificate getCertificate(String certificatePath)
                throws Exception {
        
            CertificateFactory certificateFactory = CertificateFactory
                    .getInstance(X509);
            FileInputStream in = new FileInputStream(certificatePath);
     
            Certificate certificate = certificateFactory.generateCertificate(in);
            in.close();
     
            return certificate;
        }
     
        /**
         * 获得Certificate
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        private static Certificate getCertificate(String keyStorePath,
                String alias, String password) throws Exception {
        
            KeyStore ks = getKeyStore(keyStorePath, password);
            Certificate certificate = ks.getCertificate(alias);
     
            return certificate;
        }
     
        /**
         * 获得KeyStore
         * 
         * @param keyStorePath
         * @param password
         * @return
         * @throws Exception
         */
        private static KeyStore getKeyStore(String keyStorePath, String password)
                throws Exception {
        
            FileInputStream is = new FileInputStream(keyStorePath);
            KeyStore ks = KeyStore.getInstance(KEY_STORE);
            ks.load(is, password.toCharArray());
            is.close();
            return ks;
        }
     
        /**
         * 私钥加密
         * 
         * @param data
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPrivateKey(byte[] data, String keyStorePath,
                String alias, String password) throws Exception {
        
            // 取得私钥
            PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
     
            // 对数据加密
            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 私钥解密
         * 
         * @param data
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPrivateKey(byte[] data, String keyStorePath,
                String alias, String password) throws Exception {
        
            // 取得私钥
            PrivateKey privateKey = getPrivateKey(keyStorePath, alias, password);
     
            // 对数据加密
            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, privateKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 公钥加密
         * 
         * @param data
         * @param certificatePath
         * @return
         * @throws Exception
         */
        public static byte[] encryptByPublicKey(byte[] data, String certificatePath)
                throws Exception {
        
     
            // 取得公钥
            PublicKey publicKey = getPublicKey(certificatePath);
            // 对数据加密
            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 公钥解密
         * 
         * @param data
         * @param certificatePath
         * @return
         * @throws Exception
         */
        public static byte[] decryptByPublicKey(byte[] data, String certificatePath)
                throws Exception {
        
            // 取得公钥
            PublicKey publicKey = getPublicKey(certificatePath);
     
            // 对数据加密
            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
     
            return cipher.doFinal(data);
     
        }
     
        /**
         * 验证Certificate
         * 
         * @param certificatePath
         * @return
         */
        public static boolean verifyCertificate(String certificatePath) {
        
            return verifyCertificate(new Date(), certificatePath);
        }
     
        /**
         * 验证Certificate是否过期或无效
         * 
         * @param date
         * @param certificatePath
         * @return
         */
        public static boolean verifyCertificate(Date date, String certificatePath) {
        
            boolean status = true;
            try {
        
                // 取得证书
                Certificate certificate = getCertificate(certificatePath);
                // 验证证书是否过期或无效
                status = verifyCertificate(date, certificate);
            } catch (Exception e) {
        
                status = false;
            }
            return status;
        }
     
        /**
         * 验证证书是否过期或无效
         * 
         * @param date
         * @param certificate
         * @return
         */
        private static boolean verifyCertificate(Date date, Certificate certificate) {
        
            boolean status = true;
            try {
        
                X509Certificate x509Certificate = (X509Certificate) certificate;
                x509Certificate.checkValidity(date);
            } catch (Exception e) {
        
                status = false;
            }
            return status;
        }
     
        /**
         * 签名
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * 
         * @return
         * @throws Exception
         */
        public static String sign(byte[] sign, String keyStorePath, String alias,
                String password) throws Exception {
        
            // 获得证书
            X509Certificate x509Certificate = (X509Certificate) getCertificate(
                    keyStorePath, alias, password);
            // 获取私钥
            KeyStore ks = getKeyStore(keyStorePath, password);
            // 取得私钥
            PrivateKey privateKey = (PrivateKey) ks.getKey(alias, password
                    .toCharArray());
     
            // 构建签名
            Signature signature = Signature.getInstance(x509Certificate
                    .getSigAlgName());
            signature.initSign(privateKey);
            signature.update(sign);
            return encryptBASE64(signature.sign());
        }
     
        /**
         * 验证签名
         * 
         * @param data
         * @param sign
         * @param certificatePath
         * @return
         * @throws Exception
         */
        public static boolean verify(byte[] data, String sign,
                String certificatePath) throws Exception {
        
            // 获得证书
            X509Certificate x509Certificate = (X509Certificate) getCertificate(certificatePath);
            // 获得公钥
            PublicKey publicKey = x509Certificate.getPublicKey();
            // 构建签名
            Signature signature = Signature.getInstance(x509Certificate
                    .getSigAlgName());
            signature.initVerify(publicKey);
            signature.update(data);
     
            return signature.verify(decryptBASE64(sign));
     
        }
     
        /**
         * 验证Certificate
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         */
        public static boolean verifyCertificate(Date date, String keyStorePath,
                String alias, String password) {
        
            boolean status = true;
            try {
        
                Certificate certificate = getCertificate(keyStorePath, alias,
                        password);
                status = verifyCertificate(date, certificate);
            } catch (Exception e) {
        
                status = false;
            }
            return status;
        }
     
        /**
         * 验证Certificate
         * 
         * @param keyStorePath
         * @param alias
         * @param password
         * @return
         */
        public static boolean verifyCertificate(String keyStorePath, String alias,
                String password) {
        
            return verifyCertificate(new Date(), keyStorePath, alias, password);
        }
     
        /**
         * 获得SSLSocektFactory
         * 
         * @param password
         *            密码
         * @param keyStorePath
         *            密钥库路径
         * 
         * @param trustKeyStorePath
         *            信任库路径
         * @return
         * @throws Exception
         */
        private static SSLSocketFactory getSSLSocketFactory(String password,
                String keyStorePath, String trustKeyStorePath) throws Exception {
        
            // 初始化密钥库
            KeyManagerFactory keyManagerFactory = KeyManagerFactory
                    .getInstance(SunX509);
            KeyStore keyStore = getKeyStore(keyStorePath, password);
            keyManagerFactory.init(keyStore, password.toCharArray());
     
            // 初始化信任库
            TrustManagerFactory trustManagerFactory = TrustManagerFactory
                    .getInstance(SunX509);
            KeyStore trustkeyStore = getKeyStore(trustKeyStorePath, password);
            trustManagerFactory.init(trustkeyStore);
     
            // 初始化SSL上下文
            SSLContext ctx = SSLContext.getInstance(SSL);
            ctx.init(keyManagerFactory.getKeyManagers(), trustManagerFactory
                    .getTrustManagers(), null);
            SSLSocketFactory sf = ctx.getSocketFactory();
     
            return sf;
        }
     
        /**
         * 为HttpsURLConnection配置SSLSocketFactory
         * 
         * @param conn
         *            HttpsURLConnection
         * @param password
         *            密码
         * @param keyStorePath
         *            密钥库路径
         * 
         * @param trustKeyStorePath
         *            信任库路径
         * @throws Exception
         */
        public static void configSSLSocketFactory(HttpsURLConnection conn,
                String password, String keyStorePath, String trustKeyStorePath)
                throws Exception {
        
            conn.setSSLSocketFactory(getSSLSocketFactory(password, keyStorePath,
                    trustKeyStorePath));
        }
    }

增加了**configSSLSocketFactory**方法供外界调用，该方法为 HttpsURLConnection配置了SSLSocketFactory。当HttpsURLConnection配置了 SSLSocketFactory后，我们就可以通过HttpsURLConnection的getInputStream、 getOutputStream，像往常使用HttpURLConnection做操作了。尤其要说明一点，未配置SSLSocketFactory 前，HttpsURLConnection的getContentLength()获得值永远都是\*\*-1\*\*。

给出相应测试类：

import static org.junit.Assert.*;
     
    import java.io.DataInputStream;
    import java.io.InputStream;
    import java.net.URL;
     
    import javax.net.ssl.HttpsURLConnection;
     
    import org.junit.Test;
     
    /**
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class CertificateCoderTest {
        
        private String password = "123456";
        private String alias = "www.zlex.org";
        private String certificatePath = "d:/zlex.cer";
        private String keyStorePath = "d:/zlex.keystore";
        private String clientKeyStorePath = "d:/zlex-client.keystore";
        private String clientPassword = "654321";
     
        @Test
        public void test() throws Exception {
        
            System.err.println("公钥加密——私钥解密");
            String inputStr = "Ceritifcate";
            byte[] data = inputStr.getBytes();
     
            byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
                    certificatePath);
     
            byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
                    keyStorePath, alias, password);
            String outputStr = new String(decrypt);
     
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
     
            // 验证数据一致
            assertArrayEquals(data, decrypt);
     
            // 验证证书有效
            assertTrue(CertificateCoder.verifyCertificate(certificatePath));
     
        }
     
        @Test
        public void testSign() throws Exception {
        
            System.err.println("私钥加密——公钥解密");
     
            String inputStr = "sign";
            byte[] data = inputStr.getBytes();
     
            byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
                    keyStorePath, alias, password);
     
            byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
                    certificatePath);
     
            String outputStr = new String(decodedData);
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
            assertEquals(inputStr, outputStr);
     
            System.err.println("私钥签名——公钥验证签名");
            // 产生签名
            String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
                    password);
            System.err.println("签名:\r" + sign);
     
            // 验证签名
            boolean status = CertificateCoder.verify(encodedData, sign,
                    certificatePath);
            System.err.println("状态:\r" + status);
            assertTrue(status);
     
        }
     
        @Test
        public void testHttps() throws Exception {
        
            URL url = new URL("https://www.zlex.org/examples/");
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
     
            conn.setDoInput(true);
            conn.setDoOutput(true);
     
            CertificateCoder.configSSLSocketFactory(conn, clientPassword,
                    clientKeyStorePath, clientKeyStorePath);
     
            InputStream is = conn.getInputStream();
     
            int length = conn.getContentLength();
     
            DataInputStream dis = new DataInputStream(is);
            byte[] data = new byte[length];
            dis.readFully(data);
     
            dis.close();
            System.err.println(new String(data));
            conn.disconnect();
        }
    }

注意**testHttps**方法，几乎和我们往常做HTTP访问没有差别，我们来看控制台输出：

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <HTML><HEAD><TITLE>Apache Tomcat Examples</TITLE>
 <META http-equiv=Content-Type content="text/html">
 </HEAD>
 <BODY>
 
 <H3>Apache Tomcat Examples</H3>
 
 <ul>
 <li><a href="http://javaeye.shaduwang.com/?snowolf/blog/servlets">Servlets examples</a></li>
 <li><a href="http://javaeye.shaduwang.com/?snowolf/blog/jsp">JSP Examples</a></li>
 </ul>
 </BODY></HTML>

通过浏览器直接访问https://www.zlex.org/examples/你 也会获得上述内容。也就是说应用甲方作为服务器构建tomcat服务，乙方可以通过上述方式访问甲方受保护的SSL应用，并且不需要考虑具体的加密解密问 题。甲乙双方可以经过相应配置，通过双方的tomcat配置有效的SSL服务，简化上述代码实现，完全通过证书配置完成SSL双向认证！

我们使用自签名证书完成了认证。接下来，我们使用第三方CA签名机构完成证书签名。  
这里我们使用[thawte][]提供的测试用21天免费ca证书。  
1.要在该网站上注明你的域名，这里使用**www.zlex.org**作为测试用域名（请勿使用该域名作为你的域名地址，该域名受法律保护！请使用其他非注册域名！）。  
2.如果域名有效，你会收到邮件要求你访问https://www.thawte.com/cgi/server/try.exe获得ca证书。  
3.复述密钥库的创建。

keytool -genkey -validity 36000 -alias www.zlex.org -keyalg RSA -keystore d:\zlex.keystore

在这里我使用的密码为 **123456**

控制台输出：

4.通过如下命令，从zlex.keystore中导出CA证书申请。

keytool -certreq -alias www.zlex.org -file d:\zlex.csr -keystore d:\zlex.keystore -v

你会获得zlex.csr文件，可以用记事本打开，内容如下格式：

-----BEGIN NEW CERTIFICATE REQUEST-----
    MIIBnDCCAQUCAQAwXDELMAkGA1UEBhMCQ04xCzAJBgNVBAgTAkJKMQswCQYDVQQHEwJCSjENMAsG
    A1UEChMEemxleDENMAsGA1UECxMEemxleDEVMBMGA1UEAxMMd3d3LnpsZXgub3JnMIGfMA0GCSqG
    SIb3DQEBAQUAA4GNADCBiQKBgQCR6DXU9Mp+mCKO7cv9JPsj0n1Ec/GpM09qvhpgX3FNad/ZWSDc
    vU77YXZSoF9hQp3w1LC+eeKgd2MlVpXTvbVwBNVd2HiQPp37ic6BUUjSaX8LHtCl7l0BIEye9qQ2
    j8G0kak7e8ZA0s7nb3Ymq/K8BV7v0MQIdhIc1bifK9ZDewIDAQABoAAwDQYJKoZIhvcNAQEFBQAD
    gYEAMA1r2fbZPtNx37U9TRwadCH2TZZecwKJS/hskNm6ryPKIAp9APWwAyj8WJHRBz5SpZM4zmYO
    oMCI8BcnY2A4JP+R7/SwXTdH/xcg7NVghd9A2SCgqMpF7KMfc5dE3iygdiPu+UhY200Dvpjx8gmJ
    1UbH3+nqMUyCrZgURFslOUY=
    -----END NEW CERTIFICATE REQUEST-----

5.将上述文件内容拷贝到https://www.thawte.com/cgi/server/try.exe中，点击next，获得回应内容，这里是p7b格式。  
内容如下：

将其存储为zlex.p7b  
6.将由CA签发的证书导入密钥库。

keytool -import -trustcacerts -alias www.zlex.org -file d:\zlex.p7b -keystore d:\zlex.keystore -v

在这里我使用的密码为 **123456**

控制台输出：

输入keystore密码：
    
    回复中的最高级认证：
    
    所有者:CN=Thawte Test CA Root, OU=TEST TEST TEST, O=Thawte Certification, ST=FOR
     TESTING PURPOSES ONLY, C=ZA
    签发人:CN=Thawte Test CA Root, OU=TEST TEST TEST, O=Thawte Certification, ST=FOR
     TESTING PURPOSES ONLY, C=ZA
    序列号:0
    有效期: Thu Aug 01 08:00:00 CST 1996 至Fri Jan 01 05:59:59 CST 2021
    证书指纹:
             MD5:5E:E0:0E:1D:17:B7:CA:A5:7D:36:D6:02:DF:4D:26:A4
             SHA1:39:C6:9D:27:AF:DC:EB:47:D6:33:36:6A:B2:05:F1:47:A9:B4:DA:EA
             签名算法名称:MD5withRSA
             版本: 3
    
    扩展:
    
    #1: ObjectId: 2.5.29.19 Criticality=true
    BasicConstraints:[
      CA:true
      PathLen:2147483647
    ]
    
    
    ... 是不可信的。 还是要安装回复？ [否]：  Y
    认证回复已安装在 keystore中
    [正在存储 d:\zlex.keystore]

7.域名定位  
将域名www.zlex.org定位到本机上。打开C:\\Windows\\System32\\drivers\\etc\\hosts文件，将 www.zlex.org绑定在本机上。在文件末尾追加127.0.0.1 www.zlex.org。现在通过地址栏访问http://www.zlex.org，或者通过ping命令，如果能够定位到本机，域名映射就搞定 了。

8.配置server.xml

将文件**zlex.keystore**拷贝到tomcat的**conf**目录下，重新启动tomcat。访问https://www.zlex.org/，我们发现联网有些迟钝。大约5秒钟后，网页正常显示，同时有如下图所示：  
![各种Java加密算法][Java 14]  
浏览器验证了该CA机构的有效性。

打开证书，如下图所示：  
![各种Java加密算法][Java 15]

调整测试类：

import static org.junit.Assert.*;
     
    import java.io.DataInputStream;
    import java.io.InputStream;
    import java.net.URL;
     
    import javax.net.ssl.HttpsURLConnection;
     
    import org.junit.Test;
     
    /**
     * 
     * @author 梁栋
     * @version 1.0
     * @since 1.0
     */
    public class CertificateCoderTest {
        
        private String password = "123456";
        private String alias = "www.zlex.org";
        private String certificatePath = "d:/zlex.cer";
        private String keyStorePath = "d:/zlex.keystore";
     
        @Test
        public void test() throws Exception {
        
            System.err.println("公钥加密——私钥解密");
            String inputStr = "Ceritifcate";
            byte[] data = inputStr.getBytes();
     
            byte[] encrypt = CertificateCoder.encryptByPublicKey(data,
                    certificatePath);
     
            byte[] decrypt = CertificateCoder.decryptByPrivateKey(encrypt,
                    keyStorePath, alias, password);
            String outputStr = new String(decrypt);
     
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
     
            // 验证数据一致
            assertArrayEquals(data, decrypt);
     
            // 验证证书有效
            assertTrue(CertificateCoder.verifyCertificate(certificatePath));
     
        }
     
        @Test
        public void testSign() throws Exception {
        
            System.err.println("私钥加密——公钥解密");
     
            String inputStr = "sign";
            byte[] data = inputStr.getBytes();
     
            byte[] encodedData = CertificateCoder.encryptByPrivateKey(data,
                    keyStorePath, alias, password);
     
            byte[] decodedData = CertificateCoder.decryptByPublicKey(encodedData,
                    certificatePath);
     
            String outputStr = new String(decodedData);
            System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
            assertEquals(inputStr, outputStr);
     
            System.err.println("私钥签名——公钥验证签名");
            // 产生签名
            String sign = CertificateCoder.sign(encodedData, keyStorePath, alias,
                    password);
            System.err.println("签名:\r" + sign);
     
            // 验证签名
            boolean status = CertificateCoder.verify(encodedData, sign,
                    certificatePath);
            System.err.println("状态:\r" + status);
            assertTrue(status);
     
        }
     
        @Test
        public void testHttps() throws Exception {
        
            URL url = new URL("https://www.zlex.org/examples/");
            HttpsURLConnection conn = (HttpsURLConnection) url.openConnection();
     
            conn.setDoInput(true);
            conn.setDoOutput(true);
     
            CertificateCoder.configSSLSocketFactory(conn, password, keyStorePath,
                    keyStorePath);
     
            InputStream is = conn.getInputStream();
     
            int length = conn.getContentLength();
     
            DataInputStream dis = new DataInputStream(is);
            byte[] data = new byte[length];
            dis.readFully(data);
     
            dis.close();
            conn.disconnect();
            System.err.println(new String(data));
        }
    }

再次执行，验证通过！  
由此，我们了基于SSL协议的认证过程。测试类的testHttps方法模拟了一次浏览器的HTTPS访问。

[Java]: https://img-blog.csdnimg.cn/img_convert/bf6f2313069e437edc85174eeb34d2b2.jpeg
[Java 1]: https://img-blog.csdnimg.cn/img_convert/4db42a4e22e99afa4e2b63e15f79284f.jpeg
[Java 2]: https://img-blog.csdnimg.cn/img_convert/abbf0fb35b49e0b077c9eea3a7201f68.jpeg
[Java 3]: https://img-blog.csdnimg.cn/img_convert/7f87509c24318fc937902a9a2533f141.jpeg
[Java 4]: https://img-blog.csdnimg.cn/img_convert/9841d24b049127282d3fa4f840b28ff2.jpeg
[Java 5]: https://img-blog.csdnimg.cn/img_convert/ef752b73bd1bdb306373db1a368db3af.jpeg
[Java 6]: https://img-blog.csdnimg.cn/img_convert/3f899e48a10facc354751b3fa92a87c1.jpeg
[Java 7]: https://img-blog.csdnimg.cn/img_convert/3392a3726c811dd1bf943af006a93b0a.jpeg
[Java 8]: https://img-blog.csdnimg.cn/img_convert/240b461cbc9ec280075bd989eb92c254.jpeg
[Java 9]: https://img-blog.csdnimg.cn/img_convert/b52bd4bf7c8aee50083fc173efd9a982.jpeg
[Java 10]: https://img-blog.csdnimg.cn/img_convert/6028777fc13f1dae0f15f71d9a9eacde.jpeg
[Java 11]: https://img-blog.csdnimg.cn/img_convert/6cf30c2ab9ce96eacde6cb48ad7a434d.jpeg
[http_www.zlex.org]: http://www.zlex.org/
[Java 12]: https://img-blog.csdnimg.cn/img_convert/dfe8fee636d2c6686b736adc6a5ac739.jpeg
[Java 13]: https://img-blog.csdnimg.cn/img_convert/eba28ad5272931403cb20844d8ce51ff.jpeg
[thawte]: https://www.thawte.com/
[Java 14]: https://img-blog.csdnimg.cn/img_convert/5e8780e2bb4880e74b74edc6e866d7f9.jpeg
[Java 15]: https://img-blog.csdnimg.cn/img_convert/2ee0b0429f049f8c2b7e04628eddd53a.jpeg