數字證書簡介及Java編碼實現

1.數字證書簡介

數字證書具備常規加密解密必要的信息，包含簽名算法，可用於網絡數據加密解密交互，標識網絡用戶（計算機）身份。數字證書為發布公鑰提供了一種簡便的途徑，其數字證書則成為加密算法以及公鑰的載體。依靠數字證書，我們可以構建一個簡單的加密網絡應用平台。

數字證書類似於個人身份證，由數字證書頒發認證機構（Certificate Authority, CA）簽發。只有經過CA簽發的證書在網絡中才具備可認證性。CA頒發給自己的證書叫根證書。

VeriSign, GeoTrust和Thawte是國際權威數字證書頒發認證機構的三巨頭。其中應用最廣泛的是VeriSign簽發的電子商務用數字證書。

最為常用的非對稱加密算法是RSA，與之配套的簽名算法是SHA1withRSA，最常用的消息摘要算法是SHA1.

 

除了RSA，還可以使用DSA算法。只是使用DSA算法無法完成加密解密實現，即這樣的證書不包括加密解密功能。

數字證書有多種文件編碼格式，主要包含CER編碼，DER編碼等。

CER(Canonical Encoding Rules, 規范編碼格式)，DER(Distinguished Encoding Rules 卓越編碼格式)，兩者的區別是前者是變長模式，后者是定長模式。

所有證書都符合公鑰基礎設施(PKI, Public Key Infrastructure)制定的ITU-T X509國際標准(X.509標准)。

2.模型分析

在實際應用中，很多數字證書都屬於自簽名證書，即證書申請者為自己的證書簽名。這類證書通常應用於軟件廠商內部發放的產品中，或約定使用該證書的數據交互雙方。數字證書完全充當加密算法的載體，為必要數據做加密解密和簽名驗簽等操作。在我司的開發過程中，數字證書更多是用來做加密和解密。

1）證書簽發

2）加密交互，圖略。

當客戶端獲取到服務器下發的數字證書后，就可以進行加密交互了。具體做法是：

客戶端使用公鑰，加密后發送給服務端，服務端用私鑰進行解密驗證。

服務端使用私鑰進行加密和數字簽名。

3. KeyTool 管理證書

KeyTool與本地密鑰庫相關聯，將私鑰存於密鑰庫，公鑰則以數字證書輸出。KeyTool位於JDK目錄下的bin目錄中，需要通過命令行進行相應的操作。

1）構建自簽名證書

申請數字證書之前，需要在密鑰庫中以別名的方式生成本地數字證書，建立相應的加密算法，密鑰，有效期等信息。

keytool -genkeypair -keyalg RSA -keysize 2048 -sigalg SHA1withRSA -validity 3600 -alias myCertificate -keystore myKeystore.keystore

各參數含義如下：

-genkeypair　　表示生成密鑰對

-keyalg　　　　指定密鑰算法，這里是RSA

-keysize　　　　指定密鑰長度，默認1024，這里指定2048

-sigal　　　　　指定簽名算法，這里是SHA1withRSA

-validity　　　　指定有效期，單位為天

-alias　　　　　指定別名

-keystore　　　　指定密鑰庫存儲位置

這里我輸入參數Changeme123作為密鑰庫的密碼，也可通過參數-storepass指定密碼。可以用-dname "CN=xxx...."這樣的形式，避免更多交互。

注意：一個keystore應該是可以存儲多套<私鑰-數字證書>的信息，通過別名來區分。通過實踐，調用上述命令兩次（別名不同），生成同一個keystore，用不同別名進行加密解密和簽名驗簽，沒有任何問題。

更多命令可參考：http://blog.chinaunix.net/uid-17102734-id-2830223.html 

經過上述操作后，密鑰庫中已經創建了數字證書。雖然這時的數字證書並沒有經過CA認證，但並不影響我們使用。我們仍可將證書導出，發送給合作伙伴進行加密交互。

keytool -exportcert -alias myCertificate -keystore myKeystore.keystore -file myCer.cer -rfc

各參數含義如下：

-exportcert　　表示證書導出操作

-alias　　　　　指定別名

-keystore　　　指定密鑰庫文件

-file　　　　　　指定導出證書的文件路徑

-rfc　　　　　　指定以Base64編碼格式輸出

