几个文字加密的 JS 简洁算法 -- 字符错位法

小甲鱼

注:原帖来自Java eye : Liner

算法2：字符错位法
——相当于把一篇文章的字全部打乱随机重排。

Javascript代码

1. (function() {
   
2.     //
   
3.     // 字符错位-加密：
   
4.     // 密钥长 ≥16，循环步长 10， 末尾余量反向对齐错位。
   
5.     // 特点：
   
6.     // 1. 密文为字符串中现有的字符，不易被检测出已加密；
   
7.     // 2. 可适用于任意字符集；
   
8.     // 3. 不增加文本的长度，即密文长度等于原文长度。
   
9.     // 缺点：
   
10.     // 1. 原文不应有固定特征，如 html 标签，否则易破解；
    
11.     // 2. 原文长度必须不小于密钥长度。
    
12.     // 推荐：
    
13.     // 适用于较长的文本处理，一般为文章的正文段落。
    
14.     //
    
15.     // @param array key  - 0-N 连续数字随机排布
    
16.     // @return string    - 加密后的字符串
    
17.     //
    
18.     String.prototype._displace = function( key )
    
19.     {
    
20.         if (key.length < 16 || this.length < key.length)
    
21.             return  false;
    
22. 
    
23.         var _pos = key.length, _buf = new Array(_pos);
    
24. 
    
25.         var _sect = function(s) {
    
26.             for (var _i=0; _i<key.length; ++_i) {
    
27.                 _buf[_i] = s.charAt(key[_i]);
    
28.             }
    
29.             return  [ _buf.slice(0, 10).join(''), _buf.slice(10).join('') ];
    
30.         };
    
31. 
    
32.         // _bs: back-string
    
33.         var _arr = _sect(this), _to = _arr[0], _bs = this.length - _pos;
    
34. 
    
35.         while (_bs >= 10) {
    
36.             _arr = _sect( _arr[1] + this.substring(_pos, _pos + 10) );
    
37.             _pos += 10;
    
38.             _to += _arr[0];
    
39.             _bs = this.length - _pos;
    
40.         }
    
41.         _to += _arr[1];
    
42. 
    
43.         // 末尾余量处理
    
44.         if (_bs > 0) {
    
45.             var _ep = this.length - key.length;
    
46.             _arr = _sect(_to.substring(_ep) + this.substring(_pos));
    
47.             _to = _to.substring(0, _ep) + _arr.join('');
    
48.         }
    
49. 
    
50.         return  _to;
    
51.     };
    
52. 
    
53. 
    
54.     //
    
55.     // 字符错位-解密： 从尾至头逆向计算
    
56.     //
    
57.     // @return string  - 解密后的字符串
    
58.     //
    
59.     String.prototype._undisplace = function( key )
    
60.     {
    
61.         if (key.length < 16) return  false;
    
62. 
    
63.         var _buf = new Array(_pos),
    
64.             _s2  = key.length - 10,  // 重叠长
    
65.             _pos = parseInt((this.length - key.length) / 10) * 10 + key.length;
    
66. 
    
67.         var _sect = function(s) {
    
68.             for (var _i=0; _i<key.length; ++_i) {
    
69.                 _buf[key[_i]] = s.charAt(_i);
    
70.             }
    
71.             // [重叠段, 有效段]
    
72.             return  [ _buf.slice(0, _s2).join(''), _buf.slice(_s2).join('') ];
    
73.         };
    
74. 
    
75.         return  (function(s) {
    
76.             var _to = '', _arr = null;
    
77.             // 末尾余量
    
78.             if (_pos < s.length) {
    
79.                 _arr = _sect(s.slice(-key.length));
    
80.                 _to = _arr[1].slice(_pos - s.length);
    
81.                 s = s.slice(0, -key.length) + _arr[0] + _arr[1].slice(0, _pos - s.length);
    
82.             }
    
83.             _pos -= key.length;
    
84.             _arr = _sect(s.slice(_pos));
    
85.             _to = _arr[1] + _to;
    
86.             _pos -= 10;
    
87.             while (_pos >= 0) {
    
88.                 _arr = _sect( s.substring(_pos, _pos + 10) + _arr[0] );
    
89.                 _pos -= 10;
    
90.                 _to = _arr[1] + _to;
    
91.             }
    
92. 
    
93.             return  _arr[0] + _to;
    
94. 
    
95.         })(this);
    
96.     };
    
97. })();

复制代码

用法：

Javascript代码

1. <script language="JavaScript">
   
2.     var _str = "中文字符串和 English char string 的 JS 加密 Test. 包含一些标点符号，*@%! 等。";
   
3.     var _k2 = [2,15,3,1,4,10,5,9,8,6,14,13,7,0,12,11];
   
4.     var _enc2 = _str._displace(_k2);
   
5.     alert(_enc2);
   
6.     alert(_enc2._undisplace(_k2));
   
7. </script>

复制代码

特点：
1.  密钥数组值为 0- N 的连续值，但排列是任意的（即取排列的“任意性”为密钥的不可知性）。
2.  因为存在重叠段，字符的错位移动是在整个字符串范围内进行，加密性好于没有重叠的分段错位方式。
3.  虽然密钥的长度也是一个变数（即长度本身的不可知性），但加密强度主要取决于增长密钥带来的数据随机性（N! --N 的阶乘）。

復襍

随便看看，收藏丶东西，这是很好的习惯。