RSA概要介紹

1976年以前，所有的加密方法都是同一種模式：

1. 甲方選擇某一種加密規則，對資訊進行加密；
2. 乙方使用同一種規則，對資訊進行解密

由於加密和解密使用同樣的規則（簡稱“祕鑰”）,這種被稱為“對稱加密演算法”。這種加密模式有個最大的弱點：甲方必須把加密規則告訴乙方，否則無法解密。儲存和傳遞祕鑰成了最頭疼的問題。

1976年，兩位美國電腦科學家Whitfield Diffie和Martin Hellman，提出了一種嶄新的構思，可以在不直接傳遞祕鑰完成加密，這個被稱為”Diffie-Hellman金鑰交換演算法”。這個演算法啟發了其他科學家。人們認識到，加密和解密可以使用不同的規則，這要這種規則直接存在某種對應的關係即可，這樣就避免了直接傳遞祕鑰。

這種新的加密模式被稱為“非對稱加密演算法”：

1. 乙方生成兩把金鑰（公鑰和私鑰）。公鑰是公開的，任何人都可以獲得，私鑰則是保密的。
2. 甲方獲取乙方的公鑰，然後用它對資訊加密。
3. 乙方得到加密後的資訊，用私鑰解密。

如果公鑰加密的資訊只有私鑰解得開，那麼只要私鑰不洩漏，通訊就是安全的。

1977年，三位數學家Rivest、Shamir 和 Adleman 設計了一種演算法，可以實現非對稱加密。這種演算法用他們三個人的名字命名，叫做RSA演算法。從那時直到現在，RSA演算法一直是最廣為使用的”非對稱加密演算法”。毫不誇張地說，只要有計算機網路的地方，就有RSA演算法。

這種演算法非常可靠，金鑰越長，它就越難破解。根據已經披露的文獻，目前被破解的最長RSA金鑰是768個二進位制位。也就是說，長度超過768位的金鑰，還無法破解（至少沒人公開宣佈）。因此可以認為，1024位的RSA金鑰基本安全，2048位的金鑰極其安全。

RSA是目前最有影響力的公鑰加密演算法，它能夠抵抗到目前為止已知的絕大多數密碼攻擊，已被ISO推薦為公鑰資料加密標準。

RSA加解密Java實現方式

RSA基礎類：

public class RSABase {

    private static final String ALGORITHM = "RSA";

    private static final String SIGN_ALGORITHMS = "SHA1WithRSA";

    private static final String DEFAULT_CHARSET = "UTF-8";

    /** RSA最大加密明文大小 */
 

    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** RSA最大解密密文大小 */
    private static final int MAX_DECRYPT_BLOCK = 128;

    private static final String TRANSFORMATION = "RSA";

    public static String sign(String content, String privateKey) {
        try {
            PrivateKey priKey = getPrivateKey(privateKey);
            java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
            signature.initSign(priKey);
            signature.update(content.getBytes(DEFAULT_CHARSET));
            byte[] signed = signature.sign();
            return Base64.encode(signed);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return null;
    }

    /**
     * 解密
     * 
     * @param content
     *            密文
     * @param private_key
     *            私鑰
     * @return 解密後的字串
     */
    public static String decryptByPrivateKey(String content, String private_key) throws Exception {
        return decrypByKey(content, getPrivateKey(private_key));
    }

    /**
     * 解密
     * 
     * @param content
     *            密文
     * @param private_key
     *            私鑰
     * @return 解密後的字串
     */
    public static String decryptByPublicKey(String content, String public_key) throws Exception {
        return decrypByKey(content, getPublickKey(public_key));
    }

    /**
     * 解密
     * 
     * @param content
     * @param key
     * @return
     * @throws Exception
     */
    private static String decrypByKey(String content, Key key) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.DECRYPT_MODE, key);
        InputStream ins = new ByteArrayInputStream(Base64.decode(content));
        ByteArrayOutputStream writer = new ByteArrayOutputStream();
        // rsa解密的位元組大小最多是128，將需要解密的內容，按128位拆開解密
        byte[] buf = new byte[MAX_DECRYPT_BLOCK];
        int bufl;

