js xxtea 支持中文（转为byte数组与服务器交互）

最新推荐文章于 2024-04-03 10:00:20 发布
最新推荐文章于 2024-04-03 10:00:20 发布
阅读量701 收藏
点赞数
分类专栏： js 文章标签： js xxtea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012398269/article/details/84302722
版权

js与服务器通过byte数组交互




        var login = function () {
            var data = xxtea_encrypt("aaa", 'caonima');
            var oReq = new XMLHttpRequest();

            // 方法一：参考https://www.jb51.net/article/92623.htm
            // oReq.responseType = "arraybuffer";
            // oReq.onload = function (oEvent) {
            //     console.log("oEvent-------" +JSON.stringify(oEvent));
            //     var arrayBuffer = oReq.response; // 注意:不是oReq.responseText
            //     console.log("arrayBuffer" + arrayBuffer);
            //     if (arrayBuffer) {
            //         var byteArray = new Uint8Array(arrayBuffer);
            //         console.log("arrayBuffer" + byteArray);
            //         var cao = xxtea_decrypt(byteArray, "caonima");
            //         console.log("binStr " + cao);
            //     }
            // };

            //方法二：参考 https://blog.csdn.net/github_37519401/article/details/78582885
            oReq.overrideMimeType('text/plain; charset=x-user-defined');//该行重写了默认的MIME类型,强制浏览器将该响应当成纯文本文件来对待, 使用一个用户自定义的字符集.
            oReq.onreadystatechange = function(e) {
                if (this.readyState == 4 && this.status == 200) {
                        var responseText = this.responseText;
                        console.log("responseText长度 " + responseText.length);
                        var array = new Uint8Array(responseText.length);
                        for (var i = 0, len = responseText.length; i < len; ++i) {
                            var c = responseText.charCodeAt(i);
                            var byte = c & 0xff; 
                            array[i] = byte;
                        }

                        console.log("bytearray " + array);
                        var cao = xxtea_decrypt(array, "caonima");
                        console.log("最终结果 " + cao);
                }
            };


            oReq.open("POST", 'http://qianliliang.com/account/account', true);
            oReq.send(data);
      }


    // 加密：得到的是byte数组
    // str是string， key也是string
    function xxtea_encrypt(str, key) {
        if (str == "") {
            return "";
        }

        if (typeof str === 'string') str = toBytes(str);
        if (typeof key === 'string') key = toBytes(key);
        if (str === undefined || str === null || str.length === 0) {
            return str;
        }
        var v= toUint32Array(str, true);
        var k =  toUint32Array(key, false);

        var n = v.length - 1;
     
        var z = v[n], y = v[0], delta = 0x9E3779B9;
        var mx, e, q = Math.floor(6 + 52 / (n + 1)), sum = 0;
        while (q-- > 0) {
            sum = sum + delta & 0xffffffff;
            e = sum >>> 2 & 3;
            for (var p = 0; p < n; p++) {
                y = v[p + 1];
                mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                z = v[p] = v[p] + mx & 0xffffffff;
            }
            y = v[0];
            mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            z = v[n] = v[n] + mx & 0xffffffff;
        }
        console.log("草拟吗" + v);
        // var str = long2str(v, false);
        var uint8Array = toUint8Array(v, false);
        console.log("草拟吗" + uint8Array);

        return uint8Array;
    }

    // 解密
    // byte数组， key是string
    function xxtea_decrypt(bytes, key) {

        var v = toUint32Array(bytes, false);
        var k = toUint32Array(toBytes(key), false);

        var n = v.length - 1;
     
        var z = v[n - 1], y = v[0], delta = 0x9E3779B9;
        var mx, e, q = Math.floor(6 + 52 / (n + 1)), sum = q * delta & 0xffffffff;
        while (sum != 0) {
            e = sum >>> 2 & 3;
            for (var p = n; p > 0; p--) {
                z = v[p - 1];
                mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
                y = v[p] = v[p] - mx & 0xffffffff;
            }
            z = v[n];
            mx = (z >>> 5 ^ y << 2) + (y >>> 3 ^ z << 4) ^ (sum ^ y) + (k[p & 3 ^ e] ^ z);
            y = v[0] = v[0] - mx & 0xffffffff;
            sum = sum - delta & 0xffffffff;
        }

        var test= toUint8Array(v, true);
        //var test= new Array(97,98,99);
        return toString(test);
    }

    // byte数组转32位无符号数组
    function toUint32Array(bytes, includeLength) {
        var length = bytes.length;
        var n = length >> 2;
        if ((length & 3) !== 0) {
            ++n;
        }
        var v;
        if (includeLength) {
            v = new Array(n + 1);
            v[n] = length;
        }
        else {
            v = new Uint32Array(n);
        }
        for (var i = 0; i < length; ++i) {
            v[i >> 2] |= bytes[i] << ((i & 3) << 3);
        }
        return v;
    }


    // 32位无符号整数型数组 转 byte数组
    function toUint8Array(v, includeLength) {
        var n;
        if (includeLength) {
            n = v[v.length - 1];
        } else {
            n = v.length << 2;
        }

        var result = new Uint8Array(n);
        for (var i = 0; i < n; i++) {
            result[i] =  v[i >> 2] >> ((i & 3) << 3);
        }
        return result;
    }

    // str转byte数组
    function toBytes(str) {
        var n = str.length;
        // A single code unit uses at most 3 bytes.
        // Two code units at most 4.
        var bytes = new Uint8Array(n * 3);
        var length = 0;
        for (var i = 0; i < n; i++) {
            var codeUnit = str.charCodeAt(i);
            if (codeUnit < 0x80) {
                bytes[length++] = codeUnit;
            }
            else if (codeUnit < 0x800) {
                bytes[length++] = 0xC0 | (codeUnit >> 6);
                bytes[length++] = 0x80 | (codeUnit & 0x3F);
            }
            else if (codeUnit < 0xD800 || codeUnit > 0xDFFF) {
                bytes[length++] = 0xE0 | (codeUnit >> 12);
                bytes[length++] = 0x80 | ((codeUnit >> 6) & 0x3F);
                bytes[length++] = 0x80 | (codeUnit & 0x3F);
            }
            else {
                if (i + 1 < n) {
                    var nextCodeUnit = str.charCodeAt(i + 1);
                    if (codeUnit < 0xDC00 && 0xDC00 <= nextCodeUnit && nextCodeUnit <= 0xDFFF) {
                        var rune = (((codeUnit & 0x03FF) << 10) | (nextCodeUnit & 0x03FF)) + 0x010000;
                        bytes[length++] = 0xF0 | (rune >> 18);
                        bytes[length++] = 0x80 | ((rune >> 12) & 0x3F);
                        bytes[length++] = 0x80 | ((rune >> 6) & 0x3F);
                        bytes[length++] = 0x80 | (rune & 0x3F);
                        i++;
                        continue;
                    }
                }
                throw new Error('Malformed string');
            }
        }
    console.log("长度 " +length);
        return bytes.subarray(0, length);
    }

    function toShortString(bytes, n) {
        var charCodes = new Array(n);
        var i = 0, off = 0;
        for (var len = bytes.length; i < n && off < len; i++) {
            var unit = bytes[off++];
            switch (unit >> 4) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                charCodes[i] = unit;
                break;
            case 12:
            case 13:
                if (off < len) {
                    charCodes[i] = ((unit & 0x1F) << 6) |
                                    (bytes[off++] & 0x3F);
                }
                else {
                    throw new Error('Unfinished UTF-8 octet sequence');
                }
                break;
            case 14:
                if (off + 1 < len) {
                    charCodes[i] = ((unit & 0x0F) << 12) |
                                   ((bytes[off++] & 0x3F) << 6) |
                                   (bytes[off++] & 0x3F);
                }
                else {
                    throw new Error('Unfinished UTF-8 octet sequence');
                }
                break;
            case 15:
                if (off + 2 < len) {
                    var rune = (((unit & 0x07) << 18) |
                                ((bytes[off++] & 0x3F) << 12) |
                                ((bytes[off++] & 0x3F) << 6) |
                                (bytes[off++] & 0x3F)) - 0x10000;
                    if (0 <= rune && rune <= 0xFFFFF) {
                        charCodes[i++] = (((rune >> 10) & 0x03FF) | 0xD800);
                        charCodes[i] = ((rune & 0x03FF) | 0xDC00);
                    }
                    else {
                        throw new Error('Character outside valid Unicode range: 0x' + rune.toString(16));
                    }
                }
                else {
                    throw new Error('Unfinished UTF-8 octet sequence');
                }
                break;
            default:
                throw new Error('Bad UTF-8 encoding 0x' + unit.toString(16));
            }
        }
        if (i < n) {
            charCodes = charCodes.slice(0, i);//charCodes.subarray(0, i);
        }
        return String.fromCharCode.apply(String, charCodes);
    }

    function toLongString(bytes, n) {
        var buf = [];
        var charCodes = new Array(0xFFFF);
        var i = 0, off = 0;
        for (var len = bytes.length; i < n && off < len; i++) {
            var unit = bytes[off++];
            switch (unit >> 4) {
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
            case 6:
            case 7:
                charCodes[i] = unit;
                break;
            case 12:
            case 13:
                if (off < len) {
                    charCodes[i] = ((unit & 0x1F) << 6) |
                                    (bytes[off++] & 0x3F);
                }
                else {
                    throw new Error('Unfinished UTF-8 octet sequence');
                }
                break;
            case 14:
                if (off + 1 < len) {
                    charCodes[i] = ((unit & 0x0F) << 12) |
                                   ((bytes[off++] & 0x3F) << 6) |
                                   (bytes[off++] & 0x3F);
                }
                else {
                    throw new Error('Unfinished UTF-8 octet sequence');
                }
                break;
            case 15:
                if (off + 2 < len) {
                    var rune = (((unit & 0x07) << 18) |
                                ((bytes[off++] & 0x3F) << 12) |
                                ((bytes[off++] & 0x3F) << 6) |
                                (bytes[off++] & 0x3F)) - 0x10000;
                    if (0 <= rune && rune <= 0xFFFFF) {
                        charCodes[i++] = (((rune >> 10) & 0x03FF) | 0xD800);
                        charCodes[i] = ((rune & 0x03FF) | 0xDC00);
                    }
                    else {
                        throw new Error('Character outside valid Unicode range: 0x' + rune.toString(16));
                    }
                }
                else {
                    throw new Error('Unfinished UTF-8 octet sequence');
                }
                break;
            default:
                throw new Error('Bad UTF-8 encoding 0x' + unit.toString(16));
            }
            if (i >= 65534) {
                var size = i + 1;
                buf.push(String.fromCharCode.apply(String, charCodes.subarray(0, size)));
                n -= size;
                i = -1;
            }
        }
        if (i > 0) {
            buf.push(String.fromCharCode.apply(String, charCodes.slice(0, i)));
        }
        return buf.join('');
    }

    function toString(bytes) {
        var n = bytes.length;
        if (n === 0) return '';
        return ((n < 100000) ? toShortString(bytes, n) : toLongString(bytes, n));
    }
    ```
搬砖狗
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
XXTea加密 c++ 与 js 互相加解密
小宇文
10-18 2903
关于加密功能，客户端使用的是creator  用js开发的，服务器端用lua做的 要做加密功能： 1.利用c++绑定调用c++实现加密,                              好处：调用同一种方法，一次实现                             坏处：c++绑定只能用在原生系统，如果是浏览器端将无法使用加密功能           
XXTEA加密算法各种语言实现整理
01-29
XXTEA加密算法各种语言实现整理,包括C# delphi java javascript php c actionscript ps
XXtea 加密算法的JS实现和C#实现（源码）
09-01
XXTEA算法的C#实现和JS实现，可以互相的加密解密，有一个共有私钥。执行效率非常的高，非常适用于WEB解决方案中使用。
js xxtea 支持中文（转成16进制字符串）
u012398269的博客
11-19 1169
js xxtea 支持中文 // 加密 function xxtea_encrypt(str, key) { if (str == &amp;quot;&amp;quot;) { return &amp;quot;&amp;quot;; } var v = str2long(str, true); var k = str2long(key, false);
XXTEA 加密算法的 JavaScript 和 PHP 实现
zxyskycn的专栏
11-11 352
微型加密算法（TEA）及其相关变种（XTEA，Block TEA，XXTEA） 都是分组加密算法，它们很容易被描述，实现也很简单（典型的几行代码）。 TEA 算法最初是由剑桥计算机实验室的 David Wheeler 和 Roger Needham 在 1994 年设计的。该算法使用 128 位的密钥为 64 位的信息块进行加密，它需要进行 64 轮迭代，尽管作者认为 32 轮已经足够了。该算法...
XXTEA的实现（javascript版本）
dieTicket的博客
04-07 4081
//对某个app进行逆向分析的时候，发现是xxtea算法，记录一下。密文可以选择是十六进制格式与base64编码格式function long2str(v, w) { var vl = v.length; var sl = v[vl - 1] &amp; 0xffffffff; for (var i = 0; i &lt; vl; i++) { v[...
xxtea 算法的 js 加密处理类,包含 UtfParser 和 Base64 类 ？
Wu hao's blog
09-14 782
ES5写法： /* * xxtea算法的js加密处理类,还包含了UtfParser类,还包含了Base64类 */ //Class:Xxtea export function Xxtea(privateKey) { this._keyString = privateKey; } //将长整形转换为string,private Xxtea.prototype._long2str = function (v, w) { var vl = v.length; var n = (vl
lua xxtea解密工具,仅支持lua代码
12-04
使用方式:1. 点击运行XXTEADecrypt.exe2. 填写签名3. 填写秘钥key4,拖拽或选择需要解密的lua文件夹5.拖拽或选择输出文件夹6.点击解密按钮
XXTEA加密算法的C代码实现
04-04
“微型加密算法（TEA）及其相关变种（XTEA，Block TEA，XXTEA）都是分组加密算法，它们很容易被描述，实现也很简单（典型的几行代码）。 TEA 算法最初是由剑桥计算机实验室的 David Wheeler 和 Roger Needham 在 ...
xxtea.rar_XXTEA
09-24
XXTEA算法是一种高效、简洁的微积分加密算法，由David Wheeler和Roger Needham于1994年提出，主要用于短数据块的加密。在给定的“xxtea.rar_XXTEA”压缩包中，我们可以看到一个名为“hello”的文件，这可能是用XXTEA...
PHP实现的XXTEA加密解密算法示例
10-18
XXTEA（Extreme eXtended Encryption Algorithm）是一种块密码，设计用于提高DES（Data Encryption Standard）和3DES等传统加密算法的安全性和效率。它是由David Wheeler和Roger Needham在1998年提出的，是一种快速...
XXTEA 加密算法的概述及 Javascript 及 .net (C#) 实现
ThinMichael is here
05-23 3531
微型加密算法（TEA）及其相关变种（XTEA，Block TEA，XXTEA） 都是分组加密算法，它们很容易被描述，实现也很简单（典型的几行代码）。TEA 算法最初是由剑桥计算机实验室的 David Wheeler 和 Roger Needham 在 1994 年设计的。该算法使用 128 位的密钥为 64 位的信息块进行加密，它需要进行 64 轮迭代，尽管作者认为 32 轮已经足够了。该算法
Js字节数组问题
scl8295的博客
03-08 810
字节数组
在 JavaScript 中存储字节数组
six6de6的博客
09-23 3175
在 JavaScript 中存储字节数组
Javascript如何将中文转换UTF16和UTF8字节数组
mole的专栏
04-29 6241
之前因为项目的需要，需要把带有中文的字符串转换成字节数组和图片数据合并后，以二进制数据上传给服务器端。 之前，看到网上有利用Array.prototype.map.call(str, function (c) { return c.charCodeAt(0); })方法将字符串转换成字节数组，但实测结果表明该方式实现了下列功能： 1、若字符是单字节字符，则用一个小于128的数值来表示。 2、
js对数组进行操作以及数组和字符串之间的转换
qq_40749131的博客
06-15 475
var list=[];//定义数组 //1、字符串转化为数组 var str="aa,bb,cc"; list=str.split(,); console.log(list); 结果为: [aa,bb,cc] //2、数组添加 list.push("dd"); console.log(list); 结果为： [aa,bb,cc,dd] //3.移除相同字符 for(var i=0;i&...
js 解析 bytearray 成 字符串
weixin_34288121的博客
10-13 446
function bin2String(array) { return String.fromCharCode.apply(String, array); } var bit=[104,101,108,108,111,32,119,111,114,108,100]; var tostring=bin2String(['104','101','108','108','111'...
js-字符串转字节数组
最新发布
weixin_45978842的博客
04-03 774
【代码】js-字符串转字节数组。
用户登录如何给密码加密xxtea.js
为啥不能换名字的博客
11-21 628
先说一下xxtea.js 可以用这个加密 这个就是xxtea.js的源码保存一下就好了 /**********************************************************\ | | | xxtea.js ...
python xxtea
12-17
Python的xxtea是一个用于加密和解密数据的库。xxtea使用Tea加密算法，可以对数据进行快速、高效且安全的加密。 xxtea库提供了两个主要的函数：encrypt()和decrypt()。encrypt()函数用于将数据加密，而decrypt()函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值