【原创】文本转进制加密解密，支持2 - 36进制，自定义秘钥

憨憨问号 · 发表于 2024-10-29 12:11:23

本帖最后由憨憨问号于 2024-10-29 12:12 编辑
前言：

1.纯源码，无嵌套模块
2.灵感来源于https://bbs.125.la/forum.php?mod=viewthread&tid=14827786，感谢大神无私开源

3.后面在讲效果和原理解析，不想看我扯淡的直接回复拿源码

文本转任意进制加密.rar (14.71 KB, 下载次数: 115, 售价: 1 枚精币)

2024-10-29 11:58 上传

点击文件名下载附件
点赞+1jb，回复+1jb，评分+1jb，正好！

效果：
原文：精易论坛真有趣
秘钥：蜂蜜
密文：蜜蜜蜜蜜蜜蜂蜂蜜蜂蜜蜜蜜蜜蜜蜂蜜蜜蜂蜂蜜蜜蜂蜂蜂蜂蜜蜂蜂蜜蜜蜜蜂蜂蜂蜜蜂蜜蜜蜜蜂蜜蜜蜜蜂蜜蜂蜜蜂蜜蜂蜜蜜蜜蜂蜜蜂蜜蜜蜂蜜蜜蜜蜜蜜蜂蜜蜜蜜蜂蜂蜂蜜蜜蜜蜜蜜蜜蜜蜂蜂蜜蜜蜜蜂蜂蜂蜂蜜蜂蜂蜜蜜蜂蜂蜂蜜蜜蜂蜜蜜蜂蜜蜂蜂蜂蜜蜜

原文：我是憨憨问号
秘钥：来哔哩看憨批问号玩植物大战僵尸
密文：号问玩物号大看尸号问哔物号问哔物大批玩战问批玩来

原理：

子程序名	返回值类型	公开	备注
进制_10到其它	文本型		2 - 36 ;到十进制是有符号的感谢精易论坛https://bbs.125.la/forum.php?mod=viewthread&tid=14827786
参数名	类型	参考	可空	数组	备注
十进制	长整数型
到进制	整数型				2 - 36

变量名	类型	静态	数组	备注
结果	文本型

结果＝取空白文本 (66)
_i64toa_s (十进制, 结果, 66, 到进制)
返回 (结果)

子程序名	返回值类型	公开	备注
进制_转换	文本型		2 - 36 感谢精易论坛https://bbs.125.la/forum.php?mod=viewthread&tid=14827786
参数名	类型	参考	可空	数组	备注
进制文本	文本型				进制文本,含有支持含有这些字符： 0123456789abcdefghijklmnopqrstuvwxyz
from	整数型				默认0=自动识别，0x开头当16,0开头没x当8,1-9开头当10 剩下的类型范围 2-36，超出将无效
to	整数型				2 - 36

返回 (进制_10到其它 (进制_其它到10 (进制文本, from), to))

子程序名	返回值类型	公开	备注
进制_其它到10	长整数型		2 - 36 感谢精易论坛https://bbs.125.la/forum.php?mod=viewthread&tid=14827786
参数名	类型	参考	可空	数组	备注
文本	文本型				支持0xyyy 0yyy 格式，自动删除前空白符，
文本进制	整数型				默认0=自动识别，0x开头当16,0开头没x当8,1-9开头当10 剩下的类型范围 2-36，超出将无效

返回 (_strtoi64 (文本, 0, 文本进制))

这段代码用的是论坛大佬发布的帖子https://bbs.125.la/forum.php?mod=viewthread&tid=14827786
在此基础上我又进行了二段封装，使其能够将汉字转换为进制数

子程序名	返回值类型	公开	备注
wh_文本到n进制	文本型		返回处理好的n进制文本，每个文本之间用空格分割，空格不可省略
参数名	类型	参考	可空	数组	备注
文本	文本型				填入明文
进制n	整数型				填写要转换的进制，值可以是2-36之间的任何数