        while ((bufl = ins.read(buf)) != -1) {
            byte[] block = null;

            if (buf.length == bufl) {
                block = buf;
            } else {
                block = new byte[bufl];
                for (int i = 0; i < bufl; i++) {
                    block[i] = buf[i];
                }
            }
            writer.write(cipher.doFinal(block));
        }
        return new String(writer.toByteArray(), DEFAULT_CHARSET);
    }

    /**
     * 得到私鑰
     * 
     * @param key
     *            金鑰字串（經過base64編碼）
     * @throws Exception
     */
    protected static PrivateKey getPrivateKey(String key) throws Exception {
        byte[] keyBytes = Base64.decode(key);
        PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
        return privateKey;
    }

    /**
     * 從檔案中載入私鑰
     * 
     * @throws Exception
     */
    protected static PrivateKey getPrivateKey(InputStream in) throws Exception {
        return getPrivateKey(readFileKey(in));
    }


    /**
     * 從檔案中載入私鑰
     * 
     * @throws Exception
     */
    protected static PublicKey getPublickKey(InputStream in) throws Exception {
        return getPublickKey(readFileKey(in));
    }


    /**
     * 讀取檔案中的祕鑰資訊
     * @param in
     * @return
     * @throws Exception
     */
    private static String readFileKey(InputStream in) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(in));
        String readLine = null;
        StringBuilder sb = new StringBuilder();
        while ((readLine = br.readLine()) != null) {
            if (readLine.charAt(0) == '-') {
                continue;
            } else {
                sb.append(readLine);
                sb.append('\r');
            }
        }
        return sb.toString();
    }


    /**
     * 根據制定的可以進行加密
     * 
     * @param content
     * @param key
     * @return
     * @throws Exception
     */
    public static String encyptByKey(String content, Key key) throws Exception {
        Cipher cipher = Cipher.getInstance(TRANSFORMATION);
        cipher.init(Cipher.ENCRYPT_MODE, key);
        byte[] data = content.getBytes(DEFAULT_CHARSET);
        int inputlen = data.length;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        int offset = 0;
        byte[] cache;
        int i = 0;
        // rsa加密的位元組大小最多是117,分段加密
        while (inputlen - offset > 0) {
            if (inputlen - offset > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offset, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offset, inputlen - offset);
            }
            bos.write(cache, 0, cache.length);
            i++;
            offset = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptData = bos.toByteArray();
        bos.close();

        return Base64.encode(encryptData);
    }

    /**
     * 
     * @param content
     *            原始資料
     * @param publicKey
     *            金鑰字串（經過base64編碼）
     * @return 加密後的資料
     * @throws Exception
     */
    public static String encyptByPublicKey(String content, String publicKey) throws Exception {
        return encyptByKey(content, getPublickKey(publicKey));
    }

    /**
     * 
     * @param content
     *            原始資料
     * @param privateKey
     *            金鑰字串（經過base64編碼）
     * @return 加密後的資料
     * @throws Exception
     */
    public static String encyptByPrivateKey(String content, String privateKey) throws Exception {
        return encyptByKey(content, getPrivateKey(privateKey));
    }

    /**
     * 得到公鑰
     * 
     * @param publicKey
     *            金鑰字串（經過base64編碼）
     * @return
     * @throws Exception
     */
    private static PublicKey getPublickKey(String publicKey) throws Exception {
        byte[] buffer = Base64.decode(publicKey);
        KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);
        X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
        return keyFactory.generatePublic(keySpec);
    }

    /**
     * RSA驗簽名檢查
     * 
     * @param content
     *            待簽名資料
     * @param sign
     *            簽名值
     * @param public_key
     *            公鑰
     * @return 布林值
     */
    public static boolean verify(String content, String sign, String public_key) {
        try {
            PublicKey pubKey = getPublickKey(public_key);
            java.security.Signature signature = java.security.Signature.getInstance(SIGN_ALGORITHMS);
            signature.initVerify(pubKey);
            signature.update(content.getBytes(DEFAULT_CHARSET));
            return signature.verify(Base64.decode(sign));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
}

BASE64類：

public final class Base64 {

    private static final int BASELENGTH = 128;
    private static final int LOOKUPLENGTH = 64;
    private static final int TWENTYFOURBITGROUP = 24;
    private static final int EIGHTBIT = 8;
    private static final int SIXTEENBIT = 16;
    private static final int FOURBYTE = 4;
    private static final int SIGN = -128;
    private static char PAD = '=';
    private static byte[] base64Alphabet = new byte[BASELENGTH];
    private static char[] lookUpBase64Alphabet = new char[LOOKUPLENGTH];

    static {
        for (int i = 0; i < BASELENGTH; ++i) {
            base64Alphabet[i] = -1;
        }
        for (int i = 'Z'; i >= 'A'; i--) {
            base64Alphabet[i] = (byte) (i - 'A');
        }
        for (int i = 'z'; i >= 'a'; i--) {
            base64Alphabet[i] = (byte) (i - 'a' + 26);
        }

        for (int i = '9'; i >= '0'; i--) {
            base64Alphabet[i] = (byte) (i - '0' + 52);
        }

        base64Alphabet['+'] = 62;
        base64Alphabet['/'] = 63;

        for (int i = 0; i <= 25; i++) {
            lookUpBase64Alphabet[i] = (char) ('A' + i);
        }

        for (int i = 26, j = 0; i <= 51; i++, j++) {
            lookUpBase64Alphabet[i] = (char) ('a' + j);
        }

        for (int i = 52, j = 0; i <= 61; i++, j++) {
            lookUpBase64Alphabet[i] = (char) ('0' + j);
        }
        lookUpBase64Alphabet[62] = (char) '+';
        lookUpBase64Alphabet[63] = (char) '/';

    }

    private static boolean isWhiteSpace(char octect) {
        return (octect == 0x20 || octect == 0xd || octect == 0xa || octect == 0x9);
    }

    private static boolean isPad(char octect) {
        return (octect == PAD);
    }

    private static boolean isData(char octect) {
        return (octect < BASELENGTH && base64Alphabet[octect] != -1);
    }

    /**
     * Encodes hex octects into Base64
     * 
     * @param binaryData
     *            Array containing binaryData
     * @return Encoded Base64 array
     */
    public static String encode(byte[] binaryData) {

        if (binaryData == null) {
            return null;
        }

        int lengthDataBits = binaryData.length * EIGHTBIT;
        if (lengthDataBits == 0) {
            return "";
        }

        int fewerThan24bits = lengthDataBits % TWENTYFOURBITGROUP;
        int numberTriplets = lengthDataBits / TWENTYFOURBITGROUP;
        int numberQuartet = fewerThan24bits != 0 ? numberTriplets + 1 : numberTriplets;
        char encodedData[] = null;

        encodedData = new char[numberQuartet * 4];

        byte k = 0, l = 0, b1 = 0, b2 = 0, b3 = 0;

        int encodedIndex = 0;
        int dataIndex = 0;

        for (int i = 0; i < numberTriplets; i++) {
            b1 = binaryData[dataIndex++];
            b2 = binaryData[dataIndex++];
            b3 = binaryData[dataIndex++];

            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);
            byte val3 = ((b3 & SIGN) == 0) ? (byte) (b3 >> 6) : (byte) ((b3) >> 6 ^ 0xfc);

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[(l << 2) | val3];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[b3 & 0x3f];
        }

        // form integral number of 6-bit groups
        if (fewerThan24bits == EIGHTBIT) {
            b1 = binaryData[dataIndex];
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[k << 4];
            encodedData[encodedIndex++] = PAD;
            encodedData[encodedIndex++] = PAD;
        } else if (fewerThan24bits == SIXTEENBIT) {
            b1 = binaryData[dataIndex];
            b2 = binaryData[dataIndex + 1];
            l = (byte) (b2 & 0x0f);
            k = (byte) (b1 & 0x03);

            byte val1 = ((b1 & SIGN) == 0) ? (byte) (b1 >> 2) : (byte) ((b1) >> 2 ^ 0xc0);
            byte val2 = ((b2 & SIGN) == 0) ? (byte) (b2 >> 4) : (byte) ((b2) >> 4 ^ 0xf0);

            encodedData[encodedIndex++] = lookUpBase64Alphabet[val1];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[val2 | (k << 4)];
            encodedData[encodedIndex++] = lookUpBase64Alphabet[l << 2];
            encodedData[encodedIndex++] = PAD;
        }

        return new String(encodedData);
    }

    /**
     * Decodes Base64 data into octects
     * 
     * @param encoded
     *            string containing Base64 data
     * @return Array containind decoded data.
     */
    public static byte[] decode(String encoded) {

        if (encoded == null) {
            return null;
        }

        char[] base64Data = encoded.toCharArray();
        // remove white spaces
        int len = removeWhiteSpace(base64Data);

        if (len % FOURBYTE != 0) {
            return null;// should be divisible by four
        }

        int numberQuadruple = (len / FOURBYTE);

        if (numberQuadruple == 0) {
            return new byte[0];
        }

        byte decodedData[] = null;
        byte b1 = 0, b2 = 0, b3 = 0, b4 = 0;
        char d1 = 0, d2 = 0, d3 = 0, d4 = 0;

        int i = 0;
        int encodedIndex = 0;
        int dataIndex = 0;
        decodedData = new byte[(numberQuadruple) * 3];

        for (; i < numberQuadruple - 1; i++) {

            if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))
                    || !isData((d3 = base64Data[dataIndex++])) || !isData((d4 = base64Data[dataIndex++]))) {
                return null;
            } // if found "no data" just return null

            b1 = base64Alphabet[d1];
            b2 = base64Alphabet[d2];
            b3 = base64Alphabet[d3];
            b4 = base64Alphabet[d4];

            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);
        }

        if (!isData((d1 = base64Data[dataIndex++])) || !isData((d2 = base64Data[dataIndex++]))) {
            return null;// if found "no data" just return null
        }

        b1 = base64Alphabet[d1];
        b2 = base64Alphabet[d2];

        d3 = base64Data[dataIndex++];
        d4 = base64Data[dataIndex++];
        if (!isData((d3)) || !isData((d4))) {// Check if they are PAD characters
            if (isPad(d3) && isPad(d4)) {
                if ((b2 & 0xf) != 0)// last 4 bits should be zero
                {
                    return null;
                }
                byte[] tmp = new byte[i * 3 + 1];
                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                tmp[encodedIndex] = (byte) (b1 << 2 | b2 >> 4);
                return tmp;
            } else if (!isPad(d3) && isPad(d4)) {
                b3 = base64Alphabet[d3];
                if ((b3 & 0x3) != 0)// last 2 bits should be zero
                {
                    return null;
                }
                byte[] tmp = new byte[i * 3 + 2];
                System.arraycopy(decodedData, 0, tmp, 0, i * 3);
                tmp[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
                tmp[encodedIndex] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
                return tmp;
            } else {
                return null;
            }
        } else { // No PAD e.g 3cQl
            b3 = base64Alphabet[d3];
            b4 = base64Alphabet[d4];
            decodedData[encodedIndex++] = (byte) (b1 << 2 | b2 >> 4);
            decodedData[encodedIndex++] = (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf));
            decodedData[encodedIndex++] = (byte) (b3 << 6 | b4);

        }

        return decodedData;
    }

    /**
     * remove WhiteSpace from MIME containing encoded Base64 data.
     * 
     * @param data
     *            the byte array of base64 data (with WS)
     * @return the new length
     */
    private static int removeWhiteSpace(char[] data) {
        if (data == null) {
            return 0;
        }

        // count characters that's not whitespace
        int newSize = 0;
        int len = data.length;
        for (int i = 0; i < len; i++) {
            if (!isWhiteSpace(data[i])) {
                data[newSize++] = data[i];
            }
        }
        return newSize;
    }
}

