Java加解密技术系列之RSA详解

距离上一次写博客感觉已经很长时间了，先吐槽一下，这个月以来，公司一直在加班，又是发版、上线，又是新项目太紧，具体的就不多说了。今天来说说非对称加密真的是太重要了，我们的日常生活中，都离不开非对称加密。

概念

在说 rsa 之前，首先聊聊什么是非对称加密。在讲对称加密的时候，就曾经说过，对称加密算法在加密和解密时使用的是同一个秘钥，加解密双方必须使用同一个密钥才能进行正常的沟通。而非对称加密则不然，非对称加密算法需要两个密钥来进行加密和解密，分别是公钥和私钥。

需要注意的一点，这个公钥和私钥必须是一对的，如果用公钥对数据进行加密，那么只有使用对应的私钥才能解密，反之亦然。由于加密和解密使用的是两个不同的密钥，因此，这种算法叫做非对称加密算法。

工作过程

如下图，甲乙之间使用非对称加密的方式传输数据。

在非对称加密中使用的主要算法有：rsa、elgamal、背包算法、rabin、d-h、ecc（椭圆曲线加密算法）等。今天主要是介绍 rsa ，至于其他的算法，后续会选择几个进行介绍。

rsa

其实，在早在 1978 年的时候，rsa就已经出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。其原理就如上面的工作过程所述。

rsa 算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。

代码实现

下面来看一下具体的代码实现。

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; 
  } 
 
  /** 
   * 用私钥对信息生成数字签名 
   * @param data 加密数据 
   * @param privatekey 私钥 
   * @return 
   */ 
  public static string sign(byte[] data, string privatekey) { 
    string str = ""; 
    try { 
      // 解密由base64编码的私钥 
      byte[] bytes = decryptbase64(privatekey); 
      // 构造pkcs8encodedkeyspec对象 
      pkcs8encodedkeyspec pkcs = new pkcs8encodedkeyspec(bytes); 
      // 指定的加密算法 
      keyfactory factory = keyfactory.getinstance(key_rsa); 
      // 取私钥对象 
      privatekey key = factory.generateprivate(pkcs); 
      // 用私钥对信息生成数字签名 
      signature signature = signature.getinstance(key_rsa_signature); 
      signature.initsign(key); 
      signature.update(data); 
      str = encryptbase64(signature.sign()); 
    } catch (exception e) { 
      e.printstacktrace(); 
    } 
    return str; 
  } 
 
  /** 
   * 校验数字签名 
   * @param data 加密数据 
   * @param publickey 公钥 
   * @param sign 数字签名 
   * @return 校验成功返回true，失败返回false 
   */ 
  public static boolean verify(byte[] data, string publickey, string sign) { 
    boolean flag = false; 
    try { 
      // 解密由base64编码的公钥 
      byte[] bytes = decryptbase64(publickey); 
      // 构造x509encodedkeyspec对象 
      x509encodedkeyspec keyspec = new x509encodedkeyspec(bytes); 
      // 指定的加密算法 
      keyfactory factory = keyfactory.getinstance(key_rsa); 
      // 取公钥对象 
      publickey key = factory.generatepublic(keyspec); 
      // 用公钥验证数字签名 
      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 加密数据 
   * @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); 
      // 对数据解密 
      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 加密数据 
   * @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); 
      // 对数据解密 
      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 待加密数据 
   * @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); 
      // 对数据加密 
      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 待加密数据 
   * @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); 
      // 对数据加密 
      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 字节数组 
   * @throws exception 
   */ 
  public static byte[] decryptbase64(string key) throws exception { 
    return (new base64decoder()).decodebuffer(key); 
  } 
 
  /** 
   * base64 加密 
   * @param key 需要加密的字节数组 
   * @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("私钥签名——公钥验证签名"); 
    // 产生签名 
    string sign = sign(encenglish, privatekey); 
    system.out.println("签名:\r" + sign); 
    // 验证签名 
    boolean status = verify(encenglish, publickey, sign); 
    system.out.println("状态:\r" + status); 
  } 
}

加解密结果

结束语

其实，看似很复杂的过程，用一句话就可以描述：使用公钥加密、私钥解密，完成了乙方到甲方的一次数据传递，通过私钥加密、公钥解密，同时通过私钥签名、公钥验证签名，完成了一次甲方到乙方的数据传递与验证，两次数据传递完成一整套的数据交互。

非对称加密算法的出现，就是为了解决只有一把密钥的加解密，只要这一把密钥丢失或者被公开，那么加密数据就很容易被攻击。同时，也正是由于非对称加密算法的出现，才有了后面的数字签名、数字证书等等。

好了，今天就到这吧，下一篇继续非对称加密，至于哪一种，到时候就知道了，这里先保密