打印證書

keytool -printcert -file myCer.cer

2）構建CA簽發證書

如果要獲取CA機構誰的數字證書，需要將數字證書簽發申請(CSR)導出，經由CA機構認證並頒發，將認證后的證書導入本地密鑰庫和信息庫。

keytool -certreq -alias myCertificate -keystore myKeystore.keystore -file myCsr.csr -v

各參數含義如下：

-certreq　　　　表示數字證書申請操作

-alias　　　　　　指定別名

-keystore　　　　指定密鑰庫文件路徑

-file　　　　　　指定導出申請的路徑

-v　　　　　　　詳細信息

獲得簽發的數字證書后，需要將其導入信任庫。

keytool -importcert -trustcacerts -alias myCertificate -file myCer.cer -keystore myKeystore.keystore

參數不作詳細講解，如果是原來的證書文件，那么會報錯：

查看證書

keytool -list -alias myCertificate -keystore myKeystore.keystore

 

經過上述的所有操作后，可以得到下面幾個文件

4. 證書使用

終於到了激動人心的時刻，可以用代碼通過keystore進行加解密操作了！

Java 6提供了完善的數字證書管理實現，我們幾乎無需關注，僅通過操作密鑰庫和數字證書就可完成相應的加密解密和簽名驗簽過程。

密鑰庫管理私鑰，數字證書管理公鑰，公鑰和私鑰分屬消息傳遞雙方，進行加密消息傳遞。

考慮一個場景。

A機器某模塊需要將數據導出到一個文件中，將文件發送到B機器，由B將數據導入。

在這個場景中，A就相當於服務端，需要將證書給B，同時用私鑰加密數據，生成簽名，導出到文件中。

B相當於客戶端，用收到的數字證書進行解密和驗簽。

package jdbc.pro.lin;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.security.InvalidKeyException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.SignatureException;
import java.security.UnrecoverableKeyException;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

public class MyCertifacate {
    private static final String STORE_PASS = "Changeme123";
    private static final String ALIAS = "myCertificate";
    private static final String KEYSTORE_PATH = "D:\\JavaDemo\\Certifacate\\myKeystore.keystore";
    private static final String CERT_PATH = "D:\\JavaDemo\\Certifacate\\myCer.cer";
    private static final String PLAIN_TEXT = "MANUTD is the most greatest club in the world.";
    /** JDK6只支持X.509標准的證書 */
    private static final String CERT_TYPE = "X.509";

    public static void main(String[] args) throws IOException {
        /**
         * 假設現在有這樣一個場景 。A機器上的數據，需要加密導出，然后將導出文件放到B機器上導入。 在這個場景中，A相當於服務器，B相當於客戶端
         */

        /** A */
        KeyStore keyStore = getKeyStore(STORE_PASS, KEYSTORE_PATH);
        PrivateKey privateKey = getPrivateKey(keyStore, ALIAS, STORE_PASS);
        X509Certificate certificate = getCertificateByKeystore(keyStore, ALIAS);

        /** 加密和簽名 */
        byte[] encodedText = encode(PLAIN_TEXT.getBytes(), privateKey);
        byte[] signature = sign(certificate, privateKey, PLAIN_TEXT.getBytes());

        /** 現在B收到了A的密文和簽名，以及A的可信任證書 */
        X509Certificate receivedCertificate = getCertificateByCertPath(
                CERT_PATH, CERT_TYPE);
        PublicKey publicKey = getPublicKey(receivedCertificate);
        byte[] decodedText = decode(encodedText, publicKey);
        System.out.println("Decoded Text : " + new String(decodedText));
        System.out.println("Signature is : "
                + verify(receivedCertificate, decodedText, signature));
    }

    /**
     * 加載密鑰庫，與Properties文件的加載類似，都是使用load方法
     * 
     * @throws IOException
     */
    public static KeyStore getKeyStore(String storepass, String keystorePath)
            throws IOException {
        InputStream inputStream = null;
        try {
            KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
            inputStream = new FileInputStream(keystorePath);
            keyStore.load(inputStream, storepass.toCharArray());
            return keyStore;
        } catch (KeyStoreException | NoSuchAlgorithmException
                | CertificateException | IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (null != inputStream) {
                inputStream.close();
            }
        }
        return null;
    }