RSA工具類：

public class RsaUtil {

    public static String PUBLICK_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQClexlMC+y6aqjPOM4dIF3xbu3o"
            + "OnA41wG9l2GsomyaUILJR9/ppFVfabSU3acTdSkzq451PbTtKOo+kP8Ih/2qhV5N"
            + "Z2h1bptM28W2rSKPKcDt5o754L+GsXbWo39zd7uS5yZFKhLZw7YVi3fJ6ty5XMMs" + "7ERx/hMY/bYqyTAabQIDAQAB";
    public static final String PRIVATE_KEY = "MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKV7GUwL7LpqqM84"
            + "zh0gXfFu7eg6cDjXAb2XYayibJpQgslH3+mkVV9ptJTdpxN1KTOrjnU9tO0o6j6Q"
            + "/wiH/aqFXk1naHVum0zbxbatIo8pwO3mjvngv4axdtajf3N3u5LnJkUqEtnDthWL"
            + "d8nq3LlcwyzsRHH+Exj9tirJMBptAgMBAAECgYBPEqdf40LXQSgw/N/goxrAx1T/"
            + "Zw1A29yFD9UofOSQSHB2ZdXk+xWgZg5YJCI19gIeIpgMBdRyjt5/zyFOnkzjbeXF"
            + "Jx0i8i+8AKUsU+NencswTiPy9lHQKTLIbFEifDxl2IWaCaQ2kn+3z+jfxbcm9znT"
            + "vsFlu1kcaY/lNLZVsQJBANDsIt1yyEK8Wi68TdXRGuxl1OD8c9nZkLVTHax+1JWo"
            + "QyjI2rF4H3Do+S9QwofV26SDgPKsZwKNbTuHxlnWWTsCQQDKxQAWpP3HoHFAG2LQ"
            + "2KTJwBZtfM1sQjeN64hQ8cj89o1XRQjF2oWO0Ve+ibeDzMmGaLeky9WDfmnp6G05"
            + "2+B3AkBv+6JUgInG+557HoO57/M2cv6/+ZE/W9as2ng1VWYtMZuN6NsP9QslQjsO"
            + "mYMru/2XGMWtTauJOrUqC4TN8o6xAkEAw7l86F7CiJsaNiM5MxarmgLMo0rAjysr"
            + "rNYZcuiwdV0X+ZEtcq4IFV+FLuqINbTLIe6atXv70T2IxrwQErVm6QJAWfjVujrj"
            + "8yjGWK/gZDK5b/eSuDTg5lMJneGEzZm8uXRVUQqka5dP+j8vFr9IuEYb/N4CN5Je" + "E7x8NgrbgXVlbA==";

