RC4加密算法初次接触以及深入学习

简单介绍:
RC4加密算法是大名鼎鼎的RSA三人组中的头号人物Ron Rivest在1987年设计的密钥长度可变的流加密算法簇。RC4算法是一种在电子信息领域加密的技术手段,用于无线通信网络,是一种电子密码,只有经过授权(缴纳相应费用)的用户才能享受该服务。和DES算法一样,是一种对称加密算法,也就是说使用的密钥为单钥(或称为私钥)。但不同于DES的是,RC4不是对明文进行分组处理,而是字节流的方式依次加密明文中的每一个字节,解密的时候也是依次对密文中的每一个字节进行解密。( RC4是一种对称密码算法,它属于对称密码算法中的序列密码(streamcipher,也称为流密码),它是可变密钥长度,面向字节操作的流密码。流密码也属于对称密码,但与分组加密算法不同的是,流密码不对明文数据进行分组,而是用密钥生成与明文一样长短的密码流对明文进行加密,加解密使用相同的密钥。)

何为对称加密算法。

对称加密(也叫私钥加密)指加密和解密使用相同密钥的加密算法。有时又叫传统密码算法,就是加密密钥能够从解密密钥中推算出来,同时解密密钥也可以从加密密钥中推算出来。而在大多数的对称算法中,加密密钥和解密密钥是相同的,所以也称这种加密算法为秘密密钥算法或单密钥算法。它要求发送方和接收方在安全通信之前,商定一个密钥。对称算法的安全性依赖于密钥,泄漏密钥就意味着任何人都可以对他们发送或接收的消息解密,所以密钥的保密性对通信的安全性至关重要。


 RC4算法的特点是算法简单,运行速度快,而且密钥长度是可变的,可变范围为1-256字节(8-2048比特),在如今技术支持的前提下,当密钥长度为128比特时,用暴力法搜索密钥已经不太可行,所以可以预见RC4的密钥范围任然可以在今后相当长的时间里抵御暴力搜索密钥的攻击。实际上,如今也没有找到对于128bit密钥长度的RC4加密算法的有效攻击方法。
 简而言之就是:(1)、算法简洁易于软件实现,加密速度快,安全性比较高;(2)、密钥长度可变,一般用256个字节。


对称密码算法的工作方式有四种:电子密码本(ECB, electronic codebook)方式、密码分组链接(CBC, cipherblock chaining)方式、密文反馈(CFB, cipher-feedback)方式、输出反馈(OFB, output-feedback)方式。
RC4算法采用的是输出反馈工作方式,所以可以用一个短的密钥产生一个相对较长的密钥序列。
OFB方式的最大的优点是消息如果发生错误(这里指的是消息的某一位发生了改变,而不是消息的某一位丢失),错误不会传递到产生的密钥序列上;缺点是对插入攻击很敏感,并且对同步的要求比较高。
RC4的执行速度相当快,它大约是分块密码算法DES的5倍,是3DES的15倍,且比高级加密算法AES也快很多。RC4算法简单,实现容易。RC4的安全保证主要在于输入密钥的产生途径,只要在这方面不出现漏洞,采用128bit的密钥是非常安全的。


RC4算法中几个关键变量:
1. 密钥流:RC4算法的关键是根据明文和密钥生成相应的密钥流,密钥流的长度和明文的长度是对应的,也就是说明文的长度是500字节,那么密钥流也是500字节。当然,加密生成的密文也是500字节,因为密文第i字节=明文第i字节^密钥流第i字节;
2. 状态向量S:长度为256,S[0],S[1]…..S[255]。每个单元都是一个字节,算法运行的任何时候,S都包括0-255的8比特数的排列组合,只不过值的位置发生了变换;
3. 临时向量T:长度也为256,每个单元也是一个字节。如果密钥的长度是256字节,就直接把密钥的值赋给T,否则,轮转地将密钥的每个字节赋给T;
4. 密钥K:长度为1-256字节,注意密钥的长度keylen与明文长度、密钥流的长度没有必然关系,通常密钥的长度取为16字节(128比特)。

加密原理详细介绍:
1 , 通过密钥调度算法KSA初始化状态矢量S(S就是一个随机数发生器,称为S-box)
2 , 再通过伪随机数生成算法PRGA得到密钥流keystream
3 , 密钥流keystream 与明文进行xor运算得到密文,解密用 密钥流与密文xor

1.KSA

RC4首先使用密钥调度算法(KSA)来完成对大小为256的字节数组S(s-box)初始化及替换。在替换时使用密钥。其密钥长度一般取5~16字节,即40~128位,也可以更长,通常不超过256位。首先用0~255初始化数组S,然后使用密钥进行替换。
这里写图片描述

2.PRGA

数组S在完成初始化之后,输入密钥便不再被使用。密钥流的生成是从S[0]~S[255],对每个S[i],根据当前S的值,将S[i]与S中的另一字节置换。当S[255]完成转换后,操作继续重复执行。

得到的子密码k用以和明文进行XOR运算,得到密文,解密过程也完全相同。
这里写图片描述

