精华内容
下载资源
问答
  • sm4加密sm3加密
    千次阅读
    2021-06-30 09:27:22

    sm4加密有32位key值加密和16位key值加密

    加粗样式sm4中32位加密:可以参考:

    安装

    npm install @haici/gmsm4 --save
    

    使用方法

    一、通过 baseKey 获取加密秘钥 key约定 baseKey 为字符串(长度不限)
    
    import { genKey } from '@haici/gmsm4';
    
    const key = genKey('123456789');
    

    二、使用 ECB 模式加密key 要求为 32 位十六进制字符串

    import sm4,{ genKey } from '@haici/gmsm4';
    
    let text = 'This is 一段明文内容!';
    let key = genKey('123456789');
    
    let enData = sm4.encryptWithECB(key,text); //加密
    let deData = sm4.encryptWithECB(key,enData); //解密
    

    三、使用 CBC 模式加密iv 和 key 要求为 32 位十六进制字符串

    import sm4, { genKey } from '@haici/gmsm4';
    
    let text = 'This is 一段明文内容!';
    let iv = '00000000000000000000000000000000';
    let key = genKey('123456789');
    
    let enData = sm4.encryptWithCBC(key,iv,text); //加密
    let deData = sm4.decryptWithCBC(key,iv,enData); //解密
    

    sm4中16位加密:可以参考:

    安装依赖:

    npm install gm-crypt
    

    使用

      // 引用sm4包进行加密
      const SM4 = require("gm-crypt").sm4;
      let sm4Config = {
        //配置sm4参数
        key: "HENG1AN2WEN3YIN4",//这里这个key值是跟后端要的
        mode: "ecb", // 加密的方式有两种,ecb和cbc两种,也是看后端如何定义的,不过要是cbc的话下面还要加一个iv的参数,ecb不用
         cipherType: "base64" 
          };
          let sm4 = new SM4(sm4Config);//这里new一个函数,将上面的sm4Config作为参数传递进去。然后就可以开心的加密了
          let Account = sm4.encrypt(this.Account); //账号加密
    

    sm3加密:可以参考

    引入

    npm install sm3
    const sm3 = require('sm3');
    const hash = sm3('值');
    
    更多相关内容
  • sm3加密

    2022-03-17 10:28:44
    后端实现sm3加密: <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</artifactId> <version>1.54</version> </dependency> ...

    后端实现sm3加密:

    <dependency>
          <groupId>org.bouncycastle</groupId>
          <artifactId>bcprov-jdk15on</artifactId>
          <version>1.54</version>
        </dependency>
    

    工具类

    public class Sm3Utils {
        private static final String ENCODING = "UTF-8";
    
        static {
            Security.addProvider(new BouncyCastleProvider());
        }
    
        /**
         * sm3算法加密
         *
         * @param paramStr 待加密字符串
         * @return 返回加密后,固定长度=32的16进制字符串
         * @explain
         */
        public static String encrypt(String paramStr) {
            // 将返回的hash值转换成16进制字符串
            String resultHexString = "";
            try {
                // 将字符串转换成byte数组
                byte[] srcData = paramStr.getBytes(ENCODING);
                // 调用hash()
                byte[] resultHash = hash(srcData);
                // 将返回的hash值转换成16进制字符串
                resultHexString = ByteUtils.toHexString(resultHash);
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return resultHexString;
        }
    
        /**
         * 返回长度=32的byte数组
         *
         * @param srcData
         * @return
         * @explain 生成对应的hash值
         */
        public static byte[] hash(byte[] srcData) {
            SM3Digest digest = new SM3Digest();
            digest.update(srcData, 0, srcData.length);
            byte[] hash = new byte[digest.getDigestSize()];
            digest.doFinal(hash, 0);
            return hash;
        }
    
        /**
         * 判断源数据与加密数据是否一致
         *
         * @param srcStr       原字符串
         * @param sm3HexString 16进制字符串
         * @return 校验结果
         * @explain 通过验证原数组和生成的hash数组是否为同一数组,验证2者是否为同一数据
         */
        public static boolean verify(String srcStr, String sm3HexString) {
            boolean flag = false;
            try {
                byte[] srcData = srcStr.getBytes(ENCODING);
                byte[] sm3Hash = ByteUtils.fromHexString(sm3HexString);
                byte[] newHash = hash(srcData);
                if (Arrays.equals(newHash, sm3Hash)) {
                    flag = true;
                }
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
            return flag;
        }
    }
    

    自测

     public static void main(String[] args) {
            String text="admin123";
            String encr= Sm3Utils.encrypt(text);
            System.out.println(encr);
            boolean verify = Sm3Utils.verify(text,encr);
            System.out.println(verify);
        }
    

    前端实现:
    1.首先安装

    npm install --save sm-crypto
    

    2.实现方式:

    // 加密方法
    methods:{
        doSM3() {
    	    const sm3 = require('sm-crypto').sm3
    	    this.loginForm.password = sm3(this.loginForm.passwords)
        },
        //点击登录
        handleLogin(){
        this.$refs.loginForm.validate((valid) => {
            if (valid) {
            doSM3()//调用加密方法
              this.loginForm.password = doSM3(this.loginForm.passwords)
              //调用接口部分,此处省略
            } else {
              return false
            }
          })
        
        }
    
    展开全文
  • sm3加密工具类.zip

    2019-12-19 17:29:38
    sm3加密java源码,带jar包,绝对可用 public class Sm3Utils { private final static byte[] hex = "0123456789ABCDEF".getBytes(); /** * @desc SM3加密算法实现方法 * @param data * @return */ ...
  • C#国密SM3加密算法,可以和java接口通用。
  • Java实现SM3加密和验证

    千次阅读 2022-04-07 14:42:05
    在商用密码体系中,SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等,其算法公开。据国家密码管理局表示,其安全性及效率与SHA-256相当。 需要引入如下坐标依赖: <dependency> <groupId&...

    在商用密码体系中,SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等,其算法公开。据国家密码管理局表示,其安全性及效率与SHA-256相当。

    需要引入如下坐标依赖:

    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
        <version>1.68</version>
    </dependency>
    

    自定义密钥加密及校验

    加密

    	private static final String ENCODING = "UTF-8";
        /**
         * 加密
         *
         * @param src 明文
         * @param key 密钥
         * @return
         * @throws Exception
         */
        public static String encrypt(String src, String key) throws Exception {
            return ByteUtils.toHexString(getEncryptByKey(src, key));
        }
    
    
        /**
         * SM3加密方式之: 根据自定义密钥进行加密,返回加密后长度为32位的16进制字符串
         *
         * @param src 源数据
         * @param key 密钥
         * @return
         * @throws Exception
         */
        public static byte[] getEncryptByKey(String src, String key) throws Exception {
            byte[] srcByte = src.getBytes(ENCODING);
            byte[] keyByte = key.getBytes(ENCODING);
            KeyParameter keyParameter = new KeyParameter(keyByte);
            SM3Digest sm3 = new SM3Digest();
            HMac hMac = new HMac(sm3);
            hMac.init(keyParameter);
            hMac.update(srcByte, 0, srcByte.length);
            byte[] result = new byte[hMac.getMacSize()];
            hMac.doFinal(result, 0);
            return result;
        }
    

    校验

        /**
         * 利用源数据+密钥校验与密文是否一致
         *
         * @param src       源数据
         * @param key       密钥
         * @param sm3HexStr 密文
         * @return
         * @throws Exception
         */
        public static boolean verify(String src, String key, String sm3HexStr) throws Exception {
            byte[] sm3HashCode = ByteUtils.fromHexString(sm3HexStr);
            byte[] newHashCode = getEncryptByKey(src, key);
            return Arrays.equals(newHashCode, sm3HashCode);
        }
    

    无密钥的加密及校验

    加密

        /**
         * SM3加密方式之:不提供密钥的方式 SM3加密,返回加密后长度为64位的16进制字符串
         *
         * @param src 明文
         * @return
         */
        public static String encrypt(String src) {
            return ByteUtils.toHexString(getEncryptBySrcByte(src.getBytes()));
        }
    
        /**
         * 返回长度为32位的加密后的byte数组
         *
         * @param srcByte
         * @return
         */
        public static byte[] getEncryptBySrcByte(byte[] srcByte) {
            SM3Digest sm3 = new SM3Digest();
            sm3.update(srcByte, 0, srcByte.length);
            byte[] encryptByte = new byte[sm3.getDigestSize()];
            sm3.doFinal(encryptByte, 0);
            return encryptByte;
        }
    

    校验

        /**
         * 校验源数据与加密数据是否一致
         *
         * @param src       源数据
         * @param sm3HexStr 16进制的加密数据
         * @return
         * @throws Exception
         */
        public static boolean verify(String src, String sm3HexStr) throws Exception {
            byte[] sm3HashCode = ByteUtils.fromHexString(sm3HexStr);
            byte[] newHashCode = getEncryptBySrcByte(src.getBytes(ENCODING));
            return Arrays.equals(newHashCode, sm3HashCode);
        }
    

    测试验证

    public static void main(String[] args) throws Exception {
            String srcStr = "今天天气很晴朗";
            String key = "zjqzjq";
            // ******************************自定义密钥加密及校验*****************************************
            String hexStrByKey = SM3Utils.encrypt(srcStr, key);
            System.out.println("带密钥加密后的密文:" + hexStrByKey);
    
            System.out.println("明文(带密钥)与密文校验结果:" + SM3Utils.verify(srcStr, key, hexStrByKey));
    
            // ******************************无密钥的加密及校验******************************************
            String hexStrNoKey = SM3Utils.encrypt(srcStr);
            System.out.println("不带密钥加密后的密文:" + hexStrNoKey);
    
            System.out.println("明文(不带密钥)与密文校验结果:" + SM3Utils.verify(srcStr, hexStrNoKey));
    
        }
    

    结果输出如下:
    在这里插入图片描述

    展开全文
  • springboot 和 js (vue) 实现SM3加密 防篡改 一、以下是对引入SM3进行说明 1.首先导入jar <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15on</...

    springboot 和 js (vue) 实现SM3加密 防篡改

    一、以下是对引入SM3进行说明

    1.首先导入jar

    <dependency>
        <groupId>org.bouncycastle</groupId>
        <artifactId>bcprov-jdk15on</artifactId>
        <version>1.68</version>
    </dependency>
    

    2.写一个java的SM3工具类

    import java.io.UnsupportedEncodingException;
    import java.security.Security;
    import java.util.Arrays;
    
    import org.bouncycastle.crypto.digests.SM3Digest;
    import org.bouncycastle.crypto.macs.HMac;
    import org.bouncycastle.crypto.params.KeyParameter;
    import org.bouncycastle.jce.provider.BouncyCastleProvider;
    import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
    
    public class SM3 {
    
    	private static final String ENCODING = "UTF-8";
    	
    	static {
    		Security.addProvider(new BouncyCastleProvider());
    	}
    	/**
    	 * SM3加密
    	 * @param paramStr	待加密字符串
    	 * @return	返回加密后,固定长度=32的16进制字符串
    	 */
    	public static String encrypt(String paramStr) {
    		//将返回的hash值转换为16进制字符串
    		String resultHexString = "";
    		try {
    			//将字符串转换成byte数组
    			byte[]  srcData = paramStr.getBytes(ENCODING);
    			byte[] resultHash = hash(srcData);
    			//将返回的hash值转换成16进制字符串
    			resultHexString = ByteUtils.toHexString(resultHash);
    		} catch (UnsupportedEncodingException e) {
    			e.printStackTrace();
    		}
    		return resultHexString;
    	}
    	/**
    	 * 返回长度为32的byte数组
    	 * 生成对应的hash值
    	 * @param srcData
    	 * @return
    	 */
    	public static byte[] hash(byte[] srcData){
    		SM3Digest digest = new SM3Digest();
    		digest.update(srcData,0,srcData.length);
    		byte[] hash = new byte[digest.getDigestSize()];
    		digest.doFinal(hash, 0);
    		return hash;
    	}
    	/**
    	 * 通过指定密钥进行加密
    	 * @param key 密钥
    	 * @param srcData 被加密的byte数组
    	 * @return
    	 */
    	public static byte[] hmac(byte[] key,byte[] srcData){
    		KeyParameter keyParameter = new KeyParameter(key);
    		SM3Digest digest = new SM3Digest();
    		HMac mac = new HMac(digest);
    		mac.init(keyParameter);
    		mac.update(srcData,0,srcData.length);
    		byte[] result = new byte[mac.getMacSize()];
    		mac.doFinal(result, 0);
    		return result;
    	}
    	/**
    	 * 判断数据源与加密数据是否一致,通过验证原数组和生成是hash数组是否为同一数组,验证二者是否为同一数据
    	 * @param srcStr
    	 * @param sm3HexString
    	 * @return
    	 */
    	public static boolean vertify(String srcStr,String sm3HexString){
    		boolean flag = false;
    		try {
    			byte[] srcData = srcStr.getBytes(ENCODING);
    			byte[] sm3Hash = ByteUtils.fromHexString(sm3HexString);
    			byte[] newHash = hash(srcData);
    			if(Arrays.equals(newHash, sm3Hash));
    				flag = true;
    		} catch (UnsupportedEncodingException e) {
    			e.printStackTrace();
    		}
    		return flag;
    	}
    	
    	public static void main(String[] args){
    		//测试
    		String str = "412345195604153562";
    		String hex = SM3.encrypt(str);
    		System.out.println(hex);
    		
    		String str1 = "1234";
    		String hex1 = SM3.encrypt(str1);
    		System.out.println(hex1);
    		
    		String str2 = "qwer12345";
    		String hex2 = SM3.encrypt(str2);
    		System.out.println(hex2);
    		
    		String strpre = "412727";
    		String hexpre = SM3.encrypt(strpre);
    		System.out.println(hexpre);
    		//验证加密后的16进制字符串与加密前的字符串是否相同
    		boolean flag = SM3.vertify(str, hex);
    		System.out.println(flag);
    	}
    }
    
    

    3.前端需要四个js

    cipher-core.js
    core.js
    jsbn.js
    jsbn2.js
    sm3.js

    4.1 编写JavaScript 的页面

    <!DOCTYPE html>
    <html>
    <head>
    <meta http-equiv="X-UA-Compatible" content="chrome=1" />
    <meta name="description" content="SM3摘要加密测试" />
    <title>SM3摘要加密测试</title>
    <!-- for pkcs5pkey -->
    <script src="js/core.js"></script>
    <script src="js/cipher-core.js"></script>
    <script language="JavaScript" type="text/javascript" src="js/jsbn.js"></script>
    <script language="JavaScript" type="text/javascript" src="js/jsbn2.js"></script>
    <script language="JavaScript" type="text/javascript" src="js/sm3.js"></script>
    <script language="JavaScript" type="text/javascript">
    	function doSM3() {
    		/*var f1 = document.form1;
    		var msg = f1.sm3input.value;
    		var msgData = CryptoJS.enc.Utf8.parse(msg);
    
    		var md;
    		var sm3keycur = new SM3Digest();
    		msgData = sm3keycur.GetWords(msgData.toString());
    		console.log(msgData);
    		sm3keycur.BlockUpdate(msgData, 0, msgData.length);
    		console.log(msgData);
    		var c3 = new Array(32);
    		sm3keycur.DoFinal(c3, 0);
    		f1.sm3key.value = sm3keycur.GetHex(c3).toString();
    		
    		*/
    		var f1 = document.form1;
    		var msg = f1.sm3input.value;
    		var msgData = CryptoJS.enc.Utf8.parse(msg);
    		var sm3keycur = new SM3Digest();
    		msgData = sm3keycur.GetWords(msgData.toString());
    		sm3keycur.BlockUpdate(msgData, 0, msgData.length);
    		var c3 = new Array(32);
    		sm3keycur.DoFinal(c3, 0);
    		//解决sm3相同参数前后台加密不一致的问题
    		for(var i = 0,len = c3.length; i < len; i++){
    			if(256 == c3[i]){
    				c3[i]=0;
    			}
    		}
    		var hashHex = sm3keycur.GetHex(c3).toString();
    		f1.sm3key.value = hashHex;
    		return hashHex;
    	}
    </script>
    </head>
    <body>
    	<script type="text/javascript">
    		if (/msie/.test(navigator.userAgent.toLowerCase())) {
    			document
    					.write("<p><em>若IE浏览器下提示停止运行此脚本,请选择<b>否(N)</b>继续运行。</em></p>");
    		}
    	</script>
    	<!-- now editing -->
    	<form name="form1">
    		<p>
    			加密字符串: <input type="text" name="sm3input" value="" size="100" /><br />
    			<input type="button" value="加密" onClick="doSM3();" /><br /> 
    			加密结果: <input type="text" name="sm3key" value="" size="100" /><br />
    		</p>
    	</form>
    </body>
    </html>
    

    4.2 如果使用的是vue 需要自己改一下

    import './core'
    import './cipher-core'
    import './jsbn'
    import './jsbn2'
    import './sm3'
    import { SM3Digest } from './sm3'
    import { CryptoJS } from './core'
    export function doSM3(plaintext) {
      let d = CryptoJS.enc.Utf8.parse(plaintext);
      let msg = d;
      let md;
      const sm3keycur = new SM3Digest();
      msg = sm3keycur.GetWords(msg.toString());
      msg.forEach(element => {
        console.log('asd', element)
      });
      console.log('msg', msg);
      sm3keycur.BlockUpdate(msg, 0, msg.length);
      console.log('msg1', msg);
      const c3 = new Array(32);
      sm3keycur.DoFinal(c3, 0);
      md = sm3keycur.GetHex(c3).toString()
      console.log('加密后', md);
    }
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    编写防篡改的功能

    需要一个拦截器

    @Override
        public boolean preHandle(HttpServletRequest request,
                                 HttpServletResponse response, Object handler) throws Exception {
    
            //这里需要判断下是主站还是子站
            if (isMaster == 1) {
                long beginTimeThreadLocal = System.currentTimeMillis();
                //拦截器处理代码
                log.info("进入防 重放攻击 和 防篡改 拦截器!");
    
                //首先判断是不是可以不验证的 地址
                Set<String> uriSet = new HashSet<>(ignoredUrlsProperties.getSignUrls());
                boolean isMatch = false;
                for (String uri : uriSet) {
                    if (uri.contains("/**")) {
                        uri = uri.split("/\\*\\*")[0];
                    }
                    isMatch = request.getRequestURI().contains(uri);
                    if (isMatch) {
                        break;
                    }
                }
                if (isMatch) {
                    return true;
                } else {
                    // 获取时间戳
                    String timestamp = request.getHeader("timestamp");
                    // 获取随机字符串
                    String nonceStr = request.getHeader("nonceStr");
                    // 获取签名
                    String signature = request.getHeader("signature");
                    //如果请求头里没有,去参数获取
                    if (StrUtil.isEmpty(timestamp)) {
                        timestamp = request.getParameter("timestamp");
                    }
                    if (StrUtil.isEmpty(nonceStr)) {
                        nonceStr = request.getParameter("nonceStr");
                    }
                    if (StrUtil.isEmpty(signature)) {
                        signature = request.getParameter("signature");
                    }
    
                    if (StrUtil.isEmpty(timestamp)) {
                        throw new Exception("invalid  timestamp:验证失败,无效的时间戳");
                    }
    
                    long receiveTime = Long.parseLong(timestamp);
                    // 判断时间是否大于 1 分钟 (防止重放攻击)
                    long NONCE_STR_TIMEOUT_SECONDS = 1L;
                    if ((System.currentTimeMillis() - receiveTime) / (1000 * 60) >= NONCE_STR_TIMEOUT_SECONDS) {
                        //addLog(beginTimeThreadLocal,request,"验证失败,数据被重放","REPLAY");
                        throw new Exception("invalid  timestamp:验证失败,时间戳过期");
                    }
    
                    // 判断该用户的nonceStr参数是否已经在redis中(防止短时间内的重放攻击)
                    Boolean haveNonceStr = redisTemplate.hasKey(SecurityConstant.NONCE + nonceStr);
                    if (haveNonceStr) {
                        addLog(beginTimeThreadLocal, request, "验证失败,会话被重放", "REPLAY");
                        throw new Exception("invalid nonceStr:验证失败,会话被重放");
                    }
    
                    // 对请求头参数进行签名
                    if (StrUtil.isEmpty(signature) || !Objects.equals(signature, this.signature(timestamp, nonceStr, request))) {
                        addLog(beginTimeThreadLocal, request, "验证失败,数据被篡改", "TAMPERING");
                        throw new Exception("invalid signature:验证失败,数据被篡改");
                    }
    
                    // 将本次用户请求的nonceStr参数存到redis中设置xx秒后自动删除
                    redisTemplate.opsForValue().set(SecurityConstant.NONCE + nonceStr, nonceStr, NONCE_STR_TIMEOUT_SECONDS, TimeUnit.MINUTES);
                    log.info("验证通过");
                    return true;
                }
            }
            return true;
        }
    
    /**
         * 这里是后端生成的 sm3加密编码
         * (通过 参数+时间戳+随机数   生成的编码)
         * @param timestamp
         * @param nonceStr
         * @param request
         * @return
         * @throws UnsupportedEncodingException
         */
        private String signature(String timestamp, String nonceStr, HttpServletRequest request) {
            Map<String, Object> params = new HashMap<>(16);
            Enumeration<String> enumeration = request.getParameterNames();
            while (enumeration.hasMoreElements()){
                String name = enumeration.nextElement();
                String value = request.getParameter(name);
                params.put(name, value);
            }
            //获取参数,因为有的接口是没有参数的,所以要单独处理下
            String param=this.sortQueryParamString(params);
            String qs ;
            if(StringUtils.isNotEmpty(param)){
                qs=String.format("%s&timestamp=%s&nonceStr=%s", param, timestamp, nonceStr);
            }else{
                qs=String.format("timestamp=%s&nonceStr=%s", timestamp, nonceStr);
            }
            log.info("qs:{}", qs);
            //从前端获取的nonce和后端的 进行对比,如果不一致则表示数据被篡改
            String newNonce= SM3Util.hashCodeStr(qs);
            log.info("newNonce:{}", newNonce);
            return newNonce;
        }
    
        /**
         * 按照字母顺序进行升序排序
         *
         * @param params 请求参数
         * @return 排序后结果
         */
        private String sortQueryParamString(Map<String, Object> params) {
            List<String> listKeys = Lists.newArrayList(params.keySet());
            Collections.sort(listKeys);
            StrBuilder content = StrBuilder.create();
            for (String param : listKeys) {
                //如果是全部作为参数传过来,也会接收到加密的签,所以需要过滤掉(下载和导出功能会出现)
                if(!param.equals("signature")){
                    content.append(param).append("=").append(params.get(param)).append("&");
                }
            }
            if (content.length() > 0) {
                return content.subString(0, content.length() - 1);
            }
            return content.toString();
        }
    

    然后需要配置这个过滤器生效

    
    @Configuration
    public class InterceptorConfiguration implements WebMvcConfigurer {
    	@Autowired
        private IgnoredUrlsProperties ignoredUrlsProperties;
    
        @Autowired
        private LimitRaterInterceptor limitRaterInterceptor;
        @Autowired
        private CorsInterceptor corsInterceptor;
        @Autowired
        private SignAuthInterceptor replayInterceptor;
     	
     	@Override
        public void addInterceptors(InterceptorRegistry registry) {
    
            // 注册拦截器
            InterceptorRegistration ir = registry.addInterceptor(limitRaterInterceptor);
            // 配置拦截的路径
            ir.addPathPatterns("/**");
            // 配置不拦截的路径 避免加载css也拦截
            ir.excludePathPatterns(ignoredUrlsProperties.getUrls());
    
            registry.addInterceptor(getSysLogAspect())
                    .addPathPatterns("/**")
                    .excludePathPatterns("/css/**", "/webjars/**", "/images/**", "/js/**", "/login.html");
    
            registry.addInterceptor(corsInterceptor).addPathPatterns("/**");
            registry.addInterceptor(replayInterceptor).addPathPatterns("/**");
        }
    

    在yml文件中配置过滤的类

    # 忽略url
    ignored:
    # 无需验证重放和篡改认证的请求
      signUrls:
        - /druid/**
        - /static/**
        - /store/**
        - /resources/**
        - /doc.html
        - /swagger-ui.html
        - /swagger-resources/**
        - /swagger/**
        - /xboot/test/**
        - /webjars/**
    

    前端也需要对应的加密

    这里就不写前端的了,前端传过来需要有header 头的时间戳、随机数、和校验码
    那么这个校验码就是 = 所有的参数(key=value形式逐个拼接)+时间戳 +随机数

    校验

    前端给过来的和后端获取到的参数在进行加密,然后对比两个码是否一致即可。

    展开全文
  • java sm3加密算法

    千次阅读 2021-02-12 18:44:05
    1.准备工作所需jar包:bcprov-jdk15on-1.59.jarcommons-lang3-3.1.jar20200901对应的maven依赖org.bouncycastlebcprov-jdk15on1.66import org.bouncycastle.crypto.digests.SM3Digest;import org.bouncycastle....
  • js 和 java 的sm3 加密

    2019-02-21 17:49:00
    相关标准为“GM/T 0004-2012 《SM3密码杂凑算法》”。 在商用密码体系中,SM3主要用于数字签名及验证、消息认证码生成及验证、随机数生成等,其算法公开。据国家密码管理局表示,其安全性及效率与SHA-256相当
  • 最近项目要使用SM3加密,搜了网上很多资料,整理了一下,里面有java后台前端js实现SM3加密,验证SM3加密工具,以及SM3文档
  • c#写的国密sm3 demo 里面有一些其他的测试代码没有清理,请忽略
  • C#国密SM4/SM3加密

    2021-07-24 09:45:02
    所有.NET版本均适用。
  • 前端使用sm2、sm3加密解密 案例

    千次阅读 2020-11-23 13:50:06
    const cipherMode = 1 // 1 - C1C3C2,0 - C1C2C3,默认为1 加密: let encryptData = sm2.doEncrypt(msgString, publicKey, cipherMode) // 加密结果 conso.log("加密结果:",encryptData); 解密: let decrypt...
  • Java sm3加密算法的实现

    千次阅读 2021-03-18 12:28:33
    1.准备工作所需jar包:bcprov-jdk15on-1.59.jarcommons-lang3-3.1.jar对应的maven依赖org.bouncycastlebcprov-jdk15on1.66import org.bouncycastle.crypto.digests.SM3Digest;import org.bouncycastle.crypto.macs....
  • 主要介绍了Python 实现国产SM3加密算法的示例代码,帮助大家更好的理解和学习密码学,感兴趣的朋友可以了解下
  • from math importceil################################################################################国产SM3加密算法###############################################################################IV= ...
  • var encryptValue = sm3.Encrypt("待加密的字符串,支持中文"); //encryptValue 为加密后的字符串 java使用: //1、无key方式 String returnValue = SM3.encrypt("待加密的字符串,支持中文"); //returnValue ...
  • js版本的sm3加密

    2019-01-19 11:39:16
    js版本的sm3加密,里面有调用的示例代码,我自己测试过,好使
  • js版sm2加解密、签名、验签 sm3加密
  • 最近在工作中需要对hive中某些数据进行SM3加密,在网上找了很久,遇到一些坑,在这里分享。 例:取姓名第一个汉字后接身份证号进行SM3加密。 1.SM3工具类 pom.xml: <!--sm3,sm4加密算法--> <...
  • 国密SM2_SM3加密解密,加签验签操作C#源码,网络上很难找的资源,实现了密SM2_SM3加密解密,加签验签操作,.NET版
  • PHP关于国密SM3加密的处理

    千次阅读 2021-03-23 21:10:14
    这几天对接中国联通物联网IoT Gateway门户API系统,其中用到国密SM3,其提供的token需使用国密SM3对源串进行加密处理,网上搜索也没找到什么函数之类的,只有c和java语言写的,看来要使用这个SM3加密就必须进行扩展...
  • 极简教学Java的SM3加密算法[免费附上github源码] 讲文之前,简单介绍一下SM3算法 SM3算法:SM3杂凑算法是我国自主设计的密码杂凑算法,适用于商用密码应用中的数字签名和验证消息认证码的生成与验证以及随机数的...
  • 输入消息体: 输入key: 加密结果: 解密结果: **base64.js** (function (global, factory) { typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof ...
  • sm3加密(js、java).zip

    2021-01-24 22:45:16
    可以根据相关项目修改使用(有引用jar包)
  • python 实现SM3加密算法

    千次阅读 2020-05-18 17:25:52
    from math import ceil IV="7380166f 4914b2b... y = Hash_sm3(str) print(y) # klen = 19 # print(KDF("57E7B63623FAE5F08CDA468E872A20AFA03DED41BF1403770E040DC83AF31A67991F2B01EBF9EFD8881F0A0493000603", klen))
  • SM3加密 js版和java版

    2018-11-16 09:59:03
    SM3国产加密JS版和JAVA版,直接可以使用。js版有使用方法。
  • 1.先安装sm3的依赖和引入 npm install --save sm-crypto import 'jsbn' import { sm3 } from 'sm-crypto' 2.排序方法 export function objKeySort(obj) { // 排序的函数 var newkey = Object.keys(obj)....
  • SM3是中国采用的一种密码散列函数标准,由国家密码管理局于2010年12月17日发布。相关标准为“GM/T 0004-2012 《SM3密码杂凑算法》”。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,177
精华内容 6,470
关键字:

sm3加密