任意字节集数据与文本型无损互转 文本型代替字节集的方法 带加密压缩与CRC32校验功能

CNWTEPRG

此算法与Base64算法类似，但不能完全代替使用，此算法处理一段加密数据后文件长度增加3%左右，可能会低于0%，而Base64则固定增加30%左右。

1. 
   
2. .版本 2
   
3. .支持库 YunReg
   
4. .支持库 spec
   
5. .支持库 dp1
   
6. 
   
7. .程序集 程序集1
   
8. .程序集变量 十六进制文本表, 文本型
   
9. 
   
10. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
    
11. 
    
12. 置随机数种子 ()
    
13. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
    
14. 返回 (0)  ' 可以根据您的需要返回任意数值
    
15. 
    
16. .子程序 _临时子程序
    
17. .局部变量 编码前, 字节集
    
18. .局部变量 解码后, 字节集
    
19. .局部变量 文本, 文本型
    
20. .局部变量 编码前长度, 整数型
    
21. .局部变量 编码后长度, 整数型
    
22. .局部变量 base64编码长度, 整数型
    
23. .局部变量 密码文本, 文本型
    
24. .局部变量 计数, 整数型
    
25. 
    
26. ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
    
27. 
    
28. .计次循环首 (100, 计数)
    
29.     密码文本 ＝ “123456” ＋ 到文本 (计数)
    
30.     编码前 ＝ 随机字节集 (10000)
    
31.     文本 ＝ 任意字节集到文本 (编码前, 密码文本)
    
32.     解码后 ＝ 任意文本到字节集 (文本, 密码文本)
    
33.     .如果真 (编码前 ≠ 解码后)
    
34.         暂停 ()
    
35.     .如果真结束
    
36.     编码前长度 ＝ 取字节集长度 (编码前)
    
37.     编码后长度 ＝ 取文本长度 (文本)
    
38.     base64编码长度 ＝ 取文本长度 (BASE64算法编码 (编码前))
    
39.     调试输出 (编码前长度, 编码后长度, base64编码长度)
    
40.     调试输出 (取百分比 (编码后长度, 编码前长度), 取百分比 (base64编码长度, 编码前长度))
    
41. .计次循环尾 ()
    
42. 
    
43. 
    
44. 
    
45. .子程序 取百分比, 双精度小数型
    
46. .参数 当前值, 整数型
    
47. .参数 最大值, 整数型
    
48. 
    
49. 返回 (当前值 ÷ 最大值 × 100)
    
50. 
    
51. 
    
52. .子程序 文本型数组到字节集, 字节集
    
53. .参数 文本型, 文本型, 数组
    
54. .局部变量 字节集, 字节集
    
55. .局部变量 计数, 整数型
    
56. 
    
57. .计次循环首 (取数组成员数 (文本型), 计数)
    
58.     字节集 ＝ 字节集 ＋ 到字节集 (文本型 [计数]) ＋ { 0 }
    
59. .计次循环尾 ()
    
60. 返回 (字节集)
    
61. 
    
62. .子程序 字节集到文本型数组
    
63. .参数 字节集, 字节集
    
64. .参数 文本型数组, 文本型, 参考 数组
    
65. .局部变量 字节集数组, 字节集, , "0"
    
66. .局部变量 数组成员数, 整数型
    
67. .局部变量 数组成员计数, 整数型
    
68. 
    
69. 字节集数组 ＝ 分割字节集 (字节集, { 0 }, )
    
70. 数组成员数 ＝ 取数组成员数 (字节集数组)
    
71. 重定义数组 (文本型数组, 假, 数组成员数)
    
72. .计次循环首 (数组成员数, 数组成员计数)
    
73.     文本型数组 [数组成员计数] ＝ 到文本 (字节集数组 [数组成员计数])
    
74. .计次循环尾 ()
    
75. 
    
76. 
    
77. .子程序 随机字节集, 字节集
    
78. .参数 长度, 整数型
    
79. .局部变量 计数, 整数型
    
80. .局部变量 字节集, 字节集
    
81. 
    
82. 字节集 ＝ 取空白字节集 (长度)
    
83. .计次循环首 (长度, 计数)
    
84.     字节集 [计数] ＝ 取随机数 (0, 255)
    
85. .计次循环尾 ()
    
86. 返回 (字节集)
    
87. 
    
88. .子程序 字节到十六进制, 文本型
    
89. .参数 字节, 字节型
    
90. 
    
91. 返回 (取文本中间 (十六进制文本表, 右移 (字节, 4) ＋ 1, 1) ＋ 取文本中间 (十六进制文本表, 位与 (字节, 15) ＋ 1, 1))
    
92. 
    
93. .子程序 十六进制到字节, 字节型
    
