RC4加解密JAVA程序使用说明
RC4加密解密算法原理与完整源代码实例演示
RC4加密解密算法原理与完整源代码实例演⽰RC4加密算法是⼤名⿍⿍的RSA三⼈组中的头号⼈物Ron Rivest在1987年设计的密钥长度可变的流加密算法簇。
之所以称其为簇，是由于其核⼼部分的S-box长度可为任意，但⼀般为256字节。
该算法的速度可以达到加密的10倍左右，且具有很⾼级别的⾮线性。
RC4起初是⽤于保护商业机密的。
但是在1994年9⽉，它的算法被发布在互联⽹上，也就不再有什么商业机密了。
RC4也被叫做ARC4（Alleged RC4——所谓的RC4），因为RSA从来就没有正式发布过这个算法。
原理RC4算法的原理很简单，包括初始化算法（KSA）和伪随机⼦密码⽣成算法（PRGA)两⼤部分。
假设S-box的长度为256，密钥长度为Len。
先来看看算法的初始化部分（⽤C代码表⽰）：其中，参数1是⼀个256长度的char型数组，定义为: unsigned char sBox[256];参数2是密钥，其内容可以随便定义：char key[256];参数3是密钥的长度，Len = strlen(key);void rc4_init(unsigned char *s, unsigned char *key, unsigned long Len){int i =0, j = 0, k[256] = {0};unsigned char tmp = 0;for(i=0;i<256;i++){s[i]=i;k[i]=key[i%Len];}for (i=0; i<256; i++){j=(j+s[i]+k[i])%256;tmp = s[i];s[i] = s[j]; //交换s[i]和s[j]s[j] = tmp;}}在初始化的过程中，密钥的主要功能是将S-box搅乱，i确保S-box的每个元素都得到处理，j保证S-box的搅乱是随机的。
⽽不同的S-box在经过伪随机⼦密码⽣成算法的处理后可以得到不同的⼦密钥序列，将S-box和明⽂进⾏xor运算，得到密⽂，解密过程也完全相同。
RC4加密解密算法123
RC4加密解密算法123RC4是⼀种对称密码，它属于对称密码算法中的序列密码(streamcipher,也称为流密码)，它是可变密钥长度，⾯向字节操作的流密码。
RC4是流密码streamcipher中的⼀种，为序列密码。
RC4加密算法是Ron Rivest在1987年设计出的密钥长度可变的加密算法簇。
起初该算法是商业机密，直到1994年，它才公诸于众。
由于RC4具有算法简单，运算速度快，软硬件实现都⼗分容易等优点，使其在⼀些协议和标准⾥得到了⼴泛应⽤。
流密码也属于对称密码，但与分组加密算法不同的是，流密码不对明⽂数据进⾏分组，⽽是⽤密钥⽣成与明⽂⼀样长短的密码流对明⽂进⾏加密，加解密使⽤相同的密钥。
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算法加密流程：包括密钥调度算法KSA和伪随机⼦密码⽣成算法PRGA两⼤部分(以密钥长度为256个字节为例)。
实验9使用RC4进行数据加密和解密
实验9 RC4算法
一实验目的
1了解RC4算法的过程；
2使用RC4 算法对数据进行加密和解密。
二实验原理
1RC4算法是一种序列密码体制(或称流密码体制)，其加密密钥和解密密钥相同。
2RC4的密钥长度可变，但是为了保证安全强度,目前RC4至少使用128位的密钥。
三实验步骤
1RC4有两个主要的算法：________和__________。
2密钥调度算法的作用是将一个随机密钥变换成一个初始置换，即相当于初始化状态矢量S盒；
3伪随机数生成算法的作用是利用初始置换S盒生成一个伪随机数输出序列。
4下载RC4.rar
5通过输入密钥来运行RC4加密（解密）程序
两人一组完成实验，每次实验一个同学负责加密，另一个同学负责解密。
①A同学在D盘下新建一个文件夹，命名为自己的姓名，在这个文件夹
下新建一个1.txt文档，选择下表中第一个明文进行实验，将加密后的
文档发给B同学；
B同学对收到的文档进行解密。
②B同学在D盘下新建一个文件夹，命名为自己的姓名，在这个文件夹
下新建一个11.txt文档，选择下表中第二个明文进行实验，将加密后的
文档发给A同学；
A同学对收到的文档进行解密。
③两个同学对第三个明文进行实验，观察密钥的长度
（提示：为了保证安全强度,目前RC4至少使用128位的密钥，即16字节，本程序中给出的密钥长度最短长度为16个字节，如果你加密的密钥长度小于16个字节，计算机处理的时候自动在后面添加0，补足16个字节；如果你所给的密钥长度大于16个字节，则计算机只处理前面16个字节，注意加解密过程中密钥的一致性）。
c#rc4算法，加密解密类
c#rc4算法，加密解密类rc4算法，原理，以密匙⽣成256位的密匙流，然后以车轮式滚过源数据异或加密。
1/*2 * 由SharpDevelop创建。
3 * ⽤户： YISH4 * ⽇期: 04/04/20155 * 时间: 03:016 *7 * 要改变这种模板请点击⼯具|选项|代码编写|编辑标准头⽂件8*/9using System;1011namespace Libraries12 {13///<summary>14/// Description of CryptoGraphy.15///</summary>16public class RC4Crypt:IDisposable{17byte[] S;18byte[] T;19byte[] K;20byte[] k;21public RC4Crypt() { }22public RC4Crypt(byte[] key){23this.K=key;24 }25public byte[] Key26 {27get28 {29return K;30 }31set32 {33 K = value;34 }35 }36//初始化状态向量S和临时向量T，供keyStream⽅法调⽤37void initial(){38if (S == null || T == null)39 {40 S = new byte[256];41 T = new byte[256];42 }43for (int i = 0; i < 256; ++i) {44 S[i]=(byte)i;45 T[i] = K[i % K.Length];46 }47 }48//初始排列状态向量S，供keyStream⽅法调⽤49void ranges(){50int j=0;51for (int i = 0; i < 256; ++i) {52 j=(j+S[i]+T[i])&0xff;53 S[i]=(byte)((S[i]+S[j])&0xff);54 S[j]=(byte)((S[i]-S[j])&0xff);55 S[i]=(byte)((S[i]-S[j])&0xff);56 }57 }58//⽣成密钥流59//len:明⽂为len个字节60void keyStream(int len){61 initial();62 ranges();63int i=0,j=0,t=0;64 k=new byte[len];65for (int r = 0; r < len; r++) {66 i=(i+1)&0xff;67 j=(j+S[i])&0xff;6869 S[i]=(byte)((S[i]+S[j])&0xff);70 S[j]=(byte)((S[i]-S[j])&0xff);71 S[i]=(byte)((S[i]-S[j])&0xff);7273 t=(S[i]+S[j])&0xff;74 k[r]=S[t];75 }76 }7778public byte[] EncryptByte(byte[] data){79//⽣产密匙流80 keyStream(data.Length);81for (int i = 0; i < data.Length; i++) {82 k[i]=(byte)(data[i]^k[i]);83 }84return k;85 }8687public byte[] DecryptByte(byte[] data){88return EncryptByte(data);89 }9091//是否回收完毕92bool _disposed;93public void Dispose()94 {95 Dispose(true);96 GC.SuppressFinalize(this);97 }98 ~RC4Crypt()99 {100 Dispose(false);101 }102//这⾥的参数表⽰⽰是否需要释放那些实现IDisposable接⼝的托管对象103protected virtual void Dispose(bool disposing)104 {105if (_disposed) return;//如果已经被回收，就中断执⾏106if (disposing)107 {108//TODO:释放那些实现IDisposable接⼝的托管对象109110 }111//TODO:释放⾮托管资源，设置对象为null112 S = null;113 T = null;114 K = null;115 k = null;116 _disposed = true;117 }118 }119 }。
RC4加密解密算法工具类-Java语言实现
RC4加密解密算法⼯具类-Java语⾔实现摘要 RC4加密解密算法是⼯具类是⼤名⿍⿍的 RSA三⼈组中的头号⼈物Ron Rivest设计的，可以有效抵御暴⼒搜索密钥的攻击。
鉴于此，提供⼀个由Java语⾔实现的⼯具类。
前⾔ RC4加密算法是⼤名⿍⿍的 RSA三⼈组中的头号⼈物Ron Rivest在1987年设计的密钥长度可变的流加密算法簇。
之所以称其为簇，是因为其核⼼部分的S-box长度可为任意长度，但⼀般为256字节。
RC4算法是⼀种对称加密算法，所谓对称加密，就是加密和解密的过程是⼀样的。
RC4算法的特点是算法简单，执⾏速度快。
并且密钥长度是可变的，可变范围为1-256字节(8-2048⽐特)，在现在技术⽀持的前提下，当密钥长度为128bit时，⽤暴⼒法搜索密钥已经不太可⾏，所以能够预见RC4的密钥范围仍然能够在今后相当长的时间⾥抵御暴⼒搜索密钥的攻击。
实际上，现在也没有找到对于128bit密钥长度的RC4加密算法的有效攻击⽅法。
算法实现package com.eg.wiener.utils;import java.io.UnsupportedEncodingException;import java.util.UUID;/*** RC4加解密算法⼯具类** @author Wiener* @date 2020/11/17*/public class RC4Util {private static String CHARSET = "UTF-8";public static String decry_RC4(byte[] data, String key) {if (data == null || key == null) {return null;}return asString(RC4Base(data, key));}/*** 解密* @param data* @param key* @return*/public static String decry_RC4(String data, String key) {if (data == null || key == null) {return null;}return new String(RC4Base(HexString2Bytes(data), key));}/*** 加密，返回字节流* @param data* @param key* @return*/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);}/*** 加密，返回密⽂* @param data 明⽂* @param key 密钥* @return 密⽂*/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 = null;try {b_key = aKey.getBytes(CHARSET);} catch (UnsupportedEncodingException e) {e.printStackTrace();}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;}public static void main(String[] args) {String key = "myKey";String encryStr = encry_RC4_string(String.format("%03d", 12333201), key);System.out.println(encryStr);System.out.println(decry_RC4(encryStr, key));}/*** ⽣成6位密⽂* @param data 明⽂，可以为⽤户id等* @param key 密钥* @return*/public static String m4Rc4Encrypt(int data, String key) {if (null == key) {key = UUID.randomUUID().toString();}return encry_RC4_string(String.format("%03d", data), key);// String.format("%03d", i) 主要实现位数不够前⾯补零。
java 加解密方法
java 加解密方法在Java中，可以使用以下方法进行加密和解密：1. 对称加密算法：对称加密算法使用相同的密钥进行加密和解密。
常见的对称加密算法包括AES（高级加密标准）和DES （数据加密标准）。
以下是一个使用AES算法进行加密解密的示例：```javaimport javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import java.nio.charset.StandardCharsets;import java.util.Base64;public class SymmetricEncryption {private static final String AES_ALGORITHM = "AES";private static final String ENCRYPTION_KEY = "0123456789abcdef";public static String encrypt(String plaintext) throws Exception { SecretKeySpec keySpec = newSecretKeySpec(ENCRYPTION_KEY.getBytes(StandardCharsets. UTF_8), AES_ALGORITHM);Cipher cipher = Cipher.getInstance(AES_ALGORITHM);cipher.init(Cipher.ENCRYPT_MODE, keySpec);byte[] ciphertext =cipher.doFinal(plaintext.getBytes(StandardCharsets.UTF_8));return Base64.getEncoder().encodeToString(ciphertext);}public static String decrypt(String ciphertext) throws Exception {SecretKeySpec keySpec = newSecretKeySpec(ENCRYPTION_KEY.getBytes(StandardCharsets. UTF_8), AES_ALGORITHM);Cipher cipher = Cipher.getInstance(AES_ALGORITHM);cipher.init(Cipher.DECRYPT_MODE, keySpec);byte[] plaintext =cipher.doFinal(Base64.getDecoder().decode(ciphertext));return new String(plaintext, StandardCharsets.UTF_8);}public static void main(String[] args) throws Exception {String plaintext = "Hello, world!";String ciphertext = encrypt(plaintext);System.out.println("Encrypted: " + ciphertext);String decryptedText = decrypt(ciphertext);System.out.println("Decrypted: " + decryptedText);}}```2. 非对称加密算法：非对称加密算法使用一对密钥，分别为公钥和私钥，其中公钥用于加密，私钥用于解密。
RC4实验指导书
实验3：RC4加密解算法实现一、实验目的1、理解RC4加密算法；2、设计RC4加密算法程序。
二、实验内容编程实现RC4加/解密算法。
三、实验原理及步骤1．RC4加/解密算法（1）密钥的产生（2）加密（3）解密四、测试用例例选明文Chinli 密码为123456五、实验要求及说明1、一人一组，独立完成程序设计及调试；2、实验报告须附录测试用例源代码。
RC4函数（加密/解密）其实，RC4只有加密，将密文再加密一次，就是解密了。
GetKey函数随机字符串产生器，为了方便，大多数加密算法都有一个随机密码产生器，这里也就附带一个了。
ByteToHex函数把字节码转为十六进制码，一个字节两个十六进制。
研究发现，十六进制字符串非常适合在HTTP中传输，Base64中的某些字符会造成转义，挺麻烦的。
HexToByte函数把十六进制字符串，转为字节码。
服务器也按照十六进制字符串的形式把数据传回来，这里就可以解码啦。
同时，使用十六进制字符串传输，避开了传输过程中多国语言的问题。
Encrypt函数把字符串经RC4加密后，再把密文转为十六进制字符串返回，可直接用于传输。
Decrypt函数直接密码十六进制字符串密文，再解密，返回字符串明文。
源码如下：Encrypt.h文件：#ifndef _ENCRYPT_RC4_#define _ENCRYPT_RC4_#include <string.h>#define BOX_LEN 256int GetKey(const unsigned char* pass, int pass_len, unsigned char *out);int RC4(const unsigned char* data, int data_len, const unsigned char* key, int key_len, unsigned char* out, int* out_len);static void swap_byte(unsigned char* a, unsigned char* b);char* Encrypt(const char* szSource, const char* szPassWord); // 加密，返回加密结果char* Decrypt(const char* szSource, const char* szPassWord); // 解密，返回解密结果char* ByteToHex(const unsigned char* vByte, const int vLen); // 把字节码pbBuffer转为十六进制字符串，方便传输unsigned char* HexToByte(const char* szHex); // 把十六进制字符串转为字节码pbBuffer，解码#endif // #ifndef _ENCRYPT_RC4_Encrypt.cpp文件：#include "Encrypt.h"char* Encrypt(const char* szSource, const char* szPassWord) // 加密，返回加密结果{if(szSource == NULL || szPassWord == NULL) return NULL;unsigned char* ret = new unsigned char[strlen(szSource)];int ret_len = 0;if(RC4((unsigned char*)szSource,strlen(szSource),(unsigned char*)szPassWord,strlen(szPassWord),ret,&ret_len) == NULL)return NULL;char* ret2 = ByteToHex(ret, ret_len);delete[] ret;return ret2;}char* Decrypt(const char* szSource, const char* szPassWord) // 解密，返回解密结果{if(szSource == NULL || (strlen(szSource)%2 != 0) || szPassWord == NULL)return NULL;unsigned char* src = HexToByte(szSource);unsigned char* ret = new unsigned char[strlen(szSource) / 2 + 1];int ret_len = 0;memset(ret, strlen(szSource) / 2 + 1,0);if(RC4(src, strlen(szSource) / 2, (unsigned char*)szPassWord, strlen(szPassWord), ret, &ret_len) == NULL)return NULL;ret[ret_len] = '\0';return (char*)ret;}int RC4(const unsigned char* data, int data_len, const unsigned char* key, int key_len, unsigned char* out, int* out_len){if (data == NULL || key == NULL || out == NULL)return NULL;unsigned char* mBox = new unsigned char[BOX_LEN];if(GetKey(key, key_len, mBox) == NULL)return NULL;int i=0;int x=0;int y=0;for(int k = 0; k < data_len; k++){x = (x + 1) % BOX_LEN;y = (mBox[x] + y) % BOX_LEN;swap_byte(&mBox[x], &mBox[y]);out[k] = data[k] ^ mBox[(mBox[x] + mBox[y]) % BOX_LEN];}*out_len = data_len;delete[] mBox;return -1;}int GetKey(const unsigned char* pass, int pass_len, unsigned char* out) {if(pass == NULL || out == NULL)return NULL;int i;for(i = 0; i < BOX_LEN; i++)out[i] = i;int j = 0;for(i = 0; i < BOX_LEN; i++){j = (pass[i % pass_len] + out[i] + j) % BOX_LEN;swap_byte(&out[i], &out[j]);}return -1;}static void swap_byte(unsigned char* a, unsigned char* b){unsigned char swapByte;swapByte = *a;*a = *b;*b = swapByte;}// 把字节码转为十六进制码，一个字节两个十六进制，内部为字符串分配空间char* ByteToHex(const unsigned char* vByte, const int vLen){if(!vByte)return NULL;char* tmp = new char[vLen * 2 + 1]; // 一个字节两个十六进制码，最后要多一个'\0'int tmp2;for (int i=0;i<vLen;i++){tmp2 = (int)(vByte[i])/16;tmp[i*2] = (char)(tmp2+((tmp2>9)?'A'-10:'0'));tmp2 = (int)(vByte[i])%16;tmp[i*2+1] = (char)(tmp2+((tmp2>9)?'A'-10:'0'));}tmp[vLen * 2] = '\0';return tmp;}// 把十六进制字符串，转为字节码，每两个十六进制字符作为一个字节unsigned char* HexToByte(const char* szHex){if(!szHex)return NULL;int iLen = strlen(szHex);if (iLen<=0 || 0!=iLen%2)return NULL;unsigned char* pbBuf = new unsigned char[iLen/2]; // 数据缓冲区int tmp1, tmp2;for (int i=0;i<iLen/2;i++){tmp1 = (int)szHex[i*2] - (((int)szHex[i*2]>='A')?'A'-10:'0');if(tmp1>=16)return NULL;tmp2 = (int)szHex[i*2+1] - (((int)szHex[i*2+1]>='A')?'A'-10:'0');if(tmp2>=16)return NULL;pbBuf[i] = (tmp1*16+tmp2); }return pbBuf;}main.cpp文件#include <iostream>#include <string>#include <stdio.h>#include "Encrypt.h"int main(int argc,char *argv[]) {int size = 0;char source[] = "chenli";char pass[] = "123456";char *result1 = NULL;char *result2 = NULL;result1 = Encrypt(source, pass);printf("result1=%s\n", result1);result2 = Decrypt(result1, pass);printf("result2=%s\n", result2);delete []result1;delete []result2;return 0;}。
RC4 objective-c和C#加解密结合
NSNumber *temp = [iS objectAtIndex:i];
[iS replaceObjectAtIndex:i withObject:[iS objectAtIndex:j]];
for (short i = 0; i < 256; i++)
{
char c = EncodeKeyString.ToCharArray()[i % EncodeKeyString.Length];
charArray[i] = c;
}
int_j = 0;
for (int i = 0; i < 255; i++)
{
int _int_a = intArray[i];
char _char_a = charArray[i];
public static string Rc4EncryptMethod(string DataString, string EncodeKeyString)
{
int[] intArray = new int[256];
char[] charArray = new char[256];
int _int_is = intArray[int_i];
int_j = (int_j + _int_is) % 256;
int _int_is_i = intArray[int_i];
int _int_is_j = intArray[int_j];
char _char_y = (char)(_char_c ^ _int_iY);
RC4加解密算法之源代码
RC4加解密算法之源代码///////////////////////////////////////////////////////////////////////////** RC4加密算法//** ⽤法: 1.定义⼀个RC4_KEY结构,2.⽤函数RC4Init初始化状态,3.⽤RC4Works加密//使⽤说明://1.定义密钥变量RC4_KEY rc4key;//2.初始化密钥 RC4Init(255字节以内的⼝令字符串,⼝令长度,&rc4key);//3.加/解密 RC4Works(⽆符号字符型数据,数据长度,&rc4key);///////////////////////////////////////////////////////////////////////////#ifndef __RC4_H#define __RC4_H#ifdef __cplusplusextern "C" {#endiftypedef struct _RC4_KEY{BYTE bySTab[256]; //256字节的S表BYTE byIt,byJt; //t时刻的两个指针} RC4_KEY,*PRC4_KEY;BOOL RC4Init(LPSTR, int, RC4_KEY *);BOOL RC4Works (LPBYTE, int, RC4_KEY *);static BYTE xyzzy_tmpc;#define SWAP_BYTE(a,b) xyzzy_tmpc=a; a=b; b=xyzzy_tmpcBOOL RC4Init(char *pszKey, int nKeyLen, RC4_KEY *key){BYTE by1,by2;LPBYTE bySTab;int nCount;if((strlen(pszKey)<1)||(nKeyLen<1)) return FALSE;nKeyLen=(nKeyLen>256)?(256):nKeyLen; //⼝令最多只能256字节bySTab = &key->bySTab[0];for (nCount=0; nCount<256; nCount++) bySTab[nCount]=(BYTE)nCount;key->byIt=0;key->byJt=0;by1=by2=0;for (nCount=0; nCount<256; nCount++){by2 = (BYTE)(pszKey[by1] + bySTab[nCount] + by2);SWAP_BYTE(bySTab[nCount], bySTab[by2]);by1 = (BYTE)(by1+1)%nKeyLen;}return TRUE;}BOOL RC4Works(LPBYTE pbyData, int nDataLen, RC4_KEY *key){if((pbyData==NULL) ||(nDataLen<1)) return FALSE;BYTE byIt,byJt;LPBYTE bySTab;int nCount;byIt=key->byIt;byJt=key->byJt;bySTab = &key->bySTab[0];for (nCount=0; nCount<nDataLen; nCount++){byIt++;byJt += bySTab[byIt];SWAP_BYTE(bySTab[byIt], bySTab[byJt]);pbyData[nCount] ^= bySTab[(bySTab[byIt] + bySTab[byJt])&0xFF];}key->byIt=byIt;key->byJt=byJt;return TRUE;}#ifdef __cplusplus}#endif#endif。
RC4实验报告
Return(type):无
Others:无
Bug:无
********************************************************/
Function:void re_S(unsigned char *S)
Input(type)unsigned char *S,unsigned char *T
Output(type):unsigned char *S,unsigned char *T
Return(type):无
Others:无
Bug:无
********************************************************/
RC4算法密码技术实验报告
实验项目：实验三----RC4算法
实验要求
（内容）
用RC4制台对所有文件（任意类型的文件）的加解密（注意明文和密文都以文件形式存在）加解密形式：
cipher –e/-d key inputfile outputfile
说明：对于加密来说，输入文件名就是明文文件，对于解密来说，输入文件名就是密文文件
void re_Sbox(unsigned char *S,unsigned char *T)
void re_RC4(unsigned char *S,char *key)
void RC4(FILE *readfile,FILE *writefile,char *key)
int main(int argc,char *argv[])
Bug:无
********************************************************/