求大神优化一下论坛这个帖子的RC4加密500KB加密速度

sd3970566

https://bbs.125.la/forum.php?mod=viewthread&tid=13983317
我目前在用这个帖子的加解密算法。  加密短的没有问题  毫秒级别就好了··
但是我现在又想用他加密  文本文件。 大概100KB-500KB的大小。  实际测试  我电脑加密500KB大小文件的情况。加密最少要两三分钟···。太慢了。 要是能压缩到1分钟以内。或者是10秒以内就好了（解密只要1秒就解密成功了，加密我想过去应该也可以吧）。
PS： 不考虑换算法。我就喜欢这个加密！

jr21066

算法一窍不通.前边的转换修改了一下.
易语言的整数运算还是很快的.不一定非要用汇编

  

窗口程序集名	保 留	保 留	备 注
程序集1

子程序名	返回值类型	公开	备 注
_启动子程序	整数型		本子程序在程序启动后最先执行

变量名	类 型	静态	数组	备 注
内容	字节集
数组1	字节型		0
文本数组	文本型		0

内容 ＝ { 1, 2, 3, 4, 5, 6, 7, 8, 9 }
字节集到字节数组 (内容, 数组1)
调试输出 (数组1)
调试输出 (字节数组到字节集 (数组1))
文本数组 ＝ { “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9” }
调试输出 (字符数组到文本 (文本数组))
返回 (0)  ' 可以根据您的需要返回任意数值

子程序名	返回值类型	公开	备 注
字节数组到字节集	字节集
参数名	类 型	参考	可空	数组	备 注
参_字节数组	字节型

变量名	类 型	静态	数组	备 注
计数器	整数型
内存句柄	整数型
指针	整数型
大小	整数型
返回值	字节集

大小 ＝ 取数组成员数 (参_字节数组)
内存句柄 ＝ 申请内存 (大小, )
计次循环首 (大小, 计数器)
写到内存 (参_字节数组 [计数器], 内存句柄 ＋ 指针, )
指针 ＝ 指针 ＋ 1
计次循环尾 ()
返回值 ＝ 指针到字节集 (内存句柄, 大小)
释放内存 (内存句柄)
返回 (返回值)

子程序名	返回值类型	公开	备 注
字节集到字节数组
参数名	类 型	参考	可空	数组	备 注
参_字节集	字节集
参_字节数组	字节型

变量名	类 型	静态	数组	备 注
计数器	整数型
大小	整数型
指针	整数型

指针 ＝ 取变量数据地址 (参_字节集)
大小 ＝ 取字节集长度 (参_字节集)
重定义数组 (参_字节数组, 假, 大小)
计次循环首 (大小, 计数器)
参_字节数组 [计数器] ＝ 指针到字节 (指针 ＋ 计数器 － 1)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
字符数组到文本	文本型
参数名	类 型	参考	可空	数组	备 注
参_文本数组	文本型

变量名	类 型	静态	数组	备 注
计数器	整数型
大小	整数型
内存句柄	整数型
指针	整数型
返回值	文本型

大小 ＝ 取数组成员数 (参_文本数组)
内存句柄 ＝ 申请内存 (大小 ＋ 1, )
计次循环首 (大小, 计数器)
写到内存 (参_文本数组 [计数器], 内存句柄 ＋ 指针, )
指针 ＝ 指针 ＋ 1
计次循环尾 ()
返回值 ＝ 指针到文本 (内存句柄)
释放内存 (内存句柄)
返回 (返回值)

子程序名	返回值类型	公开	备 注
uniteBytes	字节型
参数名	类 型	参考	可空	数组	备 注
参数1	字节型
参数2	字节型

' private static byte uniteBytes(byte arg8, byte arg9) {
' return ((byte)((((char)((((char)Byte.decode("0x" + new String(new byte[]{arg8})).byteValue())) << 4))) ^ (((char)
' Byte.decode("0x" + new String(new byte[]{arg9})).byteValue()))));
' }
返回 (到字节 (位异或 (左移 (字节到整数 (参数1), 4), 字节到整数 (参数2))))

子程序名	返回值类型	公开	备 注
字节到整数	整数型
参数名	类 型	参考	可空	数组	备 注
参_字节	字节型

