易语言MD5计算模块纯算法源码 - 绝不调用任何DLL的API与其他支持库实现MD5计算功能

CNWTEPRG

算法纯核心库实现，与 取数据摘要() 计算出的结果不一致就会暂停，算法移植到了易语言，新人可拿去研究。

1. 
   
2. .版本 2
   
3. .支持库 dp1
   
4. 
   
5. .程序集 MD5计算模块
   
6. .程序集变量 AA, 整数型
   
7. .程序集变量 BB, 整数型
   
8. .程序集变量 CC, 整数型
   
9. .程序集变量 DD, 整数型
   
10. 
    
11. .子程序 _启动子程序, 整数型
    
12. 
    
13. 
    
14. _临时子程序 ()
    
15. 返回 (0)
    
16. 
    
17. .子程序 _临时子程序
    
18. .局部变量 字节集, 字节集
    
19. .局部变量 系统计算的MD5, 文本型
    
20. .局部变量 本程序计算的MD5, 文本型
    
21. 
    
22. ' 本名称子程序用作测试程序用，仅在开发及调试环境中有效，编译发布程序前将被系统自动清空，请将所有用作测试的临时代码放在本子程序中。 ***注意不要修改本子程序的名称、参数及返回值类型。
    
23. 置随机数种子 ()
    
24. .计次循环首 (100, )
    
25.     字节集 ＝ 随机字节集 ()
    
26.     系统计算的MD5 ＝ 取数据摘要 (字节集)
    
27.     本程序计算的MD5 ＝ MD5 (字节集)
    
28.     .如果真 (系统计算的MD5 ≠ 本程序计算的MD5)
    
29.         暂停 ()
    
30.     .如果真结束
    
31.     输出调试文本 (本程序计算的MD5)
    
32. .计次循环尾 ()
    
33. 
    
34. 
    
35. 
    
36. .子程序 随机字节集, 字节集
    
37. .局部变量 长度, 整数型
    
38. .局部变量 返回值, 字节集
    
39. .局部变量 计数, 整数型
    
40. 
    
41. 长度 ＝ 取随机数 (1, 32767)
    
42. 返回值 ＝ 取空白字节集 (长度)
    
43. .计次循环首 (长度, 计数)
    
44.     返回值 [计数] ＝ 取随机数 (0, 255)
    
45. .计次循环尾 ()
    
46. 返回 (返回值)
    
47. 
    
48. 
    
49. .子程序 初始化
    
50. 
    
51. AA ＝ 1732584193
    
52. BB ＝ -271733879
    
53. CC ＝ -1732584194
    
54. DD ＝ 271733878
    
55. 
    
56. 
    
57. .子程序 循环左移, 整数型
    
58. .参数 欲移动的整数, 整数型
    
59. .参数 欲移动的位数, 整数型
    
60. .局部变量 字节集, 字节集
    
61. .局部变量 进位输入, 逻辑型
    
62. .局部变量 进位输出, 逻辑型
    
63. .局部变量 计数, 整数型
    
64. .局部变量 移出的位, 逻辑型
    
65. 
    
66. 字节集 ＝ 到字节集 (欲移动的整数)
    
67. .计次循环首 (欲移动的位数 ％ 32, )
    
68.     进位输入 ＝ 假
    
69.     移出的位 ＝ 字节集 [4] ≥ 128
    
70.     .计次循环首 (4, 计数)
    
71.         进位输出 ＝ 字节集 [计数] ≥ 128
    
72.         字节集 [计数] ＝ 左移 (字节集 [计数], 1) ＋ 到字节 (进位输入)
    
73.         进位输入 ＝ 进位输出
    
74.     .计次循环尾 ()
    
75.     字节集 [1] ＝ 字节集 [1] ＋ 到字节 (移出的位)
    
76. .计次循环尾 ()
    
77. 返回 (字节集到整数 (字节集))
    
78. 
    
79. .子程序 F, 整数型
    
80. .参数 X, 整数型
    
81. .参数 Y, 整数型
    
82. .参数 Z, 整数型
    
83. 
    
84. 返回 (位或 (位与 (X, Y), 位与 (位取反 (X), Z)))
    
