几个文字加密的 JS 简洁算法（字符平移法）和一些个人的想法

未深入了解过数据加密——我想那应该是科学家们的事。

俺小程序员一个，但喜欢思考，琢磨过“加密的问题”良久良久……（没有最终结果）  这里说说自己琢磨之后的一些想法，仅供茶余饭后  没事瞎想时的一些零星素材。

“加密”嘛，顾名思义，基本就是要别人看不明白本来可以明白的xx，所以，对于我们日常看见的文字，只要让别人看不明白就算加密了。

不同于对其他信息的加密（比如音视频），我觉得对“文字”的加密可以有一个很简单的逻辑： 中文字符就那么几千万把个，但却可以组合成无限量的任意文章，字还是那些字，文章的意思却可以相差天远地别！ 回想“活字印刷”时的场景，在排字之前，你能知道排出来的是一篇什么文章么？？？

所以，文字的加密很简单——把字“打乱”就可以了。——字还是那些字，打乱之后说不定还是另一篇文章哩！ 你知道原文是什么吗？？——它可能是另一篇不太读得通顺的文章，也可能是那篇本来就不怎么读得通顺的原文。——这样的加密，你如何破解？ 怎么算是已经破解了？？  呵呵， 好玩吧？

现在的问题是，怎么把字打乱？ 算法是什么——必须要能根据密钥恢复回来（废话）。

时间就是效率，不罗嗦了（感觉像在浪费生命）， 这里贴出几个小算法，仅供参考，或提出质疑——是否可靠？ 提前谢谢提出质疑者（当然有解决办法就更好了）！


JS 实现：（JS 的底层 Unicode 支持是效率的根本——废话真多！）

算法1： 字符平移法

(function() {
    var _Charset = {
            'cjk': [ 'u4e00', 'u9fa5' ],    // 汉字 [一-龥]
            'num': [ 'u0030', 'u0039' ],    // 数字 [0-9]
            'lal': [ 'u0061', 'u007a' ],    // 小写字母 [a-z]
            'ual': [ 'u0041', 'u005a' ],    // 大写字母 [A-Z]
            'asc': [ 'u0020', 'u007e' ]     // ASCII 可视字符
        };

    //
    // 加密：字符码在字符集内平移。
    // 特点：
    // 1. 字串越短加密效果越好，若短文不大于密钥长度，则不可破解。
    // 2. 不增加文本的长度，即密文长度等于原文长度。
    // 缺点：
    // 1. 一次只能对“一个”连续值的字符集进行处理，而一般字符串中会
    //    同时包含多个字符集中的字符。
    // 2. 汉字平移后的字较生僻，明显体现出已被平移处理；
    // 推荐：
    // 适于特定类型的短字符串的处理，如：时间串、名称、标题等。
    //
    // 参数 cset：
    // 用 Unicode 表示 -- 4 位十六进制，前置‘u’，
    // 可用预定义的 _Charset 属性名标识，默认为 cjk。
    //
    // @param array na  - 平移量数组
    // @param array cset  - 字符集名/范围 [ 起点, 终点 ]）
    // @return string  - 平移后的字符串
    //
    String.prototype._shift = (function()
    {
        var _cset, _id, _beg, _len, _exp;

        return  function( na, cset ) {
            switch (typeof cset) {
                case 'undefined':
                    cset = 'cjk';
                case 'string':
                    _cset = (cset == _id) ? null : _Charset[cset];
                    break;
                default: _cset = cset;
            }
            if ( _cset ) {
                _beg = parseInt(_cset[0].substring(1), 16);
                _len = parseInt(_cset[1].substring(1), 16) - _beg + 1;
                _exp = RegExp('[\\' + _cset[0] + '-\\' + _cset[1] + ']', 'g');
                _id  = cset;
            }
            var _sz = na.length,
                _cnt = 0;
            return  this.replace(_exp, function(s) {
                var _c = s.charCodeAt(0) - _beg;
                return  String.fromCharCode((_c+na[_cnt++%_sz])%_len + _beg);
            });
        };
    })();


    //
    // 解密：字符码在字符集内平移-恢复。
    //
    String.prototype._unshift = (function()
    {
        var _cset, _id, _beg, _len, _exp;

        return  function( na, cset ) {
            switch (typeof cset) {
                case 'undefined':
                    cset = 'cjk';
                case 'string':
                    _cset = (cset == _id) ? null : _Charset[cset];
                    break;
                default: _cset = cset;
            }
            if ( _cset ) {
                _beg = parseInt(_cset[0].substring(1), 16);
                _len = parseInt(_cset[1].substring(1), 16) - _beg + 1;
                _exp = RegExp('[\\' + _cset[0] + '-\\' + _cset[1] + ']', 'g');
                _id  = cset;
            }
            var _sz = na.length,
                _cnt = 0;
            return  this.replace(_exp, function(s) {
                var _c = s.charCodeAt(0) - _beg;
                return  String.fromCharCode((_c-na[_cnt++%_sz]%_len+_len)%_len + _beg);
            });
        };
    })();

})();