94. .参数 十六进制文本, 文本型
    
95. .局部变量 高字节, 字节型
    
96. .局部变量 低字节, 字节型
    
97. 
    
98. 高字节 ＝ 一位十六进制到字节 (取文本左边 (十六进制文本, 1))
    
99. 低字节 ＝ 一位十六进制到字节 (取文本右边 (十六进制文本, 1))
    
100. 返回 (位或 (低字节, 左移 (高字节, 4)))
     
101. 
     
102. 
     
103. .子程序 一位十六进制到字节, 字节型
     
104. .参数 十六进制文本, 文本型
     
105. .局部变量 文本, 文本型
     
106. .局部变量 计数, 整数型
     
107. 
     
108. .变量循环首 (0, 15, 1, 计数)
     
109.     .如果真 (十六进制文本 ＝ 取文本中间 (十六进制文本表, 计数 ＋ 1, 1))
     
110.         返回 (计数)
     
111.     .如果真结束
     
112. 
     
113. .变量循环尾 ()
     
114. 暂停 ()
     
115. 结束 ()
     
116. 
     
117. 返回 (255)
     
118. 
     
119. .子程序 整数到十六进制, 文本型
     
120. .参数 整数, 整数型
     
121. .局部变量 字节集, 字节集
     
122. .局部变量 计数, 整数型
     
123. .局部变量 返回值, 文本型
     
124. 
     
125. 字节集 ＝ 到字节集 (整数)
     
126. .变量循环首 (4, 1, -1, 计数)
     
127.     返回值 ＝ 返回值 ＋ 字节到十六进制 (字节集 [计数])
     
128. .变量循环尾 ()
     
129. 返回 (返回值)
     
130. 
     
131. .子程序 十六进制到整数, 整数型
     
132. .参数 十六进制文本, 文本型
     
133. .局部变量 计数, 整数型
     
134. .局部变量 计数2, 整数型
     
135. .局部变量 字节集, 字节集
     
136. 
     
137. 字节集 ＝ 取空白字节集 (4)
     
138. 计数2 ＝ 5
     
139. .变量循环首 (1, 7, 2, 计数)
     
140.     计数2 ＝ 计数2 － 1
     
141.     字节集 [计数2] ＝ 十六进制到字节 (取文本中间 (十六进制文本, 计数, 2))
     
142. .变量循环尾 ()
     
143. 返回 (取字节集数据 (字节集, 3, ))
     
144. 
     
145. 
     
146. .子程序 任意字节集到文本, 文本型, 公开
     
147. .参数 字节集, 字节集
     
148. .参数 密码文本, 文本型, 可空
     
149. .局部变量 文本型数组, 文本型, , "0"
     
150. .局部变量 返回值, 文本型
     
151. .局部变量 成员数, 整数型
     
152. .局部变量 计数, 整数型
     
153. .局部变量 加密压缩后, 字节集
     
154. 
     
155. 加密压缩后 ＝ 加密压缩 (字节集, 密码文本)
     
156. 返回值 ＝ 随机十六进制文本表 ()
     
157. 返回值 ＝ 返回值 ＋ 整数到十六进制 (取字节集长度 (加密压缩后))
     
158. 返回值 ＝ 返回值 ＋ 整数到十六进制 (crc32 (加密压缩后))
     
159. 字节集到文本型数组 (加密压缩后, 文本型数组)
     
160. 成员数 ＝ 取数组成员数 (文本型数组)
     
161. .计次循环首 (成员数, 计数)
     
162.     返回值 ＝ 返回值 ＋ 整数到十六进制 (取文本长度 (文本型数组 [计数])) ＋ 文本型数组 [计数]
     
163. .计次循环尾 ()
     
164. 返回 (返回值)
     
165. 
     
166. 
     
167. .子程序 任意文本到字节集, 字节集, 公开
     
168. .参数 文本, 文本型
     
169. .参数 密码文本, 文本型, 可空
     
170. .局部变量 长度, 整数型
     
171. .局部变量 计数, 整数型
     
172. .局部变量 总长, 整数型
     
173. .局部变量 返回值, 字节集
     
174. .局部变量 字节集长度, 整数型
     
175. .局部变量 字节集CRC, 整数型
     
176. 
     
177. 
     
178. 总长 ＝ 取文本长度 (文本)
     
179. 计数 ＝ 1
     
180. 十六进制文本表 ＝ 取文本中间 (文本, 计数, 16)
     
181. .如果真 (十六进制文本表是否无效 (到字节集 (十六进制文本表)))
     
182.     返回 ({  })
     
183. .如果真结束
     
184. 计数 ＝ 计数 ＋ 16
     
185. 字节集长度 ＝ 十六进制到整数 (取文本中间 (文本, 计数, 8))
     