如果 (参_字节 ≤ 57)
返回 (参_字节 － 48)
返回 (参_字节 － 55)

子程序名	返回值类型	公开	备 注
HexString2Bytes	字节集
参数名	类 型	参考	可空	数组	备 注
arg7	文本型

变量名	类 型	静态	数组	备 注
v2	字节型		0
v3	整数型
v4	字节型		0
v1	整数型

' private static byte[] HexString2Bytes(String arg7) {
' byte[] v2;
' try {
' int v3 = arg7.length();
' v2 = new byte[v3 / 2];
' byte[] v4 = arg7.getBytes("GBK");
' int v1;
' for(v1 = 0; v1 < v3 / 2; ++v1) {
' v2[v1] = test.uniteBytes(v4[v1 * 2], v4[v1 * 2 + 1]);
' }
' }
' catch(Exception v0) {
' v0.printStackTrace();
' v2 = new byte[0];
' }
v3 ＝ 取文本长度 (arg7)
重定义数组 (v2, 假, v3 ÷ 2)
字节集到字节数组 (到字节集 (arg7), v4)
判断循环首 (v1 ＜ v3 ÷ 2)
v2 [v1 ＋ 1] ＝ uniteBytes (v4 [v1 × 2 ＋ 1], v4 [v1 × 2 ＋ 2])
v1 ＝ v1 ＋ 1
判断循环尾 ()
返回 (字节数组到字节集 (v2))
' return v2;
' }

子程序名	返回值类型	公开	备 注
initKey	字节集
参数名	类 型	参考	可空	数组	备 注
arg11	文本型

变量名	类 型	静态	数组	备 注
v7	字节集
v10	整数型
v0	字节型		0
v5	字节型		256
v2	整数型
v3	整数型
v4	整数型
v6	字节型

' private static byte[] initKey(String arg11) {
' byte[] v7 = null;
' int v10 = 256;
' try {
' byte[] v0 = arg11.getBytes("GBK");
' byte[] v5 = new byte[256];
' int v2;
' for(v2 = 0; v2 < v10; ++v2) {
' v5[v2] = ((byte)v2);
' }
v10 ＝ 256
字节集到字节数组 (到字节集 (arg11), v0)
判断循环首 (v2 ＜ v10)
v5 [v2 ＋ 1] ＝ 到字节 (v2)
v2 ＝ v2 ＋ 1
判断循环尾 ()
' int v3 = 0;
' int v4 = 0;
' if(v0 != null && v0.length != 0) {
' v2 = 0;
' }
' else {
' return v7;
' }
判断 (取数组成员数 (v0) ≠ 0)
v2 ＝ 0
返回 (v7)
' while(v2 < v10) {
' v4 = (v0[v3] & 255) + (v5[v2] & 255) + v4 & 255;
' byte v6 = v5[v2];
' v5[v2] = v5[v4];
' v5[v4] = v6;
' v3 = (v3 + 1) % v0.length;
' ++v2;
' }
判断循环首 (v2 ＜ v10)
v4 ＝ 位与 (位与 (v0 [v3 ＋ 1], 255) ＋ 位与 (v5 [v2 ＋ 1], 255) ＋ v4, 255)
v6 ＝ v5 [v2 ＋ 1]
v5 [v2 ＋ 1] ＝ v5 [v4 ＋ 1]
v5 [v4 ＋ 1] ＝ v6
v3 ＝ (v3 ＋ 1) ％ 取数组成员数 (v0)
v2 ＝ v2 ＋ 1
判断循环尾 ()
' return v5;
' }
' catch(Exception v1) {
' v1.printStackTrace();
' return v7;
' }
' }
返回 (字节数组到字节集 (v5))

子程序名	返回值类型	公开	备 注
RC4Base	字节集
参数名	类 型	参考	可空	数组	备 注
arg9	字节集
arg10	文本型

变量名	类 型	静态	数组	备 注
v4	整数型
v6	整数型
v1	字节型		0
v2	字节型		0
v0	整数型
v3	字节型