85. 
    
86. 
    
87. .子程序 G, 整数型
    
88. .参数 X, 整数型
    
89. .参数 Y, 整数型
    
90. .参数 Z, 整数型
    
91. 
    
92. 返回 (位或 (位与 (X, Z), 位与 (Y, 位取反 (Z))))
    
93. 
    
94. 
    
95. .子程序 H, 整数型
    
96. .参数 X, 整数型
    
97. .参数 Y, 整数型
    
98. .参数 Z, 整数型
    
99. 
    
100. 返回 (位异或 (X, Y, Z))
     
101. 
     
102. 
     
103. .子程序 I, 整数型
     
104. .参数 X, 整数型
     
105. .参数 Y, 整数型
     
106. .参数 Z, 整数型
     
107. 
     
108. 返回 (位异或 (Y, 位或 (X, 位取反 (Z))))
     
109. 
     
110. 
     
111. .子程序 FF
     
112. .参数 a, 整数型, 参考
     
113. .参数 b, 整数型
     
114. .参数 c, 整数型
     
115. .参数 d, 整数型
     
116. .参数 Mj, 整数型
     
117. .参数 s, 整数型
     
118. .参数 ti, 整数型
     
119. 
     
120. a ＝ b ＋ 循环左移 (a ＋ F (b, c, d) ＋ Mj ＋ ti, s)
     
121. 
     
122. .子程序 GG
     
123. .参数 a, 整数型, 参考
     
124. .参数 b, 整数型
     
125. .参数 c, 整数型
     
126. .参数 d, 整数型
     
127. .参数 Mj, 整数型
     
128. .参数 s, 整数型
     
129. .参数 ti, 整数型
     
130. 
     
131. a ＝ b ＋ 循环左移 (a ＋ G (b, c, d) ＋ Mj ＋ ti, s)
     
132. 
     
133. .子程序 HH
     
134. .参数 a, 整数型, 参考
     
135. .参数 b, 整数型
     
136. .参数 c, 整数型
     
137. .参数 d, 整数型
     
138. .参数 Mj, 整数型
     
139. .参数 s, 整数型
     
140. .参数 ti, 整数型
     
141. 
     
142. a ＝ b ＋ 循环左移 (a ＋ H (b, c, d) ＋ Mj ＋ ti, s)
     
143. 
     
144. .子程序 II
     
145. .参数 a, 整数型, 参考
     
146. .参数 b, 整数型
     
147. .参数 c, 整数型
     
148. .参数 d, 整数型
     
149. .参数 Mj, 整数型
     
150. .参数 s, 整数型
     
151. .参数 ti, 整数型
     
152. 
     
153. a ＝ b ＋ 循环左移 (a ＋ I (b, c, d) ＋ Mj ＋ ti, s)
     
154. 
     
155. .子程序 主要循环
     
156. .参数 x, 整数型, 数组
     
157. .局部变量 A, 整数型
     
158. .局部变量 B, 整数型
     
159. .局部变量 C, 整数型
     
160. .局部变量 D, 整数型
     
161. 
     
162. A ＝ AA
     
163. B ＝ BB
     
164. C ＝ CC
     
165. D ＝ DD
     
166. 
     
167. FF (A, B, C, D, x [1], 7, -680876936)
     
168. FF (D, A, B, C, x [2], 12, -389564586)
     
169. FF (C, D, A, B, x [3], 17, 606105819)
     
170. FF (B, C, D, A, x [4], 22, -1044525330)
     
171. FF (A, B, C, D, x [5], 7, -176418897)
     
172. FF (D, A, B, C, x [6], 12, 1200080426)
     
173. FF (C, D, A, B, x [7], 17, -1473231341)
     
174. FF (B, C, D, A, x [8], 22, -45705983)
     
175. FF (A, B, C, D, x [9], 7, 1770035416)
     
176. FF (D, A, B, C, x [10], 12, -1958414417)
     
177. FF (C, D, A, B, x [11], 17, -42063)
     
178. FF (B, C, D, A, x [12], 22, -1990404162)
     
179. FF (A, B, C, D, x [13], 7, 1804603682)
     
