rc4加密算法c

Ⅰ rc4算法该怎样写一个完整的程序代码用的是c/c++都行。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef unsigned long ULONG;
void rc4_init(unsigned char *s, unsigned char *data,unsigned Len) { //初始化函数
int i,j;
unsigned char k[256] = {0},tmp;
for(i = 0;i < 256;i++) {
s[i] = i;
k[i] = data[i%Len];
}
for(i = 0; i < 256; i++) {
j = (j + s[i] + k[i])%Len;
tmp = s[i];
s[i] = s[j]; //交换s[i]和s[j]
s[j] = tmp;
}
}

void rc4_crypt(unsigned char *s, unsigned char *Data, unsigned long Len) { //加解密
int i = 0, j = 0, t = 0;
unsigned long k = 0;
unsigned char tmp;
for(k = 0;k < Len;k++) {
i = (i + 1)%256;
j = (j + s[i])%256;
tmp = s[i];
s[i] = s[j]; //交换s[x]和s[y]
s[j] = tmp;
t = (s[i] + s[j])%256;
Data[k] ^= s[t];
}
}

int main() {
unsigned char s[256] = {0},st[256] = {0}; //S-box
char key[256] = "just for test";
char pData[512] = "待加密数据Data";
ULONG len = strlen(pData);
printf("pData = %s\n",pData);
printf("key = %s, length = %d\n\n",key,strlen(key));
rc4_init(s,(unsigned char *)key,strlen(key)); //初始化
printf("完成对S[i]的初始化，如下：\n\n");
for(int i = 0; i < 256; i++) {
printf("%-3d ",s[i]);
}
printf("\n\n");
for(i = 0; i < 256;i++) { //用st[i]暂时保留经过初始化的s[i]，很重要的！！！
st[i] = s[i];
}
printf("已经初始化，现在加密:\n\n");
rc4_crypt(s,(unsigned char *)pData,len);//加密
printf("pData = %s\n\n",pData);
printf("已经加密，现在解密:\n\n");
rc4_init(s,(unsigned char *)key,strlen(key)); //初始化密钥
rc4_crypt(st,(unsigned char *)pData,len);//解密
printf("pData = %s\n\n",pData);
return 0;
}

Ⅱ RC4的原理