' private static byte[] RC4Base(byte[] arg9, String arg10) {
' int v4 = 0;
' int v6 = 0;
' byte[] v1 = 加密操作.initKey(arg10);
' byte[] v2 = new byte[arg9.length];
' int v0;
' for(v0 = 0; v0 < arg9.length; ++v0) {
' v4 = v4 + 1 & 255;
' v6 = (v1[v4] & 255) + v6 & 255;
' byte v3 = v1[v4];
' v1[v4] = v1[v6];
' v1[v6] = v3;
' v2[v0] = ((byte)(arg9[v0] ^ v1[(v1[v4] & 255) + (v1[v6] & 255) & 255]));
' }
' return v2;
' }
字节集到字节数组 (initKey (arg10), v1)
重定义数组 (v2, 假, 取字节集长度 (arg9))
判断循环首 (v0 ＜ 取字节集长度 (arg9))
v4 ＝ 位与 (v4 ＋ 1, 255)
v6 ＝ 位与 (位与 (v1 [v4 ＋ 1], 255) ＋ v6, 255)
v3 ＝ v1 [v4 ＋ 1]
v1 [v4 ＋ 1] ＝ v1 [v6 ＋ 1]
v1 [v6 ＋ 1] ＝ v3
v2 [v0 ＋ 1] ＝ 到字节 (位异或 (取字节集数据 (arg9, 1, v0 ＋ 1), v1 [位与 (位与 (v1 [v4 ＋ 1], 255) ＋ 位与 (v1 [v6 ＋ 1], 255), 255) ＋ 1]))
v0 ＝ v0 ＋ 1
判断循环尾 ()
返回 (字节数组到字节集 (v2))

子程序名	返回值类型	公开	备 注
RC4_Encode	文本型
参数名	类 型	参考	可空	数组	备 注
arg10	文本型				原文
arg11	文本型				密钥

变量名	类 型	静态	数组	备 注
v9	文本型
v0	字节型		0
v3	文本型		0
v5	整数型
v8	文本型		0
v4	整数型
v7	整数型
v1	整数型
v6	整数型

' @SimpleFunction public static String RC4加密(String arg10, String arg11) {
' String v9;
' if(arg10 != null && arg11 != null) {
' try {
' byte[] v0 = 加密操作.RC4Base(arg10.getBytes("GBK"), arg11);
' char[] v3 = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
' int v5 = v0.length;
' char[] v8 = new char[v5 * 2];
' int v4 = 0;
' int v7 = 0;
' while(v4 < v5) {
' int v1 = v0[v4];
' int v6 = v7 + 1;
' v8[v7] = v3[v1 >>> 4 & 15];
' v7 = v6 + 1;
' v8[v6] = v3[v1 & 15];
' ++v4;
' }
字节集到字节数组 (RC4Base (到字节集 (arg10), arg11), v0)
v3 ＝ { “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F” }
v5 ＝ 取数组成员数 (v0)
重定义数组 (v8, 假, v5 × 2)
判断循环首 (v4 ＜ v5)
v1 ＝ v0 [v4 ＋ 1]
v6 ＝ v7 ＋ 1
v8 [v7 ＋ 1] ＝ v3 [位与 (右移 (v1, 4), 15) ＋ 1]
v7 ＝ v6 ＋ 1
v8 [v6 ＋ 1] ＝ v3 [位与 (v1, 15) ＋ 1]
v4 ＝ v4 ＋ 1
判断循环尾 ()
' v9 = new String(v8);
' }
' catch(Exception v2) {
' v2.printStackTrace();
' v9 = "";
' }
' }
' else {
' v9 = "";
' }
v9 ＝ 字符数组到文本 (v8)
返回 (v9)
' return v9;
' }

子程序名	返回值类型	公开	备 注
RC4_Decode	文本型
参数名	类 型	参考	可空	数组	备 注
arg4	文本型				密文
arg5	文本型				密钥

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

' public static String RC4解密(String arg4, String arg5) {
' String v1;
' if(arg4 != null && arg5 != null) {
' try {
' v1 = new String(test.RC4Base(test.HexString2Bytes(arg4), arg5), "GBK");
' }
' catch(Exception v0) {
' v0.printStackTrace();
' v1 = "";
' }
' }
' else {
' v1 = "";
' }
v1 ＝ 到文本 (RC4Base (HexString2Bytes (arg4), arg5))
返回 (v1)
' return v1;
' }

