快捷導(dǎo)航

Java加解密技術(shù)系列之RSA詳解

更新時(shí)間：2016年10月31日 16:47:35 作者：crazyYong

出于安全考慮，網(wǎng)絡(luò)的傳輸中經(jīng)常對(duì)傳輸數(shù)據(jù)做加密和編碼處理，本篇文章主要介紹Java加解密技術(shù)系列之RSA詳解，非常具有實(shí)用價(jià)值，需要的朋友可以參考下。

距離上一次寫(xiě)博客感覺(jué)已經(jīng)很長(zhǎng)時(shí)間了，先吐槽一下，這個(gè)月以來(lái)，公司一直在加班，又是發(fā)版、上線，又是新項(xiàng)目太緊，具體的就不多說(shuō)了。今天來(lái)說(shuō)說(shuō)非對(duì)稱加密真的是太重要了，我們的日常生活中，都離不開(kāi)非對(duì)稱加密。

概念

在說(shuō) RSA 之前，首先聊聊什么是非對(duì)稱加密。在講對(duì)稱加密的時(shí)候，就曾經(jīng)說(shuō)過(guò)，對(duì)稱加密算法在加密和解密時(shí)使用的是同一個(gè)秘鑰，加解密雙方必須使用同一個(gè)密鑰才能進(jìn)行正常的溝通。而非對(duì)稱加密則不然，非對(duì)稱加密算法需要兩個(gè)密鑰來(lái)進(jìn)行加密和解密，分別是公鑰和私鑰。

需要注意的一點(diǎn)，這個(gè)公鑰和私鑰必須是一對(duì)的，如果用公鑰對(duì)數(shù)據(jù)進(jìn)行加密，那么只有使用對(duì)應(yīng)的私鑰才能解密，反之亦然。由于加密和解密使用的是兩個(gè)不同的密鑰，因此，這種算法叫做非對(duì)稱加密算法。

工作過(guò)程

如下圖，甲乙之間使用非對(duì)稱加密的方式傳輸數(shù)據(jù)。

在非對(duì)稱加密中使用的主要算法有：RSA、Elgamal、背包算法、Rabin、D-H、ECC（橢圓曲線加密算法）等。今天主要是介紹 RSA ，至于其他的算法，后續(xù)會(huì)選擇幾個(gè)進(jìn)行介紹。

RSA

其實(shí)，在早在 1978 年的時(shí)候，RSA就已經(jīng)出現(xiàn)了，它是第一個(gè)既能用于數(shù)據(jù)加密也能用于數(shù)字簽名的算法。它易于理解和操作，也很流行。其原理就如上面的工作過(guò)程所述。

RSA 算法基于一個(gè)十分簡(jiǎn)單的數(shù)論事實(shí)：將兩個(gè)大素?cái)?shù)相乘十分容易，但是想要對(duì)其乘積進(jìn)行因式分解卻極其困難，因此可以將乘積公開(kāi)作為加密密鑰。

代碼實(shí)現(xiàn)

下面來(lái)看一下具體的代碼實(shí)現(xiàn)。

import com.google.common.collect.Maps; 
import sun.misc.BASE64Decoder; 
import sun.misc.BASE64Encoder; 
 
import javax.crypto.Cipher; 
import java.security.*; 
import java.security.interfaces.RSAPrivateKey; 
import java.security.interfaces.RSAPublicKey; 
import java.security.spec.PKCS8EncodedKeySpec; 
import java.security.spec.X509EncodedKeySpec; 
import java.util.Map; 
 
/** 
 * Created by xiang.li on 2015/3/3. 
 * RSA 加解密工具類 
 */ 
public class RSA { 
  /** 
   * 定義加密方式 
   */ 
  private final static String KEY_RSA = "RSA"; 
  /** 
   * 定義簽名算法 
   */ 
  private final static String KEY_RSA_SIGNATURE = "MD5withRSA"; 
  /** 
   * 定義公鑰算法 
   */ 
  private final static String KEY_RSA_PUBLICKEY = "RSAPublicKey"; 
  /** 
   * 定義私鑰算法 
   */ 
  private final static String KEY_RSA_PRIVATEKEY = "RSAPrivateKey"; 
 