RC4算法的原理很简单，包括初始化算法（KSA）和伪随机子密码生成算法（PRGA)两大部分。假设S-box的长度为256，密钥长度为Len。先来看看算法的初始化部分（用C代码表示）：
其中，参数1是一个256长度的char型数组，定义为: unsigned char sBox[256];
参数2是密钥，其内容可以随便定义：char key[256];
参数3是密钥的长度，Len = strlen(key); /*初始化函数*/voidrc4_init(unsignedchar*s,unsignedchar*key,unsignedlongLen){inti=0,j=0;chark[256]={0};unsignedchartmp=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运算，得到密文，解密过程也完全相同。
再来看看算法的加密部分（用C代码表示）：
其中，参数1是上边rc4_init函数中，被搅乱的S-box;
参数2是需要加密的数据data;
参数3是data的长度. /*加解密*/voidrc4_crypt(unsignedchar*s,unsignedchar*Data,unsignedlongLen){inti=0,j=0,t=0;unsignedlongk=0;unsignedchartmp;for(k=0;k<Len;k++){i=(i+1)%256;j=(j+s[i])%256;tmp=s[i];s[i]=s[j];//交换s[x]和s[y]s[j]=tmp;t=(s[i]+s[j])%256;Data[k]^=s[t];}}最后，在main函数中，调用顺序如下： intmain(){unsignedchars[256]={0},s2[256]={0};//S-boxcharkey[256]={justfortest};charpData[512]=这是一个用来加密的数据Data;unsignedlonglen=strlen(pData);inti;printf(pData=%s ,pData);printf(key=%s,length=%d ,key,strlen(key));rc4_init(s,(unsignedchar*)key,strlen(key));//已经完成了初始化printf(完成对S[i]的初始化，如下： );for(i=0;i<256;i++){printf(%02X,s[i]);if(i&&(i+1)%16==0)putchar(' ');}printf( );for(i=0;i<256;i++)//用s2[i]暂时保留经过初始化的s[i]，很重要的！！！{s2[i]=s[i];}printf(已经初始化，现在加密: );rc4_crypt(s,(unsignedchar*)pData,len);//加密printf(pData=%s ,pData);printf(已经加密，现在解密: );//rc4_init(s,(unsignedchar*)key,strlen(key));//初始化密钥rc4_crypt(s2,(unsignedchar*)pData,len);//解密printf(pData=%s ,pData);return0;}因此最终的完整程序是： //程序开始#include<stdio.h>#include<string.h>typedefunsignedlongULONG;/*初始化函数*/voidrc4_init(unsignedchar*s,unsignedchar*key,unsignedlongLen){inti=0,j=0;chark[256]={0};unsignedchartmp=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;}}/*加解密*/voidrc4_crypt(unsignedchar*s,unsignedchar*Data,unsignedlongLen){inti=0,j=0,t=0;unsignedlongk=0;unsignedchartmp;for(k=0;k<Len;k++){i=(i+1)%256;j=(j+s[i])%256;tmp=s[i];s[i]=s[j];//交换s[x]和s[y]s[j]=tmp;t=(s[i]+s[j])%256;Data[k]^=s[t];}}intmain(){unsignedchars[256]={0},s2[256]={0};//S-boxcharkey[256]={justfortest};charpData[512]=这是一个用来加密的数据Data;unsignedlonglen=strlen(pData);inti;printf(pData=%s ,pData);printf(key=%s,length=%d ,key,strlen(key));rc4_init(s,(unsignedchar*)key,strlen(key));//已经完成了初始化printf(完成对S[i]的初始化，如下： );for(i=0;i<256;i++){printf(%02X,s[i]);if(i&&(i+1)%16==0)putchar(' ');}printf( );for(i=0;i<256;i++)//用s2[i]暂时保留经过初始化的s[i]，很重要的！！！{s2[i]=s[i];}printf(已经初始化，现在加密: );rc4_crypt(s,(unsignedchar*)pData,len);//加密printf(pData=%s ,pData);printf(已经加密，现在解密: );//rc4_init(s,(unsignedchar*)key,strlen(key));//初始化密钥rc4_crypt(s2,(unsignedchar*)pData,len);//解密printf(pData=%s ,pData);return0;}//程序完

Ⅲ RC4算法的详细介绍

RC4加密算法
之所以称其为簇，是由于其核心部分的S-box长度可为任意，但一般为256字节。该算法的速度可以达到DES加密的10倍左右。
RC4算法的原理很简单，包括初始化算法和伪随机子密码生成算法两大部分。假设S-box长度和密钥长度均为n。先来看看算法的初始化部分（用类C伪代码表示）：
for (i=0; i<n; i++){
s[i]=i;
}
j=0;
for (i=0; i<n; i++)
{
j=(j+s[i]+k[i])%n;
swap(s[i], s[j]);
}
在初始化的过程中，密钥的主要功能是将S-box搅乱，i确保S-box的每个元素都得到处理，j保证S-box的搅乱是随机的。而不同的S-box在经过伪随机子密码生成算法的处理后可以得到不同的子密钥序列，并且，该序列是随机的：
i=j=0;
while (明文未结束)
{
++i%=n;
j=(j+s)%n;
swap(s, s[j]);
sub_k=s((s+s[j])%n);
}
得到的子密码sub_k用以和明文进行xor运算，得到密文，解密过程也完全相同。
由于RC4算法加密是采用的xor，所以，一旦子密钥序列出现了重复，密文就有可能被破解。关于如何破解xor加密，请参看Bruce Schneier的Applied Cryptography一书的1.4节Simple XOR，在此我就不细说了。那么，RC4算法生成的子密钥序列是否会出现重复呢？经过我的测试，存在部分弱密钥，使得子密钥序列在不到100万字节内就发生了完全的重复，如果是部分重复，则可能在不到10万字节内就能发生重复，因此，推荐在使用RC4算法时，必须对加密密钥进行测试，判断其是否为弱密钥。
但在2001年就有以色列科学家指出RC4加密算法存在着漏洞，这可能对无线通信网络的安全构成威胁。
以色列魏茨曼研究所和美国思科公司的研究者发现，在使用“有线等效保密规则”（WEP）的无线网络中，在特定情况下，人们可以逆转RC4算法的加密过程，获取密钥，从而将已加密的信息解密。实现这一过程并不复杂，只需要使用一台个人电脑对加密的数据进行分析，经过几个小时的时间就可以破译出信息的全部内容。
专家说，这并不表示所有使用RC4算法的软件都容易泄密，但它意味着RC4算法并不像人们原先认为的那样安全。这一发现可能促使人们重新设计无线通信网络，并且使用新的加密算法。

Ⅳ 求RC4算法的原理，最好用通俗的语言讲解，能打下比方更好了（本人能看懂一点VB跟C）

RC4经典加密算法VB版本代码

VB版rc4算法

Public Sub main()
Dim key As String
For i = 1 To 16
Randomize
key = key & Chr(Rnd * 255)
Next i
MsgBox RC4(RC4("Welcome To Plindge Studio!", key), key)
End Sub
Public Function RC4(inp As String, key As String) As String
Dim S(0 To 255) As Byte, K(0 To 255) As Byte, i As Long
Dim j As Long, temp As Byte, Y As Byte, t As Long, x As Long
Dim Outp As String

For i = 0 To 255
S(i) = i
Next

j = 1
For i = 0 To 255
If j > Len(key) Then j = 1
K(i) = Asc(Mid(key, j, 1))
j = j + 1
Next i

j = 0
For i = 0 To 255
j = (j + S(i) + K(i)) Mod 256
temp = S(i)
S(i) = S(j)
S(j) = temp
Next i

i = 0
j = 0
For x = 1 To Len(inp)
i = (i + 1) Mod 256
j = (j + S(i)) Mod 256
temp = S(i)
S(i) = S(j)
S(j) = temp
t = (S(i) + (S(j) Mod 256)) Mod 256
Y = S(t)

Outp = Outp & Chr(Asc(Mid(inp, x, 1)) Xor Y)
Next
RC4 = Outp
End Function

Ⅳ 如何在voip中使用rc4对udp收发函数进行加密

qutecom 一个开源的voip客户端
asterisk 开源的ippbx
rc4加密算法简单，快速，据说是比DES算法快10倍。sip 信令本身就属于明文方式传输的，之所以要加密，是为了防止运营商的干扰，使用一个弱的加密算法，是要能防止串改就满足要求了。
rc4 算法可以google原来，用密钥来生成一个256长度的box， 然后box与明文异或操作得到密文，密文再次异或就恢复明文。
下面实现了 qutecom 到asterisk 信令的当向加密，反向的目前还没弄完，等完工了在来补充。

rc4.h
/*
*RC4 functions for HTMLDOC.
*
* Original code by Rob Earhart
* Copyright 1999 by Carnegie Mellon University, All Rights Reserved
*
* Permission to use, , modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above right notice appear in all copies and that
* both that right notice and this permission notice appear in
* supporting documentation, and that the name of Carnegie Mellon
* University not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission.
*
* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE FOR
* ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/

#ifndef _RC4_H_
# define _RC4_H_

# ifdef __cplusplus
extern "C" {
# endif /* __cplusplus */

/*
* RC4 context...
*/

typedef struct
{
unsigned char sbox[256]; /* S boxes for encryption */
int i, j; /* Current indices into S boxes */
} rc4_context_t;

/*
* Prototypes...
*/

extern void rc4_init(rc4_context_t *context, const unsigned char *key,
unsigned keylen);
extern void rc4_encrypt(rc4_context_t *context, const unsigned char *input,
unsigned char *output, unsigned len);

# ifdef __cplusplus
}
# endif /* __cplusplus */

#endif /* !_RC4_H_ */

rc4.c
/*
* RC4 functions for HTMLDOC.
*
* Original code by Tim Martin
* Copyright 1999 by Carnegie Mellon University, All Rights Reserved
*
* Permission to use, , modify, and distribute this software and its
* documentation for any purpose and without fee is hereby granted,
* provided that the above right notice appear in all copies and that
* both that right notice and this permission notice appear in
* supporting documentation, and that the name of Carnegie Mellon
* University not be used in advertising or publicity pertaining to
* distribution of the software without specific, written prior
* permission.
*
* CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
* THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
* FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE FOR
* ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
* Contents:
*
* rc4_init() - Initialize an RC4 context with the specified key.
* rc4_encrypt() - Encrypt the given buffer.
*/

#include "rc4.h"

/*
* 'rc4_init()' - Initialize an RC4 context with the specified key.
*/

void
rc4_init(rc4_context_t *text, /* IO - Context */
const unsigned char *key, /* I - Key */
unsigned keylen) /* I - Length of key */
{
int i, j; /* Looping vars */
unsigned char tmp; /* Temporary variable */

/*
* Fill in linearly s0=0, s1=1, ...
*/

for (i = 0; i < 256; i ++)
text->sbox[i] = i;

for (i = 0, j = 0; i < 256; i ++)
{
/*
* j = (j + Si + Ki) mod 256
*/

j = (j + text->sbox[i] + key[i % keylen]) & 255;

/*
* Swap Si and Sj...
*/

tmp = text->sbox[i];
text->sbox[i] = text->sbox[j];
text->sbox[j] = tmp;
}

/*
* Initialized counters to 0 and return...
*/

text->i = 0;
text->j = 0;
}

/*
* 'rc4_encrypt()' - Encrypt the given buffer.
*/

void
rc4_encrypt(rc4_context_t *text, /* I - Context */
const unsigned char *input, /* I - Input buffer */
unsigned char *output, /* O - Output buffer */
unsigned len) /* I - Size of buffers */
{
unsigned char tmp; /* Swap variable */
int i, j; /* Looping vars */
int t; /* Current S box */

/*
* Loop through the entire buffer...
*/

i = text->i;
j = text->j;

while (len > 0)
{
/*
* Get the next S box indices...
*/

i = (i + 1) & 255;
j = (j + text->sbox[i]) & 255;

/*
* Swap Si and Sj...
*/

tmp = text->sbox[i];
text->sbox[i] = text->sbox[j];
text->sbox[j] = tmp;

/*
* Get the S box index for this byte...
*/

t = (text->sbox[i] + text->sbox[j]) & 255;

/*
* Encrypt using the S box...
*/

*output++ = *input++ ^ text->sbox[t];
len --;
}

/*
* Copy current S box indices back to context...
*/

text->i = i;
text->j = j;
}

修改exosip项目中的 jcallback.c 在函数cb_udp_snd_message 中修改，加入rc4加密部分
....

if( 1 )
{
rc4_context_t context;
char * key = "*****";
unsigned char * out = NULL;
int i=0;
out = osip_malloc (length);
if (out == NULL)
return -1;
rc4_init(&context,key,16);
rc4_encrypt(&context,message,out,length);

rc4_message = osip_malloc(length+4);
if(rc4_message != NULL)
{
rc4_message[0] = 'R';
rc4_message[1] = 'C';
rc4_message[2] = '4';
rc4_message[3] = ':';
for(i=0;i<length;i++)
{
rc4_message[i+4] = out[i];
}
}
osip_free(out);
}

// Really send the packet over network
if(rc4_message == NULL)
{
i = owsip_send (account, (const void*) message, length, 0, address, OWSL_ADDRESS_SIZE);
}
else
{
i = owsip_send (account, (const void*) rc4_message, length+4, 0, address, OWSL_ADDRESS_SIZE);
osip_free(rc4_message);
}
....

在asterisk 中的chan_sip.c 修改函数 sipsock_read， 添加 接受信令rc4解密代码
.....
if(res>4 && req.data[0]=='R' && req.data[1]=='C' && req.data[2]=='4' && req.data[3]==':')
{
rc4_context_t context;
char * key = "********";
unsigned char * out = NULL;
int i=0;
out = malloc(res-4);
rc4_init(&context,key,16);
rc4_encrypt(&context,req.data+4,out,res-4);
for(i=0;i<res-4;i++)
{
req.data[i] = out[i];
}
free(out);
req.data[res-4] = '/0';
res = res-4;
req.len = res;
}
.....

Ⅵ php如何对文件进行RC4加密

不清楚。

给文件加密，我使用的是超级加密3000.

超级加密 3000采用先进的加密算法，使你的文件和文件夹加密后，真正的达到超高的加密强度，让你的加密数据无懈可击。

Ⅶ RC4的RC4加密算法

RC4加密算法是大名鼎鼎的RSA三人组中的头号人物Ronald Rivest在1987年设计的密钥长度可变的流加密算法簇。之所以称其为簇，是由于其核心部分的S-box长度可为任意，但一般为256字节。该算法的速度可以达到DES加密的10倍左右，且具有很高级别的非线性。RC4起初是用于保护商业机密的。但是在1994年9月，它的算法被发布在互联网上，也就不再有什么商业机密了。RC4也被叫做ARC4（Alleged RC4——所谓的RC4），因为RSA从来就没有正式发布过这个算法。

Ⅷ VC++ RC4,加密解密, 使用问题

#include "rc4.h"

void main()
{
char key[]="abcd";
RC4_KEY stKey;
BYTE d1[4]={0x11,0x22,0x33,0x44};

//加密
RC4Init(key,strlen(key),&stKey);
RC4Works(d1,4,&stKey);

//解密
RC4Init(key,strlen(key),&stKey);
RC4Works(d1,4,&stKey);
}

Ⅸ 用c/c++实现RC4算法（n=3）利用生成的密钥对“this is a test ”进行加/解密（按对应位作模2加运算）

头文件什么的我就不打了.........
关键部分：
string s;
getline(cin,s,'\n')
for (int q=0;q<s.length();q++)
if (s[q]>='a'&&s[q]<='z')
s[q]=(s[q]-‘a'’+2)%26+'a'

cout<<<s;//此时s就是加密后的 如果把加密后的还原 把上面的+2改成-2

Ⅹ SSL使用什么作为RC4流加密算法

SSL版本中所用到的加密算法包括：RC4、RC2、IDEA和DES，
而加密算法所用的密钥由 消息散列函数MD5产生。
RC4、RC2是由RSA定义的，其中RC2适用于块加密，RC4适用于流 加密。