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

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

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

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

概念

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

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

工作過程

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

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

RSA

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

RSA 算法基于一個十分簡單的數(shù)論事實：將兩個大素數(shù)相乘十分容易，但是想要對其乘積進行因式分解卻極其困難，因此可以將乘積公開作為加密密鑰。

代碼實現(xiàn)

下面來看一下具體的代碼實現(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; 
  } 
 
  /** 
   * 用私鑰對信息生成數(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對象 
      PKCS8EncodedKeySpec pkcs = new PKCS8EncodedKeySpec(bytes); 
      // 指定的加密算法 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      // 取私鑰對象 
      PrivateKey key = factory.generatePrivate(pkcs); 
      // 用私鑰對信息生成數(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; 
  } 
 
  /** 
   * 校驗數(shù)字簽名 
   * @param data 加密數(shù)據(jù) 
   * @param publicKey 公鑰 
   * @param sign 數(shù)字簽名 
   * @return 校驗成功返回true，失敗返回false 
   */ 
  public static boolean verify(byte[] data, String publicKey, String sign) { 
    boolean flag = false; 
    try { 
      // 解密由base64編碼的公鑰 
      byte[] bytes = decryptBase64(publicKey); 
      // 構(gòu)造X509EncodedKeySpec對象 
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes); 
      // 指定的加密算法 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      // 取公鑰對象 
      PublicKey key = factory.generatePublic(keySpec); 
      // 用公鑰驗證數(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 { 
      // 對私鑰解密 
      byte[] bytes = decryptBase64(key); 
      // 取得私鑰 
      PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(bytes); 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      PrivateKey privateKey = factory.generatePrivate(keySpec); 
      // 對數(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 { 
      // 對公鑰解密 
      byte[] bytes = decryptBase64(key); 
      // 取得公鑰 
      X509EncodedKeySpec keySpec = new X509EncodedKeySpec(bytes); 
      KeyFactory factory = KeyFactory.getInstance(KEY_RSA); 
      PublicKey publicKey = factory.generatePublic(keySpec); 
      // 對數(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); 
      // 對數(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); 
      // 對數(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); 
  } 
 
  /** 
   * 測試方法 
   * @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("私鑰簽名——公鑰驗證簽名"); 
    // 產(chǎn)生簽名 
    String sign = sign(encEnglish, privateKey); 
    System.out.println("簽名:\r" + sign); 
    // 驗證簽名 
    boolean status = verify(encEnglish, publicKey, sign); 
    System.out.println("狀態(tài):\r" + status); 
  } 
}

加解密結(jié)果

結(jié)束語

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

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

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

您可能感興趣的文章: