devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

安全扫描：敏感数据加密传输和保存（国密）_敏感信息密文保存

作者：不正经 | 2024-06-11 11:06:09

赞

踩

敏感信息密文保存

记难受的老项目进行安全扫描的坑：敏感数据加密传输和保存

首先我们先创建这么一个JAVA工具类，用里面的main方法来得到SM2加密时需要用到的公钥和私钥，需要注意的是，执行一次就拿到这两个值来放到另一个类中或者数据库中来永久使用，需要调用时从里面调用即可，记得保密！

  1. package com.cn.zj.sm;
  2.  
  3. import java.math.BigInteger;
  4.  
  5. import org.bouncycastle.crypto.AsymmetricCipherKeyPair;
  6. import org.bouncycastle.crypto.params.ECPrivateKeyParameters;
  7. import org.bouncycastle.crypto.params.ECPublicKeyParameters;
  8. import org.bouncycastle.math.ec.ECPoint;
  9. import org.bouncycastle.util.encoders.Hex;
  10.  
  11. public class SMutil 
  12. {
  13. 	public static class SM2Key{
  14. 		public String publicKey;	//公钥
  15. 		public String privateKey;	//私钥
  16. 	}
  17. 	
  18. 	private static boolean isEmpty(String str)
  19. 	{
  20. 		if(str==null || str.trim().equals("")){
  21. 			return true;
  22. 		}
  23. 		return false;
  24. 	}
  25. 	/**
  26. 	 * 生成SM2秘钥
  27. 	 */
  28. 	@SuppressWarnings("deprecation")
  29. 	public static SM2Key generateSM2Key(){
  30.         SM2 sm2 = SM2.Instance();  
  31.         AsymmetricCipherKeyPair key = sm2.ecc_key_pair_generator.generateKeyPair();  
  32.         ECPrivateKeyParameters ecpriv = (ECPrivateKeyParameters) key.getPrivate();  
  33.         ECPublicKeyParameters ecpub = (ECPublicKeyParameters) key.getPublic();  
  34.         BigInteger privateKey = ecpriv.getD();
  35. 		ECPoint publicKey = ecpub.getQ();
  36. 		SM2Key sm2Key = new SM2Key();
  37.         sm2Key.publicKey = Util.byteToHex(publicKey.getEncoded());
  38.         sm2Key.privateKey = Util.byteToHex(privateKey.toByteArray());
  39.         return sm2Key;
  40. 	}
  41. 	
  42. 	/**
  43. 	 * SM2加密
  44. 	 * @param publickey 公钥
  45. 	 * @param src 待加密的明文
  46. 	 * @return
  47. 	 */
  48. 	public static String sm2encrypt(String publickey, String str){
  49. 		if(isEmpty(publickey) || isEmpty(str)){
  50. 			return null;
  51. 		}
  52. 		try {
  53. 			return SM2Utils.encrypt(Util.hexToByte(publickey), str.getBytes());
  54. 		} catch (Exception e) {
  55. 			e.printStackTrace();
  56. 		}
  57. 		return null;
  58. 	}
  59. 	
  60. 	/**
  61. 	 * SM2解密
  62. 	 * @param privatekey	私钥
  63. 	 * @param src	待解密的密文
  64. 	 * @return
  65. 	 */
  66. 	public static String sm2decrypt(String privatekey, String str){
  67. 		if(isEmpty(privatekey) || isEmpty(str)){
  68. 			return null;
  69. 		}
  70. 		try {
  71. 			return new String(SM2Utils.decrypt(Util.hexToByte(privatekey), Util.hexToByte(str)));
  72. 		} catch (Exception e) {
  73. 			e.printStackTrace();
  74. 		}
  75. 		return null;
  76. 	}
  77. 	
  78. 	/**
  79. 	 * SM3加密
  80. 	 * @param str	待加密的明文
  81. 	 * @return
  82. 	 */
  83. 	public static String sm3encrypt(String str){
  84. 		if(isEmpty(str)){
  85. 			return null;
  86. 		}
  87.         byte[] md = new byte[32];  
  88.         byte[] msg1 = str.getBytes();  
  89.         SM3Digest sm3 = new SM3Digest();  
  90.         sm3.update(msg1, 0, msg1.length);  
  91.         sm3.doFinal(md, 0);  
  92.         return new String(Hex.encode(md));  
  93.  
  94. 	}
  95. 	
  96. 	/**
  97. 	 * sm3密码校验
  98. 	 * @param str 待校验的明文
  99. 	 * @param sm3Str sm3加密后的密文 
  100. 	 * @return
  101. 	 */
  102. 	public static boolean sm3decrypt(String str, String sm3Str){
  103. 		if(isEmpty(str) || isEmpty(sm3Str)){
  104. 			return false;
  105. 		}
  106. 		return sm3Str.equalsIgnoreCase(sm3encrypt(str));		
  107. 	}
  108. 	
  109. 	/**
  110. 	 * SM4加密
  111. 	 * @param str	待加密的明文
  112. 	 * @return
  113. 	 */
  114. 	public static String sm4encrypt(String str){
  115. 		if(isEmpty(str)){
  116. 			return null;
  117. 		}
  118. 		String ret = new SM4Utils().encryptData_ECB(str);  
  119. 		return ret;
  120. 	}
  121. 	
  122. 	/**
  123. 	 * SM4加密
  124. 	 * @param str	待解密的密文
  125. 	 * @return
  126. 	 */
  127. 	public static String sm4decrypt(String str){
  128. 		if(isEmpty(str)){
  129. 			return null;
  130. 		}
  131. 		String ret = new SM4Utils().decryptData_ECB(str);  
  132. 		return ret;
  133. 	}
  134.  
  135. 	public static void main(String[] args){
  136. 		SM2Key sm2Key = generateSM2Key();
  137. 		System.out.println("私钥privateKey："+sm2Key.privateKey);
  138. 		System.out.println("公钥publicKey: "+sm2Key.publicKey);
  139. 	}
  140. }

 这是一个在上面的工具类基础上写出的另一个更加功能完善的工具类，可以直接调用，公钥和私钥都已经放在上面

  1.  
  2. package com.cn.zj.sm;
  3.  
  4. import org.apache.commons.lang3.ArrayUtils;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.stereotype.Service;
  8.  
  9. import com.xquant.xqa.component.util.utils.StringUtil;
  10.  
  11. /**
  12.  * @program: SMHandler
  13.  * @description: 国密加密解密
  14.  * @author: zhangjun
  15.  * @create: 2021/03/30
  16.  **/
  17. @Service
  18. public class SMHandler {
  19.     //SM2私钥
  20.     private static final String privatekey = "24F2401757F59665DED44ECEC08C7314E14F74E95B0720D0FA03E7992440CF1A";
  21.     //SM2公钥
  22.     private static final String pubkeyHex = "04509AEB08F6645C6AC92B965A5EAA6EE7761908A4AE1454DA537A855F1ADF0D611D45486362D856D7DFB45688EC969B96FD32E5E008FFE9E74E4A424A422DF3AC";
  23.  
  24.     private Logger logger = LoggerFactory.getLogger(SMHandler.class);
  25.     
  26.   
  27.  
  28.     /**
  29.      * @Title: passWordCryptBySM2_3
  30.      * @Description: 解析前端传入密文，转译成数据库存储密文，
  31.      *  前端加密逻辑要求：密文 = SM2 (明文)+SM3 (明文)
  32.      *  存入数据库密文要求：密文 = SM3 (明文)
  33.      * @param str 前端传入密文
  34.      * @return: java.lang.String 密码明文
  35.      * @throws
  36.      */
  37.     public String passWordCryptBySM2_3(String str){
  38.         //【1】分割传输过来的密文，得到 0.SM2加密过的明文  1.SM3算法加密后的密文
  39.         String[] strArr = StringUtil.split(str,"|");
  40.         if(ArrayUtils.isEmpty(strArr) || strArr.length != 2){
  41.             logger.info("完整性校验失败："+ str);
  42.             return null;
  43.         }
  44.         //【2】用SM2私钥解密传输过来的密文，获取明文
  45.         String privateKey = privatekey;
  46.         String passWord = SMutil.sm2decrypt(privateKey,strArr[0]);
  47.         String passWd = SMutil.sm2decrypt(privateKey,strArr[1]);
  48.         //【3】完整性校验——判断明文与加密后的密文是否相同
  49. //        if(!SMutil.sm3decrypt(passWord,strArr[1])){
  50.         if(!SMutil.sm3decrypt(passWord,passWd)){
  51.             logger.info("完整性校验失败："+ str);
  52.             return null;
  53.         }
  54. //        System.out.println("传入密文："+str);
  55. //        System.out.println("SM2密钥加密密文："+strArr[0]);
  56. //        System.out.println("SM3加密密文："+strArr[1]);
  57. //        System.out.println("密码："+passWord);
  58.         //【4】返回SM3加密后明文
  59. //        return strArr[1];
  60.       //【4】返回密码明文
  61.         return passWord;
  62.     }
  63.  
  64.     /**
  65.      * @Title: passWordCryptBySM2_3_4
  66.      * @Description: 解析前端传入密文，转译成数据库存储密文，
  67.      *  前端加密逻辑要求：密文 = SM2 (明文+SM3 (明文))
  68.      *  存入数据库密文要求：密文 = SM4 (明文)
  69.      * @param str 前端传入密文
  70.      * @return: java.lang.String 数据库存储密文
  71.      * @throws
  72.      */
  73.     public String passWordCryptBySM2_3_4(String str){
  74.          //【1】用SM2私钥解密传输过来的密文，得到SM3算法加密后的密文及明文
  75.     	 String privateKey = privatekey;
  76.          String mm = SMutil.sm2decrypt(privateKey,str);
  77.          //根据标识符切割【0】：SM3算法加密后的密文，【1】明文
  78.          String[] mmArr = StringUtil.split(mm,"|");
  79.          if(ArrayUtils.isEmpty(mmArr) || mmArr.length != 2){
  80.          logger.info("传入密文解密失败："+ str);
  81.             return null;
  82.          }
  83.          String mw_sm3 = mmArr[0];
  84.          String passWord = mmArr[1];
  85.          //【2】完整性校验——判断明文与加密后的密文是否相同
  86.          if(!SMutil.sm3decrypt(passWord,mw_sm3)){
  87.          logger.info("完整性校验失败："+ mw_sm3);
  88.          return null;
  89.          }
  90.          //【3】SM4加密明文，存入数据库
  91.          String mw_sm4 = SMutil.sm4encrypt(passWord);
  92.          //        System.out.println("传入密文："+str);
  93.          //        System.out.println("SM2密钥解密后密文："+mm);
  94.          //        System.out.println("SM3加密后密文："+mw_sm3);
  95.          //        System.out.println("SM4加密后密文："+mw_sm4);
  96.          //        System.out.println("密码："+passWord);
  97.          return mw_sm4;
  98.     }
  99.  
  100.  
  101.     /**
  102.      * @Title: accountDecryptBySM2
  103.      * @Description: 解析前端传入密文，转译成明文
  104.      *  前端加密逻辑要求：密文 = SM2 (明文)
  105.      * @param str
  106.      * @return: java.lang.String
  107.      * @throws
  108.      */
  109.     public String accountDecryptBySM2(String str){
  110.     	String privateKey = privatekey;
  111.         String mm = SMutil.sm2decrypt(privateKey,str);
  112.         if(mm == null){
  113.             logger.info("传入密文解密失败："+ str);
  114.             return null;
  115.         }
  116.         return mm;
  117.     }
  118.  
  119.  
  120.     /**
  121.      * @Title: passWordEnryptBySM3
  122.      * @Description: 加密密码存入数据库
  123.      *  加密要求：密文 = SM3(明文)
  124.      * @param str
  125.      * @return: java.lang.String
  126.      * @throws
  127.      */
  128.     public String passWordEnryptBySM3(String str){
  129.         String mm = SMutil.sm3encrypt(str);
  130.         if(mm == null){
  131.             logger.info("加密失败："+ str);
  132.             return null;
  133.         }
  134.         return mm;
  135.     }
  136.  
  137. 	/**
  138. 	 * @Title: passWordEnryptBySM2
  139. 	 * @Description: 加密密码存入数据库
  140.      *  加密要求：密文 = SM2(公钥,明文)
  141. 	 * @param str
  142. 	 * @return
  143. 	 * @throws
  144. 	 */
  145. 	public String passWordEnryptBySM2(String str) {
  146. 		String publicKey = ConfigSupport.getProperty("SM2.pubkeyHex", pubkeyHex);
  147. 		String mm = SMutil.sm2encrypt(publicKey, str);
  148.         if(mm == null){
  149.             logger.info("加密失败："+ str);
  150.             return null;
  151.         }
  152.         return mm;
  153. 	}
  154. 	
  155. 	/**
  156. 	 * @Title: passWordDecryptBySM2
  157. 	 * @Description: 返回解密后的明文
  158.      *  解密要求：明文 = SM2(私钥, 密文)
  159. 	 * @param str
  160. 	 * @return
  161. 	 * @throws
  162. 	 */
  163. 	public String passWordDecryptBySM2(String str) {
  164. 		String privateKey = privatekey;
  165.         String passWord = SMutil.sm2decrypt(privateKey, str);
  166.         if(passWord == null){
  167.             logger.info("解密失败："+ str);
  168.             return null;
  169.         }
  170.         return passWord;
  171. 	}
  172.  
  173. 	public static void main(String[] args) {
  174. 		String publicKey = ConfigSupport.getProperty("SM2.pubkeyHex", pubkeyHex);
  175. 		String mm = SMutil.sm2encrypt(publicKey, "111111");
  176. 		String str2 = "16ebf7bd3f730247ff2df62ddfe30201487c0c0ebbfb0b0326d2212735490287";
  177.         System.out.println(SMutil.sm2decrypt("00C1C7D8BF35BA59F4F0B28959EBBB1AAE6606140AAEAC4C379A8D57CCA508D16D", str2));
  178. 	}
  179. }

所以在java代码层面的加密和解密的代码只需要调用SMHandler这个工具类即可，代码如下：

  1. //加密---begin
  2. if(StringUtil.isNotEmpty(role.getRoleName())){
  3.     String name = sMHandler.passWordEnryptBySM2(role.getRoleName());
  4.     if(StringUtil.isEmpty(name)){
  5.        return new CommResponse(false,"操作失败");
  6.             }else{
  7.                 role.setRoleName(name);
  8.             }
  9. }
  10. //加密---end
  11. //解密---begin
  12. if(StringUtil.isNotEmpty(role.getRoleName())){
  13.     String name = sMHandler.passWordDecryptBySM2(role.getRoleName());
  14.     if(StringUtil.isEmpty(name)){
  15.        return new CommResponse(false,"操作失败");
  16.             }else{
  17.                 role.setRoleName(name);
  18.             }
  19. }
  20. //解密---end

接下来就是JS层面的加密解密，首先我们先找到sm.js这个文件，在里面写三个function方法，获取公钥私钥和加密解密，当然你也可以自己创建一个新的js文件，代码如下：

  1. function getSm2pubkeyHex() {
  2.         var pubkey = '04509AEB08F6645C6AC92B965A5EAA6EE7761908A4AE1454DA537A855F1ADF0D611D45486362D856D7DFB45688EC969B96FD32E5E008FFE9E74E4A424A422DF3AC'
  3.         return  pubkey;
  4. }
  5. function getSm2prikeyHex() {
  6.         var prikey = '24F2401757F59665DED44ECEC08C7314E14F74E95B0720D0FA03E7992440CF1A'
  7. 		return  prikey ;
  8. }
  9. function SMutil()
  10. {
  11.     this.sm2encrypt = function(data, publickey){
  12.         var msgData = CryptoJS.enc.Utf8.parse(data);
  13.  
  14.         var pubkeyHex = publickey;
  15.         if (pubkeyHex.length > 64 * 2) {
  16.             pubkeyHex = pubkeyHex.substr(pubkeyHex.length - 64 * 2);
  17.         }
  18.  
  19.         var xHex = pubkeyHex.substr(0, 64);
  20.         var yHex = pubkeyHex.substr(64);
  21.  
  22.  
  23.         var cipher = new SM2Cipher("0");
  24.         var userKey = cipher.CreatePoint(xHex, yHex);
  25.  
  26.         msgData = cipher.GetWords(msgData.toString());
  27.  
  28.         var encryptData = cipher.Encrypt(userKey, msgData);
  29.         return '04' + encryptData;
  30.     }
  31.  
  32.     this.sm3encrypt = function(str){
  33.         var sm3 = new window.SM3Digest();
  34.         str = new SM2Cipher().GetWords(CryptoJS.enc.Utf8.parse(str).toString());
  35.         sm3.BlockUpdate(str,0,str.length);
  36.         var md = new Array(32);
  37.         sm3.DoFinal(md, 0);
  38.         var words = [ ];
  39.         var j = 0;
  40.         for (var i = 0; i < md.length * 2; i += 2) {
  41.             words[i >>> 3] |= parseInt(md[j]) << (24 - (i % 8) * 4);
  42.             j++;
  43.         }
  44.         var encryptData = new CryptoJS.lib.WordArray.init(words, md.length).toString();
  45.         return encryptData;
  46.     }
  47.  
  48.     this.sm2Decrypt = function(privateKey,encrypted) {
  49.         encrypted = encrypted.substr(2);
  50.         var privKey = new BigInteger(privateKey, 16);
  51.         var cipher = new SM2Cipher("0");
  52.         var decryptData = cipher.Decrypt(privKey, encrypted);
  53.         return decryptData;
  54.     }

那我们在js中加密解密方法就只需要调用sm文件里面这个方法即可，代码如下：

  1. //加密---begin
  2. 		var smutil = new SMutil();
  3. 		var pubkey = smutil.getSm2pubkeyHex();
  4. 		smutil.sm2encrypt(str, pubkey);
  5. //加密---end
  6. //解密---begin
  7. 		var smutil = new SMutil();
  8. 		var prikey = smutil.getSm2prikeyHex();
  9. 		smutil.sm2Decrypt(prikey, str);
  10. //解密---end

因为公钥和私钥在前端和后端的一致性，所以前端加密的数据可以在后端解密，后端加密的数据也可以在前端解密。这就是最简单快捷的国密SM2加密解密，当然我的方法中还有sm3和sm2混合加密解密，sm4加密解密，我就不一一介绍了

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/702907
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号