180. FF (D, A, B, C, x [14], 12, -40341101)
     
181. FF (C, D, A, B, x [15], 17, -1502002290)
     
182. FF (B, C, D, A, x [16], 22, 1236535329)
     
183. GG (A, B, C, D, x [2], 5, -165796510)
     
184. GG (D, A, B, C, x [7], 9, -1069501632)
     
185. GG (C, D, A, B, x [12], 14, 643717713)
     
186. GG (B, C, D, A, x [1], 20, -373897302)
     
187. GG (A, B, C, D, x [6], 5, -701558691)
     
188. GG (D, A, B, C, x [11], 9, 38016083)
     
189. GG (C, D, A, B, x [16], 14, -660478335)
     
190. GG (B, C, D, A, x [5], 20, -405537848)
     
191. GG (A, B, C, D, x [10], 5, 568446438)
     
192. GG (D, A, B, C, x [15], 9, -1019803690)
     
193. GG (C, D, A, B, x [4], 14, -187363961)
     
194. GG (B, C, D, A, x [9], 20, 1163531501)
     
195. GG (A, B, C, D, x [14], 5, -1444681467)
     
196. GG (D, A, B, C, x [3], 9, -51403784)
     
197. GG (C, D, A, B, x [8], 14, 1735328473)
     
198. GG (B, C, D, A, x [13], 20, -1926607734)
     
199. HH (A, B, C, D, x [6], 4, -378558)
     
200. HH (D, A, B, C, x [9], 11, -2022574463)
     
201. HH (C, D, A, B, x [12], 16, 1839030562)
     
202. HH (B, C, D, A, x [15], 23, -35309556)
     
203. HH (A, B, C, D, x [2], 4, -1530992060)
     
204. HH (D, A, B, C, x [5], 11, 1272893353)
     
205. HH (C, D, A, B, x [8], 16, -155497632)
     
206. HH (B, C, D, A, x [11], 23, -1094730640)
     
207. HH (A, B, C, D, x [14], 4, 681279174)
     
208. HH (D, A, B, C, x [1], 11, -358537222)
     
209. HH (C, D, A, B, x [4], 16, -722521979)
     
210. HH (B, C, D, A, x [7], 23, 76029189)
     
211. HH (A, B, C, D, x [10], 4, -640364487)
     
212. HH (D, A, B, C, x [13], 11, -421815835)
     
213. HH (C, D, A, B, x [16], 16, 530742520)
     
214. HH (B, C, D, A, x [3], 23, -995338651)
     
215. II (A, B, C, D, x [1], 6, -198630844)
     
216. II (D, A, B, C, x [8], 10, 1126891415)
     
217. II (C, D, A, B, x [15], 15, -1416354905)
     
218. II (B, C, D, A, x [6], 21, -57434055)
     
219. II (A, B, C, D, x [13], 6, 1700485571)
     
220. II (D, A, B, C, x [4], 10, -1894986606)
     
221. II (C, D, A, B, x [11], 15, -1051523)
     
222. II (B, C, D, A, x [2], 21, -2054922799)
     
223. II (A, B, C, D, x [9], 6, 1873313359)
     
224. II (D, A, B, C, x [16], 10, -30611744)
     
225. II (C, D, A, B, x [7], 15, -1560198380)
     
226. II (B, C, D, A, x [14], 21, 1309151649)
     
227. II (A, B, C, D, x [5], 6, -145523070)
     
228. II (D, A, B, C, x [12], 10, -1120210379)
     
229. II (C, D, A, B, x [3], 15, 718787259)
     
230. II (B, C, D, A, x [10], 21, -343485551)
     
231. AA ＝ AA ＋ A
     
232. BB ＝ BB ＋ B
     
233. CC ＝ CC ＋ C
     
234. DD ＝ DD ＋ D
     
235. 
     
236. 
     
237. .子程序 级联, 文本型
     
238. .参数 值1, 整数型
     
239. .参数 值2, 整数型
     
240. .参数 值3, 整数型
     
241. .参数 值4, 整数型
     
242. .局部变量 数据, 字节集
     
243. .局部变量 计数, 整数型
     