  /** 
   * 初始化密鑰 
   * @return 
   */ 
  public static Map<String, Object> init() { 
    Map<String, Object> map = null; 
    try { 
      KeyPairGenerator generator = KeyPairGenerator.getInstance(KEY_RSA); 
      generator.initialize(1024); 
      KeyPair keyPair = generator.generateKeyPair(); 
      // 公鑰 
      RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); 
      // 私鑰 
      RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); 
      // 將密鑰封裝為map 
      map = Maps.newHashMap(); 
      map.put(KEY_RSA_PUBLICKEY, publicKey); 
      map.put(KEY_RSA_PRIVATEKEY, privateKey); 
    } catch (NoSuchAlgorithmException e) { 
      e.printStackTrace(); 
    } 
    return map; 
  } 
 
  /** 
   * 用私鑰對(duì)信息生成數(shù)字簽名 
   * @param data 加密數(shù)據(jù) 
   * @param privateKey 私鑰 
   * @return 
   */ 
  public static String sign(byte[] data, String privateKey) { 
    String str = ""; 
    try { 
      // 解密由base64編碼的私鑰 
      byte[] bytes = decryptBase64(privateKey); 
      // 構(gòu)造PKCS8EncodedKeySpec對(duì)象 
      PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes); 
      // 指定的加密算法 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      // 取私鑰對(duì)象 
      PrivateKey key = factory.generatePrivate(pkcs); 
      // 用私鑰對(duì)信息生成數(shù)字簽名 
      Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE); 
      signature.initSign(key); 
      signature.update(data); 
      str = encryptBase64(signature.sign()); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return str; 
  } 
 
  /** 
   * 校驗(yàn)數(shù)字簽名 
   * @param data 加密數(shù)據(jù) 
   * @param publicKey 公鑰 
   * @param sign 數(shù)字簽名 
   * @return 校驗(yàn)成功返回true，失敗返回false 
   */ 
  public static boolean verify(byte[] data, String publicKey, String sign) { 
    boolean flag = false; 
    try { 
      // 解密由base64編碼的公鑰 
      byte[] bytes = decryptBase64(publicKey); 
      // 構(gòu)造X509EncodedKeySpec對(duì)象 
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes); 
      // 指定的加密算法 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      // 取公鑰對(duì)象 
      PublicKey key = factory.generatePublic(keySpec); 
      // 用公鑰驗(yàn)證數(shù)字簽名 
      Signature signature = Signature.getInstance(KEY_RSA_SIGNATURE); 
      signature.initVerify(key); 
      signature.update(data); 
      flag = signature.verify(decryptBase64(sign)); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return flag; 
  } 
 
  /** 
   * 私鑰解密 
   * @param data 加密數(shù)據(jù) 
   * @param key 私鑰 
   * @return 
   */ 
  public static byte[] decryptByPrivateKey(byte[] data, String key) { 
    byte[] result = null; 
    try { 
      // 對(duì)私鑰解密 
      byte[] bytes = decryptBase64(key); 
      // 取得私鑰 
      PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes); 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      PrivateKey privateKey = factory.generatePrivate(keySpec); 
      // 對(duì)數(shù)據(jù)解密 
      Cipher cipher = Cipher.getInstance(factory.getAlgorithm()); 
      cipher.init(Cipher.DECRYPT_MODE, privateKey); 
      result = cipher.doFinal(data); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return result; 
  } 
 
  /** 
   * 私鑰解密 
   * @param data 加密數(shù)據(jù) 
   * @param key 公鑰 
   * @return 
   */ 
  public static byte[] decryptByPublicKey(byte[] data, String key) { 
    byte[] result = null; 
    try { 
      // 對(duì)公鑰解密 
      byte[] bytes = decryptBase64(key); 
      // 取得公鑰 
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes); 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      PublicKey publicKey = factory.generatePublic(keySpec); 
      // 對(duì)數(shù)據(jù)解密 
      Cipher cipher = Cipher.getInstance(factory.getAlgorithm()); 
      cipher.init(Cipher.DECRYPT_MODE, publicKey); 
      result = cipher.doFinal(data); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return result; 
  } 
 
  /** 
   * 公鑰加密 
   * @param data 待加密數(shù)據(jù) 
   * @param key 公鑰 
   * @return 
   */ 
  public static byte[] encryptByPublicKey(byte[] data, String key) { 
    byte[] result = null; 
    try { 
      byte[] bytes = decryptBase64(key); 
      // 取得公鑰 
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes); 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      PublicKey publicKey = factory.generatePublic(keySpec); 
      // 對(duì)數(shù)據(jù)加密 
      Cipher cipher = Cipher.getInstance(factory.getAlgorithm()); 
      cipher.init(Cipher.ENCRYPT_MODE, publicKey); 
      result = cipher.doFinal(data); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return result; 
  } 
 
  /** 
   * 私鑰加密 
   * @param data 待加密數(shù)據(jù) 
   * @param key 私鑰 
   * @return 
   */ 
  public static byte[] encryptByPrivateKey(byte[] data, String key) { 
    byte[] result = null; 
    try { 
      byte[] bytes = decryptBase64(key); 
      // 取得私鑰 
      PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes); 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      PrivateKey privateKey = factory.generatePrivate(keySpec); 
      // 對(duì)數(shù)據(jù)加密 
      Cipher cipher = Cipher.getInstance(factory.getAlgorithm()); 
      cipher.init(Cipher.ENCRYPT_MODE, privateKey); 
      result = cipher.doFinal(data); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return result; 
  } 
 
  /** 
   * 獲取公鑰 
   * @param map 
   * @return 
   */ 
  public static String getPublicKey(Map<String, Object> map) { 
    String str = ""; 
    try { 
      Key key = (Key) map.get(KEY_RSA_PUBLICKEY); 
      str = encryptBase64(key.getEncoded()); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return str; 
  } 
 
  /** 
   * 獲取私鑰 
   * @param map 
   * @return 
   */ 
  public static String getPrivateKey(Map<String, Object> map) { 
    String str = ""; 
    try { 
      Key key = (Key) map.get(KEY_RSA_PRIVATEKEY); 
      str = encryptBase64(key.getEncoded()); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return str; 
  } 
 
  /** 
   * BASE64 解密 
   * @param key 需要解密的字符串 
   * @return 字節(jié)數(shù)組 
   * @throws Exception 
   */ 
  public static byte[] decryptBase64(String key) throws Exception { 
    return (new BASE64Decoder()).decodeBuffer(key); 
  } 
 
  /** 
   * BASE64 加密 
   * @param key 需要加密的字節(jié)數(shù)組 
   * @return 字符串 
   * @throws Exception 
   */ 
  public static String encryptBase64(byte[] key) throws Exception { 
    return (new BASE64Encoder()).encodeBuffer(key); 
  } 
 
  /** 
   * 測(cè)試方法 
   * @param args 
   */ 
  public static void main(String[] args) { 
    String privateKey = ""; 
    String publicKey = ""; 
    // 生成公鑰私鑰 
    Map<String, Object> map = init(); 
    publicKey = getPublicKey(map); 
    privateKey = getPrivateKey(map); 
    System.out.println("公鑰: \n\r" + publicKey); 
    System.out.println("私鑰： \n\r" + privateKey); 
    System.out.println("公鑰加密--------私鑰解密"); 
    String word = "你好，世界！"; 
    byte[] encWord = encryptByPublicKey(word.getBytes(), publicKey); 
    String decWord = new String(decryptByPrivateKey(encWord, privateKey)); 
    System.out.println("加密前: " + word + "\n\r" + "解密后: " + decWord); 
    System.out.println("私鑰加密--------公鑰解密"); 
    String english = "Hello, World!"; 
    byte[] encEnglish = encryptByPrivateKey(english.getBytes(), privateKey); 
    String decEnglish = new String(decryptByPublicKey(encEnglish, publicKey)); 
    System.out.println("加密前: " + english + "\n\r" + "解密后: " + decEnglish); 
    System.out.println("私鑰簽名——公鑰驗(yàn)證簽名"); 
    // 產(chǎn)生簽名 
    String sign = sign(encEnglish, privateKey); 
    System.out.println("簽名:\r" + sign); 
    // 驗(yàn)證簽名 
    boolean status = verify(encEnglish, publicKey, sign); 
    System.out.println("狀態(tài):\r" + status); 
  } 
}

加解密結(jié)果

結(jié)束語(yǔ)

其實(shí)，看似很復(fù)雜的過(guò)程，用一句話就可以描述：使用公鑰加密、私鑰解密，完成了乙方到甲方的一次數(shù)據(jù)傳遞，通過(guò)私鑰加密、公鑰解密，同時(shí)通過(guò)私鑰簽名、公鑰驗(yàn)證簽名，完成了一次甲方到乙方的數(shù)據(jù)傳遞與驗(yàn)證，兩次數(shù)據(jù)傳遞完成一整套的數(shù)據(jù)交互。

非對(duì)稱加密算法的出現(xiàn)，就是為了解決只有一把密鑰的加解密，只要這一把密鑰丟失或者被公開(kāi)，那么加密數(shù)據(jù)就很容易被攻擊。同時(shí)，也正是由于非對(duì)稱加密算法的出現(xiàn)，才有了后面的數(shù)字簽名、數(shù)字證書(shū)等等。

好了，今天就到這吧，下一篇繼續(xù)非對(duì)稱加密，至于哪一種，到時(shí)候就知道了，這里先保密

您可能感興趣的文章: