rc4加密可以加密什么

Ⅰ rc4和rc4md5

IV及初始化向量S，

密文：密文第i字节=明文第i字节^密钥流第i字节

密钥流：根据明文和密钥生成，密钥流长度和明文长度一样

状态向量S或IV：长度256个8位，256个字节

临时向量T：长度也是256个8位，256个字节，如果密钥的长度是256字节，就直接把密钥的值赋给T，否则，轮转地将密钥的每个字节赋给T；

密钥K:密钥长度与明文长度、密钥流的长度没有必然关系，通常密钥的长度取为16字节（128比特）

1.初始化S和T：

S的值升序被置为0-255

T的值是密钥K的值的循环复制

2.S的初始置换

用T产生S的初始置换，置换伪码如下

j = 0;

for (i = 0 ; i < 256 ; i++){

j = (j + S[i] + T[i]) mod 256;

swap(S[i] , S[j]);

}

因为对S的操作仅是交换，S仍然包含所有值为0-255的元素。

3.密钥流的生成

i , j = 0;

while (true){

i = (i + 1) mod 256;

j = (j + S[i]) mod 256;

swap(S[i] , S[j]);

t = (S[i] + S[j]) mod 256;

k = S[t];

}

k即为密钥流的一个字节

WEP加密、RC4算法

RC4                                                                 

RSA实验室研发的对称加密 流 算法                                     

    实现简单                                                       

    速度快                                                         

加密: 对明文流和密钥流进行XOR计算                                   

解密: 对密文流和密钥流进行XOR计算                                   

RC4算法key由两个过程生成                                             

    合并IV和PSK，利用Key Scheling Algorithm (KSA)算法生成起始状态表

    Pseudo-Random Generation Algorithm (PRGA)算法生成最终密钥流

rc4算法中加密用的key就是key本身，一般长度16字节128位

rc4md5中加密用的key是md5（key+iv）得到结果位16字节hash值128位

Ⅱ 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算法并不像人们原先认为的那样安全。这一发现可能促使人们重新设计无线通信网络，并且使用新的加密算法。

Ⅲ 如何在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;
}
.....

Ⅳ 对称加密算法的加密算法主要有哪些

1、3DES算法

3DES（即Triple DES）是DES向AES过渡的加密算法（1999年，NIST将3-DES指定为过渡的加密标准），加密算法，其具体实现如下：设Ek()和Dk()代表DES算法的加密和解密过程，K代表DES算法使用的密钥，M代表明文，C代表密文，这样：

3DES加密过程为：C=Ek3(Dk2(Ek1(M)))

3DES解密过程为：M=Dk1(EK2(Dk3(C)))

2、Blowfish算法

BlowFish算法用来加密64Bit长度的字符串。

BlowFish算法使用两个“盒”——unsignedlongpbox[18]和unsignedlongsbox[4,256]。

BlowFish算法中，有一个核心加密函数:BF_En(后文详细介绍）。该函数输入64位信息，运算后，以64位密文的形式输出。用BlowFish算法加密信息，需要两个过程：密钥预处理和信息加密。

分别说明如下：

密钥预处理：

BlowFish算法的源密钥——pbox和sbox是固定的。我们要加密一个信息，需要自己选择一个key，用这个key对pbox和sbox进行变换，得到下一步信息加密所要用的key_pbox和key_sbox。具体的变化算法如下：

1)用sbox填充key_sbox

2)用自己选择的key8个一组地去异或pbox，用异或的结果填充key_pbox。key可以循环使用。

比如说：选的key是"abcdefghijklmn"。则异或过程为：

key_pbox[0]=pbox[0]abcdefgh；

key_pbox[1]=pbox[1]ijklmnab；

…………

…………

如此循环，直到key_pbox填充完毕。

3)用BF_En加密一个全0的64位信息，用输出的结果替换key_pbox[0]和key_pbox[1],i=0；

4)用BF_En加密替换后的key_pbox,key_pbox[i+1]，用输出替代key_pbox[i+2]和key_pbox[i+3]；

5)i+2，继续第4步，直到key_pbox全部被替换；

6)用key_pbox[16]和key_pbox[17]做首次输入（相当于上面的全0的输入），用类似的方法，替换key_sbox信息加密。

信息加密就是用函数把待加密信息x分成32位的两部分:xL,xRBF_En对输入信息进行变换。

3、RC5算法

RC5是种比较新的算法，Rivest设计了RC5的一种特殊的实现方式，因此RC5算法有一个面向字的结构：RC5-w/r/b，这里w是字长其值可以是16、32或64对于不同的字长明文和密文块的分组长度为2w位，r是加密轮数，b是密钥字节长度。

(4)rc4加密可以加密什么扩展阅读：