    /**
     * 獲取私鑰
     * 
     * @param keyStore
     * @param alias
     * @param password
     * @return
     */
    public static PrivateKey getPrivateKey(KeyStore keyStore, String alias,
            String password) {
        try {
            return (PrivateKey) keyStore.getKey(alias, password.toCharArray());
        } catch (UnrecoverableKeyException | KeyStoreException
                | NoSuchAlgorithmException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 獲取公鑰
     * 
     * @param certificate
     * @return
     */
    public static PublicKey getPublicKey(Certificate certificate) {
        return certificate.getPublicKey();
    }

    /**
     * 通過密鑰庫獲取數字證書，不需要密碼，因為獲取到Keystore實例
     * 
     * @param keyStore
     * @param alias
     * @return
     */
    public static X509Certificate getCertificateByKeystore(KeyStore keyStore,
            String alias) {
        try {
            return (X509Certificate) keyStore.getCertificate(alias);
        } catch (KeyStoreException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 通過證書路徑生成證書，與加載密鑰庫差不多，都要用到流。
     * 
     * @param path
     * @param certType
     * @return
     * @throws IOException
     */
    public static X509Certificate getCertificateByCertPath(String path,
            String certType) throws IOException {
        InputStream inputStream = null;
        try {
            // 實例化證書工廠
            CertificateFactory factory = CertificateFactory
                    .getInstance(certType);
            // 取得證書文件流
            inputStream = new FileInputStream(path);
            // 生成證書
            Certificate certificate = factory.generateCertificate(inputStream);

            return (X509Certificate) certificate;
        } catch (CertificateException | IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } finally {
            if (null != inputStream) {
                inputStream.close();
            }
        }
        return null;

    }

    /**
     * 從證書中獲取加密算法，進行簽名
     * 
     * @param certificate
     * @param privateKey
     * @param plainText
     * @return
     */
    public static byte[] sign(X509Certificate certificate,
            PrivateKey privateKey, byte[] plainText) {
        /** 如果要從密鑰庫獲取簽名算法的名稱，只能將其強制轉換成X509標准，JDK 6只支持X.509類型的證書 */
        try {
            Signature signature = Signature.getInstance(certificate
                    .getSigAlgName());
            signature.initSign(privateKey);
            signature.update(plainText);
            return signature.sign();
        } catch (NoSuchAlgorithmException | InvalidKeyException
                | SignatureException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 驗簽，公鑰包含在證書里面
     * 
     * @param certificate
     * @param decodedText
     * @param receivedignature
     * @return
     */
    public static boolean verify(X509Certificate certificate,
            byte[] decodedText, final byte[] receivedignature) {
        try {
            Signature signature = Signature.getInstance(certificate
                    .getSigAlgName());
            /** 注意這里用到的是證書，實際上用到的也是證書里面的公鑰 */
            signature.initVerify(certificate);
            signature.update(decodedText);
            return signature.verify(receivedignature);
        } catch (NoSuchAlgorithmException | InvalidKeyException
                | SignatureException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return false;
    }

    /**
     * 加密。注意密鑰是可以獲取到它適用的算法的。
     * 
     * @param plainText
     * @param privateKey
     * @return
     */
    public static byte[] encode(byte[] plainText, PrivateKey privateKey) {
        try {
            Cipher cipher = Cipher.getInstance(privateKey.getAlgorithm());
            cipher.init(Cipher.ENCRYPT_MODE, privateKey);
            return cipher.doFinal(plainText);
        } catch (NoSuchAlgorithmException | NoSuchPaddingException
                | InvalidKeyException | IllegalBlockSizeException
                | BadPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;

    }

    /**
     * 解密，注意密鑰是可以獲取它適用的算法的。
     * 
     * @param encodedText
     * @param publicKey
     * @return
     */
    public static byte[] decode(byte[] encodedText, PublicKey publicKey) {
        try {
            Cipher cipher = Cipher.getInstance(publicKey.getAlgorithm());
            cipher.init(Cipher.DECRYPT_MODE, publicKey);
            return cipher.doFinal(encodedText);
        } catch (NoSuchAlgorithmException | NoSuchPaddingException
                | InvalidKeyException | IllegalBlockSizeException
                | BadPaddingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return null;
    }
}