子程序名	返回值类型	公开	备 注
指针到字节	字节型
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 程序集1<br /> <br /> .子程序 _启动子程序, 整数型, , 本子程序在程序启动后最先执行<br /> .局部变量 内容, 字节集<br /> .局部变量 数组1, 字节型, , "0"<br /> .局部变量 文本数组, 文本型, , "0"<br /> <br /> 内容 ＝ { 1, 2, 3, 4, 5, 6, 7, 8, 9 }<br /> 字节集到字节数组 (内容, 数组1)<br /> 调试输出 (数组1)<br /> 调试输出 (字节数组到字节集 (数组1))<br /> 文本数组 ＝ { “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9” }<br /> 调试输出 (字符数组到文本 (文本数组))<br /> 返回 (0)  ' 可以根据您的需要返回任意数值<br /> <br /> .子程序 字节数组到字节集, 字节集<br /> .参数 参_字节数组, 字节型, 数组<br /> .局部变量 计数器, 整数型<br /> .局部变量 内存句柄, 整数型<br /> .局部变量 指针, 整数型<br /> .局部变量 大小, 整数型<br /> .局部变量 返回值, 字节集<br /> <br /> 大小 ＝ 取数组成员数 (参_字节数组)<br /> 内存句柄 ＝ 申请内存 (大小, )<br /> .计次循环首 (大小, 计数器)<br />     写到内存 (参_字节数组 [计数器], 内存句柄 ＋ 指针, )<br />     指针 ＝ 指针 ＋ 1<br /> .计次循环尾 ()<br /> 返回值 ＝ 指针到字节集 (内存句柄, 大小)<br /> 释放内存 (内存句柄)<br /> 返回 (返回值)<br /> <br /> .子程序 字节集到字节数组<br /> .参数 参_字节集, 字节集<br /> .参数 参_字节数组, 字节型, 参考 数组<br /> .局部变量 计数器, 整数型<br /> .局部变量 大小, 整数型<br /> .局部变量 指针, 整数型<br /> <br /> 指针 ＝ 取变量数据地址 (参_字节集)<br /> 大小 ＝ 取字节集长度 (参_字节集)<br /> 重定义数组 (参_字节数组, 假, 大小)<br /> .计次循环首 (大小, 计数器)<br />     参_字节数组 [计数器] ＝ 指针到字节 (指针 ＋ 计数器 － 1)<br /> .计次循环尾 ()<br /> <br /> .子程序 字符数组到文本, 文本型<br /> .参数 参_文本数组, 文本型, 数组<br /> .局部变量 计数器, 整数型<br /> .局部变量 大小, 整数型<br /> .局部变量 内存句柄, 整数型<br /> .局部变量 指针, 整数型<br /> .局部变量 返回值, 文本型<br /> <br /> 大小 ＝ 取数组成员数 (参_文本数组)<br /> 内存句柄 ＝ 申请内存 (大小 ＋ 1, )<br /> .计次循环首 (大小, 计数器)<br />     写到内存 (参_文本数组 [计数器], 内存句柄 ＋ 指针, )<br />     指针 ＝ 指针 ＋ 1<br /> .计次循环尾 ()<br /> 返回值 ＝ 指针到文本 (内存句柄)<br /> 释放内存 (内存句柄)<br /> 返回 (返回值)<br /> <br /> <br /> .子程序 uniteBytes, 字节型<br /> .参数 参数1, 字节型<br /> .参数 参数2, 字节型<br /> <br /> ' private static byte uniteBytes(byte arg8, byte arg9) {<br /> ' return ((byte)((((char)((((char)Byte.decode("0x" + new String(new byte[]{arg8})).byteValue())) << 4))) ^ (((char)<br /> <br /> ' Byte.decode("0x" + new String(new byte[]{arg9})).byteValue()))));<br /> ' }<br /> <br /> 返回 (到字节 (位异或 (左移 (字节到整数 (参数1), 4), 字节到整数 (参数2))))<br /> <br /> .子程序 字节到整数, 整数型<br /> .参数 参_字节, 字节型<br /> <br /> .如果 (参_字节 ≤ 57)<br />     返回 (参_字节 － 48)<br /> .否则<br />     返回 (参_字节 － 55)<br /> .如果结束<br /> <br /> <br /> .子程序 HexString2Bytes, 字节集<br /> .参数 arg7, 文本型<br /> .局部变量 v2, 字节型, , "0"<br /> .局部变量 v3, 整数型<br /> .局部变量 v4, 字节型, , "0"<br /> .局部变量 v1, 整数型<br /> <br /> ' private static byte[] HexString2Bytes(String arg7) {<br /> ' byte[] v2;<br /> ' try {<br /> ' int v3 = arg7.length();<br /> ' v2 = new byte[v3 / 2];<br /> ' byte[] v4 = arg7.getBytes("GBK");<br /> ' int v1;<br /> ' for(v1 = 0; v1 < v3 / 2; ++v1) {<br /> ' v2[v1] = test.uniteBytes(v4[v1 * 2], v4[v1 * 2 + 1]);<br /> ' }<br /> ' }<br /> ' catch(Exception v0) {<br /> ' v0.printStackTrace();<br /> ' v2 = new byte[0];<br /> ' }<br /> v3 ＝ 取文本长度 (arg7)<br /> 重定义数组 (v2, 假, v3 ÷ 2)<br /> 字节集到字节数组 (到字节集 (arg7), v4)<br /> .判断循环首 (v1 ＜ v3 ÷ 2)<br />     v2 [v1 ＋ 1] ＝ uniteBytes (v4 [v1 × 2 ＋ 1], v4 [v1 × 2 ＋ 2])<br />     v1 ＝ v1 ＋ 1<br /> .判断循环尾 ()<br /> 返回 (字节数组到字节集 (v2))<br /> ' return v2;<br /> ' }<br /> <br /> .子程序 initKey, 字节集<br /> .参数 arg11, 文本型<br /> .局部变量 v7, 字节集<br /> .局部变量 v10, 整数型<br /> .局部变量 v0, 字节型, , "0"<br /> .局部变量 v5, 字节型, , "256"<br /> .局部变量 v2, 整数型<br /> .局部变量 v3, 整数型<br /> .局部变量 v4, 整数型<br /> .局部变量 v6, 字节型<br /> <br /> ' private static byte[] initKey(String arg11) {<br /> ' byte[] v7 = null;<br /> ' int v10 = 256;<br /> ' try {<br /> ' byte[] v0 = arg11.getBytes("GBK");<br /> ' byte[] v5 = new byte[256];<br /> ' int v2;<br /> ' for(v2 = 0; v2 < v10; ++v2) {<br /> ' v5[v2] = ((byte)v2);<br /> ' }<br /> v10 ＝ 256<br /> 字节集到字节数组 (到字节集 (arg11), v0)<br /> .判断循环首 (v2 ＜ v10)<br />     v5 [v2 ＋ 1] ＝ 到字节 (v2)<br />     v2 ＝ v2 ＋ 1<br /> .判断循环尾 ()<br /> ' int v3 = 0;<br /> ' int v4 = 0;<br /> ' if(v0 != null && v0.length != 0) {<br /> ' v2 = 0;<br /> ' }<br /> ' else {<br /> ' return v7;<br /> ' }<br /> .判断开始 (取数组成员数 (v0) ≠ 0)<br />     v2 ＝ 0<br /> .默认<br />     返回 (v7)<br /> .判断结束<br /> ' while(v2 < v10) {<br /> ' v4 = (v0[v3] & 255) + (v5[v2] & 255) + v4 & 255;<br /> ' byte v6 = v5[v2];<br /> ' v5[v2] = v5[v4];<br /> ' v5[v4] = v6;<br /> ' v3 = (v3 + 1) % v0.length;<br /> ' ++v2;<br /> ' }<br /> .判断循环首 (v2 ＜ v10)<br />     v4 ＝ 位与 (位与 (v0 [v3 ＋ 1], 255) ＋ 位与 (v5 [v2 ＋ 1], 255) ＋ v4, 255)<br />     v6 ＝ v5 [v2 ＋ 1]<br />     v5 [v2 ＋ 1] ＝ v5 [v4 ＋ 1]<br />     v5 [v4 ＋ 1] ＝ v6<br />     v3 ＝ (v3 ＋ 1) ％ 取数组成员数 (v0)<br />     v2 ＝ v2 ＋ 1<br /> .判断循环尾 ()<br /> ' return v5;<br /> ' }<br /> ' catch(Exception v1) {<br /> ' v1.printStackTrace();<br /> ' return v7;<br /> ' }<br /> ' }<br /> 返回 (字节数组到字节集 (v5))<br /> <br /> .子程序 RC4Base, 字节集<br /> .参数 arg9, 字节集<br /> .参数 arg10, 文本型<br /> .局部变量 v4, 整数型<br /> .局部变量 v6, 整数型<br /> .局部变量 v1, 字节型, , "0"<br /> .局部变量 v2, 字节型, , "0"<br /> .局部变量 v0, 整数型<br /> .局部变量 v3, 字节型<br /> <br /> ' private static byte[] RC4Base(byte[] arg9, String arg10) {<br /> ' int v4 = 0;<br /> ' int v6 = 0;<br /> ' byte[] v1 = 加密操作.initKey(arg10);<br /> ' byte[] v2 = new byte[arg9.length];<br /> ' int v0;<br /> ' for(v0 = 0; v0 < arg9.length; ++v0) {<br /> ' v4 = v4 + 1 & 255;<br /> ' v6 = (v1[v4] & 255) + v6 & 255;<br /> ' byte v3 = v1[v4];<br /> ' v1[v4] = v1[v6];<br /> ' v1[v6] = v3;<br /> ' v2[v0] = ((byte)(arg9[v0] ^ v1[(v1[v4] & 255) + (v1[v6] & 255) & 255]));<br /> ' }<br /> <br /> ' return v2;<br /> ' }<br /> 字节集到字节数组 (initKey (arg10), v1)<br /> 重定义数组 (v2, 假, 取字节集长度 (arg9))<br /> .判断循环首 (v0 ＜ 取字节集长度 (arg9))<br />     v4 ＝ 位与 (v4 ＋ 1, 255)<br />     v6 ＝ 位与 (位与 (v1 [v4 ＋ 1], 255) ＋ v6, 255)<br />     v3 ＝ v1 [v4 ＋ 1]<br />     v1 [v4 ＋ 1] ＝ v1 [v6 ＋ 1]<br />     v1 [v6 ＋ 1] ＝ v3<br />     v2 [v0 ＋ 1] ＝ 到字节 (位异或 (取字节集数据 (arg9, 1, v0 ＋ 1), v1 [位与 (位与 (v1 [v4 ＋ 1], 255) ＋ 位与 (v1 [v6 ＋ 1], 255), 255) ＋ 1]))<br />     v0 ＝ v0 ＋ 1<br /> .判断循环尾 ()<br /> 返回 (字节数组到字节集 (v2))<br /> <br /> .子程序 RC4_Encode, 文本型, 公开<br /> .参数 arg10, 文本型, , 原文<br /> .参数 arg11, 文本型, , 密钥<br /> .局部变量 v9, 文本型<br /> .局部变量 v0, 字节型, , "0"<br /> .局部变量 v3, 文本型, , "0"<br /> .局部变量 v5, 整数型<br /> .局部变量 v8, 文本型, , "0"<br /> .局部变量 v4, 整数型<br /> .局部变量 v7, 整数型<br /> .局部变量 v1, 整数型<br /> .局部变量 v6, 整数型<br /> <br /> ' @SimpleFunction public static String RC4加密(String arg10, String arg11) {<br /> ' String v9;<br /> ' if(arg10 != null && arg11 != null) {<br /> ' try {<br /> ' byte[] v0 = 加密操作.RC4Base(arg10.getBytes("GBK"), arg11);<br /> ' char[] v3 = new char[]{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};<br /> ' int v5 = v0.length;<br /> ' char[] v8 = new char[v5 * 2];<br /> ' int v4 = 0;<br /> ' int v7 = 0;<br /> ' while(v4 < v5) {<br /> ' int v1 = v0[v4];<br /> ' int v6 = v7 + 1;<br /> ' v8[v7] = v3[v1 >>> 4 & 15];<br /> ' v7 = v6 + 1;<br /> ' v8[v6] = v3[v1 & 15];<br /> ' ++v4;<br /> ' }<br /> 字节集到字节数组 (RC4Base (到字节集 (arg10), arg11), v0)<br /> v3 ＝ { “0”, “1”, “2”, “3”, “4”, “5”, “6”, “7”, “8”, “9”, “A”, “B”, “C”, “D”, “E”, “F” }<br /> v5 ＝ 取数组成员数 (v0)<br /> 重定义数组 (v8, 假, v5 × 2)<br /> .判断循环首 (v4 ＜ v5)<br />     v1 ＝ v0 [v4 ＋ 1]<br />     v6 ＝ v7 ＋ 1<br />     v8 [v7 ＋ 1] ＝ v3 [位与 (右移 (v1, 4), 15) ＋ 1]<br />     v7 ＝ v6 ＋ 1<br />     v8 [v6 ＋ 1] ＝ v3 [位与 (v1, 15) ＋ 1]<br />     v4 ＝ v4 ＋ 1<br /> .判断循环尾 ()<br /> ' v9 = new String(v8);<br /> ' }<br /> ' catch(Exception v2) {<br /> ' v2.printStackTrace();<br /> ' v9 = "";<br /> ' }<br /> ' }<br /> ' else {<br /> ' v9 = "";<br /> ' }<br /> v9 ＝ 字符数组到文本 (v8)<br /> 返回 (v9)<br /> ' return v9;<br /> ' }<br /> <br /> .子程序 RC4_Decode, 文本型, 公开<br /> .参数 arg4, 文本型, , 密文<br /> .参数 arg5, 文本型, , 密钥<br /> .局部变量 v1, 文本型<br /> <br /> ' public static String RC4解密(String arg4, String arg5) {<br /> ' String v1;<br /> ' if(arg4 != null && arg5 != null) {<br /> ' try {<br /> ' v1 = new String(test.RC4Base(test.HexString2Bytes(arg4), arg5), "GBK");<br /> ' }<br /> ' catch(Exception v0) {<br /> ' v0.printStackTrace();<br /> ' v1 = "";<br /> ' }<br /> ' }<br /> ' else {<br /> ' v1 = "";<br /> ' }<br /> v1 ＝ 到文本 (RC4Base (HexString2Bytes (arg4), arg5))<br /> 返回 (v1)<br /> ' return v1;<br /> ' }<br /> <br /> .子程序 指针到字节, 字节型, 公开<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)

sd3970566

@lyjdgkg @zxw0402 @枫叶果果吖 @jiang910615 @花老板 @r11111 @1565030103
爱特一波汇编相关大神···

53770zhang

@jr21066 和@cf006a 也很厉害

zxw0402

可以是可以,但是,做汇编是一件费时费精力的事情,这个如果对我自己来说没有价值而特意去研究的话,感觉心思放不上去.因为最近颈椎病原因,所以不太愿意用空余时间再去研究,同时这里也提醒一下各位易友,经常坐电脑旁边,记得多做抬头摇头动作,谨防颈椎病

sd3970566

zxw0402 发表于 2020-11-22 18:56
可以是可以,但是,做汇编是一件费时费精力的事情,这个如果对我自己来说没有价值而特意去研究的话,感觉心思放 ...

能不能 就把原帖里 最浪费速度的地方微调一下。  全部都改确实麻烦。 改一两处极其浪费速度的地方就行了呀···大神颈椎好了之后 帮帮忙啦。。。   我也颈椎病 不过不是写代码导致的。是躺在床上玩手机玩太迟。 长期几次就出现 。严重时 出现 平躺起身天旋地转的感觉，都不敢躺下睡觉了· 医生说是颈椎压迫神经。   怕死的我 天天做广播··过了几天就恢复了。·

sd3970566

@cf006a @jr21066

madfrag

不全改很难提速,HexString2Bytes 这个有现成的
有好几个版本,大多是混合版本,找纯汇编的(没有一句易语言代码的那种)

jr21066

又修改了  HexString2Bytes

后边的计算看起来头痛.不搞了.

sd3970566

jr21066 发表于 2020-11-22 20:45
又修改了  HexString2Bytes

后边的计算看起来头痛.不搞了.

真心牛逼。原来要600秒的。 现在只要60秒了。···  还能不能再快点··