普遍而言，有3个独立密钥的3DES（密钥选项1）的密钥长度为168位（三个56位的DES密钥），但由于中途相遇攻击，它的有效安全性仅为112位。密钥选项2将密钥长度缩短到了112位，但该选项对特定的选择明文攻击和已知明文攻击的强度较弱，因此NIST认定它只有80位的安全性。

对密钥选项1的已知最佳攻击需要约2组已知明文，2部，2次DES加密以及2位内存（该论文提到了时间和内存的其它分配方案）。

这在现在是不现实的，因此NIST认为密钥选项1可以使用到2030年。若攻击者试图在一些可能的（而不是全部的）密钥中找到正确的，有一种在内存效率上较高的攻击方法可以用每个密钥对应的少数选择明文和约2次加密操作找到2个目标密钥中的一个。

Ⅳ 加密技术

对称加密就是指，加密和解密使用同一个密钥的加密方式。需要用到的有加密算法和加密秘钥。例如加密算法可以类似这样的加密规则(a ->b，b->w，c->a)

发送方使用密钥将明文数据加密成密文，然后发送出去，接收方收到密文后，使用同一个密钥将密文解密成明文读取。

优点：加密计算量小、速度快，效率高，适合对大量数据进行加密的场景。
缺点：（1）密钥不适合在网上传输（容易被截取），（2）密钥维护麻烦

DES 、3DES、Blowfish、IDEA、RC4、RC5、RC6和AES。

数据加密标准DES属于常规密钥密码体制，是一种分组密码。加密前，先对整个明文进行分组，每一组长为64位，然后对每一个64位二进制数据进行加密处理，产生一组64位密文数据。最后将各组密文串接起来，即得出整个的密文。使用的密钥为64位（实际密钥长度为56位，有8位用于奇偶检验）

DES的保密性取决于密钥的保密，而算法是公开的。尽管人们在破译DES方面取得了许多进展，但至今仍未能找到比穷举搜索密钥更有效的方法。DES是世界上第一个公认的实用密码算法标准，它曾对密码学的发展做出了重大贡献。目前较为严重的问题是DES的密钥长度，现在已经设计出搜索DES密钥的专用芯片。

DES算法安全性取决于密钥长度，56位密钥破解需要3.5到21分钟，128位密钥破解需要5.4 * 10^18次方年

注意的是：这里是没有密钥的情况下，直接穷举密钥尝试破解。如果密钥在传送过程中被人截取了，就相当于直接知道加密规则了，根本不需要破解，因此密钥在网络中传送还是不安全。

与对称加密算法不同，非对称加密算法需要密钥对，即两个密钥：公开密钥（公钥）和私有密钥（私钥）。

公开密钥与私有密钥是一对，如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密；如果用私有密钥对数据进行加密，那么只有用对应的公开密钥才能解密。因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。

公钥和私钥是怎么来的？
操作系统随机生成一个随机数，将这个随机数通过某个函数进行运算，分成两部分，公钥和私钥

优点：安全性高
缺点：加密与解密速度慢。

RSA、ECC（移动设备用）、Diffie-Hellman、El Gamal、DSA（数字签名用）。

答案是不能
鉴于非对称加密的机制，我们可能会有这种思路：服务器先把公钥直接明文传输给浏览器，之后浏览器向服务器传数据前都先用这个公钥加密好再传，这条数据的安全似乎可以保障了！ 因为只有服务器有相应的私钥能解开这条数据 。
然而 由服务器到浏览器的这条路怎么保障安全？ 如果服务器用它的的私钥加密数据传给浏览器，那么浏览器用公钥可以解密它，而这个公钥是一开始通过明文传输给浏览器的，这个公钥被谁劫持到的话，他也能用该公钥解密服务器传来的信息了。所以 目前似乎只能保证由浏览器向服务器传输数据时的安全性 （其实仍有漏洞，下文会说）。

1、先通过非对称加密技术，把对称加密的密钥X传给对方，使得这个对称加密的密钥X是安全的
2、后面再通过对称加密技术进行数据传输

详细流程
（1）服务器端拥有用于非对称加密的 公钥A 、 私钥A’ 。
（2）客户端向网站服务器请求，服务器先把 公钥A 明文给传输浏客户端
（3）客户端随机生成一个用于对称加密的 密钥X ，用 公钥A 加密后传给服务器端。
（4）服务器端拿到后用 私钥A’ 解密得到 密钥X 。
（5）这样双方就都拥有 密钥X 了，且别人无法知道它。之后双方所有数据都用 密钥X 加密解密。

数字签名是基于公钥密码体制（非对称密钥密码体制）的。

数字签名必须保证以下三点：