    public static String encrypt(String content) {
        try {
            return RSABase.encyptByPublicKey(content, PUBLICK_KEY);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    public static String decrypt(String content) {
        try {
            return RSABase.decryptByPrivateKey(content, PRIVATE_KEY);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    public static String sign(String content) {
        return RSABase.sign(content, PRIVATE_KEY);
    }

    public static void main(String[] args) {
        // 加解密測試
        String content = "2rwssfssdafsfj";
        String encrypt = encrypt(content);
        System.out.println(encrypt);
        System.out.println(decrypt(encrypt));

        // 簽名測試
        String sign = sign(content);
        System.out.println(sign);
        System.out.println(RSABase.verify(content, sign, PUBLICK_KEY));
    }

}

相關的介紹就不用寫了，程式碼和註釋已經很明白了

使用openssl生成祕鑰

windows環境的操作方法：
1. 工具下載：openssl工具
2. 雙擊執行bin目錄下的openssl.exe
2. 生成RSA私鑰命令：genrsa -out rsa_private_key.pem 1024
3. 生成RSA公鑰命令：rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem
4. 將RSA私鑰轉換成PKCS8格式：pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -out rsa_private_key_pkcs.txt -nocrypt

注意上面提供的測試程式碼私鑰是基於pkcs8格式的。

RSA簽名及驗籤

資料摘要

資料摘要就是對資料來源進行一個演算法之後得到的一個摘要，也叫資料指紋，不同的資料來源，摘要結果不一樣。

資料摘要演算法是一種能產生特殊輸出格式的演算法，其原理是根據一定的運算規則對原始資料進行某種資訊的提取，被提取的資訊稱為原始資料的資訊摘要。

常用的摘要演算法有RSA公司的MD5演算法和SHA-1演算法以及其大量的變體。

資料摘要的特點：
1. 無論輸入的訊息有多長，計算出來的訊息摘要的長度總是固定的。例如應用MD5演算法摘要的訊息有128個位元位，用SHA-1演算法摘要的訊息最終有160位元位的輸出。
1. 一般來說（不考慮碰撞的情況下），只要輸入的原始資料不同，對其進行摘要以後產生的訊息摘要也必不相同，即使原始資料稍有改變，輸出的訊息摘要便完全不同。但是，相同的輸入必會產生相同的輸出。
1. 具有不可逆性，即只能進行正向的資訊摘要，而無法從摘要中恢復出任何的原始訊息。

資料簽名

大家知道要保證資訊的可靠通訊，必須要解決兩個問題：一，確定訊息的來源就是其申明的那個人；二，要保證資料在傳輸的過程中不被第三方篡改，即使篡改了也能發覺出來。

所謂書數字簽名就是為了解決上述兩個問題二產生，對非對稱加密技術和資料摘要技術的一個具體應用。對訊息傳送者來說，首先要生成一對公私鑰，將公鑰發給訊息接收者。
使用方法：
1. 訊息傳送者要給訊息接收者傳送訊息，出了傳送原始資料外，還需要傳送原始資料的數字簽名
2. 對訊息接受者來說，它將收到兩個資料，原始資料和簽名資料，它需要判斷這兩個資料的合法信來確保通訊的可靠，那麼如何操作呢：(1):對原始資料提取資料摘要，注意這裡使用的訊息摘要演算法和傳送方的一致；(2):對附加的那段數字簽名使用預先得到的公鑰解密；(3):比較前兩步所得到的兩段訊息是否一致。如果一致，則表明訊息是可靠的，否則訊息在傳輸過程中一定出現了問題，訊息不可信。

在加解密的程式碼中已經提供了簽名和驗籤的操作，就不在闡述。使用過支付寶的SDK的朋友都知道，向支付寶介面提交訂單資訊是就需要對訂單資訊進行簽名，支付寶為了確保訂單資訊的可靠性就使用了簽名機制。

總結：

1. 使用加解密為了保證資料的安全性，公鑰加密私鑰解密；私鑰加密公鑰解密。
2. 簽名機制是為了保證資料通訊的可靠性,私鑰簽名公鑰驗籤。