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; 
 
 
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"; 
 
   
  public static Map init() { 
    Map 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; 
  } 
 
   
  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; 
  } 
 
   
  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; 
  } 
 
   
  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; 
  } 
 
   
  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; 
  } 
 
   
  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; 
  } 
 
   
  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; 
  } 
 
   
  public static String getPublicKey(Map map) { 
    String str = ""; 
    try { 
      Key key = (Key) map.get(KEY_RSA_PUBLICKEY); 
      str = encryptbase64(key.getEncoded()); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return str; 
  } 
 
   
  public static String getPrivateKey(Map map) { 
    String str = ""; 
    try { 
      Key key = (Key) map.get(KEY_RSA_PRIVATEKEY); 
      str = encryptbase64(key.getEncoded()); 
    } catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return str; 
  } 
 
   
  public static byte[] decryptbase64(String key) throws Exception { 
    return (new base64Decoder()).decodeBuffer(key); 
  } 
 
   
  public static String encryptbase64(byte[] key) throws Exception { 
    return (new base64Encoder()).encodeBuffer(key); 
  } 
 
   
  public static void main(String[] args) { 
    String privateKey = ""; 
    String publicKey = ""; 
    // 生成公钥私钥 
    Map map = init(); 
    publicKey = getPublicKey(map); 
    privateKey = getPrivateKey(map); 
    System.out.println("公钥: nr" + publicKey); 
    System.out.println("私钥： nr" + privateKey); 
    System.out.println("公钥加密--------私钥解密"); 
    String word = "你好，世界！"; 
    byte[] encWord = encryptByPublicKey(word.getBytes(), publicKey); 
    String decWord = new String(decryptByPrivateKey(encWord, privateKey)); 
    System.out.println("加密前: " + word + "nr" + "解密后: " + 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 + "nr" + "解密后: " + 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); 
  } 
}

加解密结果

结束语

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

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

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