续前一篇博文《几个文字加密的简洁算法和一些个人的想法》――字符平移法
以及上一篇博文《几个文字加密的简洁算法（续）》――字符错位法
这里提供第三种加密方法――对字符 Unicode 值 的 “进制转换” 法
先说点废话……
0x7a 是英文小写字母‘z’的编码值，这是编码规范规定的，机器知道，程序员也知道。
0x7a 是十进制 122――这，为什么呢？ ……因为
十六进制是由 0123456789abcdef 十六个字符来表达的，并且，a 代表 10、b 代表 11，以此类推。122 用十六进制转换下来就是 7a。so…… 单纯的进制转换其实是不能实现加密的！
但是，如果 a 不代表 10，b 不代表 11，9 代表的是 0 或其它呢――也就是说，进制表中各字符所代表的值是 随机 的，不符合常规约定，那…… 7a 代表什么呢？ 你无法知道，机器也不可能明白！
所以，如果指定一个字符 随机排列 的进制表，依此转换字符编码值，那除非你有那个原始的进制表，否则你是无法知道 7a 是哪个字符的值（即：0x7a != 122）。
“进制乱序法”――这里，随机排布的进制表就是密钥。
根据 Unicode-16 的编码规范，CJK 字符集中 20902 个汉字的编码值在 65535 以内（即 2 的 16 次方），如果用十六进制表示，每个字需要4个进制字符表达，1 变 4！ 密文增加得太多了，不划算！ 折中，取 3 个进制字符表达，需要 41 进制 才能涵盖 65535 的码值（41*41*41 = 68921 > 65535）。
原则上，进制表字符可以采用任意 8 bit 字符，但考虑通用性，以及字符在各种网络上的正常传输，这里仅采用英文字符 a-z，和 A-Z，区分大小写共 52 个字符 作为进制表字符候选。
注意：算法中对转换后的字符串（进制表字符）增加了“平移加密”（见 算法1 ） 操作，使得加密强度更高了。
算法3：进制乱序法
(function() {
//
// 进制转换-加密：
// 采用 [a-zA-Z] 52 个字符随机排列成进制表，对字符的值进行转换。
// 固定 3 位字符，41 进制，字符值最大可为 68920（> 65535）。
// 特点：
// 1. 密文为纯大小写英文字母，及原有的 [\s\n\r]；
// 2. 增加了平移操作，双重加密；
// 3. key[0-40] 为进制表，逆向 16-25 位作为平移密钥；
// 4. 进制表段字符不可重复。
// 5. 空白、换行和回车 [\s\n\r] 不加密。
// 缺点：
// 密文会比原文长，单字节字符会增长得较多。
// 推荐：
// 适用于任意类型的文本加密，网络环境可采用压缩传输；
// 注意：
// key 字符串不能含非 [a-zA-Z] 字符（关联数组）。
//
// @param string key - 进制表串（length >= 41）
// @return string - 转换后的字符串
//
String.prototype._41hex = (function()
{
var _k, _k2, _sz;
return function( key ) {
if (key.length < 41) return null;
if (_k != key) {
_sz = key.charCodeAt(40) % 10 + 16,
_k2 = key.slice(-_sz).split('');
for (var _i=0; _i<_sz; ++_i) {
_k2[_i] = _k2[_i].charCodeAt(0);
}
_k = key;
}
var _cnt = 0;
return this.replace(/[^\s\n\r]/g, function(s) {
var _n = s.charCodeAt(0);
return key.charAt(parseInt(_n/1681)) + key.charAt(parseInt(_n%1681/41)) + key.charAt(_n%41);
}).replace(/[a-zA-Z]/g, function(s) {
var _n = s.charCodeAt(0),
_beg = (_n < 0x61) ? 0x41 : 0x61,
_c = _n - _beg;
return String.fromCharCode((_c+_k2[_cnt++%_sz])%26 + _beg);
});
};
})();
//
// 进制转换-解密
// @return string - 恢复后的字符串
//
String.prototype._un41hex = (function()
{
var _k, _k2 = [], _sz, _tbl = {};
return function( key ) {
if (key.length < 41) return null;
if (_k != key) {
// 逆向，防止属性值覆盖
for (var _i=key.length-1; _i>=0; --_i) {
_tbl[key.charAt(_i)] = _i;
_k2[_i] = key.charCodeAt(_i);
}
_sz = _k2[40] % 10 + 16;
_k2 = _k2.slice(-_sz);
_k = key;
}
var _cnt = 0;
return this.replace(/[a-zA-Z]/g, function(s) {
var _n = s.charCodeAt(0),
_beg = (_n < 0x61) ? 0x41 : 0x61,
_c = _n - _beg;
return String.fromCharCode((_c-_k2[_cnt++%_sz]%26+26)%26 + _beg);
}).replace(/[a-zA-Z]{3}/g, function(s) {
var _n = _tbl[s.charAt(0)]*1681 + _tbl[s.charAt(1)]*41 + _tbl[s.charAt(2)];
return String.fromCharCode(_n);
});
};
})();
})();
优化单字节字符串加密
――采用 2 个进制表字符，用 16 进制表达，降低密文的增长长度，仅适用于码值在 0xff 以内的字符（码值超出的字符――如中文会 原样保留）。
(function() {
//
// 进制转换：单字节字符版本-加密。
// 采用 16 进制，固定 2 个字符。
// 特点：
// 值大于 0xff 的字符会原样保留，即不加密非拉丁字符。
//
// @param string key - 进制表串（length >= 16）
// @return string - 转换后的字符串
//
String.prototype._16hex = (function()
{
var _k, _k2, _sz;
return function( key ) {
if (key.length < 16) return null;
if (_k != key) {
// 加强平移密钥
_sz = key.charCodeAt(15) % (key.length-6) + 6,
_k2 = key.slice(-_sz).split('');
for (var _i=0; _i<_sz; ++_i) {
_k2[_i] = _k2[_i].charCodeAt(0);
}
_k = key;
}
var _cnt = 0;
return this.replace(/[\x21-\xff]/g, function(s) {
var _n = s.charCodeAt(0);
return key.charAt(parseInt(_n/16)) + key.charAt(_n%16);
}).replace(/[a-zA-Z]/g, function(s) {
var _n = s.charCodeAt(0),
_beg = (_n < 0x61) ? 0x41 : 0x61,
_c = _n - _beg;
return String.fromCharCode((_c+_k2[_cnt++%_sz])%26 + _beg);
});
};
})();
//
// 进制转换：单字节字符版本-解密
// @return string - 恢复后的字符串
//
String.prototype._un16hex = (function()
{
var _k, _k2 = [], _sz, _tbl = {};
return function( key ) {
if (key.length < 16) return null;
if (_k != key) {
// 逆向，防止属性值覆盖
for (var _i=key.length-1; _i>=0; --_i) {
_tbl[key.charAt(_i)] = _i;
_k2[_i] = key.charCodeAt(_i);
}
_sz = _k2[15] % (key.length-6) + 6;
_k2 = _k2.slice(-_sz);
_k = key;
}
var _cnt = 0;
return this.replace(/[a-zA-Z]/g, function(s) {
var _n = s.charCodeAt(0),
_beg = (_n < 0x61) ? 0x41 : 0x61,
_c = _n - _beg;
return String.fromCharCode((_c-_k2[_cnt++%_sz]%26+26)%26 + _beg);
}).replace(/[a-zA-Z]{2}/g, function(s) {
var _n = _tbl[s.charAt(0)]*16 + _tbl[s.charAt(1)];
return String.fromCharCode(_n);
});
};
})();
})();
用法：
<script language="JavaScript">
var _str = "中文字符串和 English char string 的 JS 加密 Test. 包含一些标点符号，*@%! 等。";
// [a-zA-Z] 的随机排列
var _t = 'DsCqrtEcbFLOuijMklNmUVnwGvHopIJKxyzABaSTWPQRXdeYfhZg';
var _enc3 = _str._41hex(_t);
alert(_enc3);
alert(_enc3._un41hex(_t));
</script>
特点：
1. 密文会增长，是原始字符串长度的 3 倍（或 2 倍），但适用于各种字符集；
2. 密文是英文大小写字母，便于各类环境下的数据传输，保留空格和换行不做转换，节约编码长度；
3. 因对密文进行了平移操作，所以即便只是统计 41 进制表中包含了哪些字符也不可能（破解需要知道进制表中有哪些字符和如何排列）。
扯了好多哦…………快过节了，没事多唠唠哈哈，俺的时间不值钱……呵呵
1 楼
zyengogo
2011-02-10
这个加密没大看明白呢？
2 楼
Liner
2011-02-10
zyengogo 写道
这个加密没大看明白呢？
试试怎么把十进制转换成十六进制――用简单的进位法
return key.charAt(parseInt(_n/16)) + key.charAt(_n%16);
就这一行，可以假设 _n 不会超过 255