JAVA加解密16-非對稱加密算法-RSA算法

一、概述
1.RSA是基于大數(shù)因子分解難題。目前各種主流計(jì)算機(jī)語言都支持RSA算法的實(shí)現(xiàn)
2.java6支持RSA算法
3.RSA算法可以用于數(shù)據(jù)加密和數(shù)字簽名
4.RSA算法相對于DES/AES等對稱加密算法，他的速度要慢的多
5.總原則：公鑰加密，私鑰解密 / 私鑰加密，公鑰解密

二、模型分析
RSA算法構(gòu)建密鑰對簡單的很，這里我們還是以甲乙雙方發(fā)送數(shù)據(jù)為模型
1.甲方在本地構(gòu)建密鑰對（公鑰+私鑰），并將公鑰公布給乙方
2.甲方將數(shù)據(jù)用私鑰進(jìn)行加密，發(fā)送給乙方
3.乙方用甲方提供的公鑰對數(shù)據(jù)進(jìn)行解密

如果乙方向傳送數(shù)據(jù)給甲方：
4.乙方用公鑰對數(shù)據(jù)進(jìn)行加密，然后傳送給甲方
5.甲方用私鑰對數(shù)據(jù)進(jìn)行解密

三、代碼分析

package com.ca.test;
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;
import javax.crypto.interfaces.DHPrivateKey;
import javax.crypto.interfaces.DHPublicKey;
import org.apache.commons.codec.binary.Base64;
/**
 * 非對稱加密算法RSA算法組件
 * 非對稱算法一般是用來傳送對稱加密算法的密鑰來使用的，相對于DH算法，RSA算法只需要一方構(gòu)造密鑰，不需要
 * 大費(fèi)周章的構(gòu)造各自本地的密鑰對了。DH算法只能算法非對稱算法的底層實(shí)現(xiàn)。而RSA算法算法實(shí)現(xiàn)起來較為簡單
 * @author kongqz
 * */
public class RSACoder {
    //非對稱密鑰算法
    public static final String KEY_ALGORITHM="RSA";
    
    
    /**
     * 密鑰長度，DH算法的默認(rèn)密鑰長度是1024
     * 密鑰長度必須是64的倍數(shù)，在512到65536位之間
     * */
    private static final int KEY_SIZE=512;
    //公鑰
    private static final String PUBLIC_KEY="RSAPublicKey";
    
    //私鑰
    private static final String PRIVATE_KEY="RSAPrivateKey";
    
    /**
     * 初始化密鑰對
     * @return Map 甲方密鑰的Map
     * */
    public static Map<String,Object> initKey() throws Exception{
        //實(shí)例化密鑰生成器
        KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance(KEY_ALGORITHM);
        //初始化密鑰生成器
        keyPairGenerator.initialize(KEY_SIZE);
        //生成密鑰對
        KeyPair keyPair=keyPairGenerator.generateKeyPair();
        //甲方公鑰
        RSAPublicKey publicKey=(RSAPublicKey) keyPair.getPublic();
        //甲方私鑰
        RSAPrivateKey privateKey=(RSAPrivateKey) keyPair.getPrivate();
        //將密鑰存儲在map中
        Map<String,Object> keyMap=new HashMap<String,Object>();
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);
        return keyMap;
        
    }
    
    
    /**
     * 私鑰加密
     * @param data待加密數(shù)據(jù)
     * @param key 密鑰
     * @return byte[] 加密數(shù)據(jù)
     * */
    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);
        //數(shù)據(jù)加密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }
    /**
     * 公鑰加密
     * @param data待加密數(shù)據(jù)
     * @param key 密鑰
     * @return byte[] 加密數(shù)據(jù)
     * */
    public static byte[] encryptByPublicKey(byte[] data,byte[] key) throws Exception{
        
        //實(shí)例化密鑰工廠
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公鑰
        //密鑰材料轉(zhuǎn)換
        X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
        //產(chǎn)生公鑰
        PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
        
        //數(shù)據(jù)加密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);
        return cipher.doFinal(data);
    }
    /**
     * 私鑰解密
     * @param data 待解密數(shù)據(jù)
     * @param key 密鑰
     * @return byte[] 解密數(shù)據(jù)
     * */
    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);
        //數(shù)據(jù)解密
        Cipher cipher=Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        return cipher.doFinal(data);
    }
    /**
     * 公鑰解密
     * @param data 待解密數(shù)據(jù)
     * @param key 密鑰
     * @return byte[] 解密數(shù)據(jù)
     * */
    public static byte[] decryptByPublicKey(byte[] data,byte[] key) throws Exception{
        
        //實(shí)例化密鑰工廠
        KeyFactory keyFactory=KeyFactory.getInstance(KEY_ALGORITHM);
        //初始化公鑰
        //密鑰材料轉(zhuǎn)換
        X509EncodedKeySpec x509KeySpec=new X509EncodedKeySpec(key);
        //產(chǎn)生公鑰
        PublicKey pubKey=keyFactory.generatePublic(x509KeySpec);
        //數(shù)據(jù)解密
        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[] privateKey=RSACoder.getPrivateKey(keyMap);
        System.out.println("公鑰：/n"+Base64.encodeBase64String(publicKey));
        System.out.println("私鑰：/n"+Base64.encodeBase64String(privateKey));
        
        System.out.println("================密鑰對構(gòu)造完畢,甲方將公鑰公布給乙方，開始進(jìn)行加密數(shù)據(jù)的傳輸=============");
        String str="RSA密碼交換算法";
        System.out.println("/n===========甲方向乙方發(fā)送加密數(shù)據(jù)==============");
        System.out.println("原文:"+str);
        //甲方進(jìn)行數(shù)據(jù)的加密
        byte[] code1=RSACoder.encryptByPrivateKey(str.getBytes(), privateKey);
        System.out.println("加密后的數(shù)據(jù)："+Base64.encodeBase64String(code1));
        System.out.println("===========乙方使用甲方提供的公鑰對數(shù)據(jù)進(jìn)行解密==============");
        //乙方進(jìn)行數(shù)據(jù)的解密
        byte[] decode1=RSACoder.decryptByPublicKey(code1, publicKey);
        System.out.println("乙方解密后的數(shù)據(jù)："+new String(decode1)+"/n/n");
        
        System.out.println("===========反向進(jìn)行操作，乙方向甲方發(fā)送數(shù)據(jù)==============/n/n");
        
        str="乙方向甲方發(fā)送數(shù)據(jù)RSA算法";
        
        System.out.println("原文:"+str);
        
        //乙方使用公鑰對數(shù)據(jù)進(jìn)行加密
        byte[] code2=RSACoder.encryptByPublicKey(str.getBytes(), publicKey);
        System.out.println("===========乙方使用公鑰對數(shù)據(jù)進(jìn)行加密==============");
        System.out.println("加密后的數(shù)據(jù)："+Base64.encodeBase64String(code2));
        
        System.out.println("=============乙方將數(shù)據(jù)傳送給甲方======================");
        System.out.println("===========甲方使用私鑰對數(shù)據(jù)進(jìn)行解密==============");
        
        //甲方使用私鑰對數(shù)據(jù)進(jìn)行解密
        byte[] decode2=RSACoder.decryptByPrivateKey(code2, privateKey);
        
        System.out.println("甲方解密后的數(shù)據(jù)："+new String(decode2));
    }
}

