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從來就沒有正式發布過這個演算法。