精华内容
下载资源
问答
  • js中文加密js中文加密js中文加密js中文加密js中文加密js中文加密
  • 中文加密

    千次阅读 2012-07-08 07:02:35
    在信息领域,数据的安全性越来越重要,因为信息泄露而导致的商业损失也越来越引起了人们的关注,从而,信息加密解密的手段也层出不穷。然而,最有效的手段莫过于一门自然语言。即便对于SHA、MD5、DES、RSA等所有加密...

    在信息领域,数据的安全性越来越重要,因为信息泄露而导致的商业损失也越来越引起了人们的关注,从而,信息加密解密的手段也层出不穷。

    然而,最有效的手段莫过于一门自然语言。即便对于SHA、MD5、DES、RSA等所有加密算法全部精通,而且解密正确,对于不懂得这门自然语言的人来说,解密出来之后必定会遇到更大的屏障,而且这种屏障不是短期之内能够逾越的。

    而对于各种不同的自然语言,应该可以有相对应的特殊的加密解密算法,因为每种自然语言的结构都是不一样的,有字母组成的语言,也有像中文这样复杂的由笔画组成的,而现在的加密算法都是基于字母型语言所做出的,如果有针对中文结构而产生的加密算法,那么就不仅仅是考验解密人员计算机能力的问题了,对于不了解中文的人,想要正确的解密,会更加困难。

    其实就是要把加密解密的手段组合起来,把计算机方面的技术和自然语言方面的技术结合起来。比方说,把组成汉子的各种部件拆分开来,然后加密之后,重新组合,然后再用计算机的算法重新加密,这种经过二次加密而生成的文字串,解密起来就需要两方面的知识。

    加密想要真正让人无法破解,那么最可能的一种方式就是采用不通用的加密方式,所有的规律都是基于特定情况的,那样才不容易被别人所猜测到。

    记得镜花缘书中有璇玑图,那个应该也是古老的一种加密手段了,但它是对于文章加密,而不是对于文字加密,还有藏头诗,一直是传递秘密信息的有效手段,如果可能的话,在中文信息安全中也可以采用类似的方式,不仅仅对文字加密,还要对整篇文章的结构进行加密,会产生更加有趣的效果。

    古老的文化中总是会有很多智慧体现,我们作为现代人,不应该只看着当前的技术,而忽略了古老的智慧,很多情况下,那些古老的智慧,要比现在的智慧更高。比方说易经的奥秘,现在仍然在很多地方起着非常重要的作用,只不过研究这门学问的人越来越少了。

    现代文化和古代文化也应该结合起来,回到加密的话题,如果把古文字和古汉语的内容也加到其中,那么加密的级别又会再上一个新的台阶,想要解密出正确的信息,所需要的知识就更多了。

    貌似加密解密的手段是没有止境的,只要不产生太大的性能负担,所有加密手段都会是可行的。

    展开全文
  • VB的MD5中文加密

    2018-11-29 09:55:13
    VB的MD5中文加密,是一个不错的加密方式,但是仅适用于自己内容加密判断使用,因为和JAVA等对汉字的编码格式不统一,所以汉字加密直接不能使用VB的MD5,但是内部包含了JS的Md5,如果必须使用和其它语言一致的MD5使,...
  • RSA中文加密乱码问题

    2020-09-14 14:56:44
    记录一次,代码中使用rsa加密,本次以及测试环境中文加密正常,不会出现乱码,但是生产环境会出现中文乱码。 排查一段时间,定位到问题; 针对中文获取字节流时,指定utf-8编码--代码如下 int inputLen = data....

    记录一次,代码中使用rsa加密,本地以及测试环境中文加密正常,不会出现乱码,但是生产环境会出现中文乱码。

    排查一段时间,定位到问题;

    针对中文获取字节流时,指定utf-8编码--代码如下

    int inputLen = data.getBytes(UTF_8).length;以此类推,所以获取字节流位置,均添加指定utf-8编码

    /**
             * RSA加密
             *
             * @param data 待加密数据
             * @param publicKey 公钥
             * @return
             */
            public static String encrypt(String data, PublicKey publicKey) throws Exception {
                Cipher cipher = Cipher.getInstance(ENCRYPT_CONTENT);
                cipher.init(Cipher.ENCRYPT_MODE, publicKey);
                int inputLen = data.getBytes(UTF_8).length;
    
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offset = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段加密
                while (inputLen - offset > 0) {
                    if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
                        cache = cipher.doFinal(data.getBytes(UTF_8), offset, MAX_ENCRYPT_BLOCK);
                    } else {
                        cache = cipher.doFinal(data.getBytes(UTF_8), offset, inputLen - offset);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offset = i * MAX_ENCRYPT_BLOCK;
                }
                byte[] encryptedData = out.toByteArray();
    
                out.close();
                // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
                // 加密后的字符串
                String result = new String(Base64.encodeBase64(encryptedData), UTF_8);
                return result;
            }

    解密:

     /**
             * RSA解密
             *
             * @param data 待解密数据
             * @param privateKey 私钥
             * @return
             */
            public static String decrypt(String data, PrivateKey privateKey) throws Exception {
                Cipher cipher = Cipher.getInstance(ENCRYPT_CONTENT);
                cipher.init(Cipher.DECRYPT_MODE, privateKey);
                byte[] dataBytes = Base64.decodeBase64(data.getBytes(UTF_8));
                int inputLen = dataBytes.length;
                ByteArrayOutputStream out = new ByteArrayOutputStream();
                int offset = 0;
                byte[] cache;
                int i = 0;
                // 对数据分段解密
                while (inputLen - offset > 0) {
                    if (inputLen - offset > MAX_DECRYPT_BLOCK) {
                        cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
                    } else {
                        cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
                    }
                    out.write(cache, 0, cache.length);
                    i++;
                    offset = i * MAX_DECRYPT_BLOCK;
                }
                byte[] decryptedData = out.toByteArray();
                out.close();
                // 解密后的内容
                String result = new String(decryptedData, UTF_8);
                return result;
            }

     

    展开全文
  • js网页界面实现DES算法。有界面,支持中文加密和解密。
  • js md5 中文加密和后端 java md5加密不一致


    1. js md5 解决方案

    function md5(string) {
        function md5_RotateLeft(lValue, iShiftBits) {
            return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
        }
        function md5_AddUnsigned(lX, lY) {
            var lX4, lY4, lX8, lY8, lResult;
            lX8 = (lX & 0x80000000);
            lY8 = (lY & 0x80000000);
            lX4 = (lX & 0x40000000);
            lY4 = (lY & 0x40000000);
            lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
            if (lX4 & lY4) {
                return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
            }
            if (lX4 | lY4) {
                if (lResult & 0x40000000) {
                    return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
                } else {
                    return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
                }
            } else {
                return (lResult ^ lX8 ^ lY8);
            }
        }
        function md5_F(x, y, z) {
            return (x & y) | ((~x) & z);
        }
        function md5_G(x, y, z) {
            return (x & z) | (y & (~z));
        }
        function md5_H(x, y, z) {
            return (x ^ y ^ z);
        }
        function md5_I(x, y, z) {
            return (y ^ (x | (~z)));
        }
        function md5_FF(a, b, c, d, x, s, ac) {
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_F(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_GG(a, b, c, d, x, s, ac) {
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_G(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_HH(a, b, c, d, x, s, ac) {
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_H(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_II(a, b, c, d, x, s, ac) {
            a = md5_AddUnsigned(a, md5_AddUnsigned(md5_AddUnsigned(md5_I(b, c, d), x), ac));
            return md5_AddUnsigned(md5_RotateLeft(a, s), b);
        };
        function md5_ConvertToWordArray(string) {
            var lWordCount;
            var lMessageLength = string.length;
            var lNumberOfWords_temp1 = lMessageLength + 8;
            var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
            var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
            var lWordArray = Array(lNumberOfWords - 1);
            var lBytePosition = 0;
            var lByteCount = 0;
            while (lByteCount < lMessageLength) {
                lWordCount = (lByteCount - (lByteCount % 4)) / 4;
                lBytePosition = (lByteCount % 4) * 8;
                lWordArray[lWordCount] = (lWordArray[lWordCount] | (string.charCodeAt(lByteCount) << lBytePosition));
                lByteCount++;
            }
            lWordCount = (lByteCount - (lByteCount % 4)) / 4;
            lBytePosition = (lByteCount % 4) * 8;
            lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
            lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
            lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
            return lWordArray;
        };
        function md5_WordToHex(lValue) {
            var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
            for (lCount = 0; lCount <= 3; lCount++) {
                lByte = (lValue >>> (lCount * 8)) & 255;
                WordToHexValue_temp = "0" + lByte.toString(16);
                WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
            }
            return WordToHexValue;
        };
        function md5_Utf8Encode(string) {
            string = string.replace(/\r\n/g, "\n");
            var utftext = "";
            for (var n = 0; n < string.length; n++) {
                var c = string.charCodeAt(n);
                if (c < 128) {
                    utftext += String.fromCharCode(c);
                } else if ((c > 127) && (c < 2048)) {
                    utftext += String.fromCharCode((c >> 6) | 192);
                    utftext += String.fromCharCode((c & 63) | 128);
                } else {
                    utftext += String.fromCharCode((c >> 12) | 224);
                    utftext += String.fromCharCode(((c >> 6) & 63) | 128);
                    utftext += String.fromCharCode((c & 63) | 128);
                }
            }
            return utftext;
        };
        var x = Array();
        var k, AA, BB, CC, DD, a, b, c, d;
        var S11 = 7, S12 = 12, S13 = 17, S14 = 22;
        var S21 = 5, S22 = 9, S23 = 14, S24 = 20;
        var S31 = 4, S32 = 11, S33 = 16, S34 = 23;
        var S41 = 6, S42 = 10, S43 = 15, S44 = 21;
        string = md5_Utf8Encode(string);
        x = md5_ConvertToWordArray(string);
        a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
        for (k = 0; k < x.length; k += 16) {
            AA = a; BB = b; CC = c; DD = d;
            a = md5_FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
            d = md5_FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
            c = md5_FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
            b = md5_FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
            a = md5_FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
            d = md5_FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
            c = md5_FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
            b = md5_FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
            a = md5_FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
            d = md5_FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
            c = md5_FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
            b = md5_FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
            a = md5_FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
            d = md5_FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
            c = md5_FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
            b = md5_FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
            a = md5_GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
            d = md5_GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
            c = md5_GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
            b = md5_GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
            a = md5_GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
            d = md5_GG(d, a, b, c, x[k + 10], S22, 0x2441453);
            c = md5_GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
            b = md5_GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
            a = md5_GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
            d = md5_GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
            c = md5_GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
            b = md5_GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
            a = md5_GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
            d = md5_GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
            c = md5_GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
            b = md5_GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
            a = md5_HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
            d = md5_HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
            c = md5_HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
            b = md5_HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
            a = md5_HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
            d = md5_HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
            c = md5_HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
            b = md5_HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
            a = md5_HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
            d = md5_HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
            c = md5_HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
            b = md5_HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
            a = md5_HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
            d = md5_HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
            c = md5_HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
            b = md5_HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
            a = md5_II(a, b, c, d, x[k + 0], S41, 0xF4292244);
            d = md5_II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
            c = md5_II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
            b = md5_II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
            a = md5_II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
            d = md5_II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
            c = md5_II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
            b = md5_II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
            a = md5_II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
            d = md5_II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
            c = md5_II(c, d, a, b, x[k + 6], S43, 0xA3014314);
            b = md5_II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
            a = md5_II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
            d = md5_II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
            c = md5_II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
            b = md5_II(b, c, d, a, x[k + 9], S44, 0xEB86D391);
            a = md5_AddUnsigned(a, AA);
            b = md5_AddUnsigned(b, BB);
            c = md5_AddUnsigned(c, CC);
            d = md5_AddUnsigned(d, DD);
        }
        return (md5_WordToHex(a) + md5_WordToHex(b) + md5_WordToHex(c) + md5_WordToHex(d)).toLowerCase();
    }
    
    

    2. 测试

    2.1 前端代码

    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Title</title>
    </head>
    <body>
    
    </body>
    <script src="./testMd5.js"></script>
    <script>
        console.log("测试中文:"+md5("测试中文"))
    </script>
    </html>
    
    

    2.2 后端java代码

     @Test
        public void testMd5(){
            String out = DigestUtils.md5DigestAsHex("测试中文".getBytes());
            System.out.println(out);
        }
    

    由此可见 使用上面的md5加密代码就可以实现前后端的md5加密一致性

    展开全文
  • 使用crypto模块实现md5加密功能(解决中文加密前后端不一致的问题)

    使用crypto模块实现md5加密功能(解决中文加密前后端不一致的问题)

    参考文章:

    (1)使用crypto模块实现md5加密功能(解决中文加密前后端不一致的问题)

    (2)https://www.cnblogs.com/wx1993/p/6226183.html

    (3)https://www.codeprj.com/blog/5f01071.html


    备忘一下。


    展开全文
  • 视屏音频图片SWF动画游戏中文加密软件一机一码程序
  • public class RSAChinese { /** * 创建密钥对生成器,指定加密和解密算法为RSA * @param keylen * @return */ public String[] createKey(int keylen) {// 输入密钥长度 String[] output = new String[5];...
  • 一 对称加密1.mycyrpt的对称加密:/*** @param $key //数据加密密钥 由自己定义,长度有限制 string* @param $string //需要进行加解密的字符串 string* @param $decrypt //加密还是解密 (最简单的,0代表加密,1代表...
  • 完美支持中文的jqueryBase64加密解密,加密:$.base64.encode("要加密的文字"); $.base64.decode("要解密的密文");
  • Java实现浏览器链接地址的中文加密和解密 一:在好些的网站上进行相关的中文搜索的时候,发现点击搜索后留意了链接中的中文的变化,全部变成了加密后的字符串了.那么问题来了,java怎么实现这样的漂亮的加密的字符串了...
  • 中文加密和解密,中文加密后以ASCII值显示,解密后以拼音显示!(跟男朋友闹着玩时写着玩的,供大家参考)此外已打包部署好,在bin文件夹下
  • js 中文加密解密

    千次阅读 2018-07-16 23:08:38
    encodeURI() 加密 进行两次加密 decodeURI() 解密 进行两次解密
  • url中文加密

    2017-08-18 10:17:42
    我在某些网站看到有写中文加密成十六进制编码, 比如: 丰=%B7%E1 本=%B1%BE 这些是用什么加密得来的呢? 如果我用.net来写可以么
  • 专业中文加密工具

    2011-11-12 13:26:32
    TrueCrypt,是一款免费开源的加密软件,同时支持Windows Vista,7/XP, Mac OS X, Linux 等操作系统。TrueCrypt不需要生成任何文件即可在硬盘上建立虚拟磁盘,用户可以按照盘符进行访问,所有虚拟磁盘上的文件都被自动...
  • public final class MD5 {java/**git* 默认构造方法数组*/ideprivate MD5() {加密}spa/**字符串* 得到MD5加密字符串get* it* @param source 源字符串io** @return 加密后的字符串**/public static String getMD5...
  • 字符串中文加密解密软件(含源代码)简单的VB字符串加密解密函数,16万汉字加密5秒,解密3秒。
  • md5中文加密问题

    千次阅读 2018-12-17 19:01:29
    写项目的时候需要用到md5加密,测试的时候输入的文字一直是中文的,导致一直显示密文错误,死活找不到原因,然后找同事交流之后发现同事用我的代码测试是可以返回成功的,对比之后发现原来他一直使用的是数字以及...
  • 最近项目中遇到一个这样...仔细对比,发现在页面分享时,浏览器自动对中文进行了二次加密,所以需要二次解密,才可以获取字段值。 eg. location.href = "index.html?provinceName="+"江苏"; location.search...
  • //加密 将上传文件名加密 String content = "爱我zhonghua.txt"; System.out.println("原文"+content); String password = "abc123"; String code = AES.encrypt(content, password); System.out.println(...
  • package test1;import java.io.*;import java.util.*;import java.util.logging.Level;import java.util.logging.Logger;public class Main {static String encrypt(String s) {try {char tmp;byte[] s1 = s.getByte...
  • url中文加密解密

    千次阅读 2017-12-14 16:23:49
    encodeURIComponent方法在编码单个URIComponent(指请求参数)应当是最常用的,它可以讲参数中的中文、特殊字符进行转义,而不会影响整个URL。 5 示例: 1 escape() [plain] view plain ...
  • Java中文加密解密

    千次阅读 2017-12-08 17:00:02
    import java.io.UnsupportedEncodingException; import java.math.BigInteger; public class ChineseTrans { public static void main(String[] args) throws UnsupportedEncodingException { ...
  • .net 的 Url 中文加密

    2014-10-14 11:50:00
    当 Get 的请求参数可能出现中文的时候,那么就需要对其中文进行加密处理; 引用程序集:System.Web 加密方法:HttpUtility.UrlEncode();  解密方法:HttpUtility.UrlDecode(); 注:加密的内容只对中文有效,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,701
精华内容 2,280
关键字:

中文加密