RC4加解密算法python简单实现

Posted 2023-04-18

参考技术A 序列密码又称流密码，原理是明文流和密钥流按顺序逐位异或运算，从而产出密文流，序列密码属于对合运算。

以下是典型的序列密码RC4的加解密算法实现。其中秘钥流产生算法由RSA和PRGA两个核心子算法组成。

其中引用了FrankTools模块中的ItoB, XOR, StoB, BtoS, swap函数，FrankTools模块中将常用函数打包以便调用，展示如下：

水平和精力所限，疏漏之处难免，欢迎各位多多不吝赐教！
[e-mail]

RC4算法

RC4算法简介:https://baike.baidu.com/item/RC4%E7%AE%97%E6%B3%95/9686396?fr=aladdin

 

RC4算法java实现:

/**
 * RC4加解密算法
 * RC4对称性加密解密算法
 */
public class RC4 {

    /**
     * 解密后的数据为String类型
     *
     * @param data
     * @param key
     * @return
     */
    public static String decryRC4Str(byte[] data, String key) {
        if (data == null || key == null) {
            return null;
        }
        return asString(RC4Base(data, key));
    }

    /**
     * 解密后的数据为String类型
     *
     * @param data
     * @param key
     * @return
     */
    public static String decryRC4Str(String data, String key) {
        if (data == null || key == null) {
            return null;
        }
        return new String(RC4Base(hexString2Bytes(data), key));
    }

    /**
     * 解密后的数据为byte[]类型
     *
     * @param data
     * @param key
     * @return
     */
    public static byte[] decryRC4Byte(byte[] data, String key) {
        if (data == null || key == null) {
            return null;
        }
        return RC4Base(data, key);
    }

    /**
     * 加密后的数据为byte[]类型
     *
     * @param data
     * @param key
     * @return
     */
    public static byte[] encryRC4Byte(String data, String key) {
        if (data == null || key == null) {
            return null;
        }
        byte b_data[] = data.getBytes();
        return RC4Base(b_data, key);
    }

    /**
     * 加密后的数据为String类型
     *
     * @param data
     * @param key
     * @return
     */
    public static String encryRC4Str(String data, String key) {
        if (data == null || key == null) {
            return null;
        }
        return toHexString(asString(encryRC4Byte(data, key)));
    }

    /**
     * 将byte[]转化成String类型
     *
     * @param buf
     * @return
     */
    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();
    }

    /**
     * 初始计算Key
     *
     * @param aKey
     * @return
     */
    private static byte[] prepareKey(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;
    }

    /**
     * 将String转化成16进制的String
     *
     * @param s
     * @return
     */
    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表示十六进制
    }

    /**
     * 将String转换成byte[]
     *
     * @param src
     * @return
     */
    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;
    }

    /**
     * byte的异或
     *
     * @param src0
     * @param src1
     * @return
     */
    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;
    }

    /**
     * RC4算法核心
     *
     * @param input
     * @param mKkey
     * @return
     */
    private static byte[] RC4Base(byte[] input, String mKkey) {
        int x = 0;
        int y = 0;
        byte key[] = prepareKey(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;
    }
}