上图位用户A使用数字签名向用户B传输一份文件的过程：

什么时候使用这种不对文件加密，而对文件的摘要加密（对文件进行签名）的技术呢？

注意： 这里强调的是只有“A公钥” 上有认证机构CA的数字签名，意思是CA用它的私钥对“A公钥”的内容进行单向散列函数得到的 加密摘要（数字签名） ，该签名放在“A公钥”中（左上角那个），对于B用户来说，它从可靠的路径拿到CA的公钥，使用CA的公钥解密“A公钥”的内容得到的128位的摘要 和 “A公钥”的内容通过单向散列函数计算出来的是否一致，如果是表示认可这个“A公钥”

当用户A遗失或泄露了CA颁发的证书后，为了避免他人使用该证书冒充用户A，用户A向认证机构CA "挂失" 该证书。于是认证机构CA把该证书放入该认证机构的证书吊销列表（CRL）中，并在网上公示。

用户B在收到用户A的公钥时，除了要验证该公钥是否位认证机构颁发的，还要登录认证机构的网站查看该公钥是否已被认证机构吊销变为无效证书。

认证机构CA的作用：

1、http连接很简单，是无状态的，明文传输。https协议 = http协议 + SSL，可以进行加密传输，身份认证
2、http连接的是80端口，https连接的是443端口
3、https协议需要服务器端到CA申请SSL证书，即客户端请求的时候，服务器端发送SSL证书给客户端，SSL证书内容包括公钥、CA机构的数字签名。验证了服务器端的身份以及公钥的可靠性。 （注意：混合加密那里“将公钥A给客户端”，严格的来说是把SSL证书给客户端）

SSL提供以下三个功能
1、 SSL服务器鉴别。允许用户证实服务器的身份。 具有SSL功能的浏览器维持一个表，上面有一些可信赖的认证中心CA和它们的公钥
2、 SSL客户鉴别。允许服务器证实客户的身份。
3、 加密的SSL会话，通过混合加密实现的 。客户和服务器交互的所有数据都是发送方加密，接受方解密

SSL的位置

（1）方法：get，post，head，put，delete，option，trace，connect
（2）URL字段
（3）HTTP协议版本

User-Agent：产生请求的浏览器类型
Aceept：客户端可识别的内容类型列表
Host：主机地址

200：请求被成功处理
301：永久性重定向
302：临时性重定向
403：没有访问权限
404：没有对应资源
500：服务器错误
503：服务器停机

HTTP协议的底层使用TCP协议，所以HTTP协议的长连接和短连接在本质上是TCP层的长连接和短连接。由于TCP建立连接、维护连接、释放连接都是要消耗一定的资源，浪费一定的时间。所对于服务器来说，频繁的请求释放连接会浪费大量的时间，长时间维护太多的连接的话又需要消耗资源。所以长连接和短连接并不存在优劣之分，只是适用的场合不同而已。长连接和短连接分别有如下优点和缺点：

注意： 从HTTP/1.1版本起，默认使用长连接用以保持连接特性。 使用长连接的HTTP协议，会在响应消息报文段加入: Connection: keep-alive。TCP中也有keep alive，但是TCP中的keep alive只是探测TCP连接是否活着，而HTTP中的keep-alive是让一个TCP连接获得更久一点。

Ⅵ wifi 的几种加密方式

一种数据加密算法，用于提供等同于有线局域网的保护能力。它的安全技术源自于名为RC4的RSA数据加密技术，是无线局域网WLAN的必要的安全防护层。目前常见的是64位WEP加密和128位WEP加密。WPA(WiFiProtectedAccess
，WiFi网络安全存取)。WPA协议是一种保护无线网络(WiFi)安全的系统，它是在前一代有线等效加密(WEP)的基础上产生的，解决了前任WEP的缺陷问题，它使用TKIP(临时密钥完整性)协议，是IEEE
802.11i标准中的过渡方案
。其中WPA-PSK主要面向个人用户。
WPA2，即WPA加密的升级版。它是WiFi联盟验证过的IEEE 802.11i标准的认证形式，WPA2实现了802.11i的强制性元素，特别是Michael算法被公认彻底安全的CCMP(计数器模式密码块链消息完整码协议)讯息认证码所取代、而RC4加密算法也被AES(高级加密)所取代。
WPA-PSK+WPA2-PSK。从字面便可以看出，很明显，最后一种是两种加密算法的组合，可以说是强强联手。WPA-PSK 也叫做 WPA-Personal(WPA个人)。WPA-PSK使用TKIP加密方法把无线设备和接入点联系起来.WPA2-PSK使用AES加密方法把无线设备和接入点联系起来。
1、聊胜于无的WEP
WEP作为一种老式的加密手段，它的特点是使用一个静态的密钥来加密所有的通信
，这就意味着，网管人员如果想更新密钥，必须亲自访问每台主机，并且其所采用的RC4的RSA数据加密技术具有可预测性，对于入侵者来说很容易截取和破解加密密钥，使用户的安全防护形同虚设，因此如非迫不得已，不建议选择此种安全模式。
2、升级后的WPA
继WEP之后，人们将期望转向了其升级后的WPA，与之前WEP的静态密钥不同，WPA需要不断的转换密钥。WPA采用有效的密钥分发机制，可以跨越不同厂商的无线网卡实现应用。它作为WEP的升级版，在安全的防护上比WEP更为周密，主要体现在身份认证、加密机制和数据包检查等方面，而且它还提升了无线网络的管理能力。
3、追求，永无止境：WPA2
WPA2是WiFi联盟验证过的IEEE 802.11i标准的认证形式，WPA2实现了802.11i的强制性元素，特别是Michael算法被公认彻底安全的CCMP(计数器模式密码块链消息完整码协议)讯息认证码所取代、而RC4加密算法也被AES所取代。
目前WPA2加密方式的安全防护能力非常出色，只要用户的无线网络设备均能够支持WPA2加密，那么恭喜你，你的无线网络处于一个非常安全的境地。

