符合Java特性的RC4加密算法

无限软件

稍稍使用了一下精易模块（进制_十六到十 等）。
起源：最近在分析基于E4A编写的安卓程序，于是就看到了E4A的rc4实现类，正好那个程序调用了这个加密，提取出加密代码作为java程序编译运行，加密结果跟易语言真的是……说天差地远应该也没什么问题。
所以说，这个加密是翻译java代码来的，不是真正自己写的。
（PS：这次翻译又进一步体会到易语言的索引“从1开始”给我带来的巨大不便……）
这个算法应该是和E4A的“RC4加密”“RC4解密”没有什么差别的，应该可以用在易语言程序和E4A程序的互相通讯上作为加密手段使用。
最后，关于子程序内部参数/变量名称混乱无逻辑，主要是因为JEB反编译出来的Java代码也是没有参数/变量名的，属于自动生成的名称（argX为参数，vX为变量）。
算法区：

  

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

变量名	类 型	静态	数组	备 注
i	整数型
temp	字节集

计次循环首 (取数组成员数 (arg), i)
temp ＝ temp ＋ 到字节集 (arg [i])
计次循环尾 ()
返回 (temp)

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

变量名	类 型	静态	数组	备 注
i	整数型
temp	字节型		0

计次循环首 (取字节集长度 (arg), i)
加入成员 (temp, 取字节集数据 (arg, 1, i))
计次循环尾 ()
re ＝ temp

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

变量名	类 型	静态	数组	备 注
i	整数型
temp	文本型

计次循环首 (取数组成员数 (arg), i)
temp ＝ temp ＋ arg [i]
计次循环尾 ()
返回 (temp)

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

' 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()))));
' }
返回 (到字节 (位异或 (左移 (进制_十六到十 (字符 (arg8)), 4), 进制_十六到十 (字符 (arg9)))))

子程序名	返回值类型	公开	备 注
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;
' }

.版本 2<br /> <br /> .子程序 字节数组到字节集, 字节集<br /> .参数 arg, 字节型, 数组<br /> .局部变量 i, 整数型<br /> .局部变量 temp, 字节集<br /> <br /> .计次循环首 (取数组成员数 (arg), i)<br />     temp ＝ temp ＋ 到字节集 (arg <i>)<br /> .计次循环尾 ()<br /> 返回 (temp)<br /> <br /> .子程序 字节集到字节数组<br /> .参数 arg, 字节集<br /> .参数 re, 字节型, 参考 数组<br /> .局部变量 i, 整数型<br /> .局部变量 temp, 字节型, , "0"<br /> <br /> .计次循环首 (取字节集长度 (arg), i)<br />     加入成员 (temp, 取字节集数据 (arg, 1, i))<br /> .计次循环尾 ()<br /> re ＝ temp<br /> <br /> .子程序 字符数组到文本, 文本型<br /> .参数 arg, 文本型, 数组<br /> .局部变量 i, 整数型<br /> .局部变量 temp, 文本型<br /> <br /> .计次循环首 (取数组成员数 (arg), i)<br />     temp ＝ temp ＋ arg <i><br /> .计次循环尾 ()<br /> 返回 (temp)<br /> <br /> .子程序 uniteBytes, 字节型<br /> .参数 arg8, 字节型<br /> .参数 arg9, 字节型<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 /> 返回 (到字节 (位异或 (左移 (进制_十六到十 (字符 (arg8)), 4), 进制_十六到十 (字符 (arg9)))))<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 /> <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 /> <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 /> ' }

忽略了所有try-catch结构和部分非空（!=null）判断，可能比较随意，也没什么大问题，自己优化吧。
预告：目前正在翻译论坛的易代码插件（dz内部名称ecode）……

a37755406

支持。。。。。虽然没有看是什么。。。。

q1091438980

看不懂  ······

Tz勿忘心安

最近在分析基于E4A编写的安卓程序，于是就看到了E4A的rc4实现类，正好那个程序调用了这个加密，提取出加密代码作为java程序编译运行，加密结果跟易语言真的是……说天差地远应该也没什么问题。

jjjhu

看看咯

大白哈尼

先下下来研究

sd3970566

RC4加密时效率太慢了,500KB的文本要加密个3分钟。。能否更快一些。