[关闭]
@HUST-SuWB 2018-04-22T09:01:28.000000Z 字数 6246 阅读 561

对称加密&非对称加密

Finlabtech

定义

AES对称加密算法：客户端服务端使用相同的密钥进行加解密操作，因此密钥的安全性就很重要。
RSA非对称加密算法：客户端使用公钥加密，服务端使用对应的私钥进行解密，由于私钥只有服务端有，因此即便公钥泄露，第三方依然无法解密传输的信息。当然，反过来如果服务端使用私钥加密，那么客户端也可以使用公钥进行解密，此时客户端可以肯定信息是通过服务端发出来的，因此只有服务端握有私钥，这种思路可以用来进行身份校验。

实战

理论上，只要密钥在网络上传输就有泄露的风险，因此直接使用AES时有一定风险的，但如果全部用RSA又不太现实，首先RSA能加密的数据量比较小，其次RSA很慢，对于大数据量来说计算切割成很多段使用RSA加密也会过于耗时，相反，AES可以直接在硬件层面加速，效率就会高很多。
所以，在实际使用中一般的推荐做法是主体信息使用AES加密，但是AES的密钥通过RSA加密传输，这就保证了AES密钥的安全性。
由于项目需要与第三方进行接口交互，请求是直接走的http，所以对于接口的入参需要一定的加密处理，所以在经过了一番调研后确定了AES+RSA的加密方案，这里可以推荐一个RSA的实现示例，是我在网上找到的，具体链接见代码的说明。

  1. import org.apache.commons.codec.binary.Base64;
  2. import org.apache.commons.io.IOUtils;
  4. import javax.crypto.Cipher;
  5. import java.io.ByteArrayOutputStream;
  6. import java.security.*;
  7. import java.security.interfaces.RSAPrivateKey;
  8. import java.security.interfaces.RSAPublicKey;
  9. import java.security.spec.InvalidKeySpecException;
  10. import java.security.spec.PKCS8EncodedKeySpec;
  11. import java.security.spec.X509EncodedKeySpec;
  12. import java.util.HashMap;
  13. import java.util.Map;
  15. /**
  16.  * @author: tianxie
  17.  * @Description: https://blog.csdn.net/cz0217/article/details/78426733
  18.  * @Date: 2018/3/29下午3:44
  19.  */
  20. public class RSAUtils2 {
  22.     public static final String CHARSET = "UTF-8";
  23.     public static final String RSA_ALGORITHM = "RSA";
  26.     public static Map<String, String> createKeys(int keySize) {
  27.         //为RSA算法创建一个KeyPairGenerator对象
  28.         KeyPairGenerator kpg;
  29.         try{
  30.             kpg = KeyPairGenerator.getInstance(RSA_ALGORITHM);
  31.         }catch(NoSuchAlgorithmException e){
  32.             throw new IllegalArgumentException("No such algorithm-->[" + RSA_ALGORITHM + "]");
  33.         }
  35.         //初始化KeyPairGenerator对象,密钥长度
  36.         kpg.initialize(keySize);
  37.         //生成密匙对
  38.         KeyPair keyPair = kpg.generateKeyPair();
  39.         //得到公钥
  40.         Key publicKey = keyPair.getPublic();
  41.         String publicKeyStr = Base64.encodeBase64URLSafeString(publicKey.getEncoded());
  42.         //得到私钥
  43.         Key privateKey = keyPair.getPrivate();
  44.         String privateKeyStr = Base64.encodeBase64URLSafeString(privateKey.getEncoded());
  45.         Map<String, String> keyPairMap = new HashMap<String, String>();
  46.         keyPairMap.put("publicKey", publicKeyStr);
  47.         keyPairMap.put("privateKey", privateKeyStr);
  49.         return keyPairMap;
  50.     }
  52.     /**
  53.      * 得到公钥
  54.      * @param publicKey 密钥字符串（经过base64编码）
  55.      * @throws Exception
  56.      */
  57.     public static RSAPublicKey getPublicKey(String publicKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
  58.         //通过X509编码的Key指令获得公钥对象
  59.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
  60.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(Base64.decodeBase64(publicKey));
  61.         RSAPublicKey key = (RSAPublicKey) keyFactory.generatePublic(x509KeySpec);
  62.         return key;
  63.     }
  65.     /**
  66.      * 得到私钥
  67.      * @param privateKey 密钥字符串（经过base64编码）
  68.      * @throws Exception
  69.      */
  70.     public static RSAPrivateKey getPrivateKey(String privateKey) throws NoSuchAlgorithmException, InvalidKeySpecException {
  71.         //通过PKCS#8编码的Key指令获得私钥对象
  72.         KeyFactory keyFactory = KeyFactory.getInstance(RSA_ALGORITHM);
  73.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(Base64.decodeBase64(privateKey));
  74.         RSAPrivateKey key = (RSAPrivateKey) keyFactory.generatePrivate(pkcs8KeySpec);
  75.         return key;
  76.     }
  78.     /**
  79.      * 公钥加密
  80.      * @param data
  81.      * @param publicKey
  82.      * @return
  83.      */
  84.     public static String publicEncrypt(String data, RSAPublicKey publicKey) {
  85.         try{
  86.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  87.             cipher.init(Cipher.ENCRYPT_MODE, publicKey);
  88.             return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), publicKey.getModulus().bitLength()));
  89.         }catch(Exception e){
  90.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
  91.         }
  92.     }
  94.     /**
  95.      * 私钥解密
  96.      * @param data
  97.      * @param privateKey
  98.      * @return
  99.      */
  101.     public static String privateDecrypt(String data, RSAPrivateKey privateKey) {
  102.         try{
  103.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  104.             cipher.init(Cipher.DECRYPT_MODE, privateKey);
  105.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), privateKey.getModulus().bitLength()), CHARSET);
  106.         }catch(Exception e){
  107.             throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
  108.         }
  109.     }
  111.     /**
  112.      * 私钥加密
  113.      * @param data
  114.      * @param privateKey
  115.      * @return
  116.      */
  118.     public static String privateEncrypt(String data, RSAPrivateKey privateKey) {
  119.         try{
  120.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  121.             cipher.init(Cipher.ENCRYPT_MODE, privateKey);
  122.             return Base64.encodeBase64URLSafeString(rsaSplitCodec(cipher, Cipher.ENCRYPT_MODE, data.getBytes(CHARSET), privateKey.getModulus().bitLength()));
  123.         }catch(Exception e){
  124.             throw new RuntimeException("加密字符串[" + data + "]时遇到异常", e);
  125.         }
  126.     }
  128.     /**
  129.      * 公钥解密
  130.      * @param data
  131.      * @param publicKey
  132.      * @return
  133.      */
  135.     public static String publicDecrypt(String data, RSAPublicKey publicKey) {
  136.         try{
  137.             Cipher cipher = Cipher.getInstance(RSA_ALGORITHM);
  138.             cipher.init(Cipher.DECRYPT_MODE, publicKey);
  139.             return new String(rsaSplitCodec(cipher, Cipher.DECRYPT_MODE, Base64.decodeBase64(data), publicKey.getModulus().bitLength()), CHARSET);
  140.         }catch(Exception e){
  141.             throw new RuntimeException("解密字符串[" + data + "]时遇到异常", e);
  142.         }
  143.     }
  145.     private static byte[] rsaSplitCodec(Cipher cipher, int opmode, byte[] datas, int keySize){
  146.         int maxBlock = 0;
  147.         if(opmode == Cipher.DECRYPT_MODE){
  148.             maxBlock = keySize / 8;
  149.         }else{
  150.             maxBlock = keySize / 8 - 11;
  151.         }
  152.         ByteArrayOutputStream out = new ByteArrayOutputStream();
  153.         int offSet = 0;
  154.         byte[] buff;
  155.         int i = 0;
  156.         try{
  157.             while(datas.length > offSet){
  158.                 if(datas.length-offSet > maxBlock){
  159.                     buff = cipher.doFinal(datas, offSet, maxBlock);
  160.                 }else{
  161.                     buff = cipher.doFinal(datas, offSet, datas.length-offSet);
  162.                 }
  163.                 out.write(buff, 0, buff.length);
  164.                 i++;
  165.                 offSet = i * maxBlock;
  166.             }
  167.         }catch(Exception e){
  168.             throw new RuntimeException("加解密阀值为["+maxBlock+"]的数据时发生异常", e);
  169.         }
  170.         byte[] resultDatas = out.toByteArray();
  171.         IOUtils.closeQuietly(out);
  172.         return resultDatas;
  173.     }
  174. }