Ⅶ 可以给我一个用RC4加密明文的例子吗 谢谢啊

运行环境：Microsoft Visual Studio 6.0
语言：C++

#include<stdio.h>
#include<string>
void decrypt(char cipher[]);///////////////////////////////解密过程函数,根据输入密钥再一次生成密钥流
void main()
{
printf("**************************RC4加解密程**************************\n");
char choose1,choose2;
do{
int s[256],t[256];
char k[256];/////////////////用户输入的密钥
char plaintext[1024],ciphertext[1024];
printf("输入密钥:\n");
gets(k);
for(int i=0;i<256;i++)//////////////给字节状态矢量和可变长的密钥数组赋值
{
s[i]=i;
t[i]=k[i%strlen(k)];
}
int j=0;
for(i=0;i<256;i++) //////使用可变长的密钥数组初始化字节状态矢量数组s
{
int temp;
j=(j+s[i]+t[i])%256;
temp=s[i];
s[i]=s[j];
s[j]=temp;
}
printf("\n输入要加密的字符串:\n");
gets(plaintext);
int m,n,key[256],q;
m=n=0;
printf("\n得到密文：\n");
for(i=0;i<strlen(plaintext);i++)/////////////由字节状态矢量数组变换生成密钥流并对明文字符进行加密
{
int temp;

m=(m+1)% 256;
n=(n+s[n])% 256;
temp=s[m];
s[m]=s[n];
s[n]=temp;
q=(s[m]+s[n])%256;
key[i]=s[q];
ciphertext[i]=plaintext[i]^key[i];
printf("%c",ciphertext[i]);
}
ciphertext[i]='\0';
//解密
printf("\n是否对上面的密文进行解密？(y/n)\n");
scanf("%c",&choose2);
getchar();
while(choose2=='y'||choose2=='Y')
{
decrypt(ciphertext);///////////////////////////////解密过程函数
choose2='n';
}
printf("\n是否希望继续使用程序？(y/n)\n");
scanf("%c",&choose1);
getchar();
}
while(choose1=='y'||choose1=='Y');
printf("\n****************************程序结束*****************************");
system("pause");
}
//解密函数，密钥流的生成与加密相同
void decrypt(char cipher[])
{
int s[256],t[256];
int i;
char k[256];/////////////////用户输入的密钥
char plaintext[1024];
printf("\n输入密钥:\n");
gets(k);
for(i=0;i<256;i++)//////////////给字节状态矢量和可变长的密钥数组赋值
{

s[i]=i;
t[i]=k[i%strlen(k)];
}
int j=0;
for(i=0;i<256;i++) //////使用可变长的密钥数组初始化字节状态矢量数组s
{
int temp;
j=(j+s[i]+t[i])%256;
temp=s[i];
s[i]=s[j];
s[j]=temp;
}
int m,n,key[256],q;
m=n=0;
printf("\n解密后所得到明文是：\n");
for(i=0;i<strlen(cipher);i++)/////////////由字节状态矢量数组变换生成密钥流并对密文字符进行解密
{
int temp;
m=(m+1)% 256;
n=(n+s[n])% 256;
temp=s[m];
s[m]=s[n];
s[n]=temp;
q=(s[m]+s[n])%256;
key[i]=s[q];
plaintext[i]=cipher[i]^key[i];
printf("%c",plaintext[i]);
}
printf("\n");
}

Ⅷ RC4的介绍

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