公鑰，私鑰和數字簽名這樣最好理解 (轉載)

原文地址

http://blog.csdn.net/tabactivity/article/details/49685319

原文內容

一、公鑰加密  假設一下，我找了兩個數字，一個是1，一個是2。我喜歡2這個數字，就保留起來，不告訴你們(私鑰），然後我告訴大家，1是我的公鑰。

我有一個文件，不能讓別人看，我就用1加密了。別人找到了這個文件，但是他不知道2就是解密的私鑰啊，所以他解不開，只有我可以用 數字2，就是我的私鑰，來解密。這樣我就可以保護數據了。

我的好朋友x用我的公鑰1加密了字符a，加密後成了b，放在網上。別人偷到了這個文件，但是別人解不開，因爲別人不知道2就是我的私鑰， 只有我才能解密，解密後就得到a。這樣，我們就可以傳送加密的數據了。

 

二、私鑰簽名 如果我用私鑰加密一段數據（當然只有我可以用私鑰加密，因爲只有我知道2是我的私鑰），結果所有的人都看到我的內容了，因爲他們都知 道我的公鑰是1，那麼這種加密有什麼用處呢？

但是我的好朋友x說有人冒充我給他發信。怎麼辦呢？我把我要發的信，內容是c，用我的私鑰2，加密，加密後的內容是d，發給x，再告訴他 解密看是不是c。他用我的公鑰1解密，發現果然是c。 這個時候，他會想到，能夠用我的公鑰解密的數據，必然是用我的私鑰加的密。只有我知道我得私鑰，因此他就可以確認確實是我發的東西。 這樣我們就能確認發送方身份了。這個過程叫做數字簽名。當然具體的過程要稍微複雜一些。用私鑰來加密數據，用途就是數字簽名。

 

總結：公鑰和私鑰是成對的，它們互相解密。

公鑰加密，私鑰解密。

私鑰數字簽名，公鑰驗證。

 

舉例

比如有兩個用戶Alice和Bob，Alice想把一段明文通過雙鑰加密的技術發送給Bob，Bob有一對公鑰和私鑰，那麼加密解密的過程如下：

1. Bob將他的公開密鑰傳送給Alice。
2. Alice用Bob的公開密鑰加密她的消息，然後傳送給Bob。
3. Bob用他的私人密鑰解密Alice的消息。

　　上面的過程可以用下圖表示，Alice使用Bob的公鑰進行加密，Bob用自己的私鑰進行解密。

例子和圖出自《網絡安全基礎 應用與標準第二版》

 

RSA算法

RSA公鑰加密算法是1977年由Ron Rivest、Adi Shamirh和LenAdleman在（美國麻省理工學院）開發的。RSA取名來自開發他們三者的名字。RSA是目前最有影響力的公鑰加密算法，它能夠抵抗到目前爲止已知的所有密碼攻擊，已被ISO推薦爲公鑰數據加密標準。RSA算法基於一個十分簡單的數論事實：將兩個大素數相乘十分容易，但那時想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作爲加密密鑰。

 

package cn.aizichan.utils.digest;

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.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;

public class RSACoder {
    //非對稱密鑰算法
    public static final String KEY_ALGORITHM="RSA";
    /**
     * 密鑰長度，DH算法的默認密鑰長度是1024
     * 密鑰長度必須是64的倍數，在512到65536位之間
     * */
    private static final int KEY_SIZE=512;
    //公鑰
    private static final String PUBLIC_KEY="xiaoxiaorenzhe";

    //私鑰
    private static final String PRIVATE_KEY="dadapangzi";

    /**
     * 初始化密鑰對
     * @return Map 甲方密鑰的Map
     * */
    public static Map<String,Object> initKey() throws Exception{
        //實例化密鑰生成器
        KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密鑰生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密鑰對
        KeyPair keyPair=keyPairGenerator.generateKeyPair();
        //甲方公鑰
        RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
        System.out.println("係數："+publicKey.getModulus()+"  加密指數："+publicKey.getPublicExponent());
        //甲方私鑰
        RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
        System.out.println("係數："+privateKey.getModulus()+"解密指數："+privateKey.getPrivateExponent());
        //將密鑰存儲在map中
        Map<String,Object> keyMap=new HashMap<String,Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;

    }

    /**
     * 私鑰加密
     * @param data待加密數據
     * @param key 密鑰
     * @return byte[] 加密數據
     * */
    public static byte[] encryptByPrivateKey(byte[] data,byte[] key) throws Exception{

        //取得私鑰
        PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私鑰
        PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
        //數據加密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公鑰加密
     * @param data待加密數據
     * @param key 密鑰
     * @return byte[] 加密數據
     * */
    public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{

        //實例化密鑰工廠
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公鑰
        //密鑰材料轉換
        X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
        //產生公鑰
        PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);

        //數據加密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }
    /**
     * 私鑰解密
     * @param data 待解密數據
     * @param key 密鑰
     * @return byte[] 解密數據
     * */
    public static byte[] decryptByPrivateKey(byte[] data,byte[] key) throws Exception{
        //取得私鑰
        PKCS8EncodedKeySpec pkcs8KeySpec=new PKCS8EncodedKeySpec(key);
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //生成私鑰
        PrivateKey privateKey=keyFactory.generatePrivate(pkcs8KeySpec);
        //數據解密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }

    /**
     * 公鑰解密
     * @param data 待解密數據
     * @param key 密鑰
     * @return byte[] 解密數據
     * */
    public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{

        //實例化密鑰工廠
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公鑰
        //密鑰材料轉換
        X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
        //產生公鑰
        PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
        //數據解密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }

    /**
     * 取得私鑰
     * @param keyMap 密鑰map
     * @return byte[] 私鑰
     * */
    public static byte[] getPrivateKey(Map<String,Object> keyMap){
        Key key=(Key)keyMap.get(PRIVATE_KEY);
        return key.getEncoded();
    }
    /**
     * 取得公鑰
     * @param keyMap 密鑰map
     * @return byte[] 公鑰
     * */
    public static byte[] getPublicKey(Map<String,Object> keyMap) throws Exception{
        Key key=(Key) keyMap.get(PUBLIC_KEY);
        return key.getEncoded();
    }
    /**
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        //初始化密鑰
        //生成密鑰對
        Map<String,Object> keyMap=RSACoder.initKey();
        //公鑰
        byte[] publicKey=RSACoder.getPublicKey(keyMap);
        //byte[] publicKey = b;
        //私鑰
        byte[] privateKey=RSACoder.getPrivateKey(keyMap);
        System.out.println("公鑰："+Base64.encode(publicKey));
        System.out.println("私鑰："+Base64.encode(privateKey));

        System.out.println("================密鑰對構造完畢,甲方將公鑰公佈給乙方，開始進行加密數據的傳輸=============");
        String str="aattaggcctegthththfef/aat.mp4";
        System.out.println("===========甲方向乙方發送加密數據==============");
        System.out.println("原文:"+str);
        //甲方進行數據的加密
        byte[] code1=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
        System.out.println("甲方 使用乙方公鑰加密後的數據："+Base64.encode(code1));
        System.out.println("===========乙方使用甲方提供的公鑰對數據進行解密==============");
        //乙方進行數據的解密
        //byte[] decode1=RSACoder.decryptByPublicKey(code1, publicKey);
        byte[] decode1=RSACoder.decryptByPrivateKey(code1, privateKey);
        System.out.println("乙方解密後的數據："+new String(decode1)+"");

        System.out.println("===========反向進行操作，乙方向甲方發送數據==============");

        str="乙方向甲方發送數據RSA算法";

        System.out.println("原文:"+str);

        //乙方使用公鑰對數據進行加密
        byte[] code2=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
        System.out.println("===========乙方使用公鑰對數據進行加密==============");
        System.out.println("加密後的數據："+Base64.encode(code2));

        System.out.println("=============乙方將數據傳送給甲方======================");
        System.out.println("===========甲方使用私鑰對數據進行解密==============");

        //甲方使用私鑰對數據進行解密
        byte[] decode2=RSACoder.decryptByPrivateKey(code2, privateKey);

        System.out.println("甲方解密後的數據："+new String(decode2));


    }
}