用法：

<script language="JavaScript">
    var _str = "中文字符串和 English char string 的 JS 加密 Test. 包含一些标点符号，*@%! 等。";
    var _k1 = [2034,85,45,22,65,213,65,398,356,1709,354];
    var _enc = _str._shift(_k1);
    alert(_enc);
    alert(_enc._unshift(_k1));
</script>

密钥是个数组，如果觉得不方便，当然可以用一句话，取每个字符的码值分解成数组了。

（待续……）

几个针对特定字符环境的特化版：

    //
    // alnum 特化版-加密
    // 字符集：
    // [0-9a-zA-Z] = 英文字母（大小写） + 数字
    //
    String.prototype._shift_en = function( na )
    {
        var _sz = na.length,
            _cnt = 0;
        return  this.replace(/[0-9a-zA-Z]/g, function(s) {
            var _n = s.charCodeAt(0),
                _beg = 0x41,
                _len = 26;
            if (_n >= 0x61) {
                _beg = 0x61;
            } else if (_n < 0x41) {
                _beg = 0x30;
                _len = 10;
            }
            var _c = _n - _beg;
            return  String.fromCharCode((_c+na[_cnt++%_sz])%_len + _beg);
        });
    };

    //
    // alnum 特化版-解密
    //
    String.prototype._unshift_en = function( na )
    {
        var _sz = na.length,
            _cnt = 0;
        return  this.replace(/[0-9a-zA-Z]/g, function(s) {
            var _n = s.charCodeAt(0),
                _beg = 0x41,
                _len = 26;
            if (_n >= 0x61) {
                _beg = 0x61;
            } else if (_n < 0x41) {
                _beg = 0x30;
                _len = 10;
            }
            var _c = _n - _beg;
            return  String.fromCharCode((_c-na[_cnt++%_sz]%_len+_len)%_len + _beg);
        });
    };


    //
    // 汉语文字环境特化版-加密
    // 字符集：
    // [0-9a-zA-Z\u4e00-\u9fa5] = CJK 统一汉字 + 英文字母（大小写） + 数字
    //
    String.prototype._shift_zh = function( na )
    {
        var _sz = na.length,
            _cnt = 0;
        return  this.replace(/[0-9a-zA-Z\u4e00-\u9fa5]/g, function(s) {
            var _n = s.charCodeAt(0),
                _beg = 0x41,
                _len = 26;
            if (_n >= 0x4e00) {
                _beg = 0x4e00;
                _len = 20902;
            } else if (_n >= 0x61) {
                _beg = 0x61;
            } else if (_n < 0x41) {
                _beg = 0x30;
                _len = 10;
            }
            var _c = _n - _beg;
            return  String.fromCharCode((_c+na[_cnt++%_sz])%_len + _beg);
        });
    };

    //
    // 汉语文字环境特化版-解密
    //
    String.prototype._unshift_zh = function( na )
    {
        var _sz = na.length,
            _cnt = 0;
        return  this.replace(/[0-9a-zA-Z\u4e00-\u9fa5]/g, function(s) {
            var _n = s.charCodeAt(0),
                _beg = 0x41,
                _len = 26;
            if (_n >= 0x4e00) {
                _beg = 0x4e00;
                _len = 20902;
            } else if (_n >= 0x61) {
                _beg = 0x61;
            } else if (_n < 0x41) {
                _beg = 0x30;
                _len = 10;
            }
            var _c = _n - _beg;
            return  String.fromCharCode((_c-na[_cnt++%_sz]%_len+_len)%_len + _beg);
        });
    };


    //
    // 中文环境字符特化版-加密
    // 字符集：
    // [\u0020-\u007e\u4e00-\u9fa5] = CJK 统一汉字 + ASCII 常规字符
    // 注：
    // \u0020 = 空格，\u007e = ~
    //
    String.prototype._shift_chs = function( na )
    {
        var _sz = na.length,
            _cnt = 0;
        return  this.replace(/[\u0020-\u007e\u4e00-\u9fa5]/g, function(s) {
            var _n = s.charCodeAt(0),
                _beg = 0x20,
                _len = 95;
            if (_n >= 0x4e00) {
                _beg = 0x4e00;
                _len = 20902;
            }
            var _c = _n - _beg;
            return  String.fromCharCode((_c+na[_cnt++%_sz])%_len + _beg);
        });
    };

    //
    // 中文环境字符特化版-解密
    //
    String.prototype._unshift_chs = function( na )
    {
        var _sz = na.length,
            _cnt = 0;
        return  this.replace(/[\u0020-\u007e\u4e00-\u9fa5]/g, function(s) {
            var _n = s.charCodeAt(0),
                _beg = 0x20,
                _len = 95;
            if (_n >= 0x4e00) {
                _beg = 0x4e00;
                _len = 20902;
            }
            var _c = _n - _beg;
            return  String.fromCharCode((_c-na[_cnt++%_sz]%_len+_len)%_len + _beg);
        });
    };

不错的思路。简单有效。加密要求不太高的环境下很适合。