1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
package com.vci.server.volume.delegate;
 
public class RC4 {
 
     public static String decry_RC4(byte[] data, String key) {
            if (data == null || key == null) {
                return null;
            }
            return asString(RC4Base(data, key));
        }
       
       
        public static String decry_RC4(String data, String key) {
            if (data == null || key == null) {
                return null;
            }
            return new String(RC4Base(HexString2Bytes(data), key));
        }
       
       
        public static byte[] encry_RC4_byte(String data, String key) {
            if (data == null || key == null) {
                return null;
            }
            byte b_data[] = data.getBytes();
            return RC4Base(b_data, key);
        }
       
        public static byte[] encry_RC4_byte(byte[] b_data, String key) {
            if (b_data == null || key == null) {
                return null;
            }
           
            return RC4Base(b_data, key);
        }
       
        public static String encry_RC4_string(String data, String key) {
            if (data == null || key == null) {
                return null;
            }
            return toHexString(asString(encry_RC4_byte(data, key)));
        }
       
       
        private static String asString(byte[] buf) {
            StringBuffer strbuf = new StringBuffer(buf.length);
            for (int i = 0; i < buf.length; i++) {
                strbuf.append((char) buf[i]);
            }
            return strbuf.toString();
        }
       
 
        private static byte[] initKey(String aKey) {
            byte[] b_key = aKey.getBytes();
            byte state[] = new byte[256];
 
            for (int i = 0; i < 256; i++) {
                state[i] = (byte) i;
            }
            int index1 = 0;
            int index2 = 0;
            if (b_key == null || b_key.length == 0) {
                return null;
            }
            for (int i = 0; i < 256; i++) {
                index2 = ((b_key[index1] & 0xff) + (state[i] & 0xff) + index2) & 0xff;
                byte tmp = state[i];
                state[i] = state[index2];
                state[index2] = tmp;
                index1 = (index1 + 1) % b_key.length;
            }
            return state;
        }
       
        private static String toHexString(String s) {
            String str = "";
            for (int i = 0; i < s.length(); i++) {
                int ch = (int) s.charAt(i);
                String s4 = Integer.toHexString(ch & 0xFF);
                if (s4.length() == 1) {
                    s4 = '0' + s4;
                }
                str = str + s4;
            }
            return str;// 0x��ʾʮ�����
        }
       
       
        private static byte[] HexString2Bytes(String src) {
            int size = src.length();
            byte[] ret = new byte[size / 2];
            byte[] tmp = src.getBytes();
            for (int i = 0; i < size / 2; i++) {
                ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
            }
            return ret;
        }
       
        private static byte uniteBytes(byte src0, byte src1) {
            char _b0 = (char)Byte.decode("0x" + new String(new byte[] { src0 }))
                    .byteValue();
            _b0 = (char) (_b0 << 4);
            char _b1 = (char)Byte.decode("0x" + new String(new byte[] { src1 }))
                    .byteValue();
            byte ret = (byte) (_b0 ^ _b1);
            return ret;
        }
       
        private static byte[] RC4Base (byte [] input, String mKkey) {
            int x = 0;
            int y = 0;
            byte key[] = initKey(mKkey);
            int xorIndex;
            byte[] result = new byte[input.length];
 
            for (int i = 0; i < input.length; i++) {
                x = (x + 1) & 0xff;
                y = ((key[x] & 0xff) + y) & 0xff;
                byte tmp = key[x];
                key[x] = key[y];
                key[y] = tmp;
                xorIndex = ((key[x] & 0xff) + (key[y] & 0xff)) & 0xff;
                result[i] = (byte) (input[i] ^ key[xorIndex]);
            }
            return result;
        }
    }