调用示例如下：

  1. @Test
  2.     public void test2() {
  3.         Map<String, String> keyMap = RSAUtils2.createKeys(1024);
  4.         String  publicKey = keyMap.get("publicKey");
  5.         String  privateKey = keyMap.get("privateKey");
  6.         System.out.println("公钥: \n\r" + publicKey);
  7.         System.out.println("私钥： \n\r" + privateKey);
  9.         System.out.println("公钥加密——私钥解密");
  10.         String str = "站在大明门前守卫的禁卫军，事先没有接到\n" +
  11.                 "有关的命令，但看到大批盛装的官员来临，也就\n" +
  12.                 "以为确系举行大典，因而未加询问。进大明门即\n" +
  13.                 "为皇城。文武百官看到端门午门之前气氛平静，\n" +
  14.                 "城楼上下也无朝会的迹象，既无几案，站队点名\n" +
  15.                 "的御史和御前侍卫“大汉将军”也不见踪影，不免\n" +
  16.                 "心中揣测，互相询问：所谓午朝是否讹传？";
  17.         System.out.println("\r明文：\r\n" + str);
  18.         System.out.println("\r明文大小：\r\n" + str.getBytes().length);
  19.         try {
  20.             String encodedData = RSAUtils2.publicEncrypt(str, RSAUtils2.getPublicKey(publicKey));
  21.             System.out.println("密文：\r\n" + encodedData);
  22.             String decodedData = RSAUtils2.privateDecrypt(encodedData, RSAUtils2.getPrivateKey(privateKey));
  23.             System.out.println("解密后文字: \r\n" + decodedData);
  24.         } catch (Exception e) {}
  25.     }

扩展

在调用相关加密算法的时候，除了AES和RSA之外你会看到很多文章都会提到以MD5为代表的摘要算法。理论上MD5是不可逆的，所以就不存在破解的说法，MD5也广泛的应用在密码加密领域。很多系统的用户密码都是使用的MD5加密，但由于彩虹表的存在，常用密码的MD5密文其实都可以通过查表查出来，所以单纯的使用MD5并不是一个保险的做法，因此现在普遍都是使用的MD5(msg+salt)，甚至设定两个salt进行两层MD5。
同时，还有一个名词也很常见，叫base64，需要明确的是base64并不是加密算法，所以它是无法加密信息的，它其实是一种编码，存在的意义是为了方便信息传输，具体介绍可以参考知乎的一篇文章：如何用通俗易懂的语言解释base64

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注