接下来给出RC4加密算法的Java实现:

public class RC4Demo {
     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 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 = null;
            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;
        }

        public static void main(String[] args){
            String inputStr = "RC4加密Demo";
            String key = "12341234567";
            String str = encry_RC4_string(inputStr, key);
            System.out.println(str);
            System.out.println(decry_RC4(str, key));
        }
  结果如下: 71ebbdd59b476483406d01d507  //加密前
            RC4加密Demo        //加密后
}

上边的这种Java代码,是商业级的,把所需的全部封装好了。但是用在移动端性能比较差。因此给出下面这种加密方法,适合移动端。

package cn.exercise.bianchengTest;

public class RC4test3 {

    public static String RC4Encry(String aInput, String aKey) {
        int[] iS = new int[256];
        byte[] iK = new byte[256];
        /*初始化S盒*/ 
        for (int i = 0; i < 256; i++)
            iS[i] = i;

        int j = 1;
        /*密钥填充256数组*/  
        for (int i = 0; i < 256; i++) {
            iK[i] = (byte) aKey.charAt((i % aKey.length()));
        }

        j = 0;
        /*打乱S盒*/  
        for (int i = 0; i < 255; i++) {
            j = (j + iS[i] + iK[i]) % 256;
            int temp = iS[i];
            iS[i] = iS[j];
            iS[j] = temp;
        }
        /*加解密数据*/   
        int i = 0;
        j = 0;
        char[] iInputChar = aInput.toCharArray();
        char[] iOutputChar = new char[iInputChar.length];
        for (int x = 0; x < iInputChar.length; x++) {
            i = (i + 1) % 256;
            j = (j + iS[i]) % 256;
            int temp = iS[i];
            iS[i] = iS[j];
            iS[j] = temp;
            int t = (iS[i] + (iS[j] % 256)) % 256;
            int iY = iS[t];
            char iCY = (char) iY;
            iOutputChar[x] = (char) (iInputChar[x] ^ iCY);
        }

        return new String(iOutputChar);

    }

    public static String RC4DeEncry(String aInput, String aKey) {
        String rc4Encry = RC4Encry(aInput, aKey);
        return rc4Encry;
    }

    public static void main(String[] args) {
        String inputStr = "一二三四五一二三四五一二三四五一二三四五一二三四五一二三四五";
        String key = "abcdefg";
        //执行加密操作
        String str = RC4Encry(inputStr, key);
        //执行解密操作
        String result = RC4DeEncry(str, key);

        // 打印加密后的字符串
        System.out.println(str);
        // 打印解密后的字符串
        System.out.println(result);
    }

}

结果如下: 仵亵乏嚫丠仝丿亄噉丑丽亟仏嘎乣义久乙噚仍乯严乤嘛亊产任亹嘰仩   //打印加密后的字符串      
          一二三四五一二三四五一二三四五一二三四五一二三四五一二三四五    //打印解密后的字符串     

最后也是最重要的一点,本人设计出了可用于多线程的RC4加密算法,等毕设做完就开源出来。

  • 2
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
RC4加密算法是一种流密码(stream cipher)算法,它以对称密钥的方式对数据进行加密。以下是使用C语言实现RC4加密算法的示例代码: ```c #include <stdio.h> #include <string.h> void swap(unsigned char *a, unsigned char *b) { unsigned char temp = *a; *a = *b; *b = temp; } void rc4(unsigned char *key, unsigned char *data, int data_length) { unsigned char s[256]; int i, j = 0, k; // 初始化S盒 for (i = 0; i < 256; i++) { s[i] = i; } // 根据密钥打乱S盒 for (i = 0; i < 256; i++) { j = (j + s[i] + key[i % strlen(key)]) % 256; swap(&s[i], &s[j]); } // 加密/解密数据 i = j = 0; for (k = 0; k < data_length; k++) { i = (i + 1) % 256; j = (j + s[i]) % 256; swap(&s[i], &s[j]); data[k] ^= s[(s[i] + s[j]) % 256]; } } int main() { unsigned char key[] = "mykey"; unsigned char data[] = "Hello, world!"; int data_length = strlen(data); printf("原始数据: %s\n", data); rc4(key, data, data_length); printf("加密后的数据: "); for (int i = 0; i < data_length; i++) { printf("%02X ", data[i]); } printf("\n"); rc4(key, data, data_length); printf("解密后的数据: %s\n", data); return 0; } ``` 在这段代码中,我们首先定义了一个swap函数,用于交换两个字节的位置。然后,我们定义了rc4函数来实现RC4算法。在rc4函数中,我们首先初始化了一个256字节的S盒,并根据密钥打乱S盒的顺序。然后,我们使用打乱后的S盒来加密/解密数据。最后,我们在main函数中使用示例密钥和数据来进行加密和解密,并输出结果。 请注意,这只是一个简单的示例,实际使用中需要注意安全性和性能等方面的考虑。此外,RC4算法已经有一些已知的安全漏洞,在实际应用中可能需要选择更安全的加密算法

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Fighting_Boss_Hao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值