控制臺輸出：
公鑰：
MFwwDQYJKoZIhvcNAQEBBQADSwAwSAJBAM0qc+eVm4pyBbCBuM4jRxOYsxWkylLXVklyWp3JNs71
B6vLVg2Iwh6TwPbpXbGWOI11RMLhe5bwLpdeBqP4f4MCAwEAAQ==
私鑰：
MIIBVQIBADANBgkqhkiG9w0BAQEFAASCAT8wggE7AgEAAkEAzSpz55WbinIFsIG4ziNHE5izFaTK
UtdWSXJanck2zvUHq8tWDYjCHpPA9uldsZY4jXVEwuF7lvAul14Go/h/gwIDAQABAkByhW3pKSOH
Zhoy6lYkCqEUGTptrGybTUQG/2QBi12iqzenm7rKlasjdMEr6Q8RX5RpGArzvhvLepAPqPZ5LXjR
AiEA7vI8/9HHrZSbHQ4Up7xby7bOULknoRjZy68HRMPRSXUCIQDbzwQfvrYNqLiauTcNsg6ejCJw
cxSCLlJupgwBBjyOFwIgVEbWIviPr/ZpGz9bI6o4ykoozKnxg01ri/6o1qUmTP0CIQDBC0XO73oJ
8vT2BdZA8/D884vHgHoxfqcswC3otGZ4TwIhANGXz8GHxM0zuOg8pds54S1ARlrkUXFULocVZ2Ka
ngFf
================密鑰對構(gòu)造完畢,甲方將公鑰公布給乙方，開始進(jìn)行加密數(shù)據(jù)的傳輸=============
===========甲方向乙方發(fā)送加密數(shù)據(jù)==============
原文:RSA密碼交換算法
加密后的數(shù)據(jù)：kF3vekz0DpJmLzwdrWjfZLyGBWsKzFOwm+8im85KZr6QA49csvCl9KgsfjSVLuXwgsPrFoEhkiqQ
0+VApr001A==
===========乙方使用甲方提供的公鑰對數(shù)據(jù)進(jìn)行解密==============
乙方解密后的數(shù)據(jù)：RSA密碼交換算法

===========反向進(jìn)行操作，乙方向甲方發(fā)送數(shù)據(jù)==============

原文:乙方向甲方發(fā)送數(shù)據(jù)RSA算法
===========乙方使用公鑰對數(shù)據(jù)進(jìn)行加密==============
加密后的數(shù)據(jù)：xM1MB3DlDKRwSozf9z8YQlftrWpKT8lkabi17cN/ZLOEkOO8jVLKVAjpjsMwtJMcpHTjntdkHKOm
s1V8xbh3og==
=============乙方將數(shù)據(jù)傳送給甲方======================
===========甲方使用私鑰對數(shù)據(jù)進(jìn)行解密==============
甲方解密后的數(shù)據(jù)：乙方向甲方發(fā)送數(shù)據(jù)RSA算法

四、總結(jié)
1.RSA與DH算法不同，只需要一套密鑰就能完成加密、解密的工作
2.通過代碼能看出來，公鑰長度明顯小于私鑰
3.遵循：公鑰加密-私鑰解密，私鑰加密-公鑰解密的原則
4.公鑰和私鑰肯定是完全不同

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容