186. 计数 ＝ 计数 ＋ 8
     
187. 字节集CRC ＝ 十六进制到整数 (取文本中间 (文本, 计数, 8))
     
188. 计数 ＝ 计数 ＋ 8
     
189. .循环判断首 ()
     
190.     长度 ＝ 十六进制到整数 (取文本中间 (文本, 计数, 8))
     
191.     计数 ＝ 计数 ＋ 8
     
192.     返回值 ＝ 返回值 ＋ 到字节集 (取文本中间 (文本, 计数, 长度)) ＋ { 0 }
     
193.     计数 ＝ 计数 ＋ 长度
     
194. .循环判断尾 (计数 ＜ 总长)
     
195. 返回值 ＝ 取字节集左边 (返回值, 字节集长度)
     
196. .如果真 (字节集CRC ≠ crc32 (返回值))
     
197.     返回 ({  })
     
198. .如果真结束
     
199. 返回 (解密解压 (返回值, 密码文本))
     
200. 
     
201. 
     
202. .子程序 随机十六进制文本表, 文本型
     
203. .局部变量 字节集, 字节集
     
204. .局部变量 计数, 整数型
     
205. 
     
206. 字节集 ＝ 取空白字节集 (16)
     
207. .循环判断首 ()
     
208.     .计次循环首 (16, 计数)
     
209.         字节集 [计数] ＝ 取随机数 (1, 255)
     
210.     .计次循环尾 ()
     
211. .循环判断尾 (十六进制文本表是否无效 (字节集))
     
212. 十六进制文本表 ＝ 到文本 (字节集)
     
213. 返回 (十六进制文本表)
     
214. 
     
215. .子程序 十六进制文本表是否无效, 逻辑型
     
216. .参数 字节集, 字节集
     
217. .局部变量 出现的值, 逻辑型, , "0"
     
218. .局部变量 计数, 整数型
     
219. 
     
220. 重定义数组 (出现的值, 假, 256)
     
221. .计次循环首 (取字节集长度 (字节集), 计数)
     
222.     .如果真 (出现的值 [字节集 [计数] ＋ 1] ＝ 真 或 字节集 [计数] ＝ 0)
     
223.         返回 (真)
     
224.     .如果真结束
     
225.     出现的值 [字节集 [计数] ＋ 1] ＝ 真
     
226. .计次循环尾 ()
     
227. 返回 (假)
     
228. 
     
229. 
     
230. .子程序 crc32, 整数型
     
231. .参数 data, 字节集
     
232. .局部变量 crcval, 整数型
     
233. .局部变量 len, 整数型
     
234. .局部变量 i, 整数型
     
235. .局部变量 j, 整数型
     
236. .局部变量 table, 整数型, , "256"
     
237. .局部变量 crc, 整数型
     
238. 
     
239. len ＝ 取字节集长度 (data)
     
240. crcval ＝ 4294967295
     
241. .变量循环首 (0, 255, 1, i)
     
242.     crc ＝ i
     
243.     .变量循环首 (0, 7, 1, )
     
244.         .如果 (位与 (crc, 1) ≠ 0)
     
245.             crc ＝ 位异或 (位与 (右移 (crc, 1), 2147483647), 3988292384)
     
246.         .否则
     
247.             crc ＝ 位与 (右移 (crc, 1), 2147483647)
     
248. 
     
249.         .如果结束
     
250. 
     
251.     .变量循环尾 ()
     
252.     table [i ＋ 1] ＝ crc
     
253. .变量循环尾 ()
     
254. .计次循环首 (len, i)
     
255.     j ＝ 位异或 (data [i], 位与 (crcval, 255)) ＋ 1
     
256.     crcval ＝ 位异或 (位与 (右移 (crcval, 8), 16777215), table [j])
     
257. .计次循环尾 ()
     
258. 返回 (位取反 (crcval))
     
259. 
     
260. 
     
261. .子程序 加密压缩, 字节集
     
262. .参数 字节集, 字节集
     
263. .参数 密码文本, 文本型, 可空
     
264. 
     
265. 返回 (加密数据 (压缩数据 (字节集), 密码文本, 1))
     
266. 
     
267. 
     
268. 
     
269. .子程序 解密解压, 字节集
     
270. .参数 字节集, 字节集
     
271. .参数 密码文本, 文本型, 可空
     
272. 
     
273. 返回 (解压数据 (解密数据 (字节集, 密码文本, 1)))
     
274. 
     
275. 
     

复制代码

电脑高手

看看是如何实现无损转换的

520

不可能的玩意被你可能了

demon

低于0%是什么鬼

愿望

这怎么可能

Get

不知道啥玩意了

222

66666666

66大顺

路过回复看看

4面8方

我也同楼上

1心1亿

没见过这神发明