244. .局部变量 十六进制文本, 文本型
     
245. .局部变量 返回值, 文本型
     
246. 
     
247. 数据 ＝ 到字节集 (值1) ＋ 到字节集 (值2) ＋ 到字节集 (值3) ＋ 到字节集 (值4)
     
248. 十六进制文本 ＝ “0123456789abcdef”
     
249. 返回值 ＝ “”
     
250. .计次循环首 (16, 计数)
     
251.     返回值 ＝ 返回值 ＋ 取文本中间 (十六进制文本, 右移 (数据 [计数], 4) ＋ 1, 1) ＋ 取文本中间 (十六进制文本, 位与 (数据 [计数], 15) ＋ 1, 1)
     
252. .计次循环尾 ()
     
253. 返回 (返回值)
     
254. 
     
255. .子程序 字节集到整数, 整数型
     
256. .参数 字节集, 字节集
     
257. 
     
258. 返回 (合并整数 (合并短整数 (到字节 (字节集 [1]), 到字节 (字节集 [2])), 合并短整数 (到字节 (字节集 [3]), 到字节 (字节集 [4]))))
     
259. 
     
260. .子程序 字节集到整数数组
     
261. .参数 数据, 字节集
     
262. .参数 整数, 整数型, 参考 数组
     
263. .局部变量 长度, 整数型
     
264. .局部变量 计数, 整数型
     
265. 
     
266. 长度 ＝ 取字节集长度 (数据)
     
267. 重定义数组 (整数, 假, 0)
     
268. .变量循环首 (0, 长度 － 1, 4, 计数)
     
269.     加入成员 (整数, 字节集到整数 (取字节集中间 (数据, 计数 ＋ 1, 4)))
     
270. .变量循环尾 ()
     
271. 
     
272. .子程序 填充, 字节集
     
273. .参数 填充的数据, 字节集
     
274. .局部变量 位长, 长整数型
     
275. 
     
276. 位长 ＝ 取字节集长度 (填充的数据) × 8
     
277. 填充的数据 ＝ 填充的数据 ＋ { 128 }
     
278. .判断循环首 (取字节集长度 (填充的数据) ％ 64 ≠ 56)
     
279.     填充的数据 ＝ 填充的数据 ＋ { 0 }
     
280. .判断循环尾 ()
     
281. 填充的数据 ＝ 填充的数据 ＋ 到字节集 (位长)
     
282. 返回 (填充的数据)
     
283. 
     
284. .子程序 MD5, 文本型, 公开
     
285. .参数 字节集数据, 字节集
     
286. .局部变量 字节集, 字节集
     
287. .局部变量 整数分组数组, 整数型, , "0"
     
288. .局部变量 计数, 整数型
     
289. 
     
290. 初始化 ()
     
291. 字节集 ＝ 字节集数据
     
292. 字节集 ＝ 填充 (字节集)
     
293. .变量循环首 (1, 取字节集长度 (字节集), 64, 计数)
     
294.     字节集到整数数组 (取字节集中间 (字节集, 计数, 64), 整数分组数组)
     
295.     主要循环 (整数分组数组)
     
296. .变量循环尾 ()
     
297. 返回 (级联 (AA, BB, CC, DD))
     
298. 
     
299. 
     

复制代码

电脑高手

小萌 发表于 2018-2-21 11:15
貌似计算几百MB以上的数据可能会出错。

这个内存可能不够吧还是别的原因。

Cute

HNY 发表于 2018-2-21 22:05
测试了1mb的数据，比系统带的慢了N倍，没出现错误。

应该是循环左移的问题。

纸飞机

demon 发表于 2018-2-23 11:43
...这变量名，这子程序...

好像没什么问题的吧

电脑高手

5a5x那边计算这的都是借助js或vbs什么实现的，简直就是糊弄鬼了。

Cute

貌似计算几百MB以上的数据可能会出错。

1心1亿

看看咋实现的

4面8方

看来这玩意真能口算

小莉今年7岁

不错，正好需要

Kuni7wa

没想到如此简单

电脑高手

测试了1mb的数据，比系统带的慢了N倍，没出现错误。