变量名	类型	静态	数组	备注
un码	文本型
待处理十进制文本	文本型		0
处理结果	文本型
i	整数型

un码＝编码_Ansi到Unicode_文本型 (文本)
待处理十进制文本＝分割文本 (un码, “&#”, ) ' 以un码的恒定格式进行分割
删除成员 (待处理十进制文本, 1, 1) ' 删除空成员

计次循环首 (取数组成员数 (待处理十进制文本), i)

如果 (处理结果＝ “”) ' 简单的判断，防止分隔符出现在开头

处理结果＝处理结果＋进制_10到其它 (到长整数 (待处理十进制文本 [i]), 进制n) ' 进制转换后储存起来

处理结果＝处理结果＋ “ ” ＋进制_10到其它 (到长整数 (待处理十进制文本 [i]), 进制n) ' 进制转换后储存起来

计次循环尾 ()
返回 (处理结果)

子程序名	返回值类型	公开	备注
wh_n进制到文本	文本型		返回处理好的文本，每个文本之间用空格分割，空格不可省略
参数名	类型	参考	可空	数组	备注
文本	文本型				填入n进制文本
进制n	整数型				填写要转换的进制，值可以是2-36之间的任何数

变量名	类型	静态	数组	备注
进制文本	文本型		0
un码	文本型
i	整数型

进制文本＝分割文本 (文本, “ ”, ) ' 以空格作为分割

计次循环首 (取数组成员数 (进制文本), i)

un码＝ un码＋ “&#” ＋到文本 (进制_其它到10 (进制文本 [i], 进制n)) ' 进制转换后储存起来

计次循环尾 ()
返回 (编码_Unicode到Ansi_文本型 (un码))

.版本 2<br />
<br />
.子程序 wh_文本到n进制, 文本型, 公开, 返回处理好的n进制文本，每个文本之间用空格分割，空格不可省略<br />
.参数 文本, 文本型, , 填入明文<br />
.参数 进制n, 整数型, , 填写要转换的进制，值可以是2-36之间的任何数<br />
.局部变量 un码, 文本型<br />
.局部变量 待处理十进制文本, 文本型, , "0"<br />
.局部变量 处理结果, 文本型<br />
.局部变量 i, 整数型<br />
<br />
un码 ＝ 编码_Ansi到Unicode_文本型 (文本)<br />
待处理十进制文本 ＝ 分割文本 (un码, “&#”, )  ' 以un码的恒定格式进行分割<br />
删除成员 (待处理十进制文本, 1, 1)  ' 删除空成员<br />
.计次循环首 (取数组成员数 (待处理十进制文本), i)<br />
    .如果 (处理结果 ＝ “”)  ' 简单的判断，防止分隔符出现在开头<br />
        处理结果 ＝ 处理结果 ＋ 进制_10到其它 (到长整数 (待处理十进制文本 <i>), 进制n)  ' 进制转换后储存起来<br />
    .否则<br />
        处理结果 ＝ 处理结果 ＋ “ ” ＋ 进制_10到其它 (到长整数 (待处理十进制文本 <i>), 进制n)  ' 进制转换后储存起来<br />
    .如果结束<br />
<br />
.计次循环尾 ()<br />
返回 (处理结果)<br />
<br />
.子程序 wh_n进制到文本, 文本型, 公开, 返回处理好的文本，每个文本之间用空格分割，空格不可省略<br />
.参数 文本, 文本型, , 填入n进制文本<br />
.参数 进制n, 整数型, , 填写要转换的进制，值可以是2-36之间的任何数<br />
.局部变量 进制文本, 文本型, , "0"<br />
.局部变量 un码, 文本型<br />
.局部变量 i, 整数型<br />
<br />
进制文本 ＝ 分割文本 (文本, “ ”, )  ' 以空格作为分割<br />
.计次循环首 (取数组成员数 (进制文本), i)<br />
    un码 ＝ un码 ＋ “&#” ＋ 到文本 (进制_其它到10 (进制文本 <i>, 进制n))  ' 进制转换后储存起来<br />
.计次循环尾 ()<br />
返回 (编码_Unicode到Ansi_文本型 (un码))

二段封装的原理如下：
1.利用“编码_Ansi到Unicode_文本型”命令将文本转为unicode值
例如“精易论坛”转换后变为“精易论坛”
2.对转换后的un码进行分割，以“&#”作为分隔符，分割成一个个十进制整数
3.将十进制整数分别进行进制转换后输出结果

如此一来，已经实现了简单的加密了
例如“精易论坛”加密为14进制的结果为“b8d0 9747 d070 8215”

再最后，我又进行了第三段封装，也就是将转换进制后的un码再次进行混淆

子程序名	返回值类型	公开	备注
问号独家_文本加密	文本型		输入一段文本，填入任意纯汉字秘钥，自动判断加密逻辑，输出加密后的文本
参数名	类型	参考	可空	数组	备注
原文	文本型
秘钥	文本型				秘钥必须是不重复的纯汉字，否则会出问题，加解密时需保持秘钥一致

变量名	类型	静态	数组	备注
进制	整数型
秘钥数组原文数组	文本型		0
秘钥数组	文本型		36
i	整数型

进制＝取文本长度 (秘钥) ÷ 2 ' 自动判断加密进制
调试输出 (到文本 (进制) ＋ “进制加密”)

如果真 (取文本长度 (原文) ＜ 2) ' 判断文本是否为空文本

返回 (“原文不可为空！”)

如果真 (取文本长度 (秘钥) ＜ 2) ' 判断文本是否为空文本

返回 (“秘钥不可为空！”)

如果真 (_只取汉字 (秘钥) ≠ 秘钥) ' 判断秘钥是否是纯汉字

返回 (“秘钥必须是纯汉字”)

如果真 (进制＞ 36 或进制＜ 2) ' 限制秘钥位数

返回 (“秘钥不能小于两位或是大于36位”)

如果真 (文本_去重复文本 (秘钥, ) ≠ 秘钥) ' 进制秘钥重复

返回 (“秘钥的每个文本都不能重复”)
文本_逐字分割_汇编 (秘钥, 秘钥数组) ' 分割秘钥

计次循环首 (36 －取数组成员数 (秘钥数组), i) ' 用空文本填充不足36的位置

加入成员 (秘钥数组, “”)

计次循环尾 ()
原文＝ wh_文本到n进制 (原文, 进制)  ' 转换进制
原文＝到小写 (原文)  ' 防止有大写
' 调试输出 (原文)  ' 加密前的进制文本
' ———————————加密字符———————————
原文＝子文本替换 (原文, “0”, 秘钥数组 [1], , , 真)
原文＝子文本替换 (原文, “1”, 秘钥数组 [2], , , 真)
原文＝子文本替换 (原文, “2”, 秘钥数组 [3], , , 真)
原文＝子文本替换 (原文, “3”, 秘钥数组 [4], , , 真)
原文＝子文本替换 (原文, “4”, 秘钥数组 [5], , , 真)
原文＝子文本替换 (原文, “5”, 秘钥数组 [6], , , 真)
原文＝子文本替换 (原文, “6”, 秘钥数组 [7], , , 真)
原文＝子文本替换 (原文, “7”, 秘钥数组 [8], , , 真)
原文＝子文本替换 (原文, “8”, 秘钥数组 [9], , , 真)
原文＝子文本替换 (原文, “9”, 秘钥数组 [10], , , 真)
原文＝子文本替换 (原文, “a”, 秘钥数组 [11], , , 真)
原文＝子文本替换 (原文, “b”, 秘钥数组 [12], , , 真)
原文＝子文本替换 (原文, “c”, 秘钥数组 [13], , , 真)
原文＝子文本替换 (原文, “d”, 秘钥数组 [14], , , 真)
原文＝子文本替换 (原文, “e”, 秘钥数组 [15], , , 真)
原文＝子文本替换 (原文, “f”, 秘钥数组 [16], , , 真)
原文＝子文本替换 (原文, “g”, 秘钥数组 [17], , , 真)
原文＝子文本替换 (原文, “h”, 秘钥数组 [18], , , 真)
原文＝子文本替换 (原文, “i”, 秘钥数组 [19], , , 真)
原文＝子文本替换 (原文, “j”, 秘钥数组 [20], , , 真)
原文＝子文本替换 (原文, “k”, 秘钥数组 [21], , , 真)
原文＝子文本替换 (原文, “l”, 秘钥数组 [22], , , 真)
原文＝子文本替换 (原文, “m”, 秘钥数组 [23], , , 真)
原文＝子文本替换 (原文, “n”, 秘钥数组 [24], , , 真)
原文＝子文本替换 (原文, “o”, 秘钥数组 [25], , , 真)
原文＝子文本替换 (原文, “p”, 秘钥数组 [26], , , 真)
原文＝子文本替换 (原文, “q”, 秘钥数组 [27], , , 真)
原文＝子文本替换 (原文, “r”, 秘钥数组 [28], , , 真)
原文＝子文本替换 (原文, “s”, 秘钥数组 [29], , , 真)
原文＝子文本替换 (原文, “t”, 秘钥数组 [30], , , 真)
原文＝子文本替换 (原文, “u”, 秘钥数组 [31], , , 真)
原文＝子文本替换 (原文, “v”, 秘钥数组 [32], , , 真)
原文＝子文本替换 (原文, “w”, 秘钥数组 [33], , , 真)
原文＝子文本替换 (原文, “x”, 秘钥数组 [34], , , 真)
原文＝子文本替换 (原文, “y”, 秘钥数组 [35], , , 真)
原文＝子文本替换 (原文, “z”, 秘钥数组 [36], , , 真)
' ———————————加密字符———————————
' 调试输出 (原文)  ' 加密后的进制文本
返回 (原文)

子程序名	返回值类型	公开	备注
问号独家_文本解密	文本型		输入一段文本，填入任意纯汉字秘钥，自动判断加密逻辑，输出解密后的文本
参数名	类型	参考	可空	数组	备注
密文	文本型
秘钥	文本型				秘钥必须是不重复的纯汉字，加解密时需保持秘钥一致

变量名	类型	静态	数组	备注
进制	整数型
秘钥数组	文本型		36
i	整数型

进制＝取文本长度 (秘钥) ÷ 2 ' 自动判断加密进制
调试输出 (到文本 (进制) ＋ “进制加密”)

如果真 (取文本长度 (密文) ＜ 2) ' 判断文本是否为空文本

返回 (“密文不可为空！”)

如果真 (取文本长度 (秘钥) ＜ 2) ' 判断文本是否为空文本

返回 (“秘钥不可为空！”)

如果真 (_只取汉字 (秘钥) ≠ 秘钥) ' 判断秘钥是否是纯汉字

返回 (“秘钥必须是纯汉字”)

如果真 (进制＞ 36 或进制＜ 2) ' 限制秘钥位数

返回 (“秘钥不能小于两位或是大于36位！”)

如果真 (文本_去重复文本 (秘钥, ) ≠ 秘钥) ' 禁止秘钥重复

返回 (“秘钥的每个文本都不能重复”)
文本_逐字分割_汇编 (秘钥, 秘钥数组) ' 分割秘钥

计次循环首 (36 －取数组成员数 (秘钥数组), i) ' 用空文本填充不足36的位置

加入成员 (秘钥数组, “”)

计次循环尾 ()
' 调试输出 (密文)  ' 解密前的密文
' ———————————加密字符———————————
密文＝子文本替换 (密文, 秘钥数组 [1], “0”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [2], “1”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [3], “2”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [4], “3”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [5], “4”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [6], “5”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [7], “6”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [8], “7”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [9], “8”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [10], “9”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [11], “a”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [12], “b”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [13], “c”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [14], “d”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [15], “e”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [16], “f”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [17], “g”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [18], “h”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [19], “i”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [20], “j”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [21], “k”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [22], “l”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [23], “m”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [24], “n”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [25], “o”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [26], “p”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [27], “q”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [28], “r”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [29], “s”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [30], “t”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [31], “u”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [32], “v”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [33], “w”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [34], “x”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [35], “y”, , , 真)
密文＝子文本替换 (密文, 秘钥数组 [36], “z”, , , 真)
' ———————————加密字符———————————
密文＝ wh_n进制到文本 (密文, 进制)  ' 转换进制
' 调试输出 (密文)  ' 解密后的密文
返回 (密文)

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.子程序 问号独家_文本加密, 文本型, 公开, 输入一段文本，填入任意纯汉字秘钥，自动判断加密逻辑，输出加密后的文本<br />
.参数 原文, 文本型<br />
.参数 秘钥, 文本型, , 秘钥必须是不重复的纯汉字，否则会出问题，加解密时需保持秘钥一致<br />
.局部变量 进制, 整数型<br />
.局部变量 秘钥数组原文数组, 文本型, , "0"<br />
.局部变量 秘钥数组, 文本型, , "36"<br />
.局部变量 i, 整数型<br />
<br />
进制 ＝ 取文本长度 (秘钥) ÷ 2  ' 自动判断加密进制<br />
调试输出 (到文本 (进制) ＋ “进制加密”)<br />
.如果真 (取文本长度 (原文) ＜ 2)  ' 判断文本是否为空文本<br />
    返回 (“原文不可为空！”)<br />
.如果真结束<br />
.如果真 (取文本长度 (秘钥) ＜ 2)  ' 判断文本是否为空文本<br />
    返回 (“秘钥不可为空！”)<br />
.如果真结束<br />
.如果真 (_只取汉字 (秘钥) ≠ 秘钥)  ' 判断秘钥是否是纯汉字<br />
    返回 (“秘钥必须是纯汉字”)<br />
.如果真结束<br />
.如果真 (进制 ＞ 36 或 进制 ＜ 2)  ' 限制秘钥位数<br />
    返回 (“秘钥不能小于两位或是大于36位”)<br />
.如果真结束<br />
.如果真 (文本_去重复文本 (秘钥, ) ≠ 秘钥)  ' 进制秘钥重复<br />
    返回 (“秘钥的每个文本都不能重复”)<br />
.如果真结束<br />
文本_逐字分割_汇编 (秘钥, 秘钥数组)  ' 分割秘钥<br />
.计次循环首 (36 － 取数组成员数 (秘钥数组), i)  ' 用空文本填充不足36的位置<br />
    加入成员 (秘钥数组, “”)<br />
.计次循环尾 ()<br />
原文 ＝ wh_文本到n进制 (原文, 进制)  ' 转换进制<br />
原文 ＝ 到小写 (原文)  ' 防止有大写<br />
' 调试输出 (原文)  ' 加密前的进制文本<br />
' ———————————加密字符———————————<br />
原文 ＝ 子文本替换 (原文, “0”, 秘钥数组 [1], , , 真)<br />
原文 ＝ 子文本替换 (原文, “1”, 秘钥数组 [2], , , 真)<br />
原文 ＝ 子文本替换 (原文, “2”, 秘钥数组 [3], , , 真)<br />
原文 ＝ 子文本替换 (原文, “3”, 秘钥数组 [4], , , 真)<br />
原文 ＝ 子文本替换 (原文, “4”, 秘钥数组 [5], , , 真)<br />
原文 ＝ 子文本替换 (原文, “5”, 秘钥数组 [6], , , 真)<br />
原文 ＝ 子文本替换 (原文, “6”, 秘钥数组 [7], , , 真)<br />
原文 ＝ 子文本替换 (原文, “7”, 秘钥数组 [8], , , 真)<br />
原文 ＝ 子文本替换 (原文, “8”, 秘钥数组 [9], , , 真)<br />
原文 ＝ 子文本替换 (原文, “9”, 秘钥数组 [10], , , 真)<br />
原文 ＝ 子文本替换 (原文, “a”, 秘钥数组 [11], , , 真)<br />
原文 ＝ 子文本替换 (原文, “b”, 秘钥数组 [12], , , 真)<br />
原文 ＝ 子文本替换 (原文, “c”, 秘钥数组 [13], , , 真)<br />
原文 ＝ 子文本替换 (原文, “d”, 秘钥数组 [14], , , 真)<br />
原文 ＝ 子文本替换 (原文, “e”, 秘钥数组 [15], , , 真)<br />
原文 ＝ 子文本替换 (原文, “f”, 秘钥数组 [16], , , 真)<br />
原文 ＝ 子文本替换 (原文, “g”, 秘钥数组 [17], , , 真)<br />
原文 ＝ 子文本替换 (原文, “h”, 秘钥数组 [18], , , 真)<br />
原文 ＝ 子文本替换 (原文, “i”, 秘钥数组 [19], , , 真)<br />
原文 ＝ 子文本替换 (原文, “j”, 秘钥数组 [20], , , 真)<br />
原文 ＝ 子文本替换 (原文, “k”, 秘钥数组 [21], , , 真)<br />
原文 ＝ 子文本替换 (原文, “l”, 秘钥数组 [22], , , 真)<br />
原文 ＝ 子文本替换 (原文, “m”, 秘钥数组 [23], , , 真)<br />
原文 ＝ 子文本替换 (原文, “n”, 秘钥数组 [24], , , 真)<br />
原文 ＝ 子文本替换 (原文, “o”, 秘钥数组 [25], , , 真)<br />
原文 ＝ 子文本替换 (原文, “p”, 秘钥数组 [26], , , 真)<br />
原文 ＝ 子文本替换 (原文, “q”, 秘钥数组 [27], , , 真)<br />
原文 ＝ 子文本替换 (原文, “r”, 秘钥数组 [28], , , 真)<br />
原文 ＝ 子文本替换 (原文, “s”, 秘钥数组 [29], , , 真)<br />
原文 ＝ 子文本替换 (原文, “t”, 秘钥数组 [30], , , 真)<br />
原文 ＝ 子文本替换 (原文, “u”, 秘钥数组 [31], , , 真)<br />
原文 ＝ 子文本替换 (原文, “v”, 秘钥数组 [32], , , 真)<br />
原文 ＝ 子文本替换 (原文, “w”, 秘钥数组 [33], , , 真)<br />
原文 ＝ 子文本替换 (原文, “x”, 秘钥数组 [34], , , 真)<br />
原文 ＝ 子文本替换 (原文, “y”, 秘钥数组 [35], , , 真)<br />
原文 ＝ 子文本替换 (原文, “z”, 秘钥数组 [36], , , 真)<br />
' ———————————加密字符———————————<br />
' 调试输出 (原文)  ' 加密后的进制文本<br />
返回 (原文)<br />
<br />
.子程序 问号独家_文本解密, 文本型, 公开, 输入一段文本，填入任意纯汉字秘钥，自动判断加密逻辑，输出解密后的文本<br />
.参数 密文, 文本型<br />
.参数 秘钥, 文本型, , 秘钥必须是不重复的纯汉字，加解密时需保持秘钥一致<br />
.局部变量 进制, 整数型<br />
.局部变量 秘钥数组, 文本型, , "36"<br />
.局部变量 i, 整数型<br />
<br />
进制 ＝ 取文本长度 (秘钥) ÷ 2  ' 自动判断加密进制<br />
调试输出 (到文本 (进制) ＋ “进制加密”)<br />
.如果真 (取文本长度 (密文) ＜ 2)  ' 判断文本是否为空文本<br />
    返回 (“密文不可为空！”)<br />
.如果真结束<br />
.如果真 (取文本长度 (秘钥) ＜ 2)  ' 判断文本是否为空文本<br />
    返回 (“秘钥不可为空！”)<br />
.如果真结束<br />
.如果真 (_只取汉字 (秘钥) ≠ 秘钥)  ' 判断秘钥是否是纯汉字<br />
    返回 (“秘钥必须是纯汉字”)<br />
.如果真结束<br />
.如果真 (进制 ＞ 36 或 进制 ＜ 2)  ' 限制秘钥位数<br />
    返回 (“秘钥不能小于两位或是大于36位！”)<br />
.如果真结束<br />
.如果真 (文本_去重复文本 (秘钥, ) ≠ 秘钥)  ' 禁止秘钥重复<br />
    返回 (“秘钥的每个文本都不能重复”)<br />
.如果真结束<br />
文本_逐字分割_汇编 (秘钥, 秘钥数组)  ' 分割秘钥<br />
.计次循环首 (36 － 取数组成员数 (秘钥数组), i)  ' 用空文本填充不足36的位置<br />
    加入成员 (秘钥数组, “”)<br />
.计次循环尾 ()<br />
' 调试输出 (密文)  ' 解密前的密文<br />
' ———————————加密字符———————————<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [1], “0”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [2], “1”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [3], “2”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [4], “3”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [5], “4”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [6], “5”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [7], “6”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [8], “7”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [9], “8”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [10], “9”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [11], “a”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [12], “b”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [13], “c”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [14], “d”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [15], “e”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [16], “f”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [17], “g”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [18], “h”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [19], “i”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [20], “j”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [21], “k”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [22], “l”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [23], “m”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [24], “n”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [25], “o”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [26], “p”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [27], “q”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [28], “r”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [29], “s”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [30], “t”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [31], “u”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [32], “v”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [33], “w”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [34], “x”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [35], “y”, , , 真)<br />
密文 ＝ 子文本替换 (密文, 秘钥数组 [36], “z”, , , 真)<br />
' ———————————加密字符———————————<br />
密文 ＝ wh_n进制到文本 (密文, 进制)  ' 转换进制<br />
' 调试输出 (密文)  ' 解密后的密文<br />
返回 (密文)

第三段封装的原理：
1.得到原文和秘钥后，先判断秘钥的位数，决定加密进制，例如秘钥为“你好”则用二进制加密，秘钥为“鸡你太美”则用四进制加密
2.逐字分割秘钥文本，将其用数组储存起来，若秘钥数组不足36个成员，则用“”（空文本）补齐36
3.将原文先用“第二段封装”的代码转换为进制数
4.再将“0”“1”“2”....“x”“y”“z”这36个字符分别用秘钥数组[1] 秘钥数组[2] 秘钥数组[3]...秘钥数组[35] 秘钥数组[36]进行子文本替换。例如秘钥为“你好”时，则会把0替换为你，1替换为好，而2 - z则会被空文本替换。解密时过程与此正好相反

如此一来完成整个加密过程
支持2到36所有进制，密文支持标点，秘钥仅支持汉字，后续可能会优化支持标点符号

制作初衷：
最早我在论坛发过“把文本加密成傻逼二字”的帖子，不知道还有没有
最近我又在b站看到有人艾特我看这个视频：https://www.bilibili.com/video/BV1wTtWeeE9N
以及这个哈基米加密：https://www.bilibili.com/video/BV11mxeeFEDu
但是他们的缺点都很明显，那就是二字加密就只能是二字加密，三字加密就只能是三字加密

所以我突发奇想，能不能做一个自动判断秘钥位数来决定是几进制加密的东西？

所以这个模块就应运而生了（我才不会告诉你其实就是上午拉肚子没去上课在家显得放屁所以写了这么一坨东西，上面鬼扯那么多其实都是借口）

模块和源码一起打包进去了，编译即用

回复本帖祝您新的一年大富大贵